@sema-agent/server 7.4.0 → 7.6.0

package/dist/governance-ask-marks.js

@@ -0,0 +1,122 @@
+/**
+ * [2942]/[2943] `governanceForced` 的**判定缝** —— operator 治理层产的 ask 在 server 进程内的标记通道。
+ *
+ * 🔴 为什么需要一条 out-of-band 通道(侦察结论,亲验装树 core 5.16.x dist):
+ * `PermissionResult.decisionReason`(`"rule" | "mode" | "hook" | "safety" | "classifier"`)**到不了帧铸点**。
+ * core 在 `dist/core/runner/prepare-task.js` 的 ask 铸造点(`resolveAsk({...})`,三处继承臂 + 主臂)只把
+ * `toolName / toolCallId / args / preview / message / askSourceIdentity() / riskAxesOf() / requiresRealApproval`
+ * 装进 `AskRequest`;`decisionReason` 连同整个 `PermissionResult` 一起留在 core 内部。`AskRequest` 的类型面
+ * (`dist/core/tool-policy.d.ts:78`)也确认没有这个键。所以「映射 decisionReason ⇒ governanceForced」这条
+ * 缝在**当前 core 上不存在**——它不是没接线,是没有这个字段可读。
+ *
+ * 另一侧同样不可用:`riskAxes.irreversible` 在 shellGate 上场时对**每一次** shell 调用都为真(core
+ * `prepare-task.js:1620-1631` 无条件 `irreversibilityTier.set("Bash"/"Monitor", …)`),与「这只 ask 是谁
+ * 提的」无关;`requiresRealApproval` 的生产者是 core 自己的两条安全策略(unverifiable-delete /
+ * transcript-integrity),与治理层无关。两者都不是判据。
+ *
+ * ⇒ 采用的方案 = **server 标记自家产物**:治理层策略(`runtime-governance.ts` 的
+ * `applyRuntimeGovernance`)在合成时被包一层观察器,自己产 `ask` 时把该次调用的 `toolCallId` 记进本表;
+ * 帧铸点(`tool-approval.ts` 的 `askBroadcast`)按 `toolCallId` 回查。
+ * **禁把信号藏进 message 文本**——那是 in-band hack,消费端只能靠正则猜。
+ *
+ * ## 三条硬语义
+ *
+ * 1. **只做正向断言**。命中 = 有直接证据(治理策略本人产的 ask,或治理层把 shellGate 抬到 `"always"` 后
+ *    的 shell 调用——该档下每一次 shell 调用都被治理层门住,推断是紧的)。**未命中 ≠ 「不是治理」**,
+ *    只是「没有证据」⇒ wire 上键**缺席**,绝不编一个 `false`。宁可漏标,不可错标:一个错标会把运维支去
+ *    翻一份根本没门住这只 ask 的治理配置。
+ * 2. **peek,不 consume**。同一 `toolCallId` 可能被广播两次(重试 / failover / 闭包再入,见
+ *    `tool-approval.ts` 里 `pendingByAskId` 的顶注),消费式读会让第二帧莫名丢键。
+ * 3. **有界**。写入点是每一次工具调用,读取点只在 ask 上——未被读到的标记(调用被放行 / 被别的策略 deny)
+ *    必须能自己老化掉。按插入序淘汰最旧的(`Set` 的迭代序 = 插入序)。
+ *
+ * ## 作用域:按**审批 broker key** 分格,不是进程级一锅烩
+ *
+ * 🔴 codex 交叉复审 round3 [medium](验真):`toolCallId` **不是**全局唯一的 —— 它多数情况下是**提供方**
+ * 逐字给的 id(core 的 brain 层不另铸),本仓自己的代码就是这么假设的:core 把 tool-result 引用命名成
+ * `tr_<sessionId>_<toolCallId>`(见 `plugins/tool-result-store-sql.ts` 的 `deleteBySession` 顶注),
+ * `deriveAskId` 也把 `sourceTaskId`/`runId`/`legKey` 一并入哈希。一张不分格的表会**跨任务/跨租户串味**:
+ * 低熵 id(本地/自建模型服务常见的 `call_1` 之类)下,A 任务的治理标会被 B 任务的普通 ask 读走(假出处),
+ * 或被 B 的一次治理放行反手清掉(丢真出处)。
+ *
+ * 分格用的 **scope = 审批协调器的 broker key**(`["session", owner, sessionId]` / `["adhoc", owner, taskId]`)。
+ * 选它的理由是**两侧都够得到、且是同一个值**:
+ *  · 写侧(治理策略的观察器跑在 core 的 `policy.check` 里,入参只有 `ToolCallRequest`)⇒ 经
+ *    AsyncLocalStorage 拿 —— 作用域由 `runWithContext` 与审批 ctx **同拍**进出。
+ *  · 读侧(`askBroadcast`)⇒ 由 `origin`/`primary` **显式算出**同一把 key。
+ *
+ * 🔴 读侧**显式算**而不是也读 ALS(codex 交叉复审 round5 [medium],红先复现后改的形):委派/长命 bg 子代
+ * 的 ask 可能在**另一条腿**的上下文里发出(宿主腿退场、壳重连出新腿,子代的卡落到新腿的流上)。读侧若取
+ * 环境里的那张表,拿到的是**新腿**的空表,信号静默丢失 —— 那条路径已由
+ * `test/governance-forced-signal.test.ts` 的「长命 bg 子代形」用例钉住(改形前它是红的)。scope 由**出处**
+ * 决定、与卡投递到哪条连接无关,与本仓 `AskOriginIdentity` 顶注「投递面与出处面是两件事」同源。
+ *
+ * 残余(成文):同一 (owner, sessionId) 下的**并发多 run** 共用一格 —— 那正是 broker 自己的分组粒度
+ * (卡本来就跨该会话投递),同租户同会话内的 id 碰撞才会互串,比进程级一锅烩窄得多。要再窄需要一个
+ * 写侧也够得到的 run 级身份,core 的 `ToolCallRequest` 今天给不出。
+ */
+import { AsyncLocalStorage } from "node:async_hooks";
+/** 默认表容量(全进程合计,复合键计数)。一次 turn 的工具调用数远小于此;满表淘汰的是最旧的标记
+ *  (那些早已不可能再被读到)。 */
+const DEFAULT_MAX_MARKS = 1024;
+/** 复合键。JSON 元组编码(同 `streamKey`/`sessionAllowKey` 先例):任何一段里含分隔符都不可能与下一段
+ *  的边界产生歧义 —— 一个精心构造的 sessionId 因此无法伪造出另一格。 */
+const compositeKey = (scope, toolCallId) => JSON.stringify([scope, toolCallId]);
+/** 一张独立的标记表(不进程共享)。生产路径用的是下面 `governanceAskMarksFor` 给出的**分格视图**;
+ *  本工厂给测试(与将来的多实例形)一个不依赖任何环境的干净表。 */
+export function createGovernanceAskMarks(opts) {
+    return createScopedView(new Set(), "", Math.max(1, Math.floor(opts?.max ?? DEFAULT_MAX_MARKS)));
+}
+function createScopedView(marks, scope, max) {
+    return {
+        setMarked(toolCallId, marked) {
+            if (typeof toolCallId !== "string" || toolCallId === "")
+                return; // 无身份 ⇒ 无从回查,不占格
+            const key = compositeKey(scope, toolCallId);
+            // 重标记要**刷新新鲜度**:先删后加把它挪到插入序尾部,免得一只长命的 ask 被自己后来的调用挤掉。
+            marks.delete(key);
+            if (!marked)
+                return; // 覆写成「不是治理门」= 清格(setMarked 顶注:复查路径的陈旧标)
+            marks.add(key);
+            while (marks.size > max) {
+                const oldest = marks.values().next();
+                if (oldest.done)
+                    break;
+                marks.delete(oldest.value);
+            }
+        },
+        isMarked(toolCallId) {
+            return typeof toolCallId === "string" && toolCallId !== "" && marks.has(compositeKey(scope, toolCallId));
+        },
+        clear() {
+            for (const k of [...marks])
+                if (k.startsWith(`[${JSON.stringify(scope)},`))
+                    marks.delete(k);
+        },
+        size() {
+            let n = 0;
+            for (const k of marks)
+                if (k.startsWith(`[${JSON.stringify(scope)},`))
+                    n += 1;
+            return n;
+        },
+    };
+}
+/** 进程级底表(分格由复合键承担,见顶注「作用域」段)。 */
+const processMarks = new Set();
+/** 写侧的 scope 载体 —— 由 `ToolApprovalCoordinator.runWithContext` 与审批 ctx 同拍进出。 */
+const scopeAls = new AsyncLocalStorage();
+/** 进入一条 run 腿的标记作用域(唯一调用点 = `ToolApprovalCoordinator.runWithContext`)。 */
+export function runWithGovernanceAskScope(scope, fn) {
+    return scopeAls.run(scope, fn);
+}
+/** **写侧**入口:当前异步作用域那一格的视图;作用域外 = `undefined`(写 no-op,见顶注)。 */
+export function currentGovernanceAskMarks() {
+    const scope = scopeAls.getStore();
+    return scope === undefined ? undefined : createScopedView(processMarks, scope, DEFAULT_MAX_MARKS);
+}
+/** **读侧**入口:按**显式** scope 取视图(读侧不读 ALS —— 理由见顶注 round5 那段)。 */
+export function governanceAskMarksFor(scope) {
+    return createScopedView(processMarks, scope, DEFAULT_MAX_MARKS);
+}
+//# sourceMappingURL=governance-ask-marks.js.map

package/dist/hooks/hook-runner.d.ts

@@ -14,6 +14,21 @@ export declare const MAX_HOOK_MATCHER_GROUPS = 16;
 export declare const MAX_HOOK_HTTP_HEADERS = 32;
 /** hook 进程 stdout/stderr 各自的采集上限(字节)——防输出洪泛打爆内存/日志。 */
 export declare const MAX_HOOK_OUTPUT_BYTES: number;
+/**
+ * 一次事件里所有 hook 上下文片段**聚合后**喂给模型的总量上限(字符)。
+ *
+ * 为什么单条帽不够:一次事件最多 {@link MAX_HOOK_ENTRIES_PER_EVENT} 条(parseHooksConfig 的广度闸),
+ * 每条最多推两段(`decision:"block"` 的 reason + `hookSpecificOutput.additionalContext`),
+ * {@link composeHooks} 再把部署槽与 task 槽的**成品**拼一次 —— 单条 4096 相乘后一次注入可达 ~256KB,
+ * 而这些字符是**逐次工具调用**进模型可见文本的(core `hooks.js` 的 preToolContext / `prepare-task.js`
+ * 的 tool_result 追加 / `runtask.js` 的 Stop follow-up),不是日志。
+ *
+ * 帽值取 10_000 的依据:模型可见文本在本栈的既有预算量纲就是 10k —— core `truncateError`
+ * (`src/core/tool-errors.ts`)的 10k 中截,逐字锚 CC 序列化器 `A7e` 的 `1e4`;#181 战役里 core 还要给
+ * `beforeToolCall` block reason 补一道同值兜底闸。取同一量级 = 「一次 hook 注入 ≤ 一份错误文本预算」,
+ * 且 4096 的单条帽保证**前两条**钩子的话仍整段进得去(截断是配置广度的代价,不是常态)。
+ */
+export declare const MAX_HOOK_CONTEXT_TOTAL_CHARS = 10000;
 export interface ParseHooksConfigResult {
     config?: HooksConfig;
     /** 人可读的第一条校验错误(HTTP 层用它 400 fail-loud;resume 防御路径用它 warn)。 */
@@ -96,6 +111,19 @@ export type HookLlmCall = (opts: {
 /** 失败判别码(B8:判别一律走码,禁按 error 文案分支——v3.1 批2,统检第二波 high)。error 仍是给人看的
  *  自由文本;code 是给控制流的。缺席=未分类失败(不重试、不特判)。 */
 export type HookLlmFailureCode = "no_content" | "hard_timeout";
+/**
+ * hook 上下文片段 → 喂给模型的单串。**所有** `additionalContext` 聚合点的唯一属主(此前是同一个
+ * `contexts.join("\n")` 表达式抄在二十余处,总量帽无处可挂 —— 那正是漂移成因)。
+ *
+ * 三条语义,都是承重的:
+ *  1. **顺序保留、只截尾**:先来的钩子先说话;一旦装不下就停,后面的条目一律不再挤进来(哪怕更短)。
+ *     按长度重排会让"第 3 条钩子的话"随别人的长度忽隐忽现,排障时无从复现。
+ *  2. **截断可见**:尾巴挂一行标记说明省了几条、丢了多少字符。静默丢弃会让 hook 作者以为自己的
+ *     context 生效了,而模型那头根本没见过 —— 这类"以为配好了"的缺席比长文本本身更贵。
+ *  3. **标记不计预算**:与 core `truncateError` / CC `A7e` 同姿势(marker 不占那 10k),否则帽值的
+ *     含义会随标记文案长度漂。
+ */
+export declare function buildHookContext(parts: readonly string[]): string | undefined;
 /**
  * 阶段三a:`http` 条目——契约语义 = POST hook 输入 JSON 到 `url`;headers 里的 `$NAME` 仅当 NAME 列在
  * `allowedEnvVars` 才从 worker 进程 env 插值(配置本身绝不携带密钥值,契约同边界)。

package/dist/hooks/hook-runner.js

@@ -65,6 +65,24 @@ export const MAX_HOOK_HTTP_HEADERS = 32;
 export const MAX_HOOK_OUTPUT_BYTES = 1024 * 1024;
 /** 喂给模型的 deny 原因/additionalContext 的单条长度上限(字符)。 */
 const MAX_HOOK_FEEDBACK_CHARS = 4_096;
+/**
+ * 一次事件里所有 hook 上下文片段**聚合后**喂给模型的总量上限(字符)。
+ *
+ * 为什么单条帽不够:一次事件最多 {@link MAX_HOOK_ENTRIES_PER_EVENT} 条(parseHooksConfig 的广度闸),
+ * 每条最多推两段(`decision:"block"` 的 reason + `hookSpecificOutput.additionalContext`),
+ * {@link composeHooks} 再把部署槽与 task 槽的**成品**拼一次 —— 单条 4096 相乘后一次注入可达 ~256KB,
+ * 而这些字符是**逐次工具调用**进模型可见文本的(core `hooks.js` 的 preToolContext / `prepare-task.js`
+ * 的 tool_result 追加 / `runtask.js` 的 Stop follow-up),不是日志。
+ *
+ * 帽值取 10_000 的依据:模型可见文本在本栈的既有预算量纲就是 10k —— core `truncateError`
+ * (`src/core/tool-errors.ts`)的 10k 中截,逐字锚 CC 序列化器 `A7e` 的 `1e4`;#181 战役里 core 还要给
+ * `beforeToolCall` block reason 补一道同值兜底闸。取同一量级 = 「一次 hook 注入 ≤ 一份错误文本预算」,
+ * 且 4096 的单条帽保证**前两条**钩子的话仍整段进得去(截断是配置广度的代价,不是常态)。
+ */
+export const MAX_HOOK_CONTEXT_TOTAL_CHARS = 10_000;
+/** 帽满时仍值得保留的最短残段(字符)。比这更短的尾巴不是信息:模型会把半句话读成完整指令,
+ *  宁可整条落进"省略"计数。 */
+const MIN_HOOK_CONTEXT_PARTIAL_CHARS = 256;
 /** PostToolUse payload 里 tool_response 文本投影的上限(字符)——工具结果可能是 MB 级。 */
 const MAX_TOOL_RESPONSE_CHARS = 32_768;
 /** stdin payload 里 tool_input JSON 投影的上限(字符;巨大 tool_input 经 JSON.stringify 造成
@@ -233,6 +251,104 @@ const DEFAULT_AGENT_HOOK_TIMEOUT_SECONDS = 120;
 function clip(s, n) {
     return s.length > n ? `${s.slice(0, n)}…(${s.length})` : s;
 }
+/**
+ * hook 上下文片段 → 喂给模型的单串。**所有** `additionalContext` 聚合点的唯一属主(此前是同一个
+ * `contexts.join("\n")` 表达式抄在二十余处,总量帽无处可挂 —— 那正是漂移成因)。
+ *
+ * 三条语义,都是承重的:
+ *  1. **顺序保留、只截尾**:先来的钩子先说话;一旦装不下就停,后面的条目一律不再挤进来(哪怕更短)。
+ *     按长度重排会让"第 3 条钩子的话"随别人的长度忽隐忽现,排障时无从复现。
+ *  2. **截断可见**:尾巴挂一行标记说明省了几条、丢了多少字符。静默丢弃会让 hook 作者以为自己的
+ *     context 生效了,而模型那头根本没见过 —— 这类"以为配好了"的缺席比长文本本身更贵。
+ *  3. **标记不计预算**:与 core `truncateError` / CC `A7e` 同姿势(marker 不占那 10k),否则帽值的
+ *     含义会随标记文案长度漂。
+ */
+export function buildHookContext(parts) {
+    const present = parts.filter((p) => p.length > 0).map(readHookContextPart);
+    if (present.length === 0)
+        return undefined;
+    const kept = [];
+    let used = 0;
+    let truncating = false;
+    let messages = 0;
+    let omitted = 0;
+    let droppedChars = 0;
+    for (const part of present) {
+        // 内层的账先并进来(标记读回,见 {@link readHookContextPart}),再谈这一轮自己丢了什么。
+        messages += part.messages;
+        omitted += part.omitted;
+        droppedChars += part.dropped;
+        if (!truncating) {
+            const sep = kept.length > 0 ? 1 : 0; // join 的 "\n" 也占预算
+            const room = MAX_HOOK_CONTEXT_TOTAL_CHARS - used - sep;
+            if (room >= part.body.length) {
+                if (part.body.length > 0) {
+                    kept.push(part.body);
+                    used += sep + part.body.length;
+                }
+                continue;
+            }
+            truncating = true;
+            // 只有**单条**发言可以切尾:切了它仍是"部分在场",账目诚实(dropped 记尾巴,omitted 不变)。
+            // 已聚合的成品代表内层多条、正文里却没有条目边界 —— 切一刀会把第 2..N 条整个抹掉却记 0 条省略,
+            // 标记恰好在最常走的两层合流路上说谎(codex 复审 R4,亲核属实)。⇒ 它要么整段留,要么整条丢。
+            if (part.messages === 1 && room >= MIN_HOOK_CONTEXT_PARTIAL_CHARS) {
+                kept.push(part.body.slice(0, room));
+                used += sep + room;
+                droppedChars += part.body.length - room;
+                continue;
+            }
+        }
+        // 整条不见 = 它代表的**全部**条目都不见。内层已经报过的那几条上面加过了,这里只补差额
+        // ——否则一个"3 of 5"的成品被整条丢掉会记成 8 条,报出"省掉的比总数还多"这种自相矛盾的账。
+        omitted += part.messages - part.omitted;
+        droppedChars += part.body.length;
+    }
+    const body = kept.join("\n");
+    if (droppedChars === 0)
+        return body;
+    const marker = `[hook context truncated at ${MAX_HOOK_CONTEXT_TOTAL_CHARS} chars: ${omitted} of ${messages} hook messages omitted, ${droppedChars} characters dropped]`;
+    return kept.length > 0 ? `${body}\n${marker}` : marker;
+}
+/** 截断标记的尾锚形。帽值**逐字写进模式**(不是 `\d+`):只认"我们自己这一版才会写出的那一份",
+ *  别处飘来的同类文字连模式都不匹配。 */
+const HOOK_CONTEXT_MARKER_RE = new RegExp(`\\n\\[hook context truncated at ${MAX_HOOK_CONTEXT_TOTAL_CHARS} chars: (\\d+) of (\\d+) hook messages omitted, (\\d+) characters dropped\\]$`);
+/** 读回标记时接受的数字上界(2^42)。比任何真值大若干数量级,又小到几十条相加也绝不越过安全整数
+ *  —— 伪造的巨数因此根本进不来,合并加法也不必每一步复验溢出。 */
+const MAX_HOOK_CONTEXT_PARSED_COUNT = 2 ** 42;
+/**
+ * 片段 → 内容 + 它自带的截断账。
+ *
+ * 为什么必须能**读回**自己写的标记:`composeHooks` 会把 {@link buildHookContext} 的成品当片段再喂一次
+ * (部署槽在场即走这条路 —— 是常态不是边角)。标记按内容处理会犯两桩:①切在标记中间 ⇒ 模型读到半截
+ * 标记;②外层重新记账 ⇒ 内层丢掉的那一万多字符凭空消失,标记数字变成谎。标记既然不计预算,读回时也
+ * 不能算内容;把它携带的账并进外层,函数对自己的输出就是幂等的。
+ *
+ * 🔴 这把尺子对着的是**不可信文本**(钩子想吐什么就吐什么),所以只认"我们自己才写得出的那一份":
+ * 帽值逐字相等(在模式里)、`dropped ≥ 1`(我们从不在零丢弃时写标记)、`omitted ≤ messages`、
+ * `messages ≥ 1`、数字都在 {@link MAX_HOOK_CONTEXT_PARSED_COUNT} 内。任一条不合 ⇒ **整段当普通内容**。
+ * 认下之后也不会有"内容静默少一行":认下 ⇒ `dropped > 0` ⇒ 输出必然带标记 —— 摘掉的那一行总是被
+ * **重写**回去(数字可能被合并),从不是被删掉。伪造得刚好合规只会让记账口径偏,不改任何裁决;
+ * 而且钩子配置在单用户闸内,伪造者就是这份账的读者本人。
+ */
+function readHookContextPart(part) {
+    const m = HOOK_CONTEXT_MARKER_RE.exec(part);
+    if (!m)
+        return { body: part, messages: 1, omitted: 0, dropped: 0 };
+    const omitted = Number(m[1]);
+    const messages = Number(m[2]);
+    const dropped = Number(m[3]);
+    const sane = (n) => Number.isSafeInteger(n) && n <= MAX_HOOK_CONTEXT_PARSED_COUNT;
+    if (!sane(omitted) || !sane(messages) || !sane(dropped) || messages < 1 || omitted > messages || dropped < 1) {
+        return { body: part, messages: 1, omitted: 0, dropped: 0 };
+    }
+    return { body: part.slice(0, part.length - m[0].length), messages, omitted, dropped };
+}
+/** {@link buildHookContext} 的字段形(聚合点全是 `...spread` 进结果对象):空 → 不产字段。 */
+function buildHookContextField(parts) {
+    const text = buildHookContext(parts);
+    return text === undefined ? {} : { additionalContext: text };
+}
 /** 跑一条 command hook:sh -c,stdin=payload JSON(CC-verbatim),超时 SIGKILL,输出各限 1MiB。 */
 function runCommandHook(entry, payload, ctx) {
     return new Promise((resolve) => {
@@ -736,7 +852,7 @@ export function createTaskHooks(config, ctx) {
                     if (run.code === 2) {
                         // CC:exit 2 = 阻断,stderr 喂给模型
                         const reason = clip(run.stderr.trim(), MAX_HOOK_FEEDBACK_CHARS) || "blocked by a PreToolUse hook";
-                        return { action: "deny", message: reason, ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}) };
+                        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) });
@@ -750,11 +866,11 @@ export function createTaskHooks(config, ctx) {
                     if (out.continue === false) {
                         const reason = clip(typeof out.stopReason === "string" ? out.stopReason : "hook requested stop", MAX_HOOK_FEEDBACK_CHARS);
                         // core 的 preToolUse seam 无"终止整个 run"能力(阶段一诚实近似:deny 本次调用)。
-                        return { action: "deny", message: reason, ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}) };
+                        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, ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}) };
+                        return { action: "deny", message: reason, ...buildHookContextField(contexts) };
                     }
                     const hso = out.hookSpecificOutput;
                     if (hso !== null && typeof hso === "object" && hso.hookEventName === "PreToolUse") {
@@ -764,7 +880,7 @@ export function createTaskHooks(config, ctx) {
                         const decision = h.permissionDecision;
                         if (decision === "deny") {
                             const reason = clip(typeof h.permissionDecisionReason === "string" ? h.permissionDecisionReason : "denied by a PreToolUse hook", MAX_HOOK_FEEDBACK_CHARS);
-                            return { action: "deny", message: reason, ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}) };
+                            return { action: "deny", message: reason, ...buildHookContextField(contexts) };
                         }
                         if (decision === "ask") {
                             asked = clip(typeof h.permissionDecisionReason === "string" ? h.permissionDecisionReason : "a PreToolUse hook requires approval", MAX_HOOK_FEEDBACK_CHARS);
@@ -798,7 +914,7 @@ export function createTaskHooks(config, ctx) {
                     action: "ask",
                     message: asked,
                     ...(rewritten ? { updatedInput: currentInput } : {}),
-                    ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}),
+                    ...buildHookContextField(contexts),
                 };
             }
             if (unknownDecision) {
@@ -814,14 +930,14 @@ export function createTaskHooks(config, ctx) {
                     action: "ask",
                     message: "a PreToolUse hook returned an unrecognized permissionDecision — approval required",
                     ...(rewritten ? { updatedInput: currentInput } : {}),
-                    ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}),
+                    ...buildHookContextField(contexts),
                 };
             }
             if (rewritten || contexts.length > 0) {
                 return {
                     action: "allow",
                     ...(rewritten ? { updatedInput: currentInput } : {}),
-                    ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}),
+                    ...buildHookContextField(contexts),
                 };
             }
             return undefined; // 无意见(≠ allow 短路;core 门照常裁决)
@@ -879,7 +995,8 @@ export function createTaskHooks(config, ctx) {
                     }
                 }
             }
-            return contexts.length > 0 ? { additionalContext: contexts.join("\n") } : undefined;
+            const additionalContext = buildHookContext(contexts);
+            return additionalContext === undefined ? undefined : { additionalContext };
         };
         hooks.postToolUse = postToolUseHook;
     }
@@ -927,7 +1044,8 @@ export function createTaskHooks(config, ctx) {
                         contexts.push(clip(h.additionalContext, MAX_HOOK_FEEDBACK_CHARS));
                 }
             }
-            return contexts.length > 0 ? { additionalContext: contexts.join("\n") } : undefined;
+            const additionalContext = buildHookContext(contexts);
+            return additionalContext === undefined ? undefined : { additionalContext };
         };
         hooks.postToolUseFailure = postToolUseFailureHook;
     }
@@ -973,7 +1091,8 @@ export function createTaskHooks(config, ctx) {
                 if (out.hookSpecificOutput !== undefined)
                     ctx.logger.warn("hook_result_unsupported", { event: "PostToolBatch" });
             }
-            return contexts.length > 0 ? { additionalContext: contexts.join("\n") } : undefined;
+            const additionalContext = buildHookContext(contexts);
+            return additionalContext === undefined ? undefined : { additionalContext };
         };
         hooks.postToolBatch = postToolBatchHook;
     }
@@ -989,7 +1108,7 @@ export function createTaskHooks(config, ctx) {
             for (const { run } of singles) {
                 if (run.code === 2) {
                     const reason = clip(run.stderr.trim(), MAX_HOOK_FEEDBACK_CHARS) || "blocked by a UserPromptSubmit hook";
-                    return { block: reason, ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}) };
+                    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) });
@@ -1003,11 +1122,11 @@ export function createTaskHooks(config, ctx) {
                 if (out.continue === false) {
                     // continue:false=终止整个 run;userPromptSubmit 的 block 语义正是"任务带理由收场"——同义直映射。
                     const reason = clip(typeof out.stopReason === "string" ? out.stopReason : "hook requested stop", MAX_HOOK_FEEDBACK_CHARS);
-                    return { block: reason, ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}) };
+                    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);
-                    return { block: reason, ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}) };
+                    return { block: reason, ...buildHookContextField(contexts) };
                 }
                 const hso = out.hookSpecificOutput;
                 if (hso !== null && typeof hso === "object" && hso.hookEventName === "UserPromptSubmit") {
@@ -1016,7 +1135,8 @@ export function createTaskHooks(config, ctx) {
                         contexts.push(clip(h.additionalContext, MAX_HOOK_FEEDBACK_CHARS));
                 }
             }
-            return contexts.length > 0 ? { additionalContext: contexts.join("\n") } : undefined;
+            const additionalContext = buildHookContext(contexts);
+            return additionalContext === undefined ? undefined : { additionalContext };
         };
         hooks.userPromptSubmit = userPromptSubmitHook;
     }
@@ -1180,7 +1300,7 @@ export function createTaskHooks(config, ctx) {
                 return undefined;
             return {
                 ...(block !== undefined ? { block } : {}),
-                ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}),
+                ...buildHookContextField(contexts),
             };
         };
         hooks.stop = stopHook;
@@ -1288,7 +1408,7 @@ export function composeHooks(deployment, task) {
                 if (r.additionalContext)
                     contexts.push(r.additionalContext);
                 if (r.action === "deny")
-                    return { ...r, ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}) };
+                    return { ...r, ...buildHookContextField(contexts) };
                 if (r.action === "ask")
                     asked = r;
                 if (r.action === "allow" && r.updatedInput !== undefined) {
@@ -1301,14 +1421,14 @@ export function composeHooks(deployment, task) {
                 return {
                     ...asked,
                     ...(askedUpdated === undefined && current !== input ? { updatedInput: current } : {}),
-                    ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}),
+                    ...buildHookContextField(contexts),
                 };
             }
             if (current !== input || contexts.length > 0) {
                 return {
                     action: "allow",
                     ...(current !== input ? { updatedInput: current } : {}),
-                    ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}),
+                    ...buildHookContextField(contexts),
                 };
             }
             return undefined;
@@ -1324,7 +1444,7 @@ export function composeHooks(deployment, task) {
             const updatedOutput = rt?.updatedOutput ?? rd?.updatedOutput;
             return {
                 ...(updatedOutput ? { updatedOutput } : {}),
-                ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}),
+                ...buildHookContextField(contexts),
             };
         };
     }
@@ -1333,7 +1453,8 @@ export function composeHooks(deployment, task) {
             const rd = d.postToolUseFailure ? await d.postToolUseFailure(toolName, input, failure, ctx) : undefined;
             const rt = t.postToolUseFailure ? await t.postToolUseFailure(toolName, input, failure, ctx) : undefined;
             const contexts = [rd?.additionalContext, rt?.additionalContext].filter((c) => typeof c === "string" && c.length > 0);
-            return contexts.length ? { additionalContext: contexts.join("\n") } : undefined;
+            const additionalContext = buildHookContext(contexts);
+            return additionalContext === undefined ? undefined : { additionalContext };
         };
     }
     if (d.postToolBatch || t.postToolBatch) {
@@ -1341,19 +1462,22 @@ export function composeHooks(deployment, task) {
             const rd = d.postToolBatch ? await d.postToolBatch(calls) : undefined;
             const rt = t.postToolBatch ? await t.postToolBatch(calls) : undefined;
             const contexts = [rd?.additionalContext, rt?.additionalContext].filter((c) => typeof c === "string" && c.length > 0);
-            return contexts.length ? { additionalContext: contexts.join("\n") } : undefined;
+            const additionalContext = buildHookContext(contexts);
+            return additionalContext === undefined ? undefined : { additionalContext };
         };
     }
     if (d.userPromptSubmit || t.userPromptSubmit) {
         out.userPromptSubmit = async (prompt) => {
             const rd = d.userPromptSubmit ? await d.userPromptSubmit(prompt) : undefined;
+            // 短路的是**槽序**(部署拦下就不再跑 task 槽),不是预算:`additionalContext` 与 `block` 在 core
+            // 是解耦两字段(见下方 stop 注),原样外送就是一条绕过总帽的道。
             if (rd?.block)
-                return rd;
+                return { ...rd, ...buildHookContextField(rd.additionalContext ? [rd.additionalContext] : []) };
             const rt = t.userPromptSubmit ? await t.userPromptSubmit(prompt) : undefined;
             if (!rd && !rt)
                 return undefined;
             const contexts = [rd?.additionalContext, rt?.additionalContext].filter((c) => typeof c === "string" && c.length > 0);
-            return { ...(rt?.block ? { block: rt.block } : {}), ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}) };
+            return { ...(rt?.block ? { block: rt.block } : {}), ...buildHookContextField(contexts) };
         };
     }
     if (d.stop || t.stop) {
@@ -1362,12 +1486,12 @@ export function composeHooks(deployment, task) {
         out.stop = async (sctx) => {
             const rd = d.stop ? await d.stop(sctx) : undefined;
             if (rd?.block)
-                return rd;
+                return { ...rd, ...buildHookContextField(rd.additionalContext ? [rd.additionalContext] : []) };
             const rt = t.stop ? await t.stop(sctx) : undefined;
             if (!rd && !rt)
                 return undefined;
             const contexts = [rd?.additionalContext, rt?.additionalContext].filter((c) => typeof c === "string" && c.length > 0);
-            return { ...(rt?.block ? { block: rt.block } : {}), ...(contexts.length ? { additionalContext: contexts.join("\n") } : {}) };
+            return { ...(rt?.block ? { block: rt.block } : {}), ...buildHookContextField(contexts) };
         };
     }
     if (d.preCompact || t.preCompact) {

package/dist/http/routes/approvals-assistant.js

@@ -1,10 +1,10 @@
-import { principalFrom, decodeCheckpointScope } from "../../security.js";
+import { principalFrom, decodeCheckpointScope, PRINCIPAL_TOKEN_HEADER, APPROVAL_MAC_HEADER, APPROVAL_MAC_KID_HEADER } from "../../security.js";
 import { verifyDirectDoorProof } from "../../principal-jwt.js";
 import { MAX_APPROVAL_REASON_CHARS } from "../../approval-hmac.js";
 import { redactedPreview } from "../../trace/redact.js";
 import { fleetRunLabels } from "../../fleet/fleet-bus.js"; // [2069]④ §3 行展示名与 fleet 行同源(见用处的注)
 import { sleep } from "../sse-log.js";
-import { sendJson, sendError, sseHeaders } from "../send.js";
+import { sendJson, sendError, sseHeaders, SSE_MAX_STREAM_MS, SSE_HEARTBEAT_IDLE_MS } from "../send.js";
 import { gatedPrincipal, explicitOperatorOk, isOperator } from "../principal-gate.js";
 // design/80 seam #2 (assistant-scheduler): graceful preempt (durable yield) + resource_limit resume of one task.
 export const ASSISTANT_PREEMPT_RE = /^\/v1\/assistant\/tasks\/([^/]+)\/preempt$/;
@@ -427,7 +427,7 @@ async function handleApprovalsAssistantBody(req, res, url, ctx, miss) {
             let deciderPrincipal = principal;
             if (deps.config.directDoorActive) {
                 const hdr = (n) => { const h = req.headers[n]; return Array.isArray(h) ? h[0] : h; };
-                const proof = verifyDirectDoorProof({ jwt: hdr("x-approval-principal-token"), mac: hdr("x-approval-mac"), kid: hdr("x-approval-mac-kid") }, 
+                const proof = verifyDirectDoorProof({ jwt: hdr(PRINCIPAL_TOKEN_HEADER), mac: hdr(APPROVAL_MAC_HEADER), kid: hdr(APPROVAL_MAC_KID_HEADER) }, 
                 // reason 入签:同一条规则也适用于身份绑定腿(两个绑定位为 null,第五位照常参与)。
                 { sessionId: run.sessionId, decision, reason: typeof body.reason === "string" ? body.reason : null }, deps.config, { actionBinding: false });
                 if (!proof.ok) {
@@ -569,7 +569,7 @@ async function handleApprovalsAssistantBody(req, res, url, ctx, miss) {
                     const h = req.headers[n];
                     return Array.isArray(h) ? h[0] : h;
                 };
-                const proof = verifyDirectDoorProof({ jwt: hdr("x-approval-principal-token"), mac: hdr("x-approval-mac"), kid: hdr("x-approval-mac-kid") }, 
+                const proof = verifyDirectDoorProof({ jwt: hdr(PRINCIPAL_TOKEN_HEADER), mac: hdr(APPROVAL_MAC_HEADER), kid: hdr(APPROVAL_MAC_KID_HEADER) }, 
                 // reason 入签(三方裁 (a) + clay 干净切):落账理由属于决定内容,与 decision 同受完整性保护。
                 { sessionId, boundCallId: binding.boundCallId, boundInputHash: binding.boundInputHash, decision, reason: typeof body.reason === "string" ? body.reason : null }, deps.config);
                 if (!proof.ok) {
@@ -682,7 +682,6 @@ export async function streamApprovals(req, res, cs, scope, pollMs = APPROVALS_ST
     let closed = false;
     req.on("close", () => { closed = true; });
     const start = Date.now();
-    const MAX_MS = 15 * 60 * 1000;
     let lastBeat = Date.now();
     let prev = new Map();
     let first = true;
@@ -715,11 +714,11 @@ export async function streamApprovals(req, res, cs, scope, pollMs = APPROVALS_ST
                     res.write(`event: resolved\ndata: ${JSON.stringify({ type: "resolved", sessionId: p.sessionId, toolCallId: p.toolCallId })}\n\n`); // decided/expired/gone
         }
         prev = cur;
-        if (Date.now() - start > MAX_MS) {
+        if (Date.now() - start > SSE_MAX_STREAM_MS) {
             res.write(`event: error\ndata: ${JSON.stringify({ type: "error", errorCode: "STREAM_MAX_DURATION", message: "approvals stream reached its 15-minute cap — reconnect to continue" })}\n\n`);
             break;
         }
-        if (Date.now() - lastBeat > 15_000) {
+        if (Date.now() - lastBeat > SSE_HEARTBEAT_IDLE_MS) {
             res.write(`event: heartbeat\ndata: ${JSON.stringify({ type: "heartbeat" })}\n\n`);
             lastBeat = Date.now();
         }

package/dist/http/routes/diagnostics.js

@@ -58,14 +58,19 @@ export function buildStaticWiringAudit(facts) {
     // park 车道的**持久性读数**(codex 交叉复审 2026-08-07 R2-F2,验真后部分采纳)。`capable` 说的是
     // 「有没有 checkpoint 店」、`effective` 说的是「这条部署形会不会真 park」—— 两者都为真时仍可能是一个
     // 重启即丢的店,那样窗到期后被 park 的审批在重启后无法赎回,而流内审批协议正是拿 park 当降级目的地。
-    // 🔴 为什么是 **warn 而不是拒启**:本仓的 SQL/local checkpoint 店**都还没有 `durability` 声明**,core
-    // 因此对每一个真持久部署都读出 `process_local`。据此拒启会拿一个不可信信号挡住 100% 的现存 durable
-    // 部署 —— 那不是查出矛盾。根治在店侧补声明;在那之前,把「这个读数不可信」响亮说出来,不静默。
+    // ✅ **读数已转可信**(#168 件5,2026-08-07):树上三条 checkpoint 店(SQL 双生 + local 文件形)现在都
+    // 如实声明了 `durability`,所以这条读数不再对真持久部署恒假 —— 它现在说的就是字面意思。
+    //
+    // 🔴 仍然是 **warn 而不是拒启**,判据与 session 那条**刻意不同**,理由写在这里免得下一个人以为是漏改:
+    // session 那条对表的是「声明 durable × 介质不 durable」——两个已知量互相矛盾,拒启是查出了谎。这一条
+    // 对表的是「有没有人声明」,而 core 把**缺席**折成 `process-local`;一个合法的第三方/新增 checkpoint
+    // 店没表态时,拒启会挡住一个本来跑得好好的部署,而**没有任何旋钮**能让它继续启动(补偿为零 ⇒ 不升格)。
+    // 升格的前置件 = core 把「未声明」与「声明为进程内」分成两个可区分读数,或本仓给出一个显式承认旋钮。
     if (facts.parkFacility && facts.manifest.parkLane.checkpointDurability !== "declared_durable") {
         warnings.push(`park facility is enabled but the checkpoint store does not declare durable storage ` +
             `(parkLane.checkpointDurability=${JSON.stringify(facts.manifest.parkLane.checkpointDurability ?? null)}). ` +
-            `A parked approval survives a restart only on a durable store — and the in-tree checkpoint adapters currently declare no durability at all, so this reading cannot yet distinguish "really process-local" from "nobody declared it". ` +
-            `Treat park-lane recovery as unproven until the adapter declares its durability.`);
+            `A parked approval survives a restart only on a durable store, and this reading folds "declared process-local" together with "declared nothing" — every in-tree adapter declares "durable", so a non-durable reading here means a store this build does not own. ` +
+            `Treat park-lane recovery as unproven until that adapter declares its durability.`);
     }
     if (facts.manifest.interaction.posture === "interactive" && facts.manifest.question.wired !== "wired") {
         warnings.push(`interactionPosture declares "interactive" but no question delivery face is wired (question.wired=${JSON.stringify(facts.manifest.question.wired)}) — ` +