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

package/dist/src/control-plane/native/verifier.js

@@ -1,7 +1,7 @@
 // @bun
 // packages/runtime/src/control-plane/native/verifier.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync5, writeFileSync as writeFileSync6 } from "fs";
-import { resolve as resolve13 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync6, writeFileSync as writeFileSync7 } from "fs";
+import { resolve as resolve14 } from "path";
 
 // packages/runtime/src/control-plane/runtime/baked-secrets.ts
 var BAKED_RUNTIME_SECRETS = {
@@ -47,8 +47,8 @@ function resolveRuntimeSecrets(env, baked = BAKED_RUNTIME_SECRETS) {
 }
 
 // packages/runtime/src/control-plane/native/git-ops.ts
-import { existsSync as existsSync10, lstatSync, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname8, isAbsolute as isAbsolute2, resolve as resolve12 } from "path";
+import { existsSync as existsSync11, lstatSync, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname8, isAbsolute as isAbsolute2, resolve as resolve13 } from "path";
 
 // packages/runtime/src/control-plane/runtime/context.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
@@ -539,6 +539,49 @@ function safeReadJson(path) {
   }
 }
 
+// packages/runtime/src/control-plane/skill-materializer.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, readdirSync, rmSync, writeFileSync as writeFileSync3 } from "fs";
+import { resolve as resolve5 } 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 = resolve5(projectRoot, ".pi", "skills");
+  if (existsSync4(skillsRoot)) {
+    for (const name of readdirSync(skillsRoot)) {
+      const dir = resolve5(skillsRoot, name);
+      if (existsSync4(resolve5(dir, MARKER_FILENAME))) {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    }
+  }
+  const written = [];
+  for (const { pluginName, skill } of entries) {
+    const sourcePath = resolve5(projectRoot, skill.path);
+    if (!existsSync4(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 = readFileSync3(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 = resolve5(skillsRoot, skillDirName(skill.id));
+    mkdirSync3(dir, { recursive: true });
+    writeFileSync3(resolve5(dir, "SKILL.md"), body, "utf-8");
+    writeFileSync3(resolve5(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;
@@ -575,6 +618,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,
@@ -588,12 +642,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 existsSync5, readFileSync as readFileSync4, readdirSync, statSync, writeFileSync as writeFileSync3 } from "fs";
-import { basename as basename3, join as join2, resolve as resolve6 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync2, statSync, writeFileSync as writeFileSync4 } from "fs";
+import { basename as basename3, join as join2, resolve as resolve7 } from "path";
 
 // packages/runtime/src/control-plane/tasks/legacy-task-config-source.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { resolve as resolve5 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { resolve as resolve6 } from "path";
 
 // packages/runtime/src/control-plane/tasks/task-record-reader.ts
 async function findTaskById(reader, id) {
@@ -616,7 +670,7 @@ class LegacyTaskConfigReadError extends Error {
   }
 }
 function createLegacyTaskConfigRecordReader(projectRoot, options = {}) {
-  const configPath = options.configPath ?? resolve5(projectRoot, ".rig", "task-config.json");
+  const configPath = options.configPath ?? resolve6(projectRoot, ".rig", "task-config.json");
   const reader = {
     async listTasks() {
       return readLegacyTaskRecords(projectRoot, configPath);
@@ -627,8 +681,8 @@ function createLegacyTaskConfigRecordReader(projectRoot, options = {}) {
   };
   return reader;
 }
-function readLegacyTaskRecords(projectRoot, configPath = resolve5(projectRoot, ".rig", "task-config.json")) {
-  if (!existsSync4(configPath)) {
+function readLegacyTaskRecords(projectRoot, configPath = resolve6(projectRoot, ".rig", "task-config.json")) {
+  if (!existsSync5(configPath)) {
     return [];
   }
   const rawConfig = readLegacyTaskConfigJson(projectRoot, configPath);
@@ -636,7 +690,7 @@ function readLegacyTaskRecords(projectRoot, configPath = resolve5(projectRoot, "
 }
 function readLegacyTaskConfigJson(projectRoot, configPath) {
   try {
-    const parsed = JSON.parse(readFileSync3(configPath, "utf8"));
+    const parsed = JSON.parse(readFileSync4(configPath, "utf8"));
     if (isPlainRecord(parsed)) {
       return parsed;
     }
@@ -720,7 +774,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 ?? resolve6(projectRoot, ".rig", "task-config.json");
+  const configPath = options.configPath ?? resolve7(projectRoot, ".rig", "task-config.json");
   const legacy = createLegacyTaskConfigRecordReader(projectRoot, { configPath });
   const spawnFn = options.spawn ?? spawnSync;
   const ghBinary = options.ghBinary ?? "gh";
@@ -803,10 +857,10 @@ function readMaterializedTaskMetadata(entry) {
   return metadata;
 }
 function readConfiguredFilesTaskSourcePath(projectRoot) {
-  const jsonPath = resolve6(projectRoot, "rig.config.json");
-  if (existsSync5(jsonPath)) {
+  const jsonPath = resolve7(projectRoot, "rig.config.json");
+  if (existsSync6(jsonPath)) {
     try {
-      const parsed = JSON.parse(readFileSync4(jsonPath, "utf8"));
+      const parsed = JSON.parse(readFileSync5(jsonPath, "utf8"));
       if (isPlainRecord2(parsed) && isPlainRecord2(parsed.taskSource)) {
         const source = parsed.taskSource;
         return source.kind === "files" && typeof source.path === "string" ? source.path : null;
@@ -815,12 +869,12 @@ function readConfiguredFilesTaskSourcePath(projectRoot) {
       return null;
     }
   }
-  const tsPath = resolve6(projectRoot, "rig.config.ts");
-  if (!existsSync5(tsPath)) {
+  const tsPath = resolve7(projectRoot, "rig.config.ts");
+  if (!existsSync6(tsPath)) {
     return null;
   }
   try {
-    const source = readFileSync4(tsPath, "utf8");
+    const source = readFileSync5(tsPath, "utf8");
     const taskSourceBlock = source.match(/taskSource\s*:\s*\{[\s\S]*?\}/m)?.[0] ?? "";
     const kind = taskSourceBlock.match(/kind\s*:\s*["']([^"']+)["']/)?.[1];
     if (kind !== "files") {
@@ -840,10 +894,10 @@ function readRawTaskEntry(configPath, taskId) {
   return isPlainRecord2(entry) ? entry : null;
 }
 function readRawTaskConfig(configPath) {
-  if (!existsSync5(configPath)) {
+  if (!existsSync6(configPath)) {
     return null;
   }
-  const parsed = JSON.parse(readFileSync4(configPath, "utf8"));
+  const parsed = JSON.parse(readFileSync5(configPath, "utf8"));
   return isPlainRecord2(parsed) ? parsed : null;
 }
 function stripLegacyTaskConfigMetadata2(raw) {
@@ -851,12 +905,12 @@ function stripLegacyTaskConfigMetadata2(raw) {
   return tasks;
 }
 function listFileBackedTasks(projectRoot, sourcePath) {
-  const directory = resolve6(projectRoot, sourcePath);
-  if (!existsSync5(directory)) {
+  const directory = resolve7(projectRoot, sourcePath);
+  if (!existsSync6(directory)) {
     return [];
   }
   const tasks = [];
-  for (const name of readdirSync(directory)) {
+  for (const name of readdirSync2(directory)) {
     if (!FILE_TASK_PATTERN.test(name))
       continue;
     const inferredId = basename3(name).replace(FILE_TASK_PATTERN, "");
@@ -867,11 +921,11 @@ function listFileBackedTasks(projectRoot, sourcePath) {
   return tasks;
 }
 function readFileBackedTask(projectRoot, sourcePath, taskId, rawEntry) {
-  const file = findFileBackedTaskFile(resolve6(projectRoot, sourcePath), taskId);
+  const file = findFileBackedTaskFile(resolve7(projectRoot, sourcePath), taskId);
   if (!file) {
     return null;
   }
-  const raw = JSON.parse(readFileSync4(file, "utf8"));
+  const raw = JSON.parse(readFileSync5(file, "utf8"));
   if (!isPlainRecord2(raw)) {
     return null;
   }
@@ -884,17 +938,17 @@ function readFileBackedTask(projectRoot, sourcePath, taskId, rawEntry) {
   };
 }
 function findFileBackedTaskFile(directory, taskId) {
-  if (!existsSync5(directory)) {
+  if (!existsSync6(directory)) {
     return null;
   }
-  for (const name of readdirSync(directory)) {
+  for (const name of readdirSync2(directory)) {
     if (!FILE_TASK_PATTERN.test(name))
       continue;
     const file = join2(directory, name);
     try {
       if (!statSync(file).isFile())
         continue;
-      const raw = JSON.parse(readFileSync4(file, "utf8"));
+      const raw = JSON.parse(readFileSync5(file, "utf8"));
       const inferredId = basename3(file).replace(FILE_TASK_PATTERN, "");
       const id = isPlainRecord2(raw) && typeof raw.id === "string" ? raw.id : inferredId;
       if (id === taskId) {
@@ -1054,8 +1108,8 @@ async function readConfiguredTaskSourceTask(projectRoot, taskId) {
 }
 
 // packages/runtime/src/control-plane/native/task-state.ts
-import { existsSync as existsSync9, readFileSync as readFileSync6, readdirSync as readdirSync2, statSync as statSync3, writeFileSync as writeFileSync4 } from "fs";
-import { basename as basename5, resolve as resolve11 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync7, readdirSync as readdirSync3, statSync as statSync3, writeFileSync as writeFileSync5 } from "fs";
+import { basename as basename5, resolve as resolve12 } from "path";
 
 // packages/runtime/src/control-plane/state-sync/types.ts
 var CANONICAL_TASK_LIFECYCLE_STATUSES = new Set([
@@ -1071,40 +1125,40 @@ var CANONICAL_TASK_LIFECYCLE_STATUSES = new Set([
 ]);
 // packages/runtime/src/control-plane/native/git-native.ts
 import { tmpdir as tmpdir3 } from "os";
-import { dirname as dirname5, isAbsolute, resolve as resolve7 } from "path";
-var sharedGitNativeOutputDir = resolve7(tmpdir3(), "rig-native");
-var sharedGitNativeOutputPath = resolve7(sharedGitNativeOutputDir, `rig-git-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`);
+import { dirname as dirname5, isAbsolute, resolve as resolve8 } from "path";
+var sharedGitNativeOutputDir = resolve8(tmpdir3(), "rig-native");
+var sharedGitNativeOutputPath = resolve8(sharedGitNativeOutputDir, `rig-git-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`);
 
 // packages/runtime/src/control-plane/native/utils.ts
-import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
-import { resolve as resolve10 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
+import { resolve as resolve11 } from "path";
 
 // packages/runtime/src/layout.ts
-import { existsSync as existsSync6 } from "fs";
-import { basename as basename4, dirname as dirname6, resolve as resolve8 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { basename as basename4, dirname as dirname6, resolve as resolve9 } from "path";
 var RIG_DEFINITION_DIRNAME = "rig";
 var RIG_ARTIFACTS_DIRNAME = "artifacts";
 function resolveMonorepoRoot(projectRoot) {
-  const normalizedProjectRoot = resolve8(projectRoot);
+  const normalizedProjectRoot = resolve9(projectRoot);
   const explicit = process.env.MONOREPO_ROOT?.trim();
   if (explicit) {
-    const explicitRoot = resolve8(explicit);
+    const explicitRoot = resolve9(explicit);
     const explicitParent = dirname6(explicitRoot);
     if (basename4(explicitParent) === ".worktrees") {
       const owner = dirname6(explicitParent);
-      const ownerHasGit = existsSync6(resolve8(owner, ".git"));
-      const ownerHasTaskConfig = existsSync6(resolve8(owner, ".rig", "task-config.json"));
-      const ownerHasRigConfig = existsSync6(resolve8(owner, "rig.config.ts"));
+      const ownerHasGit = existsSync7(resolve9(owner, ".git"));
+      const ownerHasTaskConfig = existsSync7(resolve9(owner, ".rig", "task-config.json"));
+      const ownerHasRigConfig = existsSync7(resolve9(owner, "rig.config.ts"));
       if (ownerHasGit && (ownerHasTaskConfig || ownerHasRigConfig)) {
         return owner;
       }
       throw new Error(`MONOREPO_ROOT points to worktree ${explicitRoot}, but the owner checkout is incomplete at ${owner}.`);
     }
-    if (!existsSync6(resolve8(explicitRoot, ".git"))) {
+    if (!existsSync7(resolve9(explicitRoot, ".git"))) {
       throw new Error(`MONOREPO_ROOT points to ${explicitRoot}, but no git checkout was found there.`);
     }
-    const hasTaskConfig = existsSync6(resolve8(explicitRoot, ".rig", "task-config.json"));
-    const hasRigConfig = existsSync6(resolve8(explicitRoot, "rig.config.ts"));
+    const hasTaskConfig = existsSync7(resolve9(explicitRoot, ".rig", "task-config.json"));
+    const hasRigConfig = existsSync7(resolve9(explicitRoot, "rig.config.ts"));
     if (!hasTaskConfig && !hasRigConfig) {
       throw new Error(`MONOREPO_ROOT points to ${explicitRoot}, but neither .rig/task-config.json nor rig.config.ts exists there.`);
     }
@@ -1113,9 +1167,9 @@ function resolveMonorepoRoot(projectRoot) {
   const projectParent = dirname6(normalizedProjectRoot);
   if (basename4(projectParent) === ".worktrees") {
     const worktreeOwner = dirname6(projectParent);
-    const ownerHasGit = existsSync6(resolve8(worktreeOwner, ".git"));
-    const ownerHasTaskConfig = existsSync6(resolve8(worktreeOwner, ".rig", "task-config.json"));
-    const ownerHasRigConfig = existsSync6(resolve8(worktreeOwner, "rig.config.ts"));
+    const ownerHasGit = existsSync7(resolve9(worktreeOwner, ".git"));
+    const ownerHasTaskConfig = existsSync7(resolve9(worktreeOwner, ".rig", "task-config.json"));
+    const ownerHasRigConfig = existsSync7(resolve9(worktreeOwner, "rig.config.ts"));
     if (ownerHasGit && (ownerHasTaskConfig || ownerHasRigConfig)) {
       return worktreeOwner;
     }
@@ -1123,28 +1177,28 @@ function resolveMonorepoRoot(projectRoot) {
   return normalizedProjectRoot;
 }
 function resolveRuntimeWorkspaceLayout(workspaceDir) {
-  const root = resolve8(workspaceDir);
-  const rigRoot = resolve8(root, ".rig");
-  const logsDir = resolve8(rigRoot, "logs");
-  const stateDir = resolve8(rigRoot, "state");
-  const runtimeDir = resolve8(rigRoot, "runtime");
-  const binDir = resolve8(rigRoot, "bin");
+  const root = resolve9(workspaceDir);
+  const rigRoot = resolve9(root, ".rig");
+  const logsDir = resolve9(rigRoot, "logs");
+  const stateDir = resolve9(rigRoot, "state");
+  const runtimeDir = resolve9(rigRoot, "runtime");
+  const binDir = resolve9(rigRoot, "bin");
   return {
     workspaceDir: root,
     rigRoot,
     stateDir,
     logsDir,
-    artifactsRoot: resolve8(root, RIG_ARTIFACTS_DIRNAME),
+    artifactsRoot: resolve9(root, RIG_ARTIFACTS_DIRNAME),
     runtimeDir,
-    homeDir: resolve8(rigRoot, "home"),
-    tmpDir: resolve8(rigRoot, "tmp"),
-    cacheDir: resolve8(rigRoot, "cache"),
-    sessionDir: resolve8(rigRoot, "session"),
+    homeDir: resolve9(rigRoot, "home"),
+    tmpDir: resolve9(rigRoot, "tmp"),
+    cacheDir: resolve9(rigRoot, "cache"),
+    sessionDir: resolve9(rigRoot, "session"),
     binDir,
-    distDir: resolve8(rigRoot, "dist"),
-    pluginBinDir: resolve8(binDir, "plugins"),
-    contextPath: resolve8(rigRoot, "runtime-context.json"),
-    controlPlaneEventsFile: resolve8(logsDir, "control-plane.events.jsonl")
+    distDir: resolve9(rigRoot, "dist"),
+    pluginBinDir: resolve9(binDir, "plugins"),
+    contextPath: resolve9(rigRoot, "runtime-context.json"),
+    controlPlaneEventsFile: resolve9(logsDir, "control-plane.events.jsonl")
   };
 }
 function resolveActiveRuntimeWorkspaceRoot(monorepoRoot) {
@@ -1152,14 +1206,14 @@ function resolveActiveRuntimeWorkspaceRoot(monorepoRoot) {
   if (!explicit) {
     throw new Error("No active runtime workspace. Set RIG_TASK_WORKSPACE or provision a task runtime first.");
   }
-  return resolve8(explicit);
+  return resolve9(explicit);
 }
 function resolveRigLayout(projectRoot) {
   const monorepoRoot = resolveMonorepoRoot(projectRoot);
-  const definitionRoot = resolve8(projectRoot, RIG_DEFINITION_DIRNAME);
+  const definitionRoot = resolve9(projectRoot, RIG_DEFINITION_DIRNAME);
   const runtimeWorkspaceRoot = resolveActiveRuntimeWorkspaceRoot(monorepoRoot);
   const runtimeLayout = resolveRuntimeWorkspaceLayout(runtimeWorkspaceRoot);
-  const policyDir = resolve8(definitionRoot, "policy");
+  const policyDir = resolve9(definitionRoot, "policy");
   return {
     projectRoot,
     monorepoRoot,
@@ -1167,48 +1221,48 @@ function resolveRigLayout(projectRoot) {
     runtimeWorkspaceRoot,
     stateRoot: runtimeLayout.rigRoot,
     artifactsRoot: runtimeLayout.artifactsRoot,
-    configPath: resolve8(definitionRoot, "config.sh"),
-    taskConfigPath: resolve8(runtimeWorkspaceRoot, ".rig", "task-config.json"),
+    configPath: resolve9(definitionRoot, "config.sh"),
+    taskConfigPath: resolve9(runtimeWorkspaceRoot, ".rig", "task-config.json"),
     policyDir,
-    policyFile: resolve8(policyDir, "policy.json"),
-    pluginsDir: resolve8(definitionRoot, "plugins"),
-    hooksDir: resolve8(definitionRoot, "hooks"),
-    toolsDir: resolve8(definitionRoot, "tools"),
-    templatesDir: resolve8(definitionRoot, "templates"),
-    validationDir: resolve8(definitionRoot, "validation"),
+    policyFile: resolve9(policyDir, "policy.json"),
+    pluginsDir: resolve9(definitionRoot, "plugins"),
+    hooksDir: resolve9(definitionRoot, "hooks"),
+    toolsDir: resolve9(definitionRoot, "tools"),
+    templatesDir: resolve9(definitionRoot, "templates"),
+    validationDir: resolve9(definitionRoot, "validation"),
     stateDir: runtimeLayout.stateDir,
     logsDir: runtimeLayout.logsDir,
-    notificationsDir: resolve8(definitionRoot, "notifications"),
+    notificationsDir: resolve9(definitionRoot, "notifications"),
     runtimeDir: runtimeLayout.runtimeDir,
     distDir: runtimeLayout.distDir,
     binDir: runtimeLayout.binDir,
     pluginBinDir: runtimeLayout.pluginBinDir,
-    keybindingsPath: resolve8(definitionRoot, "keybindings.json"),
+    keybindingsPath: resolve9(definitionRoot, "keybindings.json"),
     controlPlaneEventsFile: runtimeLayout.controlPlaneEventsFile
   };
 }
 
 // packages/runtime/src/control-plane/native/runtime-native.ts
 import { dlopen, ptr, suffix, toBuffer } from "bun:ffi";
-import { copyFileSync, existsSync as existsSync7, mkdirSync as mkdirSync3, renameSync, rmSync, statSync as statSync2 } from "fs";
+import { copyFileSync, existsSync as existsSync8, mkdirSync as mkdirSync4, renameSync, rmSync as rmSync2, statSync as statSync2 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { dirname as dirname7, resolve as resolve9 } from "path";
-var sharedNativeRuntimeOutputDir = resolve9(tmpdir4(), "rig-native");
-var sharedNativeRuntimeOutputPath = resolve9(sharedNativeRuntimeOutputDir, `runtime-native-${process.platform}-${process.arch}.${suffix}`);
+import { dirname as dirname7, resolve as resolve10 } from "path";
+var sharedNativeRuntimeOutputDir = resolve10(tmpdir4(), "rig-native");
+var sharedNativeRuntimeOutputPath = resolve10(sharedNativeRuntimeOutputDir, `runtime-native-${process.platform}-${process.arch}.${suffix}`);
 var colocatedNativeRuntimeFileName = `runtime-native.${suffix}`;
 var nativeRuntimeLibrary = await loadNativeRuntimeLibrary();
 async function ensureNativeRuntimeLibraryPath(outputPath = sharedNativeRuntimeOutputPath, options = {}) {
   if (await buildNativeRuntimeLibrary(outputPath, options)) {
     return outputPath;
   }
-  return !options.force && existsSync7(outputPath) ? outputPath : null;
+  return !options.force && existsSync8(outputPath) ? outputPath : null;
 }
 async function loadNativeRuntimeLibrary() {
   if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
     return null;
   }
   for (const candidate of nativeRuntimeLibraryCandidates()) {
-    if (!candidate || !existsSync7(candidate)) {
+    if (!candidate || !existsSync8(candidate)) {
       continue;
     }
     const loaded = tryDlopenNativeRuntimeLibrary(candidate);
@@ -1224,10 +1278,10 @@ async function loadNativeRuntimeLibrary() {
 }
 function nativePackageLibraryCandidates(fromDir, names) {
   const candidates = [];
-  let cursor = resolve9(fromDir);
+  let cursor = resolve10(fromDir);
   for (let index = 0;index < 8; index += 1) {
     for (const name of names) {
-      candidates.push(resolve9(cursor, "native", `${process.platform}-${process.arch}`, name), resolve9(cursor, "native", `${process.platform}-${process.arch}`, "lib", name), resolve9(cursor, "native", name), resolve9(cursor, "native", "lib", name));
+      candidates.push(resolve10(cursor, "native", `${process.platform}-${process.arch}`, name), resolve10(cursor, "native", `${process.platform}-${process.arch}`, "lib", name), resolve10(cursor, "native", name), resolve10(cursor, "native", "lib", name));
     }
     const parent = dirname7(cursor);
     if (parent === cursor)
@@ -1243,22 +1297,22 @@ function nativeRuntimeLibraryCandidates() {
   return [...new Set([
     explicit,
     ...nativePackageLibraryCandidates(import.meta.dir, [colocatedNativeRuntimeFileName, platformSpecific]),
-    execDir ? resolve9(execDir, colocatedNativeRuntimeFileName) : "",
-    execDir ? resolve9(execDir, platformSpecific) : "",
-    execDir ? resolve9(execDir, "..", colocatedNativeRuntimeFileName) : "",
-    execDir ? resolve9(execDir, "..", platformSpecific) : "",
-    execDir ? resolve9(execDir, "lib", colocatedNativeRuntimeFileName) : "",
-    execDir ? resolve9(execDir, "..", "lib", colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve10(execDir, colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve10(execDir, platformSpecific) : "",
+    execDir ? resolve10(execDir, "..", colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve10(execDir, "..", platformSpecific) : "",
+    execDir ? resolve10(execDir, "lib", colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve10(execDir, "..", "lib", colocatedNativeRuntimeFileName) : "",
     sharedNativeRuntimeOutputPath
   ].filter(Boolean))];
 }
 function resolveNativeRuntimeSourcePath() {
   const explicit = process.env.RIG_NATIVE_RUNTIME_SOURCE?.trim();
-  if (explicit && existsSync7(explicit)) {
+  if (explicit && existsSync8(explicit)) {
     return explicit;
   }
-  const bundled = resolve9(import.meta.dir, "../../../native/snapshot.zig");
-  return existsSync7(bundled) ? bundled : null;
+  const bundled = resolve10(import.meta.dir, "../../../native/snapshot.zig");
+  return existsSync8(bundled) ? bundled : null;
 }
 async function buildNativeRuntimeLibrary(outputPath, options = {}) {
   if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
@@ -1271,8 +1325,8 @@ async function buildNativeRuntimeLibrary(outputPath, options = {}) {
   }
   const tempOutputPath = `${outputPath}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    mkdirSync3(dirname7(outputPath), { recursive: true });
-    const needsBuild = options.force === true || !existsSync7(outputPath) || statSync2(sourcePath).mtimeMs > statSync2(outputPath).mtimeMs;
+    mkdirSync4(dirname7(outputPath), { recursive: true });
+    const needsBuild = options.force === true || !existsSync8(outputPath) || statSync2(sourcePath).mtimeMs > statSync2(outputPath).mtimeMs;
     if (!needsBuild) {
       return true;
     }
@@ -1290,14 +1344,14 @@ async function buildNativeRuntimeLibrary(outputPath, options = {}) {
       stderr: "pipe"
     });
     const exitCode = await build.exited;
-    if (exitCode !== 0 || !existsSync7(tempOutputPath)) {
-      rmSync(tempOutputPath, { force: true });
+    if (exitCode !== 0 || !existsSync8(tempOutputPath)) {
+      rmSync2(tempOutputPath, { force: true });
       return false;
     }
     renameSync(tempOutputPath, outputPath);
     return true;
   } catch {
-    rmSync(tempOutputPath, { force: true });
+    rmSync2(tempOutputPath, { force: true });
     return false;
   }
 }
@@ -1377,11 +1431,11 @@ function runCapture(command, cwd, env) {
   };
 }
 function readJsonFile(path, fallback) {
-  if (!existsSync8(path)) {
+  if (!existsSync9(path)) {
     return fallback;
   }
   try {
-    return JSON.parse(readFileSync5(path, "utf-8"));
+    return JSON.parse(readFileSync6(path, "utf-8"));
   } catch {
     return fallback;
   }
@@ -1392,31 +1446,31 @@ function nowIso() {
 function resolveHarnessPaths(projectRoot) {
   const hasRuntimeWorkspace = Boolean(process.env.RIG_TASK_WORKSPACE?.trim());
   const monorepoRoot = resolveMonorepoRoot2(projectRoot);
-  const harnessRoot = resolve10(projectRoot, "rig");
-  const stateRoot = resolve10(projectRoot, ".rig");
+  const harnessRoot = resolve11(projectRoot, "rig");
+  const stateRoot = resolve11(projectRoot, ".rig");
   const layout = hasRuntimeWorkspace ? resolveRigLayout(projectRoot) : null;
-  const stateDir = layout?.stateDir ?? resolve10(stateRoot, "state");
-  const logsDir = layout?.logsDir ?? resolve10(stateRoot, "logs");
-  const artifactsDir = layout?.artifactsRoot ?? resolve10(monorepoRoot, "artifacts");
-  const taskConfigPath = layout?.taskConfigPath ?? resolve10(monorepoRoot, ".rig", "task-config.json");
-  const binDir = layout?.binDir ?? resolve10(stateRoot, "bin");
+  const stateDir = layout?.stateDir ?? resolve11(stateRoot, "state");
+  const logsDir = layout?.logsDir ?? resolve11(stateRoot, "logs");
+  const artifactsDir = layout?.artifactsRoot ?? resolve11(monorepoRoot, "artifacts");
+  const taskConfigPath = layout?.taskConfigPath ?? resolve11(monorepoRoot, ".rig", "task-config.json");
+  const binDir = layout?.binDir ?? resolve11(stateRoot, "bin");
   return {
     harnessRoot,
     stateDir: process.env.RIG_STATE_DIR || stateDir,
     artifactsDir,
     logsDir: process.env.RIG_LOGS_DIR || logsDir,
     binDir,
-    hooksDir: resolve10(harnessRoot, "hooks"),
-    validationDir: resolve10(harnessRoot, "validation"),
+    hooksDir: resolve11(harnessRoot, "hooks"),
+    validationDir: resolve11(harnessRoot, "validation"),
     taskConfigPath,
-    sessionPath: process.env.RIG_SESSION_FILE || resolve10(stateRoot, "session", "session.json"),
+    sessionPath: process.env.RIG_SESSION_FILE || resolve11(stateRoot, "session", "session.json"),
     monorepoRoot,
-    tsApiTestsDir: process.env.TS_API_TESTS_DIR || resolve10(monorepoRoot, "TSAPITests"),
-    taskRepoCommitsPath: resolve10(stateDir, "task-repo-commits.json"),
-    baseRepoPinsPath: resolve10(stateDir, "base-repo-pins.json"),
-    failedApproachesPath: resolve10(stateDir, "failed_approaches.md"),
-    agentProfilePath: resolve10(stateDir, "agent-profile.json"),
-    reviewProfilePath: resolve10(stateDir, "review-profile.json")
+    tsApiTestsDir: process.env.TS_API_TESTS_DIR || resolve11(monorepoRoot, "TSAPITests"),
+    taskRepoCommitsPath: resolve11(stateDir, "task-repo-commits.json"),
+    baseRepoPinsPath: resolve11(stateDir, "base-repo-pins.json"),
+    failedApproachesPath: resolve11(stateDir, "failed_approaches.md"),
+    agentProfilePath: resolve11(stateDir, "agent-profile.json"),
+    reviewProfilePath: resolve11(stateDir, "review-profile.json")
   };
 }
 // packages/runtime/src/control-plane/state-sync/reconcile.ts
@@ -1471,25 +1525,25 @@ function lookupTask(projectRoot, input) {
 function artifactDirForId(projectRoot, id) {
   const workspaceDir = process.env.RIG_TASK_WORKSPACE?.trim();
   if (workspaceDir) {
-    const worktreeArtifacts = resolve11(workspaceDir, "artifacts", id);
-    if (existsSync9(worktreeArtifacts) || existsSync9(resolve11(workspaceDir, "artifacts"))) {
+    const worktreeArtifacts = resolve12(workspaceDir, "artifacts", id);
+    if (existsSync10(worktreeArtifacts) || existsSync10(resolve12(workspaceDir, "artifacts"))) {
       return worktreeArtifacts;
     }
   }
   try {
     const paths = resolveHarnessPaths(projectRoot);
-    return resolve11(paths.artifactsDir, id);
+    return resolve12(paths.artifactsDir, id);
   } catch {
-    return resolve11(resolveMonorepoRoot2(projectRoot), "artifacts", id);
+    return resolve12(resolveMonorepoRoot2(projectRoot), "artifacts", id);
   }
 }
 function resolveTaskConfigPath(projectRoot) {
   const paths = resolveHarnessPaths(projectRoot);
-  if (existsSync9(paths.taskConfigPath)) {
+  if (existsSync10(paths.taskConfigPath)) {
     return paths.taskConfigPath;
   }
   for (const candidate of sourceTaskConfigCandidates(projectRoot)) {
-    if (existsSync9(candidate)) {
+    if (existsSync10(candidate)) {
       return candidate;
     }
   }
@@ -1497,7 +1551,7 @@ function resolveTaskConfigPath(projectRoot) {
 }
 function findSourceTaskConfigPath(projectRoot) {
   for (const candidate of sourceTaskConfigCandidates(projectRoot)) {
-    if (existsSync9(candidate)) {
+    if (existsSync10(candidate)) {
       return candidate;
     }
   }
@@ -1510,7 +1564,7 @@ function readAndSyncSourceTaskConfig(projectRoot) {
   const synced = synchronizeTaskConfigWithTracker(projectRoot, raw);
   if (sourcePath && synced.updated) {
     try {
-      writeFileSync4(sourcePath, `${JSON.stringify(synced.config, null, 2)}
+      writeFileSync5(sourcePath, `${JSON.stringify(synced.config, null, 2)}
 `, "utf-8");
     } catch {}
   }
@@ -1562,12 +1616,12 @@ function shouldRefreshAutoSyncedTaskConfigEntry(entry) {
   return !candidate.role;
 }
 function readSourceIssueRecords(projectRoot) {
-  const issuesPath = resolve11(resolveMonorepoRoot2(projectRoot), ".beads", "issues.jsonl");
-  if (!existsSync9(issuesPath)) {
+  const issuesPath = resolve12(resolveMonorepoRoot2(projectRoot), ".beads", "issues.jsonl");
+  if (!existsSync10(issuesPath)) {
     return [];
   }
   const records = [];
-  for (const line of readFileSync6(issuesPath, "utf-8").split(/\r?\n/)) {
+  for (const line of readFileSync7(issuesPath, "utf-8").split(/\r?\n/)) {
     const trimmed = line.trim();
     if (!trimmed) {
       continue;
@@ -1623,19 +1677,19 @@ function readConfiguredFileTaskConfig(projectRoot) {
   if (!sourcePath) {
     return {};
   }
-  const directory = resolve11(projectRoot, sourcePath);
-  if (!existsSync9(directory)) {
+  const directory = resolve12(projectRoot, sourcePath);
+  if (!existsSync10(directory)) {
     return {};
   }
   const config = {};
-  for (const name of readdirSync2(directory)) {
+  for (const name of readdirSync3(directory)) {
     if (!FILE_TASK_PATTERN2.test(name))
       continue;
-    const file = resolve11(directory, name);
+    const file = resolve12(directory, name);
     try {
       if (!statSync3(file).isFile())
         continue;
-      const raw = JSON.parse(readFileSync6(file, "utf8"));
+      const raw = JSON.parse(readFileSync7(file, "utf8"));
       if (!raw || typeof raw !== "object" || Array.isArray(raw))
         continue;
       const record = raw;
@@ -1677,10 +1731,10 @@ function firstStringList2(...candidates) {
   return [];
 }
 function readConfiguredFilesTaskSourcePath2(projectRoot) {
-  const jsonPath = resolve11(projectRoot, "rig.config.json");
-  if (existsSync9(jsonPath)) {
+  const jsonPath = resolve12(projectRoot, "rig.config.json");
+  if (existsSync10(jsonPath)) {
     try {
-      const parsed = JSON.parse(readFileSync6(jsonPath, "utf8"));
+      const parsed = JSON.parse(readFileSync7(jsonPath, "utf8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         const taskSource = parsed.taskSource;
         if (taskSource && typeof taskSource === "object" && !Array.isArray(taskSource)) {
@@ -1692,12 +1746,12 @@ function readConfiguredFilesTaskSourcePath2(projectRoot) {
       return null;
     }
   }
-  const tsPath = resolve11(projectRoot, "rig.config.ts");
-  if (!existsSync9(tsPath)) {
+  const tsPath = resolve12(projectRoot, "rig.config.ts");
+  if (!existsSync10(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") {
@@ -1711,9 +1765,9 @@ function readConfiguredFilesTaskSourcePath2(projectRoot) {
 function sourceTaskConfigCandidates(projectRoot) {
   const runtimeContext = loadRuntimeContextFromEnv();
   return [
-    runtimeContext?.monorepoMainRoot ? resolve11(runtimeContext.monorepoMainRoot, ".rig", "task-config.json") : "",
-    process.env.MONOREPO_MAIN_ROOT?.trim() ? resolve11(process.env.MONOREPO_MAIN_ROOT.trim(), ".rig", "task-config.json") : "",
-    resolve11(resolveMonorepoRoot2(projectRoot), ".rig", "task-config.json")
+    runtimeContext?.monorepoMainRoot ? resolve12(runtimeContext.monorepoMainRoot, ".rig", "task-config.json") : "",
+    process.env.MONOREPO_MAIN_ROOT?.trim() ? resolve12(process.env.MONOREPO_MAIN_ROOT.trim(), ".rig", "task-config.json") : "",
+    resolve12(resolveMonorepoRoot2(projectRoot), ".rig", "task-config.json")
   ].filter(Boolean);
 }
 
@@ -3011,12 +3065,12 @@ var TASK_ARTIFACT_STAGE_FALLBACK = new Set([
   "validation-summary.json"
 ]);
 function readPrMetadata(projectRoot, taskId) {
-  const path = resolve12(artifactDirForId(projectRoot, taskId), "pr-state.json");
-  if (!existsSync10(path)) {
+  const path = resolve13(artifactDirForId(projectRoot, taskId), "pr-state.json");
+  if (!existsSync11(path)) {
     return [];
   }
   try {
-    const parsed = JSON.parse(readFileSync7(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync8(path, "utf-8"));
     if (!parsed || typeof parsed !== "object") {
       return [];
     }
@@ -3042,11 +3096,11 @@ async function verifyTask(options) {
   const taskId = options.taskId;
   const normalizedTaskId = lookupTask(options.projectRoot, taskId);
   const artifactDir = artifactDirForId(options.projectRoot, taskId);
-  mkdirSync5(artifactDir, { recursive: true });
-  const validationSummaryPath = resolve13(artifactDir, "validation-summary.json");
-  const reviewFeedbackPath = resolve13(artifactDir, "review-feedback.md");
-  const reviewStatePath = resolve13(artifactDir, "review-state.json");
-  const greptileRawPath = resolve13(artifactDir, "review-greptile-raw.json");
+  mkdirSync6(artifactDir, { recursive: true });
+  const validationSummaryPath = resolve14(artifactDir, "validation-summary.json");
+  const reviewFeedbackPath = resolve14(artifactDir, "review-feedback.md");
+  const reviewStatePath = resolve14(artifactDir, "review-state.json");
+  const greptileRawPath = resolve14(artifactDir, "review-greptile-raw.json");
   const prStates = readPrMetadata(options.projectRoot, taskId);
   const prState = prStates[0] || null;
   const localReasons = [];
@@ -3058,7 +3112,7 @@ async function verifyTask(options) {
   if (!normalizedTaskId && !await hasConfiguredSourceTask(options.projectRoot, taskId)) {
     localReasons.push(`[Task Config] Unknown task id '${taskId}' in task-config or configured task source.`);
   }
-  if (!existsSync11(validationSummaryPath)) {
+  if (!existsSync12(validationSummaryPath)) {
     localReasons.push(`[Artifact Quality] validation-summary.json not found at ${validationSummaryPath}.`);
   } else {
     const summary = await parseValidationSummary(validationSummaryPath);
@@ -3067,13 +3121,13 @@ async function verifyTask(options) {
     }
   }
   for (const file of ["task-result.json", "decision-log.md", "next-actions.md", "changed-files.txt"]) {
-    const requiredPath = resolve13(artifactDir, file);
-    if (!existsSync11(requiredPath)) {
+    const requiredPath = resolve14(artifactDir, file);
+    if (!existsSync12(requiredPath)) {
       localReasons.push(`[Artifact Quality] Missing required artifact file: ${requiredPath}`);
     }
   }
-  const taskResultPath = resolve13(artifactDir, "task-result.json");
-  if (existsSync11(taskResultPath)) {
+  const taskResultPath = resolve14(artifactDir, "task-result.json");
+  if (existsSync12(taskResultPath)) {
     const taskResult = await readJsonFile2(taskResultPath);
     const artifactStatus = typeof taskResult?.status === "string" ? taskResult.status.trim().toLowerCase() : "";
     if (artifactStatus === "partial") {
@@ -3086,8 +3140,8 @@ async function verifyTask(options) {
       localReasons.push("[Artifact Quality] task-result.json next actions indicate remaining implementation scope.");
     }
   }
-  const nextActionsPath = resolve13(artifactDir, "next-actions.md");
-  if (existsSync11(nextActionsPath)) {
+  const nextActionsPath = resolve14(artifactDir, "next-actions.md");
+  if (existsSync12(nextActionsPath)) {
     const nextActionsContent = await Bun.file(nextActionsPath).text();
     if (nextActionsContent.includes("TODO: Replace this scaffold") || nextActionsContent.includes("bd-<downstream-task-id>")) {
       localReasons.push("[Artifact Quality] next-actions.md still contains scaffold placeholder text. Replace with real recommendations.");
@@ -3100,12 +3154,6 @@ async function verifyTask(options) {
   if (sourceCloseoutIssueId) {
     localReasons.push(...evaluateGithubSourceIssuePrCloseout(options.projectRoot, prStates, sourceCloseoutIssueId));
   }
-  const pluginResults = await options.plugins.runValidators(taskId);
-  for (const result of pluginResults) {
-    if (!result.passed) {
-      localReasons.push(`[Plugin Validator] ${result.id}: ${result.summary}`);
-    }
-  }
   const reviewMode = await loadReviewMode(paths.reviewProfilePath, process.env.AI_REVIEW_MODE || "advisory");
   const reviewProvider = await loadReviewProvider(paths.reviewProfilePath, process.env.AI_REVIEW_PROVIDER || "greptile");
   if (!options.skipAiReview && localReasons.length === 0 && reviewProvider === "greptile" && reviewMode !== "off") {
@@ -3124,7 +3172,7 @@ async function verifyTask(options) {
       aiReasons.push(`[AI Review] Required mode needs a completed Greptile approval; current verdict is ${ai.verdict}.`);
     }
     if (persistArtifacts && ai.rawResponse) {
-      writeFileSync6(greptileRawPath, `${ai.rawResponse}
+      writeFileSync7(greptileRawPath, `${ai.rawResponse}
 `, "utf-8");
     }
   } else if (!options.skipAiReview && reviewMode === "off") {
@@ -3463,7 +3511,7 @@ function isAcceptedValidationSummary(summary) {
   return summary.status === "skipped" && summary.total === 0 && summary.failed === 0;
 }
 async function loadReviewMode(reviewProfilePath, fallback) {
-  const parsed = existsSync11(reviewProfilePath) ? await readJsonFile2(reviewProfilePath) : null;
+  const parsed = existsSync12(reviewProfilePath) ? await readJsonFile2(reviewProfilePath) : null;
   const mode = parsed?.mode;
   if (mode === "off" || mode === "advisory" || mode === "required") {
     return mode;
@@ -3474,7 +3522,7 @@ async function loadReviewMode(reviewProfilePath, fallback) {
   return "advisory";
 }
 async function loadReviewProvider(reviewProfilePath, fallback) {
-  const parsed = existsSync11(reviewProfilePath) ? await readJsonFile2(reviewProfilePath) : null;
+  const parsed = existsSync12(reviewProfilePath) ? await readJsonFile2(reviewProfilePath) : null;
   const provider = parsed?.provider;
   if (typeof provider === "string" && provider.trim().length > 0) {
     return provider;
@@ -3633,7 +3681,7 @@ function writeFeedbackFile(options) {
   if (options.aiRawFeedback) {
     lines.push("## Raw Reviewer Feedback", "", "```text", options.aiRawFeedback, "```", "");
   }
-  writeFileSync6(options.output, `${lines.join(`
+  writeFileSync7(options.output, `${lines.join(`
 `)}
 `, "utf-8");
 }
@@ -3650,7 +3698,7 @@ function writeReviewStateFile(options) {
     ai_warnings: options.aiWarnings,
     updated_at: nowIso()
   };
-  writeFileSync6(options.output, `${JSON.stringify(payload, null, 2)}
+  writeFileSync7(options.output, `${JSON.stringify(payload, null, 2)}
 `, "utf-8");
 }
 async function runGreptileReviewForPr(options) {
@@ -4440,7 +4488,7 @@ function filterActionableGithubGreptileThreads(threads) {
 }
 function resolvePrRepoRoot(projectRoot, prState) {
   const runtimeWorkspace = process.env.RIG_TASK_WORKSPACE?.trim();
-  if (prState.target === "monorepo" && runtimeWorkspace && existsSync11(resolve13(runtimeWorkspace, ".git"))) {
+  if (prState.target === "monorepo" && runtimeWorkspace && existsSync12(resolve14(runtimeWorkspace, ".git"))) {
     return runtimeWorkspace;
   }
   const paths = resolveHarnessPaths(projectRoot);