@sema-agent/server 7.147.0 → 7.149.0

package/dist/stores-sql/session-policy-store-sql.d.ts

@@ -2,7 +2,7 @@ import { type SessionPolicyStore, type SessionPermissionRules, type StoredSessio
 import type { Pool as MySqlPool } from "mysql2/promise";
 import type { Pool as PgPool } from "pg";
 import { type JsonColumnShape } from "../plugins/sql-json-column.js";
-import { type SqlDriver } from "../plugins/sql-driver.js";
+import { type SqlDialect, type SqlDriver, type SqlTxConn } from "../plugins/sql-driver.js";
 /** `session_policy.policy_key` 的**唯一铸造点**(core 复合键的 sha256)。
  *
  *  🔴 导出而不是让收编腿再抄一份(clay 宪法「schema 单一属主禁复制」):[ref] form b 的身份重绑要
@@ -44,16 +44,38 @@ export type StoredSessionRulesBody = SessionPermissionRules & Pick<StoredSession
  * + 恰好解一次 `decodeJsonColumn` + 折码 `foldJsonColumn`);本店只留「形判据是哪一只」与「坏体折成哪个码」。
  */
 export declare function readSessionRulesBody(body: unknown): JsonColumnShape<StoredSessionRulesBody>;
-/** 本店唯一的日志口:抹除封键那一臂([ref])的点名。缺席 ⇒ 退回 `console.warn`(不静默)。
- *  结构型,与服务日志口的 `warn` 逐位同形:本目录对服务的观测模块零依赖(目录的可搬性),服务的日志口照样直接交进来。 */
+/** 封键的 warn 事件名(提交后每次抹除至多一条,点名会话与被封的键)。 */
+export declare const SEALED_EVENT = "session_policy_erase_sealed_keys";
+/** 一把被封的键:单向哈希的键 + 那一行读不出的两个计数的原文(取证用;不带 principal 明文、不带规则体)。 */
+export type SealedEraseKey = {
+    readonly policyKey: string;
+    readonly rev: string;
+    readonly gen: string;
+};
+/** 本店的日志口:抹除封键那一臂([ref])的点名。**必填**:组合座(`store-backend.ts`)交服务的日志口,没有自己的就交日志出口接缝的
+ *  缺省 logger —— 本目录不碰 stdio(目录的可搬性;进程 stdout / stderr 只有接缝一个出口,`test/log-exit-single-source-gate.test.ts`)。
+ *  结构型,与服务日志口的 `warn` 逐位同形,服务的日志口照样直接交进来。注入的这只抛 ⇒ 同一行落接缝的缺省 logger(见 `discloseSealed`)。 */
 export type SessionPolicyStoreLogger = {
     warn(msg: string, fields?: Record<string, unknown>): void;
 };
+/**
+ * 一次客户端写的计数(部署的格:会话规则是客户端可见的会话态,提交出口撤回一只刚铸的会话之前读这只计数)。组合座交入;店只在锁住根行、根行在、
+ * 所有拒判之后、规则落行之前,同一事务、同一连接调它一次 —— 计数住部署的旁表,店目录不认识那张表。
+ */
+export type SessionClientWriteCounter = (conn: SqlTxConn, dialect: SqlDriver["dialect"], sessionId: string) => Promise<void>;
+/**
+ * 按会话抹除规则行的**唯一语句源**(店的 `deleteBySession` 在自己的事务里调;会话删除执行体 `retention-store-sql.ts` 在会话树事务里对一批会话调 ——
+ * 同一组语句,`session_policy_rev_mark` 的高水位律只写这一处,core 契约 `session_policy.rev_survives_delete`)。调用方持事务。
+ * 步序:锁这批会话的规则行(`policy_key` 升序,与 `putRules` 同向)→ 每把键写记号(rev 高水位 + 下一代 `gen`;读不出计数的行写封键)→ 删规则行。
+ * 返回封键(调用方负责响亮披露)。没有规则行 ⇒ 零写。
+ */
+export declare function eraseSessionPolicyRowsOn(conn: Pick<SqlTxConn, "query">, dialect: SqlDialect, sessionIds: readonly string[]): Promise<readonly SealedEraseKey[]>;
 /** Dual-dialect durable SessionPolicyStore. See the file header for the dialect-delta ledger. */
 export declare class SqlSessionPolicyStore implements SessionPolicyStore {
     private readonly db;
-    private readonly logger?;
-    constructor(db: SqlDriver, logger?: SessionPolicyStoreLogger | undefined);
+    private readonly countClientWrite;
+    private readonly logger;
+    constructor(db: SqlDriver, countClientWrite: SessionClientWriteCounter, logger: SessionPolicyStoreLogger);
     /** Pick the dialect's SQL text. Both statements stay written out at the call site ON PURPOSE. */
     private q;
     /** 判据属主 = `sql-errors.ts`([ref] P1-①;本站点旧形已是并集形,收编后语义不变)。 */
@@ -143,9 +165,9 @@ export declare class SqlSessionPolicyStore implements SessionPolicyStore {
      *  (驱动错误;那只记号本来就读不回,`putRules` 同样拒)—— 抹除不读记号,这一形不在本判词射程内。 */
     deleteBySession(sessionId: string): Promise<void>;
     /**
-     * [ref] 封键的响亮面:一次抹除至多一条 warn。日志座**抛** ⇒ 退回 `console.warn` 带原句 —— 走到这里删除已经提交,
-     * 一次日志故障不许把它报成失败(E21 会因此 500、overwrite-dst 会因此中止;codex 7.105.0 修复验证轮 [medium] 同形)。
-     * 缺日志座(直接 `new` 本店的工具 / 测试)⇒ `console.warn`,不静默。
+     * [ref] 封键的响亮面:一次抹除至多一条 warn。走到这里删除已经提交,一次日志故障不许把它报成失败(E21 会因此 500、
+     * overwrite-dst 会因此中止;codex 7.105.0 修复验证轮 [medium] 同形)⇒ 日志座抛不往外抛;**也不吞披露**:同一行落日志出口接缝的
+     * 缺省 logger(与数据根权限收紧的披露座同一条律:披露不许因日志座坏而消失)—— 运维面对一把读写都拒的封键,要靠这一行知道为什么。
      */
     private discloseSealed;
     /**
@@ -161,10 +183,10 @@ export declare class SqlSessionPolicyStore implements SessionPolicyStore {
 }
 /** MySQL-protocol (TiDB) binding — historical class name + ctor shape preserved. */
 export declare class TiDBSessionPolicyStore extends SqlSessionPolicyStore {
-    constructor(pool: MySqlPool, logger?: SessionPolicyStoreLogger);
+    constructor(pool: MySqlPool, countClientWrite: SessionClientWriteCounter, logger: SessionPolicyStoreLogger);
 }
 /** PostgreSQL binding — historical class name + ctor shape preserved. */
 export declare class PgSessionPolicyStore extends SqlSessionPolicyStore {
-    constructor(pool: PgPool, logger?: SessionPolicyStoreLogger);
+    constructor(pool: PgPool, countClientWrite: SessionClientWriteCounter, logger: SessionPolicyStoreLogger);
 }
 //# sourceMappingURL=session-policy-store-sql.d.ts.map

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

@@ -5,6 +5,7 @@ import { decodeJsonColumn, isJsonColumnBodyProblem, jsonColumnText } from "../pl
 import { pgHasUnstorable } from "../plugins/pg-safe-json.js";
 import { mysqlDriver, pgDriver } from "../plugins/sql-driver.js";
 import { isDupKeyError, retryOnDeadlock } from "../plugins/sql-errors.js";
+import { createLogger } from "../observability/logger.js";
 export const policyKeyFor = (sessionId, principal) => createHash("sha256").update(JSON.stringify([sessionId, principal ?? null])).digest("hex");
 const policyKey = policyKeyFor;
 const RULES = SESSION_RULES_COLUMN.name;
@@ -50,16 +51,47 @@ function readRowCounters(r, where) {
     return { rev, gen };
 }
 const SEALED_MARK_REV = Number.MAX_SAFE_INTEGER;
-const SEALED_EVENT = "session_policy_erase_sealed_keys";
+export const SEALED_EVENT = "session_policy_erase_sealed_keys";
 const NO_SEALED_KEYS = [];
 function sealedKeyError(sessionId, what) {
     return new SessionPolicyError("corrupt", `session rules for session ${JSON.stringify(sessionId)}: ${what} is sealed — an erase removed a row whose counters were unreadable (session_policy_rev_mark.rev = ${SEALED_MARK_REV}), so its rule state is unknown; refusing rather than serve it as "no rules" until an operator unseals it (USAGE §9.11)`);
 }
+export async function eraseSessionPolicyRowsOn(conn, dialect, sessionIds) {
+    if (sessionIds.length === 0)
+        return NO_SEALED_KEYS;
+    const q = (mysql, pg) => (dialect === "mysql" ? mysql : pg);
+    const idHoles = sessionIds.map((_, i) => (dialect === "mysql" ? "?" : `$${i + 1}`)).join(",");
+    const { rows } = await conn.query(`SELECT policy_key, session_id, rev, gen FROM session_policy WHERE session_id IN (${idHoles}) ORDER BY policy_key FOR UPDATE`, [...sessionIds]);
+    if (rows.length === 0)
+        return NO_SEALED_KEYS;
+    const now = new Date();
+    const keys = rows.map((r) => String(r.policy_key));
+    const params = [];
+    const sealedKeys = [];
+    const tuples = rows.map((r) => {
+        const sessionId = String(r.session_id);
+        const counters = readRowCounters(r, `for session ${JSON.stringify(sessionId)} (erase)`);
+        const readable = !("problem" in counters) && isStoredCounter(counters.gen + 1, 0);
+        if (!readable)
+            sealedKeys.push({ policyKey: String(r.policy_key), rev: String(r.rev), gen: String(r.gen) });
+        params.push(String(r.policy_key), sessionId, readable ? counters.rev : SEALED_MARK_REV, readable ? counters.gen + 1 : 0, now);
+        const base = params.length - 5;
+        return dialect === "mysql" ? "(?,?,?,?,?)" : `($${base + 1},$${base + 2},$${base + 3},$${base + 4},$${base + 5})`;
+    });
+    await conn.query(q(`INSERT INTO session_policy_rev_mark (policy_key, session_id, rev, gen, erased_at) VALUES ${tuples.join(",")}` +
+        " ON DUPLICATE KEY UPDATE rev = GREATEST(session_policy_rev_mark.rev, VALUES(rev)), gen = GREATEST(session_policy_rev_mark.gen + 1, VALUES(gen)), erased_at = VALUES(erased_at)", `INSERT INTO session_policy_rev_mark (policy_key, session_id, rev, gen, erased_at) VALUES ${tuples.join(",")}` +
+        " ON CONFLICT (policy_key) DO UPDATE SET rev = GREATEST(session_policy_rev_mark.rev, EXCLUDED.rev), gen = GREATEST(session_policy_rev_mark.gen + 1, EXCLUDED.gen), erased_at = EXCLUDED.erased_at"), params);
+    const holes = keys.map((_, i) => (dialect === "mysql" ? "?" : `$${i + 1}`)).join(",");
+    await conn.query(`DELETE FROM session_policy WHERE policy_key IN (${holes})`, keys);
+    return sealedKeys;
+}
 export class SqlSessionPolicyStore {
     db;
+    countClientWrite;
     logger;
-    constructor(db, logger) {
+    constructor(db, countClientWrite, logger) {
         this.db = db;
+        this.countClientWrite = countClientWrite;
         this.logger = logger;
     }
     q(mysql, pg) {
@@ -94,6 +126,7 @@ export class SqlSessionPolicyStore {
     async putRules(sessionId, principal, rules, opts) {
         const key = policyKey(sessionId, principal);
         return this.retrying(() => this.tx(async (conn) => {
+            const root = await conn.query(this.q("SELECT session_id FROM session_meta WHERE session_id = ? FOR UPDATE", "SELECT session_id FROM session_meta WHERE session_id = $1 FOR UPDATE"), [sessionId]);
             const { rows } = await conn.query(this.q(`SELECT ${jsonColumnText("mysql", RULES)}, rev, gen FROM session_policy WHERE policy_key = ? FOR UPDATE`, `SELECT ${jsonColumnText("pg", RULES)}, rev, gen FROM session_policy WHERE policy_key = $1 FOR UPDATE`), [key]);
             const prior = rows[0] ? rowToStored(rows[0], `for session ${JSON.stringify(sessionId)} (pre-write snapshot)`) : undefined;
             const priorRev = prior?.rev ?? 0;
@@ -115,6 +148,8 @@ export class SqlSessionPolicyStore {
             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`);
             }
+            if (root.rows.length > 0)
+                await this.countClientWrite(conn, this.db.dialect, sessionId);
             const json = JSON.stringify(clean);
             const now = new Date();
             if (prior) {
@@ -132,30 +167,7 @@ export class SqlSessionPolicyStore {
         return retryOnDeadlock(this.db.dialect, attempt, (e) => this.isDupKey(e));
     }
     async deleteBySession(sessionId) {
-        const sealed = await this.retrying(() => this.tx(async (conn) => {
-            const { rows } = await conn.query(this.q("SELECT policy_key, rev, gen FROM session_policy WHERE session_id = ? ORDER BY policy_key FOR UPDATE", "SELECT policy_key, rev, gen FROM session_policy WHERE session_id = $1 ORDER BY policy_key FOR UPDATE"), [sessionId]);
-            if (rows.length === 0)
-                return NO_SEALED_KEYS;
-            const now = new Date();
-            const keys = rows.map((r) => String(r.policy_key));
-            const params = [];
-            const sealedKeys = [];
-            const tuples = rows.map((r) => {
-                const counters = readRowCounters(r, `for session ${JSON.stringify(sessionId)} (erase)`);
-                const readable = !("problem" in counters) && isStoredCounter(counters.gen + 1, 0);
-                if (!readable)
-                    sealedKeys.push({ policyKey: String(r.policy_key), rev: String(r.rev), gen: String(r.gen) });
-                params.push(String(r.policy_key), sessionId, readable ? counters.rev : SEALED_MARK_REV, readable ? counters.gen + 1 : 0, now);
-                const base = params.length - 5;
-                return this.db.dialect === "mysql" ? "(?,?,?,?,?)" : `($${base + 1},$${base + 2},$${base + 3},$${base + 4},$${base + 5})`;
-            });
-            await conn.query(this.q(`INSERT INTO session_policy_rev_mark (policy_key, session_id, rev, gen, erased_at) VALUES ${tuples.join(",")}` +
-                " ON DUPLICATE KEY UPDATE rev = GREATEST(session_policy_rev_mark.rev, VALUES(rev)), gen = GREATEST(session_policy_rev_mark.gen + 1, VALUES(gen)), erased_at = VALUES(erased_at)", `INSERT INTO session_policy_rev_mark (policy_key, session_id, rev, gen, erased_at) VALUES ${tuples.join(",")}` +
-                " ON CONFLICT (policy_key) DO UPDATE SET rev = GREATEST(session_policy_rev_mark.rev, EXCLUDED.rev), gen = GREATEST(session_policy_rev_mark.gen + 1, EXCLUDED.gen), erased_at = EXCLUDED.erased_at"), params);
-            const holes = keys.map((_, i) => (this.db.dialect === "mysql" ? "?" : `$${i + 1}`)).join(",");
-            await conn.query(`DELETE FROM session_policy WHERE policy_key IN (${holes})`, keys);
-            return sealedKeys;
-        }));
+        const sealed = await this.retrying(() => this.tx((conn) => eraseSessionPolicyRowsOn(conn, this.db.dialect, [sessionId])));
         if (sealed.length > 0)
             this.discloseSealed(sessionId, sealed);
     }
@@ -165,15 +177,11 @@ export class SqlSessionPolicyStore {
             keys,
             note: "these rows' counters were unreadable, so the erase could not end their lineage: each key now carries a sealed rev mark and answers every read and write with SessionPolicyError corrupt until an operator unseals its session_policy_rev_mark row in place (USAGE §9.11)",
         };
-        if (this.logger === undefined) {
-            console.warn(`[session-policy] ${SEALED_EVENT}`, fields);
-            return;
-        }
         try {
             this.logger.warn(SEALED_EVENT, fields);
         }
-        catch (err) {
-            console.warn(`[session-policy] ${SEALED_EVENT} — the injected logger threw (${err instanceof Error ? err.message : String(err)})`, fields);
+        catch {
+            createLogger().warn(SEALED_EVENT, fields);
         }
     }
     async tx(fn) {
@@ -198,13 +206,13 @@ export class SqlSessionPolicyStore {
     }
 }
 export class TiDBSessionPolicyStore extends SqlSessionPolicyStore {
-    constructor(pool, logger) {
-        super(mysqlDriver(pool), logger);
+    constructor(pool, countClientWrite, logger) {
+        super(mysqlDriver(pool), countClientWrite, logger);
     }
 }
 export class PgSessionPolicyStore extends SqlSessionPolicyStore {
-    constructor(pool, logger) {
-        super(pgDriver(pool), logger);
+    constructor(pool, countClientWrite, logger) {
+        super(pgDriver(pool), countClientWrite, logger);
     }
 }
 //# sourceMappingURL=session-policy-store-sql.js.map

package/dist/stores-sql/session-write-hooks.d.ts

@@ -4,7 +4,7 @@
  *
  * ## 形 = 引擎 SQL 店包的钩表(`@sema-agent/core-stores-sql` 的 `SqlTransactionHooks.session.beforeCommit`)
  * {@link SessionWriteHooks.beforeCommit} 与包里那一只同名、同调用时刻(根行锁住之后、写之前)、同语句面(本事务连接的 `query`)、同写闭集
- * (`import` / `delete` / `retention-delete`)。本仓还不依赖那只包 ⇒ 型在这里声明;店随包搬家时改从包根取型。与包的形只差一处,是向引擎的请托:
+ * (`import` / `delete` / `retention-delete`;本服务另加 `erase`)。本仓还不依赖那只包 ⇒ 型在这里声明;店随包搬家时改从包根取型。与包的形只差一处,是向引擎的请托:
  * 拒的载荷 —— 包里是一句话(`{ refuse: string }`),这里是部署的具名错误(`{ refuse: Error }`):导入 / 删除的调用方按错误的型答各自的 wire 码
  * (409 `session_active` / `conflict.session_writer`),一句话答不出。
  *
@@ -25,15 +25,21 @@ export interface SessionTxStatements {
     }>;
 }
 /**
- * 改动会话树根的写(闭集,与包同一组词):
+ * 改动会话树根的写(闭集;前三个词与包同一组,`erase` 是本服务的扩展 —— 向引擎的请托同上):
  *  · `import` —— 导入写口(整段新建、整段换装、暂存提交)落定这一行:根行已被本事务锁住 / 占下;
- *  · `delete` —— 属主删除:根行已被本事务锁住;
- *  · `retention-delete` —— 留存删除一棵会话树的根(留存座的事务;根行已锁)。
+ *  · `delete` —— 不经删除协调器的删一行(提交出口的条件撤回):根行已被本事务锁住;
+ *  · `retention-delete` —— 留存删除一棵会话树的根(留存座的事务;根行已锁);
+ *  · `erase` —— 删净一只在删会话(执行器 `stores-sql/retention-store-sql.ts` 的 `eraseSession`,删除协调器的执行体):这一行必须处于 `token` 那一次删除的在删态
+ *    (会话三态 活 → 在删 → 没了,围栏在 `plugins/session-store-sql.ts` 的删除面);根行已被本事务锁住。
  */
-export interface SessionWrite {
+export type SessionWrite = {
     readonly op: "import" | "delete" | "retention-delete";
     readonly rootSessionId: string;
-}
+} | {
+    readonly op: "erase";
+    readonly rootSessionId: string;
+    readonly token: string;
+};
 /** 钩的答案:放行,或拒(店回滚、一个字节不写、原样抛这只错)。 */
 export type SessionWriteVerdict = "proceed" | {
     readonly refuse: Error;

package/dist/stores-sql/tidb-session-storage.d.ts

@@ -3,7 +3,6 @@ import type { Pool } from "mysql2/promise";
 import { WindowedSessionStorage } from "./windowed-session-storage.js";
 export declare const SESSION_EVENT_LATEST_BY_TYPE_SQL: {
     readonly floor: `SELECT /*+ USE_INDEX(session_event, idx_session_event_type) */ ${string} FROM session_event WHERE session_id = ? AND type = 'compaction' ORDER BY seq DESC LIMIT 1`;
-    readonly epochAnchor: `SELECT /*+ USE_INDEX(session_event, idx_session_event_type) */ seq, ${string} FROM session_event WHERE session_id = ? AND seq < ? AND type IN ('prompt_epoch','compaction') ORDER BY seq DESC LIMIT 100`;
 };
 /**
  * TiDB-backed session storage — the durable L1 event log for one session (the window view and its reads: {@link WindowedSessionStorage}).
@@ -25,12 +24,13 @@ export declare class TiDBSessionStorage extends WindowedSessionStorage {
     private readonly floorSeq;
     constructor(pool: Pool, sessionId: string, metadata: SessionMetadata, entries: SessionTreeEntry[], leafId: string | null, floorEntryId?: string | null, floorSeq?: number);
     /**
-     * [ref] S3 [ref] pull seam — `SessionStorage.getEpochAnchor?()`: the nearest prompt-epoch carrier BELOW the
+     * [ref] S3 [ref] pull seam — `SessionStorage.getEpochAnchor?()`: the nearest prompt-epoch carrier on the branch BELOW the
      * bounded-wake floor, AS STORED (engine 7.52.0: `Promise<unknown>`; the engine reads the record, a retired shape
      * included). The engine's `Session.getPromptEpoch()` asks for it only when the in-window branch walk finds no carrier
      * (a rewind/resumeAt cut inside the kept tail; compactions without a restatement). The one reading of every windowed
-     * storage (both SQL twins, the local leg's view window) is {@link scanEpochAnchor}; this backend supplies its page query
-     * (keyset-paged to exhaustion) and decodes its own rows.
+     * storage (both SQL twins, the local leg's view window) is {@link scanEpochAnchor} — it walks the floor entry's parent
+     * chain, not the row order; this backend supplies the twins' page ({@link epochAnchorPageSql}, keyset-paged to
+     * exhaustion) and decodes its own carrier rows.
      */
     getEpochAnchor(): Promise<unknown>;
     /**

package/dist/stores-sql/tidb-session-storage.js

@@ -4,14 +4,13 @@ import { toIso } from "../plugins/sql-row-helpers.js";
 import { isMysqlDupKeyError } from "../plugins/sql-errors.js";
 import { PLACEMENT_SELECT_COLUMNS, placementFromRow } from "../plugins/session-placement.js";
 import { decodeSessionEventPayload } from "./session-event-payload.js";
-import { scanEpochAnchor } from "../plugins/session-epoch-anchor.js";
+import { epochAnchorPageSql, epochFloorOf, scanEpochAnchor, sqlEpochAnchorRowOf } from "../plugins/session-epoch-anchor.js";
 import { jsonColumnText } from "../plugins/sql-json-column.js";
-import { incarnationFromCell } from "../session-incarnation.js";
+import { forkLineageOfRow, incarnationFromCell } from "../session-incarnation.js";
 import { WindowedSessionStorage } from "./windowed-session-storage.js";
 const SESSION_EVENT_BY_TYPE_HINT = "/*+ USE_INDEX(session_event, idx_session_event_type) */";
 export const SESSION_EVENT_LATEST_BY_TYPE_SQL = {
     floor: `SELECT ${SESSION_EVENT_BY_TYPE_HINT} ${jsonColumnText("mysql", "payload")} FROM session_event WHERE session_id = ? AND type = 'compaction' ORDER BY seq DESC LIMIT 1`,
-    epochAnchor: `SELECT ${SESSION_EVENT_BY_TYPE_HINT} seq, ${jsonColumnText("mysql", "payload")} FROM session_event WHERE session_id = ? AND seq < ? AND type IN ('prompt_epoch','compaction') ORDER BY seq DESC LIMIT 100`,
 };
 const isDupKey = isMysqlDupKeyError;
 export class TiDBSessionStorage extends WindowedSessionStorage {
@@ -25,13 +24,13 @@ export class TiDBSessionStorage extends WindowedSessionStorage {
         this.floorSeq = floorSeq;
     }
     async getEpochAnchor() {
-        return scanEpochAnchor(this.floorSeq, async (beforeSeq) => {
-            const [rows] = await this.pool.query(SESSION_EVENT_LATEST_BY_TYPE_SQL.epochAnchor, [this.sessionId, beforeSeq]);
-            return rows.map((r) => ({ seq: r.seq, payload: r.payload }));
+        return scanEpochAnchor(epochFloorOf(this.floorSeq, await this.windowFloorEntry()), async (beforeSeq) => {
+            const [rows] = await this.pool.query(epochAnchorPageSql("mysql"), [this.sessionId, beforeSeq]);
+            return rows.map(sqlEpochAnchorRowOf);
         }, (row) => decodeSessionEventPayload(row.payload, this.sessionId, row.seq));
     }
     static async wake(pool, sessionId) {
-        const [metaRows] = await pool.query(`SELECT created_at, leaf_id, leaf_seq, incarnation, ${PLACEMENT_SELECT_COLUMNS} FROM session_meta WHERE session_id = ?`, [sessionId]);
+        const [metaRows] = await pool.query(`SELECT created_at, leaf_id, leaf_seq, incarnation, ${PLACEMENT_SELECT_COLUMNS}, forked_from, forked_from_incarnation FROM session_meta WHERE session_id = ?`, [sessionId]);
         const meta = metaRows[0];
         if (!meta)
             return null;
@@ -39,7 +38,13 @@ export class TiDBSessionStorage extends WindowedSessionStorage {
         const [eventRows] = await pool.query(`SELECT seq, ${jsonColumnText("mysql", "payload")} FROM session_event WHERE session_id = ? AND seq >= ? ORDER BY seq ASC`, [sessionId, floorSeq]);
         const entries = eventRows.map((r) => decodeSessionEventPayload(r.payload, sessionId, r.seq));
         const placement = placementFromRow(meta);
-        const metadata = { id: sessionId, createdAt: toIso(meta.created_at), incarnation: incarnationFromCell(sessionId, meta.incarnation), ...(placement !== undefined ? { placement } : {}) };
+        const metadata = {
+            id: sessionId,
+            createdAt: toIso(meta.created_at),
+            incarnation: incarnationFromCell(sessionId, meta.incarnation),
+            ...(placement !== undefined ? { placement } : {}),
+            ...forkLineageOfRow(sessionId, meta.forked_from, meta.forked_from_incarnation),
+        };
         return new TiDBSessionStorage(pool, sessionId, metadata, entries, meta.leaf_id ?? null, floorEntryId, floorSeq);
     }
     static async computeFloor(pool, sessionId) {

package/dist/stores-sql/tidb-session-store.d.ts

@@ -13,10 +13,36 @@
 import { type AcquiredSession, type PlacedSessionRow, type SessionHead, type SessionPlacementRecord, type SessionStore, type SessionTreeEntry } from "@sema-agent/core";
 import type { Pool } from "mysql2/promise";
 import type { RetentionDeclaration } from "@sema-agent/core";
-import type { SessionWriteHooks } from "./session-write-hooks.js";
+import { type RegisterReceipt, type WithdrawJudgeVerdict, type WithdrawOutcome } from "../session-incarnation.js";
+import type { SessionTxStatements, SessionWriteHooks } from "./session-write-hooks.js";
 import { type PlacementAcquireOpts } from "../plugins/session-placement.js";
 import { type StagingHandle } from "../session-sync-kernel.js";
 import { type ForkPlacement, type ForkTarget, type ForkToOutcome } from "../plugins/session-fork.js";
+/**
+ * **条件撤回的店那一半**(两方言一形;TiDB 孪生与 PG 孪生 `pg-session-storage.ts` 同调;撤回的规则在 `plugins/session-birth.ts` 头注)。
+ * 店拿根行、化身、内容、认领;部署交入的条件({@link SessionDeleteCondition})带可撤条目型名单与部署判据(启用标记、客户端写计数、别的 run、本次 run 的部署行),
+ * 判据跑在**同一事务、同一连接**的语句面上。每一读都是锁定读(`FOR UPDATE`):TiDB 悲观事务里普通 SELECT 读的是事务开始时的快照,
+ * 等根锁期间别人提交的写(导入的内容、计数 +1、新 run 行)它看不到 —— 锁定读是当前读;PG 读已提交下每一句新快照,同一形照写。
+ */
+export interface SessionDeleteCondition {
+    /** 候选那一位(这一笔 INSERT 铸下的属主 + 化身)。 */
+    readonly expect: {
+        readonly owner: string | null;
+        readonly incarnation: string;
+    };
+    /** 可撤集合 A 组的条目型(部署交入;名单的唯一属主在部署,店只拿它做锁定读的 `NOT IN`)。 */
+    readonly withdrawableEntryTypes: readonly string[];
+    /** 部署判据(同一语句面;放行时已在同一事务里删掉本次 run 的部署行)。 */
+    readonly judge: (tx: SessionTxStatements) => Promise<WithdrawJudgeVerdict>;
+}
+/** 两孪生的方言词(店只用它挑占位符形)。 */
+type WithdrawDialect = "mysql" | "pg";
+/**
+ * 店的那一半(调用方已开事务、持着这只连接;答 `withdrawn` ⇒ 调用方提交,否则回滚):
+ * 锁根行 → 不在 ⇒ `absent`;属主 / 化身不是候选 ⇒ `incarnation` → 锁定读一条可撤集合之外的会话条目 ⇒ `content` → 部署钩 `delete` 臂(认领在 ⇒ 拒)⇒ `claim`
+ * → 部署判据 → 删会话条目 + 按化身删根行(旁表随外键级联)。
+ */
+export declare function withdrawSessionOn(tx: SessionTxStatements, dialect: WithdrawDialect, hooks: SessionWriteHooks, sessionId: string, cond: SessionDeleteCondition): Promise<WithdrawOutcome>;
 export declare class TiDBSessionStore implements SessionStore {
     private readonly pool;
     /** 托管留存声明 = 装配交给它的词(后端按扫车道开不开给;不给 ⇒ `"none"`)。读法逐字见
@@ -45,6 +71,13 @@ export declare class TiDBSessionStore implements SessionStore {
     private load;
     /** Idempotently create a session_meta row with an owner (core `SessionStore.register`). Existing owner is never overwritten. */
     register(sessionId: string, owner: string | null): Promise<void>;
+    /**
+     * 出生回执面(`plugins/session-birth.ts`):与 {@link register} 同一笔 INSERT;候选化身 = 这一次 INSERT 入参里铸的那一只(不复读)。
+     * 已在的行上 INSERT 是 no-op 臂 ⇒ 行上的化身不是候选 ⇒ 撤回在锁内比对时判「留」—— 出生事实只在那里判,这里不分新旧行。
+     */
+    registerWithReceipt(sessionId: string, owner: string | null): Promise<RegisterReceipt>;
+    /** 条件删除(`plugins/session-birth.ts` 的撤回;本连接开事务 → 店与部署两半同一语句面 → 撤回才提交,否则回滚)。 */
+    deleteSessionIf(sessionId: string, cond: SessionDeleteCondition): Promise<WithdrawOutcome>;
     /**
      * acquire 的建行(唯一一处):普通会话 ⇒ 无主(按 id 首建的既有读法);placed 会话 ⇒ 属主 = `placement.owner` 原样,与元组同一条 INSERT 落库
      * (core 7.62.0 [ref] 盒义务 7:委派树的属主是引擎判的,店只记、不判、不推断;唯一读法 `placedSessionOwnerOf`,值不是主体名也不是 null ⇒ 响亮拒、不留行。PG 孪生同调)。
@@ -101,7 +134,7 @@ export declare class TiDBSessionStore implements SessionStore {
      */
     forget(sessionId: string): void;
     /** 真删除一只 placed 会话的两张表(条件删门在 `placement_kind IS NOT NULL`;事务内 meta 先删=提交点,
-     *  与 {@link deleteSession} 同序)。任何 I/O 失败上浮成 `SessionError("storage")`,绝不吞。 */
+     *  会话删除执行体同序:行先删 = 提交点)。任何 I/O 失败上浮成 `SessionError("storage")`,绝不吞。 */
     private deletePlacedSession;
     /**
      * E17 — fork a session: copy its WHOLE durable history to a NEW uuidv7 session owned by `owner`, mirroring
@@ -233,22 +266,8 @@ export declare class TiDBSessionStore implements SessionStore {
      * stream is never reaped while another abandoned one is. Returns the affected row count. Driven by main.ts's reaper.
      */
     sweepStagingSessions(): Promise<number>;
-    /**
-     * E21 — purge a session's CONVERSATION HISTORY (session_meta + session_event). Idempotent: a missing
-     * session is a no-op (returns false). The service's OWN run-ledger / checkpoint / tool-result rows are
-     * purged separately by the route's `purgeSession` coordinator — this method owns only the session
-     * abstraction's tables (the `SessionRepo.delete` half).
-     *
-     * `owner` is the single-DB-fleet null-safe SQL owner guard on `session_meta.owner` (defense-in-depth — the
-     * route already owner-gates; `<=>` so a legacy null-owner session matches owner=null). session_event carries
-     * no owner column, so its purge is GATED on the owner-matched meta delete: if the meta DELETE matched 0 rows
-     * (wrong owner / already gone) we skip the event delete — so a wrong-owner caller can never strand-delete
-     * another tenant's events. Meta is deleted FIRST (mirrors core BUG-2: once it's gone, wake is `null`
-     * regardless of leftover events; if a crash interleaves, orphan events with NO meta are invisible, never a
-     * half-session), and the event purge only runs after that owner-matched commit point.
-     */
-    deleteSession(sessionId: string, owner: string | null): Promise<boolean>;
     get size(): number;
     dispose(): void;
 }
+export {};
 //# sourceMappingURL=tidb-session-store.d.ts.map

package/dist/stores-sql/tidb-session-store.js

@@ -5,11 +5,11 @@ import { jsonColumnText } from "../plugins/sql-json-column.js";
 import { MANAGED_RETENTION, UNMANAGED_RETENTION } from "../plugins/retention-declaration.js";
 import { headFromRow, mintSessionIncarnation, sessionFaceFromRow } from "../session-incarnation.js";
 import { contentForkRelation, fastForwardSharedContentDiverged } from "../session-sync-content.js";
-import { placementCapabilityOf, LIST_PLACED_BATCH, PLACEMENT_SELECT_COLUMNS, placedRowFromRow, placementFromRow, placementInsertValues, SESSION_DURABILITY, SESSION_PLACEMENTS, } from "../plugins/session-placement.js";
+import { placementCapabilityOf, LIST_PLACED_BATCH, PLACEMENT_SELECT_COLUMNS, placedRowFromRow, placementFromRow, placementInsertCells, SESSION_DURABILITY, SESSION_PLACEMENTS, } from "../plugins/session-placement.js";
 import { classifySyncRelationshipByIds, SyncConflictError, StagedCommitOwnerChangedError, stagingIdFor, STAGING_ID_MARKER, STAGING_GC_GRACE_MS, } from "../session-sync-kernel.js";
 import { assertFirstOwnerWritable, forkOwnerOf, isSessionOwnerValue, placedSessionOwnerOf } from "../plugins/session-ownership.js";
-import { selectForkRows } from "@sema-agent/core";
-import { FORK_LOG_ROW_SHAPE, ForkTargetUnsettledError, classifyForkTarget, forkByFreshId, forkPointOf } from "../plugins/session-fork.js";
+import { forkRowCells, selectForkRows } from "@sema-agent/core";
+import { FORK_LOG_ROW_SHAPE, ForkTargetUnsettledError, classifyForkTarget, forkByFreshId, forkPointOf, sameSourceGeneration } from "../plugins/session-fork.js";
 import { isMysqlDupKeyError } from "../plugins/sql-errors.js";
 const statementsOn = (conn) => ({
     async query(sql, params) {
@@ -17,6 +17,34 @@ const statementsOn = (conn) => ({
         return Array.isArray(res) ? { rows: res, affected: 0 } : { rows: [], affected: res.affectedRows };
     },
 });
+function withdrawPlaceholders(dialect, from, count) {
+    return Array.from({ length: count }, (_, i) => (dialect === "pg" ? `$${from + i}` : "?"));
+}
+const keptAs = (word) => ({ withdrawn: false, kept: word });
+export async function withdrawSessionOn(tx, dialect, hooks, sessionId, cond) {
+    const [p1] = withdrawPlaceholders(dialect, 1, 1);
+    const root = (await tx.query(`SELECT owner, incarnation FROM session_meta WHERE session_id = ${p1} FOR UPDATE`, [sessionId])).rows[0];
+    if (root === undefined)
+        return keptAs("absent");
+    const owner = root.owner === null || root.owner === undefined ? null : String(root.owner);
+    if (String(root.incarnation ?? "") !== cond.expect.incarnation || owner !== cond.expect.owner)
+        return keptAs("incarnation");
+    const types = withdrawPlaceholders(dialect, 2, cond.withdrawableEntryTypes.length);
+    const content = await tx.query(`SELECT type FROM session_event WHERE session_id = ${p1} AND type NOT IN (${types.join(", ")}) LIMIT 1 FOR UPDATE`, [sessionId, ...cond.withdrawableEntryTypes]);
+    if (content.rows.length > 0)
+        return keptAs("content");
+    if ((await hooks.beforeCommit(tx, { op: "delete", rootSessionId: sessionId })) !== "proceed")
+        return keptAs("claim");
+    const judged = await cond.judge(tx);
+    if (judged !== "proceed")
+        return keptAs(judged.keep);
+    await tx.query(`DELETE FROM session_event WHERE session_id = ${p1}`, [sessionId]);
+    const [q1, q2] = withdrawPlaceholders(dialect, 1, 2);
+    const gone = await tx.query(`DELETE FROM session_meta WHERE session_id = ${q1} AND incarnation = ${q2}`, [sessionId, cond.expect.incarnation]);
+    if (gone.affected !== 1)
+        throw new Error(`withdraw of session ${sessionId}: the root row this transaction holds locked matched ${gone.affected} rows on delete — engine/driver anomaly, refusing to commit`);
+    return { withdrawn: true };
+}
 class HookRefusal {
     refuse;
     constructor(refuse) {
@@ -74,21 +102,45 @@ export class TiDBSessionStore {
         return { session: new StoredSession(storage), sessionId };
     }
     async register(sessionId, owner) {
+        await this.registerWithReceipt(sessionId, owner);
+    }
+    async registerWithReceipt(sessionId, owner) {
         if (!isSessionOwnerValue(owner)) {
             if ((await this.headOf(sessionId)) !== undefined)
-                return;
+                return {};
             assertFirstOwnerWritable(sessionId, owner);
         }
-        await this.insertMeta(sessionId, owner, undefined);
+        const incarnation = mintSessionIncarnation();
+        await this.insertMeta(sessionId, owner, undefined, incarnation);
+        return { minted: { sessionId, owner, incarnation } };
+    }
+    async deleteSessionIf(sessionId, cond) {
+        const conn = await this.pool.getConnection();
+        try {
+            await conn.beginTransaction();
+            const outcome = await withdrawSessionOn(statementsOn(conn), "mysql", this.hooks, sessionId, cond);
+            if (outcome.withdrawn)
+                await conn.commit();
+            else
+                await conn.rollback();
+            return outcome;
+        }
+        catch (err) {
+            await conn.rollback().catch(() => undefined);
+            throw err;
+        }
+        finally {
+            conn.release();
+        }
     }
     async createOnAcquire(sessionId, placement) {
         await this.insertMeta(sessionId, placement === undefined ? null : placedSessionOwnerOf(sessionId, placement), placement);
     }
-    async insertMeta(sessionId, owner, placement) {
+    async insertMeta(sessionId, owner, placement, incarnation = mintSessionIncarnation()) {
         const now = new Date();
-        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 (?,?,?,?,NULL,0,?,?,?,?,?,?,?) ON DUPLICATE KEY UPDATE leaf_seq = leaf_seq", [sessionId, owner, now, now, mintSessionIncarnation(), ...placementInsertValues(placement, now)]);
+        const placed = placementInsertCells(placement, now);
+        await this.pool.query(`INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq, incarnation, ${placed.columns}) ` +
+            "VALUES (?,?,?,?,NULL,0,?,?,?,?,?,?,?) ON DUPLICATE KEY UPDATE leaf_seq = leaf_seq", [sessionId, owner, now, now, incarnation, ...placed.values]);
     }
     async placementOf(sessionId) {
         const [rows] = await this.pool.query(`SELECT ${PLACEMENT_SELECT_COLUMNS} FROM session_meta WHERE session_id = ?`, [sessionId]);
@@ -168,7 +220,8 @@ export class TiDBSessionStore {
         throw new ForkTargetUnsettledError(target.id);
     }
     async forkToOnce(sourceId, owner, target) {
-        const [metaRows] = await this.pool.query("SELECT leaf_id, owner FROM session_meta WHERE session_id = ?", [sourceId]);
+        const sourceRow = "SELECT leaf_id, owner, incarnation FROM session_meta WHERE session_id = ?";
+        const [metaRows] = await this.pool.query(sourceRow, [sourceId]);
         if (!metaRows[0])
             return null;
         const leafId = metaRows[0].leaf_id ?? null;
@@ -177,16 +230,20 @@ export class TiDBSessionStore {
         if (storage === null)
             return null;
         const point = await forkPointOf(storage);
+        const cells = forkRowCells(await storage.getMetadata());
         const [allRows] = await this.pool.query(`SELECT entry_id, parent_id, type, ${jsonColumnText("mysql", "payload")}, ts FROM session_event WHERE session_id = ? ORDER BY seq ASC`, [sourceId]);
+        const [afterRows] = await this.pool.query(sourceRow, [sourceId]);
+        if (!sameSourceGeneration(cells.forkedFromIncarnation, metaRows[0].incarnation, afterRows[0]?.incarnation))
+            return null;
         const { rows: eventRows, leafId: forkLeafId } = selectForkRows(allRows, leafId, point, FORK_LOG_ROW_SHAPE);
         const now = new Date();
         const conn = await this.pool.getConnection();
         let collided = false;
         try {
             await conn.beginTransaction();
+            const placed = placementInsertCells(target.placement, now);
             try {
-                await conn.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 (?,?,?,?,?,?,?,?,?,?,?,?,?)", [target.id, forkOwner, now, now, forkLeafId, eventRows.length, mintSessionIncarnation(), ...placementInsertValues(target.placement, now)]);
+                await conn.query(`INSERT INTO session_meta (session_id, owner, created_at, updated_at, leaf_id, leaf_seq, incarnation, ${placed.columns}, forked_from, forked_from_incarnation) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`, [target.id, forkOwner, now, now, forkLeafId, eventRows.length, mintSessionIncarnation(), ...placed.values, cells.forkedFrom, cells.forkedFromIncarnation ?? null]);
             }
             catch (err) {
                 if (!isMysqlDupKeyError(err))
@@ -362,33 +419,6 @@ export class TiDBSessionStore {
         }
         return removed;
     }
-    async deleteSession(sessionId, owner) {
-        const conn = await this.pool.getConnection();
-        try {
-            await conn.beginTransaction();
-            const [locked] = await conn.query("SELECT session_id FROM session_meta WHERE session_id = ? FOR UPDATE", [sessionId]);
-            if (locked.length > 0)
-                settleHookVerdict(await this.hooks.beforeCommit(statementsOn(conn), { op: "delete", rootSessionId: sessionId }));
-            const [metaRes] = await conn.query("DELETE FROM session_meta WHERE session_id = ? AND owner <=> ?", [sessionId, owner]);
-            if (metaRes.affectedRows > 0)
-                await conn.query("DELETE FROM session_event WHERE session_id = ?", [sessionId]);
-            await conn.commit();
-            return metaRes.affectedRows > 0;
-        }
-        catch (err) {
-            try {
-                await conn.rollback();
-            }
-            catch {
-            }
-            if (err instanceof HookRefusal)
-                throw err.refuse;
-            throw err;
-        }
-        finally {
-            conn.release();
-        }
-    }
     get size() {
         return this.pending.size;
     }

package/dist/stores-sql/tool-result-store-sql.d.ts

@@ -22,7 +22,7 @@ export declare function ensureSchema(pool: PgPool | PgPoolClient): Promise<void>
  * 一句看不出根因的话。这正是「响亮或 fail-closed,禁静默降级」那条要挡的形态。
  *
  * 判据用**能力探测**而不是版本号/information_schema:发一条恒空的 `WHERE 1=0` 读,列不在就报错。
- * 探针读抛且是**可证**的缺列 ⇒ 拒启(其余错误原样上抛,与兄弟探针同一条规则)。拒因的出路是**闭集三条**(与整库对账同一份,{@link describeProbedTableDrift} / {@link schemaWaysOut}),没有销毁性的一条:
+ * 探针读抛且是**可证**的缺列 ⇒ 拒启(其余错误原样上抛,与兄弟探针同一条规则)。拒因的出路是**闭集三条**(与整库对账同一份,{@link probedMissingColumnRefusal} / {@link schemaWaysOut}),没有销毁性的一条:
  * 缺的出处两列由对账同一套件逐条打印 `ALTER TABLE tool_result ADD COLUMN …`;键宽不够则第 (2) 条是部署者自己把 `ref` 加宽到本构建的定义。
  */
 export declare function assertToolResultProvenanceSchema(query: (sql: string) => Promise<{