@agimon-ai/po-hook 0.0.0-alpha.0

package/dist/hookModules-GoRDG8mg.mjs

@@ -0,0 +1,749 @@
+import fs from "node:fs";
+import { doomConfigCandidates } from "@agimon-ai/po-config/layeredConfig";
+import { parse } from "yaml";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { createDoomTelemetry } from "@agimon-ai/po-telemetry";
+import fs$1 from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+//#endregion
+//#region src/services/hookDecisions/index.ts
+function decisionsFrom(outcomes) {
+	return outcomes.flatMap((outcome) => outcome.decision ? [outcome.decision] : []);
+}
+function failuresFrom(outcomes) {
+	return outcomes.flatMap((outcome) => outcome.failure ? [outcome.failure] : []);
+}
+/** Both spellings a hook may use to refuse the call it observed. */
+function isDenied(decision) {
+	return decision?.decision === "block" || decision?.hookSpecificOutput?.permissionDecision === "deny";
+}
+function decisionReason(decision) {
+	return decision?.reason ?? decision?.hookSpecificOutput?.reason;
+}
+/** Context a hook wants added to the conversation rather than used to block. */
+function additionalContextsFrom(decisions) {
+	return decisions.map((decision) => decision.hookSpecificOutput?.additionalContext).filter((value) => Boolean(value));
+}
+/** What a post-tool hook has to say, whichever field it said it in. */
+function toolResultMessages(decisions) {
+	return decisions.map((decision) => decision.hookSpecificOutput?.additionalContext ?? decisionReason(decision)).filter((value) => Boolean(value));
+}
+/**
+* A guardrail that never ran looks exactly like one that passed, so the agent is
+* told which checks were missed and what its options are.
+*/
+function hookFailureMessage(failures) {
+	return [
+		"One or more repository hooks did not complete, so their checks were not applied:",
+		...failures.map((failure) => `- ${failure.command}: ${failure.message}`),
+		"Options:",
+		"- Inspect the hook command or configuration and rerun after correcting it.",
+		"- Continue only if the missed advisory check is acceptable.",
+		"- Ask the user before bypassing a hook that may enforce a guardrail."
+	].join("\n");
+}
+//#endregion
+//#region src/constants/hookDocuments.ts
+const HOOKS_FILE = "hooks.yaml";
+const FILE_NOT_FOUND_ERROR = "ENOENT";
+const REGISTRY_SOURCE_ATTRIBUTE = "repository";
+//#endregion
+//#region src/constants/telemetry.ts
+const HOOK_TELEMETRY_EVENT = {
+	hookFailed: "doom_pi_hook.failed",
+	hookRegistryReadFailed: "doom_pi_hook.registry_read_failed"
+};
+//#endregion
+//#region src/services/toolNames/index.ts
+/**
+* Pi's tool names translated into the Claude names hook matchers are written
+* against.
+*
+* Hook authors write `matcher: Bash`, and Pi reports `bash`, so a matcher would
+* never fire without this. Only this direction belongs here: rewriting Claude
+* names for Pi is an agent-definition concern the harness owns.
+*/
+const PI_TO_CLAUDE = /* @__PURE__ */ new Map([
+	["read", "Read"],
+	["edit", "Edit"],
+	["write", "Write"],
+	["bash", "Bash"],
+	["find", "Glob"],
+	["grep", "Grep"],
+	["subagent", "Agent"]
+]);
+/** The Claude name a hook matcher expects for a tool Pi just ran. */
+function toClaudeToolName(tool) {
+	return PI_TO_CLAUDE.get(tool) ?? tool;
+}
+/** Whether a matcher, if the row declares one, accepts the tool that fired. */
+function matchesTool(matcher, toolName) {
+	if (!toolName || !matcher) return true;
+	return new RegExp(matcher).test(toClaudeToolName(toolName));
+}
+//#endregion
+//#region src/services/hookRegistry/index.ts
+/**
+* Identity of a set of registry sources, for callers that cache the parse.
+*
+* Keyed on contents rather than mtime, so it stays correct for an in-place
+* rewrite and needs no invalidation hook. Reading both files is cheap; parsing
+* is what a cache built on this skips.
+*/
+function registryCacheKey(sources) {
+	return sources.map((source) => `${source.registryId ?? source.baseDirectory} ${source.text}`).join(" ");
+}
+/**
+* Flattens parsed registry documents into sorted rows, keeping only bindings
+* that declare a `pi` frontend.
+*
+* A later source replaces the group of the same id outright rather than merging
+* into it, so a repository that redefines a group owns it completely.
+*/
+function registryEntries(sources) {
+	const groups = /* @__PURE__ */ new Map();
+	let position = 0;
+	for (const source of sources) for (const [groupId, group] of Object.entries(source.document.groups ?? {})) {
+		const entries = [];
+		for (const [rowIndex, hook] of (group.hooks ?? []).entries()) {
+			position += 1;
+			if (!hook.pi) continue;
+			const registryId = source.registryId ?? path.join(source.baseDirectory, ".po/hooks.yaml");
+			const rowId = String(rowIndex);
+			const attribution = `${registryId}: group ${groupId}, row ${rowId}, event ${hook.event}`;
+			const binding = hook.pi;
+			const hasCommand = binding.command !== void 0;
+			const hasModule = binding.module !== void 0;
+			if (hasCommand === hasModule) throw new Error(`${attribution}: declare exactly one of command or module`);
+			const target = hasCommand ? binding.command : binding.module;
+			if (typeof target !== "string" || !target.trim() || target.includes("\0")) throw new Error(`${attribution}: command or module must be a nonempty string without NUL`);
+			if (binding.timeout !== void 0 && (!Number.isFinite(binding.timeout) || binding.timeout <= 0)) throw new Error(`${attribution}: timeout must be a positive finite number`);
+			if (hasModule && ![
+				"SessionStart",
+				"PreToolUse",
+				"PostToolUse",
+				"Stop"
+			].includes(hook.event)) throw new Error(`${attribution}: unsupported module event`);
+			entries.push({
+				matcher: binding.matcher,
+				timeout: binding.timeout,
+				skipInSubagent: binding.skipInSubagent,
+				...hasModule ? { module: path.resolve(source.baseDirectory, target) } : { command: target },
+				registryId,
+				rowId,
+				event: hook.event,
+				order: hook.pi.order ?? 0,
+				position,
+				groupId,
+				core: group.core === true,
+				baseDirectory: source.baseDirectory
+			});
+		}
+		groups.set(groupId, entries);
+	}
+	const entries = [...groups.values()].flat();
+	entries.sort((left, right) => left.order - right.order || left.position - right.position);
+	return entries;
+}
+/**
+* The rows one dispatch runs.
+*
+* Group selection changes when /mode switches mid-session, so inclusion is
+* applied per call rather than being baked into a cached parse. Core groups
+* always load; the rest are gated by the layers the harness resolved.
+*/
+function selectRegistryHooks(entries, selection) {
+	const allowed = selection.allowedGroups === void 0 ? void 0 : new Set(selection.allowedGroups);
+	return entries.filter((entry) => entry.core || !allowed || allowed.has(entry.groupId)).filter((entry) => entry.event === selection.event).filter((entry) => !(entry.skipInSubagent && selection.inSubagent)).filter((entry) => matchesTool(entry.matcher, selection.toolName)).map((entry) => ({
+		hook: entry.module === void 0 ? {
+			command: entry.command,
+			timeout: entry.timeout
+		} : {
+			module: entry.module,
+			timeout: entry.timeout
+		},
+		registryId: entry.registryId,
+		groupId: entry.groupId,
+		rowId: entry.rowId,
+		event: entry.event,
+		root: entry.baseDirectory
+	}));
+}
+//#endregion
+//#region src/services/hookDocuments/index.ts
+function reason(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function isMissingFile(error) {
+	return error?.code === FILE_NOT_FOUND_ERROR;
+}
+/**
+* Reads `.po/hooks.yaml` from the global config directory and the repository,
+* and the plugin hook configs the harness resolved.
+*
+* Every file is re-read on every dispatch: it costs almost nothing and keeps an
+* in-place rewrite visible, which an mtime check would miss when two writes land
+* inside the same filesystem timestamp granularity. Both caches are keyed on
+* contents instead, so parsing — the expensive half — is what they skip.
+*/
+function createHookDocumentReader(options = {}) {
+	const readFile = options.readFile ?? ((filePath) => fs.promises.readFile(filePath, "utf8"));
+	const telemetry = options.telemetry;
+	const warn = options.warn ?? ((message) => void process.stderr.write(message));
+	let cachedRegistryKey;
+	let cachedRegistryEntries = [];
+	const pluginConfigCache = /* @__PURE__ */ new Map();
+	const readSource = async (candidate) => {
+		try {
+			return {
+				registryId: candidate.filePath,
+				baseDirectory: candidate.baseDirectory,
+				text: await readFile(candidate.filePath)
+			};
+		} catch (error) {
+			if (isMissingFile(error)) return void 0;
+			throw error;
+		}
+	};
+	const parseSources = (sources) => {
+		const key = registryCacheKey(sources);
+		if (cachedRegistryKey === key) return cachedRegistryEntries;
+		cachedRegistryEntries = registryEntries(sources.map((source) => ({
+			registryId: source.registryId,
+			baseDirectory: source.baseDirectory,
+			document: parse(source.text) ?? {}
+		})));
+		cachedRegistryKey = key;
+		return cachedRegistryEntries;
+	};
+	return {
+		async registry(repoRoot) {
+			const candidates = doomConfigCandidates(HOOKS_FILE, repoRoot, options.homeDirectory);
+			const registryPath = candidates.map((candidate) => candidate.filePath).join(" and ");
+			try {
+				const sources = (await Promise.all(candidates.map(readSource))).filter((source) => source !== void 0);
+				return { entries: parseSources(sources) };
+			} catch (error) {
+				telemetry?.recordError(HOOK_TELEMETRY_EVENT.hookRegistryReadFailed, error, { "hook.registry.source": REGISTRY_SOURCE_ATTRIBUTE });
+				warn(`[pi-hook] could not read ${registryPath}: ${reason(error)}\n`);
+				return {
+					entries: [],
+					failure: {
+						command: registryPath,
+						message: reason(error),
+						reason: "registry_read"
+					}
+				};
+			}
+		},
+		async plugins(sources) {
+			const documents = [];
+			const failures = [];
+			for (const source of sources) try {
+				const text = await readFile(source.configPath);
+				const cached = pluginConfigCache.get(source.configPath);
+				const config = cached?.source === text ? cached.config : JSON.parse(text);
+				pluginConfigCache.set(source.configPath, {
+					source: text,
+					config
+				});
+				documents.push({
+					pluginRoot: source.pluginRoot,
+					config
+				});
+			} catch (error) {
+				failures.push({
+					command: source.configPath,
+					message: reason(error),
+					reason: "plugin_config"
+				});
+			}
+			return {
+				documents,
+				failures
+			};
+		}
+	};
+}
+//#endregion
+//#region src/services/hookPayload/index.ts
+/** The payload shape a Claude Code session hook is written against. */
+function toolHookPayload(event, hookEventName, repoRoot, sessionId, identity = {}) {
+	return {
+		session_id: sessionId,
+		transcript_path: "",
+		cwd: repoRoot,
+		hook_event_name: hookEventName,
+		tool_name: toClaudeToolName(event.toolName),
+		tool_input: event.input,
+		...event.type === "tool_result" ? { tool_response: {
+			success: !event.isError,
+			content: event.content
+		} } : {},
+		...identity.parentSessionId === void 0 ? {} : { parent_session_id: identity.parentSessionId },
+		...identity.agent === void 0 ? {} : { agent_type: identity.agent }
+	};
+}
+/** Session lifecycle hooks observe no tool, so they only need where and who. */
+function sessionHookPayload(sessionId, repoRoot) {
+	return {
+		session_id: sessionId,
+		cwd: repoRoot
+	};
+}
+//#endregion
+//#region src/constants/hookRunner.ts
+const HOOK_SHELL = "/bin/bash";
+const HOOK_TERMINATION_GRACE_MS = 2e3;
+const MILLISECONDS_PER_SECOND = 1e3;
+const PROCESS_NOT_FOUND_ERROR = "ESRCH";
+const WINDOWS_PLATFORM = "win32";
+const LINE_BREAK = /\r?\n/;
+//#endregion
+//#region src/services/hookRunner/index.ts
+function errorCode(error) {
+	return error instanceof Error && "code" in error ? String(error.code) : void 0;
+}
+/**
+* Runs advisory hook commands through bash and reports what each one decided.
+*
+* A hook is a command the repository owns, so it is spawned in its own process
+* group and terminated as one: a hook that starts a server and stalls should
+* not leave the server behind when the timeout fires.
+*/
+function createBashHookRunner(options = {}) {
+	const spawn$1 = options.spawn ?? spawn;
+	const telemetry = options.telemetry;
+	const warn = options.warn ?? ((message) => void process.stderr.write(message));
+	const useProcessGroup = (options.platform ?? process.platform) !== WINDOWS_PLATFORM;
+	const signalOwnedProcess = (pid, kill) => {
+		return (signal) => {
+			try {
+				if (useProcessGroup && pid !== void 0) {
+					process.kill(-pid, signal);
+					return;
+				}
+				kill(signal);
+			} catch (error) {
+				if (errorCode(error) !== "ESRCH") process.emitWarning(`Could not signal repository hook process: ${String(error)}`);
+			}
+		};
+	};
+	return { run(hook, payload, runOptions) {
+		const timeoutSeconds = hook.timeout ?? 10;
+		const environment = options.env ?? process.env;
+		return new Promise((resolve) => {
+			const child = spawn$1(HOOK_SHELL, ["-c", hook.command], {
+				cwd: runOptions.repoRoot,
+				env: {
+					...environment,
+					CLAUDE_PROJECT_DIR: runOptions.repoRoot,
+					CODEX_REPO_ROOT: runOptions.repoRoot,
+					ORIGINAL_REPO_PATH: environment.ORIGINAL_REPO_PATH ?? runOptions.repoRoot,
+					...runOptions.pluginRoot ? { CLAUDE_PLUGIN_ROOT: runOptions.pluginRoot } : {}
+				},
+				stdio: [
+					"pipe",
+					"pipe",
+					"pipe"
+				],
+				detached: useProcessGroup
+			});
+			let stdout = "";
+			let stderr = "";
+			let settled = false;
+			let timedOut = false;
+			let childExited = false;
+			let timeoutExitCode = null;
+			let stdinError;
+			let escalationTimer;
+			const signal = signalOwnedProcess(child.pid, (value) => child.kill(value));
+			const ownedProcessIsAlive = () => {
+				if (!useProcessGroup || child.pid === void 0) return !childExited;
+				try {
+					process.kill(-child.pid, 0);
+					return true;
+				} catch (error) {
+					return errorCode(error) !== PROCESS_NOT_FOUND_ERROR;
+				}
+			};
+			const finish = (outcome = {}) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timer);
+				if (escalationTimer) clearTimeout(escalationTimer);
+				resolve(outcome);
+			};
+			const finishTimeout = () => {
+				const message = `Hook timed out after ${timeoutSeconds} seconds.`;
+				telemetry?.recordWarning(HOOK_TELEMETRY_EVENT.hookFailed, message, {
+					"hook.reason": "timeout",
+					"hook.exit_code": timeoutExitCode ?? -1
+				});
+				warn(`[pi-hook] advisory hook timed out: ${hook.command}\n${stderr}`);
+				finish({ failure: {
+					command: hook.command,
+					message,
+					reason: "timeout"
+				} });
+			};
+			const timer = setTimeout(() => {
+				timedOut = true;
+				signal("SIGTERM");
+				escalationTimer = setTimeout(() => {
+					if (ownedProcessIsAlive()) signal("SIGKILL");
+					finishTimeout();
+				}, HOOK_TERMINATION_GRACE_MS);
+			}, timeoutSeconds * MILLISECONDS_PER_SECOND);
+			child.stdin?.on("error", (error) => {
+				if (settled || timedOut || errorCode(error) === "EPIPE") return;
+				stdinError = error;
+			});
+			child.stdout?.on("data", (chunk) => {
+				stdout += chunk.toString();
+			});
+			child.stderr?.on("data", (chunk) => {
+				stderr += chunk.toString();
+			});
+			child.once("error", (error) => {
+				if (timedOut) return;
+				telemetry?.recordError(HOOK_TELEMETRY_EVENT.hookFailed, error, { "hook.reason": "spawn_failed" });
+				warn(`[pi-hook] advisory hook failed: ${error.message}\n`);
+				finish({ failure: {
+					command: hook.command,
+					message: error.message,
+					reason: "spawn_failed"
+				} });
+			});
+			child.once("exit", (code) => {
+				childExited = true;
+				timeoutExitCode = code;
+				if (timedOut) return;
+				if (code !== 0) {
+					const message = stderr.trim() || `Advisory hook exited with code ${code ?? "unknown"}`;
+					telemetry?.recordWarning(HOOK_TELEMETRY_EVENT.hookFailed, message, {
+						"hook.reason": "non_zero_exit",
+						"hook.exit_code": code ?? -1
+					});
+					warn(`[pi-hook] advisory hook failed (${code}): ${hook.command}\n${stderr}`);
+					finish({ failure: {
+						command: hook.command,
+						message,
+						reason: "non_zero_exit"
+					} });
+					return;
+				}
+				if (stdinError) {
+					telemetry?.recordError(HOOK_TELEMETRY_EVENT.hookFailed, stdinError, { "hook.reason": "stdin_failed" });
+					warn(`[pi-hook] advisory hook could not write stdin: ${stdinError.message}\n`);
+					finish({ failure: {
+						command: hook.command,
+						message: stdinError.message,
+						reason: "stdin_failed"
+					} });
+					return;
+				}
+				const jsonLine = stdout.trim().split(LINE_BREAK).reverse().find((line) => line.startsWith("{"));
+				if (!jsonLine) {
+					finish();
+					return;
+				}
+				try {
+					finish({ decision: JSON.parse(jsonLine) });
+				} catch (error) {
+					telemetry?.recordWarning(HOOK_TELEMETRY_EVENT.hookFailed, error, { "hook.reason": "invalid_json" });
+					warn(`[pi-hook] advisory hook returned invalid JSON: ${hook.command}\n`);
+					finish({ failure: {
+						command: hook.command,
+						message: error instanceof Error ? error.message : String(error),
+						reason: "invalid_json"
+					} });
+				}
+			});
+			child.stdin?.end(JSON.stringify(payload));
+		});
+	} };
+}
+//#endregion
+//#region src/constants/hookTelemetry.ts
+const SERVICE_NAME = "po-hook";
+const PACKAGE_NAME = "@agimon-ai/po-hook";
+//#endregion
+//#region src/services/hookTelemetry/index.ts
+function createHookTelemetry(options = {}) {
+	const telemetry = createDoomTelemetry({
+		serviceName: SERVICE_NAME,
+		packageName: PACKAGE_NAME,
+		cwd: options.cwd,
+		workspaceRoot: options.workspaceRoot,
+		env: options.env,
+		telemetryFactory: options.telemetryFactory,
+		warn: options.warn,
+		enableLogs: true,
+		enableTraces: true
+	});
+	return {
+		recordError: (event, error, attributes) => telemetry.recordError(event, error, attributes),
+		recordWarning: (event, error, attributes) => telemetry.recordWarning(event, error, attributes)
+	};
+}
+//#endregion
+//#region src/services/pluginHooks/index.ts
+/**
+* The plugin hooks one dispatch runs.
+*
+* Plugin configs are the Claude Code `hooks.json` shape verbatim: an event name
+* maps to groups, each with an optional matcher and a list of commands. Order
+* follows the declaration order of the plugins the harness resolved.
+*/
+function selectPluginHooks(documents, eventName, toolName) {
+	const matches = [];
+	for (const document of documents) for (const group of document.config.hooks?.[eventName] ?? []) {
+		if (!matchesTool(group.matcher, toolName)) continue;
+		for (const hook of group.hooks ?? []) matches.push({
+			hook,
+			root: document.pluginRoot
+		});
+	}
+	return matches;
+}
+//#endregion
+//#region src/constants/hooks.ts
+const HOOK_EVENT = {
+	sessionStart: "SessionStart",
+	preToolUse: "PreToolUse",
+	postToolUse: "PostToolUse",
+	stop: "Stop",
+	sessionEnd: "SessionEnd"
+};
+//#endregion
+//#region src/services/hookModules/index.ts
+function assertHostEffects(instance) {
+	if (instance.hostEffectFailure) throw instance.hostEffectFailure.error;
+}
+const HANDLER_NAMES = [
+	"tool_call",
+	"tool_result",
+	"session_start",
+	"agent_settled",
+	"dispose"
+];
+function object(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateHandlers(value) {
+	if (!object(value) || Object.entries(value).some(([key, handler]) => !HANDLER_NAMES.includes(key) || typeof handler !== "function")) throw new Error("setup must return hook handlers");
+}
+function jsonValue(value, ancestors = /* @__PURE__ */ new Set()) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (typeof value !== "object" || ancestors.has(value)) return false;
+	if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype) return false;
+	ancestors.add(value);
+	const valid = Object.values(value).every((item) => jsonValue(item, ancestors));
+	ancestors.delete(value);
+	return valid;
+}
+function validResult(event, value) {
+	if (value === void 0) return true;
+	if (!object(value)) return false;
+	if (event === "tool_call") return Object.keys(value).every((key) => ["block", "reason"].includes(key)) && (value.block === void 0 || typeof value.block === "boolean") && (value.reason === void 0 || typeof value.reason === "string");
+	if (event !== "tool_result") return false;
+	return Object.keys(value).every((key) => [
+		"content",
+		"details",
+		"isError"
+	].includes(key)) && (value.isError === void 0 || typeof value.isError === "boolean") && (value.details === void 0 || jsonValue(value.details)) && (value.content === void 0 || Array.isArray(value.content) && value.content.every((part) => object(part) && (part.type === "text" && typeof part.text === "string" || part.type === "image" && typeof part.data === "string" && typeof part.mimeType === "string")));
+}
+/** One registry belongs to one session binding, never to the process. */
+function createHookModules(options = {}) {
+	const instances = /* @__PURE__ */ new Map();
+	let descriptor;
+	let closed = false;
+	let disposal;
+	function artifacts() {
+		descriptor ??= (async () => {
+			if (!options.descriptor) return /* @__PURE__ */ new Map();
+			const value = JSON.parse(await fs$1.readFile(options.descriptor.file, "utf8"));
+			if (!object(value) || value.version !== 1 || !Array.isArray(value.modules)) throw new Error("invalid hook module descriptor");
+			const result = /* @__PURE__ */ new Map();
+			for (const entry of value.modules) {
+				if (!object(entry) || typeof entry.source !== "string" || typeof entry.artifact !== "string" || !path.isAbsolute(entry.source) || !path.isAbsolute(entry.artifact) || ![
+					".mjs",
+					".js",
+					".cjs"
+				].includes(path.extname(entry.artifact)) || result.has(entry.source)) throw new Error("invalid hook module artifact mapping");
+				result.set(entry.source, entry.artifact);
+			}
+			return result;
+		})();
+		return descriptor;
+	}
+	async function disposeInstance(instance) {
+		if (!instance.handlers || instance.disposed) return;
+		instance.disposed = true;
+		await instance.handlers.dispose?.();
+	}
+	function contextFor(context, instance, signal) {
+		function assertActive(message) {
+			if (closed || signal.aborted || instance.lifetime.signal.aborted) throw new Error("hook context revoked");
+			if (message && instance.settled) throw new Error("agent_settled cannot send messages");
+		}
+		return {
+			...context,
+			signal,
+			async sendMessage(text, delivery) {
+				assertActive(true);
+				await context.sendMessage(text, delivery);
+			},
+			async appendCustomEntry(type, data) {
+				assertActive(false);
+				await context.appendCustomEntry(type, data);
+			}
+		};
+	}
+	return {
+		async validate(rows) {
+			for (const row of rows) {
+				if (!row.module) continue;
+				try {
+					const artifact = (await artifacts()).get(row.module);
+					if (!artifact) throw new Error("module missing from descriptor");
+					if (!(await fs$1.stat(artifact)).isFile()) throw new Error(`hook artifact is not a file: ${artifact}`);
+				} catch (cause) {
+					throw new Error(`${row.registryId ?? ""}: group ${row.groupId ?? ""}, row ${row.rowId ?? ""}, event ${row.event ?? ""}, module ${row.module}: ${cause instanceof Error ? cause.message : String(cause)}. Fix the hook module, then restart or reopen this session.`, { cause });
+				}
+			}
+		},
+		async invoke(row, event, context, operationSignal) {
+			const source = "module" in row.hook ? row.hook.module : void 0;
+			const failure = (error, timeout = false) => ({ failure: {
+				command: source ?? "",
+				reason: timeout ? "timeout" : "module_failed",
+				message: `${row.registryId ?? ""}: group ${row.groupId ?? ""}, row ${row.rowId ?? ""}, event ${row.event ?? event.type}, module ${source ?? ""}: ${error instanceof Error ? error.message : String(error)}`
+			} });
+			if (!source) return failure(/* @__PURE__ */ new Error("not a module row"));
+			if (closed || context.signal.aborted) return failure(/* @__PURE__ */ new Error("hook session disposed"));
+			const key = `${context.sessionId}\0${source}`;
+			let instance = instances.get(key);
+			if (!instance) {
+				instance = {
+					lifetime: new AbortController(),
+					queue: Promise.resolve(),
+					quarantined: false,
+					settled: false,
+					disposed: false
+				};
+				instances.set(key, instance);
+			}
+			const current = instance;
+			const hostContext = {
+				...context,
+				async sendMessage(text, delivery) {
+					try {
+						await context.sendMessage(text, delivery);
+					} catch (error) {
+						current.hostEffectFailure = { error };
+						throw error;
+					}
+				},
+				async appendCustomEntry(type, data) {
+					try {
+						await context.appendCustomEntry(type, data);
+					} catch (error) {
+						current.hostEffectFailure = { error };
+						throw error;
+					}
+				}
+			};
+			const run = async () => {
+				if (closed || current.quarantined || current.lifetime.signal.aborted) return failure(/* @__PURE__ */ new Error("module quarantined or disposed"));
+				current.hostEffectFailure = void 0;
+				current.settled = event.type === "agent_settled";
+				const controller = new AbortController();
+				const signal = AbortSignal.any([
+					context.signal,
+					current.lifetime.signal,
+					controller.signal,
+					...operationSignal ? [operationSignal] : []
+				]);
+				let timer;
+				let setup = !current.handlers;
+				let timedOut = false;
+				const operation = (async () => {
+					if (!current.handlers) {
+						const artifact = (await artifacts()).get(source);
+						if (!artifact) throw new Error("sync required: module missing from descriptor");
+						const imported = await import(pathToFileURL(artifact).href);
+						if (signal.aborted) throw new Error("hook context aborted");
+						if (!object(imported.default) || typeof imported.default.setup !== "function") throw new Error("module default export must declare setup");
+						const handlers = await imported.default.setup(contextFor(hostContext, current, AbortSignal.any([context.signal, current.lifetime.signal])));
+						validateHandlers(handlers);
+						current.handlers = handlers;
+						if (closed || current.quarantined || signal.aborted) {
+							await disposeInstance(current);
+							return;
+						}
+					}
+					setup = false;
+					const ctx = contextFor(hostContext, current, signal);
+					switch (event.type) {
+						case "tool_call": return current.handlers.tool_call?.(event, ctx);
+						case "tool_result": return current.handlers.tool_result?.(event, ctx);
+						case "session_start": return current.handlers.session_start?.(event, ctx);
+						case "agent_settled": return current.handlers.agent_settled?.(event, ctx);
+					}
+				})();
+				try {
+					const aborted = new Promise((_, reject) => {
+						const abort = () => reject(/* @__PURE__ */ new Error(timedOut ? "hook module timed out" : "hook context aborted"));
+						signal.addEventListener("abort", abort, { once: true });
+						operation.finally(() => signal.removeEventListener("abort", abort)).catch(() => void 0);
+						if (signal.aborted) abort();
+						timer = setTimeout(() => {
+							timedOut = true;
+							controller.abort();
+						}, (row.hook.timeout ?? 10) * 1e3);
+					});
+					const result = await Promise.race([operation, aborted]);
+					assertHostEffects(current);
+					if (!validResult(event.type, result)) return { failure: {
+						...failure(/* @__PURE__ */ new Error("invalid hook result")).failure,
+						reason: "invalid_result"
+					} };
+					return result === void 0 ? {} : { result };
+				} catch (error) {
+					assertHostEffects(current);
+					if (setup || timedOut || signal.aborted) {
+						current.quarantined = true;
+						current.lifetime.abort();
+					}
+					return failure(error, timedOut);
+				} finally {
+					clearTimeout(timer);
+					controller.abort();
+					current.settled = false;
+				}
+			};
+			const invocation = current.queue.then(run);
+			current.queue = invocation.catch(() => void 0);
+			return invocation;
+		},
+		dispose() {
+			disposal ??= (async () => {
+				closed = true;
+				for (const instance of instances.values()) instance.lifetime.abort();
+				await Promise.all([...instances.values()].map(async (instance) => {
+					await instance.queue;
+					await disposeInstance(instance);
+				}));
+			})();
+			return disposal;
+		}
+	};
+}
+//#endregion
+export { decisionsFrom as _, createBashHookRunner as a, isDenied as b, createHookDocumentReader as c, selectRegistryHooks as d, matchesTool as f, decisionReason as g, additionalContextsFrom as h, createHookTelemetry as i, registryCacheKey as l, HOOK_TELEMETRY_EVENT as m, HOOK_EVENT as n, sessionHookPayload as o, toClaudeToolName as p, selectPluginHooks as r, toolHookPayload as s, createHookModules as t, registryEntries as u, failuresFrom as v, toolResultMessages as x, hookFailureMessage as y };
+
+//# sourceMappingURL=hookModules-GoRDG8mg.mjs.map