@link-assistant/hive-mind 2.16.0 → 2.18.0

package/src/isolation-runner.lib.mjs

@@ -1,4 +1,3 @@
-import { ensureUseM } from './use-m-bootstrap.lib.mjs';
 /**
  * Isolation Runner for Telegram bot
  *
@@ -30,30 +29,22 @@ import { buildRouterGitConfigEntries, buildRouterTaskEnv, getRouterSuppressedCre
 import { acquireRouterForTask, attachRouterTaskContainer, registerFormalAiWithRouter, releaseRouterForTask } from './router-task-isolation.lib.mjs';
 import { buildGitConfigEnv, GIT_PUSH_GUARD_CONTAINER_DIR, GIT_PUSH_GUARD_ESCAPE_ENV, hasForcePushOptIn, installGitPushGuard } from './git-push-guard.lib.mjs';
 export { getDockerIsolationImage, resolveDockerIsolationImageTag } from './hive-mind-image.lib.mjs';
-let commandStreamDollarPromise = null;
-async function getCommandStreamDollar() {
-  if (!commandStreamDollarPromise) {
-    commandStreamDollarPromise = (async () => {
-      if (typeof globalThis.use === 'undefined') {
-        await ensureUseM();
-      }
-      const { $ } = await globalThis.use('command-stream');
-      return $;
-    })();
-  }
-  try {
-    return await commandStreamDollarPromise;
-  } catch (error) {
-    commandStreamDollarPromise = null;
-    throw error;
-  }
-}
 // 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 };
+// Issue #2189: the `$` loader and PATH lookup live in their own module so the
+// resume/attach wrappers can use them without importing this runner (a cycle).
+import { findStartCommandBinary, getCommandStreamDollar } from './start-command-cli.lib.mjs';
+export { findStartCommandBinary };
+// Issue #2189: `$ --resume` / `$ --resume-all`, added in start-command 0.33.0
+// (link-foundation/start#162). Re-exported so callers keep reaching every
+// isolation verb through this module.
+import { resumeAllIsolationSessions, resumeIsolatedSession } from './isolation-runner.resume.lib.mjs';
+export { resumeAllIsolationSessions, resumeIsolatedSession };
+export { parseExecutionResumeAllOutput, parseExecutionResumeOutput, RESUME_ALL_ACTIONS, RESUME_MODES } from './isolation-runner.resume.lib.mjs';
 // Valid isolation backends
 const VALID_ISOLATION_BACKENDS = ['screen', 'tmux', 'docker'];
 const DOCKER_CONTAINER_HOME = '/home/box';
@@ -311,20 +302,6 @@ async function runStartCommand(binPath, startCommandArgs) {
 export function generateSessionId() {
   return crypto.randomUUID();
 }
-/**
- * Find the `$` CLI binary path
- * @returns {Promise<string|null>} Path to `$` binary or null
- */
-async function findStartCommandBinary() {
-  try {
-    const $ = await getCommandStreamDollar();
-    const result = await $({ mirror: false })`which $`;
-    const path = result.stdout?.toString().trim() || '';
-    return path || null;
-  } catch {
-    return null;
-  }
-}
 /**
  * Verbose post-launch diagnostics for a native docker-isolated session.
  *
@@ -611,6 +588,21 @@ export async function stopIsolatedSession(sessionId, verbose = false) {
         console.log(`[VERBOSE] isolation-runner: $ --stop ${sessionId} stderr: ${stderr.substring(0, 300)}`);
       }
     }
+    // Issue #2189: `command-stream`'s `$` resolves — it does not throw — when the
+    // child exits non-zero, so the catch below never sees a refusal. `$ --stop`
+    // answers `Error: No execution found with UUID or session name: …` on stderr
+    // with exit code 1; without this check every such refusal was reported to the
+    // operator as a successful stop, and a session nobody stopped looked handled.
+    const code = Number.isFinite(result.code) ? result.code : 0;
+    if (code !== 0) {
+      // describeChildExit rather than an interpolated code: issue #2135 made it
+      // the single vocabulary for "how a child ended", so a `$` that was
+      // signalled reads the same way here as everywhere else. command-stream
+      // normalizes a signalled exit to 128+signum before we see it
+      // (node_modules/command-stream/src/$.process-runner-stream-kill.mjs:194),
+      // so there is no separate signal to pass.
+      return { success: false, output: stdout, error: stderr.trim() || describeChildExit({ command: '`$ --stop`', code }) };
+    }
     return { success: true, output: stdout || stderr, error: null };
   } catch (error) {
     const stderr = error?.stderr?.toString?.() || '';
@@ -679,6 +671,37 @@ export async function checkDockerContainerRunning(containerName, verbose = false
     return false;
   }
 }
+/**
+ * Check whether the Docker container backing a session still exists at all —
+ * running or stopped.
+ *
+ * Issue #2189 requirement R2: a killed session should be re-entered rather than
+ * restarted from scratch, and `$ --resume` can only do that while the container
+ * is still there. `checkDockerContainerRunning` answers a different question (a
+ * stopped container is "not running" but is exactly the one worth resuming), so
+ * the state is read instead of the running flag.
+ *
+ * @param {string} containerName - Container name (the session UUID)
+ * @param {boolean} [verbose] - Enable verbose logging
+ * @returns {Promise<boolean>} True when `docker inspect` finds the container
+ */
+export async function checkDockerContainerExists(containerName, verbose = false) {
+  if (!containerName) return false;
+  try {
+    const $ = await getCommandStreamDollar();
+    const result = await $({ mirror: false })`docker inspect -f ${'{{.State.Status}}'} ${containerName}`;
+    const code = Number.isFinite(result.code) ? result.code : 0;
+    const state = (result.stdout?.toString() || '').trim();
+    const exists = code === 0 && state !== '';
+    if (verbose) {
+      console.log(`[VERBOSE] isolation-runner: docker inspect state for '${containerName}': ${exists ? state : 'no such container'}`);
+    }
+    return exists;
+  } catch {
+    // `docker inspect` exits non-zero when no such container exists.
+    return false;
+  }
+}
 export function parseDockerContainerWritableLayerSizeOutput(output) {
   const text = String(output || '').trim();
   if (!text) return null;

package/src/isolation-runner.parsers.lib.mjs

@@ -73,13 +73,22 @@ export function parseStartCommandExecutionUuid(output) {
  * `--output-format json` is supported, or human-readable key/value text.
  * Keep the parser tolerant so completion monitoring survives either format.
  *
+ * start-command 0.33.0 (link-foundation/start#164, #165) added three additive
+ * hint fields to a finished record: `exitReason` (e.g.
+ * `memory-exhaustion (v8-heap-limit)` or `signal (SIGSEGV)`),
+ * `memoryExhausted` and `memoryExhaustedReason` (the log line carrying the
+ * evidence). They are hints, never verdicts — upstream never lets them change
+ * `status`, `exitCode` or `oomKilled` — and they are absent on older `$`
+ * binaries, so they are parsed as nullable and every consumer keeps its own
+ * log-marker classification as defense in depth (issue #2189).
+ *
  * @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}}
+ * @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, oomKilled: boolean|null, exitReason: string|null, memoryExhausted: boolean|null, memoryExhaustedReason: string|null, 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: '' };
+    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, exitReason: null, memoryExhausted: null, memoryExhaustedReason: null, raw: '' };
   }
   const normalizeBooleanField = value => {
     if (typeof value === 'boolean') return value;
@@ -112,6 +121,9 @@ export function parseSessionStatusOutput(output) {
       sessionName: data?.sessionName || data?.options?.sessionName || null,
       processIds,
       oomKilled: normalizeBooleanField(data?.oomKilled ?? data?.OOMKilled ?? data?.options?.oomKilled ?? data?.state?.oomKilled ?? data?.State?.OOMKilled),
+      exitReason: typeof data?.exitReason === 'string' && data.exitReason.trim() ? data.exitReason.trim() : null,
+      memoryExhausted: normalizeBooleanField(data?.memoryExhausted),
+      memoryExhaustedReason: typeof data?.memoryExhaustedReason === 'string' && data.memoryExhaustedReason.trim() ? data.memoryExhaustedReason.trim() : null,
       raw,
     };
   } catch {
@@ -123,7 +135,11 @@ export function parseSessionStatusOutput(output) {
       .find(line => line.trim() && !line.includes(' '))
       ?.trim() || null;
   const readField = name => {
-    const match = raw.match(new RegExp(`^\\s*${name}\\s+"?([^"\\n]+)"?\\s*$`, 'mi'));
+    // Links notation separates key and value with whitespace (`  exitReason x`);
+    // `--output-format text` uses a padded colon (`Exit Reason:       x`). Accept
+    // both — the colon is optional, so every existing camelCase lookup is
+    // unchanged and the text labels (which contain a space) become readable too.
+    const match = raw.match(new RegExp(`^\\s*${name}\\s*:?\\s+"?([^"\\n]+)"?\\s*$`, 'mi'));
     return match ? match[1].trim() : null;
   };
   const readBooleanField = name => normalizeBooleanField(readField(name));
@@ -154,6 +170,12 @@ export function parseSessionStatusOutput(output) {
     sessionName: readField('sessionName'),
     processIds,
     oomKilled: readBooleanField('oomKilled'),
+    // `--output-format text` labels the same three fields `Exit Reason:`,
+    // `Memory Exhausted:` and `Memory Evidence:`; links notation uses the camelCase
+    // keys. Accept both so the parser does not depend on the output format.
+    exitReason: readField('exitReason') || readField('Exit Reason'),
+    memoryExhausted: readBooleanField('memoryExhausted') ?? readBooleanField('Memory Exhausted'),
+    memoryExhaustedReason: readField('memoryExhaustedReason') || readField('Memory Evidence'),
     raw,
   };
 }
@@ -286,6 +308,10 @@ export function parseSessionListOutput(output) {
         isolation: isolationCandidate ? isolationCandidate.toLowerCase() : null,
         workingDirectory: data.workingDirectory || null,
         sessionName: data.sessionName || data.options?.sessionName || null,
+        // Additive 0.33.0 hints (link-foundation/start#164, #165); null on older `$`.
+        exitReason: typeof data.exitReason === 'string' && data.exitReason.trim() ? data.exitReason.trim() : null,
+        memoryExhausted: typeof data.memoryExhausted === 'boolean' ? data.memoryExhausted : null,
+        memoryExhaustedReason: typeof data.memoryExhaustedReason === 'string' && data.memoryExhaustedReason.trim() ? data.memoryExhaustedReason.trim() : null,
       };
     })
     .filter(Boolean);

package/src/isolation-runner.resume.lib.mjs

@@ -0,0 +1,263 @@
+/**
+ * `$ --resume` / `$ --resume-all` wrappers (start-command >= 0.33.0).
+ *
+ * Issue #2189 reported that a killed working session was only ever *offered*
+ * for resume, and that when Hive Mind did resume one it had to start a fresh
+ * isolated run — the container the work had happened in, with its clone, its
+ * build cache and its half-finished branch, was thrown away. The missing
+ * capability was filed upstream as link-foundation/start#162 and delivered in
+ * `start-command@0.33.0`:
+ *
+ *   - `$ --resume <id> -- <command>` re-enters an existing execution. For a
+ *     stopped docker session it commits the container filesystem and runs the
+ *     new command in a container derived from that snapshot, so the workspace
+ *     survives. The execution UUID is preserved, so `--status`, `--list` and
+ *     `--upload-log` keep addressing one logical session across restarts.
+ *   - `$ --resume-all` re-attaches a completion watcher to every execution
+ *     still marked running and reconciles the ones that ended unsupervised. It
+ *     never restarts work silently.
+ *
+ * Both are additive: a Hive Mind talking to an older `$` gets a clean
+ * `unsupported` result and the caller falls back to its previous behaviour.
+ * Neither wrapper throws.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/2189
+ * @see https://github.com/link-foundation/start/issues/162
+ */
+
+import { describeChildExit } from './child-exit.lib.mjs';
+import { findStartCommandBinary, getCommandStreamDollar, START_COMMAND_MISSING_ERROR } from './start-command-cli.lib.mjs';
+
+/** Strategies `$ --resume` can pick, mirroring upstream `ResumeMode`. */
+export const RESUME_MODES = Object.freeze({
+  DOCKER_START: 'docker-start',
+  DOCKER_SNAPSHOT: 'docker-snapshot',
+  RELAUNCH: 'relaunch',
+});
+
+/** Outcomes `$ --resume-all` reports per execution, mirroring `ResumeAllAction`. */
+export const RESUME_ALL_ACTIONS = Object.freeze({
+  REATTACHED: 'reattached',
+  RUNNING: 'running',
+  RECONCILED: 'reconciled',
+  UNKNOWN: 'unknown',
+});
+
+/**
+ * Does this `$` failure mean the verb does not exist yet?
+ *
+ * An older binary rejects the flag while parsing, long before it looks at the
+ * store. Distinguishing that from a real refusal ("session is still running")
+ * is what lets the caller degrade gracefully instead of reporting a bug.
+ *
+ * @param {string} message - stderr/message from the failed invocation
+ * @returns {boolean}
+ */
+export function isUnsupportedStartCommandVerb(message) {
+  const text = String(message || '').toLowerCase();
+  // 0.32.1 answers `$ --resume-all` with `Error: Unknown wrapper option:
+  // --resume-all` (verified against the pinned pre-0.33.0 binary), and other
+  // argument parsers word it differently; match the family, not one string.
+  return /unknown (\w+ )?(option|argument|flag)|unrecognized option|invalid option|no such option/.test(text);
+}
+
+/**
+ * Parse the `executionResume` block `$ --resume --output-format json` prints.
+ *
+ * Tolerates links notation too (`executionResume` followed by indented
+ * `key value` pairs), because an operator's `$` may default to it.
+ *
+ * @param {string} output - Raw stdout
+ * @returns {{uuid: string|null, mode: string|null, backend: string|null, sessionName: string|null, previousSessionName: string|null, snapshotImage: string|null, command: string|null, message: string|null}}
+ */
+export function parseExecutionResumeOutput(output) {
+  const empty = { uuid: null, mode: null, backend: null, sessionName: null, previousSessionName: null, snapshotImage: null, command: null, message: null };
+  const raw = (output || '').trim();
+  if (!raw) return empty;
+  const str = value => (typeof value === 'string' && value.trim() ? value.trim() : null);
+  try {
+    const parsed = JSON.parse(raw);
+    const data = Array.isArray(parsed) ? parsed[0] : parsed;
+    return {
+      uuid: str(data?.uuid),
+      mode: str(data?.mode),
+      backend: str(data?.backend),
+      sessionName: str(data?.sessionName),
+      previousSessionName: str(data?.previousSessionName),
+      snapshotImage: str(data?.snapshotImage),
+      command: str(data?.command),
+      message: str(data?.message),
+    };
+  } catch {
+    // Links notation — fall through.
+  }
+  // Links notation indents `key value`; `--output-format text` prints
+  // `Label:   value`. The optional colon covers both with one expression.
+  const readField = name => {
+    const match = raw.match(new RegExp(`^\\s*${name}\\s*:?\\s+"?([^"\\n]+)"?\\s*$`, 'mi'));
+    return str(match?.[1]);
+  };
+  return {
+    uuid: readField('uuid'),
+    mode: readField('mode') || readField('Resume Mode'),
+    backend: readField('backend'),
+    sessionName: readField('sessionName') || readField('Session Name'),
+    previousSessionName: readField('previousSessionName'),
+    snapshotImage: readField('snapshotImage'),
+    command: readField('command'),
+    message: readField('message'),
+  };
+}
+
+/**
+ * Parse the `executionResumeAll` block `$ --resume-all --output-format json`
+ * prints. Anything unparseable yields an empty list rather than a throw — a
+ * startup reconciliation must never be able to stop the bot from starting.
+ *
+ * @param {string} output - Raw stdout
+ * @returns {Array<{uuid: string|null, backend: string|null, sessionName: string|null, state: string|null, action: string|null, exitCode: number|null, message: string|null}>}
+ */
+export function parseExecutionResumeAllOutput(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 : [];
+  const str = value => (typeof value === 'string' && value.trim() ? value.trim() : null);
+  return records
+    .map(entry => {
+      if (!entry || typeof entry !== 'object') return null;
+      const exitCode = entry.exitCode === null || entry.exitCode === undefined ? null : Number(entry.exitCode);
+      return {
+        uuid: str(entry.uuid),
+        backend: str(entry.backend),
+        sessionName: str(entry.sessionName),
+        state: str(entry.state),
+        action: str(entry.action),
+        exitCode: Number.isFinite(exitCode) ? exitCode : null,
+        message: str(entry.message),
+      };
+    })
+    .filter(Boolean);
+}
+
+/**
+ * Normalize what `command-stream`'s `$` hands back for one invocation.
+ *
+ * `$` does *not* throw on a non-zero exit — it resolves with `code` set (checked
+ * against command-stream in experiments/issue-2189-start-command-resume.mjs).
+ * Reading only the resolved value would therefore report every refusal
+ * ("session is still running", "no execution found", "unknown wrapper option")
+ * as a successful resume. Both shapes are folded into one verdict here.
+ *
+ * @param {object|null} result - Resolved value from `$`
+ * @param {*} [error] - Rejection from `$`, when it threw instead
+ * @returns {{ok: boolean, stdout: string, message: string|null, unsupported: boolean}}
+ */
+function interpretStartCommandResult(result, error = null) {
+  const source = error || result || {};
+  const stdout = source.stdout?.toString?.().trim() || '';
+  const stderr = source.stderr?.toString?.().trim() || '';
+  const code = error ? (Number.isFinite(source.code) ? source.code : 1) : Number.isFinite(source.code) ? source.code : 0;
+  if (!error && code === 0) return { ok: true, stdout, message: null, unsupported: false };
+  // describeChildExit is the repository's single vocabulary for "how a child
+  // ended" (issue #2135); command-stream has already normalized a signalled
+  // exit to 128+signum by this point, so the code is all there is to say.
+  const message = stderr || source.message || describeChildExit({ command: 'start-command', code });
+  return { ok: false, stdout, message, unsupported: isUnsupportedStartCommandVerb(`${message}\n${stdout}`) };
+}
+
+/**
+ * Re-enter an existing execution via `$ --resume <identifier> [-- <command>]`.
+ *
+ * With a `command`, a stopped docker session is snapshotted and the command runs
+ * against that snapshot, so the work already on disk is preserved — this is the
+ * "re-enter the same container" half of issue #2189. Without one, the stored
+ * command is re-run in place.
+ *
+ * The command is passed as a single argument after `--`, exactly like the launch
+ * path does: start-command 0.33.0 preserves argv boundaries and runs a lone
+ * argument verbatim as a shell script, so no quoting is lost.
+ *
+ * @param {string} identifier - Execution UUID or session name
+ * @param {Object} [options]
+ * @param {string|null} [options.command] - Command to run against the resumed session
+ * @param {boolean} [options.verbose]
+ * @returns {Promise<{success: boolean, unsupported: boolean, uuid: string|null, mode: string|null, backend: string|null, sessionName: string|null, previousSessionName: string|null, snapshotImage: string|null, message: string|null, output: string, error: string|null}>}
+ */
+export async function resumeIsolatedSession(identifier, { command = null, verbose = false } = {}) {
+  const base = { success: false, unsupported: false, uuid: null, mode: null, backend: null, sessionName: null, previousSessionName: null, snapshotImage: null, message: null, output: '', error: null };
+  if (!identifier) return { ...base, error: 'No execution identifier was given to resume.' };
+
+  const binPath = await findStartCommandBinary();
+  if (!binPath) {
+    if (verbose) console.log('[VERBOSE] isolation-runner: cannot resume - $ binary not found');
+    return { ...base, unsupported: true, error: START_COMMAND_MISSING_ERROR };
+  }
+
+  try {
+    const $ = await getCommandStreamDollar();
+    const raw = command ? await $({ mirror: false })`${binPath} --resume ${identifier} --output-format json -- ${command}` : await $({ mirror: false })`${binPath} --resume ${identifier} --output-format json`;
+    const { ok, stdout, message, unsupported } = interpretStartCommandResult(raw);
+    if (!ok) {
+      if (verbose) console.log(`[VERBOSE] isolation-runner: $ --resume ${identifier} refused${unsupported ? ' (verb not supported by this $ build)' : ''}: ${message}`);
+      return { ...base, unsupported, output: stdout, error: message };
+    }
+    const parsed = parseExecutionResumeOutput(stdout);
+    if (verbose) {
+      console.log(`[VERBOSE] isolation-runner: $ --resume ${identifier} → mode=${parsed.mode || '(unknown)'} session=${parsed.sessionName || '(unknown)'} uuid=${parsed.uuid || '(unknown)'}`);
+    }
+    return { ...base, ...parsed, success: true, output: stdout };
+  } catch (error) {
+    const { stdout, message, unsupported } = interpretStartCommandResult(null, error);
+    if (verbose) console.log(`[VERBOSE] isolation-runner: $ --resume ${identifier} failed${unsupported ? ' (verb not supported by this $ build)' : ''}: ${message}`);
+    return { ...base, unsupported, output: stdout, error: message };
+  }
+}
+
+/**
+ * Reconcile every execution still marked running via `$ --resume-all`.
+ *
+ * Run at bot startup: the detached-docker completion watchers are children of
+ * the process that launched them, so a bot restart leaves every running
+ * container unsupervised — its exit would never be written to the log footer,
+ * which is one of the ways issue #2189's session stayed in limbo. `--resume-all`
+ * re-attaches a watcher to what is alive and finalizes what died meanwhile. It
+ * starts no work on its own.
+ *
+ * @param {Object} [options]
+ * @param {boolean} [options.verbose]
+ * @returns {Promise<{success: boolean, unsupported: boolean, executions: Array<Object>, output: string, error: string|null}>}
+ */
+export async function resumeAllIsolationSessions({ verbose = false } = {}) {
+  const base = { success: false, unsupported: false, executions: [], output: '', error: null };
+  const binPath = await findStartCommandBinary();
+  if (!binPath) {
+    if (verbose) console.log('[VERBOSE] isolation-runner: cannot run $ --resume-all - $ binary not found');
+    return { ...base, unsupported: true, error: START_COMMAND_MISSING_ERROR };
+  }
+
+  try {
+    const $ = await getCommandStreamDollar();
+    const raw = await $({ mirror: false })`${binPath} --resume-all --output-format json`;
+    const { ok, stdout, message, unsupported } = interpretStartCommandResult(raw);
+    if (!ok) {
+      if (verbose) console.log(`[VERBOSE] isolation-runner: $ --resume-all refused${unsupported ? ' (verb not supported by this $ build)' : ''}: ${message}`);
+      return { ...base, unsupported, output: stdout, error: message };
+    }
+    const executions = parseExecutionResumeAllOutput(stdout);
+    if (verbose) {
+      const summary = executions.map(entry => `${entry.action}:${entry.sessionName || entry.uuid}`).join(', ') || '(none)';
+      console.log(`[VERBOSE] isolation-runner: $ --resume-all reconciled ${executions.length} execution(s): ${summary}`);
+    }
+    return { ...base, success: true, executions, output: stdout };
+  } catch (error) {
+    const { stdout, message, unsupported } = interpretStartCommandResult(null, error);
+    if (verbose) console.log(`[VERBOSE] isolation-runner: $ --resume-all failed${unsupported ? ' (verb not supported by this $ build)' : ''}: ${message}`);
+    return { ...base, unsupported, output: stdout, error: message };
+  }
+}

package/src/locales/en.lino

@@ -508,6 +508,13 @@ en
       must
         be
           type "URL must be a GitHub {{allowedTypes}} (not {{type}})"
+      recovered """
+        ℹ️ I repaired the link before starting.
+
+        You sent: {{original}}
+        Using: {{used}}
+        Repaired: {{repairs}}
+      """
     language
       invalid """
         ❌ Invalid language. Supported: {{supported}}.

package/src/locales/hi.lino

@@ -508,6 +508,13 @@ hi
       must
         be
           type "URL GitHub {{allowedTypes}} होना चाहिए ({{type}} नहीं)"
+      recovered """
+        ℹ️ शुरू करने से पहले लिंक ठीक की गई।
+
+        आपने भेजा: {{original}}
+        उपयोग किया जा रहा है: {{used}}
+        ठीक किया गया: {{repairs}}
+      """
     language
       invalid """
         ❌ अमान्य भाषा। समर्थित: {{supported}}।

package/src/locales/ru.lino

@@ -508,6 +508,13 @@ ru
       must
         be
           type "URL должен быть GitHub {{allowedTypes}} (не {{type}})"
+      recovered """
+        ℹ️ Ссылка была исправлена перед запуском.
+
+        Вы отправили: {{original}}
+        Используется: {{used}}
+        Исправлено: {{repairs}}
+      """
     language
       invalid """
         ❌ Неверный язык. Поддерживаются: {{supported}}.

package/src/locales/zh.lino

@@ -508,6 +508,13 @@ zh
       must
         be
           type "URL 必须是 GitHub {{allowedTypes}}（不是 {{type}}）"
+      recovered """
+        ℹ️ 开始前已修复链接。
+
+        您发送的：{{original}}
+        实际使用：{{used}}
+        修复内容：{{repairs}}
+      """
     language
       invalid """
         ❌ 语言无效。支持的语言：{{supported}}。

package/src/pull-request-changes.lib.mjs

@@ -106,7 +106,7 @@ const measureDiff = diff => {
     section = null;
   };
 
-  for (let start = 0; start < diff.length; ) {
+  for (let start = 0; start < diff.length;) {
     let end = diff.indexOf('\n', start);
     if (end === -1) end = diff.length;
     const line = diff.slice(start, end);

package/src/session-kill-diagnostics.lib.mjs

@@ -54,6 +54,16 @@ export const KILL_DIAGNOSTICS_LOG_BYTES = 1024 * 1024;
  */
 export const HEAP_EXHAUSTED_PERCENT = 90;
 
+/**
+ * Prefix start-command 0.33.0 puts on every `exitReason` that reports memory
+ * exhaustion, whatever the mechanism — `memory-exhaustion (v8-heap-limit)`,
+ * `memory-exhaustion (kernel-oom-killer)`, `memory-exhaustion (go-runtime)`,
+ * `memory-exhaustion (allocation-failure)`. Matching the prefix rather than the
+ * exact strings means a new upstream mechanism is classified correctly without
+ * a Hive Mind release. See link-foundation/start#164 and #165.
+ */
+export const UPSTREAM_MEMORY_EXHAUSTION_PREFIX = 'memory-exhaustion';
+
 /** Disk is considered full at or above this used percentage… */
 export const DISK_FULL_USED_PERCENT = 95;
 /** …or below this much free space, whichever triggers first. */
@@ -268,9 +278,12 @@ function describeDisk(disk, timestamp) {
  * @param {number|null} [params.exitCode]
  * @param {Object|null} [params.system] - collectSystemKillDiagnostics() result
  * @param {boolean} [params.stopRequestedByUser] - The operator asked for the stop
+ * @param {boolean|null} [params.reportedMemoryExhausted] - `$ --status` `memoryExhausted` (start-command >= 0.33.0)
+ * @param {string|null} [params.reportedMemoryExhaustedReason] - `$ --status` `memoryExhaustedReason` (the evidence line)
+ * @param {string|null} [params.reportedExitReason] - `$ --status` `exitReason` hint, e.g. `memory-exhaustion (v8-heap-limit)`
  * @returns {{cause: string, summary: string, evidence: string[], memory: Object|null, disk: Object|null, victims: Array}}
  */
-export function describeKillCause({ logText = null, resourceMarkers = null, oomKilled = false, exitCode = null, system = null, stopRequestedByUser = false } = {}) {
+export function describeKillCause({ logText = null, resourceMarkers = null, oomKilled = false, exitCode = null, system = null, stopRequestedByUser = false, reportedMemoryExhausted = null, reportedMemoryExhaustedReason = null, reportedExitReason = null } = {}) {
   const parsed = resourceMarkers || (logText ? parseResourceMarkers(logText) : { markers: [], byPhase: {} });
   const memoryMarker = selectLastMemoryResourceMarker(parsed);
   const heapMarker = selectLastHeapResourceMarker(parsed);
@@ -310,6 +323,30 @@ export function describeKillCause({ logText = null, resourceMarkers = null, oomK
     evidence.push(`the ${fatalMemoryMarker.runtime} runtime aborted on its own heap limit: \`${fatalMemoryMarker.line}\` (a self-abort is invisible to \`docker inspect\` and to cgroup OOM counters)`);
   }
 
+  // Issue #2189 also went upstream: start-command 0.33.0 (link-foundation/start
+  // #164, #165) performs the same tail scan inside `$` and reports it as
+  // `memoryExhausted` / `memoryExhaustedReason` / `exitReason`. Consuming it
+  // catches the case our own scan cannot: the fatal line scrolled out of the
+  // bounded window we read, but `$` saw it when the command exited. The local
+  // scan stays as defense in depth — these fields are absent on an older `$`.
+  const reportedExitReasonText = typeof reportedExitReason === 'string' && reportedExitReason.trim() ? reportedExitReason.trim() : null;
+  const reportedMemoryExhaustion = abnormalExit && (reportedMemoryExhausted === true || (reportedExitReasonText !== null && reportedExitReasonText.startsWith(UPSTREAM_MEMORY_EXHAUSTION_PREFIX)));
+  // `memory-exhaustion (v8-heap-limit)` → `v8-heap-limit`: the prefix is already
+  // said in words by the surrounding sentence, so only the mechanism is new.
+  const reportedMechanism =
+    reportedMemoryExhaustion && reportedExitReasonText
+      ? reportedExitReasonText
+          .slice(UPSTREAM_MEMORY_EXHAUSTION_PREFIX.length)
+          .trim()
+          .replace(/^\((.*)\)$/, '$1') || null
+      : null;
+  if (reportedMemoryExhaustion) {
+    const detail = reportedMemoryExhaustedReason ? `: \`${reportedMemoryExhaustedReason}\`` : '';
+    evidence.push(`\`$ --status\` reports memory exhaustion${reportedMechanism ? ` (\`${reportedMechanism}\`)` : ''}${detail}`);
+  } else if (reportedExitReasonText && abnormalExit) {
+    evidence.push(`\`$ --status\` reports \`exitReason = ${reportedExitReasonText}\``);
+  }
+
   const ratio = memoryRatio(memory);
   const memoryExhausted = ratio !== null && ratio <= MEMORY_EXHAUSTED_AVAILABLE_RATIO;
   // A heap already at the limit is only evidence of a kill when the session
@@ -322,7 +359,7 @@ export function describeKillCause({ logText = null, resourceMarkers = null, oomK
   let cause = KILL_CAUSE_UNKNOWN;
   if (stopRequestedByUser) {
     cause = KILL_CAUSE_FORCED_KILL;
-  } else if (victims.length > 0 || (cgroupOomKills !== null && cgroupOomKills > 0) || oomKilled || memoryExhausted || fatalMemoryMarker || heapExhausted) {
+  } else if (victims.length > 0 || (cgroupOomKills !== null && cgroupOomKills > 0) || oomKilled || memoryExhausted || fatalMemoryMarker || heapExhausted || reportedMemoryExhaustion) {
     cause = KILL_CAUSE_OUT_OF_MEMORY;
   } else if (diskFull) {
     cause = KILL_CAUSE_DISK_FULL;
@@ -340,6 +377,11 @@ export function describeKillCause({ logText = null, resourceMarkers = null, oomK
     // Same shape as the fatal-marker case, but reconstructed from telemetry when
     // the fatal line itself was lost (truncated tail, killed before flushing).
     summary = `out of memory — the runtime's own heap was exhausted: ${heapLine}${memoryLine ? ` (host memory was fine: ${memoryLine})` : ''}`;
+  } else if (cause === KILL_CAUSE_OUT_OF_MEMORY && reportedMemoryExhaustion && victims.length === 0 && !oomKilled && !(cgroupOomKills > 0) && !memoryExhausted) {
+    // Only `$` saw the evidence (our bounded window missed the fatal line).
+    // Quote what it saw rather than falling back to the host-memory phrasing,
+    // which would again read as a contradiction on a healthy machine.
+    summary = `out of memory — start-command reported memory exhaustion${reportedMechanism ? ` (${reportedMechanism})` : ''}${reportedMemoryExhaustedReason ? `: \`${reportedMemoryExhaustedReason}\`` : ''}${memoryLine ? ` (host memory was fine: ${memoryLine})` : ''}`;
   } else if (cause === KILL_CAUSE_OUT_OF_MEMORY) {
     const victim = victims.length > 0 ? `, kernel OOM killer terminated \`${victims[victims.length - 1].comm || 'unknown'}\` (pid ${victims[victims.length - 1].pid ?? '?'})` : '';
     summary = `out of memory${memoryLine ? ` — ${memoryLine}` : ''}${victim}`;
@@ -352,7 +394,7 @@ export function describeKillCause({ logText = null, resourceMarkers = null, oomK
     summary = 'unknown — no resource marker, cgroup counter or kernel OOM report was available';
   }
 
-  return { cause, summary, evidence, memory, heap: heapMemory, heapUsedPercent, disk, victims, fatalMemoryMarker };
+  return { cause, summary, evidence, memory, heap: heapMemory, heapUsedPercent, disk, victims, fatalMemoryMarker, reportedMemoryExhaustion, reportedExitReason: reportedExitReasonText };
 }
 
 /**
@@ -429,7 +471,7 @@ export function formatKillResumeSection({ sessionId = null, attempt = null, maxA
  * @param {Object} [options]
  * @returns {Promise<{section: string, diagnosis: Object|null}>}
  */
-export async function buildKillDiagnosticsSection(logPath, { verbose = false, readFile = fsPromises.readFile, maxLogBytes = KILL_DIAGNOSTICS_LOG_BYTES, oomKilled = false, exitCode = null, stopRequestedByUser = false, locale = null, collectSystem = collectSystemKillDiagnostics } = {}) {
+export async function buildKillDiagnosticsSection(logPath, { verbose = false, readFile = fsPromises.readFile, maxLogBytes = KILL_DIAGNOSTICS_LOG_BYTES, oomKilled = false, exitCode = null, stopRequestedByUser = false, locale = null, collectSystem = collectSystemKillDiagnostics, reportedMemoryExhausted = null, reportedMemoryExhaustedReason = null, reportedExitReason = null } = {}) {
   try {
     let logText = '';
     if (logPath) {
@@ -441,7 +483,7 @@ export async function buildKillDiagnosticsSection(logPath, { verbose = false, re
       logText = await readLogTextBounded(logPath, { readFile, maxBytes: maxLogBytes, verbose });
     }
     const system = await collectSystem({ verbose });
-    const diagnosis = describeKillCause({ logText, oomKilled, exitCode, system, stopRequestedByUser });
+    const diagnosis = describeKillCause({ logText, oomKilled, exitCode, system, stopRequestedByUser, reportedMemoryExhausted, reportedMemoryExhaustedReason, reportedExitReason });
     if (verbose) console.log(`[VERBOSE] kill-diagnostics: cause=${diagnosis.cause} — ${diagnosis.summary}`);
     return { section: formatKillDiagnosticsSection(diagnosis, { locale }), diagnosis };
   } catch (error) {