@sema-agent/server 7.134.0 → 7.136.0

package/dist/hooks/hook-llm.js

@@ -2,6 +2,7 @@ import { admitRouteRequest, BrainError, joinRequestUrl, resolveRouteCredential,
 import { matchCatalogModel, refusedCatalogEntry, servedModelTableLeg } from "../model-select.js";
 import { echoModelRef, modelUnavailableMessage } from "../model-entry-refusal.js";
 import { resolveOpenaiRouteEndpoint } from "../model-route-endpoint.js";
+import { anthropicLaneCredentialOf } from "../model-route-gap.js";
 import { anthropicRouteRoot, brainLaneFor, routeTableOf } from "../model-provider.js";
 import { egressRedirectRefusal } from "../egress-redirect.js";
 import { buildDisplaySafeRefusal, redactSecrets } from "../trace/redact.js";
@@ -33,6 +34,16 @@ function gateRefusal(pick, e, declaredRoot) {
         error: `hook model "${pick.catalogRef}" cannot be routed (${code}) — ` + buildDisplaySafeRefusal(text, [pick.baseUrl, declaredRoot ?? ""]),
     };
 }
+function routeCredentialHeader(credential) {
+    if (credential === undefined)
+        return {};
+    switch (credential.kind) {
+        case "x-api-key":
+            return { "x-api-key": credential.value };
+        case "bearer":
+            return { authorization: `Bearer ${credential.value}` };
+    }
+}
 export function createHookLlm(deps) {
     const { config, metrics } = deps;
     const anthropicRouteBaseUrl = () => anthropicRouteRoot(config.anthropic ?? {});
@@ -122,9 +133,10 @@ export function createHookLlm(deps) {
             let admitted;
             let declaredRoot;
             if (pick.api === "anthropic-messages") {
+                const routeCredential = anthropicLaneCredentialOf(config.anthropic ?? {});
                 const routeBase = anthropicRouteBaseUrl();
                 declaredRoot = routeBase;
-                const routed = judgeRoute(pick, perModelKey, config.anthropic?.authToken ?? config.anthropic?.apiKey, routeBase);
+                const routed = judgeRoute(pick, perModelKey, routeCredential?.value, routeBase);
                 if (!routed.ok)
                     return routed;
                 admitted = routed.admission;
@@ -132,13 +144,7 @@ export function createHookLlm(deps) {
                 headers = {
                     "content-type": "application/json",
                     "anthropic-version": config.anthropic?.version ?? "2023-06-01",
-                    ...(routed.credential.source === "per-model"
-                        ? { "x-api-key": routed.credential.apiKey ?? "" }
-                        : config.anthropic?.authToken
-                            ? { authorization: `Bearer ${config.anthropic.authToken}` }
-                            : config.anthropic?.apiKey
-                                ? { "x-api-key": config.anthropic.apiKey }
-                                : {}),
+                    ...(routed.credential.source === "per-model" ? { "x-api-key": routed.credential.apiKey ?? "" } : routeCredentialHeader(routeCredential)),
                 };
                 const want = maxOutputTokens ?? 1024;
                 const maxTokens = Math.min(config.models[pick.catalogRef]?.maxTokens ?? want, want);

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

@@ -1,10 +1,11 @@
 import { type HookEntry, type HookEntryType, type HookEventName, type HooksDroppedPiece, type HooksDroppedPieceCode, type HooksRejection, type HooksRejectionCode } from "@sema-agent/settings-schema/hooks";
-import { type ConfigPath } from "@sema-agent/settings-schema";
+import { type ConfigPath, type UrlCredential } from "@sema-agent/settings-schema";
 import { ENGINE_OWNED_HOOK_EVENTS } from "@sema-agent/settings-schema/hooks";
 import type { EngineDollar, ModRegistration } from "@sema-agent/core";
 import type { Logger } from "../observability/logger.js";
 import type { HookManagedUnrun, HookNoticeObservation } from "../fleet/fleet-bus.js";
 import { LIMIT_REASONS, type LimitMeasure } from "../limit-refusal.js";
+import { type UrlCredentialRefusal } from "../url-credential-refusal.js";
 import { type HookGroupSource } from "./hook-source.js";
 import { type RunnableCommandHookEntry } from "./command-spawn.js";
 /** 服务侧防线上限(契约本身不设量纲;不设界=单请求可塞任意大配置/任意长命令)。超界=校验错(fail-loud)。 */
@@ -134,12 +135,12 @@ export type ParseHooksConfigResult = {
     readonly pieces?: readonly HooksRefusalPiece[];
 };
 /**
- * 🔴 **S-924 → S-995(clay [ref] ③;八病审计 SG H6-d;test 7.112.0 验收 OBS ①)—— 工具事件的 matcher 选中了工具**别名**、却选不中它的正名 ⇒ fresh 提交面响亮拒。**
+ * 🔴 **[ref] → [ref](clay [ref] ③;八病审计 SG H6-d;test 7.112.0 验收 OBS ①)—— 工具事件的 matcher 选中了工具**别名**、却选不中它的正名 ⇒ fresh 提交面响亮拒。**
  *
  * 病:三个工具事件(PreToolUse / PostToolUse / PostToolUseFailure)的 matcher 都按调用的 **wire 名**匹配(本文件顶注
  * 「tool_name 是哪一个名」;core `NAME_READINGS` 三行均为 `wire`)。引擎自带工具 `ListAgents` 的别名 `ListPeers` 写进 matcher
  * ⇒ **永不命中、一句话都没有**(post 两事件自 7.107.0 / core 7.36.0 起如此,PreToolUse 一直如此)。静默不命中 = 写的人以为在生效的 hook
- * 其实没跑,硬破坏三句要求的「响亮」没有着落。7.112.0(S-924)只拒**字面**别名;同一个错误写成 `^ListPeers$` / `ListPeers.*` / `(ListPeers)` 照样 200(S-995)。
+ * 其实没跑,硬破坏三句要求的「响亮」没有着落。7.112.0([ref])只拒**字面**别名;同一个错误写成 `^ListPeers$` / `ListPeers.*` / `(ListPeers)` 照样 200([ref])。
  *
  * 规则(一条;字面形是它的特例):{@link hooksMatcherIssue} 对 core 静态目录里**每一条退役别名**问「这只 matcher 选不选它 / 选不选它的正名」:
  * matcher **命中别名 ∧ 不命中它的正名** ⇒ `400 request.field_invalid`(`admission.ts` fresh 门)。「选不选」**只有一只读法**:契约包的 `hookMatcherSelects`
@@ -148,7 +149,7 @@ export type ParseHooksConfigResult = {
  *  ② **形只问契约包的 `hookMatcherForm`**(与 `hookMatcherSelects` 同一只解析步,本仓不留形判),闭集三词、两档一张表:
  *     · `literal`(缺席 / 空 / `*` / 名字表形;契约不编、不跑调用方的正则)⇒ 两档都**直接问契约函数**、**不占求值预算**;
  *     · `regex` ⇒ **`"regex"` 档**(hooks 会被采纳的车道,`taskHooksHonored`)把**同一只契约函数**经 `node:vm` 的 `timeout` 带**每次求值各一份固定预算**调用({@link matcherSelectsWithin};
- *       每次求值的额度**不共享**、不随同一受理里别的 matcher 缩水、这一份不读钟 —— S-1455;另有一只受理总额度,见下「预算与结局」);**超时 ⇒ 这只 matcher 是灾难回溯 ⇒ `400 request.field_invalid` 拒**(见下「预算与结局」);
+ *       每次求值的额度**不共享**、不随同一受理里别的 matcher 缩水、这一份不读钟 —— [ref];另有一只受理总额度,见下「预算与结局」);**超时 ⇒ 这只 matcher 是灾难回溯 ⇒ `400 request.field_invalid` 拒**(见下「预算与结局」);
  *       **`"literal"` 档**(多租户车道:hooks 整只被 resolveSpec 忽略)= **不适用**:该车道没有被守的对象(hooks 不装配),不判、不算未判、不登记 —— **零调用方正则执行**
  *       (7.112.0 的字面判保留:裸 `ListPeers` / `Read|ListPeers` 照旧 400);
  *     · `invalid`(编不过)⇒ `"regex"` 档 = **`400 request.field_invalid` 拒**(判决 `invalid_regex`,见下「预算与结局」;不进求值 —— 形判已答「读不了」);`"literal"` 档 = 不适用(同上)。
@@ -156,7 +157,7 @@ export type ParseHooksConfigResult = {
  *  · **为什么两档**(codex r1 [high] + 主会话裁):受理面是**所有**车道,而运行期只有单用户车道跑 hooks。在受理线程上跑调用方的正则 = 给多租户加一个事件循环 DoS 面
  *    (实测:`(.*)*` ×10 + `X` 对 9 字符名字首次执行 1.7 s,18 字符嵌套形 15 s,24 字符 157 s;8 MiB 交替串编译 + 求值 9 s)—— 预算只界住一次请求、界不住「每个请求再拿一份」。
  *    但也不能因此在多租户车道「不判决」(那会放宽已发行为:裸 `ListPeers` 的 400)。所以两车道同一条规则、两档深度。谓词 `taskHooksHonored` 是唯一属主(与 resolveSpec / capabilities 同调)。
- *  · **为什么不进 {@link parseHooksConfig}**(codex r1 [high],S-924):`parseHooksConfig` 同时是 resume 重放(`parseTaskSettings` 宽容层)的校验器,
+ *  · **为什么不进 {@link parseHooksConfig}**(codex r1 [high],[ref]):`parseHooksConfig` 同时是 resume 重放(`parseTaskSettings` 宽容层)的校验器,
  *    它判不过 ⇒ **整只 hooks 不采纳**。存量 body 里同一份 hooks 常常还有会真拦的 PreToolUse 钩子 —— 一个永不命中的别名 matcher 把它们一并带走,
  *    升级前被拦的 Bash 升级后放行(安全轴上的回退)。所以这条规则住在 fresh 专用的判据里,与 `taskSettingsKeyIssue` 同姿势
  *    (「fresh 400 / resume 宽容」双层:会砖存量的规则只咬 fresh)。resume 照旧整只采纳,别名那一组继续永不命中(与 7.111.0 逐字同),其余照跑。
@@ -167,57 +168,57 @@ export type ParseHooksConfigResult = {
  *  · **正名同在则不拒**:`正名|别名` / `List.*` 会命中正名,不是「静默不命中」,且正是 7.107.0 CHANGELOG 给的「滚动期两名都写」补偿形。
  *    只拒「别名那一路永远打不中、而它的正名不在选中集里」—— 含 `Read|ListPeers`(7.112.0 已拒;主会话裁:规则形采「按条目逐条问」,不放宽;卡面整 matcher「匹配不到任何现役名」形会把它放回 200)。
  *    多拒(相对卡面形)三例与出路:`Read|ListPeers` / `ListPeers|mcp__.*`(别名支永不命中,出路:改成正名)/ 排除式 `^(?!ListAgents).*`(出路:`^(?!ListAgents|ListPeers).*` 两名都不命中 ⇒ 放)。
- *  · **空白与大小写(S-995 / sema-test [ref] 起,运行期与 CC 同形)**:名字表读法(契约函数;`|` 与 `,` 分隔)容忍两端与分隔符两侧空白 ⇒ `" ListPeers"` / `"ListPeers "` / `"Read | ListPeers"` 会命中别名 ⇒ 落进本规则 400;
+ *  · **空白与大小写([ref] / sema-test [ref] 起,运行期与 CC 同形)**:名字表读法(契约函数;`|` 与 `,` 分隔)容忍两端与分隔符两侧空白 ⇒ `" ListPeers"` / `"ListPeers "` / `"Read | ListPeers"` 会命中别名 ⇒ 落进本规则 400;
  *    **区分大小写、不剥词内空白** ⇒ `"listpeers"` / `"List Peers"` 对别名与正名都选不中,照旧受理(CC 同形)。
  *  · **不在本规则内**:两边都选不中的 matcher(大小写错 / 词内空白 / 纯错字;目录之外的 MCP / 嵌入方工具名同样「选不中目录里任何名」,受理面无从区分错字与它们)=
  *    **「选不到目录里任何名」另一类,候设计(台账另立号,主会话裁)**。
  *
- * 🔴 **预算与结局(S-1455 / S-1503;良性设置的受理结局只取决于配置,不取决于机器忙闲)**:regex 档每一次求值(一只正则形 matcher 对一个名字的一次问)各拿**一份固定的墙钟预算**
+ * 🔴 **预算与结局([ref] / [ref];良性设置的受理结局只取决于配置,不取决于机器忙闲)**:regex 档每一次求值(一只正则形 matcher 对一个名字的一次问)各拿**一份固定的墙钟预算**
  * {@link ADMISSION_MATCHER_BUDGET}`.budgetMs`(vm `timeout`,从这次求值开始计)—— **不共享**(此前一次受理共用 100 ms,忙机上会被吃光 ⇒
  * 同一份设置忙机偶尔被收下、闲机恒 400),额度不随同一受理里 matcher 的个数缩水,这一份**不读钟**(没有「截止线」可被调度停顿越过)。预算只防**灾难回溯**:
  * 良性求值 ~0.1 ms,灾难形(指数级)吃满预算也跑不完 —— 两者相差数个数量级,取值给足余量(1 000 ms),让忙机上的调度停顿也跨不过这条线。
- * **另有一只受理总额度**(S-1503;同一张表的 `.totalMs`,5 000 ms):每次求值的额度界得住「一只 matcher 不会无限算」,界不住「刚好低于它的病态 matcher × 别名数 × 2 × 组数」(3 事件 × 16 组 × 1 别名 × 2 = 96 次,
+ * **另有一只受理总额度**([ref];同一张表的 `.totalMs`,5 000 ms):每次求值的额度界得住「一只 matcher 不会无限算」,界不住「刚好低于它的病态 matcher × 别名数 × 2 × 组数」(3 事件 × 16 组 × 1 别名 × 2 = 96 次,
  * 每次 0.99 s 就是 96 s 的事件循环占用)。一次受理里所有**已完成**的正则形求值的耗时之和(一只单调钟逐次累加;字面形与非工具事件不进 vm、不计)一旦**超过**总额度 ⇒ 同码 `400`,
  * `detail.reason = budget_exceeded`({@link BudgetExceededMatcherIssue},点名越线的那一组与总额度)。单次超时先到、先判 `over_budget`(更具体)。一次受理的最坏占用 ≤ 总额度 + 一次求值的额度。
  * 总额度这一只读钟,但良性设置离它近三个数量级(一份最大的良性配置 —— 3 工具事件 × 16 组 —— 总耗时在毫秒级),所以良性设置的结局仍不随机器忙闲翻转;只有求值总耗时逼近总额度的病态设置才可能落在边界两侧。
  * **超时 ⇒ 确定拒绝**:`400 request.field_invalid`({@link OverBudgetMatcherIssue}),句子点名**哪一只 matcher**(事件 + 组下标,不回显原字节)与**预算**;**按配置顺序遇到的第一只超时 / 命中别名的 matcher 定结局**。
- * 为什么是拒绝而不是放行:运行期 {@link hookMatcherMatches} 在**每次工具调用**里问同一只带预算的口(S-1017 起;此前是裸调、无预算)—— 一只在受理面连目录里几个短名字都求不完的 matcher 放进去,
+ * 为什么是拒绝而不是放行:运行期 {@link hookMatcherMatches} 在**每次工具调用**里问同一只带预算的口([ref] 起;此前是裸调、无预算)—— 一只在受理面连目录里几个短名字都求不完的 matcher 放进去,
  * 运行期每次调用都要白烧一整份预算(超预算的组按选中处理并登记,守卫不丢,但每次调用卡一份预算);放行 = 把一个确定的坏配置推迟成运行期每次调用的卡顿。这条拒不是「越界即拒」的新检测面:被拒的恰是**无法被求值**的 matcher,与 `hook_matcher_invalid`(编不过 ⇒ 该组不跑)同属「这只 matcher 不可用」,
  * 只是编不过的运行期自己安全地不跑它,跑不完的不行。
  * 总用时的上界:首个超时 / 总额度越线即拒、不再往下求值;未超时的求值各自 < 预算,其和 ≤ 总额度 + 一次求值的额度。regex 档只在单用户车道(`taskHooksHonored`,hooks 会装配的那条;调用方就是进程属主,本来就能配任意 `command` 钩子)运行,
  * 多租户车道走 literal 档、零调用方正则执行 —— 受理面的 DoS 面不因此重开。
  *
- * 🔴 **编不过的正则 = 确定的拒绝**(S-1455 收尾;与超预算同类 —— 确定性的坏配置,结局只取决于配置):`"regex"` 档遇契约 `hookMatcherForm` 答 `invalid`(或求值时契约函数答 `"invalid"`)⇒
+ * 🔴 **编不过的正则 = 确定的拒绝**([ref] 收尾;与超预算同类 —— 确定性的坏配置,结局只取决于配置):`"regex"` 档遇契约 `hookMatcherForm` 答 `invalid`(或求值时契约函数答 `"invalid"`)⇒
  * `400 request.field_invalid`({@link InvalidRegexMatcherIssue}),句子点名**哪一只 matcher**(事件 + 组下标 + 原文〔超 {@link MATCHER_ECHO_CHARS} 字符截断〕)与引擎的编译错误句;机读位 `detail` 只有闭集三键 + 坐标 `path`(那一组的 `matcher`)。
  * 受理面与运行期问**同一只判**:契约把"编不过"答成 `invalid`,运行期 {@link hookMatcherMatches} 因此不跑那一组(并记 `hook_matcher_invalid`),受理面因此拒 —— 本仓不加第二个判官
  * (编译错误句只是诊断文字,见 {@link matcherCompileSentence};拒不拒由契约函数一个人说了算)。为什么是拒绝而不是放行:放行 = 用户以为在生效的钩子(含会真拦的 PreToolUse deny 钩子)
  * 在每次工具调用里都**悄悄不跑**,硬破坏三句要求的「响亮」没有着落;`"literal"` 档(多租户车道,hooks 不装配)= 不适用,与正则形同一行表。resume 重放不判(照旧采纳、该组不跑)。
- * 🔴 **形判对所有事件同一判**(S-1472;此前只守三个工具事件,写在 `StopFailure` 的 `error` 词 / `PreCompact`·`PostCompact` 的 `trigger` 词上的坏 matcher 受理、运行期该组不跑并记 `hook_matcher_invalid`;壳跑的事件〔如 `SessionStart`〕由壳按同一只契约函数处置):
+ * 🔴 **形判对所有事件同一判**([ref];此前只守三个工具事件,写在 `StopFailure` 的 `error` 词 / `PreCompact`·`PostCompact` 的 `trigger` 词上的坏 matcher 受理、运行期该组不跑并记 `hook_matcher_invalid`;壳跑的事件〔如 `SessionStart`〕由壳按同一只契约函数处置):
  * 「这一串是不是一只读得了的 matcher」是**串的形**问题,不是事件的问题 —— `hookMatcherForm` 答 `invalid` ⇒ `400`,**不论写在 33 个契约事件里的哪一个**(含 matcher 被忽略的 `UserPromptSubmit` / `Stop` / `PostToolBatch`:规则里没有「事件类」这个维度,
  * 也就没有一张按事件类分档的表)。死别名问(「选中别名而选不中正名」)只对 matcher 匹配**工具 wire 名**的事件(上面的三个工具事件)才问 —— 别的事件上 matcher 匹配的不是工具名,没有「别名」可言;这一问不占别的事件的求值预算。
  *
  * 🔴 **「未判」臂过 `recordFailOpen`**(F 类 tag `MATCHER_UNJUDGED_TAG`;主会话裁,CLAUDE.md「合法 F 类回退走登记 tag」):一只 matcher 没能被判 ⇒ 照旧受理 + 登记一笔,
- * detail = `event=… reason=… matcherChars=…`(**不带 matcher 原字节**,S-716 姿势)。现在只剩一种 reason:
+ * detail = `event=… reason=… matcherChars=…`(**不带 matcher 原字节**,[ref] 姿势)。现在只剩一种 reason:
  *   `oversize` —— 两档:matcher 超 {@link MAX_MATCHER_EVAL_CHARS} 字符不读(多租户车道上 hooks 不装配,这一笔只为让超长输入显形)。
- * (`over_budget` 臂自 S-1455 起退役:它是「预算用尽 ⇒ 照旧受理」的随负载翻转的结局,现在是上面的确定拒绝;`invalid_regex` 臂自 S-1455 收尾起退役,同理。)
+ * (`over_budget` 臂自 [ref] 起退役:它是「预算用尽 ⇒ 照旧受理」的随负载翻转的结局,现在是上面的确定拒绝;`invalid_regex` 臂自 [ref] 收尾起退役,同理。)
  * 放行最坏后果 = 那一只 matcher 没被这条判据守住、照旧永不命中,**不是安全闸**(受理面有效性判)。
  * 拒放集合相对 7.113.0 的一处放宽(披露在 CHANGELOG / MIGRATION):超过上限的字面别名 matcher 7.113.0 拒(当时字面判不设上限),自 7.114.0 两档都判未判、受理。
  *
- * 错误句:死别名与超预算两形只回显**目录里的**别名与正名 / 位置(闭集字符串与数字),不回显调用方的原字节(S-716 姿势);编不过一形**点名那只 matcher 的原文**(截断到 {@link MATCHER_ECHO_CHARS} 字符)与引擎的编译错误句 ——
+ * 错误句:死别名与超预算两形只回显**目录里的**别名与正名 / 位置(闭集字符串与数字),不回显调用方的原字节([ref] 姿势);编不过一形**点名那只 matcher 的原文**(截断到 {@link MATCHER_ECHO_CHARS} 字符)与引擎的编译错误句 ——
  * 调用方要改的就是这一串,且它本来就是调用方自己送来的;机读位 `detail` 仍不带这两段。
  *
- * 🔴 **判决是数据,句子与体的机读位同出一只铸点**(S-1025;client-core 请托,additive):{@link hooksMatcherIssue} 回 {@link HooksMatcherIssue}(闭集四形:{@link DeadToolMatcherIssue} 的 event / alias / canonical,
+ * 🔴 **判决是数据,句子与体的机读位同出一只铸点**([ref];client-core 请托,additive):{@link hooksMatcherIssue} 回 {@link HooksMatcherIssue}(闭集四形:{@link DeadToolMatcherIssue} 的 event / alias / canonical,
  * {@link OverBudgetMatcherIssue} 的 event / groupIndex / budgetMs,{@link BudgetExceededMatcherIssue} 的 event / groupIndex / totalMs,{@link InvalidRegexMatcherIssue} 的 event / groupIndex〔+ 句子用的 matcher / compileError〕,以 `reason` 区分)而不是句子;{@link buildHooksRefusal} 是**唯一**把它铸成拒句 + `field` + `detail` 的函数(配置读者的拒同经它),
  * 受理门只取它的返回、**不解析句子**。体上多出的两键让三端不必解析英文就能把这只拒与普通提交失败分流、提示用户改 matcher;死别名那一句逐字同 7.114.0、零新码。
  */
 /** 超此长度的 matcher 不在受理面读(两档同一个上限;未判,reason = oversize)。与 {@link MAX_HOOK_COMMAND_CHARS} 同量纲的服务侧防线:真实 matcher(精确名 / 交替 / `mcp__.*`)远在其内;目录全部工具名交替 ~0.5 KiB。 */
 export declare const MAX_MATCHER_EVAL_CHARS = 8192;
 /**
- * 正则形 matcher 的**求值预算表**(毫秒)—— 两个数同出这一张表,判据与测试注入都不另持第二份(名字里的 `ADMISSION` 是历史:`budgetMs` 自 S-1017 起**受理面与运行期共用**,`totalMs` 只属受理面):
- *  · `budgetMs` = **每一次**正则形求值各一份的固定墙钟额度(S-1455;vm `timeout`)。**不共享、额度不随受理里别的 matcher 缩水、这一份不读钟**;字面形不占它。
- *    **运行期读同一个数**(S-1017;{@link hookMatcherMatches} 每次现读本对象):运行期每次工具调用对正则形 matcher 的每次求值也各拿这一份,超了 ⇒ 该组按选中处理并登记,不另设运行期额度。
- *    良性求值 ~0.1 ms;灾难回溯(指数级)吃满它也跑不完 ⇒ 这只 matcher 被 400 拒(`over_budget`)。取值是「良性求值之上数个数量级」的余量 —— 小了,忙机上的调度停顿会把良性 matcher 读成灾难(受理结局随负载翻转,正是 S-1455 要根除的形)。
- *  · `totalMs` = **一次受理**里所有已完成的正则形求值的**耗时之和**的总额度(S-1503):之和一旦超过它 ⇒ `400`,`detail.reason = budget_exceeded`。每次求值的额度只界住「一只 matcher 不会无限算」,
+ * 正则形 matcher 的**求值预算表**(毫秒)—— 两个数同出这一张表,判据与测试注入都不另持第二份(名字里的 `ADMISSION` 是历史:`budgetMs` 自 [ref] 起**受理面与运行期共用**,`totalMs` 只属受理面):
+ *  · `budgetMs` = **每一次**正则形求值各一份的固定墙钟额度([ref];vm `timeout`)。**不共享、额度不随受理里别的 matcher 缩水、这一份不读钟**;字面形不占它。
+ *    **运行期读同一个数**([ref];{@link hookMatcherMatches} 每次现读本对象):运行期每次工具调用对正则形 matcher 的每次求值也各拿这一份,超了 ⇒ 该组按选中处理并登记,不另设运行期额度。
+ *    良性求值 ~0.1 ms;灾难回溯(指数级)吃满它也跑不完 ⇒ 这只 matcher 被 400 拒(`over_budget`)。取值是「良性求值之上数个数量级」的余量 —— 小了,忙机上的调度停顿会把良性 matcher 读成灾难(受理结局随负载翻转,正是 [ref] 要根除的形)。
+ *  · `totalMs` = **一次受理**里所有已完成的正则形求值的**耗时之和**的总额度([ref]):之和一旦超过它 ⇒ `400`,`detail.reason = budget_exceeded`。每次求值的额度只界住「一只 matcher 不会无限算」,
  *    界不住「刚好低于它的病态 matcher × 别名数 × 2 × 组数」—— 今天 3 事件 × 16 组 × 1 别名 × 2 = 96 次,每次 0.99 s 可占住事件循环 96 s(单用户车道上持 token 的调用方)。
  *    总额度读一只单调钟、**只累加已完成求值的耗时**(`performance.now`),求值本身不被它缩短(每次求值的额度仍是固定的 `budgetMs`),所以一次受理最坏占用 ≤ `totalMs` + `budgetMs`。
  *    取值同一条余量律:一份最大的良性配置(3 工具事件 × 16 组)的总耗时实测约 9 ms,离 `totalMs` 近三个数量级 —— 良性设置的结局不随机器忙闲翻转;只有求值总耗时逼近 `totalMs` 的病态设置才可能。
@@ -226,7 +227,7 @@ export declare const ADMISSION_MATCHER_BUDGET: {
     readonly budgetMs: 1000;
     readonly totalMs: 5000;
 };
-/** 拒句里回显的 matcher 原文 / 引擎编译错误句、运行期 `hook_matcher_invalid` 日志行的 `matcher` 字段,各自的字符上限(都过回显的一只口径 `echoCallerText`,截断记号 `…`;S-1455 收尾 / S-1735)。真实 matcher 远在其内;上限只防一只 8 KiB 的坏 matcher 把拒句撑成一屏。 */
+/** 拒句里回显的 matcher 原文 / 引擎编译错误句、运行期 `hook_matcher_invalid` 日志行的 `matcher` 字段,各自的字符上限(都过回显的一只口径 `echoCallerText`,截断记号 `…`;[ref] 收尾 / [ref])。真实 matcher 远在其内;上限只防一只 8 KiB 的坏 matcher 把拒句撑成一屏。 */
 export declare const MATCHER_ECHO_CHARS = 200;
 /** 运行期 `hook_entries_skipped` 日志行的 `if` 字段(配置写的权限规则表达式)的字符上限;与 matcher 同口径(`echoCallerText`),截断记号 `…`。 */
 export declare const IF_ECHO_CHARS = 200;
@@ -255,14 +256,14 @@ export interface DeadToolMatcherIssue {
     readonly alias: string;
     readonly canonical: string;
 }
-/** 一条受理面判决(纯数据)· 求值超预算(S-1455):`event` 事件下第 `groupIndex` 组(从 0 起)的 matcher 单次求值没在 `budgetMs` 内结束(灾难回溯)。三键都是闭集 / 数字,不含调用方原字节。 */
+/** 一条受理面判决(纯数据)· 求值超预算([ref]):`event` 事件下第 `groupIndex` 组(从 0 起)的 matcher 单次求值没在 `budgetMs` 内结束(灾难回溯)。三键都是闭集 / 数字,不含调用方原字节。 */
 export interface OverBudgetMatcherIssue {
     readonly reason: "over_budget";
     readonly event: HookEventName;
     readonly groupIndex: number;
     readonly budgetMs: number;
 }
-/** 一条受理面判决(纯数据)· 受理总额度用尽(S-1503):`event` 事件下第 `groupIndex` 组(从 0 起)的 matcher 求完之后,本次受理里所有已完成正则形求值的耗时之和超过了 `totalMs`。三键都是闭集 / 数字,不含调用方原字节。 */
+/** 一条受理面判决(纯数据)· 受理总额度用尽([ref]):`event` 事件下第 `groupIndex` 组(从 0 起)的 matcher 求完之后,本次受理里所有已完成正则形求值的耗时之和超过了 `totalMs`。三键都是闭集 / 数字,不含调用方原字节。 */
 export interface BudgetExceededMatcherIssue {
     readonly reason: "budget_exceeded";
     readonly event: HookEventName;
@@ -270,7 +271,7 @@ export interface BudgetExceededMatcherIssue {
     readonly totalMs: number;
 }
 /**
- * 一条受理面判决(纯数据)· 正则编不过(S-1455 收尾):`event` 事件下第 `groupIndex` 组(从 0 起)的 matcher 在契约包的读法下答 `invalid`。
+ * 一条受理面判决(纯数据)· 正则编不过([ref] 收尾):`event` 事件下第 `groupIndex` 组(从 0 起)的 matcher 在契约包的读法下答 `invalid`。
  * `matcher` = 那只 matcher 的原文、`compileError` = 引擎的编译错误句(各自截到 {@link MATCHER_ECHO_CHARS} 字符):**只供铸拒句用**,机读位 `detail` 不带它们。
  */
 export interface InvalidRegexMatcherIssue {
@@ -393,18 +394,41 @@ export interface HooksRefusal {
 }
 /**
  * 判决 → 拒句 + 机读位 —— `settings.hooks` 这一面**拒句与机读位的唯一铸点**(配置读者的拒与 fresh 提交面的 matcher 拒同经这里;受理门 `admission.ts` 用返回值填 400 体,
- * 不从句子里反解字段)。句子:死别名逐字 = 7.114.0 的那一句(`test/hooks-alias-matcher-s995.test.ts` R7 冻结);超预算点名**哪一只**(事件 + 组下标 + `matcher`)与**预算**,不回显 matcher 原字节(S-716 姿势);
+ * 不从句子里反解字段)。句子:死别名逐字 = 7.114.0 的那一句(`test/hooks-alias-matcher-s995.test.ts` R7 冻结);超预算点名**哪一只**(事件 + 组下标 + `matcher`)与**预算**,不回显 matcher 原字节([ref] 姿势);
  * 分类器的一块 = 坐标 + 码 + 释义(+ 坏键);服务侧上限的几句逐字 = 7.131.0。`reason` 闭集穷举(多一形 = 这里编译红)。
  */
 export declare function buildHooksRefusal(issue: HooksIssue): HooksRefusal;
 /**
- * fresh 提交面专用判据(S-924 / S-995 / S-1455 / S-1472 / S-1503):配置里第一条「该拒」的 matcher 的判决数据({@link HooksMatcherIssue}):「永远打不中」(死别名,只属工具事件)· 「编不过」(任何事件)· 「单次求值超预算」(灾难回溯)· 「受理总额度用尽」;没有 ⇒ undefined。
- * 拒句与 400 体的机读位由 {@link buildHooksRefusal} 从这份数据铸(S-1025)。**按配置顺序(事件 → 组)遇到的第一条定结局**;良性设置的结局只取决于配置(每次求值的额度固定、不共享;总额度离良性设置近三个数量级,见头注「预算与结局」)。
+ * fresh 提交面专用判据([ref] / [ref] / [ref] / [ref] / [ref]):配置里第一条「该拒」的 matcher 的判决数据({@link HooksMatcherIssue}):「永远打不中」(死别名,只属工具事件)· 「编不过」(任何事件)· 「单次求值超预算」(灾难回溯)· 「受理总额度用尽」;没有 ⇒ undefined。
+ * 拒句与 400 体的机读位由 {@link buildHooksRefusal} 从这份数据铸([ref])。**按配置顺序(事件 → 组)遇到的第一条定结局**;良性设置的结局只取决于配置(每次求值的额度固定、不共享;总额度离良性设置近三个数量级,见头注「预算与结局」)。
  * 入参是 {@link parseHooksConfig} 已校验过的配置;`depth` 由调用点按车道定(见头注:`taskHooksHonored(config) ? "regex" : "literal"`)。
  * `budget` **仅供测试注入**({@link MatcherEvalBudget});生产调用点只传前两个实参。
  * **只有 `admission.ts` 的 fresh 提交门调它** —— resume 重放不调(理由见上面的头注)。未判的 matcher 过 `recordFailOpen`(tag `MATCHER_UNJUDGED_TAG`);超预算的不是未判,是拒。
  */
 export declare function hooksMatcherIssue(config: RunnableHooksConfig, depth: MatcherEvalDepth, budget?: MatcherEvalBudget): HooksMatcherIssue | undefined;
+/** fresh 提交面 http 钩子 `url` 带凭据的判决(数据):是哪一条(事件 + 组下标 + 条目下标,与 matcher 判决同一种坐标)+ 判官的答案。 */
+export interface HooksUrlCredentialIssue {
+    readonly event: HookEventName;
+    readonly groupIndex: number;
+    readonly entryIndex: number;
+    readonly credential: UrlCredential;
+}
+/**
+ * fresh 提交面专用判据([ref]):配置里第一条「url 带凭据」的 http 钩子 —— userinfo,或名字在日志脱敏器凭据名表里的 query / fragment 参数(判官契约包根的 `findUrlCredential` 一只,
+ * MCP `transport.url` · A2A 对端 · 搜索后端 `endpoint` · 包源六址同读);没有 ⇒ undefined。这一座有为凭据设的位(条目的 `headers`,停驻任务的续跑上下文里只以封签存在),
+ * url 却照原样进停驻上下文、日志与读面 —— 凭据只许走前者(`$NAME` 引用 + `allowedEnvVars` 让配置本身不携带密钥值,见 USAGE 9.5c)。
+ * 入参是 {@link parseHooksConfig} 已校验过的配置:**按配置序**(事件 → 组 → 条目)遇到的第一条定结局;只看 `type:"http"` 条目(别的条目型没有 `url`)。
+ *
+ * **只有 `admission.ts` 的 fresh 提交门调它** —— 重放存量 body 的腿(`parseTaskSettings`)不调:拒会让升级前停驻的任务里整只 hooks 不被采纳(守卫钩子随之消失 = fail-open),
+ * 已落盘的字节也不因拒而消失。拒句与机读位由 {@link buildHooksUrlCredentialRefusal} 铸。
+ */
+export declare function hooksUrlCredentialIssue(config: RunnableHooksConfig): HooksUrlCredentialIssue | undefined;
+/**
+ * {@link hooksUrlCredentialIssue} 的判决 → 拒句 + 机读位。`field` 是这一条 `url` 在请求体里的全坐标(`settings.hooks.<事件>[g].hooks[h].url`,与封签位、本族别的 `field` 同一种写法),
+ * 出路指到同一条的 `headers`。机读位的形与 MCP / A2A / 搜索后端三座同一只铸点(`url-credential-refusal.ts`),所以**不**走上面 {@link buildHooksRefusal} 的 `field:"settings.hooks"` + `detail` 形 ——
+ * 那一形按 `detail.reason` 分形、属于配置读者与 matcher 判据;「URL 带凭据」是跨座位的一个事实,消费端按 `reason` 穷举读一次。
+ */
+export declare function buildHooksUrlCredentialRefusal(issue: HooksUrlCredentialIssue): UrlCredentialRefusal;
 /**
  * 坐标的出门段:事件名等键段是用户文本 ⇒ 先过 {@link outgoingPath}(凭据形不原样回显),每个串段再过调用方串的唯一回显口径(`caller-text-echo.ts`:剥控制 / 双向字符、截到 64 字 + …)——
  * 一只 100 KB 的未知键不把拒体撑大、也不在句子里夹看不见的字符。400 体的 `detail.path` 与拒句里的坐标读的都是它。
@@ -421,7 +445,10 @@ export declare function hooksCoordinate(path: ConfigPath): string;
  *  · **本仓不执行的条目类型整份拒**:分类器受理契约的全部五型,而本仓只跑 {@link SUPPORTED_HOOK_ENTRY_TYPES}。含其余类型的配置整份拒,不留跳过臂。
  *  · **本仓的 wire 键**(分类器不认、会剥掉的三只):组上的 `source`(来源闭集,`hook-source.ts`)、command 条目上的 `plugin` / `args`(执行上下文,`command-spawn.ts`)——
  *    在分类器装上的**同一坐标**上读原值(分类器只在 `loaded` 时放行,装上的件与原值逐位对齐),形错 ⇒ {@link HooksWireKeyIssue}。
- *    `plugin` / `args` 只在 command 条目上有义:别的条目上它们与任何未知键一样被分类器剥掉(CC 同形)。值为 `undefined` 与缺席同读(与分类器读可选字段同一口径)。
+ *    `plugin` / `args` 只在 command 条目上有义。值为 `undefined` 与缺席同读(与分类器读可选字段同一口径)。
+ *  · **读者不携带的键**(分类器不认的字段、非 command 条目上的 `plugin` / `args`、组上的拼错键):本读者的可跑形里没有它们(读法照分类器)。
+ *    「写了却被剥掉」在 FRESH 提交面由键闭集门的第三个实例拒(`task-settings.ts` 的 `hooksKeyIssue`,词表 = 本函数交回的可跑形,400 `request.body_shape`);
+ *    续跑重放腿不过那道门,存量体按受理时的读法重放(剥掉,不砖停驻任务)。
  *  · **服务侧上限**(广度闸;契约本身不设量纲)。exec 形的命令行(`command` + 各 `args`)计入 `command` 帽;插件上下文一道总字符帽。
  *
  * 拒返回判决(`issue`)与它的句子(`error`)而不 throw —— submit 路径 400 fail-loud(体带 `field: "settings.hooks"` + `detail`)、resume 防御路径 warn-drop(hooks 整只不采纳),由调用方选;
@@ -433,7 +460,7 @@ export declare function parseHooksConfig(raw: unknown): ParseHooksConfigResult;
  * 三形(名字表 / 空 `*` 缺省 / 不锚定的 JS 正则)与「编不过 ⇒ `"invalid"`」都由它答;**对所有带 matcher 的事件同一只读法**(工具事件 / StopFailure 的 `error` 词 /
  * PreCompact·PostCompact 的 `trigger` 词 / `if` 条件的名部),不按事件分档。
  *
- * 🔴 **预算(S-1017)**:求法与受理面 `"regex"` 档同一格表({@link MATCHER_EVALUATION}):字面形(名字表 / 空 / `*` / 缺省)直接问契约函数,不进 vm、不占额度;
+ * 🔴 **预算([ref])**:求法与受理面 `"regex"` 档同一格表({@link MATCHER_EVALUATION}):字面形(名字表 / 空 / `*` / 缺省)直接问契约函数,不进 vm、不占额度;
  * 正则形**每一次求值**进 vm、各拿一份固定的 {@link ADMISSION_MATCHER_BUDGET}`.budgetMs`(不共享、不读钟、不新造第二只预算常量)。受理面只对 core 目录里的别名 / 正名这几个短名字求过值,
  * 运行期要对**任意别的工具名**求值 —— 受理过了的 matcher 在某个名字上灾难回溯,不能再同步占住事件循环。
  * 四个答案(闭集,{@link MatcherAnswer}),调用方各用一条穷举 switch 处置({@link matcherGroupSelected} / {@link hookIfMatches}):
@@ -448,7 +475,7 @@ export declare function hookMatcherMatches(matcher: string | undefined, value: s
  *  求值:名部走 permission matcher(交替/正则同 matcher 字段),括号内 arg-模式(`*` 通配)匹配工具输入的
  *  主字符串(Bash=command,文件工具=file_path/path)。CC 行为逐条目:不匹配 → 跳过该条目(记日志);
  *  非工具事件(payload 无 tool_name)→ "cannot be evaluated" 跳过;解析失败 → 跳过。返回:
- *  true=跑 / "not_matched" / "unevaluable"(调用方分别记账;跳过永不静默)/ "over_budget"(S-1017:名部求值没在预算内结束 ⇒ 调用方按**选中**处理 + 登记,见 {@link hookMatcherMatches})。
+ *  true=跑 / "not_matched" / "unevaluable"(调用方分别记账;跳过永不静默)/ "over_budget"([ref]:名部求值没在预算内结束 ⇒ 调用方按**选中**处理 + 登记,见 {@link hookMatcherMatches})。
  *
  *  2.1.250 复核([ref],2026-08-30;语料=sema-internal `blueprints/cc-decoded/cli250.js`):求值器与 220
  *  逐字同构——五种工具事件之外「cannot be evaluated for non-tool event」跳过、「Skipping hook due to if
@@ -517,7 +544,7 @@ export type HookLlmCall = (opts: {
 /** 失败判别码(B8:判别一律走码,禁按 error 文案分支——v3.1 批2,统检第二波 high)。error 仍是给人看的
  *  自由文本;code 是给控制流的。缺席=未分类失败(不重试、不特判)。
  *
- *  🔴 **一类真因一个码**(S-1635;闭集 —— 消费方的 `switch` 无兜底分支,加一个码而不表态 = 编译错误):码是**成因族**的名字,铸点是直连载体
+ *  🔴 **一类真因一个码**([ref];闭集 —— 消费方的 `switch` 无兜底分支,加一个码而不表态 = 编译错误):码是**成因族**的名字,铸点是直连载体
  *  (`hook-llm.ts` 的 `callLlm` / `hookModelFor`)的每一个失败臂,消费方(会话标题器的 fail-open 标签表)据此区分「该改哪里」,不读 `error` 文案:
  *   · `model_unresolved`:这只模型在本部署上选不出来 —— 目录里没有 / 条目不可用 / 网关腿解析不出端点(改目录或网关配置)
  *   · `route_refused`:路由核验拒发 —— key↔URL 不配对,或 foreign 端点无 per-model key(改路由 / 凭据配置;零请求)

package/dist/hooks/hook-runner.js

@@ -3,7 +3,7 @@ import { composeHostSubprocessEnv, hostSubprocessEnv } from "../server-secret-en
 import vm from "node:vm";
 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 { findUrlCredential, 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";
@@ -11,11 +11,13 @@ import { MAX_HOOK_NOTICE_TEXT_CHARS, boundedNoticeText } from "../fleet/fleet-bu
 import { recordFailOpen } from "../observability/fail-open.js";
 import { LIMIT_REASONS } from "../limit-refusal.js";
 import { clipDataText, echoCallerText } from "../caller-text-echo.js";
+import { seatText } from "../trace/exit-seat.js";
 import { redactSecrets, buildDisplaySafeUrl } from "../trace/redact.js";
 import { canonicalJsonStringify } from "@sema-agent/core";
 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 { buildRequestUrlCredentialRefusal, urlCredentialHeaderExit } from "../url-credential-refusal.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;
@@ -102,9 +104,7 @@ 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 BLANKED_HEADER_ECHO_CHARS = 200;
 const MATCHER_UNJUDGED_TAG = "server.hooks.matcher-unjudged";
 function matcherReadsWireToolName(event) {
     return HOOK_EVENT_OWNER[event] === "engine" && HOOK_EVENT_MATCHER_FIELD[event] === "tool_name";
@@ -331,6 +331,24 @@ export function hooksMatcherIssue(config, depth, budget = {}) {
     }
     return undefined;
 }
+export function hooksUrlCredentialIssue(config) {
+    for (const [event, groups] of Object.entries(config)) {
+        for (const [groupIndex, group] of (groups ?? []).entries()) {
+            for (const [entryIndex, entry] of group.hooks.entries()) {
+                if (entry.type !== "http")
+                    continue;
+                const credential = findUrlCredential(entry.url);
+                if (credential !== undefined)
+                    return { event, groupIndex, entryIndex, credential };
+            }
+        }
+    }
+    return undefined;
+}
+export function buildHooksUrlCredentialRefusal(issue) {
+    const entry = `settings.hooks.${issue.event}[${issue.groupIndex}].hooks[${issue.entryIndex}]`;
+    return buildRequestUrlCredentialRefusal(`${entry}.url`, issue.credential, urlCredentialHeaderExit(`${entry}.headers`));
+}
 const HOOKS_PIECE_MEANING = {
     "hooks-not-object": "`hooks` must be an object keyed by hook event name",
     "unknown-event": "not a hook event name",
@@ -504,10 +522,10 @@ const MAX_LLM_ENTRIES_PER_EVENT = 4;
 const DEFAULT_PROMPT_HOOK_TIMEOUT_SECONDS = 30;
 const DEFAULT_AGENT_HOOK_TIMEOUT_SECONDS = 120;
 function logHookCommandFailed(ctx, event, run) {
-    ctx.logger.warn("hook_command_failed", { event, code: run.code, stderr: echoCallerText(run.stderr, { maxChars: LOG_ERROR_ECHO_CHARS }) });
+    ctx.logger.warn("hook_command_failed", { event, code: run.code, stderr: seatText("operator-log-error", run.stderr) });
 }
 function logHookSystemMessage(ctx, event, message) {
-    ctx.logger.info("hook_system_message", { event, message: echoCallerText(message, { maxChars: LOG_MESSAGE_ECHO_CHARS }) });
+    ctx.logger.info("hook_system_message", { event, message: seatText("operator-log-message", message) });
 }
 function hookDisplayName(entry) {
     if (typeof entry.statusMessage === "string" && entry.statusMessage.length > 0)
@@ -536,7 +554,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: echoCallerText(String(e), { maxChars: LOG_PREVIEW_ECHO_CHARS }) });
+        ctx.logger.warn("hook_notice_sink_threw", { kind: n.kind, event: n.event, error: seatText("operator-log-text", String(e)) });
     }
 }
 function noteHookFailure(ctx, args) {
@@ -557,7 +575,7 @@ function noteHookFailure(ctx, args) {
 }
 function noteMatcherOverBudget(ctx, args) {
     const budgetMs = ADMISSION_MATCHER_BUDGET.budgetMs;
-    const shown = (text) => echoCallerText(boundedNoticeText(text), { maxChars: MATCHER_ECHO_CHARS });
+    const shown = (text) => seatText("operator-log-text", text);
     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 });
@@ -879,7 +897,7 @@ async function fireAsyncCommandHook(entry, payload, ctx, event, halt) {
         }
         child.on("error", (e) => {
             clearTimeout(timer);
-            ctx.logger.warn("hook_async_failed", { event, reason: "spawn_failed", error: echoCallerText(String(e), { maxChars: LOG_ERROR_ECHO_CHARS }) });
+            ctx.logger.warn("hook_async_failed", { event, reason: "spawn_failed", error: seatText("operator-log-error", String(e)) });
             noteHookFailure(ctx, { event, entry, reason: "spawn_failed", stderr: String(e), toolName: toolNameOf(payload) });
         });
         child.on("close", (code) => {
@@ -902,14 +920,14 @@ async function fireAsyncCommandHook(entry, payload, ctx, event, halt) {
                     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: echoCallerText(String(e), { maxChars: LOG_PREVIEW_ECHO_CHARS }) }));
+            }, (e) => ctx.logger.warn("hook_async_rewake_dropped", { event, reason: "wake_failed", error: seatText("operator-log-text", String(e)) }));
         });
         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: echoCallerText(String(e), { maxChars: LOG_ERROR_ECHO_CHARS }) });
+        ctx.logger.warn("hook_async_failed", { event, reason: "spawn_failed", error: seatText("operator-log-error", String(e)) });
         noteHookFailure(ctx, { event, entry, reason: "spawn_failed", stderr: String(e), toolName: toolNameOf(payload) });
     }
 }
@@ -996,7 +1014,7 @@ async function runHttpHook(entry, payload, ctx, event) {
             blankedCount: interpolated.blanked.length,
             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 })),
+                .map(({ header, name, reason }) => ({ header: echoCallerText(header, { maxChars: BLANKED_HEADER_ECHO_CHARS }), name: echoCallerText(name, { maxChars: BLANKED_HEADER_ECHO_CHARS }), reason })),
         });
     }
     const headers = { "content-type": "application/json", ...interpolated.headers };
@@ -1034,7 +1052,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: echoCallerText(trimmed, { maxChars: LOG_PREVIEW_ECHO_CHARS }) });
+                ctx.logger.warn("hook_http_non_json_response", { url: buildDisplaySafeUrl(entry.url), preview: seatText("operator-log-text", trimmed) });
                 noteHookFailure(ctx, {
                     event: eventOfPayload(payload),
                     entry,
@@ -1086,7 +1104,7 @@ function readHookStdout(ran, event, ctx, payload, ledger) {
         return out;
     const t = run.stdout.trim();
     if (t.startsWith("{") || t.startsWith("[")) {
-        ctx.logger.warn("hook_bad_json_output", { event, type: entry.type, preview: echoCallerText(t, { maxChars: LOG_PREVIEW_ECHO_CHARS }) });
+        ctx.logger.warn("hook_bad_json_output", { event, type: entry.type, preview: seatText("operator-log-text", t) });
         noteHookFailure(ctx, { event, entry, reason: "bad_json", exitCode: run.code, stderr: run.stderr, toolName: toolNameOf(payload) });
         ledger.unrun(ran.source, entry, "bad_json");
     }
@@ -1193,7 +1211,7 @@ async function runMatchingEntries(event, groups, matchValue, payload, ctx, onceF
             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 }) });
+            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: seatText("operator-log-error", run.spawnError) });
             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" };
@@ -1411,7 +1429,7 @@ export function createSettingsHooksRegistration(config, ctx, budgetMs) {
                                 unknownDecision = true;
                                 ctx.logger.warn("hook_permission_decision_unknown", {
                                     event: "PreToolUse",
-                                    decision: echoCallerText(typeof decision === "string" ? decision : typeof decision, { maxChars: LOG_PREVIEW_ECHO_CHARS }),
+                                    decision: seatText("operator-log-text", typeof decision === "string" ? decision : typeof decision),
                                     tool: toolName,
                                     effect: "hook ruling not honored (closed word set is allow|deny|ask); this call falls back to the engine gate",
                                 });
@@ -1675,7 +1693,7 @@ export function createSettingsHooksRegistration(config, ctx, budgetMs) {
                         branch = await sctx.getBranch?.();
                     }
                     catch (e) {
-                        ctx.logger.warn("hook_stop_branch_failed", { error: echoCallerText(e instanceof Error ? e.message : String(e), { maxChars: LOG_ERROR_ECHO_CHARS }) });
+                        ctx.logger.warn("hook_stop_branch_failed", { error: seatText("operator-log-error", e instanceof Error ? e.message : String(e)) });
                     }
                     const rendered = renderBranchTranscript(branch);
                     if (rendered.sufficient) {
@@ -1718,7 +1736,7 @@ export function createSettingsHooksRegistration(config, ctx, budgetMs) {
                     if (v.ok)
                         continue;
                     if (v.impossible) {
-                        ctx.logger.warn("hook_stop_condition_impossible", { event: "Stop", reason: echoCallerText(v.reason?.trim() ?? "", { maxChars: LOG_MESSAGE_ECHO_CHARS }) });
+                        ctx.logger.warn("hook_stop_condition_impossible", { event: "Stop", reason: seatText("operator-log-message", v.reason?.trim() ?? "") });
                         continue;
                     }
                     if (block === undefined)
@@ -1728,7 +1746,7 @@ export function createSettingsHooksRegistration(config, ctx, budgetMs) {
                 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: echoCallerText(run.stdout.trim(), { maxChars: LOG_PREVIEW_ECHO_CHARS }) });
+                        ctx.logger.warn("hook_llm_unparsed_verdict", { event: "Stop", head: seatText("operator-log-text", run.stdout.trim()) });
                         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");
                     }

package/dist/host-decision.d.ts

@@ -44,7 +44,7 @@ import { type AskOutcome, type HostDecider, type PermissionResult, type ResumeOu
  * 这个事实铸(`human_refused` / `approval_window_expired` / `policy_refused`)。core 若改这一格的词表,
  * 读它的每一处编译期先红。
  *
- * 🔴 **S-558:为什么这一格住在本叶子模块**(此前是 `tool-approval.ts` 的模块私有型):来源位随决议
+ * 🔴 **[ref]:为什么这一格住在本叶子模块**(此前是 `tool-approval.ts` 的模块私有型):来源位随决议
  * **落持久行**之后,店(`src/plugins/approval-ask-store-sql.ts` 的 `AskRow.settledBy` /
  * `DecideAskInput.settledBy`)与协调器都要说同一个型 —— 而店不能反向依赖协调器。本模块只依赖
  * `@sema-agent/core`,与同住的 {@link HostDecision}(耐久腿的同位事实)恰好是一对:一条决议的来源
@@ -54,7 +54,7 @@ export type HostSettledBy = NonNullable<Extract<AskOutcome, {
     allow: boolean;
 }>["settledBy"]>;
 /** 直接取 core `ResumeOutcome` policy_ask 臂的 `hostDecision` 型 —— 本仓不复述那几个词(第二铸点)。它的 `decidedBy` 就是 core 的 `HostDecider`
- *  (core 7.45.0 #1387:三个型位读同一只闭集)。**谁结束了这次等待**的闭集只有 core 包根那一只(`HOST_DECIDERS` / `HostDecider` / `isHostDecider`)。 */
+ *  (core 7.45.0 [ref]:三个型位读同一只闭集)。**谁结束了这次等待**的闭集只有 core 包根那一只(`HOST_DECIDERS` / `HostDecider` / `isHostDecider`)。 */
 export type HostDecision = Extract<ResumeOutcome, {
     gate: "policy_ask";
 }>["hostDecision"];
@@ -72,14 +72,14 @@ export type HostDecision = Extract<ResumeOutcome, {
  *  · `plan_review` 不读这只键:引擎的 plan_review 结局形没有决定者位(core 的结局规整会把别的键整只重建掉),收下它就是
  *    一句「已记」的空话。那一门照兄弟门字段那一族拒(`approvals-assistant.ts` 的回决门族派生),候 core 给座。
  *
- * 词表的来源:core 包根的 `HOST_DECIDERS` / `HostDecider` / `isHostDecider`(core 7.45.0 #1387;此前包根只有型,本仓手写一只闭集常量 + 两道
+ * 词表的来源:core 包根的 `HOST_DECIDERS` / `HostDecider` / `isHostDecider`(core 7.45.0 [ref];此前包根只有型,本仓手写一只闭集常量 + 两道
  * 编译门双向咬它 —— 那份手抄随本版退役)。wire 闭集 = 那只词表去掉扫的那一个词,运行期值与型都从它派生,没有第二份词表。
  */
 /** 只有本服务自己的截止扫说得出的那一个词 —— core 词表里唯一不上 wire 的成员(`satisfies`:core 改名 / 退役它 ⇒ 这里编译红)。 */
 declare const SWEEP_ONLY_DECIDER = "sla_timeout";
 /** wire 上的出处词(决定体 `decidedBy` 的值域)= core 闭集去掉扫的那一个。 */
 export type ApprovalDecidedBy = Exclude<HostDecider, typeof SWEEP_ONLY_DECIDER>;
-/** wire 闭集的运行期值:core `HOST_DECIDERS`(#1387)去掉扫的那一个,顺序随 core。core 加一个词 ⇒ 它在这里自动在场(决定口的门照收;两只座的映射
+/** wire 闭集的运行期值:core `HOST_DECIDERS`([ref])去掉扫的那一个,顺序随 core。core 加一个词 ⇒ 它在这里自动在场(决定口的门照收;两只座的映射
  *  {@link liveSettledBy} 的穷举 `switch` 编译红,由人裁它在同步座上怎么落)。 */
 export declare const APPROVAL_DECIDED_BY: readonly ApprovalDecidedBy[];
 /** 闭集外的拒句(三条决定口同一句;码按各口既有约定,见 {@link readDecidedBy})。成员表派生自 {@link APPROVAL_DECIDED_BY}(词表一个来源;今天字节与 7.118.0 同)。 */
@@ -141,7 +141,7 @@ export declare function readDecidedBy(raw: unknown, directDoorActive: boolean):
  */
 export declare function liveSettledBy(decidedBy: ApprovalDecidedBy): Extract<HostSettledBy, "policy"> | undefined;
 /**
- * 引擎自己的那一条例外:**一张要人的卡不归策略答** —— 判官是 core 的 `policyCannotAnswer(question, decidedBy)`(#1395 包根导出;引擎的续跑入口、
+ * 引擎自己的那一条例外:**一张要人的卡不归策略答** —— 判官是 core 的 `policyCannotAnswer(question, decidedBy)`([ref] 包根导出;引擎的续跑入口、
  * 执行带与同步座读同一条)。本仓**只在自己的副作用先于引擎落地的两条口**上于裁决之前问它(live `/respond`:会话放行 / 常驻规则 / 一条按 approve
  * 回放的 DECIDED 行;耐久 ask 账:一条宣称 approve 的 DECIDED 行),并且只问**放行**那一向(与引擎续跑入口同:拒永远答得了)。耐久 `/decide` 不判:
  * 引擎在 CAS 之前就拒(`checkpoint.invalid_outcome`,卡留 pending),本口的副作用全在引擎受理之后 —— 在那里再问一次就是第二个判官。

package/dist/host-lsp-manager.d.ts

@@ -1,7 +1,7 @@
 /**
- * S-616(core 7.30.1 #1073 提货)—— **宿主车道本地语言服务器**的唯一构造点。
+ * [ref](core 7.30.1 [ref] 提货)—— **宿主车道本地语言服务器**的唯一构造点。
  *
- * ## 病(DEBTS S-684 同轴的第二条,7.99.0 修复验证 opus 腿普查带出)
+ * ## 病(DEBTS [ref] 同轴的第二条,7.99.0 修复验证 opus 腿普查带出)
  * core 的 `NodeLspManager` 默认 spawn(`defaultLspSpawn`)在 7.30.1 之前**不带 env** ⇒ 语言服务器整份继承本进程的
  * `process.env`,脑钥 / 仓库令牌 / 本仓自己的凭据键全在里面,而语言服务器会执行仓里的代码(构建脚本、插件、
  * 工作区配置)。7.30.1 起 core 默认改成 `scrubSecretEnv(process.env)`(按键名**形状**剥),并开了
@@ -9,10 +9,10 @@
  * 本仓唯一组合 `hostSubprocessEnv` 的结果 —— 引擎 `inheritedHostEnv("scrub")` ∪ 点名放回)。
  *
  * ## 规则(一句)
- * 语言服务器子进程的 env = 引擎 `inheritedHostEnv("scrub")`(形状剥 ∪ 本进程起服声明的自有凭据名)∪ 部署方点名放回的键(S-699,见下节;缺省空名单)——
+ * 语言服务器子进程的 env = 引擎 `inheritedHostEnv("scrub")`(形状剥 ∪ 本进程起服声明的自有凭据名)∪ 部署方点名放回的键([ref],见下节;缺省空名单)——
  * 剥除与模型可驱动的 host shell(`inheritEnv:"scrub"`)
  * 和 project-memory 的 git 子进程**同一只函数**:目录 `type:"secret"` 键按名剥 ∘ core 形状规则按形剥。只交 core 的默认
- * 会漏掉形状规则认不出的本仓凭据键(当时是 `OTEL_EXPORTER_OTLP_HEADERS`,core 7.33.7 #1180 起 core 按名剥它;今天只剩名单型旋钮三只),那正是 S-684 当初的病形。
+ * 会漏掉形状规则认不出的本仓凭据键(当时是 `OTEL_EXPORTER_OTLP_HEADERS`,core 7.33.7 [ref] 起 core 按名剥它;今天只剩名单型旋钮三只),那正是 [ref] 当初的病形。
  * 剥掉了什么经既有观测面留痕(site = `server.lsp.spawn-env`,每 site×key 一次披露 + 逐次计数)—— core 那侧
  * 刻意不报(无收集器,KL),本仓这一格补上。
  *
@@ -20,7 +20,7 @@
  * env 在**构造时**取一次快照(boot / run-local 起腿时),而不是 core 默认那样每次 spawn 现取:`NodeLspManagerOptions.env`
  * 是一份静态记录。本仓的 `process.env` 是 boot 期输入(热配置走 web-admin,不改 `process.env`),两者在本仓部署上同值。
  *
- * ## 点名放行(S-699,`LSP_ENV_ALLOW`)
+ * ## 点名放行([ref],`LSP_ENV_ALLOW`)
  * 剥除会连语言服务器自己的真实依赖一起剥掉(`.npmrc` 的 `${NPM_TOKEN}` 插值、rust-analyzer `cargo metadata` 私有 registry 的
  * `CARGO_REGISTRIES_<名>_TOKEN` —— 形状规则按名判,分不出「给语言服务器用的令牌」与「编排器的令牌」)。出路 = 部署方点名:
  * env = 引擎 `inheritedHostEnv("scrub")` 之上把 `config.lspEnvAllow` 点到的键经 `allowlistedEnv`(与沙箱三腿