@sema-agent/server 7.150.0 → 7.152.0

package/dist/device-ws-protocol.d.ts

@@ -5,16 +5,20 @@ export declare const DEVICE_WS_PATH = "/v1/device/ws";
  * 本 server 铸/认的协议**修订号**(wire 上的 `protocolVersion`)。
  *
  * 规则(真源 = 协议文档 `docs/DEVICE-EXECUTOR-PROTOCOL.md` §2.1「Protocol revisions」段,此处只转述):加帧 / 加字段 = additive 不升号;
- * 其余变更一律升号并在增量表加一行,已发布的行不改 —— **server 受理的闭集(executor → server 方向,今天 = 结局 `errorCode` 词集)加词 = 升号**,
- * **语义变更(server 下发的帧意思变了)= 升号**。修订号是 executor 在发 hello 之前唯一能读到的「这台 server 受理什么、发来的帧是什么意思」的事实
- * (challenge 帧带它),所以 server 受理的词集必须是修订号的函数({@link DEVICE_OUTCOME_ERROR_CODES_BY_REVISION},协议文档同名表),不另发第二份列表;
- * 闭集变了而修订号没变 = 同一个修订号两种受理集(7.132.0 给结局码加 `liveness_no_output` 时没抬号,7.136.0 补到 2)。类型锁:抬了号而表没有这一行 ⇒ 编译红。
+ * 其余变更一律升号并在增量表加一行,已发布的行不改 —— **指令两向的闭集加词 = 升号**:server 受理的结局 `errorCode` 词集(executor → server)
+ * 与 server 下发的指令 kind 集(server → executor),各一张按修订号分行的表({@link DEVICE_OUTCOME_ERROR_CODES_BY_REVISION} /
+ * {@link DEVICE_INSTRUCTION_KINDS_BY_REVISION},同一组行键;协议文档是同一张修订号表的两栏);**语义变更(server 下发的帧意思变了)= 升号**。
+ * 修订号是 executor 在发 hello 之前唯一能读到的「这台 server 受理什么、会发来什么、发来的帧是什么意思」的事实(challenge 帧带它),所以两个闭集
+ * 都必须是修订号的函数,不另发第二份列表;闭集变了而修订号没变 = 同一个修订号两种集合(7.132.0 给结局码加 `liveness_no_output` 时没抬号,7.136.0 补到 2)。
+ * 下发方向的读法:汇聚端只认**这条连接协商的修订号**那一份 kind 集({@link asInstructionKindAt}),高于它的 kind 与认不出的词同读 —— 恒不下发。
+ * 类型锁:抬了号而任一张表没有这一行 ⇒ 编译红。
  */
 export declare const DEVICE_PROTOCOL_VERSION: DeviceProtocolRevision;
 /**
  * 受理下沿:低于它 ⇒ `helloReject: protocol_version_unsupported`(带 `minProtocolVersion` 与一句 {@link deviceProtocolRevisionRefusal},响亮拒,不静默降级,[ref])。
  * 兼容窗 = [MIN, 当前]。律(协议文档 §2.1 规则句):升号的变更旧修订的 executor 守不住 ⇒ 同一版把下沿抬到那一修订号 —— 旧 executor 在 hello 被拒一次,
  * 而不是逐调用失败。今天 = 5:修订号 5 起路径只锚不折(下沿理由见 {@link DEVICE_FLOOR_CHANGE}),写给修订号 ≤ 4 的 executor 认的是折过的路径。
+ * 修订号 6(kind 集加 `openBound`)不抬下沿:那个 kind 只派给协商修订号 ≥ 6 的连接,修订号 5 的 executor 收不到它 ⇒ 守得住。
  * 这是**本 server** 的受理下沿,不是 executor 协商时的下界(executor 一侧修订号是累积的:实现了 5 的照样能按 4 服务老 server)。
  */
 export declare const DEVICE_MIN_PROTOCOL_VERSION: DeviceProtocolRevision;
@@ -71,11 +75,44 @@ export type DeviceCancelState = (typeof DEVICE_CANCEL_STATES)[number];
  */
 export declare const DEVICE_INSTRUCTION_STATES: readonly ["queued", "dispatch_committed", "terminal", "terminal_never_started"];
 export type DeviceInstructionState = (typeof DEVICE_INSTRUCTION_STATES)[number];
-/** 指令 kind ↔ core 的 FileSystem+Shell 面 1:1(§5.1;双端穷举 switch)。 */
-export declare const DEVICE_INSTRUCTION_KINDS: readonly ["exec", "execStream", "readTextFile", "readTextLines", "readBinaryFile", "writeFile", "writeFileExclusive", "writeFileGuarded", "appendFile", "fileInfo", "listDir", "canonicalPath", "exists", "readLink", "createDir", "remove", "createTempDir", "createTempFile", "statBatch"];
-export type DeviceInstructionKind = (typeof DEVICE_INSTRUCTION_KINDS)[number];
-/** 认得就收窄,认不出就 null(**不猜**:未知 kind 恒不下发,fail-closed 方向)。 */
-export declare function asInstructionKind(v: string): DeviceInstructionKind | null;
+/**
+ * 指令 kind ↔ core 的 FileSystem+Shell 面 1:1(§5.1;双端穷举 switch)—— **按修订号分行的增量表,是这个闭集唯一的一份来源**(与结局码同一条律):
+ * 修订号 N 的 kind 集 = 行 ≤ N 的并、按行序({@link deviceInstructionKindsAt}),{@link DEVICE_INSTRUCTION_KINDS} 是当前修订号的那一份(派生)。
+ * 汇聚端对一条连接只认它协商的修订号那一份({@link asInstructionKindAt}):executor 在 `hello.supports` 里声明了一个高于自己修订号的 kind,与声明了
+ * 一个认不出的词同读 —— 不进声明集、恒不下发。已发布修订号的行不许改(测试冻结了每个修订号的集合哈希);加 kind = 抬 {@link DEVICE_PROTOCOL_VERSION} + 加一行。
+ * 行键与 {@link DEVICE_OUTCOME_ERROR_CODES_BY_REVISION} 同一组(`satisfies` 锁:少一行 / 多一行 ⇒ 编译红)。
+ */
+export declare const DEVICE_INSTRUCTION_KINDS_BY_REVISION: {
+    readonly 1: readonly ["exec", "execStream", "readTextFile", "readTextLines", "readBinaryFile", "writeFile", "writeFileExclusive", "writeFileGuarded", "appendFile", "fileInfo", "listDir", "canonicalPath", "exists", "readLink", "createDir", "remove", "createTempDir", "createTempFile", "statBatch"];
+    readonly 2: readonly [];
+    readonly 3: readonly [];
+    readonly 4: readonly [];
+    readonly 5: readonly [];
+    /**
+     * 7.151.0:绑定读 —— 判过的那只对象就是读到的那只。协议没有跨指令的句柄,所以 `BoundFileObject` 的每一答是一条指令
+     * ({@link DeviceInstructionArgsByKind}`.openBound.op` 四选一):执行器在本机打开这条路径(叶链接不跟)、核对这只打开的对象此刻就在这条路径上
+     * (且 `identity` / `kind` 在场时等于它们)、经这一次打开作答、关掉。executor 必须实现才答得出 ⇒ 加词抬号;只派给协商修订号 ≥ 6 的连接,
+     * 修订号 5 的 executor 收不到它(受理下沿不动)。presence-typed(同 `writeFileGuarded` / `readLink`):执行器在 `hello.supports` 声明才装这一面;
+     * 没声明 ⇒ 这一面缺席(引擎不绑定读,附件不附),**不许**用 `fileInfo` + `readBinaryFile` 仿真。
+     */
+    readonly 6: readonly ["openBound"];
+};
+export type DeviceInstructionKind = (typeof DEVICE_INSTRUCTION_KINDS_BY_REVISION)[DeviceProtocolRevision][number];
+/**
+ * 协议修订号 `revision` 下发的指令 kind 全集(行 ≤ revision 的并,按行序 —— 协议文档 §3.1 的表同序)。executor 按**自己声明的修订号**取这一份,
+ * 决定 `hello.supports` 里能声明哪些 kind。不是本包认得的修订号 ⇒ 抛 `RangeError`(不静默给空集或全集)。
+ */
+export declare function deviceInstructionKindsAt(revision: number): readonly DeviceInstructionKind[];
+/** 当前修订号下发的 kind 全集(派生自增量表;§3.1 的表就是它)。 */
+export declare const DEVICE_INSTRUCTION_KINDS: readonly DeviceInstructionKind[];
+/** `openBound` 指令的四个答(一个 `BoundFileObject` 成员一个;`open` 是开答)。 */
+export declare const DEVICE_BOUND_READ_OPS: readonly ["open", "size", "readBytes", "list"];
+export type DeviceBoundReadOp = (typeof DEVICE_BOUND_READ_OPS)[number];
+/**
+ * 认词 **按协商修订号**:`v` 在修订号 `revision` 的 kind 集里就收窄,不在就 null(**不猜**:高于协商修订号的 kind 与认不出的词同读,恒不下发,fail-closed 方向)。
+ * 不是本包认得的修订号 ⇒ 抛 `RangeError`(汇聚端在 hello 的版本窗之后才调它,窗外到不了这里;到了就是响亮的缺陷,不静默给全集)。
+ */
+export declare function asInstructionKindAt(v: string, revision: number): DeviceInstructionKind | null;
 /**
  * 结果帧的错误码闭集 = core 的 `FileErrorCode ∪ ExecutionErrorCode`(§5.1「error code 全闭集」:
  * 未知值映射为协议错误而非透传 string)—— **按修订号分行的增量表,是这个闭集唯一的一份来源**:
@@ -88,6 +125,7 @@ export declare const DEVICE_OUTCOME_ERROR_CODES_BY_REVISION: {
     readonly 3: readonly ["name_too_long"];
     readonly 4: readonly ["symlink_loop"];
     readonly 5: readonly [];
+    readonly 6: readonly [];
 };
 /** 本包认得的协议修订号(= 增量表的行键)。 */
 export type DeviceProtocolRevision = keyof typeof DEVICE_OUTCOME_ERROR_CODES_BY_REVISION;
@@ -151,7 +189,9 @@ export type DeviceInstructionOutcome = {
 } | {
     ok: true;
     kind: "read";
-} | {
+}
+/** `identity` 是 additive 扩键(`openBound` 开答:被打开对象的 `<dev>:<inode>`,之后每一答的对拍凭据)。 */
+ | {
     ok: true;
     kind: "stat";
     info?: WireFileInfo;
@@ -159,6 +199,7 @@ export type DeviceInstructionOutcome = {
     existsValue?: boolean;
     canonicalPath?: string;
     linkTarget?: string | null;
+    identity?: string;
 }
 /** 写面的**落盘对象收据**(§4.3.1 / core `WriteReceipt`)。`created` 是 additive 扩键(车A-4):
  *  core 的收据形要求它,缺席 = adapter 只能猜「是新建还是覆盖」,而猜出来的收据就是假收据。 */
@@ -255,6 +296,18 @@ export interface DeviceInstructionArgsByKind {
     statBatch: {
         paths: string[];
     };
+    /**
+     * 绑定读的一答。`op`:`open` ⇒ `stat` 结局带 `identity` 与 `info`(`kind` 只许 `file` / `dir`);`size` ⇒ `stat` 带 `info`(`size` = 此刻大小);
+     * `readBytes` ⇒ `read` 结局 + `data` 片(大小 > `max` ⇒ `invalid`,一个字节不读);`list` ⇒ `stat` 带 `entries`(经这只打开的目录列,链接不跟)。
+     * `identity` / `kind` 在场(开答之后的三答)⇒ 这一次打开的对象须与它们都相等,否则 `precondition_failed`;开后不在这条路径上同拒。
+     */
+    openBound: {
+        path: string;
+        op: DeviceBoundReadOp;
+        identity?: string;
+        kind?: "file" | "directory";
+        max?: number;
+    };
 }
 export type DeviceChallengeFrame = {
     t: "challenge";

package/dist/device-ws-protocol.js

@@ -1,7 +1,7 @@
 import { createPublicKey, randomBytes, randomInt, verify as edVerify } from "node:crypto";
 import { MAX_TIMER_DELAY_MS, inWholeNumberBounds, wholeNumberBoundsRule } from "./config-types.js";
 export const DEVICE_WS_PATH = "/v1/device/ws";
-export const DEVICE_PROTOCOL_VERSION = 5;
+export const DEVICE_PROTOCOL_VERSION = 6;
 export const DEVICE_MIN_PROTOCOL_VERSION = 5;
 const DEVICE_FLOOR_CHANGE = 'since server 7.150.0 every path an instruction carries (args.path, args.paths, cwd) arrives unfolded, with "." / ".." / empty segments kept for the device\'s filesystem to resolve';
 export function deviceProtocolRevisionRefusal(declared) {
@@ -24,30 +24,54 @@ export const DEVICE_GOODBYE_REASONS = ["shutdown", "sleep", "user_stop"];
 export const DEVICE_CHUNK_KINDS = ["stdout", "stderr", "data", "exit"];
 export const DEVICE_CANCEL_STATES = ["not_started", "killed"];
 export const DEVICE_INSTRUCTION_STATES = ["queued", "dispatch_committed", "terminal", "terminal_never_started"];
-export const DEVICE_INSTRUCTION_KINDS = [
-    "exec",
-    "execStream",
-    "readTextFile",
-    "readTextLines",
-    "readBinaryFile",
-    "writeFile",
-    "writeFileExclusive",
-    "writeFileGuarded",
-    "appendFile",
-    "fileInfo",
-    "listDir",
-    "canonicalPath",
-    "exists",
-    "readLink",
-    "createDir",
-    "remove",
-    "createTempDir",
-    "createTempFile",
-    "statBatch",
-];
-const INSTRUCTION_KIND_SET = new Set(DEVICE_INSTRUCTION_KINDS);
-export function asInstructionKind(v) {
-    return INSTRUCTION_KIND_SET.has(v) ? v : null;
+export const DEVICE_INSTRUCTION_KINDS_BY_REVISION = {
+    1: [
+        "exec",
+        "execStream",
+        "readTextFile",
+        "readTextLines",
+        "readBinaryFile",
+        "writeFile",
+        "writeFileExclusive",
+        "writeFileGuarded",
+        "appendFile",
+        "fileInfo",
+        "listDir",
+        "canonicalPath",
+        "exists",
+        "readLink",
+        "createDir",
+        "remove",
+        "createTempDir",
+        "createTempFile",
+        "statBatch",
+    ],
+    2: [],
+    3: [],
+    4: [],
+    5: [],
+    6: ["openBound"],
+};
+export function deviceInstructionKindsAt(revision) {
+    if (!Number.isInteger(revision) || revision < 1 || revision > DEVICE_PROTOCOL_VERSION) {
+        throw new RangeError(`device-ws: no instruction-kind set for protocol revision ${String(revision)} (this package knows revisions 1..${DEVICE_PROTOCOL_VERSION})`);
+    }
+    const out = [];
+    for (const [rev, kinds] of Object.entries(DEVICE_INSTRUCTION_KINDS_BY_REVISION)) {
+        if (Number(rev) <= revision)
+            out.push(...kinds);
+    }
+    return out;
+}
+export const DEVICE_INSTRUCTION_KINDS = deviceInstructionKindsAt(DEVICE_PROTOCOL_VERSION);
+export const DEVICE_BOUND_READ_OPS = ["open", "size", "readBytes", "list"];
+const INSTRUCTION_KIND_SETS = new Map(Object.keys(DEVICE_INSTRUCTION_KINDS_BY_REVISION).map((rev) => [Number(rev), new Set(deviceInstructionKindsAt(Number(rev)))]));
+export function asInstructionKindAt(v, revision) {
+    const kinds = INSTRUCTION_KIND_SETS.get(revision);
+    if (kinds === undefined) {
+        throw new RangeError(`device-ws: no instruction-kind set for protocol revision ${String(revision)} (this package knows revisions 1..${DEVICE_PROTOCOL_VERSION})`);
+    }
+    return kinds.has(v) ? v : null;
 }
 export const DEVICE_OUTCOME_ERROR_CODES_BY_REVISION = {
     1: [
@@ -75,6 +99,7 @@ export const DEVICE_OUTCOME_ERROR_CODES_BY_REVISION = {
     3: ["name_too_long"],
     4: ["symlink_loop"],
     5: [],
+    6: [],
 };
 export function deviceOutcomeErrorCodesAt(revision) {
     if (!Number.isInteger(revision) || revision < 1 || revision > DEVICE_PROTOCOL_VERSION) {
@@ -232,6 +257,12 @@ function parseOutcome(v) {
                     return null;
                 out.linkTarget = v.linkTarget;
             }
+            if (v.identity !== undefined) {
+                const id = str(v.identity);
+                if (id === null)
+                    return null;
+                out.identity = id;
+            }
             return out;
         }
         case "write": {

package/dist/elicitation.js

@@ -6,7 +6,7 @@ import { refusalBody } from "./http/refusal-body.js";
 import { keyAdmits, ownerCellOf, recoveredSubject } from "./owner-faces.js";
 import { createHitlOpenRace } from "./hitl-delivery.js";
 const MAX_ELICIT_MESSAGE_CHARS = 4096;
-const MAX_ELICIT_SCHEMA_BYTES = 8192;
+const MAX_ELICIT_SCHEMA_CHARS = 8192;
 const RELEASE_ACTION = { refused: "decline", unanswered: "cancel" };
 export const DEFAULT_ELICITATION_THROTTLE = {
     maxConcurrentPerRun: 2,
@@ -42,7 +42,7 @@ function boundSchema(schema) {
         return undefined;
     const redacted = redactDeep(schema);
     try {
-        if (JSON.stringify(redacted).length > MAX_ELICIT_SCHEMA_BYTES)
+        if (JSON.stringify(redacted).length > MAX_ELICIT_SCHEMA_CHARS)
             return undefined;
     }
     catch {

package/dist/engine-identity.d.ts

@@ -5,9 +5,11 @@
  * 与本仓的人面汇点同轴);`isolationScope` = **带场景的主体**(只在请求带了场景时有;引擎按它分登记域 / offload 租界 / 后台登记 / peer 目录 / 工作流 scope,
  * 引擎的读法是「隔离格缺席 ⇒ 读 `principal`」)。没带场景的请求只有 `principal`,与今天逐字节同。检查点的分区走本仓自己供的 `scope` 格。
  *
- * 今天的引擎还没有隔离格:{@link taskSpecIdentityOf} 是**唯一的落点**,今天只写 `principal`;隔离格到货后改那一行(钉在 `test/scenario-subject.test.ts`)。
- * 落点之前引擎自己按 `spec.principal` 分的那几面按人分(同一个人的各场景在那几面互见)—— 本仓镜像这几面的读口(工作流读面、后台登记簿的停止标记、
- * leader 子任务的 spec)同读 {@link taskSpecIdentityOf},读到的就是引擎写下的那一个值,不各写一份。
+ * 今天的引擎还没有隔离格:{@link taskSpecIdentityOf} 是**唯一的落点**,今天只写 `principal`;隔离格到货后改那一行(钉在 `test/scenario-subject.test.ts`),
+ * {@link engineScopeOf} 同一提交换读(钉在 `test/workflow-scope-core-parity.test.ts`)。
+ * 落点之前引擎自己按 `spec.principal` 分的那几面按人分(同一个人的各场景在那几面互见)。本仓读这几面(工作流行的 `scope` 列、后台登记簿与它的停止标记、
+ * 会话信箱盒与被扣来信的队列、名册)时「一只主体 ⇒ 那一格 scope」只有一只换算 {@link engineScopeOf},读到的就是引擎写下的那一个值,不各写一份;
+ * leader 子任务与提交腿的 spec 同经落点 {@link taskSpecIdentityOf}。
  */
 import { type Person, type Subject, type SubjectParts } from "./owner-brands.js";
 /** 引擎交界的身份(本仓的类型;二元)。 */
@@ -20,15 +22,25 @@ export interface EngineIdentity {
 export declare function specIdentityOf(parts: SubjectParts | undefined): EngineIdentity;
 /**
  * 落进 `TaskSpec` 的身份格(**唯一落点**)。今天的引擎没有隔离格 ⇒ 只写 `principal`,`isolationScope` 在这里不落(引擎按人分它自己的那几面);
- * 引擎的隔离格到货 ⇒ 这里加一格,别处不动。
+ * 引擎的隔离格到货 ⇒ 这里加一格,同一提交里 {@link engineScopeOf} 改读 core 的 `isolationScopeOf`(身份格闭集型在那里编译红,逼读法表态),别处不动。
  */
 export declare function taskSpecIdentityOf(parts: SubjectParts | undefined): {
     readonly principal?: string;
 };
 /**
- * 引擎按身份分的那几面落下的 **scope**(core 写侧 `spec.principal ?? "default"` 的同一条读法;工作流行的 `scope` 列就是它):一只主体 ⇒ 落点 {@link taskSpecIdentityOf}
- * 写下的人;匿名 ⇒ 单机形的租户键 `"default"`(`owner-faces.ts` 的 `LEGACY_UNOWNED_AMNESTY_TENANT`)。读者只在属主存取器(`http/owner-access.ts`):工作流按 id 的门
- * (调用方一侧按它换成引擎身份再与行的 scope 比)与工作流列表的属主过滤同读这一只;承认之后 journal / 流按承认的那一行的 scope 读。
+ * 🔴 **一只主体在引擎按身份分的那几面上的 scope —— 唯一一只换算**(工作流行的 `scope` 列 / 后台登记簿 / 会话信箱盒与被扣来信的队列 / 停止标记 / 名册:
+ * 引擎写下它们时用的那一个值)。规则 = core 写侧那一条,落在本仓交给引擎的身份格({@link taskSpecIdentityOf})上 ⇒ {@link scopeOfLanded}:
+ *  · core 7.66.0(本仓钉的版本):工作流行 `scope` = `ctx.principal ?? 挂载 scope`(`createRunWorkflowTool` 的 `execute` 里的 `taskScope`;`startWorkflow` 缺席落
+ *    `"default"`)—— `ctx.principal` 是 Runner 填的 `spec.principal`;挂载 scope 与后台登记簿 / 被扣来信队列同一个量,即 Runner 准备任务时算的任务 scope
+ *    `registryScope ?? spec.principal ?? "default"`(同一个值挂进 `run_workflow`、交给信箱排空腿开 held 队列)。本仓不供 `registryScope` ⇒ 各面同值 = 落下的
+ *    `principal`,匿名 = `"default"`。
+ *  · core 的下一形([ref] 隔离格随 7.68.0 到货;[ref] 同版根导出 `callScopeOf` / `isolationScopeOf`):`callScopeOf(ctx, 挂载) = ctx.isolationScope ?? 挂载.scope`,
+ *    Runner 把 `ctx.isolationScope` 填成 `isolationScopeOf(spec) = spec.isolationScope || spec.principal`;落点只写 `principal` 时两形同值。
+ * **随 core [ref] 到货换读、退本读法**:提货车让落点写出隔离格的同一提交里,这里改读 core 根导出的 `isolationScopeOf`(落下的身份格 ⇒ `?? "default"`),
+ * {@link scopeOfLanded} 退役 —— 落点多一格而读法没表态 = 编译红(身份格闭集,见它)。真 core 对拍钉:`test/workflow-scope-core-parity.test.ts`。
+ * 工作流行「归谁」只在属主存取器经它判(`http/owner-access.ts` 的 `workflowScopeOf`:列表 / 按 id / 舰队流同读)。
  */
 export declare function engineScopeOf(subject: Subject | undefined): string;
+/** 一只**持久的**属主串(会话 / run 行的属主列、续跑腿交来的属主、请求鉴权句柄的纯串主体)在那几面上的 scope:先过内部恢复管线,再经 {@link engineScopeOf};无主 ⇒ 匿名那一格。 */
+export declare function engineScopeOfOwner(owner: string | null | undefined): string;
 //# sourceMappingURL=engine-identity.d.ts.map

package/dist/engine-identity.js

@@ -1,5 +1,5 @@
 import { partsOf } from "./owner-brands.js";
-import { LEGACY_UNOWNED_AMNESTY_TENANT } from "./owner-faces.js";
+import { LEGACY_UNOWNED_AMNESTY_TENANT, recoveredSubject } from "./owner-faces.js";
 export function specIdentityOf(parts) {
     if (parts === undefined)
         return { principal: undefined };
@@ -10,6 +10,14 @@ export function taskSpecIdentityOf(parts) {
     return principal === undefined ? {} : { principal };
 }
 export function engineScopeOf(subject) {
-    return taskSpecIdentityOf(subject === undefined ? undefined : partsOf(subject)).principal ?? LEGACY_UNOWNED_AMNESTY_TENANT;
+    return scopeOfLanded(taskSpecIdentityOf(subject === undefined ? undefined : partsOf(subject)));
+}
+export function engineScopeOfOwner(owner) {
+    return engineScopeOf(recoveredSubject(owner));
+}
+function scopeOfLanded(landed) {
+    const { principal, ...unread } = landed;
+    unread;
+    return principal ?? LEGACY_UNOWNED_AMNESTY_TENANT;
 }
 //# sourceMappingURL=engine-identity.js.map

package/dist/entry-mode-clamp-notice.d.ts

@@ -10,7 +10,8 @@
  * ## 铸点(唯一)
  * {@link buildEntryModeClampNotice} 是本码**唯一**的铸点;调用点只有一处:`http/admission.ts` 的 `prepareSpec`(提交入口,盖章之后、装配
  * 之后 —— 那时会话 id 才定)。一次提交一次 ⇒ 一条 run 至多一帧(core 码册的去重单位「once per run」)。读的是盖章那一次求值的读数
- * (`EntryPermissionMode`),不另判一遍「折没折」。续跑腿不铸:它们重放的是已盖过章的存储体,折叠只发生过一次。
+ * (`EntryPermissionMode`),不另判一遍「折没折」。续跑腿不铸:续跑口按**现**地板钳存储体的词时(`permission-mode-admission.ts` `stampReplayEntryMode`),
+ * 那一腿的生效词由它的 `wiring_manifest.permissionMode` 说(引擎收到的就是钳过的词);本码只说受理门那一折(per run 一帧)。
  * 装配期铸、腿开口那一拍投(`PreparedTaskSubmission.engineNotices` → `registerEngineNoticeLeg` 的 `pending`)—— 与请求腿 MCP 丢弃同一条投递路,
  * 白名单 / 归属 / 消毒 / 隔离一个不绕。
  *

package/dist/entry-problems.d.ts

@@ -1,14 +1,51 @@
+/**
+ * **条目问题的机读位** —— 请求体里的工具名清单 / 规则表有坏条目时,拒体(提交口 400 · 设置规则 422 · 续跑重放 409)与受理应答(`warnings`)说「哪几条、为什么」的**唯一一只形**,一处铸。
+ *
+ * 形(拒体机读位的版式律:事实在拒体根上,`problems[]` 每项的领域结构原样):
+ *   拒体   `{ error, errorCode, field, problems: EntryProblem[], total }`
+ *   应答   `{ …, warnings: EntryProblem[] }`(受理了、没拒,只告;只在有话说时在场)
+ *   一条问题 `{ code, field, entry, reason }`:
+ *    · `code`   = 这一条所在的那张清单**被拒时**拒体会带的码(技能清单 `request.field_invalid`;子代定义的 `denyTools` / `allowTools` `config.agent.unknown_tool`;根 run 的
+ *                 `excludeTools` / `allowTools` `config.tool_face_control`;设置规则桶 `request.unprocessable`)—— 一条问题就是「一只迷你拒绝」;
+ *    · `field`  = 这一条所在清单的**体内坐标**(`agents[0].denyTools`、`excludeTools`、`settings.permissions.deny`;不带条目下标);
+ *    · `entry`  = 条目的脱敏原值({@link redactListEntry}:不加引号、不转义,认出的凭据换记号);
+ *    · `reason` = 为什么这一条什么也不是,闭词:引擎条目读法的原因词原样(`near_miss` / `tool_name` / `grammar` / `content_unsupported` / `wildcard_all` / `namespace_wildcard`),
+ *                 规则编译器那一面的判词(引擎名字判官的 `retired` / `unmintable_segment` / `unprefixed_namespace`、引擎规则文法的 `invalid.*` · `unsupported.*` 码原样),
+ *                 契约包层准入的判词(`below_trust_floor`),与本仓自己的三词({@link SERVER_ENTRY_PROBLEM_REASONS})。铸点的实参型是这几张表的并({@link EntryProblemReason}):
+ *                 写一个哪张表都没有的词 = tsc 红(本仓自己的词只能从闭集取)。
+ *  · 拒体的 `error` 句子**不变**:码与句子仍是「先撞上的那一张清单」的(第一条问题的码与坐标 = 体的 `errorCode` 与顶层 `field`),机读位另把**这一遍判下来的全部问题**一次列全 ——
+ *    单条问题的体 = 列表长 1,不是另一种形。
+ *  · `total` = 这一遍判下来的问题总数;`problems` 至多 {@link MAX_ENTRY_PROBLEMS} 条(按扫描序截,每张清单自己的条数帽另在先:超帽的清单整只拒、不逐条读,不进本列表)。
+ *    `total > problems.length` ⇒ 被截过。拒体恒有 `total`,缺席的「被截与否」不靠数条数猜。
+ *
+ * 为什么机读位只有这一个铸点:壳要按条提示、不解析句子(句子给人读,`error` 文案冻结但不是协议);一个面一个自己的键表就是 [ref] / [ref] 之后又一种形。
+ */
+import type { AllowEntryInertReason, PermissionRuleIssue } from "@sema-agent/core";
+import type { LayerAdmissionVerdict } from "@sema-agent/settings-schema";
+import type { UnmatchableRuleName } from "./namespaced-rule-name.js";
 /** `problems` 的条数上限(= 一张清单的条数帽 `MAX_ALLOW_LAYER_ENTRIES` 的数;数在这里写死一次,`rule-entry-list.ts` 的帽改了不应拖着机读位走 —— 两者是两个界)。 */
 export declare const MAX_ENTRY_PROBLEMS = 1000;
 /**
  * 本仓自己铸的 `reason` 词(闭集;其余 `reason` 是引擎的词原样 —— 见文件头):
  *  · `not_in_roster` —— 受理应答 `warnings` 的词:放行侧选择器清单里的这个名字不在名册(引擎目录 ∪ 本仓自铸工具 ∪ 本请求挂的调用方工具)、也不是协议命名空间名(懒挂载),引擎照旧受理、之后只告运维;
- *  · `home_unresolvable` —— 设置规则 422 的词:`~/` 形路径规则而本部署解不出执行环境的家目录。
+ *  · `home_unresolvable` —— 设置规则 422 的词:`~/` 形路径规则而本部署解不出执行环境的家目录;
+ *  · `cc_rule_form` —— 名表消费者(按**整串工具名**比对的那几张表:`settings.permissions.neverAuto`,以及运维 / 中心的审批名单)里的带括号条目:这张表只比整名,
+ *    `Bash(ls)` 永远匹配不到任何活工具。判据是本仓这几张表的比对方式,不是引擎的读法(引擎的 allow 层对同一条另有判词,读的是另一张表)⇒ 本仓的词。
  */
-export declare const SERVER_ENTRY_PROBLEM_REASONS: readonly ["not_in_roster", "home_unresolvable"];
+export declare const SERVER_ENTRY_PROBLEM_REASONS: readonly ["not_in_roster", "home_unresolvable", "cc_rule_form"];
 export type ServerEntryProblemReason = (typeof SERVER_ENTRY_PROBLEM_REASONS)[number];
 /** 「读得出、却不在名册」的告知词({@link SERVER_ENTRY_PROBLEM_REASONS} 的第一员):`warnings` 里它之外的词都是引擎的条目读法读成空的原因词。 */
 export declare const NOT_IN_ROSTER: ServerEntryProblemReason;
+/** 「执行环境的家目录 / 配置根读不出」的拒词(设置规则 422;两个铸点同读这一只)。 */
+export declare const HOME_UNRESOLVABLE: ServerEntryProblemReason;
+/** 「名表消费者里的带括号条目」的拒词(`config.ts` 的名表判据是唯一铸点)。 */
+export declare const CC_RULE_FORM: ServerEntryProblemReason;
+/**
+ * 一条问题的 `reason` 可以是哪些词 —— 铸点实参的型(wire 上的 `reason` 仍按开集读:引擎的词表随引擎版本增减):
+ * 本仓自铸的三词 ∪ 引擎条目读法的原因词 ∪ 引擎名字判官的判词 ∪ 引擎规则文法的码 ∪ 契约包层准入的 `below_trust_floor`。
+ * 哪张表都没有的词在铸点 tsc 红 —— 「自铸了闭集外的词」不可能静默上 wire。
+ */
+export type EntryProblemReason = ServerEntryProblemReason | AllowEntryInertReason | UnmatchableRuleName["kind"] | PermissionRuleIssue["code"] | Extract<LayerAdmissionVerdict, "below_trust_floor">;
 /** 一条问题(wire 形)。 */
 export interface EntryProblem {
     readonly code: string;
@@ -17,7 +54,7 @@ export interface EntryProblem {
     readonly reason: string;
 }
 /** 铸一条问题:`entry` 收**原串**,这里过脱敏(调用方没有「忘了脱敏」的可能)。 */
-export declare function entryProblem(code: string, field: string, rawEntry: string, reason: string): EntryProblem;
+export declare function entryProblem(code: string, field: string, rawEntry: string, reason: EntryProblemReason): EntryProblem;
 /** 拒体上的机读位(原样摊在拒体根上:`HttpError.extra` / `refusalBody` 的 `facts`)。型别名而不是接口 —— 要能直接当 `Record<string, unknown>` 用。 */
 export type EntryProblemsFacts = {
     readonly field: string;

package/dist/entry-problems.js

@@ -1,7 +1,9 @@
 import { redactListEntry } from "./list-entry-display.js";
 export const MAX_ENTRY_PROBLEMS = 1_000;
-export const SERVER_ENTRY_PROBLEM_REASONS = ["not_in_roster", "home_unresolvable"];
+export const SERVER_ENTRY_PROBLEM_REASONS = ["not_in_roster", "home_unresolvable", "cc_rule_form"];
 export const NOT_IN_ROSTER = "not_in_roster";
+export const HOME_UNRESOLVABLE = "home_unresolvable";
+export const CC_RULE_FORM = "cc_rule_form";
 export function entryProblem(code, field, rawEntry, reason) {
     return { code, field, entry: redactListEntry(rawEntry), reason };
 }

package/dist/execution-env-refusal.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 本仓自铸的**执行环境拒码**闭集(`env.*` 族)的唯一属主(纯叶:零值依赖)。
+ *
+ * 一族一句:**这只执行环境没开,而且再问也是同一个答** —— 部署状态(或会话数据)与这条 run 冲突,原样重试不改判,出路在部署。两处产出、同一族:
+ *  · 工厂在铸环境之前拒(host 车道:读数在构造时就到手,`lane-home-probe.ts` 的 `laneHomeRefusal`;k8s 车道:每条 run 铸环境前读一次集群 API 凭据,
+ *    `boot/execution-env.ts` 的 `createK8sRunEnvFactory`),都经 {@link executionEnvRefusalError} 铸带码的错,引擎在准备期原样再抛、run 以它失败;
+ *  · 远端车道在建连时答的**立定拒**(这只环境此后每一次建连都答同一个拒,适配器记住它):码由 `plugins/remote-env-connect-seat.ts` 的拒因表从事实词拼出
+ *    —— 那张表是远端车道拼本族码的唯一入口,立定 ⇔ 码在引擎可重试表之外 ⇔ 记住。
+ * 同步提交腿按零工作拒落档(`runs.ts` 的 `EXECUTION_ENV_REFUSAL_HTTP_STATUS`,按本闭集键控:加一员而档没跟 ⇒ tsc 红)。
+ *  · `env.home_unconfirmed` —— 家目录主张证不了(`judgeLaneHome` 的三形拒句:读不出 / 不是绝对路径 / 与实测不一致;远端车道只在环境**答了**的两形上记住它)。
+ *    三形一个码:出路都在部署(声明、环境里的 `HOME`,或会话 `settings.env` 里的 `HOME`),消费端不按形分岔;是哪一形、怎么改,句子里说。
+ *  · `env.snapshot_bucket_missing` —— k8s 车道的工作区快照桶不在(对象存储对 `latest` 或归档的读答 `404 NoSuchBucket`):建桶,或把
+ *    `WORKSPACE_SNAPSHOT_BUCKET` 指向已有的桶,或 `WORKSPACE_PERSIST=off`。
+ *  · `env.occupant_missing` —— k8s 车道读这条 run 的会话住客:会话行在、却不带住客令牌(存储数据缺陷,重发不改判):给行补令牌或删会话,或关掉要它的旋钮。
+ *  · `env.sandbox_refused` —— 隔离车道(k8s / e2b / local-docker)替这条 run 建的沙箱被立定地拒:集群在准入时拒了 pod、成员凭据中继建不起来、
+ *    快照归档在桶里却取不回、工作区的填充(会话附件 / 项目包种子)放不进且换一台机器也是同一个答、k8s 车道的集群 API 凭据起服之后读不到或被集群 401 拒
+ *    (`k8s-api-credentials.ts`:凭据起服时就缺是起服拒 `config.k8s_api_credentials_missing`,到不了 run)。是哪一件、怎么改,句子里说。
+ *  · `env.host_key_rejected` —— ssh 车道:目标机出示的主机密钥过不了部署钉的判(`SSH_HOST_FINGERPRINT` / `SSH_KNOWN_HOSTS`:指纹不符、条目换了钥、被吊销、没有条目)。
+ *    改钉或查明对面为什么换了钥;同一配置同一主机每次同答。
+ */
+export declare const EXECUTION_ENV_REFUSAL_CODES: readonly ["env.home_unconfirmed", "env.snapshot_bucket_missing", "env.occupant_missing", "env.sandbox_refused", "env.host_key_rejected"];
+export type ExecutionEnvRefusalCode = (typeof EXECUTION_ENV_REFUSAL_CODES)[number];
+/** 本族的带码错(唯一铸点):句 = 拒句原文,`code` = 闭集里的一员;工厂原样抛出,引擎在准备期再抛,run 的失败终局原样承运码与句。 */
+export declare function executionEnvRefusalError<C extends ExecutionEnvRefusalCode>(code: C, message: string): Error & {
+    readonly code: C;
+};
+/** 这个码是不是本族的一员(按闭集,不按前缀:引擎自己的 `env.lifetime_expired` 同前缀而不是本族)。 */
+export declare function isExecutionEnvRefusalCode(code: unknown): code is ExecutionEnvRefusalCode;
+//# sourceMappingURL=execution-env-refusal.d.ts.map

package/dist/execution-env-refusal.js

@@ -0,0 +1,8 @@
+export const EXECUTION_ENV_REFUSAL_CODES = ["env.home_unconfirmed", "env.snapshot_bucket_missing", "env.occupant_missing", "env.sandbox_refused", "env.host_key_rejected"];
+export function executionEnvRefusalError(code, message) {
+    return Object.assign(new Error(message), { code });
+}
+export function isExecutionEnvRefusalCode(code) {
+    return typeof code === "string" && EXECUTION_ENV_REFUSAL_CODES.includes(code);
+}
+//# sourceMappingURL=execution-env-refusal.js.map

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

@@ -184,7 +184,7 @@ export declare function deployedExecutionLanes(config: Pick<ServiceConfigFlat, "
  * 读者问的都是这一句,**同一只函数**,不许各写一份 `=== "host"`:
  *  ① 部署形表行 `toolsOnThisHost`(`deployment-shape.ts`)—— wire `executionLane.toolsOnThisHost` + 出厂自扫技能与中心 plugin 技能的 `baseDir`;
  *  ② 部署形表行 `callerOwnsWorkerDisk`(本列 ∧ 单主)—— SendUserFile 本机腿(「无手不挂」)、调用方宿主路径(附加目录 / 项目上下文)、指令文件探针、
- *     本机语言服务器(`createLspManager`;这类车道的适配器必须绑得住读 `openBound`,对拍钉 `test/host-env-open-bound.test.ts`);
+ *     本机语言服务器(`createLspManager`;「绑得住读」`openBound` 不是本列的事,是每条有手车道的结构前提,见 {@link laneWiresExecutionEnv});
  *  ③ `approval.ts` 的 `buildNoResponderBootWarns` —— 写门的 ask 只在「有手写本机盘」时才会发生(它手里已有车道词,直接读本列)。
  */
 export declare function handsOnWorkerFilePlane(lane: ExecutionLane): boolean;
@@ -230,6 +230,8 @@ export declare function laneIsolated(lane: ExecutionLane): boolean;
  * 这条车道**有没有手**(块 `io`:文件与 shell 两面真到达目标;`none` 的桩块 false)的唯一布尔口。读者四处:路由的「有没有执行环境」(`boot/resolve-spec.ts`)、
  * wire `executionLane.isolated` 的在场判据(`capabilities/execution-lane.ts`)、场景详情的附件供给集(`boot/stage-07-capability-layer.ts` 把它填进
  * `ScenarioDeps.handsLane`:「这一 run 有没有工作区」的车道半场)、起服家目录那一行({@link buildLaneHomeBootNote})—— 同读这一只。
+ * 有手车道的结构前提:适配器有绑定读面(`openBound`;设备的面 presence-typed,执行器声明了才装)—— 「能不能绑定读」的源是适配器对象本身,
+ * 本列不另存一位(对拍钉 `test/host-env-open-bound.test.ts` P3;本版唯一缓装 = ssh,同文件 `HELD_THIS_VERSION`,翻回条件钉在那里)。
  */
 export declare function laneWiresExecutionEnv(lane: ExecutionLane): boolean;
 /** 一条**已登记**的分叉:表写的是目标态,今天的判别式还答别的。 */

package/dist/field-conflict.d.ts

@@ -7,7 +7,7 @@ export type FieldConflictReason = (typeof FIELD_CONFLICT_REASONS)[number];
  * 动态下标的坐标用模板字面量型(`agents[1].skills`)。
  */
 export interface FieldConflictCoordinates {
-    readonly cascade_verify: "verify" | "cascade" | "sandboxImageProfile" | "resumeAt" | "suggestNextPrompts";
+    readonly cascade_verify: "verify" | "cascade" | "sandboxImageProfile" | "resumeAt" | "rewindFilesTo" | "suggestNextPrompts";
     readonly image_profile: "capabilitiesNeeded" | "sandboxImageProfile";
     readonly resume_anchor: "resumeAtMode" | "resumeAt";
     readonly system_prompt_fold: "appendSystemPrompt" | "projectId" | "settings.outputStyle";

package/dist/file-history-capture.d.ts

@@ -52,21 +52,28 @@ export interface FileHistoryAssembly {
     /** 擦除脸:在场 ⟺ 后端在(与旋钮无关;是 {@link store} 的删除类动词视图)。 */
     readonly erasure: FileHistoryErasureFace | undefined;
 }
-/** 装配:「这台部署有没有文件历史店」的唯一判定。旋钮不在这里 —— 它只关捕获,不摘店([ref])。 */
+/** 「这台部署有没有文件历史店」的唯一判定:店是后端恒交的那一只(`StoreBackend.fileHistory()`,落定席位写的同一只)⇒ 店在 ⟺ 后端在。旋钮不在这里 ——
+ *  它只关捕获,不摘店([ref])。只问「在不在」的读者(能力位)读这一只,不必取店。 */
+export declare function fileHistoryWired(backend: StoreBackend | undefined): backend is StoreBackend;
+/** 装配:取那只店(判定 = {@link fileHistoryWired})。起服装配(引擎的还原族 / 擦除脸)与服务面要店的读者(同步族、rewind 口)都经这里取,手里有后端 ⇒ 型上就有店。 */
+export declare function assembleFileHistory(backend: StoreBackend): {
+    readonly store: ServiceFileHistoryStore;
+    readonly erasure: FileHistoryErasureFace;
+};
 export declare function assembleFileHistory(backend: StoreBackend | undefined): FileHistoryAssembly;
 /**
- * 「捕不捕」的**唯一**判定(纯函数):能力词。`store` = 装配出来的店(在不在),`knob` = 部署旋钮 `FILE_HISTORY_CAPTURE`
+ * 「捕不捕」的**唯一**判定(纯函数):能力词。`wired` = 店在不在({@link fileHistoryWired} 的答 / 装配出来的店在不在),`knob` = 部署旋钮 `FILE_HISTORY_CAPTURE`
  * (`config.fileHistoryCapture`)。从**装配结果**派生,不照旋钮字面回声:后端本来就没有这只店的部署同样是 `off`。
  *
  * 与 `restoreFiles` 分叉([ref] 当时写下的分叉条件,自 [ref] 成真):本词答「这台部署捕不捕、能不能按 run 关掉」,
  * `restoreFiles` 答「这台部署能不能还原」—— 旋钮关的部署本词 `off` 而 `restoreFiles` 仍为真。
  */
-export declare function fileHistoryCaptureOf(store: object | undefined, knob: boolean): FileHistoryCapture;
+export declare function fileHistoryCaptureOf(wired: boolean, knob: boolean): FileHistoryCapture;
 /**
  * core 的部署捕获位 `RunnerDeps.fileHistoryCapture`,由 {@link fileHistoryCaptureOf} 派生(同一组输入、同一只判定)。
  * 形照 `execution-lane-caps.ts` 的穷举 switch(无 default 臂):能力词加一个而这里不加臂 ⇒ 编译红 —— 加臂的那一刻就是
  * 决定「这一词下 core 的捕获位怎么递」的地方。没有店 ⇒ 恒 `undefined`(core 对「off 但没店」拒 prepare)。
  */
-export declare function coreFileHistoryCaptureSeat(store: object | undefined, knob: boolean): RunnerDeps["fileHistoryCapture"];
+export declare function coreFileHistoryCaptureSeat(wired: boolean, knob: boolean): RunnerDeps["fileHistoryCapture"];
 export {};
 //# sourceMappingURL=file-history-capture.d.ts.map

package/dist/file-history-capture.js

@@ -3,19 +3,22 @@ const FILE_HISTORY_CAPTURE_WORD_SET = {
     "on-optional": true,
 };
 export const FILE_HISTORY_CAPTURE_WORDS = Object.keys(FILE_HISTORY_CAPTURE_WORD_SET);
+export function fileHistoryWired(backend) {
+    return backend !== undefined;
+}
 export function assembleFileHistory(backend) {
-    if (backend === undefined)
+    if (!fileHistoryWired(backend))
         return { store: undefined, erasure: undefined };
     const physical = backend.fileHistory();
     return { store: physical, erasure: physical };
 }
-export function fileHistoryCaptureOf(store, knob) {
-    return store !== undefined && knob ? "on-optional" : "off";
+export function fileHistoryCaptureOf(wired, knob) {
+    return wired && knob ? "on-optional" : "off";
 }
-export function coreFileHistoryCaptureSeat(store, knob) {
-    if (store === undefined)
+export function coreFileHistoryCaptureSeat(wired, knob) {
+    if (!wired)
         return undefined;
-    const word = fileHistoryCaptureOf(store, knob);
+    const word = fileHistoryCaptureOf(wired, knob);
     switch (word) {
         case "off":
             return "off";

package/dist/file-history-disclosure.d.ts

@@ -50,16 +50,18 @@ export interface CaughtFailure {
     readonly fault: Pick<FileHistoryError, "permanence">;
 }
 /**
- * 把一个 caught error 折成店侧的散文 + 判断,**并**在它是一枚 typed 永久失败时留痕。
+ * 把一个 caught error 折成店侧的散文 + 判断,**并**在它是一枚 typed 永久失败时留痕。**先读店边界**(`storeBoundaryFault`,`site` = 折点所在的店方法):
+ * 文件历史店把失败**返回**成值(不抛),值里的文本取自这里 —— 驱动错(以及词法外的码:工作区 fs 的 `ENOENT` / `EACCES`、对象存储的码)在这里换成边界形
+ * (类别句 + 原码尾注,原句进运维日志 `at=store` 一行),返回值里不再带库的原话。
  *
- * `text` = 散文形:带 typed `code` 的前缀一个括号词(`(blob_too_large_for_sql) blob of … exceeds …`),
- * 不带的**逐字**是原 message(transient 失败的文案因此与本批之前一字不差)。
+ * `text` = 散文形:带本仓词法内 `code` 的(typed 失败:`blob_too_large_for_sql` 一类)前缀一个括号词(`(blob_too_large_for_sql) blob of … exceeds …`),
+ * 其余逐字是(过了边界的)message —— 边界句自带 `[original code: <码>]` 尾注,不再前缀第二遍码。
  * `fault` = 判断形(core 7.55.0 `FileHistoryError.permanence`):永久码表里的码 ⇒ `{ permanence: "terminal" }`;连接类故障 ⇒ `{ permanence: "transient" }`
  * (什么都不改稍后再试可能成);部署错配类故障 ⇒ `{ permanence: "terminal" }`(修表 / 授权之前重试注定失败);其余 ⇒ `{}`(店不知道 —— 认不出的驱动 / 库错是不是会自己好,不归本店判)。
- * 永久码先于分类判(一只错不会两个都是);分类词只读判官 `storeFaultClassOf`,本文件不写码。
+ * 永久码先于分类判(一只错不会两个都是);分类词只读判官 `storeFaultClassOf`(边界形带着它在原错上判的词),本文件不写码。
  * 副作用 = 机器形:码取自错误对象,逐次计数 + 每进程每码一条 warn。观测绝不抛。
  */
-export declare function foldCaughtFailure(err: unknown): CaughtFailure;
+export declare function foldCaughtFailure(err: unknown, site: string): CaughtFailure;
 /** 装配层把 logger/metrics 接上(main.ts,与 `installFailOpenRecorder` 同一处)。 */
 export declare function installFileHistoryFailureRecorder(deps: Sink): void;
 /** 本进程逐码累计(测试/诊断读面)。 */

package/dist/file-history-disclosure.js

@@ -1,5 +1,6 @@
 import { FILE_HISTORY_ERROR_CODES, FileHistoryStoreError } from "@sema-agent/core";
 import { storeFaultClassOf } from "./plugins/store-fault.js";
+import { outwardFailureCode, storeBoundaryFault } from "./terminal.js";
 const PERMANENT_STORE_FAILURE_CODES = {
     blob_too_large_for_sql: {
         note: "a blob is larger than this deployment's SQL snapshot-blob cap — the same file will fail every turn until the deployment changes",
@@ -30,16 +31,17 @@ function drainToMetrics() {
         }
     }
 }
-export function foldCaughtFailure(err) {
-    const message = err instanceof Error ? err.message : String(err);
-    const code = err?.code;
-    const typedCode = typeof code === "string" && code !== "" ? code : undefined;
+export function foldCaughtFailure(err, site) {
+    const seen = storeBoundaryFault(err, site);
+    const message = seen instanceof Error ? seen.message : String(seen);
+    const code = seen?.code;
+    const typedCode = typeof code === "string" && code !== "" && outwardFailureCode(code) === code ? code : undefined;
     const permanentCode = typedCode !== undefined && isPermanentCode(typedCode) ? typedCode : undefined;
     if (permanentCode !== undefined)
         recordPermanent(permanentCode, message);
     return {
         text: typedCode !== undefined ? `(${typedCode}) ${message}` : message,
-        fault: permanentCode !== undefined ? { permanence: "terminal" } : faultOfClass(storeFaultClassOf(err)),
+        fault: permanentCode !== undefined ? { permanence: "terminal" } : faultOfClass(storeFaultClassOf(seen)),
     };
 }
 function faultOfClass(cls) {