@link-assistant/hive-mind 1.64.3 → 1.65.0

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @link-assistant/hive-mind
 
+## 1.65.0
+
+### Minor Changes
+
+- 14fe57e: Prevent normal Docker release manifest jobs from downloading DinD digest artifacts.
+- 74ce579: Reduce `/terminal_watch` Telegram edits by updating only when the displayed terminal snapshot changes and count only real terminal snapshot updates.
+- 78ab6e2: Add `--auto-delete-branch-on-merge` option for the `solve` command. When set together with `--watch`, the branch is deleted from the remote after the pull request is merged; when set together with `--auto-merge`, the auto-merge call requests branch deletion as part of the merge. The option is opt-in (default `false`), enables full GitHub Flow automation, avoids temporary auto-restart cleanup, uses the GitHub REST API for watch-mode deletion, and treats "branch already gone" responses as success so it does not warn when GitHub's "Automatically delete head branches" repo setting beats us to it.
+- 152de95: Add a Claude CLI streaming input case study with reproducible experiment scripts.
+
+## 1.64.4
+
+### Patch Changes
+
+- 20f5898: Add `/stop <UUID>` and reply-to-message-with-UUID modes to the Telegram bot (#524). Sending `/stop <uuid>` (or replying with `/stop` to a message containing a UUID) forwards CTRL+C to the matching isolated `/solve` or `/hive` session via `$ --stop <uuid>` from link-foundation/start (link-foundation/start#112), so individual screen/tmux/docker sessions can be cancelled from Telegram. Mirrors the existing `/log` and `/terminal_watch` UUID-resolution pattern. Bare `/stop` retains its existing chat-pause behaviour (#1081).
+
 ## 1.64.3
 
 ### Patch Changes

package/package.json

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

package/src/isolation-runner.lib.mjs

@@ -255,6 +255,55 @@ export async function querySessionStatus(sessionId, verbose = false) {
   }
 }
 
+/**
+ * Ask the `$` CLI to gracefully stop an isolated session by sending CTRL+C.
+ *
+ * Wraps `$ --stop <uuid>` from start-command (link-foundation/start#112).
+ * Works for any isolation backend (screen, tmux, docker, …) — `$` knows the
+ * backend it launched with and forwards the interrupt accordingly.
+ *
+ * @param {string} sessionId - UUID of the session to stop
+ * @param {boolean} [verbose] - Enable verbose logging
+ * @returns {Promise<{success: boolean, output: string, error: string|null}>}
+ */
+export async function stopIsolatedSession(sessionId, verbose = false) {
+  const binPath = await findStartCommandBinary();
+  if (!binPath) {
+    if (verbose) {
+      console.log('[VERBOSE] isolation-runner: Cannot stop session - $ binary not found');
+    }
+    return {
+      success: false,
+      output: '',
+      error: '`$` (start-command) binary not found on PATH. Install link-foundation/start to use /stop <UUID>.',
+    };
+  }
+
+  try {
+    const result = await $({ mirror: false })`${binPath} --stop ${sessionId}`;
+    const stdout = result.stdout?.toString() || '';
+    const stderr = result.stderr?.toString() || '';
+    if (verbose) {
+      console.log(`[VERBOSE] isolation-runner: $ --stop ${sessionId} stdout: ${stdout.substring(0, 300)}`);
+      if (stderr) {
+        console.log(`[VERBOSE] isolation-runner: $ --stop ${sessionId} stderr: ${stderr.substring(0, 300)}`);
+      }
+    }
+    return { success: true, output: stdout || stderr, error: null };
+  } catch (error) {
+    const stderr = error?.stderr?.toString?.() || '';
+    const stdout = error?.stdout?.toString?.() || '';
+    if (verbose) {
+      console.log(`[VERBOSE] isolation-runner: $ --stop ${sessionId} failed: ${error.message}`);
+    }
+    return {
+      success: false,
+      output: stdout,
+      error: stderr.trim() || error?.message || String(error),
+    };
+  }
+}
+
 /**
  * Check if a screen session exists via `screen -ls`.
  * Used as a fallback when `$ --status` fails to find or correctly track

package/src/solve.auto-merge.lib.mjs

@@ -67,6 +67,8 @@ const { maybeAttachWorkingSessionSummary } = resultsLib;
 const { interruptibleSleep } = await import('./interruptible-sleep.lib.mjs');
 const { formatAutoIterationLimit, hasReachedAutoIterationLimit, normalizeAutoIterationLimit, shouldSyncBeforeRestart } = await import('./auto-iteration-limits.lib.mjs');
 
+const shouldDeleteBranchAfterMerge = argv => argv.autoDeleteBranchOnMerge || argv.deleteBranchAfterMerge || false;
+
 /**
  * Main function: Watch and restart until PR becomes mergeable
  * This implements --auto-restart-until-mergeable functionality
@@ -273,7 +275,11 @@ export const watchUntilMergeable = async params => {
         if (isAutoMerge) {
           // Attempt to merge the PR
           await log(formatAligned('🔀', 'Auto-merging PR...', ''));
-          const mergeResult = await mergePullRequest(owner, repo, prNumber, { squash: argv.squash || false, deleteAfter: argv.deleteBranchAfterMerge || false }, argv.verbose);
+          const deleteAfterMerge = shouldDeleteBranchAfterMerge(argv);
+          if (deleteAfterMerge) {
+            await log(formatAligned('', 'Branch cleanup:', 'will delete branch after successful merge', 2));
+          }
+          const mergeResult = await mergePullRequest(owner, repo, prNumber, { squash: argv.squash || false, deleteAfter: deleteAfterMerge }, argv.verbose);
 
           if (mergeResult.success) {
             await log(formatAligned('🎉', 'PR MERGED SUCCESSFULLY!', ''));
@@ -1045,7 +1051,11 @@ export const attemptAutoMerge = async params => {
   await log(formatAligned('✅', 'PR is mergeable:', 'Attempting to merge...', 2));
 
   // Attempt to merge
-  const mergeResult = await mergePullRequest(owner, repo, prNumber, { squash: argv.squash || false, deleteAfter: argv.deleteBranchAfterMerge || false }, argv.verbose);
+  const deleteAfterMerge = shouldDeleteBranchAfterMerge(argv);
+  if (deleteAfterMerge) {
+    await log(formatAligned('', 'Branch cleanup:', 'will delete branch after successful merge', 2));
+  }
+  const mergeResult = await mergePullRequest(owner, repo, prNumber, { squash: argv.squash || false, deleteAfter: deleteAfterMerge }, argv.verbose);
 
   if (mergeResult.success) {
     await log(formatAligned('🎉', 'PR MERGED SUCCESSFULLY!', ''));

package/src/solve.config.lib.mjs

@@ -243,6 +243,11 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: 'Interval in seconds for checking feedback in watch mode (default: 60)',
     default: 60,
   },
+  'auto-delete-branch-on-merge': {
+    type: 'boolean',
+    description: 'Automatically delete the branch after the pull request is merged in --watch mode or by --auto-merge. Enables full GitHub Flow support (issue #401).',
+    default: false,
+  },
   'min-disk-space': {
     type: 'number',
     description: 'Minimum required disk space in MB (default: 2048)',

package/src/solve.watch.lib.mjs

@@ -107,6 +107,52 @@ export const watchForFeedback = async params => {
       await log('');
       await log(formatAligned('🎉', 'PR MERGED!', 'Stopping watch mode'));
       await log(formatAligned('', 'Pull request:', `#${prNumber} has been merged`, 2));
+
+      // Issue #401: If --auto-delete-branch-on-merge is enabled in --watch mode,
+      // delete the branch from the remote after the PR is merged. This enables
+      // full GitHub Flow automation. Only applies in --watch mode (not auto-restart),
+      // because auto-restart is for completing local work, not finalizing GitHub Flow.
+      const shouldAutoDeleteBranch = !isTemporaryWatch && argv.autoDeleteBranchOnMerge && branchName;
+      if (shouldAutoDeleteBranch) {
+        await log('');
+        await log(formatAligned('🗑️', 'AUTO-DELETE:', `Deleting branch ${branchName} after merge`));
+        try {
+          // Delete the branch from the remote via GitHub REST API.
+          // We use `gh api ... -X DELETE` rather than `git push --delete` so we don't
+          // require a configured local remote in tempDir at this point in the run.
+          const deleteBranchResult = await $`gh api repos/${owner}/${repo}/git/refs/heads/${branchName} -X DELETE`;
+          if (deleteBranchResult.code === 0) {
+            await log(formatAligned('✅', 'Branch deleted:', `${branchName}`, 2));
+          } else {
+            const stderrText = deleteBranchResult.stderr?.toString().trim() || 'Unknown error';
+            // 422 Reference does not exist -> branch was already deleted (e.g. GitHub's "Automatically delete head branches"
+            // setting raced ahead of us). Treat as success rather than warning.
+            if (/Reference does not exist|Not Found|422|404/i.test(stderrText)) {
+              await log(formatAligned('✅', 'Branch already removed:', `${branchName} (no action needed)`, 2));
+            } else {
+              await log(formatAligned('⚠️', 'Branch deletion failed:', stderrText, 2));
+              reportError(new Error(`Branch deletion returned non-zero exit code: ${stderrText}`), {
+                context: 'delete_branch_on_merge_non_zero',
+                owner,
+                repo,
+                branchName,
+                exitCode: deleteBranchResult.code,
+                operation: 'delete_remote_branch',
+              });
+            }
+          }
+        } catch (deleteError) {
+          reportError(deleteError, {
+            context: 'delete_branch_on_merge',
+            owner,
+            repo,
+            branchName,
+            operation: 'delete_remote_branch',
+          });
+          await log(formatAligned('⚠️', 'Branch deletion error:', cleanErrorMessage(deleteError), 2));
+        }
+      }
+
       await log('');
       break;
     }

package/src/telegram-bot.mjs

@@ -571,6 +571,7 @@ bot.command('help', async ctx => {
   message += '*/subscribe* / */unsubscribe* - 🔔 Get private DM forward of /solve completion (experimental, #1688)\n';
   message += '*/help* - Show this help message\n';
   message += '*/stop* / */start* - Stop or resume accepting new tasks (owner only)\n';
+  message += '*/stop* `<uuid>` - Send CTRL+C to an isolated solve/hive session (owner only). Also works as a reply to a message containing the UUID.\n';
   message += '*/log* - Fetch isolation session log (owner only). Usage: `/log <uuid>` or reply with `/log`\n';
   message += '*/terminal\\_watch* - Live-update an isolation session log (owner only). Usage: `/terminal_watch <uuid>` or reply with `/terminal_watch`\n\n';
   message += '🔔 *Session Notifications:* Completion notifications are automatic; use /subscribe for private DM forwards.\n';

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

@@ -10,10 +10,17 @@
  * - Graceful stop: existing queue items continue to process
  * - Read-only commands (/help, /limits, /version) remain available when stopped
  * - Write commands (/solve, /hive) are rejected when stopped
+ * - `/stop <UUID>` or reply-to-message-with-UUID forwards CTRL+C to the
+ *   matching isolated solve/hive session via `$ --stop <UUID>` from
+ *   link-foundation/start (issue #524).
  *
  * @see https://github.com/link-assistant/hive-mind/issues/1081
+ * @see https://github.com/link-assistant/hive-mind/issues/524
+ * @see https://github.com/link-foundation/start/issues/112
  */
 
+import { extractSessionIdFromText } from './telegram-log-command.lib.mjs';
+
 // Store stopped chats: Map<chatId, { stoppedAt: Date, stoppedBy: { id, username, firstName }, reason?: string }>
 const stoppedChats = new Map();
 
@@ -86,6 +93,30 @@ export function getStoppedChatRejectMessage(chatId, commandName = 'Command') {
   return `❌ ${commandName} command rejected.\n\n🚫 Reason: ${reason}\n\nUse /start to resume (chat owner only).`;
 }
 
+/**
+ * Extract a session UUID for `/stop`. Priority:
+ *   1. UUID literal anywhere in the `/stop` message text.
+ *   2. UUID in the text/caption of the message being replied to.
+ *
+ * The `text` argument is the raw `/stop ...` command text. `repliedTo`, when
+ * present, is the Telegram message object that the user replied to with `/stop`.
+ *
+ * @param {string} text
+ * @param {Object|null|undefined} repliedTo
+ * @returns {{ sessionId: string|null, source: 'argument'|'reply'|null }}
+ */
+export function extractStopSessionId(text, repliedTo) {
+  // Strip the leading `/stop` (or `/stop@botname`) before looking for a UUID,
+  // so we don't accidentally match digits inside the command name itself.
+  const argText = String(text || '').replace(/^\/stop(?:@\w+)?\s*/i, '');
+  const direct = extractSessionIdFromText(argText);
+  if (direct) return { sessionId: direct, source: 'argument' };
+  const replyText = repliedTo ? `${repliedTo.text || ''}\n${repliedTo.caption || ''}` : '';
+  const fromReply = extractSessionIdFromText(replyText);
+  if (fromReply) return { sessionId: fromReply, source: 'reply' };
+  return { sessionId: null, source: null };
+}
+
 /**
  * Registers the /start and /stop command handlers with the bot
  * @param {Object} bot - The Telegraf bot instance
@@ -95,9 +126,13 @@ export function getStoppedChatRejectMessage(chatId, commandName = 'Command') {
  * @param {Function} options.isForwardedOrReply - Function to check if message is forwarded/reply
  * @param {Function} options.isGroupChat - Function to check if chat is a group
  * @param {Function} options.isChatAuthorized - Function to check if chat is authorized
+ * @param {Function} [options.isTopicAuthorized] - Topic-level authorization fallback
+ * @param {Function} [options.buildAuthErrorMessage] - Builds the chat-not-authorized message
+ * @param {Function} [options.stopIsolatedSession] - Override for tests; calls `$ --stop <uuid>`
  */
 export function registerStartStopCommands(bot, options) {
-  const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized } = options;
+  const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized, isTopicAuthorized, buildAuthErrorMessage } = options;
+  const stopIsolatedSessionImpl = options.stopIsolatedSession || (async (...args) => (await import('./isolation-runner.lib.mjs')).stopIsolatedSession(...args));
 
   /**
    * Validate command context: checks old message, forwarded, group chat, authorized, and owner status.
@@ -145,9 +180,110 @@ export function registerStartStopCommands(bot, options) {
     return { valid: true, chatId };
   }
 
-  // /stop command - stop accepting new tasks in this chat
-  // Only accessible by chat owner (creator)
+  // /stop command. Two modes:
+  //   1. `/stop <UUID>` or reply-to-message-with-UUID — forward CTRL+C to the
+  //      matching isolated session via `$ --stop <UUID>` (issue #524).
+  //   2. bare `/stop` (optionally with a free-text reason) — pause new task
+  //      acceptance for the chat (issue #1081).
+  // Only accessible by chat owner (creator) in both modes.
   bot.command('stop', async ctx => {
+    VERBOSE && console.log('[VERBOSE] /stop command received');
+    if (isOldMessage(ctx)) {
+      VERBOSE && console.log('[VERBOSE] /stop ignored: old message');
+      return;
+    }
+
+    // Detect UUID modes BEFORE the forwarded/reply rejection used by the
+    // chat-level stop, because the UUID-from-reply mode is intentionally a
+    // reply (issue #524).
+    const message = ctx.message;
+    const repliedTo = message?.reply_to_message || null;
+    const { sessionId, source } = extractStopSessionId(message?.text || '', repliedTo);
+
+    if (sessionId) {
+      VERBOSE && console.log(`[VERBOSE] /stop: detected UUID ${sessionId} (source=${source})`);
+      // Reuse the same auth model as /log: must be chat owner in groups; in
+      // private DMs the user is implicitly the owner of their own chat.
+      const chatId = ctx.chat?.id;
+      const chatType = ctx.chat?.type;
+      if (chatType !== 'private') {
+        if (!isGroupChat(ctx)) {
+          await ctx.reply('❌ The /stop command only works in group chats or private chats with the bot.', { reply_to_message_id: message.message_id });
+          return;
+        }
+        if (!isChatAuthorized(chatId)) {
+          if (!isTopicAuthorized || !isTopicAuthorized(ctx)) {
+            const errMsg = buildAuthErrorMessage ? buildAuthErrorMessage(ctx) : `❌ This chat (ID: ${chatId}) is not authorized to use this bot.`;
+            await ctx.reply(errMsg, { reply_to_message_id: message.message_id });
+            return;
+          }
+        }
+        try {
+          const member = await ctx.telegram.getChatMember(chatId, ctx.from.id);
+          if (!member || member.status !== 'creator') {
+            VERBOSE && console.log('[VERBOSE] /stop <UUID> ignored: user is not chat owner');
+            await ctx.reply('❌ /stop <UUID> is only available to the chat owner.', { reply_to_message_id: message.message_id });
+            return;
+          }
+        } catch (error) {
+          console.error('[ERROR] /stop <UUID>: getChatMember failed:', error);
+          await ctx.reply('❌ Failed to verify permissions for /stop.', { reply_to_message_id: message.message_id });
+          return;
+        }
+      }
+
+      const ack = await ctx.reply(`⏹️ Asking session \`${sessionId}\` to stop (sending CTRL+C via \`$ --stop\`)…`, {
+        parse_mode: 'Markdown',
+        reply_to_message_id: message.message_id,
+      });
+
+      let result;
+      try {
+        result = await stopIsolatedSessionImpl(sessionId, VERBOSE);
+      } catch (error) {
+        console.error('[ERROR] /stop <UUID>: stopIsolatedSession threw:', error);
+        result = { success: false, output: '', error: error?.message || String(error) };
+      }
+
+      const trimmedOutput = (result.output || '').toString().trim();
+      const trimmedError = (result.error || '').toString().trim();
+      const lines = [];
+      if (result.success) {
+        lines.push(`✅ Stop request sent to session \`${sessionId}\`.`);
+        lines.push('');
+        lines.push('The session should terminate shortly.');
+        if (trimmedOutput) {
+          lines.push('');
+          lines.push('```');
+          lines.push(trimmedOutput.slice(0, 1000));
+          lines.push('```');
+        }
+      } else {
+        lines.push(`❌ Failed to stop session \`${sessionId}\`.`);
+        if (trimmedError) {
+          lines.push('');
+          lines.push('```');
+          lines.push(trimmedError.slice(0, 1000));
+          lines.push('```');
+        }
+      }
+
+      try {
+        await ctx.telegram.editMessageText(ack.chat.id, ack.message_id, undefined, lines.join('\n'), { parse_mode: 'Markdown' });
+      } catch (error) {
+        console.error('[ERROR] /stop <UUID>: editMessageText failed, falling back to reply:', error);
+        await ctx.reply(lines.join('\n'), { parse_mode: 'Markdown', reply_to_message_id: message.message_id });
+      }
+      return;
+    }
+
+    // No UUID — fall through to the chat-level pause flow. That flow rejects
+    // forwards/replies on purpose (#1081) so a stray reply doesn't pause the chat.
+    if (isForwardedOrReply(ctx)) {
+      VERBOSE && console.log('[VERBOSE] /stop ignored: forwarded or reply');
+      return;
+    }
+
     const check = await validateOwnerCommand(ctx, '/stop');
     if (!check.valid) return;
     const chatId = check.chatId;

package/src/telegram-terminal-watch-command.lib.mjs

@@ -173,12 +173,18 @@ async function querySessionStatusWithRetry(querySessionStatus, sessionId, verbos
 
 // Note: /terminal_watch never uploads the full session log itself (issue #1720).
 // Use /log <uuid> if you want the log file delivered as a document.
-export function watchTerminalLogSession({ bot, chatId, messageId, sessionId, logPath, querySessionStatus, isTerminalSessionStatus, options = {}, repoDescription = null, verbose = false }) {
+function getDisplayedTerminalSnapshot(logText, options) {
+  return sanitizeCodeBlock(tailTextForTerminal(logText, options));
+}
+
+export function watchTerminalLogSession({ bot, chatId, messageId, sessionId, logPath, querySessionStatus, isTerminalSessionStatus, options = {}, repoDescription = null, verbose = false, initialStatusResult = null, initialLogText = null, initialMessage = '' }) {
   const key = `${chatId}:${messageId}:${sessionId}`;
   activeWatches.get(key)?.stop();
 
   let stopped = false;
-  let lastMessage = '';
+  const hasInitialLogText = initialLogText !== null && initialLogText !== undefined;
+  let lastSnapshot = hasInitialLogText ? getDisplayedTerminalSnapshot(initialLogText, options) : null;
+  let lastMessage = initialMessage || (hasInitialLogText ? formatTerminalWatchMessage({ sessionId, statusResult: initialStatusResult, logText: initialLogText, options, updateCount: 0, completed: !!initialStatusResult?.status && isTerminalSessionStatus(initialStatusResult.status), repoDescription }) : '');
   let updateCount = 0;
   let timer = null;
   const intervalMs = options.intervalMs || DEFAULT_INTERVAL_MS;
@@ -189,11 +195,16 @@ export function watchTerminalLogSession({ bot, chatId, messageId, sessionId, log
       const statusResult = await querySessionStatus(sessionId, verbose);
       const completed = !!statusResult?.status && isTerminalSessionStatus(statusResult.status);
       const logText = await readLogFile(logPath);
-      const message = formatTerminalWatchMessage({ sessionId, statusResult, logText, options, updateCount: ++updateCount, completed, repoDescription });
-      if (message !== lastMessage) {
+      const snapshot = getDisplayedTerminalSnapshot(logText, options);
+      const snapshotChanged = snapshot !== lastSnapshot;
+      if (snapshotChanged) updateCount++;
+      const message = formatTerminalWatchMessage({ sessionId, statusResult, logText, options, updateCount, completed, repoDescription });
+      const shouldEdit = !lastMessage || snapshotChanged || (completed && message !== lastMessage);
+      if (shouldEdit && message !== lastMessage) {
         await bot.telegram.editMessageText(chatId, messageId, undefined, message, { parse_mode: 'Markdown' });
         lastMessage = message;
       }
+      lastSnapshot = snapshot;
       if (completed) {
         stopped = true;
         activeWatches.delete(key);
@@ -255,14 +266,15 @@ async function startWatchFromResolvedSession({ bot, ctx, sessionId, statusResult
   if (!targetChatId) return { started: false, reason: 'Missing target chat id' };
 
   const initialLogText = await readLogFile(logPath);
-  const initialText = formatTerminalWatchMessage({ sessionId, statusResult, logText: initialLogText, options: watchOptions, repoDescription });
+  const initialCompleted = !!statusResult?.status && isTerminalSessionStatus(statusResult.status);
+  const initialText = formatTerminalWatchMessage({ sessionId, statusResult, logText: initialLogText, options: watchOptions, completed: initialCompleted, repoDescription });
   let replyToMessageId = ctx.message?.message_id || undefined;
   if (decision.destination === 'dm' && ctx.chat.type !== 'private') {
     replyToMessageId = await forwardOrCopyToDm(ctx, ctx.message?.reply_to_message || ctx.message);
   }
 
   const watchMessage = await createWatchMessage({ ctx, targetChatId, replyToMessageId, text: initialText });
-  watchTerminalLogSession({ bot, chatId: targetChatId, messageId: watchMessage.message_id, sessionId, logPath, querySessionStatus, isTerminalSessionStatus, options: watchOptions, repoDescription, verbose });
+  watchTerminalLogSession({ bot, chatId: targetChatId, messageId: watchMessage.message_id, sessionId, logPath, querySessionStatus, isTerminalSessionStatus, options: watchOptions, repoDescription, verbose, initialStatusResult: statusResult, initialLogText, initialMessage: initialText });
 
   if (!auto && decision.destination === 'dm' && ctx.chat.type !== 'private') {
     await ctx.reply(`📬 Started terminal watch for \`${sessionId}\` in your direct messages.`, { parse_mode: 'Markdown', reply_to_message_id: ctx.message.message_id });