@algosuite/vo-mcp 0.2.0-beta.67 → 0.2.0-beta.69

package/dist/runner-cli.js

@@ -314,21 +314,21 @@ function backupConfigOnce(configPath) {
   copyFileSync(configPath, backupPath);
   return backupPath;
 }
-function writeFileAtomic(path22, content) {
-  sweepStaleTempFiles(path22);
-  const temp = `${path22}.vo-mcp-tmp-${process.pid}-${Date.now()}`;
+function writeFileAtomic(path23, content) {
+  sweepStaleTempFiles(path23);
+  const temp = `${path23}.vo-mcp-tmp-${process.pid}-${Date.now()}`;
   try {
     writeFileSync2(temp, content, { encoding: "utf8", mode: 384 });
-    if (existsSync3(path22)) {
+    if (existsSync3(path23)) {
       try {
-        chmodSync2(temp, statSync(path22).mode & 511);
+        chmodSync2(temp, statSync(path23).mode & 511);
       } catch {
       }
     }
     let lastErr = null;
     for (let attempt = 0; attempt < RENAME_RETRIES; attempt += 1) {
       try {
-        renameSync(temp, path22);
+        renameSync(temp, path23);
         return;
       } catch (err) {
         lastErr = err;
@@ -337,7 +337,7 @@ function writeFileAtomic(path22, content) {
         sleepSync(RENAME_RETRY_MS);
       }
     }
-    writeFileSync2(path22, content, "utf8");
+    writeFileSync2(path23, content, "utf8");
     try {
       unlinkSync2(temp);
     } catch {
@@ -503,8 +503,8 @@ function tablePath(line) {
 function tableSections(lines) {
   const starts = [];
   for (let index = 0; index < lines.length; index += 1) {
-    const path22 = tablePath(lines[index] ?? "");
-    if (path22) starts.push({ path: path22, start: index });
+    const path23 = tablePath(lines[index] ?? "");
+    if (path23) starts.push({ path: path23, start: index });
   }
   return starts.map((section, index) => ({
     ...section,
@@ -696,11 +696,11 @@ function resolveLinuxConfigHome(home, env2) {
   const configured = env2["XDG_CONFIG_HOME"]?.trim();
   return configured && isAbsolute2(configured) ? configured : join5(home, ".config");
 }
-function launcherIsCurrent(path22, desiredContent, label, log2) {
-  if (!existsSync6(path22)) return false;
-  if (readFileSync5(path22, "utf8") === desiredContent) return true;
-  const backupPath = `${path22}.backup-${Date.now()}`;
-  copyFileSync2(path22, backupPath);
+function launcherIsCurrent(path23, desiredContent, label, log2) {
+  if (!existsSync6(path23)) return false;
+  if (readFileSync5(path23, "utf8") === desiredContent) return true;
+  const backupPath = `${path23}.backup-${Date.now()}`;
+  copyFileSync2(path23, backupPath);
   log2(`  Backed up existing ${label} to: ${backupPath}`);
   return false;
 }
@@ -916,17 +916,17 @@ function resolveDesktopConfigPath(home, plat, appData) {
   }
   return join6(home, ".config", "Claude", "claude_desktop_config.json");
 }
-function readClaudeConfig(path22) {
-  if (!existsSync7(path22)) return { kind: "absent", config: {}, mtimeMs: null };
+function readClaudeConfig(path23) {
+  if (!existsSync7(path23)) return { kind: "absent", config: {}, mtimeMs: null };
   for (let attempt = 0; attempt < 3; attempt += 1) {
-    const before = statSync3(path22).mtimeMs;
+    const before = statSync3(path23).mtimeMs;
     let raw;
     try {
-      raw = readFileSync6(path22, "utf8");
+      raw = readFileSync6(path23, "utf8");
     } catch {
       return { kind: "invalid", config: {}, mtimeMs: before };
     }
-    if (!existsSync7(path22) || statSync3(path22).mtimeMs !== before) continue;
+    if (!existsSync7(path23) || statSync3(path23).mtimeMs !== before) continue;
     const text = raw.replace(/^\uFEFF/u, "");
     if (!text.trim()) return { kind: "empty", config: {}, mtimeMs: before };
     try {
@@ -938,9 +938,9 @@ function readClaudeConfig(path22) {
   }
   return { kind: "invalid", config: {}, mtimeMs: null };
 }
-function writeClaudeConfig(path22, config) {
-  mkdirSync6(dirname4(path22), { recursive: true });
-  writeFileAtomic(path22, `${JSON.stringify(config, null, 2)}
+function writeClaudeConfig(path23, config) {
+  mkdirSync6(dirname4(path23), { recursive: true });
+  writeFileAtomic(path23, `${JSON.stringify(config, null, 2)}
 `);
 }
 function carriedEntryKeys(entry) {
@@ -1344,6 +1344,7 @@ var init_pnpm_link_detach = __esm({
 
 // src/runner/process-runner.mjs
 import { spawn } from "node:child_process";
+import path2 from "node:path";
 function sleepMs(ms) {
   if (ms <= 0) return Promise.resolve();
   return new Promise((resolve3) => setTimeout(resolve3, ms));
@@ -1351,15 +1352,25 @@ function sleepMs(ms) {
 async function spawnUtility(command, args, timeoutMs) {
   return await new Promise((resolve3) => {
     let settled = false;
+    let stdout = "";
+    let stderr = "";
     const finish = (result) => {
       if (settled) return;
       settled = true;
-      resolve3(result);
+      resolve3({ stdout, stderr, ...result });
     };
     const child = spawn(command, args, {
-      stdio: "ignore",
+      stdio: ["ignore", "pipe", "pipe"],
       windowsHide: true
     });
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      stdout = `${stdout}${chunk}`.slice(-MAX_UTILITY_OUTPUT_CHARS);
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr = `${stderr}${chunk}`.slice(-MAX_UTILITY_OUTPUT_CHARS);
+    });
     let timer = null;
     if (timeoutMs > 0) {
       timer = setTimeout(() => {
@@ -1381,27 +1392,48 @@ async function spawnUtility(command, args, timeoutMs) {
     });
   });
 }
+function windowsTaskkillExe(env2 = process.env) {
+  const systemRoot = env2.SystemRoot || env2.WINDIR || "C:\\Windows";
+  return path2.win32.join(systemRoot, "System32", "taskkill.exe");
+}
 async function killProcessTreeDefault(pid, options = {}) {
   if (!Number.isInteger(pid) || pid <= 0) return;
-  if (process.platform === "win32") {
-    await spawnUtility(
-      "taskkill",
+  if ((options.platform || process.platform) === "win32") {
+    const utilityRunner = options.spawnUtility || spawnUtility;
+    return await utilityRunner(
+      windowsTaskkillExe(options.env || process.env),
       ["/pid", String(pid), "/t", "/f"],
       options.timeoutMs ?? DEFAULT_FORCE_KILL_TIMEOUT_MS
     );
-    return;
   }
   try {
     process.kill(pid, "SIGKILL");
   } catch {
   }
 }
+function cleanupResultError(result) {
+  if (!result || typeof result !== "object") return null;
+  if (result.error) {
+    return result.error instanceof Error ? result.error : new Error(String(result.error));
+  }
+  const detail = String(result.stderr || result.stdout || "").trim().replace(/\s+/g, " ").slice(-400);
+  if (result.timedOut) {
+    return new Error(`process-tree cleanup utility timed out${detail ? `: ${detail}` : ""}`);
+  }
+  if ("status" in result && result.status !== 0) {
+    return new Error(
+      `process-tree cleanup utility exited with status ${String(result.status)}${detail ? `: ${detail}` : ""}`
+    );
+  }
+  return null;
+}
 async function runProcess(command, args = [], options = {}) {
   const timeoutMs = options.timeoutMs ?? DEFAULT_PROCESS_TIMEOUT_MS;
   const killGraceMs = options.killGraceMs ?? DEFAULT_KILL_GRACE_MS;
   const forceKillTimeoutMs = options.forceKillTimeoutMs ?? DEFAULT_FORCE_KILL_TIMEOUT_MS;
+  const platform4 = options.platform || process.platform;
   const spawnImpl = options.spawnImpl || spawn;
-  const killProcessTree2 = options.killProcessTree || killProcessTreeDefault;
+  const killProcessTree2 = options.killProcessTree || ((pid, killOptions) => killProcessTreeDefault(pid, { ...killOptions, platform: platform4 }));
   const spawnOptions = {
     cwd: options.cwd,
     env: options.env,
@@ -1417,6 +1449,9 @@ async function runProcess(command, args = [], options = {}) {
     let graceTimeout = null;
     let forceKillTimeout = null;
     let child = null;
+    let parentExit = null;
+    let cleanupInFlight = false;
+    let pendingTerminalResult = null;
     const clearTimers = () => {
       if (timeout) clearTimeout(timeout);
       if (graceTimeout) clearTimeout(graceTimeout);
@@ -1428,8 +1463,33 @@ async function runProcess(command, args = [], options = {}) {
       clearTimers();
       resolve3({ stdout, stderr, timedOut, ...result });
     };
+    const handleTerminalResult = (result) => {
+      const normalizedResult = timedOut && typeof result.status === "number" ? { ...result, exitStatus: result.status, status: null } : result;
+      if (timedOut && cleanupInFlight) {
+        pendingTerminalResult = normalizedResult;
+        return;
+      }
+      finish(normalizedResult);
+    };
+    const exitedParentOwnershipError = () => {
+      return new Error(
+        `process parent exited before timeout cleanup, but inherited stdio remained open; PID ${String(child?.pid ?? "unknown")} may no longer belong to the spawned process`
+      );
+    };
     const beginForceKill = () => {
-      if (settled || !child?.pid) return;
+      if (settled) return;
+      if (parentExit) {
+        finish({
+          status: null,
+          error: exitedParentOwnershipError()
+        });
+        return;
+      }
+      if (!Number.isInteger(child?.pid) || child.pid <= 0) {
+        finish({ status: null, error: new Error("process timed out before a process-tree cleanup PID was available") });
+        return;
+      }
+      cleanupInFlight = true;
       forceKillTimeout = setTimeout(() => {
         finish({
           status: null,
@@ -1437,17 +1497,36 @@ async function runProcess(command, args = [], options = {}) {
         });
       }, forceKillTimeoutMs);
       forceKillTimeout.unref?.();
-      void (async () => {
-        try {
-          await killProcessTree2(child.pid, { timeoutMs: forceKillTimeoutMs });
-        } catch (error) {
+      const cleanupPromise = Promise.resolve().then(
+        () => {
+          if (settled) return void 0;
+          if (parentExit) throw exitedParentOwnershipError();
+          return killProcessTree2(child.pid, { timeoutMs: forceKillTimeoutMs });
+        }
+      );
+      void cleanupPromise.then(
+        (result) => {
+          const error = cleanupResultError(result);
+          cleanupInFlight = false;
+          if (error) {
+            finish({ status: null, error });
+            return;
+          }
+          if (pendingTerminalResult) finish(pendingTerminalResult);
+        },
+        (error) => {
+          cleanupInFlight = false;
           finish({ status: null, error });
         }
-      })();
+      );
     };
     const beginTimeout = () => {
       if (settled || !child) return;
       timedOut = true;
+      if (platform4 === "win32") {
+        beginForceKill();
+        return;
+      }
       try {
         child.kill("SIGTERM");
       } catch (error) {
@@ -1473,8 +1552,11 @@ async function runProcess(command, args = [], options = {}) {
       stderr += chunk;
       if (typeof options.onStderr === "function") options.onStderr(chunk);
     });
-    child.on("error", (error) => finish({ status: null, error }));
-    child.on("close", (code, signal) => finish({ status: code, signal }));
+    child.on("error", (error) => handleTerminalResult({ status: null, error }));
+    child.on("exit", (code, signal) => {
+      parentExit = { code, signal };
+    });
+    child.on("close", (code, signal) => handleTerminalResult({ status: code, signal }));
     if (timeoutMs > 0) {
       timeout = setTimeout(beginTimeout, timeoutMs);
       timeout.unref?.();
@@ -1499,13 +1581,14 @@ function summarizeProcessFailure(result, options = {}) {
   const timedOutText = result?.timedOut ? "timed out" : "";
   return [errorText, timedOutText, tail].filter(Boolean).join("; ").slice(0, limit) || `command exited with status ${String(result?.status ?? "unknown")}`;
 }
-var DEFAULT_PROCESS_TIMEOUT_MS, DEFAULT_KILL_GRACE_MS, DEFAULT_FORCE_KILL_TIMEOUT_MS;
+var DEFAULT_PROCESS_TIMEOUT_MS, DEFAULT_KILL_GRACE_MS, DEFAULT_FORCE_KILL_TIMEOUT_MS, MAX_UTILITY_OUTPUT_CHARS;
 var init_process_runner = __esm({
   "src/runner/process-runner.mjs"() {
     "use strict";
     DEFAULT_PROCESS_TIMEOUT_MS = 10 * 60 * 1e3;
     DEFAULT_KILL_GRACE_MS = 5e3;
     DEFAULT_FORCE_KILL_TIMEOUT_MS = 15e3;
+    MAX_UTILITY_OUTPUT_CHARS = 4096;
   }
 });
 
@@ -1616,14 +1699,18 @@ async function addWorktreeWithRetry({
   sleep: sleep3 = sleepMs,
   removeDir = async (target) => {
     await fsp2.rm(target, { recursive: true, force: true });
-  }
+  },
+  baseRef = "origin/main"
 }) {
+  if (baseRef !== "origin/main" && !/^[0-9a-f]{40}$/u.test(baseRef)) {
+    throw new Error("worktree base ref must be origin/main or an exact lowercase SHA");
+  }
   const maxAttempts = Math.max(1, Math.floor(attempts));
   let result = null;
   for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
     result = await runner(
       "git",
-      ["worktree", "add", "-b", branchName, worktreeDir, "origin/main"],
+      ["worktree", "add", "-b", branchName, worktreeDir, baseRef],
       { cwd: root, timeoutMs }
     );
     if (result.status === 0 && await pathExistsFn(worktreeDir)) {
@@ -1648,7 +1735,7 @@ var init_worktree_add = __esm({
 // src/runner/pnpm-canonical-health.mjs
 import fs from "node:fs";
 import fsp3 from "node:fs/promises";
-import path2 from "node:path";
+import path3 from "node:path";
 function readJsonFile(file) {
   if (!fs.existsSync(file)) return null;
   try {
@@ -1658,7 +1745,7 @@ function readJsonFile(file) {
   }
 }
 function packageJsonAt(root) {
-  return readJsonFile(path2.join(root, "package.json"));
+  return readJsonFile(path3.join(root, "package.json"));
 }
 function dependencyNamesForPackage(root) {
   const manifest = packageJsonAt(root);
@@ -1670,7 +1757,7 @@ function dependencyNamesForPackage(root) {
   ])].sort();
 }
 function packageEntryPath(nodeModulesDir, packageName) {
-  return path2.join(nodeModulesDir, ...String(packageName || "").split("/"));
+  return path3.join(nodeModulesDir, ...String(packageName || "").split("/"));
 }
 function rootFsApi() {
   return {
@@ -1699,7 +1786,7 @@ async function inspectDependencyEntry(nodeModulesDir, packageName, fsApi) {
   } catch {
     return { issue: `missing or dangling dependency link: ${entry}` };
   }
-  const packageJsonPath = path2.join(resolved, "package.json");
+  const packageJsonPath = path3.join(resolved, "package.json");
   if (!await pathExists3(packageJsonPath, fsApi)) {
     return { issue: `dependency target is missing package.json: ${entry} -> ${resolved}` };
   }
@@ -1711,11 +1798,11 @@ async function inspectDependencyEntry(nodeModulesDir, packageName, fsApi) {
   return { issue: null };
 }
 function representativePackages(root, linkedWorkspaceDirs, sampleLimit) {
-  const packages = [{ nodeModulesDir: path2.join(root, "node_modules"), packageRoot: root }];
+  const packages = [{ nodeModulesDir: path3.join(root, "node_modules"), packageRoot: root }];
   for (const relativeDir of linkedWorkspaceDirs) {
     packages.push({
-      nodeModulesDir: path2.join(root, relativeDir, "node_modules"),
-      packageRoot: path2.join(root, relativeDir)
+      nodeModulesDir: path3.join(root, relativeDir, "node_modules"),
+      packageRoot: path3.join(root, relativeDir)
     });
   }
   const representatives = [];
@@ -1727,7 +1814,7 @@ function representativePackages(root, linkedWorkspaceDirs, sampleLimit) {
   return representatives;
 }
 function canonicalNodeModulesQuarantineRoot(root) {
-  return path2.join(root, ".agent-worktrees", QUARANTINE_DIRNAME);
+  return path3.join(root, ".agent-worktrees", QUARANTINE_DIRNAME);
 }
 async function inspectCanonicalNodeModulesHealth({
   root,
@@ -1738,8 +1825,8 @@ async function inspectCanonicalNodeModulesHealth({
   sampleLimit = DEFAULT_SAMPLE_LIMIT
 }) {
   const issues = [];
-  const nodeModulesDir = path2.join(root, "node_modules");
-  const markerPath = path2.join(nodeModulesDir, ".vo-deps-state.json");
+  const nodeModulesDir = path3.join(root, "node_modules");
+  const markerPath = path3.join(nodeModulesDir, ".vo-deps-state.json");
   if (!await pathExists3(nodeModulesDir, fsApi)) {
     issues.push(`missing root node_modules: ${nodeModulesDir}`);
   } else {
@@ -1748,8 +1835,8 @@ async function inspectCanonicalNodeModulesHealth({
       issues.push(`root node_modules must be a real directory: ${nodeModulesDir}`);
     }
   }
-  if (!await pathExists3(path2.join(nodeModulesDir, ".pnpm"), fsApi)) {
-    issues.push(`missing root .pnpm store view: ${path2.join(nodeModulesDir, ".pnpm")}`);
+  if (!await pathExists3(path3.join(nodeModulesDir, ".pnpm"), fsApi)) {
+    issues.push(`missing root .pnpm store view: ${path3.join(nodeModulesDir, ".pnpm")}`);
   }
   if (requireMarker) {
     try {
@@ -1762,7 +1849,7 @@ async function inspectCanonicalNodeModulesHealth({
     }
   }
   for (const relativeDir of linkedWorkspaceDirs) {
-    const workspaceNodeModules = path2.join(root, relativeDir, "node_modules");
+    const workspaceNodeModules = path3.join(root, relativeDir, "node_modules");
     if (!await pathExists3(workspaceNodeModules, fsApi)) {
       issues.push(`missing workspace node_modules: ${workspaceNodeModules}`);
       continue;
@@ -1785,17 +1872,17 @@ async function inspectCanonicalNodeModulesHealth({
 async function quarantineCanonicalNodeModules(root, issues, options = {}) {
   const fsApi = options.fsApi || rootFsApi();
   const logger = options.logger || console.error;
-  const nodeModulesDir = path2.join(root, "node_modules");
+  const nodeModulesDir = path3.join(root, "node_modules");
   const quarantineRoot = canonicalNodeModulesQuarantineRoot(root);
   if (!await pathExists3(nodeModulesDir, fsApi)) return null;
   await fsApi.mkdir(quarantineRoot, { recursive: true });
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   let attempt = 0;
   for (; ; ) {
-    const quarantinePath = path2.join(quarantineRoot, `node_modules-${stamp}-${process.pid}-${attempt}`);
+    const quarantinePath = path3.join(quarantineRoot, `node_modules-${stamp}-${process.pid}-${attempt}`);
     try {
       await fsApi.rename(nodeModulesDir, quarantinePath);
-      const metadataPath = path2.join(quarantinePath, ".vo-runner-quarantine.json");
+      const metadataPath = path3.join(quarantinePath, ".vo-runner-quarantine.json");
       await fsApi.writeFile(metadataPath, `${JSON.stringify({
         issues,
         originalPath: nodeModulesDir,
@@ -1821,22 +1908,22 @@ var init_pnpm_canonical_health = __esm({
 
 // src/runner/pnpm-command.mjs
 import fs2 from "node:fs";
-import path3 from "node:path";
+import path4 from "node:path";
 function isWindowsDriveOrUnc(value) {
   return WINDOWS_DRIVE_OR_UNC_RE.test(String(value || ""));
 }
 function portableDirname(value) {
-  if (isWindowsDriveOrUnc(value)) return path3.win32.dirname(value);
-  if (path3.posix.isAbsolute(value)) return path3.posix.dirname(value);
-  return path3.dirname(value);
+  if (isWindowsDriveOrUnc(value)) return path4.win32.dirname(value);
+  if (path4.posix.isAbsolute(value)) return path4.posix.dirname(value);
+  return path4.dirname(value);
 }
 function portableJoin(root, ...segments) {
-  if (isWindowsDriveOrUnc(root)) return path3.win32.join(root, ...segments);
-  if (path3.posix.isAbsolute(root)) return path3.posix.join(root, ...segments);
-  return path3.join(root, ...segments);
+  if (isWindowsDriveOrUnc(root)) return path4.win32.join(root, ...segments);
+  if (path4.posix.isAbsolute(root)) return path4.posix.join(root, ...segments);
+  return path4.join(root, ...segments);
 }
 function readPackageManager(root) {
-  const packagePath = path3.join(root, "package.json");
+  const packagePath = path4.join(root, "package.json");
   if (!fs2.existsSync(packagePath)) return "";
   try {
     return String(JSON.parse(fs2.readFileSync(packagePath, "utf8"))?.packageManager || "").trim();
@@ -1856,13 +1943,13 @@ function pnpmSelector(root) {
   const packageManager = readPackageManager(root);
   const version = validatedPnpmVersionToken(root);
   if (packageManager && !version) {
-    throw new Error(`[vo-mcp runner] invalid pnpm packageManager token in ${path3.join(root, "package.json")}`);
+    throw new Error(`[vo-mcp runner] invalid pnpm packageManager token in ${path4.join(root, "package.json")}`);
   }
   return version ? `pnpm@${version}` : "pnpm";
 }
 function whereResults(result) {
   if (result?.status !== 0) return [];
-  return String(result.stdout || "").split(/\r?\n/u).map((line) => line.trim()).filter((line) => path3.win32.isAbsolute(line));
+  return String(result.stdout || "").split(/\r?\n/u).map((line) => line.trim()).filter((line) => path4.win32.isAbsolute(line));
 }
 async function resolveWindowsNativeCommand(command, runner) {
   const result = await runner("where", [command], { timeoutMs: 1e4 });
@@ -1874,7 +1961,7 @@ function trustedCorepackCandidates(options) {
   const roots = [portableDirname(execPath)];
   for (const key of ["ProgramW6432", "ProgramFiles", "ProgramFiles(x86)"]) {
     const programFiles = String(env2[key] || "").trim();
-    if (isWindowsDriveOrUnc(programFiles) || path3.posix.isAbsolute(programFiles)) {
+    if (isWindowsDriveOrUnc(programFiles) || path4.posix.isAbsolute(programFiles)) {
       roots.push(portableJoin(programFiles, "nodejs"));
     }
   }
@@ -1953,7 +2040,7 @@ var init_pnpm_command = __esm({
 
 // src/runner/pnpm-materialize.mjs
 import fsp4 from "node:fs/promises";
-import path4 from "node:path";
+import path5 from "node:path";
 function linkType() {
   return process.platform === "win32" ? "junction" : "dir";
 }
@@ -1965,13 +2052,13 @@ async function realpathOrThrow(target, fsApi) {
   }
 }
 function shouldMapToWorktree(resolvedTarget, canonicalRoot) {
-  const relative = path4.relative(canonicalRoot, resolvedTarget).replace(/\\/g, "/");
+  const relative = path5.relative(canonicalRoot, resolvedTarget).replace(/\\/g, "/");
   return Boolean(relative && !relative.startsWith("..") && !relative.split("/").includes("node_modules"));
 }
 async function resolveEntryTarget(sourceEntry, canonicalRoot, worktreeRoot, fsApi) {
   const resolved = await realpathOrThrow(sourceEntry, fsApi);
   if (!shouldMapToWorktree(resolved, canonicalRoot)) return resolved;
-  const mapped = path4.join(worktreeRoot, path4.relative(canonicalRoot, resolved));
+  const mapped = path5.join(worktreeRoot, path5.relative(canonicalRoot, resolved));
   if (!await fsApi.pathExists(mapped)) {
     throw new Error(`[vo-mcp runner] task-local workspace target is missing for dependency link: ${mapped}`);
   }
@@ -1982,7 +2069,7 @@ async function ensureLinkedDirectory(source, target, fsApi) {
     if (await fsApi.realpath(target) === await fsApi.realpath(source)) return;
     throw new Error(`[vo-mcp runner] refusing to overwrite existing dependency path: ${target}`);
   }
-  await fsApi.mkdir(path4.dirname(target), { recursive: true });
+  await fsApi.mkdir(path5.dirname(target), { recursive: true });
   await fsApi.symlink(source, target, linkType());
   if (await fsApi.realpath(target) !== await fsApi.realpath(source)) {
     throw new Error(`[vo-mcp runner] dependency link validation failed for ${target}`);
@@ -1996,8 +2083,8 @@ async function maybeYield2(state) {
 async function copyDirRecursive(sourceDir, targetDir, fsApi, yieldState) {
   await fsApi.mkdir(targetDir, { recursive: true });
   for (const entry of await fsApi.readdir(sourceDir, { withFileTypes: true })) {
-    const source = path4.join(sourceDir, entry.name);
-    const target = path4.join(targetDir, entry.name);
+    const source = path5.join(sourceDir, entry.name);
+    const target = path5.join(targetDir, entry.name);
     await maybeYield2(yieldState);
     if (entry.isDirectory()) {
       await copyDirRecursive(source, target, fsApi, yieldState);
@@ -2009,17 +2096,17 @@ async function copyDirRecursive(sourceDir, targetDir, fsApi, yieldState) {
 async function materializeEntry(sourceEntry, targetEntry, canonicalRoot, worktreeRoot, options) {
   await options.beforeEntry?.(sourceEntry, targetEntry);
   const stat3 = await options.fsApi.lstat(sourceEntry);
-  if (stat3.isDirectory() && !stat3.isSymbolicLink() && path4.basename(sourceEntry) === ".bin") {
+  if (stat3.isDirectory() && !stat3.isSymbolicLink() && path5.basename(sourceEntry) === ".bin") {
     await copyDirRecursive(sourceEntry, targetEntry, options.fsApi, options.yieldState);
     return;
   }
-  if (stat3.isDirectory() && !stat3.isSymbolicLink() && path4.basename(sourceEntry).startsWith("@")) {
+  if (stat3.isDirectory() && !stat3.isSymbolicLink() && path5.basename(sourceEntry).startsWith("@")) {
     await options.fsApi.mkdir(targetEntry, { recursive: true });
     for (const nested of await options.fsApi.readdir(sourceEntry, { withFileTypes: true })) {
       await maybeYield2(options.yieldState);
       await materializeEntry(
-        path4.join(sourceEntry, nested.name),
-        path4.join(targetEntry, nested.name),
+        path5.join(sourceEntry, nested.name),
+        path5.join(targetEntry, nested.name),
         canonicalRoot,
         worktreeRoot,
         options
@@ -2032,7 +2119,7 @@ async function materializeEntry(sourceEntry, targetEntry, canonicalRoot, worktre
     await ensureLinkedDirectory(resolvedTarget, targetEntry, options.fsApi);
     return;
   }
-  await options.fsApi.mkdir(path4.dirname(targetEntry), { recursive: true });
+  await options.fsApi.mkdir(path5.dirname(targetEntry), { recursive: true });
   await options.fsApi.copyFile(sourceEntry, targetEntry);
 }
 function createPnpmFsApi(pathExists6) {
@@ -2056,8 +2143,8 @@ async function materializeNodeModulesForest(sourceNodeModules, targetNodeModules
   for (const entry of await options.fsApi.readdir(sourceNodeModules, { withFileTypes: true })) {
     await maybeYield2(options.yieldState);
     await materializeEntry(
-      path4.join(sourceNodeModules, entry.name),
-      path4.join(targetNodeModules, entry.name),
+      path5.join(sourceNodeModules, entry.name),
+      path5.join(targetNodeModules, entry.name),
       canonicalRoot,
       worktreeRoot,
       options
@@ -2074,15 +2161,15 @@ var init_pnpm_materialize = __esm({
 import { createHash as createHash2 } from "node:crypto";
 import fs3 from "node:fs";
 import fsp5 from "node:fs/promises";
-import path5 from "node:path";
+import path6 from "node:path";
 function hashText(text) {
   return createHash2("sha256").update(String(text)).digest("hex");
 }
 function statePath(root) {
-  return path5.join(root, ".agent-worktrees", "runner-pnpm-hydration.json");
+  return path6.join(root, ".agent-worktrees", "runner-pnpm-hydration.json");
 }
 function packageJson(root) {
-  const packagePath = path5.join(root, "package.json");
+  const packagePath = path6.join(root, "package.json");
   if (!fs3.existsSync(packagePath)) return null;
   try {
     return JSON.parse(fs3.readFileSync(packagePath, "utf8"));
@@ -2099,7 +2186,7 @@ async function pathExists4(target) {
   }
 }
 function lockfileHash(root) {
-  const lockPath = path5.join(root, "pnpm-lock.yaml");
+  const lockPath = path6.join(root, "pnpm-lock.yaml");
   if (!fs3.existsSync(lockPath)) return "";
   return hashText(fs3.readFileSync(lockPath, "utf8"));
 }
@@ -2114,7 +2201,7 @@ function readHydrationState(root) {
 }
 function writeHydrationState(root, state) {
   const file = statePath(root);
-  fs3.mkdirSync(path5.dirname(file), { recursive: true });
+  fs3.mkdirSync(path6.dirname(file), { recursive: true });
   fs3.writeFileSync(file, `${JSON.stringify({
     ...state,
     stateVersion: 2,
@@ -2123,7 +2210,7 @@ function writeHydrationState(root, state) {
 `, "utf8");
 }
 function voDepsStatePath(root) {
-  return path5.join(root, "node_modules", ".vo-deps-state.json");
+  return path6.join(root, "node_modules", ".vo-deps-state.json");
 }
 async function ensureVoDepsState(root, expectedHash, fsApi = fsp5) {
   const marker = voDepsStatePath(root);
@@ -2133,7 +2220,7 @@ async function ensureVoDepsState(root, expectedHash, fsApi = fsp5) {
   } catch {
   }
   const temp = `${marker}.tmp-${process.pid}-${Date.now()}`;
-  await fsApi.mkdir(path5.dirname(marker), { recursive: true });
+  await fsApi.mkdir(path6.dirname(marker), { recursive: true });
   await fsApi.writeFile(temp, `${JSON.stringify({ lockfileHash: expectedHash, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)}
 `, "utf8");
   await fsApi.rename(temp, marker);
@@ -2160,7 +2247,7 @@ function workspacePatternsFromPackageJson(root) {
   return [];
 }
 function workspacePatternsFromPnpmWorkspace(root) {
-  const workspacePath = path5.join(root, "pnpm-workspace.yaml");
+  const workspacePath = path6.join(root, "pnpm-workspace.yaml");
   if (!fs3.existsSync(workspacePath)) return [];
   const lines = fs3.readFileSync(workspacePath, "utf8").split(/\r?\n/u);
   const patterns = [];
@@ -2219,8 +2306,8 @@ function collectPackageDirs(root, options = {}) {
   while (stack.length > 0) {
     const current = stack.pop();
     if (!current) continue;
-    const relativeDir = path5.relative(root, current.dir).replace(/\\/g, "/");
-    if (relativeDir && fs3.existsSync(path5.join(current.dir, "package.json"))) {
+    const relativeDir = path6.relative(root, current.dir).replace(/\\/g, "/");
+    if (relativeDir && fs3.existsSync(path6.join(current.dir, "package.json"))) {
       found.push(relativeDir);
       if (found.length >= maxDirs) break;
     }
@@ -2228,7 +2315,7 @@ function collectPackageDirs(root, options = {}) {
     for (const entry of fs3.readdirSync(current.dir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
       if (IGNORED_SCAN_DIRS.has(entry.name)) continue;
-      stack.push({ dir: path5.join(current.dir, entry.name), depth: current.depth + 1 });
+      stack.push({ dir: path6.join(current.dir, entry.name), depth: current.depth + 1 });
     }
   }
   return found.sort();
@@ -2252,8 +2339,8 @@ async function runInstall(root, options = {}) {
   }
 }
 async function hasReadyNodeModules(root) {
-  const nodeModules = path5.join(root, "node_modules");
-  return await pathExists4(path5.join(nodeModules, ".modules.yaml")) || await pathExists4(path5.join(nodeModules, ".pnpm"));
+  const nodeModules = path6.join(root, "node_modules");
+  return await pathExists4(path6.join(nodeModules, ".modules.yaml")) || await pathExists4(path6.join(nodeModules, ".pnpm"));
 }
 function hydrationFsApi(overrides = {}) {
   return { ...createPnpmFsApi(pathExists4), ...overrides };
@@ -2290,7 +2377,7 @@ async function ensurePnpmHydration(root, options = {}) {
     expectedHash: hash,
     requireMarker: false
   });
-  if (!health.healthy && await fsApi.pathExists(path5.join(root, "node_modules"))) {
+  if (!health.healthy && await fsApi.pathExists(path6.join(root, "node_modules"))) {
     quarantine = await quarantineCanonicalNodeModules(root, health.issues, {
       fsApi,
       logger: options.logger
@@ -2302,7 +2389,7 @@ async function ensurePnpmHydration(root, options = {}) {
   }
   const linkedWorkspaceDirs = [];
   for (const relativeDir of workspaceDirs) {
-    if (await pathExists4(path5.join(root, relativeDir, "node_modules"))) {
+    if (await pathExists4(path6.join(root, relativeDir, "node_modules"))) {
       linkedWorkspaceDirs.push(relativeDir);
     }
   }
@@ -2338,18 +2425,18 @@ async function linkHydratedNodeModules({ root, worktreeDir, hydration, options =
       yieldEvery: Math.max(1, options.yieldEvery ?? DEFAULT_YIELD_EVERY2)
     }
   };
-  recordOwnedNodeModulesRoot(dependencyOwnership, path5.join(worktreeDir, "node_modules"));
+  recordOwnedNodeModulesRoot(dependencyOwnership, path6.join(worktreeDir, "node_modules"));
   await materializeNodeModulesForest(
-    path5.join(root, "node_modules"),
-    path5.join(worktreeDir, "node_modules"),
+    path6.join(root, "node_modules"),
+    path6.join(worktreeDir, "node_modules"),
     root,
     worktreeDir,
     materializeOptions
   );
   for (const relativeDir of hydration.linkedWorkspaceDirs) {
-    const sourceNodeModules = path5.join(root, relativeDir, "node_modules");
-    const targetNodeModules = path5.join(worktreeDir, relativeDir, "node_modules");
-    if (!await fsApi.pathExists(path5.join(worktreeDir, relativeDir))) continue;
+    const sourceNodeModules = path6.join(root, relativeDir, "node_modules");
+    const targetNodeModules = path6.join(worktreeDir, relativeDir, "node_modules");
+    if (!await fsApi.pathExists(path6.join(worktreeDir, relativeDir))) continue;
     recordOwnedNodeModulesRoot(dependencyOwnership, targetNodeModules);
     await materializeNodeModulesForest(sourceNodeModules, targetNodeModules, root, worktreeDir, materializeOptions);
   }
@@ -2387,28 +2474,28 @@ var init_pnpm_hydration = __esm({
 
 // src/runner/worktree-paths.mjs
 import { createHash as createHash3 } from "node:crypto";
-import path6 from "node:path";
+import path7 from "node:path";
 function samePath2(left, right) {
-  const a = path6.resolve(left);
-  const b = path6.resolve(right);
+  const a = path7.resolve(left);
+  const b = path7.resolve(right);
   return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
 }
 function worktreePoolForRoot(root, { clonesRootDir = process.env.VO_CODE_RUNNER_CLONES_ROOT || "" } = {}) {
-  const canonicalRoot = path6.resolve(root);
+  const canonicalRoot = path7.resolve(root);
   if (clonesRootDir) {
-    const clonePool = path6.resolve(clonesRootDir);
-    if (samePath2(path6.dirname(canonicalRoot), clonePool)) {
-      return path6.join(clonePool, ".agent-worktrees", path6.basename(canonicalRoot));
+    const clonePool = path7.resolve(clonesRootDir);
+    if (samePath2(path7.dirname(canonicalRoot), clonePool)) {
+      return path7.join(clonePool, ".agent-worktrees", path7.basename(canonicalRoot));
     }
   }
-  return path6.join(canonicalRoot, ".agent-worktrees");
+  return path7.join(canonicalRoot, ".agent-worktrees");
 }
 function worktreeDirForName(root, worktreeName, options = {}) {
   const leaf = createHash3("sha256").update(String(worktreeName)).digest("hex").slice(0, 16);
-  return path6.join(worktreePoolForRoot(root, options), leaf);
+  return path7.join(worktreePoolForRoot(root, options), leaf);
 }
 function recoveryLedgerPathForRoot(root, options = {}) {
-  return path6.join(worktreePoolForRoot(root, options), "recovery-ledger.jsonl");
+  return path7.join(worktreePoolForRoot(root, options), "recovery-ledger.jsonl");
 }
 var init_worktree_paths = __esm({
   "src/runner/worktree-paths.mjs"() {
@@ -2419,7 +2506,7 @@ var init_worktree_paths = __esm({
 // src/runner/worktree-cleanup.mjs
 import fs4 from "node:fs";
 import fsp6 from "node:fs/promises";
-import path7 from "node:path";
+import path8 from "node:path";
 function stateFromEntry(entry) {
   return {
     root: entry.root,
@@ -2460,14 +2547,14 @@ function pruneSuccessfulStates(nowMs = Date.now()) {
 function assertTrackedCleanupPath(entry) {
   const poolRoot = worktreePoolForRoot(entry.root);
   const expected = worktreeDirForName(entry.root, entry.worktreeName);
-  const resolvedPool = path7.resolve(poolRoot);
-  const resolvedTarget = path7.resolve(entry.worktreeDir);
-  if (!resolvedTarget.startsWith(`${resolvedPool}${path7.sep}`)) {
+  const resolvedPool = path8.resolve(poolRoot);
+  const resolvedTarget = path8.resolve(entry.worktreeDir);
+  if (!resolvedTarget.startsWith(`${resolvedPool}${path8.sep}`)) {
     const error = new Error(`cleanup refused outside managed pool: ${entry.worktreeDir}`);
     error.cleanupFatal = true;
     throw error;
   }
-  if (resolvedTarget !== path7.resolve(expected)) {
+  if (resolvedTarget !== path8.resolve(expected)) {
     const error = new Error(`cleanup refused for unexpected tracked path: ${entry.worktreeDir}`);
     error.cleanupFatal = true;
     throw error;
@@ -2481,8 +2568,8 @@ async function worktreeStillRegistered2(root, worktreeDir, gitRunner) {
   if (result.status !== 0) {
     throw new Error(`git worktree list --porcelain failed during cleanup verification: ${summarizeProcessFailure(result)}`);
   }
-  const registered = String(result.stdout || "").split(/\r?\n/u).filter((line) => line.startsWith("worktree ")).map((line) => path7.resolve(line.slice("worktree ".length).trim()));
-  return registered.includes(path7.resolve(worktreeDir));
+  const registered = String(result.stdout || "").split(/\r?\n/u).filter((line) => line.startsWith("worktree ")).map((line) => path8.resolve(line.slice("worktree ".length).trim()));
+  return registered.includes(path8.resolve(worktreeDir));
 }
 function cleanupBackoff(attempt) {
   return 250 * attempt;
@@ -2592,7 +2679,7 @@ function scheduleTrackedCleanup(entry, options = {}) {
 }
 function pendingCleanupDirs() {
   return new Set(
-    [...CLEANUP_STATES.values()].filter((state) => state.status === "pending").map((state) => path7.resolve(state.worktreeDir))
+    [...CLEANUP_STATES.values()].filter((state) => state.status === "pending").map((state) => path8.resolve(state.worktreeDir))
   );
 }
 var CLEANUP_STATES, CLEANUP_PROMISES, SUCCESS_HISTORY_LIMIT, SUCCESS_HISTORY_TTL_MS, DEFAULT_CLEANUP_ATTEMPTS;
@@ -2613,13 +2700,13 @@ var init_worktree_cleanup = __esm({
 // src/runner/task-root-prepare.mjs
 import fs5 from "node:fs";
 import fsp7 from "node:fs/promises";
-import path8 from "node:path";
+import path9 from "node:path";
 function prepLockDir(root) {
-  return path8.join(root, ".agent-worktrees", "runner-root-prep.lock");
+  return path9.join(root, ".agent-worktrees", "runner-root-prep.lock");
 }
 function readLockMeta(lockDir) {
   try {
-    return JSON.parse(fs5.readFileSync(path8.join(lockDir, "owner.json"), "utf8"));
+    return JSON.parse(fs5.readFileSync(path9.join(lockDir, "owner.json"), "utf8"));
   } catch {
     return null;
   }
@@ -2639,9 +2726,9 @@ async function acquirePrepLock(root, options = {}) {
   const staleMs = options.lockStaleMs ?? PREP_LOCK_STALE_MS;
   const sleep3 = options.sleep || sleepMs;
   const lockDir = prepLockDir(root);
-  const ownerPath = path8.join(lockDir, "owner.json");
+  const ownerPath = path9.join(lockDir, "owner.json");
   const deadline = nowMs() + waitMs;
-  fs5.mkdirSync(path8.dirname(lockDir), { recursive: true });
+  fs5.mkdirSync(path9.dirname(lockDir), { recursive: true });
   for (; ; ) {
     try {
       fs5.mkdirSync(lockDir);
@@ -2691,16 +2778,16 @@ async function gitText(root, args, options = {}) {
 }
 function canonicalRecoveryDir(root, options = {}) {
   const now = options.now || (() => /* @__PURE__ */ new Date());
-  return path8.join(
-    options.managedPool || path8.join(root, ".agent-worktrees"),
+  return path9.join(
+    options.managedPool || path9.join(root, ".agent-worktrees"),
     ".canonical-recovery",
     `preexisting-${now().toISOString().replace(/[:.]/gu, "-")}`
   );
 }
 function canonicalPath(root, relative) {
-  const resolvedRoot = path8.resolve(root);
-  const target = path8.resolve(root, relative);
-  const prefix = `${resolvedRoot}${path8.sep}`;
+  const resolvedRoot = path9.resolve(root);
+  const target = path9.resolve(root, relative);
+  const prefix = `${resolvedRoot}${path9.sep}`;
   if (!target.startsWith(prefix)) {
     throw new Error(`canonical recovery path escaped the runner clone: ${relative}`);
   }
@@ -2728,7 +2815,7 @@ async function recoverManagedCanonicalResidue(root, options = {}) {
   if (patchResult.status !== 0) {
     throw new Error(`could not preserve canonical tracked changes: ${summarizeProcessFailure(patchResult)}`);
   }
-  await fsp7.writeFile(path8.join(quarantineDir, "tracked.patch"), String(patchResult.stdout || ""), "utf8");
+  await fsp7.writeFile(path9.join(quarantineDir, "tracked.patch"), String(patchResult.stdout || ""), "utf8");
   const symlinks = [];
   for (const relative of paths.untracked) {
     const source = canonicalPath(root, relative);
@@ -2740,13 +2827,13 @@ async function recoverManagedCanonicalResidue(root, options = {}) {
     if (!stat3.isFile()) {
       throw new Error(`canonical recovery refuses unsupported untracked entry: ${relative}`);
     }
-    const target = canonicalPath(path8.join(quarantineDir, "untracked"), relative);
-    await fsp7.mkdir(path8.dirname(target), { recursive: true });
+    const target = canonicalPath(path9.join(quarantineDir, "untracked"), relative);
+    await fsp7.mkdir(path9.dirname(target), { recursive: true });
     await fsp7.copyFile(source, target);
   }
-  await fsp7.writeFile(path8.join(quarantineDir, "manifest.json"), `${JSON.stringify({
+  await fsp7.writeFile(path9.join(quarantineDir, "manifest.json"), `${JSON.stringify({
     recoveredAt: (/* @__PURE__ */ new Date()).toISOString(),
-    canonicalRoot: path8.resolve(root),
+    canonicalRoot: path9.resolve(root),
     canonicalHead: headSha,
     tracked: paths.tracked,
     untracked: paths.untracked,
@@ -2809,6 +2896,18 @@ async function alignCanonicalClone(root, options = {}) {
   }
   return { updated: true, headSha, originSha };
 }
+async function fetchExactTaskBase(root, baseSha, options = {}) {
+  if (!/^[0-9a-f]{40}$/u.test(baseSha)) {
+    throw new Error("comparative base SHA must be exact lowercase hex");
+  }
+  const fetched = await git(root, ["fetch", "origin", baseSha], options);
+  if (fetched.status !== 0) {
+    throw new Error(`exact comparative source is unavailable: ${summarizeProcessFailure(fetched)}`);
+  }
+  const resolved = await gitText(root, ["rev-parse", `${baseSha}^{commit}`], options);
+  if (resolved !== baseSha) throw new Error("exact comparative source did not resolve to the requested commit");
+  return resolved;
+}
 function shouldIgnoreManagedEntry(entryName) {
   return IGNORED_MANAGED_ENTRIES.has(entryName) || entryName.endsWith(".lock") || entryName.startsWith("runner-");
 }
@@ -2818,11 +2917,11 @@ async function registeredWorktreeDirs(root, options = {}) {
     throw new Error(`git worktree list --porcelain failed while checking managed residue: ${summarizeProcessFailure(listed)}`);
   }
   return new Set(
-    String(listed.stdout || "").split(/\r?\n/u).filter((line) => line.startsWith("worktree ")).map((line) => path8.resolve(line.slice("worktree ".length).trim()))
+    String(listed.stdout || "").split(/\r?\n/u).filter((line) => line.startsWith("worktree ")).map((line) => path9.resolve(line.slice("worktree ".length).trim()))
   );
 }
 async function reportLegacyResiduals(root, options = {}) {
-  const managedRoot = path8.join(root, ".agent-worktrees");
+  const managedRoot = path9.join(root, ".agent-worktrees");
   if (!fs5.existsSync(managedRoot)) return [];
   const registered = await registeredWorktreeDirs(root, options);
   const pending = pendingCleanupDirs();
@@ -2830,7 +2929,7 @@ async function reportLegacyResiduals(root, options = {}) {
   for (const entry of fs5.readdirSync(managedRoot, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
     if (shouldIgnoreManagedEntry(entry.name)) continue;
-    const absolute = path8.resolve(path8.join(managedRoot, entry.name));
+    const absolute = path9.resolve(path9.join(managedRoot, entry.name));
     if (registered.has(absolute)) continue;
     if (pending.has(absolute)) continue;
     found.push(absolute);
@@ -2849,6 +2948,9 @@ async function prepareTaskRoot(root, options = {}) {
   try {
     await reportLegacyResiduals(root, options);
     const alignment = await alignCanonicalClone(root, options);
+    if (options.baseSha) {
+      await fetchExactTaskBase(root, options.baseSha, options);
+    }
     const hydration = await ensurePnpmHydration(root, {
       logger: options.logger,
       runner: options.runner || runProcess
@@ -2899,7 +3001,7 @@ var init_worktree_github_auth = __esm({
 
 // src/runner/worktree-recovery-start.mjs
 import fsp8 from "node:fs/promises";
-import path9 from "node:path";
+import path10 from "node:path";
 async function recordWorktreeStarted(worktreeTarget, meta = {}) {
   if (!worktreeTarget?.worktreeName || !meta.taskId) return null;
   const entry = {
@@ -2914,7 +3016,7 @@ async function recordWorktreeStarted(worktreeTarget, meta = {}) {
     reason: "worktree allocated before execution"
   };
   const ledger = recoveryLedgerPathForRoot(worktreeTarget.root || process.cwd());
-  await fsp8.mkdir(path9.dirname(ledger), { recursive: true });
+  await fsp8.mkdir(path10.dirname(ledger), { recursive: true });
   await fsp8.appendFile(ledger, `${JSON.stringify(entry)}
 `, "utf8");
   return { entry, ledger };
@@ -2929,7 +3031,7 @@ var init_worktree_recovery_start = __esm({
 // src/runner/worktree-helper.mjs
 import fs6 from "node:fs";
 import fsp9 from "node:fs/promises";
-import path10 from "node:path";
+import path11 from "node:path";
 function repoRoot() {
   return process.env.VO_CODE_RUNNER_REPO || process.cwd();
 }
@@ -2945,7 +3047,7 @@ function cloneDirForSlug(repoSlug, clonesRootDir) {
   const [owner, name] = String(repoSlug).split("/");
   if (owner === "." || owner === ".." || name === "." || name === "..") return null;
   if (owner.startsWith("-") || name.startsWith("-")) return null;
-  return path10.join(clonesRootDir, `${sanitize(owner, "owner")}__${sanitize(name, "repo")}`);
+  return path11.join(clonesRootDir, `${sanitize(owner, "owner")}__${sanitize(name, "repo")}`);
 }
 function cloneLockDir(dir) {
   return `${dir}.clone-lock`;
@@ -2960,7 +3062,7 @@ async function pathExists5(target) {
 }
 async function readLockMeta2(lockDir) {
   try {
-    return JSON.parse(await fsp9.readFile(path10.join(lockDir, "owner.json"), "utf8"));
+    return JSON.parse(await fsp9.readFile(path11.join(lockDir, "owner.json"), "utf8"));
   } catch {
     return null;
   }
@@ -2981,11 +3083,11 @@ async function acquireCloneLock(dir, options = {}) {
   const sleep3 = options.sleep || sleepMs;
   const lockDir = cloneLockDir(dir);
   const deadline = nowMs() + waitMs;
-  await fsp9.mkdir(path10.dirname(lockDir), { recursive: true });
+  await fsp9.mkdir(path11.dirname(lockDir), { recursive: true });
   for (; ; ) {
     try {
       await fsp9.mkdir(lockDir);
-      await fsp9.writeFile(path10.join(lockDir, "owner.json"), `${JSON.stringify({
+      await fsp9.writeFile(path11.join(lockDir, "owner.json"), `${JSON.stringify({
         pid: process.pid,
         createdAt: new Date(nowMs()).toISOString(),
         dir
@@ -3014,7 +3116,7 @@ async function acquireCloneLock(dir, options = {}) {
   }
 }
 async function isUsableGitClone(dir, runner = runProcess) {
-  if (!await pathExists5(path10.join(dir, ".git"))) return false;
+  if (!await pathExists5(path11.join(dir, ".git"))) return false;
   const result = await runner("git", ["-C", dir, "rev-parse", "HEAD"], { timeoutMs: 1e4 });
   return result.status === 0 && Boolean(String(result.stdout || "").trim());
 }
@@ -3035,7 +3137,7 @@ async function ensureUsableClone(repoSlug, dir, options = {}) {
     const maxAttempts = options.maxAttempts || 5;
     const raceWaitMs = options.raceWaitMs ?? 1e4;
     let lastError = null;
-    await fsp9.mkdir(path10.dirname(dir), { recursive: true });
+    await fsp9.mkdir(path11.dirname(dir), { recursive: true });
     for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
       if (await pathExists5(dir)) {
         if (await waitForUsableClone(dir, runner, sleep3, raceWaitMs)) return dir;
@@ -3047,7 +3149,7 @@ async function ensureUsableClone(repoSlug, dir, options = {}) {
         ["clone", "--no-tags", `https://github.com/${owner}/${name}.git`, tmpDir],
         { timeoutMs: 6e5, env: githubGitAuthEnv(options.githubToken) }
       );
-      if (clone.status !== 0 || !await pathExists5(path10.join(tmpDir, ".git"))) {
+      if (clone.status !== 0 || !await pathExists5(path11.join(tmpDir, ".git"))) {
         await fsp9.rm(tmpDir, { recursive: true, force: true });
         lastError = new Error(`[vo-mcp runner] clone failed for ${repoSlug}: ${describeGitFailure(clone)}`);
         continue;
@@ -3074,7 +3176,7 @@ async function ensureUsableClone(repoSlug, dir, options = {}) {
 }
 async function resolveTaskRoot(repoSlug, options = {}) {
   const root = clonesRoot();
-  if (root && !path10.isAbsolute(root)) {
+  if (root && !path11.isAbsolute(root)) {
     throw new Error(`[vo-mcp runner] VO_CODE_RUNNER_CLONES_ROOT must be an absolute path (got '${root}')`);
   }
   const dir = cloneDirForSlug(repoSlug, root);
@@ -3123,10 +3225,16 @@ async function createFixWorktree(kind, error = {}, options = {}) {
   const dependencyOwnership = createDependencyOwnershipTracker(worktreeDir);
   const prep = await prepare(root, {
     recoverDirtyCanonical: multiRepo,
-    managedPool: path10.dirname(worktreeDir)
+    managedPool: path11.dirname(worktreeDir),
+    baseSha: options.baseSha || null
   });
   await processRunner("git", ["config", "core.longpaths", "true"], { cwd: root, timeoutMs: 3e4 });
-  const add = await addWorktree({ root, branchName, worktreeDir });
+  const add = await addWorktree({
+    root,
+    branchName,
+    worktreeDir,
+    baseRef: options.baseSha || "origin/main"
+  });
   if (!add.ok) {
     const detail = describeGitFailure(add.result);
     if (multiRepo) {
@@ -3189,7 +3297,7 @@ function preserveFailedWorktree(worktreeName, meta = {}) {
   };
   try {
     const ledger = recoveryLedgerPathForRoot(root);
-    fs6.mkdirSync(path10.dirname(ledger), { recursive: true });
+    fs6.mkdirSync(path11.dirname(ledger), { recursive: true });
     fs6.appendFileSync(ledger, `${JSON.stringify(entry)}
 `, "utf8");
     console.error(`[vo-mcp runner] Preserved worktree ${worktreeName} (reason: ${entry.reason})`);
@@ -3235,9 +3343,9 @@ function partitionRecoveryLedger(lines, { nowMs, ttlMs = PRESERVED_WORKTREE_TTL_
   return decisions;
 }
 function isManagedPreservedDir(dir, root = repoRoot()) {
-  const normalized = path10.resolve(String(dir || ""));
-  const pool = path10.resolve(worktreePoolForRoot(root));
-  return normalized.startsWith(pool + path10.sep);
+  const normalized = path11.resolve(String(dir || ""));
+  const pool = path11.resolve(worktreePoolForRoot(root));
+  return normalized.startsWith(pool + path11.sep);
 }
 function mergeAppendedSinceRead(originalRaw, currentRaw, keptLines) {
   const originalSet = new Set(String(originalRaw || "").split(/\r?\n/u).map((l) => l.trim()).filter(Boolean));
@@ -3762,13 +3870,13 @@ async function getTaskKnowledgeContextRequest(req, taskId, { query } = {}, {
 } = {}) {
   const body = {};
   if (typeof query === "string" && query.trim()) body.query = query;
-  const path22 = `/api/v1/code-task/${encodeURIComponent(taskId)}/knowledge-context`;
+  const path23 = `/api/v1/code-task/${encodeURIComponent(taskId)}/knowledge-context`;
   const timeoutMs = Math.max(Number(taskRequestTimeoutMs) || 0, MIN_KNOWLEDGE_CONTEXT_TIMEOUT_MS);
   for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt += 1) {
     let res;
     let cause;
     try {
-      res = await req("POST", path22, body, { timeoutMs });
+      res = await req("POST", path23, body, { timeoutMs });
     } catch (err) {
       cause = err;
     }
@@ -3835,10 +3943,10 @@ async function getPreparedJobRequest(req, taskId, options = {}, invalidateToken
   if (typeof taskId !== "string" || taskId.length === 0) {
     return { ok: false, reason: "missing_task_id", status: 0, ...envMeta };
   }
-  const path22 = `/api/v1/code-task/${encodeURIComponent(taskId)}/prepared-job?${query}`;
+  const path23 = `/api/v1/code-task/${encodeURIComponent(taskId)}/prepared-job?${query}`;
   let res;
   try {
-    res = await req("GET", path22, void 0, { timeoutMs });
+    res = await req("GET", path23, void 0, { timeoutMs });
   } catch (err) {
     return { ok: false, reason: `transport: ${err?.message || String(err)}`, status: 0, ...envMeta };
   }
@@ -3937,11 +4045,11 @@ function createControlPlaneClient({
   const resolvedBaseUrl = baseUrl ?? env2.VO_CONTROL_PLANE_URL ?? "";
   if (!resolvedBaseUrl) throw new Error("VO_CONTROL_PLANE_URL is required for the code-runner daemon");
   const root = resolvedBaseUrl.replace(/\/+$/, "");
-  async function req(method, path22, body, { timeoutMs } = {}) {
+  async function req(method, path23, body, { timeoutMs } = {}) {
     const bearer = await resolveBearer(env2);
     const controller = timeoutMs ? new AbortController() : null;
     let timeoutId;
-    const request = Promise.resolve(fetchImpl(`${root}${path22}`, {
+    const request = Promise.resolve(fetchImpl(`${root}${path23}`, {
       method,
       headers: {
         "content-type": "application/json",
@@ -3954,7 +4062,7 @@ function createControlPlaneClient({
     const timeout = new Promise((_, reject) => {
       timeoutId = setTimeout(() => {
         controller.abort();
-        reject(new Error(`control-plane ${path22} timed out after ${timeoutMs}ms`));
+        reject(new Error(`control-plane ${path23} timed out after ${timeoutMs}ms`));
       }, timeoutMs);
     });
     try {
@@ -3963,7 +4071,7 @@ function createControlPlaneClient({
       clearTimeout(timeoutId);
     }
   }
-  const taskReq = (method, path22, body, options = {}) => req(method, path22, body, { timeoutMs: taskRequestTimeoutMs, ...options });
+  const taskReq = (method, path23, body, options = {}) => req(method, path23, body, { timeoutMs: taskRequestTimeoutMs, ...options });
   const claimGate = makeClaimGateNotice({ log: (m) => console.warn(`[code-runner ${(/* @__PURE__ */ new Date()).toISOString()}] ${m}`) });
   return {
     getClaimGate: () => claimGate.current(),
@@ -4107,8 +4215,8 @@ function createControlPlaneClient({
       return listAllPrOpenedTasks(taskReq);
     },
     async downloadTaskAttachment(taskId, attachmentId) {
-      const path22 = `/api/v1/code-task/${encodeURIComponent(taskId)}/attachment/${encodeURIComponent(attachmentId)}`;
-      const res = await taskReq("GET", path22);
+      const path23 = `/api/v1/code-task/${encodeURIComponent(taskId)}/attachment/${encodeURIComponent(attachmentId)}`;
+      const res = await taskReq("GET", path23);
       if (res.status === 401) cachedFirebaseToken = null;
       if (!res.ok) throw new Error(`attachment download failed: HTTP ${res.status}`);
       return Buffer.from(await res.arrayBuffer());
@@ -4266,7 +4374,7 @@ var init_control_plane_client = __esm({
 
 // ../../scripts/virtual-office/code-runner/windows-claude-launch.mjs
 import { existsSync as existsSync8, realpathSync } from "node:fs";
-import { win32 as path11 } from "node:path";
+import { win32 as path12 } from "node:path";
 import { spawnSync } from "node:child_process";
 function pathValue(env2) {
   for (const key of ["Path", "PATH", "path"]) {
@@ -4287,38 +4395,38 @@ function envValue(env2, name) {
 function userClaudeCandidates(bin, env2) {
   if (!/^claude(?:\.(?:exe|cmd|ps1))?$/iu.test(bin)) return [];
   const userProfile = envValue(env2, "USERPROFILE");
-  const appData = envValue(env2, "APPDATA") || (userProfile ? path11.join(userProfile, "AppData", "Roaming") : "");
-  const localAppData = envValue(env2, "LOCALAPPDATA") || (userProfile ? path11.join(userProfile, "AppData", "Local") : "");
+  const appData = envValue(env2, "APPDATA") || (userProfile ? path12.join(userProfile, "AppData", "Roaming") : "");
+  const localAppData = envValue(env2, "LOCALAPPDATA") || (userProfile ? path12.join(userProfile, "AppData", "Local") : "");
   const candidates = [];
   if (appData) {
-    const npmBin = path11.join(appData, "npm");
+    const npmBin = path12.join(appData, "npm");
     candidates.push(
-      path11.join(npmBin, "claude.exe"),
-      path11.join(npmBin, "claude.cmd"),
-      path11.join(npmBin, "claude.ps1"),
-      path11.join(npmBin, "claude"),
-      path11.join(npmBin, ...NATIVE_CLAUDE_PARTS)
+      path12.join(npmBin, "claude.exe"),
+      path12.join(npmBin, "claude.cmd"),
+      path12.join(npmBin, "claude.ps1"),
+      path12.join(npmBin, "claude"),
+      path12.join(npmBin, ...NATIVE_CLAUDE_PARTS)
     );
   }
-  if (userProfile) candidates.push(path11.join(userProfile, ".local", "bin", "claude.exe"));
+  if (userProfile) candidates.push(path12.join(userProfile, ".local", "bin", "claude.exe"));
   if (localAppData) {
     candidates.push(
-      path11.join(localAppData, "Microsoft", "WinGet", "Links", "claude.exe"),
-      path11.join(localAppData, "Microsoft", "WindowsApps", "claude.exe")
+      path12.join(localAppData, "Microsoft", "WinGet", "Links", "claude.exe"),
+      path12.join(localAppData, "Microsoft", "WindowsApps", "claude.exe")
     );
   }
   return candidates;
 }
 function pathCandidates(bin, env2) {
-  if (path11.isAbsolute(bin) || /[\\/]/u.test(bin)) {
-    return [path11.resolve(bin)];
-  }
-  const extension = path11.extname(bin);
-  const fromPath = pathValue(env2).split(";").map(cleanPathSegment).filter(Boolean).flatMap((directory) => extension ? [path11.join(directory, bin)] : [
-    path11.join(directory, `${bin}.exe`),
-    path11.join(directory, `${bin}.cmd`),
-    path11.join(directory, `${bin}.ps1`),
-    path11.join(directory, bin)
+  if (path12.isAbsolute(bin) || /[\\/]/u.test(bin)) {
+    return [path12.resolve(bin)];
+  }
+  const extension = path12.extname(bin);
+  const fromPath = pathValue(env2).split(";").map(cleanPathSegment).filter(Boolean).flatMap((directory) => extension ? [path12.join(directory, bin)] : [
+    path12.join(directory, `${bin}.exe`),
+    path12.join(directory, `${bin}.cmd`),
+    path12.join(directory, `${bin}.ps1`),
+    path12.join(directory, bin)
   ]);
   const seen = /* @__PURE__ */ new Set();
   return [...fromPath, ...userClaudeCandidates(bin, env2)].filter((candidate) => {
@@ -4349,8 +4457,8 @@ function resolveWindowsClaudeExecutable({
   for (const candidate of pathCandidates(requested, env2)) {
     const found = canonicalExistingPath(candidate, exists, canonicalize);
     if (!found) continue;
-    if (path11.extname(found).toLowerCase() === ".exe") return found;
-    const native = path11.join(path11.dirname(found), ...NATIVE_CLAUDE_PARTS);
+    if (path12.extname(found).toLowerCase() === ".exe") return found;
+    const native = path12.join(path12.dirname(found), ...NATIVE_CLAUDE_PARTS);
     const resolvedNative = canonicalExistingPath(native, exists, canonicalize);
     if (resolvedNative) return resolvedNative;
   }
@@ -4611,6 +4719,7 @@ function finalizeAgentTaskResult({
   result,
   bin,
   stderrTail,
+  classifyStderr = null,
   timedOut,
   killed,
   cancelReason,
@@ -4641,8 +4750,16 @@ function finalizeAgentTaskResult({
     if (code !== 0 || signal) summary = fallback || `${bin} exited ${signal || code}`;
     else summary = fallback || `${bin} exited without terminal result`;
   }
+  let failure = result.failure ?? null;
+  if (!failure && !sawTerminalResult && (code !== 0 || signal) && typeof classifyStderr === "function") {
+    try {
+      failure = classifyStderr(stderrTail);
+    } catch {
+    }
+  }
   return {
     ...result,
+    ...failure ? { failure } : {},
     ok: sawTerminalResult && result.ok && (code === 0 || forcedAfterResult),
     summary: augmentSummary(summary)
   };
@@ -4847,12 +4964,12 @@ var init_terminal_process_cleanup = __esm({
 import { spawnSync as spawnSync5 } from "node:child_process";
 import { existsSync as existsSync9, mkdirSync as mkdirSync7, readdirSync as readdirSync2, readFileSync as readFileSync7, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "node:fs";
 import os from "node:os";
-import path12 from "node:path";
+import path13 from "node:path";
 function registryRoot(tmp = os.tmpdir()) {
-  return path12.join(tmp, REGISTRY_ROOT_NAME);
+  return path13.join(tmp, REGISTRY_ROOT_NAME);
 }
 function instanceDir(root, instanceId) {
-  return path12.join(root, String(instanceId).replace(/[^A-Za-z0-9_-]/g, ""));
+  return path13.join(root, String(instanceId).replace(/[^A-Za-z0-9_-]/g, ""));
 }
 function registerDaemonInstance({
   root = registryRoot(),
@@ -4863,7 +4980,7 @@ function registerDaemonInstance({
   if (!instanceId) return null;
   const dir = instanceDir(root, instanceId);
   mkdirSync7(dir, { recursive: true });
-  const file = path12.join(dir, DAEMON_RECORD);
+  const file = path13.join(dir, DAEMON_RECORD);
   writeFileSync5(file, JSON.stringify({ daemonPid, daemonStartedAtMs, instanceId }), {
     encoding: "utf8",
     mode: 384
@@ -4882,7 +4999,7 @@ function recordAgentPid({
     const dir = instanceDir(root, instanceId);
     mkdirSync7(dir, { recursive: true });
     writeFileSync5(
-      path12.join(dir, `${pid}.json`),
+      path13.join(dir, `${pid}.json`),
       JSON.stringify({ pid, agentId, startedAtMs, instanceId }),
       { encoding: "utf8", mode: 384 }
     );
@@ -4898,7 +5015,7 @@ function unrecordAgentPid({
 } = {}) {
   if (!instanceId || !Number.isInteger(pid)) return false;
   try {
-    rmSync2(path12.join(instanceDir(root, instanceId), `${pid}.json`), { force: true });
+    rmSync2(path13.join(instanceDir(root, instanceId), `${pid}.json`), { force: true });
     return true;
   } catch {
     return false;
@@ -4926,7 +5043,7 @@ function readRegistry({ root = registryRoot(), currentInstanceId } = {}) {
   for (const dirent of dirents) {
     if (!dirent.isDirectory()) continue;
     if (currentInstanceId && dirent.name === instanceDirName(currentInstanceId)) continue;
-    const dir = path12.join(root, dirent.name);
+    const dir = path13.join(root, dirent.name);
     let daemon = null;
     const agents = [];
     let files;
@@ -4938,7 +5055,7 @@ function readRegistry({ root = registryRoot(), currentInstanceId } = {}) {
     for (const name of files) {
       let parsed;
       try {
-        parsed = JSON.parse(readFileSync7(path12.join(dir, name), "utf8"));
+        parsed = JSON.parse(readFileSync7(path13.join(dir, name), "utf8"));
       } catch {
         continue;
       }
@@ -4986,7 +5103,7 @@ function windowsSystemRoot(env2 = process.env) {
   return env2.SystemRoot || env2.WINDIR || "C:\\Windows";
 }
 function windowsPowershellExe(env2 = process.env) {
-  return path12.join(windowsSystemRoot(env2), "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+  return path13.join(windowsSystemRoot(env2), "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
 }
 function listProcessCreationTimes({ platform: platform4 = process.platform, spawn: spawn5 = spawnSync5, env: env2 = process.env, warn = console.warn } = {}) {
   const map = /* @__PURE__ */ new Map();
@@ -5031,7 +5148,7 @@ function parsePosixPsLine(line) {
 function killProcessTree(pid, { platform: platform4 = process.platform, spawn: spawn5 = spawnSync5, env: env2 = process.env } = {}) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
   if (platform4 === "win32") {
-    const taskkill = path12.join(windowsSystemRoot(env2), "System32", "taskkill.exe");
+    const taskkill = path13.join(windowsSystemRoot(env2), "System32", "taskkill.exe");
     const r = spawn5(taskkill, ["/PID", String(pid), "/T", "/F"], { windowsHide: true, stdio: "ignore", timeout: 15e3 });
     return !r.error && r.status === 0;
   }
@@ -5567,7 +5684,8 @@ function runAgentTask({
         // parser would work, the runner would report null, and the feature
         // would measure nothing while every test passed.
         tokenUsage: evt.tokenUsage ?? result.tokenUsage ?? null,
-        modelUsage: evt.modelUsage ?? result.modelUsage ?? null
+        modelUsage: evt.modelUsage ?? result.modelUsage ?? null,
+        failure: evt.failure ?? result.failure ?? null
       };
       terminalCleanupTimer ??= armTerminalCleanup({
         child,
@@ -5596,6 +5714,7 @@ function runAgentTask({
         result,
         bin,
         stderrTail,
+        classifyStderr: runner.classifyStderr,
         timedOut,
         killed,
         cancelReason,
@@ -5720,26 +5839,15 @@ var init_claude_runner = __esm({
         if (process.platform !== "win32") return { bin, args, spawnOptions: spawnOptions ?? this.getSpawnOptions() };
         return buildWindowsClaudeLaunch({ bin, args, env: env2 });
       }
-      /**
-       * Fill ANTHROPIC_API_KEY from the OS keychain when not already set (M4 BYO),
-       * so a friend who ran `vo-mcp set-key` authenticates without an env var.
-       * Explicit env wins; no key stored → unchanged (Claude Code login as before).
-       */
       applyAuthEnv(env2 = process.env) {
         return withAnthropicKey(env2);
       }
       costBasis(env2 = process.env) {
         return claudeCostBasis(env2);
       }
-      /** Describe which Anthropic auth source the spawn will use (for runner logs). */
       describeAuth(env2 = process.env) {
         return describeAnthropicAuthSource(env2);
       }
-      /**
-       * Best-effort auth check: is `claude` on PATH and can we verify login?
-       * Never throws. If we can't cheaply detect auth, we return installed:true
-       * and let the real spawn fail with a clearer error from the CLI itself.
-       */
       async checkAuth() {
         return checkClaudeAuth();
       }
@@ -5865,6 +5973,66 @@ var init_flat_token_usage = __esm({
   }
 });
 
+// ../../scripts/virtual-office/code-runner/error-message.mjs
+function boundedErrorMessage(error, maxLength = 240) {
+  try {
+    return String(error?.message ?? error ?? "unknown error").slice(0, maxLength);
+  } catch {
+    return "unknown error";
+  }
+}
+function codexFailure(code, fields = {}) {
+  const definition = FAILURE_DEFINITIONS[code];
+  return {
+    schema: FAILURE_SCHEMA,
+    agent: "codex",
+    source: definition.source,
+    code,
+    ...fields,
+    operator_next_action: definition.operator_next_action
+  };
+}
+function classifyCodexTerminalFailure(evt = {}) {
+  const error = evt && typeof evt.error === "object" && evt.error !== null ? evt.error : null;
+  if (!/^The ['"][^'"]+['"] model is not supported when using Codex with a ChatGPT account\.$/u.test(
+    typeof error?.message === "string" ? error.message : ""
+  )) return null;
+  const status = Number(evt.status ?? error.status);
+  return codexFailure("model_unsupported_for_account", Number.isInteger(status) ? { provider_status: status } : {});
+}
+function classifyCodexStderr(stderr = "") {
+  if (!/(?:^|\n)\s*windows sandbox(?: failed)?: runner error:.*\bCreateProcessAsUserW failed:\s*1312\b/imu.test(String(stderr))) return null;
+  return codexFailure("codex_runtime_launch_logon_session", { win32_error: 1312 });
+}
+function serializeRunnerFailure(record, maxLength = 2e3) {
+  const definition = record && FAILURE_DEFINITIONS[record.code];
+  if (!definition || record.schema !== FAILURE_SCHEMA || record.source !== definition.source) return null;
+  const value = codexFailure(record.code, {
+    ...record.code === "model_unsupported_for_account" && Number.isInteger(record.provider_status) ? { provider_status: record.provider_status } : {},
+    ...definition.win32_error ? { win32_error: definition.win32_error } : {}
+  });
+  const serialized2 = JSON.stringify(value);
+  return serialized2.length <= Math.max(0, maxLength) ? serialized2 : null;
+}
+var FAILURE_SCHEMA, FAILURE_DEFINITIONS;
+var init_error_message = __esm({
+  "../../scripts/virtual-office/code-runner/error-message.mjs"() {
+    "use strict";
+    FAILURE_SCHEMA = "vo.runner_failure.v1";
+    FAILURE_DEFINITIONS = {
+      model_unsupported_for_account: {
+        source: "terminal_event",
+        operator_next_action: "Create a new owner-reviewed task with an account-supported Codex model; keep the preserved draft PR for review rather than resuming this task."
+      },
+      codex_runtime_launch_logon_session: {
+        source: "stderr",
+        win32_error: 1312,
+        operator_next_action: "Repair the Codex Windows logon/session configuration on the serving host, then rerun the runner."
+      }
+    };
+  }
+});
+
 // ../../scripts/virtual-office/code-runner/codex-runner.mjs
 import { spawnSync as spawnSync6 } from "node:child_process";
 import { existsSync as existsSync10 } from "node:fs";
@@ -5965,7 +6133,8 @@ function parseCodexEvent(line) {
   }
   if (type === "turn.failed" || type === "error") {
     const msg = evt.error && (evt.error.message || evt.error) || evt.message || "codex run failed";
-    return { kind: "result", isError: true, costUsd: null, summary: String(msg), numTurns: null };
+    const failure = classifyCodexTerminalFailure(evt);
+    return { kind: "result", isError: true, costUsd: null, summary: String(msg), numTurns: null, ...failure ? { failure } : {} };
   }
   return null;
 }
@@ -5976,6 +6145,7 @@ var init_codex_runner = __esm({
     init_agent_key_store();
     init_agent_auth_tier();
     init_flat_token_usage();
+    init_error_message();
     CODEX_PREFER_LOGIN_ENV = "VO_RUNNER_CODEX_PREFER_LOGIN";
     LEGACY_PREFER_LOGIN_ENV = "VO_RUNNER_PREFER_LOGIN";
     CodexRunner = class {
@@ -5993,6 +6163,9 @@ var init_codex_runner = __esm({
       parseEvent(line) {
         return parseCodexEvent(line);
       }
+      classifyStderr(stderr) {
+        return classifyCodexStderr(stderr);
+      }
       /**
        * SECURITY: never `shell: true` — same RCE class as cursor-runner. The old
        * `shell: win32 && !/\.exe$/` fell back to shell mode whenever
@@ -6014,12 +6187,6 @@ var init_codex_runner = __esm({
           windowsVerbatimArguments: false
         };
       }
-      /**
-       * Fill the OpenAI credential env var(s) (OPENAI_API_KEY / CODEX_API_KEY) from
-       * the OS keychain when not already set, so a BYO friend who ran
-       * `vo-mcp set-key --provider codex` authenticates without an env var. Explicit
-       * env wins; no key stored → unchanged (a prior `codex login` still works).
-       */
       applyAuthEnv(env2 = process.env) {
         if (isTruthyFlag2(env2[CODEX_PREFER_LOGIN_ENV]) || isTruthyFlag2(env2[LEGACY_PREFER_LOGIN_ENV])) {
           const out = { ...env2 };
@@ -6032,20 +6199,9 @@ var init_codex_runner = __esm({
       costBasis(env2 = process.env) {
         return String(env2.OPENAI_API_KEY || env2.CODEX_API_KEY || "").trim() ? "vendor_billed" : "subscription_api_equivalent";
       }
-      /**
-       * Dispatch-time billing tier for the NEXT codex spawn, from the SAME facts
-       * checkAuth() already gathered — no extra subprocess. applyAuthEnv() is a
-       * keychain read in this process (@napi-rs/keyring), not a spawn.
-       *
-       * Codex is the agent where this signal was already computed and then thrown
-       * away: checkAuth() distinguished "API key available (no persisted ChatGPT
-       * login)" from a real login, but only inside a `message` string that the
-       * heartbeat schema strips before storage. This gives that fact a typed home.
-       */
       authTier(env2 = this.env) {
         return safeAuthTier(() => authTierFromCostBasis(this.costBasis(this.applyAuthEnv(env2))));
       }
-      /** Best-effort binary + persisted-login probe. Never throws or spends tokens. */
       async checkAuth() {
         try {
           const bin = this.binary;
@@ -6937,9 +7093,9 @@ var init_rate_limit_detector_core = __esm({
 
 // ../../scripts/virtual-office/code-runner/rate-limit-resume-state.mjs
 import fsp10 from "node:fs/promises";
-import path13 from "node:path";
+import path14 from "node:path";
 async function atomicWrite(file, content) {
-  await fsp10.mkdir(path13.dirname(file), { recursive: true });
+  await fsp10.mkdir(path14.dirname(file), { recursive: true });
   const temp = `${file}.tmp-${process.pid}-${Date.now()}`;
   const handle = await fsp10.open(temp, "wx");
   try {
@@ -7000,7 +7156,7 @@ function writeResumeAttempts(file, store) {
 }
 async function acquireLock(lockFile, { now = Date.now, sleep: sleep3 = delay } = {}) {
   const deadline = now() + LOCK_WAIT_MS;
-  await fsp10.mkdir(path13.dirname(lockFile), { recursive: true });
+  await fsp10.mkdir(path14.dirname(lockFile), { recursive: true });
   for (; ; ) {
     let handle;
     try {
@@ -7145,6 +7301,17 @@ async function classifyFailureForResume({
   record = recordRateLimited,
   deferRecord = false
 } = {}) {
+  const structuredFailure = serializeRunnerFailure(run.failure);
+  if (structuredFailure) {
+    return {
+      rateLimited: false,
+      progress: {
+        status: "failed",
+        message: `runner blocker: ${run.failure.code}; operator review required`,
+        result: structuredFailure
+      }
+    };
+  }
   if (enabled) {
     const rl = detect(run.summary, { now });
     if (rl.rateLimited) {
@@ -7219,6 +7386,7 @@ var init_rate_limit_resume = __esm({
     "use strict";
     init_rate_limit_detector_core();
     init_rate_limit_resume_state();
+    init_error_message();
   }
 });
 
@@ -7458,14 +7626,14 @@ function parsePorcelainZ(out) {
   for (let i = 0; i < tokens.length; i += 1) {
     const token2 = tokens[i];
     if (!token2) continue;
-    const path22 = token2.slice(3);
-    if (path22) files.push(path22);
+    const path23 = token2.slice(3);
+    if (path23) files.push(path23);
     if (token2[0] === "R" || token2[0] === "C") i += 1;
   }
   return files;
 }
-function isAgentScratch(path22) {
-  const normalized = String(path22 || "");
+function isAgentScratch(path23) {
+  const normalized = String(path23 || "");
   return SCRATCH_PATTERNS.some((pattern) => pattern.test(normalized));
 }
 var SCRATCH_PATTERNS;
@@ -7722,7 +7890,7 @@ var init_executor = __esm({
 
 // ../../scripts/virtual-office/code-runner/test-gen-gate.mjs
 import fs7 from "node:fs";
-import path14 from "node:path";
+import path15 from "node:path";
 async function postFailed(client, id, message, result) {
   try {
     await client.postProgress(id, {
@@ -7758,7 +7926,7 @@ async function gateTestGenTaskOrFail({ client, id, task, files, worktreeDir, env
   }
   let testSource = "";
   try {
-    testSource = fs7.readFileSync(path14.join(worktreeDir, testFile), "utf8");
+    testSource = fs7.readFileSync(path15.join(worktreeDir, testFile), "utf8");
   } catch (err) {
     await postFailed(client, id, `could not read generated test ${testFile}: ${err.message}`, "gate_test_unreadable");
     return true;
@@ -7808,7 +7976,7 @@ var init_test_gen_gate = __esm({
 // ../../scripts/virtual-office/code-runner/completion-gate.mjs
 import { execFile } from "node:child_process";
 import fs8 from "node:fs";
-import path15 from "node:path";
+import path16 from "node:path";
 function resolveCompletionGate(task) {
   const raw = task?.completion_gate;
   if (raw === void 0 || raw === null) return null;
@@ -7846,14 +8014,14 @@ function workspaceFingerprint(worktreeDir, execFileImpl = execFile) {
 }
 function readState(worktreeDir) {
   try {
-    return JSON.parse(fs8.readFileSync(path15.join(worktreeDir, COMPLETION_GATE_STATE_FILE), "utf8"));
+    return JSON.parse(fs8.readFileSync(path16.join(worktreeDir, COMPLETION_GATE_STATE_FILE), "utf8"));
   } catch {
     return null;
   }
 }
 function writeState(worktreeDir, state) {
   try {
-    fs8.writeFileSync(path15.join(worktreeDir, COMPLETION_GATE_STATE_FILE), `${JSON.stringify(state)}
+    fs8.writeFileSync(path16.join(worktreeDir, COMPLETION_GATE_STATE_FILE), `${JSON.stringify(state)}
 `, "utf8");
   } catch {
   }
@@ -8565,16 +8733,28 @@ var init_repair_publication_strategy = __esm({
 
 // ../../scripts/virtual-office/code-runner/partial-pr-continuation.mjs
 function partialPrContinuationResult(run = {}, maxLength = 2e3, reason = null) {
+  const limit = Math.max(0, Number(maxLength) || 0);
   const summary = String(run.summary || "agent stopped before completing the task").trim();
   const reasonMarker = reason === "rate_limited" ? `
 ${RATE_LIMITED_CONTINUATION_MARKER}` : "";
-  return `${PARTIAL_PR_CONTINUATION_MARKER}${reasonMarker}
-${summary}`.slice(0, Math.max(0, maxLength));
+  const blockedMarker = "ALGOSUITE_TASK_OUTCOME: BLOCKED";
+  const blockedPrefix = `${blockedMarker}${reasonMarker}
+`;
+  const serializedFailure = serializeRunnerFailure(run.failure, Math.max(0, limit - blockedPrefix.length - 1));
+  const outcomeMarker = serializedFailure ? blockedMarker : PARTIAL_PR_CONTINUATION_MARKER;
+  const prefix = `${outcomeMarker}${reasonMarker}
+`;
+  const failure = serializedFailure && outcomeMarker === blockedMarker ? serializedFailure : null;
+  const suffix = failure ? `
+${failure}` : "";
+  const summaryRoom = Math.max(0, limit - prefix.length - suffix.length);
+  return `${prefix}${summary.slice(0, summaryRoom)}${suffix}`.slice(0, limit);
 }
 var PARTIAL_PR_CONTINUATION_MARKER, RATE_LIMITED_CONTINUATION_MARKER;
 var init_partial_pr_continuation = __esm({
   "../../scripts/virtual-office/code-runner/partial-pr-continuation.mjs"() {
     "use strict";
+    init_error_message();
     PARTIAL_PR_CONTINUATION_MARKER = "ALGOSUITE_TASK_OUTCOME: NEEDS_CONTINUATION";
     RATE_LIMITED_CONTINUATION_MARKER = "ALGOSUITE_CONTINUATION_REASON: RATE_LIMITED";
   }
@@ -9441,7 +9621,7 @@ var init_task_prompt = __esm({
 import { createHash as createHash4, randomUUID as randomUUID3 } from "node:crypto";
 import { chmod, mkdir, mkdtemp, readFile, readdir, realpath, rm, stat, writeFile } from "node:fs/promises";
 import os2 from "node:os";
-import path16 from "node:path";
+import path17 from "node:path";
 function safeTaskToken(taskId) {
   return String(taskId || "task").replace(/[^0-9A-Za-z_-]/gu, "_").slice(0, 48) || "task";
 }
@@ -9454,9 +9634,9 @@ function hasGeneratedPrefix(name) {
   return name.startsWith(DIRECTORY_PREFIX) || name.startsWith(LEGACY_DIRECTORY_PREFIX);
 }
 function assertGeneratedDirectory(directory, containmentRoot) {
-  const resolvedDirectory = path16.resolve(directory);
-  const resolvedRoot = path16.resolve(containmentRoot);
-  if (path16.dirname(resolvedDirectory) !== resolvedRoot || !hasGeneratedPrefix(path16.basename(resolvedDirectory))) {
+  const resolvedDirectory = path17.resolve(directory);
+  const resolvedRoot = path17.resolve(containmentRoot);
+  if (path17.dirname(resolvedDirectory) !== resolvedRoot || !hasGeneratedPrefix(path17.basename(resolvedDirectory))) {
     throw new Error("refusing to clean an unverified task-attachment directory");
   }
   return resolvedDirectory;
@@ -9465,7 +9645,7 @@ async function resolveContainmentRoot(worktreeDir) {
   if (typeof worktreeDir !== "string" || !worktreeDir.trim()) {
     throw new Error("refusing to materialize task attachments outside an agent-readable worktree: no worktreeDir given");
   }
-  const root = path16.resolve(worktreeDir);
+  const root = path17.resolve(worktreeDir);
   const stats = await stat(root).catch(() => null);
   if (!stats?.isDirectory()) {
     throw new Error(`refusing to materialize task attachments: agent worktree root is not a directory (${root})`);
@@ -9474,15 +9654,15 @@ async function resolveContainmentRoot(worktreeDir) {
 }
 async function createAttachmentDirectory(taskId, containmentRoot) {
   const root = await resolveContainmentRoot(containmentRoot);
-  const directory = await mkdtemp(path16.join(root, `${DIRECTORY_PREFIX}${safeTaskToken(taskId)}-`));
+  const directory = await mkdtemp(path17.join(root, `${DIRECTORY_PREFIX}${safeTaskToken(taskId)}-`));
   const [realRoot, realDirectory] = await Promise.all([realpath(root), realpath(directory)]);
-  if (path16.dirname(realDirectory) !== realRoot) {
+  if (path17.dirname(realDirectory) !== realRoot) {
     await rm(directory, { recursive: true, force: true }).catch(() => void 0);
     throw new Error("task-attachment directory escaped the agent worktree root");
   }
-  await writeFile(path16.join(directory, GITIGNORE_FILE), GITIGNORE_BODY, { encoding: "utf8", mode: 384 });
-  const marker = JSON.stringify({ owner: MARKER_OWNER, token: randomUUID3(), directory: path16.basename(directory), created_at: (/* @__PURE__ */ new Date()).toISOString() });
-  await writeFile(path16.join(directory, MARKER_FILE), marker, { encoding: "utf8", mode: 384 });
+  await writeFile(path17.join(directory, GITIGNORE_FILE), GITIGNORE_BODY, { encoding: "utf8", mode: 384 });
+  const marker = JSON.stringify({ owner: MARKER_OWNER, token: randomUUID3(), directory: path17.basename(directory), created_at: (/* @__PURE__ */ new Date()).toISOString() });
+  await writeFile(path17.join(directory, MARKER_FILE), marker, { encoding: "utf8", mode: 384 });
   return { directory, marker, root, cleaned: false };
 }
 async function cleanupGeneratedDirectory(state) {
@@ -9496,7 +9676,7 @@ async function cleanupGeneratedDirectory(state) {
     state.cleaned = true;
     return;
   }
-  const marker = await readFile(path16.join(directory, MARKER_FILE), "utf8").catch(() => "");
+  const marker = await readFile(path17.join(directory, MARKER_FILE), "utf8").catch(() => "");
   if (marker !== state.marker) throw new Error("refusing to clean a task-attachment directory without its exact marker");
   await rm(directory, { recursive: true, force: true });
   state.cleaned = true;
@@ -9515,7 +9695,7 @@ async function sweepStaleTaskAttachmentDirectories({
   now = Date.now(),
   maxAgeMs = DEFAULT_STALE_AGE_MS
 } = {}) {
-  const root = path16.resolve(tempRoot);
+  const root = path17.resolve(tempRoot);
   if (!Number.isFinite(maxAgeMs) || maxAgeMs <= 0) throw new Error("stale attachment age must be positive");
   const entries = await readdir(root, { withFileTypes: true }).catch((error) => {
     if (error?.code === "ENOENT") return [];
@@ -9524,8 +9704,8 @@ async function sweepStaleTaskAttachmentDirectories({
   let removed = 0;
   for (const entry of entries) {
     if (!entry.isDirectory() || !hasGeneratedPrefix(entry.name)) continue;
-    const directory = assertGeneratedDirectory(path16.join(root, entry.name), root);
-    const markerRaw = await readFile(path16.join(directory, MARKER_FILE), "utf8").catch(() => "");
+    const directory = assertGeneratedDirectory(path17.join(root, entry.name), root);
+    const markerRaw = await readFile(path17.join(directory, MARKER_FILE), "utf8").catch(() => "");
     const marker = parseOwnedMarker(markerRaw, entry.name);
     if (!marker) continue;
     const directoryStat = await stat(directory);
@@ -9582,8 +9762,8 @@ async function materializeTaskAttachments(client, task, { worktreeDir } = {}) {
       const sha2562 = createHash4("sha256").update(content).digest("hex");
       if (sha2562 !== ref.sha256) throw new Error(`attachment ${ref.attachment_id} sha256 mismatch`);
       const name = sanitizeTaskAttachmentName(ref.name, index);
-      const filePath = path16.resolve(state.directory, name);
-      if (path16.dirname(filePath) !== state.directory) throw new Error(`attachment ${ref.attachment_id} resolved outside its task directory`);
+      const filePath = path17.resolve(state.directory, name);
+      if (path17.dirname(filePath) !== state.directory) throw new Error(`attachment ${ref.attachment_id} resolved outside its task directory`);
       await writeFile(filePath, content, { flag: "wx", mode: 384 });
       await chmod(filePath, 384);
       files.push({ attachmentId: ref.attachment_id, name, mime: ref.mime, sizeBytes: ref.size_bytes, sha256: sha2562, path: filePath });
@@ -9668,9 +9848,9 @@ async function readSpool(spoolDir = SPOOL_DIR) {
   }
   return out;
 }
-async function readCloudMap(path22) {
+async function readCloudMap(path23) {
   try {
-    return JSON.parse(await readFile2(path22, "utf8"));
+    return JSON.parse(await readFile2(path23, "utf8"));
   } catch {
     return {};
   }
@@ -9971,9 +10151,9 @@ function backoffMs(streak, baseMs) {
   if (streak <= 0) return 0;
   return Math.min(baseMs * 2 ** Math.min(streak - 1, 20), MAX_BACKOFF_MS);
 }
-async function loadState(path22) {
+async function loadState(path23) {
   try {
-    const parsed = JSON.parse(await readFile3(path22, "utf8"));
+    const parsed = JSON.parse(await readFile3(path23, "utf8"));
     if (parsed && typeof parsed === "object" && Number.isInteger(parsed.byte_offset) && parsed.byte_offset >= 0) {
       return { ...parsed, byte_offset: parsed.byte_offset };
     }
@@ -9981,15 +10161,15 @@ async function loadState(path22) {
   }
   return { byte_offset: 0, last_event_id: null, forwarded_total: 0, rejected_total: 0, rejected_event_ids: [] };
 }
-async function saveState(path22, state) {
-  await mkdir2(dirname9(path22), { recursive: true });
-  await writeFile3(path22, JSON.stringify(state, null, 2), "utf8");
+async function saveState(path23, state) {
+  await mkdir2(dirname9(path23), { recursive: true });
+  await writeFile3(path23, JSON.stringify(state, null, 2), "utf8");
 }
-async function readNewBytes(path22, offset, max) {
-  const st = await stat2(path22);
+async function readNewBytes(path23, offset, max) {
+  const st = await stat2(path23);
   if (st.size <= offset) return { buf: Buffer.alloc(0), size: st.size };
   const length = Math.min(st.size - offset, max);
-  const fh = await open(path22, "r");
+  const fh = await open(path23, "r");
   try {
     const buf = Buffer.alloc(length);
     const { bytesRead } = await fh.read(buf, 0, length, offset);
@@ -11082,10 +11262,10 @@ function formatShadowLogLine(record) {
   const loud = record.unexplained_fields?.length ? "!! " : "";
   return `${loud}[prepared-job-shadow] ${parts.join(" ")}`;
 }
-function appendShadowRecord(record, { path: path22 = PREPARED_JOB_SHADOW_SINK, append = appendFileSync, mkdir: mkdir5 = mkdirSync8 } = {}) {
+function appendShadowRecord(record, { path: path23 = PREPARED_JOB_SHADOW_SINK, append = appendFileSync, mkdir: mkdir5 = mkdirSync8 } = {}) {
   try {
-    mkdir5(dirname10(path22), { recursive: true });
-    append(path22, `${JSON.stringify(record)}
+    mkdir5(dirname10(path23), { recursive: true });
+    append(path23, `${JSON.stringify(record)}
 `, "utf8");
     return true;
   } catch {
@@ -11405,7 +11585,7 @@ var init_shared = __esm({
 // ../../scripts/virtual-office/code-runner/account-usage/claude.mjs
 import fs10 from "node:fs";
 import os3 from "node:os";
-import path17 from "node:path";
+import path18 from "node:path";
 function fileCaptureTime(filePath, explicit, statFn) {
   if (typeof explicit === "string" && explicit) return explicit;
   try {
@@ -11419,7 +11599,7 @@ function usageBaseUrl(env2 = process.env) {
   return String(raw).replace(/\/+$/, "");
 }
 function readOAuthToken({ homeDir = os3.homedir(), read = readJson2, now = Date.now() } = {}) {
-  const creds = read(path17.join(homeDir, ".claude", ".credentials.json"));
+  const creds = read(path18.join(homeDir, ".claude", ".credentials.json"));
   const oauth = creds && typeof creds === "object" ? creds.claudeAiOauth : null;
   if (!oauth || typeof oauth !== "object") return null;
   const token2 = typeof oauth.accessToken === "string" ? oauth.accessToken.trim() : "";
@@ -11429,7 +11609,7 @@ function readOAuthToken({ homeDir = os3.homedir(), read = readJson2, now = Date.
   return token2;
 }
 function readAccountId({ homeDir = os3.homedir(), read = readJson2 } = {}) {
-  const cfg = read(path17.join(homeDir, ".claude.json"));
+  const cfg = read(path18.join(homeDir, ".claude.json"));
   const account = cfg && typeof cfg === "object" ? cfg.oauthAccount : null;
   return account && typeof account.accountUuid === "string" ? account.accountUuid : null;
 }
@@ -11539,7 +11719,7 @@ function readClaudeFileUsage({
     if (age === null || age > MAX_FILE_AGE_MS) return null;
     return row;
   };
-  const statusPath = path17.join(homeDir, ".claude", "claude-usage.json");
+  const statusPath = path18.join(homeDir, ".claude", "claude-usage.json");
   const status = read(statusPath);
   if (status && (status.seven_day || status.five_hour)) {
     const row = fresh(makeUsageRow({
@@ -11554,7 +11734,7 @@ function readClaudeFileUsage({
     }));
     if (row) return row;
   }
-  const weeklyPath = path17.join(homeDir, ".claude", "claude-weekly-usage.json");
+  const weeklyPath = path18.join(homeDir, ".claude", "claude-weekly-usage.json");
   const weekly = read(weeklyPath);
   if (weekly) {
     const row = fresh(makeUsageRow({
@@ -11932,20 +12112,6 @@ var init_pr_watcher_failure_confirmation = __esm({
   }
 });
 
-// ../../scripts/virtual-office/code-runner/error-message.mjs
-function boundedErrorMessage(error, maxLength = 240) {
-  try {
-    return String(error?.message ?? error ?? "unknown error").slice(0, maxLength);
-  } catch {
-    return "unknown error";
-  }
-}
-var init_error_message = __esm({
-  "../../scripts/virtual-office/code-runner/error-message.mjs"() {
-    "use strict";
-  }
-});
-
 // ../../scripts/virtual-office/code-runner/watcher-coordination.mjs
 import { createHash as createHash7 } from "node:crypto";
 function ciFixOccurrenceKey({ repo, prNumber, headSha, repairAttempt }) {
@@ -12441,7 +12607,49 @@ var init_superseded_pr_source = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/ci-fix-prompt.mjs
-function buildCiFixPrompt({ prNumber, repo, branch, headSha, failedChecks, prPatch, failedLogs }) {
+function fairSplit(aLen, bLen, budget) {
+  if (aLen + bLen <= budget) return { a: aLen, b: bLen };
+  const half = Math.floor(budget / 2);
+  if (aLen <= half) return { a: aLen, b: budget - aLen };
+  if (bLen <= half) return { a: budget - bLen, b: bLen };
+  return { a: half, b: budget - half };
+}
+function boundHead(content, allocated, label) {
+  if (content.length <= allocated) return content;
+  const marker = `
+[${label} truncated to the first ${allocated} characters available in this dispatch]`;
+  if (marker.length >= allocated) return marker.slice(0, Math.max(0, allocated));
+  return `${content.slice(0, allocated - marker.length)}${marker}`;
+}
+function boundTail(content, allocated, label) {
+  if (content.length <= allocated) return content;
+  const marker = `[${label} truncated to the final ${allocated} characters available in this dispatch]
+`;
+  if (marker.length >= allocated) return marker.slice(0, Math.max(0, allocated));
+  return `${marker}${content.slice(-(allocated - marker.length))}`;
+}
+function boundedEvidenceShares({
+  prPatch,
+  failedLogs,
+  fixedOverheadChars,
+  prNumber,
+  maxTotalChars = CI_FIX_PROMPT_MAX_CHARS
+}) {
+  const patchWanted = String(prPatch || "").trim() || NO_PATCH_EVIDENCE;
+  const logsWanted = String(failedLogs || "").trim() || NO_LOG_EVIDENCE;
+  const available = maxTotalChars - fixedOverheadChars;
+  if (available < NO_PATCH_EVIDENCE.length + NO_LOG_EVIDENCE.length) {
+    throw new Error(
+      `CI-fix prompt for PR #${prNumber ?? "?"} cannot fit its mandatory instructions and identity (${fixedOverheadChars} chars) plus even an empty-evidence notice inside the ${maxTotalChars}-character dispatch limit \u2014 refusing to send a malformed or instructions-truncated request`
+    );
+  }
+  const { a: patchShare, b: logsShare } = fairSplit(patchWanted.length, logsWanted.length, available);
+  return {
+    patchBody: boundHead(patchWanted, patchShare, "PR patch"),
+    logsBody: boundTail(logsWanted, logsShare, "failed-job evidence")
+  };
+}
+function renderHeader({ prNumber, repo, branch, headSha, failedChecks }) {
   return [
     `${CI_FIX_MARKER} An AlgoHQ-dispatched pull request has FAILING CI and needs a fix.`,
     "",
@@ -12460,24 +12668,45 @@ function buildCiFixPrompt({ prNumber, repo, branch, headSha, failedChecks, prPat
     "VO-ALLOW-PR-OVERLAP marker. Your work ships: finish the fix completely, leave UNCOMMITTED",
     "edits, and the runner publishes for you. A denied git/gh is EXPECTED; do NOT retry it.",
     "",
-    HEADLESS_EXECUTION_CONTRACT,
+    HEADLESS_EXECUTION_CONTRACT
+  ].join("\n");
+}
+function assemblePrompt(header, patchBody, logsBody) {
+  return [
+    header,
     "",
     "## Bounded source PR patch excerpt",
     "```diff",
-    prPatch || "[No excerpt available; the complete exact source is still materialized in the worktree.]",
+    patchBody,
     "```",
     "",
     "## Failed-job evidence",
     "```text",
-    failedLogs || "[No failed-job log was available; use the named checks and patch.]",
+    logsBody,
     "```"
   ].join("\n");
 }
+function buildCiFixPrompt({ prNumber, repo, branch, headSha, failedChecks, prPatch, failedLogs }) {
+  const header = renderHeader({ prNumber, repo, branch, headSha, failedChecks });
+  const fixedOverheadChars = assemblePrompt(header, "", "").length;
+  const { patchBody, logsBody } = boundedEvidenceShares({
+    prPatch,
+    failedLogs,
+    fixedOverheadChars,
+    prNumber,
+    maxTotalChars: CI_FIX_PROMPT_MAX_CHARS
+  });
+  return assemblePrompt(header, patchBody, logsBody);
+}
+var CI_FIX_PROMPT_MAX_CHARS, NO_PATCH_EVIDENCE, NO_LOG_EVIDENCE;
 var init_ci_fix_prompt = __esm({
   "../../scripts/virtual-office/code-runner/ci-fix-prompt.mjs"() {
     "use strict";
     init_superseded_pr_source();
     init_headless_execution_contract();
+    CI_FIX_PROMPT_MAX_CHARS = 9900;
+    NO_PATCH_EVIDENCE = "[No excerpt available; the complete exact source is still materialized in the worktree.]";
+    NO_LOG_EVIDENCE = "[No failed-job log was available; use the named checks and patch.]";
   }
 });
 
@@ -12500,7 +12729,7 @@ function noteCiViaRest(log2) {
   log2("watch: CI status read via REST check-runs/status (gh's GraphQL rollup needs actions:read for checkSuite.workflowRun, which the read scope does not carry)");
 }
 async function readCommitCiViaRest(repo, sha, { run, env: env2 }) {
-  const api = async (path22) => JSON.parse(await run("gh", ["api", path22], { timeout: 3e4, env: env2 }) || "{}");
+  const api = async (path23) => JSON.parse(await run("gh", ["api", path23], { timeout: 3e4, env: env2 }) || "{}");
   const rollup = [];
   let total = null;
   for (let page = 1; page <= REST_MAX_PAGES && (total === null || rollup.length < total); page += 1) {
@@ -13164,9 +13393,9 @@ function buildControlHandler({ getStatus, requestStop, allowedOrigin }) {
       res.end();
       return;
     }
-    const path22 = String(req.url || "").split("?")[0];
+    const path23 = String(req.url || "").split("?")[0];
     res.setHeader("content-type", "application/json");
-    if (req.method === "GET" && path22 === "/status") {
+    if (req.method === "GET" && path23 === "/status") {
       let status;
       try {
         status = getStatus();
@@ -13177,7 +13406,7 @@ function buildControlHandler({ getStatus, requestStop, allowedOrigin }) {
       res.end(JSON.stringify({ ok: true, ...status }));
       return;
     }
-    if (req.method === "POST" && path22 === "/stop") {
+    if (req.method === "POST" && path23 === "/stop") {
       if (!isControlOriginAllowed(req.headers.origin, allowedOrigin) || !req.headers["x-vo-control"]) {
         res.statusCode = 403;
         res.end(JSON.stringify({ ok: false, error: "forbidden" }));
@@ -13371,22 +13600,22 @@ var init_effort_mode_config = __esm({
 import { randomUUID as randomUUID6 } from "node:crypto";
 import fs11 from "node:fs";
 import os4 from "node:os";
-import path18 from "node:path";
+import path19 from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 function userCacheRoot() {
   try {
     const home = os4.homedir();
-    if (home) return path18.join(home, ".claude");
+    if (home) return path19.join(home, ".claude");
   } catch {
   }
-  return path18.join(os4.tmpdir(), `vo-model-registry-${randomUUID6()}`);
+  return path19.join(os4.tmpdir(), `vo-model-registry-${randomUUID6()}`);
 }
 function resolveCacheBaseDir(env2 = process.env, moduleDir = __dirname) {
   if (env2.VO_MODEL_REGISTRY_CACHE_DIR) return env2.VO_MODEL_REGISTRY_CACHE_DIR;
   if (env2.VO_RUNNER_RUNTIME_ROOT) return env2.VO_RUNNER_RUNTIME_ROOT;
-  const segments = moduleDir.split(path18.sep);
+  const segments = moduleDir.split(path19.sep);
   const isRepoCheckout2 = segments.at(-1) === "virtual-office" && segments.at(-2) === "scripts";
-  return isRepoCheckout2 ? path18.resolve(moduleDir, "..", "..") : userCacheRoot();
+  return isRepoCheckout2 ? path19.resolve(moduleDir, "..", "..") : userCacheRoot();
 }
 function uniqueModels(models = []) {
   return [...new Set(models.map((model) => String(model || "").trim()).filter(Boolean))];
@@ -13509,7 +13738,7 @@ function readCache(cacheFile = DEFAULT_CACHE_FILE, nowMs = Date.now(), ttlMs = D
   }
 }
 function writeCache(cacheFile = DEFAULT_CACHE_FILE, payload) {
-  fs11.mkdirSync(path18.dirname(cacheFile), { recursive: true });
+  fs11.mkdirSync(path19.dirname(cacheFile), { recursive: true });
   fs11.writeFileSync(cacheFile, JSON.stringify(payload, null, 2));
 }
 async function fetchRegistryCatalog({
@@ -13567,13 +13796,13 @@ var __dirname, DEFAULT_CACHE_DIR, DEFAULT_CACHE_FILE, DEFAULT_TTL_MS3, ANTHROPIC
 var init_model_registry = __esm({
   "../../scripts/virtual-office/model-registry.mjs"() {
     "use strict";
-    __dirname = path18.dirname(fileURLToPath6(import.meta.url));
-    DEFAULT_CACHE_DIR = path18.join(
+    __dirname = path19.dirname(fileURLToPath6(import.meta.url));
+    DEFAULT_CACHE_DIR = path19.join(
       resolveCacheBaseDir(),
       ".virtual-office-cache",
       "model-registry"
     );
-    DEFAULT_CACHE_FILE = path18.join(DEFAULT_CACHE_DIR, "catalog.json");
+    DEFAULT_CACHE_FILE = path19.join(DEFAULT_CACHE_DIR, "catalog.json");
     DEFAULT_TTL_MS3 = 60 * 60 * 1e3;
     ANTHROPIC_API_VERSION = "2023-06-01";
     FAMILY_DEFINITIONS = {
@@ -14212,9 +14441,9 @@ function operatorTierToRung(tier, difficulty, thresholds) {
   if (tier === "best" && difficulty >= thresholds.rungBounds.R5) return "R5";
   return base;
 }
-function readCodexModelsCache({ path: path22 = DEFAULT_CODEX_MODELS_CACHE, read = readFileSync9 } = {}) {
+function readCodexModelsCache({ path: path23 = DEFAULT_CODEX_MODELS_CACHE, read = readFileSync9 } = {}) {
   try {
-    const parsed = JSON.parse(read(path22, "utf8"));
+    const parsed = JSON.parse(read(path23, "utf8"));
     return Array.isArray(parsed?.models) ? parsed : null;
   } catch {
     return null;
@@ -14471,15 +14700,15 @@ function formatDecisionReason(decision, maxLen = 480) {
   const s = `[${decision.routerVersion}] ${decision.taskClass} d=${decision.difficulty} c=${decision.confidence} \u2192 ${decision.rung}/${decision.tier}${decision.effort ? ` effort=${decision.effort}` : ""} turns=${decision.maxTurns} $${decision.maxBudgetUsd}${decision.flags.length ? ` [${decision.flags.join(",")}]` : ""} :: ${decision.reasons.join("; ")}`;
   return s.length > maxLen ? `${s.slice(0, maxLen - 1)}\u2026` : s;
 }
-function appendDecisionFallback(decision, { path: path22 = DECISION_FALLBACK_PATH, append = appendFileSync2, mkdir: mkdir5 = mkdirSync9, task, thresholds, roleCostInputs } = {}) {
+function appendDecisionFallback(decision, { path: path23 = DECISION_FALLBACK_PATH, append = appendFileSync2, mkdir: mkdir5 = mkdirSync9, task, thresholds, roleCostInputs } = {}) {
   try {
-    mkdir5(dirname12(path22), { recursive: true });
-    append(path22, `${JSON.stringify(decision)}
+    mkdir5(dirname12(path23), { recursive: true });
+    append(path23, `${JSON.stringify(decision)}
 `, "utf8");
     if (isRouterDecision(decision)) {
       try {
         const records = buildShadowRecords({ decision, task, thresholds: thresholds || loadThresholds(), roleCostInputs });
-        for (const record of records) append(path22, `${JSON.stringify(record)}
+        for (const record of records) append(path23, `${JSON.stringify(record)}
 `, "utf8");
       } catch {
       }
@@ -15533,7 +15762,7 @@ var init_inference_task_runner = __esm({
 // ../../scripts/virtual-office/code-runner/isolation-audit.mjs
 import fs12 from "node:fs";
 import fsp11 from "node:fs/promises";
-import path19 from "node:path";
+import path20 from "node:path";
 async function defaultRun3(command, args, cwd, options = {}) {
   return runProcess2(command, args, { cwd, timeout: 6e4, ...options });
 }
@@ -15546,7 +15775,7 @@ async function canonicalRootForWorktree(worktreeDir, run) {
     "--path-format=absolute",
     "--git-common-dir"
   ])).trim();
-  const root = path19.dirname(commonDir);
+  const root = path20.dirname(commonDir);
   return samePath3(root, worktreeDir) ? null : root;
 }
 async function snapshot(root, run) {
@@ -15588,21 +15817,21 @@ async function changedPaths(root, run) {
 }
 async function quarantineCanonicalWrites({ baseline, worktreeDir, taskId, run, now }) {
   const paths = await changedPaths(baseline.root, run);
-  const quarantineDir = path19.join(
-    path19.dirname(worktreeDir),
+  const quarantineDir = path20.join(
+    path20.dirname(worktreeDir),
     ".canonical-recovery",
     `${String(taskId || "unknown").replace(/[^a-z0-9-]/gi, "-")}-${now().toISOString().replace(/[:.]/g, "-")}`
   );
   await fsp11.mkdir(quarantineDir, { recursive: true });
   const patch = await git2(run, baseline.root, ["diff", "--binary", "HEAD"], { raw: true });
-  await fsp11.writeFile(path19.join(quarantineDir, "tracked.patch"), patch, "utf8");
+  await fsp11.writeFile(path20.join(quarantineDir, "tracked.patch"), patch, "utf8");
   for (const relative of paths.untracked) {
-    const source = path19.join(baseline.root, relative);
-    const target = path19.join(quarantineDir, "untracked", relative);
-    await fsp11.mkdir(path19.dirname(target), { recursive: true });
+    const source = path20.join(baseline.root, relative);
+    const target = path20.join(quarantineDir, "untracked", relative);
+    await fsp11.mkdir(path20.dirname(target), { recursive: true });
     await fsp11.copyFile(source, target);
   }
-  await fsp11.writeFile(path19.join(quarantineDir, "manifest.json"), `${JSON.stringify({
+  await fsp11.writeFile(path20.join(quarantineDir, "manifest.json"), `${JSON.stringify({
     taskId,
     canonicalRoot: baseline.root,
     canonicalHead: baseline.head,
@@ -15624,8 +15853,8 @@ async function restoreExactCanonicalPaths(baseline, evidence, run) {
     ]);
   }
   for (const relative of evidence.untracked) {
-    const target = path19.resolve(baseline.root, relative);
-    const prefix = `${path19.resolve(baseline.root)}${path19.sep}`;
+    const target = path20.resolve(baseline.root, relative);
+    const prefix = `${path20.resolve(baseline.root)}${path20.sep}`;
     if (!target.startsWith(prefix) || !fs12.existsSync(target)) continue;
     await fsp11.rm(target, { force: true });
   }
@@ -15662,7 +15891,7 @@ var init_isolation_audit = __esm({
     init_process_runner2();
     splitZ2 = (value) => String(value || "").split("\0").map((item) => item.trim()).filter(Boolean);
     samePath3 = (left, right) => {
-      const [a, b] = [left, right].map((value) => path19.resolve(value));
+      const [a, b] = [left, right].map((value) => path20.resolve(value));
       return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
     };
   }
@@ -15984,7 +16213,11 @@ async function finalizePublishedPr({
   const overlapBlocked = pr.overlapDraft === true;
   const blockedRefs = Array.isArray(pr.overlapBlockedBy) && pr.overlapBlockedBy.length > 0 ? pr.overlapBlockedBy.map((n) => `#${n}`).join(", ") : "unresolved (see PR body for the gate report)";
   const overlapNote = overlapBlocked ? ` as DRAFT \u2014 overlap-blocked by ${blockedRefs} (finished work preserved; mark ready after the overlap is resolved)` : "";
-  const fixDispatchGuard = overlapBlocked ? { allowFixDispatch: false } : {};
+  const serializedRunnerFailure = serializeRunnerFailure(run?.failure);
+  const runnerFailure = Boolean(serializedRunnerFailure);
+  const runnerFailureRecord = serializedRunnerFailure ? JSON.parse(serializedRunnerFailure) : null;
+  const runnerFailureMessage = runnerFailureRecord ? `blocked by ${runnerFailureRecord.code}; operator review required: ${runnerFailureRecord.operator_next_action}` : "";
+  const fixDispatchGuard = overlapBlocked || runnerFailure ? { allowFixDispatch: false } : {};
   let resumeQueued = false;
   if (cfg.watchEnabled) {
     try {
@@ -15995,7 +16228,7 @@ async function finalizePublishedPr({
         taskId: id,
         operatorId: task.operator_id,
         tenantId: task.tenant_id,
-        needsContinuation: partial && !rateLimitResume && (task.continuation_attempt ?? 0) < (task.continuation_max_attempts ?? 3),
+        needsContinuation: partial && !rateLimitResume && !runnerFailure && (task.continuation_attempt ?? 0) < (task.continuation_max_attempts ?? 3),
         continuationExhausted: partial && (task.continuation_attempt ?? 0) >= (task.continuation_max_attempts ?? 3),
         repairChain: task.repair_chain ?? {
           root_pr_number: pr.prNumber,
@@ -16052,15 +16285,15 @@ async function finalizePublishedPr({
     safeProgress: safeProgress2,
     log: log2,
     patch: {
-      status: "pr_opened",
-      message: `opened ${pr.prUrl}${overlapNote}${pr.newCommit === false ? " (no new commits \u2014 the branch already held every change)" : ""}`,
+      status: runnerFailure ? "failed" : "pr_opened",
+      message: runnerFailure ? `${runnerFailureMessage}; preserved PR ${pr.prUrl} for owner review` : `opened ${pr.prUrl}${overlapNote}${pr.newCommit === false ? " (no new commits \u2014 the branch already held every change)" : ""}`,
       pr_url: pr.prUrl,
       pr_number: pr.prNumber,
       pr_branch: pr.branch,
       result: (() => {
         const prefix = overlapBlocked ? `[VO-PUBLISH-OVERLAP-BLOCKED: ${blockedRefs}] ` : "";
         const room = 2e3 - prefix.length;
-        return `${prefix}${partial ? partialPrContinuationResult(run, room, rateLimitResume ? "rate_limited" : null) : String(run.summary).slice(0, room)}`;
+        return `${prefix}${partial || runnerFailure ? partialPrContinuationResult(run, room, rateLimitResume ? "rate_limited" : null) : String(run.summary).slice(0, room)}`;
       })(),
       ...runOutcomePatch(run),
       ...terminalLedgerPatch(run)
@@ -16104,13 +16337,14 @@ var init_publication_outcome = __esm({
     init_outcome_commit();
     init_terminal_delivery();
     init_rate_limit_resume();
+    init_error_message();
     defaultRunCommand4 = (cmd, args, cwd, opts = {}) => runProcess2(cmd, args, { cwd, ...opts });
   }
 });
 
 // ../../scripts/virtual-office/code-runner/committed-scratch-cleanup.mjs
 import fsp12 from "node:fs/promises";
-import path20 from "node:path";
+import path21 from "node:path";
 function defaultRun4(command, args, cwd, options = {}) {
   return runProcess2(command, args, { cwd, ...options });
 }
@@ -16118,13 +16352,13 @@ async function resolveSafeScratchTarget(worktreeDir, file) {
   if (!isAgentScratch(file)) {
     throw new Error(`refusing to remove non-scratch publication path: ${file}`);
   }
-  const root = path20.resolve(worktreeDir);
-  const target = path20.resolve(root, file);
-  const relative = path20.relative(root, target);
-  if (!relative || relative.startsWith(`..${path20.sep}`) || path20.isAbsolute(relative)) {
+  const root = path21.resolve(worktreeDir);
+  const target = path21.resolve(root, file);
+  const relative = path21.relative(root, target);
+  if (!relative || relative.startsWith(`..${path21.sep}`) || path21.isAbsolute(relative)) {
     throw new Error(`refusing to remove publication scratch outside worktree: ${file}`);
   }
-  for (let cursor = target; cursor !== root; cursor = path20.dirname(cursor)) {
+  for (let cursor = target; cursor !== root; cursor = path21.dirname(cursor)) {
     try {
       if ((await fsp12.lstat(cursor)).isSymbolicLink()) {
         throw new Error(`refusing to follow symlink while removing publication scratch: ${file}`);
@@ -16246,7 +16480,7 @@ var init_publication_scope = __esm({
 // ../../scripts/virtual-office/code-runner/recovery-ledger.mjs
 import fs13 from "node:fs";
 import fsp13 from "node:fs/promises";
-import path21 from "node:path";
+import path22 from "node:path";
 function recoveryTaskId(prompt) {
   const match = String(prompt || "").match(/VO_RECOVERY_FROM_CODE_TASK:\s*([0-9a-f-]{36})/i);
   return match ? match[1].toLowerCase() : null;
@@ -16260,10 +16494,10 @@ function cloneLeaf(repo) {
 function recoveryLedgerCandidates(repo, clonesRoot2) {
   const leaf = cloneLeaf(repo);
   if (!leaf || !clonesRoot2) return [];
-  const canonical = path21.join(clonesRoot2, leaf);
+  const canonical = path22.join(clonesRoot2, leaf);
   return [
-    path21.join(clonesRoot2, ".agent-worktrees", leaf, "recovery-ledger.jsonl"),
-    path21.join(canonical, ".agent-worktrees", "recovery-ledger.jsonl")
+    path22.join(clonesRoot2, ".agent-worktrees", leaf, "recovery-ledger.jsonl"),
+    path22.join(canonical, ".agent-worktrees", "recovery-ledger.jsonl")
   ];
 }
 async function readLedger(file, readFile6) {
@@ -16441,7 +16675,16 @@ function isMaxTurnExhaustion(run = {}, maxTurns) {
   return Number.isInteger(maxTurns) && maxTurns > 0 && Number.isInteger(run.numTurns) && run.numTurns > maxTurns;
 }
 function decideNoChangesTerminalStatus({ partial, run = {}, maxTurns } = {}) {
+  const structuredFailure = serializeRunnerFailure(run.failure);
   if (!partial) {
+    if (structuredFailure) {
+      const failure = JSON.parse(structuredFailure);
+      return {
+        status: "failed",
+        message: `agent reported a runner blocker with no file changes \u2014 ${failure.code}; ${failure.operator_next_action}`,
+        result: partialPrContinuationResult(run, RESULT_LIMIT)
+      };
+    }
     if (reportsBlocker(run.summary)) {
       return {
         status: "failed",
@@ -16465,8 +16708,8 @@ function decideNoChangesTerminalStatus({ partial, run = {}, maxTurns } = {}) {
   const cause = String(run.summary || "").trim();
   return {
     status: "failed",
-    message: cause ? `agent made no file changes \u2014 ${cause.slice(0, 200)}` : "agent made no file changes",
-    result: (cause || "no_changes").slice(0, RESULT_LIMIT)
+    message: structuredFailure ? `agent made no file changes \u2014 ${JSON.parse(structuredFailure).code}; ${JSON.parse(structuredFailure).operator_next_action}` : cause ? `agent made no file changes \u2014 ${cause.slice(0, 200)}` : "agent made no file changes",
+    result: structuredFailure ? partialPrContinuationResult(run, RESULT_LIMIT) : (cause || "no_changes").slice(0, RESULT_LIMIT)
   };
 }
 async function closeSupersededSourceOnNoChanges({
@@ -16599,6 +16842,8 @@ var init_no_changes_terminal_status = __esm({
     init_terminal_ledger_patch();
     init_outcome_commit();
     init_terminal_delivery();
+    init_error_message();
+    init_partial_pr_continuation();
     RESULT_LIMIT = 2e3;
   }
 });
@@ -16916,6 +17161,50 @@ var init_daemon_config = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/task-worktree-preparation.mjs
+async function git3(worktreeDir, args, runCommand = runProcess2) {
+  const result = await runCommand("git", args, { cwd: worktreeDir, timeoutMs: 6e4 });
+  if (result.status !== 0) throw new Error(`source binding git ${args[0]} failed before model execution`);
+  return String(result.stdout || "").trim();
+}
+function hasAffirmativePreSpawnNoSpendEvidence(parentTask) {
+  return Boolean(parentTask && parentTask.status === "failed" && parentTask.completed_at && parentTask.execution_started_at === null && parentTask.usage_reported_at && parentTask.cost_usd === 0 && parentTask.cost_basis === "no_agent_spawned" && typeof parentTask.claimed_by === "string" && parentTask.claimed_by.length > 0 && RUNNER_INSTANCE_ID.test(parentTask.runner_instance_id ?? "") && parentTask.usage_runner_instance_id === parentTask.runner_instance_id && !parentTask.token_usage && !parentTask.model_usage && !parentTask.detached_run_economics?.length && !parentTask.resumed_from && !parentTask.pr_branch && !parentTask.pr_url && !parentTask.pr_number);
+}
+async function bindTaskExecutionSource({
+  client,
+  task,
+  parentTask,
+  worktreeDir,
+  continuationRestore,
+  runCommand = runProcess2
+}) {
+  const baseSha = task.comparative_base_sha;
+  if (!baseSha) return null;
+  if (!EXACT_SHA.test(baseSha)) throw new Error("comparative base SHA is invalid");
+  const actualSha = await git3(worktreeDir, ["rev-parse", "HEAD"], runCommand);
+  if (!EXACT_SHA.test(actualSha)) throw new Error("worktree HEAD is not an exact commit SHA");
+  if (!task.resumed_from) {
+    if (actualSha !== baseSha) throw new Error("initial comparative worktree HEAD does not match requested base");
+  } else if (continuationRestore) {
+    if (task.pr_head_sha_at_enqueue && actualSha !== task.pr_head_sha_at_enqueue) {
+      throw new Error("continuation worktree HEAD does not match its expected continuation head");
+    }
+    await git3(worktreeDir, ["merge-base", "--is-ancestor", baseSha, actualSha], runCommand);
+  } else {
+    if (!hasAffirmativePreSpawnNoSpendEvidence(parentTask)) {
+      throw new Error("continuation branch is missing and prior execution state is unknown; recovery review required");
+    }
+    if (actualSha !== baseSha) throw new Error("safe pre-spawn continuation did not rematerialize the original base");
+  }
+  const acknowledgement = await client.postProgress(task.code_task_id, {
+    execution_start_sha: actualSha,
+    stage: "preparing_worktree",
+    message: `Exact execution source ${actualSha} verified before model start`
+  });
+  if (acknowledgement?.terminal || acknowledgement?.task?.execution_start_sha !== actualSha) {
+    throw new Error("control plane did not durably acknowledge execution_start_sha");
+  }
+  return { baseSha, executionStartSha: actualSha };
+}
 async function prepareTaskWorktree({ client, task, cfg, safeProgress: safeProgress2, log: log2 }) {
   const id = task.code_task_id;
   await safeProgress2(client, id, runnerStagePatch(
@@ -16932,7 +17221,7 @@ async function prepareTaskWorktree({ client, task, cfg, safeProgress: safeProgre
   const wt = await createFixWorktree(
     "code-task",
     { source: id.slice(0, 8), repo: task.repo },
-    { githubToken }
+    { githubToken, baseSha: task.comparative_base_sha ?? null }
   );
   if (!wt.worktreeName || !wt.worktreeDir) {
     throw new Error("worktree isolation failure \u2014 refusing to run in the main tree");
@@ -16962,8 +17251,16 @@ async function prepareTaskWorktree({ client, task, cfg, safeProgress: safeProgre
     });
     log2(repairPlan.strategy === "in-place" ? `task ${id}: repairing ${task.repo}#${task.repair_pr_number}@${repairPlan.headSha} IN PLACE on ${repairPlan.remoteBranch}` : `task ${id}: materialized full repair source ${task.repo}#${task.repair_pr_number}@${repairPlan.headSha} for supersede (${repairPlan.reason})${repairPlan.conflicted ? " with conflicts for the agent to resolve" : ""}`);
   }
-  return { wt, githubToken, agentGithubReadToken, continuationRestore, repairPlan };
+  const sourceBinding = await bindTaskExecutionSource({
+    client,
+    task,
+    parentTask,
+    worktreeDir: wt.worktreeDir,
+    continuationRestore
+  });
+  return { wt, githubToken, agentGithubReadToken, continuationRestore, repairPlan, sourceBinding };
 }
+var EXACT_SHA, RUNNER_INSTANCE_ID;
 var init_task_worktree_preparation = __esm({
   "../../scripts/virtual-office/code-runner/task-worktree-preparation.mjs"() {
     "use strict";
@@ -16971,6 +17268,9 @@ var init_task_worktree_preparation = __esm({
     init_resume_branch();
     init_repair_publication_strategy();
     init_task_helpers();
+    init_process_runner2();
+    EXACT_SHA = /^[0-9a-f]{40}$/u;
+    RUNNER_INSTANCE_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
   }
 });