@sema-agent/server 7.138.0 → 7.140.0

package/dist/execution-lane-caps.js

@@ -1,6 +1,7 @@
 import { homedir } from "node:os";
-import { EXECUTION_LANE_WORDS as DECLARABLE_LANE_WORDS, EXECUTION_LANES } from "@sema-agent/settings-schema/execution-lanes";
-import { DECLARE_HOME_REMEDY, buildHomeAbsentNote } from "./lane-home-probe.js";
+import { StubExecutionEnv } from "@sema-agent/core";
+import { EXECUTION_LANE_WORDS as DECLARABLE_LANE_WORDS, EXECUTION_LANES, isBlankCoordinate } from "@sema-agent/settings-schema/execution-lanes";
+import { DECLARE_HOME_REMEDY, LANE_HOME_UNDECLARED_EVENT, LANE_HOME_UNMEASURED_EVENT, buildHomeAbsentNote, buildHomeUnmeasuredNote } from "./lane-home-probe.js";
 const NO = "unsupported";
 const YES = "supported";
 const SU = "single-user-only";
@@ -13,15 +14,8 @@ export function executionLaneCaps(lane) {
                 scheduler: NO,
                 lsp: NO,
                 sandboxSendUserFile: NO,
-                isolation: NO,
-                suspendable: NO,
                 remoteScratchpad: NO,
-                sandboxPathAdjudication: NO,
                 worktreeIsolation: NO,
-                memoryPersistenceCapable: NO,
-                hostFilePlane: YES,
-                coreRemoteExecutionEnv: NO,
-                canonicalPathAuthority: NO,
                 tenantSeparation: YES,
             };
         case "host":
@@ -31,15 +25,8 @@ export function executionLaneCaps(lane) {
                 scheduler: SU,
                 lsp: SU,
                 sandboxSendUserFile: NO,
-                isolation: NO,
-                suspendable: NO,
                 remoteScratchpad: NO,
-                sandboxPathAdjudication: NO,
                 worktreeIsolation: YES,
-                memoryPersistenceCapable: YES,
-                hostFilePlane: YES,
-                coreRemoteExecutionEnv: YES,
-                canonicalPathAuthority: YES,
                 tenantSeparation: executionLaneRow(lane).tenantSeparation,
             };
         case "e2b":
@@ -49,15 +36,8 @@ export function executionLaneCaps(lane) {
                 scheduler: NO,
                 lsp: NO,
                 sandboxSendUserFile: YES,
-                isolation: YES,
-                suspendable: YES,
                 remoteScratchpad: YES,
-                sandboxPathAdjudication: YES,
                 worktreeIsolation: NO,
-                memoryPersistenceCapable: NO,
-                hostFilePlane: NO,
-                coreRemoteExecutionEnv: YES,
-                canonicalPathAuthority: YES,
                 tenantSeparation: executionLaneRow(lane).tenantSeparation,
             };
         case "k8s":
@@ -67,15 +47,8 @@ export function executionLaneCaps(lane) {
                 scheduler: NO,
                 lsp: NO,
                 sandboxSendUserFile: YES,
-                isolation: YES,
-                suspendable: YES,
                 remoteScratchpad: YES,
-                sandboxPathAdjudication: YES,
                 worktreeIsolation: NO,
-                memoryPersistenceCapable: NO,
-                hostFilePlane: NO,
-                coreRemoteExecutionEnv: YES,
-                canonicalPathAuthority: YES,
                 tenantSeparation: executionLaneRow(lane).tenantSeparation,
             };
         case "ssh":
@@ -85,15 +58,8 @@ export function executionLaneCaps(lane) {
                 scheduler: NO,
                 lsp: NO,
                 sandboxSendUserFile: SU,
-                isolation: NO,
-                suspendable: NO,
                 remoteScratchpad: YES,
-                sandboxPathAdjudication: YES,
                 worktreeIsolation: NO,
-                memoryPersistenceCapable: NO,
-                hostFilePlane: NO,
-                coreRemoteExecutionEnv: YES,
-                canonicalPathAuthority: YES,
                 tenantSeparation: executionLaneRow(lane).tenantSeparation,
             };
         case "adb":
@@ -103,15 +69,8 @@ export function executionLaneCaps(lane) {
                 scheduler: NO,
                 lsp: NO,
                 sandboxSendUserFile: NO,
-                isolation: NO,
-                suspendable: NO,
                 remoteScratchpad: NO,
-                sandboxPathAdjudication: YES,
                 worktreeIsolation: NO,
-                memoryPersistenceCapable: NO,
-                hostFilePlane: NO,
-                coreRemoteExecutionEnv: YES,
-                canonicalPathAuthority: YES,
                 tenantSeparation: executionLaneRow(lane).tenantSeparation,
             };
         case "local-docker":
@@ -121,15 +80,8 @@ export function executionLaneCaps(lane) {
                 scheduler: NO,
                 lsp: NO,
                 sandboxSendUserFile: NO,
-                isolation: YES,
-                suspendable: NO,
                 remoteScratchpad: YES,
-                sandboxPathAdjudication: YES,
                 worktreeIsolation: NO,
-                memoryPersistenceCapable: NO,
-                hostFilePlane: NO,
-                coreRemoteExecutionEnv: YES,
-                canonicalPathAuthority: YES,
                 tenantSeparation: executionLaneRow(lane).tenantSeparation,
             };
         case "device":
@@ -139,19 +91,47 @@ export function executionLaneCaps(lane) {
                 scheduler: NO,
                 lsp: NO,
                 sandboxSendUserFile: NO,
-                isolation: NO,
-                suspendable: NO,
                 remoteScratchpad: YES,
-                sandboxPathAdjudication: YES,
                 worktreeIsolation: NO,
-                memoryPersistenceCapable: NO,
-                hostFilePlane: NO,
-                coreRemoteExecutionEnv: YES,
-                canonicalPathAuthority: YES,
                 tenantSeparation: executionLaneRow(lane).tenantSeparation,
             };
     }
 }
+const IN_PROCESS_BLOCK = new StubExecutionEnv().capabilities;
+const HOST_BLOCK = Object.freeze({ isolation: false, suspendable: false, sharesProcessTable: true, canonicalPathAuthoritative: true, hostLocalPaths: true, externalContentTarget: false, io: true, keepsReadFloor: false });
+const E2B_BLOCK = Object.freeze({ isolation: true, suspendable: true, sharesProcessTable: false, canonicalPathAuthoritative: true, hostLocalPaths: false, externalContentTarget: false, io: true, keepsReadFloor: false });
+const K8S_BLOCK = Object.freeze({ isolation: true, suspendable: false, sharesProcessTable: false, canonicalPathAuthoritative: true, hostLocalPaths: false, externalContentTarget: false, io: true, keepsReadFloor: false });
+const K8S_SNAPSHOT_BLOCK = Object.freeze({ ...K8S_BLOCK, suspendable: true });
+const LOCAL_DOCKER_BLOCK = Object.freeze({ isolation: true, suspendable: false, sharesProcessTable: false, canonicalPathAuthoritative: true, hostLocalPaths: false, externalContentTarget: false, io: true, keepsReadFloor: false });
+const SSH_BLOCK = Object.freeze({ isolation: false, suspendable: false, sharesProcessTable: false, canonicalPathAuthoritative: true, hostLocalPaths: false, externalContentTarget: false, io: true, keepsReadFloor: false });
+const ADB_BLOCK = Object.freeze({ isolation: false, suspendable: false, sharesProcessTable: false, canonicalPathAuthoritative: true, hostLocalPaths: false, externalContentTarget: false, io: true, keepsReadFloor: false });
+const DEVICE_BLOCK = Object.freeze({ isolation: false, suspendable: false, sharesProcessTable: false, canonicalPathAuthoritative: true, hostLocalPaths: false, externalContentTarget: true, io: true, keepsReadFloor: false });
+function laneBlock(lane, snapshotStore) {
+    switch (lane) {
+        case "in-process":
+            return IN_PROCESS_BLOCK;
+        case "host":
+            return HOST_BLOCK;
+        case "e2b":
+            return E2B_BLOCK;
+        case "k8s":
+            return snapshotStore ? K8S_SNAPSHOT_BLOCK : K8S_BLOCK;
+        case "local-docker":
+            return LOCAL_DOCKER_BLOCK;
+        case "ssh":
+            return SSH_BLOCK;
+        case "adb":
+            return ADB_BLOCK;
+        case "device":
+            return DEVICE_BLOCK;
+    }
+}
+export function capabilitiesFor(deployment) {
+    const lane = executionLaneOf(deployment.remoteExec?.provider);
+    if (lane === undefined)
+        return undefined;
+    return laneBlock(lane, lane === "k8s" && Boolean(deployment.remoteExec?.s3Snapshot));
+}
 export const ALL_EXECUTION_LANES = Object.freeze(["in-process", ...DECLARABLE_LANE_WORDS]);
 const EXECUTION_LANE_SET = new Set(ALL_EXECUTION_LANES);
 export function isExecutionLane(word) {
@@ -180,6 +160,12 @@ export function laneRequiredEnv(lane) {
     const row = executionLaneRow(lane);
     return [...row.requiredEnv, ...row.requiredSecretEnv];
 }
+export function isBlankRequiredEnvValue(value) {
+    return value === undefined || isBlankCoordinate(value);
+}
+export function laneMissingEnv(lane, env) {
+    return laneRequiredEnv(lane).filter((name) => isBlankRequiredEnvValue(env[name]));
+}
 export function executionLaneRequiredRefusal(deployment) {
     if (!deployment.requireExecutionLane || executionLaneOf(deployment.remoteExec?.provider) !== "in-process")
         return undefined;
@@ -199,9 +185,12 @@ export function executionLaneOf(provider) {
         return "in-process";
     return isExecutionLane(provider) ? provider : undefined;
 }
+export function deployedExecutionLanes(config) {
+    return [executionLaneOf(config.remoteExec?.provider)];
+}
 export function handsOnWorkerFilePlane(lane) {
-    const caps = executionLaneCaps(lane);
-    return caps.hostFilePlane === "supported" && caps.coreRemoteExecutionEnv === "supported";
+    const block = laneBlock(lane, false);
+    return block.io && block.hostLocalPaths;
 }
 export function laneBindsReads(lane) {
     switch (lane) {
@@ -223,11 +212,11 @@ export function laneMeasuresHome(lane) {
         case "local-docker":
         case "ssh":
         case "adb":
+        case "e2b":
+        case "host":
             return true;
         case "device":
-        case "host":
         case "in-process":
-        case "e2b":
             return false;
     }
 }
@@ -247,23 +236,10 @@ export function laneReadFaceDefault(lane) {
 }
 export const LANE_OPEN_READ_FACE_CAUTION = "a deployment that mounts host paths or shared volumes into the sandbox (hostPath, bind mount) exposes those host files to reads on an open face — pin READ_FACE=roots or add read-deny rows (READ_DENY_PATTERNS) for them";
 export function laneIsolated(lane) {
-    const isolation = executionLaneCaps(lane).isolation;
-    switch (isolation) {
-        case "supported":
-            return true;
-        case "unsupported":
-            return false;
-    }
+    return laneBlock(lane, false).isolation;
 }
 export function laneWiresExecutionEnv(lane) {
-    const wired = executionLaneCaps(lane).coreRemoteExecutionEnv;
-    switch (wired) {
-        case "supported":
-            return true;
-        case "unsupported":
-        case "single-user-only":
-            return false;
-    }
+    return laneBlock(lane, false).io;
 }
 export const PLANNED_LANE_DIVERGENCES = Object.freeze([]);
 export const E2B_SANDBOX_HOME = "/home/user";
@@ -288,14 +264,32 @@ export function executionLaneHomeDir(deployment) {
             return undefined;
     }
 }
-export function buildUndeclaredHomeNote(deployment) {
-    if (executionLaneHomeDir(deployment) !== undefined)
-        return undefined;
+export function buildLaneHomeClaim(deployment) {
+    const home = executionLaneHomeDir(deployment);
+    if (home === undefined)
+        return {};
+    return { homeDir: home, homeDirSource: deployment.remoteExecHomeDir !== undefined ? "declared" : "lane" };
+}
+export function buildLaneHomeBootNote(deployment) {
     const lane = executionLaneOf(deployment.remoteExec?.provider);
-    if (lane === undefined || executionLaneCaps(lane).coreRemoteExecutionEnv !== "supported")
+    if (lane === undefined || !laneWiresExecutionEnv(lane))
         return undefined;
     if (laneMeasuresHome(lane))
         return undefined;
-    return buildHomeAbsentNote(lane, "REMOTE_EXEC_HOME_DIR is unset, and this lane cannot read its execution environment's home", DECLARE_HOME_REMEDY);
+    const home = executionLaneHomeDir(deployment);
+    if (home === undefined)
+        return { event: LANE_HOME_UNDECLARED_EVENT, note: buildHomeAbsentNote(lane, "REMOTE_EXEC_HOME_DIR is unset, and this lane cannot read its execution environment's home", DECLARE_HOME_REMEDY) };
+    return { event: LANE_HOME_UNMEASURED_EVENT, note: buildHomeUnmeasuredNote(lane, home) };
+}
+export function buildReadDenyFloorUnkeptNote(deployment) {
+    if (!deployment.readDenyFloorRequired)
+        return undefined;
+    if (capabilitiesFor(deployment)?.keepsReadFloor === true)
+        return undefined;
+    const lane = executionLaneOf(deployment.remoteExec?.provider) ?? String(deployment.remoteExec?.provider);
+    return (`READ_DENY_FLOOR_REQUIRED=true, but the "${lane}" execution lane does not keep the read-deny byte floor (a program its commands run can open a path ` +
+        `the read-deny table refuses). Every run whose read-deny table has rows — the shipped default tiers put rows there unless READ_DENY_BUILTIN_TIERS=none — ` +
+        `is refused before any command starts (config.read_deny_floor_unkept; a synchronous submit answers 409). ` +
+        `Either run on a lane that keeps the floor, or unset READ_DENY_FLOOR_REQUIRED to run with one operator notice per run instead.`);
 }
 //# sourceMappingURL=execution-lane-caps.js.map

package/dist/execution-placement.d.ts

@@ -0,0 +1,259 @@
+/**
+ * **执行放置** —— 根会话行上「这一位住客」的一格(叶模块:型 + 纯函数 + 测试走廊的内存参照实现;运行期只依赖 core 的住客判官)。
+ *
+ * ## 规则(全仓唯一处写)
+ *  · **一格四态**:`absent`(这一位住客还没有放置)| `writer(L[, D])`(本引擎声明在车道 L 上写;device 车道带设备 D,D 缺 = 迁移回填的
+ *    「有 run、设备未知」)| `mirror`(写者在别处,本处只读)| `forking`(只 local:fork 的目标格已写、存档未落 —— 崩溃中间态,SQL 单事务不可达)。
+ *    载体:SQL `session_meta` 的 `execution_*` 七列(列定义与语句的唯一属主 = `plugins/execution-placement-sql.ts`);local = 会话元数据边档那一格的
+ *    `execution` 位(`plugins/local-session-store.ts`)。处处 `execution` 限定,与同行 `placement_*`(委派分区)不同义;执行格只在 `placement_kind IS NULL` 的行上 ——
+ *    委派分区行读作「不在」。
+ *  · **读只有一只**:会话店的执行席 {@link ExecutionPlacementSeat.read}(一次行读:住客 + 格;行不在 / 委派分区行 ⇒ `undefined`;读故障抛,不吞成 `absent`)。
+ *  · **写只按住客谓词** `(root, incarnation, owner) ∧ placement_kind IS NULL`:住客换了(删后重建,哪怕同一属主;local M10 窗内的认领)= 这一格不在 ⇒ 落空;
+ *    0 行一律按住客复读分类({@link settledPlaceOutcome} / {@link settledMirrorOutcome} / {@link settledDeviceBindOutcome}),**永不对现住客重试**。
+ *  · **没有的转换**:writer ↔ mirror、writer(L) → writer(L')(device 车道的换绑 writer(device, D) → writer(device, D') 除外,它有自己的语句与门)。
+ *  · **放置存在 ⇒ 住客存在**:放置是行的列 / 格,删会话即删放置;建行恒 absent(SQL 建行 INSERT 列名显式;local 新格整格新铸),导入新建的行同锁落 mirror。
+ *
+ * ## 测试走廊的会话行(不是第二只生产店)
+ * {@link InMemoryExecutionPlacementSeat} 是**语义参照实现**(与 `InMemoryDeviceStore` 同一身份):持「会话行」(root → 住客 + 格),给只用 `Map` 会话店的
+ * 测试走廊与 `InMemoryDeviceStore` 共用。**生产装配零引用** —— `src/` 非测试路径里只许 `device-store.ts` 与本模块提到它。
+ */
+import { type SessionHead } from "@sema-agent/core";
+import type { DeviceOwner } from "./device-store.js";
+import type { ExecutionLane } from "./execution-lane-caps.js";
+import type { SessionFace } from "./session-incarnation.js";
+/** writer(device, D) 的 D:设备、绑定属主(= 设备属主)、换绑序号、放下时刻(ISO)。 */
+export interface ExecutionDeviceCell {
+    readonly id: string;
+    readonly owner: DeviceOwner;
+    readonly rev: number;
+    readonly placedAt: string;
+}
+/** `lane = "device"` ∧ `device` 缺 = writer(device, ∅)(只来自迁移回填:有 run 而设备未知)。 */
+export type ExecutionWriterCell = {
+    readonly role: "writer";
+    readonly lane: ExecutionLane;
+    readonly device?: ExecutionDeviceCell;
+};
+export type ExecutionPlacementCell = {
+    readonly role: "absent";
+} | ExecutionWriterCell | {
+    readonly role: "mirror";
+} | {
+    readonly role: "forking";
+};
+/** 一次行读的答案:这一位住客 + 它的格(同一行、同一次读)。 */
+export interface ExecutionPlacementReading {
+    readonly occupant: SessionFace;
+    readonly cell: ExecutionPlacementCell;
+}
+/** place 的结果(0 行按住客复读分类;`gone` = 行不在或住客不是判过的那一位)。 */
+export type PlaceOutcome = {
+    readonly outcome: "placed";
+} | {
+    readonly outcome: "same";
+} | {
+    readonly outcome: "tree_bound";
+    readonly boundLane: ExecutionLane;
+} | {
+    readonly outcome: "mirror";
+} | {
+    readonly outcome: "gone";
+};
+/** identical 臂补 mirror 的结果(`active` = 写事务内(SQL)/ 写锁内(local)读到认领,带那只认领的 task id;判官的答案先于它,只拦「absent → mirror」这一笔写)。 */
+export type MarkMirrorOutcome = {
+    readonly outcome: "mirrored";
+} | {
+    readonly outcome: "writer";
+} | {
+    readonly outcome: "gone";
+} | {
+    readonly outcome: "active";
+    readonly activeTaskId: string;
+};
+/**
+ * 「谁带执行席」的唯一一句(要求会话店带席的装配拒句引它,不另抄):三店都带(SQL 两孪生 + local,即 `StoreBackend` 交出的会话店),两只包装原样转发;
+ * 只用 `Map` 会话店的测试走廊 / 内存嵌入给参照实现。
+ */
+export declare const EXECUTION_PLACEMENT_SEAT_CARRIERS = "every built-in session store carries one (the MySQL-protocol and PostgreSQL stores and the local store, i.e. the session store a StoreBackend hands out; the caching and fork-routing wrappers forward it), and an in-memory test or embedding passes InMemoryExecutionPlacementSeat";
+/** 会话店的执行席(三店 + 两只包装原样转发)。 */
+export interface ExecutionPlacementSeat {
+    /** 一次行读:行不在 / 委派分区行 ⇒ `undefined`;读故障抛(不吞成 absent)。 */
+    read(root: string): Promise<ExecutionPlacementReading | undefined>;
+    /** absent → writer(L)(非 device 车道;device 车道的首绑走设备店,同一只 SQL 语句模块)。传 device 车道 ⇒ 响亮抛(装配缝)。 */
+    place(root: string, occupant: SessionFace, cell: ExecutionWriterCell): Promise<PlaceOutcome>;
+    /** identical 臂补 mirror:WHERE 住客谓词 ∧ 不是 writer;写事务内先锁根行读认领(SQL),local 在这只会话的写锁里读同一个认领。 */
+    markMirror(root: string, occupant: SessionFace): Promise<MarkMirrorOutcome>;
+}
+/**
+ * 读不出的存档的故障词(闭集;一次性迁移 M32 的 local 腿点名用 —— 随 M32 · 窗口见 `plugins/one-time-migrations.ts` 登记表,窗关后随迁移码删):
+ *  · `corrupt_session` —— 存档在,会话头读不出 / 截断;`invalid_session` —— 读得出而日志结构走不通(两个都是 core 的 `SessionError` 词,原样);
+ *  · `storage` —— 读的时候抛了**别的**故障(I/O 级:权限 / 磁盘 I/O / 超大 —— core 的 `readJsonlRecords` 只吞 ENOENT,其余 errno 原样抛,不是 `SessionError`),
+ *    说不出在不在也说不出内容;{@link UnusableArchive.errno} 带那只故障的 `code`。
+ */
+export type UnusableArchiveWord = "corrupt_session" | "invalid_session" | "storage";
+/**
+ * local 的会话存档**读不出**(会话头读不出 / 日志结构走不通 / 读的时候抛了别的故障):盘上有这只会话的存档,只是读不出它 —— 与「不在」是两件事。
+ * (本型与 {@link isUnusableArchive} 随 M32 · 窗口见 `plugins/one-time-migrations.ts` 登记表。)
+ * local 店对存档的**唯一探针**答三态(不在 · 在而读得出 · 本型),要对存档动手的读者看到本型就把 {@link UnusableArchive.fault}(抛出来的那只故障,**原样**)上抛,
+ * 只问「有没有」的读者不上抛(见 `plugins/local-session-store.ts` 的 `probeArchive`)。
+ */
+export interface UnusableArchive {
+    readonly state: "unusable";
+    readonly word: UnusableArchiveWord;
+    /** `word === "storage"` 且那只故障带字符串 `code` 时:该 `code`(`EACCES` / `EIO` / `ERR_STRING_TOO_LONG` ……);其余缺席。盘上路径与故障句不进这一格。 */
+    readonly errno?: string;
+    /** 探针抛出来的那只故障,原样(上抛的读者抛的就是它)。 */
+    readonly fault: unknown;
+}
+export declare function isUnusableArchive(x: object | undefined): x is UnusableArchive;
+/**
+ * 一次性迁移 M32 **local 腿**的席(随 M32 · 窗口见 `plugins/one-time-migrations.ts` 登记表;只 local 有:SQL 的行就是会话,没有「会话元数据格缺 ∧ 存档读不出」这一形)。`read` 与 {@link ExecutionPlacementSeat.read} 是
+ * **同一读**(同一只实现的本体),只差一点:这只会话的存档读不出(格缺而探针读不出,或 fork 创建的格而探针读不出)⇒ **答 {@link UnusableArchive} 而不抛** —— 开机回填不动存档、
+ * 只补一格放置,读不出的会话由它点名跳过(该会话的请求照旧答存档的故障);席的 `read` 对同一形照旧抛。`place` 就是席的 `place`。
+ */
+export interface LocalPlacementBackfillSeat extends Pick<ExecutionPlacementSeat, "place"> {
+    read(root: string): Promise<ExecutionPlacementReading | UnusableArchive | undefined>;
+}
+/** wire 投影(新读面 + 受理回声共用)。 */
+export type ExecutionPlacementView = {
+    readonly role: "absent";
+} | {
+    readonly role: "writer";
+    readonly lane: ExecutionLane;
+    readonly device?: {
+        readonly deviceId: string;
+        readonly rev: number;
+    };
+} | {
+    readonly role: "mirror";
+} | {
+    readonly role: "forking";
+};
+/** 格 → wire 投影(唯一一只;设备只投 id 与 rev,属主与时刻不上 wire)。 */
+export declare function executionPlacementView(cell: ExecutionPlacementCell): ExecutionPlacementView;
+/**
+ * 住客谓词的 JS 读法(SQL `incarnation = ? AND owner <=> ?` 的对位)= core 的行期望判官 `sessionRowMatches`(会话行格写原语锁内判的也是它,
+ * `session-row.ts` 的 `judgeSessionRowWrite`):属主与化身两样都没变才是判过的那一位 —— 同一化身的属主会变(local M10 认领、identical 重戳、
+ * SQL 导入提交点改属主)。两侧收「属主 + 化身」那一读:活住客(`SessionFace`)与店的头(`SessionHead`,门判过的那一读);调用方一侧恒是执行席的读数
+ * (住客经 `sessionFaceFromRow` 解码,令牌非空),所以「两侧都没有令牌」这一形在这里不可达。写口的判官与执行上下文解析器步 ① 的 `judged` 复核都经它。
+ */
+export declare function sameOccupant(a: Pick<SessionHead, "owner" | "incarnation">, b: Pick<SessionHead, "owner" | "incarnation">): boolean;
+/**
+ * 写口撞上本处写者 —— 三个导入写口(staged 提交点 / 整段 `importEntries` / `replaceEntries`)在写事务内(local:写锁内、写格之前)复读到 `writer`
+ * ⇒ 回滚、目的端零字节、抛它。具名类型:会话同步路由按类型把它答 409 `conflict.session_writer`;不是 core `SessionError`(那张闭集的 `conflict` 在导入面另有固定答复)。
+ */
+export declare class SessionWriterPresentError extends Error {
+    readonly sessionId: string;
+    readonly lane: ExecutionLane;
+    readonly code = "conflict.session_writer";
+    constructor(sessionId: string, lane: ExecutionLane);
+}
+/**
+ * local 的 `forking` 中间态(fork 创建的格 —— 带 fork 键、执行位没人写过 —— 而存档不在)上的普通取用 —— 引擎 acquire 的缺档新建臂、登记、三个导入写口、执行席的写一律抛它;
+ * 只有同键的 `forkTo` 重试在两把写锁内补拷存档。具名类型:路由层按类型答 409 `conflict.fork_in_progress`。
+ */
+export declare class SessionForkInProgressError extends Error {
+    readonly sessionId: string;
+    readonly code = "conflict.fork_in_progress";
+    constructor(sessionId: string);
+}
+/**
+ * 写事务内的认领读命中(读写序律,`plugins/execution-placement-sql.ts` 的 `lockRootAndReadClaim`):改根住客 / 放置的写者在自己的事务里先锁根
+ * `session_meta` 行、再锁定读 `task_active(root)`,读到认领 ⇒ 回滚、一个字节不写、抛它。只 SQL 后端(local 不立此律:没有 device 工厂)。
+ * 具名类型、**不带 wire 码**:各门按自己的既有码答(导入 409 `session_active`、删除 409 `conflict.session_active_run`),体带 `activeTaskId`。
+ */
+export declare class SessionActiveRunError extends Error {
+    readonly sessionId: string;
+    readonly activeTaskId: string;
+    constructor(sessionId: string, activeTaskId: string);
+}
+/** 0 行分类的「这一格此刻可写」答案(只给锁内读写的实现用:local 与内存参照实现写它;SQL 在 0 行之后读到它 = 不变量破,响亮抛)。 */
+export declare const WRITABLE: "writable";
+/**
+ * place 的唯一判官(三店 + 内存参照实现同调):对一次按根的读数判「判过的住客 + 想要的格」此刻是什么结果。
+ * 行不在 / 住客不同 ⇒ `gone`;writer 同车道 ⇒ `same`;writer 异车道 ⇒ `tree_bound`;mirror ⇒ `mirror`;absent ⇒ {@link WRITABLE};forking ⇒ 抛 {@link SessionForkInProgressError}。
+ * 想要的格只认非 device 车道(device 首绑的判官是 {@link settledDeviceBindOutcome})。
+ */
+export declare function settledPlaceOutcome(root: string, reading: ExecutionPlacementReading | undefined, occupant: SessionFace, wanted: ExecutionWriterCell): PlaceOutcome | typeof WRITABLE;
+/** markMirror 的唯一判官(认领那一半在本判官之后,SQL 与 local 各在自己的写事务 / 写锁内判):行不在 / 住客不同 ⇒ `gone`;writer ⇒ `writer`;mirror ⇒ `mirrored`(幂等,零写);absent ⇒ {@link WRITABLE};forking ⇒ 抛。 */
+export declare function settledMirrorOutcome(root: string, reading: ExecutionPlacementReading | undefined, occupant: SessionFace): MarkMirrorOutcome | typeof WRITABLE;
+/** device 车道首绑(absent → writer(device, D) 或 writer(device, ∅) → writer(device, D))的结果(设备店的事务 / 内存参照实现同调)。 */
+export type DeviceBindOutcome = {
+    readonly outcome: "bound";
+    readonly device: ExecutionDeviceCell;
+} | {
+    readonly outcome: "same";
+    readonly device: ExecutionDeviceCell;
+} | {
+    readonly outcome: "device_conflict";
+    readonly device: ExecutionDeviceCell;
+} | {
+    readonly outcome: "tree_bound";
+    readonly boundLane: ExecutionLane;
+} | {
+    readonly outcome: "mirror";
+} | {
+    readonly outcome: "gone";
+};
+/**
+ * device 首绑的唯一判官:行不在 / 住客不同 ⇒ `gone`;absent 或 writer(device, ∅) ⇒ {@link WRITABLE};writer(device, D):D = 想要的设备 ⇒ `same`、否则 `device_conflict`;
+ * writer 异车道 ⇒ `tree_bound`;mirror ⇒ `mirror`;forking ⇒ 抛。
+ */
+export declare function settledDeviceBindOutcome(root: string, reading: ExecutionPlacementReading | undefined, occupant: SessionFace, deviceId: string): Exclude<DeviceBindOutcome, {
+    outcome: "bound";
+}> | typeof WRITABLE;
+/**
+ * device 换绑 writer(device, D) → writer(device, D') 的结果(按住客 ∧ 两属主列 ∧ rev 定址;0 行按住客复读分 `rev_conflict` / `gone`)。
+ * `rebound` 带被换下的那台(`from`,审计行 `session_rebound` 的 detail 要它);`idempotent` = 目标就是格上那台且前态 rev 对得上 ⇒ 零写、rev 不加、不写审计。
+ */
+export type DeviceRebindOutcome = {
+    readonly outcome: "rebound";
+    readonly device: ExecutionDeviceCell;
+    readonly from: string;
+} | {
+    readonly outcome: "idempotent";
+    readonly device: ExecutionDeviceCell;
+} | {
+    readonly outcome: "rev_conflict";
+    readonly device: ExecutionDeviceCell;
+} | {
+    readonly outcome: "gone";
+};
+/**
+ * device 换绑的唯一判官(设备店的事务 / 内存参照实现同调,在锁住的那一读上判):行不在 / 住客不同 / 不是 writer(device, D) / 绑定属主不是判过的那一位 ⇒ `gone`;
+ * rev 不等 ⇒ `rev_conflict`;rev 对得上而目标就是格上那台 ⇒ `idempotent`(必须先于写判 —— `execution_rev + 1` 恒变列会把一次无操作也推进一格);否则 {@link WRITABLE}。
+ */
+export declare function settledDeviceRebindOutcome(reading: ExecutionPlacementReading | undefined, occupant: SessionFace, owner: DeviceOwner, expectedRev: number, targetDeviceId: string): Exclude<DeviceRebindOutcome, {
+    outcome: "rebound";
+}> | typeof WRITABLE;
+/**
+ * 「这一格把这棵树放在哪台设备上」的**唯一读法**(准入链、device 工厂、换绑门与上面的换绑判官同调):writer(device, D) ⇒ D;其余一律 `undefined` ——
+ * absent(还没放)、mirror(写者在别处)、forking(local 中间态)、writer(device, ∅)(迁移回填的「有 run、设备未知」)、writer(别的车道)。
+ * 读者把 `undefined` 答成各自的「没有设备绑定」(`device.not_bound` / 设备 404);穷举 switch,新角色 = 编译红。
+ */
+export declare function boundDeviceOf(cell: ExecutionPlacementCell): ExecutionDeviceCell | undefined;
+/** seat.place 只认非 device 车道(device 首绑走设备店);传 device ⇒ 响亮抛 —— 这是装配缝,不是一个答案。 */
+export declare function assertPlaceableLane(root: string, cell: ExecutionWriterCell): void;
+/**
+ * **测试走廊的会话行**(语义参照实现,与 `InMemoryDeviceStore` 同一身份 —— 生产装配零引用,见头注):root → 住客 + 格。
+ * 只用 `Map` 会话店的测试走廊经 {@link seatRow} / {@link dropRow} 模拟会话行的生灭(= SQL 店的建行 / 删行),`InMemoryDeviceStore` 在它上面做设备首绑 / 换绑。
+ * 语义与 SQL 语句模块逐格同:同一组判官({@link settledPlaceOutcome} 等),写只按住客谓词。
+ */
+export declare class InMemoryExecutionPlacementSeat implements ExecutionPlacementSeat {
+    private readonly rows;
+    /** 建行(会话店建行的对位):行不在 ⇒ 建一只 absent 行;在 ⇒ 不动(与 SQL `ON CONFLICT DO NOTHING` 同一条 first-write 律)。 */
+    seatRow(root: string, occupant: SessionFace): void;
+    /** 删行(删会话的对位):放置随行消失。 */
+    dropRow(root: string): void;
+    read(root: string): Promise<ExecutionPlacementReading | undefined>;
+    place(root: string, occupant: SessionFace, cell: ExecutionWriterCell): Promise<PlaceOutcome>;
+    markMirror(root: string, occupant: SessionFace): Promise<MarkMirrorOutcome>;
+    /** device 首绑(SQL `placeDeviceStatement` / `bindDeviceStatement` 的对位):absent 或 writer(device, ∅) ⇒ writer(device, D)、rev 0。 */
+    bindDevice(root: string, occupant: SessionFace, device: {
+        readonly id: string;
+        readonly owner: DeviceOwner;
+    }, placedAt: string): DeviceBindOutcome;
+    /** device 换绑(SQL `rebindDeviceStatement` 的对位):按住客 ∧ 两属主列 ∧ rev 定址,rev + 1;目标就是格上那台 ⇒ `idempotent` 零写。 */
+    rebindDevice(root: string, occupant: SessionFace, owner: DeviceOwner, expectedRev: number, targetDeviceId: string, placedAt: string): DeviceRebindOutcome;
+}
+//# sourceMappingURL=execution-placement.d.ts.map