@sema-agent/server 7.139.0 → 7.141.0

package/dist/plugins/execution-placement-sql.d.ts

@@ -6,7 +6,7 @@
  *  · **列定义唯一属主**(两方言):中央 DDL(`tidb-pool.ts` 的 `CREATE TABLE session_meta`、`pg-session-storage.ts` 的 `PG_SESSION_SCHEMA`)内插
  *    {@link sessionMetaPlacementColumnsDdl}(先例:`SESSION_META_INCARNATION_COLUMN`);起服列册对账(`schema-consistency.ts`)从同一份建表文本解析期望列集。
  *    存量库的加列只由一次性迁移做,`ensureSchema` 不 ALTER(SCHEMA POLICY)。
- *  · **语句唯一属主**:会话店(执行席、导入写口)与设备店(首绑 / 换绑)、一次性迁移(搬绑定 / 回填)的事务都借这里的语句,别处零手写。
+ *  · **语句唯一属主**:会话店(执行席、导入写口)与设备店(首绑 / 换绑 / 绑定数)、一次性迁移(搬绑定 / 回填)的事务都借这里的语句,别处零手写。
  *    语句是方言无关的 `{ text, values }`(调用方用自己的连接跑:SqlDriver 的 `SqlTxConn`、node-pg 的客户端、mysql2 的连接都行)。
  *
  * ## 住客谓词(写与 judged 复核的唯一定址)
@@ -35,35 +35,35 @@ export interface PlacementStatement {
  */
 export declare const SESSION_META_PLACEMENT_COLUMNS: readonly [{
     readonly name: "execution_role";
-    readonly tidb: "execution_role VARCHAR(16) NULL";
+    readonly mysql: "execution_role VARCHAR(16) NULL";
     readonly pg: "execution_role VARCHAR(16) COLLATE \"C\"";
 }, {
     readonly name: "execution_lane";
-    readonly tidb: "execution_lane VARCHAR(32) NULL";
+    readonly mysql: "execution_lane VARCHAR(32) NULL";
     readonly pg: "execution_lane VARCHAR(32) COLLATE \"C\"";
 }, {
     readonly name: "execution_device_id";
-    readonly tidb: "execution_device_id VARCHAR(64) NULL";
+    readonly mysql: "execution_device_id VARCHAR(64) NULL";
     readonly pg: "execution_device_id VARCHAR(64) COLLATE \"C\"";
 }, {
     readonly name: "execution_device_owner_tenant";
-    readonly tidb: "execution_device_owner_tenant VARCHAR(190) NULL";
+    readonly mysql: "execution_device_owner_tenant VARCHAR(190) NULL";
     readonly pg: "execution_device_owner_tenant VARCHAR(190) COLLATE \"C\"";
 }, {
     readonly name: "execution_device_owner_subject";
-    readonly tidb: "execution_device_owner_subject VARCHAR(190) NULL";
+    readonly mysql: "execution_device_owner_subject VARCHAR(190) NULL";
     readonly pg: "execution_device_owner_subject VARCHAR(190) COLLATE \"C\"";
 }, {
     readonly name: "execution_placed_at";
-    readonly tidb: "execution_placed_at DATETIME(3) NULL";
+    readonly mysql: "execution_placed_at DATETIME(3) NULL";
     readonly pg: "execution_placed_at TIMESTAMPTZ(3)";
 }, {
     readonly name: "execution_rev";
-    readonly tidb: "execution_rev BIGINT NULL";
+    readonly mysql: "execution_rev BIGINT NULL";
     readonly pg: "execution_rev BIGINT";
 }, {
     readonly name: "fork_key";
-    readonly tidb: "fork_key VARCHAR(255) NULL";
+    readonly mysql: "fork_key VARCHAR(255) NULL";
     readonly pg: "fork_key VARCHAR(255) COLLATE \"C\"";
 }];
 /** 中央 DDL 内插的那一段(列与列之间逗号分隔,不带首尾逗号)。 */
@@ -100,6 +100,16 @@ export declare function bindDeviceStatement(dialect: SqlDialect, root: string, o
 }, now: Date): PlacementStatement;
 /** rebind:writer(device, D) → writer(device, D'),按住客 ∧ 两属主列 ∧ rev 定址,`execution_rev + 1`(恒变列)。属主两列不动(换绑只在同一属主的设备之间)。 */
 export declare function rebindDeviceStatement(dialect: SqlDialect, root: string, occupant: SessionFace, owner: DeviceOwner, expectedRev: number, targetDeviceId: string, now: Date): PlacementStatement;
+/**
+ * 带设备列的根会话行(非委派分区行上 `execution_device_id` 非空):绑定数的读只用它**缩小**读的行 —— 一条绑定必有设备列,反之不然;
+ * 是不是一条绑定只由行的唯一解码 {@link placementCellFromRow} + `boundDeviceOf` 判(SQL 不另判一遍)。两方言同一句。
+ */
+export declare function deviceCellRowsStatement(): PlacementStatement;
+/**
+ * 绑定数:根会话行上 writer(device, D) 的格数(设备店 `countDeviceBindings` 的读;只交一个数)。逐行过唯一解码 ⇒ 解码器拒的行
+ * (设备在而属主 / rev / 时刻缺、设备落在别的车道)原样抛 {@link ExecutionPlacementRowError},不当一条绑定数进去,也不当没有。
+ */
+export declare function countDeviceBindingsOn(conn: PlacementRowsOn): Promise<number>;
 /** identical 臂补 mirror:absent / mirror → mirror,WHERE 住客谓词 ∧ 不是 writer。 */
 export declare function markMirrorStatement(dialect: SqlDialect, root: string, occupant: SessionFace): PlacementStatement;
 /** 回填(一次性迁移):无执行格、非委派分区、有 run 行的会话行 ⇒ writer(表唯一项)。幂等(第二次跑零行)。 */

package/dist/plugins/execution-placement-sql.js

@@ -1,16 +1,16 @@
 import { isExecutionLane } from "../execution-lane-caps.js";
 import { sessionFaceFromRow } from "../session-incarnation.js";
 import { toIso } from "./sql-row-helpers.js";
-import { WRITABLE, assertPlaceableLane, settledMirrorOutcome, settledPlaceOutcome, } from "../execution-placement.js";
+import { WRITABLE, assertPlaceableLane, boundDeviceOf, settledMirrorOutcome, settledPlaceOutcome, } from "../execution-placement.js";
 export const SESSION_META_PLACEMENT_COLUMNS = [
-    { name: "execution_role", tidb: "execution_role VARCHAR(16) NULL", pg: `execution_role VARCHAR(16) COLLATE "C"` },
-    { name: "execution_lane", tidb: "execution_lane VARCHAR(32) NULL", pg: `execution_lane VARCHAR(32) COLLATE "C"` },
-    { name: "execution_device_id", tidb: "execution_device_id VARCHAR(64) NULL", pg: `execution_device_id VARCHAR(64) COLLATE "C"` },
-    { name: "execution_device_owner_tenant", tidb: "execution_device_owner_tenant VARCHAR(190) NULL", pg: `execution_device_owner_tenant VARCHAR(190) COLLATE "C"` },
-    { name: "execution_device_owner_subject", tidb: "execution_device_owner_subject VARCHAR(190) NULL", pg: `execution_device_owner_subject VARCHAR(190) COLLATE "C"` },
-    { name: "execution_placed_at", tidb: "execution_placed_at DATETIME(3) NULL", pg: "execution_placed_at TIMESTAMPTZ(3)" },
-    { name: "execution_rev", tidb: "execution_rev BIGINT NULL", pg: "execution_rev BIGINT" },
-    { name: "fork_key", tidb: "fork_key VARCHAR(255) NULL", pg: `fork_key VARCHAR(255) COLLATE "C"` },
+    { name: "execution_role", mysql: "execution_role VARCHAR(16) NULL", pg: `execution_role VARCHAR(16) COLLATE "C"` },
+    { name: "execution_lane", mysql: "execution_lane VARCHAR(32) NULL", pg: `execution_lane VARCHAR(32) COLLATE "C"` },
+    { name: "execution_device_id", mysql: "execution_device_id VARCHAR(64) NULL", pg: `execution_device_id VARCHAR(64) COLLATE "C"` },
+    { name: "execution_device_owner_tenant", mysql: "execution_device_owner_tenant VARCHAR(190) NULL", pg: `execution_device_owner_tenant VARCHAR(190) COLLATE "C"` },
+    { name: "execution_device_owner_subject", mysql: "execution_device_owner_subject VARCHAR(190) NULL", pg: `execution_device_owner_subject VARCHAR(190) COLLATE "C"` },
+    { name: "execution_placed_at", mysql: "execution_placed_at DATETIME(3) NULL", pg: "execution_placed_at TIMESTAMPTZ(3)" },
+    { name: "execution_rev", mysql: "execution_rev BIGINT NULL", pg: "execution_rev BIGINT" },
+    { name: "fork_key", mysql: "fork_key VARCHAR(255) NULL", pg: `fork_key VARCHAR(255) COLLATE "C"` },
 ];
 export function sessionMetaPlacementColumnsDdl(dialect) {
     return SESSION_META_PLACEMENT_COLUMNS.map((c) => c[dialect]).join(",\n     ");
@@ -64,6 +64,17 @@ export function rebindDeviceStatement(dialect, root, occupant, owner, expectedRe
         `AND execution_device_owner_tenant = ${b.p(owner.tenant)} AND execution_device_owner_subject = ${b.p(owner.subject)} AND execution_rev = ${b.p(expectedRev)}`;
     return { text: `UPDATE session_meta SET ${set} WHERE ${where}`, values: b.values };
 }
+export function deviceCellRowsStatement() {
+    return { text: `SELECT session_id, ${SESSION_META_PLACEMENT_READ_COLUMNS} FROM session_meta WHERE execution_device_id IS NOT NULL AND placement_kind IS NULL`, values: [] };
+}
+export async function countDeviceBindingsOn(conn) {
+    const s = deviceCellRowsStatement();
+    let bindings = 0;
+    for (const row of await conn(s.text, s.values))
+        if (boundDeviceOf(placementCellFromRow(text(row.session_id), row)) !== undefined)
+            bindings += 1;
+    return bindings;
+}
 export function markMirrorStatement(dialect, root, occupant) {
     const b = binder(dialect);
     return { text: `UPDATE session_meta SET execution_role = '${MIRROR}' WHERE ${occupantPredicate(dialect, b.p, root, occupant)} AND ${NOT_WRITER}`, values: b.values };

package/dist/plugins/file-history-store-sql.d.ts

@@ -3,7 +3,7 @@ import type { Pool as PgPool } from "pg";
 import { type FileHistoryRetentionPolicy, type ExecutionEnv, type FileHistoryStore, type FileHistoryResult, type FileHistoryTrackResult, type FileHistoryRestoreResult, type FileHistoryExport, type FileHistoryExportResult } from "@sema-agent/core";
 import { type BlobBackend } from "./blob-backend.js";
 import type { SyncBlobPutResult } from "./store-backend.js";
-import { type SqlDriver } from "./sql-driver.js";
+import { type SqlDriver, type SqlDialect } from "./sql-driver.js";
 /** The file-history blob domain's SQL table (BlobBackend `table`/MinIO index binding + the A7 assert). */
 export declare const FILE_HISTORY_BLOB_TABLE = "file_history_blob";
 /** MinIO object-key prefix for this domain (snapshot epoch used "blobs/"; a separate prefix keeps the
@@ -196,5 +196,5 @@ export declare class PgFileHistoryStore extends SqlFileHistoryStore {
  */
 export declare function assertFileHistorySchema(query: (sql: string) => Promise<{
     rows: Record<string, unknown>[];
-}>, dialect: "tidb" | "pg"): Promise<void>;
+}>, dialect: SqlDialect): Promise<void>;
 //# sourceMappingURL=file-history-store-sql.d.ts.map

package/dist/plugins/file-history-store-sql.js

@@ -33,13 +33,13 @@ export class SqlFileHistoryStore {
         this.db = db;
         this.pool = pool;
         this.blobs = blobBackend ?? new SqlBlobBackend(this.db.dialect, this.pool, undefined, FILE_HISTORY_BLOB_TABLE);
-        this.boundaryKeep = resolveFileHistoryRetention(this.db.dialect === "tidb" ? "TiDBFileHistoryStore" : "PgFileHistoryStore", opts?.retention);
+        this.boundaryKeep = resolveFileHistoryRetention(this.db.dialect === "mysql" ? "TiDBFileHistoryStore" : "PgFileHistoryStore", opts?.retention);
     }
-    q(tidb, pg) {
-        return this.db.dialect === "tidb" ? tidb : pg;
+    q(mysql, pg) {
+        return this.db.dialect === "mysql" ? mysql : pg;
     }
     bool(v) {
-        return this.db.dialect === "tidb" ? (v ? 1 : 0) : v;
+        return this.db.dialect === "mysql" ? (v ? 1 : 0) : v;
     }
     leaseKey(scope, entryId) {
         return `${scope}\x00${entryId}`;

package/dist/plugins/file-run-store.d.ts

@@ -1,6 +1,6 @@
 import { type UsageRow } from "../usage-analytics.js";
 import type { TaskStatus } from "@sema-agent/core";
-import { StoreBootRefusalError, type FenceLanded, type InProcessClaimFence, type CreateRunOutcome, type NewRunMeta, type RunIdemBinding, type RunListQuery, type RunRecord, type SessionSummary, type RunEvent, type PersistedTaskResult, type LatestRunRef } from "./store-contracts.js";
+import { StoreBootRefusalError, type FenceLanded, type FencedRun, type InProcessClaimFence, type CreateRunOutcome, type NewRunMeta, type RunIdemBinding, type RunListQuery, type RunRecord, type SessionSummary, type RunEvent, type PersistedTaskResult, type LatestRunRef } from "./store-contracts.js";
 import type { RunStoreCheckpointProbe } from "./memory-run-store.js";
 import type { LedgerEventType } from "../trace/ledger-events.js";
 import { type SpaceCommitClaim, type SpaceCommitReading, type SpaceCommitState } from "../workspace-space-commit.js";
@@ -149,7 +149,7 @@ export declare class FileRunStore implements InProcessClaimFence {
     markResuming(taskId: string, instanceId: string): Promise<boolean>;
     getActiveTaskId(sessionId: string): Promise<string | undefined>;
     /** 认领当写栅栏用(契约 = `store-contracts.ts` 的 `InProcessClaimFence`):判、刷新活性(同步落盘)与 `write` 是同一个同步段。 */
-    whileHoldingClaim(sessionId: string, taskId: string, write: () => FenceLanded): boolean;
+    whileHoldingClaim(sessionId: string, taskId: string, write: (run: FencedRun) => FenceLanded): boolean;
     getRun(taskId: string): Promise<RunRecord | undefined>;
     /** Undo THIS submission's binding (key + body fingerprint → null) — called only where the submit surface refuses the submission
      *  before any work and terminalizes the row it just claimed (the sync leg's zero-work refusal, an execution-placement reject):

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

@@ -538,7 +538,7 @@ export class FileRunStore {
             return false;
         r.updatedAt = new Date();
         this.persist(r);
-        write();
+        write({ instanceId: r.instanceId });
         return true;
     }
     async getRun(taskId) {

package/dist/plugins/fork-routing-session-store.d.ts

@@ -19,12 +19,20 @@
  *    绝不打到 durable 店——那是 authorizer 的职权)。
  *  - `fork(sourceId)` → 源在哪店在哪店 fork(路由未知时 host 先试,null 再 transient);新 id 记路由。
  *  - `list`/`size`/`dispose` = transient 侧(host 店归 main runner 所有;不双列、不双清)。
+ *  - 带 placement 的建(受信 spawner:后台子代,host 声明了委派分区)→ **host**(分区住 durable 店,名册钉住,见 {@link placed})。
+ *
+ * 规则一条:**一只后台子代的 durable 行在,它的转录就是 host 店委派分区里的一只 placed 行**(活过重启、随行同亡);transient 店只装
+ * 没有任何 durable 记录指着的会话(普通子任务、前台子代)。所以停驻不搬家:声明了分区的部署上,能停驻的后台子代生来就在 host 店
+ * (停驻挂点只验它在不在,`plugins/session-store.ts` 的 `attestChildSessionDurable`);host 不声明分区的部署没有停驻挂点(core 如实答 `no_park_lane`)。
+ *
+ * 声明面两条各读各的(引擎 `SessionStore.durability` / `placements` 两条注的分工,本类就是那条注里「瞬态车道与持久分区不同的路由店」):`placements` 从 host 逐字转发(分区的耐久);
+ * 顶层 `durability` **不转发、不声明** —— 它只说**未 placed** 的会话,而本店自己铸的未 placed 会话(无 id 的普通子任务、claim-create)住进程内短 TTL 店,
+ * 转发 host 的 `durable` 等于对子 Runner 的接线清单谎报「重启不丢」(引擎对缺席读 fail-closed 的 `process_local`,这里读法就是如实)。
  *
  * 路由表 LRU 上限 {@link ROUTE_MAX}:满额逐最老(refresh-on-use);被逐后下次 `acquire` 按上述规则重derive
  * (requireExisting 的 host-first 重试仍落对店),中途 touch/noteTaskRun 缺路由=落 transient(no-op 级)。
  */
 import { type SessionStore, type AcquiredSession, type SessionStoreSummary, type SessionPlacement, type PlacedSessionRow } from "@sema-agent/core";
-import { type DelegationTree } from "../delegated-session-owner.js";
 import type { ExecutionPlacementSeat } from "../execution-placement.js";
 import type { ForkToFn } from "./session-fork.js";
 /** acquire 选项形(core 5.48 SessionStore 契约):[ref] placement=受信 spawner 的分区建会话声明。 */
@@ -38,12 +46,7 @@ export declare class ForkRoutingSessionStore implements SessionStore {
     private readonly route;
     /** pin 时的店归属——unpin 恒回同店(LRU 逐出不拆对,见 pin/unpin)。 */
     private readonly pinnedAt;
-    /** [ref] 晋升名册(探针 Finding A 修):已 promoteToHost 的 id **永久**钉 host——路由表会被 LRU
-     *  逐出,而私店的 forget 只清 entries 缓存行、底层 repo 行不清且 sweep 扫不到(core session-store.js
-     *  亲读),逐出后 transient-first 的 requireExisting 会把陈旧快照端回给 revive。本集不逐出(上界=
-     *  parked 子代数,天然小);pick/acquire 首查。 */
-    private readonly promoted;
-    /** [ref] placement 半场:placed id 名册(与 promoted 同姿势——不随路由 LRU 逐出)。placed 会话的
+    /** [ref] placement 半场:placed id 名册(不随路由 LRU 逐出)。placed 会话的
      *  真居所恒=host(分区在 durable 店),任何形的 acquire/touch/release 都不得落 transient——
      *  否则 transient 的 claim-create 会铸出同 id 影子会话,requireExisting 的 transient-first 顺序
      *  会让影子遮蔽真转录(F-7 顺序对 placed 反向成害)。 */
@@ -76,31 +79,6 @@ export declare class ForkRoutingSessionStore implements SessionStore {
     unpin(sessionId: string): void | Promise<void>;
     noteTaskRun(sessionId: string, taskId: string, runId?: string): void | Promise<void>;
     list(): Promise<SessionStoreSummary[]>;
-    /**
-     * [ref] 子代 park 晋升:把住在 transient(TTL)店的子会话**整树拷贝**进 host durable 店,然后
-     * 让该 id 从此路由到 host——`ensureChildSessionDurable` 的「主动晋升」半场(1.263 的只查不迁形在
-     * 拆店生产形下恒否决 park:子会话从不在 host 店,core 收 veto 即 expire checkpoint + settle failed,
-     * cli 真机 14ms~2s expired 即此)。
-     *
-     * 三步缺一不可:
-     *  1. 拷贝:transient 读整树(getEntries)+ 源 leaf → host 店 acquire(id)(durable 店的 acquire
-     *     缺行即建行)→ storage.appendEntry 逐条 verbatim(重复 id 容忍=幂等续迁:上次晋升半途崩的
-     *     残留行跳过)→ setLeafId(源 leaf)(分支树以源为准,不信 append 推进的 leaf)。
-     *  2. transient.forget(id):`requireExisting` 的 acquire 是 **transient-first**(F-7 裁定)——私店
-     *     副本不移除,revive 会续写进 1h TTL 副本,durable park 名存实亡。
-     *  3. 路由记 host(此后 touch/pin/release 全走 host;pinnedAt 若记着 transient 一并改写,
-     *     unpin 不落错店)。
-     *
-     * 已在 host(路由或真行)⇒ 幂等直返。两店都无此会话 ⇒ 抛(调用方=park veto,诚实 fail-closed)。
-     *
-     * [ref]:宿主行**在建行那一笔里**带属主 `owner` —— 调用方按委派继承律算好(`delegated-session-owner.ts`:委派树根的属主,
-     * 推不出 ⇒ 孤行哨兵;`tree` = 判据读到的委派树,判断用:宿主行记着别的树 ⇒ 拒),这里经宿主店的首写登记写下、再按律定夺(core `register` 契约:登记不判授权,判在复读)。
-     * 宿主店里同 id 已有一行:记着这一棵委派树且无主 ⇒ 按同一条律认领(只有记录委派树的店);别的树的 / 属主不是它(别人先认领的空壳,或 local 店的无主空壳)⇒ 抛(停驻否决),
-     * 转录不拷进别人的行;宿主店记不了 / 读不回属主 ⇒ 同样抛 —— 晋升出一只无主的转录行就是把它交给任何拿到 id 的人。
-     */
-    promoteToHost(sessionId: string, owner: string | null, tree: DelegationTree): Promise<void>;
-    /** 晋升的建行那一笔([ref],规则见 {@link promoteToHost} 头注):宿主店首写登记 `owner`,然后按律定下宿主行的属主(与停驻快路同一只 `settleDelegatedOwner`)。 */
-    private registerPromotedOwner;
     fork(sourceId: string, owner?: string | null): Promise<string | null>;
     get size(): number;
     dispose(): void | Promise<void>;

package/dist/plugins/fork-routing-session-store.js

@@ -1,13 +1,11 @@
 import { SessionError } from "@sema-agent/core";
 import { recordFailOpen } from "../observability/fail-open.js";
-import { delegatedOwnerHostOf, settleDelegatedOwner } from "../delegated-session-owner.js";
 const ROUTE_MAX = 8192;
 export class ForkRoutingSessionStore {
     host;
     transient;
     route = new Map();
     pinnedAt = new Map();
-    promoted = new Set();
     placed = new Set();
     placements;
     listPlaced;
@@ -50,7 +48,7 @@ export class ForkRoutingSessionStore {
         }
     }
     pick(id) {
-        if (this.promoted.has(id) || this.placed.has(id))
+        if (this.placed.has(id))
             return this.host;
         const r = this.route.get(id);
         if (r !== undefined)
@@ -94,7 +92,7 @@ export class ForkRoutingSessionStore {
             this.remember(sessionId, "host");
             return a;
         }
-        if (this.promoted.has(sessionId) || this.placed.has(sessionId)) {
+        if (this.placed.has(sessionId)) {
             const a = await this.host.acquire(sessionId, opts);
             this.remember(sessionId, "host");
             return a;
@@ -187,63 +185,6 @@ export class ForkRoutingSessionStore {
     list() {
         return this.transient.list?.() ?? Promise.resolve([]);
     }
-    async promoteToHost(sessionId, owner, tree) {
-        if (this.promoted.has(sessionId))
-            return;
-        if (this.route.get(sessionId) === "host") {
-            this.promoted.add(sessionId);
-            return;
-        }
-        let src;
-        try {
-            src = await this.transient.acquire(sessionId, { requireExisting: true });
-        }
-        catch {
-            const probe = await this.host.acquire(sessionId, { requireExisting: true });
-            await this.host.forget?.(probe.sessionId);
-            this.promoted.add(sessionId);
-            this.remember(sessionId, "host");
-            return;
-        }
-        const entries = await src.session.getEntries();
-        const leaf = await src.session.getLeafId();
-        await this.registerPromotedOwner(sessionId, owner, tree);
-        const dst = await this.host.acquire(sessionId);
-        try {
-            const storage = dst.session.getStorage();
-            const existing = new Set((await dst.session.getEntries()).map((e) => e.id));
-            for (const entry of entries) {
-                if (existing.has(entry.id))
-                    continue;
-                await storage.appendEntry(entry);
-            }
-            await storage.setLeafId(leaf);
-            const verifyLeaf = await dst.session.getLeafId();
-            if (verifyLeaf !== leaf)
-                throw new Error(`session "${sessionId}" promotion verification failed (leaf mismatch after import)`);
-        }
-        finally {
-            await this.host.forget?.(sessionId);
-        }
-        try {
-            await this.transient.forget?.(sessionId);
-        }
-        catch {
-        }
-        if (this.pinnedAt.get(sessionId) === "transient")
-            this.pinnedAt.set(sessionId, "host");
-        this.promoted.add(sessionId);
-        this.remember(sessionId, "host");
-    }
-    async registerPromotedOwner(sessionId, owner, tree) {
-        const register = this.host.register;
-        const host = delegatedOwnerHostOf(this.host);
-        if (register === undefined || host === undefined) {
-            throw new Error(`session "${sessionId}" cannot be promoted: the host session store cannot record or read back a session owner (register / headOf; placementOf and claimOwnerless together or neither), so the promoted transcript would land ownerless`);
-        }
-        await register.call(this.host, sessionId, owner);
-        await settleDelegatedOwner(host, sessionId, owner, tree);
-    }
     async fork(sourceId, owner) {
         const routed = this.route.get(sourceId);
         const tryFork = async (store, where) => {

package/dist/plugins/image-bake-store-sql.js

@@ -145,7 +145,7 @@ export async function ensurePgImageBakeSchema(pool, poolName = "standard") {
 }
 const isDupKey = isDupKeyError;
 function dupKeyName(dialect, err) {
-    if (dialect === "tidb") {
+    if (dialect === "mysql") {
         const msg = String(err?.sqlMessage ?? err?.message ?? "");
         if (/uq_image_bake_event_line/i.test(msg))
             return "uq_line";
@@ -169,8 +169,8 @@ export class SqlImageBake {
         this.db = db;
         this.poolName = poolName;
     }
-    q(tidb, pg) {
-        return this.db.dialect === "tidb" ? tidb : pg;
+    q(mysql, pg) {
+        return this.db.dialect === "mysql" ? mysql : pg;
     }
     insertParams(bakeId, input, now) {
         return [
@@ -214,7 +214,7 @@ export class SqlImageBake {
         const conn = await this.db.connect();
         let inserted = false;
         try {
-            if (this.db.dialect === "tidb") {
+            if (this.db.dialect === "mysql") {
                 await conn.begin();
                 await conn.query("INSERT INTO image_bake_admit (pool) VALUES (?) ON DUPLICATE KEY UPDATE pool = pool", [this.poolName]);
                 await conn.query("SELECT pool FROM image_bake_admit WHERE pool = ? FOR UPDATE", [this.poolName]);
@@ -255,15 +255,15 @@ export class SqlImageBake {
         return { created: true, bake };
     }
     async getBake(bakeId) {
-        const { rows } = await this.db.query(this.q(`SELECT ${bakeSelectCols("tidb")} FROM image_bake WHERE bake_id = ? LIMIT 1`, `SELECT ${bakeSelectCols("pg")} FROM image_bake WHERE bake_id = $1 LIMIT 1`), [bakeId]);
+        const { rows } = await this.db.query(this.q(`SELECT ${bakeSelectCols("mysql")} FROM image_bake WHERE bake_id = ? LIMIT 1`, `SELECT ${bakeSelectCols("pg")} FROM image_bake WHERE bake_id = $1 LIMIT 1`), [bakeId]);
         return rows[0] ? refusingBakeRow(() => mapRow(rows[0])) : null;
     }
     async getBakeByIdem(idemKey) {
-        const { rows } = await this.db.query(this.q(`SELECT ${bakeSelectCols("tidb")} FROM image_bake WHERE idem_key = ? LIMIT 1`, `SELECT ${bakeSelectCols("pg")} FROM image_bake WHERE idem_key = $1 LIMIT 1`), [idemKey]);
+        const { rows } = await this.db.query(this.q(`SELECT ${bakeSelectCols("mysql")} FROM image_bake WHERE idem_key = ? LIMIT 1`, `SELECT ${bakeSelectCols("pg")} FROM image_bake WHERE idem_key = $1 LIMIT 1`), [idemKey]);
         return rows[0] ? refusingBakeRow(() => mapRow(rows[0])) : null;
     }
     async findActiveByArgv(argv) {
-        const { rows } = await this.db.query(this.q(`SELECT ${bakeSelectCols("tidb")} FROM image_bake WHERE status IN ('queued','running') AND argv = CAST(? AS JSON) ` +
+        const { rows } = await this.db.query(this.q(`SELECT ${bakeSelectCols("mysql")} FROM image_bake WHERE status IN ('queued','running') AND argv = CAST(? AS JSON) ` +
             "ORDER BY created_at DESC LIMIT 1", `SELECT ${bakeSelectCols("pg")} FROM image_bake WHERE status IN ('queued','running') AND argv = $1::jsonb ` +
             "ORDER BY created_at DESC LIMIT 1"), [JSON.stringify(argv)]);
         return rows[0] ? refusingBakeRow(() => mapRow(rows[0])) : null;
@@ -380,7 +380,7 @@ export class SqlImageBake {
         return m == null ? 0 : Number(m);
     }
     async getEvents(bakeId, afterSeq) {
-        const { rows } = await this.db.query(this.q(`SELECT seq, line_ord, kind, level, ${jsonColumnText("tidb", "data")}, ts FROM image_bake_event WHERE bake_id = ? AND seq > ? ORDER BY seq ASC`, `SELECT seq, line_ord, kind, level, ${jsonColumnText("pg", "data")}, ts FROM image_bake_event WHERE bake_id = $1 AND seq > $2 ORDER BY seq ASC`), [bakeId, afterSeq]);
+        const { rows } = await this.db.query(this.q(`SELECT seq, line_ord, kind, level, ${jsonColumnText("mysql", "data")}, ts FROM image_bake_event WHERE bake_id = ? AND seq > ? ORDER BY seq ASC`, `SELECT seq, line_ord, kind, level, ${jsonColumnText("pg", "data")}, ts FROM image_bake_event WHERE bake_id = $1 AND seq > $2 ORDER BY seq ASC`), [bakeId, afterSeq]);
         return rows.map((r) => ({
             seq: Number(r.seq),
             lineOrd: r.line_ord === null ? null : Number(r.line_ord),
@@ -401,7 +401,7 @@ export class SqlImageBake {
         await this.tx(async (conn) => {
             const res = await conn.query(this.q("UPDATE image_bake SET status=?, state=?, digest=?, repo=?, ref=?, index_id=?, exit_code=?, error=?, " +
                 "error_code=?, manifest_sha=?, tag=?, ingest_secret=NULL, updated_at=? WHERE bake_id=? AND status IN ('queued','running')", "UPDATE image_bake SET status=$1, state=$2, digest=$3, repo=$4, ref=$5, index_id=$6, exit_code=$7, error=$8, " +
-                "error_code=$9, manifest_sha=$10, tag=$11, ingest_secret=NULL, updated_at=$12 WHERE bake_id=$13 AND status IN ('queued','running')"), this.db.dialect === "tidb" ? this.terminalParamsTidb(bakeId, t) : this.terminalParamsPg(bakeId, t));
+                "error_code=$9, manifest_sha=$10, tag=$11, ingest_secret=NULL, updated_at=$12 WHERE bake_id=$13 AND status IN ('queued','running')"), this.db.dialect === "mysql" ? this.terminalParamsTidb(bakeId, t) : this.terminalParamsPg(bakeId, t));
             affectedRows = res.affected;
             await conn.query(this.q("DELETE FROM image_bake_lease WHERE pool = ? AND bake_id = ?", "DELETE FROM image_bake_lease WHERE pool = $1 AND bake_id = $2"), [this.poolName, bakeId]);
         });

package/dist/plugins/image-index-sql.js

@@ -181,8 +181,8 @@ export class SqlImageIndex {
     constructor(db) {
         this.db = db;
     }
-    q(tidb, pg) {
-        return this.db.dialect === "tidb" ? tidb : pg;
+    q(mysql, pg) {
+        return this.db.dialect === "mysql" ? mysql : pg;
     }
     static idFor(repo, digest) {
         return createHash("sha256").update(`${repo}@${digest}`).digest("hex").slice(0, 64);
@@ -216,7 +216,7 @@ export class SqlImageIndex {
            status = EXCLUDED.status, visibility = EXCLUDED.visibility, tenant_id = EXCLUDED.tenant_id,
            manifest_sha = EXCLUDED.manifest_sha, recipe_git_sha = EXCLUDED.recipe_git_sha,
            generator_version = EXCLUDED.generator_version, build_date = EXCLUDED.build_date,
-           supersedes = EXCLUDED.supersedes, signed = EXCLUDED.signed, updated_at = EXCLUDED.updated_at`), this.db.dialect === "tidb" ? tidbUpsertParams(e, id, now) : pgUpsertParams(e, id, now));
+           supersedes = EXCLUDED.supersedes, signed = EXCLUDED.signed, updated_at = EXCLUDED.updated_at`), this.db.dialect === "mysql" ? tidbUpsertParams(e, id, now) : pgUpsertParams(e, id, now));
         return id;
     }
     async registerBuilding(e) {
@@ -258,21 +258,21 @@ export class SqlImageIndex {
            supersedes = EXCLUDED.supersedes,
            signed = CASE WHEN sandbox_image_index.status = 'published'
                          THEN sandbox_image_index.signed ELSE EXCLUDED.signed END,
-           updated_at = EXCLUDED.updated_at`), this.db.dialect === "tidb" ? tidbUpsertParams(e, id, now) : pgUpsertParams(e, id, now));
+           updated_at = EXCLUDED.updated_at`), this.db.dialect === "mysql" ? tidbUpsertParams(e, id, now) : pgUpsertParams(e, id, now));
         return id;
     }
     async getById(id) {
-        const { rows } = await this.db.query(this.q(`SELECT ${imageSelectCols("tidb")} FROM sandbox_image_index WHERE id=? LIMIT 1`, `SELECT ${imageSelectCols("pg")} FROM sandbox_image_index WHERE id = $1 LIMIT 1`), [id]);
+        const { rows } = await this.db.query(this.q(`SELECT ${imageSelectCols("mysql")} FROM sandbox_image_index WHERE id=? LIMIT 1`, `SELECT ${imageSelectCols("pg")} FROM sandbox_image_index WHERE id = $1 LIMIT 1`), [id]);
         return rows[0] ? refusingImageRow(() => mapRow(rows[0])) : null;
     }
     async getByDigest(digest) {
-        const { rows } = await this.db.query(this.q(`SELECT ${imageSelectCols("tidb")} FROM sandbox_image_index WHERE digest=? ORDER BY updated_at DESC LIMIT 1`, `SELECT ${imageSelectCols("pg")} FROM sandbox_image_index WHERE digest = $1 ORDER BY updated_at DESC LIMIT 1`), [digest]);
+        const { rows } = await this.db.query(this.q(`SELECT ${imageSelectCols("mysql")} FROM sandbox_image_index WHERE digest=? ORDER BY updated_at DESC LIMIT 1`, `SELECT ${imageSelectCols("pg")} FROM sandbox_image_index WHERE digest = $1 ORDER BY updated_at DESC LIMIT 1`), [digest]);
         return rows[0] ? refusingImageRow(() => mapRow(rows[0])) : null;
     }
     async latestPublished(profile, viewer) {
-        if (this.db.dialect === "tidb") {
+        if (this.db.dialect === "mysql") {
             const vis = visibilityClauseTidb(viewer);
-            const { rows } = await this.db.query(`SELECT ${imageSelectCols("tidb")} FROM sandbox_image_index
+            const { rows } = await this.db.query(`SELECT ${imageSelectCols("mysql")} FROM sandbox_image_index
           WHERE profile=? AND status='published' AND ${vis.sql}
           ORDER BY (build_date IS NULL), build_date DESC, created_at DESC LIMIT 1`, [profile, ...vis.params]);
             return rows[0] ? refusingImageRow(() => mapRow(rows[0])) : null;
@@ -286,7 +286,7 @@ export class SqlImageIndex {
     async list(filter) {
         const limit = Math.min(Math.max(1, filter.limit ?? DEFAULT_LIMIT), MAX_LIMIT);
         let rawRows;
-        if (this.db.dialect === "tidb") {
+        if (this.db.dialect === "mysql") {
             const vis = visibilityClauseTidb(filter);
             const where = [vis.sql];
             const params = [...vis.params];
@@ -309,7 +309,7 @@ export class SqlImageIndex {
                     params.push(new Date(c.createdAt), new Date(c.createdAt), c.id);
                 }
             }
-            const sql = `SELECT ${imageSelectCols("tidb")} FROM sandbox_image_index WHERE ${where.join(" AND ")} ` +
+            const sql = `SELECT ${imageSelectCols("mysql")} FROM sandbox_image_index WHERE ${where.join(" AND ")} ` +
                 `ORDER BY created_at DESC, id DESC LIMIT ?`;
             const { rows } = await this.db.query(sql, [...params, limit + 1]);
             rawRows = rows;
@@ -359,7 +359,7 @@ export class SqlImageIndex {
         return { entries, nextCursor };
     }
     async setStatus(id, status, opts) {
-        if (this.db.dialect === "tidb") {
+        if (this.db.dialect === "mysql") {
             const sets = ["status=?", "updated_at=?"];
             const params = [status, new Date()];
             if (opts && "supersedes" in opts) {

package/dist/plugins/k8s-exec-protocol.d.ts

@@ -40,11 +40,14 @@ export declare function isLabelValue(v: string): boolean;
 /**
  * The volume names the adapter itself mints on a sandbox pod — the ONE table (a patch volume / volumeMount must not reuse one: it would collide
  * with, or mount, the adapter's own volume). Today: the space's build-cache claim and the member-credential broker's lease volume. A volume the
- * adapter adds later is added HERE, and the patch judge below refuses it with no second guard.
+ * adapter adds later is added HERE, and the patch judge below refuses it with no second guard. The two read-floor volumes carry the
+ * supervisor binary per architecture (read-only ConfigMap volumes; `sandbox-read-floor.ts`).
  */
 export declare const ADAPTER_VOLUME_NAMES: {
     readonly cache: "ws-cache";
     readonly brokerLease: "sema-broker-lease";
+    readonly floorX86_64: "sema-floor-x86-64";
+    readonly floorAarch64: "sema-floor-aarch64";
 };
 /**
  * The confined, ADDITIVE pod-spec patch. Every field is purely additive —

package/dist/plugins/k8s-exec-protocol.js

@@ -8,7 +8,12 @@ const LABEL_VALUE = /^(?:[A-Za-z0-9](?:[-A-Za-z0-9_.]{0,61}[A-Za-z0-9])?)?$/;
 export function isLabelValue(v) {
     return LABEL_VALUE.test(v);
 }
-export const ADAPTER_VOLUME_NAMES = { cache: "ws-cache", brokerLease: BROKER_VOLUME_NAME };
+export const ADAPTER_VOLUME_NAMES = {
+    cache: "ws-cache",
+    brokerLease: BROKER_VOLUME_NAME,
+    floorX86_64: "sema-floor-x86-64",
+    floorAarch64: "sema-floor-aarch64",
+};
 const RESERVED_VOLUME_NAMES = new Set(Object.values(ADAPTER_VOLUME_NAMES));
 const agentContainerOf = (pod) => pod.spec.containers?.[0];
 const POD_SPEC_PATCH_FIELDS = {

package/dist/plugins/leader-run-store-sql.js

@@ -95,8 +95,8 @@ export class SqlLeaderRunStore {
     constructor(db) {
         this.db = db;
     }
-    q(tidb, pg) {
-        return this.db.dialect === "tidb" ? tidb : pg;
+    q(mysql, pg) {
+        return this.db.dialect === "mysql" ? mysql : pg;
     }
     async createRun(input) {
         const id = uuidv7();
@@ -120,12 +120,12 @@ export class SqlLeaderRunStore {
         return { created: true, run };
     }
     async getRun(id) {
-        const res = await this.db.query(this.q(`SELECT ${selectCols("tidb")} FROM ${LEADER_RUN_TABLE} WHERE leader_run_id = ?`, `SELECT ${selectCols("pg")} FROM ${LEADER_RUN_TABLE} WHERE leader_run_id = $1`), [id]);
+        const res = await this.db.query(this.q(`SELECT ${selectCols("mysql")} FROM ${LEADER_RUN_TABLE} WHERE leader_run_id = ?`, `SELECT ${selectCols("pg")} FROM ${LEADER_RUN_TABLE} WHERE leader_run_id = $1`), [id]);
         const row = res.rows[0];
         return row ? mapRow(row) : undefined;
     }
     async getByIdem(idemKey) {
-        const res = await this.db.query(this.q(`SELECT ${selectCols("tidb")} FROM ${LEADER_RUN_TABLE} WHERE idem_key = ?`, `SELECT ${selectCols("pg")} FROM ${LEADER_RUN_TABLE} WHERE idem_key = $1`), [idemKey]);
+        const res = await this.db.query(this.q(`SELECT ${selectCols("mysql")} FROM ${LEADER_RUN_TABLE} WHERE idem_key = ?`, `SELECT ${selectCols("pg")} FROM ${LEADER_RUN_TABLE} WHERE idem_key = $1`), [idemKey]);
         const row = res.rows[0];
         return row ? mapRow(row) : undefined;
     }

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

@@ -1,5 +1,6 @@
 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 CheckpointAskCandidate, type CtxRowRewrite, type CtxRowsRewrite, type DecidedApprovalRecord, type PendingCheckpoint, type PendingRowBinding } from "./checkpoint-store-sql.js";
+import { type CheckpointAskCandidate, type CtxClaimRewrite, type CtxRowRewrite, type CtxRowsRewrite, type DecidedApprovalRecord, type PendingCheckpoint, type PendingRowBinding } from "./checkpoint-store-sql.js";
+import { type FencedRun, type InProcessClaimFence } from "./store-contracts.js";
 import type { SealedCheckpointCtx } from "../http/checkpoint-ctx.js";
 export interface LocalCheckpointStoreOptions {
     /** taskId join for the pending card (the local FileRunStore's `getActiveTaskId`). Absent ⇒ `taskId: null`. */
@@ -7,6 +8,8 @@ export interface LocalCheckpointStoreOptions {
     /** E21 owner guard (the LocalSessionStore's owner read, `headOf(id)?.owner`: `undefined` = no session row). Absent ⇒ owner guard degrades
      *  to null-owner-only (a non-null owner with no owner source purges NOTHING — fail-closed, mirrors the SQL EXISTS guard). */
     readSessionOwner?: (sessionId: string) => Promise<string | null | undefined>;
+    /** ctx 改写的认领栅栏({@link LocalCheckpointStore.rewriteCtxWhileClaimed}):同一数据根上的文件 run 店(进程内栅栏形)。缺席 ⇒ 那一口响亮抛(装配缺陷)。 */
+    claims?: InProcessClaimFence;
 }
 export declare class LocalCheckpointStore {
     /** [ref] 车1:托管留存声明 —— **诚实的 none**(与 local session 店同一条判据:本店的行没有按期删除的腿;
@@ -202,6 +205,12 @@ export declare class LocalCheckpointStore {
      * 只收对象,读腿只认对象,两条腿一个类型。
      */
     getCtx<T extends object = object>(sessionId: string): Promise<T | null>;
+    /**
+     * **认领栅栏下改写既有 ctx 行** —— 规则、结局闭集与 SQL 孪生 `SqlCheckpointStore.rewriteCtxWhileClaimed` 逐条同(那里是全文)。
+     * 本孪生的栅栏是进程内形(`store-contracts.ts` `InProcessClaimFence`):判认领、刷新活性、问腿判据与本口的落盘是**同一个同步段**(原子写本就同步),
+     * 中间没有让出,所以认领在写落定之前挪不动。只改既有档(档不在 ⇒ `context_absent`,不建档);形闸同 {@link LocalCheckpointStore.putCtx},在栅栏之前判。
+     */
+    rewriteCtxWhileClaimed(sessionId: string, taskId: string, ctx: SealedCheckpointCtx, legHolds: (run: FencedRun) => boolean): Promise<CtxClaimRewrite>;
     /**
      * 🔴 **一次性迁移的 ctx 行改写店腿**(local 孪生;`checkpoint-store-sql.ts` `CheckpointCtxRowsRewriter`,判词与 SQL 孪生 `rewriteCtxRows` 逐条同):
      * 逐档读(信封经读腿**同一只**判形 —— 读不出 ⇒ 计数、跳过、**不删**),`rewrite` 交回新体 ⇒ 信封原样(`sessionId` / `updatedAt` 不动:收割按 `updatedAt` 判)

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

@@ -11,6 +11,7 @@ import { quarantineUnreadableSidecar } from "./local-sidecar-quarantine.js";
 import { createZodColumnReader, decodeJsonColumn, foldJsonColumn, readStringArrayColumn } from "./sql-json-column.js";
 import { UNMANAGED_RETENTION } from "./retention-store-sql.js";
 import { assertJsonColumnWritable, createObjectColumnReader } from "./sql-json-column.js";
+import { FENCE_LANDED } from "./store-contracts.js";
 function terminalAtOf(cp) {
     return Math.max(cp.createdAt + TERMINAL_BACKSTOP_MS, (cp.deadline ?? 0) + TERMINAL_GRACE_MS);
 }
@@ -326,6 +327,27 @@ export class LocalCheckpointStore {
         const rec = refusingCtx(sessionId, () => decodeJsonColumn(readFileSync(p, "utf8"), createCtxRecordReader(), `checkpoint-ctx ${ctxFileOf(sessionId)} for session ${JSON.stringify(sessionId)}`));
         return rec.sessionId === sessionId ? rec.ctx : null;
     }
+    async rewriteCtxWhileClaimed(sessionId, taskId, ctx, legHolds) {
+        const claims = this.opts.claims;
+        if (claims === undefined)
+            throw new Error("LocalCheckpointStore.rewriteCtxWhileClaimed: no claim fence is bound to this store (wiring defect: the local backend binds its own run store)");
+        const rec = { sessionId, updatedAt: Date.now(), ctx };
+        const text = JSON.stringify(rec);
+        assertJsonColumnWritable(text, createCtxRecordReader(), `checkpoint ctx for session ${JSON.stringify(sessionId)} (local claim-fenced rewrite)`);
+        const path = join(this.ctxDir, ctxFileOf(sessionId));
+        let outcome = "context_absent";
+        const held = claims.whileHoldingClaim(sessionId, taskId, (run) => {
+            if (!legHolds(run)) {
+                outcome = "claim_released";
+            }
+            else if (existsSync(path)) {
+                atomicWriteFile(this.tmpDir, path, text);
+                outcome = "written";
+            }
+            return FENCE_LANDED;
+        });
+        return held ? outcome : "claim_released";
+    }
     async rewriteCtxRows(rewrite) {
         const out = { scanned: 0, rewritten: 0, valuesRewritten: 0, unreadable: 0, tooLarge: 0 };
         for (const f of readdirSync(this.ctxDir)) {