@h-rig/runtime 0.0.6-alpha.28 → 0.0.6-alpha.29

package/dist/src/control-plane/hooks/inject-context.js

@@ -2,8 +2,8 @@
 // @bun
 
 // packages/runtime/src/control-plane/hooks/inject-context.ts
-import { existsSync as existsSync20, readFileSync as readFileSync12 } from "fs";
-import { resolve as resolve21 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync13 } from "fs";
+import { resolve as resolve22 } from "path";
 import { resolveProjectRoot } from "@rig/hook-kit";
 
 // packages/runtime/src/control-plane/memory-sync/db.ts
@@ -1128,8 +1128,8 @@ async function loadReviewProfile(path) {
 }
 
 // packages/runtime/src/control-plane/native/repo-ops.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync11, readFileSync as readFileSync11, readdirSync as readdirSync4, rmSync as rmSync4, writeFileSync as writeFileSync9 } from "fs";
-import { basename as basename7, dirname as dirname11, resolve as resolve20 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync12, readFileSync as readFileSync12, readdirSync as readdirSync5, rmSync as rmSync5, writeFileSync as writeFileSync10 } from "fs";
+import { basename as basename7, dirname as dirname11, resolve as resolve21 } from "path";
 
 // packages/runtime/src/control-plane/state-sync/types.ts
 var SUPPORTED_TASK_STATE_SCHEMA_VERSION = 1;
@@ -1626,8 +1626,8 @@ function syncManagedRepo(projectRoot, repoId) {
   return { layout, headCommit };
 }
 // packages/runtime/src/control-plane/native/task-ops.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync18, mkdirSync as mkdirSync10, readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "fs";
-import { resolve as resolve19 } from "path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync19, mkdirSync as mkdirSync11, readFileSync as readFileSync11, writeFileSync as writeFileSync9 } from "fs";
+import { resolve as resolve20 } from "path";
 
 // packages/runtime/src/build-time-config.ts
 function normalizeBuildConfig(value) {
@@ -2046,6 +2046,49 @@ function safeReadJson(path) {
   }
 }
 
+// packages/runtime/src/control-plane/skill-materializer.ts
+import { existsSync as existsSync12, mkdirSync as mkdirSync9, readFileSync as readFileSync5, readdirSync as readdirSync2, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "fs";
+import { resolve as resolve13 } from "path";
+import { loadSkill } from "@rig/skill-loader";
+var MARKER_FILENAME = ".rig-plugin";
+function skillDirName(id) {
+  return id.replace(/[^a-zA-Z0-9._-]+/g, "-");
+}
+async function materializeSkills(projectRoot, entries) {
+  const skillsRoot = resolve13(projectRoot, ".pi", "skills");
+  if (existsSync12(skillsRoot)) {
+    for (const name of readdirSync2(skillsRoot)) {
+      const dir = resolve13(skillsRoot, name);
+      if (existsSync12(resolve13(dir, MARKER_FILENAME))) {
+        rmSync3(dir, { recursive: true, force: true });
+      }
+    }
+  }
+  const written = [];
+  for (const { pluginName, skill } of entries) {
+    const sourcePath = resolve13(projectRoot, skill.path);
+    if (!existsSync12(sourcePath)) {
+      console.warn(`[plugin-host] skill "${skill.id}" from plugin "${pluginName}" not materialized: ${sourcePath} does not exist`);
+      continue;
+    }
+    let body;
+    try {
+      await loadSkill(sourcePath);
+      body = readFileSync5(sourcePath, "utf-8");
+    } catch (err) {
+      console.warn(`[plugin-host] skill "${skill.id}" from plugin "${pluginName}" not materialized: ${err instanceof Error ? err.message : err}`);
+      continue;
+    }
+    const dir = resolve13(skillsRoot, skillDirName(skill.id));
+    mkdirSync9(dir, { recursive: true });
+    writeFileSync5(resolve13(dir, "SKILL.md"), body, "utf-8");
+    writeFileSync5(resolve13(dir, MARKER_FILENAME), `${JSON.stringify({ plugin: pluginName, skillId: skill.id }, null, 2)}
+`, "utf-8");
+    written.push({ id: skill.id, pluginName, directory: dir });
+  }
+  return written;
+}
+
 // packages/runtime/src/control-plane/plugin-host-context.ts
 async function buildPluginHostContext(projectRoot) {
   let config;
@@ -2082,6 +2125,17 @@ async function buildPluginHostContext(projectRoot) {
   } catch (err) {
     console.warn(`[plugin-host] hook materialization failed: ${err instanceof Error ? err.message : err}`);
   }
+  try {
+    const skillEntries = config.plugins.flatMap((plugin) => (plugin.contributes?.skills ?? []).map((skill) => ({
+      pluginName: plugin.name,
+      skill
+    })));
+    if (skillEntries.length > 0) {
+      await materializeSkills(projectRoot, skillEntries);
+    }
+  } catch (err) {
+    console.warn(`[plugin-host] skill materialization failed: ${err instanceof Error ? err.message : err}`);
+  }
   return {
     config,
     pluginHost,
@@ -2095,12 +2149,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 readFileSync6, readdirSync as readdirSync2, statSync as statSync3, writeFileSync as writeFileSync5 } from "fs";
-import { basename as basename5, join as join4, resolve as resolve14 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync7, readdirSync as readdirSync3, statSync as statSync3, writeFileSync as writeFileSync6 } from "fs";
+import { basename as basename5, join as join4, resolve as resolve15 } from "path";
 
 // packages/runtime/src/control-plane/tasks/legacy-task-config-source.ts
-import { existsSync as existsSync12, readFileSync as readFileSync5 } from "fs";
-import { resolve as resolve13 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync6 } from "fs";
+import { resolve as resolve14 } from "path";
 
 // packages/runtime/src/control-plane/tasks/task-record-reader.ts
 async function findTaskById(reader, id) {
@@ -2123,7 +2177,7 @@ class LegacyTaskConfigReadError extends Error {
   }
 }
 function createLegacyTaskConfigRecordReader(projectRoot, options = {}) {
-  const configPath = options.configPath ?? resolve13(projectRoot, ".rig", "task-config.json");
+  const configPath = options.configPath ?? resolve14(projectRoot, ".rig", "task-config.json");
   const reader = {
     async listTasks() {
       return readLegacyTaskRecords(projectRoot, configPath);
@@ -2134,8 +2188,8 @@ function createLegacyTaskConfigRecordReader(projectRoot, options = {}) {
   };
   return reader;
 }
-function readLegacyTaskRecords(projectRoot, configPath = resolve13(projectRoot, ".rig", "task-config.json")) {
-  if (!existsSync12(configPath)) {
+function readLegacyTaskRecords(projectRoot, configPath = resolve14(projectRoot, ".rig", "task-config.json")) {
+  if (!existsSync13(configPath)) {
     return [];
   }
   const rawConfig = readLegacyTaskConfigJson(projectRoot, configPath);
@@ -2143,7 +2197,7 @@ function readLegacyTaskRecords(projectRoot, configPath = resolve13(projectRoot,
 }
 function readLegacyTaskConfigJson(projectRoot, configPath) {
   try {
-    const parsed = JSON.parse(readFileSync5(configPath, "utf8"));
+    const parsed = JSON.parse(readFileSync6(configPath, "utf8"));
     if (isPlainRecord(parsed)) {
       return parsed;
     }
@@ -2227,7 +2281,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 ?? resolve14(projectRoot, ".rig", "task-config.json");
+  const configPath = options.configPath ?? resolve15(projectRoot, ".rig", "task-config.json");
   const legacy = createLegacyTaskConfigRecordReader(projectRoot, { configPath });
   const spawnFn = options.spawn ?? spawnSync;
   const ghBinary = options.ghBinary ?? "gh";
@@ -2310,10 +2364,10 @@ function readMaterializedTaskMetadata(entry) {
   return metadata;
 }
 function readConfiguredFilesTaskSourcePath(projectRoot) {
-  const jsonPath = resolve14(projectRoot, "rig.config.json");
-  if (existsSync13(jsonPath)) {
+  const jsonPath = resolve15(projectRoot, "rig.config.json");
+  if (existsSync14(jsonPath)) {
     try {
-      const parsed = JSON.parse(readFileSync6(jsonPath, "utf8"));
+      const parsed = JSON.parse(readFileSync7(jsonPath, "utf8"));
       if (isPlainRecord2(parsed) && isPlainRecord2(parsed.taskSource)) {
         const source = parsed.taskSource;
         return source.kind === "files" && typeof source.path === "string" ? source.path : null;
@@ -2322,12 +2376,12 @@ function readConfiguredFilesTaskSourcePath(projectRoot) {
       return null;
     }
   }
-  const tsPath = resolve14(projectRoot, "rig.config.ts");
-  if (!existsSync13(tsPath)) {
+  const tsPath = resolve15(projectRoot, "rig.config.ts");
+  if (!existsSync14(tsPath)) {
     return null;
   }
   try {
-    const source = readFileSync6(tsPath, "utf8");
+    const source = readFileSync7(tsPath, "utf8");
     const taskSourceBlock = source.match(/taskSource\s*:\s*\{[\s\S]*?\}/m)?.[0] ?? "";
     const kind = taskSourceBlock.match(/kind\s*:\s*["']([^"']+)["']/)?.[1];
     if (kind !== "files") {
@@ -2347,10 +2401,10 @@ function readRawTaskEntry(configPath, taskId) {
   return isPlainRecord2(entry) ? entry : null;
 }
 function readRawTaskConfig(configPath) {
-  if (!existsSync13(configPath)) {
+  if (!existsSync14(configPath)) {
     return null;
   }
-  const parsed = JSON.parse(readFileSync6(configPath, "utf8"));
+  const parsed = JSON.parse(readFileSync7(configPath, "utf8"));
   return isPlainRecord2(parsed) ? parsed : null;
 }
 function stripLegacyTaskConfigMetadata2(raw) {
@@ -2358,12 +2412,12 @@ function stripLegacyTaskConfigMetadata2(raw) {
   return tasks;
 }
 function listFileBackedTasks(projectRoot, sourcePath) {
-  const directory = resolve14(projectRoot, sourcePath);
-  if (!existsSync13(directory)) {
+  const directory = resolve15(projectRoot, sourcePath);
+  if (!existsSync14(directory)) {
     return [];
   }
   const tasks = [];
-  for (const name of readdirSync2(directory)) {
+  for (const name of readdirSync3(directory)) {
     if (!FILE_TASK_PATTERN.test(name))
       continue;
     const inferredId = basename5(name).replace(FILE_TASK_PATTERN, "");
@@ -2374,11 +2428,11 @@ function listFileBackedTasks(projectRoot, sourcePath) {
   return tasks;
 }
 function readFileBackedTask(projectRoot, sourcePath, taskId, rawEntry) {
-  const file = findFileBackedTaskFile(resolve14(projectRoot, sourcePath), taskId);
+  const file = findFileBackedTaskFile(resolve15(projectRoot, sourcePath), taskId);
   if (!file) {
     return null;
   }
-  const raw = JSON.parse(readFileSync6(file, "utf8"));
+  const raw = JSON.parse(readFileSync7(file, "utf8"));
   if (!isPlainRecord2(raw)) {
     return null;
   }
@@ -2391,17 +2445,17 @@ function readFileBackedTask(projectRoot, sourcePath, taskId, rawEntry) {
   };
 }
 function findFileBackedTaskFile(directory, taskId) {
-  if (!existsSync13(directory)) {
+  if (!existsSync14(directory)) {
     return null;
   }
-  for (const name of readdirSync2(directory)) {
+  for (const name of readdirSync3(directory)) {
     if (!FILE_TASK_PATTERN.test(name))
       continue;
     const file = join4(directory, name);
     try {
       if (!statSync3(file).isFile())
         continue;
-      const raw = JSON.parse(readFileSync6(file, "utf8"));
+      const raw = JSON.parse(readFileSync7(file, "utf8"));
       const inferredId = basename5(file).replace(FILE_TASK_PATTERN, "");
       const id = isPlainRecord2(raw) && typeof raw.id === "string" ? raw.id : inferredId;
       if (id === taskId) {
@@ -2561,30 +2615,30 @@ async function readConfiguredTaskSourceTask(projectRoot, taskId) {
 }
 
 // packages/runtime/src/control-plane/native/task-state.ts
-import { existsSync as existsSync17, readFileSync as readFileSync9, readdirSync as readdirSync3, statSync as statSync4, writeFileSync as writeFileSync7 } from "fs";
-import { basename as basename6, resolve as resolve18 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync10, readdirSync as readdirSync4, statSync as statSync4, writeFileSync as writeFileSync8 } from "fs";
+import { basename as basename6, resolve as resolve19 } from "path";
 // packages/runtime/src/control-plane/state-sync/read.ts
-import { existsSync as existsSync16, readFileSync as readFileSync8 } from "fs";
-import { resolve as resolve17 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync9 } from "fs";
+import { resolve as resolve18 } from "path";
 
 // packages/runtime/src/control-plane/native/git-native.ts
-import { chmodSync as chmodSync2, copyFileSync as copyFileSync3, existsSync as existsSync14, mkdirSync as mkdirSync9, readFileSync as readFileSync7, renameSync as renameSync2, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "fs";
+import { chmodSync as chmodSync2, copyFileSync as copyFileSync3, existsSync as existsSync15, mkdirSync as mkdirSync10, readFileSync as readFileSync8, renameSync as renameSync2, rmSync as rmSync4, writeFileSync as writeFileSync7 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { dirname as dirname10, isAbsolute, resolve as resolve15 } from "path";
+import { dirname as dirname10, isAbsolute, resolve as resolve16 } from "path";
 import { createHash as createHash2 } from "crypto";
-var sharedGitNativeOutputDir = resolve15(tmpdir4(), "rig-native");
-var sharedGitNativeOutputPath = resolve15(sharedGitNativeOutputDir, `rig-git-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`);
+var sharedGitNativeOutputDir = resolve16(tmpdir4(), "rig-native");
+var sharedGitNativeOutputPath = resolve16(sharedGitNativeOutputDir, `rig-git-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`);
 var trackerCommandUsageProbe = "usage: rig-git fetch-ref <repo-path> <remote> <branch>";
 function temporaryGitBinaryOutputPath(outputPath) {
   const suffix2 = process.platform === "win32" ? ".exe" : "";
-  return resolve15(dirname10(outputPath), `.rig-git-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}${suffix2}`);
+  return resolve16(dirname10(outputPath), `.rig-git-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}${suffix2}`);
 }
 function publishGitBinary(tempOutputPath, outputPath) {
   try {
     renameSync2(tempOutputPath, outputPath);
   } catch (error) {
-    if (process.platform === "win32" && existsSync14(outputPath)) {
-      rmSync3(outputPath, { force: true });
+    if (process.platform === "win32" && existsSync15(outputPath)) {
+      rmSync4(outputPath, { force: true });
       renameSync2(tempOutputPath, outputPath);
       return;
     }
@@ -2599,22 +2653,22 @@ function rigGitSourceCandidates() {
   const cwd = process.cwd()?.trim() || "";
   const projectRoot = process.env.PROJECT_RIG_ROOT?.trim() || "";
   const hostProjectRoot = process.env.RIG_HOST_PROJECT_ROOT?.trim() || "";
-  const moduleRelativeSource = resolve15(import.meta.dir, "../../../native/rig-git.zig");
+  const moduleRelativeSource = resolve16(import.meta.dir, "../../../native/rig-git.zig");
   return [...new Set([
     process.env.RIG_NATIVE_GIT_SOURCE?.trim() || "",
     moduleRelativeSource,
-    projectRoot ? resolve15(projectRoot, "packages/runtime/native/rig-git.zig") : "",
-    hostProjectRoot ? resolve15(hostProjectRoot, "packages/runtime/native/rig-git.zig") : "",
-    cwd ? resolve15(cwd, "packages/runtime/native/rig-git.zig") : "",
-    execDir ? resolve15(execDir, "..", "..", "packages/runtime/native/rig-git.zig") : "",
-    execDir ? resolve15(execDir, "..", "native", "rig-git.zig") : ""
+    projectRoot ? resolve16(projectRoot, "packages/runtime/native/rig-git.zig") : "",
+    hostProjectRoot ? resolve16(hostProjectRoot, "packages/runtime/native/rig-git.zig") : "",
+    cwd ? resolve16(cwd, "packages/runtime/native/rig-git.zig") : "",
+    execDir ? resolve16(execDir, "..", "..", "packages/runtime/native/rig-git.zig") : "",
+    execDir ? resolve16(execDir, "..", "native", "rig-git.zig") : ""
   ].filter(Boolean))];
 }
 function nativePackageBinaryCandidates(fromDir, fileName) {
   const candidates = [];
-  let cursor = resolve15(fromDir);
+  let cursor = resolve16(fromDir);
   for (let index = 0;index < 8; index += 1) {
-    candidates.push(resolve15(cursor, "native", `${process.platform}-${process.arch}`, fileName), resolve15(cursor, "native", `${process.platform}-${process.arch}`, "bin", fileName), resolve15(cursor, "native", fileName), resolve15(cursor, "native", "bin", fileName));
+    candidates.push(resolve16(cursor, "native", `${process.platform}-${process.arch}`, fileName), resolve16(cursor, "native", `${process.platform}-${process.arch}`, "bin", fileName), resolve16(cursor, "native", fileName), resolve16(cursor, "native", "bin", fileName));
     const parent = dirname10(cursor);
     if (parent === cursor)
       break;
@@ -2629,15 +2683,15 @@ function rigGitBinaryCandidates() {
   return [...new Set([
     explicit,
     ...nativePackageBinaryCandidates(import.meta.dir, fileName),
-    execDir ? resolve15(execDir, fileName) : "",
-    execDir ? resolve15(execDir, "..", fileName) : "",
-    execDir ? resolve15(execDir, "..", "bin", fileName) : "",
+    execDir ? resolve16(execDir, fileName) : "",
+    execDir ? resolve16(execDir, "..", fileName) : "",
+    execDir ? resolve16(execDir, "..", "bin", fileName) : "",
     sharedGitNativeOutputPath
   ].filter(Boolean))];
 }
 function resolveGitSourcePath() {
   for (const candidate of rigGitSourceCandidates()) {
-    if (candidate && existsSync14(candidate)) {
+    if (candidate && existsSync15(candidate)) {
       return candidate;
     }
   }
@@ -2648,7 +2702,7 @@ function resolveGitBinaryPath() {
     return null;
   }
   for (const candidate of rigGitBinaryCandidates()) {
-    if (candidate && existsSync14(candidate)) {
+    if (candidate && existsSync15(candidate)) {
       return candidate;
     }
   }
@@ -2678,18 +2732,18 @@ function nativeBuildManifestPath(outputPath) {
   return `${outputPath}.build-manifest.json`;
 }
 function hasMatchingNativeBuildManifestSync(manifestPath, buildKey) {
-  if (!existsSync14(manifestPath)) {
+  if (!existsSync15(manifestPath)) {
     return false;
   }
   try {
-    const manifest = JSON.parse(readFileSync7(manifestPath, "utf8"));
+    const manifest = JSON.parse(readFileSync8(manifestPath, "utf8"));
     return manifest.version === 1 && manifest.buildKey === buildKey;
   } catch {
     return false;
   }
 }
 function sha256FileSync(path) {
-  return createHash2("sha256").update(readFileSync7(path)).digest("hex");
+  return createHash2("sha256").update(readFileSync8(path)).digest("hex");
 }
 function ensureRigGitBinaryPathSync(outputPath = preferredGitBinaryOutputPath()) {
   if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
@@ -2707,7 +2761,7 @@ function ensureRigGitBinaryPathSync(outputPath = preferredGitBinaryOutputPath())
   if (!zigBinary) {
     throw new Error("zig is required to build native Rig git tools.");
   }
-  mkdirSync9(dirname10(outputPath), { recursive: true });
+  mkdirSync10(dirname10(outputPath), { recursive: true });
   const sourceDigest = sha256FileSync(sourcePath);
   const buildKey = JSON.stringify({
     version: 1,
@@ -2718,7 +2772,7 @@ function ensureRigGitBinaryPathSync(outputPath = preferredGitBinaryOutputPath())
     sourceDigest
   });
   const manifestPath = nativeBuildManifestPath(outputPath);
-  const needsBuild = !existsSync14(outputPath) || !hasMatchingNativeBuildManifestSync(manifestPath, buildKey) || !binarySupportsTrackerCommandsSync(outputPath);
+  const needsBuild = !existsSync15(outputPath) || !hasMatchingNativeBuildManifestSync(manifestPath, buildKey) || !binarySupportsTrackerCommandsSync(outputPath);
   if (!needsBuild) {
     chmodSync2(outputPath, 493);
     return outputPath;
@@ -2736,7 +2790,7 @@ function ensureRigGitBinaryPathSync(outputPath = preferredGitBinaryOutputPath())
     stdout: "pipe",
     stderr: "pipe"
   });
-  if (build.exitCode !== 0 || !existsSync14(tempOutputPath)) {
+  if (build.exitCode !== 0 || !existsSync15(tempOutputPath)) {
     const stderr = build.stderr.toString().trim();
     const stdout = build.stdout.toString().trim();
     const details = [stderr, stdout].filter(Boolean).join(`
@@ -2744,17 +2798,17 @@ function ensureRigGitBinaryPathSync(outputPath = preferredGitBinaryOutputPath())
     throw new Error(`Failed to build native Rig git tools: ${details || `zig exited with code ${build.exitCode}`}`);
   }
   chmodSync2(tempOutputPath, 493);
-  if (existsSync14(outputPath) && hasMatchingNativeBuildManifestSync(manifestPath, buildKey)) {
-    rmSync3(tempOutputPath, { force: true });
+  if (existsSync15(outputPath) && hasMatchingNativeBuildManifestSync(manifestPath, buildKey)) {
+    rmSync4(tempOutputPath, { force: true });
     chmodSync2(outputPath, 493);
     return outputPath;
   }
   publishGitBinary(tempOutputPath, outputPath);
   if (!binarySupportsTrackerCommandsSync(outputPath)) {
-    rmSync3(outputPath, { force: true });
+    rmSync4(outputPath, { force: true });
     throw new Error("Failed to build native Rig git tools: tracker command probe failed");
   }
-  writeFileSync6(manifestPath, `${JSON.stringify({ version: 1, buildKey }, null, 2)}
+  writeFileSync7(manifestPath, `${JSON.stringify({ version: 1, buildKey }, null, 2)}
 `, "utf8");
   return outputPath;
 }
@@ -2776,7 +2830,7 @@ function runGitNative(command, args) {
     }
   } else {
     const explicitBinaryPath = process.env.RIG_NATIVE_GIT_BIN?.trim() || "";
-    binaryPath = explicitBinaryPath && existsSync14(explicitBinaryPath) ? explicitBinaryPath : !explicitBinaryPath ? resolveGitBinaryPath() : null;
+    binaryPath = explicitBinaryPath && existsSync15(explicitBinaryPath) ? explicitBinaryPath : !explicitBinaryPath ? resolveGitBinaryPath() : null;
     if (!binaryPath) {
       try {
         binaryPath = ensureRigGitBinaryPathSync(preferredGitBinaryOutputPath());
@@ -2832,25 +2886,25 @@ function nativeFetchRef(repoPath, remote, branch) {
   return requireGitNativeString("fetch-ref", [repoPath, remote, branch]);
 }
 function nativeReadBlobAtRef(repoPath, ref, path) {
-  const requestDir = resolve15(sharedGitNativeOutputDir, "reads", `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`);
-  mkdirSync9(requestDir, { recursive: true });
-  const outputPath = resolve15(requestDir, "blob.txt");
+  const requestDir = resolve16(sharedGitNativeOutputDir, "reads", `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`);
+  mkdirSync10(requestDir, { recursive: true });
+  const outputPath = resolve16(requestDir, "blob.txt");
   try {
     requireGitNative("read-blob-at-ref", [repoPath, ref, path, outputPath]);
-    return readFileSync7(outputPath, "utf8");
+    return readFileSync8(outputPath, "utf8");
   } finally {
-    rmSync3(requestDir, { recursive: true, force: true });
+    rmSync4(requestDir, { recursive: true, force: true });
   }
 }
 
 // packages/runtime/src/control-plane/state-sync/repo.ts
-import { existsSync as existsSync15 } from "fs";
-import { resolve as resolve16 } from "path";
+import { existsSync as existsSync16 } from "fs";
+import { resolve as resolve17 } from "path";
 function resolveTrackerRepoPath(projectRoot) {
   const monorepoRoot = resolveMonorepoRoot2(projectRoot);
   try {
     const layout = resolveMonorepoRepoLayout(projectRoot);
-    if (existsSync15(resolve16(layout.mirrorRoot, "HEAD"))) {
+    if (existsSync16(resolve17(layout.mirrorRoot, "HEAD"))) {
       return layout.mirrorRoot;
     }
   } catch {}
@@ -2861,8 +2915,8 @@ function resolveTrackerRepoPath(projectRoot) {
 var DEFAULT_READ_DEPS = {
   fetchRef: nativeFetchRef,
   readBlobAtRef: nativeReadBlobAtRef,
-  exists: existsSync16,
-  readFile: (path) => readFileSync8(path, "utf8")
+  exists: existsSync17,
+  readFile: (path) => readFileSync9(path, "utf8")
 };
 function parseIssueStatus(rawStatus) {
   const normalized = normalizeTaskLifecycleStatus(rawStatus);
@@ -2943,12 +2997,12 @@ function shouldPreferLocalTrackerState(options) {
   if (runtimeContextPath) {
     return true;
   }
-  return existsSync16(resolve17(runtimeWorkspace, ".rig", "runtime-context.json"));
+  return existsSync17(resolve18(runtimeWorkspace, ".rig", "runtime-context.json"));
 }
 function readLocalTrackerState(projectRoot, deps) {
   const monorepoRoot = resolveMonorepoRoot2(projectRoot);
-  const issuesPath = resolve17(monorepoRoot, ".beads", "issues.jsonl");
-  const taskStatePath = resolve17(monorepoRoot, ".beads", "task-state.json");
+  const issuesPath = resolve18(monorepoRoot, ".beads", "issues.jsonl");
+  const taskStatePath = resolve18(monorepoRoot, ".beads", "task-state.json");
   return projectSyncedTrackerSnapshot({
     source: "local",
     issuesBaseOid: null,
@@ -3010,7 +3064,7 @@ function readValidationDescriptions(projectRoot) {
   return readValidationDescriptionMap(raw);
 }
 function readSourceValidationDescriptions(projectRoot) {
-  const rootRaw = readJsonFile(resolve18(projectRoot, "rig", "task-config.json"), {});
+  const rootRaw = readJsonFile(resolve19(projectRoot, "rig", "task-config.json"), {});
   const sourcePath = findSourceTaskConfigPath(projectRoot);
   const sourceRaw = sourcePath ? readJsonFile(sourcePath, {}) : {};
   const rootDescriptions = readValidationDescriptionMap(rootRaw);
@@ -3086,15 +3140,15 @@ function readValidationDescriptionsFromMeta(meta) {
   return meta.validation_descriptions;
 }
 function readLocalSourceTaskStateEnvelope(projectRoot) {
-  const taskStatePath = resolve18(resolveMonorepoRoot2(projectRoot), ".beads", "task-state.json");
+  const taskStatePath = resolve19(resolveMonorepoRoot2(projectRoot), ".beads", "task-state.json");
   return readTaskStateMetadataEnvelope(readJsonFile(taskStatePath, {}));
 }
 function readLocalSourceTaskLifecycleStatus(projectRoot, taskId) {
-  const issuesPath = resolve18(resolveMonorepoRoot2(projectRoot), ".beads", "issues.jsonl");
-  if (!existsSync17(issuesPath)) {
+  const issuesPath = resolve19(resolveMonorepoRoot2(projectRoot), ".beads", "issues.jsonl");
+  if (!existsSync18(issuesPath)) {
     return null;
   }
-  for (const line of readFileSync9(issuesPath, "utf8").split(/\r?\n/)) {
+  for (const line of readFileSync10(issuesPath, "utf8").split(/\r?\n/)) {
     const trimmed = line.trim();
     if (!trimmed) {
       continue;
@@ -3119,25 +3173,25 @@ function inferTaskIdFromRuntimePath(path) {
 function artifactDirForId(projectRoot, id) {
   const workspaceDir = process.env.RIG_TASK_WORKSPACE?.trim();
   if (workspaceDir) {
-    const worktreeArtifacts = resolve18(workspaceDir, "artifacts", id);
-    if (existsSync17(worktreeArtifacts) || existsSync17(resolve18(workspaceDir, "artifacts"))) {
+    const worktreeArtifacts = resolve19(workspaceDir, "artifacts", id);
+    if (existsSync18(worktreeArtifacts) || existsSync18(resolve19(workspaceDir, "artifacts"))) {
       return worktreeArtifacts;
     }
   }
   try {
     const paths = resolveHarnessPaths(projectRoot);
-    return resolve18(paths.artifactsDir, id);
+    return resolve19(paths.artifactsDir, id);
   } catch {
-    return resolve18(resolveMonorepoRoot2(projectRoot), "artifacts", id);
+    return resolve19(resolveMonorepoRoot2(projectRoot), "artifacts", id);
   }
 }
 function resolveTaskConfigPath(projectRoot) {
   const paths = resolveHarnessPaths(projectRoot);
-  if (existsSync17(paths.taskConfigPath)) {
+  if (existsSync18(paths.taskConfigPath)) {
     return paths.taskConfigPath;
   }
   for (const candidate of sourceTaskConfigCandidates(projectRoot)) {
-    if (existsSync17(candidate)) {
+    if (existsSync18(candidate)) {
       return candidate;
     }
   }
@@ -3145,7 +3199,7 @@ function resolveTaskConfigPath(projectRoot) {
 }
 function findSourceTaskConfigPath(projectRoot) {
   for (const candidate of sourceTaskConfigCandidates(projectRoot)) {
-    if (existsSync17(candidate)) {
+    if (existsSync18(candidate)) {
       return candidate;
     }
   }
@@ -3158,7 +3212,7 @@ function readAndSyncSourceTaskConfig(projectRoot) {
   const synced = synchronizeTaskConfigWithTracker(projectRoot, raw);
   if (sourcePath && synced.updated) {
     try {
-      writeFileSync7(sourcePath, `${JSON.stringify(synced.config, null, 2)}
+      writeFileSync8(sourcePath, `${JSON.stringify(synced.config, null, 2)}
 `, "utf-8");
     } catch {}
   }
@@ -3210,12 +3264,12 @@ function shouldRefreshAutoSyncedTaskConfigEntry(entry) {
   return !candidate.role;
 }
 function readSourceIssueRecords(projectRoot) {
-  const issuesPath = resolve18(resolveMonorepoRoot2(projectRoot), ".beads", "issues.jsonl");
-  if (!existsSync17(issuesPath)) {
+  const issuesPath = resolve19(resolveMonorepoRoot2(projectRoot), ".beads", "issues.jsonl");
+  if (!existsSync18(issuesPath)) {
     return [];
   }
   const records = [];
-  for (const line of readFileSync9(issuesPath, "utf-8").split(/\r?\n/)) {
+  for (const line of readFileSync10(issuesPath, "utf-8").split(/\r?\n/)) {
     const trimmed = line.trim();
     if (!trimmed) {
       continue;
@@ -3271,19 +3325,19 @@ function readConfiguredFileTaskConfig(projectRoot) {
   if (!sourcePath) {
     return {};
   }
-  const directory = resolve18(projectRoot, sourcePath);
-  if (!existsSync17(directory)) {
+  const directory = resolve19(projectRoot, sourcePath);
+  if (!existsSync18(directory)) {
     return {};
   }
   const config = {};
-  for (const name of readdirSync3(directory)) {
+  for (const name of readdirSync4(directory)) {
     if (!FILE_TASK_PATTERN2.test(name))
       continue;
-    const file = resolve18(directory, name);
+    const file = resolve19(directory, name);
     try {
       if (!statSync4(file).isFile())
         continue;
-      const raw = JSON.parse(readFileSync9(file, "utf8"));
+      const raw = JSON.parse(readFileSync10(file, "utf8"));
       if (!raw || typeof raw !== "object" || Array.isArray(raw))
         continue;
       const record = raw;
@@ -3325,10 +3379,10 @@ function firstStringList2(...candidates) {
   return [];
 }
 function readConfiguredFilesTaskSourcePath2(projectRoot) {
-  const jsonPath = resolve18(projectRoot, "rig.config.json");
-  if (existsSync17(jsonPath)) {
+  const jsonPath = resolve19(projectRoot, "rig.config.json");
+  if (existsSync18(jsonPath)) {
     try {
-      const parsed = JSON.parse(readFileSync9(jsonPath, "utf8"));
+      const parsed = JSON.parse(readFileSync10(jsonPath, "utf8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         const taskSource = parsed.taskSource;
         if (taskSource && typeof taskSource === "object" && !Array.isArray(taskSource)) {
@@ -3340,12 +3394,12 @@ function readConfiguredFilesTaskSourcePath2(projectRoot) {
       return null;
     }
   }
-  const tsPath = resolve18(projectRoot, "rig.config.ts");
-  if (!existsSync17(tsPath)) {
+  const tsPath = resolve19(projectRoot, "rig.config.ts");
+  if (!existsSync18(tsPath)) {
     return null;
   }
   try {
-    const source = readFileSync9(tsPath, "utf8");
+    const source = readFileSync10(tsPath, "utf8");
     const taskSourceBlock = source.match(/taskSource\s*:\s*\{[\s\S]*?\}/m)?.[0] ?? "";
     const kind = taskSourceBlock.match(/kind\s*:\s*["']([^"']+)["']/)?.[1];
     if (kind !== "files") {
@@ -3359,9 +3413,9 @@ function readConfiguredFilesTaskSourcePath2(projectRoot) {
 function sourceTaskConfigCandidates(projectRoot) {
   const runtimeContext = loadRuntimeContextFromEnv();
   return [
-    runtimeContext?.monorepoMainRoot ? resolve18(runtimeContext.monorepoMainRoot, ".rig", "task-config.json") : "",
-    process.env.MONOREPO_MAIN_ROOT?.trim() ? resolve18(process.env.MONOREPO_MAIN_ROOT.trim(), ".rig", "task-config.json") : "",
-    resolve18(resolveMonorepoRoot2(projectRoot), ".rig", "task-config.json")
+    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")
   ].filter(Boolean);
 }
 
@@ -3660,16 +3714,16 @@ async function taskDeps(projectRoot, taskId) {
   for (const dep of deps) {
     const artifactDir = artifactDirForId(projectRoot, dep);
     console.log(`=== ${dep} ===`);
-    if (!existsSync18(artifactDir)) {
+    if (!existsSync19(artifactDir)) {
       console.log(`  (no artifacts yet)
 `);
       continue;
     }
-    printArtifactSection(resolve19(artifactDir, "decision-log.md"), "--- Decisions ---");
-    printArtifactSection(resolve19(artifactDir, "next-actions.md"), "--- Next Actions (for you) ---");
-    const changedFiles = resolve19(artifactDir, "changed-files.txt");
-    if (existsSync18(changedFiles)) {
-      const lines = readFileSync10(changedFiles, "utf-8").split(/\r?\n/).filter(Boolean);
+    printArtifactSection(resolve20(artifactDir, "decision-log.md"), "--- Decisions ---");
+    printArtifactSection(resolve20(artifactDir, "next-actions.md"), "--- Next Actions (for you) ---");
+    const changedFiles = resolve20(artifactDir, "changed-files.txt");
+    if (existsSync19(changedFiles)) {
+      const lines = readFileSync11(changedFiles, "utf-8").split(/\r?\n/).filter(Boolean);
       console.log(`--- Changed Files (${lines.length}) ---`);
       for (const line of lines) {
         console.log(line);
@@ -3770,12 +3824,12 @@ function printIndented(text) {
   }
 }
 function readLocalBeadsTasks(projectRoot) {
-  const issuesPath = resolve19(resolveMonorepoRoot2(projectRoot), ".beads/issues.jsonl");
-  if (!existsSync18(issuesPath)) {
+  const issuesPath = resolve20(resolveMonorepoRoot2(projectRoot), ".beads/issues.jsonl");
+  if (!existsSync19(issuesPath)) {
     return [];
   }
   const tasks = [];
-  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;
@@ -3888,11 +3942,11 @@ function taskDependencies(projectRoot, taskId, tracker) {
   return [...ids].sort();
 }
 function printArtifactSection(path, header) {
-  if (!existsSync18(path)) {
+  if (!existsSync19(path)) {
     return;
   }
   console.log(header);
-  process.stdout.write(readFileSync10(path, "utf-8"));
+  process.stdout.write(readFileSync11(path, "utf-8"));
   console.log("");
 }
 
@@ -3918,7 +3972,7 @@ function repoDiscover(projectRoot, taskId) {
 }
 function repoBaseline(projectRoot, refresh = false) {
   const paths = resolveRepoDiscoveryPaths(projectRoot);
-  if (!refresh && existsSync19(paths.baseRepoPinsPath)) {
+  if (!refresh && existsSync20(paths.baseRepoPinsPath)) {
     const baseline = readJsonFile(paths.baseRepoPinsPath, { recorded_at: nowIso(), repos: {} });
     return baseline.repos || {};
   }
@@ -3932,8 +3986,8 @@ function repoBaseline(projectRoot, refresh = false) {
 }
 function persistBaselinePins(projectRoot, repos) {
   const paths = resolveRepoDiscoveryPaths(projectRoot);
-  mkdirSync11(resolve20(paths.baseRepoPinsPath, ".."), { recursive: true });
-  writeFileSync9(paths.baseRepoPinsPath, `${JSON.stringify({ recorded_at: nowIso(), repos }, null, 2)}
+  mkdirSync12(resolve21(paths.baseRepoPinsPath, ".."), { recursive: true });
+  writeFileSync10(paths.baseRepoPinsPath, `${JSON.stringify({ recorded_at: nowIso(), repos }, null, 2)}
 `, "utf-8");
   return repos;
 }
@@ -4005,28 +4059,28 @@ function readRepoDiscoveryTaskConfig(projectRoot) {
 function resolveRepoDiscoveryPaths(projectRoot) {
   const monorepoRoot = resolveMonorepoRepoLayout(projectRoot).checkoutRoot;
   const explicitHostProjectRoot = (process.env.RIG_HOST_PROJECT_ROOT || "").trim();
-  const normalizedProjectRoot = resolve20(projectRoot);
+  const normalizedProjectRoot = resolve21(projectRoot);
   const hostProjectRoot = explicitHostProjectRoot && shouldUseHostProjectStateRoot(normalizedProjectRoot) ? explicitHostProjectRoot : normalizedProjectRoot;
-  const stateDir = resolve20(hostProjectRoot, ".rig", "state");
+  const stateDir = resolve21(hostProjectRoot, ".rig", "state");
   return {
     monorepoRoot,
-    taskRepoCommitsPath: resolve20(stateDir, "task-repo-commits.json"),
-    baseRepoPinsPath: resolve20(stateDir, "base-repo-pins.json")
+    taskRepoCommitsPath: resolve21(stateDir, "task-repo-commits.json"),
+    baseRepoPinsPath: resolve21(stateDir, "base-repo-pins.json")
   };
 }
 function shouldUseHostProjectStateRoot(projectRoot) {
   const runtimeWorkspace = process.env.RIG_TASK_WORKSPACE?.trim();
-  if (runtimeWorkspace && resolve20(runtimeWorkspace) === projectRoot) {
+  if (runtimeWorkspace && resolve21(runtimeWorkspace) === projectRoot) {
     return true;
   }
   return basename7(dirname11(projectRoot)) === ".worktrees";
 }
 function readPinFromArtifact(projectRoot, depTask, repoKey) {
-  const snapshot = resolve20(artifactDirForId(projectRoot, depTask), "git-state.txt");
-  if (!existsSync19(snapshot)) {
+  const snapshot = resolve21(artifactDirForId(projectRoot, depTask), "git-state.txt");
+  if (!existsSync20(snapshot)) {
     return "";
   }
-  const content = readFileSync11(snapshot, "utf-8");
+  const content = readFileSync12(snapshot, "utf-8");
   const chunk = content.split(/\r?\n/);
   let inSection = false;
   for (const line of chunk) {
@@ -4055,7 +4109,7 @@ function defaultMemoryQuery(taskId, runtimeContext) {
 async function printSharedMemorySection(taskId) {
   const runtimeContext = loadRuntimeContextFromEnv();
   const memory = runtimeContext?.memory;
-  if (!memory?.hydratedPath || !existsSync20(memory.hydratedPath)) {
+  if (!memory?.hydratedPath || !existsSync21(memory.hydratedPath)) {
     return;
   }
   const db = await openMemoryDb(memory.hydratedPath);
@@ -4102,17 +4156,17 @@ async function main() {
     console.log("(no explicit/discovered task pins)");
   } else {
     for (const [key, expected] of Object.entries(pins)) {
-      const repoPath = key.startsWith("/") ? key : resolve21(projectRoot, key);
+      const repoPath = key.startsWith("/") ? key : resolve22(projectRoot, key);
       let current = "missing";
-      if (existsSync20(resolve21(repoPath, ".git"))) {
+      if (existsSync21(resolve22(repoPath, ".git"))) {
         current = runCapture(["git", "-C", repoPath, "rev-parse", "HEAD"], projectRoot).stdout.trim() || "unknown";
       }
       console.log(`${current === expected ? "OK  " : "WARN"} ${key} expected ${expected} got ${current}`);
     }
   }
-  const failedPath = resolve21(resolveHarnessPaths(projectRoot).stateDir, "failed_approaches.md");
-  if (existsSync20(failedPath)) {
-    const lines = readFileSync12(failedPath, "utf-8").split(/\r?\n/);
+  const failedPath = resolve22(resolveHarnessPaths(projectRoot).stateDir, "failed_approaches.md");
+  if (existsSync21(failedPath)) {
+    const lines = readFileSync13(failedPath, "utf-8").split(/\r?\n/);
     let printing = false;
     const failureLines = [];
     for (const line of lines) {