@h-rig/runtime 0.0.6-alpha.3 → 0.0.6-alpha.30

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

@@ -1,1131 +0,0 @@
-// @bun
-// packages/runtime/src/control-plane/runtime/plugins.ts
-import { existsSync as existsSync3, readdirSync } from "fs";
-import { resolve as resolve3, basename } from "path";
-
-// packages/runtime/src/control-plane/runtime/guard.ts
-import { optimizeNextInvocation } from "bun:jsc";
-import { existsSync as existsSync2, readFileSync, statSync as statSync2 } from "fs";
-import { resolve as resolve2 } from "path";
-
-// packages/runtime/src/control-plane/native/utils.ts
-import { ptr as ptr2 } from "bun:ffi";
-
-// packages/runtime/src/control-plane/native/runtime-native.ts
-import { dlopen, ptr, suffix, toBuffer } from "bun:ffi";
-import { copyFileSync, existsSync, mkdirSync, renameSync, rmSync, statSync } from "fs";
-import { tmpdir } from "os";
-import { dirname, resolve } from "path";
-var sharedNativeRuntimeOutputDir = resolve(tmpdir(), "rig-native");
-var sharedNativeRuntimeOutputPath = resolve(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 && existsSync(outputPath) ? outputPath : null;
-}
-async function loadNativeRuntimeLibrary() {
-  if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
-    return null;
-  }
-  for (const candidate of nativeRuntimeLibraryCandidates()) {
-    if (!candidate || !existsSync(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 = resolve(fromDir);
-  for (let index = 0;index < 8; index += 1) {
-    for (const name of names) {
-      candidates.push(resolve(cursor, "native", `${process.platform}-${process.arch}`, name), resolve(cursor, "native", `${process.platform}-${process.arch}`, "lib", name), resolve(cursor, "native", name), resolve(cursor, "native", "lib", name));
-    }
-    const parent = dirname(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() ? dirname(process.execPath.trim()) : "";
-  const platformSpecific = `runtime-native-${process.platform}-${process.arch}.${suffix}`;
-  return [...new Set([
-    explicit,
-    ...nativePackageLibraryCandidates(import.meta.dir, [colocatedNativeRuntimeFileName, platformSpecific]),
-    execDir ? resolve(execDir, colocatedNativeRuntimeFileName) : "",
-    execDir ? resolve(execDir, platformSpecific) : "",
-    execDir ? resolve(execDir, "..", colocatedNativeRuntimeFileName) : "",
-    execDir ? resolve(execDir, "..", platformSpecific) : "",
-    execDir ? resolve(execDir, "lib", colocatedNativeRuntimeFileName) : "",
-    execDir ? resolve(execDir, "..", "lib", colocatedNativeRuntimeFileName) : "",
-    sharedNativeRuntimeOutputPath
-  ].filter(Boolean))];
-}
-function resolveNativeRuntimeSourcePath() {
-  const explicit = process.env.RIG_NATIVE_RUNTIME_SOURCE?.trim();
-  if (explicit && existsSync(explicit)) {
-    return explicit;
-  }
-  const bundled = resolve(import.meta.dir, "../../../native/snapshot.zig");
-  return existsSync(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(dirname(outputPath), { recursive: true });
-    const needsBuild = options.force === true || !existsSync(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 || !existsSync(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/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/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 = resolve2(projectRoot, "rig/policy/policy.json");
-  if (!existsSync2(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 resolve2(rawPath);
-  return resolve2(projectRoot, rawPath);
-}
-function isHarnessPath(projectRoot, rawPath) {
-  const absPath = resolveAbsolutePath(projectRoot, rawPath);
-  const managedRoots = [
-    resolve2(projectRoot, "rig"),
-    resolve2(projectRoot, ".rig"),
-    resolve2(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 = resolve2(taskWorkspace, ".rig");
-    const workspaceArtifactsRoot = resolve2(taskWorkspace, "artifacts");
-    if (absPath === workspaceRigRoot || absPath.startsWith(workspaceRigRoot + "/") || absPath === workspaceArtifactsRoot || absPath.startsWith(workspaceArtifactsRoot + "/")) {
-      return true;
-    }
-  }
-  const runtimeRoot = resolve2(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 = resolve2(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/plugin-mode.ts
-var LEGACY_PLUGIN_SCAN_ENV = "RIG_LEGACY_PLUGIN_SCAN";
-function isLegacyPluginScanEnabled(env = process.env) {
-  const value = env[LEGACY_PLUGIN_SCAN_ENV]?.trim().toLowerCase();
-  return value === "1" || value === "true" || value === "yes" || value === "on";
-}
-
-// packages/runtime/src/control-plane/runtime/plugins.ts
-class PluginManager {
-  eventBus;
-  context;
-  pluginDir;
-  pluginFiles;
-  pluginNames;
-  localBinDir;
-  pluginsRequireBinaries;
-  plugins;
-  loadPromise;
-  constructor(options) {
-    this.eventBus = options.eventBus;
-    this.context = options.context;
-    this.pluginDir = options.pluginDir;
-    this.pluginFiles = options.pluginFiles;
-    this.pluginNames = options.pluginNames;
-    this.localBinDir = options.localBinDir;
-    this.pluginsRequireBinaries = options.pluginsRequireBinaries;
-    this.plugins = options.preloadedPlugins ?? null;
-    this.loadPromise = null;
-  }
-  static disabled(options) {
-    const validatorProjectRoot = options.runtimeContext?.workspaceDir || options.projectRoot;
-    return new PluginManager({
-      eventBus: options.eventBus,
-      context: {
-        projectRoot: validatorProjectRoot,
-        runId: options.runId,
-        eventBus: options.eventBus
-      },
-      pluginDir: resolve3(options.projectRoot, "rig/plugins"),
-      pluginFiles: [],
-      pluginNames: [],
-      localBinDir: options.runtimeContext ? resolve3(options.runtimeContext.binDir, "plugins") : resolve3(options.projectRoot, "rig/plugins"),
-      pluginsRequireBinaries: false,
-      preloadedPlugins: []
-    });
-  }
-  static async load(options) {
-    const pluginDir = resolve3(options.projectRoot, "rig/plugins");
-    const runtimeImageConfig = loadRuntimeImageConfig(options.projectRoot);
-    const localBinDir = options.runtimeContext ? resolve3(options.runtimeContext.binDir, "plugins") : resolve3(options.projectRoot, "rig/plugins");
-    const legacyPluginScan = options.legacyPluginScan ?? isLegacyPluginScanEnabled(options.env);
-    const files = legacyPluginScan ? safeReadDir(pluginDir).filter((entry) => /\.(ts|js|mjs|cjs)$/.test(entry)) : [];
-    const pluginNames = files.map((file) => basename(file).replace(/\.plugin\.(ts|js|mjs|cjs)$/, ""));
-    const validatorProjectRoot = options.runtimeContext?.workspaceDir || options.projectRoot;
-    const context = {
-      projectRoot: validatorProjectRoot,
-      runId: options.runId,
-      eventBus: options.eventBus
-    };
-    return new PluginManager({
-      eventBus: options.eventBus,
-      context,
-      pluginDir,
-      pluginFiles: files,
-      pluginNames,
-      localBinDir,
-      pluginsRequireBinaries: options.pluginsRequireBinaries ?? (runtimeImageConfig.plugins_require_binaries && Boolean(options.runtimeContext))
-    });
-  }
-  list() {
-    if (this.plugins) {
-      return this.plugins.map((plugin) => ({
-        name: plugin.name,
-        validators: plugin.validators?.map((validator) => validator.id) ?? []
-      }));
-    }
-    return this.pluginNames.map((name) => ({
-      name,
-      validators: []
-    }));
-  }
-  async beforeCommand(ctx) {
-    const plugins = await this.ensureLoaded();
-    for (const plugin of plugins) {
-      if (!plugin.beforeCommand) {
-        continue;
-      }
-      await this.safeInvoke(plugin.name, "beforeCommand", () => plugin.beforeCommand?.(ctx, this.context));
-    }
-  }
-  async afterCommand(result) {
-    const plugins = await this.ensureLoaded();
-    for (const plugin of plugins) {
-      if (!plugin.afterCommand) {
-        continue;
-      }
-      await this.safeInvoke(plugin.name, "afterCommand", () => plugin.afterCommand?.(result, this.context));
-    }
-  }
-  async onEvent(event) {
-    const plugins = this.plugins;
-    if (!plugins) {
-      return;
-    }
-    for (const plugin of plugins) {
-      if (!plugin.onEvent) {
-        continue;
-      }
-      await this.safeInvoke(plugin.name, "onEvent", () => plugin.onEvent?.(event, this.context));
-    }
-  }
-  async runValidators(taskId) {
-    const plugins = await this.ensureLoaded();
-    const results = [];
-    for (const plugin of plugins) {
-      for (const validator of plugin.validators ?? []) {
-        await this.eventBus.emit("validator.started", {
-          plugin: plugin.name,
-          validator: validator.id,
-          taskId
-        });
-        try {
-          const result = await validator.run({ taskId, projectRoot: this.context.projectRoot }, this.context);
-          results.push(result);
-          await this.eventBus.emit("validator.finished", {
-            plugin: plugin.name,
-            validator: validator.id,
-            taskId,
-            passed: result.passed,
-            summary: result.summary
-          });
-        } catch (error) {
-          const failed = {
-            id: validator.id,
-            passed: false,
-            summary: `${plugin.name}/${validator.id} failed unexpectedly`,
-            details: `${error}`
-          };
-          results.push(failed);
-          await this.eventBus.emit("validator.finished", {
-            plugin: plugin.name,
-            validator: validator.id,
-            taskId,
-            passed: false,
-            summary: failed.summary,
-            details: failed.details
-          });
-        }
-      }
-    }
-    return results;
-  }
-  async safeInvoke(pluginName, hook, call) {
-    try {
-      await call();
-    } catch (error) {
-      await this.eventBus.emit("plugin.error", {
-        plugin: pluginName,
-        phase: hook,
-        error: `${error}`
-      });
-    }
-  }
-  async ensureLoaded() {
-    if (this.plugins) {
-      return this.plugins;
-    }
-    if (this.loadPromise) {
-      return this.loadPromise;
-    }
-    this.loadPromise = this.loadCompiledPlugins();
-    try {
-      this.plugins = await this.loadPromise;
-      return this.plugins;
-    } finally {
-      this.loadPromise = null;
-    }
-  }
-  resolveBinPath(binName) {
-    const candidates = [this.localBinDir].filter(Boolean).map((dir) => resolve3(dir, binName));
-    return candidates.find((candidate) => existsSync3(candidate));
-  }
-  async loadCompiledPlugins() {
-    const plugins = [];
-    for (const file of this.pluginFiles) {
-      const binName = basename(file).replace(/\.plugin\.(ts|js|mjs|cjs)$/, "");
-      let binPath = this.resolveBinPath(binName);
-      if (!binPath) {
-        const triedPaths = [this.localBinDir].filter(Boolean).map((dir) => resolve3(dir, binName));
-        const missingError = `Compiled plugin binary not found for '${binName}'. Tried: ${triedPaths.join(", ")}`;
-        await this.eventBus.emit("plugin.error", {
-          file: resolve3(this.pluginDir, file),
-          phase: "load",
-          error: missingError
-        });
-        if (this.pluginsRequireBinaries) {
-          throw new Error(missingError);
-        }
-        plugins.push({
-          name: binName,
-          validators: []
-        });
-        await this.eventBus.emit("plugin.loaded", {
-          plugin: binName,
-          file: resolve3(this.pluginDir, file),
-          source: "metadata-only"
-        });
-        continue;
-      }
-      const wrapper = createBinaryPluginWrapper(binName, binPath, this.context.projectRoot);
-      plugins.push(wrapper);
-      await this.eventBus.emit("plugin.loaded", {
-        plugin: wrapper.name,
-        file: binPath,
-        source: "compiled-binary"
-      });
-    }
-    return plugins;
-  }
-}
-function createBinaryPluginWrapper(name, binPath, projectRoot) {
-  return {
-    name,
-    validators: [
-      {
-        id: `${name}:compiled`,
-        async run(ctx) {
-          const proc = Bun.spawn([binPath, "--validate", ctx.taskId, ctx.projectRoot], {
-            cwd: projectRoot,
-            stdout: "pipe",
-            stderr: "pipe"
-          });
-          const exitCode = await proc.exited;
-          const stdout = await new Response(proc.stdout).text();
-          const stderr = await new Response(proc.stderr).text();
-          if (exitCode !== 0) {
-            return {
-              id: `${name}:compiled`,
-              passed: false,
-              summary: `Plugin binary ${name} exited with code ${exitCode}`,
-              details: stderr || stdout
-            };
-          }
-          try {
-            const results = JSON.parse(stdout.trim());
-            const failed = results.filter((r) => !r.passed);
-            if (failed.length > 0) {
-              return {
-                id: `${name}:compiled`,
-                passed: false,
-                summary: `${failed.length} of ${results.length} validator(s) failed`,
-                details: failed.map((f) => `${f.id}: ${f.summary}`).join(`
-`)
-              };
-            }
-            return {
-              id: `${name}:compiled`,
-              passed: true,
-              summary: `All ${results.length} validator(s) passed`
-            };
-          } catch {
-            return {
-              id: `${name}:compiled`,
-              passed: false,
-              summary: `Failed to parse output from compiled plugin ${name}`,
-              details: stdout.slice(0, 500)
-            };
-          }
-        }
-      }
-    ]
-  };
-}
-function safeReadDir(path) {
-  try {
-    return readdirSync(path, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name).sort();
-  } catch {
-    return [];
-  }
-}
-export {
-  PluginManager
-};