@link-assistant/hive-mind 2.11.11 → 2.11.13

package/CHANGELOG.md

@@ -1,5 +1,85 @@
 # @link-assistant/hive-mind
 
+## 2.11.13
+
+### Patch Changes
+
+- 61f20ce: Closed issues no longer stop the mergeable loop, and every stop is now explained
+  in a GitHub comment (issue #2144).
+
+  A `solve …/pull/927 --auto-merge` run stopped after its first monitoring
+  iteration with `❌ GITHUB TARGET UNAVAILABLE: Issue #905 has been closed.` — in
+  the _same_ probe that reported the pull request as `"mergeable": true,
+"mergeable_state": "clean"`. Nothing was posted to GitHub and the process exited
+  `0`, so the run looked successful while the pull request sat unmerged until a
+  human merged it manually two hours later.
+
+  - `src/github-terminal-state.lib.mjs` now distinguishes _terminal_ states from
+    _merge blockers_. A closed or deleted **issue** is a merge blocker: the loop
+    keeps working to make the pull request mergeable. Only the pull request being
+    merged, closed or unreachable — or the repository/branches it needs being gone
+    — stops the loop.
+  - A closed issue holds back `--auto-merge` only. When it does, the tool comments
+    that the pull request is ready and asks the user to reopen the issue or merge
+    manually, instead of stopping silently.
+  - New `src/automation-stop-reporting.lib.mjs`: a registry of 13 stop reasons,
+    each with a title, an explanation and concrete next steps, plus a deduped,
+    never-throwing reporter. It is wired into all 11 stop paths of
+    `--auto-merge`, `--auto-restart-until-mergeable` and `--watch`. Unknown reason
+    codes degrade to a generic comment, so a new stop can never regress to
+    silence.
+  - `attemptAutoMerge` was extracted into
+    `src/solve.auto-merge-attempt.lib.mjs` to stay within the repository's
+    file-length policy.
+  - Fixed a second defect found in the same log: the quiet GitHub probes from
+    issue #2130 were silently defeated because all three callers injected their own
+    mirroring `$`, so ~33 KB of pull request JSON plus the full issue payload were
+    written to the attached log on every iteration. They now pass
+    `quietProbe($)`, with a regression test.
+
+  Timeline, requirement inventory, root causes, edge cases and the codebase sweep:
+  `docs/case-studies/issue-2144/README.md`. Reproduction:
+  `experiments/issue-2144/repro-closed-issue-stops-loop.mjs`.
+
+## 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.13",
   "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/automation-stop-reporting.lib.mjs

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+
+/**
+ * Announce on GitHub *why* a long-running automation loop stopped.
+ *
+ * Issue #2144: `--auto-restart-until-mergeable` and `--watch` used to exit
+ * silently on several paths (terminal GitHub entity states, tool execution
+ * failures, auto-resume limit). The reported incident stopped the loop on an
+ * open, mergeable pull request because its linked issue was closed, and left
+ * no GitHub comment at all — from the pull request's point of view the
+ * automation simply vanished.
+ *
+ * Two things live here:
+ *   1. A registry that turns an internal stop reason into human-readable text
+ *      (what happened, what it means, what the user should do next).
+ *   2. `reportAutomationStop`, which posts that text as a deduplicated,
+ *      tracked tool comment. Every stop path calls it, so "we stopped and
+ *      exactly why" is always published.
+ *
+ * The module is intentionally free of top-level `command-stream` /`use-m`
+ * imports: the comment builders are pure functions and can be unit-tested
+ * without a GitHub environment. The `$` helper is passed in by callers.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/2144
+ */
+
+import { AUTOMATION_STOPPED_MARKER, AUTO_MERGE_BLOCKED_MARKER, postTrackedComment } from './tool-comments.lib.mjs';
+
+export { AUTOMATION_STOPPED_MARKER, AUTO_MERGE_BLOCKED_MARKER };
+
+/**
+ * Human-readable descriptions for every stop reason the solver can return.
+ *
+ * `canComment: false` marks reasons where the comment target itself is gone
+ * (deleted repository / pull request), so posting is skipped instead of
+ * producing a guaranteed API failure.
+ */
+export const STOP_REASONS = {
+  pull_request_closed: {
+    title: 'the pull request was closed without merging',
+    detail: 'A closed pull request can never become mergeable, so continuing to work on it would be pointless.',
+    nextSteps: ['Reopen the pull request and re-run the command to continue.'],
+  },
+  pull_request_unavailable: {
+    title: 'the pull request is no longer accessible',
+    detail: 'GitHub answered with 404/410 for this pull request (deleted, transferred, or access revoked).',
+    nextSteps: ['Verify the pull request still exists and that the token has access to it.'],
+    canComment: false,
+  },
+  repository_unavailable: {
+    title: 'the repository is no longer accessible',
+    detail: 'GitHub answered with 404/410 for the repository (deleted, renamed, made private, or access revoked).',
+    nextSteps: ['Verify the repository still exists and that the token has access to it.'],
+    canComment: false,
+  },
+  source_branch_unavailable: {
+    title: 'the source branch of the pull request is gone',
+    detail: 'The head branch (or its repository) is no longer accessible, so no further commits can be pushed to this pull request.',
+    nextSteps: ['Restore the source branch, or open a new pull request from a branch that still exists.'],
+  },
+  target_branch_unavailable: {
+    title: 'the target branch of the pull request is gone',
+    detail: 'The base branch (or its repository) is no longer accessible, so this pull request can never be merged as-is.',
+    nextSteps: ['Restore the base branch, or retarget this pull request to an existing branch.'],
+  },
+  terminal_github_entity_error: {
+    title: 'a GitHub entity required by this automation is no longer accessible',
+    detail: 'A repository, pull request, or branch answered with 404/410 while checking CI status.',
+    nextSteps: ['Verify the repository, pull request, and branches still exist and that the token has access to them.'],
+  },
+  auto_resume_limit_reached: {
+    title: 'the usage-limit auto-resume budget was exhausted',
+    detail: 'The AI session hit provider usage limits more times than `--auto-resume-max-iterations` allows.',
+    nextSteps: ['Re-run the command after the usage limit resets, or raise `--auto-resume-max-iterations`.'],
+  },
+  tool_failure: {
+    title: 'the AI session failed',
+    detail: 'The AI tool exited with an error that is not a usage limit, so restarting it automatically would most likely fail the same way.',
+    nextSteps: ['Review the attached working session log for the failure, fix the cause, and re-run the command.'],
+  },
+  tool_failure_after_resume: {
+    title: 'the AI session failed after resuming from a usage limit',
+    detail: 'The session was resumed once the usage limit reset, but the resumed run exited with an error.',
+    nextSteps: ['Review the attached working session log for the failure, fix the cause, and re-run the command.'],
+  },
+  merge_failed: {
+    title: 'GitHub refused the merge',
+    detail: 'Every merge requirement was satisfied, but the merge API call itself failed (branch protection, required reviews, or a race with another push).',
+    nextSteps: ['Check the branch protection rules and required reviews, then merge manually or re-run the command.'],
+  },
+  issue_closed: {
+    title: 'the linked issue is closed, so auto-merge was held back',
+    detail: 'The pull request is ready to merge. A closed issue never stops work on the pull request — it only blocks the automatic merge.',
+    nextSteps: ['Reopen the linked issue and re-run the command so auto-merge can complete.', 'Or merge this pull request manually — it is ready.'],
+  },
+  issue_unavailable: {
+    title: 'the linked issue is no longer accessible, so auto-merge was held back',
+    detail: 'The pull request is ready to merge. A missing issue never stops work on the pull request — it only blocks the automatic merge.',
+    nextSteps: ['Restore or re-create the linked issue and re-run the command so auto-merge can complete.', 'Or merge this pull request manually — it is ready.'],
+  },
+  watch_stopped: {
+    title: 'watch mode stopped',
+    detail: 'The watch loop reached a state where it can no longer make progress.',
+    nextSteps: ['Re-run the command once the reported condition is resolved.'],
+  },
+};
+
+const MODE_LABELS = {
+  'auto-restart-until-mergeable': '`--auto-restart-until-mergeable`',
+  'auto-merge': '`--auto-merge`',
+  watch: '`--watch`',
+};
+
+/**
+ * Resolve a stop reason to its description, with a safe fallback so an unknown
+ * or newly added reason is still reported (never silently swallowed).
+ *
+ * @param {string} reason
+ * @returns {{reason: string, title: string, detail: string, nextSteps: string[], canComment: boolean, known: boolean}}
+ */
+export const describeStopReason = reason => {
+  const key = String(reason || 'unknown');
+  const known = Object.prototype.hasOwnProperty.call(STOP_REASONS, key);
+  const entry = known ? STOP_REASONS[key] : null;
+  return {
+    reason: key,
+    title: entry?.title || `the automation stopped with reason \`${key}\``,
+    detail: entry?.detail || 'No further automatic progress is possible in this state.',
+    nextSteps: entry?.nextSteps || ['Review the working session log, resolve the reported condition, and re-run the command.'],
+    canComment: entry?.canComment !== false,
+    known,
+  };
+};
+
+const bulletList = lines =>
+  (lines || [])
+    .filter(Boolean)
+    .map(line => `- ${line}`)
+    .join('\n');
+
+/**
+ * Build the "automation stopped" comment body.
+ *
+ * @param {Object} options
+ * @param {string} options.reason internal stop reason
+ * @param {string} [options.mode] which loop stopped
+ * @param {string} [options.message] concrete message from the detector
+ * @param {string[]} [options.details] extra evidence lines
+ * @returns {string} markdown comment body
+ */
+export const buildAutomationStopComment = ({ reason, mode = null, message = null, details = [] }) => {
+  const description = describeStopReason(reason);
+  const modeLabel = MODE_LABELS[mode] || (mode ? `\`${mode}\`` : 'This automation');
+  const sections = [`## 🛑 ${AUTOMATION_STOPPED_MARKER}: ${description.title}`, '', `${modeLabel} stopped working on this pull request.`, '', `**Reason code:** \`${description.reason}\``];
+
+  if (message) {
+    sections.push('', `**What happened:** ${message}`);
+  }
+  sections.push('', description.detail);
+
+  const evidence = (details || []).filter(Boolean);
+  if (evidence.length > 0) {
+    sections.push('', '**Details:**', bulletList(evidence));
+  }
+
+  sections.push('', '**What to do next:**', bulletList(description.nextSteps));
+  sections.push('', '---', `*Reported automatically by hive-mind (${mode || 'automation'}).*`);
+
+  return sections.join('\n');
+};
+
+/**
+ * Build the comment posted when the pull request is ready but `--auto-merge`
+ * is blocked by the state of the linked issue.
+ *
+ * Issue #2144: a closed issue must never stop the loop from making the pull
+ * request mergeable — it only blocks the *automatic* merge, and then the user
+ * is asked to reopen the issue or merge manually.
+ *
+ * @param {Object} options
+ * @param {Array<{reason: string, message: string, resolution?: string, details?: string[]}>} options.blockers
+ * @param {number|string|null} [options.issueNumber]
+ * @returns {string} markdown comment body
+ */
+export const buildAutoMergeBlockedComment = ({ blockers = [], issueNumber = null }) => {
+  const reasons = blockers.filter(Boolean);
+  const sections = [`## ⚠️ ${AUTO_MERGE_BLOCKED_MARKER}: this pull request is ready, but it was not merged automatically`, '', 'All merge requirements are satisfied — CI passed, there are no conflicts, and there are no pending changes.', '', 'Auto-merge (`--auto-merge`) was requested but is being held back:'];
+
+  for (const blocker of reasons) {
+    sections.push('', `- **${blocker.message}** (\`${blocker.reason}\`)`);
+    for (const detail of blocker.details || []) {
+      sections.push(`  - ${detail}`);
+    }
+    if (blocker.resolution) {
+      sections.push(`  - ➡️ ${blocker.resolution}`);
+    }
+  }
+
+  sections.push('', '**What to do next:**');
+  sections.push(bulletList([issueNumber ? `Reopen issue #${issueNumber} and re-run the command so auto-merge can complete.` : 'Reopen the linked issue and re-run the command so auto-merge can complete.', 'Or merge this pull request manually — it is ready.']));
+  sections.push('', '---', '*Reported automatically by hive-mind with the --auto-merge flag.*');
+
+  return sections.join('\n');
+};
+
+/**
+ * Post a stop report to the pull request (or issue), deduplicated per reason.
+ *
+ * Never throws: a failed comment must not mask the stop itself.
+ *
+ * @param {Object} options
+ * @param {Function} options.$ command-stream tagged template
+ * @param {string} options.owner
+ * @param {string} options.repo
+ * @param {number|string} options.targetNumber pull request (or issue) number
+ * @param {string} options.reason
+ * @param {string} [options.mode]
+ * @param {string} [options.message]
+ * @param {string[]} [options.details]
+ * @param {boolean} [options.verbose]
+ * @param {Function} [options.log]
+ * @param {string} [options.body] pre-built body (skips buildAutomationStopComment)
+ * @param {string} [options.signature] pre-built dedup signature
+ * @returns {Promise<{posted: boolean, reason: string, skipped?: string, error?: string}>}
+ */
+export const reportAutomationStop = async ({ $, owner, repo, targetNumber, reason, mode = null, message = null, details = [], verbose = false, log = null, body = null, signature = null }) => {
+  const description = describeStopReason(reason);
+  const write = async text => {
+    if (typeof log === 'function') await log(text);
+  };
+
+  if (!$ || !owner || !repo || !targetNumber) {
+    return { posted: false, reason: description.reason, skipped: 'missing_target' };
+  }
+
+  if (!description.canComment) {
+    await write(`   ℹ️  Not posting a stop comment: ${description.title}`);
+    return { posted: false, reason: description.reason, skipped: 'target_unavailable' };
+  }
+
+  const commentBody = body || buildAutomationStopComment({ reason, mode, message, details });
+  const dedupSignature = signature || `${AUTOMATION_STOPPED_MARKER}: ${description.title}`;
+
+  try {
+    const { checkForExistingComment } = await import('./solve.auto-merge-helpers.lib.mjs');
+    const alreadyPosted = await checkForExistingComment(owner, repo, targetNumber, dedupSignature, verbose);
+    if (alreadyPosted) {
+      await write(`   ℹ️  Stop reason already reported on #${targetNumber} (${description.reason})`);
+      return { posted: false, reason: description.reason, skipped: 'duplicate' };
+    }
+
+    const result = await postTrackedComment({ $, owner, repo, targetNumber, body: commentBody });
+    if (!result.ok) {
+      await write(`   ⚠️  Could not post stop reason comment: ${result.stderr || 'unknown error'}`);
+      return { posted: false, reason: description.reason, error: result.stderr || 'post_failed' };
+    }
+
+    await write(`   💬 Posted stop reason to #${targetNumber}: ${description.title}`);
+    return { posted: true, reason: description.reason };
+  } catch (error) {
+    await write(`   ⚠️  Could not post stop reason comment: ${error.message}`);
+    return { posted: false, reason: description.reason, error: error.message };
+  }
+};
+
+export default {
+  STOP_REASONS,
+  describeStopReason,
+  buildAutomationStopComment,
+  buildAutoMergeBlockedComment,
+  reportAutomationStop,
+};

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') {