@sema-agent/server 7.147.0 → 7.148.0

package/dist/session-erase.d.ts

@@ -0,0 +1,145 @@
+/**
+ * **删净一只会话 —— 一只执行体**(两个决定者共用:`DELETE /v1/sessions/:id` 的删除协调器 `boot/session-faces.ts`,与托管留存的会话树清扫)。
+ *
+ * ## 律
+ * 删净一只会话 = **在这只会话的行锁下**删完它挂靠的全部行,行本身最后删:
+ *  · SQL 后端:一个事务(执行器 `stores-sql/retention-store-sql.ts` 的 `eraseSession` / `deleteExpiredSessions`,两只入口跑同一段事务体
+ *    —— 锁行 → 会话座事务内钩判 → 部署行 → 引擎座行 → 行与日志 → 墓碑);
+ *  · local 后端:{@link createLocalSessionEraser} —— 会话店这只会话的写锁一节(判 → 各店动词按 {@link SESSION_TREE_LEGS} → 删行)。
+ * 锁里那一判按决定者:在线删除 = 行的属主是围栏判过的那一位 ∧ `erase`(这一行处于**这一次删除的在删态** —— 令牌比对;会话三态 活 → 在删 → 没了,
+ * 律在 `session-deletion.ts`,围栏是删除协调器的事);留存 = `retention-delete`(没有认领、不在删)。令牌只在围栏判过属主之后写下,同 id 的下一位住客是新行、不带它 ⇒
+ * 一次陈旧 / 被接管的删除在锁里读到的不是自己的令牌,一行不删(`superseded`)。属主那一比是域键的一致性(SQL 的部署行与墓碑按域写,域在事务开之前就要定)。
+ * 会话挂靠的**行**都在锁里(含完成信箱的清除围栏与会话盒):删不掉 ⇒ 行留在删、删除可重试;锁着 ⇒ 碰不到下一位住客。提交之后由**同一只**收尾
+ * {@link createSessionEraseSettler} 处理按内容 / 按住客化身寻址的残余(附件字节、住客空间);SQL 组合座另在提交之后按「入队不晚于提交」清一次
+ * 事务进行中落下的迟到完成行(`retention-deployment.ts` 的 `sweepLateCompletionRows`)。
+ * 不在锁里的:在线删除在围栏之后、执行体之前对这只在删会话做的进程面动作(信箱 retire 围栏、子代结束、scratchpad、后台 shell、删过的 id)——
+ * 删除协调器每一步之前核令牌(`boot/session-faces.ts`);一步已经开跑时被接管的那一拍是协调器注里披露的残余(不是行)。
+ *
+ * ## 决定者之差
+ * 在线删除删的是一只**可能还活着**的会话(删前:子代预检 → 围栏 → 信箱 retire 围栏、子代结束、本进程删过的 id;删后:本副本的进程态);留存只删闲到视界外、
+ * 无活引用、不在删的会话(hold / 候选 / 活引用 / 审计)。行面唯一的差:规则行的 rev 高水位记号(在线留、留存删;`retention-store-sql.ts` 的 `RuleMarks`)。
+ */
+import { type MailboxStore, type ToolResultStore } from "@sema-agent/core";
+import type { Logger } from "./observability/logger.js";
+import type { WorkflowCompletionInbox } from "./orchestration/workflow-completion-inbox.js";
+import type { SpaceReclaimer } from "./workspace-space.js";
+/** 锁里读到的这一位住客(会话行上的属主 + 化身;存量行没有化身 ⇒ `undefined`)。 */
+export interface SessionOccupant {
+    readonly owner: string | null;
+    readonly incarnation: string | undefined;
+}
+/** 一次执行体提交之后交收尾的东西:真删掉的会话(id + 删前属主 + 住客)、本次删掉的附件行的字节哈希、全库无出处卸载结果数。 */
+export interface SessionTreesErased {
+    readonly sessions: readonly {
+        readonly sessionId: string;
+        readonly owner: string | null;
+        readonly incarnation: string | undefined;
+    }[];
+    /** 本次删掉的附件行的字节哈希(收尾按「无行引用才删」释放;local 的附件店随行删字节,恒空)。 */
+    readonly attachmentShas: readonly string[];
+    /** 全库无出处的卸载结果行数(core 口径:这类行任何会话删除都删不到 ⇒ 删除不完整;实体清理归 TTL)。 */
+    readonly unattributableToolResults: number;
+}
+/** 执行体的回执(闭集)。 */
+export type SessionEraseReceipt = 
+/** 这一行此刻不是这一次删除的在删态 —— 另一次删除接管了它(换了令牌)或已经删完(行不在 / 同 id 的新住客)。一行没删。 */
+{
+    readonly outcome: "superseded";
+}
+/** 全部行已删、已提交。 */
+ | {
+    readonly outcome: "erased";
+    readonly trees: SessionTreesErased;
+};
+/** 执行体的入参:哪只会话 + 删除协调器的围栏判过的那一位属主(域键)+ 围栏写下的令牌(判官比的那一只)。 */
+export interface SessionEraseInput {
+    readonly sessionId: string;
+    readonly owner: string | null;
+    readonly token: string;
+}
+/** 删净一只在删会话的执行体(SQL:执行器的组合座交出;local:{@link createLocalSessionEraser})。 */
+export interface SessionEraser {
+    erase(input: SessionEraseInput): Promise<SessionEraseReceipt>;
+}
+/**
+ * 会话树的行腿 —— **闭集,序即执行序**(SQL 事务体的语句序对它:`test/session-erase-single-executor.test.ts` 录制钉按首次出现序比)。
+ * `checkpoint` 腿含停驻 ctx 旁表(SQL 上 ctx 在部署段、检查点行在引擎座段,首次出现序落在这里)。`mailbox` 是行删除之前的**最后一腿**:会话盒的 `drop`
+ * 同时撤掉投递围栏(墓碑随箱亡),之后除了会话行不许再有别的腿(local 上各店逐个落盘,围栏撤了而行还在的那一段窗只容会话行那一步)。
+ */
+export declare const SESSION_TREE_LEGS: readonly ["runs", "approval", "checkpoint", "anchors", "exemption", "attachment", "user_input", "task_list", "workflow_inbox", "tool_result", "policy", "file_history", "mailbox"];
+export type SessionTreeLeg = (typeof SESSION_TREE_LEGS)[number];
+/** local 执行体的各店(缺席 = 本部署没有这只店 ⇒ 这一腿无行可删)。动词与在线协调器此前逐店调的同一组。 */
+export interface LocalSessionTreeStores {
+    readonly runStore: {
+        deleteBySession(sessionId: string): Promise<{
+            removed: number;
+        }>;
+    } | undefined;
+    readonly approvalAskStore: {
+        deleteBySession(sessionId: string): Promise<void>;
+    } | undefined;
+    readonly checkpointStore: {
+        deleteBySession(sessionId: string, owner: string | null): Promise<number>;
+    } | undefined;
+    readonly resumeAnchorStore: {
+        deleteBySession(sessionId: string): Promise<unknown>;
+    } | undefined;
+    readonly approvalExemptionStore: {
+        deleteBySession(sessionId: string): Promise<unknown>;
+    } | undefined;
+    readonly taskAttachmentStore: {
+        deleteBySession(sessionId: string): Promise<number>;
+    } | undefined;
+    readonly userInputLedgerStore: {
+        deleteBySession(sessionId: string): Promise<unknown>;
+    } | undefined;
+    readonly taskListLane: {
+        deleteBySession(sessionId: string): Promise<void>;
+    } | undefined;
+    readonly workflowCompletionInbox: Pick<WorkflowCompletionInbox, "purge"> | undefined;
+    readonly mailboxStore: Pick<MailboxStore, "drop"> | undefined;
+    readonly toolResultStore: Pick<ToolResultStore, "deleteBySession"> | undefined;
+    readonly sessionPolicyStore: {
+        deleteBySession?(sessionId: string): Promise<void>;
+    } | undefined;
+    readonly fileHistoryErasure: {
+        deleteBySession?(scope: string): Promise<unknown>;
+        reap(scope: string, keep: readonly string[]): Promise<unknown>;
+    } | undefined;
+}
+/**
+ * local 会话店的删除锁节(`plugins/local-session-store.ts` 的 `deleteSession`):这只会话的写锁里 —— 行不在 / 属主不是 `owner` ⇒ `undefined`;
+ * `erase` 判(这一行处于 `token` 那一次删除的在删态;不是 ⇒ 抛 `SessionDeletionSupersededError`)—— 两支都一行不删;→ `legs(锁里读到的住客)` → 删行,交回那一位住客。
+ */
+export type LocalSessionDeletionSection = (sessionId: string, owner: string | null, token: string, legs: (occupant: SessionOccupant) => Promise<void>) => Promise<SessionOccupant | undefined>;
+/**
+ * local 后端的执行体:会话店写锁一节里按 {@link SESSION_TREE_LEGS} 跑各店动词(闭集 `switch`,漏一腿 = 编译红)。一腿抛 ⇒ 锁节抛、行不删(重发收敛)。
+ */
+export declare function createLocalSessionEraser(deleteSession: LocalSessionDeletionSection, stores: LocalSessionTreeStores, logger: Pick<Logger, "warn">): SessionEraser;
+/** 收尾要的座(缺席 = 本部署没有这一样残余)。 */
+export interface SessionEraseSettleSeats {
+    /** 附件字节的释放口(SQL 附件店:无行引用才删对象)。 */
+    readonly attachments: {
+        releaseBytes(shas: readonly string[]): Promise<{
+            readonly failed: readonly string[];
+        }>;
+    } | undefined;
+    readonly spaceReclaimer: SpaceReclaimer | undefined;
+    readonly logger: Pick<Logger, "warn">;
+}
+/**
+ * 收尾:一次执行体提交之后对真删掉的会话处理库外残余。答出时附件字节那一步已做完;`spaces` = 住客空间回收那一步
+ * (对象存储上的一串请求,座按契约不抛、抛了已被这里响亮接住 ⇒ 它永不拒):在线删除不等它(应答不等对象存储),留存清扫等它(一轮在截止上收手)。
+ */
+export type SessionEraseSettler = (trees: SessionTreesErased) => Promise<{
+    readonly spaces: Promise<void>;
+}>;
+/**
+ * 两个决定者共用的**收尾**(行已删、已提交)。只收**按内容寻址 / 按住客化身寻址**的残余 —— 碰不到同 id 重登记的下一位住客;
+ * 会话挂靠的行(含完成信箱围栏与行、会话盒)都在执行体的锁里(删不掉 ⇒ 行留着、删除可重试)。每一步失败只记一行 warn,各有兜底:
+ *  ① 附件字节 —— 本次删掉的附件行的哈希,无行引用才删对象(孤儿 GC 兜底);
+ *  ② 住客空间 —— 住客化身在的会话交回收座(答案里的 `spaces`:等不等它是决定者的事;座按契约不抛,抛了这里响亮接住;桶的生命周期规则兜底);
+ *  ③ 全库无出处卸载结果数 > 0 ⇒ 一行 warn(删除不完整的如实告知)。
+ */
+export declare function createSessionEraseSettler(seats: SessionEraseSettleSeats): SessionEraseSettler;
+//# sourceMappingURL=session-erase.d.ts.map

package/dist/session-erase.js

@@ -0,0 +1,115 @@
+import { peerSessionBoxHandle } from "@sema-agent/core";
+import { recordFailOpen } from "./observability/fail-open.js";
+import { redactIncarnations } from "./session-incarnation.js";
+import { seatText } from "./trace/exit-seat.js";
+import { sessionTenantScope } from "./session-children-retire.js";
+import { SessionDeletionSupersededError } from "./execution-placement.js";
+export const SESSION_TREE_LEGS = ["runs", "approval", "checkpoint", "anchors", "exemption", "attachment", "user_input", "task_list", "workflow_inbox", "tool_result", "policy", "file_history", "mailbox"];
+export function createLocalSessionEraser(deleteSession, stores, logger) {
+    return {
+        async erase({ sessionId, owner, token }) {
+            let unattributable = 0;
+            const leg = async (which, occupant) => {
+                switch (which) {
+                    case "runs":
+                        return void (await stores.runStore?.deleteBySession(sessionId));
+                    case "approval":
+                        return void (await stores.approvalAskStore?.deleteBySession(sessionId));
+                    case "checkpoint":
+                        return void (await stores.checkpointStore?.deleteBySession(sessionId, occupant.owner));
+                    case "anchors":
+                        return void (await stores.resumeAnchorStore?.deleteBySession(sessionId));
+                    case "exemption":
+                        return void (await stores.approvalExemptionStore?.deleteBySession(sessionId));
+                    case "attachment":
+                        return void (await stores.taskAttachmentStore?.deleteBySession(sessionId));
+                    case "user_input":
+                        return void (await stores.userInputLedgerStore?.deleteBySession(sessionId));
+                    case "task_list":
+                        return void (await stores.taskListLane?.deleteBySession(sessionId));
+                    case "workflow_inbox":
+                        return void (await stores.workflowCompletionInbox?.purge(sessionId, occupant.owner));
+                    case "tool_result": {
+                        const report = await stores.toolResultStore?.deleteBySession?.(sessionId);
+                        if (report !== undefined)
+                            unattributable = report.unattributable;
+                        return;
+                    }
+                    case "policy":
+                        return void (await stores.sessionPolicyStore?.deleteBySession?.(sessionId));
+                    case "file_history": {
+                        const erasure = stores.fileHistoryErasure;
+                        if (erasure === undefined)
+                            return;
+                        if (typeof erasure.deleteBySession === "function")
+                            return void (await erasure.deleteBySession(sessionId));
+                        await erasure.reap(sessionId, []);
+                        logger.warn("session_file_history_baselines_retained", {
+                            sessionId,
+                            note: "this file-history store has no whole-scope erase verb (deleteBySession); boundaries were reaped but v1 baselines (original file bytes) remain in the store until it implements that verb — an open deletion-rights gap, not silent",
+                        });
+                        return;
+                    }
+                    case "mailbox":
+                        return void (await stores.mailboxStore?.drop(sessionTenantScope(occupant.owner), peerSessionBoxHandle(sessionId)));
+                    default: {
+                        const unknownLeg = which;
+                        throw new Error(`session erase: no arm for leg ${JSON.stringify(unknownLeg)}`);
+                    }
+                }
+            };
+            let erased;
+            try {
+                erased = await deleteSession(sessionId, owner, token, async (occupant) => {
+                    for (const which of SESSION_TREE_LEGS)
+                        await leg(which, occupant);
+                });
+            }
+            catch (err) {
+                if (err instanceof SessionDeletionSupersededError)
+                    return { outcome: "superseded" };
+                throw err;
+            }
+            if (erased === undefined)
+                return { outcome: "superseded" };
+            return { outcome: "erased", trees: { sessions: [{ sessionId, ...erased }], attachmentShas: [], unattributableToolResults: unattributable } };
+        },
+    };
+}
+export function createSessionEraseSettler(seats) {
+    const { logger } = seats;
+    return async (trees) => {
+        if (trees.attachmentShas.length > 0 && seats.attachments !== undefined) {
+            const released = await seats.attachments.releaseBytes(trees.attachmentShas).catch((err) => ({ failed: trees.attachmentShas, err: seatText("operator-log-text", String(err)) }));
+            if (released.failed.length > 0) {
+                logger.warn("session_erase_attachment_bytes_release_failed", {
+                    shas: trees.attachmentShas.length,
+                    failed: released.failed.length,
+                    ...("err" in released ? { err: released.err } : {}),
+                    effect: "these objects stay until the orphan-object sweep collects them (its grace applies)",
+                });
+            }
+        }
+        const spaces = trees.sessions.flatMap((s) => (s.incarnation === undefined ? [] : [{ sessionId: s.sessionId, spaceKey: s.incarnation }]));
+        let reclaimed = Promise.resolve();
+        if (spaces.length > 0 && seats.spaceReclaimer !== undefined) {
+            reclaimed = seats.spaceReclaimer.reclaim(spaces).catch((err) => {
+                recordFailOpen("server.workspace-space.reclaim-failed", "stage=seat_threw");
+                logger.warn("workspace_space_reclaim_failed", {
+                    sessions: spaces.length,
+                    stage: "seat_threw",
+                    error: seatText("operator-log-text", redactIncarnations(String(err))),
+                    effect: "the ended space's cache volume and snapshot objects may stay (the reclaim seat threw, which its contract forbids; the session delete went ahead) — the bucket's lifecycle rule is the fallback for objects, the volume is deleted by label sema.space",
+                });
+            });
+        }
+        if (trees.unattributableToolResults > 0) {
+            logger.warn("tool_result_unattributable_rows_survive_session_delete", {
+                sessions: trees.sessions.map((s) => s.sessionId),
+                unattributable: trees.unattributableToolResults,
+            });
+        }
+        return { spaces: reclaimed };
+    };
+}
+//# sourceMappingURL=session-erase.js.map

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

@@ -30,14 +30,14 @@
  *      (同 `placement_kind` 的先例),不在这里解析句子。
  *  · `not_found` —— 留白:每一面各有自己的「不存在」答法(404 `not_found.session` / 同步口的 `resume.session_not_found` /
  *    列表里的缺席),码位各不相同,不由本表统一。
- *  · `placement_refused` —— `import` 面 **409 `conflict.session_placed`**(机读位 `detail.placement_kind`,固定句);`open` 面留白。
+ *  · `placement_refused` —— `import` 面 **409 `conflict.session_placed`**(机读位 `placement_kind`,在拒体根上;固定句);`open` 面留白。
  *    同一个词在两面上说的不是同一件事:import 面只有「会话同步往一只**分区会话**(委派子代的转录)上写」一个来源
  *    (三只持久会话店的整段换装 / 暂存提交门:目标 id 的 `placement_kind` 在场 ⇒ 不适用),调用方没做错格式、是**目标**不收这种写;
  *    open 面上同一个词还含「声明了分区的创建撞上了分区外 / 异组的行」两形(core `TtlSessionStore.assertPlacementAdmission` 的后两条),
  *    那不是「目标是分区会话」。而 run 终局上它是引擎词汇(`terminal.code`),原样随 failed 体走 —— 若在这里分诊成 409,
  *    体上的 `errorCode` 仍是引擎词 `placement_refused`,一个状态两个名字。所以 open 面留白。
  *    409 的语义:目标会话**状态**不收这种写(重试同一个 id 同一结果;换一个会话 id 推)—— 与 `conflict.session_ownerless` / `conflict.session_children_alive` 同族。
- *    `detail.placement_kind` 是**常量**,不是从错误里读的:core 的 `SessionError` 只带 `code` 与句子,不带种类;今天分区种类闭集只有
+ *    `placement_kind` 是**常量**,不是从错误里读的:core 的 `SessionError` 只带 `code` 与句子,不带种类;今天分区种类闭集只有
  *    `"subagent"` 一个词,所以常量就是事实。core 给 `SessionPlacementRecord["kind"]` 加第二个词 ⇒ 下面的守卫编译红,由人裁定种类从哪儿读
  *    (请求 core 把种类放进错误,而不是在这里解析句子)。
  *  · `invalid_entry` / `invalid_fork_target` —— 留白:本仓今天没有一条 wire 口把它们作为自己的
@@ -76,8 +76,8 @@ export interface SessionErrorWire {
      * 点名条目 id / 会话 id / 引擎内部词,wire 上只回一句固定话(各自冻结在 `test/api-error-text-freeze.test.ts` 的常量锚格)。
      */
     readonly sentence?: string;
-    /** 机读事实(体顶层的 `detail` 键;缺席 = 体里不带这个键)。只有 import 面的 `placement_refused` 用它:`{ placement_kind }`。 */
-    readonly detail?: Readonly<Record<string, string>>;
+    /** 机读事实(摊在拒体根上;缺席 = 没有可机读的事实)。只有 import 面的 `placement_refused` 用它:`{ placement_kind }`(键名随 SQL 列)。 */
+    readonly facts?: Readonly<Record<string, string>>;
 }
 /** import 面 `invalid_session` 的固定句(修前 session-sync 暂存导入腿那一行的原文)。 */
 export declare const STAGED_IMPORT_INVALID_SENTENCE = "staged session log failed validation";
@@ -108,7 +108,7 @@ export declare class StampedSessionArchiveError extends SessionError {
  *
  * 码与句子**就是**那只存档故障的(`cause` = 它;码不另铸 —— 只会是 `corrupt_session`,读不出而说不出在不在的 I/O 级故障不换型):
  * 不认识本型的站点看到的与此前逐字相同(`sessionErrorHttp` 按码映射,wire 与运维日志不变)。认识本型的站点 —— 会话读面的属主读
- * (`http/owner-access.ts` 的 `foldOwnerUnreadable`)—— 把它读成「没有这一行」:与对非属主、对不存在的会话同一只 404,原故障进运维日志。
+ * (`http/owner-access.ts` 的 `readOwnerCell`)—— 把它读成「没有这一行」:与对非属主、对不存在的会话同一只 404,原故障进运维日志。
  */
 export declare class SessionOwnerUnreadableError extends SessionError {
     constructor(fault: SessionError);

package/dist/session-error-wire.js

@@ -22,7 +22,7 @@ export class SessionOwnerUnreadableError extends SessionError {
 export const STAMPED_SESSION_ARCHIVE_SENTENCE = "this session's stored archive still carries an owner stamp written by an earlier server version, so it cannot be forked or have its log replaced; nothing was written — delete the session and push it again";
 const CORRUPT_SESSION = { status: 500, errorCode: "corrupt_session" };
 const INVALID_ENTRIES = { status: 422, errorCode: "invalid_entries", sentence: STAGED_IMPORT_INVALID_SENTENCE };
-const SESSION_PLACED = { status: 409, errorCode: "conflict.session_placed", sentence: PLACED_SESSION_SENTENCE, detail: { placement_kind: PLACEMENT_KIND } };
+const SESSION_PLACED = { status: 409, errorCode: "conflict.session_placed", sentence: PLACED_SESSION_SENTENCE, facts: { placement_kind: PLACEMENT_KIND } };
 const STAGED_IMPORT_OWNER_CHANGED = { status: 409, errorCode: "conflict", sentence: STAGED_IMPORT_OWNER_CHANGED_SENTENCE };
 const STAMPED_SESSION_ARCHIVE = { status: 409, errorCode: "conflict.session_archive_stamped", sentence: STAMPED_SESSION_ARCHIVE_SENTENCE };
 export function sessionErrorWireOf(e, face) {

package/dist/session-incarnation.d.ts

@@ -7,7 +7,7 @@
  *
  * ## 规则(全仓唯一处写)
  *  · **铸点只在新建行**:会话店的 `register` / 无 id 创建 / fork / session-sync 的导入新行。已存在的行化身一个字节都不动;
- *    session-sync 的整段换装(replace / staged commit)换的是**同一位住客**的日志,化身沿用 —— 属主却可以被换装重戳为导入者(local 的 M10 认领同理),
+ *    session-sync 的整段换装(replace / staged commit)换的是**同一位住客**的日志,化身沿用 —— 属主却可以被换装重戳为导入者,
  *    所以化身与属主不是同一条律(读法分三种,见下「两读」)。删除随行消失,同 id 重新登记铸新的。
  *  · **两读(住客的三种问法,各读各的格,不混用)**:
  *    K1 **住客自己的记录**(工作区、记忆、空间分区……按「这一位住客」落的东西)只按化身绑 —— 同一位住客的属主换代(推送重戳 / 认领)不换住客,记录照落;
@@ -15,7 +15,7 @@
  *    (`execution-placement.ts` 的 `sameOccupant`,SQL `incarnation = ? AND owner <=> ?` 的对位)—— 读与写之间属主换了一代 ⇒ 不是判过的那一行;
  *    K0 **只问属主的门**(授权门、暂存提交的属主 CAS)只读属主那一格。三种都读会话**行**;local 店的行 = 会话元数据边档那一格(引擎仓里的存档是匿名内容仓,
  *    存档头上的属主不是行事实 —— `plugins/local-session-store.ts` 头注)。
- *  · **值是不透明随机串**(`randomUUID()`,v4:没有时间戳、没有机器信息 —— 刻意不用 uuidv7,那一形带铸造时刻)。只拿来比较。
+ *  · **值是不透明随机串**(铸法只有 core 的 `incarnationCell(undefined)`,v4:没有时间戳、没有机器信息 —— 刻意不用 uuidv7,那一形带铸造时刻)。只拿来比较。
  *  · **一格、一个解码**:住客令牌是会话**行**上的一格 —— SQL `session_meta.incarnation`(两方言)、local 后端的会话元数据边档那一格
  *    (`plugins/local-session-store.ts` 的 `session-incarnations.json`)。行上的值只经 {@link incarnationFromCell} 解码。
  *  · **按 id 读只有一只:core 的 `SessionStore.headOf(id)`**(core 7.55.0 [ref] S2;`{ owner, incarnation, leafId }`,同一行、同一次读 ——
@@ -47,10 +47,11 @@
  *    认领之后唯一写口按那一读的住客定址判一次(化身 ∧ 属主;不在或不是那一位 ⇒ 回滚认领、答既有的 `409 decide.not_parked`);
  *    赎回面(`parked-revive-surface.ts`)只收写口放行的那一位,属主 = 卡的 principal 时交继承座。
  *  · core 的记忆引擎:Runner 读**它取到的那只会话**的 `getMetadata().incarnation`(SQL 两店的 wake 带出这一列;local 店交出的会话
- *    在元数据上答边档那一格),不再有宿主座。
+ *    在元数据上答边档那一格),不再有宿主座。local 数据根上两条入口(HTTP 服务的 local 臂、run-local)经**同一只** local 店打开会话
+ *    (`plugins/store-backend.ts` 的 `openLocalBackend`)⇒ 同一只会话在两条入口上是同一位住客;引擎存档头上另铸的那只令牌不作住客读(只当存档的行代号)。
  *  · 没取会话的那一侧(k8s 工作区空间的分区,`boot/execution-env.ts`):会话店的 `headOf`,经 {@link sessionFaceOfHead} 拿令牌;缓存包装层原样转发。
  */
-import type { SessionHead } from "@sema-agent/core";
+import { type SessionHead, type SessionMetadata } from "@sema-agent/core";
 /** 一位活住客:属主 + 它的令牌(同一行、同一次读;投影自会话店的头,见 {@link sessionFaceOfHead})。 */
 export interface SessionFace {
     /** `null` = 登记为无主的会话。 */
@@ -60,7 +61,10 @@ export interface SessionFace {
 }
 /** 会话店的按 id 读(core `SessionStore.headOf` 的形):`undefined` = 没有这只会话;读抛 = 读故障,不是答案。 */
 export type HeadRead = (sessionId: string) => Promise<SessionHead | undefined>;
-/** 铸一只新化身(铸点见头注,只在新建行)。 */
+/**
+ * 铸一只新化身(铸点见头注,只在新建行)。**铸法只有 core 那一只**:`incarnationCell(undefined)` —— 引擎自带仓的唯一铸点(新行一只随机 v4 串,无时间无机器);
+ * 本仓不再自带第二份铸法。core 的返回型把这一格写作可选(`existing` 非空时可以无令牌),新行永远有 —— 这里只收窄成 `string`,缺了是响亮的不变量破,不补铸。
+ */
 export declare function mintSessionIncarnation(): string;
 /** 日志里点名一只化身时唯一允许的形:前 8 位。完整令牌不进任何日志正文。 */
 export declare function incarnationLogPrefix(incarnation: string): string;
@@ -128,6 +132,11 @@ export declare function sessionFaceOfHead(sessionId: string, head: SessionHead |
  * 一次性迁移 M23(窗内)的回填读的都是这一只返回值。缺席 = 店没有实装 `headOf`(读不出属主 / 住客 / 叶子,调用方各按自己的 fail-closed 臂处置)。
  */
 export declare function headReadOf(store: object | undefined): HeadRead | undefined;
+/**
+ * 删除门(`DELETE /v1/sessions/:id` 的属主门 + 协调器的化身围栏)的头读 —— **只判这一处**:店交了 `deletionHeadOf`(删除已开始、还没收完的那一行也答得出属主与住客;local)⇒ 它;
+ * 否则 ⇒ {@link headReadOf}(删除是一个事务的店,没有删到一半的行)。缺席 = 店没有按 id 读。
+ */
+export declare function deletionHeadReadOf(store: object | undefined): HeadRead | undefined;
 /** 换装沿用的行格(化身 + fork 键):{@link carriedRowCells} 的答案。`forkKey: null` = 没有可沿用的键(新建行 / 行上本来没有)。 */
 export interface CarriedRowCells {
     readonly incarnation: string;
@@ -158,4 +167,42 @@ export declare const SESSION_META_INCARNATION_COLUMN: {
     readonly mysql: "incarnation VARCHAR(64) NOT NULL DEFAULT ''";
     readonly pg: "incarnation VARCHAR(64) COLLATE \"C\" NOT NULL DEFAULT ''";
 };
+/**
+ * SQL 两方言 `session_meta` 的 fork 谱系两列(列定义的唯一属主;两方言建表语句各插一处 —— 与上面的化身列同住:谱系的住客那一半就是源行那一刻的化身;
+ * 谁写、怎么铸见 `plugins/session-fork.ts`「fork 谱系」)。宽度 = 会话 id 列 / 化身列的宽度(两格存的就是这两种值)。
+ * 可空:NULL = 不是 fork 建的行,或谱系落地之前建的 fork(不回填)。存量库缺这两列 ⇒ 起服列册对账拒启,拒句给 ALTER(由本建表语句生成)。
+ */
+export declare const SESSION_META_LINEAGE_COLUMNS: {
+    readonly mysql: "forked_from VARCHAR(64) NULL,\n     forked_from_incarnation VARCHAR(64) NULL";
+    readonly pg: "forked_from VARCHAR(64) COLLATE \"C\",\n     forked_from_incarnation VARCHAR(64) COLLATE \"C\"";
+};
+/**
+ * 行上谱系两格 → 交出的会话元数据的谱系两键(三店的唯一读法:SQL 唤醒读两列、列表读 `forked_from`;local 读那一格的两位)。
+ * 非空串 ⇒ 在;NULL / 缺 / 空串 ⇒ 键缺席(omit-when-absent,恒不铸 `null`)。来源住客读法 = 化身的宽读臂(与头读的住客同一只解码);它是谱系的住客那一半 ——
+ * 没有源 id 就没有谱系,来源住客也不单独交出。
+ */
+export declare function forkLineageOfRow(sessionId: string, forkedFrom: unknown, forkedFromIncarnation: unknown): Pick<SessionMetadata, "forkedFrom" | "forkedFromIncarnation">;
+/** 一次新建行交回的候选:哪只会话、记下的属主、这一次 INSERT 铸的化身(入参里铸的那一只,不是登记之后的复读)。 */
+export interface SessionBirth {
+    readonly sessionId: string;
+    readonly owner: string | null;
+    readonly incarnation: string;
+}
+/** 登记回执:`minted` 只在这一笔真建了新行时在场。 */
+export interface RegisterReceipt {
+    readonly minted?: SessionBirth;
+}
+/** 撤回判下来「留」的店内词(闭集;出口的计数词表在它之上加座内的词,`src/submission-exit.ts`)。`claim` = 这一行被持有:活 run 的认领,或一次删除的在删态(会话三态,`session-deletion.ts`)。 */
+export type StoreKeptWord = "absent" | "incarnation" | "content" | "claim" | "client_writes" | "runs" | "upgrade_pending";
+/** 撤回的结局。 */
+export type WithdrawOutcome = {
+    readonly withdrawn: true;
+} | {
+    readonly withdrawn: false;
+    readonly kept: StoreKeptWord;
+};
+/** 部署判据的答案(店的条件删除在同一事务里问部署):放行(本次 run 的部署行已在同一事务里删掉)或留(部署那一半的哪一条)。 */
+export type WithdrawJudgeVerdict = "proceed" | {
+    readonly keep: Extract<StoreKeptWord, "client_writes" | "runs" | "upgrade_pending">;
+};
 //# sourceMappingURL=session-incarnation.d.ts.map

package/dist/session-incarnation.js

@@ -1,6 +1,9 @@
-import { randomUUID } from "node:crypto";
+import { incarnationCell } from "@sema-agent/core";
 export function mintSessionIncarnation() {
-    return randomUUID();
+    const { incarnation } = incarnationCell(undefined);
+    if (incarnation === undefined)
+        throw new Error("core's incarnationCell(undefined) minted no token for a new row — refusing to invent one");
+    return incarnation;
 }
 export function incarnationLogPrefix(incarnation) {
     return incarnation.slice(0, 8);
@@ -67,6 +70,10 @@ export function headReadOf(store) {
     const read = store?.headOf;
     return typeof read === "function" ? read.bind(store) : undefined;
 }
+export function deletionHeadReadOf(store) {
+    const read = store?.deletionHeadOf;
+    return typeof read === "function" ? read.bind(store) : headReadOf(store);
+}
 export function carriedRowCells(sessionId, prior) {
     const held = prior === undefined ? undefined : incarnationFromCell(sessionId, prior.incarnation, "absent");
     if (held === undefined)
@@ -78,4 +85,14 @@ export const SESSION_META_INCARNATION_COLUMN = {
     mysql: "incarnation VARCHAR(64) NOT NULL DEFAULT ''",
     pg: `incarnation VARCHAR(64) COLLATE "C" NOT NULL DEFAULT ''`,
 };
+export const SESSION_META_LINEAGE_COLUMNS = {
+    mysql: "forked_from VARCHAR(64) NULL,\n     forked_from_incarnation VARCHAR(64) NULL",
+    pg: `forked_from VARCHAR(64) COLLATE "C",\n     forked_from_incarnation VARCHAR(64) COLLATE "C"`,
+};
+export function forkLineageOfRow(sessionId, forkedFrom, forkedFromIncarnation) {
+    if (typeof forkedFrom !== "string" || forkedFrom === "")
+        return {};
+    const occupant = incarnationFromCell(sessionId, forkedFromIncarnation, "absent");
+    return { forkedFrom, ...(occupant !== undefined ? { forkedFromIncarnation: occupant } : {}) };
+}
 //# sourceMappingURL=session-incarnation.js.map

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

@@ -21,7 +21,7 @@
  *  · 本仓自己的形读者、桶表与逐键问引擎的那一圈(同一问的第二个读者,[ref])⇒ 读回直接读引擎的形读法。
  */
 import { SessionPolicyError } from "@sema-agent/core";
-import type { SessionPermissionRules, SessionRuleEntryRefusal, SessionRuleShapeRefusal, SessionRulesRecord } from "@sema-agent/core";
+import type { SessionPermissionRules, SessionRuleEntryRefusal, SessionRulesRecord } from "@sema-agent/core";
 /** 引擎的两只**内容**拒(规则体自己的问题;`conflict` / `loosen_forbidden` / `corrupt` 是店与这一次写的关系,不在此列)。 */
 export type SessionRulesRefusal = SessionPolicyError & {
     readonly code: "invalid_shape" | "inert_entry";
@@ -120,8 +120,11 @@ export declare function describeInertEntry(r: SessionRuleEntryRefusal): string;
  * 引擎契约破了(`inert_entry` 不带条目读数)⇒ 抛,不编一句。
  */
 export declare function sessionPolicyErrorSentence(e: SessionPolicyError): string;
-/** 一只 `SessionPolicyError` 上 wire 的拒体格(引擎的 `detail` 原样摊在体顶层;只在两只内容码上有)。 */
-export declare function sessionPolicyErrorFacts(e: SessionPolicyError): Readonly<SessionRuleShapeRefusal | SessionRuleEntryRefusal> | undefined;
+/**
+ * 一只 `SessionPolicyError` 上 wire 的拒体事实(只在两只内容码上有):引擎的 `detail` 经**闭集映射**进拒体根(对位 `http/refusal-body.ts` 的 `resumeRefusalFacts`)——
+ * 按码取那一张键表,逐键过境、值原样;表外的键(引擎多带的成员、句子专用的 `carriedBy`)不过境,值为 `undefined` 的键不铸。
+ */
+export declare function sessionPolicyErrorFacts(e: SessionPolicyError): Readonly<Record<string, unknown>> | undefined;
 /**
  * 🔴 **`SessionPolicyError` 的闭集 → HTTP 的**唯一**映射(core 7.25.0 提货批新建)。**
  *

package/dist/session-policy-wire.js

@@ -107,8 +107,18 @@ export function sessionPolicyErrorSentence(e) {
         throw new Error(`SessionPolicyError inert_entry without the entry reader's detail: ${e.message}`);
     return describeInertEntry(e.detail);
 }
+const SHAPE_REFUSAL_FACT_KEYS = ["field", "got"];
+const ENTRY_REFUSAL_FACT_KEYS = ["field", "entry", "reason", "verdict", "guidance", "currentName", "ambiguous", "valueType"];
 export function sessionPolicyErrorFacts(e) {
-    return isSessionRulesRefusal(e) ? e.detail : undefined;
+    if (!isSessionRulesRefusal(e) || e.detail === undefined)
+        return undefined;
+    const detail = { ...e.detail };
+    const keys = e.code === "invalid_shape" ? SHAPE_REFUSAL_FACT_KEYS : ENTRY_REFUSAL_FACT_KEYS;
+    const facts = {};
+    for (const key of keys)
+        if (detail[key] !== undefined)
+            facts[key] = detail[key];
+    return facts;
 }
 export function sessionPolicyErrorHttp(code) {
     switch (code) {

package/dist/session-resident-background.d.ts

@@ -1,74 +1,3 @@
-/**
- * `/health.inflight` 计法表里**会话驻留的后台行**两类 —— 后台子代理(`backgroundAgents`,进阻断集)与后台 shell / monitor(`sessionResident`,只进总数)。
- *
- * ## 病
- * 引擎在飞数原先只数 HTTP 腿与 leader 腿。模型在会话里起的后台活 —— `run_in_background` 的 shell / monitor、core `backgroundScope:"session"` 下的
- * 后台子代理(Agent / Fork)—— 活过起它的那一条腿:腿一收,三张登记簿里都没有它,而引擎还托管着它。读 `/health` 判「这台引擎是否空闲」的外部判官看不见它们,
- * 只好另拼一条谓词(同一个事实两个读法);附着租约 / 排空 / SIGHUP 空闲窗对还在烧模型的后台子代理同样看不见,把它随引擎的受控退中断。
- *
- * ## 两个事实(本文件产分项里的两项;两个和只在 `fleet/drain-entry.ts` 各写一次)
- * `/health.inflight`(总数,{@link inflightTotal})= 引擎此刻托管着多少活 = `http + leader + backgroundAgents + sessionResident`,可观测事实;
- * `drainState.blockingInflight`(阻断集,{@link blockingInflightOf})= 还有没有必须等完的活 = `http + leader + backgroundAgents`,排空 / 孤儿窗 / 附着租约自退 / SIGHUP 空闲窗判停读它。
- * 两个和读**同一只**分项函数(`http/server.ts` 的 `inflightBreakdown`),本文件的读数在一次走查里同时交出两项 —— 判停与 `/health` 不是两份算法。
- *  · `backgroundAgents` **进阻断集**:后台子代理是一条在干活的模型腿,干完自己收尾(在审批 / 问答卡上等人时行仍是 `running`、照计;窗满转成耐久停驻后不再计);
- *    不等它 = 受控退把一条还在干活的子代理中断(账本行落终态,模型工作丢)。与驻留 shell 的分界不是「有没有墙钟上限」—— core [ref] 已退役会话级子代理的
- *    30 min 缺省墙钟,两类都没有 —— 而是「会不会自己结束」:模型腿干完即止,`while true` 的 shell 永不。
- *    上界 = 停滞收割窗 `BG_AGENT_STALL_MS`(下面「停滞收割」一节):任务表行一直是 `running`、却不再有工具活动的子代理 —— 挂死的,或已收尾、但 core 在把行转终态之前
- *    await 的那一次委派行写 / 工作树收尾挂住了的(core `agents/subagent.js` 子代收尾链:`await rowSettled` 先于 `settleBackgroundAgent`)—— 静默满窗即被收,不再无界地撑着判停窗。
- *  · `sessionResident` **只进总数**:驻留 shell 不是一条腿,等它没有意义;一只不退出的 shell(`while true`)若阻断,崩溃孤儿引擎就永生、排空每次等满窗。
- *    窗到 / 排空完成,退出边界的后台收割收掉它们,retain 行按 retain 既有语义活过受控退。
- *
- * ## 读法(本文件是唯一属主;行判一处写:{@link sessionResidentTermOf})
- * 行集 = core `TaskRegistry.liveTasks(access)` 的投影,按行类型与状态分到两项之一或不计:
- *
- *  | 行(`sessionScoped` 为真)                         | 状态 `pending` / `running` | `parked`          | 终态 |
- *  |---------------------------------------------------|----------------------------|-------------------|------|
- *  | `background_agent`(后台子代理)                   | `backgroundAgents`         | 不计(耐久停驻) | 不计 |
- *  | `background_bash` / `monitor`,非 retain          | `sessionResident`          | 不计              | 不计 |
- *  | `background_bash` / `monitor`,retain             | 不计(交付的活服务,活过受控退)                 |||
- *  | `workflow`                                        | 不计(见下)                                     |||
- *
- *  · **`sessionScoped` 为假的行不计**:挂在 run 腿上的后台行随腿登记在 `http` 项里,数它是第二次(腿一收,core 的拆腿收割把它们一起结掉)。
- *  · **`parked` 不计**:与停驻的 run 同一条律 —— 停驻是耐久的(引擎退了不丢,下次起来仍可赎回),不占执行座;算它,一张没人答的审批就让引擎永远退不掉。
- *  · **`workflow` 行不计**(计法表成文的一行,不是遗漏):任务表对一条 workflow 只投 `running`,一条腿停在审批门上等人时也还是 `running` ——
- *    这只读法分不出「在干活」与「在等人」。进阻断集 ⇒ 一张没人答的审批让崩溃孤儿引擎永生(与驻留 shell 同一病);只进总数 ⇒ 多一类只报不阻断的项、
- *    判据与停驻律对不上。停驻位(core `runParkedOf`)要由任务表投出来才能按停驻律分(请托 core);到货前 workflow 照旧不进在飞,与 7.146.x 同。
- *  · **状态是闭集**(`SemaTaskStatus` 穷举):core 加一个词 ⇒ 这里编译红,不会被静默读成「不计」。
- *  · **一行只数一次**:各会话的可见集可以相交(core `canAccess` 对后台子代理还认 `rootSessionId` —— 子会话与根会话都在围栏表时,两次读都看得见同一行)⇒ 整趟走查按 `task_id` 去重。
- *  · **选座 `liveTasks`,不读 `list()`**:`list()` 是显示投影,硬帽 500 行(core 注:resolution must NEVER ride the display-capped list());
- *    超过 500 行时 `list()` 会静默少数,方向恰是「以为空闲」。`liveTasks` 无显示帽。
- *
- * ## 枚举源
- * core 的 `canAccess` 要求访问元组带 `scope`(缺 scope 一律拒),`list` / `liveTasks` 因此只读「调用方可达行」,没有进程总数的读口。
- * 进程级的数由本仓自己枚举「本进程有哪些会话」:枚举源 = **围栏表**(`boot/execution-env.ts` 的 `SessionScopedRegistries.sessionOwners`):
- * 每次提交经 resolve-spec 写一笔(会话 id → 属主),删会话的 E21 级联清一笔,LRU 有界。scope 轴 = {@link sessionChildrenScope}(会话属主 `?? "default"`,
- * 删除门 / 换绑门 / 结清口 / 会话后台读面同一个取法,不另取)。会话驻留的后台子代理 `owner` = 会话 id([ref] 纪律),同一只访问元组够得着。
- * 〔待 core:一只进程级、不按访问元组收窄的计数读口(`countRunningBackgroundShells` 的子代理孪生)到货后,子代理一项改读它 —— 下面三条边界随之消失。〕
- *
- * ## 读到的边界(成文,不静默)
- *  · 围栏表是 LRU(上界 4096 会话):被挤出表的会话,它的会话驻留行在这里不可见 —— 回到 7.146.x 前的读数(不是新的错),不会多数;
- *  · 不经 resolve-spec 的内部车道(服务为自己起的 run)不写围栏表,它们起的会话驻留行同样不可见;
- *  · 删会话的级联在 `dropSessionScoped` 之后、后台收割之前失败(会话行因此没删)时,围栏表已先清:该会话还在跑的驻留行在下一次提交重新围栏之前不可见
- *    (修法是把 `dropSession` 的「清秘密」与「忘身份」拆开,属围栏表的属主,不在本读法里);
- *  · 每次读是 O(围栏表会话数 × 注册表行数)(`liveTasks` 逐会话走一遍注册表);表的上界 4096、注册表行数小,量级是毫秒。
- *    这一读在判停路径上(排空 1 s 拍 / 租约拍 / SIGHUP 拍)每拍付一次 —— 后台子代理进阻断集的代价,与 `/health` 同一份。
- *
- * ## 停滞收割:先收尸,再数活(本文件是收割的唯一调用点)
- * 引擎把会话驻留后台子代理的反僵尸义务交给调用方:`TaskRegistry.reapStaleSessionBackgroundAgents(staleMs)` 把**最后一次工具活动**距今超过 `staleMs` 的
- * `running` 行收成 `killed`(归因 `system`,措辞与耐久 stale-running 清扫同一句)并中止它的 run;停驻行、随腿的行、终态行它不碰。
- * {@link countSessionResidentBackground} 每读一次先调它一次、再走任务表 —— 所以计法表里「在跑的后台子代理」= 引擎任务表此刻说 `running` 的行,
- * 而任务表在被数之前已经按停滞窗结清过一遍。本服务不另判「这一行其实不活」(行说 running、本服务说不活 = 一个事实两种读法):不活的行由引擎收成终态,本文件只数。
- *  · **拍**:不另起计时器。读口的读者就是拍 —— 排空 1 s 拍、附着租约拍、SIGHUP 空闲窗 1 s 拍、`/health`、崩溃遗言;每一处判停读数之前都先收过一次。
- *    没有任何读者的进程里没有判据要读这一项,僵尸行只停在任务表的显示面上。
- *  · **窗**:`BG_AGENT_STALL_MS`,缺省 = 下限 = 派生值(`config.ts` 的 `backgroundAgentStallFloorMs`:等人的四个窗取大 + 引擎单命令上限)。
- *    子代在审批卡 / 问答卡上等人时行是 `running`、没有工具活动 —— 窗不盖住等人的窗,就会把一只等你回来批的子代当僵尸收掉。
- *  · **收割失败**(引擎抛)⇒ 读口照数任务表(没收掉的行照算在跑:宁可等,与收割接线之前同读)并经 `stall.report` 报出;读口不抛。
- *
- * ## 读不出 ⇒ 非空闲(响亮,不替成 0)
- * 本函数在判停路径(排空首读在期限计时器装上之前)、`/health` 应答与崩溃遗言里被调,**不许抛**(判停首读一抛 ⇒ 期限计时器装不上 ⇒ 永不硬停;
- * 崩溃遗言里一抛会吞掉遗言本身)。某个会话的读失败(含行判遇到闭集外的值)⇒ 该会话按 **1 只在跑的后台子代理**计 —— 落在阻断项里,判停也看得见
- * (读不出 ⇒ 非空闲:宁可当有活)—— 并经 `onUnreadable` 报出;调用方必须给报口(装配层一会话一行 `session_resident_background_unreadable`),不存在静默的 0。
- */
 import { type TaskListRow, type TaskRegistry } from "@sema-agent/core";
 import type { InflightBreakdown } from "./fleet/drain-entry.js";
 /** 枚举源的形:会话 id → 会话属主(`null` = 匿名)。`Map` 满足它。 */

package/dist/session-resident-background.js

@@ -1,5 +1,6 @@
+import { writeLogText } from "./observability/logger.js";
 import { defaultTaskRegistry } from "@sema-agent/core";
-import { sessionChildrenScope } from "./session-children-retire.js";
+import { sessionTenantScope } from "./session-children-retire.js";
 function liveStatus(status) {
     switch (status) {
         case "pending":
@@ -43,7 +44,7 @@ export function countSessionResidentBackground(sessions, opts) {
     for (const [sessionId, owner] of sessions) {
         try {
             const fresh = [];
-            for (const row of registry.liveTasks({ owner: sessionId, sessionId, scope: sessionChildrenScope(owner) })) {
+            for (const row of registry.liveTasks({ owner: sessionId, sessionId, scope: sessionTenantScope(owner) })) {
                 const term = sessionResidentTermOf(row);
                 if (term !== undefined && !counted.has(row.task_id))
                     fresh.push([row.task_id, term]);
@@ -82,7 +83,7 @@ function reportSafely(fallbackLine, report) {
         report();
     }
     catch (reportErr) {
-        console.error(...fallbackLine, reportErr);
+        writeLogText("stderr", ...fallbackLine, reportErr);
     }
 }
 //# sourceMappingURL=session-resident-background.js.map

package/dist/session-row.d.ts

@@ -56,7 +56,8 @@ export interface ReplaySessionRowWrite {
 export type SessionRowWrite = ClientSessionRowWrite | ReplaySessionRowWrite;
 /**
  * 写原语的结局(闭集四员):`written` / `changed` 带提交(回滚)之后另读的那一行(列表行投影,含新 `rowTag`);`mirror`(客户端写在只读镜像上)/
- * `absent`(行期望不中 / 没有行 / 委派分区行 / 应答行已不是判过的那一位住客)一个字节没写。
+ * `absent`(行期望不中 / 没有行 / 委派分区行:锁下拒,一个字节没写;或应答行复核已不是判过的那一位住客:判官答 `changed`、回滚之后换人 = 零写,答 `write`、已提交之后换人〔SQL 后端才有这一窗〕= 写已落,
+ * 随旧行的外键级联删掉,或留在已换主的行上 —— 三分见 `plugins/session-row-sql.ts` 头注「结局 `absent` 的三种去向」)。
  */
 export type SessionRowWriteOutcome<Row> = {
     readonly kind: "written";

package/dist/session-rules-seat.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 🔴 **会话规则的引擎席**(场景子命名空间):会话规则桶的键 = (会话号, **会话属主**)—— 会话号定分区,会话行的属主是那一格分区的主体
+ * (路由 `GET/PUT /v1/sessions/:id/policy` 按会话属主写,`http/routes/sessions.ts`)。引擎读写会话规则时交的是 `spec.principal` = **人**
+ * (引擎交界的身份格,`engine-identity.ts`):带场景的会话,人 ≠ 属主,原样查 = 落到另一只桶(运维在 health 会话上 PUT 的 deny 对引擎不存在 = 安全轴放宽)。
+ *
+ * 律(一句):引擎交来的人恰是这只会话属主背后的人 ⇒ 键换成会话属主;否则原样(与今天逐字节同 —— 没带场景的会话属主与人字节相同,两种读法同一个键)。
+ * 属主只经会话店的头读一处(`headOf(id)?.owner`,会话行是属主的唯一事实);读不到头(会话不在 / 店不交头读)⇒ 原样。读写两腿与祖先会话的规则读同经这一只席。
+ */
+import type { SessionPolicyStore } from "@sema-agent/core";
+import type { HeadRead } from "./session-incarnation.js";
+export declare function createEngineSessionRulesSeat(store: SessionPolicyStore, headOf: HeadRead | undefined): SessionPolicyStore;
+//# sourceMappingURL=session-rules-seat.d.ts.map