@sema-agent/server 7.143.0 → 7.145.0

package/dist/parked-revive-surface.d.ts

@@ -24,17 +24,16 @@
  * 近似如实记:重解的列表是**部署缺省**那一份,读不回那一 run 的逐请求差异(`settings.webSearch` 后端、center overlay 场景)——
  * 座只判 bundle 实例的成员性,继承面是 `[...web, ...scaffolds]`,那两项差异不改变谁在面内。
  *
- * **属主来源([ref] / [ref])与交座是两个独立判据**:赎回工具的停驻挂点(复活的子代再要审批时停驻,`plugins/session-store.ts`)按委派继承律定宿主行属主,
- * 律要的是**委派树根的见证**:根 id(行上本来就带 `rootSessionId`)+ 判断那一刻的根行住客 = 写口放行的那一位(赎回腿解析器那一读;不是那一位时
- * 写口整条拒,走不到这里)—— 见证恒带住客。所以**每一行**都交出它({@link ScenarioContext} 的 `delegationRoot`):交座的一层行以
- * `{ sessionId: root, delegationRoot }` 重解,不交座的行(更深的行、根属主不是卡的租户的一层行)以 `{ delegationRoot }` 重解 —— 只喂停驻挂点,不挂任何会话级设施、
- * 不带 principal,交座判据(上面三条)一个字不动。行上没有根 ⇒ boot 期那只裸 Agent(没有根可交 ⇒ 律给哨兵)。挂点那一刻根行已不在 ⇒ 律给哨兵;在而不是见证的那一位
- * (批准之后删了、同 id 被重新登记)⇒ 停驻否决 —— 两件都在挂点那一侧判,与这里无关。
+ * **委派树根见证([ref])与交座是两个独立判据**:Runner 之外复活的后台子代的完成 relay(会话通知门,`session-notify-door.ts`)要**委派树根的见证**:
+ * 根 id(行上本来就带 `rootSessionId`)+ 判断那一刻的根行住客 = 写口放行的那一位(赎回腿解析器那一读;不是那一位时写口整条拒,走不到这里)—— 见证恒带住客。
+ * 所以**每一行**都交出它({@link ScenarioContext} 的 `delegationRoot`):交座的一层行以 `{ sessionId: root, delegationRoot }` 重解,不交座的行(更深的行、根属主不是卡的租户的
+ * 一层行)以 `{ delegationRoot }` 重解 —— 只喂 relay,不挂任何会话级设施、不带 principal,交座判据(上面三条)一个字不动。行上没有根 ⇒ boot 期那只裸 Agent(没有根可交 ⇒ 不接 relay)。
+ * 复活的子代再要审批时的停驻挂点(`plugins/session-store.ts`)不读见证:引擎交它那一行自己的属主,挂点只比对(core 7.62.0 [ref];根见证在挂点的读法随 [ref] P-5 退役)。
  */
 import { type BackgroundAgentRecord, type ToolSpec } from "@sema-agent/core";
 import type { Scenario } from "./capabilities/scenarios.js";
 import type { SessionFace } from "./session-incarnation.js";
-/** 一次赎回用的面:驱动的 Agent 工具(它的停驻挂点绑着行上的根)+ (交座时)与它同出一张列表的继承座。 */
+/** 一次赎回用的面:驱动的 Agent 工具(它的完成 relay 绑着行上的根)+ (交座时)与它同出一张列表的继承座。 */
 export interface ParkedReviveSurface {
     readonly reviveTool: ToolSpec;
     /** 缺席 = 不交座(core fail-closed:复活的子代不继承任何场景层工具)。 */

package/dist/peer-inbound-face.d.ts

@@ -23,33 +23,28 @@
  *    成因会在重判时移动,列 / 决每次都读卡上**当下**的成因。
  *  · **一个调用方、一张卡、一个答案**:决断口只认列表会列出的卡(`decision === "held"` ∧ 可审成因);已批待投(`approved`)/ 已交接(`delivered`)的卡不列、不收。
  *
- * ## 索引(🚧 待 core 的枚举口到货即退役)
- * core 的队列注册表是模块私有的,只能按 (scope, 会话, 箱) 查 —— 宿主拿不到「这个进程里有哪些队列」。本面因此记一张**坐标表**:
- * (会话 id, 车道) —— 只是「去哪儿查」,不是卡,不含任何卡的事实。喂它的是 core 自己的两条通告(经部署级通告转发席,
- * `boot/runner-deps.ts` 的 `createEngineNoticeForwarder`):`peer.inbound_disposition{disposition:"held"}`(成因可审)进表,
- * `peer.held_settled{heldCount:0}` 出表。读的时候每一行都回 core 的队列取当下的卡,表里多一行 = 多查一次空队列,少一行 = 那张卡不列
- * (信仍按 core 的期限带回执过期 —— 安全默认)。退役条件:core 导出进程内 held 队列的枚举(连同各队列的 scope)。
- * 🚧 **坐标不带 scope**(通告 detail 里没有):同一会话 id 在本进程里被两个主体各排空出一只队列时(无主会话行 / 别的主体跑了这只会话),
- * 一只队列清空的那条 `heldCount:0` 把坐标带出表,另一只队列里的卡就不再列出,直到它的下一条 `held`(失败方向 = 上一句的安全默认)。
- * 钉 = `test/peer-inbound-approvals.test.ts` 的 🚧 R2 特征化格;core 请托 = 两条通告的 detail 带队列 scope(或上面的枚举口)。
+ * ## 枚举(core 7.62.0 `listPeerHeldQueues`)
+ * 列与关停都读 core 进程注册表的快照(`listPeerHeldQueues()`:每只队列的 scope / 打开它的会话 / 卡来自哪只箱 / 同一时刻的卡),本面不记任何表 ——
+ * 一张卡在不在、属于哪个 scope、哪只箱,全是那一读。决断口按行 id 的 (会话, 车道, seq) 回 `peerHeldQueueIfAny(调用方 scope, …)` 取同一只队列。
+ * 箱只有两种(会话自己的箱 / 它也排空的 principal 收件箱,core 的快照注逐字);读到第三种 ⇒ 那只队列的卡不列(没有车道就拼不出决断口 id)+ F 类
+ * `server.peer-inbound.queue-box-unknown` 留痕 —— 信仍被扣、按 core 的期限带回执过期(安全默认)。
+ *
+ * ## 到期
+ * 卡上的到期时刻是 core 的 `PeerHeldEntry.deadlineAt`(到期计时武装时在场:可审成因 ∧ 有限 `dialogExpiry` ∧ 卡仍 `held`;成因一动 core 重武装或清掉它)。
+ * 行的 `deadline` 就是它的原值,本仓不按 `heldAt + dialogExpiry` 自算(成因一动就是第二份、错的读法)。
  *
  * ## 关停
  * CC `HBe` 在宿主:core 不调 `PeerHeldQueue.shutdown()`(全库零生产调用点)。{@link PeerInboundFace.shutdown} 在有序关停的审批收尾那一拍
- * (`boot/shutdown.ts`,关池之前)对坐标表里每只队列调它 —— 仍被扣的信按 core 的规则带 `expired` 回执结清(reason `shutdown`)。
- * scope 读自会话行属主(`owner ?? "default"`,与 `boot/session-faces.ts` 信箱腿同读),调用方给读口。
- * 🚧 core 的队列 scope 是排空那条 run 的主体(`spec.principal ?? "default"`):无主会话被具名主体跑过时两者不同,关停找不到那只队列
- * (失败方向同崩溃:信仍被扣在箱里,下一位消费者重新领它)。钉 = 🚧 R4 特征化格;core 请托同上。
- * 🚧 core 的结清回执是投出即返(排空汇点 `void routePeerDeliveryReceipt(…)`):`shutdown()` 兑现时回执可能还没落箱,关池在它之后 ⇒ 那一条回执可能丢
- * (信本身已结清)。宿主没有可等的句柄;core 请托 = `shutdown()` 等回执落箱再兑现。
- */
+ * (`boot/shutdown.ts`,关池之前)对注册表里**每只**队列调它(进程的队列都是本进程的;不求 scope)—— 仍被扣的信按 core 的规则带 `expired` 回执结清
+ * (reason `shutdown`)。core 的 `shutdown()` 等它发出的每条回执落箱再兑现,没落的点名 seq 拒(卡照样全结);各队列互不等,一只拒不挡别的
+ * (`Promise.allSettled`),拒句进读数 `receiptFaults`,由关停链写一行 warn。
+  */
 import { type PeerHeldEntry, type PeerHeldSettleOutcome } from "@sema-agent/core";
 import { type PeerInboundLane } from "./org-delivery-gate.js";
 /**
- * 一个 principal(或会话行属主)的信箱 scope —— core 写侧 `taskScope = spec.principal ?? "default"` 的同一条读法(无主 ⇒ `"default"`)。
- * 列 / 决用调用方的 principal,关停用会话行属主;两者在属主围栏下同值(`resolve-spec.ts` 的 `fenceSessionOwner`),
- * 无主存量会话被具名壳续聊的混属主形是既有残余(`boot/session-faces.ts` 信箱腿同一条登记)。
+ * 调用方 principal 的信箱 scope —— core 写侧 `taskScope = spec.principal ?? "default"` 的同一条读法(无主 ⇒ `"default"`)。列 / 决都按它找队列。
  */
-export declare function peerBoxScope(principalOrOwner: string | null | undefined): string;
+export declare function peerBoxScope(principal: string | null | undefined): string;
 /** 决断口 id 的坐标(id 是它的唯一拼法,见 {@link peerInboundIdOf})。 */
 export interface PeerInboundCoord {
     readonly sessionId: string;
@@ -68,9 +63,9 @@ export declare function parsePeerInboundId(id: string): PeerInboundCoord | undef
  *  · `cause` —— core 的扣信成因(`PeerHeldEntry.cause`,`CrossSessionHoldCause` 闭集);
  *  · `content` / `fromName` —— 信的存储正文(`[summary] message`,core 的规范存储形)与发信方的显示名,**过凭据脱敏**(显示面;与停驻行的工具入参同一条);
  *  · `fromSession` / `fromScope` —— 发信会话 / 跨 principal 投递的发信 scope(core 的 typed 归属锚),在场才带;
- *  · `sentAt` / `heldAt` —— epoch ms。
- * 🚧 **没有 `deadline`**:到期计时在 core 队列里(在扣信、成因变动、换绑时各自起表),卡上不带它;本仓若按 `heldAt + dialogExpiry` 自算,
- * 成因一动就是一个错的截止时刻(第二份读法)。core 给卡加上到期时刻即补上(请托见 [ref] 收车档)。
+ *  · `sentAt` / `heldAt` —— epoch ms;
+ *  · `deadline` —— core 卡上的到期时刻 `deadlineAt` 原值(绝对 epoch ms,与停驻行 `deadline` 同名同义;壳用 `deadline − serverNowMs` 渲倒计时),
+ *    到期计时没武装(`dialogExpiry` 为 `null`)⇒ 缺席。
  */
 export interface PeerInboundPendingRow {
     readonly kind: "peer_inbound";
@@ -81,6 +76,7 @@ export interface PeerInboundPendingRow {
     readonly content: string;
     readonly sentAt: number;
     readonly heldAt: number;
+    readonly deadline?: number;
     readonly fromSession?: string;
     readonly fromName?: string;
     readonly fromScope?: string;
@@ -103,25 +99,24 @@ export type PeerInboundDecideResult = {
     readonly kind: "unrecorded";
     readonly error: unknown;
 };
-/** 关停读数:结清了几只队列、几只会话的 scope 读不出(那几只的卡随进程离开 —— 信仍在箱里被扣着,下一位消费者重新领它)。 */
+/**
+ * 关停读数:`queues` = 关了几只队列(注册表里的每一只,含空的);`cards` = 关停那一刻快照里的卡数;`receiptFaults` = 各只拒了的队列的拒句
+ * (core 点名回执没落箱的 seq —— 卡已结清,只是发信方可能没收到那条 `expired`)。
+ */
 export interface PeerInboundShutdownReading {
     readonly queues: number;
-    readonly scopeUnresolved: number;
+    readonly cards: number;
+    readonly receiptFaults: readonly string[];
 }
 export interface PeerInboundFace {
-    /** 部署级通告转发席的观察口:只读两条码的坐标,其余一概不看。永不抛(转发席不许把异常回抛给引擎)。 */
-    observe(notice: {
-        readonly code: string;
-        readonly detail?: Record<string, unknown>;
-    }): void;
-    /** `scope` 里此刻等人审的信({@link awaitsReview} 的卡),按 `heldAt` 升序(同刻按 id)。 */
+    /** `scope` 里此刻等人审的信({@link awaitsReview} 的卡;读 core 的队列枚举),按 `heldAt` 升序(同刻按 id)。 */
     list(scope: string): PeerInboundPendingRow[];
     /** 决断转发:只认 `scope` 里此刻等人审的那张卡(与 {@link list} 同一只判据);`settle` 抛(店拒了 CAS)⇒ `unrecorded`。 */
     decide(scope: string, coord: PeerInboundCoord, decision: PeerInboundDecision): Promise<PeerInboundDecideResult>;
-    /** 有序关停:坐标表里每只队列 `shutdown()`(core 的规则:仍 held 的卡带 `expired` 回执结清,reason `shutdown`)。 */
-    shutdown(scopeOfSession: (sessionId: string) => Promise<string | undefined>): Promise<PeerInboundShutdownReading>;
+    /** 有序关停:core 注册表里每只队列 `shutdown()`(core 的规则:仍 held 的卡带 `expired` 回执结清,reason `shutdown`;等回执落箱)。永不抛。 */
+    shutdown(): Promise<PeerInboundShutdownReading>;
 }
 export declare function createPeerInboundFace(): PeerInboundFace;
-/** 进程单例 —— 与 core 的 held 队列注册表同一个寿命(进程级);部署级通告转发席与审批路由读的是同一只。 */
+/** 进程单例 —— 决断尾(一张卡一次只过一只决断)是进程级的;审批路由与关停链读的是同一只。 */
 export declare const defaultPeerInboundFace: PeerInboundFace;
 //# sourceMappingURL=peer-inbound-face.d.ts.map

package/dist/peer-inbound-face.js

@@ -1,10 +1,10 @@
-import { PEER_HELD_REVIEW_CAUSES, isPeerSessionId, peerHeldQueueIfAny, } from "@sema-agent/core";
+import { PEER_HELD_REVIEW_CAUSES, isPeerSessionId, listPeerHeldQueues, peerHeldQueueIfAny, } from "@sema-agent/core";
 import { PEER_INBOUND_LANES, boxOfLane, laneOfBox } from "./org-delivery-gate.js";
 import { PEER_INBOUND_ID_PREFIX } from "./approval-queue-kind.js";
 import { recordFailOpen } from "./observability/fail-open.js";
 import { seatText } from "./trace/exit-seat.js";
-export function peerBoxScope(principalOrOwner) {
-    return principalOrOwner ?? "default";
+export function peerBoxScope(principal) {
+    return principal ?? "default";
 }
 export function peerInboundIdOf(c) {
     return `${PEER_INBOUND_ID_PREFIX}${c.sessionId}:${c.lane}:${c.seq}`;
@@ -39,23 +39,18 @@ function rowOf(sessionId, lane, card) {
         content: seatText("peer-inbound-card-text", card.content),
         sentAt: card.sentAt,
         heldAt: card.heldAt,
+        ...(card.deadlineAt !== undefined ? { deadline: card.deadlineAt } : {}),
         ...(fromSession !== undefined ? { fromSession } : {}),
         ...(card.from !== undefined ? { fromName: seatText("peer-inbound-card-text", card.from) } : {}),
         ...(fromScope !== undefined ? { fromScope } : {}),
     };
 }
-function coordinatesOf(code, detail) {
-    const sessionId = detail?.sessionId;
-    const box = detail?.box;
-    if (typeof sessionId === "string" && typeof box === "string" && isPeerSessionId(sessionId)) {
-        const lane = laneOfBox(box, sessionId);
-        if (lane !== undefined)
-            return { sessionId, lane };
-    }
-    recordFailOpen("server.peer-inbound.notice-coordinates-unreadable", `code=${code}`);
-    return undefined;
+function laneOfQueue(q) {
+    const lane = laneOfBox(q.box, q.sessionId);
+    if (lane === undefined)
+        recordFailOpen("server.peer-inbound.queue-box-unknown", `cards=${q.size}`);
+    return lane;
 }
-const indexKey = (e) => JSON.stringify([e.lane, e.sessionId.toLowerCase()]);
 function awaitsReview(card) {
     return card.decision === "held" && isReviewCause(card.cause);
 }
@@ -66,7 +61,6 @@ function queueOf(scope, e) {
     return peerHeldQueueIfAny(scope, e.sessionId, boxOfLane(e.lane));
 }
 export function createPeerInboundFace() {
-    const index = new Map();
     const tails = new WeakMap();
     const serially = (q, seq, step) => {
         const perQueue = tails.get(q) ?? new Map();
@@ -80,37 +74,19 @@ export function createPeerInboundFace() {
         });
     };
     return {
-        observe(notice) {
-            switch (notice.code) {
-                case "peer.inbound_disposition": {
-                    if (notice.detail?.disposition !== "held" || !isReviewCause(notice.detail.cause))
-                        return;
-                    const e = coordinatesOf(notice.code, notice.detail);
-                    if (e !== undefined && !index.has(indexKey(e)))
-                        index.set(indexKey(e), e);
-                    return;
-                }
-                case "peer.held_settled": {
-                    if (notice.detail?.heldCount !== 0)
-                        return;
-                    const e = coordinatesOf(notice.code, notice.detail);
-                    if (e !== undefined)
-                        index.delete(indexKey(e));
-                    return;
-                }
-                default:
-                    return;
-            }
-        },
         list(scope) {
             const rows = [];
-            for (const e of index.values()) {
-                const q = queueOf(scope, e);
-                if (q === undefined)
+            for (const q of listPeerHeldQueues()) {
+                if (q.scope !== scope)
+                    continue;
+                const reviewable = q.entries.filter(awaitsReview);
+                if (reviewable.length === 0)
+                    continue;
+                const lane = laneOfQueue(q);
+                if (lane === undefined)
                     continue;
-                for (const card of q.list())
-                    if (awaitsReview(card))
-                        rows.push(rowOf(e.sessionId, e.lane, card));
+                for (const card of reviewable)
+                    rows.push(rowOf(q.sessionId, lane, card));
             }
             return rows.sort((a, b) => a.heldAt - b.heldAt || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
         },
@@ -131,26 +107,15 @@ export function createPeerInboundFace() {
                 return outcome === "gone" ? { kind: "not_found" } : { kind: "settled", outcome };
             });
         },
-        async shutdown(scopeOfSession) {
-            let queues = 0;
-            let scopeUnresolved = 0;
-            const scopes = new Map();
-            for (const e of [...index.values()]) {
-                const sid = e.sessionId.toLowerCase();
-                if (!scopes.has(sid))
-                    scopes.set(sid, await scopeOfSession(e.sessionId).catch(() => undefined));
-                const scope = scopes.get(sid);
-                if (scope === undefined) {
-                    scopeUnresolved += 1;
-                    continue;
-                }
-                const q = queueOf(scope, e);
-                if (q === undefined)
-                    continue;
-                await q.shutdown();
-                queues += 1;
-            }
-            return { queues, scopeUnresolved };
+        async shutdown() {
+            const snapshots = listPeerHeldQueues();
+            const queues = snapshots.flatMap((s) => {
+                const q = peerHeldQueueIfAny(s.scope, s.sessionId, s.box);
+                return q === undefined ? [] : [q];
+            });
+            const settled = await Promise.allSettled(queues.map((q) => q.shutdown()));
+            const receiptFaults = settled.flatMap((r) => (r.status === "rejected" ? [r.reason instanceof Error ? r.reason.message : String(r.reason)] : []));
+            return { queues: queues.length, cards: snapshots.reduce((n, s) => n + s.size, 0), receiptFaults };
         },
     };
 }

package/dist/plugins/approval-ask-store-file.d.ts

@@ -130,6 +130,11 @@ export declare class FileApprovalAskStore implements ApprovalAskStore {
     private journalV1Records;
     /** 盘上还有 v1 信封记录(随 M34):重放到 v1 记录时置位,任何一次压实(整本重写成 v2)清位 —— 已被压实过的账本不再为升级重写第二次。 */
     private journalV1OnDisk;
+    /**
+     * 盘上还有删行记录({@link ROW_REMOVAL_OPS}):写下一条 / 重放到一条时置位,任何一次压实(整本重写成快照)清位 —— 与 {@link journalV1OnDisk} 同形。
+     * 置位期间压实到期(顶注「压实」段的起因 ②):同一拍压实;压实失败 ⇒ 位留着,下一次写(或下一次起服)再试。
+     */
+    private removalRecordsOnDisk;
     /** 本次启动隔离出去的原件路径(无坏字节 ⇒ `undefined`)。 */
     readonly corruptQuarantinePath: string | undefined;
     /**
@@ -159,11 +164,16 @@ export declare class FileApprovalAskStore implements ApprovalAskStore {
      * 代价如实:不可编码的值(BigInt / 循环引用)在本形上**抛**,而 InMemory 形收得下 —— 那与 SQL 孪生
      * 同向(它也存不下),是**介质事实**,写进顶注的边界段。
      *
-     * 🔴 **压实失败不许落到调用方头上**(替补对抗复审 F3 [medium],实测后修):走到 `maybeCompact()` 时这
+     * 🔴 **压实失败不许落到调用方头上**(替补对抗复审 F3 [medium],实测后修):走到 {@link compactOrRecord} 时这
      * 一次写**已经 fsync 落盘、也已经翻进内存**,把一次纯管家动作的 I/O 错误抛给调用方 = 把一次已生效的
      * 人类批准报成失败(客户端重试会拿到 `ask_not_pending`)。压实是 F 类兜底:失败留痕、下一次写再试。
+     * 两个起因同一条:删行记录引起的压实失败,位({@link removalRecordsOnDisk})留着,下一次**任何**写(与下一次起服)再试 ——
+     * 不是等下一次真删了行的调用。三只删行动词的内核体全是同步前缀,所以走到这里时被删的行已经不在内存里,快照里没有它们。
      */
     private write;
+    /** 压实到期就压实;失败 ⇒ 登记过的 F 类兜底(计数 + 留痕),不上抛 —— `write()` 尾段与起服各调一次,同一句话。 */
+    private compactOrRecord;
+    /** 压实是否到期(顶注「压实」段两个起因)。到期 ⇒ 压实;失败原样抛给 {@link compactOrRecord}。 */
     private maybeCompact;
     /** 整本重写成行快照 + 原子替换。失败 ⇒ 原账本原样留着、`records` 不动(下一次写再试),日志由
      *  core 的 [ref] 惰性重开接住 —— 一次瞬时 I/O 错误绝不把这条日志变成砖。 */
@@ -193,8 +203,12 @@ export declare class FileApprovalAskStore implements ApprovalAskStore {
     abortBatch(batchId: string): Promise<string[]>;
     deferReconcile(askId: string, expectedState: AskState, expectedRev: number, nowMs: number): Promise<boolean>;
     resolveProvisional(askId: string, from: AskState, to: AskState, patch: AskTransitionPatch): Promise<boolean>;
+    /** 删一个 run 名下的全部问行与批行。与两只留存动词同律:内核的纯读选择为空 ⇒ 不落账本、不压实;否则「先落账、再翻内存」并同拍压实(顶注「压实」段起因 ②)。 */
     deleteByTask(taskId: string): Promise<void>;
-    /** 留存律的问行半场(谓词在内核,见接口注)。空的一次(内核的纯读选择为空)不落账本、不碰内存;否则照常「先落账、再翻内存」。 */
+    /**
+     * 留存律的问行半场(谓词在内核,见接口注)。空的一次(内核的纯读选择为空)不落账本、不碰内存、不压实;否则照常「先落账、再翻内存」,
+     * 并在 `write()` 尾段同一拍压实(顶注「压实」段起因 ②)—— 选择非空 ⇒ 内核同步前缀里必删 ≥ 1 行,被删行的字节不留在盘上。
+     */
     reapSettledAsks(cutoffMs: number, limit: number, keepAnchors: ReadonlySet<string>): Promise<number>;
     /** 留存律的批行半场(同上)。 */
     reapEmptyBatches(cutoffMs: number, limit: number): Promise<number>;

package/dist/plugins/approval-ask-store-file.js

@@ -28,6 +28,7 @@ const JOURNAL_OPS = [
 ];
 const JOURNAL_OP_WORDS = new Set(JOURNAL_OPS);
 export const JOURNAL_OP_TABLE_GATE = true;
+const ROW_REMOVAL_OPS = new Set(["reapSettledAsks", "reapEmptyBatches", "deleteByTask"]);
 const JOURNAL_V1_CLAIM_INTENTS = ["expire", "cancel"];
 const JOURNAL_V1_CLAIM_INTENT_WORDS = new Set(JOURNAL_V1_CLAIM_INTENTS);
 const JOURNAL_ENVELOPE = 2;
@@ -94,6 +95,7 @@ export class FileApprovalAskStore {
     corruptLineCount = 0;
     journalV1Records = 0;
     journalV1OnDisk = false;
+    removalRecordsOnDisk = false;
     corruptQuarantinePath;
     constructor(root) {
         const dir = join(root, APPROVAL_ASK_DIR);
@@ -117,6 +119,9 @@ export class FileApprovalAskStore {
                 `and rewrote the live journal from the replayed state. A dropped record is a LOST approval-ask transition: inspect the quarantined file.`);
             this.compact();
         }
+        else if (this.removalRecordsOnDisk) {
+            this.compactOrRecord();
+        }
     }
     clockRead() {
         const pinned = this.pinnedNow;
@@ -136,6 +141,8 @@ export class FileApprovalAskStore {
         const onDisk = { v: JOURNAL_ENVELOPE, k: "op", t, ...callToDisk(encoded) };
         this.logFor().append(onDisk, true);
         this.records += 1;
+        if (ROW_REMOVAL_OPS.has(call.op))
+            this.removalRecordsOnDisk = true;
         this.pinnedNow = t;
         let out;
         try {
@@ -144,15 +151,22 @@ export class FileApprovalAskStore {
         finally {
             this.pinnedNow = null;
         }
+        this.compactOrRecord();
+        return out;
+    }
+    compactOrRecord() {
         try {
             this.maybeCompact();
         }
         catch (e) {
             recordFailOpen("server.approval-ask-journal.compaction-failed", `path=${this.path} err=${e instanceof Error ? e.message : String(e)}`);
         }
-        return out;
     }
     maybeCompact() {
+        if (this.removalRecordsOnDisk) {
+            this.compact();
+            return;
+        }
         if (this.records < ASK_JOURNAL_COMPACT_MIN_RECORDS)
             return;
         const snapshot = this.core.exportRows();
@@ -168,6 +182,7 @@ export class FileApprovalAskStore {
         this.log?.closeForSwap();
         atomicWriteFile(this.tmpDir, this.path, lines.join(""));
         this.journalV1OnDisk = false;
+        this.removalRecordsOnDisk = false;
         this.records = lines.length;
     }
     replayRecord(disk) {
@@ -203,6 +218,8 @@ export class FileApprovalAskStore {
             refuse("unknown record kind");
         if (typeof probe.op !== "string" || !JOURNAL_OP_WORDS.has(probe.op))
             refuse("verb outside this build's closed set (a DOWNGRADE: a newer server wrote it)");
+        if (typeof probe.op === "string" && ROW_REMOVAL_OPS.has(probe.op))
+            this.removalRecordsOnDisk = true;
         if (typeof probe.t !== "number" || !Number.isFinite(probe.t))
             refuse("call record without a clock reading");
         if (probe.op === "claimTerminal" && !JOURNAL_V1_CLAIM_INTENT_WORDS.has(String(raw.intent)))
@@ -301,6 +318,9 @@ export class FileApprovalAskStore {
         return this.write({ op: "resolveProvisional", askId, from, to, patch }, (c) => this.core.resolveProvisional(c.askId, c.from, c.to, c.patch));
     }
     async deleteByTask(taskId) {
+        const plan = this.core.planDeleteByTask(taskId);
+        if (plan.askIds.length === 0 && plan.batchIds.length === 0)
+            return;
         return this.write({ op: "deleteByTask", taskId }, (c) => this.core.deleteByTask(c.taskId));
     }
     async reapSettledAsks(cutoffMs, limit, keepAnchors) {

package/dist/plugins/approval-ask-store-memory.d.ts

@@ -16,8 +16,9 @@
  *  · {@link InMemoryApprovalAskStore.exportRows} / {@link InMemoryApprovalAskStore.importRows} —— 压实用的
  *    整本快照口(纯搬行,不经任何谓词)。压实要把「一串调用」折成「一串终局行」,没有这一对就只能在
  *    File 形里另写一套「哪些行还算数」的判据 —— 那才是第二份手抄。
- *  · {@link InMemoryApprovalAskStore.planReapSettledAsks} / {@link InMemoryApprovalAskStore.planReapEmptyBatches} —— 两只留存动词的
- *    **纯读选择**(删哪些行)。File 形据它判「这一次有没有东西可删」,空的一次不落账本;删除本身仍是接口动词,与选择共用这一只。
+ *  · {@link InMemoryApprovalAskStore.planReapSettledAsks} / {@link InMemoryApprovalAskStore.planReapEmptyBatches} /
+ *    {@link InMemoryApprovalAskStore.planDeleteByTask} —— 三只删行动词的**纯读选择**(删哪些行)。File 形据它判「这一次有没有东西可删」,空的一次不落账本;
+ *    删除本身仍是接口动词,与选择共用这一只。
  *  · {@link InMemoryApprovalAskStore.peekAsk} —— 一行的**同步**点读(纯读,零判定)。File 形在写口的同步前缀里据它判「这次决议在不在
  *    属主域内」(出域的一次不落账本)、重放时据它喂行自己的属主([ref],理由在 File 形的 `decideAsk`)。
  *
@@ -118,6 +119,11 @@ export declare class InMemoryApprovalAskStore implements ApprovalAskStore {
     getByIdempotencyKey(taskId: string, key: string): Promise<AskRow | null>;
     resolveProvisional(askId: string, from: AskState, to: AskState, patch: AskTransitionPatch): Promise<boolean>;
     deleteByTask(taskId: string): Promise<void>;
+    /** {@link deleteByTask} 会删哪些行(纯读,零写;选择与删除共用这一只,没有第二份谓词)。 */
+    planDeleteByTask(taskId: string): {
+        readonly askIds: readonly string[];
+        readonly batchIds: readonly string[];
+    };
     getBatch(batchId: string): Promise<BatchRow | null>;
     /**
      * 留存律的问行半场(谓词见接口注,与 SQL twin 的 `DELETE … LIMIT` 同答)。方法体全同步(零 `await`)⇒ File 形把它当一次落账的调用

package/dist/plugins/approval-ask-store-memory.js

@@ -365,14 +365,17 @@ export class InMemoryApprovalAskStore {
         return true;
     }
     async deleteByTask(taskId) {
-        for (const [id, r] of this.asks) {
-            if (r.taskId === taskId)
-                this.asks.delete(id);
-        }
-        for (const [id, b] of this.batches) {
-            if (b.taskId === taskId)
-                this.batches.delete(id);
-        }
+        const plan = this.planDeleteByTask(taskId);
+        for (const id of plan.askIds)
+            this.asks.delete(id);
+        for (const id of plan.batchIds)
+            this.batches.delete(id);
+    }
+    planDeleteByTask(taskId) {
+        return {
+            askIds: [...this.asks.values()].filter((r) => r.taskId === taskId).map((r) => r.askId),
+            batchIds: [...this.batches.values()].filter((b) => b.taskId === taskId).map((b) => b.batchId),
+        };
     }
     async getBatch(batchId) {
         const b = this.batches.get(batchId);

package/dist/plugins/caching-session-store.d.ts

@@ -4,7 +4,6 @@ import type { StagingHandle } from "../session-sync-kernel.js";
 import { type PlacementAcquireOpts } from "./session-placement.js";
 import type { InstructionSourceStore } from "../instruction-source-notice.js";
 import type { SessionWorkspaceStore } from "../session-workspace.js";
-import type { OwnerlessClaim } from "../delegated-session-owner.js";
 export interface CachingOptions {
     /** Idle seconds a woken session is kept warm. 0 disables caching (pure passthrough). */
     ttlSec: number;
@@ -57,8 +56,6 @@ export declare class CachingSessionStore implements SessionStore {
      *  k8s 工作区空间 / SSE 探针 / resume-at 读的都是本类。 */
     readonly headOf: SessionHeadReader["headOf"];
     readonly register?: (sessionId: string, owner: string | null) => Promise<void>;
-    /** [ref] 委派继承律的认领口,纯转发(写的是行上的属主那一格 —— 只 CAS 子行自己,不碰暖缓存里的会话;停驻挂点在默认部署上读的就是本类 —— 与 `placementOf` 同转发同缺:内店记录委派树 ⇒ 两只都在)。 */
-    readonly claimOwnerless?: OwnerlessClaim;
     /** Delegated SessionRepo seam (§0.5) — list/fork/delete operate on the DURABLE tables directly (they bypass the
      *  warm cache by design; a fork/delete must read/write durable state, not a possibly-stale cached view). */
     readonly listSessions?: (opts: {
@@ -119,6 +116,9 @@ export declare class CachingSessionStore implements SessionStore {
      *  裸店、不经本包装,但 security.ts 的 OwnerAwareSessionStore 契约列了它 —— 经 sessionStorage 消费的
      *  未来调用方不该静默 no-op,与 beginImportStaging 同批补齐(同一类白名单缺口)。 */
     readonly sweepStagingSessions?: () => Promise<number>;
+    /** 带戳存档的早拒口(local 店独有;`OwnerAwareSessionStore.assertArchiveAnonymous`),读持久存档头、不经暖缓存。
+     *  🔴 必须转发(与 staging 族同一条教训):默认部署把真店包进本类,会话同步第一阶段的路由读到的是包装层 —— 不转发 = 这一口在默认部署上静默不发(第一阶段仍答通用冲突),没有任何一处报错。 */
+    readonly assertArchiveAnonymous?: (sessionId: string) => Promise<void>;
     /** 2c session-sync (§7/§8) — delegated IDEMPOTENT replace; like importEntries it writes durable state under
      *  `sessionId`, so a stale warm handle for that id is evicted on success (next acquire re-wakes from the new log). */
     readonly replaceEntries?: (sessionId: string, owner: string | null, entries: SessionTreeEntry[]) => Promise<void>;

package/dist/plugins/caching-session-store.js

@@ -9,7 +9,6 @@ export class CachingSessionStore {
     onStaleHit;
     headOf;
     register;
-    claimOwnerless;
     listSessions;
     fork;
     forkTo;
@@ -30,6 +29,7 @@ export class CachingSessionStore {
     importEntries;
     beginImportStaging;
     sweepStagingSessions;
+    assertArchiveAnonymous;
     replaceEntries;
     retention;
     placements;
@@ -56,8 +56,6 @@ export class CachingSessionStore {
         const ownerAware = inner;
         if (ownerAware.register)
             this.register = ownerAware.register.bind(inner);
-        if (ownerAware.claimOwnerless)
-            this.claimOwnerless = ownerAware.claimOwnerless.bind(inner);
         if (ownerAware.listSessions)
             this.listSessions = ownerAware.listSessions.bind(inner);
         if (ownerAware.sessionSummaryOf)
@@ -88,6 +86,8 @@ export class CachingSessionStore {
             this.listEntryIds = ownerAware.listEntryIds.bind(inner);
         if (ownerAware.exportEntriesStream)
             this.exportEntriesStream = ownerAware.exportEntriesStream.bind(inner);
+        if (ownerAware.assertArchiveAnonymous)
+            this.assertArchiveAnonymous = ownerAware.assertArchiveAnonymous.bind(inner);
         this.forget = (sessionId) => {
             this.evict(sessionId);
             return inner.forget?.(sessionId);