@sema-agent/server 7.131.0 → 7.133.0

package/dist/hooks/hook-runner.js

@@ -1,15 +1,23 @@
 import { spawn } from "node:child_process";
+import { composeHostSubprocessEnv, hostSubprocessEnv } from "../server-secret-env.js";
 import vm from "node:vm";
-import { hostShell, resolveHostShell, adoptHostForegroundChild } from "../plugins/host-platform.js";
+import { hostShell, resolveHostShell, adoptHostForegroundChild, killTreeSoft, killTreeHard } from "../plugins/host-platform.js";
 import { classifyHooksConfig, DEFAULT_HOOK_TIMEOUT_SECONDS, HOOK_ENTRY_TYPES, HOOK_EVENTS, HOOK_EVENT_OWNER, HOOK_EVENT_MATCHER_FIELD, hookMatcherForm, hookMatcherSelects, interpolateHookEnvVars, } from "@sema-agent/settings-schema/hooks";
 import { formatConfigPath, outgoingPath } from "@sema-agent/settings-schema";
-import { describeToolCatalog, isEngineRefusal, receiveHookResult } from "@sema-agent/core";
-import { boundedNoticeText } from "../fleet/fleet-bus.js";
+import { ENGINE_OWNED_HOOK_EVENTS } from "@sema-agent/settings-schema/hooks";
+import { describeToolCatalog } from "@sema-agent/core";
+import { hangClassic } from "./classic-stations.js";
+import { MAX_HOOK_NOTICE_TEXT_CHARS, boundedNoticeText } from "../fleet/fleet-bus.js";
 import { recordFailOpen } from "../observability/fail-open.js";
+import { LIMIT_REASONS } from "../limit-refusal.js";
+import { clipDataText, echoCallerText } from "../caller-text-echo.js";
 import { redactSecrets, buildDisplaySafeUrl } from "../trace/redact.js";
+import { canonicalJson } from "../canonical-json.js";
 import { ccPromptSystemFor, wrapCondition, parseCcVerdict, CC_EVALUATOR_MAX_OUTPUT_TOKENS } from "./cc-stop-prompt.js";
 import { ccAgentHookSystemFor } from "./cc-agent-hook-prompt.js";
 import { renderBranchTranscript } from "./branch-transcript.js";
+import { HOOK_PHASES, HOOK_SOURCE_VOCABULARY_SENTENCE, hookPhaseOf, readHookGroupSource } from "./hook-source.js";
+import { commandLineChars, composeHookEnvLayer, hookPluginChars, planCommandSpawn, readHookArgs, readHookPlugin } from "./command-spawn.js";
 export const MAX_HOOK_ENTRIES_PER_EVENT = 32;
 export const MAX_HOOK_COMMAND_CHARS = 8_192;
 export const MAX_HOOK_TIMEOUT_SECONDS = 600;
@@ -26,26 +34,41 @@ const HOOK_ENV_ALLOWLIST = [
     "PATH", "HOME", "SHELL", "USER", "LOGNAME", "TERM", "TZ",
     "LANG", "LC_ALL", "LC_CTYPE", "LC_MESSAGES", "TMPDIR",
 ];
+function hookBaseEnv(spawning) {
+    return spawning
+        ? hostSubprocessEnv({ site: "server.hooks.spawn-env", policy: [...HOOK_ENV_ALLOWLIST], allow: [] })
+        : composeHostSubprocessEnv({ policy: [...HOOK_ENV_ALLOWLIST], allow: [] });
+}
+function hookEnvOverBase(layer, spawning) {
+    return { ...hookBaseEnv(spawning), ...layer };
+}
 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 };
+    return hookEnvOverBase(composeHookEnvLayer(ctx.shellEnv, ctx.cwd, undefined), false);
 }
-const LIT_EVENTS = [
-    "PreToolUse",
-    "PostToolUse",
-    "PostToolUseFailure",
-    "PostToolBatch",
-    "UserPromptSubmit",
-    "Stop",
-    "StopFailure",
-    "PreCompact",
-    "PostCompact",
-];
+export const SETTINGS_HOOK_STATIONS = {
+    PreToolUse: ["classic.PreToolUse"],
+    PostToolUse: ["classic.PostToolUse"],
+    PostToolUseFailure: ["classic.PostToolUseFailure"],
+    PostToolBatch: ["classic.PostToolBatch"],
+    UserPromptSubmit: ["classic.UserPromptSubmit"],
+    Stop: ["classic.Stop", "classic.SubagentStop"],
+    StopFailure: ["classic.StopFailure"],
+    PreCompact: ["classic.PreCompact"],
+    PostCompact: ["classic.PostCompact"],
+};
+function hangTranslator(on, event, translators) {
+    const translate = translators[event];
+    if (translate === undefined)
+        return;
+    for (const station of SETTINGS_HOOK_STATIONS[event])
+        hangClassic(on, station, translate);
+}
+export const SETTINGS_HOOKS_REGISTRATION = "settings.hooks";
+export const DEFAULT_SETTINGS_HOOKS_BUDGET_MS = MAX_HOOK_TIMEOUT_SECONDS * 1000;
+export function settingsHooksBudgetMs(config) {
+    return config.hooksTimeoutMs ?? DEFAULT_SETTINGS_HOOKS_BUDGET_MS;
+}
+export const HOOK_KILL_GRACE_MS = 1_000;
 const BRAIN_TO_TURN_ERROR = {
     auth: "authentication_failed",
     rate_limit: "rate_limit",
@@ -76,8 +99,12 @@ function isRunnableHookEntry(entry) {
     return isSupportedHookEntryType(entry.type);
 }
 export const MAX_MATCHER_EVAL_CHARS = MAX_HOOK_COMMAND_CHARS;
-export const ADMISSION_MATCHER_EVAL_BUDGET_MS = 1_000;
+export const ADMISSION_MATCHER_BUDGET = { budgetMs: 1_000, totalMs: 5_000 };
 export const MATCHER_ECHO_CHARS = 200;
+export const IF_ECHO_CHARS = 200;
+const LOG_PREVIEW_ECHO_CHARS = 200;
+const LOG_ERROR_ECHO_CHARS = 300;
+const LOG_MESSAGE_ECHO_CHARS = 500;
 const MATCHER_UNJUDGED_TAG = "server.hooks.matcher-unjudged";
 function matcherReadsWireToolName(event) {
     return HOOK_EVENT_OWNER[event] === "engine" && HOOK_EVENT_MATCHER_FIELD[event] === "tool_name";
@@ -130,7 +157,11 @@ const MATCHER_EVALUATION = {
     regex: { regex: "budgeted", literal: "not_applicable" },
     invalid: { regex: "unreadable", literal: "not_applicable" },
 };
-function judgeMatcher(matcher, depth, budgetMs) {
+const RUNTIME_EVAL_DEPTH = "regex";
+function matcherSelectsBy(evaluation, matcher, name, budgetMs) {
+    return evaluation === "inline" ? hookMatcherSelects(matcher, name) : matcherSelectsWithin(matcher, name, budgetMs);
+}
+function judgeMatcher(matcher, depth, ledger, judgesAlias) {
     if (matcher.length > MAX_MATCHER_EVAL_CHARS)
         return { kind: "unjudged", reason: "oversize" };
     const evaluate = MATCHER_EVALUATION[hookMatcherForm(matcher)][depth];
@@ -141,14 +172,34 @@ function judgeMatcher(matcher, depth, budgetMs) {
             return { kind: "invalid_regex" };
         case "inline":
         case "budgeted":
+            if (!judgesAlias)
+                return undefined;
             break;
         default: {
             const unreachable = evaluate;
             return unreachable;
         }
     }
-    const selects = (name) => (evaluate === "inline" ? hookMatcherSelects(matcher, name) : matcherSelectsWithin(matcher, name, budgetMs));
-    const unanswered = (verdict) => (verdict === "over_budget" ? { kind: "over_budget" } : { kind: "invalid_regex" });
+    const selects = (name) => {
+        if (evaluate === "inline")
+            return matcherSelectsBy(evaluate, matcher, name, ledger.budgetMs);
+        const startedAt = ledger.now();
+        const answer = matcherSelectsBy(evaluate, matcher, name, ledger.budgetMs);
+        ledger.spentMs += ledger.now() - startedAt;
+        if (answer === "over_budget" || answer === "invalid")
+            return answer;
+        return ledger.spentMs > ledger.totalMs ? "budget_exceeded" : answer;
+    };
+    const unanswered = (verdict) => {
+        switch (verdict) {
+            case "over_budget":
+                return { kind: "over_budget" };
+            case "budget_exceeded":
+                return { kind: "budget_exceeded" };
+            case "invalid":
+                return { kind: "invalid_regex" };
+        }
+    };
     for (const [alias, canonical] of engineToolAliases()) {
         const selectsAlias = selects(alias);
         if (typeof selectsAlias === "string")
@@ -163,50 +214,111 @@ function judgeMatcher(matcher, depth, budgetMs) {
     }
     return undefined;
 }
-export function buildToolMatcherRefusal(issue) {
+const HOOKS_CAPS = {
+    matcher_groups: { measure: "entries", cap: MAX_HOOK_MATCHER_GROUPS, sentence: (event, count) => `settings.hooks.${event}: ${count} matcher groups exceeds cap ${MAX_HOOK_MATCHER_GROUPS}` },
+    event_entries: { measure: "entries", cap: MAX_HOOK_ENTRIES_PER_EVENT, sentence: (event, count) => `settings.hooks.${event}: ${count} entries exceeds cap ${MAX_HOOK_ENTRIES_PER_EVENT}` },
+    command: { measure: "characters", cap: MAX_HOOK_COMMAND_CHARS, sentence: (event) => `settings.hooks.${event}: command exceeds ${MAX_HOOK_COMMAND_CHARS} chars` },
+    url: { measure: "characters", cap: MAX_HOOK_COMMAND_CHARS, sentence: (event) => `settings.hooks.${event}: url exceeds ${MAX_HOOK_COMMAND_CHARS} chars` },
+    headers: { measure: "entries", cap: MAX_HOOK_HTTP_HEADERS, sentence: (event, count) => `settings.hooks.${event}: ${count} headers exceeds cap ${MAX_HOOK_HTTP_HEADERS}` },
+    header_chars: { measure: "characters", cap: MAX_HOOK_COMMAND_CHARS, sentence: (event) => `settings.hooks.${event}: headers exceed ${MAX_HOOK_COMMAND_CHARS} chars total` },
+    allowed_env_vars: { measure: "entries", cap: MAX_HOOK_HTTP_HEADERS, sentence: (event) => `settings.hooks.${event}: allowedEnvVars exceeds cap ${MAX_HOOK_HTTP_HEADERS}` },
+    plugin: { measure: "characters", cap: MAX_HOOK_COMMAND_CHARS, sentence: (event) => `settings.hooks.${event}: plugin context exceeds ${MAX_HOOK_COMMAND_CHARS} chars total` },
+};
+const HOOKS_WIRE_KEY_SHAPE = {
+    source: `source must be one of ${HOOK_SOURCE_VOCABULARY_SENTENCE}`,
+    plugin: "plugin must be { name, root, dataDir?, options? } — name a non-empty string, root and dataDir absolute paths with no \"..\" segment and no NUL byte, " +
+        "options an object of string values whose keys are identifiers ([A-Za-z_][A-Za-z0-9_]*); nothing else",
+    args: "args must be an array of strings without NUL bytes (exec form: command is the executable, args its arguments)",
+};
+function hooksCapIssue(limit, event, path, count) {
+    const c = HOOKS_CAPS[limit];
+    return { reason: LIMIT_REASONS[c.measure], limit, event, path, count, cap: c.cap };
+}
+const matcherPath = (event, groupIndex) => ["hooks", event, groupIndex, "matcher"];
+export function buildHooksRefusal(issue) {
+    const field = "settings.hooks";
     switch (issue.reason) {
         case "dead_alias":
             return {
                 message: `settings.hooks.${issue.event}: matcher "${issue.alias}" is an alias; tool-event matchers match the tool's wire name (PostToolUse / PostToolUseFailure since 7.107.0) — use "${issue.canonical}"`,
-                field: "settings.hooks",
-                detail: { reason: issue.reason, event: issue.event, alias: issue.alias, canonical: issue.canonical },
+                field,
+                detail: { reason: issue.reason, event: issue.event, alias: issue.alias, canonical: issue.canonical, path: matcherPath(issue.event, issue.groupIndex) },
             };
         case "over_budget":
             return {
                 message: `settings.hooks.${issue.event}[${issue.groupIndex}].matcher: evaluating the pattern did not finish within ${issue.budgetMs} ms (catastrophic regex backtracking) — rewrite it as a tool-name list or a pattern without nested repetition`,
-                field: "settings.hooks",
-                detail: { reason: issue.reason, event: issue.event, groupIndex: issue.groupIndex, budgetMs: issue.budgetMs },
+                field,
+                detail: { reason: issue.reason, event: issue.event, groupIndex: issue.groupIndex, budgetMs: issue.budgetMs, path: matcherPath(issue.event, issue.groupIndex) },
+            };
+        case "budget_exceeded":
+            return {
+                message: `settings.hooks.${issue.event}[${issue.groupIndex}].matcher: evaluating this configuration's regular-expression matchers took longer than ${issue.totalMs} ms in total (very slow patterns) — write tool names as a list such as "Read|Edit", or simplify the patterns`,
+                field,
+                detail: { reason: issue.reason, event: issue.event, groupIndex: issue.groupIndex, totalMs: issue.totalMs, path: matcherPath(issue.event, issue.groupIndex) },
             };
         case "invalid_regex":
             return {
                 message: `settings.hooks.${issue.event}[${issue.groupIndex}].matcher: ${JSON.stringify(issue.matcher)} is not a valid regular expression (${issue.compileError}) — fix the pattern, or write the tool names as a list such as "Read|Edit"`,
-                field: "settings.hooks",
-                detail: { reason: issue.reason, event: issue.event, groupIndex: issue.groupIndex },
+                field,
+                detail: { reason: issue.reason, event: issue.event, groupIndex: issue.groupIndex, path: matcherPath(issue.event, issue.groupIndex) },
+            };
+        case "unsupported_entry_type":
+            return {
+                message: `${hooksCoordinate(issue.path)}: this server does not run hook entries of type ${issue.type}; supported: ${SUPPORTED_HOOK_ENTRY_TYPES.join(" / ")}`,
+                field,
+                detail: { reason: issue.reason, path: hooksOutgoingPath(issue.path), type: issue.type },
             };
+        case "over_cap":
+        case "too_long": {
+            const cap = issue;
+            return { message: HOOKS_CAPS[cap.limit].sentence(cap.event, cap.count), field, detail: { reason: cap.reason, path: hooksOutgoingPath(cap.path), count: cap.count, cap: cap.cap } };
+        }
+        case "unnamed_refusal":
+            return { message: `${hooksCoordinate(issue.path)}: the hooks reader refused this configuration without naming a piece`, field, detail: { reason: issue.reason, path: hooksOutgoingPath(issue.path) } };
+        case "wire_key_invalid":
+            return { message: `${hooksCoordinate(issue.path)}: ${HOOKS_WIRE_KEY_SHAPE[issue.key]}`, field, detail: { reason: issue.reason, path: hooksOutgoingPath(issue.path), key: issue.key } };
         default: {
-            const unreachable = issue;
-            return unreachable;
+            const piece = issue;
+            const key = piece.key !== undefined ? hooksOutgoingKey(piece.key) : undefined;
+            return {
+                message: hooksPieceRefusal(piece),
+                field,
+                detail: { reason: piece.reason, path: hooksOutgoingPath(piece.path), ...(key !== undefined ? { key } : {}) },
+            };
         }
     }
 }
-export function toolMatcherIssue(config, depth, budget = {}) {
-    const budgetMs = budget.budgetMs ?? ADMISSION_MATCHER_EVAL_BUDGET_MS;
+export function hooksMatcherIssue(config, depth, budget = {}) {
+    const ledger = {
+        budgetMs: budget.budgetMs ?? ADMISSION_MATCHER_BUDGET.budgetMs,
+        totalMs: budget.totalMs ?? ADMISSION_MATCHER_BUDGET.totalMs,
+        now: budget.now ?? (() => performance.now()),
+        spentMs: 0,
+    };
+    const budgetMs = ledger.budgetMs;
     for (const [event, groups] of Object.entries(config)) {
-        if (!matcherReadsWireToolName(event))
-            continue;
+        const judgesAlias = matcherReadsWireToolName(event);
         for (const [groupIndex, group] of (groups ?? []).entries()) {
             if (group.matcher === undefined)
                 continue;
-            const verdict = judgeMatcher(group.matcher, depth, budgetMs);
+            const verdict = judgeMatcher(group.matcher, depth, ledger, judgesAlias);
             if (verdict === undefined)
                 continue;
             switch (verdict.kind) {
                 case "dead":
-                    return { reason: "dead_alias", event, alias: verdict.alias, canonical: verdict.canonical };
+                    return { reason: "dead_alias", event, groupIndex, alias: verdict.alias, canonical: verdict.canonical };
                 case "over_budget":
                     return { reason: "over_budget", event, groupIndex, budgetMs };
+                case "budget_exceeded":
+                    return { reason: "budget_exceeded", event, groupIndex, totalMs: ledger.totalMs };
                 case "invalid_regex":
-                    return { reason: "invalid_regex", event, groupIndex, matcher: clip(group.matcher, MATCHER_ECHO_CHARS), compileError: clip(matcherCompileSentence(group.matcher), MATCHER_ECHO_CHARS) };
+                    return {
+                        reason: "invalid_regex",
+                        event,
+                        groupIndex,
+                        matcher: echoCallerText(group.matcher, { maxChars: MATCHER_ECHO_CHARS }),
+                        compileError: echoCallerText(matcherCompileSentence(group.matcher), { maxChars: MATCHER_ECHO_CHARS }),
+                    };
                 case "unjudged":
                     recordFailOpen(MATCHER_UNJUDGED_TAG, `event=${event} reason=${verdict.reason} matcherChars=${group.matcher.length}`);
                     break;
@@ -232,80 +344,121 @@ const HOOKS_PIECE_MEANING = {
     "guard-matcher-invalid": "a PreToolUse / PermissionRequest matcher group is not valid",
     "guard-entry-invalid": "a PreToolUse / PermissionRequest hook entry is not valid",
 };
+export function hooksOutgoingPath(path) {
+    return outgoingPath(path).map((seg) => (typeof seg === "string" ? echoCallerText(seg) : seg));
+}
 export function hooksCoordinate(path) {
-    return `settings.${formatConfigPath(outgoingPath(path))}`;
+    return `settings.${formatConfigPath(hooksOutgoingPath(path))}`;
+}
+function hooksOutgoingKey(key) {
+    return echoCallerText(String(outgoingPath([key])[0] ?? ""));
+}
+function hooksPieceIssue(piece) {
+    return piece.field !== undefined ? { reason: piece.code, path: piece.path, key: piece.field } : { reason: piece.code, path: piece.path };
 }
 function hooksPieceRefusal(piece) {
-    const field = piece.field !== undefined ? ` (field: ${piece.field})` : "";
-    return `${hooksCoordinate(piece.path)}: ${piece.code} — ${HOOKS_PIECE_MEANING[piece.code]}${field}`;
+    const field = piece.key !== undefined ? ` (field: ${hooksOutgoingKey(piece.key)})` : "";
+    return `${hooksCoordinate(piece.path)}: ${piece.reason} — ${HOOKS_PIECE_MEANING[piece.reason]}${field}`;
 }
-function unsupportedHookEntryTypeRefusal(path, type) {
-    return `${hooksCoordinate(path)}: this server does not run hook entries of type ${type}; supported: ${SUPPORTED_HOOK_ENTRY_TYPES.join(" / ")}`;
+function hooksRefused(issue, pieces) {
+    const error = buildHooksRefusal(issue).message;
+    return pieces === undefined ? { issue, error } : { issue, error, pieces };
 }
 export function parseHooksConfig(raw) {
     const classified = classifyHooksConfig({ hooks: raw });
     if (classified.outcome !== "loaded") {
         const first = classified.outcome === "rejected" ? classified.rejections[0] : classified.dropped[0];
         const pieces = classified.outcome === "rejected" ? classified.rejections : classified.dropped;
-        return { error: first !== undefined ? hooksPieceRefusal(first) : `${hooksCoordinate(["hooks"])}: the hooks reader refused this configuration without naming a piece`, pieces };
+        return hooksRefused(first !== undefined ? hooksPieceIssue(first) : { reason: "unnamed_refusal", path: ["hooks"] }, pieces);
     }
     const loaded = classified.hooks;
     if (loaded === undefined) {
-        return { error: hooksPieceRefusal({ code: "hooks-not-object", path: ["hooks"] }) };
+        return hooksRefused({ reason: "hooks-not-object", path: ["hooks"] });
     }
     const config = {};
+    const rawMember = (node, key) => node !== null && typeof node === "object" && Object.hasOwn(node, key) ? node[key] : undefined;
     for (const key of Object.keys(loaded)) {
         if (!isHookEventName(key)) {
-            return { error: hooksPieceRefusal({ code: "unknown-event", path: ["hooks", key] }) };
+            return hooksRefused({ reason: "unknown-event", path: ["hooks", key] });
         }
         const event = key;
         const groups = loaded[event];
         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}` };
-        }
+        if (groups.length > MAX_HOOK_MATCHER_GROUPS)
+            return hooksRefused(hooksCapIssue("matcher_groups", event, ["hooks", event], groups.length));
         let entries = 0;
+        let firstPastCap;
         const kept = [];
+        const rawGroups = rawMember(raw, event);
         for (const [groupIndex, group] of groups.entries()) {
+            const rawGroup = rawMember(rawGroups, groupIndex);
+            const rawSource = rawMember(rawGroup, "source");
+            const source = rawSource === undefined ? undefined : readHookGroupSource(rawSource);
+            if (rawSource !== undefined && source === undefined)
+                return hooksRefused({ reason: "wire_key_invalid", path: ["hooks", event, groupIndex, "source"], key: "source" });
             const hooks = [];
-            for (const [entryIndex, entry] of group.hooks.entries()) {
+            for (const [entryIndex, contractEntry] of group.hooks.entries()) {
                 entries++;
-                if (!isRunnableHookEntry(entry)) {
-                    return { error: unsupportedHookEntryTypeRefusal(["hooks", event, groupIndex, "hooks", entryIndex, "type"], entry.type) };
-                }
-                if (entry.type === "command" && entry.command.length > MAX_HOOK_COMMAND_CHARS) {
-                    return { error: `settings.hooks.${event}: command exceeds ${MAX_HOOK_COMMAND_CHARS} chars` };
+                const at = ["hooks", event, groupIndex, "hooks", entryIndex];
+                if (entries === MAX_HOOK_ENTRIES_PER_EVENT + 1)
+                    firstPastCap = at;
+                if (!isRunnableHookEntry(contractEntry))
+                    return hooksRefused({ reason: "unsupported_entry_type", path: [...at, "type"], type: contractEntry.type });
+                let entry = contractEntry;
+                if (entry.type === "command") {
+                    const rawEntry = rawMember(rawMember(rawGroup, "hooks"), entryIndex);
+                    const rawArgs = rawMember(rawEntry, "args");
+                    const rawPlugin = rawMember(rawEntry, "plugin");
+                    const args = rawArgs === undefined ? undefined : readHookArgs(rawArgs);
+                    if (rawArgs !== undefined && args === undefined)
+                        return hooksRefused({ reason: "wire_key_invalid", path: [...at, "args"], key: "args" });
+                    const plugin = rawPlugin === undefined ? undefined : readHookPlugin(rawPlugin);
+                    if (rawPlugin !== undefined && plugin === undefined)
+                        return hooksRefused({ reason: "wire_key_invalid", path: [...at, "plugin"], key: "plugin" });
+                    entry = { ...entry, ...(args !== undefined ? { args } : {}), ...(plugin !== undefined ? { plugin } : {}) };
+                    const line = commandLineChars(entry);
+                    if (line > MAX_HOOK_COMMAND_CHARS)
+                        return hooksRefused(hooksCapIssue("command", event, [...at, "command"], line));
+                    if (plugin !== undefined && hookPluginChars(plugin) > MAX_HOOK_COMMAND_CHARS)
+                        return hooksRefused(hooksCapIssue("plugin", event, [...at, "plugin"], hookPluginChars(plugin)));
                 }
                 if (entry.type === "http") {
-                    if (entry.url.length > MAX_HOOK_COMMAND_CHARS) {
-                        return { error: `settings.hooks.${event}: url exceeds ${MAX_HOOK_COMMAND_CHARS} chars` };
-                    }
+                    if (entry.url.length > MAX_HOOK_COMMAND_CHARS)
+                        return hooksRefused(hooksCapIssue("url", event, [...at, "url"], entry.url.length));
                     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}` };
-                    }
+                    if (headerEntries.length > MAX_HOOK_HTTP_HEADERS)
+                        return hooksRefused(hooksCapIssue("headers", event, [...at, "headers"], headerEntries.length));
                     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 (headerChars > MAX_HOOK_COMMAND_CHARS)
+                        return hooksRefused(hooksCapIssue("header_chars", event, [...at, "headers"], headerChars));
+                    const envVars = entry.allowedEnvVars?.length ?? 0;
+                    if (envVars > MAX_HOOK_HTTP_HEADERS)
+                        return hooksRefused(hooksCapIssue("allowed_env_vars", event, [...at, "allowedEnvVars"], envVars));
                 }
                 hooks.push(entry);
             }
-            kept.push(group.matcher !== undefined ? { matcher: group.matcher, hooks } : { hooks });
-        }
-        if (entries > MAX_HOOK_ENTRIES_PER_EVENT) {
-            return { error: `settings.hooks.${event}: ${entries} entries exceeds cap ${MAX_HOOK_ENTRIES_PER_EVENT}` };
+            kept.push({ ...(group.matcher !== undefined ? { matcher: group.matcher } : {}), ...(source !== undefined ? { source } : {}), hooks });
         }
+        if (firstPastCap !== undefined)
+            return hooksRefused(hooksCapIssue("event_entries", event, firstPastCap, entries));
         config[event] = kept;
     }
     return { config };
 }
 export function hookMatcherMatches(matcher, value) {
-    return hookMatcherSelects(matcher, value);
+    const evaluate = MATCHER_EVALUATION[hookMatcherForm(matcher)][RUNTIME_EVAL_DEPTH];
+    switch (evaluate) {
+        case "inline":
+        case "budgeted":
+            return matcherSelectsBy(evaluate, matcher, value, ADMISSION_MATCHER_BUDGET.budgetMs);
+        case "unreadable":
+            return "invalid";
+        default: {
+            const unreachable = evaluate;
+            return unreachable;
+        }
+    }
 }
 export function hookIfMatches(cond, payload) {
     if (cond.length > 500 || (cond.match(/\*/g)?.length ?? 0) > 16)
@@ -318,10 +471,20 @@ export function hookIfMatches(cond, payload) {
     if (!m)
         return "unevaluable";
     const nameOk = hookMatcherMatches(m[1].trim(), toolName);
-    if (nameOk === "invalid")
-        return "unevaluable";
-    if (!nameOk)
-        return "not_matched";
+    switch (nameOk) {
+        case "invalid":
+            return "unevaluable";
+        case "over_budget":
+            return "over_budget";
+        case false:
+            return "not_matched";
+        case true:
+            break;
+        default: {
+            const unreachable = nameOk;
+            return unreachable;
+        }
+    }
     const spec = m[2];
     if (spec === undefined || spec === "*" || spec === "")
         return true;
@@ -340,8 +503,11 @@ export function hookIfMatches(cond, payload) {
 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 logHookCommandFailed(ctx, event, run) {
+    ctx.logger.warn("hook_command_failed", { event, code: run.code, stderr: echoCallerText(run.stderr, { maxChars: LOG_ERROR_ECHO_CHARS }) });
+}
+function logHookSystemMessage(ctx, event, message) {
+    ctx.logger.info("hook_system_message", { event, message: echoCallerText(message, { maxChars: LOG_MESSAGE_ECHO_CHARS }) });
 }
 function hookDisplayName(entry) {
     if (typeof entry.statusMessage === "string" && entry.statusMessage.length > 0)
@@ -370,7 +536,7 @@ function emitHookNotice(ctx, n) {
     }
     catch (e) {
         recordFailOpen("server.hooks.notice-sink-threw", `kind=${n.kind} event=${n.event}`);
-        ctx.logger.warn("hook_notice_sink_threw", { kind: n.kind, event: n.event, error: clip(String(e), 200) });
+        ctx.logger.warn("hook_notice_sink_threw", { kind: n.kind, event: n.event, error: echoCallerText(String(e), { maxChars: LOG_PREVIEW_ECHO_CHARS }) });
     }
 }
 function noteHookFailure(ctx, args) {
@@ -389,84 +555,212 @@ function noteHookFailure(ctx, args) {
         ...(args.detail !== undefined ? { detail: boundedNoticeText(args.detail) } : {}),
     });
 }
+function noteMatcherOverBudget(ctx, args) {
+    const budgetMs = ADMISSION_MATCHER_BUDGET.budgetMs;
+    const shown = (text) => echoCallerText(boundedNoticeText(text), { maxChars: MATCHER_ECHO_CHARS });
+    const expression = shown(args.expression);
+    const value = shown(args.value);
+    ctx.logger.warn("hook_matcher_over_budget", { event: args.event, scope: args.scope, expression, value, budgetMs, selected: true });
+    const first = args.entries[0];
+    if (first === undefined)
+        return;
+    const what = args.scope === "if" ? "if condition" : "matcher";
+    const count = args.entries.length;
+    noteHookFailure(ctx, {
+        event: args.event,
+        entry: first,
+        reason: "matcher_over_budget",
+        ...(args.toolName !== undefined ? { toolName: args.toolName } : {}),
+        detail: `${what} \`${expression}\` did not finish within ${budgetMs} ms on \`${value}\`; treated as selected (${count} ${count === 1 ? "entry" : "entries"})`,
+    });
+}
+function matcherGroupSelected(ctx, event, group, value, toolName) {
+    const answer = hookMatcherMatches(group.matcher, value);
+    switch (answer) {
+        case true:
+            return true;
+        case false:
+            return false;
+        case "invalid":
+            ctx.logger.warn("hook_matcher_invalid", { event, matcher: echoCallerText(group.matcher ?? "", { maxChars: MATCHER_ECHO_CHARS }) });
+            return "invalid";
+        case "over_budget":
+            noteMatcherOverBudget(ctx, { event, scope: "matcher", expression: group.matcher ?? "", value, entries: group.hooks, ...(toolName !== undefined ? { toolName } : {}) });
+            return "over_budget";
+        default: {
+            const unreachable = answer;
+            return unreachable;
+        }
+    }
+}
+export const PERMISSIVE_VERDICT_EVENTS = {
+    PreToolUse: true,
+    PostToolUse: false,
+    PostToolUseFailure: false,
+    PostToolBatch: false,
+    Notification: false,
+    UserPromptSubmit: false,
+    UserPromptExpansion: false,
+    SessionStart: false,
+    SessionEnd: false,
+    Stop: false,
+    StopFailure: false,
+    SubagentStart: false,
+    SubagentStop: false,
+    PreCompact: false,
+    PostCompact: false,
+    PermissionRequest: false,
+    PermissionDenied: false,
+    Setup: false,
+    TeammateIdle: false,
+    TaskCreated: false,
+    TaskCompleted: false,
+    Elicitation: false,
+    ElicitationResult: false,
+    ConfigChange: false,
+    WorktreeCreate: false,
+    WorktreeRemove: false,
+    InstructionsLoaded: false,
+    CwdChanged: false,
+    FileChanged: false,
+    MessageDisplay: false,
+    DirectoryAdded: false,
+    PreModelSwitch: false,
+    PostModelSwitch: false,
+};
+const DISTRUST_DETAIL = {
+    input_truncated: `the hook did not receive the whole payload (tool_input over ${MAX_TOOL_INPUT_CHARS} characters was replaced by a truncation marker, or a prompt / agent entry's payload text was clipped at that size); its allow / updatedInput are not honored`,
+    matcher_over_budget: "the matcher (or the if condition's tool-name part) did not finish within its budget; the entry ran as selected, so its allow / updatedInput are not honored",
+};
+function noteVerdictUntrusted(ctx, args) {
+    const notice = {
+        kind: "hook_verdict_untrusted",
+        event: args.event,
+        reason: args.reason,
+        lane: hookPhaseOf(args.source) === "unmanaged" ? "unmanaged" : "managed",
+        hookName: boundedNoticeText(hookDisplayName(args.entry)),
+        entryType: args.entry.type,
+        ...(args.toolName !== undefined ? { toolName: args.toolName } : {}),
+        ...(args.source !== undefined ? { source: boundedNoticeText(args.source) } : {}),
+        detail: boundedNoticeText(DISTRUST_DETAIL[args.reason]),
+    };
+    const logEcho = (text) => echoCallerText(text, { maxChars: MAX_HOOK_NOTICE_TEXT_CHARS });
+    ctx.logger.warn("hook_verdict_not_honored", {
+        event: notice.event,
+        reason: notice.reason,
+        lane: notice.lane,
+        hookName: logEcho(notice.hookName),
+        entryType: notice.entryType,
+        ...(notice.toolName !== undefined ? { toolName: notice.toolName } : {}),
+        ...(notice.source !== undefined ? { source: logEcho(notice.source) } : {}),
+        detail: notice.detail,
+    });
+    if (!ctx.onHookNotice)
+        return;
+    emitHookNotice(ctx, notice);
+}
+function createUnrunLedger(ctx, event, toolName) {
+    let managedWithoutVerdict = false;
+    return {
+        untrusted(source, entry, reason) {
+            if (hookPhaseOf(source) === "unmanaged")
+                return;
+            managedWithoutVerdict = true;
+            noteVerdictUntrusted(ctx, { event, reason, entry, source, toolName });
+        },
+        unrun(source, entry, reason, detail) {
+            if (source === undefined || hookPhaseOf(source) === "unmanaged")
+                return;
+            managedWithoutVerdict = true;
+            ctx.logger.warn("hook_managed_unrun", { event, reason, source: echoCallerText(source), type: entry.type, ...(toolName !== undefined ? { tool: toolName } : {}) });
+            if (!ctx.onHookNotice)
+                return;
+            emitHookNotice(ctx, {
+                kind: "hook_managed_unrun",
+                event,
+                reason,
+                source: boundedNoticeText(source),
+                hookName: boundedNoticeText(hookDisplayName(entry)),
+                entryType: entry.type,
+                ...(toolName !== undefined ? { toolName } : {}),
+                ...(detail !== undefined ? { detail: boundedNoticeText(detail) } : {}),
+            });
+        },
+        get managedWithoutVerdict() {
+            return managedWithoutVerdict;
+        },
+    };
+}
+function noteExitNonzero(ctx, ledger, event, ran, toolName, detail) {
+    logHookCommandFailed(ctx, event, ran.run);
+    noteHookFailure(ctx, { event, entry: ran.entry, reason: "exit_nonzero", exitCode: ran.run.code, stderr: ran.run.stderr, ...(toolName !== undefined ? { toolName } : {}), ...(detail !== undefined ? { detail } : {}) });
+    ledger.unrun(ran.source, ran.entry, "exit_nonzero");
+}
 export function buildHookContext(parts) {
-    const present = parts.filter((p) => p.length > 0).map(readHookContextPart);
+    const present = parts.filter((p) => p.length > 0);
     if (present.length === 0)
         return undefined;
     const kept = [];
     let used = 0;
     let truncating = false;
-    let messages = 0;
     let omitted = 0;
     let droppedChars = 0;
     for (const part of present) {
-        messages += part.messages;
-        omitted += part.omitted;
-        droppedChars += part.dropped;
         if (!truncating) {
             const sep = kept.length > 0 ? 1 : 0;
             const room = MAX_HOOK_CONTEXT_TOTAL_CHARS - used - sep;
-            if (room >= part.body.length) {
-                if (part.body.length > 0) {
-                    kept.push(part.body);
-                    used += sep + part.body.length;
-                }
+            if (room >= part.length) {
+                kept.push(part);
+                used += sep + part.length;
                 continue;
             }
             truncating = true;
-            if (part.messages === 1 && room >= MIN_HOOK_CONTEXT_PARTIAL_CHARS) {
-                kept.push(part.body.slice(0, room));
+            if (room >= MIN_HOOK_CONTEXT_PARTIAL_CHARS) {
+                kept.push(part.slice(0, room));
                 used += sep + room;
-                droppedChars += part.body.length - room;
+                droppedChars += part.length - room;
                 continue;
             }
         }
-        omitted += part.messages - part.omitted;
-        droppedChars += part.body.length;
+        omitted += 1;
+        droppedChars += part.length;
     }
     const body = kept.join("\n");
     if (droppedChars === 0)
         return body;
-    const marker = `[hook context truncated at ${MAX_HOOK_CONTEXT_TOTAL_CHARS} chars: ${omitted} of ${messages} hook messages omitted, ${droppedChars} characters dropped]`;
+    const marker = `[hook context truncated at ${MAX_HOOK_CONTEXT_TOTAL_CHARS} chars: ${omitted} of ${present.length} hook messages omitted, ${droppedChars} characters dropped]`;
     return kept.length > 0 ? `${body}\n${marker}` : marker;
 }
-const HOOK_CONTEXT_MARKER_RE = new RegExp(`\\n\\[hook context truncated at ${MAX_HOOK_CONTEXT_TOTAL_CHARS} chars: (\\d+) of (\\d+) hook messages omitted, (\\d+) characters dropped\\]$`);
-const MAX_HOOK_CONTEXT_PARSED_COUNT = 2 ** 42;
-function readHookContextPart(part) {
-    const m = HOOK_CONTEXT_MARKER_RE.exec(part);
-    if (!m)
-        return { body: part, messages: 1, omitted: 0, dropped: 0 };
-    const omitted = Number(m[1]);
-    const messages = Number(m[2]);
-    const dropped = Number(m[3]);
-    const sane = (n) => Number.isSafeInteger(n) && n <= MAX_HOOK_CONTEXT_PARSED_COUNT;
-    if (!sane(omitted) || !sane(messages) || !sane(dropped) || messages < 1 || omitted > messages || dropped < 1) {
-        return { body: part, messages: 1, omitted: 0, dropped: 0 };
-    }
-    return { body: part.slice(0, part.length - m[0].length), messages, omitted, dropped };
-}
 function buildHookContextField(parts) {
     const text = buildHookContext(parts);
     return text === undefined ? {} : { additionalContext: text };
 }
-async function runCommandHook(entry, payload, ctx) {
-    try {
-        await resolveHostShell();
-    }
-    catch (e) {
-        return { code: null, stdout: "", stderr: "", timedOut: false, spawnError: String(e) };
+function spawnPlannedCommand(plan, ctx, stdio) {
+    const env = hookEnvOverBase(plan.env, true);
+    if (plan.kind === "exec")
+        return spawn(plan.file, [...plan.args], { cwd: ctx.cwd, env, stdio, detached: true });
+    const sh = hostShell();
+    return spawn(sh.shell, [...sh.args, plan.command], { cwd: ctx.cwd, env, stdio, detached: true });
+}
+async function runCommandHook(entry, payload, ctx, halt) {
+    const plan = await planCommandSpawn(entry, ctx.cwd, ctx.shellEnv);
+    if (plan.kind === "refused")
+        return { code: null, stdout: "", stderr: "", timedOut: false, spawnError: plan.error };
+    if (plan.kind === "shell") {
+        try {
+            await resolveHostShell();
+        }
+        catch (e) {
+            return { code: null, stdout: "", stderr: "", timedOut: false, spawnError: String(e) };
+        }
     }
+    if (halt.aborted)
+        return { code: null, stdout: "", stderr: "", timedOut: false, aborted: {} };
     return new Promise((resolve) => {
         const timeoutMs = Math.min(entry.timeout ?? DEFAULT_HOOK_TIMEOUT_SECONDS, MAX_HOOK_TIMEOUT_SECONDS) * 1000;
         let child;
         try {
-            const sh = hostShell();
-            child = spawn(sh.shell, [...sh.args, entry.command], {
-                cwd: ctx.cwd,
-                env: hookEnv(ctx),
-                stdio: ["pipe", "pipe", "pipe"],
-                detached: true,
-            });
+            child = spawnPlannedCommand(plan, ctx, ["pipe", "pipe", "pipe"]);
         }
         catch (e) {
             resolve({ code: null, stdout: "", stderr: "", timedOut: false, spawnError: String(e) });
@@ -477,16 +771,20 @@ async function runCommandHook(entry, payload, ctx) {
         let stderr = "";
         let timedOut = false;
         let settled = false;
+        let sent;
         const settle = (code) => {
             if (settled)
                 return;
             settled = true;
             clearTimeout(timer);
+            halt.removeEventListener("abort", onHalt);
             ticket?.release();
-            resolve({ code, stdout, stderr, timedOut });
+            resolve({ code, stdout, stderr, timedOut, ...(sent !== undefined ? { aborted: { signal: sent } } : {}) });
         };
         const timer = setTimeout(() => {
             timedOut = true;
+            if (sent !== undefined)
+                sent = "SIGKILL";
             try {
                 if (child.pid)
                     process.kill(-child.pid, "SIGKILL");
@@ -498,6 +796,31 @@ async function runCommandHook(entry, payload, ctx) {
             }
             settle(null);
         }, timeoutMs);
+        const signalGroup = (sig) => {
+            try {
+                if (child.pid)
+                    (sig === "SIGTERM" ? killTreeSoft : killTreeHard)(child.pid);
+                else
+                    child.kill(sig);
+            }
+            catch {
+                child.kill(sig);
+            }
+        };
+        const onHalt = () => {
+            if (settled)
+                return;
+            sent = "SIGTERM";
+            signalGroup("SIGTERM");
+            const escalate = setTimeout(() => {
+                if (child.exitCode !== null || child.signalCode !== null)
+                    return;
+                sent = "SIGKILL";
+                signalGroup("SIGKILL");
+            }, HOOK_KILL_GRACE_MS);
+            escalate.unref();
+        };
+        halt.addEventListener("abort", onHalt, { once: true });
         child.stdout?.on("data", (d) => {
             if (stdout.length < MAX_HOOK_OUTPUT_BYTES)
                 stdout += d.toString("utf8").slice(0, MAX_HOOK_OUTPUT_BYTES - stdout.length);
@@ -508,6 +831,7 @@ async function runCommandHook(entry, payload, ctx) {
         });
         child.on("error", (e) => {
             clearTimeout(timer);
+            halt.removeEventListener("abort", onHalt);
             if (!settled) {
                 settled = true;
                 resolve({ code: null, stdout, stderr, timedOut, spawnError: String(e) });
@@ -518,18 +842,18 @@ async function runCommandHook(entry, payload, ctx) {
         child.stdin?.end(`${JSON.stringify(boundedToolInputPayload(payload))}\n`);
     });
 }
-async function fireAsyncCommandHook(entry, payload, ctx, event) {
+async function fireAsyncCommandHook(entry, payload, ctx, event, halt) {
     try {
         const rewake = entry.asyncRewake === true;
         const timeoutMs = Math.min(entry.timeout ?? DEFAULT_HOOK_TIMEOUT_SECONDS, MAX_HOOK_TIMEOUT_SECONDS) * 1000;
-        await resolveHostShell();
-        const sh = hostShell();
-        const child = spawn(sh.shell, [...sh.args, entry.command], {
-            cwd: ctx.cwd,
-            env: hookEnv(ctx),
-            stdio: ["pipe", "ignore", rewake ? "pipe" : "ignore"],
-            detached: true,
-        });
+        const plan = await planCommandSpawn(entry, ctx.cwd, ctx.shellEnv);
+        if (plan.kind === "refused")
+            throw new Error(plan.error);
+        if (plan.kind === "shell")
+            await resolveHostShell();
+        if (halt.aborted)
+            return;
+        const child = spawnPlannedCommand(plan, ctx, ["pipe", "ignore", rewake ? "pipe" : "ignore"]);
         const ticket = adoptHostForegroundChild(child);
         let killedByTimeout = false;
         const timer = setTimeout(() => {
@@ -555,7 +879,7 @@ async function fireAsyncCommandHook(entry, payload, ctx, event) {
         }
         child.on("error", (e) => {
             clearTimeout(timer);
-            ctx.logger.warn("hook_async_failed", { event, reason: "spawn_failed", error: clip(String(e), 300) });
+            ctx.logger.warn("hook_async_failed", { event, reason: "spawn_failed", error: echoCallerText(String(e), { maxChars: LOG_ERROR_ECHO_CHARS }) });
             noteHookFailure(ctx, { event, entry, reason: "spawn_failed", stderr: String(e), toolName: toolNameOf(payload) });
         });
         child.on("close", (code) => {
@@ -578,14 +902,14 @@ async function fireAsyncCommandHook(entry, payload, ctx, event) {
                     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) }));
+            }, (e) => ctx.logger.warn("hook_async_rewake_dropped", { event, reason: "wake_failed", error: echoCallerText(String(e), { maxChars: LOG_PREVIEW_ECHO_CHARS }) }));
         });
         child.stdin?.on("error", () => { });
         child.stdin?.end(`${JSON.stringify(boundedToolInputPayload(payload))}\n`);
         child.unref();
     }
     catch (e) {
-        ctx.logger.warn("hook_async_failed", { event, reason: "spawn_failed", error: clip(String(e), 300) });
+        ctx.logger.warn("hook_async_failed", { event, reason: "spawn_failed", error: echoCallerText(String(e), { maxChars: LOG_ERROR_ECHO_CHARS }) });
         noteHookFailure(ctx, { event, entry, reason: "spawn_failed", stderr: String(e), toolName: toolNameOf(payload) });
     }
 }
@@ -610,14 +934,19 @@ function noteAsyncOutcome(entry, ctx, event, payload, outcome) {
         ...(code === 2 ? { detail: "exit 2 on a fire-and-forget async hook: there is no blocking or wake face to honor it (asyncRewake would wake the model)" } : {}),
     });
 }
+function llmHookArguments(payload) {
+    const bounded = boundedToolInputPayload(payload);
+    const json = JSON.stringify(bounded);
+    const text = clipDataText(json, MAX_TOOL_INPUT_CHARS);
+    return { text, truncated: bounded !== payload || text !== json };
+}
 async function runLlmHook(entry, payload, ctx, extra) {
     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 substituted = entry.prompt.split("$ARGUMENTS").join(args);
+    const substituted = entry.prompt.split("$ARGUMENTS").join(llmHookArguments(payload).text);
     const prompt = extra?.transcript !== undefined ? `${extra.transcript}\n\n---\n\n${wrapCondition("Stop", substituted)}` : substituted;
     let hardTopTimer;
     const hardTop = new Promise((r) => {
@@ -647,9 +976,9 @@ async function runLlmHook(entry, payload, ctx, extra) {
         if (!res.ok) {
             return res.code === "hard_timeout"
                 ? { code: null, stdout: "", stderr: "", timedOut: true, ...(noticed ? { noticed } : {}) }
-                : { code: null, stdout: "", stderr: "", timedOut: false, spawnError: clip(res.error, 500), ...(noticed ? { noticed } : {}) };
+                : { code: null, stdout: "", stderr: "", timedOut: false, spawnError: res.error, ...(noticed ? { noticed } : {}) };
         }
-        return { code: 0, stdout: clip(res.text, 1024 * 1024), stderr: "", timedOut: false };
+        return { code: 0, stdout: clipDataText(res.text, 1024 * 1024), stderr: "", timedOut: false };
     }
     finally {
         if (hardTopTimer !== undefined)
@@ -665,7 +994,9 @@ async function runHttpHook(entry, payload, ctx, event) {
             event,
             url: buildDisplaySafeUrl(entry.url),
             blankedCount: interpolated.blanked.length,
-            blanked: interpolated.blanked.slice(0, MAX_BLANKED_REFERENCES_LOGGED).map(({ header, name, reason }) => ({ header, name, reason })),
+            blanked: interpolated.blanked
+                .slice(0, MAX_BLANKED_REFERENCES_LOGGED)
+                .map(({ header, name, reason }) => ({ header: echoCallerText(header, { maxChars: LOG_PREVIEW_ECHO_CHARS }), name: echoCallerText(name, { maxChars: LOG_PREVIEW_ECHO_CHARS }), reason })),
         });
     }
     const headers = { "content-type": "application/json", ...interpolated.headers };
@@ -703,7 +1034,7 @@ async function runHttpHook(entry, payload, ctx, event) {
             if (trimmed === "")
                 return { code: 0, stdout: "{}", stderr: "", timedOut: false };
             if (!parseHookStdout(body)) {
-                ctx.logger.warn("hook_http_non_json_response", { url: buildDisplaySafeUrl(entry.url), preview: clip(trimmed, 200) });
+                ctx.logger.warn("hook_http_non_json_response", { url: buildDisplaySafeUrl(entry.url), preview: echoCallerText(trimmed, { maxChars: LOG_PREVIEW_ECHO_CHARS }) });
                 noteHookFailure(ctx, {
                     event: eventOfPayload(payload),
                     entry,
@@ -712,7 +1043,7 @@ async function runHttpHook(entry, payload, ctx, event) {
                     stderr: trimmed,
                     toolName: toolNameOf(payload),
                 });
-                return { code: 0, stdout: "", stderr: "", timedOut: false };
+                return { code: 0, stdout: "", stderr: "", timedOut: false, badJson: true };
             }
             return { code: 0, stdout: body, stderr: "", timedOut: false };
         }
@@ -748,14 +1079,16 @@ function boundedToolInputPayload(payload) {
     const bounded = boundedInputValue(p.tool_input);
     return bounded === p.tool_input ? payload : { ...p, tool_input: bounded };
 }
-function readHookStdout(run, entry, event, ctx, payload) {
+function readHookStdout(ran, event, ctx, payload, ledger) {
+    const { run, entry } = ran;
     const out = parseHookStdout(run.stdout);
     if (out !== undefined)
         return out;
     const t = run.stdout.trim();
     if (t.startsWith("{") || t.startsWith("[")) {
-        ctx.logger.warn("hook_bad_json_output", { event, type: entry.type, preview: clip(t, 200) });
+        ctx.logger.warn("hook_bad_json_output", { event, type: entry.type, preview: echoCallerText(t, { maxChars: LOG_PREVIEW_ECHO_CHARS }) });
         noteHookFailure(ctx, { event, entry, reason: "bad_json", exitCode: run.code, stderr: run.stderr, toolName: toolNameOf(payload) });
+        ledger.unrun(ran.source, entry, "bad_json");
     }
     return undefined;
 }
@@ -771,7 +1104,7 @@ function parseHookStdout(stdout) {
         return undefined;
     }
 }
-function runRunnableEntry(entry, payload, ctx, event, llmExtra) {
+function runRunnableEntry(entry, payload, ctx, event, llmExtra, halt) {
     switch (entry.type) {
         case "http":
             return runHttpHook(entry, payload, ctx, event);
@@ -780,7 +1113,7 @@ function runRunnableEntry(entry, payload, ctx, event, llmExtra) {
         case "agent":
             return runLlmHook(entry, payload, ctx, { system: ccAgentHookSystemFor(event), event });
         case "command":
-            return runCommandHook(entry, payload, ctx);
+            return runCommandHook(entry, payload, ctx, halt);
         default: {
             const unreachable = entry;
             void unreachable;
@@ -788,79 +1121,162 @@ function runRunnableEntry(entry, payload, ctx, event, llmExtra) {
         }
     }
 }
-async function runMatchingEntries(event, groups, matchValue, payload, ctx, onceFired, deadlineAt, keyBase, llmExtra) {
+function isSyncEntry(entry) {
+    return !(entry.type === "command" && (entry.async === true || entry.asyncRewake === true));
+}
+async function runMatchingEntries(event, groups, matchValue, payload, ctx, onceFired, halt, deadlineAt, ledger, llmExtra) {
     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 === "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;
+    const toolName = toolNameOf(payload);
+    const inputTruncated = boundedToolInputPayload(payload) !== payload;
+    const truncatedFor = (entry) => (entry.type === "prompt" || entry.type === "agent" ? llmHookArguments(payload).truncated : inputTruncated);
+    const settle = async (entry, onceKey) => {
+        if (halt.aborted)
+            return { kind: "halted" };
+        if (entry.once && onceFired.has(onceKey))
+            return { kind: "passed" };
+        let ifOverBudget = false;
+        if (entry.if !== undefined) {
+            const iv = hookIfMatches(entry.if, payload);
+            switch (iv) {
+                case true:
+                    break;
+                case "over_budget":
+                    noteMatcherOverBudget(ctx, { event, scope: "if", expression: entry.if, value: toolName ?? "", entries: [entry], ...(toolName !== undefined ? { toolName } : {}) });
+                    ifOverBudget = true;
+                    break;
+                case "not_matched":
+                    ctx.logger.warn("hook_entries_skipped", { event, type: entry.type, reason: "if_not_matched", if: echoCallerText(entry.if, { maxChars: IF_ECHO_CHARS }) });
+                    return { kind: "passed" };
+                case "unevaluable":
+                    ctx.logger.warn("hook_entries_skipped", { event, type: entry.type, reason: "if_unevaluable", if: echoCallerText(entry.if, { maxChars: IF_ECHO_CHARS }) });
+                    return { kind: "unrun", reason: "if_unevaluable" };
+                default: {
+                    const unreachable = iv;
+                    return unreachable;
                 }
             }
-            if (entry.type === "command" && (entry.async || entry.asyncRewake)) {
-                if (entry.once)
-                    onceFired.add(onceKey);
-                void fireAsyncCommandHook(entry, payload, ctx, event);
-                continue;
+        }
+        if (entry.type === "command" && entry.shell === "powershell") {
+            ctx.logger.warn("hook_entries_skipped", { event, type: entry.type, reason: "powershell_not_supported" });
+            return isSyncEntry(entry) ? { kind: "unrun", reason: "powershell_unsupported" } : { kind: "passed" };
+        }
+        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" });
+                return { kind: "unrun", reason: "llm_carrier_unavailable" };
             }
-            if (Date.now() > deadlineAt) {
-                ctx.logger.warn("hook_event_deadline_exceeded", { event, budgetSec: MAX_HOOK_EVENT_TOTAL_SECONDS });
-                return results;
+            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 });
+                return { kind: "unrun", reason: "llm_cap" };
             }
+        }
+        if (entry.type === "command" && (entry.async || entry.asyncRewake)) {
             if (entry.once)
                 onceFired.add(onceKey);
-            if (entry.type === "prompt" || entry.type === "agent")
-                llmEntries++;
-            const run = await runRunnableEntry(entry, payload, ctx, event, llmExtra);
-            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) });
-                if (!run.noticed)
-                    noteHookFailure(ctx, { event, entry, reason: "spawn_failed", exitCode: run.code, stderr: run.spawnError, toolName: toolNameOf(payload) });
-                continue;
-            }
-            if (run.timedOut) {
-                ctx.logger.warn("hook_command_timeout", { event, timeoutSec: Math.min(entry.timeout ?? DEFAULT_HOOK_TIMEOUT_SECONDS, MAX_HOOK_TIMEOUT_SECONDS) });
-                if (!run.noticed)
-                    noteHookFailure(ctx, { event, entry, reason: "timeout", exitCode: run.code, stderr: run.stderr, toolName: toolNameOf(payload) });
-                continue;
+            void fireAsyncCommandHook(entry, payload, ctx, event, halt);
+            return { kind: "passed" };
+        }
+        if (Date.now() > deadlineAt) {
+            ctx.logger.warn("hook_event_deadline_exceeded", { event, budgetSec: MAX_HOOK_EVENT_TOTAL_SECONDS });
+            return { kind: "unrun", reason: "budget_exhausted" };
+        }
+        if (entry.once)
+            onceFired.add(onceKey);
+        if (entry.type === "prompt" || entry.type === "agent")
+            llmEntries++;
+        const run = await runRunnableEntry(entry, payload, ctx, event, llmExtra, halt);
+        if (run.aborted !== undefined) {
+            if (run.aborted.signal !== undefined)
+                ctx.logger.warn("hook_command_killed", { event, type: entry.type, killed: true, signal: run.aborted.signal });
+            return { kind: "halted" };
+        }
+        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: echoCallerText(run.spawnError, { maxChars: LOG_ERROR_ECHO_CHARS }) });
+            if (!run.noticed)
+                noteHookFailure(ctx, { event, entry, reason: "spawn_failed", exitCode: run.code, stderr: run.spawnError, ...(toolName !== undefined ? { toolName } : {}) });
+            return { kind: "unrun", reason: "spawn_failed" };
+        }
+        if (run.timedOut) {
+            ctx.logger.warn("hook_command_timeout", { event, timeoutSec: Math.min(entry.timeout ?? DEFAULT_HOOK_TIMEOUT_SECONDS, MAX_HOOK_TIMEOUT_SECONDS) });
+            if (!run.noticed)
+                noteHookFailure(ctx, { event, entry, reason: "timeout", exitCode: run.code, stderr: run.stderr, ...(toolName !== undefined ? { toolName } : {}) });
+            return { kind: "unrun", reason: "timeout" };
+        }
+        if (run.badJson)
+            return { kind: "unrun", reason: "bad_json" };
+        return ifOverBudget ? { kind: "ran", run, overBudget: true } : { kind: "ran", run };
+    };
+    for (const { group, index } of groups) {
+        const selected = matcherGroupSelected(ctx, event, group, matchValue, toolName);
+        if (selected === "invalid") {
+            for (const entry of group.hooks)
+                if (isSyncEntry(entry))
+                    ledger.unrun(group.source, entry, "matcher_invalid");
+            continue;
+        }
+        if (selected === false)
+            continue;
+        for (const [ei, entry] of group.hooks.entries()) {
+            const fate = await settle(entry, `${event}:${index}:${ei}`);
+            switch (fate.kind) {
+                case "ran": {
+                    const distrust = !PERMISSIVE_VERDICT_EVENTS[event]
+                        ? undefined
+                        : truncatedFor(entry)
+                            ? "input_truncated"
+                            : selected === "over_budget" || fate.overBudget === true
+                                ? "matcher_over_budget"
+                                : undefined;
+                    results.push({ entry, run: fate.run, source: group.source, ...(distrust !== undefined ? { distrust } : {}) });
+                    if (distrust !== undefined)
+                        ledger.untrusted(group.source, entry, distrust);
+                    break;
+                }
+                case "unrun":
+                    ledger.unrun(group.source, entry, fate.reason);
+                    if (fate.reason === "budget_exhausted")
+                        return results;
+                    break;
+                case "passed":
+                    break;
+                case "halted":
+                    return results;
+                default: {
+                    const unreachable = fate;
+                    return unreachable;
+                }
             }
-            results.push({ entry, run });
         }
     }
     return results;
 }
+function createLaneClocks() {
+    const startedAt = {};
+    return (phase) => {
+        const lane = phase === "unmanaged" ? "unmanaged" : "managed";
+        return (startedAt[lane] ??= Date.now() + MAX_HOOK_EVENT_TOTAL_SECONDS * 1000);
+    };
+}
+function hookLanesOf(groups) {
+    const indexed = groups.map((group, index) => ({ group, index, phase: hookPhaseOf(group.source) }));
+    return HOOK_PHASES.map((phase) => ({ phase, groups: indexed.filter((g) => g.phase === phase).map(({ group, index }) => ({ group, index })) })).filter((l) => l.groups.length > 0);
+}
+function trustRank(phase) {
+    return HOOK_PHASES.length - 1 - HOOK_PHASES.indexOf(phase);
+}
+async function runEventLanes(event, groups, matchValue, payload, ctx, onceFired, halt, ledger, llmExtra) {
+    const deadlineFor = createLaneClocks();
+    const ran = [];
+    for (const lane of hookLanesOf(groups)) {
+        if (halt.aborted)
+            break;
+        for (const r of await runMatchingEntries(event, lane.groups, matchValue, payload, ctx, onceFired, halt, deadlineFor(lane.phase), ledger, llmExtra))
+            ran.push({ ...r, phase: lane.phase });
+    }
+    return ran.sort((a, b) => trustRank(a.phase) - trustRank(b.phase)).map(({ entry, run, source }) => ({ entry, run, source }));
+}
 function basePayload(ctx, permissionMode) {
     return {
         session_id: ctx.sessionId,
@@ -872,38 +1288,27 @@ function basePayload(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 { entry, run } of singles) {
+async function runObserveOnlyEvent(event, groups, matchValue, payload, ctx, onceFired, halt) {
+    const ledger = createUnrunLedger(ctx, event, toolNameOf(payload));
+    const singles = await runEventLanes(event, groups, matchValue, payload, ctx, onceFired, halt, ledger);
+    for (const ran of singles) {
+        const { run } = ran;
         if (run.code !== 0) {
-            ctx.logger.warn("hook_command_failed", { event, code: run.code, stderr: clip(run.stderr, 300) });
-            noteHookFailure(ctx, {
-                event,
-                entry,
-                reason: "exit_nonzero",
-                exitCode: run.code,
-                stderr: run.stderr,
-                toolName: toolNameOf(payload),
-                ...(run.code === 2 ? { detail: `exit 2 on ${event}: this event has no blocking face, so the hook's blocking intent could not be honored` } : {}),
-            });
+            noteExitNonzero(ctx, ledger, event, ran, toolNameOf(payload), run.code === 2 ? `exit 2 on ${event}: this event has no blocking face, so the hook's blocking intent could not be honored` : undefined);
             continue;
         }
-        const out = readHookStdout(run, entry, event, ctx, payload);
+        const out = readHookStdout(ran, event, ctx, payload, ledger);
         if (!out)
             continue;
         if (typeof out.systemMessage === "string")
-            ctx.logger.info("hook_system_message", { event, message: clip(out.systemMessage, 500) });
+            logHookSystemMessage(ctx, event, out.systemMessage);
         if (out.decision !== undefined || out.continue === false || out.hookSpecificOutput !== undefined) {
             ctx.logger.warn("hook_result_unsupported", { event });
         }
     }
 }
-export function createTaskHooks(config, ctx) {
+export function createSettingsHooksRegistration(config, ctx, budgetMs) {
     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 });
@@ -925,98 +1330,131 @@ export function createTaskHooks(config, ctx) {
         return undefined;
     }
     const onceFired = new Set();
-    const hooks = {};
+    const translators = {};
     if (pre) {
-        const preToolUseHook = async (toolName, input, tctx) => {
-            let currentInput = input;
+        translators.PreToolUse = async (e, signal) => {
+            const toolName = e.tool;
+            const ledger = createUnrunLedger(ctx, "PreToolUse", toolName);
+            const deadlineFor = createLaneClocks();
+            let currentInput = e.input;
             let rewritten = false;
             let asked;
             let allowedFor;
             let unknownDecision = false;
-            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 groupInput = currentInput;
-                const payload = {
-                    ...basePayload(ctx, tctx.permissionMode),
-                    hook_event_name: "PreToolUse",
-                    tool_name: toolName,
-                    tool_input: groupInput,
-                    tool_use_id: tctx.toolCallId,
-                };
-                const singles = await runMatchingEntries("PreToolUse", [{ ...group, matcher: undefined }], toolName, payload, ctx, onceFired, deadlineAt, `PreToolUse:${gi}`);
-                for (const { entry, 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, ...buildHookContextField(contexts) };
-                    }
-                    if (run.code !== 0) {
-                        ctx.logger.warn("hook_command_failed", { event: "PreToolUse", code: run.code, stderr: clip(run.stderr, 300) });
-                        noteHookFailure(ctx, { event: "PreToolUse", entry, reason: "exit_nonzero", exitCode: run.code, stderr: run.stderr, toolName });
-                        continue;
-                    }
-                    const out = readHookStdout(run, entry, "PreToolUse", ctx, payload);
-                    if (!out)
-                        continue;
-                    if (typeof out.systemMessage === "string")
-                        ctx.logger.info("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, ...buildHookContextField(contexts) };
-                    }
-                    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, ...buildHookContextField(contexts) };
-                    }
-                    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, ...buildHookContextField(contexts) };
+            const contexts = { unmanaged: [], managedPlugin: [], managedPolicy: [] };
+            const contextField = () => buildHookContextField([...HOOK_PHASES].sort((a, b) => trustRank(a) - trustRank(b)).flatMap((p) => contexts[p]));
+            const runPass = async (phase, groups, once) => {
+                let rewroteBy;
+                for (const laneGroup of groups) {
+                    const groupInput = currentInput;
+                    const payload = {
+                        ...basePayload(ctx, e.permissionMode),
+                        hook_event_name: "PreToolUse",
+                        tool_name: toolName,
+                        tool_input: groupInput,
+                        tool_use_id: e.tool_use_id,
+                    };
+                    const singles = await runMatchingEntries("PreToolUse", [laneGroup], toolName, payload, ctx, once, signal, deadlineFor(phase), ledger);
+                    for (const ran of singles) {
+                        const { entry, run } = ran;
+                        if (run.code === 2) {
+                            const reason = clipDataText(run.stderr.trim(), MAX_HOOK_FEEDBACK_CHARS) || "blocked by a PreToolUse hook";
+                            return { deny: { action: "deny", message: reason, ...contextField() } };
                         }
-                        if (decision === "ask") {
-                            asked = clip(typeof h.permissionDecisionReason === "string" ? h.permissionDecisionReason : "a PreToolUse hook requires approval", MAX_HOOK_FEEDBACK_CHARS);
+                        if (run.code !== 0) {
+                            noteExitNonzero(ctx, ledger, "PreToolUse", ran, toolName);
+                            continue;
                         }
-                        if (decision === "allow" || decision === undefined) {
-                            const rewrites = h.updatedInput !== null && typeof h.updatedInput === "object";
-                            if (rewrites) {
-                                currentInput = h.updatedInput;
-                                rewritten = true;
-                            }
-                            if (decision === "allow")
-                                allowedFor = { input: rewrites ? h.updatedInput : groupInput };
+                        const out = readHookStdout(ran, "PreToolUse", ctx, payload, ledger);
+                        if (!out)
+                            continue;
+                        if (typeof out.systemMessage === "string")
+                            logHookSystemMessage(ctx, "PreToolUse", out.systemMessage);
+                        if (out.continue === false) {
+                            const reason = clipDataText(typeof out.stopReason === "string" ? out.stopReason : "hook requested stop", MAX_HOOK_FEEDBACK_CHARS);
+                            return { deny: { action: "deny", message: reason, ...contextField() } };
                         }
-                        else if (decision !== "deny" && decision !== "ask") {
-                            unknownDecision = true;
-                            ctx.logger.warn("hook_permission_decision_unknown", {
-                                event: "PreToolUse",
-                                decision: clip(typeof decision === "string" ? decision : typeof decision, 200),
-                                tool: toolName,
-                                effect: "hook ruling not honored (closed word set is allow|deny|ask); this call falls back to the engine gate",
-                            });
+                        if (out.decision === "block") {
+                            const reason = clipDataText(typeof out.reason === "string" ? out.reason : "blocked by a PreToolUse hook", MAX_HOOK_FEEDBACK_CHARS);
+                            return { deny: { action: "deny", message: reason, ...contextField() } };
+                        }
+                        const hso = out.hookSpecificOutput;
+                        if (hso !== null && typeof hso === "object" && hso.hookEventName === "PreToolUse") {
+                            const h = hso;
+                            if (typeof h.additionalContext === "string")
+                                contexts[phase].push(clipDataText(h.additionalContext, MAX_HOOK_FEEDBACK_CHARS));
+                            const decision = h.permissionDecision;
+                            if (decision === "deny") {
+                                const reason = clipDataText(typeof h.permissionDecisionReason === "string" ? h.permissionDecisionReason : "denied by a PreToolUse hook", MAX_HOOK_FEEDBACK_CHARS);
+                                return { deny: { action: "deny", message: reason, ...contextField() } };
+                            }
+                            if (decision === "ask") {
+                                asked = clipDataText(typeof h.permissionDecisionReason === "string" ? h.permissionDecisionReason : "a PreToolUse hook requires approval", MAX_HOOK_FEEDBACK_CHARS);
+                            }
+                            if (decision === "allow" || decision === undefined) {
+                                const proposed = h.updatedInput !== null && typeof h.updatedInput === "object" ? h.updatedInput : undefined;
+                                const proposesRewrite = proposed !== undefined && canonicalJson(proposed) !== canonicalJson(groupInput);
+                                if (ran.distrust !== undefined && hookPhaseOf(ran.source) === "unmanaged" && (decision === "allow" || proposesRewrite)) {
+                                    noteVerdictUntrusted(ctx, { event: "PreToolUse", reason: ran.distrust, entry, source: ran.source, toolName });
+                                }
+                                const offered = ran.distrust === undefined ? proposed : undefined;
+                                const rewrites = offered !== undefined && proposesRewrite;
+                                if (rewrites) {
+                                    currentInput = offered;
+                                    rewritten = true;
+                                    rewroteBy = ran;
+                                }
+                                if (decision === "allow" && ran.distrust === undefined)
+                                    allowedFor = { input: rewrites ? offered : groupInput };
+                            }
+                            else if (decision !== "deny" && decision !== "ask") {
+                                unknownDecision = true;
+                                ctx.logger.warn("hook_permission_decision_unknown", {
+                                    event: "PreToolUse",
+                                    decision: echoCallerText(typeof decision === "string" ? decision : typeof decision, { maxChars: LOG_PREVIEW_ECHO_CHARS }),
+                                    tool: toolName,
+                                    effect: "hook ruling not honored (closed word set is allow|deny|ask); this call falls back to the engine gate",
+                                });
+                                ledger.unrun(ran.source, entry, "decision_out_of_set");
+                            }
                         }
                     }
                 }
+                return { rewroteBy };
+            };
+            for (const lane of hookLanesOf(pre)) {
+                if (lane.phase === "unmanaged") {
+                    const pass = await runPass(lane.phase, lane.groups, onceFired);
+                    if (pass.deny !== undefined)
+                        return pass.deny;
+                    continue;
+                }
+                const onceBefore = new Set(onceFired);
+                const first = await runPass(lane.phase, lane.groups, onceFired);
+                if (first.deny !== undefined)
+                    return first.deny;
+                if (first.rewroteBy === undefined)
+                    continue;
+                contexts[lane.phase].length = 0;
+                const rejudgeOnce = new Set(onceBefore);
+                const second = await runPass(lane.phase, lane.groups, rejudgeOnce);
+                for (const key of rejudgeOnce)
+                    onceFired.add(key);
+                if (second.deny !== undefined)
+                    return second.deny;
+                if (second.rewroteBy !== undefined) {
+                    ledger.unrun(second.rewroteBy.source, second.rewroteBy.entry, "rewrite_unsettled", "the managed hooks of this phase rewrote the tool input again after being re-run on their own rewrite; approval required");
+                }
             }
             if (asked !== undefined) {
+                return { action: "ask", message: asked, ...(rewritten ? { updatedInput: currentInput } : {}), ...contextField() };
+            }
+            if (ledger.managedWithoutVerdict) {
                 return {
                     action: "ask",
-                    message: asked,
+                    message: "a managed PreToolUse hook did not run to a verdict — approval required",
                     ...(rewritten ? { updatedInput: currentInput } : {}),
-                    ...buildHookContextField(contexts),
+                    ...contextField(),
                 };
             }
             if (unknownDecision) {
@@ -1024,60 +1462,63 @@ export function createTaskHooks(config, ctx) {
                     action: "ask",
                     message: "a PreToolUse hook returned an unrecognized permissionDecision — approval required",
                     ...(rewritten ? { updatedInput: currentInput } : {}),
-                    ...buildHookContextField(contexts),
+                    ...contextField(),
                 };
             }
-            const carried = { ...(rewritten ? { updatedInput: currentInput } : {}), ...buildHookContextField(contexts) };
+            const carried = { ...(rewritten ? { updatedInput: currentInput } : {}), ...contextField() };
             if (allowedFor !== undefined && allowedFor.input === currentInput)
                 return { action: "allow", ...carried };
-            if (rewritten || contexts.length > 0)
+            if (rewritten || HOOK_PHASES.some((p) => contexts[p].length > 0))
                 return carried;
             return undefined;
         };
-        hooks.preToolUse = preToolUseHook;
     }
     if (post) {
-        const postToolUseHook = async (toolName, input, output, tctx) => {
+        translators.PostToolUse = async (e, signal) => {
+            const toolName = e.tool;
+            const input = e.input;
+            const output = e.output;
             const contexts = [];
             const responseText = output.content
                 .map((c) => (c && typeof c === "object" && typeof c.text === "string" ? c.text : ""))
                 .join("");
             const payload = {
-                ...basePayload(ctx, tctx.permissionMode),
+                ...basePayload(ctx, e.permissionMode),
                 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,
+                tool_response: { isError: output.isError, text: clipDataText(responseText, MAX_TOOL_RESPONSE_CHARS) },
+                tool_use_id: e.tool_use_id,
             };
-            const singles = await runMatchingEntries("PostToolUse", post, toolName, payload, ctx, onceFired, Date.now() + MAX_HOOK_EVENT_TOTAL_SECONDS * 1000);
-            for (const { entry, run } of singles) {
+            const ledger = createUnrunLedger(ctx, "PostToolUse", toolName);
+            const singles = await runEventLanes("PostToolUse", post, toolName, payload, ctx, onceFired, signal, ledger);
+            for (const ran of singles) {
+                const { entry, run } = ran;
                 if (run.code === 2) {
-                    const fb = clip(run.stderr.trim(), MAX_HOOK_FEEDBACK_CHARS);
+                    const fb = clipDataText(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) });
-                    noteHookFailure(ctx, { event: "PostToolUse", entry, reason: "exit_nonzero", exitCode: run.code, stderr: run.stderr, toolName });
+                    noteExitNonzero(ctx, ledger, "PostToolUse", ran, toolName);
                     continue;
                 }
-                const out = readHookStdout(run, entry, "PostToolUse", ctx, payload);
+                const out = readHookStdout(ran, "PostToolUse", ctx, payload, ledger);
                 if (!out)
                     continue;
                 if (typeof out.systemMessage === "string")
-                    ctx.logger.info("hook_system_message", { event: "PostToolUse", message: clip(out.systemMessage, 500) });
+                    logHookSystemMessage(ctx, "PostToolUse", out.systemMessage);
                 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));
+                    contexts.push(clipDataText(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));
+                        contexts.push(clipDataText(h.additionalContext, MAX_HOOK_FEEDBACK_CHARS));
                     if (h.updatedMCPToolOutput !== undefined) {
                         ctx.logger.warn("hook_updated_mcp_output_unsupported", { event: "PostToolUse" });
                     }
@@ -1086,139 +1527,140 @@ export function createTaskHooks(config, ctx) {
             const additionalContext = buildHookContext(contexts);
             return additionalContext === undefined ? undefined : { additionalContext };
         };
-        hooks.postToolUse = postToolUseHook;
     }
     if (postFailure) {
-        const postToolUseFailureHook = async (toolName, input, f, tctx) => {
+        translators.PostToolUseFailure = async (e, signal) => {
+            const toolName = e.tool;
+            const f = e.failure;
             const contexts = [];
             const payload = {
-                ...basePayload(ctx, tctx.permissionMode),
+                ...basePayload(ctx, e.permissionMode),
                 hook_event_name: "PostToolUseFailure",
                 tool_name: toolName,
-                tool_input: input,
-                tool_use_id: tctx.toolCallId,
-                error: clip(f.error, MAX_TOOL_RESPONSE_CHARS),
+                tool_input: e.input,
+                tool_use_id: e.tool_use_id,
+                error: clipDataText(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 { entry, run } of singles) {
+            const ledger = createUnrunLedger(ctx, "PostToolUseFailure", toolName);
+            const singles = await runEventLanes("PostToolUseFailure", postFailure, toolName, payload, ctx, onceFired, signal, ledger);
+            for (const ran of singles) {
+                const { entry, run } = ran;
                 if (run.code === 2) {
-                    const fb = clip(run.stderr.trim(), MAX_HOOK_FEEDBACK_CHARS);
+                    const fb = clipDataText(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) });
-                    noteHookFailure(ctx, { event: "PostToolUseFailure", entry, reason: "exit_nonzero", exitCode: run.code, stderr: run.stderr, toolName });
+                    noteExitNonzero(ctx, ledger, "PostToolUseFailure", ran, toolName);
                     continue;
                 }
-                const out = readHookStdout(run, entry, "PostToolUseFailure", ctx, payload);
+                const out = readHookStdout(ran, "PostToolUseFailure", ctx, payload, ledger);
                 if (!out)
                     continue;
                 if (typeof out.systemMessage === "string")
-                    ctx.logger.info("hook_system_message", { event: "PostToolUseFailure", message: clip(out.systemMessage, 500) });
+                    logHookSystemMessage(ctx, "PostToolUseFailure", out.systemMessage);
                 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));
+                    contexts.push(clipDataText(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));
+                        contexts.push(clipDataText(h.additionalContext, MAX_HOOK_FEEDBACK_CHARS));
                 }
             }
             const additionalContext = buildHookContext(contexts);
             return additionalContext === undefined ? undefined : { additionalContext };
         };
-        hooks.postToolUseFailure = postToolUseFailureHook;
     }
     if (postBatch) {
-        const postToolBatchHook = async (calls, _meta, bctx) => {
+        translators.PostToolBatch = async (e, signal) => {
             const contexts = [];
             const payload = {
-                ...basePayload(ctx, bctx?.permissionMode),
+                ...basePayload(ctx, e.permissionMode),
                 hook_event_name: "PostToolBatch",
-                tool_calls: calls.map((c) => ({
+                tool_calls: e.batch.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) } : {}) },
+                    tool_response: { isError: c.isError, ...(c.response !== undefined ? { text: clipDataText(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 { entry, run } of singles) {
+            const ledger = createUnrunLedger(ctx, "PostToolBatch", undefined);
+            const singles = await runEventLanes("PostToolBatch", ignoreMatchers(postBatch), "", payload, ctx, onceFired, signal, ledger);
+            for (const ran of singles) {
+                const { entry, run } = ran;
                 if (run.code === 2) {
-                    const fb = clip(run.stderr.trim(), MAX_HOOK_FEEDBACK_CHARS);
+                    const fb = clipDataText(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) });
-                    noteHookFailure(ctx, { event: "PostToolBatch", entry, reason: "exit_nonzero", exitCode: run.code, stderr: run.stderr });
+                    noteExitNonzero(ctx, ledger, "PostToolBatch", ran);
                     continue;
                 }
-                const out = readHookStdout(run, entry, "PostToolBatch", ctx, payload);
+                const out = readHookStdout(ran, "PostToolBatch", ctx, payload, ledger);
                 if (!out)
                     continue;
                 if (typeof out.systemMessage === "string")
-                    ctx.logger.info("hook_system_message", { event: "PostToolBatch", message: clip(out.systemMessage, 500) });
+                    logHookSystemMessage(ctx, "PostToolBatch", out.systemMessage);
                 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));
+                    contexts.push(clipDataText(out.reason, MAX_HOOK_FEEDBACK_CHARS));
                 if (out.hookSpecificOutput !== undefined)
                     ctx.logger.warn("hook_result_unsupported", { event: "PostToolBatch" });
             }
             const additionalContext = buildHookContext(contexts);
             return additionalContext === undefined ? undefined : { additionalContext };
         };
-        hooks.postToolBatch = postToolBatchHook;
     }
     if (promptSubmit) {
-        const userPromptSubmitHook = async (prompt, uctx) => {
+        translators.UserPromptSubmit = async (e, signal) => {
             const contexts = [];
-            const payload = { ...basePayload(ctx, uctx?.permissionMode), 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 { entry, run } of singles) {
+            const payload = { ...basePayload(ctx, e.permissionMode), hook_event_name: "UserPromptSubmit", prompt: clipDataText(e.prompt, MAX_TOOL_INPUT_CHARS) };
+            const ledger = createUnrunLedger(ctx, "UserPromptSubmit", undefined);
+            const singles = await runEventLanes("UserPromptSubmit", ignoreMatchers(promptSubmit), "", payload, ctx, onceFired, signal, ledger);
+            for (const ran of singles) {
+                const { entry, run } = ran;
                 if (run.code === 2) {
-                    const reason = clip(run.stderr.trim(), MAX_HOOK_FEEDBACK_CHARS) || "blocked by a UserPromptSubmit hook";
+                    const reason = clipDataText(run.stderr.trim(), MAX_HOOK_FEEDBACK_CHARS) || "blocked by a UserPromptSubmit hook";
                     return { block: reason, ...buildHookContextField(contexts) };
                 }
                 if (run.code !== 0) {
-                    ctx.logger.warn("hook_command_failed", { event: "UserPromptSubmit", code: run.code, stderr: clip(run.stderr, 300) });
-                    noteHookFailure(ctx, { event: "UserPromptSubmit", entry, reason: "exit_nonzero", exitCode: run.code, stderr: run.stderr });
+                    noteExitNonzero(ctx, ledger, "UserPromptSubmit", ran);
                     continue;
                 }
-                const out = readHookStdout(run, entry, "UserPromptSubmit", ctx, payload);
+                const out = readHookStdout(ran, "UserPromptSubmit", ctx, payload, ledger);
                 if (!out)
                     continue;
                 if (typeof out.systemMessage === "string")
-                    ctx.logger.info("hook_system_message", { event: "UserPromptSubmit", message: clip(out.systemMessage, 500) });
+                    logHookSystemMessage(ctx, "UserPromptSubmit", out.systemMessage);
                 if (out.continue === false) {
-                    const reason = clip(typeof out.stopReason === "string" ? out.stopReason : "hook requested stop", MAX_HOOK_FEEDBACK_CHARS);
+                    const reason = clipDataText(typeof out.stopReason === "string" ? out.stopReason : "hook requested stop", MAX_HOOK_FEEDBACK_CHARS);
                     return { block: reason, ...buildHookContextField(contexts) };
                 }
                 if (out.decision === "block") {
-                    const reason = clip(typeof out.reason === "string" ? out.reason : "blocked by a UserPromptSubmit hook", MAX_HOOK_FEEDBACK_CHARS);
+                    const reason = clipDataText(typeof out.reason === "string" ? out.reason : "blocked by a UserPromptSubmit hook", MAX_HOOK_FEEDBACK_CHARS);
                     return { block: reason, ...buildHookContextField(contexts) };
                 }
                 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));
+                        contexts.push(clipDataText(h.additionalContext, MAX_HOOK_FEEDBACK_CHARS));
                 }
             }
             const additionalContext = buildHookContext(contexts);
             return additionalContext === undefined ? undefined : { additionalContext };
         };
-        hooks.userPromptSubmit = userPromptSubmitHook;
     }
     if (stopEntries) {
-        const stopHook = async (sctx) => {
+        translators.Stop = async (sctx, signal) => {
             const payload = { ...basePayload(ctx, sctx.permissionMode), hook_event_name: "Stop", stop_hook_active: sctx.stopHookActive };
             let llmExtra;
             const wantsPrompt = stopEntries.some((g) => g.hooks.some((h) => h.type === "prompt"));
@@ -1233,7 +1675,7 @@ export function createTaskHooks(config, ctx) {
                         branch = await sctx.getBranch?.();
                     }
                     catch (e) {
-                        ctx.logger.warn("hook_stop_branch_failed", { error: e instanceof Error ? e.message : String(e) });
+                        ctx.logger.warn("hook_stop_branch_failed", { error: echoCallerText(e instanceof Error ? e.message : String(e), { maxChars: LOG_ERROR_ECHO_CHARS }) });
                     }
                     const rendered = renderBranchTranscript(branch);
                     if (rendered.sufficient) {
@@ -1246,22 +1688,29 @@ export function createTaskHooks(config, ctx) {
                 }
             }
             const stopGroups = ignoreMatchers(stopEntries);
+            const ledger = createUnrunLedger(ctx, "Stop", undefined);
+            if (!llmExtra && wantsPrompt) {
+                for (const g of stopGroups)
+                    for (const h of g.hooks)
+                        if (h.type === "prompt")
+                            ledger.unrun(g.source, h, "evidence_unavailable", ctx.stopPromptTranscript === false ? "transcript disabled" : "no transcript evidence");
+            }
             const effectiveGroups = llmExtra || !wantsPrompt
                 ? stopGroups
                 : stopGroups.map((g) => ({ ...g, hooks: g.hooks.filter((h) => h.type !== "prompt") })).filter((g) => g.hooks.length > 0);
-            const singles = await runMatchingEntries("Stop", effectiveGroups, "", payload, ctx, onceFired, Date.now() + MAX_HOOK_EVENT_TOTAL_SECONDS * 1000, undefined, llmExtra);
+            const singles = await runEventLanes("Stop", effectiveGroups, "", payload, ctx, onceFired, signal, ledger, llmExtra);
             let block;
             let sawContinueFalse = false;
             const contexts = [];
-            for (const { entry, run } of singles) {
+            for (const ran of singles) {
+                const { entry, run } = ran;
                 if (run.code === 2) {
                     if (block === undefined)
-                        block = clip(run.stderr.trim(), MAX_HOOK_FEEDBACK_CHARS) || "blocked by a Stop hook";
+                        block = clipDataText(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) });
-                    noteHookFailure(ctx, { event: "Stop", entry, reason: "exit_nonzero", exitCode: run.code, stderr: run.stderr });
+                    noteExitNonzero(ctx, ledger, "Stop", ran);
                     continue;
                 }
                 if (llmExtra && entry.type === "prompt" && parseCcVerdict(run.stdout)) {
@@ -1269,33 +1718,34 @@ export function createTaskHooks(config, ctx) {
                     if (v.ok)
                         continue;
                     if (v.impossible) {
-                        ctx.logger.warn("hook_stop_condition_impossible", { event: "Stop", reason: clip(v.reason?.trim() ?? "", 500) });
+                        ctx.logger.warn("hook_stop_condition_impossible", { event: "Stop", reason: echoCallerText(v.reason?.trim() ?? "", { maxChars: LOG_MESSAGE_ECHO_CHARS }) });
                         continue;
                     }
                     if (block === undefined)
-                        block = clip(v.reason?.trim() || "stop condition not satisfied", MAX_HOOK_FEEDBACK_CHARS);
+                        block = clipDataText(v.reason?.trim() || "stop condition not satisfied", MAX_HOOK_FEEDBACK_CHARS);
                     continue;
                 }
-                const out = llmExtra && entry.type === "prompt" ? parseHookStdout(run.stdout) : readHookStdout(run, entry, "Stop", ctx, payload);
+                const out = llmExtra && entry.type === "prompt" ? parseHookStdout(run.stdout) : readHookStdout(ran, "Stop", ctx, payload, ledger);
                 if (!out) {
                     if (llmExtra && entry.type === "prompt") {
-                        ctx.logger.warn("hook_llm_unparsed_verdict", { event: "Stop", head: clip(run.stdout.trim(), 200) });
+                        ctx.logger.warn("hook_llm_unparsed_verdict", { event: "Stop", head: echoCallerText(run.stdout.trim(), { maxChars: LOG_PREVIEW_ECHO_CHARS }) });
                         emitHookNotice(ctx, { kind: "hook_decision_unavailable", event: "Stop", reason: "unparsed" });
+                        ledger.unrun(ran.source, entry, "bad_json", "the prompt hook's answer could not be read as a verdict");
                     }
                     continue;
                 }
                 if (typeof out.systemMessage === "string")
-                    ctx.logger.info("hook_system_message", { event: "Stop", message: clip(out.systemMessage, 500) });
+                    logHookSystemMessage(ctx, "Stop", out.systemMessage);
                 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);
+                    block = clipDataText(typeof out.reason === "string" ? out.reason : "blocked by a Stop hook", MAX_HOOK_FEEDBACK_CHARS);
                 }
                 const hso = out.hookSpecificOutput;
                 if (hso !== null && typeof hso === "object" && hso.hookEventName === "Stop") {
                     const h = hso;
                     if (typeof h.additionalContext === "string")
-                        contexts.push(clip(h.additionalContext, MAX_HOOK_FEEDBACK_CHARS));
+                        contexts.push(clipDataText(h.additionalContext, MAX_HOOK_FEEDBACK_CHARS));
                 }
             }
             if (sawContinueFalse)
@@ -1307,236 +1757,73 @@ export function createTaskHooks(config, ctx) {
                 ...buildHookContextField(contexts),
             };
         };
-        hooks.stop = stopHook;
     }
     if (stopFailureEntries) {
-        const stopFailureHook = async (fctx) => {
+        translators.StopFailure = async (fctx, signal) => {
             const turnError = toAssistantTurnError(fctx.errorKind);
             const payload = {
                 ...basePayload(ctx, undefined),
                 hook_event_name: "StopFailure",
                 error: turnError,
-                ...(fctx.error ? { error_details: clip(redactSecrets(fctx.error), MAX_HOOK_FEEDBACK_CHARS) } : {}),
+                ...(fctx.error ? { error_details: clipDataText(redactSecrets(fctx.error), MAX_HOOK_FEEDBACK_CHARS) } : {}),
             };
-            await runObserveOnlyEvent("StopFailure", stopFailureEntries, turnError, payload, ctx, onceFired);
+            await runObserveOnlyEvent("StopFailure", stopFailureEntries, turnError, payload, ctx, onceFired, signal);
         };
-        hooks.stopFailure = stopFailureHook;
     }
     if (preCompactEntries) {
-        const preCompactHook = async (pctx) => {
+        translators.PreCompact = async (pctx, signal) => {
             const payload = {
                 ...basePayload(ctx, undefined),
                 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 { entry, run } of singles) {
+            const ledger = createUnrunLedger(ctx, "PreCompact", undefined);
+            const singles = await runEventLanes("PreCompact", preCompactEntries, pctx.trigger, payload, ctx, onceFired, signal, ledger);
+            for (const ran of singles) {
+                const { entry, run } = ran;
                 if (run.code === 2) {
-                    return { block: clip(run.stderr.trim(), MAX_HOOK_FEEDBACK_CHARS) || "blocked by a PreCompact hook" };
+                    return { block: clipDataText(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) });
-                    noteHookFailure(ctx, { event: "PreCompact", entry, reason: "exit_nonzero", exitCode: run.code, stderr: run.stderr });
+                    noteExitNonzero(ctx, ledger, "PreCompact", ran);
                     continue;
                 }
-                const out = readHookStdout(run, entry, "PreCompact", ctx, payload);
+                const out = readHookStdout(ran, "PreCompact", ctx, payload, ledger);
                 if (!out)
                     continue;
                 if (typeof out.systemMessage === "string")
-                    ctx.logger.info("hook_system_message", { event: "PreCompact", message: clip(out.systemMessage, 500) });
+                    logHookSystemMessage(ctx, "PreCompact", out.systemMessage);
                 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 { block: clipDataText(typeof out.reason === "string" ? out.reason : "blocked by a PreCompact hook", MAX_HOOK_FEEDBACK_CHARS) };
                 }
             }
             return undefined;
         };
-        hooks.preCompact = preCompactHook;
     }
     if (postCompactEntries) {
-        const postCompactHook = async (cctx) => {
+        translators.PostCompact = async (cctx, signal) => {
             const payload = {
                 ...basePayload(ctx, undefined),
                 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);
-        };
-        hooks.postCompact = postCompactHook;
-    }
-    return hooks;
-}
-const HOOK_SLOT_FOLD = {
-    preToolUse: "custom",
-    preToolUseObservational: "custom",
-    postToolUse: "custom",
-    postToolUseFailure: "custom",
-    postToolBatch: "custom",
-    userPromptSubmit: "custom",
-    stop: "custom",
-    preCompact: "custom",
-    timeoutMs: "scalar",
-    postCompact: "observe-void",
-    stopFailure: "observe-void",
-    permissionDenied: "observe-void",
-};
-const OBSERVE_VOID_HOOK_SLOTS = Object.keys(HOOK_SLOT_FOLD).filter((k) => HOOK_SLOT_FOLD[k] === "observe-void");
-export function composeHooks(deployment, task) {
-    if (!deployment)
-        return task;
-    const d = deployment;
-    const t = task;
-    const out = {};
-    const timeoutMs = d.timeoutMs ?? t.timeoutMs;
-    if (timeoutMs !== undefined)
-        out.timeoutMs = timeoutMs;
-    if (d.preToolUse || t.preToolUse) {
-        const bothObservational = (d.preToolUse === undefined || d.preToolUseObservational === true) &&
-            (t.preToolUse === undefined || t.preToolUseObservational === true);
-        if (bothObservational)
-            out.preToolUseObservational = true;
-        out.preToolUse = async (toolName, input, ctx) => {
-            let current = input;
-            const contexts = [];
-            let asked;
-            let allowedFor;
-            for (const slot of [d.preToolUse?.bind(d), t.preToolUse?.bind(t)]) {
-                if (!slot)
-                    continue;
-                const r = receiveHookResult(await slot(toolName, current, ctx));
-                if (r === undefined || r === null || r === false)
-                    continue;
-                if (isEngineRefusal(r))
-                    return r;
-                if (r.additionalContext)
-                    contexts.push(r.additionalContext);
-                const action = r.action;
-                const updatedInput = r.updatedInput;
-                switch (action) {
-                    case "deny":
-                        return { ...r, ...buildHookContextField(contexts) };
-                    case "ask":
-                        asked = r;
-                        break;
-                    case "allow":
-                        if (updatedInput !== undefined)
-                            current = updatedInput;
-                        allowedFor = { input: current };
-                        break;
-                    case undefined:
-                        if (updatedInput !== undefined)
-                            current = updatedInput;
-                        break;
-                    default: {
-                        const unread = action;
-                        void unread;
-                        return r;
-                    }
-                }
-            }
-            if (asked) {
-                const askedUpdated = asked.updatedInput;
-                return {
-                    ...asked,
-                    ...(askedUpdated === undefined && current !== input ? { updatedInput: current } : {}),
-                    ...buildHookContextField(contexts),
-                };
-            }
-            const carried = { ...(current !== input ? { updatedInput: current } : {}), ...buildHookContextField(contexts) };
-            if (allowedFor !== undefined && allowedFor.input === current)
-                return { action: "allow", ...carried };
-            if (current !== input || contexts.length > 0)
-                return carried;
-            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 } : {}),
-                ...buildHookContextField(contexts),
-            };
-        };
-    }
-    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);
-            const additionalContext = buildHookContext(contexts);
-            return additionalContext === undefined ? undefined : { additionalContext };
-        };
-    }
-    if (d.postToolBatch || t.postToolBatch) {
-        out.postToolBatch = async (calls, meta, bctx) => {
-            const rd = d.postToolBatch ? await d.postToolBatch(calls, meta, bctx) : undefined;
-            const rt = t.postToolBatch ? await t.postToolBatch(calls, meta, bctx) : undefined;
-            const contexts = [rd?.additionalContext, rt?.additionalContext].filter((c) => typeof c === "string" && c.length > 0);
-            const additionalContext = buildHookContext(contexts);
-            return additionalContext === undefined ? undefined : { additionalContext };
-        };
-    }
-    if (d.userPromptSubmit || t.userPromptSubmit) {
-        out.userPromptSubmit = async (prompt, uctx) => {
-            const rd = d.userPromptSubmit ? await d.userPromptSubmit(prompt, uctx) : undefined;
-            if (rd?.block)
-                return { ...rd, ...buildHookContextField(rd.additionalContext ? [rd.additionalContext] : []) };
-            const rt = t.userPromptSubmit ? await t.userPromptSubmit(prompt, uctx) : 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 } : {}), ...buildHookContextField(contexts) };
-        };
-    }
-    if (d.stop || t.stop) {
-        out.stop = async (sctx) => {
-            const rd = d.stop ? await d.stop(sctx) : undefined;
-            if (rd?.block)
-                return { ...rd, ...buildHookContextField(rd.additionalContext ? [rd.additionalContext] : []) };
-            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 } : {}), ...buildHookContextField(contexts) };
-        };
-    }
-    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") } : {}),
+                compact_summary: clipDataText(cctx.summary, MAX_TOOL_RESPONSE_CHARS),
             };
+            await runObserveOnlyEvent("PostCompact", postCompactEntries, cctx.trigger, payload, ctx, onceFired, signal);
         };
     }
-    for (const slot of OBSERVE_VOID_HOOK_SLOTS) {
-        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;
+    const events = Object.keys(translators);
+    return {
+        name: SETTINGS_HOOKS_REGISTRATION,
+        uses: { events: events.flatMap((event) => SETTINGS_HOOK_STATIONS[event]), calls: [] },
+        budgetMs,
+        register(on) {
+            for (const event of events)
+                hangTranslator(on, event, translators);
+        },
+    };
 }
 //# sourceMappingURL=hook-runner.js.map