@sema-agent/server 7.132.0 → 7.133.0

package/dist/hooks/hook-runner.js

@@ -1,20 +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 { ENGINE_OWNED_HOOK_EVENTS } from "@sema-agent/settings-schema/hooks";
 import { describeToolCatalog } from "@sema-agent/core";
 import { hangClassic } from "./classic-stations.js";
-import { boundedNoticeText } from "../fleet/fleet-bus.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 { echoCallerText } from "../caller-text-echo.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;
@@ -31,11 +34,16 @@ const HOOK_ENV_ALLOWLIST = [
     "PATH", "HOME", "SHELL", "USER", "LOGNAME", "TERM", "TZ",
     "LANG", "LC_ALL", "LC_CTYPE", "LC_MESSAGES", "TMPDIR",
 ];
-function hookEnv(ctx, spawning) {
-    const base = spawning
+function hookBaseEnv(spawning) {
+    return spawning
         ? hostSubprocessEnv({ site: "server.hooks.spawn-env", policy: [...HOOK_ENV_ALLOWLIST], allow: [] })
         : composeHostSubprocessEnv({ policy: [...HOOK_ENV_ALLOWLIST], allow: [] });
-    return { ...base, CLAUDE_PROJECT_DIR: ctx.cwd, ...ctx.shellEnv };
+}
+function hookEnvOverBase(layer, spawning) {
+    return { ...hookBaseEnv(spawning), ...layer };
+}
+function hookEnv(ctx) {
+    return hookEnvOverBase(composeHookEnvLayer(ctx.shellEnv, ctx.cwd, undefined), false);
 }
 export const SETTINGS_HOOK_STATIONS = {
     PreToolUse: ["classic.PreToolUse"],
@@ -60,6 +68,7 @@ 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",
@@ -92,6 +101,10 @@ function isRunnableHookEntry(entry) {
 export const MAX_MATCHER_EVAL_CHARS = MAX_HOOK_COMMAND_CHARS;
 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";
@@ -144,6 +157,10 @@ const MATCHER_EVALUATION = {
     regex: { regex: "budgeted", literal: "not_applicable" },
     invalid: { regex: "unreadable", literal: "not_applicable" },
 };
+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" };
@@ -165,9 +182,9 @@ function judgeMatcher(matcher, depth, ledger, judgesAlias) {
     }
     const selects = (name) => {
         if (evaluate === "inline")
-            return hookMatcherSelects(matcher, name);
+            return matcherSelectsBy(evaluate, matcher, name, ledger.budgetMs);
         const startedAt = ledger.now();
-        const answer = matcherSelectsWithin(matcher, name, ledger.budgetMs);
+        const answer = matcherSelectsBy(evaluate, matcher, name, ledger.budgetMs);
         ledger.spentMs += ledger.now() - startedAt;
         if (answer === "over_budget" || answer === "invalid")
             return answer;
@@ -205,6 +222,13 @@ const HOOKS_CAPS = {
     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];
@@ -251,6 +275,8 @@ export function buildHooksRefusal(issue) {
         }
         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 piece = issue;
             const key = piece.key !== undefined ? hooksOutgoingKey(piece.key) : undefined;
@@ -350,6 +376,7 @@ export function parseHooksConfig(raw) {
         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 hooksRefused({ reason: "unknown-event", path: ["hooks", key] });
@@ -363,17 +390,39 @@ export function parseHooksConfig(raw) {
         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++;
                 const at = ["hooks", event, groupIndex, "hooks", entryIndex];
                 if (entries === MAX_HOOK_ENTRIES_PER_EVENT + 1)
                     firstPastCap = at;
-                if (!isRunnableHookEntry(entry))
-                    return hooksRefused({ reason: "unsupported_entry_type", path: [...at, "type"], type: entry.type });
-                if (entry.type === "command" && entry.command.length > MAX_HOOK_COMMAND_CHARS)
-                    return hooksRefused(hooksCapIssue("command", event, [...at, "command"], entry.command.length));
+                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 hooksRefused(hooksCapIssue("url", event, [...at, "url"], entry.url.length));
@@ -389,7 +438,7 @@ export function parseHooksConfig(raw) {
                 }
                 hooks.push(entry);
             }
-            kept.push(group.matcher !== undefined ? { matcher: group.matcher, hooks } : { hooks });
+            kept.push({ ...(group.matcher !== undefined ? { matcher: group.matcher } : {}), ...(source !== undefined ? { source } : {}), hooks });
         }
         if (firstPastCap !== undefined)
             return hooksRefused(hooksCapIssue("event_entries", event, firstPastCap, entries));
@@ -398,7 +447,18 @@ export function parseHooksConfig(raw) {
     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)
@@ -411,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;
@@ -433,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)
@@ -463,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) {
@@ -482,6 +555,147 @@ 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);
     if (present.length === 0)
@@ -521,24 +735,32 @@ 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, true),
-                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) });
@@ -549,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");
@@ -570,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);
@@ -580,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) });
@@ -590,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, true),
-            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(() => {
@@ -627,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) => {
@@ -650,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) });
     }
 }
@@ -682,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) => {
@@ -719,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)
@@ -731,13 +988,15 @@ async function runLlmHook(entry, payload, ctx, extra) {
 const MAX_BLANKED_REFERENCES_LOGGED = 16;
 async function runHttpHook(entry, payload, ctx, event) {
     const timeoutMs = Math.min(entry.timeout ?? DEFAULT_HOOK_TIMEOUT_SECONDS, MAX_HOOK_TIMEOUT_SECONDS) * 1000;
-    const interpolated = interpolateHookEnvVars(entry.headers ?? {}, entry.allowedEnvVars ?? [], hookEnv(ctx, false));
+    const interpolated = interpolateHookEnvVars(entry.headers ?? {}, entry.allowedEnvVars ?? [], hookEnv(ctx));
     if (interpolated.blanked.length > 0) {
         ctx.logger.warn("hook_http_header_env_blanked", {
             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 };
@@ -775,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,
@@ -784,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 };
         }
@@ -820,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;
 }
@@ -843,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);
@@ -852,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;
@@ -860,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: echoCallerText(group.matcher ?? "", { maxChars: MATCHER_ECHO_CHARS }) });
-            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,
@@ -944,27 +1288,20 @@ 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 });
         }
@@ -995,98 +1332,129 @@ export function createSettingsHooksRegistration(config, ctx, budgetMs) {
     const onceFired = new Set();
     const translators = {};
     if (pre) {
-        translators.PreToolUse = async (e) => {
+        translators.PreToolUse = async (e, signal) => {
             const toolName = e.tool;
-            const input = e.input;
-            let currentInput = input;
+            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: echoCallerText(group.matcher ?? "", { maxChars: MATCHER_ECHO_CHARS }) });
-                    continue;
-                }
-                if (!m)
-                    continue;
-                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", [{ ...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) {
@@ -1094,19 +1462,19 @@ export function createSettingsHooksRegistration(config, ctx, budgetMs) {
                     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;
         };
     }
     if (post) {
-        translators.PostToolUse = async (e) => {
+        translators.PostToolUse = async (e, signal) => {
             const toolName = e.tool;
             const input = e.input;
             const output = e.output;
@@ -1119,37 +1487,38 @@ export function createSettingsHooksRegistration(config, ctx, budgetMs) {
                 hook_event_name: "PostToolUse",
                 tool_name: toolName,
                 tool_input: input,
-                tool_response: { isError: output.isError, text: clip(responseText, MAX_TOOL_RESPONSE_CHARS) },
+                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" });
                     }
@@ -1160,7 +1529,7 @@ export function createSettingsHooksRegistration(config, ctx, budgetMs) {
         };
     }
     if (postFailure) {
-        translators.PostToolUseFailure = async (e) => {
+        translators.PostToolUseFailure = async (e, signal) => {
             const toolName = e.tool;
             const f = e.failure;
             const contexts = [];
@@ -1170,36 +1539,37 @@ export function createSettingsHooksRegistration(config, ctx, budgetMs) {
                 tool_name: toolName,
                 tool_input: e.input,
                 tool_use_id: e.tool_use_id,
-                error: clip(f.error, MAX_TOOL_RESPONSE_CHARS),
+                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);
@@ -1207,7 +1577,7 @@ export function createSettingsHooksRegistration(config, ctx, budgetMs) {
         };
     }
     if (postBatch) {
-        translators.PostToolBatch = async (e) => {
+        translators.PostToolBatch = async (e, signal) => {
             const contexts = [];
             const payload = {
                 ...basePayload(ctx, e.permissionMode),
@@ -1216,31 +1586,32 @@ export function createSettingsHooksRegistration(config, ctx, budgetMs) {
                     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" });
             }
@@ -1249,38 +1620,39 @@ export function createSettingsHooksRegistration(config, ctx, budgetMs) {
         };
     }
     if (promptSubmit) {
-        translators.UserPromptSubmit = async (e) => {
+        translators.UserPromptSubmit = async (e, signal) => {
             const contexts = [];
-            const payload = { ...basePayload(ctx, e.permissionMode), hook_event_name: "UserPromptSubmit", prompt: clip(e.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);
@@ -1288,7 +1660,7 @@ export function createSettingsHooksRegistration(config, ctx, budgetMs) {
         };
     }
     if (stopEntries) {
-        translators.Stop = 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"));
@@ -1303,7 +1675,7 @@ export function createSettingsHooksRegistration(config, ctx, budgetMs) {
                         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) {
@@ -1316,22 +1688,29 @@ export function createSettingsHooksRegistration(config, ctx, budgetMs) {
                 }
             }
             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)) {
@@ -1339,33 +1718,34 @@ export function createSettingsHooksRegistration(config, ctx, budgetMs) {
                     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)
@@ -1379,59 +1759,60 @@ export function createSettingsHooksRegistration(config, ctx, budgetMs) {
         };
     }
     if (stopFailureEntries) {
-        translators.StopFailure = 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);
         };
     }
     if (preCompactEntries) {
-        translators.PreCompact = 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;
         };
     }
     if (postCompactEntries) {
-        translators.PostCompact = 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),
+                compact_summary: clipDataText(cctx.summary, MAX_TOOL_RESPONSE_CHARS),
             };
-            await runObserveOnlyEvent("PostCompact", postCompactEntries, cctx.trigger, payload, ctx, onceFired);
+            await runObserveOnlyEvent("PostCompact", postCompactEntries, cctx.trigger, payload, ctx, onceFired, signal);
         };
     }
     const events = Object.keys(translators);