@h-rig/core 0.0.6-alpha.17 → 0.0.6-alpha.170

package/dist/src/hook-runner.js

@@ -0,0 +1,756 @@
+// @bun
+// packages/core/src/load-config.ts
+import { existsSync as existsSync2, mkdirSync, mkdtempSync, readFileSync as readFileSync2, readdirSync, rmSync, statSync } from "fs";
+import { isBuiltin } from "module";
+import { dirname, isAbsolute, join as join2, relative, resolve } from "path";
+import { pathToFileURL } from "url";
+import { Schema as Schema3 } from "effect";
+import { RigConfig as RigConfig3 } from "@rig/contracts";
+
+// packages/core/src/define-config.ts
+import { Schema } from "effect";
+import { RigConfig } from "@rig/contracts";
+function normalizeWorkspaceConfig(raw) {
+  const workspace = raw && typeof raw === "object" && !Array.isArray(raw) ? { ...raw } : {};
+  if (workspace.mainRepo === undefined)
+    workspace.mainRepo = ".";
+  if (workspace.checkout === undefined && workspace.isolation !== undefined)
+    workspace.checkout = workspace.isolation;
+  if (workspace.isolation === undefined && workspace.checkout !== undefined)
+    workspace.isolation = workspace.checkout;
+  return workspace;
+}
+function applyConfigDefaults(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return raw;
+  const record = raw;
+  return {
+    ...record,
+    plugins: Array.isArray(record.plugins) ? record.plugins.flat() : [],
+    workspace: normalizeWorkspaceConfig(record.workspace)
+  };
+}
+
+// packages/core/src/declarative-config.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { parse as parseToml } from "smol-toml";
+import { Schema as Schema2 } from "effect";
+import { RigConfig as RigConfig2 } from "@rig/contracts";
+
+// packages/core/src/embedded-plugins.ts
+var registered = null;
+function getStandardPluginsResolver() {
+  return registered;
+}
+var bakedProjectConfig = null;
+function getEmbeddedProjectConfig() {
+  return bakedProjectConfig;
+}
+
+// packages/core/src/declarative-config.ts
+var DECLARATIVE_CONFIG_NAMES = ["rigfig.toml", "rigfig.json"];
+function findDeclarativeConfigPath(cwd) {
+  const dir = join(cwd, ".rig");
+  for (const name of DECLARATIVE_CONFIG_NAMES) {
+    const candidate = join(dir, name);
+    if (existsSync(candidate))
+      return candidate;
+  }
+  return null;
+}
+function parseDeclarativeFile(path) {
+  const raw = readFileSync(path, "utf8");
+  const parsed = path.endsWith(".json") ? JSON.parse(raw) : parseToml(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Declarative config ${path} must parse to an object.`);
+  }
+  return parsed;
+}
+function loadDeclarativeConfig(path) {
+  const data = parseDeclarativeFile(path);
+  const standardSection = data.standard && typeof data.standard === "object" && !Array.isArray(data.standard) ? data.standard : {};
+  const useStandard = standardSection.enabled !== false;
+  let plugins = [];
+  if (useStandard) {
+    const resolver = getStandardPluginsResolver();
+    if (!resolver) {
+      throw new Error(`Declarative config ${path} needs the embedded standard plugins, but none were registered. ` + `This is a seed/boot wiring error (the binary entrypoint must import the standard-plugin registration).`);
+    }
+    plugins = resolver(data);
+  }
+  const { standard: _standardDirective, ...configFields } = data;
+  const withDefaults = applyConfigDefaults({ ...configFields, plugins });
+  const explicitPlugins = Array.isArray(withDefaults.plugins) ? [...withDefaults.plugins] : [];
+  const decoded = Schema2.decodeUnknownSync(RigConfig2)({
+    ...withDefaults,
+    plugins: explicitPlugins
+  });
+  return { ...decoded, plugins: explicitPlugins };
+}
+
+// packages/core/src/load-config.ts
+var TS_NAMES = [".rig/rig.config.ts", ".rig/rig.config.mts"];
+var JSON_NAMES = [".rig/rig.config.json"];
+function isModuleResolutionError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("Cannot find module") || message.includes("Could not resolve");
+}
+function runningFromCompiledBinary() {
+  return import.meta.url.includes("$bunfs");
+}
+function packageNameAndSubpath(specifier) {
+  if (specifier.startsWith(".") || specifier.startsWith("/") || /^[a-zA-Z]+:/.test(specifier))
+    return null;
+  const parts = specifier.split("/");
+  const packageName = specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+  if (!packageName)
+    return null;
+  const rest = parts.slice(specifier.startsWith("@") ? 2 : 1).join("/");
+  return { packageName, subpath: rest ? `./${rest}` : "." };
+}
+function exportTargetFromEntry(entry) {
+  if (typeof entry === "string")
+    return entry;
+  if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+    const conditions = entry;
+    for (const key of ["bun", "import", "default", "require"]) {
+      if (typeof conditions[key] === "string")
+        return conditions[key];
+    }
+  }
+  return null;
+}
+function patternExportTarget(record, subpath) {
+  for (const [pattern, entry] of Object.entries(record)) {
+    if (!pattern.includes("*"))
+      continue;
+    const [prefix = "", suffix = ""] = pattern.split("*");
+    if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix))
+      continue;
+    const replacement = subpath.slice(prefix.length, subpath.length - suffix.length);
+    const target = exportTargetFromEntry(entry);
+    if (target)
+      return target.replace("*", replacement);
+  }
+  return null;
+}
+function exportTargetFromPackageJson(pkg, subpath) {
+  const exportsField = pkg.exports;
+  const target = (() => {
+    if (typeof exportsField === "string" && subpath === ".")
+      return exportsField;
+    if (!exportsField || typeof exportsField !== "object" || Array.isArray(exportsField))
+      return null;
+    const record = exportsField;
+    return exportTargetFromEntry(record[subpath] ?? (subpath === "." ? record["."] : undefined)) ?? patternExportTarget(record, subpath);
+  })();
+  if (target)
+    return target;
+  return subpath === "." && typeof pkg.module === "string" ? pkg.module : subpath === "." && typeof pkg.main === "string" ? pkg.main : null;
+}
+function resolvePackageDirFromBunStore(packageName, nodeModulesDir) {
+  const storeDir = join2(nodeModulesDir, ".bun");
+  if (!existsSync2(storeDir))
+    return null;
+  const encoded = packageName.replace("/", "+");
+  try {
+    const candidates = readdirSync(storeDir).filter((entry) => entry.startsWith(`${encoded}@`)).map((entry) => {
+      const candidateDir = join2(storeDir, entry, "node_modules", packageName);
+      const packageJsonPath = join2(candidateDir, "package.json");
+      if (!existsSync2(packageJsonPath))
+        return null;
+      try {
+        const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
+        return {
+          dir: candidateDir,
+          sortKey: pkg.version?.trim() || entry
+        };
+      } catch {
+        return {
+          dir: candidateDir,
+          sortKey: entry
+        };
+      }
+    }).filter((candidate) => candidate !== null).sort((a, b) => b.sortKey.localeCompare(a.sortKey, undefined, { numeric: true, sensitivity: "base" }));
+    return candidates[0]?.dir ?? null;
+  } catch {
+    return null;
+  }
+}
+function resolveDirectoryModulePath(directoryPath) {
+  const packageJsonPath = join2(directoryPath, "package.json");
+  if (existsSync2(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
+      const target = exportTargetFromPackageJson(pkg, ".");
+      if (target) {
+        const resolved = resolveModulePath(join2(directoryPath, target));
+        if (resolved)
+          return resolved;
+      }
+    } catch {}
+  }
+  for (const candidate of ["index.js", "index.mjs", "index.cjs", "index.ts", "index.json"]) {
+    const resolved = resolveModulePath(join2(directoryPath, candidate));
+    if (resolved)
+      return resolved;
+  }
+  return null;
+}
+function resolveModulePath(candidatePath) {
+  if (!existsSync2(candidatePath)) {
+    for (const extension of [".ts", ".mts", ".tsx", ".js", ".mjs", ".cjs", ".json"]) {
+      const withExtension = `${candidatePath}${extension}`;
+      if (existsSync2(withExtension))
+        return resolveModulePath(withExtension);
+    }
+    return null;
+  }
+  try {
+    const stat = statSync(candidatePath);
+    if (stat.isFile())
+      return candidatePath;
+    if (stat.isDirectory())
+      return resolveDirectoryModulePath(candidatePath);
+  } catch {
+    return null;
+  }
+  return null;
+}
+function resolvePackageExportFromDir(packageDir, subpath) {
+  const packageJsonPath = join2(packageDir, "package.json");
+  if (existsSync2(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
+      const target = exportTargetFromPackageJson(pkg, subpath);
+      if (target) {
+        const resolved = resolveModulePath(join2(packageDir, target));
+        if (resolved)
+          return resolved;
+      }
+    } catch {
+      return null;
+    }
+  }
+  if (subpath !== ".") {
+    const legacySubpath = subpath.replace(/^\.\//, "");
+    for (const candidate of [
+      join2(packageDir, legacySubpath),
+      join2(packageDir, `${legacySubpath}.js`),
+      join2(packageDir, `${legacySubpath}.mjs`),
+      join2(packageDir, `${legacySubpath}.cjs`),
+      join2(packageDir, `${legacySubpath}.ts`),
+      join2(packageDir, `${legacySubpath}.json`)
+    ]) {
+      const resolved = resolveModulePath(candidate);
+      if (resolved)
+        return resolved;
+    }
+  }
+  return subpath === "." ? resolveDirectoryModulePath(packageDir) : null;
+}
+var runtimeBundleQueue = Promise.resolve();
+function enqueueRuntimeBundle(operation) {
+  const next = runtimeBundleQueue.then(operation, operation);
+  runtimeBundleQueue = next.then(() => {
+    return;
+  }, () => {
+    return;
+  });
+  return next;
+}
+function isWithinDir(candidatePath, rootPath) {
+  const rel = relative(resolve(rootPath), resolve(candidatePath));
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+function resolvedFilePath(path, rootPath) {
+  if (!path || !isAbsolute(path))
+    return null;
+  const resolved = resolveModulePath(path);
+  if (!resolved)
+    return null;
+  return rootPath && !isWithinDir(resolved, rootPath) ? null : resolved;
+}
+function resolveProjectPackageImport(specifier, configDir) {
+  const parsed = packageNameAndSubpath(specifier);
+  if (!parsed)
+    return null;
+  const nodeModulesDir = join2(configDir, "node_modules");
+  const directPackageDir = join2(nodeModulesDir, parsed.packageName);
+  const packageDir = existsSync2(join2(directPackageDir, "package.json")) ? directPackageDir : resolvePackageDirFromBunStore(parsed.packageName, nodeModulesDir);
+  return packageDir ? resolvePackageExportFromDir(packageDir, parsed.subpath) : null;
+}
+function canImportRigWorkspacePackagesDirectly(source, configDir) {
+  const packageNames = new Set;
+  for (const match of source.matchAll(/(?:from\s*|import\s*\(\s*|import\s*)["'](@rig\/[^"']+)["']/g)) {
+    const parsed = packageNameAndSubpath(match[1] ?? "");
+    if (parsed?.packageName)
+      packageNames.add(parsed.packageName);
+  }
+  if (packageNames.size === 0)
+    return false;
+  for (const packageName of packageNames) {
+    const shortName = packageName.replace(/^@rig\//, "");
+    const manifestPath = join2(configDir, "packages", shortName, "package.json");
+    if (!existsSync2(manifestPath))
+      return false;
+    try {
+      const parsed = JSON.parse(readFileSync2(manifestPath, "utf8"));
+      if (parsed.name !== packageName)
+        return false;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+async function importConfigViaRuntimeBundleUnserialized(configPath) {
+  const bun = globalThis.Bun;
+  if (!bun?.build) {
+    throw new Error(`Failed to import ${configPath}: bare imports could not be resolved and no Bun.build runtime bundler is available.`);
+  }
+  const RUNTIME_ONLY_EXTERNAL_PACKAGES = new Set(["effect", "mupdf", "fastembed", "onnxruntime-node", "markit-ai"]);
+  const configDir = dirname(configPath);
+  const UNRESOLVED_NAMESPACE = "rig-config-unresolved";
+  const unresolvedLocalPlugin = {
+    name: "rig-config-unresolved-local",
+    setup(build) {
+      build.onLoad({ filter: /\.(?:html|txt)$/ }, (args) => ({
+        loader: "js",
+        contents: `export default ${JSON.stringify(readFileSync2(args.path, "utf8"))};
+`
+      }));
+      build.onResolve({ filter: /.*/ }, (args) => {
+        const directFilePath = resolvedFilePath(args.path, configDir);
+        if (directFilePath)
+          return { path: directFilePath };
+        const packageImport = packageNameAndSubpath(args.path);
+        if (packageImport && (packageImport.packageName.startsWith("@rig/") || RUNTIME_ONLY_EXTERNAL_PACKAGES.has(packageImport.packageName))) {
+          return { path: args.path, external: true };
+        }
+        const projectPackagePath = resolveProjectPackageImport(args.path, configDir);
+        if (projectPackagePath)
+          return { path: projectPackagePath };
+        if (/^(?:node|bun):/.test(args.path) || isBuiltin(args.path))
+          return;
+        if (packageImport)
+          return { path: args.path, external: true };
+        const parentCandidates = args.path.startsWith(".") ? [args.importer && isAbsolute(args.importer) ? dirname(args.importer) : null, configDir].filter((value) => Boolean(value)) : [args.importer && isAbsolute(args.importer) ? dirname(args.importer) : configDir];
+        for (const parent2 of parentCandidates) {
+          const filePath = resolvedFilePath(resolve(parent2, args.path), configDir);
+          if (filePath)
+            return { path: filePath };
+        }
+        const parent = parentCandidates[0] ?? configDir;
+        try {
+          const resolved = bun.resolveSync?.(args.path, parent) ?? resolve(parent, args.path);
+          const filePath = resolvedFilePath(resolved, configDir);
+          if (filePath)
+            return { path: filePath };
+        } catch {}
+        return { path: args.path, namespace: UNRESOLVED_NAMESPACE };
+      });
+      build.onLoad({ filter: /.*/, namespace: UNRESOLVED_NAMESPACE }, (args) => ({
+        loader: "js",
+        contents: `module.exports = {};
+throw new Error(${JSON.stringify(`Failed to bundle ${configPath}: Could not resolve local import "${args.path}". Maybe you need to fix a relative import in rig.config.ts or install project deps.`)});
+`
+      }));
+    }
+  };
+  const result = await bun.build({
+    entrypoints: [configPath],
+    target: "bun",
+    external: ["effect", "mupdf", "fastembed", "onnxruntime-node", "markit-ai"],
+    format: "esm",
+    throw: false,
+    packages: "bundle",
+    plugins: [unresolvedLocalPlugin]
+  });
+  if (!result.success || !result.outputs[0]) {
+    const detail = result.logs.map((log) => String(log)).join(`
+`);
+    throw new Error(`Failed to bundle ${configPath}: ${detail || "unknown bundler error"}`);
+  }
+  const bundleParentDir = join2(configDir, ".rig", "tmp");
+  mkdirSync(bundleParentDir, { recursive: true });
+  const dir = mkdtempSync(join2(bundleParentDir, "rig-config-bundle-"));
+  try {
+    const bundledPath = join2(dir, "rig.config.bundled.js");
+    await bun.write(bundledPath, await result.outputs[0].text());
+    return await import(pathToFileURL(bundledPath).href);
+  } finally {
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {}
+  }
+}
+async function loadConfig(cwd) {
+  const baked = getEmbeddedProjectConfig();
+  if (baked && resolve(baked.projectRoot) === resolve(cwd)) {
+    return decodeExplicitPluginConfig(baked.raw);
+  }
+  for (const name of TS_NAMES) {
+    const p = join2(cwd, name);
+    if (existsSync2(p)) {
+      const mod = await enqueueRuntimeBundle(async () => {
+        if (runningFromCompiledBinary()) {
+          return importConfigViaRuntimeBundleUnserialized(p);
+        }
+        const source = readFileSync2(p, "utf8");
+        const importsRigHostPackages = /(?:import\s+[^;]*?from\s*|import\s*\()\s*["']@rig\//.test(source);
+        if (importsRigHostPackages && !canImportRigWorkspacePackagesDirectly(source, cwd)) {
+          return importConfigViaRuntimeBundleUnserialized(p);
+        }
+        try {
+          return await import(pathToFileURL(p).href);
+        } catch (error) {
+          if (!isModuleResolutionError(error))
+            throw error;
+          return importConfigViaRuntimeBundleUnserialized(p);
+        }
+      });
+      const raw = mod.default ?? mod.config;
+      return decodeExplicitPluginConfig(raw);
+    }
+  }
+  const declarativePath = findDeclarativeConfigPath(cwd);
+  if (declarativePath) {
+    return loadDeclarativeConfig(declarativePath);
+  }
+  for (const name of JSON_NAMES) {
+    const p = join2(cwd, name);
+    if (existsSync2(p)) {
+      const raw = JSON.parse(readFileSync2(p, "utf-8"));
+      return decodeExplicitPluginConfig(raw);
+    }
+  }
+  throw new Error(`no .rig/rig.config.{ts,mts,json} or .rig/rigfig.{toml,json} found in ${cwd}`);
+}
+function decodeExplicitPluginConfig(raw) {
+  const withDefaults = applyConfigDefaults(raw);
+  const explicitPlugins = Array.isArray(withDefaults.plugins) ? [...withDefaults.plugins] : [];
+  const decoded = Schema3.decodeUnknownSync(RigConfig3)({
+    ...withDefaults,
+    plugins: explicitPlugins
+  });
+  return { ...decoded, plugins: explicitPlugins };
+}
+
+// packages/core/src/hook-runtime.ts
+import { appendFileSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, realpathSync, writeSync } from "fs";
+import { resolve as resolve2 } from "path";
+import { RIG_DEFINITION_DIRNAME, RIG_STATE_DIRNAME } from "@rig/contracts";
+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 readBuildConfigForCoreHooks() {
+  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 {};
+  }
+}
+var BUILD_CONFIG = readBuildConfigForCoreHooks();
+var BAKED_PROJECT_ROOT = BUILD_CONFIG.AGENT_PROJECT_ROOT ?? "";
+var BAKED_TASK_ID = BUILD_CONFIG.AGENT_TASK_ID ?? "";
+var BAKED_STATE_DIR = BUILD_CONFIG.AGENT_STATE_DIR ?? "";
+var BAKED_BUN_PATH = BUILD_CONFIG.AGENT_BUN_PATH ?? "";
+var BAKED_TASK_CONFIG = BUILD_CONFIG.AGENT_TASK_CONFIG ?? "";
+var BAKED_POLICY_CONTENT = BUILD_CONFIG.AGENT_POLICY_CONTENT ?? "";
+var BAKED_TASK_SCOPES = BUILD_CONFIG.AGENT_TASK_SCOPES ?? "";
+var RUNTIME_CONTEXT_ENV = "RIG_RUNTIME_CONTEXT_FILE";
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function loadHookContextFromEnv() {
+  const contextFile = process.env[RUNTIME_CONTEXT_ENV]?.trim();
+  let filePath = contextFile || "";
+  if (!filePath) {
+    let current = resolve2(process.cwd());
+    while (true) {
+      const candidate = resolve2(current, "runtime-context.json");
+      if (existsSync3(candidate)) {
+        filePath = candidate;
+        break;
+      }
+      const parent = resolve2(current, "..");
+      if (parent === current) {
+        break;
+      }
+      current = parent;
+    }
+  }
+  if (!filePath || !existsSync3(filePath)) {
+    return null;
+  }
+  try {
+    const raw = JSON.parse(readFileSync3(filePath, "utf-8"));
+    if (!isPlainObject(raw)) {
+      return null;
+    }
+    const taskId = typeof raw.taskId === "string" ? raw.taskId : "";
+    const role = typeof raw.role === "string" ? raw.role : "";
+    const scopes = isStringArray(raw.scopes) ? raw.scopes : [];
+    const validation = isStringArray(raw.validation) ? raw.validation : [];
+    const hostProjectRoot = typeof raw.hostProjectRoot === "string" ? raw.hostProjectRoot : undefined;
+    const monorepoMainRoot = typeof raw.monorepoMainRoot === "string" ? raw.monorepoMainRoot : undefined;
+    const stateDir = typeof raw.stateDir === "string" ? raw.stateDir : "";
+    const policyFile = typeof raw.policyFile === "string" ? raw.policyFile : "";
+    if (!taskId || !stateDir) {
+      return null;
+    }
+    return {
+      taskId,
+      role,
+      scopes,
+      validation,
+      hostProjectRoot,
+      monorepoMainRoot,
+      stateDir,
+      policyFile
+    };
+  } catch {
+    return null;
+  }
+}
+var cachedContext;
+function getContext() {
+  if (cachedContext !== undefined) {
+    return cachedContext;
+  }
+  cachedContext = loadHookContextFromEnv();
+  return cachedContext;
+}
+function resolveProjectRoot() {
+  const ctx = getContext();
+  if (ctx?.hostProjectRoot)
+    return ctx.hostProjectRoot;
+  if (BAKED_PROJECT_ROOT) {
+    return BAKED_PROJECT_ROOT;
+  }
+  if (process.env.PROJECT_RIG_ROOT) {
+    return process.env.PROJECT_RIG_ROOT;
+  }
+  const candidates = [process.cwd(), resolve2(import.meta.dirname, "../..")];
+  for (const candidate of candidates) {
+    if (existsSync3(resolve2(candidate, RIG_DEFINITION_DIRNAME)) || existsSync3(resolve2(candidate, RIG_STATE_DIRNAME))) {
+      return candidate;
+    }
+  }
+  return resolve2(import.meta.dirname, "../..");
+}
+function resolveTaskIdForHook(_projectRoot) {
+  const ctx = getContext();
+  if (ctx)
+    return ctx.taskId;
+  if (BAKED_TASK_ID) {
+    return BAKED_TASK_ID;
+  }
+  const fromEnv = (process.env.RIG_TASK_ID || "").trim();
+  if (fromEnv) {
+    return fromEnv;
+  }
+  const runtimeId = (process.env.RIG_TASK_RUNTIME_ID || "").trim();
+  if (runtimeId.startsWith("task-") && runtimeId.length > "task-".length) {
+    return runtimeId.slice("task-".length);
+  }
+  return "";
+}
+async function readHookInput() {
+  let text = "";
+  const inputFile = process.env.RIG_HOOK_INPUT_FILE?.trim();
+  if (inputFile) {
+    text = readFileSync3(inputFile, "utf-8");
+  } else {
+    try {
+      text = readFileSync3("/dev/stdin", "utf-8");
+    } catch {
+      text = readFileSync3(0, "utf-8");
+    }
+  }
+  if (!text.trim()) {
+    return { input: {}, valid: true, hadPayload: false };
+  }
+  try {
+    return {
+      input: JSON.parse(text),
+      valid: true,
+      hadPayload: true
+    };
+  } catch {
+    return { input: {}, valid: false, hadPayload: true };
+  }
+}
+function extractToolFilePaths(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 buildPluginHookContext(parsed, opts) {
+  const toolName = parsed.input.tool_name;
+  const toolInput = parsed.input.tool_input ?? {};
+  return {
+    event: opts.event,
+    toolName,
+    toolInput,
+    filePaths: toolName ? extractToolFilePaths(toolName, toolInput) : [],
+    projectRoot: opts.projectRoot,
+    taskId: opts.taskId
+  };
+}
+function hookResultToProtocol(result) {
+  if (result.decision === "block") {
+    const lines = [`BLOCKED: ${result.reason ?? "blocked by plugin hook"}`];
+    if (result.systemMessage) {
+      lines.push(result.systemMessage);
+    }
+    return { exitCode: 1, stdout: `${lines.join(`
+`)}
+` };
+  }
+  return {
+    exitCode: 0,
+    stdout: result.systemMessage ? `${result.systemMessage}
+` : ""
+  };
+}
+async function runTypedHook(fn, opts) {
+  const parsed = await readHookInput();
+  const projectRoot = opts.projectRoot ?? resolveProjectRoot();
+  const taskId = opts.taskId ?? resolveTaskIdForHook(projectRoot);
+  const ctx = buildPluginHookContext(parsed, {
+    event: opts.event,
+    projectRoot,
+    taskId
+  });
+  let result;
+  try {
+    result = await fn(ctx);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    writeSync(2, `[rig hook] typed hook threw: ${message}
+`);
+    process.exit(0);
+  }
+  const { exitCode, stdout } = hookResultToProtocol(result);
+  if (stdout) {
+    writeSync(1, stdout);
+  }
+  process.exit(exitCode);
+}
+
+// packages/core/src/hook-runner.ts
+function parseHookRunnerArgs(argv) {
+  const args = {};
+  for (let i = 0;i < argv.length; i += 1) {
+    const flag = argv[i];
+    const value = argv[i + 1];
+    if (value === undefined)
+      break;
+    switch (flag) {
+      case "--plugin":
+        args.plugin = value;
+        i += 1;
+        break;
+      case "--hook":
+        args.hook = value;
+        i += 1;
+        break;
+      case "--event":
+        args.event = value;
+        i += 1;
+        break;
+      case "--project-root":
+        args.projectRoot = value;
+        i += 1;
+        break;
+      default:
+        break;
+    }
+  }
+  return args;
+}
+function findTypedHook(plugins, pluginName, hookId) {
+  const plugin = plugins.find((p) => p.name === pluginName);
+  if (!plugin) {
+    return { hook: null, reason: `plugin "${pluginName}" not found in rig config` };
+  }
+  const registration = (plugin.contributes?.hooks ?? []).find((h) => h.id === hookId);
+  if (!registration) {
+    return {
+      hook: null,
+      reason: `plugin "${pluginName}" has no metadata entry for hook "${hookId}"`
+    };
+  }
+  const implementation = registration.handler;
+  if (!implementation) {
+    return {
+      hook: null,
+      reason: `plugin "${pluginName}" has no typed implementation for hook "${hookId}"`
+    };
+  }
+  return { hook: { implementation, registration } };
+}
+function warnAndAllow(message) {
+  process.stderr.write(`[rig hook-runner] ${message} \u2014 allowing
+`);
+  process.exit(0);
+}
+async function main(argv) {
+  const args = parseHookRunnerArgs(argv);
+  if (!args.plugin || !args.hook) {
+    warnAndAllow("missing --plugin/--hook arguments");
+  }
+  const projectRoot = args.projectRoot?.trim() || process.env.CLAUDE_PROJECT_DIR?.trim() || process.cwd();
+  let plugins;
+  try {
+    const config = await loadConfig(projectRoot);
+    plugins = config.plugins;
+  } catch (err) {
+    warnAndAllow(`failed to load rig config from ${projectRoot}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const { hook, reason } = findTypedHook(plugins, args.plugin, args.hook);
+  if (!hook) {
+    warnAndAllow(reason ?? "typed hook not found");
+  }
+  const event = hook.registration.event;
+  return runTypedHook(hook.implementation, { event, projectRoot });
+}
+if (import.meta.main) {
+  main(process.argv.slice(2));
+}
+export {
+  parseHookRunnerArgs,
+  main,
+  findTypedHook
+};