@sema-agent/server 7.92.1 → 7.92.2

package/dist/plugins/schema-consistency.d.ts

@@ -0,0 +1,88 @@
+/**
+ * **启动期「库 ≟ 代码」列集对账探针**(S-547)—— 存量库缺列/多列一律**响亮拒启**。
+ *
+ * ── 病(test T-47 三库一致的真读数)───────────────────────────────────────────────────────────────
+ * 7.91.2 建的 `session_policy`(那时还没有 `gen` 列)+ 一行数据,7.92.0 的二进制接上去:`CREATE TABLE
+ * IF NOT EXISTS` 对存量表是**空操作** ⇒ 启动全绿、日志零提 `gen`、健康检查 healthy,直到**用户路径上**
+ * 第一次读写策略行才炸 —— `PUT/GET /v1/sessions/:id/policy` 500,`POST /v1/tasks` 的 run 终局对外
+ * `errorCode` 直接是裸 `42703` / `ER_BAD_FIELD_ERROR`。
+ *
+ * ── 与 SCHEMA POLICY(`tidb-pool.ts` 顶注,clay 裁 2026-07-26)不冲突 ─────────────────────────────
+ * 那条口径禁的是 **ALTER seam**:「代码是 schema 的唯一真源、存量库删库重建、`ensure*` 里不许再出现
+ * `ALTER TABLE`」。本探针**一条 DDL 都不发**,它是只读的 information_schema 对账 —— 恰恰是那条口径的
+ * **执行面**:口径说「库必须等于代码」,在此之前没有任何东西检查过这句话是不是真的。两者一个是禁令
+ * (不许代码偷改库)、一个是对账(库偏离了就别起),同向不同面。
+ *
+ * ── 为什么两个方向都拒(缺列 **和** 多列)──────────────────────────────────────────────────────
+ * 缺列 = 库比代码旧(升级没重建库):读写会在用户路径上炸。多列 = 库比代码**新** —— 滚动升级窗里一个
+ * **旧副本**连上了已被新副本重建过的库;它按旧列集读写,新列上的不变量(本例:`gen` 血统)在它眼里
+ * 根本不存在,于是它会悄悄写出违反新契约的行。后者比前者更隐蔽,所以不做「幽灵列只警告」。
+ * ⇒ 运维顺序因此是**先升库再升副本**(见 `docs/DEPLOY-PREREQS.md` 滚动升级窗那一节)。
+ *
+ * ── 期望列集从哪来:**机器派生,不许手抄**([ref])────────────────────────────────────────────
+ * 期望值 = `schema-ensure-legs.ts` 的录制驱动跑一遍**真的** `ensure*Schema`,把录到的 `CREATE TABLE`
+ * 语句文本解析出列集。于是「代码里的 schema」与「探针拿来对账的 schema」是**同一份字节**,不存在第二
+ * 处清单会腐掉。(更好的形是把语句数组本身改成结构化再生成 SQL —— 那要改 70 张表的 DDL 写法,爆炸
+ * 半径远大于本批;先解析文本,理由写在这里。)拒启文案里的那句 `ALTER TABLE … ADD COLUMN …` 也由
+ * **同一份解析结果**生成,不是手写的。
+ *
+ * ── 失败方向:读不到就拒,不跳过 ─────────────────────────────────────────────────────────────
+ * information_schema 查询抛错、或整库一行都读不出来 ⇒ **拒启**。探针的语义是「我证明了库等于代码」,
+ * 证不出来时放行等于把一条保护性断言静默降级成祝福([ref]:保护型缺席必须 fail-closed)。
+ * `recordFailOpen` 在这条腿上**不适用** —— 它是 F 类(装饰/缓存)的登记口,不是 P 类保护臂的逃生门。
+ */
+import { type SchemaDialect } from "./schema-ensure-legs.js";
+/** 一列:名字 + 它在 `CREATE TABLE` 里的**原样定义文本**(生成 ADD COLUMN 指路用,不另手写)。 */
+export interface ParsedColumn {
+    readonly name: string;
+    readonly ddl: string;
+}
+/** 一张表的列形。 */
+export interface ParsedTable {
+    readonly table: string;
+    readonly columns: readonly ParsedColumn[];
+}
+/**
+ * 解析一条 `CREATE TABLE`。不是建表语句(CREATE INDEX / INSERT / SELECT / CREATE EXTENSION)⇒ `undefined`。
+ *
+ * 认识面窄得刻意:只取**表名 + 顶层列名 + 该列的定义文本**。类型、默认值、可空性一律**不比对** ——
+ * 本探针守的是「列在不在」这一类(T-47 的真病),把类型也拉进来会让方言差异(`DATETIME(3)` ⇄
+ * `TIMESTAMPTZ(3)`、`vector(d)` ⇄ `jsonb` 的运行期参数化)变成一堆假红,而那是另一条判据另一台车。
+ */
+export declare function parseCreateTable(stmt: string): ParsedTable | undefined;
+/** 启动时真会建出来的**全部**表形(录制 → 解析)。同名表二次出现以**先到**为准(`IF NOT EXISTS` 的真语义)。 */
+export declare function expectedTableShapes(dialect: SchemaDialect): Promise<Map<string, ParsedTable>>;
+/** 拒启码(机读)。附录 A / 拒启码表的登记名。 */
+export declare const SCHEMA_MISMATCH_ERROR_CODE = "config.schema_mismatch";
+/** 一张表的对账结论。 */
+export interface TableMismatch {
+    readonly table: string;
+    /** 代码有、库没有(库比代码**旧**)。 */
+    readonly missing: readonly ParsedColumn[];
+    /** 库有、代码没有(库比代码**新** —— 滚动窗里的旧副本)。 */
+    readonly ghost: readonly string[];
+}
+/** 探针读口:一条 SQL → 行数组(两方言由调用方各自绑)。 */
+export type SchemaProbeRead = (sql: string) => Promise<Array<Record<string, unknown>>>;
+/**
+ * 库里实际的列集(表名 → 列名集合)。
+ *
+ * 🔴 **PG 侧读的是「查询真正会解析到的那个关系」,不是 `current_schema()`**(codex 对抗复审本轮 [medium]
+ * 采纳):店里的 SQL 全是**不限定 schema** 的裸表名,它按 `search_path` **逐个** schema 解析,命中第一个;
+ * 而 `current_schema()` 只是路径的第一段。两者不等的部署是真的存在(角色的 `search_path` 配了多段),那时
+ * 只读第一段会让探针对「表其实住在路径后段、而且缺列」这一形**完全沉默**。⇒ 按 `current_schemas(false)`
+ * 的**顺序**取每张表的第一次命中 —— 探针于是与执行器看同一张表。MySQL 协议没有这个概念(库 = 连接上的
+ * `DATABASE()`),那条臂一个字不变。
+ */
+export declare function readLiveColumns(read: SchemaProbeRead, dialect: SchemaDialect): Promise<Map<string, Set<string>>>;
+/** 对账(纯函数:期望 × 实况 → 不符表清单)。 */
+export declare function diffSchema(expected: Map<string, ParsedTable>, live: Map<string, Set<string>>): TableMismatch[];
+/** 拒启文案(表名 + 缺/多列 + 两条路;ADD COLUMN 句由解析结果**生成**)。 */
+export declare function describeSchemaMismatch(dialect: SchemaDialect, mismatches: readonly TableMismatch[]): string;
+/**
+ * 启动期对账:**建表之后**跑,不符即抛(= 拒启)。两方言 + InnoDB 同腿(MySQL 协议共用 `mysql` 臂)。
+ *
+ * 失败方向见文件头注:读抛 / 整库零行 ⇒ 拒。
+ */
+export declare function assertSchemaMatchesCode(read: SchemaProbeRead, dialect: SchemaDialect): Promise<void>;
+//# sourceMappingURL=schema-consistency.d.ts.map

package/dist/plugins/schema-consistency.js

@@ -0,0 +1,202 @@
+import { recordEnsureStatements } from "./schema-ensure-legs.js";
+const QUOTES = new Set(["'", '"', "`"]);
+function stripLineComments(sql) {
+    let out = "";
+    for (let i = 0; i < sql.length; i++) {
+        const c = sql[i];
+        if (QUOTES.has(c)) {
+            const q = c;
+            out += c;
+            i++;
+            while (i < sql.length) {
+                out += sql[i];
+                if (sql[i] === q)
+                    break;
+                i++;
+            }
+            continue;
+        }
+        if (c === "-" && sql[i + 1] === "-") {
+            while (i < sql.length && sql[i] !== "\n")
+                i++;
+            out += "\n";
+            continue;
+        }
+        out += c;
+    }
+    return out;
+}
+function splitTopLevel(body) {
+    const parts = [];
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < body.length; i++) {
+        const c = body[i];
+        if (QUOTES.has(c)) {
+            const q = c;
+            i++;
+            while (i < body.length && body[i] !== q)
+                i++;
+            continue;
+        }
+        if (c === "(")
+            depth++;
+        else if (c === ")")
+            depth--;
+        else if (c === "," && depth === 0) {
+            parts.push(body.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(body.slice(start));
+    return parts;
+}
+const CONSTRAINT_HEADS = new Set(["PRIMARY", "UNIQUE", "KEY", "INDEX", "CONSTRAINT", "FOREIGN", "CHECK", "FULLTEXT", "SPATIAL", "EXCLUDE"]);
+const unquote = (s) => s.replace(/^[`"](.*)[`"]$/s, "$1");
+export function parseCreateTable(stmt) {
+    const sql = stripLineComments(stmt).trim();
+    const head = /^CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([`"]?[\w$.]+[`"]?)\s*\(/i.exec(sql);
+    if (!head)
+        return undefined;
+    const open = sql.indexOf("(", head[0].length - 1);
+    let depth = 0;
+    let close = -1;
+    for (let i = open; i < sql.length; i++) {
+        const c = sql[i];
+        if (QUOTES.has(c)) {
+            const q = c;
+            i++;
+            while (i < sql.length && sql[i] !== q)
+                i++;
+            continue;
+        }
+        if (c === "(")
+            depth++;
+        else if (c === ")") {
+            depth--;
+            if (depth === 0) {
+                close = i;
+                break;
+            }
+        }
+    }
+    if (close < 0)
+        return undefined;
+    const columns = [];
+    for (const raw of splitTopLevel(sql.slice(open + 1, close))) {
+        const part = raw.trim().replace(/\s+/g, " ");
+        if (part === "")
+            continue;
+        const first = part.split(/[\s(]/, 1)[0];
+        if (CONSTRAINT_HEADS.has(first.toUpperCase()))
+            continue;
+        columns.push({ name: unquote(first).toLowerCase(), ddl: part });
+    }
+    return { table: unquote(head[1]).toLowerCase(), columns };
+}
+export async function expectedTableShapes(dialect) {
+    const shapes = new Map();
+    for (const stmt of await recordEnsureStatements(dialect)) {
+        const parsed = parseCreateTable(stmt);
+        if (parsed && !shapes.has(parsed.table))
+            shapes.set(parsed.table, parsed);
+    }
+    return shapes;
+}
+export const SCHEMA_MISMATCH_ERROR_CODE = "config.schema_mismatch";
+export async function readLiveColumns(read, dialect) {
+    const live = new Map();
+    if (dialect !== "pg") {
+        for (const row of await read("SELECT table_name AS t, column_name AS c FROM information_schema.columns WHERE table_schema = DATABASE()")) {
+            addColumn(live, row["t"], row["c"], "fold");
+        }
+        return live;
+    }
+    const order = new Map();
+    for (const row of await read("SELECT s AS s, ord AS ord FROM unnest(current_schemas(false)) WITH ORDINALITY AS t(s, ord)")) {
+        const s = String(row["s"] ?? "");
+        if (s !== "")
+            order.set(s, Number(row["ord"]));
+    }
+    const winner = new Map();
+    for (const row of await read("SELECT table_schema AS s, table_name AS t, column_name AS c FROM information_schema.columns WHERE table_schema = ANY (current_schemas(false))")) {
+        const t = String(row["t"] ?? "");
+        const rank = order.get(String(row["s"] ?? "")) ?? Number.MAX_SAFE_INTEGER;
+        const held = winner.get(t);
+        if (held !== undefined && rank > held)
+            continue;
+        if (held === undefined || rank < held) {
+            winner.set(t, rank);
+            live.delete(t);
+        }
+        addColumn(live, t, row["c"], "verbatim");
+    }
+    return live;
+}
+function addColumn(live, table, column, mode) {
+    const t = mode === "fold" ? String(table ?? "").toLowerCase() : String(table ?? "");
+    const c = mode === "fold" ? String(column ?? "").toLowerCase() : String(column ?? "");
+    if (t === "" || c === "")
+        return;
+    let set = live.get(t);
+    if (set === undefined) {
+        set = new Set();
+        live.set(t, set);
+    }
+    set.add(c);
+}
+export function diffSchema(expected, live) {
+    const out = [];
+    for (const [table, shape] of expected) {
+        const cols = live.get(table);
+        if (cols === undefined)
+            continue;
+        const missing = shape.columns.filter((c) => !cols.has(c.name));
+        const known = new Set(shape.columns.map((c) => c.name));
+        const ghost = [...cols].filter((c) => !known.has(c)).sort();
+        if (missing.length > 0 || ghost.length > 0)
+            out.push({ table, missing, ghost });
+    }
+    return out;
+}
+export function describeSchemaMismatch(dialect, mismatches) {
+    const lines = [
+        `${SCHEMA_MISMATCH_ERROR_CODE}: the ${dialect === "pg" ? "PostgreSQL" : "MySQL-protocol"} database does not match this build's schema — refusing to start.`,
+        "This repo ships no ALTER seam (schema policy: the code is the single source of truth), so a drifted database is",
+        "a deployment-order problem, not something the process may quietly work around.",
+        "",
+    ];
+    for (const m of mismatches) {
+        if (m.missing.length > 0) {
+            lines.push(`  table ${m.table}: MISSING column(s) ${m.missing.map((c) => c.name).join(", ")} — the database is OLDER than this build.`);
+            for (const c of m.missing)
+                lines.push(`    ALTER TABLE ${m.table} ADD COLUMN ${c.ddl};`);
+        }
+        if (m.ghost.length > 0) {
+            lines.push(`  table ${m.table}: UNKNOWN column(s) ${m.ghost.join(", ")} — the database is NEWER than this build (a rolling window where an old replica reached an upgraded database).`);
+            lines.push(`    No ALTER is suggested for this direction: deploy the build that owns those columns (upgrade the database FIRST, then the replicas).`);
+        }
+    }
+    lines.push("", "  Two ways out: (1) deploy the build whose code matches this database; (2) rebuild the database from this build", "  (DROP DATABASE <name>; CREATE DATABASE <name>; restart — every table is recreated by ensure*Schema at boot).");
+    return lines.join("\n");
+}
+export async function assertSchemaMatchesCode(read, dialect) {
+    const expected = await expectedTableShapes(dialect);
+    let live;
+    try {
+        live = await readLiveColumns(read, dialect);
+    }
+    catch (err) {
+        throw new Error(`${SCHEMA_MISMATCH_ERROR_CODE}: could not read information_schema.columns to verify the ${dialect} schema — refusing to start ` +
+            `(an unverifiable schema is treated as a mismatch, not as a pass): ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+    }
+    if (live.size === 0) {
+        throw new Error(`${SCHEMA_MISMATCH_ERROR_CODE}: information_schema.columns returned no rows anywhere on this ${dialect} connection's schema path — refusing to start. ` +
+            `Either the connection points at an empty/foreign schema, or the account cannot see its own catalog; both make the ` +
+            `"database matches the code" check unprovable, and an unprovable protective check never passes.`);
+    }
+    const mismatches = diffSchema(expected, live);
+    if (mismatches.length > 0)
+        throw new Error(describeSchemaMismatch(dialect, mismatches));
+}
+//# sourceMappingURL=schema-consistency.js.map

package/dist/plugins/schema-ensure-legs.d.ts

@@ -0,0 +1,55 @@
+import type { PgQueryFn } from "./pg-query.js";
+/** 录制的方言。`mysql` = MySQL 协议(TiDB / InnoDB 同腿),`pg` = PostgreSQL。 */
+export type SchemaDialect = "mysql" | "pg";
+/** advisory lock 语句 —— 与 schema 无关,录制时跳过(但要答成功,否则 ensure* 走降级告警路径)。 */
+export declare const LOCK_RE: RegExp;
+/**
+ * **「一个新库对 ensure 探针怎么答」的唯一属主**(合并复审 车HB 后收口:此前生成器录制器、`test/ensure-schema.test.ts`
+ * 的假池、`test/schema-baseline-generated.test.ts` ③c 的假驱动各抄一份,S-287 加了索引探针 + PG 锁改 `got === true`
+ * 之后三份各漂一处 —— 假池答零行诱发 68 条 ALTER、③c 答 `got: 1` 让 PG 锁永远拿不到)。
+ * 返回 `undefined` = 不是探针,由调用方录制 / 执行;三条例外的理由见上面三条正则的注。
+ */
+export declare function answerEnsureProbe(text: string): {
+    rows: Record<string, unknown>[];
+} | undefined;
+/** 基线内容:建表/建索引/建扩展 + 种子行。其余一律视为**增量 seam**(违反 SCHEMA POLICY)。 */
+/**
+ * 一条 `ensure*` 腿真正需要的三个句柄面。**录制**驱动(基线生成,下面的 {@link recorder})与**真库**驱动
+ * (`scripts/db-lane-warm.ts` 的按车分库暖库)实现同一组签名 ⇒ {@link MYSQL_LEGS} / {@link PG_LEGS} 是这
+ * 两条用途的**单源**:加一条 boot ensure 腿只改那两个数组一处,基线生成与车道库暖库同时跟上。
+ *
+ * 为什么必须单源(S-285/S-256/S-343 真案):暖库此前手抄了「中央两条」(`ensureSchema`/`ensurePgSchema`),
+ * 其余 per-store 腿(现值 mysql 10 / pg 11)在**新建的**车道库上从没被建过 ⇒ 新车道首跑几十格红,而发车机那只老库因为历史上
+ * 被跑过一次就有表,于是这个缺口在老库上**恒绿**。两张手抄清单迟早分叉,正是本仓反复吃的亏。
+ */
+export interface EnsureDriver {
+    /** mysql2 Pool 形(`getConnection()` + `query`)。 */
+    readonly mysqlPool: unknown;
+    /** node-pg Pool 形(`connect()` + `query`)。 */
+    readonly pgPool: unknown;
+    /** 裸 {@link PgQueryFn} 形(per-store 的 PG ensure 直接收这个)。 */
+    readonly pgQuery: PgQueryFn;
+}
+/**
+ * 一条 `ensure*` 腿。`name` 不是装饰:`test/schema-baseline-generated.test.ts` 判据 ③b 拿它与
+ * `src/boot/stores.ts` 里真被 await 的 ensure 名对账,抓"boot 会建、录制没录"的漏族(usage_window
+ * 就是这么漏掉一整张表的 —— 那种漏在两条方言上**同时**发生,判据 ④ 的方言对拍完美对称 ⇒ 永不报警)。
+ * ⇒ 遍历与自报清单必须同一份数组,否则清单会自己腐掉,对账就成了自说自话。
+ *
+ * 第三个消费方(S-285/S-256/S-343):`scripts/db-lane-warm.ts` 拿**同一份数组**对真库跑一遍 ⇒ 按车分库的
+ * 新库与生产 boot 建出同一套表。判据 ③c 钉住「warm 跑过的腿名 == 本清单」,任何人把它抄成第二份就当场红。
+ */
+export interface EnsureLeg {
+    readonly name: string;
+    readonly run: (d: EnsureDriver) => Promise<void>;
+}
+export declare const MYSQL_LEGS: readonly EnsureLeg[];
+export declare const PG_LEGS: readonly EnsureLeg[];
+/** 生成器自报的驱动清单(判据 ③b 的对账一侧)。与上面两个数组同源 ⇒ 加腿不改这里就不会漏报。 */
+export declare const DRIVEN_ENSURES: {
+    readonly mysql: readonly string[];
+    readonly pg: readonly string[];
+};
+/** 跑一遍一条方言的真 `ensure*` 全腿,返回**录制到的语句流**(顺序即执行顺序)。纯内存,不碰数据库。 */
+export declare function recordEnsureStatements(dialect: SchemaDialect): Promise<string[]>;
+//# sourceMappingURL=schema-ensure-legs.d.ts.map

package/dist/plugins/schema-ensure-legs.js

@@ -0,0 +1,87 @@
+import { ensureSchema } from "./tidb-pool.js";
+import { ensurePgSchema } from "./pg-pool.js";
+import { ensureTiDBMemoryEngineSchema } from "./memory-engine-tidb.js";
+import { ensurePgMemoryEngineSchema } from "./memory-engine-pg.js";
+import { ensurePgMemoryEmbedderMetaSchema } from "./memory-embedder-fingerprint.js";
+import { ensureTiDBMemorySyncSchema, ensureTiDBMemoryHistorySchema } from "./memory-sync-store-tidb.js";
+import { ensurePgMemorySyncSchema, ensurePgMemoryHistorySchema } from "./memory-sync-store-pg.js";
+import { ensureTiDBRosterSchema, ensurePgRosterSchema } from "./roster-store-sql.js";
+import { ensureTiDBBackgroundAgentSchema, ensurePgBackgroundAgentSchema } from "./background-agent-store-sql.js";
+import { ensureTiDBMailboxSchema, ensurePgMailboxSchema } from "./mailbox-store-sql.js";
+import { ensureTiDBTaskAttachmentSchema, ensurePgTaskAttachmentSchema } from "./task-attachment-store.js";
+import { ensureTiDBUsageWindowSchema, ensurePgUsageWindowSchema } from "./usage-window-store-sql.js";
+import { ensureTiDBTaskListSchema, ensurePgTaskListSchema } from "./task-list-store-sql.js";
+import { ensureTiDBDeviceSchema, ensurePgDeviceSchema } from "./device-store-sql.js";
+export const LOCK_RE = /GET_LOCK|RELEASE_LOCK|pg_(try_)?advisory/i;
+const INDEX_PROBE_RE = /FROM information_schema\.statistics\b/i;
+const PG_INDEX_VALID_RE = /FROM pg_index i WHERE i\.indexrelid = to_regclass/i;
+export function answerEnsureProbe(text) {
+    if (LOCK_RE.test(text))
+        return { rows: [{ got: true }] };
+    if (INDEX_PROBE_RE.test(text))
+        return { rows: [{ present: 1 }] };
+    if (PG_INDEX_VALID_RE.test(text))
+        return { rows: [{ indisvalid: true }] };
+    return undefined;
+}
+function recorder() {
+    const sql = [];
+    const answer = (text) => (answerEnsureProbe(text) ?? { rows: [] });
+    const record = (text) => {
+        sql.push(text);
+        return answer(text);
+    };
+    const mysqlConn = {
+        query: async (text) => {
+            const r = record(text);
+            return [r.rows, []];
+        },
+        release: () => undefined,
+    };
+    return {
+        sql,
+        mysqlPool: { getConnection: async () => mysqlConn, query: async (t) => [record(t).rows, []] },
+        pgPool: { connect: async () => ({ query: async (t) => record(t), release: () => undefined }) },
+        pgQuery: async (t) => record(t),
+    };
+}
+const asMysqlPool = (p) => p;
+const asPgPool = (p) => p;
+export const MYSQL_LEGS = [
+    { name: "ensureSchema", run: (r) => ensureSchema(asMysqlPool(r.mysqlPool)) },
+    { name: "ensureTiDBMemoryEngineSchema", run: (r) => ensureTiDBMemoryEngineSchema(asMysqlPool(r.mysqlPool)) },
+    { name: "ensureTiDBMemorySyncSchema", run: (r) => ensureTiDBMemorySyncSchema(asMysqlPool(r.mysqlPool)) },
+    { name: "ensureTiDBMemoryHistorySchema", run: (r) => ensureTiDBMemoryHistorySchema(asMysqlPool(r.mysqlPool)) },
+    { name: "ensureTiDBRosterSchema", run: (r) => ensureTiDBRosterSchema(asMysqlPool(r.mysqlPool)) },
+    { name: "ensureTiDBBackgroundAgentSchema", run: (r) => ensureTiDBBackgroundAgentSchema(asMysqlPool(r.mysqlPool)) },
+    { name: "ensureTiDBMailboxSchema", run: (r) => ensureTiDBMailboxSchema(asMysqlPool(r.mysqlPool)) },
+    { name: "ensureTiDBTaskAttachmentSchema", run: (r) => ensureTiDBTaskAttachmentSchema(asMysqlPool(r.mysqlPool)) },
+    { name: "ensureTiDBUsageWindowSchema", run: (r) => ensureTiDBUsageWindowSchema(asMysqlPool(r.mysqlPool)) },
+    { name: "ensureTiDBTaskListSchema", run: (r) => ensureTiDBTaskListSchema(asMysqlPool(r.mysqlPool)) },
+    { name: "ensureTiDBDeviceSchema", run: (r) => ensureTiDBDeviceSchema(asMysqlPool(r.mysqlPool)) },
+];
+export const PG_LEGS = [
+    { name: "ensurePgSchema", run: (r) => ensurePgSchema(asPgPool(r.pgPool)) },
+    { name: "ensurePgMemoryEngineSchema", run: (r) => ensurePgMemoryEngineSchema(r.pgQuery) },
+    { name: "ensurePgMemoryEmbedderMetaSchema", run: (r) => ensurePgMemoryEmbedderMetaSchema(r.pgQuery) },
+    { name: "ensurePgMemorySyncSchema", run: (r) => ensurePgMemorySyncSchema(r.pgQuery) },
+    { name: "ensurePgMemoryHistorySchema", run: (r) => ensurePgMemoryHistorySchema(r.pgQuery) },
+    { name: "ensurePgRosterSchema", run: (r) => ensurePgRosterSchema(r.pgQuery) },
+    { name: "ensurePgBackgroundAgentSchema", run: (r) => ensurePgBackgroundAgentSchema(r.pgQuery) },
+    { name: "ensurePgMailboxSchema", run: (r) => ensurePgMailboxSchema(r.pgQuery) },
+    { name: "ensurePgTaskAttachmentSchema", run: (r) => ensurePgTaskAttachmentSchema(r.pgQuery) },
+    { name: "ensurePgUsageWindowSchema", run: (r) => ensurePgUsageWindowSchema(r.pgQuery) },
+    { name: "ensurePgTaskListSchema", run: (r) => ensurePgTaskListSchema(r.pgQuery) },
+    { name: "ensurePgDeviceSchema", run: (r) => ensurePgDeviceSchema(r.pgQuery) },
+];
+export const DRIVEN_ENSURES = {
+    mysql: MYSQL_LEGS.map((l) => l.name),
+    pg: PG_LEGS.map((l) => l.name),
+};
+export async function recordEnsureStatements(dialect) {
+    const r = recorder();
+    for (const leg of dialect === "mysql" ? MYSQL_LEGS : PG_LEGS)
+        await leg.run(r);
+    return r.sql;
+}
+//# sourceMappingURL=schema-ensure-legs.js.map

package/dist/plugins/session-policy-store-sql.js

@@ -1,12 +1,26 @@
 import { createHash } from "node:crypto";
 import { loosenReasons, SessionPolicyError, normalizeRules, stripRev } from "@sema-agent/core";
+import { readSessionPermissionRules, describeSessionPermissionRulesProblem } from "../session-policy-wire.js";
 import { pgHasUnstorable } from "./pg-safe-json.js";
 import { mysqlDriver, pgDriver } from "./sql-driver.js";
 import { isDeadlockError, isDupKeyError } from "./sql-errors.js";
 export const policyKeyFor = (sessionId, principal) => createHash("sha256").update(JSON.stringify([sessionId, principal ?? null])).digest("hex");
 const policyKey = policyKeyFor;
 const RETRY_LIMIT = 8;
-const parseRules = (v) => (typeof v === "string" ? JSON.parse(v) : v);
+function readRulesBody(text, where) {
+    let body;
+    try {
+        body = JSON.parse(text);
+    }
+    catch {
+        throw new SessionPolicyError("corrupt", `session rules row ${where} carries a rules body that is not JSON (a torn or hand-edited write) — refusing rather than serve a row nobody can read as rules`);
+    }
+    const read = readSessionPermissionRules(body);
+    if (read.problem !== undefined) {
+        throw new SessionPolicyError("corrupt", `session rules row ${where} carries a malformed rules body (${describeSessionPermissionRulesProblem(read.problem)}) — refusing rather than serve it as an EMPTY rule set, which would silently drop every tightening this session carries`);
+    }
+    return read.rules;
+}
 function rowToStored(r, where) {
     const rev = Number(r.rev);
     if (!Number.isFinite(rev) || !Number.isInteger(rev) || rev < 1) {
@@ -16,7 +30,11 @@ function rowToStored(r, where) {
     if (!Number.isFinite(gen) || !Number.isInteger(gen) || gen < 0) {
         throw new SessionPolicyError("corrupt", `session rules row ${where} carries lineage gen ${String(r.gen)} — a generation is a whole number ≥ 0; refusing rather than let a reader judge lineage by a value nothing minted`);
     }
-    return { ...parseRules(r.rules), rev, gen };
+    const raw = r.rules;
+    if (typeof raw !== "string") {
+        throw new Error(`session rules row ${where}: the read did not project the rules column as TEXT (got ${typeof raw}) — the SELECT and rowToStored have drifted apart`);
+    }
+    return { ...readRulesBody(raw, where), rev, gen };
 }
 export class SqlSessionPolicyStore {
     db;
@@ -30,13 +48,13 @@ export class SqlSessionPolicyStore {
         return isDupKeyError(this.db.dialect, e);
     }
     async getRules(sessionId, principal) {
-        const { rows } = await this.db.query(this.q("SELECT rules, rev, gen FROM session_policy WHERE policy_key = ?", "SELECT rules, rev, gen FROM session_policy WHERE policy_key = $1"), [policyKey(sessionId, principal)]);
+        const { rows } = await this.db.query(this.q("SELECT CAST(rules AS CHAR) AS rules, rev, gen FROM session_policy WHERE policy_key = ?", "SELECT rules::text AS rules, rev, gen FROM session_policy WHERE policy_key = $1"), [policyKey(sessionId, principal)]);
         if (!rows[0])
             return null;
         return rowToStored(rows[0], `for session ${JSON.stringify(sessionId)}`);
     }
     async listBySession(sessionId) {
-        const { rows } = await this.db.query(this.q("SELECT principal, rules, rev, gen FROM session_policy WHERE session_id = ?", "SELECT principal, rules, rev, gen FROM session_policy WHERE session_id = $1"), [sessionId]);
+        const { rows } = await this.db.query(this.q("SELECT principal, CAST(rules AS CHAR) AS rules, rev, gen FROM session_policy WHERE session_id = ?", "SELECT principal, rules::text AS rules, rev, gen FROM session_policy WHERE session_id = $1"), [sessionId]);
         return rows.map((r) => ({
             principal: r.principal == null ? undefined : String(r.principal),
             rules: rowToStored(r, `for session ${JSON.stringify(sessionId)} (enumeration)`),
@@ -45,7 +63,7 @@ export class SqlSessionPolicyStore {
     async putRules(sessionId, principal, rules, opts) {
         const key = policyKey(sessionId, principal);
         return this.retrying(() => this.tx(async (conn) => {
-            const { rows } = await conn.query(this.q("SELECT rules, rev, gen FROM session_policy WHERE policy_key = ? FOR UPDATE", "SELECT rules, rev, gen FROM session_policy WHERE policy_key = $1 FOR UPDATE"), [key]);
+            const { rows } = await conn.query(this.q("SELECT CAST(rules AS CHAR) AS rules, rev, gen FROM session_policy WHERE policy_key = ? FOR UPDATE", "SELECT rules::text AS rules, rev, gen FROM session_policy WHERE policy_key = $1 FOR UPDATE"), [key]);
             const prior = rows[0] ? rowToStored(rows[0], `for session ${JSON.stringify(sessionId)} (pre-write snapshot)`) : undefined;
             const priorRev = prior?.rev ?? 0;
             if (opts?.expectedRev !== undefined && priorRev !== opts.expectedRev) {

package/dist/rules-consent.d.ts

@@ -1,4 +1,4 @@
-import { type DirectWritableRuleBehavior } from "./permission-rule-vocab.js";
+import { type DirectWritableRuleBehavior, type RemovalLiveness } from "./permission-rule-vocab.js";
 import { type RuleOwner, type ImportPreview, type RedeemedBatchMember, type ImportedSettingsLayer, type PersistedRule, type RuleBehavior, type RuleCandidate, type EffectivePermissionRule, type RemoveResult, type EditedRuleTextPrecheck, type RuleScope, type RuleOffer } from "@sema-agent/core";
 import type { DurableRulePartitionProvider, PermissionRuleStoreProvider, RuleApprovalRecordStore } from "@sema-agent/core";
 import { type RuleImportTicket, type RuleTicketPurpose, type RuleTicketReclaimResult, type RuleTicketRedeemResult, type RuleTicketSnapshot } from "./plugins/permission-rule-store-sql.js";
@@ -599,15 +599,36 @@ export type RuleWritten =
 {
     status: "persisted" | "no-op";
     rev: number;
+    stillLive: Extract<RemovalLiveness, "yes">;
     row: PersistedRuleWireRow;
 }
+/** 同上两个词,但**写后读回时它已经不在了** —— 一次合法并发(自己的 / operator 的撤销挤在了「引擎落了
+ *  dot」与「读回那一行」之间)。
+ *
+ *  🔴 B3(core fable 复审 2026-09-20):这一形**不是** `indeterminate`。core 已经答了 `added` 并把 `rev`
+ *  交到手里 —— 「写没写」这一问有答案;没答案的是「它现在还站着吗」,而那是**另一个问题**,撤销面早就有
+ *  一只键在回答它({@link RemovalLiveness} 三词)。折成 `indeterminate` 的代价有名字:那条腿的处置是
+ *  「retry」,而照着重试会把**刚刚被人撤掉的收紧重新立起来**(core `AddResult.failed` 头注逐字警告过
+ *  这条路)。
+ *
+ *  🔴 `row` 在这一支**缺席**,而缺席由 `stillLive` 判别(不是「未知」):没有活行可端的时候编一行出来
+ *  才是谎 —— 亲读 core 的 `AddResult`,`added` 臂只有 `{status, rev, dot}`,**刻意**不带行(头注:之后
+ *  落地的撤销是「`list()` 答的普通后续事件」),而本仓的行形带着 `status: "live"` 这一格,给一行已经
+ *  不在的规则铸它就是第二个谎。 */
+ | {
+    status: "persisted" | "no-op";
+    rev: number;
+    stillLive: Extract<RemovalLiveness, "no">;
+    row?: undefined;
+}
 /** 裁定性不收(内容判据 / 方向判据)。`detail` 是给人看的那一半,`reason` 是给客户端分流的那一半。 */
  | {
     status: "rejected";
     reason: LocalImportRefusalCode;
     detail: string;
 }
-/** **不知道落没落**:店在这一条上出了状况。如实编,禁猜(端点侧 503 + 指路 `GET /v1/rules` 对账)。 */
+/** **不知道落没落**:店在这一条上出了状况(core 的 `failed` 两种强度)。如实编,禁猜(端点侧 503 +
+ *  指路 `GET /v1/rules` 对账)。**「写落了随后被撤」不在本臂** —— 那一形有答案,见上面 `stillLive:"no"`。 */
  | {
     status: "indeterminate";
     detail: string;

package/dist/rules-consent.js

@@ -739,7 +739,7 @@ export function createRuleConsentLane(stores, opts) {
             const before = await lane.listRules(input.principal);
             const standing = rowOf(before.rows);
             if (standing !== undefined)
-                return { status: "no-op", rev: before.rev, row: standing };
+                return { status: "no-op", rev: before.rev, stillLive: "yes", row: standing };
             const screened = screenLocalImportRow(row);
             if ("reason" in screened)
                 return { status: "rejected", reason: screened.reason, detail: screened.detail };
@@ -758,15 +758,17 @@ export function createRuleConsentLane(stores, opts) {
             }
             const readBack = await lane.listRules(input.principal);
             const landed = rowOf(readBack.rows);
+            const status = added.status === "no-op" ? "no-op" : "persisted";
             if (landed === undefined) {
                 localImportLogger.warn("direct_rule_write_vanished_before_read_back", {
                     behavior: input.behavior,
                     scope: row.scope,
-                    note: "the store reported this rule as landed, and it was already gone when the row was read back — a revocation landed in between",
+                    note: "the store reported this rule as in effect, and it was already gone when the row was read back — a revocation landed in between",
+                    wrote: status === "persisted",
                 });
-                return { status: "indeterminate", detail: "this rule landed and was already gone when it was read back — a revocation landed in between" };
+                return { status, rev: added.rev, stillLive: "no" };
             }
-            return { status: added.status === "no-op" ? "no-op" : "persisted", rev: added.rev, row: landed };
+            return { status, rev: added.rev, stillLive: "yes", row: landed };
         },
     };
     return lane;

package/dist/run-local.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { DEFAULT_MODEL_REF } from "./model-select.js";
-import { terminalProjection } from "@sema-agent/core";
+import { outwardPlane } from "./terminal.js";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { realpathSync } from "node:fs";
@@ -535,7 +535,7 @@ export async function runLocal(argv, deps = {}) {
         print(result.result);
     }
     else {
-        const plane = terminalProjection(result.terminal);
+        const plane = outwardPlane(result.terminal);
         const salvage = result.result || result.salvagedOutput || plane.blockedReason || "";
         if (salvage)
             print(salvage);