@sema-agent/server 7.138.0 → 7.139.0

package/dist/device-store.js

@@ -123,9 +123,14 @@ export function assertRevokeShape(input) {
     assertBoundedText("revokedBy", input.revokedBy, DEVICE_TEXT_LIMITS.actor);
     assertBoundedText("revokeReason", input.reason ?? "", DEVICE_TEXT_LIMITS.revokeReason);
 }
+export function assertPlaceDeviceShape(input) {
+    assertRootSessionIdShape(input.root);
+    assertDeviceIdShape(input.deviceId);
+    assertDeviceOwnerShape(input.owner);
+}
 export function assertRebindShape(input) {
-    assertRootSessionIdShape(input.rootSessionId);
-    assertDeviceIdShape(input.toDeviceId);
+    assertRootSessionIdShape(input.root);
+    assertDeviceIdShape(input.targetDeviceId);
     assertDeviceOwnerShape(input.owner);
     if (!Number.isInteger(input.expectedRev) || input.expectedRev < 0) {
         throw new Error(`device-store: expectedRev must be a non-negative integer (got ${input.expectedRev}) — it enters a byte-exact BIGINT equality predicate`);
@@ -194,13 +199,14 @@ function cloneOwner(o) {
 }
 export class InMemoryDeviceStore {
     devices = new Map();
-    sessions = new Map();
     tokens = new Map();
     audit = [];
     auditSeq = 0;
     now;
+    seat;
     constructor(opts) {
-        this.now = opts?.now ?? (() => Date.now());
+        this.seat = opts.seat;
+        this.now = opts.now ?? (() => Date.now());
     }
     async issueEnrollToken(input) {
         assertIssueTokenShape(input);
@@ -361,57 +367,24 @@ export class InMemoryDeviceStore {
         row.rev += 1;
         return true;
     }
-    async bindSession(input) {
-        assertRootSessionIdShape(input.rootSessionId);
-        assertDeviceIdShape(input.deviceId);
-        assertDeviceOwnerShape(input.owner);
+    async placeDeviceExecution(input) {
+        assertPlaceDeviceShape(input);
         const device = this.devices.get(input.deviceId);
         if (!device || !sameOwner(device.owner, input.owner))
             return { outcome: "device_not_found" };
         if (device.status !== "active")
             return { outcome: "device_revoked" };
-        const existing = this.sessions.get(input.rootSessionId);
-        if (existing) {
-            const same = existing.deviceId === input.deviceId && sameOwner(existing.owner, input.owner);
-            return { outcome: same ? "idempotent" : "conflict", row: this.snapshotSession(existing) };
-        }
-        const row = {
-            rootSessionId: input.rootSessionId,
-            deviceId: input.deviceId,
-            owner: cloneOwner(input.owner),
-            boundAtMs: this.now(),
-            rev: 0,
-        };
-        this.sessions.set(row.rootSessionId, row);
-        return { outcome: "bound", row: this.snapshotSession(row) };
+        return this.seat.bindDevice(input.root, input.occupant, { id: input.deviceId, owner: cloneOwner(input.owner) }, new Date(this.now()).toISOString());
     }
-    async rebindSession(input) {
+    async rebindDeviceExecution(input) {
         assertRebindShape(input);
-        const device = this.devices.get(input.toDeviceId);
+        const device = this.devices.get(input.targetDeviceId);
         if (!device || !sameOwner(device.owner, input.owner) || device.status !== "active")
             return { outcome: "device_not_found" };
-        const row = this.sessions.get(input.rootSessionId);
-        if (!row || !sameOwner(row.owner, input.owner))
-            return { outcome: "binding_not_found" };
-        if (row.deviceId === input.toDeviceId && row.rev === input.expectedRev)
-            return { outcome: "idempotent", row: this.snapshotSession(row) };
-        if (row.rev !== input.expectedRev)
-            return { outcome: "rev_conflict", row: this.snapshotSession(row) };
-        const from = row.deviceId;
-        row.deviceId = input.toDeviceId;
-        row.boundAtMs = this.now();
-        row.rev += 1;
-        this.pushAudit({ event: "session_rebound", deviceId: input.toDeviceId, owner: row.owner, detail: { from, to: input.toDeviceId, rev: row.rev } });
-        return { outcome: "rebound", row: this.snapshotSession(row) };
-    }
-    async getSessionBinding(rootSessionId) {
-        assertRootSessionIdShape(rootSessionId);
-        const row = this.sessions.get(rootSessionId);
-        return row ? this.snapshotSession(row) : null;
-    }
-    async deleteByRootSession(rootSessionId) {
-        assertRootSessionIdShape(rootSessionId);
-        return this.sessions.delete(rootSessionId) ? 1 : 0;
+        const out = this.seat.rebindDevice(input.root, input.occupant, cloneOwner(input.owner), input.expectedRev, input.targetDeviceId, new Date(this.now()).toISOString());
+        if (out.outcome === "rebound")
+            this.pushAudit({ event: "session_rebound", deviceId: input.targetDeviceId, owner: input.owner, detail: { from: out.from, to: input.targetDeviceId, rev: out.device.rev } });
+        return out;
     }
     async appendAudit(input) {
         this.pushAudit(input);
@@ -440,9 +413,6 @@ export class InMemoryDeviceStore {
     snapshotDevice(row) {
         return { ...row, owner: cloneOwner(row.owner) };
     }
-    snapshotSession(row) {
-        return { ...row, owner: cloneOwner(row.owner) };
-    }
 }
 export { sameOwner as sameDeviceOwner, cloneOwner as cloneDeviceOwner };
 //# sourceMappingURL=device-store.js.map

package/dist/device-ws-hub.js

@@ -832,7 +832,8 @@ export function createDeviceWsHub(options) {
             return { kind: "rejected", reject: rejection(DEVICE_DRAINING_CODE, "this device hub is closed for shutdown — the instruction was never dispatched (safe to retry once the device reconnects on a replacement replica)", DRAIN_RETRY_AFTER_SEC) };
         if (draining)
             return drainingRejectResult();
-        const admitted = await enrollment.admitSession({ rootSessionId: input.rootSessionId, requester: input.requester });
+        const placement = await enrollment.readPlacement(input.rootSessionId);
+        const admitted = await enrollment.admitSession({ rootSessionId: input.rootSessionId, placement, requester: input.requester });
         if (!admitted.ok)
             return { kind: "rejected", reject: admitted.reject };
         if (abortedNow())

package/dist/env-name-allowlist-knobs.d.ts

@@ -10,12 +10,13 @@
  *      带外凭据(e2b / docker / k8s 车道本来就是多租户 fleet 的主形),与 LSP 那条「本机子进程」的形不同;多租户下起服说一句。
  *  · `BAKE_ENV_ALLOW`([ref] 残余,7.103.0)由 **bake-runner 进程**读(构建宿主守护进程:没有主体、没有租户 ⇒ 没有姿态列,
  *    不进 {@link describeAllowlistPostures} 的姿态句)。它与服务侧四只旋钮同一只解析器、同一只「点名放行」谓词、同一条「原文按凭据类」律。
- *  · `channel` = 这张名单**交给谁、在谁的减法之上**(闭集两词,解析器按它定「不许点哪些名」):
+ *  · `channel` = 这张名单**交给谁、在谁的减法之上**(闭集两词)。它只定拒句里「交到哪里」那半句与出路的主语,**不定拒不拒**:「不许点哪些名」对五只一律
+ *    = 名单型旋钮名 ∪ 本服务自有凭据名(引擎此刻的声明:起服解析时判一次,声明增长时由换代声明对活配置里每只服务侧名单此刻交出去的名重判一次;判官 = 引擎
+ *    `inheritEnvPolicyProblem`,与引擎拒嵌入方白名单同句),规则全文在解析器头注 ②。
  *    - `host-put-back`(`LSP_ENV_ALLOW` / `BAKE_ENV_ALLOW`)—— 剥后放回形:宿主子进程的 env 先经唯一组合(引擎扣掉本服务自有凭据 + 形状剥),
- *      名单点到的键再从本进程环境**原样**取回叠上去。点到本服务自有凭据名 = 把引擎刚扣下的那枚交回去 ⇒ 起服拒,判官 = 引擎同一只
- *      (`inheritEnvPolicyProblem`,读起服声明;与引擎拒嵌入方白名单同句)。
+ *      名单点到的键再从本进程环境**原样**取回叠上去;点到本服务自有凭据名 = 把引擎刚扣下的那枚交回那只子进程。
  *    - `sandbox-grant`(三只沙箱名单)—— 沙箱 env 的唯一来源(沙箱不从本进程继承任何东西),部署方显式交出的带外凭据([ref] 照转发);
- *      本列不在「自有凭据」律的射程里,只拒点名名单型旋钮(原文按凭据类)。
+ *      点到本服务自有凭据名 = 把它装进模型读得到的沙箱 env。沙箱要凭据 ⇒ 部署方给沙箱另铸一把(名与值都不同于本服务的任何凭据)。
  * 表是 `Record<旋钮, …>`:闭集加一只旋钮而不补行 = 编译红;行形随读它的进程定(服务进程 ⇒ 必须写姿态列)。
  *
  * 🔴 **姿态列只在这里写一次**([ref];7.101.0 合并复审 O9):凡要对人说「多租户下哪只旋钮忽略、哪只照转发」的句子,一律取

package/dist/exec-cut.d.ts

@@ -0,0 +1,60 @@
+/**
+ * 一条**跑过**才被切的命令,执行错误怎么造、切断那一刻输出往哪去的**唯一一条律**(七只 adapter —— host〔管道 / spool 两形〕/ adb / e2b / ssh / k8s /
+ * local-docker / device —— 同读这一只):
+ *
+ *   命令已经起跑、之后被切 —— 墙钟(`timeout`)、静默界(`liveness_no_output`)、调用方中止(`aborted`)、宿主侧输出回调失败(`callback_error`)—— 它在被切之前
+ *   写出的 stdout / stderr 是真实的工作成果,必须原样带在 `ExecutionError.partialStdout` / `partialStderr` 上(core 合同:参考行为是超时保留**全部**已捕获的输出,
+ *   只追加一句「超时了」;丢掉 600 s 的构建日志会逼模型盲重跑)。引擎只从这两个字段读输出拼工具结果,从 `message` 读不到 ——
+ *   缺席就报「(no output was produced before the cutoff)」,模型对着一个其实已写了进度的命令说「什么也没产出」。
+ *
+ *   **切断即落定**:切断时本层手里还没交出的输出(远端 shell 腿 cwd 过滤器压着的 stderr 尾巴、host spool 还没泵的字节)只**记账**(尾窗 / detach tee),
+ *   随错误交回,不经调用方的输出回调**外发**。**落定先于构造,构造只记账**:构造结局会做事的腿(ssh / adb / k8s / host spool —— 冲刷压着的尾巴、泵 spool、
+ *   杀进程)的 `finish` 收一只构造结局的函数,先置落定,再构造、收尾、解决 —— 构造期间不调调用方的代码,重入的 detach / abort / close 读到的都是「已落定」。
+ *   正常结束同一顺序:压着的尾巴先记账、解决,**之后**才交给回调(那是流本身的结尾,不是切断)—— 回调里发生什么(重入、抛错)都改不了、也挂不住结局。
+ *   构造只读尾窗 / SDK 句柄字段的腿(host 管道 / local-docker / e2b)造错误即读,没有可重入的东西;device 的错误在投递结算之后才造。
+ *
+ * 与 `exec-bounds.ts` 的分工:那一只定「什么界在何时切、切断报哪个码、哪句话、几秒」(`buildLivenessCut` 等);这一只定「切断的错误带什么」。静默切断的
+ * 数据(`buildLivenessCut` 的返回)直接就是这里的 {@link ExecCut};墙钟与中止切断各 adapter 自己说句子(它们的成因词各车道不同),错误一律经 {@link createCutError} 造;
+ * 码是数据的腿(device:码由对端说,经映射表落到本侧)经 {@link createExecFailure} 按同一判别造。
+ *
+ * 输出的口径 = 同一条命令正常收口时 `exec` 会交出的那一份,切断不另设一道界、不二次切片:自带有界滚动尾窗(`RollingTailBuffer`)的腿读尾窗的当前文本,被丢掉的字节照旧附
+ * `markTruncated` 的记号({@link buildCapturedOutput});收口交出的是 SDK 整串的腿(e2b)读 SDK 句柄自己的记录;device 读它自己收齐的两路串。远端 shell 腿(ssh / adb / k8s)
+ * 的 stderr 在读之前先把 cwd 过滤器压着的尾巴记进账,与正常收口同一步。`message` 只陈述事实(哪一界、多少毫秒),不再夹输出。
+ *
+ * 不在本律里:命令**没起跑**就失败的码(`spawn_error` / `shell_unavailable` / 起跑前的 `aborted` / device 投递门之前的拒)按定义没有输出;结果未知
+ * (`transport_lost` / `outcome_unknown`)与未分类(`unknown`)的码引擎不读它的 partial —— 判别只有 {@link isRanThenCutCode} 一处。
+ */
+import { ExecutionError, type ExecutionErrorCode, type RollingTailBuffer } from "@sema-agent/core";
+/** 命令已起跑、随后被切的四个码(core `ExecutionError` 注:`partialStdout` / `partialStderr` 为这四个码而设)。 */
+export type RanThenCutCode = Extract<ExecutionErrorCode, "timeout" | "liveness_no_output" | "aborted" | "callback_error">;
+/**
+ * 一次切断的数据:码 + 句。`noOutputSec` 只属静默切断(静默窗口的整秒数,core `ExecutionError` 第五构造参)—— 与 `exec-bounds.ts` 的
+ * `buildLivenessCut` 返回值同形,可直接传入。
+ */
+export type ExecCut = {
+    readonly code: Exclude<RanThenCutCode, "liveness_no_output">;
+    readonly message: string;
+} | {
+    readonly code: "liveness_no_output";
+    readonly message: string;
+    readonly noOutputSec?: number;
+};
+/** 切断那一刻命令已写出的输出(纯数据;两路都是字符串,没写 = 空串)。 */
+export interface CapturedOutput {
+    readonly stdout: string;
+    readonly stderr: string;
+}
+/**
+ * 切断那一刻两路滚动尾窗里的内容 = 该命令正常收口时 `exec` 交出的那一份(滚出窗外的字节照旧附 {@link markTruncated} 的记号)。
+ * `stdout` 缺席 = 这一次往返把 stdout 整份留作**数据载荷**(字节精确的文件读取:adb / local-docker 的 `binary`、k8s 的非 `boundOutput`)—— 载荷不是
+ * 命令输出,被切的数据读取没有「已写出的输出」可交给读者,stdout 记空串;stderr 恒是命令输出。
+ */
+export declare function buildCapturedOutput(stdout: RollingTailBuffer | undefined, stderr: RollingTailBuffer): CapturedOutput;
+/** 一条起跑后被切的命令的执行错误 —— 唯一造法(见文件头注):码 / 句取自 `cut`,输出取自 `captured`(逐字,不截)。 */
+export declare function createCutError(cut: ExecCut, captured: CapturedOutput): ExecutionError;
+/**
+ * 码是**数据**时的执行错误(device:对端说的词经映射表落到本侧,这一刻才知道是哪个码)—— 同一条律:命令起跑过(`ran` = 它已写出的输出)且码是起跑后被切的
+ * 四个之一 ⇒ 经 {@link createCutError} 带输出;其余(没起跑 = `ran` 缺席 / 结果未知 / 未分类)按律不带。码在调用处就是字面量的腿直接用 {@link createCutError}。
+ */
+export declare function createExecFailure(code: ExecutionErrorCode, message: string, ran?: CapturedOutput): ExecutionError;
+//# sourceMappingURL=exec-cut.d.ts.map

package/dist/exec-cut.js

@@ -0,0 +1,36 @@
+import { ExecutionError, markTruncated } from "@sema-agent/core";
+function isRanThenCutCode(code) {
+    switch (code) {
+        case "timeout":
+        case "liveness_no_output":
+        case "aborted":
+        case "callback_error":
+            return true;
+        case "shell_unavailable":
+        case "spawn_error":
+        case "transport_lost":
+        case "suspended":
+        case "auth_failed":
+        case "outcome_unknown":
+        case "target_unavailable":
+        case "unknown":
+            return false;
+    }
+}
+export function buildCapturedOutput(stdout, stderr) {
+    const err = stderr.result();
+    const out = stdout?.result();
+    return {
+        stdout: out === undefined ? "" : markTruncated(out.text, out.droppedBytes),
+        stderr: markTruncated(err.text, err.droppedBytes),
+    };
+}
+export function createCutError(cut, captured) {
+    return new ExecutionError(cut.code, cut.message, undefined, { stdout: captured.stdout, stderr: captured.stderr }, cut.code === "liveness_no_output" ? cut.noOutputSec : undefined);
+}
+export function createExecFailure(code, message, ran) {
+    if (ran !== undefined && isRanThenCutCode(code))
+        return createCutError({ code, message }, ran);
+    return new ExecutionError(code, message);
+}
+//# sourceMappingURL=exec-cut.js.map

package/dist/execution-lane-caps.d.ts

@@ -139,6 +139,20 @@ export declare function executionLaneRow(lane: RemoteExecProvider): ExecutionLan
  * device 没有必需 env(设备是运行期连进来的;它的 boot 前提是跨键的,在跨域不变量区拒启)。
  */
 export declare function laneRequiredEnv(lane: RemoteExecProvider): readonly string[];
+/**
+ * 一个必需 env 的值**算不算缺**的唯一判官 —— 两半各有归属:
+ *  · **空白半边**(空串、只含空白)归契约包:包根导出的 `isBlankCoordinate` 是这件事唯一的实现,契约包的写闸(车道声明保存时)问的是同一只函数,本仓不另抄一份;
+ *  · **未设半边**(`undefined`)归本仓:契约包的判官只收字符串,「这一键根本没设」由调用方先判,所以这一臂留在这里。
+ * 合起来:`undefined`、空串、只含空白一律按缺 —— 引擎把空值读成未设,纯空白拼进坐标(镜像名、命名空间、主机名)也只会在第一次用的时候才失败。
+ * 所有车道、所有必需键同判一只,没有「某个键另有一套缺席 / 空白判法」。
+ * 只判「是不是空白」:不 trim 值本身、不管值的格式(`" sandboxes "` 照过);可选键不走它(个别可选键的空串有语义,如 `K8S_RUNTIME_CLASS` 的空串 = 不用 Kata)。
+ */
+export declare function isBlankRequiredEnvValue(value: string | undefined): boolean;
+/**
+ * 一条车道此刻**缺**的必需 env 键名(次序同 {@link laneRequiredEnv};「缺」的判官是 {@link isBlankRequiredEnvValue})。
+ * 读者:`config.ts` 的 [ref] 拒启门(非空 ⇒ 拒启并点名缺哪几键);判的是调用方交来的 env 快照,本函数不读 `process.env`。
+ */
+export declare function laneMissingEnv(lane: RemoteExecProvider, env: Readonly<Record<string, string | undefined>>): readonly string[];
 /**
  * [ref] 件③ / [ref] —— **「`REQUIRE_EXECUTION_LANE=true` ∧ 没有任何车道被点名 ⇒ 拒启」的判据与拒因句的唯一属主**(`modelProviderRefusal` /
  * `modelRouteEndpointRefusal` 同形:属主在叶模块,执法点各自调它,登记在 `config-invariants.ts`)。
@@ -175,6 +189,11 @@ export declare function executionLaneRequiredRefusal(deployment: {
  */
 export declare function executionLaneOf(provider: RemoteExecProvider | undefined): ExecutionLane;
 export declare function executionLaneOf(provider: string | undefined): ExecutionLane | undefined;
+/**
+ * 本部署声明的**有序执行车道表**(首项 = 缺省 = 服务车道)的唯一读法。本版 `REMOTE_EXEC` 单值 ⇒ 一元表 `[executionLaneOf(provider)]`;
+ * 车道表配置面落地时只改这一只。读者:执行放置切换的回填(一次性迁移 M32 与它的 DDL 前探针 —— 回填只在一元表下有唯一答案)。
+ */
+export declare function deployedExecutionLanes(config: Pick<ServiceConfigFlat, "remoteExec">): readonly ExecutionLane[];
 /**
  * [ref] —— 「这条车道的**手**就在本 worker 的盘上吗」。**两位合取,都读表**(不手抄):
  *  · `coreRemoteExecutionEnv` —— core 拿到了执行环境 = 手带真挂上(`in-process` 答 NO:core 落 `StubExecutionEnv`);

package/dist/execution-lane-caps.js

@@ -1,5 +1,6 @@
 import { homedir } from "node:os";
 import { EXECUTION_LANE_WORDS as DECLARABLE_LANE_WORDS, EXECUTION_LANES } from "@sema-agent/settings-schema/execution-lanes";
+import { isBlankCoordinate } from "@sema-agent/settings-schema";
 import { DECLARE_HOME_REMEDY, buildHomeAbsentNote } from "./lane-home-probe.js";
 const NO = "unsupported";
 const YES = "supported";
@@ -180,6 +181,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,6 +206,9 @@ 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";

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