@h-rig/runtime 0.0.6-alpha.0

package/dist/src/control-plane/runtime/isolation/home.js

@@ -0,0 +1,1217 @@
+// @bun
+// packages/runtime/src/control-plane/runtime/isolation/home.ts
+import {
+  chmodSync,
+  copyFileSync as copyFileSync2,
+  cpSync,
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync3,
+  statSync as statSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { mkdir } from "fs/promises";
+import { basename as basename2, delimiter, resolve as resolve7 } from "path";
+
+// packages/runtime/src/control-plane/runtime/runtime-paths.ts
+import { existsSync as existsSync2, readdirSync, realpathSync } from "fs";
+import { resolve as resolve2 } from "path";
+
+// 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;
+}
+
+// packages/runtime/src/control-plane/runtime/sandbox/utils.ts
+function uniq(values) {
+  return [...new Set(values)];
+}
+// 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 ? resolve2(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 ? resolve2(home, ".local/bin/claude") : "",
+    home ? resolve2(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 resolve2(bunBinaryPath, "../..");
+}
+function resolveClaudeInstallDir() {
+  const realPath = resolveClaudeBinaryPath();
+  return resolve2(realPath, "..");
+}
+function resolveNodeInstallDir() {
+  const preferredNode = resolvePreferredNodeBinary();
+  if (!preferredNode)
+    return null;
+  const explicitNode = process.env.RIG_NODE_BIN?.trim();
+  if (explicitNode && resolve2(explicitNode) === resolve2(preferredNode)) {
+    return preferredNode.endsWith("/bin/node") ? resolve2(preferredNode, "../..") : resolve2(preferredNode, "..");
+  }
+  try {
+    const realPath = realpathSync(preferredNode);
+    if (realPath.endsWith("/bin/node")) {
+      return resolve2(realPath, "../..");
+    }
+    return resolve2(realPath, "..");
+  } catch {
+    return resolve2(preferredNode, "..");
+  }
+}
+function resolvePreferredNodeBinary() {
+  const candidates = [];
+  const envNode = process.env.RIG_NODE_BIN?.trim();
+  if (envNode) {
+    const explicit = resolve2(envNode);
+    if (existsSync2(explicit)) {
+      return explicit;
+    }
+  }
+  const nvmBin = process.env.NVM_BIN?.trim();
+  if (nvmBin) {
+    candidates.push(resolve2(nvmBin, "node"));
+  }
+  const home = process.env.HOME?.trim();
+  if (home) {
+    const nvmVersionsDir = resolve2(home, ".nvm/versions/node");
+    if (existsSync2(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(resolve2(nvmVersionsDir, versionDir, "bin/node"));
+        }
+      } catch {}
+    }
+  }
+  const whichNode = Bun.which("node");
+  if (whichNode) {
+    candidates.push(whichNode);
+  }
+  const deduped = uniq(candidates.map((candidate) => resolve2(candidate)));
+  const existing = deduped.filter((candidate) => existsSync2(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 = resolve2(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 = resolve2(candidate);
+  if (!existsSync2(normalized)) {
+    return "";
+  }
+  try {
+    return realpathSync(normalized);
+  } catch {
+    return normalized;
+  }
+}
+function looksLikeRuntimeGateway(candidate) {
+  const normalized = resolve2(candidate).replace(/\\/g, "/");
+  return normalized.includes("/.rig/bin/") || normalized.endsWith("/rig-shell") || normalized.endsWith("/rig-agent");
+}
+
+// packages/runtime/src/control-plane/runtime/baked-secrets.ts
+var BAKED_RUNTIME_SECRETS = {
+  ANTHROPIC_API_KEY: typeof RIG_BAKED_ANTHROPIC_API_KEY !== "undefined" ? RIG_BAKED_ANTHROPIC_API_KEY : "",
+  OPENAI_API_KEY: typeof RIG_BAKED_OPENAI_API_KEY !== "undefined" ? RIG_BAKED_OPENAI_API_KEY : "",
+  OPENROUTER_API_KEY: typeof RIG_BAKED_OPENROUTER_API_KEY !== "undefined" ? RIG_BAKED_OPENROUTER_API_KEY : "",
+  AI_REVIEW_MODE: typeof RIG_BAKED_AI_REVIEW_MODE !== "undefined" ? RIG_BAKED_AI_REVIEW_MODE : "",
+  AI_REVIEW_PROVIDER: typeof RIG_BAKED_AI_REVIEW_PROVIDER !== "undefined" ? RIG_BAKED_AI_REVIEW_PROVIDER : "",
+  GREPTILE_API_BASE: typeof RIG_BAKED_GREPTILE_API_BASE !== "undefined" ? RIG_BAKED_GREPTILE_API_BASE : "",
+  GREPTILE_REMOTE: typeof RIG_BAKED_GREPTILE_REMOTE !== "undefined" ? RIG_BAKED_GREPTILE_REMOTE : "",
+  GREPTILE_REPOSITORY: typeof RIG_BAKED_GREPTILE_REPOSITORY !== "undefined" ? RIG_BAKED_GREPTILE_REPOSITORY : "",
+  GREPTILE_CONTEXT_BRANCH: typeof RIG_BAKED_GREPTILE_CONTEXT_BRANCH !== "undefined" ? RIG_BAKED_GREPTILE_CONTEXT_BRANCH : "",
+  GREPTILE_DEFAULT_BRANCH: typeof RIG_BAKED_GREPTILE_DEFAULT_BRANCH !== "undefined" ? RIG_BAKED_GREPTILE_DEFAULT_BRANCH : "",
+  GREPTILE_API_KEY: typeof RIG_BAKED_GREPTILE_API_KEY !== "undefined" ? RIG_BAKED_GREPTILE_API_KEY : "",
+  GREPTILE_GITHUB_TOKEN: typeof RIG_BAKED_GREPTILE_GITHUB_TOKEN !== "undefined" ? RIG_BAKED_GREPTILE_GITHUB_TOKEN : "",
+  GREPTILE_POLL_ATTEMPTS: typeof RIG_BAKED_GREPTILE_POLL_ATTEMPTS !== "undefined" ? RIG_BAKED_GREPTILE_POLL_ATTEMPTS : "",
+  GREPTILE_POLL_INTERVAL_MS: typeof RIG_BAKED_GREPTILE_POLL_INTERVAL_MS !== "undefined" ? RIG_BAKED_GREPTILE_POLL_INTERVAL_MS : "",
+  GH_TOKEN: typeof RIG_BAKED_GITHUB_TOKEN !== "undefined" ? RIG_BAKED_GITHUB_TOKEN : "",
+  GITHUB_TOKEN: typeof RIG_BAKED_GITHUB_TOKEN !== "undefined" ? RIG_BAKED_GITHUB_TOKEN : "",
+  GITHUB_SSH_KEY: typeof RIG_BAKED_GITHUB_SSH_KEY !== "undefined" ? RIG_BAKED_GITHUB_SSH_KEY : "",
+  AWS_ACCESS_KEY_ID: typeof RIG_BAKED_AWS_ACCESS_KEY_ID !== "undefined" ? RIG_BAKED_AWS_ACCESS_KEY_ID : "",
+  AWS_SECRET_ACCESS_KEY: typeof RIG_BAKED_AWS_SECRET_ACCESS_KEY !== "undefined" ? RIG_BAKED_AWS_SECRET_ACCESS_KEY : "",
+  AWS_REGION: typeof RIG_BAKED_AWS_REGION !== "undefined" ? RIG_BAKED_AWS_REGION : "",
+  LINEAR_API_KEY: typeof RIG_BAKED_LINEAR_API_KEY !== "undefined" ? RIG_BAKED_LINEAR_API_KEY : "",
+  LINEAR_WEBHOOK_SECRET: typeof RIG_BAKED_LINEAR_WEBHOOK_SECRET !== "undefined" ? RIG_BAKED_LINEAR_WEBHOOK_SECRET : ""
+};
+function resolveRuntimeSecrets(env, baked = BAKED_RUNTIME_SECRETS) {
+  const resolved = {};
+  const keys = new Set([
+    ...Object.keys(BAKED_RUNTIME_SECRETS),
+    ...Object.keys(baked)
+  ]);
+  for (const key of keys) {
+    const envValue = env[key]?.trim();
+    const bakedValue = baked[key]?.trim();
+    if (envValue) {
+      resolved[key] = envValue;
+    } else if (bakedValue) {
+      resolved[key] = bakedValue;
+    }
+  }
+  return resolved;
+}
+
+// packages/runtime/src/control-plane/native/git-native.ts
+import { tmpdir } from "os";
+import { dirname as dirname2, isAbsolute, resolve as resolve3 } from "path";
+var sharedGitNativeOutputDir = resolve3(tmpdir(), "rig-native");
+var sharedGitNativeOutputPath = resolve3(sharedGitNativeOutputDir, `rig-git-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`);
+function runtimeRigGitFileName() {
+  return `rig-git${process.platform === "win32" ? ".exe" : ""}`;
+}
+
+// packages/runtime/src/control-plane/native/runtime-native.ts
+import { dlopen, ptr, suffix, toBuffer } from "bun:ffi";
+import { copyFileSync, existsSync as existsSync3, mkdirSync, renameSync, rmSync, statSync } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { dirname as dirname3, resolve as resolve4 } from "path";
+var sharedNativeRuntimeOutputDir = resolve4(tmpdir2(), "rig-native");
+var sharedNativeRuntimeOutputPath = resolve4(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 && existsSync3(outputPath) ? outputPath : null;
+}
+async function materializeNativeRuntimeLibrary(targetDir) {
+  const sourcePath = await ensureNativeRuntimeLibraryPath();
+  if (!sourcePath) {
+    return null;
+  }
+  const targetPath = resolve4(targetDir, colocatedNativeRuntimeFileName);
+  mkdirSync(targetDir, { recursive: true });
+  const needsCopy = !existsSync3(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 || !existsSync3(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 = resolve4(fromDir);
+  for (let index = 0;index < 8; index += 1) {
+    for (const name of names) {
+      candidates.push(resolve4(cursor, "native", `${process.platform}-${process.arch}`, name), resolve4(cursor, "native", `${process.platform}-${process.arch}`, "lib", name), resolve4(cursor, "native", name), resolve4(cursor, "native", "lib", name));
+    }
+    const parent = dirname3(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() ? dirname3(process.execPath.trim()) : "";
+  const platformSpecific = `runtime-native-${process.platform}-${process.arch}.${suffix}`;
+  return [...new Set([
+    explicit,
+    ...nativePackageLibraryCandidates(import.meta.dir, [colocatedNativeRuntimeFileName, platformSpecific]),
+    execDir ? resolve4(execDir, colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve4(execDir, platformSpecific) : "",
+    execDir ? resolve4(execDir, "..", colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve4(execDir, "..", platformSpecific) : "",
+    execDir ? resolve4(execDir, "lib", colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve4(execDir, "..", "lib", colocatedNativeRuntimeFileName) : "",
+    sharedNativeRuntimeOutputPath
+  ].filter(Boolean))];
+}
+function resolveNativeRuntimeSourcePath() {
+  const explicit = process.env.RIG_NATIVE_RUNTIME_SOURCE?.trim();
+  if (explicit && existsSync3(explicit)) {
+    return explicit;
+  }
+  const bundled = resolve4(import.meta.dir, "../../../native/snapshot.zig");
+  return existsSync3(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(dirname3(outputPath), { recursive: true });
+    const needsBuild = options.force === true || !existsSync3(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 || !existsSync3(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/browser-contract.ts
+function browserEnvFromContext(browser) {
+  if (!browser?.required) {
+    return {};
+  }
+  const env = {
+    RIG_BROWSER_REQUIRED: "1",
+    RIG_BROWSER_PRESET: browser.preset,
+    RIG_BROWSER_MODE: browser.mode,
+    RIG_BROWSER_STATE_DIR: browser.stateDir,
+    RIG_BROWSER_PROFILE: browser.effectiveProfile,
+    RIG_BROWSER_BASE_PROFILE: browser.defaultProfile,
+    RIG_BROWSER_ATTACH_URL: browser.effectiveAttachUrl,
+    RIG_BROWSER_DEFAULT_ATTACH_URL: browser.defaultAttachUrl,
+    RIG_BROWSER_LAUNCH_HELPER: browser.launchHelper,
+    RIG_BROWSER_CHECK_HELPER: browser.checkHelper,
+    RIG_BROWSER_ATTACH_INFO_HELPER: browser.attachInfoHelper,
+    RIG_BROWSER_E2E_HELPER: browser.e2eHelper,
+    RIG_BROWSER_RESET_HELPER: browser.resetProfileHelper
+  };
+  if (browser.devCommand) {
+    env.RIG_BROWSER_DEV_COMMAND = browser.devCommand;
+  }
+  if (browser.launchCommand) {
+    env.RIG_BROWSER_LAUNCH_COMMAND = browser.launchCommand;
+  }
+  if (browser.checkCommand) {
+    env.RIG_BROWSER_CHECK_COMMAND = browser.checkCommand;
+  }
+  if (browser.e2eCommand) {
+    env.RIG_BROWSER_E2E_COMMAND = browser.e2eCommand;
+  }
+  return env;
+}
+
+// packages/runtime/src/control-plane/runtime/context.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "fs";
+import { dirname as dirname4, resolve as resolve5 } from "path";
+var RUNTIME_CONTEXT_ENV = "RIG_RUNTIME_CONTEXT_FILE";
+var runtimeContextStringFields = [
+  "runtimeId",
+  "taskId",
+  "role",
+  "workspaceDir",
+  "stateDir",
+  "logsDir",
+  "sessionDir",
+  "sessionFile",
+  "policyFile",
+  "binDir",
+  "createdAt"
+];
+var runtimeContextArrayFields = ["scopes", "validation"];
+var runtimeContextOptionalStringFields = [
+  "artifactRoot",
+  "hostProjectRoot",
+  "monorepoMainRoot",
+  "monorepoBaseRef",
+  "monorepoBaseCommit"
+];
+function loadRuntimeContext(path) {
+  const absPath = resolve5(path);
+  if (!existsSync4(absPath)) {
+    throw new Error(`RuntimeTaskContext file not found: ${absPath}`);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(absPath, "utf8"));
+  } catch (err) {
+    throw new Error(`Failed to parse RuntimeTaskContext at ${absPath}: ${String(err)}`);
+  }
+  if (typeof raw !== "object" || raw === null) {
+    throw new Error(`RuntimeTaskContext at ${absPath} is not an object`);
+  }
+  const obj = raw;
+  for (const field of runtimeContextStringFields) {
+    if (typeof obj[field] !== "string" || obj[field].length === 0) {
+      throw new Error(`RuntimeTaskContext field "${field}" must be a non-empty string (at ${absPath})`);
+    }
+  }
+  for (const field of runtimeContextArrayFields) {
+    if (!Array.isArray(obj[field])) {
+      throw new Error(`RuntimeTaskContext field "${field}" must be an array (at ${absPath})`);
+    }
+    if (!obj[field].every((entry) => typeof entry === "string")) {
+      throw new Error(`RuntimeTaskContext field "${field}" must be a string[] (at ${absPath})`);
+    }
+  }
+  for (const field of runtimeContextOptionalStringFields) {
+    if (field in obj && obj[field] !== undefined && typeof obj[field] !== "string") {
+      throw new Error(`RuntimeTaskContext field "${field}" must be a string when present (at ${absPath})`);
+    }
+  }
+  if (obj.browser !== undefined) {
+    if (typeof obj.browser !== "object" || obj.browser === null || Array.isArray(obj.browser)) {
+      throw new Error(`RuntimeTaskContext field "browser" must be an object when present (at ${absPath})`);
+    }
+    const browser = obj.browser;
+    for (const field of [
+      "preset",
+      "mode",
+      "stateDir",
+      "defaultProfile",
+      "effectiveProfile",
+      "defaultAttachUrl",
+      "effectiveAttachUrl",
+      "launchHelper",
+      "checkHelper",
+      "attachInfoHelper",
+      "e2eHelper",
+      "resetProfileHelper"
+    ]) {
+      if (typeof browser[field] !== "string" || browser[field].length === 0) {
+        throw new Error(`RuntimeTaskContext field "browser.${field}" must be a non-empty string (at ${absPath})`);
+      }
+    }
+    for (const field of ["devCommand", "launchCommand", "checkCommand", "e2eCommand"]) {
+      if (browser[field] !== undefined && typeof browser[field] !== "string") {
+        throw new Error(`RuntimeTaskContext field "browser.${field}" must be a string when present (at ${absPath})`);
+      }
+    }
+    if (typeof browser.required !== "boolean") {
+      throw new Error(`RuntimeTaskContext field "browser.required" must be a boolean (at ${absPath})`);
+    }
+  }
+  if (obj.memory !== undefined) {
+    if (typeof obj.memory !== "object" || obj.memory === null || Array.isArray(obj.memory)) {
+      throw new Error(`RuntimeTaskContext field "memory" must be an object when present (at ${absPath})`);
+    }
+    const memory = obj.memory;
+    for (const field of ["canonicalPath", "canonicalRef", "canonicalBaseOid", "hydratedPath"]) {
+      if (typeof memory[field] !== "string" || memory[field].length === 0) {
+        throw new Error(`RuntimeTaskContext field "memory.${field}" must be a non-empty string (at ${absPath})`);
+      }
+    }
+    if (typeof memory.createdFresh !== "boolean") {
+      throw new Error(`RuntimeTaskContext field "memory.createdFresh" must be a boolean (at ${absPath})`);
+    }
+    if (typeof memory.retrieval !== "object" || memory.retrieval === null || Array.isArray(memory.retrieval)) {
+      throw new Error(`RuntimeTaskContext field "memory.retrieval" must be an object (at ${absPath})`);
+    }
+    const retrieval = memory.retrieval;
+    for (const field of ["topK", "lexicalWeight", "vectorWeight", "recencyWeight", "confidenceWeight"]) {
+      if (typeof retrieval[field] !== "number" || Number.isNaN(retrieval[field])) {
+        throw new Error(`RuntimeTaskContext field "memory.retrieval.${field}" must be a number (at ${absPath})`);
+      }
+    }
+  }
+  if (obj.initialDirtyFiles !== undefined) {
+    if (typeof obj.initialDirtyFiles !== "object" || obj.initialDirtyFiles === null || Array.isArray(obj.initialDirtyFiles)) {
+      throw new Error(`RuntimeTaskContext field "initialDirtyFiles" must be an object when present (at ${absPath})`);
+    }
+    const dirtyFiles = obj.initialDirtyFiles;
+    for (const key of ["project", "monorepo"]) {
+      if (dirtyFiles[key] === undefined) {
+        continue;
+      }
+      if (!Array.isArray(dirtyFiles[key]) || !dirtyFiles[key].every((entry) => typeof entry === "string")) {
+        throw new Error(`RuntimeTaskContext field "initialDirtyFiles.${key}" must be a string[] when present (at ${absPath})`);
+      }
+    }
+  }
+  if (obj.initialHeadCommits !== undefined) {
+    if (typeof obj.initialHeadCommits !== "object" || obj.initialHeadCommits === null || Array.isArray(obj.initialHeadCommits)) {
+      throw new Error(`RuntimeTaskContext field "initialHeadCommits" must be an object when present (at ${absPath})`);
+    }
+    const headCommits = obj.initialHeadCommits;
+    for (const key of ["project", "monorepo"]) {
+      if (headCommits[key] === undefined) {
+        continue;
+      }
+      if (typeof headCommits[key] !== "string") {
+        throw new Error(`RuntimeTaskContext field "initialHeadCommits.${key}" must be a string when present (at ${absPath})`);
+      }
+    }
+  }
+  return obj;
+}
+function runtimeMemoryEnvFromContext(ctx) {
+  if (!ctx?.memory) {
+    return {};
+  }
+  return {
+    RIG_MEMORY_DB_PATH: ctx.memory.hydratedPath,
+    RIG_MEMORY_CANONICAL_PATH: ctx.memory.canonicalPath,
+    RIG_MEMORY_CANONICAL_REF: ctx.memory.canonicalRef,
+    RIG_MEMORY_CANONICAL_BASE_OID: ctx.memory.canonicalBaseOid,
+    RIG_MEMORY_CREATED_FRESH: ctx.memory.createdFresh ? "1" : "0",
+    RIG_MEMORY_RETRIEVAL_TOP_K: String(ctx.memory.retrieval.topK),
+    RIG_MEMORY_RETRIEVAL_LEXICAL_WEIGHT: String(ctx.memory.retrieval.lexicalWeight),
+    RIG_MEMORY_RETRIEVAL_VECTOR_WEIGHT: String(ctx.memory.retrieval.vectorWeight),
+    RIG_MEMORY_RETRIEVAL_RECENCY_WEIGHT: String(ctx.memory.retrieval.recencyWeight),
+    RIG_MEMORY_RETRIEVAL_CONFIDENCE_WEIGHT: String(ctx.memory.retrieval.confidenceWeight)
+  };
+}
+
+// packages/runtime/src/control-plane/runtime/isolation/shared.ts
+import { existsSync as existsSync5, readFileSync as readFileSync2, rmSync as rmSync2 } from "fs";
+import { resolve as resolve6 } from "path";
+
+// packages/runtime/src/control-plane/native/utils.ts
+function resolveMonorepoRoot2(projectRoot) {
+  return resolveMonorepoRoot(projectRoot);
+}
+var scopeRegexCache = new Map;
+
+// packages/runtime/src/control-plane/runtime/isolation/shared.ts
+var generatedCredentialFiles = new Set;
+var credentialCleanupRegistered = false;
+function resolveMonorepoRoot3(projectRoot) {
+  return resolveMonorepoRoot2(projectRoot);
+}
+function sha256Hex(input) {
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(input);
+  return hasher.digest("hex");
+}
+function registerCredentialCleanup(path) {
+  generatedCredentialFiles.add(path);
+  if (credentialCleanupRegistered) {
+    return;
+  }
+  credentialCleanupRegistered = true;
+  const cleanup = () => {
+    for (const filePath of generatedCredentialFiles) {
+      try {
+        rmSync2(filePath, { force: true });
+      } catch {}
+    }
+    generatedCredentialFiles.clear();
+  };
+  process.on("exit", cleanup);
+  process.on("beforeExit", cleanup);
+}
+function hashProjectPath(workspaceDir) {
+  return sha256Hex(workspaceDir).slice(0, 16);
+}
+function resolveGithubCliBinaryPath() {
+  const explicit = process.env.RIG_GH_BIN?.trim();
+  if (explicit && existsSync5(explicit)) {
+    return explicit;
+  }
+  const bunResolved = Bun.which("gh");
+  if (bunResolved && existsSync5(bunResolved)) {
+    return bunResolved;
+  }
+  for (const candidate of ["/opt/homebrew/bin/gh", "/usr/local/bin/gh", "/usr/bin/gh"]) {
+    if (existsSync5(candidate)) {
+      return candidate;
+    }
+  }
+  return "";
+}
+async function resolveGithubCliAuthToken(ghBinary = "") {
+  const gh = ghBinary || resolveGithubCliBinaryPath();
+  if (!gh) {
+    return "";
+  }
+  const auth = Bun.spawn([gh, "auth", "token"], {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [exitCode, stdout] = await Promise.all([
+    auth.exited,
+    new Response(auth.stdout).text()
+  ]);
+  if (exitCode !== 0) {
+    return "";
+  }
+  return stdout.trim();
+}
+function resolveSystemCertBundlePath() {
+  const candidates = [
+    process.env.SSL_CERT_FILE?.trim(),
+    "/etc/ssl/cert.pem",
+    "/private/etc/ssl/cert.pem",
+    "/opt/homebrew/etc/openssl@3/cert.pem"
+  ];
+  for (const candidate of candidates) {
+    if (candidate && existsSync5(candidate)) {
+      return resolve6(candidate);
+    }
+  }
+  return "";
+}
+function readKnownHosts(path) {
+  if (!existsSync5(path)) {
+    return new Set;
+  }
+  return new Set(readFileSync2(path, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean));
+}
+
+// packages/runtime/src/control-plane/runtime/isolation/home.ts
+var GITHUB_SSH_KEY_PLACEHOLDER = "<base64 encoded>";
+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(`
+`);
+async function runtimeEnv(projectRoot, runtime) {
+  const bunBinaryPath = resolveBunBinaryPath();
+  const bunDir = resolveBunInstallDir(bunBinaryPath);
+  const claudeBinaryPath = process.env.RIG_CLAUDE_PATH?.trim() || (() => {
+    try {
+      return resolveClaudeBinaryPath();
+    } catch {
+      return "";
+    }
+  })();
+  const claudeDir = claudeBinaryPath ? (() => {
+    try {
+      return resolveClaudeInstallDir();
+    } catch {
+      return resolve7(claudeBinaryPath, "..");
+    }
+  })() : "";
+  const nodeDir = resolveNodeInstallDir();
+  const hostGhBinary = resolveGithubCliBinaryPath();
+  const runtimeCertBundlePath = await materializeRuntimeCertBundle(runtime);
+  const monorepoMainRoot = resolveMonorepoRoot3(projectRoot);
+  const realHome = process.env.HOME?.trim();
+  const inheritedPath = (process.env.PATH ?? "").split(delimiter).map((entry) => entry.trim()).filter(Boolean).filter((entry) => !entry.endsWith("/.rig/bin") && !entry.endsWith("/rig/tools"));
+  const pathEntries = [
+    runtime.binDir,
+    `${projectRoot}/rig/tools`,
+    `${bunDir}/bin`,
+    claudeDir,
+    nodeDir ? `${nodeDir}/bin` : "",
+    realHome ? resolve7(realHome, ".local/bin") : "",
+    realHome ? resolve7(realHome, ".cargo/bin") : "",
+    ...inheritedPath,
+    "/usr/local/bin",
+    "/usr/local/sbin",
+    "/opt/homebrew/bin",
+    "/opt/homebrew/sbin",
+    "/usr/bin",
+    "/bin",
+    "/usr/sbin",
+    "/sbin"
+  ].filter(Boolean);
+  const runtimeBash = resolve7(runtime.binDir, "bash");
+  const runtimeRigGit = resolve7(runtime.binDir, runtimeRigGitFileName());
+  const preferredShell = existsSync6(runtimeBash) ? runtimeBash : "/bin/bash";
+  const nativeRuntimeLibraryPath = await materializeNativeRuntimeLibrary(runtime.binDir);
+  const env = {
+    PROJECT_RIG_ROOT: projectRoot,
+    RIG_HOST_PROJECT_ROOT: projectRoot,
+    HOME: runtime.homeDir,
+    TMPDIR: runtime.tmpDir,
+    XDG_CACHE_HOME: runtime.cacheDir,
+    XDG_STATE_HOME: runtime.stateDir,
+    RIG_AGENT_ID: runtime.id,
+    RIG_TASK_ID: runtime.taskId,
+    RIG_TASK_RUNTIME_ID: runtime.id,
+    RIG_TASK_WORKSPACE: runtime.workspaceDir,
+    RIG_TASK_RUNTIME_MODE: runtime.mode,
+    RIG_RUNTIME_MODE: runtime.mode,
+    RIG_RUNTIME_HOME: runtime.rootDir,
+    RIG_RUNTIME_BIN_DIR: runtime.binDir,
+    ...existsSync6(runtimeRigGit) ? { RIG_NATIVE_GIT_BIN: runtimeRigGit } : {},
+    RIG_BUN_PATH: bunBinaryPath,
+    ...claudeBinaryPath ? { RIG_CLAUDE_PATH: claudeBinaryPath } : {},
+    RIG_AGENT_BIN: resolve7(runtime.binDir, "rig-agent"),
+    RIG_HOOKS_ACTIVE: "1",
+    RIG_AUTO_PR_ON_COMPLETE: "1",
+    RIG_POLICY_FILE: resolve7(projectRoot, "rig/policy/policy.json"),
+    RIG_STATE_DIR: runtime.stateDir,
+    RIG_LOGS_DIR: runtime.logsDir,
+    RIG_SESSION_FILE: resolve7(runtime.sessionDir, "session.json"),
+    MONOREPO_ROOT: runtime.workspaceDir,
+    MONOREPO_MAIN_ROOT: monorepoMainRoot,
+    TS_API_TESTS_DIR: resolve7(runtime.workspaceDir, "TSAPITests"),
+    BASH: preferredShell,
+    SHELL: preferredShell,
+    PATH: [...new Set(pathEntries)].join(delimiter),
+    LANG: process.env.LANG ?? "en_US.UTF-8",
+    TERM: process.env.TERM ?? "xterm-256color",
+    PYTHONDONTWRITEBYTECODE: "1",
+    PYTHONPYCACHEPREFIX: resolve7(runtime.cacheDir, "python"),
+    ...process.env.RIG_PR_BASE_PROJECT && { RIG_PR_BASE_PROJECT: process.env.RIG_PR_BASE_PROJECT },
+    ...process.env.RIG_PR_BASE_MONOREPO && { RIG_PR_BASE_MONOREPO: process.env.RIG_PR_BASE_MONOREPO },
+    CLAUDE_HOME: runtime.claudeHomeDir,
+    PI_CODING_AGENT_DIR: resolve7(runtime.homeDir, ".pi", "agent"),
+    [RUNTIME_CONTEXT_ENV]: runtime.contextFile,
+    ...nativeRuntimeLibraryPath ? { RIG_NATIVE_RUNTIME_LIB: nativeRuntimeLibraryPath } : {},
+    ...hostGhBinary ? { RIG_GH_BIN: hostGhBinary } : {},
+    ...runtimeCertBundlePath ? {
+      SSL_CERT_FILE: runtimeCertBundlePath,
+      CURL_CA_BUNDLE: runtimeCertBundlePath,
+      REQUESTS_CA_BUNDLE: runtimeCertBundlePath,
+      NODE_EXTRA_CA_CERTS: runtimeCertBundlePath
+    } : {}
+  };
+  const knownHostsPath = resolve7(runtime.homeDir, ".ssh", "known_hosts");
+  if (existsSync6(knownHostsPath)) {
+    const agentSshKey = resolve7(runtime.homeDir, ".ssh", "rig-agent-key");
+    const sshParts = [
+      "ssh",
+      `-o UserKnownHostsFile="${knownHostsPath}"`,
+      "-o StrictHostKeyChecking=yes",
+      "-F /dev/null"
+    ];
+    if (existsSync6(agentSshKey)) {
+      sshParts.splice(1, 0, `-i "${agentSshKey}"`, "-o IdentitiesOnly=yes");
+    }
+    env.GIT_SSH_COMMAND = sshParts.join(" ");
+  }
+  for (const [key, value] of Object.entries(resolveRuntimeSecrets(process.env))) {
+    if (key === "GITHUB_SSH_KEY") {
+      continue;
+    }
+    if (value) {
+      env[key] = value;
+    }
+  }
+  const fallbackGithubToken = !env.GITHUB_TOKEN && !env.GH_TOKEN ? await resolveGithubCliAuthToken(hostGhBinary) : "";
+  if (fallbackGithubToken) {
+    env.GITHUB_TOKEN = fallbackGithubToken;
+  }
+  if (!env.GITHUB_TOKEN && env.GH_TOKEN) {
+    env.GITHUB_TOKEN = env.GH_TOKEN;
+  }
+  if (!env.GH_TOKEN && env.GITHUB_TOKEN) {
+    env.GH_TOKEN = env.GITHUB_TOKEN;
+  }
+  if (!env.GREPTILE_GITHUB_TOKEN && env.GITHUB_TOKEN) {
+    env.GREPTILE_GITHUB_TOKEN = env.GITHUB_TOKEN;
+  }
+  if (existsSync6(runtime.contextFile)) {
+    const runtimeContext = loadRuntimeContext(runtime.contextFile);
+    Object.assign(env, runtimeMemoryEnvFromContext(runtimeContext));
+    Object.assign(env, browserEnvFromContext(runtimeContext.browser));
+  }
+  persistRuntimeSecrets(runtime.rootDir, env);
+  return env;
+}
+function runtimeCommandEnv(baseEnv, command) {
+  const env = { ...baseEnv };
+  delete env.ENV;
+  delete env.BASH_ENV;
+  const executable = command[0]?.trim() ?? "";
+  const shellName = basename2(executable);
+  const isPosixSh = executable === "/bin/sh" || shellName === "sh" || shellName === "dash";
+  if (isPosixSh) {
+    delete env.BASH;
+    if (executable) {
+      env.SHELL = executable;
+    }
+  }
+  return env;
+}
+async function provisionRuntimeHome(runtime, options = {}) {
+  await mkdir(runtime.homeDir, { recursive: true });
+  await mkdir(runtime.tmpDir, { recursive: true });
+  await mkdir(runtime.cacheDir, { recursive: true });
+  await provisionAgentSshKey(runtime.homeDir);
+  if (options.provider === "codex") {
+    const hasCodexAuth = await injectCodexAuth(resolve7(runtime.homeDir, ".codex"));
+    if (!hasCodexAuth) {
+      console.warn("[rig] No Codex auth.json found for isolated runtime. " + "Run `codex login` in your host shell, then retry the agent run.");
+    }
+  }
+  if (options.provider === "pi") {
+    const hasPiAuth = await injectPiAgentConfig(resolve7(runtime.homeDir, ".pi", "agent"));
+    if (!hasPiAuth) {
+      console.warn("[rig] No Pi auth.json found for isolated runtime. " + "Run `pi /login` in your host shell, then retry the agent run.");
+    }
+  }
+}
+async function provisionClaudeHome(config) {
+  mkdirSync3(config.claudeHomeDir, { recursive: true });
+  const workspaceSettings = resolve7(config.workspaceDir, ".claude/settings.json");
+  const hostSettings = resolve7(config.hostProjectRoot, ".claude/settings.json");
+  const projectSettings = existsSync6(workspaceSettings) ? workspaceSettings : hostSettings;
+  const runtimeSettings = await loadRuntimeClaudeSettings(projectSettings);
+  if (existsSync6(projectSettings)) {
+    writeFileSync2(resolve7(config.claudeHomeDir, "settings.local.json"), `${JSON.stringify(runtimeSettings, null, 2)}
+`, "utf-8");
+  }
+  writeClaudeProjectSettings(config.claudeHomeDir, config.workspaceDir, runtimeSettings);
+  writeFileSync2(resolve7(config.claudeHomeDir, "settings.json"), JSON.stringify({
+    permissions: { defaultMode: "bypassPermissions" },
+    autoMemoryEnabled: false
+  }, null, 2));
+  const hasCredentials = await injectClaudeCredentials(config.claudeHomeDir);
+  if (!hasCredentials) {
+    console.warn("[rig] No Claude credentials found for isolated runtime. " + "Run `claude /login` in your host shell, then retry the agent run.");
+  }
+  const realClaudeHome = resolve7(process.env.HOME ?? "", ".claude");
+  if (process.env.HOME && existsSync6(resolve7(realClaudeHome, "CLAUDE.md"))) {
+    cpSync(resolve7(realClaudeHome, "CLAUDE.md"), resolve7(config.claudeHomeDir, "CLAUDE.md"));
+  }
+  if (process.env.HOME && existsSync6(resolve7(realClaudeHome, "agents"))) {
+    cpSync(resolve7(realClaudeHome, "agents"), resolve7(config.claudeHomeDir, "agents"), { recursive: true });
+  }
+  if (process.platform === "darwin" && process.env.HOME) {
+    writeClaudeProjectSettings(realClaudeHome, config.workspaceDir, runtimeSettings);
+  }
+}
+async function materializeRuntimeCertBundle(runtime) {
+  const sourcePath = resolveSystemCertBundlePath();
+  if (!sourcePath) {
+    return "";
+  }
+  const certsDir = resolve7(runtime.rootDir, "certs");
+  const targetPath = resolve7(certsDir, "ca-certificates.pem");
+  await mkdir(certsDir, { recursive: true });
+  let shouldCopy = !existsSync6(targetPath);
+  if (!shouldCopy) {
+    try {
+      shouldCopy = statSync2(sourcePath).mtimeMs > statSync2(targetPath).mtimeMs;
+    } catch {
+      shouldCopy = true;
+    }
+  }
+  if (shouldCopy) {
+    copyFileSync2(sourcePath, targetPath);
+  }
+  return targetPath;
+}
+function persistRuntimeSecrets(runtimeRoot, env) {
+  const secretsPath = resolve7(runtimeRoot, "runtime-secrets.json");
+  const persisted = {};
+  for (const key of [
+    "GITHUB_TOKEN",
+    "GH_TOKEN",
+    "GREPTILE_GITHUB_TOKEN",
+    "GREPTILE_API_KEY",
+    "AI_REVIEW_MODE",
+    "AI_REVIEW_PROVIDER"
+  ]) {
+    const value = env[key];
+    if (value) {
+      persisted[key] = value;
+    }
+  }
+  if (Object.keys(persisted).length === 0) {
+    return;
+  }
+  writeFileSync2(secretsPath, `${JSON.stringify(persisted, null, 2)}
+`, "utf-8");
+}
+async function provisionAgentSshKey(homeDir) {
+  const sshDir = resolve7(homeDir, ".ssh");
+  if (!existsSync6(sshDir)) {
+    await mkdir(sshDir, { recursive: true });
+  }
+  seedKnownHosts(sshDir);
+  const secrets = resolveRuntimeSecrets(process.env);
+  const privateKey = decodeProvisionedSshKey(secrets.GITHUB_SSH_KEY);
+  if (!privateKey) {
+    const hostKeyPath = resolveHostSshKeyPath(process.env.HOME ?? "");
+    if (!process.env.HOME || !existsSync6(hostKeyPath)) {
+      return;
+    }
+    const agentKeyPath2 = resolve7(sshDir, "rig-agent-key");
+    if (!existsSync6(agentKeyPath2)) {
+      copyFileSync2(hostKeyPath, agentKeyPath2);
+      chmodSync(agentKeyPath2, 384);
+    }
+    const hostPubPath = `${hostKeyPath}.pub`;
+    if (existsSync6(hostPubPath)) {
+      const agentPubPath = `${agentKeyPath2}.pub`;
+      if (!existsSync6(agentPubPath)) {
+        copyFileSync2(hostPubPath, agentPubPath);
+      }
+    }
+    writeSshConfig(sshDir, agentKeyPath2);
+    return;
+  }
+  const agentKeyPath = resolve7(sshDir, "rig-agent-key");
+  if (!existsSync6(agentKeyPath)) {
+    writeFileSync2(agentKeyPath, privateKey, { mode: 384 });
+  }
+  writeSshConfig(sshDir, agentKeyPath);
+}
+function decodeProvisionedSshKey(encodedKey) {
+  const trimmed = encodedKey?.trim();
+  if (!trimmed || trimmed === GITHUB_SSH_KEY_PLACEHOLDER) {
+    return null;
+  }
+  const decoded = Buffer.from(trimmed, "base64").toString("utf-8").trim();
+  if (!decoded.includes("PRIVATE KEY")) {
+    return null;
+  }
+  return `${decoded}
+`;
+}
+function resolveHostSshKeyPath(homeDir) {
+  const sshDir = resolve7(homeDir, ".ssh");
+  const candidates = [
+    "rig-agent-key",
+    "id_ed25519",
+    "id_ecdsa",
+    "id_rsa"
+  ].map((name) => resolve7(sshDir, name));
+  return candidates.find((candidate) => existsSync6(candidate)) ?? resolve7(sshDir, "rig-agent-key");
+}
+function writeSshConfig(sshDir, keyPath) {
+  const configPath = resolve7(sshDir, "config");
+  if (existsSync6(configPath)) {
+    return;
+  }
+  const knownHostsPath = resolve7(sshDir, "known_hosts");
+  const config = [
+    "Host github.com",
+    `  IdentityFile ${keyPath}`,
+    "  IdentitiesOnly yes",
+    `  UserKnownHostsFile ${knownHostsPath}`,
+    "  StrictHostKeyChecking yes",
+    ""
+  ].join(`
+`);
+  writeFileSync2(configPath, config, { mode: 420 });
+}
+function seedKnownHosts(sshDir) {
+  const knownHostsPath = resolve7(sshDir, "known_hosts");
+  const existingLines = readKnownHosts(knownHostsPath);
+  const requiredLines = GITHUB_KNOWN_HOSTS.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const missing = requiredLines.filter((line) => !existingLines.has(line));
+  if (missing.length === 0) {
+    return;
+  }
+  try {
+    for (const line of missing) {
+      existingLines.add(line);
+    }
+    writeFileSync2(knownHostsPath, `${Array.from(existingLines).join(`
+`)}
+`, { mode: 420 });
+  } catch (err) {
+    const hint = existsSync6(knownHostsPath) ? "" : " \u2014 known_hosts is missing; git SSH operations may fail";
+    console.warn(`[rig] Could not update ${knownHostsPath}: ${err instanceof Error ? err.message : String(err)}${hint}`);
+  }
+}
+function writeClaudeProjectSettings(claudeHomeDir, workspaceDir, runtimeSettings) {
+  const projectHash = hashProjectPath(workspaceDir);
+  const projectDir = resolve7(claudeHomeDir, "projects", projectHash);
+  mkdirSync3(projectDir, { recursive: true });
+  writeFileSync2(resolve7(projectDir, "settings.json"), `${JSON.stringify(runtimeSettings, null, 2)}
+`, "utf-8");
+}
+async function loadRuntimeClaudeSettings(projectSettingsPath) {
+  if (!existsSync6(projectSettingsPath)) {
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = await Bun.file(projectSettingsPath).json();
+  } catch {
+    return {};
+  }
+  const clone = JSON.parse(JSON.stringify(parsed));
+  const hooks = clone.hooks;
+  if (!hooks || typeof hooks !== "object") {
+    return clone;
+  }
+  for (const key of ["PreToolUse", "PostToolUse", "SessionStart", "Stop"]) {
+    const groups = hooks[key];
+    if (!Array.isArray(groups)) {
+      continue;
+    }
+    for (const group of groups) {
+      if (!group || typeof group !== "object" || Array.isArray(group)) {
+        continue;
+      }
+      const hookGroup = group;
+      if (!Array.isArray(hookGroup.hooks)) {
+        continue;
+      }
+      for (const hook of hookGroup.hooks) {
+        if (!hook || hook.type !== "command" || typeof hook.command !== "string") {
+          continue;
+        }
+        const shMatch = hook.command.match(/rig\/hooks\/([a-z0-9-]+)\.sh$/i);
+        if (shMatch) {
+          hook.command = `.rig/bin/hooks/${shMatch[1]}`;
+          continue;
+        }
+        const splinterMatch = hook.command.match(/\.splinter\/bin\/hooks\/([a-z0-9-]+)$/i);
+        if (splinterMatch) {
+          hook.command = `.rig/bin/hooks/${splinterMatch[1]}`;
+        }
+      }
+    }
+  }
+  return clone;
+}
+async function injectClaudeCredentials(claudeHomeDir, options = {}) {
+  const credentialsPath = resolve7(claudeHomeDir, ".credentials.json");
+  const platform = options.platform ?? process.platform;
+  if (platform === "darwin") {
+    const raw = options.loadKeychainCredentials ? await options.loadKeychainCredentials() : await (async () => {
+      const result = await Bun.$`security find-generic-password -s "Claude Code-credentials" -w`.quiet().nothrow();
+      return result.exitCode === 0 ? result.stdout.toString().trim() : "";
+    })();
+    if (raw) {
+      try {
+        JSON.parse(raw);
+        writeFileSync2(credentialsPath, raw, { mode: 384 });
+        registerCredentialCleanup(credentialsPath);
+        return true;
+      } catch {}
+    }
+  }
+  const hostClaudeHome = options.hostClaudeHome ? resolve7(options.hostClaudeHome) : process.env.CLAUDE_HOME?.trim() ? resolve7(process.env.CLAUDE_HOME) : process.env.HOME ? resolve7(process.env.HOME, ".claude") : "";
+  if (hostClaudeHome) {
+    const realCredentials = resolve7(hostClaudeHome, ".credentials.json");
+    if (existsSync6(realCredentials)) {
+      cpSync(realCredentials, credentialsPath);
+      return true;
+    }
+  }
+  return false;
+}
+async function injectCodexAuth(codexHomeDir) {
+  mkdirSync3(codexHomeDir, { recursive: true });
+  const hostCodexHome = process.env.CODEX_HOME?.trim() ? resolve7(process.env.CODEX_HOME) : process.env.HOME ? resolve7(process.env.HOME, ".codex") : "";
+  if (!hostCodexHome) {
+    return false;
+  }
+  const hostAuthPath = resolve7(hostCodexHome, "auth.json");
+  if (!existsSync6(hostAuthPath)) {
+    return false;
+  }
+  const runtimeAuthPath = resolve7(codexHomeDir, "auth.json");
+  copyFileSync2(hostAuthPath, runtimeAuthPath);
+  chmodSync(runtimeAuthPath, 384);
+  return true;
+}
+async function injectPiAgentConfig(piAgentDir) {
+  mkdirSync3(piAgentDir, { recursive: true });
+  const hostPiAgentDir = process.env.PI_CODING_AGENT_DIR?.trim() ? resolve7(process.env.PI_CODING_AGENT_DIR) : process.env.HOME ? resolve7(process.env.HOME, ".pi", "agent") : "";
+  if (!hostPiAgentDir) {
+    return false;
+  }
+  const hostAuthPath = resolve7(hostPiAgentDir, "auth.json");
+  if (!existsSync6(hostAuthPath)) {
+    return false;
+  }
+  const runtimeAuthPath = resolve7(piAgentDir, "auth.json");
+  copyFileSync2(hostAuthPath, runtimeAuthPath);
+  chmodSync(runtimeAuthPath, 384);
+  const hostSettingsPath = resolve7(hostPiAgentDir, "settings.json");
+  if (existsSync6(hostSettingsPath)) {
+    const runtimeSettingsPath = resolve7(piAgentDir, "settings.json");
+    copyFileSync2(hostSettingsPath, runtimeSettingsPath);
+    chmodSync(runtimeSettingsPath, 384);
+  }
+  return true;
+}
+function loadRuntimeTaskContext(runtime) {
+  return loadRuntimeContext(runtime.contextFile);
+}
+var __testOnly = {
+  injectClaudeCredentials,
+  injectCodexAuth,
+  injectPiAgentConfig
+};
+export {
+  runtimeEnv,
+  runtimeCommandEnv,
+  provisionRuntimeHome,
+  provisionClaudeHome,
+  loadRuntimeTaskContext,
+  __testOnly
+};