@sema-agent/server 7.93.7 → 7.95.0

package/dist/plugins/local-checkpoint-store.js

@@ -1,17 +1,41 @@
+import { z } from "zod";
 import { ASK_USER_QUESTION_TOOL_NAME, contentKindOf } from "../approval-content-kind.js";
 import { createHash } from "node:crypto";
-import { existsSync, readFileSync, readdirSync, renameSync, unlinkSync, mkdirSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, unlinkSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { isApprovalGateKind } from "../tool-approval.js";
 import { FileCheckpointStore, atomicWriteFile, executionVerdict, sanitizePathComponent, } from "@sema-agent/core";
 import { approvalDecisionOfWinner, approvalPayloadFingerprint, boundedRuleOffers, boundedToolInput, pendingActionToolCallId, pendingRowPrecedes, TERMINAL_BACKSTOP_MS, TERMINAL_GRACE_MS } from "./checkpoint-store-sql.js";
+import { quarantineUnreadableSidecar } from "./local-sidecar-quarantine.js";
+import { createZodColumnReader, decodeJsonColumn, readStringArrayColumn } from "./sql-json-column.js";
 import { UNMANAGED_RETENTION } from "./retention-store-sql.js";
+import { assertJsonColumnWritable, createObjectColumnReader } from "./sql-json-column.js";
 function terminalAtOf(cp) {
     return Math.max(cp.createdAt + TERMINAL_BACKSTOP_MS, (cp.deadline ?? 0) + TERMINAL_GRACE_MS);
 }
 function ctxFileOf(sessionId) {
     return `${sanitizePathComponent(sessionId).slice(0, 48)}-${createHash("sha256").update(sessionId).digest("hex").slice(0, 12)}.json`;
 }
+const CtxRecordSchema = z.object({
+    sessionId: z.string(),
+    updatedAt: z.number(),
+    ctx: z.unknown(),
+});
+const readCtxRecord = createZodColumnReader(CtxRecordSchema);
+const readScopeRegistry = readStringArrayColumn;
+const readSessionTokenIndex = createZodColumnReader(z.record(z.string(), z.array(z.string())));
+function createCtxRecordReader() {
+    const readPayload = createObjectColumnReader();
+    return (body) => {
+        const envelope = readCtxRecord(body);
+        if (envelope.problem !== undefined)
+            return { problem: envelope.problem };
+        const payload = readPayload(envelope.value.ctx);
+        if (payload.problem !== undefined)
+            return { problem: `its \`ctx\` member is not a JSON object (${payload.problem})` };
+        return { value: { ...envelope.value, ctx: payload.value } };
+    };
+}
 export class LocalCheckpointStore {
     retention = UNMANAGED_RETENTION;
     durability = "durable";
@@ -37,37 +61,23 @@ export class LocalCheckpointStore {
         mkdirSync(this.tmpDir, { recursive: true });
         if (existsSync(this.scopesPath)) {
             try {
-                const arr = JSON.parse(readFileSync(this.scopesPath, "utf8"));
-                if (Array.isArray(arr))
-                    for (const s of arr)
-                        if (typeof s === "string")
-                            this.scopes.add(s);
+                for (const s of decodeJsonColumn(readFileSync(this.scopesPath, "utf8"), readScopeRegistry, "checkpoint-scopes.json (the local scope registry)"))
+                    this.scopes.add(s);
             }
             catch (e) {
-                const quarantine = `${this.scopesPath}.corrupt-${Date.now()}`;
-                try {
-                    renameSync(this.scopesPath, quarantine);
-                }
-                catch {
-                }
+                quarantineUnreadableSidecar(this.scopesPath, "LocalCheckpointStore scope registry", e instanceof Error ? e.message : String(e));
                 this.scopeRegistryCorrupt = true;
-                console.warn(`LocalCheckpointStore: checkpoint-scopes.json is corrupt (${e instanceof Error ? e.message : String(e)}) — ` +
-                    `will rebuild the scope set from the data plane on first read (core listScopes); ` +
-                    `file quarantined at ${quarantine}`);
+                console.warn("LocalCheckpointStore: will rebuild the scope set from the data plane on first read (core listScopes) — enumeration is EMPTY until then");
             }
         }
         if (existsSync(this.sessionTokensPath)) {
             try {
-                const rec = JSON.parse(readFileSync(this.sessionTokensPath, "utf8"));
-                if (rec && typeof rec === "object" && !Array.isArray(rec)) {
-                    for (const [sid, toks] of Object.entries(rec)) {
-                        if (!Array.isArray(toks))
-                            continue;
-                        this.sessionTokens.set(sid, new Set(toks.filter((t) => typeof t === "string")));
-                    }
-                }
+                const rec = decodeJsonColumn(readFileSync(this.sessionTokensPath, "utf8"), readSessionTokenIndex, "checkpoint-session-tokens.json (the local session→tokens index)");
+                for (const [sid, toks] of Object.entries(rec))
+                    this.sessionTokens.set(sid, new Set(toks));
             }
-            catch {
+            catch (e) {
+                quarantineUnreadableSidecar(this.sessionTokensPath, "LocalCheckpointStore session→tokens index", e instanceof Error ? e.message : String(e));
             }
         }
     }
@@ -298,19 +308,16 @@ export class LocalCheckpointStore {
     }
     async putCtx(sessionId, ctx) {
         const rec = { sessionId, updatedAt: Date.now(), ctx };
-        atomicWriteFile(this.tmpDir, join(this.ctxDir, ctxFileOf(sessionId)), JSON.stringify(rec));
+        const text = JSON.stringify(rec);
+        assertJsonColumnWritable(text, createCtxRecordReader(), `checkpoint ctx for session ${JSON.stringify(sessionId)} (local write leg)`);
+        atomicWriteFile(this.tmpDir, join(this.ctxDir, ctxFileOf(sessionId)), text);
     }
     async getCtx(sessionId) {
         const p = join(this.ctxDir, ctxFileOf(sessionId));
         if (!existsSync(p))
             return null;
-        try {
-            const rec = JSON.parse(readFileSync(p, "utf8"));
-            return rec.sessionId === sessionId ? (rec.ctx ?? null) : null;
-        }
-        catch {
-            return null;
-        }
+        const rec = decodeJsonColumn(readFileSync(p, "utf8"), createCtxRecordReader(), `checkpoint-ctx ${ctxFileOf(sessionId)} for session ${JSON.stringify(sessionId)}`);
+        return rec.sessionId === sessionId ? rec.ctx : null;
     }
     async reapCtx(cutoff) {
         let n = 0;
@@ -320,7 +327,7 @@ export class LocalCheckpointStore {
             const p = join(this.ctxDir, f);
             let rec;
             try {
-                rec = JSON.parse(readFileSync(p, "utf8"));
+                rec = decodeJsonColumn(readFileSync(p, "utf8"), readCtxRecord, `checkpoint-ctx ${f} (reap scan)`);
             }
             catch {
                 continue;

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

@@ -107,6 +107,20 @@ export declare class LocalSessionStore implements SessionStore {
     private doFlush;
     /** Throttled best-effort warn for a sidecar I/O failure (bug D): never throws, at most once per ~minute so a
      *  persistently-failing disk doesn't spam the log on every debounced flush. */
+    /**
+     * 读不出一份边档时的**唯一**处置(两只 sidecar 共用)——先**留证**再降级。
+     *
+     * 🔴 为什么留证是必需的而不是洁癖(codex 对抗复审一轮 [medium],亲验为真;红先在
+     * `test/local-store-bad-body.test.ts`):两只边档都是**整档原子替换**的写法,所以「读不出 ⇒ 空表 +
+     * 继续服务」之后,**下一次写就把原档盖掉了**。对一份整份是垃圾的体无所谓;对一份只有某一格值型
+     * 不对的**混合体**,那等于把一次局部的、可修的损坏放大成一次全量的、不可逆的丢失。判据不变
+     * (半份值仍然不许端出去),改的是拒的那一刻。
+     *
+     * 两条 warn 各说一件事:{@link quarantineUnreadableSidecar} 说「字节挪到哪了」(每次都说,因为它稀有
+     * 且不可重现),{@link warnSidecar} 说「这条腿降级了」(节流,因为写失败可能每拍都发生)。
+     * ENOENT(首次启动没有这份档)在调用点就被排除,压根到不了这里。
+     */
+    private refuseSidecar;
     private warnSidecar;
     acquire(sessionId?: string, opts?: {
         requireExisting?: boolean;

package/dist/plugins/local-session-store.js

@@ -2,6 +2,8 @@ import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { SessionError, validateEntriesForImport } from "@sema-agent/core";
 import { contentForkRelation, fastForwardSharedContentDiverged, identicalIdsAlsoIdenticalContent } from "../session-sync-content.js";
+import { quarantineUnreadableSidecar } from "./local-sidecar-quarantine.js";
+import { decodeJsonColumn, readStringRecordColumn } from "./sql-json-column.js";
 import { UNMANAGED_RETENTION } from "./retention-store-sql.js";
 import { classifySyncRelationshipByIds, SyncConflictError, stagingIdFor, } from "../session-sync-kernel.js";
 const ownerEq = (a, b) => (a ?? null) === (b ?? null);
@@ -62,15 +64,15 @@ export class LocalSessionStore {
             const path = this.titleSidecarPath;
             st.loaded = (async () => {
                 try {
-                    const parsed = JSON.parse(await readFile(path, "utf8"));
+                    const parsed = decodeJsonColumn(await readFile(path, "utf8"), readStringRecordColumn, "session-titles.json (the local title sidecar)");
                     for (const [id, t] of Object.entries(parsed)) {
-                        if (typeof t === "string" && !st.titles.has(id))
+                        if (!st.titles.has(id))
                             st.titles.set(id, t);
                     }
                 }
                 catch (e) {
                     if (e?.code !== "ENOENT")
-                        this.warnSidecar("read", e);
+                        this.refuseSidecar(path, "LocalSessionStore title sidecar", e);
                 }
             })();
         }
@@ -113,16 +115,15 @@ export class LocalSessionStore {
             const path = this.sidecarPath;
             this.loaded = (async () => {
                 try {
-                    const raw = await readFile(path, "utf8");
-                    const parsed = JSON.parse(raw);
+                    const parsed = decodeJsonColumn(await readFile(path, "utf8"), readStringRecordColumn, "session-last-activity.json (the local recency sidecar)");
                     for (const [id, ts] of Object.entries(parsed)) {
-                        if (typeof ts === "string" && !this.lastActivity.has(id))
+                        if (!this.lastActivity.has(id))
                             this.lastActivity.set(id, ts);
                     }
                 }
                 catch (e) {
                     if (e?.code !== "ENOENT")
-                        this.warnSidecar("read", e);
+                        this.refuseSidecar(path, "LocalSessionStore lastActivity sidecar", e);
                 }
             })();
         }
@@ -164,6 +165,10 @@ export class LocalSessionStore {
         if (this.dirty)
             await this.doFlush();
     }
+    refuseSidecar(path, what, e) {
+        quarantineUnreadableSidecar(path, what, e instanceof Error ? e.message : String(e));
+        this.warnSidecar("read", e);
+    }
     warnSidecar(op, e) {
         const now = Date.now();
         if (now - this.lastWarnAt < 60_000)

package/dist/plugins/local-sidecar-quarantine.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 把一份读不出形的档挪开并**大声说**。永不抛(它挂在降级臂上,不许把降级变成故障)。
+ *
+ * @param path    原档路径。
+ * @param what    给人读的一句话:这是什么档、读不出会怎样(进 warn 文案)。
+ * @param reason  判形失败的原因(属主的错误文案 / 异常消息)。
+ * @returns 隔离档的路径;挪不动时 `undefined`(此时 warn 里已说清)。
+ */
+export declare function quarantineUnreadableSidecar(path: string, what: string, reason: string): string | undefined;
+//# sourceMappingURL=local-sidecar-quarantine.d.ts.map

package/dist/plugins/local-sidecar-quarantine.js

@@ -0,0 +1,15 @@
+import { renameSync } from "node:fs";
+export function quarantineUnreadableSidecar(path, what, reason) {
+    const target = `${path}.corrupt-${Date.now()}-${process.pid}`;
+    try {
+        renameSync(path, target);
+    }
+    catch (e) {
+        console.warn(`${what}: ${path} is unreadable (${reason}) and could NOT be quarantined (${e instanceof Error ? e.message : String(e)}) — ` +
+            `the bytes are still at that path; a later write to it may replace them`);
+        return undefined;
+    }
+    console.warn(`${what}: ${path} is unreadable (${reason}) — quarantined at ${target} so the next write cannot replace it`);
+    return target;
+}
+//# sourceMappingURL=local-sidecar-quarantine.js.map

package/dist/plugins/local-task-attachment-store.d.ts

@@ -1,4 +1,4 @@
-import type { TaskAttachmentStore, TaskAttachmentRecord } from "./task-attachment-store.js";
+import { type TaskAttachmentStore, type TaskAttachmentRecord } from "./task-attachment-store.js";
 export declare class LocalTaskAttachmentStore implements TaskAttachmentStore {
     private readonly dir;
     private metas;

package/dist/plugins/local-task-attachment-store.js

@@ -1,6 +1,9 @@
 import { promises as fsp } from "node:fs";
 import { join } from "node:path";
+import { TaskAttachmentRecordSchema } from "./task-attachment-store.js";
+import { createZodColumnReader, decodeJsonColumn } from "./sql-json-column.js";
 const ID_RE = /^[0-9a-f-]{16,64}$/i;
+const readAttachmentMeta = createZodColumnReader(TaskAttachmentRecordSchema);
 export class LocalTaskAttachmentStore {
     dir;
     metas;
@@ -19,8 +22,8 @@ export class LocalTaskAttachmentStore {
                     if (!ID_RE.test(id))
                         continue;
                     try {
-                        const meta = JSON.parse(await fsp.readFile(join(this.dir, f), "utf8"));
-                        if (meta && meta.id === id)
+                        const meta = decodeJsonColumn(await fsp.readFile(join(this.dir, f), "utf8"), readAttachmentMeta, `attachments/${f} (task attachment meta)`);
+                        if (meta.id === id)
                             m.set(id, meta);
                     }
                     catch {

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

@@ -55,9 +55,12 @@ export declare const MAILBOX_MSG_TABLE = "mailbox_message";
  *  —— `mailbox` 行是**盒**事实(next_seq / lease),墓碑是**收件人**事实,两者的生命周期本来就不同
  *  (`drop` 同时终结两者 —— 墓碑随箱亡,理由全文见 `mailbox-recipient-lifecycle.ts` 模块头)。 */
 export declare const MAILBOX_TOMBSTONE_TABLE = "mailbox_tombstone";
-/** 店侧日志座(可选;boot 注入 `Logger`)。7.58.0 合并重扫 [medium]:坏 `peer_meta` 行的 fail-closed 抛必须**响亮**——core 唯一的
- *  claimLease 调用方(peer-session-drain)吞掉该错,店不记这一笔就成了「静默永久卡箱」。抛之前记 `mailbox_peer_meta_corrupt`
- *  (scope/handle/seq/code),运维按 seq 修行。 */
+/** 店侧日志座(可选;boot 注入 `Logger`)。7.58.0 合并重扫 [medium]:坏行的 fail-closed 抛必须**响亮**——core 唯一的
+ *  claimLease 调用方(peer-session-drain)吞掉该错,店不记这一笔就成了「静默永久卡箱」。抛之前记
+ *  `mailbox_message_column_corrupt`(scope/handle/seq/column/code),运维按 seq 修行。
+ *  🔴 S-550 车③a **改名并归一**:旧事件名 `mailbox_peer_meta_corrupt` 在 `hop_chain` 也变成 fail-closed 的
+ *  那一刻就说不出真话了(同一条读腿两列同判)。一个事件 + 一个 `column` 字段,而不是两个事件名 —— 运维
+ *  面按 column 分桶,店里只有一条留痕规则。 */
 export interface MailboxStoreLogger {
     warn(event: string, fields: Record<string, unknown>): void;
 }

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

@@ -2,6 +2,7 @@ import { MAILBOX_INVALID_PEER_META_CODE, MAILBOX_TOMBSTONED_RECIPIENT_CODE, Mail
 import { pgHasUnstorable, pgSanitizeText, PgUnstorableError } from "./pg-safe-json.js";
 import { ensureIndexes } from "./ensure-index.js";
 import { escapeLike } from "./sql-escape.js";
+import { decodeNullableJsonColumn, foldJsonColumn, jsonColumnText, readStringArrayColumn } from "./sql-json-column.js";
 export const MAILBOX_TABLE = "mailbox";
 export const MAILBOX_MSG_TABLE = "mailbox_message";
 export const MAILBOX_TOMBSTONE_TABLE = "mailbox_tombstone";
@@ -46,19 +47,13 @@ function encodeHopChain(hopChain) {
     }
     return text;
 }
-function decodeHopChain(raw) {
-    if (raw === null || raw === undefined)
-        return undefined;
-    let parsed;
+function decodeHopChain(raw, seq) {
     try {
-        parsed = JSON.parse(bufToStr(raw));
+        return decodeNullableJsonColumn(raw, readStringArrayColumn, `${MAILBOX_MSG_TABLE}.hop_chain for seq ${String(seq)}`);
     }
-    catch {
-        return undefined;
+    catch (e) {
+        throw foldJsonColumn(e, (m) => new Error(`MailboxStore: ${m} — refusing the lease rather than let a message skip peer admission (an absent chain makes core's judgePeerAdmission not run at all)`));
     }
-    if (!Array.isArray(parsed) || parsed.some((x) => typeof x !== "string"))
-        return undefined;
-    return parsed;
 }
 const PEER_META_MAX_BYTES = 60_000;
 function encodePeerMeta(raw) {
@@ -71,52 +66,59 @@ function encodePeerMeta(raw) {
     }
     return text;
 }
-function decodePeerMeta(raw) {
-    if (raw === null || raw === undefined)
-        return undefined;
-    const text = bufToStr(raw);
-    let parsed;
+function decodePeerMeta(raw, seq) {
     try {
-        parsed = JSON.parse(text);
+        return decodeNullableJsonColumn(raw, readPeerMetaColumn, `${MAILBOX_MSG_TABLE}.peer_meta for seq ${String(seq)}`);
     }
-    catch (err) {
-        throw new MailboxStoreError(MAILBOX_INVALID_PEER_META_CODE, `MailboxStore: stored peer_meta is not JSON (refusing the lease — a corrupt typed record must not be read as "no metadata"): ${err instanceof Error ? err.message : String(err)}`);
+    catch (e) {
+        if (e instanceof MailboxStoreError)
+            throw e;
+        throw foldJsonColumn(e, (m) => new MailboxStoreError(MAILBOX_INVALID_PEER_META_CODE, `MailboxStore: ${m} — refusing the lease rather than read a corrupt typed record as "no metadata"`));
     }
+}
+const readPeerMetaColumn = (body) => {
     try {
-        return readMailboxPeerMeta(parsed);
+        const meta = readMailboxPeerMeta(body);
+        return meta === undefined ? { problem: "the JSON literal `null` — absence is SQL NULL on this column, so a written `null` can only be a hand edit" } : { value: meta };
     }
     catch (err) {
         if (err instanceof MailboxStoreError)
             throw err;
-        throw new MailboxStoreError(MAILBOX_INVALID_PEER_META_CODE, `MailboxStore: stored peer_meta failed validation (refusing the lease): ${err instanceof Error ? err.message : String(err)}`);
+        return { problem: err instanceof Error ? err.message : String(err) };
     }
-}
+};
 function rowsToMessages(rows, scope, handle, logger) {
     const out = [];
     for (const r of rows) {
-        try {
-            out.push(rowToMessage(r));
-        }
-        catch (err) {
-            if (err instanceof MailboxStoreError)
-                logger?.warn("mailbox_peer_meta_corrupt", { scope, handle, seq: Number(r.seq), code: err.code, note: "claimLease refused for the whole box (fail-closed); repair or NULL the peer_meta column of this row" });
-            throw err;
-        }
+        const read = (column, decode) => {
+            try {
+                return decode();
+            }
+            catch (err) {
+                logger?.warn("mailbox_message_column_corrupt", {
+                    scope,
+                    handle,
+                    seq: Number(r.seq),
+                    column,
+                    ...(err instanceof MailboxStoreError ? { code: err.code } : {}),
+                    note: "claimLease refused for the whole box (fail-closed); repair or NULL that column of this row",
+                });
+                throw err;
+            }
+        };
+        const hopChain = read("hop_chain", () => decodeHopChain(r.hop_chain, r.seq));
+        const peerMeta = read("peer_meta", () => decodePeerMeta(r.peer_meta, r.seq));
+        out.push({
+            seq: Number(r.seq),
+            ...(r.from_id !== null && r.from_id !== undefined ? { from: bufToStr(r.from_id) } : {}),
+            content: String(r.content),
+            sentAt: Number(r.sent_at_ms),
+            ...(hopChain !== undefined ? { hopChain } : {}),
+            ...(peerMeta !== undefined ? { peerMeta } : {}),
+        });
     }
     return out;
 }
-function rowToMessage(r) {
-    const hopChain = decodeHopChain(r.hop_chain);
-    const peerMeta = decodePeerMeta(r.peer_meta);
-    return {
-        seq: Number(r.seq),
-        ...(r.from_id !== null && r.from_id !== undefined ? { from: bufToStr(r.from_id) } : {}),
-        content: String(r.content),
-        sentAt: Number(r.sent_at_ms),
-        ...(hopChain !== undefined ? { hopChain } : {}),
-        ...(peerMeta !== undefined ? { peerMeta } : {}),
-    };
-}
 export async function ensureTiDBMailboxSchema(pool) {
     await pool.query(`CREATE TABLE IF NOT EXISTS ${MAILBOX_TABLE} (
     scope_key VARBINARY(190) NOT NULL,
@@ -250,7 +252,7 @@ export class TiDBMailboxStore {
                 bufToStr(box.lease_owner) !== owner) {
                 return null;
             }
-            const [msgs] = (await c.query(`SELECT seq, from_id, content, sent_at_ms, hop_chain, peer_meta FROM ${MAILBOX_MSG_TABLE} WHERE scope_key = ? AND handle = ? ORDER BY seq FOR UPDATE`, [scope, handle]));
+            const [msgs] = (await c.query(`SELECT seq, from_id, content, sent_at_ms, ${jsonColumnText("tidb", "hop_chain")}, ${jsonColumnText("tidb", "peer_meta")} FROM ${MAILBOX_MSG_TABLE} WHERE scope_key = ? AND handle = ? ORDER BY seq FOR UPDATE`, [scope, handle]));
             if (msgs.length === 0)
                 return null;
             const maxSeq = Number(msgs[msgs.length - 1].seq);
@@ -397,7 +399,7 @@ export class PgMailboxStore {
             const box = boxes[0];
             if (box.lease_owner !== null && Number(box.lease_expires_at_ms) > now && String(box.lease_owner) !== owner)
                 return null;
-            const { rows: msgs } = await c.query(`SELECT seq, from_id, content, sent_at_ms, hop_chain, peer_meta FROM ${MAILBOX_MSG_TABLE} WHERE scope_key = $1 AND handle = $2 ORDER BY seq FOR UPDATE`, [scope, handle]);
+            const { rows: msgs } = await c.query(`SELECT seq, from_id, content, sent_at_ms, ${jsonColumnText("pg", "hop_chain")}, ${jsonColumnText("pg", "peer_meta")} FROM ${MAILBOX_MSG_TABLE} WHERE scope_key = $1 AND handle = $2 ORDER BY seq FOR UPDATE`, [scope, handle]);
             if (msgs.length === 0)
                 return null;
             const maxSeq = Number(msgs[msgs.length - 1].seq);

package/dist/plugins/memory-embedder-fingerprint.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { PG_MEMORY_ENGINE_TABLES } from "./memory-engine-pg.js";
+import { createZodColumnReader, decodeJsonColumn, jsonColumnText, SqlJsonColumnError } from "./sql-json-column.js";
 export const PG_MEMORY_ENGINE_META_TABLE = "agent_memory_engine_meta";
 export const EMBEDDER_IDENTITY_META_KEY = "embedder_identity";
 export const CAS_MAX_ROUNDS = 3;
@@ -13,28 +14,23 @@ export async function ensurePgMemoryEmbedderMetaSchema(query) {
     meta_value jsonb NOT NULL
   )`);
 }
+const readEmbedderIdentityColumn = createZodColumnReader(EmbedderIdentitySchema);
 function parseStoredText(text) {
-    let candidate;
     try {
-        candidate = JSON.parse(text);
+        return { kind: "ok", value: decodeJsonColumn(text, readEmbedderIdentityColumn, `${PG_MEMORY_ENGINE_META_TABLE}.meta_value for key ${EMBEDDER_IDENTITY_META_KEY}`) };
     }
     catch (err) {
-        return { kind: "unreadable", raw: `${text.slice(0, 160)} [JSON.parse: ${String(err).slice(0, 80)}]` };
+        if (!(err instanceof SqlJsonColumnError))
+            throw err;
+        return { kind: "unreadable", raw: `${text.slice(0, 160)} [${err.problem}: ${err.message.slice(0, 120)}]` };
     }
-    if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate)) {
-        return { kind: "unreadable", raw: `${text.slice(0, 160)} [not a JSON object]` };
-    }
-    const parsed = EmbedderIdentitySchema.safeParse(candidate);
-    if (!parsed.success)
-        return { kind: "unreadable", raw: text.slice(0, 200) };
-    return { kind: "ok", value: parsed.data };
 }
 async function readStored(query) {
-    const r = await query(`SELECT meta_value::text AS meta_value_text FROM ${PG_MEMORY_ENGINE_META_TABLE} WHERE meta_key = $1`, [EMBEDDER_IDENTITY_META_KEY]);
+    const r = await query(`SELECT ${jsonColumnText("pg", "meta_value")} FROM ${PG_MEMORY_ENGINE_META_TABLE} WHERE meta_key = $1`, [EMBEDDER_IDENTITY_META_KEY]);
     const row = r.rows[0];
     if (row === undefined)
         return { kind: "absent" };
-    const text = row.meta_value_text;
+    const text = row.meta_value;
     if (typeof text !== "string")
         return { kind: "unreadable", raw: `[meta_value::text did not return text: ${typeof text}]` };
     return parseStoredText(text);

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

@@ -1,5 +1,7 @@
 import { cosineDistance, jaccardDistance, termSet } from "@sema-agent/core";
-import { isUniqueViolation } from "./memory-engine-vector-util.js";
+import { isUniqueViolation, readEmbeddingColumn, readFrontmatterColumn } from "./memory-engine-vector-util.js";
+import { decodeJsonColumn, decodeNullableJsonColumn, foldJsonColumn, isJsonColumnBodyProblem, jsonColumnText } from "./sql-json-column.js";
+import { recordFailOpen } from "../observability/fail-open.js";
 import { computeEntryRev, serializeEntryFile } from "@sema-agent/core";
 import { pgSafeJsonStringify, pgHasUnstorable } from "./pg-safe-json.js";
 import { assertMemoryScopeWidth, memoryEntryKeyWidthRefusal } from "./memory-key-guards.js";
@@ -44,8 +46,24 @@ function vectorLiteral(v) {
 function inPlaceholders(first, count) {
     return Array.from({ length: count }, (_, i) => `$${first + i}`).join(", ");
 }
-function fromJson(v) {
-    return (typeof v === "string" ? JSON.parse(v) : v);
+function readFrontmatter(cell, id) {
+    try {
+        return decodeJsonColumn(cell, readFrontmatterColumn, `${PG_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`));
+    }
+}
+function readEmbedding(cell, id) {
+    try {
+        return decodeNullableJsonColumn(cell, readEmbeddingColumn, `${PG_MEMORY_ENGINE_TABLES.entry}.embedding for entry ${String(id)}`);
+    }
+    catch (e) {
+        if (!isJsonColumnBodyProblem(e))
+            throw e;
+        recordFailOpen("server.sql-json.memory-engine.embedding");
+        return undefined;
+    }
 }
 export class PgMemoryEngineBackend {
     query;
@@ -78,7 +96,7 @@ export class PgMemoryEngineBackend {
         return this.pgvectorSql ? vectorLiteral(v) : pgSafeJsonStringify(v);
     }
     headerFromRow(r) {
-        const fm = fromJson(r.frontmatter);
+        const fm = readFrontmatter(r.frontmatter, r.id);
         return {
             id: r.id,
             slug: r.slug,
@@ -98,7 +116,7 @@ export class PgMemoryEngineBackend {
             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,
         };
@@ -107,14 +125,14 @@ export class PgMemoryEngineBackend {
         const uniq = [...new Set(scopes)];
         if (uniq.length === 0)
             return [];
-        const res = await this.query(`SELECT id, scope, slug, frontmatter, rev, mtime_ms, size_bytes FROM ${PG_MEMORY_ENGINE_TABLES.entry} WHERE scope IN (${inPlaceholders(1, uniq.length)}) ORDER BY id`, uniq);
+        const res = await this.query(`SELECT id, scope, slug, ${jsonColumnText("pg", "frontmatter")}, rev, mtime_ms, size_bytes FROM ${PG_MEMORY_ENGINE_TABLES.entry} WHERE scope IN (${inPlaceholders(1, uniq.length)}) ORDER BY id`, uniq);
         return res.rows.map((r) => this.headerFromRow(r));
     }
     async getByIds(ids) {
         const uniq = [...new Set(ids)];
         if (uniq.length === 0)
             return [];
-        const res = await this.query(`SELECT id, scope, slug, frontmatter, body, rev, mtime_ms, size_bytes FROM ${PG_MEMORY_ENGINE_TABLES.entry} WHERE id IN (${inPlaceholders(1, uniq.length)}) ORDER BY id`, uniq);
+        const res = await this.query(`SELECT id, scope, slug, ${jsonColumnText("pg", "frontmatter")}, body, rev, mtime_ms, size_bytes FROM ${PG_MEMORY_ENGINE_TABLES.entry} WHERE id IN (${inPlaceholders(1, uniq.length)}) ORDER BY id`, uniq);
         return res.rows.map((r) => this.entryFromRow(r));
     }
     async search(query, scopes, opts) {
@@ -132,7 +150,7 @@ export class PgMemoryEngineBackend {
             if (Array.isArray(qv) && qv.length === this.embedder.dimensions) {
                 const vecParam = scopes.length + 1;
                 const bandExpr = bands ? `(CASE WHEN ${originMarkedSqlPredicate("frontmatter")} THEN 1 ELSE 0 END) ASC, ` : "";
-                const res = await this.query(`SELECT id, scope, slug, frontmatter, rev, mtime_ms, size_bytes, embedding <=> $${vecParam}::vector AS dist
+                const res = await this.query(`SELECT id, scope, slug, ${jsonColumnText("pg", "frontmatter")}, rev, mtime_ms, size_bytes, embedding <=> $${vecParam}::vector AS dist
              FROM ${PG_MEMORY_ENGINE_TABLES.entry}
             WHERE scope IN (${inPlaceholders(1, scopes.length)}) AND embedding IS NOT NULL
             ORDER BY ${bandExpr}embedding <=> $${vecParam}::vector ASC, id ASC
@@ -141,16 +159,16 @@ export class PgMemoryEngineBackend {
                 return hits.sort(contractOrder);
             }
         }
-        const res = await this.query(`SELECT id, scope, slug, frontmatter, body, rev, mtime_ms, size_bytes, embedding FROM ${PG_MEMORY_ENGINE_TABLES.entry} WHERE scope IN (${inPlaceholders(1, scopes.length)})`, [...scopes]);
+        const res = await this.query(`SELECT id, scope, slug, ${jsonColumnText("pg", "frontmatter")}, body, rev, mtime_ms, size_bytes, ${jsonColumnText("pg", "embedding")} FROM ${PG_MEMORY_ENGINE_TABLES.entry} WHERE scope IN (${inPlaceholders(1, scopes.length)})`, [...scopes]);
         const queryVec = this.embedder ? await this.embedder.embed(query).catch(() => null) : null;
         const dims = this.embedder?.dimensions;
         const scored = [];
         for (const raw of res.rows) {
             const r = raw;
-            const fm = fromJson(r.frontmatter);
+            const fm = readFrontmatter(r.frontmatter, r.id);
             if (queryVec && Array.isArray(queryVec) && queryVec.length === dims && r.embedding != null) {
-                const stored = fromJson(r.embedding);
-                if (Array.isArray(stored) && stored.length === dims) {
+                const stored = readEmbedding(r.embedding, r.id);
+                if (stored !== undefined && stored.length === dims) {
                     scored.push({ ...this.headerFromRow(r), score: cosineDistance(queryVec, stored) });
                     continue;
                 }
@@ -233,10 +251,10 @@ export class PgMemoryEngineBackend {
                 return;
             }
             const entry = rawEntry;
-            const prior = await this.query(`SELECT scope, slug, rev, frontmatter FROM ${T} WHERE id = $1`, [entry.id]);
+            const prior = await this.query(`SELECT scope, slug, rev, ${jsonColumnText("pg", "frontmatter")} FROM ${T} WHERE id = $1`, [entry.id]);
             const priorRow = prior.rows.length > 0 ? prior.rows[0] : 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 });
@@ -304,7 +322,7 @@ export class PgMemoryEngineBackend {
                 slug = `${entry.slug}-${n}`;
             }
         }
-        const cur = await this.query(`SELECT slug, rev, scope, frontmatter FROM ${PG_MEMORY_ENGINE_TABLES.entry} WHERE id = $1`, [patch.id]);
+        const cur = await this.query(`SELECT slug, rev, scope, ${jsonColumnText("pg", "frontmatter")} FROM ${PG_MEMORY_ENGINE_TABLES.entry} WHERE id = $1`, [patch.id]);
         if (cur.rows.length === 0) {
             report.conflicts.push({ op: patch.op, id: patch.id, reason: "unknown id (entry not found in backend)" });
             return;
@@ -312,7 +330,7 @@ export class PgMemoryEngineBackend {
         const currentRev = String(cur.rows[0].rev);
         const currentSlug = String(cur.rows[0].slug);
         const currentScope = String(cur.rows[0].scope);
-        const committedFm = fromJson(cur.rows[0].frontmatter);
+        const committedFm = readFrontmatter(cur.rows[0].frontmatter, patch.id);
         const committedBaseFm = rememberBatchCommitted(originBaseline, patch.id, committedFm);
         if (patch.op === "update" && patch.entry !== undefined) {
             if (committedFm.provenance?.kind === "repo_file") {