@algosuite/vo-mcp 0.2.0-beta.75 → 0.2.0-beta.76

package/dist/runner-cli.js

@@ -1614,6 +1614,67 @@ var init_process_runner = __esm({
   }
 });
 
+// src/runner/worktree-paths.mjs
+import { createHash as createHash2 } from "node:crypto";
+import fs from "node:fs";
+import path3 from "node:path";
+function canonicalPathKey(target, { cache: cache2 = null, realpath: realpath2 = fs.realpathSync.native } = {}) {
+  const resolved = path3.resolve(String(target || ""));
+  const tail = [];
+  let cursor = resolved;
+  for (; ; ) {
+    let real = cache2 ? cache2.get(cursor) : void 0;
+    if (real === void 0) {
+      try {
+        real = realpath2(cursor);
+      } catch {
+        real = null;
+      }
+      if (cache2) cache2.set(cursor, real);
+    }
+    if (real) {
+      const unprefixed = String(real).replace(/^\\\\\?\\UNC\\/u, "\\\\").replace(/^\\\\\?\\/u, "");
+      const joined = tail.length ? path3.join(unprefixed, ...[...tail].reverse()) : unprefixed;
+      return process.platform === "win32" ? joined.toLowerCase() : joined;
+    }
+    const parent = path3.dirname(cursor);
+    if (parent === cursor) break;
+    tail.push(path3.basename(cursor));
+    cursor = parent;
+  }
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function samePath2(left, right) {
+  const a = path3.resolve(left);
+  const b = path3.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 = path3.resolve(root);
+  if (clonesRootDir) {
+    const clonePool = path3.resolve(clonesRootDir);
+    if (samePath2(path3.dirname(canonicalRoot), clonePool)) {
+      return path3.join(clonePool, ".agent-worktrees", path3.basename(canonicalRoot));
+    }
+  }
+  return path3.join(canonicalRoot, ".agent-worktrees");
+}
+function worktreeDirForName(root, worktreeName, options = {}) {
+  const leaf = createHash2("sha256").update(String(worktreeName)).digest("hex").slice(0, 16);
+  return path3.join(worktreePoolForRoot(root, options), leaf);
+}
+function recoveryLedgerPathForRoot(root, options = {}) {
+  return path3.join(worktreePoolForRoot(root, options), "recovery-ledger.jsonl");
+}
+function legacyRecoveryLedgerPathForRoot(root) {
+  return path3.join(path3.resolve(root), ".agent-worktrees", "recovery-ledger.jsonl");
+}
+var init_worktree_paths = __esm({
+  "src/runner/worktree-paths.mjs"() {
+    "use strict";
+  }
+});
+
 // src/runner/worktree-add.mjs
 import fsp2 from "node:fs/promises";
 async function pathExists2(target) {
@@ -1634,8 +1695,9 @@ async function worktreeStillRegistered(root, worktreeDir, runner) {
       `git worktree list --porcelain failed during rollback verification: ${summarizeProcessFailure(listed)}`
     );
   }
-  const registered = String(listed.stdout || "").split(/\r?\n/u).filter((line) => line.startsWith("worktree ")).map((line) => line.slice("worktree ".length).trim());
-  return registered.includes(worktreeDir);
+  const cache2 = /* @__PURE__ */ new Map();
+  const target = canonicalPathKey(worktreeDir, { cache: cache2 });
+  return String(listed.stdout || "").split(/\r?\n/u).filter((line) => line.startsWith("worktree ")).some((line) => canonicalPathKey(line.slice("worktree ".length).trim(), { cache: cache2 }) === target);
 }
 async function branchStillExists(root, branchName, runner) {
   const listed = await runner("git", ["branch", "--list", "--format=%(refname:short)", branchName], {
@@ -1749,25 +1811,26 @@ var init_worktree_add = __esm({
     "use strict";
     init_pnpm_link_detach();
     init_process_runner();
+    init_worktree_paths();
     DEFAULT_WORKTREE_ADD_TIMEOUT_MS = 10 * 60 * 1e3;
     DEFAULT_WORKTREE_ADD_ATTEMPTS = 2;
   }
 });
 
 // src/runner/pnpm-canonical-health.mjs
-import fs from "node:fs";
+import fs2 from "node:fs";
 import fsp3 from "node:fs/promises";
-import path3 from "node:path";
+import path4 from "node:path";
 function readJsonFile(file) {
-  if (!fs.existsSync(file)) return null;
+  if (!fs2.existsSync(file)) return null;
   try {
-    return JSON.parse(fs.readFileSync(file, "utf8"));
+    return JSON.parse(fs2.readFileSync(file, "utf8"));
   } catch {
     return null;
   }
 }
 function packageJsonAt(root) {
-  return readJsonFile(path3.join(root, "package.json"));
+  return readJsonFile(path4.join(root, "package.json"));
 }
 function dependencyNamesForPackage(root) {
   const manifest = packageJsonAt(root);
@@ -1779,7 +1842,7 @@ function dependencyNamesForPackage(root) {
   ])].sort();
 }
 function packageEntryPath(nodeModulesDir, packageName) {
-  return path3.join(nodeModulesDir, ...String(packageName || "").split("/"));
+  return path4.join(nodeModulesDir, ...String(packageName || "").split("/"));
 }
 function rootFsApi() {
   return {
@@ -1808,7 +1871,7 @@ async function inspectDependencyEntry(nodeModulesDir, packageName, fsApi) {
   } catch {
     return { issue: `missing or dangling dependency link: ${entry}` };
   }
-  const packageJsonPath = path3.join(resolved, "package.json");
+  const packageJsonPath = path4.join(resolved, "package.json");
   if (!await pathExists3(packageJsonPath, fsApi)) {
     return { issue: `dependency target is missing package.json: ${entry} -> ${resolved}` };
   }
@@ -1820,11 +1883,11 @@ async function inspectDependencyEntry(nodeModulesDir, packageName, fsApi) {
   return { issue: null };
 }
 function representativePackages(root, linkedWorkspaceDirs, sampleLimit) {
-  const packages = [{ nodeModulesDir: path3.join(root, "node_modules"), packageRoot: root }];
+  const packages = [{ nodeModulesDir: path4.join(root, "node_modules"), packageRoot: root }];
   for (const relativeDir of linkedWorkspaceDirs) {
     packages.push({
-      nodeModulesDir: path3.join(root, relativeDir, "node_modules"),
-      packageRoot: path3.join(root, relativeDir)
+      nodeModulesDir: path4.join(root, relativeDir, "node_modules"),
+      packageRoot: path4.join(root, relativeDir)
     });
   }
   const representatives = [];
@@ -1836,7 +1899,7 @@ function representativePackages(root, linkedWorkspaceDirs, sampleLimit) {
   return representatives;
 }
 function canonicalNodeModulesQuarantineRoot(root) {
-  return path3.join(root, ".agent-worktrees", QUARANTINE_DIRNAME);
+  return path4.join(root, ".agent-worktrees", QUARANTINE_DIRNAME);
 }
 async function inspectCanonicalNodeModulesHealth({
   root,
@@ -1847,8 +1910,8 @@ async function inspectCanonicalNodeModulesHealth({
   sampleLimit = DEFAULT_SAMPLE_LIMIT
 }) {
   const issues = [];
-  const nodeModulesDir = path3.join(root, "node_modules");
-  const markerPath = path3.join(nodeModulesDir, ".vo-deps-state.json");
+  const nodeModulesDir = path4.join(root, "node_modules");
+  const markerPath = path4.join(nodeModulesDir, ".vo-deps-state.json");
   if (!await pathExists3(nodeModulesDir, fsApi)) {
     issues.push(`missing root node_modules: ${nodeModulesDir}`);
   } else {
@@ -1857,8 +1920,8 @@ async function inspectCanonicalNodeModulesHealth({
       issues.push(`root node_modules must be a real directory: ${nodeModulesDir}`);
     }
   }
-  if (!await pathExists3(path3.join(nodeModulesDir, ".pnpm"), fsApi)) {
-    issues.push(`missing root .pnpm store view: ${path3.join(nodeModulesDir, ".pnpm")}`);
+  if (!await pathExists3(path4.join(nodeModulesDir, ".pnpm"), fsApi)) {
+    issues.push(`missing root .pnpm store view: ${path4.join(nodeModulesDir, ".pnpm")}`);
   }
   if (requireMarker) {
     try {
@@ -1871,7 +1934,7 @@ async function inspectCanonicalNodeModulesHealth({
     }
   }
   for (const relativeDir of linkedWorkspaceDirs) {
-    const workspaceNodeModules = path3.join(root, relativeDir, "node_modules");
+    const workspaceNodeModules = path4.join(root, relativeDir, "node_modules");
     if (!await pathExists3(workspaceNodeModules, fsApi)) {
       issues.push(`missing workspace node_modules: ${workspaceNodeModules}`);
       continue;
@@ -1894,17 +1957,17 @@ async function inspectCanonicalNodeModulesHealth({
 async function quarantineCanonicalNodeModules(root, issues, options = {}) {
   const fsApi = options.fsApi || rootFsApi();
   const logger = options.logger || console.error;
-  const nodeModulesDir = path3.join(root, "node_modules");
+  const nodeModulesDir = path4.join(root, "node_modules");
   const quarantineRoot = canonicalNodeModulesQuarantineRoot(root);
   if (!await pathExists3(nodeModulesDir, fsApi)) return null;
   await fsApi.mkdir(quarantineRoot, { recursive: true });
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   let attempt = 0;
   for (; ; ) {
-    const quarantinePath = path3.join(quarantineRoot, `node_modules-${stamp}-${process.pid}-${attempt}`);
+    const quarantinePath = path4.join(quarantineRoot, `node_modules-${stamp}-${process.pid}-${attempt}`);
     try {
       await fsApi.rename(nodeModulesDir, quarantinePath);
-      const metadataPath = path3.join(quarantinePath, ".vo-runner-quarantine.json");
+      const metadataPath = path4.join(quarantinePath, ".vo-runner-quarantine.json");
       await fsApi.writeFile(metadataPath, `${JSON.stringify({
         issues,
         originalPath: nodeModulesDir,
@@ -1929,27 +1992,27 @@ var init_pnpm_canonical_health = __esm({
 });
 
 // src/runner/pnpm-command.mjs
-import fs2 from "node:fs";
+import fs3 from "node:fs";
 import os from "node:os";
-import path4 from "node:path";
+import path5 from "node:path";
 function isWindowsDriveOrUnc(value) {
   return WINDOWS_DRIVE_OR_UNC_RE.test(String(value || ""));
 }
 function portableDirname(value) {
-  if (isWindowsDriveOrUnc(value)) return path4.win32.dirname(value);
-  if (path4.posix.isAbsolute(value)) return path4.posix.dirname(value);
-  return path4.dirname(value);
+  if (isWindowsDriveOrUnc(value)) return path5.win32.dirname(value);
+  if (path5.posix.isAbsolute(value)) return path5.posix.dirname(value);
+  return path5.dirname(value);
 }
 function portableJoin(root, ...segments) {
-  if (isWindowsDriveOrUnc(root)) return path4.win32.join(root, ...segments);
-  if (path4.posix.isAbsolute(root)) return path4.posix.join(root, ...segments);
-  return path4.join(root, ...segments);
+  if (isWindowsDriveOrUnc(root)) return path5.win32.join(root, ...segments);
+  if (path5.posix.isAbsolute(root)) return path5.posix.join(root, ...segments);
+  return path5.join(root, ...segments);
 }
 function readPackageManager(root) {
-  const packagePath = path4.join(root, "package.json");
-  if (!fs2.existsSync(packagePath)) return "";
+  const packagePath = path5.join(root, "package.json");
+  if (!fs3.existsSync(packagePath)) return "";
   try {
-    return String(JSON.parse(fs2.readFileSync(packagePath, "utf8"))?.packageManager || "").trim();
+    return String(JSON.parse(fs3.readFileSync(packagePath, "utf8"))?.packageManager || "").trim();
   } catch {
     return "";
   }
@@ -1966,13 +2029,13 @@ function pnpmSelector(root) {
   const packageManager = readPackageManager(root);
   const version = validatedPnpmVersionToken(root);
   if (packageManager && !version) {
-    throw new Error(`[vo-mcp runner] invalid pnpm packageManager token in ${path4.join(root, "package.json")}`);
+    throw new Error(`[vo-mcp runner] invalid pnpm packageManager token in ${path5.join(root, "package.json")}`);
   }
   return version ? `pnpm@${version}` : "pnpm";
 }
 function whereResults(result) {
   if (result?.status !== 0) return [];
-  return String(result.stdout || "").split(/\r?\n/u).map((line) => line.trim()).filter((line) => path4.win32.isAbsolute(line));
+  return String(result.stdout || "").split(/\r?\n/u).map((line) => line.trim()).filter((line) => path5.win32.isAbsolute(line));
 }
 async function resolveWindowsNativeCommand(command, runner) {
   const result = await runner("where", [command], { timeoutMs: 1e4 });
@@ -1984,29 +2047,29 @@ function trustedCorepackCandidates(options) {
   const roots = [portableDirname(execPath)];
   for (const key of ["ProgramW6432", "ProgramFiles", "ProgramFiles(x86)"]) {
     const programFiles = String(env2[key] || "").trim();
-    if (isWindowsDriveOrUnc(programFiles) || path4.posix.isAbsolute(programFiles)) {
+    if (isWindowsDriveOrUnc(programFiles) || path5.posix.isAbsolute(programFiles)) {
       roots.push(portableJoin(programFiles, "nodejs"));
     }
   }
   return [...new Set(roots)].map((root) => portableJoin(root, "node_modules", "corepack", "dist", "corepack.js"));
 }
 function resolveTrustedCorepackJs(options) {
-  const existsSync13 = options.existsSync || fs2.existsSync;
+  const existsSync13 = options.existsSync || fs3.existsSync;
   return trustedCorepackCandidates(options).find((candidate) => existsSync13(candidate)) || "";
 }
 function defaultPnpmShimRoot() {
-  return path4.join(os.homedir(), ".vo", "pnpm-shim");
+  return path5.join(os.homedir(), ".vo", "pnpm-shim");
 }
 function materializePnpmShimDir(corepackJs, execPath, options = {}) {
-  const mkdirSync10 = options.mkdirSync || fs2.mkdirSync;
-  const writeFileSync6 = options.writeFileSync || fs2.writeFileSync;
-  const chmodSync3 = options.chmodSync || fs2.chmodSync;
+  const mkdirSync10 = options.mkdirSync || fs3.mkdirSync;
+  const writeFileSync6 = options.writeFileSync || fs3.writeFileSync;
+  const chmodSync3 = options.chmodSync || fs3.chmodSync;
   const dir = options.shimRoot || defaultPnpmShimRoot();
   mkdirSync10(dir, { recursive: true });
-  writeFileSync6(path4.join(dir, PNPM_SHIM_CMD_NAME), `@echo off\r
+  writeFileSync6(path5.join(dir, PNPM_SHIM_CMD_NAME), `@echo off\r
 "${execPath}" "${corepackJs}" pnpm %*\r
 `);
-  const shPath = path4.join(dir, PNPM_SHIM_SH_NAME);
+  const shPath = path5.join(dir, PNPM_SHIM_SH_NAME);
   writeFileSync6(shPath, `#!/bin/sh
 exec "${execPath}" "${corepackJs}" pnpm "$@"
 `);
@@ -2018,8 +2081,8 @@ exec "${execPath}" "${corepackJs}" pnpm "$@"
 }
 function commandDirectory(command) {
   if (!command) return "";
-  if (isWindowsDriveOrUnc(command)) return path4.win32.dirname(command);
-  if (path4.posix.isAbsolute(command)) return path4.posix.dirname(command);
+  if (isWindowsDriveOrUnc(command)) return path5.win32.dirname(command);
+  if (path5.posix.isAbsolute(command)) return path5.posix.dirname(command);
   return "";
 }
 function agentPathDirs(command, execPath) {
@@ -2108,7 +2171,7 @@ var init_pnpm_command = __esm({
 
 // src/runner/pnpm-materialize.mjs
 import fsp4 from "node:fs/promises";
-import path5 from "node:path";
+import path6 from "node:path";
 function linkType() {
   return process.platform === "win32" ? "junction" : "dir";
 }
@@ -2119,14 +2182,16 @@ async function realpathOrThrow(target, fsApi) {
     throw new Error(`[vo-mcp runner] dependency path is missing: ${target}`);
   }
 }
-function shouldMapToWorktree(resolvedTarget, canonicalRoot) {
-  const relative = path5.relative(canonicalRoot, resolvedTarget).replace(/\\/g, "/");
-  return Boolean(relative && !relative.startsWith("..") && !relative.split("/").includes("node_modules"));
+function shouldMapToWorktree(resolvedTarget, canonicalRoot, pathApi = path6) {
+  const relative = pathApi.relative(canonicalRoot, resolvedTarget);
+  if (!relative || pathApi.isAbsolute(relative)) return false;
+  const normalized = relative.replace(/\\/g, "/");
+  return !normalized.startsWith("..") && !normalized.split("/").includes("node_modules");
 }
 async function resolveEntryTarget(sourceEntry, canonicalRoot, worktreeRoot, fsApi) {
   const resolved = await realpathOrThrow(sourceEntry, fsApi);
   if (!shouldMapToWorktree(resolved, canonicalRoot)) return resolved;
-  const mapped = path5.join(worktreeRoot, path5.relative(canonicalRoot, resolved));
+  const mapped = path6.join(worktreeRoot, path6.relative(canonicalRoot, resolved));
   if (!await fsApi.pathExists(mapped)) {
     throw new Error(`[vo-mcp runner] task-local workspace target is missing for dependency link: ${mapped}`);
   }
@@ -2137,7 +2202,7 @@ async function ensureLinkedDirectory(source, target, fsApi) {
     if (await fsApi.realpath(target) === await fsApi.realpath(source)) return;
     throw new Error(`[vo-mcp runner] refusing to overwrite existing dependency path: ${target}`);
   }
-  await fsApi.mkdir(path5.dirname(target), { recursive: true });
+  await fsApi.mkdir(path6.dirname(target), { recursive: true });
   await fsApi.symlink(source, target, linkType());
   if (await fsApi.realpath(target) !== await fsApi.realpath(source)) {
     throw new Error(`[vo-mcp runner] dependency link validation failed for ${target}`);
@@ -2151,8 +2216,8 @@ async function maybeYield2(state) {
 async function copyDirRecursive(sourceDir, targetDir, fsApi, yieldState) {
   await fsApi.mkdir(targetDir, { recursive: true });
   for (const entry of await fsApi.readdir(sourceDir, { withFileTypes: true })) {
-    const source = path5.join(sourceDir, entry.name);
-    const target = path5.join(targetDir, entry.name);
+    const source = path6.join(sourceDir, entry.name);
+    const target = path6.join(targetDir, entry.name);
     await maybeYield2(yieldState);
     if (entry.isDirectory()) {
       await copyDirRecursive(source, target, fsApi, yieldState);
@@ -2164,17 +2229,17 @@ async function copyDirRecursive(sourceDir, targetDir, fsApi, yieldState) {
 async function materializeEntry(sourceEntry, targetEntry, canonicalRoot, worktreeRoot, options) {
   await options.beforeEntry?.(sourceEntry, targetEntry);
   const stat3 = await options.fsApi.lstat(sourceEntry);
-  if (stat3.isDirectory() && !stat3.isSymbolicLink() && path5.basename(sourceEntry) === ".bin") {
+  if (stat3.isDirectory() && !stat3.isSymbolicLink() && path6.basename(sourceEntry) === ".bin") {
     await copyDirRecursive(sourceEntry, targetEntry, options.fsApi, options.yieldState);
     return;
   }
-  if (stat3.isDirectory() && !stat3.isSymbolicLink() && path5.basename(sourceEntry).startsWith("@")) {
+  if (stat3.isDirectory() && !stat3.isSymbolicLink() && path6.basename(sourceEntry).startsWith("@")) {
     await options.fsApi.mkdir(targetEntry, { recursive: true });
     for (const nested of await options.fsApi.readdir(sourceEntry, { withFileTypes: true })) {
       await maybeYield2(options.yieldState);
       await materializeEntry(
-        path5.join(sourceEntry, nested.name),
-        path5.join(targetEntry, nested.name),
+        path6.join(sourceEntry, nested.name),
+        path6.join(targetEntry, nested.name),
         canonicalRoot,
         worktreeRoot,
         options
@@ -2187,7 +2252,7 @@ async function materializeEntry(sourceEntry, targetEntry, canonicalRoot, worktre
     await ensureLinkedDirectory(resolvedTarget, targetEntry, options.fsApi);
     return;
   }
-  await options.fsApi.mkdir(path5.dirname(targetEntry), { recursive: true });
+  await options.fsApi.mkdir(path6.dirname(targetEntry), { recursive: true });
   await options.fsApi.copyFile(sourceEntry, targetEntry);
 }
 function createPnpmFsApi(pathExists6) {
@@ -2207,13 +2272,14 @@ function createPnpmFsApi(pathExists6) {
   };
 }
 async function materializeNodeModulesForest(sourceNodeModules, targetNodeModules, canonicalRoot, worktreeRoot, options) {
+  const realCanonicalRoot = await realpathOrThrow(canonicalRoot, options.fsApi);
   await options.fsApi.mkdir(targetNodeModules, { recursive: true });
   for (const entry of await options.fsApi.readdir(sourceNodeModules, { withFileTypes: true })) {
     await maybeYield2(options.yieldState);
     await materializeEntry(
-      path5.join(sourceNodeModules, entry.name),
-      path5.join(targetNodeModules, entry.name),
-      canonicalRoot,
+      path6.join(sourceNodeModules, entry.name),
+      path6.join(targetNodeModules, entry.name),
+      realCanonicalRoot,
       worktreeRoot,
       options
     );
@@ -2226,21 +2292,21 @@ var init_pnpm_materialize = __esm({
 });
 
 // src/runner/pnpm-hydration.mjs
-import { createHash as createHash2 } from "node:crypto";
-import fs3 from "node:fs";
+import { createHash as createHash3 } from "node:crypto";
+import fs4 from "node:fs";
 import fsp5 from "node:fs/promises";
-import path6 from "node:path";
+import path7 from "node:path";
 function hashText(text) {
-  return createHash2("sha256").update(String(text)).digest("hex");
+  return createHash3("sha256").update(String(text)).digest("hex");
 }
 function statePath(root) {
-  return path6.join(root, ".agent-worktrees", "runner-pnpm-hydration.json");
+  return path7.join(root, ".agent-worktrees", "runner-pnpm-hydration.json");
 }
 function packageJson(root) {
-  const packagePath = path6.join(root, "package.json");
-  if (!fs3.existsSync(packagePath)) return null;
+  const packagePath = path7.join(root, "package.json");
+  if (!fs4.existsSync(packagePath)) return null;
   try {
-    return JSON.parse(fs3.readFileSync(packagePath, "utf8"));
+    return JSON.parse(fs4.readFileSync(packagePath, "utf8"));
   } catch {
     return null;
   }
@@ -2254,23 +2320,23 @@ async function pathExists4(target) {
   }
 }
 function lockfileHash(root) {
-  const lockPath = path6.join(root, "pnpm-lock.yaml");
-  if (!fs3.existsSync(lockPath)) return "";
-  return hashText(fs3.readFileSync(lockPath, "utf8"));
+  const lockPath = path7.join(root, "pnpm-lock.yaml");
+  if (!fs4.existsSync(lockPath)) return "";
+  return hashText(fs4.readFileSync(lockPath, "utf8"));
 }
 function readHydrationState(root) {
   const file = statePath(root);
-  if (!fs3.existsSync(file)) return null;
+  if (!fs4.existsSync(file)) return null;
   try {
-    return JSON.parse(fs3.readFileSync(file, "utf8"));
+    return JSON.parse(fs4.readFileSync(file, "utf8"));
   } catch {
     return null;
   }
 }
 function writeHydrationState(root, state) {
   const file = statePath(root);
-  fs3.mkdirSync(path6.dirname(file), { recursive: true });
-  fs3.writeFileSync(file, `${JSON.stringify({
+  fs4.mkdirSync(path7.dirname(file), { recursive: true });
+  fs4.writeFileSync(file, `${JSON.stringify({
     ...state,
     stateVersion: 2,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -2278,7 +2344,7 @@ function writeHydrationState(root, state) {
 `, "utf8");
 }
 function voDepsStatePath(root) {
-  return path6.join(root, "node_modules", ".vo-deps-state.json");
+  return path7.join(root, "node_modules", ".vo-deps-state.json");
 }
 async function ensureVoDepsState(root, expectedHash, fsApi = fsp5) {
   const marker = voDepsStatePath(root);
@@ -2288,7 +2354,7 @@ async function ensureVoDepsState(root, expectedHash, fsApi = fsp5) {
   } catch {
   }
   const temp = `${marker}.tmp-${process.pid}-${Date.now()}`;
-  await fsApi.mkdir(path6.dirname(marker), { recursive: true });
+  await fsApi.mkdir(path7.dirname(marker), { recursive: true });
   await fsApi.writeFile(temp, `${JSON.stringify({ lockfileHash: expectedHash, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)}
 `, "utf8");
   await fsApi.rename(temp, marker);
@@ -2315,9 +2381,9 @@ function workspacePatternsFromPackageJson(root) {
   return [];
 }
 function workspacePatternsFromPnpmWorkspace(root) {
-  const workspacePath = path6.join(root, "pnpm-workspace.yaml");
-  if (!fs3.existsSync(workspacePath)) return [];
-  const lines = fs3.readFileSync(workspacePath, "utf8").split(/\r?\n/u);
+  const workspacePath = path7.join(root, "pnpm-workspace.yaml");
+  if (!fs4.existsSync(workspacePath)) return [];
+  const lines = fs4.readFileSync(workspacePath, "utf8").split(/\r?\n/u);
   const patterns = [];
   let inPackages = false;
   for (const rawLine of lines) {
@@ -2374,16 +2440,16 @@ function collectPackageDirs(root, options = {}) {
   while (stack.length > 0) {
     const current = stack.pop();
     if (!current) continue;
-    const relativeDir = path6.relative(root, current.dir).replace(/\\/g, "/");
-    if (relativeDir && fs3.existsSync(path6.join(current.dir, "package.json"))) {
+    const relativeDir = path7.relative(root, current.dir).replace(/\\/g, "/");
+    if (relativeDir && fs4.existsSync(path7.join(current.dir, "package.json"))) {
       found.push(relativeDir);
       if (found.length >= maxDirs) break;
     }
     if (current.depth >= maxDepth) continue;
-    for (const entry of fs3.readdirSync(current.dir, { withFileTypes: true })) {
+    for (const entry of fs4.readdirSync(current.dir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
       if (IGNORED_SCAN_DIRS.has(entry.name)) continue;
-      stack.push({ dir: path6.join(current.dir, entry.name), depth: current.depth + 1 });
+      stack.push({ dir: path7.join(current.dir, entry.name), depth: current.depth + 1 });
     }
   }
   return found.sort();
@@ -2407,8 +2473,8 @@ async function runInstall(root, options = {}) {
   }
 }
 async function hasReadyNodeModules(root) {
-  const nodeModules = path6.join(root, "node_modules");
-  return await pathExists4(path6.join(nodeModules, ".modules.yaml")) || await pathExists4(path6.join(nodeModules, ".pnpm"));
+  const nodeModules = path7.join(root, "node_modules");
+  return await pathExists4(path7.join(nodeModules, ".modules.yaml")) || await pathExists4(path7.join(nodeModules, ".pnpm"));
 }
 function hydrationFsApi(overrides = {}) {
   return { ...createPnpmFsApi(pathExists4), ...overrides };
@@ -2445,7 +2511,7 @@ async function ensurePnpmHydration(root, options = {}) {
     expectedHash: hash,
     requireMarker: false
   });
-  if (!health.healthy && await fsApi.pathExists(path6.join(root, "node_modules"))) {
+  if (!health.healthy && await fsApi.pathExists(path7.join(root, "node_modules"))) {
     quarantine = await quarantineCanonicalNodeModules(root, health.issues, {
       fsApi,
       logger: options.logger
@@ -2457,7 +2523,7 @@ async function ensurePnpmHydration(root, options = {}) {
   }
   const linkedWorkspaceDirs = [];
   for (const relativeDir of workspaceDirs) {
-    if (await pathExists4(path6.join(root, relativeDir, "node_modules"))) {
+    if (await pathExists4(path7.join(root, relativeDir, "node_modules"))) {
       linkedWorkspaceDirs.push(relativeDir);
     }
   }
@@ -2493,18 +2559,18 @@ async function linkHydratedNodeModules({ root, worktreeDir, hydration, options =
       yieldEvery: Math.max(1, options.yieldEvery ?? DEFAULT_YIELD_EVERY2)
     }
   };
-  recordOwnedNodeModulesRoot(dependencyOwnership, path6.join(worktreeDir, "node_modules"));
+  recordOwnedNodeModulesRoot(dependencyOwnership, path7.join(worktreeDir, "node_modules"));
   await materializeNodeModulesForest(
-    path6.join(root, "node_modules"),
-    path6.join(worktreeDir, "node_modules"),
+    path7.join(root, "node_modules"),
+    path7.join(worktreeDir, "node_modules"),
     root,
     worktreeDir,
     materializeOptions
   );
   for (const relativeDir of hydration.linkedWorkspaceDirs) {
-    const sourceNodeModules = path6.join(root, relativeDir, "node_modules");
-    const targetNodeModules = path6.join(worktreeDir, relativeDir, "node_modules");
-    if (!await fsApi.pathExists(path6.join(worktreeDir, relativeDir))) continue;
+    const sourceNodeModules = path7.join(root, relativeDir, "node_modules");
+    const targetNodeModules = path7.join(worktreeDir, relativeDir, "node_modules");
+    if (!await fsApi.pathExists(path7.join(worktreeDir, relativeDir))) continue;
     recordOwnedNodeModulesRoot(dependencyOwnership, targetNodeModules);
     await materializeNodeModulesForest(sourceNodeModules, targetNodeModules, root, worktreeDir, materializeOptions);
   }
@@ -2540,67 +2606,6 @@ var init_pnpm_hydration = __esm({
   }
 });
 
-// src/runner/worktree-paths.mjs
-import { createHash as createHash3 } from "node:crypto";
-import fs4 from "node:fs";
-import path7 from "node:path";
-function canonicalPathKey(target, { cache: cache2 = null, realpath: realpath2 = fs4.realpathSync.native } = {}) {
-  const resolved = path7.resolve(String(target || ""));
-  const tail = [];
-  let cursor = resolved;
-  for (; ; ) {
-    let real = cache2 ? cache2.get(cursor) : void 0;
-    if (real === void 0) {
-      try {
-        real = realpath2(cursor);
-      } catch {
-        real = null;
-      }
-      if (cache2) cache2.set(cursor, real);
-    }
-    if (real) {
-      const unprefixed = String(real).replace(/^\\\\\?\\UNC\\/u, "\\\\").replace(/^\\\\\?\\/u, "");
-      const joined = tail.length ? path7.join(unprefixed, ...[...tail].reverse()) : unprefixed;
-      return process.platform === "win32" ? joined.toLowerCase() : joined;
-    }
-    const parent = path7.dirname(cursor);
-    if (parent === cursor) break;
-    tail.push(path7.basename(cursor));
-    cursor = parent;
-  }
-  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
-}
-function samePath2(left, right) {
-  const a = path7.resolve(left);
-  const b = path7.resolve(right);
-  return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
-}
-function worktreePoolForRoot(root, { clonesRootDir = process.env.VO_CODE_RUNNER_CLONES_ROOT || "" } = {}) {
-  const canonicalRoot = path7.resolve(root);
-  if (clonesRootDir) {
-    const clonePool = path7.resolve(clonesRootDir);
-    if (samePath2(path7.dirname(canonicalRoot), clonePool)) {
-      return path7.join(clonePool, ".agent-worktrees", path7.basename(canonicalRoot));
-    }
-  }
-  return path7.join(canonicalRoot, ".agent-worktrees");
-}
-function worktreeDirForName(root, worktreeName, options = {}) {
-  const leaf = createHash3("sha256").update(String(worktreeName)).digest("hex").slice(0, 16);
-  return path7.join(worktreePoolForRoot(root, options), leaf);
-}
-function recoveryLedgerPathForRoot(root, options = {}) {
-  return path7.join(worktreePoolForRoot(root, options), "recovery-ledger.jsonl");
-}
-function legacyRecoveryLedgerPathForRoot(root) {
-  return path7.join(path7.resolve(root), ".agent-worktrees", "recovery-ledger.jsonl");
-}
-var init_worktree_paths = __esm({
-  "src/runner/worktree-paths.mjs"() {
-    "use strict";
-  }
-});
-
 // src/runner/worktree-cleanup.mjs
 import fs5 from "node:fs";
 import fsp6 from "node:fs/promises";
@@ -3057,27 +3062,29 @@ async function fetchExactTaskBase(root, baseSha, options = {}) {
 function shouldIgnoreManagedEntry(entryName) {
   return IGNORED_MANAGED_ENTRIES.has(entryName) || entryName.endsWith(".lock") || entryName.startsWith("runner-");
 }
-async function registeredWorktreeDirs(root, options = {}) {
+async function registeredWorktreeKeys(root, cache2, options = {}) {
   const listed = await git(root, ["worktree", "list", "--porcelain"], options);
   if (listed.status !== 0) {
     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) => path9.resolve(line.slice("worktree ".length).trim()))
+    String(listed.stdout || "").split(/\r?\n/u).filter((line) => line.startsWith("worktree ")).map((line) => canonicalPathKey(line.slice("worktree ".length).trim(), { cache: cache2 }))
   );
 }
 async function reportLegacyResiduals(root, options = {}) {
   const managedRoot = path9.join(root, ".agent-worktrees");
   if (!fs6.existsSync(managedRoot)) return [];
-  const registered = await registeredWorktreeDirs(root, options);
-  const pending = pendingCleanupDirs();
+  const cache2 = /* @__PURE__ */ new Map();
+  const registered = await registeredWorktreeKeys(root, cache2, options);
+  const pending = new Set([...pendingCleanupDirs()].map((dir) => canonicalPathKey(dir, { cache: cache2 })));
   const found = [];
   for (const entry of fs6.readdirSync(managedRoot, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
     if (shouldIgnoreManagedEntry(entry.name)) continue;
     const absolute = path9.resolve(path9.join(managedRoot, entry.name));
-    if (registered.has(absolute)) continue;
-    if (pending.has(absolute)) continue;
+    const key = canonicalPathKey(absolute, { cache: cache2 });
+    if (registered.has(key)) continue;
+    if (pending.has(key)) continue;
     found.push(absolute);
   }
   if (found.length === 0) return [];
@@ -3114,6 +3121,7 @@ var init_task_root_prepare = __esm({
     init_pnpm_command();
     init_process_runner();
     init_worktree_cleanup();
+    init_worktree_paths();
     PREP_LOCK_WAIT_MS = 20 * 60 * 1e3;
     PREP_LOCK_STALE_MS = 45 * 60 * 1e3;
     REPORTED_RESIDUAL_SNAPSHOTS = /* @__PURE__ */ new Set();