@link-assistant/hive-mind 2.11.11 → 2.11.12

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # @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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "2.11.11",
+  "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

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
@@ -410,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;
+    // 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 === '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;
-    }
-
-    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') {

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));
   }

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 };
 
@@ -762,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);
@@ -820,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/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) {

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}