@sema-agent/server 7.7.1 → 7.8.1

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

@@ -26,8 +26,8 @@ import { pgSafeJsonStringify, pgHasUnstorable } from "./pg-safe-json.js";
 /** Table names (single source). Deliberately DISJOINT from the legacy `agent_memory*` tables —
  *  the retired MemoryStore plane and this entry plane must never cross-write. */
 export const PG_MEMORY_ENGINE_TABLES = {
-    entries: "agent_memory_engine_entries",
-    cursors: "agent_memory_engine_cursors",
+    entry: "agent_memory_engine_entry",
+    cursor: "agent_memory_engine_cursor",
 };
 /** Idempotent DDL for the entry plane. Call once at startup (or run through your migration tool). */
 export async function ensurePgMemoryEngineSchema(query, opts = {}) {
@@ -41,7 +41,7 @@ export async function ensurePgMemoryEngineSchema(query, opts = {}) {
     if (vec?.pgvector)
         await query("CREATE EXTENSION IF NOT EXISTS vector");
     const embeddingCol = vec?.pgvector ? `vector(${vec.dimensions})` : "jsonb";
-    await query(`CREATE TABLE IF NOT EXISTS ${PG_MEMORY_ENGINE_TABLES.entries} (
+    await query(`CREATE TABLE IF NOT EXISTS ${PG_MEMORY_ENGINE_TABLES.entry} (
     id text COLLATE "C" PRIMARY KEY,
     scope text COLLATE "C" NOT NULL,
     slug text COLLATE "C" NOT NULL,
@@ -53,7 +53,7 @@ export async function ensurePgMemoryEngineSchema(query, opts = {}) {
     embedding ${embeddingCol}
   )`);
     try {
-        await query(`CREATE INDEX IF NOT EXISTS idx_${PG_MEMORY_ENGINE_TABLES.entries}_scope ON ${PG_MEMORY_ENGINE_TABLES.entries} (scope)`);
+        await query(`CREATE INDEX IF NOT EXISTS idx_${PG_MEMORY_ENGINE_TABLES.entry}_scope ON ${PG_MEMORY_ENGINE_TABLES.entry} (scope)`);
     }
     catch {
         /* pg-mem: partial CREATE INDEX support — the index is a perf add-on, never correctness */
@@ -63,8 +63,8 @@ export async function ensurePgMemoryEngineSchema(query, opts = {}) {
     // insert, leaving two entries whose file projections overwrite each other at materialize. The DB
     // constraint is the only true arbiter; the add path catches the violation and retries the next
     // suffix. NOT wrapped in try/catch — if this constraint cannot be created, the backend is unsafe.
-    await query(`CREATE UNIQUE INDEX IF NOT EXISTS uq_${PG_MEMORY_ENGINE_TABLES.entries}_scope_slug ON ${PG_MEMORY_ENGINE_TABLES.entries} (scope, slug)`);
-    await query(`CREATE TABLE IF NOT EXISTS ${PG_MEMORY_ENGINE_TABLES.cursors} (
+    await query(`CREATE UNIQUE INDEX IF NOT EXISTS uq_${PG_MEMORY_ENGINE_TABLES.entry}_scope_slug ON ${PG_MEMORY_ENGINE_TABLES.entry} (scope, slug)`);
+    await query(`CREATE TABLE IF NOT EXISTS ${PG_MEMORY_ENGINE_TABLES.cursor} (
     scope text COLLATE "C" PRIMARY KEY,
     cursor text COLLATE "C" NOT NULL
   )`);
@@ -149,14 +149,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.entries} WHERE scope IN (${inPlaceholders(1, uniq.length)}) ORDER BY id`, uniq);
+        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);
         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.entries} WHERE id IN (${inPlaceholders(1, uniq.length)}) ORDER BY id`, uniq);
+        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);
         return res.rows.map((r) => this.entryFromRow(r)); // unknown ids: silently absent
     }
     async search(query, scopes, opts) {
@@ -180,7 +180,7 @@ export class PgMemoryEngineBackend {
             if (Array.isArray(qv) && qv.length === this.embedder.dimensions) {
                 const vecParam = scopes.length + 1;
                 const res = await this.query(`SELECT id, scope, slug, frontmatter, rev, mtime_ms, size_bytes, embedding <=> $${vecParam}::vector AS dist
-             FROM ${PG_MEMORY_ENGINE_TABLES.entries}
+             FROM ${PG_MEMORY_ENGINE_TABLES.entry}
             WHERE scope IN (${inPlaceholders(1, scopes.length)}) AND embedding IS NOT NULL
             ORDER BY embedding <=> $${vecParam}::vector ASC
             LIMIT ${Math.min(limit, 100_000)}`, [...scopes, vectorLiteral(qv)]);
@@ -188,7 +188,7 @@ export class PgMemoryEngineBackend {
             }
             // Wrong-dimension query vector (transient embedder fault) — fall open to the in-process path.
         }
-        const res = await this.query(`SELECT id, scope, slug, frontmatter, body, rev, mtime_ms, size_bytes, embedding FROM ${PG_MEMORY_ENGINE_TABLES.entries} WHERE scope IN (${inPlaceholders(1, scopes.length)})`, [...scopes]);
+        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 queryVec = this.embedder ? await this.embedder.embed(query).catch(() => null) : null;
         const dims = this.embedder?.dimensions;
         const scored = [];
@@ -256,7 +256,7 @@ export class PgMemoryEngineBackend {
         return report;
     }
     async applyOne(patch, report, plannedSlugs, historyRows) {
-        const T = PG_MEMORY_ENGINE_TABLES.entries;
+        const T = PG_MEMORY_ENGINE_TABLES.entry;
         // A patch whose entry carries a DIFFERENT id than the patch addresses is
         // malformed — the two backends would otherwise diverge (File writes the entry's id, Pg would
         // key the SELECT on patch.id but the write on entry.id). Refused up front, both backends alike.
@@ -354,7 +354,7 @@ export class PgMemoryEngineBackend {
         }
         // update/delete address an EXISTING entry by immutable id. (scope in the projection = the
         // history row's scope for delete — a tombstone can't be joined back to the deleted row.)
-        const cur = await this.query(`SELECT slug, rev, scope, frontmatter FROM ${PG_MEMORY_ENGINE_TABLES.entries} WHERE id = $1`, [patch.id]);
+        const cur = await this.query(`SELECT slug, rev, scope, 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;
@@ -395,7 +395,7 @@ export class PgMemoryEngineBackend {
         if (patch.op === "delete") {
             // Conditional on the rev we just judged — a write that lands between the SELECT and this DELETE
             // re-reports as the same CAS conflict instead of silently deleting the newer committed state.
-            const res = await this.query(`DELETE FROM ${PG_MEMORY_ENGINE_TABLES.entries} WHERE id = $1 AND rev = $2 RETURNING id`, [patch.id, currentRev]);
+            const res = await this.query(`DELETE FROM ${PG_MEMORY_ENGINE_TABLES.entry} WHERE id = $1 AND rev = $2 RETURNING id`, [patch.id, currentRev]);
             if (res.rows.length === 0) {
                 report.conflicts.push({ op: "delete", id: patch.id, reason: "rev mismatch (concurrent change)", baseRev: patch.baseRev, currentRev: await this.freshRev(patch.id, currentRev) });
                 return;
@@ -421,7 +421,7 @@ export class PgMemoryEngineBackend {
         const cEntry = entry; // R3 终形:拒绝式后恒干净,rev 对拍原文
         const rev = computeEntryRev(cEntry);
         const embedding = await this.embeddingParam(this.haystackOf(cEntry.slug, cEntry.frontmatter, cEntry.body));
-        const res = await this.query(`UPDATE ${PG_MEMORY_ENGINE_TABLES.entries}
+        const res = await this.query(`UPDATE ${PG_MEMORY_ENGINE_TABLES.entry}
           SET scope = $2, slug = $3, frontmatter = $4, body = $5, rev = $6, mtime_ms = $7, size_bytes = $8, embedding = $9
         WHERE id = $1 AND rev = $10
         RETURNING id`, [cEntry.id, cEntry.scope, cEntry.slug, pgSafeJsonStringify(cEntry.frontmatter), cEntry.body, rev, this.clock(), Buffer.byteLength(serializeEntryFile(cEntry), "utf8"), embedding, currentRev]);
@@ -438,15 +438,15 @@ export class PgMemoryEngineBackend {
      *  SELECT→write window), the report's `currentRev` must be the rev NOW — re-reporting the pre-race
      *  SELECT value could claim `baseRev === currentRev` alongside a "rev mismatch" reason. */
     async freshRev(id, fallback) {
-        const res = await this.query(`SELECT rev FROM ${PG_MEMORY_ENGINE_TABLES.entries} WHERE id = $1`, [id]);
+        const res = await this.query(`SELECT rev FROM ${PG_MEMORY_ENGINE_TABLES.entry} WHERE id = $1`, [id]);
         return res.rows.length > 0 ? String(res.rows[0].rev) : fallback;
     }
     async getConsolidationCursor(scope) {
-        const res = await this.query(`SELECT cursor FROM ${PG_MEMORY_ENGINE_TABLES.cursors} WHERE scope = $1`, [scope]);
+        const res = await this.query(`SELECT cursor FROM ${PG_MEMORY_ENGINE_TABLES.cursor} WHERE scope = $1`, [scope]);
         return res.rows.length > 0 ? String(res.rows[0].cursor) : undefined;
     }
     async setConsolidationCursor(scope, cursor) {
-        await this.query(`INSERT INTO ${PG_MEMORY_ENGINE_TABLES.cursors} (scope, cursor) VALUES ($1, $2)
+        await this.query(`INSERT INTO ${PG_MEMORY_ENGINE_TABLES.cursor} (scope, cursor) VALUES ($1, $2)
        ON CONFLICT (scope) DO UPDATE SET cursor = $2`, [scope, cursor]);
     }
 }

package/dist/plugins/memory-engine-tidb.d.ts

@@ -5,8 +5,8 @@ import type { Pool } from "mysql2/promise";
 /** Table names (single source) — SAME names as PG_MEMORY_ENGINE_TABLES (the two dialects never share
  *  one database), deliberately DISJOINT from the legacy `agent_memory*` MemoryStore plane. */
 export declare const TIDB_MEMORY_ENGINE_TABLES: {
-    readonly entries: "agent_memory_engine_entries";
-    readonly cursors: "agent_memory_engine_cursors";
+    readonly entry: "agent_memory_engine_entry";
+    readonly cursor: "agent_memory_engine_cursor";
 };
 /** Idempotent DDL for the entry plane (TiDB dialect). Call once at startup.
  *  Key lengths: utf8mb4 = 4 bytes/char and the default index-key cap is 3072 bytes, so the

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

@@ -12,7 +12,7 @@
 //   - add 路径 Pg 用 `INSERT … ON CONFLICT (id) DO UPDATE`(冲突靶=仅 PK)。MySQL 的 ON DUPLICATE KEY
 //     UPDATE 会被 **任意** 唯一键触发——(scope,slug) 撞键时它会把竞争对手的行改写成本 entry 的 id(数据毁),
 //     不能用;拆成「不存在→INSERT / 已存在→UPDATE by id」,两条腿的 ER_DUP_ENTRY 都按键名分诊(PRIMARY=
-//     并发同 id add → 转 UPDATE 腿;uq_agent_memory_engine_entries_scope_slug=并发 slug 竞争 → 下一个 -n 后缀重试);
+//     并发同 id add → 转 UPDATE 腿;uq_agent_memory_engine_entry_scope_slug=并发 slug 竞争 → 下一个 -n 后缀重试);
 //   - unique violation 判定:ER_DUP_ENTRY(errno 1062),不是 Pg 的 23505;
 //   - pg-mem 伪影 workaround(索引列 ANY 零行/重复占位符重复行)不抄——MySQL 本就走 IN-list,dedupe 保留
 //     是因为它同时是诚实语义(重复 key 问的是同一个 entry,契约锁死 once-per-entry);
@@ -27,14 +27,14 @@ import { pgHasUnstorable } from "./pg-safe-json.js";
 /** Table names (single source) — SAME names as PG_MEMORY_ENGINE_TABLES (the two dialects never share
  *  one database), deliberately DISJOINT from the legacy `agent_memory*` MemoryStore plane. */
 export const TIDB_MEMORY_ENGINE_TABLES = {
-    entries: "agent_memory_engine_entries",
-    cursors: "agent_memory_engine_cursors",
+    entry: "agent_memory_engine_entry",
+    cursor: "agent_memory_engine_cursor",
 };
 /** Idempotent DDL for the entry plane (TiDB dialect). Call once at startup.
  *  Key lengths: utf8mb4 = 4 bytes/char and the default index-key cap is 3072 bytes, so the
  *  (scope, slug) unique key budget is scope 190 + slug 512 = 702 chars ⇒ 2808 bytes ≤ 3072. */
 export async function ensureTiDBMemoryEngineSchema(pool) {
-    await pool.query(`CREATE TABLE IF NOT EXISTS ${TIDB_MEMORY_ENGINE_TABLES.entries} (
+    await pool.query(`CREATE TABLE IF NOT EXISTS ${TIDB_MEMORY_ENGINE_TABLES.entry} (
     id          VARCHAR(64)  NOT NULL,
     scope       VARCHAR(190) NOT NULL,
     slug        VARCHAR(512) NOT NULL,
@@ -45,13 +45,13 @@ export async function ensureTiDBMemoryEngineSchema(pool) {
     size_bytes  INT          NOT NULL,
     embedding   JSON         NULL,
     PRIMARY KEY (id),
-    KEY idx_agent_memory_engine_entries_scope (scope),
-    UNIQUE KEY uq_agent_memory_engine_entries_scope_slug (scope, slug)
+    KEY idx_agent_memory_engine_entry_scope (scope),
+    UNIQUE KEY uq_agent_memory_engine_entry_scope_slug (scope, slug)
   ) COLLATE utf8mb4_bin`);
     // The (scope, slug) UNIQUE key above is CORRECTNESS, not perf (Pg 版同注):two
     // instances racing an add of one scope+slug (different ids) can both probe "free" and both insert;
     // the DB constraint is the only true arbiter and the add path retries the next suffix on violation.
-    await pool.query(`CREATE TABLE IF NOT EXISTS ${TIDB_MEMORY_ENGINE_TABLES.cursors} (
+    await pool.query(`CREATE TABLE IF NOT EXISTS ${TIDB_MEMORY_ENGINE_TABLES.cursor} (
     scope  VARCHAR(190) NOT NULL,
     \`cursor\` TEXT     NOT NULL,
     PRIMARY KEY (scope)
@@ -62,7 +62,7 @@ function isDupEntry(err) {
         return false;
     return err.code === "ER_DUP_ENTRY" || err.errno === 1062;
 }
-/** ER_DUP_ENTRY messages name the violated key (`… for key 'tbl.PRIMARY'` / `… for key 'tbl.uq_agent_memory_engine_entries_scope_slug'`)
+/** ER_DUP_ENTRY messages name the violated key (`… for key 'tbl.PRIMARY'` / `… for key 'tbl.uq_agent_memory_engine_entry_scope_slug'`)
  *  — the add path uses this to tell "id already exists (→ overwrite leg)" from "slug race (→ -n retry)". */
 function isPrimaryKeyDup(err) {
     return isDupEntry(err) && /for key '[^']*PRIMARY'/i.test(String(err.message ?? ""));
@@ -134,14 +134,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.entries} WHERE scope IN (${inPlaceholders(uniq.length)}) ORDER BY id`, uniq);
+        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);
         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.entries} WHERE id IN (${inPlaceholders(uniq.length)}) ORDER BY id`, uniq);
+        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);
         return rows.map((r) => this.entryFromRow(r)); // unknown ids: silently absent
     }
     async search(query, scopes, opts) {
@@ -155,7 +155,7 @@ 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.entries} WHERE scope IN (${inPlaceholders(uniq.length)})`, uniq);
+        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 scored = [];
         for (const raw of rows) {
             const r = raw;
@@ -212,7 +212,7 @@ export class TiDBMemoryEngineBackend {
         return report;
     }
     async applyOne(patch, report, plannedSlugs, historyRows) {
-        const T = TIDB_MEMORY_ENGINE_TABLES.entries;
+        const T = TIDB_MEMORY_ENGINE_TABLES.entry;
         // A patch whose entry carries a DIFFERENT id than the patch addresses is malformed — refused up
         // front, all backends alike (Pg 版同注).
         if (patch.op !== "delete" && patch.entry !== undefined && patch.entry.id !== patch.id) {
@@ -263,7 +263,7 @@ export class TiDBMemoryEngineBackend {
                 }
             }
             // Slug collision with a DIFFERENT entry → deterministic `-n` suffix (file-backend parity); the
-            // probe is only an optimization — the write INSIDE the loop is arbitrated by uq_agent_memory_engine_entries_scope_slug, and
+            // probe is only an optimization — the write INSIDE the loop is arbitrated by uq_agent_memory_engine_entry_scope_slug, and
             // a concurrent loser retries the next suffix (Pg 版同注).
             let slug = entry.slug;
             for (let n = 2;; n++) {
@@ -419,7 +419,7 @@ export class TiDBMemoryEngineBackend {
     /** The row's rev NOW, or undefined if the row is gone. The existence distinction is the whole point
      *  (codex lens-3): a concurrent delete must not be mistaken for an idempotent already-at-target write. */
     async freshRevOrMissing(id) {
-        const rows = await this.selectRows(`SELECT rev FROM ${TIDB_MEMORY_ENGINE_TABLES.entries} WHERE id = ?`, [id]);
+        const rows = await this.selectRows(`SELECT rev FROM ${TIDB_MEMORY_ENGINE_TABLES.entry} WHERE id = ?`, [id]);
         return rows.length > 0 ? String(rows[0].rev) : undefined;
     }
     /** When the conditional write reports zero rows (a write landed inside the SELECT→write window), the
@@ -429,13 +429,13 @@ export class TiDBMemoryEngineBackend {
         return (await this.freshRevOrMissing(id)) ?? fallback;
     }
     async getConsolidationCursor(scope) {
-        const rows = await this.selectRows(`SELECT \`cursor\` FROM ${TIDB_MEMORY_ENGINE_TABLES.cursors} WHERE scope = ?`, [scope]);
+        const rows = await this.selectRows(`SELECT \`cursor\` FROM ${TIDB_MEMORY_ENGINE_TABLES.cursor} WHERE scope = ?`, [scope]);
         return rows.length > 0 ? String(rows[0].cursor) : undefined;
     }
     async setConsolidationCursor(scope, cursor) {
         // Single unique key (the PK) on this table — ON DUPLICATE KEY UPDATE is unambiguous here,
         // unlike the two-unique-key entries table (see the file-head dialect note).
-        await this.write(`INSERT INTO ${TIDB_MEMORY_ENGINE_TABLES.cursors} (scope, \`cursor\`) VALUES (?, ?) ON DUPLICATE KEY UPDATE \`cursor\` = VALUES(\`cursor\`)`, [scope, cursor]);
+        await this.write(`INSERT INTO ${TIDB_MEMORY_ENGINE_TABLES.cursor} (scope, \`cursor\`) VALUES (?, ?) ON DUPLICATE KEY UPDATE \`cursor\` = VALUES(\`cursor\`)`, [scope, cursor]);
     }
 }
 //# sourceMappingURL=memory-engine-tidb.js.map

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

@@ -2,7 +2,7 @@ import type { MemorySyncCursor } from "@sema-agent/core";
 import type { PgQueryFn } from "./pg-query.js";
 /** Table names (single source). SAME names as the TiDB twin (the two dialects never share one DB). */
 export declare const PG_MEMORY_SYNC_TABLES: {
-    readonly syncCursors: "agent_memory_engine_sync_cursors";
+    readonly syncCursor: "agent_memory_engine_sync_cursor";
     readonly pushQueue: "agent_memory_engine_push_queue";
     readonly history: "agent_memory_engine_history";
 };
@@ -37,7 +37,7 @@ export interface MemorySyncStore {
     /** Whole-row replace (round semantics — baseRevs is swapped as one map, never merged). */
     putCursor(cursor: MemorySyncCursor): Promise<void>;
     enqueue(item: PushQueueItem): Promise<void>;
-    /** Lease-claim up to `limit` due rows (next_attempt_at <= nowMs), oldest-due first. Claimed rows
+    /** Lease-claim up to `limit` due rows (next_attempt_at_ms <= nowMs), oldest-due first. Claimed rows
      *  are invisible to other claimers until `complete`/`fail` or lease expiry (crash self-heal). */
     claimDue(nowMs: number, limit: number): Promise<ClaimedPushQueueItem[]>;
     /** Success = delete the row (outbox posture: the queue only holds outstanding work). */

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

@@ -1,13 +1,13 @@
 import { pgSafeJsonStringify, pgProtocolJsonStringify } from "./pg-safe-json.js";
 /** Table names (single source). SAME names as the TiDB twin (the two dialects never share one DB). */
 export const PG_MEMORY_SYNC_TABLES = {
-    syncCursors: "agent_memory_engine_sync_cursors",
+    syncCursor: "agent_memory_engine_sync_cursor",
     pushQueue: "agent_memory_engine_push_queue",
     history: "agent_memory_engine_history",
 };
 /** Idempotent DDL for the sync plane (PG dialect). Call once at startup. */
 export async function ensurePgMemorySyncSchema(query) {
-    await query(`CREATE TABLE IF NOT EXISTS ${PG_MEMORY_SYNC_TABLES.syncCursors} (
+    await query(`CREATE TABLE IF NOT EXISTS ${PG_MEMORY_SYNC_TABLES.syncCursor} (
     scope         varchar(190) COLLATE "C" NOT NULL,
     peer          varchar(190) COLLATE "C" NOT NULL,
     base_revs     jsonb        NOT NULL,
@@ -15,16 +15,16 @@ export async function ensurePgMemorySyncSchema(query) {
     PRIMARY KEY (scope, peer)
   )`);
     await query(`CREATE TABLE IF NOT EXISTS ${PG_MEMORY_SYNC_TABLES.pushQueue} (
-    id              char(36) COLLATE "C"     PRIMARY KEY,
-    scope           varchar(190) COLLATE "C" NOT NULL,
-    entry_id        char(36) COLLATE "C"     NOT NULL,
-    payload         jsonb        NOT NULL,
-    attempts        integer      NOT NULL DEFAULT 0,
-    next_attempt_at bigint       NOT NULL,
-    last_error      text COLLATE "C"         NULL
+    id                 char(36) COLLATE "C"     PRIMARY KEY,
+    scope              varchar(190) COLLATE "C" NOT NULL,
+    entry_id           char(36) COLLATE "C"     NOT NULL,
+    payload            jsonb        NOT NULL,
+    attempts           integer      NOT NULL DEFAULT 0,
+    next_attempt_at_ms bigint       NOT NULL,
+    last_error         text COLLATE "C"         NULL
   )`);
     // Scan face (§1.2): the reaper/consumer sweeps by due time. Perf add-on, never correctness.
-    await query(`CREATE INDEX IF NOT EXISTS idx_${PG_MEMORY_SYNC_TABLES.pushQueue}_next_attempt ON ${PG_MEMORY_SYNC_TABLES.pushQueue} (next_attempt_at)`);
+    await query(`CREATE INDEX IF NOT EXISTS idx_${PG_MEMORY_SYNC_TABLES.pushQueue}_next_attempt_ms ON ${PG_MEMORY_SYNC_TABLES.pushQueue} (next_attempt_at_ms)`);
 }
 /** jsonb defense: node-pg hands back parsed objects, but a text-typed round-trip (or a foreign
  *  writer) may yield a string — same posture as parseJson in run-store-sql.ts. */
@@ -51,7 +51,7 @@ export class PgMemorySyncStore {
     }
     // ── cursors ────────────────────────────────────────────────────────────────
     async getCursor(scope, peer) {
-        const res = await this.query(`SELECT base_revs, updated_at_ms FROM ${PG_MEMORY_SYNC_TABLES.syncCursors} WHERE scope = $1 AND peer = $2`, [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 row = res.rows[0];
         if (!row)
             return undefined;
@@ -65,7 +65,7 @@ export class PgMemorySyncStore {
     async putCursor(cursor) {
         // PK (scope,peer) is the table's ONLY unique key ⇒ ON CONFLICT has exactly one target, no
         // hijack face (纪律:the entries-table ban on blind upserts does NOT apply here).
-        await this.query(`INSERT INTO ${PG_MEMORY_SYNC_TABLES.syncCursors} (scope, peer, base_revs, updated_at_ms)
+        await this.query(`INSERT INTO ${PG_MEMORY_SYNC_TABLES.syncCursor} (scope, peer, base_revs, updated_at_ms)
        VALUES ($1, $2, $3::jsonb, $4)
        ON CONFLICT (scope, peer) DO UPDATE SET base_revs = EXCLUDED.base_revs, updated_at_ms = EXCLUDED.updated_at_ms`, 
         // codex R11:baseRevs=对账基线(entry id→rev,协议数据)——有损改写=peer 收到的与库里存的
@@ -76,7 +76,7 @@ export class PgMemorySyncStore {
     async enqueue(item) {
         // Plain INSERT, fail-loud on a duplicate id: the caller mints uuidv7 per enqueue, so a dup is a
         // caller bug (or a replay the caller must decide about) — never silently absorbed here.
-        await this.query(`INSERT INTO ${PG_MEMORY_SYNC_TABLES.pushQueue} (id, scope, entry_id, payload, attempts, next_attempt_at, last_error)
+        await this.query(`INSERT INTO ${PG_MEMORY_SYNC_TABLES.pushQueue} (id, scope, entry_id, payload, attempts, next_attempt_at_ms, last_error)
        VALUES ($1, $2, $3, $4::jsonb, 0, $5, NULL)`, 
         // codex R10:payload=协议数据(文档明言 verbatim;rev=内容哈希)——jsonb 列存不了脏值,但有损
         // 改写=payload 与 rev 内部矛盾(消费端永拒/应用脏内容)。协议纪律:拒绝式(与 memory add/update
@@ -88,9 +88,9 @@ export class PgMemorySyncStore {
             return [];
         const leasedUntilMs = nowMs + this.claimLeaseMs;
         // ONE statement = one implicit transaction: SKIP LOCKED excludes claimers overlapping in time,
-        // the next_attempt_at bump (lease) excludes everyone arriving after we commit. RETURNING gives
+        // the next_attempt_at_ms bump (lease) excludes everyone arriving after we commit. RETURNING gives
         // the post-update row, so attempts/last_error are the pre-claim values (fail() is the only
-        // incrementer) and next_attempt_at is the lease we just wrote.
+        // incrementer) and next_attempt_at_ms is the lease we just wrote.
         // ⚠️ MATERIALIZED CTE, NOT `WHERE id IN (SELECT … LIMIT n FOR UPDATE SKIP LOCKED)`: the IN-subquery
         // form lets the planner RESCAN the locking subquery (e.g. as a rescanned semi-join inner), and each
         // rescan skips the rows the previous pass locked and picks the NEXT due ones — an over-claim beyond
@@ -99,12 +99,12 @@ export class PgMemorySyncStore {
         // (PG12+) pins one evaluation; UPDATE … FROM joins the pinned id set.
         const res = await this.query(`WITH due AS MATERIALIZED (
          SELECT id FROM ${PG_MEMORY_SYNC_TABLES.pushQueue}
-         WHERE next_attempt_at <= $1
-         ORDER BY next_attempt_at, id
+         WHERE next_attempt_at_ms <= $1
+         ORDER BY next_attempt_at_ms, id
          LIMIT $2
          FOR UPDATE SKIP LOCKED
        )
-       UPDATE ${PG_MEMORY_SYNC_TABLES.pushQueue} q SET next_attempt_at = $3
+       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]);
         return res.rows.map((r) => ({
@@ -124,7 +124,7 @@ export class PgMemorySyncStore {
         // attempts = attempts + 1 is SQL-atomic — a read-modify-write in JS would race a concurrent
         // failer and lose increments (the attempt cap is the fail-loud stop, it must count honestly).
         await this.query(`UPDATE ${PG_MEMORY_SYNC_TABLES.pushQueue}
-       SET attempts = attempts + 1, last_error = $2, next_attempt_at = $3
+       SET attempts = attempts + 1, last_error = $2, next_attempt_at_ms = $3
        WHERE id = $1`, [id, error, nextAttemptAtMs]);
     }
 }

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

@@ -4,7 +4,7 @@ import type { Pool } from "mysql2/promise";
 /** Table names (single source) — SAME names as PG_MEMORY_SYNC_TABLES (the two dialects never share
  *  one database). */
 export declare const TIDB_MEMORY_SYNC_TABLES: {
-    readonly syncCursors: "agent_memory_engine_sync_cursors";
+    readonly syncCursor: "agent_memory_engine_sync_cursor";
     readonly pushQueue: "agent_memory_engine_push_queue";
     readonly history: "agent_memory_engine_history";
 };

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

@@ -2,14 +2,14 @@ import { historyRowFrom } from "./memory-sync-store-pg.js";
 /** Table names (single source) — SAME names as PG_MEMORY_SYNC_TABLES (the two dialects never share
  *  one database). */
 export const TIDB_MEMORY_SYNC_TABLES = {
-    syncCursors: "agent_memory_engine_sync_cursors",
+    syncCursor: "agent_memory_engine_sync_cursor",
     pushQueue: "agent_memory_engine_push_queue",
     history: "agent_memory_engine_history",
 };
 /** Idempotent DDL for the sync plane (TiDB dialect). Call once at startup.
  *  Key budget: utf8mb4 = 4 bytes/char, index cap 3072 bytes ⇒ PK(scope,peer) = 380 chars = 1520 B ✓. */
 export async function ensureTiDBMemorySyncSchema(pool) {
-    await pool.query(`CREATE TABLE IF NOT EXISTS ${TIDB_MEMORY_SYNC_TABLES.syncCursors} (
+    await pool.query(`CREATE TABLE IF NOT EXISTS ${TIDB_MEMORY_SYNC_TABLES.syncCursor} (
     scope         VARCHAR(190) NOT NULL,
     peer          VARCHAR(190) NOT NULL,
     base_revs     JSON         NOT NULL,
@@ -17,15 +17,15 @@ export async function ensureTiDBMemorySyncSchema(pool) {
     PRIMARY KEY (scope, peer)
   ) COLLATE utf8mb4_bin`);
     await pool.query(`CREATE TABLE IF NOT EXISTS ${TIDB_MEMORY_SYNC_TABLES.pushQueue} (
-    id              CHAR(36)     NOT NULL,
-    scope           VARCHAR(190) NOT NULL,
-    entry_id        CHAR(36)     NOT NULL,
-    payload         JSON         NOT NULL,
-    attempts        INT          NOT NULL DEFAULT 0,
-    next_attempt_at BIGINT       NOT NULL,
-    last_error      TEXT         NULL,
+    id                 CHAR(36)     NOT NULL,
+    scope              VARCHAR(190) NOT NULL,
+    entry_id           CHAR(36)     NOT NULL,
+    payload            JSON         NOT NULL,
+    attempts           INT          NOT NULL DEFAULT 0,
+    next_attempt_at_ms BIGINT       NOT NULL,
+    last_error         TEXT         NULL,
     PRIMARY KEY (id),
-    KEY idx_agent_memory_engine_push_queue_next_attempt (next_attempt_at)
+    KEY idx_agent_memory_engine_push_queue_next_attempt_ms (next_attempt_at_ms)
   ) COLLATE utf8mb4_bin`);
 }
 /** JSON-column defense: mysql2 normally hands back parsed objects for JSON columns, but string
@@ -52,7 +52,7 @@ export class TiDBMemorySyncStore {
     }
     // ── cursors ────────────────────────────────────────────────────────────────
     async getCursor(scope, peer) {
-        const [rows] = await this.pool.query(`SELECT base_revs, updated_at_ms FROM ${TIDB_MEMORY_SYNC_TABLES.syncCursors} WHERE scope = ? AND peer = ?`, [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 row = rows[0];
         if (!row)
             return undefined;
@@ -66,7 +66,7 @@ export class TiDBMemorySyncStore {
     async putCursor(cursor) {
         // The table's ONLY unique key is PK(scope,peer) ⇒ ON DUPLICATE KEY UPDATE has exactly one
         // possible trigger — no hijack face (the entries-table ban does NOT apply; see header).
-        await this.pool.query(`INSERT INTO ${TIDB_MEMORY_SYNC_TABLES.syncCursors} (scope, peer, base_revs, updated_at_ms)
+        await this.pool.query(`INSERT INTO ${TIDB_MEMORY_SYNC_TABLES.syncCursor} (scope, peer, base_revs, updated_at_ms)
        VALUES (?, ?, ?, ?)
        ON DUPLICATE KEY UPDATE base_revs = VALUES(base_revs), updated_at_ms = VALUES(updated_at_ms)`, [cursor.scope, cursor.peer, JSON.stringify(cursor.baseRevs), cursor.updatedAtMs]);
     }
@@ -74,7 +74,7 @@ export class TiDBMemorySyncStore {
     async enqueue(item) {
         // Plain INSERT, fail-loud on a duplicate id (ER_DUP_ENTRY 1062) — caller mints uuidv7 per
         // enqueue, a dup is a caller bug, never silently absorbed. Same posture as the PG twin.
-        await this.pool.query(`INSERT INTO ${TIDB_MEMORY_SYNC_TABLES.pushQueue} (id, scope, entry_id, payload, attempts, next_attempt_at, last_error)
+        await this.pool.query(`INSERT INTO ${TIDB_MEMORY_SYNC_TABLES.pushQueue} (id, scope, entry_id, payload, attempts, next_attempt_at_ms, last_error)
        VALUES (?, ?, ?, ?, 0, ?, NULL)`, [item.id, item.scope, item.entryId, JSON.stringify(item.payload), item.nextAttemptAtMs]);
     }
     async claimDue(nowMs, limit) {
@@ -82,21 +82,21 @@ export class TiDBMemorySyncStore {
             return [];
         const leasedUntilMs = nowMs + this.claimLeaseMs;
         // Optimistic CAS claim (header rationale): read the due candidates, then win each row with a
-        // conditional UPDATE on the exact next_attempt_at we read. Losers (another worker claimed, or
+        // conditional UPDATE on the exact next_attempt_at_ms we read. Losers (another worker claimed, or
         // fail()/a re-schedule moved the row) see affectedRows=0 and are skipped — the SKIP LOCKED
         // equivalent, without pessimistic locks or a held connection.
-        const [candidates] = await this.pool.query(`SELECT id, scope, entry_id, payload, attempts, next_attempt_at, last_error
+        const [candidates] = await this.pool.query(`SELECT id, scope, entry_id, payload, attempts, next_attempt_at_ms, last_error
        FROM ${TIDB_MEMORY_SYNC_TABLES.pushQueue}
-       WHERE next_attempt_at <= ?
-       ORDER BY next_attempt_at, id
+       WHERE next_attempt_at_ms <= ?
+       ORDER BY next_attempt_at_ms, id
        LIMIT ?`, [nowMs, limit]);
         const claimed = [];
         for (const row of candidates) {
-            // affectedRows=CHANGED 语义坑防御:lease = nowMs + claimLeaseMs > nowMs ≥ 读到的 next_attempt_at
+            // affectedRows=CHANGED 语义坑防御:lease = nowMs + claimLeaseMs > nowMs ≥ 读到的 next_attempt_at_ms
             // (WHERE 已保证),新值严格大于旧值 ⇒ 匹配必 change ⇒ affectedRows=1 恒等于「真的赢了」。
             const [res] = await this.pool.query(`UPDATE ${TIDB_MEMORY_SYNC_TABLES.pushQueue}
-         SET next_attempt_at = ?
-         WHERE id = ? AND next_attempt_at = ?`, [leasedUntilMs, row.id, toMs(row.next_attempt_at)]);
+         SET next_attempt_at_ms = ?
+         WHERE id = ? AND next_attempt_at_ms = ?`, [leasedUntilMs, row.id, toMs(row.next_attempt_at_ms)]);
             if (res.affectedRows !== 1)
                 continue; // lost the race — skip, never block
             claimed.push({
@@ -119,7 +119,7 @@ export class TiDBMemorySyncStore {
         // guarantees the row CHANGES — the claim verdict is honest under BOTH affectedRows semantics
         // (mysql2 default = FOUND_ROWS/matched; changed-only would also work here).
         await this.pool.query(`UPDATE ${TIDB_MEMORY_SYNC_TABLES.pushQueue}
-       SET attempts = attempts + 1, last_error = ?, next_attempt_at = ?
+       SET attempts = attempts + 1, last_error = ?, next_attempt_at_ms = ?
        WHERE id = ?`, [error, nextAttemptAtMs, id]);
     }
 }

package/dist/plugins/pg-pool.js

@@ -116,9 +116,9 @@ export const PG_SCHEMA_STATEMENTS = [
     `CREATE INDEX IF NOT EXISTS idx_checkpoint_status_deadline ON checkpoint (status, deadline)`,
     `CREATE INDEX IF NOT EXISTS idx_checkpoint_session_status ON checkpoint (session_id, status)`,
     `CREATE TABLE IF NOT EXISTS checkpoint_ctx (
-     session_id VARCHAR(190) COLLATE "C" NOT NULL,
-     ctx        JSONB        NOT NULL,
-     updated_at BIGINT       NOT NULL,
+     session_id    VARCHAR(190) COLLATE "C" NOT NULL,
+     ctx           JSONB        NOT NULL,
+     updated_at_ms BIGINT       NOT NULL,
      PRIMARY KEY (session_id)
    )`,
     // E18 resume-at anchor map (the PG twin of the TiDB resume_anchor table — eventId→entryId; see tidb-pool.ts).
@@ -203,17 +203,17 @@ export const PG_SCHEMA_STATEMENTS = [
     // is TEXT, NOT JSONB — the byte-match contract is "string in, string out" (the store JSON.parses on load); JSONB would
     // make `pg` auto-parse the row back to an object and break the twin's String()→JSON.parse path. See workflow-journal-store-sql.ts.
     `CREATE TABLE IF NOT EXISTS workflow_journal (
-     run_id     VARCHAR(191) COLLATE "C" NOT NULL,
-     ordinal    INT          NOT NULL,
+     run_id        VARCHAR(191) COLLATE "C" NOT NULL,
+     ordinal       INT          NOT NULL,
      -- SVC-2 / CORE-9 audit BLOCKER: cross-tenant resume isolation (the WorkflowJournalStore seam takes a scope
      -- param). NOT NULL DEFAULT '' — a row written without a scope lands in the '' bucket, which is
      -- CROSS-SCOPE-ORPHANED but harmless: a real resume always filters \`WHERE scope = <caller>\`, so '' rows are
      -- never handed to a tenant. Keep the DEFAULT: it is what makes a scope-less write land in that dead bucket
      -- instead of failing or leaking into a real tenant's scope.
-     scope      VARCHAR(190) COLLATE "C" NOT NULL DEFAULT '',
-     call_key   VARCHAR(255) COLLATE "C" NOT NULL,
-     result     TEXT COLLATE "C"         NOT NULL,
-     created_at BIGINT       NOT NULL,
+     scope         VARCHAR(190) COLLATE "C" NOT NULL DEFAULT '',
+     call_key      VARCHAR(255) COLLATE "C" NOT NULL,
+     result        TEXT COLLATE "C"         NOT NULL,
+     created_at_ms BIGINT       NOT NULL,
      PRIMARY KEY (run_id, ordinal)
    )`,
     // RB-242 / WF2 ([1981] core 拍板 a 形):cross-replica workflow resume admission lease — the PG twin of
@@ -228,30 +228,30 @@ export const PG_SCHEMA_STATEMENTS = [
     // P1 (fleet failover): WorkflowRunStore + completion-inbox PG twins (design doc in workflow-run-store-sql.ts).
     // `run` is TEXT not jsonb (node-pg auto-parse would break the shared String()→JSON.parse path).
     `CREATE TABLE IF NOT EXISTS workflow_run (
-     id         VARCHAR(191) COLLATE "C" NOT NULL,
-     scope      VARCHAR(190) COLLATE "C" NOT NULL,
-     status     VARCHAR(16) COLLATE "C"  NOT NULL,
-     run        TEXT COLLATE "C"         NOT NULL,
-     rev        INTEGER      NOT NULL DEFAULT 0,
-     created_at BIGINT       NOT NULL,
-     ended_at   BIGINT,
+     id            VARCHAR(191) COLLATE "C" NOT NULL,
+     scope         VARCHAR(190) COLLATE "C" NOT NULL,
+     status        VARCHAR(16) COLLATE "C"  NOT NULL,
+     run           TEXT COLLATE "C"         NOT NULL,
+     rev           INTEGER      NOT NULL DEFAULT 0,
+     created_at_ms BIGINT       NOT NULL,
+     ended_at      BIGINT,
      PRIMARY KEY (id)
    )`,
-    `CREATE INDEX IF NOT EXISTS idx_wfrun_scope_created ON workflow_run (scope, created_at)`,
+    `CREATE INDEX IF NOT EXISTS idx_wfrun_scope_created ON workflow_run (scope, created_at_ms)`,
     `CREATE INDEX IF NOT EXISTS idx_wfrun_scope_status ON workflow_run (scope, status)`,
     `CREATE TABLE IF NOT EXISTS workflow_completion_inbox (
-     seq         BIGSERIAL,
-     session_id  VARCHAR(190) COLLATE "C" NOT NULL,
-     run_id      VARCHAR(191) COLLATE "C" NOT NULL,
-     owner       VARCHAR(190) COLLATE "C",
-     status      VARCHAR(16) COLLATE "C"  NOT NULL,
-     summary     TEXT COLLATE "C"         NOT NULL,
-     enqueued_at BIGINT       NOT NULL,
+     seq            BIGSERIAL,
+     session_id     VARCHAR(190) COLLATE "C" NOT NULL,
+     run_id         VARCHAR(191) COLLATE "C" NOT NULL,
+     owner          VARCHAR(190) COLLATE "C",
+     status         VARCHAR(16) COLLATE "C"  NOT NULL,
+     summary        TEXT COLLATE "C"         NOT NULL,
+     enqueued_at_ms BIGINT       NOT NULL,
      -- 1.109 delivery envelope. kind NULL = a LEGACY \`workflow_complete\` row (the shape that predates the
      -- envelope); readers must keep treating NULL as that kind, it is not "unknown". payload = the kind's
      -- body, NULL for the legacy shape.
-     kind        VARCHAR(24) COLLATE "C",
-     payload     TEXT COLLATE "C",
+     kind           VARCHAR(24) COLLATE "C",
+     payload        TEXT COLLATE "C",
      PRIMARY KEY (session_id, run_id),
      -- Twin-alignment with TiDB's \`UNIQUE KEY uq_wfinbox_seq (seq)\` (same constraint name on purpose, so the two
      -- schemas can be diffed by name). This is NOT a correctness fix: seq is BIGSERIAL, so it is already unique in

package/dist/plugins/task-list-store-sql.d.ts

@@ -27,7 +27,7 @@ import type { Pool as MySqlPool } from "mysql2/promise";
 import type { Pool as PgPool } from "pg";
 import { type TaskListStore } from "@sema-agent/core";
 export declare const TASK_LIST_META_TABLE = "task_list_meta";
-export declare const TASK_LIST_ITEMS_TABLE = "task_list_items";
+export declare const TASK_LIST_ITEM_TABLE = "task_list_item";
 export declare function ensureTiDBTaskListSchema(pool: MySqlPool): Promise<void>;
 export declare function ensurePgTaskListSchema(q: (text: string, params?: unknown[]) => Promise<unknown>): Promise<void>;
 export declare function createTiDBTaskListStore(pool: MySqlPool, listKey: string): TaskListStore;