@sema-agent/server 7.141.0 → 7.143.0

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

@@ -4,7 +4,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { isDeepStrictEqual } from "node:util";
 import { dirname, join, resolve } from "node:path";
 import { assertFirstOwnerWritable, forkOwnerOf, importerOwnerOf } from "./session-ownership.js";
-import { StampedSessionArchiveError } from "../session-error-wire.js";
+import { SessionOwnerUnreadableError, StampedSessionArchiveError, sessionUnreadableOf } from "../session-error-wire.js";
 import { FileSessionRepo, SessionError, StoredSession, admitSessionPlacement, atomicWriteFile, sessionLogMarkOf, settledForkOptions, uuidv7, validateEntriesForImport } from "@sema-agent/core";
 import { createPlacedSessionRow, sourceFacesVia } from "../delegated-session-owner.js";
 import { placementCapabilityOf } from "./session-placement.js";
@@ -54,6 +54,12 @@ function unusableArchiveOf(word, fault) {
     const code = fault instanceof SessionError ? undefined : fault?.code;
     return { state: "unusable", word, fault, ...(word === "storage" && typeof code === "string" ? { errno: code } : {}) };
 }
+function ownerUnreadableArchive(probe) {
+    const { fault } = probe;
+    if (probe.word === "storage" || !(fault instanceof SessionError))
+        return probe;
+    return { ...probe, fault: new SessionOwnerUnreadableError(probe.word, fault) };
+}
 function importRowRefused(sessionId, landing) {
     return new SessionError("conflict", landing === "create"
         ? `session ${sessionId} already exists — importEntries only creates a session (replaceEntries rewrites one); nothing was written`
@@ -597,7 +603,7 @@ export class LocalSessionStore {
             return { state: "found", meta: readSessionMetaCell(cell) };
         const probe = await this.probeArchive(sessionId);
         if (probe.state === "unusable")
-            return probe;
+            return ownerUnreadableArchive(probe);
         if (probe.state === "absent")
             return { state: "absent" };
         const meta = await this.cellOfPresent(sessionId);
@@ -677,7 +683,7 @@ export class LocalSessionStore {
     }
     async lockedRowOf(sessionId) {
         const meta = this.metaCellOf(sessionId);
-        if (meta === undefined || (await this.listedMeta(sessionId)) === undefined)
+        if (meta === undefined || (await this.rowHeaderOf(sessionId)) === undefined)
             return undefined;
         return { owner: meta.owner ?? null, incarnation: incarnationFromCell(sessionId, meta.incarnation, "absent"), placed: false, mirror: meta.execution?.role === "mirror", cells: this.rowCellsOf(sessionId) };
     }
@@ -713,19 +719,62 @@ export class LocalSessionStore {
     }
     async listRowOf(sessionId) {
         await this.loadRowSidecars();
-        const listed = await this.listedMeta(sessionId);
+        const header = await this.rowHeaderOf(sessionId);
         const meta = this.metaCellOf(sessionId);
-        if (listed === undefined || meta === undefined)
+        if (header === undefined || meta === undefined)
             return undefined;
-        return { row: await this.summaryOf(listed, await this.runRollups()), occupant: { owner: meta.owner ?? null, incarnation: incarnationFromCell(sessionId, meta.incarnation, "absent") } };
+        return { row: await this.summaryOf(await this.listedRowOf(header), await this.runRollups()), occupant: { owner: meta.owner ?? null, incarnation: incarnationFromCell(sessionId, meta.incarnation, "absent") } };
     }
     async sessionSummaryOf(sessionId) {
         await this.loadRowSidecars();
-        const meta = await this.listedMeta(sessionId);
-        return meta === undefined ? undefined : this.summaryOf(meta, await this.runRollups());
+        const header = await this.rowHeaderOf(sessionId);
+        return header === undefined ? undefined : this.summaryOf(await this.listedRowOf(header), await this.runRollups());
+    }
+    async rowHeaders() {
+        await this.meta.ensureLoaded();
+        const listed = await this.repo.list();
+        const listedIds = new Set(listed.map((row) => row.id));
+        const placed = this.createPlacedIdsReader();
+        const rows = listed.map((header) => ({ sessionId: header.id, header }));
+        for (const id of [...this.meta.state.entries.keys()].sort()) {
+            if (listedIds.has(id))
+                continue;
+            const row = await this.headerUnreadableRowOf(id, placed);
+            if (row !== undefined)
+                rows.push(row);
+        }
+        return rows;
+    }
+    async rowHeaderOf(sessionId) {
+        await this.meta.ensureLoaded();
+        const header = (await this.repo.list()).find((m) => m.id === sessionId);
+        if (header !== undefined)
+            return { sessionId, header };
+        return this.meta.state.entries.has(sessionId) ? this.headerUnreadableRowOf(sessionId, this.createPlacedIdsReader()) : undefined;
+    }
+    async headerUnreadableRowOf(sessionId, placed) {
+        try {
+            await this.archiveHeadOf(sessionId);
+            return undefined;
+        }
+        catch (fault) {
+            return (await placed()).has(sessionId) ? undefined : { sessionId, headerFault: fault };
+        }
+    }
+    createPlacedIdsReader() {
+        let ids;
+        return () => (ids ??= (async () => new Set((await this.listPlaced?.("subagent"))?.map((row) => row.sessionId) ?? []))());
     }
-    async listedMeta(sessionId) {
-        return (await this.repo.list()).find((m) => m.id === sessionId);
+    async listedRowOf(row) {
+        if ("headerFault" in row)
+            return { sessionId: row.sessionId, unreadable: row.headerFault };
+        try {
+            await this.archiveHeadOf(row.sessionId);
+            return { sessionId: row.sessionId, readable: row.header };
+        }
+        catch (fault) {
+            return { sessionId: row.sessionId, unreadable: fault };
+        }
     }
     async readInstructionSource(sessionId) {
         await this.instructionSources.ensureLoaded();
@@ -953,14 +1002,16 @@ export class LocalSessionStore {
     }
     async listSessions(opts) {
         await this.loadRowSidecars();
-        const metas = await this.repo.list();
+        const rows = [];
+        for (const header of await this.rowHeaders())
+            rows.push(await this.listedRowOf(header));
         const rollups = await this.runRollups();
         const all = [];
-        for (const meta of metas) {
-            const owner = this.ownerCellOf(meta.id);
+        for (const row of rows) {
+            const owner = this.ownerCellOf(row.sessionId);
             if (opts.owner !== undefined && owner !== opts.owner && !(opts.includeUnowned === true && owner === null))
                 continue;
-            all.push(await this.summaryOf(meta, rollups));
+            all.push(await this.summaryOf(row, rollups));
         }
         const qlc = opts.q?.toLowerCase();
         const filtered = qlc ? all.filter((r) => r.objectivePreview?.toLowerCase().includes(qlc)) : all;
@@ -983,23 +1034,25 @@ export class LocalSessionStore {
         const cell = this.meta.state.entries.get(sessionId);
         return cell === undefined ? null : (readSessionMetaCell(cell).owner ?? null);
     }
-    async summaryOf(meta, rollups) {
-        const firstActivityAt = rowCreatedAtOf(meta.id, this.metaCellOf(meta.id));
-        const owner = this.ownerCellOf(meta.id);
-        const cells = this.rowCellsOf(meta.id);
-        const rowTag = this.rowTagKeyOf(meta.id, owner, cells);
-        const lastActivityAt = this.lastActivity.get(meta.id) ?? firstActivityAt;
-        const objectivePreview = await this.previewOf(meta);
+    async summaryOf(listed, rollups) {
+        const { sessionId } = listed;
+        const firstActivityAt = rowCreatedAtOf(sessionId, this.metaCellOf(sessionId));
+        const owner = this.ownerCellOf(sessionId);
+        const cells = this.rowCellsOf(sessionId);
+        const rowTag = this.rowTagKeyOf(sessionId, owner, cells);
+        const lastActivityAt = this.lastActivity.get(sessionId) ?? firstActivityAt;
+        const objectivePreview = "readable" in listed ? await this.previewOf(listed.readable) : null;
         return {
-            sessionId: meta.id,
+            sessionId,
             owner,
             lastActivityAt,
             firstActivityAt,
             objectivePreview,
-            ...this.runProjectionOf(meta.id, rollups),
+            ...this.runProjectionOf(sessionId, rollups),
             title: cells.title,
             pinned: cells.pinned,
             ...rowTag,
+            ...("unreadable" in listed ? { unreadable: sessionUnreadableOf(listed.unreadable) } : {}),
         };
     }
     rowTagKeyOf(sessionId, owner, cells) {
@@ -1381,19 +1434,16 @@ export class LocalSessionStore {
         if (!this.repo.readRow || !this.repo.importEntries)
             throw new SessionError("storage", "LocalSessionStore: the one-time migration M33 needs a session repo that reads a whole row and imports a log (readRow / importEntries)");
         await this.meta.ensureLoaded();
-        const listed = await this.repo.list();
-        const listedIds = new Set(listed.map((row) => row.id));
+        const rowHeaders = await this.rowHeaders();
+        const listed = [];
         const unreadable = [];
-        for (const id of [...this.meta.state.entries.keys()].sort()) {
-            if (listedIds.has(id))
+        for (const row of rowHeaders) {
+            if ("header" in row) {
+                listed.push(row.header);
                 continue;
-            try {
-                await this.archiveHeadOf(id);
-            }
-            catch (e) {
-                const errno = errnoOf(e);
-                unreadable.push({ sessionId: id, ...(errno !== undefined ? { errno } : {}) });
             }
+            const errno = errnoOf(row.headerFault);
+            unreadable.push({ sessionId: row.sessionId, ...(errno !== undefined ? { errno } : {}) });
         }
         let rowFactsBackfilled = 0;
         const committed = await this.meta.commit((draft) => {

package/dist/plugins/local-task-attachment-store.d.ts

@@ -1,18 +1,28 @@
-import { type TaskAttachmentStore, type TaskAttachmentRecord } from "./task-attachment-store.js";
+import { type AttachmentStoreBindOutcome, type TaskAttachmentStore, type TaskAttachmentRecord } from "./task-attachment-store.js";
 export declare class LocalTaskAttachmentStore implements TaskAttachmentStore {
     private readonly dir;
     private metas;
     private hydration;
+    /** 变更串行段的尾(见 `serialized`):每只变更口排在上一只的落盘与合回之后。本店唯一一只。 */
+    private mutationTail;
     constructor(rootDir: string);
     private hydrate;
+    /**
+     * 本店**唯一**的变更串行段:凡改 `this.metas` 或删盘上行的口(put / bind / delete / deleteBySession / reapUnbound)把**整条操作**
+     * (判 + 落盘 + 合回内存)交进来,于是任何一只变更口都观察不到别的变更口做到一半的中间态 —— bind 落盘期间「副本已判、内存未合」
+     * 的那一段,收割 / 删除既不会判到旧内存、也不会把盘上正在落的行删掉。读口不进来:它们只读内存,不排队。
+     * 一只变更失败不堵后面的(尾巴吞掉失败,错原样上抛给它自己的调用方)。操作体里不得再调 `serialized`(会排在自己后面)。
+     */
+    private serialized;
     put(rec: TaskAttachmentRecord & {
         content: Uint8Array;
     }): Promise<void>;
     get(owner: string, id: string): Promise<TaskAttachmentRecord | null>;
     getContent(owner: string, id: string): Promise<Uint8Array | null>;
     private persistMeta;
-    bind(owner: string, ids: string[], sessionId: string, boundAtMs: number): Promise<number>;
+    bind(owner: string, ids: readonly string[], sessionId: string, boundAtMs: number): Promise<AttachmentStoreBindOutcome>;
     listBySession(sessionId: string): Promise<TaskAttachmentRecord[]>;
+    /** 删一行(meta + bytes + 内存索引)。只在 `serialized` 的操作体里调用。 */
     private removeRow;
     delete(owner: string, id: string): Promise<boolean>;
     deleteBySession(sessionId: string): Promise<number>;

package/dist/plugins/local-task-attachment-store.js

@@ -1,6 +1,6 @@
 import { promises as fsp } from "node:fs";
 import { join } from "node:path";
-import { TaskAttachmentRecordSchema } from "./task-attachment-store.js";
+import { bindRowsInProcess, TaskAttachmentRecordSchema } from "./task-attachment-store.js";
 import { createZodColumnReader, decodeJsonColumn } from "./sql-json-column.js";
 const ID_RE = /^[0-9a-f-]{16,64}$/i;
 const readAttachmentMeta = createZodColumnReader(TaskAttachmentRecordSchema);
@@ -8,6 +8,7 @@ export class LocalTaskAttachmentStore {
     dir;
     metas;
     hydration;
+    mutationTail = Promise.resolve();
     constructor(rootDir) {
         this.dir = join(rootDir, "attachments");
     }
@@ -37,17 +38,24 @@ export class LocalTaskAttachmentStore {
         })();
         return this.hydration;
     }
-    async put(rec) {
-        const metas = await this.hydrate();
-        await fsp.mkdir(this.dir, { recursive: true });
-        const { content, ...meta } = rec;
-        const binTmp = join(this.dir, `${rec.id}.bin.tmp`);
-        const metaTmp = join(this.dir, `${rec.id}.json.tmp`);
-        await fsp.writeFile(binTmp, Buffer.from(content));
-        await fsp.rename(binTmp, join(this.dir, `${rec.id}.bin`));
-        await fsp.writeFile(metaTmp, JSON.stringify(meta));
-        await fsp.rename(metaTmp, join(this.dir, `${rec.id}.json`));
-        metas.set(rec.id, { ...meta });
+    serialized(op) {
+        const run = this.mutationTail.then(op);
+        this.mutationTail = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    put(rec) {
+        return this.serialized(async () => {
+            const metas = await this.hydrate();
+            await fsp.mkdir(this.dir, { recursive: true });
+            const { content, ...meta } = rec;
+            const binTmp = join(this.dir, `${rec.id}.bin.tmp`);
+            const metaTmp = join(this.dir, `${rec.id}.json.tmp`);
+            await fsp.writeFile(binTmp, Buffer.from(content));
+            await fsp.rename(binTmp, join(this.dir, `${rec.id}.bin`));
+            await fsp.writeFile(metaTmp, JSON.stringify(meta));
+            await fsp.rename(metaTmp, join(this.dir, `${rec.id}.json`));
+            metas.set(rec.id, { ...meta });
+        });
     }
     async get(owner, id) {
         const m = (await this.hydrate()).get(id);
@@ -69,19 +77,29 @@ export class LocalTaskAttachmentStore {
         await fsp.writeFile(tmp, JSON.stringify(m));
         await fsp.rename(tmp, join(this.dir, `${m.id}.json`));
     }
-    async bind(owner, ids, sessionId, boundAtMs) {
-        const metas = await this.hydrate();
-        let bound = 0;
-        for (const id of ids) {
-            const m = metas.get(id);
-            if (!m || m.owner !== owner)
-                continue;
-            m.sessionId = sessionId;
-            m.boundAtMs = boundAtMs;
-            await this.persistMeta(m);
-            bound++;
-        }
-        return bound;
+    bind(owner, ids, sessionId, boundAtMs) {
+        return this.serialized(async () => {
+            const metas = await this.hydrate();
+            const draft = new Map(metas);
+            for (const id of new Set(ids)) {
+                const row = metas.get(id);
+                if (row !== undefined)
+                    draft.set(id, { ...row });
+            }
+            const { outcome, claimed } = bindRowsInProcess(draft, owner, ids, sessionId, boundAtMs);
+            const landed = [];
+            try {
+                for (const m of claimed) {
+                    await this.persistMeta(m);
+                    landed.push(m);
+                }
+            }
+            finally {
+                for (const m of landed)
+                    metas.set(m.id, m);
+            }
+            return outcome;
+        });
     }
     async listBySession(sessionId) {
         const metas = await this.hydrate();
@@ -95,26 +113,32 @@ export class LocalTaskAttachmentStore {
         await fsp.rm(join(this.dir, `${id}.bin`), { force: true });
         this.metas?.delete(id);
     }
-    async delete(owner, id) {
-        const m = (await this.hydrate()).get(id);
-        if (!m || m.owner !== owner)
-            return false;
-        await this.removeRow(id);
-        return true;
+    delete(owner, id) {
+        return this.serialized(async () => {
+            const m = (await this.hydrate()).get(id);
+            if (!m || m.owner !== owner)
+                return false;
+            await this.removeRow(id);
+            return true;
+        });
     }
-    async deleteBySession(sessionId) {
-        const metas = await this.hydrate();
-        const hit = [...metas.values()].filter((m) => m.sessionId === sessionId);
-        for (const m of hit)
-            await this.removeRow(m.id);
-        return hit.length;
+    deleteBySession(sessionId) {
+        return this.serialized(async () => {
+            const metas = await this.hydrate();
+            const hit = [...metas.values()].filter((m) => m.sessionId === sessionId);
+            for (const m of hit)
+                await this.removeRow(m.id);
+            return hit.length;
+        });
     }
-    async reapUnbound(olderThanMs) {
-        const metas = await this.hydrate();
-        const hit = [...metas.values()].filter((m) => m.sessionId === undefined && m.createdAtMs < olderThanMs);
-        for (const m of hit)
-            await this.removeRow(m.id);
-        return hit.length;
+    reapUnbound(olderThanMs) {
+        return this.serialized(async () => {
+            const metas = await this.hydrate();
+            const hit = [...metas.values()].filter((m) => m.sessionId === undefined && m.createdAtMs < olderThanMs);
+            for (const m of hit)
+                await this.removeRow(m.id);
+            return hit.length;
+        });
     }
 }
 //# sourceMappingURL=local-task-attachment-store.js.map

package/dist/plugins/mailbox-recipient-lifecycle.d.ts

@@ -1,11 +1,8 @@
 /**
- * 信箱**收件人生命周期面**([ref])—— core `MailboxStore` 契约里被点名、但机制**刻意不由 core 命名**的
- * 那一半:「这个收件人正在被部署删掉」。
- *
- * core 的原话(`core/store-contracts/mailbox-store-contract.ts` 的 `MailboxTombstonedRecipientContractHooks`
- * 逐字):「Put `(scope, handle)` into the deployment's PRE-DELETE state — whatever that is for this backend
- * (a cascade marking the session row, a `deleting` column, a tombstone table). Core does not name the
- * mechanism, only what `append` must then do.」 ⇒ 本文件就是 server 侧那个 "whatever"。
+ * 信箱**收件人生命周期面**([ref])—— 「这个收件人正在被部署删掉」。core 7.61.0 起它是 `MailboxStore` 契约里的一对可选成员
+ * (`retireRecipient` / `listRetiredRecipients`,一个能力:两个都在或都不在),经 core 的唯一判官 `mailboxRecipientLifecycleOf` 读
+ * (缺一半 ⇒ 判官拒)。本仓不另立型:{@link MailboxRecipientLifecycle} 就是那只判官答的形,{@link recipientLifecycleOf} 是本仓唯一的读法 ——
+ * 店带那一对 ⇒ 判官的答;不带 ⇒ {@link createDropOnlyRecipientLifecycle}(见文末「缺席形」)。
  *
  * ## 两个动词,各答一个问题
  *
@@ -50,30 +47,11 @@
  * 后端选择点(`boot/stores.ts` 的 `mailbox_store_enabled` 行)逐次落 `recipientTombstones` 读数,
  * 披露在 `docs/DEPLOY-PREREQS.md`。方向上它也不放宽任何东西 —— 两种形都**不收**给已删会话的信。
  */
-import type { MailboxStore } from "@sema-agent/core";
-/** 一条墓碑(= 一个已退役的收件人)。 */
-export interface MailboxRecipientTombstone {
-    /** 盒句柄(会话盒 = `session.<小写 id>`)。 */
-    readonly handle: string;
-    /** 退役时刻(epoch ms)——目录据此铸 `diedAt`。 */
-    readonly retiredAt: number;
-    /** 退役前的显示名(会话的删前 `title`);缺席 = 当时没有可用的名字。 */
-    readonly label?: string;
-}
-export interface MailboxRecipientLifecycle {
-    /**
-     * 把 `(scope, handle)` 置入**预删除态**:此后 `append` 一律以 `MAILBOX_TOMBSTONED_RECIPIENT_CODE` 拒。
-     * **只打标**——不删消息、不动租约、不碰盒行的高水位(理由 = core T2 试剂盒的两格副作用判据,见模块头)。
-     * 幂等(重复 retire 只更新时刻/名字)。
-     *
-     * @returns 是否真的落了一张耐久墓碑。`false` 有两种,都是「没落」:① 本后端没有预删除态,箱已被直接 `drop`
-     *          (拒的方向不变,退化的只有拒绝措辞与「正在删除中」那一行的可见性);② 这只键收件箱的键判官不收(SQL 两孪生:没有箱可打标,
-     *          这只键的 `append` 本来就以判官那一句拒,不带墓碑码)。
-     */
-    retireRecipient(scope: string, handle: string, at: number, label?: string): Promise<boolean>;
-    /** 本 scope 下句柄以 `handlePrefix` 开头的墓碑。无预删除态的后端恒返回空。 */
-    listRetiredRecipients(scope: string, handlePrefix: string): Promise<readonly MailboxRecipientTombstone[]>;
-}
+import { mailboxRecipientLifecycleOf, type MailboxStore } from "@sema-agent/core";
+/** 收件人生命周期面 = core 判官 `mailboxRecipientLifecycleOf` 答的那一对(本仓零份第二型;墓碑行型直接用 core 的 `MailboxRecipientTombstone`)。 */
+export type MailboxRecipientLifecycle = NonNullable<ReturnType<typeof mailboxRecipientLifecycleOf>>;
+/** 一只店的收件人生命周期面 —— 本仓唯一的读法:店带那一对 ⇒ core 判官的答(缺一半判官就拒,`config.invalid_argument`);不带 ⇒ drop-only 形。 */
+export declare function recipientLifecycleOf(store: MailboxStore): MailboxRecipientLifecycle;
 /**
  * 看不见收件人生命周期的后端的诚实形:retire = 直接把箱 `drop` 掉(**不**打标,因为没有可打标的地方),
  * 墓碑清单恒空。

package/dist/plugins/mailbox-recipient-lifecycle.js

@@ -1,3 +1,7 @@
+import { mailboxRecipientLifecycleOf } from "@sema-agent/core";
+export function recipientLifecycleOf(store) {
+    return mailboxRecipientLifecycleOf(store) ?? createDropOnlyRecipientLifecycle(store);
+}
 export function createDropOnlyRecipientLifecycle(store) {
     return {
         retireRecipient: async (scope, handle) => {

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

@@ -1,8 +1,7 @@
 import type { Pool as MySqlPool } from "mysql2/promise";
 import type { Pool as PgPool } from "pg";
-import type { MailboxAckResult, MailboxAppendMessage, MailboxDecision, MailboxDecisionOutcome, MailboxLease, MailboxStore } from "@sema-agent/core";
+import type { MailboxAckResult, MailboxAppendMessage, MailboxDecision, MailboxDecisionOutcome, MailboxLease, MailboxRecipientTombstone, MailboxStore } from "@sema-agent/core";
 import { type IndexSpec } from "./ensure-index.js";
-import type { MailboxRecipientLifecycle, MailboxRecipientTombstone } from "./mailbox-recipient-lifecycle.js";
 import type { SqlDialect } from "./sql-driver.js";
 export declare const MAILBOX_TABLE = "mailbox";
 export declare const MAILBOX_MSG_TABLE = "mailbox_message";
@@ -12,6 +11,11 @@ export declare const MAILBOX_MSG_TABLE = "mailbox_message";
  *  —— `mailbox` 行是**盒**事实(next_seq / lease),墓碑是**收件人**事实,两者的生命周期本来就不同
  *  (`drop` 同时终结两者 —— 墓碑随箱亡,理由全文见 `mailbox-recipient-lifecycle.ts` 模块头)。 */
 export declare const MAILBOX_TOMBSTONE_TABLE = "mailbox_tombstone";
+/** 盒的**已收窗**(core 7.61.0):`ack` 删掉的带身份记录各留一行 `{ record_id, seq, digests }`,每盒恰留按 `seq` 最新的 `MAILBOX_CONSUMED_ID_WINDOW` 行;
+ *  `append` 在盒行锁之内连同持有行一起交引擎的 `judgeMailboxAppendById` 判(同记录 ⇒ 答它当时的 `seq`、零写;不同 ⇒ `mailbox.duplicate_record_id`)。
+ *  是**盒**事实(与 `next_seq` 同生命周期):`drop` 随盒删、`reap` 留着(它清掉的东西从没被收过)。新表而不是 `mailbox` 加列,理由同墓碑表(存量库零运维动作)。
+ *  `digests` = 引擎 `mailboxReplayDigests` 的四面摘要 JSON(只读那一只函数,不另算)。 */
+export declare const MAILBOX_CONSUMED_TABLE = "mailbox_consumed";
 /**
  * 身份键(`scope` / `handle` / lease `owner`)的 UTF-8 字节上界 = 键列宽(TiDB `VARBINARY(190)`;PG 列按字符,本判官在两方言上都按字节拒)。
  */
@@ -35,10 +39,10 @@ export type MailboxKeyColumn = "scope" | "handle" | "owner";
 /** 库里读回的一对键列判官拒不拒(与入口同一只判官;字节先无损读成串,读不成 = 不良构)。`reap` 的候选句柄与一次性迁移 M27 都按它判。 */
 export declare function storedMailboxKeyless(scopeKey: unknown, handle: unknown): boolean;
 /**
- * 收件箱表族:三张表的键都是 `(scope_key, handle)`。次序 = 锁序(盒行 → 消息行 → 墓碑行;盒行先删的理由见 `drop`)。
+ * 收件箱表族:四张表的键都是 `(scope_key, handle)`。次序 = 锁序(盒行 → 消息行 → 已收窗行 → 墓碑行;盒行先删的理由见 `drop`)。
  * 「丢掉一只箱」= 按这个次序逐表按键删 —— `drop` 与一次性迁移 M27 是同一组语句({@link mailboxKeyDeleteSql})。
  */
-export declare const MAILBOX_KEYED_TABLES: readonly ["mailbox", "mailbox_message", "mailbox_tombstone"];
+export declare const MAILBOX_KEYED_TABLES: readonly ["mailbox", "mailbox_message", "mailbox_consumed", "mailbox_tombstone"];
 export type MailboxKeyedTable = (typeof MAILBOX_KEYED_TABLES)[number];
 /** 按键删收件箱表族的一张表(两方言;参数 = [scope_key, handle])。 */
 export declare function mailboxKeyDeleteSql(dialect: SqlDialect, table: MailboxKeyedTable): string;
@@ -55,7 +59,7 @@ export declare function ensureTiDBMailboxSchema(pool: MySqlPool): Promise<void>;
 /** [ref]:本 store 的索引**声明**(两方言共用一份)。PG 侧由下面的 `ensurePgMailboxSchema` 应用,MySQL 侧由 `tidb-pool.ts` 的中央 `ensureSchema` 应用(那里内联 `KEY` 已在 `CREATE TABLE` 里 ⇒ 新建库探到即零 DDL,存量库缺谁补谁)。加索引以外的 schema 变更仍归运维,见 `plugins/ensure-index.ts` 头注。 */
 export declare const MAILBOX_INDEXES: readonly IndexSpec[];
 export declare function ensurePgMailboxSchema(q: (text: string, params?: unknown[]) => Promise<unknown>): Promise<void>;
-export declare class TiDBMailboxStore implements MailboxStore, MailboxRecipientLifecycle {
+export declare class TiDBMailboxStore implements MailboxStore {
     private readonly pool;
     private readonly logger?;
     /** [ref]([ref] §1.2⑥):跨进程安全**显式**声明 —— core 的 `mailboxCrossProcessMountVerdict` 只对字面 `true` 放行
@@ -82,15 +86,15 @@ export declare class TiDBMailboxStore implements MailboxStore, MailboxRecipientL
     reap(scope: string, now: number, opts?: {
         maxAgeMs?: number;
     }): Promise<number>;
-    /** 见 {@link MailboxRecipientLifecycle.retireRecipient}。**只打标**:不删消息、不动租约、不碰 next_seq。
+    /** 见 core `MailboxStore.retireRecipient`。**只打标**:不删消息、不动租约、不碰 next_seq。
      *  锁序 = 盒行先(与 append / claim / ack / drop / reap 五面统一 —— ABBA 死锁形不许在这里重开),
      *  于是 retire 与并发 append 在同一把行锁上串行:要么 append 先拿到 seq、要么它读到墓碑被拒,没有中间态。 */
     retireRecipient(scope: string, handle: string, at: number, label?: string): Promise<boolean>;
-    /** 见 {@link MailboxRecipientLifecycle.listRetiredRecipients}。前缀查带 `ESCAPE`(句柄是开集串,
+    /** 见 core `MailboxStore.listRetiredRecipients`。前缀查带 `ESCAPE`(句柄是开集串,
      *  `_`/`%` 若被当通配会把**别的**收件人一起列出来 —— 与本仓 `?q=` 面同一条 escapeLike 纪律)。 */
     listRetiredRecipients(scope: string, handlePrefix: string): Promise<readonly MailboxRecipientTombstone[]>;
 }
-export declare class PgMailboxStore implements MailboxStore, MailboxRecipientLifecycle {
+export declare class PgMailboxStore implements MailboxStore {
     private readonly pool;
     private readonly logger?;
     /** [ref] 跨进程安全显式声明(TiDB 孪生同注:事务 + 盒行 FOR UPDATE 锁序是真值前提;终验 = test/mailbox-cross-process-kit.test.ts pg 腿)。 */