relayline 0.6.0

Claude Code, Codex and DeepSeek hand work to each other, and every hand-off comes with a receipt. This release is about making those receipts harder to misread, and about publishing what the recheck did and did not show.

What changed

• Receipts. A failed or broken check now reads outcome=check_failed or outcome=check_broken, not ok=true. A self-checked pass says it was not independently verified. Receipts name the final executor; reassignment and budget stops reach the lead's one-line result. JSON ok, exit codes and verdict rules are unchanged.
• Choosing who does the work. routing.require_ready=true prefers installed CLIs with login evidence. Roles stay opt-in.
• Daily UI. Budget and review stops, quota age, today's spend and write-mode hints in the ccx ui preview.
• Memory suggestions. Better filtering (task briefs are not counted as your words, fragments and near-duplicates are dropped), batch accept/reject, and old candidates expire.
• Repair chain. A re-review that did not run or was unclear gives a clear needs_lead hint.
• Evaluation summaries. Completion and correctness are separate; failed attempts count towards spend.

Full list: CHANGELOG.

What the recheck showed, with its limits

Two pre-registered runs on the release candidate, $4.02 at API-equivalent prices.

Run	Result	What it cannot tell you
hc2, 10 hold-out tasks × 3	28/30 right against hidden tests (clean rows 25/27), $0.088 per success, median wall 168 s. 19 ordinary ok receipts, none of them wrong	Doing it yourself and the built-in sub-agent were not rerun, so there is no current comparison. 0/19 has a 95 % upper bound of about 15 %; it does not show a false-receipt rate below 2 %. Only 6 of the 19 had status=done
pg3b, 30 small exercises	15/30 right. 15 of 29 ok_self_checked receipts were wrong, and review passed all 29	No ordinary ok receipts, so insufficient evidence for the false-receipt bar. A review pass there did not mean the work was right

The earlier "about 30 % cheaper than doing it yourself" (hc1, 2026-10-29) is a historical result on old code and does not describe this version. Against hc1, paired cost rose 32 % and cumulative wall time 157 %. Code, sandbox conditions and the Claude version all changed, and these were not separated, so this neither establishes a product slowdown nor shows the saving is gone. In every run compared, ccx was slower than doing it yourself.

hc2's pre-registration was ambiguous on its regression rule: "≤25/30" and "clean rows only". Clean rows were 25/27. Read as a proportion this is not a regression, which is how it was judged; read as the bare number 25 it would have stopped the release. The report says so.

Not done in this release

• No GIF and no blog post; these notes stand in.
• No new trial of H11: memory.by_kind stays off and experimental.
• macOS and Linux are CI only, not run on real machines. Gemini CLI, a real quota stop and installing the Codex plugin from GitHub are not run for real.
• Real use outside ccx's own tests is still thin.

Install

pipx install git+https://github.com/SUPERD6/relayline@v0.6.0

Then ccx setup and ccx doctor. Python 3.11+, standard library only. The wheel and sdist are attached.

relayline 0.5.0

• Highlights: everything since 0.4.0 (PRs up to #104), grouped by theme below; 523 tests. Measured on real CLIs:
  shared work context, right the first time 36/36 vs 7/36 and 63 % less spend
  (report); project memory 9/9 vs 0/9 and hub memory 9/9 vs 0/9;
  seven-cores round 1 (report): delegating cut the lead's tokens 32 %
  but not the total spend, routing gave no gain, review after the fix 3/3.
  Round 2 (report): a cheap model was right 47/49 on trap tasks;
  review 36/36 vs 33/36 at +$0.004 a task; dividing the work 14/14 vs 12/14 at 20–39× the spend; ten parallel
  runs 2.5× faster but 4.7× the tokens. Default shape: one cheap model plus another vendor's cheap review.

Save: routing and cost

• Default tradeoff is now save (was balanced): routing starts small work on the cheap model. With routing fed
  the seven-cores A/B (PR #30), 5-minute work goes to codex luna low (predicted 0.94, about $0.004) instead of
  claude sonnet medium (0.997, about $0.04); 15-minute work still goes to sonnet. An existing hub keeps its own
  defaults.tradeoff if it set one (ccx config get defaults.tradeoff).
• Explicit picks can teach routing. A verdict reaches routing only with a difficulty b, and a run with --model
  / --effort but no --minutes (or rubric flags) has none: in the seven-cores A/B (PR #30) 63 verified luna-low
  runs left routing at n = 0, still predicting p = 0.48 where they were right 55 times out of 63. agent-delegate's
  explicit-pick line now includes --minutes <n> and says why, and the result of such a run says
  route.learns: "no: give --minutes ...". (The A/B's 84 runs were fed back into one person's routing state with
  b from the minutes the A/B used; luna low at 5 minutes then predicts 0.94 and --tradeoff save picks it.)
• H14, a head start for new users: the task-routing priors carry the seven-cores A/B round 1 per rung ([observed]:
  runs and first-rung successes by hidden tests, per difficulty). Until a hub records a rung's first outcome, that rung
  starts from the theta shift these outcomes imply at weight 0.5 (cap 1.5): luna low +0.67 (5-minute work 0.55 → 0.74,
  measured 38/45), sonnet medium +0.78 (42/42). A hub that already learned a rung is not affected. ccx doctor shows
  where routing starts ("routing prior"). See task-routing references/method.md §6b.
• ccx route --lead reads your own conversation's size from its last request when --lead-ctx is not given
  (ctx_source: lead_session; given / none otherwise; Claude Code and Codex leads) and prices it as its own
  term: each request you make re-reads it, and doing the task yourself takes more of them than delegating (new
  priors lead_turns_self_base / lead_turns_self_per_b / lead_turns_delegate, from the seven-cores A/B: 3 vs 2
  at small tasks). --ctx-tokens keeps its meaning (context the task adds). task_routing.py route --lead-ctx.
• ccx propose (H12): the same flags as ccx route --lead, plus a proposal id, whether it is worth offering and
  one line to say. ccx run --proposal ID records the yes and links the run; ccx propose --no ID records a no.
  ccx propose --stats [--days 7]: proposed -> agreed -> delegated -> judged, and the share of real
  (non-evaluation) runs with a verdict from the lead or the person (target 60 %).
• --to auto / ccx route no longer read a week of Codex session logs to know its quota. quota.codex_readings
  reads only the end (64 KB) of the session files changed in the last 48 hours (at most 40, newest first), plus
  small pieces further back at twice the distance each time, and parses only lines with rate_limits; when none of
  those has one it looks at up to 5 older files. Each file's readings are cached in
  <hub>/ccx/codex-quota-cache.json by (path, mtime, size). The pace now says when its reading was taken
  (read_at). Measured on one machine (144 session files, 2.5 GB): ccx route --minutes 5 13.9 s -> 0.70 s
  (quota 13.87 s -> 0.10 s uncached, 0.04 s cached), same projection as the full scan (0.224 vs 0.223).
• H2: every attempt taken for a quota stop leaves its evidence in <hub>/ccx/quota-stops.jsonl: Claude's rejected
  rate_limit_event as it came, or the hint that matched and the words around it (Codex and others), with run,
  agent, model and retry time. ccx quota shows the last five (recent_quota_stops). A wrong call (the word
  "quota" in a task's own output, a new wording of a real limit) can then be found and the hints corrected without
  spending quota to test. No quota stop has happened in real use yet (0 of 337 runs on the author's machine).
• A sub-agent's own sub-agents, limited by spend and quota rather than head count (proposals F10–F14, narrowed
  by the PR #6 measurements). F10: Codex's concurrency and F13: its sub-agent model are no longer forced to 3 and
  the parent's rung; ccx sets them only when quota is tight (1 at a time, one rung down) or snug (2), or when the
  lead says --subagents N|off. F11: the spend cap is the piece's budget (--budget, a queue item's remaining
  share), else [subagents] max_usd; a run over it stops as over_budget and ccx resume RUN --budget X goes on.
  F12: Claude write sub-runs get the Agent tool, because their sub-agents' spend shows while they run (stream
  events and <session>/subagents/*.jsonl, checked live with Claude Code 2.1.309); the watchdog reads it, and a
  Claude result is now counted from modelUsage — usage covered only the main conversation's last request
  (11.6k vs 19.9k cache-write tokens with one sub-agent), so sub-agent tokens were missed. F14: a brief listing
  3+ parts (or --parallel) explicitly asks for sub-agents on the independent parts. Docs now say that with
  codex-cli 0.164 + gpt-6-luna/low sub-agents were not started even when asked, so these limits are untested live.
• The lead's own context (proposal H10). Almost all spend is the lead re-reading its whole conversation every turn
  (here: sub-agents $0.34 in 30 days; the median lead turn re-reads ~220k tokens, ~$0.06, over ~19k turns). ccx lead
  lists recent lead conversations: turns, what the last and the largest turn read, cost per turn, advice. ccx sync
  adds a Claude Code UserPromptSubmit hook (ccx lead --hint) that prints one line when a conversation re-reads more
  than 150k tokens a turn (at most once per 20 turns, never fails the turn); ccx uninstall removes it. Codex: no
  per-turn hook yet. ccx report shows "Lead cost per turn"; agent-delegate says to send big reads out and hand a
  long conversation over to a fresh one.
• A model for the lead itself (proposal J5): ccx lead --suggest reads the last 30 turns of this conversation
  (Claude Code), sorts them into code edits, doc edits, reading/running and talk (files changed through the shell
  count as code), and compares what a turn costs at this context size on each model. When code is under a fifth of
  the turns it suggests one rung down, with the saving per 100 turns and how many turns pay back the one cache
  rewrite a switch costs; otherwise it says to stay. ccx report adds what the same lead turns would have cost one
  rung down. Here: 7 days of lead turns $1,204 AE, one rung down $952 less; this conversation (~440k tokens a turn,
  half its recent turns editing code) is told to stay on opus.
• Long output cut down before the lead reads it (proposal J3): ccx sum -- <command> runs the command, keeps the
  full output in .ccx/sum/ (git-ignored, last 20) and prints only what matters — for tests each failure's header,
  last frame and error line plus the summary; for diffs files changed with +/− counts and the first hunks; for logs
  error lines with one line of context, repeats folded, and the tail. Capped at 2,000 characters
  (--max-chars); --ask "..." lets a cheap routed model answer from the saved output; the exit code is the
  command's. agent-delegate tells the lead to use it. Here a 40,657-character git diff came back as 2,053.
• What the lead re-reads every turn (proposal J1): ccx lead --breakdown splits the first turn's measured
  prefix into system prompt, built-in tool definitions, each MCP server's tool definitions, each instruction file,
  the skill list, the start hook's output and the rest, from the tools' own session files (Claude Code's request
  shape and start-up attachments; Codex's base instructions, tools and AGENTS.md). Sizes are estimated from the text
  and scaled to the measured count; each part shows its cost per 100 turns, and big ones get advice (turn off an
  MCP server this project doesn't use, link fewer skills, shorten an instruction file). Here: 78.6k tokens a turn,
  of which built-in tool definitions ~23k, the skill list ~6k, one browser MCP server ~5.6k.
• Where the prompt cache broke (proposal J2): ccx lead --cache finds turns that re-wrote the conversation into
  the cache (Claude: cache writes jump; Codex: uncached input jumps) and names the likely cause — idle longer than
  the cache lives (1 h when Claude Code asks for it, else 5 min; ~10 min for Codex), a model switch, the
  conversation compacted, an instruction file edited, the tool list changed — with what each break cost over a
  cache read. The previous long session here had 5 breaks costing ~$8.5 extra (3 idle, 2 compactions).
• A formal comparison over a week (proposal H11). ccx trial start [--days 7] [--rate 0.5] puts about half of the
  delegable tasks on the lead's side ("do this one yourself", closed with ccx ab done) and delegates the rest,
  balanced per kind of work and difficulty. Both halves are measured the same way: the lead conversation the task
  belongs to (and its own built-in helpers) in the task's window, plus the sub-agent's spend and ten minutes for
  checking a delegated result; unjudged runs don't count as having held...

v0.4.0

ccx 0.4.0 — choosing models from public benchmarks and total cost, quota by pace, a durable work queue, self-checks and independent reviews, and a handoff written from the session file.

Routing

• Abilities merged from public benchmarks (Epoch AI, LMArena, models.dev; refreshed weekly) per kind of work (--kind code|read|research|write), with local outcomes on top.
• Difficulty in human minutes (--minutes) plus objective signals measured from the brief; the lead's estimate bias is learned.
• Picks by total cost: money + a quota shadow price + time + risk. Quota is projected to each window's reset (ccx quota).
• DeepSeek flash at low/high/max as its own pay-per-token agent, with a daily cap.

Work and quality

• ccx q: a per-project work queue (append-only). Dependencies set the order, ready pieces run in parallel, each piece has its own check and budget, and a sub-agent can split its piece into sub-pieces (SPLIT:).
• Sub-agents check their own work; --check CMD is run again by ccx, and a failure counts as a failure.
• Independent review (--review auto|on|off): a cheap model from another vendor reviews the diff and answers pass or issues with file:line; problems go back for one fix round. In a live trial it caught 9/9 seeded bugs with 0/5 false alarms, and 1 real bug in 4 real tasks, at about $0.002–0.004 per review.
• Named long-lived seats (--seat reviewer); ccx q resume reports how each piece came back.
• Built-in sub-agents on by default (one level, ≤ 3, routed model, $2 spend watchdog); --no-subagents to turn them off.

Memory and handoff

• Memory notes carry a source, can replace older ones, can be marked checked and searched; the start-up push is capped at about 600 tokens.
• ccx handoff --from-transcript codex|claude: when the old lead can't write the handoff (quota out, crashed), ccx builds it by code from that lead's session file, with secrets masked. A format the code can't read goes to a routed sub-agent.
• ccx send waits while you are typing in that Codex conversation.

Fixes from live runs

• A Claude sub-agent can run the exact --check command (a full python.exe path was blocked); sub-agents are told not to commit or push.
• codex-cli 0.164 still offers its multi_agent v2 tools with the features disabled, so --no-subagents also states the rule in the brief.
• CI: a small matrix on push, the full matrix on tags, PRs and manual runs.

Full list: CHANGELOG.md. 201 tests pass locally. This is the first public release: the repository history was squashed into one commit, and commit ids in CHANGELOG/STATUS refer to the earlier private history. Still a work in progress — see the note at the top of the README.

🤖 Generated with Claude Code