@sema-agent/server 7.147.0 → 7.149.0

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

@@ -1,17 +1,78 @@
 import { FileSessionRepo, type AcquiredSession, type PlacedSessionRow, type SessionHead, type SessionPlacementRecord, type SessionStore, type SessionRepo, type SessionMetadata, type SessionTreeEntry, type StoreDurability } from "@sema-agent/core";
 import { type PlacementAcquireOpts } from "./session-placement.js";
 import { z } from "zod";
-import { StoreBootRefusalError, type SessionRunClaimSource, type SessionRunRollupSource, type SessionSummary } from "./store-contracts.js";
+import { StoreBootRefusalError, type SessionRootRows, type SessionRunClaimSource, type SessionRunRollupSource, type SessionSummary } from "./store-contracts.js";
 import { type ClientSessionRowWrite, type ReplaySessionRowWrite, type ReplaySessionRowWriteOutcome, type SessionRowAnswer, type SessionRowPatch, type SessionRowWriteOutcome } from "../session-row.js";
 import { type SqlJsonColumnProblem } from "./sql-json-column.js";
 import { type LocalArchiveKeptStamped, type LocalArchiveUnreadable } from "./one-time-migrations.js";
+import { type ReleaseTriple } from "./release-version.js";
 import { type Logger } from "../observability/logger.js";
-import { type SessionFace } from "../session-incarnation.js";
+import type { SessionOccupant } from "../session-erase.js";
+import { type RegisterReceipt, type SessionBirth, type SessionFace, type WithdrawOutcome } from "../session-incarnation.js";
+import type { SessionDeletionFace } from "../session-deletion.js";
+import { type ExecutionLane } from "../execution-lane-caps.js";
 import { type ExecutionPlacementSeat, type LocalPlacementBackfillSeat } from "../execution-placement.js";
 import { type ForkPlacement, type ForkTarget, type ForkToOutcome } from "./session-fork.js";
 import { type InstructionSourceBaseline } from "../instruction-source-notice.js";
 import type { SessionWorkspace } from "../session-workspace.js";
 import { type StagedCommitOptions, type StagingHandle, type SyncRelation } from "../session-sync-kernel.js";
+/**
+ * 本店执行格的形(会话元数据那一格的 `execution` 位;规则在 `src/execution-placement.ts`):`writer(L)` | `mirror`;缺 = absent。
+ * local 车道没有 device 表 ⇒ 不设任何设备位(writer 只带车道)。`forking` 不是存下的值,是「fork 创建的格({@link isForkCreatedCell})而存档不在」的读法。
+ */
+type LocalExecutionCell = {
+    readonly role: "writer";
+    readonly lane: ExecutionLane;
+} | {
+    readonly role: "mirror";
+};
+/** 对象形一格(六位;`owner` 键缺 = 属主从没被记下,与 `owner: null` = 记下无主不同义)。 */
+interface SessionMetaCellObject {
+    readonly incarnation: string;
+    readonly owner?: string | null;
+    readonly execution?: LocalExecutionCell;
+    readonly forkKey?: string;
+    /** 行的建档时刻(ISO;SQL `session_meta.created_at` 的对位)。每个铸行点同一笔写下;缺 = 补铸的格(没有事实可写),或一次性迁移 M33 之前写下、还没回填的格。 */
+    readonly createdAt?: string;
+    /** fork 谱系:建这一行的那次 fork 的源会话 id(只由 fork 创建点写)。缺 = 这一行不是 fork 建的。 */
+    readonly forkedFrom?: string;
+    /**
+     * fork 谱系的住客那一半:源行在 fork 那一刻的住客令牌(这只边档那一格的令牌体系 —— 与 SQL 孪生 `session_meta.forked_from_incarnation` 同义),与 `forkedFrom` 同一笔、
+     * 只由 fork 创建点写(core `forkRowCells` 铸)。缺 = 不是 fork 建的,或这一位落地之前建的 fork / 源那一刻没有格(来源住客未知,不回填)。
+     */
+    readonly forkedFromIncarnation?: string;
+    /**
+     * 「删除中」(删一行的唯一删序的第一笔,{@link LocalSessionStore.dropRowHeld} 的 s0):在 = 删除已经开始、还没收完 —— 这一行对每个读者都不在(读者律),每一节会话写锁先把它收完(写者律),
+     * 起服扫一遍逐只收尾。只有删序写它、只有删序的收尾删它;别的写者撞上带它的格 = 不变量破,响亮抛。缺 = 活行。
+     */
+    readonly dropping?: true;
+    /**
+     * 「在删」(会话三态 活 → 在删 → 没了 的中间一态,律在 `src/session-deletion.ts`):值 = 立了围栏的那一次删除的**令牌**。在 = 一次删除已经在这只会话的写锁里判过
+     * 「没有认领、属主是调用方」,还没删完 —— 删除门之外的一切读者与写者读作「行不在」(读者律同 `dropping`),写者撞上它不写(登记 = 已存在;其余写者响亮抛);
+     * 只有删除面写它:围栏写、接管换写,终刀的删序随这一格一起删。与 `dropping` 两件事:`dropping` = 这一行的字节正在删(店内删序 s0),`deleting` = 这只会话正被一次删除独占。
+     * 缺 = 不在删。
+     */
+    readonly deleting?: string;
+    /**
+     * 客户端写计数(提交出口的撤回判据,`session-birth.ts`;SQL 孪生 `session_ext.client_writes`):客户端可见会话态的四个写者(行格写 / 导入 / 会话规则 / 附件绑定)
+     * 在这只会话的写锁里、自己的写之前 +1。**在场即版本位** —— 本版的登记新行臂铸格时写 `0`(「生在计数协议之下」);缺 = 本版之前铸的格(或不经登记铸的格),
+     * 撤回对它一律答「留」(`upgrade_pending`)。不需要一次性升级:撤回的候选只可能是本版登记新铸的格(化身比对,`session-birth.ts`),缺这一位的格永远不是候选。
+     */
+    readonly clientWrites?: number;
+}
+/**
+ * 会话元数据边档(`session-incarnations.json`)的一格 —— SQL 孪生 `session_meta` 行在本店的对位(同一行 ⇒ 同一格、同一次落盘):属主 / 化身 / 执行放置 / `fork_key` /
+ * 建档时刻 / fork 谱系。**本店读的每一样行事实只住在这里**(规则一,见 {@link LocalSessionStore} 的 `rowMetadataOf` 注):引擎仓里的存档是匿名内容仓,存档头上的属主、
+ * 建档时刻、谱系本店都不读。两形:
+ *  · 对象 `{ incarnation, owner?, execution?, forkKey?, createdAt?, forkedFrom?, forkedFromIncarnation? }` —— `owner` 键在 = 属主**记下了**(`owner: null` = 登记为无主的会话,与 SQL 列上的 NULL 同义);
+ *    `owner` 键缺 = 属主**从没被记下**(与裸串同义);`execution` 缺 = absent;`forkKey` = 建这一格的那次 fork 请求的键(只由 fork 创建点写);`createdAt` / `forkedFrom` / `forkedFromIncarnation` 见上。
+ *  · 裸串(只有化身)—— **只读旧形,不再新写**:7.118.x 及更早只往这只边档里写化身(属主那时只活在进程内存里),那些格原样留在盘上;读作「属主从没被记下」、
+ *    登记不认领它({@link LocalSessionStore.register} 只补化身;7.119.0–7.147.x 的升级窗内曾由一次性迁移 M10 让带 principal 的登记认领,窗关、认领臂删)。本店补铸 / 只补化身时写对象形 `{ incarnation }`(同义)。
+ * **每个写者只改自己那一位**、其余照 `before` 带过({@link cellWith} / {@link cellObjectOf}):执行位的写永不写 `owner` 键 ⇒ 遗留格回填执行位后仍是「未记」(读作无主);
+ * 推送 / 换装改属主与执行位,建档时刻与谱系照带。
+ * 文件名是 7.104.0 起就在盘上的那一只(当时只装化身)—— 它是持久面,换名要一次搬家迁移,而里面装的仍是同一张「会话元数据」表。
+ */
+type SessionMetaCell = string | SessionMetaCellObject;
 /**
  * 对象形一格的形(本店是它唯一的写者,形属主就在这里):不收别的键 —— 一只不认得某一位的读者(回滚到的上一版)对带着那一位的格整只严格拒,
  * 而不是把它读丢(边档是严格读,见 `SidecarMap.strict`)。
@@ -21,20 +82,25 @@ export declare const SESSION_META_CELL_OBJECT: z.ZodObject<{
     owner: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     execution: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         role: z.ZodLiteral<"writer">;
-        lane: z.ZodCustom<"host" | "e2b" | "k8s" | "ssh" | "adb" | "local-docker" | "device" | "none", "host" | "e2b" | "k8s" | "ssh" | "adb" | "local-docker" | "device" | "none">;
+        lane: z.ZodCustom<"none" | "host" | "e2b" | "k8s" | "ssh" | "adb" | "local-docker" | "device", "none" | "host" | "e2b" | "k8s" | "ssh" | "adb" | "local-docker" | "device">;
     }, z.core.$strict>, z.ZodObject<{
         role: z.ZodLiteral<"mirror">;
     }, z.core.$strict>], "role">>;
     forkKey: z.ZodOptional<z.ZodString>;
     createdAt: z.ZodOptional<z.ZodString>;
     forkedFrom: z.ZodOptional<z.ZodString>;
+    forkedFromIncarnation: z.ZodOptional<z.ZodString>;
+    dropping: z.ZodOptional<z.ZodLiteral<true>>;
+    deleting: z.ZodOptional<z.ZodString>;
+    clientWrites: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
 /**
  * 数据根对账里一只文件的读数(拒句的逐文件一段;{@link LocalDataRootSchemaMismatchError.findings}):严格边档清册里的一只边档,或引擎版本高水位 marker
- * (`local-engine-high-water.ts`)。**判别联合**,判别位 `problem`:`"newer-engine"` ⇒ {@link LocalDataRootNewerEngine}(必带 `engineHighWater`);
- * 别的每一个词 ⇒ {@link LocalDataRootUnreadable}(没有 `engineHighWater`)—— 载荷跟着判别位走,由类型保证,不靠运行时约定。
+ * (`local-engine-high-water.ts`),或跳过了必经一次性迁移的会话存档目录({@link judgeArchiveTokenAdoptionDuty})。**判别联合**,判别位 `problem`:
+ * `"newer-engine"` ⇒ {@link LocalDataRootNewerEngine}(必带 `engineHighWater`);`"skipped-required-migration"` ⇒ {@link LocalDataRootSkippedMigration}(必带 `skippedMigration`);
+ * 别的每一个词 ⇒ {@link LocalDataRootUnreadable}(两样都没有)—— 载荷跟着判别位走,由类型保证,不靠运行时约定。
  */
-export type LocalDataRootMismatch = LocalDataRootUnreadable | LocalDataRootNewerEngine;
+export type LocalDataRootMismatch = LocalDataRootUnreadable | LocalDataRootNewerEngine | LocalDataRootSkippedMigration;
 /**
  * 读不出的种别:形 —— `not-json` / `malformed` / `not-text`(形读者的判词),或 I/O 的 errno(`EACCES` / `EISDIR` / 悬空符号链接的 `ENOENT` …,恒以 `E` 起头);
  * 说不出 errno ⇒ `unreadable`。`newer-engine` 不在其中(那是另一支)。
@@ -64,12 +130,45 @@ export interface LocalDataRootNewerEngine {
         readonly engine: string;
     };
 }
+/**
+ * 数据根跳过了一条**必经**的一次性迁移(本构建已不带它),而根里还留着那条迁移要处理的形 —— 哪一形由 `skippedMigration.residue` 说(判别联合,闭集):
+ *  · `archives-without-cell` —— 会话存档在、会话元数据格缺:存档头上的住客令牌没被收进行({@link judgeArchiveTokenAdoptionDuty})。两种来历由两格推出(不另带位):
+ *    `highWater` 为 `null` 或早于 `requiredSince` ⇒ 带那条迁移的版本从没打开过这只根;不早于 ⇒ 带它的版本打开过、没收完(收令牌欠账标记还在);
+ *  · `pre-cutoff-skill-exemptions` —— 会话豁免日志里有首次放行早于 `Skill` 豁免截点(或截点缺席)的 `Skill` 行(`approval-exemption-skill-cutoff.ts`,数据根准入判);
+ *    `cutoff` = 截点(`null` = 根里没有截点文件:落截点的版本从没完整打开过这只根)。
+ * 出路一律要一个**不低于 `requiredSince` 与 `highWater` 两者**、仍带那条迁移的版本完整起一次(更低的会被高水位拒在门外)。
+ */
+export interface LocalDataRootSkippedMigration {
+    /** 那一形住的目录(会话存档目录 / 会话豁免日志目录)的绝对路径。 */
+    readonly path: string;
+    /** 角色(`sessions (the local session archives)` / `approval-exemptions (the local session approval exemptions)`)。 */
+    readonly label: string;
+    readonly problem: "skipped-required-migration";
+    readonly unknownFields: readonly [];
+    /**
+     * `highWater` = 这只根记的引擎高水位(纯 `x.y.z`;`null` = 没有 marker:只被不记高水位的引擎打开过 —— 7.148.0 之前的 run-local、7.144.0 之前的服务);
+     * `requiredSince` = 那条迁移的引入版本(根必须被它或更新、且仍带它的版本完整起过一次);`sessions` = 那一形的会话数。
+     */
+    readonly skippedMigration: {
+        readonly residue: "archives-without-cell";
+        readonly highWater: string | null;
+        readonly requiredSince: string;
+        readonly sessions: number;
+    } | {
+        readonly residue: "pre-cutoff-skill-exemptions";
+        readonly highWater: string | null;
+        readonly requiredSince: string;
+        readonly sessions: number;
+        readonly cutoff: string | null;
+    };
+}
 /**
  * **local 数据根的「本构建读不出」拒**(起服对账一族的 local 腿;机读码与 SQL 列册对账同一个 `config.schema_mismatch`,拒句同形)。
  * 一只严格边档用它那一只严格读者读不出 ⇒ 这一只拒,文件原地不动、一个字节不改。两处触发、一只类:
- *  · `boot` —— 两处拒启:local 后端**打开数据根的那一刻**(锁在手之后、本仓任何一只店建起之前;`store-backend.ts` 的 `openLocalBackend`)引擎版本高水位 marker 读不出 / 高于本构建
- *    (`local-engine-high-water.ts`,读数种别 `newer-engine` 或读不出的那几种;同一判词「数据根比代码新」的第二种证据 —— 这一拒由公开序列的 `ensureSchema()` 交出);
- *    起服对账(`LocalBackend.ensureSchema()`)里严格边档清册读不出的每一只合成一只({@link LocalSessionStore.assertStrictSidecarsReadable});
+ *  · `boot` —— **只由数据根准入铸**(`local-data-root-admission.ts` 的 `admitLocalDataRoot`:只读,本进程对这只根第一笔写之前 ⇒ 拒句说「数据根一个字节没动」处处成立):
+ *    引擎版本高水位 marker 读不出 / 高于本构建(`local-engine-high-water.ts`,读数种别 `newer-engine` 或读不出的那几种;同一判词「数据根比代码新」的第二种证据)、
+ *    严格边档清册读不出的每一只合成一只({@link judgeStrictSidecars})、跳版拒启臂({@link judgeArchiveTokenAdoptionDuty},读数种别 `skipped-required-migration`);
+ *    公开序列上由 `ensureSchema()` 交出(`createStoreBackend()` 的 local 腿当场取准入,拒 ⇒ 交回一只没取锁的拒后端);
  *  · `serving` —— 起服之后这只边档第一次被碰时才读不出(嵌入方跳过了 `ensureSchema()`;或起服后别的写者把它写成本构建读不出的形,在替换之前那一读里看见):
  *    读不出的是**形**(`not-json` / `malformed`,确定的判词)⇒ 这只边档在本进程里从此每一读每一写都交这一只(重启才重判);碰它的请求失败(把它交给 HTTP 全局兜底的路由:
  *    500 `internal.error` + 一行 error 级 `request_error` 带本码;自己接住故障的路由按各自的 500 臂答)。I/O 故障(非确定)不粘。
@@ -82,6 +181,61 @@ export declare class LocalDataRootSchemaMismatchError extends StoreBootRefusalEr
     readonly code = "config.schema_mismatch";
     constructor(findings: readonly LocalDataRootMismatch[], when: "boot" | "serving");
 }
+/**
+ * 「会话存档在而会话元数据格缺 ⇒ 建一格,化身沿用存档头上的令牌」那条一次性迁移(登记表 M47,`one-time-migrations.ts`)的引入版本 —— 跳版拒启臂的唯一常量。
+ * 登记表 M47 行的 `introducedIn` 与它逐字相同(`test/local-root-one-row-store.test.ts` 钉);M47 删码之后行不在了,臂照读这里。
+ */
+export declare const ARCHIVE_TOKEN_ADOPTION_SINCE = "7.148.0";
+/**
+ * 欠账标记在不在(`lstat`:目录里有这一项就算在 —— 悬空符号链接也是在;`ENOENT` = 不在;别的故障原样抛 = 判不了 ⇒ 调用方不放行)。只读在场,不读内容。
+ * 读者两位:常驻臂({@link judgeArchiveTokenAdoptionDuty},不带迁移的构建)与迁移的尾部(`LocalSessionStore.adoptArchiveTokensM47`:在 ⇒ 这一次起服是欠账起服)。
+ */
+export declare function archiveTokenAdoptionPendingPresent(root: string): boolean;
+/** 数据根存档目录里的会话 id(同步一读,只读目录项、不读存档):存档目录不在 ⇒ 空;目录读故障原样抛(判不了 ⇒ 不放行)。三位读者读同一只布局:记账、常驻臂与收令牌的证明。 */
+export declare function archiveIdsInSync(root: string): string[];
+/** 严格边档的同步一读的读数(数据根准入与 M47 收尾证明共用;读不出 ⇒ 一段读数,由调用方决定拒形)。 */
+type StrictSidecarReading<V> = {
+    readonly state: "absent";
+} | {
+    readonly state: "read";
+    readonly entries: Record<string, V>;
+} | {
+    readonly state: "unreadable";
+    readonly finding: LocalDataRootMismatch;
+};
+/** 严格边档清册的字节(按清册次序;同步一读,零写)—— 数据根准入的观察读它,锁内的「没动」核对读同一只。 */
+export declare function readStrictSidecarTextsSync(root: string): readonly DataRootFileText[];
+/** 会话元数据边档的严格同步一读(清册里那一只;在窗的 M40 改名在内存里先套)—— M47 收尾的证明读盘上此刻那一份。 */
+export declare function readSessionMetaCellsSync(root: string): StrictSidecarReading<SessionMetaCell>;
+/**
+ * **数据根准入的严格边档一格**(纯;唯一调用点 = `local-data-root-admission.ts` 的 `admitLocalDataRoot`,判的是准入那一次观察里的字节 `texts`,按清册次序):
+ * 读不出的合成**一只** {@link LocalDataRootSchemaMismatchError}(`boot` 形,逐文件一段)⇒ 拒。缺席 = 还没有,不是读不出(交空表)。
+ * 7.148.0 及以前这一问在 `LocalBackend.ensureSchema()` 里(店构造、抬高水位、M40 写之后);搬到准入里,被拒的起服才真的零写。
+ * 交回会话元数据的格(准入的跳版臂按它数「存档在而格缺」)。
+ */
+export declare function judgeStrictSidecars(root: string, texts: readonly DataRootFileText[]): Readonly<Record<string, SessionMetaCell>>;
+/** 跳版臂的动作(准入算、锁内做):`record` = 带 M47 的构建要在抬之前记欠账;`discharge` = 欠账标记在而无事可收,抬之前销账;`none` = 不写。 */
+export type ArchiveTokenAdoptionDutyAction = "none" | "record" | "discharge";
+/**
+ * **判收令牌欠账**(纯,无窗;唯一调用点 = 数据根准入 `admitLocalDataRoot`,判的是准入那一次观察里的存档 id、欠账标记在不在与会话元数据的格)。
+ * 两件事、两只事实:「谁可能写过这只根」归引擎高水位(本函数只读它的读数);「这只根还欠不欠那条迁移」归欠账标记({@link ARCHIVE_TOKEN_ADOPTION_PENDING_FILE})。
+ * 「欠账开着吗」只在这一处判 —— 带迁移的构建算出要记、不带迁移的构建拒:
+ *  · **带迁移**(`adoptionCarried` = 登记表 `migrationCarried("M47")`:行随码同删 —— 删码那一版起臂恒判)⇒ 打开之前的高水位早于 {@link ARCHIVE_TOKEN_ADOPTION_SINCE} 或缺席(带那条迁移的版本从没打开过这只根)
+ *    ∧ 存档目录里至少一只存档 ⇒ `record`(锁内、抬之前由 {@link settleArchiveTokenAdoptionDuty} 原子写欠账标记)。只读目录、不读会话元数据边档(那一读归准入的严格边档一格)。
+ *    销账在迁移的尾部:`required` 提交 → 用常驻臂的同一只读法证明收齐 → 删标记(任何一步失败标记留着)。
+ *  · **不带迁移** ⇒ **常驻臂**:(① 打开之前的高水位早于引入版本或缺席 ∨ ② 欠账标记在)∧ 根里有存档在而格缺的会话(`cells` = 准入那一读的会话元数据格)⇒
+ *    {@link LocalDataRootSchemaMismatchError}(`boot`,读数种别 `skipped-required-migration`;② 那一支的拒句点名「打开过它的那一版带这条迁移但没收完」与「不低于已记高水位」的出路)。
+ *    拒在准入里 ⇒ 数据根零写、高水位不抬 ⇒ 拒句点名的那一版(带那条迁移、不比已记高水位旧)仍开得了这只根。① ② 都假 ⇒ 带那条迁移的版本收齐过这只根,此后的无格存档只可能是
+ *    建档与写格之间的崩溃留下的(头令牌从没交出过,补铸无害)。标记在而无格存档为零(收齐之后、销账之前停了)⇒ `discharge`(锁内、抬之前删):留着它,高水位抬过窗内版本之后
+ *    一只崩溃生的无格存档就让这只根被拒,而出路要的「不低于已记高水位、仍带那条迁移」的版本不存在。
+ */
+export declare function judgeArchiveTokenAdoptionDuty(root: string, priorHighWater: ReleaseTriple | undefined, adoptionCarried: boolean, observed: {
+    readonly cells: Readonly<Record<string, unknown>>;
+    readonly archiveIds: readonly string[];
+    readonly adoptionPending: boolean;
+}): ArchiveTokenAdoptionDutyAction;
+/** **做收令牌欠账的动作**(锁内;准入的读数核过之后、抬高水位之前;唯一调用点 = 数据根准入的锁内一步)。`record` 写不进 ⇒ 抛(抬之前拒)。 */
+export declare function settleArchiveTokenAdoptionDuty(physicalRoot: string, priorHighWater: ReleaseTriple | undefined, action: ArchiveTokenAdoptionDutyAction): void;
 /** 数据根对账文件的一读的读数(两个出口同形)。 */
 export type DataRootFileText = {
     readonly state: "absent";
@@ -133,6 +287,13 @@ export declare class LocalArchiveSnapshotsPresentError extends StoreBootRefusalE
  * 目录在而读不了(权限 / I/O)⇒ 同一只拒(判不出里面有没有快照 —— fail-closed,不让起服降级臂把它读成「这台机器存不了盘」)。
  */
 export declare function assertNoArchiveSnapshots(dir: string): void;
+/** M47 local 腿一次跑的读数({@link LocalSessionStore.adoptArchiveTokensM47};报告键见 `one-time-migrations.ts` 的 `localArchiveTokensAdopted` / `localArchiveTokensMinted`)。 */
+export interface LocalArchiveTokenAdoption {
+    /** 建了格、化身沿用存档头令牌的会话数。 */
+    readonly adopted: number;
+    /** 建了格、存档头没有令牌(7.49.0 之前的存档)而新铸的会话数。 */
+    readonly minted: number;
+}
 export interface LocalArchiveMigrationReading {
     /** 补了行事实(建档时刻 / 谱系)的格数(含为盘上有存档而没有格的会话新建的格)。 */
     readonly rowFactsBackfilled: number;
@@ -154,7 +315,20 @@ export interface LocalSessionStoreDeclaration {
     readonly durability?: StoreDurability;
     readonly placements?: NonNullable<SessionStore["placements"]>;
 }
-export declare class LocalSessionStore implements SessionStore {
+/**
+ * 条件撤回的 run 半(run 店的窄面;文件 / 内存 run 店都答)—— local 会话店在这只会话的写锁(= 根行锁)里调,实现**不得再取根行锁**(锁不可重入)。
+ * 本会话有 `ownTaskId` 之外的 run 行 ⇒ `{ keep: "runs" }`、一个字节不删;否则**严格**删掉本次 run 的部署行(先盘后索引、失败即抛)⇒ `"proceed"`。
+ */
+export interface SessionRunWithdrawSource {
+    withdrawRunsOf(sessionId: string, ownTaskId: string | undefined): "proceed" | {
+        readonly keep: "runs";
+    };
+}
+/** 本店的撤回装配(装配方给;SQL 孪生的部署判据的 local 对位):本会话的续跑输入怎么严格删(数据根上的 checkpoint ctx 档;缺 = 本部署没有续跑输入可删)。 */
+export interface LocalSessionWithdrawDeclaration {
+    readonly withdrawCheckpointCtx?: (sessionId: string) => void;
+}
+export declare class LocalSessionStore implements SessionStore, SessionRootRows {
     private readonly repo;
     private readonly runs;
     /** [ref] 车1:托管留存声明 —— **诚实的 none**。本店的行没有任何按期删除的腿(留存 lane 的三方法只实现在
@@ -183,13 +357,6 @@ export declare class LocalSessionStore implements SessionStore {
     private readonly recordedPlacementOf;
     /** In-flight acquisitions keyed by id, so concurrent acquire(sameId) in one process share one (mirrors TiDBSessionStore). */
     private readonly pending;
-    /**
-     * 本进程里删行已经开始的会话 id(删除与 placed 行的 release 都在 {@link dropRowHeld} 第一步登记)。锁外读者的补铸({@link cellOfPresent}:格缺而存档在 ⇒ 当作
-     * 7.104.0 之前写下的会话补一格)对登记过的 id 不铸 —— 删行的那一笔与存档的删除不是同一笔(placed 行存档最后删,存档行头是重试判别位),两笔之间盘上正是
-     * 「格缺而存档在」那一形;锁外的读若照旧补铸,存档随后删掉就留下一只没有存档的格(读作一只无主会话,再 release 也清不掉)。删行一开始,这一行对读者就不在了;
-     * 中途失败、存档还在 ⇒ 读者读作不在,重发收完。进程内只增(一只删掉的会话一个 id);补铸只对格缺的存档起作用,所以同 id 再建(登记 / 导入 / 建会话都自己铸格)不受影响。
-     */
-    private readonly rowsDropped;
     /** Last-activity marker (touch) for ordering — the keyset sort key for {@link listSessions}. PERSISTED to a JSON
      *  sidecar under {@link dataDir} (when given) so the /resume picker's newest-first order SURVIVES a service restart:
      *  without persistence the map starts EMPTY on boot and every session degrades to `createdAt` ordering (the picker
@@ -240,12 +407,7 @@ export declare class LocalSessionStore implements SessionStore {
      * 盘上有会话而边档里没有它那一格 ⇒ 第一次读补铸一格只有化身的(属主没有事实可写)并落盘。严格读(读不出 ⇒ 整只拒,见 `SidecarMap.strict`)。
      */
     private readonly meta;
-    /**
-     * [ref] —— 本店的**严格边档清册**(今天一只:会话元数据)。唯一来源 = 构造里 `sidecar(…, strict)` 那一参:工厂造出严格读的边档时同一手登进来,
-     * 没有第二张手写名单。读者只有起服对账 {@link assertStrictSidecarsReadable}。
-     */
-    private readonly strictSidecars;
-    /** 认领行(`session_owner_claimed`,一次性迁移 M10 的认领臂,窗口见 `plugins/one-time-migrations.ts` 登记表)的出口(本店今天只有这一行经它;委派孤行 warn 的铸点已不在 `src/`)。 */
+    /** 本店运维日志行(存档收尾未完成 `session_drop_unfinished`、令牌收养跳过 `archive_token_adoption_skipped`)的出口。 */
     private readonly log;
     /**
      * 按会话的写锁(表见 {@link SESSION_WRITE_LOCKS_BY_ROOT})—— 会话行两位的**每一笔**写(用户的行格写原语:判 → 边档草稿 → 落盘 → 发布;自动标题器的
@@ -258,161 +420,212 @@ export declare class LocalSessionStore implements SessionStore {
     private readonly sessionWriteLocks;
     /**
      * 执行席(规则在 `src/execution-placement.ts`):读 = 那一格的 `execution` 位(fork 创建的格而存档不在 ⇒ `forking`);place / markMirror 在这只会话的写锁里判住客
-     * (化身 + 头读投影的属主 `owner ?? null`)再只改 `execution` 那一位 —— 住客换了(删后重建、M10 窗内认领)⇒ `gone`,不写。
+     * (化身 + 头读投影的属主 `owner ?? null`)再只改 `execution` 那一位 —— 住客换了(删后重建)⇒ `gone`,不写。
      * 认领(run 店的单活槽,{@link SessionRunClaimSource}):`markMirror` 在同一把写锁里读它、只拦「absent → mirror」这一笔(判序与 SQL 孪生同,见 {@link markMirrorExecution});`place` 是认领持有者自己的初始放置写,不读认领。
-     * 导入三写口(整段 `importEntries` / `replaceEntries` / 暂存提交)同在写锁里读它、交 SQL 事务内钩 `import` 臂的那一只判官 {@link judgeImportWrite}(见 {@link admitImportHeld});路由的认领判(第一阶段写前判 + 提交前复判)是更早的一道,不是唯一一道。
+     * 导入三写口(整段 `importEntries` / `replaceEntries` / 暂存提交)同在写锁里读它、交 SQL 事务内钩 `import` 臂的那一只判官 {@link judgeSessionWrite}(见 {@link admitImportHeld});路由的认领判(第一阶段写前判 + 提交前复判)是更早的一道,不是唯一一道。
      */
     readonly executionPlacement: ExecutionPlacementSeat;
     /**
-     * 一次性迁移 M32 的 local 腿用的席(随 M32 · 窗口见 `one-time-migrations.ts` 登记表):`read` 与 {@link executionPlacement} 的 `read` 是**同一读**({@link placementRead}),只差「这只会话的存档读不出」这一形
-     * (格缺而探针读不出;fork 创建的格而探针说不出在不在)—— 席的读照旧抛那只故障,本席答 {@link UnusableArchive}(开机回填不动存档、只补一格放置:读不出的会话由回填点名跳过,不拒启)。
-     * `place` 就是席的 `place`。
+     * 一次性迁移 M32 的 local 腿用的席(随 M32 · 窗口见 `one-time-migrations.ts` 登记表):唯一成员 `backfill` = {@link backfillPlacement} —— 锁里观察一次、一笔写成 writer
+     * (观察抛 ⇒ 答 {@link UnusableArchive} 点名跳过,开机回填不动存档;车道表不是一项 ⇒ `ambiguous`、不写)。
      */
     readonly executionPlacementBackfill: LocalPlacementBackfillSeat;
     /** 数据根(`resolve()` 之后;内存部署 = `undefined`)—— 一次性迁移 M33 的快照目录住在它下面(窗口见 `plugins/one-time-migrations.ts` 登记表)。 */
     private readonly dataRoot;
     /** 一次性迁移 M33:本进程起服以来消化掉的快照记录数(恢复先行那一步累加,迁移读数交出时清零)。 */
     private archiveSnapshotsSettled;
+    /** 撤回时本会话续跑输入的严格删法({@link LocalSessionWithdrawDeclaration};缺 = 没有可删的)。 */
+    private readonly withdrawCheckpointCtx;
     /** @param repo     the core SessionRepo this store projects into the §0.5 SessionStore shape.
      *  @param runs     the run store whose per-session projection is the ONLY source of a row's `runCount` / `lastStatus` / `lastRunId` /
      *                  `lastTaskRunId` (LocalBackend passes its `FileRunStore`). Required — a run-less local session store does not exist.
      *  @param dataDir  the SAME data dir the file-backed repo persists under (LocalBackend passes `fileBackend.root`).
      *                  When given, lastActivity is persisted to `<dataDir>/session-last-activity.json` so it survives a
      *                  restart (the file-backed deployment); omit it for the in-memory deployment (nothing survives).
-     *  @param opts.log the `session_owner_claimed` line's sink (LocalBackend passes a logger at the deployment's
-     *                  LOG_LEVEL; absent ⇒ an info-level JSON-line logger — a claim is never silent).
+     *  @param opts.log the sink of this store's operator log lines (LocalBackend passes a logger at the deployment's
+     *                  LOG_LEVEL; absent ⇒ an info-level JSON-line logger).
      *  @param opts.durability / opts.placements the deployment's declaration ({@link LocalSessionStoreDeclaration}; see the two fields). */
     constructor(repo: HeadReadingSessionRepo & Partial<PlacementRecordingRepo>, runs: SessionRunRollupSource & SessionRunClaimSource, dataDir?: string, opts?: {
         log?: Pick<Logger, "info" | "warn">;
-    } & LocalSessionStoreDeclaration);
+    } & LocalSessionStoreDeclaration & LocalSessionWithdrawDeclaration);
     /**
      * 🔴 一次性迁移 **M40 的 local 会话腿**(窗口见 `plugins/one-time-migrations.ts` 登记表 M40 行;唯一调用点 `LocalBackend.ensureSchema()` 的**第一步**,
-     * 排在 {@link assertStrictSidecarsReadable} 之前 —— 严格读的执行位只认本版车道词,旧词先到那里就整只拒启):会话元数据边档里 `execution` 位记成退役词的
+     * 先于任何读会话元数据的店步骤 —— 严格读的执行位只认本版车道词;数据根准入的那一读在内存里先套同一只内核 {@link renameRetiredExecutionLaneWordsInCellsM40},零写):会话元数据边档里 `execution` 位记成退役词的
      * writer 格改记新名,整只原子重写一次。只改那一个词,别的字节按 JSON 原样写回。字节经边档的唯一一读({@link readDataRootFileText})。
      * 缺文件 / 读不出(I/O 故障如 EACCES / EISDIR、坏 JSON、不是对象)⇒ 不抛、不改,交给其后的严格对账判 —— 它读同一只文件、以 `config.schema_mismatch`
      * 拒(那是这只拒码在本店的唯一铸点);这里抛了,拒码与具名拒都会丢。读得出而写不进 ⇒ {@link ExecutionLaneRenameWriteRefusedError}(拒启,降级臂不吞)。
      * 内存部署 / 没有旧词 ⇒ 零写。返回改了的格数。词的属主 = `execution-lane-rename-m40.ts`。
      */
+    /** 一次性迁移 **M42 的 local 腿**(场景前缀的切换检查;窗口见 `plugins/one-time-migrations.ts` 登记表):会话元数据格里属主以保留前缀开头的会话数(严格边档那一读,零写)。 */
+    scenarioPrefixOwnerRowsM42(): Promise<number>;
     renameRetiredExecutionLaneWordM40(): Promise<number>;
-    /**
-     * [ref] —— **起服对账的 local 腿**(SQL 列册对账的对位;唯一调用点 `LocalBackend.ensureSchema()`,排在 M33 快照消化之前 —— 消化会写会话元数据格):
-     * 严格边档清册里的每一只读一次盘(`SidecarMap.reconcile`:冷 ⇒ 载入那一读;已载入 ⇒ 重读只判);读不出的合成**一只** {@link LocalDataRootSchemaMismatchError}
-     * (`boot` 形,逐文件一段)⇒ 拒启,开始服务之前。每一只只会以那一只拒失败(严格读的拒臂把读不出的每一形都收成它);别的故障原样上抛(响亮,不归并)。内存部署(没有数据根)⇒ 零读。
-     */
-    assertStrictSidecarsReadable(): Promise<void>;
     /**
      * 这一格此刻是不是 `forking`(fork 创建的格 {@link isForkCreatedCell} ∧ 存档不在)。存档在不在只问 repo 的唯一探针 {@link probeArchive} 的「不在」—— **只问有没有**:存档在而用不了(会话头读不出 / 截断)
      * 是「在」,内容读不读得出归真正读内容的那一读(门之后、体之前读一次叶子,读不出 ⇒ `corrupt_session`)。所以带键的会话与不带键的会话在执行席上同形,坏档照样能被换装修好
-     * (换装是修坏档的唯一路径)。**唯一的例外是探针说不出在不在**(`storage` 词:读的时候抛了别的故障)⇒ 不替它答 forking 与否:{@link forkingOf} 把那只故障上抛(要对这只会话动手的读者 ——
-     * 写口的判、登记、缺档新建臂 —— 看到它就抛),{@link forkingRead} 交出 {@link UnusableArchive}(执行席的读上抛它,回填席点名它)。持这只会话的写锁时读数稳定(改存档在不在的写者都持这把锁);锁外是一次观察。
+     * (换装是修坏档的唯一路径)。探针说不出在不在(`storage`)⇒ 原样抛(不替它答 forking 与否)。持这只会话的写锁时读数稳定(改存档在不在的写者都持这把锁);锁外是一次观察。
      */
-    private forkingRead;
-    /** {@link forkingRead} 的上抛一形(与 {@link metaOf} 之于 {@link metaRead} 同一条规矩):探针说不出在不在 ⇒ 抛那只故障、原样。 */
     private forkingOf;
     /**
-     * 执行放置的读**本体**(一次:那一格 + 必要时的存档探针;两只席的读共用这一只)。行不在 ⇒ `undefined`;盘上有会话而格缺 ⇒ 补铸(与 {@link headOf} 同一只 {@link metaRead});
-     * 存档读不出({@link UnusableArchive}:格缺而探针读不出 ⇒ 不补铸;fork 创建的格而探针说不出在不在 ⇒ {@link forkingRead} 交出)⇒ 交出这只 {@link UnusableArchive}。
-     * 上抛还是点名,归两只席各自的读者({@link readExecutionPlacement} 上抛那只故障;{@link executionPlacementBackfill} 原样交出)。
+     * **观察** —— 一只会话此刻的行事实(存档事实的唯一读者,答形见 {@link RowObservation};**不补铸、不写**;存储故障原样抛):
+     * 那一格({@link cellStateOf}:标记格 ⇒ `absent`)· 格缺时存档的唯一探针一次 · `want.placement` ⇒ 行头上的元组一次({@link placedRecordOf}:行头读不出 ⇒ 按普通行答)·
+     * `want.forking` ⇒ fork 创建的格而存档不在({@link forkingOf};placed 行不问)。交出住客面的读者(头读 / 元数据读 / 执行席的读)在观察之后自己补铸遗留行 —— 那是一次写,
+     * 在这只会话的写锁里复判之后才铸({@link metaHeld}):锁外的一次观察可以早于一整条删序,复判挡住「s5 之后补铸幽灵格」。写口在锁里、写之前观察(锁里读数稳定),
+     * 写链草稿上的回调同步,只判草稿上的格 + 观察到的存档事实。
+     */
+    private observeRow;
+    /**
+     * 执行席的读(core 席的合同:读故障抛,不吞成 absent):一次观察(格 + 行头元组 + forking),读数见 {@link executionReadingOf}。遗留行(格缺而存档读得出、不是 placed)⇒
+     * 进这只会话的写锁**整只重新观察**(格 + 行头元组 + forking)再答 —— 锁外那一读可以早于一整条删除加同 id 重建(重建成 placed 行时,锁外的「不是 placed」与锁里的新格拼不成一只读数);
+     * 锁里仍是那只遗留行 ⇒ 补铸({@link mintHeld})后按那一格答。
      */
-    private placementRead;
-    /** 执行席的读(core 席的合同:读故障抛,不吞成 absent):{@link placementRead} 的本体,存档读不出 ⇒ 上抛那只故障、原样(与 {@link metaOf} 同一条规矩:要动存档的读者看到读不出就抛)。 */
     private readExecutionPlacement;
+    /**
+     * 一次性迁移 M32 local 腿的回填(随 M32 · 窗口见 `plugins/one-time-migrations.ts` 登记表;席 {@link executionPlacementBackfill} 的唯一成员):**在这只会话的写锁里观察一次**(格 + 行头元组 + forking),
+     * 抛 ⇒ 席接住、转成 {@link UnusableArchive} 点名跳过(一个字节不写;读不出的存档不归回填判)。absent 的那一格(活格没有执行位、不是 forking)或遗留行(格缺而存档读得出、不是 placed)
+     * ∧ 车道表只有一项 ⇒ **一笔**写成 writer(格缺就在同一笔里铸化身);车道表不是一项 ⇒ `ambiguous`,不写(调用方循环完响亮拒,「Nothing was changed」是真话);
+     * 别的(行不在 / placed / 已有执行位 / forking)⇒ `skipped`。观察与写在同一节锁里 ⇒ 读与写之间没有别的写者(不再按住客谓词重判)。
+     */
+    private backfillPlacement;
     /** place(锁内):判官 {@link settledPlaceOutcome} 在写链的草稿上判(与登记的防 clobber 同一处),可写 ⇒ 只改 `execution` 位。 */
     private placeExecution;
     /**
      * identical 臂补 mirror(锁内):先在这只会话的写锁里读 run 认领(行在才读;SQL 孪生:写事务内锁根行后读 `task_active`,根行不在 ⇒ 不读),再交判官 {@link settledMirrorOutcome};
      * 判官的答案先于认领 —— 行不在 / 住客不同 ⇒ `gone`、writer ⇒ `writer`、已是 mirror ⇒ `mirrored`(幂等零写)都不被认领改写;只有「absent → mirror」这一笔写
-     * 遇上认领 ⇒ `active`(带那只认领的 task id,格不写)。可写且无认领 ⇒ 只改 `execution` 位为 mirror。
+     * 遇上认领 ⇒ `active`(带那只认领的 task id,格不写)。可写且无认领 ⇒ 只改 `execution` 位为 mirror。认领唯一的运行期写者(`createRun`)排在同一把锁后面(规则 L),锁内读数稳定。
      */
     private markMirrorExecution;
     /**
-     * 执行位两只写口的锁内一形(调用方持这只会话的写锁):在写链的草稿上读出这一格(`forking` 在锁内先判 —— 改存档在不在的写者都持这把锁)、交判官,
-     * 判官给 `execution` ⇒ 只改那一位。判官 / 解码抛的错**不在写链里抛**(写链一节抛了会把共享链留成拒态):收下、写链这一节不写、出链后原样上抛。
+     * 执行位两只写口的锁内一形(调用方持这只会话的写锁):先观察一次(行头元组 + forking —— 锁内读数稳定),再在写链的草稿上读出这一格、交判官,判官给 `execution` ⇒ 只改那一位。
+     * 委派分区行 ⇒ 交判官的是「不在」(判官一字不改:`gone`,不写)。判官 / 解码抛的错收下、写链这一节不写、出链后原样上抛。
      */
     private settleExecutionHeld;
-    /** 已发布的那一格(同步读;调用方先 `meta.ensureLoaded()`)。 */
-    private metaCellOf;
+    /**
+     * 一格此刻的四态(观察的格那一半;`meta.state.entries` 只由这一只与 {@link liveCellIds} / {@link droppingIds} / {@link deletingIds} 读):活格 ·
+     * 在删格(一次删除独占着这只会话;它的终刀若停在删序 s0 之后,格同时带标记 —— 仍是在删格:收完它归删除协议,不归写者律)·
+     * 标记格(不在删而字节正在删 —— placed 行的 release / 提交出口撤回的删序停在 s0 之后)· 没有格。
+     * 同步读已发布的表(调用方先 `meta.ensureLoaded()`)。
+     */
+    private cellStateOf;
+    /**
+     * 读者律给直读行边档的读者(标题探针 / 指令来源基线 / 工作区):这只会话的格是不是标记格或在删格(删除已开始、还没收完 —— 行边档上的值可能还在盘上)。
+     * 是 ⇒ 读者答「行不在」的那一读。没有格的 id 不归这里判(边档读者对它们的答法不变)。
+     */
+    private rowDropping;
+    /**
+     * 列表读间的读者律(列表 / 单行摘要在枚举行集之后还要等预览与 run 汇总):枚举之后这只会话的删除开始了(标记格),或已经收完(枚举时有活格、此刻没有格)⇒ 这一行不交出 ——
+     * 否则标记格的属主读作 `null`,带 `includeUnowned` 的调用方会把别人的行当无主行收下(标题、预览照出)。同步判,调用方紧接着同步读属主与行格(同一拍)。
+     */
+    private rowGoneSince;
+    /** 这只会话的**活格**(读者律:标记格 = 行不在 ⇒ `undefined`,与没有格同答)。同步读(调用方先 `meta.ensureLoaded()`)。 */
+    private liveCellOf;
+    /** 活格的 id 全集(排序;行集枚举 {@link rowHeaders} 读它;标记格与在删格都不是活格)。 */
+    private liveCellIds;
+    /** 在删格的 id 全集(带不带删序标记都算;排序;删除面的 `pending` 读它 —— 收尾者的输入)。 */
+    private deletingIds;
+    /** 标记格的 id 全集(排序;起服扫 {@link finishPendingDrops} 读它)。 */
+    private droppingIds;
     /**
      * 把 `sessionId` 那一格写成 `next(before)` 的结果并**落盘**(写链里在草稿上判、写、落盘后才发布给读者 —— 与 instruction-source 同一只 `commit`;
      * 判据建立在每一节之前的盘上状态上,所以防 clobber 的「已记下就不动」写在 `next` 里,不写在链外)。`next` 返回 `undefined` = 不改。
      * 落不了盘 ⇒ 抛(属主与化身都是正确性事实,不做「内存里先记着」的降级:一只没落盘的化身重启后会被换掉 —— 那是另一位住客;
      * 一个没落盘的属主重启后就丢了 —— 那正是 7.119.0 修的病)。返回这一次是否真改了那一格。
+     * 🔴 带「删除中」位的 `before` 只归删序({@link dropRowHeld})改:别的写者撞上它 = 不变量破(每一节会话写锁先收完待删,锁里不该再见到它)⇒ 响亮抛、这一节不写。
+     * 🔴 在删的 `before` 只归删除面(围栏 / 终刀)改:别的写者撞上它 ⇒ `not_found`(在删读作不在;引擎把它映成 `resume.session_not_found`),这一节不写。
      */
     private writeMeta;
-    /** 删一只会话的那一格(落盘;落不了 ⇒ 抛 —— 留下的格会让一只删掉的会话在重启后「还在」)。 */
+    /** 撤回一只刚铸的格(格先、存档后的建行点建存档失败时;落盘;落不了 ⇒ 抛 —— 留下的格就是崩在两步之间的那一形)。不是删一行:删一行只走 {@link dropRowHeld}。 */
     private dropMeta;
+    /**
+     * 规则 L 的根行面({@link SessionRootRows};唯一的消费方 = 文件 run 店的 `createRun`):在这只会话的写锁里判这一行此刻在不在({@link rowPresentHeld}),交给 `body`。
+     * 改行在不在 / 住客 / 读认领的写者(删除 / 导入 / markMirror / placed release / 登记 / 按 id 建 …)都持这把锁,所以 `body` 读到的答案到它完成都成立;
+     * 认领在 `body` 里取 ⇒ 全局锁序 = 根行 → 认领(SQL 孪生同序)。锁不可重入:本店任何持锁节都不调 `createRun`。
+     */
+    withRootRow<T>(sessionId: string, body: (present: boolean) => Promise<T>): Promise<T>;
+    /**
+     * 这一行此刻在不在(锁内一形,调用方持这只会话的写锁 —— 节首已收完待删):观察一次 —— 活格 ⇒ 在;遗留行(格缺而存档在,读得出或在而内容用不了)⇒ 在(行在,只是那一格还没补铸);
+     * 不在 / 标记格 ⇒ 不在;说不出在不在(`storage`)⇒ 观察抛那只故障(判不了根行在不在,不替它答)。不补铸、不写。
+     */
+    private rowPresentHeld;
     /**
      * 在 `sessionId` 的写锁里跑 `body`(锁见 {@link sessionWriteLocks}):排在这只会话此前每一节之后,`body` 完成(或抛)才放下一节。
+     * 🔴 **写者律**:每一节做的第一件事 = 收完这只 id 上的待删({@link finishPendingDropHeld}:标记格 ⇒ 走完删序;在删格归删除协议,不在这里收);收尾失败 ⇒ `body` 不跑、原故障上抛。
+     * 所以登记 / 按 id 建 / placed 建 / fork 目标 / 导入落格 / place / 行格写 / 自动标题器都不会在标记格上做判;收掉的那一位交给 `body`(删除据它的属主答)。
      * 不可重入 —— 锁里的调用方只调 `…Held` 那一形(它们假定锁已在手),不再回到上锁的公开口。
      */
     private withSessionWriteLock;
     /**
      * 盘上这只会话的存档此刻是什么状态(repo 的**唯一探针**;`open` 读整只存档,所以只在边档里没有那一格、或要判 `forking` 时才走到这里)。三种答案:
-     * 不在(`not_found`)· 在而读得出 · 读不出({@link UnusableArchive}:`corrupt_session` = 在而内容用不了;`storage` = 读的时候抛了别的故障,I/O 级,
-     * 说不出在不在 —— 词的读法见 {@link archiveFaultWord})。探针**不吞也不改**那只故障:{@link UnusableArchive.fault} 就是抛出来的那一只,每个读者各自决定上抛还是点名 ——
-     * 要对这份存档动手的({@link existsInRepo};{@link metaOf};{@link readExecutionPlacement})一律上抛它;一次性迁移 M32 的回填({@link executionPlacementBackfill})经
-     * {@link metaRead} / {@link forkingRead} 收下它、点名跳过,不上抛。只问有没有的 {@link forkingRead} 把 `corrupt_session` 读作「在」(存档找到了),`storage` 不替它答。
+     * 不在(`not_found`)· 在而读得出 · 在而内容用不了(`corrupt_session`,带那只故障)。说不出在不在(`storage` —— 读的时候抛了别的故障,I/O 级;词的读法见 {@link archiveFaultWord})
+     * ⇒ **原样抛**(不替它答)。探针不改那只故障:要对这份存档动手的读者({@link existsInRepo})对 `corrupt` 也上抛它;只问有没有的({@link forkingOf} / 根行判)把它读作「在」。
      */
     private probeArchive;
     /**
-     * 委派分区的**唯一一读**(存档行头上的元组,repo 的 `placementOf`;文件头注):placed · 普通 · 读不出。repo 只吞「不在」,别的故障原样抛 ⇒ 这里收成
-     * {@link UnusableArchive}(词同 {@link archiveFaultWord}),由读者决定上抛还是按普通行答。
+     * 委派分区的**唯一一读**(存档行头上的元组,repo 的 `placementOf`;文件头注):placed · 普通 · 行头读不出(`corrupt_session`,带那只故障)。repo 只吞「不在」;
+     * 说不出(`storage`)⇒ 原样抛。由读者决定行头读不出时按普通行答还是上抛。
      */
     private placementProbe;
     /**
      * 改写面与执行席的读法({@link placementProbe} 的一形):placed ⇒ 那份元组;普通 ⇒ `undefined`;行头读不出(`corrupt_session`)⇒ `undefined` —— 没有可读的
-     * placement 记录,这一行按普通行答,内容读不读得出归真正读内容的那一读(坏档照样换得掉,与 forking 探针同一条规矩);说不出(`storage`)⇒ 抛那只故障。
+     * placement 记录,这一行按普通行答,内容读不读得出归真正读内容的那一读(坏档照样换得掉,与 forking 探针同一条规矩);说不出(`storage`)⇒ 探针抛那只故障。
      * core 7.61.0 起 repo 的探针按行头的元组自己读、不整头解码:placed 行的属主格坏了探针照答元组(本臂不再接得住 placed 行)—— 探针拒只剩「行头记录整个读不出」,
      * 那时没有任何元组可守(`test/local-session-placement.test.ts` 的 [ref] 三格)。
      */
     private placedRecordOf;
-    /** {@link placedRecordOf} 的是非形。 */
-    private isPlacedRow;
     /** 删除与认领的读法({@link placementProbe} 的另一形):读不出的任何一形 ⇒ 抛那只故障(说不准是不是 placed 行,就不删、不写)。 */
     private placedRecordOrThrow;
-    /** 盘上有没有一份**读得出**的这只会话的存档(补铸 / 登记 / 导入的落点判 / fork 目标这些要对存档动手的读者用):用不了的存档照旧上抛它的故障。 */
+    /** 盘上有没有一份**读得出**的这只会话的存档(登记 / 导入的落点判 / fork 目标这些要对存档动手的读者用):用不了的存档照旧上抛它的故障。 */
     private existsInRepo;
     /**
-     * 一只会话的元数据 —— 属主与化身的**唯一读口**(按 id 读 {@link headOf} / 删除与换装的属主门都经它)。`undefined` = 无此会话。
-     * 边档里有那一格 ⇒ 读它(一次同步读,两样同出一格,不会拼出混世代组合);没有那一格而盘上有会话(7.104.0 之前的会话从没被铸过化身)
-     * ⇒ 补铸一格只有化身的(属主没有事实可写,不伪造)并落盘后再答 —— 之后的读都命中那一格,不再回 repo。
+     * 一只会话的元数据 —— 属主与化身的**唯一读口**(锁外一形:按 id 读 {@link headOf} / 元数据读口 / 执行席都经它)。`undefined` = 无此会话(含标记格:删除已开始)。
+     * 一次观察:活格 ⇒ 它(一次同步读,两样同出一格,不会拼出混世代组合);遗留行(格缺而存档在 —— 7.104.0 之前的会话从没被铸过化身)⇒ 在这只会话的写锁里复判后补铸
+     * ({@link metaHeld}:锁外的观察可以早于一整条删序,复判之后才写,挡住幽灵格);存档在而内容用不了 ⇒ 具名拒 {@link SessionOwnerUnreadableError};说不出在不在 ⇒ 观察抛那只故障。
+     * 持锁的调用方用 {@link metaHeld}(锁不可重入)。
      */
     private metaOf;
     /**
-     * {@link metaOf} 的本体(三态,不抛「用不了」):边档里有那一格 ⇒ 读它;没有 ⇒ 问**唯一探针** {@link probeArchive} 一次 —— 不在 ⇒ 无此会话;在而读得出 ⇒ 补铸({@link cellOfPresent});
-     * 读不出 ⇒ {@link UnusableArchive}(**不补铸**:不替一份读不出的存档铸化身;`corrupt_session` 的故障换成具名拒 {@link SessionOwnerUnreadableError} ——
-     * 格缺 ∧ 存档用不了 = 这只会话没有可读的属主,见 {@link ownerUnreadableArchive})。要动存档的读者({@link metaOf})把它上抛;不动存档、只要「有没有」的读者
-     * ({@link executionPlacementBackfill})原样收下。
+     * {@link metaOf} 的锁内一形(调用方持这只会话的写锁):观察一次 —— 活格 ⇒ 它;不在 ⇒ `undefined`;遗留行 ⇒ 补铸一格只有化身的(属主没有事实可写,不伪造 —— 不写 `owner` 键 =
+     * 从没被记下)并落盘后再答(锁里的观察就是存档在盘上的证明);存档在而内容用不了 ⇒ 具名拒(不替一份读不出的存档铸化身)。
+     */
+    private metaHeld;
+    /**
+     * 给一只**已证明在盘上**的会话补铸那一格(锁内:调用方持这只会话的写锁,刚观察到存档 / 刚打开它)—— 只有化身(属主没有事实可写;化身经窗内长第一格的唯一规则
+     * {@link firstCellIncarnationHeld});已有格 ⇒ 不写、读它。
      */
-    private metaRead;
+    private mintHeld;
     /**
-     * 一只**已证明在盘上**的会话的那一格:有 ⇒ 读它;没有(7.104.0 之前写下、此后没被读过)⇒ 补铸一格只有化身的(属主没有事实可写,不伪造)
-     * 并落盘后再答。证明由调用方给:{@link metaOf} 探过 repo;acquire 的打开腿在这只会话的写锁里刚打开它({@link openForItselfHeld})。
-     * `undefined` = 补铸落盘之前那一格已被并发删除抹掉(只有锁外的 {@link metaOf} 走得到)。
+     * 一只已证在盘、没有会话元数据格的存档长第一格时的化身(锁内:调用方持这只会话的写锁)—— 窗内长第一格的唯一规则 {@link firstCellIncarnationOf} 的按 id 一形:
+     * 本构建带收令牌的迁移 ⇒ 读一次存档头({@link archiveHeadOf})取它的令牌(头读抛 ⇒ 原样上抛,不替一份读不出的头铸化身);不带 ⇒ 不读、新铸。
      */
-    private cellOfPresent;
+    private firstCellIncarnationHeld;
     /**
      * core `SessionStore.headOf` —— 本店按 id 读一行的**唯一**读口(SQL 孪生同义;此前的 `ownerOf` / `sessionFaceOf` / `incarnationOf` / `getHead` / `getLeafId`
      * 五只读并进来,规则见 `session-incarnation.ts` 头注)。属主与住客出自 {@link metaOf} 读到的同一格(local 后端属主 + 化身的唯一真源 —— 本店的**行**),
      * 叶子出自会话存档(本店的**内容**;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` = 无此会话。
+     * 两样住在两只文件里 ⇒ 先读那一格、读叶子、再同步复读那一格:格没了(读间被删 / 落了「删除中」)或换了主 / 换了住客 ⇒ `undefined`(调用方按删处理),
+     * 所以一只头从不把这一代的属主配上另一代的叶子([ref] 六轮复审同一条)。`undefined` = 无此会话(标记格同答:读者律)。
      * 化身那一格经 `headFromRow` 的 `absent` 读法(边档对象形恒有令牌;读不出的边档整只严格拒在 `metaOf` 之前)。
      */
     headOf(sessionId: string): Promise<SessionHead | undefined>;
     /**
-     * 引擎仓存档的头(core `SessionRepo.headOf`:日志首记录与尾,不重放)—— 本店读存档头的**唯一**一处。存档头在本店只有三种读法:叶子(读内容的人要的那一格)、
-     * 行代号(换装 / 一次性迁移的 `expect.row`、迁移判「有没有、读不读得出」)与带戳判({@link assertArchiveAnonymous};读的是存档的**形** —— 头上有没有属主戳 —— 不是属主事实);
-     * 属主 / 建档时刻 / 谱系作为行事实从不从这里读(规则一,行事实只住边档)。
+     * **「被占着」的头读**(`OwnerAwareSessionStore.deletionHeadOf`;读者:`DELETE /v1/sessions/:id` 的属主门 · 认领面 · 同步推送三口的门 —— 都问「这个 id 被占着吗」,经 `session-incarnation.ts` 的 `deletionHeadReadOf` 一只取法):活行 ⇒ 与 {@link headOf} 同答;
+     * 在删格(一次删除独占着它)与标记格(删序停在 s0 之后)⇒ 那一格上的属主与住客(叶子 `null`:内容已在删)—— 开始删它的那位属主重发删除(= 接管)就收得完。
+     * 别的读者一律读作不在(读者律);门对别的属主答「不在」的同一句,所以不可探测。SQL 孪生同交这一口(座的原始头读)。
+     */
+    deletionHeadOf(sessionId: string): Promise<SessionHead | undefined>;
+    /**
+     * 引擎仓存档的头(core `SessionRepo.headOf`:日志首记录与尾,不重放)—— 本店按 id 读存档头的**唯一**一处。存档头在本店只有三种读法:叶子(读内容的人要的那一格)、
+     * 行代号(暂存提交落点 / 一次性迁移 M33 的 `expect.row`、迁移判「有没有、读不读得出」)与带戳判({@link assertArchiveAnonymous};读的是存档的**形** —— 头上有没有属主戳 —— 不是属主事实);
+     * 属主 / 化身 / 建档时刻 / 谱系作为行事实从不从这里读(规则一,行事实只住边档);例外只有窗内无格存档长第一格的那一读({@link firstCellIncarnationHeld},M47 在树时;
+     * M47 的起服扫经列表面的行集读同一只令牌)。
      */
     private archiveHeadOf;
     /**
-     * 三条 acquire 腿(无 id 建 / 按 id 打开 / 按 id 首建)交出会话的唯一一处:行事实 = 这只会话那一格({@link cellOfPresent} —— 刚建或刚在写锁里
-     * 打开,就是在盘上的证明,不再回 repo 探一次),经唯一投影 {@link rowMetadataOf}(活住客解码、建档时刻、谱系)挂到交出的会话上({@link occupiedBy})。
+     * 三条 acquire 腿(无 id 建 / 按 id 打开 / 按 id 首建)交出会话的唯一一处:行事实 = 这只会话那一格(刚建,或刚在写锁里打开 —— 就是在盘上的证明,格缺 ⇒ {@link mintHeld} 补铸,
+     * 不再回 repo 探一次),经唯一投影 {@link rowMetadataOf}(活住客解码、建档时刻、谱系)挂到交出的会话上({@link occupiedBy})。
      */
     private handOut;
     /**
@@ -550,7 +763,7 @@ export declare class LocalSessionStore implements SessionStore {
     /**
      * 带 placement 的按 id 首建(锁内一形,调用方持这只会话的写锁、已判过存档不在且不是 fork 创建的格)。写序 = **格先、存档后**(与登记先记属主再建存档、fork 先写目标格再拷存档、
      * 导入先落格再导条目同一序;普通 acquire 的两条首建 —— 无 id 新建、按 id 缺档新建 —— 仍是存档先、格后:那两处写的属主是「无主」,崩在两笔之间留下的存档补铸后同样读作无主,
-     * 与「登记为无主」只在 M10 认领窗内有别,不在本条):
+     * 与「登记为无主」读作同一个无主,不在本条分):
      *  1. 会话元数据那一格:化身新铸;属主 = `placement.owner` 原样(core 7.62.0 [ref] 盒义务 7:委派树的属主是引擎判的,店只记、不推断;唯一读法 `placedSessionOwnerOf`,
      *     坏值 ⇒ 响亮拒、一个字节不写;SQL 孪生把它与元组写进同一条 INSERT);建档时刻同一笔写(铸行点律);
      *  2. 存档:元组 = `placement` 去掉属主(`SessionPlacementRecord` 没有属主 —— core 自己的店同样只把元组交给 repo),不交属主(引擎仓是匿名内容仓)。
@@ -559,7 +772,7 @@ export declare class LocalSessionStore implements SessionStore {
      * 不另加 fsync 屏障,与另外三个建行点同)。
      * 「placed 存档在而格缺」此后只剩三个来源,都照旧读作无主(补铸的格不写属主:属主没有事实可写),在具名树的停驻挂点被否决、响亮,匿名树 `null === null` 照放 ——
      * ① 7.144.x 及更早崩在两笔之间留下的存量行(当年存档先建;不回填:行头属主格是空的,元组里那一份属主是本店当年漏进去的未声明成员,不作来源);
-     * ② `release` 删了格、没删存档就崩(判别位最后删;它的 agent 行已先删,没有复活腿会碰它,重发 release / 分区收割收完);③ 同一数据根上 run-local 腿经 core 店写下的 placed 存档
+     * ② 7.147.x 及更早的 `release` 删了格、没删存档就崩(那时格先于存档删;本版起删序是「标记 → 存档 → 格」,不再留下这一形);③ 同一数据根上 run-local 腿经 core 店写下的 placed 存档
      * (core 形:属主在行头,本店不读行头属主)。SQL 孪生的存量无主 placed 行由 M23 在窗内回填。
      * 格已在而存档不在(登记先落了格、存档还没建 —— 一只普通会话的行;或本条崩在两笔之间留下的格)⇒ `placement_refused`(SQL 孪生:登记过的行在,带 placement 的建读回缺席元组,同一判)。
      * 建后读回准入(镜像方向):别的写者在这一刻抢先建了同 id 的存档 ⇒ repo 返回的是那一只 ⇒ 元组缺席 / 异组 ⇒ 响亮拒。
@@ -590,18 +803,22 @@ export declare class LocalSessionStore implements SessionStore {
      * overwrite history; create if not), else `headOf` would say a registered-but-never-acquired session exists while `fork` 404s it.
      *
      * 首写判据在写链里判(两只并发登记:先落盘的那一只赢,后一只不改、也不建会话)。一只**盘上已有、属主从没被记下**的会话
-     * (边档那一格只有化身 —— 7.118.x 及更早写下的,或更早到连化身都没有)是一次性迁移 M10 的对象(窗口见 `plugins/one-time-migrations.ts`
-     * 登记表):窗开着、且这次登记带着 principal(`owner !== null`)⇒ **认领**(记下属主,化身一个字节不动 —— 同一位住客),一行 info
-     * `session_owner_claimed`;否则只补化身(缺就补),属主仍是「没被记下」,读作无主。认领的安全前提是单用户 —— local 后端起服门拒
-     * `REQUIRE_PRINCIPAL=true`,授权口也只在那时才把 principal 递过来认领(`security.ts` `createAuthorizer`)。
+     * (边档那一格只有化身 —— 7.118.x 及更早写下的,或更早到连化身都没有)不认领:只补化身(缺就补),属主仍是「没被记下」,读作无主 ——
+     * core `SessionStore.register` 契约「对已有的行什么都不做」(7.119.0–7.147.x 的升级窗内,一次性迁移 M10 曾让带 principal 的登记认领这种会话;窗关、认领臂删)。
      */
     register(sessionId: string, owner: string | null): Promise<void>;
+    /**
+     * 出生回执面(`session-birth.ts`):与 {@link register} 同一笔写。**只有新建会话那一臂**(存档不在 ∧ 这一笔真写下了新格)交回候选 —— 化身是这一笔里铸的那一只,
+     * 不复读;已记下属主(并发登记里后到的那一只)/ 只补化身 ⇒ 不交候选。新格同一笔写下客户端写计数 `0`(版本位,见 {@link SessionMetaCellObject.clientWrites})。
+     */
+    registerWithReceipt(sessionId: string, owner: string | null): Promise<RegisterReceipt>;
     touch(sessionId: string): Promise<void>;
     /**
      * 普通会话:durable 史留在 repo,只丢 in-flight 那一格(义务 3,与 SQL 孪生同)。
      * 🔴 义务 4 —— **placed 会话:release 是真删除**(联合收割先删 agent 行、赢了才调这里终结转录)。判据 = 存档行头上的元组(冷启动后照样成立);
-     * 读不出 ⇒ 上抛、一个字节不删(说不准是不是 placed 行;吞掉 = 收割腿数一条「已终结」而字节还在)。删序 = **判别位最后删**:四只行边档与新近 → 元数据格 → 存档最后
-     * —— 崩在中途,存档(连同它的元组)还在,重发的 release 与分区收割腿都还认得它、收得完;反过来先删存档,剩下的边档就没人认领了。
+     * 读不出 ⇒ 上抛、一个字节不删(说不准是不是 placed 行;吞掉 = 收割腿数一条「已终结」而字节还在)。**认领政策**(规则 L,与删除同一只判官 {@link judgeSessionWrite} 的 `delete` 臂):
+     * 这一行上有活 run 的认领 ⇒ `SessionActiveRunError`,一个字节不删(活 run 的根不删;认领唯一的运行期写者排在同一把锁后面)。删序 = 删除那一条({@link dropRowHeld}:
+     * 标记先落、存档后删、格最后删)—— 崩在中途,标记还在:读者已读作不在,重发的 release(节首收尾)、分区收割腿(分区枚举照样列它 —— 行头还在 —— 重发 release)与起服扫都收得完。
      * 整段在这只会话的写锁里(与删除 / 换装 / 登记同一把)。
      */
     release(sessionId: string): Promise<void>;
@@ -615,20 +832,20 @@ export declare class LocalSessionStore implements SessionStore {
      *                          at the HTTP layer.
      *   - `firstActivityAt` — the row's `createdAt` (the session-meta cell — the SQL twins' `session_meta.created_at`; the archive header's copy is not read).
      *   - `lastActivityAt`  — the touch marker (falls back to `createdAt`); the keyset sort key.
-     *   - `objectivePreview`— the last USER-text entry, synthesized from the session tree (no run ledger).
-     *   - `runCount`/`lastStatus`/`lastRunId`/`lastTaskRunId` — [ref]:read from the run store handed in (`runs`; the TiDB
-     *                          twin LEFT-JOINs `task_run` for the same values, the run store's own `listSessions` is that
-     *                          join's same-semantics projection — latest run by `created_at DESC, task_id DESC`, count of all,
-     *                          `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 / ""`).
+     *   - `runCount`/`lastStatus`/`lastRunId`/`lastTaskRunId`/`objectivePreview` — [ref] / [ref]:read from the run store handed in (`runs`, its
+     *                          narrow face `sessionRunRollups`; the SQL twins LEFT-JOIN `task_run` for the same values — latest run by
+     *                          `created_at DESC, task_id DESC`, count of all, `lastTaskRunId` = that run's `result.runId`, preview = the most recent
+     *                          run whose preview column is a non-empty string). One call per list (not per row); a session with no run row ⇒
+     *                          `0 / "" / null / null` (TiDB's null→"" mapping); a run-store read failure throws (never `0 / ""`).
+     *   - `?q=`             — the same narrow face with `q`: a session is kept iff one of its run rows' preview column contains q
+     *                          (case-insensitive, literal — the SQL twins' EXISTS); filtered BEFORE the sort/keyset slice.
      *
      *   - `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.
+     *                          scans): the row's facts above still come from its session-meta cell and its run rows (the preview included — it
+     *                          never reads the archive); 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.
+     * the in-memory sort. Cheap (a local single-user store holds few sessions).
      */
     listSessions(opts: {
         owner?: string;
@@ -658,21 +875,20 @@ export declare class LocalSessionStore implements SessionStore {
     private ownerCellOf;
     /** 一只会话的列表行 —— {@link listSessions} 与 {@link sessionSummaryOf} 的**同一只**合成(字段来源逐位见 listSessions 的头注)。调用方先 {@link loadRowSidecars}。 */
     private summaryOf;
+    /** 列表行的 `forkedFrom` 键:那一格的谱系经三店唯一的读法 `forkLineageOfRow`(没有那一格 / 不是 fork ⇒ 键缺席;住客令牌不上列表行)。 */
+    private listedLineageOf;
     /** 列表行的 `rowTag` 键(规则 `session-row.ts`):化身出自会话元数据那一格(与写原语锁住的那一行同读),属主与两格由调用方交 —— 就是这一行交出去的那两位(同一刻读);没有那一格 ⇒ 键缺席。 */
     private rowTagKeyOf;
-    /** [ref]:run 店里每个会话的 run 投影(按 sessionId 索引)。
-     *  **一次读**:run 店的 `listSessions` 本来就按会话聚合全账(无会话过滤口),这里取全量再按会话仓的 id 查表 —— 比逐会话 N 次读便宜,
-     *  也不在会话店里另存一份 run 账。读失败 ⇒ 抛(不吞成 `0 / ""`:那会把「读不到」说成「没跑过」)。 */
+    /** [ref] / [ref]:run 店里每个会话的 run 投影(按 sessionId 索引;五位,规则在 run 店的窄读面 —— 共用纯函数 `session-run-rollup.ts`)。
+     *  **一次读**:窄读面按会话聚合全账(无会话过滤口),这里取全量再按会话仓的 id 查表 —— 比逐会话 N 次读便宜,也不在会话店里另存一份 run 账。
+     *  `q` 在场 ⇒ 只交「有一条 run 行的预览列含 q」的会话(列表的 `?q=`)。读失败 ⇒ 抛(不吞成 `0 / ""`:那会把「读不到」说成「没跑过」)。 */
     private runRollups;
     /**
-     * 一行里 run 身份与计数的**唯一出处**([ref],会话行四位一源):四位全读 {@link runRollups} 的投影(与 SQL 双生的 `task_run` rn=1 JOIN 同口径);
-     * 该会话没有 run 行 ⇒ `0` / `""` / `null`、`lastTaskRunId` 缺席(TiDB 的 `COALESCE(…,0)` / null→"" 映射)。在途的最新一条:`lastRunId` 在场(run 行建出来就有)、
+     * 一行里出自 run 行那一半的**唯一出处**(会话行五位一源):全读 {@link runRollups} 的投影(与 SQL 双生的 `task_run` JOIN 同一条规则);
+     * 该会话没有 run 行 ⇒ `0` / `""` / `null` / `null`、`lastTaskRunId` 缺席(TiDB 的 `COALESCE(…,0)` / null→"" 映射)。在途的最新一条:`lastRunId` 在场(run 行建出来就有)、
      * `lastTaskRunId` 缺席(`result` 在终局与 park 时才写)。
      */
-    private runProjectionOf;
-    /** Synthesize a session's objective preview = the most-recent USER text message (the objective the run last saw).
-     *  Reads the session's entries through the repo; any read error degrades to null (never fails the list). */
-    private previewOf;
+    private runRollupOf;
     /** E17 — fork a session's WHOLE history to a NEW id (core SessionRepo.fork). Returns the new id, or null if the source does not exist.
      *  属主按 core `SessionStore.fork` 契约(core 7.54.0 `sessionStoreContract` 的 [ownership] 格,唯一读法 {@link forkOwnerOf}):显式串 ⇒ 该串;
      *  无参 / 显式 `null` ⇒ **源会话记下的属主**(一份有主历史的拷贝永不降成匿名 —— 匿名的拷贝谁都能认领);源会话没记属主 ⇒ 拷贝也不记(读作无主)。
@@ -689,7 +905,7 @@ export declare class LocalSessionStore implements SessionStore {
      *  · **两把写锁**:按 id 字典序依次取源与目标的写锁(锁不可重入;同 id 只取一把)—— 同 id 的每个写者(删除 / 登记 / 导入 / 按 id 首建 / 别的 fork)都在目标那把锁里,
      *    core `repo.fork` 的改名覆盖写只在锁内被调;
      *  · **源先判**:源存档不在 ⇒ `null`(源被删之后的同键重试答「源不在」);源存档带属主戳 ⇒ {@link StampedSessionArchiveError}(零写);属主读在拷贝之前(源锁持到拷贝落定)—— 唯一读法 `forkOwnerOf`;
-     *  · **唯一创建点 = 格先、存档后**:锁内「目标格不在 ∧ 目标存档不在」才写目标格(带 fork 键;新住客,执行位 absent;建档时刻与谱系 `forkedFrom` = 源 id 同一笔写),再交 core `repo.fork` 写存档
+     *  · **唯一创建点 = 格先、存档后**:锁内「目标格不在 ∧ 目标存档不在」才写目标格(带 fork 键;新住客,执行位 absent;建档时刻与谱系两位 —— `forkedFrom` = 源 id、`forkedFromIncarnation` = 源那一格的令牌,core `forkRowCells` 铸 —— 同一笔写),再交 core `repo.fork` 写存档
      *    (不交属主 —— 引擎仓匿名;子存档的属主格抄自源存档,源匿名 ⇒ 子匿名)。
      *    崩在两步之间 = fork 创建的格而存档不在 = `forking`:普通取用一律 {@link SessionForkInProgressError};同键重试在两把锁内补拷存档、答 `replayed`。
      *    拷贝抛错(不是崩溃)⇒ 撤掉刚写的目标格再上抛(撤不掉 ⇒ 留下的就是 `forking`,与崩在中间同形);
@@ -749,14 +965,14 @@ export declare class LocalSessionStore implements SessionStore {
     private withImportLock;
     /**
      * 三个导入写口(`importEntries` / `replaceEntries` / 暂存提交的换装臂)的共用写序(调用方持这只会话的写锁,属主的形已在入口判过):
-     *  ① 只读、零写:引擎闸 `validateEntriesForImport`(坏包 ⇒ `invalid_session`)· 准入 {@link admitImportHeld}(读 run 认领、交判官 {@link judgeImportWrite}:活 run 认领 ⇒
+     *  ① 只读、零写:引擎闸 `validateEntriesForImport`(坏包 ⇒ `invalid_session`)· 准入 {@link admitImportHeld}(读 run 认领、交判官 {@link judgeSessionWrite}:活 run 认领 ⇒
      *    `SessionActiveRunError` · 本处写者 ⇒ `SessionWriterPresentError` · `forking` ⇒ {@link SessionForkInProgressError};SQL 孪生的事务内钩 `import` 臂同一只判官、同序、同拒;
      *    `judged` 在 {@link commitStagedImport} 里准入过,不再来一遍)· 不是这个写口的门判过的行 ⇒ {@link importRowRefused}(判据 {@link importMayLand},按写口带来的
      *    {@link ImportLanding};这条路径上唯一一次判属主);
      *  ② 行先:{@link landImportCell}(属主重戳为导入者、化身与 fork 键沿用或新铸、执行位 mirror;建档时刻与谱系照带,新行写此刻);
      *  ③ 内容,按写口的动词(唯一读法在下面这一只 switch;这里不读那一格、不判属主,只换**内容**;交给引擎仓的属主恒缺席 —— 规则一):
-     *    · `create` / `judged`(导入):原地换锁里读到的那一份存档的日志(没有存档 ⇒ 导入新建一只,匿名),以锁里读到的存档头为 `expect.row`(**行代号**:
-     *      读与写之间存档换了一代 ⇒ 引擎仓拒 `conflict`;它判不出同一代里的追加)。匿名导入只换匿名存档的日志 —— 仍带属主戳的存档(更早的版本写下、一次性迁移 M33
+     *    · `create` / `judged`(导入):`create` 以「没有」为 `expect.row`(① 已判过不在,不读存档头;读间抢建的存档 ⇒ 引擎仓拒 `conflict`、零写);
+     *      `judged` 原地换锁里读到的那一份存档的日志,以锁里读到的存档头为 `expect.row`(**行代号**:读与写之间存档换了一代 ⇒ 引擎仓拒 `conflict`;它判不出同一代里的追加)。匿名导入只换匿名存档的日志 —— 仍带属主戳的存档(更早的版本写下、一次性迁移 M33
      *      改写不了的,或跳版升上来的)到不了这里:暂存提交在一切「谁赢」的判之前就以具名拒答了它({@link assertArchiveAnonymous});`create` 落在没有存档的名上,`replace` 先清存档。
      *      读存档、校验、存档判与写在引擎仓里是一步,抛在哪一处内容都一个字节没动 ⇒ 撤回 ②({@link withdrawImportCell}:行原样 —— 净零写,SQL 孪生的事务回滚同义)再原样上抛;
      *    · `replace`(接口句「先清既有对话日志,再导入」):先清掉内容存档(不带 `expect` —— 带了就得先读它的头,读不出的存档就清不掉),再导入一只新存档。
@@ -769,12 +985,12 @@ export declare class LocalSessionStore implements SessionStore {
     private importHeld;
     /**
      * 改写面的分区判(调用方持这只会话的写锁):placed 行 ⇒ `placement_refused`(import 面 409 `conflict.session_placed`,`session-error-wire.ts`),一个字节不写。
-     * 读法 = {@link isPlacedRow}(行头读不出 ⇒ 按普通行答,坏档照样换得掉;说不出 ⇒ 抛)。
+     * 读法 = {@link placedRecordOf}(行头读不出 ⇒ 按普通行答,坏档照样换得掉;说不出 ⇒ 抛)。
      */
     private assertNotPlacedHeld;
     /**
      * 三个导入写口落 mirror 之前的**准入**(调用方持这只会话的写锁;{@link importHeld} ① 与暂存提交「内容相同、日志不动」那一支都经这一处):**取锁 → 读认领 → 判 → 写**,
-     * 与 {@link markMirrorExecution} 同序。判官就是 SQL 孪生事务内钩 `import` 臂的那一只 {@link judgeImportWrite}(词、拒码、先认领后写者都在判官里,本店不另写一份):
+     * 与 {@link markMirrorExecution} 同序。判官就是 SQL 孪生事务内钩 `import` 臂的那一只 {@link judgeSessionWrite}(词、拒码、先认领后写者都在判官里,本店不另写一份):
      * 认领读 run 店的单活槽({@link SessionRunClaimSource})、格读 {@link placementCellOf}(`forking` 按 {@link forkingOf} 判好)—— 读口按需:认领在 ⇒ 不探存档。
      * 拒 ⇒ 抛那只 typed 错,此时导入的任何一笔写(格 / 存档 / 新近)都还没发生(读侧的补铸除外:盘上有会话而格缺时,读它的读口先补铸那一格 —— 与别的读口同,幂等)。
      * 路由的认领判(第一阶段写前判 + 提交前复判)仍在、更早一道,不再是唯一防线。
@@ -783,8 +999,8 @@ export declare class LocalSessionStore implements SessionStore {
     /**
      * ① 的属主 / 住客条件:这一行此刻是不是这个写口的门判过的行({@link ImportLanding};一次读、零写 —— 格缺时「行在不在」只问存档的唯一探针
      * {@link existsInRepo},不补铸那一格)。属主比的是头读的读法 `owner ?? null`(从没被记下 = 无主;格缺而存档在 = 从没被记下),比较器是删除门的那一只
-     * {@link ownerEq}。M10 的认领只归登记({@link register}),导入不认领:遗留的「属主未记」格对带 principal 的 `replace` 读作别人的行,拒了之后那一格
-     * 原样仍是「未记」,窗内登记照样认领。
+     * {@link ownerEq}。遗留的「属主未记」格对带 principal 的 `replace` 读作别人的行,拒了之后那一格
+     * 原样仍是「未记」(登记也不认领它)。
      */
     private importMayLand;
     /**
@@ -839,34 +1055,136 @@ export declare class LocalSessionStore implements SessionStore {
         relation: SyncRelation["relation"];
         face: SessionFace;
     }>;
-    /** E21 — purge a session's conversation history (core SessionRepo.delete), owner-guarded (single-user: owner=null
-     *  matches). Idempotent: a missing/wrong-owner session is a no-op returning false. The runs-ledger / checkpoint /
-     *  tool-result rows are purged separately by the route's purgeSession coordinator. 整段在这只会话的写锁里(换人)。 */
-    deleteSession(sessionId: string, owner: string | null): Promise<boolean>;
-    /**
-     * {@link deleteSession} 的锁内一形(调用方持这只会话的写锁;换装不走它 —— 换装只换内容存档,行原样,见 {@link importHeld})。
-     * 删的是 SQL 孪生 `session_meta` 那一行在本店的全部对位:会话存档、四只行边档(标题 / 置顶 / 指令来源基线 / 工作区)、新近标记、属主 + 化身那一格。
-     * 四只边档的那一键**都经各自的写链删**(`commit`:草稿上删、落盘、再发布 —— 与写它们的那一笔同一条链、同一把会话锁),落不了盘 ⇒ 抛:
-     * 留在盘上的值会挂到同 id 的下一位住客身上(E21 的删除权残留)。元数据格**最后**删:四只边档任一只落不了而抛时,那一格还在 ⇒ 会话对属主门仍
-     * 「在」,重发删除照样走得进来、收敛;反过来先删格,重发就成了 no-op,残留永远留下。
-     * 🔴 hydrate FIRST (workflow audit 2026-07-13): after a restart the maps start empty — an un-hydrated delete would find nothing and
-     * the sidecar would keep the value (an E21 right-to-delete residue that would RESURRECT onto a same-id re-import). ensureLoaded is
-     * memoized — first caller pays, rest no-op.
-     * [ref]:化身随那一格消失(同 id 重登记铸新的 —— 那就是下一位住客)。
+    /**
+     * **删净这只在删会话的 local 执行体锁节**(会话三态的 在删 → 没了,律在 `src/session-deletion.ts`;`session-erase.ts` 的 `createLocalSessionEraser` 是唯一调用者):
+     * 整段在这只会话的写锁里 —— 行在 ∧ 属主是围栏判过的 `owner`({@link ownerEq})→ 判「这一行处于 `token` 那一次删除的在删态」(判官 {@link judgeSessionWrite} 的 `erase` 词)→
+     * **`legs(住客)`**(各店按会话删的动词,按 `SESSION_TREE_LEGS`;住客 = 锁里读到的属主 + 化身)→ 删序({@link dropRowHeld}),交回那一位住客。令牌不是它 ⇒ 抛
+     * `SessionDeletionSupersededError`(另一次删除接管了它);行不在 / 属主不是它 ⇒ `undefined` —— 都一行不删。同 id 的 `register` 取同一把写锁、在删的行对它读作「已存在」⇒ 一次陈旧的删除碰不到下一位住客。
+     * `legs()` 不得回到本店上锁的公开口(锁不可重入;会话规则店的删除直接转发、附件店删除走它自己的串行段 —— 锁序 根 → 店,与 `withClientWrite` 同向)。
+     * 🔴 hydrate FIRST (workflow audit 2026-07-13): after a restart the maps start empty — 删序逐只 `ensureLoaded`。[ref]:化身随那一格消失(同 id 重登记铸新的 —— 那就是下一位住客)。
+     */
+    deleteSession(sessionId: string, owner: string | null, token: string, legs: (occupant: SessionOccupant) => Promise<void>): Promise<SessionOccupant | undefined>;
+    /**
+     * {@link deleteSession} 的锁内一形。节首收掉了一只标记格(release / 撤回的删序停在 s0 之后 —— 不是任何一次删除的在删行)⇒ `undefined`;没有格 ⇒ `undefined`(行不在;
+     * 在删的行恒有格 —— 围栏给无格的遗留行也铸了一格)。在删格(本令牌上一次删除停在 s0 之后 ⇒ 格同时带标记)照判令牌、`legs` 重跑(各腿按 id 幂等)、删序从 s0 的重证往下走完。
      */
     private deleteSessionHeld;
+    /** 这只会话此刻的在删令牌(同步读已发布的表;调用方先 `meta.ensureLoaded()`):没有格 / 不在删 ⇒ `null`。 */
+    private deletingTokenOf;
+    /** 删除面(会话三态的围栏 / 复核 / 收尾输入;律在 `src/session-deletion.ts`)。 */
+    readonly sessionDeletion: SessionDeletionFace;
+    /** 一只在删格上的属主(遗留行围栏时没有记下属主 ⇒ 读作无主,与删除门的读法同)。 */
+    private deletionOwnerOf;
+    /**
+     * 围栏的锁内一形(调用方持这只会话的写锁):节首收掉了一只待删(删序停在 s0 之后)⇒ 行已没了 ⇒ `undefined`。否则 ——
+     * 在删格 ⇒ 属主等 ∧(不带 `expect` 或持有的就是它)⇒ 持有者在本进程还在跑(`holder` 答 `running`)⇒ `{ inProgress }`;否则 **接管**(换新令牌;数据根独占 ⇒ 不是本进程
+     * 在跑的令牌一律是死的;在删期间规则 L 不让认领落下,不再判);活行 / 遗留行(格缺而存档在)⇒ 带 `expect`(收尾者)⇒ `undefined`;属主等({@link ownerEq};遗留行读作无主)⇒
+     * 判认领(判官 {@link judgeSessionWrite} 的 `delete` 臂,读 run 店的认领;在 ⇒ 抛 `SessionActiveRunError`,一个字节不写)⇒ 写新令牌。行不在 / 属主不等 ⇒ `undefined`。
+     * 写令牌 `required`(文件 + 目录 fsync):落不了 ⇒ 抛,什么都没删(围栏没立)。遗留行铸一格(化身新铸、只带令牌;回执的化身 `undefined` —— 它的住客从没被记下,没有空间)。
+     */
+    private fenceDeletionHeld;
+    /**
+     * 客户端写计数 +1(锁内一形,调用方持这只会话的写锁):活格 ⇒ `clientWrites` = 原值(缺 ⇒ 0)+ 1,**落盘必须成功**(`required`;落不了 ⇒ 抛,调用方的写不发生);
+     * 没有活格(行不在 / 遗留行)⇒ 不计(没有可撤的候选)。
+     */
+    private bumpClientWritesHeld;
+    /**
+     * 客户端可见会话态的**本店之外**的写者(会话规则、附件绑定)经这一口:取这只会话的写锁(根行锁;全局锁序 根 → 写者自己的锁)跑 `write`,交给它一只 `count` ——
+     * 写者判定这一次**真要写**之后、自己落盘之前 `await count()`(行在 ⇒ 客户端写计数 +1、落盘必须成功;落不了 ⇒ 抛,写者的写不发生)。会话规则每次写都计;
+     * 附件绑定只在真绑上行时计(无效附件 / 空数组 / 绑定前拒不计)。撤回排在同一把锁上,读到的计数与这一笔写互不穿插。
+     * `write` 不得回到本店上锁的公开口(锁不可重入);`count` 只在这一节里有效(节外调用 ⇒ 抛)。
+     */
+    withClientWrite<T>(sessionId: string, write: (count: () => Promise<void>) => Promise<T>): Promise<T>;
+    /**
+     * 条件撤回面(`session-birth.ts` 头注的判序;SQL 孪生的一只事务 = 本店这只会话的写锁一节):
+     * 节首收掉了这只 id 的待删 / 行不在 ⇒ `absent`;遗留行、化身或属主不是候选 ⇒ `incarnation`;没有计数版本位 ⇒ `upgrade_pending`;存档里有可撤集合之外的条目 ⇒ `content`;
+     * 认领在(判官 {@link judgeSessionWrite} 的 `delete` 臂)⇒ `claim`;客户端写过 ⇒ `client_writes`;run 半(run 店的 {@link SessionRunWithdrawSource})答别的 run ⇒ `runs`,
+     * 否则它已严格删掉本次 run 的部署行 → 严格删本会话的续跑输入 → 删序 {@link dropRowHeld}。
+     * 两态(如实):删序的标记(s0)落盘**之前**失败 ⇒ 抛、这一格原样在 —— 会话完整可见(本次零工作 run 的行可能已部分不在);标记落盘**之后**失败 ⇒ 抛、会话已对每个读者不在,
+     * 下一次取这只 id 的锁或下一次起服({@link finishPendingDrops})按既有删序收完。run 店不答 run 半 ⇒ 响亮抛(判不了「别的 run」,不替它答)。
+     */
+    withdrawBirth(birth: SessionBirth, ownTaskId: string | undefined): Promise<WithdrawOutcome>;
+    /**
+     * 撤回的内容判(锁内一形):存档里有没有可撤集合之外的条目(型判据只有 `entryTypeWithdrawable` 那一只)。repo 不答导出 ⇒ 判不了 ⇒ 当作有(留,fail-closed);
+     * 存档不在 ⇒ 没有条目;别的故障原样抛。读 repo 的导出口,不经本店上锁的公开口。
+     */
+    private archiveHasContentHeld;
     /**
-     * 删一只会话的**行**(调用方持这只会话的写锁)—— 删除与 placed 的 release 两处共用这一只,存档的删除由两位各自排在前或后:
-     * ⓪ 登记「删行已开始」(锁外读者从此不补铸,见 {@link rowsDropped});① 四只行边档(标题 / 置顶 / 指令来源 / 工作区),落不了盘 ⇒ 抛(留下的那一格会在重启后
-     * 挂到同 id 的下一位身上);② 新近标记:先把盘上那一份读进来再删(冷起服后的第一笔就是删 ⇒ 删的若是空表,随后那次落盘会把盘上那一笔并回去),防抖落盘;
-     * ③ 属主 + 化身那一格**最后**删,落不了盘 ⇒ 抛(留下的格会让删掉的会话重启后「还在」;边档任一只先抛时那一格还在 ⇒ 重发照样走得进来、收敛)。
+     * 删一行的**唯一删序**(调用方持这只会话的写锁、已判过:删除 = 行在 → 认领 → 属主;placed release = 行头是 placed → 认领;节首收尾 = 这一格已带标记)——
+     * 删的是 SQL 孪生 `session_meta` 那一行在本店的全部对位:
+     *  · s0 **落标记**:那一格写上「删除中」(`required`:文件 + 目录各 fsync;格缺的遗留行 = 铸一格只带化身与标记)。标记已在(上一次停在 s0 之后)⇒ 重证它在盘上。
+     *    落不了 / 证不到 ⇒ 抛,一个字节都没清(改名落了而目录项没证 ⇒ 内存跟盘走、同读「删除中」,见 `SidecarMap.commit`)。从这一笔起这一行对每个读者都不在;
+     *  · s1 四只行边档(标题 / 置顶 / 指令来源 / 工作区)各删那一键(`required`;没有那一键 ⇒ 重证盘上那一份)—— 留在盘上的值会挂到同 id 的下一位住客身上;
+     *  · s2 新近:先把盘上那一份读进来再删(冷起服后的第一笔就是删 ⇒ 删的若是空表,随后那次落盘会把盘上那一笔并回去),防抖落盘(只管排序的装饰位,沿用既有 F 类 warn,不作判据);
+     *  · s3 删存档(`not_found` 照常);
+     *  · s4 **屏障**:fsync 存档目录({@link syncArchiveDirectory};core 的文件仓删存档只删文件、不 fsync 目录)—— 删格之前确知 s1–s3 在盘上;
+     *  · s5 删格(`required`)。
+     * 每一步落不了 ⇒ 抛,后面的步不走;标记还在 ⇒ 下一次取这只 id 的锁(写者律)或下一次起服({@link finishPendingDrops})从 s0 的重证往下走完(每一步都幂等)。
+     * 三档保证:普通异常 ⇒ 不撤回、往前收;进程终止 ⇒ 同(标记是一次原子改名);掉电 ⇒ 在 fsync 是真屏障的平台上同,别的平台只保证前两档。交回收掉的那一格(删除节据它的属主答)。
      */
     private dropRowHeld;
     /**
-     * 引擎文件仓的存档目录(`<数据根>/sessions`,`FileSessionRepo` 的布局)fsync 一次,失败即抛 —— M33 在删快照之前确知新写的存档目录项在盘上
-     * (引擎的导入只尽力 fsync 目录,吞掉失败)。只有 M33 用;目录不在 ⇒ 抛(布局变了就响亮,不静默跳过屏障)。
+     * 引擎文件仓的存档目录(`<数据根>/sessions`,`FileSessionRepo` 的布局)fsync 一次,失败即抛 —— 常设屏障:删序的 s4(删格之前确知删掉的存档目录项在盘上;core 的文件仓删存档只删文件、
+     * 不 fsync 目录)与一次性迁移 M33(删快照之前确知新写的存档目录项在盘上;引擎的导入只尽力 fsync 目录,吞掉失败)。repo 不是文件仓(内存部署 / 内存 repo)⇒ 没有存档文件,无事;
+     * win32 不 fsync 目录(打不开目录 fd;与原子写同一条平台律 —— 那里的掉电保证只到普通异常与进程终止两档);文件仓而目录不在 ⇒ 抛(布局变了就响亮,不静默跳过屏障)。
      */
     private syncArchiveDirectory;
+    /**
+     * **写者律**的那一步({@link withSessionWriteLock} 的每一节先调,调用方持这只会话的写锁):这只 id 是**标记格**(不在删而带「删除中」—— release / 撤回的删序停在 s0 之后)⇒
+     * 走完删序({@link dropRowHeld},从 s0 的重证开始),交回收掉的那一格;没有待删 ⇒ `undefined`。收不完 ⇒ 抛(这一节不跑,原故障上抛)。
+     * 在删格(哪怕同时带标记 —— 它的终刀停在 s0 之后)**不归这里收**:收它归删除协议(围栏接管 → 协调器各腿 → 终刀,`src/session-deletion.ts`)—— 写者律收了它,
+     * 同 id 的重登记就会抢在协调器其余各腿之前收尾,而后那些腿删到的是新住客的状态。
+     */
+    private finishPendingDropHeld;
+    /**
+     * **起服扫**(唯一调用点 `LocalBackend.ensureSchema()`,排在严格边档对账之后):每一只标记格(上一个进程的 release / 撤回停在 s0 之后;在删格不在此列 —— 它们由删除协调器的起服收尾收)取一次它的锁 —— 节首收尾走完删序。
+     * 收不完 ⇒ 每只一行 warn `session_drop_unfinished`(id + 故障),照常服务:读者律已让它不可见,下一次取这只 id 的锁时再收。内存部署(没有数据根)⇒ 零读。
+     */
+    finishPendingDrops(): Promise<void>;
+    /**
+     * 一次性迁移 **M48 的 local 腿**(会话行半场;窗、删法与删后谁接住:窗口见 `plugins/one-time-migrations.ts` 登记表):属主恰为 cli 哨兵(`shell-sentinel-owner-m48.ts`)的
+     * 会话元数据格改写成无主(`owner: null`),一次边档提交(落不了盘 ⇒ 响亮抛,不当已改)。带「删除中」位的格不碰(删序正在收它)。起服时调(`LocalBackend.runOneTimeMigrations`,
+     * 任何读者之前);数据根独占 ⇒ 没有混跑窗。幂等:写后不再有哨兵值 ⇒ 第二跑零命中、不落盘。命中的格由 {@link shellSentinelCellIdsM48} 说(与 {@link countShellSentinelOwnersM48} 同一只)。
+     */
+    clearShellSentinelOwnersM48(): Promise<number>;
+    /**
+     * 一次性迁移 **M48 的 local 腿**(有身份边界的部署:只数不写;窗、删法与删后谁接住:窗口见 `plugins/one-time-migrations.ts` 登记表):属主恰为 cli 哨兵的会话元数据格数 ——
+     * 命中判据与 {@link clearShellSentinelOwnersM48} 是同一只函数({@link shellSentinelCellIdsM48}),在写链上读同一份草稿(`change` 答 `false` ⇒ 不写、不重证)。
+     */
+    countShellSentinelOwnersM48(): Promise<number>;
+    /**
+     * 一次性迁移 M47 的 local 腿(`LocalBackend.ensureSchema` 调,紧随快照消化、先于整段 `runOneTimeMigrations` —— 迁移段里任何一步拒启也不再挡在它前面;起服、先于任何请求;窗内每次起服都跑,第二次起零命中):
+     * 列表面行集({@link rowHeaders})里每一只**存档头读得出、会话元数据格缺**的会话 —— 主要来源是 7.148.0 之前的 run-local(它经引擎的文件仓直接建档、续跑,从不写格),
+     * 其次是建档与写格之间的崩溃 —— 建一格:化身经窗内长第一格的唯一规则 {@link firstCellIncarnationOf}(存档头上的令牌;没有 ⇒ 新铸 —— 7.49.0 之前的存档头没有令牌),
+     * 建档时刻 / 谱系 = 存档头的(与 M33 行回填同一只读法 {@link archivedRowFactsOf}),属主键不写(从没被记下,与补铸同义)。格在的一个字节不动。一次边档提交。
+     * 为什么取头令牌:格缺 ⇒ 没有竞争的令牌;存档头那只是唯一交给过消费者的值 —— 7.148.0 之前 run-local 的记忆引擎按它落记录(采集 opt-out、污染标记),收进行之后两条入口照样绑;
+     * 崩溃生的无格存档,头令牌从没交出过(交出在写格之后,{@link handOut}),取它也无害。本条是那条规则的急切版(窗内按 id 打开 / 登记 / 回填走同一只函数)。
+     *
+     * **欠账起服**(数据根里有收令牌欠账标记 —— 带本条的构建打开这只根时它还欠,数据根准入算出、锁内在抬高水位之前由 `settleArchiveTokenAdoptionDuty` 记下的)多两步,收齐才**销账**:
+     *  1. 边档提交用 `required`(有改动 ⇒ 写并证目录项;零改动 ⇒ 重证盘上那一份 —— 上一次可能正停在「落了、没证」;证不了 ⇒ 拒);
+     *  2. **证明收齐**({@link assertArchiveTokensAdoptedM47}):用常驻臂自己那一只读法(失败即抛的目录读 + 盘上的严格边档读 {@link readSessionMetaCellsSync})再读一遍,
+     *     剩下的无格存档必须都在本条的收取范围之外(placed、存档头读不出)—— 引擎的列表在目录读失败时降级为空列表(列表面的成文降级),本条读到空列表会「什么都没收」,
+     *     证明把它变成拒,在 M33 与任何请求之前;
+     *  3. 删标记(落盘)。任何一步失败 ⇒ 拒启、标记留着,下一次窗内起服重来;窗关之后的构建见标记 ∧ 无格存档 ⇒ 拒(出路 = 不低于已记高水位、仍带本条的版本起一次)。
+     * 非欠账起服(无标记:高水位不早于引入版本 ∧ 收齐过)照旧 `best-effort`,零命中不写也不重证(每次窗内起服不多一次 fsync、不因它拒启)。
+     */
+    adoptArchiveTokensM47(): Promise<LocalArchiveTokenAdoption>;
+    /**
+     * M47 欠账起服的**证明**(销账之前;拒 ⇒ 标记留着):盘上「存档在而格缺」的每一只(常驻臂的同一只读法 {@link readSessionMetaCellsSync} + 存档目录读:目录读失败即抛)都必须在本条的收取范围之外
+     * ({@link adoptionScopeOf});范围之内还剩 ⇒ `SessionError("storage")`(只点名只数)。
+     */
+    private assertArchiveTokensAdoptedM47;
+    /**
+     * 一只无格存档在不在 M47 的收取范围里(= 引擎列表面的行:行头读得出、非 placed —— 本条从那里取行;列表对行头读抛的存档一律跳过并披露)。两步,只把**行头**读不出剔出去:
+     *  ① 行头上的元组({@link recordedPlacementOf}:只读首记录)—— 读抛(没有头记录 / 元组那一格坏 / 首记录读不了)⇒ `out`;placed ⇒ `out`;
+     *  ② 普通行再读头({@link archiveHeadOf}:首记录 + 尾)—— 不在 ⇒ `out`(无事可收);`corrupt_session`(此时只剩属主那一格坏 —— 首记录与元组在 ① 已读得出)⇒ `out`;
+     *     读得出 ⇒ `in`;别的故障(读尾的 I/O 等:行头 ① 已证读得出,列表本该列它)⇒ `in`(漏收就是漏收,拒、不剔)。
+     * 剔出去的(行头读不出)每只一行 warn `archive_token_adoption_skipped`(id + 故障):本条与任何读者此刻都取不到它的令牌 —— 剔除并披露,与一次性迁移 M32「一只读不出的旧会话不拒启」同一条律;
+     * 它若在窗关之后才读得出,第一次读新铸。
+     */
+    private adoptionScopeOf;
+    /** {@link adoptionScopeOf} 的剔除披露(行头读不出的无格存档):一行 warn,答 `out`。 */
+    private skippedFromAdoption;
     /** 快照目录(数据根下;内存部署 ⇒ `undefined`:没有持久存档,迁移零动作)。 */
     private archiveSnapshotDir;
     /**
@@ -881,14 +1199,14 @@ export declare class LocalSessionStore implements SessionStore {
     settleArchiveSnapshots(): Promise<number>;
     /** 消化一份快照记录(步 0 的一条;拒 ⇒ {@link LocalArchiveSnapshotsPresentError},记录原样留着)。 */
     private settleArchiveSnapshot;
-    /** 把行事实补进那一格(格缺 ⇒ 铸一格;已有的位一个不动)并落盘。 */
+    /** 把行事实补进那一格(格缺 ⇒ 建一格,化身经窗内长第一格的唯一规则;已有的位一个不动)并落盘。`archiveToken` = 快照记下的那一代存档头上的令牌。 */
     private fillRowFacts;
     /**
      * 一次性迁移 M33 的 local 腿(`LocalBackend.runOneTimeMigrations` 调;起服、先于任何请求;窗内每次起服都跑,第二次起零命中):
      *  0. 恢复先行({@link settleArchiveSnapshots},幂等);
      *  1. **枚举**(行集 `rowHeaders`):id 全集 = 引擎仓的列表(读得出头的存档)∪ 边档全部键;只在边档里的、头读抛且不是 placed 行(行头读得出)的 ⇒ 计 unreadable(步 3 整档读抛的同计)。两边都不在的读不出存档(列表跳过它、边档里没它的格)
      *     对本店与引擎同样不可见,不计;
-     *  2. **行回填**:列表里每一只存档 —— 格缺 ⇒ 建一格(化身新铸、属主「从没被记下」,与补铸同义);格缺建档时刻 ⇒ 写存档头的;格缺谱系而存档头有 ⇒ 写它。只写行(边档的一次提交),
+     *  2. **行回填**:列表里每一只存档 —— 格缺 ⇒ 建一格(化身经窗内长第一格的唯一规则 {@link firstCellIncarnationOf}、属主「从没被记下」,与补铸同义);格缺建档时刻 ⇒ 写存档头的;格缺谱系而存档头有 ⇒ 写它。只写行(边档的一次提交),
      *     然后一道**落盘屏障**(边档文件与目录各 fsync)—— 在这之前不碰任何存档;
      *  3. **存档归一**(每只头上带属主戳的存档,在它的会话写锁里):a 整档一次读(读时跳过了记录 ⇒ 留着,计 kept `records_skipped`:重写会抹掉盘上那几行读不出的字节)→
      *     b 先验(引擎导入闸,带 `preserveActorAssertions`:同部署迁移,发言者归属不剥)—— 抛 ⇒ kept `invalid`;验后的日志与原日志不逐条相等(引擎导入会改写内容)⇒ kept `normalizes`;