tandem-cli 0.5.0__tar.gz → 0.5.2__tar.gz

{tandem_cli-0.5.0 → tandem_cli-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tandem-cli
-Version: 0.5.0
+Version: 0.5.2
 Summary: Run Claude Code, Codex CLI, and opencode in one shared coding session with live trace sync.
 Project-URL: Homepage, https://github.com/Bhavya6187/tandem
 Project-URL: Repository, https://github.com/Bhavya6187/tandem
@@ -94,6 +94,22 @@ network calls — set `rate_limits = false` under `[frame]` in
 [Configuration](https://github.com/Bhavya6187/tandem/blob/main/docs/configuration.md)
 for the status bar's other settings.
 
+**0.5.1 keeps up with the current CLIs.** claude 2.1.26x and codex 0.153
+changed their session records, and codex now holds a writer lock on every
+open thread. On those versions 0.5.0 failed `tandem doctor` and every flip
+into claude on the new metadata records, warned that codex was out of range
+at each start, and could lose a claude → codex flip to `already has an
+active writer`. All three are fixed, and codex's list-shaped tool outputs
+now reach the other side as text with their exit codes intact.
+
+**0.5.2 stops claude complaining about synced turns.** claude 2.1.261
+restores a session's model on resume from its last assistant entry, and a
+claude session that had never run a turn of its own (claude → codex →
+opencode → claude) opened with `Session model <synced> could not be
+restored … using fable instead`. Synced entries now carry claude's own
+`<synthetic>` tag until claude has run, which its resume skips; the synced
+turns still render and still reach the model.
+
 ## Why tandem?
 
 - **Keep going when a model hits its limit.** The tab bar shows each

{tandem_cli-0.5.0 → tandem_cli-0.5.2}/README.md

@@ -68,6 +68,22 @@ network calls — set `rate_limits = false` under `[frame]` in
 [Configuration](https://github.com/Bhavya6187/tandem/blob/main/docs/configuration.md)
 for the status bar's other settings.
 
+**0.5.1 keeps up with the current CLIs.** claude 2.1.26x and codex 0.153
+changed their session records, and codex now holds a writer lock on every
+open thread. On those versions 0.5.0 failed `tandem doctor` and every flip
+into claude on the new metadata records, warned that codex was out of range
+at each start, and could lose a claude → codex flip to `already has an
+active writer`. All three are fixed, and codex's list-shaped tool outputs
+now reach the other side as text with their exit codes intact.
+
+**0.5.2 stops claude complaining about synced turns.** claude 2.1.261
+restores a session's model on resume from its last assistant entry, and a
+claude session that had never run a turn of its own (claude → codex →
+opencode → claude) opened with `Session model <synced> could not be
+restored … using fable instead`. Synced entries now carry claude's own
+`<synthetic>` tag until claude has run, which its resume skips; the synced
+turns still render and still reach the model.
+
 ## Why tandem?
 
 - **Keep going when a model hits its limit.** The tab bar shows each

{tandem_cli-0.5.0 → tandem_cli-0.5.2}/docs/formats.md

@@ -6,14 +6,21 @@ database) the CLIs wrote. Versions observed:
 
 | CLI | version | session storage |
 | --- | --- | --- |
-| Claude Code (`claude`) | 2.1.220 | `~/.claude/projects/<munged-cwd>/<sessionId>.jsonl` |
-| Codex CLI (`codex`) | 0.145.0 | `~/.codex/sessions/YYYY/MM/DD/rollout-<YYYY-MM-DDThh-mm-ss>-<uuidv7>.jsonl` |
+| Claude Code (`claude`) | 2.1.261 | `~/.claude/projects/<munged-cwd>/<sessionId>.jsonl` |
+| Codex CLI (`codex`) | 0.153.4 | `~/.codex/sessions/YYYY/MM/DD/rollout-<YYYY-MM-DDThh-mm-ss>-<uuidv7>.jsonl` |
 | opencode (`opencode`) | 1.18.15 | one SQLite database, the path `opencode db path` prints (see below) |
 
 Env overrides honored: `CLAUDE_CONFIG_DIR` (claude home), `CODEX_HOME` (codex
 home), `OPENCODE_DB` (opencode database), `TANDEM_HOME` (tandem state).
 
-## Claude Code transcript (claude 2.1.220)
+Rechecked 2026-09-05 on claude 2.1.261 / codex 0.153.4 (a live paired
+session plus a four-turn claude→codex→claude→codex→claude probe): the
+conversation-bearing shapes below are unchanged; the additions are marked
+"2.1.26x" / "0.153". Codex's accepted range runs through 0.159; 0.160+
+warns until rechecked. Unknown top-level record types still fail
+validation rather than being silently declared compatible.
+
+## Claude Code transcript (claude 2.1.220, rechecked 2.1.261)
 
 - One JSONL file per session, named `<sessionId>.jsonl` (sessionId is a
   UUIDv4). Project directory name = cwd with every character outside
@@ -42,13 +49,32 @@ home), `OPENCODE_DB` (opencode database), `TANDEM_HOME` (tandem state).
     metadata (permission mode, AI-generated title, linked PR, worktree
     moves, file-backup tracking). Not conversation content; claude resumes
     transcripts containing them without complaint.
+  - 2.1.26x adds four more uuid-less metadata records: `atis-latch`
+    (`atis`, `sessionId`), `bridge-session` (`bridgeSessionId`,
+    `lastSequenceNum`, owner account/org — routine per-session identity,
+    `lastSequenceNum` constant 0), `cost-state` (accumulated cost, timing,
+    line counts, `modelUsage`) and `custom-title` (`customTitle`, set when
+    the user renames a session). Same handling as the batch above.
+  - 2.1.26x can put a `fallback` block (`{from: {model}, to: {model}}`) in
+    an assistant message when the model is switched mid-session. No prose;
+    tandem drops it like any other non-text assistant block.
 - Resume: `claude --resume <sessionId>` (from the same cwd). A new session
   can be pinned to a chosen id with `claude --session-id <uuid>`.
+  - 2.1.261 restores the session model on resume from the last assistant
+    entry whose `message.model` is a string other than `"<synthetic>"`
+    (claude's own tag on model-less stubs such as API-error messages) and
+    warns `Session model X could not be restored (not a model this version
+    of Claude Code recognizes) — using <default> instead` when that value is
+    not a model it knows. Tandem-rendered assistant entries therefore copy
+    the model claude last used in that transcript, and carry `"<synthetic>"`
+    until claude has run at all (a zero-turn claude flipped back into). The
+    `"<synced>"` placeholder tandem ≤0.5.1 wrote there drew the warning;
+    entries carrying it are still skipped when tandem derives the model.
 - Turn boundary: a `user` entry with string content starts a turn; an
   `assistant` line with `stop_reason: "end_turn"` ends it. The `Stop` hook
   (injectable per-invocation via `--settings '<json>'`) fires at turn end.
 
-## Codex rollout (codex-cli 0.145.0)
+## Codex rollout (codex-cli 0.145.0, rechecked 0.153.4)
 
 - One JSONL file per session under a date-sharded dir; the session id
   (UUIDv7) is embedded in the filename. `~/.codex/session_index.jsonl` maps
@@ -70,9 +96,15 @@ home), `OPENCODE_DB` (opencode database), `TANDEM_HOME` (tandem state).
     - `function_call` — `{name, arguments: <json string>, call_id}` (e.g.
       `exec_command`).
     - `function_call_output` — `{call_id, output}` (chunked shell output with
-      exit code header).
+      exit code header). `output` is a string, or (0.153, roughly half of
+      all outputs) a list of `{type: "input_text", text}` blocks that are
+      consecutive chunks of one output — flatten by concatenation. Same
+      for `custom_tool_call_output`.
     - `custom_tool_call` / `custom_tool_call_output` — `apply_patch` with
-      `input` = patch text (`*** Begin Patch ...`).
+      `input` = patch text (`*** Begin Patch ...`). 0.153 code mode uses the
+      same pair with `name: "exec"` and JavaScript in `input` (plus `id`,
+      `status`, `internal_chat_message_metadata_passthrough`, all inert);
+      nested tool calls live inside that outer call/output.
   - `event_msg` — the **UI-facing** stream. `payload.type`: `task_started`
     (`turn_id`), `user_message`, `agent_message` (`phase`), `token_count`,
     `patch_apply_end` (`{stdout, success, changes: {path: {type, content}}}`),
@@ -89,6 +121,11 @@ home), `OPENCODE_DB` (opencode database), `TANDEM_HOME` (tandem state).
       grepping for these literals gets back, not a rejection.
   - `turn_context` — per turn: cwd, approval_policy, sandbox_policy, model.
   - `world_state` — environment snapshot.
+  - `token_usage_record` (0.153) — per-response accounting: thread/turn/
+    response ids plus `usage`, `turn_token_usage`, `thread_token_usage`.
+    Not model history. `event_msg/token_count` still appears and remains
+    the usage meter's source — never sum the two. `event_msg/
+    thread_settings_applied` is likewise bookkeeping.
 - Resume: `codex resume <session-id>` (interactive) and
   `codex exec resume <session-id> "<prompt>"` (one-shot). Turn-complete
   notification hook: `-c 'notify=["/bin/sh","-c","..."]'` per invocation.

{tandem_cli-0.5.0 → tandem_cli-0.5.2}/docs/how-it-works.md

@@ -133,8 +133,8 @@ tandem pins what it was built against (observed formats documented in
 
 | CLI | Tested | Accepted range |
 | --- | --- | --- |
-| Claude Code | 2.1.220 | ≥ 2.0, < 3 |
-| Codex CLI | 0.145.0 | ≥ 0.140, < 0.150 |
+| Claude Code | 2.1.261 | ≥ 2.0, < 3 |
+| Codex CLI | 0.153.4 | ≥ 0.140, < 0.160 |
 | opencode | 1.18.15 | ≥ 1.18 (no ceiling) |
 
 Above a range's ceiling, tandem warns and asks you to run `tandem doctor`

{tandem_cli-0.5.0 → tandem_cli-0.5.2}/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "tandem",
   "description": "Route Claude Code subagent dispatches to cheap codex models via tandem.",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "author": {"name": "tandem"}
 }

{tandem_cli-0.5.0 → tandem_cli-0.5.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tandem-cli"
-version = "0.5.0"
+version = "0.5.2"
 description = "Run Claude Code, Codex CLI, and opencode in one shared coding session with live trace sync."
 readme = "README.md"
 license = "MIT"

{tandem_cli-0.5.0 → tandem_cli-0.5.2}/src/tandem/compat.py

@@ -2,7 +2,7 @@
 
 Both session formats are internal to their CLIs and drift between releases.
 Tandem pins the ranges it was built against; outside a range we warn and
-require `tandem doctor` before enabling sync (see cli.py).
+recommend `tandem doctor` before trusting sync (see cli.py).
 """
 
 from __future__ import annotations
@@ -23,8 +23,8 @@ class CompatRange:
 
 # Format observations in docs/formats.md correspond to these versions.
 COMPAT: dict[str, CompatRange] = {
-    "claude": CompatRange(tested="2.1.220", min_version=(2, 0), max_exclusive=(3,)),
-    "codex": CompatRange(tested="0.145.0", min_version=(0, 140), max_exclusive=(0, 150)),
+    "claude": CompatRange(tested="2.1.261", min_version=(2, 0), max_exclusive=(3,)),
+    "codex": CompatRange(tested="0.153.4", min_version=(0, 140), max_exclusive=(0, 160)),
     # Floor-only by operator decision (spec: Compat gate). Pre-1.18 opencode
     # predates SQLite session storage and genuinely cannot work.
     "opencode": CompatRange(tested="1.18.15", min_version=(1, 18)),

{tandem_cli-0.5.0 → tandem_cli-0.5.2}/src/tandem/flip.py

@@ -31,8 +31,8 @@ def run_session(tandem_id: str, sink_factory, run_harness=None) -> int:
     # The standby travels across flips here: popped for adoption by the
     # next run, refilled from the runner that just ended. Injected test
     # runners never touch it. `reapers` collects the threads tearing down
-    # standbys the gate rejected — the flip does not wait for them, this
-    # function's finally does.
+    # standbys the gate rejected for the wrong side — the flip does not
+    # wait for those, this function's finally does.
     carry: dict = {"standby": None, "reapers": []}
     if run_harness is None:
 
@@ -104,9 +104,10 @@ def _reap(standby, carry: dict) -> None:
     session's exit can join it.
 
     The kill ladder is slow by construction — quit keystrokes, then the
-    unconditional soft/term waits — so killing a stale standby inline would
-    put seconds between the user's Ctrl-] and the next harness starting,
-    on precisely the flips warmup exists to speed up. The child is
+    unconditional soft/term waits — so killing a stale standby inline puts
+    seconds between the user's Ctrl-] and the next harness starting, on
+    precisely the flips warmup exists to speed up. Only affordable when the
+    standby and the relaunch share no session (see `_switch`); the child is
     already out of the carry, so nothing can adopt it while it dies."""
     thread = threading.Thread(
         target=_kill, args=(standby,), name="tandem-warm-reap", daemon=True
@@ -226,8 +227,11 @@ def _switch(
     and the state it snapshotted are finally comparable against what the
     next run will actually launch. A stale one is killed here and nowhere
     else — the runner silently ignores an adoptee it cannot use, so a wrong
-    side that survived this gate would leak — but killed on a reaper thread,
-    since the ladder's own timeouts would otherwise be charged to the flip."""
+    side that survived this gate would leak. One warmed for the side about
+    to launch dies inline, before the relaunch: it holds that side's session
+    open, and codex refuses a second writer on a thread. One warmed for any
+    other side dies on a reaper thread, since the ladder's own timeouts
+    would otherwise be charged to the flip for nothing."""
     with StateStore() as store:
         session = store.get_session(tandem_id)
         if session is None:
@@ -264,7 +268,18 @@ def _switch(
             _flip_debug(f"standby-gate side={new_active} fresh={fresh}")
             if not fresh:
                 carry["standby"] = None
-                _reap(standby, carry)   # off-thread: the flip must not wait
+                if standby.recipe.side == new_active:
+                    # It resumed the very session the cold spawn is about
+                    # to resume, and codex (0.153+) holds a per-thread
+                    # writer lock for as long as the process lives: a
+                    # relaunch that overlaps its ladder fails with
+                    # `thread ... already has an active writer` and ends
+                    # the session. Killed inline — the ladder's seconds
+                    # are the price of a flip that lands at all.
+                    _kill(standby)
+                    _flip_debug(f"standby-reaped side={new_active} inline")
+                else:
+                    _reap(standby, carry)   # off-thread: nothing in common
     code, flip, launched = _try_enter(tandem_id, run_harness)
     if launched:
         return code, flip

{tandem_cli-0.5.0 → tandem_cli-0.5.2}/src/tandem/harness/claude_code.py

@@ -1,6 +1,7 @@
 """Claude Code adapter.
 
-Session format observed on claude 2.1.220 (docs/formats.md):
+Session format observed on claude 2.1.220, rechecked on 2.1.261
+(docs/formats.md):
 - transcript: ~/.claude/projects/<munged-cwd>/<sessionId>.jsonl
 - entries chained by uuid/parentUuid; types: user, assistant, attachment,
   queue-operation, last-prompt, summary, system
@@ -116,12 +117,28 @@ _CLAUDE_ENTRY_TYPES = {
     "user", "assistant", "attachment", "system", "summary",
     "queue-operation", "last-prompt", "progress", "file-history-snapshot",
     "mode",  # {"type":"mode","mode":"normal",...} observed on --resume runs
-    # uuid-less metadata entries claude 2.1.220 interleaves with conversation
+    # uuid-less session metadata claude interleaves with the conversation;
+    # none of it is portable content. 2.1.220 batch, then the 2.1.26x batch
+    # (session latch, remote-bridge identity, accumulated cost/timing, a
+    # user-set title).
     "permission-mode", "ai-title", "file-history-delta", "pr-link",
     "relocated", "worktree-state",
+    "atis-latch", "bridge-session", "cost-state", "custom-title",
 }
 
 
+# claude's own tag for an assistant entry no model produced (its API-error
+# stubs carry it). `claude --resume` (2.1.261) restores the session model from
+# the last assistant entry and warns "Session model X could not be restored"
+# for anything it does not recognise; "<synthetic>" is the one value that scan
+# skips, so rendered entries carry it until claude itself has run and a real
+# model can be copied instead (live-verified 2026-09-05: no warning, synced
+# turns still render and reach the model).
+SYNTHETIC_MODEL = "<synthetic>"
+# what tandem <= 0.5.1 wrote in that slot; still skipped when deriving
+LEGACY_SYNCED_MODEL = "<synced>"
+
+
 class ClaudeCodeAdapter(HarnessAdapter):
     id = "claude"
     display_name = "Claude Code"
@@ -153,6 +170,10 @@ class ClaudeCodeAdapter(HarnessAdapter):
             etype = e.get("type")
             if etype not in _CLAUDE_ENTRY_TYPES:
                 problems.append(f"line {i}: unknown entry type {etype!r}")
+                if e.get("uuid"):
+                    # still a chain participant: one unknown type must not
+                    # cascade into a dangling-parent problem per later entry
+                    seen_uuids.add(e["uuid"])
                 continue
             if etype in ("user", "assistant"):
                 convo += 1
@@ -425,7 +446,7 @@ class ClaudeCodeAdapter(HarnessAdapter):
             st["run_msg_id"] = f"msg_tandem_{entry['uuid'][:8]}"
         return {
             "role": "assistant",
-            "model": st.get("model") or "<synced>",
+            "model": st.get("model") or SYNTHETIC_MODEL,
             "id": st["run_msg_id"],
             "type": "message",
             "content": content,
@@ -478,14 +499,15 @@ class ClaudeCodeAdapter(HarnessAdapter):
 
     def derive_last_model(self, transcript: Path) -> str | None:
         """Model of the last main-thread assistant entry with a real model
-        name. Skips the "<synced>" placeholder (pre-fix tandem appends) and
-        sidechain entries (subagents may run on a different model)."""
+        name. Skips tandem's own tags (SYNTHETIC_MODEL now, the older
+        "<synced>"), claude's synthetic stubs, and sidechain entries
+        (subagents may run on a different model)."""
         model = None
         for obj in self._tail_objects(transcript):
             if obj.get("type") != "assistant" or obj.get("isSidechain"):
                 continue
             m = (obj.get("message") or {}).get("model")
-            if m and m != "<synced>":
+            if m and m not in (SYNTHETIC_MODEL, LEGACY_SYNCED_MODEL):
                 model = m
         return model
 

{tandem_cli-0.5.0 → tandem_cli-0.5.2}/src/tandem/harness/codex.py

@@ -1,6 +1,7 @@
 """Codex CLI adapter.
 
-Session format observed on codex-cli 0.145.0 (docs/formats.md):
+Session format observed on codex-cli 0.145.0, rechecked on 0.153.4
+(docs/formats.md):
 - rollout: ~/.codex/sessions/YYYY/MM/DD/rollout-<ts>-<uuidv7>.jsonl
 - each line {timestamp, type, payload}; model-facing history is the
   response_item lines, UI history is the event_msg lines
@@ -76,9 +77,25 @@ class _CodexUsageMeter(UsageMeter):
 _CODEX_LINE_TYPES = {
     "session_meta", "response_item", "event_msg", "turn_context",
     "world_state", "compacted",
+    "token_usage_record",  # 0.153.4 per-response accounting (not model history)
 }
 
 
+def output_text(output: Any) -> str:
+    """Flatten a `*_output` payload to the text the model saw. Codex writes
+    either a plain string or (0.153: about half the time) a list of
+    `{"type": "input_text", "text": ...}` blocks — consecutive chunks of one
+    output, so they concatenate without a separator."""
+    if isinstance(output, str):
+        return output
+    if isinstance(output, list):
+        return "".join(
+            b["text"] for b in output
+            if isinstance(b, dict) and isinstance(b.get("text"), str)
+        )
+    return "" if output is None else str(output)
+
+
 class CodexAdapter(HarnessAdapter):
     id = "codex"
     display_name = "Codex CLI"
@@ -298,13 +315,11 @@ class CodexAdapter(HarnessAdapter):
                 call_id = payload.get("call_id")
                 pending = ctx.pending_calls.get(call_id or "", {})
                 structured = pending.pop("_structured", None) if pending else None
-                output = payload.get("output", "")
-                if not isinstance(output, str):
-                    output = str(output)
                 return [
                     ToolResult(
                         source="codex", timestamp=ts, turn_index=ctx.turn_index,
-                        call_id=call_id, output=output, structured=structured,
+                        call_id=call_id, output=output_text(payload.get("output")),
+                        structured=structured,
                     )
                 ]
             return [sysev(f"response_item:{ptype}")]

{tandem_cli-0.5.0 → tandem_cli-0.5.2}/src/tandem/ops.py

@@ -24,6 +24,7 @@ from pathlib import Path
 
 from . import paths
 from .harness import get_adapter
+from .harness.codex import output_text
 from .runner import TailLoop, await_codex_rollout
 from .state import PairedSession, StateStore
 from .sync import SyncEngine, SyncSetupError
@@ -492,18 +493,6 @@ _PATCH_TARGET_RE = re.compile(
     r"""\*\*\* (?:Add|Update|Delete) File: (.+?)(?=\\n|[\n"']|$)""")
 
 
-def _output_text(output) -> str:
-    """Flatten a custom_tool_call_output payload: codex writes either a plain
-    string or a list of {"type": "input_text", "text": …} blocks."""
-    if isinstance(output, str):
-        return output
-    if isinstance(output, list):
-        return "\n".join(
-            b["text"] for b in output
-            if isinstance(b, dict) and isinstance(b.get("text"), str))
-    return ""
-
-
 def blocked_write_paths(sub_path: Path, *, since: int = 0) -> list[str]:
     """Paths whose apply_patch the sandbox rejected during this run, in event
     order. Anything unreadable or unexpected yields [] — detection is
@@ -565,7 +554,7 @@ def blocked_write_paths(sub_path: Path, *, since: int = 0) -> list[str]:
                 continue
             # ... and one grep for both literals passes that gate on its own,
             # so the marker must also sit where codex puts it: line-anchored.
-            if not _PATCH_REJECTED_RE.search(_output_text(p.get("output"))):
+            if not _PATCH_REJECTED_RE.search(output_text(p.get("output"))):
                 continue
             add(_PATCH_TARGET_RE.findall(src))
     return rejected

tandem_cli-0.5.2/tests/test_current_formats.py

@@ -0,0 +1,189 @@
+"""Shapes observed with Claude 2.1.261 / Codex 0.153.4 (September 2026)."""
+
+import pytest
+
+from conftest import claude_assistant, claude_user, write_line
+from tandem.cli import _resolve_participants
+from tandem.converter import ReferenceConverter
+from tandem.doctor import validate_transcript
+from tandem.events import SessionContext
+from tandem.harness import ADAPTERS
+from tandem.ops import drain_source, switch_session
+from tandem.util import read_jsonl
+
+# uuid-less session metadata claude 2.1.26x interleaves with the conversation
+_CLAUDE_METADATA = [
+    {"type": "atis-latch", "atis": ""},
+    {"type": "bridge-session", "bridgeSessionId": "cse_probe",
+     "lastSequenceNum": 0, "ownerAccountUuid": "account",
+     "ownerOrganizationUuid": "organization"},
+    {"type": "cost-state", "totalCostUSD": 0.01, "totalAPIDuration": 100,
+     "totalAPIDurationWithoutRetries": 100, "totalToolDuration": 0,
+     "totalLinesAdded": 0, "totalLinesRemoved": 0, "totalDuration": 150,
+     "startTime": 1788624000000, "modelUsage": {}, "hasUnknownModelCost": False},
+    {"type": "custom-title", "customTitle": "Renamed by the user"},
+]
+
+
+@pytest.mark.parametrize("record", _CLAUDE_METADATA, ids=lambda r: r["type"])
+def test_claude_session_metadata_is_valid_and_not_conversation(env_factory, record):
+    env = env_factory()
+    sid = env.session.native_id("claude")
+    record = dict(record, sessionId=sid)  # never mutate the parametrize table
+    write_line(env.claude_shadow, record)
+    assert validate_transcript("claude", env.claude_shadow, sid) == []
+    ctx = SessionContext(tandem_id="probe", cwd=env.cwd, direction="claude->codex")
+    assert ReferenceConverter().translate_entry(record, ctx.direction, ctx) == []
+    assert ctx.turn_index == 0
+
+
+def test_claude_model_fallback_block_is_dropped_not_text(env_factory):
+    """2.1.26x records a mid-session model switch as an assistant content
+    block; it carries no prose, so it must translate to nothing rather than
+    to an assistant message or a translation failure."""
+    env = env_factory()
+    entry = claude_assistant(
+        [{"type": "fallback", "from": {"model": "claude-fable-5"},
+          "to": {"model": "claude-opus-4-8"}}], uuid="a-fallback")
+    ctx = SessionContext(tandem_id="probe", cwd=env.cwd, direction="claude->codex")
+    assert ReferenceConverter().translate_entry(entry, ctx.direction, ctx) == []
+
+
+def test_unknown_uuid_carrying_entry_does_not_cascade_into_parent_problems(env_factory):
+    """A future chain participant claude has not told us about yet is ONE
+    problem, not one plus a dangling-parent complaint for every entry chained
+    after it (which would bury the real cause under doctor's `... N more`)."""
+    env = env_factory()
+    sid = env.session.native_id("claude")
+    write_line(env.claude_shadow, {"type": "novel-chain-entry", "uuid": "novel-1",
+                                   "sessionId": sid})
+    write_line(env.claude_shadow, {**claude_user("after the novelty", uuid="u-after"),
+                                   "parentUuid": "novel-1"})
+    problems = validate_transcript("claude", env.claude_shadow, sid)
+    assert problems == ["line 1: unknown entry type 'novel-chain-entry'"]
+
+
+def usage_record():
+    usage = {"input_tokens": 100, "cached_input_tokens": 64,
+             "cache_write_input_tokens": 0, "output_tokens": 10,
+             "reasoning_output_tokens": 2, "total_tokens": 110}
+    return {"timestamp": "2026-09-05T16:00:00.000Z", "type": "token_usage_record",
+            "payload": {"thread_id": "thread", "turn_id": "turn",
+                        "session_id": "thread", "root_turn_id": "turn",
+                        "response_id": "response", "usage": usage,
+                        "turn_token_usage": usage, "thread_token_usage": usage}}
+
+
+def test_codex_accounting_record_is_valid_and_not_conversation(env_factory):
+    env = env_factory()
+    record = usage_record()
+    write_line(env.codex_shadow, record)
+    assert validate_transcript("codex", env.codex_shadow,
+                               env.session.native_id("codex")) == []
+    ctx = SessionContext(tandem_id="probe", cwd=env.cwd, direction="codex->claude")
+    assert ReferenceConverter().translate_entry(record, ctx.direction, ctx) == []
+    assert ctx.turn_index == 0
+
+
+def _blocks(text_parts):
+    """codex 0.153 writes roughly half of its tool outputs as a list of
+    input_text blocks rather than one string (531 of ~5000 local outputs)."""
+    return [{"type": "input_text", "text": t} for t in text_parts]
+
+
+def test_codex_list_shaped_tool_output_parses_to_joined_text():
+    adapter = ADAPTERS["codex"]
+    ctx = SessionContext(tandem_id="probe", cwd="/tmp", direction="codex->claude")
+    (ev,) = adapter.parse_entry(
+        {"type": "response_item", "payload": {
+            "type": "custom_tool_call_output", "call_id": "c1",
+            "output": _blocks(["Script completed\nOutput:\n", "cobalt\n"])}},
+        ctx)
+    assert ev.kind == "tool_result"
+    assert ev.output == "Script completed\nOutput:\ncobalt\n"
+    assert "input_text" not in ev.output
+
+
+def _codex_turn_with_tools(user_text, assistant_text):
+    """One 0.153 turn: a code-mode `exec` call (list-shaped output), an
+    exec_command whose list-shaped output reports a failure, the new
+    accounting record, then the final answer."""
+    return [
+        {"timestamp": "t", "type": "event_msg",
+         "payload": {"type": "task_started", "turn_id": "x"}},
+        {"timestamp": "t", "type": "event_msg",
+         "payload": {"type": "user_message", "message": user_text}},
+        {"timestamp": "t", "type": "response_item", "payload": {
+            "type": "custom_tool_call", "id": "tool-id", "status": "completed",
+            "call_id": "call-exec", "name": "exec",
+            "input": 'text(await tools.exec_command({cmd:"printf cobalt"}));',
+            "internal_chat_message_metadata_passthrough": {}}},
+        {"timestamp": "t", "type": "response_item", "payload": {
+            "type": "custom_tool_call_output", "call_id": "call-exec",
+            "output": _blocks(["Script completed\nOutput:\n", "cobalt"])}},
+        {"timestamp": "t", "type": "response_item", "payload": {
+            "type": "function_call", "name": "exec_command",
+            "arguments": '{"cmd": "false"}', "call_id": "call-shell"}},
+        {"timestamp": "t", "type": "response_item", "payload": {
+            "type": "function_call_output", "call_id": "call-shell",
+            "output": _blocks(["Process exited with code 1\nOutput:\n", "boom"])}},
+        usage_record(),
+        {"timestamp": "t", "type": "response_item",
+         "payload": {"type": "message", "role": "assistant", "phase": "final_answer",
+                     "content": [{"type": "output_text", "text": assistant_text}]}},
+        {"timestamp": "t", "type": "event_msg",
+         "payload": {"type": "task_complete", "turn_id": "x",
+                     "last_agent_message": assistant_text}},
+    ]
+
+
+def _claude_tool_blocks(transcript):
+    blocks = [b for e in read_jsonl(transcript)
+              for b in (e.get("message") or {}).get("content") or []
+              if isinstance(b, dict)]
+    return ([b for b in blocks if b["type"] == "tool_use"],
+            [b for b in blocks if b["type"] == "tool_result"])
+
+
+def test_current_formats_survive_repeated_switches_without_echo(env_factory):
+    env = env_factory()
+    write_line(env.claude_shadow, claude_user("remember apricot", uuid="u-probe"))
+    write_line(env.claude_shadow, {"type": "atis-latch", "atis": ""})
+    write_line(env.claude_shadow, claude_assistant(
+        [{"type": "text", "text": "apricot remembered"}], uuid="a-probe"))
+    assert switch_session(env.store, env.session, "codex")[1] == []
+    env.refresh()
+    records = _codex_turn_with_tools("remember cobalt", "cobalt remembered")
+    for record in records:
+        write_line(env.codex_shadow, record)
+    assert switch_session(env.store, env.session, "claude")[1] == []
+    env.refresh()
+
+    calls, results = _claude_tool_blocks(env.claude_shadow)
+    assert [c["name"] for c in calls] == ["exec", "Bash"]
+    assert [r["tool_use_id"] for r in results] == [c["id"] for c in calls]
+    # code-mode call: JavaScript kept verbatim, list output flattened to text
+    assert calls[0]["input"]["input"] == records[2]["payload"]["input"]
+    assert results[0]["content"] == "Script completed\nOutput:\ncobalt"
+    assert results[0]["is_error"] is False
+    # exec_command with a list-shaped failure still maps to a failed Bash
+    assert calls[1]["input"] == {"command": "false"}
+    assert results[1]["content"] == "boom"
+    assert results[1]["is_error"] is True
+
+    before = env.codex_shadow.read_bytes(), env.claude_shadow.read_bytes()
+    drain_source(env.store, env.session, "claude")
+    assert switch_session(env.store, env.session, "codex")[1] == []
+    assert before == (env.codex_shadow.read_bytes(), env.claude_shadow.read_bytes())
+    for source, target in [("claude", "codex"), ("codex", "claude")]:
+        assert env.store.get_cursor(env.session.tandem_id, source, target).failed_turns == 0
+
+
+def test_installed_versions_start_without_format_warning(monkeypatch, capsys):
+    monkeypatch.setattr("tandem.config.load_harnesses", lambda: ["claude", "codex"])
+    for hid, version in [("claude", "2.1.261 (Claude Code)"),
+                         ("codex", "codex-cli 0.153.4")]:
+        monkeypatch.setattr(type(ADAPTERS[hid]), "detect_version",
+                            lambda self, _v=version: _v)
+    assert _resolve_participants()[0] == ["claude", "codex"]
+    assert capsys.readouterr().err == ""