@link-assistant/hive-mind 1.73.5 → 1.73.7

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # @link-assistant/hive-mind
 
+## 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
+
+- defa8c4: fix(claude): repair corrupted thinking-block transcripts so resume preserves context (#1834)
+
+  Follow-up to the Issue #1834 recovery ("can we do even better?"). The previous
+  recovery (PR #1835) was reactive: a plain resume of a transcript poisoned by a
+  corrupted extended-thinking block (`{ "type": "thinking", "thinking": "" }` with a
+  kept signature) just repeats the `400 ... thinking blocks ... cannot be modified`
+  error, so recovery almost always fell through to a **fresh restart that discards
+  dozens of turns** of accumulated context (50 turns / $3.84 in the second
+  reproduction log).
+
+  Recovery Phase 1 now **proactively repairs the on-disk session transcript** before
+  resuming: `repairCorruptedThinkingBlocks` (new
+  `src/claude.session-transcript-repair.lib.mjs`) strips the empty-text
+  `thinking`/`redacted_thinking` blocks from the session JSONL — a workaround proven
+  upstream (the Anthropic API permits _omitting_ earlier thinking, just not
+  _modifying_ it). When repair succeeds the resume keeps all accumulated context;
+  when it can't help, recovery still falls back to a fresh restart, so there is no
+  regression.
+
+  The repair is conservative: it never throws, only removes empty-text blocks (valid
+  signed thinking is untouched), never empties an assistant message, and writes a
+  one-time `<session>.jsonl.pre-repair-backup` before rewriting. The case study under
+  `docs/case-studies/issue-1834` is updated with a second reproduction log and the
+  new repair-then-resume design.
+
 ## 1.73.5
 
 ### Patch Changes

package/package.json

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

package/src/claude.session-transcript-repair.lib.mjs

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+
+// Issue #1834 (PR #1836): repair a Claude Code session transcript that was poisoned by a
+// corrupted extended-thinking block, so the session can be RESUMED (context preserved) instead
+// of being discarded entirely.
+//
+// Root cause (upstream anthropics/claude-code#63147, #46843, #24662, #41992): when extended
+// thinking is combined with tool use, Claude Code can persist a thinking block to the on-disk
+// session JSONL with its `thinking` text emptied to "" while keeping the original `signature`:
+//
+//   { "type": "thinking", "thinking": "", "signature": "Eyc…" }
+//
+// On resume/continue the API replays that block and validates the signature against the now-empty
+// text, rejecting every following turn with a 400:
+//   `thinking` or `redacted_thinking` blocks in the latest assistant message cannot be modified.
+//
+// The proven community workaround (anthropics/claude-code#46843, miteshashar/claude-code-thinking-
+// blocks-fix) is to STRIP the corrupted (empty-text) thinking blocks from the transcript — the API
+// permits omitting earlier-turn thinking, so once the offending blocks are gone the session resumes
+// cleanly with all of its text/tool-use history intact. This is strictly better than throwing the
+// whole session away: when the repair succeeds we keep the accumulated context (worth many dollars
+// and dozens of turns); when it can't help we still fall back to a fresh restart.
+
+import { promises as fs } from 'fs';
+import os from 'os';
+import path from 'path';
+
+/**
+ * Resolve the on-disk session transcript path for a Claude Code session. Claude Code stores each
+ * session as `~/.claude/projects/<cwd-with-slashes-as-dashes>/<sessionId>.jsonl` (mirrors the
+ * path logic already used by getModelUsageFromSession in claude.lib.mjs).
+ *
+ * @param {string} tempDir - the working directory the Claude session ran in.
+ * @param {string} sessionId - the Claude Code session id.
+ * @param {string} [homeDir] - override home dir (tests).
+ * @returns {string} absolute path to the session JSONL file.
+ */
+export const resolveSessionTranscriptPath = (tempDir, sessionId, homeDir = os.homedir()) => {
+  const projectDirName = String(tempDir).replace(/\//g, '-');
+  return path.join(homeDir, '.claude', 'projects', projectDirName, `${sessionId}.jsonl`);
+};
+
+/**
+ * True when a content block is a corrupted thinking block: an extended-thinking block whose text
+ * was emptied (the upstream corruption) — `{ type: 'thinking', thinking: '' }` (optionally with a
+ * stale `signature`) or the redacted variant `{ type: 'redacted_thinking', data: '' }`.
+ */
+const isCorruptedThinkingBlock = block => {
+  if (!block || typeof block !== 'object') return false;
+  if (block.type === 'thinking') return !block.thinking; // '' / undefined / null
+  if (block.type === 'redacted_thinking') return !block.data;
+  return false;
+};
+
+/**
+ * Strip corrupted (empty-text) thinking blocks from a Claude Code session transcript so the session
+ * can be resumed. Conservative and side-effect-safe:
+ *   - never throws (returns a result object describing what happened);
+ *   - only removes blocks whose thinking text is empty (legitimate signed thinking is untouched);
+ *   - never empties an assistant message (if removing the blocks would leave a message with no
+ *     content, that message is left exactly as-is);
+ *   - writes a one-time backup (`<file>.pre-repair-backup`) before modifying the transcript.
+ *
+ * @param {object} opts
+ * @param {string} opts.tempDir - working directory the session ran in.
+ * @param {string} opts.sessionId - Claude Code session id.
+ * @param {string} [opts.homeDir] - override home dir (tests).
+ * @param {Function} [opts.log] - async logger.
+ * @returns {Promise<{ repaired: boolean, removedBlocks: number, scannedLines: number, sessionFile: string|null, reason?: string }>}
+ */
+export const repairCorruptedThinkingBlocks = async ({ tempDir, sessionId, homeDir, log = async () => {} } = {}) => {
+  const result = { repaired: false, removedBlocks: 0, scannedLines: 0, sessionFile: null };
+  if (!tempDir || !sessionId) {
+    return { ...result, reason: 'missing tempDir or sessionId' };
+  }
+  const sessionFile = resolveSessionTranscriptPath(tempDir, sessionId, homeDir);
+  result.sessionFile = sessionFile;
+  let fileContent;
+  try {
+    fileContent = await fs.readFile(sessionFile, 'utf8');
+  } catch {
+    // No transcript on disk (e.g. fresh run never persisted, or path mismatch) — nothing to repair.
+    return { ...result, reason: 'session transcript not found' };
+  }
+
+  try {
+    const lines = fileContent.split('\n');
+    const out = [];
+    let removedBlocks = 0;
+    let scannedLines = 0;
+    for (const line of lines) {
+      if (!line.trim()) {
+        out.push(line);
+        continue;
+      }
+      scannedLines++;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        out.push(line); // preserve anything we can't parse verbatim
+        continue;
+      }
+      const content = entry?.message?.content;
+      if (Array.isArray(content)) {
+        const corrupted = content.filter(isCorruptedThinkingBlock).length;
+        if (corrupted > 0) {
+          const cleaned = content.filter(b => !isCorruptedThinkingBlock(b));
+          // Never leave an assistant message with an empty content array (invalid for the API).
+          if (cleaned.length > 0) {
+            entry.message.content = cleaned;
+            removedBlocks += corrupted;
+            out.push(JSON.stringify(entry));
+            continue;
+          }
+        }
+      }
+      out.push(line);
+    }
+
+    result.scannedLines = scannedLines;
+    if (removedBlocks === 0) {
+      return { ...result, reason: 'no corrupted thinking blocks found' };
+    }
+
+    // Back up the original transcript exactly once before rewriting it.
+    const backupFile = `${sessionFile}.pre-repair-backup`;
+    try {
+      await fs.access(backupFile);
+    } catch {
+      try {
+        await fs.copyFile(sessionFile, backupFile);
+      } catch {
+        // Best effort — a missing backup must not block the repair.
+      }
+    }
+
+    await fs.writeFile(sessionFile, out.join('\n'), 'utf8');
+    result.repaired = true;
+    result.removedBlocks = removedBlocks;
+    await log(`🩹 Repaired session transcript: stripped ${removedBlocks} corrupted thinking block(s) from ${scannedLines} message line(s) (Issue #1834). Backup: ${backupFile}`, { verbose: true });
+    return result;
+  } catch (error) {
+    // Defensive: any unexpected failure degrades gracefully to "no repair" so the caller can fall
+    // back to a fresh restart.
+    return { ...result, reason: `repair failed: ${error?.message || error}` };
+  }
+};
+
+export default { repairCorruptedThinkingBlocks, resolveSessionTranscriptPath };

package/src/claude.thinking-block-recovery.lib.mjs

@@ -12,9 +12,12 @@
 //
 // PR #1835 feedback: "in case of this specific error we should try resume first, and if not possible
 // try to restart." Recovery is therefore a two-phase escalation:
-//   Phase 1 — resume the existing session (context-preserving; occasionally the transcript is intact
-//             enough to continue).
-//   Phase 2 — resume unavailable or already failed → discard the session and start fresh (`/clear`).
+//   Phase 1 — REPAIR the on-disk transcript (strip the corrupted empty-text thinking blocks) and
+//             resume the existing session (context-preserving). Plain resume of a poisoned
+//             transcript is futile — the 400 just repeats — so we first remove the offending blocks,
+//             which the API permits omitting. When repair succeeds the resume keeps all accumulated
+//             text/tool-use history (Issue #1834 "can we do even better?").
+//   Phase 2 — repair/resume unavailable or already failed → discard the session and start fresh.
 // On every attempt we first auto-commit any uncommitted work (Issue #1834 / PR #1835 feedback:
 // "on all critical errors we auto commit uncommitted changes by default") so nothing is lost when
 // the session context resets.
@@ -22,6 +25,7 @@
 import { retryLimits, criticalErrorRecovery } from './config.lib.mjs';
 import { waitWithCountdown } from './tool-retry.lib.mjs';
 import { commitUncommittedChangesOnCriticalError } from './critical-error-commit.lib.mjs';
+import { repairCorruptedThinkingBlocks } from './claude.session-transcript-repair.lib.mjs';
 
 /**
  * Create a stateful corrupted-thinking-block recovery handler. The returned function persists its
@@ -36,11 +40,13 @@ import { commitUncommittedChangesOnCriticalError } from './critical-error-commit
  * @param {Function} ctx.$ - command-stream executor.
  * @param {Function} ctx.log - async logger.
  * @param {number} [ctx.waitMs=5000] - settle delay before re-running (overridable for tests).
+ * @param {Function} [ctx.repair=repairCorruptedThinkingBlocks] - transcript repair (injectable for tests).
+ * @param {string} [ctx.homeDir] - override home dir for transcript lookup (tests).
  * @returns {(opts: {classified: object, source: string, sessionId: string|null}) => Promise<boolean>}
  *          Resolves true when a recovery attempt was initiated (caller should re-run); false when
  *          both caps are exhausted (caller should fail).
  */
-export const createThinkingBlockRecovery = ({ argv, tempDir, branchName, $, log, waitMs = 5000 }) => {
+export const createThinkingBlockRecovery = ({ argv, tempDir, branchName, $, log, waitMs = 5000, repair = repairCorruptedThinkingBlocks, homeDir }) => {
   let resumeCount = 0;
   let restartCount = 0;
   return async ({ classified, source, sessionId }) => {
@@ -49,11 +55,22 @@ export const createThinkingBlockRecovery = ({ argv, tempDir, branchName, $, log,
         await commitUncommittedChangesOnCriticalError({ tempDir, branchName, $, log, reason: `${classified.label} (${source})` });
       }
     };
-    // Phase 1 — resume the existing session first (cheaper, keeps accumulated context).
+    // Phase 1 — repair the on-disk transcript, then resume (keeps accumulated context).
     if (sessionId && resumeCount < retryLimits.maxThinkingBlockResumes) {
       resumeCount++;
       await preserveWork();
-      await log(`\n⚠️ ${classified.label} (${source}). Resume attempt ${resumeCount}/${retryLimits.maxThinkingBlockResumes} — trying to resume the existing session first before discarding it (Issue #1834)...`, { level: 'warning' });
+      await log(`\n⚠️ ${classified.label} (${source}). Resume attempt ${resumeCount}/${retryLimits.maxThinkingBlockResumes} — repairing the corrupted transcript then resuming the existing session before discarding it (Issue #1834)...`, { level: 'warning' });
+      // Strip the corrupted (empty-text) thinking blocks so resume isn't doomed to repeat the 400.
+      try {
+        const repairResult = await repair({ tempDir, sessionId, homeDir, log });
+        if (repairResult?.repaired) {
+          await log(`   🩹 Stripped ${repairResult.removedBlocks} corrupted thinking block(s) from the transcript — resume will preserve context (Issue #1834).`, { verbose: true });
+        } else {
+          await log(`   ℹ️ Transcript repair made no change (${repairResult?.reason || 'unknown'}) — resuming as-is (Issue #1834).`, { verbose: true });
+        }
+      } catch {
+        // Repair must never block recovery — fall through to a plain resume attempt.
+      }
       argv.resume = sessionId;
       await waitWithCountdown(waitMs, log);
       await log('\n🔄 Resuming the session now...');

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/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/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`;