@sema-agent/server 7.5.0 → 7.7.0

package/dist/plugins/background-agent-store-sql.js

@@ -163,7 +163,7 @@ export async function ensureTiDBBackgroundAgentSchema(pool) {
     handle VARBINARY(190) NOT NULL,
     scope VARCHAR(190) NOT NULL,
     owner VARCHAR(190) NOT NULL,
-    session_scoped TINYINT NOT NULL,
+    session_scoped TINYINT(1) NOT NULL,
     session_id VARCHAR(190) NULL,
     parent_session_id VARCHAR(190) NULL,
     -- core 1.367 δ(additive):root 锚(listBySession 第二臂;NULL = 该记录无 root 锚,谓词天然拒)
@@ -198,29 +198,29 @@ export async function ensurePgBackgroundAgentSchema(q) {
     await q(`CREATE TABLE IF NOT EXISTS ${BACKGROUND_AGENT_TABLE} (
     scope_key VARCHAR(190) COLLATE "C" NOT NULL,
     handle VARCHAR(190) COLLATE "C" NOT NULL,
-    scope VARCHAR(190) NOT NULL,
-    owner VARCHAR(190) NOT NULL,
+    scope VARCHAR(190) COLLATE "C" NOT NULL,
+    owner VARCHAR(190) COLLATE "C" NOT NULL,
     session_scoped SMALLINT NOT NULL,
-    session_id VARCHAR(190),
-    parent_session_id VARCHAR(190),
+    session_id VARCHAR(190) COLLATE "C",
+    parent_session_id VARCHAR(190) COLLATE "C",
     -- core 1.367 δ(additive,TiDB 同案):root 锚(listBySession 第二臂)
-    root_session_id VARCHAR(190),
-    session_anchor VARCHAR(190),
-    name VARCHAR(255),
-    agent_type VARCHAR(190),
-    status VARCHAR(16) NOT NULL,
+    root_session_id VARCHAR(190) COLLATE "C",
+    session_anchor VARCHAR(190) COLLATE "C",
+    name VARCHAR(255) COLLATE "C",
+    agent_type VARCHAR(190) COLLATE "C",
+    status VARCHAR(16) COLLATE "C" NOT NULL,
     spawned_at_ms BIGINT NOT NULL,
     updated_at_ms BIGINT NOT NULL,
     settled_at_ms BIGINT,
-    usage_json TEXT,
+    usage_json TEXT COLLATE "C",
     rev BIGINT NOT NULL,
     -- core 1.383([1565] / design/153 件3a)ε(TiDB 同案注):updateIf 的 CAS 守卫专用列
-    parked_checkpoint_token VARCHAR(190),
-    park_claim_id VARCHAR(190),
+    parked_checkpoint_token VARCHAR(190) COLLATE "C",
+    park_claim_id VARCHAR(190) COLLATE "C",
     -- core 5.14.0 #22(TiDB 同案注:三态与「写侧投影」口径见 MySQL 孪生的行内注)。
-    admitted_org_scopes TEXT,
-    admitted_org_write_scope VARCHAR(190),
-    record_json TEXT NOT NULL,
+    admitted_org_scopes TEXT COLLATE "C",
+    admitted_org_write_scope VARCHAR(190) COLLATE "C",
+    record_json TEXT COLLATE "C" NOT NULL,
     PRIMARY KEY (scope_key, handle)
   )`);
     await q(`CREATE INDEX IF NOT EXISTS idx_bga_anchor ON ${BACKGROUND_AGENT_TABLE} (scope_key, session_anchor, spawned_at_ms)`);

package/dist/plugins/breaker-state-sql.js

@@ -4,8 +4,8 @@ import { mysqlDriver, pgDriver } from "./sql-driver.js";
  *  centrally in tidb-pool.ts (no PG-side twin needed there — production wires ONE ensureTidbSchema). */
 export const PG_BREAKER_STATE_SCHEMA = [
     `CREATE TABLE IF NOT EXISTS circuit_breaker (
-     breaker_key VARCHAR(190)   NOT NULL,
-     phase       VARCHAR(16)    NOT NULL,
+     breaker_key VARCHAR(190) COLLATE "C"   NOT NULL,
+     phase       VARCHAR(16) COLLATE "C"    NOT NULL,
      failures    INTEGER        NOT NULL DEFAULT 0,
      opened_at   TIMESTAMPTZ(3),
      updated_at  TIMESTAMPTZ(3) NOT NULL,

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

@@ -226,8 +226,11 @@ export declare class SqlCheckpointStore implements CheckpointStore {
      *
      * 🔴 从「一条无条件 UPDATE」变成「读-改-写」,中间那道窗必须自己有 CAS:两个并发 steer 读到同一份
      * 队列、后写者整个盖掉前者 —— 就是 #147 要消灭的静默丢失换了个位置复发。守卫是 `pending_steer_rev`
-     * **专用整数列**(不是拿旧列值比:本表无显式 COLLATE,*_ci 排序规则会把只差大小写的两份信封判等 ⇒
-     * CAS 假命中;也不是复用 resolve 的 `rev`:bump 它会让并发 resume 的 `resolve(expect)` 白白落败)。
+     * **专用整数列**(不是拿旧列值比:整数按构造唯一,而长 JSON 文本的相等性取决于排序规则/字段序/空白与
+     * 转义形,任一处判等松一点就是一次 CAS 假命中 = 悄悄丢一条 steer。#192 A11 更正:本注原先的理由写的是
+     * "本表无显式 COLLATE,*_ci 会把只差大小写的两份信封判等",那半已不成立——`checkpoint` 现在钉了
+     * `COLLATE utf8mb4_bin`/PG 侧 `COLLATE "C"`;结论不变,理由回到上面那条更根本的;
+     * 也不是复用 resolve 的 `rev`:bump 它会让并发 resume 的 `resolve(expect)` 白白落败)。
      * CAS 输了就重读重算(队列只有 3 个位子,争用者天然极少);给足冗余仍全败 ⇒ **抛**,不返回 false ——
      * `false` 在调用方的语义是「没有 pending 行可转向」(HTTP 409「已不再挂起」),把争用报成那个是撒谎。
      *

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

@@ -454,8 +454,11 @@ export class SqlCheckpointStore {
      *
      * 🔴 从「一条无条件 UPDATE」变成「读-改-写」,中间那道窗必须自己有 CAS:两个并发 steer 读到同一份
      * 队列、后写者整个盖掉前者 —— 就是 #147 要消灭的静默丢失换了个位置复发。守卫是 `pending_steer_rev`
-     * **专用整数列**(不是拿旧列值比:本表无显式 COLLATE,*_ci 排序规则会把只差大小写的两份信封判等 ⇒
-     * CAS 假命中;也不是复用 resolve 的 `rev`:bump 它会让并发 resume 的 `resolve(expect)` 白白落败)。
+     * **专用整数列**(不是拿旧列值比:整数按构造唯一,而长 JSON 文本的相等性取决于排序规则/字段序/空白与
+     * 转义形,任一处判等松一点就是一次 CAS 假命中 = 悄悄丢一条 steer。#192 A11 更正:本注原先的理由写的是
+     * "本表无显式 COLLATE,*_ci 会把只差大小写的两份信封判等",那半已不成立——`checkpoint` 现在钉了
+     * `COLLATE utf8mb4_bin`/PG 侧 `COLLATE "C"`;结论不变,理由回到上面那条更根本的;
+     * 也不是复用 resolve 的 `rev`:bump 它会让并发 resume 的 `resolve(expect)` 白白落败)。
      * CAS 输了就重读重算(队列只有 3 个位子,争用者天然极少);给足冗余仍全败 ⇒ **抛**,不返回 false ——
      * `false` 在调用方的语义是「没有 pending 行可转向」(HTTP 409「已不再挂起」),把争用报成那个是撒谎。
      *

package/dist/plugins/image-bake-store-sql.d.ts

@@ -7,7 +7,7 @@ import { type BakeStatus, type BakeState, type BakeRecord, type BakeEvent, type
  *  TINYINT(1) 归一(clay 批 2026-07-26):布尔列的 PG 映射统一 SMALLINT 0/1(此前本家族用 BOOLEAN)——
  *  两方言驱动读回同为 number ⇒ 不再存在「忘了配的适配器」这个病族;写入参与 SQL 字面量一律 0/1,
  *  读侧 `!!`/`Boolean()` 保持,store 出口 JS 类型逐字节不变(真双库套件的严格值断言为证)。
- *  The uq_line UNIQUE is given an explicit name so a 23505 can be attributed to it via err.constraint. */
+ *  The line UNIQUE is given the explicit name uq_image_bake_event_line so a 23505 can be attributed to it via err.constraint. */
 export declare const PG_IMAGE_BAKE_SCHEMA: string[];
 /** Idempotent self-contained PG schema apply (for the integration test; central aggregation is done separately). */
 export declare function ensurePgImageBakeSchema(pool: PgPool | PoolClient, poolName?: string): Promise<void>;

package/dist/plugins/image-bake-store-sql.js

@@ -26,7 +26,7 @@
  *   - `?` placeholders vs `$n`                        - `CAST(? AS JSON)` vs `$n::jsonb` (argv equality)
  *   - `INSERT IGNORE` vs `ON CONFLICT DO NOTHING`     - affectedRows vs rowCount (via SqlDriver)
  *   - dup-key `ER_DUP_ENTRY` vs SQLSTATE `23505`      - which UNIQUE collided: mysql2 `sqlMessage` text
- *                                                       vs pg `err.constraint` (uq_line naming differs)
+ *                                                       vs pg `err.constraint` (#192 A5 归一后两条方言同名 uq_image_bake_event_line)
  *   - `BEGIN PESSIMISTIC` (TiDB current read) vs `BEGIN` (PG READ COMMITTED under the sentinel lock)
  *   - the ADMISSION statement itself differs (see createBakeIfIdle) — both are correct under the
  *     sentinel lock, and both are preserved verbatim because the real-DB suites are the oracle
@@ -46,34 +46,34 @@ import { mapBakeRow as mapRow, BAKE_SELECT_COLS as SELECT_COLS, } from "./store-
  *  TINYINT(1) 归一(clay 批 2026-07-26):布尔列的 PG 映射统一 SMALLINT 0/1(此前本家族用 BOOLEAN)——
  *  两方言驱动读回同为 number ⇒ 不再存在「忘了配的适配器」这个病族;写入参与 SQL 字面量一律 0/1,
  *  读侧 `!!`/`Boolean()` 保持,store 出口 JS 类型逐字节不变(真双库套件的严格值断言为证)。
- *  The uq_line UNIQUE is given an explicit name so a 23505 can be attributed to it via err.constraint. */
+ *  The line UNIQUE is given the explicit name uq_image_bake_event_line so a 23505 can be attributed to it via err.constraint. */
 export const PG_IMAGE_BAKE_SCHEMA = [
     `CREATE TABLE IF NOT EXISTS image_bake (
-     bake_id          VARCHAR(64)  NOT NULL,
-     profile          VARCHAR(128) NOT NULL,
+     bake_id          VARCHAR(64) COLLATE "C"  NOT NULL,
+     profile          VARCHAR(128) COLLATE "C" NOT NULL,
      bands            JSONB        NULL,
-     base_ref         VARCHAR(255) NULL,
+     base_ref         VARCHAR(255) COLLATE "C" NULL,
      push             SMALLINT     NOT NULL DEFAULT 0,
      dry_run          SMALLINT     NOT NULL DEFAULT 0,
      logs             SMALLINT     NOT NULL DEFAULT 0,
      argv             JSONB        NOT NULL,
-     status           VARCHAR(16)  NOT NULL,
-     state            VARCHAR(16)  NULL,
-     digest           VARCHAR(255) NULL,
-     repo             VARCHAR(255) NULL,
-     ref              VARCHAR(320) NULL,
-     index_id         VARCHAR(64)  NULL,
+     status           VARCHAR(16) COLLATE "C"  NOT NULL,
+     state            VARCHAR(16) COLLATE "C"  NULL,
+     digest           VARCHAR(255) COLLATE "C" NULL,
+     repo             VARCHAR(255) COLLATE "C" NULL,
+     ref              VARCHAR(320) COLLATE "C" NULL,
+     index_id         VARCHAR(64) COLLATE "C"  NULL,
      exit_code        INT          NULL,
-     error            TEXT         NULL,
-     error_code       VARCHAR(32)  NULL,
-     manifest_sha     VARCHAR(64)  NULL,
-     tag              VARCHAR(255) NULL,
-     idem_key         VARCHAR(255) NULL,
-     ingest_secret    VARCHAR(64)  NULL,
-     runner_id        VARCHAR(64)  NULL,
+     error            TEXT COLLATE "C"         NULL,
+     error_code       VARCHAR(32) COLLATE "C"  NULL,
+     manifest_sha     VARCHAR(64) COLLATE "C"  NULL,
+     tag              VARCHAR(255) COLLATE "C" NULL,
+     idem_key         VARCHAR(255) COLLATE "C" NULL,
+     ingest_secret    VARCHAR(64) COLLATE "C"  NULL,
+     runner_id        VARCHAR(64) COLLATE "C"  NULL,
      lease_until      TIMESTAMPTZ(3) NULL,
      cancel_requested SMALLINT     NOT NULL DEFAULT 0,
-     requested_by     VARCHAR(128) NULL,
+     requested_by     VARCHAR(128) COLLATE "C" NULL,
      created_at       TIMESTAMPTZ(3) NOT NULL,
      updated_at       TIMESTAMPTZ(3) NOT NULL,
      PRIMARY KEY (bake_id),
@@ -82,19 +82,19 @@ export const PG_IMAGE_BAKE_SCHEMA = [
     `CREATE INDEX IF NOT EXISTS idx_image_bake_status ON image_bake (status)`,
     `CREATE INDEX IF NOT EXISTS idx_image_bake_created ON image_bake (created_at)`,
     `CREATE TABLE IF NOT EXISTS image_bake_event (
-     bake_id  VARCHAR(64) NOT NULL,
+     bake_id  VARCHAR(64) COLLATE "C" NOT NULL,
      seq      INT         NOT NULL,
      line_ord INT         NULL,
-     kind     VARCHAR(24) NOT NULL,
-     level    VARCHAR(8)  NULL,
+     kind     VARCHAR(24) COLLATE "C" NOT NULL,
+     level    VARCHAR(8) COLLATE "C"  NULL,
      data     JSONB       NULL,
      ts       TIMESTAMPTZ(3) NOT NULL,
      PRIMARY KEY (bake_id, seq),
      CONSTRAINT uq_image_bake_event_line UNIQUE (bake_id, line_ord)
    )`,
     `CREATE TABLE IF NOT EXISTS image_bake_lease (
-     pool        VARCHAR(32) NOT NULL DEFAULT 'standard',
-     bake_id     VARCHAR(64) NOT NULL,
+     pool        VARCHAR(32) COLLATE "C" NOT NULL DEFAULT 'standard',
+     bake_id     VARCHAR(64) COLLATE "C" NOT NULL,
      acquired_at TIMESTAMPTZ(3) NOT NULL,
      expires_at  TIMESTAMPTZ(3) NOT NULL,
      PRIMARY KEY (pool)
@@ -104,7 +104,7 @@ export const PG_IMAGE_BAKE_SCHEMA = [
     // NOT EXISTS that two concurrent READ COMMITTED txns both pass — see createBakeIfIdle). Dialect-uniform with
     // the TiDB twin so a future divergence FAILS LOUD in the shared real-DB suite.
     `CREATE TABLE IF NOT EXISTS image_bake_admit (
-     pool VARCHAR(32) NOT NULL,
+     pool VARCHAR(32) COLLATE "C" NOT NULL,
      PRIMARY KEY (pool)
    )`,
 ];
@@ -121,7 +121,7 @@ function isDupKey(dialect, err) {
     return Boolean(err) && code === (dialect === "tidb" ? "ER_DUP_ENTRY" : "23505");
 }
 /** Which UNIQUE key did the dup collide on? The ATTRIBUTION CHANNEL differs by engine: mysql2 names the key in
- *  `sqlMessage` ("Duplicate entry '…' for key 'image_bake_event.uq_line'" vs "…'image_bake_event.PRIMARY'");
+ *  `sqlMessage` ("Duplicate entry '…' for key 'image_bake_event.uq_image_bake_event_line'" vs "…'image_bake_event.PRIMARY'");
  *  PG names the violated constraint in `err.constraint` (the PK is auto-named `image_bake_event_pkey`, the line
  *  UNIQUE is explicitly named `uq_image_bake_event_line` so it is attributable at all).
  *  M2: a line-unique dup is a BENIGN at-least-once re-send (already stored → no-op); a `PRIMARY` (bake_id,seq)
@@ -129,7 +129,7 @@ function isDupKey(dialect, err) {
 function dupKeyName(dialect, err) {
     if (dialect === "tidb") {
         const msg = String(err?.sqlMessage ?? err?.message ?? "");
-        if (/uq_line/i.test(msg))
+        if (/uq_image_bake_event_line/i.test(msg))
             return "uq_line";
         if (/PRIMARY/i.test(msg))
             return "primary";

package/dist/plugins/image-index-sql.js

@@ -52,33 +52,33 @@ import { mysqlDriver, pgDriver } from "./sql-driver.js";
  *  读侧 `!!` 保持,出口 JS 类型不变), inline UNIQUE KEY/KEY → separate CREATE UNIQUE INDEX / CREATE INDEX). */
 export const PG_IMAGE_INDEX_SCHEMA = [
     `CREATE TABLE IF NOT EXISTS sandbox_image_index (
-     id                 VARCHAR(64)  NOT NULL,
-     profile            VARCHAR(64)  NOT NULL,
+     id                 VARCHAR(64) COLLATE "C"  NOT NULL,
+     profile            VARCHAR(64) COLLATE "C"  NOT NULL,
      bands              JSONB,
-     repo               VARCHAR(255) NOT NULL,
-     tag                VARCHAR(128) NOT NULL,
-     digest             VARCHAR(80)  NOT NULL,
+     repo               VARCHAR(255) COLLATE "C" NOT NULL,
+     tag                VARCHAR(128) COLLATE "C" NOT NULL,
+     digest             VARCHAR(80) COLLATE "C"  NOT NULL,
      toolchain_versions JSONB,
      capabilities       JSONB,
      pod_contract       JSONB,
      size_bytes         BIGINT,
-     status             VARCHAR(16)  NOT NULL DEFAULT 'building',
-     visibility         VARCHAR(16)  NOT NULL DEFAULT 'public',
-     tenant_id          VARCHAR(64),
-     manifest_sha       VARCHAR(64),
-     recipe_git_sha     VARCHAR(64),
-     generator_version  VARCHAR(32),
+     status             VARCHAR(16) COLLATE "C"  NOT NULL DEFAULT 'building',
+     visibility         VARCHAR(16) COLLATE "C"  NOT NULL DEFAULT 'public',
+     tenant_id          VARCHAR(64) COLLATE "C",
+     manifest_sha       VARCHAR(64) COLLATE "C",
+     recipe_git_sha     VARCHAR(64) COLLATE "C",
+     generator_version  VARCHAR(32) COLLATE "C",
      build_date         TIMESTAMPTZ(3),
-     supersedes         VARCHAR(64),
+     supersedes         VARCHAR(64) COLLATE "C",
      signed             SMALLINT     NOT NULL DEFAULT 0,
      created_at         TIMESTAMPTZ(3) NOT NULL,
      updated_at         TIMESTAMPTZ(3) NOT NULL,
      PRIMARY KEY (id)
    )`,
     `CREATE UNIQUE INDEX IF NOT EXISTS uq_repo_digest ON sandbox_image_index (repo, digest)`,
-    `CREATE INDEX IF NOT EXISTS idx_profile_status ON sandbox_image_index (profile, status, visibility)`,
-    `CREATE INDEX IF NOT EXISTS idx_digest ON sandbox_image_index (digest)`,
-    `CREATE INDEX IF NOT EXISTS idx_tenant ON sandbox_image_index (tenant_id, status)`,
+    `CREATE INDEX IF NOT EXISTS idx_sandbox_image_index_profile_status ON sandbox_image_index (profile, status, visibility)`,
+    `CREATE INDEX IF NOT EXISTS idx_sandbox_image_index_digest ON sandbox_image_index (digest)`,
+    `CREATE INDEX IF NOT EXISTS idx_sandbox_image_index_tenant ON sandbox_image_index (tenant_id, status)`,
 ];
 /** Idempotent self-contained schema apply (for the integration test; central aggregation is done separately). */
 export async function ensureSchema(pool) {

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

@@ -111,7 +111,7 @@ export async function ensurePgMailboxSchema(q) {
     await q(`CREATE TABLE IF NOT EXISTS ${MAILBOX_TABLE} (
     scope_key VARCHAR(190) COLLATE "C" NOT NULL,
     handle VARCHAR(190) COLLATE "C" NOT NULL,
-    scope VARCHAR(190) NOT NULL,
+    scope VARCHAR(190) COLLATE "C" NOT NULL,
     next_seq BIGINT NOT NULL,
     lease_owner VARCHAR(190) COLLATE "C",
     lease_expires_at_ms BIGINT,
@@ -123,9 +123,9 @@ export async function ensurePgMailboxSchema(q) {
     handle VARCHAR(190) COLLATE "C" NOT NULL,
     seq BIGINT NOT NULL,
     from_id VARCHAR(255) COLLATE "C",
-    content TEXT NOT NULL,
+    content TEXT COLLATE "C" NOT NULL,
     sent_at_ms BIGINT NOT NULL,
-    hop_chain TEXT, -- core 5.17.0 design/176(TiDB twin 同注:NULL = 缺席且有语义)
+    hop_chain TEXT COLLATE "C", -- core 5.17.0 design/176(TiDB twin 同注:NULL = 缺席且有语义)
     PRIMARY KEY (scope_key, handle, seq)
   )`);
     await q(`CREATE INDEX IF NOT EXISTS idx_mbm_sent ON ${MAILBOX_MSG_TABLE} (scope_key, handle, sent_at_ms)`);

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

@@ -42,18 +42,18 @@ export async function ensurePgMemoryEngineSchema(query, opts = {}) {
         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} (
-    id text PRIMARY KEY,
-    scope text NOT NULL,
-    slug text NOT NULL,
+    id text COLLATE "C" PRIMARY KEY,
+    scope text COLLATE "C" NOT NULL,
+    slug text COLLATE "C" NOT NULL,
     frontmatter jsonb NOT NULL,
-    body text NOT NULL,
-    rev text NOT NULL,
+    body text COLLATE "C" NOT NULL,
+    rev text COLLATE "C" NOT NULL,
     mtime_ms bigint NOT NULL,
     size_bytes integer NOT NULL,
     embedding ${embeddingCol}
   )`);
     try {
-        await query(`CREATE INDEX IF NOT EXISTS ${PG_MEMORY_ENGINE_TABLES.entries}_scope_idx ON ${PG_MEMORY_ENGINE_TABLES.entries} (scope)`);
+        await query(`CREATE INDEX IF NOT EXISTS idx_${PG_MEMORY_ENGINE_TABLES.entries}_scope ON ${PG_MEMORY_ENGINE_TABLES.entries} (scope)`);
     }
     catch {
         /* pg-mem: partial CREATE INDEX support — the index is a perf add-on, never correctness */
@@ -63,10 +63,10 @@ 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 ${PG_MEMORY_ENGINE_TABLES.entries}_scope_slug_uq ON ${PG_MEMORY_ENGINE_TABLES.entries} (scope, slug)`);
+    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} (
-    scope text PRIMARY KEY,
-    cursor text NOT NULL
+    scope text COLLATE "C" PRIMARY KEY,
+    cursor text COLLATE "C" NOT NULL
   )`);
 }
 /** pgvector input literal — the same `[…]` string JSON.parse reads back from jsonb (one format, two columns). */

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 腿;uk_scope_slug=并发 slug 竞争 → 下一个 -n 后缀重试);
+//     并发同 id add → 转 UPDATE 腿;uq_agent_memory_engine_entries_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);
@@ -45,9 +45,9 @@ export async function ensureTiDBMemoryEngineSchema(pool) {
     size_bytes  INT          NOT NULL,
     embedding   JSON         NULL,
     PRIMARY KEY (id),
-    KEY idx_scope (scope),
-    UNIQUE KEY uk_scope_slug (scope, slug)
-  )`);
+    KEY idx_agent_memory_engine_entries_scope (scope),
+    UNIQUE KEY uq_agent_memory_engine_entries_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.
@@ -55,14 +55,14 @@ export async function ensureTiDBMemoryEngineSchema(pool) {
     scope  VARCHAR(190) NOT NULL,
     \`cursor\` TEXT     NOT NULL,
     PRIMARY KEY (scope)
-  )`);
+  ) COLLATE utf8mb4_bin`);
 }
 function isDupEntry(err) {
     if (typeof err !== "object" || err === null)
         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.uk_scope_slug'`)
+/** ER_DUP_ENTRY messages name the violated key (`… for key 'tbl.PRIMARY'` / `… for key 'tbl.uq_agent_memory_engine_entries_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 ?? ""));
@@ -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 uk_scope_slug, and
+            // probe is only an optimization — the write INSIDE the loop is arbitrated by uq_agent_memory_engine_entries_scope_slug, and
             // a concurrent loser retries the next suffix (Pg 版同注).
             let slug = entry.slug;
             for (let n = 2;; n++) {

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

@@ -8,23 +8,23 @@ export const PG_MEMORY_SYNC_TABLES = {
 /** 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} (
-    scope         varchar(190) NOT NULL,
-    peer          varchar(190) NOT NULL,
+    scope         varchar(190) COLLATE "C" NOT NULL,
+    peer          varchar(190) COLLATE "C" NOT NULL,
     base_revs     jsonb        NOT NULL,
     updated_at_ms bigint       NOT NULL,
     PRIMARY KEY (scope, peer)
   )`);
     await query(`CREATE TABLE IF NOT EXISTS ${PG_MEMORY_SYNC_TABLES.pushQueue} (
-    id              char(36)     PRIMARY KEY,
-    scope           varchar(190) NOT NULL,
-    entry_id        char(36)     NOT 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 bigint       NOT NULL,
-    last_error      text         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 ${PG_MEMORY_SYNC_TABLES.pushQueue}_next_attempt_idx ON ${PG_MEMORY_SYNC_TABLES.pushQueue} (next_attempt_at)`);
+    await query(`CREATE INDEX IF NOT EXISTS idx_${PG_MEMORY_SYNC_TABLES.pushQueue}_next_attempt ON ${PG_MEMORY_SYNC_TABLES.pushQueue} (next_attempt_at)`);
 }
 /** 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. */
@@ -135,17 +135,17 @@ export async function ensurePgMemoryHistorySchema(query) {
     // (caller-injected epoch ms) instead of the draft's TIMESTAMP — the family's clock discipline
     // (sync_cursors.updated_at_ms precedent; DB clocks never judge anything).
     await query(`CREATE TABLE IF NOT EXISTS ${PG_MEMORY_SYNC_TABLES.history} (
-    id            char(36)     NOT NULL,
-    rev           varchar(128) NOT NULL,
-    prev_rev      varchar(128) NULL,
-    op            varchar(16)  NOT NULL,
-    scope         varchar(190) NOT NULL,
+    id            char(36) COLLATE "C"     NOT NULL,
+    rev           varchar(128) COLLATE "C" NOT NULL,
+    prev_rev      varchar(128) COLLATE "C" NULL,
+    op            varchar(16) COLLATE "C"  NOT NULL,
+    scope         varchar(190) COLLATE "C" NOT NULL,
     snapshot      jsonb        NULL,
     written_at_ms bigint       NOT NULL,
     PRIMARY KEY (id, rev)
   )`);
     // countByScope / future per-scope export-with-history scan face. Perf add-on, never correctness.
-    await query(`CREATE INDEX IF NOT EXISTS ${PG_MEMORY_SYNC_TABLES.history}_scope_idx ON ${PG_MEMORY_SYNC_TABLES.history} (scope)`);
+    await query(`CREATE INDEX IF NOT EXISTS idx_${PG_MEMORY_SYNC_TABLES.history}_scope ON ${PG_MEMORY_SYNC_TABLES.history} (scope)`);
 }
 export class PgMemoryHistoryStore {
     query;

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

@@ -15,7 +15,7 @@ export async function ensureTiDBMemorySyncSchema(pool) {
     base_revs     JSON         NOT NULL,
     updated_at_ms BIGINT       NOT NULL,
     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,
@@ -25,8 +25,8 @@ export async function ensureTiDBMemorySyncSchema(pool) {
     next_attempt_at BIGINT       NOT NULL,
     last_error      TEXT         NULL,
     PRIMARY KEY (id),
-    KEY idx_next_attempt (next_attempt_at)
-  )`);
+    KEY idx_agent_memory_engine_push_queue_next_attempt (next_attempt_at)
+  ) COLLATE utf8mb4_bin`);
 }
 /** JSON-column defense: mysql2 normally hands back parsed objects for JSON columns, but string
  *  shapes leak through (connection flags/proxies) — same posture as memory-engine-tidb.ts. */
@@ -138,8 +138,8 @@ export async function ensureTiDBMemoryHistorySchema(pool) {
     snapshot      JSON         NULL,
     written_at_ms BIGINT       NOT NULL,
     PRIMARY KEY (id, rev),
-    KEY idx_history_scope (scope)
-  )`);
+    KEY idx_agent_memory_engine_history_scope (scope)
+  ) COLLATE utf8mb4_bin`);
 }
 export class TiDBMemoryHistoryStore {
     pool;

package/dist/plugins/outcome-ledger-sql.js

@@ -113,12 +113,12 @@ export function coreOutcomeToLedgerRow(o) {
  */
 export const PG_OUTCOME_LEDGER_SCHEMA = [
     `CREATE TABLE IF NOT EXISTS outcome_ledger (
-     id             VARCHAR(64)  NOT NULL,
-     task_signature VARCHAR(190) NOT NULL,
-     model          VARCHAR(190) NOT NULL,
-     task_id        VARCHAR(64),
-     run_status     VARCHAR(20)  NOT NULL DEFAULT 'completed-graded',
-     route          VARCHAR(16),
+     id             VARCHAR(64) COLLATE "C"  NOT NULL,
+     task_signature VARCHAR(190) COLLATE "C" NOT NULL,
+     model          VARCHAR(190) COLLATE "C" NOT NULL,
+     task_id        VARCHAR(64) COLLATE "C",
+     run_status     VARCHAR(20) COLLATE "C"  NOT NULL DEFAULT 'completed-graded',
+     route          VARCHAR(16) COLLATE "C",
      worker_count   INTEGER,
      oracle_passed  INTEGER,
      oracle_total   INTEGER,
@@ -128,7 +128,7 @@ export const PG_OUTCOME_LEDGER_SCHEMA = [
      replan_triggers JSONB,
      cost_micro_usd BIGINT,
      turns          INTEGER,
-     outcome        VARCHAR(8),
+     outcome        VARCHAR(8) COLLATE "C",
      llm_assisted   JSONB,
      signature_inputs JSONB,
      -- design/73 §1 bridge: the VERBATIM core TaskOutcome fact (oracleHadRedRun / status / oracle blob) as it

package/dist/plugins/pg-cost-quota.js

@@ -1,6 +1,6 @@
 import { PgWriteBehindCounter } from "./write-behind-counter.js";
 /** The counter's table binding for the cumulative cost quota (mirror of the TiDB twin's binding). */
-const COST_QUOTA_TABLE = { table: "cost_quota", keyCol: "scope_key", valCol: "micro" };
+const COST_QUOTA_TABLE = { table: "cost_quota", keyCol: "scope_key", valCol: "micro_usd" };
 export class PgCostQuota {
     limitMicroUsd;
     counter;
@@ -39,9 +39,9 @@ export class PgCostQuota {
  *  tables, so a self-contained ensureSchema is safe (the central pg-pool aggregation is done separately). */
 export const PG_COST_QUOTA_SCHEMA = [
     `CREATE TABLE IF NOT EXISTS cost_quota (
-     scope_key     VARCHAR(190) NOT NULL,
+     scope_key     VARCHAR(190) COLLATE "C" NOT NULL,
      window_bucket BIGINT       NOT NULL,
-     micro         BIGINT       NOT NULL DEFAULT 0,
+     micro_usd         BIGINT       NOT NULL DEFAULT 0,
      updated_at    TIMESTAMPTZ(3) NOT NULL,
      PRIMARY KEY (scope_key, window_bucket)
    )`,