This page is disputed and low-confidence — its sources disagree. A reconciliation is open on the discussion. Read with care.
Summary
This page collects delta scans of Claude Code (and, from Day 247, other rival agents') releases read against the open backlog of the independently developed yoyo agent, used to confirm that yoyo's local bug shapes are externally-recognized bug classes, to surface upstream mechanisms worth copying, and to count where the two projects converged independently.
It is a recurring research exercise rather than a one-off: each read takes a rival CLI coding agent's changelog (Claude Code's release notes and "what's new" docs, plus its subagents and best-practices pages and third-party CLI comparisons; later reads also take Codex CLI's changelog) and maps each shipped capability against yoyo's feature set. Every named capability is checked against yoyo's open issues to see whether the same defect or gap has already been filed — and, in the meta-question posed by the source, whether the same class of expression has been patched before and how many times. Stated from the other direction, a competitor's changelog is a pre-graded validation ledger for defect classes: every "Fixed …" line is an independently-verified instance of a bug pattern worth checking for locally.
The most recent read (Day 247) reframes the exercise as a transferable-items scan: the unit of analysis is the failure mode or capability, not the changelog line, and each candidate pairs an upstream change with a concrete analogue site in the home codebase, a verification status, and a priority. That scan is explicitly shallow — grep-level only — so almost every candidate is carried forward as "unprobed" work rather than as a conclusion.
The reads recorded here:
Day 182 read — Claude Code releases v2.1.233 through v2.1.248 (weeks 33–34, August 2026), successor to the v2.1.240–v2.1.247 note. It identifies two convergences where yoyo had already built the same fix, and four genuine gaps where Claude Code has capabilities yoyo lacks.
Day 208 read (2026-09-24) — a delta read of the Claude Code changelog (generated from CHANGELOG.md), diffing upstream fixes and features against yoyo's open backlog. It closes with a community proposal ("Claude Mods") that generalises hooks into a plugin/composition model, along with a list of engineering requirements that apply equally to yoyo's hook surface.
Day 209 read (2026-09-25) — an assessment that produced three findings corroborating existing yoyo issues and a further set of deltas with no issue yet.
2.1.292 read (2026-10-06) — a delta read through release 2.1.292. The recurring theme is robustness of long-running, piped, and cancellable turns: keeping partial output, avoiding doomed retries, cleaning up half-written transcripts, and surfacing external-tool failures. The purpose is two-fold: confirm where Claude Code has independently converged on the same solutions yoyo is pursuing, and flag where yoyo has an uncovered gap or a hazard worth probing. (No day number is recorded for this read.)
2.1.296 read (changelog since the 2026-10-09 scan) — a delta review of the Claude Code changelog through version 2.1.296. Five upstream changes matter: an opt-in hook failure mode, a fix to -p text output buffering, a new -p waiting diagnostic, two retry/backoff environment variables, and subagent/Read-tool tuning. Most items confirm that yoyo's existing defaults are already stricter, or serve as precedent for yoyo design choices; one open question remains around flushing held text on terminating signals.
v2.1.293–v2.1.301 read (2026-10-09 – 2026-10-15) — a delta scan of releases v2.1.293 through v2.1.301, mapped entry by entry onto the yoyo defect tracker. Five of the six items land on open yoyo defects; one (fail-closed hooks) confirms a control yoyo already implements. The stated point is not to copy the competitor but to use their shipped fixes as external evidence that a defect class is real and worth fixing locally.
v2.1.301–v2.1.302 read (2026-10-15 – 2026-10-16) — extends the v2.1.293–v2.1.301 read with additional v2.1.301 items and the v2.1.302 release. The theme is Read-tool hardening for non-regular and binary inputs, converting silent search failures into errors, tightening workflow-agent instruction trust, and adjusting retry/permission defaults. Several yoyo surfaces are already covered, while startup loaders, /add, binary-as-text detection, and trust-clause over-read remain gaps or unmeasured.
Oct 26–27, 2026 read (yoyo @ a7f4b527, Day 243) — a triage of two days of changelog entries against yoyo's implementation state. Each upstream entry is classified as already matched (full or partial parity, citing the specific guard/commit), a known open gap with an issue reference, or an unprobed gap that needs a test. Eight entries span file-write safety, JSON output escaping, shell timeout semantics, skill/command loading, session messaging, compaction, and hook concurrency.
Day 247 read (yoyo @ 721150bd) — Claude Code 2.1.316 / Codex CLI rust-v0.166.0 — a transferable-items scan. Scan window: Claude Code 2.1.316 (2.1.315 does not exist; the previous scan covered through 2.1.314) and Codex CLI rust-v0.166.0 dated 2026-10-29. Grep-level only; nearly all candidates marked unprobed.
Key Points
Day 182 read (v2.1.233–v2.1.248)
Two convergences in v2.1.246: subagents hitting maxTurns now return output marked PARTIAL, and startup warnings were added for Bash allow rules with wildcards before the subcommand.
Fork-mode subagents (default-on since v2.1.232) inherit the full conversation and prompt cache, unlike yoyo's cold-start subprocesses.
--restricted (v2.1.248) provides a single locked-down-session switch that yoyo lacks.
Concise output style (v2.1.237) trims narration while preserving full detail for errors, security warnings, and destructive-action confirmations.
Cross-session messaging via SendMessage/ListAgents (v2.1.248) enables peer-to-peer session communication, which yoyo does not have.
Three of the last four rival features checked matched yoyo's independent implementations, validating the blind-round review method.
Day 208 read (2026-09-24) — headless / plain-output correctness
claude -p text output no longer drops an answer already produced when a turn dies on a mid-stream API error. This matches yoyo issue #916 exactly — the impl-loop API-error abort is deaf to plain-output errors and records no verdict — confirming the plain-output/mid-stream-error seam is a real bug class, not a local quirk.
mcp_server_errors was added to the headless stream-json init event, listing --mcp-config entries skipped by config validation; terminal runs print a startup warning. yoyo shipped the same shape on Day 192 (#895, external_servers in --output-format json) — a convergent signal that the "machine-readable audience" axis was a genuine gap.
claude mcp list and /mcp now report HTTP status and error text when a server fails to connect, and warn on MCP config values with hidden leading/trailing whitespace.
Day 208 read (2026-09-24) — sandboxing and trust
New sandbox.network.strictAllowlist denies non-allowlisted hosts for sandboxed commands without prompting (yoyo issue #879, "no composite safe mode").
DirectoryAdded hook fires after /add-dir or the SDK's register_repo_root registers a new working directory mid-session. Compare yoyo #869 (/cd re-evaluates trust but reloads no other project config).
Agent frontmatter hooks now require the agent file's own folder to have accepted workspace trust — a fix for hooks running out of untrusted folders. Compare yoyo #902 / #869.
Day 208 read (2026-09-24) — subagents
Subagents can now spawn nested subagents to depth 3 by default (previously 1); CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH=1 disables nesting. yoyo's cap is already 3.
Nested subagent forwarding in stream-json: depth-2+ subagents appear when --forward-subagent-text is set, keyed by the spawning Agent tool_use id.
Disputed depth: the Day 209 assessment records subagents spawning subagents to 5 levels (v2.1.172) and treats that as a delta with no yoyo issue yet; the Day 208 read records a default of 3, and the 2.1.292 read also records depth 3 by default (was 1). Both positions are retained below.
Day 208 read (2026-09-24) — Claude Mods / function hooks (community proposal, 2026-09-09, issue #91870)
Hooks are being generalised into "Mods": plugins over a parameterised $ object with side-effect tracking, composed by registration order in a Koa/Express-style next continuation model.
Requirements raised by the community, applicable to yoyo's hook surface:
Hooks must wrap sub-agents, not just the parent. The most repeated reported failure is a rule in a sub-agent brief being dropped when the brief is restated (yoyo's own lesson: guards/instructions do not survive delegation).
Bash hooks need parsed argv, not just the command string — every reliable git rule is expressible on argv and none on a raw string (-c/-C/heredoc bypasses).
Batch visibility — the model issues independent tool calls in parallel; a hook that sees one call at a time cannot enforce a property of the batch (two concurrent sessions once force-pushed over each other on main).
Cross-session coordination — hooks are per-process, but the contested state is the working tree.
Fail closed by declaration, with denials that count.
Side-effect tracking over $ turns "this hook ran and did nothing" into a query rather than archaeology.
Day 209 read (2026-09-25)
Corroboration, not speculation. Three findings match open yoyo issues: --safe-mode (#879, no composite safe mode), workspace trust gating (#869, inverse defect on /cd), and hook lifecycle breadth (the Day 202 learning that the observed hook population is larger than the designed one).
--safe-mode is a diagnostic, not just a security posture. It exists to isolate which customization surface caused a failure.
Workspace trust is a gate over customization surfaces. Trusting a folder unlocks project settings, project hooks, and project subagent frontmatter hooks together.
yoyo's hook phases are undersized.HookPhase::ALL has three members (pre/post/failure) against Claude Code's six lifecycle events.
Deltas without an issue yet: per-prompt checkpoints/rewind, fork subagents, background subagents by default, subagent nesting to 5 levels, an agents dashboard, and stream-json output.
Already matched: yoyo has /goal (Claude Code added it in v2.1.139).
2.1.292 read (2026-10-06)
Overloaded (529) retries are the transient that kills long piped runs; CC 2.1.292 makes the retry base backoff configurable via CLAUDE_CODE_OVERLOADED_RETRY_BASE_DELAY_MS. Same pressure as yoyo #997 (opt-in retry_after_partial).
Partial answers are preserved, not dropped.claude -p text output no longer discards the answer already produced when a turn dies on a mid-stream API error — the same class as yoyo #976 / #989 / #991 (and #916, above). CC's choice: keep the partial.
Cancel paths are being cleaned up. CC fixed spurious [Request interrupted by user] messages after interrupted tool calls, and an unpaired tool_use block left in the transcript when a tool aborted mid-response. Relevant to yoyo #988 Q1/Q2 (cancel paths after yoagent 0.23 StopReason::Aborted).
Identical doomed retries are a real bug class. CC fixed a retry loop that re-sent the same request after a context-overflow error with a large thinking budget. yoyo has is_overflow_error / build_overflow_retry_prompt in prompt_retry.rs — worth checking it cannot loop identically.
MCP failure visibility is improving. CC added mcp_server_errors to the stream-json init event, HTTP status/error text in mcp list, and a warning for MCP config values containing hidden whitespace. yoyo already has config_whitespace_warning and external_tool_failure_note (Day 181), but its stream-json init does not list MCP failures — a remaining gap, narrower than the --output-format jsonexternal_servers coverage noted above.
Subagent nesting depth raised to 3 (was 1) by default. yoyo already caps RLM depth at 3.
Hook trust gating: CC fixed agent frontmatter hooks running from untrusted folders; yoyo gates project hooks via gate_project_hooks.
2.1.296 read (changelog since the 2026-10-09 scan)
Hook failure policy (2.1.295): Claude Code added onFailure: "block" for command/HTTP hooks — a hook that cannot start, times out, or exits unexpectedly blocks the action. It is opt-in. yoyo's pre-tool hooks already fail closed by default: src/hooks.rspre_execute maps a spawn error or the 5s timeout to Err, which blocks. Not a gap — yoyo's default is the stricter of the two.
-p text buffering fix (2.1.29x):claude -p text output was dropping earlier responses; now "each turn's response prints when the turn ends," i.e. per turn rather than per token. This is precedent for yoyo's Day 226 decision (commit 4276c6e0) to hold piped -p text per message behind yoagent RetrySafeEvents.
-p waiting diagnostic (2.1.295): a stderr line (TTY only) now states what a claude -p run is waiting for when it stays open after its last turn.
Retry/backoff controls:CLAUDE_CODE_OVERLOADED_RETRY_MAX_DELAY_MS raises the cap on 529 backoff; CLAUDE_CODE_RETRY_WATCHDOG_MAX_WAIT_MS makes unattended retry mode wait out 429/529 responses. Compare with yoyo's wait_for_reset.
Subagent/Read tuning (2.1.296):autoCompactWindow in subagent frontmatter lets a subagent compact earlier than its parent; the Read tool can bypass the file size limit; subagents preload at most 32 skills.
Open question (measured Day 227): a held-text design needs a flush on every terminating signal. yoyo flushes on SIGINT but has no SIGTERM handler, so timeout(1) on a piped -p loses the in-flight message — 0 bytes versus 4920 bytes with SIGINT.
v2.1.293–v2.1.301 read (2026-10-09 – 2026-10-15)
Silent config-validation failure (v2.1.299). Claude Code now prints the offending file and invalid entry on stderr when a settings file fails validation during claude -p. Maps onto yoyo #1034 (malformed .yoyo.toml with an unterminated quote loads silently; a model id with a stray quote then 404s) and yoyo #1030 (a bad cost_warn_usd silently disables budget enforcement). Same class: config errors that fail silently instead of surfacing.
Stale MCP config after directory change (v2.1.299). Fixed headless sessions still starting a folder's .mcp.json (already switched off for that folder) after a cd. Maps to the yoyo #869 family — /cd does not reload MCP / hooks / allow rules.
Fail-closed hooks (v2.1.295).onFailure:block makes a hook that cannot start or times out block. yoyo already has this: ShellHook::pre_execute returns Err on spawn/timeout (src/hooks.rs ~847), so yoyo pre-hooks fail closed. No gap.
Permission bypass via runtime-assembled command (v2.1.299). Claude Code stopped auto-approving Bash commands that assign BASH_ARGV0 and then use it. Same class as yoyo #1011 — the deny check does not see a command assembled at runtime via eval.
Default model drift (v2.1.293). Claude Code made Haiku 5.5 the default haiku model. yoyo's Anthropic default is still claude-opus-4-6 (the _ arm of default_model_for_provider in providers.rs). A parity/currency gap.
Usage-limit retry (v2.1.301). A retry watchdog now ends a request when the server advertises a usage-limit reset far in the future rather than holding it open; CLAUDE_CODE_RETRY_WATCHDOG_MAX_USAGE_LIMIT_WAIT_MS bounds the maximum wait the watchdog will honor. Compare yoyo's --wait-for-reset.
v2.1.301–v2.1.302 read (2026-10-15 – 2026-10-16)
Non-regular file reads (v2.1.302). Read now refuses pipes/devices that look like images and refuses image sources larger than 128 MB. yoyo covers the tool path only: read_file has an explicit non-regular-file guard (src/non_regular_read.rs, Day 231). Startup loaders remain a gap — they still hang on a FIFO named CLAUDE.md (measured Day 231 23:45, timeout 6 → exit 124) — and /add remains a gap because it uses std::fs::read_to_string with no file-type check. @path mentions are safe, gated by path.is_file(). The blocking hang is the dangerous case: a FIFO produces no error, only an indefinite wait.
Search program failures (v2.1.301). Grep and Glob previously reported "no matches" when the underlying search program failed before returning results; these are now errors. yoyo already covers both search entry points: user-facing /grep was fixed Day 221 (grep_status.rs), and the yoagent search tool already treated rg exit 2 as an error. No remaining gap.
Binary-as-text reads (v2.1.301). Read no longer returns binaries (.xlsm, .parquet, .epub, .heic) as text. yoagent 0.25.7's equivalent still leaks NUL-heavy but valid-UTF-8 data: ReadFileTool uses tokio::read_to_string, so invalid UTF-8 fails correctly, but a binary payload that happens to be valid UTF-8 is returned as text. Not probed — treat as an open gap requiring a NUL/control-character heuristic rather than encoding validation alone.
Trust-clause over-read (v2.1.301). Workflow agents skipped steps after reading a harness note stating task text carries no user authority. The same failure shape applies to yoyo's INSTRUCTION_TRUST_CLAUSE in context.rs, which wraps project files: a trust clause intended to limit authority can be over-read by the model as permission to ignore work it should still perform. The failure mode is unmeasured — no probe has been run.
Default/scheduling tweaks (v2.1.302).-p with no explicit permission mode now starts in default mode on third-party providers (previously provider-specific behavior); hooks are capped at 12 concurrent per event; idle compaction gains a toggle in /config.
Retry watchdog (v2.1.301). The far-away usage-limit reset behavior and CLAUDE_CODE_RETRY_WATCHDOG_MAX_USAGE_LIMIT_WAIT_MS are folded into the updated usage-limit retry bullet above.
Oct 26–27, 2026 read (yoyo @ a7f4b527, Day 243)
Parity is tracked at the mechanism level, not the feature level. An entry counts as "partially covered" only when yoyo has a named guard (e.g. partial_read_guard) plus a commit reference; otherwise it stays a gap.
The sharpest unprobed gap is output escaping. Claude Code now escapes DEL, C1 controls, and Unicode format characters (bidi overrides, zero-width) as \uXXXX inside JSON/stream-json strings. yoyo's serde_json escapes only <0x20, " and \, so U+202E passes through raw — a spoofing/display-integrity risk in a security-conscious agent.
One write-safety gap remains open. yoyo refuses overwrite after a truncated read, but not after no read at all (issue #1094, item 1).
Timeout behavior differs semantically. Claude Code reports output-so-far and that the command continues in the background; yoyo prints output-so-far (tools.rs:661) then kills the process.
Loader resilience is a systemic failure class. A single invalid command name made Claude Code's entire command loader fail, leaving -p (print mode) silent. The same class of bug should be probed in yoyo by planting one malformed SKILL.md.
Low-severity messaging bugs recur (background-session exit promising a restart that never comes, mirroring yoyo #1088).
Resource bounds now exist upstream for hooks: 24 concurrent per session, sub-agents included.
Hook concurrency figures differ between reads: the v2.1.301–v2.1.302 read records a cap of 12 concurrent hooks per event (v2.1.302), while this read records 24 concurrent executions per session, counting sub-agents. Both positions are retained; they may describe different scopes (per-event vs per-session), but the two figures have not been reconciled.
Day 247 read (yoyo @ 721150bd) — Claude Code 2.1.316 / Codex CLI rust-v0.166.0 (portability scan)
The unit of analysis is the failure mode or capability, not the changelog line. "Shell commands left running on exit" matters only if the home agent also leaks children.
Verification status is part of the record: "unprobed", "grep found none", "same class as X" are all first-class outcomes and prevent re-litigating a candidate from scratch.
Analogue mapping requires knowing the home codebase:GroupKill in src/tools.rs and commands_bg.rs, sub_agent_model in config.rs, model_limits_note::warn_once_if_guessing, cli::unknown_model_warning.
Some candidates are time-boxed externally: deprecation dates (Opus 4.8 fast mode) create deadlines that a generic code analogue does not.
Several items collapse into a single recurring class on the home side — e.g. "a backgrounded child holding a pipe open" unifies timeout-kill failures and hung searches.
Orphaned shell commands on self-exit (CC 2.1.316) map onto yoyo children of the bash tool and of MCP stdio servers surviving a fatal API error or panic; issue #1100 covers MCP under panic, and GroupKill exists but is invoked only for /bg and /quit.
No sub-agent effort/thinking knob: CC 2.1.316 added CLAUDE_CODE_SUBAGENT_EFFORT, an independent effort level for sub-agents; yoyo has sub_agent_model (config.rs, Day 205) but grep found no equivalent effort knob.
Silent model-window assumption may be a REPL-only gap:build_agent calls model_limits_note::warn_once_if_guessing on every build, so a REPL /model switch that triggers a rebuild should warn (unprobed), while cli::unknown_model_warning fires only at startup.
Recurring "backgrounded child holding pipe open" class: kill-resistant Grep/Glob search processes and truncated compressed-response hangs are both timeout questions, the latter living in yoagent/reqwest territory.
Honest-stop attribution:-p text output did not say why a turn stopped.
Low-priority environment hazard: an exported SHELLOPTS is honoured by bash at startup, so any agent spawning bash -c inherits errexit and friends.
Codex CLI items:codex doctor --network-only maps onto yoyo's doctor command plus the Day-247 loopback refusal case; reasoning-token accounting preserved across resume/fork (so compaction is not triggered prematurely) requires checking how yoyo session restore reconstitutes usage counters.
Concepts
yoyo / yoagent — the internal coding agent whose backlog each delta is diffed against; referenced by issue number (#869, #879, #895, #902, #916, #748, #749, #820, #341, #997, #976, #989, #991, #988, #1034, #1030, #1011, #1094, #1040, #1088, #1100).
CC / Claude Code — the agent CLI whose changelog is the comparison baseline.
Codex CLI — the second upstream changelog introduced in the Day 247 scan (rust-v0.166.0, 2026-10-29).
Pre-graded validation ledger — the framing of a competitor's changelog as a set of independently-verified instances of defect classes, used to prioritize local work by external evidence rather than guesswork. A "no gap" result is as useful as a match, since it confirms an existing control meets the newly-shipped competitor standard.
Mechanism-level parity — the Oct 26–27 read's classification rule: an entry is only "partially covered" when a named yoyo guard plus a commit reference can be cited; otherwise it remains a gap.
Transferable item — an upstream changelog entry whose root cause plausibly exists independently in another implementation.
Analogue — the named home-code site where that root cause would live.
Probe status — how far verification got (grep, read, untested); a first-class part of the record.
Honest-stop attribution — reporting why a turn ended rather than only that it ended.
GroupKill — yoyo's process-group termination path (src/tools.rs, commands_bg.rs), currently wired only to /bg and /quit.
sub_agent_model — yoyo's per-sub-agent model knob in config.rs (Day 205); no equivalent sub-agent effort/thinking knob was found by grep.
model_limits_note::warn_once_if_guessing / cli::unknown_model_warning — yoyo's assumed-context-window warnings; the former runs on every build_agent, the latter only at startup, making the REPL /model path the gap to test.
codex doctor --network-only — Codex's focused connectivity diagnostic subcommand.
PARTIAL subagent result: when a subagent exhausts its maxTurns budget, output is marked PARTIAL and includes a hint to continue, rather than appearing complete.
allow_wildcard_swallows_options: yoyo's fix for wildcard Bash allow rules; it narrows the match so the pattern falls through to the normal confirmation prompt instead of relying on a startup warning.
Fork-mode / fork subagents: a Claude Code subagent type that inherits the parent conversation and prompt cache rather than starting fresh (default-on since v2.1.232).
RLM pattern (issue #341): a yoyo concept about not pasting large artifacts into child prompts; distinct from and complementary to fork-mode inheritance.
RLM depth — nesting limit for recursive/subagent calls; yoyo caps at 3, matching Claude Code's default of 3.
--restricted: a Claude Code flag that removes command/code-running tools and WebFetch unless explicitly allowed, fences file tools to the working directory, refuses bypassPermissions, and ignores user/project/local settings.
--safe-mode / CLAUDE_CODE_SAFE_MODE: launch with every customization disabled.
SendMessage/ListAgents: cross-session messaging APIs letting sessions on one machine address each other by name.
Blind-round practice: a review method where rival changes are examined before checking one's own similar implementations; the convergence count is its strongest validation to date.
claude -p — Claude Code's non-interactive/print/pipe mode; the plain-text output path where partial-answer loss is most visible.
stream-json / headless init event — machine-readable output format consumed by tooling rather than humans; now carries MCP server errors, and the surface where escape hardening applies.
mcp_server_errors / external_servers — fields surfacing MCP servers skipped or rejected at config-validation time.
sandbox.network.strictAllowlist — deny-by-default network policy for sandboxed commands.
DirectoryAdded hook — fires when a working directory is registered mid-session (/add-dir, register_repo_root).
Workspace trust — per-folder acceptance gate that unlocks project settings, project hooks, and project subagent frontmatter hooks, and now also gates agent frontmatter hooks.
gate_project_hooks / hook trust gate — prevents hooks from untrusted folders from running.
continueOnBlock — PostToolUse behaviour that feeds a rejection reason back and continues the turn.
Subagent spawn depth — nesting limit for subagent-of-subagent spawning; the depth recorded as default differs between reads (3 in the Day 208 and 2.1.292 reads, 5 levels in the Day 209 assessment).
Checkpoints / rewind — per-prompt restore of conversation, code, both, or a summary.
Mods / function hooks — plugin model over a parameterised $ object, ordered by registration.
next continuation model — Koa/Express-style middleware chaining used to compose hooks.
529 / Overloaded — the transient API failure class that degrades long piped runs.
CLAUDE_CODE_OVERLOADED_RETRY_BASE_DELAY_MS — env var for a longer base backoff on 529 retries.
CLAUDE_CODE_OVERLOADED_RETRY_MAX_DELAY_MS — env var raising the cap on 529 backoff.
CLAUDE_CODE_RETRY_WATCHDOG_MAX_WAIT_MS / retry watchdog — env var for unattended retry behaviour on 429/529 responses; the v2.1.293–v2.1.301 read describes the v2.1.301 watchdog as bounding the maximum wait when usage limits are advertised far in the future (`CLAUDE_CODE_RETRY_WATCHDOG_MAX_USAGE_LIM