One artifact, four CLIs: cross-agent handoff with Delimit

Findings

1 baseline observation, 3 post-handoff shifts, 1 pattern-accumulation finding. Each finding cites the tool, the on-disk surface, and the consumer impact.

1. baseline statefinding F1
   change type: no_shared_session_state (4 CLIs, 4 stores)
   surface: Claude Code, Codex CLI, Cursor, Gemini CLI (process-local conversation buffers, no cross-tool transport)

   The four CLIs in scope do not share session state with each other. Each one keeps its conversation buffer in its own process and its own on-disk format. A Claude Code chat does not show up in Codex; a Codex chat does not show up in Cursor; nothing in the protocol asks them to. The shape of the problem follows from that: when one CLI runs out of quota, restart capacity, or context window, the other three see a cold start. Pasting the transcript across does not survive; the new CLI gets a wall of past dialogue but no structured handle on what was decided, which files were touched, or what the next step is. The reset cost is paid every time, and the cost compounds the longer the original session ran.

2. post-handoff shiftfinding F2
   change type: structured_handoff_written (delimit_session_handoff)
   surface: ~/.delimit/sessions/session_YYYYMMDD_HHMMSS.json (one JSON file per handoff, written by ai.ledger_manager.session_handoff)

   delimit_session_handoff takes a small set of structured fields (summary, items_completed, items_added, key_decisions, blockers, files_changed, venture) and writes a single JSON record to ~/.delimit/sessions/. The shape is fixed: id, timestamp, venture, summary, the five list fields, all named. The record is local-first, owned by the user, readable by any process that can open a JSON file. Crucially, the writer is the MCP server, not Claude Code. Any CLI that speaks MCP to the same Delimit server writes to and reads from the same handoff store; the artifact is not bound to the CLI that produced it. The transcript-paste pattern is replaced by an artifact pattern, which is what makes the handoff portable.

3. post-handoff shiftfinding F3
   change type: structured_handoff_read (delimit_revive)
   surface: delimit_revive in the resuming CLI (Codex, Cursor, or Gemini); reads the latest soul + recent handoffs, surfaces them as next-step context

   delimit_revive runs on the resuming side. It auto-detects the project from cwd, loads the most recent captured soul (active task, decisions, blockers), and returns it through MCP to whichever CLI invoked it. Paired with delimit_ledger_context, the resuming CLI sees: what was being worked on, which ledger items were open, which files were modified, what blockers were live, and which decisions were locked in. The next agent does not re-read the transcript and try to infer state; the state was already written down. The replayable property is the same one the merge gate ships: the artifact is content-addressed and any reader at the same id sees the same fields.

4. pattern accumulationfinding F4
   change type: kernel_application_4 (handoff as cross-CLI shared state)
   surface: delimit_session_handoff + delimit_revive + delimit_ledger_context + delimit_soul_capture (the cross-session continuity stack)

   The Delimit governance kernel is small: classify deterministically against a published schema, write a record, let any reader replay it. The merge gate on AI-written code applies that kernel to OpenAPI diffs. The TDQS linter applies it to MCP tool definitions. The cross-CLI handoff applies it to session state: a fixed schema (the seven handoff fields), a deterministic write, a per-id replayable record. The MCP protocol carries the schema across CLI boundaries the way an OpenAPI spec carries a contract across language boundaries. No CLI vendor needs to coordinate; the artifact is the coordination point. Same primitive, fourth artifact class.

5. post-handoff shiftfinding F5
   change type: allowed_tool_envelope_preserved (no state drift across CLIs)
   surface: MCP tool allowlist read on revive; gov_health checked at session start in the resuming CLI

   A handoff is not just text. The resuming CLI also sees which Delimit tools are available, which policy preset is active, and what the governance kernel reported on the way out. delimit_gov_health is part of the session-start ritual on every CLI that runs the Delimit MCP; the resuming agent reads the same kernel state the prior agent left behind. If a policy preset was tightened mid-session, the next agent inherits the tightening. If a tool was disabled by license tier, the next agent is told. The envelope of allowed actions travels with the handoff, which closes the gap where a transcript paste would silently drop the policy context.

Without Delimit vs with Delimit

What this report is not

Not a claim that Delimit changes how Claude Code, Codex, Cursor, or Gemini work internally. It does not. Each CLI keeps its own process-local conversation buffer; that does not change. What changes is the layer above: a fixed-shape session artifact, written through MCP, readable by every CLI that speaks MCP to the same Delimit server. The CLIs do not need to know about each other for the handoff to work, because the handoff is not between CLIs; it is between sessions, with the artifact as the shared state.

Not a replacement for a commit. A handoff is bounded cross-session context, not a substitute for shipping work to git. The two are complementary: a clean handoff makes it easy for the next agent to pick up at the open question; a clean commit makes the finished work portable. delimit_repo_diagnose and the merge gate cover the commit side.

Reproduce locally

The handoff shape is content-addressed at the file id. Anyone with Delimit installed can write a handoff in one CLI and read it in another:

# Install the CLI and register the MCP server
npm install -g delimit-cli
delimit setup

# In your first CLI (Claude Code, Codex, Cursor, Gemini Code Assist)
# Ask the agent to call the MCP tool when you are ready to hand off:
#   delimit_session_handoff(summary="...", items_completed=[...], files_changed=[...])
# The MCP server writes the record to ~/.delimit/sessions/.

# Inspect the record on disk
ls ~/.delimit/sessions/
cat ~/.delimit/sessions/session_*.json | head

# In the second CLI, at session start
# Ask the agent to call delimit_revive, or run delimit resume from the shell.
# delimit_revive          loads the latest handoff plus the ledger context.
# delimit_ledger_context  open items, recent decisions, policy preset.

The JSON shape on disk is fixed. The seven named fields are id, timestamp, venture, summary, items_completed, items_added, key_decisions, blockers, and files_changed. Any tool that opens the file sees the same record; the artifact is the shared state.