@algosuite/vo-mcp 0.2.0-beta.7 → 0.2.0-beta.8

package/dist/runner-cli.js

@@ -1297,15 +1297,41 @@ var init_pnpm_hydration = __esm({
   }
 });
 
-// src/runner/worktree-cleanup.mjs
+// src/runner/worktree-paths.mjs
 import { createHash as createHash2 } from "node:crypto";
-import fs3 from "node:fs";
-import fsp6 from "node:fs/promises";
 import path5 from "node:path";
-function worktreeDirForName(root, worktreeName) {
+function samePath(left, right) {
+  const a = path5.resolve(left);
+  const b = path5.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 = path5.resolve(root);
+  if (clonesRootDir) {
+    const clonePool = path5.resolve(clonesRootDir);
+    if (samePath(path5.dirname(canonicalRoot), clonePool)) {
+      return path5.join(clonePool, ".agent-worktrees", path5.basename(canonicalRoot));
+    }
+  }
+  return path5.join(canonicalRoot, ".agent-worktrees");
+}
+function worktreeDirForName(root, worktreeName, options = {}) {
   const leaf = createHash2("sha256").update(String(worktreeName)).digest("hex").slice(0, 16);
-  return path5.join(root, ".agent-worktrees", leaf);
+  return path5.join(worktreePoolForRoot(root, options), leaf);
 }
+function recoveryLedgerPathForRoot(root, options = {}) {
+  return path5.join(worktreePoolForRoot(root, options), "recovery-ledger.jsonl");
+}
+var init_worktree_paths = __esm({
+  "src/runner/worktree-paths.mjs"() {
+    "use strict";
+  }
+});
+
+// src/runner/worktree-cleanup.mjs
+import fs3 from "node:fs";
+import fsp6 from "node:fs/promises";
+import path6 from "node:path";
 function stateFromEntry(entry) {
   return {
     root: entry.root,
@@ -1344,16 +1370,16 @@ function pruneSuccessfulStates(nowMs = Date.now()) {
   }
 }
 function assertTrackedCleanupPath(entry) {
-  const poolRoot = path5.join(entry.root, ".agent-worktrees");
+  const poolRoot = worktreePoolForRoot(entry.root);
   const expected = worktreeDirForName(entry.root, entry.worktreeName);
-  const resolvedPool = path5.resolve(poolRoot);
-  const resolvedTarget = path5.resolve(entry.worktreeDir);
-  if (!resolvedTarget.startsWith(`${resolvedPool}${path5.sep}`)) {
+  const resolvedPool = path6.resolve(poolRoot);
+  const resolvedTarget = path6.resolve(entry.worktreeDir);
+  if (!resolvedTarget.startsWith(`${resolvedPool}${path6.sep}`)) {
     const error = new Error(`cleanup refused outside managed pool: ${entry.worktreeDir}`);
     error.cleanupFatal = true;
     throw error;
   }
-  if (resolvedTarget !== path5.resolve(expected)) {
+  if (resolvedTarget !== path6.resolve(expected)) {
     const error = new Error(`cleanup refused for unexpected tracked path: ${entry.worktreeDir}`);
     error.cleanupFatal = true;
     throw error;
@@ -1367,8 +1393,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) => path5.resolve(line.slice("worktree ".length).trim()));
-  return registered.includes(path5.resolve(worktreeDir));
+  const registered = String(result.stdout || "").split(/\r?\n/u).filter((line) => line.startsWith("worktree ")).map((line) => path6.resolve(line.slice("worktree ".length).trim()));
+  return registered.includes(path6.resolve(worktreeDir));
 }
 function cleanupBackoff(attempt) {
   return 250 * attempt;
@@ -1478,7 +1504,7 @@ function scheduleTrackedCleanup(entry, options = {}) {
 }
 function pendingCleanupDirs() {
   return new Set(
-    [...CLEANUP_STATES.values()].filter((state) => state.status === "pending").map((state) => path5.resolve(state.worktreeDir))
+    [...CLEANUP_STATES.values()].filter((state) => state.status === "pending").map((state) => path6.resolve(state.worktreeDir))
   );
 }
 var CLEANUP_STATES, CLEANUP_PROMISES, SUCCESS_HISTORY_LIMIT, SUCCESS_HISTORY_TTL_MS, DEFAULT_CLEANUP_ATTEMPTS;
@@ -1487,6 +1513,7 @@ var init_worktree_cleanup = __esm({
     "use strict";
     init_pnpm_link_detach();
     init_process_runner();
+    init_worktree_paths();
     CLEANUP_STATES = /* @__PURE__ */ new Map();
     CLEANUP_PROMISES = /* @__PURE__ */ new Map();
     SUCCESS_HISTORY_LIMIT = 50;
@@ -1498,13 +1525,13 @@ var init_worktree_cleanup = __esm({
 // src/runner/task-root-prepare.mjs
 import fs4 from "node:fs";
 import fsp7 from "node:fs/promises";
-import path6 from "node:path";
+import path7 from "node:path";
 function prepLockDir(root) {
-  return path6.join(root, ".agent-worktrees", "runner-root-prep.lock");
+  return path7.join(root, ".agent-worktrees", "runner-root-prep.lock");
 }
 function readLockMeta(lockDir) {
   try {
-    return JSON.parse(fs4.readFileSync(path6.join(lockDir, "owner.json"), "utf8"));
+    return JSON.parse(fs4.readFileSync(path7.join(lockDir, "owner.json"), "utf8"));
   } catch {
     return null;
   }
@@ -1524,9 +1551,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 = path6.join(lockDir, "owner.json");
+  const ownerPath = path7.join(lockDir, "owner.json");
   const deadline = nowMs() + waitMs;
-  fs4.mkdirSync(path6.dirname(lockDir), { recursive: true });
+  fs4.mkdirSync(path7.dirname(lockDir), { recursive: true });
   for (; ; ) {
     try {
       fs4.mkdirSync(lockDir);
@@ -1574,10 +1601,104 @@ async function gitText(root, args, options = {}) {
   }
   return String(result.stdout || "").trim();
 }
-async function alignCanonicalClone(root, options = {}) {
+function canonicalRecoveryDir(root, options = {}) {
+  const now = options.now || (() => /* @__PURE__ */ new Date());
+  return path7.join(
+    options.managedPool || path7.join(root, ".agent-worktrees"),
+    ".canonical-recovery",
+    `preexisting-${now().toISOString().replace(/[:.]/gu, "-")}`
+  );
+}
+function canonicalPath(root, relative) {
+  const resolvedRoot = path7.resolve(root);
+  const target = path7.resolve(root, relative);
+  const prefix = `${resolvedRoot}${path7.sep}`;
+  if (!target.startsWith(prefix)) {
+    throw new Error(`canonical recovery path escaped the runner clone: ${relative}`);
+  }
+  return target;
+}
+async function changedCanonicalPaths(root, options = {}) {
+  const [trackedResult, untrackedResult] = await Promise.all([
+    git(root, ["-c", "core.quotepath=false", "diff", "--name-only", "-z", "HEAD"], options),
+    git(root, ["-c", "core.quotepath=false", "ls-files", "--others", "--exclude-standard", "-z"], options)
+  ]);
+  if (trackedResult.status !== 0 || untrackedResult.status !== 0) {
+    throw new Error("could not enumerate canonical clone residue before recovery");
+  }
+  return {
+    tracked: splitZ(trackedResult.stdout),
+    untracked: splitZ(untrackedResult.stdout)
+  };
+}
+async function recoverManagedCanonicalResidue(root, options = {}) {
+  const paths = await changedCanonicalPaths(root, options);
+  const quarantineDir = canonicalRecoveryDir(root, options);
+  const headSha = await gitText(root, ["rev-parse", "HEAD"], options);
+  await fsp7.mkdir(quarantineDir, { recursive: true });
+  const patchResult = await git(root, ["diff", "--binary", "HEAD"], options);
+  if (patchResult.status !== 0) {
+    throw new Error(`could not preserve canonical tracked changes: ${summarizeProcessFailure(patchResult)}`);
+  }
+  await fsp7.writeFile(path7.join(quarantineDir, "tracked.patch"), String(patchResult.stdout || ""), "utf8");
+  const symlinks = [];
+  for (const relative of paths.untracked) {
+    const source = canonicalPath(root, relative);
+    const stat = await fsp7.lstat(source);
+    if (stat.isSymbolicLink()) {
+      symlinks.push({ path: relative, target: await fsp7.readlink(source) });
+      continue;
+    }
+    if (!stat.isFile()) {
+      throw new Error(`canonical recovery refuses unsupported untracked entry: ${relative}`);
+    }
+    const target = canonicalPath(path7.join(quarantineDir, "untracked"), relative);
+    await fsp7.mkdir(path7.dirname(target), { recursive: true });
+    await fsp7.copyFile(source, target);
+  }
+  await fsp7.writeFile(path7.join(quarantineDir, "manifest.json"), `${JSON.stringify({
+    recoveredAt: (/* @__PURE__ */ new Date()).toISOString(),
+    canonicalRoot: path7.resolve(root),
+    canonicalHead: headSha,
+    tracked: paths.tracked,
+    untracked: paths.untracked,
+    symlinks
+  }, null, 2)}
+`, "utf8");
+  if (paths.tracked.length > 0) {
+    const restored = await git(root, [
+      "restore",
+      `--source=${headSha}`,
+      "--staged",
+      "--worktree",
+      "--",
+      ...paths.tracked
+    ], options);
+    if (restored.status !== 0) {
+      throw new Error(`could not restore canonical tracked changes; evidence: ${quarantineDir}`);
+    }
+  }
+  for (const relative of paths.untracked) {
+    await fsp7.rm(canonicalPath(root, relative), { force: true });
+  }
   const status = await gitText(root, ["status", "--porcelain"], options);
   if (status) {
-    throw new Error(`canonical clone is dirty: ${status.split(/\r?\n/u, 1)[0]}`);
+    throw new Error(`canonical clone recovery did not restore a clean tree; evidence: ${quarantineDir}`);
+  }
+  (options.logger || console.error)(
+    `[vo-mcp runner] preserved and recovered ${paths.tracked.length + paths.untracked.length} preexisting canonical-clone write(s): ${quarantineDir}`
+  );
+  return { quarantineDir, ...paths };
+}
+async function alignCanonicalClone(root, options = {}) {
+  let status = await gitText(root, ["status", "--porcelain"], options);
+  if (status) {
+    if (options.recoverDirtyCanonical !== true) {
+      throw new Error(`canonical clone is dirty: ${status.split(/\r?\n/u, 1)[0]}`);
+    }
+    await recoverManagedCanonicalResidue(root, options);
+    status = await gitText(root, ["status", "--porcelain"], options);
+    if (status) throw new Error("canonical clone remained dirty after managed recovery");
   }
   const branch = await gitText(root, ["branch", "--show-current"], options);
   if (branch !== "main") {
@@ -1609,11 +1730,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) => path6.resolve(line.slice("worktree ".length).trim()))
+    String(listed.stdout || "").split(/\r?\n/u).filter((line) => line.startsWith("worktree ")).map((line) => path7.resolve(line.slice("worktree ".length).trim()))
   );
 }
 async function reportLegacyResiduals(root, options = {}) {
-  const managedRoot = path6.join(root, ".agent-worktrees");
+  const managedRoot = path7.join(root, ".agent-worktrees");
   if (!fs4.existsSync(managedRoot)) return [];
   const registered = await registeredWorktreeDirs(root, options);
   const pending = pendingCleanupDirs();
@@ -1621,7 +1742,7 @@ async function reportLegacyResiduals(root, options = {}) {
   for (const entry of fs4.readdirSync(managedRoot, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
     if (shouldIgnoreManagedEntry(entry.name)) continue;
-    const absolute = path6.resolve(path6.join(managedRoot, entry.name));
+    const absolute = path7.resolve(path7.join(managedRoot, entry.name));
     if (registered.has(absolute)) continue;
     if (pending.has(absolute)) continue;
     found.push(absolute);
@@ -1649,7 +1770,7 @@ async function prepareTaskRoot(root, options = {}) {
     await release();
   }
 }
-var PREP_LOCK_WAIT_MS, PREP_LOCK_STALE_MS, REPORTED_RESIDUAL_SNAPSHOTS, IGNORED_MANAGED_ENTRIES;
+var PREP_LOCK_WAIT_MS, PREP_LOCK_STALE_MS, REPORTED_RESIDUAL_SNAPSHOTS, IGNORED_MANAGED_ENTRIES, splitZ;
 var init_task_root_prepare = __esm({
   "src/runner/task-root-prepare.mjs"() {
     "use strict";
@@ -1660,19 +1781,20 @@ var init_task_root_prepare = __esm({
     PREP_LOCK_STALE_MS = 45 * 60 * 1e3;
     REPORTED_RESIDUAL_SNAPSHOTS = /* @__PURE__ */ new Set();
     IGNORED_MANAGED_ENTRIES = /* @__PURE__ */ new Set([
+      ".canonical-recovery",
       "recovery-ledger.jsonl",
       "runner-pnpm-hydration.json",
       "runner-node-modules-quarantine",
       "runner-root-prep.lock"
     ]);
+    splitZ = (value) => String(value || "").split("\0").filter((item) => item.length > 0);
   }
 });
 
 // src/runner/worktree-helper.mjs
-import { createHash as createHash3 } from "node:crypto";
 import fs5 from "node:fs";
 import fsp8 from "node:fs/promises";
-import path7 from "node:path";
+import path8 from "node:path";
 function repoRoot() {
   return process.env.VO_CODE_RUNNER_REPO || process.cwd();
 }
@@ -1683,16 +1805,12 @@ function sanitize(value, fallback) {
   const cleaned = String(value || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
   return cleaned || fallback;
 }
-function worktreeDirForName2(root, worktreeName) {
-  const leaf = createHash3("sha256").update(String(worktreeName)).digest("hex").slice(0, 16);
-  return path7.join(root, ".agent-worktrees", leaf);
-}
 function cloneDirForSlug(repoSlug, clonesRootDir) {
   if (!clonesRootDir || !repoSlug || !VALID_REPO_SLUG.test(String(repoSlug))) return null;
   const [owner, name] = String(repoSlug).split("/");
   if (owner === "." || owner === ".." || name === "." || name === "..") return null;
   if (owner.startsWith("-") || name.startsWith("-")) return null;
-  return path7.join(clonesRootDir, `${sanitize(owner, "owner")}__${sanitize(name, "repo")}`);
+  return path8.join(clonesRootDir, `${sanitize(owner, "owner")}__${sanitize(name, "repo")}`);
 }
 function cloneLockDir(dir) {
   return `${dir}.clone-lock`;
@@ -1707,7 +1825,7 @@ async function pathExists5(target) {
 }
 async function readLockMeta2(lockDir) {
   try {
-    return JSON.parse(await fsp8.readFile(path7.join(lockDir, "owner.json"), "utf8"));
+    return JSON.parse(await fsp8.readFile(path8.join(lockDir, "owner.json"), "utf8"));
   } catch {
     return null;
   }
@@ -1728,11 +1846,11 @@ async function acquireCloneLock(dir, options = {}) {
   const sleep3 = options.sleep || sleepMs;
   const lockDir = cloneLockDir(dir);
   const deadline = nowMs() + waitMs;
-  await fsp8.mkdir(path7.dirname(lockDir), { recursive: true });
+  await fsp8.mkdir(path8.dirname(lockDir), { recursive: true });
   for (; ; ) {
     try {
       await fsp8.mkdir(lockDir);
-      await fsp8.writeFile(path7.join(lockDir, "owner.json"), `${JSON.stringify({
+      await fsp8.writeFile(path8.join(lockDir, "owner.json"), `${JSON.stringify({
         pid: process.pid,
         createdAt: new Date(nowMs()).toISOString(),
         dir
@@ -1761,7 +1879,7 @@ async function acquireCloneLock(dir, options = {}) {
   }
 }
 async function isUsableGitClone(dir, runner = runProcess) {
-  if (!await pathExists5(path7.join(dir, ".git"))) return false;
+  if (!await pathExists5(path8.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());
 }
@@ -1782,7 +1900,7 @@ async function ensureUsableClone(repoSlug, dir, options = {}) {
     const maxAttempts = options.maxAttempts || 5;
     const raceWaitMs = options.raceWaitMs ?? 1e4;
     let lastError = null;
-    await fsp8.mkdir(path7.dirname(dir), { recursive: true });
+    await fsp8.mkdir(path8.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;
@@ -1794,7 +1912,7 @@ async function ensureUsableClone(repoSlug, dir, options = {}) {
         ["clone", "--no-tags", `https://github.com/${owner}/${name}.git`, tmpDir],
         { timeoutMs: 6e5 }
       );
-      if (clone.status !== 0 || !await pathExists5(path7.join(tmpDir, ".git"))) {
+      if (clone.status !== 0 || !await pathExists5(path8.join(tmpDir, ".git"))) {
         await fsp8.rm(tmpDir, { recursive: true, force: true });
         lastError = new Error(`[vo-mcp runner] clone failed for ${repoSlug}: ${describeGitFailure(clone)}`);
         continue;
@@ -1821,7 +1939,7 @@ async function ensureUsableClone(repoSlug, dir, options = {}) {
 }
 async function resolveTaskRoot(repoSlug) {
   const root = clonesRoot();
-  if (root && !path7.isAbsolute(root)) {
+  if (root && !path8.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);
@@ -1866,9 +1984,12 @@ async function createFixWorktree(kind, error = {}, options = {}) {
   const unique = `${process.pid}-${Math.random().toString(36).slice(2, 8)}`;
   const worktreeName = `${safeKind}-${safeTarget}-${stamp}-${unique}`;
   const branchName = `vo/${worktreeName}`;
-  const worktreeDir = worktreeDirForName2(root, worktreeName);
+  const worktreeDir = worktreeDirForName(root, worktreeName);
   const dependencyOwnership = createDependencyOwnershipTracker(worktreeDir);
-  const prep = await prepare(root);
+  const prep = await prepare(root, {
+    recoverDirtyCanonical: multiRepo,
+    managedPool: path8.dirname(worktreeDir)
+  });
   await processRunner("git", ["config", "core.longpaths", "true"], { cwd: root, timeoutMs: 3e4 });
   const add = await addWorktree({ root, branchName, worktreeDir });
   if (!add.ok) {
@@ -1920,7 +2041,7 @@ function preserveFailedWorktree(worktreeName, meta = {}) {
   const tracked = TRACKED_WORKTREES.get(worktreeName);
   if (tracked) TRACKED_WORKTREES.delete(worktreeName);
   const root = tracked ? tracked.root : repoRoot();
-  const worktreeDir = tracked ? tracked.worktreeDir : worktreeDirForName2(root, worktreeName);
+  const worktreeDir = tracked ? tracked.worktreeDir : worktreeDirForName(root, worktreeName);
   const entry = {
     at: (/* @__PURE__ */ new Date()).toISOString(),
     worktreeName,
@@ -1932,8 +2053,8 @@ function preserveFailedWorktree(worktreeName, meta = {}) {
     reason: String(meta.reason || "task failed").slice(0, 300)
   };
   try {
-    const ledger = path7.join(root, ".agent-worktrees", "recovery-ledger.jsonl");
-    fs5.mkdirSync(path7.dirname(ledger), { recursive: true });
+    const ledger = recoveryLedgerPathForRoot(root);
+    fs5.mkdirSync(path8.dirname(ledger), { recursive: true });
     fs5.appendFileSync(ledger, `${JSON.stringify(entry)}
 `, "utf8");
     console.error(`[vo-mcp runner] Preserved worktree ${worktreeName} (reason: ${entry.reason})`);
@@ -1951,6 +2072,8 @@ var init_worktree_helper = __esm({
     init_pnpm_hydration();
     init_task_root_prepare();
     init_worktree_cleanup();
+    init_worktree_paths();
+    init_worktree_paths();
     VALID_REPO_SLUG = /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/u;
     DEFAULT_CLONE_LOCK_WAIT_MS = 12e4;
     DEFAULT_CLONE_LOCK_STALE_MS = 30 * 60 * 1e3;
@@ -2008,9 +2131,9 @@ function createControlPlaneClient({
     throw new Error("VO_CONTROL_PLANE_URL is required for the code-runner daemon");
   }
   const root = baseUrl.replace(/\/+$/, "");
-  async function req(method, path12, body) {
+  async function req(method, path16, body) {
     const bearer = await resolveBearer(env2);
-    return fetchImpl(`${root}${path12}`, {
+    return fetchImpl(`${root}${path16}`, {
       method,
       headers: {
         "content-type": "application/json",
@@ -2200,6 +2323,34 @@ function createControlPlaneClient({
       if (!res.ok) throw new Error(`heartbeat failed: HTTP ${res.status}`);
       return true;
     },
+    /** Poll one authenticated runner's durable Mission Control action queue. */
+    async pollRunnerControl({ runnerId, operatorId }) {
+      const body = { runner_id: runnerId };
+      if (operatorId) body.operator_id = operatorId;
+      const res = await req("POST", "/api/v1/runner/control/poll", body);
+      if (res.status === 401) {
+        cachedFirebaseToken = null;
+        throw new Error("runner control poll unauthorized (401)");
+      }
+      if (!res.ok) throw new Error(`runner control poll failed: HTTP ${res.status}`);
+      const json = await res.json();
+      const action = json?.action;
+      return action && typeof action.action_id === "string" && action.action_id ? { ...action, actionId: action.action_id } : null;
+    },
+    /** Acknowledge a maintenance action after the host has restarted the child. */
+    async completeRunnerControl(actionId, { runnerId, operatorId, status, detail }) {
+      const body = { runner_id: runnerId, status };
+      if (operatorId) body.operator_id = operatorId;
+      if (detail) body.detail = detail;
+      const res = await req("POST", `/api/v1/runner/control/${encodeURIComponent(actionId)}/complete`, body);
+      if (res.status === 401) {
+        cachedFirebaseToken = null;
+        throw new Error("runner control completion unauthorized (401)");
+      }
+      if (!res.ok) throw new Error(`runner control completion failed: HTTP ${res.status}`);
+      const json = await res.json();
+      return json?.action || null;
+    },
     /**
      * Mint a short-lived (~1h), repo-scoped GitHub App installation token for
      * THIS runner's operator (M3). The control-plane keys the mint on the
@@ -2257,9 +2408,121 @@ var init_control_plane_client = __esm({
   }
 });
 
+// ../../scripts/virtual-office/code-runner/windows-claude-launch.mjs
+import { existsSync as existsSync2, realpathSync } from "node:fs";
+import { win32 as path9 } from "node:path";
+import { spawnSync } from "node:child_process";
+function pathValue(env2) {
+  for (const key of ["Path", "PATH", "path"]) {
+    if (typeof env2?.[key] === "string") return env2[key];
+  }
+  return "";
+}
+function cleanPathSegment(value) {
+  const trimmed = String(value || "").trim();
+  return trimmed.startsWith('"') && trimmed.endsWith('"') ? trimmed.slice(1, -1) : trimmed;
+}
+function pathCandidates(bin, env2) {
+  if (path9.isAbsolute(bin) || /[\\/]/u.test(bin)) {
+    return [path9.resolve(bin)];
+  }
+  const extension = path9.extname(bin);
+  return pathValue(env2).split(";").map(cleanPathSegment).filter(Boolean).flatMap((directory) => extension ? [path9.join(directory, bin)] : [
+    path9.join(directory, `${bin}.exe`),
+    path9.join(directory, `${bin}.cmd`),
+    path9.join(directory, `${bin}.ps1`),
+    path9.join(directory, bin)
+  ]);
+}
+function canonicalExistingPath(candidate, exists, canonicalize) {
+  if (!exists(candidate)) return null;
+  try {
+    return canonicalize(candidate);
+  } catch {
+    return null;
+  }
+}
+function resolveWindowsClaudeExecutable({
+  bin = "claude",
+  env: env2 = process.env,
+  exists = existsSync2,
+  canonicalize = realpathSync
+} = {}) {
+  const requested = String(bin || "").trim();
+  if (!requested || requested.includes("\0")) {
+    throw new TypeError("Claude executable must be a non-empty path without NUL bytes");
+  }
+  for (const candidate of pathCandidates(requested, env2)) {
+    const found = canonicalExistingPath(candidate, exists, canonicalize);
+    if (!found) continue;
+    if (path9.extname(found).toLowerCase() === ".exe") return found;
+    const native = path9.join(path9.dirname(found), ...NATIVE_CLAUDE_PARTS);
+    const resolvedNative = canonicalExistingPath(native, exists, canonicalize);
+    if (resolvedNative) return resolvedNative;
+  }
+  const error = new Error(
+    `Could not resolve a native claude.exe for "${requested}". Update Claude Code with npm install -g @anthropic-ai/claude-code; the VO runner will not execute a shell-only .cmd/.ps1 shim.`
+  );
+  error.code = "ENOENT";
+  throw error;
+}
+function buildWindowsClaudeLaunch({
+  bin = "claude",
+  args = [],
+  env: env2 = process.env
+} = {}) {
+  return {
+    bin: resolveWindowsClaudeExecutable({ bin, env: env2 }),
+    args: Array.from(args, (value) => String(value)),
+    spawnOptions: {
+      shell: false,
+      windowsHide: true,
+      windowsVerbatimArguments: false
+    }
+  };
+}
+function spawnClaudeSync(args = [], options = {}) {
+  if (process.platform !== "win32") {
+    return spawnSync("claude", args, { windowsHide: true, ...options });
+  }
+  try {
+    const launch = buildWindowsClaudeLaunch({
+      bin: "claude",
+      args,
+      env: options.env || process.env
+    });
+    return spawnSync(launch.bin, launch.args, {
+      ...options,
+      ...launch.spawnOptions
+    });
+  } catch (error) {
+    return {
+      error,
+      status: null,
+      signal: null,
+      output: null,
+      stdout: null,
+      stderr: null
+    };
+  }
+}
+var NATIVE_CLAUDE_PARTS;
+var init_windows_claude_launch = __esm({
+  "../../scripts/virtual-office/code-runner/windows-claude-launch.mjs"() {
+    "use strict";
+    NATIVE_CLAUDE_PARTS = [
+      "node_modules",
+      "@anthropic-ai",
+      "claude-code",
+      "bin",
+      "claude.exe"
+    ];
+  }
+});
+
 // ../../scripts/virtual-office/code-runner/anthropic-key-store.mjs
 import { createRequire as createRequire2 } from "node:module";
-import { spawnSync } from "node:child_process";
+import { spawnSync as spawnSync2 } from "node:child_process";
 function defaultEntryCtor() {
   if (_loadTried) return _entryCtor;
   _loadTried = true;
@@ -2283,7 +2546,7 @@ function isTruthyFlag(v) {
   return s === "1" || s === "true" || s === "yes" || s === "on";
 }
 function withAnthropicKey(baseEnv = {}, { getKey = getAnthropicKey } = {}) {
-  if (isTruthyFlag(baseEnv[PREFER_LOGIN_ENV])) {
+  if (isTruthyFlag(baseEnv[CLAUDE_PREFER_LOGIN_ENV]) || isTruthyFlag(baseEnv[PREFER_LOGIN_ENV])) {
     const next = { ...baseEnv };
     delete next.ANTHROPIC_API_KEY;
     return next;
@@ -2293,7 +2556,7 @@ function withAnthropicKey(baseEnv = {}, { getKey = getAnthropicKey } = {}) {
   return key ? { ...baseEnv, ANTHROPIC_API_KEY: key } : { ...baseEnv };
 }
 function describeAnthropicAuthSource(baseEnv = {}, { getKey = getAnthropicKey } = {}) {
-  if (isTruthyFlag(baseEnv[PREFER_LOGIN_ENV])) {
+  if (isTruthyFlag(baseEnv[CLAUDE_PREFER_LOGIN_ENV]) || isTruthyFlag(baseEnv[PREFER_LOGIN_ENV])) {
     return "claude auth login (VO_RUNNER_PREFER_LOGIN set \u2014 any API key ignored)";
   }
   if (baseEnv.ANTHROPIC_API_KEY) return "ANTHROPIC_API_KEY from environment";
@@ -2306,29 +2569,31 @@ function augmentAuthError(summary) {
   return `${s}
 \u21B3 Anthropic auth failed on the runner. The \`claude\` CLI is a SEPARATE install/login from the Claude Desktop app and the Claude Code IDE extension \u2014 signing into those does NOT authenticate it. Fix: run \`claude auth login\` (Claude subscription) on the runner machine, or clear any stale ANTHROPIC_API_KEY (env / OS keychain / .env.local) and set VO_RUNNER_PREFER_LOGIN=1 \u2014 then restart the runner. Verify with \`claude -p "say hi"\`.`;
 }
-function probeClaudeLoginState({ spawn: spawn4 = spawnSync } = {}) {
+function probeClaudeLoginState({
+  spawn: spawn4 = spawnSync2,
+  buildWindowsLaunch = buildWindowsClaudeLaunch,
+  platform = process.platform
+} = {}) {
   try {
-    const st = spawn4("claude", ["auth", "status"], {
-      shell: process.platform === "win32",
-      windowsHide: true,
-      timeout: 5e3,
-      encoding: "utf8"
-    });
+    const launch = platform === "win32" ? buildWindowsLaunch({ bin: "claude", args: ["auth", "status"] }) : { bin: "claude", args: ["auth", "status"], spawnOptions: { windowsHide: true } };
+    const st = spawn4(launch.bin, launch.args, { ...launch.spawnOptions, timeout: 5e3, encoding: "utf8" });
     const parsed = JSON.parse(String(st.stdout || "").trim() || "{}");
     return typeof parsed.loggedIn === "boolean" ? parsed.loggedIn : null;
   } catch {
     return null;
   }
 }
-var require2, KEY_SERVICE, KEY_ACCOUNT, _entryCtor, _loadTried, PREFER_LOGIN_ENV, AUTH_ERROR_RE;
+var require2, KEY_SERVICE, KEY_ACCOUNT, _entryCtor, _loadTried, PREFER_LOGIN_ENV, CLAUDE_PREFER_LOGIN_ENV, AUTH_ERROR_RE;
 var init_anthropic_key_store = __esm({
   "../../scripts/virtual-office/code-runner/anthropic-key-store.mjs"() {
     "use strict";
+    init_windows_claude_launch();
     require2 = createRequire2(import.meta.url);
     KEY_SERVICE = "algosuite-vo";
     KEY_ACCOUNT = "anthropic-api-key";
     _loadTried = false;
     PREFER_LOGIN_ENV = "VO_RUNNER_PREFER_LOGIN";
+    CLAUDE_PREFER_LOGIN_ENV = "VO_RUNNER_CLAUDE_PREFER_LOGIN";
     AUTH_ERROR_RE = /\b401\b|invalid[^.]{0,24}(authentication|credential)|authentication_error|unauthorized|not[ _-]?authenticated/i;
   }
 });
@@ -2416,7 +2681,7 @@ var init_agent_task_stream = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/sandbox/sandbox-docker.mjs
-import { spawnSync as spawnSync2 } from "node:child_process";
+import { spawnSync as spawnSync3 } from "node:child_process";
 function buildDockerArgs({
   worktreeDir,
   image = DEFAULT_SANDBOX_IMAGE,
@@ -2501,15 +2766,17 @@ var init_context7_mcp = __esm({
 
 // ../../scripts/virtual-office/code-runner/claude-args.mjs
 function buildClaudeArgs({ permissionMode = DEFAULT_PERMISSION_MODE, maxTurns, model, effort, maxBudgetUsd, env: env2 = process.env } = {}) {
+  const effectivePermissionMode = String(permissionMode || DEFAULT_PERMISSION_MODE);
+  const allowedTools = effectivePermissionMode === DEFAULT_PERMISSION_MODE ? `${VO_SESSION_STATE_TOOL},${VO_HEADLESS_PNPM_TOOL},${VO_HEADLESS_PNPM_FROM_DIR_TOOL}` : VO_SESSION_STATE_TOOL;
   const args = [
     "-p",
     "--output-format",
     "stream-json",
     "--verbose",
     "--permission-mode",
-    String(permissionMode || DEFAULT_PERMISSION_MODE),
+    effectivePermissionMode,
     "--allowedTools",
-    VO_SESSION_STATE_TOOL
+    allowedTools
   ];
   if (Number.isInteger(maxTurns) && maxTurns > 0) {
     args.push("--max-turns", String(maxTurns));
@@ -2526,22 +2793,24 @@ function buildClaudeArgs({ permissionMode = DEFAULT_PERMISSION_MODE, maxTurns, m
   args.push(...context7McpArgs(env2));
   return args;
 }
-var DEFAULT_PERMISSION_MODE, VO_SESSION_STATE_TOOL;
+var DEFAULT_PERMISSION_MODE, VO_SESSION_STATE_TOOL, VO_HEADLESS_PNPM_TOOL, VO_HEADLESS_PNPM_FROM_DIR_TOOL;
 var init_claude_args = __esm({
   "../../scripts/virtual-office/code-runner/claude-args.mjs"() {
     "use strict";
     init_context7_mcp();
     DEFAULT_PERMISSION_MODE = "acceptEdits";
     VO_SESSION_STATE_TOOL = "mcp__vo-mcp__vo_report_session_state";
+    VO_HEADLESS_PNPM_TOOL = "Bash(pnpm *)";
+    VO_HEADLESS_PNPM_FROM_DIR_TOOL = "Bash(pnpm --dir *)";
   }
 });
 
 // ../../scripts/virtual-office/code-runner/terminal-process-cleanup.mjs
-import { spawnSync as spawnSync3 } from "node:child_process";
+import { spawnSync as spawnSync4 } from "node:child_process";
 function terminateAgentProcessTree({
   child,
   platform = process.platform,
-  spawn: spawn4 = spawnSync3
+  spawn: spawn4 = spawnSync4
 } = {}) {
   if (!child || !Number.isInteger(child.pid) || child.pid <= 0) return false;
   if (platform === "win32") {
@@ -2577,7 +2846,7 @@ var init_terminal_process_cleanup = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/claude-runner.mjs
-import { spawn as spawn2, spawnSync as spawnSync4 } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 function extractText(content) {
   if (typeof content === "string") return content.trim();
   if (Array.isArray(content)) {
@@ -2657,7 +2926,9 @@ function runAgentTask({
       });
       spawnBin = sandbox.dockerBin || "docker";
       spawnOpts = { windowsHide: true };
-    }
+    } else if (typeof runner.prepareSpawn === "function") {
+      ({ bin: spawnBin, args: spawnArgs, spawnOptions: spawnOpts } = runner.prepareSpawn({ bin: spawnBin, args: spawnArgs, spawnOptions: spawnOpts, env: spawnEnv }));
+    } else if (typeof runner.prepareSpawnArgs === "function") spawnArgs = runner.prepareSpawnArgs(spawnArgs);
     const child = spawnImpl(spawnBin, spawnArgs, {
       cwd,
       env: spawnEnv,
@@ -2791,6 +3062,7 @@ var init_claude_runner = __esm({
     init_agent_task_stream();
     init_sandbox_docker();
     init_claude_args();
+    init_windows_claude_launch();
     init_terminal_process_cleanup();
     ClaudeRunner = class {
       get binary() {
@@ -2803,10 +3075,11 @@ var init_claude_runner = __esm({
         return parseStreamEvent(line);
       }
       getSpawnOptions() {
-        return {
-          shell: process.platform === "win32",
-          windowsHide: true
-        };
+        return { shell: false, windowsHide: true };
+      }
+      prepareSpawn({ bin, args, spawnOptions, env: env2 = process.env } = {}) {
+        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),
@@ -2827,12 +3100,7 @@ var init_claude_runner = __esm({
        */
       async checkAuth() {
         try {
-          const probe = spawnSync4("claude", ["--version"], {
-            shell: process.platform === "win32",
-            windowsHide: true,
-            timeout: 3e3,
-            stdio: "ignore"
-          });
+          const probe = spawnClaudeSync(["--version"], { timeout: 3e3, stdio: "ignore" });
           if (probe.error) {
             return {
               installed: false,
@@ -2946,6 +3214,7 @@ var init_agent_key_store = __esm({
 // ../../scripts/virtual-office/code-runner/codex-runner.mjs
 var codex_runner_exports = {};
 __export(codex_runner_exports, {
+  CODEX_PREFER_LOGIN_ENV: () => CODEX_PREFER_LOGIN_ENV,
   CodexRunner: () => CodexRunner,
   buildCodexArgs: () => buildCodexArgs,
   codexRunner: () => codexRunner,
@@ -2953,17 +3222,23 @@ __export(codex_runner_exports, {
   resolveCodexBinary: () => resolveCodexBinary
 });
 import { spawnSync as spawnSync5 } from "node:child_process";
-import { existsSync as existsSync2 } from "node:fs";
+import { existsSync as existsSync3 } from "node:fs";
 import { join as join2 } from "node:path";
+function isTruthyFlag2(value) {
+  return ["1", "true", "yes", "on"].includes(String(value ?? "").trim().toLowerCase());
+}
 function resolveCodexBinary({
   env: env2 = process.env,
   platform = process.platform,
-  exists = existsSync2
+  exists = existsSync3
 } = {}) {
   if (platform !== "win32") return "codex";
   const appData = String(env2.APPDATA || "").trim();
+  const userProfile = String(env2.USERPROFILE || "").trim();
+  const localAppData = String(env2.LOCALAPPDATA || "").trim();
+  const candidates = [];
   if (appData) {
-    const npmVendorBinary = join2(
+    candidates.push(join2(
       appData,
       "npm",
       "node_modules",
@@ -2976,9 +3251,17 @@ function resolveCodexBinary({
       "x86_64-pc-windows-msvc",
       "bin",
       "codex.exe"
-    );
-    if (exists(npmVendorBinary)) return npmVendorBinary;
+    ));
+  }
+  if (userProfile) {
+    candidates.push(join2(userProfile, ".local", "bin", "codex.exe"));
+    candidates.push(join2(userProfile, ".codex", "bin", "codex.exe"));
   }
+  if (localAppData) {
+    candidates.push(join2(localAppData, "Microsoft", "WindowsApps", "codex.exe"));
+  }
+  const absolute = candidates.find((candidate) => exists(candidate));
+  if (absolute) return absolute;
   return "codex";
 }
 function buildCodexArgs({ model, effort } = {}) {
@@ -3029,14 +3312,21 @@ function parseCodexEvent(line) {
   }
   return null;
 }
-var CodexRunner, codexRunner;
+var CODEX_PREFER_LOGIN_ENV, LEGACY_PREFER_LOGIN_ENV, CodexRunner, codexRunner;
 var init_codex_runner = __esm({
   "../../scripts/virtual-office/code-runner/codex-runner.mjs"() {
     "use strict";
     init_agent_key_store();
+    CODEX_PREFER_LOGIN_ENV = "VO_RUNNER_CODEX_PREFER_LOGIN";
+    LEGACY_PREFER_LOGIN_ENV = "VO_RUNNER_PREFER_LOGIN";
     CodexRunner = class {
+      constructor({ spawn: spawn4 = spawnSync5, resolveBinary = resolveCodexBinary, env: env2 = process.env } = {}) {
+        this.spawn = spawn4;
+        this.resolveBinary = resolveBinary;
+        this.env = env2;
+      }
       get binary() {
-        return resolveCodexBinary();
+        return this.resolveBinary();
       }
       buildArgs(opts = {}) {
         return buildCodexArgs(opts);
@@ -3058,25 +3348,58 @@ var init_codex_runner = __esm({
        * 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 };
+          delete out.OPENAI_API_KEY;
+          delete out.CODEX_API_KEY;
+          return out;
+        }
         return withAgentKey("openai", env2);
       }
-      /** Best-effort: is `codex` on PATH? Never throws. */
+      /** Best-effort binary + persisted-login probe. Never throws or spends tokens. */
       async checkAuth() {
         try {
           const bin = this.binary;
-          const { status, error } = spawnSync5(bin, ["--version"], {
+          const version = this.spawn(bin, ["--version"], {
             ...this.getSpawnOptions({ bin }),
             windowsHide: true,
             timeout: 3e3,
             stdio: "ignore"
           });
-          if (error) {
-            return { installed: false, authenticated: false, message: `codex not found on PATH: ${error.message}` };
+          if (version.error) {
+            return { installed: false, authenticated: false, message: `codex not found on PATH: ${version.error.message}` };
           }
-          if (status !== 0) {
+          if (version.status !== 0) {
             return { installed: true, authenticated: false, message: "codex exists but --version failed (auth unclear)" };
           }
-          return { installed: true, authenticated: true, message: "codex binary found (auth check is best-effort)" };
+          const login = this.spawn(bin, ["login", "status"], {
+            ...this.getSpawnOptions({ bin }),
+            windowsHide: true,
+            timeout: 5e3,
+            encoding: "utf8"
+          });
+          const output = `${login.stdout || ""}
+${login.stderr || ""}`.trim();
+          if (login.error || login.status !== 0) {
+            const authEnv = this.applyAuthEnv(this.env);
+            if (authEnv.OPENAI_API_KEY || authEnv.CODEX_API_KEY) {
+              return {
+                installed: true,
+                authenticated: true,
+                message: "codex API key available (no persisted ChatGPT login)"
+              };
+            }
+            return {
+              installed: true,
+              authenticated: false,
+              message: output || login.error?.message || "codex is installed but not logged in"
+            };
+          }
+          return {
+            installed: true,
+            authenticated: true,
+            message: output || "codex login status succeeded"
+          };
         } catch (err) {
           return { installed: false, authenticated: false, message: `checkAuth probe failed: ${err.message}` };
         }
@@ -3262,12 +3585,12 @@ var init_grok_model_catalog = __esm({
 
 // ../../scripts/virtual-office/code-runner/grok-runner.mjs
 import { spawnSync as spawnSync7 } from "node:child_process";
-import { existsSync as existsSync3 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 import { join as join3, win32 } from "node:path";
 function resolveGrokBinary({
   env: env2 = process.env,
   platform = process.platform,
-  exists = existsSync3
+  exists = existsSync4
 } = {}) {
   const explicit = String(env2.VO_CODE_RUNNER_GROK_BIN || env2.GROK_BIN || "").trim();
   if (explicit) return explicit;
@@ -3940,6 +4263,7 @@ var init_rate_limit_resume = __esm({
 function isTransientGitError(err) {
   if (!err) return false;
   if (err.code && TRANSIENT_CODES.has(err.code)) return true;
+  if (err.code === "UNKNOWN" && /^spawn(?:\s|$)/i.test(String(err.syscall || ""))) return true;
   const msg = String(err.message || err);
   if (/non-fast-forward|fast[- ]forward|\(fetch first\)|permission denied|authentication failed|\b40[134]\b|merge conflict|nothing to commit|did not match any/i.test(msg)) {
     return false;
@@ -3980,7 +4304,7 @@ var init_auto_merge = __esm({
 
 // ../../scripts/virtual-office/code-runner/pr-overlap-gate.mjs
 import { spawnSync as spawnSync8 } from "node:child_process";
-import path8 from "node:path";
+import path10 from "node:path";
 var init_pr_overlap_gate = __esm({
   "../../scripts/virtual-office/code-runner/pr-overlap-gate.mjs"() {
     "use strict";
@@ -3995,14 +4319,14 @@ function parsePorcelainZ(out) {
   for (let i = 0; i < tokens.length; i += 1) {
     const tok = tokens[i];
     if (!tok) continue;
-    const path12 = tok.slice(3);
-    if (path12) files.push(path12);
+    const path16 = tok.slice(3);
+    if (path16) files.push(path16);
     if (tok[0] === "R" || tok[0] === "C") i += 1;
   }
   return files;
 }
-function isAgentScratch(path12) {
-  const p = String(path12 || "");
+function isAgentScratch(path16) {
+  const p = String(path16 || "");
   return SCRATCH_PATTERNS.some((re) => re.test(p));
 }
 function isMaxTurnsResult(summary) {
@@ -4063,7 +4387,7 @@ var init_publish = __esm({
 // ../../scripts/virtual-office/code-runner/process-runner.mjs
 import { spawn as spawn3 } from "node:child_process";
 function buildStepLabel(cmd, args = []) {
-  return `${cmd} ${args[0] || ""}`.trim();
+  return [cmd, ...args.slice(0, 2)].filter(Boolean).join(" ");
 }
 function buildExitError(cmd, args, { status, signal, stderr, stdout }) {
   const err = new Error(
@@ -4082,6 +4406,18 @@ function buildTimeoutError(cmd, args, timeout, { stderr, stdout } = {}) {
   err.stdout = stdout;
   return err;
 }
+function buildSpawnError(cmd, args, cwd, err) {
+  const code = err?.code ? String(err.code) : "unknown";
+  const detail = err instanceof Error ? err.message : String(err);
+  const failure = new Error(
+    `${buildStepLabel(cmd, args)} spawn failed${cwd ? ` in ${cwd}` : ""} (${code}): ${detail}`,
+    { cause: err }
+  );
+  for (const key of ["code", "syscall", "path", "spawnargs"]) {
+    if (err?.[key] !== void 0) failure[key] = err[key];
+  }
+  return failure;
+}
 function runProcess2(cmd, args, {
   cwd,
   timeout = 18e4,
@@ -4127,7 +4463,7 @@ function runProcess2(cmd, args, {
       stderr += chunk.toString();
     });
     child.on("error", (err) => {
-      settle(reject, err);
+      settle(reject, buildSpawnError(cmd, args, cwd, err));
     });
     child.on("close", (status, signal) => {
       const result = {
@@ -4181,7 +4517,7 @@ var init_process_runner2 = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/publish-async.mjs
-import path9 from "node:path";
+import path11 from "node:path";
 function compactTitle(value, max = 100) {
   return String(value || "").replace(/\s+/g, " ").trim().slice(0, max) || "code-task";
 }
@@ -4222,10 +4558,15 @@ async function resolveOrCreateBranchAsync(worktreeDir, branchPrefix, runCommand
   }
   return branch;
 }
-async function runLocalPrOverlapGateAsync(worktreeDir, files, { env: env2 = process.env, excludePrNumber = null } = {}) {
-  const scriptPath = path9.join(worktreeDir, "scripts", "ci", "check-local-pr-overlap.mjs");
+async function runLocalPrOverlapGateAsync(worktreeDir, files, { branch = "", env: env2 = process.env, excludePrNumber = null } = {}) {
+  const scriptPath = path11.join(worktreeDir, "scripts", "ci", "check-local-pr-overlap.mjs");
   try {
-    const output = await runProcess2("node", [scriptPath, "--stdin", ...excludePrNumber ? ["--exclude-pr", String(excludePrNumber)] : []], {
+    const output = await runProcess2("node", [
+      scriptPath,
+      "--stdin",
+      ...branch ? ["--branch", String(branch)] : [],
+      ...excludePrNumber ? ["--exclude-pr", String(excludePrNumber)] : []
+    ], {
       cwd: worktreeDir,
       env: env2,
       input: JSON.stringify([...new Set((files || []).map((file) => String(file || "").trim()).filter(Boolean))]),
@@ -4327,22 +4668,51 @@ async function markPrReadyAsync(worktreeDir, prNumber, githubToken = null, { run
     env: githubToken ? installationTokenEnv(githubToken) : void 0
   });
 }
-async function closeSupersededPrAsync(worktreeDir, prNumber, branch, githubToken = null, { runCommand = defaultRunCommand } = {}) {
+async function closeSupersededPrAsync(worktreeDir, prNumber, replacementUrl, githubToken = null, { runCommand = defaultRunCommand } = {}) {
   if (!Number.isInteger(prNumber) || prNumber <= 0) return false;
+  if (!/^https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/\d+$/u.test(String(replacementUrl || ""))) return false;
   const env2 = githubToken ? installationTokenEnv(githubToken) : void 0;
   const raw = await runCommand("gh", ["pr", "view", String(prNumber), "--json", "state"], worktreeDir, { env: env2 });
   const state = JSON.parse(raw || "{}")?.state;
   if (state !== "OPEN") return false;
   await runCommand(
     "gh",
-    ["pr", "close", String(prNumber), "--comment", `VO repair branch ${branch} is pushed from current main and supersedes this failed PR; its replacement is being opened now.`],
+    ["pr", "close", String(prNumber), "--comment", `Superseded by ${replacementUrl}, rebuilt from current main by VO repair.`],
     worktreeDir,
     { env: env2, timeout: 6e4 }
   );
   return true;
 }
-async function pushBranchAsync(worktreeDir, branch, githubToken, { runCommand = defaultRunCommand, allowAmbientFallback = false } = {}) {
-  const { primary, fallback } = pushPlan(branch, githubToken, { allowAmbientFallback });
+async function cleanupSupersededPrAsync({
+  worktreeDir,
+  supersedesPrNumber,
+  replacementUrl,
+  replacementNumber,
+  githubToken,
+  runCommand,
+  onCleanupWarning
+}) {
+  if (!supersedesPrNumber) return {};
+  if (Number(supersedesPrNumber) === Number(replacementNumber)) {
+    return { supersededPrClosed: false };
+  }
+  try {
+    const closed = await retryTransientAsync(
+      () => closeSupersededPrAsync(worktreeDir, supersedesPrNumber, replacementUrl, githubToken, { runCommand }),
+      { onRetry: gitRetryLog("gh pr close superseded") }
+    );
+    return { supersededPrClosed: closed };
+  } catch (err) {
+    const message = err && err.message ? err.message : String(err);
+    onCleanupWarning?.(
+      `[publish] replacement PR #${replacementNumber} is open; source PR #${supersedesPrNumber} cleanup failed: ${message}`
+    );
+    return { supersededPrClosed: false, supersededPrCloseError: message };
+  }
+}
+async function pushBranchAsync(worktreeDir, branch, githubToken, { runCommand = defaultRunCommand, allowAmbientFallback = false, remoteBranch = branch } = {}) {
+  const pushRef = remoteBranch && remoteBranch !== branch ? `HEAD:refs/heads/${remoteBranch}` : branch;
+  const { primary, fallback } = pushPlan(pushRef, githubToken, { allowAmbientFallback });
   try {
     await runCommand("git", primary.args, worktreeDir, { env: primary.env });
     return primary.tokenUsed;
@@ -4364,7 +4734,9 @@ async function openCodeTaskPrAsync(worktreeDir, files, {
   allowAmbientGithubFallback = false,
   draft = false,
   armAutoMerge = false,
+  targetBranch = null,
   supersedesPrNumber = null,
+  onCleanupWarning = console.error,
   runCommand = defaultRunCommand,
   runOverlapGate = runLocalPrOverlapGateAsync
 } = {}) {
@@ -4385,7 +4757,9 @@ async function openCodeTaskPrAsync(worktreeDir, files, {
     branch = committed.branch;
     truncated = committed.truncated;
   }
+  const prBranch = String(targetBranch || branch).trim() || branch;
   const overlap = await runOverlapGate(worktreeDir, files.filter((file) => !isAgentScratch(file)), {
+    branch: prBranch,
     env: githubToken ? installationTokenEnv(githubToken) : process.env,
     excludePrNumber: supersedesPrNumber
   });
@@ -4394,18 +4768,13 @@ ${overlap.output}`);
   const tokenUsed = await retryTransientAsync(
     () => pushBranchAsync(worktreeDir, branch, githubToken, {
       runCommand,
-      allowAmbientFallback: allowAmbientGithubFallback
+      allowAmbientFallback: allowAmbientGithubFallback,
+      remoteBranch: prBranch
     }),
     { onRetry: gitRetryLog("git push") }
   );
   const authToken = tokenUsed ? githubToken : null;
-  if (supersedesPrNumber) {
-    await retryTransientAsync(
-      () => closeSupersededPrAsync(worktreeDir, supersedesPrNumber, branch, authToken, { runCommand }),
-      { onRetry: gitRetryLog("gh pr close superseded") }
-    );
-  }
-  const existing = await existingPrUrlAsync(worktreeDir, branch, authToken, { runCommand });
+  const existing = await existingPrUrlAsync(worktreeDir, prBranch, authToken, { runCommand });
   if (existing) {
     if (!draft && existing.isDraft) {
       await retryTransientAsync(
@@ -4421,20 +4790,30 @@ ${overlap.output}`);
       draft,
       runCommand
     });
+    const superseded2 = await cleanupSupersededPrAsync({
+      worktreeDir,
+      supersedesPrNumber,
+      replacementUrl: existing.url,
+      replacementNumber: existing.number,
+      githubToken: authToken,
+      runCommand,
+      onCleanupWarning
+    });
     return {
       prUrl: existing.url,
       prNumber: existing.number,
-      branch,
+      branch: prBranch,
       truncated,
       resumed: true,
       markedReady: !draft && existing.isDraft,
-      ...autoMerge2
+      ...autoMerge2,
+      ...superseded2
     };
   }
   const out = await retryTransientAsync(
     () => runCommand(
       "gh",
-      ["pr", "create", "--base", "main", "--head", branch, "--title", compactTitle(title), "--body", String(body || ""), ...draft ? ["--draft"] : []],
+      ["pr", "create", "--base", "main", "--head", prBranch, "--title", compactTitle(title), "--body", String(body || ""), ...draft ? ["--draft"] : []],
       worktreeDir,
       { env: authToken ? installationTokenEnv(authToken) : void 0 }
     ),
@@ -4443,6 +4822,7 @@ ${overlap.output}`);
   const match = out.match(/https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/(\d+)/);
   if (!match) throw new Error("gh pr create returned no parseable PR URL");
   const prNumber = Number(match[1]);
+  const prUrl = match[0];
   const autoMerge = await maybeArmAutoMergeAsync({
     worktreeDir,
     prNumber,
@@ -4451,7 +4831,16 @@ ${overlap.output}`);
     draft,
     runCommand
   });
-  return { prUrl: match[0], prNumber, branch, truncated, ...autoMerge };
+  const superseded = await cleanupSupersededPrAsync({
+    worktreeDir,
+    supersedesPrNumber,
+    replacementUrl: prUrl,
+    replacementNumber: prNumber,
+    githubToken: authToken,
+    runCommand,
+    onCleanupWarning
+  });
+  return { prUrl, prNumber, branch: prBranch, truncated, ...autoMerge, ...superseded };
 }
 var sleep;
 var init_publish_async = __esm({
@@ -4465,6 +4854,111 @@ var init_publish_async = __esm({
   }
 });
 
+// ../../scripts/virtual-office/code-runner/resume-branch.mjs
+function compactBranchSegment(value) {
+  return String(value || "").trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || "resume";
+}
+function defaultRunCommand2(cmd, args, cwd, opts = {}) {
+  return runProcess2(cmd, args, { cwd, ...opts });
+}
+function buildResumeLocalBranchName(remoteBranch, {
+  now = () => /* @__PURE__ */ new Date(),
+  pid = process.pid,
+  random = Math.random
+} = {}) {
+  const stamp = now().toISOString().replace(/[:.]/g, "-");
+  const unique = `${pid}-${random().toString(36).slice(2, 8)}`;
+  return `vo/resume-${compactBranchSegment(remoteBranch)}-${stamp}-${unique}`;
+}
+async function assertBranchName(worktreeDir, branch, { env: env2, runCommand = defaultRunCommand2 } = {}) {
+  const candidate = String(branch || "").trim();
+  if (!candidate) throw new Error("resume branch is required");
+  await runCommand("git", ["check-ref-format", "--branch", candidate], worktreeDir, {
+    env: env2,
+    timeout: 3e4
+  });
+  return candidate;
+}
+async function restoreContinuationBranch(worktreeDir, remoteBranch, {
+  env: env2,
+  runCommand = defaultRunCommand2,
+  localBranchName
+} = {}) {
+  const branch = await assertBranchName(worktreeDir, remoteBranch, { env: env2, runCommand });
+  const localBranch = await assertBranchName(
+    worktreeDir,
+    localBranchName || buildResumeLocalBranchName(branch),
+    { env: env2, runCommand }
+  );
+  await runCommand(
+    "git",
+    ["fetch", "origin", `${branch}:refs/remotes/origin/${branch}`],
+    worktreeDir,
+    { env: env2, timeout: 12e4 }
+  );
+  await runCommand("git", ["checkout", "-b", localBranch, `origin/${branch}`], worktreeDir, {
+    env: env2,
+    timeout: 6e4
+  });
+  return { localBranch, remoteBranch: branch };
+}
+function parseHeadRefName(output) {
+  const parsed = JSON.parse(String(output || "{}"));
+  const branch = String(parsed?.headRefName || "").trim();
+  return branch || null;
+}
+async function resolvePrHeadBranch(worktreeDir, {
+  repo,
+  prNumber,
+  githubToken = null,
+  allowAmbientGithubFallback = false,
+  runCommand = defaultRunCommand2
+} = {}) {
+  if (!repo || !Number.isInteger(prNumber) || prNumber <= 0) return null;
+  const args = ["pr", "view", String(prNumber), "-R", String(repo), "--json", "headRefName"];
+  try {
+    const output = await runCommand("gh", args, worktreeDir, {
+      env: githubToken ? installationTokenEnv(githubToken) : void 0,
+      timeout: 6e4
+    });
+    return parseHeadRefName(output);
+  } catch (error) {
+    if (!githubToken || !allowAmbientGithubFallback) throw error;
+  }
+  const fallback = await runCommand("gh", args, worktreeDir, { timeout: 6e4 });
+  return parseHeadRefName(fallback);
+}
+async function prepareContinuationBranch(worktreeDir, {
+  task,
+  parentTask,
+  githubToken = null,
+  allowAmbientGithubFallback = false,
+  runCommand = defaultRunCommand2
+} = {}) {
+  const continuationBranch = task?.pr_branch || parentTask?.pr_branch || (parentTask?.pr_number ? await resolvePrHeadBranch(worktreeDir, {
+    repo: task?.repo,
+    prNumber: parentTask.pr_number,
+    githubToken,
+    allowAmbientGithubFallback,
+    runCommand
+  }) : null);
+  if (!continuationBranch && (task?.pr_branch || parentTask?.pr_url || parentTask?.pr_number)) {
+    throw new Error(`continuation PR branch could not be resolved for task ${task?.code_task_id || "unknown"}`);
+  }
+  if (!continuationBranch) return null;
+  return restoreContinuationBranch(worktreeDir, continuationBranch, {
+    env: githubToken ? installationTokenEnv(githubToken) : void 0,
+    runCommand
+  });
+}
+var init_resume_branch = __esm({
+  "../../scripts/virtual-office/code-runner/resume-branch.mjs"() {
+    "use strict";
+    init_publish();
+    init_process_runner2();
+  }
+});
+
 // ../../scripts/virtual-office/code-runner/dispatch-onboarding.mjs
 function buildDispatchOnboarding({ repo = "Algosuite-ai/Nexus" } = {}) {
   const reads = MANDATORY_READS.map((r, i) => `  ${i + 1}. ${r}`).join("\n");
@@ -4545,6 +5039,7 @@ var init_dispatch_onboarding = __esm({
       "A handoff or roadmap line is a CLAIM, not evidence \u2014 verify shipped state against `git show origin/main:<path>`, never the stale local main tree.",
       `MANDATORY FOR EVERY VO PR (cloud-run/vo-*, packages/vo-mcp, packages/consensus-engine, packages/vo-ratchets, packages/vo-arch-defaults, scripts/virtual-office, vo-claude-plugin): record a dated Change-log entry IN THE SAME PR via EITHER appending to the "\xA7 10 Change log" of docs/vo/vo-roadmap-2026-05-26.md OR (PREFERRED) creating docs/vo/roadmap-log/<YYYY-MM-DD>-<short-slug>.md (fragments avoid conflicts when PRs ship concurrently) and flip any status the work shipped. CI enforces this (check-vo-roadmap-discipline.mjs); bypass ONLY via "VO-ROADMAP-ALLOW: <reason>" in the PR body. The roadmap is the single source of truth \u2014 if you didn't update it, you didn't ship. Finish line = MERGED + DEPLOYED + LIVE-VERIFIED.`,
       "Every UI change ships against docs/current/ui-trust-standard.md and adds VO QA tester coverage; verify in a real browser, not selector-presence.",
+      "UNATTENDED VERIFICATION: no human can approve shell prompts. Run `pnpm ...` directly from the worktree root. For a standalone nested project with its own pnpm-lock.yaml, use `pnpm --dir <project> install --frozen-lockfile --prefer-offline --ignore-scripts --config.confirmModulesPurge=false`, then `pnpm --dir <project> ...` for its focused tests/type-check. These two pnpm forms are pre-authorized; do not skip local verification or wait for approval.",
       'PR \u2192 LIVE is YOUR job end-to-end \u2014 the operator must NEVER be the one to discover a red PR or a backed-up deploy. Own every PR from branch \u2192 CI \u2192 merge \u2192 functions deploy \u2192 LIVE-VERIFIED. "Done" = the functions you changed are actually SERVING in prod in every region; prove it with `node scripts/ci/prove-pr-live.mjs --pr <N>` \u2014 a merge / green deploy checkmark / homepage 200 is NOT proof. If a function staled, re-deploy ONLY the affected functions (targeted), never a full deploy. If you hit a usage/rate limit, STOP cleanly with the PR obligation OPEN \u2014 the watchdog auto-resumes when it resets; do not abandon it. See docs/current/pr-live-stewardship-doctrine.md.',
       `CONTEXT DEPTH IS NOT A REASON TO STOP. "I'm deep in context / fresh context would be better / I'll checkpoint" is the SAME premature-stop failure as doing 20 minutes of work instead of 6 hours \u2014 there is no quality cliff before compaction and the harness carries work forward. Keep BUILDING until the task is genuinely DONE; delicate or fleet-governing work means be CAREFUL, not stop. The ONLY valid pauses are real blockers: an operator decision is required, a dependency is not merged, or a hard external wait.`
     ];
@@ -4648,9 +5143,9 @@ var init_task_prompt = __esm({
 import { homedir as homedir3 } from "node:os";
 import { join as join5 } from "node:path";
 import { readdir, readFile, unlink, writeFile } from "node:fs/promises";
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 function deriveUuid(seed) {
-  const h = createHash4("sha256").update(seed).digest("hex");
+  const h = createHash3("sha256").update(seed).digest("hex");
   return `${h.slice(0, 8)}-${h.slice(8, 12)}-5${h.slice(13, 16)}-${(parseInt(h.slice(16, 18), 16) & 63 | 128).toString(16)}${h.slice(18, 20)}-${h.slice(20, 32)}`;
 }
 function spoolToCloud(record, ids) {
@@ -4687,9 +5182,9 @@ async function readSpool(spoolDir = SPOOL_DIR) {
   }
   return out;
 }
-async function readCloudMap(path12) {
+async function readCloudMap(path16) {
   try {
-    return JSON.parse(await readFile(path12, "utf8"));
+    return JSON.parse(await readFile(path16, "utf8"));
   } catch {
     return {};
   }
@@ -4832,13 +5327,13 @@ var init_rate_limit_resume_scheduler_core = __esm({
 });
 
 // ../../scripts/virtual-office/code-runner/rate-limit-resume-scheduler.mjs
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "node:fs";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync5, mkdirSync as mkdirSync3 } from "node:fs";
 import { dirname as dirname3, join as join6, resolve } from "node:path";
 function log(msg) {
   console.log(`[rate-limit-scheduler ${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}`);
 }
 function readQueue(queuePath) {
-  if (!existsSync4(queuePath)) return [];
+  if (!existsSync5(queuePath)) return [];
   const content = readFileSync2(queuePath, "utf-8");
   const lines = content.split("\n").filter((l) => l.trim());
   const entries = [];
@@ -4861,7 +5356,7 @@ function attemptsStorePath() {
 }
 function readAttemptsStore() {
   const p = attemptsStorePath();
-  if (!existsSync4(p)) return {};
+  if (!existsSync5(p)) return {};
   try {
     const parsed = JSON.parse(readFileSync2(p, "utf-8"));
     return parsed && typeof parsed === "object" ? parsed : {};
@@ -5103,7 +5598,7 @@ var init_agent_availability = __esm({
 // ../../scripts/virtual-office/code-runner/account-usage.mjs
 import fs6 from "node:fs";
 import os from "node:os";
-import path10 from "node:path";
+import path12 from "node:path";
 function readClaudeUsage({ homeDir = os.homedir(), read: rawRead = readJson } = {}) {
   const read = (p) => {
     try {
@@ -5112,7 +5607,7 @@ function readClaudeUsage({ homeDir = os.homedir(), read: rawRead = readJson } =
       return null;
     }
   };
-  const status = read(path10.join(homeDir, ".claude", "claude-usage.json"));
+  const status = read(path12.join(homeDir, ".claude", "claude-usage.json"));
   if (status && (status.seven_day || status.five_hour)) {
     const entry = {
       agent: "claude",
@@ -5121,7 +5616,7 @@ function readClaudeUsage({ homeDir = os.homedir(), read: rawRead = readJson } =
     };
     if (entry.seven_day_used_pct !== null || entry.five_hour_used_pct !== null) return entry;
   }
-  const weekly = read(path10.join(homeDir, ".claude", "claude-weekly-usage.json"));
+  const weekly = read(path12.join(homeDir, ".claude", "claude-weekly-usage.json"));
   if (weekly) {
     const entry = {
       agent: "claude",
@@ -5252,6 +5747,90 @@ var init_ci_repair_evidence = __esm({
   }
 });
 
+// ../../scripts/virtual-office/code-runner/pr-watcher-failure-confirmation.mjs
+function reset(entry) {
+  delete entry.repairFailureFingerprint;
+  delete entry.repairFailureObservations;
+  delete entry.repairFailureFirstSeenAt;
+}
+function repairFailureFingerprint(pr) {
+  if (pr?.ci !== "failing" || pr.hasPendingChecks) return null;
+  const headSha = String(pr.headSha || "").trim().toLowerCase();
+  const failedChecks = [...new Set((pr.failedChecks || []).map((name) => String(name).trim()).filter(Boolean))].sort();
+  if (!headSha || failedChecks.length === 0) return null;
+  return JSON.stringify({ headSha, failedChecks });
+}
+function observeRepairFailure(entry, pr, observedAt) {
+  const fingerprint = repairFailureFingerprint(pr);
+  if (!fingerprint) {
+    reset(entry);
+    return {
+      confirmed: false,
+      fingerprint: null,
+      observations: 0,
+      required: REPAIR_FAILURE_CONFIRMATIONS_REQUIRED,
+      reason: pr?.hasPendingChecks ? "checks still pending" : pr?.ci === "failing" ? "missing exact head/check evidence" : "not failing"
+    };
+  }
+  if (entry.repairFailureFingerprint === fingerprint) {
+    entry.repairFailureObservations = Math.min(
+      REPAIR_FAILURE_CONFIRMATIONS_REQUIRED,
+      Math.max(1, Number(entry.repairFailureObservations) || 1) + 1
+    );
+  } else {
+    entry.repairFailureFingerprint = fingerprint;
+    entry.repairFailureObservations = 1;
+    entry.repairFailureFirstSeenAt = observedAt;
+  }
+  return {
+    confirmed: entry.repairFailureObservations >= REPAIR_FAILURE_CONFIRMATIONS_REQUIRED,
+    fingerprint,
+    observations: entry.repairFailureObservations,
+    required: REPAIR_FAILURE_CONFIRMATIONS_REQUIRED,
+    reason: entry.repairFailureObservations === 1 ? "first observation" : "stable failure confirmed"
+  };
+}
+var REPAIR_FAILURE_CONFIRMATIONS_REQUIRED;
+var init_pr_watcher_failure_confirmation = __esm({
+  "../../scripts/virtual-office/code-runner/pr-watcher-failure-confirmation.mjs"() {
+    "use strict";
+    REPAIR_FAILURE_CONFIRMATIONS_REQUIRED = 2;
+  }
+});
+
+// ../../scripts/virtual-office/code-runner/superseded-pr-source.mjs
+function supersededSourcePrNumber(prompt) {
+  const text = String(prompt || "");
+  if (text.includes(CI_FIX_MARKER)) {
+    const match = text.match(/\bPR:\s*#(\d+)\b/u);
+    return match ? Number(match[1]) : null;
+  }
+  const repairMatch = text.match(/^REPAIR MISSION:\s*PR\s+#(\d+)\b/iu);
+  if (repairMatch) return Number(repairMatch[1]);
+  const recoverySupersedeMatch = text.match(
+    /^VO_RECOVERY_FROM_CODE_TASK:\s*[0-9a-f-]{36}\n\nSupersede draft PR #(\d+) from a fresh current origin\/main branch\b/iu
+  );
+  if (recoverySupersedeMatch) return Number(recoverySupersedeMatch[1]);
+  const restoredContextMatch = text.match(
+    /^(?:The previous run reached its max-turn cap after opening a partial draft PR\.|The previous run left a draft PR\.)\nThe VO runner will restore the existing draft PR context before you start \(draft PR https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/(\d+), PR #(\d+)\)\. Continue that work and finish it\./u
+  );
+  if (restoredContextMatch) {
+    return restoredContextMatch[1] === restoredContextMatch[2] ? Number(restoredContextMatch[1]) : null;
+  }
+  const continuationMatch = text.match(
+    /^(?:The previous run reached its max-turn cap after opening a partial draft PR\.|The previous run left a draft PR\.)\nContinue the work already started on the branch for PR #(\d+) \(draft PR https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/(\d+)\); check it out and finish it\./u
+  );
+  if (!continuationMatch || continuationMatch[1] !== continuationMatch[2]) return null;
+  return Number(continuationMatch[1]);
+}
+var CI_FIX_MARKER;
+var init_superseded_pr_source = __esm({
+  "../../scripts/virtual-office/code-runner/superseded-pr-source.mjs"() {
+    "use strict";
+    CI_FIX_MARKER = "[VO-CI-FIX]";
+  }
+});
+
 // ../../scripts/virtual-office/code-runner/pr-watcher.mjs
 import { homedir as homedir4 } from "node:os";
 import { join as join7 } from "node:path";
@@ -5294,6 +5873,7 @@ function parsePrCiStatus(view) {
     ci,
     failedChecks,
     failedCheckLinks,
+    hasPendingChecks: pending,
     branch: view && view.headRefName || null,
     headSha: view && view.headRefOid || null,
     url: view && view.url || null,
@@ -5338,11 +5918,6 @@ function buildCiFixPrompt({ prNumber, repo, branch, headSha, failedChecks, prPat
     "```"
   ].join("\n");
 }
-function ciFixSourcePrNumber(prompt) {
-  if (!String(prompt || "").includes(CI_FIX_MARKER)) return null;
-  const match = String(prompt).match(/\bPR:\s*#(\d+)\b/u);
-  return match ? Number(match[1]) : null;
-}
 async function readState(stateFile) {
   try {
     const parsed = JSON.parse(await readFile2(stateFile, "utf8"));
@@ -5410,7 +5985,8 @@ async function runWatchCycle({
     checked += 1;
     const pr = parsePrCiStatus(view);
     entry.lastCi = pr.ci;
-    const action = decideWatchAction(
+    const confirmation = observeRepairFailure(entry, pr, now());
+    const proposedAction = decideWatchAction(
       pr,
       entry.fixAttempts,
       maxFixAttempts,
@@ -5418,6 +5994,10 @@ async function runWatchCycle({
       maxResumeAttempts,
       autoMergeEnabled
     );
+    const action = proposedAction === "fix" && !confirmation.confirmed ? "wait" : proposedAction;
+    if (proposedAction === "fix" && action === "wait") {
+      log3(`watch: pr #${prNumber} CI repair waiting for stable exact-head failure ${confirmation.observations}/${confirmation.required} (${confirmation.reason})`);
+    }
     if (action === "untrack") {
       delete state[prNumber];
       untracked += 1;
@@ -5545,12 +6125,14 @@ function makeWatchRunner({
     stateFile
   });
 }
-var CI_FIX_MARKER, DEFAULT_STATE_FILE, FAIL_CONCLUSIONS, STALE_MS2, MAX_ENQUEUE_ERRORS;
+var DEFAULT_STATE_FILE, FAIL_CONCLUSIONS, STALE_MS2, MAX_ENQUEUE_ERRORS;
 var init_pr_watcher = __esm({
   "../../scripts/virtual-office/code-runner/pr-watcher.mjs"() {
     "use strict";
     init_ci_repair_evidence();
-    CI_FIX_MARKER = "[VO-CI-FIX]";
+    init_pr_watcher_failure_confirmation();
+    init_superseded_pr_source();
+    init_superseded_pr_source();
     DEFAULT_STATE_FILE = join7(homedir4(), ".vo", "dispatched-prs.json");
     FAIL_CONCLUSIONS = /* @__PURE__ */ new Set([
       "FAILURE",
@@ -5626,9 +6208,9 @@ function buildControlHandler({ getStatus, requestStop, allowedOrigin }) {
       res.end();
       return;
     }
-    const path12 = String(req.url || "").split("?")[0];
+    const path16 = String(req.url || "").split("?")[0];
     res.setHeader("content-type", "application/json");
-    if (req.method === "GET" && path12 === "/status") {
+    if (req.method === "GET" && path16 === "/status") {
       let status;
       try {
         status = getStatus();
@@ -5639,7 +6221,7 @@ function buildControlHandler({ getStatus, requestStop, allowedOrigin }) {
       res.end(JSON.stringify({ ok: true, ...status }));
       return;
     }
-    if (req.method === "POST" && path12 === "/stop") {
+    if (req.method === "POST" && path16 === "/stop") {
       if (!isControlOriginAllowed(req.headers.origin, allowedOrigin) || !req.headers["x-vo-control"]) {
         res.statusCode = 403;
         res.end(JSON.stringify({ ok: false, error: "forbidden" }));
@@ -5757,35 +6339,35 @@ var init_effort_mode_config = __esm({
       fast: {
         tier: "cheap",
         permissionMode: "acceptEdits",
-        maxTurns: 20,
+        maxTurns: 80,
         thinkingDirective: "",
         multiAgentInstruction: ""
       },
       standard: {
         tier: "mid",
         permissionMode: "acceptEdits",
-        maxTurns: 40,
+        maxTurns: 200,
         thinkingDirective: "",
         multiAgentInstruction: ""
       },
       deep: {
         tier: "best",
         permissionMode: "acceptEdits",
-        maxTurns: 60,
+        maxTurns: 300,
         thinkingDirective: "Think step-by-step. Verify assumptions against source code. Check edge cases.",
         multiAgentInstruction: ""
       },
       ultra: {
         tier: "best",
         permissionMode: "acceptEdits",
-        maxTurns: 80,
+        maxTurns: 500,
         thinkingDirective: "Think step-by-step. Exhaustively verify every assumption against source code and documentation. Adversarially review your own work.",
         multiAgentInstruction: "If this task needs multiple phases (research, build, verify), propose a plan first."
       },
       ultracode: {
         tier: "best",
-        permissionMode: "default",
-        maxTurns: 120,
+        permissionMode: "acceptEdits",
+        maxTurns: 800,
         thinkingDirective: "Think step-by-step. Exhaustively verify every assumption against source code and documentation. Build worked examples to validate correctness. Adversarially review your own work.",
         multiAgentInstruction: "Decompose this work into parallel research, build, and verification streams; use workflow orchestration where it helps."
       }
@@ -5796,7 +6378,7 @@ var init_effort_mode_config = __esm({
 
 // ../../scripts/virtual-office/model-registry.mjs
 import fs7 from "node:fs";
-import path11 from "node:path";
+import path13 from "node:path";
 import { fileURLToPath } from "node:url";
 function uniqueModels(models = []) {
   return [...new Set(models.map((model) => String(model || "").trim()).filter(Boolean))];
@@ -5919,7 +6501,7 @@ function readCache(cacheFile = DEFAULT_CACHE_FILE, nowMs = Date.now(), ttlMs = D
   }
 }
 function writeCache(cacheFile = DEFAULT_CACHE_FILE, payload) {
-  fs7.mkdirSync(path11.dirname(cacheFile), { recursive: true });
+  fs7.mkdirSync(path13.dirname(cacheFile), { recursive: true });
   fs7.writeFileSync(cacheFile, JSON.stringify(payload, null, 2));
 }
 async function fetchRegistryCatalog({
@@ -5977,10 +6559,10 @@ var __dirname, ROOT, DEFAULT_CACHE_DIR, DEFAULT_CACHE_FILE, DEFAULT_TTL_MS3, ANT
 var init_model_registry = __esm({
   "../../scripts/virtual-office/model-registry.mjs"() {
     "use strict";
-    __dirname = path11.dirname(fileURLToPath(import.meta.url));
-    ROOT = path11.resolve(__dirname, "..", "..");
-    DEFAULT_CACHE_DIR = path11.join(ROOT, ".virtual-office-cache", "model-registry");
-    DEFAULT_CACHE_FILE = path11.join(DEFAULT_CACHE_DIR, "catalog.json");
+    __dirname = path13.dirname(fileURLToPath(import.meta.url));
+    ROOT = path13.resolve(__dirname, "..", "..");
+    DEFAULT_CACHE_DIR = path13.join(ROOT, ".virtual-office-cache", "model-registry");
+    DEFAULT_CACHE_FILE = path13.join(DEFAULT_CACHE_DIR, "catalog.json");
     DEFAULT_TTL_MS3 = 60 * 60 * 1e3;
     ANTHROPIC_API_VERSION = "2023-06-01";
     FAMILY_DEFINITIONS = {
@@ -6560,9 +7142,9 @@ function operatorTierToRung(tier, difficulty, thresholds) {
   if (tier === "best" && difficulty >= thresholds.rungBounds.R5) return "R5";
   return base;
 }
-function readCodexModelsCache({ path: path12 = DEFAULT_CODEX_MODELS_CACHE, read = readFileSync3 } = {}) {
+function readCodexModelsCache({ path: path16 = DEFAULT_CODEX_MODELS_CACHE, read = readFileSync3 } = {}) {
   try {
-    const parsed = JSON.parse(read(path12, "utf8"));
+    const parsed = JSON.parse(read(path16, "utf8"));
     return Array.isArray(parsed?.models) ? parsed : null;
   } catch {
     return null;
@@ -6978,6 +7560,320 @@ var init_agent_process_env = __esm({
   }
 });
 
+// ../../scripts/virtual-office/code-runner/isolation-audit.mjs
+import fs8 from "node:fs";
+import fsp9 from "node:fs/promises";
+import path14 from "node:path";
+async function defaultRun(command, args, cwd, options = {}) {
+  return runProcess2(command, args, { cwd, timeout: 6e4, ...options });
+}
+async function git2(run, cwd, args, options = {}) {
+  return run("git", args, cwd, options);
+}
+async function canonicalRootForWorktree(worktreeDir, run) {
+  const commonDir = String(await git2(run, worktreeDir, [
+    "rev-parse",
+    "--path-format=absolute",
+    "--git-common-dir"
+  ])).trim();
+  const root = path14.dirname(commonDir);
+  return samePath2(root, worktreeDir) ? null : root;
+}
+async function snapshot(root, run) {
+  const [head, status] = await Promise.all([
+    git2(run, root, ["rev-parse", "HEAD"]),
+    git2(run, root, ["-c", "core.quotepath=false", "status", "--porcelain=v1", "-z"], { raw: true })
+  ]);
+  return { head: String(head).trim(), status: String(status) };
+}
+async function isVerifiedRemoteFastForward(baseline, current, run) {
+  if (current.status) return false;
+  try {
+    const branch = String(await git2(run, baseline.root, ["branch", "--show-current"])).trim();
+    if (branch !== "main") return false;
+    await git2(run, baseline.root, ["fetch", "--quiet", "origin", "main"]);
+    const remoteHead = String(await git2(run, baseline.root, ["rev-parse", "FETCH_HEAD"])).trim();
+    await git2(run, baseline.root, ["merge-base", "--is-ancestor", baseline.head, current.head]);
+    await git2(run, baseline.root, ["merge-base", "--is-ancestor", current.head, remoteHead]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function captureCanonicalBaseline(worktreeDir, { run = defaultRun } = {}) {
+  const root = await canonicalRootForWorktree(worktreeDir, run);
+  if (!root) return { root: null, head: null, status: "", standalone: true };
+  const state = await snapshot(root, run);
+  if (state.status) {
+    throw new Error(`canonical clone is dirty before agent launch; refusing task execution: ${root}`);
+  }
+  return { root, ...state };
+}
+async function changedPaths(root, run) {
+  const [tracked, untracked] = await Promise.all([
+    git2(run, root, ["-c", "core.quotepath=false", "diff", "--name-only", "-z", "HEAD"], { raw: true }),
+    git2(run, root, ["-c", "core.quotepath=false", "ls-files", "--others", "--exclude-standard", "-z"], { raw: true })
+  ]);
+  return { tracked: splitZ2(tracked), untracked: splitZ2(untracked) };
+}
+async function quarantineCanonicalWrites({ baseline, worktreeDir, taskId, run, now }) {
+  const paths = await changedPaths(baseline.root, run);
+  const quarantineDir = path14.join(
+    path14.dirname(worktreeDir),
+    ".canonical-recovery",
+    `${String(taskId || "unknown").replace(/[^a-z0-9-]/gi, "-")}-${now().toISOString().replace(/[:.]/g, "-")}`
+  );
+  await fsp9.mkdir(quarantineDir, { recursive: true });
+  const patch = await git2(run, baseline.root, ["diff", "--binary", "HEAD"], { raw: true });
+  await fsp9.writeFile(path14.join(quarantineDir, "tracked.patch"), patch, "utf8");
+  for (const relative of paths.untracked) {
+    const source = path14.join(baseline.root, relative);
+    const target = path14.join(quarantineDir, "untracked", relative);
+    await fsp9.mkdir(path14.dirname(target), { recursive: true });
+    await fsp9.copyFile(source, target);
+  }
+  await fsp9.writeFile(path14.join(quarantineDir, "manifest.json"), `${JSON.stringify({
+    taskId,
+    canonicalRoot: baseline.root,
+    canonicalHead: baseline.head,
+    tracked: paths.tracked,
+    untracked: paths.untracked
+  }, null, 2)}
+`, "utf8");
+  return { quarantineDir, ...paths };
+}
+async function restoreExactCanonicalPaths(baseline, evidence, run) {
+  if (evidence.tracked.length > 0) {
+    await git2(run, baseline.root, [
+      "restore",
+      `--source=${baseline.head}`,
+      "--staged",
+      "--worktree",
+      "--",
+      ...evidence.tracked
+    ]);
+  }
+  for (const relative of evidence.untracked) {
+    const target = path14.resolve(baseline.root, relative);
+    const prefix = `${path14.resolve(baseline.root)}${path14.sep}`;
+    if (!target.startsWith(prefix) || !fs8.existsSync(target)) continue;
+    await fsp9.rm(target, { force: true });
+  }
+}
+async function assertCanonicalIsolation(baseline, { worktreeDir, taskId, run = defaultRun, now = () => /* @__PURE__ */ new Date() } = {}) {
+  if (baseline.standalone) return { ok: true, standalone: true };
+  const current = await snapshot(baseline.root, run);
+  if (current.head === baseline.head && !current.status) return { ok: true };
+  if (current.head !== baseline.head) {
+    if (await isVerifiedRemoteFastForward(baseline, current, run)) {
+      return {
+        ok: true,
+        canonicalFastForward: true,
+        fromHead: baseline.head,
+        toHead: current.head
+      };
+    }
+    throw new Error(`canonical clone HEAD changed during task ${taskId}; manual recovery required: ${baseline.root}`);
+  }
+  const evidence = await quarantineCanonicalWrites({ baseline, worktreeDir, taskId, run, now });
+  await restoreExactCanonicalPaths(baseline, evidence, run);
+  const restored = await snapshot(baseline.root, run);
+  if (restored.head !== baseline.head || restored.status) {
+    throw new Error(`canonical clone recovery could not restore the exact baseline; evidence: ${evidence.quarantineDir}`);
+  }
+  throw new Error(
+    `agent attempted ${evidence.tracked.length + evidence.untracked.length} canonical-clone write(s); writes were quarantined and the clone was restored exactly: ${evidence.quarantineDir}`
+  );
+}
+var splitZ2, samePath2;
+var init_isolation_audit = __esm({
+  "../../scripts/virtual-office/code-runner/isolation-audit.mjs"() {
+    "use strict";
+    init_process_runner2();
+    splitZ2 = (value) => String(value || "").split("\0").map((item) => item.trim()).filter(Boolean);
+    samePath2 = (left, right) => {
+      const [a, b] = [left, right].map((value) => path14.resolve(value));
+      return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
+    };
+  }
+});
+
+// ../../scripts/virtual-office/code-runner/recovery-ledger.mjs
+import fs9 from "node:fs";
+import fsp10 from "node:fs/promises";
+import path15 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;
+}
+function cloneLeaf(repo) {
+  const [owner, name] = String(repo || "").split("/");
+  if (!owner || !name) return null;
+  const clean = (value) => value.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return `${clean(owner)}__${clean(name)}`;
+}
+function recoveryLedgerCandidates(repo, clonesRoot2) {
+  const leaf = cloneLeaf(repo);
+  if (!leaf || !clonesRoot2) return [];
+  const canonical = path15.join(clonesRoot2, leaf);
+  return [
+    path15.join(clonesRoot2, ".agent-worktrees", leaf, "recovery-ledger.jsonl"),
+    path15.join(canonical, ".agent-worktrees", "recovery-ledger.jsonl")
+  ];
+}
+async function readLedger(file, readFile3) {
+  try {
+    return String(await readFile3(file, "utf8")).split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+  } catch {
+    return [];
+  }
+}
+async function findPreservedRecovery(task, {
+  clonesRoot: clonesRoot2 = process.env.VO_CODE_RUNNER_CLONES_ROOT || "",
+  readFile: readFile3 = fsp10.readFile,
+  exists = fs9.existsSync
+} = {}) {
+  const originalTaskId = recoveryTaskId(task.prompt);
+  if (!originalTaskId) return null;
+  for (const ledgerPath of recoveryLedgerCandidates(task.repo, clonesRoot2)) {
+    const entries = await readLedger(ledgerPath, readFile3);
+    const resolved = entries.some((entry) => RESOLVED_RECOVERY_TYPES.has(entry.type) && entry.taskId === originalTaskId);
+    const preserved = [...entries].reverse().find((entry) => entry.taskId === originalTaskId && entry.worktreeDir);
+    if (!resolved && preserved && exists(preserved.worktreeDir)) {
+      return { originalTaskId, ledgerPath, preserved };
+    }
+  }
+  return null;
+}
+async function recoverPreservedCodeTask({
+  task,
+  cfg,
+  client,
+  log: log3,
+  find = findPreservedRecovery,
+  listChanged = listChangedFilesAsync,
+  listCommitted = listCommittedFilesAsync,
+  openPr = openCodeTaskPrAsync,
+  appendFile = fsp10.appendFile,
+  track = trackDispatchedPr
+} = {}) {
+  const recovery = await find(task);
+  if (!recovery) return null;
+  const cwd = recovery.preserved.worktreeDir;
+  let files = (await listChanged(cwd)).filter((file) => !isAgentScratch(file));
+  let alreadyCommitted = false;
+  if (files.length === 0) {
+    files = (await listCommitted(cwd)).filter((file) => !isAgentScratch(file));
+    alreadyCommitted = files.length > 0;
+  }
+  if (files.length === 0) {
+    await appendFile(recovery.ledgerPath, `${JSON.stringify({
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      type: "recovery_skipped_no_files",
+      taskId: recovery.originalTaskId,
+      resumedTaskId: task.code_task_id,
+      worktreeDir: cwd
+    })}
+`, "utf8");
+    log3(`task ${task.code_task_id}: preserved task ${recovery.originalTaskId} has no recoverable files; starting fresh`);
+    return null;
+  }
+  const token2 = (await client.getInstallationToken({ required: cfg.requireGithubAppAuth }))?.token ?? null;
+  const run = { summary: `Recovered preserved work from task ${recovery.originalTaskId}.` };
+  const supersedesPrNumber = supersededSourcePrNumber(recovery.preserved.prompt || task.prompt);
+  const targetBranch = supersedesPrNumber && task.pr_branch ? task.pr_branch : null;
+  const pr = await openPr(cwd, files, {
+    title: `code-task recovery: ${String(task.prompt).split("\n").find((line) => line && !line.startsWith(RECOVERY_MARKER)) || task.prompt}`,
+    body: buildPrBody(task, run, files, { armAutoMerge: cfg.armAutoMerge }),
+    alreadyCommitted,
+    githubToken: token2,
+    allowAmbientGithubFallback: cfg.allowAmbientGithub,
+    draft: false,
+    armAutoMerge: false,
+    supersedesPrNumber,
+    targetBranch
+  });
+  await appendFile(recovery.ledgerPath, `${JSON.stringify({
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    type: "recovered",
+    taskId: recovery.originalTaskId,
+    resumedTaskId: task.code_task_id,
+    prUrl: pr.prUrl,
+    prNumber: pr.prNumber
+  })}
+`, "utf8");
+  await client.postProgress(task.code_task_id, {
+    status: "pr_opened",
+    stage: "opening_pr",
+    pr_url: pr.prUrl,
+    pr_number: pr.prNumber,
+    message: `recovered preserved work from ${recovery.originalTaskId} and opened ${pr.prUrl}`,
+    result: run.summary
+  });
+  log3(`task ${task.code_task_id} recovered ${recovery.originalTaskId} \u2192 PR ${pr.prUrl}`);
+  if (cfg.watchEnabled) {
+    await track({
+      prNumber: pr.prNumber,
+      repo: task.repo,
+      branch: pr.branch,
+      taskId: task.code_task_id,
+      operatorId: task.operator_id,
+      tenantId: task.tenant_id,
+      needsContinuation: false,
+      allowFixDispatch: !String(task.prompt || "").includes(CI_FIX_MARKER)
+    }).catch((e) => log3(`watch: track failed for recovered #${pr.prNumber}: ${e.message}`));
+  }
+  return { ...pr, files, originalTaskId: recovery.originalTaskId };
+}
+var RECOVERY_MARKER, RESOLVED_RECOVERY_TYPES;
+var init_recovery_ledger = __esm({
+  "../../scripts/virtual-office/code-runner/recovery-ledger.mjs"() {
+    "use strict";
+    init_publish();
+    init_publish_async();
+    init_task_helpers();
+    init_pr_watcher();
+    init_superseded_pr_source();
+    RECOVERY_MARKER = "VO_RECOVERY_FROM_CODE_TASK:";
+    RESOLVED_RECOVERY_TYPES = /* @__PURE__ */ new Set(["recovered", "recovery_skipped_no_files"]);
+  }
+});
+
+// ../../scripts/virtual-office/code-runner/no-changes-terminal-status.mjs
+function isMaxTurnExhaustion(run = {}, maxTurns) {
+  const summary = String(run.summary || "").trim().toLowerCase();
+  if (summary === "error_max_turns" || summary === "inconclusive_max_turns") return true;
+  return Number.isInteger(maxTurns) && maxTurns > 0 && Number.isInteger(run.numTurns) && run.numTurns > maxTurns;
+}
+function decideNoChangesTerminalStatus({ partial, run = {}, maxTurns } = {}) {
+  if (!partial) {
+    return {
+      status: "no_changes_needed",
+      message: "agent completed \u2014 no change needed (already fixed / nothing to do)",
+      result: String(run.summary || "no_changes_needed").slice(0, RESULT_LIMIT)
+    };
+  }
+  if (isMaxTurnExhaustion(run, maxTurns)) {
+    return {
+      status: "failed",
+      message: "agent reached the max-turn limit before producing a verified change",
+      result: "inconclusive_max_turns"
+    };
+  }
+  return {
+    status: "failed",
+    message: "agent made no file changes",
+    result: "no_changes"
+  };
+}
+var RESULT_LIMIT;
+var init_no_changes_terminal_status = __esm({
+  "../../scripts/virtual-office/code-runner/no-changes-terminal-status.mjs"() {
+    "use strict";
+    RESULT_LIMIT = 2e3;
+  }
+});
+
 // ../../scripts/virtual-office/code-runner-daemon.mjs
 var code_runner_daemon_exports = {};
 __export(code_runner_daemon_exports, {
@@ -7027,10 +7923,23 @@ async function processOneTask(client, task, cfg) {
   let worktreeName = "";
   let preserveReason = null;
   try {
+    if (await recoverPreservedCodeTask({ task, cfg, client, log: log2 })) return;
     await safeProgress(client, id, runnerStagePatch("preparing_worktree", `${cfg.runnerId} preparing an isolated worktree for ${task.repo}`));
     const wt = await Promise.resolve(createFixWorktree("code-task", { source: id.slice(0, 8), repo: task.repo }));
     worktreeName = wt.worktreeName;
     if (!worktreeName || !wt.worktreeDir) throw new Error("worktree isolation failure \u2014 refusing to run in the main tree");
+    const githubToken = (await client.getInstallationToken({ required: cfg.requireGithubAppAuth }))?.token ?? null;
+    const parentTask = task.resumed_from ? await client.getTask(task.resumed_from).catch(() => null) : null;
+    const continuationRestore = await prepareContinuationBranch(wt.worktreeDir, {
+      task,
+      parentTask,
+      githubToken,
+      allowAmbientGithubFallback: cfg.allowAmbientGithub
+    });
+    if (continuationRestore) {
+      log2(`task ${id}: restored continuation branch ${continuationRestore.remoteBranch} into ${continuationRestore.localBranch}`);
+    }
+    const canonicalBaseline = await captureCanonicalBaseline(wt.worktreeDir);
     const sel = resolveTaskRunner(task, cfg, process.env, { warn: (m) => log2(`agent-select: ${m}`) });
     const { dispatchMode, routerMode, tier, model, permissionMode: effectivePermissionMode, maxTurns: effectiveMaxTurns, effort: effectiveEffort, maxBudgetUsd: effectiveMaxBudgetUsd, prompt: effortPrompt, routerDecision } = await resolveEffortDispatch({ client, task, agent: sel.agent, env: process.env, basePrompt: await composeCodeTaskPrompt(client, task, {
       log: log2,
@@ -7063,6 +7972,7 @@ async function processOneTask(client, task, cfg) {
       cancelPollMs: cfg.cancelPollMs,
       maxWallClockMs: cfg.maxWallClockMs
     });
+    await assertCanonicalIsolation(canonicalBaseline, { worktreeDir: wt.worktreeDir, taskId: id });
     if (run.killed) {
       preserveReason = "cancelled by operator \u2014 work preserved for recovery";
       log2(`task ${id} cancelled by operator`);
@@ -7113,10 +8023,9 @@ async function processOneTask(client, task, cfg) {
       log2(`task ${id}: dropped ${scratch.length} scratch file(s): ${scratch.join(", ")}`);
     }
     if (files.length === 0) {
+      const terminal = decideNoChangesTerminalStatus({ partial, run, maxTurns: effectiveMaxTurns });
       await safeProgress(client, id, {
-        status: partial ? "failed" : "no_changes_needed",
-        message: partial ? "agent made no file changes" : "agent completed \u2014 no change needed (already fixed / nothing to do)",
-        result: partial ? "no_changes" : String(run.summary || "no_changes_needed").slice(0, 2e3),
+        ...terminal,
         cost_usd: numOrUndef(run.costUsd),
         num_turns: numOrUndef(run.numTurns)
       });
@@ -7129,7 +8038,6 @@ async function processOneTask(client, task, cfg) {
       return;
     }
     await safeProgress(client, id, runnerStagePatch("opening_pr", `opening PR for ${files.length} changed file(s)`));
-    const githubToken = (await client.getInstallationToken({ required: cfg.requireGithubAppAuth }))?.token ?? null;
     const pr = await openCodeTaskPrAsync(wt.worktreeDir, files, {
       title: `${partial ? `${partialPrTitlePrefix(run)} \u2014 ` : ""}code-task: ${task.prompt}`,
       body: buildPrBody(task, run, files, { armAutoMerge: cfg.armAutoMerge }),
@@ -7139,19 +8047,22 @@ async function processOneTask(client, task, cfg) {
       draft: partial,
       armAutoMerge: false,
       // watcher waits for green CI, then uses exact-SHA consensus merge
-      supersedesPrNumber: ciFixSourcePrNumber(task.prompt)
+      targetBranch: continuationRestore?.remoteBranch || void 0,
+      supersedesPrNumber: supersededSourcePrNumber(task.prompt)
     });
     const autoMergeMessage = pr.autoMergeArmed ? "; auto-merge armed" : pr.autoMergeError ? `; auto-merge arm failed: ${String(pr.autoMergeError).slice(0, 220)}` : "";
+    const cleanupMessage = pr.supersededPrCloseError ? `; replacement published, source PR cleanup pending: ${String(pr.supersededPrCloseError).slice(0, 180)}` : "";
     await safeProgress(client, id, {
       status: "pr_opened",
-      message: `opened ${pr.prUrl}${autoMergeMessage}`,
+      message: `opened ${pr.prUrl}${autoMergeMessage}${cleanupMessage}`,
       pr_url: pr.prUrl,
       pr_number: pr.prNumber,
+      pr_branch: pr.branch,
       result: String(run.summary).slice(0, 2e3),
       cost_usd: numOrUndef(run.costUsd),
       num_turns: numOrUndef(run.numTurns)
     });
-    log2(`task ${id} \u2192 PR ${pr.prUrl}${autoMergeMessage}`);
+    log2(`task ${id} \u2192 PR ${pr.prUrl}${autoMergeMessage}${cleanupMessage}`);
     if (cfg.watchEnabled) {
       await trackDispatchedPr({
         prNumber: pr.prNumber,
@@ -7280,13 +8191,14 @@ var init_code_runner_daemon = __esm({
     init_resolve_runner();
     init_rate_limit_resume();
     init_publish();
-    init_publish();
     init_publish_async();
+    init_resume_branch();
     init_task_prompt();
     init_loop_ticks();
     init_agent_availability();
     init_account_usage();
     init_pr_watcher();
+    init_superseded_pr_source();
     init_watch_cycle_coordinator();
     init_control_server();
     init_apply_effort_mode();
@@ -7294,6 +8206,9 @@ var init_code_runner_daemon = __esm({
     init_reconnect_backoff();
     init_task_helpers();
     init_agent_process_env();
+    init_isolation_audit();
+    init_recovery_ledger();
+    init_no_changes_terminal_status();
     RATE_LIMIT_RESUME_ENABLED = process.env.VO_RATE_LIMIT_RESUME === "1";
     parseList = (s) => String(s || "").split(/[\s,]+/).map((x) => x.trim()).filter(Boolean);
     sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));