@h-rig/runtime 0.0.6-alpha.0

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

@@ -0,0 +1,2255 @@
+// @bun
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// packages/runtime/src/layout.ts
+import { existsSync } from "fs";
+import { basename, dirname, resolve } from "path";
+function resolveMonorepoRoot(projectRoot) {
+  const normalizedProjectRoot = resolve(projectRoot);
+  const explicit = process.env.MONOREPO_ROOT?.trim();
+  if (explicit) {
+    const explicitRoot = resolve(explicit);
+    const explicitParent = dirname(explicitRoot);
+    if (basename(explicitParent) === ".worktrees") {
+      const owner = dirname(explicitParent);
+      const ownerHasGit = existsSync(resolve(owner, ".git"));
+      const ownerHasTaskConfig = existsSync(resolve(owner, ".rig", "task-config.json"));
+      const ownerHasRigConfig = existsSync(resolve(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 (!existsSync(resolve(explicitRoot, ".git"))) {
+      throw new Error(`MONOREPO_ROOT points to ${explicitRoot}, but no git checkout was found there.`);
+    }
+    const hasTaskConfig = existsSync(resolve(explicitRoot, ".rig", "task-config.json"));
+    const hasRigConfig = existsSync(resolve(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.`);
+    }
+    return explicitRoot;
+  }
+  const projectParent = dirname(normalizedProjectRoot);
+  if (basename(projectParent) === ".worktrees") {
+    const worktreeOwner = dirname(projectParent);
+    const ownerHasGit = existsSync(resolve(worktreeOwner, ".git"));
+    const ownerHasTaskConfig = existsSync(resolve(worktreeOwner, ".rig", "task-config.json"));
+    const ownerHasRigConfig = existsSync(resolve(worktreeOwner, "rig.config.ts"));
+    if (ownerHasGit && (ownerHasTaskConfig || ownerHasRigConfig)) {
+      return worktreeOwner;
+    }
+  }
+  return normalizedProjectRoot;
+}
+function resolveRuntimeWorkspaceLayout(workspaceDir) {
+  const root = resolve(workspaceDir);
+  const rigRoot = resolve(root, ".rig");
+  const logsDir = resolve(rigRoot, "logs");
+  const stateDir = resolve(rigRoot, "state");
+  const runtimeDir = resolve(rigRoot, "runtime");
+  const binDir = resolve(rigRoot, "bin");
+  return {
+    workspaceDir: root,
+    rigRoot,
+    stateDir,
+    logsDir,
+    artifactsRoot: resolve(root, RIG_ARTIFACTS_DIRNAME),
+    runtimeDir,
+    homeDir: resolve(rigRoot, "home"),
+    tmpDir: resolve(rigRoot, "tmp"),
+    cacheDir: resolve(rigRoot, "cache"),
+    sessionDir: resolve(rigRoot, "session"),
+    binDir,
+    distDir: resolve(rigRoot, "dist"),
+    pluginBinDir: resolve(binDir, "plugins"),
+    contextPath: resolve(rigRoot, "runtime-context.json"),
+    controlPlaneEventsFile: resolve(logsDir, "control-plane.events.jsonl")
+  };
+}
+function resolveActiveRuntimeWorkspaceRoot(monorepoRoot) {
+  const explicit = process.env.RIG_TASK_WORKSPACE?.trim();
+  if (!explicit) {
+    throw new Error("No active runtime workspace. Set RIG_TASK_WORKSPACE or provision a task runtime first.");
+  }
+  return resolve(explicit);
+}
+function resolveRigLayout(projectRoot) {
+  const monorepoRoot = resolveMonorepoRoot(projectRoot);
+  const definitionRoot = resolve(projectRoot, RIG_DEFINITION_DIRNAME);
+  const runtimeWorkspaceRoot = resolveActiveRuntimeWorkspaceRoot(monorepoRoot);
+  const runtimeLayout = resolveRuntimeWorkspaceLayout(runtimeWorkspaceRoot);
+  const policyDir = resolve(definitionRoot, "policy");
+  return {
+    projectRoot,
+    monorepoRoot,
+    definitionRoot,
+    runtimeWorkspaceRoot,
+    stateRoot: runtimeLayout.rigRoot,
+    artifactsRoot: runtimeLayout.artifactsRoot,
+    configPath: resolve(definitionRoot, "config.sh"),
+    taskConfigPath: resolve(runtimeWorkspaceRoot, ".rig", "task-config.json"),
+    policyDir,
+    policyFile: resolve(policyDir, "policy.json"),
+    pluginsDir: resolve(definitionRoot, "plugins"),
+    hooksDir: resolve(definitionRoot, "hooks"),
+    toolsDir: resolve(definitionRoot, "tools"),
+    templatesDir: resolve(definitionRoot, "templates"),
+    validationDir: resolve(definitionRoot, "validation"),
+    stateDir: runtimeLayout.stateDir,
+    logsDir: runtimeLayout.logsDir,
+    notificationsDir: resolve(definitionRoot, "notifications"),
+    runtimeDir: runtimeLayout.runtimeDir,
+    distDir: runtimeLayout.distDir,
+    binDir: runtimeLayout.binDir,
+    pluginBinDir: runtimeLayout.pluginBinDir,
+    keybindingsPath: resolve(definitionRoot, "keybindings.json"),
+    controlPlaneEventsFile: runtimeLayout.controlPlaneEventsFile
+  };
+}
+var RIG_DEFINITION_DIRNAME = "rig", RIG_ARTIFACTS_DIRNAME = "artifacts";
+var init_layout = () => {};
+
+// packages/runtime/src/control-plane/runtime/sandbox/utils.ts
+function uniq(values) {
+  return [...new Set(values)];
+}
+var init_utils = __esm(() => {
+  init_layout();
+});
+
+// packages/runtime/src/control-plane/runtime/image.ts
+init_layout();
+import { ptr as ptr3, toBuffer as toBuffer2 } from "bun:ffi";
+import {
+  existsSync as existsSync6,
+  readFileSync as readFileSync2,
+  readdirSync as readdirSync2,
+  mkdirSync as mkdirSync3,
+  writeFileSync as writeFileSync2,
+  renameSync as renameSync3,
+  rmSync as rmSync3,
+  cpSync as cpSync2,
+  lstatSync,
+  unlinkSync,
+  symlinkSync
+} from "fs";
+import { resolve as resolve11 } from "path";
+
+// packages/runtime/src/control-plane/native/runtime-native.ts
+import { dlopen, ptr, suffix, toBuffer } from "bun:ffi";
+import { copyFileSync, existsSync as existsSync2, mkdirSync, renameSync, rmSync, statSync } from "fs";
+import { tmpdir } from "os";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+var sharedNativeRuntimeOutputDir = resolve2(tmpdir(), "rig-native");
+var sharedNativeRuntimeOutputPath = resolve2(sharedNativeRuntimeOutputDir, `runtime-native-${process.platform}-${process.arch}.${suffix}`);
+var colocatedNativeRuntimeFileName = `runtime-native.${suffix}`;
+var nativeRuntimeLibrary = await loadNativeRuntimeLibrary();
+function requireNativeRuntimeLibrary(feature) {
+  if (!nativeRuntimeLibrary) {
+    throw new Error(`Native Zig runtime is required for ${feature}`);
+  }
+  return nativeRuntimeLibrary;
+}
+async function ensureNativeRuntimeLibraryPath(outputPath = sharedNativeRuntimeOutputPath, options = {}) {
+  if (await buildNativeRuntimeLibrary(outputPath, options)) {
+    return outputPath;
+  }
+  return !options.force && existsSync2(outputPath) ? outputPath : null;
+}
+async function materializeNativeRuntimeLibrary(targetDir) {
+  const sourcePath = await ensureNativeRuntimeLibraryPath();
+  if (!sourcePath) {
+    return null;
+  }
+  const targetPath = resolve2(targetDir, colocatedNativeRuntimeFileName);
+  mkdirSync(targetDir, { recursive: true });
+  const needsCopy = !existsSync2(targetPath) || statSync(sourcePath).mtimeMs > statSync(targetPath).mtimeMs;
+  if (needsCopy) {
+    copyFileSync(sourcePath, targetPath);
+  }
+  return targetPath;
+}
+async function loadNativeRuntimeLibrary() {
+  if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
+    return null;
+  }
+  for (const candidate of nativeRuntimeLibraryCandidates()) {
+    if (!candidate || !existsSync2(candidate)) {
+      continue;
+    }
+    const loaded = tryDlopenNativeRuntimeLibrary(candidate);
+    if (loaded) {
+      return loaded;
+    }
+  }
+  const builtLibraryPath = await ensureNativeRuntimeLibraryPath(sharedNativeRuntimeOutputPath, { force: true });
+  if (!builtLibraryPath) {
+    return null;
+  }
+  return tryDlopenNativeRuntimeLibrary(builtLibraryPath);
+}
+function nativePackageLibraryCandidates(fromDir, names) {
+  const candidates = [];
+  let cursor = resolve2(fromDir);
+  for (let index = 0;index < 8; index += 1) {
+    for (const name of names) {
+      candidates.push(resolve2(cursor, "native", `${process.platform}-${process.arch}`, name), resolve2(cursor, "native", `${process.platform}-${process.arch}`, "lib", name), resolve2(cursor, "native", name), resolve2(cursor, "native", "lib", name));
+    }
+    const parent = dirname2(cursor);
+    if (parent === cursor)
+      break;
+    cursor = parent;
+  }
+  return candidates;
+}
+function nativeRuntimeLibraryCandidates() {
+  const explicit = process.env.RIG_NATIVE_RUNTIME_LIB?.trim() || "";
+  const execDir = process.execPath?.trim() ? dirname2(process.execPath.trim()) : "";
+  const platformSpecific = `runtime-native-${process.platform}-${process.arch}.${suffix}`;
+  return [...new Set([
+    explicit,
+    ...nativePackageLibraryCandidates(import.meta.dir, [colocatedNativeRuntimeFileName, platformSpecific]),
+    execDir ? resolve2(execDir, colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve2(execDir, platformSpecific) : "",
+    execDir ? resolve2(execDir, "..", colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve2(execDir, "..", platformSpecific) : "",
+    execDir ? resolve2(execDir, "lib", colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve2(execDir, "..", "lib", colocatedNativeRuntimeFileName) : "",
+    sharedNativeRuntimeOutputPath
+  ].filter(Boolean))];
+}
+function resolveNativeRuntimeSourcePath() {
+  const explicit = process.env.RIG_NATIVE_RUNTIME_SOURCE?.trim();
+  if (explicit && existsSync2(explicit)) {
+    return explicit;
+  }
+  const bundled = resolve2(import.meta.dir, "../../../native/snapshot.zig");
+  return existsSync2(bundled) ? bundled : null;
+}
+async function buildNativeRuntimeLibrary(outputPath, options = {}) {
+  if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
+    return false;
+  }
+  const zigBinary = Bun.which("zig");
+  const sourcePath = resolveNativeRuntimeSourcePath();
+  if (!zigBinary || !sourcePath) {
+    return false;
+  }
+  const tempOutputPath = `${outputPath}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+  try {
+    mkdirSync(dirname2(outputPath), { recursive: true });
+    const needsBuild = options.force === true || !existsSync2(outputPath) || statSync(sourcePath).mtimeMs > statSync(outputPath).mtimeMs;
+    if (!needsBuild) {
+      return true;
+    }
+    const build = Bun.spawn([
+      zigBinary,
+      "build-lib",
+      sourcePath,
+      "-dynamic",
+      "-O",
+      "ReleaseFast",
+      `-femit-bin=${tempOutputPath}`
+    ], {
+      cwd: import.meta.dir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const exitCode = await build.exited;
+    if (exitCode !== 0 || !existsSync2(tempOutputPath)) {
+      rmSync(tempOutputPath, { force: true });
+      return false;
+    }
+    renameSync(tempOutputPath, outputPath);
+    return true;
+  } catch {
+    rmSync(tempOutputPath, { force: true });
+    return false;
+  }
+}
+function tryDlopenNativeRuntimeLibrary(outputPath) {
+  try {
+    return dlopen(outputPath, {
+      rig_scope_match: {
+        args: ["ptr", "ptr"],
+        returns: "u8"
+      },
+      snapshot_capture: {
+        args: ["ptr", "u64", "ptr", "u64"],
+        returns: "ptr"
+      },
+      snapshot_delta: {
+        args: ["ptr", "ptr"],
+        returns: "ptr"
+      },
+      snapshot_store_delta: {
+        args: ["ptr", "ptr", "ptr", "u64", "ptr", "u64", "ptr", "u64", "ptr", "u64"],
+        returns: "ptr"
+      },
+      snapshot_inspect_delta: {
+        args: ["ptr", "u64"],
+        returns: "ptr"
+      },
+      snapshot_apply_delta: {
+        args: ["ptr", "u64", "ptr", "u64"],
+        returns: "ptr"
+      },
+      snapshot_release: {
+        args: ["ptr"],
+        returns: "void"
+      },
+      runtime_hash_file: {
+        args: ["ptr", "u64"],
+        returns: "ptr"
+      },
+      runtime_hash_tree: {
+        args: ["ptr", "u64"],
+        returns: "ptr"
+      },
+      runtime_prepare_paths: {
+        args: ["ptr", "u64", "ptr", "u64", "ptr", "u64", "ptr", "u64", "ptr", "u64"],
+        returns: "ptr"
+      },
+      runtime_link_dependency_layer: {
+        args: ["ptr", "u64", "ptr", "u64"],
+        returns: "ptr"
+      },
+      runtime_scan_worktrees: {
+        args: ["ptr", "u64"],
+        returns: "ptr"
+      }
+    });
+  } catch {
+    return null;
+  }
+}
+
+// packages/runtime/src/control-plane/native/git-native.ts
+import { tmpdir as tmpdir2 } from "os";
+import { dirname as dirname3, isAbsolute, resolve as resolve3 } from "path";
+var sharedGitNativeOutputDir = resolve3(tmpdir2(), "rig-native");
+var sharedGitNativeOutputPath = resolve3(sharedGitNativeOutputDir, `rig-git-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`);
+// packages/runtime/src/control-plane/native/utils.ts
+import { ptr as ptr2 } from "bun:ffi";
+init_layout();
+
+// packages/runtime/src/control-plane/native/scope-rules.ts
+var activeRules = null;
+function getScopeRules() {
+  return activeRules;
+}
+
+// packages/runtime/src/control-plane/native/utils.ts
+var nativeScopeMatcher = null;
+var scopeRegexCache = new Map;
+function unique(values) {
+  return [...new Set(values)];
+}
+function normalizeRelativeScopePath(inputPath) {
+  let normalized = inputPath.replace(/^\.\//, "");
+  const rules = getScopeRules();
+  if (rules?.stripPrefixes) {
+    for (const prefix of rules.stripPrefixes) {
+      if (normalized.startsWith(prefix)) {
+        normalized = normalized.slice(prefix.length);
+      }
+    }
+  }
+  return normalized;
+}
+function normalizePathToScope(projectRoot, monorepoRoot, inputPath) {
+  let normalized = inputPath.replace(/^\.\//, "");
+  if (normalized.startsWith(projectRoot + "/")) {
+    normalized = normalized.slice(projectRoot.length + 1);
+  }
+  if (normalized.startsWith(monorepoRoot + "/")) {
+    normalized = normalized.slice(monorepoRoot.length + 1);
+  }
+  return normalizeRelativeScopePath(normalized);
+}
+function scopeMatches(path, scopes) {
+  const matcher = getNativeScopeMatcher();
+  const pathVariants = unique([path, normalizeRelativeScopePath(path)]);
+  for (const scope of scopes) {
+    const scopeVariants = unique([scope, normalizeRelativeScopePath(scope)]);
+    for (const candidatePath of pathVariants) {
+      for (const candidateScope of scopeVariants) {
+        if (candidatePath === candidateScope) {
+          return true;
+        }
+        if (matcher.match(candidateScope, candidatePath)) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function getNativeScopeMatcher() {
+  if (nativeScopeMatcher) {
+    return nativeScopeMatcher;
+  }
+  nativeScopeMatcher = createNativeScopeMatcher();
+  return nativeScopeMatcher;
+}
+function createNativeScopeMatcher() {
+  const library = requireNativeRuntimeLibrary("scope matching");
+  return {
+    match: (pattern, path) => {
+      const patternBuffer = Buffer.from(`${pattern}\x00`);
+      const pathBuffer = Buffer.from(`${path}\x00`);
+      return library.symbols.rig_scope_match(Number(ptr2(patternBuffer)), Number(ptr2(pathBuffer))) !== 0;
+    }
+  };
+}
+// packages/runtime/src/control-plane/runtime/context.ts
+var DEFAULT_RUNTIME_MEMORY_RETRIEVAL = {
+  topK: 5,
+  lexicalWeight: 0.35,
+  vectorWeight: 0.45,
+  recencyWeight: 0.1,
+  confidenceWeight: 0.1
+};
+
+// packages/runtime/src/control-plane/memory-sync/query.ts
+var DEFAULT_RESULT_LIMIT = DEFAULT_RUNTIME_MEMORY_RETRIEVAL.topK;
+var DAY_MS = 24 * 60 * 60 * 1000;
+// packages/runtime/src/build-time-config.ts
+function normalizeBuildConfig(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string"));
+}
+function readBuildConfig() {
+  if (typeof __RIG_BUILD_CONFIG__ !== "undefined") {
+    return normalizeBuildConfig(__RIG_BUILD_CONFIG__);
+  }
+  const raw = process.env.RIG_BUILD_CONFIG_JSON?.trim();
+  if (!raw) {
+    return {};
+  }
+  try {
+    return normalizeBuildConfig(JSON.parse(raw));
+  } catch {
+    return {};
+  }
+}
+
+// packages/runtime/src/control-plane/runtime/tooling/shell.ts
+import { tmpdir as tmpdir3 } from "os";
+import { basename as basename2, dirname as dirname4, resolve as resolve4 } from "path";
+var sharedNativeShellOutputDir = resolve4(tmpdir3(), "rig-native");
+var sharedNativeShellOutputPath = resolve4(sharedNativeShellOutputDir, `rig-shell-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`);
+// packages/runtime/src/control-plane/runtime/tooling/file-tools.ts
+import { tmpdir as tmpdir4 } from "os";
+import { basename as basename3, dirname as dirname5, resolve as resolve5 } from "path";
+var sharedNativeToolsOutputDir = resolve5(tmpdir4(), "rig-native");
+var sharedNativeToolsOutputPath = resolve5(sharedNativeToolsOutputDir, `rig-tools-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`);
+// packages/runtime/src/control-plane/plugin-host-context.ts
+import { createPluginHost } from "@rig/core";
+import { loadConfig } from "@rig/core/load-config";
+
+// packages/runtime/src/control-plane/repos/registry.ts
+var MANAGED_REPOS = new Map;
+
+// packages/runtime/src/control-plane/tasks/source-aware-task-config-source.ts
+var STATUS_LABELS = new Set(["ready", "blocked", "in-progress", "under-review", "failed", "cancelled"]);
+
+// packages/runtime/src/control-plane/state-sync/types.ts
+var CANONICAL_TASK_LIFECYCLE_STATUSES = new Set([
+  "draft",
+  "open",
+  "ready",
+  "queued",
+  "in_progress",
+  "under_review",
+  "blocked",
+  "completed",
+  "cancelled"
+]);
+// packages/runtime/src/control-plane/repos/layout.ts
+init_layout();
+// packages/runtime/src/control-plane/state-sync/reconcile.ts
+var STALE_CLAIM_MS = 24 * 60 * 60 * 1000;
+// packages/runtime/src/control-plane/native/validator.ts
+init_layout();
+
+// packages/runtime/src/binary-run.ts
+init_layout();
+import { chmodSync, cpSync, existsSync as existsSync3, mkdirSync as mkdirSync2, renameSync as renameSync2, rmSync as rmSync2, writeFileSync } from "fs";
+import { basename as basename4, dirname as dirname6, resolve as resolve6 } from "path";
+import { fileURLToPath } from "url";
+import { drainMicrotasks, gcAndSweep } from "bun:jsc";
+var runtimeBinaryBuildQueue = Promise.resolve();
+async function buildRuntimeBinary(options) {
+  return runSerializedRuntimeBinaryBuild(async () => {
+    const resolved = resolveRuntimeBinaryBuildOptions(options);
+    runBestEffortBuildGc();
+    const manifestPath = runtimeBinaryCacheManifestPath(resolved.outputPath);
+    const buildKey = createRuntimeBinaryBuildKey({
+      entrypoint: resolved.entrypoint,
+      define: resolved.define,
+      env: resolved.env
+    });
+    if (await isRuntimeBinaryBuildFresh({ outputPath: resolved.outputPath, manifestPath, buildKey })) {
+      return;
+    }
+    if (shouldUseRuntimeBinaryBuildWorker()) {
+      await buildRuntimeBinaryViaWorker(resolved);
+    } else {
+      await buildRuntimeBinaryInProcess(resolved, { manifestPath, buildKey });
+    }
+    runBestEffortBuildGc();
+  });
+}
+async function buildRuntimeBinaryInProcess(options, manifest) {
+  const tempBuildDir = resolve6(dirname6(options.outputPath), `.bun-build-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  const tempOutputPath = resolve6(tempBuildDir, basename4(options.outputPath));
+  mkdirSync2(tempBuildDir, { recursive: true });
+  await withTemporaryEnv({
+    ...options.env,
+    ...options.define ? { RIG_BUILD_CONFIG_JSON: JSON.stringify(options.define) } : {}
+  }, async () => withTemporaryCwd(tempBuildDir, async () => {
+    const buildResult = await Bun.build({
+      entrypoints: [options.entrypoint],
+      compile: {
+        target: currentCompileTarget(),
+        outfile: tempOutputPath
+      },
+      target: "bun",
+      format: "esm",
+      minify: true,
+      bytecode: true,
+      metafile: true,
+      define: options.define ? {
+        __RIG_BUILD_CONFIG__: JSON.stringify(options.define)
+      } : undefined
+    });
+    if (!buildResult.success) {
+      const details = buildResult.logs.map((log) => [log.message, log.position?.file ? `${log.position.file}:${log.position.line}:${log.position.column}` : ""].filter(Boolean).join(" ")).filter(Boolean).join(`
+`);
+      throw new Error(`Failed to build ${options.entrypoint}: ${details || "Bun.build() returned errors"}`);
+    }
+    if (!existsSync3(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}`);
+    }
+    renameSync2(tempOutputPath, options.outputPath);
+    chmodSync(options.outputPath, 493);
+    if (manifest) {
+      await writeRuntimeBinaryCacheManifest({
+        manifestPath: manifest.manifestPath,
+        buildKey: manifest.buildKey,
+        cwd: tempBuildDir,
+        metafile: buildResult.metafile
+      });
+    }
+  })).finally(() => {
+    rmSync2(tempBuildDir, { recursive: true, force: true });
+  });
+}
+function runBestEffortBuildGc() {
+  try {
+    drainMicrotasks();
+  } catch {}
+  try {
+    gcAndSweep();
+  } catch {}
+}
+function runtimeBinaryCacheManifestPath(outputPath) {
+  return `${outputPath}.build-manifest.json`;
+}
+function resolveRuntimeBinaryBuildOptions(options) {
+  return {
+    ...options,
+    entrypoint: resolve6(options.cwd, options.sourcePath),
+    outputPath: resolve6(options.outputPath)
+  };
+}
+function shouldUseRuntimeBinaryBuildWorker() {
+  if (process.env.RIG_RUNTIME_BUILD_WORKER === "1") {
+    return false;
+  }
+  if (process.env.RIG_RUNTIME_BUILD_IN_PROCESS === "1") {
+    return false;
+  }
+  return true;
+}
+async function buildRuntimeBinaryViaWorker(options) {
+  const workerSourcePath = resolveRuntimeBinaryBuildWorkerSourcePath(options);
+  if (!workerSourcePath || !existsSync3(workerSourcePath)) {
+    await buildRuntimeBinaryInProcess(options, {
+      manifestPath: runtimeBinaryCacheManifestPath(options.outputPath),
+      buildKey: createRuntimeBinaryBuildKey({
+        entrypoint: options.entrypoint,
+        define: options.define,
+        env: options.env
+      })
+    });
+    return;
+  }
+  const payloadPath = createRuntimeBinaryBuildWorkerPayloadPath(options.outputPath);
+  const bunCli = resolveRuntimeBinaryBuildWorkerInvocation();
+  await Bun.write(payloadPath, `${JSON.stringify(options)}
+`);
+  const build = Bun.spawn([bunCli.command, workerSourcePath, payloadPath], {
+    cwd: options.cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: {
+      ...process.env,
+      ...options.env,
+      ...bunCli.env,
+      RIG_RUNTIME_BUILD_WORKER: "1"
+    }
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    build.exited,
+    new Response(build.stdout).text(),
+    new Response(build.stderr).text()
+  ]);
+  rmSync2(payloadPath, { force: true });
+  if (exitCode !== 0) {
+    throw new Error(`Failed to build ${options.entrypoint}: ${(stderr || stdout || `worker exited ${exitCode}`).trim()}`);
+  }
+}
+function createRuntimeBinaryBuildWorkerPayloadPath(outputPath) {
+  return resolve6(dirname6(outputPath), `.bun-build-worker-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.json`);
+}
+function resolveRuntimeBinaryBuildWorkerSourcePath(options) {
+  const envRoots = [
+    options.cwd?.trim(),
+    process.env.RIG_HOST_PROJECT_ROOT?.trim(),
+    process.env.PROJECT_RIG_ROOT?.trim()
+  ].filter(Boolean);
+  for (const root of envRoots) {
+    const candidate = resolve6(root, "packages/runtime/src/binary-build-worker.ts");
+    if (existsSync3(candidate)) {
+      return candidate;
+    }
+  }
+  const localCandidate = resolve6(import.meta.dir, "binary-build-worker.ts");
+  return existsSync3(localCandidate) ? localCandidate : null;
+}
+function resolveRuntimeBinaryBuildWorkerInvocation() {
+  const bunPath = Bun.which("bun");
+  if (bunPath) {
+    return { command: bunPath, env: {} };
+  }
+  if (process.execPath?.trim()) {
+    return {
+      command: process.execPath,
+      env: { BUN_BE_BUN: "1" }
+    };
+  }
+  throw new Error("bun is required to run the runtime binary build worker.");
+}
+function currentCompileTarget() {
+  if (process.platform === "darwin") {
+    return process.arch === "arm64" ? "bun-darwin-arm64" : "bun-darwin-x64";
+  }
+  if (process.platform === "linux") {
+    return process.arch === "arm64" ? "bun-linux-arm64" : "bun-linux-x64";
+  }
+  return "bun-windows-x64";
+}
+function createRuntimeBinaryBuildKey(input) {
+  return JSON.stringify({
+    version: 1,
+    bunVersion: Bun.version,
+    platform: process.platform,
+    arch: process.arch,
+    entrypoint: input.entrypoint,
+    define: sortRecord(input.define),
+    env: sortRecord(input.env)
+  });
+}
+async function isRuntimeBinaryBuildFresh(input) {
+  if (!existsSync3(input.outputPath) || !existsSync3(input.manifestPath)) {
+    return false;
+  }
+  let manifest = null;
+  try {
+    manifest = await Bun.file(input.manifestPath).json();
+  } catch {
+    return false;
+  }
+  if (!manifest || manifest.version !== 1 || manifest.buildKey !== input.buildKey) {
+    return false;
+  }
+  for (const [filePath, expectedDigest] of Object.entries(manifest.inputs || {})) {
+    if (!existsSync3(filePath)) {
+      return false;
+    }
+    if (await sha256File(filePath) !== expectedDigest) {
+      return false;
+    }
+  }
+  return true;
+}
+async function writeRuntimeBinaryCacheManifest(input) {
+  const inputs = {};
+  for (const inputPath of Object.keys(input.metafile?.inputs || {}).sort()) {
+    const normalized = normalizeBuildInputPath(input.cwd, inputPath);
+    if (!normalized || !existsSync3(normalized)) {
+      continue;
+    }
+    inputs[normalized] = await sha256File(normalized);
+  }
+  const manifest = {
+    version: 1,
+    buildKey: input.buildKey,
+    inputs
+  };
+  await Bun.write(input.manifestPath, `${JSON.stringify(manifest, null, 2)}
+`);
+}
+function normalizeBuildInputPath(cwd, inputPath) {
+  if (!inputPath) {
+    return null;
+  }
+  if (inputPath.startsWith("file://")) {
+    return fileURLToPath(inputPath);
+  }
+  if (inputPath.startsWith("<")) {
+    return null;
+  }
+  return resolve6(cwd, inputPath);
+}
+async function sha256File(path) {
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(await Bun.file(path).arrayBuffer());
+  return hasher.digest("hex");
+}
+function sortRecord(value) {
+  if (!value) {
+    return;
+  }
+  return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)));
+}
+async function runSerializedRuntimeBinaryBuild(action) {
+  const previous = runtimeBinaryBuildQueue;
+  let release;
+  runtimeBinaryBuildQueue = new Promise((resolve7) => {
+    release = resolve7;
+  });
+  await previous;
+  try {
+    return await action();
+  } finally {
+    release();
+  }
+}
+async function withTemporaryEnv(env, action) {
+  if (!env) {
+    return action();
+  }
+  const previousValues = new Map;
+  for (const [key, value] of Object.entries(env)) {
+    previousValues.set(key, process.env[key]);
+    if (value === undefined) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+  try {
+    return await action();
+  } finally {
+    for (const [key, value] of previousValues.entries()) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  }
+}
+async function withTemporaryCwd(cwd, action) {
+  const previousCwd = process.cwd();
+  process.chdir(cwd);
+  try {
+    return await action();
+  } finally {
+    process.chdir(previousCwd);
+  }
+}
+
+// packages/runtime/src/control-plane/runtime/provisioning-env.ts
+import { delimiter, resolve as resolve8 } from "path";
+
+// packages/runtime/src/control-plane/runtime/runtime-paths.ts
+import { existsSync as existsSync4, readdirSync, realpathSync } from "fs";
+import { resolve as resolve7 } from "path";
+
+// packages/runtime/src/control-plane/runtime/sandbox-utils.ts
+init_utils();
+
+// packages/runtime/src/control-plane/runtime/runtime-paths.ts
+function resolveBunBinaryPath() {
+  const explicit = normalizeExecutablePath(process.env.RIG_BUN_PATH?.trim());
+  if (explicit) {
+    return explicit;
+  }
+  const pathBun = normalizeExecutablePath(Bun.which("bun")?.trim());
+  if (pathBun && !looksLikeRuntimeGateway(pathBun)) {
+    return pathBun;
+  }
+  const home = process.env.HOME?.trim();
+  const fallbackCandidates = [
+    home ? resolve7(home, ".bun/bin/bun") : "",
+    "/opt/homebrew/bin/bun",
+    "/usr/local/bin/bun",
+    "/usr/bin/bun"
+  ];
+  for (const candidate of fallbackCandidates) {
+    const normalized = normalizeExecutablePath(candidate);
+    if (normalized) {
+      return normalized;
+    }
+  }
+  const execPath = normalizeExecutablePath(process.execPath?.trim());
+  if (execPath && !looksLikeRuntimeGateway(execPath)) {
+    return execPath;
+  }
+  throw new Error("bun not found in PATH");
+}
+function resolveClaudeBinaryPath() {
+  const explicit = normalizeExecutablePath(process.env.RIG_CLAUDE_PATH?.trim());
+  if (explicit) {
+    return explicit;
+  }
+  const pathClaude = normalizeExecutablePath(Bun.which("claude")?.trim());
+  if (pathClaude && !looksLikeRuntimeGateway(pathClaude)) {
+    return pathClaude;
+  }
+  const home = process.env.HOME?.trim();
+  const fallbackCandidates = [
+    home ? resolve7(home, ".local/bin/claude") : "",
+    home ? resolve7(home, ".local/share/claude/local/claude") : "",
+    "/opt/homebrew/bin/claude",
+    "/usr/local/bin/claude",
+    "/usr/bin/claude"
+  ];
+  for (const candidate of fallbackCandidates) {
+    const normalized = normalizeExecutablePath(candidate);
+    if (normalized) {
+      return normalized;
+    }
+  }
+  throw new Error("claude not found in PATH");
+}
+function resolveBunInstallDir(bunBinaryPath = resolveBunBinaryPath()) {
+  return resolve7(bunBinaryPath, "../..");
+}
+function resolveClaudeInstallDir() {
+  const realPath = resolveClaudeBinaryPath();
+  return resolve7(realPath, "..");
+}
+function resolveNodeInstallDir() {
+  const preferredNode = resolvePreferredNodeBinary();
+  if (!preferredNode)
+    return null;
+  const explicitNode = process.env.RIG_NODE_BIN?.trim();
+  if (explicitNode && resolve7(explicitNode) === resolve7(preferredNode)) {
+    return preferredNode.endsWith("/bin/node") ? resolve7(preferredNode, "../..") : resolve7(preferredNode, "..");
+  }
+  try {
+    const realPath = realpathSync(preferredNode);
+    if (realPath.endsWith("/bin/node")) {
+      return resolve7(realPath, "../..");
+    }
+    return resolve7(realPath, "..");
+  } catch {
+    return resolve7(preferredNode, "..");
+  }
+}
+function resolvePreferredNodeBinary() {
+  const candidates = [];
+  const envNode = process.env.RIG_NODE_BIN?.trim();
+  if (envNode) {
+    const explicit = resolve7(envNode);
+    if (existsSync4(explicit)) {
+      return explicit;
+    }
+  }
+  const nvmBin = process.env.NVM_BIN?.trim();
+  if (nvmBin) {
+    candidates.push(resolve7(nvmBin, "node"));
+  }
+  const home = process.env.HOME?.trim();
+  if (home) {
+    const nvmVersionsDir = resolve7(home, ".nvm/versions/node");
+    if (existsSync4(nvmVersionsDir)) {
+      try {
+        const versionDirs = readdirSync(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(resolve7(nvmVersionsDir, versionDir, "bin/node"));
+        }
+      } catch {}
+    }
+  }
+  const whichNode = Bun.which("node");
+  if (whichNode) {
+    candidates.push(whichNode);
+  }
+  const deduped = uniq(candidates.map((candidate) => resolve7(candidate)));
+  const existing = deduped.filter((candidate) => existsSync4(candidate));
+  if (existing.length === 0) {
+    return null;
+  }
+  const stable = existing.find((candidate) => {
+    const major = inferNodeMajor(candidate);
+    return typeof major === "number" && major >= 18 && major <= 24;
+  });
+  if (stable) {
+    return stable;
+  }
+  return existing[0] ?? null;
+}
+function inferNodeMajor(nodeBinaryPath) {
+  const normalized = resolve7(nodeBinaryPath).replace(/\\/g, "/");
+  const match = normalized.match(/(?:^|\/)(?:node-)?v?(\d+)\.\d+\.\d+(?:\/|$)/);
+  if (!match) {
+    return null;
+  }
+  const major = Number.parseInt(match[1], 10);
+  return Number.isFinite(major) ? major : null;
+}
+function normalizeExecutablePath(candidate) {
+  if (!candidate) {
+    return "";
+  }
+  const normalized = resolve7(candidate);
+  if (!existsSync4(normalized)) {
+    return "";
+  }
+  try {
+    return realpathSync(normalized);
+  } catch {
+    return normalized;
+  }
+}
+function looksLikeRuntimeGateway(candidate) {
+  const normalized = resolve7(candidate).replace(/\\/g, "/");
+  return normalized.includes("/.rig/bin/") || normalized.endsWith("/rig-shell") || normalized.endsWith("/rig-agent");
+}
+
+// packages/runtime/src/control-plane/runtime/provisioning-env.ts
+function runtimeProvisioningEnv(baseEnv = process.env) {
+  const env = { ...baseEnv };
+  const realBash = baseEnv.RIG_REAL_BASH?.trim() || "/bin/bash";
+  const bunBinary = baseEnv.RIG_BUN_PATH?.trim() || resolveBunBinaryPath();
+  const bunDir = resolveBunInstallDir(bunBinary);
+  const claudeBinary = baseEnv.RIG_CLAUDE_PATH?.trim() || (() => {
+    try {
+      return resolveClaudeBinaryPath();
+    } catch {
+      return "";
+    }
+  })();
+  const claudeDir = claudeBinary ? (() => {
+    try {
+      return resolveClaudeInstallDir();
+    } catch {
+      return resolve8(claudeBinary, "..");
+    }
+  })() : "";
+  const nodeDir = resolveNodeInstallDir();
+  const realHome = baseEnv.HOME?.trim();
+  const inheritedPath = (baseEnv.PATH ?? "").split(delimiter).map((entry) => entry.trim()).filter(Boolean).filter((entry) => !entry.endsWith("/.rig/bin") && !entry.endsWith("/rig/tools"));
+  const pathEntries = [
+    `${bunDir}/bin`,
+    claudeDir,
+    nodeDir ? `${nodeDir}/bin` : "",
+    realHome ? resolve8(realHome, ".local/bin") : "",
+    realHome ? resolve8(realHome, ".cargo/bin") : "",
+    ...inheritedPath,
+    "/usr/local/bin",
+    "/usr/local/sbin",
+    "/opt/homebrew/bin",
+    "/opt/homebrew/sbin",
+    "/usr/bin",
+    "/bin",
+    "/usr/sbin",
+    "/sbin"
+  ].filter(Boolean);
+  env.BASH = realBash;
+  env.SHELL = baseEnv.SHELL?.trim() || realBash;
+  env.PATH = [...new Set(pathEntries)].join(delimiter);
+  env.RIG_BUN_PATH = bunBinary;
+  if (claudeBinary) {
+    env.RIG_CLAUDE_PATH = claudeBinary;
+  }
+  env.PYTHON = env.PYTHON?.trim() || "python3";
+  const nodeGypPath = Bun.which("node-gyp");
+  if (nodeGypPath) {
+    env.npm_config_node_gyp = nodeGypPath;
+  }
+  delete env.RIG_BASH_ACTIVE;
+  delete env.RIG_BASH_MODE;
+  return env;
+}
+
+// packages/runtime/src/control-plane/native/git-ops.ts
+var TASK_ARTIFACT_STAGE_FALLBACK = new Set([
+  "changed-files.txt",
+  "contract-changes.md",
+  "decision-log.md",
+  "git-state.txt",
+  "next-actions.md",
+  "pr-state.json",
+  "task-result.json",
+  "validation-summary.json"
+]);
+
+// packages/runtime/src/control-plane/provider/runtime-instructions.ts
+var CLAUDE_ROUTER_TOOL_NAMES = [
+  "`mcp__rig_runtime_tools__read`",
+  "`mcp__rig_runtime_tools__write`",
+  "`mcp__rig_runtime_tools__edit`",
+  "`mcp__rig_runtime_tools__glob`",
+  "`mcp__rig_runtime_tools__grep`"
+].join(", ");
+var CODEX_DYNAMIC_TOOL_NAMES = [
+  "`shell`",
+  "`read`",
+  "`write`",
+  "`edit`",
+  "`glob`",
+  "`grep`"
+].join(", ");
+
+// packages/runtime/src/control-plane/native/task-ops.ts
+var BUILD_CONFIG = readBuildConfig();
+var BAKED_INFO_OUTPUT = BUILD_CONFIG.AGENT_INFO_OUTPUT ?? "";
+var BAKED_DEPS_OUTPUT = BUILD_CONFIG.AGENT_DEPS_OUTPUT ?? "";
+var BAKED_STATUS_OUTPUT = BUILD_CONFIG.AGENT_STATUS_OUTPUT ?? "";
+var REOPENABLE_TASK_STATUSES = new Set(["completed", "cancelled", "blocked"]);
+var GENERATED_TASK_ARTIFACT_FILES = new Set([
+  "changed-files.txt",
+  "decision-log.md",
+  "next-actions.md",
+  "task-result.json",
+  "validation-summary.json",
+  "review-feedback.md",
+  "review-state.json",
+  "review-status.txt",
+  "review-greptile-raw.json",
+  "pr-state.json",
+  "git-state.txt"
+]);
+
+// packages/runtime/src/control-plane/runtime/isolation/index.ts
+init_layout();
+
+// packages/runtime/src/control-plane/runtime/overlay.ts
+init_layout();
+
+// packages/runtime/src/control-plane/runtime/isolation/shared.ts
+var generatedCredentialFiles = new Set;
+
+// packages/runtime/src/control-plane/runtime/isolation/home.ts
+var GITHUB_KNOWN_HOSTS = [
+  "github.com ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOMqqnkVzrm0SdG6UOoqKLsabgH5C9okWi0dh2l9GKJl",
+  "github.com ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBEmKSENjQEezOmxkZMy7opKgwFB9nkt5YRrYMjNuG5N87uRgg6CLrbo5wAdT/y6v0mKV0U2w0WZ2YB/++Tpockg=",
+  "github.com ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQCj7ndNxQowgcQnjshcLrqPEiiphnt+VTTvDP6mHBL9j1aNUkY4Ue1gvwnGLVlOhGeYrnZaMgRK6+PKCUXaDbC7qtbW8gIkhL7aGCsOr/C56SJMy/BCZfxd1nWzAOxSDPgVsmerOBYfNqltV9/hWCqBywINIR+5dIg6JTJ72pcEpEjcYgXkE2YEFXV1JHnsKgbLWNlhScqb2UmyRkQyytRLtL+38TGxkxCflmO+5Z8CSSNY7GidjMIZ7Q4zMjA2n1nGrlTDkzwDCsw+wqFPGQA179cnfGWOWRVruj16z6XyvxvjJwbz0wQZ75XK5tKSb7FNyeIEs4TT4jk+S4dhPeAUC5y+bDYirYgM4GC7uEnztnZyaVWQ7B381AK4Qdrwt51ZqExKbQpTUNn+EjqoTwvqNj4kqx5QUCI0ThS/YkOxJCXmPUWZbhjpCg56i+2aB6CmK2JGhn57K5mj0MNdBXA4/WnwH6XoPWJzK5Nyu2zB3nAZp+S5hpQs+p1vN1/wsjk="
+].join(`
+`);
+
+// packages/runtime/src/control-plane/runtime/tooling/claude-router.ts
+if (false) {}
+// packages/runtime/src/control-plane/runtime/isolation/discovery.ts
+init_layout();
+
+// packages/runtime/src/control-plane/runtime/tooling/claude-router-binary.ts
+import { tmpdir as tmpdir5 } from "os";
+import { dirname as dirname7, resolve as resolve9 } from "path";
+var sharedRouterOutputDir = resolve9(tmpdir5(), "rig-native");
+var sharedRouterOutputPath = resolve9(sharedRouterOutputDir, `rig-tool-router-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`);
+// packages/runtime/src/control-plane/runtime/isolation/toolchain.ts
+async function buildBinary(entrypoint, outputPath, cwd, defines) {
+  await buildRuntimeBinary({
+    sourcePath: entrypoint,
+    outputPath,
+    cwd,
+    define: defines,
+    env: runtimeProvisioningEnv()
+  });
+}
+
+// packages/runtime/src/control-plane/runtime/guard.ts
+import { optimizeNextInvocation } from "bun:jsc";
+import { existsSync as existsSync5, readFileSync, statSync as statSync2 } from "fs";
+import { resolve as resolve10 } from "path";
+
+// packages/runtime/src/control-plane/runtime/guard-types.ts
+var POLICY_VERSION = 1;
+
+// packages/runtime/src/control-plane/runtime/guard.ts
+var DEFAULT_SCOPE = {
+  fail_closed: true,
+  harness_paths_exempt: true,
+  runtime_paths_exempt: true
+};
+var DEFAULT_SANDBOX = {
+  mode: "enforce",
+  network: true,
+  read_deny: [],
+  write_allow_from_runtime: true
+};
+var DEFAULT_ISOLATION = {
+  default_mode: "worktree",
+  repo_symlink_fallback: false,
+  strict_provisioning: true,
+  fail_closed_on_provision_error: true
+};
+var DEFAULT_COMPLETION = {
+  derive_checks_from_scope: true,
+  checks: [],
+  typescript_config_probe: ["tsconfig.json"],
+  eslint_config_probe: [".eslintrc.js", ".eslintrc.json", "eslint.config.js"]
+};
+var DEFAULT_RUNTIME_IMAGE = {
+  deps: {
+    monorepo_install: false,
+    hp_next_install: false
+  },
+  plugins_require_binaries: true
+};
+var DEFAULT_RUNTIME_SNAPSHOT = {
+  enabled: true
+};
+function defaultPolicy() {
+  return {
+    version: POLICY_VERSION,
+    mode: "enforce",
+    scope: { ...DEFAULT_SCOPE },
+    rules: [],
+    sandbox: { ...DEFAULT_SANDBOX },
+    isolation: { ...DEFAULT_ISOLATION },
+    completion: { ...DEFAULT_COMPLETION },
+    runtime_image: {
+      deps: { ...DEFAULT_RUNTIME_IMAGE.deps },
+      plugins_require_binaries: DEFAULT_RUNTIME_IMAGE.plugins_require_binaries
+    },
+    runtime_snapshot: { ...DEFAULT_RUNTIME_SNAPSHOT }
+  };
+}
+var policyCache = null;
+var policyCachePath = null;
+var seededPolicyConfig = null;
+var compiledRegexCache = new Map;
+function loadPolicy(projectRoot) {
+  if (seededPolicyConfig) {
+    return seededPolicyConfig;
+  }
+  const configPath = resolve10(projectRoot, "rig/policy/policy.json");
+  if (!existsSync5(configPath)) {
+    return defaultPolicy();
+  }
+  let mtimeMs;
+  try {
+    mtimeMs = statSync2(configPath).mtimeMs;
+  } catch {
+    return defaultPolicy();
+  }
+  if (policyCache && policyCachePath === configPath && policyCache.mtimeMs === mtimeMs) {
+    return policyCache.config;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(configPath, "utf-8"));
+  } catch {
+    return defaultPolicy();
+  }
+  const config = mergeWithDefaults(parsed);
+  policyCache = { mtimeMs, config };
+  policyCachePath = configPath;
+  return config;
+}
+function mergeWithDefaults(parsed) {
+  const base = defaultPolicy();
+  if (typeof parsed.mode === "string" && isValidMode(parsed.mode)) {
+    base.mode = parsed.mode;
+  }
+  if (parsed.scope && typeof parsed.scope === "object" && !Array.isArray(parsed.scope)) {
+    const s = parsed.scope;
+    if (typeof s.fail_closed === "boolean")
+      base.scope.fail_closed = s.fail_closed;
+    if (typeof s.harness_paths_exempt === "boolean")
+      base.scope.harness_paths_exempt = s.harness_paths_exempt;
+    if (typeof s.runtime_paths_exempt === "boolean")
+      base.scope.runtime_paths_exempt = s.runtime_paths_exempt;
+  }
+  if (Array.isArray(parsed.rules)) {
+    base.rules = precompilePolicyRuleRegexes(parsed.rules.filter(isValidRule));
+  }
+  if (Array.isArray(parsed.deny) && base.rules.length === 0) {
+    base.rules = precompilePolicyRuleRegexes(migrateLegacyDeny(parsed.deny));
+  }
+  if (parsed.sandbox && typeof parsed.sandbox === "object" && !Array.isArray(parsed.sandbox)) {
+    const sb = parsed.sandbox;
+    if (typeof sb.mode === "string" && isValidMode(sb.mode))
+      base.sandbox.mode = sb.mode;
+    if (typeof sb.network === "boolean")
+      base.sandbox.network = sb.network;
+    if (Array.isArray(sb.read_deny))
+      base.sandbox.read_deny = sb.read_deny.filter((v) => typeof v === "string");
+    if (typeof sb.write_allow_from_runtime === "boolean")
+      base.sandbox.write_allow_from_runtime = sb.write_allow_from_runtime;
+  }
+  if (parsed.isolation && typeof parsed.isolation === "object" && !Array.isArray(parsed.isolation)) {
+    const iso = parsed.isolation;
+    if (iso.default_mode === "worktree")
+      base.isolation.default_mode = iso.default_mode;
+    if (typeof iso.repo_symlink_fallback === "boolean")
+      base.isolation.repo_symlink_fallback = iso.repo_symlink_fallback;
+    if (typeof iso.strict_provisioning === "boolean")
+      base.isolation.strict_provisioning = iso.strict_provisioning;
+    if (typeof iso.fail_closed_on_provision_error === "boolean")
+      base.isolation.fail_closed_on_provision_error = iso.fail_closed_on_provision_error;
+  }
+  if (parsed.completion && typeof parsed.completion === "object" && !Array.isArray(parsed.completion)) {
+    const comp = parsed.completion;
+    if (typeof comp.derive_checks_from_scope === "boolean")
+      base.completion.derive_checks_from_scope = comp.derive_checks_from_scope;
+    if (Array.isArray(comp.checks))
+      base.completion.checks = comp.checks.filter((v) => typeof v === "string");
+    if (Array.isArray(comp.typescript_config_probe))
+      base.completion.typescript_config_probe = comp.typescript_config_probe.filter((v) => typeof v === "string");
+    if (Array.isArray(comp.eslint_config_probe))
+      base.completion.eslint_config_probe = comp.eslint_config_probe.filter((v) => typeof v === "string");
+  }
+  if (parsed.runtime_image && typeof parsed.runtime_image === "object" && !Array.isArray(parsed.runtime_image)) {
+    const runtimeImage = parsed.runtime_image;
+    if (runtimeImage.deps && typeof runtimeImage.deps === "object" && !Array.isArray(runtimeImage.deps)) {
+      const deps = runtimeImage.deps;
+      if (typeof deps.monorepo_install === "boolean") {
+        base.runtime_image.deps.monorepo_install = deps.monorepo_install;
+      }
+      if (typeof deps.hp_next_install === "boolean") {
+        base.runtime_image.deps.hp_next_install = deps.hp_next_install;
+      }
+    }
+    if (typeof runtimeImage.plugins_require_binaries === "boolean") {
+      base.runtime_image.plugins_require_binaries = runtimeImage.plugins_require_binaries;
+    }
+  }
+  if (parsed.runtime_snapshot && typeof parsed.runtime_snapshot === "object" && !Array.isArray(parsed.runtime_snapshot)) {
+    const runtimeSnapshot = parsed.runtime_snapshot;
+    if (typeof runtimeSnapshot.enabled === "boolean") {
+      base.runtime_snapshot.enabled = runtimeSnapshot.enabled;
+    }
+  }
+  return base;
+}
+function isValidMode(value) {
+  return value === "off" || value === "observe" || value === "enforce";
+}
+function isValidRule(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const r = value;
+  return typeof r.id === "string" && typeof r.category === "string" && r.match != null && typeof r.match === "object";
+}
+function migrateLegacyDeny(deny) {
+  const rules = [];
+  for (const entry of deny) {
+    if (typeof entry.id !== "string")
+      continue;
+    const match = {};
+    if (typeof entry.pattern === "string")
+      match.pattern = entry.pattern;
+    if (typeof entry.regex === "string")
+      match.regex = entry.regex;
+    if (!match.pattern && !match.regex)
+      continue;
+    rules.push({
+      id: entry.id,
+      category: "command",
+      match,
+      action: "block",
+      ...typeof entry.description === "string" ? { description: entry.description } : {}
+    });
+  }
+  return rules;
+}
+function precompilePolicyRuleRegexes(rules) {
+  return rules.map((rule) => {
+    const compiledRegex = rule.match.regex ? compileSafeRegex(rule.match.regex, `rules.${rule.id}.match.regex`, true) : undefined;
+    const compiledUnlessRegex = rule.unless?.regex ? compileSafeRegex(rule.unless.regex, `rules.${rule.id}.unless.regex`, true) : undefined;
+    return {
+      ...rule,
+      ...compiledRegex ? { compiledRegex } : {},
+      ...compiledUnlessRegex ? { compiledUnlessRegex } : {}
+    };
+  });
+}
+function getRegexUnsafeReason(pattern) {
+  if (pattern.length > 512) {
+    return "pattern exceeds max safe length (512 chars)";
+  }
+  if (/\\[1-9]/.test(pattern)) {
+    return "pattern uses backreferences";
+  }
+  if (/\((?:[^()\\]|\\.)*[+*](?:[^()\\]|\\.)*\)\s*[*+{]/.test(pattern)) {
+    return "pattern contains nested quantifiers";
+  }
+  if (/\((?:[^()\\]|\\.)*\.\\?[+*](?:[^()\\]|\\.)*\)\s*[*+{]/.test(pattern)) {
+    return "pattern contains nested broad quantifiers";
+  }
+  return null;
+}
+function compileSafeRegex(pattern, sourceLabel, logOnFailure) {
+  const cached = compiledRegexCache.get(pattern);
+  if (cached !== undefined) {
+    return cached ?? undefined;
+  }
+  const unsafeReason = getRegexUnsafeReason(pattern);
+  if (unsafeReason) {
+    if (logOnFailure) {
+      console.warn(`[policy] Skipping unsafe regex in ${sourceLabel}: ${unsafeReason}`);
+    }
+    compiledRegexCache.set(pattern, null);
+    return;
+  }
+  try {
+    const compiled = new RegExp(pattern);
+    compiledRegexCache.set(pattern, compiled);
+    return compiled;
+  } catch (error) {
+    if (logOnFailure) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`[policy] Skipping invalid regex in ${sourceLabel}: ${message}`);
+    }
+    compiledRegexCache.set(pattern, null);
+    return;
+  }
+}
+function matchRule(rule, input) {
+  const { match } = rule;
+  if (match.pattern && input.includes(match.pattern)) {
+    return true;
+  }
+  if (match.regex) {
+    const compiled = rule.compiledRegex || compileSafeRegex(match.regex, `rules.${rule.id}.match.regex`, false);
+    if (!compiled) {
+      return false;
+    }
+    try {
+      return compiled.test(input);
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function matchRuleUnless(rule, command, taskId) {
+  if (!rule.unless)
+    return false;
+  if (rule.unless.regex) {
+    const compiled = rule.compiledUnlessRegex || compileSafeRegex(rule.unless.regex, `rules.${rule.id}.unless.regex`, false);
+    if (!compiled) {
+      return false;
+    }
+    try {
+      if (compiled.test(command))
+        return true;
+    } catch {}
+  }
+  if (rule.unless.task_in && taskId) {
+    if (rule.unless.task_in.includes(taskId))
+      return true;
+  }
+  return false;
+}
+function resolveAction(mode, matched) {
+  if (matched.length === 0)
+    return "allow";
+  if (mode === "off")
+    return "allow";
+  if (mode === "observe")
+    return "warn";
+  return "block";
+}
+function resolveAbsolutePath(projectRoot, rawPath) {
+  if (rawPath.startsWith("/"))
+    return resolve10(rawPath);
+  return resolve10(projectRoot, rawPath);
+}
+function isHarnessPath(projectRoot, rawPath) {
+  const absPath = resolveAbsolutePath(projectRoot, rawPath);
+  const managedRoots = [
+    resolve10(projectRoot, "rig"),
+    resolve10(projectRoot, ".rig"),
+    resolve10(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 = resolve10(taskWorkspace, ".rig");
+    const workspaceArtifactsRoot = resolve10(taskWorkspace, "artifacts");
+    if (absPath === workspaceRigRoot || absPath.startsWith(workspaceRigRoot + "/") || absPath === workspaceArtifactsRoot || absPath.startsWith(workspaceArtifactsRoot + "/")) {
+      return true;
+    }
+  }
+  const runtimeRoot = resolve10(projectRoot, ".rig/runtime/agents");
+  return absPath === runtimeRoot || absPath.startsWith(runtimeRoot + "/");
+}
+function isTestFile(path) {
+  return /\.(test|spec)\.(ts|tsx|js|jsx)$/.test(path) || /\/(__tests__|tests|test)\//.test(path);
+}
+function evaluate(context) {
+  const policy = loadPolicy(context.projectRoot);
+  switch (context.evaluation.type) {
+    case "tool-call":
+      return evaluateToolCall(policy, context);
+    case "command":
+      return evaluateCommand(policy, context);
+    case "content-write":
+      return evaluateContent(policy, context);
+    case "file-access":
+      return evaluateScope(policy, context, context.evaluation.file_path, context.evaluation.access);
+  }
+}
+function evaluateScope(policy, context, filePath, access) {
+  const allowed = () => ({
+    allowed: true,
+    matchedRules: [],
+    action: "allow",
+    failClosed: false
+  });
+  if (policy.scope.harness_paths_exempt && isHarnessPath(context.projectRoot, filePath)) {
+    return allowed();
+  }
+  if (policy.scope.runtime_paths_exempt && isRuntimePath(context.projectRoot, filePath, context.taskWorkspace)) {
+    return allowed();
+  }
+  if (!context.taskId) {
+    if (access === "write" && policy.scope.fail_closed) {
+      return {
+        allowed: false,
+        matchedRules: [],
+        action: resolveAction(policy.mode, [{ id: "scope:no-task", category: "command", reason: "No active task; fail-closed for write operations" }]),
+        failClosed: true
+      };
+    }
+    return allowed();
+  }
+  const scopes = context.taskScopes || [];
+  if (scopes.length === 0) {
+    return allowed();
+  }
+  if (context.taskWorkspace && context.taskWorkspace !== context.projectRoot && filePath.startsWith("/")) {
+    const absPath = resolve10(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 }];
+      return {
+        allowed: policy.mode !== "enforce",
+        matchedRules: matched2,
+        action: resolveAction(policy.mode, matched2),
+        failClosed: false
+      };
+    }
+  }
+  const monorepoRoot = context.monorepoRoot || process.env.MONOREPO_ROOT?.trim() || context.taskWorkspace || context.projectRoot;
+  let normalizedPath = filePath;
+  if (context.taskWorkspace && context.taskWorkspace !== context.projectRoot && filePath.startsWith(context.taskWorkspace + "/")) {
+    normalizedPath = filePath.slice(context.taskWorkspace.length + 1);
+  }
+  normalizedPath = normalizePathToScope(context.projectRoot, monorepoRoot, normalizedPath);
+  if (scopeMatches(filePath, scopes) || scopeMatches(normalizedPath, scopes)) {
+    return allowed();
+  }
+  const reason = `File '${filePath}' (normalized: '${normalizedPath}') is outside scope of task ${context.taskId}`;
+  const matched = [{ id: "scope:out-of-scope", category: "command", reason }];
+  return {
+    allowed: policy.mode !== "enforce",
+    matchedRules: matched,
+    action: resolveAction(policy.mode, matched),
+    failClosed: false
+  };
+}
+function evaluateCommand(policy, context) {
+  const evaluation = context.evaluation;
+  if (evaluation.type !== "command") {
+    return { allowed: true, matchedRules: [], action: "allow", failClosed: false };
+  }
+  const command = evaluation.command;
+  const matchedRules = [];
+  for (const rule of policy.rules) {
+    if (rule.category !== "command")
+      continue;
+    if (!matchRule(rule, command))
+      continue;
+    if (matchRuleUnless(rule, command, context.taskId))
+      continue;
+    matchedRules.push({
+      id: rule.id,
+      category: rule.category,
+      description: rule.description,
+      reason: rule.description || `Matched rule ${rule.id}`
+    });
+  }
+  const writeTarget = extractWriteTarget(command);
+  if (writeTarget && !/^\/dev\//.test(writeTarget) && !/^\/proc\//.test(writeTarget)) {
+    const scopeResult = evaluateScope(policy, context, writeTarget, "write");
+    if (!scopeResult.allowed || scopeResult.matchedRules.length > 0) {
+      matchedRules.push(...scopeResult.matchedRules);
+    }
+  }
+  const action = resolveAction(policy.mode, matchedRules);
+  return {
+    allowed: action !== "block",
+    matchedRules,
+    action,
+    failClosed: false
+  };
+}
+function extractWriteTarget(command) {
+  const redirect = command.match(/>>?\s+([^\s;|&]+)/);
+  if (redirect?.[1])
+    return redirect[1];
+  const tee = command.match(/tee\s+(-a\s+)?([^\s;|&]+)/);
+  if (tee?.[2])
+    return tee[2];
+  return "";
+}
+function evaluateContent(policy, context) {
+  const evaluation = context.evaluation;
+  if (evaluation.type !== "content-write") {
+    return { allowed: true, matchedRules: [], action: "allow", failClosed: false };
+  }
+  const { content, file_path } = evaluation;
+  const matchedRules = [];
+  const scopeResult = evaluateScope(policy, context, file_path, "write");
+  if (scopeResult.matchedRules.length > 0) {
+    matchedRules.push(...scopeResult.matchedRules);
+  }
+  for (const rule of policy.rules) {
+    if (rule.category !== "content" && rule.category !== "import" && rule.category !== "test-integrity")
+      continue;
+    if (rule.applies_to === "test-files" && !isTestFile(file_path))
+      continue;
+    if (!matchRule(rule, content))
+      continue;
+    if (matchRuleUnless(rule, content, context.taskId))
+      continue;
+    matchedRules.push({
+      id: rule.id,
+      category: rule.category,
+      description: rule.description,
+      reason: rule.description || `Matched rule ${rule.id}`
+    });
+  }
+  const action = resolveAction(policy.mode, matchedRules);
+  return {
+    allowed: action !== "block",
+    matchedRules,
+    action,
+    failClosed: false
+  };
+}
+function evaluateToolCall(policy, context) {
+  const evaluation = context.evaluation;
+  if (evaluation.type !== "tool-call") {
+    return { allowed: true, matchedRules: [], action: "allow", failClosed: false };
+  }
+  const { tool_name, tool_input } = evaluation;
+  const allMatched = [];
+  const filePaths = extractFilePathsFromToolInput(tool_name, tool_input);
+  for (const fp of filePaths) {
+    const access = isWriteTool(tool_name) ? "write" : "read";
+    const scopeResult = evaluateScope(policy, context, fp, access);
+    if (scopeResult.matchedRules.length > 0) {
+      allMatched.push(...scopeResult.matchedRules);
+    }
+  }
+  const content = extractContentFromToolInput(tool_input);
+  if (content) {
+    const filePath = filePaths[0] || "";
+    const contentContext = {
+      ...context,
+      evaluation: { type: "content-write", file_path: filePath, content }
+    };
+    const contentPolicy = loadPolicy(context.projectRoot);
+    for (const rule of contentPolicy.rules) {
+      if (rule.category !== "content" && rule.category !== "import" && rule.category !== "test-integrity")
+        continue;
+      if (rule.applies_to === "test-files" && !isTestFile(filePath))
+        continue;
+      if (!matchRule(rule, content))
+        continue;
+      if (matchRuleUnless(rule, content, context.taskId))
+        continue;
+      allMatched.push({
+        id: rule.id,
+        category: rule.category,
+        description: rule.description,
+        reason: rule.description || `Matched rule ${rule.id}`
+      });
+    }
+  }
+  if (tool_name === "Bash") {
+    const command = String(tool_input.command || tool_input.cmd || "");
+    if (command) {
+      const cmdContext = {
+        ...context,
+        evaluation: { type: "command", command }
+      };
+      const cmdResult = evaluateCommand(policy, cmdContext);
+      if (cmdResult.matchedRules.length > 0) {
+        allMatched.push(...cmdResult.matchedRules);
+      }
+    }
+  }
+  const seen = new Set;
+  const deduplicated = [];
+  for (const rule of allMatched) {
+    if (!seen.has(rule.id)) {
+      seen.add(rule.id);
+      deduplicated.push(rule);
+    }
+  }
+  const action = resolveAction(policy.mode, deduplicated);
+  return {
+    allowed: action !== "block",
+    matchedRules: deduplicated,
+    action,
+    failClosed: false
+  };
+}
+function isWriteTool(toolName) {
+  return toolName === "Write" || toolName === "Edit" || toolName === "MultiEdit";
+}
+function extractFilePathsFromToolInput(toolName, input) {
+  const paths = [];
+  const add = (value) => {
+    if (typeof value === "string" && value.trim()) {
+      paths.push(value.trim());
+    }
+  };
+  if (toolName === "Read" || toolName === "Write" || toolName === "Edit" || toolName === "MultiEdit") {
+    add(input.file_path);
+    add(input.path);
+  } else if (toolName === "Glob") {
+    add(input.path);
+  } else if (toolName === "Grep") {
+    add(input.path);
+  } else {
+    add(input.file_path);
+    add(input.path);
+  }
+  return paths;
+}
+function extractContentFromToolInput(input) {
+  if (typeof input.content === "string")
+    return input.content;
+  if (typeof input.new_string === "string")
+    return input.new_string;
+  return "";
+}
+function loadRuntimeImageConfig(projectRoot) {
+  return loadPolicy(projectRoot).runtime_image ?? {
+    deps: { ...DEFAULT_RUNTIME_IMAGE.deps },
+    plugins_require_binaries: DEFAULT_RUNTIME_IMAGE.plugins_require_binaries
+  };
+}
+var guardHotPathPrimed = false;
+function primeGuardHotPaths() {
+  if (guardHotPathPrimed) {
+    return;
+  }
+  guardHotPathPrimed = true;
+  try {
+    optimizeNextInvocation(matchRule);
+    optimizeNextInvocation(evaluate);
+  } catch {}
+}
+primeGuardHotPaths();
+
+// packages/runtime/src/control-plane/runtime/sandbox/backend.ts
+init_utils();
+// packages/runtime/src/control-plane/runtime/isolation/runner.ts
+init_layout();
+// packages/runtime/src/control-plane/runtime/image.ts
+var HASH_RESULT_SIZE = 40;
+var nativeRuntimeLibrary2 = null;
+function sha256Hex2(input) {
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(input);
+  return hasher.digest("hex");
+}
+function hashFile(filePath) {
+  if (!existsSync6(filePath)) {
+    return "";
+  }
+  return hashPathWithNative("runtime_hash_file", filePath);
+}
+function hashDirectory(dir) {
+  if (!existsSync6(dir)) {
+    return sha256Hex2("(empty)");
+  }
+  return hashPathWithNative("runtime_hash_tree", dir);
+}
+function hashDirectories(dirs) {
+  const combined = new Bun.CryptoHasher("sha256");
+  for (const { label, path } of dirs) {
+    const dirHash = hashDirectory(path);
+    combined.update(`${label}:${dirHash}
+`);
+  }
+  return combined.digest("hex");
+}
+async function probeVersion(args) {
+  try {
+    const proc = Bun.spawn(args, { stdout: "pipe", stderr: "pipe" });
+    const [exitCode, stdout] = await Promise.all([
+      proc.exited,
+      new Response(proc.stdout).text()
+    ]);
+    if (exitCode === 0) {
+      return stdout.trim().split(`
+`)[0] ?? "";
+    }
+    return "";
+  } catch {
+    return "";
+  }
+}
+async function computeRuntimeImageFingerprint(projectRoot) {
+  return runFingerprintSidecar(projectRoot);
+}
+async function computeRuntimeImageFingerprintNative(projectRoot) {
+  const [nodeVersion, claudeVersion] = await Promise.all([
+    probeVersion(["node", "--version"]),
+    probeVersion(["claude", "--version"])
+  ]);
+  const runtimeDir = resolve11(projectRoot, "packages", "runtime");
+  const cliDir = resolve11(projectRoot, "packages", "cli");
+  const serverDir = resolve11(projectRoot, "packages", "server");
+  const runtimeCodeHash = hashDirectories([
+    { label: "packages/runtime", path: runtimeDir },
+    { label: "packages/cli", path: cliDir },
+    { label: "packages/server", path: serverDir }
+  ]);
+  const policyPath = resolve11(projectRoot, "rig/policy/policy.json");
+  const policyHash = hashFile(policyPath);
+  const pluginsDir = resolve11(projectRoot, "rig/plugins");
+  const pluginsHash = hashDirectory(pluginsDir);
+  const baseLockfiles = [
+    "bun.lock",
+    "bun.lockb",
+    "package-lock.json",
+    "package.json",
+    "tsconfig.json"
+  ];
+  const extra = process.env.RIG_RUNTIME_IMAGE_EXTRA_LOCKFILES?.trim();
+  const lockfileCandidates = extra ? [...baseLockfiles, ...extra.split(",").map((p) => p.trim()).filter(Boolean)] : baseLockfiles;
+  const lockfileHashes = {};
+  for (const relPath of lockfileCandidates) {
+    const fullPath = resolve11(projectRoot, relPath);
+    if (existsSync6(fullPath)) {
+      lockfileHashes[relPath] = hashFile(fullPath);
+    }
+  }
+  return {
+    platform: process.platform,
+    bunVersion: Bun.version,
+    nodeVersion,
+    claudeVersion,
+    runtimeCodeHash,
+    policyHash,
+    pluginsHash,
+    lockfileHashes
+  };
+}
+async function runFingerprintSidecar(projectRoot) {
+  const sidecarPath = resolveRuntimeSourceScriptPath(projectRoot, "image-fingerprint-sidecar.ts");
+  const bunCli = resolveBunCliInvocation();
+  const proc = Bun.spawn([bunCli.command, sidecarPath, "--project-root", projectRoot], {
+    cwd: projectRoot,
+    env: {
+      ...process.env,
+      ...bunCli.env
+    },
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    proc.exited,
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text()
+  ]);
+  if (exitCode !== 0) {
+    throw new Error(stderr.trim() || stdout.trim() || `runtime image sidecar exited with ${exitCode}`);
+  }
+  return JSON.parse(stdout);
+}
+function resolveRuntimeSourceScriptPath(projectRoot, fileName) {
+  const hostRoots = [
+    process.env.RIG_HOST_PROJECT_ROOT?.trim(),
+    process.env.PROJECT_RIG_ROOT?.trim(),
+    projectRoot.trim()
+  ].filter((value) => Boolean(value));
+  for (const root of hostRoots) {
+    const candidate = resolve11(root, "packages/runtime/src/control-plane/runtime", fileName);
+    if (existsSync6(candidate)) {
+      return candidate;
+    }
+  }
+  return resolve11(import.meta.dir, fileName);
+}
+function resolveBunCliInvocation() {
+  if (process.env.RIG_BUN_PATH?.trim()) {
+    return {
+      command: process.env.RIG_BUN_PATH.trim(),
+      env: {}
+    };
+  }
+  try {
+    const systemBun = resolveBunBinaryPath();
+    return {
+      command: systemBun,
+      env: {}
+    };
+  } catch {}
+  if (process.execPath?.trim()) {
+    return {
+      command: process.execPath,
+      env: { BUN_BE_BUN: "1" }
+    };
+  }
+  return { command: "bun", env: {} };
+}
+function hashPathWithNative(symbol, path) {
+  const pathBuffer = Buffer.from(path, "utf8");
+  const runtimeLibrary = getNativeRuntimeLibrary();
+  const resultPtr = runtimeLibrary.symbols[symbol](Number(ptr3(pathBuffer)), pathBuffer.byteLength);
+  if (!resultPtr) {
+    throw new Error(`${symbol} returned null for ${path}`);
+  }
+  try {
+    const view = viewAt(resultPtr, HASH_RESULT_SIZE);
+    const error = readError(view, 24, 32);
+    if (error) {
+      throw new Error(`${symbol} failed: ${error}`);
+    }
+    return readString(readU64(view, 8), readU64(view, 16));
+  } finally {
+    runtimeLibrary.symbols.snapshot_release(resultPtr);
+  }
+}
+function getNativeRuntimeLibrary() {
+  if (nativeRuntimeLibrary2) {
+    return nativeRuntimeLibrary2;
+  }
+  nativeRuntimeLibrary2 = requireNativeRuntimeLibrary("runtime image hashing");
+  return nativeRuntimeLibrary2;
+}
+function viewAt(pointer, size) {
+  const buffer = toBuffer2(pointer, 0, size);
+  return new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+}
+function readString(pointer, length) {
+  if (!pointer || length === 0) {
+    return "";
+  }
+  return Buffer.from(toBuffer2(pointer, 0, length)).toString("utf8");
+}
+function readU64(view, offset) {
+  return Number(view.getBigUint64(offset, true));
+}
+function readError(view, pointerOffset, lengthOffset) {
+  const errorPointer = readU64(view, pointerOffset);
+  const errorLength = readU64(view, lengthOffset);
+  if (!errorPointer || !errorLength) {
+    return null;
+  }
+  return readString(errorPointer, errorLength);
+}
+function computeRuntimeImageId(fp) {
+  const serialized = JSON.stringify(fp);
+  return sha256Hex2(serialized).slice(0, 16);
+}
+var LOCK_STALE_MS = 10 * 60 * 1000;
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readRuntimeImageLockData(lockPath) {
+  try {
+    const stat = lstatSync(lockPath);
+    const raw = stat.isDirectory() ? readFileSync2(resolve11(lockPath, "owner.json"), "utf-8") : readFileSync2(lockPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function acquireRuntimeImageLock(lockPath) {
+  const lockData = { pid: process.pid, timestamp: Date.now() };
+  const lockBody = JSON.stringify(lockData);
+  const tryExclusiveCreate = () => {
+    try {
+      mkdirSync3(lockPath);
+      writeFileSync2(resolve11(lockPath, "owner.json"), lockBody, "utf-8");
+      return true;
+    } catch {
+      try {
+        if (existsSync6(lockPath) && !lstatSync(lockPath).isDirectory()) {
+          rmSync3(lockPath, { force: true });
+        }
+      } catch {}
+      return false;
+    }
+  };
+  if (tryExclusiveCreate()) {
+    return true;
+  }
+  if (existsSync6(lockPath)) {
+    const data = readRuntimeImageLockData(lockPath);
+    if (data) {
+      const age = Date.now() - data.timestamp;
+      if (age < LOCK_STALE_MS) {
+        return false;
+      }
+      if (isPidAlive(data.pid)) {
+        return false;
+      }
+    }
+    rmSync3(lockPath, { recursive: true, force: true });
+  }
+  return tryExclusiveCreate();
+}
+function releaseRuntimeImageLock(lockPath) {
+  try {
+    rmSync3(lockPath, { recursive: true, force: true });
+  } catch {}
+}
+async function waitForRuntimeImageManifest(manifestPath, timeoutMs, pollMs = 500) {
+  const deadline = Date.now() + timeoutMs;
+  while (!existsSync6(manifestPath) && Date.now() < deadline) {
+    await Bun.sleep(pollMs);
+  }
+  return existsSync6(manifestPath);
+}
+var SHARED_HOOK_NAMES = [
+  "scope-guard",
+  "import-guard",
+  "safety-guard",
+  "test-integrity-guard",
+  "audit-trail",
+  "post-edit-lint",
+  "completion-verification",
+  "inject-context",
+  "task-runtime-start"
+];
+function discoverValidators(projectRoot) {
+  const validatorsRoot = resolve11(projectRoot, "packages/runtime/src/control-plane/validators");
+  const entries = [];
+  if (!existsSync6(validatorsRoot)) {
+    return entries;
+  }
+  const categories = readdirSync2(validatorsRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  for (const category of categories) {
+    const categoryDir = resolve11(validatorsRoot, category);
+    const files = readdirSync2(categoryDir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".ts")).map((e) => e.name).sort();
+    for (const file of files) {
+      const check = file.replace(/\.ts$/, "");
+      if (!/^[a-z][\w-]*$/.test(check)) {
+        continue;
+      }
+      entries.push({
+        category,
+        check,
+        sourcePath: `packages/runtime/src/control-plane/validators/${category}/${check}.ts`
+      });
+    }
+  }
+  return entries;
+}
+function discoverPlugins(projectRoot) {
+  const pluginsRoot = resolve11(projectRoot, "rig/plugins");
+  if (!existsSync6(pluginsRoot)) {
+    return [];
+  }
+  return readdirSync2(pluginsRoot, { withFileTypes: true }).filter((entry) => entry.isFile() && /\.plugin\.(ts|js|mjs|cjs)$/.test(entry.name)).map((entry) => {
+    const name = entry.name.replace(/\.plugin\.(ts|js|mjs|cjs)$/, "");
+    return {
+      name,
+      sourcePath: `rig/plugins/${entry.name}`
+    };
+  }).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+}
+async function provisionDependencyLayer(projectRoot, tempDepsDir) {
+  const config = loadRuntimeImageConfig(projectRoot);
+  if (!config.deps.monorepo_install && !config.deps.hp_next_install)
+    return;
+  const linkNodeModules = (sourceNodeModules, targetNodeModules) => {
+    if (existsSync6(targetNodeModules)) {
+      return;
+    }
+    try {
+      symlinkSync(sourceNodeModules, targetNodeModules);
+    } catch {
+      cpSync2(sourceNodeModules, targetNodeModules, {
+        recursive: true,
+        force: true,
+        dereference: true
+      });
+    }
+  };
+  const ensureInstall = async (cwd, label) => {
+    const bunCli = resolveBunBinaryPath();
+    const install = Bun.spawn([bunCli, "install"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: runtimeProvisioningEnv()
+    });
+    const [exitCode, stdout, stderr] = await Promise.all([
+      install.exited,
+      new Response(install.stdout).text(),
+      new Response(install.stderr).text()
+    ]);
+    if (exitCode !== 0) {
+      throw new Error([
+        `Failed to install shared runtime dependencies for ${label}.`,
+        `cwd: ${cwd}`,
+        stderr.trim() || stdout.trim()
+      ].filter(Boolean).join(`
+`));
+    }
+  };
+  if (config.deps.monorepo_install) {
+    const monorepoSubRel = process.env.RIG_MONOREPO_INSTALL_PATH?.trim() || "repos/spliter-monorepo/humoongate";
+    const monorepoSubRoot = resolve11(projectRoot, monorepoSubRel);
+    const monorepoSubPackage = resolve11(monorepoSubRoot, "package.json");
+    if (existsSync6(monorepoSubPackage)) {
+      const sourceNodeModules = resolve11(monorepoSubRoot, "node_modules");
+      try {
+        if (lstatSync(sourceNodeModules).isSymbolicLink() && !existsSync6(sourceNodeModules)) {
+          unlinkSync(sourceNodeModules);
+        }
+      } catch {}
+      if (!existsSync6(sourceNodeModules)) {
+        await ensureInstall(monorepoSubRoot, "monorepo");
+      }
+      const targetRoot = resolve11(tempDepsDir, "humoongate");
+      const targetNodeModules = resolve11(targetRoot, "node_modules");
+      mkdirSync3(targetRoot, { recursive: true });
+      linkNodeModules(sourceNodeModules, targetNodeModules);
+      for (const fileName of ["package.json", "bun.lockb"]) {
+        const source = resolve11(monorepoSubRoot, fileName);
+        if (existsSync6(source)) {
+          cpSync2(source, resolve11(targetRoot, fileName), { force: true });
+        }
+      }
+    }
+  }
+  if (config.deps.hp_next_install) {
+    const monorepoRel = process.env.RIG_HP_NEXT_MONOREPO_PATH?.trim() || "repos/spliter-monorepo";
+    const appRel = process.env.RIG_HP_NEXT_APP_PATH?.trim() || "microservices/hp-next-frontend/app";
+    const monorepoRoot = resolve11(projectRoot, monorepoRel);
+    const hpNextRoot = resolve11(monorepoRoot, appRel);
+    const hpNextPackage = resolve11(hpNextRoot, "package.json");
+    if (existsSync6(hpNextPackage)) {
+      const rootNodeModules = resolve11(monorepoRoot, "node_modules");
+      const hpNextNodeModules = resolve11(hpNextRoot, "node_modules");
+      if (!existsSync6(rootNodeModules) && !existsSync6(hpNextNodeModules)) {
+        await ensureInstall(monorepoRoot, "spliter-monorepo hp-next workspace");
+      }
+      const targetRoot = resolve11(tempDepsDir, "microservices", "hp-next-frontend", "app");
+      mkdirSync3(targetRoot, { recursive: true });
+      if (existsSync6(rootNodeModules)) {
+        linkNodeModules(rootNodeModules, resolve11(targetRoot, "root-node_modules"));
+      }
+      if (existsSync6(hpNextNodeModules)) {
+        linkNodeModules(hpNextNodeModules, resolve11(targetRoot, "node_modules"));
+      }
+      for (const fileName of ["package.json", "bun.lock", "bun.lockb", "package-lock.json"]) {
+        const source = resolve11(hpNextRoot, fileName);
+        if (existsSync6(source)) {
+          cpSync2(source, resolve11(targetRoot, fileName), { force: true });
+        }
+      }
+      for (const fileName of ["package.json", "bun.lock", "bun.lockb", "package-lock.json"]) {
+        const source = resolve11(monorepoRoot, fileName);
+        if (existsSync6(source)) {
+          cpSync2(source, resolve11(targetRoot, `workspace-${fileName}`), { force: true });
+        }
+      }
+    }
+  }
+}
+function imageFromDir(rootDir, fingerprint, id) {
+  return {
+    id,
+    rootDir,
+    binDir: resolve11(rootDir, "bin"),
+    hooksDir: resolve11(rootDir, "bin/hooks"),
+    pluginsDir: resolve11(rootDir, "bin/plugins"),
+    validatorsDir: resolve11(rootDir, "bin/validators"),
+    depsDir: resolve11(rootDir, "deps"),
+    manifestPath: resolve11(rootDir, "image-manifest.json"),
+    fingerprint
+  };
+}
+function cleanupImageBuildDirs(rootDir, currentBuildDir) {
+  const imagesRootDir = resolve11(rootDir, "..");
+  const buildPrefix = `${rootDir}.building-`;
+  try {
+    for (const entry of readdirSync2(imagesRootDir)) {
+      const fullPath = resolve11(imagesRootDir, entry);
+      if (fullPath.startsWith(buildPrefix) && fullPath !== currentBuildDir) {
+        rmSync3(fullPath, { recursive: true, force: true });
+      }
+    }
+  } catch {}
+}
+async function buildImage(projectRoot, image) {
+  const { rootDir } = image;
+  const bunPath = resolveBunBinaryPath();
+  const buildDir = `${rootDir}.building-${process.pid}`;
+  cleanupImageBuildDirs(rootDir, buildDir);
+  if (existsSync6(buildDir)) {
+    rmSync3(buildDir, { recursive: true, force: true });
+  }
+  let promoted = false;
+  try {
+    const tempBinDir = resolve11(buildDir, "bin");
+    const tempHooksDir = resolve11(buildDir, "bin/hooks");
+    const tempPluginsDir = resolve11(buildDir, "bin/plugins");
+    const tempValidatorsDir = resolve11(buildDir, "bin/validators");
+    const tempDepsDir = resolve11(buildDir, "deps");
+    mkdirSync3(tempBinDir, { recursive: true });
+    mkdirSync3(tempHooksDir, { recursive: true });
+    mkdirSync3(tempPluginsDir, { recursive: true });
+    mkdirSync3(tempValidatorsDir, { recursive: true });
+    mkdirSync3(tempDepsDir, { recursive: true });
+    const nativeRuntimeLibraryPath = await materializeNativeRuntimeLibrary(tempBinDir);
+    if (!nativeRuntimeLibraryPath) {
+      throw new Error("Failed to provision the native Zig runtime library for runtime images.");
+    }
+    await buildBinary("packages/cli/bin/rig.ts", resolve11(tempBinDir, "rig"), projectRoot);
+    await buildBinary("packages/runtime/bin/rig-agent.ts", resolve11(tempBinDir, "rig-agent"), projectRoot);
+    await buildBinary("packages/runtime/src/control-plane/controlled-bash.ts", resolve11(tempBinDir, "controlled-bash"), projectRoot);
+    for (const hookName of SHARED_HOOK_NAMES) {
+      await buildBinary(`packages/runtime/src/control-plane/hooks/${hookName}.ts`, resolve11(tempHooksDir, hookName), projectRoot);
+    }
+    const plugins = discoverPlugins(projectRoot);
+    for (const plugin of plugins) {
+      if (existsSync6(resolve11(projectRoot, plugin.sourcePath))) {
+        await buildBinary(plugin.sourcePath, resolve11(tempPluginsDir, plugin.name), projectRoot);
+      }
+    }
+    const validators = discoverValidators(projectRoot);
+    for (const { category, check, sourcePath } of validators) {
+      if (!existsSync6(resolve11(projectRoot, sourcePath))) {
+        continue;
+      }
+      await buildBinary(sourcePath, resolve11(tempValidatorsDir, `${category}-${check}`), projectRoot, {
+        AGENT_BUN_PATH: bunPath
+      });
+    }
+    await provisionDependencyLayer(projectRoot, tempDepsDir);
+    const manifest = {
+      id: image.id,
+      fingerprint: image.fingerprint,
+      builtAt: new Date().toISOString(),
+      pid: process.pid
+    };
+    writeFileSync2(resolve11(buildDir, "image-manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
+    if (existsSync6(rootDir)) {
+      return;
+    }
+    try {
+      renameSync3(buildDir, rootDir);
+      promoted = true;
+    } catch {
+      if (existsSync6(rootDir)) {
+        return;
+      }
+      throw new Error(`Failed to promote runtime image build directory: ${buildDir} -> ${rootDir}`);
+    }
+  } finally {
+    if (!promoted && existsSync6(buildDir)) {
+      rmSync3(buildDir, { recursive: true, force: true });
+    }
+  }
+}
+function isRuntimeImageHealthy(projectRoot, image) {
+  if (!existsSync6(image.manifestPath)) {
+    return false;
+  }
+  const requiredPaths = [
+    resolve11(image.binDir, "rig"),
+    resolve11(image.binDir, "rig-agent"),
+    resolve11(image.binDir, "controlled-bash"),
+    ...SHARED_HOOK_NAMES.map((hookName) => resolve11(image.hooksDir, hookName)),
+    ...discoverPlugins(projectRoot).map((plugin) => resolve11(image.pluginsDir, plugin.name)),
+    ...discoverValidators(projectRoot).map(({ category, check }) => resolve11(image.validatorsDir, `${category}-${check}`))
+  ];
+  return requiredPaths.every((path) => existsSync6(path));
+}
+function computeRuntimeImageIdFromFingerprint(fp) {
+  return computeRuntimeImageId(fp);
+}
+async function ensureRuntimeImage(projectRoot) {
+  const fingerprint = await computeRuntimeImageFingerprint(projectRoot);
+  const id = computeRuntimeImageId(fingerprint);
+  const layout = resolveRigLayout(projectRoot);
+  const imagesRoot = resolve11(layout.runtimeDir, "images");
+  mkdirSync3(imagesRoot, { recursive: true });
+  const imageRootDir = resolve11(imagesRoot, id);
+  const image = imageFromDir(imageRootDir, fingerprint, id);
+  if (isRuntimeImageHealthy(projectRoot, image)) {
+    return image;
+  }
+  const lockPath = resolve11(imagesRoot, `${id}.lock`);
+  const acquired = acquireRuntimeImageLock(lockPath);
+  try {
+    if (isRuntimeImageHealthy(projectRoot, image)) {
+      return image;
+    }
+    if (!acquired) {
+      const ready = await waitForRuntimeImageManifest(image.manifestPath, LOCK_STALE_MS);
+      if (!ready || !isRuntimeImageHealthy(projectRoot, image)) {
+        throw new Error(`Runtime image ${id} is being built by another process and is not healthy after waiting. ` + `Lock file: ${lockPath}`);
+      }
+      return image;
+    }
+    if (existsSync6(image.rootDir)) {
+      rmSync3(image.rootDir, { recursive: true, force: true });
+    }
+    await buildImage(projectRoot, image);
+    return image;
+  } finally {
+    if (acquired) {
+      releaseRuntimeImageLock(lockPath);
+    }
+  }
+}
+export {
+  waitForRuntimeImageManifest,
+  releaseRuntimeImageLock,
+  ensureRuntimeImage,
+  computeRuntimeImageIdFromFingerprint,
+  computeRuntimeImageId,
+  computeRuntimeImageFingerprintNative,
+  computeRuntimeImageFingerprint,
+  acquireRuntimeImageLock
+};