@sema-agent/server 1.185.0

package/dist/hooks/hook-runner.js

@@ -0,0 +1,975 @@
+import { spawn } from "node:child_process";
+import { HooksConfig, DEFAULT_HOOK_TIMEOUT_SECONDS, HOOK_EVENT_OWNER, } from "@sema-agent/registry-core/hooks";
+import { redactSecrets } from "../trace/redact.js";
+export const MAX_HOOK_ENTRIES_PER_EVENT = 32;
+export const MAX_HOOK_COMMAND_CHARS = 8_192;
+export const MAX_HOOK_TIMEOUT_SECONDS = 600;
+export const MAX_HOOK_EVENT_TOTAL_SECONDS = 120;
+export const MAX_HOOK_MATCHER_GROUPS = 16;
+export const MAX_HOOK_HTTP_HEADERS = 32;
+export const MAX_HOOK_OUTPUT_BYTES = 1024 * 1024;
+const MAX_HOOK_FEEDBACK_CHARS = 4_096;
+const MAX_TOOL_RESPONSE_CHARS = 32_768;
+const MAX_TOOL_INPUT_CHARS = 262_144;
+const HOOK_ENV_ALLOWLIST = [
+    "PATH", "HOME", "SHELL", "USER", "LOGNAME", "TERM", "TZ",
+    "LANG", "LC_ALL", "LC_CTYPE", "LC_MESSAGES", "TMPDIR",
+];
+function hookEnv(ctx) {
+    const env = { CLAUDE_PROJECT_DIR: ctx.cwd };
+    for (const k of HOOK_ENV_ALLOWLIST) {
+        const v = process.env[k];
+        if (typeof v === "string")
+            env[k] = v;
+    }
+    return { ...env, ...ctx.shellEnv };
+}
+const LIT_EVENTS = [
+    "PreToolUse",
+    "PostToolUse",
+    "PostToolUseFailure",
+    "PostToolBatch",
+    "UserPromptSubmit",
+    "Stop",
+    "StopFailure",
+    "PreCompact",
+    "PostCompact",
+];
+const BRAIN_TO_TURN_ERROR = {
+    auth: "authentication_failed",
+    rate_limit: "rate_limit",
+    invalid_request: "invalid_request",
+    server: "server_error",
+    max_output_tokens: "max_output_tokens",
+};
+function toAssistantTurnError(errorKind) {
+    return (errorKind !== undefined ? BRAIN_TO_TURN_ERROR[errorKind] : undefined) ?? "unknown";
+}
+export function parseHooksConfig(raw) {
+    const parsed = HooksConfig.safeParse(raw);
+    if (!parsed.success) {
+        const first = parsed.error.issues[0];
+        return { error: `settings.hooks: ${first ? `${first.path.join(".")}: ${first.message}` : "invalid shape"}` };
+    }
+    const config = parsed.data;
+    for (const [event, groups] of Object.entries(config)) {
+        if (!groups)
+            continue;
+        if (groups.length > MAX_HOOK_MATCHER_GROUPS) {
+            return { error: `settings.hooks.${event}: ${groups.length} matcher groups exceeds cap ${MAX_HOOK_MATCHER_GROUPS}` };
+        }
+        let entries = 0;
+        for (const group of groups) {
+            for (const entry of group.hooks) {
+                entries++;
+                if (entry.type === "command" && entry.command.length > MAX_HOOK_COMMAND_CHARS) {
+                    return { error: `settings.hooks.${event}: command exceeds ${MAX_HOOK_COMMAND_CHARS} chars` };
+                }
+                if (entry.type === "http") {
+                    if (entry.url.length > MAX_HOOK_COMMAND_CHARS) {
+                        return { error: `settings.hooks.${event}: url exceeds ${MAX_HOOK_COMMAND_CHARS} chars` };
+                    }
+                    const headerEntries = Object.entries(entry.headers ?? {});
+                    if (headerEntries.length > MAX_HOOK_HTTP_HEADERS) {
+                        return { error: `settings.hooks.${event}: ${headerEntries.length} headers exceeds cap ${MAX_HOOK_HTTP_HEADERS}` };
+                    }
+                    const headerChars = headerEntries.reduce((n, [k, v]) => n + k.length + v.length, 0);
+                    if (headerChars > MAX_HOOK_COMMAND_CHARS) {
+                        return { error: `settings.hooks.${event}: headers exceed ${MAX_HOOK_COMMAND_CHARS} chars total` };
+                    }
+                    if ((entry.allowedEnvVars?.length ?? 0) > MAX_HOOK_HTTP_HEADERS) {
+                        return { error: `settings.hooks.${event}: allowedEnvVars exceeds cap ${MAX_HOOK_HTTP_HEADERS}` };
+                    }
+                }
+            }
+        }
+        if (entries > MAX_HOOK_ENTRIES_PER_EVENT) {
+            return { error: `settings.hooks.${event}: ${entries} entries exceeds cap ${MAX_HOOK_ENTRIES_PER_EVENT}` };
+        }
+    }
+    return { config };
+}
+export function hookMatcherMatches(matcher, value) {
+    if (matcher === undefined || matcher === "" || matcher === "*")
+        return true;
+    if (matcher === value)
+        return true;
+    try {
+        return new RegExp(`^(?:${matcher})$`).test(value);
+    }
+    catch {
+        return "invalid";
+    }
+}
+export function hookIfMatches(cond, payload) {
+    if (cond.length > 500 || (cond.match(/\*/g)?.length ?? 0) > 16)
+        return "unevaluable";
+    const p = (payload ?? {});
+    const toolName = typeof p.tool_name === "string" ? p.tool_name : undefined;
+    if (!toolName)
+        return "unevaluable";
+    const m = /^([^(]+?)(?:\((.*)\))?$/s.exec(cond.trim());
+    if (!m)
+        return "unevaluable";
+    const nameOk = hookMatcherMatches(m[1].trim(), toolName);
+    if (nameOk === "invalid")
+        return "unevaluable";
+    if (!nameOk)
+        return "not_matched";
+    const spec = m[2];
+    if (spec === undefined || spec === "*" || spec === "")
+        return true;
+    const input = p.tool_input;
+    const primary = input && (typeof input.command === "string" ? input.command : typeof input.file_path === "string" ? input.file_path : typeof input.path === "string" ? input.path : undefined);
+    if (primary === undefined)
+        return "unevaluable";
+    try {
+        const re = new RegExp(`^${spec.split("*").map((s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*")}$`);
+        return re.test(primary) ? true : "not_matched";
+    }
+    catch {
+        return "unevaluable";
+    }
+}
+const MAX_LLM_ENTRIES_PER_EVENT = 4;
+const DEFAULT_PROMPT_HOOK_TIMEOUT_SECONDS = 30;
+const DEFAULT_AGENT_HOOK_TIMEOUT_SECONDS = 120;
+function clip(s, n) {
+    return s.length > n ? `${s.slice(0, n)}…(${s.length})` : s;
+}
+function runCommandHook(entry, payload, ctx) {
+    return new Promise((resolve) => {
+        const timeoutMs = Math.min(entry.timeout ?? DEFAULT_HOOK_TIMEOUT_SECONDS, MAX_HOOK_TIMEOUT_SECONDS) * 1000;
+        let child;
+        try {
+            child = spawn("/bin/sh", ["-c", entry.command], {
+                cwd: ctx.cwd,
+                env: hookEnv(ctx),
+                stdio: ["pipe", "pipe", "pipe"],
+                detached: true,
+            });
+        }
+        catch (e) {
+            resolve({ code: null, stdout: "", stderr: "", timedOut: false, spawnError: String(e) });
+            return;
+        }
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        let settled = false;
+        const settle = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({ code, stdout, stderr, timedOut });
+        };
+        const timer = setTimeout(() => {
+            timedOut = true;
+            try {
+                if (child.pid)
+                    process.kill(-child.pid, "SIGKILL");
+                else
+                    child.kill("SIGKILL");
+            }
+            catch {
+                child.kill("SIGKILL");
+            }
+            settle(null);
+        }, timeoutMs);
+        child.stdout?.on("data", (d) => {
+            if (stdout.length < MAX_HOOK_OUTPUT_BYTES)
+                stdout += d.toString("utf8").slice(0, MAX_HOOK_OUTPUT_BYTES - stdout.length);
+        });
+        child.stderr?.on("data", (d) => {
+            if (stderr.length < MAX_HOOK_OUTPUT_BYTES)
+                stderr += d.toString("utf8").slice(0, MAX_HOOK_OUTPUT_BYTES - stderr.length);
+        });
+        child.on("error", (e) => {
+            clearTimeout(timer);
+            if (!settled) {
+                settled = true;
+                resolve({ code: null, stdout, stderr, timedOut, spawnError: String(e) });
+            }
+        });
+        child.on("close", (code) => settle(code));
+        child.stdin?.on("error", () => { });
+        child.stdin?.end(`${JSON.stringify(boundedToolInputPayload(payload))}\n`);
+    });
+}
+function fireAsyncCommandHook(entry, payload, ctx, event) {
+    try {
+        const rewake = entry.asyncRewake === true;
+        const timeoutMs = Math.min(entry.timeout ?? DEFAULT_HOOK_TIMEOUT_SECONDS, MAX_HOOK_TIMEOUT_SECONDS) * 1000;
+        const child = spawn("/bin/sh", ["-c", entry.command], {
+            cwd: ctx.cwd,
+            env: hookEnv(ctx),
+            stdio: ["pipe", "ignore", rewake ? "pipe" : "ignore"],
+            detached: true,
+        });
+        const timer = setTimeout(() => {
+            try {
+                if (child.pid)
+                    process.kill(-child.pid, "SIGKILL");
+                else
+                    child.kill("SIGKILL");
+            }
+            catch {
+                child.kill("SIGKILL");
+            }
+        }, timeoutMs);
+        timer.unref?.();
+        let stderr = "";
+        if (rewake) {
+            child.stderr?.on("data", (d) => {
+                if (stderr.length < MAX_HOOK_OUTPUT_BYTES)
+                    stderr += d.toString("utf8").slice(0, MAX_HOOK_OUTPUT_BYTES - stderr.length);
+            });
+            child.stderr?.unref?.();
+        }
+        child.on("error", () => clearTimeout(timer));
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            if (!rewake || code !== 2)
+                return;
+            const text = stderr.trim();
+            if (!ctx.wake) {
+                ctx.logger.warn("hook_async_rewake_dropped", { event, reason: "no_wake_pipeline" });
+                return;
+            }
+            if (!text) {
+                ctx.logger.warn("hook_async_rewake_dropped", { event, reason: "empty_stderr" });
+                return;
+            }
+            void ctx.wake(text).then((delivered) => {
+                if (delivered)
+                    ctx.logger.info("hook_async_rewake_delivered", { event, chars: text.length });
+                else
+                    ctx.logger.warn("hook_async_rewake_dropped", { event, reason: "no_live_stream" });
+            }, (e) => ctx.logger.warn("hook_async_rewake_dropped", { event, reason: "wake_failed", error: String(e).slice(0, 200) }));
+        });
+        child.stdin?.on("error", () => { });
+        child.stdin?.end(`${JSON.stringify(boundedToolInputPayload(payload))}\n`);
+        child.unref();
+    }
+    catch {
+    }
+}
+async function runLlmHook(entry, payload, ctx) {
+    const call = entry.type === "prompt" ? ctx.hookLlm : ctx.hookAgent;
+    if (!call)
+        return { code: null, stdout: "", stderr: "", timedOut: false, spawnError: `no ${entry.type} hook carrier wired on this deployment` };
+    const defSec = entry.type === "prompt" ? DEFAULT_PROMPT_HOOK_TIMEOUT_SECONDS : DEFAULT_AGENT_HOOK_TIMEOUT_SECONDS;
+    const timeoutMs = Math.min(entry.timeout ?? defSec, MAX_HOOK_TIMEOUT_SECONDS) * 1000;
+    const args = clip(JSON.stringify(boundedToolInputPayload(payload)), MAX_TOOL_INPUT_CHARS);
+    const prompt = entry.prompt.split("$ARGUMENTS").join(args);
+    const hardTop = new Promise((r) => setTimeout(() => r({ ok: false, error: "__hook_llm_hard_timeout__" }), timeoutMs + 5_000).unref?.());
+    const res = await Promise.race([call({ prompt, ...(entry.model ? { model: entry.model } : {}), timeoutMs }), hardTop]).catch((e) => ({ ok: false, error: String(e) }));
+    if (!res.ok) {
+        return res.error === "__hook_llm_hard_timeout__"
+            ? { code: null, stdout: "", stderr: "", timedOut: true }
+            : { code: null, stdout: "", stderr: "", timedOut: false, spawnError: clip(res.error, 500) };
+    }
+    return { code: 0, stdout: clip(res.text, 1024 * 1024), stderr: "", timedOut: false };
+}
+async function runHttpHook(entry, payload, ctx) {
+    const timeoutMs = Math.min(entry.timeout ?? DEFAULT_HOOK_TIMEOUT_SECONDS, MAX_HOOK_TIMEOUT_SECONDS) * 1000;
+    const allowed = new Set(entry.allowedEnvVars ?? []);
+    const envSource = hookEnv(ctx);
+    const headers = { "content-type": "application/json" };
+    for (const [k, v] of Object.entries(entry.headers ?? {})) {
+        headers[k] = v.replace(/\$([A-Za-z_][A-Za-z0-9_]*)/g, (whole, name) => {
+            if (!allowed.has(name))
+                return whole;
+            const ev = envSource[name];
+            return typeof ev === "string" ? ev : whole;
+        });
+    }
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), timeoutMs);
+    try {
+        const res = await fetch(entry.url, {
+            method: "POST",
+            headers,
+            body: `${JSON.stringify(boundedToolInputPayload(payload))}\n`,
+            signal: ac.signal,
+            redirect: "error",
+        });
+        let body = "";
+        const reader = res.body?.getReader();
+        if (reader) {
+            const decoder = new TextDecoder();
+            let bytes = 0;
+            while (bytes < MAX_HOOK_OUTPUT_BYTES) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                const budget = MAX_HOOK_OUTPUT_BYTES - bytes;
+                const chunk = value.byteLength > budget ? value.subarray(0, budget) : value;
+                bytes += chunk.byteLength;
+                body += decoder.decode(chunk, { stream: true });
+                if (value.byteLength > budget)
+                    break;
+            }
+            body += decoder.decode();
+            await reader.cancel().catch(() => undefined);
+        }
+        if (res.ok) {
+            const trimmed = body.trim();
+            if (trimmed === "")
+                return { code: 0, stdout: "{}", stderr: "", timedOut: false };
+            if (!parseHookStdout(body)) {
+                ctx.logger.warn("hook_http_non_json_response", { url: clip(entry.url, 300), preview: clip(trimmed, 200) });
+                return { code: 0, stdout: "", stderr: "", timedOut: false };
+            }
+            return { code: 0, stdout: body, stderr: "", timedOut: false };
+        }
+        return { code: res.status, stdout: "", stderr: body, timedOut: false };
+    }
+    catch (e) {
+        if (ac.signal.aborted)
+            return { code: null, stdout: "", stderr: "", timedOut: true };
+        return { code: null, stdout: "", stderr: "", timedOut: false, spawnError: String(e) };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function boundedInputValue(v) {
+    let s;
+    try {
+        s = JSON.stringify(v);
+    }
+    catch {
+        return { __unserializable__: true };
+    }
+    if (s === undefined || s.length <= MAX_TOOL_INPUT_CHARS)
+        return v;
+    return { __truncated__: true, chars: s.length };
+}
+function boundedToolInputPayload(payload) {
+    if (!payload || typeof payload !== "object")
+        return payload;
+    const p = payload;
+    if (!("tool_input" in p))
+        return payload;
+    const bounded = boundedInputValue(p.tool_input);
+    return bounded === p.tool_input ? payload : { ...p, tool_input: bounded };
+}
+function parseHookStdout(stdout) {
+    const t = stdout.trim();
+    if (!t.startsWith("{"))
+        return undefined;
+    try {
+        const v = JSON.parse(t);
+        return v !== null && typeof v === "object" && !Array.isArray(v) ? v : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function runMatchingEntries(event, groups, matchValue, payload, ctx, onceFired, deadlineAt, keyBase) {
+    const results = [];
+    let llmEntries = 0;
+    let gi = -1;
+    for (const group of groups) {
+        gi++;
+        const m = hookMatcherMatches(group.matcher, matchValue);
+        if (m === "invalid") {
+            ctx.logger.warn("hook_matcher_invalid", { event, matcher: clip(group.matcher ?? "", 200) });
+            continue;
+        }
+        if (!m)
+            continue;
+        let ei = -1;
+        for (const entry of group.hooks) {
+            ei++;
+            const onceKey = `${keyBase ?? event}:${gi}:${ei}`;
+            if (entry.once && onceFired.has(onceKey))
+                continue;
+            if (entry.type !== "command" && entry.type !== "http" && entry.type !== "prompt" && entry.type !== "agent") {
+                ctx.logger.warn("hook_entries_skipped", { event, type: entry.type, reason: "type_not_supported" });
+                continue;
+            }
+            if (entry.type === "prompt" || entry.type === "agent") {
+                const carrier = entry.type === "prompt" ? ctx.hookLlm : ctx.hookAgent;
+                if (!carrier) {
+                    ctx.logger.warn("hook_entries_skipped", { event, type: entry.type, reason: "llm_carrier_unavailable" });
+                    continue;
+                }
+                if (llmEntries >= MAX_LLM_ENTRIES_PER_EVENT) {
+                    ctx.logger.warn("hook_entries_skipped", { event, type: entry.type, reason: "llm_entries_per_event_cap", cap: MAX_LLM_ENTRIES_PER_EVENT });
+                    continue;
+                }
+            }
+            if (entry.type === "command" && entry.shell === "powershell") {
+                ctx.logger.warn("hook_entries_skipped", { event, type: entry.type, reason: "powershell_not_supported" });
+                continue;
+            }
+            if (entry.if !== undefined) {
+                const iv = hookIfMatches(entry.if, payload);
+                if (iv !== true) {
+                    ctx.logger.warn("hook_entries_skipped", { event, type: entry.type, reason: iv === "unevaluable" ? "if_unevaluable" : "if_not_matched", if: clip(entry.if, 200) });
+                    continue;
+                }
+            }
+            if (entry.type === "command" && (entry.async || entry.asyncRewake)) {
+                if (entry.once)
+                    onceFired.add(onceKey);
+                fireAsyncCommandHook(entry, payload, ctx, event);
+                continue;
+            }
+            if (Date.now() > deadlineAt) {
+                ctx.logger.warn("hook_event_deadline_exceeded", { event, budgetSec: MAX_HOOK_EVENT_TOTAL_SECONDS });
+                return results;
+            }
+            if (entry.once)
+                onceFired.add(onceKey);
+            if (entry.type === "prompt" || entry.type === "agent")
+                llmEntries++;
+            const run = entry.type === "http" ? await runHttpHook(entry, payload, ctx)
+                : entry.type === "prompt" || entry.type === "agent" ? await runLlmHook(entry, payload, ctx)
+                    : await runCommandHook(entry, payload, ctx);
+            if (run.spawnError) {
+                ctx.logger.warn(entry.type === "http" ? "hook_http_request_failed" : entry.type === "prompt" || entry.type === "agent" ? "hook_llm_failed" : "hook_command_spawn_failed", { event, type: entry.type, error: clip(run.spawnError, 300) });
+                continue;
+            }
+            if (run.timedOut) {
+                ctx.logger.warn("hook_command_timeout", { event, timeoutSec: Math.min(entry.timeout ?? DEFAULT_HOOK_TIMEOUT_SECONDS, MAX_HOOK_TIMEOUT_SECONDS) });
+                continue;
+            }
+            results.push({ entry, run });
+        }
+    }
+    return results;
+}
+function basePayload(ctx) {
+    return {
+        session_id: ctx.sessionId,
+        transcript_path: "",
+        cwd: ctx.cwd,
+        ...(ctx.permissionMode ? { permission_mode: ctx.permissionMode } : {}),
+    };
+}
+function ignoreMatchers(groups) {
+    return groups.map((g) => (g.matcher === undefined ? g : { ...g, matcher: undefined }));
+}
+async function runObserveOnlyEvent(event, groups, matchValue, payload, ctx, onceFired) {
+    const singles = await runMatchingEntries(event, groups, matchValue, payload, ctx, onceFired, Date.now() + MAX_HOOK_EVENT_TOTAL_SECONDS * 1000);
+    for (const { run } of singles) {
+        if (run.code !== 0) {
+            ctx.logger.warn("hook_command_failed", { event, code: run.code, stderr: clip(run.stderr, 300) });
+            continue;
+        }
+        const out = parseHookStdout(run.stdout);
+        if (!out)
+            continue;
+        if (typeof out.systemMessage === "string")
+            ctx.logger.warn("hook_system_message", { event, message: clip(out.systemMessage, 500) });
+        if (out.decision !== undefined || out.continue === false || out.hookSpecificOutput !== undefined) {
+            ctx.logger.warn("hook_result_unsupported", { event });
+        }
+    }
+}
+export function buildTaskHooks(config, ctx) {
+    const configured = Object.keys(config).filter((e) => (config[e]?.length ?? 0) > 0);
+    const dark = configured.filter((e) => HOOK_EVENT_OWNER[e] === "engine" && !LIT_EVENTS.includes(e));
+    if (dark.length > 0) {
+        ctx.logger.warn("hook_events_not_fired", { events: dark, phase: 2 });
+    }
+    const shellOwned = configured.filter((e) => HOOK_EVENT_OWNER[e] === "shell");
+    if (shellOwned.length > 0) {
+        ctx.logger.debug("hook_events_shell_owned", { events: shellOwned });
+    }
+    const lit = (e) => {
+        const groups = config[e];
+        return groups && groups.length > 0 ? groups : undefined;
+    };
+    const pre = lit("PreToolUse");
+    const post = lit("PostToolUse");
+    const postFailure = lit("PostToolUseFailure");
+    const postBatch = lit("PostToolBatch");
+    const promptSubmit = lit("UserPromptSubmit");
+    const stopEntries = lit("Stop");
+    const stopFailureEntries = lit("StopFailure");
+    const preCompactEntries = lit("PreCompact");
+    const postCompactEntries = lit("PostCompact");
+    if (!pre && !post && !postFailure && !postBatch && !promptSubmit && !stopEntries && !stopFailureEntries && !preCompactEntries && !postCompactEntries) {
+        return undefined;
+    }
+    const onceFired = new Set();
+    const hooks = {};
+    if (pre) {
+        hooks.preToolUse = async (toolName, input, tctx) => {
+            let currentInput = input;
+            let rewritten = false;
+            let asked;
+            const contexts = [];
+            const deadlineAt = Date.now() + MAX_HOOK_EVENT_TOTAL_SECONDS * 1000;
+            let gi = -1;
+            for (const group of pre) {
+                gi++;
+                const m = hookMatcherMatches(group.matcher, toolName);
+                if (m === "invalid") {
+                    ctx.logger.warn("hook_matcher_invalid", { event: "PreToolUse", matcher: clip(group.matcher ?? "", 200) });
+                    continue;
+                }
+                if (!m)
+                    continue;
+                const payload = {
+                    ...basePayload(ctx),
+                    hook_event_name: "PreToolUse",
+                    tool_name: toolName,
+                    tool_input: currentInput,
+                    tool_use_id: tctx.toolCallId,
+                };
+                const singles = await runMatchingEntries("PreToolUse", [{ ...group, matcher: undefined }], toolName, payload, ctx, onceFired, deadlineAt, `PreToolUse:${gi}`);
+                for (const { run } of singles) {
+                    if (run.code === 2) {
+                        const reason = clip(run.stderr.trim(), MAX_HOOK_FEEDBACK_CHARS) || "blocked by a PreToolUse hook";
+                        return { action: "deny", message: reason, ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}) };
+                    }
+                    if (run.code !== 0) {
+                        ctx.logger.warn("hook_command_failed", { event: "PreToolUse", code: run.code, stderr: clip(run.stderr, 300) });
+                        continue;
+                    }
+                    const out = parseHookStdout(run.stdout);
+                    if (!out)
+                        continue;
+                    if (typeof out.systemMessage === "string")
+                        ctx.logger.warn("hook_system_message", { event: "PreToolUse", message: clip(out.systemMessage, 500) });
+                    if (out.continue === false) {
+                        const reason = clip(typeof out.stopReason === "string" ? out.stopReason : "hook requested stop", MAX_HOOK_FEEDBACK_CHARS);
+                        return { action: "deny", message: reason, ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}) };
+                    }
+                    if (out.decision === "block") {
+                        const reason = clip(typeof out.reason === "string" ? out.reason : "blocked by a PreToolUse hook", MAX_HOOK_FEEDBACK_CHARS);
+                        return { action: "deny", message: reason, ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}) };
+                    }
+                    const hso = out.hookSpecificOutput;
+                    if (hso !== null && typeof hso === "object" && hso.hookEventName === "PreToolUse") {
+                        const h = hso;
+                        if (typeof h.additionalContext === "string")
+                            contexts.push(clip(h.additionalContext, MAX_HOOK_FEEDBACK_CHARS));
+                        const decision = h.permissionDecision;
+                        if (decision === "deny") {
+                            const reason = clip(typeof h.permissionDecisionReason === "string" ? h.permissionDecisionReason : "denied by a PreToolUse hook", MAX_HOOK_FEEDBACK_CHARS);
+                            return { action: "deny", message: reason, ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}) };
+                        }
+                        if (decision === "ask") {
+                            asked = clip(typeof h.permissionDecisionReason === "string" ? h.permissionDecisionReason : "a PreToolUse hook requires approval", MAX_HOOK_FEEDBACK_CHARS);
+                        }
+                        if (decision === "allow" || decision === undefined) {
+                            if (h.updatedInput !== null && typeof h.updatedInput === "object") {
+                                currentInput = h.updatedInput;
+                                rewritten = true;
+                            }
+                        }
+                    }
+                }
+            }
+            if (asked !== undefined) {
+                return {
+                    action: "ask",
+                    message: asked,
+                    ...(rewritten ? { updatedInput: currentInput } : {}),
+                    ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}),
+                };
+            }
+            if (rewritten || contexts.length > 0) {
+                return {
+                    action: "allow",
+                    ...(rewritten ? { updatedInput: currentInput } : {}),
+                    ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}),
+                };
+            }
+            return undefined;
+        };
+    }
+    if (post) {
+        hooks.postToolUse = async (toolName, input, output, tctx) => {
+            const contexts = [];
+            const responseText = output.content
+                .map((c) => (c && typeof c === "object" && typeof c.text === "string" ? c.text : ""))
+                .join("");
+            const payload = {
+                ...basePayload(ctx),
+                hook_event_name: "PostToolUse",
+                tool_name: toolName,
+                tool_input: input,
+                tool_response: { isError: output.isError, text: clip(responseText, MAX_TOOL_RESPONSE_CHARS) },
+                tool_use_id: tctx.toolCallId,
+            };
+            const singles = await runMatchingEntries("PostToolUse", post, toolName, payload, ctx, onceFired, Date.now() + MAX_HOOK_EVENT_TOTAL_SECONDS * 1000);
+            for (const { run } of singles) {
+                if (run.code === 2) {
+                    const fb = clip(run.stderr.trim(), MAX_HOOK_FEEDBACK_CHARS);
+                    if (fb)
+                        contexts.push(fb);
+                    continue;
+                }
+                if (run.code !== 0) {
+                    ctx.logger.warn("hook_command_failed", { event: "PostToolUse", code: run.code, stderr: clip(run.stderr, 300) });
+                    continue;
+                }
+                const out = parseHookStdout(run.stdout);
+                if (!out)
+                    continue;
+                if (typeof out.systemMessage === "string")
+                    ctx.logger.warn("hook_system_message", { event: "PostToolUse", message: clip(out.systemMessage, 500) });
+                if (out.continue === false) {
+                    ctx.logger.warn("hook_continue_false_unsupported", { event: "PostToolUse" });
+                }
+                if (out.decision === "block" && typeof out.reason === "string")
+                    contexts.push(clip(out.reason, MAX_HOOK_FEEDBACK_CHARS));
+                const hso = out.hookSpecificOutput;
+                if (hso !== null && typeof hso === "object" && hso.hookEventName === "PostToolUse") {
+                    const h = hso;
+                    if (typeof h.additionalContext === "string")
+                        contexts.push(clip(h.additionalContext, MAX_HOOK_FEEDBACK_CHARS));
+                    if (h.updatedMCPToolOutput !== undefined) {
+                        ctx.logger.warn("hook_updated_mcp_output_unsupported", { event: "PostToolUse" });
+                    }
+                }
+            }
+            return contexts.length > 0 ? { additionalContext: contexts.join("\n") } : undefined;
+        };
+    }
+    if (postFailure) {
+        hooks.postToolUseFailure = async (toolName, input, f, tctx) => {
+            const contexts = [];
+            const payload = {
+                ...basePayload(ctx),
+                hook_event_name: "PostToolUseFailure",
+                tool_name: toolName,
+                tool_input: input,
+                tool_use_id: tctx.toolCallId,
+                error: clip(f.error, MAX_TOOL_RESPONSE_CHARS),
+                is_interrupt: f.isInterrupt,
+            };
+            const singles = await runMatchingEntries("PostToolUseFailure", postFailure, toolName, payload, ctx, onceFired, Date.now() + MAX_HOOK_EVENT_TOTAL_SECONDS * 1000);
+            for (const { run } of singles) {
+                if (run.code === 2) {
+                    const fb = clip(run.stderr.trim(), MAX_HOOK_FEEDBACK_CHARS);
+                    if (fb)
+                        contexts.push(fb);
+                    continue;
+                }
+                if (run.code !== 0) {
+                    ctx.logger.warn("hook_command_failed", { event: "PostToolUseFailure", code: run.code, stderr: clip(run.stderr, 300) });
+                    continue;
+                }
+                const out = parseHookStdout(run.stdout);
+                if (!out)
+                    continue;
+                if (typeof out.systemMessage === "string")
+                    ctx.logger.warn("hook_system_message", { event: "PostToolUseFailure", message: clip(out.systemMessage, 500) });
+                if (out.continue === false)
+                    ctx.logger.warn("hook_continue_false_unsupported", { event: "PostToolUseFailure" });
+                if (out.decision === "block" && typeof out.reason === "string")
+                    contexts.push(clip(out.reason, MAX_HOOK_FEEDBACK_CHARS));
+                const hso = out.hookSpecificOutput;
+                if (hso !== null && typeof hso === "object" && hso.hookEventName === "PostToolUseFailure") {
+                    const h = hso;
+                    if (typeof h.additionalContext === "string")
+                        contexts.push(clip(h.additionalContext, MAX_HOOK_FEEDBACK_CHARS));
+                }
+            }
+            return contexts.length > 0 ? { additionalContext: contexts.join("\n") } : undefined;
+        };
+    }
+    if (postBatch) {
+        hooks.postToolBatch = async (calls) => {
+            const contexts = [];
+            const payload = {
+                ...basePayload(ctx),
+                hook_event_name: "PostToolBatch",
+                tool_calls: calls.map((c) => ({
+                    tool_name: c.toolName,
+                    tool_input: boundedInputValue(c.input),
+                    tool_use_id: c.toolCallId,
+                    tool_response: { isError: c.isError, ...(c.response !== undefined ? { text: clip(c.response, MAX_TOOL_RESPONSE_CHARS) } : {}) },
+                })),
+            };
+            const singles = await runMatchingEntries("PostToolBatch", ignoreMatchers(postBatch), "", payload, ctx, onceFired, Date.now() + MAX_HOOK_EVENT_TOTAL_SECONDS * 1000);
+            for (const { run } of singles) {
+                if (run.code === 2) {
+                    const fb = clip(run.stderr.trim(), MAX_HOOK_FEEDBACK_CHARS);
+                    if (fb)
+                        contexts.push(fb);
+                    continue;
+                }
+                if (run.code !== 0) {
+                    ctx.logger.warn("hook_command_failed", { event: "PostToolBatch", code: run.code, stderr: clip(run.stderr, 300) });
+                    continue;
+                }
+                const out = parseHookStdout(run.stdout);
+                if (!out)
+                    continue;
+                if (typeof out.systemMessage === "string")
+                    ctx.logger.warn("hook_system_message", { event: "PostToolBatch", message: clip(out.systemMessage, 500) });
+                if (out.continue === false)
+                    ctx.logger.warn("hook_continue_false_unsupported", { event: "PostToolBatch" });
+                if (out.decision === "block" && typeof out.reason === "string")
+                    contexts.push(clip(out.reason, MAX_HOOK_FEEDBACK_CHARS));
+                if (out.hookSpecificOutput !== undefined)
+                    ctx.logger.warn("hook_result_unsupported", { event: "PostToolBatch" });
+            }
+            return contexts.length > 0 ? { additionalContext: contexts.join("\n") } : undefined;
+        };
+    }
+    if (promptSubmit) {
+        hooks.userPromptSubmit = async (prompt) => {
+            const contexts = [];
+            const payload = { ...basePayload(ctx), hook_event_name: "UserPromptSubmit", prompt: clip(prompt, MAX_TOOL_INPUT_CHARS) };
+            const singles = await runMatchingEntries("UserPromptSubmit", ignoreMatchers(promptSubmit), "", payload, ctx, onceFired, Date.now() + MAX_HOOK_EVENT_TOTAL_SECONDS * 1000);
+            for (const { run } of singles) {
+                if (run.code === 2) {
+                    const reason = clip(run.stderr.trim(), MAX_HOOK_FEEDBACK_CHARS) || "blocked by a UserPromptSubmit hook";
+                    return { block: reason, ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}) };
+                }
+                if (run.code !== 0) {
+                    ctx.logger.warn("hook_command_failed", { event: "UserPromptSubmit", code: run.code, stderr: clip(run.stderr, 300) });
+                    continue;
+                }
+                const out = parseHookStdout(run.stdout);
+                if (!out)
+                    continue;
+                if (typeof out.systemMessage === "string")
+                    ctx.logger.warn("hook_system_message", { event: "UserPromptSubmit", message: clip(out.systemMessage, 500) });
+                if (out.continue === false) {
+                    const reason = clip(typeof out.stopReason === "string" ? out.stopReason : "hook requested stop", MAX_HOOK_FEEDBACK_CHARS);
+                    return { block: reason, ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}) };
+                }
+                if (out.decision === "block") {
+                    const reason = clip(typeof out.reason === "string" ? out.reason : "blocked by a UserPromptSubmit hook", MAX_HOOK_FEEDBACK_CHARS);
+                    return { block: reason, ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}) };
+                }
+                const hso = out.hookSpecificOutput;
+                if (hso !== null && typeof hso === "object" && hso.hookEventName === "UserPromptSubmit") {
+                    const h = hso;
+                    if (typeof h.additionalContext === "string")
+                        contexts.push(clip(h.additionalContext, MAX_HOOK_FEEDBACK_CHARS));
+                }
+            }
+            return contexts.length > 0 ? { additionalContext: contexts.join("\n") } : undefined;
+        };
+    }
+    if (stopEntries) {
+        hooks.stop = async (sctx) => {
+            const payload = { ...basePayload(ctx), hook_event_name: "Stop", stop_hook_active: sctx.stopHookActive };
+            const singles = await runMatchingEntries("Stop", ignoreMatchers(stopEntries), "", payload, ctx, onceFired, Date.now() + MAX_HOOK_EVENT_TOTAL_SECONDS * 1000);
+            let block;
+            let sawContinueFalse = false;
+            for (const { run } of singles) {
+                if (run.code === 2) {
+                    if (block === undefined)
+                        block = clip(run.stderr.trim(), MAX_HOOK_FEEDBACK_CHARS) || "blocked by a Stop hook";
+                    continue;
+                }
+                if (run.code !== 0) {
+                    ctx.logger.warn("hook_command_failed", { event: "Stop", code: run.code, stderr: clip(run.stderr, 300) });
+                    continue;
+                }
+                const out = parseHookStdout(run.stdout);
+                if (!out)
+                    continue;
+                if (typeof out.systemMessage === "string")
+                    ctx.logger.warn("hook_system_message", { event: "Stop", message: clip(out.systemMessage, 500) });
+                if (out.continue === false)
+                    sawContinueFalse = true;
+                if (out.decision === "block" && block === undefined) {
+                    block = clip(typeof out.reason === "string" ? out.reason : "blocked by a Stop hook", MAX_HOOK_FEEDBACK_CHARS);
+                }
+            }
+            if (sawContinueFalse)
+                return undefined;
+            return block !== undefined ? { block } : undefined;
+        };
+    }
+    if (stopFailureEntries) {
+        hooks.stopFailure = async (fctx) => {
+            const turnError = toAssistantTurnError(fctx.errorKind);
+            const payload = {
+                ...basePayload(ctx),
+                hook_event_name: "StopFailure",
+                error: turnError,
+                ...(fctx.error ? { error_details: clip(redactSecrets(fctx.error), MAX_HOOK_FEEDBACK_CHARS) } : {}),
+            };
+            await runObserveOnlyEvent("StopFailure", stopFailureEntries, turnError, payload, ctx, onceFired);
+        };
+    }
+    if (preCompactEntries) {
+        hooks.preCompact = async (pctx) => {
+            const payload = {
+                ...basePayload(ctx),
+                hook_event_name: "PreCompact",
+                trigger: pctx.trigger,
+                custom_instructions: pctx.customInstructions ?? null,
+            };
+            const singles = await runMatchingEntries("PreCompact", preCompactEntries, pctx.trigger, payload, ctx, onceFired, Date.now() + MAX_HOOK_EVENT_TOTAL_SECONDS * 1000);
+            for (const { run } of singles) {
+                if (run.code === 2) {
+                    return { block: clip(run.stderr.trim(), MAX_HOOK_FEEDBACK_CHARS) || "blocked by a PreCompact hook" };
+                }
+                if (run.code !== 0) {
+                    ctx.logger.warn("hook_command_failed", { event: "PreCompact", code: run.code, stderr: clip(run.stderr, 300) });
+                    continue;
+                }
+                const out = parseHookStdout(run.stdout);
+                if (!out)
+                    continue;
+                if (typeof out.systemMessage === "string")
+                    ctx.logger.warn("hook_system_message", { event: "PreCompact", message: clip(out.systemMessage, 500) });
+                if (out.continue === false) {
+                    ctx.logger.warn("hook_continue_false_unsupported", { event: "PreCompact" });
+                }
+                if (out.decision === "block") {
+                    return { block: clip(typeof out.reason === "string" ? out.reason : "blocked by a PreCompact hook", MAX_HOOK_FEEDBACK_CHARS) };
+                }
+            }
+            return undefined;
+        };
+    }
+    if (postCompactEntries) {
+        hooks.postCompact = async (cctx) => {
+            const payload = {
+                ...basePayload(ctx),
+                hook_event_name: "PostCompact",
+                trigger: cctx.trigger,
+                compact_summary: clip(cctx.summary, MAX_TOOL_RESPONSE_CHARS),
+            };
+            await runObserveOnlyEvent("PostCompact", postCompactEntries, cctx.trigger, payload, ctx, onceFired);
+        };
+    }
+    return hooks;
+}
+export function composeHooks(deployment, task) {
+    if (!deployment)
+        return task;
+    const d = deployment;
+    const t = task;
+    const out = {};
+    if (d.preToolUse || t.preToolUse) {
+        out.preToolUse = async (toolName, input, ctx) => {
+            let current = input;
+            const contexts = [];
+            let asked;
+            for (const slot of [d.preToolUse?.bind(d), t.preToolUse?.bind(t)]) {
+                if (!slot)
+                    continue;
+                const r = await slot(toolName, current, ctx);
+                if (!r)
+                    continue;
+                if (r.additionalContext)
+                    contexts.push(r.additionalContext);
+                if (r.action === "deny")
+                    return { ...r, ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}) };
+                if (r.action === "ask")
+                    asked = r;
+                if (r.action === "allow" && r.updatedInput !== undefined) {
+                    current = r.updatedInput;
+                }
+            }
+            if (asked) {
+                const askedUpdated = asked.updatedInput;
+                return {
+                    ...asked,
+                    ...(askedUpdated === undefined && current !== input ? { updatedInput: current } : {}),
+                    ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}),
+                };
+            }
+            if (current !== input || contexts.length > 0) {
+                return {
+                    action: "allow",
+                    ...(current !== input ? { updatedInput: current } : {}),
+                    ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}),
+                };
+            }
+            return undefined;
+        };
+    }
+    if (d.postToolUse || t.postToolUse) {
+        out.postToolUse = async (toolName, input, output, ctx) => {
+            const rd = d.postToolUse ? await d.postToolUse(toolName, input, output, ctx) : undefined;
+            const rt = t.postToolUse ? await t.postToolUse(toolName, input, output, ctx) : undefined;
+            if (!rd && !rt)
+                return undefined;
+            const contexts = [rd?.additionalContext, rt?.additionalContext].filter((c) => typeof c === "string" && c.length > 0);
+            const updatedOutput = rt?.updatedOutput ?? rd?.updatedOutput;
+            return {
+                ...(updatedOutput ? { updatedOutput } : {}),
+                ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}),
+            };
+        };
+    }
+    if (d.postToolUseFailure || t.postToolUseFailure) {
+        out.postToolUseFailure = async (toolName, input, failure, ctx) => {
+            const rd = d.postToolUseFailure ? await d.postToolUseFailure(toolName, input, failure, ctx) : undefined;
+            const rt = t.postToolUseFailure ? await t.postToolUseFailure(toolName, input, failure, ctx) : undefined;
+            const contexts = [rd?.additionalContext, rt?.additionalContext].filter((c) => typeof c === "string" && c.length > 0);
+            return contexts.length ? { additionalContext: contexts.join("\n") } : undefined;
+        };
+    }
+    if (d.postToolBatch || t.postToolBatch) {
+        out.postToolBatch = async (calls) => {
+            const rd = d.postToolBatch ? await d.postToolBatch(calls) : undefined;
+            const rt = t.postToolBatch ? await t.postToolBatch(calls) : undefined;
+            const contexts = [rd?.additionalContext, rt?.additionalContext].filter((c) => typeof c === "string" && c.length > 0);
+            return contexts.length ? { additionalContext: contexts.join("\n") } : undefined;
+        };
+    }
+    if (d.userPromptSubmit || t.userPromptSubmit) {
+        out.userPromptSubmit = async (prompt) => {
+            const rd = d.userPromptSubmit ? await d.userPromptSubmit(prompt) : undefined;
+            if (rd?.block)
+                return rd;
+            const rt = t.userPromptSubmit ? await t.userPromptSubmit(prompt) : undefined;
+            if (!rd && !rt)
+                return undefined;
+            const contexts = [rd?.additionalContext, rt?.additionalContext].filter((c) => typeof c === "string" && c.length > 0);
+            return { ...(rt?.block ? { block: rt.block } : {}), ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}) };
+        };
+    }
+    if (d.stop || t.stop) {
+        out.stop = async (sctx) => {
+            const rd = d.stop ? await d.stop(sctx) : undefined;
+            if (rd?.block)
+                return rd;
+            const rt = t.stop ? await t.stop(sctx) : undefined;
+            if (!rd && !rt)
+                return undefined;
+            const contexts = [rd?.additionalContext, rt?.additionalContext].filter((c) => typeof c === "string" && c.length > 0);
+            return { ...(rt?.block ? { block: rt.block } : {}), ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}) };
+        };
+    }
+    if (d.preCompact || t.preCompact) {
+        out.preCompact = async (pctx) => {
+            const rd = d.preCompact ? await d.preCompact(pctx) : undefined;
+            const rt = t.preCompact ? await t.preCompact(pctx) : undefined;
+            if (!rd && !rt)
+                return undefined;
+            const block = rd?.block ?? rt?.block;
+            const instructions = [rd?.additionalInstructions, rt?.additionalInstructions].filter((c) => typeof c === "string" && c.length > 0);
+            return {
+                ...(block !== undefined ? { block } : {}),
+                ...(instructions.length ? { additionalInstructions: instructions.join("\n") } : {}),
+            };
+        };
+    }
+    for (const slot of ["stopFailure", "postCompact", "permissionDenied"]) {
+        const ds = d[slot];
+        const ts = t[slot];
+        if (ds && ts) {
+            out[slot] = async (...args) => {
+                await ds(...args);
+                await ts(...args);
+            };
+        }
+        else if (ds || ts) {
+            out[slot] = (ds ?? ts);
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=hook-runner.js.map