@link-assistant/hive-mind 2.10.0 → 2.10.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @link-assistant/hive-mind
 
+## 2.10.1
+
+### Patch Changes
+
+- a9b0967: Fix killed Telegram task resume instructions by recovering the last tool session from the complete task log, rejecting unrelated shared-directory session logs, and preserving the original slash-command alias through queued and restarted sessions.
+
 ## 2.10.0
 
 ### Minor Changes

package/package.json

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

package/src/session-monitor.lib.mjs

@@ -25,8 +25,7 @@ import { promisify } from 'util';
 import { formatSessionCompletionMessage, getSessionCompletionExitCode, classifySessionOutcome } from './work-session-formatting.lib.mjs';
 import { notifySubscribers, getSubscriberCount } from './telegram-subscribers.lib.mjs';
 import { classifyExitStatus, normalizeExitCode } from './session-status.lib.mjs';
-import path from 'node:path';
-import { readLastSessionIdFromLog, findLatestSessionLogId, buildResumeCommand, formatResumeSection } from './session-resume.lib.mjs';
+import { readLastSessionIdFromLog, buildResumeCommand, formatResumeSection } from './session-resume.lib.mjs';
 
 export { formatSessionCompletionMessage, getSessionCompletionExitCode } from './work-session-formatting.lib.mjs';
 
@@ -913,14 +912,11 @@ export async function monitorSessions(bot, verbose = false, options = {}) {
             const logPath = statusResult?.logPath || sessionInfo?.logPath || null;
             // The id must be the AI TOOL's session id, not the isolation session
             //   id (sessionInfo.sessionId — wrong namespace for `solve --resume`).
-            //   Prefer the last `Session ID:` marker in the captured log; fall
-            //   back to the newest `<sessionId>.log` start-command wrote in the
-            //   same directory. If neither exists, offer no command (a bogus
-            //   resume id would be worse than none).
-            let lastSessionId = readLastSessionIdFromLog(logPath, { verbose });
-            if (!lastSessionId && logPath) {
-              lastSessionId = findLatestSessionLogId({ dir: path.dirname(logPath), verbose });
-            }
+            //   Scan backwards through this task's captured log for its last
+            //   `Session ID:` marker. Do not guess from neighboring UUID-named
+            //   logs: start-command stores unrelated tasks in the same backend
+            //   directory, which caused issue #2109's invalid resume id.
+            const lastSessionId = readLastSessionIdFromLog(logPath, { verbose });
             const resumeCommand = buildResumeCommand({ sessionInfo, lastSessionId });
             const resumeSection = formatResumeSection({ lastSessionId, command: resumeCommand });
             if (resumeSection) {

package/src/session-resume.lib.mjs

@@ -11,11 +11,10 @@
  *   1. **Use the LAST session id.** A single `/solve` run can spin up *many*
  *      tool sessions — auto-continue across usage-limit resets, uncommitted-
  *      changes restarts (`solve.watch`), and manual `--resume` chains. Every one
- *      prints a `Session ID:` marker to the captured log in chronological order,
- *      and start-command also renames the per-session log to `<sessionId>.log`.
+ *      prints a `Session ID:` marker to the captured log in chronological order.
  *      The most advanced context lives in the *last* of these, so resuming must
- *      pick the last id — never the first. {@link selectLastSessionId} /
- *      {@link findLatestSessionLogId} enforce that rule.
+ *      pick the last id — never the first. {@link selectLastSessionId} and
+ *      {@link readLastSessionIdFromLog} enforce that rule.
  *
  *   2. **Never storm.** Auto-resuming a killed session must be bounded so a job
  *      that reliably OOMs cannot spawn an infinite relaunch loop (which would be
@@ -41,6 +40,8 @@ const SESSION_ID_MARKER_RE = /Session ID:\s*`?([^\s`]+)`?/gi;
 // `<sessionId>.log` files start-command writes. Used to validate directory
 // scans so unrelated `*.log` files are never mistaken for a session.
 const SESSION_LOG_UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const DEFAULT_LOG_SCAN_CHUNK_BYTES = 262144;
+const LOG_SCAN_OVERLAP_BYTES = 1024;
 
 /**
  * Extract every tool session id printed to a log, in the order they appear.
@@ -79,34 +80,52 @@ export function selectLastSessionId(text) {
 }
 
 /**
- * Read the LAST tool session id from a `/solve` execution log. Only the tail of
- * the file is scanned (the most recent session marker lives near the end), so
- * this stays cheap on multi-megabyte logs. Never throws — a missing/unreadable
- * log yields `null`.
+ * Read the LAST tool session id from a `/solve` execution log. The file is
+ * scanned backwards in bounded chunks: this normally stops after the tail
+ * chunk, while still finding a valid marker that precedes a long tool trace.
+ * Adjacent chunks overlap so a marker split at a chunk boundary is not lost.
+ * Never throws — a missing/unreadable log yields `null`.
  *
  * @param {string} logPath
  * @param {Object} [options]
  * @param {Object} [options.fsImpl=fs] - Injectable fs (for tests)
- * @param {number} [options.tailBytes=262144] - Trailing bytes to scan (256 KiB)
+ * @param {number} [options.tailBytes=262144] - Bytes per backwards scan chunk
  * @param {boolean} [options.verbose]
  * @returns {string|null}
  */
 export function readLastSessionIdFromLog(logPath, options = {}) {
-  const { fsImpl = fs, tailBytes = 262144, verbose = false } = options;
+  const { fsImpl = fs, tailBytes = DEFAULT_LOG_SCAN_CHUNK_BYTES, verbose = false } = options;
   if (!logPath) return null;
   try {
     const stat = fsImpl.statSync(logPath);
-    const start = Math.max(0, stat.size - tailBytes);
+    const chunkBytes = Number.isFinite(tailBytes) && tailBytes > 0 ? Math.floor(tailBytes) : DEFAULT_LOG_SCAN_CHUNK_BYTES;
     const fd = fsImpl.openSync(logPath, 'r');
     try {
-      const length = stat.size - start;
-      const buffer = Buffer.alloc(length);
-      fsImpl.readSync(fd, buffer, 0, length, start);
-      const id = selectLastSessionId(buffer.toString('utf8'));
-      if (verbose && id) {
-        console.log(`[VERBOSE] session-resume: last tool session id in ${logPath} is ${id}`);
+      let end = stat.size;
+      let laterPrefix = Buffer.alloc(0);
+      let chunksScanned = 0;
+      while (end > 0) {
+        const start = Math.max(0, end - chunkBytes);
+        const length = end - start;
+        const buffer = Buffer.alloc(length);
+        const bytesRead = fsImpl.readSync(fd, buffer, 0, length, start);
+        const current = bytesRead === length ? buffer : buffer.subarray(0, bytesRead);
+        const scanBuffer = laterPrefix.length > 0 ? Buffer.concat([current, laterPrefix]) : current;
+        const id = selectLastSessionId(scanBuffer.toString('utf8'));
+        chunksScanned += 1;
+        if (id) {
+          if (verbose) {
+            console.log(`[VERBOSE] session-resume: last tool session id in ${logPath} is ${id} (scanned ${chunksScanned} chunk${chunksScanned === 1 ? '' : 's'})`);
+          }
+          return id;
+        }
+        laterPrefix = current.subarray(0, Math.min(current.length, LOG_SCAN_OVERLAP_BYTES));
+        end = start;
       }
-      return id;
+      if (verbose) {
+        console.log(`[VERBOSE] session-resume: no tool session id found in ${logPath} after scanning ${chunksScanned} chunk${chunksScanned === 1 ? '' : 's'}`);
+      }
+      return null;
     } finally {
       fsImpl.closeSync(fd);
     }
@@ -121,10 +140,10 @@ export function readLastSessionIdFromLog(logPath, options = {}) {
 /**
  * Find the id of the most-recently-modified `<sessionId>.log` in a directory.
  *
- * start-command renames each tool session's log to `<sessionId>.log`, so the
- * newest such file is the last session of the run — a second, filesystem-based
- * source for the "use the last session" rule that works even when the captured
- * stdout log has been rotated away. Never throws.
+ * This helper is safe only when `dir` is already known to contain logs for one
+ * task. A shared start-command directory cannot attribute its newest UUID log
+ * to a particular `/solve` run, so completion notifications must not use this
+ * as a fallback. Never throws.
  *
  * @param {Object} options
  * @param {string} options.dir - Directory holding `<sessionId>.log` files
@@ -215,7 +234,8 @@ export function buildResumeCommand({ sessionInfo = {}, lastSessionId = null, bin
   const url = sessionInfo.url || (Array.isArray(sessionInfo.args) ? sessionInfo.args[0] : null);
   if (!url) return null;
 
-  const bin = binary || command;
+  const commandAlias = typeof sessionInfo.commandAlias === 'string' && /^[a-z0-9_-]+$/i.test(sessionInfo.commandAlias) ? sessionInfo.commandAlias : null;
+  const bin = binary || (commandAlias ? `/${commandAlias}` : command);
   let args;
   if (Array.isArray(sessionInfo.args) && sessionInfo.args.length > 0) {
     args = stripResumeFlag(sessionInfo.args);

package/src/session-store.lib.mjs

@@ -33,7 +33,9 @@ import path from 'node:path';
 // excluded so the snapshot stays small and safe to reload.
 // `args` (#1927 review follow-up) is persisted so a killed /solve can be resumed
 // with its exact original invocation plus `--resume <lastSessionId>`.
-const PERSISTABLE_FIELDS = ['chatId', 'messageId', 'startTime', 'url', 'command', 'isolationBackend', 'sessionId', 'containerFilesystemStartBytes', 'containerFilesystemLastBytes', 'containerFilesystemLastObservedAt', 'tool', 'infoBlock', 'urlContext', 'requesterUserId', 'showLimits', 'locale', 'logPath', 'args'];
+// `commandAlias` (#2109) preserves the Telegram spelling (`solve`, `codex`,
+// `claude`, etc.) so a bot notification never suggests a terminal-only command.
+const PERSISTABLE_FIELDS = ['chatId', 'messageId', 'startTime', 'url', 'command', 'commandAlias', 'isolationBackend', 'sessionId', 'containerFilesystemStartBytes', 'containerFilesystemLastBytes', 'containerFilesystemLastObservedAt', 'tool', 'infoBlock', 'urlContext', 'requesterUserId', 'showLimits', 'locale', 'logPath', 'args'];
 
 /**
  * Resolve the directory durable bot state is written to. Honors

package/src/telegram-bot.mjs

@@ -820,13 +820,13 @@ async function handleSolveCommand(ctx) {
 
   if (check.canStart && check.startReserved) {
     const startingMessage = await safeReply(ctx, formatStartingWorkSessionMessage({ infoBlock, locale: solveLocale }), { reply_to_message_id: ctx.message.message_id });
-    await executeAndUpdateMessage(ctx, startingMessage, 'solve', argsWithLocale, infoBlock, effectiveSolveIsolation, solveTool, solveUrlContext, { showLimits: solveShowLimits, limitsAtStart: solveLimitsAtStart, locale: solveLocale });
+    await executeAndUpdateMessage(ctx, startingMessage, 'solve', argsWithLocale, infoBlock, effectiveSolveIsolation, solveTool, solveUrlContext, { showLimits: solveShowLimits, limitsAtStart: solveLimitsAtStart, locale: solveLocale, commandAlias: solveCommandName });
   } else {
     if (!solveQueue.executeCallback) {
       const _t = (s, i) => trackSession(s, i, VERBOSE);
       solveQueue.executeCallback = createIsolationAwareQueueCallback(ISOLATION_BACKEND, isolationRunner, _t, createQueueExecuteCallback(executeStartScreen, _t), VERBOSE);
     }
-    const queueItem = solveQueue.enqueue({ url: normalizedUrl, args: argsWithLocale, ctx, requester, infoBlock, tool: solveTool, perCommandIsolation: effectiveSolveIsolation, urlContext: solveUrlContext, showLimits: solveShowLimits, limitsAtStart: solveLimitsAtStart, locale: solveLocale });
+    const queueItem = solveQueue.enqueue({ url: normalizedUrl, args: argsWithLocale, ctx, requester, infoBlock, commandAlias: solveCommandName, tool: solveTool, perCommandIsolation: effectiveSolveIsolation, urlContext: solveUrlContext, showLimits: solveShowLimits, limitsAtStart: solveLimitsAtStart, locale: solveLocale });
     const queueMessage = buildSolveQueuedMessage({ locale: solveLocale, tool: solveTool, position: toolQueuedCount + 1, infoBlock, reason: check.reason ? escapeMarkdown(check.reason) : '' }); // tool-specific position (#1551)
     const queuedMessage = await safeReply(ctx, queueMessage, { reply_to_message_id: ctx.message.message_id });
     queueItem.messageInfo = { chatId: queuedMessage.chat.id, messageId: queuedMessage.message_id };

package/src/telegram-command-execution.lib.mjs

@@ -99,7 +99,7 @@ function executeWithCommand(startScreenCmd, command, args, verbose = false) {
  */
 export function buildExecuteAndUpdateMessage(deps) {
   const { resolveIsolation, ISOLATION_BACKEND, isolationRunner, VERBOSE, executeStartScreen, trackSession, untrackSession, AUTO_WATCH_MESSAGE, startAutoTerminalWatchForSession, bot, formatExecutingWorkSessionMessage, formatStartingWorkSessionMessage } = deps;
-  return async function executeAndUpdateMessage(ctx, startingMessage, commandName, args, infoBlock, perCommandIsolation = null, tool = 'claude', urlContext = null, { showLimits = false, limitsAtStart = null, locale = null } = {}) {
+  return async function executeAndUpdateMessage(ctx, startingMessage, commandName, args, infoBlock, perCommandIsolation = null, tool = 'claude', urlContext = null, { showLimits = false, limitsAtStart = null, locale = null, commandAlias = null } = {}) {
     const { chat, message_id: msgId } = startingMessage;
     const safeEdit = async text => {
       try {
@@ -111,7 +111,7 @@ export function buildExecuteAndUpdateMessage(deps) {
     const requesterUserId = ctx.from?.id ?? null; // Issue #1688: suppress duplicate /subscribe DM
     // #1927 review follow-up: persist the full args so a killed /solve can be
     //   resumed with its exact original invocation + `--resume <lastSessionId>`.
-    const baseSessionInfo = { chatId: ctx.chat.id, messageId: msgId, startTime: new Date(), url: args[0], command: commandName, tool, infoBlock, urlContext, requesterUserId, showLimits, limitsAtStart, locale, args: Array.isArray(args) ? [...args] : undefined }; // #594: showLimits/limitsAtStart
+    const baseSessionInfo = { chatId: ctx.chat.id, messageId: msgId, startTime: new Date(), url: args[0], command: commandName, commandAlias, tool, infoBlock, urlContext, requesterUserId, showLimits, limitsAtStart, locale, args: Array.isArray(args) ? [...args] : undefined }; // #594: showLimits/limitsAtStart
     const iso = await resolveIsolation(perCommandIsolation, ISOLATION_BACKEND, isolationRunner, VERBOSE);
     let result, session, sessionInfo;
     if (iso) {

package/src/telegram-isolation.lib.mjs

@@ -90,11 +90,13 @@ export function createIsolationAwareQueueCallback(botIsolationBackend, botIsolat
             startTime: new Date(),
             url: item.url,
             command: item.command || 'solve',
+            commandAlias: item.commandAlias || null,
             isolationBackend: iso.backend,
             sessionId: sid,
             containerFilesystemStartBytes: Number.isFinite(r.containerFilesystemStartBytes) ? r.containerFilesystemStartBytes : null,
             tool,
             infoBlock: item.infoBlock,
+            args: Array.isArray(item.args) ? [...item.args] : undefined,
             // Issue #1688: propagate URL context + requester through the queue so the
             //   completion notification can append a 'Pull request:' line and skip
             //   notifying the requester twice via /subscribe.

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

@@ -53,6 +53,7 @@ class SolveQueueItem {
     this.ctx = options.ctx;
     this.requester = options.requester;
     this.infoBlock = options.infoBlock;
+    this.commandAlias = options.commandAlias || null; // #2109: retain Telegram spelling for resume guidance
     this.tool = options.tool || 'claude';
     // Issue #1983: preserve per-command isolation through queued execution.
     this.perCommandIsolation = options.perCommandIsolation || null;
@@ -1442,16 +1443,14 @@ export function createQueueExecuteCallback(executeStartScreen, trackSessionFn) {
           startTime: new Date(),
           url: item.url,
           command: 'solve',
+          commandAlias: item.commandAlias || null,
           tool: item.tool || 'claude',
           infoBlock: item.infoBlock,
-          // Issue #1688: propagate URL context + requester so the completion
-          //   notification can append a 'Pull request:' line and skip
-          //   notifying the requester twice via /subscribe.
+          args: Array.isArray(item.args) ? [...item.args] : undefined,
+          // #1688: propagate URL context and requester to completion.
           urlContext: item.urlContext || null,
           requesterUserId: item.requesterUserId ?? null,
-          // Issue #594: --show-limits virtual option carries the start-of-task
-          //   snapshot from the queueing point through to the completion
-          //   handler so it can render an end-of-task delta.
+          // #594: carry the start-of-task limits snapshot to completion.
           showLimits: item.showLimits === true,
           limitsAtStart: item.limitsAtStart || null,
           locale: item.locale || null,