@kontourai/flow-agents 4.2.0 → 4.2.1

package/scripts/hooks/lib/codex-exit-code.js

@@ -113,10 +113,13 @@ function normalizeCallArguments(argumentsField) {
     }
   }
   if (!parsed || typeof parsed !== 'object') return null;
-  return normalizeCommandText(parsed.command);
+  // Codex records exec_command arguments under `cmd`; older shell fixtures
+  // and some adapters use `command`.
+  return normalizeCommandText(parsed.cmd) || normalizeCommandText(parsed.command);
 }
 
 const OUTPUT_FIELD_NEEDLE = '"output":"';
+const COMMAND_FUNCTION_NAMES = new Set(['exec_command', 'shell']);
 
 /**
  * parseCandidateLine(line, maxLineHeadBytes) → candidate | null
@@ -149,7 +152,15 @@ function parseCandidateLine(line, maxLineHeadBytes) {
       return { type: 'function_call_output', callId, output: payload.output };
     }
     if (payload.type === 'function_call') {
-      return { type: 'function_call', callId, command: normalizeCallArguments(payload.arguments) };
+      const name = typeof payload.name === 'string' && payload.name.trim() ? payload.name.trim() : null;
+      const command = normalizeCallArguments(payload.arguments);
+      const commandCapable = name === null || COMMAND_FUNCTION_NAMES.has(name) || command !== null;
+      return {
+        type: 'function_call',
+        callId,
+        commandCapable,
+        command,
+      };
     }
     return null;
   }
@@ -214,13 +225,12 @@ function resolveContainedRealPath(transcriptPath) {
  * Correlation policy (Decision B, #470 iteration 2, HIGH finding #4), in
  * priority order:
  *   1. call_id match wins — authoritative.
- *   2. Absent a call_id match: take the newest `function_call_output` in the
- *      scanned window, resolve its paired `function_call` (same call_id), and
- *      compare that call's `arguments` command (normalized) to `command`. A
- *      resolved MATCH uses the newest output; a resolved MISMATCH DECLINES
- *      (`null`) rather than knowingly attribute a different call's exit code.
- *   3. If no pairing is resolvable at all (the common single-call case): fall
- *      back to the newest `function_call_output` banner.
+ *   2. Absent a call_id match: pair outputs with calls by rollout call_id and
+ *      select the only pair whose normalized arguments match `command`. Zero
+ *      matches or multiple matches DECLINE (`null`) rather than attribute a
+ *      neighboring or repeated command's exit code.
+ *   3. If no pairing is resolvable at all and the rollout contains exactly one
+ *      output with no function call, use that genuinely unpaired legacy output.
  *
  * Any failure (missing/unreadable/non-regular file, containment violation,
  * malformed JSON lines, no candidate found) yields `null` — never throws.
@@ -271,41 +281,83 @@ function readExitCodeFromRollout(transcriptPath, options) {
   }
   if (truncated && lines.length > 1) lines.shift();
 
-  let matchedByCallId = null;
+  const outputsByRequestedCallId = [];
   let newestOutputEntry = null;
-  let pairedCommand = null;
+  const outputEntries = [];
+  const commandByCallId = new Map();
+  const seenFunctionCallIds = new Set();
+  const ambiguousCallIds = new Set();
+  let functionCallCount = 0;
+  let sawUnclassifiableLine = false;
+  let sawUnresolvableFunctionCall = false;
 
   for (let i = lines.length - 1; i >= 0; i--) {
     const line = lines[i].trim();
     if (!line) continue;
     const candidate = parseCandidateLine(line, maxLineHeadBytes);
-    if (!candidate) continue; // malformed/partial/unrecognized line — skip, keep scanning
+    if (!candidate) {
+      if (Buffer.byteLength(line, 'utf8') > maxLineHeadBytes) {
+        sawUnclassifiableLine = true;
+      } else {
+        try {
+          JSON.parse(line); // valid non-candidate events do not poison correlation
+        } catch {
+          sawUnclassifiableLine = true;
+        }
+      }
+      continue; // malformed/partial/unrecognized line — skip, keep scanning
+    }
 
     if (candidate.type === 'function_call_output') {
+      outputEntries.push(candidate); // scan order is newest to oldest
       if (newestOutputEntry === null) newestOutputEntry = candidate; // first seen scanning backward = newest
       if (callId && candidate.callId === callId) {
-        matchedByCallId = candidate;
-        break; // call_id match is authoritative — stop scanning
+        outputsByRequestedCallId.push(candidate);
       }
     } else if (candidate.type === 'function_call') {
-      if (newestOutputEntry && pairedCommand === null && candidate.callId === newestOutputEntry.callId) {
-        pairedCommand = candidate.command;
+      functionCallCount += 1;
+      if (candidate.callId) {
+        if (seenFunctionCallIds.has(candidate.callId)) ambiguousCallIds.add(candidate.callId);
+        else seenFunctionCallIds.add(candidate.callId);
+      }
+      if (candidate.commandCapable && candidate.callId && candidate.command !== null) {
+        if (!commandByCallId.has(candidate.callId)) commandByCallId.set(candidate.callId, candidate.command);
+      } else if (candidate.commandCapable) {
+        sawUnresolvableFunctionCall = true;
       }
     }
   }
 
   let chosenOutput = null;
-  if (matchedByCallId) {
-    chosenOutput = matchedByCallId.output;
+  if ((callId || command) && sawUnclassifiableLine) return null;
+  if (callId) {
+    if (outputsByRequestedCallId.length === 1 && !ambiguousCallIds.has(callId)) {
+      chosenOutput = outputsByRequestedCallId[0].output;
+    } else {
+      return null; // explicit call ID is unresolved, reused, or has duplicate outputs
+    }
   } else if (newestOutputEntry) {
-    if (pairedCommand !== null && command) {
-      if (pairedCommand === command) {
-        chosenOutput = newestOutputEntry.output;
+    if (command) {
+      if (sawUnresolvableFunctionCall) return null;
+      const matchingCallIds = [...commandByCallId.entries()]
+        .filter(([, candidateCommand]) => candidateCommand === command)
+        .map(([candidateCallId]) => candidateCallId);
+      const matches = outputEntries.filter((entry) => commandByCallId.get(entry.callId) === command);
+      if (matchingCallIds.length === 1
+        && !ambiguousCallIds.has(matchingCallIds[0])
+        && matches.length === 1) {
+        chosenOutput = matches[0].output;
+      } else if (matchingCallIds.length > 0 || matches.length > 0 || commandByCallId.size > 0) {
+        return null; // no unique command correlation
+      } else if (!truncated && outputEntries.length === 1 && functionCallCount === 0) {
+        chosenOutput = newestOutputEntry.output; // genuinely unpaired legacy fallback
       } else {
-        return null; // positive command mismatch — decline rather than mis-attribute
+        return null; // multi-call or partially paired tail
       }
+    } else if (!truncated && outputEntries.length === 1 && functionCallCount === 0) {
+      chosenOutput = newestOutputEntry.output; // genuinely unpaired legacy fallback
     } else {
-      chosenOutput = newestOutputEntry.output; // single-call fallback — no pairing resolvable
+      return null; // no correlation signal for a paired or multi-call tail
     }
   }
 

package/src/builder-flow-runtime.ts

@@ -710,7 +710,7 @@ async function bundleGateEvidence(
     throw new BuilderBuildRunInputError("evidence.claims.metadata.gate_claim.route_reason", `is not declared by gate ${String((gate as AnyRecord).id ?? "<unknown>")}`);
   }
   if (String((gate as AnyRecord).id) === "verify-gate" && relevant.some((claim) => claim.claimType === "builder.verify.tests" && claim.value === "pass")) {
-    await assertVerifiedTestsTrust(bundle.claims, projectRoot);
+    await assertVerifiedTestsTrust(relevant, projectRoot);
   }
   return { failed, routeReason, expectationIds, visitEnteredAt: enteredAt };
 }
@@ -739,15 +739,20 @@ function timestampAtOrAfter(value: unknown, boundary: number): boolean {
   return parsed !== null && parsed >= boundary;
 }
 
-async function assertVerifiedTestsTrust(claims: unknown[], projectRoot: string): Promise<void> {
-  const testClaims = claims.filter((claim): claim is AnyRecord => isRecord(claim)
+async function assertVerifiedTestsTrust(currentGateClaims: AnyRecord[], projectRoot: string): Promise<void> {
+  const testClaims = currentGateClaims.filter((claim): claim is AnyRecord => isRecord(claim)
     && claim.claimType === "builder.verify.tests"
     && claim.value === "pass"
     && isRecord(claim.metadata)
     && isRecord(claim.metadata.gate_claim)
     && claim.metadata.gate_claim.expectation_id === "tests-evidence");
   if (testClaims.length === 0) throw new BuilderBuildRunInputError("evidence.tests", "is missing a passing tests-evidence claim");
-  const liveCritiques = claims.filter((claim): claim is AnyRecord => isRecord(claim)
+  // A route-back starts a new gate visit and therefore a new critique generation. Historical
+  // reviewer slices remain in the bundle and manifest for audit, but only critiques acquired
+  // during this visit describe the implementation snapshot currently being verified. Within a
+  // visit every live reviewer slice still participates, so changing reviewers cannot bury a
+  // disputed finding.
+  const liveCritiques = currentGateClaims.filter((claim): claim is AnyRecord => isRecord(claim)
     && isRecord(claim.metadata)
     && claim.metadata.origin === "critique"
     && typeof claim.metadata.superseded_by !== "string");
@@ -763,7 +768,7 @@ async function assertVerifiedTestsTrust(claims: unknown[], projectRoot: string):
     await Promise.all(artifacts.map((artifact) => assertReviewedArtifactDigest(artifact, projectRoot)));
     assertReviewedWorkspaceSnapshot(claim, artifacts, projectRoot);
   }));
-  const criteria = claims.filter((claim): claim is AnyRecord => isRecord(claim) && isRecord(claim.metadata) && claim.metadata.origin === "acceptance");
+  const criteria = currentGateClaims.filter((claim): claim is AnyRecord => isRecord(claim) && isRecord(claim.metadata) && claim.metadata.origin === "acceptance");
   if (criteria.length === 0 || criteria.some((claim) => {
     const criterion = isRecord(claim.metadata.criterion) ? claim.metadata.criterion : null;
     return claim.value !== "pass" || !criterion || !Array.isArray(criterion.evidence_refs) || criterion.evidence_refs.length === 0;

package/src/cli/builder-flow-runtime.test.mjs

@@ -1382,6 +1382,8 @@ test("failed verification projects Flow-owned route-back attempt and budget", as
   assert.equal(verify.run.state.current_step, "verify");
 
   const failureTimestamp = new Date().toISOString();
+  const initialPrerequisites = verifiedTestsPrerequisites(session, failureTimestamp);
+  initialPrerequisites[0].claim.metadata.reviewer = "reviewer-before-route-back";
   const routed = await writeAndSync(session, [bundleClaim({
     expectation: "tests-evidence",
     claimType: "builder.verify.tests",
@@ -1389,7 +1391,7 @@ test("failed verification projects Flow-owned route-back attempt and budget", as
     status: "fail",
     routeReason: "implementation_defect",
     timestamp: failureTimestamp,
-  }), ...verifiedTestsPrerequisites(session, failureTimestamp)]);
+  }), ...initialPrerequisites]);
 
   assert.equal(routed.run.state.current_step, "execute");
   assert.equal(routed.projection.flow_run.route_back_attempt, 1);
@@ -1415,15 +1417,66 @@ test("failed verification projects Flow-owned route-back attempt and budget", as
   assert.equal(staleRetry.attached, false);
   assert.equal(staleRetry.run.state.current_step, "verify");
   assert.equal(staleRetry.run.state.transitions.filter((transition) => transition.type === "route_back").length, 1);
+  fs.writeFileSync(path.join(session.projectRoot, "review-target", "delivery.md"), "corrected delivery after route-back\n");
   const correctedAt = new Date(Date.parse(reentered.run.state.transitions.at(-1).at) + 1).toISOString();
+  const correctedPrerequisites = verifiedTestsPrerequisites(session, correctedAt)
+    .map((entry, index) => withIdentitySuffix(entry, `corrected-${index}`));
+  correctedPrerequisites[0].claim.metadata.reviewer = "reviewer-after-route-back";
   const corrected = await writeAndSync(session, [
     withIdentitySuffix(bundleClaim({ expectation: "tests-evidence", claimType: "builder.verify.tests", subjectType: "flow-step", timestamp: correctedAt }), "corrected"),
-    ...verifiedTestsPrerequisites(session, correctedAt).map((entry, index) => withIdentitySuffix(entry, `corrected-${index}`)),
+    ...correctedPrerequisites,
+    // Compose-safe writers preserve this older reviewer's still-live PASS slice. It targets the
+    // prior implementation bytes and must remain audit history without deadlocking the new gate
+    // visit or requiring the new reviewer to impersonate the old one.
+    initialPrerequisites[0],
   ]);
   assert.equal(corrected.run.state.current_step, "merge-ready");
   const verifyEvidence = corrected.run.manifest.evidence.filter((entry) => entry.gate_id === "verify-gate");
   assert.equal(verifyEvidence.length, 2);
   assert.equal(verifyEvidence[0].superseded_by, verifyEvidence[1].id);
+  const retainedCritiques = readJson(path.join(session.sessionDir, "trust.bundle")).claims
+    .filter((claim) => claim.metadata?.origin === "critique" && !claim.metadata.superseded_by);
+  assert.deepEqual(retainedCritiques.map((claim) => claim.metadata.reviewer).sort(), [
+    "reviewer-after-route-back",
+    "reviewer-before-route-back",
+  ]);
+});
+
+test("a different passing reviewer cannot hide a disputed critique in the same gate visit", async () => {
+  const session = makeSession("same-visit-reviewer-handoff");
+  await startBuilderFlowSession({ sessionDir: session.sessionDir });
+  await writeAndSync(session, [bundleClaim({ expectation: "selected-work", claimType: "builder.pull-work.selected", subjectType: "work-item" })]);
+  await writeAndSync(session, [
+    bundleClaim({ expectation: "pickup-probe-readiness", claimType: "builder.design-probe.pickup-readiness", subjectType: "work-item" }),
+    bundleClaim({ expectation: "probe-decisions-or-accepted-gaps", claimType: "builder.design-probe.decisions", subjectType: "decision" }),
+  ]);
+  await writeAndSync(session, [bundleClaim({ expectation: "implementation-plan", claimType: "builder.plan.implementation", subjectType: "artifact" })]);
+  await writeAndSync(session, [bundleClaim({ expectation: "implementation-scope", claimType: "builder.execute.scope", subjectType: "change" })]);
+
+  const timestamp = new Date().toISOString();
+  const prerequisites = verifiedTestsPrerequisites(session, timestamp);
+  prerequisites[0].claim.metadata.reviewer = "passing-reviewer";
+  const disputedCritique = withIdentitySuffix(structuredClone(prerequisites[0]), "disputed-reviewer");
+  disputedCritique.claim.value = "fail";
+  disputedCritique.claim.status = "disputed";
+  disputedCritique.claim.metadata.reviewer = "disputed-reviewer";
+  disputedCritique.claim.metadata.lanes = [{ id: "code", status: "fail" }];
+  disputedCritique.claim.metadata.findings = [{ id: "unresolved", status: "open", severity: "high" }];
+  disputedCritique.event.status = "disputed";
+
+  const blocked = await writeAndSync(session, [
+    bundleClaim({ expectation: "tests-evidence", claimType: "builder.verify.tests", subjectType: "flow-step", timestamp }),
+    ...prerequisites,
+    disputedCritique,
+  ]);
+  assert.equal(blocked.attached, false);
+  assert.equal(blocked.run.state.current_step, "verify");
+  const retainedCritiques = readJson(path.join(session.sessionDir, "trust.bundle")).claims
+    .filter((claim) => claim.metadata?.origin === "critique" && !claim.metadata.superseded_by);
+  assert.deepEqual(retainedCritiques.map((claim) => [claim.metadata.reviewer, claim.value]).sort(), [
+    ["disputed-reviewer", "fail"],
+    ["passing-reviewer", "pass"],
+  ]);
 });
 
 test("producer-superseded FAIL is audit history and live PASS drives verify", async () => {

package/src/cli/codex-exit-code.test.mjs

@@ -55,6 +55,22 @@ function functionCall(callId, command) {
   };
 }
 
+function execCommandCall(callId, cmd) {
+  return {
+    timestamp: "2026-07-06T00:00:00Z",
+    type: "response_item",
+    payload: { type: "function_call", call_id: callId, name: "exec_command", arguments: JSON.stringify({ cmd }) },
+  };
+}
+
+function functionToolCall(callId, name, args) {
+  return {
+    timestamp: "2026-07-06T00:00:00Z",
+    type: "response_item",
+    payload: { type: "function_call", call_id: callId, name, arguments: JSON.stringify(args) },
+  };
+}
+
 // --- extractExitCodeFromBanner: preamble-anchored (CRITICAL finding #1) ---
 
 test("extractExitCodeFromBanner: forgery in post-Output: stdout is ignored (preamble wins)", () => {
@@ -95,7 +111,7 @@ test("readExitCodeFromRollout: malformed JSONL lines are skipped, valid entry st
 
 // --- truncation arithmetic (HEAD-anchored bounded scan, MEDIUM finding #5) ---
 
-test("readExitCodeFromRollout: target line near EOF still found when file exceeds the scan window", () => {
+test("readExitCodeFromRollout: call-id target near EOF is found when file exceeds the scan window", () => {
   const filler = [];
   for (let i = 0; i < 60; i++) filler.push({ timestamp: "2026-07-06T00:00:00Z", type: "turn_context", payload: {} });
   const target = functionCallOutput("call_1", "Process exited with code 1\nOutput:\n...");
@@ -106,7 +122,7 @@ test("readExitCodeFromRollout: target line near EOF still found when file exceed
   // Window smaller than the whole file (forces truncation) but comfortably
   // larger than the target line itself.
   const maxScanBytes = targetLineBytes + 50;
-  assert.equal(readExitCodeFromRollout(file, { maxScanBytes }), 1);
+  assert.equal(readExitCodeFromRollout(file, { callId: "call_1", maxScanBytes }), 1);
 });
 
 test("readExitCodeFromRollout: target line start beyond maxScanBytes yields null (never mis-reads a fragment)", () => {
@@ -130,6 +146,15 @@ test("readExitCodeFromRollout: call_id match wins over the newer entry", () => {
   assert.equal(readExitCodeFromRollout(file, { callId: "call_b" }), 5);
 });
 
+test("readExitCodeFromRollout: an unresolved explicit call_id never downgrades to command matching", () => {
+  const file = writeRollout([
+    execCommandCall("call_other", "npm test"),
+    functionCallOutput("call_other", "Process exited with code 0\nOutput:\n..."),
+  ]);
+
+  assert.equal(readExitCodeFromRollout(file, { callId: "call_missing", command: "npm test" }), null);
+});
+
 // --- command cross-check correlation (Decision B #2, HIGH finding #4) ---
 
 test("readExitCodeFromRollout: command cross-check mismatch declines to null", () => {
@@ -148,6 +173,196 @@ test("readExitCodeFromRollout: command cross-check match uses the correlated ent
   assert.equal(readExitCodeFromRollout(file, { command: "npm run lint" }), 1);
 });
 
+test("readExitCodeFromRollout: Codex exec_command cmd argument correlates the result", () => {
+  const file = writeRollout([
+    execCommandCall("call_1", "npm run lint"),
+    functionCallOutput("call_1", "Process exited with code 1\nOutput:\n..."),
+  ]);
+  assert.equal(readExitCodeFromRollout(file, { command: "npm run lint" }), 1);
+  assert.equal(readExitCodeFromRollout(file, { command: "npm test" }), null);
+});
+
+test("readExitCodeFromRollout: parallel call cannot inherit the previous call result", () => {
+  const file = writeRollout([
+    execCommandCall("call_pass", "find seed -type f"),
+    execCommandCall("call_fail", "cat seed/src/window.js"),
+    functionCallOutput("call_pass", "Process exited with code 0\nOutput:\n..."),
+  ]);
+
+  assert.equal(readExitCodeFromRollout(file, { command: "find seed -type f" }), 0);
+  assert.equal(readExitCodeFromRollout(file, { command: "cat seed/src/window.js" }), null);
+});
+
+test("readExitCodeFromRollout: parallel outputs correlate to their exact commands", () => {
+  const file = writeRollout([
+    execCommandCall("call_pass", "find seed -type f"),
+    execCommandCall("call_fail", "cat seed/src/window.js"),
+    functionCallOutput("call_pass", "Process exited with code 0\nOutput:\n..."),
+    functionCallOutput("call_fail", "Process exited with code 1\nOutput:\n..."),
+  ]);
+
+  assert.equal(readExitCodeFromRollout(file, { command: "find seed -type f" }), 0);
+  assert.equal(readExitCodeFromRollout(file, { command: "cat seed/src/window.js" }), 1);
+});
+
+test("readExitCodeFromRollout: repeated parallel command text is ambiguous without call_id", () => {
+  const file = writeRollout([
+    execCommandCall("call_a", "npm test"),
+    execCommandCall("call_b", "npm test"),
+    functionCallOutput("call_a", "Process exited with code 0\nOutput:\n..."),
+    functionCallOutput("call_b", "Process exited with code 1\nOutput:\n..."),
+  ]);
+
+  assert.equal(readExitCodeFromRollout(file, { command: "npm test" }), null);
+  assert.equal(readExitCodeFromRollout(file, { callId: "call_a", command: "npm test" }), 0);
+  assert.equal(readExitCodeFromRollout(file, { callId: "call_b", command: "npm test" }), 1);
+});
+
+test("readExitCodeFromRollout: a repeated call without its output cannot reuse an older result", () => {
+  const file = writeRollout([
+    execCommandCall("call_old", "npm test"),
+    functionCallOutput("call_old", "Process exited with code 0\nOutput:\n..."),
+    execCommandCall("call_current", "npm test"),
+  ]);
+
+  assert.equal(readExitCodeFromRollout(file, { command: "npm test" }), null);
+});
+
+test("readExitCodeFromRollout: unresolved multi-call tail never falls back to newest output", () => {
+  const file = writeRollout([
+    {
+      timestamp: "2026-07-06T00:00:00Z",
+      type: "response_item",
+      payload: { type: "function_call", call_id: "call_a", name: "unknown", arguments: "not-json" },
+    },
+    functionCallOutput("call_a", "Process exited with code 0\nOutput:\n..."),
+    functionCallOutput("call_b", "Process exited with code 1\nOutput:\n..."),
+  ]);
+
+  assert.equal(readExitCodeFromRollout(file, { command: "npm test" }), null);
+  assert.equal(readExitCodeFromRollout(file, {}), null);
+});
+
+test("readExitCodeFromRollout: malformed function call cannot make an output look unpaired", () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "codex-exit-code-"));
+  const file = path.join(dir, "rollout.jsonl");
+  const output = JSON.stringify(functionCallOutput("call_old", "Process exited with code 0\nOutput:\n..."));
+  fs.writeFileSync(file, `${output}\n{"payload":{"type":"function_call","call_id":"call_current"\n`);
+
+  assert.equal(readExitCodeFromRollout(file, { command: "npm test" }), null);
+});
+
+test("readExitCodeFromRollout: truncated call context cannot make an output look unpaired", () => {
+  const output = functionCallOutput("call_old", "Process exited with code 7\nOutput:\n...");
+  const file = writeRollout([functionCall("call_old", "npm run lint"), output]);
+  const outputLineBytes = Buffer.byteLength(JSON.stringify(output), "utf8") + 1;
+
+  assert.equal(readExitCodeFromRollout(file, {
+    command: "npm test",
+    maxScanBytes: outputLineBytes + 10,
+  }), null);
+});
+
+test("readExitCodeFromRollout: reused call IDs are ambiguous", () => {
+  const file = writeRollout([
+    execCommandCall("same", "npm test"),
+    execCommandCall("same", "npm run lint"),
+    functionCallOutput("same", "Process exited with code 9\nOutput:\n..."),
+  ]);
+
+  assert.equal(readExitCodeFromRollout(file, { command: "npm test" }), null);
+  assert.equal(readExitCodeFromRollout(file, { command: "npm run lint" }), null);
+});
+
+test("readExitCodeFromRollout: an unresolvable current call blocks historical command reuse", () => {
+  const file = writeRollout([
+    execCommandCall("call_old", "npm test"),
+    functionCallOutput("call_old", "Process exited with code 0\nOutput:\n..."),
+    {
+      timestamp: "2026-07-06T00:00:01Z",
+      type: "response_item",
+      payload: { type: "function_call", call_id: "call_current", name: "exec_command", arguments: "not-json" },
+    },
+  ]);
+
+  assert.equal(readExitCodeFromRollout(file, { command: "npm test" }), null);
+});
+
+test("readExitCodeFromRollout: malformed duplicate call IDs remain ambiguous", () => {
+  const file = writeRollout([
+    execCommandCall("same", "npm test"),
+    {
+      timestamp: "2026-07-06T00:00:01Z",
+      type: "response_item",
+      payload: { type: "function_call", call_id: "same", name: "exec_command", arguments: "not-json" },
+    },
+    functionCallOutput("same", "Process exited with code 9\nOutput:\n..."),
+  ]);
+
+  assert.equal(readExitCodeFromRollout(file, { callId: "same", command: "npm test" }), null);
+  assert.equal(readExitCodeFromRollout(file, { command: "npm test" }), null);
+});
+
+test("readExitCodeFromRollout: malformed JSON blocks historical and explicit-id correlation", () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "codex-exit-code-"));
+  const file = path.join(dir, "rollout.jsonl");
+  const call = JSON.stringify(execCommandCall("same", "npm test"));
+  const output = JSON.stringify(functionCallOutput("same", "Process exited with code 0\nOutput:\n..."));
+  fs.writeFileSync(file, `${call}\n${output}\n{"payload":{"type":"function_call","call_id":"same"\n`);
+
+  assert.equal(readExitCodeFromRollout(file, { command: "npm test" }), null);
+  assert.equal(readExitCodeFromRollout(file, { callId: "same", command: "npm test" }), null);
+});
+
+test("readExitCodeFromRollout: a partial function-call token blocks historical correlation", () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "codex-exit-code-"));
+  const file = path.join(dir, "rollout.jsonl");
+  const call = JSON.stringify(execCommandCall("old", "npm test"));
+  const output = JSON.stringify(functionCallOutput("old", "Process exited with code 0\nOutput:\n..."));
+  fs.writeFileSync(file, `${call}\n${output}\n{"payload":{"type":"function_cal\n`);
+
+  assert.equal(readExitCodeFromRollout(file, { command: "npm test" }), null);
+});
+
+test("readExitCodeFromRollout: unrelated function tools do not poison exact command correlation", () => {
+  const file = writeRollout([
+    functionToolCall("patch_call", "apply_patch", { patch: "*** Begin Patch" }),
+    execCommandCall("command_call", "npm test"),
+    functionCallOutput("command_call", "Process exited with code 0\nOutput:\n..."),
+  ]);
+
+  assert.equal(readExitCodeFromRollout(file, { command: "npm test" }), 0);
+});
+
+test("readExitCodeFromRollout: nameless command-shaped calls participate in ambiguity checks", () => {
+  const file = writeRollout([
+    execCommandCall("old", "npm test"),
+    functionCallOutput("old", "Process exited with code 0\nOutput:\n..."),
+    functionToolCall("current", null, { cmd: "npm test" }),
+    functionCallOutput("current", "Process exited with code 1\nOutput:\n..."),
+  ]);
+
+  assert.equal(readExitCodeFromRollout(file, { command: "npm test" }), null);
+  assert.equal(readExitCodeFromRollout(file, { callId: "current", command: "npm test" }), 1);
+});
+
+test("readExitCodeFromRollout: semantically nameless malformed calls block historical command reuse", () => {
+  for (const name of [null, "", "   "]) {
+    const file = writeRollout([
+      execCommandCall("old", "npm test"),
+      functionCallOutput("old", "Process exited with code 0\nOutput:\n..."),
+      {
+        timestamp: "2026-07-06T00:00:01Z",
+        type: "response_item",
+        payload: { type: "function_call", call_id: "current", name, arguments: "not-json" },
+      },
+      functionCallOutput("current", "Process exited with code 1\nOutput:\n..."),
+    ]);
+
+    assert.equal(readExitCodeFromRollout(file, { command: "npm test" }), null);
+  }
+});
+
 test("readExitCodeFromRollout: no resolvable pairing falls back to the newest banner (single-call case)", () => {
   const file = writeRollout([
     functionCallOutput("call_1", "Process exited with code 1\nOutput:\n..."),