@link-assistant/hive-mind 1.78.12 → 2.0.0

package/src/github-merge.lib.mjs

@@ -19,6 +19,7 @@ const execRaw = promisify(execCallback);
 import { parseGitHubUrl } from './github.lib.mjs';
 import { githubLimits } from './config.lib.mjs';
 import { ghWithRateLimitRetry } from './github-rate-limit.lib.mjs';
+import { getTerminalGitHubEntityErrorMessage, isTerminalGitHubEntityError } from './github-terminal-state.lib.mjs';
 
 // Issue #1722: gh api `--paginate --slurp` responses for repos with many
 // historical workflow runs can easily exceed Node's default 1 MB exec buffer
@@ -411,6 +412,17 @@ export async function checkPRCIStatus(owner, repo, prNumber, verbose = false) {
       hasPending,
     };
   } catch (error) {
+    if (isTerminalGitHubEntityError(error)) {
+      const terminalError = getTerminalGitHubEntityErrorMessage(error);
+      if (verbose) console.log(`[VERBOSE] /merge: Terminal GitHub entity error while checking CI status for PR #${prNumber}: ${terminalError}`);
+      return {
+        status: 'terminal_github_entity_error',
+        checks: [],
+        allPassed: false,
+        hasPending: false,
+        error: terminalError,
+      };
+    }
     if (verbose) {
       console.log(`[VERBOSE] /merge: Error checking CI status: ${error.message}`);
     }
@@ -434,7 +446,7 @@ export async function checkPRCIStatus(owner, repo, prNumber, verbose = false) {
  * @param {string} repo - Repository name
  * @param {number} prNumber - Pull request number
  * @param {boolean} verbose - Whether to log verbose output
- * @returns {Promise<{mergeable: boolean, reason: string|null}>}
+ * @returns {Promise<{mergeable: boolean, reason: string|null, terminal?: boolean}>}
  */
 export async function checkPRMergeable(owner, repo, prNumber, verbose = false) {
   // Issue #1339: GitHub computes mergeability asynchronously. When mergeStateStatus is
@@ -495,6 +507,12 @@ export async function checkPRMergeable(owner, repo, prNumber, verbose = false) {
 
       return { mergeable, reason };
     } catch (error) {
+      if (isTerminalGitHubEntityError(error)) {
+        const terminalError = getTerminalGitHubEntityErrorMessage(error);
+        if (verbose) console.log(`[VERBOSE] /merge: Terminal GitHub entity error while checking mergeability for PR #${prNumber}: ${terminalError}`);
+        return { mergeable: false, reason: terminalError, terminal: true };
+      }
+
       if (verbose) {
         console.log(`[VERBOSE] /merge: Error checking mergeability: ${error.message}`);
       }
@@ -652,6 +670,14 @@ export async function waitForCI(owner, repo, prNumber, options = {}, verbose = f
       return { success: false, status: 'failure', error: 'CI checks failed' };
     }
 
+    if (ciStatus.status === 'terminal_github_entity_error') {
+      return {
+        success: false,
+        status: 'terminal_github_entity_error',
+        error: ciStatus.error || 'GitHub repository, pull request, issue, or branch is no longer accessible',
+      };
+    }
+
     if (ciStatus.status === 'pending') {
       if (verbose) {
         console.log(`[VERBOSE] /merge: Waiting for CI... (${Math.round((Date.now() - startTime) / 1000)}s elapsed)`);
@@ -1240,6 +1266,28 @@ export async function getDetailedCIStatus(owner, repo, prNumber, verbose = false
       passedChecks,
     };
   } catch (error) {
+    if (isTerminalGitHubEntityError(error)) {
+      const terminalError = getTerminalGitHubEntityErrorMessage(error);
+      if (verbose) console.log(`[VERBOSE] /merge: Terminal GitHub entity error while getting detailed CI status for PR #${prNumber}: ${terminalError}`);
+      return {
+        status: 'terminal_github_entity_error',
+        checks: [],
+        sha: null,
+        hasFailures: false,
+        hasCancelled: false,
+        hasStale: false,
+        hasPending: false,
+        hasQueued: false,
+        allPassed: false,
+        failedChecks: [],
+        cancelledChecks: [],
+        staleChecks: [],
+        pendingChecks: [],
+        queuedChecks: [],
+        passedChecks: [],
+        error: terminalError,
+      };
+    }
     if (verbose) {
       console.log(`[VERBOSE] /merge: Error getting detailed CI status: ${error.message}`);
     }

package/src/github-terminal-state.lib.mjs

@@ -0,0 +1,266 @@
+#!/usr/bin/env node
+import { ensureUseM } from './use-m-bootstrap.lib.mjs';
+
+/**
+ * Detect terminal GitHub entity states for long-running watch/merge loops.
+ *
+ * These checks intentionally treat 404-style repository, PR, issue, and branch
+ * responses as terminal. In a solver loop, deleted entities and lost access are
+ * not transient CI states; retrying them indefinitely wastes time and tokens.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1931
+ */
+
+let defaultCommandRunner = null;
+
+const getDefaultCommandRunner = async () => {
+  if (defaultCommandRunner) return defaultCommandRunner;
+  if (typeof globalThis.use === 'undefined') {
+    await ensureUseM();
+  }
+  const use = globalThis.use;
+  const { $: rawDollar } = await use('command-stream');
+  const { wrapDollarWithGhRetry } = await import('./github-rate-limit.lib.mjs');
+  defaultCommandRunner = wrapDollarWithGhRetry(rawDollar);
+  return defaultCommandRunner;
+};
+
+const textFrom = value => {
+  if (!value) return '';
+  if (typeof value === 'string') return value;
+  if (value instanceof Error) {
+    return [value.message, value.stdout?.toString?.(), value.stderr?.toString?.()].filter(Boolean).join('\n');
+  }
+  return [value.message, value.stdout?.toString?.(), value.stderr?.toString?.(), value.output?.toString?.()].filter(Boolean).join('\n');
+};
+
+export const getGitHubCommandOutput = result => [result?.stdout?.toString?.() || '', result?.stderr?.toString?.() || '', result?.output?.toString?.() || ''].filter(Boolean).join('\n');
+
+export const isTerminalGitHubEntityError = value => {
+  const text = textFrom(value);
+  if (!text) return false;
+
+  return [/\bHTTP\s+404\b/i, /\bHTTP\s+410\b/i, /\b404\s+Not Found\b/i, /\b410\s+Gone\b/i, /\bNot Found\s+\(HTTP 404\)/i, /"status"\s*:\s*"404"/i, /"status"\s*:\s*"410"/i, /\bstatus['"]?\s*:\s*404\b/i, /\bstatus['"]?\s*:\s*410\b/i, /Could not resolve to a Repository/i, /Could not resolve to a PullRequest/i, /Could not resolve to an Issue/i, /Could not resolve to a Branch/i, /Could not resolve to a Repository with the name/i, /GraphQL:.*Could not resolve.*Repository/i, /\brepository not found\b/i, /\bgh:\s*Not Found\b/i].some(pattern => pattern.test(text));
+};
+
+export const getTerminalGitHubEntityErrorMessage = (value, fallback = 'GitHub entity is no longer accessible') => {
+  const text = textFrom(value)
+    .split('\n')
+    .map(line => line.trim())
+    .filter(Boolean)
+    .join(' ');
+  return text || fallback;
+};
+
+const terminal = ({ reason, message, details = [], success = false, data = null }) => ({
+  terminal: true,
+  success,
+  reason,
+  message,
+  details,
+  data,
+});
+
+const ok = (data = {}) => ({
+  terminal: false,
+  success: null,
+  reason: null,
+  message: null,
+  details: [],
+  data,
+});
+
+const safeJsonParse = value => {
+  const text = value?.toString?.().trim() || '';
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+};
+
+const commandFailedTerminally = result => {
+  const code = result?.code ?? 0;
+  return code !== 0 && isTerminalGitHubEntityError(getGitHubCommandOutput(result));
+};
+
+const toTemplateStrings = strings => Object.assign([...strings], { raw: [...strings] });
+
+const runCommand = async (commandRunner, strings, ...values) => {
+  try {
+    return await commandRunner(toTemplateStrings(strings), ...values);
+  } catch (error) {
+    return {
+      code: error.code || 1,
+      stdout: error.stdout || '',
+      stderr: error.stderr || error.message || '',
+      output: textFrom(error),
+    };
+  }
+};
+
+const checkBranch = async ({ commandRunner, repoFullName, branchName, reason, label }) => {
+  if (!repoFullName || !branchName) {
+    return ok();
+  }
+
+  const encodedBranchName = encodeURIComponent(branchName);
+  const branchResult = await runCommand(commandRunner, ['gh api repos/', '/branches/', ''], repoFullName, encodedBranchName);
+
+  if (commandFailedTerminally(branchResult)) {
+    return terminal({
+      reason,
+      message: `${label} branch '${branchName}' is no longer accessible in ${repoFullName}.`,
+      details: [getTerminalGitHubEntityErrorMessage(branchResult)],
+    });
+  }
+
+  return ok();
+};
+
+/**
+ * Check whether the GitHub entities watched by a long-running operation reached
+ * a terminal state.
+ *
+ * @param {Object} options
+ * @param {string} options.owner
+ * @param {string} options.repo
+ * @param {number|string|null} [options.issueNumber]
+ * @param {number|string|null} [options.prNumber]
+ * @param {string|null} [options.sourceBranchName]
+ * @param {string|null} [options.targetBranchName]
+ * @param {Function} [options.commandRunner] command-stream tagged template
+ * @returns {Promise<{terminal: boolean, success: boolean|null, reason: string|null, message: string|null, details: string[], data?: Object}>}
+ */
+export const checkGitHubTerminalState = async ({ owner, repo, issueNumber = null, prNumber = null, sourceBranchName = null, targetBranchName = null, commandRunner = null }) => {
+  const runner = commandRunner || (await getDefaultCommandRunner());
+  const repoResult = await runCommand(runner, ['gh api repos/', '/', " --jq '{full_name: .full_name, default_branch: .default_branch}'"], owner, repo);
+  if (commandFailedTerminally(repoResult)) {
+    return terminal({
+      reason: 'repository_unavailable',
+      message: `Repository ${owner}/${repo} is no longer accessible.`,
+      details: [getTerminalGitHubEntityErrorMessage(repoResult)],
+    });
+  }
+
+  const repoData = safeJsonParse(repoResult.stdout) || {};
+
+  if (prNumber) {
+    const prResult = await runCommand(runner, ['gh api repos/', '/', '/pulls/', ''], owner, repo, prNumber);
+    if (commandFailedTerminally(prResult)) {
+      return terminal({
+        reason: 'pull_request_unavailable',
+        message: `Pull request #${prNumber} in ${owner}/${repo} is no longer accessible.`,
+        details: [getTerminalGitHubEntityErrorMessage(prResult)],
+      });
+    }
+
+    const prData = safeJsonParse(prResult.stdout);
+    if (prData) {
+      const prState = String(prData.state || '').toLowerCase();
+      if (prData.merged === true) {
+        return terminal({
+          reason: 'pull_request_merged',
+          message: `Pull request #${prNumber} has been merged.`,
+          success: true,
+          data: { pr: prData, repo: repoData },
+        });
+      }
+      if (prState === 'closed') {
+        return terminal({
+          reason: 'pull_request_closed',
+          message: `Pull request #${prNumber} has been closed without merging.`,
+          data: { pr: prData, repo: repoData },
+        });
+      }
+
+      const headRepo = prData.head?.repo?.full_name || null;
+      const headRef = prData.head?.ref || sourceBranchName;
+      if (!headRepo && headRef) {
+        return terminal({
+          reason: 'source_branch_unavailable',
+          message: `Source repository for branch '${headRef}' is no longer accessible.`,
+          details: ['GitHub returned no head repository for the open pull request.'],
+          data: { pr: prData, repo: repoData },
+        });
+      }
+
+      const sourceBranchState = await checkBranch({
+        commandRunner: runner,
+        repoFullName: headRepo,
+        branchName: headRef,
+        reason: 'source_branch_unavailable',
+        label: 'Source',
+      });
+      if (sourceBranchState.terminal) return sourceBranchState;
+
+      const baseRepo = prData.base?.repo?.full_name || `${owner}/${repo}`;
+      const baseRef = prData.base?.ref || targetBranchName || repoData.default_branch;
+      if (!baseRepo && baseRef) {
+        return terminal({
+          reason: 'target_branch_unavailable',
+          message: `Target repository for branch '${baseRef}' is no longer accessible.`,
+          details: ['GitHub returned no base repository for the open pull request.'],
+          data: { pr: prData, repo: repoData },
+        });
+      }
+
+      const targetBranchState = await checkBranch({
+        commandRunner: runner,
+        repoFullName: baseRepo,
+        branchName: baseRef,
+        reason: 'target_branch_unavailable',
+        label: 'Target',
+      });
+      if (targetBranchState.terminal) return targetBranchState;
+    }
+  } else {
+    const sourceBranchState = await checkBranch({
+      commandRunner: runner,
+      repoFullName: `${owner}/${repo}`,
+      branchName: sourceBranchName,
+      reason: 'source_branch_unavailable',
+      label: 'Source',
+    });
+    if (sourceBranchState.terminal) return sourceBranchState;
+
+    const targetBranchState = await checkBranch({
+      commandRunner: runner,
+      repoFullName: `${owner}/${repo}`,
+      branchName: targetBranchName,
+      reason: 'target_branch_unavailable',
+      label: 'Target',
+    });
+    if (targetBranchState.terminal) return targetBranchState;
+  }
+
+  if (issueNumber && String(issueNumber) !== String(prNumber)) {
+    const issueResult = await runCommand(runner, ['gh api repos/', '/', '/issues/', ''], owner, repo, issueNumber);
+    if (commandFailedTerminally(issueResult)) {
+      return terminal({
+        reason: 'issue_unavailable',
+        message: `Issue #${issueNumber} in ${owner}/${repo} is no longer accessible.`,
+        details: [getTerminalGitHubEntityErrorMessage(issueResult)],
+      });
+    }
+
+    const issueData = safeJsonParse(issueResult.stdout);
+    if (String(issueData?.state || '').toLowerCase() === 'closed') {
+      return terminal({
+        reason: 'issue_closed',
+        message: `Issue #${issueNumber} has been closed.`,
+        data: { issue: issueData, repo: repoData },
+      });
+    }
+  }
+
+  return ok({ repo: repoData });
+};
+
+export default {
+  checkGitHubTerminalState,
+  getGitHubCommandOutput,
+  getTerminalGitHubEntityErrorMessage,
+  isTerminalGitHubEntityError,
+};

package/src/hive.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // Import Sentry instrumentation first (must be before other imports)
 import './instrument.mjs';
-import { ensureUseM } from './use-m-bootstrap.lib.mjs';
+import { ensureUseM, fetchUseMCodeFromCdn } from './use-m-bootstrap.lib.mjs';
 import { wrapDollarWithGhRetry as _wrapDollarWithGhRetry, execGhWithRetry } from './github-rate-limit.lib.mjs'; // rate-limit marker (#1726): gh API calls flow through $ wrapped by caller. execGhWithRetry adds transient-network retry (#1756).
 const earlyArgs = process.argv.slice(2);
 if (earlyArgs.includes('--version')) {
@@ -46,12 +46,7 @@ if (isRunningDirectly) {
     if (typeof globalThis.use === 'undefined') {
       try {
         await ensureUseM({
-          fetchUseMCode: () =>
-            withTimeout(
-              fetch('https://unpkg.com/use-m/use.js').then(r => r.text()),
-              10000,
-              'fetching use-m library'
-            ),
+          fetchUseMCode: () => withTimeout(fetchUseMCodeFromCdn(), 10000, 'fetching use-m library'),
           log: message => console.log(message),
         });
       } catch (error) {

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

@@ -870,6 +870,13 @@ export const getMergeBlockers = async (owner, repo, prNumber, verbose = false, c
         });
       }
     }
+  } else if (ciStatus.status === 'terminal_github_entity_error') {
+    blockers.push({
+      type: 'terminal_github_entity_error',
+      message: ciStatus.error || 'GitHub repository, pull request, issue, or branch is no longer accessible',
+      details: [],
+    });
+    return { blockers, ciStatus, noCiConfigured: false, noCiTriggered: false, noWorkflowRunsForCommit };
   } else if (ciStatus.status === 'unknown') {
     // Unable to determine CI status - treat as pending to be safe
     // Do NOT treat as mergeable (which would be incorrect)
@@ -882,6 +889,15 @@ export const getMergeBlockers = async (owner, repo, prNumber, verbose = false, c
 
   // Check mergeability
   const mergeStatus = await checkPRMergeable(owner, repo, prNumber, verbose);
+  if (mergeStatus.terminal) {
+    blockers.push({
+      type: 'terminal_github_entity_error',
+      message: mergeStatus.reason || 'GitHub repository, pull request, issue, or branch is no longer accessible',
+      details: [],
+    });
+    return { blockers, ciStatus, noCiConfigured: false, noCiTriggered: false, noWorkflowRunsForCommit };
+  }
+
   if (!mergeStatus.mergeable) {
     blockers.push({
       type: 'not_mergeable',

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

@@ -43,7 +43,12 @@ const { sanitizeLogContent, attachLogToGitHub } = githubLib;
 
 // Import shared utilities from the restart-shared module
 const restartShared = await import('./solve.restart-shared.lib.mjs');
-const { checkPRMerged, checkPRClosed, checkForUncommittedChanges, getUncommittedChangesDetails, executeToolIteration, buildAutoRestartInstructions, isUsageLimitReached } = restartShared;
+const { checkForUncommittedChanges, getUncommittedChangesDetails, executeToolIteration, buildAutoRestartInstructions, isUsageLimitReached } = restartShared;
+
+// Issue #1931: deleted/inaccessible repositories, PRs, issues, and branches
+// are terminal states for long-running watch loops, not retryable CI states.
+const terminalStateLib = await import('./github-terminal-state.lib.mjs');
+const { checkGitHubTerminalState } = terminalStateLib;
 
 // Import validation functions for time parsing (used for usage limit wait)
 const validation = await import('./solve.validation.lib.mjs');
@@ -155,24 +160,30 @@ export const watchUntilMergeable = async params => {
     iteration++;
     const currentTime = new Date();
 
-    // Check if PR is merged
-    const isMerged = await checkPRMerged(owner, repo, prNumber);
-    if (isMerged) {
+    const terminalState = await checkGitHubTerminalState({
+      owner,
+      repo,
+      issueNumber,
+      prNumber,
+      sourceBranchName: prBranch || branchName,
+      commandRunner: $,
+    });
+    if (terminalState.terminal && terminalState.success) {
       await log('');
       await log(formatAligned('🎉', 'PR MERGED!', 'Stopping auto-restart-until-mergeable mode'));
       await log(formatAligned('', 'Pull request:', `#${prNumber} has been merged`, 2));
       await log('');
       return { success: true, reason: 'merged', latestSessionId, latestAnthropicCost };
     }
-
-    // Check if PR is closed (not merged)
-    const isClosed = await checkPRClosed(owner, repo, prNumber);
-    if (isClosed) {
+    if (terminalState.terminal) {
       await log('');
-      await log(formatAligned('🚫', 'PR CLOSED!', 'Stopping auto-restart-until-mergeable mode'));
-      await log(formatAligned('', 'Pull request:', `#${prNumber} has been closed without merging`, 2));
+      await log(formatAligned('❌', 'GITHUB TARGET UNAVAILABLE:', terminalState.message, 2), { level: 'error' });
+      for (const detail of terminalState.details || []) {
+        await log(formatAligned('', 'Detail:', detail, 4), { level: 'error' });
+      }
+      await log(formatAligned('', 'Action:', 'Stopping auto-restart-until-mergeable mode', 2), { level: 'error' });
       await log('');
-      return { success: false, reason: 'closed', latestSessionId, latestAnthropicCost };
+      return { success: false, reason: terminalState.reason, latestSessionId, latestAnthropicCost };
     }
 
     await log(formatAligned('🔍', `Check #${iteration}:`, currentTime.toLocaleTimeString()));
@@ -205,6 +216,18 @@ export const watchUntilMergeable = async params => {
       // Get merge blockers
       const { blockers, noCiConfigured, noCiTriggered, workflowRunConclusions, ciStatus, noWorkflowRunsForCommit } = await getMergeBlockers(owner, repo, prNumber, argv.verbose, consecutiveNoRunsChecks, prBranch);
 
+      const terminalGitHubBlocker = blockers.find(b => b.type === 'terminal_github_entity_error');
+      if (terminalGitHubBlocker) {
+        await log('');
+        await log(formatAligned('❌', 'GITHUB TARGET UNAVAILABLE:', terminalGitHubBlocker.message, 2), { level: 'error' });
+        for (const detail of terminalGitHubBlocker.details || []) {
+          await log(formatAligned('', 'Detail:', detail, 4), { level: 'error' });
+        }
+        await log(formatAligned('', 'Action:', 'Stopping auto-restart-until-mergeable mode', 2), { level: 'error' });
+        await log('');
+        return { success: false, reason: 'terminal_github_entity_error', latestSessionId, latestAnthropicCost };
+      }
+
       // Issue #1503/#1918: Reset counter when CI checks exist (safety valve only for
       // consecutive "no runs"). Issue #1918: do NOT reset while getMergeBlockers is still
       // waiting for PR-triggered workflow runs to register (noWorkflowRunsForCommit). A
@@ -1201,6 +1224,25 @@ export const attemptAutoMerge = async params => {
   await log('');
   await log(formatAligned('🔀', 'AUTO-MERGE:', 'Checking if PR can be merged...'));
 
+  const terminalState = await checkGitHubTerminalState({
+    owner,
+    repo,
+    issueNumber,
+    prNumber,
+    commandRunner: $,
+  });
+  if (terminalState.terminal) {
+    if (terminalState.success) {
+      await log(formatAligned('🎉', 'PR already merged:', `#${prNumber}`, 2));
+      return { success: true, reason: 'merged' };
+    }
+    await log(formatAligned('❌', 'GITHUB TARGET UNAVAILABLE:', terminalState.message, 2), { level: 'error' });
+    for (const detail of terminalState.details || []) {
+      await log(formatAligned('', 'Detail:', detail, 4), { level: 'error' });
+    }
+    return { success: false, reason: terminalState.reason, error: terminalState.message };
+  }
+
   // Issue #1226: Check merge permissions before attempting
   const { canMerge, permission } = await checkMergePermissions(owner, repo, argv.verbose);
   if (!canMerge) {
@@ -1234,6 +1276,11 @@ export const attemptAutoMerge = async params => {
 
   // Check if PR is mergeable
   const mergeStatus = await checkPRMergeable(owner, repo, prNumber, argv.verbose);
+  if (mergeStatus.terminal) {
+    await log(formatAligned('❌', 'GITHUB TARGET UNAVAILABLE:', mergeStatus.reason || 'GitHub repository, pull request, issue, or branch is no longer accessible', 2), { level: 'error' });
+    return { success: false, reason: 'terminal_github_entity_error', error: mergeStatus.reason };
+  }
+
   if (!mergeStatus.mergeable) {
     await log(formatAligned('⚠️', 'PR not mergeable:', mergeStatus.reason || 'Unknown reason', 2));
     return { success: false, reason: 'not_mergeable', error: mergeStatus.reason };

package/src/solve.watch.lib.mjs

@@ -39,6 +39,11 @@ const { detectAndCountFeedback } = feedbackLib;
 const restartShared = await import('./solve.restart-shared.lib.mjs');
 const { checkPRMerged, checkForUncommittedChanges, getUncommittedChangesDetails, executeToolIteration, buildUncommittedChangesFeedback, isApiError } = restartShared;
 
+// Issue #1931: deleted/inaccessible repositories, PRs, issues, and branches
+// are terminal states for watch mode, not retryable feedback checks.
+const terminalStateLib = await import('./github-terminal-state.lib.mjs');
+const { checkGitHubTerminalState } = terminalStateLib;
+
 // Issue #1574: Interruptible sleep so CTRL+C is never blocked by a lingering timer
 const { interruptibleSleep } = await import('./interruptible-sleep.lib.mjs');
 const { formatAutoIterationLimit, hasReachedAutoIterationLimit, normalizeAutoIterationLimit } = await import('./auto-iteration-limits.lib.mjs');
@@ -111,8 +116,27 @@ export const watchForFeedback = async params => {
     iteration++;
     const currentTime = new Date();
 
+    const terminalState = await checkGitHubTerminalState({
+      owner,
+      repo,
+      issueNumber,
+      prNumber,
+      sourceBranchName: prBranch || branchName,
+      commandRunner: $,
+    });
+    if (terminalState.terminal && !terminalState.success) {
+      await log('');
+      await log(formatAligned('❌', 'GITHUB TARGET UNAVAILABLE:', terminalState.message, 2), { level: 'error' });
+      for (const detail of terminalState.details || []) {
+        await log(formatAligned('', 'Detail:', detail, 4), { level: 'error' });
+      }
+      await log(formatAligned('', 'Action:', 'Stopping watch mode', 2), { level: 'error' });
+      await log('');
+      break;
+    }
+
     // Check if PR is merged
-    const isMerged = await checkPRMerged(owner, repo, prNumber);
+    const isMerged = terminalState.terminal && terminalState.success ? true : await checkPRMerged(owner, repo, prNumber);
     if (isMerged) {
       await log('');
       await log(formatAligned('🎉', 'PR MERGED!', 'Stopping watch mode'));

package/src/telegram-bot.mjs

@@ -12,8 +12,6 @@ if (typeof use === 'undefined') {
 }
 
 const { lino } = await import('./lino.lib.mjs');
-const { buildUserMention } = await import('./buildUserMention.lib.mjs');
-const { reportError, initializeSentry, addBreadcrumb } = await import('./sentry.lib.mjs');
 const { loadLenvConfig } = await import('./lenv-reader.lib.mjs');
 const { getLinoYargsFactory, getenv, hideBin } = await import('./cli-arguments.lib.mjs');
 
@@ -27,26 +25,8 @@ await loadLenvConfig({ override: true, quiet: true });
 const yargs = getLinoYargsFactory();
 const { createYargsConfig: createSolveYargsConfig, detectMalformedFlags } = await import('./solve.config.lib.mjs');
 const { createYargsConfig: createHiveYargsConfig } = await import('./hive.config.lib.mjs');
-const { parseGitHubUrl, validateGitHubEntityExistence } = await import('./github.lib.mjs');
-const { validateModelName, buildModelOptionDescription } = await import('./models/index.mjs');
 const { validateBranchInArgs } = await import('./solve.branch.lib.mjs');
-const { extractIsolationFromArgs, isValidPerCommandIsolation, resolveIsolation, createIsolationAwareQueueCallback } = await import('./telegram-isolation.lib.mjs');
-const limitsLib = await import('./limits.lib.mjs');
-const { formatUsageMessage, formatCodexLimitsSection, getAllCachedLimits } = limitsLib;
-const { handleShowLimitsFlag, captureStartSnapshotAndAppend } = await import('./telegram-show-limits.lib.mjs'); // #594
-const { getVersionInfo, formatVersionMessage } = await import('./version-info.lib.mjs');
-const { escapeMarkdown, escapeMarkdownV2, cleanNonPrintableChars, makeSpecialCharsVisible } = await import('./telegram-markdown.lib.mjs');
-const { getSolveQueue, createQueueExecuteCallback } = await import('./telegram-solve-queue.lib.mjs');
-const { applySolveToolAlias, getFirstParsedPositionalArg, getSolveCommandNameFromText, getSolveToolAliasFromText, moveArgumentToFront, parseArgsWithYargs, parseCommandArgs, SOLVE_COMMAND_NAMES } = await import('./telegram-solve-command.lib.mjs');
-const { executeStartScreen: executeStartScreenCommand, buildExecuteAndUpdateMessage } = await import('./telegram-command-execution.lib.mjs');
-const { isChatStopped, getChatStopInfo, getStoppedChatRejectMessage, DEFAULT_STOP_REASON } = await import('./telegram-start-stop-command.lib.mjs');
-const { isOldMessage: _isOldMessage, isGroupChat: _isGroupChat, isChatAuthorized: _isChatAuthorized, isForwarded: _isForwarded, isForwardedOrReply: _isForwardedOrReply, extractCommandFromText, extractGitHubUrl: _extractGitHubUrl } = await import('./telegram-message-filters.lib.mjs');
-const { installTelegramFormattingFallback, isTelegramFormattingError, isTelegramMessageTooLongError, safeEditMessageText, safeReply, TELEGRAM_TEXT_LIMIT } = await import('./telegram-safe-reply.lib.mjs');
-const { registerTerminalWatchCommand, startAutoTerminalWatchForSession } = await import('./telegram-terminal-watch-command.lib.mjs');
-const { launchBotWithRetry } = await import('./telegram-bot-launcher.lib.mjs');
-const { trackSession, startSessionMonitoring, hasActiveSessionForUrlAsync, findStoppableSessionByUrl } = await import('./session-monitor.lib.mjs');
-const { formatExecutingWorkSessionMessage, formatStartingWorkSessionMessage } = await import('./work-session-formatting.lib.mjs');
-const { buildTelegramHelpMessage, buildTelegramInfoBlock, buildSolveQueuedMessage } = await import('./telegram-ui-messages.lib.mjs');
+const { extractIsolationFromArgs, isValidPerCommandIsolation } = await import('./telegram-isolation.lib.mjs');
 
 const config = yargs(hideBin(process.argv))
   .usage('Usage: hive-telegram-bot [options]')
@@ -179,11 +159,16 @@ if (ISOLATION_BACKEND) {
     process.exit(1);
   }
   console.log(`🔒 Isolation mode enabled: ${ISOLATION_BACKEND} (experimental)`);
-  isolationRunner = await import('./isolation-runner.lib.mjs');
+  // Dry-run mode validates configuration and exits before any command can be
+  // executed, so avoid loading start-command/command-stream and their optional
+  // native dependencies on parser-only runs.
+  if (!config.dryRun) {
+    isolationRunner = await import('./isolation-runner.lib.mjs');
+  }
   // For docker isolation, run a startup preflight so a missing/un-passed-through
   // image surfaces as a loud, actionable warning instead of a surprise multi-GB
   // pull on the first isolated task (issues #1914, #1879). Never throws.
-  if (ISOLATION_BACKEND === 'docker' && typeof isolationRunner.preflightDockerIsolation === 'function') {
+  if (!config.dryRun && ISOLATION_BACKEND === 'docker' && typeof isolationRunner.preflightDockerIsolation === 'function') {
     try {
       await isolationRunner.preflightDockerIsolation({ verbose: VERBOSE });
     } catch (preflightError) {
@@ -314,6 +299,28 @@ if (config.dryRun) {
 // === HEAVY DEPENDENCIES LOADED BELOW (skipped in dry-run mode) ===
 // These imports are after dry-run check to speed up config validation. Telegraf can take 3-8s to load on cold start (issue #801).
 
+const { buildUserMention } = await import('./buildUserMention.lib.mjs');
+const { reportError, initializeSentry, addBreadcrumb } = await import('./sentry.lib.mjs');
+const { parseGitHubUrl, validateGitHubEntityExistence } = await import('./github.lib.mjs');
+const { validateModelName, buildModelOptionDescription } = await import('./models/index.mjs');
+const { resolveIsolation, createIsolationAwareQueueCallback } = await import('./telegram-isolation.lib.mjs');
+const limitsLib = await import('./limits.lib.mjs');
+const { formatUsageMessage, formatCodexLimitsSection, getAllCachedLimits } = limitsLib;
+const { handleShowLimitsFlag, captureStartSnapshotAndAppend } = await import('./telegram-show-limits.lib.mjs'); // #594
+const { getVersionInfo, formatVersionMessage } = await import('./version-info.lib.mjs');
+const { escapeMarkdown, escapeMarkdownV2, cleanNonPrintableChars, makeSpecialCharsVisible } = await import('./telegram-markdown.lib.mjs');
+const { getSolveQueue, createQueueExecuteCallback } = await import('./telegram-solve-queue.lib.mjs');
+const { applySolveToolAlias, getFirstParsedPositionalArg, getSolveCommandNameFromText, getSolveToolAliasFromText, moveArgumentToFront, parseArgsWithYargs, parseCommandArgs, SOLVE_COMMAND_NAMES } = await import('./telegram-solve-command.lib.mjs');
+const { executeStartScreen: executeStartScreenCommand, buildExecuteAndUpdateMessage } = await import('./telegram-command-execution.lib.mjs');
+const { isChatStopped, getChatStopInfo, getStoppedChatRejectMessage, DEFAULT_STOP_REASON } = await import('./telegram-start-stop-command.lib.mjs');
+const { isOldMessage: _isOldMessage, isGroupChat: _isGroupChat, isChatAuthorized: _isChatAuthorized, isForwarded: _isForwarded, isForwardedOrReply: _isForwardedOrReply, extractCommandFromText, extractGitHubUrl: _extractGitHubUrl } = await import('./telegram-message-filters.lib.mjs');
+const { installTelegramFormattingFallback, isTelegramFormattingError, isTelegramMessageTooLongError, safeEditMessageText, safeReply, TELEGRAM_TEXT_LIMIT } = await import('./telegram-safe-reply.lib.mjs');
+const { registerTerminalWatchCommand, startAutoTerminalWatchForSession } = await import('./telegram-terminal-watch-command.lib.mjs');
+const { launchBotWithRetry } = await import('./telegram-bot-launcher.lib.mjs');
+const { trackSession, startSessionMonitoring, hasActiveSessionForUrlAsync, findStoppableSessionByUrl } = await import('./session-monitor.lib.mjs');
+const { formatExecutingWorkSessionMessage, formatStartingWorkSessionMessage } = await import('./work-session-formatting.lib.mjs');
+const { buildTelegramHelpMessage, buildTelegramInfoBlock, buildSolveQueuedMessage } = await import('./telegram-ui-messages.lib.mjs');
+
 // Initialize Sentry for error tracking
 await initializeSentry({
   debug: VERBOSE,