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

package/dist/src/exec.js

@@ -0,0 +1,101 @@
+// @bun
+// packages/core/src/exec.ts
+import { existsSync, readFileSync } from "fs";
+function runCapture(command, cwd, env) {
+  const result = Bun.spawnSync(command, {
+    cwd,
+    env: env ? { ...process.env, ...env } : process.env,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  return {
+    exitCode: result.exitCode,
+    stdout: result.stdout.toString(),
+    stderr: result.stderr.toString()
+  };
+}
+var DEFAULT_VALIDATION_TIMEOUT_MS = 30000;
+function getValidationTimeoutMs() {
+  const envVal = process.env.RIG_VALIDATION_TIMEOUT_MS;
+  if (envVal) {
+    const parsed = Number(envVal);
+    if (Number.isFinite(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  return DEFAULT_VALIDATION_TIMEOUT_MS;
+}
+async function runCaptureAsync(command, cwd, env, timeoutMs) {
+  const timeout = timeoutMs ?? getValidationTimeoutMs();
+  const proc = Bun.spawn(command, {
+    cwd,
+    env: env ? { ...process.env, ...env } : process.env,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const stdoutPromise = new Response(proc.stdout).text();
+  const stderrPromise = new Response(proc.stderr).text();
+  const timeoutResult = Symbol("timeout");
+  const exitOrTimeout = await Promise.race([
+    proc.exited,
+    Bun.sleep(timeout).then(() => timeoutResult)
+  ]);
+  if (exitOrTimeout === timeoutResult) {
+    proc.kill("SIGKILL");
+    const [stdout2, stderr2] = await Promise.all([
+      Promise.race([stdoutPromise, Bun.sleep(2000).then(() => "")]),
+      Promise.race([stderrPromise, Bun.sleep(2000).then(() => "")])
+    ]);
+    return {
+      exitCode: 124,
+      stdout: stdout2,
+      stderr: `${stderr2}
+[TIMEOUT] Process killed after ${timeout}ms`
+    };
+  }
+  const [stdout, stderr] = await Promise.all([stdoutPromise, stderrPromise]);
+  const exitCode = exitOrTimeout;
+  return { exitCode, stdout, stderr };
+}
+function runInherit(command, cwd, env) {
+  const proc = Bun.spawnSync(command, {
+    cwd,
+    env: env ? { ...process.env, ...env } : process.env,
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  return proc.exitCode;
+}
+function readJsonFile(path, fallback) {
+  if (!existsSync(path)) {
+    return fallback;
+  }
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function nowIso() {
+  return new Date().toISOString();
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+function fileLines(path) {
+  if (!existsSync(path)) {
+    return [];
+  }
+  return readFileSync(path, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+}
+export {
+  unique,
+  runInherit,
+  runCaptureAsync,
+  runCapture,
+  readJsonFile,
+  nowIso,
+  getValidationTimeoutMs,
+  fileLines
+};

package/dist/src/harness-paths.d.ts

@@ -0,0 +1,18 @@
+export declare function resolveHarnessPaths(projectRoot: string): {
+    harnessRoot: string;
+    stateDir: string;
+    artifactsDir: string;
+    logsDir: string;
+    binDir: string;
+    hooksDir: string;
+    validationDir: string;
+    taskConfigPath: string;
+    sessionPath: string;
+    monorepoRoot: string;
+    tsApiTestsDir: string;
+    taskRepoCommitsPath: string;
+    baseRepoPinsPath: string;
+    failedApproachesPath: string;
+    agentProfilePath: string;
+    reviewProfilePath: string;
+};

package/dist/src/harness-paths.js

@@ -0,0 +1,141 @@
+// @bun
+// packages/core/src/harness-paths.ts
+import { resolve as resolve3 } from "path";
+
+// packages/core/src/layout.ts
+import { resolve as resolve2 } from "path";
+import {
+  RIG_ARTIFACTS_DIRNAME,
+  RIG_DEFINITION_DIRNAME,
+  RIG_STATE_DIRNAME
+} from "@rig/contracts";
+
+// packages/core/src/checkout-root.ts
+import { dirname, resolve } from "path";
+import { existsSync } from "fs";
+function findNearestGitCheckoutRoot(startDir) {
+  let current = resolve(startDir);
+  for (;; ) {
+    if (existsSync(resolve(current, ".git")))
+      return current;
+    const parent = dirname(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+function resolveCheckoutRoot(projectRoot) {
+  const normalizedProjectRoot = resolve(projectRoot);
+  const explicit = process.env.MONOREPO_ROOT?.trim();
+  if (explicit) {
+    const explicitRoot = resolve(explicit);
+    const gitRoot = findNearestGitCheckoutRoot(explicitRoot);
+    if (gitRoot)
+      return gitRoot;
+    throw new Error(`MONOREPO_ROOT points to ${explicitRoot}, but no git checkout was found there or above it.`);
+  }
+  return findNearestGitCheckoutRoot(normalizedProjectRoot) ?? normalizedProjectRoot;
+}
+
+// packages/core/src/layout.ts
+var resolveMonorepoRoot = resolveCheckoutRoot;
+function resolveRuntimeWorkspaceLayout(workspaceDir) {
+  const root = resolve2(workspaceDir);
+  const rigRoot = resolve2(root, ".rig");
+  const logsDir = resolve2(rigRoot, "logs");
+  const stateDir = resolve2(rigRoot, "state");
+  const runtimeDir = resolve2(rigRoot, "runtime");
+  const binDir = resolve2(rigRoot, "bin");
+  return {
+    workspaceDir: root,
+    rigRoot,
+    stateDir,
+    logsDir,
+    artifactsRoot: resolve2(root, RIG_ARTIFACTS_DIRNAME),
+    runtimeDir,
+    homeDir: resolve2(rigRoot, "home"),
+    tmpDir: resolve2(rigRoot, "tmp"),
+    cacheDir: resolve2(rigRoot, "cache"),
+    sessionDir: resolve2(rigRoot, "session"),
+    binDir,
+    distDir: resolve2(rigRoot, "dist"),
+    pluginBinDir: resolve2(binDir, "plugins"),
+    contextPath: resolve2(rigRoot, "runtime-context.json"),
+    controlPlaneEventsFile: resolve2(logsDir, "control-plane.events.jsonl")
+  };
+}
+function resolveActiveRuntimeWorkspaceRoot(_monorepoRoot) {
+  const explicit = process.env.RIG_TASK_WORKSPACE?.trim();
+  if (!explicit) {
+    throw new Error("No active runtime workspace. Set RIG_TASK_WORKSPACE or provision a task runtime first.");
+  }
+  return resolve2(explicit);
+}
+function resolveRigLayout(projectRoot) {
+  const monorepoRoot = resolveMonorepoRoot(projectRoot);
+  const definitionRoot = resolve2(projectRoot, RIG_DEFINITION_DIRNAME);
+  const runtimeWorkspaceRoot = resolveActiveRuntimeWorkspaceRoot(monorepoRoot);
+  const runtimeLayout = resolveRuntimeWorkspaceLayout(runtimeWorkspaceRoot);
+  const policyDir = resolve2(definitionRoot, "policy");
+  return {
+    projectRoot,
+    monorepoRoot,
+    definitionRoot,
+    runtimeWorkspaceRoot,
+    stateRoot: runtimeLayout.rigRoot,
+    artifactsRoot: runtimeLayout.artifactsRoot,
+    configPath: resolve2(definitionRoot, "config.sh"),
+    taskConfigPath: resolve2(runtimeWorkspaceRoot, ".rig", "task-config.json"),
+    policyDir,
+    policyFile: resolve2(policyDir, "policy.json"),
+    pluginsDir: resolve2(definitionRoot, "plugins"),
+    hooksDir: resolve2(definitionRoot, "hooks"),
+    toolsDir: resolve2(definitionRoot, "tools"),
+    templatesDir: resolve2(definitionRoot, "templates"),
+    validationDir: resolve2(definitionRoot, "validation"),
+    stateDir: runtimeLayout.stateDir,
+    logsDir: runtimeLayout.logsDir,
+    notificationsDir: resolve2(definitionRoot, "notifications"),
+    runtimeDir: runtimeLayout.runtimeDir,
+    distDir: runtimeLayout.distDir,
+    binDir: runtimeLayout.binDir,
+    pluginBinDir: runtimeLayout.pluginBinDir,
+    keybindingsPath: resolve2(definitionRoot, "keybindings.json"),
+    controlPlaneEventsFile: runtimeLayout.controlPlaneEventsFile
+  };
+}
+
+// packages/core/src/harness-paths.ts
+function resolveHarnessPaths(projectRoot) {
+  const hasRuntimeWorkspace = Boolean(process.env.RIG_TASK_WORKSPACE?.trim());
+  const monorepoRoot = resolveCheckoutRoot(projectRoot);
+  const harnessRoot = resolve3(projectRoot, "rig");
+  const stateRoot = resolve3(projectRoot, ".rig");
+  const layout = hasRuntimeWorkspace ? resolveRigLayout(projectRoot) : null;
+  const stateDir = layout?.stateDir ?? resolve3(stateRoot, "state");
+  const logsDir = layout?.logsDir ?? resolve3(stateRoot, "logs");
+  const artifactsDir = layout?.artifactsRoot ?? resolve3(monorepoRoot, "artifacts");
+  const taskConfigPath = layout?.taskConfigPath ?? resolve3(monorepoRoot, ".rig", "task-config.json");
+  const binDir = layout?.binDir ?? resolve3(stateRoot, "bin");
+  return {
+    harnessRoot,
+    stateDir: process.env.RIG_STATE_DIR || stateDir,
+    artifactsDir,
+    logsDir: process.env.RIG_LOGS_DIR || logsDir,
+    binDir,
+    hooksDir: resolve3(harnessRoot, "hooks"),
+    validationDir: resolve3(harnessRoot, "validation"),
+    taskConfigPath,
+    sessionPath: process.env.RIG_SESSION_FILE || resolve3(stateRoot, "session", "session.json"),
+    monorepoRoot,
+    tsApiTestsDir: process.env.TS_API_TESTS_DIR || resolve3(monorepoRoot, "TSAPITests"),
+    taskRepoCommitsPath: resolve3(stateDir, "task-repo-commits.json"),
+    baseRepoPinsPath: resolve3(stateDir, "base-repo-pins.json"),
+    failedApproachesPath: resolve3(stateDir, "failed_approaches.md"),
+    agentProfilePath: resolve3(stateDir, "agent-profile.json"),
+    reviewProfilePath: resolve3(stateDir, "review-profile.json")
+  };
+}
+export {
+  resolveHarnessPaths
+};

package/dist/src/hook-materializer.d.ts

@@ -0,0 +1,72 @@
+import type { HookEvent, HookRegistration } from "@rig/contracts";
+export interface PluginHookEntry {
+    /** The plugin that owns this hook. Used as the `_rigPlugin` marker. */
+    pluginName: string;
+    /** The plugin's hook registration. Either `command` must be set or the
+     *  entry must be marked `typed`; hooks with neither (pure metadata) are
+     *  skipped during materialization. */
+    hook: HookRegistration;
+    /** True when the plugin ships a typed implementation for this hook via
+     *  definePlugin runtime fields (`{ hooks: { [id]: fn } }`). The
+     *  materializer then writes a shim command that routes the invocation
+     *  through `control-plane/hook-runner.ts` instead of requiring a raw
+     *  `command` string. */
+    typed?: boolean;
+}
+/**
+ * Resolve the path to the typed-hook runner entrypoint.
+ *
+ * Workspace/dev checkouts (and consumer projects with `@rig/runtime` in
+ * node_modules of THIS process) resolve the sibling source file directly.
+ * When that file isn't on disk (e.g. running from a compiled binary whose
+ * modules live under the virtual $bunfs root), fall back to the consumer
+ * project's own node_modules via `$CLAUDE_PROJECT_DIR` — Claude Code expands
+ * that variable when it runs the hook command.
+ */
+export declare function resolveHookRunnerPath(): string;
+/**
+ * Build the shell shim command for a typed hook. The command invokes the
+ * hook-runner, which loads the project's rig config, finds the plugin's
+ * typed implementation, and bridges stdin/stdout to the hook protocol.
+ * `--event` is informational (the runner trusts the metadata registration);
+ * `--plugin`/`--hook`/`--project-root` are the runner's actual inputs.
+ */
+export declare function buildTypedHookShimCommand(pluginName: string, hook: HookRegistration, projectRoot: string): string;
+export type SessionHookAdapterResult = {
+    readonly adapterId: "claude-code";
+    readonly status: "materialized";
+    readonly path: string;
+    readonly events: readonly HookEvent[];
+} | {
+    readonly adapterId: "pi";
+    readonly status: "skipped";
+    readonly reason: string;
+};
+export interface AgentSessionHookAdapter {
+    readonly id: "claude-code" | "pi";
+    materialize(projectRoot: string, entries: readonly PluginHookEntry[]): SessionHookAdapterResult;
+}
+export declare function createPiNoopSessionHookAdapter(): AgentSessionHookAdapter;
+export declare function createClaudeCodeSessionHookAdapter(): AgentSessionHookAdapter;
+export type AgentSessionHookAdapterEnv = Record<string, string | undefined>;
+export declare function defaultAgentSessionHookAdapters(env?: AgentSessionHookAdapterEnv): readonly AgentSessionHookAdapter[];
+export declare function materializeSessionHookAdapters(projectRoot: string, entries: readonly PluginHookEntry[], adapters?: readonly AgentSessionHookAdapter[]): readonly SessionHookAdapterResult[];
+/**
+ * Materialize plugin-contributed hooks into `.claude/settings.json` via the
+ * Claude Code session-hook adapter.
+ *
+ * Removes any previously-materialized plugin entries (marked with
+ * `_rigPlugin`) before re-inserting the current set. Operator-authored
+ * entries (without the marker) are preserved untouched. The function is
+ * idempotent — running it twice with the same input is a no-op.
+ *
+ * @returns the absolute path to the settings file that was written.
+ */
+export declare function materializeHooks(projectRoot: string, entries: readonly PluginHookEntry[]): string;
+export type ApplyClaudeCodeSessionHooksOptions = {
+    readonly replacePluginOwned?: boolean;
+};
+export declare function applyClaudeCodeSessionHooksToSettings(existing: Record<string, unknown>, entries: readonly PluginHookEntry[], projectRoot: string, options?: ApplyClaudeCodeSessionHooksOptions): {
+    readonly settings: Record<string, unknown>;
+    readonly events: readonly HookEvent[];
+};

package/dist/src/hook-materializer.js

@@ -0,0 +1,281 @@
+// @bun
+// packages/core/src/hook-materializer.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { dirname, resolve as resolve2 } from "path";
+
+// packages/core/src/hook-runtime.ts
+import { appendFileSync, existsSync, mkdirSync, readFileSync, realpathSync, writeSync } from "fs";
+import { resolve } from "path";
+import { RIG_DEFINITION_DIRNAME, RIG_STATE_DIRNAME } from "@rig/contracts";
+function bunRuntime() {
+  const runtime = globalThis;
+  return runtime.Bun;
+}
+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 ?? "";
+function normalizeExecutablePath(candidate) {
+  if (!candidate) {
+    return "";
+  }
+  const normalized = resolve(candidate);
+  if (!existsSync(normalized)) {
+    return "";
+  }
+  try {
+    return realpathSync(normalized);
+  } catch {
+    return normalized;
+  }
+}
+function looksLikeRuntimeGateway(candidate) {
+  const normalized = resolve(candidate).replace(/\\/g, "/");
+  return normalized.includes("/.rig/bin/") || normalized.endsWith("/rig-shell") || normalized.endsWith("/rig-agent");
+}
+function resolveBunBinaryPath() {
+  const explicit = normalizeExecutablePath(process.env.RIG_BUN_PATH?.trim());
+  if (explicit) {
+    return explicit;
+  }
+  const bunWhich = bunRuntime()?.which?.("bun");
+  const pathBun = normalizeExecutablePath(bunWhich?.trim());
+  if (pathBun && !looksLikeRuntimeGateway(pathBun)) {
+    return pathBun;
+  }
+  const home = process.env.HOME?.trim();
+  const fallbackCandidates = [
+    home ? resolve(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 resolveBunCliInvocation() {
+  if (BAKED_BUN_PATH) {
+    return {
+      command: BAKED_BUN_PATH,
+      env: {}
+    };
+  }
+  if (process.env.RIG_BUN_PATH?.trim()) {
+    return {
+      command: process.env.RIG_BUN_PATH.trim(),
+      env: {}
+    };
+  }
+  try {
+    const systemBun = resolveBunBinaryPath();
+    return {
+      command: systemBun,
+      env: {}
+    };
+  } catch {}
+  if (process.execPath?.trim()) {
+    return {
+      command: process.execPath,
+      env: { BUN_BE_BUN: "1" }
+    };
+  }
+  return { command: "bun", env: {} };
+}
+
+// packages/core/src/hook-materializer.ts
+var MARKER_PLUGIN = "_rigPlugin";
+var MARKER_HOOK_ID = "_rigHookId";
+function matcherToString(matcher) {
+  if (matcher.kind === "all")
+    return;
+  if (matcher.kind === "tool")
+    return matcher.name;
+  return matcher.pattern;
+}
+function isPluginOwned(cmd) {
+  return typeof cmd[MARKER_PLUGIN] === "string";
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+function resolveHookRunnerPath() {
+  const sibling = resolve2(import.meta.dirname, "hook-runner.ts");
+  if (existsSync2(sibling)) {
+    return sibling;
+  }
+  return "$CLAUDE_PROJECT_DIR/node_modules/@rig/core/src/hook-runner.ts";
+}
+function buildTypedHookShimCommand(pluginName, hook, projectRoot) {
+  const runnerPath = resolveHookRunnerPath();
+  const runnerArg = runnerPath.startsWith("$CLAUDE_PROJECT_DIR") ? `"${runnerPath}"` : shellQuote(runnerPath);
+  const bun = resolveBunCliInvocation();
+  const envPrefix = Object.entries(bun.env).map(([key, value]) => `${key}=${shellQuote(value)}`).join(" ");
+  const parts = [
+    envPrefix,
+    shellQuote(bun.command),
+    runnerArg,
+    "--plugin",
+    shellQuote(pluginName),
+    "--hook",
+    shellQuote(hook.id),
+    "--event",
+    shellQuote(hook.event),
+    "--project-root",
+    shellQuote(projectRoot)
+  ].filter(Boolean);
+  return parts.join(" ");
+}
+function createPiNoopSessionHookAdapter() {
+  return {
+    id: "pi",
+    materialize() {
+      return {
+        adapterId: "pi",
+        status: "skipped",
+        reason: "Pi sessions do not consume Claude Code settings hooks."
+      };
+    }
+  };
+}
+function createClaudeCodeSessionHookAdapter() {
+  return {
+    id: "claude-code",
+    materialize(projectRoot, entries) {
+      return writeClaudeCodeHookSettings(projectRoot, entries);
+    }
+  };
+}
+function defaultAgentSessionHookAdapters(env = process.env) {
+  if (env.RIG_AGENT_SESSION_HOOK_ADAPTER === "claude-code") {
+    return [createClaudeCodeSessionHookAdapter()];
+  }
+  if (env.RIG_AGENT_SESSION_HOOK_ADAPTER === "pi" || typeof env.PI_CODING_AGENT_SESSION_DIR === "string" && env.PI_CODING_AGENT_SESSION_DIR.trim().length > 0 || env.RIG_RUN_PROCESS === "1") {
+    return [createPiNoopSessionHookAdapter()];
+  }
+  return [createClaudeCodeSessionHookAdapter()];
+}
+function materializeSessionHookAdapters(projectRoot, entries, adapters = [createClaudeCodeSessionHookAdapter()]) {
+  return adapters.map((adapter) => adapter.materialize(projectRoot, entries));
+}
+function materializeHooks(projectRoot, entries) {
+  const result = createClaudeCodeSessionHookAdapter().materialize(projectRoot, entries);
+  return result.status === "materialized" ? result.path : resolve2(projectRoot, ".claude", "settings.json");
+}
+function applyClaudeCodeSessionHooksToSettings(existing, entries, projectRoot, options = {}) {
+  const hooks = typeof existing.hooks === "object" && existing.hooks !== null && !Array.isArray(existing.hooks) ? existing.hooks : {};
+  const replacePluginOwned = options.replacePluginOwned ?? true;
+  if (replacePluginOwned) {
+    for (const event of Object.keys(hooks)) {
+      const groups = hooks[event] ?? [];
+      const cleaned = [];
+      for (const group of groups) {
+        const operatorHooks = group.hooks.filter((h) => !isPluginOwned(h));
+        if (operatorHooks.length > 0) {
+          cleaned.push({ ...group, hooks: operatorHooks });
+        }
+      }
+      if (cleaned.length > 0) {
+        hooks[event] = cleaned;
+      } else {
+        delete hooks[event];
+      }
+    }
+  }
+  const materializedEvents = new Set;
+  for (const { pluginName, hook, typed } of entries) {
+    const command = hook.command ?? (typed ? buildTypedHookShimCommand(pluginName, hook, projectRoot) : undefined);
+    if (!command) {
+      continue;
+    }
+    const event = hook.event;
+    materializedEvents.add(event);
+    const matcherString = matcherToString(hook.matcher);
+    const groups = hooks[event] ??= [];
+    let group = groups.find((g) => g.matcher === matcherString);
+    if (!group) {
+      group = matcherString === undefined ? { hooks: [] } : { matcher: matcherString, hooks: [] };
+      groups.push(group);
+    }
+    const alreadyPresent = group.hooks.some((candidate) => candidate[MARKER_PLUGIN] === pluginName && candidate[MARKER_HOOK_ID] === hook.id);
+    if (alreadyPresent) {
+      continue;
+    }
+    group.hooks.push({
+      type: "command",
+      command,
+      [MARKER_PLUGIN]: pluginName,
+      [MARKER_HOOK_ID]: hook.id
+    });
+  }
+  const next = { ...existing };
+  if (Object.keys(hooks).length > 0) {
+    next.hooks = hooks;
+  } else {
+    delete next.hooks;
+  }
+  return { settings: next, events: [...materializedEvents].sort() };
+}
+function writeClaudeCodeHookSettings(projectRoot, entries) {
+  const settingsPath = resolve2(projectRoot, ".claude", "settings.json");
+  const existing = existsSync2(settingsPath) ? safeReadJson(settingsPath) : {};
+  const { settings, events } = applyClaudeCodeSessionHooksToSettings(existing, entries, projectRoot);
+  mkdirSync2(dirname(settingsPath), { recursive: true });
+  writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
+`, "utf-8");
+  return {
+    adapterId: "claude-code",
+    status: "materialized",
+    path: settingsPath,
+    events
+  };
+}
+function safeReadJson(path) {
+  try {
+    return JSON.parse(readFileSync2(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+export {
+  resolveHookRunnerPath,
+  materializeSessionHookAdapters,
+  materializeHooks,
+  defaultAgentSessionHookAdapters,
+  createPiNoopSessionHookAdapter,
+  createClaudeCodeSessionHookAdapter,
+  buildTypedHookShimCommand,
+  applyClaudeCodeSessionHooksToSettings
+};

package/dist/src/hook-protocol.d.ts

@@ -0,0 +1,2 @@
+export type { HookInput, ParsedHookInput, TypedHookOptions } from "./hook-runtime";
+export { BAKED_BUN_PATH, BAKED_POLICY_CONTENT, BAKED_PROJECT_ROOT, BAKED_STATE_DIR, BAKED_TASK_CONFIG, BAKED_TASK_ID, BAKED_TASK_SCOPES, block, buildPluginHookContext, escapeRegExp, extractToolFilePaths, hookResultToProtocol, isTestFilePath, readHookInput, resolveBunCli, resolveBunCliInvocation, resolvePolicyContent, resolveProjectRoot, resolveTaskConfig, resolveTaskIdForHook, resolveTaskScopes, runTypedHook, } from "./hook-runtime";