@sema-agent/server 7.9.0 → 7.11.0

package/dist/plugins/adoption-log-sql.js

@@ -0,0 +1,273 @@
+import { createHash } from "node:crypto";
+import { mysqlDriver, pgDriver } from "./sql-driver.js";
+export const ADOPTION_LOG_TABLE = "adoption_log";
+/** 弧的阶段(183 §3.2 根级状态机的 form b 投影)。**单调**,只增不减。 */
+export const ADOPTION_PHASE = {
+    /** ② 意图已落库(行在,尚未动任何数据行)。 */
+    INTENT: 2,
+    /** ③ 身份轴重绑腿全部完成(与腿的 UPDATE **同一个事务**)。 */
+    REBOUND: 3,
+    /** ④ 解析切换 / 配置清单产出。form b 的 server 半场:配置账已物化进 `configs`。 */
+    CONFIGS: 4,
+    /** ⑤ 承运腿。**form b 恒零承运**(数据本来就在 SQL)—— 阶段位仍显式推进,好让 form a 上车时挂得上。 */
+    CARRIED: 5,
+    /** ⑥ 永久终态。 */
+    TERMINAL: 6,
+};
+/** MySQL 协议方言的建表语句(展开进 tidb-pool 的中央 `SCHEMA_STATEMENTS`,与 approval-ask 同姿势:
+ *  跟着中央 ensureSchema 在 named-lock 的那条 conn 上建,不绕开 DDL 串行化)。 */
+export const TIDB_ADOPTION_LOG_STATEMENTS = [
+    `CREATE TABLE IF NOT EXISTS ${ADOPTION_LOG_TABLE} (
+     adoption_id    VARCHAR(64)  NOT NULL,
+     -- from_principal 上的 UNIQUE = 183 D7「同一个源不许被收编两次」的**数据库强形**。
+     -- 它同时是发起腿的幂等身份:并发同参 POST 由这条约束仲裁,不靠应用层先查后插。
+     from_principal VARCHAR(190) NOT NULL,
+     to_principal   VARCHAR(190) NOT NULL,
+     phase          INT          NOT NULL,
+     state          VARCHAR(16)  NOT NULL,
+     -- legs/configs/report 是 TEXT 不是 JSON:report 的契约是「逐字节恒同」,JSON 列会重排键序(顶注)。
+     legs           MEDIUMTEXT   NOT NULL,
+     configs        MEDIUMTEXT   NOT NULL,
+     report         MEDIUMTEXT   NULL,
+     reject_code    VARCHAR(64)  NULL,
+     reject_detail  TEXT         NULL,
+     created_at_ms  BIGINT       NOT NULL,
+     updated_at_ms  BIGINT       NOT NULL,
+     PRIMARY KEY (adoption_id),
+     UNIQUE KEY uq_adoption_log_from (from_principal),
+     KEY idx_adoption_log_state (state)
+   ) COLLATE utf8mb4_bin`,
+];
+/** PostgreSQL 孪生(由 `ensurePgSchema` 在 advisory lock 的那条 client 上调用)。 */
+export async function ensurePgAdoptionLogSchema(q) {
+    await q(`CREATE TABLE IF NOT EXISTS ${ADOPTION_LOG_TABLE} (
+     adoption_id    VARCHAR(64) COLLATE "C"  NOT NULL,
+     -- MySQL 孪生的行内注解释了这条 UNIQUE 为什么是幂等身份的真源(183 D7 的 DB 强形)。
+     from_principal VARCHAR(190) COLLATE "C" NOT NULL,
+     to_principal   VARCHAR(190) COLLATE "C" NOT NULL,
+     phase          INT          NOT NULL,
+     state          VARCHAR(16) COLLATE "C"  NOT NULL,
+     legs           TEXT COLLATE "C"         NOT NULL,
+     configs        TEXT COLLATE "C"         NOT NULL,
+     report         TEXT COLLATE "C",
+     reject_code    VARCHAR(64) COLLATE "C",
+     reject_detail  TEXT COLLATE "C",
+     created_at_ms  BIGINT       NOT NULL,
+     updated_at_ms  BIGINT       NOT NULL,
+     PRIMARY KEY (adoption_id),
+     CONSTRAINT uq_adoption_log_from UNIQUE (from_principal)
+   )`);
+    await q(`CREATE INDEX IF NOT EXISTS idx_adoption_log_state ON ${ADOPTION_LOG_TABLE} (state)`);
+}
+const COLS = "adoption_id, from_principal, to_principal, phase, state, legs, configs, report, reject_code, reject_detail, created_at_ms, updated_at_ms";
+function toRow(r) {
+    return {
+        adoptionId: String(r.adoption_id),
+        fromPrincipal: String(r.from_principal),
+        toPrincipal: String(r.to_principal),
+        phase: Number(r.phase),
+        state: String(r.state),
+        legsJson: String(r.legs),
+        configsJson: String(r.configs),
+        reportJson: r.report == null ? null : String(r.report),
+        rejectCode: r.reject_code == null ? null : String(r.reject_code),
+        rejectDetail: r.reject_detail == null ? null : String(r.reject_detail),
+        createdAtMs: Number(r.created_at_ms),
+        updatedAtMs: Number(r.updated_at_ms),
+    };
+}
+/** PG advisory lock 的 32 位对象键(类键固定,对象键 = 名字的 sha256 前 4 字节转有符号 int4)。 */
+const PG_ADOPTION_LOCK_CLASS = 4907;
+function pgLockObjectKey(name) {
+    return createHash("sha256").update(name).digest().readInt32BE(0);
+}
+/**
+ * 弧锁的名字。**定长**(前缀 14 + 32 位十六进制 = 46 字符)。
+ *
+ * 🔴 为什么必须 hash 而不是把 principal 直接拼进去(codex R3-F3,亲核属实):TiDB/MySQL 的 `GET_LOCK`
+ * 锁名上限是 **64 字符**,而请求面收的 principal 到 190 —— 超过 50 字符的源身份会让取锁**在弧动起来
+ * 之前**就失败,而那时意图行已经落库,于是每一次重发、每一次副本 boot 续跑都确定性地再撞一次同一堵墙。
+ * (PG 那条腿本来就走 hash 出来的 int4 对象键,这里只是把 MySQL 腿补齐到同一姿势。)
+ */
+export function adoptionLockName(fromPrincipal) {
+    return `sema_adoption:${createHash("sha256").update(fromPrincipal).digest("hex").slice(0, 32)}`;
+}
+/**
+ * 收编日志店(单文件双方言,SqlDriver 形——checkpoint-store / approval-ask-store 同款)。
+ *
+ * 每条语句的两方言文本**并排写在调用点**(A12 判据:方言差异必须显式,不许用占位符编号循环拼)。
+ */
+export class SqlAdoptionLogStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    q(tidb, pg) {
+        return this.db.dialect === "tidb" ? tidb : pg;
+    }
+    /** 池级只读执行面(phase 0 的 preflight 扫描用——它**零写**,不需要也不该占一条事务连接)。
+     *  写路径一律走 {@link rebindTransaction};把驱动整个暴露出去会让调用方能绕开 phase CAS。 */
+    get reader() {
+        return this.db;
+    }
+    /**
+     * 发起腿的 **insert-or-fetch 原子形**。返回读回的行(可能是别人插的)+ 是否本次插入。
+     * 调用方据 `row.toPrincipal !== toPrincipal` 判「同 from 异 to」⇒ typed 409。
+     */
+    async ensureAdoption(row) {
+        const emptyLegs = "[]";
+        const res = await this.db.query(this.q(`INSERT IGNORE INTO ${ADOPTION_LOG_TABLE} (${COLS}) VALUES (?, ?, ?, ?, 'in_flight', ?, ?, NULL, NULL, NULL, ?, ?)`, `INSERT INTO ${ADOPTION_LOG_TABLE} (${COLS}) VALUES ($1, $2, $3, $4, 'in_flight', $5, $6, NULL, NULL, NULL, $7, $8) ON CONFLICT (from_principal) DO NOTHING`), [row.adoptionId, row.fromPrincipal, row.toPrincipal, ADOPTION_PHASE.INTENT, emptyLegs, emptyLegs, row.nowMs, row.nowMs]);
+        const inserted = res.affected > 0;
+        const stored = await this.getByFrom(row.fromPrincipal);
+        if (!stored)
+            throw new Error(`ensureAdoption: row vanished right after insert (from=${row.fromPrincipal})`);
+        return { row: stored, inserted };
+    }
+    async getById(adoptionId, exec = this.db) {
+        const res = await exec.query(this.q(`SELECT ${COLS} FROM ${ADOPTION_LOG_TABLE} WHERE adoption_id = ?`, `SELECT ${COLS} FROM ${ADOPTION_LOG_TABLE} WHERE adoption_id = $1`), [adoptionId]);
+        return res.rows[0] ? toRow(res.rows[0]) : null;
+    }
+    async getByFrom(fromPrincipal, exec = this.db) {
+        const res = await exec.query(this.q(`SELECT ${COLS} FROM ${ADOPTION_LOG_TABLE} WHERE from_principal = ?`, `SELECT ${COLS} FROM ${ADOPTION_LOG_TABLE} WHERE from_principal = $1`), [fromPrincipal]);
+        return res.rows[0] ? toRow(res.rows[0]) : null;
+    }
+    /** I6 server 同族:每副本 boot 必查的在飞名单(**响亮**,不静默跳过)。 */
+    async listInFlight(exec = this.db) {
+        const res = await exec.query(this.q(`SELECT ${COLS} FROM ${ADOPTION_LOG_TABLE} WHERE state = 'in_flight' ORDER BY created_at_ms ASC`, `SELECT ${COLS} FROM ${ADOPTION_LOG_TABLE} WHERE state = 'in_flight' ORDER BY created_at_ms ASC`), []);
+        return res.rows.map(toRow);
+    }
+    /**
+     * 迁移事务:腿的全部 UPDATE **与** phase CAS 落在**同一个事务**里。
+     *
+     * 🔴 为什么必须同事务(而不是「先迁完再推 phase」):两句分开就留下一个窗 —— 腿提交了、phase 没推,
+     * 崩溃后接棒副本重跑腿(幂等,零行变化)却把**首次的行数读数**丢了,回执里的 `legs` 会变成一串 0。
+     * 同事务之后这个窗根本不存在:要么「行迁了且 phase=3 且 legs 读数在」,要么什么都没发生。
+     * 任何异常(含唯一键违例 = 跨轴组合冲突)⇒ ROLLBACK ⇒ **源/目的地两侧字节零变更**。
+     */
+    async rebindOn(conn, adoptionId, expectPhase, nextPhase, nowMs, work, encodeLegs) {
+        try {
+            await conn.begin();
+            const legs = await work(conn);
+            const cas = await conn.query(
+            // 🔴 谓词里必须带 `state = 'in_flight'`(codex R2-F1..F3 的 F3):被拒的行**故意**停在 phase INTENT
+            // (「两侧字节零变更」要求它一步都别走),所以只判 phase 的 CAS 对一条已 rejected 的行是**满足**的
+            // —— 一个在锁上排队的过期调用方于是能把一条永久拒了的弧推去迁数据。终态永久性是库级不变量,
+            // 这道守卫就该在库里,不在调用方的 if 里。
+            this.q(`UPDATE ${ADOPTION_LOG_TABLE} SET phase = ?, legs = ?, updated_at_ms = ? WHERE adoption_id = ? AND phase = ? AND state = 'in_flight'`, `UPDATE ${ADOPTION_LOG_TABLE} SET phase = $1, legs = $2, updated_at_ms = $3 WHERE adoption_id = $4 AND phase = $5 AND state = 'in_flight'`), [nextPhase, encodeLegs(legs), nowMs, adoptionId, expectPhase]);
+            if (cas.affected !== 1) {
+                await conn.rollback();
+                return { ok: false, reason: "phase_moved" };
+            }
+            await conn.commit();
+            return { ok: true, legs };
+        }
+        catch (err) {
+            try {
+                await conn.rollback();
+            }
+            catch (rollbackErr) {
+                // 🔴 不空吞(#191 静默降级门):回滚本身失败通常意味着连接已经废了,原始异常才是要上抛的那个,
+                // 但「回滚没成功」是运维必须看见的事 —— 它决定了库里可能留着一段未提交/已废弃的事务状态。
+                console.warn("[adoption-log] rollback after a failed rebind transaction also failed:", rollbackErr);
+            }
+            throw err;
+        }
+    }
+    /**
+     * 终态**之后**的迟到行清扫事务(无 phase 变更 —— phase 已经是终态,而终态是永久的)。
+     *
+     * 🔴 它不是「再收编一次」:腿本身幂等,清扫只是把收编**结束后**又落到旧身份下的行(配置未随迁的
+     * 部署会持续制造它们)一并搬过去,并让 `current.residualSourceRows` 有个能归零的动作。
+     * `immutableReport` 一个字节都不动(史实与现势分家,183 §6)。
+     */
+    async sweepOn(conn, work) {
+        try {
+            await conn.begin();
+            const out = await work(conn);
+            await conn.commit();
+            return out;
+        }
+        catch (err) {
+            try {
+                await conn.rollback();
+            }
+            catch (rollbackErr) {
+                console.warn("[adoption-log] rollback after a failed sweep transaction also failed:", rollbackErr); // 同上:不空吞
+            }
+            throw err;
+        }
+    }
+    /** 单调 CAS 推进(无数据写的阶段;`false` = 别人已经推过了/相位不符 ⇒ 调用方重读行)。 */
+    async advancePhase(adoptionId, expectPhase, nextPhase, nowMs, exec = this.db) {
+        const res = await exec.query(this.q(`UPDATE ${ADOPTION_LOG_TABLE} SET phase = ?, updated_at_ms = ? WHERE adoption_id = ? AND phase = ?`, `UPDATE ${ADOPTION_LOG_TABLE} SET phase = $1, updated_at_ms = $2 WHERE adoption_id = $3 AND phase = $4`), [nextPhase, nowMs, adoptionId, expectPhase]);
+        return res.affected === 1;
+    }
+    /** phase 4:配置账物化(与 phase 推进同一条语句,免得账落了相位没推)。 */
+    async putConfigs(adoptionId, expectPhase, nextPhase, configsJson, nowMs, exec = this.db) {
+        const res = await exec.query(this.q(`UPDATE ${ADOPTION_LOG_TABLE} SET phase = ?, configs = ?, updated_at_ms = ? WHERE adoption_id = ? AND phase = ?`, `UPDATE ${ADOPTION_LOG_TABLE} SET phase = $1, configs = $2, updated_at_ms = $3 WHERE adoption_id = $4 AND phase = $5`), [nextPhase, configsJson, nowMs, adoptionId, expectPhase]);
+        return res.affected === 1;
+    }
+    /**
+     * ⑥ 终态:`report` 一次写入,`state='adopted'`。
+     * 🔴 `AND report IS NULL` 是 I4(永久终态 + 不可变史实)的**数据库强形**:即使调用序漂了,快照也
+     * 不可能被第二次写盖掉 —— 「逐字节恒同」于是不依赖调用方自觉。
+     */
+    async finalizeAdopted(adoptionId, expectPhase, reportJson, nowMs, exec = this.db) {
+        const res = await exec.query(this.q(`UPDATE ${ADOPTION_LOG_TABLE} SET phase = ?, state = 'adopted', report = ?, updated_at_ms = ? WHERE adoption_id = ? AND phase = ? AND report IS NULL`, `UPDATE ${ADOPTION_LOG_TABLE} SET phase = $1, state = 'adopted', report = $2, updated_at_ms = $3 WHERE adoption_id = $4 AND phase = $5 AND report IS NULL`), [ADOPTION_PHASE.TERMINAL, reportJson, nowMs, adoptionId, expectPhase]);
+        return res.affected === 1;
+    }
+    /** 目的地冲突 ⇒ rejected 终态(源/目的地两侧字节零变更;phase 停在 INTENT)。 */
+    async finalizeRejected(adoptionId, code, detail, nowMs, exec = this.db) {
+        const res = await exec.query(this.q(`UPDATE ${ADOPTION_LOG_TABLE} SET state = 'rejected', reject_code = ?, reject_detail = ?, updated_at_ms = ? WHERE adoption_id = ? AND state = 'in_flight'`, `UPDATE ${ADOPTION_LOG_TABLE} SET state = 'rejected', reject_code = $1, reject_detail = $2, updated_at_ms = $3 WHERE adoption_id = $4 AND state = 'in_flight'`), [code, detail, nowMs, adoptionId]);
+        return res.affected === 1;
+    }
+    /**
+     * 收编弧的 advisory 锁(183 I1 的 form b 形:「与任何活写互斥」在 SQL 侧 = 一次只有一个副本在推这条弧)。
+     *
+     * **非阻塞取 + 有界轮询**(tidb-pool 的 `acquireEnsureSchemaLock` 同款判据:阻塞式 GET_LOCK 会把并发
+     * 调用方全部park 在 TiDB 的悲观锁行上,既耗它的重试预算又饿死应用自己的 FOR UPDATE 路)。取不到 ⇒
+     * 返回 `undefined`,调用方按「在飞」应答 —— **不假装成功,也不无限等**。
+     */
+    async withLock(name, fn, attempts = 20, sleepMs = 100) {
+        const conn = await this.db.connect();
+        let held = false;
+        try {
+            for (let i = 0; i < attempts && !held; i += 1) {
+                const res = await conn.query(this.q("SELECT GET_LOCK(?, 0) AS got", "SELECT pg_try_advisory_lock($1, $2) AS got"), this.db.dialect === "tidb" ? [name] : [PG_ADOPTION_LOCK_CLASS, pgLockObjectKey(name)]);
+                const got = res.rows[0]?.got;
+                held = got === 1 || got === true || got === "1";
+                if (!held)
+                    await new Promise((r) => setTimeout(r, sleepMs));
+            }
+            if (!held)
+                return undefined;
+            // 🔴 把**这一条**连接交出去:整条弧(读 / 事务 / CAS)都跑在它上面,弧内绝不再向池要第二条
+            // ——`connectionLimit=1` 的部署上那第二条永远等不到(codex R3-F2)。
+            return await fn(conn);
+        }
+        finally {
+            if (held) {
+                try {
+                    await conn.query(this.q("SELECT RELEASE_LOCK(?) AS released", "SELECT pg_advisory_unlock($1, $2) AS released"), this.db.dialect === "tidb" ? [name] : [PG_ADOPTION_LOCK_CLASS, pgLockObjectKey(name)]);
+                }
+                catch (releaseErr) {
+                    // 锁在连接关闭时会自动释放,所以释放失败不该盖掉真正的结果 —— 但同样不空吞:
+                    // 释放失败意味着这把弧锁会一直持到连接回收,下一个副本要多等一会儿,那是要能看见的。
+                    console.warn("[adoption-log] releasing the adoption arc lock failed (it auto-frees when the connection closes):", releaseErr);
+                }
+            }
+            conn.release();
+        }
+    }
+}
+export class TiDBAdoptionLogStore extends SqlAdoptionLogStore {
+    constructor(pool) {
+        super(mysqlDriver(pool));
+    }
+}
+export class PgAdoptionLogStore extends SqlAdoptionLogStore {
+    constructor(pool) {
+        super(pgDriver(pool));
+    }
+}
+//# sourceMappingURL=adoption-log-sql.js.map

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

@@ -4,7 +4,7 @@ import { type Checkpoint, type CheckpointGate, type CheckpointState, type Checkp
 import { type SqlDriver } from "./sql-driver.js";
 /**
  * design/80 D-1 (§3 invariant #3 — crash-safe reaper backstop): an ABSOLUTE upper bound on a pending
- * checkpoint's lifetime, stamped at put() into `terminal_at` INDEPENDENT of the per-approval `deadline`. The
+ * checkpoint's lifetime, stamped at put() into `terminal_at_ms` INDEPENDENT of the per-approval `deadline`. The
  * SLA-timer (D-D) does the fine, per-gate-kind resolve-deny; THIS coarse backstop ensures even a pending row
  * with a NULL `deadline` (no approval TTL configured) is eventually GC'd if the SLA service dies — closing a
  * forever-leak of a never-resolved suspension (the current `reap`/`reapExpired` only catch non-NULL deadlines).
@@ -13,9 +13,9 @@ import { type SqlDriver } from "./sql-driver.js";
  */
 export declare const TERMINAL_BACKSTOP_MS: number;
 /**
- * design/80 D-D (adversarial fix): the crash-safe `terminal_at` backstop must fall STRICTLY AFTER any SLA
- * `deadline`, never AT it. `terminal_at = max(createdAt+backstop, deadline)` made the two coincide whenever an
- * operator tuned APPROVAL_TERMINAL_BACKSTOP_MS at/below the SLA — and reapExpired's terminal_at-branch (which
+ * design/80 D-D (adversarial fix): the crash-safe `terminal_at_ms` backstop must fall STRICTLY AFTER any SLA
+ * `deadline`, never AT it. `terminal_at_ms = max(createdAt+backstop, deadline)` made the two coincide whenever an
+ * operator tuned APPROVAL_TERMINAL_BACKSTOP_MS at/below the SLA — and reapExpired's terminal_at_ms-branch (which
  * has NO gate_kind filter) then abort-EXPIRED a human/irreversible_ask gate in the SAME tick the deny-sweep
  * wanted to gracefully DENY it, racing it away. Adding this grace to the deadline term guarantees the deny-sweep
  * at least this window of clean ticks before the absolute backstop can fire. Far smaller than the backstop, so
@@ -152,6 +152,19 @@ export declare class SqlCheckpointStore implements CheckpointStore {
      * `wiring-governance-operator.test.ts` 的 #172 组;已上报上游求一个能表达该宽度的词。
      */
     readonly fidelity: StoreFidelity;
+    /**
+     * `CheckpointStore.redecision` 声明(core 5.22.0 F-012 L2/L3;[3342] clay 裁放行)——**如实按能力判**:
+     * 本店的 {@link SqlCheckpointStore.reopen} 是真 CAS 实现(`resolved`→`pending` 原子翻回 + `reopen_reason`
+     * 权威列,design/80 D-1 的两条重开腿都走它),声明 `reopen: true` 是读数不是抬举。core 的沙箱准入
+     * 模式(pre-flight 要求 `redecision.reopen === true`,declaration never duck-typing——方法在场不算数)
+     * 由这一格武装:Kata 腿(`capabilities.isolation` 真声明)+ durable park 部署下,`sandbox_local` ask
+     * 自动放行并以 `permission.sandbox_admitted` durable 事件披露(缺席披露=core 侧变异恰红)。
+     * `validatingLease` **不声明**:本店没有 durable validating-lease 纪律,不承诺没有的东西。
+     * 翻向钉:`wiring-governance-operator.test.ts`(修前恰红,与本声明同 commit)。
+     */
+    readonly redecision: {
+        readonly reopen: true;
+    };
     constructor(db: SqlDriver, logger?: {
         info?(msg: string, meta?: unknown): void;
     } | undefined);
@@ -252,8 +265,8 @@ export declare class SqlCheckpointStore implements CheckpointStore {
     /**
      * GLOBAL sweep for the service's per-replica TTL reaper (expiry isn't tenant-
      * sensitive — only `resolve` is scoped). Idempotent across replicas (DB serializes; no election). Returns count.
-     * Called with `cutoff = Date.now()` (deadline/terminal_at are ABSOLUTE epoch-ms), so it expires any pending row
-     * whose per-approval `deadline` OR its design/80 D-1 §3-inv#3 `terminal_at` crash-safe backstop has passed —
+     * Called with `cutoff = Date.now()` (deadline/terminal_at_ms are ABSOLUTE epoch-ms), so it expires any pending row
+     * whose per-approval `deadline` OR its design/80 D-1 §3-inv#3 `terminal_at_ms` crash-safe backstop has passed —
      * the latter closes the forever-leak of a pending row with a NULL `deadline` (no approval TTL was configured).
      *
      * design/80 D-D: the deadline-branch EXPIRES (≈ abort) every kind EXCEPT a tool-approval human/irreversible_ask
@@ -262,7 +275,7 @@ export declare class SqlCheckpointStore implements CheckpointStore {
      * AskUserQuestion ALSO mints gate.kind='human' (no question-specific kind in core) — but DENYING a question is
      * incoherent (the model gets a "denied" tool-result, not an answer), so it is carved BACK INTO the expire path
      * (COALESCE(tool_name,'')='AskUserQuestion') to abort-expire on timeout instead. Legacy rows (gate_kind NULL)
-     * stay on the expire path. The terminal_at-branch is the crash-safe backstop for ANY kind (incl. a human gate
+     * stay on the expire path. The terminal_at_ms-branch is the crash-safe backstop for ANY kind (incl. a human gate
      * whose deny-resume keeps failing) — it always abort-expires past the absolute cap (which is now STRICTLY after
      * the deadline, so it never races the deny-sweep at the deadline instant).
      */
@@ -291,7 +304,7 @@ export declare class SqlCheckpointStore implements CheckpointStore {
      * (gate kind + risk severity + budget spent + deadline per suspended task), no N+1 `get`s. The projection is
      * core's shared {@link summarizeCheckpoint} run over the persisted blob (the `checkpoint` column = the same full
      * {@link Checkpoint} `get()` parses), so this stays byte-identical to core's InMemory/Pg/File impls. Order =
-     * created_at ASC; callers (the inbox/scheduler) sort by severity. The COLUMN `status` is authoritative (the blob
+     * created_at_ms ASC; callers (the inbox/scheduler) sort by severity. The COLUMN `status` is authoritative (the blob
      * is the suspend-time snapshot), so it overrides the blob's status before the summary is derived.
      *
      * LIMIT bounds the fan-out (review w16yqkkxv): a triage view never needs more than a few — 500 is a generous
@@ -309,7 +322,7 @@ export declare class SqlCheckpointStore implements CheckpointStore {
      *
      * 「这条 PARKING 的 ask 究竟 park 成了哪张 checkpoint?」的唯一读法。为什么不是「按 session 翻历史页」:
      * 分页宽读会漏匹配,而漏匹配在收敛器那侧的后果是**假阴性 ⇒ 落一条不可逆的 DENIED**。所以这里改成
-     * 谓词精确查——`(scope, session_id, tool_call_id, created_at ≥ sinceMs)` 这组条件下的行数天然极小,
+     * 谓词精确查——`(scope, session_id, tool_call_id, created_at_ms ≥ sinceMs)` 这组条件下的行数天然极小,
      * 一次全量返回,结构上没有分页假阴性。
      *
      * 三条口径,逐条都是判据:

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

@@ -37,7 +37,7 @@ import { mysqlDriver, pgDriver, dialectProtocolJsonEncoder } from "./sql-driver.
 const MAX_TOOL_INPUT_CHARS = 8192;
 /**
  * design/80 D-1 (§3 invariant #3 — crash-safe reaper backstop): an ABSOLUTE upper bound on a pending
- * checkpoint's lifetime, stamped at put() into `terminal_at` INDEPENDENT of the per-approval `deadline`. The
+ * checkpoint's lifetime, stamped at put() into `terminal_at_ms` INDEPENDENT of the per-approval `deadline`. The
  * SLA-timer (D-D) does the fine, per-gate-kind resolve-deny; THIS coarse backstop ensures even a pending row
  * with a NULL `deadline` (no approval TTL configured) is eventually GC'd if the SLA service dies — closing a
  * forever-leak of a never-resolved suspension (the current `reap`/`reapExpired` only catch non-NULL deadlines).
@@ -46,15 +46,15 @@ const MAX_TOOL_INPUT_CHARS = 8192;
  */
 export const TERMINAL_BACKSTOP_MS = Math.max(60_000, Number(process.env.APPROVAL_TERMINAL_BACKSTOP_MS) || 30 * 86_400_000);
 /**
- * design/80 D-D (adversarial fix): the crash-safe `terminal_at` backstop must fall STRICTLY AFTER any SLA
- * `deadline`, never AT it. `terminal_at = max(createdAt+backstop, deadline)` made the two coincide whenever an
- * operator tuned APPROVAL_TERMINAL_BACKSTOP_MS at/below the SLA — and reapExpired's terminal_at-branch (which
+ * design/80 D-D (adversarial fix): the crash-safe `terminal_at_ms` backstop must fall STRICTLY AFTER any SLA
+ * `deadline`, never AT it. `terminal_at_ms = max(createdAt+backstop, deadline)` made the two coincide whenever an
+ * operator tuned APPROVAL_TERMINAL_BACKSTOP_MS at/below the SLA — and reapExpired's terminal_at_ms-branch (which
  * has NO gate_kind filter) then abort-EXPIRED a human/irreversible_ask gate in the SAME tick the deny-sweep
  * wanted to gracefully DENY it, racing it away. Adding this grace to the deadline term guarantees the deny-sweep
  * at least this window of clean ticks before the absolute backstop can fire. Far smaller than the backstop, so
  * it never meaningfully delays the eventual crash-safe GC.
  */
-export const TERMINAL_GRACE_MS = 3_600_000; // exported for the LOCAL twin's read-time terminal_at derivation (anti-drift) // 1h — many reaper intervals of deny-sweep runway past the SLA deadline
+export const TERMINAL_GRACE_MS = 3_600_000; // exported for the LOCAL twin's read-time terminal_at_ms derivation (anti-drift) // 1h — many reaper intervals of deny-sweep runway past the SLA deadline
 /**
  * The capability token IS the resume credential (token-as-auth) — anyone who reads it can impersonate a
  * resume, so it must never reach the logs (which fan out to a log-aggregation pipeline). For the diagnostic
@@ -269,6 +269,17 @@ export class SqlCheckpointStore {
      * `wiring-governance-operator.test.ts` 的 #172 组;已上报上游求一个能表达该宽度的词。
      */
     fidelity = "json";
+    /**
+     * `CheckpointStore.redecision` 声明(core 5.22.0 F-012 L2/L3;[3342] clay 裁放行)——**如实按能力判**:
+     * 本店的 {@link SqlCheckpointStore.reopen} 是真 CAS 实现(`resolved`→`pending` 原子翻回 + `reopen_reason`
+     * 权威列,design/80 D-1 的两条重开腿都走它),声明 `reopen: true` 是读数不是抬举。core 的沙箱准入
+     * 模式(pre-flight 要求 `redecision.reopen === true`,declaration never duck-typing——方法在场不算数)
+     * 由这一格武装:Kata 腿(`capabilities.isolation` 真声明)+ durable park 部署下,`sandbox_local` ask
+     * 自动放行并以 `permission.sandbox_admitted` durable 事件披露(缺席披露=core 侧变异恰红)。
+     * `validatingLease` **不声明**:本店没有 durable validating-lease 纪律,不承诺没有的东西。
+     * 翻向钉:`wiring-governance-operator.test.ts`(修前恰红,与本声明同 commit)。
+     */
+    redecision = { reopen: true };
     constructor(db, logger) {
         this.db = db;
         this.logger = logger;
@@ -303,8 +314,8 @@ export class SqlCheckpointStore {
         // payload without an N+1 trace.turns fetch. Stored as a stringified JSON column value.
         const toolInput = boundedToolInput(pa?.args);
         try {
-            await this.db.query(this.q("INSERT INTO checkpoint (token, scope, session_id, version, status, tool_name, tool_call_id, tool_input, checkpoint, deadline, created_at, terminal_at, gate_kind, bound_input_hash, risk_descriptor) " +
-                "VALUES (?,?,?,?,'pending',?,?,?,?,?,?,?,?,?,?)", "INSERT INTO checkpoint (token, scope, session_id, version, status, tool_name, tool_call_id, tool_input, checkpoint, deadline, created_at, terminal_at, gate_kind, bound_input_hash, risk_descriptor) " +
+            await this.db.query(this.q("INSERT INTO checkpoint (token, scope, session_id, version, status, tool_name, tool_call_id, tool_input, checkpoint, deadline, created_at_ms, terminal_at_ms, gate_kind, bound_input_hash, risk_descriptor) " +
+                "VALUES (?,?,?,?,'pending',?,?,?,?,?,?,?,?,?,?)", "INSERT INTO checkpoint (token, scope, session_id, version, status, tool_name, tool_call_id, tool_input, checkpoint, deadline, created_at_ms, terminal_at_ms, gate_kind, bound_input_hash, risk_descriptor) " +
                 "VALUES ($1,$2,$3,$4,'pending',$5,$6,$7::jsonb,$8::jsonb,$9,$10,$11,$12,$13,$14)"), [
                 token,
                 cp.scope,
@@ -316,7 +327,7 @@ export class SqlCheckpointStore {
                 this.json(cp, "checkpoint"),
                 cp.deadline ?? null,
                 cp.createdAt,
-                Math.max(cp.createdAt + TERMINAL_BACKSTOP_MS, (cp.deadline ?? 0) + TERMINAL_GRACE_MS), // D-1 §3 inv#3 backstop — STRICTLY after any SLA deadline (grace) so the terminal_at-branch never races the D-D deny-sweep, and never pre-empts an operator's longer TTL
+                Math.max(cp.createdAt + TERMINAL_BACKSTOP_MS, (cp.deadline ?? 0) + TERMINAL_GRACE_MS), // D-1 §3 inv#3 backstop — STRICTLY after any SLA deadline (grace) so the terminal_at_ms-branch never races the D-D deny-sweep, and never pre-empts an operator's longer TTL
                 cp.gate?.kind ?? null, // D-D SLA split: human/irreversible_ask deadline → resolve-deny; others → expire
                 pa?.boundInputHash ?? null, // D-1: the opaque hash the portal must echo on /decide (surfaced via listPending so the TOCTOU binding is reachable)
                 ((g) => (g?.riskDescriptor ? this.json(g.riskDescriptor, "risk descriptor") : null))(cp.gate), // riskDescriptor inbox: stamp core's INERT descriptor for triage-sort
@@ -413,8 +424,8 @@ export class SqlCheckpointStore {
         const params = [this.json(outcome, "checkpoint outcome"), Date.now(), token, scope];
         if (expect)
             params.push(expect.rev);
-        const res = await this.db.query(this.q("UPDATE checkpoint SET status = 'resolved', outcome = ?, decided_at = ?, rev = rev + 1, reopen_reason = NULL WHERE token = ? AND scope = ? AND status = 'pending'" +
-            (expect ? " AND rev = ?" : ""), "UPDATE checkpoint SET status = 'resolved', outcome = $1::jsonb, decided_at = $2, rev = rev + 1, reopen_reason = NULL WHERE token = $3 AND scope = $4 AND status = 'pending'" +
+        const res = await this.db.query(this.q("UPDATE checkpoint SET status = 'resolved', outcome = ?, decided_at_ms = ?, rev = rev + 1, reopen_reason = NULL WHERE token = ? AND scope = ? AND status = 'pending'" +
+            (expect ? " AND rev = ?" : ""), "UPDATE checkpoint SET status = 'resolved', outcome = $1::jsonb, decided_at_ms = $2, rev = rev + 1, reopen_reason = NULL WHERE token = $3 AND scope = $4 AND status = 'pending'" +
             (expect ? " AND rev = $5" : "")), params);
         return res.affected === 1;
     }
@@ -508,19 +519,19 @@ export class SqlCheckpointStore {
      * Uses `expired` (not a `resolve`-deny) so a CANCELLED checkpoint never pollutes resolved-count / outcome.
      */
     async expire(token, scope) {
-        const res = await this.db.query(this.q("UPDATE checkpoint SET status = 'expired', decided_at = ? WHERE token = ? AND scope = ? AND status = 'pending'", "UPDATE checkpoint SET status = 'expired', decided_at = $1 WHERE token = $2 AND scope = $3 AND status = 'pending'"), [Date.now(), token, scope]);
+        const res = await this.db.query(this.q("UPDATE checkpoint SET status = 'expired', decided_at_ms = ? WHERE token = ? AND scope = ? AND status = 'pending'", "UPDATE checkpoint SET status = 'expired', decided_at_ms = $1 WHERE token = $2 AND scope = $3 AND status = 'pending'"), [Date.now(), token, scope]);
         return res.affected === 1;
     }
     /** Interface reap: CAS-expire pending checkpoints in `scope` past `cutoff`. Returns count. */
     async reap(scope, cutoff) {
-        const res = await this.db.query(this.q("UPDATE checkpoint SET status = 'expired', decided_at = ? WHERE scope = ? AND status = 'pending' AND deadline IS NOT NULL AND deadline <= ?", "UPDATE checkpoint SET status = 'expired', decided_at = $1 WHERE scope = $2 AND status = 'pending' AND deadline IS NOT NULL AND deadline <= $3"), [Date.now(), scope, cutoff]);
+        const res = await this.db.query(this.q("UPDATE checkpoint SET status = 'expired', decided_at_ms = ? WHERE scope = ? AND status = 'pending' AND deadline IS NOT NULL AND deadline <= ?", "UPDATE checkpoint SET status = 'expired', decided_at_ms = $1 WHERE scope = $2 AND status = 'pending' AND deadline IS NOT NULL AND deadline <= $3"), [Date.now(), scope, cutoff]);
         return res.affected;
     }
     /**
      * GLOBAL sweep for the service's per-replica TTL reaper (expiry isn't tenant-
      * sensitive — only `resolve` is scoped). Idempotent across replicas (DB serializes; no election). Returns count.
-     * Called with `cutoff = Date.now()` (deadline/terminal_at are ABSOLUTE epoch-ms), so it expires any pending row
-     * whose per-approval `deadline` OR its design/80 D-1 §3-inv#3 `terminal_at` crash-safe backstop has passed —
+     * Called with `cutoff = Date.now()` (deadline/terminal_at_ms are ABSOLUTE epoch-ms), so it expires any pending row
+     * whose per-approval `deadline` OR its design/80 D-1 §3-inv#3 `terminal_at_ms` crash-safe backstop has passed —
      * the latter closes the forever-leak of a pending row with a NULL `deadline` (no approval TTL was configured).
      *
      * design/80 D-D: the deadline-branch EXPIRES (≈ abort) every kind EXCEPT a tool-approval human/irreversible_ask
@@ -529,14 +540,14 @@ export class SqlCheckpointStore {
      * AskUserQuestion ALSO mints gate.kind='human' (no question-specific kind in core) — but DENYING a question is
      * incoherent (the model gets a "denied" tool-result, not an answer), so it is carved BACK INTO the expire path
      * (COALESCE(tool_name,'')='AskUserQuestion') to abort-expire on timeout instead. Legacy rows (gate_kind NULL)
-     * stay on the expire path. The terminal_at-branch is the crash-safe backstop for ANY kind (incl. a human gate
+     * stay on the expire path. The terminal_at_ms-branch is the crash-safe backstop for ANY kind (incl. a human gate
      * whose deny-resume keeps failing) — it always abort-expires past the absolute cap (which is now STRICTLY after
      * the deadline, so it never races the deny-sweep at the deadline instant).
      */
     async reapExpired(cutoff) {
-        const res = await this.db.query(this.q("UPDATE checkpoint SET status = 'expired', decided_at = ? " +
-            `WHERE status = 'pending' AND ((deadline IS NOT NULL AND deadline <= ? AND (gate_kind IS NULL OR gate_kind NOT IN ${APPROVAL_GATE_KINDS_SQL_IN} OR COALESCE(tool_name,'') = 'AskUserQuestion')) OR (terminal_at IS NOT NULL AND terminal_at <= ?))`, "UPDATE checkpoint SET status = 'expired', decided_at = $1 " +
-            `WHERE status = 'pending' AND ((deadline IS NOT NULL AND deadline <= $2 AND (gate_kind IS NULL OR gate_kind NOT IN ${APPROVAL_GATE_KINDS_SQL_IN} OR COALESCE(tool_name,'') = 'AskUserQuestion')) OR (terminal_at IS NOT NULL AND terminal_at <= $3))`), [Date.now(), cutoff, cutoff]);
+        const res = await this.db.query(this.q("UPDATE checkpoint SET status = 'expired', decided_at_ms = ? " +
+            `WHERE status = 'pending' AND ((deadline IS NOT NULL AND deadline <= ? AND (gate_kind IS NULL OR gate_kind NOT IN ${APPROVAL_GATE_KINDS_SQL_IN} OR COALESCE(tool_name,'') = 'AskUserQuestion')) OR (terminal_at_ms IS NOT NULL AND terminal_at_ms <= ?))`, "UPDATE checkpoint SET status = 'expired', decided_at_ms = $1 " +
+            `WHERE status = 'pending' AND ((deadline IS NOT NULL AND deadline <= $2 AND (gate_kind IS NULL OR gate_kind NOT IN ${APPROVAL_GATE_KINDS_SQL_IN} OR COALESCE(tool_name,'') = 'AskUserQuestion')) OR (terminal_at_ms IS NOT NULL AND terminal_at_ms <= $3))`), [Date.now(), cutoff, cutoff]);
         return res.affected;
     }
     /**
@@ -560,11 +571,11 @@ export class SqlCheckpointStore {
      *  joined from task_active (the JOIN KEY to the run/trace — a suspended run KEEPS its
      *  session claim, so the join is live for every pending row; null only in pathological windows). */
     async listPending(scope) {
-        const base = "SELECT c.session_id, c.scope, c.tool_name, c.tool_call_id, c.tool_input, c.bound_input_hash, c.risk_descriptor, c.created_at, c.deadline, c.gate_kind, ta.task_id " +
+        const base = "SELECT c.session_id, c.scope, c.tool_name, c.tool_call_id, c.tool_input, c.bound_input_hash, c.risk_descriptor, c.created_at_ms, c.deadline, c.gate_kind, ta.task_id " +
             "FROM checkpoint c LEFT JOIN task_active ta ON ta.session_id = c.session_id WHERE c.status='pending'";
         const { rows } = scope
-            ? await this.db.query(`${base}${this.q(" AND c.scope=?", " AND c.scope=$1")} ORDER BY c.created_at ASC`, [scope])
-            : await this.db.query(`${base} ORDER BY c.created_at ASC`);
+            ? await this.db.query(`${base}${this.q(" AND c.scope=?", " AND c.scope=$1")} ORDER BY c.created_at_ms ASC`, [scope])
+            : await this.db.query(`${base} ORDER BY c.created_at_ms ASC`);
         const out = rows.map((r) => {
             const toolCallId = r.tool_call_id ?? null;
             const boundInputHash = r.bound_input_hash ?? null;
@@ -587,7 +598,7 @@ export class SqlCheckpointStore {
                 // Both drivers return the JSON column already parsed; null for pre-migration rows. PG 库内恒干净
                 // (拒绝式)——直读即审阅面=执行面。
                 input: r.tool_input ?? null,
-                createdAt: Number(r.created_at),
+                createdAt: Number(r.created_at_ms),
                 deadline: r.deadline == null ? null : Number(r.deadline),
                 riskDescriptor: parseJson(r.risk_descriptor),
             };
@@ -602,14 +613,14 @@ export class SqlCheckpointStore {
      * (gate kind + risk severity + budget spent + deadline per suspended task), no N+1 `get`s. The projection is
      * core's shared {@link summarizeCheckpoint} run over the persisted blob (the `checkpoint` column = the same full
      * {@link Checkpoint} `get()` parses), so this stays byte-identical to core's InMemory/Pg/File impls. Order =
-     * created_at ASC; callers (the inbox/scheduler) sort by severity. The COLUMN `status` is authoritative (the blob
+     * created_at_ms ASC; callers (the inbox/scheduler) sort by severity. The COLUMN `status` is authoritative (the blob
      * is the suspend-time snapshot), so it overrides the blob's status before the summary is derived.
      *
      * LIMIT bounds the fan-out (review w16yqkkxv): a triage view never needs more than a few — 500 is a generous
      * ceiling that still protects memory/latency if a scope ever accumulates pathologically many pending gates.
      */
     async listByScope(scope) {
-        const { rows } = await this.db.query(this.q("SELECT checkpoint, status FROM checkpoint WHERE status = 'pending' AND scope = ? ORDER BY created_at ASC LIMIT 500", "SELECT checkpoint, status FROM checkpoint WHERE status = 'pending' AND scope = $1 ORDER BY created_at ASC LIMIT 500"), [scope]);
+        const { rows } = await this.db.query(this.q("SELECT checkpoint, status FROM checkpoint WHERE status = 'pending' AND scope = ? ORDER BY created_at_ms ASC LIMIT 500", "SELECT checkpoint, status FROM checkpoint WHERE status = 'pending' AND scope = $1 ORDER BY created_at_ms ASC LIMIT 500"), [scope]);
         const out = [];
         for (const r of rows) {
             // A corrupt/missing blob skips THAT row rather than crashing the whole scheduler view (review w16yqkkxv):
@@ -638,7 +649,7 @@ export class SqlCheckpointStore {
      *
      * 「这条 PARKING 的 ask 究竟 park 成了哪张 checkpoint?」的唯一读法。为什么不是「按 session 翻历史页」:
      * 分页宽读会漏匹配,而漏匹配在收敛器那侧的后果是**假阴性 ⇒ 落一条不可逆的 DENIED**。所以这里改成
-     * 谓词精确查——`(scope, session_id, tool_call_id, created_at ≥ sinceMs)` 这组条件下的行数天然极小,
+     * 谓词精确查——`(scope, session_id, tool_call_id, created_at_ms ≥ sinceMs)` 这组条件下的行数天然极小,
      * 一次全量返回,结构上没有分页假阴性。
      *
      * 三条口径,逐条都是判据:
@@ -661,9 +672,9 @@ export class SqlCheckpointStore {
      * 维,列命中行结构上也必须解 blob 才拿得到它。
      */
     async findCheckpointCandidatesForAsk(scope, sessionId, toolCallId, sinceMs) {
-        const { rows } = await this.db.query(this.q("SELECT token, status, created_at, tool_call_id, bound_input_hash, version, checkpoint FROM checkpoint " +
-            "WHERE scope=? AND session_id=? AND created_at>=? AND (tool_call_id=? OR tool_call_id IS NULL) ORDER BY created_at ASC", "SELECT token, status, created_at, tool_call_id, bound_input_hash, version, checkpoint FROM checkpoint " +
-            "WHERE scope=$1 AND session_id=$2 AND created_at>=$3 AND (tool_call_id=$4 OR tool_call_id IS NULL) ORDER BY created_at ASC"), [scope, sessionId, sinceMs, toolCallId]);
+        const { rows } = await this.db.query(this.q("SELECT token, status, created_at_ms, tool_call_id, bound_input_hash, version, checkpoint FROM checkpoint " +
+            "WHERE scope=? AND session_id=? AND created_at_ms>=? AND (tool_call_id=? OR tool_call_id IS NULL) ORDER BY created_at_ms ASC", "SELECT token, status, created_at_ms, tool_call_id, bound_input_hash, version, checkpoint FROM checkpoint " +
+            "WHERE scope=$1 AND session_id=$2 AND created_at_ms>=$3 AND (tool_call_id=$4 OR tool_call_id IS NULL) ORDER BY created_at_ms ASC"), [scope, sessionId, sinceMs, toolCallId]);
         const out = [];
         for (const r of rows) {
             // `sourceTaskId: null` 是**所有 unparseable 臂的共同底**(读不出的行不许带出一个可用于身份比对的
@@ -671,7 +682,7 @@ export class SqlCheckpointStore {
             const base = {
                 token: String(r.token),
                 status: String(r.status),
-                createdAtMs: Number(r.created_at),
+                createdAtMs: Number(r.created_at_ms),
                 boundInputHash: r.bound_input_hash == null ? null : String(r.bound_input_hash),
                 sourceTaskId: null,
             };

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

@@ -27,6 +27,16 @@ export declare class LocalCheckpointStore {
      * 内核哪天改宽度,包装层的声明会被那条钉当场揪出来,而不是靠人记得同步。
      */
     readonly fidelity: StoreFidelity;
+    /**
+     * `CheckpointStore.redecision` 声明(core 5.22.0 F-012 L2/L3;[3342] clay 裁放行)——**如实按内核判**,
+     * 与 durability/fidelity 同一条判据:内核 core `FileCheckpointStore` **自己**声明 `{ reopen: true }`,
+     * 本类的 {@link LocalCheckpointStore.reopen} 纯委派给它 ⇒ 抄内核的读数是诚实的。包装类**不继承**被
+     * 包装者的声明(委派不是子类),所以这一格必须自己写。`validatingLease` 不声明(内核也没声明)。
+     * 翻向钉:`wiring-governance-operator.test.ts`(修前恰红,与本声明同 commit)。
+     */
+    readonly redecision: {
+        readonly reopen: true;
+    };
     private readonly inner;
     private readonly scopesPath;
     private readonly sessionTokensPath;
@@ -84,7 +94,7 @@ export declare class LocalCheckpointStore {
      * design/80 D-D global expiry sweep — same kind-split as the TiDB twin: the deadline branch abort-expires
      * every kind EXCEPT a human/irreversible_ask approval gate (those get the graceful resolve-DENY via
      * listExpiredApprovalGates), with the AskUserQuestion carve-back (denying a question is incoherent → expire);
-     * the terminal_at branch (derived read-time via the SAME formula the TiDB put stamps) abort-expires ANY kind.
+     * the terminal_at_ms branch (derived read-time via the SAME formula the TiDB put stamps) abort-expires ANY kind.
      */
     reapExpired(cutoff: number): Promise<number>;
     /** design/80 D-D SLA deny-sweep input — pending human/irreversible_ask gates past deadline (excl. AskUserQuestion). */

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

@@ -26,7 +26,7 @@ import { join } from "node:path";
 import { isApprovalGateKind } from "../tool-approval.js"; // A-002.1 单一属主
 import { FileCheckpointStore, atomicWriteFile, sanitizePathComponent, } from "@sema-agent/core";
 import { boundedToolInput, TERMINAL_BACKSTOP_MS, TERMINAL_GRACE_MS } from "./checkpoint-store-sql.js";
-/** design/80 D-D read-time twin of the TiDB put-time `terminal_at` column (same formula — anti-drift). */
+/** design/80 D-D read-time twin of the TiDB put-time `terminal_at_ms` column (same formula — anti-drift). */
 function terminalAtOf(cp) {
     return Math.max(cp.createdAt + TERMINAL_BACKSTOP_MS, (cp.deadline ?? 0) + TERMINAL_GRACE_MS);
 }
@@ -54,6 +54,14 @@ export class LocalCheckpointStore {
      * 内核哪天改宽度,包装层的声明会被那条钉当场揪出来,而不是靠人记得同步。
      */
     fidelity = "json";
+    /**
+     * `CheckpointStore.redecision` 声明(core 5.22.0 F-012 L2/L3;[3342] clay 裁放行)——**如实按内核判**,
+     * 与 durability/fidelity 同一条判据:内核 core `FileCheckpointStore` **自己**声明 `{ reopen: true }`,
+     * 本类的 {@link LocalCheckpointStore.reopen} 纯委派给它 ⇒ 抄内核的读数是诚实的。包装类**不继承**被
+     * 包装者的声明(委派不是子类),所以这一格必须自己写。`validatingLease` 不声明(内核也没声明)。
+     * 翻向钉:`wiring-governance-operator.test.ts`(修前恰红,与本声明同 commit)。
+     */
+    redecision = { reopen: true };
     inner;
     scopesPath;
     sessionTokensPath;
@@ -286,7 +294,7 @@ export class LocalCheckpointStore {
      * design/80 D-D global expiry sweep — same kind-split as the TiDB twin: the deadline branch abort-expires
      * every kind EXCEPT a human/irreversible_ask approval gate (those get the graceful resolve-DENY via
      * listExpiredApprovalGates), with the AskUserQuestion carve-back (denying a question is incoherent → expire);
-     * the terminal_at branch (derived read-time via the SAME formula the TiDB put stamps) abort-expires ANY kind.
+     * the terminal_at_ms branch (derived read-time via the SAME formula the TiDB put stamps) abort-expires ANY kind.
      */
     async reapExpired(cutoff) {
         let n = 0;

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

@@ -44,8 +44,8 @@ export async function ensurePgMemoryEngineSchema(query, opts = {}) {
     const embeddingCol = vec?.pgvector ? `vector(${vec.dimensions})` : "jsonb";
     await query(`CREATE TABLE IF NOT EXISTS ${PG_MEMORY_ENGINE_TABLES.entry} (
     id text COLLATE "C" PRIMARY KEY,
-    scope text COLLATE "C" NOT NULL,
-    slug text COLLATE "C" NOT NULL,
+    scope varchar(190) COLLATE "C" NOT NULL,
+    slug varchar(512) COLLATE "C" NOT NULL,
     frontmatter jsonb NOT NULL,
     body text COLLATE "C" NOT NULL,
     rev text COLLATE "C" NOT NULL,
@@ -66,7 +66,7 @@ export async function ensurePgMemoryEngineSchema(query, opts = {}) {
     // suffix. NOT wrapped in try/catch — if this constraint cannot be created, the backend is unsafe.
     await query(`CREATE UNIQUE INDEX IF NOT EXISTS uq_${PG_MEMORY_ENGINE_TABLES.entry}_scope_slug ON ${PG_MEMORY_ENGINE_TABLES.entry} (scope, slug)`);
     await query(`CREATE TABLE IF NOT EXISTS ${PG_MEMORY_ENGINE_TABLES.cursor} (
-    scope text COLLATE "C" PRIMARY KEY,
+    scope varchar(190) COLLATE "C" PRIMARY KEY,
     cursor text COLLATE "C" NOT NULL
   )`);
 }