@sema-agent/server 7.93.7 → 7.95.0

package/dist/plugins/memory-engine-tidb.js

@@ -1,4 +1,6 @@
 import { jaccardDistance, termSet } from "@sema-agent/core";
+import { readFrontmatterColumn } from "./memory-engine-vector-util.js";
+import { decodeJsonColumn, foldJsonColumn, jsonColumnText } from "./sql-json-column.js";
 import { computeEntryRev, serializeEntryFile } from "@sema-agent/core";
 import { pgHasUnstorable } from "./pg-safe-json.js";
 import { assertMemoryScopeWidth, memoryEntryKeyWidthRefusal } from "./memory-key-guards.js";
@@ -41,8 +43,13 @@ function isPrimaryKeyDup(err) {
 function inPlaceholders(count) {
     return Array.from({ length: count }, () => "?").join(", ");
 }
-function fromJson(v) {
-    return (typeof v === "string" ? JSON.parse(v) : v);
+function readFrontmatter(cell, id) {
+    try {
+        return decodeJsonColumn(cell, readFrontmatterColumn, `${TIDB_MEMORY_ENGINE_TABLES.entry}.frontmatter for entry ${String(id)}`);
+    }
+    catch (e) {
+        throw foldJsonColumn(e, (m) => new Error(`memory-engine: ${m} — refusing rather than serve a note whose frontmatter (the origin/exposure law carrier) nobody can read`));
+    }
 }
 export class TiDBMemoryEngineBackend {
     pool;
@@ -72,7 +79,7 @@ export class TiDBMemoryEngineBackend {
         return `${fm.name ?? slug} ${fm.description ?? ""} ${body}`;
     }
     headerFromRow(r) {
-        const fm = fromJson(r.frontmatter);
+        const fm = readFrontmatter(r.frontmatter, r.id);
         return {
             id: r.id,
             slug: r.slug,
@@ -92,7 +99,7 @@ export class TiDBMemoryEngineBackend {
             id: r.id,
             slug: r.slug,
             scope: r.scope,
-            frontmatter: fromJson(r.frontmatter),
+            frontmatter: readFrontmatter(r.frontmatter, r.id),
             body: r.body,
             rev: r.rev,
         };
@@ -101,14 +108,14 @@ export class TiDBMemoryEngineBackend {
         const uniq = [...new Set(scopes)];
         if (uniq.length === 0)
             return [];
-        const rows = await this.selectRows(`SELECT id, scope, slug, frontmatter, rev, mtime_ms, size_bytes FROM ${TIDB_MEMORY_ENGINE_TABLES.entry} WHERE scope IN (${inPlaceholders(uniq.length)}) ORDER BY id`, uniq);
+        const rows = await this.selectRows(`SELECT id, scope, slug, ${jsonColumnText("tidb", "frontmatter")}, rev, mtime_ms, size_bytes FROM ${TIDB_MEMORY_ENGINE_TABLES.entry} WHERE scope IN (${inPlaceholders(uniq.length)}) ORDER BY id`, uniq);
         return rows.map((r) => this.headerFromRow(r));
     }
     async getByIds(ids) {
         const uniq = [...new Set(ids)];
         if (uniq.length === 0)
             return [];
-        const rows = await this.selectRows(`SELECT id, scope, slug, frontmatter, body, rev, mtime_ms, size_bytes FROM ${TIDB_MEMORY_ENGINE_TABLES.entry} WHERE id IN (${inPlaceholders(uniq.length)}) ORDER BY id`, uniq);
+        const rows = await this.selectRows(`SELECT id, scope, slug, ${jsonColumnText("tidb", "frontmatter")}, body, rev, mtime_ms, size_bytes FROM ${TIDB_MEMORY_ENGINE_TABLES.entry} WHERE id IN (${inPlaceholders(uniq.length)}) ORDER BY id`, uniq);
         return rows.map((r) => this.entryFromRow(r));
     }
     async search(query, scopes, opts) {
@@ -121,11 +128,11 @@ export class TiDBMemoryEngineBackend {
         if (q.size === 0)
             return [];
         const uniq = [...new Set(scopes)];
-        const rows = await this.selectRows(`SELECT id, scope, slug, frontmatter, body, rev, mtime_ms, size_bytes FROM ${TIDB_MEMORY_ENGINE_TABLES.entry} WHERE scope IN (${inPlaceholders(uniq.length)})`, uniq);
+        const rows = await this.selectRows(`SELECT id, scope, slug, ${jsonColumnText("tidb", "frontmatter")}, body, rev, mtime_ms, size_bytes FROM ${TIDB_MEMORY_ENGINE_TABLES.entry} WHERE scope IN (${inPlaceholders(uniq.length)})`, uniq);
         const scored = [];
         for (const raw of rows) {
             const r = raw;
-            const fm = fromJson(r.frontmatter);
+            const fm = readFrontmatter(r.frontmatter, r.id);
             const d = jaccardDistance(q, this.haystackOf(r.slug, fm, r.body));
             if (d === null)
                 continue;
@@ -203,11 +210,11 @@ export class TiDBMemoryEngineBackend {
                 report.conflicts.push({ op: "add", id: entry.id, reason: "unstorable_bytes (utf8mb4 cannot store NUL/lone surrogates without mangling; strip them at the source — the store never rewrites content)" });
                 return;
             }
-            const prior = await this.selectRows(`SELECT scope, slug, rev, frontmatter FROM ${T} WHERE id = ?`, [entry.id]);
+            const prior = await this.selectRows(`SELECT scope, slug, rev, ${jsonColumnText("tidb", "frontmatter")} FROM ${T} WHERE id = ?`, [entry.id]);
             const priorRow = prior.length > 0 ? prior[0] : undefined;
             let existsById = priorRow !== undefined;
             {
-                const committedBaseFm = rememberBatchCommitted(originBaseline, entry.id, priorRow !== undefined ? fromJson(priorRow.frontmatter) : undefined);
+                const committedBaseFm = rememberBatchCommitted(originBaseline, entry.id, priorRow !== undefined ? readFrontmatter(priorRow.frontmatter, entry.id) : undefined);
                 const refusal = originWhitewashRefusal("add", committedBaseFm, entry.frontmatter);
                 if (refusal !== undefined) {
                     report.conflicts.push({ op: "add", id: entry.id, reason: refusal });
@@ -288,7 +295,7 @@ export class TiDBMemoryEngineBackend {
                 slug = `${entry.slug}-${n}`;
             }
         }
-        const cur = await this.selectRows(`SELECT slug, rev, scope, frontmatter FROM ${T} WHERE id = ?`, [patch.id]);
+        const cur = await this.selectRows(`SELECT slug, rev, scope, ${jsonColumnText("tidb", "frontmatter")} FROM ${T} WHERE id = ?`, [patch.id]);
         if (cur.length === 0) {
             report.conflicts.push({ op: patch.op, id: patch.id, reason: "unknown id (entry not found in backend)" });
             return;
@@ -296,7 +303,7 @@ export class TiDBMemoryEngineBackend {
         const currentRev = String(cur[0].rev);
         const currentSlug = String(cur[0].slug);
         const currentScope = String(cur[0].scope);
-        const committedFm = fromJson(cur[0].frontmatter);
+        const committedFm = readFrontmatter(cur[0].frontmatter, patch.id);
         const committedBaseFm = rememberBatchCommitted(originBaseline, patch.id, committedFm);
         if (patch.op === "update" && patch.entry !== undefined) {
             if (committedFm.provenance?.kind === "repo_file") {

package/dist/plugins/memory-engine-vector-util.d.ts

@@ -1,2 +1,28 @@
+/** memory-engine 方言实现共用的纯工具函数。三个距离/词集函数(termSet/jaccardDistance/cosineDistance)
+ *  在 core(1.268.0 起公开导出,单一语义源)——消费者直引 core([ref] 兼容面全清:此处转口已删)。
+ *  `isUniqueViolation` 重新内联:它当年随 core 的 pg **示例适配器**导出面走,core 1.424 按 clay 包卫生令
+ *  把整个 examples 面退出 npm 包([ref] BREAKING)⇒ re-export 断源。原为逐字抄自 core 1.423
+ *  `examples/adapters/pg-adapter.js`(纯谓词,无 byte-equal 契约约束);[ref] P1-① 后**码面判据**
+ *  改走属主 `sql-errors.ts`,只留 message 补充臂(理由在函数体内)。 */
+import type { MemoryEntryFrontmatter } from "@sema-agent/core";
+import { type JsonColumnReader } from "./sql-json-column.js";
 export declare function isUniqueViolation(err: unknown): boolean;
+/**
+ * `agent_memory_engine_entry.frontmatter` 的**形读者**。
+ *
+ * 🔴 判据只到「一只 JSON 对象」为止:键表属主在 core(`MemoryEntryFrontmatter`),而 core 没有导出
+ * 验证器 —— 在这里手写一份等价 zod 就是设计稿明令禁止的第二份键集。这一条最小判据已经把坏体四形全关在
+ * 门外,而此前这里是**零判据**(裸 `JSON.parse` + `as MemoryEntryFrontmatter`)。
+ *
+ * 🔴 失败方向 = **拒**,而且这一列不是普通载荷:`frontmatter` 是 **origin/exposure 不可变律**的载体
+ * (`committedOriginOf` / `exposureBandOf` / `distilledCarriage` 全读它)。一行读不出形的 frontmatter 被
+ * 当成 `{}` 端出去 = 那条笔记的 external-origin 标记与曝光带**静默消失** —— 洗白检查(`originWhitewashRefusal`)
+ * 拿到的「已提交基线」于是是空的,一次真的洗白会被放过。
+ */
+export declare const readFrontmatterColumn: JsonColumnReader<MemoryEntryFrontmatter>;
+/**
+ * `agent_memory_engine_entry.embedding` 的**形读者** = 本店既有的那一条判据(`Array.isArray`)。
+ * 维数判据仍在调用点(它要跟 embedder 的 `dimensions` 比,那是运行期事实,不是列的形)。
+ */
+export declare const readEmbeddingColumn: JsonColumnReader<unknown[]>;
 //# sourceMappingURL=memory-engine-vector-util.d.ts.map

package/dist/plugins/memory-engine-vector-util.js

@@ -1,4 +1,5 @@
 import { isPgUniqueViolation } from "./sql-errors.js";
+import { createObjectColumnReader, readJsonArrayColumn } from "./sql-json-column.js";
 export function isUniqueViolation(err) {
     if (isPgUniqueViolation(err))
         return true;
@@ -6,4 +7,6 @@ export function isUniqueViolation(err) {
         return false;
     return /duplicate key|unique constraint|already exists/i.test(String(err.message ?? ""));
 }
+export const readFrontmatterColumn = createObjectColumnReader();
+export const readEmbeddingColumn = readJsonArrayColumn;
 //# sourceMappingURL=memory-engine-vector-util.js.map

package/dist/plugins/memory-sync-store-pg.d.ts

@@ -50,6 +50,12 @@ export interface MemorySyncStore {
 export declare const MEMORY_SYNC_INDEXES: readonly IndexSpec[];
 /** Idempotent DDL for the sync plane (PG dialect). Call once at startup. */
 export declare function ensurePgMemorySyncSchema(query: PgQueryFn): Promise<void>;
+/**
+ * 本店三只 JSON 承载列的**折码点**(唯一)—— 本店没有枚举式 corrupt 码,既有的「读不出来」口径就是
+ * 响亮抛(`claimLeaseMs` 守卫 / dup id 一律 fail-loud)⇒ 折成响亮裸 `Error`,点名 `<表>.<列>` + 行标识
+ * (S-550 车①② 裁定,沿用;不新铸码)。两个孪生共用本函数(MySQL 腿 import 它 —— 一条折码规则一个写者)。
+ */
+export declare function refusingMemorySyncRow<T>(read: () => T): T;
 /** Options for {@link PgMemorySyncStore}. */
 export interface PgMemorySyncStoreOptions {
     /** How long a `claimDue` lease holds a row invisible before a crashed worker's claim self-heals.

package/dist/plugins/memory-sync-store-pg.js

@@ -1,6 +1,7 @@
 import { ensureIndexes } from "./ensure-index.js";
 import { pgSafeJsonStringify, pgProtocolJsonStringify } from "./pg-safe-json.js";
 import { assertMemoryScopeWidth } from "./memory-key-guards.js";
+import { decodeJsonColumn, decodeNullableJsonColumn, foldJsonColumn, jsonColumnText, readNonNullJsonValueColumn, readOpaqueJsonValueColumn, readStringRecordColumn, } from "./sql-json-column.js";
 export const PG_MEMORY_SYNC_TABLES = {
     syncCursor: "agent_memory_engine_sync_cursor",
     pushQueue: "agent_memory_engine_push_queue",
@@ -28,10 +29,13 @@ export async function ensurePgMemorySyncSchema(query) {
   )`);
     await ensureIndexes(query, "pg", MEMORY_SYNC_INDEXES);
 }
-function fromJsonb(v) {
-    if (typeof v === "string")
-        return JSON.parse(v);
-    return v;
+export function refusingMemorySyncRow(read) {
+    try {
+        return read();
+    }
+    catch (e) {
+        throw foldJsonColumn(e, (m) => new Error(`memory-sync store: ${m} — refusing rather than serve a sync row nobody can read`));
+    }
 }
 function toMs(v) {
     return typeof v === "number" ? v : Number(v);
@@ -48,14 +52,14 @@ export class PgMemorySyncStore {
         this.claimLeaseMs = lease;
     }
     async getCursor(scope, peer) {
-        const res = await this.query(`SELECT base_revs, updated_at_ms FROM ${PG_MEMORY_SYNC_TABLES.syncCursor} WHERE scope = $1 AND peer = $2`, [scope, peer]);
+        const res = await this.query(`SELECT ${jsonColumnText("pg", "base_revs")}, updated_at_ms FROM ${PG_MEMORY_SYNC_TABLES.syncCursor} WHERE scope = $1 AND peer = $2`, [scope, peer]);
         const row = res.rows[0];
         if (!row)
             return undefined;
         return {
             scope,
             peer,
-            baseRevs: fromJsonb(row.base_revs),
+            baseRevs: refusingMemorySyncRow(() => decodeJsonColumn(row.base_revs, readStringRecordColumn, `${PG_MEMORY_SYNC_TABLES.syncCursor}.base_revs for scope ${scope} peer ${peer}`)),
             updatedAtMs: toMs(row.updated_at_ms),
         };
     }
@@ -83,12 +87,12 @@ export class PgMemorySyncStore {
        )
        UPDATE ${PG_MEMORY_SYNC_TABLES.pushQueue} q SET next_attempt_at_ms = $3
        FROM due WHERE q.id = due.id
-       RETURNING q.id, q.scope, q.entry_id, q.payload, q.attempts, q.last_error`, [nowMs, limit, leasedUntilMs]);
+       RETURNING q.id, q.scope, q.entry_id, ${jsonColumnText("pg", "payload")}, q.attempts, q.last_error`, [nowMs, limit, leasedUntilMs]);
         return res.rows.map((r) => ({
             id: String(r.id),
             scope: String(r.scope),
             entryId: String(r.entry_id),
-            payload: fromJsonb(r.payload),
+            payload: refusingMemorySyncRow(() => decodeJsonColumn(r.payload, readOpaqueJsonValueColumn, `${PG_MEMORY_SYNC_TABLES.pushQueue}.payload for item ${String(r.id)}`)),
             attempts: toMs(r.attempts),
             lastError: r.last_error == null ? null : String(r.last_error),
             leasedUntilMs,
@@ -138,7 +142,7 @@ export class PgMemoryHistoryStore {
        ON CONFLICT (id, rev) DO NOTHING`, params);
     }
     async historyOf(id) {
-        const res = await this.query(`SELECT id, rev, prev_rev, op, scope, snapshot, written_at_ms
+        const res = await this.query(`SELECT id, rev, prev_rev, op, scope, ${jsonColumnText("pg", "snapshot")}, written_at_ms
        FROM ${PG_MEMORY_SYNC_TABLES.history}
        WHERE id = $1
        ORDER BY written_at_ms ASC, rev ASC`, [id]);
@@ -156,7 +160,7 @@ export function historyRowFrom(r) {
         prevRev: r.prev_rev == null ? null : String(r.prev_rev),
         op: String(r.op),
         scope: String(r.scope),
-        snapshot: r.snapshot == null ? null : fromJsonb(r.snapshot),
+        snapshot: refusingMemorySyncRow(() => decodeNullableJsonColumn(r.snapshot, readNonNullJsonValueColumn, `${PG_MEMORY_SYNC_TABLES.history}.snapshot for entry ${String(r.id)} rev ${String(r.rev)}`)) ?? null,
         writtenAtMs: toMs(r.written_at_ms),
     };
 }

package/dist/plugins/memory-sync-store-tidb.js

@@ -1,4 +1,5 @@
-import { historyRowFrom } from "./memory-sync-store-pg.js";
+import { historyRowFrom, refusingMemorySyncRow } from "./memory-sync-store-pg.js";
+import { decodeJsonColumn, jsonColumnText, readOpaqueJsonValueColumn, readStringRecordColumn } from "./sql-json-column.js";
 import { ensureIndexes } from "./ensure-index.js";
 import { MEMORY_SYNC_INDEXES, MEMORY_HISTORY_INDEXES, PG_MEMORY_SYNC_TABLES } from "./memory-sync-store-pg.js";
 import { assertMemoryScopeWidth } from "./memory-key-guards.js";
@@ -30,11 +31,6 @@ export async function ensureTiDBMemorySyncSchema(pool) {
   ) COLLATE utf8mb4_bin`);
     await ensureIndexes((text, params) => pool.query(text, params), "mysql", MEMORY_SYNC_INDEXES);
 }
-function fromJson(v) {
-    if (typeof v === "string")
-        return JSON.parse(v);
-    return v;
-}
 function toMs(v) {
     return typeof v === "number" ? v : Number(v);
 }
@@ -50,14 +46,14 @@ export class TiDBMemorySyncStore {
         this.claimLeaseMs = lease;
     }
     async getCursor(scope, peer) {
-        const [rows] = await this.pool.query(`SELECT base_revs, updated_at_ms FROM ${TIDB_MEMORY_SYNC_TABLES.syncCursor} WHERE scope = ? AND peer = ?`, [scope, peer]);
+        const [rows] = await this.pool.query(`SELECT ${jsonColumnText("tidb", "base_revs")}, updated_at_ms FROM ${TIDB_MEMORY_SYNC_TABLES.syncCursor} WHERE scope = ? AND peer = ?`, [scope, peer]);
         const row = rows[0];
         if (!row)
             return undefined;
         return {
             scope,
             peer,
-            baseRevs: fromJson(row.base_revs),
+            baseRevs: refusingMemorySyncRow(() => decodeJsonColumn(row.base_revs, readStringRecordColumn, `${TIDB_MEMORY_SYNC_TABLES.syncCursor}.base_revs for scope ${scope} peer ${peer}`)),
             updatedAtMs: toMs(row.updated_at_ms),
         };
     }
@@ -76,7 +72,7 @@ export class TiDBMemorySyncStore {
         if (limit <= 0)
             return [];
         const leasedUntilMs = nowMs + this.claimLeaseMs;
-        const [candidates] = await this.pool.query(`SELECT id, scope, entry_id, payload, attempts, next_attempt_at_ms, last_error
+        const [candidates] = await this.pool.query(`SELECT id, scope, entry_id, ${jsonColumnText("tidb", "payload")}, attempts, next_attempt_at_ms, last_error
        FROM ${TIDB_MEMORY_SYNC_TABLES.pushQueue}
        WHERE next_attempt_at_ms <= ?
        ORDER BY next_attempt_at_ms, id
@@ -92,7 +88,7 @@ export class TiDBMemorySyncStore {
                 id: row.id,
                 scope: row.scope,
                 entryId: row.entry_id,
-                payload: fromJson(row.payload),
+                payload: refusingMemorySyncRow(() => decodeJsonColumn(row.payload, readOpaqueJsonValueColumn, `${TIDB_MEMORY_SYNC_TABLES.pushQueue}.payload for item ${row.id}`)),
                 attempts: toMs(row.attempts),
                 lastError: row.last_error == null ? null : String(row.last_error),
                 leasedUntilMs,
@@ -141,7 +137,7 @@ export class TiDBMemoryHistoryStore {
        ON DUPLICATE KEY UPDATE id = id`, params);
     }
     async historyOf(id) {
-        const [rows] = await this.pool.query(`SELECT id, rev, prev_rev, op, scope, snapshot, written_at_ms
+        const [rows] = await this.pool.query(`SELECT id, rev, prev_rev, op, scope, ${jsonColumnText("tidb", "snapshot")}, written_at_ms
        FROM ${TIDB_MEMORY_SYNC_TABLES.history}
        WHERE id = ?
        ORDER BY written_at_ms ASC, rev ASC`, [id]);

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

@@ -1,6 +1,8 @@
 import { emitLeafAdvance } from "../session-leaf-bus.js";
 import { BaseSessionStorage, StoredSession, SessionError, uuidv7, validateEntriesForImport, leafIdAfterEntry, normalizePromptEpoch, } from "@sema-agent/core";
 import { escapeLike } from "./sql-escape.js";
+import { decodeSessionEventPayload } from "./session-event-payload.js";
+import { jsonColumnText } from "./sql-json-column.js";
 import { pgSafeJsonStringify } from "./pg-safe-json.js";
 import { toIso } from "./sql-row-helpers.js";
 import { assertPlacementAdmission, LIST_PLACED_BATCH, PLACEMENT_SELECT_COLUMNS, placedRowFromRow, placementFromRow, placementInsertValues, SQL_SESSION_PLACEMENTS, } from "./session-placement.js";
@@ -10,9 +12,6 @@ import { isPgUniqueViolation } from "./sql-errors.js";
 import { MANAGED_RETENTION } from "./retention-store-sql.js";
 import { ensureIndexes } from "./ensure-index.js";
 const isDupKey = isPgUniqueViolation;
-function parseEntry(p) {
-    return (typeof p === "string" ? JSON.parse(p) : p);
-}
 export const PG_SESSION_SCHEMA = [
     `CREATE TABLE IF NOT EXISTS session_meta (
      session_id  VARCHAR(64) COLLATE "C"  NOT NULL,
@@ -74,11 +73,11 @@ export class PgSessionStorage extends BaseSessionStorage {
             return undefined;
         let cursor = this.floorSeq;
         for (;;) {
-            const res = await this.pool.query("SELECT seq, payload FROM session_event WHERE session_id = $1 AND seq < $2 AND type IN ('prompt_epoch','compaction') ORDER BY seq DESC LIMIT 100", [this.sessionId, cursor]);
+            const res = await this.pool.query(`SELECT seq, ${jsonColumnText("pg", "payload")} FROM session_event WHERE session_id = $1 AND seq < $2 AND type IN ('prompt_epoch','compaction') ORDER BY seq DESC LIMIT 100`, [this.sessionId, cursor]);
             if (res.rows.length === 0)
                 return undefined;
             for (const r of res.rows) {
-                const e = parseEntry(r.payload);
+                const e = decodeSessionEventPayload(r.payload, this.sessionId, r.seq);
                 const d = e.type === "prompt_epoch" ? normalizePromptEpoch(e) : normalizePromptEpoch(e.details?.promptEpoch);
                 if (d)
                     return d;
@@ -92,18 +91,18 @@ export class PgSessionStorage extends BaseSessionStorage {
         if (!meta)
             return null;
         const { floorEntryId, floorSeq } = await PgSessionStorage.computeFloor(pool, sessionId);
-        const eventRes = await pool.query("SELECT payload FROM session_event WHERE session_id = $1 AND seq >= $2 ORDER BY seq ASC", [sessionId, floorSeq]);
-        const entries = eventRes.rows.map((r) => parseEntry(r.payload));
+        const eventRes = await pool.query(`SELECT seq, ${jsonColumnText("pg", "payload")} FROM session_event WHERE session_id = $1 AND seq >= $2 ORDER BY seq ASC`, [sessionId, floorSeq]);
+        const entries = eventRes.rows.map((r) => decodeSessionEventPayload(r.payload, sessionId, r.seq));
         const placement = placementFromRow(meta);
         const metadata = { id: sessionId, createdAt: toIso(meta.created_at), ...(placement !== undefined ? { placement } : {}) };
         return new PgSessionStorage(pool, sessionId, metadata, entries, meta.leaf_id ?? null, floorEntryId, floorSeq);
     }
     static async computeFloor(pool, sessionId) {
-        const compRes = await pool.query("SELECT payload FROM session_event WHERE session_id = $1 AND type = 'compaction' ORDER BY seq DESC LIMIT 1", [sessionId]);
+        const compRes = await pool.query(`SELECT ${jsonColumnText("pg", "payload")} FROM session_event WHERE session_id = $1 AND type = 'compaction' ORDER BY seq DESC LIMIT 1`, [sessionId]);
         if (!compRes.rows[0])
             return { floorEntryId: null, floorSeq: 0 };
-        const comp = parseEntry(compRes.rows[0].payload);
-        const fk = comp.firstKeptEntryId;
+        const comp = decodeSessionEventPayload(compRes.rows[0].payload, sessionId, "latest compaction");
+        const fk = comp.type === "compaction" ? comp.firstKeptEntryId : undefined;
         if (!fk)
             return { floorEntryId: null, floorSeq: 0 };
         const seqRes = await pool.query("SELECT seq FROM session_event WHERE session_id = $1 AND entry_id = $2", [sessionId, fk]);
@@ -115,11 +114,10 @@ export class PgSessionStorage extends BaseSessionStorage {
         const inMem = await super.getEntry(id);
         if (inMem)
             return inMem;
-        const res = await this.pool.query("SELECT payload FROM session_event WHERE session_id = $1 AND entry_id = $2", [this.sessionId, id]);
-        const p = res.rows[0]?.payload;
-        if (p == null)
+        const res = await this.pool.query(`SELECT ${jsonColumnText("pg", "payload")} FROM session_event WHERE session_id = $1 AND entry_id = $2`, [this.sessionId, id]);
+        if (res.rows[0] === undefined)
             return undefined;
-        return parseEntry(p);
+        return decodeSessionEventPayload(res.rows[0].payload, this.sessionId, id);
     }
     async appendEntry(entry, opts) {
         await this.persist(entry, opts);
@@ -355,7 +353,7 @@ export class PgSessionStore {
         if (!metaRes.rows[0])
             return null;
         const leafId = metaRes.rows[0].leaf_id ?? null;
-        const eventRes = await this.pool.query("SELECT entry_id, parent_id, type, payload, ts FROM session_event WHERE session_id = $1 ORDER BY seq ASC", [sourceId]);
+        const eventRes = await this.pool.query(`SELECT entry_id, parent_id, type, ${jsonColumnText("pg", "payload")}, ts FROM session_event WHERE session_id = $1 ORDER BY seq ASC`, [sourceId]);
         const rows = eventRes.rows;
         const newId = uuidv7();
         const now = new Date();
@@ -364,7 +362,7 @@ export class PgSessionStore {
             await conn.query("BEGIN");
             for (let seq = 0; seq < rows.length; seq++) {
                 const r = rows[seq];
-                const payload = typeof r.payload === "string" ? r.payload : pgSafeJsonStringify(r.payload);
+                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]);
@@ -387,8 +385,8 @@ export class PgSessionStore {
         const metaRes = await this.pool.query("SELECT 1 FROM session_meta WHERE session_id = $1", [sessionId]);
         if (metaRes.rows.length === 0)
             return null;
-        const eventRes = await this.pool.query("SELECT payload FROM session_event WHERE session_id = $1 ORDER BY seq ASC", [sessionId]);
-        return eventRes.rows.map((r) => parseEntry(r.payload));
+        const eventRes = await this.pool.query(`SELECT seq, ${jsonColumnText("pg", "payload")} FROM session_event WHERE session_id = $1 ORDER BY seq ASC`, [sessionId]);
+        return eventRes.rows.map((r) => decodeSessionEventPayload(r.payload, sessionId, r.seq));
     }
     async listEntryIds(sessionId) {
         const metaRes = await this.pool.query("SELECT 1 FROM session_meta WHERE session_id = $1", [sessionId]);
@@ -406,9 +404,9 @@ export class PgSessionStore {
         async function* gen() {
             let cursor = opts?.afterSeq ?? -1;
             for (;;) {
-                const res = await pool.query("SELECT seq, payload FROM session_event WHERE session_id = $1 AND seq > $2 ORDER BY seq ASC LIMIT $3", [sessionId, cursor, batchSize]);
+                const res = await pool.query(`SELECT seq, ${jsonColumnText("pg", "payload")} FROM session_event WHERE session_id = $1 AND seq > $2 ORDER BY seq ASC LIMIT $3`, [sessionId, cursor, batchSize]);
                 for (const r of res.rows)
-                    yield parseEntry(r.payload);
+                    yield decodeSessionEventPayload(r.payload, sessionId, r.seq);
                 if (res.rows.length < batchSize)
                     return;
                 cursor = Number(res.rows[res.rows.length - 1].seq);
@@ -483,8 +481,8 @@ export class PgSessionStore {
         return new PgStagingHandle(this.pool, realSessionId, stagingIdFor(realSessionId, token));
     }
     async readStagedEntries(stagingId) {
-        const res = await this.pool.query("SELECT payload FROM session_event WHERE session_id = $1 ORDER BY seq ASC", [stagingId]);
-        return res.rows.map((r) => parseEntry(r.payload));
+        const res = await this.pool.query(`SELECT seq, ${jsonColumnText("pg", "payload")} FROM session_event WHERE session_id = $1 ORDER BY seq ASC`, [stagingId]);
+        return res.rows.map((r) => decodeSessionEventPayload(r.payload, stagingId, r.seq));
     }
     async sweepStagingSessions() {
         const cutoff = new Date(Date.now() - STAGING_GC_GRACE_MS);
@@ -579,11 +577,11 @@ class PgStagingHandle {
                 throw new SyncConflictError(this.realSessionId, rel);
             }
             if (rel.relation === "fast_forward" && opts?.resolution !== "overwrite-dst" && dstIds !== null && dstIds.length > 0) {
-                const dstFull = await conn.query("SELECT payload FROM session_event WHERE session_id = $1 ORDER BY seq ASC", [this.realSessionId]);
-                const stagedFull = await conn.query("SELECT entry_id, payload FROM session_event WHERE session_id = $1 ORDER BY seq ASC", [this.stagingId]);
+                const dstFull = await conn.query(`SELECT seq, ${jsonColumnText("pg", "payload")} FROM session_event WHERE session_id = $1 ORDER BY seq ASC`, [this.realSessionId]);
+                const stagedFull = await conn.query(`SELECT entry_id, ${jsonColumnText("pg", "payload")} FROM session_event WHERE session_id = $1 ORDER BY seq ASC`, [this.stagingId]);
                 const dstSet = new Set(dstIds);
-                const dstEntries = dstFull.rows.map((r) => parseEntry(r.payload));
-                const stagedShared = stagedFull.rows.filter((r) => dstSet.has(String(r.entry_id))).map((r) => parseEntry(r.payload));
+                const dstEntries = dstFull.rows.map((r) => decodeSessionEventPayload(r.payload, this.realSessionId, r.seq));
+                const stagedShared = stagedFull.rows.filter((r) => dstSet.has(String(r.entry_id))).map((r) => decodeSessionEventPayload(r.payload, this.stagingId, r.entry_id));
                 const diverged = fastForwardSharedContentDiverged(stagedShared, dstEntries);
                 if (diverged) {
                     await conn.query("ROLLBACK");
@@ -592,10 +590,10 @@ class PgStagingHandle {
             }
             await conn.query("DELETE FROM session_event WHERE session_id = $1", [this.realSessionId]);
             await conn.query("UPDATE session_event SET session_id = $1 WHERE session_id = $2", [this.realSessionId, this.stagingId]);
-            const lastRes = await conn.query("SELECT payload FROM session_event WHERE session_id = $1 ORDER BY seq DESC LIMIT 1", [this.realSessionId]);
+            const lastRes = await conn.query(`SELECT ${jsonColumnText("pg", "payload")} FROM session_event WHERE session_id = $1 ORDER BY seq DESC LIMIT 1`, [this.realSessionId]);
             let leafId = null;
             if (lastRes.rows[0])
-                leafId = leafIdAfterEntry(parseEntry(lastRes.rows[0].payload));
+                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]);

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

@@ -0,0 +1,37 @@
+/**
+ * **`session_event.payload` 这一列的单一属主**(S-550 车③a)—— 投影铸点、解码点、形读者各一份,三个
+ * 会话存储腿(`tidb-session-storage.ts` / `pg-session-storage.ts` / `tidb-session-store.ts`)共读本文件。
+ *
+ * ## 为什么必须收成一处
+ * 这一列此前有 **10 个** 各自写一遍的读法(`typeof p === "string" ? JSON.parse(p) : p as SessionTreeEntry`),
+ * 分布在三个文件的 wake / getEntry / getEpochAnchor / computeFloor / export / fork / import / 收尾 leaf
+ * 计算上。那个三元式正是 S-550 要消灭的歧义本身:**从值本身分不出驱动解过没解过**,而这一列在 MySQL 侧是
+ * `JSON`、PG 侧是 `JSONB` —— 一台 MariaDB 部署上它以文本到达(驱动不自动解码),一条被迁移脚本多
+ * `JSON.stringify` 过一次的行则在真 JSON 列上「串就再解一次」地被读成好体。十份拷贝里只要有一份将来
+ * 忘了跟,那一条 wake 就会静默读出半棵树。
+ *
+ * ## 失败方向 = 拒
+ * 会话事件日志是 **wake 的全部依据**:一行读不出形的 payload 被当成 `null` / 空对象端出去 ⇒ 这只会话的
+ * 上下文树里多一个没有 `id`、没有 `type` 的节点,`leafIdAfterEntry` 与 `buildContext` 在它上面的行为未定;
+ * 静默跳过它则是**一段对话从历史里消失**(而模型会照着一棵少了一截的树继续说话)。两者都比一次响亮的
+ * wake 失败坏。本店没有枚举式 corrupt 码(`SessionError` 的词表 —— `conflict` 等 —— 是并发契约词,
+ * 不是读侧 corrupt 词)⇒ 折成响亮裸 `Error`,点名 `<表>.<列>` + 行标识(S-550 车①② 裁定,沿用)。
+ */
+import type { SessionTreeEntry } from "@sema-agent/core";
+import { type JsonColumnReader } from "./sql-json-column.js";
+/**
+ * 形读者:core 自己声明的 `SessionTreeEntryBase` 里那两把**不可省**的串键。
+ *
+ * 🚧 **如实声明判据的射程**:core 的 base 形是 `{type, id, parentId, timestamp}` 四键全必填,但 `parentId`
+ * 可为 `null`、而 `JSON.stringify` 会把一个 `undefined` 的键直接丢掉 —— 拿它当必填有把存量行判坏的风险。
+ * 所以判据取 `type` + `id` 两把 —— 它们是本仓读腿**自己**要用的那两把:`e.type === "prompt_epoch"`
+ * (epoch 锚点腿)与 core 的 `leafIdAfterEntry`(亲读 7.26.2 的 dist:
+ * `entry.type === "leaf" ? entry.targetId : entry.id`,两把都在里面)。而且它们进得了列就必定是串 ——
+ * 写腿把这两把各自**另外**落进一列 `NOT NULL`(`session_event.entry_id` / `.type`)。
+ * 这两条已经把坏体四形全关在门外;**不复刻 core 的变体键表**(那是设计稿明令禁止的第二份键集,
+ * core 也没有导出 `SessionTreeEntry` 的验证器 —— `validateEntriesForImport` 吃的是已经成形的对象)。
+ */
+export declare const readSessionEventPayload: JsonColumnReader<SessionTreeEntry>;
+/** 一格 `session_event.payload`(已按文本投影)→ 一条事件。坏体 ⇒ 响亮拒(见文件头注)。 */
+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

@@ -0,0 +1,20 @@
+import { decodeJsonColumn, foldJsonColumn } 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)" };
+    const row = body;
+    if (typeof row.id !== "string")
+        return { problem: "the entry carries no string `id`" };
+    if (typeof row.type !== "string")
+        return { problem: "the entry carries no string `type`" };
+    return { value: body };
+};
+export function decodeSessionEventPayload(cell, sessionId, rowId) {
+    try {
+        return decodeJsonColumn(cell, readSessionEventPayload, `session_event.payload for session ${sessionId} row ${String(rowId)}`);
+    }
+    catch (e) {
+        throw foldJsonColumn(e, (m) => new Error(`session storage: ${m} — refusing rather than wake a session from a tree with a node nobody can read`));
+    }
+}
+//# sourceMappingURL=session-event-payload.js.map