@link-assistant/hive-mind 2.11.10 → 2.11.12

package/CHANGELOG.md

@@ -1,5 +1,78 @@
 # @link-assistant/hive-mind
 
+## 2.11.12
+
+### Patch Changes
+
+- be63949: Render structured tool error payloads as readable text instead of
+  `[object Object]` (issue #2141).
+
+  A `solve --tool agent --model formal-ai` run failed 22 seconds in and published
+  one artefact: a "Solution Draft Failed" comment reading `AGENT execution failed
+with Agent reported error: [object Object]`. `--attach-logs` was off, so that
+  string was the entire post-mortem and the real cause is unrecoverable.
+  `@link-assistant/agent` emits `NamedError.toObject()` — `{"type":"error",
+"error":{"name":"…","data":{"message":"…"}}}` — and the adapter interpolated that
+  object into a template literal. The `|| JSON.stringify(msg)` fallback that would
+  have saved the diagnosis was unreachable, because the object is truthy.
+
+  - New `src/error-text.lib.mjs` renders strings, `Error` instances, `NamedError`
+    payloads, nested `{error:{…}}` envelopes and arrays into one readable line —
+    circular-safe, depth-limited, truncated at 2000 characters, never a
+    placeholder.
+  - A codebase-wide audit found the same defect class in nine places across six
+    adapters; all now use the shared renderer. One of them was not cosmetic:
+    `codex.lib.mjs` guarded `error` / `turn.failed` events with `typeof
+data.message === 'string'` and therefore **discarded** object-shaped failures,
+    reporting the run as a success.
+  - Defence in depth: `isMeaningfulErrorText` and `extractToolErrorCore` now reject
+    a core polluted by `[object Object]`, so any site this audit missed degrades to
+    the honest `AGENT execution failed` rather than the misleading long form.
+  - The agent adapter now fails fast when the CLI logs a fatal startup error
+    (`ProviderModelNotFoundError` and friends) and then exits 0 with no error event
+    and no output — a silent failure reproduced against agent CLI 0.25.5 and
+    reported upstream.
+  - `--verbose` dumps the raw JSON of every error and fatal log record, and the
+    pre-PR failure comment now tells the reader to rerun with
+    `--attach-logs --verbose`.
+
+  Case study, raw evidence and the upstream reports:
+  `docs/case-studies/issue-2141/README.md`.
+
+## 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

package/package.json

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

package/src/agent.lib.mjs

@@ -27,12 +27,98 @@ import { buildFormalAiPricingInfo } from './formal-ai-pricing.lib.mjs'; // Issue
 import { checkPlaywrightMcpPackageAvailability, getAgentPlaywrightMcpDisableEnv } from './playwright-mcp.lib.mjs';
 import { createAgentTokenUsage, accumulateAgentStepFinishUsage, parseAgentTokenUsage } from './agent-token-usage.lib.mjs';
 import { createJsonStreamScanner, parseJsonRecords } from './json-stream.lib.mjs';
+import { firstErrorText, stringifyErrorValue } from './error-text.lib.mjs';
 import { classifyRetryableError, prepareRetryAfterError, waitWithCountdown } from './tool-retry.lib.mjs';
 import { attachStreamingInput, finalizeBidirectionalHandler, setupBidirectionalHandler } from './bidirectional-interactive.lib.mjs';
 import { ensureAiToolScratchIgnored, filterAiToolScratchFromStatus } from './ai-tool-scratch.lib.mjs';
 
 export { createAgentTokenUsage, accumulateAgentStepFinishUsage, parseAgentTokenUsage };
 
+/**
+ * Render one streamed agent error record as human-readable text (issue #2141).
+ *
+ * `@link-assistant/agent` 0.25.x publishes `NamedError.toObject()` under the
+ * `error` key: `{"type":"error","error":{"name":"RetryTimeoutExceededError",
+ * "data":{"message":"…"}}}`. The previous chain `data.message || data.error ||
+ * raw.substring(0, 100)` returned that *object*, and interpolating it into
+ * `Agent reported error: ${…}` produced the reason published to GitHub in issue
+ * #2141: "AGENT execution failed with Agent reported error: [object Object]".
+ *
+ * @param {object} record - a sanitized JSON record from the agent stream.
+ * @param {string} [raw] - the raw record text, used as a last resort.
+ * @returns {string} readable error text, never `[object Object]`.
+ */
+export const extractAgentErrorText = (record, raw = '') => {
+  const fallback = String(raw || '').substring(0, 200) || 'Agent emitted an error event without any details';
+  return firstErrorText([record?.message, record?.error, record?.data, record], { fallback });
+};
+
+/**
+ * Model/provider initialization failures that leave the session unable to do any
+ * work at all (issue #2141).
+ */
+const FATAL_AGENT_LOG_PATTERNS = [/ProviderModelNotFoundError/i, /ProviderInitError/i, /NoSuchModelError/i, /ModelNotFoundError/i, /failed to initialize .*model/i];
+
+/**
+ * Detect an agent `log` record that reports a fatal startup failure (issue #2141).
+ *
+ * Reproduced locally with agent CLI 0.25.5: `agent --model nonexistent/model`
+ * prints
+ *
+ *   {"type":"log","level":"error","service":"session.prompt",
+ *    "error":"ProviderModelNotFoundError",
+ *    "hint":"Check that the model exists in the provider",
+ *    "message":"Failed to initialize specified model - NOT falling back to default"}
+ *
+ * then `session.idle` and exits **0** without ever emitting `{"type":"error"}`.
+ * Hive Mind therefore reported the run as a success with no result summary, which
+ * is the same class of undiagnosable outcome as issue #2141's `[object Object]`:
+ * the run failed, but nothing said so.
+ *
+ * @param {object} record - a sanitized JSON record from the agent stream.
+ * @returns {string|null} readable failure text, or null when the record is not fatal.
+ */
+export const detectFatalAgentLogRecord = record => {
+  if (!record || typeof record !== 'object') return null;
+  if (record.type !== 'log' || record.level !== 'error') return null;
+
+  const text = firstErrorText([record.error, record.message], { fallback: '' });
+  if (!text) return null;
+  const haystack = `${stringifyErrorValue(record.error)} ${stringifyErrorValue(record.message)}`;
+  if (!FATAL_AGENT_LOG_PATTERNS.some(pattern => pattern.test(haystack))) return null;
+
+  const parts = [stringifyErrorValue(record.error), stringifyErrorValue(record.message), record.hint ? `hint: ${stringifyErrorValue(record.hint)}` : ''];
+  return parts.filter(Boolean).join(' — ');
+};
+
+/**
+ * Scan agent stdout for explicit JSON error records (issues #1201, #2119, #2141).
+ *
+ * Exported so the detection precedence can be tested directly instead of being
+ * re-implemented in tests (the old duplicate in tests/test-agent-error-detection.mjs
+ * kept the `[object Object]` bug invisible).
+ *
+ * @param {string} stdoutOutput - captured agent stdout.
+ * @returns {{detected: boolean, type?: string, match?: string, record?: object}}
+ */
+export const detectAgentErrorsInOutput = stdoutOutput => {
+  // Issue #2119: frame records by balanced JSON, not by newlines, so
+  // pretty-printed and concatenated records are still inspected.
+  for (const record of parseJsonRecords(stdoutOutput)) {
+    const msg = sanitizeObjectStrings(record);
+
+    // Issue #1968: ignore bare `null`/primitive records (msg.type would throw on null).
+    if (msg === null || typeof msg !== 'object') continue;
+
+    // Check for explicit error message types from agent
+    if (msg.type === 'error' || msg.type === 'step_error') {
+      return { detected: true, type: 'AgentError', match: extractAgentErrorText(msg, JSON.stringify(msg)), record: msg };
+    }
+  }
+
+  return { detected: false };
+};
+
 // Import pricing functions from claude.lib.mjs
 // We reuse fetchModelInfo and checkModelVisionCapability to get data from models.dev API
 const claudeLib = await import('./claude.lib.mjs');
@@ -608,6 +694,9 @@ export const executeAgentCommand = async params => {
       // Issue #1276: Track successful completion events to clear error flags
       // When agent emits session.idle or disposal events, it means it recovered and completed successfully
       let agentCompletedSuccessfully = false;
+      // Issue #2141: a fatal startup log record (e.g. ProviderModelNotFoundError)
+      // that the agent CLI reports without any `{"type":"error"}` event.
+      let fatalLogErrorMessage = null;
       // Issue #1250: Accumulate token usage during streaming instead of parsing fullOutput later
       // This fixes the issue where NDJSON lines get concatenated without newlines, breaking JSON.parse
       const streamingTokenUsage = createAgentTokenUsage();
@@ -668,8 +757,23 @@ export const executeAgentCommand = async params => {
         // Issue #1201: Detect error events during streaming for reliable detection
         if (data.type === 'error' || data.type === 'step_error') {
           streamingErrorDetected = true;
-          streamingErrorMessage = data.message || data.error || raw.substring(0, 100);
+          // Issue #2141: render `{name, data:{message}}` payloads as text so the
+          // published failure reason is diagnosable instead of "[object Object]".
+          streamingErrorMessage = extractAgentErrorText(data, raw);
           await log(`⚠️  Error event detected in stream: ${streamingErrorMessage}`, { level: 'warning' });
+          // Issue #2141: keep the untouched record so the root cause survives even
+          // when the rendering above loses a field. Verbose-only to keep normal
+          // logs readable; --attach-logs then carries the full payload.
+          await log(`   Raw error record: ${JSON.stringify(data)}`, { level: 'warning', verbose: true });
+        }
+        // Issue #2141: fail fast when the CLI could not even start the model.
+        if (!fatalLogErrorMessage) {
+          const fatalLogText = detectFatalAgentLogRecord(data);
+          if (fatalLogText) {
+            fatalLogErrorMessage = fatalLogText;
+            await log(`⚠️  Fatal agent log record detected: ${fatalLogText}`, { level: 'warning' });
+            await log(`   Raw log record: ${JSON.stringify(data)}`, { level: 'warning', verbose: true });
+          }
         }
         // Issue #1263: Track text content for result summary
         // Agent outputs text via 'text', 'assistant', or 'message' type events
@@ -759,26 +863,9 @@ export const executeAgentCommand = async params => {
       // 1. Non-zero exit code (agent returns 1 on errors)
       // 2. Explicit JSON error messages from agent (type: "error")
       // 3. Usage limit detection (handled separately)
-      const detectAgentErrors = stdoutOutput => {
-        // Issue #2119: frame records by balanced JSON, not by newlines, so
-        // pretty-printed and concatenated records are still inspected.
-        for (const record of parseJsonRecords(stdoutOutput)) {
-          const msg = sanitizeObjectStrings(record);
-
-          // Issue #1968: ignore bare `null`/primitive records (msg.type would throw on null).
-          if (msg === null || typeof msg !== 'object') continue;
-
-          // Check for explicit error message types from agent
-          if (msg.type === 'error' || msg.type === 'step_error') {
-            return { detected: true, type: 'AgentError', match: msg.message || msg.error || JSON.stringify(msg).substring(0, 100) };
-          }
-        }
-
-        return { detected: false };
-      };
-
       // Only check for JSON error messages, not pattern matching in output
-      const outputError = detectAgentErrors(fullOutput);
+      // Issue #2141: the detection now renders structured payloads as text.
+      const outputError = detectAgentErrorsInOutput(fullOutput);
 
       // Issue #1276: Clear streaming error detection if agent completed successfully
       // When an error occurs during execution (e.g., timeout) but the agent recovers and completes,
@@ -857,6 +944,18 @@ export const executeAgentCommand = async params => {
         }
       }
 
+      // Issue #2141: agent CLI 0.25.5 exits 0 after `ProviderModelNotFoundError`
+      // without emitting an error event, so the run was published as a success
+      // with no result summary. Treat a fatal startup log record as the failure
+      // it is, but only when the session produced no work at all — a recovered
+      // error must keep exit code 0 authoritative (issue #1276).
+      if (exitCode === 0 && !outputError.detected && fatalLogErrorMessage && !lastTextContent) {
+        outputError.detected = true;
+        outputError.type = 'AgentFatalLog';
+        outputError.match = fatalLogErrorMessage;
+        await log(`\n⚠️  Agent exited 0 but never started a model: ${fatalLogErrorMessage}`, { level: 'warning' });
+      }
+
       if (exitCode !== 0 || outputError.detected) {
         const retryableError = classifyRetryableError(outputError.match || streamingErrorMessage || lastMessage || fullOutput);
         if (retryableError.isRetryable) {

package/src/cancelled-ci-rerun.lib.mjs

@@ -12,6 +12,7 @@
  */
 
 import { CANCELLED_CI_REVIEW_MARKER } from './tool-comments.lib.mjs';
+import { stringifyErrorValue } from './error-text.lib.mjs'; // Issue #2141
 
 const CANCELLED_OR_STALE_CONCLUSIONS = new Set(['cancelled', 'stale']);
 
@@ -122,7 +123,8 @@ const formatRunReference = run => {
 
 const formatRerunFailure = failure => {
   const runPart = formatRunReference(failure?.run);
-  const error = failure?.error || 'Unknown error';
+  // Issue #2141: the error may arrive as an object; never publish [object Object].
+  const error = stringifyErrorValue(failure?.error, { fallback: 'Unknown error' });
   return `${runPart}: ${error}`;
 };
 

package/src/claude.lib.mjs

@@ -36,6 +36,7 @@ import { createThinkingBlockRecovery } from './claude.thinking-block-recovery.li
 import { buildMissingClaudeResultMessage, collectClaudeStreamEventFacts, getClaudeMessageContent, shouldFailClaudeStreamWithoutResult } from './claude.stream-events.lib.mjs';
 import { formatNumber, mapModelToId, checkModelVisionCapability } from './claude.model-utils.lib.mjs';
 import { showResumeCommand } from './claude.resume-output.lib.mjs';
+import { stringifyErrorValue } from './error-text.lib.mjs'; // Issue #2141
 import { createPullRequestBaseBranchCommandIntervention } from './solve.pr-base-command-intervention.lib.mjs';
 export { availableModels, fetchModelInfo }; // Re-export for backward compatibility
 export { formatNumber, mapModelToId, checkModelVisionCapability };
@@ -96,7 +97,7 @@ export const validateClaudeConnection = async (model = 'haiku') => {
             const jsonMatch = text.match(/\{.*"error".*\}/);
             if (jsonMatch) {
               const errorObj = JSON.parse(jsonMatch[0]);
-              return errorObj.error;
+              return stringifyErrorValue(errorObj.error, { fallback: jsonMatch[0] }); // Issue #2141: the `error` field is usually an object
             }
           }
         } catch (e) {
@@ -936,7 +937,7 @@ export const executeClaudeCommand = async params => {
               }
               if (data.type === 'text' && data.text) lastMessage = data.text;
               else if (data.type === 'error') {
-                lastMessage = data.error || JSON.stringify(data);
+                lastMessage = stringifyErrorValue(data.error, { fallback: JSON.stringify(data) }); // Issue #2141: `data.error` is often an object; render it as text so the reason is never "[object Object]" and the substring checks below get a real string
                 if (lastMessage.includes('Internal server error')) isInternalServerError = true;
               }
               // Issue #1491: Track token usage from stream events for independent calculation
@@ -1009,7 +1010,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 +1081,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

@@ -269,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.`);
     }
@@ -285,6 +304,9 @@ export const getCodexCompletionHealth = (codexJsonState, { lastMessage = '' } =
     turnStarted,
     turnCompleted,
     turnFailed,
+    turnLifecycle,
+    echoedTurnStarts,
+    foreignThreadIds,
     reasons,
   };
 };
@@ -305,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

@@ -25,6 +25,7 @@ import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs
 import { buildSolveResumeCommand } from './solve.resume-command.lib.mjs'; // Issue #942
 const __codexBuildSolveResumeCmd = (argv, sessionId, tempDir) => (sessionId && argv?.url ? buildSolveResumeCommand({ issueUrl: argv.url, sessionId, tool: 'codex', model: argv.model, fallbackModel: argv.fallbackModel, tempDir }) : null);
 import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
+import { firstErrorText } from './error-text.lib.mjs'; // Issue #2141
 import { createLineBuffer } from './json-stream.lib.mjs'; // Issue #2119
 import { mapModelToId, resolveCodexReasoningEffort } from './codex.options.lib.mjs';
 import { buildCodexRunDiagnostics, codexRunAlreadyFailed, describeCodexLastMessageOutcome } from './codex.run-diagnostics.lib.mjs'; // Issue #2130
@@ -43,52 +44,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, '\\$&');
 
@@ -380,6 +340,12 @@ export const parseCodexExecJsonOutput = (output, state = {}, requestedModelId =
     // 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();
@@ -432,6 +398,11 @@ export const parseCodexExecJsonOutput = (output, state = {}, requestedModelId =
 
     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;
     }
@@ -440,20 +411,20 @@ export const parseCodexExecJsonOutput = (output, state = {}, requestedModelId =
       if (typeof getter(data) === 'string') observedModelPaths.add(pathName);
     }
 
-    if (eventType === 'error' && typeof data.message === 'string' && (data.message.includes('401 Unauthorized') || data.message.includes('401') || data.message.includes('Unauthorized'))) {
-      nextState.authError = true;
-    }
-
-    if (eventType === 'error' && typeof data.message === 'string') {
-      nextState.streamErrors.push({ message: data.message });
-    }
-
-    if (eventType === 'turn.failed' && typeof data.error?.message === 'string' && (data.error.message.includes('401 Unauthorized') || data.error.message.includes('401') || data.error.message.includes('Unauthorized'))) {
-      nextState.authError = true;
+    // Issue #2141: these payloads are not always strings. Requiring `typeof …
+    // === 'string'` dropped every object-shaped failure — a dropped
+    // `turn.failed` reads as a success — and interpolating one would have
+    // published "[object Object]". Render it as text instead.
+    const streamErrorText = eventType === 'error' ? firstErrorText([data.message, data.error]) : '';
+    if (streamErrorText) {
+      if (streamErrorText.includes('401') || streamErrorText.includes('Unauthorized')) nextState.authError = true;
+      nextState.streamErrors.push({ message: streamErrorText });
     }
 
-    if (eventType === 'turn.failed' && typeof data.error?.message === 'string') {
-      nextState.turnFailures.push({ message: data.error.message });
+    const turnFailureText = eventType === 'turn.failed' ? firstErrorText([data.error, data.message]) : '';
+    if (turnFailureText) {
+      if (turnFailureText.includes('401') || turnFailureText.includes('Unauthorized')) nextState.authError = true;
+      nextState.turnFailures.push({ message: turnFailureText });
     }
 
     if (eventType === 'turn.completed' && data.usage && typeof data.usage === 'object') {
@@ -1030,7 +1001,7 @@ 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);

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

@@ -97,6 +97,13 @@ export const buildCodexRunDiagnostics = ({ state = {}, exitCode = null, mappedMo
   }
   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/error-text.lib.mjs

@@ -0,0 +1,130 @@
+/**
+ * Shared human-readable rendering of structured error payloads (issue #2141).
+ *
+ * Agentic CLIs publish errors as *objects*, not strings. `@link-assistant/agent`
+ * 0.25.x emits `NamedError.toObject()`:
+ *
+ *   {"type":"error","error":{"name":"RetryTimeoutExceededError","data":{"message":"…"}}}
+ *
+ * Every adapter that interpolated such a payload into a template literal
+ * (`Agent reported error: ${outputError.match}`) destroyed the diagnosis and
+ * published `AGENT execution failed with Agent reported error: [object Object]`
+ * to the GitHub issue, which is what issue #2141 reported. This module turns any
+ * of those shapes into text a human can act on, and is reused by every tool
+ * adapter so the defect cannot come back in one CLI at a time.
+ */
+
+export const MAX_ERROR_TEXT_LENGTH = 2000;
+
+/** Text that carries no diagnostic value even though it is a non-empty string. */
+const PLACEHOLDER_ERROR_TEXTS = new Set(['[object object]', '[object error]', 'undefined', 'null', '{}', '[]']);
+
+/**
+ * `[object Object]` (and friends) must never be published as a failure reason:
+ * it is the symptom this module exists to remove, so callers can assert on it.
+ */
+export const isPlaceholderErrorText = value => {
+  if (typeof value !== 'string') return false;
+  return PLACEHOLDER_ERROR_TEXTS.has(value.trim().toLowerCase());
+};
+
+const truncateErrorText = (text, maxLength) => {
+  if (typeof text !== 'string') return '';
+  if (!Number.isFinite(maxLength) || maxLength <= 0) return text;
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, maxLength)}… (truncated)`;
+};
+
+const safeJsonStringify = value => {
+  const seen = new WeakSet();
+  try {
+    return JSON.stringify(value, (_key, entry) => {
+      if (entry && typeof entry === 'object') {
+        if (seen.has(entry)) return '[Circular]';
+        seen.add(entry);
+      }
+      if (typeof entry === 'bigint') return entry.toString();
+      if (typeof entry === 'function') return `[Function ${entry.name || 'anonymous'}]`;
+      return entry;
+    });
+  } catch {
+    return null;
+  }
+};
+
+const joinParts = parts => parts.filter(part => typeof part === 'string' && part.trim().length > 0).join(': ');
+
+const stringifyValue = (value, depth) => {
+  if (value === null || value === undefined) return '';
+  if (typeof value === 'string') return value.trim();
+  if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') return String(value);
+  if (typeof value === 'symbol' || typeof value === 'function') return String(value);
+
+  if (Array.isArray(value)) {
+    if (depth > 4) return safeJsonStringify(value) || String(value);
+    const rendered = value
+      .map(entry => stringifyValue(entry, depth + 1))
+      .filter(Boolean)
+      .join('; ');
+    return rendered || safeJsonStringify(value) || String(value);
+  }
+
+  if (typeof value !== 'object') return String(value);
+  if (depth > 4) return safeJsonStringify(value) || String(value);
+
+  if (value instanceof Error) {
+    const rendered = joinParts([value.name && value.name !== 'Error' ? value.name : '', value.message]);
+    return rendered || value.name || 'Error';
+  }
+
+  // `NamedError.toObject()` from @link-assistant/agent: {name, data:{message,…}}.
+  // The name alone ("RetryTimeoutExceededError") is already actionable, so keep
+  // it even when `data` carries no message.
+  const name = typeof value.name === 'string' && value.name.trim() ? value.name.trim() : null;
+
+  const nestedCandidates = [value.message, value.data, value.error, value.reason, value.cause, value.detail, value.details, value.description, value.hint, value.result, value.stderr];
+
+  for (const candidate of nestedCandidates) {
+    if (candidate === null || candidate === undefined) continue;
+    const rendered = stringifyValue(candidate, depth + 1);
+    if (!rendered || isPlaceholderErrorText(rendered)) continue;
+    // Avoid "Foo: Foo" when the nested value repeats the name.
+    if (name && rendered === name) return name;
+    return joinParts([name, rendered]);
+  }
+
+  if (name) return name;
+
+  const json = safeJsonStringify(value);
+  if (json && json !== '{}') return json;
+  return '';
+};
+
+/**
+ * Render any error payload (string, Error, NamedError object, nested envelope,
+ * array of the above) as a single human-readable line.
+ *
+ * @param {unknown} value - the payload as received from the tool stream.
+ * @param {object} [options]
+ * @param {number} [options.maxLength] - truncation budget for the rendered text.
+ * @param {string} [options.fallback] - returned when nothing readable is found.
+ * @returns {string} readable text, never `[object Object]`.
+ */
+export const stringifyErrorValue = (value, { maxLength = MAX_ERROR_TEXT_LENGTH, fallback = '' } = {}) => {
+  const rendered = stringifyValue(value, 0);
+  if (!rendered || isPlaceholderErrorText(rendered)) return fallback;
+  return truncateErrorText(rendered, maxLength);
+};
+
+/**
+ * Pick the first readable rendering among several candidate payloads.
+ * Used where an adapter has to try `data.message`, then `data.error`, then the
+ * raw record text (the exact chain that produced `[object Object]` before).
+ */
+export const firstErrorText = (candidates, { maxLength = MAX_ERROR_TEXT_LENGTH, fallback = '' } = {}) => {
+  for (const candidate of Array.isArray(candidates) ? candidates : [candidates]) {
+    const rendered = stringifyErrorValue(candidate, { maxLength });
+    if (rendered) return rendered;
+  }
+  return fallback;
+};

package/src/gemini.lib.mjs

@@ -17,6 +17,7 @@ import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs
 import { buildSolveResumeCommand } from './solve.resume-command.lib.mjs'; // Issue #942
 const __geminiBuildSolveResumeCmd = (argv, sessionId, tempDir) => (sessionId && argv?.url ? buildSolveResumeCommand({ issueUrl: argv.url, sessionId, tool: 'gemini', model: argv.model, fallbackModel: argv.fallbackModel, tempDir }) : null);
 import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
+import { stringifyErrorValue } from './error-text.lib.mjs'; // Issue #2141
 import { defaultModels, geminiModels, isFormalAiModel } from './models/index.mjs';
 import { isPrepareOnly, logPreparedToolCommand, resolveFormalAiToolExecution } from './formal-ai.lib.mjs';
 import { buildFormalAiPricingInfo } from './formal-ai-pricing.lib.mjs'; // Issue #2119
@@ -210,7 +211,8 @@ const applyGeminiJsonEvent = (event, nextState, modelId = null) => {
   }
 
   if (data.error) {
-    nextState.errorMessages.push(extractGeminiTextContent(data.error) || JSON.stringify(data.error));
+    // Issue #2141: prefer readable text over a raw JSON dump of the payload.
+    nextState.errorMessages.push(extractGeminiTextContent(data.error) || stringifyErrorValue(data.error, { fallback: JSON.stringify(data.error) }));
   } else if (type.toLowerCase().includes('error')) {
     nextState.errorMessages.push(text || JSON.stringify(data));
   }
@@ -462,7 +464,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/interactive-codex-events.lib.mjs

@@ -2,6 +2,7 @@
 
 import { createCollapsible, createRawJsonSection, createRedactedRawJsonSection, escapeMarkdown, redactImageData, safeJsonStringify, truncateMiddle } from './interactive-mode.shared.lib.mjs';
 import { INTERACTIVE_SESSION_STARTED_MARKER } from './tool-comments.lib.mjs';
+import { firstErrorText } from './error-text.lib.mjs'; // Issue #2141
 
 export const createCodexEventHandlers = ({ state, postComment, handleAssistantText, imageRenderer }) => {
   const handleCodexThreadStarted = async data => {
@@ -142,7 +143,9 @@ ${createRawJsonSection(data)}`);
   };
 
   const handleCodexError = async data => {
-    const message = data.message || data.error?.message || 'Unknown Codex error';
+    // Issue #2141: `data.error` is often an object, so render it as text instead
+    // of letting `[object Object]` reach the GitHub comment.
+    const message = firstErrorText([data?.message, data?.error, data], { fallback: 'Unknown Codex error' });
     await postComment(`## ❌ Codex error
 
 ${createCollapsible('View error', escapeMarkdown(message), true)}

package/src/lib.mjs

@@ -2,6 +2,7 @@
 import { ensureUseM } from './use-m-bootstrap.lib.mjs';
 import { createCredentialStreamSanitizer, maskToken, sanitizeCredentialText } from './credential-sanitization-core.lib.mjs';
 import { recordLogBytes, resetLogGrowth } from './log-growth.lib.mjs'; // issue #2135: notice a session log that is running away
+import { isPlaceholderErrorText } from './error-text.lib.mjs'; // issue #2141: never publish "[object Object]" as a reason
 
 export { maskToken };
 
@@ -95,10 +96,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 +112,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 +159,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 {
@@ -747,6 +763,9 @@ export const isMeaningfulErrorText = value => {
   if (!value || typeof value !== 'string') return false;
   const collapsed = value.replace(/\s+/g, ' ').trim();
   if (!collapsed) return false;
+  // Issue #2141: "[object Object]" has letters, but it is the *absence* of an
+  // error message — a structured payload that was stringified by mistake.
+  if (isPlaceholderErrorText(collapsed)) return false;
   // Require at least one Unicode letter or number; pure punctuation/brackets
   // (e.g. "}", "{", "[]", ",") are stream fragments, not real errors.
   return /[\p{L}\p{N}]/u.test(collapsed);
@@ -805,6 +824,13 @@ export const extractToolErrorCore = ({ toolResult } = {}) => {
   // Issue #1941: reject stray fragments with no letters/digits (e.g. "}").
   if (!isMeaningfulErrorText(rawCore)) return null;
 
+  // Issue #2141: a core that embeds "[object Object]" (e.g. "Agent reported
+  // error: [object Object]") carries no diagnosis at all. Publishing the generic
+  // phrase is more honest than publishing a stringified object, and it keeps the
+  // symptom out of GitHub comments even if a new adapter forgets to render its
+  // payload as text.
+  if (rawCore.includes('[object Object]')) return null;
+
   // Collapse to a single clean line and strip noise.
   const core = rawCore.replace(/\s+/g, ' ').trim();
   return core || null;

package/src/opencode.lib.mjs

@@ -394,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;
 

package/src/qwen.lib.mjs

@@ -27,6 +27,7 @@ import { getCumulativeContextInputTokens, getRestoredContextInputTokens, toToken
 import { ensureAiToolScratchIgnored, filterAiToolScratchFromStatus } from './ai-tool-scratch.lib.mjs';
 import { getTerminalEventCompletionHealth } from './tool-run-health.lib.mjs'; // Issue #1990
 import { takeJsonRecords } from './json-stream.lib.mjs'; // Issue #2119
+import { stringifyErrorValue } from './error-text.lib.mjs'; // Issue #2141
 
 export const mapModelToId = model => qwenModels[model] || model;
 
@@ -41,18 +42,6 @@ const isQwenAuthError = output => {
   return text.includes('401') || text.includes('unauthorized') || text.includes('authentication') || text.includes('auth') || text.includes('login') || text.includes('api key') || text.includes('oauth free tier');
 };
 
-const stringifyErrorValue = value => {
-  if (value === null || value === undefined) return '';
-  if (typeof value === 'string') return value;
-  if (typeof value?.message === 'string') return value.message;
-  if (typeof value?.error?.message === 'string') return value.error.message;
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-};
-
 const getNestedValue = (object, pathParts) => {
   let cursor = object;
   for (const part of pathParts) {
@@ -566,7 +555,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);
         }

package/src/solve.pre-pr-failure-notifier.lib.mjs

@@ -12,6 +12,14 @@ const truncate = (value, maxLength = 2000) => {
 
 const fence = value => truncate(value || 'Unknown error').replaceAll('```', '` ` `');
 
+/**
+ * Issue #2141: the failure comment was the *only* record of the run — the reason
+ * said "Agent reported error: [object Object]", `--attach-logs` was off, and the
+ * session log was never published, so the root cause could not be recovered
+ * afterwards. Say what is missing and how to make the next run diagnosable.
+ */
+const buildLogLine = logAttachmentAttempted => (logAttachmentAttempted ? 'Log attachment was attempted but failed. Check the solver terminal log for the complete failure output.' : 'Logs were not attached because `--attach-logs` was not enabled, so this comment is the only surviving record of the failure. Rerun with `--attach-logs --verbose` to publish the full session log with the raw tool error records.');
+
 const isForkDivergenceFailure = reason => {
   const normalizedReason = String(reason || '').toLowerCase();
   return normalizedReason.includes('fork divergence') || (normalizedReason.includes('fork') && normalizedReason.includes('non-fast-forward')) || normalizedReason.includes('force-with-lease');
@@ -124,7 +132,7 @@ export function resolvePreExitFailureNotificationTarget({ code, globalState }) {
 export function buildPrePullRequestFailureComment({ reason, owner, repo, issueNumber, argv = {}, logAttachmentAttempted = false, failureActionSection = null }) {
   const tool = argv.tool || 'claude';
   const modelLine = argv.model ? `\n- **Requested model**: \`${argv.model}\`` : '';
-  const logLine = logAttachmentAttempted ? 'Log attachment was attempted but failed. Check the solver terminal log for the complete failure output.' : 'Logs were not attached because `--attach-logs` was not enabled.';
+  const logLine = buildLogLine(logAttachmentAttempted);
   const actionSection = failureActionSection || buildPrePullRequestFailureActionSection(reason);
 
   return `## 🚨 ${SOLUTION_DRAFT_FAILED_MARKER}
@@ -151,7 +159,7 @@ export function buildExistingPullRequestFailureComment({ reason, owner, repo, pr
   const tool = argv.tool || 'claude';
   const modelLine = argv.model ? `\n- **Requested model**: \`${argv.model}\`` : '';
   const issueLine = issueNumber ? `\n- **Linked issue**: #${issueNumber}` : '';
-  const logLine = logAttachmentAttempted ? 'Log attachment was attempted but failed. Check the solver terminal log for the complete failure output.' : 'Logs were not attached because `--attach-logs` was not enabled.';
+  const logLine = buildLogLine(logAttachmentAttempted);
   const actionSection = failureActionSection || buildPrePullRequestFailureActionSection(reason);
 
   return `## 🚨 ${SOLUTION_DRAFT_FAILED_MARKER}