@sema-agent/server 7.43.0 → 7.44.0

package/dist/plugins/session-placement.js

@@ -1,58 +1,6 @@
-/**
- * #292 C18(core 5.48.0 design/323「不造新店」提货批,黑板 [4743] 点名义务)——**subagent 转录持久化**
- * 的 placement 语义,SQL 孪生共用的一份判据。
- *
- * ## 这是什么
- *
- * core 5.48.0 给 `SessionStore` 开了一组**全 optional** 的 placement 面:一只**声明** `placements`
- * (「本店懂 placement 语义,且落在 subagent 分区里的会话是这个耐久度」)+ `acquire(id,{placement})`
- * 的创建形 + `listPlaced` / `placementOf` 两只读面。声明即承诺**六条义务**(core `SessionStore.placements`
- * 顶注逐字):
- *
- *  1. placed 会话享受所声明的耐久度(重启后 `acquire(id,{requireExisting:true})` 仍到得了);
- *  2. placed 会话**不上宿主枚举面**(壳的 /resume 列表不许把子代转录当成可续聊会话);
- *  3. **未** placed 的会话,acquire 语义逐字节不变;
- *  4. `release(placedId)` 是**真删除**(durable 史一并),联合 reap 的「行与会话同亡」靠它;
- *  5. placement **first-write 不可变**:re-open(`requireExisting`,带不带 placement 参数)返回同一
- *     会话且**永不重写**元组;
- *  6. placed id **不可被 claim**:后来的 claim 形 acquire(无 `requireExisting`、无创建 placement)
- *     撞上已存在的 placed id ⇒ 响亮拒 `SessionError("placement_refused")`,绝不附着。
- *
- * ## 为什么判据住在这里而不是各写一份
- *
- * 本仓成文教训(`memory-origin-law.ts` 顶注同族、`key-resolver.ts` 顶注「链只有一条」):两支方言各
- * 抄一份准入判据,迟早在某一支上少一个分支——而少掉的那一支**没有任何报错面**,表现只是「这台机器上
- * 一个陌生人可以把自己接到别人子代的转录上」。所以准入判据(两个方向)、列名、行→元组的映射都在
- * 这一处;两支后端只负责在自己的 I/O 点上调用它。
- *
- * ## 判据的两个方向(缺一不可,core `TtlSessionStore.assertPlacementAdmission` 的镜像)
- *
- * ① **claim 关门**:已 placed 的行拒绝 claim 形 acquire;
- * ② **镜像方向(pre-claim squat 竞态)**:子会话 id 在 spawn 帧上**先于**子代 prepare 公布,于是一次
- *    并发的 claim 形 acquire 可能抢先建出**普通**会话,而后带 placement 的可信调用方拿到的就是一只
- *    宿主可枚举、release 不真删的普通会话 ——「声明了 full tier 却在静默说谎」。⇒ 在**声明了分区**的
- *    店上,带 placement 的 acquire 必须回读到**已持久化**且同一元组身份的行,回读缺失/异组=响亮拒。
- */
 import { SessionError } from "@sema-agent/core";
-/**
- * 两支 SQL 孪生的 placement **声明**(core `SessionStore.placements`)。
- *
- * 🔴 声明制,不是鸭子类型:core 的铸造门判「row store ∧ session 店声明」,不声明的店**不收** placed
- * 语义(合法降级:placement 参数被忽略,会话就是普通会话)。所以这一格只有在上面六条义务**全部**在
- * 本店实装之后才允许存在——它是一句关于本店行为的承诺,不是一个功能开关。
- * `durable` 的依据:两支孪生的会话史落在 `session_meta`+`session_event` 两张真表上,进程重启后
- * `acquire(id,{requireExisting:true})` 从事件日志重放(义务 1 的机器证在
- * `test/session-placement-db-integration.test.ts` 的跨进程复活格)。
- */
 export const SQL_SESSION_PLACEMENTS = { subagent: { durability: "durable" } };
-/**
- * `session_meta` 上承载 placement 元组的六列,**两方言同名**(单点定义:列名手抄两份必漂,而漂掉的
- * 那一支只会表现为「这台机器上 placed 行读不出来」——静默,不报错)。
- * `placed_at` 是 GC 的年龄锚(core `PlacedSessionRow.placedAt`);其余五列是元组本身。
- */
 export const PLACEMENT_SELECT_COLUMNS = "placement_kind, placement_scope, placement_parent_session_id, placement_root_session_id, placement_handle, placed_at";
-/** DATETIME/TIMESTAMPTZ 单元格 → epoch ms。两支池都返回 `Date`(mysql2 `timezone:"Z"` / node-pg 原生),
- *  字符串臂是防御性回落(驱动配置若变,宁可解析一次也不要静默把 placedAt 读成 NaN)。 */
 function toEpochMs(v) {
     if (v == null)
         return undefined;
@@ -62,14 +10,6 @@ function toEpochMs(v) {
     return Number.isFinite(ms) ? ms : undefined;
 }
 const asStringOrUndefined = (v) => (typeof v === "string" && v.length > 0 ? v : undefined);
-/**
- * 行 → 持久化的 placement 元组(`undefined` = 这是一只普通会话)。
- *
- * 🔴 判别位是 `placement_kind`:它在场即 placed。`placed_at` 缺失(带外 SQL 写进半只元组)时回落
- * `0` 而**不是**把整只元组读成缺席——把「元组半缺」读成「没有 placement」等于让义务 2/4/6 在那一行上
- * 集体失效(宿主枚举会重新列出它、release 退回租约语义);`listPlaced` 那一侧另有 `tupleIncomplete`
- * 的诚实变体负责让 GC 对它 fail-closed。
- */
 export function placementFromRow(row) {
     if (row === undefined)
         return undefined;
@@ -85,12 +25,6 @@ export function placementFromRow(row) {
         placedAt: toEpochMs(row.placed_at) ?? 0,
     };
 }
-/**
- * 行 → 一条 {@link PlacedSessionRow}(`listPlaced` 的行形)。
- *
- * core 契约:join 键是**完整**的 `(scope, handle)`;缺任何一半 ⇒ 返回 `tupleIncomplete` 的诚实变体,
- * 消费方对它 fail-closed(永不按年龄收割)。一个「无行」与「另一个租户有行」分不清的 join 不许删东西。
- */
 export function placedRowFromRow(sessionId, row, lastActivityMs) {
     const placedAt = toEpochMs(row.placed_at) ?? lastActivityMs ?? 0;
     const scope = asStringOrUndefined(row.placement_scope);
@@ -99,7 +33,6 @@ export function placedRowFromRow(sessionId, row, lastActivityMs) {
         ? { sessionId, placedAt, scope, handle }
         : { sessionId, placedAt, tupleIncomplete: true };
 }
-/** 创建时一次落行的六个绑定值(顺序 = {@link PLACEMENT_SELECT_COLUMNS});无 placement ⇒ 六个 NULL。 */
 export function placementInsertValues(placement, placedAt) {
     if (placement === undefined)
         return [null, null, null, null, null, null];
@@ -112,23 +45,9 @@ export function placementInsertValues(placement, placedAt) {
         placedAt,
     ];
 }
-/**
- * 准入判据 —— **两个方向**(顶注 ①②;core `TtlSessionStore.assertPlacementAdmission` 的 SQL 镜像,
- * 逐条同义,文案自铸)。
- *
- * @param persisted 该 id 在库里**已持久化**的元组(缺席 = 普通会话 / 无此行)。
- *
- * · 方向①(claim 关门):`persisted` 在场 + 非 `requireExisting` + 调用方没带创建 placement ⇒ 拒。
- *   `requireExisting`(读/复活形,义务 5)与「创建调用及其幂等重取」(带 placement 的可信内部链)
- *   是仅有的两个合法形。placement 不可变意味着带 placement 的参数**永远重写不了**任何东西——持久化
- *   的那一份恒赢,所以放行它不开任何后门。
- * · 方向②(镜像/squat):带 placement 的创建形回读到**缺席**或**异组**元组 ⇒ 拒。缺席 = 并发的
- *   claim 形抢先建出了普通会话(或带外写把元组抹了);异组 = 同 id 上坐着另一条委派链的转录。
- *   两者都不许让「声明了 durable 分区」这句话在静默中变成谎。
- */
 export function assertPlacementAdmission(sessionId, persisted, opts) {
     if (opts?.requireExisting === true)
-        return; // 读/复活形:义务 5 的合法入口,两方向都不判
+        return;
     if (persisted !== undefined && opts?.placement === undefined) {
         throw new SessionError("placement_refused", `session ${sessionId} belongs to the ${persisted.kind} placement partition — a claim-form acquire cannot attach to it (read it with requireExisting, or address the agent through its a* handle)`);
     }
@@ -142,12 +61,5 @@ export function assertPlacementAdmission(sessionId, persisted, opts) {
         throw new SessionError("placement_refused", `session ${sessionId}'s persisted placement does not match the declared one (persisted ${persisted.kind}/${persisted.scope ?? "-"}/${persisted.handle ?? "-"} vs declared ${want.kind}/${want.scope ?? "-"}/${want.handle ?? "-"}) — refusing a cross-tuple attach`);
     }
 }
-/**
- * 一次 `listPlaced` 最多带回的行数。
- *
- * core 契约不设上界,但两支孪生面对的是一张可以很大的真表:无界 SELECT 会让一次 reap tick 把整个
- * placed 分区拉进内存。行按**年龄升序**(最老先出)⇒ 截断的语义是「本 tick 先收最老的一批,下一 tick
- * 接着收」,而不是「有些行永远看不见」。判据消费方(core 的分区收割腿)本就是每 tick 重新枚举的。
- */
 export const LIST_PLACED_BATCH = 1000;
 //# sourceMappingURL=session-placement.js.map

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

@@ -1,82 +1,28 @@
-/**
- * Durable `SessionPolicyStore` (E6) — SINGLE-FILE DUAL-DIALECT (design/158 A12 定型半场). ONE
- * implementation, TWO dialects; the historical `TiDBSessionPolicyStore` / `PgSessionPolicyStore` class
- * names survive as thin ctor subclasses so every consumer (store-backend.ts, the session-sync
- * fanout/push/pull suites, the E6 equivalence suite) is untouched.
- *
- * Operator-tightened per-session tool-permission rules (CAS-versioned, tighten-only) — the cross-replica
- * twin of core's InMemorySessionPolicyStore (`@sema-agent/core` session-policy-store.js), backing core's
- * `RunnerDeps.sessionPolicyStore`. core READS via getRules at prepare-time and folds the rules into the
- * ToolPolicy FIRST (subtract-only); the service's operator endpoint WRITES via putRules.
- *
- * BYTE-MATCH discipline (the env-gated equivalence test vs InMemorySessionPolicyStore is the contract):
- *  - Key = `sha256(JSON.stringify([sessionId, principal ?? null]))` — the SHA of core's exact composite key. The hash
- *    (a) gives a FIXED 64-char PK regardless of how long / JSON-escapable the principal is (a VARCHAR(190) principal of
- *    control chars JSON-escapes past any fixed width — review finding), and (b) sidesteps PK collation pitfalls
- *    (trailing-space PAD). `principal` undefined/null collapse to one row, "" stays distinct (core's `?? null`).
- *  - putRules order is LOAD-BEARING: (1) CAS expectedRev (stale → `conflict`), (2) normalize+stripRev the incoming
- *    rules, (3) tighten gate via the REUSED core `loosenReasons` (non-operator loosen → `loosen_forbidden`), (4) rev
- *    bump (+1; first = 1). A missing row reads as rev 0 (so expectedRev:0 = create-once). The conflict + loosen_forbidden
- *    MESSAGES match core verbatim. read-check-write runs in ONE txn (SELECT…FOR UPDATE the prior so the loosen diff +
- *    CAS are atomic; the InMemory gets this free from single-threaded JS). The UPDATE additionally guards `AND rev=?`
- *    (defense beyond the row lock); a concurrent FIRST-write (no row → FOR UPDATE takes no lock) loses the PK race and
- *    is RETRIED (re-read takes the UPDATE path) so a no-expectedRev create matches core's serialized rev-2 outcome
- *    rather than a spurious conflict.
- *  - allowDirs is stored NORMALIZED (`..`-free) so a later read-back `prior` feeds loosenReasons in the same canonical
- *    shape as `clean` (the /work/../etc tighten-bypass blocker). The return is structuredClone'd (core's isolation).
- * `operator` is honored verbatim — core never adjudicates it; the HTTP route FREEZES it from a verified principal
- * (mirrors steer.trusted). `deleteBySession` is a service extension (E21 purge), not core's interface.
- *
- * ── Dialect deltas, kept EXPLICIT ────────────────────────────────────────────────────────────────────
- *   - `?` placeholders vs `$n`
- *   - dup-key errno `1062`/`ER_DUP_ENTRY` vs SQLSTATE `23505`
- *   - PG-only genuinely-divergent ALGORITHM: `pgHasUnstorable` rejects rules containing NUL / lone-surrogate
- *     bytes (fail-loud, never rewritten) before the write; TiDB has no equivalent guard. Kept as an explicit
- *     `if (this.db.dialect === "pg")` branch in putRules — see the inline 🔴 comment there for the codex
- *     R2-H1→R3 rationale (rules are the authorization semantic body: reject-only, never silently rewritten).
- *   - transaction plumbing: TiDB's native `beginTransaction/commit/rollback` vs PG's statement-issued
- *     `BEGIN/COMMIT/ROLLBACK` — normalized by `SqlDriver`'s shared `connect()`/`begin()`/`commit()`/`rollback()`
- *     (see sql-driver.ts); this store's original `beginTransaction()` call shape maps onto the driver's plain
- *     `begin()` (NOT `beginPessimistic()` — the original TiDB store never opted into `BEGIN PESSIMISTIC`).
- */
 import { createHash } from "node:crypto";
 import { loosenReasons, SessionPolicyError, normalizeRules, stripRev } from "@sema-agent/core";
 import { pgHasUnstorable } from "./pg-safe-json.js";
 import { mysqlDriver, pgDriver } from "./sql-driver.js";
 import { isDupKeyError } from "./sql-errors.js";
-/** `session_policy.policy_key` 的**唯一铸造点**(core 复合键的 sha256)。
- *
- *  🔴 导出而不是让收编腿再抄一份(clay 宪法「schema 单一属主禁复制」):design/183 form b 的身份重绑要
- *  逐行重算这把键(身份在 hash 的**原像**里,等值 UPDATE 够不着)。两处各写一遍 sha256 表达式的下场是
- *  某天有人在这里改了 key 公式而收编腿还在按旧式算 —— 迁完的行从此谁也读不到,且**静默**。 */
 export const policyKeyFor = (sessionId, principal) => createHash("sha256").update(JSON.stringify([sessionId, principal ?? null])).digest("hex");
 const policyKey = policyKeyFor;
-const parseRules = (v) => (typeof v === "string" ? JSON.parse(v) : v); // R7 终形:拒绝式下库内恒干净,直读
-/** Dual-dialect durable SessionPolicyStore. See the file header for the dialect-delta ledger. */
+const parseRules = (v) => (typeof v === "string" ? JSON.parse(v) : v);
 export class SqlSessionPolicyStore {
     db;
     constructor(db) {
         this.db = db;
     }
-    /** Pick the dialect's SQL text. Both statements stay written out at the call site ON PURPOSE. */
     q(tidb, pg) {
         return this.db.dialect === "tidb" ? tidb : pg;
     }
-    /** 判据属主 = `sql-errors.ts`(A-032 P1-①;本站点旧形已是并集形,收编后语义不变)。 */
     isDupKey(e) {
         return isDupKeyError(this.db.dialect, e);
     }
-    /** Read the stored rules for (session, principal-owner); null when none (parity with InMemory). */
     async getRules(sessionId, principal) {
         const { rows } = await this.db.query(this.q("SELECT rules, rev FROM session_policy WHERE policy_key = ?", "SELECT rules, rev FROM session_policy WHERE policy_key = $1"), [policyKey(sessionId, principal)]);
         if (!rows[0])
             return null;
         return { ...parseRules(rows[0].rules), rev: Number(rows[0].rev) };
     }
-    /** 2c session-sync: every (principal, rules) record for a session across ALL principals — getRules is
-     *  per-(session,principal), but a cross-backend session EXPORT must bundle the WHOLE session's policy (the importer
-     *  replays each via putRules). principal is read from the DENORMALIZED column (the sha256 policy_key is one-way);
-     *  NULL → undefined = the session-wide row (parity with core's InMemory `principal ?? undefined`). Rules carry rev. */
     async listBySession(sessionId) {
         const { rows } = await this.db.query(this.q("SELECT principal, rules, rev FROM session_policy WHERE session_id = ?", "SELECT principal, rules, rev FROM session_policy WHERE session_id = $1"), [sessionId]);
         return rows.map((r) => ({
@@ -84,7 +30,6 @@ export class SqlSessionPolicyStore {
             rules: { ...parseRules(r.rules), rev: Number(r.rev) },
         }));
     }
-    /** Operator/owner write: CAS + tighten-only (unless operator) + rev bump, atomic in one txn; first-write race retried. */
     async putRules(sessionId, principal, rules, opts) {
         const key = policyKey(sessionId, principal);
         for (let attempt = 0;; attempt++) {
@@ -93,24 +38,16 @@ export class SqlSessionPolicyStore {
                     const { rows } = await conn.query(this.q("SELECT rules, rev FROM session_policy WHERE policy_key = ? FOR UPDATE", "SELECT rules, rev FROM session_policy WHERE policy_key = $1 FOR UPDATE"), [key]);
                     const prior = rows[0] ? { rules: parseRules(rows[0].rules), rev: Number(rows[0].rev) } : undefined;
                     const priorRev = prior?.rev ?? 0;
-                    // (1) CAS — checked BEFORE the tighten gate; a missing row is rev 0 (expectedRev:0 = create-once).
                     if (opts?.expectedRev !== undefined && priorRev !== opts.expectedRev) {
                         throw new SessionPolicyError("conflict", `session rules rev mismatch (expected ${opts.expectedRev}, have ${priorRev})`);
                     }
-                    // (2) normalize+stripRev the INCOMING rules (allowDirs `..`-free before store AND before the loosen diff).
                     const clean = normalizeRules(stripRev(rules));
-                    // (3) tighten gate — ONLY when a prior exists AND not an operator write (strict !== true). REUSE core loosenReasons.
                     if (prior && opts?.operator !== true) {
                         const loosens = loosenReasons(prior.rules, clean);
                         if (loosens.length > 0) {
                             throw new SessionPolicyError("loosen_forbidden", `a non-operator session-rule write may only tighten; refused: ${loosens.join("; ")}`);
                         }
                     }
-                    // 🔴 PG-only genuinely-divergent ALGORITHM (not a syntax difference): codex R2-H1→R3(NUL 批终形):
-                    // rules=授权语义本体,**拒绝式**——含不可存字节的规则是垃圾输入(NUL 路径本不可用),fail-loud
-                    // 拒收;绝不改写(有损=写读不一致)、绝不信封(R3:滚动部署/回滚窗口老 replica 读信封=字段全缺=
-                    // fail-open 放行,授权面不赌版本偏斜)。TiDB's VARBINARY/utf8mb4 storage never chokes on these bytes
-                    // the way PG's protocol-byte encoding does, so it carries no equivalent guard.
                     if (this.db.dialect === "pg" && pgHasUnstorable(clean)) {
                         throw new SessionPolicyError("loosen_forbidden", "rules contain unstorable bytes (NUL / lone surrogate) — refused; strip them at the source (authorization rules are never rewritten by the store)");
                     }
@@ -118,38 +55,26 @@ export class SqlSessionPolicyStore {
                     const json = JSON.stringify(clean);
                     const now = new Date();
                     if (prior) {
-                        // `principal` is enumeration-only (not a key, not CAS): write it on UPDATE too so a pre-migration
-                        // row (principal NULL) SELF-HEALS to its real principal on the next write — never changes the rev/CAS path.
                         const upd = await conn.query(this.q("UPDATE session_policy SET principal = ?, rules = ?, rev = ?, updated_at = ? WHERE policy_key = ? AND rev = ?", "UPDATE session_policy SET principal = $1, rules = $2::jsonb, rev = $3, updated_at = $4 WHERE policy_key = $5 AND rev = $6"), [principal ?? null, json, nextRev, now, key, priorRev]);
-                        // Defense beyond the FOR UPDATE row lock: if rev moved under us, the CAS lost (treat as conflict).
                         if (upd.affected !== 1)
                             throw new SessionPolicyError("conflict", `session rules rev mismatch (expected ${opts?.expectedRev ?? priorRev}, have ${priorRev})`);
                     }
                     else {
-                        // No prior → FOR UPDATE took no row lock; a concurrent first-writer can win the PK. Let the dup-key
-                        // PROPAGATE (do NOT convert to conflict here) so the outer loop RETRIES — the re-read then finds the row
-                        // and takes the UPDATE path (matching core's serialized rev-2 outcome / or an honest CAS conflict if
-                        // expectedRev was supplied), instead of a spurious conflict. `principal ?? null` = the enumeration column.
                         await conn.query(this.q("INSERT INTO session_policy (policy_key, session_id, principal, rules, rev, created_at, updated_at) VALUES (?,?,?,?,?,?,?)", "INSERT INTO session_policy (policy_key, session_id, principal, rules, rev, created_at, updated_at) VALUES ($1,$2,$3,$4::jsonb,$5,$6,$7)"), [key, sessionId, principal ?? null, json, nextRev, now, now]);
                     }
-                    return structuredClone({ ...clean, rev: nextRev }); // core hands back a fully isolated tree
+                    return structuredClone({ ...clean, rev: nextRev });
                 });
             }
             catch (e) {
                 if (this.isDupKey(e) && attempt < 4)
-                    continue; // concurrent first-write — re-read takes the UPDATE/CAS path
+                    continue;
                 throw e;
             }
         }
     }
-    /** E21 purge — drop ALL policy rows for a session (every principal). Scoped by session_id (the route owner-gates).
-     *  Return shape aligned to core 1.423's optional interface seam (`Promise<void>`) — the affectedRows count was
-     *  incidental and unconsumed; the integration test asserts the post-state (listBySession empty) instead. */
     async deleteBySession(sessionId) {
         await this.db.query(this.q("DELETE FROM session_policy WHERE session_id = ?", "DELETE FROM session_policy WHERE session_id = $1"), [sessionId]);
     }
-    /** `begin()` (NOT `beginPessimistic()`) — matches both twins' original call shape: TiDB's native
-     *  `beginTransaction()` (optimistic), PG's plain `BEGIN`. Normalized by SqlDriver's shared tx plumbing. */
     async tx(fn) {
         const conn = await this.db.connect();
         try {
@@ -163,7 +88,6 @@ export class SqlSessionPolicyStore {
                 await conn.rollback();
             }
             catch {
-                /* ignore */
             }
             throw err;
         }
@@ -172,13 +96,11 @@ export class SqlSessionPolicyStore {
         }
     }
 }
-/** MySQL-protocol (TiDB) binding — historical class name + ctor shape preserved. */
 export class TiDBSessionPolicyStore extends SqlSessionPolicyStore {
     constructor(pool) {
         super(mysqlDriver(pool));
     }
 }
-/** PostgreSQL binding — historical class name + ctor shape preserved. */
 export class PgSessionPolicyStore extends SqlSessionPolicyStore {
     constructor(pool) {
         super(pgDriver(pool));

package/dist/plugins/session-store.js

@@ -1,14 +1,5 @@
 import { TtlSessionStore } from "@sema-agent/core";
 import { CachingSessionStore } from "./caching-session-store.js";
-/**
- * Session-store plugin seam.
- *
- * - `memory` (default): core's in-memory `TtlSessionStore` (lost on restart, 7-day idle TTL).
- * - `tidb`: the durable "Session event-log center" (L1) — append-only events + wake/resume +
- *   cross-instance CAS (F2), on whichever SQL engine `DB_BACKEND` selects (TiDB or PG, via the store backend).
- *   Optionally wrapped in a warm cache (reuse a hot session across turns; requires session affinity) —
- *   set `SESSION_CACHE_TTL_SEC=0` to disable.
- */
 export function createSessionStore(config, backend, metrics) {
     if (config.sessionBackend === "tidb") {
         if (!backend)
@@ -20,71 +11,23 @@ export function createSessionStore(config, backend, metrics) {
     }
     return new TtlSessionStore({ defaultTtlDays: 7 });
 }
-/**
- * core 1.382(design/153,[1561] 提货单①②)`SubagentToolOptions.background.ensureChildSessionDurable`
- * 的实现体——从 main.ts 装配点抽出为可独立测试的纯函数(main.ts 里的其余装配闭包历来无单测覆盖,
- * 这条因为承载真实的 park/veto 裁决,拆出来直接钉)。
- *
- * 只在 `sessionId` 已经真正路由到 HOST(durable)会话店、且**真有内容**时 resolve;其余(未路由到 host/
- * 两店皆无/host 店只有一行空壳)一律 reject——veto,core 侧子代按 pre-153 settle failed,零回归,不是
- * 危险失败模式(见函数体内注释)。
- *
- * 传入必须是 HOST 店本身(main.ts 里 `createSessionStore(...)` 的返回值),不能是 subRunner 用的
- * `ForkRoutingSessionStore` 包装店——那层包装对 `acquire(id,{requireExisting:true})` 是 transient-优先
- * (F-7 案:让"真会话在 transient"赢过"host 店里的同 id 空壳"),会把"只在 transient 店有真内容"误判成
- * "host 店已经有了"。这里要问的是纯粹"host 店本身是否已经有这份真内容",必须绕开那层路由。
- *
- * 🔴 [1575] F3(cli 复查抓获,真红确认)调用方前提——**本函数假设 `hostStore.release()` 是"归还租约"
- * 语义(不销毁内容)**,这对 core `TiDBSessionStore` 成立(`release()` 逐字注释「Durable history is
- * retained; just drop any in-flight cache entry」),但对无 repo 构造的 `TtlSessionStore`(`createSessionStore`
- * 在 `SESSION_BACKEND !== "tidb"` 时返回的那种)**不成立**——那个店形的 `release()` 是整删会话
- * (`evictPolicy="delete"`)。本函数自己**不做**、也无法通用地做"这个 store 实例的 release 是否安全"的
- * 判别(`SessionStore` 接口没有暴露这个信息,类型层面区分不了两种店形)——上文"误判方向永远偏保守"
- * 只覆盖 `getLeafId` 那道校验,不覆盖"传了一个 release=delete 的店进来"这个前提违反。**调用方必须
- * 保证只在真正 durable(release 非破坏性)的店上调用本函数**——server 侧的强制点在 main.ts 装配区:
- * `ensureChildSessionDurable` 闭包只在 `config.sessionBackend === "tidb"` 时构造。
- */
 export async function ensureSessionDurable(hostStore, sessionId) {
     const acquired = await hostStore.acquire(sessionId, { requireExisting: true });
     try {
-        // security.ts 的 authorizer 对任意调用方自报的 body.sessionId(无主时)会经 `register()` 在 host 店
-        // 插一行 session_meta(leaf_id NULL,零内容)——那是 claim-create 的副作用,不是真正落过内容的会话。
-        // 裸 acquire 命中不足以证明"这份 durable 记录里有真内容可供跨进程恢复";真实会话到 park 这一步
-        // (需要模型已经产出过至少一次带工具调用的回复)恒已有 ≥1 条树内条目。校验失败的唯一后果是多一次
-        // reject=veto=pre-153 行为,不会放大权限或掩盖错误——误判方向永远偏保守。
         const leafId = await acquired.session.getLeafId();
         if (leafId === null)
             throw new Error(`session "${sessionId}" exists in the durable store but is empty (no leaf entry) — likely a claim-create shell row, not real durable content`);
     }
     finally {
-        // 🔴 #292 C18(core 5.48.0 [4743] 点名义务①,**preflight/探活法**):这是一次「只为验存在」的
-        // acquire ⇒ 收尾必须是 `forget`(丢暖引用),**绝不能**是 `release`。core 5.48 起
-        // `release(placedId)` 被重定义为**真删除**,而本函数正是 park 前的探活腿:一条跨重启 parked 的
-        // 子代转录在这里被 release 一次就等于**删掉转录 + 烧掉那次审批**(core 发车前重扫的 P1 同款撞点,
-        // 四域复现)。缺 `forget` 面 ⇒ 什么都不做(core B-17 判例:绝不代之以 release);两支 SQL 孪生与
-        // 包装店都实装了 forget,所以生产路径上这一步是真的丢引用,不是 no-op。
         await hostStore.forget?.(acquired.sessionId);
     }
 }
-/**
- * [1593] 主动晋升版 ensureChildSessionDurable(cli TiDB 真机撞获:1.263 的只查不迁形在拆店生产形下
- * 恒否决 park——bg 子会话住 subRunner 私有 TTL 店、从不在 host 店,core 收 veto 即 expire checkpoint
- * (14ms~2s)+ settle failed,赎回窗口不存在):
- *   1. 快路:已在 host 店且有真内容 → 直接通过(幂等/重入)。
- *   2. 晋升:routing.promoteToHost 把子会话整树从私店拷进 host 店(拷贝→私店 forget→路由记 host,
- *      三步见 ForkRoutingSessionStore.promoteToHost)。
- *   3. 复验:同一把 `ensureSessionDurable` 严检(leaf 非空)——晋升产物必须达到与既有校验完全相同的
- *      durable 标准,任何一步失败=如实 reject=veto=pre-153 行为(不放大)。
- * 调用方纪律与 {@link ensureSessionDurable} 同款:hostStore 必须是 release 非破坏性的真 durable 店
- * (main.ts 的 `config.sessionBackend === "tidb"` 门不变)。
- */
 export async function ensureChildSessionDurableWithPromotion(hostStore, routing, sessionId) {
     try {
         await ensureSessionDurable(hostStore, sessionId);
         return;
     }
     catch {
-        // 不在 host 店(或空壳行)→ 走晋升;晋升自身的失败在下方如实上浮
     }
     await routing.promoteToHost(sessionId);
     await ensureSessionDurable(hostStore, sessionId);