@link-assistant/hive-mind 2.5.2 → 2.5.3

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @link-assistant/hive-mind
 
+## 2.5.3
+
+### Patch Changes
+
+- eb755b5: Recognize an operator-initiated `/stop` as "🛑 Work session stopped by user" instead of "killed — out of memory or forced kill (SIGKILL)" (issue #2052). The Telegram `/stop <uuid>` flow now records the stop via `markSessionStopRequested` before forwarding CTRL+C, so the resulting SIGTERM/SIGKILL exit (143/137) is reported as an intentional user stop. Adds `--verbose` interrupt timing traces (auto-commit vs log-upload) to make the `docker stop` grace-period race behind "no log uploaded on stop" measurable, plus a case study under `docs/case-studies/issue-2052`.
+
 ## 2.5.2
 
 ### Patch Changes

package/package.json

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

package/src/locales/en.lino

@@ -624,6 +624,7 @@ en
         finished "Work session finished successfully"
         failed "Work session failed (exit code: {{exitCode}})"
         killed "Work session {{reason}}{{exitSuffix}}"
+        stopped "Work session stopped by user{{requestedBy}}{{exitSuffix}}"
     duration
       label "Duration"
     session

package/src/locales/hi.lino

@@ -624,6 +624,7 @@ hi
         finished "कार्य सत्र सफलतापूर्वक पूरा हुआ"
         failed "कार्य सत्र विफल हुआ (exit code: {{exitCode}})"
         killed "कार्य सत्र रोका गया: {{reason}}{{exitSuffix}}"
+        stopped "कार्य सत्र उपयोगकर्ता द्वारा रोका गया{{requestedBy}}{{exitSuffix}}"
     duration
       label "अवधि"
     session

package/src/locales/ru.lino

@@ -624,6 +624,7 @@ ru
         finished "Рабочий сеанс успешно завершен"
         failed "Рабочий сеанс завершился с ошибкой (код выхода: {{exitCode}})"
         killed "Рабочий сеанс остановлен: {{reason}}{{exitSuffix}}"
+        stopped "Рабочий сеанс остановлен пользователем{{requestedBy}}{{exitSuffix}}"
     duration
       label "Длительность"
     session

package/src/locales/zh.lino

@@ -624,6 +624,7 @@ zh
         finished "工作会话已成功完成"
         failed "工作会话失败（退出代码：{{exitCode}}）"
         killed "工作会话已终止：{{reason}}{{exitSuffix}}"
+        stopped "工作会话已由用户停止{{requestedBy}}{{exitSuffix}}"
     duration
       label "耗时"
     session

package/src/session-monitor.lib.mjs

@@ -217,6 +217,33 @@ export function getTrackedSessionInfo(sessionName) {
   return activeSessions.get(sessionName) || null;
 }
 
+/**
+ * Issue #2052: record that an operator explicitly requested a session stop
+ * (e.g. Telegram `/stop <uuid>`). The subsequent SIGTERM/SIGKILL exit (143/137,
+ * delivered by `docker stop`) is then reported as "🛑 Stopped by user" instead
+ * of the misleading "out of memory or forced kill (SIGKILL)". Matches by
+ * tracking key OR by the isolation `sessionId` UUID (which is how `/stop`
+ * addresses sessions).
+ * @param {string} sessionId - UUID or session name of the session being stopped
+ * @param {{requestedBy?: string|null, verbose?: boolean}} [opts]
+ * @returns {boolean} True when a tracked session was marked.
+ */
+export function markSessionStopRequested(sessionId, { requestedBy = null, verbose = false } = {}) {
+  if (!sessionId) return false;
+  const target = activeSessions.get(sessionId) || Array.from(activeSessions.values()).find(info => info?.sessionId === sessionId) || null;
+  if (!target) {
+    if (verbose) console.log(`[VERBOSE] markSessionStopRequested: no tracked session found for ${sessionId}`);
+    return false;
+  }
+  target.stopRequestedByUser = true;
+  if (requestedBy) target.stopRequestedBy = requestedBy;
+  const key = target.sessionId || sessionId;
+  persistSessionSnapshot(key, target);
+  if (verbose) console.log(`[VERBOSE] markSessionStopRequested: ${sessionId} marked stopped by user${requestedBy ? ` (${requestedBy})` : ''}`);
+  logEvent('session_stop_requested', { sessionName: key, sessionId, requestedBy: requestedBy || null });
+  return true;
+}
+
 /**
  * Stop tracking a session that was registered optimistically but never actually
  * started (e.g. the start-command launch failed). Removes it from the in-memory

package/src/solve.interrupt.lib.mjs

@@ -22,10 +22,24 @@ export const createInterruptWrapper = ({ cleanupContext, checkForUncommittedChan
     const ctx = cleanupContext;
     if (!ctx.tempDir || !ctx.argv) return;
 
+    // Issue #2052: the interrupt handler races the isolation backend's grace
+    // period — `docker stop` sends SIGTERM, waits ~10s, then SIGKILL. Auto-commit
+    // is fast, but attaching a multi-MB log to a Gist/PR can take several seconds
+    // and may be cut off by SIGKILL, which is exactly "no log uploaded on stop".
+    // These verbose timing traces make the race measurable on the next iteration
+    // (they are silent unless --verbose is set).
+    const verbose = ctx.argv.verbose || false;
+    const startedAt = Date.now();
+    const trace = async message => {
+      if (verbose) await log(`[interrupt] +${Date.now() - startedAt}ms ${message}`, { verbose: true });
+    };
+    await trace('handler entered');
+
     await log('\n⚠️  Session interrupted by user (CTRL+C)');
 
     // Always auto-commit uncommitted changes on CTRL+C to preserve work
     if (ctx.branchName) {
+      await trace('auto-commit: start');
       try {
         await checkForUncommittedChanges(
           ctx.tempDir,
@@ -37,6 +51,7 @@ export const createInterruptWrapper = ({ cleanupContext, checkForUncommittedChan
           true, // always autoCommit on CTRL+C to preserve work
           false // no autoRestart
         );
+        await trace('auto-commit: done');
       } catch (commitError) {
         await log(`⚠️  Could not auto-commit changes on interrupt: ${commitError.message}`, {
           level: 'warning',
@@ -47,6 +62,7 @@ export const createInterruptWrapper = ({ cleanupContext, checkForUncommittedChan
     // Upload logs if --attach-logs is enabled and we have a PR
     if (shouldAttachLogs && ctx.prNumber && ctx.owner && ctx.repo) {
       await log('📎 Uploading interrupted session logs to Pull Request...');
+      await trace('log-upload: start');
       try {
         await attachLogToGitHub({
           logFile: getLogFile(),
@@ -63,6 +79,7 @@ export const createInterruptWrapper = ({ cleanupContext, checkForUncommittedChan
           requestedModel: ctx.argv.model,
           tool: ctx.argv.tool || 'claude',
         });
+        await trace('log-upload: done');
       } catch (uploadError) {
         await log(`⚠️  Could not upload logs on interrupt: ${uploadError.message}`, {
           level: 'warning',

package/src/telegram-start-stop-command.lib.mjs

@@ -285,6 +285,24 @@ export function registerStartStopCommands(bot, options) {
     return mod.getTrackedSessionInfo(sessionId);
   }
 
+  // Issue #2052: record that this stop was operator-initiated, so the eventual
+  // SIGTERM/SIGKILL exit (delivered by `docker stop`) is reported as
+  // "🛑 Stopped by user" instead of "out of memory or forced kill (SIGKILL)".
+  // Tolerant of a sync or async stub, and never lets a marking failure block
+  // the actual stop.
+  async function markSessionStopRequestedSafe(sessionId, requestedBy) {
+    try {
+      if (typeof options.markSessionStopRequested === 'function') {
+        return await options.markSessionStopRequested(sessionId, { requestedBy, verbose: VERBOSE });
+      }
+      const mod = await import('./session-monitor.lib.mjs');
+      return mod.markSessionStopRequested(sessionId, { requestedBy, verbose: VERBOSE });
+    } catch (error) {
+      console.error('[ERROR] /stop: markSessionStopRequested failed:', error);
+      return false;
+    }
+  }
+
   // Issue #1871: look a URL up in the session-monitor registry of running
   // detached sessions. A /solve or /codex that started immediately (queue
   // empty) is dispatched straight to an isolation session and removed from the
@@ -425,6 +443,12 @@ export function registerStartStopCommands(bot, options) {
       reply_to_message_id: message.message_id,
     });
 
+    // Issue #2052: mark the stop as user-initiated BEFORE forwarding CTRL+C, so
+    // even a fast SIGKILL race still finds the flag when the completion message
+    // is formatted.
+    const requestedBy = ctx.from?.username ? `@${ctx.from.username}` : ctx.from?.first_name || null;
+    await markSessionStopRequestedSafe(sessionId, requestedBy);
+
     let result;
     try {
       result = await stopIsolatedSessionImpl(sessionId, VERBOSE);

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

@@ -132,13 +132,25 @@ export function formatSessionCompletionMessage({ sessionName, sessionInfo, statu
   const finalExitCode = getSessionCompletionExitCode({ exitCode, statusResult });
   const outcome = classifySessionOutcome({ exitCode: finalExitCode, status: statusResult?.status || null });
   const { failed, killed, signal } = outcome;
-  const statusEmoji = failed ? '❌' : '✅';
   const messageLocale = locale || sessionInfo?.locale || null;
   // Issue #1927: a killed session (OOM/SIGKILL/SIGTERM) must never read as a
   // success, and the signal/reason is surfaced explicitly so an operator can
   // tell an out-of-memory kill apart from an ordinary non-zero exit.
+  // Issue #2052: when the operator explicitly requested a stop (e.g. Telegram
+  // `/stop <uuid>` → `docker stop` → SIGTERM then SIGKILL), the resulting signal
+  // exit (143/137) must NOT read as "out of memory or forced kill". A user stop
+  // is an orderly, intentional termination, so surface it as such regardless of
+  // which signal actually delivered the kill.
+  const stopRequestedByUser = Boolean(sessionInfo?.stopRequestedByUser);
+  let statusEmojiOverride = null;
   let statusText;
-  if (killed) {
+  if (killed && stopRequestedByUser) {
+    const showCode = finalExitCode !== null && !(!signal && finalExitCode === 1);
+    const exitSuffix = showCode ? ` (exit code: ${finalExitCode})` : '';
+    const requestedBy = sessionInfo?.stopRequestedBy ? ` by ${sessionInfo.stopRequestedBy}` : '';
+    statusEmojiOverride = '🛑';
+    statusText = text(messageLocale, 'telegram.work_session_stopped', `Work session stopped by user${requestedBy}${exitSuffix}`, { requestedBy, exitCode: finalExitCode ?? '', signal: signal?.signal ?? '', exitSuffix });
+  } else if (killed) {
     // A real signal exit is always >128; an exit code of exactly 1 on a
     // status-only kill (process vanished, code unknown) is a synthesized failure
     // sentinel, so suppress the misleading "(exit code: 1)" in that case.
@@ -164,6 +176,7 @@ export function formatSessionCompletionMessage({ sessionName, sessionInfo, statu
   if (pullRequestUrl) resolvedInfoBlock = appendPullRequestLine(resolvedInfoBlock, pullRequestUrl, { locale: messageLocale });
   const details = resolvedInfoBlock ? `\n\n${resolvedInfoBlock}` : '';
 
+  const statusEmoji = statusEmojiOverride || (failed ? '❌' : '✅');
   let message = `${statusEmoji} *${statusText}*\n\n`;
   message += `⏱️ ${durationLabel}: ${formatSessionDurationSeconds(durationSeconds)}\n`;
   message += `📊 ${sessionLabel}: \`${sessionName || 'unknown'}\`${isolationInfo}${details}`;