@link-assistant/hive-mind 1.73.6 → 1.73.8

package/CHANGELOG.md

@@ -1,5 +1,60 @@
 # @link-assistant/hive-mind
 
+## 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
+
+- 6188172: feat(telegram): list executed issues/PRs as clickable links in /solve_queue, add /queue alias (#1837)
+
+  The `/solve_queue` detailed status previously showed only per-tool counts and a
+  final `Completed: N, Failed: M` line, so a stuck or running task could not be
+  opened from the message. It now lists each processing (`▶️`), pending (`•`),
+  recently completed (`✅`), and failed (`❌`, with the error reason) item as a
+  clickable `[owner/repo#number](url)` link, capped per section
+  (`HIVE_MIND_MAX_DISPLAY_ITEMS_PER_QUEUE`, default 5) with a localized
+  `... and N more` line to stay under Telegram's 4096-character limit.
+
+  Also adds `/queue` as a shorter alias for `/solve_queue` (both the entity-based
+  command regex and the text-based fallback handler), and documents the work in
+  `docs/case-studies/issue-1837`.
+
 ## 1.73.6
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.73.6",
+  "version": "1.73.8",
   "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/locales/en.lino

@@ -515,7 +515,7 @@ en
           detail "Tool aliases imply `--tool <tool>`: `/codex <github-url>` equals `/solve <github-url> --tool codex`"
         reply "Or reply to a message with a GitHub link: `/solve`"
         disabled "*/solve* (aliases: */do*, */continue*, */claude*, */codex*, */opencode*, */agent*, */gemini*, */qwen*) - ❌ Disabled"
-        queue "`/solve_queue` - Show solve queue status"
+        queue "`/solve_queue` (alias: `/queue`) - Show solve queue status"
       locked
         options "🔒 Locked options: `{{options}}`"
       task

package/src/locales/hi.lino

@@ -515,7 +515,7 @@ hi
           detail "Tool aliases `--tool <tool>` लगाते हैं: `/codex <github-url>` का अर्थ `/solve <github-url> --tool codex` है"
         reply "या GitHub लिंक वाले संदेश का उत्तर दें: `/solve`"
         disabled "*/solve* (aliases: */do*, */continue*, */claude*, */codex*, */opencode*, */agent*, */gemini*, */qwen*) - ❌ अक्षम"
-        queue "`/solve_queue` - solve queue status दिखाएँ"
+        queue "`/solve_queue` (उपनाम: `/queue`) - solve queue status दिखाएँ"
       locked
         options "🔒 लॉक किए गए विकल्प: `{{options}}`"
       task

package/src/locales/ru.lino

@@ -515,7 +515,7 @@ ru
           detail "Алиасы инструментов добавляют `--tool <tool>`: `/codex <github-url>` равно `/solve <github-url> --tool codex`"
         reply "Или ответьте на сообщение со ссылкой GitHub: `/solve`"
         disabled "*/solve* (алиасы: */do*, */continue*, */claude*, */codex*, */opencode*, */agent*, */gemini*, */qwen*) - ❌ Отключено"
-        queue "`/solve_queue` - Показать состояние очереди solve"
+        queue "`/solve_queue` (псевдоним: `/queue`) - Показать состояние очереди solve"
       locked
         options "🔒 Заблокированные опции: `{{options}}`"
       task

package/src/locales/zh.lino

@@ -515,7 +515,7 @@ zh
           detail "工具别名会添加 `--tool <tool>`：`/codex <github-url>` 等同于 `/solve <github-url> --tool codex`"
         reply "也可以回复包含 GitHub 链接的消息：`/solve`"
         disabled "*/solve*（别名：*/do*、*/continue*、*/claude*、*/codex*、*/opencode*、*/agent*、*/gemini*、*/qwen*）- ❌ 已禁用"
-        queue "`/solve_queue` - 显示 solve 队列状态"
+        queue "`/solve_queue`（别名：`/queue`）- 显示 solve 队列状态"
       locked
         options "🔒 锁定选项：`{{options}}`"
       task

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/queue-config.lib.mjs

@@ -280,6 +280,13 @@ export const QUEUE_CONFIG = {
 
   // Process detection
   CLAUDE_PROCESS_NAMES: ['claude'], // Process names to detect
+
+  // Display
+  // Maximum number of items shown per section (pending/processing/completed/failed)
+  // in the /solve_queue (/queue) detailed status before collapsing into a
+  // "... and N more" line. Keeps the Telegram message under the 4096-char cap.
+  // See: https://github.com/link-assistant/hive-mind/issues/1837
+  MAX_DISPLAY_ITEMS_PER_QUEUE: parseIntWithDefault('HIVE_MIND_MAX_DISPLAY_ITEMS_PER_QUEUE', 5),
 };
 
 /**

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/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-bot.mjs

@@ -1169,7 +1169,8 @@ bot.on('message', async (ctx, next) => {
   // /subscribe + /unsubscribe (#1688) are intentionally not in the text fallback — Telegraf's bot.command() is sufficient.
   const solveHandlers = Object.fromEntries(SOLVE_COMMAND_NAMES.map(command => [command, handleSolveCommand]));
   const taskHandlers = Object.fromEntries(TASK_COMMAND_NAMES.map(command => [command, handleTaskCommand]));
-  const handlers = { ...solveHandlers, ...taskHandlers, hive: handleHiveCommand, solve_queue: handleSolveQueueCommand, solvequeue: handleSolveQueueCommand };
+  // /queue is the short alias for /solve_queue (issue #1837)
+  const handlers = { ...solveHandlers, ...taskHandlers, hive: handleHiveCommand, solve_queue: handleSolveQueueCommand, solvequeue: handleSolveQueueCommand, queue: handleSolveQueueCommand };
 
   const handler = handlers[extracted.command];
   if (!handler) return next();

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

@@ -97,11 +97,12 @@ export function registerSolveQueueCommand(bot, options) {
     });
   }
 
-  // Match /solve_queue, /solve-queue, or /solvequeue (case-insensitive)
+  // Match /solve_queue, /solve-queue, /solvequeue, or the short /queue alias (case-insensitive)
   // Note: Telegram Bot API only supports underscores in command names, not hyphens.
-  // The entity-based matching handles /solve_queue and /solvequeue.
+  // The entity-based matching handles /solve_queue, /solvequeue, and /queue.
   // /solve-queue is handled by the text-based fallback in telegram-bot.mjs (issue #1232).
-  bot.command(/^solve[_-]?queue$/i, handleSolveQueueCommand);
+  // The /queue alias was added in issue #1837 to make checking the queue faster to type.
+  bot.command(/^(?:solve[_-]?queue|queue)$/i, handleSolveQueueCommand);
 
   return { handleSolveQueueCommand };
 }

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

@@ -6,6 +6,64 @@ import { lt } from './limits-i18n.lib.mjs';
 
 const execAsync = promisify(exec);
 
+/**
+ * Build a clickable, human-readable link to a queued issue/PR for the
+ * /solve_queue (/queue) detailed status (issue #1837).
+ *
+ * For GitHub issue/PR URLs we render a compact `[owner/repo#number](url)`
+ * Markdown link so the list is scannable and clickable. When the label would
+ * contain Markdown-special characters (e.g. `_` or `*` in an owner/repo name)
+ * that could break Telegram's legacy Markdown parser, we fall back to the bare
+ * URL — which Telegram still auto-links and renders as clickable.
+ *
+ * Non-GitHub or unparseable URLs also fall back to the bare URL.
+ *
+ * @param {string} url - The issue/PR URL.
+ * @returns {string} A Markdown link or bare URL safe for `parse_mode: 'Markdown'`.
+ */
+export function formatQueueItemLink(url) {
+  if (!url || typeof url !== 'string') return String(url ?? '');
+  const match = url.match(/github\.com\/([^/\s]+)\/([^/\s]+)\/(?:issues|pull)\/(\d+)/i);
+  if (!match) return url;
+  const [, owner, repo, number] = match;
+  const label = `${owner}/${repo}#${number}`;
+  // Only build a Markdown link when the label has no Markdown-special chars
+  // that would break the legacy parser inside link text. Otherwise the bare
+  // URL is still clickable in Telegram.
+  if (/^[A-Za-z0-9/#.-]+$/.test(label)) {
+    return `[${label}](${url})`;
+  }
+  return url;
+}
+
+/**
+ * Render a history section (Completed / Failed) for the detailed queue status
+ * as a clickable list, most-recent-first, capped at `max` items with a
+ * "... and N more" line (issue #1837).
+ *
+ * @param {object} opts
+ * @param {Array} opts.items - History items (each with `url`, optional `error`).
+ * @param {string} opts.emoji - Leading emoji for each row (e.g. '✅' or '❌').
+ * @param {string} opts.label - Localized section heading.
+ * @param {number} opts.max - Maximum items to list before collapsing.
+ * @param {string|null} opts.locale - Locale for the "and N more" label.
+ * @param {boolean} [opts.withError] - Append `— error` when the item failed.
+ * @returns {string} The formatted section (empty string when no items).
+ */
+export function formatQueueHistorySection({ items, emoji, label, max, locale, withError = false }) {
+  if (!items || items.length === 0) return '';
+  let section = `*${label}* (${items.length}):\n`;
+  for (const item of [...items].reverse().slice(0, max)) {
+    section += `  ${emoji} ${formatQueueItemLink(item.url)}`;
+    if (withError && item.error) section += ` — ${item.error}`;
+    section += '\n';
+  }
+  if (items.length > max) {
+    section += `    ... ${lt('queue_and_more', { count: items.length - max }, { locale })}\n`;
+  }
+  return `${section}\n`;
+}
+
 /**
  * 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, formatWaitingReason, 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';
 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';
@@ -1320,28 +1320,17 @@ export class SolveQueue {
   }
 
   /**
-   * Format detailed queue status for Telegram message
-   * Groups output by tool queue, shows first 5 items per queue, and uses human-readable time.
+   * Format detailed queue status for Telegram message.
+   * Groups output by tool queue (clickable links per item), then lists the
+   * Completed and Failed history as clickable links, capped per section.
    *
    * Processing count = max(actual AI CLI processes via pgrep, tracked
    * `$ --status` executing screen-isolated sessions), not queue state.
    *
-   * Output format:
-   * ```
-   * 📋 Solve Queue Status
-   *
-   * claude (pending: 6, processing: 0)
-   * • url1 (waiting, 5h 43m 23s)
-   *   └ RAM usage is 70% (threshold: 65%)
-   * • url2 (queued, 2m 15s)
-   *
-   * agent (pending: 2, processing: 0)
-   * • url3 (waiting, 1h 2m 5s)
-   * ```
-   *
    * @returns {Promise<string>}
    * @see https://github.com/link-assistant/hive-mind/issues/1159
    * @see https://github.com/link-assistant/hive-mind/issues/1267
+   * @see https://github.com/link-assistant/hive-mind/issues/1837
    */
   async formatDetailedStatus(options = {}) {
     const locale = getLocale(options);
@@ -1359,22 +1348,37 @@ export class SolveQueue {
       const processing = externalProcessing.byTool[tool] || 0;
       message += `*${tool}* (${lt('queue_pending', {}, { locale })}: ${pending}, ${lt('queue_processing', {}, { locale })}: ${processing})\n`;
 
-      // Show first 5 queued items for this tool
-      const displayItems = toolQueue.slice(0, 5);
+      // 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`;
+      }
+
+      // Show first queued items for this tool with clickable links
+      const displayItems = toolQueue.slice(0, QUEUE_CONFIG.MAX_DISPLAY_ITEMS_PER_QUEUE);
       for (const item of displayItems) {
         const waitTime = formatDuration(item.getWaitTime(), { locale });
-        message += `  • ${item.url} (${queueStatusLabel(item.status, locale)}, ${waitTime})\n`;
+        message += `  • ${formatQueueItemLink(item.url)} (${queueStatusLabel(item.status, locale)}, ${waitTime})\n`;
         if (item.waitingReason) {
           message += `    └ ${item.waitingReason}\n`;
         }
       }
-      if (toolQueue.length > 5) {
-        message += `    ... ${lt('queue_and_more', { count: toolQueue.length - 5 }, { locale })}\n`;
+      if (toolQueue.length > QUEUE_CONFIG.MAX_DISPLAY_ITEMS_PER_QUEUE) {
+        message += `    ... ${lt('queue_and_more', { count: toolQueue.length - QUEUE_CONFIG.MAX_DISPLAY_ITEMS_PER_QUEUE }, { locale })}\n`;
       }
 
       message += '\n';
     }
 
+    // Completed / Failed lists - clickable links to the executed issues/PRs,
+    // most-recent-first so the newest results are easy to find (issue #1837).
+    const max = QUEUE_CONFIG.MAX_DISPLAY_ITEMS_PER_QUEUE;
+    message += formatQueueHistorySection({ items: this.completed, emoji: '✅', label: lt('queue_completed', {}, { locale }), max, locale });
+    message += formatQueueHistorySection({ items: this.failed, emoji: '❌', label: lt('queue_failed', {}, { locale }), max, locale, withError: true });
+
     // Summary stats
     message += `${lt('queue_completed', {}, { locale })}: ${stats.completed}, ${lt('queue_failed', {}, { locale })}: ${stats.failed}\n`;