[saucam]

Closes #387.

What changes

When you fork a session, switch its backend, or rewind it, the new backend has to be given the conversation so far. Until now Claude, Codex and pi got it as a text transcript in the first prompt:

• each tool's input and output cut to 2,000 characters;
• the oldest turns dropped to fit;
• the model's reasoning gone.

That happened even when the fork stayed on the same backend.

Now the conversation goes over in the backend's own form wherever the backend allows it:

Going to	Same backend (fork, rewind)	From another backend (fork, switch)
claude	Claude forks its own session at that turn: nothing converted or cut, reasoning kept	codeoid writes the conversation as a Claude session with real tool_use/tool_result blocks, and checks it with the SDK's own reader before using it
codex	Codex forks its own thread through that turn	codeoid injects the conversation into a new thread as Codex's own history items
openai, gemini, llamacpp	full history natively (unchanged)	full history natively (unchanged)
pi, gemini-cli, qwen	text transcript (unchanged)	text transcript (unchanged)

The transcript stays as the fallback. It is used for any native path that fails. On a fork or switch the session says which way it went: ↪ … continues its own conversation, ↪ … was given … as its own history, or ↪ … carried as a text transcript. session.nativeContinuation (also CODEOID_NATIVE_CONTINUATION and the Settings UI) turns this off.

Two guards on what crosses natively:

• Redacted output. If a tool_result hook redacted output, a native fork would copy the backend's unredacted log. The redaction is tracked per backing session, durably, and inherited by forks.
• Imported turns. Turns rebuilt from an imported transcript are never built into native history, so they're never replayed in the assistant's voice. A native fork from a real turn after them is still used, because it copies the backend's own record.

A native fork is skipped when the source was already near the target's window, or from a turn that ended in an error. So forking stays the way out of an overflowed session (#381).

Also fixed along the way:

• Codex lost its conversation on every daemon restart. It never saved the thread id it created, so after a restart it resumed a stale id and silently started an empty thread.
• Claude's "No conversation found" recovery started a blank session and kept only the latest prompt. It now hands the new session the conversation.
• A restart between a backend switch and the first prompt now re-seeds the new backend instead of resuming nothing.

How the spike shaped the design

The spike is in the issue; each point was verified against the real CLIs.

• Synthesized history is accepted. Claude resumes a session from any project dir, and both the Anthropic API and Codex accept history that names tools they don't have.
• Codex injection is durable. Injected Codex threads survive an app-server restart.
• The SDK's sessionStore isn't usable. A resume through it is not durable: the CLI resumes from a temp copy, and a plain resume later fails. So codeoid writes a normal Claude session file and verifies it with getSessionMessages. Once verified, Claude owns it like any other session.

Code tour

• Provider contract (providers/interface.ts):
  • AgentProvider.continueNatively(req) takes history, forkFrom?, maxChars, workdir and allowHistory?, and returns { via: "fork" | "history", backingId?, truncation? }.
  • NormalizedTurnResult.nativeRef is { backingId, ref, dir?, redacted? }.
• Canonical turns (providers/canonical.ts): assistant turns carry native (where they end in the backend's own conversation) and restored. Tool calls carry redacted. Shared helpers: fitTurnsToBudget and canonicalTurnChars.
• Claude (providers/claude/index.ts, providers/claude/native-history.ts):
  • Turn anchor: translateSDKMessage tracks the last main-chain entry uuid per turn (not subagent, not replay). It is stamped on successful results only, together with the query's cwd.
  • continueNatively:
    • Fork path: forkSession (pinned to the source's project dir), then read the fork back, then adopt it.
    • Fallback: toClaudeSessionEntries, then writeClaudeSession (0600 file, wx, 0700 dir), then getSessionMessages must read it back exactly, then adopt it.
    • Project-dir naming matches the SDK byte for byte, long paths included.
• Codex (providers/codex/index.ts, providers/codex/native-history.ts):
  • The pending native continuation is applied when the thread is created on the first turn (it takes that turn's instructions). It runs thread/fork with lastTurnId and excludeTurns, or thread/start plus thread/inject_items.
  • On failure the turn emits a custom message and falls back to the transcript.
  • Turn anchors are stamped on completed turns only. The thread id is persisted via #adoptThread.
• Session (session.ts): #seedProviderFromHistory tries #continueNatively before the context strategy. It decides forkFrom (same backend, valid ref, no redaction, fits the window) and allowHistory (no restored turns). Supporting changes:
  • #identityOnNextSend, so a native continuation still registers the ZeroID agent on its first send;
  • #nativeBackingReady, so the backend isn't treated as fresh when it already holds the conversation;
  • #redactedBackings, persisted in session meta, restored on resume and inherited by forks;
  • the #announceContinuation notice.
• Recovery: onRecoveryNeeded reseeds the new backing from the history before the prompt.
• Config: session.nativeContinuation, CODEOID_NATIVE_CONTINUATION, and a Settings manifest entry.

Verification

Tests:

• 33 new tests in native-continuation.test.ts:
  • the converters (chain integrity, tool pairing, naming, budgets);
  • turn anchors;
  • Claude continueNatively (fork, fork read-back, verify-or-remove, allowHistory, pinned dir);
  • Codex over the fake app-server (fork, inject, fallback, thread-id persistence);
  • session selection (same and cross backend, fallbacks, config off, switch freshness, rewind, identity registration, the context-fit guard, recovery reseed, redaction durability across restart and fork, restored turns).
• Typecheck and lint are clean.
• Full suite: 3284 tests: 3265 pass, 19 skipped, 0 failures. One run along the way had a timing-sensitive failure in an untouched /mcp/control test; it passed 3/3 on its own and in the next full run.
• 2 new tests in provider-claude.test.ts: backing recovery can't loop, and it re-arms after a successful turn.
• Mutation-checked: 21 guards. 20 are caught by a test. The 21st, the per-turn native.redacted check, survives because the backing-level redaction set catches the same cases, so it is defence in depth. The 21 cover:
  • the fork point being same-backend only;
  • the config switch;
  • the native backing not being marked fresh;
  • read-back verification, for both the history path and forks;
  • the turn anchor (no subagents or replays, success only);
  • the Codex transcript fallback;
  • Codex thread-id persistence;
  • tool_use/tool_result pairing;
  • identity registration;
  • the context fit;
  • the recovery reseed;
  • the redaction guards (stamping, restore-time learning);
  • restored turns;
  • the SDK's long-path naming;
  • the recovery latch: it doesn't loop, and it re-arms after a successful turn.

Run live against real Claude (Haiku) and real Codex (gpt-5.6-luna), through SessionManager.handle with the real provider registry, in a scratch store:

Scenario	Result
Claude fork at turn 1	✅ knew the secret read in turn 1, not the word said in turn 2; "continues its own conversation"
...after a simulated daemon restart	✅ resumed natively, still knew it
Claude rewind of turn 2	✅ only turn 1 remained
Claude → Codex switch	✅ Codex recalled a token Claude had read with a tool
Codex → Claude switch	✅ Claude recalled Codex's exact cat command and output
Codex fork at turn 1	✅ knew turn 1, not turn 2

The Claude fork, the restart, and Codex → Claude were re-run after the round-1 fixes and still pass. Session files the runs left in ~/.claude and ~/.codex were cleaned up.

What did not run:

• A real daemon over WebSocket, or the web/TUI clients. The live run drove SessionManager.handle, the same entry point the WebSocket server calls.
• A ZeroID-mode daemon. Identity registration is covered by a unit test with a fake identity manager.
• pi, gemini-cli and qwen. They are unchanged (transcript), covered by the existing suites.
• Very large real sessions. The fork read-back parses the whole session file on the daemon thread (the same class of cost as fix: memory keeps every byte and stops freezing the daemon #379); this is noted as a follow-up.
• Oracle: n/a. codeoid is not in enabled_repos.

Audit rounds:

• Round 1.
  • Correctness:
    • High: a native fork didn't register its agent identity.
    • Mediums: forking an overflowed session; an unverified fork; recovery losing history; a stale anchor.
    • Lows.
  • Security:
    • Medium: native fork bypassed tool_result redaction.
    • Lows: restored turns in the assistant's voice, unvalidated refs, file hygiene, error text sent to clients.
  • All fixed in 96c7350 and cf6b9d9.
• Round 2.
  • Security: "OK to merge", with one Low (the redaction flag could be lost after a partial load or compaction).
  • Correctness: "no Critical or High findings, one Medium" (the same redaction durability issue), plus Lows on the recovery seed, a recovery loop, restored-turn forks being too conservative, and unknown usage.
  • All fixed in 29f3431.
• Round 3 (combined verification): "not clean", one Medium. The round-2 recovery-loop guard was dead, because the session's reset ran before it. Lows: the redaction flag leaking into the next turn, and a meta write after destroy. All fixed in 5e0fe0c.
• Round 4 (verification): "The round is clean. I found no Critical, High or Medium issues, the three fixes are correct". Its optional Lows were folded into d0e810c, except one, which is kept as documented below.
• Final audit (whole PR, every claim checked against the code): "ready for human review once the two doc fixes (1 and 2) are in", with no code issues found. Both doc fixes and its 13 polish items are in 6921877.

Known limitation: if a recovery adopts a native backing that also can't be resumed, the session reports the error and stays failed until /rotate or a restart. It no longer loops. The suggested alternative, silently starting a blank session, would lose the conversation, so I didn't take it.

Follow-ups (not in this PR)

• Daemon-thread cost of the fork read-back. It parses the session file on the daemon thread, which matters for very large sessions (the fix: memory keeps every byte and stops freezing the daemon #379 class).
• Native continuation for pi and the Gemini CLI, if their RPCs gain a history-import or fork entry point.

🤖 Generated with Claude Code

[saucam]

pr-shepherd: CI is green on d0e810c (daemon-check, web-check, Socket Security: Project Report, Socket Security: Pull Request Alerts all SUCCESS). No auto-fixes were needed, and the branch is up to date with main. Ready for human review.