@sema-agent/server 7.140.0 → 7.142.0

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

@@ -3,8 +3,8 @@ import { createHash } from "node:crypto";
 import { CHECKPOINT_FACET_SQL, CHECKPOINT_SWEEP_ORDER_SQL, CheckpointIndexRefusedError, judgeCheckpointIndexCells } from "./checkpoint-index-columns.js";
 import { CheckpointError, isGateKind, MAX_RULE_TEXT_CHARS, validatePendingSteer, appendPendingSteer, winnerFromOutcome, summarizeCheckpoint, checkpointRevOf, MAX_SUPPORTED_CHECKPOINT_VERSION, ExecutionOutcomeConflictError, executionRecordDisposition, executionVerdict, } from "@sema-agent/core";
 import { redactDeep, redactSecrets } from "../trace/redact.js";
-import { MAX_RULE_OFFERS, MAX_RULE_OFFER_BATCH_MEMBERS, parkRowCarriesSkillCardFacts, parkRowFacts, readRuleOfferList, skillCardFacts } from "../approval-card.js";
-import { assertJsonColumnWritable, createObjectColumnReader, decodeJsonColumn, decodeNullableJsonColumn, foldJsonColumn, isJsonColumnBodyProblem, jsonColumnText, readJsonArrayColumn, readJsonObjectColumn, readNonNullJsonValueColumn, } from "./sql-json-column.js";
+import { MAX_RULE_OFFERS, MAX_RULE_OFFER_BATCH_MEMBERS, countKindlessBatchOffers, parkRowCarriesSkillCardFacts, parkRowFacts, readRuleOfferList, skillCardFacts } from "../approval-card.js";
+import { assertJsonColumnWritable, createObjectColumnReader, decodeJsonColumn, decodeNullableJsonColumn, foldJsonColumn, isJsonColumnBodyProblem, jsonColumnText, jsonColumnTextExpr, readJsonArrayColumn, readJsonObjectColumn, readNonNullJsonValueColumn, } from "./sql-json-column.js";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { durableRowIdentity, withoutCheckpointToken } from "../checkpoint-identity.js";
 import { mysqlDriver, pgDriver, dialectProtocolJsonEncoder } from "./sql-driver.js";
@@ -13,6 +13,7 @@ import { describeProbedTableDrift } from "./schema-drift-sentence.js";
 import { MANAGED_RETENTION, UNMANAGED_RETENTION } from "./retention-store-sql.js";
 import { approvalPayloadFingerprint } from "./approval-payload-fingerprint.js";
 const CTX_REWRITE_PAGE = 500;
+const KINDLESS_SCAN_PAGE = 200;
 export { approvalPayloadFingerprint } from "./approval-payload-fingerprint.js";
 const MAX_TOOL_INPUT_CHARS = 8192;
 export const TERMINAL_BACKSTOP_MS = Math.max(60_000, (Number.isFinite(Number(process.env.APPROVAL_TERMINAL_BACKSTOP_MS)) ? Number(process.env.APPROVAL_TERMINAL_BACKSTOP_MS) : 0) || 30 * 86_400_000);
@@ -78,10 +79,13 @@ function preboundBatchMembers(item) {
         return item;
     return { ...candidate, rules: candidate.rules.slice(0, MAX_RULE_OFFER_BATCH_MEMBERS) };
 }
+export function boundedReaderInput(raw) {
+    return Array.isArray(raw) ? raw.slice(0, MAX_RULE_OFFER_SCAN).map(preboundBatchMembers) : raw;
+}
 export function boundedRuleOffers(raw, opts = {}) {
     const observe = opts.countRedactions ?? true;
     const scrub = (text) => redactSecrets(text, { observe }).slice(0, MAX_RULE_TEXT_CHARS);
-    const read = readRuleOfferList(Array.isArray(raw) ? raw.slice(0, MAX_RULE_OFFER_SCAN).map(preboundBatchMembers) : raw);
+    const read = readRuleOfferList(boundedReaderInput(raw));
     const out = [];
     for (const { offer } of read) {
         if (out.length >= MAX_RULE_OFFERS)
@@ -331,6 +335,7 @@ export function readPendingSteerQueueColumn(queueRaw) {
 }
 const STEER_CAS_ATTEMPTS = 8;
 const EXECUTION_RECORD_CAS_ATTEMPTS = 8;
+export const CTX_CLAIM_REWRITES = ["written", "claim_released", "context_absent"];
 export class SqlCheckpointStore {
     db;
     logger;
@@ -338,10 +343,12 @@ export class SqlCheckpointStore {
     durability = "durable";
     fidelity = "json";
     execution = { outcome: true };
+    claims;
     constructor(db, logger, opts = {}) {
         this.db = db;
         this.logger = logger;
         this.retention = opts.retention ?? UNMANAGED_RETENTION;
+        this.claims = opts.claims;
     }
     q(mysql, pg) {
         return this.db.dialect === "mysql" ? mysql : pg;
@@ -736,6 +743,29 @@ export class SqlCheckpointStore {
         const { rows } = await this.db.query(this.q(`SELECT ${jsonColumnText("mysql", "ctx")} FROM checkpoint_ctx WHERE session_id=?`, `SELECT ${jsonColumnText("pg", "ctx")} FROM checkpoint_ctx WHERE session_id=$1`), [sessionId]);
         return rows[0] ? refusing("a resume context nobody can read", () => decodeCtxColumn(rows[0].ctx, `for session ${JSON.stringify(sessionId)}`)) : null;
     }
+    async rewriteCtxWhileClaimed(sessionId, taskId, ctx, legHolds) {
+        const claims = this.claims;
+        if (claims === undefined)
+            throw new Error("SqlCheckpointStore.rewriteCtxWhileClaimed: no claim fence is bound to this store (wiring defect: the backend binds its own run store)");
+        const text = this.json(ctx, "checkpoint ctx");
+        assertJsonColumnWritable(text, createObjectColumnReader(), `checkpoint_ctx.ctx for session ${JSON.stringify(sessionId)} (claim-fenced rewrite)`);
+        let fenced;
+        try {
+            fenced = await claims.whileHoldingClaim(sessionId, taskId, async (tx, run) => {
+                if (!legHolds(run))
+                    return "claim_released";
+                const row = await tx.query(this.q("SELECT session_id FROM checkpoint_ctx WHERE session_id = ? FOR UPDATE", "SELECT session_id FROM checkpoint_ctx WHERE session_id = $1 FOR UPDATE"), [sessionId]);
+                if (row.rows.length === 0)
+                    return "context_absent";
+                await tx.query(this.q("UPDATE checkpoint_ctx SET ctx = ?, updated_at_ms = ? WHERE session_id = ?", "UPDATE checkpoint_ctx SET ctx = $1::jsonb, updated_at_ms = $2 WHERE session_id = $3"), [text, Date.now(), sessionId]);
+                return "written";
+            });
+        }
+        catch (e) {
+            throw rowTooLargeOrSelf(this.db.dialect, e, `checkpoint_ctx.ctx for session ${JSON.stringify(sessionId)} (claim-fenced rewrite)`);
+        }
+        return fenced.held ? fenced.value : "claim_released";
+    }
     async rewriteCtxRows(rewrite) {
         const out = { scanned: 0, rewritten: 0, valuesRewritten: 0, unreadable: 0, tooLarge: 0 };
         let after = "";
@@ -779,6 +809,47 @@ export class SqlCheckpointStore {
         }
         return out;
     }
+    async scanKindlessBatchRows() {
+        const out = [];
+        let unreadableCells = 0;
+        const tolerant = (read) => {
+            try {
+                return read();
+            }
+            catch (e) {
+                if (!isJsonColumnBodyProblem(e))
+                    throw e;
+                unreadableCells += 1;
+                return undefined;
+            }
+        };
+        const prefilter = (d) => `(rule_suggestions IS NOT NULL OR ${jsonColumnTextExpr(d, "checkpoint", PARK_ROW_PENDING_ACTION.key)} LIKE '%"batch"%')`;
+        let after = "";
+        for (;;) {
+            const { rows } = await this.db.query(this.q(`SELECT token, ${jsonColumnText("mysql", "rule_suggestions")}, ${jsonColumnText("mysql", "checkpoint", PARK_ROW_PENDING_ACTION)} FROM checkpoint WHERE token > ? AND ${prefilter("mysql")} ORDER BY token LIMIT ${KINDLESS_SCAN_PAGE}`, `SELECT token, ${jsonColumnText("pg", "rule_suggestions")}, ${jsonColumnText("pg", "checkpoint", PARK_ROW_PENDING_ACTION)} FROM checkpoint WHERE token > $1 AND ${prefilter("pg")} ORDER BY token LIMIT ${KINDLESS_SCAN_PAGE}`), [after]);
+            for (const row of rows) {
+                const token = String(row.token);
+                after = token;
+                const carriers = [];
+                const column = tolerant(() => decodeNullableJsonColumn(row.rule_suggestions, readJsonArrayColumn, "checkpoint.rule_suggestions (kind-less batch census)"));
+                if (countKindlessBatchOffers(boundedReaderInput(column)) > 0)
+                    carriers.push("rule_suggestions");
+                const pendingAction = tolerant(() => decodeNullableJsonColumn(row[PARK_ROW_PENDING_ACTION.as], readJsonObjectColumn, "checkpoint.checkpoint pendingAction member (kind-less batch census)"));
+                if (typeof pendingAction === "object" && pendingAction !== null) {
+                    const blobOffers = Reflect.get(pendingAction, "ruleOffers");
+                    if (blobOffers !== undefined && !Array.isArray(blobOffers))
+                        unreadableCells += 1;
+                    else if (countKindlessBatchOffers(blobOffers) > 0)
+                        carriers.push("pendingAction.ruleOffers");
+                }
+                if (carriers.length > 0)
+                    out.push({ ref: tokenFingerprint(token), carriers });
+            }
+            if (rows.length < KINDLESS_SCAN_PAGE)
+                break;
+        }
+        return { rows: out, unreadableCells };
+    }
     async reapCtx(cutoff) {
         const res = await this.db.query(this.q("DELETE FROM checkpoint_ctx WHERE updated_at_ms < ? " +
             "AND session_id NOT IN (SELECT session_id FROM checkpoint WHERE status='pending') " +

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

@@ -9,8 +9,9 @@
  *   · `device_enroll_tokens` —— 一次性 enrollment 凭据(明文一现,落库只有 sha256)
  *   · `device_audit`         —— 安全轴事件审计(§4.8 标「审计行」的 8 个 event)
  * **根会话 ↔ 设备绑定不在本店的表里**:它是根会话行(`session_meta`)上这一位住客的执行格 writer(device, D)(列与语句的唯一属主 =
- * `execution-placement-sql.ts`;规则在 `../execution-placement.ts` 头注)。读只经会话店的执行席 `seat.read(root)`;本店只有两只写 ——
- * 首绑 {@link SqlDeviceStore.placeDeviceExecution} 与换绑 {@link SqlDeviceStore.rebindDeviceExecution},各是一只事务,锁序全局一条:设备行 → 根 `session_meta` → `task_*`。
+ * `execution-placement-sql.ts`;规则在 `../execution-placement.ts` 头注)。按根的读只经会话店的执行席 `seat.read(root)`;本店有两只写 ——
+ * 首绑 {@link SqlDeviceStore.placeDeviceExecution} 与换绑 {@link SqlDeviceStore.rebindDeviceExecution},各是一只事务,锁序全局一条:设备行 → 根 `session_meta` → `task_*` ——
+ * 与一只聚合读 {@link SqlDeviceStore.countDeviceBindings}(绑定数,池级一读、不锁,只交一个数)。
  * 刻意**没有** `device_instructions` 表:指令 pending 表是内存态(§6 注③——指令比 run 短命,落库只会
  * 造「表里 pending、run 已死」的僵尸行;at-most-once 靠 §5.3 投递边界,不靠指令落库)。
  *
@@ -157,6 +158,8 @@ export declare class SqlDeviceStore implements DeviceStore {
      * 审计写不进去 = 整次换绑失败(fail-closed,[ref])。持锁判过之后 CAS 不可能 0 行 —— 0 行即引擎异常,响亮抛。三形语义 oracle = `InMemoryDeviceStore.rebindDeviceExecution`。
      */
     rebindDeviceExecution(input: RebindDeviceExecutionInput): Promise<RebindDeviceExecutionResult>;
+    /** 绑定数(契约注见 `DeviceStore.countDeviceBindings`):池级一读,读与判的唯一属主 = `execution-placement-sql.ts` 的 `countDeviceBindingsOn`(行过唯一解码 + `boundDeviceOf`)。 */
+    countDeviceBindings(): Promise<number>;
     appendAudit(input: AppendAuditInput): Promise<void>;
     /** 审计写的**唯一**语句(池级与事务内共用;`SqlExec` 是两者的公共面)。 */
     private insertAuditOn;

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

@@ -2,7 +2,7 @@ import { mysqlDriver, pgDriver, dialectJsonEncoder } from "./sql-driver.js";
 import { isDupKeyError, isCheckViolationError } from "./sql-errors.js";
 import { DEVICE_AUDIT_EVENTS, assertAcquireShape, assertDeviceIdShape, assertDeviceOwnerShape, assertEnrollTokenHashShape, assertIssueTokenShape, assertNewDeviceShape, assertPlaceDeviceShape, assertRebindShape, assertRevokeShape, assertWholeSeconds, parseDeviceAuditEvent, parseDevicePlatformOs, parseDeviceStatus, } from "../device-store.js";
 import { WRITABLE, boundDeviceOf, settledDeviceBindOutcome, settledDeviceRebindOutcome } from "../execution-placement.js";
-import { bindDeviceStatement, lockRootAndReadClaim, placeWriterStatement, readPlacementOn, rebindDeviceStatement, rowsOnSqlExec } from "./execution-placement-sql.js";
+import { bindDeviceStatement, countDeviceBindingsOn, lockRootAndReadClaim, placeWriterStatement, readPlacementOn, rebindDeviceStatement, rowsOnSqlExec } from "./execution-placement-sql.js";
 import { ensureIndexes } from "./ensure-index.js";
 import { decodeJsonColumn, foldJsonColumn, jsonColumnText, readJsonObjectColumn } from "./sql-json-column.js";
 export const DEVICES_TABLE = "device";
@@ -581,6 +581,9 @@ export class SqlDeviceStore {
             conn.release();
         }
     }
+    async countDeviceBindings() {
+        return countDeviceBindingsOn(rowsOnSqlExec(this.db));
+    }
     async appendAudit(input) {
         await this.insertAuditOn(this.db, input);
     }

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 复核的唯一定址)
@@ -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,7 +1,7 @@
 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", 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"` },
@@ -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-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, type SettledLegMemoryObservation } 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):
@@ -169,6 +169,11 @@ export declare class FileRunStore implements InProcessClaimFence {
      *  `createdAt DESC, taskId DESC`,与本店 {@link FileRunStore.listSessions} 挑 `rn=1` 那一行的比较器逐字同一份)。
      */
     latestRunForSession(sessionId: string): Promise<LatestRunRef | undefined>;
+    /**
+     * [ref] —— 这个会话**最近一条已结腿**与它的记忆观测(规则属主 = `store-contracts.ts` 的 {@link SettledLegMemoryObservation};
+     * {@link SqlRunStore.latestMemoryObservationForSession} 的孪生:同一只已结谓词(`isTerminalRunStatus`)、同一个排序口径 —— 与本店 {@link FileRunStore.latestRunForSession} 的比较器逐字同一份)。
+     */
+    latestMemoryObservationForSession(sessionId: string): Promise<SettledLegMemoryObservation | undefined>;
     /** DISTINCT sessions newest-first by last activity (the CC /resume picker): latest run's preview/status + first/last/count. */
     listSessions(opts: {
         owner?: string;

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

@@ -7,7 +7,7 @@ import { randomBytes } from "node:crypto";
 import { AppendLog, atomicWriteFile, ensureDir, isProcessLive, processFingerprint, sanitizePathComponent, writeThenLink } from "@sema-agent/core";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { replayJsonlSkipping } from "../observability/corrupt-read-seat.js";
-import { RUN_HOLDER_DEATH_CODES, RUN_ORPHANED_ERROR, RUN_STALLED_ERROR, StoreBootRefusalError, buildRunOrphanedError, readLegacyHolderDeathCode } from "./store-contracts.js";
+import { RUN_HOLDER_DEATH_CODES, RUN_ORPHANED_ERROR, RUN_STALLED_ERROR, StoreBootRefusalError, buildRunOrphanedError, readLegacyHolderDeathCode, isTerminalRunStatus, settledLegObservationOf } from "./store-contracts.js";
 import { notifyRunTerminal } from "../observability/run-terminal.js";
 import { readRunIdentityCells, runIdentityCells } from "../identity-source.js";
 import { createInProcessSpaceCommitTable, fenceSpaceCommitAtTerminal, SPACE_COMMIT_RECORD_SCHEMA } from "../workspace-space-commit.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) {
@@ -595,6 +595,16 @@ export class FileRunStore {
         }
         return latest === undefined ? undefined : { taskId: latest.taskId, owner: latest.owner, createdAt: latest.createdAt.toISOString() };
     }
+    async latestMemoryObservationForSession(sessionId) {
+        let latest;
+        for (const r of this.runs.values()) {
+            if (r.sessionId !== sessionId || !isTerminalRunStatus(r.status))
+                continue;
+            if (latest === undefined || r.createdAt.getTime() > latest.createdAt.getTime() || (r.createdAt.getTime() === latest.createdAt.getTime() && r.taskId > latest.taskId))
+                latest = r;
+        }
+        return latest === undefined ? undefined : settledLegObservationOf(latest.taskId, latest.result);
+    }
     async listSessions(opts) {
         const bySession = new Map();
         for (const r of this.runs.values()) {

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/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/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)) {