--- title: Edit a user message --- # Edit a user message ## What it is **You can't edit a sent message _in place_, but you CAN edit it and re-run from that point into a new session.** Hover any message and choose **"Edit & re-run from here"** (on your own messages) or **"Re-run from here"** (on an AI reply): Omniscio forks a brand-new session that **shows the whole conversation** up to that point (so it reads like the same chat continued), runs your edited/new message there, and leaves the original conversation untouched. This is the "fork from this point" capability — see **[rerun-from-message.md](rerun-from-message.md)** for the full page. What you still can't do is change a sent message _in the session you're in_. Once you press Send, the operator message is committed to that conversation's history (a `conversation_messages` row with `source='operator'`), the agent has already seen it, and there's no in-place edit/delete on the bubble — re-running always forks into a NEW session rather than rewriting the current one. This is by design: Claude Code's CLI uses `--resume ` to preserve multi-turn context across spawns, so the conversation history isn't just a UI concern — it's the actual context the next CLI invocation hands to Claude, and rewriting it in place would corrupt that. The native Claude Code CLI doesn't support post-hoc in-place edits either. If you'd rather stay in the SAME session than fork a new one, you have several practical paths short of an edit. They cover most of what people mean when they say "I want to edit my last message." ## Where to find it ### How to use it (workarounds) 1. **Stop Claude mid-stream and send a correction.** If the agent is still typing its reply when you notice the mistake, press **Esc** with the composer focused. This kills the current CLI process (the Esc handler in [useSessionPanel.ts](../../src/renderer/src/features/sessions/useSessionPanel.ts) calls `interruptSession` when status is `running`). The session flips to "Needs You / Stopped". Now type a corrective message — "Sorry, ignore that, I meant X" — and Send. The agent will see both your original message and your correction in context, and will usually course-correct on the next turn. 2. **Send a follow-up correction.** If Claude has already finished replying, just send another message: "I made a typo above — read 'foo' as 'bar' and continue." The agent reads the whole conversation each turn, so a clarifying message is the conventional way to fix the record. This is how Claude Code itself expects users to handle wrong inputs — it's the same pattern as sending a follow-up in a regular chat. 3. **Use `/clear` to wipe Claude's context (but NOT Omniscio's transcript).** Type `/clear` into the composer and Send. Omniscio forwards `/clear` as plain text to the CLI, which interprets it natively — Claude Code drops its internal context window and treats the next message as a fresh start. The chat transcript above the composer in Omniscio is **not** cleared (it's a separate SQLite-backed display of the full message history); only the agent's working context is reset. This is the closest thing to "I want to undo this message" if your worry is that the bad message is going to keep poisoning the agent's reasoning. After `/clear`, your next message is the only context the agent has. Slash commands like `/clear` are passed through verbatim — Omniscio does not parse them, and there is no in-app autocomplete picker; type the command yourself. See [send-a-message.md](send-a-message.md) "Slash commands" for more. 4. **Start a new session entirely.** If you want to drop the whole thread and begin fresh, click the **+** icon at the top of the Sessions panel (or press **Ctrl+T** / **N**). The original session stays in the sidebar with its full history; the new session starts with no Claude-side context at all. See [start-a-new-session.md](start-a-new-session.md). This is the heaviest option and the right one when the conversation has gone significantly off-track. 5. **Archive the bad session.** If you don't want it in your live sidebar, archive it (Ctrl+W or middle-click the row — see [archive-a-session.md](archive-a-session.md)). The history is preserved; the row just goes to the **Archived** sub-section. Send to the archived session if you ever want to pick it back up — that auto-unarchives it. What you still cannot do, just so it's explicit: there is no way to edit the text of a sent message in place, delete a single message from the transcript, or regenerate the agent's previous reply within the same session. "Rewinding" to an earlier message and continuing IS possible now — but only as a fork into a new session (**Re-run from here**, above), never by mutating the conversation you're in. What you also cannot do: drafts (text you've typed but NOT sent yet) are different. Drafts auto-save per session and you can edit them freely until you Send. The "edit" restriction only applies to messages that have crossed the Send boundary. ## How it behaves ### How it works Operator messages are written by `sessionService.sendResponse()` in [session-service.ts](../../src/main/services/session/session-service.ts) — `queries.addMessage(parsed.sessionId, 'operator', displayText, ...)` writes a `conversation_messages` row with `source='operator'`. The bubble itself is rendered by [MessageBubble.tsx](../../src/renderer/src/components/ui/MessageBubble/MessageBubble.tsx), which now offers a **"Re-run from here"** action that forks a new session (see [rerun-from-message.md](rerun-from-message.md)) — but there is still no in-place `onEdit` / `editingMessage` that rewrites the operator row in the current session. The closest thing in the IPC channel list is `TELEGRAM_EDIT_MESSAGE`, which is for editing messages you've sent into a Telegram conversation via the integration — completely separate from the Omniscio chat transcript. `/clear` is not handled in Omniscio — it's forwarded as plain text via `processManager.writeToStdin()` to the Claude CLI, which interprets the command itself. Stream-JSON mode does not give every slash command rich UI; some commands print plain output instead of opening a panel. Omniscio has no in-app autocomplete picker for slash commands. The Esc-mid-stream interrupt path goes through `IPC.SESSION_INTERRUPT` in [session-handlers.ts](../../src/main/ipc/session-handlers.ts), which calls `processManager.interrupt(sessionId)` — the CLI is killed but the session row's status flips to "Needs You / Stopped" rather than `paused` or `archived`, so the next Send auto-respawns the CLI with `--resume ` and conversation context (including the message you regret) is preserved. See [pause-or-stop-a-session.md](pause-or-stop-a-session.md) for the difference between Esc, Pause, and Archive. ## Related - [send-a-message.md](send-a-message.md) — the Send pipeline, the slash-command passthrough, the Esc / interrupt path - [pause-or-stop-a-session.md](pause-or-stop-a-session.md) — Esc as the closest thing to "stop right now" - [start-a-new-session.md](start-a-new-session.md) — when you want to abandon the thread and start clean - [archive-a-session.md](archive-a-session.md) — when you want the bad session out of your sidebar but kept for history