@link-assistant/hive-mind 1.73.7 → 1.73.9

package/CHANGELOG.md

@@ -1,5 +1,73 @@
 # @link-assistant/hive-mind
 
+## 1.73.9
+
+### Patch Changes
+
+- 0a5b615: fix(telegram): list currently-executing tasks in `/solve_queue` (`/queue`), not just count them (#1837)
+
+  After the original #1837 work added clickable lists, the detailed status still
+  showed only a `processing: N` **count** for in-flight work — the executing task
+  itself was never rendered as a clickable link, which is exactly the case the
+  issue cares most about ("search tasks that are stuck or yet executing").
+
+  Root cause: the processing **count** comes from the external snapshot
+  (`max(pgrep, tracked-isolation-session count)`), but the processing **list**
+  iterated the queue's own in-memory `processing` Map. `executeItem()` deletes an
+  item from that Map the moment the work is dispatched to a detached
+  screen/isolation session, so while a task is actually executing the Map is empty
+  — count says `1`, list shows nothing.
+
+  The fix sources the executing items from the same place the count comes from. A
+  new `getRunningSessionItems()` in `session-monitor.lib.mjs` returns the
+  currently-running detached sessions (with their GitHub `url`, `tool`, `status`,
+  `startTime`), reusing the existing isolation `$ --status` / non-isolation
+  screen-liveness checks. New helpers `collectExecutingItems` and
+  `formatQueueProcessingItems` merge those sessions with the in-memory Map (deduped
+  by normalized GitHub URL, filtered by tool) and render them as the `▶️
+[owner/repo#n](url) (status, duration)` lines, capped with `... and N more`.
+  `formatDetailedStatus()` now lists executing tasks from this merged source.
+
+  Adds `tests/test-issue-1837-executing-list.mjs` plus new `solve-queue.test.mjs`
+  cases, and documents the root cause and fix in `docs/case-studies/issue-1837`.
+
+## 1.73.8
+
+### Patch Changes
+
+- 324ed89: fix(solve): surface the core tool error instead of bare `CLAUDE execution failed` (#1845)
+
+  When an AI tool run failed, both the terminal and the posted GitHub
+  `🚨 Solution Draft Failed` comment showed only the generic
+  `CLAUDE execution failed`, even though the underlying tool had reported a
+  specific cause (for example `API Error: Output blocked by content filtering
+policy`). The real message was captured inside the tool runner but dropped at
+  the failure-return boundary, so no downstream consumer could display it.
+
+  Every AI tool runner now surfaces a structured `errorInfo` (with a `.message`)
+  on its failure returns (`claude`, `gemini`, `opencode`, `qwen`; `codex` and
+  `agent` already did). Two shared helpers in `lib.mjs` — `extractToolErrorCore`
+  (the core error string) and `formatToolExecutionFailure` (the full
+  `CLAUDE execution failed with API Error: Output blocked by content filtering
+policy` message) — share one precedence so every surface stays consistent.
+  All failure sites now use them: `solve.mjs` (terminal exit, GitHub failure
+  comment, critical-error auto-commit reason), `solve.auto-merge.lib.mjs` and
+  `solve.watch.lib.mjs` (GitHub message + new terminal `Error details:` lines),
+  and `review.mjs`. The helpers collapse whitespace, cap the core error length,
+  and never fall back to the agent's success summary.
+
+  `isApiError` in `solve.restart-shared.lib.mjs` now classifies through the same
+  extractor, so a Claude `API Error:` reported via `errorInfo` (never `result`)
+  is detected and watch mode's `MAX_API_ERROR_RETRIES` backoff guard keeps
+  working instead of retrying forever.
+
+  The auto-commit-on-critical-error path (#1834) is confirmed to run on the
+  failure exit and is now labeled with the real failure cause; the same guarded
+  auto-commit is also added to `handleFailure()` so the `uncaughtException`,
+  `unhandledRejection`, and top-level-catch exits preserve uncommitted work too.
+  Adds unit, cross-tool, auto-commit, and `isApiError` tests plus a deep case
+  study in `docs/case-studies/issue-1845`.
+
 ## 1.73.7
 
 ### Patch Changes

package/package.json

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

package/src/claude.lib.mjs

@@ -1191,6 +1191,8 @@ export const executeClaudeCommand = async params => {
             is503Error,
             anthropicTotalCostUSD,
             resultSummary,
+            // Issue #1845: surface the actual error so callers can show it to users
+            errorInfo: { message: lastMessage || 'API explicitly marked error as not retryable', exitCode },
             queuedFeedback, // Issue #817: Bidirectional mode feedback
           };
         }
@@ -1235,6 +1237,8 @@ export const executeClaudeCommand = async params => {
             is503Error, // preserve for callers that check this
             anthropicTotalCostUSD, // Issue #1104: Include cost even on failure
             resultSummary, // Issue #1263: Include result summary
+            // Issue #1845: surface the actual error so callers can show it to users
+            errorInfo: { message: lastMessage || `Transient API error persisted after ${maxRetries} retries`, exitCode },
             queuedFeedback, // Issue #817: Bidirectional mode feedback
           };
         }
@@ -1294,6 +1298,9 @@ export const executeClaudeCommand = async params => {
           errorDuringExecution,
           anthropicTotalCostUSD, // Issue #1104: Include cost even on failure
           resultSummary, // Issue #1263: Include result summary
+          // Issue #1845: surface the core error (e.g. "API Error: Output blocked by content
+          // filtering policy") so users see what actually went wrong, not just a generic message.
+          errorInfo: { message: lastMessage || `Claude command failed with exit code ${exitCode}`, exitCode },
           queuedFeedback, // Issue #817: Bidirectional mode feedback
         };
       }
@@ -1374,6 +1381,8 @@ export const executeClaudeCommand = async params => {
         toolUseCount,
         anthropicTotalCostUSD, // Issue #1104: Include cost even on failure
         resultSummary, // Issue #1263: Include result summary
+        // Issue #1845: surface the actual exception message so callers can show it to users
+        errorInfo: { message: error.message || error.toString() },
         queuedFeedback, // Issue #817: Bidirectional mode feedback
       };
     }

package/src/gemini.lib.mjs

@@ -575,6 +575,8 @@ export const executeGeminiCommand = async params => {
           pricingInfo: { modelId: mappedModel, modelName: mappedModel, provider: 'Google', totalCostUSD: null },
           publicPricingEstimate: null,
           resultSummary: geminiJsonState.resultSummary || null,
+          // Issue #1845: surface the actual error so callers can show it to users
+          errorInfo: { message: errorText || `Gemini command failed with exit code ${exitCode}`, exitCode },
         };
       }
 
@@ -616,6 +618,8 @@ export const executeGeminiCommand = async params => {
         pricingInfo: null,
         publicPricingEstimate: null,
         resultSummary: null,
+        // Issue #1845: surface the actual exception message so callers can show it to users
+        errorInfo: { message: error.message || error.toString() },
       };
     }
   };

package/src/lib.mjs

@@ -664,6 +664,67 @@ export const cleanErrorMessage = error => {
   return message;
 };
 
+/**
+ * Extract the core/root error string from a tool runner result (Issue #1845).
+ *
+ * Applies a single precedence everywhere so every failure surface shows the
+ * same root cause: `errorInfo.message` → `errorInfo.errorMatch` → string
+ * `errorInfo` → `result`. Returns a collapsed single line, or null when no
+ * usable error string is available. Shared by `formatToolExecutionFailure`
+ * (GitHub comments / exit message) and the terminal "Error details:" lines in
+ * watch / auto-merge so they never diverge.
+ *
+ * @param {Object} options
+ * @param {Object} [options.toolResult] - Result object returned by the tool runner
+ * @returns {string|null} The core error string, or null when none is available
+ */
+export const extractToolErrorCore = ({ toolResult } = {}) => {
+  // Prefer the structured error message surfaced by the tool runner. We do NOT
+  // fall back to resultSummary here, because that holds the agent's normal
+  // work summary on success and would be misleading when used as an error.
+  const errorInfo = toolResult?.errorInfo;
+  const rawCore = errorInfo?.message || errorInfo?.errorMatch || (typeof errorInfo === 'string' ? errorInfo : null) || toolResult?.result || null;
+
+  if (!rawCore || typeof rawCore !== 'string') return null;
+
+  // Collapse to a single clean line and strip noise.
+  const core = rawCore.replace(/\s+/g, ' ').trim();
+  return core || null;
+};
+
+/**
+ * Build a user-facing tool execution failure message that includes the core
+ * error reported by the underlying tool (Issue #1845).
+ *
+ * Previously users only saw the generic "<TOOL> execution failed" and had to
+ * dig through the full failure log to discover what actually went wrong (for
+ * example "API Error: Output blocked by content filtering policy"). When the
+ * tool runner surfaces a specific error this appends it so the failure is
+ * self-explanatory:
+ *
+ *   "CLAUDE execution failed with API Error: Output blocked by content filtering policy"
+ *
+ * Falls back to the generic phrase when no specific error is available.
+ *
+ * @param {Object} options
+ * @param {string} [options.tool] - Tool name (e.g. 'claude'); defaults to 'claude'
+ * @param {Object} [options.toolResult] - Result object returned by the tool runner
+ * @param {number} [options.maxLength=300] - Max length of the appended core error
+ * @returns {string} The formatted failure message
+ */
+export const formatToolExecutionFailure = ({ tool, toolResult, maxLength = 300 } = {}) => {
+  const base = `${(tool || 'claude').toUpperCase()} execution failed`;
+
+  let core = extractToolErrorCore({ toolResult });
+  if (!core) return base;
+
+  // Avoid duplicating the base phrase if the core error already contains it.
+  if (core.toLowerCase().includes('execution failed')) return base;
+
+  if (core.length > maxLength) core = `${core.slice(0, maxLength - 1)}…`;
+  return `${base} with ${core}`;
+};
+
 /**
  * Format aligned console output
  * @param {string} icon - Icon to display

package/src/opencode.lib.mjs

@@ -466,6 +466,8 @@ export const executeOpenCodeCommand = async params => {
           permissionPromptDetected: true,
           ...pricingResult,
           resultSummary: lastTextContent || null, // Issue #1263: Use last text content from JSON output stream
+          // Issue #1845: surface the actual error so callers can show it to users
+          errorInfo: { message: 'OpenCode requested an interactive permission prompt (non-interactive run cannot continue)' },
         };
       }
 
@@ -528,6 +530,8 @@ export const executeOpenCodeCommand = async params => {
           limitResetTime,
           ...pricingResult,
           resultSummary: lastTextContent || null, // Issue #1263: Use last text content from JSON output stream
+          // Issue #1845: surface the actual error so callers can show it to users
+          errorInfo: { message: lastMessage || allOutput || `OpenCode command failed with exit code ${exitCode}`, exitCode },
         };
       }
 
@@ -593,6 +597,8 @@ export const executeOpenCodeCommand = async params => {
         pricingInfo: null,
         publicPricingEstimate: null,
         resultSummary: null, // Issue #1263: No result summary available on error
+        // Issue #1845: surface the actual exception message so callers can show it to users
+        errorInfo: { message: error.message || error.toString() },
       };
     }
   };

package/src/qwen.lib.mjs

@@ -632,6 +632,8 @@ export const executeQwenCommand = async params => {
           limitResetTime: null,
           ...usageResult,
           resultSummary,
+          // Issue #1845: surface the actual error so callers can show it to users
+          errorInfo: { message: combinedErrorText || errorMessage || `Qwen Code command failed${exitCode !== 0 ? ` with exit code ${exitCode}` : ''}`, exitCode },
         };
       }
 
@@ -665,6 +667,8 @@ export const executeQwenCommand = async params => {
         publicPricingEstimate: null,
         tokenUsage: null,
         resultSummary: null,
+        // Issue #1845: surface the actual exception message so callers can show it to users
+        errorInfo: { message: error.message || error.toString() },
       };
     }
   };

package/src/review.mjs

@@ -43,7 +43,7 @@ const path = (await use('path')).default;
 const fs = (await use('fs')).promises;
 
 // Import shared functions from lib.mjs to follow DRY principle
-import { log, setLogFile, getLogFile, formatAligned } from './lib.mjs';
+import { log, setLogFile, getLogFile, formatAligned, extractToolErrorCore } from './lib.mjs';
 import { parseCliArgumentsWithLino } from './cli-arguments.lib.mjs';
 import { reportError } from './sentry.lib.mjs';
 import * as memoryCheck from './memory-check.mjs';
@@ -398,7 +398,9 @@ Review this pull request thoroughly.`;
 
   // Handle command failure
   if (!commandSuccess) {
-    await log('\n❌ Command execution failed. Check the log file for details.');
+    // Issue #1845: surface the core error (e.g. "API Error: ...") instead of just a generic message.
+    const reviewErrorCore = extractToolErrorCore({ toolResult: result });
+    await log(`\n❌ Command execution failed${reviewErrorCore ? ` with ${reviewErrorCore}` : '. Check the log file for details.'}`);
     await log(`📁 Log file: ${getLogFile()}`);
     process.exit(1);
   }

package/src/session-monitor.lib.mjs

@@ -578,6 +578,78 @@ export async function getRunningTrackedIsolationSessions(verbose = false, option
   return { count: sessions.length, sessions, byTool };
 }
 
+/**
+ * Return the currently-executing tracked sessions with the details needed to
+ * render them as a clickable list in `/solve_queue` (`/queue`): the issue/PR
+ * `url`, the `tool`, the start time, and (for isolation sessions) the backend
+ * status. Both isolation and non-isolation screen sessions are included so the
+ * list matches what is actually executing — the queue's own in-memory
+ * `processing` Map is empty once a task has been dispatched to a detached
+ * session, which is why executing tasks were previously not listed.
+ *
+ * Liveness is determined the same way as {@link monitorSessions}: isolation
+ * sessions via `$ --status`, non-isolation screen sessions via a timeout window
+ * plus a best-effort `screen -ls` check.
+ *
+ * @param {boolean} verbose - Whether to log verbose output
+ * @param {Object} [options] - Test/support options
+ * @param {Function} [options.statusProvider] - Optional `$ --status` provider
+ * @param {Function} [options.screenChecker] - Optional screen-existence checker
+ * @returns {Promise<Array<{sessionName: string, url: string|null, tool: string, status: string|null, startTime: (Date|string|number|null), isolationBackend: (string|null)}>>}
+ * @see https://github.com/link-assistant/hive-mind/issues/1837
+ */
+export async function getRunningSessionItems(verbose = false, options = {}) {
+  const items = [];
+  const screenChecker = options.screenChecker || checkScreenSessionExists;
+
+  for (const [sessionName, sessionInfo] of activeSessions.entries()) {
+    let running = false;
+    let status = null;
+
+    if (sessionInfo.isolationBackend) {
+      const state = await getIsolationSessionState(sessionName, sessionInfo, {
+        verbose,
+        statusProvider: options.statusProvider,
+      });
+      running = state.running;
+      status = state.status || null;
+      if (!running) {
+        sessionInfo.lastKnownStatus = state.status || null;
+        sessionInfo.lastKnownExitCode = state.exitCode ?? null;
+        continue;
+      }
+    } else {
+      const startTime = sessionInfo.startTime instanceof Date ? sessionInfo.startTime : new Date(sessionInfo.startTime);
+      const elapsed = Date.now() - startTime.getTime();
+      if (elapsed >= NON_ISOLATION_SESSION_TIMEOUT_MS) {
+        if (verbose) {
+          console.log(`[VERBOSE] Non-isolation session ${sessionName} expired after ${Math.round(elapsed / 1000)}s; excluded from running list`);
+        }
+        continue;
+      }
+      running = await screenChecker(sessionName);
+      if (!running) {
+        continue;
+      }
+    }
+
+    items.push({
+      sessionName,
+      url: sessionInfo.url || null,
+      tool: sessionInfo.tool || 'claude',
+      status,
+      startTime: sessionInfo.startTime || null,
+      isolationBackend: sessionInfo.isolationBackend || null,
+    });
+  }
+
+  if (verbose) {
+    console.log(`[VERBOSE] getRunningSessionItems found ${items.length} running session(s)`);
+  }
+
+  return items;
+}
+
 /**
  * Get statistics about session tracking
  * @param {boolean} verbose - Whether to log verbose output

package/src/solve.auto-merge.lib.mjs

@@ -22,7 +22,7 @@ const { wrapDollarWithGhRetry } = await import('./github-rate-limit.lib.mjs');
 const $ = wrapDollarWithGhRetry(__rawDollar$);
 // Import shared library functions
 const lib = await import('./lib.mjs');
-const { log, cleanErrorMessage, formatAligned, getLogFile } = lib;
+const { log, cleanErrorMessage, formatAligned, formatToolExecutionFailure, extractToolErrorCore, getLogFile } = lib;
 
 // Note: We don't use detectAndCountFeedback from solve.feedback.lib.mjs
 // because we have our own non-bot comment detection logic that's more
@@ -805,6 +805,8 @@ No further AI sessions will be started automatically for this run. Please review
                 // Resume failed for a non-limit reason — stop the loop
                 await log('');
                 await log(formatAligned('❌', `${argv.tool.toUpperCase()} RESUME FAILED`, ''));
+                // Issue #1845: surface the core error in the terminal, not just in the GitHub log.
+                await log(formatAligned('', 'Error details:', extractToolErrorCore({ toolResult: resumeResult }) || 'Unknown error', 2));
                 await log(formatAligned('', 'Action:', 'Stopping auto-restart — tool execution failed after limit reset', 2));
                 // Issue #1439: Attach failure log before stopping, so user can see what happened
                 const shouldAttachLogsOnResumeFail = argv.attachLogs || argv['attach-logs'];
@@ -822,7 +824,7 @@ No further AI sessions will be started automatically for this run. Please review
                         log,
                         sanitizeLogContent,
                         verbose: argv.verbose,
-                        errorMessage: `${argv.tool.toUpperCase()} execution failed after limit reset`,
+                        errorMessage: `${formatToolExecutionFailure({ tool: argv.tool, toolResult: resumeResult })} after limit reset`,
                         sessionId: latestSessionId,
                         tempDir,
                         requestedModel: argv.originalModel || argv.model,
@@ -855,6 +857,8 @@ No further AI sessions will be started automatically for this run. Please review
           // Per reviewer feedback: non-limit failures should fail and stop attempts
           await log('');
           await log(formatAligned('❌', `${argv.tool.toUpperCase()} EXECUTION FAILED`, ''));
+          // Issue #1845: surface the core error in the terminal, not just in the GitHub log.
+          await log(formatAligned('', 'Error details:', extractToolErrorCore({ toolResult }) || 'Unknown error', 2));
           await log(formatAligned('', 'Action:', 'Stopping auto-restart — tool execution failed', 2));
           // Issue #1439: Attach failure log before stopping, so user can see what happened
           const shouldAttachLogsOnFail = argv.attachLogs || argv['attach-logs'];
@@ -872,7 +876,7 @@ No further AI sessions will be started automatically for this run. Please review
                   log,
                   sanitizeLogContent,
                   verbose: argv.verbose,
-                  errorMessage: `${argv.tool.toUpperCase()} execution failed`,
+                  errorMessage: formatToolExecutionFailure({ tool: argv.tool, toolResult }),
                   sessionId: latestSessionId,
                   tempDir,
                   requestedModel: argv.originalModel || argv.model,

package/src/solve.error-handlers.lib.mjs

@@ -18,9 +18,30 @@ export const isErrorIssueAutoCreationDisabled = argv => !!(argv?.disableReportIs
  * Handles log attachment and PR closing on failure
  */
 export const handleFailure = async options => {
-  const { error, errorType, shouldAttachLogs, argv, global, owner, repo, log, getLogFile, attachLogToGitHub, cleanErrorMessage, sanitizeLogContent, $ } = options;
+  const { error, errorType, shouldAttachLogs, argv, global, owner, repo, log, getLogFile, attachLogToGitHub, cleanErrorMessage, sanitizeLogContent, cleanupContext, $ } = options;
   const disableIssueCreation = isErrorIssueAutoCreationDisabled(argv);
 
+  // Issue #1845 / #1834: "On all failures we automatically commit uncommitted changes by default."
+  // Exceptions, unhandled rejections and main-execution errors exit here WITHOUT passing through the
+  // tool-failure auto-commit chokepoint in solve.mjs, so preserve (commit + push) any work the agent
+  // left on disk first. Gated by config (default on; HIVE_MIND_AUTO_COMMIT_ON_CRITICAL_ERROR=false).
+  // Best-effort: never let a commit failure mask the original error.
+  try {
+    const { criticalErrorRecovery } = await import('./config.lib.mjs');
+    if (criticalErrorRecovery.autoCommitUncommittedChanges && cleanupContext?.tempDir) {
+      const { commitUncommittedChangesOnCriticalError } = await import('./critical-error-commit.lib.mjs');
+      await commitUncommittedChangesOnCriticalError({
+        tempDir: cleanupContext.tempDir,
+        branchName: cleanupContext.branchName,
+        $,
+        log,
+        reason: `${errorType || 'execution'} error`,
+      });
+    }
+  } catch (preserveError) {
+    await log(`  ⚠️  Could not auto-commit changes before failure exit: ${preserveError.message}`, { verbose: true });
+  }
+
   // Offer to create GitHub issue for the error
   try {
     await handleErrorWithIssueCreation({
@@ -117,7 +138,7 @@ export const handleFailure = async options => {
  * Creates an uncaught exception handler
  */
 export const createUncaughtExceptionHandler = options => {
-  const { log, cleanErrorMessage, absoluteLogPath, shouldAttachLogs, argv, global, owner, repo, getLogFile, attachLogToGitHub, sanitizeLogContent, $ } = options;
+  const { log, cleanErrorMessage, absoluteLogPath, shouldAttachLogs, argv, global, owner, repo, getLogFile, attachLogToGitHub, sanitizeLogContent, cleanupContext, $ } = options;
 
   return async error => {
     await log(`\n❌ Uncaught Exception: ${cleanErrorMessage(error)}`, { level: 'error' });
@@ -136,6 +157,7 @@ export const createUncaughtExceptionHandler = options => {
       attachLogToGitHub,
       cleanErrorMessage,
       sanitizeLogContent,
+      cleanupContext,
       $,
     });
 
@@ -147,7 +169,7 @@ export const createUncaughtExceptionHandler = options => {
  * Creates an unhandled rejection handler
  */
 export const createUnhandledRejectionHandler = options => {
-  const { log, cleanErrorMessage, absoluteLogPath, shouldAttachLogs, argv, global, owner, repo, getLogFile, attachLogToGitHub, sanitizeLogContent, $ } = options;
+  const { log, cleanErrorMessage, absoluteLogPath, shouldAttachLogs, argv, global, owner, repo, getLogFile, attachLogToGitHub, sanitizeLogContent, cleanupContext, $ } = options;
 
   return async reason => {
     await log(`\n❌ Unhandled Rejection: ${cleanErrorMessage(reason)}`, { level: 'error' });
@@ -166,6 +188,7 @@ export const createUnhandledRejectionHandler = options => {
       attachLogToGitHub,
       cleanErrorMessage,
       sanitizeLogContent,
+      cleanupContext,
       $,
     });
 
@@ -219,7 +242,7 @@ export const handleNoPrAvailableError = async ({ isContinueMode, tempDir, issueN
  * Handles execution errors in the main catch block
  */
 export const handleMainExecutionError = async options => {
-  const { error, log, cleanErrorMessage, absoluteLogPath, shouldAttachLogs, argv, global, owner, repo, getLogFile, attachLogToGitHub, sanitizeLogContent, $ } = options;
+  const { error, log, cleanErrorMessage, absoluteLogPath, shouldAttachLogs, argv, global, owner, repo, getLogFile, attachLogToGitHub, sanitizeLogContent, cleanupContext, $ } = options;
 
   // Special handling for authentication errors
   if (error.isAuthError) {
@@ -256,6 +279,7 @@ export const handleMainExecutionError = async options => {
     attachLogToGitHub,
     cleanErrorMessage,
     sanitizeLogContent,
+    cleanupContext,
     $,
   });
 

package/src/solve.mjs

@@ -21,7 +21,7 @@ const fs = (await use('fs')).promises;
 const crypto = (await use('crypto')).default;
 const memoryCheck = await import('./memory-check.mjs');
 const lib = await import('./lib.mjs');
-const { log, setLogFile, getLogFile, getAbsoluteLogPath, cleanErrorMessage, formatAligned, getVersionInfo, setupVerboseLogInterceptor, setupStdioLogInterceptor } = lib;
+const { log, setLogFile, getLogFile, getAbsoluteLogPath, cleanErrorMessage, formatAligned, formatToolExecutionFailure, getVersionInfo, setupVerboseLogInterceptor, setupStdioLogInterceptor } = lib;
 const githubLib = await import('./github.lib.mjs');
 const { sanitizeLogContent, attachLogToGitHub, getToolDisplayName } = githubLib;
 const validation = await import('./solve.validation.lib.mjs');
@@ -181,9 +181,8 @@ const { isIssueUrl, isPrUrl, normalizedUrl, owner, repo, number: urlNumber } = u
 issueUrl = normalizedUrl || issueUrl;
 global.owner = owner;
 global.repo = repo;
-// Issue #1752: failures before PR creation can happen during checks that run
-// before the normal issue-mode setup below. Record the source issue as soon as
-// the URL is validated so the pre-exit notifier can still comment on it.
+// Issue #1752: record the source issue as soon as the URL is validated so the pre-exit
+// notifier can still comment on it if a check fails before normal issue-mode setup below.
 if (isIssueUrl) {
   global.issueNumber = urlNumber;
 }
@@ -193,8 +192,7 @@ if (argv.autoLanguage) {
   const { applyAutoLanguageToArgv } = await import('./auto-language.lib.mjs');
   await applyAutoLanguageToArgv({ argv, githubLib, owner, repo, number: urlNumber, isIssueUrl, isPrUrl, log });
 }
-// Initialize i18n based on --language / --ui-language / --work-language
-// (or detected system locale). --auto-language may set only the work track.
+// Initialize i18n from --language / --ui-language / --work-language (or system locale).
 const { initI18n } = await import('./i18n.lib.mjs');
 await initI18n({
   language: argv.language,
@@ -209,6 +207,7 @@ const errorHandlerOptions = {
   shouldAttachLogs,
   argv,
   global,
+  cleanupContext, // #1845: mutated in place; lets exception handlers auto-commit uncommitted work
   owner: null, // Will be set later when parsed
   repo: null, // Will be set later when parsed
   getLogFile,
@@ -1072,6 +1071,8 @@ try {
     //   2. Autonomous claude   - one-shot claude --resume w/ --dangerously-skip-permissions -p (claude only)
     //   3. Solve resume        - re-enters solve.mjs with --resume, preserving tool/model/dir
     const toolForFailure = argv.tool || 'claude';
+    // Issue #1845: surface the core error instead of just "<TOOL> execution failed" (terminal + comment).
+    const toolFailureMessage = formatToolExecutionFailure({ tool: toolForFailure, toolResult });
     if (sessionId) {
       await log('');
       await log('💡 To continue this session:');
@@ -1116,7 +1117,7 @@ try {
           // Include sessionId so the PR comment can present it
           sessionId,
           // If not a usage limit case, fall back to generic failure format
-          errorMessage: limitReached ? undefined : `${argv.tool.toUpperCase()} execution failed`,
+          errorMessage: limitReached ? undefined : toolFailureMessage,
           requestedModel: argv.originalModel || argv.model,
           tool: argv.tool || 'claude',
           // Issue #1454: Pass resultModelUsage for accurate multi-model display
@@ -1136,21 +1137,20 @@ try {
       }
     }
 
-    // Issue #1834 (PR #1835 feedback): "on all critical errors we auto commit uncommitted changes
-    // by default." A failed session is a critical error and exits here before the normal
-    // auto-commit chokepoint below, so preserve (commit + push) any work the agent left on disk
-    // first. On by default; disable via HIVE_MIND_AUTO_COMMIT_ON_CRITICAL_ERROR=false. Never throws.
+    // Issue #1834 (PR #1835 feedback): "on all critical errors we auto commit uncommitted changes by
+    // default." A failed session exits here before the normal auto-commit chokepoint below, so commit
+    // + push any work first. On by default; disable via HIVE_MIND_AUTO_COMMIT_ON_CRITICAL_ERROR=false.
     try {
       const { criticalErrorRecovery } = await import('./config.lib.mjs');
       if (criticalErrorRecovery.autoCommitUncommittedChanges) {
         const { commitUncommittedChangesOnCriticalError } = await import('./critical-error-commit.lib.mjs');
-        await commitUncommittedChangesOnCriticalError({ tempDir, branchName, $, log, reason: `${argv.tool || 'claude'} execution failed` });
+        await commitUncommittedChangesOnCriticalError({ tempDir, branchName, $, log, reason: toolFailureMessage });
       }
     } catch (preserveError) {
       await log(`  ⚠️  Could not auto-commit before failure exit: ${preserveError.message}`, { verbose: true });
     }
 
-    await safeExit(1, `${argv.tool.toUpperCase()} execution failed`);
+    await safeExit(1, toolFailureMessage);
   }
 
   // Clean up .playwright-mcp/ to prevent browser artifacts from triggering auto-restart (Issue #1124)
@@ -1463,6 +1463,7 @@ try {
   }
   await handleMainExecutionError({
     error,
+    cleanupContext, // #1845: enable auto-commit of uncommitted work before the failure exit
     log,
     cleanErrorMessage,
     absoluteLogPath,

package/src/solve.restart-shared.lib.mjs

@@ -29,7 +29,7 @@ const fs = (await use('fs')).promises;
 
 // Import shared library functions
 const lib = await import('./lib.mjs');
-const { log, formatAligned } = lib;
+const { log, formatAligned, extractToolErrorCore } = lib;
 
 // Import Sentry integration
 const sentryLib = await import('./sentry.lib.mjs');
@@ -507,11 +507,20 @@ export const buildUncommittedChangesFeedback = (changes, restartCount = 0, maxIt
  * @returns {boolean}
  */
 export const isApiError = toolResult => {
-  if (!toolResult || !toolResult.result) return false;
+  if (!toolResult) return false;
+
+  // Issue #1845: runners report failures via `errorInfo` (e.g. claude sets
+  // `errorInfo.message` but NOT `result`). Use the shared core-error extractor so an
+  // "API Error:" is classified correctly regardless of which field the runner populated —
+  // otherwise the MAX_API_ERROR_RETRIES guard never trips for claude and watch mode can
+  // retry a hard API error indefinitely. `extractToolErrorCore` still falls back to
+  // `result`, preserving the original behavior for runners that set it.
+  const errorText = extractToolErrorCore({ toolResult });
+  if (!errorText) return false;
 
   const errorPatterns = ['API Error:', 'not_found_error', 'authentication_error', 'invalid_request_error'];
 
-  return errorPatterns.some(pattern => toolResult.result.includes(pattern));
+  return errorPatterns.some(pattern => errorText.includes(pattern));
 };
 
 /**

package/src/solve.watch.lib.mjs

@@ -20,7 +20,7 @@ const { wrapDollarWithGhRetry } = await import('./github-rate-limit.lib.mjs');
 const $ = wrapDollarWithGhRetry(__rawDollar$);
 // Import shared library functions
 const lib = await import('./lib.mjs');
-const { log, cleanErrorMessage, formatAligned, getLogFile } = lib;
+const { log, cleanErrorMessage, formatAligned, formatToolExecutionFailure, extractToolErrorCore, getLogFile } = lib;
 
 // Import feedback detection functions
 const feedbackLib = await import('./solve.feedback.lib.mjs');
@@ -373,7 +373,9 @@ export const watchForFeedback = async params => {
             if (consecutiveApiErrors >= MAX_API_ERROR_RETRIES) {
               await log('');
               await log(formatAligned('❌', 'MAXIMUM API ERROR RETRIES REACHED', ''));
-              await log(formatAligned('', 'Error details:', toolResult.result || 'Unknown API error', 2));
+              // Issue #1845: surface the core error (e.g. "API Error: Output blocked by content
+              // filtering policy"); toolResult.result is often unset on failure, so prefer errorInfo.
+              await log(formatAligned('', 'Error details:', extractToolErrorCore({ toolResult }) || 'Unknown API error', 2));
               await log(formatAligned('', 'Consecutive failures:', `${consecutiveApiErrors}`, 2));
               await log(formatAligned('', 'Action:', 'Exiting watch mode to prevent infinite loop', 2));
               await log('');
@@ -421,7 +423,7 @@ export const watchForFeedback = async params => {
                   sessionId: toolResult.sessionId || latestSessionId,
                   tempDir,
                   // Include error information in the log upload
-                  errorMessage: toolResult.errorInfo?.message || toolResult.result || `${argv.tool.toUpperCase()} execution failed`,
+                  errorMessage: formatToolExecutionFailure({ tool: argv.tool, toolResult }),
                   // Include pricing data if available from failed attempt
                   publicPricingEstimate: toolResult.publicPricingEstimate,
                   pricingInfo: toolResult.pricingInfo,

package/src/telegram-solve-queue.helpers.lib.mjs

@@ -64,6 +64,114 @@ export function formatQueueHistorySection({ items, emoji, label, max, locale, wi
   return `${section}\n`;
 }
 
+/**
+ * Normalize an issue/PR URL for de-duplication: drop a trailing slash, drop any
+ * `#fragment`, and lowercase. Two URLs that point at the same issue/PR collapse
+ * to the same key so an item that is both in the queue's in-memory `processing`
+ * Map and in the tracked-session list is listed only once (issue #1837).
+ *
+ * @param {string} url
+ * @returns {string}
+ */
+function normalizeQueueUrl(url) {
+  return typeof url === 'string' ? url.replace(/\/+$/, '').replace(/#.*$/, '').toLowerCase() : '';
+}
+
+/**
+ * Build the list of tasks a tool is actively *executing* for the detailed queue
+ * status, by merging the queue's in-memory `processing` items with the
+ * externally-tracked running sessions (detached screen/isolation work),
+ * de-duplicated by issue/PR URL.
+ *
+ * This is the fix for the follow-up on issue #1837: once a task is dispatched to
+ * a detached session the queue's own `processing` Map is emptied, so the running
+ * task — although still counted via `pgrep`/`$ --status` — was never listed.
+ * Pulling the tracked running sessions in here makes executing tasks show up as
+ * clickable links again.
+ *
+ * @param {object} opts
+ * @param {Iterable} [opts.processingItems] - `this.processing.values()` (each with `tool`, `url`, `status`, `getWaitTime()`).
+ * @param {Array} [opts.sessionItems] - Tracked running sessions (`{url, tool, startTime, status}`).
+ * @param {string} opts.tool - Tool key to filter by.
+ * @param {number} [opts.now] - Current epoch ms (injectable for tests).
+ * @returns {Array<{url: string, queueStatus: (string|null), waitMs: number}>}
+ */
+export function collectExecutingItems({ processingItems = [], sessionItems = [], tool, now = Date.now() }) {
+  const byKey = new Map();
+
+  for (const item of processingItems) {
+    if (item.tool !== tool) continue;
+    const key = normalizeQueueUrl(item.url) || item.id;
+    byKey.set(key, {
+      url: item.url,
+      queueStatus: item.status || null,
+      waitMs: typeof item.getWaitTime === 'function' ? item.getWaitTime() : 0,
+    });
+  }
+
+  for (const session of sessionItems) {
+    if ((session.tool || 'claude') !== tool) continue;
+    if (!session.url) continue; // can't render a clickable link without a URL
+    const key = normalizeQueueUrl(session.url);
+    if (key && byKey.has(key)) continue; // already represented by an in-memory item
+    const startMs = session.startTime ? new Date(session.startTime).getTime() : null;
+    byKey.set(key || session.sessionName, {
+      url: session.url,
+      // Tracked sessions report a backend status (e.g. 'executing'); fall back to
+      // the generic "processing" label rendered by formatQueueProcessingItems.
+      queueStatus: null,
+      waitMs: startMs && !Number.isNaN(startMs) ? Math.max(0, now - startMs) : 0,
+    });
+  }
+
+  return [...byKey.values()];
+}
+
+/**
+ * Render the per-tool "executing" lines (`▶️ link (status, elapsed)`) for the
+ * detailed queue status, capped at `max` items with a localized "... and N more"
+ * line (issue #1837).
+ *
+ * @param {object} opts
+ * @param {Array} opts.items - Output of {@link collectExecutingItems}.
+ * @param {number} opts.max - Maximum items to list before collapsing.
+ * @param {string|null} opts.locale - Locale for labels/durations.
+ * @returns {string} The formatted lines (empty string when no items).
+ */
+export function formatQueueProcessingItems({ items, max, locale }) {
+  if (!items || items.length === 0) return '';
+  let out = '';
+  for (const item of items.slice(0, max)) {
+    const label = item.queueStatus ? lt(`queue_status_${item.queueStatus}`, {}, { locale }) : lt('queue_processing', {}, { locale });
+    out += `  ▶️ ${formatQueueItemLink(item.url)} (${label}, ${formatDuration(item.waitMs, { locale })})\n`;
+  }
+  if (items.length > max) {
+    out += `    ... ${lt('queue_and_more', { count: items.length - max }, { locale })}\n`;
+  }
+  return out;
+}
+
+/**
+ * Lazy wrapper around session-monitor's `getRunningSessionItems` so the queue
+ * can list executing detached sessions without a static import (mirrors how the
+ * queue lazily loads isolation-session counts). Returns an empty list on error
+ * so the detailed status still renders (issue #1837).
+ *
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<Array>}
+ */
+export async function getRunningSessionItems(verbose = false) {
+  try {
+    const { getRunningSessionItems: impl } = await import('./session-monitor.lib.mjs');
+    return await impl(verbose);
+  } catch (error) {
+    if (verbose) {
+      console.error('[VERBOSE] /solve_queue error getting running session items:', error.message);
+    }
+    return [];
+  }
+}
+
 /**
  * Count running processes by name.
  * @param {string} processName - Process name to search for (e.g., 'claude', 'agent', 'codex', 'gemini')

package/src/telegram-solve-queue.lib.mjs

@@ -17,7 +17,7 @@
 
 import { getCachedClaudeLimits, getCachedCodexLimits, getCachedGitHubLimits, getCachedMemoryInfo, getCachedCpuInfo, getCachedDiskInfo, getLimitCache } from './limits.lib.mjs';
 export { formatDuration, getRunningAgentProcesses, getRunningClaudeProcesses, getRunningCodexProcesses, getRunningGeminiProcesses, getRunningProcesses, getRunningQwenProcesses } from './telegram-solve-queue.helpers.lib.mjs';
-import { formatDuration, formatQueueHistorySection, formatQueueItemLink, formatWaitingReason, getRunningAgentProcesses, getRunningClaudeProcesses, getRunningCodexProcesses, getRunningGeminiProcesses, getRunningProcesses, getRunningQwenProcesses } from './telegram-solve-queue.helpers.lib.mjs';
+import { collectExecutingItems, formatDuration, formatQueueHistorySection, formatQueueItemLink, formatQueueProcessingItems, formatWaitingReason, getRunningAgentProcesses, getRunningClaudeProcesses, getRunningCodexProcesses, getRunningGeminiProcesses, getRunningProcesses, getRunningQwenProcesses, getRunningSessionItems } from './telegram-solve-queue.helpers.lib.mjs';
 export { QUEUE_CONFIG, THRESHOLD_STRATEGIES } from './queue-config.lib.mjs';
 import { QUEUE_CONFIG } from './queue-config.lib.mjs';
 import { formatExecutingWorkSessionMessage, formatStartingWorkSessionMessage } from './work-session-formatting.lib.mjs';
@@ -164,6 +164,9 @@ export class SolveQueue {
     this.messageUpdateCallback = options.messageUpdateCallback || null;
     this.getRunningProcessesFn = options.getRunningProcesses || getRunningProcesses;
     this.getRunningIsolatedSessionsFn = options.getRunningIsolatedSessions || getRunningIsolatedSessions;
+    // Source of currently-executing detached sessions (with issue/PR URLs) used
+    // to list executing tasks in the detailed status (issue #1837).
+    this.getRunningSessionItemsFn = options.getRunningSessionItems || getRunningSessionItems;
     this.autoStart = options.autoStart !== false;
 
     // Separate queues per tool type - claude tasks never block other tool tasks
@@ -1336,6 +1339,10 @@ export class SolveQueue {
     const locale = getLocale(options);
     const stats = this.getStats();
     const externalProcessing = await this.getExternalProcessingSnapshot(Object.keys(this.queues));
+    // Currently-executing detached sessions (with issue/PR URLs). These are the
+    // real running tasks; the queue's own `processing` Map is emptied once a task
+    // is dispatched, so without this the executing items are never listed (#1837).
+    const runningSessionItems = await this.getRunningSessionItemsFn(this.verbose);
 
     // Get actual processing counts for each tool queue.
     // This combines pgrep with tracked isolation status so users see detached
@@ -1348,14 +1355,12 @@ export class SolveQueue {
       const processing = externalProcessing.byTool[tool] || 0;
       message += `*${tool}* (${lt('queue_pending', {}, { locale })}: ${pending}, ${lt('queue_processing', {}, { locale })}: ${processing})\n`;
 
-      // Show the items this queue is actively processing for this tool, with a
-      // clickable link to each issue/PR (issue #1837). These come from the
-      // queue's own tracking, so they may differ from the pgrep-based count above.
-      const processingItems = Array.from(this.processing.values()).filter(item => item.tool === tool);
-      for (const item of processingItems.slice(0, QUEUE_CONFIG.MAX_DISPLAY_ITEMS_PER_QUEUE)) {
-        const waitTime = formatDuration(item.getWaitTime(), { locale });
-        message += `  ▶️ ${formatQueueItemLink(item.url)} (${queueStatusLabel(item.status, locale)}, ${waitTime})\n`;
-      }
+      // List the tasks this tool is actively executing as clickable links. We
+      // merge the queue's in-memory processing Map with the externally-tracked
+      // running sessions (detached screen/isolation work), deduped by URL, so
+      // executing tasks are listed even after dispatch (issue #1837).
+      const executing = collectExecutingItems({ processingItems: this.processing.values(), sessionItems: runningSessionItems, tool });
+      message += formatQueueProcessingItems({ items: executing, max: QUEUE_CONFIG.MAX_DISPLAY_ITEMS_PER_QUEUE, locale });
 
       // Show first queued items for this tool with clickable links
       const displayItems = toolQueue.slice(0, QUEUE_CONFIG.MAX_DISPLAY_ITEMS_PER_QUEUE);