baldart 4.56.2 → 4.56.3

package/CHANGELOG.md

@@ -5,6 +5,24 @@ All notable changes to BALDART will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [4.56.3] - 2026-06-20
+
+**`/new` Codex relays made Haiku-proof — the JS now owns the success decision and deterministically recovers Codex's findings, so no relay model (whatever tier the runtime hands it) can drop them.** Direct follow-up to a user question — "why is the per-card Codex relay still running on Haiku?" Forensics on the real consumer run (reading `<session>/subagents/workflows/wf_*/agent-*.jsonl`) established two facts that recontextualise v4.56.2:
+
+1. **`model: 'sonnet'` is a request, not a guarantee.** Across 19 real relay runs, the *same* `model:'sonnet'` line produced `claude-sonnet-4-6` on some runs and `claude-haiku-4-5` on others — non-deterministic, no `fallbackModel` configured, no settings pin. Claude Code silently downgrades a workflow subagent from Sonnet to Haiku under capacity pressure (the per-card relay, spawned in a repeated Discovery fan-out, saturates account-level Sonnet capacity in a long session; the lone Final relay rarely does). So v4.56.2's haiku→sonnet bump is best-effort only — it can't *guarantee* the relay isn't Haiku, and the whole "Sonnet fixes it" premise is unenforceable from a `.js` workflow (the runtime picks the model).
+
+2. **Codex usually writes PROSE, not the sentinel JSON.** The real `/tmp/codexreview-wave-*.md` had **zero** `<<<FINDINGS_JSON>>>` sentinels — Codex ignored "emit ONLY the sentinel block" and wrote a `**Findings**` prose report ending in `Turn completed.`. So the sentinel-extraction path the relay was built around frequently extracts nothing, and the findings live in the prose. The v4.56.2 failure (empty `codexProse` → cold fallback ran *unseeded* → missed the BLOCKER) was the relay model failing to capture that prose, not failing a JSON pass-through.
+
+Fix (chosen by the user over a runtime-config force, which can't ship and is blunt): **take the success decision out of the relay model and make recovery deterministic + JS-owned.** The relay now returns RAW command outputs (`marker`, `jsonBlock`, `proseTail`) and decides nothing. The JS fan-in parses `jsonBlock` itself (`null`=no JSON, `[]`=Codex ran clean, `[..]`=findings); when there's no parseable JSON and Codex didn't report ABSENT, a one-shot re-extraction agent (near-zero latitude — two fixed commands) re-runs BOTH the sentinel `awk` AND the `[codex]`-stripped prose `tail` over the on-disk file, so a relay that went off-script or returned an empty `proseTail` can no longer strand the cold fallback unseeded. Result: Codex's findings are recovered whether it emitted sentinels or prose, and whatever model the runtime assigned the relay. Verified deterministically against the real failing transcript (6/6 scenarios, incl. "Haiku returned empty proseTail" → 2304 chars of prose recovered → cold fallback seeded). `model: 'sonnet'` is kept as a best-effort request (it follows steps more reliably when capacity allows) but is no longer load-bearing.
+
+`new2.js` is intentionally **not** touched: its per-card Codex path is a different design (a foreground `--wait` DRIVER that maps findings by model, already on Haiku by design, with its own `note:'codex-unavailable'` → code-reviewer fallback) and it is the experimental A/B variant — porting this would contaminate the comparison.
+
+**PATCH** — robustness fix in the two workflow files that share the THIN-RELAY pattern (`new-card-review.js`, `new-final-review.js`); no install/layout change, no new config key, no prose-SSOT change (the relay's return schema is internal to the workflow). The Codex task prompt, the sentinel contract Codex is *asked* to honour, and the prose-salvage→code-reviewer trust model are all unchanged.
+
+### Changed
+
+- **`framework/.claude/workflows/new-card-review.js`** + **`framework/.claude/workflows/new-final-review.js`** — Codex relay restructured: `CODEX_SCHEMA` now returns raw `{marker, jsonBlock, proseTail}` (no `codexAvailable`/`findings` self-report); the relay prompt drives + returns verbatim stdout and decides nothing; the fan-in owns the parse via `parseFindingsArray` and adds a deterministic one-shot re-extraction (`EXTRACT_SCHEMA` `{jsonOut, proseOut}`, `reExtractPrompt`, `AWK_EXTRACT` SSOT) that recovers both the sentinel JSON and the prose from the on-disk file. `model: 'sonnet'` retained as best-effort with corrected rationale comments (runtime downgrades it under load; correctness no longer depends on the tier).
+
 ## [4.56.2] - 2026-06-19
 
 **`/new` per-card Codex relay bumped haiku → sonnet — stops a real run from discarding a valid Codex review (incl. a BLOCKER) and falling back to a cold, weaker `code-reviewer`.** A user reported the symptom directly: in the per-wave Discovery phase Codex emitted a perfect sentinel-wrapped JSON array (3 findings, one a BLOCKER race condition on the idempotency key), yet the workflow still ran the cold `code-reviewer (fallback)` — which re-reviewed from scratch (~101k tok) and **missed the BLOCKER**.

package/VERSION

@@ -1 +1 @@
-4.56.2
+4.56.3

package/framework/.claude/workflows/new-card-review.js

@@ -109,15 +109,42 @@ const FINDINGS_SCHEMA = {
   type: 'object', required: ['findings'], additionalProperties: false,
   properties: { findings: { type: 'array', items: FINDING }, note: { type: 'string' } },
 }
+// Haiku-proof relay contract (v4.56.3): the relay returns RAW command outputs — it does NOT decide
+// "codexAvailable" and does NOT parse findings. The JS fan-in owns the decision (parses jsonBlock
+// deterministically), so a weak/runtime-downgraded relay model can no longer drop a finding by
+// mis-judging availability — the bytes are on disk and the JS reads them. See the fan-in branch.
 const CODEX_SCHEMA = {
-  type: 'object', required: ['codexAvailable', 'findings'], additionalProperties: false,
+  type: 'object', required: ['marker', 'jsonBlock'], additionalProperties: false,
   properties: {
-    codexAvailable: { type: 'boolean', description: 'false if CODEX_NOT_FOUND / TIMED_OUT' },
-    findings: { type: 'array', items: FINDING },
-    codexProse: { type: 'string', description: 'PROSE-ONLY salvage (v4.56.0): when Codex FINISHED but emitted no sentinel JSON block, the cleaned tail of its prose review — handed to the fallback code-reviewer as UNVERIFIED leads. Empty/omitted otherwise.' },
+    marker: { type: 'string', enum: ['END_JSON', 'TURN_COMPLETED', 'CODEX_NOT_FOUND', 'TIMEOUT'], description: 'which terminator ended the poll' },
+    jsonBlock: { type: 'string', description: 'VERBATIM stdout of the awk extraction command (may be ""). The JS parses it — do NOT edit/judge.' },
+    proseTail: { type: 'string', description: 'VERBATIM stdout of the prose-tail command, ONLY when marker=TURN_COMPLETED with an empty jsonBlock; else "".' },
     note: { type: 'string' },
   },
 }
+// One-shot deterministic re-extraction over the on-disk file — independent of the relay's self-report.
+// Codex OFTEN ignores "emit ONLY the sentinel block" and writes a PROSE report ending in "Turn
+// completed." (verified on real companion output), so there's frequently NO JSON to extract and the
+// findings live in the prose. We therefore fetch BOTH: the sentinel JSON (awk) AND the prose tail.
+const EXTRACT_SCHEMA = {
+  type: 'object', required: ['jsonOut', 'proseOut'], additionalProperties: false,
+  properties: {
+    jsonOut: { type: 'string', description: 'verbatim stdout of the awk sentinel-extraction command, "" if none' },
+    proseOut: { type: 'string', description: 'verbatim stdout of the [codex]-stripped prose tail, "" if none' },
+  },
+}
+// Deterministic parse: null = no recoverable JSON array; [] = Codex ran clean (no findings); [..] = findings.
+const parseFindingsArray = (s) => {
+  if (typeof s !== 'string' || !s.trim()) return null
+  try { const v = JSON.parse(s.trim()); return Array.isArray(v) ? v : null } catch { return null }
+}
+// SSOT for the sentinel-extraction awk — used by BOTH the relay prompt and the re-extract agent.
+const AWK_EXTRACT = `awk '/<<<FINDINGS_JSON>>>/{c=1;b="";next}/<<<END_FINDINGS_JSON>>>/{c=0;last=b;next}c{b=b $0 ORS}END{printf "%s",last}'`
+const reExtractPrompt = (file) =>
+  `Run EXACTLY these TWO Bash commands and return their stdout VERBATIM. Run NOTHING else — do NOT Read the file beyond these commands, do NOT review code, do NOT reason about findings:\n` +
+  `  • jsonOut  = stdout of:  ${AWK_EXTRACT} ${file}\n` +
+  `  • proseOut = stdout of:  grep -v '^\\[codex\\]' ${file} | tail -c 12000\n` +
+  `Return { jsonOut, proseOut } and nothing else (empty string for either command that printed nothing).`
 const GATES_SCHEMA = {
   type: 'object', required: ['gates'], additionalProperties: false,
   properties: {
@@ -222,12 +249,15 @@ log(codexResolved
   ? `Codex companion resolved deterministically: ${codexScriptPath}`
   : 'Codex companion NOT found (deterministic pre-flight) — primary code review via code-reviewer fallback.')
 
-// Codex companion review. The WRAPPER is a thin relay (model: haiku — see the thunk): it launches
-// Codex, waits, and extracts Codex's JSON findings with a deterministic awk. It does NOT review or
-// re-verify code itself (Codex's findings are authoritative + FP-validated) — the old wrapper burned
-// ~100k+ tokens re-grepping to "confirm" findings the design already trusts. Codex emits its findings
-// between explicit sentinels so the extraction is unambiguous despite the companion's `[codex]` trace
-// lines and the truncated "Assistant message captured:" echo (verified on real companion runs).
+// Codex companion review. The relay LAUNCHES Codex, polls, and returns the RAW stdout of the
+// extraction commands — it does NOT review code, does NOT re-grep, and (since v4.56.3) does NOT
+// decide "did Codex succeed": the JS fan-in parses jsonBlock itself. Rationale: the relay model is
+// NOT guaranteeable — `model:'sonnet'` is a request the runtime silently downgrades to Haiku under
+// capacity pressure (observed live: a real per-card relay ran on Haiku despite model:'sonnet',
+// went off-script, and returned "unavailable" while a valid JSON array incl. a BLOCKER sat in the
+// /tmp file). Moving the success decision out of the model makes the relay robust to WHATEVER model
+// it lands on. Codex emits findings between explicit sentinels so the awk is unambiguous despite the
+// companion's `[codex]` trace lines and the truncated "Assistant message captured:" echo.
 const codexReviewTask =
   `Run a deep code review over this wave's committed diff. The code is already written and committed — find bugs, regressions, security issues, and quality problems, per the protocol in ${protocolRef} (Phase 3.7).\n\n` +
   `${waveBrief}\n\n${baselineBrief}\n\n` +
@@ -244,24 +274,22 @@ const codexReviewTask =
 const codexTaskFile = `/tmp/codextask-${cards[0].cardId}.txt`
 const codexReviewFile = `/tmp/codexreview-wave-${cards[0].cardId}.md`
 const codexPrompt =
-  `You are a THIN RELAY around the Codex companion — do NOT review or investigate code yourself, do NOT grep/sed/Read source to "confirm" findings (Codex's findings are authoritative and already FP-validated; re-verifying them is wasted work). Your ONLY job: launch Codex, wait, extract its JSON, return it.\n\n` +
+  `You DRIVE the Codex companion and return its RAW command outputs — you do NOT review or investigate code, do NOT grep/sed/Read source, and you do NOT decide whether Codex "succeeded" (the workflow decides that from the bytes you return). Launch Codex, poll, run the extraction commands, return their VERBATIM stdout.\n\n` +
   `The companion script is ALREADY CONFIRMED PRESENT at:\n  ${codexScriptPath}\n\n` +
   `Run EXACTLY these steps and nothing else:\n` +
   `  1. Write the task text (everything after "TASK PROMPT:" at the end of this message) to ${codexTaskFile} using the Write tool — do NOT inline it into the shell command (avoids quote breakage).\n` +
   `  2. Launch Codex in the BACKGROUND (run_in_background:true — a sync run hits the Bash timeout):\n` +
   `       node "${codexScriptPath}" task "$(cat ${codexTaskFile})" --cwd "${a.worktreePath || '.'}" > ${codexReviewFile} 2>&1\n` +
-  `  3. POLL ${codexReviewFile} (BashOutput / repeated reads) until it contains ANY of these — whichever appears FIRST ends the poll (do NOT keep waiting the full window once one is present):\n` +
-  `       • "<<<END_FINDINGS_JSON>>>"  → Codex emitted the JSON block (success path)\n` +
-  `       • "Turn completed."          → the companion's reliable end-of-run marker — Codex FINISHED even if it wrote prose instead of the block\n` +
-  `       • "CODEX_NOT_FOUND"          → companion missing\n` +
-  `       • the full 10-minute window has elapsed\n` +
-  `  4. Extract the findings with this EXACT command (deterministic — skips the [codex] trace + truncated echo, takes the LAST complete sentinel pair):\n` +
-  `       awk '/<<<FINDINGS_JSON>>>/{c=1;b="";next}/<<<END_FINDINGS_JSON>>>/{c=0;last=b;next}c{b=b $0 ORS}END{printf "%s",last}' ${codexReviewFile}\n` +
-  `  5. Decide the return — do NOT re-verify, re-grep, or Read any source file:\n` +
-  `       • awk output is a NON-EMPTY JSON array → parse it and return it verbatim as \`findings\`, codexAvailable:true (its keys already match the schema).\n` +
-  `       • awk output is EMPTY but the file has "Turn completed." → Codex FINISHED but wrote a prose report instead of the sentinel block. Do NOT parse findings out of the prose yourself (never guess a schema). Instead, capture the prose for the fallback to verify: run \`grep -v '^\\[codex\\]' ${codexReviewFile} | tail -c 12000\` and return codexAvailable:false, findings:[], codexProse:<that output>, then EXIT NOW (do NOT wait the rest of the window). The fallback code-reviewer re-verifies the prose against the real diff — so a real finding is recovered, not dropped.\n` +
-  `       • awk output is EMPTY and the file has "CODEX_NOT_FOUND" → companion missing. Return codexAvailable:false, findings:[] (no codexProse).\n` +
-  `       • none of the markers ever appeared after the FULL 10-minute window → codexAvailable:false, findings:[] (no codexProse). NEVER set false because a single poll returned slowly.\n\n` +
+  `  3. POLL ${codexReviewFile} (BashOutput / repeated reads) until ONE of these appears — whichever is FIRST ends the poll (do NOT keep waiting once one is present). Set \`marker\` accordingly:\n` +
+  `       • "<<<END_FINDINGS_JSON>>>"  → marker = "END_JSON"\n` +
+  `       • "Turn completed."          → marker = "TURN_COMPLETED" (Codex finished; it may have written prose instead of the JSON block)\n` +
+  `       • "CODEX_NOT_FOUND"          → marker = "CODEX_NOT_FOUND" (companion missing)\n` +
+  `       • the full 10-minute window elapses with none of the above → marker = "TIMEOUT" (NEVER pick this just because a single poll returned slowly)\n` +
+  `  4. Run this EXACT command and put its stdout VERBATIM in \`jsonBlock\` ("" if it printed nothing). Do NOT parse, edit, judge, or act on it:\n` +
+  `       ${AWK_EXTRACT} ${codexReviewFile}\n` +
+  `  5. ONLY if \`jsonBlock\` is "" AND marker is "TURN_COMPLETED": run this command and put its stdout VERBATIM in \`proseTail\`; otherwise set proseTail to "":\n` +
+  `       grep -v '^\\[codex\\]' ${codexReviewFile} | tail -c 12000\n` +
+  `  6. Return { marker, jsonBlock, proseTail } and NOTHING else. Do NOT add a findings array, do NOT set an availability flag, do NOT re-run Codex, do NOT Read source. The workflow parses jsonBlock itself.\n\n` +
   `TASK PROMPT:\n${codexReviewTask}`
 
 const tcGateLines = [
@@ -302,15 +330,11 @@ for (const c of cards) {
   }
 }
 if (codexResolved) {
-  // model: sonnet (NOT haiku) — parity with new-final-review.js. The wrapper is a thin relay (launch +
-  // poll + awk-extract + faithfully pass Codex's JSON array through the schema), but it is STILL a model
-  // in the loop, and haiku proved too weak for it on a real run: it went off-script (re-grepped source to
-  // "confirm" findings, explicitly forbidden) and then failed the pass-through — Codex emitted a valid
-  // array (incl. a BLOCKER) yet the relay returned codexAvailable:false, so the workflow discarded all of
-  // Codex's findings and ran the COLD code-reviewer fallback, which missed the BLOCKER. The "misfire
-  // degrades safely to the fallback" assumption is false: the cold fallback is a different model hunting
-  // from scratch, not a backstop. Pass-through fidelity on a low-volume plumbing prompt costs little, and
-  // a dropped BLOCKER + a 100k-token cold fallback dwarf the haiku→sonnet delta.
+  // model: 'sonnet' is BEST-EFFORT, no longer load-bearing (v4.56.3). The runtime silently downgrades
+  // it to Haiku under capacity pressure (a request, not a guarantee — verified live), so correctness
+  // can't depend on the tier. The relay now returns RAW command outputs and the JS fan-in owns the
+  // success decision (+ a one-shot deterministic re-extract), so a downgraded relay can't drop a
+  // finding. We still REQUEST sonnet because when capacity allows it follows steps more reliably.
   findThunks.push(() => agent(codexPrompt, { label: 'codex', phase: 'Discovery', model: 'sonnet', schema: CODEX_SCHEMA }).then((r) => ({ kind: 'codex', card: null, r })))
 }
 if (maxQaTier === 'full') {
@@ -329,12 +353,28 @@ let codexRan = false
 let codexProse = ''   // PROSE-ONLY salvage (v4.56.0): seeds the fallback so Codex's real finds aren't lost.
 for (const item of findResults) {
   if (item.kind === 'codex') {
-    if (item.r && item.r.codexAvailable && Array.isArray(item.r.findings)) {
+    // JS owns the success decision (v4.56.3) — never the relay model. Parse the raw jsonBlock:
+    // null = no recoverable JSON; [] = Codex ran clean; [..] = findings.
+    let cf = parseFindingsArray(item.r && item.r.jsonBlock)
+    let prose = item.r && typeof item.r.proseTail === 'string' ? item.r.proseTail.trim() : ''
+    // Re-extract ONLY when the relay gave neither JSON nor prose (the v4.56.2 failure). When it already
+    // returned prose, trust it — it read the same bytes the re-extract would (saves an agent per wave).
+    if (cf === null && !prose && item.r && item.r.marker !== 'CODEX_NOT_FOUND') {
+      // Re-extract deterministically from the on-disk file before conceding —
+      // grabbing BOTH the sentinel JSON and the prose (Codex usually writes prose, not the block). This
+      // makes prose capture JS-owned: a relay that returned empty proseTail can no longer strand the
+      // cold fallback unseeded (the v4.56.2 failure: empty codexProse → BLOCKER missed by cold review).
+      const re = await agent(reExtractPrompt(codexReviewFile), { label: 'codex-reextract', phase: 'Discovery', model: 'sonnet', schema: EXTRACT_SCHEMA })
+      cf = parseFindingsArray(re && re.jsonOut)
+      if (cf) log('Discovery: Codex JSON recovered by deterministic re-extraction.')
+      if (!cf && re && typeof re.proseOut === 'string' && re.proseOut.trim()) prose = re.proseOut.trim()
+    }
+    if (Array.isArray(cf)) {                 // parsed (incl. empty []) → Codex ran
       codexRan = true
-      raw.push(...item.r.findings.map((f) => ({ ...f, source: 'codex', preValidated: true })))
-    } else {
-      if (item.r && typeof item.r.codexProse === 'string' && item.r.codexProse.trim()) codexProse = item.r.codexProse.trim()
-      log(`Discovery: Codex companion resolved but its review did not complete${codexProse ? ' (prose-only — salvaging its findings as fallback leads)' : ''} — falling back to code-reviewer.`)
+      raw.push(...cf.map((f) => ({ ...f, source: 'codex', preValidated: true })))
+    } else {                                 // no JSON → seed the cold fallback with the prose leads
+      if (prose) codexProse = prose
+      log(`Discovery: Codex relay returned no parseable JSON (marker=${item.r && item.r.marker})${codexProse ? ' — salvaging its prose as fallback leads' : ''} — falling back to code-reviewer.`)
     }
   } else if (item.kind === 'qa') {
     gateTable = (item.r && item.r.gates) || []

package/framework/.claude/workflows/new-final-review.js

@@ -80,15 +80,42 @@ const FINDINGS_SCHEMA = {
   type: 'object', required: ['findings'], additionalProperties: false,
   properties: { findings: { type: 'array', items: FINDING }, note: { type: 'string' } },
 }
+// Haiku-proof relay contract (v4.56.3): the relay returns RAW command outputs — it does NOT decide
+// "codexAvailable" and does NOT parse findings. The JS fan-in owns the decision (parses jsonBlock
+// deterministically), so a weak/runtime-downgraded relay model can no longer drop a finding by
+// mis-judging availability — the bytes are on disk and the JS reads them. See the fan-in branch.
 const CODEX_SCHEMA = {
-  type: 'object', required: ['codexAvailable', 'findings'], additionalProperties: false,
+  type: 'object', required: ['marker', 'jsonBlock'], additionalProperties: false,
   properties: {
-    codexAvailable: { type: 'boolean', description: 'false if CODEX_NOT_FOUND / TIMED_OUT' },
-    findings: { type: 'array', items: FINDING },
-    codexProse: { type: 'string', description: 'PROSE-ONLY salvage (v4.56.0): when Codex FINISHED but emitted no sentinel JSON block, the cleaned tail of its prose review — handed to the fallback code-reviewer as UNVERIFIED leads. Empty/omitted otherwise.' },
+    marker: { type: 'string', enum: ['END_JSON', 'TURN_COMPLETED', 'CODEX_NOT_FOUND', 'TIMEOUT'], description: 'which terminator ended the poll' },
+    jsonBlock: { type: 'string', description: 'VERBATIM stdout of the awk extraction command (may be ""). The JS parses it — do NOT edit/judge.' },
+    proseTail: { type: 'string', description: 'VERBATIM stdout of the prose-tail command, ONLY when marker=TURN_COMPLETED with an empty jsonBlock; else "".' },
     note: { type: 'string' },
   },
 }
+// One-shot deterministic re-extraction over the on-disk file — independent of the relay's self-report.
+// Codex OFTEN ignores "emit ONLY the sentinel block" and writes a PROSE report ending in "Turn
+// completed." (verified on real companion output), so there's frequently NO JSON to extract and the
+// findings live in the prose. We therefore fetch BOTH: the sentinel JSON (awk) AND the prose tail.
+const EXTRACT_SCHEMA = {
+  type: 'object', required: ['jsonOut', 'proseOut'], additionalProperties: false,
+  properties: {
+    jsonOut: { type: 'string', description: 'verbatim stdout of the awk sentinel-extraction command, "" if none' },
+    proseOut: { type: 'string', description: 'verbatim stdout of the [codex]-stripped prose tail, "" if none' },
+  },
+}
+// Deterministic parse: null = no recoverable JSON array; [] = Codex ran clean (no findings); [..] = findings.
+const parseFindingsArray = (s) => {
+  if (typeof s !== 'string' || !s.trim()) return null
+  try { const v = JSON.parse(s.trim()); return Array.isArray(v) ? v : null } catch { return null }
+}
+// SSOT for the sentinel-extraction awk — used by BOTH the relay prompt and the re-extract agent.
+const AWK_EXTRACT = `awk '/<<<FINDINGS_JSON>>>/{c=1;b="";next}/<<<END_FINDINGS_JSON>>>/{c=0;last=b;next}c{b=b $0 ORS}END{printf "%s",last}'`
+const reExtractPrompt = (file) =>
+  `Run EXACTLY these TWO Bash commands and return their stdout VERBATIM. Run NOTHING else — do NOT Read the file beyond these commands, do NOT review code, do NOT reason about findings:\n` +
+  `  • jsonOut  = stdout of:  ${AWK_EXTRACT} ${file}\n` +
+  `  • proseOut = stdout of:  grep -v '^\\[codex\\]' ${file} | tail -c 12000\n` +
+  `Return { jsonOut, proseOut } and nothing else (empty string for either command that printed nothing).`
 const GATES_SCHEMA = {
   type: 'object', required: ['gates'], additionalProperties: false,
   properties: {
@@ -176,12 +203,14 @@ log(codexResolved
   ? `Codex companion resolved deterministically: ${codexScriptPath}`
   : 'Codex companion NOT found (deterministic pre-flight) — primary review via code-reviewer fallback.')
 
-// Codex companion review. The WRAPPER is a thin relay (model: sonnet — see the thunk): it launches
-// Codex, waits, and extracts Codex's JSON findings with a deterministic awk; it does NOT review or
-// re-verify code itself (Codex's findings are authoritative + FP-validated). Codex emits findings
-// between explicit sentinels so the extraction is unambiguous despite the companion's `[codex]` trace
-// and the truncated "Assistant message captured:" echo. Sonnet (not haiku) here because the Final is
-// the last cross-model gate before merge — no downstream Codex pass backstops a wrapper misfire.
+// Codex companion review. The relay LAUNCHES Codex, polls, and returns the RAW stdout of the
+// extraction commands — it does NOT review code, does NOT re-grep, and (since v4.56.3) does NOT
+// decide "did Codex succeed": the JS fan-in parses jsonBlock itself. The relay model is NOT
+// guaranteeable — `model:'sonnet'` is a request the runtime silently downgrades to Haiku under
+// capacity pressure — and the Final is the last cross-model gate before merge, so a dropped finding
+// here is unrecoverable. Moving the success decision out of the model (+ a one-shot deterministic
+// re-extract) makes the relay robust to WHATEVER model it lands on. Codex emits findings between
+// explicit sentinels so the awk is unambiguous despite the `[codex]` trace + truncated echo.
 const codexReviewTask =
   `Run a deep code review over this batch diff, per the /codexreview protocol in ${protocolRef} (Step F.3). The code is already written and committed — find bugs, regressions, security issues, and quality problems.\n\n` +
   `${scopeBrief}\n\n${baselineBrief}\n\n` +
@@ -198,24 +227,22 @@ const codexReviewTask =
 const codexTaskFile = `/tmp/codextask-batch-${a.firstCardId || 'batch'}.txt`
 const codexReviewFile = `/tmp/codexreview-batch-${a.firstCardId || 'batch'}.md`
 const codexPrompt =
-  `You are a THIN RELAY around the Codex companion — do NOT review or investigate code yourself, do NOT grep/sed/Read source to "confirm" findings (Codex's findings are authoritative and already FP-validated). Your ONLY job: launch Codex, wait, extract its JSON, return it.\n\n` +
+  `You DRIVE the Codex companion and return its RAW command outputs — you do NOT review or investigate code, do NOT grep/sed/Read source, and you do NOT decide whether Codex "succeeded" (the workflow decides that from the bytes you return). Launch Codex, poll, run the extraction commands, return their VERBATIM stdout.\n\n` +
   `The companion script is ALREADY CONFIRMED PRESENT at:\n  ${codexScriptPath}\n\n` +
   `Run EXACTLY these steps and nothing else:\n` +
   `  1. Write the task text (everything after "TASK PROMPT:" at the end of this message) to ${codexTaskFile} using the Write tool — do NOT inline it into the shell command (avoids quote breakage).\n` +
   `  2. Launch Codex in the BACKGROUND (run_in_background:true — a sync run hits the Bash timeout):\n` +
   `       node "${codexScriptPath}" task "$(cat ${codexTaskFile})" --cwd "${a.worktreePath || '.'}" > ${codexReviewFile} 2>&1\n` +
-  `  3. POLL ${codexReviewFile} (BashOutput / repeated reads) until it contains ANY of these — whichever appears FIRST ends the poll (do NOT keep waiting the full window once one is present):\n` +
-  `       • "<<<END_FINDINGS_JSON>>>"  → Codex emitted the JSON block (success path)\n` +
-  `       • "Turn completed."          → the companion's reliable end-of-run marker — Codex FINISHED even if it wrote prose instead of the block\n` +
-  `       • "CODEX_NOT_FOUND"          → companion missing\n` +
-  `       • the full 10-minute window has elapsed\n` +
-  `  4. Extract the findings with this EXACT command (deterministic — skips the [codex] trace + truncated echo, takes the LAST complete sentinel pair):\n` +
-  `       awk '/<<<FINDINGS_JSON>>>/{c=1;b="";next}/<<<END_FINDINGS_JSON>>>/{c=0;last=b;next}c{b=b $0 ORS}END{printf "%s",last}' ${codexReviewFile}\n` +
-  `  5. Decide the return — do NOT re-verify, re-grep, or Read any source file:\n` +
-  `       • awk output is a NON-EMPTY JSON array → parse it and return it verbatim as \`findings\`, codexAvailable:true (its keys already match the schema).\n` +
-  `       • awk output is EMPTY but the file has "Turn completed." → Codex FINISHED but wrote a prose report instead of the sentinel block. Do NOT parse findings out of the prose yourself (never guess a schema). Instead, capture the prose for the fallback to verify: run \`grep -v '^\\[codex\\]' ${codexReviewFile} | tail -c 12000\` and return codexAvailable:false, findings:[], codexProse:<that output>, then EXIT NOW (do NOT wait the rest of the window). The fallback code-reviewer re-verifies the prose against the real diff — so a real finding is recovered, not dropped.\n` +
-  `       • awk output is EMPTY and the file has "CODEX_NOT_FOUND" → companion missing. Return codexAvailable:false, findings:[] (no codexProse).\n` +
-  `       • none of the markers ever appeared after the FULL 10-minute window → codexAvailable:false, findings:[] (no codexProse). NEVER set false because a single poll returned slowly.\n\n` +
+  `  3. POLL ${codexReviewFile} (BashOutput / repeated reads) until ONE of these appears — whichever is FIRST ends the poll (do NOT keep waiting once one is present). Set \`marker\` accordingly:\n` +
+  `       • "<<<END_FINDINGS_JSON>>>"  → marker = "END_JSON"\n` +
+  `       • "Turn completed."          → marker = "TURN_COMPLETED" (Codex finished; it may have written prose instead of the JSON block)\n` +
+  `       • "CODEX_NOT_FOUND"          → marker = "CODEX_NOT_FOUND" (companion missing)\n` +
+  `       • the full 10-minute window elapses with none of the above → marker = "TIMEOUT" (NEVER pick this just because a single poll returned slowly)\n` +
+  `  4. Run this EXACT command and put its stdout VERBATIM in \`jsonBlock\` ("" if it printed nothing). Do NOT parse, edit, judge, or act on it:\n` +
+  `       ${AWK_EXTRACT} ${codexReviewFile}\n` +
+  `  5. ONLY if \`jsonBlock\` is "" AND marker is "TURN_COMPLETED": run this command and put its stdout VERBATIM in \`proseTail\`; otherwise set proseTail to "":\n` +
+  `       grep -v '^\\[codex\\]' ${codexReviewFile} | tail -c 12000\n` +
+  `  6. Return { marker, jsonBlock, proseTail } and NOTHING else. Do NOT add a findings array, do NOT set an availability flag, do NOT re-run Codex, do NOT Read source. The workflow parses jsonBlock itself.\n\n` +
   `TASK PROMPT:\n${codexReviewTask}`
 
 const docPrompt =
@@ -258,8 +285,10 @@ if (!slimDoc) {
 }
 // Codex thunk runs ONLY when the pre-flight resolved the companion (else: no wasted agent).
 if (codexResolved) {
-  // model: sonnet — thin relay (launch + poll + awk-extract), no self-investigation; sonnet (not haiku)
-  // because this is the last cross-model gate before merge (no downstream Codex pass backstops a misfire).
+  // model: 'sonnet' is BEST-EFFORT (v4.56.3) — the runtime silently downgrades it to Haiku under load,
+  // so correctness can't depend on the tier. The relay returns RAW outputs and the JS fan-in owns the
+  // success decision (+ a one-shot deterministic re-extract), so a downgraded relay can't drop a finding.
+  // We still REQUEST sonnet: this is the last cross-model gate before merge and a dropped find is final.
   reviewThunks.unshift(() => agent(codexPrompt, { label: 'codex', phase: 'Review', model: 'sonnet', schema: CODEX_SCHEMA }).then((r) => ({ kind: 'codex', r })))
 }
 // api-perf-cost-auditor: skipped when no API/data files OR when it already ran per-card (slimApi).
@@ -281,13 +310,28 @@ let codexRan = false
 let codexProse = ''   // PROSE-ONLY salvage (v4.56.0): seeds the fallback so Codex's real finds aren't lost.
 for (const item of reviewResults) {
   if (item.kind === 'codex') {
-    if (item.r && item.r.codexAvailable && Array.isArray(item.r.findings)) {
+    // JS owns the success decision (v4.56.3) — never the relay model. Parse the raw jsonBlock:
+    // null = no recoverable JSON; [] = Codex ran clean; [..] = findings.
+    let cf = parseFindingsArray(item.r && item.r.jsonBlock)
+    let prose = item.r && typeof item.r.proseTail === 'string' ? item.r.proseTail.trim() : ''
+    // Re-extract ONLY when the relay gave neither JSON nor prose (the v4.56.2 failure). When it already
+    // returned prose, trust it — it read the same bytes the re-extract would (saves an agent per batch).
+    if (cf === null && !prose && item.r && item.r.marker !== 'CODEX_NOT_FOUND') {
+      // Re-extract deterministically from the on-disk file before conceding —
+      // grabbing BOTH the sentinel JSON and the prose (Codex usually writes prose, not the block). This
+      // makes prose capture JS-owned: a relay that returned empty proseTail can no longer strand the
+      // cold fallback unseeded (the v4.56.2 failure: empty codexProse → BLOCKER missed by cold review).
+      const re = await agent(reExtractPrompt(codexReviewFile), { label: 'codex-reextract', phase: 'Review', model: 'sonnet', schema: EXTRACT_SCHEMA })
+      cf = parseFindingsArray(re && re.jsonOut)
+      if (cf) log('Review: Codex JSON recovered by deterministic re-extraction.')
+      if (!cf && re && typeof re.proseOut === 'string' && re.proseOut.trim()) prose = re.proseOut.trim()
+    }
+    if (Array.isArray(cf)) {                 // parsed (incl. empty []) → Codex ran
       codexRan = true
-      raw.push(...item.r.findings.map((f) => ({ ...f, source: 'codex', preValidated: true })))
-    } else {
-      // Resolved but the run itself failed (CODEX_NOT_FOUND written / empty / prose-only after timeout).
-      if (item.r && typeof item.r.codexProse === 'string' && item.r.codexProse.trim()) codexProse = item.r.codexProse.trim()
-      log(`Review: Codex companion resolved but its review did not complete${codexProse ? ' (prose-only — salvaging its findings as fallback leads)' : ''} — falling back to code-reviewer.`)
+      raw.push(...cf.map((f) => ({ ...f, source: 'codex', preValidated: true })))
+    } else {                                 // no JSON → seed the cold fallback with the prose leads
+      if (prose) codexProse = prose
+      log(`Review: Codex relay returned no parseable JSON (marker=${item.r && item.r.marker})${codexProse ? ' — salvaging its prose as fallback leads' : ''} — falling back to code-reviewer.`)
     }
   } else if (item.kind === 'qa') {
     gateTable = (item.r && item.r.gates) || []

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baldart",
-  "version": "4.56.2",
+  "version": "4.56.3",
   "description": "Claude Agent Framework - Reusable framework for coordinating AI agents and humans in software projects",
   "bin": {
     "baldart": "./bin/baldart.js"