Re-run from here (edit a message & re-run in a new session)

What it is

Pick any message in a conversation and re-run the chat from that point in a brand-new session. You can reword one of your own messages and resend it, or — if you anchor on one of the AI's replies — write a fresh next message. Either way Omniscio forks a new session that shows the whole conversation up to the point you picked (so it reads like the same chat continued, not a blank new session), runs your message there, and drops you into the new chat. The original conversation is never changed — re-running always forks; it never edits in place or rewinds the session you started from.

This is the answer to "can I edit a message I already sent?" — you can't change a sent message in place (the agent already saw it, and the transcript is the real context the CLI resumes from), but you can edit it and re-run from there into a clean fork. The fork runs on the same engine the conversation was already on — a Codex conversation continues on Codex, a Gemini one on Gemini — and carries that session's engine, model and thinking level, so you get the same assistant with your correction applied rather than a different one.

Where to find it

How to use it

1. Hover the message you want to re-run from and open its actions:
   • On one of your messages, choose "Edit & re-run from here" (the ⋯ menu). A box opens pre-filled with that message so you can reword it.
   • On an AI reply, choose "Re-run from here" (the ⋯ menu). The box opens empty — type the next message you want to send.
2. Edit or type your message, then press Ctrl+Enter (or click "Re-run in new session").
3. Omniscio opens a new session that shows the earlier conversation (cloned into it) with your edited message in place, and runs it. You land in the new chat. A clickable "Spawned by …" note at the top links back to the original, which is left exactly as it was.

What carries over: everything in the conversation up to the message you picked — for your own message, everything before it (your edited text replaces it); for an AI reply, everything up to and including that reply (you continue after it). The new session shows that earlier conversation — a visible clone of your and the AI's turns — so it reads like the same chat, with your edited message in its place. If the history is too large for the model's memory, Omniscio keeps the most recent part that fits for the AI and shows a small note that the assistant only remembers the recent part (you still see all of it above). Attachments in the earlier turns show a light "[attachment]" marker rather than the original file (v1), and the new session continues on the same engine and model the source session was running — unless that session's model cannot run on its own engine (an old row), in which case the fork still lands on the right engine using that engine's default model.

How it behaves

Over the CLI (agents)

The same fork is available to external agents over the CLI control server: POST /session/:id/rerun-from-message with body { messageId, editedText } (:id is the SOURCE session). It spawns a paid session (on the source session's own engine), so it is approval-gated by default — it lands as a pending inbox row (202) and forks only after the user approves; toggle at Settings → CLI Control → "Re-run from a message" (requireApprovalForCliSessionRerun). Unlike the lifecycle routes there is no in-app inline carve-out — every token-bearer call is gated. Full request/response shape + the anchor rule: the omniscio-control skill's sessions surface. Never call it on your own initiative — only when the user explicitly asks (it costs money).

For agents

How it works

• The action lives on the message bubble. MessageBubble.tsx adds the item to its action menu for non-aside operator/agent rows, opening RerunFromMessageModal.tsx.
• Boundary rule (pure core). selectCarriedMessages in rerun-from-message.ts decides what's carried: an operator anchor → everything before it; an agent anchor → everything up to and including it.
• Visible clone + invisible AI context. buildClonedHistory keeps the operator + agent turns of the carried conversation, and the orchestrator hands them to createSessionWithPrompt as clonedHistory, which persistRerunVisibleClone writes as visible rows — inserted between the "Spawned by" note and your edited message so the fork reads top-to-bottom as the same chat. Separately, buildRerunInitialPrompt wraps the SAME carried conversation as an invisible <previous-conversation> prefix (trimmed with the shared transcriptCharCap, reused from context-transfer-service.ts) and appends your message; that prefix is what reaches the CLI as the first turn (initialPrompt), while displayText is just your edited message. Because the clone is display-only, the prompt the AI receives is byte-identical to a fork with no clone — the same "send context, show only the question" mechanism that powers Ask about this page, now with the context also shown.
• Fork + link back. It calls the one session-spawn chokepoint createSessionWithPrompt with parentSessionId set, which stamps the new session's origin and pins the clickable "Spawned by" note (see session-provenance.md). The source session is read, never written.
• IPC. The renderer calls the session:rerun-from-message channel; the handler resolves the source session, then runs the orchestrator. Invariants are locked in rerun-from-message-contract.md.

Related

• edit-a-user-message.md — the broader "can I change a sent message?" question (in-place edit still isn't possible; re-run-from-here is the fork-based answer)
• session-provenance.md — the "Spawned by" link back to the original
• asides.md — the other fork mechanism (a one-off side question against the same session)
• start-a-new-session.md — a fully fresh session with no carried context