agent-control-plane-core 0.9.2 → 0.11.0

package/README.md

@@ -125,6 +125,9 @@ NATIVE_ASK_TIER = false;
 Read `NATIVE_ASK_TIER` instead of keeping a list of which agents to escalate an
 `ask` to a `deny` on: a guardrail that must not let an ask through escalates it
 where the flag is `false`, and leaves it alone where the host does the asking.
+`renderEscalated(adapter, verdict, event, { soleGate })` applies that rule: it
+re-renders as a `deny` any non-allow verdict that would render unenforced on a
+vetoable call, except an `ask` on a host whose flag is `true`.
 It describes the HOST, not the verdict — `ask` renders as `enforced: false`
 everywhere — and it names the pre-tool gate, since a tool that already ran has
 nothing left to suspend. Conformance probes your real `render` against it, so a
@@ -165,14 +168,31 @@ emit(claudeAdapter.render(verdict, event));
 `JSON.stringify(render(...))` to stdout exits 0, so the host never blocks.
 
 `agent-control-plane-core/runtime` publishes the rest of the plumbing the four
-hook entries share. `renderHookResponse` runs parse → judge → render, and returns
-the failure response THAT host expects when the payload does not parse. `emit`
+hook entries share. `runHookEntry(adapter, judge)` is a whole entry: each
+`bin/<host>-hook.mjs` is that one call. `renderHookResponse` runs parse → judge
+→ render, and returns the failure response THAT host expects when the payload
+does not parse. `emit`
 drains the whole body before it exits, so a large deny body is never truncated
 on a non-blocking pipe. The entries ship as `acp-claude-hook`, `acp-codex-hook`,
 `acp-amp-hook` and `acp-gemini-hook`. Codex's hook stdin carries no version, so
 set `ACP_CODEX_VERSION` to the Codex version your launcher pins (or call
 `createCodexAdapter({ version })`); without it, Codex calls parse advisory.
 
+Each entry fails the way its host expects when the hook itself breaks: claude,
+codex and gemini run the call, and amp asks. Set `ACP_FAIL_CLOSED=1` to block
+instead, on every host. The entry then exits 2 with the reason on stderr when
+the payload does not parse, or when the judge throws or answers no decision.
+Register a fail-closed entry on tool-call events only. On a Stop event, exit 2
+means "keep working".
+
+A host that kills a hook on its timeout runs the call. Set
+`ACP_HOOK_TIMEOUT_MS` below the host's hook timeout, and the entry gives its
+failure response at that deadline instead. A judge that blocks the event loop
+past the deadline still loses to the host's timeout. Nothing in the entry can
+answer for a process that never starts (no `node`, a module that fails to
+load). Claude Code covers that case with `"onFailure": "block"` on the hook
+entry. Codex has no such option, so it still runs the call.
+
 The core contract and every adapter (`claude`, `codex`, `amp`, `gemini`) are
 also on the default entry:
 

package/bin/amp-hook.mjs

@@ -4,18 +4,12 @@
  * delegate payload on stdin, applies the demo judge, and exits with Amp's
  * decision code (0 allow / 1 ask / 2 reject).
  *
- * FAILURE POSTURE — fail to ASK (exit 1), NOT allow. Amp's delegate reads exit 1
- * as "ask the human," which is the safe degradation when the guardrail itself is
- * broken: neither silently allowing (exit 0) nor hard-denying (exit 2) a call it
- * never actually judged. This is the asymmetry the per-host split exists for —
- * Amp has a safe "ask" failure code that Claude Code's transport does not.
+ * FAILURE POSTURE — fail to ASK (exit 1), its `HOST_FAILURE` row in
+ * `src/runtime.mjs`. `ACP_FAIL_CLOSED=1` blocks instead (exit 2).
  *
  * Usage: `node bin/amp-hook.mjs < payload.json`
  */
 import { ampAdapter } from "../src/adapters/amp.mjs";
-import { readStdin, renderHookResponse, emit } from "../src/runtime.mjs";
+import { runHookEntry } from "../src/runtime.mjs";
 
-/** @type {import("../src/control-plane.mjs").NativeResponse} */
-const FAIL_ASK = { transport: "external_hook", exit_code: 1, enforced: false };
-
-emit(renderHookResponse(ampAdapter, await readStdin(), FAIL_ASK));
+await runHookEntry(ampAdapter);

package/bin/claude-hook.mjs

@@ -3,18 +3,12 @@
  * Claude Code EXTERNAL_HOOK entry. Reads a native PreToolUse payload on stdin,
  * applies the demo judge, and emits Claude Code's native response.
  *
- * FAILURE POSTURE — fail OPEN. Claude Code treats a hook that crashes, times out,
- * or emits a non-conforming body as "no objection" and runs the tool anyway, so
- * on any internal failure this exits 0 with no body rather than pretending to a
- * decision it couldn't compute. A broken guardrail must not wedge the user; the
- * sandbox is the real backstop, not this hook.
+ * FAILURE POSTURE — fail OPEN (exit 0), its `HOST_FAILURE` row in
+ * `src/runtime.mjs`. `ACP_FAIL_CLOSED=1` blocks instead (exit 2).
  *
  * Usage: `node bin/claude-hook.mjs < payload.json`
  */
 import { claudeAdapter } from "../src/adapters/claude.mjs";
-import { readStdin, renderHookResponse, emit } from "../src/runtime.mjs";
+import { runHookEntry } from "../src/runtime.mjs";
 
-/** @type {import("../src/control-plane.mjs").NativeResponse} */
-const FAIL_OPEN = { transport: "external_hook", exit_code: 0, enforced: false };
-
-emit(renderHookResponse(claudeAdapter, await readStdin(), FAIL_OPEN));
+await runHookEntry(claudeAdapter);

package/bin/codex-hook.mjs

@@ -10,16 +10,14 @@
  * deny renders advisory (exit 0). Below v0.135 the render is advisory too,
  * because Codex has no hook veto there.
  *
- * FAILURE POSTURE — fail OPEN (exit 0), like Claude Code: Codex treats a
- * non-conforming hook as non-blocking. The sandbox is the backstop.
+ * FAILURE POSTURE — fail OPEN (exit 0), its `HOST_FAILURE` row in
+ * `src/runtime.mjs`. `ACP_FAIL_CLOSED=1` blocks instead (exit 2).
  *
  * Usage: `ACP_CODEX_VERSION=0.151.0 node bin/codex-hook.mjs < payload.json`
  */
 import { createCodexAdapter } from "../src/adapters/codex.mjs";
-import { readStdin, renderHookResponse, emit } from "../src/runtime.mjs";
+import { runHookEntry } from "../src/runtime.mjs";
 
-/** @type {import("../src/control-plane.mjs").NativeResponse} */
-const FAIL_OPEN = { transport: "external_hook", exit_code: 0, enforced: false };
-
-const adapter = createCodexAdapter({ version: process.env.ACP_CODEX_VERSION });
-emit(renderHookResponse(adapter, await readStdin(), FAIL_OPEN));
+await runHookEntry(
+  createCodexAdapter({ version: process.env.ACP_CODEX_VERSION }),
+);

package/bin/gemini-hook.mjs

@@ -3,17 +3,12 @@
  * Gemini CLI EXTERNAL_HOOK entry. Reads a native BeforeTool payload on stdin,
  * applies the demo judge, and emits Gemini's native response.
  *
- * FAILURE POSTURE — fail OPEN (exit 0). Gemini CLI treats a non-2 / crashed hook
- * exit as a non-fatal warning and continues, so on any internal failure this
- * exits 0 rather than emitting a spurious System Block (only a clean deny exits
- * 2). A broken guardrail must not wedge the user; the sandbox is the backstop.
+ * FAILURE POSTURE — fail OPEN (exit 0), its `HOST_FAILURE` row in
+ * `src/runtime.mjs`. `ACP_FAIL_CLOSED=1` blocks instead (exit 2).
  *
  * Usage: `node bin/gemini-hook.mjs < payload.json`
  */
 import { geminiAdapter } from "../src/adapters/gemini.mjs";
-import { readStdin, renderHookResponse, emit } from "../src/runtime.mjs";
+import { runHookEntry } from "../src/runtime.mjs";
 
-/** @type {import("../src/control-plane.mjs").NativeResponse} */
-const FAIL_OPEN = { transport: "external_hook", exit_code: 0, enforced: false };
-
-emit(renderHookResponse(geminiAdapter, await readStdin(), FAIL_OPEN));
+await runHookEntry(geminiAdapter);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-control-plane-core",
-  "version": "0.9.2",
+  "version": "0.11.0",
   "description": "Vendor-neutral control-plane contract for coding agents: a normalized ToolCallEvent/Verdict schema with per-agent adapters (Claude Code, Codex, Amp, Gemini CLI) and a conformance suite.",
   "type": "module",
   "repository": {

package/src/adapters/amp.mjs

@@ -159,7 +159,10 @@ export function parse(native) {
 
 /**
  * Amp honours a distinct ask tier: exit 1 is its "ask the user", a code Amp
- * treats as neither the allow (0) nor the reject (2). {@link render} emits it
+ * treats as neither the allow (0) nor the reject (2). Source: Amp's own notes,
+ * "`0` allows the tool call, `1` makes Amp ask, and `2` rejects the tool call"
+ * (https://ampcode.com/notes/permissions). No live probe has measured it, and
+ * no source says what exit 1 does in a headless run. {@link render} emits it
  * for every `ask`, so a consumer must NOT escalate an `ask` to a `deny` here.
  * The table below leans on the same tier for the non-vetoable deny, which is
  * only honest because the tier is real.

package/src/control-plane.mjs

@@ -958,3 +958,34 @@ export function gatedResponse(
     [row.reason_stream]: blockReason(reason),
   });
 }
+
+/**
+ * Render `verdict` on `adapter`'s host, escalating to a `deny` when the host
+ * would otherwise let the call run without the gate it asked for. A non-allow
+ * verdict that renders unenforced on a vetoable call is re-rendered as a deny,
+ * unless it is an `ask` and the host honours its own ask tier
+ * ({@link Adapter} `NATIVE_ASK_TIER`). Nothing changes for an allow, for a call
+ * this guardrail cannot veto (a deny there blocks nothing either), or for a
+ * render the host already enforces. The deny keeps the verdict's other fields.
+ * @param {Adapter} adapter
+ * @param {Verdict} verdict
+ * @param {ToolCallEvent} event
+ * @param {{ soleGate?: boolean }} [options] passed through to `render`
+ * @returns {NativeResponse}
+ */
+export function renderEscalated(adapter, verdict, event, options = {}) {
+  const { decision } = normalizeVerdict(verdict);
+  const response = adapter.render(verdict, event, options);
+  if (
+    response.enforced ||
+    decision === Decision.ALLOW ||
+    !event.this_call_vetoable ||
+    (decision === Decision.ASK && adapter.NATIVE_ASK_TIER)
+  )
+    return response;
+  return adapter.render(
+    { ...verdict, decision: Decision.DENY },
+    event,
+    options,
+  );
+}

package/src/runtime.mjs

@@ -1,13 +1,11 @@
 /**
  * The EXTERNAL_HOOK runtime, published at `agent-control-plane-core/runtime` —
  * NOT a runtime host multiplexer. Each host has its OWN entry
- * (`bin/<host>-hook.mjs`) that hardcodes its adapter and declares its OWN
- * failure posture; this module only holds the transport mechanics they
- * genuinely share (stdin read, the demo judge, the parse→judge→render pipe with
- * a host-supplied fail-safe, and stdout+exit emission). The thing item ②
- * deleted was the `--agent` switch that let one binary impersonate every host
- * and so had to pick a single shared failure behavior; sharing pure plumbing
- * across distinct entries is not that.
+ * (`bin/<host>-hook.mjs`) that hardcodes its adapter; {@link runHookEntry}
+ * runs it with that host's OWN failure posture from {@link HOST_FAILURE}. The
+ * thing item ② deleted was the `--agent` switch that let one binary
+ * impersonate every host and so had to pick a single shared failure behavior;
+ * a per-host table keyed by the adapter's own AGENT is not that.
  *
  * It is exported because every consumer writing its own hook entry had to
  * re-implement the same two things, and both fail silently when they are wrong:
@@ -15,7 +13,7 @@
  * `process.exit` (see {@link writeAllSync}).
  */
 import { writeSync } from "node:fs";
-import { Decision, sanitizeVerdict } from "./control-plane.mjs";
+import { Decision, gatedResponse, sanitizeVerdict } from "./control-plane.mjs";
 
 /**
  * Read all of stdin to a string.
@@ -57,10 +55,10 @@ export function demoJudge(event) {
 /**
  * Run one host's parse→judge→render pipe over a raw stdin payload. If the payload
  * can't be parsed or the render throws, return `onFailure` — the host's OWN
- * fail-safe response — so a crashed hook degrades the way THAT host expects
- * (claude/codex fail OPEN = exit 0; amp fails to ASK = exit 1) instead of a
- * single shared default. This is the deliberate, necessary recovery the whole
- * per-host split exists for, not a blanket swallow.
+ * fail-safe response from {@link failurePosture} — so a crashed hook degrades
+ * the way THAT host expects instead of a single shared default. This is the
+ * deliberate, necessary recovery the whole per-host split exists for, not a
+ * blanket swallow.
  *
  * A judge that THROWS is not a malformed payload: the call parsed, and the judge
  * failed to answer. That takes the same path as a judge that answers garbage —
@@ -108,6 +106,10 @@ export function renderHookResponse(
       answer = { reason: `hook judge threw: ${describe(err).split("\n")[0]}` };
       report("hook judge error", err);
     }
+    // A host-supplied `onFailure` that BLOCKS (see {@link failurePosture}) wins
+    // over the clamp's ask: Codex and Gemini cannot enforce an ask, so the
+    // clamp would run a call no judge approved.
+    if (onFailure.enforced && !isDecision(answer)) return onFailure;
     // A judge's answer is clamped, not trusted. `normalizeVerdict` (inside
     // every adapter's render) THROWS on a decision outside allow/deny/ask, and
     // that throw would land in the catch below — the host's fail-safe, exit 0
@@ -123,6 +125,151 @@ export function renderHookResponse(
   }
 }
 
+/**
+ * Whether `answer` carries one of the three decisions a judge may return.
+ * @param {unknown} answer
+ * @returns {boolean}
+ */
+function isDecision(answer) {
+  const decision =
+    answer !== null && typeof answer === "object"
+      ? /** @type {{ decision?: unknown }} */ (answer).decision
+      : undefined;
+  return Object.values(Decision).includes(/** @type {any} */ (decision));
+}
+
+/**
+ * The response that BLOCKS the call on `agent`'s host: its
+ * {@link BLOCK_TRANSPORT} row's exit code, with `reason` on the row's reason
+ * stream. Every row blocks, so this is the one fail-closed response for all hosts.
+ * @param {string} agent
+ * @param {string} reason
+ * @returns {import("./control-plane.mjs").NativeResponse}
+ */
+export function failClosedResponse(agent, reason) {
+  return gatedResponse(agent, {
+    transport: "external_hook",
+    enforced: true,
+    unblocked_exit_code: 0,
+    reason,
+  });
+}
+
+/** @type {import("./control-plane.mjs").NativeResponse} */
+const RUN = Object.freeze({
+  transport: "external_hook",
+  exit_code: 0,
+  enforced: false,
+});
+
+/**
+ * Each host's DEFAULT response when its hook breaks, which is how that host
+ * degrades a hook it cannot read:
+ * - claude, codex, gemini: exit 0, so the call runs. Each host treats a crashed
+ *   or non-conforming hook as no objection, and a spurious block would wedge the
+ *   user. The sandbox is the backstop.
+ * - amp: exit 1, which Amp's delegate reads as "ask the human". That neither
+ *   runs nor rejects a call no judge saw.
+ * @type {Readonly<Record<string, import("./control-plane.mjs").NativeResponse>>}
+ */
+export const HOST_FAILURE = Object.freeze({
+  claude: RUN,
+  codex: RUN,
+  gemini: RUN,
+  amp: Object.freeze({
+    transport: "external_hook",
+    exit_code: 1,
+    enforced: false,
+  }),
+});
+
+/**
+ * The failure response for `agent`: its {@link HOST_FAILURE} row, or
+ * {@link failClosedResponse} when `ACP_FAIL_CLOSED=1`. A blocking failure
+ * response also blocks a call whose judge threw or answered no decision.
+ * Register a fail-closed entry on tool-call events only: on a Stop event,
+ * exit 2 means "keep working". {@link runHookEntry} also answers a hang
+ * before the host's timeout. It cannot answer for a process that never starts
+ * or that the host kills for another reason; only the host can, as Claude
+ * Code's `"onFailure": "block"` does.
+ * @param {string} agent
+ * @param {NodeJS.ProcessEnv} [env]
+ * @returns {import("./control-plane.mjs").NativeResponse}
+ */
+export function failurePosture(agent, env = process.env) {
+  if (!Object.hasOwn(HOST_FAILURE, agent))
+    throw new Error(
+      `runtime: no HOST_FAILURE row for agent ${JSON.stringify(agent)}`,
+    );
+  const flag = env.ACP_FAIL_CLOSED;
+  if (flag === undefined || flag === "" || flag === "0")
+    return HOST_FAILURE[agent];
+  if (flag !== "1")
+    throw new Error(
+      `ACP_FAIL_CLOSED must be "1" or "0", got ${JSON.stringify(flag)}`,
+    );
+  return failClosedResponse(
+    agent,
+    "hook failed; ACP_FAIL_CLOSED blocks the call",
+  );
+}
+
+/**
+ * The whole hook entry for `adapter`'s host: read stdin, run
+ * {@link renderHookResponse} with that host's {@link failurePosture}, and
+ * {@link emit} the result. Every `bin/<host>-hook.mjs` is this one call. The
+ * failure response also answers a stdin read error and, when
+ * {@link hookDeadlineMs} is set, a hook still running at that deadline.
+ * @param {import("./control-plane.mjs").Adapter} adapter
+ * @param {(event: import("./control-plane.mjs").ToolCallEvent) => import("./control-plane.mjs").Verdict} [judge]
+ * @returns {Promise<never>}
+ */
+export async function runHookEntry(adapter, judge = demoJudge) {
+  const onFailure = failurePosture(adapter.AGENT);
+  const deadline = hookDeadlineMs();
+  /** @param {string} what @param {unknown} err @returns {never} */
+  const fail = (what, err) => {
+    report(what, err);
+    return emit(onFailure);
+  };
+  // A host that kills a hung hook runs the call, so the hook answers first with
+  // its own failure response. A judge that blocks the event loop outlasts this.
+  if (deadline !== undefined)
+    setTimeout(
+      () =>
+        fail(
+          "hook deadline",
+          new Error(`no response within ACP_HOOK_TIMEOUT_MS=${deadline}`),
+        ),
+      deadline,
+    );
+  /** @type {string} */
+  let raw;
+  try {
+    raw = await readStdin();
+  } catch (err) {
+    return fail("hook stdin error", err);
+  }
+  return emit(renderHookResponse(adapter, raw, onFailure, judge));
+}
+
+/**
+ * `ACP_HOOK_TIMEOUT_MS` as a positive integer, or `undefined` when unset. Set it
+ * below the host's own hook timeout, so the hook's failure response lands
+ * before the host kills it.
+ * @param {NodeJS.ProcessEnv} [env]
+ * @returns {number|undefined}
+ */
+export function hookDeadlineMs(env = process.env) {
+  const value = env.ACP_HOOK_TIMEOUT_MS;
+  if (value === undefined || value === "") return undefined;
+  if (!/^[1-9]\d*$/u.test(value))
+    throw new Error(
+      `ACP_HOOK_TIMEOUT_MS must be a positive integer of milliseconds, got ${JSON.stringify(value)}`,
+    );
+  return Number(value);
+}
+
 /**
  * A thrown value as readable text: an Error's stack (or message when it has no
  * stack), or the value itself for a bare throw.

package/types/adapters/amp.d.mts

@@ -98,7 +98,10 @@ export const NATIVE_EVENT_FOR: Record<string, string | undefined>;
 export const UNRENDERED_FIELDS: Record<string, ReadonlySet<string> | undefined>;
 /**
  * Amp honours a distinct ask tier: exit 1 is its "ask the user", a code Amp
- * treats as neither the allow (0) nor the reject (2). {@link render} emits it
+ * treats as neither the allow (0) nor the reject (2). Source: Amp's own notes,
+ * "`0` allows the tool call, `1` makes Amp ask, and `2` rejects the tool call"
+ * (https://ampcode.com/notes/permissions). No live probe has measured it, and
+ * no source says what exit 1 does in a headless run. {@link render} emits it
  * for every `ask`, so a consumer must NOT escalate an `ask` to a `deny` here.
  * The table below leans on the same tier for the non-vetoable deny, which is
  * only honest because the tier is real.

package/types/control-plane.d.mts

@@ -288,6 +288,23 @@ export function gatedResponse(agent: string, { transport, enforced, unblocked_ex
     stdout?: unknown;
     reason?: string;
 }): NativeResponse;
+/**
+ * Render `verdict` on `adapter`'s host, escalating to a `deny` when the host
+ * would otherwise let the call run without the gate it asked for. A non-allow
+ * verdict that renders unenforced on a vetoable call is re-rendered as a deny,
+ * unless it is an `ask` and the host honours its own ask tier
+ * ({@link Adapter} `NATIVE_ASK_TIER`). Nothing changes for an allow, for a call
+ * this guardrail cannot veto (a deny there blocks nothing either), or for a
+ * render the host already enforces. The deny keeps the verdict's other fields.
+ * @param {Adapter} adapter
+ * @param {Verdict} verdict
+ * @param {ToolCallEvent} event
+ * @param {{ soleGate?: boolean }} [options] passed through to `render`
+ * @returns {NativeResponse}
+ */
+export function renderEscalated(adapter: Adapter, verdict: Verdict, event: ToolCallEvent, options?: {
+    soleGate?: boolean;
+}): NativeResponse;
 /**
  * The vendor-neutral control-plane contract.
  *

package/types/runtime.d.mts

@@ -14,10 +14,10 @@ export function demoJudge(event: import("./control-plane.mjs").ToolCallEvent): i
 /**
  * Run one host's parse→judge→render pipe over a raw stdin payload. If the payload
  * can't be parsed or the render throws, return `onFailure` — the host's OWN
- * fail-safe response — so a crashed hook degrades the way THAT host expects
- * (claude/codex fail OPEN = exit 0; amp fails to ASK = exit 1) instead of a
- * single shared default. This is the deliberate, necessary recovery the whole
- * per-host split exists for, not a blanket swallow.
+ * fail-safe response from {@link failurePosture} — so a crashed hook degrades
+ * the way THAT host expects instead of a single shared default. This is the
+ * deliberate, necessary recovery the whole per-host split exists for, not a
+ * blanket swallow.
  *
  * A judge that THROWS is not a malformed payload: the call parsed, and the judge
  * failed to answer. That takes the same path as a judge that answers garbage —
@@ -39,6 +39,48 @@ export function demoJudge(event: import("./control-plane.mjs").ToolCallEvent): i
  * @returns {import("./control-plane.mjs").NativeResponse}
  */
 export function renderHookResponse(adapter: import("./control-plane.mjs").Adapter, rawInput: string, onFailure: import("./control-plane.mjs").NativeResponse, judge?: (event: import("./control-plane.mjs").ToolCallEvent) => import("./control-plane.mjs").Verdict): import("./control-plane.mjs").NativeResponse;
+/**
+ * The response that BLOCKS the call on `agent`'s host: its
+ * {@link BLOCK_TRANSPORT} row's exit code, with `reason` on the row's reason
+ * stream. Every row blocks, so this is the one fail-closed response for all hosts.
+ * @param {string} agent
+ * @param {string} reason
+ * @returns {import("./control-plane.mjs").NativeResponse}
+ */
+export function failClosedResponse(agent: string, reason: string): import("./control-plane.mjs").NativeResponse;
+/**
+ * The failure response for `agent`: its {@link HOST_FAILURE} row, or
+ * {@link failClosedResponse} when `ACP_FAIL_CLOSED=1`. A blocking failure
+ * response also blocks a call whose judge threw or answered no decision.
+ * Register a fail-closed entry on tool-call events only: on a Stop event,
+ * exit 2 means "keep working". {@link runHookEntry} also answers a hang
+ * before the host's timeout. It cannot answer for a process that never starts
+ * or that the host kills for another reason; only the host can, as Claude
+ * Code's `"onFailure": "block"` does.
+ * @param {string} agent
+ * @param {NodeJS.ProcessEnv} [env]
+ * @returns {import("./control-plane.mjs").NativeResponse}
+ */
+export function failurePosture(agent: string, env?: NodeJS.ProcessEnv): import("./control-plane.mjs").NativeResponse;
+/**
+ * The whole hook entry for `adapter`'s host: read stdin, run
+ * {@link renderHookResponse} with that host's {@link failurePosture}, and
+ * {@link emit} the result. Every `bin/<host>-hook.mjs` is this one call. The
+ * failure response also answers a stdin read error and, when
+ * {@link hookDeadlineMs} is set, a hook still running at that deadline.
+ * @param {import("./control-plane.mjs").Adapter} adapter
+ * @param {(event: import("./control-plane.mjs").ToolCallEvent) => import("./control-plane.mjs").Verdict} [judge]
+ * @returns {Promise<never>}
+ */
+export function runHookEntry(adapter: import("./control-plane.mjs").Adapter, judge?: (event: import("./control-plane.mjs").ToolCallEvent) => import("./control-plane.mjs").Verdict): Promise<never>;
+/**
+ * `ACP_HOOK_TIMEOUT_MS` as a positive integer, or `undefined` when unset. Set it
+ * below the host's own hook timeout, so the hook's failure response lands
+ * before the host kills it.
+ * @param {NodeJS.ProcessEnv} [env]
+ * @returns {number|undefined}
+ */
+export function hookDeadlineMs(env?: NodeJS.ProcessEnv): number | undefined;
 /**
  * Whether a failed `writeSync` is the one recoverable case: EAGAIN, meaning the
  * non-blocking pipe is momentarily full because the host has not drained it
@@ -80,3 +122,14 @@ export function writeAllSync(fd: number, text: string): void;
  * @returns {never}
  */
 export function emit(response: import("./control-plane.mjs").NativeResponse): never;
+/**
+ * Each host's DEFAULT response when its hook breaks, which is how that host
+ * degrades a hook it cannot read:
+ * - claude, codex, gemini: exit 0, so the call runs. Each host treats a crashed
+ *   or non-conforming hook as no objection, and a spurious block would wedge the
+ *   user. The sandbox is the backstop.
+ * - amp: exit 1, which Amp's delegate reads as "ask the human". That neither
+ *   runs nor rejects a call no judge saw.
+ * @type {Readonly<Record<string, import("./control-plane.mjs").NativeResponse>>}
+ */
+export const HOST_FAILURE: Readonly<Record<string, import("./control-plane.mjs").NativeResponse>>;