@link-assistant/hive-mind 1.73.8 → 1.73.9

package/CHANGELOG.md

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

package/package.json

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

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