@sema-agent/server 7.134.0 → 7.136.0

package/dist/session-incarnation.d.ts

@@ -1,5 +1,5 @@
 /**
- * S-790 / S-506([ref] §2)—— **会话化身**:一个会话 id 是座位,化身是这一位住客。
+ * [ref] / [ref]([ref] §2)—— **会话化身**:一个会话 id 是座位,化身是这一位住客。
  *
  * 会话 id 由调用方自选,删掉之后同一个 id 可以被别人(或同一个人)重新登记(`boot/session-faces.ts` 的级联删除注自认)。
  * 本仓大量持久状态只按会话 id 分区,于是「上一位住客留下的东西」会在下一位名下继续起作用。化身令牌给「是不是同一位住客」
@@ -11,32 +11,43 @@
  *    化身沿用。删除随行消失,同 id 重新登记铸新的。
  *  · **值是不透明随机串**(`randomUUID()`,v4:没有时间戳、没有机器信息 —— 刻意不用 uuidv7,那一形带铸造时刻)。只拿来比较。
  *  · **一格、一个解码**:住客令牌是会话**行**上的一格 —— SQL `session_meta.incarnation`(两方言)、local 后端的会话元数据边档那一格
- *    (`plugins/local-session-store.ts` 的 `session-incarnations.json`)。每只店对它只有**一次读**(`sessionFaceOf`),行上的值只经
- *    {@link incarnationFromCell} 解码;别的读法都从这一次读派生(下一节),没有第二份。
- *  · **读口唯一**:会话店的 `sessionFaceOf(sessionId) → { owner, incarnation } | undefined`,一次读同时给两样
- *    (两次独立读在删除 / 重登记的缝里能拼出混世代组合,与 `getHead` 同一条理由)。`undefined` = 没有这只会话。
- *  · **读到空化身 ⇒ 响亮拒**({@link SessionIncarnationMissingError}):一次性迁移(`plugins/one-time-migrations.ts` 登记表 M5)
- *    之后,空值只可能来自没铸化身的写腿或人为改库 —— 把它当「通配」就是让任何人都能和这一行比成同一位住客。
+ *    (`plugins/local-session-store.ts` 的 `session-incarnations.json`)。行上的值只经 {@link incarnationFromCell} 解码。
+ *  · **按 id 读只有一只:core 的 `SessionStore.headOf(id)`**(core 7.55.0 [ref] S2;`{ owner, incarnation, leafId }`,同一行、同一次读 ——
+ *    两次独立读在删除 / 重登记的缝里能拼出混世代组合)。`undefined` = 没有这只会话。店把行读成头只经 {@link headFromRow}:化身那一格按
+ *    `absent` 读(空 / 非串 ⇒ `undefined` = 住客未知,core 的同一读法)。按 id 问属主 / 住客 / 叶子的每一个读者都是这一只读的投影 ——
+ *    本仓此前每只店各有五只按 id 读(`ownerOf` / `incarnationOf` / `sessionFaceOf` / `getHead` / `getLeafId`),同一行的五个读者,全部退役。
+ *    「店有没有这只读」只判一处:{@link headReadOf}。
+ *  · **头答自会话行;会话内容读不出只是叶子那一格的事**(三种会话店一律):有没有这只会话、归谁、哪一位住客,只问行(SQL `session_meta`;
+ *    local 店 = 会话元数据边档那一格)。头里唯一可能取自会话**内容**的一格是叶子(local 店的叶子取自会话存档的末条条目,SQL 的叶子是行上的一列)——
+ *    内容读不出时,头照答行上的属主与住客,叶子那一格带着读它时撞上的那只故障({@link UnreadableLeaf}),**谁读叶子谁收到它**。
+ *    于是只判归属的读者(授权门、各路由的属主门、删除的围栏、住客读)对坏内容与好内容同答,内容的故障只让门放行之后读内容的那一位看见;
+ *    行本身读不出(local:边档里还没有这只会话的那一格、要从存档推出它在不在,而存档读不出)⇒ 头读整只拒(读故障,不是答案)。
+ *  · **两头是不是同一位住客:core 的 `compareOccupants`**(三答 `same` / `different` / `unknown`;任一侧没有行或没有令牌 ⇒ `unknown`,
+ *    `unknown` 永不当 `same`)。本仓自写的比较(`sameSessionOccupant`)退役:同一个问题只有引擎那一只判官。
+ *  · **一位活住客必须有令牌 —— 读到空化身 ⇒ 响亮拒**({@link SessionIncarnationMissingError}):本仓比 core 多的那一条律,只住在一处 ——
+ *    把头投成 {@link SessionFace}(属主 + 一只令牌)的 {@link sessionFaceOfHead}(批量来源读与换装回读用同一只 {@link sessionFaceFromRow})。
+ *    要拿令牌去**写**(带化身条件的 UPDATE、认领、空间分区键)或要响亮区分「行坏了」的读者经它;只**比较**两头的读者用 `compareOccupants`。
+ *    空值只可能来自没铸化身的写腿、人为改库,或跳过了 7.104.0–7.135.x(那几版的起服迁移给存量行铸令牌,窗关后已删码)直接升上来的库 ——
+ *    把它当「通配」就是让任何人都能和这一行比成同一位住客。
  *  · **不上 wire、不进模型上下文、不进日志正文**:日志里要点名时只打 {@link incarnationLogPrefix}(前 8 位)。
  *
- * ## 谁读它(全部派生自那一格)
- *  · `/decide` 的 parked 赎回腿(`parked-decide.ts`):claim 前读一次、claim 后再读一次,会话不在或化身变了 ⇒ 回滚 claim、
+ * ## 谁读它(全部派生自那一只头读)
+ *  · `/decide` 的 parked 赎回腿(`parked-decide.ts`):claim 前读一次、claim 后再读一次,会话不在或不是同一位住客 ⇒ 回滚 claim、
  *    答既有的 `409 decide.not_parked`;赎回面(`parked-revive-surface.ts`)只在属主相等**且**两次读是同一位住客时交继承座。
  *  · core 的记忆引擎:Runner 读**它取到的那只会话**的 `getMetadata().incarnation`(SQL 两店的 wake 带出这一列;local 店交出的会话
  *    在元数据上答边档那一格),不再有宿主座。
- *  · 按 id 读的消费方(没取会话的那一侧 —— k8s 工作区空间的分区,`boot/execution-env.ts`):core 的 `SessionStore.incarnationOf`,
- *    三只店都实装为 `sessionFaceOf` 的化身那一半;缓存包装层原样转发。「店有没有这只读」只判一处:{@link incarnationReadOf}。
+ *  · 没取会话的那一侧(k8s 工作区空间的分区,`boot/execution-env.ts`):会话店的 `headOf`,经 {@link sessionFaceOfHead} 拿令牌;缓存包装层原样转发。
  */
-import type { SessionStore } from "@sema-agent/core";
-/** 会话元数据的一次读:属主 + 化身(同一行、同一次读)。 */
+import type { SessionHead } from "@sema-agent/core";
+/** 一位活住客:属主 + 它的令牌(同一行、同一次读;投影自会话店的头,见 {@link sessionFaceOfHead})。 */
 export interface SessionFace {
     /** `null` = 登记为无主的会话。 */
     readonly owner: string | null;
-    /** 这一位住客的化身令牌(非空;空值在读口就响亮拒了)。 */
+    /** 这一位住客的化身令牌(非空;空值在投影处就响亮拒了)。 */
     readonly incarnation: string;
 }
-/** 读口的形(三只会话店 + 缓存包装层同一个签名)。 */
-export type SessionFaceReader = (sessionId: string) => Promise<SessionFace | undefined>;
+/** 会话店的按 id 读(core `SessionStore.headOf` 的形):`undefined` = 没有这只会话;读抛 = 读故障,不是答案。 */
+export type HeadRead = (sessionId: string) => Promise<SessionHead | undefined>;
 /** 铸一只新化身(铸点见头注,只在新建行)。 */
 export declare function mintSessionIncarnation(): string;
 /** 日志里点名一只化身时唯一允许的形:前 8 位。完整令牌不进任何日志正文。 */
@@ -46,11 +57,6 @@ export declare function incarnationLogPrefix(incarnation: string): string;
  * 把其中每一只化身形的串截成 {@link incarnationLogPrefix}(前 8 位 + `…`)。规则只有一条:完整令牌不进日志正文;前 8 位留着对账。
  */
 export declare function redactIncarnations(text: string): string;
-/**
- * 两次读是不是**同一位住客**:都在、化身逐字相等。任一次读不到(会话不在)⇒ 不是 —— 没有「读不到就当相同」的臂。
- * 属主是否等于某个身份是调用方自己的判据(赎回面比的是卡的权威 principal),不在这里。
- */
-export declare function sameSessionOccupant(before: SessionFace | undefined, after: SessionFace | undefined): boolean;
 /**
  * 会话行在、化身却是空的 —— 响亮拒(头注「读到空化身」一条)。具名类型:调用方按类型认它,不按文案。
  * 文案不带任何令牌(本来就是空的),只点名会话 id 与出路。
@@ -62,32 +68,54 @@ export declare class SessionIncarnationMissingError extends Error {
 }
 /**
  * 空化身那一格怎么读 —— {@link incarnationFromCell} 的参数(一只解码,两种**显式**读法;不是两只函数):
- *  · `refuse`(缺省,读口):一位活住客必须有令牌 ⇒ 空 / 非串 = {@link SessionIncarnationMissingError}(响亮拒,不当通配);
- *  · `absent`:调用方问的是「这一格里有没有一只令牌」,空 / 非串的答案是**没有**(`undefined`)—— 会话树删除时的空间键
- *    (没有令牌 = 没有空间,不回收缓存卷)与整段换装的沿用判据(没有令牌 = 铸一只新的)。
+ *  · `refuse`(缺省,活住客的投影 {@link sessionFaceFromRow} / {@link sessionFaceOfHead}):一位活住客必须有令牌 ⇒ 空 / 非串 =
+ *    {@link SessionIncarnationMissingError}(响亮拒,不当通配);SQL 两店 wake 带出的会话元数据同此读;
+ *  · `absent`:调用方问的是「这一格里有没有一只令牌」,空 / 非串的答案是**没有**(`undefined`)—— 店读出的头({@link headFromRow},
+ *    core 的「住客未知」)、会话树删除时的空间键(没有令牌 = 没有空间,不回收缓存卷)与整段换装的沿用判据(没有令牌 = 铸一只新的)。
  */
 export type EmptyIncarnationReading = "refuse" | "absent";
 /**
- * 行上化身那一格的**唯一解码**(三只店的 `sessionFaceOf`、SQL 两店 wake 带出的会话元数据、留存删除的空间键、整段换装的沿用判据都经它 ——
+ * 行上化身那一格的**唯一解码**(店读出的头、活住客的投影、SQL 两店 wake 带出的会话元数据、留存删除的空间键、整段换装的沿用判据都经它 ——
  * 「是不是一只令牌」只判这一处)。非空字符串 ⇒ 那只令牌;否则按 `empty`({@link EmptyIncarnationReading}):缺省 `refuse` ⇒
  * {@link SessionIncarnationMissingError},`absent` ⇒ `undefined`。
  */
 export declare function incarnationFromCell(sessionId: string, cell: unknown, empty?: "refuse"): string;
 export declare function incarnationFromCell(sessionId: string, cell: unknown, empty: "absent"): string | undefined;
-/** 店把一行原始列读成 {@link SessionFace} 的唯一口(三只店共用;化身那一格经 {@link incarnationFromCell})。 */
+/** 一行原始列 → {@link SessionFace}(属主 + 一只令牌)的唯一口:化身那一格经 {@link incarnationFromCell} 的 `refuse` 读法(空 ⇒ 响亮拒)。
+ *  按 id 的读者经 {@link sessionFaceOfHead};批量来源读(委派继承律)与 staged 换装的回读直接从行列经它。 */
 export declare function sessionFaceFromRow(sessionId: string, owner: string | null, incarnation: unknown): SessionFace;
-/** 按 id 读住客(core `SessionStore.incarnationOf` 的形):`undefined` = 没有这只会话;读抛 = 读故障,不是答案。 */
-export type IncarnationRead = (sessionId: string) => Promise<string | undefined>;
 /**
- * 「这只会话店能不能按 id 答住客」—— 全仓**只判这一处**:起服门(`assertWorkspaceSpaceReadable`)与 k8s 工作区空间的每 run 读
- * (`createK8sRunEnvFactory`)读的是同一只返回值(装配第 5 段判一次)。缺席 = 店没有实装 `incarnationOf`。
+ * 头的叶子那一格读不出 —— 会话**内容**读不出时的那只故障(local 店:会话存档读不出,例如存档首行的会话头坏了;行上的属主与住客照样读得出)。
+ * {@link headFromRow} 收它:头照答属主与住客,叶子那一格带着这只故障,读 `leafId` 的那一位收到它本身(同一只错误对象,码与句子原样 ——
+ * 上 wire 时照旧经 `sessionErrorHttp` 映射)。规则见头注「头答自会话行」一条。
+ */
+export declare class UnreadableLeaf {
+    readonly fault: unknown;
+    constructor(fault: unknown);
+}
+/** 店把一行读成 core {@link SessionHead} 的唯一口(SQL 两孪生、local 店同调):化身那一格按 `absent` 读(空 / 非串 ⇒ `undefined` = 住客未知,
+ *  与 core 的读法同义 —— 拒不拒是投影的事,见 {@link sessionFaceOfHead})。叶子那一格读不出({@link UnreadableLeaf})⇒ 头照答属主与住客,
+ *  读 `leafId` 的那一位收到那只故障 —— 永不把读不出的叶子答成 `null`(`null` = 空会话)。 */
+export declare function headFromRow(sessionId: string, owner: string | null, incarnation: unknown, leaf: string | null | UnreadableLeaf): SessionHead;
+/**
+ * 🔴 **会话内容读不读得出 —— 会话路由在门放行之后判它的唯一读法**:读头的叶子。内容读不出的头({@link UnreadableLeaf})在这一读上抛那只故障本身
+ * (码 `corrupt_session`,经 `sessionErrorHttp` 的 open 面落 500);读得出 ⇒ 叶子 id(`null` = 空会话)。
+ * 谁在**门放行之后**要动这只会话的内容(读叶子本身、开事件流、改名 —— 改名答的是列表行,列表读存档),谁就经它读一次;
+ * 门之前不许读(非属主对坏档与对好档同答,见头注「头答自会话行」)。三个口各写一句 `head.leafId` 与各写一句"存档坏了怎么办"是同一件事的三种答法
+ * (修前:头探针 500、事件流 200 零帧 —— 观察探针把每拍读叶子抛出的故障当瞬时错吞掉 —— 改名 404 —— 列表跳过读不出的存档,会话被说成不存在)。
+ * SQL 两店的叶子是行上的一列,永不抛 ⇒ 这一读在 SQL 上恒等于 `head.leafId`,这条判据只对内容与行分居两处的店(local)有牙。
+ * 事件流只在开流之前判一次;流开了之后存档才坏,观察探针仍把读叶子的故障当瞬时错续探(流不断、不再产出新帧)。
  */
-export declare function incarnationReadOf(store: Pick<SessionStore, "incarnationOf"> | undefined): IncarnationRead | undefined;
+export declare function leafOfAdmittedHead(head: SessionHead): string | null;
+/** 一只头 → 一位活住客({@link SessionFace}):`undefined` 头 = 没有这只会话 ⇒ `undefined`;行在而没有令牌 ⇒ {@link SessionIncarnationMissingError}
+ *  (本仓的那条律只住在这里 + {@link sessionFaceFromRow})。 */
+export declare function sessionFaceOfHead(sessionId: string, head: SessionHead): SessionFace;
+export declare function sessionFaceOfHead(sessionId: string, head: SessionHead | undefined): SessionFace | undefined;
 /**
- * 「这只会话店能不能按 id 答住客脸(属主 + 化身一次读)」—— 与 {@link incarnationReadOf} 同一处判法、同一个「能不能」:
- * 空间缓存卷的回收用它一次拿两位(属主要与这次删除验过的那位相符,化身是空间键)。店没有这只读口 ⇒ `undefined`(回收不做,不响)。
+ * 「这只会话店有没有按 id 读(`headOf`)」—— 全仓**只判这一处**:授权口、各路由的属主门、能力位、起服门、k8s 工作区空间的每 run 读与
+ * 委派继承律读的都是这一只返回值。缺席 = 店没有实装 `headOf`(读不出属主 / 住客 / 叶子,调用方各按自己的 fail-closed 臂处置)。
  */
-export declare function sessionFaceReadOf(store: object | undefined): SessionFaceReader | undefined;
+export declare function headReadOf(store: object | undefined): HeadRead | undefined;
 /**
  * session-sync **整段换装**(replace)时化身的去留 —— 三只店共用的一句判据:换装删掉再插回的是**同一位住客**的那一行
  * (删除带属主门),所以行在、属主相同、那一格里有一只令牌(唯一解码 {@link incarnationFromCell} 的 `absent` 读法)⇒ 沿用;
@@ -99,12 +127,12 @@ export declare function carriedIncarnation(sessionId: string, prior: {
 } | undefined, owner: string | null): string;
 /**
  * `session_meta.incarnation` 的列定义 —— 两方言各一句,**唯一属主**:中央 DDL(`tidb-pool.ts` / `pg-session-storage.ts` 的
- * `CREATE TABLE session_meta`)与一次性迁移 M5 的 `ADD COLUMN`(`plugins/one-time-migrations.ts`)都内插这同一串,
- * 于是「新库建出来的列」与「存量库补上的列」逐字同形(S-547 起服列册探针比的是列名,形由这里保证)。
+ * `CREATE TABLE session_meta`)内插这同一串;存量库缺这一列时,起服列册探针(`schema-consistency.ts`)拒启,拒句里的 `ALTER TABLE … ADD COLUMN …`
+ * 由同一份建表语句解析生成 ⇒ 「新库建出来的列」与「运维按拒句补上的列」逐字同形(探针比的是列名,形由这里保证)。
  *
  * `NOT NULL DEFAULT ''`:空串就是「没铸过」的唯一表示 —— 读口对它响亮拒({@link SessionIncarnationMissingError})。
  * 缺省值只为两件事存在:①存量表 `ADD COLUMN` 在两方言上一句成立(PG 对非空表加无缺省的 NOT NULL 列直接拒);
- * ②一条漏铸的写腿落下的是**读得出来的错**(读口拒),而不是一条插入期的 500 —— 两形都 fail-closed,前者还能被迁移补上。
+ * ②一条漏铸的写腿落下的是**读得出来的错**(读口拒),而不是一条插入期的 500 —— 两形都 fail-closed。
  * 宽度 64:`randomUUID()` 是 36 字符,留出余量但不给任意长串留位。
  */
 export declare const SESSION_META_INCARNATION_COLUMN: {

package/dist/session-incarnation.js

@@ -9,17 +9,14 @@ const INCARNATION_TOKEN_SHAPE = /[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9
 export function redactIncarnations(text) {
     return text.replace(INCARNATION_TOKEN_SHAPE, (token) => `${incarnationLogPrefix(token)}…`);
 }
-export function sameSessionOccupant(before, after) {
-    return before !== undefined && after !== undefined && before.incarnation === after.incarnation;
-}
 export class SessionIncarnationMissingError extends Error {
     sessionId;
     code = "session.incarnation_missing";
     constructor(sessionId) {
-        super(`session ${sessionId} has no incarnation token: every session row is minted one when it is created, and rows written before ` +
-            `7.104.0 get one from the one-time migration that runs at boot (plugins/one-time-migrations.ts, entry M5). An empty value ` +
-            `after that means a write path that did not mint one, or a hand-edited row — it is refused rather than read as "matches anyone". ` +
-            `Restart a 7.104.0+ replica so the migration backfills it, or delete the session.`);
+        super(`session ${sessionId} has no incarnation token: every session row is minted one when it is created. An empty value means a write path ` +
+            `that did not mint one, a hand-edited row, or a database upgraded from before 7.104.0 straight to a version after 7.135.x (a boot of any ` +
+            `version in between minted tokens for the older rows; the code that did so has since been removed) — it is refused rather than read as ` +
+            `"matches anyone". Give the row a distinct random token (any opaque string of at most 64 characters), or delete the session.`);
         this.sessionId = sessionId;
         this.name = "SessionIncarnationMissingError";
     }
@@ -41,12 +38,33 @@ export function incarnationFromCell(sessionId, cell, empty = "refuse") {
 export function sessionFaceFromRow(sessionId, owner, incarnation) {
     return { owner, incarnation: incarnationFromCell(sessionId, incarnation) };
 }
-export function incarnationReadOf(store) {
-    const read = store?.incarnationOf;
-    return typeof read === "function" ? read.bind(store) : undefined;
+export class UnreadableLeaf {
+    fault;
+    constructor(fault) {
+        this.fault = fault;
+    }
+}
+export function headFromRow(sessionId, owner, incarnation, leaf) {
+    const occupant = incarnationFromCell(sessionId, incarnation, "absent");
+    if (!(leaf instanceof UnreadableLeaf))
+        return { owner, incarnation: occupant, leafId: leaf };
+    const { fault } = leaf;
+    return {
+        owner,
+        incarnation: occupant,
+        get leafId() {
+            throw fault;
+        },
+    };
+}
+export function leafOfAdmittedHead(head) {
+    return head.leafId;
+}
+export function sessionFaceOfHead(sessionId, head) {
+    return head === undefined ? undefined : sessionFaceFromRow(sessionId, head.owner, head.incarnation);
 }
-export function sessionFaceReadOf(store) {
-    const read = store?.sessionFaceOf;
+export function headReadOf(store) {
+    const read = store?.headOf;
     return typeof read === "function" ? read.bind(store) : undefined;
 }
 export function carriedIncarnation(sessionId, prior, owner) {

package/dist/session-policy-wire.d.ts

@@ -2,15 +2,16 @@
  * 会话规则(`SessionPermissionRules`)的 **wire 面单一属主** —— 两条写入腿(`PUT /v1/sessions/:id/policy` 与
  * `POST /v1/sessions/:id/sync/import` 的 `policy` 面)的写口读者、`SessionPolicyError` 闭集 → HTTP 的映射、拒句。
  *
- * ── 规则(一句;引擎 7.51.0 #1480 / #1497 起)────────────────────────────────────────────────────────────────────────
+ * ── 规则(一句;引擎 7.51.0 [ref] / [ref] 起)────────────────────────────────────────────────────────────────────────
  * 会话规则在每一站只有一种文法、一只判官 —— 引擎的:写口判官 `judgeSessionRulesWrite`(形 `readSessionRulesShape` → 每条条目的读法
  * `readRuleEntry`),读回是同一只形读法(SQL 店的 `readSessionRulesBody`)。core 7.51.2 起一行条目的意思由行自带的文法戳 `grammar` 说(判官盖、店整只存、
  * 读回原样交出);写口的值带 `rev` 而无戳 ⇒ 引擎按存量行的文法读它(`earlier_grammar`,见 {@link describeInertEntry})。引擎的两只**内容**拒码各对应一个本服务码,名字随引擎的词:
  *  · `invalid_shape` ⇒ `400 rules.invalid_shape` —— 规则体不是「一只对象、键都是桶、每只桶是一列字符串」(含退役的 `commandAllow` / `commandDeny`、
  *    纯空白的目录、`rules` 缺席或不是对象);拒体顶层 = 引擎的形读数 `{ field, got }`(值的**类型**,不回显值),句子 = 引擎的句子原样。
  *  · `inert_entry` ⇒ `400 rules.inert_entry` —— 桶里有一条引擎条目读者读成「什么都不是」的条目(退役名、无前缀的 `__` 名、铸不出的协议段、
- *    `*`、`mcp__*`、文法不成的 `Bash(`、工具没有那种规则形的 `Monitor(…)` …);拒体顶层 = 引擎的条目读数 `{ field, entry, reason, verdict?, guidance?,
+ *    `*`、放行桶里的整协议名 `mcp__*`(core 7.55.0 起拒绝桶里它是这一协议的每一只工具,收)、对端段的部分通配 `mcp__git*`、文法不成的 `Bash(`、工具没有那种规则形的 `Monitor(…)` …);拒体顶层 = 引擎的条目读数 `{ field, entry, reason, verdict?, guidance?,
  *    currentName? }`,句子是本服务的({@link describeInertEntry}:引擎那一句的退役名出路指向嵌入方的构造选项 `mountedToolNames`,HTTP 调用方没有这个旋钮)。
+ * 能力位 `sessionRulesNamespaceForms`({@link sessionRulesNamespaceFormsHonored})是同一只写口读者的投影:协议命名空间的覆盖形写口真收,位才说有。
  * 两条写入腿与店拒中继({@link sessionPolicyErrorHttp} / `http/send.ts` 的 `sendSessionPolicyError`)走**同一张映射、同一句、同一份拒体** ——
  * 写口读者先问一遍只是为了 sync/import 腿在建 staging **之前**整批拒(店拒发生在逐条写的中途),判官仍是引擎那一只。
  *
@@ -39,6 +40,27 @@ export declare function readWritableSessionPermissionRules(raw: unknown): {
     refusal: SessionRulesRefusal;
     rules?: undefined;
 };
+/**
+ * 表里每一员的**覆盖形**三只与一只它覆盖的真工具名 —— 全部由该员自己的 `prefix` / `makeName` 铸出,本仓不手写任何协议前缀:
+ * 整对端 `<前缀>peer`、工具段通配 `<前缀>peer__*`、工具段 glob `<前缀>peer__get_*`;`tool` = 同一员的 `<前缀>peer__get_user`(三形都该覆盖到它)。
+ * 表加一员,下一次调用里就有它的一行。
+ */
+export declare function namespaceCoveringForms(): readonly {
+    readonly prefix: string;
+    readonly forms: readonly string[];
+    readonly tool: string;
+}[];
+/**
+ * 能力位 `sessionRulesNamespaceForms` 的**唯一**判据:会话规则记录里协议命名空间的覆盖形,引擎认成「一组工具」**且**写口收。
+ * 对 `PROTOCOL_TABLE` 的每一员:① 它的三只覆盖形,引擎的匹配器(`namespacedRuleNameCovers`,会话层与其余规则面同一只)都判得出覆盖那一员的真工具名
+ * (只当精确名收的写口不算 ——「收」与「认成一组」是两问);② 三形放进 `toolAllow` 与 `toolDeny` 两桶,两条写入腿共用的写口读者
+ * {@link readWritableSessionPermissionRules}(= 引擎写口判官)不拒。表非空 ∧ 每员都过 ⇒ `true`。
+ *
+ * 位说「有」的依据是写口**真收**,不是「表非空」这个未经验证的蕴含:`PUT /v1/sessions/:id/policy` 与 sync/import 的 `policy` 面调的就是同一只读者,
+ * 「位说有而写口恒拒」结构上不可能([ref] 族)。每次请求现算(不缓存):表是引擎的活数据,位随它走;纯函数、零 I/O,代价是几次条目读。
+ * 辖域是引擎 / 二进制事实,与本部署有没有会话规则店无关(那是 `sessionPolicy` 的事,一位一事)。
+ */
+export declare function sessionRulesNamespaceFormsHonored(): boolean;
 /** 一条 `SessionRulesRecord` 的问题(`policy[]` 的元素级;规则体的问题原样转载引擎的内容拒)。 */
 export type SessionRulesRecordProblem = 
 /** `policy` 本身不是数组。 */
@@ -110,15 +132,15 @@ export declare function sessionPolicyErrorFacts(e: SessionPolicyError): Readonly
  * **数据完整性故障**。这正是 [ref] 词表纪律说的那一形:闭集必须穷尽 `switch`,未知词是**编译**错,
  * 不是运行期落进某个恰好存在的臂。
  *
- * ⇒ 映射搬到这里(本文件是会话规则 wire 面的单一属主,S-496 先例),两条写入腿、读腿与 2c 重放腿同调它。
+ * ⇒ 映射搬到这里(本文件是会话规则 wire 面的单一属主,[ref] 先例),两条写入腿、读腿与 2c 重放腿同调它。
  * 新增一个词 ⇒ 本 switch 编译红,由人裁定它的状态码与码位,而不是让它静默继承邻居的。
  *
  * 逐词:
  *  · `conflict`(409)—— CAS 输了,重读 `rev` 再来。**码位与状态逐字不变**。
- *  · `loosen_forbidden`(403)—— 非 operator 想放松。**码位与状态逐字不变**。⚠️ 这个词还有**第二个铸点**(S-546 B5,
+ *  · `loosen_forbidden`(403)—— 非 operator 想放松。**码位与状态逐字不变**。⚠️ 这个词还有**第二个铸点**([ref] B5,
  *    如实登记、未改):PG 后端的 SQL 双生对含 NUL / 孤代理字节的规则拒收时借用了它
  *    (`plugins/session-policy-store-sql.ts` 的 `pgHasUnstorable` 臂)—— 那一形**既非放宽也非越权**,operator 写同样撞上;
- *    core 的闭集里没有「输入不可存」这个词,改码位要先裁定新码与 PUT / 2c 导入两条入口同判(DEBTS S-546 B5)。
+ *    core 的闭集里没有「输入不可存」这个词,改码位要先裁定新码与 PUT / 2c 导入两条入口同判(DEBTS [ref] B5)。
  *  · `corrupt`(**500**)—— 店读不出它自己该读的那份字节(记号/行被列外篡改或撕裂,或存着引擎今天的形读法读不出的规则体)。
  *    不是 4xx:调用方没做错任何事,它也改不了这件事;不是 503:重试改不了判(修复路径是**人**去改回或删掉那一行,
  *    而删记号要交出它握着的那个号)。

package/dist/session-policy-wire.js

@@ -1,4 +1,4 @@
-import { PROTOCOL_TABLE, SessionPolicyError, judgeSessionRulesWrite } from "@sema-agent/core";
+import { PROTOCOL_TABLE, SessionPolicyError, judgeSessionRulesWrite, namespacedRuleNameCovers } from "@sema-agent/core";
 import { displayListEntry } from "./list-entry-display.js";
 function isSessionRulesRefusal(e) {
     return e instanceof SessionPolicyError && (e.code === "invalid_shape" || e.code === "inert_entry");
@@ -13,6 +13,20 @@ export function readWritableSessionPermissionRules(raw) {
         throw e;
     }
 }
+const PROBE_PEER = "peer";
+const PROBE_TOOL = "get_user";
+export function namespaceCoveringForms() {
+    return PROTOCOL_TABLE.map((ns) => ({
+        prefix: ns.prefix,
+        forms: [`${ns.prefix}${PROBE_PEER}`, ns.makeName(PROBE_PEER, "*"), ns.makeName(PROBE_PEER, "get_*")],
+        tool: ns.makeName(PROBE_PEER, PROBE_TOOL),
+    }));
+}
+export function sessionRulesNamespaceFormsHonored() {
+    const probes = namespaceCoveringForms();
+    return (probes.length > 0 &&
+        probes.every(({ forms, tool }) => forms.every((form) => namespacedRuleNameCovers(form, tool)) && readWritableSessionPermissionRules({ toolAllow: [...forms], toolDeny: [...forms] }).refusal === undefined));
+}
 export function readSessionRulesRecords(raw) {
     if (!Array.isArray(raw))
         return { problem: { kind: "not-an-array" } };

package/dist/session-records-skipped-notice.d.ts

@@ -1,6 +1,6 @@
 import type { EngineNoticeCode, FileStorageCorruptReadInfo, SessionRepo } from "@sema-agent/core";
 import { type EngineNoticeRouter } from "./trace/engine-notice-wire.js";
-/** 码常量型 = core 码册(#1240 入册:受众 user、铸者 `NOTICE_MINTER` = `"server"`)。 */
+/** 码常量型 = core 码册([ref] 入册:受众 user、铸者 `NOTICE_MINTER` = `"server"`)。 */
 export declare const SESSION_RECORDS_SKIPPED: EngineNoticeCode;
 /**
  * 披露座上的「作用域在场则记」腿(装配点 = `plugins/store-backend.ts` 里喂给 `LocalSessionStore` 的那只

package/dist/session-row.d.ts

@@ -1,19 +1,3 @@
-/**
- * 会话行的**可写位**(`title` / `pinned`)—— `PATCH /v1/sessions/:id` 的体闭集、两键的判据,与 2c 导入同读的那一套(唯一属主)。
- *
- * ## 一列一事实,写者次序成文
- *  · `title` 是一列(SQL `session_meta.title` / local 标题边档),两个写者,一条律:**用户**经会话店唯一写口 `patchSessionMeta`
- *    **无条件**写 —— 写一个串 = 改名,写 `null` = **清回自动标题**(列回到 NULL);**自动标题器**经 `setTitleIfNull` **只填 NULL**
- *    (每次提交按列读一次:列是 NULL 才起名,见 `session-titler.ts`)。所以清与填是同一列同一律:用户清掉之后,下一次提交由自动标题器
- *    照常填;用户写过串的会话,自动标题器永不覆盖(无条件写盖得掉自动标题,NULL 守卫盖不掉用户标题)。没有第二列(不另设 `userTitle` /
- *    `label`)。清的拼法只有 `null` 一种 —— 空串 `""` 是坏体(`request.body_shape`),不是「清」。
- *  · `pinned` 是一列布尔,缺省 `false`;列表行**恒在场**(置顶是会话的状态,不是能力)。
- *
- * ## 上界 = 列宽
- * {@link SESSION_TITLE_MAX_CHARS} 是 `title` 列的宽度,两方言 DDL 内插的就是这一个数(`tidb-pool.ts` / `pg-session-storage.ts`),
- * wire 上界与存储上界是同一个事实。按**字符**计(Unicode 码点 —— 与 MySQL 协议 utf8mb4 / PostgreSQL 的 `VARCHAR(n)` 同一单位),
- * 不按 UTF-16 位计。自动标题器自己的显示预算(`session-titler.ts` 的 `TITLE_MAX_CHARS`)更短,落在这个上界之内。
- */
 /** `title` 列的宽度(字符)= 用户标题的上界。两方言 DDL 内插它。 */
 export declare const SESSION_TITLE_MAX_CHARS = 120;
 /** 会话行的可写位(体闭集;两键至少一键)。会话店唯一写口 `patchSessionMeta` 的形参。`title: null` = 清回自动标题(列写 NULL)。 */
@@ -28,7 +12,9 @@ export interface SessionRowProblem {
 }
 /**
  * `title` 一格的**唯一**读者(PATCH 体与 2c 导入同读)。`null` ⇒ 清回自动标题;串 ⇒ 1..{@link SESSION_TITLE_MAX_CHARS} 个字符、首尾无空白、
- * 不含 C0 控制字符({@link C0_CONTROL}),存原文(不脱敏、不改写);空串 ⇒ `request.body_shape`(清的拼法只有 `null`);其余 ⇒ `request.field_invalid`。
+ * 不含 C0 控制字符({@link C0_CONTROL})、至少有一个可见字符(经 core 的 `normalizePeerName` 不为空 —— NFKC → 去控制 / 格式码点 → trim;
+ * 与跨会话对端目录判「这一行有没有可用名」是**同一只**判据,`peer-directory.ts`),存原文(不脱敏、不改写);空串 ⇒ `request.body_shape`(清的拼法只有 `null`);其余 ⇒ `request.field_invalid`。
+ * 三道串判的先后固定:边空白 → C0 → 无可见字符(带 C0 的串先报 C0)。
  */
 export declare function readSessionTitle(v: unknown): {
     readonly title: string | null;

package/dist/session-row.js

@@ -1,7 +1,9 @@
+import { normalizePeerName } from "@sema-agent/core";
 export const SESSION_TITLE_MAX_CHARS = 120;
 const SESSION_ROW_PATCH_KEYS = { title: true, pinned: true };
 const BODY_SHAPE_MESSAGE = "the body must be a JSON object carrying at least one of `title` and `pinned`, and nothing else";
 const EMPTY_TITLE_MESSAGE = "title must not be the empty string — send `null` to clear it back to the automatic title";
+const INVISIBLE_TITLE_MESSAGE = "title must contain at least one visible character";
 const C0_CONTROL = /[\u0000-\u001f]/u;
 export function readSessionTitle(v) {
     if (v === null)
@@ -16,6 +18,8 @@ export function readSessionTitle(v) {
         return { problem: { code: "request.field_invalid", message: "title must not start or end with whitespace" } };
     if (C0_CONTROL.test(v))
         return { problem: { code: "request.field_invalid", message: "title must not contain control characters (U+0000 to U+001F)" } };
+    if (normalizePeerName(v) === "")
+        return { problem: { code: "request.field_invalid", message: INVISIBLE_TITLE_MESSAGE } };
     return { title: v };
 }
 export function readSessionPinned(v) {

package/dist/session-sync-kernel.d.ts

@@ -23,7 +23,7 @@ import type { SessionFace } from "./session-incarnation.js";
  *
  * Invariants the implementations uphold:
  *  - The staging rows live under `stagingId = ${realSessionId}#stg-${token}` (the `#` is illegal in a real uuidv7, so
- *    it can NEVER collide with a real session id) and have NO `session_meta` row → they are INVISIBLE to wake / ownerOf
+ *    it can NEVER collide with a real session id) and have NO `session_meta` row → they are INVISIBLE to wake / the head read (`headOf`)
  *    / listSessions (the existing orphan invariant) until `commit`'s transaction COMMITs the real session_meta row together
  *    with the swap (the sole commit point; a fresh push claims that row first inside the same txn, invisible to everyone else
  *    until COMMIT). A crash before commit leaves only collectable orphan staging rows, never a half-session.
@@ -59,8 +59,8 @@ export interface StagingHandle {
     abort(): Promise<void>;
 }
 /**
- * What a staged commit is conditioned on (S-1938 — one gate predicate, two phases). `expectedOwner` = the owner cell the import's gate
- * judged when it opened the staging, in the `ownerOf` reading: `undefined` = no such session (a fresh push), `null` = ownerless, a string =
+ * What a staged commit is conditioned on ([ref] — one gate predicate, two phases). `expectedOwner` = the owner cell the import's gate
+ * judged when it opened the staging, in the head-read reading (`headOf(id)?.owner`): `undefined` = no such session (a fresh push), `null` = ownerless, a string =
  * that owner. The route judges `mayTouch` on that cell at Phase A and again on the session's current cell right before Phase B commits; the
  * commit itself lands only on that same cell — each store compares it inside the commit txn (local: inside the session's write lock) and, when
  * the cell differs, rolls back and throws {@link StagedCommitOwnerChangedError} without writing a byte. The compare is on the owner cell, not
@@ -80,7 +80,7 @@ export interface StagedCommitOptions {
 export declare class StagedCommitOwnerChangedError extends SessionError {
     constructor(sessionId: string);
 }
-/** The owner-cell comparison of {@link StagedCommitOptions.expectedOwner} against a store's own `ownerOf`-shaped read (`undefined` = no row). */
+/** The owner-cell comparison of {@link StagedCommitOptions.expectedOwner} against a store's own owner read (`headOf(id)?.owner`; `undefined` = no row). */
 export declare function ownerCellIs(expectedOwner: string | null | undefined, actual: string | null | undefined): boolean;
 /** A session store that can stage a streamed import (P1d-β). The 3 backends implement it; the in-memory dev store
  *  does not → the method is optional (the route 501s when absent, parity with the other §0.5 optional seams). */

package/dist/session-sync.d.ts

@@ -45,12 +45,43 @@
  */
 import type { StoreBackend } from "./plugins/store-backend.js";
 import { type SyncRelation } from "./session-sync-kernel.js";
-import { type SessionTreeEntry, type SessionRulesRecord, type FileHistoryExport, type FileHistoryResult, type SessionPermissionRules, type StoredSessionRules, type SessionPolicyStore } from "@sema-agent/core";
+import { type SessionTreeEntry, type SessionRulesRecord, type FileHistoryError, type FileHistoryExport, type FileHistoryResult, type SessionPermissionRules, type StoredSessionRules, type SessionPolicyStore } from "@sema-agent/core";
 import type { ServiceFileHistoryStore, ServiceSessionPolicyStore, ResumeAnchorStore } from "./plugins/store-backend.js";
+/**
+ * core 7.55.0 [ref] T2([ref]):一只会话的文件历史**读不全**(撕裂 / 读不出的边界、读不出的跟踪集 —— 店的 `exportHistory` 答 `{ ok: false }`,`adopt_failed`
+ * 带店判的 `permanence`)。它**不是**「没有历史」:读成 `null` 的同步会把这只会话的全部 rewind 历史丢在路上、还答成功。会话同步的两只拉取口
+ * (manifest、history blob)对它答同一句 503 `state.file_history_unreadable`(路由 `sendPullUnreadable`;连接类故障在拉取口同码同体键答 `permanence: "transient"`)。
+ */
+export declare class FileHistoryUnreadableError extends Error {
+    readonly sessionId: string;
+    readonly failure: FileHistoryError;
+    readonly code = "state.file_history_unreadable";
+    constructor(sessionId: string, failure: FileHistoryError);
+}
+/**
+ * 一只会话的文件历史导出 —— `exportHistory` 三臂的**唯一读法**(会话同步两只拉取口都经它):`{ ok: true, history }` ⇒ 信封;`{ ok: true, history: null }`
+ * ⇒ `null`(没有可导出的,null 的唯一意思);`{ ok: false }` ⇒ 抛 {@link FileHistoryUnreadableError}(读不全不是没有)。店不带 `exportHistory` ⇒ 不是 2c 历史源 ⇒ `null`。
+ */
+export declare function exportedFileHistory(store: Pick<ServiceFileHistoryStore, "exportHistory">, sessionId: string): Promise<FileHistoryExport | null>;
 /** A blob getter: content-addressed bytes for a sha256 hash, or `undefined` if the source can't supply them.
  *  Returned by {@link exportSessionManifest} (closes over the source store); consumed wherever a caller pulls
  *  content-addressed history bytes lazily (the live PUSH route's `importHistory` replay). */
 export type BlobGetter = (hash: string) => Promise<Uint8Array | undefined>;
+/** blob 两面(`putBlob` / `getBlob`)齐备的文件历史店(marker 门,不做名字探测:local 的引擎文件店带同名私有助手)。 */
+export type SyncBlobHistoryStore = ServiceFileHistoryStore & {
+    readonly syncBlobFaces: true;
+} & {
+    [P in "putBlob" | "getBlob"]-?: NonNullable<ServiceFileHistoryStore[P]>;
+};
+/**
+ * 「这只文件历史店有没有 blob 两面」的**唯一**读法:marker `syncBlobFaces`(只有 SQL 两只店立它)∧ 两面在场。能力事实 `sessionSyncFileHistory`(capability-facts)
+ * 与取值口 {@link blobGetterOf} 都读它 —— 事实说有,取值口就通到事实店的 `getBlob`;事实说没有,取值口恒空。
+ * 名字探测(`store.getBlob?.…`)不可靠:core 的 local 文件店带与服务面同名的**私有**助手(同形 `putBlob` 已被 marker 挡过一次),名字探会错拿到它。
+ */
+export declare function syncBlobFacesOf(store: ServiceFileHistoryStore): SyncBlobHistoryStore | undefined;
+/** 一只文件历史店自己的 blob 取值口({@link BlobGetter}):从 {@link syncBlobFacesOf} 派生 —— 有 blob 两面 ⇒ 绑在店上的 `getBlob`;没有(core 的 local 文件店)⇒ 恒答 `undefined`(「这里取不到」)。
+ *  拉取面(manifest 的 `getBlob`)、identical 自愈臂、提交臂三处读同一只,不各写一份「无面则 undefined」。 */
+export declare function blobGetterOf(store: ServiceFileHistoryStore): BlobGetter;
 /** The history-import capability face of a `FileHistoryStore` (`importHistory` is OPTIONAL on the core
  *  contract — a store without it cannot be a 2c history sink). */
 export interface FileHistoryImportFace {
@@ -61,6 +92,21 @@ export interface FileHistoryImportFace {
  *  `undefined` when absent. Callers gate on the RETURN VALUE, not a separate `typeof` check, so there is
  *  exactly one place that knows the shape of the probe. */
 export declare function fileHistoryImportFace(fs: unknown): FileHistoryImportFace | undefined;
+/**
+ * {@link replayFileHistory} 的结果 = 店的 {@link FileHistoryResult};失败臂可再带 `missingBlob` —— 这一次尝试里**重放自己交给店的 getter 亲口答过 `undefined`** 的那枚 hash
+ * (「这枚 blob 不在」是 getter 观察到的事实,不是从店码里猜的:同一个 `adopt_failed` 也可能是取值抛了 / 发布步撞上库的故障,那两形 `missingBlob` 缺席)。
+ * 下发口({@link sendFileHistoryReplayFailure} 在路由里)据它铸 wire `missing_blob`,否则原样送店的码。
+ */
+export type FileHistoryReplayResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly error: FileHistoryError;
+    readonly missingBlob?: string;
+};
+export type FileHistoryReplayFailure = Extract<FileHistoryReplayResult, {
+    ok: false;
+}>;
 /**
  * The 2c PUSH replay of a session's file-history graph — keep-SOURCE convergence over core's
  * non-destructive-target law. `importHistory` refuses a target that already holds a DIFFERENT graph
@@ -75,10 +121,14 @@ export declare function fileHistoryImportFace(fs: unknown): FileHistoryImportFac
  * is left EMPTY — worse than the moment before this call, but strictly self-healing: the client re-PUTs
  * the blob and re-POSTs, and the retry lands on an empty target (importHistory's first-import arm).
  * The alternative (keeping the old graph) would wedge every retry on the same typed conflict forever.
+ *
+ * 缺 blob 的事实只在这里读一次:每次尝试给店的 getter 都包一层观察,店取到 `undefined` 就记下那枚 hash(按次计,替换臂的第二次尝试从空白起),
+ * 失败时随结果交出({@link FileHistoryReplayResult.missingBlob})。预检({@link sessionSyncFileHistory} 事实 + `hasBlobs`)管「这台部署根本收不到 / 索引里没有」,
+ * 这里管「预检过了而这一枚取不到」(对象存储里已丢 / 校验和不符按缺席读 / 预检与重放之间被孤儿回收清走)—— 同一只不变量的两端,wire 上同一个词。
  */
 export declare function replayFileHistory(store: ServiceFileHistoryStore, scope: string, envelope: FileHistoryExport, srcGetBlob: BlobGetter, opts: {
     allowReplace: boolean;
-}): Promise<FileHistoryResult>;
+}): Promise<FileHistoryReplayResult>;
 /**
  * The portable state of ONE session, ready to replay into another backend. Blobs are deliberately NOT inlined
  * (§5: a turn's working-tree blobs can be tens of MiB → OOM/413 if buffered); each snapshot carries only its
@@ -147,7 +197,7 @@ export interface SessionManifest {
  * with the history store's own export verb.)
  */
 export declare function exportSessionManifest(sessionId: string, srcBackend: StoreBackend, 
-/** S-589:文件历史读**装配结果**(捕获脸),不直取 `srcBackend.fileHistory()` —— 「这台部署有没有文件历史店」
+/** [ref]:文件历史读**装配结果**(捕获脸),不直取 `srcBackend.fileHistory()` —— 「这台部署有没有文件历史店」
  *  只在 `assembleFileHistory` 判一次。同一个后端铸的同一只店,四店同源的不变式不变。 */
 historyStore: ServiceFileHistoryStore): Promise<{
     manifest: SessionManifest;
@@ -165,14 +215,19 @@ export declare function planSync(sessionId: string, srcBackend: StoreBackend, ds
  *  无条件写都 rev+1,而 rev 是 operator 乐观锁的 CAS 令牌(`PutRulesOptions.expectedRev`),
  *  幂等重试/无害重复同步不该把在途 CAS 打失败。归一化用 core 的 `normalizeRules`(store 落盘
  *  前走同一函数 ⇒ 两侧同坐标);它略过店的戳 `rev` / `gen`(`listBySession` 的 rules 含 rev,
- *  它不是内容;core 7.51.0 #1474 起 `normalizeRules` 自己略过,修前的 `stripRev` 包裹随之退役)。
+ *  它不是内容;core 7.51.0 [ref] 起 `normalizeRules` 自己略过,修前的 `stripRev` 包裹随之退役)。
  *  两侧过的是同一只形读法(core 7.51.0 `readSessionRulesShape`):`incoming` 由写口读者(引擎的写口判官)交出,`stored` 由店的读回交出 ——
  *  店读回读不出形的行答 `corrupt`、根本到不了这里,所以 `normalizeRules` 对两侧都不抛(修前本仓的读回比引擎宽,另有一只判官先挡一次)。
  *  🔴 字节同 ≠ 意思同(core 7.51.2 行自带文法戳;codex r1 [high] 验真):`normalizeRules` 把店的戳 `rev` / `gen` / `grammar` 都略过,而同一串桶字节在两种文法里是两句话 ——
  *  目的行无戳(文法 0:`toolAllow` 里的 `Bash(rm:*)` 什么都不放行)、导入记录带 `grammar: 1`(放行 rm),只比字节会判「同内容」、零次 putRules、同步答 200 而目的行仍是旧意思。
  *  所以字节同之外还问引擎的收紧比对 `loosenReasons` **双向**(两侧各在自己的文法里读:`stored` 带 `rev`,`incoming` 带 `grammar`):两个方向都「没放宽」才是同一句话;
- *  意思不同就交给 `putRules` 的判官(非 operator ⇒ `loosen_forbidden`;operator ⇒ 改写成当前文法、盖戳)。本仓仍零处读 / 比戳值;意思由引擎说。 */
-export declare function sameRulesContent(stored: StoredSessionRules | null, incoming: SessionPermissionRules): boolean;
+ *  意思不同就交给 `putRules` 的判官(非 operator ⇒ `loosen_forbidden`;operator ⇒ 改写成当前文法、盖戳)。本仓仍零处读 / 比戳值;意思由引擎说。
+ *  🔴 core 7.55.0 [ref]:行还有一格 **operator 部分**(`StoredSessionRules.operatorRules`:非 operator 的写只能收回非 operator 写加上去的东西;缺席 = 整行归 operator)。
+ *  桶同、意思同,这一次写仍可能挪动它 —— operator 重放把整行变成 operator 的(引擎写口判官的答:operator 写的值整只归 operator)。只比桶会判「同内容」⇒ 零次 putRules ⇒
+ *  属主盖过戳的目的行保持「属主收得回」,源端 operator 断言过的条目在目的端被属主一条非 operator 的写收回(安全轴的静默放宽)。所以第三问:这一次写之后的部分
+ *  = 引擎写口判官对(目的行, 记录, 这次重放的态度)的答,与目的行现有的部分按同一读法(缺席 = 整行)比;不同就交给 `putRules`。判官拒 ⇒ 原样上抛(`putRules` 会拒同一句)。
+ *  `operator` 必填:同一份记录在 operator 与非 operator 的重放下是两种写(漏传是编译错,不是一条静默的读法)。 */
+export declare function sameRulesContent(stored: StoredSessionRules | null, incoming: SessionPermissionRules, operator: boolean): boolean;
 /** [ref] ① 的重放腿共享实现:PUSH 路由的两条 policy 重放腿(Phase A identical 短路支 / Phase B
  *  commit 后支)都从这里走 —— 等内容跳过(rev 零漂移),真变更照常落地(E6 tighten-only 门在
  *  putRules 内部,此处不重述)。 */