@sema-agent/server 7.149.0 → 7.150.0

package/dist/peer-seat.js

@@ -151,67 +151,60 @@ export function createPeerDesk(opts = {}) {
                 return { kind: "carry", env: entry.pieces };
         }
     };
-    const handleIdOf = (ref) => {
-        switch (ref.kind) {
-            case "handle":
-                return ref.id;
-            case "env":
-            case "vault":
-            case "assertion":
-                return undefined;
-            default: {
-                const unknownKind = ref;
-                void unknownKind;
-                return undefined;
-            }
-        }
+    const notMintedHold = () => {
+        throw new Error("peer desk: hold of a reference this desk did not mint — not held");
     };
-    const seat = Object.freeze({
-        hold: (ref) => {
-            const id = handleIdOf(ref);
-            if (id === undefined)
-                throw new Error("peer desk: hold of a reference this desk did not mint — not held");
-            const entry = table.get(id);
-            if (entry === undefined)
-                throw new Error("peer desk: hold of a handle whose entry is gone — not held (a hold never revives an entry)");
-            entry.engineHolds += 1;
-        },
-        release: (ref) => {
-            const id = handleIdOf(ref);
-            if (id === undefined)
-                throw new Error("peer desk: release of a reference this desk did not mint — nothing released");
-            const entry = table.get(id);
-            if (entry === undefined || entry.engineHolds === 0)
-                throw new Error("peer desk: release of a handle with no counted engine hold — nothing released");
-            entry.engineHolds -= 1;
-            dropIfUnheld(id, entry);
+    const notMintedRelease = () => {
+        throw new Error("peer desk: release of a reference this desk did not mint — nothing released");
+    };
+    const notMinted = (reason) => ({
+        answer: (_ref, question) => refuse(question.peer, reason),
+        hold: notMintedHold,
+        release: notMintedRelease,
+    });
+    const seatKinds = {
+        handle: {
+            answer: (ref, question) => {
+                const target = question.peer;
+                const entry = table.get(ref.id);
+                if (entry === undefined)
+                    return refuse(target, "handle_not_held");
+                if (!sameBinding(entry.binding, bindingOf(target)))
+                    return refuse(target, "binding_mismatch");
+                return carry(entry);
+            },
+            hold: (ref) => {
+                const id = ref.id;
+                if (id === undefined)
+                    return notMintedHold();
+                const entry = table.get(id);
+                if (entry === undefined)
+                    throw new Error("peer desk: hold of a handle whose entry is gone — not held (a hold never revives an entry)");
+                entry.engineHolds += 1;
+            },
+            release: (ref) => {
+                const id = ref.id;
+                if (id === undefined)
+                    return notMintedRelease();
+                const entry = table.get(id);
+                if (entry === undefined || entry.engineHolds === 0)
+                    throw new Error("peer desk: release of a handle with no counted engine hold — nothing released");
+                entry.engineHolds -= 1;
+                dropIfUnheld(id, entry);
+            },
         },
-        answer: async (question) => {
-            const target = question.peer;
-            const ref = target.credentials;
-            if (ref === undefined)
-                return { kind: "carry" };
-            switch (ref.kind) {
-                case "handle": {
-                    const entry = table.get(ref.id);
-                    if (entry === undefined)
-                        return refuse(target, "handle_not_held");
-                    if (!sameBinding(entry.binding, bindingOf(target)))
-                        return refuse(target, "binding_mismatch");
-                    return carry(entry);
-                }
-                case "env":
-                    return refuse(target, "kind_env");
-                case "vault":
-                    return refuse(target, "kind_vault");
-                case "assertion":
-                    return refuse(target, "kind_assertion");
-                default: {
-                    const unknownKind = ref;
-                    void unknownKind;
-                    return refuse(target, "kind_unknown");
-                }
-            }
+        env: notMinted("kind_env"),
+        vault: notMinted("kind_vault"),
+        assertion: notMinted("kind_assertion"),
+    };
+    const unknownKind = notMinted("kind_unknown");
+    const rowOf = (ref) => (Object.hasOwn(seatKinds, ref.kind) ? seatKinds[ref.kind] : unknownKind);
+    const seat = Object.freeze({
+        hold: (ref) => rowOf(ref).hold(ref),
+        release: (ref) => rowOf(ref).release(ref),
+        answer: async (question, signal) => {
+            const ref = question.peer.credentials;
+            return ref === undefined ? { kind: "carry" } : rowOf(ref).answer(ref, question, signal);
         },
     });
     return Object.freeze({

package/dist/plugins/exec-path-law.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The execution seam's path law — ONE reading for every execution environment this server mints (the seven lanes: adb / device / e2b /
+ * host / k8s / local-docker / ssh) and for the sandbox write gate's stand-in environment (`boot/deferred-sandbox-path-env.ts`).
+ *
+ * The law (the engine's, `ExecutionEnv` contract; the engine's own `NodeExecutionEnv` reads every path this way): a path a method is
+ * handed is ABSOLUTE AS WRITTEN, or relative and ANCHORED at the environment's working directory with exactly one separator. Nothing here
+ * folds a `..` or a `.` and nothing resolves a link: the filesystem the path lands on resolves them, components first — so a `..` that
+ * follows a symbolic link goes where the link leads (`<base>/bridge/../next` with `bridge -> elsewhere/sub` names `<base>/elsewhere/next`).
+ * A lexical fold would name `<base>/next` instead: the write gate (which asks the real filesystem what the spelling names) and the tool
+ * (which opened the folded name) would then judge and touch two different files.
+ *
+ * Three faces, one anchor ({@link anchorUnder}): the path a method reads ({@link anchoredPath}), `joinPath` ({@link joinedPath}) and the
+ * paths a listing reports (each entry anchored under the path the listing was handed). The remote lanes' shell scripts (the link-chain walk
+ * and the staged write, `remote-shell.ts`) already anchor this way in shell; this module is the same law for the TypeScript faces.
+ *
+ * Pure leaf: string arithmetic only, no I/O.
+ */
+import type { PlatformPath } from "node:path";
+/**
+ * The two facts of a path family the law reads: its separator and its absolute-path judge. The remote lanes read POSIX whatever the
+ * worker runs on (`path.posix`; the device lane passes its one absolute-path judge, `isDeviceAbsolutePath`); the host lane reads the
+ * worker's own (`path`).
+ */
+export type SeamPathFamily = Pick<PlatformPath, "sep" | "isAbsolute">;
+/** `name` placed under `dir` with exactly one separator — never folded, never re-rooted. */
+export declare function anchorUnder(family: SeamPathFamily, dir: string, name: string): string;
+/** The path a method is handed, as the environment reads it: absolute ⇒ as written; relative ⇒ anchored at `cwd`. */
+export declare function anchoredPath(family: SeamPathFamily, cwd: string, p: string): string;
+/**
+ * `joinPath`: the first part as written; every later part is a segment, never a root (its leading separators are dropped); empty parts
+ * are dropped; the rest anchored in turn. No parts ⇒ `"."`.
+ */
+export declare function joinedPath(family: SeamPathFamily, parts: readonly string[]): string;
+//# sourceMappingURL=exec-path-law.d.ts.map

package/dist/plugins/exec-path-law.js

@@ -0,0 +1,13 @@
+export function anchorUnder(family, dir, name) {
+    const endsInSeparator = dir.endsWith(family.sep) || (family.sep === "\\" && dir.endsWith("/"));
+    return endsInSeparator ? `${dir}${name}` : `${dir}${family.sep}${name}`;
+}
+export function anchoredPath(family, cwd, p) {
+    return family.isAbsolute(p) ? p : anchorUnder(family, cwd, p);
+}
+export function joinedPath(family, parts) {
+    const leading = family.sep === "\\" ? /^[\\/]+/ : /^\/+/;
+    const named = parts.map((part, i) => (i === 0 ? part : part.replace(leading, ""))).filter((part) => part !== "");
+    return named.length === 0 ? "." : named.reduce((at, part) => anchorUnder(family, at, part));
+}
+//# sourceMappingURL=exec-path-law.js.map

package/dist/plugins/file-run-store.js

@@ -652,7 +652,7 @@ export class FileRunStore {
         if (this.active.get(sessionId) !== taskId || r === undefined || r.status !== "running")
             return false;
         this.persist({ ...r, updatedAt: new Date() });
-        write({ instanceId: r.instanceId });
+        write({ instanceId: r.instanceId, legId: r.legId });
         return true;
     }
     async getRun(taskId) {

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

@@ -1,4 +1,4 @@
-import { type Checkpoint, type CheckpointSummary, type CheckpointToken, type PendingSteerInput, type ReopenReason, type ResolveExpectation, type ExecutionOutcomeRecordWord, type GateOutcome, type ResumeOutcome, type StoreDurability, type StoreFidelity } from "@sema-agent/core";
+import { type Checkpoint, type CheckpointPage, type CheckpointRowRead, type CheckpointSessionCursor, type CheckpointSessionQuery, type CheckpointSummary, type CheckpointToken, type PendingSteerInput, type ReopenReason, type ResolveExpectation, type ExecutionOutcomeRecordWord, type GateOutcome, type ResumeOutcome, type StoreDurability, type StoreFidelity } from "@sema-agent/core";
 import { type CheckpointAskCandidate, type CtxClaimPut, type CtxClaimRewrite, type CtxRowRewrite, type CtxRowsRewrite, type DecidedApprovalRecord, type ExpiredApprovalGate, type ExpiredGatePosition, type PendingCheckpoint, type PendingRowBinding } from "./checkpoint-store-face.js";
 import { type CtxWriteClaim } from "./store-contracts.js";
 import type { SealedCheckpointCtx } from "../http/checkpoint-ctx.js";
@@ -118,6 +118,9 @@ export declare class LocalCheckpointStore {
     expire(token: CheckpointToken, scope: string): Promise<boolean>;
     reap(scope: string, cutoff: number): Promise<number>;
     listByScope(scope: string): Promise<CheckpointSummary[]>;
+    /** core `CheckpointStore.listBySession`(可选动词,按在不在探):纯委派给内核 —— 读法是 core 的 `selectSessionPage`(SQL 孪生把「这只会话的行」交给同一只);
+     *  内核读的是它自己的全部行(任何状态),坏行由内核按行答 `unreadable`、经数据根那只披露座说。包装层不另判、不另列。 */
+    listBySession(query: CheckpointSessionQuery): Promise<CheckpointPage<CheckpointRowRead, CheckpointSessionCursor>>;
     close(): void;
     /** C4-B:注册表损坏时从**数据本体**懒重建 scope 集(core 1.424 `listScopes?` = 「有 ≥1 条 pending 的
      *  distinct scope 集」,与 listByScope 可见面对齐 —— 恰好是本注册表要的内容)。一次性:重建后回写

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

@@ -227,6 +227,9 @@ export class LocalCheckpointStore {
     listByScope(scope) {
         return this.inner.listByScope(scope);
     }
+    listBySession(query) {
+        return this.inner.listBySession(query);
+    }
     close() {
         this.inner.close();
     }

package/dist/plugins/memory-run-store.js

@@ -302,7 +302,7 @@ export class MemoryRunStore {
         if (this.active.get(sessionId) !== taskId || r === undefined || r.status !== "running")
             return false;
         r.updatedAt = new Date();
-        write({ instanceId: r.instanceId });
+        write({ instanceId: r.instanceId, legId: r.legId });
         return true;
     }
     async getRun(taskId) {

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

@@ -12,7 +12,8 @@
  * **≥** 某条未发布形的 `introducedIn` 而两格仍是 `null` ⇒ 红(发布准备提交就是回填时刻,忘了就当场红;版本更低 = 还在开发,不红)。
  * 最后一条删掉时,整个文件连同 `StoreBackend.runOneTimeMigrations()`(npm 公面上的接口成员)、`NO_SQL_MIGRATIONS`、
  * `logOneTimeMigrations` / `runAndLogOneTimeMigrations`、三只后端与两只测试夹具上的实现、`boot/stores.ts` 的调用点一起删 —— 零例外:本文件里只有带窗的迁移与它们自己的
- * 帮手(两只在场探针、锁腿、方言适配器);没有窗的东西(跳版升级的库的拒启臂)住在起服对账一族(`schema-consistency.ts`、`approval-exemption-skill-cutoff.ts`、local 的
+ * 帮手(两只在场探针、锁腿、方言适配器)与迁移段的**段头**两步(副本能力登记、起服准入 —— 常设,码在 `replica-registration.ts` / `serving-requirement.ts`,本文件只在 {@link runSqlOneTimeMigrations}
+ * 里排它们的序;最后一条迁移删码时,段头连同锁腿搬进起服序列,不随文件删);没有窗的东西(跳版升级的库的拒启臂)住在起服对账一族(`schema-consistency.ts`、`approval-exemption-skill-cutoff.ts`、local 的
  * `local-data-root-admission.ts`),不在这里 —— 那条迁移还在时臂只判、不拒,读本文件的 {@link migrationCarried}(行随码同删 ⇒ 删码那一版起臂恒判)。
  * 其余文件一律只写「窗口见本文件登记表」,不各写一个日期或版本 —— [ref] 之前本文件头写死了一个删除版本号(7.75.0),
  * 连同 11 个文件里的复述共 23 行;那一版过去了 28 个 minor 也没删,7.93.5 反倒往本文件里又加了一条迁移。
@@ -25,7 +26,7 @@
  * ⇒ 换成本段:**升一次级把存量字节改完,兼容臂当场删干净**。代价是每一条在它的窗内每次启动都要跑一遍(第二次起全是
  * 零命中的空转);收益是窗关之后可以把那一条连同它的 SQL 一起删,而读腿从引入那一版起就只有**一种**读法。
  *
- * ## 已退役的 M1–M11 与 M14
+ * ## 已退役的 M1–M12 与 M14
  * 退役的整树快照索引表(M1)、退役的单座 steering 列(M2)、被上游改了名的闭集词 `unresolvable` → `ancestor_marked`(M3)三条的改写、计数与读数
  * 窗关后已全部删码,登记行一并删。跳过了它们直接升的库由起服对账一族的拒启臂接住(`schema-consistency.ts` 头注「第二道对账」一节:两件退役 schema
  * 任一在场 ⇒ 拒启、点名出路;先于一切建表)—— 那一道没有窗,所以不在本文件里。本段入口({@link runSqlOneTimeMigrations})不问这一问。
@@ -64,12 +65,13 @@
  *    那一行不参与任何检查,但撤销口删不动它(引擎的写臂对这种 scope 同样拒)。出路 = 运维在库里把那只桶的那一行删掉(整桶 OCC 回写,指纹按 `buildRuleBucketChecksum` 重算)。
  *    起服不再逐桶扫描、也不再有逐行 / 逐桶的删除告警;读腿整桶拒的桶照旧整桶拒(出路是人)。local 车道的持久规则在引擎自己的 File 分区里,这一半对它本来就是空转。
  *
+ * M12(停驻行模式词读法记号的拒臂;不写库;7.150.0 删,窗 2026-11-08 关,发版日前已关)同样已删码,登记行一并删:判据、拒臂与答复、两处记号写点与 ctx 上的记号位都没有了,续跑重放不再问「行上有没有记号」。逐条写跳过了它直接升的库由谁接住:
+ * ⑦ 停驻行模式词读法记号的拒臂(M12):没有响亮臂 —— 7.121.x 及以前写下、此刻仍停驻的行(把 `APPROVAL_TERMINAL_BACKSTOP_MS` 调长的部署,或跳过了带本条的版本直接升的库)体里是请求原词、没有记号;
+ *    在设了 `AUTONOMY=plan` 的部署上不再被拒,续跑按体里的原词重放(运维的 plan 不再被按段重钳;`plan_review` 的驳回仍由引擎留在 plan)。存量行上的那只记号键原样留着、无人读。出路 = 升级前把这些停驻的 run 决掉 / 取消,
+ *    或升级窗内设 `AUTONOMY=read-only`(按段的只读围栏)。
+ *
  * ## 窗内的迁移(逐条的失败方向刻意不同)
- *  · **M12 停驻行模式词读法记号的拒臂**(7.122.0)—— 持久数据「响亮拒」那一半:7.122.0 起一条 run 的模式词只有存储体顶层 `permissionMode`
- *    一个源(提交入口盖运维 `AUTONOMY=plan` 的地板一次),更早的行体里是请求原词、运维的 plan 由治理层每段重钳。续跑重放之前:本部署此刻有入口地板 ∧
- *    ctx 上没有当前记号 `"entry_word"` ∧ 体的生效词被地板钳会变 ⇒ 认领之前 409、行字节不动。规则、拒句与写点在 `http/checkpoint-ctx.ts` 顶注第三问。
- *    没有读数键(它不写库)。
- *  · **M13 盘上 LKG 信封 formatVersion 2 → 3**(7.123.0)—— 不在店里(配置候选的盘上缓存,与 M12 同为非店迁移):被丢目录条目收成一份载体
+ *  · **M13 盘上 LKG 信封 formatVersion 2 → 3**(7.123.0)—— 不在店里(配置候选的盘上缓存):被丢目录条目收成一份载体
  *    (`models.droppedCatalogEntries`,每条被丢的目录条目一行),7.122.0 及以前写的 2 只记了有名且启用的行、记在旧键 `droppedIdentities`。
  *    `config-lkg.ts` `loadLkg` 读回 2 时在内存里迁一次(旧载体搬成新载体、去掉 etag ⇒ 中心可达后第一拍整拉、重铸完整载体),启动日志
  *    `config_lkg_migrated` 一行;写盘一律写 3。规则与判形在 `config-lkg.ts` 顶注与 `migrateV2Lkg`。没有读数键(它不写库)。
@@ -356,7 +358,7 @@
  *    `approval_ask.execution_lane` 与会话的 `execution_lane`(`session_meta` 上;M41 搬过之后在 `session_ext` 上 —— 三张表逐张读形,列在哪张改哪张)(本段**第一步**,先于任何写:列不在 ⇒ 那一张零动作 —— 跳版升上来的库由 M32 加列、按声明车道回填,不会再铸旧词);
  *    local 的会话元数据边档(`session-incarnations.json` 的 `[会话].execution.lane`,**排在严格边档对账之前** —— `LocalBackend.ensureSchema()` 第一步,否则旧词先撞严格拒)
  *    与问账日志(排在 M32 的 local 问回填之前,一次压实重写整本)。**版本围栏(停-迁-起)**:旧副本不认 `none`、新读者不认旧词,列形不变 ⇒ 混跑没有列检查拦得住。
- *    SQL:还有旧词行要改 ∧ 本库上仍有 run 在心跳(`task_run` 的 `running` 行在 `REAP_RUN_STALE_SEC` 之内更新过 —— 收割器判活的同一条谓词)⇒ 拒启
+ *    SQL:还有旧词行要改 ∧ 有停-迁-起证据(`readOlderReplicaEvidence`:`task_run` 的 `running` 行在 `REAP_RUN_STALE_SEC` 之内更新过 —— 收割器判活的同一条谓词 —— 且持有者没有登记为知道 M40)⇒ 拒启
  *    (`config.execution_lane_rename_refused`,一行没改;拒句给最新心跳时刻与「全停之后何时再起」);没有旧词行 ⇒ 零动作、可滚动。local:数据根的起服锁(core `FileStorageBackend` 的 `LOCK`)
  *    本来就只许一个进程 ⇒ 不另设守卫。读数 `executionLaneWordsRenamed`(四处合计)。幂等:第二次起服零命中零写。
  *  · **M41 会话的部署格搬出引擎座表**(7.147.0)—— 引擎座表 `session_meta` 只带引擎的列;本服务记在会话上的十二格(标题 / 置顶 / 换源通告基线 / 位置与项目 / 执行放置七列 / fork 键)
@@ -365,7 +367,8 @@
  *    (`ON DUPLICATE KEY UPDATE` / `ON CONFLICT DO UPDATE`:旁表那一行的这几格 = 根行上的值;中断后重跑同一句同一结果);② 逐行核对(每一列 null 安全相等,旁表行不在 = 缺省)——
  *    有一行不等 ⇒ 拒启 `config.session_ext_move_refused`(`copy_mismatch`,点名那只会话;一列没删,下一次起服重搬);③ **一句** `ALTER TABLE session_meta DROP COLUMN …` 删掉在场的全部部署格列
  *    (按后置条件收敛:那几列都不在)。旁表形的库(本版新建、或已搬过)⇒ 零动作。**版本围栏(停-迁-起)**:旧副本对这十二格的每一笔写在删列之后都撞未知列,
- *    搬与删之间落下的写会丢 ⇒ 还有列要搬 ∧ 本库上仍有 run 在心跳(与 M40 同一条判活谓词)⇒ 拒启(`live_runs`,一字节没写;本段第二步,紧随 M40,先于任何别的写)。
+ *    搬与删之间落下的写会丢 ⇒ 还有列要搬 ∧ 有停-迁-起证据(与 M40 同一只读法)⇒ 拒启(`older_replica`,一字节没写;本段第二步,紧随 M40,先于任何别的写)。
+ *    如实的边(7.147.0 起已披露,不改):① 搬 → ② 核对 → ③ 删列三步之间一只没被看见的旧副本落下的写会丢 —— 删列让旧写在 ③ 之后响亮失败,却挡不住 ② 与 ③ 之间那一笔。
  *    **M32 × M41 的序与读表**:迁移段里 M32 先、M41 后。M32 读两种形 —— 八列在 `session_meta` 上(7.139–7.146 形:M32 全程写根行,随后 M41 连同别的格一起搬进旁表)
  *    或部署格已在旁表(本条之后 / 新库)。旁表形里 M32 的加列 / 回填 / 收尾标记(② ④ ④b ⑥)都不跑(切换早已收尾;回填前提的拒随之不判),剩 ⓪(旧版副本建回的空退役表删掉)、围栏,
  *    与围栏拒句「采旧」造出的中途表 ③ ⑤ —— ③ 写执行格当下的家(旁表:先补行、再覆盖,`migrateDeviceBindingsOntoSideTableStatements`)。删码不改语义:本条删码时 M32 若还在,改成恒旁表形(见登记行)。
@@ -373,19 +376,19 @@
  *  · **M42 场景前缀的切换检查**(7.148.0)—— 本版起以 `_scn:` 开头的身份读作「某个人的某个场景」(恢复管线 `owner-brands.ts` 的 `partsOf`);更早的版本不保留这一前缀,
  *    自称 `_scn:<x>:<y>` 的调用方写下的行在本版会被读成另一个人的场景。**持久数据「响亮拒」那一半,不改写**:库里没有本条的标记 ⇒ 只读扫存量身份(本树建表句里名字以
  *    owner / scope / principal / subject 结尾、且库里在的每一列;local = run / 会话 / 问 / 附件四处 File 店的属主),一处命中 ⇒ 拒启 `config.scenario_prefix_switch_refused`(点名来源与行数,
- *    一字节没写);零命中 ⇒ 写标记;有标记 ⇒ 不扫(本版自己写下的合法 `_scn:` 行不让第二次起服拒启)。**停-迁-起(SQL)**:零命中而判活窗内仍有 run 在心跳(与 M40 / M41 同一条
- *    判活谓词)⇒ 同码拒启(`live_runs`),标记不写 —— 更早版本的副本不保留前缀,扫描之后它还会收下这类身份。标记随库(SQL:本条自己建的标记表一行;local:数据根里一只文件),
+ *    一字节没写);零命中 ⇒ 写标记;有标记 ⇒ 不扫(本版自己写下的合法 `_scn:` 行不让第二次起服拒启)。**停-迁-起(SQL)**:零命中而有停-迁-起证据(与 M40 / M41 同一只
+ *    读法)⇒ 同码拒启(`older_replica`),标记不写 —— 更早版本的副本不保留前缀,扫描之后它还会收下这类身份。标记随库(SQL:本条自己建的标记表一行;local:数据根里一只文件),
  *    不随进程。**第一步**:先于任何写(拒了就是一字节没动)。律、扫描面、拒句的唯一属主 = `scenario-prefix-switch-m42.ts`。读数 `scenarioPrefixSourcesScanned`(0 = 标记在场)。
  *  · **M43 撤回出口的启用标记**(7.148.0)—— 不改任何存量行。提交出口撤回一只「受理之前就被拒」的提交铸下的会话之前,读旁表的客户端写计数 `client_writes`
  *    (四个客户端写者在锁住根行之后同一事务 +1,`plugins/session-ext-table.ts`);更早版本的副本的写者不计数 ⇒ 混跑窗里它刚给这只会话改了标题,撤回却读到 0,会把人写过的会话删掉。
  *    ⇒ 撤回出口只在本库的**标记行**落下之后启用(标记表与 M42 同一张,属主 `one-time-migration-marker.ts`;读者 = 撤回事务里的部署判据 `plugins/session-withdraw-sql.ts`,标记未落 ⇒ 答 `upgrade_pending` = 留,
- *    幽灵会话照旧)。标记由本步落:标记不在 ∧ 判活窗内没有 `running` run 更新过(与 M40 同一条谓词)⇒ 落;有 ⇒ 不落、**不拒启**,下一次起服再判(M42 的停-迁-起守卫在同一版里先拒过一次)。
+ *    幽灵会话照旧)。标记由本步落:标记不在 ∧ 没有停-迁-起证据(与 M40 同一只读法;登记为知道 M43 的副本持有的 run 不算)⇒ 落;有 ⇒ 不落、**不拒启**,下一次起服再判(M42 的停-迁-起守卫在同一版里先拒过一次)。
  *    读数 `withdrawMarkWritten`。local 车道:数据根独占、没有混跑窗,版本位在会话元数据格上(`clientWrites`,本版铸的格都带),恒零。
  *  · **M51 会话在删态的切换**(7.148.0)—— 不改任何存量行。本版起删会话按会话三态走(活 → 在删 → 没了,律在 `src/session-deletion.ts`):围栏写旁表 `session_ext.deleting_token`,
  *    认领点(规则 L)读它、删除路只在围栏判一次认领。更早版本的副本不读在删态 ⇒ 混跑时它会在一只在删的会话上收下提交、建 run,而本版删除路的账本腿已不再判认领 ——
- *    比修前更坏。⇒ **停-迁-起**,没有运行期开关:标记表(与 M42 同一张)无 `M51` 行 ∧ 判活窗内有 `running` run 心跳(与 M40 / M41 / M42 同一条谓词 {@link readLiveRunHeartbeat})
- *    ⇒ 拒启 `config.session_deleting_switch_refused`(`live_runs`,一字节不写,拒句给可再起的时刻);无心跳 ⇒ 落标记(之后本版副本自己的 run 不再挡起服)。
- *    看不见的边与 M43 同:空闲的旧副本(零 `running` run)没有心跳 —— MIGRATION 本版节写「全部旧副本停下再起」。读数 `sessionDeletingSwitchMarked`(0 或 1)。
+ *    比修前更坏。⇒ **停-迁-起**,没有运行期开关:标记表(与 M42 同一张)无 `M51` 行 ∧ 有停-迁-起证据(与 M40 / M41 / M42 同一只读法 {@link readOlderReplicaEvidence})
+ *    ⇒ 拒启 `config.session_deleting_switch_refused`(`older_replica`,一字节不写,拒句给可再起的时刻);没有 ⇒ 落标记(之后不再判)。
+ *    看不见的边与 M43 同:空闲的、早于副本登记的旧副本(零 `running` run)没有证据 —— MIGRATION 写「全部旧副本停下再起」。读数 `sessionDeletingSwitchMarked`(0 或 1)。
  *    local 车道:数据根独占、没有混跑窗 ⇒ 恒零。
  *  · **M44 run 的 `errorCode` 只读列**(7.148.0)—— 码的唯一读法是 `task_run.error_code` 列;写 `result` 的三个写口同写这一列(停驻两口此前不写)。**改写半场**:
  *    按 `task_id` 键集分批扫 `result IS NOT NULL` 的行,目标 = 「这条行在稳定、非到期时修前 `GET` 会答的码」= 结果投影的码(`persistedPlaneOf`,读盘面认两代形并折码)?? 列原值;
@@ -446,6 +449,11 @@
  *    (删 `taskId` 名下的问与批 —— 今天删会话级联的一个子集,语义不丢,`InMemoryApprovalAskStore.deleteByTaskM50`)并算删行记录,构造器末段的起服压实把整本重写成存活行的快照、记录离盘
  *    (压实失败 ⇒ 位留着,下一次写或下一次窗内起服再压;重放幂等),恰一行 stderr 点名条数与账本;窗关之后 ⇒ 同一条记录拒启(`StoreBootRefusalError`,拒因点名本条、
  *    窗的最后一天与出路:用早于本条的版本起服一次 —— 它认得这只词,起服即压实删行记录),删码因此是零行为变化。没有起服读数键(它不经迁移段跑,读数是那一行 stderr)。只 local(SQL 两方言从来没有这只词)。
+ *  · **M52 停-迁-起证据的心跳一半**(7.150.0)—— 不改库。停-迁-起守卫(M40 · M41 · M42 · M51)与 M43 的标记判「库上还有不知道这条迁移的副本在服务吗」只经一只读法
+ *    `readOlderReplicaEvidence`:判活窗内心跳过的 `running` run,按持有者分组,减去登记为知道这条迁移的持有者(副本能力登记 `replica-registration.ts`,常设;本版起每只进程在
+ *    迁移段头登记一行)。早于副本登记的副本不登记,只经它们持有的 run 心跳可见 —— 这一半(与它的判活窗输入 `liveRunWindowMs`)就是本行,窗内才在;
+ *    登记一半本版**不判活**,只作归因(点名持有者)。看不见的边如实:空闲的、早于副本登记的副本没有任何证据(终局边界,运维停光旧副本是第一道);
+ *    登记行不续期、不观察,**不是围栏**。没有读数键(它不写库)。local 车道:数据根独占 ⇒ 守卫没有判活腿,恒不读。
  *
  * ## 收据账(一次起服一只,每一条迁移同一只)
  * 每一步把它**已提交**的改写 / 删除与点名读数当场记进同一只收据账({@link MigrationReceipts}):计数随每次提交累加、行随每次提交追加、形读数在那一步落定时写。走完 ⇒
@@ -471,6 +479,8 @@ import type { ExecutionLane } from "../execution-lane-caps.js";
 import { type ImportedLayerRootAllowRetired, type ImportedLayerRootBucketSkipped, type ImportedLayerRootRetirementSource } from "./imported-layer-root-retirement.js";
 import { type LocalPlacementBackfillSeat, type UnusableArchiveWord } from "../execution-placement.js";
 import type { PendingShapeChange } from "./schema-consistency.js";
+import { type OlderReplicaEvidence } from "./stop-then-start-sentence.js";
+import { type ReplicaCapability, type ReplicaRegistration } from "./replica-registration.js";
 /** 迁移读数(启动日志一行写全;测试按它断言,不靠日志文本)。 */
 export interface OneTimeMigrationReport {
     /** M17:`session_policy` 装规则的那一列 —— `renamed` = 本次把 `rules` 改名成 `rule_entries`;`current` = 早已是新名(新库 / 第二跑);
@@ -693,7 +703,7 @@ export declare class OneTimeMigrationInterruptedError extends Error {
  * 规则(窗长 30 天、窗关后的第一个 minor 删码、门怎么判)在本文件头注「窗」一节,只写那一次。
  */
 export interface OneTimeMigrationWindow {
-    /** 本文件里的条目名(头注「窗内的迁移」的 M12…)。 */
+    /** 本文件里的条目名(头注「窗内的迁移」的 M13…)。 */
     readonly id: string;
     /** 引入这条迁移的版本 = 第一只含其代码的发布 tag(取证:`git log -S '<该条的常量名>' -- src/plugins/one-time-migrations.ts`
      *  找引入提交 → `git tag --contains <提交> --sort=creatordate` 取最早)。 */
@@ -719,11 +729,22 @@ export interface OneTimeMigrationWindow {
      */
     readonly shapeChanges?: readonly PendingShapeChange[];
     /**
-     * 本条是**停-迁-起**迁移:起服时的守卫在判活窗(`REAP_RUN_STALE_SEC`)内库里还有 run 在心跳时拒启、一字节不写(动作段的唯一属主 = `stop-then-start-sentence.ts`)。
-     * 值 = 一句英文:更早版本的副本在迁移之后还会写什么、写了会怎样 —— 起服列册对账的升级清单(`schema-consistency.ts` 的 `describeUpgradeChecklist`)把它原样列给运维,
+     * 本条是**停-迁-起**迁移:起服时的守卫在有停-迁-起证据时拒启、一字节不写(动作段的唯一属主 = `stop-then-start-sentence.ts`)。两格见 {@link StopThenStartRow}:
+     * 缘由句与「这只库还欠不欠本条」的唯一读法 —— 起服列册对账的升级清单(`schema-consistency.ts` 的 `describeUpgradeChecklist`)只列这只库还欠的行、把缘由句原样列给运维,
      * 于是「本构建有哪几条要先停光旧副本」只有这一处在写、随行删码一起没。读者 = {@link stopThenStartMigrations}。
      */
-    readonly stopThenStart?: string;
+    readonly stopThenStart?: StopThenStartRow;
+}
+/**
+ * 一条停-迁-起迁移的登记格(一句话 + 一只只读判据的引用;登记表里只写引用,判据的码在本条的迁移步旁边):
+ *  · `reason` —— 一句英文:更早版本的副本在迁移之后还会写什么、写了会怎样(升级清单原样列给运维);
+ *  · `owedOn` —— **这只库还欠不欠本条**的唯一读法(只读,一字节不写):本条的守卫先问它(不欠 ⇒ 零动作、不读证据),升级清单第 2 步只列它答「欠」的行 ——
+ *    清单不另判(修前清单按登记表全列、不判欠不欠,对走过这几条的库说「不可滚动」,与守卫的放行是一事两说)。读口是列册对账同一只无参读口
+ *    {@link SchemaProbeRead}:判据的语句只内联本文件的常量(标记键 / 退役词 / 表名列名,与 `tableExists` / `columnExists` 同形),不带参数。
+ */
+export interface StopThenStartRow {
+    readonly reason: string;
+    readonly owedOn: (read: SchemaProbeRead, dialect: SqlDialect) => Promise<boolean>;
 }
 /**
  * 🔴 [ref] —— 一次性迁移登记表,本文件各条的窗的**唯一属主**。别处(接口 JSDoc、调用点、DDL 注、部署文档)只写「窗口见
@@ -749,13 +770,12 @@ export declare function migrationWindowEnd(id: string): string;
  */
 export declare function migrationCarried(id: string): boolean;
 /**
- * 本构建带的**停-迁-起**迁移(登记行的 `stopThenStart` 一格;行在 ⇔ 码在 ⇒ 起服会在这一条上判活)。读者 = 起服列册对账的升级清单:拒句把它们一次列给运维。
- * 登记表里再没有这样的行时返回空数组 —— 清单的这一步随之不出。
+ * 本构建带的**停-迁-起**迁移(登记行的 `stopThenStart` 一格;行在 ⇔ 码在 ⇒ 起服会在这一条上判活),按登记表顺序。读者 = 起服列册对账的升级清单:
+ * 逐行问 `owedOn`,只把这只库还欠的列给运维。登记表里再没有这样的行时返回空数组 —— 清单的这一步随之不出。
  */
-export declare function stopThenStartMigrations(registry?: readonly Pick<OneTimeMigrationWindow, "id" | "stopThenStart">[]): readonly {
+export declare function stopThenStartMigrations(registry?: readonly Pick<OneTimeMigrationWindow, "id" | "stopThenStart">[]): readonly ({
     readonly id: string;
-    readonly reason: string;
-}[];
+} & StopThenStartRow)[];
 /** local 车道上 SQL 独有的几条(M17 / M18 / M21 / M23 / M24 / M26 / M27 / M29)的读数(M32 的回填两车道都有、M33 只在 local,local 腿的读数由 `LocalBackend.runOneTimeMigrations` 现算):那几张表 / 列在文件底座上从来不存在 ⇒ 如实答 absent / 0。 */
 export declare const NO_SQL_MIGRATIONS: Omit<OneTimeMigrationReport, "runErrorCodeColumnRewritten" | "runObjectivePreviewRewritten" | "shellSentinelOwnersCleared" | "shellSentinelOwnerRowsRetained" | "checkpointHostSessionsBackfilled" | "legacySkillExemptionsDropped" | "executionPlacementsBackfilled" | "askExecutionLanesBackfilled" | "executionLaneWordsRenamed" | "scenarioPrefixSourcesScanned" | "executionPlacementSessionsUnreadable" | "localArchiveRowFactsBackfilled" | "localArchivesAnonymized" | "localArchivesKeptStamped" | "localArchivesUnreadable" | "localArchiveSnapshotsRecovered" | "localArchiveTokensAdopted" | "localArchiveTokensMinted" | "askJournalRecordsUpgraded" | "importedLayerRootAllowsRetired" | "importedLayerRootBucketsSkipped" | "importedLayerRootBucketsUnnamed">;
 /** 启动期的日志口(logger 的子集)。两级各有其用,见 {@link logOneTimeMigrations}。 */
@@ -795,7 +815,12 @@ export interface MigrationDb {
  * 判官不在两处各写一份。
  */
 export declare function createSqlImportedLayerRootSource(exec: Parameters<typeof listRuleBucketOwners>[0]): ImportedLayerRootRetirementSource;
-export declare function runSqlOneTimeMigrations(dialect: SqlDialect, pool: MysqlPool | PgPool, input: SqlOneTimeMigrationInput): Promise<OneTimeMigrationReport>;
+/**
+ * **段头**(常设两步,不带窗;只在这里排序;与迁移步同一条连接):两张表在(不在 ⇒ 拒,点名公开序列)→ 本进程登记(`replica-registration.ts`)→ 起服准入**锁外预读**(`serving-requirement.ts`)
+ * → 取迁移锁 → **锁内复核**(同一判据;本进程等锁期间握锁的那一只写下的要求在这里读得到)→ 各迁移步。准入拒 ⇒ 一步迁移都不跑。
+ * 登记在任何守卫读证据之前、本进程能持有任何 run 之前落下;跳过 `ensureSchema()` 的嵌入方走同一段。`me` 缺省 = 本进程的登记行;真库钉传别的构建(能力名单不同的起服者)。
+ */
+export declare function runSqlOneTimeMigrations(dialect: SqlDialect, pool: MysqlPool | PgPool, input: SqlOneTimeMigrationInput, me?: ReplicaRegistration): Promise<OneTimeMigrationReport>;
 /** M48 的那一步(见头注 M48 段):输入显式说「没有身份边界」⇒ 改写 —— 改写面里的每张表一句按值的 `UPDATE`(表不在 ⇒ 跳过);写后不再有哨兵值 ⇒ 第二跑零命中。
  *  其余一切(有身份边界,或绕过类型缺这一格 / 不是布尔 ⇒ fail-closed,不静默放宽)零改写,但对同一批表用**同一句 WHERE**({@link shellSentinelOwnerWhereM48})数一遍留着的行,
  *  非零的面记进 `shellSentinelOwnerRowsRetained`(起服日志一行 warn;见头注)。值**逐字节**比的理由在 {@link shellSentinelOwnerWhereM48}。 */
@@ -815,12 +840,12 @@ export declare function dropLegacySkillExemptionsM46(db: MigrationDb, dialect: S
 export declare const SESSION_DELETING_MARK_ID = "M51";
 /** M51 起服拒的机读码(确定的拒启表态:全停之后再起才有另一个答案)。 */
 export declare const SESSION_DELETING_SWITCH_REFUSED_CODE = "config.session_deleting_switch_refused";
-/** M51 起服拒:标记还没落,而判活窗内仍有 run 在心跳(拒因闭集只有 `live_runs`)。 */
+/** M51 起服拒:标记还没落,而有停-迁-起证据(拒因闭集只有 `older_replica`)。 */
 export declare class SessionDeletingSwitchRefusedError extends StoreBootRefusalError {
     readonly code = "config.session_deleting_switch_refused";
-    readonly reason: "live_runs";
+    readonly reason: "older_replica";
     /** `tail` = 库此刻还差的列(`describeUpgradeDriftTail`;列齐 ⇒ 空串):一次起服读全,不必补一句再试。 */
-    constructor(live: LiveRunHeartbeat, tail?: string);
+    constructor(evidence: OlderReplicaEvidence, tail?: string);
 }
 /**
  * M42 的扫描面:本树建表句(两方言各自的录制,与起服列册对账同一份)里名字合 {@link IDENTITY_COLUMN_NAME}、类型是字符 / 字节串的列,与库里实际在的列取交(条件建的表不在库里 ⇒ 不扫)。
@@ -832,12 +857,12 @@ export declare function scannedIdentityColumnsM42(db: Pick<MigrationDb, "rows">,
 }[]>;
 /**
  * 🔴 M42 的 SQL 腿:标记在场 ⇒ 返回(零扫描);否则逐列只读计数 `LIKE '<前缀>%'`,一处命中 ⇒ {@link ScenarioPrefixSwitchRefusedError}(`stored_prefix`;一字节没写,标记不写);
- * 零命中而判活窗内仍有 run 在心跳 ⇒ 同一只拒(`live_runs`,停-迁-起;标记不写);否则写标记。
+ * 零命中而有停-迁-起证据({@link readOlderReplicaEvidence})⇒ 同一只拒(`older_replica`;标记不写);否则写标记。
  * 握着迁移段的那一把锁、在那一条连接上:两只副本同时起服时第二只读到第一只写下的标记(写标记用 `INSERT IGNORE` / `ON CONFLICT DO NOTHING`,收敛)。
  */
 export declare function switchScenarioPrefixM42(db: MigrationDb, dialect: SqlDialect, receipts: {
     scenarioPrefixSourcesScanned: number;
-}, input: ExecutionLaneRenameInput): Promise<void>;
+}, input: LiveRunWindowInput): Promise<void>;
 /** M40 的拒启码(停-迁-起守卫)。 */
 export declare const EXECUTION_LANE_RENAME_REFUSED_CODE = "config.execution_lane_rename_refused";
 /**
@@ -847,7 +872,7 @@ export declare const EXECUTION_LANE_RENAME_REFUSED_CODE = "config.execution_lane
 export declare class ExecutionLaneRenameRefusedError extends StoreBootRefusalError {
     /** 带旧词的行数(两张表合计)。 */
     readonly pendingRows: number;
-    /** 判活窗内心跳过的 `running` run 数。 */
+    /** 停-迁-起证据里的 `running` run 数(持有者没有登记为知道 M40)。 */
     readonly liveRuns: number;
     /** 全停之后可以再起的最早时刻(ISO;= 最新心跳 + 判活窗 —— 那时收割谓词也判它们为死)。 */
     readonly restartAfter: string;
@@ -855,7 +880,7 @@ export declare class ExecutionLaneRenameRefusedError extends StoreBootRefusalErr
     constructor(
     /** 带旧词的行数(两张表合计)。 */
     pendingRows: number, 
-    /** 判活窗内心跳过的 `running` run 数。 */
+    /** 停-迁-起证据里的 `running` run 数(持有者没有登记为知道 M40)。 */
     liveRuns: number, 
     /** 全停之后可以再起的最早时刻(ISO;= 最新心跳 + 判活窗 —— 那时收割谓词也判它们为死)。 */
     restartAfter: string, detail: string);
@@ -875,8 +900,8 @@ export declare class ExecutionLaneRenameWriteRefusedError extends StoreBootRefus
     /** 落不了盘的那只文件(绝对路径)。 */
     file: string, cause: unknown);
 }
-/** M40 的输入:判活窗(毫秒)= 本部署的 `REAP_RUN_STALE_SEC` —— 收割器判「这条 run 的持有者还活着」用的同一个窗。 */
-export interface ExecutionLaneRenameInput {
+/** 停-迁-起证据读法心跳一半的输入(归 M52 行):判活窗(毫秒)= 本部署的 `REAP_RUN_STALE_SEC` —— 收割器判「这条 run 的持有者还活着」用的同一个窗。 */
+export interface LiveRunWindowInput {
     readonly liveRunWindowMs: number;
 }
 /** M48 的输入:本部署有没有身份边界 = 部署形表 `DEPLOYMENT_SHAPE_PREDICATES.identityBoundary` 那一行的读数(只读配置;调用方读表交来,迁移步不另读配置)。
@@ -885,27 +910,27 @@ export interface ShellSentinelOwnerInput {
     readonly identityBoundary: boolean;
 }
 /** SQL 一次性迁移段的输入(各条目自己的那一半;删码车删掉它那一半)。 */
-export type SqlOneTimeMigrationInput = ExecutionPlacementSwitchInput & ExecutionLaneRenameInput & ShellSentinelOwnerInput;
+export type SqlOneTimeMigrationInput = ExecutionPlacementSwitchInput & LiveRunWindowInput & ShellSentinelOwnerInput;
 /**
  * M40 ⓪ —— 带 `execution_lane` 列的表上的旧词改成新名(问行表 + 会话的那一列所在的表:M41 搬之前在 `session_meta`、之后在 `session_ext`;一句 UPDATE 一张表;幂等:第二跑零命中)。列不在的表零动作(跳版升上来的库:M32 稍后加列、按声明车道回填,不会再铸旧词)。
  * 还有旧词行 ⇒ 先过停-迁-起守卫({@link refuseWhileRunsHeartbeat});没有 ⇒ 不读 run 表、零写(没跑过无车道部署的库可滚动升级)。
  */
 export declare function renameRetiredExecutionLaneWordsM40(db: MigrationDb, dialect: SqlDialect, receipts: {
     executionLaneWordsRenamed: number;
-}, input: ExecutionLaneRenameInput): Promise<void>;
-/** 判活窗内的 `running` run 心跳(停-迁-起守卫的读数;M40 / M41 同读):没有 ⇒ `undefined`。 */
-interface LiveRunHeartbeat {
-    readonly liveRuns: number;
-    readonly windowSec: number;
-    /** 全停之后可以再起的最早时刻(ISO;= 最新心跳 + 判活窗;读不出最新心跳 ⇒ 现在 + 窗,上界)。 */
-    readonly restartAfter: string;
-    /** 同一时刻的人读形(带「离现在还有几秒」)。 */
-    readonly after: string;
-}
+}, input: LiveRunWindowInput): Promise<void>;
+/**
+ * **停-迁-起证据的唯一读法**(M40 / M41 / M42 / M43 / M51 同读;拒句与读数的句子属主 = `stop-then-start-sentence.ts`):判活窗内心跳过的 `running` run
+ * (收割器 `reapStale` 判活的同一条谓词:`status = 'running'` ∧ `updated_at` 在 `REAP_RUN_STALE_SEC` 窗内),按持有者(`task_run.instance_id`,建行铸、认领接管)分组,
+ * **减去登记为知道 `migrationId` 的持有者**(`replica-registration.ts`;`knows` 与起服准入同一只判据)—— 剩下的 run 就是证据:持有者没有登记行(早于副本登记的副本、`NULL` 身份、
+ * 自传身份的嵌入方)或登记了而能力名单里没有这条迁移,照算(保守)。登记一半只作归因(点名持有者),**不判活**。
+ * 本进程此刻还在迁移段里、一条 run 都没起过 ⇒ 证据里只有别的进程。`task_run` 不在 ⇒ `undefined`。心跳一半随 M52 行删(那一行的 `removal`)。
+ * `migrationId` 在型上就要在能力名单里(`ReplicaCapability`):一条迁移读证据 ⇔ 它的名在名单里。
+ */
+export declare function readOlderReplicaEvidence(db: MigrationDb, dialect: SqlDialect, input: LiveRunWindowInput, migrationId: ReplicaCapability): Promise<OlderReplicaEvidence | undefined>;
 /** M41 的拒启码(确定的拒启表态;与 `config.schema_mismatch` 同一族)。 */
 export declare const SESSION_EXT_MOVE_REFUSED_CODE = "config.session_ext_move_refused";
-/** 拒因闭集:`live_runs` = 还有列要搬而本库上仍有 run 在心跳(停-迁-起);`copy_mismatch` = 搬完核对有一行不等(一列没删)。 */
-export type SessionExtMoveRefusalReason = "live_runs" | "copy_mismatch";
+/** 拒因闭集:`older_replica` = 还有列要搬而有停-迁-起证据;`copy_mismatch` = 搬完核对有一行不等(一列没删)。 */
+export type SessionExtMoveRefusalReason = "older_replica" | "copy_mismatch";
 /** M41 的起服拒。具名类型 + 机读码 + 拒因;继承 {@link StoreBootRefusalError}:SQL 开库的等待窗不重试它。 */
 export declare class SessionExtMoveRefusedError extends StoreBootRefusalError {
     readonly reason: SessionExtMoveRefusalReason;
@@ -913,10 +938,10 @@ export declare class SessionExtMoveRefusedError extends StoreBootRefusalError {
     constructor(reason: SessionExtMoveRefusalReason, detail: string);
 }
 /**
- * M41 ⓪′ —— 停-迁-起守卫(紧随 M40 的守卫,先于任何别的写):还有部署格列要搬 ∧ 本库上仍有 run 在心跳 ⇒ 拒 `live_runs`,一字节没写。
+ * M41 ⓪′ —— 停-迁-起守卫(紧随 M40 的守卫,先于任何别的写):还有部署格列要搬 ∧ 有停-迁-起证据({@link readOlderReplicaEvidence})⇒ 拒 `older_replica`,一字节没写。
  * 旁表形 ⇒ 零动作(不读 run 表)。
  */
-export declare function refuseSessionExtMoveWhileRunsHeartbeat(db: MigrationDb, dialect: SqlDialect, input: ExecutionLaneRenameInput): Promise<void>;
+export declare function refuseSessionExtMoveWhileRunsHeartbeat(db: MigrationDb, dialect: SqlDialect, input: LiveRunWindowInput): Promise<void>;
 /**
  * M41(规则与理由见头注 M41 段):① 搬(键集分页 upsert)→ ② 逐行核对 → ③ 一句删列。旁表形 ⇒ 零动作。中断 ⇒ 下一次起服从头重跑:① 的 upsert 是「旁表这几格 = 根行上的值」,
  * 重跑同一结果;② 只读;③ 按后置条件收敛(那几列都不在)。排在迁移段最后(M32 之后:M32 读 / 写 `session_meta` 上的八列;M23 改的是引擎列)。导出给真库钉驱动「中断后续跑」。