@link-assistant/hive-mind 1.64.4 → 1.65.1

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @link-assistant/hive-mind
 
+## 1.65.1
+
+### Patch Changes
+
+- d5cd096: Add a solve flag to disable separate error-report issue creation while preserving original issue failure comments, and improve pre-PR branch divergence diagnostics.
+
+## 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

package/package.json

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

package/src/github-error-reporter.lib.mjs

@@ -271,7 +271,7 @@ export const handleErrorWithIssueCreation = async options => {
 
   // --disable-report-issue takes highest precedence
   if (disableReport) {
-    await log('ℹ️  Issue reporting disabled via --disable-report-issue.');
+    await log('ℹ️  Error issue creation is disabled by CLI configuration.');
     return null;
   }
 

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.auto-pr.lib.mjs

@@ -4,8 +4,10 @@
  */
 
 import { closingIssueNumbersContain, parseClosingIssueNumbers } from './pr-issue-linking.lib.mjs';
+import { buildPushRejectionExplanation, getRemoteBranchDivergenceSnapshot, synchronizeExistingIssueBranchBeforeAutoPrCreation } from './solve.branch-divergence.lib.mjs';
 
 import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller
+
 export async function handleAutoPrCreation({ argv, tempDir, branchName, issueNumber, owner, repo, defaultBranch, forkedRepo, isContinueMode, prNumber, log, formatAligned, $, reportError, path, fs }) {
   // Skip auto-PR creation if:
   // 1. Auto-PR creation is disabled AND we're not in continue mode with no PR
@@ -33,6 +35,16 @@ export async function handleAutoPrCreation({ argv, tempDir, branchName, issueNum
   const issueUrl = argv['issue-url'] || argv._[0];
 
   try {
+    await synchronizeExistingIssueBranchBeforeAutoPrCreation({
+      tempDir,
+      branchName,
+      isContinueMode,
+      prNumber,
+      log,
+      formatAligned,
+      $,
+    });
+
     // Determine which file to create based on CLI flags
     let useClaudeFile = argv.claudeFile !== false;
     const useAutoGitkeepFile = argv.autoGitkeepFile !== false;
@@ -527,6 +539,7 @@ Proceed.
           await log('');
           throw new Error('Permission denied - need fork or collaborator access');
         } else if (errorOutput.includes('non-fast-forward') || errorOutput.includes('rejected') || errorOutput.includes('! [rejected]')) {
+          const divergence = await getRemoteBranchDivergenceSnapshot({ $, tempDir, branchName });
           // Push rejected due to conflicts or diverged history
           await log('');
           await log(formatAligned('❌', 'PUSH REJECTED:', 'Branch has diverged from remote'), { level: 'error' });
@@ -534,6 +547,9 @@ Proceed.
           await log('  🔍 What happened:');
           await log('     The remote branch has changes that conflict with your local changes.');
           await log('     This typically means someone else has pushed to this branch.');
+          for (const line of buildPushRejectionExplanation({ branchName, isContinueMode, prNumber, divergence })) {
+            await log(line);
+          }
           await log('');
           await log('  💡 Why we cannot fix this automatically:');
           await log('     • We never use force push to preserve history');

package/src/solve.branch-divergence.lib.mjs

@@ -0,0 +1,93 @@
+const toCount = value => {
+  const parsed = Number.parseInt(String(value || '').trim(), 10);
+  return Number.isFinite(parsed) ? parsed : null;
+};
+
+const outputOf = result => {
+  const stdout = result?.stdout ? result.stdout.toString().trim() : '';
+  const stderr = result?.stderr ? result.stderr.toString().trim() : '';
+  return stdout || stderr;
+};
+
+export function buildPushRejectionExplanation({ branchName, isContinueMode, prNumber, divergence = null }) {
+  const lines = [];
+
+  if (isContinueMode && !prNumber) {
+    lines.push('     This run reused an existing issue branch because auto-continue found a matching branch with no PR.');
+    lines.push('     It is not a fresh branch created by this run, even though auto-PR creation is running now.');
+  } else {
+    lines.push('     The remote branch changed after the local branch state used for this push.');
+  }
+
+  if (divergence?.remoteExists && divergence.ahead !== null && divergence.behind !== null) {
+    lines.push(`     Current branch state for ${branchName}: ${divergence.ahead} commit(s) ahead, ${divergence.behind} commit(s) behind origin/${branchName}.`);
+  } else if (divergence?.fetchError) {
+    lines.push(`     Could not inspect origin/${branchName}: ${divergence.fetchError}`);
+  }
+
+  return lines;
+}
+
+export async function getRemoteBranchDivergenceSnapshot({ $, tempDir, branchName }) {
+  const fetchResult = await $({ cwd: tempDir, silent: true })`git fetch origin refs/heads/${branchName}:refs/remotes/origin/${branchName} 2>&1`;
+  if (fetchResult.code !== 0) {
+    return {
+      remoteExists: false,
+      ahead: null,
+      behind: null,
+      fetchError: outputOf(fetchResult) || 'remote branch not found',
+    };
+  }
+
+  const aheadResult = await $({ cwd: tempDir, silent: true })`git rev-list --count origin/${branchName}..HEAD 2>&1`;
+  const behindResult = await $({ cwd: tempDir, silent: true })`git rev-list --count HEAD..origin/${branchName} 2>&1`;
+
+  return {
+    remoteExists: aheadResult.code === 0 && behindResult.code === 0,
+    ahead: aheadResult.code === 0 ? toCount(aheadResult.stdout) : null,
+    behind: behindResult.code === 0 ? toCount(behindResult.stdout) : null,
+    fetchError: aheadResult.code === 0 && behindResult.code === 0 ? null : outputOf(aheadResult) || outputOf(behindResult) || 'could not compare local and remote branch',
+  };
+}
+
+export async function synchronizeExistingIssueBranchBeforeAutoPrCreation({ tempDir, branchName, isContinueMode, prNumber, log, formatAligned, $ }) {
+  if (!(isContinueMode && !prNumber)) {
+    return null;
+  }
+
+  await log(formatAligned('🔎', 'Existing branch sync:', branchName));
+  const divergence = await getRemoteBranchDivergenceSnapshot({ $, tempDir, branchName });
+  if (!divergence.remoteExists) {
+    await log(`   ⚠️ Could not inspect origin/${branchName}: ${divergence.fetchError || 'unknown error'}`, { level: 'warning' });
+    return divergence;
+  }
+
+  await log(`   Branch state before PR bootstrap commit: ${divergence.ahead} commit(s) ahead, ${divergence.behind} commit(s) behind origin/${branchName}`);
+
+  if (divergence.behind > 0 && divergence.ahead === 0) {
+    await log(`   Fast-forwarding ${branchName} to origin/${branchName} before creating the PR bootstrap commit...`);
+    const mergeResult = await $({ cwd: tempDir })`git merge --ff-only origin/${branchName} 2>&1`;
+    if (mergeResult.code !== 0) {
+      await log(`   ⚠️ Fast-forward failed: ${outputOf(mergeResult) || 'unknown error'}`, {
+        level: 'warning',
+      });
+      throw new Error('Existing issue branch could not be fast-forwarded before PR creation');
+    }
+    await log(`   ✅ Branch fast-forwarded to origin/${branchName}`);
+    return await getRemoteBranchDivergenceSnapshot({ $, tempDir, branchName });
+  }
+
+  if (divergence.behind > 0 && divergence.ahead > 0) {
+    for (const line of buildPushRejectionExplanation({
+      branchName,
+      isContinueMode,
+      prNumber,
+      divergence,
+    })) {
+      await log(line);
+    }
+    throw new Error('Existing issue branch has diverged before PR creation; manual resolution required');
+  }
+
+  return divergence;
+}

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)',
@@ -507,6 +512,11 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: 'Disable error issue creation entirely (no prompt, no automatic creation). Overrides --auto-report-issue if both are specified.',
     default: false,
   },
+  'disable-issue-auto-creation-on-error': {
+    type: 'boolean',
+    description: 'Disable creating a new GitHub error-report issue when solve fails, including the interactive prompt. This does not disable posting failure logs or comments to the original issue or pull request.',
+    default: false,
+  },
   'attach-solution-summary': {
     type: 'boolean',
     description: 'Attach the AI working session summary (from the result field) as a comment to the PR/issue after every working session. The summary is extracted from the AI tool JSON output and posted under a "Working session summary" header. Applies to the top-level run, auto-restart-until-mergeable iterations, and watch-mode iterations.',
@@ -713,6 +723,12 @@ export const parseArguments = async (yargs = getLinoYargsFactory(), hideBinFn =
     if (argv.toolCheck === false) {
       argv.toolConnectionCheck = false;
     }
+    // Issue #1752: new flag is the explicit user-facing switch for disabling
+    // creation of separate solver-error issues. Keep the existing internal
+    // disableReportIssue path as the single behavior flag.
+    if (argv.disableIssueAutoCreationOnError) {
+      argv.disableReportIssue = true;
+    }
   }
 
   // --finalize normalization

package/src/solve.error-handlers.lib.mjs

@@ -12,11 +12,14 @@ import { reportError } from './sentry.lib.mjs';
 // Import GitHub error reporter
 import { handleErrorWithIssueCreation } from './github-error-reporter.lib.mjs';
 
+export const isErrorIssueAutoCreationDisabled = argv => !!(argv?.disableReportIssue || argv?.disableIssueAutoCreationOnError);
+
 /**
  * Handles log attachment and PR closing on failure
  */
 export const handleFailure = async options => {
   const { error, errorType, shouldAttachLogs, argv, global, owner, repo, log, getLogFile, attachLogToGitHub, cleanErrorMessage, sanitizeLogContent, $ } = options;
+  const disableIssueCreation = isErrorIssueAutoCreationDisabled(argv);
 
   // Offer to create GitHub issue for the error
   try {
@@ -30,9 +33,9 @@ export const handleFailure = async options => {
         prNumber: global.createdPR?.number,
         errorType,
       },
-      skipPrompt: !process.stdin.isTTY || argv.noIssueCreation,
+      skipPrompt: !process.stdin.isTTY || argv.noIssueCreation || disableIssueCreation,
       autoReport: argv.autoReportIssue,
-      disableReport: argv.disableReportIssue,
+      disableReport: disableIssueCreation,
     });
   } catch (issueError) {
     reportError(issueError, {
@@ -49,7 +52,7 @@ export const handleFailure = async options => {
     const hasIssue = global.issueNumber;
     const targetType = hasPR ? 'pr' : hasIssue ? 'issue' : null;
     const targetNumber = hasPR ? global.createdPR.number : hasIssue ? global.issueNumber : null;
-    const targetLabel = hasPR ? 'Pull Request' : 'Issue';
+    const targetLabel = hasPR ? 'Pull Request' : `original issue #${targetNumber}`;
 
     if (targetType && targetNumber) {
       await log(`\n📄 Attempting to attach failure logs to ${targetLabel}...`);
@@ -70,7 +73,7 @@ export const handleFailure = async options => {
           tool: argv.tool || 'claude',
         });
         if (logUploadSuccess) {
-          await log(`📎 Failure log attached to ${targetLabel}`);
+          await log(`📎 Failure log posted to ${targetLabel}`);
           if (!hasPR && hasIssue) global.prePullRequestFailureNotificationPosted = true;
         }
       } catch (attachError) {
@@ -81,7 +84,7 @@ export const handleFailure = async options => {
           errorType,
           operation: `attach_log_to_${targetType}`,
         });
-        await log(`⚠️  Could not attach failure log to ${targetLabel}: ${attachError.message}`, { level: 'warning' });
+        await log(`⚠️  Could not post failure log to ${targetLabel}: ${attachError.message}`, { level: 'warning' });
       }
     }
   }

package/src/solve.mjs

@@ -162,6 +162,12 @@ const { isIssueUrl, isPrUrl, normalizedUrl, owner, repo, number: urlNumber } = u
 issueUrl = normalizedUrl || issueUrl;
 global.owner = owner;
 global.repo = repo;
+// Issue #1752: failures before PR creation can happen during checks that run
+// before the normal issue-mode setup below. Record the source issue as soon as
+// the URL is validated so the pre-exit notifier can still comment on it.
+if (isIssueUrl) {
+  global.issueNumber = urlNumber;
+}
 cleanupContext.owner = owner;
 cleanupContext.repo = repo;
 // Setup unhandled error handlers to ensure log path is always shown
@@ -331,6 +337,7 @@ if (autoContinueResult.isContinueMode) {
   } else {
     // We have a branch but no PR - we'll use the existing branch and create a PR later
     await log(`🔄 Using existing branch: ${prBranch} (no PR yet - will create one)`);
+    await log('   This branch was created by an earlier run; this run is reusing it rather than creating a fresh branch.');
     if (argv.verbose) {
       await log('   Branch will be checked out and PR will be created during auto-PR creation phase', {
         verbose: true,
@@ -1021,7 +1028,7 @@ try {
     const hasIssue = global.issueNumber;
     const logTargetType = hasPR ? 'pr' : hasIssue ? 'issue' : null;
     const logTargetNumber = hasPR ? global.createdPR.number : hasIssue ? global.issueNumber : null;
-    const logTargetLabel = hasPR ? 'Pull Request' : 'Issue';
+    const logTargetLabel = hasPR ? 'Pull Request' : `original issue #${logTargetNumber}`;
 
     if (shouldAttachLogs && logTargetType && logTargetNumber) {
       await log(`\n📄 Attaching failure logs to ${logTargetLabel}...`);
@@ -1054,7 +1061,7 @@ try {
         });
 
         if (logUploadSuccess) {
-          await log(`  📎 Failure logs attached to ${logTargetLabel}`);
+          await log(`  📎 Failure logs posted to ${logTargetLabel}`);
         } else {
           // Issue #1212: Always show log upload failures (not just verbose)
           await log('  ⚠️  Failed to upload failure logs');

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