@sema-agent/server 7.145.0 → 7.146.0

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

@@ -1,10 +1,10 @@
 import { jaccardDistance, termSet } from "@sema-agent/core";
 import { readFrontmatterColumn } from "./memory-engine-vector-util.js";
 import { decodeJsonColumn, foldJsonColumn, jsonColumnText } from "./sql-json-column.js";
-import { computeEntryRev, serializeEntryFile } from "@sema-agent/core";
-import { pgHasUnstorable } from "./pg-safe-json.js";
-import { assertMemoryScopeWidth, memoryEntryKeyWidthRefusal } from "./memory-key-guards.js";
-import { ambiguousOriginRefusal, createBatchCommittedBaseline, exposureBandOf, exposureCarriage, originWhitewashRefusal, rememberBatchCommitted, distilledWhitewashRefusal, distilledCarriage, unknownPatchOpRefusal, } from "./memory-origin-law.js";
+import { serializeEntryFile } from "@sema-agent/core";
+import { assertMemoryScopeWidth } from "./memory-key-guards.js";
+import { exposureBandOf, exposureCarriage, distilledCarriage } from "./memory-origin-law.js";
+import { applySqlPatches, } from "./memory-engine-sql-apply.js";
 import { isMysqlDupKeyError } from "./sql-errors.js";
 import { ensureIndexes } from "./ensure-index.js";
 import { MEMORY_ENGINE_INDEXES, PG_MEMORY_ENGINE_TABLES } from "./memory-engine-pg.js";
@@ -40,6 +40,7 @@ const isDupEntry = isMysqlDupKeyError;
 function isPrimaryKeyDup(err) {
     return isDupEntry(err) && /for key '[^']*PRIMARY'/i.test(String(err.message ?? ""));
 }
+const AT_PLANNED_PROJECTION = "CAST(scope AS BINARY) = CAST(? AS BINARY) AND CAST(slug AS BINARY) = CAST(? AS BINARY)";
 function inPlaceholders(count) {
     return Array.from({ length: count }, () => "?").join(", ");
 }
@@ -56,6 +57,7 @@ export class TiDBMemoryEngineBackend {
     clock;
     history;
     historyRowsLost = 0;
+    leg;
     get vectorMode() {
         return "lexical";
     }
@@ -66,6 +68,18 @@ export class TiDBMemoryEngineBackend {
         }
         this.clock = opts.now ?? Date.now;
         this.history = opts.history;
+        this.leg = {
+            reads: { rowOf: (id) => this.rowOf(id), idsAt: (scope, slug) => this.idsAt(scope, slug) },
+            writes: {
+                prepare: async () => undefined,
+                add: (w, prepared, confirm) => this.writeAdd(w, prepared, confirm),
+                update: (w, prepared, confirm) => this.writeUpdate(w, prepared, confirm),
+                remove: (w, confirm) => this.writeDelete(w, confirm),
+            },
+            unstorableReason: "unstorable_bytes (utf8mb4 cannot store NUL/lone surrogates without mangling; strip them at the source — the store never rewrites content)",
+            now: () => this.clock(),
+            ...(this.history !== undefined ? { appendHistory: (rows) => this.appendHistory(rows) } : {}),
+        };
     }
     async selectRows(sql, params) {
         const [rows] = await this.pool.query(sql, params);
@@ -141,242 +155,98 @@ export class TiDBMemoryEngineBackend {
         scored.sort((a, b) => (bands ? exposureBandOf(a) - exposureBandOf(b) : 0) || a.score - b.score || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
         return scored.slice(0, limit);
     }
-    async applyPatches(patches) {
-        const report = { applied: [], conflicts: [] };
-        const nonDeleteIds = new Set();
-        const plannedSlugs = new Set();
-        const historyRows = [];
-        const originBaseline = createBatchCommittedBaseline();
-        for (const patch of patches) {
-            try {
-                if (patch.op !== "delete") {
-                    if (nonDeleteIds.has(patch.id)) {
-                        report.conflicts.push({ op: patch.op, id: patch.id, reason: "duplicate id in batch: another add/update for this id is already planned (copied file keeping its frontmatter id?)" });
-                        continue;
-                    }
-                    nonDeleteIds.add(patch.id);
-                }
-                await this.applyOne(patch, report, plannedSlugs, historyRows, originBaseline);
-            }
-            catch (err) {
-                report.conflicts.push({ op: patch.op, id: patch.id, reason: `io error: ${err instanceof Error ? err.message : String(err)}` });
-            }
-        }
-        if (this.history && historyRows.length > 0) {
-            try {
-                await this.history.appendHistory(historyRows);
-            }
-            catch (err) {
-                this.historyRowsLost += historyRows.length;
-                console.warn(`TiDBMemoryEngineBackend: best-effort history append failed (${historyRows.length} row(s) lost, ${this.historyRowsLost} cumulative — audit face only, entries committed): ${err instanceof Error ? err.message : String(err)}`);
-            }
-        }
-        return report;
+    admitsLandings = true;
+    async applyPatches(patches, opts) {
+        return applySqlPatches(patches, opts, this.leg);
+    }
+    async rowOf(id) {
+        const rows = await this.selectRows(`SELECT slug, rev, scope, ${jsonColumnText("mysql", "frontmatter")} FROM ${TIDB_MEMORY_ENGINE_TABLES.entry} WHERE id = ?`, [id]);
+        const r = rows[0];
+        if (r === undefined)
+            return undefined;
+        return { scope: String(r.scope), slug: String(r.slug), rev: String(r.rev), frontmatter: readFrontmatter(r.frontmatter, id) };
     }
-    async applyOne(patch, report, plannedSlugs, historyRows, originBaseline) {
+    async idsAt(scope, slug) {
+        const rows = await this.selectRows(`SELECT id FROM ${TIDB_MEMORY_ENGINE_TABLES.entry} WHERE scope = ? AND slug = ?`, [scope, slug]);
+        return rows.map((r) => String(r.id));
+    }
+    async freshRow(id) {
+        const rows = await this.selectRows(`SELECT rev, scope, slug FROM ${TIDB_MEMORY_ENGINE_TABLES.entry} WHERE id = ?`, [id]);
+        const r = rows[0];
+        return r === undefined ? undefined : { rev: String(r.rev), scope: String(r.scope), slug: String(r.slug) };
+    }
+    async writeAdd({ stored, rev, prior }, _prepared, confirm) {
         const T = TIDB_MEMORY_ENGINE_TABLES.entry;
-        {
-            const refusal = unknownPatchOpRefusal(patch.op);
-            if (refusal !== undefined) {
-                report.conflicts.push({ op: patch.op, id: patch.id, reason: refusal });
-                return;
-            }
-        }
-        if (patch.op !== "delete" && patch.entry !== undefined && patch.entry.id !== patch.id) {
-            report.conflicts.push({ op: patch.op, id: patch.id, reason: `patch id ${JSON.stringify(patch.id)} != entry id ${JSON.stringify(patch.entry.id)} (malformed patch refused)` });
-            return;
-        }
-        if (patch.op !== "delete" && patch.entry !== undefined) {
-            const refusal = memoryEntryKeyWidthRefusal(patch.entry.scope, patch.entry.slug);
-            if (refusal !== undefined) {
-                report.conflicts.push({ op: patch.op, id: patch.id, reason: refusal });
-                return;
-            }
-        }
-        if (patch.op !== "delete" && patch.entry !== undefined) {
-            const refusal = ambiguousOriginRefusal(patch.entry.frontmatter);
-            if (refusal !== undefined) {
-                report.conflicts.push({ op: patch.op, id: patch.id, reason: refusal });
-                return;
-            }
-        }
-        if (patch.op === "add") {
-            const entry = patch.entry;
-            if (!entry) {
-                report.conflicts.push({ op: "add", id: patch.id, reason: "add patch without an entry" });
-                return;
-            }
-            if (pgHasUnstorable(entry.frontmatter) || pgHasUnstorable(entry.body) || pgHasUnstorable(entry.slug)) {
-                report.conflicts.push({ op: "add", id: entry.id, reason: "unstorable_bytes (utf8mb4 cannot store NUL/lone surrogates without mangling; strip them at the source — the store never rewrites content)" });
-                return;
-            }
-            const prior = await this.selectRows(`SELECT scope, slug, rev, ${jsonColumnText("mysql", "frontmatter")} FROM ${T} WHERE id = ?`, [entry.id]);
-            const priorRow = prior.length > 0 ? prior[0] : undefined;
-            let existsById = priorRow !== undefined;
-            {
-                const committedBaseFm = rememberBatchCommitted(originBaseline, entry.id, priorRow !== undefined ? readFrontmatter(priorRow.frontmatter, entry.id) : undefined);
-                const refusal = originWhitewashRefusal("add", committedBaseFm, entry.frontmatter);
-                if (refusal !== undefined) {
-                    report.conflicts.push({ op: "add", id: entry.id, reason: refusal });
-                    return;
-                }
-                const dRefusal = distilledWhitewashRefusal("add", committedBaseFm, entry.frontmatter);
-                if (dRefusal !== undefined) {
-                    report.conflicts.push({ op: "add", id: entry.id, reason: dRefusal });
-                    return;
-                }
-            }
-            if (patch.guard === "absent" && priorRow) {
-                const currentRev = String(priorRow.rev);
-                if (currentRev !== computeEntryRev(entry)) {
-                    report.conflicts.push({ op: "add", id: entry.id, reason: "add_guard_absent_conflict (id already exists at a different rev; add-if-absent refuses to overwrite)", currentRev });
-                    return;
-                }
-                if (String(priorRow.scope) !== entry.scope || String(priorRow.slug) !== entry.slug) {
-                    report.conflicts.push({ op: "add", id: entry.id, reason: `add_guard_absent_conflict (id already exists at the same rev but a different projection ${JSON.stringify(`${String(priorRow.scope)}/${String(priorRow.slug)}`)}; add-if-absent refuses to duplicate)`, currentRev });
-                    return;
-                }
-            }
-            if (priorRow) {
-                const held = String(priorRow.scope);
-                if (held !== entry.scope) {
-                    report.conflicts.push({ op: "add", id: entry.id, reason: `id already exists in scope ${JSON.stringify(held)} (cross-scope add refused)` });
-                    return;
-                }
-            }
-            let slug = entry.slug;
-            for (let n = 2;; n++) {
-                const derivedRefusal = memoryEntryKeyWidthRefusal(entry.scope, slug);
-                if (derivedRefusal !== undefined) {
-                    report.conflicts.push({ op: "add", id: entry.id, reason: `${derivedRefusal} (slug collision suffix "-${n - 1}" no longer fits the column — shorten the entry name)` });
-                    return;
-                }
-                const key = `${entry.scope}|${slug}`;
-                if (!plannedSlugs.has(key)) {
-                    const taken = await this.selectRows(`SELECT id FROM ${T} WHERE scope = ? AND slug = ?`, [entry.scope, slug]);
-                    const otherId = taken.find((r) => String(r.id) !== entry.id);
-                    if (!otherId) {
-                        const stored = { ...entry, slug };
-                        const rev = computeEntryRev(stored);
-                        const sizeBytes = Buffer.byteLength(serializeEntryFile(stored), "utf8");
-                        try {
-                            if (existsById) {
-                                const res = await this.write(`UPDATE ${T} SET scope = ?, slug = ?, frontmatter = ?, body = ?, rev = ?, mtime_ms = ?, size_bytes = ?, embedding = NULL WHERE id = ?`, [stored.scope, stored.slug, JSON.stringify(stored.frontmatter), stored.body, rev, this.clock(), sizeBytes, stored.id]);
-                                if (res.affectedRows === 0) {
-                                    const still = await this.selectRows(`SELECT id FROM ${T} WHERE id = ?`, [stored.id]);
-                                    if (still.length === 0) {
-                                        existsById = false;
-                                        continue;
-                                    }
-                                }
-                            }
-                            else {
-                                await this.write(`INSERT INTO ${T} (id, scope, slug, frontmatter, body, rev, mtime_ms, size_bytes, embedding) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL)`, [stored.id, stored.scope, stored.slug, JSON.stringify(stored.frontmatter), stored.body, rev, this.clock(), sizeBytes]);
-                            }
+        const sizeBytes = Buffer.byteLength(serializeEntryFile(stored), "utf8");
+        let overwrite = prior;
+        for (;;) {
+            try {
+                if (overwrite !== undefined) {
+                    const params = [stored.scope, stored.slug, JSON.stringify(stored.frontmatter), stored.body, rev, this.clock(), sizeBytes, stored.id, overwrite.scope, overwrite.slug];
+                    confirm();
+                    const res = await this.write(`UPDATE ${T} SET scope = ?, slug = ?, frontmatter = ?, body = ?, rev = ?, mtime_ms = ?, size_bytes = ?, embedding = NULL WHERE id = ? AND ${AT_PLANNED_PROJECTION}`, params);
+                    if (res.affectedRows === 0) {
+                        const fresh = await this.freshRow(stored.id);
+                        if (fresh === undefined) {
+                            overwrite = undefined;
+                            continue;
                         }
-                        catch (err) {
-                            if (isDupEntry(err)) {
-                                if (isPrimaryKeyDup(err)) {
-                                    existsById = true;
-                                    continue;
-                                }
-                                slug = `${entry.slug}-${n}`;
-                                continue;
-                            }
-                            throw err;
+                        if (fresh.scope !== overwrite.scope || fresh.slug !== overwrite.slug)
+                            return { kind: "moved" };
+                        if (fresh.rev !== rev) {
+                            throw new Error(`memory-engine: the add of ${JSON.stringify(stored.id)} wrote no row, yet the row is still at the planned projection with other content — refusing to report it either way`);
                         }
-                        plannedSlugs.add(key);
-                        report.applied.push({ op: "add", id: stored.id, slug: stored.slug });
-                        if (this.history)
-                            historyRows.push({ id: stored.id, rev, op: "add", scope: stored.scope, snapshot: { ...stored, rev }, writtenAtMs: this.clock() });
-                        return;
                     }
                 }
-                slug = `${entry.slug}-${n}`;
-            }
-        }
-        const cur = await this.selectRows(`SELECT slug, rev, scope, ${jsonColumnText("mysql", "frontmatter")} FROM ${T} WHERE id = ?`, [patch.id]);
-        if (cur.length === 0) {
-            report.conflicts.push({ op: patch.op, id: patch.id, reason: "unknown id (entry not found in backend)" });
-            return;
-        }
-        const currentRev = String(cur[0].rev);
-        const currentSlug = String(cur[0].slug);
-        const currentScope = String(cur[0].scope);
-        const committedFm = readFrontmatter(cur[0].frontmatter, patch.id);
-        const committedBaseFm = rememberBatchCommitted(originBaseline, patch.id, committedFm);
-        if (patch.op === "update" && patch.entry !== undefined) {
-            if (committedFm.provenance?.kind === "repo_file") {
-                const next = patch.entry.frontmatter;
-                const stripsProvenance = next.provenance === undefined;
-                const stripsTrust = committedFm.trust !== undefined && next.trust === undefined;
-                if (stripsProvenance || stripsTrust) {
-                    report.conflicts.push({
-                        op: "update",
-                        id: patch.id,
-                        reason: `repo_file provenance whitewash refused: update drops ${stripsProvenance ? "provenance" : "trust"} from a repo-ingested entry (malformed patch refused)`,
-                    });
-                    return;
+                else {
+                    const params = [stored.id, stored.scope, stored.slug, JSON.stringify(stored.frontmatter), stored.body, rev, this.clock(), sizeBytes];
+                    confirm();
+                    await this.write(`INSERT INTO ${T} (id, scope, slug, frontmatter, body, rev, mtime_ms, size_bytes, embedding) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL)`, params);
                 }
             }
-            const refusal = originWhitewashRefusal("update", committedBaseFm, patch.entry.frontmatter);
-            if (refusal !== undefined) {
-                report.conflicts.push({ op: "update", id: patch.id, reason: refusal });
-                return;
-            }
-            const dRefusal = distilledWhitewashRefusal("update", committedBaseFm, patch.entry.frontmatter);
-            if (dRefusal !== undefined) {
-                report.conflicts.push({ op: "update", id: patch.id, reason: dRefusal });
-                return;
-            }
-        }
-        if (patch.baseRev !== undefined && patch.baseRev !== currentRev) {
-            report.conflicts.push({ op: patch.op, id: patch.id, reason: "rev mismatch (concurrent change)", baseRev: patch.baseRev, currentRev });
-            return;
-        }
-        if (patch.op === "delete") {
-            const res = await this.write(`DELETE FROM ${T} WHERE id = ? AND rev = ?`, [patch.id, currentRev]);
-            if (res.affectedRows === 0) {
-                report.conflicts.push({ op: "delete", id: patch.id, reason: "rev mismatch (concurrent change)", baseRev: patch.baseRev, currentRev: await this.freshRev(patch.id, currentRev) });
-                return;
+            catch (err) {
+                if (!isDupEntry(err))
+                    throw err;
+                return isPrimaryKeyDup(err) ? { kind: "moved" } : { kind: "slug-taken" };
             }
-            report.applied.push({ op: "delete", id: patch.id, slug: currentSlug });
-            if (this.history)
-                historyRows.push({ id: patch.id, rev: `tombstone:${currentRev}`, prevRev: currentRev, op: "delete", scope: currentScope, writtenAtMs: this.clock() });
-            return;
-        }
-        const entry = patch.entry;
-        if (!entry) {
-            report.conflicts.push({ op: "update", id: patch.id, reason: "update patch without an entry" });
-            return;
+            return { kind: "committed" };
         }
-        if (pgHasUnstorable(entry.frontmatter) || pgHasUnstorable(entry.body) || pgHasUnstorable(entry.slug)) {
-            report.conflicts.push({ op: "update", id: patch.id, reason: "unstorable_bytes (utf8mb4 cannot store NUL/lone surrogates without mangling; strip them at the source — the store never rewrites content)" });
+    }
+    async writeUpdate({ entry, rev, currentRev, current, baseRev }, _prepared, confirm) {
+        const params = [entry.scope, entry.slug, JSON.stringify(entry.frontmatter), entry.body, rev, this.clock(), Buffer.byteLength(serializeEntryFile(entry), "utf8"), entry.id, currentRev, current.scope, current.slug];
+        confirm();
+        const res = await this.write(`UPDATE ${TIDB_MEMORY_ENGINE_TABLES.entry} SET scope = ?, slug = ?, frontmatter = ?, body = ?, rev = ?, mtime_ms = ?, size_bytes = ?, embedding = NULL WHERE id = ? AND rev = ? AND ${AT_PLANNED_PROJECTION}`, params);
+        if (res.affectedRows > 0)
+            return { kind: "committed" };
+        const fresh = await this.freshRow(entry.id);
+        const atPlanned = fresh !== undefined && fresh.rev === currentRev && fresh.scope === current.scope && fresh.slug === current.slug;
+        const writesNothingNew = rev === currentRev && entry.scope === current.scope && entry.slug === current.slug;
+        if (atPlanned && writesNothingNew)
+            return { kind: "committed" };
+        if (fresh !== undefined && fresh.rev === currentRev && (fresh.scope !== current.scope || fresh.slug !== current.slug))
+            return { kind: "moved" };
+        return { kind: "lost", conflict: { op: "update", id: entry.id, reason: "rev mismatch (concurrent change)", baseRev, currentRev: fresh?.rev ?? currentRev } };
+    }
+    async writeDelete({ id, currentRev, current, baseRev }, confirm) {
+        confirm();
+        const res = await this.write(`DELETE FROM ${TIDB_MEMORY_ENGINE_TABLES.entry} WHERE id = ? AND rev = ? AND ${AT_PLANNED_PROJECTION}`, [id, currentRev, current.scope, current.slug]);
+        if (res.affectedRows > 0)
+            return { kind: "committed" };
+        const fresh = await this.freshRow(id);
+        if (fresh !== undefined && fresh.rev === currentRev && (fresh.scope !== current.scope || fresh.slug !== current.slug))
+            return { kind: "moved" };
+        return { kind: "lost", conflict: { op: "delete", id, reason: "rev mismatch (concurrent change)", baseRev, currentRev: fresh?.rev ?? currentRev } };
+    }
+    async appendHistory(rows) {
+        if (!this.history)
             return;
+        try {
+            await this.history.appendHistory(rows);
         }
-        const rev = computeEntryRev(entry);
-        const res = await this.write(`UPDATE ${T} SET scope = ?, slug = ?, frontmatter = ?, body = ?, rev = ?, mtime_ms = ?, size_bytes = ?, embedding = NULL WHERE id = ? AND rev = ?`, [entry.scope, entry.slug, JSON.stringify(entry.frontmatter), entry.body, rev, this.clock(), Buffer.byteLength(serializeEntryFile(entry), "utf8"), entry.id, currentRev]);
-        if (res.affectedRows === 0) {
-            const fresh = await this.freshRevOrMissing(entry.id);
-            if (fresh === rev) {
-                report.applied.push({ op: "update", id: entry.id, slug: entry.slug });
-                if (this.history)
-                    historyRows.push({ id: entry.id, rev, prevRev: currentRev, op: "update", scope: entry.scope, snapshot: { ...entry, rev }, writtenAtMs: this.clock() });
-                return;
-            }
-            report.conflicts.push({ op: "update", id: patch.id, reason: "rev mismatch (concurrent change)", baseRev: patch.baseRev, currentRev: fresh ?? currentRev });
-            return;
+        catch (err) {
+            this.historyRowsLost += rows.length;
+            console.warn(`TiDBMemoryEngineBackend: best-effort history append failed (${rows.length} row(s) lost, ${this.historyRowsLost} cumulative — audit face only, entries committed): ${err instanceof Error ? err.message : String(err)}`);
         }
-        report.applied.push({ op: "update", id: entry.id, slug: entry.slug });
-        if (this.history)
-            historyRows.push({ id: entry.id, rev, prevRev: currentRev, op: "update", scope: entry.scope, snapshot: { ...entry, rev }, writtenAtMs: this.clock() });
-    }
-    async freshRevOrMissing(id) {
-        const rows = await this.selectRows(`SELECT rev FROM ${TIDB_MEMORY_ENGINE_TABLES.entry} WHERE id = ?`, [id]);
-        return rows.length > 0 ? String(rows[0].rev) : undefined;
-    }
-    async freshRev(id, fallback) {
-        return (await this.freshRevOrMissing(id)) ?? fallback;
     }
     async getConsolidationCursor(scope) {
         const rows = await this.selectRows(`SELECT \`cursor\` FROM ${TIDB_MEMORY_ENGINE_TABLES.cursor} WHERE scope = ?`, [scope]);

package/dist/plugins/memory-key-guards.d.ts

@@ -22,7 +22,7 @@ export declare const MEMORY_SYNC_PEER_COLUMN_CHARS = 190;
 export declare function assertSlugWidth(slug: string): void;
 export declare function assertMemoryScopeWidth(scope: string): void;
 /**
- * 一个 entry 写(add / update)的两个键宽一起判 —— 两方言的 `applyOne` 在**任何 I/O 之前**调用它。
+ * 一个 entry 写(add / update)的两个键宽一起判 —— 两方言共用的判(`memory-engine-sql-apply.ts` 的 `planSqlPatch`)在**任何 I/O 之前**调用它。
  *
  * 为什么两条腿共用一个入口而不是各自展开:add 与 update 写的是**同两列**(update 的
  * `SET scope = …, slug = …` 会改盘也会改名),R5 那批只护住了 add ⇒ 一次改名就能把超宽 slug 送进

package/dist/plugins/memory-origin-law.d.ts

@@ -30,8 +30,8 @@
  * ① **判据本身**({@link originWhitewashRefusal}):`committedOriginOf` / `originEquals` 都用 core 的
  *    导出实现,**不重写** —— 它们要处理 `frontmatter.origin` 与「保留在 `extra` 里的 origin 形字节块」
  *    两种承载形(legacy / 外来),自己写一份近似的等于给洗白留一条旁路。
- * ② **批次基线**({@link rememberBatchOrigin}):两支 SQL 后端逐条 patch 直打真库(没有 File backend
- *    那种「先规划整批再落盘」的阶段),所以同批 `delete` 之后再 `add` 时,库里已经没有那一行了 ——
+ * ② **批次基线**({@link rememberBatchCommitted}):两支 SQL 后端的提交阶段逐条 patch 现判、直打真库(落点问询的
+ *    计划阶段只是只读预测,不是 File backend 那种「先规划整批再落盘」),所以同批 `delete` 之后再 `add` 时,库里已经没有那一行了 ——
  *    只看当下的库会把它误判成合法新生命。基线 map 按**本批第一次触碰**记下该 id 的已提交 origin,
  *    之后同批的任何 op 都按那一份判。⇒「同批 delete+re-add 拒 / 已提交墓碑后 add 放」这条分界
  *    (core 契约逐字要求的那条)才成立。
@@ -128,7 +128,7 @@ export declare function rememberBatchCommitted(baseline: BatchCommittedBaseline,
 /**
  * 未知 op 拼写的**前置**拒绝(codex R1-[high],验真后采纳;**既有**缺口,不是本批引入)。
  *
- * 病:两支 SQL 后端的 `applyOne` 形状是「`if (op === "add") {…}` → 落到 update/delete 段」,而段内
+ * 病:两支 SQL 后端当时各一份的 `applyOne`(今两腿共用的判 `memory-engine-sql-apply.ts` 的 `planSqlPatch`)形状是「`if (op === "add") {…}` → 落到 update/delete 段」,而段内
  * 的两道白洗守卫(repo_file provenance / 本模块的 origin 不可变律)都写成 `if (patch.op === "update")`。
  * ⇒ 一个**词表外**的 op(`"upsert"` / 打错的字 / 将来 core 加的新词)会:跳过两道守卫 → 走到 update
  * 的 SQL → 把行改掉 → 在 `report.applied` 里报成一次 update。TypeScript 的联合型是**编译期**的,

package/dist/plugins/one-time-migrations.d.ts

@@ -24,7 +24,7 @@
  * ⇒ 换成本段:**升一次级把存量字节改完,兼容臂当场删干净**。代价是每一条在它的窗内每次启动都要跑一遍(第二次起全是
  * 零命中的空转);收益是窗关之后可以把那一条连同它的 SQL 一起删,而读腿从引入那一版起就只有**一种**读法。
  *
- * ## 已退役的 M1–M5 与 M14
+ * ## 已退役的 M1–M8 与 M14
  * 退役的整树快照索引表(M1)、退役的单座 steering 列(M2)、被上游改了名的闭集词 `unresolvable` → `ancestor_marked`(M3)三条的改写、计数与读数
  * 窗关后已全部删码,登记行一并删。跳过了它们直接升的库由起服对账一族的拒启臂接住(`schema-consistency.ts` 头注「第二道对账」一节:两件退役 schema
  * 任一在场 ⇒ 拒启、点名出路;先于一切建表)—— 那一道没有窗,所以不在本文件里。本段入口({@link runSqlOneTimeMigrations})不问这一问。
@@ -36,27 +36,18 @@
  * 出路是运维给那些行各填一只互不相同的随机令牌,或删会话(MIGRATION 写了升级序)。
  * LKG 的 formatVersion 1 迁移(M14:7.98.0 及以前写在默认路径的旧缓存文件迁进身份箱;非店迁移,不写库)同样已删码(本版提前于窗关删),登记行一并删;它没有自己的拒启臂 —— 那是缓存文件、不是数据:
  * `CONFIG_LKG_PATH` 指到旧文件 ⇒ `loadLkg` 的 1 臂答 `config_lkg_unusable`(env 兜底),默认路径上的旧文件名不是身份箱的文件名形、不再被读,中心可达时第一份干净候选照常写出身份箱。
+ * M6 / M7 / M8 同样已删码(本版删;三条的窗 2026-11-04 … 2026-11-05 关,发版日前都已关),登记行一并删。逐条写跳过了它直接升的库(以及滚动升级窗里旧副本新写的旧形行)由谁接住:
+ * ① run 死亡判决码回填(M6;连同 SQL 行映射里的读侧半场):没有响亮臂 —— 只有句子、码列为空的 `failed` 行(只有 ≤7.115.x 的写者铸得出;7.116.0 起的写者恒同写码)不再被判成持有者死亡:
+ *    用户输入受理账本的收敛判词(`user-input-ledger.ts` `judgeOpen`)把它落到「其余」臂 `leg_over`(补落 `settled{leg_end}`、不告知),那条 run 上丢掉的 steer 不再告诉用户;`GET /v1/runs/:id` 上 `errorCode` 缺席、只剩 `error` 句子。
+ * ② 停驻行 allow 读法记号的拒臂(M7):不写库,删的是 allow 读法记号的写点与「按记号判」的读法;拒臂留为按写者版本的**永久门**(`http/checkpoint-ctx.ts` 顶注「allow 读法问」)——
+ *    体里带非空 allow、而行的写者版本证不出 ≥ 7.117.0(缺席 / 读不出 / 更早)⇒ 续跑重放拒 409 `checkpoint.unsupported_version`(响亮,出路 = 取消后作为新任务重提)。
+ *    这一门不随窗走:日历窗关不证明旧行不在。已存行上的记号键原样留着、无人读;7.117.0–7.123.x 写下、带非空 allow 的行(有记号、没有写者版本)同样拒 —— 证据只认写者版本一个源。
+ *    反向的一格(如实登记):本版写下的行不再带这只记号,滚动升级 / 回滚窗里仍跑 7.145.x 及以前的副本读到**任何**体里带非空 allow 的本版行(提交体从壳透传的
+ *    CC settings 常带它)时照它自己的一问判,由那一版答 409 `checkpoint.unsupported_version`(带写者 / 读者两版本键;响亮,出路 = 由本版副本续跑)。
+ * ③ 停驻行披露位换名(M8):没有响亮臂 —— 仍带旧键 `shadowedRule` 的停驻行在运维待批队列上只缺结构化披露 `allowRuleShadowed`;旧键的文本仍经脱敏叶表「认不得的键按内容脱敏」一条
+ *    脱敏后原样显示(`observability/run-terminal.ts` `redactRiskDescriptor`),卡上 `message` 里引擎写好的那句话不受影响。
  *
  * ## 窗内的迁移(逐条的失败方向刻意不同)
- *  · **M6 run 死亡判决码** —— 7.116.0 起 run 店的两只死亡判决(失联收割 / 重启孤儿回收)在行上同写机读码(`error_code` =
- *    `run.stalled` / `run.orphaned`,词表属主 `store-contracts.ts` 的 `RUN_HOLDER_DEATH_CODES`),读者(`isHolderDeathVerdict`)只认码。
- *    存量行只有句子、码列空 ⇒ **写回半场**:起服把「`failed` ∧ 码列空 ∧ 句子是那两句(接管臂的括注形按前缀认)」的行补上码
- *    (SQL 两条 `UPDATE`;local 腿 = `FileRunStore.migrateLegacyHolderDeathCodes`)。**读侧半场**:滚动升级窗里 ≤7.115.x 的副本还会写只有句子的行
- *    (起服写回覆盖不到窗内新写的行)⇒ SQL 两孪生的行映射经 `readLegacyHolderDeathCode` 把这种行读成码 —— 它是本条的一半,窗关随本条一起删
- *    (见登记表 M6 的 `removal`)。local 车道没有滚动窗(数据根独占:窗内不会有旧写者与本进程并存),读侧半场不在 File 店上。
- *
- *  · **M7 停驻行 allow 读法记号的拒臂**(7.117.0,core 7.42.0)—— 不是改写,是**持久数据「响亮拒」那一半**:续跑重放体里带非空
- *    `settings.permissions.allow`、而 ctx 上的读法记号不是当前的 `"allow_layer"`(名单时代无记号 / 表态时代 `"statement"`)⇒ 认领之前 409、行字节不动。
- *    规则、两句拒句与写点在 `http/checkpoint-ctx.ts`;本条只登记它的窗(7.115.0 引入的同一只拒臂当时没有登记,7.117.0 起它覆盖两代旧词,登记在这里)。
- *    没有读数键(它不写库)。
- *  · **M8 停驻行披露位换名**(7.117.0,core 7.42.0 [ref])—— `checkpoint.risk_descriptor` 里 7.41.x 引擎写下的 `shadowedRule`(字符串:命中却清不掉的
- *    持久 allow 规则原文)在 7.42.0 引擎里换成 `allowRuleShadowed: { member, entries, omitted? }[]`,旧键不再有人读。旧键只由规则店成员铸
- *    (core 7.41.2 `gate-lanes.ts` 的披露臂是它唯一的铸点;本仓的策略从不自铸它)⇒ **一次性改写**:`{ ..., shadowedRule: v }` →
- *    `{ ..., allowRuleShadowed: [{ member: "persisted", entries: [v] }] }`(旧值是引擎拼好的「最多五条 + and N more」一串,原样作为一条条目,不拆)。
- *    列是 TEXT(两方言),改写在应用侧解析 + 按 `token` CAS 回写(`WHERE risk_descriptor = <读到的原文>`;第二跑零命中)。**没有读侧半场**:滚动窗里
- *    旧副本新写的旧键行只缺结构化披露(卡上 `message` 那句话引擎已经写好),旧键的文本由脱敏叶表的「认不得的键按内容脱敏」一条兜住
- *    (`observability/run-terminal.ts` `redactRiskDescriptor`)—— 不为它开第二种读法。local 车道没有这一列(停驻行在引擎自己的 File 店里,本仓
- *    没有合法缝改写那些字节,盘上格式归引擎):旧键留在原地、不被读,文本同样经脱敏叶表兜住。
  *  · **M9 park 指针索引改主键**(7.118.0,core 7.44.0 [ref])—— `workflow_agent_session` 的主键由 `(session_id)` 改成 `(session_id, run_id)`:
  *    停驻持有者有了引擎写的位(`parkedBy` / `generation`)之后,判决要看到点名同一个子会话的每一条记录(续跑链 / 分叉),单列主键下后写覆盖先写。
  *    表是派生投影 ⇒ **复制 + 原子换名**:照中央 DDL 建新形暂存表 → 一条 `INSERT … SELECT` 整表复制 → 正表换成待删名、暂存表换成正表名、删待删旧表
@@ -71,7 +62,7 @@
  *    (起服时没有 principal,把它判给任何人都是编造)。本条是一只**窗内才生效的行为臂**:窗开着时,带 principal 的第一次提交(attach)认领
  *    这种会话(写进那一格,一行 info `session_owner_claimed`);窗关之后(运行期读本表 M10 行的 `removableAfter`,见 {@link migrationWindowOpen})
  *    它照今天答无主,删码因此是零行为变化。认领的安全前提是单用户:local 后端起服门拒 `REQUIRE_PRINCIPAL=true`,授权口也只在
- *    `REQUIRE_PRINCIPAL` 关时把 principal 递给店认领。没有起服读数(它不在起服时写库,与 M7 同形)。
+ *    `REQUIRE_PRINCIPAL` 关时把 principal 递给店认领。没有起服读数(它不在起服时写库)。
  *  · **M11 持久规则里 scope 不被引擎收的行**(7.120.0,引擎 7.46.0)—— 7.119.0 及更早的本仓入口(`/v1/rules` 写口、两条导入面)按
  *    「root 非空」收 project scope,引擎 7.45 也收;引擎 7.46.0 把 project root 收窄成**完整绝对路径**(`isValidDurableScope`),本仓入口
  *    同版改调同一只谓词。存量的 `project:myproj` 一类行在新引擎的读侧被丢(每次 run 一条 `permission.rule_row_dropped`),而撤销口删不动它
@@ -86,7 +77,7 @@
  *    ⚠️ **够不到的一格(如实登记)**:local 车道的持久规则在**引擎自己的** File 分区里 —— 引擎的写面对这种 scope 的加 / 墓碑一律拒,
  *    本仓没有合法缝删它们,改那份盘上格式是下游改上游。那里的存量坏行照旧由引擎读侧丢并告知;出路候引擎给
  *    一条删除缝。
- *  · **M12 停驻行模式词读法记号的拒臂**(7.122.0)—— 与 M7 同形,持久数据「响亮拒」那一半:7.122.0 起一条 run 的模式词只有存储体顶层 `permissionMode`
+ *  · **M12 停驻行模式词读法记号的拒臂**(7.122.0)—— 持久数据「响亮拒」那一半:7.122.0 起一条 run 的模式词只有存储体顶层 `permissionMode`
  *    一个源(提交入口盖运维 `AUTONOMY=plan` 的地板一次),更早的行体里是请求原词、运维的 plan 由治理层每段重钳。续跑重放之前:本部署此刻有入口地板 ∧
  *    ctx 上没有当前记号 `"entry_word"` ∧ 体的生效词被地板钳会变 ⇒ 认领之前 409、行字节不动。规则、拒句与写点在 `http/checkpoint-ctx.ts` 顶注第三问。
  *    没有读数键(它不写库)。
@@ -158,9 +149,9 @@
  *    不改写存下的字节(体按原样留在 ctx 里),是一只**窗内才生效的行为臂** —— 窗开着时(运行期读本表 M19 行的 `removableAfter`,见 {@link migrationWindowOpen}),
  *    **只在续跑重放腿**、**只对判官判不过的那一格**按升级前的读法重读一次(`stored-request-tool-axes-m19.ts`),产物再交同一只判官(不过 ⇒ 整条不进的原臂),
  *    真挂上的这类 server 各一行运维 warn `mcp_tool_axes_read_as_before_upgrade`;窗关之后照今天答(整条不进),删码因此是零行为变化。
- *    窗 = 发布日 + 30 天 = 停驻行的终局兜底窗缺省(`APPROVAL_TERMINAL_BACKSTOP_MS` 缺省 30 天)—— 与 M7 / M12 同一条论证。没有起服读数(它不写库)。
+ *    窗 = 发布日 + 30 天 = 停驻行的终局兜底窗缺省(`APPROVAL_TERMINAL_BACKSTOP_MS` 缺省 30 天)—— 窗关时缺省部署上升级前停驻的行都已被收割。没有起服读数(它不写库)。
  *    窗按**发布日**算、停驻行的期限按**停驻时刻**算 ⇒ 三类部署会有升级前停驻的行活过窗、窗关后回到「整条不进」:发布后才升级的部署(发布日到它升级那天之间
- *    停驻的行)、把 `APPROVAL_TERMINAL_BACKSTOP_MS` 调长的部署、滚动升级里仍跑 7.129.x 的副本在窗内新写的行。与 M7 / M18 一样如实登记,不为它们加长窗。
+ *    停驻的行)、把 `APPROVAL_TERMINAL_BACKSTOP_MS` 调长的部署、滚动升级里仍跑 7.129.x 的副本在窗内新写的行。与 M18 一样如实登记,不为它们加长窗。
  *    **A2A 一面**(core 7.53.0 [ref] 提货批,同一只重读座、同一个窗,不另立迁移号):请求体 `a2aPeers[].toolAxes` 的判官也换成了引擎的 `readToolAxes`,7.131.x 的 A2A 读者
  *    对每只 skill 的记录只挑三个轴、多余成员静默忽略 ⇒ 续跑重放腿同一只重读座按 **7.131.x 的 A2A 读法**重读一次(重读座按面分读者:两面升级前的读法不同 ——
  *    7.131.x 的 A2A 读者对已知轴写坏是整条丢对端,重读照旧整条丢,不把 7.131.x 当时没挂上的对端救活),真挂上的对端一行 `a2a_tool_axes_read_as_before_upgrade`。窗仍按 7.130.0 的发布日算 ——
@@ -227,7 +218,7 @@
  *  · **M25 单用户记忆项目层换键形**(7.133.0)—— 不在店里、不在起服里(与 M10 同为**窗内才存在的行为臂**,但它是改写):项目层键从 `repo:<sha256(项目根)[:24]>`
  *    (7.98.0–7.132.x)换成带主体、跨设备的 `userrepo:<属主段>/<档>.<摘要>`(文法 `project-layer-key.ts`)。退役键是路径哈希、反推不出路径 ⇒ 起服没法枚举改写;
  *    改为**每个项目第一次跑任务时**由项目层准备一步(`memory-project-layer.ts` `createMemoryProjectLayers`)把该 checkout 的 `repo:` 层经 core `migrateScope`
- *    折进新键(File 与两只 SQL 孪生同一条;id 保留、CAS,冲突留原地下次再试)。本条不写起服读数(`reportKeys` 空,与 M7 / M10 同形);折了什么由运行期 info
+ *    折进新键(File 与两只 SQL 孪生同一条;id 保留、CAS,冲突留原地下次再试)。本条不写起服读数(`reportKeys` 空,与 M10 同形);折了什么由运行期 info
  *    `memory_project_layer_folded` 说。常设的另一条律(`r` 档时本 checkout 的 `p` 档折进当前档)不是迁移,不随本条删。
  *    **曾属本条的另一半已退役(如实)**:同步客户端腿的旧游标文件 `sync-cursor-<peer>.json`(只按 peer 分区)的收编臂。引擎 7.59.0 起游标必带店绑定 `store`,
  *    升级前落盘的旧文件都没有这一员,收编的形判从不认它 ⇒ 臂对任何存量文件都不可达,已整条删码(收编函数、守卫旗标、日志行一并删,零引用有钉:
@@ -256,7 +247,7 @@
  *    `http/checkpoint-ctx.ts` 末段「凭据位密封」;本处不重列)在 `checkpoint_ctx` 里只以封签存在,续跑上下文读口对凭据位上的明文答 409 `conflict.checkpoint_ctx_unsealable`(`reason:"plaintext"`)。升级之前写下的
  *    行是明文 ⇒ **起服扫一遍、原地封好**:不在本文件的迁移段里(封要保管店的封签器,而本段跑在建店的 web-admin 运行时能交给它之前的店层 ——
  *    与 M10 / M19 / M25 同为在本段之外跑的条目),编排在 `checkpoint-ctx-seal-m28.ts`(起服第 6 段,checkpoint 店建成之后、任何路由装配之前调一次),
- *    店腿是两孪生共有的 ctx 行改写腿 `rewriteCtxRows`(`checkpoint-store-sql.ts` `CheckpointCtxRowsRewriter`;M30 用同一只;SQL:键集分页 + 按原文 CAS、`updated_at_ms` 不动;local:逐档原子重写、信封的 `updatedAt` 不动),
+ *    店腿是两孪生共有的 ctx 行改写腿 `rewriteCtxRows`(`checkpoint-store-face.ts` `CheckpointCtxRowsRewriter`;M30 用同一只;SQL:键集分页 + 按原文 CAS、`updated_at_ms` 不动;local:逐档原子重写、信封的 `updatedAt` 不动),
  *    行改写是读写两侧同一只封口(`sealStoredCheckpointCtxM28`),封的是「读口会答 `plaintext` 的每一个值」(与开口同一只判词)—— 7.135.0 闭集加了一位
  *    (command 条目的 `plugin.options`)之后,7.134.0 写下的带记号行在那一位上的明文也落在这一条里、同窗补封(本条没有新窗);7.136.0 再加四位(子进程的命令行:MCP stdio 传输与
  *    command 条目各自的 `command` / `args`,第 3 代)同理 —— 无记号行与 7.134.0 / 7.135.0 写下的第 1 / 2 代行上的明文命令行同窗补封。不删行、不改续跑语义;读不出的行计数不动;已封与不带凭据的行零写。读数不进
@@ -357,6 +348,14 @@
  *    本版之前铸的卡信封(`approval_ask.card_json` / local 问账)上那一格还是旧名,`.strict()` 的卡 schema 只认新名。存卡的唯一读者入口 `readStoredCardEnvelope`
  *    在 M18 的读侧改写与 schema 之前把它改名(`approval-card.ts` 的 `renameRetiredSourceKey`,交浅拷贝、零写回,响亮计数)。不起服改写:存卡的寿命以分钟计、
  *    升级前结清在途审批是部署前置(MIGRATION 本版第 17 条),读侧接住的是滚动升级窗里旧副本新写的与升级前已结仍被读的那几行。没有读数键。
+ *  · **M38 续跑重放腿上的存量 `settings.env` 凭据条目**(7.146.0)—— 凭据不进 `settings.env` 是本版的新规则(判据 `task-settings.ts` 的 `settingsEnvCredentialIssue`:名字是本进程的凭据变量名,
+ *    或值是秘密形 ⇒ 新提交 `400 request.env_credential_refused`)。升级前受理、存下的请求体(`checkpoint_ctx`;凭据位已由 M28 封好)里老壳写进去的这类条目,续跑一重放就撞同一只判据。
+ *    与 M19 / M20 同形:不改写存下的字节,是一只**窗内才生效的行为臂** —— 窗开着时(运行期读本表 M38 行的 `removableAfter`,`stored-request-env-credentials-m38.ts`),
+ *    **只在续跑重放腿**,`resolveSpec` 把判据命中的键从这条腿唯一读到的那一份 `settings.env` 里剥掉(收窄方向:凭据离开模型的 shell 与 hooks,引擎自己用的凭据从进程环境取;剥空 = 空表,
+ *    登记它覆盖会话上一条登记 —— 会话 shell env 注册表「缺席 = 留着上一条」,不铸空表就把上一条留给了 shell),
+ *    恰一行运维 warn `settings_env_credentials_dropped`(按命中类计数,不带键名与值),任务照续;存体续跑预判窗内不拦。窗关之后 ⇒ 预判与 `resolveSpec` 同一只判据拒
+ *    (续跑口 409 `resume_blocked_by_policy`,`blockedBy` = 本码),删码因此是零行为变化。窗 = 发布日 + 30 天 = 停驻行的终局兜底窗缺省(与 M19 / M20 同一条论证与同三类逃出窗的部署:
+ *    发布后才升级的、调长了 `APPROVAL_TERMINAL_BACKSTOP_MS` 的、滚动升级里旧副本在窗内新写的行),另一类如实登记:窗内续跑过、又停驻到窗外的任务,写回的存体仍带那些条目(本条零写)。没有起服读数(它不写库)。
  *
  * ## 收据账(一次起服一只,每一条迁移同一只)
  * 每一步把它**已提交**的改写 / 删除与点名读数当场记进同一只收据账({@link MigrationReceipts}):计数随每次提交累加、行随每次提交追加、形读数在那一步落定时写。走完 ⇒
@@ -366,8 +365,7 @@
  * 如实的残余:提交与那一行日志之间进程被杀、或一条提交的确认在连接上丢了 —— 收据没有耐久载体(不为短命的迁移另建迁移账表:有 schema 形可当「跑过了」标记的几条用它自己的形 —— M9 的主键宽度、M17 的列名;改值类的几条没有这种标记,为它们造一张账表 / 一个旋钮,就是给一条短命的迁移留一份长命的状态)。
  *
  * ## 幂等
- * 改写的几条都可重复跑(M6:`WHERE error_code IS NULL`;
- * M8 / M18:字样扫描 + CAS 回写 —— 写过的行不再命中;M17 的改写只在改名那一拍跑,第二跑列名已是新名 ⇒ 零读零写;续判时已带戳的行零动作;
+ * 改写的几条都可重复跑(M18:字样扫描 + CAS 回写 —— 写过的行不再命中;M17 的改写只在改名那一拍跑,第二跑列名已是新名 ⇒ 零读零写;续判时已带戳的行零动作;
  * M24:正表 scope 列在场探针 —— 换名之后只补收尾(删待删旧表),换名之前被打断则暂存表删掉重建、回填只补缺的属主记录(`NOT EXISTS`);
  * M27:只按判官挑 —— 删过的键不再被扫到)。并发起动由 {@link runSqlOneTimeMigrations} 的 advisory 锁 + 每步的后置条件判据兜住(见那里)。
  */
@@ -383,12 +381,6 @@ import { type ImportedLayerRootAllowRetired, type ImportedLayerRootBucketSkipped
 import { type LocalPlacementBackfillSeat, type UnusableArchiveWord } from "../execution-placement.js";
 /** 迁移读数(启动日志一行写全;测试按它断言,不靠日志文本)。 */
 export interface OneTimeMigrationReport {
-    /** M6:本次给「只有句子」的死亡判决行补上机读码的 run 行数(SQL `task_run` / local `run.json`)。非零 = 这次迁移真写了存量行,必须让运维看见。 */
-    readonly holderDeathCodeRowsBackfilled: number;
-    /** M8:本次把 `checkpoint.risk_descriptor` 的旧披露键 `shadowedRule` 改写成 `allowRuleShadowed` 的行数(SQL 独有;local 恒 0)。非零 = 真写了存量行。 */
-    readonly allowRuleShadowRowsMigrated: number;
-    /** M8:带旧键字样、但这一格的 JSON 读不懂 ⇒ 没改写的行数(留给读口自己的响亮臂;非零 = 运维该看一眼这些行)。SQL 独有;local 恒 0。 */
-    readonly allowRuleShadowRowsUnreadable: number;
     /** M9:workflow park 指针索引的主键 —— `reshaped` = 本次把只有 `session_id` 的主键改成 `(session_id, run_id)`;`current` = 早已是新形
      *  (新库 / 第二跑);`file-ledger` = local 文件车道(账本一行本来就是一条 run 的指针集,没有主键可改)。 */
     readonly workflowParkIndexKey: "reshaped" | "current" | "file-ledger";
@@ -590,7 +582,7 @@ export declare class OneTimeMigrationInterruptedError extends Error {
  * 规则(窗长 30 天、窗关后的第一个 minor 删码、门怎么判)在本文件头注「窗」一节,只写那一次。
  */
 export interface OneTimeMigrationWindow {
-    /** 本文件里的条目名(头注「窗内的迁移」的 M6…)。 */
+    /** 本文件里的条目名(头注「窗内的迁移」的 M9…)。 */
     readonly id: string;
     /** 引入这条迁移的版本 = 第一只含其代码的发布 tag(取证:`git log -S '<该条的常量名>' -- src/plugins/one-time-migrations.ts`
      *  找引入提交 → `git tag --contains <提交> --sort=creatordate` 取最早)。 */
@@ -616,7 +608,7 @@ export declare const ONE_TIME_MIGRATIONS: readonly OneTimeMigrationWindow[];
 /**
  * 一条登记行的窗**此刻**开着没有(`today` = UTC 日历日 YYYY-MM-DD):未发布形(`removableAfter: null`)⇒ 开;否则今天不晚于 `removableAfter` ⇒ 开
  * (窗关当天仍开,与到期门「今天严格晚于才红」同一条边界)。
- * 给**窗内才生效的行为臂**(M10 的认领、M19 / M20 的续跑重读)与本文件迁移段之外的起服扫描(M28 / M30)用:过了窗就停,不等删码车 —— 删码因此是零行为变化,而窗只写在本表这一处。
+ * 给**窗内才生效的行为臂**(M10 的认领、M19 / M20 的续跑重读、M38 的续跑剥键)与本文件迁移段之外的起服扫描(M28 / M30)用:过了窗就停,不等删码车 —— 删码因此是零行为变化,而窗只写在本表这一处。
  */
 export declare function migrationWindowOpen(window: Pick<OneTimeMigrationWindow, "removableAfter">, today: string): boolean;
 /**
@@ -625,8 +617,8 @@ export declare function migrationWindowOpen(window: Pick<OneTimeMigrationWindow,
  * 还没有日期可写)⇒ 响亮抛,不铸一句带空日期的句子。
  */
 export declare function migrationWindowEnd(id: string): string;
-/** local 车道上 SQL 独有的几条(M8 / M9 / M11 / M17 / M18 / M21 / M23 / M24 / M26 / M27 / M29)的读数(M6 与 M32 的回填两车道都有、M33 只在 local,local 腿的读数由 `LocalBackend.runOneTimeMigrations` 现算):那几张表 / 列在文件底座上从来不存在 ⇒ 如实答 absent / 0。 */
-export declare const NO_SQL_MIGRATIONS: Omit<OneTimeMigrationReport, "holderDeathCodeRowsBackfilled" | "executionPlacementsBackfilled" | "askExecutionLanesBackfilled" | "executionPlacementSessionsUnreadable" | "localArchiveRowFactsBackfilled" | "localArchivesAnonymized" | "localArchivesKeptStamped" | "localArchivesUnreadable" | "localArchiveSnapshotsRecovered" | "askJournalRecordsUpgraded" | "importedLayerRootAllowsRetired" | "importedLayerRootBucketsSkipped">;
+/** local 车道上 SQL 独有的几条(M9 / M11 / M17 / M18 / M21 / M23 / M24 / M26 / M27 / M29)的读数(M32 的回填两车道都有、M33 只在 local,local 腿的读数由 `LocalBackend.runOneTimeMigrations` 现算):那几张表 / 列在文件底座上从来不存在 ⇒ 如实答 absent / 0。 */
+export declare const NO_SQL_MIGRATIONS: Omit<OneTimeMigrationReport, "executionPlacementsBackfilled" | "askExecutionLanesBackfilled" | "executionPlacementSessionsUnreadable" | "localArchiveRowFactsBackfilled" | "localArchivesAnonymized" | "localArchivesKeptStamped" | "localArchivesUnreadable" | "localArchiveSnapshotsRecovered" | "askJournalRecordsUpgraded" | "importedLayerRootAllowsRetired" | "importedLayerRootBucketsSkipped">;
 /** 启动期的日志口(logger 的子集)。两级各有其用,见 {@link logOneTimeMigrations}。 */
 export interface MigrationLogSink {
     warn(msg: string, meta?: Record<string, unknown>): void;
@@ -653,7 +645,7 @@ export interface MigrationDb {
  * 每条改表 DDL 的成功判据仍是它的**后置条件**({@link execUntil}),「另一个副本抢先把同一张表换了形」不会把滚动升级变成启动失败循环。
  *
  * ## 次序(codex r1 [medium] 同轮)
- * 非破坏改写(M6–M9、M18:改值不丢信息 / 复制 + 换名)在前,破坏性步骤(M11 的删行、M24 丢下跨 scope 行的换名)排在最后;
+ * 非破坏改写(M9、M18:改值不丢信息 / 复制 + 换名)在前,破坏性步骤(M11 的删行、M24 丢下跨 scope 行的换名)排在最后;
  * M11 自己半途失败时,拒因自带已删的行(`purgeUndurableScopeRows`)—— 否则重试看不见已删的行,证据永久消失;M24 的丢行计数在换名提交之后进收据账。
  *
  * 本函数**不问**退役 schema:带着它的库在更早处就被 `ensureSchema()` 自身拒掉了(起服对账一族 `schema-consistency.ts` 的探针口,先于建表);走公开序列
@@ -783,23 +775,7 @@ export declare function oldGrammarEntriesOf(body: unknown, rev: number): OldGram
  * 终名改名提交之后才写;`current` = 起服时已是终名);点名的行随扫到追加。
  */
 export declare function migrateSessionRuleGrammar(db: MigrationDb, dialect: SqlDialect, receipts: MigrationReceipts): Promise<void>;
-/** M8 一行改写的结论:改写后的文本 / 这一行不用动 / 读不懂(解析错误原样交出,调用方计数进读数)。 */
-export type ShadowedRuleRewrite = {
-    readonly kind: "rewrite";
-    readonly text: string;
-} | {
-    readonly kind: "untouched";
-} | {
-    readonly kind: "unreadable";
-    readonly error: unknown;
-};
-/**
- * M8 的**一行**改写(纯函数;导出给钉用):`risk_descriptor` 的 JSON 文本里顶层带字符串 `shadowedRule` ⇒ 改写(旧键删、`allowRuleShadowed`
- * 由旧值铸一条 `persisted` 记录;行上已经有 `allowRuleShadowed` ⇒ 只删旧键,不并);不是对象 / 没有旧键 / 旧键不是字符串 ⇒ `untouched`;
- * JSON 读不懂 ⇒ `unreadable`(这一行不动,交给读口自己的响亮臂;迁移不替它猜,但把它数进读数,不静默)。
- */
-export declare function migrateShadowedRuleDescriptor(text: string): ShadowedRuleRewrite;
-/** M18 一行改写的结论(与 M8 同形,不共用型 —— 两条各自窗关各自删):改写后的文本 / 这一行不用动 / 读不懂(解析错误原样交出,调用方计数进读数)。 */
+/** M18 一行改写的结论:改写后的文本 / 这一行不用动 / 读不懂(解析错误原样交出,调用方计数进读数)。 */
 export type RetiredCardWordsRowRewrite = {
     readonly kind: "rewrite";
     readonly text: string;