@sema-agent/server 7.2.0 → 7.3.0

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

@@ -0,0 +1,705 @@
+import { mysqlDriver, pgDriver, dialectJsonEncoder } from "./sql-driver.js";
+import { canAskTransition } from "../approval-ask-machine.js";
+/**
+ * 幂等键的入店卫生门(属主兜底轮 F2,三 twin 同判——SQL 双方言与 InMemory 都从这里过)。
+ *
+ * 🔴 为什么必须在店门口拒而不是「存什么比什么」:TiDB/MySQL 的 VARCHAR 等值与 UNIQUE 检查带
+ * PAD SPACE 语义(utf8mb4_bin 也一样)——`'retry'` 与 `'retry '` 在那侧是**同一个键**,而 PG 与
+ * InMemory 的严格字符串比较把它们当两个键 ⇒ 同一份调用方代码在不同后端拿到不同的
+ * `idempotency_conflict`/回放结果。键是调用方铸的 opaque 值,首尾空白没有任何合法语义,
+ * 在边界上 fail-loud 拒掉,方言分歧面整个消失(比把列改 VARBINARY 更窄、且对三形同时成立)。
+ */
+export function assertIdempotencyKeyShape(key) {
+    if (key.length === 0 || key.length > 255 || key.trim() !== key) {
+        throw new Error(`invalid idempotency key: must be 1-255 chars with no leading/trailing whitespace (got ${JSON.stringify(key.slice(0, 32))}${key.length > 32 ? "…" : ""}, length ${key.length})`);
+    }
+}
+/**
+ * #151 车3 刀 3b(§14.2 遗留记账):两条**重放读口**被调用方的 deadline 掐断时抛的具名错误。
+ *
+ * 具名类而不是「按 message 文本判别」:错误文案是给人看的,拿它当控制流 = 上游改一句人话下游静默失效
+ * (#90 工程规范 v3 门②)。调用方(开流 preamble)对它的处置与其余读错误一样 —— fail-open、零卡、一次
+ * warn —— 所以它今天没有专门的分支;类在这里是为了让**将来**想分「超时 vs 店真报错」的消费点有得分。
+ */
+export class ApprovalAskReadAbortedError extends Error {
+    constructor(where) {
+        super(`approval-ask read ${where} aborted by caller`);
+        this.name = "ApprovalAskReadAbortedError";
+    }
+}
+function abortedReadError(where) {
+    return new ApprovalAskReadAbortedError(where);
+}
+/**
+ * 把一次在飞的读与调用方的 `AbortSignal` 竞速(#151 车3 刀 3b)。
+ *
+ * 🔴 **它做到什么、做不到什么**(诚实边界,同 {@link ApprovalAskStore.listPendingBySession} 的注):
+ * 本仓的 `SqlDriver` 没有取消 seam,所以这里能做的是「让**调用方**不再被吊住」,不是「让**库**停下来」。
+ * 输掉竞速的那条 promise 仍在飞——它的 rejection 必须被接住(否则变成 unhandled rejection),它的成功
+ * 结果被丢弃(纯读,零副作用)。监听器用完即摘(`once` + finally 清理),不给长命 signal 攒 listener。
+ */
+async function withReadSignal(op, signal, where) {
+    if (!signal)
+        return op;
+    let onAbort;
+    const aborted = new Promise((_resolve, reject) => {
+        onAbort = () => reject(abortedReadError(where));
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+    aborted.catch(() => undefined); // 竞速赢家是 op 时,这条 promise 无人 await —— 先给它一个处理者
+    void op.catch(() => undefined); // 同理:竞速输了的 op 的 rejection 也必须有处理者
+    try {
+        return await Promise.race([op, aborted]);
+    }
+    finally {
+        if (onAbort)
+            signal.removeEventListener("abort", onAbort);
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────────────────────────
+// DDL
+// ─────────────────────────────────────────────────────────────────────────────────────────────────
+export const APPROVAL_ASKS_TABLE = "approval_asks";
+export const APPROVAL_BATCHES_TABLE = "approval_batches";
+/**
+ * TiDB/MySQL-protocol 侧的两条建表语句,**抽成导出数组**(车3 刀 3a):`tidb-pool.ts` 的
+ * `SCHEMA_STATEMENTS` 用 `...TIDB_APPROVAL_ASK_STATEMENTS` 展开它们,于是这两张表随中央
+ * `ensureSchema` 一起在 **named-lock 的那条 `conn`** 上建 —— 把一个 pool 级 ensure 函数塞进
+ * `SCHEMA_STATEMENTS` 的执行循环里做不到这点(会绕开 DDL 串行化),所以真源必须是**语句文本**。
+ * 下面的 `ensureTiDBApprovalAskSchema` 保留为遍历这个数组的薄壳(集成测试直接调它建表,
+ * 不必为了建两张表去拉起整套中央 schema)。
+ *
+ * SCHEMA POLICY 同 `tidb-pool.ts` 头注:纯 CREATE,禁 ALTER 增量 seam,改列直接改这里 + 重建库
+ * (`docs/schema/baseline-mysql.sql` 是由这些文本机器录制出的**产物**,永不手改)。
+ */
+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,
+    state VARCHAR(32) NOT NULL,
+    bound_ask_id VARCHAR(255) NULL,
+    version INT NOT NULL DEFAULT 0,
+    created_at_ms BIGINT NOT NULL,
+    updated_at_ms BIGINT NOT NULL,
+    PRIMARY KEY (batch_id),
+    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,
+    source_task_id VARCHAR(255) NOT NULL,
+    session_id VARCHAR(255) NOT NULL,
+    owner VARCHAR(255) NULL,
+    batch_id VARCHAR(255) 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(空串
+    -- 是首腿的**真值**,不是缺席)。
+    leg_key VARCHAR(64) NOT NULL,
+    parent_tool_call_id VARCHAR(255) NULL,
+    -- bound_input_hash(车5 §9 C2):铸卡时呈给人看的那份 input 的服务端摘要,对账判据 1 的第二道等式。
+    -- 宽度跟同表的 gate_bound_input_hash 对齐(255,≥ checkpoint.bound_input_hash 的 190 ⇒ 抄回来不会截断)。
+    -- 与 gate_bound_input_hash 的区别见 AskRow.boundInputHash 头注(铸行时 vs PARK 成功时,别混)。
+    bound_input_hash VARCHAR(255) NULL,
+    state VARCHAR(32) NOT NULL,
+    -- clay 批 2026-07-26 TINYINT(1) 归一先例(image-bake-store-sql.ts 头注):布尔列 TiDB 侧 TINYINT(1).
+    provisional TINYINT(1) NOT NULL DEFAULT 0,
+    version INT NOT NULL DEFAULT 0,
+    decision VARCHAR(16) NULL,
+    decision_actor TEXT NULL,
+    decision_note TEXT NULL,
+    decided_at_ms BIGINT NULL,
+    denied_reason VARCHAR(64) NULL,
+    gate_token VARCHAR(512) NULL,
+    gate_bound_call_id VARCHAR(255) NULL,
+    gate_bound_input_hash VARCHAR(255) NULL,
+    idempotency_key VARCHAR(255) NULL,
+    -- LONGTEXT 照 image-bake/background-agent 的 pending_steer 先例:重放帧载荷可能超 64K TEXT 墙。
+    card_json LONGTEXT NOT NULL,
+    schema_version INT NOT NULL,
+    expires_at_ms BIGINT NOT NULL,
+    created_at_ms BIGINT NOT NULL,
+    updated_at_ms BIGINT NOT NULL,
+    PRIMARY KEY (ask_id),
+    -- uq_approval_ask_idem(车4 §12-E,由 (idempotency_key) 改 (task_id, idempotency_key)):键归回决专用,
+    -- 作用域收到 task 内。全局唯一有两个真问题——① 跨租户键互撞(两个 task 的调用方各自生成 "retry-1" 就
+    -- 有一方被拒);② 存在性外泄(拿别人的 key 撞库能探到「它在别处存在」)。表未进生产 ⇒ 此刻改零迁移。
+    UNIQUE KEY uq_approval_ask_idem (task_id, idempotency_key),
+    KEY idx_ask_task_state (task_id, state),
+    -- idx_ask_session_state: 车3 §5.1 的 sync 腿开流重放读口(listPendingBySession)的支撑索引。
+    -- 表尚未进生产 + SCHEMA POLICY 是删库重建 ⇒ 此刻加索引零迁移成本,晚一车加就要动生产表。
+    KEY idx_ask_session_state (session_id, state),
+    KEY idx_ask_batch (batch_id),
+    KEY idx_ask_state (state)
+  ) COLLATE utf8mb4_bin`,
+];
+/** {@link TIDB_APPROVAL_ASK_STATEMENTS} 的遍历壳——生产路径走 `tidb-pool.ts` 的中央 `ensureSchema`
+ *  (那里展开了同一份数组),本函数留给只需要这两张表的集成测试。 */
+export async function ensureTiDBApprovalAskSchema(pool) {
+    for (const stmt of TIDB_APPROVAL_ASK_STATEMENTS)
+        await pool.query(stmt);
+}
+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),
+    version INT NOT NULL DEFAULT 0,
+    created_at_ms BIGINT NOT NULL,
+    updated_at_ms BIGINT NOT NULL,
+    PRIMARY KEY (batch_id)
+  )`);
+    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,
+    -- 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),
+    -- bound_input_hash(车5 §9 C2)——MySQL twin 逐字同形(宽度/语义见那侧注)。
+    bound_input_hash VARCHAR(255),
+    state VARCHAR(32) 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,
+    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,
+    schema_version INT NOT NULL,
+    expires_at_ms BIGINT NOT NULL,
+    created_at_ms BIGINT NOT NULL,
+    updated_at_ms BIGINT NOT NULL,
+    PRIMARY KEY (ask_id),
+    -- (task_id, idempotency_key) 复合唯一——MySQL twin 逐字同形(改动理由见那侧注)。
+    CONSTRAINT uq_approval_ask_idem UNIQUE (task_id, idempotency_key)
+  )`);
+    await q(`CREATE INDEX IF NOT EXISTS idx_ask_task_state ON ${APPROVAL_ASKS_TABLE} (task_id, state)`);
+    // 车3 §5.1:sync 腿开流重放读口(listPendingBySession)的支撑索引 —— MySQL twin 的
+    // `KEY idx_ask_session_state (session_id, state)` 同形。
+    await q(`CREATE INDEX IF NOT EXISTS idx_ask_session_state ON ${APPROVAL_ASKS_TABLE} (session_id, state)`);
+    await q(`CREATE INDEX IF NOT EXISTS idx_ask_batch ON ${APPROVAL_ASKS_TABLE} (batch_id)`);
+    await q(`CREATE INDEX IF NOT EXISTS idx_ask_state ON ${APPROVAL_ASKS_TABLE} (state)`);
+}
+const ASK_COLS = "ask_id, task_id, source_task_id, session_id, owner, batch_id, tool_call_id, leg_key, parent_tool_call_id, bound_input_hash, state, " +
+    "provisional, version, decision, decision_actor, decision_note, decided_at_ms, denied_reason, gate_token, " +
+    "gate_bound_call_id, gate_bound_input_hash, idempotency_key, card_json, schema_version, expires_at_ms, " +
+    "created_at_ms, updated_at_ms";
+const BATCH_COLS = "batch_id, task_id, state, bound_ask_id, version, created_at_ms, updated_at_ms";
+/** 唯一键冲突的方言判别(checkpoint-store-sql.ts 同一对常量)——`decideAsk` 用它把 `(task_id,
+ *  idempotency_key)` 撞键翻成 typed 的 `idempotency_conflict` 臂,不让驱动错误对象漏给消费层。 */
+const DUP_ENTRY = 1062; // MySQL/TiDB ER_DUP_ENTRY
+const PG_UNIQUE_VIOLATION = "23505";
+/** JSON 列的读出:**本层只做存取,不解释**——返回类型即 `unknown`,把「这是什么形」的责任留给消费方。
+ *  两个 JSON 列的 schema 属主都不在本车:`decision_actor` = design/171 ActorAssertion 形(车4 回决端点
+ *  消费,届时按宪法 [2704] 立 schema 后 safeParse);`card_json` = 172 §3.1 呈卡帧载荷(车3 wire 面属主)。
+ *  故此处刻意不铸内域类型(无 as),持久层对这两列保持透明字节存取语义。 */
+function parseJsonColumn(v) {
+    return JSON.parse(String(v));
+}
+function toBool(v) {
+    return Boolean(Number(v));
+}
+function numOrNull(v) {
+    return v === null || v === undefined ? null : Number(v);
+}
+function strOrNull(v) {
+    return v === null || v === undefined ? null : String(v);
+}
+function mapAskRow(r) {
+    return {
+        askId: String(r.ask_id),
+        taskId: String(r.task_id),
+        sourceTaskId: String(r.source_task_id),
+        sessionId: String(r.session_id),
+        owner: strOrNull(r.owner),
+        batchId: String(r.batch_id),
+        toolCallId: String(r.tool_call_id),
+        legKey: String(r.leg_key),
+        parentToolCallId: strOrNull(r.parent_tool_call_id),
+        boundInputHash: strOrNull(r.bound_input_hash),
+        state: String(r.state),
+        provisional: toBool(r.provisional),
+        version: Number(r.version),
+        decision: strOrNull(r.decision) ?? null,
+        decisionActor: r.decision_actor == null ? null : parseJsonColumn(r.decision_actor),
+        decisionNote: strOrNull(r.decision_note),
+        decidedAtMs: numOrNull(r.decided_at_ms),
+        deniedReason: strOrNull(r.denied_reason),
+        gateToken: strOrNull(r.gate_token),
+        gateBoundCallId: strOrNull(r.gate_bound_call_id),
+        gateBoundInputHash: strOrNull(r.gate_bound_input_hash),
+        idempotencyKey: strOrNull(r.idempotency_key),
+        cardJson: parseJsonColumn(r.card_json),
+        schemaVersion: Number(r.schema_version),
+        expiresAtMs: Number(r.expires_at_ms),
+        createdAtMs: Number(r.created_at_ms),
+        updatedAtMs: Number(r.updated_at_ms),
+    };
+}
+function mapBatchRow(r) {
+    return {
+        batchId: String(r.batch_id),
+        taskId: String(r.task_id),
+        state: String(r.state),
+        boundAskId: strOrNull(r.bound_ask_id),
+        version: Number(r.version),
+        createdAtMs: Number(r.created_at_ms),
+        updatedAtMs: Number(r.updated_at_ms),
+    };
+}
+/** 动态 SET 列清单(`transitionAsk`/`resolveProvisional` 用):只收 patch 里真出现的字段,`decisionActor`
+ *  按内容面 JSON 编码器序列化。`updatedAtMs` 不在这里——调用方把它拼进固定尾列(所有转移恒推进它）。 */
+function patchColumns(patch, json) {
+    const out = [];
+    if (patch.decision !== undefined)
+        out.push(["decision", patch.decision]);
+    if (patch.decisionActor !== undefined)
+        out.push(["decision_actor", patch.decisionActor == null ? null : json(patch.decisionActor)]);
+    if (patch.decisionNote !== undefined)
+        out.push(["decision_note", patch.decisionNote]);
+    if (patch.decidedAtMs !== undefined)
+        out.push(["decided_at_ms", patch.decidedAtMs]);
+    if (patch.deniedReason !== undefined)
+        out.push(["denied_reason", patch.deniedReason]);
+    if (patch.gateToken !== undefined)
+        out.push(["gate_token", patch.gateToken]);
+    if (patch.gateBoundCallId !== undefined)
+        out.push(["gate_bound_call_id", patch.gateBoundCallId]);
+    if (patch.gateBoundInputHash !== undefined)
+        out.push(["gate_bound_input_hash", patch.gateBoundInputHash]);
+    if (patch.provisional !== undefined)
+        out.push(["provisional", patch.provisional ? 1 : 0]);
+    return out;
+}
+/** 第 n 个(1-based)绑定参数的占位符文本。TiDB 用位置序 `?`(n 被忽略);PG 需要显式编号 `$n`——
+ *  两种转移(transitionAsk/resolveProvisional)的列集合按 patch 内容动态变化,固定的两段式 SQL 文本
+ *  写不出来,因此占位符本身也必须按方言现场生成(与 background-agent-store-sql.ts 的 guard 占位符
+ *  构造同精神:方言差异仍然显式——分支在这一个函数里,不是被某个跨方言的抽象吞掉）。 */
+function ph(dialect, n) {
+    return dialect === "tidb" ? "?" : `$${n}`;
+}
+/** 双方言 `ApprovalAskStore`。见文件头注的 CAS 铁则 + 方言差异清单。 */
+export class SqlApprovalAskStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    q(tidb, pg) {
+        return this.db.dialect === "tidb" ? tidb : pg;
+    }
+    json(value) {
+        return dialectJsonEncoder(this.db.dialect)(value);
+    }
+    /** 唯一键冲突判别(方言差异显式,checkpoint-store-sql.ts 同形):mysql2 挂 `errno`,node-pg 挂 SQLSTATE `code`。 */
+    isDupKey(e) {
+        return this.db.dialect === "tidb" ? e?.errno === DUP_ENTRY : e?.code === PG_UNIQUE_VIOLATION;
+    }
+    /**
+     * 🔴 失败臂的回读**必须走当前这条 `conn`**,不许调 `this.getAsk`/`this.getBatch`(codex 复审 F1,
+     * 2026-08-06 真缺陷,池大小=1 的钉上实测挂死 25s)。原因:那两个读口走**池级** `this.db.query`,而
+     * 此刻本方法还攥着自己的事务连接(要到 `finally` 才 release)——于是「回读在等一条新连接,而唯一
+     * 那条连接要等回读返回才释放」= 确定性死锁。池大于 1 时它退化成「同时走到失败臂的并发数 ≥ 池大小
+     * 就整池饿死」,是同一个缺陷的更难复现形,不是另一个问题。
+     *
+     * 调用点纪律:**先 `conn.rollback()` 再调这两个**。回滚之后连接回到 autocommit,这条 SELECT 自成
+     * 一个事务 ⇒ 读到的是最新已提交视图(正是失败臂要如实上报的东西),不受本事务快照的影响——两方言
+     * 在这一点上同义,不必再纠结 InnoDB 读视图与 TiDB start_ts 的差别。
+     */
+    async getAskOn(conn, askId) {
+        const { rows } = await conn.query(this.q(`SELECT ${ASK_COLS} FROM ${APPROVAL_ASKS_TABLE} WHERE ask_id = ?`, `SELECT ${ASK_COLS} FROM ${APPROVAL_ASKS_TABLE} WHERE ask_id = $1`), [askId]);
+        return rows[0] ? mapAskRow(rows[0]) : null;
+    }
+    /** {@link getAskOn} 的批侧同形(同一条纪律:失败臂回读走本连接)。 */
+    async getBatchOn(conn, batchId) {
+        const { rows } = await conn.query(this.q(`SELECT ${BATCH_COLS} FROM ${APPROVAL_BATCHES_TABLE} WHERE batch_id = ?`, `SELECT ${BATCH_COLS} FROM ${APPROVAL_BATCHES_TABLE} WHERE batch_id = $1`), [batchId]);
+        return rows[0] ? mapBatchRow(rows[0]) : null;
+    }
+    async ensureAsk(row) {
+        const now = row.createdAtMs;
+        const conn = await this.db.connect();
+        try {
+            await conn.begin();
+            await conn.query(this.q(`INSERT IGNORE INTO ${APPROVAL_BATCHES_TABLE} (batch_id, task_id, state, version, created_at_ms, updated_at_ms) VALUES (?, ?, 'OPEN', 0, ?, ?)`, `INSERT INTO ${APPROVAL_BATCHES_TABLE} (batch_id, task_id, state, version, created_at_ms, updated_at_ms) VALUES ($1, $2, 'OPEN', 0, $3, $4) ON CONFLICT (batch_id) DO NOTHING`), [row.batchId, row.taskId, now, now]);
+            // 🔴 `idempotency_key` **不在 INSERT 列清单里**(车4 §12-E 双写者收口):该列已归回决专用,只有
+            // `decideAsk` 赢 CAS 时写它,铸行恒 NULL。留在这里的 NULL 字面量就是这条纪律的落笔处。
+            await conn.query(this.q(`INSERT IGNORE INTO ${APPROVAL_ASKS_TABLE} (ask_id, task_id, source_task_id, session_id, owner, batch_id, tool_call_id, leg_key, parent_tool_call_id, bound_input_hash, state, provisional, version, decision, decision_actor, decision_note, decided_at_ms, denied_reason, gate_token, gate_bound_call_id, gate_bound_input_hash, idempotency_key, card_json, schema_version, expires_at_ms, created_at_ms, updated_at_ms) ` +
+                "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'STREAM_PENDING', 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, ?, ?, ?, ?, ?)", `INSERT INTO ${APPROVAL_ASKS_TABLE} (ask_id, task_id, source_task_id, session_id, owner, batch_id, tool_call_id, leg_key, parent_tool_call_id, bound_input_hash, state, provisional, version, decision, decision_actor, decision_note, decided_at_ms, denied_reason, gate_token, gate_bound_call_id, gate_bound_input_hash, idempotency_key, card_json, schema_version, expires_at_ms, created_at_ms, updated_at_ms) ` +
+                "VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, 'STREAM_PENDING', 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, $11, $12, $13, $14, $15) ON CONFLICT (ask_id) DO NOTHING"), [
+                row.askId,
+                row.taskId,
+                row.sourceTaskId,
+                row.sessionId,
+                row.owner ?? null,
+                row.batchId,
+                row.toolCallId,
+                row.legKey,
+                row.parentToolCallId ?? null,
+                row.boundInputHash ?? null,
+                this.json(row.cardJson),
+                row.schemaVersion,
+                row.expiresAtMs,
+                now,
+                now,
+            ]);
+            await conn.commit();
+        }
+        catch (err) {
+            try {
+                await conn.rollback();
+            }
+            catch {
+                /* ignore */
+            }
+            throw err;
+        }
+        finally {
+            conn.release();
+        }
+        const out = await this.getAsk(row.askId);
+        if (!out)
+            throw new Error(`ensureAsk: row vanished after insert (askId=${row.askId})`);
+        return out;
+    }
+    async transitionAsk(askId, from, to, patch) {
+        // machine 层先判(非法转移=编程错误,throw 而非返回 false——设计定稿 §4 原话)。
+        if (!canAskTransition(from, to)) {
+            throw new Error(`approval-ask-store.transitionAsk: illegal ask transition ${from} -> ${to} (askId=${askId})`);
+        }
+        const dialect = this.db.dialect;
+        const dyn = patchColumns(patch, (v) => this.json(v));
+        const cols = ["state", ...dyn.map(([c]) => c), "updated_at_ms"];
+        const vals = [to, ...dyn.map(([, v]) => v), patch.updatedAtMs];
+        let n = 0;
+        const setSql = cols.map((c) => `${c} = ${ph(dialect, ++n)}`).join(", ");
+        const askIdPh = ph(dialect, ++n);
+        const fromPh = ph(dialect, ++n);
+        // `version = version + 1`(恒变列,MySQL 同值 UPDATE affectedRows=0 坑——见文件头注 CAS 铁则②)。
+        const res = await this.db.query(`UPDATE ${APPROVAL_ASKS_TABLE} SET ${setSql}, version = version + 1 WHERE ask_id = ${askIdPh} AND state = ${fromPh}`, [...vals, askId, from]);
+        return res.affected === 1;
+    }
+    async decideAsk(askId, batchId, decision) {
+        if (decision.idempotencyKey != null)
+            assertIdempotencyKeyShape(decision.idempotencyKey); // F2 卫生门:进事务前拒
+        const now = Date.now();
+        const conn = await this.db.connect();
+        try {
+            await conn.begin();
+            // ① 批必须还 OPEN(自增写 version 保证 affected 语义在 CLIENT_FOUND_ROWS 关闭下仍=1;=0 ⇒ 批已封)。
+            const batchRes = await conn.query(this.q(`UPDATE ${APPROVAL_BATCHES_TABLE} SET version = version + 1, updated_at_ms = ? WHERE batch_id = ? AND state = 'OPEN'`, `UPDATE ${APPROVAL_BATCHES_TABLE} SET version = version + 1, updated_at_ms = $1 WHERE batch_id = $2 AND state = 'OPEN'`), [now, batchId]);
+            if (batchRes.affected !== 1) {
+                await conn.rollback();
+                return { ok: false, reason: "batch_closed", row: await this.getAskOn(conn, askId) };
+            }
+            // ② ask 必须还 STREAM_PENDING;单赢者 CAS。回决幂等键随决议**同一条语句**落列(车4 §12-E):
+            //    分两步写会开一个「已 DECIDED 但键还没落」的窗口,同 key 重试在窗口内读不到键 ⇒ 会去打第二次
+            //    CAS(输)再报 409,把一次合法回放变成冲突。同一 UPDATE ⇒ 键与终态同生共死。
+            let askRes; // 显式标注:`let x;` 是 evolving-any,本仓按强类型用
+            try {
+                askRes = await conn.query(this.q(`UPDATE ${APPROVAL_ASKS_TABLE} SET state='DECIDED', decision=?, decision_actor=?, decision_note=?, decided_at_ms=?, idempotency_key=?, version=version+1, updated_at_ms=? WHERE ask_id=? AND state='STREAM_PENDING'`, `UPDATE ${APPROVAL_ASKS_TABLE} SET state='DECIDED', decision=$1, decision_actor=$2, decision_note=$3, decided_at_ms=$4, idempotency_key=$5, version=version+1, updated_at_ms=$6 WHERE ask_id=$7 AND state='STREAM_PENDING'`), [decision.decision, decision.decisionActor == null ? null : this.json(decision.decisionActor), decision.decisionNote ?? null, now, decision.idempotencyKey ?? null, now, askId]);
+            }
+            catch (err) {
+                // `(task_id, idempotency_key)` 撞键 = 同一 key 已被本 task 内**另一条** ask 的回决占用。这是调用方
+                // 键管理的问题(不是 CAS 竞争),翻成 typed 臂交给端点译 409——方言 errno/SQLSTATE 不出店。
+                if (this.isDupKey(err)) {
+                    await conn.rollback();
+                    return { ok: false, reason: "idempotency_conflict", row: await this.getAskOn(conn, askId) };
+                }
+                throw err;
+            }
+            if (askRes.affected !== 1) {
+                await conn.rollback();
+                return { ok: false, reason: "ask_not_pending", row: await this.getAskOn(conn, askId) };
+            }
+            await conn.commit();
+        }
+        catch (err) {
+            try {
+                await conn.rollback();
+            }
+            catch {
+                /* ignore */
+            }
+            throw err;
+        }
+        finally {
+            conn.release();
+        }
+        const row = await this.getAsk(askId);
+        if (!row)
+            throw new Error(`decideAsk: row vanished after commit (askId=${askId})`);
+        return { ok: true, row };
+    }
+    async expireAsk(askId, batchId) {
+        const now = Date.now();
+        const conn = await this.db.connect();
+        try {
+            await conn.begin();
+            // ⓪ 锁序不变量(真双库 §6-4b 死锁实抓,2026-08-05):凡同一事务触碰批行+ask 行者,**一律批行先**
+            //    (decideAsk/bindBatch/abortBatch 皆批先;expireAsk 原是 ask 先 ⇒ 与 decideAsk 构成 AB-BA,
+            //    TiDB 悲观锁当场 `Deadlock found`)。这里用无谓词的 version 自增先取批行锁作序列化点——
+            //    带 state 谓词的转移放后面(谓词不符时部分引擎不留锁,序列化点会失效)。ask CAS 输时整个
+            //    事务回滚,这次自增一并撤销,无痕。
+            const lockRes = await conn.query(this.q(`UPDATE ${APPROVAL_BATCHES_TABLE} SET version=version+1 WHERE batch_id=?`, `UPDATE ${APPROVAL_BATCHES_TABLE} SET version=version+1 WHERE batch_id=$1`), [batchId]);
+            if (lockRes.affected !== 1) {
+                await conn.rollback(); // 批行不存在 = ensureAsk 从未为它建批(编程错误形,如实不赢)
+                return { won: false, voidedSiblings: [] };
+            }
+            // ① 中选:ask STREAM_PENDING → PARKING(单赢者;输 = 已被回决/取消,整体放弃)。
+            const askRes = await conn.query(this.q(`UPDATE ${APPROVAL_ASKS_TABLE} SET state='PARKING', version=version+1, updated_at_ms=? WHERE ask_id=? AND state='STREAM_PENDING'`, `UPDATE ${APPROVAL_ASKS_TABLE} SET state='PARKING', version=version+1, updated_at_ms=$1 WHERE ask_id=$2 AND state='STREAM_PENDING'`), [now, askId]);
+            if (askRes.affected !== 1) {
+                await conn.rollback();
+                return { won: false, voidedSiblings: [] };
+            }
+            // ② 批 OPEN → ROUTING_UNBOUND(已是 ROUTING_UNBOUND = 兄弟先到,affected=0 也算成功续走③——不检查
+            //    affected,批状态无论如何这一刻都已经是 ROUTING_UNBOUND 或更前进)。
+            await conn.query(this.q(`UPDATE ${APPROVAL_BATCHES_TABLE} SET state='ROUTING_UNBOUND', version=version+1, updated_at_ms=? WHERE batch_id=? AND state='OPEN'`, `UPDATE ${APPROVAL_BATCHES_TABLE} SET state='ROUTING_UNBOUND', version=version+1, updated_at_ms=$1 WHERE batch_id=$2 AND state='OPEN'`), [now, batchId]);
+            // ③ 兄弟撤卡:PG 用 RETURNING 单语句拿名单;TiDB 无 RETURNING,同事务先 SELECT 后 UPDATE。
+            let voidedSiblings;
+            if (this.db.dialect === "pg") {
+                const res = await conn.query(`UPDATE ${APPROVAL_ASKS_TABLE} SET state='VOID', version=version+1, updated_at_ms=$1 WHERE batch_id=$2 AND state='STREAM_PENDING' AND ask_id<>$3 RETURNING ask_id`, [now, batchId, askId]);
+                voidedSiblings = res.rows.map((r) => String(r.ask_id));
+            }
+            else {
+                // 🔴 `FOR UPDATE` + 按选出的 id 列表更新(车5 同病修,与 `bindBatch` 的 PARKING 臂逐字同形——
+                // 那里的完整论证见该处注):裸 SELECT 是**非锁定读**,它与随后那条宽谓词 UPDATE 不是同一个行集
+                // (`transitionAsk`/`decideAsk` 不走批锁,可以在两条语句之间把某个兄弟搬进/搬出 STREAM_PENDING)。
+                // 搬进的会被 UPDATE 改成 VOID 却**不在**返回名单里(撤卡帧漏发 ⇒ 壳上留一张已作废的卡),搬出的
+                // 会在名单里却没被改(撤卡帧误发)。PG 的 RETURNING 与 InMemory 都返回「真正被改的那一组」,
+                // 所以裸读会造出一个**只在 MySQL 方言上**成立的协议分歧。锁序:本方法已先取批行锁(步⓪),
+                // 此处再取 ask 行锁,与文件头注的「批先 ask 后」一致。
+                const sel = await conn.query(`SELECT ask_id FROM ${APPROVAL_ASKS_TABLE} WHERE batch_id=? AND state='STREAM_PENDING' AND ask_id<>? FOR UPDATE`, [batchId, askId]);
+                voidedSiblings = sel.rows.map((r) => String(r.ask_id));
+                if (voidedSiblings.length > 0) {
+                    const inList = voidedSiblings.map(() => "?").join(", ");
+                    await conn.query(`UPDATE ${APPROVAL_ASKS_TABLE} SET state='VOID', version=version+1, updated_at_ms=? WHERE ask_id IN (${inList}) AND state='STREAM_PENDING'`, [
+                        now,
+                        ...voidedSiblings,
+                    ]);
+                }
+            }
+            await conn.commit();
+            return { won: true, voidedSiblings };
+        }
+        catch (err) {
+            try {
+                await conn.rollback();
+            }
+            catch {
+                /* ignore */
+            }
+            throw err;
+        }
+        finally {
+            conn.release();
+        }
+    }
+    async bindBatch(batchId, askId, gate) {
+        const now = Date.now();
+        const conn = await this.db.connect();
+        try {
+            await conn.begin();
+            // bind-once:批 ROUTING_UNBOUND → ROUTING_BOUND + bound_ask_id(WHERE bound_ask_id IS NULL 是第二道
+            // 保险——state 谓词已经把并发者挡在外面,这里双保险防「同一批被 bind 两次」哪怕未来状态机被误改）。
+            const batchRes = await conn.query(this.q(`UPDATE ${APPROVAL_BATCHES_TABLE} SET state='ROUTING_BOUND', bound_ask_id=?, version=version+1, updated_at_ms=? WHERE batch_id=? AND state='ROUTING_UNBOUND' AND bound_ask_id IS NULL`, `UPDATE ${APPROVAL_BATCHES_TABLE} SET state='ROUTING_BOUND', bound_ask_id=$1, version=version+1, updated_at_ms=$2 WHERE batch_id=$3 AND state='ROUTING_UNBOUND' AND bound_ask_id IS NULL`), [askId, now, batchId]);
+            if (batchRes.affected !== 1) {
+                // 判别式的信息来源 = 批行的真实态。🔴 回读**放在 rollback 之后、走池上的独立读**,不在本事务内读:
+                // TiDB 的事务快照按 start_ts 取,同事务内的普通 SELECT 可能读到 BEGIN 时刻的旧值(InnoDB 的读视图
+                // 规则又与它不同)——两方言在这一点上不等价,而本车恰恰要靠这个值分 ABORTED / ROUTING_BOUND 两条
+                // **处置相反**的臂。事务已回滚(本事务除了那条 affected=0 的 CAS 什么也没写),池上重读是干净的
+                // 已提交视图,双方言同义。
+                await conn.rollback();
+                const cur = await this.getBatchOn(conn, batchId);
+                if (!cur)
+                    return { ok: false, batchState: "MISSING" };
+                return { ok: false, batchState: cur.state, ...(cur.boundAskId !== null ? { boundAskId: cur.boundAskId } : {}) };
+            }
+            // 中选 ask PARKING → PARKED(带 gate 三件)。
+            const askRes = await conn.query(this.q(`UPDATE ${APPROVAL_ASKS_TABLE} SET state='PARKED', gate_token=?, gate_bound_call_id=?, gate_bound_input_hash=?, version=version+1, updated_at_ms=? WHERE ask_id=? AND state='PARKING'`, `UPDATE ${APPROVAL_ASKS_TABLE} SET state='PARKED', gate_token=$1, gate_bound_call_id=$2, gate_bound_input_hash=$3, version=version+1, updated_at_ms=$4 WHERE ask_id=$5 AND state='PARKING'`), [gate.gateToken, gate.gateBoundCallId ?? null, gate.gateBoundInputHash ?? null, now, askId]);
+            if (askRes.affected !== 1) {
+                await conn.rollback();
+                // ask 不在 PARKING(被别的竞争者收走)⇒ 整事务回滚,批**没有**被绑上。如实报批的回滚后真值:
+                // 它仍是 ROUTING_UNBOUND(上一步的 CAS 谓词已经证明了这一点,连同本次自增一起撤销)。
+                return { ok: false, batchState: "ROUTING_UNBOUND" };
+            }
+            // 其余 PARKING 兄弟 → VOID,**名单随成功臂回传**(车5 §8 A-4):撤卡帧的 `askIds` 就是它。
+            // 读法与 expireAsk 逐字同形:PG `RETURNING` 单语句;TiDB 无 RETURNING ⇒ 同事务先 SELECT 后 UPDATE。
+            let voidedSiblings;
+            if (this.db.dialect === "pg") {
+                const res = await conn.query(`UPDATE ${APPROVAL_ASKS_TABLE} SET state='VOID', version=version+1, updated_at_ms=$1 WHERE batch_id=$2 AND state='PARKING' AND ask_id<>$3 RETURNING ask_id`, [now, batchId, askId]);
+                voidedSiblings = res.rows.map((r) => String(r.ask_id));
+            }
+            else {
+                // 🔴 `FOR UPDATE` + 按选出的 id 逐条更新(codex 复审 F2,2026-08-06):裸 SELECT 是非锁定读,
+                // 它与随后那条宽谓词 UPDATE **不是**同一个行集——`transitionAsk` 不走批锁,可以在两条语句之间
+                // 把某个兄弟搬进/搬出 PARKING。搬进的会被 UPDATE 改成 VOID 却**不在**返回名单里(撤卡帧漏发 ⇒
+                // 壳上留一张已作废的卡),搬出的会在名单里却没被改(撤卡帧误发)。PG 的 RETURNING 与 InMemory
+                // 都返回「真正被改的那一组」,所以裸读会造出一个**只在 MySQL 方言上**成立的协议分歧。
+                // 修法:锁定读把行集钉死,再只更新这批 id ⇒ 返回名单恒等于被改集合,三形同义。
+                // 锁序:本方法已先取批行锁(上面那条 CAS),此处再取 ask 行锁,与文件头注的「批先 ask 后」一致。
+                const sel = await conn.query(`SELECT ask_id FROM ${APPROVAL_ASKS_TABLE} WHERE batch_id=? AND state='PARKING' AND ask_id<>? FOR UPDATE`, [batchId, askId]);
+                voidedSiblings = sel.rows.map((r) => String(r.ask_id));
+                if (voidedSiblings.length > 0) {
+                    const inList = voidedSiblings.map(() => "?").join(", ");
+                    await conn.query(`UPDATE ${APPROVAL_ASKS_TABLE} SET state='VOID', version=version+1, updated_at_ms=? WHERE ask_id IN (${inList}) AND state='PARKING'`, [now, ...voidedSiblings]);
+                }
+            }
+            await conn.commit();
+            return { ok: true, voidedSiblings };
+        }
+        catch (err) {
+            try {
+                await conn.rollback();
+            }
+            catch {
+                /* ignore */
+            }
+            throw err;
+        }
+        finally {
+            conn.release();
+        }
+    }
+    async abortBatch(batchId) {
+        const now = Date.now();
+        const conn = await this.db.connect();
+        try {
+            await conn.begin();
+            const batchRes = await conn.query(this.q(`UPDATE ${APPROVAL_BATCHES_TABLE} SET state='ABORTED', version=version+1, updated_at_ms=? WHERE batch_id=? AND (state='OPEN' OR state='ROUTING_UNBOUND')`, `UPDATE ${APPROVAL_BATCHES_TABLE} SET state='ABORTED', version=version+1, updated_at_ms=$1 WHERE batch_id=$2 AND (state='OPEN' OR state='ROUTING_UNBOUND')`), [now, batchId]);
+            if (batchRes.affected !== 1) {
+                await conn.rollback();
+                return [];
+            }
+            // 只撤 STREAM_PENDING(设计定稿字面:「整批 STREAM_PENDING→VOID」)——已 DECIDED 的兄弟不受影响
+            // (§3.0 原话),PARKING/PARKED/DENIED 同样不在这条 UPDATE 的谓词里,保持不动。
+            let voided;
+            if (this.db.dialect === "pg") {
+                const res = await conn.query(`UPDATE ${APPROVAL_ASKS_TABLE} SET state='VOID', version=version+1, updated_at_ms=$1 WHERE batch_id=$2 AND state='STREAM_PENDING' RETURNING ask_id`, [now, batchId]);
+                voided = res.rows.map((r) => String(r.ask_id));
+            }
+            else {
+                // 🔴 同 `expireAsk`/`bindBatch` 的锁定读改造(车5 同病修):非锁定读的名单与宽谓词 UPDATE 的
+                // 行集不是同一个 ⇒ 撤卡帧漏发/误发,且分歧只在 MySQL 方言上成立。锁序:批行锁(上一条 CAS)
+                // 已取,此处再取 ask 行锁。
+                const sel = await conn.query(`SELECT ask_id FROM ${APPROVAL_ASKS_TABLE} WHERE batch_id=? AND state='STREAM_PENDING' FOR UPDATE`, [batchId]);
+                voided = sel.rows.map((r) => String(r.ask_id));
+                if (voided.length > 0) {
+                    const inList = voided.map(() => "?").join(", ");
+                    await conn.query(`UPDATE ${APPROVAL_ASKS_TABLE} SET state='VOID', version=version+1, updated_at_ms=? WHERE ask_id IN (${inList}) AND state='STREAM_PENDING'`, [now, ...voided]);
+                }
+            }
+            await conn.commit();
+            return voided;
+        }
+        catch (err) {
+            try {
+                await conn.rollback();
+            }
+            catch {
+                /* ignore */
+            }
+            throw err;
+        }
+        finally {
+            conn.release();
+        }
+    }
+    /**
+     * 🔴 排序键是 `updated_at_ms`(车5 §8 D-4;codex 三轮补抓:原先按 `created_at_ms` 排,`deferReconcile`
+     * 就是**空转**的)。这条读口与 `deferReconcile` 是一对:收敛器每轮取前 `limit` 条,判不出终局的行用
+     * `deferReconcile` 推 `updated_at_ms` 把自己排到队尾,下一轮新行才轮得到。若这里仍按建行时间排,
+     * 推 `updated_at_ms` 对顺序毫无影响 ⇒ 一旦 `limit` 被若干长驻 PARKING 行占满,每轮扫到的永远是同一批,
+     * 后来的审批被无限饿死(§5 旋钮那句「超出下轮接着扫」也就不成立)。
+     * 次级键 `created_at_ms` 只为**确定性**:同毫秒的行不至于在两次扫描间乱序(分页/限流下的稳定序)。
+     *
+     * 🔴 配套纪律(§9 C5):任何 TTL 判据一律量 immutable 的 `createdAtMs`/`expiresAtMs`,**绝不量
+     * `updatedAtMs`**——它被队列轮转每轮刷新,量它的 TTL 永不到期。
+     */
+    async listByState(state, limit) {
+        const { rows } = await this.db.query(this.q(`SELECT ${ASK_COLS} FROM ${APPROVAL_ASKS_TABLE} WHERE state = ? ORDER BY updated_at_ms ASC, created_at_ms ASC LIMIT ?`, `SELECT ${ASK_COLS} FROM ${APPROVAL_ASKS_TABLE} WHERE state = $1 ORDER BY updated_at_ms ASC, created_at_ms ASC LIMIT $2`), [state, limit]);
+        return rows.map(mapAskRow);
+    }
+    async listPendingByTask(taskId, signal) {
+        if (signal?.aborted === true)
+            throw abortedReadError("listPendingByTask");
+        const { rows } = await withReadSignal(this.db.query(this.q(`SELECT ${ASK_COLS} FROM ${APPROVAL_ASKS_TABLE} WHERE task_id = ? AND state = 'STREAM_PENDING' ORDER BY created_at_ms ASC`, `SELECT ${ASK_COLS} FROM ${APPROVAL_ASKS_TABLE} WHERE task_id = $1 AND state = 'STREAM_PENDING' ORDER BY created_at_ms ASC`), [taskId]), signal, "listPendingByTask");
+        return rows.map(mapAskRow);
+    }
+    async listPendingBySession(sessionId, owner, signal) {
+        if (signal?.aborted === true)
+            throw abortedReadError("listPendingBySession");
+        // 租户门的两段谓词文本(见接口注):`owner = ?` 对 NULL 恒 UNKNOWN ⇒ 无租户身份的部署形必须走
+        // `owner IS NULL`,否则这条读口在那些部署上恒回零行(一条静默失效的重放面,比报错更难发现)。
+        const { rows } = await withReadSignal(this.db.query(owner === null
+            ? this.q(`SELECT ${ASK_COLS} FROM ${APPROVAL_ASKS_TABLE} WHERE session_id = ? AND state = 'STREAM_PENDING' AND owner IS NULL ORDER BY created_at_ms ASC`, `SELECT ${ASK_COLS} FROM ${APPROVAL_ASKS_TABLE} WHERE session_id = $1 AND state = 'STREAM_PENDING' AND owner IS NULL ORDER BY created_at_ms ASC`)
+            : this.q(`SELECT ${ASK_COLS} FROM ${APPROVAL_ASKS_TABLE} WHERE session_id = ? AND state = 'STREAM_PENDING' AND owner = ? ORDER BY created_at_ms ASC`, `SELECT ${ASK_COLS} FROM ${APPROVAL_ASKS_TABLE} WHERE session_id = $1 AND state = 'STREAM_PENDING' AND owner = $2 ORDER BY created_at_ms ASC`), owner === null ? [sessionId] : [sessionId, owner]), signal, "listPendingBySession");
+        return rows.map(mapAskRow);
+    }
+    async getAsk(askId) {
+        const { rows } = await this.db.query(this.q(`SELECT ${ASK_COLS} FROM ${APPROVAL_ASKS_TABLE} WHERE ask_id = ?`, `SELECT ${ASK_COLS} FROM ${APPROVAL_ASKS_TABLE} WHERE ask_id = $1`), [
+            askId,
+        ]);
+        return rows[0] ? mapAskRow(rows[0]) : null;
+    }
+    async getByIdempotencyKey(taskId, key) {
+        assertIdempotencyKeyShape(key); // F2 卫生门:坏形键不做注定方言分歧的查询
+        // 谓词跟 UNIQUE `(task_id, idempotency_key)` 逐字对齐 ⇒ 至多一行,且天然带租户门(见接口注)。
+        const { rows } = await this.db.query(this.q(`SELECT ${ASK_COLS} FROM ${APPROVAL_ASKS_TABLE} WHERE task_id = ? AND idempotency_key = ?`, `SELECT ${ASK_COLS} FROM ${APPROVAL_ASKS_TABLE} WHERE task_id = $1 AND idempotency_key = $2`), [taskId, key]);
+        return rows[0] ? mapAskRow(rows[0]) : null;
+    }
+    async deferReconcile(askId, expectedState, expectedVersion, nowMs) {
+        // 纯 touch:**不碰 state**(见接口注——同态转移在状态机表上无出边,这里刻意走另一扇门),只推
+        // `updated_at_ms` 与恒变的 `version`。`AND state=? AND version=?` 双谓词 = 两副本同扫时的单赢者门。
+        const res = await this.db.query(this.q(`UPDATE ${APPROVAL_ASKS_TABLE} SET updated_at_ms = ?, version = version + 1 WHERE ask_id = ? AND state = ? AND version = ?`, `UPDATE ${APPROVAL_ASKS_TABLE} SET updated_at_ms = $1, version = version + 1 WHERE ask_id = $2 AND state = $3 AND version = $4`), [nowMs, askId, expectedState, expectedVersion]);
+        return res.affected === 1;
+    }
+    async resolveProvisional(askId, from, to, patch) {
+        // 🔴 故意不经 canAskTransition:这是设计定稿 §3.0/§4 明说的「provisional 行的版本化补偿」——终态→终态
+        // 的例外通道,机器表把终态定义为「无出边」,这里走的是另一扇门(WHERE provisional=1 AND state=from）。
+        const dialect = this.db.dialect;
+        const dyn = patchColumns(patch, (v) => this.json(v));
+        const cols = ["state", "provisional", ...dyn.map(([c]) => c), "updated_at_ms"];
+        const vals = [to, 0, ...dyn.map(([, v]) => v), patch.updatedAtMs];
+        let n = 0;
+        const setSql = cols.map((c) => `${c} = ${ph(dialect, ++n)}`).join(", ");
+        const askIdPh = ph(dialect, ++n);
+        const provPh = ph(dialect, ++n);
+        const fromPh = ph(dialect, ++n);
+        const res = await this.db.query(`UPDATE ${APPROVAL_ASKS_TABLE} SET ${setSql}, version = version + 1 WHERE ask_id = ${askIdPh} AND provisional = ${provPh} AND state = ${fromPh}`, [...vals, askId, 1, from]);
+        return res.affected === 1;
+    }
+    async deleteByTask(taskId) {
+        await this.db.query(this.q(`DELETE FROM ${APPROVAL_ASKS_TABLE} WHERE task_id = ?`, `DELETE FROM ${APPROVAL_ASKS_TABLE} WHERE task_id = $1`), [taskId]);
+        await this.db.query(this.q(`DELETE FROM ${APPROVAL_BATCHES_TABLE} WHERE task_id = ?`, `DELETE FROM ${APPROVAL_BATCHES_TABLE} WHERE task_id = $1`), [taskId]);
+    }
+    async getBatch(batchId) {
+        const { rows } = await this.db.query(this.q(`SELECT ${BATCH_COLS} FROM ${APPROVAL_BATCHES_TABLE} WHERE batch_id = ?`, `SELECT ${BATCH_COLS} FROM ${APPROVAL_BATCHES_TABLE} WHERE batch_id = $1`), [batchId]);
+        return rows[0] ? mapBatchRow(rows[0]) : null;
+    }
+}
+/** MySQL-protocol(TiDB)绑定。 */
+export class TiDBApprovalAskStore extends SqlApprovalAskStore {
+    constructor(pool) {
+        super(mysqlDriver(pool));
+    }
+}
+/** PostgreSQL 绑定。 */
+export class PgApprovalAskStore extends SqlApprovalAskStore {
+    constructor(pool) {
+        super(pgDriver(pool));
+    }
+}
+//# sourceMappingURL=approval-ask-store-sql.js.map