@sema-agent/server 7.5.0 → 7.6.0

package/dist/plugins/approval-ask-store-sql.js

@@ -71,13 +71,46 @@ export const APPROVAL_BATCHES_TABLE = "approval_batches";
  *
  * SCHEMA POLICY 同 `tidb-pool.ts` 头注:纯 CREATE,禁 ALTER 增量 seam,改列直接改这里 + 重建库
  * (`docs/schema/baseline-mysql.sql` 是由这些文本机器录制出的**产物**,永不手改)。
+ *
+ * ── 列宽的**测量依据**(#192 A10;U2 逐列取证在档)──────────────────────────────────────────────────
+ * 本表家族原先一律 VARCHAR(255),是"先建表后想"的产物。按"每列的值到底由谁铸、有没有入口上限"重新裁:
+ *
+ *  收窄(有硬上限背书,证据即上限本身):
+ *   · `ask_id` / `batch_id` / `bound_ask_id` → 64:`deriveAskId`/`deriveBatchId` 恒是 sha256 hex 取前
+ *     64 字符(`approval-ask-machine.ts` deterministicId),按构造不可能更长。
+ *   · `task_id` → 64:入口 `UUIDV7_RE`(`security.ts:134`)只放行 36 字符的规范 uuidv7;与兄弟列
+ *     `task_run.task_id VARCHAR(64)` 同宽(此前 255 是本家族独有的偏离,无依据)。
+ *   · `session_id` → 64:提交入口硬拒 >64(`http/server.ts` "sessionId must be at most 64 characters"),
+ *     与 `session_meta`/`task_run` 同宽。
+ *   · `owner` → 190:`assertPrincipalShape` 的 `PRINCIPAL_MAX_LENGTH = 190`(`security.ts:350`)硬拒更长者;
+ *     全仓每一根 owner/scope 轴都是 190,此前 255 同样是无依据偏离。
+ *   · `gate_token` → 120:它抄的是 checkpoint 的 token(core `mintCheckpointToken` = 16 字节 hex = 32 字符),
+ *     取与**被抄那一列** `checkpoint.token VARCHAR(120)` 同宽 —— 同一个值在两张表上宽度必须一致,
+ *     否则抄的那一步就是一道静默截断。512 是原先的 16 倍冗余。
+ *
+ *  🔑 上面四条收窄之所以**不引入任何新暴露面**,靠的不是入口断言而是一条更硬的事实:同一个 session_id /
+ *     task_id / owner **早就**同时躺在 `session_meta.session_id VARCHAR(64)` / `task_run.task_id VARCHAR(64)` /
+ *     `task_run.owner VARCHAR(190)` 里。任何长到能撑爆本表新宽度的值,在写到那几张**更中心**的表时就已经
+ *     先炸了 —— 本表此前的 255 从来不是一道额外的安全余量,只是一处与全仓不一致的偏离。
+ *     ⇒ 收窄的风险上界 = 0;真正要担心的是反过来:留着 255 会让人误以为这里可以存更长的 id。
+ *
+ *  🔴 **刻意不收窄**(测量结果不支持,记在这里免得下一个人以为是漏了):
+ *   · `source_task_id` / `tool_call_id` / `parent_tool_call_id` / `gate_bound_call_id` —— 这四列的值是
+ *     **模型/引擎铸的原始 id**,服务端在写行这一步**没有任何长度断言**(`approval-card.ts` 的
+ *     `MAX_IDENT` 只裁了给人看的那份 card 投影,不是本列)。没有入口上限就收窄 = 把"存不下"这件事
+ *     推迟到 INSERT 才炸(MySQL 更糟:静默截断),换来的只是几十字节。要收窄,先补入口断言
+ *     (照 `assertPrincipalShape`/`assertIdempotencyKeyShape` 的姿势),那是另一件事。
+ *   · `bound_input_hash` / `gate_bound_input_hash` —— 按约定是 sha256 hex(64),但 `readBoundInputHash`
+ *     只校验"非空字符串",没校长度/字形 ⇒ 同上,先有断言再谈收窄。
+ *   · `idempotency_key` —— 255 **正是**入口断言的上限本身(zod `.max(255)` + 店内 `assertIdempotencyKeyShape`
+ *     双执法),宽度与上限同源,恰好正确,动它反而制造截断面。
  */
 export const TIDB_APPROVAL_ASK_STATEMENTS = [
     `CREATE TABLE IF NOT EXISTS ${APPROVAL_BATCHES_TABLE} (
-    batch_id VARCHAR(255) NOT NULL,
-    task_id VARCHAR(255) NOT NULL,
+    batch_id VARCHAR(64) NOT NULL,
+    task_id VARCHAR(64) NOT NULL,
     state VARCHAR(32) NOT NULL,
-    bound_ask_id VARCHAR(255) NULL,
+    bound_ask_id VARCHAR(64) NULL,
     version INT NOT NULL DEFAULT 0,
     created_at_ms BIGINT NOT NULL,
     updated_at_ms BIGINT NOT NULL,
@@ -85,12 +118,12 @@ export const TIDB_APPROVAL_ASK_STATEMENTS = [
     KEY idx_batch_task (task_id)
   ) COLLATE utf8mb4_bin`,
     `CREATE TABLE IF NOT EXISTS ${APPROVAL_ASKS_TABLE} (
-    ask_id VARCHAR(255) NOT NULL,
-    task_id VARCHAR(255) NOT NULL,
+    ask_id VARCHAR(64) NOT NULL,
+    task_id VARCHAR(64) NOT NULL,
     source_task_id VARCHAR(255) NOT NULL,
-    session_id VARCHAR(255) NOT NULL,
-    owner VARCHAR(255) NULL,
-    batch_id VARCHAR(255) NOT NULL,
+    session_id VARCHAR(64) NOT NULL,
+    owner VARCHAR(190) NULL,
+    batch_id VARCHAR(64) NOT NULL,
     tool_call_id VARCHAR(255) NOT NULL,
     -- leg_key: 车3 §3.2′ 身份轴——sha256(resume checkpoint token) 的 hex(64 字符),首腿存空串。
     -- 取代原来的数值 leg 列:一腿一凭据,零 DDL 依赖 task_run、零 markResuming 改动。NOT NULL(空串
@@ -110,7 +143,7 @@ export const TIDB_APPROVAL_ASK_STATEMENTS = [
     decision_note TEXT NULL,
     decided_at_ms BIGINT NULL,
     denied_reason VARCHAR(64) NULL,
-    gate_token VARCHAR(512) NULL,
+    gate_token VARCHAR(120) NULL,
     gate_bound_call_id VARCHAR(255) NULL,
     gate_bound_input_hash VARCHAR(255) NULL,
     idempotency_key VARCHAR(255) NULL,
@@ -141,10 +174,10 @@ export async function ensureTiDBApprovalAskSchema(pool) {
 }
 export async function ensurePgApprovalAskSchema(q) {
     await q(`CREATE TABLE IF NOT EXISTS ${APPROVAL_BATCHES_TABLE} (
-    batch_id VARCHAR(255) NOT NULL,
-    task_id VARCHAR(255) NOT NULL,
-    state VARCHAR(32) NOT NULL,
-    bound_ask_id VARCHAR(255),
+    batch_id VARCHAR(64) COLLATE "C" NOT NULL,
+    task_id VARCHAR(64) COLLATE "C" NOT NULL,
+    state VARCHAR(32) COLLATE "C" NOT NULL,
+    bound_ask_id VARCHAR(64) COLLATE "C",
     version INT NOT NULL DEFAULT 0,
     created_at_ms BIGINT NOT NULL,
     updated_at_ms BIGINT NOT NULL,
@@ -152,33 +185,33 @@ export async function ensurePgApprovalAskSchema(q) {
   )`);
     await q(`CREATE INDEX IF NOT EXISTS idx_batch_task ON ${APPROVAL_BATCHES_TABLE} (task_id)`);
     await q(`CREATE TABLE IF NOT EXISTS ${APPROVAL_ASKS_TABLE} (
-    ask_id VARCHAR(255) NOT NULL,
-    task_id VARCHAR(255) NOT NULL,
-    source_task_id VARCHAR(255) NOT NULL,
-    session_id VARCHAR(255) NOT NULL,
-    owner VARCHAR(255),
-    batch_id VARCHAR(255) NOT NULL,
-    tool_call_id VARCHAR(255) NOT NULL,
+    ask_id VARCHAR(64) COLLATE "C" NOT NULL,
+    task_id VARCHAR(64) COLLATE "C" NOT NULL,
+    source_task_id VARCHAR(255) COLLATE "C" NOT NULL,
+    session_id VARCHAR(64) COLLATE "C" NOT NULL,
+    owner VARCHAR(190) COLLATE "C",
+    batch_id VARCHAR(64) COLLATE "C" NOT NULL,
+    tool_call_id VARCHAR(255) COLLATE "C" NOT NULL,
     -- leg_key: 车3 §3.2′ 身份轴——sha256(resume checkpoint token) 的 hex(64 字符),首腿存空串
     -- (空串是首腿的真值,不是缺席,故 NOT NULL)。MySQL 侧 twin 逐字同形。
-    leg_key VARCHAR(64) NOT NULL,
-    parent_tool_call_id VARCHAR(255),
+    leg_key VARCHAR(64) COLLATE "C" NOT NULL,
+    parent_tool_call_id VARCHAR(255) COLLATE "C",
     -- bound_input_hash(车5 §9 C2)——MySQL twin 逐字同形(宽度/语义见那侧注)。
-    bound_input_hash VARCHAR(255),
-    state VARCHAR(32) NOT NULL,
+    bound_input_hash VARCHAR(255) COLLATE "C",
+    state VARCHAR(32) COLLATE "C" NOT NULL,
     -- clay 批 TINYINT(1) 归一先例:PG 侧统一 SMALLINT 0/1(此前本家族用过 BOOLEAN,已裁弃).
     provisional SMALLINT NOT NULL DEFAULT 0,
     version INT NOT NULL DEFAULT 0,
-    decision VARCHAR(16),
-    decision_actor TEXT,
-    decision_note TEXT,
+    decision VARCHAR(16) COLLATE "C",
+    decision_actor TEXT COLLATE "C",
+    decision_note TEXT COLLATE "C",
     decided_at_ms BIGINT,
-    denied_reason VARCHAR(64),
-    gate_token VARCHAR(512),
-    gate_bound_call_id VARCHAR(255),
-    gate_bound_input_hash VARCHAR(255),
-    idempotency_key VARCHAR(255),
-    card_json TEXT NOT NULL,
+    denied_reason VARCHAR(64) COLLATE "C",
+    gate_token VARCHAR(120) COLLATE "C",
+    gate_bound_call_id VARCHAR(255) COLLATE "C",
+    gate_bound_input_hash VARCHAR(255) COLLATE "C",
+    idempotency_key VARCHAR(255) COLLATE "C",
+    card_json TEXT COLLATE "C" NOT NULL,
     schema_version INT NOT NULL,
     expires_at_ms BIGINT NOT NULL,
     created_at_ms BIGINT NOT NULL,

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;