@link-assistant/hive-mind 1.56.7 → 1.56.9

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @link-assistant/hive-mind
 
+## 1.56.9
+
+### Patch Changes
+
+- 94448c3: Fix screen-isolated work-session Telegram updates so executing messages stay compact and completion messages use `$ --status` start/end timestamps and exit codes.
+
+## 1.56.8
+
+### Patch Changes
+
+- 05a3e42: Fix CI/CD change detection for pull request synchronize events so metadata-only updates skip expensive test jobs while still reporting completed checks.
+- c12f99d: Fix screen-isolated solve monitoring so completed `$ --status` sessions no longer block duplicate commands, queued status displays executing isolation sessions, and Telegram start messages stay in an executing state until completion.
+
 ## 1.56.7
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.56.7",
+  "version": "1.56.9",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",
@@ -15,7 +15,7 @@
     "hive-telegram-bot": "./src/telegram-bot.mjs"
   },
   "scripts": {
-    "test": "node tests/solve-queue.test.mjs && node tests/limits-display.test.mjs && node tests/test-usage-limit.mjs && node tests/test-codex-support.mjs && node tests/test-build-cost-info-string.mjs && node tests/test-claude-code-install-method.mjs && node tests/test-claude-quiet-config.mjs && node tests/test-configure-claude-bin.mjs && node tests/test-docker-release-order.mjs && node tests/test-docker-box-migration.mjs && node tests/test-hive-screens.mjs && node tests/test-issue-1616-pr-issue-link-preservation.mjs && node tests/test-pre-pr-failure-notifier-1640.mjs && node tests/test-ready-to-merge-pagination-1645.mjs && node tests/test-require-gh-paginate-rule.mjs && node tests/test-auto-restart-limits-1664.mjs && node tests/test-telegram-message-filters.mjs && node tests/test-telegram-bot-command-aliases.mjs && node tests/test-telegram-options-before-url.mjs && node tests/test-telegram-bot-configuration-isolation-links-notation.mjs && node tests/test-extract-isolation-from-args.mjs && node tests/test-solve-queue-command.mjs && node tests/test-queue-display-1267.mjs && node tests/test-telegram-bot-launcher.mjs",
+    "test": "node tests/solve-queue.test.mjs && node tests/limits-display.test.mjs && node tests/test-usage-limit.mjs && node tests/test-codex-support.mjs && node tests/test-build-cost-info-string.mjs && node tests/test-claude-code-install-method.mjs && node tests/test-claude-quiet-config.mjs && node tests/test-configure-claude-bin.mjs && node tests/test-docker-release-order.mjs && node tests/test-docker-box-migration.mjs && node tests/test-hive-screens.mjs && node tests/test-issue-1616-pr-issue-link-preservation.mjs && node tests/test-pre-pr-failure-notifier-1640.mjs && node tests/test-ready-to-merge-pagination-1645.mjs && node tests/test-require-gh-paginate-rule.mjs && node tests/test-auto-restart-limits-1664.mjs && node tests/test-telegram-message-filters.mjs && node tests/test-telegram-bot-command-aliases.mjs && node tests/test-telegram-options-before-url.mjs && node tests/test-telegram-bot-configuration-isolation-links-notation.mjs && node tests/test-extract-isolation-from-args.mjs && node tests/test-solve-queue-command.mjs && node tests/test-queue-display-1267.mjs && node tests/test-issue-1670-screen-status-monitoring.mjs && node tests/test-telegram-bot-launcher.mjs",
     "test:queue": "node tests/solve-queue.test.mjs",
     "test:limits-display": "node tests/limits-display.test.mjs",
     "test:usage-limit": "node tests/test-usage-limit.mjs",

package/src/isolation-runner.lib.mjs

@@ -22,6 +22,8 @@ const { $ } = await use('command-stream');
 
 // Valid isolation backends
 const VALID_ISOLATION_BACKENDS = ['screen', 'tmux', 'docker'];
+const RUNNING_SESSION_STATUSES = new Set(['executing', 'running']);
+const TERMINAL_SESSION_STATUSES = new Set(['executed', 'completed', 'failed', 'cancelled', 'canceled', 'error']);
 
 /**
  * Generate a UUID v4 for unique session identification
@@ -31,6 +33,76 @@ export function generateSessionId() {
   return crypto.randomUUID();
 }
 
+/**
+ * Parse output from `$ --status <session>`.
+ *
+ * start-command versions used in the wild may return JSON when
+ * `--output-format json` is supported, or human-readable key/value text.
+ * Keep the parser tolerant so completion monitoring survives either format.
+ *
+ * @param {string} output - Raw stdout from `$ --status`
+ * @returns {{exists: boolean, uuid: string|null, status: string|null, exitCode: number|null, startTime: string|null, endTime: string|null, currentTime: string|null, raw: string}}
+ */
+export function parseSessionStatusOutput(output) {
+  const raw = (output || '').trim();
+  if (!raw) {
+    return { exists: false, uuid: null, status: null, exitCode: null, startTime: null, endTime: null, currentTime: null, raw: '' };
+  }
+
+  try {
+    const parsed = JSON.parse(raw);
+    const data = Array.isArray(parsed) ? parsed[0] : parsed;
+    return {
+      exists: true,
+      uuid: data?.uuid || null,
+      status: typeof data?.status === 'string' ? data.status.toLowerCase() : null,
+      exitCode: data?.exitCode !== undefined && data?.exitCode !== null ? Number(data.exitCode) : null,
+      startTime: data?.startTime || null,
+      endTime: data?.endTime || null,
+      currentTime: data?.currentTime || null,
+      raw,
+    };
+  } catch {
+    // Fall through to text parsing.
+  }
+
+  const firstLine =
+    raw
+      .split('\n')
+      .find(line => line.trim() && !line.includes(' '))
+      ?.trim() || null;
+  const readField = name => {
+    const match = raw.match(new RegExp(`^\\s*${name}\\s+"?([^"\\n]+)"?\\s*$`, 'mi'));
+    return match ? match[1].trim() : null;
+  };
+
+  const status = readField('status')?.toLowerCase() || null;
+  const exitCodeText = readField('exitCode');
+
+  return {
+    exists: Boolean(status || firstLine),
+    uuid: readField('uuid') || firstLine,
+    status,
+    exitCode: exitCodeText !== null ? Number(exitCodeText) : null,
+    startTime: readField('startTime'),
+    endTime: readField('endTime'),
+    currentTime: readField('currentTime'),
+    raw,
+  };
+}
+
+export function isExecutingSessionStatus(status) {
+  return RUNNING_SESSION_STATUSES.has(String(status || '').toLowerCase());
+}
+
+export function isTerminalSessionStatus(status) {
+  return TERMINAL_SESSION_STATUSES.has(String(status || '').toLowerCase());
+}
+
+export function shouldFallbackToScreenStatus(statusResult) {
+  return !statusResult?.exists || !statusResult?.status;
+}
+
 /**
  * Find the `$` CLI binary path
  * @returns {Promise<string|null>} Path to `$` binary or null
@@ -133,7 +205,7 @@ export async function executeWithIsolation(command, args, options = {}) {
  *
  * @param {string} sessionId - UUID of the session to check
  * @param {boolean} [verbose] - Enable verbose logging
- * @returns {Promise<{exists: boolean, status: string|null, exitCode: number|null, raw: string}>}
+ * @returns {Promise<{exists: boolean, uuid: string|null, status: string|null, exitCode: number|null, startTime: string|null, endTime: string|null, currentTime: string|null, raw: string}>}
  */
 export async function querySessionStatus(sessionId, verbose = false) {
   const binPath = await findStartCommandBinary();
@@ -141,7 +213,7 @@ export async function querySessionStatus(sessionId, verbose = false) {
     if (verbose) {
       console.log('[VERBOSE] isolation-runner: Cannot query status - $ binary not found');
     }
-    return { exists: false, status: null, exitCode: null, raw: '' };
+    return { exists: false, uuid: null, status: null, exitCode: null, startTime: null, endTime: null, currentTime: null, raw: '' };
   }
 
   try {
@@ -153,30 +225,12 @@ export async function querySessionStatus(sessionId, verbose = false) {
       console.log(`[VERBOSE] isolation-runner: Status query result: ${stdout.substring(0, 300)}`);
     }
 
-    try {
-      const data = JSON.parse(stdout);
-      return {
-        exists: true,
-        status: data.status || null,
-        exitCode: data.exitCode !== undefined ? data.exitCode : null,
-        raw: stdout,
-      };
-    } catch {
-      // If JSON parsing fails, try text-based detection
-      const isExecuting = stdout.includes('executing');
-      const isExecuted = stdout.includes('executed');
-      return {
-        exists: isExecuting || isExecuted,
-        status: isExecuting ? 'executing' : isExecuted ? 'executed' : null,
-        exitCode: null,
-        raw: stdout,
-      };
-    }
+    return parseSessionStatusOutput(stdout);
   } catch (error) {
     if (verbose) {
       console.log(`[VERBOSE] isolation-runner: Status query error: ${error.message}`);
     }
-    return { exists: false, status: null, exitCode: null, raw: '' };
+    return { exists: false, uuid: null, status: null, exitCode: null, startTime: null, endTime: null, currentTime: null, raw: '' };
   }
 }
 
@@ -222,16 +276,21 @@ export async function isSessionRunning(sessionId, options = {}) {
   const { backend, verbose = false } = opts;
 
   const result = await querySessionStatus(sessionId, verbose);
-  if (result.exists && result.status === 'executing') {
-    return true;
+  if (result.exists && result.status) {
+    if (isExecutingSessionStatus(result.status)) {
+      return true;
+    }
+    if (isTerminalSessionStatus(result.status)) {
+      return false;
+    }
   }
 
   // Fallback: for screen backend, check screen -ls directly.
-  // This works around start-command bugs where:
+  // Only use this when $ --status has no usable record. This works around
+  // older start-command bugs where:
   // 1. $ --status can't find session by --session name (only by internal UUID)
-  // 2. $ --status reports "executed" immediately for --detached screen sessions
   // See: https://github.com/link-assistant/hive-mind/issues/1545
-  if (backend === 'screen') {
+  if (backend === 'screen' && shouldFallbackToScreenStatus(result)) {
     const screenRunning = await checkScreenSessionRunning(sessionId, verbose);
     if (screenRunning && verbose) {
       console.log(`[VERBOSE] isolation-runner: $ --status says not running, but screen -ls confirms session '${sessionId}' is still active`);

package/src/session-monitor.lib.mjs

@@ -17,6 +17,9 @@
 
 import { promisify } from 'util';
 import { exec as execCallback } from 'child_process';
+import { formatSessionCompletionMessage, getSessionCompletionExitCode } from './work-session-formatting.lib.mjs';
+
+export { formatSessionCompletionMessage, getSessionCompletionExitCode } from './work-session-formatting.lib.mjs';
 
 const exec = promisify(execCallback);
 
@@ -28,12 +31,6 @@ async function getIsolationRunner() {
   }
   return _isolationRunner;
 }
-// Legacy accessor for querySessionStatus
-async function getQuerySessionStatus() {
-  const mod = await getIsolationRunner();
-  return mod.querySessionStatus;
-}
-
 // In-memory session store
 const activeSessions = new Map();
 
@@ -65,51 +62,6 @@ export async function checkScreenSessionExists(sessionName) {
   }
 }
 
-/**
- * Check if an isolated session is still running.
- * Uses isolation-runner's isSessionRunning which includes screen -ls fallback
- * for screen-backend sessions to work around start-command UUID mismatch.
- *
- * @param {string} sessionId - UUID of the isolated session (screen session name)
- * @param {Object} [options] - Options
- * @param {string} [options.backend] - Isolation backend ('screen', 'tmux', 'docker')
- * @param {boolean} [options.verbose] - Whether to log verbose output
- * @returns {Promise<boolean>} True if session is still running
- * @see https://github.com/link-assistant/hive-mind/issues/1545
- */
-async function checkIsolatedSessionRunning(sessionId, options = {}) {
-  const opts = typeof options === 'boolean' ? { verbose: options } : options;
-  const { backend, verbose = false } = opts;
-  try {
-    const runner = await getIsolationRunner();
-    return await runner.isSessionRunning(sessionId, { backend, verbose });
-  } catch (error) {
-    if (verbose) {
-      console.error(`[VERBOSE] Error checking isolated session ${sessionId}: ${error.message}`);
-    }
-    return false;
-  }
-}
-
-/**
- * Get the exit code of a completed isolated session
- * @param {string} sessionId - UUID of the isolated session
- * @param {boolean} verbose - Whether to log verbose output
- * @returns {Promise<number|null>} Exit code or null if unknown
- */
-async function getIsolatedSessionExitCode(sessionId, verbose = false) {
-  try {
-    const queryStatus = await getQuerySessionStatus();
-    const result = await queryStatus(sessionId, verbose);
-    if (result.exists && result.status === 'executed') {
-      return result.exitCode;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-
 /**
  * Track a new session for completion monitoring
  *
@@ -172,6 +124,67 @@ function completeSession(sessionName, exitCode = 0, verbose = false) {
   }
 }
 
+function normalizeSessionUrl(url) {
+  return url.replace(/\/+$/, '').replace(/#.*$/, '').toLowerCase();
+}
+
+function isNonIsolationSessionActive(sessionName, sessionInfo, verbose = false) {
+  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 (timeout: ${NON_ISOLATION_SESSION_TIMEOUT_MS / 1000}s), removing from tracking`);
+    }
+    activeSessions.delete(sessionName);
+    return false;
+  }
+  if (verbose) {
+    const remainingSec = Math.round((NON_ISOLATION_SESSION_TIMEOUT_MS - elapsed) / 1000);
+    console.log(`[VERBOSE] Non-isolation session ${sessionName} still within timeout (${remainingSec}s remaining)`);
+  }
+  return true;
+}
+
+async function getIsolationSessionState(sessionName, sessionInfo, options = {}) {
+  const { verbose = false, statusProvider = null } = options;
+  const sessionId = sessionInfo.sessionId || sessionName;
+
+  try {
+    const runner = await getIsolationRunner();
+    const statusResult = statusProvider ? await statusProvider(sessionId, sessionInfo) : await runner.querySessionStatus(sessionId, verbose);
+
+    if (statusResult?.exists && statusResult.status) {
+      if (runner.isExecutingSessionStatus(statusResult.status)) {
+        return { running: true, exitCode: null, status: statusResult.status, statusResult };
+      }
+      if (runner.isTerminalSessionStatus(statusResult.status)) {
+        return {
+          running: false,
+          exitCode: statusResult.exitCode !== undefined ? statusResult.exitCode : null,
+          status: statusResult.status,
+          statusResult,
+        };
+      }
+    }
+
+    const running = await runner.isSessionRunning(sessionId, {
+      backend: sessionInfo.isolationBackend,
+      verbose,
+    });
+    return {
+      running,
+      exitCode: running ? null : (statusResult?.exitCode ?? null),
+      status: statusResult?.status || null,
+      statusResult,
+    };
+  } catch (error) {
+    if (verbose) {
+      console.error(`[VERBOSE] Error refreshing isolated session ${sessionId}: ${error.message}`);
+    }
+    return { running: false, exitCode: null, status: null, statusResult: null };
+  }
+}
+
 /**
  * Monitor active sessions and send notifications when they complete
  * @param {Object} bot - Telegraf bot instance for sending messages
@@ -191,17 +204,16 @@ export async function monitorSessions(bot, verbose = false) {
   for (const { sessionName, sessionInfo } of sessions) {
     let stillRunning;
     let exitCode = null;
+    let statusResult = null;
 
     if (sessionInfo.isolationBackend && sessionInfo.sessionId) {
-      // Isolation mode: use $ --status with screen -ls fallback for screen backend
-      // See: https://github.com/link-assistant/hive-mind/issues/1545
-      stillRunning = await checkIsolatedSessionRunning(sessionInfo.sessionId, {
-        backend: sessionInfo.isolationBackend,
-        verbose,
-      });
-      if (!stillRunning) {
-        exitCode = await getIsolatedSessionExitCode(sessionInfo.sessionId, verbose);
-      }
+      // Isolation mode: use $ --status, with screen -ls only as a fallback
+      // when the status record is unavailable. Terminal $ statuses are
+      // authoritative so completed screen sessions do not stay blocked.
+      const state = await getIsolationSessionState(sessionName, sessionInfo, { verbose });
+      stillRunning = state.running;
+      exitCode = state.exitCode;
+      statusResult = state.statusResult;
     } else {
       // Issue #1586: Non-isolation screen sessions cannot reliably detect
       // completion because start-screen keeps the screen alive via `exec bash`.
@@ -226,21 +238,14 @@ export async function monitorSessions(bot, verbose = false) {
       console.log(`Session ${sessionName} has finished. Sending notification to chat ${sessionInfo.chatId}`);
 
       try {
-        const endTime = new Date();
-        const startTime = sessionInfo.startTime instanceof Date ? sessionInfo.startTime : new Date(sessionInfo.startTime);
-        const duration = Math.round((endTime - startTime) / 1000);
-        const minutes = Math.floor(duration / 60);
-        const seconds = duration % 60;
-
-        const statusEmoji = exitCode === null || exitCode === 0 ? '✅' : '❌';
-        const statusText = exitCode === null || exitCode === 0 ? 'Completed' : `Failed (exit code: ${exitCode})`;
-        const isolationInfo = sessionInfo.isolationBackend ? `\n🔒 Isolation: ${sessionInfo.isolationBackend}` : '';
-
-        let message = `${statusEmoji} *Work Session ${statusText}*\n\n`;
-        message += `📊 Session: \`${sessionName}\`\n`;
-        message += `⏱️ Duration: ${minutes}m ${seconds}s\n`;
-        message += `🔗 URL: ${sessionInfo.url}${isolationInfo}\n\n`;
-        message += `The work session has finished. You can now review the results.`;
+        const finalExitCode = getSessionCompletionExitCode({ exitCode, statusResult });
+        const message = formatSessionCompletionMessage({
+          sessionName,
+          sessionInfo,
+          statusResult,
+          observedEndTime: new Date(),
+          exitCode: finalExitCode,
+        });
 
         // Update the original reply message if messageId is available, otherwise send new message
         if (sessionInfo.messageId) {
@@ -249,7 +254,7 @@ export async function monitorSessions(bot, verbose = false) {
           await bot.telegram.sendMessage(sessionInfo.chatId, message, { parse_mode: 'Markdown' });
         }
 
-        completeSession(sessionName, exitCode || 0, verbose);
+        completeSession(sessionName, finalExitCode || 0, verbose);
       } catch (error) {
         console.error(`Failed to send completion notification for ${sessionName}:`, error);
         completeSession(sessionName, 1, verbose);
@@ -294,27 +299,14 @@ export function hasActiveSessionForUrl(url, verbose = false) {
   if (!url) return { isActive: false, sessionName: null };
 
   // Normalize the URL for comparison (remove trailing slashes, fragments, etc.)
-  const normalizeUrl = u => u.replace(/\/+$/, '').replace(/#.*$/, '').toLowerCase();
-  const normalizedUrl = normalizeUrl(url);
+  const normalizedUrl = normalizeSessionUrl(url);
 
   for (const [sessionName, sessionInfo] of activeSessions.entries()) {
     // Issue #1586: Auto-expire non-isolation sessions after timeout
-    if (!sessionInfo.isolationBackend) {
-      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 (timeout: ${NON_ISOLATION_SESSION_TIMEOUT_MS / 1000}s), removing from tracking`);
-        }
-        activeSessions.delete(sessionName);
-        continue;
-      }
-      if (verbose) {
-        const remainingSec = Math.round((NON_ISOLATION_SESSION_TIMEOUT_MS - elapsed) / 1000);
-        console.log(`[VERBOSE] Non-isolation session ${sessionName} still within timeout (${remainingSec}s remaining)`);
-      }
+    if (!sessionInfo.isolationBackend && !isNonIsolationSessionActive(sessionName, sessionInfo, verbose)) {
+      continue;
     }
-    if (sessionInfo.url && normalizeUrl(sessionInfo.url) === normalizedUrl) {
+    if (sessionInfo.url && normalizeSessionUrl(sessionInfo.url) === normalizedUrl) {
       if (verbose) {
         const mode = sessionInfo.isolationBackend ? `isolation:${sessionInfo.isolationBackend}` : 'non-isolation (timeout-based)';
         console.log(`[VERBOSE] Found active session for URL ${url}: ${sessionName} (${mode})`);
@@ -329,6 +321,96 @@ export function hasActiveSessionForUrl(url, verbose = false) {
   return { isActive: false, sessionName: null };
 }
 
+/**
+ * Async active-session check for command handlers.
+ *
+ * Isolation-backed sessions are refreshed through `$ --status` before they
+ * block a duplicate URL, so completed screen-isolated runs no longer require
+ * waiting for the background polling interval.
+ *
+ * @param {string} url - The GitHub URL to check
+ * @param {boolean} verbose - Whether to log verbose output
+ * @param {Object} [options] - Test/support options
+ * @param {Function} [options.statusProvider] - Optional `$ --status` provider
+ * @returns {Promise<{isActive: boolean, sessionName: string|null, status?: string|null}>}
+ */
+export async function hasActiveSessionForUrlAsync(url, verbose = false, options = {}) {
+  if (!url) return { isActive: false, sessionName: null };
+
+  const normalizedUrl = normalizeSessionUrl(url);
+
+  for (const [sessionName, sessionInfo] of activeSessions.entries()) {
+    if (!sessionInfo.url || normalizeSessionUrl(sessionInfo.url) !== normalizedUrl) {
+      continue;
+    }
+
+    if (!sessionInfo.isolationBackend) {
+      if (isNonIsolationSessionActive(sessionName, sessionInfo, verbose)) {
+        return { isActive: true, sessionName, status: null };
+      }
+      continue;
+    }
+
+    const state = await getIsolationSessionState(sessionName, sessionInfo, {
+      verbose,
+      statusProvider: options.statusProvider,
+    });
+    if (state.running) {
+      if (verbose) {
+        console.log(`[VERBOSE] Found executing isolated session for URL ${url}: ${sessionName} (status: ${state.status || 'unknown'})`);
+      }
+      return { isActive: true, sessionName, status: state.status || null };
+    }
+
+    if (verbose) {
+      console.log(`[VERBOSE] Isolated session ${sessionName} for URL ${url} is no longer running (status: ${state.status || 'unknown'}), allowing retry while monitor sends completion`);
+    }
+    sessionInfo.lastKnownStatus = state.status || null;
+    sessionInfo.lastKnownExitCode = state.exitCode ?? null;
+  }
+
+  if (verbose) {
+    console.log(`[VERBOSE] No active session found for URL ${url}`);
+  }
+  return { isActive: false, sessionName: null };
+}
+
+/**
+ * Refresh tracked isolation sessions and count only those that are executing.
+ *
+ * @param {boolean} verbose - Whether to log verbose output
+ * @param {Object} [options] - Test/support options
+ * @param {Function} [options.statusProvider] - Optional `$ --status` provider
+ * @returns {Promise<{count: number, sessions: string[], byTool: Object}>}
+ */
+export async function getRunningTrackedIsolationSessions(verbose = false, options = {}) {
+  const sessions = [];
+  const byTool = {};
+
+  for (const [sessionName, sessionInfo] of activeSessions.entries()) {
+    if (!sessionInfo.isolationBackend) {
+      continue;
+    }
+
+    const state = await getIsolationSessionState(sessionName, sessionInfo, {
+      verbose,
+      statusProvider: options.statusProvider,
+    });
+
+    if (!state.running) {
+      sessionInfo.lastKnownStatus = state.status || null;
+      sessionInfo.lastKnownExitCode = state.exitCode ?? null;
+      continue;
+    }
+
+    const tool = sessionInfo.tool || 'claude';
+    sessions.push(sessionName);
+    byTool[tool] = (byTool[tool] || 0) + 1;
+  }
+
+  return { count: sessions.length, sessions, byTool };
+}
+
 /**
  * Get statistics about session tracking
  * @param {boolean} verbose - Whether to log verbose output

package/src/telegram-bot.mjs

@@ -49,7 +49,8 @@ const { applySolveToolAlias, getFirstParsedPositionalArg, getSolveCommandNameFro
 const { isChatStopped, getChatStopInfo, getStoppedChatRejectMessage, DEFAULT_STOP_REASON } = await import('./telegram-start-stop-command.lib.mjs');
 const { isOldMessage: _isOldMessage, isGroupChat: _isGroupChat, isChatAuthorized: _isChatAuthorized, isForwardedOrReply: _isForwardedOrReply, extractCommandFromText, extractGitHubUrl: _extractGitHubUrl } = await import('./telegram-message-filters.lib.mjs');
 const { launchBotWithRetry } = await import('./telegram-bot-launcher.lib.mjs');
-const { trackSession, startSessionMonitoring, hasActiveSessionForUrl } = await import('./session-monitor.lib.mjs');
+const { trackSession, startSessionMonitoring, hasActiveSessionForUrlAsync } = await import('./session-monitor.lib.mjs');
+const { formatExecutingWorkSessionMessage } = await import('./work-session-formatting.lib.mjs');
 
 const config = yargs(hideBin(process.argv))
   .usage('Usage: hive-telegram-bot [options]')
@@ -549,7 +550,7 @@ async function safeReply(ctx, text, options = {}) {
   }
 }
 
-async function executeAndUpdateMessage(ctx, startingMessage, commandName, args, infoBlock, perCommandIsolation = null) {
+async function executeAndUpdateMessage(ctx, startingMessage, commandName, args, infoBlock, perCommandIsolation = null, tool = 'claude') {
   const { chat, message_id: msgId } = startingMessage;
   const safeEdit = async text => {
     try {
@@ -559,28 +560,33 @@ async function executeAndUpdateMessage(ctx, startingMessage, commandName, args,
     }
   };
   const iso = await resolveIsolation(perCommandIsolation, ISOLATION_BACKEND, isolationRunner, VERBOSE);
-  let result,
-    session,
-    extraInfo = '';
+  let result, session;
   if (iso) {
     session = iso.runner.generateSessionId();
     VERBOSE && console.log(`[VERBOSE] Using isolation (${iso.backend}), session: ${session}`);
     result = await iso.runner.executeWithIsolation(commandName, args, { backend: iso.backend, sessionId: session, verbose: VERBOSE });
-    extraInfo = `\n🔒 Isolation: \`${iso.backend}\``;
-    if (result.success) trackSession(session, { chatId: ctx.chat.id, messageId: msgId, startTime: new Date(), url: args[0], command: commandName, isolationBackend: iso.backend, sessionId: session }, VERBOSE);
+    if (result.success) trackSession(session, { chatId: ctx.chat.id, messageId: msgId, startTime: new Date(), url: args[0], command: commandName, isolationBackend: iso.backend, sessionId: session, tool }, VERBOSE);
   } else {
     result = await executeStartScreen(commandName, args);
     const match = result.success && (result.output.match(/session:\s*(\S+)/i) || result.output.match(/screen -R\s+(\S+)/));
     session = match ? match[1] : 'unknown';
     // Issue #1586: Track non-isolation sessions with timeout-based expiry.
     // These sessions cannot reliably detect completion (screen stays alive via
-    // `exec bash`), so hasActiveSessionForUrl() auto-expires them after 10 min.
+    // `exec bash`), so active URL checks auto-expire them after 10 min.
     // This prevents accidental duplicate commands within the timeout window.
-    if (result.success && session !== 'unknown') trackSession(session, { chatId: ctx.chat.id, messageId: msgId, startTime: new Date(), url: args[0], command: commandName }, VERBOSE);
+    if (result.success && session !== 'unknown') trackSession(session, { chatId: ctx.chat.id, messageId: msgId, startTime: new Date(), url: args[0], command: commandName, tool }, VERBOSE);
   }
   if (result.warning) return safeEdit(`⚠️  ${result.warning}`);
-  if (result.success) await safeEdit(`✅ ${commandName.charAt(0).toUpperCase() + commandName.slice(1)} command started successfully!\n\n📊 Session: \`${session}\`${extraInfo}\n\n${infoBlock}\n\n🔔 You will receive a notification when the session finishes.`);
-  else await safeEdit(`❌ Error executing ${commandName} command:\n\n\`\`\`\n${result.error || result.output}\n\`\`\``);
+  if (result.success) {
+    await safeEdit(
+      formatExecutingWorkSessionMessage({
+        commandName,
+        sessionName: session,
+        isolationBackend: iso?.backend || null,
+        infoBlock,
+      })
+    );
+  } else await safeEdit(`❌ Error executing ${commandName} command:\n\n\`\`\`\n${result.error || result.output}\n\`\`\``);
 }
 
 bot.command('help', async ctx => {
@@ -990,7 +996,7 @@ async function handleSolveCommand(ctx) {
     return;
   }
   // Issue #1567: Prevent concurrent sessions on the same PR/issue
-  const activeSession = hasActiveSessionForUrl(normalizedUrl, VERBOSE);
+  const activeSession = await hasActiveSessionForUrlAsync(normalizedUrl, VERBOSE);
   if (activeSession.isActive) {
     await safeReply(ctx, `❌ A working session is already running for this URL.\n\nURL: ${escapeMarkdown(normalizedUrl)}\nSession: \`${activeSession.sessionName}\`\n\n💡 Wait for the current session to complete, or use /solve\\_stop to cancel it.`, { reply_to_message_id: ctx.message.message_id });
     return;
@@ -1006,7 +1012,7 @@ async function handleSolveCommand(ctx) {
   const toolQueuedCount = queueStats.queuedByTool[solveTool] || 0; // tool-specific queue count (#1551)
   if (check.canStart && toolQueuedCount === 0) {
     const startingMessage = await safeReply(ctx, `🚀 Starting solve command...\n\n${infoBlock}`, { reply_to_message_id: ctx.message.message_id });
-    await executeAndUpdateMessage(ctx, startingMessage, 'solve', args, infoBlock, effectiveSolveIsolation);
+    await executeAndUpdateMessage(ctx, startingMessage, 'solve', args, infoBlock, effectiveSolveIsolation, solveTool);
   } else {
     const queueItem = solveQueue.enqueue({ url: normalizedUrl, args, ctx, requester, infoBlock, tool: solveTool, perCommandIsolation: effectiveSolveIsolation });
     let queueMessage = `📋 Solve command queued (${solveTool} queue position #${toolQueuedCount + 1})\n\n${infoBlock}`; // tool-specific position (#1551)
@@ -1171,7 +1177,7 @@ async function handleHiveCommand(ctx) {
   }
 
   const startingMessage = await safeReply(ctx, `🚀 Starting hive command...\n\n${infoBlock}`, { reply_to_message_id: ctx.message.message_id });
-  await executeAndUpdateMessage(ctx, startingMessage, 'hive', args, infoBlock, effectiveHiveIsolation);
+  await executeAndUpdateMessage(ctx, startingMessage, 'hive', args, infoBlock, effectiveHiveIsolation, hiveTool);
 }
 
 bot.command(/^hive$/i, handleHiveCommand);

package/src/telegram-isolation.lib.mjs

@@ -80,8 +80,8 @@ export function createIsolationAwareQueueCallback(botIsolationBackend, botIsolat
     if (iso) {
       const sid = iso.runner.generateSessionId();
       const r = await iso.runner.executeWithIsolation(item.command || 'solve', item.args, { backend: iso.backend, sessionId: sid, verbose });
-      if (r.success) trackSession(sid, { chatId: item.ctx?.chat?.id, messageId: item.messageInfo?.messageId, startTime: new Date(), url: item.url, command: item.command || 'solve', isolationBackend: iso.backend, sessionId: sid }, verbose);
-      return { ...r, output: r.output || `session: ${sid}` };
+      if (r.success) trackSession(sid, { chatId: item.ctx?.chat?.id, messageId: item.messageInfo?.messageId, startTime: new Date(), url: item.url, command: item.command || 'solve', isolationBackend: iso.backend, sessionId: sid, tool: item.tool || 'claude' }, verbose);
+      return { ...r, sessionId: sid, isolationBackend: iso.backend, output: r.output || `session: ${sid}` };
     }
     return fallbackCallback(item);
   };

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

@@ -17,9 +17,10 @@
 
 import { getCachedClaudeLimits, getCachedCodexLimits, getCachedGitHubLimits, getCachedMemoryInfo, getCachedCpuInfo, getCachedDiskInfo, getLimitCache } from './limits.lib.mjs';
 export { formatDuration, getRunningAgentProcesses, getRunningClaudeProcesses, getRunningCodexProcesses, getRunningProcesses } from './telegram-solve-queue.helpers.lib.mjs';
-import { formatDuration, formatWaitingReason, getRunningAgentProcesses, getRunningClaudeProcesses, getRunningCodexProcesses, getRunningProcesses } from './telegram-solve-queue.helpers.lib.mjs';
+import { formatDuration, formatWaitingReason, getRunningAgentProcesses, getRunningClaudeProcesses, getRunningProcesses } 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 } from './work-session-formatting.lib.mjs';
 
 export const QueueItemStatus = {
   QUEUED: 'queued',
@@ -133,6 +134,8 @@ export class SolveQueue {
     this.verbose = options.verbose || false;
     this.executeCallback = options.executeCallback || null;
     this.messageUpdateCallback = options.messageUpdateCallback || null;
+    this.getRunningProcessesFn = options.getRunningProcesses || getRunningProcesses;
+    this.getRunningIsolatedSessionsFn = options.getRunningIsolatedSessions || getRunningIsolatedSessions;
 
     // Separate queues per tool type - claude tasks never block agent tasks
     // See: https://github.com/link-assistant/hive-mind/issues/1159
@@ -462,6 +465,46 @@ export class SolveQueue {
     };
   }
 
+  /**
+   * Get external processing counts from both process scanning and tracked
+   * isolated sessions. The displayed/accounted value is the maximum of the two
+   * sources so screen-isolated sessions remain visible even when the AI CLI
+   * process is not directly observable, while regular non-isolated runs still
+   * use pgrep as before.
+   *
+   * @param {string[]} tools - Tool queues to count
+   * @returns {Promise<{byTool: Object, processByTool: Object, isolatedByTool: Object, total: number, isolatedTotal: number, processTotal: number}>}
+   */
+  async getExternalProcessingSnapshot(tools = Object.keys(this.queues)) {
+    const uniqueTools = [...new Set(tools)];
+    const isolated = await this.getRunningIsolatedSessionsFn(this.verbose);
+    const isolatedByTool = isolated.byTool || {};
+    const processByTool = {};
+    const byTool = {};
+
+    await Promise.all(
+      uniqueTools.map(async tool => {
+        const result = await this.getRunningProcessesFn(tool, this.verbose);
+        const processCount = result?.count || 0;
+        const isolatedCount = isolatedByTool[tool] || 0;
+        processByTool[tool] = processCount;
+        byTool[tool] = Math.max(processCount, isolatedCount);
+      })
+    );
+
+    const processTotal = Object.values(processByTool).reduce((sum, count) => sum + count, 0);
+    const isolatedTotal = isolated.count || Object.values(isolatedByTool).reduce((sum, count) => sum + count, 0);
+
+    return {
+      byTool,
+      processByTool,
+      isolatedByTool,
+      total: Math.max(processTotal, isolatedTotal),
+      isolatedTotal,
+      processTotal,
+    };
+  }
+
   /**
    * Check if a new command can start
    *
@@ -505,16 +548,19 @@ export class SolveQueue {
       }
     }
 
-    // Check running claude processes (this is a metric, not a blocking reason by itself)
-    const claudeProcs = await getRunningClaudeProcesses(this.verbose);
-    const codexProcs = await getRunningCodexProcesses(this.verbose);
-    const agentProcs = await getRunningAgentProcesses(this.verbose);
-    const hasRunningClaude = claudeProcs.count > 0;
-    const hasRunningCodex = codexProcs.count > 0;
+    // Check running tool processes (this is a metric, not a blocking reason by itself).
+    // For screen-isolated sessions, use the maximum of `$ --status` executing
+    // counts and pgrep counts so detached sessions remain visible.
+    const externalProcessing = await this.getExternalProcessingSnapshot([...Object.keys(this.queues), tool]);
+    const claudeProcessCount = externalProcessing.byTool.claude || 0;
+    const codexProcessCount = externalProcessing.byTool.codex || 0;
+    const agentProcessCount = externalProcessing.byTool.agent || 0;
+    const hasRunningClaude = claudeProcessCount > 0;
+    const hasRunningCodex = codexProcessCount > 0;
 
     // Calculate total processing count for system resources (all tools)
     // System resources (RAM, CPU, disk) apply to all tools
-    const totalProcessing = this.processing.size + claudeProcs.count + codexProcs.count + agentProcs.count;
+    const totalProcessing = this.processing.size + externalProcessing.total;
 
     // Calculate Claude-specific processing count for Claude API limits
     // Only counts Claude items in queue + external claude processes
@@ -572,10 +618,10 @@ export class SolveQueue {
       // Add claude_running info at the END (not beginning) of reasons
       // Since it's supplementary info, not the primary blocking reason
       // See: https://github.com/link-assistant/hive-mind/issues/1078
-      reasons.push(formatWaitingReason('claude_running', claudeProcs.count, 0) + ` (${claudeProcs.count} processes)`);
+      reasons.push(formatWaitingReason('claude_running', claudeProcessCount, 0) + ` (${claudeProcessCount} processes)`);
     }
     if (tool === 'codex' && hasRunningCodex && reasons.length > 0) {
-      reasons.push(formatWaitingReason('codex_running', codexProcs.count, 0) + ` (${codexProcs.count} processes)`);
+      reasons.push(formatWaitingReason('codex_running', codexProcessCount, 0) + ` (${codexProcessCount} processes)`);
     }
 
     const canStart = reasons.length === 0 && !rejected;
@@ -595,8 +641,10 @@ export class SolveQueue {
       reason: reasons.length > 0 ? reasons.join('\n') : undefined,
       reasons,
       oneAtATime,
-      claudeProcesses: claudeProcs.count,
-      codexProcesses: codexProcs.count,
+      claudeProcesses: claudeProcessCount,
+      codexProcesses: codexProcessCount,
+      agentProcesses: agentProcessCount,
+      isolatedProcesses: externalProcessing.isolatedTotal,
       totalProcessing,
       claudeProcessingCount,
       codexProcessingCount,
@@ -1075,7 +1123,7 @@ export class SolveQueue {
         const result = await this.executeCallback(item);
 
         // Extract session name from result
-        let sessionName = 'unknown';
+        let sessionName = result?.sessionId || 'unknown';
         if (result && result.output) {
           const sessionMatch = result.output.match(/session:\s*(\S+)/i) || result.output.match(/screen -R\s+(\S+)/);
           if (sessionMatch) sessionName = sessionMatch[1];
@@ -1098,7 +1146,12 @@ export class SolveQueue {
               if (result.warning) {
                 await item.ctx.telegram.editMessageText(chatId, messageId, undefined, `⚠️ ${result.warning}`, { parse_mode: 'Markdown' });
               } else if (result.success) {
-                const response = `✅ Solve command started successfully!\n\n📊 Session: \`${sessionName}\`\n\n${item.infoBlock}`;
+                const response = formatExecutingWorkSessionMessage({
+                  commandName: item.command || 'solve',
+                  sessionName,
+                  isolationBackend: result.isolationBackend,
+                  infoBlock: item.infoBlock,
+                });
                 await item.ctx.telegram.editMessageText(chatId, messageId, undefined, response, { parse_mode: 'Markdown' });
               } else {
                 const response = `❌ Error executing solve command:\n\n\`\`\`\n${result.error || result.output}\n\`\`\``;
@@ -1177,9 +1230,8 @@ export class SolveQueue {
    * Format queue status for display in /limits command
    * Shows per-tool queue breakdown with processing counts.
    *
-   * Processing count = actual running system processes (via pgrep), not items in queue processing state.
-   * This is because items transition quickly through the processing state, but the actual
-   * work happens in the spawned system process (claude, agent, etc.).
+   * Processing count = max(actual AI CLI processes via pgrep, tracked
+   * `$ --status` executing screen-isolated sessions), not queue state.
    *
    * Output format:
    * ```
@@ -1194,10 +1246,11 @@ export class SolveQueue {
    */
   async formatStatus() {
     // Always show per-tool breakdown for all known queues
+    const externalProcessing = await this.getExternalProcessingSnapshot(Object.keys(this.queues));
     let message = 'Queues\n';
     for (const [tool, toolQueue] of Object.entries(this.queues)) {
       const pending = toolQueue.length;
-      const processing = (await getRunningProcesses(tool, this.verbose)).count;
+      const processing = externalProcessing.byTool[tool] || 0;
       message += `${tool} (pending: ${pending}, processing: ${processing})\n`;
     }
 
@@ -1208,9 +1261,8 @@ 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.
    *
-   * Processing count = actual running system processes (via pgrep), not items in queue processing state.
-   * This is because items transition quickly through the processing state, but the actual
-   * work happens in the spawned system process (claude, agent, etc.).
+   * Processing count = max(actual AI CLI processes via pgrep, tracked
+   * `$ --status` executing screen-isolated sessions), not queue state.
    *
    * Output format:
    * ```
@@ -1231,16 +1283,17 @@ export class SolveQueue {
    */
   async formatDetailedStatus() {
     const stats = this.getStats();
+    const externalProcessing = await this.getExternalProcessingSnapshot(Object.keys(this.queues));
 
-    // Get actual process counts for each tool queue
-    // The "processing" count is the number of running system processes, not queue internal state
-    // This ensures users see accurate counts of what's actually running
+    // Get actual processing counts for each tool queue.
+    // This combines pgrep with tracked isolation status so users see detached
+    // screen-isolated work even when the direct AI CLI process count is lower.
     let message = '📋 *Solve Queue Status*\n\n';
 
     // Show per-tool queue breakdown with items grouped by queue
     for (const [tool, toolQueue] of Object.entries(this.queues)) {
       const pending = toolQueue.length;
-      const processing = (await getRunningProcesses(tool, this.verbose)).count;
+      const processing = externalProcessing.byTool[tool] || 0;
       message += `*${tool}* (pending: ${pending}, processing: ${processing})\n`;
 
       // Show first 5 queued items for this tool
@@ -1308,7 +1361,7 @@ export function createQueueExecuteCallback(executeStartScreen, trackSessionFn) {
       const match = result.output && (result.output.match(/session:\s*(\S+)/i) || result.output.match(/screen -R\s+(\S+)/));
       const session = match ? match[1] : null;
       if (session) {
-        trackSessionFn(session, { chatId: item.ctx?.chat?.id, messageId: item.messageInfo?.messageId, startTime: new Date(), url: item.url, command: 'solve' });
+        trackSessionFn(session, { chatId: item.ctx?.chat?.id, messageId: item.messageInfo?.messageId, startTime: new Date(), url: item.url, command: 'solve', tool: item.tool || 'claude' });
       }
     }
     return result;
@@ -1316,23 +1369,21 @@ export function createQueueExecuteCallback(executeStartScreen, trackSessionFn) {
 }
 
 /**
- * Get count of running isolated sessions tracked via ExecutionStore
- * When isolation mode is enabled, this replaces pgrep-based process detection
- * for more reliable task counting.
+ * Get count of tracked isolated sessions that are still executing according
+ * to `$ --status`. Queue display combines this with pgrep counts using max().
  *
  * @param {boolean} verbose - Whether to log verbose output
- * @returns {Promise<{count: number, sessions: string[]}>}
+ * @returns {Promise<{count: number, sessions: string[], byTool: Object}>}
  */
 export async function getRunningIsolatedSessions(verbose = false) {
   try {
-    const { getActiveSessionCount } = await import('./session-monitor.lib.mjs');
-    const count = getActiveSessionCount(verbose);
-    return { count, sessions: [] };
+    const { getRunningTrackedIsolationSessions } = await import('./session-monitor.lib.mjs');
+    return await getRunningTrackedIsolationSessions(verbose);
   } catch (error) {
     if (verbose) {
       console.error(`[VERBOSE] /solve_queue error getting isolated sessions:`, error.message);
     }
-    return { count: 0, sessions: [] };
+    return { count: 0, sessions: [], byTool: {} };
   }
 }
 

package/src/work-session-formatting.lib.mjs

@@ -0,0 +1,72 @@
+const FAILURE_STATUSES = new Set(['failed', 'cancelled', 'canceled', 'error']);
+
+function capitalizeCommandName(commandName) {
+  const normalized = commandName || 'solve';
+  return normalized.charAt(0).toUpperCase() + normalized.slice(1);
+}
+
+function parseDateValue(value) {
+  if (!value) return null;
+  const date = value instanceof Date ? value : new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+
+function normalizeExitCode(value) {
+  if (value === null || value === undefined) return null;
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : null;
+}
+
+export function getSessionCompletionExitCode({ exitCode = null, statusResult = null } = {}) {
+  const explicitExitCode = normalizeExitCode(exitCode);
+  if (explicitExitCode !== null) return explicitExitCode;
+
+  const statusExitCode = normalizeExitCode(statusResult?.exitCode);
+  if (statusExitCode !== null) return statusExitCode;
+
+  const status = String(statusResult?.status || '').toLowerCase();
+  if (FAILURE_STATUSES.has(status)) return 1;
+
+  return null;
+}
+
+export function formatSessionDurationSeconds(seconds) {
+  const totalSeconds = Math.max(0, Math.round(Number(seconds) || 0));
+  const days = Math.floor(totalSeconds / 86400);
+  const hours = Math.floor((totalSeconds % 86400) / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const remainingSeconds = totalSeconds % 60;
+  const parts = [];
+
+  if (days > 0) parts.push(`${days}d`);
+  if (hours > 0) parts.push(`${hours}h`);
+  if (minutes > 0) parts.push(`${minutes}m`);
+  if (remainingSeconds > 0 || parts.length === 0) parts.push(`${remainingSeconds}s`);
+
+  return parts.join(' ');
+}
+
+export function formatExecutingWorkSessionMessage({ commandName = 'solve', sessionName = 'unknown', isolationBackend = null, infoBlock = '' } = {}) {
+  const isolationInfo = isolationBackend ? `\n🔒 Isolation: \`${isolationBackend}\`` : '';
+  const details = infoBlock ? `\n\n${infoBlock}` : '';
+  return `⏳ ${capitalizeCommandName(commandName)} command executing...\n\n📊 Session: \`${sessionName}\`${isolationInfo}${details}`;
+}
+
+export function formatSessionCompletionMessage({ sessionName, sessionInfo, statusResult = null, observedEndTime = new Date(), exitCode = null } = {}) {
+  const finalExitCode = getSessionCompletionExitCode({ exitCode, statusResult });
+  const failed = finalExitCode !== null && finalExitCode !== 0;
+  const statusEmoji = failed ? '❌' : '✅';
+  const statusText = failed ? `Failed (exit code: ${finalExitCode})` : 'Completed';
+  const isolationInfo = sessionInfo?.isolationBackend ? `\n🔒 Isolation: ${sessionInfo.isolationBackend}` : '';
+  const startTime = parseDateValue(statusResult?.startTime) || parseDateValue(sessionInfo?.startTime) || observedEndTime;
+  const endTime = parseDateValue(statusResult?.endTime) || observedEndTime;
+  const durationSeconds = Math.max(0, (endTime.getTime() - startTime.getTime()) / 1000);
+
+  let message = `${statusEmoji} *Work Session ${statusText}*\n\n`;
+  message += `📊 Session: \`${sessionName || 'unknown'}\`\n`;
+  message += `⏱️ Duration: ${formatSessionDurationSeconds(durationSeconds)}\n`;
+  message += `🔗 URL: ${sessionInfo?.url || 'unknown'}${isolationInfo}\n\n`;
+  message += 'The work session has finished. You can now review the results.';
+
+  return message;
+}