@sema-agent/server 7.103.2 → 7.105.0

package/dist/plugins/pg-session-storage.js

@@ -11,6 +11,7 @@ import { classifySyncRelationshipByIds, SyncConflictError, stagingIdFor, STAGING
 import { isPgUniqueViolation } from "./sql-errors.js";
 import { BASELINE_IO_DEADLINE_MS, decodeInstructionSource, encodeInstructionSource } from "../instruction-source-notice.js";
 import { MANAGED_RETENTION } from "./retention-store-sql.js";
+import { SESSION_META_INCARNATION_COLUMN, carriedIncarnation, mintSessionIncarnation, sessionFaceFromRow } from "../session-incarnation.js";
 import { ensureIndexes } from "./ensure-index.js";
 const isDupKey = isPgUniqueViolation;
 function baselineQuery(text, values) {
@@ -40,6 +41,8 @@ export const PG_SESSION_SCHEMA = [
      placement_root_session_id   VARCHAR(190) COLLATE "C",
      placement_handle            VARCHAR(190) COLLATE "C",
      placed_at                   TIMESTAMPTZ(3),
+     -- S-790 / S-506:会话化身(TiDB 孪生同名同义;列定义唯一属主 = src/session-incarnation.ts 的 SESSION_META_INCARNATION_COLUMN)。
+     ${SESSION_META_INCARNATION_COLUMN.pg},
      PRIMARY KEY (session_id)
    )`,
     `CREATE TABLE IF NOT EXISTS session_event (
@@ -217,9 +220,9 @@ export class PgSessionStore {
     }
     async register(sessionId, owner, placement) {
         const now = new Date();
-        await this.pool.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq, " +
+        await this.pool.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq, incarnation, " +
             "placement_kind, placement_scope, placement_parent_session_id, placement_root_session_id, placement_handle, placed_at) " +
-            "VALUES ($1,$2,$3,$4,NULL,0,$5,$6,$7,$8,$9,$10) ON CONFLICT (session_id) DO NOTHING", [sessionId, owner, now, now, ...placementInsertValues(placement, now)]);
+            "VALUES ($1,$2,$3,$4,NULL,0,$5,$6,$7,$8,$9,$10,$11) ON CONFLICT (session_id) DO NOTHING", [sessionId, owner, now, now, mintSessionIncarnation(), ...placementInsertValues(placement, now)]);
     }
     async placementOf(sessionId) {
         const res = await this.pool.query(`SELECT ${PLACEMENT_SELECT_COLUMNS} FROM session_meta WHERE session_id = $1`, [sessionId]);
@@ -246,6 +249,12 @@ export class PgSessionStore {
             return undefined;
         return res.rows[0].owner ?? null;
     }
+    async sessionFaceOf(sessionId) {
+        const res = await this.pool.query("SELECT owner, incarnation FROM session_meta WHERE session_id = $1", [sessionId]);
+        if (res.rows.length === 0)
+            return undefined;
+        return sessionFaceFromRow(sessionId, res.rows[0].owner ?? null, res.rows[0].incarnation);
+    }
     async touch(sessionId) {
         await this.pool.query("UPDATE session_meta SET updated_at = $1 WHERE session_id = $2", [
             new Date(),
@@ -384,7 +393,7 @@ export class PgSessionStore {
                 const payload = String(r.payload);
                 await conn.query("INSERT INTO session_event (session_id, seq, entry_id, parent_id, type, payload, ts) VALUES ($1,$2,$3,$4,$5,$6::jsonb,$7)", [newId, seq, r.entry_id, r.parent_id ?? null, r.type, payload, r.ts]);
             }
-            await conn.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq) VALUES ($1,$2,$3,$4,$5,$6)", [newId, owner, now, now, leafId, rows.length]);
+            await conn.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq, incarnation) VALUES ($1,$2,$3,$4,$5,$6,$7)", [newId, owner, now, now, leafId, rows.length, mintSessionIncarnation()]);
             await conn.query("COMMIT");
             return newId;
         }
@@ -438,7 +447,7 @@ export class PgSessionStore {
         const conn = await this.pool.connect();
         try {
             await conn.query("BEGIN");
-            await this.insertValidatedLog(conn, sessionId, owner, validated);
+            await this.insertValidatedLog(conn, sessionId, owner, validated, mintSessionIncarnation());
             await conn.query("COMMIT");
         }
         catch (err) {
@@ -461,14 +470,14 @@ export class PgSessionStore {
         const conn = await this.pool.connect();
         try {
             await conn.query("BEGIN");
-            const placedRes = await conn.query("SELECT placement_kind FROM session_meta WHERE session_id = $1 FOR UPDATE", [sessionId]);
+            const placedRes = await conn.query("SELECT placement_kind, owner, incarnation FROM session_meta WHERE session_id = $1 FOR UPDATE", [sessionId]);
             if (placedRes.rows[0]?.placement_kind != null) {
                 await conn.query("ROLLBACK");
                 throw new SessionError("placement_refused", `session ${sessionId} belongs to the ${placedRes.rows[0].placement_kind} placement partition — a session-sync replace cannot overwrite a delegation transcript`);
             }
             await conn.query("DELETE FROM session_event WHERE session_id = $1", [sessionId]);
             await conn.query("DELETE FROM session_meta WHERE session_id = $1 AND owner IS NOT DISTINCT FROM $2 AND placement_kind IS NULL", [sessionId, owner]);
-            await this.insertValidatedLog(conn, sessionId, owner, validated);
+            await this.insertValidatedLog(conn, sessionId, owner, validated, carriedIncarnation(placedRes.rows[0], owner));
             await conn.query("COMMIT");
         }
         catch (err) {
@@ -485,7 +494,7 @@ export class PgSessionStore {
             conn.release();
         }
     }
-    async insertValidatedLog(conn, sessionId, owner, validated) {
+    async insertValidatedLog(conn, sessionId, owner, validated, incarnation) {
         let leafId = null;
         for (const e of validated)
             leafId = leafIdAfterEntry(e);
@@ -494,7 +503,7 @@ export class PgSessionStore {
             const e = validated[seq];
             await conn.query("INSERT INTO session_event (session_id, seq, entry_id, parent_id, type, payload, ts) VALUES ($1,$2,$3,$4,$5,$6::jsonb,$7)", [sessionId, seq, e.id, e.parentId ?? null, e.type, pgSafeJsonStringify(e), new Date(e.timestamp)]);
         }
-        await conn.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq) VALUES ($1,$2,$3,$4,$5,$6)", [sessionId, owner, now, now, leafId, validated.length]);
+        await conn.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq, incarnation) VALUES ($1,$2,$3,$4,$5,$6,$7)", [sessionId, owner, now, now, leafId, validated.length, incarnation]);
     }
     beginImportStaging(realSessionId, token) {
         return new PgStagingHandle(this.pool, realSessionId, stagingIdFor(realSessionId, token));
@@ -614,8 +623,8 @@ class PgStagingHandle {
             if (lastRes.rows[0])
                 leafId = leafIdAfterEntry(decodeSessionEventPayload(lastRes.rows[0].payload, this.realSessionId, "last staged row"));
             const now = new Date();
-            await conn.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq) VALUES ($1,$2,$3,$4,$5,$6) " +
-                "ON CONFLICT (session_id) DO UPDATE SET owner = EXCLUDED.owner, updated_at = EXCLUDED.updated_at, leaf_id = EXCLUDED.leaf_id, leaf_seq = EXCLUDED.leaf_seq", [this.realSessionId, owner, now, now, leafId, srcIds.length]);
+            await conn.query("INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq, incarnation) VALUES ($1,$2,$3,$4,$5,$6,$7) " +
+                "ON CONFLICT (session_id) DO UPDATE SET owner = EXCLUDED.owner, updated_at = EXCLUDED.updated_at, leaf_id = EXCLUDED.leaf_id, leaf_seq = EXCLUDED.leaf_seq", [this.realSessionId, owner, now, now, leafId, srcIds.length, mintSessionIncarnation()]);
             const afterMeta = await conn.query("SELECT placement_kind FROM session_meta WHERE session_id = $1", [this.realSessionId]);
             if (afterMeta.rows[0]?.placement_kind != null) {
                 await conn.query("ROLLBACK");

package/dist/plugins/retention-store-sql.js

@@ -380,6 +380,7 @@ export class SqlRetentionStore {
             ["resume_anchor", "session_id"],
             ["approval_exemption", "session_id"],
             ["session_policy", "session_id"],
+            ["session_policy_rev_mark", "session_id"],
             ...(this.opts.taskAttachmentTable ? [["task_attachment", "session_id"]] : []),
             ["file_history_tracked", "scope"],
             ["file_history_version", "scope"],

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

@@ -83,10 +83,14 @@ export declare class SqlRunStore {
     /**
      * Durable F4 ([ref]): a task suspended on a policy `ask`. Sets the run NON-terminal `suspended` and
      * KEEPS the `task_active` claim — the session stays locked (no new run) until an operator resumes it to a
-     * terminal state or the reaper expires it. The token-bearing result is NOT stored (the submitter polling
-     * this row must never receive the capability token); only the status flips.
+     * terminal state or the reaper expires it.
+     *
+     * 🔴 S-173:park 也落 `result` 列 —— 存的是**摘掉恢复凭据、脱过敏的投影**(`sealRunRowResult`,与 `setTerminal`
+     * 同一只入口、同列同序列化),不是引擎交出的原件:`paused.token` / `failed.nestedPause.token` 两座在落列前摘掉,
+     * 所以 poll 这一行的调用方(`GET /v1/runs/:id → result`)拿到的是「停在哪扇门上」而拿不到 resume 能力。
+     * `result = null` = 这条腿没观察到 park 结果(断连竞态 / 重开 re-park),列写空 —— 与修前行形同。
      */
-    setSuspended(taskId: string): Promise<void>;
+    setSuspended(taskId: string, result: PersistedTaskResult | null): Promise<void>;
     /**
      * [ref] D-B: PARK a run that paused on a REVIEW gate — a `needs_review` result (a dry-run diff review OR a
      * pre-action `plan_review`; core assemble-result slot 8.6). Like {@link setSuspended} this is a NON-terminal park
@@ -104,7 +108,7 @@ export declare class SqlRunStore {
      * mocked run-store unit tests stayed green. A mock cannot observe a unique-key claim race, a rolled-back loser,
      * or a multi-table reaper DELETE.
      */
-    setNeedsReview(taskId: string): Promise<void>;
+    setNeedsReview(taskId: string, result: PersistedTaskResult | null): Promise<void>;
     /**
      * Durable F4 resume: a suspended run is being actively resumed. Flip it back to `running` (CAS — only if
      * still suspended) and refresh liveness, so the in-flight resume is protected by the running-run heartbeat
@@ -244,8 +248,9 @@ export declare class SqlRunStore {
         rows: UsageRow[];
         truncated: boolean;
     }>;
-    /** Earliest retained event seq for a task (0 if none) → `retainedFrom` for /turns and the 416 boundary for
-     *  /stream (a resume point below this has been evicted past retention). */
+    /** Earliest retained event seq for a task (0 if none) → the `retainedFrom` field of `GET /v1/tasks/:id/turns`.
+     *  Not an eviction boundary: the ledger has no partial head trim (the only deletion takes the whole session tree),
+     *  so a value > 1 means head rows whose write failed after consuming their seq (S-211 ①). */
     retainedFrom(taskId: string): Promise<number>;
     /** Events with seq strictly greater than `afterSeq` (use 0 for the whole stream). */
     getEvents(taskId: string, afterSeq: number): Promise<RunEvent[]>;
@@ -288,6 +293,10 @@ export declare class SqlRunStore {
      * a NEW pending checkpoint — the `NOT EXISTS pending` clause excludes it. Idempotent across replicas. Returns count.
      *
      * Same alias-qualification divergence as {@link reapSuspended} — see its header note.
+     *
+     * S-173:两条收割腿都把 `result` 列写回 NULL —— park 行上那份 park 结果(`terminal.kind:"paused"`)说的是
+     * 「停在门上」,而这一刻行被打成 `failed`/`approval.expired`;留着它 = 一行两句互相矛盾的话(读面还会从它
+     * 投出 `review.pending` 之类的 park 码)。收割后的行形因此与 S-173 之前逐字同(结果空,码在 error_code 列)。
      */
     failSuspendedWithExpiredCheckpoint(): Promise<number>;
 }

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

@@ -1,4 +1,4 @@
-import { redactErrorMessage, redactLedgerEventData, redactTerminalResult } from "../observability/run-terminal.js";
+import { redactErrorMessage, redactLedgerEventData, sealRunRowResult } from "../observability/run-terminal.js";
 import { outwardPlane } from "../terminal.js";
 import { projectUsageStats, USAGE_SCAN_LIMIT } from "../usage-analytics.js";
 import { escapeLike } from "./sql-escape.js";
@@ -149,7 +149,7 @@ export class SqlRunStore {
         return m == null ? 0 : Number(m);
     }
     async setTerminal(taskId, status, result, error) {
-        result = redactTerminalResult(result);
+        result = sealRunRowResult(result);
         error = error === null ? null : (redactErrorMessage(error) ?? null);
         const errorCode = result === null ? null : (outwardPlane(result.terminal).errorCode ?? null);
         let won = false;
@@ -189,14 +189,16 @@ export class SqlRunStore {
             });
         }
     }
-    async setSuspended(taskId) {
-        await this.db.query(this.q("UPDATE task_run SET status = 'suspended', updated_at = ? WHERE task_id = ? AND status IN ('running','suspended')", "UPDATE task_run SET status = 'suspended', updated_at = $1 WHERE task_id = $2 AND status IN ('running','suspended')"), [new Date(), taskId]);
+    async setSuspended(taskId, result) {
+        const sealed = sealRunRowResult(result);
+        await this.db.query(this.q("UPDATE task_run SET status = 'suspended', result = ?, updated_at = ? WHERE task_id = ? AND status IN ('running','suspended')", "UPDATE task_run SET status = 'suspended', result = $1::jsonb, updated_at = $2 WHERE task_id = $3 AND status IN ('running','suspended')"), [sealed == null ? null : this.json(sealed), new Date(), taskId]);
     }
-    async setNeedsReview(taskId) {
-        await this.db.query(this.q("UPDATE task_run SET status = 'needs_review', updated_at = ? WHERE task_id = ? AND status IN ('running','needs_review')", "UPDATE task_run SET status = 'needs_review', updated_at = $1 WHERE task_id = $2 AND status IN ('running','needs_review')"), [new Date(), taskId]);
+    async setNeedsReview(taskId, result) {
+        const sealed = sealRunRowResult(result);
+        await this.db.query(this.q("UPDATE task_run SET status = 'needs_review', result = ?, updated_at = ? WHERE task_id = ? AND status IN ('running','needs_review')", "UPDATE task_run SET status = 'needs_review', result = $1::jsonb, updated_at = $2 WHERE task_id = $3 AND status IN ('running','needs_review')"), [sealed == null ? null : this.json(sealed), new Date(), taskId]);
     }
     async markResuming(taskId, instanceId) {
-        const { affected } = await this.db.query(this.q("UPDATE task_run SET status = 'running', cancel_requested = 0, preempt_requested = 0, instance_id = ?, updated_at = ? WHERE task_id = ? AND status IN ('suspended','needs_review')", "UPDATE task_run SET status = 'running', cancel_requested = 0, preempt_requested = 0, instance_id = $1, updated_at = $2 WHERE task_id = $3 AND status IN ('suspended','needs_review')"), [instanceId, new Date(), taskId]);
+        const { affected } = await this.db.query(this.q("UPDATE task_run SET status = 'running', cancel_requested = 0, preempt_requested = 0, result = NULL, instance_id = ?, updated_at = ? WHERE task_id = ? AND status IN ('suspended','needs_review')", "UPDATE task_run SET status = 'running', cancel_requested = 0, preempt_requested = 0, result = NULL, instance_id = $1, updated_at = $2 WHERE task_id = $3 AND status IN ('suspended','needs_review')"), [instanceId, new Date(), taskId]);
         return affected === 1;
     }
     async getActiveTaskId(sessionId) {
@@ -421,8 +423,8 @@ export class SqlRunStore {
         const cutoff = new Date(Date.now() - olderThanMs);
         let reaped = 0;
         await this.tx(async (conn) => {
-            const { affected } = await conn.query(this.q("UPDATE task_run SET status = 'failed', error = 'run stalled (instance lost?)', updated_at = ? " +
-                "WHERE status = 'running' AND updated_at < ?", "UPDATE task_run SET status = 'failed', error = 'run stalled (instance lost?)', updated_at = $1 " +
+            const { affected } = await conn.query(this.q("UPDATE task_run SET status = 'failed', result = NULL, error = 'run stalled (instance lost?)', updated_at = ? " +
+                "WHERE status = 'running' AND updated_at < ?", "UPDATE task_run SET status = 'failed', result = NULL, error = 'run stalled (instance lost?)', updated_at = $1 " +
                 "WHERE status = 'running' AND updated_at < $2"), [new Date(), cutoff]);
             reaped = affected;
             await conn.query(this.q("DELETE ta FROM task_active ta JOIN task_run tr ON ta.task_id = tr.task_id WHERE tr.status NOT IN ('running','suspended','needs_review')", "DELETE FROM task_active ta USING task_run tr WHERE ta.task_id = tr.task_id AND tr.status NOT IN ('running','suspended','needs_review')"));
@@ -434,9 +436,9 @@ export class SqlRunStore {
         const cutoff = new Date(Date.now() - olderThanMs);
         let reaped = 0;
         await this.tx(async (conn) => {
-            const { affected } = await conn.query(this.q("UPDATE task_run tr SET tr.status = 'failed', tr.error = 'approval expired before decision', tr.error_code = 'approval.expired', tr.updated_at = ? " +
+            const { affected } = await conn.query(this.q("UPDATE task_run tr SET tr.status = 'failed', tr.result = NULL, tr.error = 'approval expired before decision', tr.error_code = 'approval.expired', tr.updated_at = ? " +
                 "WHERE tr.status = 'suspended' AND tr.updated_at < ? " +
-                "AND NOT EXISTS (SELECT 1 FROM checkpoint c WHERE c.session_id = tr.session_id AND c.status = 'pending')", "UPDATE task_run AS tr SET status = 'failed', error = 'approval expired before decision', error_code = 'approval.expired', updated_at = $1 " +
+                "AND NOT EXISTS (SELECT 1 FROM checkpoint c WHERE c.session_id = tr.session_id AND c.status = 'pending')", "UPDATE task_run AS tr SET status = 'failed', result = NULL, error = 'approval expired before decision', error_code = 'approval.expired', updated_at = $1 " +
                 "WHERE tr.status = 'suspended' AND tr.updated_at < $2 " +
                 "AND NOT EXISTS (SELECT 1 FROM checkpoint c WHERE c.session_id = tr.session_id AND c.status = 'pending')"), [new Date(), cutoff]);
             reaped = affected;
@@ -447,10 +449,10 @@ export class SqlRunStore {
     async failSuspendedWithExpiredCheckpoint() {
         let reaped = 0;
         await this.tx(async (conn) => {
-            const { affected } = await conn.query(this.q("UPDATE task_run tr SET tr.status = 'failed', tr.error = 'approval expired before decision', tr.error_code = 'approval.expired', tr.updated_at = ? " +
+            const { affected } = await conn.query(this.q("UPDATE task_run tr SET tr.status = 'failed', tr.result = NULL, tr.error = 'approval expired before decision', tr.error_code = 'approval.expired', tr.updated_at = ? " +
                 "WHERE tr.status IN ('suspended','needs_review') " +
                 "AND EXISTS (SELECT 1 FROM checkpoint ce WHERE ce.session_id = tr.session_id AND ce.status = 'expired') " +
-                "AND NOT EXISTS (SELECT 1 FROM checkpoint cp WHERE cp.session_id = tr.session_id AND cp.status = 'pending')", "UPDATE task_run AS tr SET status = 'failed', error = 'approval expired before decision', error_code = 'approval.expired', updated_at = $1 " +
+                "AND NOT EXISTS (SELECT 1 FROM checkpoint cp WHERE cp.session_id = tr.session_id AND cp.status = 'pending')", "UPDATE task_run AS tr SET status = 'failed', result = NULL, error = 'approval expired before decision', error_code = 'approval.expired', updated_at = $1 " +
                 "WHERE tr.status IN ('suspended','needs_review') " +
                 "AND EXISTS (SELECT 1 FROM checkpoint ce WHERE ce.session_id = tr.session_id AND ce.status = 'expired') " +
                 "AND NOT EXISTS (SELECT 1 FROM checkpoint cp WHERE cp.session_id = tr.session_id AND cp.status = 'pending')"), [new Date()]);

package/dist/plugins/schema-indexes.js

@@ -10,6 +10,7 @@ export const CENTRAL_SCHEMA_INDEXES = [
     { table: "approval_nonce", name: "idx_approval_nonce_expires", columns: ["expires_at_ms"] },
     { table: "sendfile_link", name: "idx_sendfile_link_scope", columns: ["scope", "id"] },
     { table: "session_policy", name: "idx_session_policy_session", columns: ["session_id"] },
+    { table: "session_policy_rev_mark", name: "idx_session_policy_rev_mark_session", columns: ["session_id"] },
     { table: "snapshot_blob", name: "idx_snapshot_blob_created", columns: ["created_at"] },
     { table: "file_history_version", name: "idx_file_history_version_blob", columns: ["blob_hash"] },
     { table: "file_history_boundary_file", name: "idx_file_history_bf_key", columns: ["scope", "key_hash"] },

package/dist/plugins/send-file-ledger.d.ts

@@ -1,6 +1,7 @@
 import type { Pool as MysqlPool } from "mysql2/promise";
 import type { Pool as PgPool } from "pg";
 import type { IssuedFileLink } from "./send-user-file.js";
+import type { Logger } from "../observability/logger.js";
 /** Ledger scope sentinel for single-user issuance (no principal) — mirrors scopeSegment's "_" key segment. */
 export declare const SENDFILE_SINGLE_USER_SCOPE = "_";
 export interface SendFileLedgerEntry {
@@ -47,7 +48,10 @@ export declare class FileSendFileLedger implements SendFileLedger {
     private readonly path;
     private readonly mem;
     private log;
-    constructor(root: string);
+    /** @param opts.warn corrupt-read disclosure seat (S-582; absent ⇒ the replay owner falls back to `console.warn`). */
+    constructor(root: string, opts?: {
+        warn?: Logger["warn"];
+    });
     record(entry: SendFileLedgerEntry): Promise<void>;
     listByScope(scope: string, limit: number, beforeId?: string): Promise<SendFileLedgerEntry[]>;
     /** Release the append-log fd (LocalBackend.close → graceful-restart re-open). */

package/dist/plugins/send-file-ledger.js

@@ -1,5 +1,6 @@
 import { join } from "node:path";
-import { AppendLog, ensureDir, readJsonlRecords, uuidv7 } from "@sema-agent/core";
+import { AppendLog, ensureDir, uuidv7 } from "@sema-agent/core";
+import { replayJsonlSkipping } from "../observability/corrupt-read-seat.js";
 export const SENDFILE_SINGLE_USER_SCOPE = "_";
 export class TiDBSendFileLedger {
     pool;
@@ -68,19 +69,23 @@ export class MemorySendFileLedger {
             .map((e) => ({ ...e }));
     }
 }
+const LEDGER_ROW_SHAPE = {
+    what: "send-file ledger row without a string id / scope / objectKey",
+    read(record) {
+        const r = record;
+        return typeof r.id === "string" && typeof r.scope === "string" && typeof r.objectKey === "string" ? record : undefined;
+    },
+};
 export class FileSendFileLedger {
     path;
     mem = new MemorySendFileLedger();
     log;
-    constructor(root) {
+    constructor(root, opts) {
         const dir = join(root, "sendfile-ledger");
         ensureDir(dir);
         this.path = join(dir, "links.jsonl");
-        for (const r of readJsonlRecords(this.path)) {
-            if (!r || typeof r.id !== "string" || typeof r.scope !== "string" || typeof r.objectKey !== "string")
-                continue;
+        for (const r of replayJsonlSkipping(this.path, "send-file-ledger", LEDGER_ROW_SHAPE, opts?.warn).records)
             void this.mem.record(r);
-        }
     }
     async record(entry) {
         this.log ??= new AppendLog(this.path);

package/dist/plugins/session-event-payload.d.ts

@@ -14,10 +14,20 @@
  * 会话事件日志是 **wake 的全部依据**:一行读不出形的 payload 被当成 `null` / 空对象端出去 ⇒ 这只会话的
  * 上下文树里多一个没有 `id`、没有 `type` 的节点,`leafIdAfterEntry` 与 `buildContext` 在它上面的行为未定;
  * 静默跳过它则是**一段对话从历史里消失**(而模型会照着一棵少了一截的树继续说话)。两者都比一次响亮的
- * wake 失败坏。本店没有枚举式 corrupt 码(`SessionError` 的词表 —— `conflict` 等 —— 是并发契约词,
- * 不是读侧 corrupt 词)⇒ 折成响亮裸 `Error`,点名 `<表>.<列>` + 行标识(S-550 车①② 裁定,沿用)。
+ * wake 失败坏。
+ *
+ * ## 拒的**词** = core 的 `SessionError("corrupt_session")`(S-612,server 7.104.0)
+ * 写这段代码时 core 的 `SessionError` 闭集里还没有读侧的 corrupt 词(那时这里折成 `StoreCorruptError` / 更早是裸
+ * `Error`,点名 `<表>.<列>` + 行标识 —— S-550 车①② 裁定)。core 7.30.0(#1041)给文件会话店铸了
+ * `corrupt_session`(「这只会话的存储读不出,无法唤醒」),于是同一件事在三种会话后端上说了两种话:文件后端上 wire
+ * 是 500 `corrupt_session`,SQL 后端上是一只未分类的失败。⇒ 改抛**同一个词**;句子只留坐标(`<表>.<列>` + 会话 +
+ * 行号 + 坏体种别),不带这一行的内容、不含任何盘上路径(codex r1 [high]:修前的句子带着坏体的前 64 个字符)。失败方向不变:仍然**拒**,不跳过(SQL 行没有「撕裂」这种自然形,坏行 = 被篡改或迁移
+ * 事故;文件店「跳过坏记录、其余照回放」的那一半在这里不成立,契约附录里如实写两种后端的差别)。
+ * 映射到 wire 的唯一属主是 `src/session-error-wire.ts`。
+ * 🔴 `not-text`(读腿没按文本投影 = 本仓的码漂)**不折**:原样上抛 —— 判别与 `foldJsonColumn` 的是同一只谓词
+ * `isJsonColumnBodyProblem`,不另写一份。
  */
-import type { SessionTreeEntry } from "@sema-agent/core";
+import { type SessionTreeEntry } from "@sema-agent/core";
 import { type JsonColumnReader } from "./sql-json-column.js";
 /**
  * 形读者:core 自己声明的 `SessionTreeEntryBase` 里那两把**不可省**的串键。
@@ -32,6 +42,6 @@ import { type JsonColumnReader } from "./sql-json-column.js";
  * core 也没有导出 `SessionTreeEntry` 的验证器 —— `validateEntriesForImport` 吃的是已经成形的对象)。
  */
 export declare const readSessionEventPayload: JsonColumnReader<SessionTreeEntry>;
-/** 一格 `session_event.payload`(已按文本投影)→ 一条事件。坏体 ⇒ 响亮拒(见文件头注)。 */
+/** 一格 `session_event.payload`(已按文本投影)→ 一条事件。坏体 ⇒ 响亮拒 `SessionError("corrupt_session")`(见文件头注)。 */
 export declare function decodeSessionEventPayload(cell: unknown, sessionId: string, rowId: unknown): SessionTreeEntry;
 //# sourceMappingURL=session-event-payload.d.ts.map

package/dist/plugins/session-event-payload.js

@@ -1,4 +1,5 @@
-import { decodeJsonColumn, foldJsonColumn } from "./sql-json-column.js";
+import { SessionError } from "@sema-agent/core";
+import { decodeJsonColumn, isJsonColumnBodyProblem } from "./sql-json-column.js";
 export const readSessionEventPayload = (body) => {
     if (typeof body !== "object" || body === null || Array.isArray(body))
         return { problem: "expected a JSON object (a SessionTreeEntry)" };
@@ -14,7 +15,9 @@ export function decodeSessionEventPayload(cell, sessionId, rowId) {
         return decodeJsonColumn(cell, readSessionEventPayload, `session_event.payload for session ${sessionId} row ${String(rowId)}`);
     }
     catch (e) {
-        throw foldJsonColumn(e, (m) => `session storage: ${m} — refusing rather than wake a session from a tree with a node nobody can read`);
+        if (!isJsonColumnBodyProblem(e))
+            throw e;
+        throw new SessionError("corrupt_session", `session storage: ${e.where} is not a readable session entry (${e.problem}) — refusing rather than wake a session from a tree with a node nobody can read`, e);
     }
 }
 //# sourceMappingURL=session-event-payload.js.map

package/dist/plugins/session-policy-store-sql.js

@@ -22,18 +22,21 @@ function readRulesBody(text, where) {
         throw new SessionPolicyError("corrupt", `${e.message} — an unreadable rules body served as an EMPTY rule set would silently drop every tightening this session carries`);
     }
 }
+function isStoredCounter(n, floor) {
+    return Number.isSafeInteger(n) && n >= floor;
+}
 function rowToStored(r, where) {
     const rev = Number(r.rev);
-    if (!Number.isFinite(rev) || !Number.isInteger(rev) || rev < 1) {
-        throw new SessionPolicyError("corrupt", `session rules row ${where} carries rev ${String(r.rev)} — a stored row's rev is always ≥ 1 (the stamp is floor+1), and rev 0 is the live reader's synthetic empty seed; refusing rather than serve it as rules`);
+    if (!isStoredCounter(rev, 1)) {
+        throw new SessionPolicyError("corrupt", `session rules row ${where} carries rev ${String(r.rev)} — a stored row's rev is always a whole number ≥ 1 within the safe-integer range (the stamp is floor+1), and rev 0 is the live reader's synthetic empty seed; refusing rather than serve it as rules`);
     }
     if (r.gen === undefined || r.gen === null) {
         throw new Error(`session_policy row ${where} came back without a \`gen\` column — a read leg did not project it (the column is BIGINT NOT NULL on both dialects). ` +
             "Refusing rather than judge this row's lineage as generation 0, which is a value nothing minted.");
     }
     const gen = Number(r.gen);
-    if (!Number.isFinite(gen) || !Number.isInteger(gen) || gen < 0) {
-        throw new SessionPolicyError("corrupt", `session rules row ${where} carries lineage gen ${String(r.gen)} — a generation is a whole number ≥ 0; refusing rather than let a reader judge lineage by a value nothing minted`);
+    if (!isStoredCounter(gen, 0)) {
+        throw new SessionPolicyError("corrupt", `session rules row ${where} carries lineage gen ${String(r.gen)} — a generation is a whole number ≥ 0 within the safe-integer range; refusing rather than let a reader judge lineage by a value nothing minted`);
     }
     return { ...readRulesBody(r.rules, `session_policy.rules ${where}`), rev, gen };
 }
@@ -73,7 +76,7 @@ export class SqlSessionPolicyStore {
             const { rows: markRows } = await conn.query(this.q("SELECT rev, gen FROM session_policy_rev_mark WHERE policy_key = ? FOR UPDATE", "SELECT rev, gen FROM session_policy_rev_mark WHERE policy_key = $1 FOR UPDATE"), [key]);
             const markRev = markRows[0] ? Number(markRows[0].rev) : 0;
             const markGen = markRows[0] ? Number(markRows[0].gen) : 0;
-            if (markRows[0] !== undefined && (!Number.isInteger(markGen) || markGen < 0 || !Number.isFinite(markRev) || markRev < 0)) {
+            if (markRows[0] !== undefined && (!isStoredCounter(markGen, 0) || !isStoredCounter(markRev, 0))) {
                 throw new SessionPolicyError("corrupt", `the session rules rev mark for session ${JSON.stringify(sessionId)} is unreadable (rev ${String(markRows[0].rev)}, gen ${String(markRows[0].gen)}) — refusing rather than stamp a rev/lineage nothing proves`);
             }
             const clean = normalizeRules(stripRev(rules));
@@ -88,6 +91,9 @@ export class SqlSessionPolicyStore {
             }
             const nextRev = Math.max(priorRev, markRev) + 1;
             const nextGen = prior?.gen ?? markGen;
+            if (!isStoredCounter(nextRev, 1) || !isStoredCounter(nextGen, 0)) {
+                throw new SessionPolicyError("corrupt", `session rules for session ${JSON.stringify(sessionId)}: the next stamp (rev ${nextRev}, gen ${nextGen}) would leave the safe-integer range this store reads back — refusing before writing a row nothing could read`);
+            }
             const json = JSON.stringify(clean);
             const now = new Date();
             if (prior) {
@@ -121,6 +127,13 @@ export class SqlSessionPolicyStore {
             const now = new Date();
             const keys = rows.map((r) => String(r.policy_key));
             const params = [];
+            for (const r of rows) {
+                const rev = Number(r.rev);
+                const nextGen = Number(r.gen ?? 0) + 1;
+                if (!isStoredCounter(rev, 1) || !isStoredCounter(nextGen, 0)) {
+                    throw new SessionPolicyError("corrupt", `session rules row for session ${JSON.stringify(sessionId)} carries rev ${String(r.rev)} / gen ${String(r.gen)} — the erase would leave a mark outside the safe-integer range; refusing before writing it`);
+                }
+            }
             const tuples = rows.map((r) => {
                 params.push(String(r.policy_key), sessionId, Number(r.rev), Number(r.gen ?? 0) + 1, now);
                 const base = params.length - 5;

package/dist/plugins/store-backend.d.ts

@@ -44,9 +44,11 @@ export type { ApprovalNonceStore } from "./approval-nonce-store.js";
 /** [ref]([ref] v3.1 §3.0-§3.2 流内审批协议持久层):`ApprovalAskStore` 接口 + 行/补丁类型。
  *  车3 刀 3a 起 `StoreBackend.approvalAsk()` 已在(见接口体的那条注)。 */
 export type { ApprovalAskStore, AskRow, NewAskRow, AskTransitionPatch, DecideAskInput, DecideResult, ExpireResult, BindGateInput, BatchRow, AskDecision } from "./approval-ask-store-sql.js";
-/** E6 SessionPolicyStore — core's interface PLUS the service `deleteBySession` (E21 purge; only the durable twins carry
- *  it, core's InMemory omits it → optional). tidb/pg = durable twins; local = core's InMemorySessionPolicyStore (works
- *  local — rules need no cloud-only infra). The shared env-gated equivalence suite keeps the twins byte-matched to InMemory. */
+/** E6 SessionPolicyStore — core's interface, incl. its optional `deleteBySession` / `listBySession` seams (E21 purge / 2c
+ *  export; core's File and InMemory stores carry both since core 7.25.0 — S-546 A7 retired the service's own in-memory
+ *  twin that existed only because they once did not). tidb/pg = the SQL twin; local = core's FileSessionPolicyStore
+ *  (works local — rules need no cloud-only infra). The rev-line contract kit runs the SQL twin against core's InMemory
+ *  as oracle (`test/helpers/session-policy-rev-line-contract.ts`). */
 export type ServiceSessionPolicyStore = SessionPolicyStore;
 /** [ref] per-edited-file rewind FileHistoryStore — core's interface PLUS the service extras only the SQL twins
  *  carry (optional so the local lane's core `FileFileHistoryStore` still fits). Replaces the retired E19
@@ -192,7 +194,7 @@ export interface StoreBackend {
      *  mapping from URLs). REQUIRED on all backends (works local — one JSONL, like approvalExemption). */
     sendFileLedger(): SendFileLedger;
     /** E6 durable SessionPolicyStore (operator-tightened per-session tool rules). REQUIRED on all backends — works local
-     *  (local = core's InMemorySessionPolicyStore), like resumeAnchor. Backs core's RunnerDeps.sessionPolicyStore. */
+     *  (local = core's FileSessionPolicyStore), like resumeAnchor. Backs core's RunnerDeps.sessionPolicyStore. */
     sessionPolicy(): ServiceSessionPolicyStore;
     /** [ref] per-edited-file rewind FileHistoryStore (trackEdit/annulTrack/snapshot/restore over the tracked set;
      *  also the 2c history-transfer store). REQUIRED on all backends (local = core's file-backed
@@ -233,9 +235,13 @@ export interface StoreBackend {
      *  epoch is gone (its manifest index table retired with it), so EVERY row in that domain is an orphan and its
      *  BYTES (incl. MinIO objects) would otherwise outlive the epoch forever. SQL backends only; reaper-driven. */
     legacySnapshotBlobSweep?(): Promise<number>;
-    /** 🔴 **一次性迁移(随 7.75.0 连同 `one-time-migrations.ts` 一起从接口上删)** —— 本版三处退役落在
-     *  已写进库里的字节上,升一次级改完、兼容臂当场删干净(硬 breaking 纪律:持久数据面 = 响亮拒 +
-     *  一次性迁移,窗过即删,永不长期双读)。逐条语义、幂等与拒启臂见该模块头注。
+    /** 🔴 **一次性迁移** —— 落在已写进库里的字节上的退役,升一次级改完、兼容臂当场删干净(硬 breaking 纪律:持久数据面 =
+     *  响亮拒 + 一次性迁移,窗过即删,永不长期双读)。逐条语义、幂等与拒启臂见该模块头注。
+     *
+     *  **本成员什么时候删**(嵌入方按这里排期):每条迁移各有窗 —— 引入它的版本发布日 + 30 天,窗关之后的第一个 minor 删那一条
+     *  的码;逐条的日期只登记在 `plugins/one-time-migrations.ts` 的 `ONE_TIME_MIGRATIONS`(随包在
+     *  `dist/plugins/one-time-migrations.d.ts`),起动日志行 `one_time_migrations_applied` 的 `removableAfter` 读数同源。
+     *  **最后一条**删码时本成员随之从接口上删(硬 breaking:自建 `StoreBackend` 的实现方 tsc 红即通知)。
      *
      *  **必选,不是 optional**:漏实装一支后端 = 那条车道的存量字节永远停在旧读法上,而读腿已经只认新的
      *  ⇒ 必须是编译期错误,不是运行期的一次静默跳过。 */

package/dist/plugins/store-backend.js

@@ -13,6 +13,7 @@ import { buildStoreOpenRefusalTail } from "./store-open-refusal.js";
 import { acquireLocalBackendWithWait } from "./store-lock-wait.js";
 import { NO_SQL_MIGRATIONS, runSqlOneTimeMigrations } from "./one-time-migrations.js";
 import { LocalSessionStore } from "./local-session-store.js";
+import { noteReplayInSessionOpenScope } from "../session-records-skipped-notice.js";
 import { LocalCheckpointStore } from "./local-checkpoint-store.js";
 import { FileResumeAnchorStore } from "./file-resume-anchor-store.js";
 import { TiDBApprovalExemptionStore, PgApprovalExemptionStore, FileApprovalExemptionStore } from "./approval-exemption-store.js";
@@ -234,17 +235,19 @@ class LocalBackend {
                 (tail === undefined ? "" : ` ${tail}`));
         }
         this.sessionStore = new LocalSessionStore(new FileSessionRepo(this.fileBackend.root, {
-            onCorruptRead: createCorruptReadSeat((msg, fields) => this.discloseWarn(msg, fields), "session_repo_corrupt_read"),
+            onCorruptRead: createCorruptReadSeat((msg, fields) => this.discloseWarn(msg, fields), "session_repo_corrupt_read", undefined, noteReplayInSessionOpenScope),
         }), this.fileBackend.root);
+        const corruptReadWarn = (msg, fields) => this.discloseWarn(msg, fields);
         this.runStore = new FileRunStore(this.fileBackend.root, {
             error: (msg, fields) => void (this.onError ?? this.onWarn)?.(msg, fields),
             strictHydrate: config.runStoreStrictHydrate,
+            warn: corruptReadWarn,
         });
-        this.resumeAnchorStore = new FileResumeAnchorStore(this.fileBackend.root);
-        this.approvalExemptionStore = new FileApprovalExemptionStore(this.fileBackend.root);
-        this.approvalNonceStore = new FileApprovalNonceStore(this.fileBackend.root);
-        this.approvalAskStore = new FileApprovalAskStore(this.fileBackend.root);
-        this.sendFileLedgerStore = new FileSendFileLedger(this.fileBackend.root);
+        this.resumeAnchorStore = new FileResumeAnchorStore(this.fileBackend.root, { warn: corruptReadWarn });
+        this.approvalExemptionStore = new FileApprovalExemptionStore(this.fileBackend.root, { warn: corruptReadWarn });
+        this.approvalNonceStore = new FileApprovalNonceStore(this.fileBackend.root, { warn: corruptReadWarn });
+        this.approvalAskStore = new FileApprovalAskStore(this.fileBackend.root, { warn: corruptReadWarn });
+        this.sendFileLedgerStore = new FileSendFileLedger(this.fileBackend.root, { warn: corruptReadWarn });
         this.workflowJournalStore = new FileWorkflowJournalStore(this.fileBackend.root, undefined, {
             onCorruptRead: createCorruptReadSeat((msg, fields) => this.discloseWarn(msg, fields), "workflow_journal_corrupt_read"),
         });
@@ -280,6 +283,7 @@ class LocalBackend {
         if (!this.permissionRuleStoresInst) {
             this.permissionRuleStoresInst = createFilePermissionRuleStores(this.fileBackend.root, {
                 onError: (message) => this.onWarn?.("permission_rule_store_disclosure", { message }),
+                warn: (msg, fields) => this.discloseWarn(msg, fields),
             });
         }
         return this.permissionRuleStoresInst;

package/dist/plugins/store-contracts.d.ts

@@ -185,6 +185,11 @@ export declare const RUN_STATUS_CLASS: {
 export type UnsuccessfulRunStatus = {
     [K in RunRecord["status"]]: (typeof RUN_STATUS_CLASS)[K] extends "unsuccessful" ? K : never;
 }[RunRecord["status"]];
+/** 表判为「park」(停在门上)的词 —— **从表派生**,不是手抄的第二份清单。今天 = `"suspended" | "needs_review"`。
+ *  消费点(S-173:同步提交 200 体的 poll 回执 `status`,`http/sync-submit-body.ts`)拿它当型;表翻面 ⇒ 那里当场红。 */
+export type ParkedRunStatus = {
+    [K in RunRecord["status"]]: (typeof RUN_STATUS_CLASS)[K] extends "parked" ? K : never;
+}[RunRecord["status"]];
 /**
  * 一个状态词的类;**表里没有的词 ⇒ `undefined`**。
  *
@@ -318,8 +323,8 @@ export interface SessionSummary {
     /** K-5c (shell §K): the LATEST run's task_id — the anchor the shell uses to re-attach the live event tail in ONE
      *  hop (`GET /v1/runs/:lastRunId/events`) when resuming a picked session, instead of a second lookup. */
     lastRunId: string | null;
-    /** [ref]([ref]/[ref]):latest 终局 run 的 engine runId(`TaskResult.runId`,latest.result JSON 提取的
-     *  零迁移路线 —— result 终局才写 ⇒ 在跑 run 键诚实缺席);OMIT-when-absent,恒不铸 null。轴辨析与
+    /** [ref]([ref]/[ref]):latest run 的 engine runId(`TaskResult.runId`,latest.result JSON 提取的
+     *  零迁移路线 —— result 在终局与 park 时写、认领续跑即清空(S-173)⇒ 在跑 run 键诚实缺席);OMIT-when-absent,恒不铸 null。轴辨析与
      *  wire 半场见 `security.ts SessionListItem.lastTaskRunId`(同名同义)。 */
     lastTaskRunId?: string;
     /** The auto-generated session title (cheap-model one-liner, write-once). null = not (yet)

package/dist/plugins/tidb-pool.js

@@ -6,6 +6,7 @@ import { TIDB_LEADER_RUN_STATEMENTS } from "./leader-run-store-sql.js";
 import { TIDB_ADOPTION_LOG_STATEMENTS } from "./adoption-log-sql.js";
 import { TIDB_PERMISSION_RULE_STATEMENTS } from "./permission-rule-store-sql.js";
 import { TIDB_RETENTION_STATEMENTS } from "./retention-store-sql.js";
+import { SESSION_META_INCARNATION_COLUMN } from "../session-incarnation.js";
 import { ensureIndexes } from "./ensure-index.js";
 import { CENTRAL_SCHEMA_INDEXES } from "./schema-indexes.js";
 import { SESSION_INDEXES } from "./pg-session-storage.js";
@@ -75,6 +76,11 @@ export const SCHEMA_STATEMENTS = [
      placement_root_session_id   VARCHAR(190) NULL,
      placement_handle            VARCHAR(190) NULL,
      placed_at                   DATETIME(3)  NULL,
+     -- S-790 / S-506(design/330 §2):会话化身 —— 同一个会话 id 上**这一位住客**的不透明令牌。铸点只在新建行(register /
+     -- 无 id 创建 / fork / 导入新行),删除随行消失,同 id 重登记铸新的;'' = 没铸过,读口响亮拒。列定义的唯一属主 =
+     -- src/session-incarnation.ts 的 SESSION_META_INCARNATION_COLUMN(存量库由一次性迁移 M5 用同一串补列 + 回填)。
+     -- 不上 wire、不进模型上下文、日志只打前 8 位。
+     ${SESSION_META_INCARNATION_COLUMN.tidb},
      PRIMARY KEY (session_id),
      KEY idx_session_meta_owner (owner),
      -- listPlaced 的检索腿(kind + 租户 + 年龄升序);普通会话这三列全 NULL ⇒ 不占索引选择性。
@@ -261,8 +267,8 @@ export const SCHEMA_STATEMENTS = [
      bound_input_hash VARCHAR(190) NULL,
      -- 🔴 队列化之前的**单座**列 pending_steer 已**退役删列**:那个席位在引擎侧没了(core 7.17.0 #717 d
      -- 对带席的行 PRE-CAS 拒 seat_retired),留着一列没人读、没人写的字节只会让下一个人以为还有两种读法。
-     -- 存量库由启动期的一次性迁移处置(plugins/one-time-migrations.ts,随 7.75.0 删):列上还有非空值 ⇒
-     -- **响亮拒启**并给出两条出路(回 7.16.0 把那些 checkpoint resume 一次让座位排空 / 运维手工清列),
+     -- 存量库由启动期的一次性迁移处置(plugins/one-time-migrations.ts 的 M2,窗口见该文件登记表):列上还送得出去的格 ⇒
+     -- **响亮拒启**并给出两条出路(先在 server 7.73.x 上把那些 run 决掉或取消,让座位送达 / 运维手工清列),
      -- 清空之后 DROP COLUMN。刻意**不**自动把裸单座折进队列:那等于本仓替引擎铸一条它从没写过的队列条目。
      -- pending_steer_queue:core 5.14.0(#147)的**有界有序队列**(PendingSteerEntry[] 的 JSON),现在是本表上
      -- durable steering 的唯一载体。Never touches status/resolve (design/80 inv #4)。
@@ -381,8 +387,8 @@ export const SCHEMA_STATEMENTS = [
    ) COLLATE utf8mb4_bin`,
     `CREATE TABLE IF NOT EXISTS session_policy_rev_mark (
      policy_key CHAR(64)     NOT NULL,
-     -- 被删会话。记号的读写一律按 policy_key 单键;这一列是**运维可读性 + 未来按会话/按龄回收**的那条腿
-     -- 的抓手(今天没有任何生产查询按它选行 —— 留存腿与收编腿都不碰本表,理由见上面那段)。
+     -- 被删会话(**明文**会话 id —— 所以它必须随会话一起走,见上)。记号的读写按 policy_key 单键;托管留存的整树
+     -- 清扫按本列删(S-546 A9,索引 idx_session_policy_rev_mark_session)。
      session_id VARCHAR(64)  NOT NULL,
      -- 抹除时刻该键带过的最高 rev(GREATEST 合并:记号只升不降)。
      rev        BIGINT       NOT NULL,
@@ -391,7 +397,8 @@ export const SCHEMA_STATEMENTS = [
      -- DEFAULT 0 = 本列到货前落下的记号(那些键的行也都是第 0 代 ⇒ 下一次抹除把它们抬到 1,前后自洽)。
      gen        BIGINT       NOT NULL DEFAULT 0,
      erased_at  DATETIME(3)  NOT NULL,
-     PRIMARY KEY (policy_key)
+     PRIMARY KEY (policy_key),
+     KEY idx_session_policy_rev_mark_session (session_id)
    ) COLLATE utf8mb4_bin`,
     `CREATE TABLE IF NOT EXISTS snapshot_blob (
      blob_hash  CHAR(64)    NOT NULL,

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

@@ -13,6 +13,7 @@
 import { type AcquiredSession, type PlacedSessionRow, type SessionPlacement, type SessionPlacementRecord, type SessionStore, type SessionTreeEntry } from "@sema-agent/core";
 import type { Pool } from "mysql2/promise";
 import { type InstructionSourceBaseline } from "../instruction-source-notice.js";
+import { type SessionFace } from "../session-incarnation.js";
 import type { SessionSummary } from "./store-contracts.js";
 import { type PlacementAcquireOpts } from "./session-placement.js";
 import { type StagingHandle } from "../session-sync-kernel.js";
@@ -36,7 +37,8 @@ export declare class TiDBSessionStore implements SessionStore {
     private load;
     /** Idempotently create a session_meta row with an owner. Existing owner is never overwritten.
      *  [ref]:`placement` 在场时与行同一条 INSERT 落六列;ON DUPLICATE 臂是 no-op ⇒ 已存在的行的元组
-     *  **永不被重写**(first-write 不可变,义务 5 的写侧半场)。 */
+     *  **永不被重写**(first-write 不可变,义务 5 的写侧半场)。
+     *  S-790:化身与属主同一条 first-write 律 —— 新行铸一只(`mintSessionIncarnation`),已存在的行 no-op 臂一个字节不动。 */
     register(sessionId: string, owner: string | null, placement?: SessionPlacement): Promise<void>;
     /**
      * [ref] 义务 6 的廉价探针 —— 一行 PK SELECT:`undefined` = 普通会话或无此行。
@@ -57,6 +59,9 @@ export declare class TiDBSessionStore implements SessionStore {
     }): Promise<PlacedSessionRow[]>;
     /** Owner principal of a session, `null` if registered ownerless, `undefined` if no such session. */
     ownerOf(sessionId: string): Promise<string | null | undefined>;
+    /** S-790:属主 + 化身**一次读**(单行单 SELECT —— 两次独立读在删除 / 重登记的缝里能拼出混世代组合)。`undefined` = 无此会话;
+     *  行在而化身为空 ⇒ `SessionIncarnationMissingError`(响亮拒,判据唯一属主 `sessionFaceFromRow`)。 */
+    sessionFaceOf(sessionId: string): Promise<SessionFace | undefined>;
     touch(sessionId: string): Promise<void>;
     /** E18 — the session's current leaf `SessionTreeEntry.id` (`session_meta.leaf_id`, set transactionally on every
      *  persist). A single SELECT, NO acquire/lock/CAS — safe to call mid-run (write-safety is the append-time CAS, not