@sema-agent/server 7.53.0 → 7.54.0

package/dist/plugins/remote-env-device.js

@@ -1,6 +1,6 @@
 import { posix } from "node:path";
 import { ExecutionError, FileError, RemoteExecutionError, } from "@sema-agent/core";
-import { DEVICE_ERROR_CODES, DEVICE_RATE_LIMIT_CODE, } from "../device-store.js";
+import { DEVICE_ERROR_CODES, } from "../device-store.js";
 export const DEVICE_PROVIDER = "device";
 const ok = (value) => ({ ok: true, value });
 const STREAM_PENDING_MAX_BYTES = 2 * 1024 * 1024;
@@ -60,6 +60,7 @@ export const DEVICE_REJECT_TO_EXEC_ERROR = {
     "device.enrollment_invalid": "auth_failed",
     "not_found.device": "auth_failed",
     "limit.rate_exceeded": "target_unavailable",
+    "draining": "target_unavailable",
 };
 export const DEVICE_REJECT_TO_FILE_ERROR = {
     "device.not_bound": "transport_lost",
@@ -73,6 +74,7 @@ export const DEVICE_REJECT_TO_FILE_ERROR = {
     "device.enrollment_invalid": "permission_denied",
     "not_found.device": "permission_denied",
     "limit.rate_exceeded": "transport_lost",
+    "draining": "transport_lost",
 };
 const DEVICE_REJECT_TO_REMOTE_ERROR = {
     "device.not_bound": "connect_failed",
@@ -86,6 +88,7 @@ const DEVICE_REJECT_TO_REMOTE_ERROR = {
     "device.enrollment_invalid": "auth_failed",
     "not_found.device": "auth_failed",
     "limit.rate_exceeded": "connect_failed",
+    "draining": "connect_failed",
 };
 function rejectText(reject) {
     return `[${reject.code}] ${reject.message}`;

package/dist/plugins/roster-store-sql.d.ts

@@ -21,8 +21,7 @@
  * 是「core 变语义必须先过迁移裁量」的告警钉)。
  */
 import type { Pool } from "mysql2/promise";
-import { type RosterStore, type RosterEntry } from "@sema-agent/core";
-type RosterAccess = Parameters<RosterStore["resolve"]>[1];
+import { type RosterStore, type RosterEntry, type RosterAccess } from "@sema-agent/core";
 import type { PgQueryFn } from "./pg-query.js";
 export declare const ROSTER_TABLE = "agent_roster";
 export declare function ensureTiDBRosterSchema(pool: Pool): Promise<void>;
@@ -51,5 +50,4 @@ export declare class PgRosterStore implements RosterStore {
     /** [ref] MED2(TiDB twin 同案注)。 */
     reapOlderThan(cutoffMs: number): Promise<number>;
 }
-export {};
 //# sourceMappingURL=roster-store-sql.d.ts.map

package/dist/plugins/store-backend.js

@@ -319,7 +319,7 @@ export function createStoreBackend(config, onWarn, onError) {
     if (config.dbBackend === "pg") {
         if (!config.pg)
             return undefined;
-        const pool = createPgPool(pgPoolOptions(config.pg, config.dbQueryTimeoutMs));
+        const pool = createPgPool(pgPoolOptions(config.pg, config.dbQueryTimeoutMs), onWarn);
         return new PgBackend(pool, config);
     }
     if (!config.tidb)

package/dist/plugins/tidb-pool.d.ts

@@ -10,6 +10,19 @@ import type { ServiceConfig } from "../config-types.js";
  */
 /** Build the mysql2 pool options from TiDB config (pure → unit-testable apart from the live connection). */
 export declare function tidbPoolOptions(tidb: NonNullable<ServiceConfig["tidb"]>): mysql.PoolOptions;
+/** ── [ref] 同查结论:mysql2 与 pg-pool **不同病**,本池不需要(也不应)挂进程保命监听 ────────────────
+ *  pg 侧的病是「idle client 错误 emit 到 Pool 且无监听 ⇒ 未捕获 ⇒ 整进程 exit 1」(修在 pg-pool.ts
+ *  createPgPool 头注)。mysql2@3.22.6 亲读(不信文档,以实现为准):
+ *   · `lib/pool_connection.js:14-16` —— PoolConnection 构造器**恒挂** `once('error', () =>
+ *     this._removeFromPool())`:每条池连接天生有 error 监听(**借出期同在**——不像 pg-pool 借出时
+ *     摘监听,mysql2 的 checked-out 连接也无裸奔窗),EventEmitter 不会把 idle 死转 throw,
+ *     坏连接就地淘汰;
+ *   · `lib/base/connection.js` `_notifyError` —— fatal 闩(`if (this._fatalError) return`)挡同一
+ *     连接的二次 emit;`_handleFatalError` 摘 stream data 监听 ⇒ 闩后 `protocolError` 结构不可达;
+ *   · `lib/base/pool.js` / `lib/promise/pool.js` —— 池层与 promise 包装层都**不**把连接 error 再
+ *     emit 到池对象上(池层只 emit acquire/connection/enqueue/release)。
+ *  ⇒ 空闲连接被 KILL / 故障切换杀掉 = 库内吞并淘汰,进程不死、池自愈。真 TiDB KILL 钉在
+ *  `test/pool-idle-error-db-integration.test.ts` 第③格。升 mysql2 大版时按上面三坐标复核。 */
 export declare function createTidbPool(config: ServiceConfig): Pool;
 /**
  * Idempotent schema. `session_event` is the append-only L1 event log (positional slicing by

package/dist/runtime-governance.d.ts

@@ -126,6 +126,10 @@ export declare function governanceMandatesShellGateAlways(governance: {
     autonomy?: Autonomy;
     manualModeShellGate?: "always" | "classify";
 }): boolean;
+/** spec 序里的秩(0 起,越大越严)。入参收 `string`(fail-loud 边界:schema `trustRank` 同款姿势)——词表外 ⇒
+ *  RangeError,绝不 undefined/NaN 让比较静默成 false。导出只为对表钉(test/safety-merge-spec-consumption.test.ts,
+ *  [ref] 件4)——运行时消费仍走上表(键类型闭集)。 */
+export declare function shellGateRank(word: string): number;
 /**
  * Apply the operator's runtime governance (autonomy + commandPolicy + manualModeShellGate) onto a base
  * `TaskSpec`, TIGHTEN-ONLY, in a SINGLE {@link tightenTaskSpec} call: commandPolicy compiles to a `toolPolicy`

package/dist/runtime-governance.js

@@ -1,4 +1,5 @@
 import { combinePolicies, COARSE_SHELL_TOOLS as CORE_COARSE_SHELL_TOOLS, createCoarseCommandNamePolicy, DEFAULT_SUBAGENT_TOOL_NAME, parseLeadingCommandName, tightenTaskSpec, } from "@sema-agent/core";
+import { SAFETY_MERGE_SPEC } from "@sema-agent/settings-schema";
 import { currentGovernanceAskMarks } from "./governance-ask-marks.js";
 export function isDelegationToolName(name) {
     return name === DEFAULT_SUBAGENT_TOOL_NAME;
@@ -116,7 +117,28 @@ function createGovernanceShellGateMarkPolicy(marksOf, tools = COARSE_SHELL_TOOLS
         },
     };
 }
-const SHELL_GATE_RANK = { off: 0, classify: 1, always: 2 };
+const SHELL_GATE_RANK = (() => {
+    const tighten = SAFETY_MERGE_SPEC.shellGate.tighten;
+    const rule = tighten.rule;
+    if (tighten.rule !== "enumRank")
+        throw new Error(`SAFETY_MERGE_SPEC.shellGate.tighten.rule=${rule} — 不是 enumRank,shellGate 秩无从派生`);
+    const table = { off: -1, classify: -1, always: -1 };
+    for (const [i, w] of tighten.order.entries()) {
+        if (!(w in table))
+            throw new Error(`SAFETY_MERGE_SPEC.shellGate 序里有本仓词表外的词:${w}`);
+        table[w] = i;
+    }
+    for (const [w, r] of Object.entries(table))
+        if (r < 0)
+            throw new Error(`SAFETY_MERGE_SPEC.shellGate 序缺词:${w}`);
+    return table;
+})();
+export function shellGateRank(word) {
+    const r = SHELL_GATE_RANK[word];
+    if (r === undefined)
+        throw new RangeError(`unknown shellGate word: ${word}`);
+    return r;
+}
 export function applyRuntimeGovernance(base, governance) {
     const marksOf = () => governance.askMarks ?? currentGovernanceAskMarks();
     const overrides = { ...autonomyOverrides(governance.autonomy) };

package/dist/tool-approval.d.ts

@@ -842,30 +842,6 @@ export declare class ToolApprovalCoordinator {
      *  面)—— 把它混进本名单会让「同 askId 的重复本地注册」拿到裸 deny,而赢家拿的是 park 路由:同一条
      *  持久行、两种 live 终局。那一支改走 {@link settleSameAskIdParkRoute}。 */
     private settleVoidedSiblings;
-    /**
-     * [ref] codex R3-F1 —— 「行上此刻有没有一个**真决议**」的一次性窄读(窗到期臂的店报错支专用)。
-     *
-     * 返回 `true`/`false` = 行是 `DECIDED` 且决议是 approve/deny(**人的**裁决,或车4 端点代人落的那一次);
-     * `undefined` = 其它一切(读失败、行不在、行是 STREAM_PENDING/PARKING/PARKED/DENIED/VOID)——调用方按
-     * 自己的臂继续。判别复用 {@link replayTerminalAskRow}(不造第二套映射),这里只把它的**布尔臂**取出来:
-     * `"unavailable"`(PARKING/PARKED)刻意**不**在本口消费,那属于路由面、归 `unattendedPolicy` 管。
-     *
-     * 一次读 + 墙钟 deadline(不重试):店已经在报错的语境里,重试只会把窗到期的收尾拖成秒级,而这一口要
-     * 回答的问题(「有没有人已经答过了」)读一次就够 —— 读不到就按「不知道」处置,与本臂原语义一致。
-     *
-     * ⚠️ **已登记的残余(codex R4-F1/F2,验真后不在本批修)**:本读与随后的本地 settle 之间没有持久 CAS,
-     * 所以「读到 STREAM_PENDING、另一副本**随后**才提交 DECIDED」这条窄窗仍会得到 park/deny 终局(行是
-     * approve 而本腿不执行);`emit` 全灭臂与取消臂的 store-未知态 catch 有**同形**缺口(两者都早于本件、
-     * 各自有既有判据钉着)。方向仍是 fail-closed(没有任何东西在未经人批时执行),补偿是 core 侧那张仍然
-     * pending 的 checkpoint —— 人再批一次就走。真正的收口 = 把窗/emit-全灭/取消三条 ambiguous-CAS catch
-     * 统一到一次**持久**恢复流程(带 CAS 与终态回读),那是店语义级改动,须由本模块属主立设计件,施工车
-     * 不私开(本批已试过整段复用 `convergeFromDurableState`,被自己的全量跑打回,理由见其顶注)。
-     *
-     * ✅ **第二条残余已收口([ref],2026-08-19 登记 → 2026-08-31 [ref] 销)**:本口读出的放行此前交给
-     * `settle` 时第三形参 `updatedInput` 恒缺席(行上没有那一列),core 落回原始实参执行 = 执行面**宽于**
-     * 人所批准。现在行上有 `updated_input` 列,本口回 `{allowed, updatedInput?}` 两件,`settle` 拿到的就是
-     * 人批准的那份编辑;P-DEBT tag 随列撤线(fail-open.ts 撤线备注 + census 第 31 行终态)。
-     */
     /**
      * 🔴 session grant 短路前的**持久出处复核**([ref] 的 codex R1-[high] 补丁;[ref] 换判据)。
      *
@@ -904,8 +880,24 @@ export declare class ToolApprovalCoordinator {
      * 多半头一次到,那等于把一揽子放行整只废掉。窗的上界由本判据定死:行**一提交**窗即关。
      */
     private sessionGrantUncontestedByRow;
-    /** [ref]:返回值从裸布尔改成「方向 + 编辑载荷」(行带 `updatedInput` ⇒ 一并交出;`undefined` = 不知道)。 */
-    private readDecidedForRecovery;
+    /**
+     * [ref] 恢复读口:一次带墙钟的 `getAsk`,把行翻译成 {@link RecoveryRead} 七态。**只读不写**(单赢者:终局
+     * 写点只有各臂的 CAS)。两处消费 —— 干净输后的 `convergeFromDurableState`(在 pending/unreadable 上退避)
+     * 与店未知态后的 `recoverFromUnknownStore`(只在 unreadable 上退避)—— 共用这**一份**映射,不各自
+     * `switch` 一遍(`replayTerminalAskRow` 仍是唯一的三态映射,这里只把它接到结算动作上)。
+     *
+     * 沿革:前身 `readDecidedForRecovery`([ref] codex R3-F1,窗到期臂店报错支专用)只答「有没有真决议」,
+     * 且把「读失败」与「行不是 DECIDED」折成同一个 `undefined` —— 调用臂分不清「店真不可用」与「行就是没定」,
+     * 于是取消臂 / emit 全灭臂的同形缺口一直没法接同一条路(R4-F1/F2 登记的残余)。[ref] 把两种「不知道」
+     * 拆开(设计件 §2 K1/K2),三臂 catch 才统一得起来。[ref] 那条(行派生 approve 丢编辑)已随 [ref] 落列
+     * 收口:`approved` 臂带行上的 `updatedInput`。
+     *
+     * 行派生 approve 的两道守卫**在这里**施加(五处消费一份判据,见 {@link guardRowDerivedApprove}):
+     *  · 弃单墓碑在场 ⇒ `parked`(park 路由,可逆可再批 —— 绝不把一个证不出载荷的放行交出去);
+     *  · 编辑在飞 ⇒ `edit-in-flight`(codex R4-[critical] 同族口:载荷还在别人手里的那一拍按行结算 = 用裸
+     *    `true` 抢在它前面;持有者随后必定自己结算)。
+     */
+    private readRowForRecovery;
     /** [ref] codex R3-F2:同一 askId 下**其余本地注册**(重复注册,见 {@link pendingByAskId} 顶注)按
      *  **park 路由**收尾 —— 行已 PARKING,它们看的是同一条行,终局必须与赢家同形(`unattendedPolicy`
      *  由各自的闭包读同一个口,deny 部署上一起是 deny)。赢家自己此刻已 settle 过、已从集合里摘除,
@@ -1252,8 +1244,9 @@ export declare class ToolApprovalCoordinator {
      *
      * R6 把弃单墓碑的兑现点收在 {@link notifyExternalDecision} 上,并自称「公共咽喉」—— 那句话**不成立**:
      * 树上还有三处**直接** `settle(true, …)` / 直接把 `true` 交回 core 的行派生回放(`convergeFromDurableState`
-     * 的收敛臂、`ensureAsk` 幂等命中终局行的回放、窗到期报错臂的 `readDecidedForRecovery`),它们跳过那个
-     * 口。于是弃单之后从这三条路上仍能放出原始命令。
+     * 的收敛臂、`ensureAsk` 幂等命中终局行的回放、窗到期报错臂的 `readDecidedForRecovery` —— [ref] 起前者与
+     * 后者合并成 `readRowForRecovery` 一个读口、三臂共用),它们跳过那个口。于是弃单之后从这三条路上仍能放出
+     * 原始命令。
      *
      * 收口形 = **一个判据函数、五处消费**(上面三处 + 轮询 + HTTP 观察者):把「行说 approve」这件事
      * 在弃单墓碑在场时翻译成 `"unavailable"`(park 路由,可逆可再批),其余取值逐字透传。

package/dist/tool-approval.js

@@ -46,6 +46,20 @@ export const ASK_DECISION_CONSUMER_ABSENT = "absent";
 const DURABLE_CONVERGE_BACKOFF_MS = [50, 100, 200, 400, 800, 1600];
 const DURABLE_CONVERGE_READ_TIMEOUT_MS = 2_000;
 const DURABLE_CALL_TIMEOUT_MS = 5_000;
+function ambiguousCasFailOpenTag(intent) {
+    switch (intent) {
+        case "expire":
+            return "server.approval.ambiguous-cas.expire";
+        case "cancel":
+            return "server.approval.ambiguous-cas.cancel";
+        case "unreachable":
+            return "server.approval.ambiguous-cas.unreachable";
+        default: {
+            const unreachable = intent;
+            throw new Error(`ambiguousCasFailOpenTag: unknown intent ${String(unreachable)}`);
+        }
+    }
+}
 class ApprovalStoreDeadlineError extends Error {
     constructor(label, timeoutMs) {
         super(`approval store call ${label} timed out after ${timeoutMs}ms`);
@@ -440,26 +454,32 @@ export class ToolApprovalCoordinator {
             return false;
         }
     }
-    async readDecidedForRecovery(askId) {
+    async readRowForRecovery(askId, where) {
         if (!this.askStore)
-            return undefined;
+            return { kind: "absent" };
+        let row;
         try {
-            const row = await this.withStoreDeadline(this.askStore.getAsk(askId), "getAsk(expire-error-recovery)", DURABLE_CONVERGE_READ_TIMEOUT_MS);
-            if (row === null || row.state !== "DECIDED")
-                return undefined;
-            if (replayTerminalAskRow(row) === true && this.abandonedEditedDecisionPending(askId)) {
-                this.guardRowDerivedApprove(askId, true, "expire-error-recovery");
-                return undefined;
-            }
-            if (this.editedDecisionInFlight(askId))
-                return undefined;
-            const replayed = settleArgsOf(replayTerminalAskRow(row));
-            return replayed === "unavailable" ? undefined : replayed;
+            row = await this.withStoreDeadline(this.askStore.getAsk(askId), `getAsk(${where})`, DURABLE_CONVERGE_READ_TIMEOUT_MS);
         }
         catch (err) {
-            this.noteStoreError(err, "getAsk(expire-error-recovery)");
-            return undefined;
+            this.noteStoreError(err, `getAsk(${where})`);
+            return { kind: "unreadable" };
+        }
+        if (row === null)
+            return { kind: "absent" };
+        if (row.state === "STREAM_PENDING") {
+            return this.editedDecisionInFlight(askId) ? { kind: "edit-in-flight" } : { kind: "pending" };
         }
+        const replayed = settleArgsOf(this.guardRowDerivedApprove(askId, replayTerminalAskRow(row), where));
+        if (replayed === "unavailable")
+            return { kind: "parked" };
+        if (!replayed.allowed)
+            return { kind: "denied" };
+        if (replayed.updatedInput !== undefined)
+            return { kind: "approved", updatedInput: replayed.updatedInput };
+        if (this.editedDecisionInFlight(askId))
+            return { kind: "edit-in-flight" };
+        return { kind: "approved" };
     }
     hasOtherSuspendedOwner(askId, self) {
         if (askId === undefined)
@@ -490,13 +510,17 @@ export class ToolApprovalCoordinator {
         const now = Date.now();
         let ownCount = 0;
         let ownExpiredVictim;
+        let ownBridgeVictim;
         let ownPlainVictim;
         let ownEvictable;
         let globalExpiredVictim;
+        let globalBridgeVictim;
         for (const [k, t] of this.parkTombstones) {
             const expired = now - t.parkedAtMs > this.parkTombstoneTtlMs;
             if (globalExpiredVictim === undefined && expired && t.inflight === undefined)
                 globalExpiredVictim = k;
+            if (globalBridgeVictim === undefined && t.kind === "voidBridge" && t.inflight === undefined)
+                globalBridgeVictim = k;
             if (t.owner !== tomb.owner)
                 continue;
             ownCount++;
@@ -506,13 +530,16 @@ export class ToolApprovalCoordinator {
                 ownEvictable = k;
             if (ownExpiredVictim === undefined && expired)
                 ownExpiredVictim = k;
-            if (ownPlainVictim === undefined && t.redeemed === undefined)
+            if (ownBridgeVictim === undefined && t.kind === "voidBridge")
+                ownBridgeVictim = k;
+            if (ownPlainVictim === undefined && t.kind === "park" && t.redeemed === undefined)
                 ownPlainVictim = k;
         }
+        const insertingBridge = tomb.kind === "voidBridge";
         if (ownCount >= effectivePerPrincipalMax) {
-            const victim = ownExpiredVictim ?? ownPlainVictim ?? ownEvictable;
+            const victim = insertingBridge ? (ownExpiredVictim ?? ownBridgeVictim) : (ownExpiredVictim ?? ownBridgeVictim ?? ownPlainVictim ?? ownEvictable);
             if (victim === undefined) {
-                recordFailOpen("server.approval.park-tombstone-global-cap-refused", `owner=${tomb.owner ?? "<none>"} reason=all-inflight`);
+                recordFailOpen("server.approval.park-tombstone-global-cap-refused", `owner=${tomb.owner ?? "<none>"} reason=${insertingBridge ? "bridge-would-evict-redeemable" : "all-inflight"}`);
                 return;
             }
             this.parkTombstones.delete(victim);
@@ -520,8 +547,11 @@ export class ToolApprovalCoordinator {
         else if (this.parkTombstones.size >= this.parkTombstoneMax && globalExpiredVictim !== undefined) {
             this.parkTombstones.delete(globalExpiredVictim);
         }
+        else if (this.parkTombstones.size >= this.parkTombstoneMax && !insertingBridge && globalBridgeVictim !== undefined) {
+            this.parkTombstones.delete(globalBridgeVictim);
+        }
         else if (this.parkTombstones.size >= this.parkTombstoneMax) {
-            recordFailOpen("server.approval.park-tombstone-global-cap-refused", `owner=${tomb.owner ?? "<none>"}`);
+            recordFailOpen("server.approval.park-tombstone-global-cap-refused", `owner=${tomb.owner ?? "<none>"}${insertingBridge ? " reason=bridge-refused-at-global-cap" : ""}`);
             return;
         }
         this.parkTombstones.set(approvalId, tomb);
@@ -878,7 +908,7 @@ export class ToolApprovalCoordinator {
                 sig.removeEventListener("abort", fn);
             this.pending.delete(id);
             if (windowRouteUnavailable && askId !== undefined && batchId !== undefined && this.unattendedOutcome() !== false) {
-                this.recordParkTombstone(wireApprovalId, { askId, batchId, owner: origin.owner, parkedAtMs: Date.now() });
+                this.recordParkTombstone(wireApprovalId, { kind: "park", askId, batchId, owner: origin.owner, parkedAtMs: Date.now() });
                 parkRouted = true;
             }
             if (askId !== undefined) {
@@ -898,39 +928,37 @@ export class ToolApprovalCoordinator {
         const convergeFromDurableState = async (where) => {
             if (!this.askStore || askId === undefined)
                 return;
-            const store = this.askStore;
             const pinnedAskId = askId;
-            for (let attempt = 0; attempt < DURABLE_CONVERGE_BACKOFF_MS.length; attempt++) {
+            for (let attempt = 0; attempt <= DURABLE_CONVERGE_BACKOFF_MS.length; attempt++) {
                 if (done)
                     return;
-                try {
-                    const row = await this.withStoreDeadline(store.getAsk(pinnedAskId), `getAsk(${where})`, DURABLE_CONVERGE_READ_TIMEOUT_MS);
-                    if (done)
-                        return;
-                    if (row === null) {
+                const read = await this.readRowForRecovery(pinnedAskId, `converge:${where}`);
+                if (done)
+                    return;
+                switch (read.kind) {
+                    case "absent":
                         settle(false, "expired");
                         return;
-                    }
-                    if (row.state === "STREAM_PENDING" || this.editedDecisionInFlight(pinnedAskId)) {
-                        await new Promise((r) => setTimeout(r, DURABLE_CONVERGE_BACKOFF_MS[attempt]).unref?.());
+                    case "pending":
+                    case "edit-in-flight":
+                    case "unreadable":
+                        if (attempt < DURABLE_CONVERGE_BACKOFF_MS.length)
+                            await new Promise((r) => setTimeout(r, DURABLE_CONVERGE_BACKOFF_MS[attempt]).unref?.());
                         continue;
-                    }
-                    const outcome = settleArgsOf(this.guardRowDerivedApprove(pinnedAskId, replayTerminalAskRow(row), `converge:${where}`));
-                    if (outcome === "unavailable") {
+                    case "parked":
                         windowRouteUnavailable = true;
                         settle(false, "expired");
-                    }
-                    else if (outcome.allowed) {
-                        settle(true, "allowed", outcome.updatedInput);
-                    }
-                    else {
+                        return;
+                    case "approved":
+                        settle(true, "allowed", read.updatedInput);
+                        return;
+                    case "denied":
                         settle(false, "denied");
+                        return;
+                    default: {
+                        const unreachable = read;
+                        throw new Error(`convergeFromDurableState: unknown recovery read ${String(unreachable)}`);
                     }
-                    return;
-                }
-                catch (err) {
-                    this.noteStoreError(err, `getAsk(${where})`);
-                    await new Promise((r) => setTimeout(r, DURABLE_CONVERGE_BACKOFF_MS[attempt]).unref?.());
                 }
             }
             if (!done) {
@@ -943,6 +971,90 @@ export class ToolApprovalCoordinator {
                 }
             }
         };
+        const recoverFromUnknownStore = async (arm, casStillInFlight) => {
+            if (askId === undefined) {
+                arm.settleByIntent();
+                return;
+            }
+            const pinnedAskId = askId;
+            for (let attempt = 0; attempt <= DURABLE_CONVERGE_BACKOFF_MS.length; attempt++) {
+                if (done)
+                    return;
+                const read = await this.readRowForRecovery(pinnedAskId, `recovery:${arm.intent}`);
+                if (done)
+                    return;
+                switch (read.kind) {
+                    case "approved":
+                        settle(true, "allowed", read.updatedInput);
+                        return;
+                    case "denied":
+                        settle(false, "denied");
+                        return;
+                    case "parked":
+                        windowRouteUnavailable = true;
+                        settle(false, "expired");
+                        return;
+                    case "pending": {
+                        if (casStillInFlight) {
+                            arm.settleByIntent();
+                            return;
+                        }
+                        let result;
+                        try {
+                            result = await arm.cas();
+                        }
+                        catch (err) {
+                            this.noteStoreError(err, arm.storeLabel);
+                            arm.settleByIntent();
+                            return;
+                        }
+                        if (arm.won(result)) {
+                            arm.onWon(result);
+                            return;
+                        }
+                        await convergeFromDurableState(arm.where);
+                        return;
+                    }
+                    case "absent":
+                        arm.settleByIntent();
+                        return;
+                    case "edit-in-flight":
+                    case "unreadable":
+                        if (attempt < DURABLE_CONVERGE_BACKOFF_MS.length)
+                            await new Promise((r) => setTimeout(r, DURABLE_CONVERGE_BACKOFF_MS[attempt]).unref?.());
+                        continue;
+                    default: {
+                        const unreachable = read;
+                        throw new Error(`recoverFromUnknownStore: unknown recovery read ${String(unreachable)}`);
+                    }
+                }
+            }
+            if (done)
+                return;
+            if (this.editedDecisionInFlight(pinnedAskId)) {
+                windowRouteUnavailable = true;
+                settle(false, "expired");
+                return;
+            }
+            recordFailOpen(ambiguousCasFailOpenTag(arm.intent), `askId=${pinnedAskId} reads=${DURABLE_CONVERGE_BACKOFF_MS.length + 1}`);
+            arm.settleByIntent();
+        };
+        const resolveLocalOutcome = async (arm) => {
+            let result;
+            try {
+                result = await arm.cas();
+            }
+            catch (err) {
+                this.noteStoreError(err, arm.storeLabel);
+                await recoverFromUnknownStore(arm, err instanceof ApprovalStoreDeadlineError);
+                return;
+            }
+            if (arm.won(result)) {
+                arm.onWon(result);
+                return;
+            }
+            await convergeFromDurableState(arm.where);
+        };
         const settleParkRouteIfUnsettled = (hostSettledBy) => {
             if (done)
                 return;
@@ -955,34 +1067,30 @@ export class ToolApprovalCoordinator {
                     settleParkRouteIfUnsettled(hostSelfReport);
                     return;
                 }
-                try {
-                    const res = await this.withStoreDeadline(this.askStore.expireAsk(askId, batchId), "expireAsk(window)", DURABLE_CALL_TIMEOUT_MS, (late) => {
+                const store = this.askStore;
+                const pinnedAskId = askId;
+                const pinnedBatchId = batchId;
+                await resolveLocalOutcome({
+                    intent: "expire",
+                    storeLabel: "expireAsk",
+                    where: "windowExpired",
+                    cas: () => this.withStoreDeadline(store.expireAsk(pinnedAskId, pinnedBatchId), "expireAsk(window)", DURABLE_CALL_TIMEOUT_MS, (late) => {
                         if (!late.won)
                             return;
-                        this.settleSameAskIdParkRoute(askId);
+                        this.settleSameAskIdParkRoute(pinnedAskId);
                         this.settleVoidedSiblings(late.voidedSiblings);
-                        this.emitRevokeTo(aliveCtxs, buildRevokeFrame(batchId, late.voidedSiblings, "superseded_by_park", Date.now()));
-                    });
-                    if (res.won) {
+                        this.emitRevokeTo(aliveCtxs, buildRevokeFrame(pinnedBatchId, late.voidedSiblings, "superseded_by_park", Date.now()));
+                    }),
+                    won: (res) => res.won,
+                    onWon: (res) => {
                         windowRouteUnavailable = true;
                         settle(false, "expired");
-                        this.settleSameAskIdParkRoute(askId);
+                        this.settleSameAskIdParkRoute(pinnedAskId);
                         this.settleVoidedSiblings(res.voidedSiblings);
-                        this.emitRevokeTo(aliveCtxs, buildRevokeFrame(batchId, res.voidedSiblings, "superseded_by_park", Date.now()));
-                    }
-                    else {
-                        await convergeFromDurableState("windowExpired");
-                    }
-                }
-                catch (err) {
-                    this.noteStoreError(err, "expireAsk");
-                    const decided = await this.readDecidedForRecovery(askId);
-                    if (decided !== undefined && !done) {
-                        settle(decided.allowed, decided.allowed ? "allowed" : "denied", decided.updatedInput);
-                        return;
-                    }
-                    settleParkRouteIfUnsettled(hostSelfReport);
-                }
+                        this.emitRevokeTo(aliveCtxs, buildRevokeFrame(pinnedBatchId, res.voidedSiblings, "superseded_by_park", Date.now()));
+                    },
+                    settleByIntent: () => settleParkRouteIfUnsettled(hostSelfReport),
+                });
             })();
         };
         const forceParkNow = () => {
@@ -1005,26 +1113,29 @@ export class ToolApprovalCoordinator {
                 settle(false, "expired");
                 return;
             }
-            try {
-                const won = await this.withStoreDeadline(this.askStore.transitionAsk(askId, "STREAM_PENDING", "VOID", { updatedAtMs: Date.now() }), "transitionAsk(cancel)", DURABLE_CALL_TIMEOUT_MS, (lateWon) => {
+            const store = this.askStore;
+            const pinnedAskId = askId;
+            const pinnedBatchId = batchId;
+            await resolveLocalOutcome({
+                intent: "cancel",
+                storeLabel: "transitionAsk(cancel)",
+                where: "runCancel",
+                cas: () => this.withStoreDeadline(store.transitionAsk(pinnedAskId, "STREAM_PENDING", "VOID", { updatedAtMs: Date.now() }), "transitionAsk(cancel)", DURABLE_CALL_TIMEOUT_MS, (lateWon) => {
                     if (!lateWon)
                         return;
-                    this.settleVoidedSiblings([askId]);
-                    this.emitRevokeTo(aliveCtxs, buildRevokeFrame(batchId, [askId], "aborted", Date.now()));
-                });
-                if (won) {
+                    this.settleVoidedSiblings([pinnedAskId]);
+                    this.recordParkTombstone(wireApprovalId, { kind: "voidBridge", askId: pinnedAskId, batchId: pinnedBatchId, owner: origin.owner, parkedAtMs: Date.now() });
+                    this.emitRevokeTo(aliveCtxs, buildRevokeFrame(pinnedBatchId, [pinnedAskId], "aborted", Date.now()));
+                }),
+                won: (won) => won,
+                onWon: () => {
                     settle(false, "expired");
-                    this.settleVoidedSiblings([askId]);
-                    this.emitRevokeTo(aliveCtxs, buildRevokeFrame(batchId, [askId], "aborted", Date.now()));
-                }
-                else {
-                    await convergeFromDurableState("runCancel");
-                }
-            }
-            catch (err) {
-                this.noteStoreError(err, "transitionAsk(cancel)");
-                settle(false, "expired");
-            }
+                    this.settleVoidedSiblings([pinnedAskId]);
+                    this.recordParkTombstone(wireApprovalId, { kind: "voidBridge", askId: pinnedAskId, batchId: pinnedBatchId, owner: origin.owner, parkedAtMs: Date.now() });
+                    this.emitRevokeTo(aliveCtxs, buildRevokeFrame(pinnedBatchId, [pinnedAskId], "aborted", Date.now()));
+                },
+                settleByIntent: () => settle(false, "expired"),
+            });
         };
         if (signal) {
             const onTaskAbort = () => void runCancel();
@@ -1114,31 +1225,42 @@ export class ToolApprovalCoordinator {
         const emitAllP = (async () => {
             const results = await Promise.all(openByCtx.values());
             const anySucceeded = reachability === "unreached" || this.hasOtherSuspendedOwner(askId, selfEntry) || results.some((r) => r.legacy || r.card);
+            emitSettled = true;
             if (!anySucceeded && !done) {
                 if (this.askStore && askId !== undefined && batchId !== undefined) {
-                    try {
-                        const res = await this.withStoreDeadline(this.askStore.expireAsk(askId, batchId), "expireAsk(emit-failed)");
-                        if (res.won && !done) {
-                            emitFailed = true;
-                            settle(false, "expired");
-                            this.settleSameAskIdParkRoute(askId);
+                    const store = this.askStore;
+                    const pinnedAskId = askId;
+                    const pinnedBatchId = batchId;
+                    const settleUnreachable = () => {
+                        if (done)
+                            return;
+                        emitFailed = true;
+                        settle(false, "expired");
+                    };
+                    await resolveLocalOutcome({
+                        intent: "unreachable",
+                        storeLabel: "expireAsk(emit-failed)",
+                        where: "emitFailed",
+                        cas: () => this.withStoreDeadline(store.expireAsk(pinnedAskId, pinnedBatchId), "expireAsk(emit-failed)", DURABLE_CALL_TIMEOUT_MS, (late) => {
+                            if (!late.won)
+                                return;
+                            this.settleSameAskIdParkRoute(pinnedAskId);
+                            this.settleVoidedSiblings(late.voidedSiblings);
+                        }),
+                        won: (res) => res.won,
+                        onWon: (res) => {
+                            settleUnreachable();
+                            this.settleSameAskIdParkRoute(pinnedAskId);
                             this.settleVoidedSiblings(res.voidedSiblings);
-                        }
-                    }
-                    catch (err) {
-                        this.noteStoreError(err, "expireAsk(emit-failed)");
-                        if (!done) {
-                            emitFailed = true;
-                            settle(false, "expired");
-                        }
-                    }
+                        },
+                        settleByIntent: settleUnreachable,
+                    });
                 }
                 else if (!done) {
                     emitFailed = true;
                     settle(false, "expired");
                 }
             }
-            emitSettled = true;
         })();
         await Promise.race([emitAllP, allowedP]);
         const settled = await allowedP;

package/dist/trace/engine-notice-wire.d.ts

@@ -16,7 +16,7 @@
  * 同文件 G1 e2e 的全码扇出夹具、以及契约文档附录 D.3 那张表(含**小节标题里的码数** —— 那道门本批
  * 刚立,立完就在下一次加码时自己咬住了)。
  */
-export declare const ENGINE_NOTICE_WIRE_CODES: readonly ["memory.session_polluted", "memory.harvest_quarantined", "memory.delegation_static_mark_waived", "memory.hold_opened", "memory.hold_released", "memory.hold_disposed", "task.turn_interrupted", "steering.parked_input_blocked", "task.user_steer_undrained", "task.user_followup_undrained", "memory.capture_opted_out", "memory.capture_optout_unpersisted"];
+export declare const ENGINE_NOTICE_WIRE_CODES: readonly ["memory.session_polluted", "memory.harvest_quarantined", "memory.delegation_static_mark_waived", "memory.hold_opened", "memory.hold_released", "memory.hold_disposed", "task.turn_interrupted", "steering.parked_input_blocked", "task.user_steer_undrained", "task.user_followup_undrained", "memory.capture_opted_out", "memory.capture_optout_unpersisted", "task.halt_unconsumed", "task.late_approval"];
 export type EngineNoticeWireCode = (typeof ENGINE_NOTICE_WIRE_CODES)[number];
 /** 白名单谓词(单点):路由与门都读这一个,不许第二处手抄码串。 */
 export declare function isEngineNoticeWireCode(code: string): code is EngineNoticeWireCode;