@sema-agent/server 7.134.0 → 7.135.0

package/dist/security.js

@@ -1,4 +1,6 @@
 import { uuidv7, PROJECT_ID_REGEX } from "@sema-agent/core";
+import { DEPLOYMENT_SHAPE_PREDICATES } from "./deployment-shape.js";
+import { headReadOf } from "./session-incarnation.js";
 import { memoryScopeFor } from "./memory-scope.js";
 import { verifyPrincipalJwt } from "./principal-jwt.js";
 import { fieldConflictFacts } from "./field-conflict.js";
@@ -30,11 +32,11 @@ export async function sessionOwnerCellOf(store, sessionId, owner) {
     return { owner: null, placed: placementOf !== undefined && (await placementOf.call(store, sessionId)) !== undefined };
 }
 export const LEGACY_UNOWNED_AMNESTY_TENANT = "default";
-export function legacyUnownedSessionOk(requirePrincipal, caller, cell) {
-    return legacyUnownedAmnestyOpen(requirePrincipal, caller.principal ?? null) && ownerlessRowOpen(cell, caller);
+export function legacyUnownedSessionOk(deployment, caller, cell) {
+    return legacyUnownedAmnestyOpen(deployment, caller.principal ?? null) && ownerlessRowOpen(cell, caller);
 }
-export function legacyUnownedAmnestyOpen(requirePrincipal, gateOwner) {
-    return !requirePrincipal && gateOwner === LEGACY_UNOWNED_AMNESTY_TENANT;
+export function legacyUnownedAmnestyOpen(deployment, gateOwner) {
+    return !DEPLOYMENT_SHAPE_PREDICATES.multiTenant.holds(deployment) && gateOwner === LEGACY_UNOWNED_AMNESTY_TENANT;
 }
 const UUIDV7_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 export function isUuidV7(s) {
@@ -80,20 +82,21 @@ export function createAuthorizer(config, sessionStore) {
             projectId = body.projectId.toLowerCase();
         }
         const requireExisting = body.requireExistingSession === true;
-        const ownerOf = sessionStore.ownerOf?.bind(sessionStore);
+        const headOf = headReadOf(sessionStore);
+        const readOwner = headOf === undefined ? undefined : async (id) => (await headOf(id))?.owner;
         const register = sessionStore.register?.bind(sessionStore);
         const requested = typeof body.sessionId === "string" && body.sessionId ? body.sessionId : undefined;
         let sessionId;
         if (requested) {
-            if (ownerOf) {
-                let owner = await ownerOf(requested);
+            if (readOwner) {
+                let owner = await readOwner(requested);
                 if (owner === undefined) {
                     if (requireExisting) {
                         throw createCodedHttpError(404, "resume.session_not_found", "requireExistingSession: session does not exist (resume.session_not_found)");
                     }
                     if (register) {
                         await register(requested, principal ?? null);
-                        owner = await ownerOf(requested);
+                        owner = await readOwner(requested);
                     }
                     else if (config.requirePrincipal) {
                         throw new HttpError(403, "cannot claim a caller-supplied sessionId on a multi-tenant deployment: this worker's session store cannot record session ownership, so the id would stay unowned and the next caller could attach to it. Configure a durable session backend (SESSION_BACKEND), or omit sessionId to start a new session.");
@@ -101,7 +104,7 @@ export function createAuthorizer(config, sessionStore) {
                 }
                 else if (owner === null && principal !== undefined && !config.requirePrincipal && register) {
                     await register(requested, principal);
-                    owner = await ownerOf(requested);
+                    owner = await readOwner(requested);
                 }
                 const legacyShellOwner = !config.requirePrincipal && owner === "anon:shell-live" && principal === undefined;
                 if (!legacyShellOwner && owner != null && owner !== principal) {

package/dist/server-secret-env.d.ts

@@ -1,14 +1,14 @@
 /**
- * 宿主子进程 env 的**唯一组合点**(7.103.0 起,S-684 残余按类收口)+ 本进程**自有凭据名的唯一声明点**(7.129.0 起,core 7.51.1)。
+ * 宿主子进程 env 的**唯一组合点**(7.103.0 起,[ref] 残余按类收口)+ 本进程**自有凭据名的唯一声明点**(7.129.0 起,core 7.51.1)。
  *
  * ## 病(沿革)
- * 7.99.0 合并复审 F7(web-admin [ref] 实测;安全轴;DEBTS S-684):core 的形状剥(`*_KEY` / `*_TOKEN` …)认不出本仓自己的凭据键
+ * 7.99.0 合并复审 F7(web-admin [ref] 实测;安全轴;DEBTS [ref]):core 的形状剥(`*_KEY` / `*_TOKEN` …)认不出本仓自己的凭据键
  * (`SERVICE_AUTH_TOKENS` / `APPROVAL_HMAC_KEYS` / `OTEL_EXPORTER_OTLP_HEADERS`)⇒ 本仓在 `scrub` 腿上另加目录臂按名剥。7.129.0(web-client
  * 实测):目录臂只在 `scrub` 腿施,`inheritEnv:"all"` 是 `{ ...process.env }` 零剥除、`[names]` 点到目录 secret 名照放 —— 单用户 host 上 cli 交互 lane
  * 每次提交发 `"all"`,引擎自己的 `SERVICE_AUTH_TOKEN(S)` / `APPROVAL_HMAC_KEYS` / `MODEL_API_KEY` 逐字进模型 shell,模型一条 `curl` 可自批自己的 HITL 卡。
  * 病根是本仓自判三个继承词、而只在其中一个词上减自有凭据。
  *
- * ## 律(一句;core #1753 定,本仓只传事实、不判)
+ * ## 律(一句;core [ref] 定,本仓只传事实、不判)
  * 本包任何进程在宿主上 spawn 的子进程:env = 引擎 `inheritedHostEnv(policy, findings)` ∪ 部署方点名放回的键(只在运维真可能要传东西的腿上有旋钮),
  * 剥掉的键经一个登记过的 `SecretEnvScrubSite` 留痕(现场按**腿**命名);git 腿再叠 git 自己的两件({@link gitSubprocessEnv})。射程 = **每一条**宿主腿:
  * src 里每一只值引 `node:child_process` 的文件都是登记腿、其中每一次起子进程都显式交组合出的 env(普查门在 `test/secret-env-scrub-host-legs.test.ts`)。
@@ -28,13 +28,13 @@
  *    抛同路)。能力词 `inherit_env.own_credentials_withheld` 在本进程的事实 =
  *    {@link ownCredentialsWithheld}:最近一次成功声明的集合 ⊇ 当前生效配置应声明的集合(活配置经 {@link bindOwnCredentialsConfig} 在 `loadConfig()` 之后绑一次;
  *    未绑 / 未声明 ⇒ false,事实读不到应声明集合就不答 true)。
- *  · **值臂**(core 7.52.0 #1754):声明是一张表 `{ names, values }`。`values` = 本进程持有凭据的变量此刻的值(目录 secret 名 ∪ 模型条目 `apiKeyEnv`,{@link serverCredentialValueSources}),
+ *  · **值臂**(core 7.52.0 [ref]):声明是一张表 `{ names, values }`。`values` = 本进程持有凭据的变量此刻的值(目录 secret 名 ∪ 模型条目 `apiKeyEnv`,{@link serverCredentialValueSources}),
  *    逐个交给引擎的同一只判;引擎判「不是凭据值」的那一个不扣、名照扣、不拒启、点名一次。能力词 `inherit_env.own_credential_values_withheld` 的事实 = {@link ownCredentialValuesWithheld}(位真 ⇔ 值臂真扣)。
  *  · 调用方显式传入的 env(`cfg.env` / 单次命令的 `env` / 沙箱的点名放回)不是继承,照旧原样叠在组合结果之上 —— 那是适配器自己的凭据通道。
  * 各腿只调 {@link hostSubprocessEnv} / {@link gitSubprocessEnv} —— 不许再有内联拼装、不许再有 `{ ...process.env }`、不许本仓再判任何一个继承词、不许起子进程不交 env
  * (类级门与普查门在 `test/secret-env-scrub-host-legs.test.ts`)。
  *
- * ## 点名放行(S-699 / S-713,一只谓词各处用)
+ * ## 点名放行([ref] / [ref],一只谓词各处用)
  * {@link allowlistedEnv} 是本仓「一张名单点到哪些 env 键,就把它们从源 env **原样**交给沙箱」的唯一实现。调用:沙箱带外 env 的 `E2B_SANDBOX_ENV` / `DOCKER_SANDBOX_ENV` /
  * `K8S_SANDBOX_ENV`(`config.ts`)与名单解析器的「在不在」判。宿主子进程的剥后放回(`LSP_ENV_ALLOW` / `BAKE_ENV_ALLOW`)不经它 —— 那是引擎的严格名单臂(上一段)。
  * host shell 的 `inheritEnv:[names]`(hermetic 形)7.129.0 起由引擎读(与 core `NodeExecutionEnv` 同名选项同义,点到自有凭据名即拒),不经本谓词。
@@ -57,7 +57,7 @@ export type ModelApiKeyEnvTable = Readonly<Record<string, string>>;
  */
 export declare function serverWithheldEnvNames(modelApiKeyEnv?: ModelApiKeyEnvTable): readonly string[];
 /**
- * 本进程**持有凭据值**的变量名(值臂的来源;core 7.52.0 #1754):目录 secret 名 ∪ 模型条目 `apiKeyEnv` 的值 —— 名单与值臂两臂同一张表派生,只少名单型旋钮名(它们的值是
+ * 本进程**持有凭据值**的变量名(值臂的来源;core 7.52.0 [ref]):目录 secret 名 ∪ 模型条目 `apiKeyEnv` 的值 —— 名单与值臂两臂同一张表派生,只少名单型旋钮名(它们的值是
  * 一张变量名单,不是凭据)。纯函数,排序只为读数稳定。
  */
 export declare function serverCredentialValueSources(modelApiKeyEnv?: ModelApiKeyEnvTable): readonly string[];
@@ -111,7 +111,7 @@ export interface HostSubprocessEnvRequest {
  * 调用时机 = 每次要交 env 时现算一次(`process.env` 在本仓是 boot 期输入,各次同值;计数因此是「每组合一次」)。
  * 引擎对坏策略 / 点到自有凭据名的白名单在这里**抛**(spawn 时的拒是不变量;构造时的拒由各构造点自己先问 `inheritEnvPolicyProblem`)。
  *
- * 🔴 **git 的 env 配置族与代理变量一族只有 core 一只写手**:core 7.35.0 #1201(S-877)起它们是 core 的**豁免族** —— `GIT_CONFIG_COUNT` / `GIT_CONFIG_PARAMETERS` /
+ * 🔴 **git 的 env 配置族与代理变量一族只有 core 一只写手**:core 7.35.0 [ref]([ref])起它们是 core 的**豁免族** —— `GIT_CONFIG_COUNT` / `GIT_CONFIG_PARAMETERS` /
  * `GIT_CONFIG_KEY_<数字>` / `GIT_CONFIG_VALUE_<数字>`(大写)与 `http(s)_proxy` / `all_proxy` / `no_proxy` / `npm_config_*proxy` …(任意大小写),名与值都不读、
  * **原样交出,凭据在内**(部署面:凭据不放本进程 env —— `docs/DEPLOY-PREREQS.md`)。本仓不重判;本进程自有凭据名单不含这两族的名字
  * (钉:`test/secret-env-git-config-pair.test.ts`「一只写手」格)。
@@ -120,7 +120,7 @@ export interface HostSubprocessEnvRequest {
 export declare function hostSubprocessEnv(o: HostSubprocessEnvRequest): NodeJS.ProcessEnv;
 /**
  * {@link hostSubprocessEnv} 的**组合本体**(不披露、不计数)—— 同一只组合,两个入口:真要交给子进程的现场经 `hostSubprocessEnv`(组合 + 披露);
- * 只想知道「子进程**会**拿到什么」的读者(core 7.49.0 #1554:host 车道的 `ExecutionEnv.cdPath` 要报子进程真拿到的 `CDPATH`)读这一只 ——
+ * 只想知道「子进程**会**拿到什么」的读者(core 7.49.0 [ref]:host 车道的 `ExecutionEnv.cdPath` 要报子进程真拿到的 `CDPATH`)读这一只 ——
  * 既不另写一份组合(第二份会漂),也不把一次没发生的 spawn 记进剥除计数。`findings` 是组合点自己的收集器(引擎把形状臂与自有凭据臂的每一条扣下都推进去)。
  */
 export declare function composeHostSubprocessEnv(o: Omit<HostSubprocessEnvRequest, "site">, findings?: SecretEnvFinding[]): NodeJS.ProcessEnv;
@@ -143,10 +143,10 @@ export declare function gitSubprocessEnv(o: {
     isolateConfig: boolean;
 }): NodeJS.ProcessEnv;
 /**
- * S-699 —— **点名放行**的唯一谓词:从 `env` 里把 `names` 点到的键**原样**取出(值逐字,空串照带;源里没有的名不产生
+ * [ref] —— **点名放行**的唯一谓词:从 `env` 里把 `names` 点到的键**原样**取出(值逐字,空串照带;源里没有的名不产生
  * 条目)。密钥形的键点到了也照取 —— 点名即部署方显式承担;要不要在这之上再叠别的基底,是调用方的事(见文件头「点名放行」节)。
  * 纯函数,不留痕:点名放回的键不是剥除,不进 `secret_env_scrubbed` 的键表与计数。
- * 返回形 `Record<string, string>`(S-713):只装源里在的键,值恒是字符串 —— 沙箱两腿(`sandboxEnv` / docker `env`)要的正是这个形,
+ * 返回形 `Record<string, string>`([ref]):只装源里在的键,值恒是字符串 —— 沙箱两腿(`sandboxEnv` / docker `env`)要的正是这个形,
  * 不必在调用点再过滤一遍 `undefined`。
  */
 export declare function allowlistedEnv(names: readonly string[], env: NodeJS.ProcessEnv): Record<string, string>;

package/dist/session-children-retire.d.ts

@@ -1,5 +1,5 @@
 /**
- * S-790 件B([ref] §3)—— **删会话带走以它为根的后台子代**:一只会话被删,以它为根的子代跟着结束 —— parked 的作废
+ * [ref] 件B([ref] §3)—— **删会话带走以它为根的后台子代**:一只会话被删,以它为根的子代跟着结束 —— parked 的作废
  * (行转终态,审批卡随之离开待决面),在跑的停掉。**这件事做完,才删会话元数据**(调用方:`boot/session-faces.ts` 的删除协调器)。
  *
  * ## 两步、两种失败,类型上分开(合并复审 gpt-6 腿 [high] 之后的形,裁定 2026-09-28)

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

@@ -1,19 +1,19 @@
 /**
- * 🔴 **core `SessionError` 闭集 → HTTP 的唯一映射**(S-612,server 7.104.0;设计稿 [ref] §2.1)。
+ * 🔴 **core `SessionError` 闭集 → HTTP 的唯一映射**([ref],server 7.104.0;设计稿 [ref] §2.1)。
  *
  * ## 为什么要一只属主
  * 修前 wire 上只有**一处**认得 `SessionError` 的码:`http/routes/session-sync.ts` 的暂存导入腿把 `invalid_session`
- * 手写成 422。其余每一条路都把它交给全局兜底 ⇒ `500 internal.error "internal error"`,码丢。core 7.30.0(#1041)
+ * 手写成 422。其余每一条路都把它交给全局兜底 ⇒ `500 internal.error "internal error"`,码丢。core 7.30.0([ref])
  * 给文件会话店铸了 `corrupt_session`(存档没有会话头 ⇒ 这只会话唤不醒),而它在 wire 上一个名字都没有
- * (真跑读数见 S-612 收车档 §0:冷启动时三条提交口与每一条经归属探针 / 读存档碰到它的口都答 500 `internal.error`;
+ * (真跑读数见 [ref] 收车档 §0:冷启动时三条提交口与每一条经归属探针 / 读存档碰到它的口都答 500 `internal.error`;
  * owner 已知时同步口是 200 + failed 体、并照常走计费收尾)。
  *
  * ## 为什么多一个 `face` 参数(而不是单参)
  * core 的 `invalid_session` 是**同词两义**(亲读 dist:`engine/session/import-validate.js` 的导入门拒调用方交来的
- * 日志,`engine/session/storage-base.js` 的建树 / 走根拒**已存**日志里指向缺席条目的叶子或祖先 —— 后者即 core #1077)。
+ * 日志,`engine/session/storage-base.js` 的建树 / 走根拒**已存**日志里指向缺席条目的叶子或祖先 —— 后者即 core [ref])。
  * 本仓对它的成文义是前者(调用方的日志没过校验 ⇒ 422),而后者今天在打开会话的各口上答的是通用 500 / 同步口
- * 200 + failed(S-612 的 3b 负控格钉住这一形,#1077 落地后按 core 的新码再对一次)。单参签名装不下这件事:要么
- * 打开面的每个消费点都写一句 `code === "corrupt_session"` 特判,要么把 #1077 形从今天的应答改成「你交的日志坏了」。
+ * 200 + failed([ref] 的 3b 负控格钉住这一形,[ref] 落地后按 core 的新码再对一次)。单参签名装不下这件事:要么
+ * 打开面的每个消费点都写一句 `code === "corrupt_session"` 特判,要么把 [ref] 形从今天的应答改成「你交的日志坏了」。
  * ⇒ 面是映射的一维,写进属主,不散在消费点。
  *  · `"open"`   —— 为某只会话**打开它已存的日志**(提交各腿的引擎 prepare、鉴权门的归属探针、直接读会话的口);
  *  · `"import"` —— 校验 / 写入**调用方交来的**日志(2c session-sync 的暂存导入)。
@@ -24,7 +24,7 @@
  *    原样上 wire,契约既有立场:不为上游码铸孪生码)。三种会话后端同词:文件店由 core 铸,两只 SQL 店由
  *    `plugins/session-event-payload.ts` 铸(坏的 `session_event.payload` 行)。
  *  · `invalid_session` —— `import` 面 **422 `invalid_entries`**(修前 session-sync 的那一行,码位 / 状态逐字不变);
- *    `open` 面留白(#1077 形,见上)。
+ *    `open` 面留白([ref] 形,见上)。
  *  · `not_found` —— 留白:每一面各有自己的「不存在」答法(404 `not_found.session` / 同步口的 `resume.session_not_found` /
  *    列表里的缺席),码位各不相同,不由本表统一。
  *  · `placement_refused` —— `import` 面 **409 `conflict.session_placed`**(机读位 `detail.placement_kind`,固定句);`open` 面留白。

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`。
+ *    一次性迁移(`plugins/one-time-migrations.ts` 登记表 M5)之后,空值只可能来自没铸化身的写腿或人为改库 —— 把它当「通配」就是让任何人
+ *    都能和这一行比成同一位住客。
  *  · **不上 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,43 @@ 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 function incarnationReadOf(store: Pick<SessionStore, "incarnationOf"> | undefined): IncarnationRead | undefined;
+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 SessionFace}):`undefined` 头 = 没有这只会话 ⇒ `undefined`;行在而没有令牌 ⇒ {@link SessionIncarnationMissingError}
+ *  (本仓的那条律只住在这里 + {@link sessionFaceFromRow})。 */
+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` 读法)⇒ 沿用;
@@ -100,7 +117,7 @@ export declare function carriedIncarnation(sessionId: string, prior: {
 /**
  * `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 起服列册探针比的是列名,形由这里保证)。
+ * 于是「新库建出来的列」与「存量库补上的列」逐字同形([ref] 起服列册探针比的是列名,形由这里保证)。
  *
  * `NOT NULL DEFAULT ''`:空串就是「没铸过」的唯一表示 —— 读口对它响亮拒({@link SessionIncarnationMissingError})。
  * 缺省值只为两件事存在:①存量表 `ADD COLUMN` 在两方言上一句成立(PG 对非空表加无缺省的 NOT NULL 列直接拒);

package/dist/session-incarnation.js

@@ -9,9 +9,6 @@ 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";
@@ -41,12 +38,30 @@ 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 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-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). */