@link-assistant/hive-mind 1.78.11 → 1.78.13

package/CHANGELOG.md

@@ -1,5 +1,65 @@
 # @link-assistant/hive-mind
 
+## 1.78.13
+
+### Patch Changes
+
+- a8035e9: Fail fast when watched GitHub repositories, issues, pull requests, or branches are deleted, closed, or no longer accessible instead of retrying them as unknown CI states.
+
+  Also fall back to a pinned working `use-m` bootstrap when the upstream latest unpkg entry is missing, so local and CI test startup remains stable.
+
+## 1.78.12
+
+### Patch Changes
+
+- 5f60c04: fix(isolation): default nested Docker daemon to fuse-overlayfs so multi-GB images fit on disk + add storage-driver/disk preflight diagnostics (#1914)
+
+  `--isolation docker` was reopened after PR #1915: native Docker isolation and
+  host-image passthrough now work, but the first isolated task on the >30 GB
+  `konard/hive-mind-dind` image still died with:
+
+  ```
+  failed to register layer: no space left on device
+  ```
+
+  even though most layers reported `Already exists` (the daemon was correctly
+  seeded — passthrough is working). The failure was during layer **registration**,
+  not download.
+
+  **Root cause (in this repo).** `Dockerfile.dind` baked `ENV
+DIND_STORAGE_DRIVER="vfs"` (commit 44d2c29e). `vfs` performs **no copy-on-write**:
+  it materializes a full, independent copy of the entire filesystem for _every_
+  layer, so a multi-GB image's on-disk footprint becomes the _sum_ of all
+  cumulative layer sizes — many times the image size — and overflows the disk.
+  Worse, pinning the env var **defeated box-dind's storage-driver auto-detection**
+  (`overlay2 → fuse-overlayfs → vfs`, with graceful fallback): box would otherwise
+  have picked a copy-on-write driver here. `/dev/fuse` is present (the dind
+  container runs `--privileged`), the `fuse-overlayfs` binary ships in box-dind,
+  and `overlay` is in `/proc/filesystems` — so copy-on-write was available the
+  whole time but was being bypassed by the `vfs` pin.
+
+  **Fix.** `Dockerfile.dind` now pins `ENV DIND_STORAGE_DRIVER="fuse-overlayfs"` — a
+  copy-on-write driver that also works overlay-on-overlay (the compatibility reason
+  `vfs` was originally chosen; `overlay2` can fail on the overlay-backed hosts our
+  deploys run on). Under `fuse-overlayfs`, registering a 498 MB top layer on a
+  ~30 GB base costs ~498 MB instead of ~30 GB, so the image fits. Empirically
+  verified in the box-dind environment (`docs/case-studies/issue-1914/data/fuse-overlayfs-capability-proof.log`).
+
+  **Self-diagnosing preflight.** `src/isolation-runner.lib.mjs` gained two probes —
+  `checkDockerStorageDriver()` and `checkDockerDiskSpace()` — wired into
+  `preflightDockerIsolation()`. Before running an isolated task it now warns, with
+  an actionable remedy, when the nested daemon is on `vfs` (even if the image is
+  already present) or when free space at the Docker data root is below 40 GiB, so
+  the next operator hitting this gets a clear breadcrumb instead of a cryptic
+  `no space left on device`. Both probes are best-effort and never throw.
+
+  Added `tests/test-issue-1914-storage-driver-diagnostics.mjs` (34 assertions),
+  extended `tests/test-issue-1914-preflight-passthrough.mjs` and
+  `tests/test-docker-dind-variant.mjs`, refreshed `docs/DOCKER*.md`, and expanded
+  the `docs/case-studies/issue-1914` case study with the reopen timeline, refined
+  root-cause analysis, captured evidence, and an upstream observability request
+  (link-foundation/box#104: warn when the nested daemon lands on `vfs`).
+
 ## 1.78.11
 
 ### Patch Changes

package/package.json

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

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/isolation-runner.lib.mjs

@@ -47,6 +47,12 @@ const DEFAULT_HOST_DOCKER_SOCK = '/var/run/host-docker.sock';
 // throwaway container — booting the dind image's dockerd entrypoint — purely to
 // check whether bash exists. See issue #1914.
 const DOCKER_ISOLATION_SHELL = 'sh';
+// Free-space floor (GiB) below which the preflight warns that an impending
+// isolation-image pull may fail with `no space left on device`. The Hive Mind
+// isolation images are well over 30 GB extracted, so a host/nested daemon with
+// less headroom than this cannot safely pull one. Diagnostic only — never
+// blocks startup. See issue #1914.
+const DOCKER_ISOLATION_LOW_DISK_GIB = 40;
 
 function normalizeProcessIds(value) {
   if (!value || typeof value !== 'object') return {};
@@ -87,12 +93,13 @@ function maybeAddMount(mounts, source, target, existsSync) {
 /**
  * Resolve the tag used for the Docker isolation image.
  *
- * Defaults to `latest`, but operators can pin it (e.g. to the exact version
- * already present on the host) via `HIVE_MIND_DOCKER_ISOLATION_IMAGE_TAG`.
- * Pinning matters for Docker-in-Docker deployments: the nested daemon starts
- * with an empty image store, so an unpinned `:latest` whose registry digest has
- * drifted from the host copy forces a fresh multi-gigabyte pull on every task.
- * A pinned tag lets a pre-seeded image be reused instead. See issue #1879.
+ * Release Docker images bake this env var from `HIVE_MIND_VERSION`, so a parent
+ * container started via `:latest` still launches child isolation containers from
+ * the same immutable release tag. Local/PR builds fall back to `latest`, and
+ * operators can override the tag explicitly when using custom images. Pinning
+ * matters for Docker-in-Docker deployments: the nested daemon starts with an
+ * empty image store, so a `:latest` digest drift from the host copy forces a
+ * fresh multi-gigabyte pull. See issue #1879.
  */
 export function resolveDockerIsolationImageTag({ env = process.env } = {}) {
   const explicit = String(env.HIVE_MIND_DOCKER_ISOLATION_IMAGE_TAG || '').trim();
@@ -618,6 +625,80 @@ export async function checkDockerImagePresent(image, verbose = false) {
   }
 }
 
+/**
+ * Report the storage driver the (nested) Docker daemon is using.
+ *
+ * `vfs` performs NO copy-on-write — it stores a full copy of every image layer
+ * — so the multi-gigabyte Hive Mind images consume many times their real size
+ * on disk and the first isolated `docker run`/pull dies with
+ * `failed to register layer: no space left on device` (issue #1914 reopen).
+ * The preflight uses this to warn loudly when the daemon is on `vfs` instead of
+ * letting the disk silently overflow mid-task.
+ *
+ * Never throws: returns the lowercased driver name, or `null` when docker is
+ * unavailable / the daemon is unreachable.
+ *
+ * @param {boolean} [verbose] - Enable verbose logging
+ * @returns {Promise<string|null>} e.g. 'fuse-overlayfs', 'overlay2', 'vfs', or null
+ */
+export async function checkDockerStorageDriver(verbose = false) {
+  try {
+    const result = await $({ mirror: false })`docker info --format ${'{{.Driver}}'}`;
+    const driver = (result.stdout?.toString() || '').trim().toLowerCase() || null;
+    if (verbose) console.log(`[VERBOSE] isolation-runner: docker storage driver: ${driver || '(unknown)'}`);
+    return driver;
+  } catch {
+    if (verbose) console.log('[VERBOSE] isolation-runner: docker info unavailable; storage driver unknown');
+    return null;
+  }
+}
+
+/**
+ * Report the free space (in GiB) on the Docker daemon's data root.
+ *
+ * The Hive Mind isolation images are multiple gigabytes; when the nested daemon
+ * has to pull one, it needs room for the extracted layers. This lets the
+ * preflight predict a `no space left on device` failure (issue #1914) instead
+ * of discovering it mid-pull. Resolves the daemon's real data root via
+ * `docker info` and falls back to `/var/lib/docker`, then reads `df -Pk`.
+ *
+ * Never throws: returns `{ availableGiB, dataRoot }`, or `null` when the
+ * information cannot be determined (no docker, no df, unparseable output).
+ *
+ * @param {boolean} [verbose] - Enable verbose logging
+ * @returns {Promise<{availableGiB: number, dataRoot: string}|null>}
+ */
+export async function checkDockerDiskSpace(verbose = false) {
+  try {
+    let dataRoot = '/var/lib/docker';
+    try {
+      const info = await $({ mirror: false })`docker info --format ${'{{.DockerRootDir}}'}`;
+      const root = (info.stdout?.toString() || '').trim();
+      if (root) dataRoot = root;
+    } catch {
+      // Daemon unreachable: fall back to the conventional data root. If df then
+      // fails on it (e.g. the path does not exist) we return null below.
+    }
+
+    const df = await $({ mirror: false })`df -Pk ${dataRoot}`;
+    // `df -P` guarantees one logical line per filesystem (no wrapping). The last
+    // line is the data row: Filesystem 1024-blocks Used Available Capacity Mount
+    const lines = (df.stdout?.toString() || '').trim().split('\n');
+    const cols = (lines[lines.length - 1] || '').trim().split(/\s+/);
+    const availableKb = Number(cols[3]);
+    if (!Number.isFinite(availableKb)) {
+      if (verbose) console.log('[VERBOSE] isolation-runner: could not parse df output for Docker disk space');
+      return null;
+    }
+    const availableGiB = availableKb / (1024 * 1024);
+    if (verbose) console.log(`[VERBOSE] isolation-runner: Docker data root '${dataRoot}' has ${availableGiB.toFixed(1)} GiB free`);
+    return { availableGiB, dataRoot };
+  } catch {
+    if (verbose) console.log('[VERBOSE] isolation-runner: df unavailable; Docker disk space unknown');
+    return null;
+  }
+}
+
 /**
  * Startup preflight for `--isolation docker`.
  *
@@ -637,42 +718,78 @@ export async function checkDockerImagePresent(image, verbose = false) {
  * blocks startup — a misconfigured passthrough should degrade to a slow first
  * task, not a dead bot.
  *
+ * It also surfaces the two root causes of the issue #1914 reopen
+ * (`failed to register layer: no space left on device`): a non-copy-on-write
+ * storage driver (`vfs`, which copies every layer in full) and a Docker data
+ * root with too little free space to hold the >30 GB image. Both are reported
+ * as loud, actionable warnings so the disk overflow is self-diagnosing at
+ * startup instead of surfacing mid-task.
+ *
  * @param {Object} [options]
  * @param {Object} [options.env] - Environment (defaults to process.env)
  * @param {Function} [options.existsSync] - fs.existsSync (injectable for tests)
  * @param {boolean} [options.verbose] - Enable verbose logging
  * @param {Object} [options.logger] - Logger with .log/.warn (defaults to console)
  * @param {Function} [options.checkImagePresent] - Image-presence probe (injectable for tests)
- * @returns {Promise<{image: string, sock: string, socketMounted: boolean, imagePresent: boolean, isDind: boolean, ok: boolean, warnings: string[]}>}
+ * @param {Function} [options.checkStorageDriver] - Storage-driver probe (injectable for tests)
+ * @param {Function} [options.checkDiskSpace] - Disk-space probe (injectable for tests)
+ * @returns {Promise<{image: string, sock: string, socketMounted: boolean, imagePresent: boolean, isDind: boolean, storageDriver: (string|null), storageDriverOk: boolean, diskAvailableGiB: (number|null), ok: boolean, warnings: string[]}>}
  */
 export async function preflightDockerIsolation(options = {}) {
-  const { env = process.env, existsSync = fs.existsSync, verbose = false, logger = console, checkImagePresent = checkDockerImagePresent } = options;
+  const { env = process.env, existsSync = fs.existsSync, verbose = false, logger = console, checkImagePresent = checkDockerImagePresent, checkStorageDriver = checkDockerStorageDriver, checkDiskSpace = checkDockerDiskSpace } = options;
 
   const image = getDockerIsolationImage({ env });
   const sock = resolveHostDockerSock({ env });
   const isDind = shouldRunPrivilegedDockerIsolation(image, env);
   const socketMounted = Boolean(existsSync(sock));
   const imagePresent = Boolean(await checkImagePresent(image, verbose));
-
-  const result = { image, sock, socketMounted, imagePresent, isDind, ok: imagePresent, warnings: [] };
+  const storageDriver = await checkStorageDriver(verbose);
+  const disk = await checkDiskSpace(verbose);
+  const diskAvailableGiB = disk && Number.isFinite(disk.availableGiB) ? disk.availableGiB : null;
+  // Unknown driver (probe returned null) is treated as ok — we only flag the
+  // one driver known to overflow the disk, never block on missing information.
+  const storageDriverOk = storageDriver !== 'vfs';
+
+  const result = { image, sock, socketMounted, imagePresent, isDind, storageDriver, storageDriverOk, diskAvailableGiB, ok: imagePresent, warnings: [] };
   const info = typeof logger.log === 'function' ? logger.log.bind(logger) : () => {};
   const warn = typeof logger.warn === 'function' ? logger.warn.bind(logger) : info;
 
-  if (imagePresent) {
-    info(`✅ Docker isolation image '${image}' is already present locally — isolated tasks reuse it (no multi-GB pull). See issue #1914.`);
-    return result;
+  const preload = `node scripts/preload-dind-isolation-image.mjs --image ${image}`;
+
+  // Root Cause A of the issue #1914 reopen: a non-copy-on-write storage driver.
+  // `vfs` stores a full copy of every image layer, so the multi-GB images
+  // consume many times their size on disk and any layer write (pull, run,
+  // commit) can fail with `failed to register layer: no space left on device`.
+  // This is dangerous even when the image is already present — a task that
+  // commits or pulls more layers still overflows — so we warn independent of
+  // image presence.
+  if (storageDriver === 'vfs') {
+    result.warnings.push(`The Docker daemon backing '--isolation docker' is using the 'vfs' storage driver, which performs NO copy-on-write: ` + `it stores a full copy of every image layer, so the multi-GB Hive Mind images consume many times their size on disk and isolated tasks can fail with 'failed to register layer: no space left on device' (issue #1914). ` + `Switch to a copy-on-write driver: rebuild/redeploy with the current Dockerfile.dind (it defaults to 'fuse-overlayfs'), or for an already-running container add '-e DIND_STORAGE_DRIVER=fuse-overlayfs' to the bot container's 'docker run' and recreate it.`);
   }
 
-  // Image absent: the first isolated task will pull the full image. Explain the
-  // most likely cause and the exact fix instead of letting the operator first
-  // discover it as a surprise multi-gigabyte download mid-task.
-  const preload = `node scripts/preload-dind-isolation-image.mjs --image ${image}`;
-  if (isDind && !socketMounted) {
-    result.warnings.push(`Docker isolation image '${image}' is NOT in the nested Docker daemon and the host Docker socket is not mounted at ${sock}. ` + `box host-image passthrough cannot seed the nested daemon, so the FIRST isolated task will pull the full image (the Hive Mind images are multiple GB). ` + `Fix the deployment: add '-v /var/run/docker.sock:${sock}:ro' and '-e DIND_HOST_PASSTHROUGH_IMAGES="konard/hive-mind konard/hive-mind-dind"' to the bot container's 'docker run', or seed it now with: ${preload}`);
-  } else if (isDind && socketMounted) {
-    result.warnings.push(`Docker isolation image '${image}' is NOT in the nested Docker daemon even though the host Docker socket is mounted at ${sock}. ` + `box host-image passthrough may have skipped it (check DIND_HOST_PASSTHROUGH mode, the DIND_HOST_PASSTHROUGH_IMAGES allowlist, and that the host actually has '${image}' with a registry digest). ` + `The first isolated task will pull the full image. Seed it now with: ${preload}`);
-  } else {
-    result.warnings.push(`Docker isolation image '${image}' is not present locally; the first isolated task will pull it. ` + `If this host already has it under a different tag, pin HIVE_MIND_DOCKER_ISOLATION_IMAGE_TAG, or seed it with: ${preload}`);
+  if (!imagePresent) {
+    // Image absent: the first isolated task will pull the full image. Explain
+    // the most likely cause and the exact fix instead of letting the operator
+    // first discover it as a surprise multi-gigabyte download mid-task.
+    if (isDind && !socketMounted) {
+      result.warnings.push(`Docker isolation image '${image}' is NOT in the nested Docker daemon and the host Docker socket is not mounted at ${sock}. ` + `box host-image passthrough cannot seed the nested daemon, so the FIRST isolated task will pull the full image (the Hive Mind images are multiple GB). ` + `Fix the deployment: add '-v /var/run/docker.sock:${sock}:ro' and '-e DIND_HOST_PASSTHROUGH_IMAGES="konard/hive-mind konard/hive-mind-dind"' to the bot container's 'docker run', or seed it now with: ${preload}`);
+    } else if (isDind && socketMounted) {
+      result.warnings.push(`Docker isolation image '${image}' is NOT in the nested Docker daemon even though the host Docker socket is mounted at ${sock}. ` + `box host-image passthrough may have skipped it (check DIND_HOST_PASSTHROUGH mode, the DIND_HOST_PASSTHROUGH_IMAGES allowlist, and that the host actually has '${image}' with a registry digest). ` + `The first isolated task will pull the full image. Seed it now with: ${preload}`);
+    } else {
+      result.warnings.push(`Docker isolation image '${image}' is not present locally; the first isolated task will pull it. ` + `If this host already has it under a different tag, pin HIVE_MIND_DOCKER_ISOLATION_IMAGE_TAG, or seed it with: ${preload}`);
+    }
+
+    // Root Cause B of the issue #1914 reopen: too little disk for the pull. The
+    // image is well over 30 GB extracted; predict the `no space left on device`
+    // failure here rather than hitting it mid-pull.
+    if (diskAvailableGiB != null && diskAvailableGiB < DOCKER_ISOLATION_LOW_DISK_GIB) {
+      const root = disk?.dataRoot || 'the Docker data root';
+      result.warnings.push(`Only ~${diskAvailableGiB.toFixed(0)} GiB free on ${root} and the isolation image '${image}' is not present yet. ` + `The Hive Mind isolation image is well over 30 GB extracted, so the first isolated task's pull may fail with 'no space left on device' (issue #1914). ` + `Seed it via host passthrough (mount the host docker socket) or with '${preload}', and free space on the Docker data root.`);
+    }
+  }
+
+  if (imagePresent) {
+    info(`✅ Docker isolation image '${image}' is already present locally — isolated tasks reuse it (no multi-GB pull). See issue #1914.`);
   }
   for (const w of result.warnings) warn(`⚠️ ${w}`);
   return result;

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,

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

@@ -432,6 +432,14 @@ export class MergeQueueProcessor {
       item.status = MergeItemStatus.CHECKING_CI;
       const mergeableCheck = await checkPRMergeable(this.owner, this.repo, item.pr.number, this.verbose);
 
+      if (mergeableCheck.terminal) {
+        item.status = MergeItemStatus.FAILED;
+        item.error = mergeableCheck.reason || 'GitHub repository, pull request, issue, or branch is no longer accessible';
+        this.stats.failed++;
+        this.log(`Failed PR #${item.pr.number}: ${item.error}`);
+        return;
+      }
+
       if (!mergeableCheck.mergeable) {
         item.status = MergeItemStatus.SKIPPED;
         item.error = mergeableCheck.reason;
@@ -452,6 +460,14 @@ export class MergeQueueProcessor {
         return;
       }
 
+      if (ciStatus.status === 'terminal_github_entity_error') {
+        item.status = MergeItemStatus.FAILED;
+        item.error = ciStatus.error || 'GitHub repository, pull request, issue, or branch is no longer accessible';
+        this.stats.failed++;
+        this.log(`Failed PR #${item.pr.number}: ${item.error}`);
+        return;
+      }
+
       // Step 3: Wait for CI if pending
       if (ciStatus.status === 'pending') {
         item.status = MergeItemStatus.WAITING_CI;

package/src/use-m-bootstrap.lib.mjs

@@ -1,6 +1,19 @@
 #!/usr/bin/env node
 
-const defaultFetchUseMCode = async () => (await fetch('https://unpkg.com/use-m/use.js')).text();
+export const USE_M_BOOTSTRAP_URL = 'https://unpkg.com/use-m/use.js';
+export const USE_M_FALLBACK_BOOTSTRAP_URL = 'https://unpkg.com/use-m@8.13.8/use.js';
+
+const fetchUseMCodeFromUrl = async url => {
+  const response = await fetch(url);
+  const code = await response.text();
+  if (!response.ok || /^Not found:/i.test(code.trim())) {
+    throw new Error(`failed to load use-m bootstrap from ${url}: ${response.status} ${response.statusText}`);
+  }
+  return code;
+};
+
+const defaultFetchUseMCode = async () => fetchUseMCodeFromUrl(USE_M_BOOTSTRAP_URL);
+const fallbackFetchUseMCode = async () => fetchUseMCodeFromUrl(USE_M_FALLBACK_BOOTSTRAP_URL);
 
 /**
  * Load the shared use-m bootstrap.
@@ -10,9 +23,14 @@ const defaultFetchUseMCode = async () => (await fetch('https://unpkg.com/use-m/u
  * @returns {Promise<Function>} The global use-m `use` function.
  */
 export const ensureUseM = async (options = {}) => {
-  const { fetchUseMCode = defaultFetchUseMCode } = options;
+  const { fetchUseMCode = defaultFetchUseMCode, log = null } = options;
   if (typeof globalThis.use === 'undefined') {
-    globalThis.use = (await eval(await fetchUseMCode())).use;
+    try {
+      globalThis.use = (await eval(await fetchUseMCode())).use;
+    } catch (error) {
+      if (typeof log === 'function') log(`   use-m latest bootstrap failed (${error.message}); trying ${USE_M_FALLBACK_BOOTSTRAP_URL}`);
+      globalThis.use = (await eval(await fallbackFetchUseMCode())).use;
+    }
   }
   return globalThis.use;
 };