@link-assistant/hive-mind 2.11.9 → 2.11.11

package/CHANGELOG.md

@@ -1,5 +1,63 @@
 # @link-assistant/hive-mind
 
+## 2.11.11
+
+### Patch Changes
+
+- 36e7976: Keep stream provenance on mirrored agent output and make the Codex completion
+  gate explain itself (issue #2140).
+
+  A `solve --tool codex` run that had finished its work — PR updated, all 46
+  check-runs green, `turn.completed` received — was still failed by the completion
+  gate with `turn.started=3, turn.completed=1`. Replaying the real 96k-line log
+  through the parser shows the two extra `turn.started` records arrived on Codex's
+  **stderr**, inside an OTEL `codex.tool_result` dump of a command that merely read
+  a stored NDJSON log file from disk. This is the issue #2136 defect on a binary
+  released minutes before that fix shipped; current builds already gate correctly.
+  Three residual gaps remain, and this change closes them:
+
+  - `log()` accepted an `options.stream` hint and silently discarded it, so every
+    agent CLI's mirrored output — both streams, all five tools — was written as
+    `[INFO]` on our stdout. It is now tagged `[STDOUT]` / `[STDERR]`, matching the
+    tags the stdio interceptor already uses, and mirrored stderr goes to our
+    stderr so piping stdout yields only what the child wrote there. An explicit
+    `level` still wins, and callers that pass no stream are unchanged.
+  - `codex exec` starts exactly one thread, so a `thread.started` on the protocol
+    stream announcing a different `thread_id` is proof of echoed output. Those ids
+    are now collected and reported (`🧬 Foreign thread IDs seen on the codex
+protocol stream`).
+  - The completion-failure reason carried counts and nothing else, which made a
+    false positive impossible to refute from the posted comment. It now also
+    states the ordered turn lifecycle, how many `turn.started` records were
+    discarded as echoed telemetry, and any foreign thread id seen.
+
+  No gate outcome changes: a genuinely truncated turn still fails, and a completed
+  run with echoed events still passes.
+
+## 2.11.10
+
+### Patch Changes
+
+- 8c8844a: Stop treating agent CLI stderr as a JSON protocol stream (issue #2136).
+
+  `codex exec --json` writes its NDJSON protocol to stdout only; its stderr carries
+  OTEL tracing whose `codex.tool_result` records dump the raw stdout of every
+  command Codex runs. When the task itself drove another agent CLI, that dump
+  replayed NDJSON byte-identical to Codex's own protocol, so an echoed
+  `turn.started` was counted as Codex's own and the completion gate failed a run
+  that had actually finished — posting a "Solution Draft Failed" comment on a pull
+  request that was complete and later merged.
+
+  Codex now parses only stdout as protocol; protocol-shaped JSON seen on stderr is
+  reported separately (`🪞 Echoed protocol-shaped lines on codex stderr`) and never
+  affects event counts, session id, token usage or error detection. The completion
+  gate additionally uses the ordered turn lifecycle (`🔁 Codex turn lifecycle`)
+  instead of comparing counts, so a stray `turn.started` can no longer fail a
+  completed run while a genuinely truncated turn still does. The same stream
+  separation is applied to qwen (whose stderr echo could raise a false error and
+  whose two streams shared one line buffer), and OpenCode now reports how many JSON
+  records it parsed from stderr.
+
 ## 2.11.9
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "2.11.9",
+  "version": "2.11.11",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/claude.lib.mjs

@@ -1009,7 +1009,7 @@ export const executeClaudeCommand = async params => {
               }
               // Not JSON or parsing failed, output as-is if it's not empty
               if (line.trim() && !line.includes('node:internal')) {
-                await log(line, { stream: 'raw' });
+                await log(line, { stream: 'stdout' });
                 lastMessage = line;
                 // Issue #1015: Detect terms acceptance prompt (non-JSON "[ACTION REQUIRED]..." message)
                 const termsAcceptancePattern = /\[ACTION REQUIRED\].*terms|must run.*claude.*review.*terms/i;
@@ -1080,7 +1080,7 @@ export const executeClaudeCommand = async params => {
           }
           if (progressMonitor) await progressMonitor.processStreamEvent(data, true).catch(e => log(`⚠️ Progress: ${e.message}`, { verbose: true }));
         } catch {
-          if (!stdoutLineBuffer.includes('node:internal')) await log(stdoutLineBuffer, { stream: 'raw' });
+          if (!stdoutLineBuffer.includes('node:internal')) await log(stdoutLineBuffer, { stream: 'stdout' });
         }
       }
       if (startupTimeoutId) {

package/src/codex-health.lib.mjs

@@ -218,6 +218,26 @@ export const getCodexPluginProvisioningHealth = (codexJsonState, { capabilityPre
 // both observed in the captured runs at exit_code 0) would be wrongly failed.
 // Disk pressure is surfaced only as supporting *diagnostics* explaining why a
 // session was likely cut off, never as the sole reason to fail a completed turn.
+// Issue #2136: the count comparison above is only sound when every counted
+// `turn.started` is codex's own. It is not: under `--verbose` codex's stderr
+// carries OTEL records that dump the raw stdout of each command it ran, so a task
+// that drives another agent CLI replays that agent's `turn.started` into our
+// stream. One echoed line was enough to make turn.started=2 vs turn.completed=1
+// and fail a run that had finished successfully (formal-ai PR #913 was open with
+// green CI). codex.lib.mjs now keeps stderr out of the protocol counters, and the
+// gate itself asks the order-aware question — "was the LAST lifecycle event a
+// start?" — so a stray extra `turn.started` from any future echo path can no
+// longer flip a completed session to failed, while a genuine cut-off mid-turn
+// (the #1990 shape: the stream ends on `turn.started`) still fails.
+const isIncompleteTurnLifecycle = (turnLifecycle, { turnStarted, turnCompleted, turnFailed }) => {
+  if (!Array.isArray(turnLifecycle) || turnLifecycle.length === 0) {
+    // Callers that hand-build a state without an ordered lifecycle keep the
+    // original count rule.
+    return turnCompleted + turnFailed < Math.max(turnStarted, 1);
+  }
+  return turnLifecycle.at(-1) === 'turn.started';
+};
+
 export const getCodexCompletionHealth = (codexJsonState, { lastMessage = '' } = {}) => {
   const eventCounts = codexJsonState?.eventCounts || {};
   const turnStarted = eventCounts['turn.started'] || 0;
@@ -232,7 +252,7 @@ export const getCodexCompletionHealth = (codexJsonState, { lastMessage = '' } =
 
   // A started turn that never completed or failed = the process was cut off
   // mid-turn (OOM / disk-full / container teardown) even though it exited 0.
-  const incompleteSession = hadActivity && turnCompleted + turnFailed < Math.max(turnStarted, 1);
+  const incompleteSession = hadActivity && isIncompleteTurnLifecycle(codexJsonState?.turnLifecycle, { turnStarted, turnCompleted, turnFailed });
 
   // Diagnostic-only disk-pressure hints (never an independent failure gate).
   const diskEvidence = [];
@@ -249,9 +269,28 @@ export const getCodexCompletionHealth = (codexJsonState, { lastMessage = '' } =
   addDiskEvidence('result-summary', codexJsonState?.resultSummary);
   const diskPressureDetected = diskEvidence.length > 0;
 
+  // Issue #2140: the counts alone made the #2136 false positive unfalsifiable —
+  // "turn.started=3, turn.completed=1" was posted to the PR with nothing to say
+  // whether those starts were codex's own. Carry the evidence that decides it:
+  // the ordered lifecycle, what was discarded as echoed telemetry, and any
+  // foreign thread id that reached the protocol stream.
+  const turnLifecycle = Array.isArray(codexJsonState?.turnLifecycle) ? codexJsonState.turnLifecycle : [];
+  const telemetryEventCounts = codexJsonState?.telemetryEventCounts || {};
+  const foreignThreadIds = codexJsonState?.foreignThreadIds || [];
+  const echoedTurnStarts = telemetryEventCounts['turn.started'] || 0;
+
   const reasons = [];
   if (incompleteSession) {
     reasons.push(`Codex session ended without completing its turn (turn.started=${turnStarted}, turn.completed=${turnCompleted}, turn.failed=${turnFailed}); the process exited 0 but was cut off mid-turn.`);
+    if (turnLifecycle.length > 0) {
+      reasons.push(`Turn lifecycle in order: ${turnLifecycle.join(' → ')} — the stream ends on a start, so the last turn never finished.`);
+    }
+    if (echoedTurnStarts > 0 || foreignThreadIds.length > 0) {
+      const echoParts = [];
+      if (echoedTurnStarts > 0) echoParts.push(`${echoedTurnStarts} echoed turn.started on codex stderr (excluded from the counts above)`);
+      if (foreignThreadIds.length > 0) echoParts.push(`foreign thread id(s) on the protocol stream: ${foreignThreadIds.join(', ')}`);
+      reasons.push(`Echo diagnostics (issues #2136/#2140): ${echoParts.join('; ')}.`);
+    }
     if (diskPressureDetected) {
       reasons.push(`Disk-exhaustion signals were present in ${diskEvidence.length} location(s) (e.g. "No space left on device") — the likely cause of the interrupted session.`);
     }
@@ -265,6 +304,9 @@ export const getCodexCompletionHealth = (codexJsonState, { lastMessage = '' } =
     turnStarted,
     turnCompleted,
     turnFailed,
+    turnLifecycle,
+    echoedTurnStarts,
+    foreignThreadIds,
     reasons,
   };
 };
@@ -285,6 +327,9 @@ export const reportCodexCompletionFailure = async ({ completionHealth, log, getR
     await log(`   • ${reason}`, { level: 'error' });
   }
   await log(`   📊 turn.started=${completionHealth.turnStarted}, turn.completed=${completionHealth.turnCompleted}, turn.failed=${completionHealth.turnFailed}`, { verbose: true });
+  if (completionHealth.turnLifecycle?.length) {
+    await log(`   🔁 turn lifecycle: ${completionHealth.turnLifecycle.join(' → ')}`, { verbose: true });
+  }
   if (completionHealth.diskPressureDetected) {
     await log('   💽 Disk-exhaustion evidence (diagnostic):', { level: 'error' });
     for (const evidence of completionHealth.diskEvidence.slice(0, 5)) {

package/src/codex.lib.mjs

@@ -43,52 +43,11 @@ import { applyCodexCapabilityEnv, runCodexCapabilityPreflight } from './codex-ca
 import { createPullRequestBaseBranchCommandIntervention } from './solve.pr-base-command-intervention.lib.mjs';
 import Decimal from 'decimal.js-light';
 import { ensureAiToolScratchIgnored, filterAiToolScratchFromStatus } from './ai-tool-scratch.lib.mjs';
+import { CODEX_CACHE_READ_USAGE_PATHS, CODEX_CACHE_WRITE_USAGE_PATHS, CODEX_MODEL_DIAGNOSTIC_PATHS, CODEX_REASONING_USAGE_PATHS, CODEX_USAGE_FIELD_NAMES, createCodexTokenFieldAvailability, getFirstObservedNumber, hasAnyObservedPath, hasOwnPath } from './codex.usage-fields.lib.mjs';
 
-const CODEX_USAGE_FIELD_NAMES = ['input_tokens', 'cached_input_tokens', 'output_tokens', 'cache_write_tokens', 'cache_creation_input_tokens', 'reasoning_tokens', 'reasoning_output_tokens', 'input_tokens_details.cached_tokens', 'input_tokens_details.cache_read_tokens', 'input_tokens_details.cache_write_tokens', 'input_tokens_details.cache_creation_tokens', 'input_tokens_details.cache_creation_input_tokens', 'output_tokens_details.reasoning_tokens'];
 const CODEX_LONG_CONTEXT_PRICE_THRESHOLD = 272000;
 const CODEX_COMPACT_API_ENDPOINT = '/responses/compact';
 const getCodexExecEnv = (verbose = false) => (verbose ? { ...process.env, RUST_LOG: 'debug' } : { ...process.env });
-const CODEX_MODEL_DIAGNOSTIC_PATHS = [
-  ['model', data => data?.model],
-  ['model_name', data => data?.model_name],
-  ['from_model', data => data?.from_model],
-  ['to_model', data => data?.to_model],
-  ['message.model', data => data?.message?.model],
-];
-
-const createCodexTokenFieldAvailability = () => ({
-  inputTokens: false,
-  outputTokens: false,
-  reasoningTokens: false,
-  cacheReadTokens: false,
-  cacheWriteTokens: false,
-});
-
-const hasOwnPath = (object, pathName) => {
-  let cursor = object;
-  for (const part of pathName.split('.')) {
-    if (!cursor || typeof cursor !== 'object' || !Object.hasOwn(cursor, part)) return false;
-    cursor = cursor[part];
-  }
-  return true;
-};
-
-const getPathValue = (object, pathName) => pathName.split('.').reduce((cursor, part) => cursor?.[part], object);
-
-const getFirstObservedNumber = (object, pathNames) => {
-  for (const pathName of pathNames) {
-    if (!hasOwnPath(object, pathName)) continue;
-    const value = getPathValue(object, pathName);
-    return Number.isFinite(value) ? value : 0;
-  }
-  return 0;
-};
-
-const hasAnyObservedPath = (object, pathNames) => pathNames.some(pathName => hasOwnPath(object, pathName));
-
-const CODEX_CACHE_READ_USAGE_PATHS = ['cached_input_tokens', 'input_tokens_details.cached_tokens', 'input_tokens_details.cache_read_tokens'];
-const CODEX_CACHE_WRITE_USAGE_PATHS = ['cache_write_tokens', 'cache_creation_input_tokens', 'input_tokens_details.cache_write_tokens', 'input_tokens_details.cache_creation_tokens', 'input_tokens_details.cache_creation_input_tokens'];
-const CODEX_REASONING_USAGE_PATHS = ['reasoning_tokens', 'reasoning_output_tokens', 'output_tokens_details.reasoning_tokens'];
 
 const escapeRegExp = value => String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 
@@ -338,7 +297,21 @@ const upsertCodexItemError = (itemErrors, item) => {
   });
 };
 
-export const parseCodexExecJsonOutput = (output, state = {}, requestedModelId = null) => {
+// Issue #2136: `codex exec --json` writes its NDJSON protocol to **stdout** only.
+// Its stderr carries OTEL tracing text (RUST_LOG=debug under --verbose), and each
+// `codex.tool_result` record dumps the raw stdout of the command codex just ran —
+// so a task driving another agent CLI replays that agent's NDJSON verbatim inside
+// the trace. Feeding stderr through this parser counted the nested agent's
+// `turn.started` as codex's own, and the #1990 completion gate then failed a run
+// that had actually completed (see docs/case-studies/issue-2136).
+//
+// Fix: only stdout is trusted as protocol. Stderr is still scanned for the
+// text-only diagnostics that legitimately live there (token/model diagnostics,
+// the #2102 plugin-install rejection), but protocol-shaped JSON found there is
+// counted into `telemetryEventCounts` and otherwise ignored — it never touches
+// eventCounts, sessionId, usage or the error buckets.
+export const parseCodexExecJsonOutput = (output, state = {}, requestedModelId = null, { source = 'stdout' } = {}) => {
+  const isProtocolStream = source === 'stdout';
   const nextState = {
     sessionId: state.sessionId || null,
     authError: state.authError || false,
@@ -359,6 +332,19 @@ export const parseCodexExecJsonOutput = (output, state = {}, requestedModelId =
     pluginInstallRejections: state.pluginInstallRejections || [],
     observedUsageFieldSets: state.observedUsageFieldSets || [],
     observedModelDiagnosticPaths: state.observedModelDiagnosticPaths || [],
+    // Issue #2136: protocol-shaped JSON seen on a non-protocol stream (telemetry
+    // echo), kept for diagnostics only.
+    telemetryEventCounts: state.telemetryEventCounts || {},
+    // Issue #2136: ordered turn lifecycle from the protocol stream, so the
+    // completion gate can ask "did the last turn finish?" instead of comparing
+    // counts that an echoed `turn.started` can skew.
+    turnLifecycle: state.turnLifecycle || [],
+    // Issue #2140: `thread.started` records seen on the protocol stream that
+    // announce a thread id other than this session's. Codex only starts one
+    // thread per `codex exec`, so a second id is proof that something echoed
+    // another agent's protocol into ours — the one turn event that carries an
+    // identity we can check. Diagnostics only; the gate stays order-based.
+    foreignThreadIds: state.foreignThreadIds || [],
   };
 
   nextState.tokenUsage.tokenFieldAvailability ||= createCodexTokenFieldAvailability();
@@ -396,10 +382,26 @@ export const parseCodexExecJsonOutput = (output, state = {}, requestedModelId =
     if (data === null || typeof data !== 'object') continue;
 
     const eventType = typeof data.type === 'string' ? data.type : 'unknown';
+
+    // Issue #2136: a protocol-shaped object on a non-protocol stream is echoed
+    // telemetry, never a codex event. Count it for diagnostics and move on.
+    if (!isProtocolStream) {
+      nextState.telemetryEventCounts[eventType] = (nextState.telemetryEventCounts[eventType] || 0) + 1;
+      continue;
+    }
+
     nextState.eventCounts[eventType] = (nextState.eventCounts[eventType] || 0) + 1;
+    if (eventType === 'turn.started' || eventType === 'turn.completed' || eventType === 'turn.failed') {
+      nextState.turnLifecycle.push(eventType);
+    }
 
     if (eventType === 'thread.started' && typeof data.thread_id === 'string' && !nextState.sessionId) {
       nextState.sessionId = data.thread_id;
+    } else if (eventType === 'thread.started' && typeof data.thread_id === 'string' && data.thread_id !== nextState.sessionId) {
+      // Issue #2140: a foreign thread id on the protocol stream is echoed
+      // output, not a second codex session. Record it once so a run that ends
+      // up disputed can be settled from the log alone.
+      if (!nextState.foreignThreadIds.includes(data.thread_id)) nextState.foreignThreadIds.push(data.thread_id);
     } else if (!nextState.sessionId && typeof data.session_id === 'string') {
       nextState.sessionId = data.session_id;
     }
@@ -983,6 +985,8 @@ export const executeCodexCommand = async params => {
         pluginInstallRejections: [],
         observedUsageFieldSets: [],
         observedModelDiagnosticPaths: [],
+        telemetryEventCounts: {},
+        turnLifecycle: [],
       };
 
       // Issue #2119: a process chunk boundary can fall in the middle of an
@@ -996,12 +1000,12 @@ export const executeCodexCommand = async params => {
         if (chunk.type === 'stdout') {
           const raw = chunk.data.toString();
           if (argv.verbose) {
-            await log(raw);
+            await log(raw, { stream: 'stdout' });
           }
           lastMessage = raw;
           const output = codexStdoutLines.write(raw);
 
-          codexJsonState = parseCodexExecJsonOutput(output, codexJsonState, mappedModel);
+          codexJsonState = parseCodexExecJsonOutput(output, codexJsonState, mappedModel, { source: 'stdout' });
           await baseBranchCommandIntervention.handleCommandExecutions(codexJsonState.commandExecutions);
 
           if (interactiveHandler || progressMonitor) {
@@ -1044,7 +1048,8 @@ export const executeCodexCommand = async params => {
             await log(rawError, { stream: 'stderr' });
           }
           const errorOutput = codexStderrLines.write(rawError);
-          codexJsonState = parseCodexExecJsonOutput(errorOutput, codexJsonState, mappedModel);
+          // Issue #2136: stderr is telemetry/tracing text, not the codex protocol.
+          codexJsonState = parseCodexExecJsonOutput(errorOutput, codexJsonState, mappedModel, { source: 'stderr' });
           await baseBranchCommandIntervention.handleCommandExecutions(codexJsonState.commandExecutions);
         } else if (chunk.type === 'exit') {
           exitCode = chunk.code;
@@ -1052,9 +1057,12 @@ export const executeCodexCommand = async params => {
       }
 
       // Release any line that was still being assembled when the stream ended.
-      for (const remaining of [codexStdoutLines.flush(), codexStderrLines.flush()]) {
+      for (const [source, remaining] of [
+        ['stdout', codexStdoutLines.flush()],
+        ['stderr', codexStderrLines.flush()],
+      ]) {
         if (!remaining.trim()) continue;
-        codexJsonState = parseCodexExecJsonOutput(remaining, codexJsonState, mappedModel);
+        codexJsonState = parseCodexExecJsonOutput(remaining, codexJsonState, mappedModel, { source });
         await baseBranchCommandIntervention.handleCommandExecutions(codexJsonState.commandExecutions);
       }
 

package/src/codex.run-diagnostics.lib.mjs

@@ -86,6 +86,24 @@ export const buildCodexRunDiagnostics = ({ state = {}, exitCode = null, mappedMo
   if (Object.keys(state.eventCounts || {}).length > 0) push(`📊 Codex JSON events: ${counts(state.eventCounts)}`);
   if (Object.keys(state.itemTypeCounts || {}).length > 0) push(`📦 Codex item types: ${counts(state.itemTypeCounts)}`);
 
+  // Issue #2136: protocol-shaped JSON that arrived on codex's stderr (OTEL
+  // `codex.tool_result` records replay the raw stdout of every command codex
+  // runs, so a task driving another agent CLI replays that agent's NDJSON). These
+  // lines are deliberately NOT counted as codex events; surfacing them keeps the
+  // discrepancy between "events codex emitted" and "protocol lines seen in the
+  // log" explainable when a run is investigated after the fact.
+  if (Object.keys(state.telemetryEventCounts || {}).length > 0) {
+    push(`🪞 Echoed protocol-shaped lines on codex stderr (ignored, not codex events): ${counts(state.telemetryEventCounts)}`);
+  }
+  if (state.turnLifecycle?.length > 0) push(`🔁 Codex turn lifecycle: ${state.turnLifecycle.join(' → ')}`);
+
+  // Issue #2140: codex starts exactly one thread per `codex exec`, so any other
+  // thread id on the protocol stream is echoed output that leaked past the
+  // stream separation above. Always worth saying out loud.
+  if (state.foreignThreadIds?.length > 0) {
+    push(`🧬 Foreign thread IDs seen on the codex protocol stream (echoed, not codex sessions): ${state.foreignThreadIds.join(', ')}`, { level: 'warning', verbose: true });
+  }
+
   const usage = state.tokenUsage || {};
   if (usage.stepCount > 0) {
     push(`📈 Codex usage from turn.completed: ${usage.inputTokens.toLocaleString()} input, ${usage.cacheReadTokens.toLocaleString()} cache read, ${usage.outputTokens.toLocaleString()} output across ${usage.stepCount} turn(s)`);

package/src/codex.usage-fields.lib.mjs

@@ -0,0 +1,59 @@
+/**
+ * Usage-field vocabulary and JSON-path helpers for the `codex exec --json`
+ * parser.
+ *
+ * Split out of codex.lib.mjs to keep that file inside the max-lines budget
+ * (issues #1730 / #1990 / #2140). Everything here is pure data plus pure
+ * lookups: codex has renamed and re-nested its usage fields several times
+ * across releases, so the parser reads whichever spelling is *present* rather
+ * than assuming one shape, and reports what it actually observed.
+ */
+
+/** Every usage field name we know codex has used, for observability reporting. */
+export const CODEX_USAGE_FIELD_NAMES = ['input_tokens', 'cached_input_tokens', 'output_tokens', 'cache_write_tokens', 'cache_creation_input_tokens', 'reasoning_tokens', 'reasoning_output_tokens', 'input_tokens_details.cached_tokens', 'input_tokens_details.cache_read_tokens', 'input_tokens_details.cache_write_tokens', 'input_tokens_details.cache_creation_tokens', 'input_tokens_details.cache_creation_input_tokens', 'output_tokens_details.reasoning_tokens'];
+
+/** Places a codex event has been seen to name a model, in preference order. */
+export const CODEX_MODEL_DIAGNOSTIC_PATHS = [
+  ['model', data => data?.model],
+  ['model_name', data => data?.model_name],
+  ['from_model', data => data?.from_model],
+  ['to_model', data => data?.to_model],
+  ['message.model', data => data?.message?.model],
+];
+
+export const CODEX_CACHE_READ_USAGE_PATHS = ['cached_input_tokens', 'input_tokens_details.cached_tokens', 'input_tokens_details.cache_read_tokens'];
+export const CODEX_CACHE_WRITE_USAGE_PATHS = ['cache_write_tokens', 'cache_creation_input_tokens', 'input_tokens_details.cache_write_tokens', 'input_tokens_details.cache_creation_tokens', 'input_tokens_details.cache_creation_input_tokens'];
+export const CODEX_REASONING_USAGE_PATHS = ['reasoning_tokens', 'reasoning_output_tokens', 'output_tokens_details.reasoning_tokens'];
+
+/** Which token kinds this run has actually seen codex report. */
+export const createCodexTokenFieldAvailability = () => ({
+  inputTokens: false,
+  outputTokens: false,
+  reasoningTokens: false,
+  cacheReadTokens: false,
+  cacheWriteTokens: false,
+});
+
+/** Own-property check along a dotted path — absent ≠ present-and-zero. */
+export const hasOwnPath = (object, pathName) => {
+  let cursor = object;
+  for (const part of pathName.split('.')) {
+    if (!cursor || typeof cursor !== 'object' || !Object.hasOwn(cursor, part)) return false;
+    cursor = cursor[part];
+  }
+  return true;
+};
+
+export const getPathValue = (object, pathName) => pathName.split('.').reduce((cursor, part) => cursor?.[part], object);
+
+/** First path that is actually present wins; a non-finite value counts as 0. */
+export const getFirstObservedNumber = (object, pathNames) => {
+  for (const pathName of pathNames) {
+    if (!hasOwnPath(object, pathName)) continue;
+    const value = getPathValue(object, pathName);
+    return Number.isFinite(value) ? value : 0;
+  }
+  return 0;
+};
+
+export const hasAnyObservedPath = (object, pathNames) => pathNames.some(pathName => hasOwnPath(object, pathName));

package/src/gemini.lib.mjs

@@ -462,7 +462,7 @@ export const executeGeminiCommand = async params => {
       for await (const chunk of execCommand.stream()) {
         if (chunk.type === 'stdout') {
           const output = chunk.data.toString();
-          await log(output);
+          await log(output, { stream: 'stdout' });
           allOutput += output;
           geminiJsonState = parseGeminiJsonOutput(output, geminiJsonState, mappedModel);
           if (geminiJsonState.sessionId) {

package/src/lib.mjs

@@ -95,10 +95,14 @@ export const getAbsoluteLogPath = async () => {
  * @param {Object} options - Logging options
  * @param {string} [options.level='info'] - Log level (info, warn, error)
  * @param {boolean} [options.verbose=false] - Whether this is a verbose log
+ * @param {string} [options.stream] - Provenance of the message when it is raw
+ *   output mirrored from a child process: 'stdout' or 'stderr'. Tags the log
+ *   file lines [STDOUT]/[STDERR] (matching the process.stdout/stderr
+ *   interceptor below) and routes the console write to the same stream.
  * @returns {Promise<void>}
  */
 export const log = async (message, options = {}) => {
-  const { level = 'info', verbose = false } = options;
+  const { level = 'info', verbose = false, stream = null } = options;
 
   // Skip verbose logs unless --verbose is enabled
   if (verbose && !global.verboseMode) {
@@ -107,12 +111,20 @@ export const log = async (message, options = {}) => {
 
   const sanitizedMessage = sanitizeCredentialText(message);
 
+  // Issue #2140: mirrored child output must stay attributable to the stream it
+  // came from. Both Codex streams used to be written as plain [INFO], so a run
+  // log could not answer "did Codex emit this protocol line, or did its stderr
+  // merely echo one?" — the exact question a false completion failure hinges on.
+  // An explicit level still wins, so warnings/errors keep their own tag.
+  const mirroredStream = stream === 'stdout' || stream === 'stderr' ? stream : null;
+  const tag = mirroredStream && level === 'info' ? mirroredStream.toUpperCase() : level.toUpperCase();
+
   // Write to file if log file is set
   // Issue #1572: Handle multi-line messages by timestamping each line,
   // so continuation lines don't appear without timestamps in the log file
   if (logFile) {
     const timestamp = new Date().toISOString();
-    const prefix = `[${timestamp}] [${level.toUpperCase()}]`;
+    const prefix = `[${timestamp}] [${tag}]`;
     const lines = sanitizedMessage.split('\n');
     const logMessage = lines.map(line => `${prefix} ${line}`).join('\n');
     try {
@@ -146,7 +158,10 @@ export const log = async (message, options = {}) => {
         break;
       case 'info':
       default:
-        console.log(sanitizedMessage);
+        // Mirrored child stderr goes to our stderr, so piping stdout to a
+        // consumer keeps yielding only what the child wrote to stdout.
+        if (mirroredStream === 'stderr') console.error(sanitizedMessage);
+        else console.log(sanitizedMessage);
         break;
     }
   } finally {

package/src/opencode.lib.mjs

@@ -343,9 +343,19 @@ export const executeOpenCodeCommand = async params => {
       const stdoutScanner = createJsonStreamScanner();
       const stderrScanner = createJsonStreamScanner();
 
-      const handleOpenCodeRecords = events => {
+      // Issue #2136: count the JSON records that arrive on stderr. OpenCode has
+      // no terminal-event completion gate (success is decided by the exit code),
+      // so unlike codex and qwen these records cannot fail a healthy run — but
+      // they do feed `lastTextContent` and token usage, and a CLI that echoes a
+      // nested agent's stream would silently skew both. Issue #1263 added stderr
+      // parsing deliberately (some OpenCode-derived CLIs emit their records
+      // there), so the behaviour is kept and only made visible.
+      let stderrJsonRecordCount = 0;
+
+      const handleOpenCodeRecords = (events, { source = 'stdout' } = {}) => {
         for (const event of events) {
           if (event.type !== 'json') continue;
+          if (source === 'stderr') stderrJsonRecordCount++;
           const data = sanitizeObjectStrings(event.value);
           // Issue #1968: a bare `null`/primitive record must not abort the
           // rest of the chunk (data.type access would throw on null).
@@ -384,7 +394,7 @@ export const executeOpenCodeCommand = async params => {
       for await (const chunk of execCommand.stream()) {
         if (chunk.type === 'stdout') {
           const output = chunk.data.toString();
-          await log(output);
+          await log(output, { stream: 'stdout' });
           lastMessage = output;
           allOutput += output;
 
@@ -399,7 +409,7 @@ export const executeOpenCodeCommand = async params => {
             allOutput += errorOutput;
 
             // Issue #1263: Also parse stderr for text content
-            handleOpenCodeRecords(stderrScanner.write(errorOutput));
+            handleOpenCodeRecords(stderrScanner.write(errorOutput), { source: 'stderr' });
           }
         } else if (chunk.type === 'exit') {
           exitCode = chunk.code;
@@ -408,7 +418,11 @@ export const executeOpenCodeCommand = async params => {
 
       // Release any record that was still being assembled when the stream ended.
       handleOpenCodeRecords(stdoutScanner.flush());
-      handleOpenCodeRecords(stderrScanner.flush());
+      handleOpenCodeRecords(stderrScanner.flush(), { source: 'stderr' });
+
+      if (stderrJsonRecordCount > 0) {
+        await log(`🪞 JSON records parsed from OpenCode stderr: ${stderrJsonRecordCount} (issue #2136: stderr is not a protocol stream — check these before trusting usage/summary)`, { verbose: true });
+      }
 
       // Clean up the opencode.json config file to avoid polluting the repository
       try {

package/src/qwen.lib.mjs

@@ -143,6 +143,10 @@ const extractTextFragments = value => {
 
 const createQwenParserState = state => ({
   buffer: state?.buffer || '',
+  // Issue #2136: stderr is framed independently of stdout — mixing the two into
+  // one buffer would splice half of a stdout record onto a stderr line.
+  telemetryBuffer: state?.telemetryBuffer || '',
+  telemetryEventCounts: { ...(state?.telemetryEventCounts || {}) },
   plainText: state?.plainText || '',
   parsedEvents: Array.isArray(state?.parsedEvents) ? [...state.parsedEvents] : [],
   eventCounts: { ...(state?.eventCounts || {}) },
@@ -324,24 +328,45 @@ const addQwenEventToState = (state, rawEvent) => {
   applyQwenUsageToState(state, event);
 };
 
-export const parseQwenStreamJsonOutput = (output, state = {}) => {
+// Issue #2136: qwen-code writes its stream-json protocol to stdout; stderr is
+// human/diagnostic text. Feeding stderr through the protocol parser made every
+// JSON object a CLI happened to print there — including output a task's own
+// commands echoed back — a genuine qwen event, which could invent an `errors`
+// entry (an instant run failure), hijack the session id, add phantom token usage
+// or satisfy the #1990 terminal-event gate. Codex was bitten by exactly this
+// (see docs/case-studies/issue-2136), so qwen now marks non-stdout records as
+// telemetry: they are counted for diagnostics and otherwise ignored. Plain-text
+// stderr signals are unaffected — auth/usage-limit/retry classification still
+// reads the raw combined output.
+export const parseQwenStreamJsonOutput = (output, state = {}, { source = 'stdout' } = {}) => {
   const nextState = createQwenParserState(state);
   const text = output?.toString?.() ?? String(output || '');
   nextState.plainText += text;
 
+  const isProtocolStream = source === 'stdout';
+
   // Issue #2119: frame the stream by balanced JSON values instead of by lines.
   // `formal-ai with qwen` emits pretty-printed, multi-line records, so every
   // line failed to parse and every event - including the token usage - was
   // dropped. Scanning for balanced values also covers records concatenated
   // without a separator and records split across two process chunks.
-  const { records, rest } = takeJsonRecords(`${nextState.buffer}${text}`);
-  nextState.buffer = rest;
+  const pendingBuffer = isProtocolStream ? nextState.buffer : nextState.telemetryBuffer;
+  const { records, rest } = takeJsonRecords(`${pendingBuffer}${text}`);
+  if (isProtocolStream) {
+    nextState.buffer = rest;
+  } else {
+    nextState.telemetryBuffer = rest;
+  }
 
   for (const record of records) {
-    if (Array.isArray(record)) {
-      for (const item of record) addQwenEventToState(nextState, item);
-    } else {
-      addQwenEventToState(nextState, record);
+    const items = Array.isArray(record) ? record : [record];
+    for (const item of items) {
+      if (isProtocolStream) {
+        addQwenEventToState(nextState, item);
+        continue;
+      }
+      const eventType = item?.type || item?.event || 'unknown';
+      nextState.telemetryEventCounts[eventType] = (nextState.telemetryEventCounts[eventType] || 0) + 1;
     }
   }
 
@@ -541,7 +566,7 @@ export const executeQwenCommand = async params => {
       for await (const chunk of execCommand.stream()) {
         if (chunk.type === 'stdout') {
           const output = chunk.data.toString();
-          await log(output);
+          await log(output, { stream: 'stdout' });
           allOutput += output;
           qwenState = parseQwenStreamJsonOutput(output, qwenState);
         }
@@ -551,7 +576,8 @@ export const executeQwenCommand = async params => {
           if (errorOutput) {
             await log(errorOutput, { stream: 'stderr' });
             allOutput += errorOutput;
-            qwenState = parseQwenStreamJsonOutput(errorOutput, qwenState);
+            // Issue #2136: stderr is diagnostics, not the qwen protocol stream.
+            qwenState = parseQwenStreamJsonOutput(errorOutput, qwenState, { source: 'stderr' });
           }
         } else if (chunk.type === 'exit') {
           exitCode = chunk.code;
@@ -562,6 +588,14 @@ export const executeQwenCommand = async params => {
         qwenState = parseQwenStreamJsonOutput(`${qwenState.buffer}\n`, { ...qwenState, buffer: '' });
       }
 
+      // Issue #2136: make the ignored non-protocol JSON visible, so a future
+      // investigation can tell "qwen emitted no result event" apart from "the
+      // records in the log came from stderr and were correctly ignored".
+      const qwenTelemetryTypes = Object.entries(qwenState.telemetryEventCounts || {});
+      if (qwenTelemetryTypes.length > 0) {
+        await log(`🪞 JSON records on qwen stderr (ignored, not protocol events): ${qwenTelemetryTypes.map(([type, count]) => `${type}=${count}`).join(', ')}`, { verbose: true });
+      }
+
       const sessionId = qwenState.sessionId || null;
       const resultSummary = qwenState.lastTextContent || null;
       const errorMessage = qwenState.errors