@sema-agent/server 7.125.1 → 7.127.0

package/dist/deployment-governance.d.ts

@@ -1,4 +1,4 @@
-import { FileError, StubExecutionEnv, type ExecutionEnv, type Result, type ToolPolicy } from "@sema-agent/core";
+import { FileError, StubExecutionEnv, type ExecutionEnv, type PathFamily, type Result, type ToolPolicy } from "@sema-agent/core";
 import { type DeploymentListExemption } from "./approval.js";
 import type { ServiceConfig } from "./config.js";
 import type { applyRuntimeGovernance } from "./runtime-governance.js";
@@ -15,8 +15,9 @@ export interface DeploymentGovernanceConfigView {
     readonly agentConfigDir?: ServiceConfig["agentConfigDir"];
     /**
      * 本部署的**本地店根**(`LOCAL_DATA_ROOT → CONFIG_LOCAL_DIR → AGENT_DATA_DIR → ~/.ai-agent`)—— 在本口只喂
-     * **誊本门**(`<localDataRoot>/sessions`)。S-133 起它**不再**当守卫集的 `dataRoot`(那是引擎记忆根,见
-     * {@link DeploymentGovernanceRoots});下面这段历史注保留,记的是 S-125 件⑦ 把两根混作一根的由来。
+     * **誊本门**(`<localDataRoot>/sessions`)。S-133 起它**不再**当守卫集的数据根(那是引擎记忆根);core 7.49.0 [ref] 起守卫集
+     * 根本不收数据根 —— 豁免根只从 `RunnerDeps.memoryEngineDir` 一处来(`boot/runner-deps.ts` 共享基座,每只 boot Runner 同一个值)。
+     * 下面这段历史注保留,记的是 S-125 件⑦ 把两根混作一根的由来。
      *
      * S-125 件⑦(core 7.4.0 [ref] HRD-PRM-10)—— 当时把本键原样交给 `createSensitivePathPolicy` 的 `dataRoot`。
      *
@@ -28,21 +29,10 @@ export interface DeploymentGovernanceConfigView {
      * ⇒ 本键 = 「这道门与 transcript 门说的是同一个目录」的单一属主,值与 `ServiceConfig.localDataRoot`
      * **同一个**解析结果(不在本口重算,重算就是第二个写者)。
      *
-     * 缺席(窄接口的老调用方 / 测试夹具)⇒ **不铸 `dataRoot` 键**,core 走它自己的缺省 —— 与本口既有的
-     * `rootPath` 条件展开同姿势:缺席是「本调用方没有这项知识」,不是「数据根是 undefined」。
+     * 缺席(窄接口的老调用方 / 测试夹具)⇒ 不铸誊本门(缺席是「本调用方没有这项知识」,不是「店根是 undefined」)。
      */
     readonly localDataRoot?: ServiceConfig["localDataRoot"];
 }
-/**
- * S-133 —— 守卫集 `dataRoot` 的**显式供给**(与 `DeploymentGovernanceConfigView.localDataRoot` 是两件事):
- * `engineDataRoot` = 引擎写记忆的根 = boot 已铸的 `memoryEngine.root`(boot/stores.ts 是唯一写者;推导函数
- * `memoryEngineRootFor` 只在那里与 `memoryEngineBackendFor` 里调)。**调用腿读那只活对象,不重推导**——重推导
- * 就是第二个写者(7.59.0 重扫 codex 轮抓到 HTTP 腿的 fallback 与 stores 不同源,正是这一形)。参数非可选:
- * 一条腿忘了 = 编译红。`undefined` = 引擎未接(或窄接口的测试夹具),那时不铸 `dataRoot` 键,core 走自己的缺省。
- */
-export interface DeploymentGovernanceRoots {
-    readonly engineDataRoot: string | undefined;
-}
 /** 审批基线读的配置切面(同上,窄接口)。 */
 export interface ApprovalBaselineConfigView {
     readonly approvalRequire: ServiceConfig["approvalRequire"];
@@ -175,18 +165,26 @@ export declare function createDurableQuestionGate(live: LiveQuestionFace | undef
  *  · 词法层(`RelativeTargetLexicalEnv`)判 **缺戳相对形**(自身拼写里的守卫段,fail-closed);
  *  两层射程互补、无重叠、无缝隙;各自射程外**显式 allow**(= 让位给另一层),canon 失败留给真的判不了的形
  *  (UNC/NUL/越根)—— 那正是 7.17.1 要 deny 的。提取写目标用 core 自家 `protectivePathTargetOf` + `pathTargetValue`
- *  (与 core 守卫策略同一只提取器,零复刻);「算不算绝对」用 core `isAbsoluteForFamily(undefined, …)`(沙箱 lane
- *  无 root/cwd 声明 ⇒ 家族 undefined ⇒ 只认 `/`-rooted,与引擎同一律)。
+ *  (与 core 守卫策略同一只提取器,零复刻);「算不算绝对」用 core `isAbsoluteForFamily(SANDBOX_TREE_FAMILY, …)` —— 两层读
+ *  **同一只**谓词(词法层的 `absolutePath` 拒的正是这一形),射程因此按构造互补。
+ */
+/**
+ * 沙箱 lane 的树是 **POSIX** 树(core 7.49.0 [ref] 起 `isAbsoluteForFamily` 的族参数必写:树的族,或无树时的 `"own"`)。
+ * 沙箱的文件系统是远端容器 / 机器的 POSIX 文件系统,词法层也按 POSIX 归一(`posix.normalize`)—— 所以这里写树的族,而不是 `"own"`:
+ * `"own"` 会把 `C:\x` / UNC 拼法读成绝对形送进真身层,而在 POSIX 树上它们是**相对文件名**(写进 cwd 的一个叫 `C:\x` 的文件)。
+ * 7.48.0 的 `undefined` 只认 `/`-rooted,与本常量逐字同判(读数不变)。
  */
+export declare const SANDBOX_TREE_FAMILY: PathFamily;
 type WriteTargetForm = "unstamped-relative" | "absolute-or-stamped";
 /**
  * 只在 `form` 那一类写目标上说话,其余显式 allow(让位);非写调用与提不出目标的调用原样交给 policy(它自己判 allow)。
  *
  * 🔴 **S-877(core 7.35.0 #1200):本包装不是 `wrapToolPolicy`,它自报成员**。core 的 wrap 契约是「包装至少拒内层所拒」,
  * 而本包装**放行**内层会拒的另一形写目标 ⇒ 按契约它是一只自己的策略,内层的成员不能照搬(core wire 单点名这一只):
- *  · `writeTargetGuard`(守卫集策略自带,shell 写站问「这个绝对目标守不守」)—— 只在本层的形**覆盖守卫的入参形**时带上
- *    ({@link WRITE_TARGET_GUARD_DOMAIN}):真身层带;词法层不带(它的 env 对绝对形报错 ⇒ core 的「判不了就守」会把每一次
- *    shell 写都判成受守,正与两层射程互补的原设计相反)。这不是给某一形开的特例,是同一条「成员描述它守得住的那部分」的读法;
+ *  · `writeGuardRows`(core 7.49.0 [ref] 起;7.48.0 叫 `writeTargetGuard`,旧成员 core **不按名拒** ⇒ 不改就是壳写站静默丢部署守卫行)
+ *    —— 守卫集策略自带,壳写站按它交出的行判绝对目标;只在本层的形**覆盖行的判定形**时带上({@link WRITE_GUARD_ROWS_DOMAIN}):
+ *    真身层带;词法层不带(它的行与真身层是同一张模式表,带上只是同一组行判两遍)。这不是给某一形开的特例,是同一条
+ *    「成员描述它守得住的那部分」的读法;
  *  · `projection` / `pathRules` / `nameSets` —— 守卫集策略不带,本包装也不报(报了就是替它声称一张它没有的拒表)。
  * 修前(core 7.33.x)这里是一只 `{ check }` 字面量,7.34.0 起那只字面量把真身层的守卫剥掉了 —— 沙箱 lane 的 shell 写站
  * 因此看不见部署守卫集(`cp x .env` 在 acceptEdits 下被引擎 place 并答掉)。
@@ -253,7 +251,7 @@ export declare function buildOnlySensitiveBaselineWarning(config: Pick<Deploymen
  * 本口不知道出身这件事,也不再有自己的折叠点。叶的顺序 = 修前折叠的顺序(真身层 → 词法层 → 誊本门),deny 优先 / 首问 / 成员合并
  * 的读法因此不变。
  */
-export declare function createDeploymentGovernanceInputs(config: DeploymentGovernanceConfigView, pathAdjudication: PathAdjudication, roots: DeploymentGovernanceRoots): DeploymentGovernanceInputs;
+export declare function createDeploymentGovernanceInputs(config: DeploymentGovernanceConfigView, pathAdjudication: PathAdjudication): DeploymentGovernanceInputs;
 /**
  * 运维 allow 表 `APPROVAL_GRANT` 的**起服通告**载荷(纯数据 ⇒ `build*`;HTTP 腿与 run-local 腿各在装配时说一次,用 info 级)。规则不是秘密
  * (它们是工具名 / 命令规则),所以原样列出;空表 ⇒ `undefined`(不打)。运维只读面上同一个事实另有一处:`GET /v1/diagnostics/wiring` 的

package/dist/deployment-governance.js

@@ -16,6 +16,7 @@ export function createDurableQuestionGate(live) {
         },
     };
 }
+export const SANDBOX_TREE_FAMILY = "posix";
 function writeTargetFormOf(req) {
     if (!isProtectedWrite(req))
         return undefined;
@@ -23,11 +24,11 @@ function writeTargetFormOf(req) {
     const target = pt === undefined ? undefined : pathTargetValue(req.args, pt);
     if (typeof target !== "string" || target.length === 0)
         return undefined;
-    if (req.cwd !== undefined || target.includes("\u0000") || isAbsoluteForFamily(undefined, target))
+    if (req.cwd !== undefined || target.includes("\u0000") || isAbsoluteForFamily(SANDBOX_TREE_FAMILY, target))
         return "absolute-or-stamped";
     return "unstamped-relative";
 }
-const WRITE_TARGET_GUARD_DOMAIN = "absolute-or-stamped";
+const WRITE_GUARD_ROWS_DOMAIN = "absolute-or-stamped";
 export function scopedToWriteTargetForm(policy, form) {
     return {
         async check(req, signal) {
@@ -36,12 +37,12 @@ export function scopedToWriteTargetForm(policy, form) {
                 return { action: "allow" };
             return policy.check(req, signal);
         },
-        ...(form === WRITE_TARGET_GUARD_DOMAIN && policy.writeTargetGuard !== undefined ? { writeTargetGuard: policy.writeTargetGuard } : {}),
+        ...(form === WRITE_GUARD_ROWS_DOMAIN && policy.writeGuardRows !== undefined ? { writeGuardRows: policy.writeGuardRows } : {}),
     };
 }
 export class RelativeTargetLexicalEnv extends StubExecutionEnv {
     absolutePath(path) {
-        if (path.length === 0 || path.startsWith("/") || path.includes("\u0000")) {
+        if (path.length === 0 || isAbsoluteForFamily(SANDBOX_TREE_FAMILY, path) || path.includes("\u0000")) {
             return Promise.resolve(err(new FileError("not_supported", "this guard layer only adjudicates RELATIVE write targets (absolute forms are adjudicated against the real sandbox filesystem)", path)));
         }
         return Promise.resolve(ok(posix.normalize(`/${path}`)));
@@ -83,16 +84,14 @@ export function buildOnlySensitiveBaselineWarning(config, seat) {
         },
     };
 }
-export function createDeploymentGovernanceInputs(config, pathAdjudication, roots) {
+export function createDeploymentGovernanceInputs(config, pathAdjudication) {
     const sensitivePathLayers = config.sensitiveWritePatterns.length > 0
         ? (() => {
-            const dataRootOpt = roots.engineDataRoot !== undefined ? { dataRoot: roots.engineDataRoot } : {};
             const configRootOpt = config.agentConfigDir !== undefined ? { agentConfigDir: config.agentConfigDir } : {};
             const realTarget = createSensitivePathPolicy({
                 env: pathAdjudication.env,
                 patterns: config.sensitiveWritePatterns,
                 ...(pathAdjudication.cwd !== undefined ? { rootPath: pathAdjudication.cwd } : {}),
-                ...dataRootOpt,
                 ...configRootOpt,
             });
             const transcriptGuard = config.localDataRoot !== undefined ? [createTranscriptIntegrityPolicy({ sessionsDirs: [join(config.localDataRoot, "sessions")] })] : [];
@@ -100,7 +99,7 @@ export function createDeploymentGovernanceInputs(config, pathAdjudication, roots
                 return [realTarget, ...transcriptGuard];
             return [
                 scopedToWriteTargetForm(realTarget, "absolute-or-stamped"),
-                scopedToWriteTargetForm(createSensitivePathPolicy({ env: new RelativeTargetLexicalEnv(), patterns: config.sensitiveWritePatterns, ...dataRootOpt, ...configRootOpt }), "unstamped-relative"),
+                scopedToWriteTargetForm(createSensitivePathPolicy({ env: new RelativeTargetLexicalEnv(), patterns: config.sensitiveWritePatterns, ...configRootOpt }), "unstamped-relative"),
                 ...transcriptGuard,
             ];
         })()

package/dist/env-name-allowlist-knobs.d.ts

@@ -6,10 +6,10 @@
  *  · `example` 进拒句;
  *  · `multiTenant` = `REQUIRE_PRINCIPAL=true` 下名单作不作数 —— **只有服务进程读的旋钮有这一列**(姿态是服务进程的概念):
  *    - `LSP_ENV_ALLOW` ⇒ ignored:host 腿语言服务器在多租户姿态下本来就不起,名单无处作数,设了要说出来(S-699)。
- *    - 两只沙箱名单 ⇒ honored:S-713 照录修前语义(任何姿态下都转发),S-715 主会话裁定维持 —— 沙箱 env 是部署方为隔离沙箱显式配的
- *      带外凭据(e2b / docker 车道本来就是多租户 fleet 的主形),与 LSP 那条「本机子进程」的形不同;多租户下起服说一句。
+ *    - 三只沙箱名单(e2b / local-docker / k8s 各一只) ⇒ honored:S-713 照录修前语义(任何姿态下都转发),S-715 主会话裁定维持 —— 沙箱 env 是部署方为隔离沙箱显式配的
+ *      带外凭据(e2b / docker / k8s 车道本来就是多租户 fleet 的主形),与 LSP 那条「本机子进程」的形不同;多租户下起服说一句。
  *  · `BAKE_ENV_ALLOW`(S-684 残余,7.103.0)由 **bake-runner 进程**读(构建宿主守护进程:没有主体、没有租户 ⇒ 没有姿态列,
- *    不进 {@link describeAllowlistPostures} 的姿态句)。它与三只服务侧旋钮同一只解析器、同一只「点名放行」谓词、同一条「原文按凭据类」律。
+ *    不进 {@link describeAllowlistPostures} 的姿态句)。它与服务侧四只旋钮同一只解析器、同一只「点名放行」谓词、同一条「原文按凭据类」律。
  * 表是 `Record<旋钮, …>`:闭集加一只旋钮而不补行 = 编译红;行形随读它的进程定(服务进程 ⇒ 必须写姿态列)。
  *
  * 🔴 **姿态列只在这里写一次**([ref];7.101.0 合并复审 O9):凡要对人说「多租户下哪只旋钮忽略、哪只照转发」的句子,一律取
@@ -18,7 +18,7 @@
  * 当场撒谎。为什么是纯叶:`config-catalog.ts` 被 `config.ts` 值引,表留在 `config.ts` 会成装载环。
  */
 /** 服务进程(`config.ts` `loadConfig`)读的名单型旋钮 —— 有多租户姿态。 */
-export type ServerEnvNameAllowlistKnob = "LSP_ENV_ALLOW" | "E2B_SANDBOX_ENV" | "DOCKER_SANDBOX_ENV";
+export type ServerEnvNameAllowlistKnob = "LSP_ENV_ALLOW" | "E2B_SANDBOX_ENV" | "DOCKER_SANDBOX_ENV" | "K8S_SANDBOX_ENV";
 /** bake-runner 进程(`bake-runner/main.ts` `loadEnv`)读的名单型旋钮 —— 构建宿主守护进程没有主体 / 租户,没有姿态。 */
 export type RunnerEnvNameAllowlistKnob = "BAKE_ENV_ALLOW";
 export type EnvNameAllowlistKnob = ServerEnvNameAllowlistKnob | RunnerEnvNameAllowlistKnob;
@@ -41,7 +41,7 @@ export type EnvNameAllowlistKnobTable = {
     readonly [K in EnvNameAllowlistKnob]: K extends ServerEnvNameAllowlistKnob ? ServerEnvNameAllowlistKnobRow : RunnerEnvNameAllowlistKnobRow;
 };
 export declare const ENV_NAME_ALLOWLIST_KNOBS: EnvNameAllowlistKnobTable;
-/** 名单型旋钮的全部名字(四只;表键派生)—— 两处用:解析器的「点名名单型旋钮 = 形错」、剥除的「名单原文按凭据类」臂。 */
+/** 名单型旋钮的全部名字(五只;表键派生)—— 两处用:解析器的「点名名单型旋钮 = 形错」、剥除的「名单原文按凭据类」臂。 */
 export declare const ENV_NAME_ALLOWLIST_KNOB_NAMES: ReadonlySet<string>;
 /**
  * 多租户姿态句 —— **由表派生**,不许在别处手写。形:`under REQUIRE_PRINCIPAL=true: <旋钮> is ignored; <旋钮> / <旋钮> are forwarded as configured`

package/dist/env-name-allowlist-knobs.js

@@ -5,6 +5,7 @@ export const ENV_NAME_ALLOWLIST_KNOBS = {
     },
     E2B_SANDBOX_ENV: { example: "E2B_SANDBOX_ENV=GIT_TOKEN,NPM_TOKEN", multiTenant: { kind: "honored" } },
     DOCKER_SANDBOX_ENV: { example: "DOCKER_SANDBOX_ENV=GIT_TOKEN,NPM_TOKEN", multiTenant: { kind: "honored" } },
+    K8S_SANDBOX_ENV: { example: "K8S_SANDBOX_ENV=GIT_TOKEN,NPM_TOKEN", multiTenant: { kind: "honored" } },
     BAKE_ENV_ALLOW: { example: "BAKE_ENV_ALLOW=REGISTRY_PASSWORD,NPM_TOKEN" },
 };
 export const ENV_NAME_ALLOWLIST_KNOB_NAMES = new Set(Object.keys(ENV_NAME_ALLOWLIST_KNOBS));

package/dist/execution-lane-caps.d.ts

@@ -190,6 +190,18 @@ export declare function executionLaneOf(provider: string | undefined): Execution
  *  ③ `approval.ts` 的 `buildNoResponderBootWarns` —— 写门的 ask 只在「有手写本机盘」时才会发生。
  */
 export declare function handsOnWorkerFilePlane(lane: ExecutionLane): boolean;
+/**
+ * core 7.50.0 —— 「这条车道的执行环境能不能把一次读**绑到判过的那只对象**上」(`FileSystem.openBound`:开着并持有,叶链接不跟,
+ * 开后身份对拍)。LSP 会话的读口与路径附件只经它读;环境不实现 ⇒ 那两个读口在这条车道上一律拒。
+ *
+ * **一条律**:LSP 只在本谓词为真的车道挂(`boot/execution-env.ts` 的 LSP 管理器两臂都合取它;表的 `lsp` 位与之同向,
+ * 对拍钉 `test/host-env-open-bound.test.ts`:本谓词 ⟺ 适配器类原型上有 `openBound`)。
+ *  · `host` —— `RemoteHostExecutionEnv.openBound` 委托 core `NodeExecutionEnv` 的实现(唯一属主),真;
+ *  · `in-process` —— 没有手(core 落桩环境),无物可绑;
+ *  · 其余车道(沙箱 / 远端 shell / 设备)—— 读走 exec / sftp / 设备协议,本版不实现绑定读,假。实现之日翻这一格,LSP 沙箱桥随之回来。
+ * 穷举 switch、无 default 臂:车道加词而此处不表态 = 编译红。
+ */
+export declare function laneBindsReads(lane: ExecutionLane): boolean;
 /**
  * S-281 —— 「这条车道的手在不在 OS 级隔离边界里」。**全仓唯一**的布尔判别式(读表 `isolation` 位,见该位头注的读者清单)。
  * 穷举 switch、无 default 臂:`isolation` 的型只有两档,加档 = 编译红。

package/dist/execution-lane-caps.js

@@ -46,7 +46,7 @@ export function executionLaneCaps(lane) {
                 callerCwd: NO,
                 backgroundShell: YES,
                 scheduler: NO,
-                lsp: YES,
+                lsp: NO,
                 sandboxSendUserFile: YES,
                 isolation: YES,
                 suspendable: YES,
@@ -56,7 +56,7 @@ export function executionLaneCaps(lane) {
                 memoryPersistenceCapable: NO,
                 hostFilePlane: NO,
                 coreRemoteExecutionEnv: YES,
-                canonicalPathAuthority: NO,
+                canonicalPathAuthority: YES,
                 tenantSeparation: executionLaneRow(lane).tenantSeparation,
             };
         case "k8s":
@@ -64,7 +64,7 @@ export function executionLaneCaps(lane) {
                 callerCwd: NO,
                 backgroundShell: YES,
                 scheduler: NO,
-                lsp: YES,
+                lsp: NO,
                 sandboxSendUserFile: YES,
                 isolation: YES,
                 suspendable: YES,
@@ -128,7 +128,7 @@ export function executionLaneCaps(lane) {
                 memoryPersistenceCapable: NO,
                 hostFilePlane: NO,
                 coreRemoteExecutionEnv: YES,
-                canonicalPathAuthority: NO,
+                canonicalPathAuthority: YES,
                 tenantSeparation: executionLaneRow(lane).tenantSeparation,
             };
         case "device":
@@ -202,6 +202,20 @@ export function handsOnWorkerFilePlane(lane) {
     const caps = executionLaneCaps(lane);
     return caps.hostFilePlane === "supported" && caps.coreRemoteExecutionEnv === "supported";
 }
+export function laneBindsReads(lane) {
+    switch (lane) {
+        case "host":
+            return true;
+        case "in-process":
+        case "e2b":
+        case "k8s":
+        case "ssh":
+        case "adb":
+        case "device":
+        case "local-docker":
+            return false;
+    }
+}
 export function laneIsolated(lane) {
     const isolation = executionLaneCaps(lane).isolation;
     switch (isolation) {

package/dist/fleet/subagent-tail-bus.js

@@ -1,5 +1,6 @@
 import { redactSecrets } from "../trace/redact.js";
-import { taskProgressEventData, toolStartEventData, toolEndEventData, textEndEventData } from "../trace/project.js";
+import { taskProgressEventData, taskStartedEventData, toolStartEventData, toolEndEventData, textEndEventData } from "../trace/project.js";
+import { liveMediaBytesOf, liveToolEndForBacklog } from "../trace/tool-output-media.js";
 import { createReasoningSegments } from "../trace/model-segment.js";
 const TAIL_QUEUE_CAP = 512;
 export function projectTailFrame(e) {
@@ -7,6 +8,9 @@ export function projectTailFrame(e) {
     if (t === "task_progress") {
         return { type: "task_progress", ...taskProgressEventData(e) };
     }
+    if (t === "task_started") {
+        return { type: "task_started", ...taskStartedEventData(e) };
+    }
     if (t === "tool_start") {
         const tsv = e;
         return { type: "tool_start", ...toolStartEventData(tsv) };
@@ -80,10 +84,14 @@ export class SubagentTailBus {
             if (sub.closed)
                 continue;
             if (sub.queue.length >= TAIL_QUEUE_CAP) {
-                sub.queue.shift();
+                const oldest = sub.queue.shift();
+                if (oldest !== undefined)
+                    sub.mediaBytes -= liveMediaBytesOf(oldest);
                 sub.dropped++;
             }
-            sub.queue.push(frame);
+            const queued = frame.type === "tool_end" ? liveToolEndForBacklog(frame, sub.mediaBytes) : frame;
+            sub.mediaBytes += liveMediaBytesOf(queued);
+            sub.queue.push(queued);
             sub.wake?.();
         }
     }
@@ -91,7 +99,7 @@ export class SubagentTailBus {
         return (this.subs.get(bgAgentId)?.size ?? 0) > 0;
     }
     subscribe(bgAgentId) {
-        const sub = { queue: [], dropped: 0, closed: false };
+        const sub = { queue: [], dropped: 0, mediaBytes: 0, closed: false };
         let set = this.subs.get(bgAgentId);
         if (!set) {
             set = new Set();
@@ -121,8 +129,10 @@ export class SubagentTailBus {
                         return { value: { type: "lagged", dropped }, done: false };
                     }
                     const head = sub.queue.shift();
-                    if (head !== undefined)
+                    if (head !== undefined) {
+                        sub.mediaBytes -= liveMediaBytesOf(head);
                         return { value: head, done: false };
+                    }
                     if (sub.closed)
                         return { value: undefined, done: true };
                     await new Promise((resolve) => {

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

@@ -43,16 +43,17 @@ export interface ParseHooksConfigResult {
  * ⇒ **永不命中、一句话都没有**(post 两事件自 7.107.0 / core 7.36.0 起如此,PreToolUse 一直如此)。静默不命中 = 写的人以为在生效的 hook
  * 其实没跑,硬破坏三句要求的「响亮」没有着落。7.112.0(S-924)只拒**字面**别名;同一个错误写成 `^ListPeers$` / `ListPeers.*` / `(ListPeers)` 照样 200(S-995)。
  *
- * 规则(一条;字面形是它的特例):{@link deadToolMatcherIssue} 对 core 静态目录里**每一条退役别名**问「这只 matcher 选不选它 / 选不选它的正名」:
+ * 规则(一条;字面形是它的特例):{@link toolMatcherIssue} 对 core 静态目录里**每一条退役别名**问「这只 matcher 选不选它 / 选不选它的正名」:
  * matcher **命中别名 ∧ 不命中它的正名** ⇒ `400 request.field_invalid`(`admission.ts` fresh 门)。「选不选」**只有一只读法**:契约包的 `hookMatcherSelects`
  * (名字表 / 空 / `*` / 正则三形都由它答;正则形**不锚定**,与壳同形;运行期 {@link hookMatcherMatches} 问的也是它,本仓不留副本)。按**一条顺序**判(两档共用,7.114.0 修复轮):
  *  ① **长度上限**:超 {@link MAX_MATCHER_EVAL_CHARS} 的 matcher 两档都不读 ⇒ 未判(reason = oversize);
  *  ② **形只问契约包的 `hookMatcherForm`**(与 `hookMatcherSelects` 同一只解析步,本仓不留形判),闭集三词、两档一张表:
  *     · `literal`(缺席 / 空 / `*` / 名字表形;契约不编、不跑调用方的正则)⇒ 两档都**直接问契约函数**、**不占求值预算**;
- *     · `regex` ⇒ **`"regex"` 档**(hooks 会被采纳的车道,`taskHooksHonored`)把**同一只契约函数**经 `node:vm` 的 `timeout` 带一次受理共享的预算调用({@link matcherSelectsWithin});
+ *     · `regex` ⇒ **`"regex"` 档**(hooks 会被采纳的车道,`taskHooksHonored`)把**同一只契约函数**经 `node:vm` 的 `timeout` 带**每次求值各一份固定预算**调用({@link matcherSelectsWithin};
+ *       预算**不共享**、不随同一受理里别的 matcher 耗尽、不读钟 —— S-1455);**超时 ⇒ 这只 matcher 是灾难回溯 ⇒ `400 request.field_invalid` 拒**(见下「预算与结局」);
  *       **`"literal"` 档**(多租户车道:hooks 整只被 resolveSpec 忽略)= **不适用**:该车道没有被守的对象(hooks 不装配),不判、不算未判、不登记 —— **零调用方正则执行**
  *       (7.112.0 的字面判保留:裸 `ListPeers` / `Read|ListPeers` 照旧 400);
- *     · `invalid`(编不过)⇒ `"regex"` 档 = 未判 `invalid_regex`(不进预算求值 —— 形判已答「读不了」);`"literal"` 档 = 不适用(同上)。
+ *     · `invalid`(编不过)⇒ `"regex"` 档 = **`400 request.field_invalid` 拒**(判决 `invalid_regex`,见下「预算与结局」;不进求值 —— 形判已答「读不了」);`"literal"` 档 = 不适用(同上)。
  *    形判在 `literal` 档也跑:契约的解析步对非名字表形**构造**(只解析、不执行)一次调用方的 pattern 以分出 regex / invalid —— 长度已被 ① 界住;执行恒为零。
  *  · **为什么两档**(codex r1 [high] + 主会话裁):受理面是**所有**车道,而运行期只有单用户车道跑 hooks。在受理线程上跑调用方的正则 = 给多租户加一个事件循环 DoS 面
  *    (实测:`(.*)*` ×10 + `X` 对 9 字符名字首次执行 1.7 s,18 字符嵌套形 15 s,24 字符 157 s;8 MiB 交替串编译 + 求值 9 s)—— 预算只界住一次请求、界不住「每个请求再拿一份」。
@@ -73,63 +74,116 @@ export interface ParseHooksConfigResult {
  *  · **不在本规则内**:两边都选不中的 matcher(大小写错 / 词内空白 / 纯错字;目录之外的 MCP / 嵌入方工具名同样「选不中目录里任何名」,受理面无从区分错字与它们)=
  *    **「选不到目录里任何名」另一类,候设计(台账另立号,主会话裁)**。
  *
+ * 🔴 **预算与结局(S-1455;受理结局只取决于配置,不取决于机器忙闲)**:regex 档每一次求值(一只正则形 matcher 对一个名字的一次问)各拿**一份固定的墙钟预算**
+ * {@link ADMISSION_MATCHER_EVAL_BUDGET_MS}(vm `timeout`,从这次求值开始计)—— **不共享**(此前一次受理共用 100 ms,忙机上会被吃光 ⇒
+ * 同一份设置忙机偶尔被收下、闲机恒 400),不随同一受理里 matcher 的个数耗尽,判据里**没有时钟**(没有「截止线」可被调度停顿越过)。预算只防**灾难回溯**:
+ * 良性求值 ~0.1 ms,灾难形(指数级)吃满预算也跑不完 —— 两者相差数个数量级,取值给足余量(1 000 ms),让忙机上的调度停顿也跨不过这条线。
+ * **超时 ⇒ 确定拒绝**:`400 request.field_invalid`({@link OverBudgetMatcherIssue}),句子点名**哪一只 matcher**(事件 + 组下标,不回显原字节)与**预算**;**按配置顺序遇到的第一只超时 / 命中别名的 matcher 定结局**。
+ * 为什么是拒绝而不是放行:运行期 {@link hookMatcherMatches} 在**每次工具调用**里直接问同一只契约函数、**没有任何预算** —— 一只在受理面都跑不完的 matcher 放进去,
+ * 每次调用都会把事件循环卡住;放行 = 把一个确定的坏配置推迟成运行期的随机卡死。这条拒不是「越界即拒」的新检测面:被拒的恰是**无法被求值**的 matcher,与 `hook_matcher_invalid`(编不过 ⇒ 该组不跑)同属「这只 matcher 不可用」,
+ * 只是编不过的运行期自己安全地不跑它,跑不完的不行。
+ * 总用时的上界:首个超时即拒、不再往下求值;未超时的求值各自 < 预算。regex 档只在单用户车道(`taskHooksHonored`,hooks 会装配的那条;调用方就是进程属主,本来就能配任意 `command` 钩子)运行,
+ * 多租户车道走 literal 档、零调用方正则执行 —— 受理面的 DoS 面不因此重开。
+ *
+ * 🔴 **编不过的正则 = 确定的拒绝**(S-1455 收尾;与超预算同类 —— 确定性的坏配置,结局只取决于配置):`"regex"` 档遇契约 `hookMatcherForm` 答 `invalid`(或求值时契约函数答 `"invalid"`)⇒
+ * `400 request.field_invalid`({@link InvalidRegexMatcherIssue}),句子点名**哪一只 matcher**(事件 + 组下标 + 原文〔超 {@link MATCHER_ECHO_CHARS} 字符截断〕)与引擎的编译错误句;机读位 `detail` 只有闭集三键。
+ * 受理面与运行期问**同一只判**:契约把"编不过"答成 `invalid`,运行期 {@link hookMatcherMatches} 因此不跑那一组(并记 `hook_matcher_invalid`),受理面因此拒 —— 本仓不加第二个判官
+ * (编译错误句只是诊断文字,见 {@link matcherCompileSentence};拒不拒由契约函数一个人说了算)。为什么是拒绝而不是放行:放行 = 用户以为在生效的钩子(含会真拦的 PreToolUse deny 钩子)
+ * 在每次工具调用里都**悄悄不跑**,硬破坏三句要求的「响亮」没有着落;`"literal"` 档(多租户车道,hooks 不装配)= 不适用,与正则形同一行表。resume 重放不判(照旧采纳、该组不跑)。
+ * 🔴 **边界(如实披露)**:判据只守三个工具事件(`matcherReadsWireToolName`)—— 写在别的带 matcher 的事件(`StopFailure` 的 `error` 词 / `PreCompact`·`PostCompact` 的 `trigger` 词)上的坏 matcher 仍受理、运行期该组不跑并记 `hook_matcher_invalid`。
+ *
  * 🔴 **「未判」臂过 `recordFailOpen`**(F 类 tag `MATCHER_UNJUDGED_TAG`;主会话裁,CLAUDE.md「合法 F 类回退走登记 tag」):一只 matcher 没能被判 ⇒ 照旧受理 + 登记一笔,
- * detail = `event=… reason=… matcherChars=…`(**不带 matcher 原字节**,S-716 姿势)。三种 reason 同一个 tag:
- *   `oversize` —— 两档:matcher 超 {@link MAX_MATCHER_EVAL_CHARS} 字符不读(多租户车道上 hooks 不装配,这一笔只为让超长输入显形);
- *   `over_budget` ——「regex」档正则形:一次受理共享一份 {@link ADMISSION_MATCHER_EVAL_BUDGET_MS} 墙钟预算,用尽 ⇒ 这一只与其后各只正则形未判(`vm` 的 `timeout` 打断回溯,含 tier-up 之后的原生码);
- *   `invalid_regex` ——「regex」档正则形编不过(运行期另有每次调用的 `hook_matcher_invalid`;这是确定性的坏配置,不是负载 —— 拒它是新检测臂,不在本规则)。
- * 放行最坏后果 = 那一只 matcher 没被这条判据守住、照旧永不命中,**不是安全闸**(受理面有效性判);反方向「越界即拒」会把负载抖动 / 病态但合法的 matcher 变成对合法请求的 400。
+ * detail = `event=… reason=… matcherChars=…`(**不带 matcher 原字节**,S-716 姿势)。现在只剩一种 reason:
+ *   `oversize` —— 两档:matcher 超 {@link MAX_MATCHER_EVAL_CHARS} 字符不读(多租户车道上 hooks 不装配,这一笔只为让超长输入显形)。
+ * (`over_budget` 臂自 S-1455 起退役:它是「预算用尽 ⇒ 照旧受理」的随负载翻转的结局,现在是上面的确定拒绝;`invalid_regex` 臂自 S-1455 收尾起退役,同理。)
+ * 放行最坏后果 = 那一只 matcher 没被这条判据守住、照旧永不命中,**不是安全闸**(受理面有效性判)。
  * 拒放集合相对 7.113.0 的一处放宽(披露在 CHANGELOG / MIGRATION):超过上限的字面别名 matcher 7.113.0 拒(当时字面判不设上限),自 7.114.0 两档都判未判、受理。
  *
- * 错误句只回显**目录里的**别名与正名(闭集字符串),不回显调用方的原字节(S-716 姿势)。
+ * 错误句:死别名与超预算两形只回显**目录里的**别名与正名 / 位置(闭集字符串与数字),不回显调用方的原字节(S-716 姿势);编不过一形**点名那只 matcher 的原文**(截断到 {@link MATCHER_ECHO_CHARS} 字符)与引擎的编译错误句 ——
+ * 调用方要改的就是这一串,且它本来就是调用方自己送来的;机读位 `detail` 仍不带这两段。
  *
- * 🔴 **判决是数据,句子与体的机读位同出一只铸点**(S-1025;client-core 请托,additive):{@link deadToolMatcherIssue} 回 {@link DeadToolMatcherIssue}(event / alias / canonical)
- * 而不是句子;{@link buildDeadToolMatcherRefusal} 是**唯一**把它铸成拒句 + `field` + `detail` 的函数,受理门只取它的返回、**不解析句子**。体上多出的两键让三端不必解析英文就能把这只拒
- * 与普通提交失败分流、提示用户改 matcher;句子逐字同 7.114.0、零新码。
+ * 🔴 **判决是数据,句子与体的机读位同出一只铸点**(S-1025;client-core 请托,additive):{@link toolMatcherIssue} 回 {@link ToolMatcherIssue}(闭集三形:{@link DeadToolMatcherIssue} 的 event / alias / canonical,
+ * {@link OverBudgetMatcherIssue} 的 event / groupIndex / budgetMs,{@link InvalidRegexMatcherIssue} 的 event / groupIndex〔+ 句子用的 matcher / compileError〕,以 `reason` 区分)而不是句子;{@link buildToolMatcherRefusal} 是**唯一**把它铸成拒句 + `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;
-/** 一次 fresh 受理里 regex 档**正则形**求值共享的墙钟预算(毫秒)。字面形不占它。良性求值 ~0.1 ms;灾难回溯的 matcher 把预算吃完就停,后面的正则形组直接「未判」。 */
-export declare const ADMISSION_MATCHER_EVAL_BUDGET_MS = 100;
+/**
+ * regex 档**每一次正则形求值各一份**的墙钟预算(毫秒;S-1455)。**不共享、不随受理里 matcher 的个数耗尽、判据里不读钟**;字面形不占它。
+ * 良性求值 ~0.1 ms;灾难回溯(指数级)吃满它也跑不完 ⇒ 这只 matcher 被 400 拒。取值是「良性求值之上数个数量级」的余量 —— 小了,忙机上的调度停顿会把良性 matcher 读成灾难(受理结局随负载翻转,正是 S-1455 要根除的形)。
+ */
+export declare const ADMISSION_MATCHER_EVAL_BUDGET_MS = 1000;
+/** 拒句里回显的 matcher 原文 / 引擎编译错误句各自的字符上限(截断记号 `…(总长)` 由 `clip` 铸;S-1455 收尾)。真实 matcher 远在其内;上限只防一只 8 KiB 的坏 matcher 把拒句撑成一屏。 */
+export declare const MATCHER_ECHO_CHARS = 200;
 /** 受理面判据的求值深度(见上头注):`"regex"` = 契约字面形直接问、正则形带预算问同一只契约函数;`"literal"` = 7.112.0 的字面判(只判契约字面形,零调用方正则执行;正则形 / 编不过的形不适用)。 */
 export type MatcherEvalDepth = "regex" | "literal";
 /**
- * **仅供测试注入**的求值预算(生产调用点不传 ⇒ 预算 = {@link ADMISSION_MATCHER_EVAL_BUDGET_MS}、时钟 = `performance.now`)。
- * 让「预算是一次受理共享的」「耗尽之后的组」这类格子按求值次序断言,不按机器速度断言(`test/hooks-alias-matcher-s995.test.ts` R4)。
+ * **仅供测试注入**的求值预算(生产调用点不传 ⇒ 每次求值的预算 = {@link ADMISSION_MATCHER_EVAL_BUDGET_MS})。让「灾难形被拒」这类格子能用小额度(毫秒级)跑,不必等满生产预算。
+ * 只有预算额度、**没有时钟**:判据本身不读钟(S-1455),测试也就没有「在第几次读钟时预算已尽」可造 —— 求值次序、调度停顿都不改变结局。
  */
 export interface MatcherEvalBudget {
     readonly budgetMs?: number;
-    readonly now?: () => number;
 }
-/** 一条受理面判决(纯数据):`event` 事件下的某只 matcher 选中了退役别名 `alias`、却选不中它的正名 `canonical`。`alias` / `canonical` 恒取自 core 静态目录(闭集字符串,不含调用方原字节)。 */
+/** 一条受理面判决(纯数据)· 死别名:`event` 事件下的某只 matcher 选中了退役别名 `alias`、却选不中它的正名 `canonical`。`alias` / `canonical` 恒取自 core 静态目录(闭集字符串,不含调用方原字节)。 */
 export interface DeadToolMatcherIssue {
+    readonly reason: "dead_alias";
     readonly event: HookEventName;
     readonly alias: string;
     readonly canonical: string;
 }
-/** {@link buildDeadToolMatcherRefusal} 的返回(纯数据):拒句 + 400 体上的两个机读位。`field` 恒为字面 `"settings.hooks"`;`detail` 与 {@link DeadToolMatcherIssue} 同三键(逐个挑出,不 spread)。 */
-export interface DeadToolMatcherRefusal {
+/** 一条受理面判决(纯数据)· 求值超预算(S-1455):`event` 事件下第 `groupIndex` 组(从 0 起)的 matcher 单次求值没在 `budgetMs` 内结束(灾难回溯)。三键都是闭集 / 数字,不含调用方原字节。 */
+export interface OverBudgetMatcherIssue {
+    readonly reason: "over_budget";
+    readonly event: HookEventName;
+    readonly groupIndex: number;
+    readonly budgetMs: number;
+}
+/**
+ * 一条受理面判决(纯数据)· 正则编不过(S-1455 收尾):`event` 事件下第 `groupIndex` 组(从 0 起)的 matcher 在契约包的读法下答 `invalid`。
+ * `matcher` = 那只 matcher 的原文、`compileError` = 引擎的编译错误句(各自截到 {@link MATCHER_ECHO_CHARS} 字符):**只供铸拒句用**,机读位 `detail` 不带它们。
+ */
+export interface InvalidRegexMatcherIssue {
+    readonly reason: "invalid_regex";
+    readonly event: HookEventName;
+    readonly groupIndex: number;
+    readonly matcher: string;
+    readonly compileError: string;
+}
+/** 受理面判据的判决(闭集三形,`reason` 区分;每一形都是 400 拒):死别名 · 求值超预算 · 正则编不过。 */
+export type ToolMatcherIssue = DeadToolMatcherIssue | OverBudgetMatcherIssue | InvalidRegexMatcherIssue;
+/** {@link buildToolMatcherRefusal} 的返回(纯数据):拒句 + 400 体上的两个机读位。`field` 恒为字面 `"settings.hooks"`;`detail` 与 {@link ToolMatcherIssue} 同键(按 `reason` 分形,逐个挑出,不 spread)。 */
+export interface ToolMatcherRefusal {
     readonly message: string;
     readonly field: "settings.hooks";
     readonly detail: {
+        readonly reason: "dead_alias";
         readonly event: HookEventName;
         readonly alias: string;
         readonly canonical: string;
+    } | {
+        readonly reason: "over_budget";
+        readonly event: HookEventName;
+        readonly groupIndex: number;
+        readonly budgetMs: number;
+    } | {
+        readonly reason: "invalid_regex";
+        readonly event: HookEventName;
+        readonly groupIndex: number;
     };
 }
 /**
- * 判决 → 拒句 + 机读位。**拒句的唯一铸点**:句子逐字 = 7.114.0 的那一句(`test/hooks-alias-matcher-s995.test.ts` R7 冻结);受理门 `admission.ts` 用返回值填 400 体,
- * 不从句子里反解字段。
+ * 判决 → 拒句 + 机读位。**拒句的唯一铸点**:死别名的句子逐字 = 7.114.0 的那一句(`test/hooks-alias-matcher-s995.test.ts` R7 冻结);受理门 `admission.ts` 用返回值填 400 体,
+ * 不从句子里反解字段。超预算的句子点名**哪一只**(事件 + 组下标 + `matcher`)与**预算**,不回显 matcher 原字节(S-716 姿势);`reason` 闭集穷举(多一形 = 这里编译红)。
  */
-export declare function buildDeadToolMatcherRefusal(issue: DeadToolMatcherIssue): DeadToolMatcherRefusal;
+export declare function buildToolMatcherRefusal(issue: ToolMatcherIssue): ToolMatcherRefusal;
 /**
- * fresh 提交面专用判据(S-924 / S-995):配置里第一条「永远打不中」的工具事件 matcher 的判决数据({@link DeadToolMatcherIssue});没有 ⇒ undefined。
- * 拒句与 400 体的机读位由 {@link buildDeadToolMatcherRefusal} 从这份数据铸(S-1025)。
+ * fresh 提交面专用判据(S-924 / S-995 / S-1455):配置里第一条「该拒」的工具事件 matcher 的判决数据({@link ToolMatcherIssue}):「永远打不中」(死别名)或「求值超预算」(灾难回溯);没有 ⇒ undefined。
+ * 拒句与 400 体的机读位由 {@link buildToolMatcherRefusal} 从这份数据铸(S-1025)。**按配置顺序(事件 → 组)遇到的第一条定结局**;结局只取决于配置,不取决于求值次序之外的任何东西(无共享预算、无时钟)。
  * 入参是 {@link parseHooksConfig} 已校验过的配置;`depth` 由调用点按车道定(见头注:`taskHooksHonored(config) ? "regex" : "literal"`)。
  * `budget` **仅供测试注入**({@link MatcherEvalBudget});生产调用点只传前两个实参。
- * **只有 `admission.ts` 的 fresh 提交门调它** —— resume 重放不调(理由见上面的头注)。未判的 matcher 过 `recordFailOpen`(tag `MATCHER_UNJUDGED_TAG`)。
+ * **只有 `admission.ts` 的 fresh 提交门调它** —— resume 重放不调(理由见上面的头注)。未判的 matcher 过 `recordFailOpen`(tag `MATCHER_UNJUDGED_TAG`);超预算的不是未判,是拒。
  */
-export declare function deadToolMatcherIssue(config: HooksConfig, depth: MatcherEvalDepth, budget?: MatcherEvalBudget): DeadToolMatcherIssue | undefined;
+export declare function toolMatcherIssue(config: HooksConfig, depth: MatcherEvalDepth, budget?: MatcherEvalBudget): ToolMatcherIssue | undefined;
 /**
  * 把 wire 上的 untrusted `settings.hooks` 校验成契约 {@link HooksConfig} + 服务侧上限。
  * 错误返回 error 字符串而不 throw——submit 路径 400 fail-loud、resume 防御路径 warn-drop,由调用方选。
@@ -139,7 +193,7 @@ export declare function parseHooksConfig(raw: unknown): ParseHooksConfigResult;
  * 运行期的 matcher 读法席位:**问契约包的 `hookMatcherSelects`,别无其它**(壳与服务端都问这一只,谁都不留副本;读法全文见它的头注,这里不重述)。
  * 三形(名字表 / 空 `*` 缺省 / 不锚定的 JS 正则)与「编不过 ⇒ `"invalid"`」都由它答;**对所有带 matcher 的事件同一只读法**(工具事件 / StopFailure 的 `error` 词 /
  * PreCompact·PostCompact 的 `trigger` 词 / `if` 条件的名部),不按事件分档。`"invalid"` ⇒ 该组不跑(fail-closed 到「不跑」),由调用方记账一次(`hook_matcher_invalid`);
- * 受理面({@link deadToolMatcherIssue})问的是同一只函数。
+ * 受理面({@link toolMatcherIssue})问的是同一只函数。
  */
 export declare function hookMatcherMatches(matcher: string | undefined, value: string): boolean | "invalid";
 /** `if` 条目条件(CC-exact,对照 CC 2.1.187/198 实测行为核验的真语义,两版一致):
@@ -230,8 +284,8 @@ export type HookLlmFailureCode = "no_content" | "hard_timeout";
  */
 export declare function buildHookContext(parts: readonly string[]): string | undefined;
 /**
- * 阶段三a:`http` 条目——契约语义 = POST hook 输入 JSON 到 `url`;headers 里的 `$NAME` 仅当 NAME 列在
- * `allowedEnvVars` 才从 worker 进程 env 插值(配置本身绝不携带密钥值,契约同边界)。
+ * 阶段三a:`http` 条目——契约语义 = POST hook 输入 JSON 到 `url`;headers 里的 `$NAME` / `${NAME}` 仅当 NAME 列在
+ * `allowedEnvVars` 才从 {@link hookEnv} 插值(配置本身绝不携带密钥值,契约同边界);读法只有契约包的 `interpolateHookEnvVars` 一只(见函数体)。
  *
  * 结果折算成伪 {@link CommandRunResult},让 9 事件的既有折叠逻辑零改动复用:
  *  - 2xx + JSON body → 同 exit-0-stdout-JSON(SyncHookOutput 决策面)。⚠️ 这是对 CC 行为的合理近似