@sema-agent/server 7.43.0 → 7.44.0

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

@@ -3,19 +3,7 @@ import { BaseSessionStorage, SessionError, leafIdAfterEntry, normalizePromptEpoc
 import { toIso } from "./sql-row-helpers.js";
 import { isMysqlDupKeyError } from "./sql-errors.js";
 import { PLACEMENT_SELECT_COLUMNS, placementFromRow } from "./session-placement.js";
-/** 判据属主 = `sql-errors.ts`(A-032 P1-①;旧形只认 `code`,只带 errno 的驱动错误漏判)。 */
 const isDupKey = isMysqlDupKeyError;
-/**
- * TiDB-backed {@link BaseSessionStorage} — the durable L1 event log for one session.
- *
- * - `appendEntry` / `setLeafId` persist with an **atomic compare-and-set** on `leaf_seq` + `leaf_id`
- *   (core's F2 optimistic-lock seam): a write only lands if the branch leaf is still what the entry
- *   was built against. Two stateless runners that both woke the same session can't silently fork —
- *   the loser gets `SessionError("conflict")` (catch with `isSessionConflict`).
- * - The in-memory base tree is the wake-time snapshot; every write is also mirrored into it so the
- *   live harness keeps reading a consistent view. Wake is **bounded** to `[floor .. leaf]` (F3,
- *   core 1.6.0 branch-floor seam); older history is covered by the last compaction's summary.
- */
 export class TiDBSessionStorage extends BaseSessionStorage {
     pool;
     sessionId;
@@ -28,29 +16,14 @@ export class TiDBSessionStorage extends BaseSessionStorage {
         this.leafSeq = leafSeq;
         this.floorSeq = floorSeq;
     }
-    /**
-     * [976] S3 RB-14 pull seam — `SessionStorage.getEpochAnchor?()`: the nearest epoch carrier BELOW the
-     * bounded-wake floor. core's `Session.getPromptEpoch()` (≥1.305) calls this only when the in-window
-     * branch walk finds no carrier — i.e. a rewind/resumeAt cut inside the kept tail, where the compaction
-     * restatement is a DESCENDANT of the cut and the root pin sits under the floor. Semantics per core's
-     * ruling: highest-seq valid carrier below the floor (not an ancestor-chain walk — fallback of last
-     * resort); malformed rows are skipped (#13: fall back to the older valid pin — the write gate refuses
-     * malformed carriers, so these only exist via out-of-band writes); none ⇒ undefined = a genuine
-     * pre-epoch session (core mints legacy_migration, the correct meaning). core re-normalizes whatever we
-     * return, so this stays honest even if the two sides ever disagree on strictness.
-     */
     async getEpochAnchor() {
         if (this.floorSeq <= 0)
-            return undefined; // full load — the walk already reaches the root pin
-        // Keyset-paged scan to EXHAUSTION (codex HIGH): a long-lived session upgraded across the epoch
-        // release carries 100+ pre-epoch compactions with NO restatement between the floor and the older
-        // valid pin — a bounded LIMIT would run dry on them and return undefined, which here specifically
-        // means "genuinely pre-epoch" and would let the caller mint a migration epoch over a durable anchor.
+            return undefined;
         let cursor = this.floorSeq;
         for (;;) {
             const [rows] = await this.pool.query("SELECT seq, payload FROM session_event WHERE session_id = ? AND seq < ? AND type IN ('prompt_epoch','compaction') ORDER BY seq DESC LIMIT 100", [this.sessionId, cursor]);
             if (rows.length === 0)
-                return undefined; // exhausted — a genuine pre-epoch session
+                return undefined;
             for (const r of rows) {
                 const e = (typeof r.payload === "string" ? JSON.parse(r.payload) : r.payload);
                 const d = e.type === "prompt_epoch" ? normalizePromptEpoch(e) : normalizePromptEpoch(e.details?.promptEpoch);
@@ -60,45 +33,18 @@ export class TiDBSessionStorage extends BaseSessionStorage {
             cursor = Number(rows[rows.length - 1].seq);
         }
     }
-    /**
-     * Rebuild a session from its event log (= wake). Returns null if the session does not exist.
-     *
-     * F3 bounded load: only `[floor .. leaf]` is read, where floor = the last compaction's
-     * `firstKeptEntryId` (everything older is represented by that compaction's summary, so it never
-     * enters context). No compaction yet → floor=null → full load (the session is still short).
-     *
-     * This is the durable, bounded-READ equivalent of core's `boundedTail(pathEntries)` (1.42.0): that
-     * helper trims a FULL-loaded path in memory, whereas we compute the floor seq first and only `SELECT
-     * seq >= floorSeq` — so the head never leaves cold storage. Our sessions are LINEAR (no fork), so
-     * seq-order == root→leaf path-order and our `seq >= floorSeq` tail is byte-identical to
-     * `boundedTail(path).tail`; the resulting floored `BaseSessionStorage.buildContext()` matches a
-     * full-tree wake (core's `session-floor.test.ts`). If branching is ever added, switch to `boundedTail`.
-     */
     static async wake(pool, sessionId) {
-        // KNOWN/ACCEPTED (audit B): meta + floor + events are three queries, not one snapshot — a writer
-        // appending between them can make this wake see MORE events than the meta row described (never
-        // fewer: seq is append-only and `seq >= floorSeq` reads the tail). That's only reachable when two
-        // actors drive the same session concurrently, which the task_active session lock already
-        // serializes; the persist path then re-CASes leaf_id/leaf_seq, so a stale wake loses cleanly there. A
-        // single-snapshot read would need a repeatable-read txn per wake — not worth it for this guard rail.
-        const [metaRows] = await pool.query(
-        // #292 C18:placement 六列**捎带**在这条既有的 meta SELECT 上(不另开一次往返)——准入判据
-        // (claim 关门 / 镜像 squat 判)读的就是这一份持久化元组,而 acquire 的热路径不该为它多付一次 RTT。
-        `SELECT created_at, leaf_id, leaf_seq, ${PLACEMENT_SELECT_COLUMNS} FROM session_meta WHERE session_id = ?`, [sessionId]);
+        const [metaRows] = await pool.query(`SELECT created_at, leaf_id, leaf_seq, ${PLACEMENT_SELECT_COLUMNS} FROM session_meta WHERE session_id = ?`, [sessionId]);
         const meta = metaRows[0];
         if (!meta)
             return null;
         const { floorEntryId, floorSeq } = await TiDBSessionStorage.computeFloor(pool, sessionId);
         const [eventRows] = await pool.query("SELECT payload FROM session_event WHERE session_id = ? AND seq >= ? ORDER BY seq ASC", [sessionId, floorSeq]);
         const entries = eventRows.map((r) => typeof r.payload === "string" ? JSON.parse(r.payload) : r.payload);
-        // #292 C18:持久化的 placement 元组骑在 core 5.48 的 `SessionMetadata.placement` 可选键上
-        // (普通会话不铸这个键)——于是「这只会话是不是 placed」对每一个拿到 session 的消费方都是**同一份**
-        // 事实,不需要谁再去猜或另查一次。
         const placement = placementFromRow(meta);
         const metadata = { id: sessionId, createdAt: toIso(meta.created_at), ...(placement !== undefined ? { placement } : {}) };
         return new TiDBSessionStorage(pool, sessionId, metadata, entries, meta.leaf_id ?? null, Number(meta.leaf_seq), floorEntryId, floorSeq);
     }
-    /** The bounded-window floor = last compaction's firstKeptEntryId (and its seq). */
     static async computeFloor(pool, sessionId) {
         const [compRows] = await pool.query("SELECT payload FROM session_event WHERE session_id = ? AND type = 'compaction' ORDER BY seq DESC LIMIT 1", [sessionId]);
         if (!compRows[0])
@@ -108,12 +54,10 @@ export class TiDBSessionStorage extends BaseSessionStorage {
         if (!fk)
             return { floorEntryId: null, floorSeq: 0 };
         const [seqRows] = await pool.query("SELECT seq FROM session_event WHERE session_id = ? AND entry_id = ?", [sessionId, fk]);
-        // firstKeptEntryId missing from the log (shouldn't happen) → degrade to full load.
         if (!seqRows[0])
             return { floorEntryId: null, floorSeq: 0 };
         return { floorEntryId: fk, floorSeq: Number(seqRows[0].seq) };
     }
-    /** Sub-floor lookups (e.g. a label target) aren't in the loaded tail — fall back to the durable log. */
     async getEntry(id) {
         const inMem = await super.getEntry(id);
         if (inMem)
@@ -129,16 +73,10 @@ export class TiDBSessionStorage extends BaseSessionStorage {
         this.recordEntry(entry);
     }
     async setLeafId(leafId, opts) {
-        // A leaf move is itself a persisted `leaf` entry whose parent is the current leaf.
         const leafEntry = this.createLeafEntry(leafId);
         await this.persist(leafEntry, opts);
         this.recordEntry(leafEntry);
     }
-    /**
-     * Atomically: CAS the meta leaf (+bump leaf_seq), then append the event at the new seq.
-     * The `(session_id, seq)` primary key is the backstop — a racing writer that grabbed the same
-     * seq makes our INSERT fail with a duplicate-key, which we translate to a conflict too.
-     */
     async persist(entry, opts) {
         const newLeaf = leafIdAfterEntry(entry);
         const conditional = opts !== undefined && opts.expectedLeafId !== undefined;
@@ -155,21 +93,17 @@ export class TiDBSessionStorage extends BaseSessionStorage {
             }
             const [seqRows] = await conn.query("SELECT leaf_seq, owner FROM session_meta WHERE session_id = ?", [this.sessionId]);
             const seq = Number(seqRows[0].leaf_seq);
-            // codex-2(S2 批):S2 发射的 owner 必须取**本事务当前行**——wake 快照在「wake 后被 delete+reclaim」
-            // 窗口里是陈旧 A,而旧 A 条目仍在=假匹配,新租户 leaf 泄进旧流。事务内同 SELECT 捎带=commit 时刻
-            // 真 owner,零额外查询;reclaim 后=B ⇒ notifyLocal 对 A 条目 drop(围栏真闭合)。
             const commitOwner = seqRows[0].owner ?? null;
             await conn.query("INSERT INTO session_event (session_id, seq, entry_id, parent_id, type, payload, ts) VALUES (?,?,?,?,?,?,?)", [this.sessionId, seq, entry.id, entry.parentId ?? null, entry.type, JSON.stringify(entry), new Date(entry.timestamp)]);
             await conn.commit();
             this.leafSeq = seq;
-            emitLeafAdvance(this.sessionId, newLeaf, commitOwner, seq); // S2 fast path — post-commit only, fire-and-forget (session-leaf-bus 契约)
+            emitLeafAdvance(this.sessionId, newLeaf, commitOwner, seq);
         }
         catch (err) {
             try {
                 await conn.rollback();
             }
             catch {
-                /* ignore rollback error */
             }
             if (err instanceof SessionError)
                 throw err;