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

package/dist/src/control-plane/hooks/submodule-branch.js

@@ -121,13 +121,13 @@ var init_utils = __esm(() => {
 
 // packages/runtime/src/control-plane/hooks/task-runtime-start.ts
 init_layout();
-import { existsSync as existsSync36 } from "fs";
-import { resolve as resolve37 } from "path";
+import { existsSync as existsSync38 } from "fs";
+import { resolve as resolve38 } from "path";
 import { resolveProjectRoot } from "@rig/hook-kit";
 
 // packages/runtime/src/control-plane/native/git-ops.ts
-import { existsSync as existsSync23, lstatSync, mkdirSync as mkdirSync10, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname10, isAbsolute as isAbsolute2, resolve as resolve24 } from "path";
+import { existsSync as existsSync25, lstatSync, mkdirSync as mkdirSync11, readFileSync as readFileSync13, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname11, isAbsolute as isAbsolute2, resolve as resolve25 } from "path";
 
 // packages/runtime/src/control-plane/runtime/baked-secrets.ts
 import { existsSync as existsSync2, readFileSync } from "fs";
@@ -432,8 +432,8 @@ function isAgentRuntimeContextPath(path) {
 }
 
 // packages/runtime/src/control-plane/native/task-ops.ts
-import { appendFileSync, existsSync as existsSync22, mkdirSync as mkdirSync9, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "fs";
-import { resolve as resolve23 } from "path";
+import { appendFileSync, existsSync as existsSync24, mkdirSync as mkdirSync10, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "fs";
+import { resolve as resolve24 } from "path";
 
 // packages/runtime/src/build-time-config.ts
 function normalizeBuildConfig(value) {
@@ -1364,6 +1364,8 @@ function buildBrowserGuidanceLines(browser) {
 }
 
 // packages/runtime/src/control-plane/plugin-host-context.ts
+import { existsSync as existsSync13 } from "fs";
+import { resolve as resolvePath } from "path";
 import { createPluginHost } from "@rig/core";
 import { loadConfig } from "@rig/core/load-config";
 
@@ -1711,6 +1713,55 @@ async function materializeSkills(projectRoot, entries) {
   return written;
 }
 
+// packages/runtime/src/control-plane/pi-settings-materializer.ts
+import { existsSync as existsSync12, mkdirSync as mkdirSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname7, resolve as resolve12 } 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 (!existsSync12(path))
+    return fallback;
+  try {
+    return JSON.parse(readFileSync6(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 = resolve12(projectRoot, SETTINGS_RELATIVE_PATH);
+  const managedRecordPath = resolve12(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 || existsSync12(settingsPath)) {
+    const nextSettings = { ...settings };
+    if (nextPackages.length > 0) {
+      nextSettings.packages = nextPackages;
+    } else {
+      delete nextSettings.packages;
+    }
+    mkdirSync7(dirname7(settingsPath), { recursive: true });
+    writeFileSync5(settingsPath, `${JSON.stringify(nextSettings, null, 2)}
+`, "utf-8");
+  }
+  mkdirSync7(dirname7(managedRecordPath), { recursive: true });
+  writeFileSync5(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;
@@ -1758,6 +1809,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 || existsSync13(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,
@@ -1771,12 +1830,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 existsSync13, readFileSync as readFileSync7, readdirSync as readdirSync2, statSync as statSync2, writeFileSync as writeFileSync5 } from "fs";
-import { basename as basename4, join as join2, resolve as resolve13 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync8, readdirSync as readdirSync2, statSync as statSync2, writeFileSync as writeFileSync6 } from "fs";
+import { basename as basename4, join as join2, resolve as resolve14 } from "path";
 
 // packages/runtime/src/control-plane/tasks/legacy-task-config-source.ts
-import { existsSync as existsSync12, readFileSync as readFileSync6 } from "fs";
-import { resolve as resolve12 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync7 } from "fs";
+import { resolve as resolve13 } from "path";
 
 // packages/runtime/src/control-plane/tasks/task-record-reader.ts
 async function findTaskById(reader, id) {
@@ -1799,7 +1858,7 @@ class LegacyTaskConfigReadError extends Error {
   }
 }
 function createLegacyTaskConfigRecordReader(projectRoot, options = {}) {
-  const configPath = options.configPath ?? resolve12(projectRoot, ".rig", "task-config.json");
+  const configPath = options.configPath ?? resolve13(projectRoot, ".rig", "task-config.json");
   const reader = {
     async listTasks() {
       return readLegacyTaskRecords(projectRoot, configPath);
@@ -1810,8 +1869,8 @@ function createLegacyTaskConfigRecordReader(projectRoot, options = {}) {
   };
   return reader;
 }
-function readLegacyTaskRecords(projectRoot, configPath = resolve12(projectRoot, ".rig", "task-config.json")) {
-  if (!existsSync12(configPath)) {
+function readLegacyTaskRecords(projectRoot, configPath = resolve13(projectRoot, ".rig", "task-config.json")) {
+  if (!existsSync14(configPath)) {
     return [];
   }
   const rawConfig = readLegacyTaskConfigJson(projectRoot, configPath);
@@ -1819,7 +1878,7 @@ function readLegacyTaskRecords(projectRoot, configPath = resolve12(projectRoot,
 }
 function readLegacyTaskConfigJson(projectRoot, configPath) {
   try {
-    const parsed = JSON.parse(readFileSync6(configPath, "utf8"));
+    const parsed = JSON.parse(readFileSync7(configPath, "utf8"));
     if (isPlainRecord(parsed)) {
       return parsed;
     }
@@ -1903,7 +1962,7 @@ function isPlainRecord(candidate) {
 var STATUS_LABELS = new Set(["ready", "blocked", "in-progress", "under-review", "failed", "cancelled"]);
 var FILE_TASK_PATTERN = /\.(task\.)?json$/;
 function createSourceAwareTaskConfigRecordReader(projectRoot, options = {}) {
-  const configPath = options.configPath ?? resolve13(projectRoot, ".rig", "task-config.json");
+  const configPath = options.configPath ?? resolve14(projectRoot, ".rig", "task-config.json");
   const legacy = createLegacyTaskConfigRecordReader(projectRoot, { configPath });
   const spawnFn = options.spawn ?? spawnSync;
   const ghBinary = options.ghBinary ?? "gh";
@@ -1986,10 +2045,10 @@ function readMaterializedTaskMetadata(entry) {
   return metadata;
 }
 function readConfiguredFilesTaskSourcePath(projectRoot) {
-  const jsonPath = resolve13(projectRoot, "rig.config.json");
-  if (existsSync13(jsonPath)) {
+  const jsonPath = resolve14(projectRoot, "rig.config.json");
+  if (existsSync15(jsonPath)) {
     try {
-      const parsed = JSON.parse(readFileSync7(jsonPath, "utf8"));
+      const parsed = JSON.parse(readFileSync8(jsonPath, "utf8"));
       if (isPlainRecord2(parsed) && isPlainRecord2(parsed.taskSource)) {
         const source = parsed.taskSource;
         return source.kind === "files" && typeof source.path === "string" ? source.path : null;
@@ -1998,12 +2057,12 @@ function readConfiguredFilesTaskSourcePath(projectRoot) {
       return null;
     }
   }
-  const tsPath = resolve13(projectRoot, "rig.config.ts");
-  if (!existsSync13(tsPath)) {
+  const tsPath = resolve14(projectRoot, "rig.config.ts");
+  if (!existsSync15(tsPath)) {
     return null;
   }
   try {
-    const source = readFileSync7(tsPath, "utf8");
+    const source = readFileSync8(tsPath, "utf8");
     const taskSourceBlock = source.match(/taskSource\s*:\s*\{[\s\S]*?\}/m)?.[0] ?? "";
     const kind = taskSourceBlock.match(/kind\s*:\s*["']([^"']+)["']/)?.[1];
     if (kind !== "files") {
@@ -2023,10 +2082,10 @@ function readRawTaskEntry(configPath, taskId) {
   return isPlainRecord2(entry) ? entry : null;
 }
 function readRawTaskConfig(configPath) {
-  if (!existsSync13(configPath)) {
+  if (!existsSync15(configPath)) {
     return null;
   }
-  const parsed = JSON.parse(readFileSync7(configPath, "utf8"));
+  const parsed = JSON.parse(readFileSync8(configPath, "utf8"));
   return isPlainRecord2(parsed) ? parsed : null;
 }
 function stripLegacyTaskConfigMetadata2(raw) {
@@ -2034,8 +2093,8 @@ function stripLegacyTaskConfigMetadata2(raw) {
   return tasks;
 }
 function listFileBackedTasks(projectRoot, sourcePath) {
-  const directory = resolve13(projectRoot, sourcePath);
-  if (!existsSync13(directory)) {
+  const directory = resolve14(projectRoot, sourcePath);
+  if (!existsSync15(directory)) {
     return [];
   }
   const tasks = [];
@@ -2050,11 +2109,11 @@ function listFileBackedTasks(projectRoot, sourcePath) {
   return tasks;
 }
 function readFileBackedTask(projectRoot, sourcePath, taskId, rawEntry) {
-  const file = findFileBackedTaskFile(resolve13(projectRoot, sourcePath), taskId);
+  const file = findFileBackedTaskFile(resolve14(projectRoot, sourcePath), taskId);
   if (!file) {
     return null;
   }
-  const raw = JSON.parse(readFileSync7(file, "utf8"));
+  const raw = JSON.parse(readFileSync8(file, "utf8"));
   if (!isPlainRecord2(raw)) {
     return null;
   }
@@ -2067,7 +2126,7 @@ function readFileBackedTask(projectRoot, sourcePath, taskId, rawEntry) {
   };
 }
 function findFileBackedTaskFile(directory, taskId) {
-  if (!existsSync13(directory)) {
+  if (!existsSync15(directory)) {
     return null;
   }
   for (const name of readdirSync2(directory)) {
@@ -2077,7 +2136,7 @@ function findFileBackedTaskFile(directory, taskId) {
     try {
       if (!statSync2(file).isFile())
         continue;
-      const raw = JSON.parse(readFileSync7(file, "utf8"));
+      const raw = JSON.parse(readFileSync8(file, "utf8"));
       const inferredId = basename4(file).replace(FILE_TASK_PATTERN, "");
       const id = isPlainRecord2(raw) && typeof raw.id === "string" ? raw.id : inferredId;
       if (id === taskId) {
@@ -2237,8 +2296,8 @@ async function readConfiguredTaskSourceTask(projectRoot, taskId) {
 }
 
 // packages/runtime/src/control-plane/native/task-state.ts
-import { existsSync as existsSync19, readFileSync as readFileSync10, readdirSync as readdirSync3, statSync as statSync4, writeFileSync as writeFileSync6 } from "fs";
-import { basename as basename6, resolve as resolve19 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync11, readdirSync as readdirSync3, statSync as statSync4, writeFileSync as writeFileSync7 } from "fs";
+import { basename as basename6, resolve as resolve20 } from "path";
 
 // packages/runtime/src/control-plane/state-sync/types.ts
 var SUPPORTED_TASK_STATE_SCHEMA_VERSION = 1;
@@ -2346,22 +2405,22 @@ function readTaskStateMetadataEnvelope(raw) {
   };
 }
 // packages/runtime/src/control-plane/state-sync/read.ts
-import { existsSync as existsSync18, readFileSync as readFileSync9 } from "fs";
-import { resolve as resolve18 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync10 } from "fs";
+import { resolve as resolve19 } from "path";
 
 // packages/runtime/src/control-plane/native/utils.ts
 init_layout();
 import { ptr as ptr2 } from "bun:ffi";
-import { existsSync as existsSync15, readFileSync as readFileSync8 } from "fs";
-import { resolve as resolve15 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync9 } from "fs";
+import { resolve as resolve16 } from "path";
 
 // packages/runtime/src/control-plane/native/runtime-native.ts
 import { dlopen, ptr, suffix, toBuffer } from "bun:ffi";
-import { copyFileSync as copyFileSync4, existsSync as existsSync14, mkdirSync as mkdirSync7, renameSync as renameSync2, rmSync as rmSync6, statSync as statSync3 } from "fs";
+import { copyFileSync as copyFileSync4, existsSync as existsSync16, mkdirSync as mkdirSync8, renameSync as renameSync2, rmSync as rmSync6, statSync as statSync3 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { dirname as dirname7, resolve as resolve14 } from "path";
-var sharedNativeRuntimeOutputDir = resolve14(tmpdir4(), "rig-native");
-var sharedNativeRuntimeOutputPath = resolve14(sharedNativeRuntimeOutputDir, `runtime-native-${process.platform}-${process.arch}.${suffix}`);
+import { dirname as dirname8, resolve as resolve15 } from "path";
+var sharedNativeRuntimeOutputDir = resolve15(tmpdir4(), "rig-native");
+var sharedNativeRuntimeOutputPath = resolve15(sharedNativeRuntimeOutputDir, `runtime-native-${process.platform}-${process.arch}.${suffix}`);
 var colocatedNativeRuntimeFileName = `runtime-native.${suffix}`;
 var nativeRuntimeLibrary = await loadNativeRuntimeLibrary();
 function requireNativeRuntimeLibrary(feature) {
@@ -2392,16 +2451,16 @@ async function ensureNativeRuntimeLibraryPath(outputPath = sharedNativeRuntimeOu
   if (await buildNativeRuntimeLibrary(outputPath, options)) {
     return outputPath;
   }
-  return !options.force && existsSync14(outputPath) ? outputPath : null;
+  return !options.force && existsSync16(outputPath) ? outputPath : null;
 }
 async function materializeNativeRuntimeLibrary(targetDir) {
   const sourcePath = await ensureNativeRuntimeLibraryPath();
   if (!sourcePath) {
     return null;
   }
-  const targetPath = resolve14(targetDir, colocatedNativeRuntimeFileName);
-  mkdirSync7(targetDir, { recursive: true });
-  const needsCopy = !existsSync14(targetPath) || statSync3(sourcePath).mtimeMs > statSync3(targetPath).mtimeMs;
+  const targetPath = resolve15(targetDir, colocatedNativeRuntimeFileName);
+  mkdirSync8(targetDir, { recursive: true });
+  const needsCopy = !existsSync16(targetPath) || statSync3(sourcePath).mtimeMs > statSync3(targetPath).mtimeMs;
   if (needsCopy) {
     copyFileSync4(sourcePath, targetPath);
   }
@@ -2412,7 +2471,7 @@ async function loadNativeRuntimeLibrary() {
     return null;
   }
   for (const candidate of nativeRuntimeLibraryCandidates()) {
-    if (!candidate || !existsSync14(candidate)) {
+    if (!candidate || !existsSync16(candidate)) {
       continue;
     }
     const loaded = tryDlopenNativeRuntimeLibrary(candidate);
@@ -2428,12 +2487,12 @@ async function loadNativeRuntimeLibrary() {
 }
 function nativePackageLibraryCandidates(fromDir, names) {
   const candidates = [];
-  let cursor = resolve14(fromDir);
+  let cursor = resolve15(fromDir);
   for (let index = 0;index < 8; index += 1) {
     for (const name of names) {
-      candidates.push(resolve14(cursor, "native", `${process.platform}-${process.arch}`, name), resolve14(cursor, "native", `${process.platform}-${process.arch}`, "lib", name), resolve14(cursor, "native", name), resolve14(cursor, "native", "lib", name));
+      candidates.push(resolve15(cursor, "native", `${process.platform}-${process.arch}`, name), resolve15(cursor, "native", `${process.platform}-${process.arch}`, "lib", name), resolve15(cursor, "native", name), resolve15(cursor, "native", "lib", name));
     }
-    const parent = dirname7(cursor);
+    const parent = dirname8(cursor);
     if (parent === cursor)
       break;
     cursor = parent;
@@ -2442,27 +2501,27 @@ function nativePackageLibraryCandidates(fromDir, names) {
 }
 function nativeRuntimeLibraryCandidates() {
   const explicit = process.env.RIG_NATIVE_RUNTIME_LIB?.trim() || "";
-  const execDir = process.execPath?.trim() ? dirname7(process.execPath.trim()) : "";
+  const execDir = process.execPath?.trim() ? dirname8(process.execPath.trim()) : "";
   const platformSpecific = `runtime-native-${process.platform}-${process.arch}.${suffix}`;
   return [...new Set([
     explicit,
     ...nativePackageLibraryCandidates(import.meta.dir, [colocatedNativeRuntimeFileName, platformSpecific]),
-    execDir ? resolve14(execDir, colocatedNativeRuntimeFileName) : "",
-    execDir ? resolve14(execDir, platformSpecific) : "",
-    execDir ? resolve14(execDir, "..", colocatedNativeRuntimeFileName) : "",
-    execDir ? resolve14(execDir, "..", platformSpecific) : "",
-    execDir ? resolve14(execDir, "lib", colocatedNativeRuntimeFileName) : "",
-    execDir ? resolve14(execDir, "..", "lib", colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve15(execDir, colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve15(execDir, platformSpecific) : "",
+    execDir ? resolve15(execDir, "..", colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve15(execDir, "..", platformSpecific) : "",
+    execDir ? resolve15(execDir, "lib", colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve15(execDir, "..", "lib", colocatedNativeRuntimeFileName) : "",
     sharedNativeRuntimeOutputPath
   ].filter(Boolean))];
 }
 function resolveNativeRuntimeSourcePath() {
   const explicit = process.env.RIG_NATIVE_RUNTIME_SOURCE?.trim();
-  if (explicit && existsSync14(explicit)) {
+  if (explicit && existsSync16(explicit)) {
     return explicit;
   }
-  const bundled = resolve14(import.meta.dir, "../../../native/snapshot.zig");
-  return existsSync14(bundled) ? bundled : null;
+  const bundled = resolve15(import.meta.dir, "../../../native/snapshot.zig");
+  return existsSync16(bundled) ? bundled : null;
 }
 function resolveNativeRuntimeSidecarSourcePath() {
   const envRoots = [
@@ -2475,17 +2534,17 @@ function resolveNativeRuntimeSidecarSourcePath() {
       "packages/runtime/src/control-plane/native/runtime-native-sidecar.ts",
       "packages/runtime/dist/src/control-plane/native/runtime-native-sidecar.js"
     ]) {
-      const candidate = resolve14(root, relative);
-      if (existsSync14(candidate)) {
+      const candidate = resolve15(root, relative);
+      if (existsSync16(candidate)) {
         return candidate;
       }
     }
   }
   for (const localCandidate of [
-    resolve14(import.meta.dir, "runtime-native-sidecar.js"),
-    resolve14(import.meta.dir, "runtime-native-sidecar.ts")
+    resolve15(import.meta.dir, "runtime-native-sidecar.js"),
+    resolve15(import.meta.dir, "runtime-native-sidecar.ts")
   ]) {
-    if (existsSync14(localCandidate))
+    if (existsSync16(localCandidate))
       return localCandidate;
   }
   return null;
@@ -2501,8 +2560,8 @@ async function buildNativeRuntimeLibrary(outputPath, options = {}) {
   }
   const tempOutputPath = `${outputPath}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    mkdirSync7(dirname7(outputPath), { recursive: true });
-    const needsBuild = options.force === true || !existsSync14(outputPath) || statSync3(sourcePath).mtimeMs > statSync3(outputPath).mtimeMs;
+    mkdirSync8(dirname8(outputPath), { recursive: true });
+    const needsBuild = options.force === true || !existsSync16(outputPath) || statSync3(sourcePath).mtimeMs > statSync3(outputPath).mtimeMs;
     if (!needsBuild) {
       return true;
     }
@@ -2520,7 +2579,7 @@ async function buildNativeRuntimeLibrary(outputPath, options = {}) {
       stderr: "pipe"
     });
     const exitCode = await build.exited;
-    if (exitCode !== 0 || !existsSync14(tempOutputPath)) {
+    if (exitCode !== 0 || !existsSync16(tempOutputPath)) {
       rmSync6(tempOutputPath, { force: true });
       return false;
     }
@@ -2646,11 +2705,11 @@ function runCapture(command, cwd, env) {
   };
 }
 function readJsonFile(path, fallback) {
-  if (!existsSync15(path)) {
+  if (!existsSync17(path)) {
     return fallback;
   }
   try {
-    return JSON.parse(readFileSync8(path, "utf-8"));
+    return JSON.parse(readFileSync9(path, "utf-8"));
   } catch {
     return fallback;
   }
@@ -2664,31 +2723,31 @@ function unique(values) {
 function resolveHarnessPaths(projectRoot) {
   const hasRuntimeWorkspace = Boolean(process.env.RIG_TASK_WORKSPACE?.trim());
   const monorepoRoot = resolveMonorepoRoot2(projectRoot);
-  const harnessRoot = resolve15(projectRoot, "rig");
-  const stateRoot = resolve15(projectRoot, ".rig");
+  const harnessRoot = resolve16(projectRoot, "rig");
+  const stateRoot = resolve16(projectRoot, ".rig");
   const layout = hasRuntimeWorkspace ? resolveRigLayout(projectRoot) : null;
-  const stateDir = layout?.stateDir ?? resolve15(stateRoot, "state");
-  const logsDir = layout?.logsDir ?? resolve15(stateRoot, "logs");
-  const artifactsDir = layout?.artifactsRoot ?? resolve15(monorepoRoot, "artifacts");
-  const taskConfigPath = layout?.taskConfigPath ?? resolve15(monorepoRoot, ".rig", "task-config.json");
-  const binDir = layout?.binDir ?? resolve15(stateRoot, "bin");
+  const stateDir = layout?.stateDir ?? resolve16(stateRoot, "state");
+  const logsDir = layout?.logsDir ?? resolve16(stateRoot, "logs");
+  const artifactsDir = layout?.artifactsRoot ?? resolve16(monorepoRoot, "artifacts");
+  const taskConfigPath = layout?.taskConfigPath ?? resolve16(monorepoRoot, ".rig", "task-config.json");
+  const binDir = layout?.binDir ?? resolve16(stateRoot, "bin");
   return {
     harnessRoot,
     stateDir: process.env.RIG_STATE_DIR || stateDir,
     artifactsDir,
     logsDir: process.env.RIG_LOGS_DIR || logsDir,
     binDir,
-    hooksDir: resolve15(harnessRoot, "hooks"),
-    validationDir: resolve15(harnessRoot, "validation"),
+    hooksDir: resolve16(harnessRoot, "hooks"),
+    validationDir: resolve16(harnessRoot, "validation"),
     taskConfigPath,
-    sessionPath: process.env.RIG_SESSION_FILE || resolve15(stateRoot, "session", "session.json"),
+    sessionPath: process.env.RIG_SESSION_FILE || resolve16(stateRoot, "session", "session.json"),
     monorepoRoot,
-    tsApiTestsDir: process.env.TS_API_TESTS_DIR || resolve15(monorepoRoot, "TSAPITests"),
-    taskRepoCommitsPath: resolve15(stateDir, "task-repo-commits.json"),
-    baseRepoPinsPath: resolve15(stateDir, "base-repo-pins.json"),
-    failedApproachesPath: resolve15(stateDir, "failed_approaches.md"),
-    agentProfilePath: resolve15(stateDir, "agent-profile.json"),
-    reviewProfilePath: resolve15(stateDir, "review-profile.json")
+    tsApiTestsDir: process.env.TS_API_TESTS_DIR || resolve16(monorepoRoot, "TSAPITests"),
+    taskRepoCommitsPath: resolve16(stateDir, "task-repo-commits.json"),
+    baseRepoPinsPath: resolve16(stateDir, "base-repo-pins.json"),
+    failedApproachesPath: resolve16(stateDir, "failed_approaches.md"),
+    agentProfilePath: resolve16(stateDir, "agent-profile.json"),
+    reviewProfilePath: resolve16(stateDir, "review-profile.json")
   };
 }
 function normalizeRelativeScopePath(inputPath) {
@@ -2750,35 +2809,35 @@ function createNativeScopeMatcher() {
 }
 
 // packages/runtime/src/control-plane/state-sync/repo.ts
-import { existsSync as existsSync17 } from "fs";
-import { resolve as resolve17 } from "path";
+import { existsSync as existsSync19 } from "fs";
+import { resolve as resolve18 } from "path";
 
 // packages/runtime/src/control-plane/repos/layout.ts
 init_layout();
-import { existsSync as existsSync16 } from "fs";
-import { basename as basename5, dirname as dirname8, join as join3, resolve as resolve16 } from "path";
+import { existsSync as existsSync18 } from "fs";
+import { basename as basename5, dirname as dirname9, join as join3, resolve as resolve17 } from "path";
 function resolveRepoStateDir(projectRoot) {
-  const normalizedProjectRoot = resolve16(projectRoot);
-  const projectParent = dirname8(normalizedProjectRoot);
+  const normalizedProjectRoot = resolve17(projectRoot);
+  const projectParent = dirname9(normalizedProjectRoot);
   if (basename5(projectParent) === ".worktrees") {
-    const ownerRoot = dirname8(projectParent);
-    const ownerHasRepoMarkers = existsSync16(resolve16(ownerRoot, ".git")) || existsSync16(resolve16(ownerRoot, ".rig", "state"));
+    const ownerRoot = dirname9(projectParent);
+    const ownerHasRepoMarkers = existsSync18(resolve17(ownerRoot, ".git")) || existsSync18(resolve17(ownerRoot, ".rig", "state"));
     if (ownerHasRepoMarkers) {
-      return resolve16(ownerRoot, ".rig", "state");
+      return resolve17(ownerRoot, ".rig", "state");
     }
   }
-  return resolve16(projectRoot, ".rig", "state");
+  return resolve17(projectRoot, ".rig", "state");
 }
 function resolveManagedRepoLayout(projectRoot, repoId) {
-  const normalizedProjectRoot = resolve16(projectRoot);
+  const normalizedProjectRoot = resolve17(projectRoot);
   const entry = getManagedRepoEntry(repoId);
   const stateDir = resolveRepoStateDir(normalizedProjectRoot);
   const metadataRelativePath = join3("repos", entry.id);
-  const metadataRoot = resolve16(stateDir, metadataRelativePath);
+  const metadataRoot = resolve17(stateDir, metadataRelativePath);
   const runtimeWorkspace = process.env.RIG_TASK_WORKSPACE?.trim();
-  const runsInsideTaskWorktree = runtimeWorkspace && resolve16(runtimeWorkspace) === normalizedProjectRoot || basename5(dirname8(normalizedProjectRoot)) === ".worktrees";
+  const runsInsideTaskWorktree = runtimeWorkspace && resolve17(runtimeWorkspace) === normalizedProjectRoot || basename5(dirname9(normalizedProjectRoot)) === ".worktrees";
   const isPrimaryManagedRepo = listManagedRepoEntries()[0]?.id === repoId;
-  const checkoutRoot = isPrimaryManagedRepo && runsInsideTaskWorktree ? resolveMonorepoRoot(normalizedProjectRoot) : entry.checkoutEnvVar && process.env[entry.checkoutEnvVar]?.trim() ? resolve16(process.env[entry.checkoutEnvVar].trim()) : resolve16(normalizedProjectRoot, entry.alias);
+  const checkoutRoot = isPrimaryManagedRepo && runsInsideTaskWorktree ? resolveMonorepoRoot(normalizedProjectRoot) : entry.checkoutEnvVar && process.env[entry.checkoutEnvVar]?.trim() ? resolve17(process.env[entry.checkoutEnvVar].trim()) : resolve17(normalizedProjectRoot, entry.alias);
   return {
     projectRoot: normalizedProjectRoot,
     repoId: entry.id,
@@ -2786,12 +2845,12 @@ function resolveManagedRepoLayout(projectRoot, repoId) {
     defaultBranch: entry.defaultBranch,
     remoteUrl: entry.remoteEnvVar && process.env[entry.remoteEnvVar]?.trim() ? process.env[entry.remoteEnvVar].trim() : entry.defaultRemoteUrl,
     checkoutRoot,
-    worktreesRoot: resolve16(checkoutRoot, ".worktrees"),
+    worktreesRoot: resolve17(checkoutRoot, ".worktrees"),
     stateDir,
     metadataRoot,
     metadataRelativePath,
-    mirrorRoot: resolve16(metadataRoot, "mirror.git"),
-    mirrorStatePath: resolve16(metadataRoot, "mirror-state.json"),
+    mirrorRoot: resolve17(metadataRoot, "mirror.git"),
+    mirrorStatePath: resolve17(metadataRoot, "mirror-state.json"),
     mirrorStateRelativePath: join3(metadataRelativePath, "mirror-state.json")
   };
 }
@@ -2813,7 +2872,7 @@ function resolveTrackerRepoPath(projectRoot) {
   const monorepoRoot = resolveMonorepoRoot2(projectRoot);
   try {
     const layout = resolveMonorepoRepoLayout(projectRoot);
-    if (existsSync17(resolve17(layout.mirrorRoot, "HEAD"))) {
+    if (existsSync19(resolve18(layout.mirrorRoot, "HEAD"))) {
       return layout.mirrorRoot;
     }
   } catch {}
@@ -2824,8 +2883,8 @@ function resolveTrackerRepoPath(projectRoot) {
 var DEFAULT_READ_DEPS = {
   fetchRef: nativeFetchRef,
   readBlobAtRef: nativeReadBlobAtRef,
-  exists: existsSync18,
-  readFile: (path) => readFileSync9(path, "utf8")
+  exists: existsSync20,
+  readFile: (path) => readFileSync10(path, "utf8")
 };
 function parseIssueStatus(rawStatus) {
   const normalized = normalizeTaskLifecycleStatus(rawStatus);
@@ -2906,12 +2965,12 @@ function shouldPreferLocalTrackerState(options) {
   if (runtimeContextPath) {
     return true;
   }
-  return existsSync18(resolve18(runtimeWorkspace, ".rig", "runtime-context.json"));
+  return existsSync20(resolve19(runtimeWorkspace, ".rig", "runtime-context.json"));
 }
 function readLocalTrackerState(projectRoot, deps) {
   const monorepoRoot = resolveMonorepoRoot2(projectRoot);
-  const issuesPath = resolve18(monorepoRoot, ".beads", "issues.jsonl");
-  const taskStatePath = resolve18(monorepoRoot, ".beads", "task-state.json");
+  const issuesPath = resolve19(monorepoRoot, ".beads", "issues.jsonl");
+  const taskStatePath = resolve19(monorepoRoot, ".beads", "task-state.json");
   return projectSyncedTrackerSnapshot({
     source: "local",
     issuesBaseOid: null,
@@ -2973,7 +3032,7 @@ function readValidationDescriptions(projectRoot) {
   return readValidationDescriptionMap(raw);
 }
 function readSourceValidationDescriptions(projectRoot) {
-  const rootRaw = readJsonFile(resolve19(projectRoot, "rig", "task-config.json"), {});
+  const rootRaw = readJsonFile(resolve20(projectRoot, "rig", "task-config.json"), {});
   const sourcePath = findSourceTaskConfigPath(projectRoot);
   const sourceRaw = sourcePath ? readJsonFile(sourcePath, {}) : {};
   const rootDescriptions = readValidationDescriptionMap(rootRaw);
@@ -3049,15 +3108,15 @@ function readValidationDescriptionsFromMeta(meta) {
   return meta.validation_descriptions;
 }
 function readLocalSourceTaskStateEnvelope(projectRoot) {
-  const taskStatePath = resolve19(resolveMonorepoRoot2(projectRoot), ".beads", "task-state.json");
+  const taskStatePath = resolve20(resolveMonorepoRoot2(projectRoot), ".beads", "task-state.json");
   return readTaskStateMetadataEnvelope(readJsonFile(taskStatePath, {}));
 }
 function readLocalSourceTaskLifecycleStatus(projectRoot, taskId) {
-  const issuesPath = resolve19(resolveMonorepoRoot2(projectRoot), ".beads", "issues.jsonl");
-  if (!existsSync19(issuesPath)) {
+  const issuesPath = resolve20(resolveMonorepoRoot2(projectRoot), ".beads", "issues.jsonl");
+  if (!existsSync21(issuesPath)) {
     return null;
   }
-  for (const line of readFileSync10(issuesPath, "utf8").split(/\r?\n/)) {
+  for (const line of readFileSync11(issuesPath, "utf8").split(/\r?\n/)) {
     const trimmed = line.trim();
     if (!trimmed) {
       continue;
@@ -3098,25 +3157,25 @@ function lookupTask(projectRoot, input) {
 function artifactDirForId(projectRoot, id) {
   const workspaceDir = process.env.RIG_TASK_WORKSPACE?.trim();
   if (workspaceDir) {
-    const worktreeArtifacts = resolve19(workspaceDir, "artifacts", id);
-    if (existsSync19(worktreeArtifacts) || existsSync19(resolve19(workspaceDir, "artifacts"))) {
+    const worktreeArtifacts = resolve20(workspaceDir, "artifacts", id);
+    if (existsSync21(worktreeArtifacts) || existsSync21(resolve20(workspaceDir, "artifacts"))) {
       return worktreeArtifacts;
     }
   }
   try {
     const paths = resolveHarnessPaths(projectRoot);
-    return resolve19(paths.artifactsDir, id);
+    return resolve20(paths.artifactsDir, id);
   } catch {
-    return resolve19(resolveMonorepoRoot2(projectRoot), "artifacts", id);
+    return resolve20(resolveMonorepoRoot2(projectRoot), "artifacts", id);
   }
 }
 function resolveTaskConfigPath(projectRoot) {
   const paths = resolveHarnessPaths(projectRoot);
-  if (existsSync19(paths.taskConfigPath)) {
+  if (existsSync21(paths.taskConfigPath)) {
     return paths.taskConfigPath;
   }
   for (const candidate of sourceTaskConfigCandidates(projectRoot)) {
-    if (existsSync19(candidate)) {
+    if (existsSync21(candidate)) {
       return candidate;
     }
   }
@@ -3124,7 +3183,7 @@ function resolveTaskConfigPath(projectRoot) {
 }
 function findSourceTaskConfigPath(projectRoot) {
   for (const candidate of sourceTaskConfigCandidates(projectRoot)) {
-    if (existsSync19(candidate)) {
+    if (existsSync21(candidate)) {
       return candidate;
     }
   }
@@ -3137,7 +3196,7 @@ function readAndSyncSourceTaskConfig(projectRoot) {
   const synced = synchronizeTaskConfigWithTracker(projectRoot, raw);
   if (sourcePath && synced.updated) {
     try {
-      writeFileSync6(sourcePath, `${JSON.stringify(synced.config, null, 2)}
+      writeFileSync7(sourcePath, `${JSON.stringify(synced.config, null, 2)}
 `, "utf-8");
     } catch {}
   }
@@ -3189,12 +3248,12 @@ function shouldRefreshAutoSyncedTaskConfigEntry(entry) {
   return !candidate.role;
 }
 function readSourceIssueRecords(projectRoot) {
-  const issuesPath = resolve19(resolveMonorepoRoot2(projectRoot), ".beads", "issues.jsonl");
-  if (!existsSync19(issuesPath)) {
+  const issuesPath = resolve20(resolveMonorepoRoot2(projectRoot), ".beads", "issues.jsonl");
+  if (!existsSync21(issuesPath)) {
     return [];
   }
   const records = [];
-  for (const line of readFileSync10(issuesPath, "utf-8").split(/\r?\n/)) {
+  for (const line of readFileSync11(issuesPath, "utf-8").split(/\r?\n/)) {
     const trimmed = line.trim();
     if (!trimmed) {
       continue;
@@ -3250,19 +3309,19 @@ function readConfiguredFileTaskConfig(projectRoot) {
   if (!sourcePath) {
     return {};
   }
-  const directory = resolve19(projectRoot, sourcePath);
-  if (!existsSync19(directory)) {
+  const directory = resolve20(projectRoot, sourcePath);
+  if (!existsSync21(directory)) {
     return {};
   }
   const config = {};
   for (const name of readdirSync3(directory)) {
     if (!FILE_TASK_PATTERN2.test(name))
       continue;
-    const file = resolve19(directory, name);
+    const file = resolve20(directory, name);
     try {
       if (!statSync4(file).isFile())
         continue;
-      const raw = JSON.parse(readFileSync10(file, "utf8"));
+      const raw = JSON.parse(readFileSync11(file, "utf8"));
       if (!raw || typeof raw !== "object" || Array.isArray(raw))
         continue;
       const record = raw;
@@ -3304,10 +3363,10 @@ function firstStringList2(...candidates) {
   return [];
 }
 function readConfiguredFilesTaskSourcePath2(projectRoot) {
-  const jsonPath = resolve19(projectRoot, "rig.config.json");
-  if (existsSync19(jsonPath)) {
+  const jsonPath = resolve20(projectRoot, "rig.config.json");
+  if (existsSync21(jsonPath)) {
     try {
-      const parsed = JSON.parse(readFileSync10(jsonPath, "utf8"));
+      const parsed = JSON.parse(readFileSync11(jsonPath, "utf8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         const taskSource = parsed.taskSource;
         if (taskSource && typeof taskSource === "object" && !Array.isArray(taskSource)) {
@@ -3319,12 +3378,12 @@ function readConfiguredFilesTaskSourcePath2(projectRoot) {
       return null;
     }
   }
-  const tsPath = resolve19(projectRoot, "rig.config.ts");
-  if (!existsSync19(tsPath)) {
+  const tsPath = resolve20(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") {
@@ -3338,9 +3397,9 @@ function readConfiguredFilesTaskSourcePath2(projectRoot) {
 function sourceTaskConfigCandidates(projectRoot) {
   const runtimeContext = loadRuntimeContextFromEnv();
   return [
-    runtimeContext?.monorepoMainRoot ? resolve19(runtimeContext.monorepoMainRoot, ".rig", "task-config.json") : "",
-    process.env.MONOREPO_MAIN_ROOT?.trim() ? resolve19(process.env.MONOREPO_MAIN_ROOT.trim(), ".rig", "task-config.json") : "",
-    resolve19(resolveMonorepoRoot2(projectRoot), ".rig", "task-config.json")
+    runtimeContext?.monorepoMainRoot ? resolve20(runtimeContext.monorepoMainRoot, ".rig", "task-config.json") : "",
+    process.env.MONOREPO_MAIN_ROOT?.trim() ? resolve20(process.env.MONOREPO_MAIN_ROOT.trim(), ".rig", "task-config.json") : "",
+    resolve20(resolveMonorepoRoot2(projectRoot), ".rig", "task-config.json")
   ].filter(Boolean);
 }
 
@@ -3349,8 +3408,8 @@ init_layout();
 
 // packages/runtime/src/binary-run.ts
 init_layout();
-import { chmodSync as chmodSync4, cpSync, existsSync as existsSync20, mkdirSync as mkdirSync8, renameSync as renameSync3, rmSync as rmSync7, writeFileSync as writeFileSync7 } from "fs";
-import { basename as basename7, dirname as dirname9, resolve as resolve20 } from "path";
+import { chmodSync as chmodSync4, cpSync, existsSync as existsSync22, mkdirSync as mkdirSync9, renameSync as renameSync3, rmSync as rmSync7, writeFileSync as writeFileSync8 } from "fs";
+import { basename as basename7, dirname as dirname10, resolve as resolve21 } from "path";
 import { fileURLToPath } from "url";
 import { drainMicrotasks, gcAndSweep } from "bun:jsc";
 var runtimeBinaryBuildQueue = Promise.resolve();
@@ -3376,9 +3435,9 @@ async function buildRuntimeBinary(options) {
   });
 }
 async function buildRuntimeBinaryInProcess(options, manifest) {
-  const tempBuildDir = resolve20(dirname9(options.outputPath), `.bun-build-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-  const tempOutputPath = resolve20(tempBuildDir, basename7(options.outputPath));
-  mkdirSync8(tempBuildDir, { recursive: true });
+  const tempBuildDir = resolve21(dirname10(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 });
   await withTemporaryEnv({
     ...options.env,
     ...options.define ? { RIG_BUILD_CONFIG_JSON: JSON.stringify(options.define) } : {}
@@ -3403,7 +3462,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}`);
     }
@@ -3435,8 +3494,8 @@ function runtimeBinaryCacheManifestPath(outputPath) {
 function resolveRuntimeBinaryBuildOptions(options) {
   return {
     ...options,
-    entrypoint: resolve20(options.cwd, options.sourcePath),
-    outputPath: resolve20(options.outputPath)
+    entrypoint: resolve21(options.cwd, options.sourcePath),
+    outputPath: resolve21(options.outputPath)
   };
 }
 function shouldUseRuntimeBinaryBuildWorker() {
@@ -3450,7 +3509,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({
@@ -3487,7 +3546,7 @@ async function buildRuntimeBinaryViaWorker(options) {
   }
 }
 function createRuntimeBinaryBuildWorkerPayloadPath(outputPath) {
-  return resolve20(dirname9(outputPath), `.bun-build-worker-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.json`);
+  return resolve21(dirname10(outputPath), `.bun-build-worker-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.json`);
 }
 function resolveRuntimeBinaryBuildWorkerSourcePath(options) {
   const envRoots = [
@@ -3496,13 +3555,13 @@ function resolveRuntimeBinaryBuildWorkerSourcePath(options) {
     process.env.PROJECT_RIG_ROOT?.trim()
   ].filter(Boolean);
   for (const root of envRoots) {
-    const candidate = resolve20(root, "packages/runtime/src/binary-build-worker.ts");
-    if (existsSync20(candidate)) {
+    const candidate = resolve21(root, "packages/runtime/src/binary-build-worker.ts");
+    if (existsSync22(candidate)) {
       return candidate;
     }
   }
-  const localCandidate = resolve20(import.meta.dir, "binary-build-worker.ts");
-  return existsSync20(localCandidate) ? localCandidate : null;
+  const localCandidate = resolve21(import.meta.dir, "binary-build-worker.ts");
+  return existsSync22(localCandidate) ? localCandidate : null;
 }
 function resolveRuntimeBinaryBuildWorkerInvocation() {
   const bunPath = Bun.which("bun");
@@ -3538,7 +3597,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;
@@ -3551,7 +3610,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) {
@@ -3564,7 +3623,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);
@@ -3587,7 +3646,7 @@ function normalizeBuildInputPath(cwd, inputPath) {
   if (inputPath.startsWith("<")) {
     return null;
   }
-  return resolve20(cwd, inputPath);
+  return resolve21(cwd, inputPath);
 }
 async function sha256File4(path) {
   const hasher = new Bun.CryptoHasher("sha256");
@@ -3603,8 +3662,8 @@ function sortRecord(value) {
 async function runSerializedRuntimeBinaryBuild(action) {
   const previous = runtimeBinaryBuildQueue;
   let release;
-  runtimeBinaryBuildQueue = new Promise((resolve21) => {
-    release = resolve21;
+  runtimeBinaryBuildQueue = new Promise((resolve22) => {
+    release = resolve22;
   });
   await previous;
   try {
@@ -3649,11 +3708,11 @@ async function withTemporaryCwd(cwd, action) {
 }
 
 // packages/runtime/src/control-plane/runtime/provisioning-env.ts
-import { delimiter, resolve as resolve22 } from "path";
+import { delimiter, resolve as resolve23 } from "path";
 
 // packages/runtime/src/control-plane/runtime/runtime-paths.ts
-import { existsSync as existsSync21, readdirSync as readdirSync4, realpathSync } from "fs";
-import { resolve as resolve21 } from "path";
+import { existsSync as existsSync23, readdirSync as readdirSync4, realpathSync } from "fs";
+import { resolve as resolve22 } from "path";
 
 // packages/runtime/src/control-plane/runtime/sandbox-utils.ts
 init_utils();
@@ -3670,7 +3729,7 @@ function resolveBunBinaryPath() {
   }
   const home = process.env.HOME?.trim();
   const fallbackCandidates = [
-    home ? resolve21(home, ".bun/bin/bun") : "",
+    home ? resolve22(home, ".bun/bin/bun") : "",
     "/opt/homebrew/bin/bun",
     "/usr/local/bin/bun",
     "/usr/bin/bun"
@@ -3698,8 +3757,8 @@ function resolveClaudeBinaryPath() {
   }
   const home = process.env.HOME?.trim();
   const fallbackCandidates = [
-    home ? resolve21(home, ".local/bin/claude") : "",
-    home ? resolve21(home, ".local/share/claude/local/claude") : "",
+    home ? resolve22(home, ".local/bin/claude") : "",
+    home ? resolve22(home, ".local/share/claude/local/claude") : "",
     "/opt/homebrew/bin/claude",
     "/usr/local/bin/claude",
     "/usr/bin/claude"
@@ -3713,51 +3772,51 @@ function resolveClaudeBinaryPath() {
   throw new Error("claude not found in PATH");
 }
 function resolveBunInstallDir(bunBinaryPath = resolveBunBinaryPath()) {
-  return resolve21(bunBinaryPath, "../..");
+  return resolve22(bunBinaryPath, "../..");
 }
 function resolveClaudeInstallDir() {
   const realPath = resolveClaudeBinaryPath();
-  return resolve21(realPath, "..");
+  return resolve22(realPath, "..");
 }
 function resolveNodeInstallDir() {
   const preferredNode = resolvePreferredNodeBinary();
   if (!preferredNode)
     return null;
   const explicitNode = process.env.RIG_NODE_BIN?.trim();
-  if (explicitNode && resolve21(explicitNode) === resolve21(preferredNode)) {
-    return preferredNode.endsWith("/bin/node") ? resolve21(preferredNode, "../..") : resolve21(preferredNode, "..");
+  if (explicitNode && resolve22(explicitNode) === resolve22(preferredNode)) {
+    return preferredNode.endsWith("/bin/node") ? resolve22(preferredNode, "../..") : resolve22(preferredNode, "..");
   }
   try {
     const realPath = realpathSync(preferredNode);
     if (realPath.endsWith("/bin/node")) {
-      return resolve21(realPath, "../..");
+      return resolve22(realPath, "../..");
     }
-    return resolve21(realPath, "..");
+    return resolve22(realPath, "..");
   } catch {
-    return resolve21(preferredNode, "..");
+    return resolve22(preferredNode, "..");
   }
 }
 function resolvePreferredNodeBinary() {
   const candidates = [];
   const envNode = process.env.RIG_NODE_BIN?.trim();
   if (envNode) {
-    const explicit = resolve21(envNode);
-    if (existsSync21(explicit)) {
+    const explicit = resolve22(envNode);
+    if (existsSync23(explicit)) {
       return explicit;
     }
   }
   const nvmBin = process.env.NVM_BIN?.trim();
   if (nvmBin) {
-    candidates.push(resolve21(nvmBin, "node"));
+    candidates.push(resolve22(nvmBin, "node"));
   }
   const home = process.env.HOME?.trim();
   if (home) {
-    const nvmVersionsDir = resolve21(home, ".nvm/versions/node");
-    if (existsSync21(nvmVersionsDir)) {
+    const nvmVersionsDir = resolve22(home, ".nvm/versions/node");
+    if (existsSync23(nvmVersionsDir)) {
       try {
         const versionDirs = readdirSync4(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(resolve21(nvmVersionsDir, versionDir, "bin/node"));
+          candidates.push(resolve22(nvmVersionsDir, versionDir, "bin/node"));
         }
       } catch {}
     }
@@ -3766,8 +3825,8 @@ function resolvePreferredNodeBinary() {
   if (whichNode) {
     candidates.push(whichNode);
   }
-  const deduped = uniq(candidates.map((candidate) => resolve21(candidate)));
-  const existing = deduped.filter((candidate) => existsSync21(candidate));
+  const deduped = uniq(candidates.map((candidate) => resolve22(candidate)));
+  const existing = deduped.filter((candidate) => existsSync23(candidate));
   if (existing.length === 0) {
     return null;
   }
@@ -3781,7 +3840,7 @@ function resolvePreferredNodeBinary() {
   return existing[0] ?? null;
 }
 function inferNodeMajor(nodeBinaryPath) {
-  const normalized = resolve21(nodeBinaryPath).replace(/\\/g, "/");
+  const normalized = resolve22(nodeBinaryPath).replace(/\\/g, "/");
   const match = normalized.match(/(?:^|\/)(?:node-)?v?(\d+)\.\d+\.\d+(?:\/|$)/);
   if (!match) {
     return null;
@@ -3793,8 +3852,8 @@ function normalizeExecutablePath(candidate) {
   if (!candidate) {
     return "";
   }
-  const normalized = resolve21(candidate);
-  if (!existsSync21(normalized)) {
+  const normalized = resolve22(candidate);
+  if (!existsSync23(normalized)) {
     return "";
   }
   try {
@@ -3804,7 +3863,7 @@ function normalizeExecutablePath(candidate) {
   }
 }
 function looksLikeRuntimeGateway(candidate) {
-  const normalized = resolve21(candidate).replace(/\\/g, "/");
+  const normalized = resolve22(candidate).replace(/\\/g, "/");
   return normalized.includes("/.rig/bin/") || normalized.endsWith("/rig-shell") || normalized.endsWith("/rig-agent");
 }
 
@@ -3825,7 +3884,7 @@ function runtimeProvisioningEnv(baseEnv = process.env) {
     try {
       return resolveClaudeInstallDir();
     } catch {
-      return resolve22(claudeBinary, "..");
+      return resolve23(claudeBinary, "..");
     }
   })() : "";
   const nodeDir = resolveNodeInstallDir();
@@ -3835,8 +3894,8 @@ function runtimeProvisioningEnv(baseEnv = process.env) {
     `${bunDir}/bin`,
     claudeDir,
     nodeDir ? `${nodeDir}/bin` : "",
-    realHome ? resolve22(realHome, ".local/bin") : "",
-    realHome ? resolve22(realHome, ".cargo/bin") : "",
+    realHome ? resolve23(realHome, ".local/bin") : "",
+    realHome ? resolve23(realHome, ".cargo/bin") : "",
     ...inheritedPath,
     "/usr/local/bin",
     "/usr/local/sbin",
@@ -4145,16 +4204,16 @@ async function taskDeps(projectRoot, taskId) {
   for (const dep of deps) {
     const artifactDir = artifactDirForId(projectRoot, dep);
     console.log(`=== ${dep} ===`);
-    if (!existsSync22(artifactDir)) {
+    if (!existsSync24(artifactDir)) {
       console.log(`  (no artifacts yet)
 `);
       continue;
     }
-    printArtifactSection(resolve23(artifactDir, "decision-log.md"), "--- Decisions ---");
-    printArtifactSection(resolve23(artifactDir, "next-actions.md"), "--- Next Actions (for you) ---");
-    const changedFiles = resolve23(artifactDir, "changed-files.txt");
-    if (existsSync22(changedFiles)) {
-      const lines = readFileSync11(changedFiles, "utf-8").split(/\r?\n/).filter(Boolean);
+    printArtifactSection(resolve24(artifactDir, "decision-log.md"), "--- Decisions ---");
+    printArtifactSection(resolve24(artifactDir, "next-actions.md"), "--- Next Actions (for you) ---");
+    const changedFiles = resolve24(artifactDir, "changed-files.txt");
+    if (existsSync24(changedFiles)) {
+      const lines = readFileSync12(changedFiles, "utf-8").split(/\r?\n/).filter(Boolean);
       console.log(`--- Changed Files (${lines.length}) ---`);
       for (const line of lines) {
         console.log(line);
@@ -4278,12 +4337,12 @@ function printIndented(text) {
   }
 }
 function readLocalBeadsTasks(projectRoot) {
-  const issuesPath = resolve23(resolveMonorepoRoot2(projectRoot), ".beads/issues.jsonl");
-  if (!existsSync22(issuesPath)) {
+  const issuesPath = resolve24(resolveMonorepoRoot2(projectRoot), ".beads/issues.jsonl");
+  if (!existsSync24(issuesPath)) {
     return [];
   }
   const tasks = [];
-  for (const line of readFileSync11(issuesPath, "utf-8").split(/\r?\n/)) {
+  for (const line of readFileSync12(issuesPath, "utf-8").split(/\r?\n/)) {
     const trimmed = line.trim();
     if (!trimmed) {
       continue;
@@ -4396,11 +4455,11 @@ function taskDependencies(projectRoot, taskId, tracker) {
   return [...ids].sort();
 }
 function printArtifactSection(path, header) {
-  if (!existsSync22(path)) {
+  if (!existsSync24(path)) {
     return;
   }
   console.log(header);
-  process.stdout.write(readFileSync11(path, "utf-8"));
+  process.stdout.write(readFileSync12(path, "utf-8"));
   console.log("");
 }
 
@@ -4420,8 +4479,8 @@ function isRuntimeGatewayGitPath(candidate) {
 }
 function resolveOptionalMonorepoRoot(projectRoot) {
   const runtimeWorkspace = process.env.RIG_TASK_WORKSPACE?.trim();
-  if (runtimeWorkspace && existsSync23(resolve24(runtimeWorkspace, ".git"))) {
-    return resolve24(runtimeWorkspace);
+  if (runtimeWorkspace && existsSync25(resolve25(runtimeWorkspace, ".git"))) {
+    return resolve25(runtimeWorkspace);
   }
   try {
     return resolveMonorepoRoot2(projectRoot);
@@ -4446,7 +4505,7 @@ function resolveGitBinary(projectRoot) {
     if (!candidate || isRuntimeGatewayGitPath(candidate)) {
       continue;
     }
-    if (existsSync23(candidate)) {
+    if (existsSync25(candidate)) {
       return candidate;
     }
   }
@@ -4470,7 +4529,7 @@ function gitSyncBranch(projectRoot, taskId, targetRepo = "monorepo") {
   }
   const repoRoot = targetRepo === "monorepo" ? resolveOptionalMonorepoRoot(projectRoot) || resolveMonorepoRoot2(projectRoot) : projectRoot;
   const repoLabel = targetRepo === "monorepo" ? "Monorepo" : "Project";
-  if (!existsSync23(resolve24(repoRoot, ".git"))) {
+  if (!existsSync25(resolve25(repoRoot, ".git"))) {
     throw new Error(`${repoLabel} repo not found at ${repoRoot}`);
   }
   const branchId = resolveTaskBranchId(projectRoot, resolvedTask);
@@ -4512,7 +4571,7 @@ function resolveTaskBranchId(projectRoot, taskId) {
     }
   } catch {}
   const artifactDir = artifactDirForId(projectRoot, taskId);
-  if (existsSync23(artifactDir)) {
+  if (existsSync25(artifactDir)) {
     return taskId;
   }
   throw new Error(`Unknown task id: ${taskId}`);
@@ -4529,11 +4588,11 @@ function runCapture2(command, cwd, projectRoot = cwd) {
 }
 function runtimeGitEnv(projectRoot) {
   const { ctx, runtimeRoot } = resolveRuntimeMetadata(projectRoot);
-  const runtimeHome = runtimeRoot ? resolve24(runtimeRoot, "home") : "";
-  const runtimeTmp = runtimeRoot ? resolve24(runtimeRoot, "tmp") : "";
-  const runtimeCache = runtimeRoot ? resolve24(runtimeRoot, "cache") : "";
-  const runtimeKnownHosts = runtimeHome ? resolve24(runtimeHome, ".ssh", "known_hosts") : "";
-  const runtimeKey = runtimeHome ? resolve24(runtimeHome, ".ssh", "rig-agent-key") : "";
+  const runtimeHome = runtimeRoot ? resolve25(runtimeRoot, "home") : "";
+  const runtimeTmp = runtimeRoot ? resolve25(runtimeRoot, "tmp") : "";
+  const runtimeCache = runtimeRoot ? resolve25(runtimeRoot, "cache") : "";
+  const runtimeKnownHosts = runtimeHome ? resolve25(runtimeHome, ".ssh", "known_hosts") : "";
+  const runtimeKey = runtimeHome ? resolve25(runtimeHome, ".ssh", "rig-agent-key") : "";
   const env = {};
   if (ctx?.workspaceDir) {
     env.PROJECT_RIG_ROOT = projectRoot;
@@ -4546,14 +4605,14 @@ function runtimeGitEnv(projectRoot) {
   if (runtimeRoot) {
     env.RIG_RUNTIME_HOME = runtimeRoot;
   }
-  if (runtimeHome && existsSync23(runtimeHome)) {
+  if (runtimeHome && existsSync25(runtimeHome)) {
     env.HOME = runtimeHome;
     env.OPENSSL_CONF = ensureRuntimeOpenSslConfig(runtimeHome);
   }
-  if (runtimeTmp && existsSync23(runtimeTmp)) {
+  if (runtimeTmp && existsSync25(runtimeTmp)) {
     env.TMPDIR = runtimeTmp;
   }
-  if (runtimeCache && existsSync23(runtimeCache)) {
+  if (runtimeCache && existsSync25(runtimeCache)) {
     env.XDG_CACHE_HOME = runtimeCache;
   }
   const workspaceSecrets = loadDotEnvSecrets(ctx?.workspaceDir || projectRoot, process.env);
@@ -4597,14 +4656,14 @@ function runtimeGitEnv(projectRoot) {
     env.GH_TOKEN = env.GH_TOKEN || gitHubToken;
     applyGitHubCredentialHelperEnv(env);
   }
-  if (runtimeKnownHosts && existsSync23(runtimeKnownHosts)) {
+  if (runtimeKnownHosts && existsSync25(runtimeKnownHosts)) {
     const sshParts = [
       "ssh",
       `-o UserKnownHostsFile="${runtimeKnownHosts}"`,
       "-o StrictHostKeyChecking=yes",
       "-F /dev/null"
     ];
-    if (runtimeKey && existsSync23(runtimeKey)) {
+    if (runtimeKey && existsSync25(runtimeKey)) {
       sshParts.splice(1, 0, `-i "${runtimeKey}"`, "-o IdentitiesOnly=yes");
     }
     env.GIT_SSH_COMMAND = sshParts.join(" ");
@@ -4625,12 +4684,12 @@ function loadPersistedRuntimeSecrets(runtimeRoot) {
   if (!runtimeRoot) {
     return {};
   }
-  const path = resolve24(runtimeRoot, "runtime-secrets.json");
-  if (!existsSync23(path)) {
+  const path = resolve25(runtimeRoot, "runtime-secrets.json");
+  if (!existsSync25(path)) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync12(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync13(path, "utf-8"));
     const entries = Object.entries(parsed).filter((entry) => typeof entry[1] === "string");
     return Object.fromEntries(entries);
   } catch {
@@ -4638,13 +4697,13 @@ function loadPersistedRuntimeSecrets(runtimeRoot) {
   }
 }
 function ensureRuntimeOpenSslConfig(runtimeHome) {
-  const sslDir = resolve24(runtimeHome, ".ssl");
-  const sslConfig = resolve24(sslDir, "openssl.cnf");
-  if (!existsSync23(sslDir)) {
-    mkdirSync10(sslDir, { recursive: true });
+  const sslDir = resolve25(runtimeHome, ".ssl");
+  const sslConfig = resolve25(sslDir, "openssl.cnf");
+  if (!existsSync25(sslDir)) {
+    mkdirSync11(sslDir, { recursive: true });
   }
-  if (!existsSync23(sslConfig)) {
-    writeFileSync9(sslConfig, `# Rig runtime OpenSSL config placeholder
+  if (!existsSync25(sslConfig)) {
+    writeFileSync10(sslConfig, `# Rig runtime OpenSSL config placeholder
 `);
   }
   return sslConfig;
@@ -4662,29 +4721,29 @@ function resolveRuntimeMetadata(projectRoot) {
   if (contextFile) {
     return {
       ctx,
-      runtimeRoot: dirname10(resolve24(contextFile))
+      runtimeRoot: dirname11(resolve25(contextFile))
     };
   }
   const inferredContextFile = findRuntimeContextFile2(projectRoot);
-  if (existsSync23(inferredContextFile)) {
+  if (existsSync25(inferredContextFile)) {
     try {
       ctx = loadRuntimeContext(inferredContextFile);
     } catch {}
     return {
       ctx,
-      runtimeRoot: dirname10(inferredContextFile)
+      runtimeRoot: dirname11(inferredContextFile)
     };
   }
   return { ctx, runtimeRoot: "" };
 }
 function findRuntimeContextFile2(startPath) {
-  let current = resolve24(startPath);
+  let current = resolve25(startPath);
   while (true) {
-    const candidate = resolve24(current, "runtime-context.json");
-    if (existsSync23(candidate)) {
+    const candidate = resolve25(current, "runtime-context.json");
+    if (existsSync25(candidate)) {
       return candidate;
     }
-    const parent = dirname10(current);
+    const parent = dirname11(current);
     if (parent === current) {
       return "";
     }
@@ -4693,45 +4752,45 @@ function findRuntimeContextFile2(startPath) {
 }
 
 // packages/runtime/src/control-plane/native/repo-ops.ts
-import { existsSync as existsSync27, mkdirSync as mkdirSync14, readFileSync as readFileSync14, readdirSync as readdirSync6, rmSync as rmSync9, writeFileSync as writeFileSync11 } from "fs";
-import { basename as basename8, dirname as dirname12, resolve as resolve28 } from "path";
+import { existsSync as existsSync29, mkdirSync as mkdirSync15, readFileSync as readFileSync15, readdirSync as readdirSync6, rmSync as rmSync9, writeFileSync as writeFileSync12 } from "fs";
+import { basename as basename8, dirname as dirname13, resolve as resolve29 } from "path";
 // packages/runtime/src/control-plane/repos/mirror/bootstrap.ts
-import { existsSync as existsSync25, mkdirSync as mkdirSync12, realpathSync as realpathSync2 } from "fs";
-import { resolve as resolve26 } from "path";
+import { existsSync as existsSync27, mkdirSync as mkdirSync13, realpathSync as realpathSync2 } from "fs";
+import { resolve as resolve27 } from "path";
 
 // packages/runtime/src/control-plane/authority-files.ts
-import { existsSync as existsSync24, mkdirSync as mkdirSync11, readFileSync as readFileSync13, writeFileSync as writeFileSync10, appendFileSync as appendFileSync2, copyFileSync as copyFileSync5, statSync as statSync5, readdirSync as readdirSync5, chmodSync as chmodSync5 } from "fs";
-import { dirname as dirname11, join as join4, relative, resolve as resolve25 } from "path";
+import { existsSync as existsSync26, mkdirSync as mkdirSync12, readFileSync as readFileSync14, writeFileSync as writeFileSync11, appendFileSync as appendFileSync2, copyFileSync as copyFileSync5, statSync as statSync5, readdirSync as readdirSync5, chmodSync as chmodSync5 } from "fs";
+import { dirname as dirname12, join as join4, relative, resolve as resolve26 } from "path";
 init_layout();
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
 function resolveAuthorityProjectStateDir(projectRoot) {
   const explicit = process.env.RIG_STATE_DIR?.trim();
   if (explicit) {
-    return resolve25(explicit);
+    return resolve26(explicit);
   }
-  return resolve25(resolve25(projectRoot), ".rig", "state");
+  return resolve26(resolve26(projectRoot), ".rig", "state");
 }
 function readJsonAtPath(path, fallback) {
-  if (!existsSync24(path)) {
+  if (!existsSync26(path)) {
     return fallback;
   }
   try {
-    return JSON.parse(readFileSync13(path, "utf-8"));
+    return JSON.parse(readFileSync14(path, "utf-8"));
   } catch {
     return fallback;
   }
 }
 function writeJsonAtPath(path, value) {
-  mkdirSync11(dirname11(path), { recursive: true });
-  writeFileSync10(path, `${JSON.stringify(value, null, 2)}
+  mkdirSync12(dirname12(path), { recursive: true });
+  writeFileSync11(path, `${JSON.stringify(value, null, 2)}
 `, "utf8");
   return path;
 }
 function readAuthorityProjectStateJson(projectRoot, relativePath, fallback) {
-  return readJsonAtPath(resolve25(resolveAuthorityProjectStateDir(projectRoot), relativePath), fallback);
+  return readJsonAtPath(resolve26(resolveAuthorityProjectStateDir(projectRoot), relativePath), fallback);
 }
 function writeAuthorityProjectStateJson(projectRoot, relativePath, value) {
-  return writeJsonAtPath(resolve25(resolveAuthorityProjectStateDir(projectRoot), relativePath), value);
+  return writeJsonAtPath(resolve26(resolveAuthorityProjectStateDir(projectRoot), relativePath), value);
 }
 
 // packages/runtime/src/control-plane/repos/mirror/state.ts
@@ -4791,7 +4850,7 @@ function sameExistingPath(left, right) {
   try {
     return realpathSync2(left) === realpathSync2(right);
   } catch {
-    return resolve26(left) === resolve26(right);
+    return resolve27(left) === resolve27(right);
   }
 }
 function repoLooksUsable(repoRoot, projectRoot) {
@@ -4827,7 +4886,7 @@ function resolveMirrorRemoteUrl(layout) {
       }
     }
   }
-  if (existsSync25(resolve26(layout.checkoutRoot, ".git")) && checkoutLooksUsable(layout)) {
+  if (existsSync27(resolve27(layout.checkoutRoot, ".git")) && checkoutLooksUsable(layout)) {
     const checkoutOrigin = runGit(["git", "-C", layout.checkoutRoot, "remote", "get-url", "origin"], layout.projectRoot);
     if (checkoutOrigin.exitCode === 0) {
       const currentOrigin = checkoutOrigin.stdout.trim();
@@ -4840,9 +4899,9 @@ function resolveMirrorRemoteUrl(layout) {
 }
 function ensureManagedRepoMirror(projectRoot, repoId) {
   const layout = resolveManagedRepoLayout(projectRoot, repoId);
-  mkdirSync12(layout.metadataRoot, { recursive: true });
+  mkdirSync13(layout.metadataRoot, { recursive: true });
   const remoteUrl = resolveMirrorRemoteUrl(layout);
-  if (!existsSync25(resolve26(layout.mirrorRoot, "HEAD"))) {
+  if (!existsSync27(resolve27(layout.mirrorRoot, "HEAD"))) {
     ensureGitSuccess(runGit(["git", "init", "--bare", layout.mirrorRoot], layout.projectRoot), ["git", "init", "--bare", layout.mirrorRoot]);
   }
   const getOrigin = runGit(["git", "--git-dir", layout.mirrorRoot, "remote", "get-url", "origin"], layout.projectRoot);
@@ -4862,8 +4921,8 @@ function ensureManagedRepoMirror(projectRoot, repoId) {
   return layout;
 }
 // packages/runtime/src/control-plane/repos/mirror/refresh.ts
-import { existsSync as existsSync26, mkdirSync as mkdirSync13, realpathSync as realpathSync3, rmSync as rmSync8 } from "fs";
-import { resolve as resolve27 } from "path";
+import { existsSync as existsSync28, mkdirSync as mkdirSync14, realpathSync as realpathSync3, rmSync as rmSync8 } from "fs";
+import { resolve as resolve28 } from "path";
 function nowIso3() {
   return new Date().toISOString();
 }
@@ -4890,7 +4949,7 @@ function sameExistingPath2(left, right) {
   try {
     return realpathSync3(left) === realpathSync3(right);
   } catch {
-    return resolve27(left) === resolve27(right);
+    return resolve28(left) === resolve28(right);
   }
 }
 function ensureMirrorHead(layout) {
@@ -4936,12 +4995,12 @@ function checkoutLooksUsable2(layout) {
   return probe.exitCode === 0 && sameExistingPath2(probe.stdout.trim(), layout.checkoutRoot);
 }
 function ensureCheckoutFromMirror(layout) {
-  mkdirSync13(resolve27(layout.checkoutRoot, ".."), { recursive: true });
-  const gitPath = resolve27(layout.checkoutRoot, ".git");
-  if (existsSync26(layout.checkoutRoot) && (!existsSync26(gitPath) || !checkoutLooksUsable2(layout))) {
+  mkdirSync14(resolve28(layout.checkoutRoot, ".."), { recursive: true });
+  const gitPath = resolve28(layout.checkoutRoot, ".git");
+  if (existsSync28(layout.checkoutRoot) && (!existsSync28(gitPath) || !checkoutLooksUsable2(layout))) {
     rmSync8(layout.checkoutRoot, { recursive: true, force: true });
   }
-  if (!existsSync26(gitPath)) {
+  if (!existsSync28(gitPath)) {
     ensureGitSuccess2(runGit2(["git", "clone", layout.mirrorRoot, layout.checkoutRoot], layout.projectRoot), ["git", "clone", layout.mirrorRoot, layout.checkoutRoot]);
   }
   const getOrigin = runGit2(["git", "-C", layout.checkoutRoot, "remote", "get-url", "origin"], layout.projectRoot);
@@ -5015,7 +5074,7 @@ function repoEnsure(projectRoot, taskId) {
 }
 function repoBaseline(projectRoot, refresh = false) {
   const paths = resolveRepoDiscoveryPaths(projectRoot);
-  if (!refresh && existsSync27(paths.baseRepoPinsPath)) {
+  if (!refresh && existsSync29(paths.baseRepoPinsPath)) {
     const baseline = readJsonFile(paths.baseRepoPinsPath, { recorded_at: nowIso(), repos: {} });
     return baseline.repos || {};
   }
@@ -5039,8 +5098,8 @@ function ensureMonorepoReady(projectRoot) {
 }
 function persistBaselinePins(projectRoot, repos) {
   const paths = resolveRepoDiscoveryPaths(projectRoot);
-  mkdirSync14(resolve28(paths.baseRepoPinsPath, ".."), { recursive: true });
-  writeFileSync11(paths.baseRepoPinsPath, `${JSON.stringify({ recorded_at: nowIso(), repos }, null, 2)}
+  mkdirSync15(resolve29(paths.baseRepoPinsPath, ".."), { recursive: true });
+  writeFileSync12(paths.baseRepoPinsPath, `${JSON.stringify({ recorded_at: nowIso(), repos }, null, 2)}
 `, "utf-8");
   return repos;
 }
@@ -5119,28 +5178,28 @@ function readRepoDiscoveryTaskConfig(projectRoot) {
 function resolveRepoDiscoveryPaths(projectRoot) {
   const monorepoRoot = resolveMonorepoRepoLayout(projectRoot).checkoutRoot;
   const explicitHostProjectRoot = (process.env.RIG_HOST_PROJECT_ROOT || "").trim();
-  const normalizedProjectRoot = resolve28(projectRoot);
+  const normalizedProjectRoot = resolve29(projectRoot);
   const hostProjectRoot = explicitHostProjectRoot && shouldUseHostProjectStateRoot(normalizedProjectRoot) ? explicitHostProjectRoot : normalizedProjectRoot;
-  const stateDir = resolve28(hostProjectRoot, ".rig", "state");
+  const stateDir = resolve29(hostProjectRoot, ".rig", "state");
   return {
     monorepoRoot,
-    taskRepoCommitsPath: resolve28(stateDir, "task-repo-commits.json"),
-    baseRepoPinsPath: resolve28(stateDir, "base-repo-pins.json")
+    taskRepoCommitsPath: resolve29(stateDir, "task-repo-commits.json"),
+    baseRepoPinsPath: resolve29(stateDir, "base-repo-pins.json")
   };
 }
 function shouldUseHostProjectStateRoot(projectRoot) {
   const runtimeWorkspace = process.env.RIG_TASK_WORKSPACE?.trim();
-  if (runtimeWorkspace && resolve28(runtimeWorkspace) === projectRoot) {
+  if (runtimeWorkspace && resolve29(runtimeWorkspace) === projectRoot) {
     return true;
   }
-  return basename8(dirname12(projectRoot)) === ".worktrees";
+  return basename8(dirname13(projectRoot)) === ".worktrees";
 }
 function readPinFromArtifact(projectRoot, depTask, repoKey) {
-  const snapshot = resolve28(artifactDirForId(projectRoot, depTask), "git-state.txt");
-  if (!existsSync27(snapshot)) {
+  const snapshot = resolve29(artifactDirForId(projectRoot, depTask), "git-state.txt");
+  if (!existsSync29(snapshot)) {
     return "";
   }
-  const content = readFileSync14(snapshot, "utf-8");
+  const content = readFileSync15(snapshot, "utf-8");
   const chunk = content.split(/\r?\n/);
   let inSection = false;
   for (const line of chunk) {
@@ -5162,12 +5221,12 @@ function repoPath(projectRoot, key) {
   if (managed) {
     return managed.checkoutRoot;
   }
-  return key.startsWith("/") ? key : resolve28(projectRoot, key);
+  return key.startsWith("/") ? key : resolve29(projectRoot, key);
 }
 function applyPins(projectRoot, pins) {
   for (const [key, commit] of Object.entries(pins)) {
     const path = repoPath(projectRoot, key);
-    if (!existsSync27(resolve28(path, ".git"))) {
+    if (!existsSync29(resolve29(path, ".git"))) {
       throw new Error(`Repo for pin not available: ${key} (${path})`);
     }
     let hasCommit = runGitCapture(["git", "-C", path, "cat-file", "-e", `${commit}^{commit}`], projectRoot).exitCode === 0;
@@ -5196,7 +5255,7 @@ function verifyPins(projectRoot, pins) {
   let ok = true;
   for (const [key, expected] of Object.entries(pins)) {
     const path = repoPath(projectRoot, key);
-    if (!existsSync27(resolve28(path, ".git"))) {
+    if (!existsSync29(resolve29(path, ".git"))) {
       console.error(`ERROR: repo missing during pin verification: ${key}`);
       ok = false;
       continue;
@@ -5221,23 +5280,23 @@ function resolveRuntimeGitEnv() {
       GIT_SSH_COMMAND: process.env.GIT_SSH_COMMAND
     };
   }
-  const runtimeRoot = process.env.RIG_RUNTIME_HOME?.trim() || (process.env.RIG_RUNTIME_CONTEXT_FILE?.trim() ? resolve28(process.env.RIG_RUNTIME_CONTEXT_FILE, "..") : inferRuntimeRootFromWorkspace(process.cwd()));
-  const runtimeHome = runtimeRoot ? resolve28(runtimeRoot, "home") : process.env.HOME?.trim() || "";
+  const runtimeRoot = process.env.RIG_RUNTIME_HOME?.trim() || (process.env.RIG_RUNTIME_CONTEXT_FILE?.trim() ? resolve29(process.env.RIG_RUNTIME_CONTEXT_FILE, "..") : inferRuntimeRootFromWorkspace(process.cwd()));
+  const runtimeHome = runtimeRoot ? resolve29(runtimeRoot, "home") : process.env.HOME?.trim() || "";
   if (!runtimeHome) {
     return;
   }
-  const knownHostsPath = resolve28(runtimeHome, ".ssh", "known_hosts");
-  if (!existsSync27(knownHostsPath)) {
+  const knownHostsPath = resolve29(runtimeHome, ".ssh", "known_hosts");
+  if (!existsSync29(knownHostsPath)) {
     return { HOME: runtimeHome };
   }
-  const agentSshKey = resolve28(runtimeHome, ".ssh", "rig-agent-key");
+  const agentSshKey = resolve29(runtimeHome, ".ssh", "rig-agent-key");
   const sshParts = [
     "ssh",
     `-o UserKnownHostsFile="${knownHostsPath}"`,
     "-o StrictHostKeyChecking=yes",
     "-F /dev/null"
   ];
-  if (existsSync27(agentSshKey)) {
+  if (existsSync29(agentSshKey)) {
     sshParts.splice(1, 0, `-i "${agentSshKey}"`, "-o IdentitiesOnly=yes");
   }
   return {
@@ -5247,24 +5306,24 @@ function resolveRuntimeGitEnv() {
 }
 function inferRuntimeRootFromWorkspace(cwd) {
   const contextPath = findRuntimeContextFile3(cwd);
-  if (!contextPath || !existsSync27(contextPath)) {
+  if (!contextPath || !existsSync29(contextPath)) {
     return "";
   }
   try {
     loadRuntimeContext(contextPath);
-    return resolve28(contextPath, "..");
+    return resolve29(contextPath, "..");
   } catch {
     return "";
   }
 }
 function findRuntimeContextFile3(startPath) {
-  let current = resolve28(startPath);
+  let current = resolve29(startPath);
   while (true) {
-    const candidate = resolve28(current, "runtime-context.json");
-    if (existsSync27(candidate)) {
+    const candidate = resolve29(current, "runtime-context.json");
+    if (existsSync29(candidate)) {
       return candidate;
     }
-    const parent = resolve28(current, "..");
+    const parent = resolve29(current, "..");
     if (parent === current) {
       return "";
     }
@@ -5273,13 +5332,13 @@ function findRuntimeContextFile3(startPath) {
 }
 
 // packages/runtime/src/control-plane/runtime/isolation/index.ts
-import { existsSync as existsSync35, mkdirSync as mkdirSync22, readFileSync as readFileSync19, rmSync as rmSync14 } from "fs";
+import { existsSync as existsSync37, mkdirSync as mkdirSync23, readFileSync as readFileSync20, rmSync as rmSync14 } from "fs";
 import { copyFile, mkdir as mkdir3, 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 mkdirSync15 } from "fs";
-import { dirname as dirname13 } from "path";
+import { mkdirSync as mkdirSync16 } from "fs";
+import { dirname as dirname14 } from "path";
 var SCHEMA_STATEMENTS = [
   `CREATE TABLE IF NOT EXISTS memory_events (
     event_id TEXT PRIMARY KEY,
@@ -5492,7 +5551,7 @@ async function ensureSchema(db) {
   await ensureColumns(db.client, "memory_items", MEMORY_ITEM_COLUMNS);
 }
 async function openMemoryDb(dbPath) {
-  mkdirSync15(dirname13(dbPath), { recursive: true });
+  mkdirSync16(dirname14(dbPath), { recursive: true });
   const sqlite = new Database(dbPath, { create: true, strict: true });
   const client = createMemoryDbClient(sqlite);
   const db = {
@@ -5506,7 +5565,7 @@ async function openMemoryDb(dbPath) {
   return db;
 }
 // packages/runtime/src/control-plane/memory-sync/read.ts
-import { mkdtempSync, rmSync as rmSync10, writeFileSync as writeFileSync12 } from "fs";
+import { mkdtempSync, rmSync as rmSync10, writeFileSync as writeFileSync13 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
 import { join as join5 } from "path";
 var CANONICAL_MEMORY_DB_PATH = "rig/memory/project-memory.db";
@@ -5535,7 +5594,7 @@ async function readCanonicalMemoryDb(projectRoot, deps = {}) {
   try {
     try {
       const bytes = readDeps.readBlobBytesAtRef(repoPath2, baseOid, CANONICAL_MEMORY_DB_PATH);
-      writeFileSync12(dbPath, bytes);
+      writeFileSync13(dbPath, bytes);
     } catch (error) {
       if (!isMissingCanonicalMemoryBlobError(error)) {
         throw error;
@@ -5660,7 +5719,7 @@ init_layout();
 
 // packages/runtime/src/control-plane/runtime/overlay.ts
 init_layout();
-import { mkdirSync as mkdirSync16 } from "fs";
+import { mkdirSync as mkdirSync17 } from "fs";
 function ensureRuntimeOverlay(projectRoot, runtimeId, workspaceDir) {
   const layout = resolveRuntimeWorkspaceLayout(workspaceDir ?? projectRoot);
   const rootDir = layout.rigRoot;
@@ -5672,14 +5731,14 @@ function ensureRuntimeOverlay(projectRoot, runtimeId, workspaceDir) {
   const sessionDir = layout.sessionDir;
   const runtimeDir = layout.runtimeDir;
   const contextPath = layout.contextPath;
-  mkdirSync16(rootDir, { recursive: true });
-  mkdirSync16(homeDir, { recursive: true });
-  mkdirSync16(tmpDir, { recursive: true });
-  mkdirSync16(cacheDir, { recursive: true });
-  mkdirSync16(logsDir, { recursive: true });
-  mkdirSync16(stateDir, { recursive: true });
-  mkdirSync16(sessionDir, { recursive: true });
-  mkdirSync16(runtimeDir, { recursive: true });
+  mkdirSync17(rootDir, { recursive: true });
+  mkdirSync17(homeDir, { recursive: true });
+  mkdirSync17(tmpDir, { recursive: true });
+  mkdirSync17(cacheDir, { recursive: true });
+  mkdirSync17(logsDir, { recursive: true });
+  mkdirSync17(stateDir, { recursive: true });
+  mkdirSync17(sessionDir, { recursive: true });
+  mkdirSync17(runtimeDir, { recursive: true });
   return {
     rootDir,
     homeDir,
@@ -5697,17 +5756,17 @@ import {
   chmodSync as chmodSync6,
   copyFileSync as copyFileSync6,
   cpSync as cpSync2,
-  existsSync as existsSync29,
-  mkdirSync as mkdirSync17,
+  existsSync as existsSync31,
+  mkdirSync as mkdirSync18,
   statSync as statSync6,
-  writeFileSync as writeFileSync13
+  writeFileSync as writeFileSync14
 } from "fs";
 import { mkdir } from "fs/promises";
-import { basename as basename9, delimiter as delimiter2, resolve as resolve30 } from "path";
+import { basename as basename9, delimiter as delimiter2, resolve as resolve31 } from "path";
 
 // packages/runtime/src/control-plane/runtime/isolation/shared.ts
-import { existsSync as existsSync28, readFileSync as readFileSync15, rmSync as rmSync11 } from "fs";
-import { resolve as resolve29 } from "path";
+import { existsSync as existsSync30, readFileSync as readFileSync16, rmSync as rmSync11 } from "fs";
+import { resolve as resolve30 } from "path";
 var generatedCredentialFiles = new Set;
 var credentialCleanupRegistered = false;
 function resolveMonorepoRoot3(projectRoot) {
@@ -5731,7 +5790,7 @@ function resolveHostGitBinary() {
     if (!candidate || isRuntimeGatewayGitPath2(candidate)) {
       continue;
     }
-    if (existsSync28(candidate)) {
+    if (existsSync30(candidate)) {
       return candidate;
     }
   }
@@ -5797,7 +5856,7 @@ async function refreshRemoteBranch(repoRoot, remote, branch) {
   }
 }
 async function tryReadGitHead(repoRoot) {
-  if (!existsSync28(resolve29(repoRoot, ".git"))) {
+  if (!existsSync30(resolve30(repoRoot, ".git"))) {
     return;
   }
   const result = await runGitCommand(repoRoot, ["rev-parse", "HEAD"]);
@@ -5808,7 +5867,7 @@ async function tryReadGitHead(repoRoot) {
   return value || undefined;
 }
 async function captureRepoDirtyFiles(repoRoot) {
-  if (!existsSync28(resolve29(repoRoot, ".git"))) {
+  if (!existsSync30(resolve30(repoRoot, ".git"))) {
     return [];
   }
   const files = new Set;
@@ -5895,10 +5954,10 @@ function hashProjectPath(workspaceDir) {
   return sha256Hex(workspaceDir).slice(0, 16);
 }
 function readKnownHosts(path) {
-  if (!existsSync28(path)) {
+  if (!existsSync30(path)) {
     return new Set;
   }
-  return new Set(readFileSync15(path, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean));
+  return new Set(readFileSync16(path, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean));
 }
 
 // packages/runtime/src/control-plane/runtime/isolation/home.ts
@@ -5915,30 +5974,30 @@ async function provisionRuntimeHome(runtime, options = {}) {
   await mkdir(runtime.cacheDir, { recursive: true });
   await provisionAgentSshKey(runtime.homeDir);
   if (options.provider === "codex") {
-    const hasCodexAuth = await injectCodexAuth(resolve30(runtime.homeDir, ".codex"));
+    const hasCodexAuth = await injectCodexAuth(resolve31(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(resolve30(runtime.homeDir, ".pi", "agent"));
+    const hasPiAuth = await injectPiAgentConfig(resolve31(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) {
-  mkdirSync17(config.claudeHomeDir, { recursive: true });
-  const workspaceSettings = resolve30(config.workspaceDir, ".claude/settings.json");
-  const hostSettings = resolve30(config.hostProjectRoot, ".claude/settings.json");
-  const projectSettings = existsSync29(workspaceSettings) ? workspaceSettings : hostSettings;
+  mkdirSync18(config.claudeHomeDir, { recursive: true });
+  const workspaceSettings = resolve31(config.workspaceDir, ".claude/settings.json");
+  const hostSettings = resolve31(config.hostProjectRoot, ".claude/settings.json");
+  const projectSettings = existsSync31(workspaceSettings) ? workspaceSettings : hostSettings;
   const runtimeSettings = await loadRuntimeClaudeSettings(projectSettings);
-  if (existsSync29(projectSettings)) {
-    writeFileSync13(resolve30(config.claudeHomeDir, "settings.local.json"), `${JSON.stringify(runtimeSettings, null, 2)}
+  if (existsSync31(projectSettings)) {
+    writeFileSync14(resolve31(config.claudeHomeDir, "settings.local.json"), `${JSON.stringify(runtimeSettings, null, 2)}
 `, "utf-8");
   }
   writeClaudeProjectSettings(config.claudeHomeDir, config.workspaceDir, runtimeSettings);
-  writeFileSync13(resolve30(config.claudeHomeDir, "settings.json"), JSON.stringify({
+  writeFileSync14(resolve31(config.claudeHomeDir, "settings.json"), JSON.stringify({
     permissions: { defaultMode: "bypassPermissions" },
     autoMemoryEnabled: false
   }, null, 2));
@@ -5946,20 +6005,20 @@ 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 = resolve30(process.env.HOME ?? "", ".claude");
-  if (process.env.HOME && existsSync29(resolve30(realClaudeHome, "CLAUDE.md"))) {
-    cpSync2(resolve30(realClaudeHome, "CLAUDE.md"), resolve30(config.claudeHomeDir, "CLAUDE.md"));
+  const realClaudeHome = resolve31(process.env.HOME ?? "", ".claude");
+  if (process.env.HOME && existsSync31(resolve31(realClaudeHome, "CLAUDE.md"))) {
+    cpSync2(resolve31(realClaudeHome, "CLAUDE.md"), resolve31(config.claudeHomeDir, "CLAUDE.md"));
   }
-  if (process.env.HOME && existsSync29(resolve30(realClaudeHome, "agents"))) {
-    cpSync2(resolve30(realClaudeHome, "agents"), resolve30(config.claudeHomeDir, "agents"), { recursive: true });
+  if (process.env.HOME && existsSync31(resolve31(realClaudeHome, "agents"))) {
+    cpSync2(resolve31(realClaudeHome, "agents"), resolve31(config.claudeHomeDir, "agents"), { recursive: true });
   }
   if (process.platform === "darwin" && process.env.HOME) {
     writeClaudeProjectSettings(realClaudeHome, config.workspaceDir, runtimeSettings);
   }
 }
 async function provisionAgentSshKey(homeDir) {
-  const sshDir = resolve30(homeDir, ".ssh");
-  if (!existsSync29(sshDir)) {
+  const sshDir = resolve31(homeDir, ".ssh");
+  if (!existsSync31(sshDir)) {
     await mkdir(sshDir, { recursive: true });
   }
   seedKnownHosts(sshDir);
@@ -5967,27 +6026,27 @@ async function provisionAgentSshKey(homeDir) {
   const privateKey = decodeProvisionedSshKey(secrets.GITHUB_SSH_KEY);
   if (!privateKey) {
     const hostKeyPath = resolveHostSshKeyPath(process.env.HOME ?? "");
-    if (!process.env.HOME || !existsSync29(hostKeyPath)) {
+    if (!process.env.HOME || !existsSync31(hostKeyPath)) {
       return;
     }
-    const agentKeyPath2 = resolve30(sshDir, "rig-agent-key");
-    if (!existsSync29(agentKeyPath2)) {
+    const agentKeyPath2 = resolve31(sshDir, "rig-agent-key");
+    if (!existsSync31(agentKeyPath2)) {
       copyFileSync6(hostKeyPath, agentKeyPath2);
       chmodSync6(agentKeyPath2, 384);
     }
     const hostPubPath = `${hostKeyPath}.pub`;
-    if (existsSync29(hostPubPath)) {
+    if (existsSync31(hostPubPath)) {
       const agentPubPath = `${agentKeyPath2}.pub`;
-      if (!existsSync29(agentPubPath)) {
+      if (!existsSync31(agentPubPath)) {
         copyFileSync6(hostPubPath, agentPubPath);
       }
     }
     writeSshConfig(sshDir, agentKeyPath2);
     return;
   }
-  const agentKeyPath = resolve30(sshDir, "rig-agent-key");
-  if (!existsSync29(agentKeyPath)) {
-    writeFileSync13(agentKeyPath, privateKey, { mode: 384 });
+  const agentKeyPath = resolve31(sshDir, "rig-agent-key");
+  if (!existsSync31(agentKeyPath)) {
+    writeFileSync14(agentKeyPath, privateKey, { mode: 384 });
   }
   writeSshConfig(sshDir, agentKeyPath);
 }
@@ -6004,21 +6063,21 @@ function decodeProvisionedSshKey(encodedKey) {
 `;
 }
 function resolveHostSshKeyPath(homeDir) {
-  const sshDir = resolve30(homeDir, ".ssh");
+  const sshDir = resolve31(homeDir, ".ssh");
   const candidates = [
     "rig-agent-key",
     "id_ed25519",
     "id_ecdsa",
     "id_rsa"
-  ].map((name) => resolve30(sshDir, name));
-  return candidates.find((candidate) => existsSync29(candidate)) ?? resolve30(sshDir, "rig-agent-key");
+  ].map((name) => resolve31(sshDir, name));
+  return candidates.find((candidate) => existsSync31(candidate)) ?? resolve31(sshDir, "rig-agent-key");
 }
 function writeSshConfig(sshDir, keyPath) {
-  const configPath = resolve30(sshDir, "config");
-  if (existsSync29(configPath)) {
+  const configPath = resolve31(sshDir, "config");
+  if (existsSync31(configPath)) {
     return;
   }
-  const knownHostsPath = resolve30(sshDir, "known_hosts");
+  const knownHostsPath = resolve31(sshDir, "known_hosts");
   const config = [
     "Host github.com",
     `  IdentityFile ${keyPath}`,
@@ -6028,10 +6087,10 @@ function writeSshConfig(sshDir, keyPath) {
     ""
   ].join(`
 `);
-  writeFileSync13(configPath, config, { mode: 420 });
+  writeFileSync14(configPath, config, { mode: 420 });
 }
 function seedKnownHosts(sshDir) {
-  const knownHostsPath = resolve30(sshDir, "known_hosts");
+  const knownHostsPath = resolve31(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));
@@ -6042,23 +6101,23 @@ function seedKnownHosts(sshDir) {
     for (const line of missing) {
       existingLines.add(line);
     }
-    writeFileSync13(knownHostsPath, `${Array.from(existingLines).join(`
+    writeFileSync14(knownHostsPath, `${Array.from(existingLines).join(`
 `)}
 `, { mode: 420 });
   } catch (err) {
-    const hint = existsSync29(knownHostsPath) ? "" : " \u2014 known_hosts is missing; git SSH operations may fail";
+    const hint = existsSync31(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 = resolve30(claudeHomeDir, "projects", projectHash);
-  mkdirSync17(projectDir, { recursive: true });
-  writeFileSync13(resolve30(projectDir, "settings.json"), `${JSON.stringify(runtimeSettings, null, 2)}
+  const projectDir = resolve31(claudeHomeDir, "projects", projectHash);
+  mkdirSync18(projectDir, { recursive: true });
+  writeFileSync14(resolve31(projectDir, "settings.json"), `${JSON.stringify(runtimeSettings, null, 2)}
 `, "utf-8");
 }
 async function loadRuntimeClaudeSettings(projectSettingsPath) {
-  if (!existsSync29(projectSettingsPath)) {
+  if (!existsSync31(projectSettingsPath)) {
     return {};
   }
   let parsed;
@@ -6104,7 +6163,7 @@ async function loadRuntimeClaudeSettings(projectSettingsPath) {
   return clone;
 }
 async function injectClaudeCredentials(claudeHomeDir, options = {}) {
-  const credentialsPath = resolve30(claudeHomeDir, ".credentials.json");
+  const credentialsPath = resolve31(claudeHomeDir, ".credentials.json");
   const platform = options.platform ?? process.platform;
   if (platform === "darwin") {
     const raw = options.loadKeychainCredentials ? await options.loadKeychainCredentials() : await (async () => {
@@ -6114,16 +6173,16 @@ async function injectClaudeCredentials(claudeHomeDir, options = {}) {
     if (raw) {
       try {
         JSON.parse(raw);
-        writeFileSync13(credentialsPath, raw, { mode: 384 });
+        writeFileSync14(credentialsPath, raw, { mode: 384 });
         registerCredentialCleanup(credentialsPath);
         return true;
       } catch {}
     }
   }
-  const hostClaudeHome = options.hostClaudeHome ? resolve30(options.hostClaudeHome) : process.env.CLAUDE_HOME?.trim() ? resolve30(process.env.CLAUDE_HOME) : process.env.HOME ? resolve30(process.env.HOME, ".claude") : "";
+  const hostClaudeHome = options.hostClaudeHome ? resolve31(options.hostClaudeHome) : process.env.CLAUDE_HOME?.trim() ? resolve31(process.env.CLAUDE_HOME) : process.env.HOME ? resolve31(process.env.HOME, ".claude") : "";
   if (hostClaudeHome) {
-    const realCredentials = resolve30(hostClaudeHome, ".credentials.json");
-    if (existsSync29(realCredentials)) {
+    const realCredentials = resolve31(hostClaudeHome, ".credentials.json");
+    if (existsSync31(realCredentials)) {
       cpSync2(realCredentials, credentialsPath);
       return true;
     }
@@ -6131,36 +6190,36 @@ async function injectClaudeCredentials(claudeHomeDir, options = {}) {
   return false;
 }
 async function injectCodexAuth(codexHomeDir) {
-  mkdirSync17(codexHomeDir, { recursive: true });
-  const hostCodexHome = process.env.CODEX_HOME?.trim() ? resolve30(process.env.CODEX_HOME) : process.env.HOME ? resolve30(process.env.HOME, ".codex") : "";
+  mkdirSync18(codexHomeDir, { recursive: true });
+  const hostCodexHome = process.env.CODEX_HOME?.trim() ? resolve31(process.env.CODEX_HOME) : process.env.HOME ? resolve31(process.env.HOME, ".codex") : "";
   if (!hostCodexHome) {
     return false;
   }
-  const hostAuthPath = resolve30(hostCodexHome, "auth.json");
-  if (!existsSync29(hostAuthPath)) {
+  const hostAuthPath = resolve31(hostCodexHome, "auth.json");
+  if (!existsSync31(hostAuthPath)) {
     return false;
   }
-  const runtimeAuthPath = resolve30(codexHomeDir, "auth.json");
+  const runtimeAuthPath = resolve31(codexHomeDir, "auth.json");
   copyFileSync6(hostAuthPath, runtimeAuthPath);
   chmodSync6(runtimeAuthPath, 384);
   return true;
 }
 async function injectPiAgentConfig(piAgentDir) {
-  mkdirSync17(piAgentDir, { recursive: true });
-  const hostPiAgentDir = process.env.PI_CODING_AGENT_DIR?.trim() ? resolve30(process.env.PI_CODING_AGENT_DIR) : process.env.HOME ? resolve30(process.env.HOME, ".pi", "agent") : "";
+  mkdirSync18(piAgentDir, { recursive: true });
+  const hostPiAgentDir = process.env.PI_CODING_AGENT_DIR?.trim() ? resolve31(process.env.PI_CODING_AGENT_DIR) : process.env.HOME ? resolve31(process.env.HOME, ".pi", "agent") : "";
   if (!hostPiAgentDir) {
     return false;
   }
-  const hostAuthPath = resolve30(hostPiAgentDir, "auth.json");
-  if (!existsSync29(hostAuthPath)) {
+  const hostAuthPath = resolve31(hostPiAgentDir, "auth.json");
+  if (!existsSync31(hostAuthPath)) {
     return false;
   }
-  const runtimeAuthPath = resolve30(piAgentDir, "auth.json");
+  const runtimeAuthPath = resolve31(piAgentDir, "auth.json");
   copyFileSync6(hostAuthPath, runtimeAuthPath);
   chmodSync6(runtimeAuthPath, 384);
-  const hostSettingsPath = resolve30(hostPiAgentDir, "settings.json");
-  if (existsSync29(hostSettingsPath)) {
-    const runtimeSettingsPath = resolve30(piAgentDir, "settings.json");
+  const hostSettingsPath = resolve31(hostPiAgentDir, "settings.json");
+  if (existsSync31(hostSettingsPath)) {
+    const runtimeSettingsPath = resolve31(piAgentDir, "settings.json");
     copyFileSync6(hostSettingsPath, runtimeSettingsPath);
     chmodSync6(runtimeSettingsPath, 384);
   }
@@ -6168,13 +6227,13 @@ async function injectPiAgentConfig(piAgentDir) {
 }
 
 // packages/runtime/src/control-plane/runtime/tooling/claude-router.ts
-import { existsSync as existsSync30, mkdirSync as mkdirSync18, statSync as statSync7, writeFileSync as writeFileSync14 } from "fs";
-import { resolve as resolve31 } from "path";
+import { existsSync as existsSync32, mkdirSync as mkdirSync19, statSync as statSync7, writeFileSync as writeFileSync15 } from "fs";
+import { resolve as resolve32 } from "path";
 var CLAUDE_ROUTER_SERVER_NAME = "rig_runtime_tools";
 function buildRuntimeToolRouterServerConfig(options) {
   return {
     type: "stdio",
-    command: resolve31(options.binDir, "rig-tool-router"),
+    command: resolve32(options.binDir, "rig-tool-router"),
     args: [],
     env: {
       RIG_RUNTIME_CONTEXT_FILE: options.contextFile,
@@ -6183,14 +6242,14 @@ function buildRuntimeToolRouterServerConfig(options) {
   };
 }
 function writeClaudeRuntimeToolRouterConfig(options) {
-  const configPath = resolve31(options.stateDir, "claude-runtime-tools.mcp.json");
-  mkdirSync18(options.stateDir, { recursive: true });
+  const configPath = resolve32(options.stateDir, "claude-runtime-tools.mcp.json");
+  mkdirSync19(options.stateDir, { recursive: true });
   const payload = {
     mcpServers: {
       [CLAUDE_ROUTER_SERVER_NAME]: buildRuntimeToolRouterServerConfig(options)
     }
   };
-  writeFileSync14(configPath, `${JSON.stringify(payload, null, 2)}
+  writeFileSync15(configPath, `${JSON.stringify(payload, null, 2)}
 `, "utf-8");
   return configPath;
 }
@@ -6199,8 +6258,8 @@ if (false) {}
 init_layout();
 
 // packages/runtime/src/control-plane/runtime/isolation/worktree.ts
-import { existsSync as existsSync31, mkdirSync as mkdirSync19, rmSync as rmSync12 } from "fs";
-import { dirname as dirname14, resolve as resolve32 } from "path";
+import { existsSync as existsSync33, mkdirSync as mkdirSync20, rmSync as rmSync12 } from "fs";
+import { dirname as dirname15, resolve as resolve33 } from "path";
 async function resolveMonorepoBaseRef(monorepoRoot) {
   const explicit = process.env.RIG_RUNTIME_BASE_REF?.trim();
   if (explicit) {
@@ -6236,12 +6295,12 @@ function ensureProvisioningHostProjectRootEnv(projectRoot) {
 }
 async function provisionRuntimeWorktree(config) {
   const branch = runtimeBranchName(config.taskId, config.runtimeId);
-  let hasValidWorktree = existsSync31(resolve32(config.workspaceDir, ".git")) && (await runGitCommand(config.workspaceDir, ["rev-parse", "--show-toplevel"])).exitCode === 0;
-  if (existsSync31(config.workspaceDir) && !hasValidWorktree) {
+  let hasValidWorktree = existsSync33(resolve33(config.workspaceDir, ".git")) && (await runGitCommand(config.workspaceDir, ["rev-parse", "--show-toplevel"])).exitCode === 0;
+  if (existsSync33(config.workspaceDir) && !hasValidWorktree) {
     rmSync12(config.workspaceDir, { recursive: true, force: true });
   }
   if (!hasValidWorktree) {
-    mkdirSync19(dirname14(config.workspaceDir), { recursive: true });
+    mkdirSync20(dirname15(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) {
@@ -6417,31 +6476,31 @@ async function preferredBaseRemotes(repoRoot) {
 
 // packages/runtime/src/control-plane/runtime/isolation/toolchain.ts
 import {
-  existsSync as existsSync33,
+  existsSync as existsSync35,
   lstatSync as lstatSync2,
-  mkdirSync as mkdirSync21,
+  mkdirSync as mkdirSync22,
   readdirSync as readdirSync7,
-  readFileSync as readFileSync17,
+  readFileSync as readFileSync18,
   rmSync as rmSync13,
   statSync as statSync9,
   symlinkSync as symlinkSync4
 } from "fs";
 import { mkdir as mkdir2, writeFile } from "fs/promises";
-import { dirname as dirname16, resolve as resolve34 } from "path";
+import { dirname as dirname17, resolve as resolve35 } from "path";
 
 // packages/runtime/src/control-plane/runtime/tooling/claude-router-binary.ts
-import { chmodSync as chmodSync7, copyFileSync as copyFileSync7, existsSync as existsSync32, mkdirSync as mkdirSync20, statSync as statSync8 } from "fs";
+import { chmodSync as chmodSync7, copyFileSync as copyFileSync7, existsSync as existsSync34, mkdirSync as mkdirSync21, statSync as statSync8 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
-import { dirname as dirname15, resolve as resolve33 } from "path";
-var sharedRouterOutputDir = resolve33(tmpdir6(), "rig-native");
-var sharedRouterOutputPath = resolve33(sharedRouterOutputDir, `rig-tool-router-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`);
+import { dirname as dirname16, resolve as resolve34 } from "path";
+var sharedRouterOutputDir = resolve34(tmpdir6(), "rig-native");
+var sharedRouterOutputPath = resolve34(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 = resolve33(projectRoot, "packages/runtime/src/control-plane/runtime/tooling/claude-router.ts");
-  mkdirSync20(dirname15(outputPath), { recursive: true });
-  const needsBuild = !existsSync32(outputPath) || statSync8(sourcePath).mtimeMs > statSync8(outputPath).mtimeMs;
+  const sourcePath = resolve34(projectRoot, "packages/runtime/src/control-plane/runtime/tooling/claude-router.ts");
+  mkdirSync21(dirname16(outputPath), { recursive: true });
+  const needsBuild = !existsSync34(outputPath) || statSync8(sourcePath).mtimeMs > statSync8(outputPath).mtimeMs;
   if (!needsBuild) {
     return outputPath;
   }
@@ -6455,9 +6514,9 @@ async function ensureClaudeToolRouterBinaryPath(projectRoot, outputPath = shared
 }
 async function materializeClaudeToolRouterBinary(projectRoot, targetDir) {
   const sourcePath = await ensureClaudeToolRouterBinaryPath(projectRoot);
-  const targetPath = resolve33(targetDir, runtimeClaudeToolRouterFileName());
-  mkdirSync20(targetDir, { recursive: true });
-  const needsCopy = !existsSync32(targetPath) || statSync8(sourcePath).mtimeMs > statSync8(targetPath).mtimeMs;
+  const targetPath = resolve34(targetDir, runtimeClaudeToolRouterFileName());
+  mkdirSync21(targetDir, { recursive: true });
+  const needsCopy = !existsSync34(targetPath) || statSync8(sourcePath).mtimeMs > statSync8(targetPath).mtimeMs;
   if (needsCopy) {
     copyFileSync7(sourcePath, targetPath);
     chmodSync7(targetPath, 493);
@@ -6470,48 +6529,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 && existsSync33(resolve34(hostProjectRoot, "packages/runtime/bin/rig-agent.ts"))) {
+  if (hostProjectRoot && existsSync35(resolve35(hostProjectRoot, "packages/runtime/bin/rig-agent.ts"))) {
     return hostProjectRoot;
   }
-  const fromModule = resolve34(import.meta.dir, "../../../../../..");
-  if (existsSync33(resolve34(fromModule, "packages/runtime/bin/rig-agent.ts"))) {
+  const fromModule = resolve35(import.meta.dir, "../../../../../..");
+  if (existsSync35(resolve35(fromModule, "packages/runtime/bin/rig-agent.ts"))) {
     return fromModule;
   }
   return projectRoot;
 }
 function prepareTrackedRuntimePaths(logsDir, stateDir, sessionDir) {
-  for (const path of [logsDir, stateDir, sessionDir, resolve34(sessionDir, "session.json")]) {
+  for (const path of [logsDir, stateDir, sessionDir, resolve35(sessionDir, "session.json")]) {
     removeSymbolicLink(path);
   }
   runtimePrepareTrackedPathsNative({
     logsDir,
     stateDir,
     sessionDir,
-    controlledBashLogFile: resolve34(logsDir, "controlled-bash.jsonl"),
-    eventsFile: resolve34(logsDir, "control-plane.events.jsonl")
+    controlledBashLogFile: resolve35(logsDir, "controlled-bash.jsonl"),
+    eventsFile: resolve35(logsDir, "control-plane.events.jsonl")
   });
 }
 async function initializeRuntimeStateFiles(stateDir, sessionDir, taskId) {
   await mkdir2(stateDir, { recursive: true });
   await mkdir2(sessionDir, { recursive: true });
-  const failedApproachesPath = resolve34(stateDir, "failed_approaches.md");
-  if (!existsSync33(failedApproachesPath)) {
+  const failedApproachesPath = resolve35(stateDir, "failed_approaches.md");
+  if (!existsSync35(failedApproachesPath)) {
     await writeFile(failedApproachesPath, `# Failed Approaches
 
 `);
   }
-  const hookTripsPath = resolve34(stateDir, "hook_trips.log");
-  if (!existsSync33(hookTripsPath)) {
+  const hookTripsPath = resolve35(stateDir, "hook_trips.log");
+  if (!existsSync35(hookTripsPath)) {
     await writeFile(hookTripsPath, "");
   }
-  const sessionFile = resolve34(sessionDir, "session.json");
+  const sessionFile = resolve35(sessionDir, "session.json");
   if (taskId) {
     await writeFile(sessionFile, JSON.stringify({ activeTaskIds: [taskId] }));
   }
 }
 async function resetEphemeralTaskArtifacts(workspaceDir, taskId) {
-  const artifactDir = resolve34(workspaceDir, "artifacts", taskId);
-  const runtimeSnapshotDir = resolve34(artifactDir, "runtime-snapshots");
+  const artifactDir = resolve35(workspaceDir, "artifacts", taskId);
+  const runtimeSnapshotDir = resolve35(artifactDir, "runtime-snapshots");
   let preservedTrackedFiles = false;
   for (const file of [
     "changed-files.txt",
@@ -6527,7 +6586,7 @@ async function resetEphemeralTaskArtifacts(workspaceDir, taskId) {
       preservedTrackedFiles = true;
       continue;
     }
-    rmSync13(resolve34(artifactDir, file), { force: true });
+    rmSync13(resolve35(artifactDir, file), { force: true });
   }
   const runtimeSnapshotRelativePath = `artifacts/${taskId}/runtime-snapshots`;
   if (await resetTrackedArtifactPath(workspaceDir, runtimeSnapshotRelativePath)) {
@@ -6566,28 +6625,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", resolve34(options.binDir, "rig"), rigSourceRoot);
-  await buildBinary("packages/runtime/bin/rig-agent.ts", resolve34(options.binDir, "rig-agent"), rigSourceRoot, {
+  await buildBinary("packages/cli/bin/rig.ts", resolve35(options.binDir, "rig"), rigSourceRoot);
+  await buildBinary("packages/runtime/bin/rig-agent.ts", resolve35(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: resolve34(options.binDir, "rig-agent"),
+    AGENT_BINARY_PATH: resolve35(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", resolve34(options.binDir, "controlled-bash"), rigSourceRoot, {
+  await buildBinary("packages/runtime/src/control-plane/controlled-bash.ts", resolve35(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: resolve34(options.workspaceDir, "TSAPITests"),
-    AGENT_RIG_AGENT_BIN: resolve34(options.binDir, "rig-agent")
+    AGENT_TS_API_TESTS_DIR: resolve35(options.workspaceDir, "TSAPITests"),
+    AGENT_RIG_AGENT_BIN: resolve35(options.binDir, "rig-agent")
   });
-  await buildBinary("packages/runtime/bin/rig-browser-tool.ts", resolve34(options.binDir, runtimeBrowserToolBinaryName()), rigSourceRoot);
-  await buildBinary("packages/runtime/src/control-plane/runtime/snapshot/sidecar.ts", resolve34(options.binDir, "snapshot-sidecar"), rigSourceRoot, {
+  await buildBinary("packages/runtime/bin/rig-browser-tool.ts", resolve35(options.binDir, runtimeBrowserToolBinaryName()), rigSourceRoot);
+  await buildBinary("packages/runtime/src/control-plane/runtime/snapshot/sidecar.ts", resolve35(options.binDir, "snapshot-sidecar"), rigSourceRoot, {
     AGENT_PROJECT_ROOT: options.projectRoot,
     AGENT_BUN_PATH: resolveBunBinaryPath()
   });
@@ -6596,15 +6655,15 @@ async function buildRuntimeToolchain(options) {
     AGENT_BUN_PATH: resolveBunBinaryPath()
   };
   for (const hookName of hookNames) {
-    await buildBinary(`packages/runtime/src/control-plane/hooks/${hookName}.ts`, resolve34(runtimeBins.hooksDir, hookName), rigSourceRoot, hookDefines);
+    await buildBinary(`packages/runtime/src/control-plane/hooks/${hookName}.ts`, resolve35(runtimeBins.hooksDir, hookName), rigSourceRoot, hookDefines);
   }
-  const pluginsDir = resolve34(options.projectRoot, "rig/plugins");
-  if (existsSync33(pluginsDir)) {
+  const pluginsDir = resolve35(options.projectRoot, "rig/plugins");
+  if (existsSync35(pluginsDir)) {
     for (const entry of readdirSync7(pluginsDir, { withFileTypes: true })) {
       const match = entry.name.match(/^(.+)\.plugin\.(ts|js|mjs|cjs)$/);
       if (!match)
         continue;
-      await buildBinary(`rig/plugins/${entry.name}`, resolve34(runtimeBins.pluginsDir, match[1]), options.projectRoot);
+      await buildBinary(`rig/plugins/${entry.name}`, resolve35(runtimeBins.pluginsDir, match[1]), options.projectRoot);
     }
   }
   await materializeRigGitBinary(options.binDir);
@@ -6614,8 +6673,8 @@ async function buildRuntimeToolchain(options) {
 }
 async function writeRuntimeManifest(config) {
   const scopeHash = sha256Hex(JSON.stringify(config.scopes));
-  const binarySha256 = sha256Hex(readFileSync17(config.binaryPath));
-  const manifestPath = resolve34(config.runtimeRoot, "manifest.json");
+  const binarySha256 = sha256Hex(readFileSync18(config.binaryPath));
+  const manifestPath = resolve35(config.runtimeRoot, "manifest.json");
   const manifest = {
     runtimeId: config.runtimeId,
     taskId: config.taskId,
@@ -6735,31 +6794,31 @@ function readFileMtimeMs(path) {
 }
 function linkRuntimeDependencyLayers(monorepoRoot, workspaceDir) {
   linkGenericNodeModulesLayers(monorepoRoot, workspaceDir);
-  const sourceNodeModules = resolve34(monorepoRoot, "humoongate", "node_modules");
-  if (!existsSync33(sourceNodeModules)) {} else {
-    const runtimeHumoongate = resolve34(workspaceDir, "humoongate");
-    if (existsSync33(resolve34(runtimeHumoongate, "package.json"))) {
-      const targetNodeModules = resolve34(runtimeHumoongate, "node_modules");
+  const sourceNodeModules = resolve35(monorepoRoot, "humoongate", "node_modules");
+  if (!existsSync35(sourceNodeModules)) {} else {
+    const runtimeHumoongate = resolve35(workspaceDir, "humoongate");
+    if (existsSync35(resolve35(runtimeHumoongate, "package.json"))) {
+      const targetNodeModules = resolve35(runtimeHumoongate, "node_modules");
       runtimeLinkDependencyLayerNative(sourceNodeModules, targetNodeModules);
     }
   }
-  const runtimeHpNext = resolve34(workspaceDir, "microservices", "hp-next-frontend", "app");
-  if (!existsSync33(resolve34(runtimeHpNext, "package.json"))) {
+  const runtimeHpNext = resolve35(workspaceDir, "microservices", "hp-next-frontend", "app");
+  if (!existsSync35(resolve35(runtimeHpNext, "package.json"))) {
     return;
   }
-  const sourceHpNextNodeModules = resolve34(monorepoRoot, "microservices", "hp-next-frontend", "app", "node_modules");
-  const sourceMonorepoNodeModules = resolve34(monorepoRoot, "node_modules");
-  const targetHpNextNodeModules = resolve34(runtimeHpNext, "node_modules");
-  if (existsSync33(sourceHpNextNodeModules)) {
+  const sourceHpNextNodeModules = resolve35(monorepoRoot, "microservices", "hp-next-frontend", "app", "node_modules");
+  const sourceMonorepoNodeModules = resolve35(monorepoRoot, "node_modules");
+  const targetHpNextNodeModules = resolve35(runtimeHpNext, "node_modules");
+  if (existsSync35(sourceHpNextNodeModules)) {
     runtimeLinkDependencyLayerNative(sourceHpNextNodeModules, targetHpNextNodeModules);
     return;
   }
-  if (existsSync33(sourceMonorepoNodeModules)) {
+  if (existsSync35(sourceMonorepoNodeModules)) {
     runtimeLinkDependencyLayerNative(sourceMonorepoNodeModules, targetHpNextNodeModules);
   }
 }
 function linkGenericNodeModulesLayers(monorepoRoot, workspaceDir) {
-  linkNodeModulesLayer(resolve34(monorepoRoot, "node_modules"), resolve34(workspaceDir, "node_modules"));
+  linkNodeModulesLayer(resolve35(monorepoRoot, "node_modules"), resolve35(workspaceDir, "node_modules"));
   for (const relativePackageDir of [
     "apps/native-app/apps/marketing",
     "apps/native-app/apps/web",
@@ -6781,15 +6840,15 @@ function linkGenericNodeModulesLayers(monorepoRoot, workspaceDir) {
     "packages/standard-plugin",
     "packages/validator-kit"
   ]) {
-    const workspacePackageDir = resolve34(workspaceDir, relativePackageDir);
-    if (!existsSync33(resolve34(workspacePackageDir, "package.json"))) {
+    const workspacePackageDir = resolve35(workspaceDir, relativePackageDir);
+    if (!existsSync35(resolve35(workspacePackageDir, "package.json"))) {
       continue;
     }
-    linkNodeModulesLayer(resolve34(monorepoRoot, relativePackageDir, "node_modules"), resolve34(workspacePackageDir, "node_modules"));
+    linkNodeModulesLayer(resolve35(monorepoRoot, relativePackageDir, "node_modules"), resolve35(workspacePackageDir, "node_modules"));
   }
 }
 function linkNodeModulesLayer(sourceDir, targetDir) {
-  if (!existsSync33(sourceDir) || existsSync33(targetDir)) {
+  if (!existsSync35(sourceDir) || existsSync35(targetDir)) {
     return;
   }
   try {
@@ -6798,23 +6857,23 @@ 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)}`);
   }
-  mkdirSync21(dirname16(targetDir), { recursive: true });
+  mkdirSync22(dirname17(targetDir), { recursive: true });
   symlinkSync4(sourceDir, targetDir, "dir");
 }
 function ensureRuntimeBinTrees(runtimeBinDir) {
-  const hooksDir = resolve34(runtimeBinDir, "hooks");
-  const pluginsDir = resolve34(runtimeBinDir, "plugins");
-  const validatorsDir = resolve34(runtimeBinDir, "validators");
-  mkdirSync21(hooksDir, { recursive: true });
-  mkdirSync21(pluginsDir, { recursive: true });
-  mkdirSync21(validatorsDir, { recursive: true });
+  const hooksDir = resolve35(runtimeBinDir, "hooks");
+  const pluginsDir = resolve35(runtimeBinDir, "plugins");
+  const validatorsDir = resolve35(runtimeBinDir, "validators");
+  mkdirSync22(hooksDir, { recursive: true });
+  mkdirSync22(pluginsDir, { recursive: true });
+  mkdirSync22(validatorsDir, { recursive: true });
   return { hooksDir, pluginsDir, validatorsDir };
 }
 
 // packages/runtime/src/control-plane/runtime/guard.ts
 import { optimizeNextInvocation } from "bun:jsc";
-import { existsSync as existsSync34, readFileSync as readFileSync18, statSync as statSync10 } from "fs";
-import { resolve as resolve35 } from "path";
+import { existsSync as existsSync36, readFileSync as readFileSync19, statSync as statSync10 } from "fs";
+import { resolve as resolve36 } from "path";
 
 // packages/runtime/src/control-plane/runtime/guard-types.ts
 var POLICY_VERSION = 1;
@@ -6877,8 +6936,8 @@ function loadPolicy(projectRoot) {
   if (seededPolicyConfig) {
     return seededPolicyConfig;
   }
-  const configPath = resolve35(projectRoot, "rig/policy/policy.json");
-  if (!existsSync34(configPath)) {
+  const configPath = resolve36(projectRoot, "rig/policy/policy.json");
+  if (!existsSync36(configPath)) {
     return defaultPolicy();
   }
   let mtimeMs;
@@ -6892,7 +6951,7 @@ function loadPolicy(projectRoot) {
   }
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync18(configPath, "utf-8"));
+    parsed = JSON.parse(readFileSync19(configPath, "utf-8"));
   } catch {
     return defaultPolicy();
   }
@@ -7108,28 +7167,28 @@ function resolveAction(mode, matched) {
 }
 function resolveAbsolutePath(projectRoot, rawPath) {
   if (rawPath.startsWith("/"))
-    return resolve35(rawPath);
-  return resolve35(projectRoot, rawPath);
+    return resolve36(rawPath);
+  return resolve36(projectRoot, rawPath);
 }
 function isHarnessPath(projectRoot, rawPath) {
   const absPath = resolveAbsolutePath(projectRoot, rawPath);
   const managedRoots = [
-    resolve35(projectRoot, "rig"),
-    resolve35(projectRoot, ".rig"),
-    resolve35(projectRoot, "artifacts")
+    resolve36(projectRoot, "rig"),
+    resolve36(projectRoot, ".rig"),
+    resolve36(projectRoot, "artifacts")
   ];
   return managedRoots.some((root) => absPath === root || absPath.startsWith(root + "/"));
 }
 function isRuntimePath(projectRoot, rawPath, taskWorkspace) {
   const absPath = resolveAbsolutePath(projectRoot, rawPath);
   if (taskWorkspace) {
-    const workspaceRigRoot = resolve35(taskWorkspace, ".rig");
-    const workspaceArtifactsRoot = resolve35(taskWorkspace, "artifacts");
+    const workspaceRigRoot = resolve36(taskWorkspace, ".rig");
+    const workspaceArtifactsRoot = resolve36(taskWorkspace, "artifacts");
     if (absPath === workspaceRigRoot || absPath.startsWith(workspaceRigRoot + "/") || absPath === workspaceArtifactsRoot || absPath.startsWith(workspaceArtifactsRoot + "/")) {
       return true;
     }
   }
-  const runtimeRoot = resolve35(projectRoot, ".rig/runtime/agents");
+  const runtimeRoot = resolve36(projectRoot, ".rig/runtime/agents");
   return absPath === runtimeRoot || absPath.startsWith(runtimeRoot + "/");
 }
 function isTestFile(path) {
@@ -7177,7 +7236,7 @@ function evaluateScope(policy, context, filePath, access) {
     return allowed();
   }
   if (context.taskWorkspace && context.taskWorkspace !== context.projectRoot && filePath.startsWith("/")) {
-    const absPath = resolve35(filePath);
+    const absPath = resolve36(filePath);
     if (!absPath.startsWith(context.taskWorkspace + "/") && !isHarnessPath(context.projectRoot, filePath)) {
       const reason2 = `Absolute path '${filePath}' is outside task runtime boundary. Allowed root: ${context.taskWorkspace}`;
       const matched2 = [{ id: "scope:workspace-boundary", category: "command", reason: reason2 }];
@@ -7409,9 +7468,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 mkdir3(resolve36(workspaceLayout.stateDir, "memory"), { recursive: true });
+    await mkdir3(resolve37(workspaceLayout.stateDir, "memory"), { recursive: true });
     await copyFile(snapshot.dbPath, hydratedPath);
     return {
       canonicalPath: CANONICAL_MEMORY_DB_PATH2,
@@ -7426,12 +7485,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 (!existsSync35(legacyConfigPath)) {
+    if (!existsSync37(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)}`;
@@ -7451,7 +7510,7 @@ async function createRuntimeTaskRecordReader(options) {
       source: "plugin"
     };
   }
-  if (existsSync35(legacyConfigPath)) {
+  if (existsSync37(legacyConfigPath)) {
     const message = "Using source-aware .rig/task-config.json task source compatibility path";
     options.diagnostics?.(message);
     console.warn(message);
@@ -7468,10 +7527,10 @@ async function createRuntimeTaskRecordReader(options) {
   };
 }
 function readConfiguredTaskSourceKindHint(projectRoot) {
-  const jsonPath = resolve36(projectRoot, "rig.config.json");
-  if (existsSync35(jsonPath)) {
+  const jsonPath = resolve37(projectRoot, "rig.config.json");
+  if (existsSync37(jsonPath)) {
     try {
-      const parsed = JSON.parse(readFileSync19(jsonPath, "utf8"));
+      const parsed = JSON.parse(readFileSync20(jsonPath, "utf8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         const taskSource = parsed.taskSource;
         if (taskSource && typeof taskSource === "object" && !Array.isArray(taskSource)) {
@@ -7483,12 +7542,12 @@ function readConfiguredTaskSourceKindHint(projectRoot) {
       return null;
     }
   }
-  const tsPath = resolve36(projectRoot, "rig.config.ts");
-  if (!existsSync35(tsPath)) {
+  const tsPath = resolve37(projectRoot, "rig.config.ts");
+  if (!existsSync37(tsPath)) {
     return null;
   }
   try {
-    const source = readFileSync19(tsPath, "utf8");
+    const source = readFileSync20(tsPath, "utf8");
     const taskSourceBlock = source.match(/taskSource\s*:\s*\{[\s\S]*?\}/m)?.[0] ?? "";
     const kind = taskSourceBlock.match(/kind\s*:\s*["']([^"']+)["']/)?.[1];
     return kind ?? null;
@@ -7558,8 +7617,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 mkdir3(resolve36(options.workspaceDir, ".rig"), { recursive: true });
+  const configPath = resolve37(options.workspaceDir, ".rig", "task-config.json");
+  await mkdir3(resolve37(options.workspaceDir, ".rig"), { recursive: true });
   await writeFile2(configPath, `${JSON.stringify({ [options.task.id]: entry }, null, 2)}
 `, "utf-8");
 }
@@ -7623,9 +7682,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 (!existsSync35(resolve36(monorepoRoot, ".git"))) {
+  if (!existsSync37(resolve37(monorepoRoot, ".git"))) {
     throw new Error(`Monorepo root is not a git checkout: ${monorepoRoot}`);
   }
   const taskResolution = await resolveRuntimeTaskRecord({
@@ -7660,7 +7719,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
@@ -7673,8 +7732,8 @@ async function ensureAgentRuntime(options) {
     projectRoot: options.projectRoot,
     workspaceDir
   });
-  mkdirSync22(runtime.binDir, { recursive: true });
-  mkdirSync22(workspaceLayout.distDir, { recursive: true });
+  mkdirSync23(runtime.binDir, { recursive: true });
+  mkdirSync23(workspaceLayout.distDir, { recursive: true });
   prepareRuntimeWorkspace(options.projectRoot, workspaceDir);
   if (options.preserveTaskArtifacts) {
     console.log(`[rig-agent] Preserving runtime task artifacts for resume of ${options.taskId}.`);
@@ -7693,7 +7752,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,
@@ -7709,8 +7768,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
@@ -7721,9 +7780,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,
@@ -7740,8 +7799,8 @@ async function ensureAgentRuntime(options) {
   });
   rmSync14(runtime.binDir, { recursive: true, force: true });
   rmSync14(workspaceLayout.distDir, { recursive: true, force: true });
-  mkdirSync22(runtime.binDir, { recursive: true });
-  mkdirSync22(workspaceLayout.distDir, { recursive: true });
+  mkdirSync23(runtime.binDir, { recursive: true });
+  mkdirSync23(workspaceLayout.distDir, { recursive: true });
   await buildRuntimeToolchain({
     projectRoot: options.projectRoot,
     workspaceDir,
@@ -7778,9 +7837,9 @@ async function ensureAgentRuntime(options) {
     workspaceDir,
     taskEntry
   });
-  const sandboxDir = resolve36(runtimeRoot, "sandbox");
+  const sandboxDir = resolve37(runtimeRoot, "sandbox");
   await mkdir3(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",
@@ -7827,7 +7886,7 @@ function isProvisionedRuntimeWorkspace(workspaceDir) {
     return false;
   }
   const layout = resolveRuntimeWorkspaceLayout(workspaceDir);
-  return existsSync36(resolve37(workspaceDir, ".git")) && existsSync36(resolve37(layout.binDir, "rig-agent")) && existsSync36(resolve37(layout.binDir, "hooks", "scope-guard")) && existsSync36(resolve37(layout.sessionDir, "session.json"));
+  return existsSync38(resolve38(workspaceDir, ".git")) && existsSync38(resolve38(layout.binDir, "rig-agent")) && existsSync38(resolve38(layout.binDir, "hooks", "scope-guard")) && existsSync38(resolve38(layout.sessionDir, "session.json"));
 }
 async function main() {
   const projectRoot = resolveProjectRoot();