@sema-agent/server 7.142.0 → 7.143.0

package/dist/plugins/file-run-store.d.ts

@@ -41,6 +41,14 @@ export declare class FileRunStore implements InProcessClaimFence {
     private readonly events;
     /** taskId → the open append log (one O_APPEND fd per run, lazily opened, held for lifetime). */
     private readonly eventLogs;
+    /** `<root>/run-blobs/` — one section-blob ledger per session (plane 4 of the header). */
+    private readonly blobsDir;
+    /** sessionId → (digest → section body): the index of plane 4 (hydrated per session that has run rows). */
+    private readonly sectionBlobs;
+    /** sessionId → the open section-blob ledger (lazily opened, held until the session is deleted / dispose). */
+    private readonly blobLogs;
+    /** `(taskId, seq)` of manifest rows already reported as unresolvable (one report per row per store instance = per process). */
+    private readonly unresolvedReported;
     /** [ref] the checkpoint-table stand-in (see memory-run-store.ts {@link RunStoreCheckpointProbe} — the full
      *  rationale lives on the interface); absent ⇒ the suspended-run reapers stay honest NO-OPs. */
     private checkpointProbe?;
@@ -61,6 +69,11 @@ export declare class FileRunStore implements InProcessClaimFence {
     private runJsonPath;
     private eventsPath;
     private activePath;
+    /** A session's section-blob ledger. The file name is core's `sanitizeScope` form (readable prefix + sha256 of the id), not the
+     *  bare id: two ids that differ only in letter case are one file on a case-insensitive file system (macOS by default), and a
+     *  deleted session must never take another session's blocks with it. `undefined` only for a run row read back from a damaged
+     *  run.json whose session id is not a string — such a row has no ledger (its manifest rows are stored whole). */
+    private blobLedgerPath;
     private spaceCommitPath;
     /** One space's commit record, or `undefined` (no file). A record that is not this store's shape is a loud read failure
      *  (the reader — the next run's connect — refuses; it never guesses that no commit is in flight). */
@@ -129,6 +142,22 @@ export declare class FileRunStore implements InProcessClaimFence {
     isPreemptRequested(taskId: string, owner: string | null): Promise<boolean>;
     heartbeat(taskId: string, owner: string | null): Promise<void>;
     appendEvent(taskId: string, seq: number, type: LedgerEventType, data: unknown): Promise<void>;
+    /**
+     * 写口里第四个盘面的那一段(与事件行的追加在**同一同步调用**里,块在前):帧经编解码拆成引用形 + 段体,本会话块账本里还没有的段体先追加
+     * (一批一次 fsync:事件行本身 fsync:false,而一只块被同会话之后每一条清单行引用 —— 丢一行丢一帧,丢一块丢一串帧),再把引用形交回给
+     * 事件行的追加。块追加抛 ⇒ 原样上抛:事件行不写,不退回整帧(与事件行自己写失败同一条路,汇点的串行写口留 seq 洞)。
+     * 这条 run 没有行(会话不详)⇒ 没有块账本可挂 ⇒ 帧原样存:和类型里「没有一段用引用」的合法实例,读口原样交出。
+     */
+    private storeSections;
+    private blobLogFor;
+    /** Drop a session's section-blob ledger: the file first, then the open fd and the index. The file removal is NOT best-effort
+     *  (unlike {@link dropRun}'s directory): it is the delete's first destructive step, so a removal that fails throws before
+     *  anything else changed — the session delete answers an error and a retry starts from the same state, instead of leaving
+     *  an index that no longer matches the disk. (`AppendLog.close` never throws: it swallows its own `closeSync`.) */
+    private dropSectionBlobs;
+    /** 读口的悬空引用臂:清单行有一段装不回 ⇒ 这一帧这一次不交出(永不交出缺段的清单),每 `(taskId, seq)` 每只店实例(= 每进程)留一次 F 类痕;
+     *  帧仍在索引里,`maxSeq` / `retainedFrom` 照旧按存位算(下一个写者的 seq 不会撞上它)。 */
+    private reportUnresolved;
     maxSeq(taskId: string): Promise<number>;
     retainedFrom(taskId: string): Promise<number>;
     getEvents(taskId: string, afterSeq: number): Promise<RunEvent[]>;

package/dist/plugins/file-run-store.js

@@ -4,9 +4,10 @@ import { projectUsageStats, USAGE_SCAN_LIMIT } from "../usage-analytics.js";
 import { join } from "node:path";
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync } from "node:fs";
 import { randomBytes } from "node:crypto";
-import { AppendLog, atomicWriteFile, ensureDir, isProcessLive, processFingerprint, sanitizePathComponent, writeThenLink } from "@sema-agent/core";
+import { AppendLog, atomicWriteFile, ensureDir, isProcessLive, processFingerprint, sanitizePathComponent, sanitizeScope, writeThenLink } from "@sema-agent/core";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { replayJsonlSkipping } from "../observability/corrupt-read-seat.js";
+import { joinFromStore, splitForStore } from "./wiring-section-codec.js";
 import { RUN_HOLDER_DEATH_CODES, RUN_ORPHANED_ERROR, RUN_STALLED_ERROR, StoreBootRefusalError, buildRunOrphanedError, readLegacyHolderDeathCode, isTerminalRunStatus, settledLegObservationOf } from "./store-contracts.js";
 import { notifyRunTerminal } from "../observability/run-terminal.js";
 import { readRunIdentityCells, runIdentityCells } from "../identity-source.js";
@@ -26,6 +27,13 @@ const EVENT_RECORD_SHAPE = {
         return typeof record.seq === "number" ? record : undefined;
     },
 };
+const SECTION_BLOB_SHAPE = {
+    what: "wiring-section blob record without a string digest and an object/array body",
+    read(record) {
+        const r = record;
+        return typeof r.digest === "string" && typeof r.body === "object" && r.body !== null ? record : undefined;
+    },
+};
 const CLAIM_RECORD_SHAPE = {
     what: "active-run claim record without a string sessionId / taskId",
     read(record) {
@@ -61,6 +69,10 @@ export class FileRunStore {
     byIdem = new Map();
     events = new Map();
     eventLogs = new Map();
+    blobsDir;
+    sectionBlobs = new Map();
+    blobLogs = new Map();
+    unresolvedReported = new Set();
     checkpointProbe;
     claimOwner = { nonce: randomBytes(12).toString("hex"), ...processFingerprint() };
     claimLocks = new Map();
@@ -72,6 +84,7 @@ export class FileRunStore {
         this.runsDir = join(root, "runs");
         this.activeDir = join(root, "runs", "active");
         this.tmpDir = join(root, "tmp");
+        this.blobsDir = join(root, "run-blobs");
         this.spaceCommitsDir = join(root, "space-commits");
         this.spaceCommits = createInProcessSpaceCommitTable({
             load: (spaceKey) => this.loadSpaceCommit(spaceKey),
@@ -109,6 +122,9 @@ export class FileRunStore {
     activePath(sessionId) {
         return join(this.activeDir, sanitizePathComponent(sessionId));
     }
+    blobLedgerPath(sessionId) {
+        return typeof sessionId === "string" ? join(this.blobsDir, `${sanitizeScope(sessionId)}.jsonl`) : undefined;
+    }
     spaceCommitPath(spaceKey) {
         return join(this.spaceCommitsDir, `${sanitizePathComponent(spaceKey)}.json`);
     }
@@ -144,6 +160,7 @@ export class FileRunStore {
         const { identitySource, identityScope, identityPrincipalInc, ...rest } = d;
         return {
             ...rest,
+            result: d.result ?? null,
             idemKey: typeof d.idemKey === "string" ? d.idemKey : null,
             idemBodyFingerprint: typeof d.idemBodyFingerprint === "string" ? d.idemBodyFingerprint : null,
             identity: readRunIdentityCells(identitySource, identityScope, identityPrincipalInc),
@@ -261,6 +278,19 @@ export class FileRunStore {
                 this.events.set(disk.taskId, list);
             }
         }
+        for (const sessionId of new Set([...this.runs.values()].map((r) => r.sessionId))) {
+            const path = this.blobLedgerPath(sessionId);
+            if (path === undefined)
+                continue;
+            const recs = this.replay(path, SECTION_BLOB_SHAPE).records;
+            if (recs.length === 0)
+                continue;
+            const index = new Map();
+            for (const b of recs)
+                if (!index.has(b.digest))
+                    index.set(b.digest, b.body);
+            this.sectionBlobs.set(sessionId, index);
+        }
         let claims;
         try {
             claims = readdirSync(this.activeDir);
@@ -435,10 +465,58 @@ export class FileRunStore {
             return;
         const clone = data == null ? null : structuredClone(data);
         const ts = new Date().toISOString();
-        this.eventLogFor(taskId).append({ seq, type, data: clone, ts }, false);
-        list.push({ seq, type, data: clone, ts });
+        const stored = this.storeSections(taskId, type, clone);
+        this.eventLogFor(taskId).append({ seq, type, data: stored, ts }, false);
+        list.push({ seq, type, data: stored, ts });
         this.events.set(taskId, list);
     }
+    storeSections(taskId, type, data) {
+        const { stored, blobs } = splitForStore(type, data);
+        if (blobs.length === 0)
+            return stored;
+        const sessionId = this.runs.get(taskId)?.sessionId;
+        const path = sessionId === undefined ? undefined : this.blobLedgerPath(sessionId);
+        if (sessionId === undefined || path === undefined)
+            return data;
+        let index = this.sectionBlobs.get(sessionId);
+        if (index === undefined) {
+            index = new Map();
+            this.sectionBlobs.set(sessionId, index);
+        }
+        const fresh = blobs.filter((b) => !index.has(b.digest));
+        if (fresh.length > 0) {
+            const log = this.blobLogFor(sessionId, path);
+            for (const [i, b] of fresh.entries())
+                log.append({ digest: b.digest, body: b.body }, i === fresh.length - 1);
+            for (const b of fresh)
+                index.set(b.digest, b.body);
+        }
+        return stored;
+    }
+    blobLogFor(sessionId, path) {
+        let log = this.blobLogs.get(sessionId);
+        if (!log) {
+            log = new AppendLog(path);
+            this.blobLogs.set(sessionId, log);
+        }
+        return log;
+    }
+    dropSectionBlobs(sessionId) {
+        const path = this.blobLedgerPath(sessionId);
+        if (path !== undefined)
+            rmSync(path, { force: true });
+        this.blobLogs.get(sessionId)?.close();
+        this.blobLogs.delete(sessionId);
+        this.sectionBlobs.delete(sessionId);
+    }
+    reportUnresolved(taskId, seq, missing) {
+        const key = `${taskId}\u0000${seq}`;
+        if (this.unresolvedReported.has(key))
+            return;
+        this.unresolvedReported.add(key);
+        const sections = missing.map((m) => `${m.section}:${m.digest}`).join(",");
+        recordFailOpen("server.run-store.corrupt-record-skipped", `kind=section-ref taskId=${taskId} seq=${seq} sections=${sections} reason=wiring_manifest row references section blobs its session's ledger does not hold (row withheld from reads)`);
+    }
     async maxSeq(taskId) {
         const list = this.events.get(taskId);
         return list && list.length ? Math.max(...list.map((e) => e.seq)) : 0;
@@ -449,10 +527,19 @@ export class FileRunStore {
     }
     async getEvents(taskId, afterSeq) {
         const list = this.events.get(taskId) ?? [];
-        return list
-            .filter((e) => e.seq > afterSeq)
-            .sort((a, b) => a.seq - b.seq)
-            .map((e) => ({ ...e, data: e.data == null ? null : structuredClone(e.data) }));
+        const sessionId = this.runs.get(taskId)?.sessionId;
+        const blobs = sessionId === undefined ? undefined : this.sectionBlobs.get(sessionId);
+        const lookup = (digest) => blobs?.get(digest);
+        const out = [];
+        for (const e of list.filter((x) => x.seq > afterSeq).sort((a, b) => a.seq - b.seq)) {
+            const joined = joinFromStore(e.type, e.data, lookup);
+            if (joined.kind === "unresolved") {
+                this.reportUnresolved(taskId, e.seq, joined.missing);
+                continue;
+            }
+            out.push({ ...e, data: joined.data == null ? null : structuredClone(joined.data) });
+        }
+        return out;
     }
     async setTerminal(taskId, status, result, error) {
         await fenceSpaceCommitAtTerminal(taskId, async (spaceCommit) => this.writeTerminal(taskId, status, result, error, spaceCommit));
@@ -661,6 +748,7 @@ export class FileRunStore {
         const claimed = this.active.get(sessionId);
         if (claimed !== undefined)
             return { active: claimed };
+        this.dropSectionBlobs(sessionId);
         let removed = 0;
         for (const [taskId, r] of [...this.runs]) {
             if (r.sessionId !== sessionId)
@@ -1024,7 +1112,7 @@ export class FileRunStore {
         return new Set([...this.runs.values()].map((r) => r.sessionId));
     }
     dispose() {
-        for (const log of this.eventLogs.values()) {
+        for (const log of [...this.eventLogs.values(), ...this.blobLogs.values()]) {
             try {
                 log.close();
             }
@@ -1032,6 +1120,7 @@ export class FileRunStore {
             }
         }
         this.eventLogs.clear();
+        this.blobLogs.clear();
     }
 }
 //# sourceMappingURL=file-run-store.js.map

package/dist/plugins/imported-layer-root-retirement.d.ts

@@ -0,0 +1,82 @@
+/**
+ * 🔴 一次性迁移 M36(窗口见 `plugins/one-time-migrations.ts` 登记表)—— **引擎 7.61.0 之前导入的、在每个项目根放行的全局 allow,按引擎写下的那一句判据退役**。
+ *
+ * ## 为什么
+ * 引擎 7.61.0 之前的设置导入门把用户层(用户配置目录下的那份 settings)里从 `/` 写起的路径规则存成**全局行**。全局行在每个任务的**项目根**读 `/x`,
+ * 用户层却在**它自己的配置目录**读 —— 同一串字落店之后守着 / 放着的是另一个地方:一条本意是「配置目录下的 notes」的放行 `Edit(/notes/**)`
+ * 在每个项目里放行 `notes/` 的编辑、不问。引擎 7.61.0 起导入门不再这样存(`preview.skipped`,理由前缀 `unsupported.layer_root:`);
+ * **存量行**引擎不迁、也不在读侧丢 —— 判据只写成一句话(引擎 INTEGRATION-CORE §5.14),由店的属主跑。本文件就是那一次跑。
+ *
+ * ## 判据(逐字照引擎那一句;不加条件、不减条件)
+ * 一个已存的 add 被退役,当且仅当四条都成立:行的态是 `allow`;add 的出处是 `imported-cc`;行的 scope 是 `global`;`ruleBasesNeeded(row)` 点名 `root`。
+ * **按 add 退役、不按行**:每只选中的行写**一只** observed-remove 墓碑,`removedDots` 恰是选中的那几只 add —— 同一行另有一只 `user` add 的,那一行照旧活着
+ * (人亲手同意过的那一份不跟着导入一起走)。deny / ask 的 add **不退役**:它们按店的读法(`<task>/x`)只收紧,退役会把部署有意带进来的收紧放掉。
+ *
+ * ## 读哪些桶(店自己答;答不全的那一种如实写下)
+ * 一律问**店**:它能叫出名字的每一只桶,判据在桶里判(不在桶外按「谁可能有」预筛)。
+ *  · SQL:规则表里的每一只桶(`listRuleBucketOwners`,按 `owner_key` 分页)。不从审批记录推 —— 收编把规则桶整桶改键到新身份、审批史留在旧身份名下,
+ *    从记录推出的属主集在收编之后漏掉新桶。
+ *  · File:引擎的 File 分区后端**没有**列桶口(桶文件按属主名的单向摘要命名),本步能叫出名字的只有本店导入记录点名过的属主
+ *    (`FileRuleApprovalRecordStore.importRecordOwners`;`imported-cc` 只由导入记录派生,记录是只增日志)。**已知缺口(如实)**:引擎的本地数据根收编
+ *    把一只桶改名到一个没有任何导入记录点名的身份之后,那只桶本步叫不出、不读 —— 等引擎给 File 分区后端一个列桶口再收。
+ *
+ * ## 写在哪里(一处)
+ * 墓碑经**这只桶自己的写面**落(`writerOf(partition).apply({ kind: "tighten-delete" })`,引擎的写面契约)—— SQL 两孪生走 `SqlDurableRulePartition` 的那只
+ * (店内唯一写法 `writeBucket`),File 走引擎 File 分区的那只。同一个函数、同一次调用,不分叉。删除点(`deletedBy`)由这只桶的写面 `nextDot()` 铸
+ * —— 与引擎撤销口 `removePersistedRule` 同一约定(本副本的 actor,一次删除一枚)。OCC:读到的 rev 交给 `apply`,输了就重读重选(另一只副本可能刚退役过,
+ * 重选为空 ⇒ 零写),有界次数后点名跳过、下一次起服再来。
+ *
+ * ## 失败方向
+ * 列桶 / 解析桶 / 读桶 / 取点 / 写面**抛** ⇒ 原样抛:起服拒,收据账里已提交的墓碑随拒因交出(与本段其余各步同一条路)。例外两条,都由店的判官按抛出物的**类**判(不按文案):
+ * 取点时店说这只桶**在写它的那一步里没了**(`source.isVanishedBucket`:另一只副本删桶恰落在这一窗)⇒ 无可退役、点名跳过 `vanished`(桶都没了,它什么都不放行);
+ * 另一条是解析桶(属主 → 分区)或读桶时**店的唯一判官整桶拒**了
+ * 这只桶(解析与读同一条律、同一只判官;`source.isWholeBucketRefusal`:确定性判决,引擎读侧对它同样整桶拒、它什么都不放行;SQL = 读腿真往外交的那两类 —— 判官四道的拒与某只 JSON 列的体读不出)
+ * ⇒ 点名跳过 `bucket_unreadable`,接着读下一只桶(一只读不出的桶不挡别的桶,也不挡起服);一次读失败(连接 / 超时)
+ * 证明不了以后也读不出,所以它**不**归这一类 —— 跳过它就是让那几行在读恢复之后照旧放行。File 店没有这种判决证据(引擎的 File 分区对损坏与 I/O 失败抛同一种错,
+ * 解析时读收编标记也是:一次 EIO 与一份坏标记同一种错)⇒ 那一侧解析 / 读桶抛一律起服拒。另两种店**答了**却做不了的(没有写面或写面拒 / 并发争不过)⇒ 点名跳过,下一次起服再试,其间那几行照旧放行,每次起服都点名。
+ */
+import { type DurableRulePartitionProvider, type PersistedRule, type RuleAdd, type RuleOwner } from "@sema-agent/core";
+/** 一只被退役的导入 add 所在的行(一行一条读数)。**不带规则正文**(与 M11 同一条纪律:规则正文不出店)—— 桶键 + 工具名足够让运维去列举面对上它。 */
+export interface ImportedLayerRootAllowRetired {
+    /** 桶键(`buildRuleOwnerKey`:属主的单向摘要;两种店同一把,日志里不出属主名)。 */
+    readonly ownerKey: string;
+    readonly tool: string;
+    /** 这一行被退役的导入 add 数(≥ 1)。 */
+    readonly addsRetired: number;
+    /** 退役之后这一行是否仍活着 —— 它另有别的出处的 add(人亲手同意过的那一份)。`false` = 这一行不再生效。 */
+    readonly stillLive: boolean;
+}
+/**
+ * 跳过一只桶的成因(闭集;日志句按它穷尽分)。
+ *  · `bucket_unreadable` —— 解析或读这只桶时,店的唯一判官整桶拒了它(`isWholeBucketRefusal` 真)。引擎读侧对它同样整桶拒:它什么都不放行。
+ *  · `vanished` —— 读到了要退役的行,写它的那一步里这只桶被并发删掉了(店的判官按类说)。桶没了 ⇒ 无可退役,什么都不放行;不拒启。
+ *  · `not_writable` —— 选中了行,而这只桶没有写面(只读视图)或写面拒了这只墓碑。那几行照旧放行,每次起服都点名。
+ *  · `contended` —— 每一次写都输给并发写者,有界次数用完。下一次起服再来;其间照旧放行。
+ */
+export type ImportedLayerRootSkipReason = "bucket_unreadable" | "vanished" | "not_writable" | "contended";
+export interface ImportedLayerRootBucketSkipped {
+    readonly ownerKey: string;
+    readonly reason: ImportedLayerRootSkipReason;
+    /** 一句不带行内容的话:读 / 解析桶抛出来的东西只报它的种类(原句可能引到桶里的行 —— 与 M11 `contentFreeRefusal` 同一条纪律;
+     *  原句由店自己的披露口说,File 店的 `permission_rule_store_disclosure`、SQL 店的整桶拒句);写面拒的是闭集词,原样带。 */
+    readonly why: string;
+}
+/** 本步记进收据账的两格(`OneTimeMigrationReport` 的两只键,随提交追加)。 */
+export interface ImportedLayerRootReadings {
+    importedLayerRootAllowsRetired: ImportedLayerRootAllowRetired[];
+    importedLayerRootBucketsSkipped: ImportedLayerRootBucketSkipped[];
+}
+/** 一种店交给本步的三样东西:它能叫出名字的桶的属主(见头注「读哪些桶」)、它的 durable 分区后端(读桶、写墓碑)、它的整桶拒判别(见头注「失败方向」)。 */
+export interface ImportedLayerRootRetirementSource {
+    candidateOwners(): Promise<readonly RuleOwner[]>;
+    readonly durable: DurableRulePartitionProvider;
+    /** 这只读桶抛出物是不是店的唯一判官的**确定性**整桶拒(真 ⇒ 点名跳过、读下一只桶;假 ⇒ 原样抛、起服拒)。判的是读面**真往外交的**抛出物的类,不按文案。 */
+    isWholeBucketRefusal(e: unknown): boolean;
+    /** 这只取点抛出物是不是店说的「桶在写它的那一步里没了」(真 ⇒ 点名跳过 `vanished`;假 ⇒ 原样抛、起服拒)。 */
+    isVanishedBucket(e: unknown): boolean;
+}
+/** 判据(引擎 §5.14 那一句,逐字):这一行里该退役的 add;不选 ⇒ 空。 */
+export declare function importedLayerRootAddsOf(row: PersistedRule): readonly RuleAdd[];
+/** 跑一遍:读记录点名的每只桶(按桶键去重),退役判据选中的 add。读数随每次提交记进 `into`。 */
+export declare function retireImportedLayerRootAllows(source: ImportedLayerRootRetirementSource, into: ImportedLayerRootReadings): Promise<void>;
+//# sourceMappingURL=imported-layer-root-retirement.d.ts.map

package/dist/plugins/imported-layer-root-retirement.js

@@ -0,0 +1,96 @@
+import { ruleBasesNeeded, writerOf } from "@sema-agent/core";
+import { buildRuleOwnerKey } from "./permission-rule-store-sql.js";
+const RETIREMENT_OCC_ATTEMPTS = 5;
+export function importedLayerRootAddsOf(row) {
+    if (row.behavior !== "allow" || row.scope.kind !== "global" || !ruleBasesNeeded(row).includes("root"))
+        return [];
+    return row.adds.filter((a) => a.origin === "imported-cc");
+}
+export async function retireImportedLayerRootAllows(source, into) {
+    const seen = new Set();
+    for (const owner of await source.candidateOwners()) {
+        const ownerKey = buildRuleOwnerKey(owner);
+        if (seen.has(ownerKey))
+            continue;
+        seen.add(ownerKey);
+        await retireInBucket(source, owner, ownerKey, into);
+    }
+}
+async function retireInBucket(source, owner, ownerKey, into) {
+    const durable = source.durable;
+    const skip = (reason, why) => void into.importedLayerRootBucketsSkipped.push({ ownerKey, reason, why });
+    const unreadable = (what, e) => {
+        if (!source.isWholeBucketRefusal(e))
+            throw e;
+        skip("bucket_unreadable", withheld(what, e));
+    };
+    let partition;
+    try {
+        partition = partitionOf(durable, owner);
+    }
+    catch (e) {
+        return unreadable("the store refused this bucket as a whole while resolving it", e);
+    }
+    for (let attempt = 0; attempt < RETIREMENT_OCC_ATTEMPTS; attempt++) {
+        let stored;
+        try {
+            stored = await partition.list();
+        }
+        catch (e) {
+            return unreadable("the store refused this bucket as a whole", e);
+        }
+        const selected = stored.rules.flatMap((row) => {
+            const adds = importedLayerRootAddsOf(row);
+            return adds.length > 0 ? [{ row, adds }] : [];
+        });
+        if (selected.length === 0)
+            return;
+        const writer = writerOf(partition);
+        if (writer === undefined)
+            return skip("not_writable", "this bucket is served through a read-only view (it has no write face)");
+        let rev = stored.rev;
+        let lost = false;
+        for (const { row, adds } of selected) {
+            let deletedBy;
+            try {
+                deletedBy = await writer.nextDot();
+            }
+            catch (e) {
+                if (!source.isVanishedBucket(e))
+                    throw e;
+                return skip("vanished", "the bucket was deleted while this step was writing to it (a concurrent delete); nothing is left to retire");
+            }
+            const tombstone = { behavior: row.behavior, rule: row.rule, scope: row.scope, removedDots: adds.map((a) => a.dot), deletedBy };
+            const out = await writer.apply({ kind: "tighten-delete", tombstone }, { expectedRev: rev });
+            if ("conflict" in out) {
+                lost = true;
+                break;
+            }
+            if ("refused" in out)
+                return skip("not_writable", `the store refused the tombstone (${out.refused})`);
+            rev = out.rev;
+            into.importedLayerRootAllowsRetired.push({ ownerKey, tool: row.tool, addsRetired: adds.length, stillLive: row.adds.length > adds.length });
+        }
+        if (!lost)
+            return;
+    }
+    skip("contended", `every write lost to a concurrent writer ${RETIREMENT_OCC_ATTEMPTS} times`);
+}
+function partitionOf(durable, owner) {
+    switch (owner.kind) {
+        case "principal":
+            return durable.forPrincipal(owner.principal);
+        case "local-owner":
+            if (durable.forLocalOwner === undefined)
+                throw new Error("this provider has no local-owner bucket");
+            return durable.forLocalOwner();
+        default: {
+            const unknown = owner;
+            throw new Error(`M36: an owner of a kind this pass does not know: ${JSON.stringify(unknown)}`);
+        }
+    }
+}
+function withheld(what, e) {
+    return `${what} threw ${e instanceof Error ? e.name : typeof e} (its text is withheld here: it may quote the bucket's rows)`;
+}
+//# sourceMappingURL=imported-layer-root-retirement.js.map

package/dist/plugins/local-checkpoint-store.d.ts

@@ -151,7 +151,7 @@ export declare class LocalCheckpointStore {
      *    唯一的读不动形是账本重放级(整店同时读不动)。所以 SQL 孪生那道 `version > MAX_SUPPORTED` 的
      *    `unparseable` 臂在这里没有对应物;本口的 `unparseable` 只由**窄读器**判(blob 形不合)。
      *  · **窄读器是同一只** `pendingActionToolCallId`(与 SQL 孪生共用,零第二份手抄):身份三元组的第一维
-     *    `sourceTaskId`、`boundInputHash`、以及「读不出 vs 确定不匹配」的三态,全部由它一家判。
+     *    `sourceSessionId`、`boundInputHash`、以及「读不出 vs 确定不匹配」的三态,全部由它一家判。
      */
     findCheckpointCandidatesForAsk(scope: string, sessionId: string, toolCallId: string, sinceMs: number): Promise<CheckpointAskCandidate[]>;
     /**

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

@@ -278,12 +278,12 @@ export class LocalCheckpointStore {
             const base = { token: t, status: cp.status, createdAtMs: cp.createdAt };
             const derived = pendingActionToolCallId(cp);
             if (!derived.readable) {
-                out.push({ ...base, sourceTaskId: null, boundCallId: null, boundInputHash: null, unparseable: true });
+                out.push({ ...base, sourceSessionId: null, boundCallId: null, boundInputHash: null, unparseable: true });
                 continue;
             }
             if (derived.toolCallId !== toolCallId)
                 continue;
-            out.push({ ...base, sourceTaskId: derived.sourceTaskId, boundCallId: derived.toolCallId, boundInputHash: derived.boundInputHash });
+            out.push({ ...base, sourceSessionId: derived.sourceSessionId, boundCallId: derived.toolCallId, boundInputHash: derived.boundInputHash });
         }
         return out.sort((a, b) => a.createdAtMs - b.createdAtMs || (a.token < b.token ? -1 : a.token > b.token ? 1 : 0));
     }

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

@@ -272,6 +272,8 @@ export declare class LocalSessionStore implements SessionStore {
     /**
      * 改写面与执行席的读法({@link placementProbe} 的一形):placed ⇒ 那份元组;普通 ⇒ `undefined`;行头读不出(`corrupt_session` / `invalid_session`)⇒ `undefined` —— 没有可读的
      * placement 记录,这一行按普通行答,内容读不读得出归真正读内容的那一读(坏档照样换得掉,与 forking 探针同一条规矩);说不出(`storage`)⇒ 抛那只故障。
+     * core 7.61.0 起 repo 的探针按行头的元组自己读、不整头解码:placed 行的属主格坏了探针照答元组(本臂不再接得住 placed 行)—— 探针拒只剩「行头记录整个读不出」,
+     * 那时没有任何元组可守(`test/local-session-placement.test.ts` 的 [ref] 三格)。
      */
     private placedRecordOf;
     /** {@link placedRecordOf} 的是非形。 */
@@ -288,7 +290,8 @@ export declare class LocalSessionStore implements SessionStore {
     private metaOf;
     /**
      * {@link metaOf} 的本体(三态,不抛「用不了」):边档里有那一格 ⇒ 读它;没有 ⇒ 问**唯一探针** {@link probeArchive} 一次 —— 不在 ⇒ 无此会话;在而读得出 ⇒ 补铸({@link cellOfPresent});
-     * 读不出 ⇒ {@link UnusableArchive}(**不补铸**:不替一份读不出的存档铸化身)。要动存档的读者({@link metaOf})把它上抛;不动存档、只要「有没有」的读者
+     * 读不出 ⇒ {@link UnusableArchive}(**不补铸**:不替一份读不出的存档铸化身;`corrupt_session` / `invalid_session` 两词的故障换成具名拒 {@link SessionOwnerUnreadableError} ——
+     * 格缺 ∧ 存档用不了 = 这只会话没有可读的属主,见 {@link ownerUnreadableArchive})。要动存档的读者({@link metaOf})把它上抛;不动存档、只要「有没有」的读者
      * ({@link executionPlacementBackfill})原样收下。
      */
     private metaRead;
@@ -304,7 +307,8 @@ export declare class LocalSessionStore implements SessionStore {
      * 叶子出自会话存档(本店的**内容**;core `SessionRepo.headOf`:File repo 读日志首记录与尾、不重放 —— 存档首行的属主 / 令牌本店不读)。
      * 存档读不出(会话头坏了、I/O 故障)⇒ 头照答行上的属主与住客,叶子那一格带着那只故障(`UnreadableLeaf`,读叶子的人收到它):只判归属的读者
      * 不因坏存档改判,坏存档只让读内容的那一位看见(SQL 孪生的头不碰 `session_event`,同一条律;规则在 `session-incarnation.ts` 头注)。
-     * 行本身读不出(边档里还没有这一格、要从存档推出这只会话在不在,而存档读不出 —— {@link metaOf} 的探针)⇒ 整只拒。
+     * 行本身读不出(边档里还没有这一格、要从存档推出这只会话在不在,而存档读不出 —— {@link metaOf} 的探针)⇒ 整只拒:会话头坏 / 日志结构走不通 ⇒ 具名拒
+     * {@link SessionOwnerUnreadableError}(没有可读的属主;码与句子是原故障的),说不出在不在的 I/O 级故障 ⇒ 原故障。
      * 两样住在两只文件里 ⇒ 先读那一格、读叶子、再同步复读那一格:格没了(读间被删)或换了主 / 换了住客 ⇒ `undefined`(调用方按删处理),
      * 所以一只头从不把这一代的属主配上另一代的叶子([ref] 六轮复审同一条)。`undefined` = 无此会话。
      * 化身那一格经 `headFromRow` 的 `absent` 读法(边档对象形恒有令牌;读不出的边档整只严格拒在 `metaOf` 之前)。

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, sessionUnreadableOf } 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);

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 腿)。 */