@h-rig/runtime 0.0.6-alpha.34 → 0.0.6-alpha.36

package/dist/src/control-plane/runtime/queue.js

@@ -149,32 +149,32 @@ var RIG_DEFINITION_DIRNAME = "rig", RIG_ARTIFACTS_DIRNAME = "artifacts";
 var init_layout = () => {};
 
 // packages/runtime/src/control-plane/runtime/sandbox/utils.ts
-import { existsSync as existsSync21, readdirSync as readdirSync4, realpathSync } from "fs";
-import { resolve as resolve22 } from "path";
+import { existsSync as existsSync23, readdirSync as readdirSync4, realpathSync } from "fs";
+import { resolve as resolve23 } from "path";
 function toRealPath(path) {
-  if (!existsSync21(path)) {
-    return resolve22(path);
+  if (!existsSync23(path)) {
+    return resolve23(path);
   }
   try {
     return realpathSync.native(path);
   } catch {
-    return resolve22(path);
+    return resolve23(path);
   }
 }
 function resolveHostGitMetadataPaths(projectRoot, workspaceDir) {
   const candidates = new Set;
   const addPath = (candidate) => {
-    if (existsSync21(candidate)) {
+    if (existsSync23(candidate)) {
       candidates.add(toRealPath(candidate));
     }
   };
-  addPath(resolve22(projectRoot, ".git"));
-  addPath(resolve22(workspaceDir, "..", "..", ".git"));
+  addPath(resolve23(projectRoot, ".git"));
+  addPath(resolve23(workspaceDir, "..", "..", ".git"));
   for (const repoRoot of resolveHostRepoRootPaths(projectRoot)) {
-    addPath(resolve22(repoRoot, ".git"));
+    addPath(resolve23(repoRoot, ".git"));
   }
-  const workspaceGit = resolve22(workspaceDir, ".git");
-  if (existsSync21(workspaceGit)) {
+  const workspaceGit = resolve23(workspaceDir, ".git");
+  if (existsSync23(workspaceGit)) {
     addPath(workspaceGit);
   }
   return [...candidates];
@@ -182,7 +182,7 @@ function resolveHostGitMetadataPaths(projectRoot, workspaceDir) {
 function resolveHostRepoRootPaths(projectRoot) {
   const candidates = new Set;
   const addPath = (candidate) => {
-    if (existsSync21(candidate)) {
+    if (existsSync23(candidate)) {
       candidates.add(toRealPath(candidate));
     }
   };
@@ -192,11 +192,11 @@ function resolveHostRepoRootPaths(projectRoot) {
       addPath(monorepoRoot);
     }
   } catch {}
-  const reposDir = resolve22(projectRoot, "repos");
-  if (existsSync21(reposDir)) {
+  const reposDir = resolve23(projectRoot, "repos");
+  if (existsSync23(reposDir)) {
     for (const entry of readdirSync4(reposDir, { withFileTypes: true })) {
       if (entry.isDirectory() || entry.isSymbolicLink()) {
-        addPath(resolve22(reposDir, entry.name));
+        addPath(resolve23(reposDir, entry.name));
       }
     }
   }
@@ -240,8 +240,8 @@ var exports_backend_seatbelt = {};
 __export(exports_backend_seatbelt, {
   SeatbeltBackend: () => SeatbeltBackend
 });
-import { mkdirSync as mkdirSync17, writeFileSync as writeFileSync12 } from "fs";
-import { resolve as resolve33 } from "path";
+import { mkdirSync as mkdirSync18, writeFileSync as writeFileSync13 } from "fs";
+import { resolve as resolve34 } from "path";
 
 class SeatbeltBackend {
   kind = "macos-seatbelt";
@@ -265,11 +265,11 @@ class SeatbeltBackend {
     };
   }
   writeSeatbeltProfile(options) {
-    const sandboxDir = resolve33(options.runtime.rootDir, "sandbox");
-    mkdirSync17(sandboxDir, { recursive: true });
-    const profilePath = resolve33(sandboxDir, "seatbelt.sb");
+    const sandboxDir = resolve34(options.runtime.rootDir, "sandbox");
+    mkdirSync18(sandboxDir, { recursive: true });
+    const profilePath = resolve34(sandboxDir, "seatbelt.sb");
     const profile = this.renderProfile(options);
-    writeFileSync12(profilePath, `${profile}
+    writeFileSync13(profilePath, `${profile}
 `, "utf-8");
     return profilePath;
   }
@@ -354,7 +354,7 @@ class SeatbeltBackend {
     const realHome = process.env.HOME?.trim();
     if (realHome) {
       for (const binSubdir of [".local/bin", ".cargo/bin"]) {
-        const binPath = resolve33(realHome, binSubdir);
+        const binPath = resolve34(realHome, binSubdir);
         if (ctx.pathExists(binPath)) {
           lines.push(`(allow file-read* (subpath ${seatbeltString(ctx.realPath(binPath))}))`);
         }
@@ -383,8 +383,8 @@ var exports_backend_bwrap = {};
 __export(exports_backend_bwrap, {
   BwrapBackend: () => BwrapBackend
 });
-import { mkdirSync as mkdirSync18 } from "fs";
-import { resolve as resolve34 } from "path";
+import { mkdirSync as mkdirSync19 } from "fs";
+import { resolve as resolve35 } from "path";
 
 class BwrapBackend {
   kind = "linux-bwrap";
@@ -513,18 +513,18 @@ class BwrapBackend {
     const realHome = process.env.HOME?.trim();
     if (realHome) {
       for (const binSubdir of [".local/bin", ".local/lib", ".cargo/bin"]) {
-        const binPath = ctx.realPath(resolve34(realHome, binSubdir));
+        const binPath = ctx.realPath(resolve35(realHome, binSubdir));
         if (ctx.pathExists(binPath)) {
           args.push("--ro-bind", binPath, binPath);
         }
       }
-      const agentSshDir = resolve34(homeReal, ".ssh");
+      const agentSshDir = resolve35(homeReal, ".ssh");
       if (ctx.pathExists(agentSshDir)) {
         args.push("--ro-bind", agentSshDir, agentSshDir);
       } else {
-        const hostSshDir = resolve34(realHome, ".ssh");
+        const hostSshDir = resolve35(realHome, ".ssh");
         if (ctx.pathExists(hostSshDir)) {
-          mkdirSync18(agentSshDir, { recursive: true });
+          mkdirSync19(agentSshDir, { recursive: true });
           args.push("--ro-bind", hostSshDir, agentSshDir);
           args.push("--ro-bind", hostSshDir, hostSshDir);
         }
@@ -567,8 +567,8 @@ var init_backend_bwrap = __esm(() => {
 
 // packages/runtime/src/control-plane/runtime/queue.ts
 init_layout();
-import { existsSync as existsSync34 } from "fs";
-import { resolve as resolve37 } from "path";
+import { existsSync as existsSync36 } from "fs";
+import { resolve as resolve38 } from "path";
 
 // packages/runtime/src/control-plane/native/task-state.ts
 import { existsSync as existsSync9, readFileSync as readFileSync5, readdirSync, statSync as statSync2, writeFileSync as writeFileSync3 } from "fs";
@@ -3029,9 +3029,9 @@ function primeGuardHotPaths() {
 }
 primeGuardHotPaths();
 // packages/runtime/src/control-plane/runtime/isolation/index.ts
-import { existsSync as existsSync33, mkdirSync as mkdirSync19, readFileSync as readFileSync16, rmSync as rmSync13 } from "fs";
+import { existsSync as existsSync35, mkdirSync as mkdirSync20, readFileSync as readFileSync17, rmSync as rmSync13 } from "fs";
 import { copyFile, mkdir as mkdir4, writeFile as writeFile2 } from "fs/promises";
-import { resolve as resolve36 } from "path";
+import { resolve as resolve37 } from "path";
 // packages/runtime/src/control-plane/memory-sync/db.ts
 import { Database } from "bun:sqlite";
 import { mkdirSync as mkdirSync4 } from "fs";
@@ -3319,8 +3319,8 @@ async function readCanonicalMemoryDb(projectRoot, deps = {}) {
 var DEFAULT_RESULT_LIMIT = DEFAULT_RUNTIME_MEMORY_RETRIEVAL.topK;
 var DAY_MS = 24 * 60 * 60 * 1000;
 // packages/runtime/src/control-plane/native/task-ops.ts
-import { appendFileSync, existsSync as existsSync24, mkdirSync as mkdirSync10, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "fs";
-import { resolve as resolve26 } from "path";
+import { appendFileSync, existsSync as existsSync26, mkdirSync as mkdirSync11, readFileSync as readFileSync13, writeFileSync as writeFileSync10 } from "fs";
+import { resolve as resolve27 } from "path";
 
 // packages/runtime/src/build-time-config.ts
 function normalizeBuildConfig(value) {
@@ -3884,6 +3884,8 @@ function buildBrowserGuidanceLines(browser) {
 }
 
 // packages/runtime/src/control-plane/plugin-host-context.ts
+import { existsSync as existsSync19 } from "fs";
+import { resolve as resolvePath } from "path";
 import { createPluginHost } from "@rig/core";
 import { loadConfig } from "@rig/core/load-config";
 
@@ -4165,6 +4167,55 @@ async function materializeSkills(projectRoot, entries) {
   return written;
 }
 
+// packages/runtime/src/control-plane/pi-settings-materializer.ts
+import { existsSync as existsSync18, mkdirSync as mkdirSync9, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
+import { dirname as dirname11, resolve as resolve19 } from "path";
+var SETTINGS_RELATIVE_PATH = ".pi/settings.json";
+var MANAGED_RECORD_RELATIVE_PATH = ".rig/state/pi-managed-packages.json";
+function readJson(path, fallback) {
+  if (!existsSync18(path))
+    return fallback;
+  try {
+    return JSON.parse(readFileSync9(path, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function packageKey(entry) {
+  if (typeof entry === "string")
+    return entry;
+  if (entry && typeof entry === "object" && typeof entry.source === "string") {
+    return entry.source;
+  }
+  return JSON.stringify(entry);
+}
+function materializePiPackages(projectRoot, declaredPackages) {
+  const settingsPath = resolve19(projectRoot, SETTINGS_RELATIVE_PATH);
+  const managedRecordPath = resolve19(projectRoot, MANAGED_RECORD_RELATIVE_PATH);
+  const settings = readJson(settingsPath, {});
+  const previouslyManaged = new Set(readJson(managedRecordPath, []));
+  const existing = Array.isArray(settings.packages) ? settings.packages : [];
+  const operatorEntries = existing.filter((entry) => !previouslyManaged.has(packageKey(entry)));
+  const operatorKeys = new Set(operatorEntries.map(packageKey));
+  const managedToAdd = declaredPackages.filter((pkg) => !operatorKeys.has(pkg));
+  const nextPackages = [...operatorEntries, ...managedToAdd];
+  if (nextPackages.length > 0 || existsSync18(settingsPath)) {
+    const nextSettings = { ...settings };
+    if (nextPackages.length > 0) {
+      nextSettings.packages = nextPackages;
+    } else {
+      delete nextSettings.packages;
+    }
+    mkdirSync9(dirname11(settingsPath), { recursive: true });
+    writeFileSync7(settingsPath, `${JSON.stringify(nextSettings, null, 2)}
+`, "utf-8");
+  }
+  mkdirSync9(dirname11(managedRecordPath), { recursive: true });
+  writeFileSync7(managedRecordPath, `${JSON.stringify(managedToAdd, null, 2)}
+`, "utf-8");
+  return { settingsPath, packages: managedToAdd };
+}
+
 // packages/runtime/src/control-plane/plugin-host-context.ts
 async function buildPluginHostContext(projectRoot) {
   let config;
@@ -4212,6 +4263,14 @@ async function buildPluginHostContext(projectRoot) {
   } catch (err) {
     console.warn(`[plugin-host] skill materialization failed: ${err instanceof Error ? err.message : err}`);
   }
+  try {
+    const piPackages = config.runtime?.pi?.packages ?? [];
+    if (piPackages.length > 0 || existsSync19(resolvePath(projectRoot, ".rig/state/pi-managed-packages.json"))) {
+      materializePiPackages(projectRoot, piPackages);
+    }
+  } catch (err) {
+    console.warn(`[plugin-host] Pi package materialization failed: ${err instanceof Error ? err.message : err}`);
+  }
   return {
     config,
     pluginHost,
@@ -4225,12 +4284,12 @@ async function buildPluginHostContext(projectRoot) {
 
 // packages/runtime/src/control-plane/tasks/source-aware-task-config-source.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync19, readFileSync as readFileSync10, readdirSync as readdirSync3, statSync as statSync5, writeFileSync as writeFileSync7 } from "fs";
-import { basename as basename6, join as join4, resolve as resolve20 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync11, readdirSync as readdirSync3, statSync as statSync5, writeFileSync as writeFileSync8 } from "fs";
+import { basename as basename6, join as join4, resolve as resolve21 } from "path";
 
 // packages/runtime/src/control-plane/tasks/legacy-task-config-source.ts
-import { existsSync as existsSync18, readFileSync as readFileSync9 } from "fs";
-import { resolve as resolve19 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync10 } from "fs";
+import { resolve as resolve20 } from "path";
 
 // packages/runtime/src/control-plane/tasks/task-record-reader.ts
 async function findTaskById(reader, id) {
@@ -4253,7 +4312,7 @@ class LegacyTaskConfigReadError extends Error {
   }
 }
 function createLegacyTaskConfigRecordReader(projectRoot, options = {}) {
-  const configPath = options.configPath ?? resolve19(projectRoot, ".rig", "task-config.json");
+  const configPath = options.configPath ?? resolve20(projectRoot, ".rig", "task-config.json");
   const reader = {
     async listTasks() {
       return readLegacyTaskRecords(projectRoot, configPath);
@@ -4264,8 +4323,8 @@ function createLegacyTaskConfigRecordReader(projectRoot, options = {}) {
   };
   return reader;
 }
-function readLegacyTaskRecords(projectRoot, configPath = resolve19(projectRoot, ".rig", "task-config.json")) {
-  if (!existsSync18(configPath)) {
+function readLegacyTaskRecords(projectRoot, configPath = resolve20(projectRoot, ".rig", "task-config.json")) {
+  if (!existsSync20(configPath)) {
     return [];
   }
   const rawConfig = readLegacyTaskConfigJson(projectRoot, configPath);
@@ -4273,7 +4332,7 @@ function readLegacyTaskRecords(projectRoot, configPath = resolve19(projectRoot,
 }
 function readLegacyTaskConfigJson(projectRoot, configPath) {
   try {
-    const parsed = JSON.parse(readFileSync9(configPath, "utf8"));
+    const parsed = JSON.parse(readFileSync10(configPath, "utf8"));
     if (isPlainRecord(parsed)) {
       return parsed;
     }
@@ -4357,7 +4416,7 @@ function isPlainRecord(candidate) {
 var STATUS_LABELS = new Set(["ready", "blocked", "in-progress", "under-review", "failed", "cancelled"]);
 var FILE_TASK_PATTERN2 = /\.(task\.)?json$/;
 function createSourceAwareTaskConfigRecordReader(projectRoot, options = {}) {
-  const configPath = options.configPath ?? resolve20(projectRoot, ".rig", "task-config.json");
+  const configPath = options.configPath ?? resolve21(projectRoot, ".rig", "task-config.json");
   const legacy = createLegacyTaskConfigRecordReader(projectRoot, { configPath });
   const spawnFn = options.spawn ?? spawnSync;
   const ghBinary = options.ghBinary ?? "gh";
@@ -4440,10 +4499,10 @@ function readMaterializedTaskMetadata(entry) {
   return metadata;
 }
 function readConfiguredFilesTaskSourcePath2(projectRoot) {
-  const jsonPath = resolve20(projectRoot, "rig.config.json");
-  if (existsSync19(jsonPath)) {
+  const jsonPath = resolve21(projectRoot, "rig.config.json");
+  if (existsSync21(jsonPath)) {
     try {
-      const parsed = JSON.parse(readFileSync10(jsonPath, "utf8"));
+      const parsed = JSON.parse(readFileSync11(jsonPath, "utf8"));
       if (isPlainRecord2(parsed) && isPlainRecord2(parsed.taskSource)) {
         const source = parsed.taskSource;
         return source.kind === "files" && typeof source.path === "string" ? source.path : null;
@@ -4452,12 +4511,12 @@ function readConfiguredFilesTaskSourcePath2(projectRoot) {
       return null;
     }
   }
-  const tsPath = resolve20(projectRoot, "rig.config.ts");
-  if (!existsSync19(tsPath)) {
+  const tsPath = resolve21(projectRoot, "rig.config.ts");
+  if (!existsSync21(tsPath)) {
     return null;
   }
   try {
-    const source = readFileSync10(tsPath, "utf8");
+    const source = readFileSync11(tsPath, "utf8");
     const taskSourceBlock = source.match(/taskSource\s*:\s*\{[\s\S]*?\}/m)?.[0] ?? "";
     const kind = taskSourceBlock.match(/kind\s*:\s*["']([^"']+)["']/)?.[1];
     if (kind !== "files") {
@@ -4477,10 +4536,10 @@ function readRawTaskEntry(configPath, taskId) {
   return isPlainRecord2(entry) ? entry : null;
 }
 function readRawTaskConfig(configPath) {
-  if (!existsSync19(configPath)) {
+  if (!existsSync21(configPath)) {
     return null;
   }
-  const parsed = JSON.parse(readFileSync10(configPath, "utf8"));
+  const parsed = JSON.parse(readFileSync11(configPath, "utf8"));
   return isPlainRecord2(parsed) ? parsed : null;
 }
 function stripLegacyTaskConfigMetadata2(raw) {
@@ -4488,8 +4547,8 @@ function stripLegacyTaskConfigMetadata2(raw) {
   return tasks;
 }
 function listFileBackedTasks(projectRoot, sourcePath) {
-  const directory = resolve20(projectRoot, sourcePath);
-  if (!existsSync19(directory)) {
+  const directory = resolve21(projectRoot, sourcePath);
+  if (!existsSync21(directory)) {
     return [];
   }
   const tasks = [];
@@ -4504,11 +4563,11 @@ function listFileBackedTasks(projectRoot, sourcePath) {
   return tasks;
 }
 function readFileBackedTask(projectRoot, sourcePath, taskId, rawEntry) {
-  const file = findFileBackedTaskFile(resolve20(projectRoot, sourcePath), taskId);
+  const file = findFileBackedTaskFile(resolve21(projectRoot, sourcePath), taskId);
   if (!file) {
     return null;
   }
-  const raw = JSON.parse(readFileSync10(file, "utf8"));
+  const raw = JSON.parse(readFileSync11(file, "utf8"));
   if (!isPlainRecord2(raw)) {
     return null;
   }
@@ -4521,7 +4580,7 @@ function readFileBackedTask(projectRoot, sourcePath, taskId, rawEntry) {
   };
 }
 function findFileBackedTaskFile(directory, taskId) {
-  if (!existsSync19(directory)) {
+  if (!existsSync21(directory)) {
     return null;
   }
   for (const name of readdirSync3(directory)) {
@@ -4531,7 +4590,7 @@ function findFileBackedTaskFile(directory, taskId) {
     try {
       if (!statSync5(file).isFile())
         continue;
-      const raw = JSON.parse(readFileSync10(file, "utf8"));
+      const raw = JSON.parse(readFileSync11(file, "utf8"));
       const inferredId = basename6(file).replace(FILE_TASK_PATTERN2, "");
       const id = isPlainRecord2(raw) && typeof raw.id === "string" ? raw.id : inferredId;
       if (id === taskId) {
@@ -4695,8 +4754,8 @@ init_layout();
 
 // packages/runtime/src/binary-run.ts
 init_layout();
-import { chmodSync as chmodSync4, cpSync, existsSync as existsSync20, mkdirSync as mkdirSync9, renameSync as renameSync3, rmSync as rmSync8, writeFileSync as writeFileSync8 } from "fs";
-import { basename as basename7, dirname as dirname11, resolve as resolve21 } from "path";
+import { chmodSync as chmodSync4, cpSync, existsSync as existsSync22, mkdirSync as mkdirSync10, renameSync as renameSync3, rmSync as rmSync8, writeFileSync as writeFileSync9 } from "fs";
+import { basename as basename7, dirname as dirname12, resolve as resolve22 } from "path";
 import { fileURLToPath } from "url";
 import { drainMicrotasks, gcAndSweep } from "bun:jsc";
 var runtimeBinaryBuildQueue = Promise.resolve();
@@ -4722,9 +4781,9 @@ async function buildRuntimeBinary(options) {
   });
 }
 async function buildRuntimeBinaryInProcess(options, manifest) {
-  const tempBuildDir = resolve21(dirname11(options.outputPath), `.bun-build-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-  const tempOutputPath = resolve21(tempBuildDir, basename7(options.outputPath));
-  mkdirSync9(tempBuildDir, { recursive: true });
+  const tempBuildDir = resolve22(dirname12(options.outputPath), `.bun-build-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  const tempOutputPath = resolve22(tempBuildDir, basename7(options.outputPath));
+  mkdirSync10(tempBuildDir, { recursive: true });
   await withTemporaryEnv({
     ...options.env,
     ...options.define ? { RIG_BUILD_CONFIG_JSON: JSON.stringify(options.define) } : {}
@@ -4749,7 +4808,7 @@ async function buildRuntimeBinaryInProcess(options, manifest) {
 `);
       throw new Error(`Failed to build ${options.entrypoint}: ${details || "Bun.build() returned errors"}`);
     }
-    if (!existsSync20(tempOutputPath)) {
+    if (!existsSync22(tempOutputPath)) {
       const emitted = buildResult.outputs.map((output) => output.path).join(", ") || "(none)";
       throw new Error(`Failed to build ${options.entrypoint}: Bun.build() did not emit ${tempOutputPath}. Emitted: ${emitted}`);
     }
@@ -4781,8 +4840,8 @@ function runtimeBinaryCacheManifestPath(outputPath) {
 function resolveRuntimeBinaryBuildOptions(options) {
   return {
     ...options,
-    entrypoint: resolve21(options.cwd, options.sourcePath),
-    outputPath: resolve21(options.outputPath)
+    entrypoint: resolve22(options.cwd, options.sourcePath),
+    outputPath: resolve22(options.outputPath)
   };
 }
 function shouldUseRuntimeBinaryBuildWorker() {
@@ -4796,7 +4855,7 @@ function shouldUseRuntimeBinaryBuildWorker() {
 }
 async function buildRuntimeBinaryViaWorker(options) {
   const workerSourcePath = resolveRuntimeBinaryBuildWorkerSourcePath(options);
-  if (!workerSourcePath || !existsSync20(workerSourcePath)) {
+  if (!workerSourcePath || !existsSync22(workerSourcePath)) {
     await buildRuntimeBinaryInProcess(options, {
       manifestPath: runtimeBinaryCacheManifestPath(options.outputPath),
       buildKey: createRuntimeBinaryBuildKey({
@@ -4833,7 +4892,7 @@ async function buildRuntimeBinaryViaWorker(options) {
   }
 }
 function createRuntimeBinaryBuildWorkerPayloadPath(outputPath) {
-  return resolve21(dirname11(outputPath), `.bun-build-worker-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.json`);
+  return resolve22(dirname12(outputPath), `.bun-build-worker-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.json`);
 }
 function resolveRuntimeBinaryBuildWorkerSourcePath(options) {
   const envRoots = [
@@ -4842,13 +4901,13 @@ function resolveRuntimeBinaryBuildWorkerSourcePath(options) {
     process.env.PROJECT_RIG_ROOT?.trim()
   ].filter(Boolean);
   for (const root of envRoots) {
-    const candidate = resolve21(root, "packages/runtime/src/binary-build-worker.ts");
-    if (existsSync20(candidate)) {
+    const candidate = resolve22(root, "packages/runtime/src/binary-build-worker.ts");
+    if (existsSync22(candidate)) {
       return candidate;
     }
   }
-  const localCandidate = resolve21(import.meta.dir, "binary-build-worker.ts");
-  return existsSync20(localCandidate) ? localCandidate : null;
+  const localCandidate = resolve22(import.meta.dir, "binary-build-worker.ts");
+  return existsSync22(localCandidate) ? localCandidate : null;
 }
 function resolveRuntimeBinaryBuildWorkerInvocation() {
   const bunPath = Bun.which("bun");
@@ -4884,7 +4943,7 @@ function createRuntimeBinaryBuildKey(input) {
   });
 }
 async function isRuntimeBinaryBuildFresh(input) {
-  if (!existsSync20(input.outputPath) || !existsSync20(input.manifestPath)) {
+  if (!existsSync22(input.outputPath) || !existsSync22(input.manifestPath)) {
     return false;
   }
   let manifest = null;
@@ -4897,7 +4956,7 @@ async function isRuntimeBinaryBuildFresh(input) {
     return false;
   }
   for (const [filePath, expectedDigest] of Object.entries(manifest.inputs || {})) {
-    if (!existsSync20(filePath)) {
+    if (!existsSync22(filePath)) {
       return false;
     }
     if (await sha256File4(filePath) !== expectedDigest) {
@@ -4910,7 +4969,7 @@ async function writeRuntimeBinaryCacheManifest(input) {
   const inputs = {};
   for (const inputPath of Object.keys(input.metafile?.inputs || {}).sort()) {
     const normalized = normalizeBuildInputPath(input.cwd, inputPath);
-    if (!normalized || !existsSync20(normalized)) {
+    if (!normalized || !existsSync22(normalized)) {
       continue;
     }
     inputs[normalized] = await sha256File4(normalized);
@@ -4933,7 +4992,7 @@ function normalizeBuildInputPath(cwd, inputPath) {
   if (inputPath.startsWith("<")) {
     return null;
   }
-  return resolve21(cwd, inputPath);
+  return resolve22(cwd, inputPath);
 }
 async function sha256File4(path) {
   const hasher = new Bun.CryptoHasher("sha256");
@@ -4949,8 +5008,8 @@ function sortRecord(value) {
 async function runSerializedRuntimeBinaryBuild(action) {
   const previous = runtimeBinaryBuildQueue;
   let release;
-  runtimeBinaryBuildQueue = new Promise((resolve22) => {
-    release = resolve22;
+  runtimeBinaryBuildQueue = new Promise((resolve23) => {
+    release = resolve23;
   });
   await previous;
   try {
@@ -4995,11 +5054,11 @@ async function withTemporaryCwd(cwd, action) {
 }
 
 // packages/runtime/src/control-plane/runtime/provisioning-env.ts
-import { delimiter, resolve as resolve24 } from "path";
+import { delimiter, resolve as resolve25 } from "path";
 
 // packages/runtime/src/control-plane/runtime/runtime-paths.ts
-import { existsSync as existsSync22, readdirSync as readdirSync5, realpathSync as realpathSync2 } from "fs";
-import { resolve as resolve23 } from "path";
+import { existsSync as existsSync24, readdirSync as readdirSync5, realpathSync as realpathSync2 } from "fs";
+import { resolve as resolve24 } from "path";
 
 // packages/runtime/src/control-plane/runtime/sandbox-utils.ts
 init_utils();
@@ -5016,7 +5075,7 @@ function resolveBunBinaryPath() {
   }
   const home = process.env.HOME?.trim();
   const fallbackCandidates = [
-    home ? resolve23(home, ".bun/bin/bun") : "",
+    home ? resolve24(home, ".bun/bin/bun") : "",
     "/opt/homebrew/bin/bun",
     "/usr/local/bin/bun",
     "/usr/bin/bun"
@@ -5044,8 +5103,8 @@ function resolveClaudeBinaryPath() {
   }
   const home = process.env.HOME?.trim();
   const fallbackCandidates = [
-    home ? resolve23(home, ".local/bin/claude") : "",
-    home ? resolve23(home, ".local/share/claude/local/claude") : "",
+    home ? resolve24(home, ".local/bin/claude") : "",
+    home ? resolve24(home, ".local/share/claude/local/claude") : "",
     "/opt/homebrew/bin/claude",
     "/usr/local/bin/claude",
     "/usr/bin/claude"
@@ -5059,35 +5118,35 @@ function resolveClaudeBinaryPath() {
   throw new Error("claude not found in PATH");
 }
 function resolveBunInstallDir(bunBinaryPath = resolveBunBinaryPath()) {
-  return resolve23(bunBinaryPath, "../..");
+  return resolve24(bunBinaryPath, "../..");
 }
 function resolveClaudeInstallDir() {
   const realPath = resolveClaudeBinaryPath();
-  return resolve23(realPath, "..");
+  return resolve24(realPath, "..");
 }
 function resolveNodeInstallDir() {
   const preferredNode = resolvePreferredNodeBinary();
   if (!preferredNode)
     return null;
   const explicitNode = process.env.RIG_NODE_BIN?.trim();
-  if (explicitNode && resolve23(explicitNode) === resolve23(preferredNode)) {
-    return preferredNode.endsWith("/bin/node") ? resolve23(preferredNode, "../..") : resolve23(preferredNode, "..");
+  if (explicitNode && resolve24(explicitNode) === resolve24(preferredNode)) {
+    return preferredNode.endsWith("/bin/node") ? resolve24(preferredNode, "../..") : resolve24(preferredNode, "..");
   }
   try {
     const realPath = realpathSync2(preferredNode);
     if (realPath.endsWith("/bin/node")) {
-      return resolve23(realPath, "../..");
+      return resolve24(realPath, "../..");
     }
-    return resolve23(realPath, "..");
+    return resolve24(realPath, "..");
   } catch {
-    return resolve23(preferredNode, "..");
+    return resolve24(preferredNode, "..");
   }
 }
 function resolveRuntimeDependencyRoots(runtimeDirs) {
   const roots = [];
   if (process.platform === "darwin") {
     for (const macPath of ["/opt/homebrew", "/opt/homebrew/opt"]) {
-      if (existsSync22(macPath)) {
+      if (existsSync24(macPath)) {
         roots.push(macPath);
       }
     }
@@ -5105,23 +5164,23 @@ function resolvePreferredNodeBinary() {
   const candidates = [];
   const envNode = process.env.RIG_NODE_BIN?.trim();
   if (envNode) {
-    const explicit = resolve23(envNode);
-    if (existsSync22(explicit)) {
+    const explicit = resolve24(envNode);
+    if (existsSync24(explicit)) {
       return explicit;
     }
   }
   const nvmBin = process.env.NVM_BIN?.trim();
   if (nvmBin) {
-    candidates.push(resolve23(nvmBin, "node"));
+    candidates.push(resolve24(nvmBin, "node"));
   }
   const home = process.env.HOME?.trim();
   if (home) {
-    const nvmVersionsDir = resolve23(home, ".nvm/versions/node");
-    if (existsSync22(nvmVersionsDir)) {
+    const nvmVersionsDir = resolve24(home, ".nvm/versions/node");
+    if (existsSync24(nvmVersionsDir)) {
       try {
         const versionDirs = readdirSync5(nvmVersionsDir).map((entry) => entry.trim()).filter((entry) => /^v\d+\.\d+\.\d+$/.test(entry)).sort((a, b) => Bun.semver.order(b.replace(/^v/, ""), a.replace(/^v/, "")));
         for (const versionDir of versionDirs) {
-          candidates.push(resolve23(nvmVersionsDir, versionDir, "bin/node"));
+          candidates.push(resolve24(nvmVersionsDir, versionDir, "bin/node"));
         }
       } catch {}
     }
@@ -5130,8 +5189,8 @@ function resolvePreferredNodeBinary() {
   if (whichNode) {
     candidates.push(whichNode);
   }
-  const deduped = uniq(candidates.map((candidate) => resolve23(candidate)));
-  const existing = deduped.filter((candidate) => existsSync22(candidate));
+  const deduped = uniq(candidates.map((candidate) => resolve24(candidate)));
+  const existing = deduped.filter((candidate) => existsSync24(candidate));
   if (existing.length === 0) {
     return null;
   }
@@ -5145,7 +5204,7 @@ function resolvePreferredNodeBinary() {
   return existing[0] ?? null;
 }
 function inferNodeMajor(nodeBinaryPath) {
-  const normalized = resolve23(nodeBinaryPath).replace(/\\/g, "/");
+  const normalized = resolve24(nodeBinaryPath).replace(/\\/g, "/");
   const match = normalized.match(/(?:^|\/)(?:node-)?v?(\d+)\.\d+\.\d+(?:\/|$)/);
   if (!match) {
     return null;
@@ -5157,8 +5216,8 @@ function normalizeExecutablePath(candidate) {
   if (!candidate) {
     return "";
   }
-  const normalized = resolve23(candidate);
-  if (!existsSync22(normalized)) {
+  const normalized = resolve24(candidate);
+  if (!existsSync24(normalized)) {
     return "";
   }
   try {
@@ -5168,7 +5227,7 @@ function normalizeExecutablePath(candidate) {
   }
 }
 function looksLikeRuntimeGateway(candidate) {
-  const normalized = resolve23(candidate).replace(/\\/g, "/");
+  const normalized = resolve24(candidate).replace(/\\/g, "/");
   return normalized.includes("/.rig/bin/") || normalized.endsWith("/rig-shell") || normalized.endsWith("/rig-agent");
 }
 
@@ -5189,7 +5248,7 @@ function runtimeProvisioningEnv(baseEnv = process.env) {
     try {
       return resolveClaudeInstallDir();
     } catch {
-      return resolve24(claudeBinary, "..");
+      return resolve25(claudeBinary, "..");
     }
   })() : "";
   const nodeDir = resolveNodeInstallDir();
@@ -5199,8 +5258,8 @@ function runtimeProvisioningEnv(baseEnv = process.env) {
     `${bunDir}/bin`,
     claudeDir,
     nodeDir ? `${nodeDir}/bin` : "",
-    realHome ? resolve24(realHome, ".local/bin") : "",
-    realHome ? resolve24(realHome, ".cargo/bin") : "",
+    realHome ? resolve25(realHome, ".local/bin") : "",
+    realHome ? resolve25(realHome, ".cargo/bin") : "",
     ...inheritedPath,
     "/usr/local/bin",
     "/usr/local/sbin",
@@ -5229,8 +5288,8 @@ function runtimeProvisioningEnv(baseEnv = process.env) {
 }
 
 // packages/runtime/src/control-plane/runtime/baked-secrets.ts
-import { existsSync as existsSync23, readFileSync as readFileSync11 } from "fs";
-import { resolve as resolve25 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync12 } from "fs";
+import { resolve as resolve26 } from "path";
 var BAKED_RUNTIME_SECRETS = {
   ANTHROPIC_API_KEY: typeof RIG_BAKED_ANTHROPIC_API_KEY !== "undefined" ? RIG_BAKED_ANTHROPIC_API_KEY : "",
   OPENAI_API_KEY: typeof RIG_BAKED_OPENAI_API_KEY !== "undefined" ? RIG_BAKED_OPENAI_API_KEY : "",
@@ -5273,12 +5332,12 @@ function resolveRuntimeSecrets(env, baked = BAKED_RUNTIME_SECRETS) {
   return resolved;
 }
 function loadDotEnvSecrets(projectRoot, env = process.env) {
-  const dotenvPath = resolve25(projectRoot, ".env");
-  if (!existsSync23(dotenvPath)) {
+  const dotenvPath = resolve26(projectRoot, ".env");
+  if (!existsSync25(dotenvPath)) {
     return {};
   }
   const parsed = {};
-  const lines = readFileSync11(dotenvPath, "utf-8").split(/\r?\n/);
+  const lines = readFileSync12(dotenvPath, "utf-8").split(/\r?\n/);
   for (const rawLine of lines) {
     const line = rawLine.trim();
     if (!line || line.startsWith("#")) {
@@ -5635,16 +5694,16 @@ async function taskDeps(projectRoot, taskId) {
   for (const dep of deps) {
     const artifactDir = artifactDirForId(projectRoot, dep);
     console.log(`=== ${dep} ===`);
-    if (!existsSync24(artifactDir)) {
+    if (!existsSync26(artifactDir)) {
       console.log(`  (no artifacts yet)
 `);
       continue;
     }
-    printArtifactSection(resolve26(artifactDir, "decision-log.md"), "--- Decisions ---");
-    printArtifactSection(resolve26(artifactDir, "next-actions.md"), "--- Next Actions (for you) ---");
-    const changedFiles = resolve26(artifactDir, "changed-files.txt");
-    if (existsSync24(changedFiles)) {
-      const lines = readFileSync12(changedFiles, "utf-8").split(/\r?\n/).filter(Boolean);
+    printArtifactSection(resolve27(artifactDir, "decision-log.md"), "--- Decisions ---");
+    printArtifactSection(resolve27(artifactDir, "next-actions.md"), "--- Next Actions (for you) ---");
+    const changedFiles = resolve27(artifactDir, "changed-files.txt");
+    if (existsSync26(changedFiles)) {
+      const lines = readFileSync13(changedFiles, "utf-8").split(/\r?\n/).filter(Boolean);
       console.log(`--- Changed Files (${lines.length}) ---`);
       for (const line of lines) {
         console.log(line);
@@ -5768,12 +5827,12 @@ function printIndented(text) {
   }
 }
 function readLocalBeadsTasks(projectRoot) {
-  const issuesPath = resolve26(resolveMonorepoRoot2(projectRoot), ".beads/issues.jsonl");
-  if (!existsSync24(issuesPath)) {
+  const issuesPath = resolve27(resolveMonorepoRoot2(projectRoot), ".beads/issues.jsonl");
+  if (!existsSync26(issuesPath)) {
     return [];
   }
   const tasks = [];
-  for (const line of readFileSync12(issuesPath, "utf-8").split(/\r?\n/)) {
+  for (const line of readFileSync13(issuesPath, "utf-8").split(/\r?\n/)) {
     const trimmed = line.trim();
     if (!trimmed) {
       continue;
@@ -5886,11 +5945,11 @@ function taskDependencies(projectRoot, taskId, tracker) {
   return [...ids].sort();
 }
 function printArtifactSection(path, header) {
-  if (!existsSync24(path)) {
+  if (!existsSync26(path)) {
     return;
   }
   console.log(header);
-  process.stdout.write(readFileSync12(path, "utf-8"));
+  process.stdout.write(readFileSync13(path, "utf-8"));
   console.log("");
 }
 
@@ -5992,7 +6051,7 @@ init_layout();
 
 // packages/runtime/src/control-plane/runtime/overlay.ts
 init_layout();
-import { mkdirSync as mkdirSync11 } from "fs";
+import { mkdirSync as mkdirSync12 } from "fs";
 function ensureRuntimeOverlay(projectRoot, runtimeId, workspaceDir) {
   const layout = resolveRuntimeWorkspaceLayout(workspaceDir ?? projectRoot);
   const rootDir = layout.rigRoot;
@@ -6004,14 +6063,14 @@ function ensureRuntimeOverlay(projectRoot, runtimeId, workspaceDir) {
   const sessionDir = layout.sessionDir;
   const runtimeDir = layout.runtimeDir;
   const contextPath = layout.contextPath;
-  mkdirSync11(rootDir, { recursive: true });
-  mkdirSync11(homeDir, { recursive: true });
-  mkdirSync11(tmpDir, { recursive: true });
-  mkdirSync11(cacheDir, { recursive: true });
-  mkdirSync11(logsDir, { recursive: true });
-  mkdirSync11(stateDir, { recursive: true });
-  mkdirSync11(sessionDir, { recursive: true });
-  mkdirSync11(runtimeDir, { recursive: true });
+  mkdirSync12(rootDir, { recursive: true });
+  mkdirSync12(homeDir, { recursive: true });
+  mkdirSync12(tmpDir, { recursive: true });
+  mkdirSync12(cacheDir, { recursive: true });
+  mkdirSync12(logsDir, { recursive: true });
+  mkdirSync12(stateDir, { recursive: true });
+  mkdirSync12(sessionDir, { recursive: true });
+  mkdirSync12(runtimeDir, { recursive: true });
   return {
     rootDir,
     homeDir,
@@ -6029,17 +6088,17 @@ import {
   chmodSync as chmodSync5,
   copyFileSync as copyFileSync5,
   cpSync as cpSync2,
-  existsSync as existsSync26,
-  mkdirSync as mkdirSync12,
+  existsSync as existsSync28,
+  mkdirSync as mkdirSync13,
   statSync as statSync6,
-  writeFileSync as writeFileSync10
+  writeFileSync as writeFileSync11
 } from "fs";
 import { mkdir as mkdir2 } from "fs/promises";
-import { basename as basename8, delimiter as delimiter2, resolve as resolve28 } from "path";
+import { basename as basename8, delimiter as delimiter2, resolve as resolve29 } from "path";
 
 // packages/runtime/src/control-plane/runtime/isolation/shared.ts
-import { existsSync as existsSync25, readFileSync as readFileSync13, rmSync as rmSync9 } from "fs";
-import { resolve as resolve27 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync14, rmSync as rmSync9 } from "fs";
+import { resolve as resolve28 } from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 var generatedCredentialFiles = new Set;
 var credentialCleanupRegistered = false;
@@ -6064,7 +6123,7 @@ function resolveHostGitBinary() {
     if (!candidate || isRuntimeGatewayGitPath(candidate)) {
       continue;
     }
-    if (existsSync25(candidate)) {
+    if (existsSync27(candidate)) {
       return candidate;
     }
   }
@@ -6130,7 +6189,7 @@ async function refreshRemoteBranch(repoRoot, remote, branch) {
   }
 }
 async function tryReadGitHead(repoRoot) {
-  if (!existsSync25(resolve27(repoRoot, ".git"))) {
+  if (!existsSync27(resolve28(repoRoot, ".git"))) {
     return;
   }
   const result = await runGitCommand(repoRoot, ["rev-parse", "HEAD"]);
@@ -6141,7 +6200,7 @@ async function tryReadGitHead(repoRoot) {
   return value || undefined;
 }
 async function captureRepoDirtyFiles(repoRoot) {
-  if (!existsSync25(resolve27(repoRoot, ".git"))) {
+  if (!existsSync27(resolve28(repoRoot, ".git"))) {
     return [];
   }
   const files = new Set;
@@ -6232,16 +6291,16 @@ function hashProjectPath(workspaceDir) {
 }
 function resolveGithubCliBinaryPath() {
   const explicit = process.env.RIG_GH_BIN?.trim();
-  if (explicit && existsSync25(explicit) && !isRuntimeGatewayGhPath(explicit)) {
+  if (explicit && existsSync27(explicit) && !isRuntimeGatewayGhPath(explicit)) {
     return explicit;
   }
   for (const candidate of ["/usr/bin/gh", "/opt/homebrew/bin/gh", "/usr/local/bin/gh"]) {
-    if (existsSync25(candidate)) {
+    if (existsSync27(candidate)) {
       return candidate;
     }
   }
   const bunResolved = Bun.which("gh");
-  if (bunResolved && existsSync25(bunResolved) && !isRuntimeGatewayGhPath(bunResolved)) {
+  if (bunResolved && existsSync27(bunResolved) && !isRuntimeGatewayGhPath(bunResolved)) {
     return bunResolved;
   }
   return "";
@@ -6275,17 +6334,17 @@ function resolveSystemCertBundlePath() {
     "/opt/homebrew/etc/openssl@3/cert.pem"
   ];
   for (const candidate of candidates) {
-    if (candidate && existsSync25(candidate)) {
-      return resolve27(candidate);
+    if (candidate && existsSync27(candidate)) {
+      return resolve28(candidate);
     }
   }
   return "";
 }
 function readKnownHosts(path) {
-  if (!existsSync25(path)) {
+  if (!existsSync27(path)) {
     return new Set;
   }
-  return new Set(readFileSync13(path, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean));
+  return new Set(readFileSync14(path, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean));
 }
 
 // packages/runtime/src/control-plane/runtime/isolation/home.ts
@@ -6300,12 +6359,12 @@ function resolveControlPlaneSourceRoot(projectRoot) {
   const candidates = [
     process.env.RIG_CONTROL_PLANE_SOURCE_ROOT?.trim(),
     process.env.RIG_HOST_PROJECT_ROOT?.trim(),
-    resolve28(import.meta.dir, "../../../../.."),
+    resolve29(import.meta.dir, "../../../../.."),
     projectRoot
   ].filter((value) => Boolean(value));
   for (const candidate of candidates) {
-    const root = resolve28(candidate);
-    if (existsSync26(resolve28(root, "packages/runtime/src/control-plane/pi-sessiond/bin.ts"))) {
+    const root = resolve29(candidate);
+    if (existsSync28(resolve29(root, "packages/runtime/src/control-plane/pi-sessiond/bin.ts"))) {
       return root;
     }
   }
@@ -6325,7 +6384,7 @@ async function runtimeEnv(projectRoot, runtime) {
     try {
       return resolveClaudeInstallDir();
     } catch {
-      return resolve28(claudeBinaryPath, "..");
+      return resolve29(claudeBinaryPath, "..");
     }
   })() : "";
   const nodeDir = resolveNodeInstallDir();
@@ -6340,8 +6399,8 @@ async function runtimeEnv(projectRoot, runtime) {
     `${bunDir}/bin`,
     claudeDir,
     nodeDir ? `${nodeDir}/bin` : "",
-    realHome ? resolve28(realHome, ".local/bin") : "",
-    realHome ? resolve28(realHome, ".cargo/bin") : "",
+    realHome ? resolve29(realHome, ".local/bin") : "",
+    realHome ? resolve29(realHome, ".cargo/bin") : "",
     ...inheritedPath,
     "/usr/local/bin",
     "/usr/local/sbin",
@@ -6352,9 +6411,9 @@ async function runtimeEnv(projectRoot, runtime) {
     "/usr/sbin",
     "/sbin"
   ].filter(Boolean);
-  const runtimeBash = resolve28(runtime.binDir, "bash");
-  const runtimeRigGit = resolve28(runtime.binDir, runtimeRigGitFileName());
-  const preferredShell = existsSync26(runtimeBash) ? runtimeBash : "/bin/bash";
+  const runtimeBash = resolve29(runtime.binDir, "bash");
+  const runtimeRigGit = resolve29(runtime.binDir, runtimeRigGitFileName());
+  const preferredShell = existsSync28(runtimeBash) ? runtimeBash : "/bin/bash";
   const nativeRuntimeLibraryPath = await materializeNativeRuntimeLibrary(runtime.binDir);
   const controlPlaneSourceRoot = resolveControlPlaneSourceRoot(projectRoot);
   const env = {
@@ -6375,30 +6434,30 @@ async function runtimeEnv(projectRoot, runtime) {
     RIG_RUNTIME_MODE: runtime.mode,
     RIG_RUNTIME_HOME: runtime.rootDir,
     RIG_RUNTIME_BIN_DIR: runtime.binDir,
-    ...existsSync26(runtimeRigGit) ? { RIG_NATIVE_GIT_BIN: runtimeRigGit } : {},
+    ...existsSync28(runtimeRigGit) ? { RIG_NATIVE_GIT_BIN: runtimeRigGit } : {},
     RIG_BUN_PATH: bunBinaryPath,
     ...claudeBinaryPath ? { RIG_CLAUDE_PATH: claudeBinaryPath } : {},
-    RIG_AGENT_BIN: resolve28(runtime.binDir, "rig-agent"),
+    RIG_AGENT_BIN: resolve29(runtime.binDir, "rig-agent"),
     RIG_HOOKS_ACTIVE: "1",
     RIG_AUTO_PR_ON_COMPLETE: "1",
-    RIG_POLICY_FILE: resolve28(projectRoot, "rig/policy/policy.json"),
+    RIG_POLICY_FILE: resolve29(projectRoot, "rig/policy/policy.json"),
     RIG_STATE_DIR: runtime.stateDir,
     RIG_LOGS_DIR: runtime.logsDir,
-    RIG_SESSION_FILE: resolve28(runtime.sessionDir, "session.json"),
+    RIG_SESSION_FILE: resolve29(runtime.sessionDir, "session.json"),
     MONOREPO_ROOT: runtime.workspaceDir,
     MONOREPO_MAIN_ROOT: monorepoMainRoot,
-    TS_API_TESTS_DIR: resolve28(runtime.workspaceDir, "TSAPITests"),
+    TS_API_TESTS_DIR: resolve29(runtime.workspaceDir, "TSAPITests"),
     BASH: preferredShell,
     SHELL: preferredShell,
     PATH: [...new Set(pathEntries)].join(delimiter2),
     LANG: process.env.LANG ?? "en_US.UTF-8",
     TERM: process.env.TERM ?? "xterm-256color",
     PYTHONDONTWRITEBYTECODE: "1",
-    PYTHONPYCACHEPREFIX: resolve28(runtime.cacheDir, "python"),
+    PYTHONPYCACHEPREFIX: resolve29(runtime.cacheDir, "python"),
     ...process.env.RIG_PR_BASE_PROJECT && { RIG_PR_BASE_PROJECT: process.env.RIG_PR_BASE_PROJECT },
     ...process.env.RIG_PR_BASE_MONOREPO && { RIG_PR_BASE_MONOREPO: process.env.RIG_PR_BASE_MONOREPO },
     CLAUDE_HOME: runtime.claudeHomeDir,
-    PI_CODING_AGENT_DIR: resolve28(runtime.homeDir, ".pi", "agent"),
+    PI_CODING_AGENT_DIR: resolve29(runtime.homeDir, ".pi", "agent"),
     [RUNTIME_CONTEXT_ENV]: runtime.contextFile,
     ...nativeRuntimeLibraryPath ? { RIG_NATIVE_RUNTIME_LIB: nativeRuntimeLibraryPath } : {},
     ...hostGhBinary ? { RIG_GH_BIN: hostGhBinary } : {},
@@ -6409,16 +6468,16 @@ async function runtimeEnv(projectRoot, runtime) {
       NODE_EXTRA_CA_CERTS: runtimeCertBundlePath
     } : {}
   };
-  const knownHostsPath = resolve28(runtime.homeDir, ".ssh", "known_hosts");
-  if (existsSync26(knownHostsPath)) {
-    const agentSshKey = resolve28(runtime.homeDir, ".ssh", "rig-agent-key");
+  const knownHostsPath = resolve29(runtime.homeDir, ".ssh", "known_hosts");
+  if (existsSync28(knownHostsPath)) {
+    const agentSshKey = resolve29(runtime.homeDir, ".ssh", "rig-agent-key");
     const sshParts = [
       "ssh",
       `-o UserKnownHostsFile="${knownHostsPath}"`,
       "-o StrictHostKeyChecking=yes",
       "-F /dev/null"
     ];
-    if (existsSync26(agentSshKey)) {
+    if (existsSync28(agentSshKey)) {
       sshParts.splice(1, 0, `-i "${agentSshKey}"`, "-o IdentitiesOnly=yes");
     }
     env.GIT_SSH_COMMAND = sshParts.join(" ");
@@ -6455,7 +6514,7 @@ async function runtimeEnv(projectRoot, runtime) {
   if (!env.GREPTILE_GITHUB_TOKEN && env.GITHUB_TOKEN) {
     env.GREPTILE_GITHUB_TOKEN = env.GITHUB_TOKEN;
   }
-  if (existsSync26(runtime.contextFile)) {
+  if (existsSync28(runtime.contextFile)) {
     const runtimeContext = loadRuntimeContext(runtime.contextFile);
     Object.assign(env, runtimeMemoryEnvFromContext(runtimeContext));
     Object.assign(env, browserEnvFromContext(runtimeContext.browser));
@@ -6484,30 +6543,30 @@ async function provisionRuntimeHome(runtime, options = {}) {
   await mkdir2(runtime.cacheDir, { recursive: true });
   await provisionAgentSshKey(runtime.homeDir);
   if (options.provider === "codex") {
-    const hasCodexAuth = await injectCodexAuth(resolve28(runtime.homeDir, ".codex"));
+    const hasCodexAuth = await injectCodexAuth(resolve29(runtime.homeDir, ".codex"));
     if (!hasCodexAuth) {
       console.warn("[rig] No Codex auth.json found for isolated runtime. " + "Run `codex login` in your host shell, then retry the agent run.");
     }
   }
   if (options.provider === "pi") {
-    const hasPiAuth = await injectPiAgentConfig(resolve28(runtime.homeDir, ".pi", "agent"));
+    const hasPiAuth = await injectPiAgentConfig(resolve29(runtime.homeDir, ".pi", "agent"));
     if (!hasPiAuth) {
       console.warn("[rig] No Pi auth.json found for isolated runtime. " + "Run `pi /login` in your host shell, then retry the agent run.");
     }
   }
 }
 async function provisionClaudeHome(config) {
-  mkdirSync12(config.claudeHomeDir, { recursive: true });
-  const workspaceSettings = resolve28(config.workspaceDir, ".claude/settings.json");
-  const hostSettings = resolve28(config.hostProjectRoot, ".claude/settings.json");
-  const projectSettings = existsSync26(workspaceSettings) ? workspaceSettings : hostSettings;
+  mkdirSync13(config.claudeHomeDir, { recursive: true });
+  const workspaceSettings = resolve29(config.workspaceDir, ".claude/settings.json");
+  const hostSettings = resolve29(config.hostProjectRoot, ".claude/settings.json");
+  const projectSettings = existsSync28(workspaceSettings) ? workspaceSettings : hostSettings;
   const runtimeSettings = await loadRuntimeClaudeSettings(projectSettings);
-  if (existsSync26(projectSettings)) {
-    writeFileSync10(resolve28(config.claudeHomeDir, "settings.local.json"), `${JSON.stringify(runtimeSettings, null, 2)}
+  if (existsSync28(projectSettings)) {
+    writeFileSync11(resolve29(config.claudeHomeDir, "settings.local.json"), `${JSON.stringify(runtimeSettings, null, 2)}
 `, "utf-8");
   }
   writeClaudeProjectSettings(config.claudeHomeDir, config.workspaceDir, runtimeSettings);
-  writeFileSync10(resolve28(config.claudeHomeDir, "settings.json"), JSON.stringify({
+  writeFileSync11(resolve29(config.claudeHomeDir, "settings.json"), JSON.stringify({
     permissions: { defaultMode: "bypassPermissions" },
     autoMemoryEnabled: false
   }, null, 2));
@@ -6515,12 +6574,12 @@ async function provisionClaudeHome(config) {
   if (!hasCredentials) {
     console.warn("[rig] No Claude credentials found for isolated runtime. " + "Run `claude /login` in your host shell, then retry the agent run.");
   }
-  const realClaudeHome = resolve28(process.env.HOME ?? "", ".claude");
-  if (process.env.HOME && existsSync26(resolve28(realClaudeHome, "CLAUDE.md"))) {
-    cpSync2(resolve28(realClaudeHome, "CLAUDE.md"), resolve28(config.claudeHomeDir, "CLAUDE.md"));
+  const realClaudeHome = resolve29(process.env.HOME ?? "", ".claude");
+  if (process.env.HOME && existsSync28(resolve29(realClaudeHome, "CLAUDE.md"))) {
+    cpSync2(resolve29(realClaudeHome, "CLAUDE.md"), resolve29(config.claudeHomeDir, "CLAUDE.md"));
   }
-  if (process.env.HOME && existsSync26(resolve28(realClaudeHome, "agents"))) {
-    cpSync2(resolve28(realClaudeHome, "agents"), resolve28(config.claudeHomeDir, "agents"), { recursive: true });
+  if (process.env.HOME && existsSync28(resolve29(realClaudeHome, "agents"))) {
+    cpSync2(resolve29(realClaudeHome, "agents"), resolve29(config.claudeHomeDir, "agents"), { recursive: true });
   }
   if (process.platform === "darwin" && process.env.HOME) {
     writeClaudeProjectSettings(realClaudeHome, config.workspaceDir, runtimeSettings);
@@ -6531,10 +6590,10 @@ async function materializeRuntimeCertBundle(runtime) {
   if (!sourcePath) {
     return "";
   }
-  const certsDir = resolve28(runtime.rootDir, "certs");
-  const targetPath = resolve28(certsDir, "ca-certificates.pem");
+  const certsDir = resolve29(runtime.rootDir, "certs");
+  const targetPath = resolve29(certsDir, "ca-certificates.pem");
   await mkdir2(certsDir, { recursive: true });
-  let shouldCopy = !existsSync26(targetPath);
+  let shouldCopy = !existsSync28(targetPath);
   if (!shouldCopy) {
     try {
       shouldCopy = statSync6(sourcePath).mtimeMs > statSync6(targetPath).mtimeMs;
@@ -6556,7 +6615,7 @@ function applyGitHubCredentialHelperEnv(env) {
   env.GIT_CONFIG_VALUE_1 = '!f() { test "$1" = get || exit 0; token="${GITHUB_TOKEN:-${GH_TOKEN:-${RIG_GITHUB_TOKEN:-}}}"; test -n "$token" || exit 0; echo username=x-access-token; echo password="$token"; }; f';
 }
 function persistRuntimeSecrets(runtimeRoot, env) {
-  const secretsPath = resolve28(runtimeRoot, "runtime-secrets.json");
+  const secretsPath = resolve29(runtimeRoot, "runtime-secrets.json");
   const persisted = {};
   for (const key of [
     "GITHUB_TOKEN",
@@ -6575,12 +6634,12 @@ function persistRuntimeSecrets(runtimeRoot, env) {
   if (Object.keys(persisted).length === 0) {
     return;
   }
-  writeFileSync10(secretsPath, `${JSON.stringify(persisted, null, 2)}
+  writeFileSync11(secretsPath, `${JSON.stringify(persisted, null, 2)}
 `, "utf-8");
 }
 async function provisionAgentSshKey(homeDir) {
-  const sshDir = resolve28(homeDir, ".ssh");
-  if (!existsSync26(sshDir)) {
+  const sshDir = resolve29(homeDir, ".ssh");
+  if (!existsSync28(sshDir)) {
     await mkdir2(sshDir, { recursive: true });
   }
   seedKnownHosts(sshDir);
@@ -6588,27 +6647,27 @@ async function provisionAgentSshKey(homeDir) {
   const privateKey = decodeProvisionedSshKey(secrets.GITHUB_SSH_KEY);
   if (!privateKey) {
     const hostKeyPath = resolveHostSshKeyPath(process.env.HOME ?? "");
-    if (!process.env.HOME || !existsSync26(hostKeyPath)) {
+    if (!process.env.HOME || !existsSync28(hostKeyPath)) {
       return;
     }
-    const agentKeyPath2 = resolve28(sshDir, "rig-agent-key");
-    if (!existsSync26(agentKeyPath2)) {
+    const agentKeyPath2 = resolve29(sshDir, "rig-agent-key");
+    if (!existsSync28(agentKeyPath2)) {
       copyFileSync5(hostKeyPath, agentKeyPath2);
       chmodSync5(agentKeyPath2, 384);
     }
     const hostPubPath = `${hostKeyPath}.pub`;
-    if (existsSync26(hostPubPath)) {
+    if (existsSync28(hostPubPath)) {
       const agentPubPath = `${agentKeyPath2}.pub`;
-      if (!existsSync26(agentPubPath)) {
+      if (!existsSync28(agentPubPath)) {
         copyFileSync5(hostPubPath, agentPubPath);
       }
     }
     writeSshConfig(sshDir, agentKeyPath2);
     return;
   }
-  const agentKeyPath = resolve28(sshDir, "rig-agent-key");
-  if (!existsSync26(agentKeyPath)) {
-    writeFileSync10(agentKeyPath, privateKey, { mode: 384 });
+  const agentKeyPath = resolve29(sshDir, "rig-agent-key");
+  if (!existsSync28(agentKeyPath)) {
+    writeFileSync11(agentKeyPath, privateKey, { mode: 384 });
   }
   writeSshConfig(sshDir, agentKeyPath);
 }
@@ -6625,21 +6684,21 @@ function decodeProvisionedSshKey(encodedKey) {
 `;
 }
 function resolveHostSshKeyPath(homeDir) {
-  const sshDir = resolve28(homeDir, ".ssh");
+  const sshDir = resolve29(homeDir, ".ssh");
   const candidates = [
     "rig-agent-key",
     "id_ed25519",
     "id_ecdsa",
     "id_rsa"
-  ].map((name) => resolve28(sshDir, name));
-  return candidates.find((candidate) => existsSync26(candidate)) ?? resolve28(sshDir, "rig-agent-key");
+  ].map((name) => resolve29(sshDir, name));
+  return candidates.find((candidate) => existsSync28(candidate)) ?? resolve29(sshDir, "rig-agent-key");
 }
 function writeSshConfig(sshDir, keyPath) {
-  const configPath = resolve28(sshDir, "config");
-  if (existsSync26(configPath)) {
+  const configPath = resolve29(sshDir, "config");
+  if (existsSync28(configPath)) {
     return;
   }
-  const knownHostsPath = resolve28(sshDir, "known_hosts");
+  const knownHostsPath = resolve29(sshDir, "known_hosts");
   const config = [
     "Host github.com",
     `  IdentityFile ${keyPath}`,
@@ -6649,10 +6708,10 @@ function writeSshConfig(sshDir, keyPath) {
     ""
   ].join(`
 `);
-  writeFileSync10(configPath, config, { mode: 420 });
+  writeFileSync11(configPath, config, { mode: 420 });
 }
 function seedKnownHosts(sshDir) {
-  const knownHostsPath = resolve28(sshDir, "known_hosts");
+  const knownHostsPath = resolve29(sshDir, "known_hosts");
   const existingLines = readKnownHosts(knownHostsPath);
   const requiredLines = GITHUB_KNOWN_HOSTS.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
   const missing = requiredLines.filter((line) => !existingLines.has(line));
@@ -6663,23 +6722,23 @@ function seedKnownHosts(sshDir) {
     for (const line of missing) {
       existingLines.add(line);
     }
-    writeFileSync10(knownHostsPath, `${Array.from(existingLines).join(`
+    writeFileSync11(knownHostsPath, `${Array.from(existingLines).join(`
 `)}
 `, { mode: 420 });
   } catch (err) {
-    const hint = existsSync26(knownHostsPath) ? "" : " \u2014 known_hosts is missing; git SSH operations may fail";
+    const hint = existsSync28(knownHostsPath) ? "" : " \u2014 known_hosts is missing; git SSH operations may fail";
     console.warn(`[rig] Could not update ${knownHostsPath}: ${err instanceof Error ? err.message : String(err)}${hint}`);
   }
 }
 function writeClaudeProjectSettings(claudeHomeDir, workspaceDir, runtimeSettings) {
   const projectHash = hashProjectPath(workspaceDir);
-  const projectDir = resolve28(claudeHomeDir, "projects", projectHash);
-  mkdirSync12(projectDir, { recursive: true });
-  writeFileSync10(resolve28(projectDir, "settings.json"), `${JSON.stringify(runtimeSettings, null, 2)}
+  const projectDir = resolve29(claudeHomeDir, "projects", projectHash);
+  mkdirSync13(projectDir, { recursive: true });
+  writeFileSync11(resolve29(projectDir, "settings.json"), `${JSON.stringify(runtimeSettings, null, 2)}
 `, "utf-8");
 }
 async function loadRuntimeClaudeSettings(projectSettingsPath) {
-  if (!existsSync26(projectSettingsPath)) {
+  if (!existsSync28(projectSettingsPath)) {
     return {};
   }
   let parsed;
@@ -6725,7 +6784,7 @@ async function loadRuntimeClaudeSettings(projectSettingsPath) {
   return clone;
 }
 async function injectClaudeCredentials(claudeHomeDir, options = {}) {
-  const credentialsPath = resolve28(claudeHomeDir, ".credentials.json");
+  const credentialsPath = resolve29(claudeHomeDir, ".credentials.json");
   const platform = options.platform ?? process.platform;
   if (platform === "darwin") {
     const raw = options.loadKeychainCredentials ? await options.loadKeychainCredentials() : await (async () => {
@@ -6735,16 +6794,16 @@ async function injectClaudeCredentials(claudeHomeDir, options = {}) {
     if (raw) {
       try {
         JSON.parse(raw);
-        writeFileSync10(credentialsPath, raw, { mode: 384 });
+        writeFileSync11(credentialsPath, raw, { mode: 384 });
         registerCredentialCleanup(credentialsPath);
         return true;
       } catch {}
     }
   }
-  const hostClaudeHome = options.hostClaudeHome ? resolve28(options.hostClaudeHome) : process.env.CLAUDE_HOME?.trim() ? resolve28(process.env.CLAUDE_HOME) : process.env.HOME ? resolve28(process.env.HOME, ".claude") : "";
+  const hostClaudeHome = options.hostClaudeHome ? resolve29(options.hostClaudeHome) : process.env.CLAUDE_HOME?.trim() ? resolve29(process.env.CLAUDE_HOME) : process.env.HOME ? resolve29(process.env.HOME, ".claude") : "";
   if (hostClaudeHome) {
-    const realCredentials = resolve28(hostClaudeHome, ".credentials.json");
-    if (existsSync26(realCredentials)) {
+    const realCredentials = resolve29(hostClaudeHome, ".credentials.json");
+    if (existsSync28(realCredentials)) {
       cpSync2(realCredentials, credentialsPath);
       return true;
     }
@@ -6752,36 +6811,36 @@ async function injectClaudeCredentials(claudeHomeDir, options = {}) {
   return false;
 }
 async function injectCodexAuth(codexHomeDir) {
-  mkdirSync12(codexHomeDir, { recursive: true });
-  const hostCodexHome = process.env.CODEX_HOME?.trim() ? resolve28(process.env.CODEX_HOME) : process.env.HOME ? resolve28(process.env.HOME, ".codex") : "";
+  mkdirSync13(codexHomeDir, { recursive: true });
+  const hostCodexHome = process.env.CODEX_HOME?.trim() ? resolve29(process.env.CODEX_HOME) : process.env.HOME ? resolve29(process.env.HOME, ".codex") : "";
   if (!hostCodexHome) {
     return false;
   }
-  const hostAuthPath = resolve28(hostCodexHome, "auth.json");
-  if (!existsSync26(hostAuthPath)) {
+  const hostAuthPath = resolve29(hostCodexHome, "auth.json");
+  if (!existsSync28(hostAuthPath)) {
     return false;
   }
-  const runtimeAuthPath = resolve28(codexHomeDir, "auth.json");
+  const runtimeAuthPath = resolve29(codexHomeDir, "auth.json");
   copyFileSync5(hostAuthPath, runtimeAuthPath);
   chmodSync5(runtimeAuthPath, 384);
   return true;
 }
 async function injectPiAgentConfig(piAgentDir) {
-  mkdirSync12(piAgentDir, { recursive: true });
-  const hostPiAgentDir = process.env.PI_CODING_AGENT_DIR?.trim() ? resolve28(process.env.PI_CODING_AGENT_DIR) : process.env.HOME ? resolve28(process.env.HOME, ".pi", "agent") : "";
+  mkdirSync13(piAgentDir, { recursive: true });
+  const hostPiAgentDir = process.env.PI_CODING_AGENT_DIR?.trim() ? resolve29(process.env.PI_CODING_AGENT_DIR) : process.env.HOME ? resolve29(process.env.HOME, ".pi", "agent") : "";
   if (!hostPiAgentDir) {
     return false;
   }
-  const hostAuthPath = resolve28(hostPiAgentDir, "auth.json");
-  if (!existsSync26(hostAuthPath)) {
+  const hostAuthPath = resolve29(hostPiAgentDir, "auth.json");
+  if (!existsSync28(hostAuthPath)) {
     return false;
   }
-  const runtimeAuthPath = resolve28(piAgentDir, "auth.json");
+  const runtimeAuthPath = resolve29(piAgentDir, "auth.json");
   copyFileSync5(hostAuthPath, runtimeAuthPath);
   chmodSync5(runtimeAuthPath, 384);
-  const hostSettingsPath = resolve28(hostPiAgentDir, "settings.json");
-  if (existsSync26(hostSettingsPath)) {
-    const runtimeSettingsPath = resolve28(piAgentDir, "settings.json");
+  const hostSettingsPath = resolve29(hostPiAgentDir, "settings.json");
+  if (existsSync28(hostSettingsPath)) {
+    const runtimeSettingsPath = resolve29(piAgentDir, "settings.json");
     copyFileSync5(hostSettingsPath, runtimeSettingsPath);
     chmodSync5(runtimeSettingsPath, 384);
   }
@@ -6789,13 +6848,13 @@ async function injectPiAgentConfig(piAgentDir) {
 }
 
 // packages/runtime/src/control-plane/runtime/tooling/claude-router.ts
-import { existsSync as existsSync27, mkdirSync as mkdirSync13, statSync as statSync7, writeFileSync as writeFileSync11 } from "fs";
-import { resolve as resolve29 } from "path";
+import { existsSync as existsSync29, mkdirSync as mkdirSync14, statSync as statSync7, writeFileSync as writeFileSync12 } from "fs";
+import { resolve as resolve30 } from "path";
 var CLAUDE_ROUTER_SERVER_NAME = "rig_runtime_tools";
 function buildRuntimeToolRouterServerConfig(options) {
   return {
     type: "stdio",
-    command: resolve29(options.binDir, "rig-tool-router"),
+    command: resolve30(options.binDir, "rig-tool-router"),
     args: [],
     env: {
       RIG_RUNTIME_CONTEXT_FILE: options.contextFile,
@@ -6804,14 +6863,14 @@ function buildRuntimeToolRouterServerConfig(options) {
   };
 }
 function writeClaudeRuntimeToolRouterConfig(options) {
-  const configPath = resolve29(options.stateDir, "claude-runtime-tools.mcp.json");
-  mkdirSync13(options.stateDir, { recursive: true });
+  const configPath = resolve30(options.stateDir, "claude-runtime-tools.mcp.json");
+  mkdirSync14(options.stateDir, { recursive: true });
   const payload = {
     mcpServers: {
       [CLAUDE_ROUTER_SERVER_NAME]: buildRuntimeToolRouterServerConfig(options)
     }
   };
-  writeFileSync11(configPath, `${JSON.stringify(payload, null, 2)}
+  writeFileSync12(configPath, `${JSON.stringify(payload, null, 2)}
 `, "utf-8");
   return configPath;
 }
@@ -6820,8 +6879,8 @@ if (false) {}
 init_layout();
 
 // packages/runtime/src/control-plane/runtime/isolation/worktree.ts
-import { existsSync as existsSync28, mkdirSync as mkdirSync14, rmSync as rmSync10 } from "fs";
-import { dirname as dirname12, resolve as resolve30 } from "path";
+import { existsSync as existsSync30, mkdirSync as mkdirSync15, rmSync as rmSync10 } from "fs";
+import { dirname as dirname13, resolve as resolve31 } from "path";
 async function resolveMonorepoBaseRef(monorepoRoot) {
   const explicit = process.env.RIG_RUNTIME_BASE_REF?.trim();
   if (explicit) {
@@ -6857,12 +6916,12 @@ function ensureProvisioningHostProjectRootEnv(projectRoot) {
 }
 async function provisionRuntimeWorktree(config) {
   const branch = runtimeBranchName(config.taskId, config.runtimeId);
-  let hasValidWorktree = existsSync28(resolve30(config.workspaceDir, ".git")) && (await runGitCommand(config.workspaceDir, ["rev-parse", "--show-toplevel"])).exitCode === 0;
-  if (existsSync28(config.workspaceDir) && !hasValidWorktree) {
+  let hasValidWorktree = existsSync30(resolve31(config.workspaceDir, ".git")) && (await runGitCommand(config.workspaceDir, ["rev-parse", "--show-toplevel"])).exitCode === 0;
+  if (existsSync30(config.workspaceDir) && !hasValidWorktree) {
     rmSync10(config.workspaceDir, { recursive: true, force: true });
   }
   if (!hasValidWorktree) {
-    mkdirSync14(dirname12(config.workspaceDir), { recursive: true });
+    mkdirSync15(dirname13(config.workspaceDir), { recursive: true });
     const branchExists = await runGitCommand(config.monorepoRoot, ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`]);
     const add = branchExists.exitCode === 0 ? await runGitCommand(config.monorepoRoot, ["worktree", "add", "--force", config.workspaceDir, branch]) : await runGitCommand(config.monorepoRoot, ["worktree", "add", "--force", "-b", branch, config.workspaceDir, config.baseRef]);
     if (add.exitCode !== 0) {
@@ -7038,31 +7097,31 @@ async function preferredBaseRemotes(repoRoot) {
 
 // packages/runtime/src/control-plane/runtime/isolation/toolchain.ts
 import {
-  existsSync as existsSync30,
+  existsSync as existsSync32,
   lstatSync,
-  mkdirSync as mkdirSync16,
+  mkdirSync as mkdirSync17,
   readdirSync as readdirSync6,
-  readFileSync as readFileSync15,
+  readFileSync as readFileSync16,
   rmSync as rmSync11,
   statSync as statSync9,
   symlinkSync as symlinkSync4
 } from "fs";
 import { mkdir as mkdir3, writeFile } from "fs/promises";
-import { dirname as dirname14, resolve as resolve32 } from "path";
+import { dirname as dirname15, resolve as resolve33 } from "path";
 
 // packages/runtime/src/control-plane/runtime/tooling/claude-router-binary.ts
-import { chmodSync as chmodSync6, copyFileSync as copyFileSync6, existsSync as existsSync29, mkdirSync as mkdirSync15, statSync as statSync8 } from "fs";
+import { chmodSync as chmodSync6, copyFileSync as copyFileSync6, existsSync as existsSync31, mkdirSync as mkdirSync16, statSync as statSync8 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
-import { dirname as dirname13, resolve as resolve31 } from "path";
-var sharedRouterOutputDir = resolve31(tmpdir6(), "rig-native");
-var sharedRouterOutputPath = resolve31(sharedRouterOutputDir, `rig-tool-router-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`);
+import { dirname as dirname14, resolve as resolve32 } from "path";
+var sharedRouterOutputDir = resolve32(tmpdir6(), "rig-native");
+var sharedRouterOutputPath = resolve32(sharedRouterOutputDir, `rig-tool-router-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`);
 function runtimeClaudeToolRouterFileName() {
   return `rig-tool-router${process.platform === "win32" ? ".exe" : ""}`;
 }
 async function ensureClaudeToolRouterBinaryPath(projectRoot, outputPath = sharedRouterOutputPath) {
-  const sourcePath = resolve31(projectRoot, "packages/runtime/src/control-plane/runtime/tooling/claude-router.ts");
-  mkdirSync15(dirname13(outputPath), { recursive: true });
-  const needsBuild = !existsSync29(outputPath) || statSync8(sourcePath).mtimeMs > statSync8(outputPath).mtimeMs;
+  const sourcePath = resolve32(projectRoot, "packages/runtime/src/control-plane/runtime/tooling/claude-router.ts");
+  mkdirSync16(dirname14(outputPath), { recursive: true });
+  const needsBuild = !existsSync31(outputPath) || statSync8(sourcePath).mtimeMs > statSync8(outputPath).mtimeMs;
   if (!needsBuild) {
     return outputPath;
   }
@@ -7076,9 +7135,9 @@ async function ensureClaudeToolRouterBinaryPath(projectRoot, outputPath = shared
 }
 async function materializeClaudeToolRouterBinary(projectRoot, targetDir) {
   const sourcePath = await ensureClaudeToolRouterBinaryPath(projectRoot);
-  const targetPath = resolve31(targetDir, runtimeClaudeToolRouterFileName());
-  mkdirSync15(targetDir, { recursive: true });
-  const needsCopy = !existsSync29(targetPath) || statSync8(sourcePath).mtimeMs > statSync8(targetPath).mtimeMs;
+  const targetPath = resolve32(targetDir, runtimeClaudeToolRouterFileName());
+  mkdirSync16(targetDir, { recursive: true });
+  const needsCopy = !existsSync31(targetPath) || statSync8(sourcePath).mtimeMs > statSync8(targetPath).mtimeMs;
   if (needsCopy) {
     copyFileSync6(sourcePath, targetPath);
     chmodSync6(targetPath, 493);
@@ -7091,48 +7150,48 @@ var GIT_INDEX_LOCK_RETRY_DELAY_MS = 250;
 var GIT_INDEX_LOCK_STALE_AFTER_MS = 5000;
 function resolveRigSourceRoot(projectRoot) {
   const hostProjectRoot = process.env.RIG_HOST_PROJECT_ROOT?.trim();
-  if (hostProjectRoot && existsSync30(resolve32(hostProjectRoot, "packages/runtime/bin/rig-agent.ts"))) {
+  if (hostProjectRoot && existsSync32(resolve33(hostProjectRoot, "packages/runtime/bin/rig-agent.ts"))) {
     return hostProjectRoot;
   }
-  const fromModule = resolve32(import.meta.dir, "../../../../../..");
-  if (existsSync30(resolve32(fromModule, "packages/runtime/bin/rig-agent.ts"))) {
+  const fromModule = resolve33(import.meta.dir, "../../../../../..");
+  if (existsSync32(resolve33(fromModule, "packages/runtime/bin/rig-agent.ts"))) {
     return fromModule;
   }
   return projectRoot;
 }
 function prepareTrackedRuntimePaths(logsDir, stateDir, sessionDir) {
-  for (const path of [logsDir, stateDir, sessionDir, resolve32(sessionDir, "session.json")]) {
+  for (const path of [logsDir, stateDir, sessionDir, resolve33(sessionDir, "session.json")]) {
     removeSymbolicLink(path);
   }
   runtimePrepareTrackedPathsNative({
     logsDir,
     stateDir,
     sessionDir,
-    controlledBashLogFile: resolve32(logsDir, "controlled-bash.jsonl"),
-    eventsFile: resolve32(logsDir, "control-plane.events.jsonl")
+    controlledBashLogFile: resolve33(logsDir, "controlled-bash.jsonl"),
+    eventsFile: resolve33(logsDir, "control-plane.events.jsonl")
   });
 }
 async function initializeRuntimeStateFiles(stateDir, sessionDir, taskId) {
   await mkdir3(stateDir, { recursive: true });
   await mkdir3(sessionDir, { recursive: true });
-  const failedApproachesPath = resolve32(stateDir, "failed_approaches.md");
-  if (!existsSync30(failedApproachesPath)) {
+  const failedApproachesPath = resolve33(stateDir, "failed_approaches.md");
+  if (!existsSync32(failedApproachesPath)) {
     await writeFile(failedApproachesPath, `# Failed Approaches
 
 `);
   }
-  const hookTripsPath = resolve32(stateDir, "hook_trips.log");
-  if (!existsSync30(hookTripsPath)) {
+  const hookTripsPath = resolve33(stateDir, "hook_trips.log");
+  if (!existsSync32(hookTripsPath)) {
     await writeFile(hookTripsPath, "");
   }
-  const sessionFile = resolve32(sessionDir, "session.json");
+  const sessionFile = resolve33(sessionDir, "session.json");
   if (taskId) {
     await writeFile(sessionFile, JSON.stringify({ activeTaskIds: [taskId] }));
   }
 }
 async function resetEphemeralTaskArtifacts(workspaceDir, taskId) {
-  const artifactDir = resolve32(workspaceDir, "artifacts", taskId);
-  const runtimeSnapshotDir = resolve32(artifactDir, "runtime-snapshots");
+  const artifactDir = resolve33(workspaceDir, "artifacts", taskId);
+  const runtimeSnapshotDir = resolve33(artifactDir, "runtime-snapshots");
   let preservedTrackedFiles = false;
   for (const file of [
     "changed-files.txt",
@@ -7148,7 +7207,7 @@ async function resetEphemeralTaskArtifacts(workspaceDir, taskId) {
       preservedTrackedFiles = true;
       continue;
     }
-    rmSync11(resolve32(artifactDir, file), { force: true });
+    rmSync11(resolve33(artifactDir, file), { force: true });
   }
   const runtimeSnapshotRelativePath = `artifacts/${taskId}/runtime-snapshots`;
   if (await resetTrackedArtifactPath(workspaceDir, runtimeSnapshotRelativePath)) {
@@ -7187,28 +7246,28 @@ async function buildRuntimeToolchain(options) {
     throw new Error("Failed to provision the native Zig runtime library.");
   }
   const rigSourceRoot = resolveRigSourceRoot(options.projectRoot);
-  await buildBinary("packages/cli/bin/rig.ts", resolve32(options.binDir, "rig"), rigSourceRoot);
-  await buildBinary("packages/runtime/bin/rig-agent.ts", resolve32(options.binDir, "rig-agent"), rigSourceRoot, {
+  await buildBinary("packages/cli/bin/rig.ts", resolve33(options.binDir, "rig"), rigSourceRoot);
+  await buildBinary("packages/runtime/bin/rig-agent.ts", resolve33(options.binDir, "rig-agent"), rigSourceRoot, {
     ...options.runtimeSecretDefines,
     AGENT_TASK_ID: options.taskId,
     AGENT_PROJECT_ROOT: options.projectRoot,
     AGENT_RUNTIME_ID: options.runtimeId,
     AGENT_SCOPE_HASH: options.bakedScopeHash,
     AGENT_MANIFEST_PATH: options.manifestPath,
-    AGENT_BINARY_PATH: resolve32(options.binDir, "rig-agent"),
+    AGENT_BINARY_PATH: resolve33(options.binDir, "rig-agent"),
     AGENT_INFO_OUTPUT: options.bakedInfoOutput,
     AGENT_DEPS_OUTPUT: options.bakedDepsOutput,
     AGENT_STATUS_OUTPUT: options.bakedStatusOutput
   });
-  await buildBinary("packages/runtime/src/control-plane/controlled-bash.ts", resolve32(options.binDir, "controlled-bash"), rigSourceRoot, {
+  await buildBinary("packages/runtime/src/control-plane/controlled-bash.ts", resolve33(options.binDir, "controlled-bash"), rigSourceRoot, {
     AGENT_PROJECT_ROOT: options.projectRoot,
     AGENT_LOGS_DIR: options.logsDir,
     AGENT_MONOREPO_ROOT: resolveMonorepoRoot3(options.projectRoot),
-    AGENT_TS_API_TESTS_DIR: resolve32(options.workspaceDir, "TSAPITests"),
-    AGENT_RIG_AGENT_BIN: resolve32(options.binDir, "rig-agent")
+    AGENT_TS_API_TESTS_DIR: resolve33(options.workspaceDir, "TSAPITests"),
+    AGENT_RIG_AGENT_BIN: resolve33(options.binDir, "rig-agent")
   });
-  await buildBinary("packages/runtime/bin/rig-browser-tool.ts", resolve32(options.binDir, runtimeBrowserToolBinaryName()), rigSourceRoot);
-  await buildBinary("packages/runtime/src/control-plane/runtime/snapshot/sidecar.ts", resolve32(options.binDir, "snapshot-sidecar"), rigSourceRoot, {
+  await buildBinary("packages/runtime/bin/rig-browser-tool.ts", resolve33(options.binDir, runtimeBrowserToolBinaryName()), rigSourceRoot);
+  await buildBinary("packages/runtime/src/control-plane/runtime/snapshot/sidecar.ts", resolve33(options.binDir, "snapshot-sidecar"), rigSourceRoot, {
     AGENT_PROJECT_ROOT: options.projectRoot,
     AGENT_BUN_PATH: resolveBunBinaryPath()
   });
@@ -7217,15 +7276,15 @@ async function buildRuntimeToolchain(options) {
     AGENT_BUN_PATH: resolveBunBinaryPath()
   };
   for (const hookName of hookNames) {
-    await buildBinary(`packages/runtime/src/control-plane/hooks/${hookName}.ts`, resolve32(runtimeBins.hooksDir, hookName), rigSourceRoot, hookDefines);
+    await buildBinary(`packages/runtime/src/control-plane/hooks/${hookName}.ts`, resolve33(runtimeBins.hooksDir, hookName), rigSourceRoot, hookDefines);
   }
-  const pluginsDir = resolve32(options.projectRoot, "rig/plugins");
-  if (existsSync30(pluginsDir)) {
+  const pluginsDir = resolve33(options.projectRoot, "rig/plugins");
+  if (existsSync32(pluginsDir)) {
     for (const entry of readdirSync6(pluginsDir, { withFileTypes: true })) {
       const match = entry.name.match(/^(.+)\.plugin\.(ts|js|mjs|cjs)$/);
       if (!match)
         continue;
-      await buildBinary(`rig/plugins/${entry.name}`, resolve32(runtimeBins.pluginsDir, match[1]), options.projectRoot);
+      await buildBinary(`rig/plugins/${entry.name}`, resolve33(runtimeBins.pluginsDir, match[1]), options.projectRoot);
     }
   }
   await materializeRigGitBinary(options.binDir);
@@ -7235,8 +7294,8 @@ async function buildRuntimeToolchain(options) {
 }
 async function writeRuntimeManifest(config) {
   const scopeHash = sha256Hex(JSON.stringify(config.scopes));
-  const binarySha256 = sha256Hex(readFileSync15(config.binaryPath));
-  const manifestPath = resolve32(config.runtimeRoot, "manifest.json");
+  const binarySha256 = sha256Hex(readFileSync16(config.binaryPath));
+  const manifestPath = resolve33(config.runtimeRoot, "manifest.json");
   const manifest = {
     runtimeId: config.runtimeId,
     taskId: config.taskId,
@@ -7356,31 +7415,31 @@ function readFileMtimeMs(path) {
 }
 function linkRuntimeDependencyLayers(monorepoRoot, workspaceDir) {
   linkGenericNodeModulesLayers(monorepoRoot, workspaceDir);
-  const sourceNodeModules = resolve32(monorepoRoot, "humoongate", "node_modules");
-  if (!existsSync30(sourceNodeModules)) {} else {
-    const runtimeHumoongate = resolve32(workspaceDir, "humoongate");
-    if (existsSync30(resolve32(runtimeHumoongate, "package.json"))) {
-      const targetNodeModules = resolve32(runtimeHumoongate, "node_modules");
+  const sourceNodeModules = resolve33(monorepoRoot, "humoongate", "node_modules");
+  if (!existsSync32(sourceNodeModules)) {} else {
+    const runtimeHumoongate = resolve33(workspaceDir, "humoongate");
+    if (existsSync32(resolve33(runtimeHumoongate, "package.json"))) {
+      const targetNodeModules = resolve33(runtimeHumoongate, "node_modules");
       runtimeLinkDependencyLayerNative(sourceNodeModules, targetNodeModules);
     }
   }
-  const runtimeHpNext = resolve32(workspaceDir, "microservices", "hp-next-frontend", "app");
-  if (!existsSync30(resolve32(runtimeHpNext, "package.json"))) {
+  const runtimeHpNext = resolve33(workspaceDir, "microservices", "hp-next-frontend", "app");
+  if (!existsSync32(resolve33(runtimeHpNext, "package.json"))) {
     return;
   }
-  const sourceHpNextNodeModules = resolve32(monorepoRoot, "microservices", "hp-next-frontend", "app", "node_modules");
-  const sourceMonorepoNodeModules = resolve32(monorepoRoot, "node_modules");
-  const targetHpNextNodeModules = resolve32(runtimeHpNext, "node_modules");
-  if (existsSync30(sourceHpNextNodeModules)) {
+  const sourceHpNextNodeModules = resolve33(monorepoRoot, "microservices", "hp-next-frontend", "app", "node_modules");
+  const sourceMonorepoNodeModules = resolve33(monorepoRoot, "node_modules");
+  const targetHpNextNodeModules = resolve33(runtimeHpNext, "node_modules");
+  if (existsSync32(sourceHpNextNodeModules)) {
     runtimeLinkDependencyLayerNative(sourceHpNextNodeModules, targetHpNextNodeModules);
     return;
   }
-  if (existsSync30(sourceMonorepoNodeModules)) {
+  if (existsSync32(sourceMonorepoNodeModules)) {
     runtimeLinkDependencyLayerNative(sourceMonorepoNodeModules, targetHpNextNodeModules);
   }
 }
 function linkGenericNodeModulesLayers(monorepoRoot, workspaceDir) {
-  linkNodeModulesLayer(resolve32(monorepoRoot, "node_modules"), resolve32(workspaceDir, "node_modules"));
+  linkNodeModulesLayer(resolve33(monorepoRoot, "node_modules"), resolve33(workspaceDir, "node_modules"));
   for (const relativePackageDir of [
     "apps/native-app/apps/marketing",
     "apps/native-app/apps/web",
@@ -7402,15 +7461,15 @@ function linkGenericNodeModulesLayers(monorepoRoot, workspaceDir) {
     "packages/standard-plugin",
     "packages/validator-kit"
   ]) {
-    const workspacePackageDir = resolve32(workspaceDir, relativePackageDir);
-    if (!existsSync30(resolve32(workspacePackageDir, "package.json"))) {
+    const workspacePackageDir = resolve33(workspaceDir, relativePackageDir);
+    if (!existsSync32(resolve33(workspacePackageDir, "package.json"))) {
       continue;
     }
-    linkNodeModulesLayer(resolve32(monorepoRoot, relativePackageDir, "node_modules"), resolve32(workspacePackageDir, "node_modules"));
+    linkNodeModulesLayer(resolve33(monorepoRoot, relativePackageDir, "node_modules"), resolve33(workspacePackageDir, "node_modules"));
   }
 }
 function linkNodeModulesLayer(sourceDir, targetDir) {
-  if (!existsSync30(sourceDir) || existsSync30(targetDir)) {
+  if (!existsSync32(sourceDir) || existsSync32(targetDir)) {
     return;
   }
   try {
@@ -7419,25 +7478,25 @@ function linkNodeModulesLayer(sourceDir, targetDir) {
   } catch (error) {
     console.warn(`[rig-agent] Native dependency-layer linking failed for ${targetDir}; using symlink fallback: ${error instanceof Error ? error.message : String(error)}`);
   }
-  mkdirSync16(dirname14(targetDir), { recursive: true });
+  mkdirSync17(dirname15(targetDir), { recursive: true });
   symlinkSync4(sourceDir, targetDir, "dir");
 }
 function ensureRuntimeBinTrees(runtimeBinDir) {
-  const hooksDir = resolve32(runtimeBinDir, "hooks");
-  const pluginsDir = resolve32(runtimeBinDir, "plugins");
-  const validatorsDir = resolve32(runtimeBinDir, "validators");
-  mkdirSync16(hooksDir, { recursive: true });
-  mkdirSync16(pluginsDir, { recursive: true });
-  mkdirSync16(validatorsDir, { recursive: true });
+  const hooksDir = resolve33(runtimeBinDir, "hooks");
+  const pluginsDir = resolve33(runtimeBinDir, "plugins");
+  const validatorsDir = resolve33(runtimeBinDir, "validators");
+  mkdirSync17(hooksDir, { recursive: true });
+  mkdirSync17(pluginsDir, { recursive: true });
+  mkdirSync17(validatorsDir, { recursive: true });
   return { hooksDir, pluginsDir, validatorsDir };
 }
 
 // packages/runtime/src/control-plane/runtime/isolation/runner.ts
-import { existsSync as existsSync32, rmSync as rmSync12, writeFileSync as writeFileSync13 } from "fs";
-import { basename as basename9, resolve as resolve35 } from "path";
+import { existsSync as existsSync34, rmSync as rmSync12, writeFileSync as writeFileSync14 } from "fs";
+import { basename as basename9, resolve as resolve36 } from "path";
 
 // packages/runtime/src/control-plane/runtime/sandbox/backend.ts
-import { existsSync as existsSync31 } from "fs";
+import { existsSync as existsSync33 } from "fs";
 init_utils();
 
 // packages/runtime/src/control-plane/runtime/sandbox/backend-none.ts
@@ -7537,13 +7596,13 @@ async function resolveBackend(projectRoot, options) {
     depRoots
   };
   const fsContext = {
-    pathExists: (p) => existsSync31(p),
+    pathExists: (p) => existsSync33(p),
     realPath: toRealPath
   };
   if (process.platform === "darwin" && (!requestedBackend || requestedBackend === "macos-seatbelt")) {
     const seatbelt = Bun.which("sandbox-exec");
     probed.push("sandbox-exec");
-    if (seatbelt && existsSync31(seatbelt)) {
+    if (seatbelt && existsSync33(seatbelt)) {
       const SeatbeltBackendClass = loadSeatbeltBackend();
       if (SeatbeltBackendClass) {
         return {
@@ -7664,8 +7723,8 @@ init_layout();
 var SNAPSHOT_SIDECAR_READY_TIMEOUT_MS = 1e4;
 async function startRuntimeSnapshotSidecar(runtime, options = {}) {
   const instanceId = sanitizeRuntimeRefSegment(options.instanceId?.trim() || runtime.id);
-  const readyFile = resolve35(runtime.stateDir, `runtime-snapshot-sidecar-${instanceId}.ready`);
-  const requestFile = resolve35(runtime.stateDir, `runtime-snapshot-sidecar-${instanceId}.request.json`);
+  const readyFile = resolve36(runtime.stateDir, `runtime-snapshot-sidecar-${instanceId}.ready`);
+  const requestFile = resolve36(runtime.stateDir, `runtime-snapshot-sidecar-${instanceId}.request.json`);
   rmSync12(readyFile, { force: true });
   rmSync12(requestFile, { force: true });
   const sidecarBinary = resolveSnapshotSidecarBinaryPath(runtime.binDir);
@@ -7709,7 +7768,7 @@ async function startRuntimeSnapshotSidecar(runtime, options = {}) {
       rmSync12(requestFile, { force: true });
     },
     finalize: async (commandParts, exitCode) => {
-      writeFileSync13(requestFile, `${JSON.stringify({ command: commandParts, exitCode })}
+      writeFileSync14(requestFile, `${JSON.stringify({ command: commandParts, exitCode })}
 `, "utf-8");
       const [sidecarExitCode, stdout, stderr] = await Promise.all([
         proc.exited,
@@ -7773,8 +7832,8 @@ async function runInAgentRuntime(options) {
     const stdout = await new Response(proc.stdout).text();
     const stderr = await new Response(proc.stderr).text();
     try {
-      await Bun.write(resolve35(options.runtime.logsDir, "agent-stdout.log"), stdout);
-      await Bun.write(resolve35(options.runtime.logsDir, "agent-stderr.log"), stderr);
+      await Bun.write(resolve36(options.runtime.logsDir, "agent-stdout.log"), stdout);
+      await Bun.write(resolve36(options.runtime.logsDir, "agent-stderr.log"), stderr);
     } catch {}
     await snapshotSidecar.finalize(runtimeCommand, exitCode);
     return {
@@ -7806,10 +7865,10 @@ function resolveSnapshotSidecarScriptPath() {
   return resolveRuntimeSourceScriptPath("snapshot-sidecar.ts");
 }
 function resolveSnapshotSidecarBinaryPath(binDir) {
-  return resolve35(binDir, "snapshot-sidecar");
+  return resolve36(binDir, "snapshot-sidecar");
 }
 function shouldUseCompiledSnapshotSidecar(binaryPath) {
-  if (!existsSync32(binaryPath)) {
+  if (!existsSync34(binaryPath)) {
     return false;
   }
   const preference = process.env.RIG_USE_COMPILED_SNAPSHOT_SIDECAR?.trim().toLowerCase();
@@ -7824,12 +7883,12 @@ function resolveRuntimeSourceScriptPath(fileName) {
     process.env.PROJECT_RIG_ROOT?.trim()
   ].filter((value) => Boolean(value));
   for (const root of hostRoots) {
-    const candidate = resolve35(root, "packages/runtime/src/control-plane/runtime", fileName);
-    if (existsSync32(candidate)) {
+    const candidate = resolve36(root, "packages/runtime/src/control-plane/runtime", fileName);
+    if (existsSync34(candidate)) {
       return candidate;
     }
   }
-  return resolve35(import.meta.dir, "..", fileName);
+  return resolve36(import.meta.dir, "..", fileName);
 }
 function resolveBunCliInvocation() {
   if (process.env.RIG_BUN_PATH?.trim()) {
@@ -7856,7 +7915,7 @@ function resolveBunCliInvocation() {
 async function waitForSnapshotSidecarReady(readyFile, proc, stdoutTextPromise, stderrTextPromise) {
   const deadline = Date.now() + SNAPSHOT_SIDECAR_READY_TIMEOUT_MS;
   while (Date.now() < deadline) {
-    if (existsSync32(readyFile)) {
+    if (existsSync34(readyFile)) {
       return;
     }
     const exitCode = proc.exitCode;
@@ -7874,9 +7933,9 @@ var CANONICAL_MEMORY_DB_PATH2 = "rig/memory/project-memory.db";
 async function hydrateRuntimeMemory(options) {
   const snapshot = await readCanonicalMemoryDb(options.projectRoot);
   const workspaceLayout = resolveRuntimeWorkspaceLayout(options.workspaceDir);
-  const hydratedPath = resolve36(workspaceLayout.stateDir, "memory", "project-memory.db");
+  const hydratedPath = resolve37(workspaceLayout.stateDir, "memory", "project-memory.db");
   try {
-    await mkdir4(resolve36(workspaceLayout.stateDir, "memory"), { recursive: true });
+    await mkdir4(resolve37(workspaceLayout.stateDir, "memory"), { recursive: true });
     await copyFile(snapshot.dbPath, hydratedPath);
     return {
       canonicalPath: CANONICAL_MEMORY_DB_PATH2,
@@ -7891,12 +7950,12 @@ async function hydrateRuntimeMemory(options) {
   }
 }
 async function createRuntimeTaskRecordReader(options) {
-  const legacyConfigPath = resolve36(options.projectRoot, ".rig", "task-config.json");
+  const legacyConfigPath = resolve37(options.projectRoot, ".rig", "task-config.json");
   let pluginHostContext = null;
   try {
     pluginHostContext = await buildPluginHostContext(options.projectRoot);
   } catch (error) {
-    if (!existsSync33(legacyConfigPath)) {
+    if (!existsSync35(legacyConfigPath)) {
       throw error;
     }
     const message = `Plugin task source unavailable; using source-aware .rig/task-config.json compatibility path: ${error instanceof Error ? error.message : String(error)}`;
@@ -7916,7 +7975,7 @@ async function createRuntimeTaskRecordReader(options) {
       source: "plugin"
     };
   }
-  if (existsSync33(legacyConfigPath)) {
+  if (existsSync35(legacyConfigPath)) {
     const message = "Using source-aware .rig/task-config.json task source compatibility path";
     options.diagnostics?.(message);
     console.warn(message);
@@ -7933,10 +7992,10 @@ async function createRuntimeTaskRecordReader(options) {
   };
 }
 function readConfiguredTaskSourceKindHint(projectRoot) {
-  const jsonPath = resolve36(projectRoot, "rig.config.json");
-  if (existsSync33(jsonPath)) {
+  const jsonPath = resolve37(projectRoot, "rig.config.json");
+  if (existsSync35(jsonPath)) {
     try {
-      const parsed = JSON.parse(readFileSync16(jsonPath, "utf8"));
+      const parsed = JSON.parse(readFileSync17(jsonPath, "utf8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         const taskSource = parsed.taskSource;
         if (taskSource && typeof taskSource === "object" && !Array.isArray(taskSource)) {
@@ -7948,12 +8007,12 @@ function readConfiguredTaskSourceKindHint(projectRoot) {
       return null;
     }
   }
-  const tsPath = resolve36(projectRoot, "rig.config.ts");
-  if (!existsSync33(tsPath)) {
+  const tsPath = resolve37(projectRoot, "rig.config.ts");
+  if (!existsSync35(tsPath)) {
     return null;
   }
   try {
-    const source = readFileSync16(tsPath, "utf8");
+    const source = readFileSync17(tsPath, "utf8");
     const taskSourceBlock = source.match(/taskSource\s*:\s*\{[\s\S]*?\}/m)?.[0] ?? "";
     const kind = taskSourceBlock.match(/kind\s*:\s*["']([^"']+)["']/)?.[1];
     return kind ?? null;
@@ -8023,8 +8082,8 @@ async function writeRuntimeTaskConfigProjection(options) {
     ...options.taskEntry.validation && options.taskEntry.validation.length > 0 ? { validation: options.taskEntry.validation } : {},
     ...options.taskEntry.browser ? { browser: options.taskEntry.browser } : {}
   };
-  const configPath = resolve36(options.workspaceDir, ".rig", "task-config.json");
-  await mkdir4(resolve36(options.workspaceDir, ".rig"), { recursive: true });
+  const configPath = resolve37(options.workspaceDir, ".rig", "task-config.json");
+  await mkdir4(resolve37(options.workspaceDir, ".rig"), { recursive: true });
   await writeFile2(configPath, `${JSON.stringify({ [options.task.id]: entry }, null, 2)}
 `, "utf-8");
 }
@@ -8088,9 +8147,9 @@ async function ensureAgentRuntime(options) {
   }
   ensureProvisioningHostProjectRootEnv(options.projectRoot);
   const monorepoRoot = resolveMonorepoRoot3(options.projectRoot);
-  const workspaceDir = resolve36(monorepoRoot, ".worktrees", runtimeWorktreeName(options.taskId, options.id));
+  const workspaceDir = resolve37(monorepoRoot, ".worktrees", runtimeWorktreeName(options.taskId, options.id));
   const createdAt = new Date().toISOString();
-  if (!existsSync33(resolve36(monorepoRoot, ".git"))) {
+  if (!existsSync35(resolve37(monorepoRoot, ".git"))) {
     throw new Error(`Monorepo root is not a git checkout: ${monorepoRoot}`);
   }
   const taskResolution = await resolveRuntimeTaskRecord({
@@ -8125,7 +8184,7 @@ async function ensureAgentRuntime(options) {
     logsDir: overlay.logsDir,
     stateDir: overlay.stateDir,
     sessionDir: overlay.sessionDir,
-    claudeHomeDir: resolve36(workspaceLayout.homeDir, ".claude"),
+    claudeHomeDir: resolve37(workspaceLayout.homeDir, ".claude"),
     contextFile: overlay.contextPath,
     binDir: workspaceLayout.binDir,
     createdAt
@@ -8138,8 +8197,8 @@ async function ensureAgentRuntime(options) {
     projectRoot: options.projectRoot,
     workspaceDir
   });
-  mkdirSync19(runtime.binDir, { recursive: true });
-  mkdirSync19(workspaceLayout.distDir, { recursive: true });
+  mkdirSync20(runtime.binDir, { recursive: true });
+  mkdirSync20(workspaceLayout.distDir, { recursive: true });
   prepareRuntimeWorkspace(options.projectRoot, workspaceDir);
   if (options.preserveTaskArtifacts) {
     console.log(`[rig-agent] Preserving runtime task artifacts for resume of ${options.taskId}.`);
@@ -8158,7 +8217,7 @@ async function ensureAgentRuntime(options) {
       runtimeId: options.id
     }),
     workspaceDir,
-    artifactRoot: resolve36(workspaceDir, "artifacts", options.taskId),
+    artifactRoot: resolve37(workspaceDir, "artifacts", options.taskId),
     hostProjectRoot: options.projectRoot,
     monorepoMainRoot: monorepoRoot,
     monorepoBaseRef: baseRef,
@@ -8174,8 +8233,8 @@ async function ensureAgentRuntime(options) {
     stateDir: overlay.stateDir,
     logsDir: overlay.logsDir,
     sessionDir: overlay.sessionDir,
-    sessionFile: resolve36(overlay.sessionDir, "session.json"),
-    policyFile: resolve36(options.projectRoot, "rig/policy/policy.json"),
+    sessionFile: resolve37(overlay.sessionDir, "session.json"),
+    policyFile: resolve37(options.projectRoot, "rig/policy/policy.json"),
     binDir: runtime.binDir,
     createdAt,
     memory
@@ -8186,9 +8245,9 @@ async function ensureAgentRuntime(options) {
     task: taskResolution.task,
     taskEntry
   });
-  const manifestPath = resolve36(runtimeRoot, "manifest.json");
+  const manifestPath = resolve37(runtimeRoot, "manifest.json");
   const bakedScopeHash = sha256Hex(JSON.stringify(taskEntry.scope || []));
-  const runtimeAgentBinary = resolve36(runtime.binDir, "rig-agent");
+  const runtimeAgentBinary = resolve37(runtime.binDir, "rig-agent");
   await ensureRigGitBinaryPath();
   const bakedInfoOutput = await captureTaskInfoOutput({
     projectRoot: options.projectRoot,
@@ -8205,8 +8264,8 @@ async function ensureAgentRuntime(options) {
   });
   rmSync13(runtime.binDir, { recursive: true, force: true });
   rmSync13(workspaceLayout.distDir, { recursive: true, force: true });
-  mkdirSync19(runtime.binDir, { recursive: true });
-  mkdirSync19(workspaceLayout.distDir, { recursive: true });
+  mkdirSync20(runtime.binDir, { recursive: true });
+  mkdirSync20(workspaceLayout.distDir, { recursive: true });
   await buildRuntimeToolchain({
     projectRoot: options.projectRoot,
     workspaceDir,
@@ -8243,9 +8302,9 @@ async function ensureAgentRuntime(options) {
     workspaceDir,
     taskEntry
   });
-  const sandboxDir = resolve36(runtimeRoot, "sandbox");
+  const sandboxDir = resolve37(runtimeRoot, "sandbox");
   await mkdir4(sandboxDir, { recursive: true });
-  await writeFile2(resolve36(runtimeRoot, "runtime.json"), JSON.stringify({
+  await writeFile2(resolve37(runtimeRoot, "runtime.json"), JSON.stringify({
     id: options.id,
     taskId: options.taskId,
     mode: "worktree",
@@ -8399,12 +8458,12 @@ ${result.stderr.trim()}` : ""}`);
 }
 function resolveTaskCommand(projectRoot, action, taskId, hostProjectRoot = projectRoot) {
   try {
-    const compiledRig = resolve37(resolveRigLayout(projectRoot).binDir, "rig");
-    if (existsSync34(compiledRig)) {
+    const compiledRig = resolve38(resolveRigLayout(projectRoot).binDir, "rig");
+    if (existsSync36(compiledRig)) {
       return [compiledRig, "task", action, "--task", taskId];
     }
   } catch {}
-  return ["bun", "run", resolve37(hostProjectRoot, "packages/cli/bin/rig.ts"), "task", action, "--task", taskId];
+  return ["bun", "run", resolve38(hostProjectRoot, "packages/cli/bin/rig.ts"), "task", action, "--task", taskId];
 }
 function rankTasks(projectRoot, snapshot) {
   const readyTaskIds = listReadyTaskIdsFromTracker(snapshot);