@sema-agent/server 7.141.0 → 7.143.0

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

@@ -1,6 +1,6 @@
 import { type UsageRow } from "../usage-analytics.js";
 import type { TaskStatus } from "@sema-agent/core";
-import { StoreBootRefusalError, type FenceLanded, type FencedRun, type InProcessClaimFence, type CreateRunOutcome, type NewRunMeta, type RunIdemBinding, type RunListQuery, type RunRecord, type SessionSummary, type RunEvent, type PersistedTaskResult, type LatestRunRef } from "./store-contracts.js";
+import { StoreBootRefusalError, type FenceLanded, type FencedRun, type InProcessClaimFence, type CreateRunOutcome, type NewRunMeta, type RunIdemBinding, type RunListQuery, type RunRecord, type SessionSummary, type RunEvent, type PersistedTaskResult, type LatestRunRef, type SettledLegMemoryObservation } from "./store-contracts.js";
 import type { RunStoreCheckpointProbe } from "./memory-run-store.js";
 import type { LedgerEventType } from "../trace/ledger-events.js";
 import { type SpaceCommitClaim, type SpaceCommitReading, type SpaceCommitState } from "../workspace-space-commit.js";
@@ -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[]>;
@@ -169,6 +198,11 @@ export declare class FileRunStore implements InProcessClaimFence {
      *  `createdAt DESC, taskId DESC`,与本店 {@link FileRunStore.listSessions} 挑 `rn=1` 那一行的比较器逐字同一份)。
      */
     latestRunForSession(sessionId: string): Promise<LatestRunRef | undefined>;
+    /**
+     * [ref] —— 这个会话**最近一条已结腿**与它的记忆观测(规则属主 = `store-contracts.ts` 的 {@link SettledLegMemoryObservation};
+     * {@link SqlRunStore.latestMemoryObservationForSession} 的孪生:同一只已结谓词(`isTerminalRunStatus`)、同一个排序口径 —— 与本店 {@link FileRunStore.latestRunForSession} 的比较器逐字同一份)。
+     */
+    latestMemoryObservationForSession(sessionId: string): Promise<SettledLegMemoryObservation | undefined>;
     /** DISTINCT sessions newest-first by last activity (the CC /resume picker): latest run's preview/status + first/last/count. */
     listSessions(opts: {
         owner?: string;

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

@@ -4,10 +4,11 @@ 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 { RUN_HOLDER_DEATH_CODES, RUN_ORPHANED_ERROR, RUN_STALLED_ERROR, StoreBootRefusalError, buildRunOrphanedError, readLegacyHolderDeathCode } from "./store-contracts.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";
 import { createInProcessSpaceCommitTable, fenceSpaceCommitAtTerminal, SPACE_COMMIT_RECORD_SCHEMA } from "../workspace-space-commit.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));
@@ -595,6 +682,16 @@ export class FileRunStore {
         }
         return latest === undefined ? undefined : { taskId: latest.taskId, owner: latest.owner, createdAt: latest.createdAt.toISOString() };
     }
+    async latestMemoryObservationForSession(sessionId) {
+        let latest;
+        for (const r of this.runs.values()) {
+            if (r.sessionId !== sessionId || !isTerminalRunStatus(r.status))
+                continue;
+            if (latest === undefined || r.createdAt.getTime() > latest.createdAt.getTime() || (r.createdAt.getTime() === latest.createdAt.getTime() && r.taskId > latest.taskId))
+                latest = r;
+        }
+        return latest === undefined ? undefined : settledLegObservationOf(latest.taskId, latest.result);
+    }
     async listSessions(opts) {
         const bySession = new Map();
         for (const r of this.runs.values()) {
@@ -651,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)
@@ -1014,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();
             }
@@ -1022,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` 之前)。
@@ -349,9 +353,9 @@ export declare class LocalSessionStore implements SessionStore {
     writeSessionRowCells(sessionId: string, cells: SessionRowPatch, how: ReplaySessionRowWrite): Promise<ReplaySessionRowWriteOutcome<SessionSummary>>;
     /**
      * 写原语锁住的那一行(调用方持这只会话的写锁并已 {@link loadRowSidecars}):会话元数据那一格(属主 `owner ?? null` —— 与头读、列表行同读;化身经
-     * `incarnationFromCell` 的 `absent` 读法;执行位 `mirror`)+ 列表面上有它(会话仓里有;`forking` 中间态的存档不在 ⇒ 不在列表上)+ 两只边档的格。
-     * 没有那一格或不在列表面上 ⇒ `undefined`(没有行)。委派分区行(placed)不上列表面(repo 的 `list()` 按存档行头排除,义务 2)⇒ 走到这里的行恒非 placed,
-     * `placed: false` 是列表面那一判的投影,不是另一读。
+     * `incarnationFromCell` 的 `absent` 读法;执行位 `mirror`)+ 行集里有它({@link rowHeaderOf};`forking` 中间态的存档不在 ⇒ 不在列表上)+ 两只边档的格。
+     * 没有那一格或不在列表面上 ⇒ `undefined`(没有行)。委派分区行(placed)不上列表面(repo 的 `list()` 按存档行头排除,义务 2;行头读不出的行没有可读的 placement 记录、
+     * 按普通行读 —— 文件头注那一条)⇒ `placed: false` 是列表面那一判的投影,不是另一读。存档读不出的行照样是一行(行格住在边档,写得了;HTTP 改名口的坏档判据排在本原语之前)。
      */
     private lockedRowOf;
     /** 两只边档上这只会话的可写格(已发布的值;缺键 = 缺省)。调用方先 {@link loadRowSidecars}。 */
@@ -361,10 +365,35 @@ export declare class LocalSessionStore implements SessionStore {
     /** 应答行(锁内另读):列表行同一只合成 + 读到它时那一格上的住客。不在列表面上 / 没有那一格 ⇒ `undefined`。 */
     private listRowOf;
     /** ONE session's list row — {@link listSessions}' projection ({@link summaryOf}, the same synthesis) for one id;
-     *  `undefined` = not a row of the list face (not in the session repo). */
+     *  `undefined` = not a row of the list face ({@link rowHeaders}). */
     sessionSummaryOf(sessionId: string): Promise<SessionSummary | undefined>;
-    /** 会话仓里这只会话的列表元数据(列表面上的行 = `repo.list()` 里的一项)。 */
-    private listedMeta;
+    /**
+     * 本店的**行集** —— 唯一的会话枚举(列表 {@link listSessions}、一次性迁移 M33 的步 1 读它;按 id 读的 {@link rowHeaderOf} 是同一只判据的一只 id 形):
+     *  · 引擎仓的列表(core `repo.list()`:存档**行头**读得出、非 placed)—— 行头读得出的行;
+     *  · ∪ 会话元数据边档里有格、不在引擎仓列表里的 id,经 {@link headerUnreadableRowOf}:存档头读了抛、且不是 placed 行 ⇒ 行头读不出的行(带那只故障);
+     *    不抛(存档不在:fork 中间态 / 删除中;或读间新建)/ placed 行(行头读得出,repo 的 `listPlaced` 认得它,尾部再坏也不上列表面)⇒ 不是行集里的行。
+     * 边档里没有格、存档头又读不出的会话(7.104.0 之前写下、此后从没被读过)没有一格可读的行事实 —— 属主读不出 ⇒ 不进行集(fail-closed,与归属门同读:
+     * {@link metaOf} 判不了它在不在 ⇒ 整只拒);运维面由 core 列表的披露座与起服 warn 点名它。
+     * 「行头读不读得出」(行集,M33 回填行事实问的就是它)与「叶子读不读得出」(列表行的 `unreadable`,{@link listedRowOf})是两件事、各一只读法。
+     */
+    private rowHeaders;
+    /**
+     * 行集里的这一行({@link rowHeaders} 的按 id 一形:同一只判据,只判这一只 id 的行 —— 别的会话读不出不改它的答)。`undefined` = 不是行集里的行。
+     * ⚠️ 如实:取它的行头仍经引擎仓列表(`repo.list()` 读一遍各会话的头),所以别的会话的头坏了,这一次读照旧为它报一次读坏披露;按 id 直读不在本形里。
+     */
+    private rowHeaderOf;
+    /** 不在引擎仓列表里、边档有格的一只 id:存档头读了抛、且不是 placed 行 ⇒ 行头读不出的那一行;否则 `undefined`(见 {@link rowHeaders})。 */
+    private headerUnreadableRowOf;
+    /**
+     * 委派分区行的 id 集的读者(repo 记 placement ⇒ 它的 `listPlaced`,行头那一读;不记 ⇒ 空集 —— 那种 repo 里没有 placed 行)。惰性、一次读:只在有一只 id 的存档头读抛、
+     * 要分「行头读不出」与「行头读得出的 placed 行尾部坏了」时才读。
+     */
+    private createPlacedIdsReader;
+    /**
+     * 列表面上的一行的内容那一半 = 头读的**叶子**那一读({@link archiveHeadOf},与 {@link headOf} 的叶子同一读):行头读不出 ⇒ 读不出(那只故障);行头读得出 ⇒ 再读叶子,
+     * 抛 ⇒ 读不出(尾部 I/O 故障之类:行头好、头读照样抛);否则读得出。所以行上的 `unreadable` 与头读、读口对同一只会话的答复同读。
+     */
+    private listedRowOf;
     /** [ref] —— 换源通告的基线读(local 孪生;三态读法与 SQL 两孪生的 `session_meta.instruction_source` 同一只编解码)。 */
     readInstructionSource(sessionId: string): Promise<InstructionSourceBaseline>;
     /**
@@ -481,6 +510,10 @@ export declare class LocalSessionStore implements SessionStore {
      *                          `lastTaskRunId` = that run's `result.runId`). One call per list (not per row); a session with no
      *                          run row ⇒ `0 / "" / null` (TiDB's null→"" mapping); a run-store read failure throws (never `0 / ""`).
      *
+     *   - `unreadable`      — present-iff the row's head leaf cannot be read ({@link listedRowOf}: the archive header, or the tail the head read
+     *                          scans): the row's facts above still come from its session-meta cell; `objectivePreview` is null; the marker's
+     *                          `errorCode` is what the session's own reads answer.
+     *
      * Keyset matches the contract: STRICTLY older than the cursor, ties broken by id DESC; `limit` is honored after
      * the in-memory sort. Cheap (a local single-user store holds few sessions). Errors reading one session's entries
      * degrade that row's preview to null rather than failing the whole list.
@@ -693,7 +726,7 @@ export declare class LocalSessionStore implements SessionStore {
     /**
      * 一次性迁移 M33 的 local 腿(`LocalBackend.runOneTimeMigrations` 调;起服、先于任何请求;窗内每次起服都跑,第二次起零命中):
      *  0. 恢复先行({@link settleArchiveSnapshots},幂等);
-     *  1. **枚举**:id 全集 = 引擎仓的列表(读得出头的存档)∪ 边档全部键;只在边档里的、头读抛的 ⇒ 计 unreadable(步 3 整档读抛的同计)。两边都不在的读不出存档(列表跳过它、边档里没它的格)
+     *  1. **枚举**(行集 `rowHeaders`):id 全集 = 引擎仓的列表(读得出头的存档)∪ 边档全部键;只在边档里的、头读抛且不是 placed 行(行头读得出)的 ⇒ 计 unreadable(步 3 整档读抛的同计)。两边都不在的读不出存档(列表跳过它、边档里没它的格)
      *     对本店与引擎同样不可见,不计;
      *  2. **行回填**:列表里每一只存档 —— 格缺 ⇒ 建一格(化身新铸、属主「从没被记下」,与补铸同义);格缺建档时刻 ⇒ 写存档头的;格缺谱系而存档头有 ⇒ 写它。只写行(边档的一次提交),
      *     然后一道**落盘屏障**(边档文件与目录各 fsync)—— 在这之前不碰任何存档;