@link-assistant/hive-mind 2.13.4 → 2.13.5

package/src/hive.mjs

@@ -103,125 +103,10 @@ if (isRunningDirectly) {
     const commandName = process.argv[1] ? process.argv[1].split('/').pop() : '';
     const isLocalScript = commandName.endsWith('.mjs');
     const solveCommand = isLocalScript ? './solve.mjs' : 'solve';
-    /**
-     * Fallback function to fetch issues from organization/user repositories
-     * when search API hits rate limits
-     * @param {string} owner - Organization or user name
-     * @param {string} scope - 'organization' or 'user'
-     * @param {string} monitorTag - Label to filter by (optional)
-     * @param {boolean} allIssues - Whether to fetch all issues or only labeled ones
-     * @returns {Promise<Array>} Array of issues
-     */
-    async function fetchIssuesFromRepositories(owner, scope, monitorTag, fetchAllIssues = false) {
-      try {
-        await log(`   🔄 Using repository-by-repository fallback for ${scope}: ${owner}`);
-        // Strategy 1: Try GraphQL approach first (faster but has limitations)
-        // Only try GraphQL for "all issues" mode, not for labeled issues
-        if (fetchAllIssues) {
-          const graphqlResult = await tryFetchIssuesWithGraphQL(owner, scope, log, cleanErrorMessage);
-          if (graphqlResult.success) {
-            await log(`   ✅ GraphQL approach successful: ${graphqlResult.issues.length} issues from ${graphqlResult.repoCount} repositories`);
-            return graphqlResult.issues;
-          }
-        }
-        // Strategy 2: Fallback to gh api --paginate approach (comprehensive but slower)
-        await log('   📋 Using gh api --paginate approach for comprehensive coverage...', { verbose: true });
-
-        // Get list of ALL repositories using gh api with --paginate (includes isArchived for filtering)
-        let repoListCmd;
-        if (scope === 'organization') {
-          repoListCmd = `gh api orgs/${owner}/repos --paginate --jq '.[] | {name: .name, owner: .owner.login, isArchived: .archived}'`;
-        } else {
-          repoListCmd = `gh api users/${owner}/repos --paginate --jq '.[] | {name: .name, owner: .owner.login, isArchived: .archived}'`;
-        }
-        await log('   📋 Fetching repository list (using --paginate for unlimited pagination)...', { verbose: true });
-        await log(`   🔎 Command: ${repoListCmd}`, { verbose: true });
-        // Add delay for rate limiting
-        await new Promise(resolve => setTimeout(resolve, 2000));
-        // #1756: route through execGhWithRetry for transient 5xx + rate-limit
-        const { stdout: repoOutput } = await execGhWithRetry(repoListCmd, {
-          execOptions: { encoding: 'utf8', env: process.env },
-          label: `gh api ${scope} repos (paginated)`,
-        });
-        // Parse the output line by line, as gh api with --jq outputs one JSON object per line
-        const repoLines = repoOutput
-          .trim()
-          .split('\n')
-          .filter(line => line.trim());
-        const allRepositories = repoLines.map(line => JSON.parse(line));
-        await log(`   📊 Found ${allRepositories.length} repositories`);
-        // Filter repositories to only include those owned by the target user/org
-        const ownedRepositories = allRepositories.filter(repo => {
-          const repoOwner = repo.owner?.login || repo.owner;
-          return repoOwner === owner;
-        });
-        const unownedCount = allRepositories.length - ownedRepositories.length;
-        if (unownedCount > 0) {
-          await log(`   ⏭️  Skipping ${unownedCount} repository(ies) not owned by ${owner}`);
-        }
-        // Filter out archived repositories from owned repositories
-        const repositories = ownedRepositories.filter(repo => !repo.isArchived);
-        const archivedCount = ownedRepositories.length - repositories.length;
-        if (archivedCount > 0) {
-          await log(`   ⏭️  Skipping ${archivedCount} archived repository(ies)`);
-        }
-        await log(`   ✅ Processing ${repositories.length} non-archived repositories owned by ${owner}`);
-        let collectedIssues = [];
-        let processedRepos = 0;
-        // Process repositories in batches to avoid overwhelming the API
-        for (const repo of repositories) {
-          try {
-            const repoName = repo.name;
-            const ownerName = repo.owner?.login || owner;
-            await log(`   🔍 Fetching issues from ${ownerName}/${repoName}...`, { verbose: true });
-            // Build the appropriate issue list command
-            let issueCmd;
-            if (fetchAllIssues) {
-              issueCmd = `gh issue list --repo ${ownerName}/${repoName} --state open --json url,title,number,createdAt`;
-            } else {
-              issueCmd = `gh issue list --repo ${ownerName}/${repoName} --state open --label "${monitorTag}" --json url,title,number,createdAt`;
-            }
-            // Add delay between repository requests
-            await new Promise(resolve => setTimeout(resolve, 1000));
-            const repoIssues = await fetchAllIssuesWithPagination(issueCmd);
-            // Add repository information to each issue
-            const issuesWithRepo = repoIssues.map(issue => ({
-              ...issue,
-              repository: {
-                name: repoName,
-                owner: { login: ownerName },
-              },
-            }));
-            collectedIssues.push(...issuesWithRepo);
-            processedRepos++;
-            if (issuesWithRepo.length > 0) {
-              await log(`   ✅ Found ${issuesWithRepo.length} issues in ${ownerName}/${repoName}`, { verbose: true });
-            }
-          } catch (repoError) {
-            reportError(repoError, {
-              context: 'fetchIssuesFromRepositories',
-              repo: repo.name,
-              operation: 'fetch_repo_issues',
-            });
-            await log(`   ⚠️  Failed to fetch issues from ${repo.name}: ${cleanErrorMessage(repoError)}`, {
-              verbose: true,
-            });
-            // Continue with other repositories
-          }
-        }
-        await log(`   ✅ Repository fallback complete: ${collectedIssues.length} issues from ${processedRepos}/${repositories.length} repositories`);
-        return collectedIssues;
-      } catch (error) {
-        reportError(error, {
-          context: 'fetchIssuesFromRepositories',
-          owner,
-          scope,
-          operation: 'repository_fallback',
-        });
-        await log(`   ❌ Repository fallback failed: ${cleanErrorMessage(error)}`, { level: 'error' });
-        return [];
-      }
-    }
+    // Repository-by-repository fallback lives in its own module so hive.mjs stays
+    // under the 1350-line early-warning threshold (issue #2175, warning from #1593).
+    const repositoryFallbackLib = await import('./hive.repository-fallback.lib.mjs');
+    const fetchIssuesFromRepositories = repositoryFallbackLib.createRepositoryIssueFetcher({ log, cleanErrorMessage, tryFetchIssuesWithGraphQL, execGhWithRetry, fetchAllIssuesWithPagination, reportError });
     // Configure command line arguments - GitHub URL as positional argument
     const rawArgs = normalizeCliArgs(hideBin(process.argv));
     // Use .parse() instead of .argv to ensure .strict() mode works correctly
@@ -1398,37 +1283,10 @@ if (isRunningDirectly) {
     delegateSignalHandling(true);
     process.on('SIGINT', () => gracefulShutdown('interrupt'));
     process.on('SIGTERM', () => gracefulShutdown('termination'));
-    // Check system resources (disk space and RAM) before starting monitoring (skip in dry-run mode)
-    if (argv.dryRun || argv.skipToolConnectionCheck || argv.toolConnectionCheck === false) {
-      await log('⏩ Skipping system resource check (dry-run mode or skip-tool-connection-check enabled)', {
-        verbose: true,
-      });
-      await log('⏩ Skipping AI tool connection check (dry-run mode or skip-tool-connection-check enabled)', {
-        verbose: true,
-      });
-    } else {
-      // Issue #2160: reclaim idle solver workspaces left behind by earlier runs before refusing to
-      // start, and report an exhausted disk as the environment condition it is (exit 75) instead of
-      // a generic error. `exitOnFailure` is deliberately not used: it calls process.exit(1)
-      // directly, which skips the log-flushing safeExit path and printed no actionable reason.
-      const startupRequiredDiskSpaceMB = argv.minDiskSpace || 10240;
-      const startupDiskGuard = await ensureDiskSpaceForWorker({ requiredMB: startupRequiredDiskSpaceMB, log });
-      if (!startupDiskGuard.ok) {
-        await log(`❌ Insufficient disk space to start: ${startupDiskGuard.freeMB}MB available, ${startupRequiredDiskSpaceMB}MB required`, { level: 'error' });
-        await log('   Free space on this host, or run with --auto-cleanup so workspaces are removed after each task.', { level: 'error' });
-        await safeExit(EXIT_CODE_INSUFFICIENT_DISK_SPACE, `Insufficient disk space (${startupDiskGuard.freeMB}MB available, ${startupRequiredDiskSpaceMB}MB required)`);
-      }
-      const systemCheck = await checkSystem({ minDiskSpaceMB: startupRequiredDiskSpaceMB, minMemoryMB: 256 }, { log });
-      if (!systemCheck.success) {
-        await safeExit(1, 'System resource check failed');
-      }
-      // Validate the selected AI tool connection before starting monitoring with the same model that will be used
-      const isToolConnected = await validateToolConnection({ tool: argv.tool, model: argv.model, verbose: argv.verbose, validateClaudeConnection });
-      if (!isToolConnected) {
-        await log(`❌ Cannot start monitoring without ${argv.tool || 'claude'} connection`, { level: 'error' });
-        await safeExit(1, 'Error occurred');
-      }
-    }
+    // Pre-flight checks live in hive.startup-checks.lib.mjs so hive.mjs stays under
+    // the 1350-line early-warning threshold (issue #2175, warning from #1593).
+    const startupChecksLib = await import('./hive.startup-checks.lib.mjs');
+    await startupChecksLib.runStartupChecks({ argv, log, safeExit, ensureDiskSpaceForWorker, checkSystem, validateToolConnection, validateClaudeConnection, EXIT_CODE_INSUFFICIENT_DISK_SPACE });
     // Wrap monitor function with Sentry error tracking
     const monitorWithSentry = !argv.sentry ? monitor : withSentry(monitor, 'hive.monitor', 'command');
     // Start monitoring

package/src/hive.repository-fallback.lib.mjs

@@ -0,0 +1,125 @@
+/**
+ * Repository-by-repository issue fetching fallback for the hive.
+ *
+ * Extracted from src/hive.mjs (issue #2175) so the entry point stays under the
+ * 1350-line early-warning threshold that protects concurrent merges (#1593).
+ * The logic is unchanged; it now takes its collaborators as parameters instead
+ * of closing over the dynamically imported bindings in hive.mjs, which also
+ * makes it unit-testable (see tests/hive-repository-fallback-2175.test.mjs).
+ *
+ * Used when GitHub's search API is rate-limited: rather than giving up, every
+ * repository owned by the org/user is listed and queried directly.
+ */
+
+/**
+ * Build the repository-fallback fetcher with its dependencies bound.
+ *
+ * @param {object} deps
+ * @param {Function} deps.log
+ * @param {Function} deps.cleanErrorMessage
+ * @param {Function} deps.tryFetchIssuesWithGraphQL
+ * @param {Function} deps.execGhWithRetry
+ * @param {Function} deps.fetchAllIssuesWithPagination
+ * @param {Function} deps.reportError
+ * @param {(ms: number) => Promise<void>} [deps.sleeper] delay between API calls
+ * @returns {(owner: string, scope: string, monitorTag?: string, fetchAllIssues?: boolean) => Promise<Array>}
+ */
+export function createRepositoryIssueFetcher({ log, cleanErrorMessage, tryFetchIssuesWithGraphQL, execGhWithRetry, fetchAllIssuesWithPagination, reportError, sleeper = ms => new Promise(resolve => setTimeout(resolve, ms)) }) {
+  /**
+   * Fallback function to fetch issues from organization/user repositories
+   * when search API hits rate limits
+   * @param {string} owner - Organization or user name
+   * @param {string} scope - 'organization' or 'user'
+   * @param {string} monitorTag - Label to filter by (optional)
+   * @param {boolean} fetchAllIssues - Whether to fetch all issues or only labeled ones
+   * @returns {Promise<Array>} Array of issues
+   */
+  return async function fetchIssuesFromRepositories(owner, scope, monitorTag, fetchAllIssues = false) {
+    try {
+      await log(`   🔄 Using repository-by-repository fallback for ${scope}: ${owner}`);
+      // Strategy 1: Try GraphQL approach first (faster but has limitations)
+      // Only try GraphQL for "all issues" mode, not for labeled issues
+      if (fetchAllIssues) {
+        const graphqlResult = await tryFetchIssuesWithGraphQL(owner, scope, log, cleanErrorMessage);
+        if (graphqlResult.success) {
+          await log(`   ✅ GraphQL approach successful: ${graphqlResult.issues.length} issues from ${graphqlResult.repoCount} repositories`);
+          return graphqlResult.issues;
+        }
+      }
+      // Strategy 2: Fallback to gh api --paginate approach (comprehensive but slower)
+      await log('   📋 Using gh api --paginate approach for comprehensive coverage...', { verbose: true });
+
+      // Get list of ALL repositories using gh api with --paginate (includes isArchived for filtering)
+      const scopePath = scope === 'organization' ? 'orgs' : 'users';
+      const repoListCmd = `gh api ${scopePath}/${owner}/repos --paginate --jq '.[] | {name: .name, owner: .owner.login, isArchived: .archived}'`;
+      await log('   📋 Fetching repository list (using --paginate for unlimited pagination)...', { verbose: true });
+      await log(`   🔎 Command: ${repoListCmd}`, { verbose: true });
+      // Add delay for rate limiting
+      await sleeper(2000);
+      // #1756: route through execGhWithRetry for transient 5xx + rate-limit
+      const { stdout: repoOutput } = await execGhWithRetry(repoListCmd, {
+        execOptions: { encoding: 'utf8', env: process.env },
+        label: `gh api ${scope} repos (paginated)`,
+      });
+      // Parse the output line by line, as gh api with --jq outputs one JSON object per line
+      const repoLines = repoOutput
+        .trim()
+        .split('\n')
+        .filter(line => line.trim());
+      const allRepositories = repoLines.map(line => JSON.parse(line));
+      await log(`   📊 Found ${allRepositories.length} repositories`);
+      // Filter repositories to only include those owned by the target user/org
+      const ownedRepositories = allRepositories.filter(repo => {
+        const repoOwner = repo.owner?.login || repo.owner;
+        return repoOwner === owner;
+      });
+      const unownedCount = allRepositories.length - ownedRepositories.length;
+      if (unownedCount > 0) {
+        await log(`   ⏭️  Skipping ${unownedCount} repository(ies) not owned by ${owner}`);
+      }
+      // Filter out archived repositories from owned repositories
+      const repositories = ownedRepositories.filter(repo => !repo.isArchived);
+      const archivedCount = ownedRepositories.length - repositories.length;
+      if (archivedCount > 0) {
+        await log(`   ⏭️  Skipping ${archivedCount} archived repository(ies)`);
+      }
+      await log(`   ✅ Processing ${repositories.length} non-archived repositories owned by ${owner}`);
+      const collectedIssues = [];
+      let processedRepos = 0;
+      // Process repositories in batches to avoid overwhelming the API
+      for (const repo of repositories) {
+        try {
+          const repoName = repo.name;
+          const ownerName = repo.owner?.login || owner;
+          await log(`   🔍 Fetching issues from ${ownerName}/${repoName}...`, { verbose: true });
+          // Build the appropriate issue list command
+          const labelFilter = fetchAllIssues ? '' : ` --label "${monitorTag}"`;
+          const issueCmd = `gh issue list --repo ${ownerName}/${repoName} --state open${labelFilter} --json url,title,number,createdAt`;
+          // Add delay between repository requests
+          await sleeper(1000);
+          const repoIssues = await fetchAllIssuesWithPagination(issueCmd);
+          // Add repository information to each issue
+          const issuesWithRepo = repoIssues.map(issue => ({
+            ...issue,
+            repository: { name: repoName, owner: { login: ownerName } },
+          }));
+          collectedIssues.push(...issuesWithRepo);
+          processedRepos++;
+          if (issuesWithRepo.length > 0) {
+            await log(`   ✅ Found ${issuesWithRepo.length} issues in ${ownerName}/${repoName}`, { verbose: true });
+          }
+        } catch (repoError) {
+          reportError(repoError, { context: 'fetchIssuesFromRepositories', repo: repo.name, operation: 'fetch_repo_issues' });
+          await log(`   ⚠️  Failed to fetch issues from ${repo.name}: ${cleanErrorMessage(repoError)}`, { verbose: true });
+          // Continue with other repositories
+        }
+      }
+      await log(`   ✅ Repository fallback complete: ${collectedIssues.length} issues from ${processedRepos}/${repositories.length} repositories`);
+      return collectedIssues;
+    } catch (error) {
+      reportError(error, { context: 'fetchIssuesFromRepositories', owner, scope, operation: 'repository_fallback' });
+      await log(`   ❌ Repository fallback failed: ${cleanErrorMessage(error)}`, { level: 'error' });
+      return [];
+    }
+  };
+}

package/src/hive.startup-checks.lib.mjs

@@ -0,0 +1,57 @@
+/**
+ * Pre-flight checks the hive runs before it starts monitoring.
+ *
+ * Extracted from src/hive.mjs (issue #2175) so the entry point stays under the
+ * 1350-line early-warning threshold that protects concurrent merges (#1593).
+ * Behaviour is unchanged; the collaborators that used to be closure bindings in
+ * hive.mjs are parameters, which also makes the sequence unit-testable
+ * (see tests/hive-startup-checks-2175.test.mjs).
+ */
+
+/**
+ * Run the startup checks, exiting through `safeExit` when one fails.
+ *
+ * @param {object} deps
+ * @param {object} deps.argv parsed CLI arguments
+ * @param {Function} deps.log
+ * @param {Function} deps.safeExit
+ * @param {Function} deps.ensureDiskSpaceForWorker
+ * @param {Function} deps.checkSystem
+ * @param {Function} deps.validateToolConnection
+ * @param {Function} deps.validateClaudeConnection
+ * @param {number} deps.EXIT_CODE_INSUFFICIENT_DISK_SPACE
+ * @returns {Promise<{skipped: boolean}>}
+ */
+export async function runStartupChecks({ argv, log, safeExit, ensureDiskSpaceForWorker, checkSystem, validateToolConnection, validateClaudeConnection, EXIT_CODE_INSUFFICIENT_DISK_SPACE }) {
+  if (argv.dryRun || argv.skipToolConnectionCheck || argv.toolConnectionCheck === false) {
+    await log('⏩ Skipping system resource check (dry-run mode or skip-tool-connection-check enabled)', { verbose: true });
+    await log('⏩ Skipping AI tool connection check (dry-run mode or skip-tool-connection-check enabled)', { verbose: true });
+    return { skipped: true };
+  }
+
+  // Issue #2160: reclaim idle solver workspaces left behind by earlier runs before refusing to
+  // start, and report an exhausted disk as the environment condition it is (exit 75) instead of
+  // a generic error. `exitOnFailure` is deliberately not used: it calls process.exit(1)
+  // directly, which skips the log-flushing safeExit path and printed no actionable reason.
+  const startupRequiredDiskSpaceMB = argv.minDiskSpace || 10240;
+  const startupDiskGuard = await ensureDiskSpaceForWorker({ requiredMB: startupRequiredDiskSpaceMB, log });
+  if (!startupDiskGuard.ok) {
+    await log(`❌ Insufficient disk space to start: ${startupDiskGuard.freeMB}MB available, ${startupRequiredDiskSpaceMB}MB required`, { level: 'error' });
+    await log('   Free space on this host, or run with --auto-cleanup so workspaces are removed after each task.', { level: 'error' });
+    await safeExit(EXIT_CODE_INSUFFICIENT_DISK_SPACE, `Insufficient disk space (${startupDiskGuard.freeMB}MB available, ${startupRequiredDiskSpaceMB}MB required)`);
+  }
+
+  const systemCheck = await checkSystem({ minDiskSpaceMB: startupRequiredDiskSpaceMB, minMemoryMB: 256 }, { log });
+  if (!systemCheck.success) {
+    await safeExit(1, 'System resource check failed');
+  }
+
+  // Validate the selected AI tool connection before starting monitoring with the same model that will be used
+  const isToolConnected = await validateToolConnection({ tool: argv.tool, model: argv.model, verbose: argv.verbose, validateClaudeConnection });
+  if (!isToolConnected) {
+    await log(`❌ Cannot start monitoring without ${argv.tool || 'claude'} connection`, { level: 'error' });
+    await safeExit(1, 'Error occurred');
+  }
+
+  return { skipped: false };
+}

package/src/isolation-runner.lib.mjs

@@ -47,6 +47,10 @@ async function getCommandStreamDollar() {
 }
 // Re-export the shared status predicates so existing callers that reach them via the isolation-runner module (e.g. session-monitor's `runner.isExecutingSessionStatus`) keep working. The canonical definitions live in session-status.lib.mjs so the killed/terminated/oom vocabulary stays consistent everywhere (issue #1927).
 export { isExecutingSessionStatus, isTerminalSessionStatus, isKilledSessionStatus } from './session-status.lib.mjs';
+// Issue #2175: the `$` output parsers live in their own module to keep this file
+// under the 1350-line warning threshold. Re-exported so importers are unaffected.
+import { isUnknownDockerExitCode, parseSessionExitFooter, parseSessionListOutput, parseSessionStatusOutput, parseStartCommandExecutionUuid, readSessionExitFromLog, shouldFallbackToScreenStatus } from './isolation-runner.parsers.lib.mjs';
+export { isUnknownDockerExitCode, parseSessionExitFooter, parseSessionListOutput, parseSessionStatusOutput, parseStartCommandExecutionUuid, readSessionExitFromLog, shouldFallbackToScreenStatus };
 // Valid isolation backends
 const VALID_ISOLATION_BACKENDS = ['screen', 'tmux', 'docker'];
 const DOCKER_CONTAINER_HOME = '/home/box';
@@ -59,17 +63,6 @@ const DOCKER_ISOLATION_SHELL = 'sh';
 const DOCKER_ISOLATION_LOW_DISK_GIB = 40;
 // Docker-only start gate used to capture the container writable-layer baseline before the task command begins cloning or generating files. The parent releases the gate immediately after `docker inspect --size`; the fallback keeps the task from hanging forever if the parent exits at the wrong time.
 const DOCKER_START_GATE_WAIT_TENTHS = 300;
-// Sentinel start-command's detached docker logger records when it cannot capture the container's real exit code. A terminal `$ --status` carrying this value is ambiguous — the container may still be running — so we cross-check it against a live `docker inspect` before concluding the session finished. See #1939. The upstream emission of this premature sentinel was fixed in start-command 0.29.1 (link-foundation/start#136), which the Hive Mind images now pin; this cross-check is retained as defense-in-depth so an older `$` on an operator's PATH cannot resurrect the bug.
-const DOCKER_UNKNOWN_EXIT_CODE = -1;
-function normalizeProcessIds(value) {
-  if (!value || typeof value !== 'object') return {};
-  const out = {};
-  for (const [key, raw] of Object.entries(value)) {
-    const number = Number(raw);
-    if (Number.isInteger(number) && number > 0) out[key] = number;
-  }
-  return out;
-}
 function normalizeTool(tool) {
   return String(tool || 'claude')
     .trim()
@@ -269,233 +262,6 @@ async function runStartCommand(binPath, startCommandArgs) {
 export function generateSessionId() {
   return crypto.randomUUID();
 }
-const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-/**
- * Extract start-command's own execution UUID from a launch banner.
- *
- * Issue #2154: an isolated task has two UUIDs. Hive Mind generates the session
- * name and passes it as `--session` (it also becomes the container name);
- * start-command mints a separate execution UUID and prints it as the `session`
- * field of its launch banner:
- *
- * ```
- * │ session   edc7b051-e12f-4f7b-b677-c885f3208407
- * │ container 0a3627ef-f1f1-4801-a073-3678b9453db7
- * ```
- *
- * `$ --list` shows the execution UUID, while Telegram and the logs showed the
- * session UUID, so the two views could not be joined — which is why three
- * refused tasks and two healthy ones looked equally unaccounted for. Returning
- * it lets the caller record both.
- *
- * Only a well-formed UUID is returned; a banner we do not recognise yields
- * null rather than a guess, because a wrong correlation is worse than none.
- *
- * @param {string} output - Raw stdout from the detached `$` launch
- * @returns {string|null}
- */
-export function parseStartCommandExecutionUuid(output) {
-  const raw = (output || '').trim();
-  if (!raw) return null;
-  try {
-    const parsed = JSON.parse(raw);
-    const data = Array.isArray(parsed) ? parsed[0] : parsed;
-    const uuid = data?.uuid || data?.session || null;
-    if (typeof uuid === 'string' && UUID_PATTERN.test(uuid.trim())) return uuid.trim();
-  } catch {
-    // Human-readable banner — fall through.
-  }
-  // The banner is box-drawn (`│ session   <uuid>`); tolerate the prefix, an
-  // ASCII `|`, or no prefix at all.
-  const match = raw.match(/^[\s│|]*session\s+([^\s]+)\s*$/im);
-  const candidate = match?.[1]?.trim();
-  return candidate && UUID_PATTERN.test(candidate) ? candidate : null;
-}
-/**
- * Parse output from `$ --status <session>`.
- *
- * start-command versions used in the wild may return JSON when
- * `--output-format json` is supported, or human-readable key/value text.
- * Keep the parser tolerant so completion monitoring survives either format.
- *
- * @param {string} output - Raw stdout from `$ --status`
- * @returns {{exists: boolean, uuid: string|null, status: string|null, exitCode: number|null, startTime: string|null, endTime: string|null, currentTime: string|null, logPath: string|null, command: string|null, isolation: string|null, workingDirectory: string|null, sessionName: string|null, processIds: Object, raw: string}}
- */
-export function parseSessionStatusOutput(output) {
-  const raw = (output || '').trim();
-  if (!raw) {
-    return { exists: false, uuid: null, status: null, exitCode: null, startTime: null, endTime: null, currentTime: null, logPath: null, command: null, isolation: null, workingDirectory: null, sessionName: null, processIds: {}, oomKilled: null, raw: '' };
-  }
-  const normalizeBooleanField = value => {
-    if (typeof value === 'boolean') return value;
-    if (value === null || value === undefined) return null;
-    const normalized = String(value).trim().toLowerCase();
-    if (['true', '1', 'yes'].includes(normalized)) return true;
-    if (['false', '0', 'no'].includes(normalized)) return false;
-    return null;
-  };
-  try {
-    const parsed = JSON.parse(raw);
-    const data = Array.isArray(parsed) ? parsed[0] : parsed;
-    // start-command (link-foundation/start) reports the isolation backend at `options.isolated` in both JSON and links-notation output. Older hypothetical layouts used `options.isolation` or a top-level `isolation` field — keep accepting all three so we are tolerant of future renames. See https://github.com/link-assistant/hive-mind/issues/1700.
-    const isolationCandidate = (typeof data?.isolation === 'string' && data.isolation) || (typeof data?.options?.isolated === 'string' && data.options.isolated) || (typeof data?.options?.isolation === 'string' && data.options.isolation) || null;
-    const topPid = Number(data?.pid);
-    const processIds = normalizeProcessIds(data?.processIds);
-    if (Number.isInteger(topPid) && topPid > 0 && processIds.pid == null) processIds.pid = topPid;
-    return {
-      exists: true,
-      uuid: data?.uuid || null,
-      status: typeof data?.status === 'string' ? data.status.toLowerCase() : null,
-      exitCode: data?.exitCode !== undefined && data?.exitCode !== null ? Number(data.exitCode) : null,
-      startTime: data?.startTime || null,
-      endTime: data?.endTime || null,
-      currentTime: data?.currentTime || null,
-      logPath: data?.logPath || null,
-      command: data?.command || null,
-      isolation: isolationCandidate ? isolationCandidate.toLowerCase() : null,
-      workingDirectory: data?.workingDirectory || null,
-      sessionName: data?.sessionName || data?.options?.sessionName || null,
-      processIds,
-      oomKilled: normalizeBooleanField(data?.oomKilled ?? data?.OOMKilled ?? data?.options?.oomKilled ?? data?.state?.oomKilled ?? data?.State?.OOMKilled),
-      raw,
-    };
-  } catch {
-    // Fall through to text parsing.
-  }
-  const firstLine =
-    raw
-      .split('\n')
-      .find(line => line.trim() && !line.includes(' '))
-      ?.trim() || null;
-  const readField = name => {
-    const match = raw.match(new RegExp(`^\\s*${name}\\s+"?([^"\\n]+)"?\\s*$`, 'mi'));
-    return match ? match[1].trim() : null;
-  };
-  const readBooleanField = name => normalizeBooleanField(readField(name));
-  const status = readField('status')?.toLowerCase() || null;
-  const exitCodeText = readField('exitCode');
-  // `start-command` links-notation output nests the isolation backend under `options` as `isolated <backend>` (not `isolation`). The leading indent varies by depth, but `readField` is anchored with `^\s*` which already matches indented lines. Older code only looked for `isolation`, which
-  // returned null for every real session and made /log + /terminal_watch
-  // reject screen/tmux/docker sessions. See issue #1700.
-  const isolationText = readField('isolated') || readField('isolation');
-  const processIds = {};
-  for (const name of ['pid', 'wrapperPid', 'childPid', 'processPid', 'commandPid']) {
-    const value = readField(name);
-    const number = Number(value);
-    if (Number.isInteger(number) && number > 0) processIds[name] = number;
-  }
-  return {
-    exists: Boolean(status || firstLine),
-    uuid: readField('uuid') || firstLine,
-    status,
-    exitCode: exitCodeText !== null ? Number(exitCodeText) : null,
-    startTime: readField('startTime'),
-    endTime: readField('endTime'),
-    currentTime: readField('currentTime'),
-    logPath: readField('logPath'),
-    command: readField('command'),
-    isolation: isolationText?.toLowerCase() || null,
-    workingDirectory: readField('workingDirectory'),
-    sessionName: readField('sessionName'),
-    processIds,
-    oomKilled: readBooleanField('oomKilled'),
-    raw,
-  };
-}
-/**
- * Decide whether a detached-docker exit code is "unknown" (not a real result).
- *
- * start-command's detached docker logger writes the exit-code footer only after
- * `docker logs -f` returns, capturing the real code via `docker inspect`. When
- * it cannot capture one it records the sentinel `-1`. A `$ --status` that
- * reports a terminal status ("executed") while still carrying that sentinel — or
- * no exit code at all — is therefore ambiguous: the container may actually still
- * be running. Callers treat such a status as provisional and cross-check the
- * live container before declaring the session finished. See issue #1939.
- *
- * @param {number|null|undefined} exitCode
- * @returns {boolean} True when the exit code carries no real result.
- */
-export function isUnknownDockerExitCode(exitCode) {
-  return exitCode === null || exitCode === undefined || Number(exitCode) === DOCKER_UNKNOWN_EXIT_CODE;
-}
-export function shouldFallbackToScreenStatus(statusResult) {
-  return !statusResult?.exists || !statusResult?.status;
-}
-/**
- * Parse the footer start-command appends to every execution log when the wrapped
- * command exits. The footer is authoritative about the terminal exit code even
- * when `$ --status` is wrong: start-command writes it from the command's own
- * `close`/`exited` handler, so its presence proves the command terminated.
- *
- * Footer shape (see start-command spawn-helpers.js):
- *
- *     ==================================================
- *     Finished: 2026-06-14 19:10:49.822
- *     Exit Code: 137
- *
- * Issue #1927: start-command's `enrichDetachedStatus` can flip a completed
- * `executed/137` record back to `executing` (nulling the exit code) when a
- * lingering shell keeps the screen session alive — so `$ --status` reports
- * `executing` forever and the bot never notices the kill. Reading this footer
- * lets hive-mind detect the real terminal exit regardless of that flip.
- *
- * @param {string} text - Log text (typically the tail of the log file)
- * @returns {{finished: boolean, exitCode: number|null, endTime: string|null}}
- */
-export function parseSessionExitFooter(text) {
-  if (!text) return { finished: false, exitCode: null, endTime: null };
-  // Match the LAST footer block in the text (a re-run could append more than
-  // one). Anchor on the `=` separator so command output that merely prints
-  // "Exit Code: N" mid-stream is not mistaken for the footer.
-  const re = /={10,}\s*\r?\nFinished:\s*([^\r\n]+)\r?\nExit Code:\s*(-?\d+)/g;
-  let match;
-  let last = null;
-  while ((match = re.exec(text)) !== null) last = match;
-  if (!last) return { finished: false, exitCode: null, endTime: null };
-  return { finished: true, exitCode: Number(last[2]), endTime: last[1].trim() };
-}
-/**
- * Read the terminal exit code from the tail of a start-command execution log.
- *
- * Only the last `tailBytes` of the file are read (the footer lives at the end),
- * so this is cheap even for multi-megabyte logs. Never throws — a missing or
- * unreadable log yields `{ finished: false }`.
- *
- * @param {string} logPath
- * @param {Object} [options]
- * @param {Object} [options.fsImpl=fs] - Injectable fs (for tests)
- * @param {number} [options.tailBytes=16384] - How many trailing bytes to scan
- * @param {boolean} [options.verbose]
- * @returns {{finished: boolean, exitCode: number|null, endTime: string|null}}
- */
-export function readSessionExitFromLog(logPath, options = {}) {
-  const { fsImpl = fs, tailBytes = 16384, verbose = false } = options;
-  if (!logPath) return { finished: false, exitCode: null, endTime: null };
-  try {
-    const { size } = fsImpl.statSync(logPath);
-    if (!size) return { finished: false, exitCode: null, endTime: null };
-    const start = Math.max(0, size - tailBytes);
-    const length = size - start;
-    const buffer = Buffer.alloc(length);
-    const fd = fsImpl.openSync(logPath, 'r');
-    try {
-      fsImpl.readSync(fd, buffer, 0, length, start);
-    } finally {
-      fsImpl.closeSync(fd);
-    }
-    const result = parseSessionExitFooter(buffer.toString('utf8'));
-    if (verbose && result.finished) {
-      console.log(`[VERBOSE] isolation-runner: log footer for ${logPath} reports exit ${result.exitCode} (finished ${result.endTime})`);
-    }
-    return result;
-  } catch (error) {
-    if (verbose) {
-      console.log(`[VERBOSE] isolation-runner: could not read exit footer from ${logPath}: ${error.message}`);
-    }
-    return { finished: false, exitCode: null, endTime: null };
-  }
-}
 /**
  * Find the `$` CLI binary path
  * @returns {Promise<string|null>} Path to `$` binary or null
@@ -700,45 +466,6 @@ export async function querySessionStatus(sessionId, verbose = false) {
     return { exists: false, uuid: null, status: null, exitCode: null, startTime: null, endTime: null, currentTime: null, logPath: null, command: null, isolation: null, workingDirectory: null, sessionName: null, processIds: {}, raw: '' };
   }
 }
-/**
- * Parse output from `$ --list --output-format json`.
- *
- * start-command may return a top-level array, or an object with an
- * `executions`/`sessions` array. Each entry is normalized to the same shape used
- * by {@link parseSessionStatusOutput} (uuid/status/exitCode/command/isolation/…).
- * Tolerant of unknown layouts — anything unparseable yields an empty list.
- *
- * @param {string} output - Raw stdout from `$ --list`
- * @returns {Array<{uuid: string|null, status: string|null, exitCode: number|null, startTime: string|null, endTime: string|null, command: string|null, isolation: string|null, workingDirectory: string|null, sessionName: string|null}>}
- */
-export function parseSessionListOutput(output) {
-  const raw = (output || '').trim();
-  if (!raw) return [];
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return [];
-  }
-  const records = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.executions) ? parsed.executions : Array.isArray(parsed?.sessions) ? parsed.sessions : parsed && typeof parsed === 'object' ? [parsed] : [];
-  return records
-    .map(data => {
-      if (!data || typeof data !== 'object') return null;
-      const isolationCandidate = (typeof data.isolation === 'string' && data.isolation) || (typeof data.options?.isolated === 'string' && data.options.isolated) || (typeof data.options?.isolation === 'string' && data.options.isolation) || null;
-      return {
-        uuid: data.uuid || data.session || data.sessionId || null,
-        status: typeof data.status === 'string' ? data.status.toLowerCase() : null,
-        exitCode: data.exitCode !== undefined && data.exitCode !== null ? Number(data.exitCode) : null,
-        startTime: data.startTime || null,
-        endTime: data.endTime || null,
-        command: data.command || null,
-        isolation: isolationCandidate ? isolationCandidate.toLowerCase() : null,
-        workingDirectory: data.workingDirectory || null,
-        sessionName: data.sessionName || data.options?.sessionName || null,
-      };
-    })
-    .filter(Boolean);
-}
 /**
  * List all executions known to start-command via `$ --list --output-format json`.
  *