@sema-agent/server 7.147.0 → 7.148.0

package/dist/elicitation.js

@@ -3,6 +3,8 @@ import { uuidv7, delimitUntrusted } from "@sema-agent/core";
 import { redactSecrets, redactDeep } from "./trace/redact.js";
 import { recordFailOpen } from "./observability/fail-open.js";
 import { refusalBody } from "./http/refusal-body.js";
+import { keyAdmits, ownerCellOf, recoveredSubject } from "./owner-faces.js";
+import { createHitlOpenRace } from "./hitl-delivery.js";
 const MAX_ELICIT_MESSAGE_CHARS = 4096;
 const MAX_ELICIT_SCHEMA_BYTES = 8192;
 const RELEASE_ACTION = { refused: "decline", unanswered: "cancel" };
@@ -114,34 +116,33 @@ export class ElicitationCoordinator {
         signal?.addEventListener("abort", onAbort, { once: true });
         ctx.abortSignal?.addEventListener("abort", onAbort, { once: true });
         this.pending.set(id, { settle, owner: ctx.owner, taskId: ctx.taskId });
-        const emitted = (async () => {
-            const now = this.now();
-            return ctx.emit({ type: "elicitation", elicitationId: id, mcpServerName: req.server, message, ...(requestedSchema !== undefined ? { requestedSchema } : {}), mode: "form", serverNowMs: now, expiresInMs: this.throttle.ttlMs, expiresAtMs: now + this.throttle.ttlMs });
-        })().then(() => "ok", () => "failed");
-        const delivery = await Promise.race([emitted, answerP.then(() => "stalled")]);
-        if (delivery === "ok") {
+        const now = this.now();
+        const race = createHitlOpenRace({
+            targets: [{ transport: ctx.transport, frame: { type: "elicitation", elicitationId: id, mcpServerName: req.server, message, ...(requestedSchema !== undefined ? { requestedSchema } : {}), mode: "form", serverNowMs: now, expiresInMs: this.throttle.ttlMs, expiresAtMs: now + this.throttle.ttlMs } }],
+            settled: answerP,
+        });
+        const charge = () => {
             rc.total += 1;
             rc.lastByServer.set(req.server, t);
+        };
+        const phase = await race.phase;
+        if (phase === "delivered") {
+            charge();
         }
-        else if (delivery === "failed") {
+        else if (phase === "undelivered") {
             recordFailOpen("server.elicitation.open-frame-undelivered", `elicitation=${id} server=${req.server}`);
             settle({ action: RELEASE_ACTION.unanswered });
         }
-        const answer = await answerP;
-        void emitted
-            .then((result) => {
-            if (result === "failed") {
-                if (delivery === "stalled")
+        else {
+            void race.landing.then((late) => {
+                if (late === "delivered")
+                    charge();
+                else
                     recordFailOpen("server.elicitation.open-frame-undelivered", `elicitation=${id} server=${req.server}`);
-                return undefined;
-            }
-            if (delivery === "stalled") {
-                rc.total += 1;
-                rc.lastByServer.set(req.server, t);
-            }
-            return ctx.emit({ type: "elicitation_complete", elicitationId: id, mcpServerName: req.server, action: answer.action, serverNowMs: this.now() });
-        })
-            .catch(() => recordFailOpen("server.elicitation.complete-breadcrumb-dropped", `elicitation=${id}`));
+            });
+        }
+        const answer = await answerP;
+        race.close({ type: "elicitation_complete", elicitationId: id, mcpServerName: req.server, action: answer.action, serverNowMs: this.now() });
         return answer;
     };
     respond(id, principal, body) {
@@ -149,7 +150,7 @@ export class ElicitationCoordinator {
         if (!parsed.ok)
             return { status: 400, body: refusalBody({ errorCode: "request.body_shape", message: parsed.error }) };
         const entry = this.pending.get(id);
-        if (!entry || (entry.owner !== null && entry.owner !== principal)) {
+        if (!entry || !keyAdmits("ask.answer", { subject: recoveredSubject(principal), operator: false }, ownerCellOf(entry.owner))) {
             return { status: 404, body: refusalBody({ errorCode: "elicitation.not_pending", message: "no pending elicitation for this id (answered, expired, or not on this replica)" }) };
         }
         entry.settle(parsed.value);

package/dist/engine-identity.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 🔴 **引擎交界的身份**(唯一一处;叶子):一只主体的三格(`owner-brands.ts` 的 `partsOf`)怎么落进引擎 `TaskSpec` 的身份格。
+ *
+ * 二元形:`principal` = **人**(引擎的成文契约「终端用户 / MCP RBAC / 治理键」:用量窗扣账、出站 MCP / A2A 身份、事件归因、检查点的 `principal` 格都按人,
+ * 与本仓的人面汇点同轴);`isolationScope` = **带场景的主体**(只在请求带了场景时有;引擎按它分登记域 / offload 租界 / 后台登记 / peer 目录 / 工作流 scope,
+ * 引擎的读法是「隔离格缺席 ⇒ 读 `principal`」)。没带场景的请求只有 `principal`,与今天逐字节同。检查点的分区走本仓自己供的 `scope` 格。
+ *
+ * 今天的引擎还没有隔离格:{@link taskSpecIdentityOf} 是**唯一的落点**,今天只写 `principal`;隔离格到货后改那一行(钉在 `test/scenario-subject.test.ts`)。
+ * 落点之前引擎自己按 `spec.principal` 分的那几面按人分(同一个人的各场景在那几面互见)—— 本仓镜像这几面的读口(工作流读面、后台登记簿的停止标记、
+ * leader 子任务的 spec)同读 {@link taskSpecIdentityOf},读到的就是引擎写下的那一个值,不各写一份。
+ */
+import type { Person, Subject, SubjectParts } from "./owner-brands.js";
+/** 引擎交界的身份(本仓的类型;二元)。 */
+export interface EngineIdentity {
+    readonly principal: Person | undefined;
+    /** 带场景的主体;没带场景 ⇒ 缺席(引擎读 `principal`)。 */
+    readonly isolationScope?: Subject;
+}
+/** 一只主体(没有 ⇒ 匿名)在引擎交界上的身份。 */
+export declare function specIdentityOf(parts: SubjectParts | undefined): EngineIdentity;
+/**
+ * 落进 `TaskSpec` 的身份格(**唯一落点**)。今天的引擎没有隔离格 ⇒ 只写 `principal`,`isolationScope` 在这里不落(引擎按人分它自己的那几面);
+ * 引擎的隔离格到货 ⇒ 这里加一格,别处不动。
+ */
+export declare function taskSpecIdentityOf(parts: SubjectParts | undefined): {
+    readonly principal?: string;
+};
+//# sourceMappingURL=engine-identity.d.ts.map

package/dist/engine-identity.js

@@ -0,0 +1,10 @@
+export function specIdentityOf(parts) {
+    if (parts === undefined)
+        return { principal: undefined };
+    return parts.scenario === undefined ? { principal: parts.person } : { principal: parts.person, isolationScope: parts.subject };
+}
+export function taskSpecIdentityOf(parts) {
+    const { principal } = specIdentityOf(parts);
+    return principal === undefined ? {} : { principal };
+}
+//# sourceMappingURL=engine-identity.js.map

package/dist/entry-problems.d.ts

@@ -18,14 +18,12 @@ export interface EntryProblem {
 }
 /** 铸一条问题:`entry` 收**原串**,这里过脱敏(调用方没有「忘了脱敏」的可能)。 */
 export declare function entryProblem(code: string, field: string, rawEntry: string, reason: string): EntryProblem;
-/** 拒体上的机读位(原样进 `HttpError.extra` / `refusalBody` 的 `facts`:顶层 `field` + 对象形 `detail`)。 */
-export interface EntryProblemsFacts {
+/** 拒体上的机读位(原样摊在拒体根上:`HttpError.extra` / `refusalBody` 的 `facts`)。型别名而不是接口 —— 要能直接当 `Record<string, unknown>` 用。 */
+export type EntryProblemsFacts = {
     readonly field: string;
-    readonly detail: {
-        readonly problems: readonly EntryProblem[];
-        readonly total: number;
-    };
-}
+    readonly problems: readonly EntryProblem[];
+    readonly total: number;
+};
 /**
  * 一遍判下来的全部问题 ⇒ 拒体的机读位。**不能空**:没有问题就没有拒(调用方只在命中时调),空表是调用点的错,响亮抛。
  * 顶层 `field` = 第一条问题的坐标(句子点名的那一张清单)。

package/dist/entry-problems.js

@@ -9,6 +9,6 @@ export function entryProblemsFacts(found) {
     const first = found[0];
     if (first === undefined)
         throw new Error("entryProblemsFacts: a refusal needs at least one problem");
-    return { field: first.field, detail: { problems: found.length > MAX_ENTRY_PROBLEMS ? found.slice(0, MAX_ENTRY_PROBLEMS) : found, total: found.length } };
+    return { field: first.field, problems: found.length > MAX_ENTRY_PROBLEMS ? found.slice(0, MAX_ENTRY_PROBLEMS) : found, total: found.length };
 }
 //# sourceMappingURL=entry-problems.js.map

package/dist/env-facts.js

@@ -1,3 +1,4 @@
+import { writeLogText } from "./observability/logger.js";
 import { isAbsolute, join, resolve, sep } from "node:path";
 import { mkdir, readdir, rm, stat } from "node:fs/promises";
 import { ensureDir } from "@sema-agent/core";
@@ -147,7 +148,7 @@ export async function purgeScratchpadDir(localDataRoot, sessionId) {
         await rm(dir, { recursive: true, force: true });
     }
     catch (err) {
-        console.warn(`scratchpad_purge_failed dir=${dir}: ${err instanceof Error ? err.message : String(err)}`);
+        writeLogText("stderr", `scratchpad_purge_failed dir=${dir}: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
 export async function sweepStaleScratchpads(localDataRoot, opts) {

package/dist/env-witness.d.ts

@@ -0,0 +1,7 @@
+/** 出口座登记「这条 run 的环境一旦留下持久物就告诉我」;交回注销口(只注销自己登记的那一只)。 */
+export declare function listenEnvWitness(runId: string, onWitness: () => void): () => void;
+/** 环境留下了按会话键的持久物(run id 缺席 = 子 run / 服务自起的 run,不属任何提交 ⇒ 无事)。 */
+export declare function witnessEnv(runId: string | undefined): void;
+/** 在听的座数(测试读:收场后归零 = 不积累)。 */
+export declare function envWitnessListeners(): number;
+//# sourceMappingURL=env-witness.d.ts.map

package/dist/env-witness.js

@@ -0,0 +1,16 @@
+const listening = new Map();
+export function listenEnvWitness(runId, onWitness) {
+    listening.set(runId, onWitness);
+    return () => {
+        if (listening.get(runId) === onWitness)
+            listening.delete(runId);
+    };
+}
+export function witnessEnv(runId) {
+    if (runId !== undefined)
+        listening.get(runId)?.();
+}
+export function envWitnessListeners() {
+    return listening.size;
+}
+//# sourceMappingURL=env-witness.js.map

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

@@ -3,7 +3,7 @@ import { type ExecutionLane as DeclarableLane, type ExecutionLaneRow } from "@se
 import type { ServiceConfigFlat } from "./config-types.js";
 import { type LaneHomeConfig } from "./lane-home-probe.js";
 /** 一位能力的三态。`single-user-only` = 车道支持,但只在单用户部署(`requirePrincipal !== true`)开 ——
- *  多租户下这一位必须关(host 家族的 cwd/scheduler/backgroundShell/LSP 都是这一档,理由同源:
+ *  多租户下这一位必须关(host 家族的 cwd/scheduler/backgroundShell 都是这一档,理由同源 —— 本机语言服务器同理由,答者是部署形行 `callerOwnsWorkerDisk`:
  *  一个租户的输入不许把 agent 指向 worker 宿主上另一个租户/运维的文件与进程)。 */
 export type LaneCapability = "supported" | "unsupported" | "single-user-only";
 /** 闭集:执行车道全集 = settings-schema 词表正本的可声明车道(**派生**,本仓零手抄;`REMOTE_EXEC` 能写下去的词就是这些)。
@@ -23,8 +23,6 @@ export interface ExecutionLaneCaps {
     /** 自唤醒 scheduler(`CronCreate`/…)。判别式:`boot/execution-env.ts` host 臂的 `hostScheduler`
      *  与 `http/routes/capabilities.ts` 的 `scheduler` 位(两处同判据)。 */
     readonly scheduler: LaneCapability;
-    /** LSP。判别式:`boot/execution-env.ts` 的 `lspManager` 两臂(沙箱桥 e2b/k8s;host 本地 NodeLspManager)。 */
-    readonly lsp: LaneCapability;
     /** SendUserFile 的**沙箱直传腿**(host 的本机 fs 源是另一条腿,不是本位)。
      *  读者:部署形表行 `sandboxSendUserFile`(本位即判据;判定依据在 `capabilities/sandbox-file-send.ts` 头注)。 */
     readonly sandboxSendUserFile: LaneCapability;
@@ -58,8 +56,8 @@ export interface ExecutionLaneCaps {
  *    绑定验证),故不要求单用户。(部署形表行 `callerCwd` 直接读本位。)
  *  · `remoteScratchpad: supported` —— executor 平台闭集 = darwin|linux,`/tmp/scratchpad/<sessionId>`
  *    的惰性 mkdir 约定原样适用;不加词则 scratchpad envFact 对模型整块缺席。
- *  · scheduler / backgroundShell / lsp / sandboxSendUserFile / worktreeIsolation = v1 **诚实关闭**
- *    (不是遗漏:设备侧长驻进程、LSP sidecar、直传腿都是 follow-on,声明了就是谎)。
+ *  · scheduler / backgroundShell / sandboxSendUserFile / worktreeIsolation = v1 **诚实关闭**
+ *    (不是遗漏:设备侧长驻进程、直传腿都是 follow-on,声明了就是谎)。
  */
 export declare function executionLaneCaps(lane: ExecutionLane): ExecutionLaneCaps;
 /** 读地板旋钮的 env 名(拒起句与起服行点名它)。 */
@@ -186,22 +184,11 @@ export declare function deployedExecutionLanes(config: Pick<ServiceConfigFlat, "
  *
  * 读者问的都是这一句,**同一只函数**,不许各写一份 `=== "host"`:
  *  ① 部署形表行 `toolsOnThisHost`(`deployment-shape.ts`)—— wire `executionLane.toolsOnThisHost` + 出厂自扫技能与中心 plugin 技能的 `baseDir`;
- *  ② 部署形表行 `callerOwnsWorkerDisk`(本列 ∧ 单主)—— SendUserFile 本机腿(「无手不挂」)、调用方宿主路径(附加目录 / 项目上下文)、指令文件探针;
+ *  ② 部署形表行 `callerOwnsWorkerDisk`(本列 ∧ 单主)—— SendUserFile 本机腿(「无手不挂」)、调用方宿主路径(附加目录 / 项目上下文)、指令文件探针、
+ *     本机语言服务器(`createLspManager`;这类车道的适配器必须绑得住读 `openBound`,对拍钉 `test/host-env-open-bound.test.ts`);
  *  ③ `approval.ts` 的 `buildNoResponderBootWarns` —— 写门的 ask 只在「有手写本机盘」时才会发生(它手里已有车道词,直接读本列)。
  */
 export declare function handsOnWorkerFilePlane(lane: ExecutionLane): boolean;
-/**
- * core 7.50.0 —— 「这条车道的执行环境能不能把一次读**绑到判过的那只对象**上」(`FileSystem.openBound`:开着并持有,叶链接不跟,
- * 开后身份对拍)。LSP 会话的读口与路径附件只经它读;环境不实现 ⇒ 那两个读口在这条车道上一律拒。
- *
- * **一条律**:LSP 只在本谓词为真的车道挂(`boot/execution-env.ts` 的 LSP 管理器两臂都合取它;表的 `lsp` 位与之同向,
- * 对拍钉 `test/host-env-open-bound.test.ts`:本谓词 ⟺ 适配器类原型上有 `openBound`)。
- *  · `host` —— `RemoteHostExecutionEnv.openBound` 委托 core `NodeExecutionEnv` 的实现(唯一属主),真;
- *  · `none` —— 没有手(执行环境两座都不给),无物可绑;
- *  · 其余车道(沙箱 / 远端 shell / 设备)—— 读走 exec / sftp / 设备协议,本版不实现绑定读,假。实现之日翻这一格,LSP 沙箱桥随之回来。
- * 穷举 switch、无 default 臂:车道加词而此处不表态 = 编译红。
- */
-export declare function laneBindsReads(lane: ExecutionLane): boolean;
 /**
  * 「这条车道的执行环境**自己读得出家目录**」—— 读得出 ⇒ 读数是真源:适配器持一只 `LaneHomeSeat`(取值律与座的唯一属主 = `lane-home-probe.ts`),
  * 部署给的主张({@link buildLaneHomeClaim})在每只环境开起来时被证,不一致 ⇒ 那只环境不开;没有主张 ⇒ 读数填 `ExecutionEnv.homeDir` 的座。

package/dist/execution-lane-caps.js

@@ -12,7 +12,6 @@ export function executionLaneCaps(lane) {
                 callerCwd: NO,
                 backgroundShell: NO,
                 scheduler: NO,
-                lsp: NO,
                 sandboxSendUserFile: NO,
                 remoteScratchpad: NO,
                 worktreeIsolation: NO,
@@ -23,7 +22,6 @@ export function executionLaneCaps(lane) {
                 callerCwd: SU,
                 backgroundShell: SU,
                 scheduler: SU,
-                lsp: SU,
                 sandboxSendUserFile: NO,
                 remoteScratchpad: NO,
                 worktreeIsolation: YES,
@@ -34,7 +32,6 @@ export function executionLaneCaps(lane) {
                 callerCwd: NO,
                 backgroundShell: YES,
                 scheduler: NO,
-                lsp: NO,
                 sandboxSendUserFile: YES,
                 remoteScratchpad: YES,
                 worktreeIsolation: NO,
@@ -45,7 +42,6 @@ export function executionLaneCaps(lane) {
                 callerCwd: NO,
                 backgroundShell: YES,
                 scheduler: NO,
-                lsp: NO,
                 sandboxSendUserFile: YES,
                 remoteScratchpad: YES,
                 worktreeIsolation: NO,
@@ -56,7 +52,6 @@ export function executionLaneCaps(lane) {
                 callerCwd: NO,
                 backgroundShell: NO,
                 scheduler: NO,
-                lsp: NO,
                 sandboxSendUserFile: SU,
                 remoteScratchpad: YES,
                 worktreeIsolation: NO,
@@ -67,7 +62,6 @@ export function executionLaneCaps(lane) {
                 callerCwd: NO,
                 backgroundShell: NO,
                 scheduler: NO,
-                lsp: NO,
                 sandboxSendUserFile: NO,
                 remoteScratchpad: NO,
                 worktreeIsolation: NO,
@@ -78,7 +72,6 @@ export function executionLaneCaps(lane) {
                 callerCwd: NO,
                 backgroundShell: NO,
                 scheduler: NO,
-                lsp: NO,
                 sandboxSendUserFile: NO,
                 remoteScratchpad: YES,
                 worktreeIsolation: NO,
@@ -89,7 +82,6 @@ export function executionLaneCaps(lane) {
                 callerCwd: YES,
                 backgroundShell: NO,
                 scheduler: NO,
-                lsp: NO,
                 sandboxSendUserFile: NO,
                 remoteScratchpad: YES,
                 worktreeIsolation: NO,
@@ -263,20 +255,6 @@ export function handsOnWorkerFilePlane(lane) {
     const block = laneBlock(lane, NO_SUB_KNOBS);
     return block.io && block.hostLocalPaths;
 }
-export function laneBindsReads(lane) {
-    switch (lane) {
-        case "host":
-            return true;
-        case "none":
-        case "e2b":
-        case "k8s":
-        case "ssh":
-        case "adb":
-        case "device":
-        case "local-docker":
-            return false;
-    }
-}
 export function laneMeasuresHome(lane) {
     switch (lane) {
         case "k8s":

package/dist/execution-placement.d.ts

@@ -9,7 +9,7 @@
  *    委派分区行读作「不在」。
  *  · **读只有一只**:会话店的执行席 {@link ExecutionPlacementSeat.read}(一次行读:住客 + 格;行不在 / 委派分区行 ⇒ `undefined`;读故障抛,不吞成 `absent`)。
  *    跨行的聚合也只有一只:设备店的绑定数 `countDeviceBindings`(writer(device, D) 的格数 = {@link boundDeviceOf} 的聚合;只交数,不交根 id)。
- *  · **写只按住客谓词** `(root, incarnation, owner) ∧ placement_kind IS NULL`:住客换了(删后重建,哪怕同一属主;local M10 窗内的认领)= 这一格不在 ⇒ 落空;
+ *  · **写只按住客谓词** `(root, incarnation, owner) ∧ placement_kind IS NULL`:住客换了(删后重建,哪怕同一属主)= 这一格不在 ⇒ 落空;
  *    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。
@@ -22,6 +22,7 @@ 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";
+import type { SessionWrite } from "./plugins/store-backend.js";
 /** writer(device, D) 的 D:设备、绑定属主(= 设备属主)、换绑序号、放下时刻(ISO)。 */
 export interface ExecutionDeviceCell {
     readonly id: string;
@@ -108,13 +109,22 @@ export interface UnusableArchive {
     readonly fault: unknown;
 }
 export declare function isUnusableArchive(x: object | undefined): x is UnusableArchive;
+/** {@link LocalPlacementBackfillSeat.backfill} 的结局(随 M32):写成了 writer · 这一格此刻不归回填(行不在 / placed / 已有执行位 / forking)· 车道表不是一项而这一格要回填(不写)· 存档读不出(点名跳过)。 */
+export type LocalPlacementBackfillOutcome = {
+    readonly outcome: "placed";
+} | {
+    readonly outcome: "skipped";
+} | {
+    readonly outcome: "ambiguous";
+} | UnusableArchive;
 /**
- * 一次性迁移 M32 **local 腿**的席(随 M32 · 窗口见 `plugins/one-time-migrations.ts` 登记表;只 local 有:SQL 的行就是会话,没有「会话元数据格缺 ∧ 存档读不出」这一形)。`read` 与 {@link ExecutionPlacementSeat.read} 是
- * **同一读**(同一只实现的本体),只差一点:这只会话的存档读不出(格缺而探针读不出,或 fork 创建的格而探针读不出)⇒ **答 {@link UnusableArchive} 而不抛** —— 开机回填不动存档、
- * 只补一格放置,读不出的会话由它点名跳过(该会话的请求照旧答存档的故障);席的 `read` 对同一形照旧抛。`place` 就是席的 `place`。
+ * 一次性迁移 M32 **local 腿**的席(随 M32 · 窗口见 `plugins/one-time-migrations.ts` 登记表;只 local 有:SQL 的行就是会话,没有「会话元数据格缺 ∧ 存档读不出」这一形)。
+ * 唯一成员 `backfill(root, lanes)`:在这只会话的写锁里**观察一次**(与执行席的读同一只观察),absent 的那一格 ∧ 车道表只有一项 ⇒ **一笔**写成 writer(格缺就在同一笔里铸化身);
+ * 车道表不是一项 ⇒ `ambiguous`、不写;观察抛(这只会话的存档读不出)⇒ 答 {@link UnusableArchive} 而不抛 —— 开机回填不动存档、只补一格放置,读不出的会话由它点名跳过
+ * (该会话的请求照旧答存档的故障)。观察与写在同一节锁里:读与写之间没有别的写者。
  */
-export interface LocalPlacementBackfillSeat extends Pick<ExecutionPlacementSeat, "place"> {
-    read(root: string): Promise<ExecutionPlacementReading | UnusableArchive | undefined>;
+export interface LocalPlacementBackfillSeat {
+    backfill(root: string, lanes: readonly ExecutionLane[]): Promise<LocalPlacementBackfillOutcome>;
 }
 /** wire 投影(新读面 + 受理回声共用)。 */
 export type ExecutionPlacementView = {
@@ -135,7 +145,7 @@ export type ExecutionPlacementView = {
 export declare function executionPlacementView(cell: ExecutionPlacementCell): ExecutionPlacementView;
 /**
  * 住客谓词的 JS 读法(SQL `incarnation = ? AND owner <=> ?` 的对位)= core 的行期望判官 `sessionRowMatches`(会话行格写原语锁内判的也是它,
- * `session-row.ts` 的 `judgeSessionRowWrite`):属主与化身两样都没变才是判过的那一位 —— 同一化身的属主会变(local M10 认领、identical 重戳、
+ * `session-row.ts` 的 `judgeSessionRowWrite`):属主与化身两样都没变才是判过的那一位 —— 同一化身的属主会变(identical 重戳、
  * SQL 导入提交点改属主)。两侧收「属主 + 化身」那一读:活住客(`SessionFace`)与店的头(`SessionHead`,门判过的那一读)。三处调用方:
  *  · 执行格的写口判官(本模块)与执行上下文解析器步 ① 的 `judged` 复核(`http/execution-context.ts`)—— 一侧恒是执行席的读数(住客经 `sessionFaceFromRow` 解码,令牌非空);
  *  · 会话通知门投递前的住客复核(`session-notify-door.ts` 的 `recheck`)—— 两侧都是会话店的头读:不铸化身的店上**两侧都没有令牌**。
@@ -163,8 +173,8 @@ export declare class SessionForkInProgressError extends Error {
 }
 /**
  * 写口在写事务 / 写锁内的认领读命中:SQL = 读写序律(`plugins/execution-placement-sql.ts` 的 `lockRootAndReadClaim`:改根住客 / 放置的写者在自己的事务里先锁根
- * `session_meta` 行、再锁定读 `task_active(root)`,读到认领 ⇒ 回滚、一个字节不写、抛它);local = 这只会话的写锁内读 run 店的认领(`markMirror` 返回 `active` 臂;
- * 三个导入写口经 {@link judgeImportWrite} 抛它)—— 删除终刀与 device 首绑在写事务内的认领读仍只在 SQL 后端(local 没有 device 工厂)。
+ * `session_meta` 行、再锁定读 `task_active(root)`,读到认领 ⇒ 回滚、一个字节不写、抛它);local = 这只会话的写锁(= 根行锁)内读 run 店的认领(`markMirror` 返回 `active` 臂;
+ * 三个导入写口、删除与 placed 行的终结经 {@link judgeSessionWrite} 抛它)—— device 首绑在写事务内的认领读只在 SQL 后端(local 没有 device 工厂)。
  * 具名类型、**不带 wire 码**:各门按自己的既有码答(导入 409 `session_active`、删除 409 `conflict.session_active_run`),体带 `activeTaskId`。
  */
 export declare class SessionActiveRunError extends Error {
@@ -182,21 +192,51 @@ export declare const WRITABLE: "writable";
 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;
-/** {@link judgeImportWrite} 的判:放行,或拒(拒的载荷是写口抛的那只 typed 错;SQL 的事务内钩原样交给店,local 直接抛)。 */
-export type ImportWriteVerdict = "proceed" | {
-    readonly refuse: SessionActiveRunError | SessionWriterPresentError | SessionForkInProgressError;
+/**
+ * 删净在删会话的执行体(写词 `erase`;`session-erase.ts`)在根行锁里读到:这一行此刻**不是**这一次删除的在删态 —— 另一次删除接管了它(换了令牌)、它已经删完(行不在 / 同 id 的新住客)。
+ * 一个字节不删。具名类型、不带 wire 码:协调器把它读作「这次尝试被接管」(路由 409 `conflict.session_deleting`)。
+ */
+export declare class SessionDeletionSupersededError extends Error {
+    readonly sessionId: string;
+    constructor(sessionId: string);
+}
+/**
+ * 改动会话树根的写(导入三写口 / 撤回 / placed 行的终结 / 留存删除)在根行锁里读到这一行**在删**(会话三态,`src/session-deletion.ts`):一次删除独占着它,一个字节不写。
+ * 带 wire 码 `conflict.session_deleting`(全局兜底映射 409;导入路由的属主门读头 —— 在删读作不在 ⇒ 404 —— 只有门判过之后才落围栏的那一拍走到这里)。
+ * 留存删除读作「本轮跳过这棵树」(在删的行由删除协调器删完,留存不当第二个收尾者);撤回读作留(`claim`:一次删除持有这一行)。
+ */
+export declare class SessionDeletingError extends Error {
+    readonly sessionId: string;
+    readonly code = "conflict.session_deleting";
+    constructor(sessionId: string);
+}
+/** {@link judgeSessionWrite} 的判:放行,或拒(拒的载荷是写口抛的那只 typed 错;SQL 的事务内钩原样交给店,local 直接抛)。 */
+export type SessionWriteJudgement = "proceed" | {
+    readonly refuse: SessionActiveRunError | SessionWriterPresentError | SessionForkInProgressError | SessionDeletionSupersededError | SessionDeletingError;
 };
 /**
- * 三个导入写口(整段 `importEntries` / `replaceEntries` / 暂存提交)落定这一行**之前**的唯一判官,**连序**在内(SQL 的事务内钩 `import` 臂与 local 的写锁内同调,两店不各抄一份):
- * 先读认领 —— 在 ⇒ {@link SessionActiveRunError};再读这一格 —— `writer` ⇒ {@link SessionWriterPresentError}(带车道)、`forking` ⇒ {@link SessionForkInProgressError};
- * `absent` / `mirror` ⇒ 放行(落 mirror 由调用方写)。读口由调用方给、**按需读**:认领在 ⇒ 不读格(SQL:不发格那一句锁定读;local:不探存档)。
- * 读与判必须在写者独占的同一刻里:SQL = 锁根行之后、同一连接;local = 这只会话的写锁内、写格之前(取锁 → 读认领 → 判 → 写)。
+ * 一个写词碰不碰这一行的执行格(写词闭集的**唯一**分派,穷尽 —— 加一个词在这里编译红):`import` ⇒ 碰(判写者 / fork 中间态,放行后调用方落 mirror);
+ * `delete` / `retention-delete` ⇒ 不碰(删除不问执行格:格随这一行一起走)。判官 {@link judgeSessionWrite} 与 SQL 事务内钩的写派(放行后落不落 mirror)都读它。
+ */
+export declare function sessionWriteTouchesCell(op: SessionWrite["op"]): boolean;
+/**
+ * 改动会话树根的写(闭集 = `SessionWrite.op`:`import` 导入三写口落定这一行 / `delete` 提交出口的条件撤回与 placed 行的终结 / `retention-delete` 留存删一棵树的根 /
+ * `erase` 删净在删会话的执行体)落定**之前**的唯一判官,**连序**在内(SQL 的事务内钩与 local 的写锁内同调,两店不各抄一份):
+ * 先读这一行的在删令牌:
+ *  · `erase` —— 令牌等于 `write.token` ⇒ 放行,否则 {@link SessionDeletionSupersededError}(认领在围栏那一刻判过,在删期间认领落不下;不读认领、不读格);
+ *  · 其余三个词 —— 在删 ⇒ {@link SessionDeletingError}(一次删除独占着这一行;任何别的写者 / 删除者都不碰它);
+ * 不在删 ⇒ 其余三个词再读认领 —— 在 ⇒ {@link SessionActiveRunError}(活 run 挂着的根不换内容、不删);认领不在 ⇒ 按词:
+ *  · `import` 再读这一格 —— `writer` ⇒ {@link SessionWriterPresentError}(带车道)、`forking` ⇒ {@link SessionForkInProgressError};`absent` / `mirror` ⇒ 放行(落 mirror 由调用方写);
+ *  · `delete` / `retention-delete` ⇒ 放行(删除不问执行格:格随这一行一起走)。
+ * 读口由调用方给、**按需读**:在删令牌每个词都读;认领在 ⇒ 不读格;删除三词从不读格(SQL:不发格那一句锁定读;local:不探存档)。
+ * 读与判必须在写者独占的同一刻里:SQL = 锁根行之后、同一连接;local = 这只会话的写锁(= 根行锁)内、第一笔写之前(取锁 → 读认领 → 判 → 写)。
  * 返回判、不抛:拒之后一个字节不写由调用方保证(SQL 回滚,local 判在第一笔写之前)。
  */
-export declare function judgeImportWrite(root: string, read: {
+export declare function judgeSessionWrite(write: SessionWrite, read: {
     readonly claim: () => Promise<string | null | undefined>;
     readonly cell: () => Promise<ExecutionPlacementCell>;
-}): Promise<ImportWriteVerdict>;
+    readonly deleting: () => Promise<string | null>;
+}): Promise<SessionWriteJudgement>;
 /** device 车道首绑(absent → writer(device, D) 或 writer(device, ∅) → writer(device, D))的结果(设备店的事务 / 内存参照实现同调)。 */
 export type DeviceBindOutcome = {
     readonly outcome: "bound";

package/dist/execution-placement.js

@@ -94,10 +94,49 @@ export function settledMirrorOutcome(root, reading, occupant) {
         }
     }
 }
-export async function judgeImportWrite(root, read) {
+export class SessionDeletionSupersededError extends Error {
+    sessionId;
+    constructor(sessionId) {
+        super(`session ${sessionId} is no longer held by this deletion attempt (another deletion took it over, or it is already gone) — nothing was deleted by this attempt`);
+        this.sessionId = sessionId;
+        this.name = "SessionDeletionSupersededError";
+    }
+}
+export class SessionDeletingError extends Error {
+    sessionId;
+    code = "conflict.session_deleting";
+    constructor(sessionId) {
+        super(`session ${sessionId} is being deleted — this write was refused inside its transaction; nothing was written`);
+        this.sessionId = sessionId;
+        this.name = "SessionDeletingError";
+    }
+}
+export function sessionWriteTouchesCell(op) {
+    switch (op) {
+        case "import":
+            return true;
+        case "delete":
+        case "retention-delete":
+        case "erase":
+            return false;
+        default: {
+            const unknownOp = op;
+            throw new Error(`sessionWriteTouchesCell: no write ${JSON.stringify(unknownOp)}`);
+        }
+    }
+}
+export async function judgeSessionWrite(write, read) {
+    const root = write.rootSessionId;
+    const deleting = await read.deleting();
+    if (write.op === "erase")
+        return deleting === write.token ? "proceed" : { refuse: new SessionDeletionSupersededError(root) };
+    if (deleting !== null)
+        return { refuse: new SessionDeletingError(root) };
     const claim = await read.claim();
     if (claim !== null && claim !== undefined)
         return { refuse: new SessionActiveRunError(root, claim) };
+    if (!sessionWriteTouchesCell(write.op))
+        return "proceed";
     const cell = await read.cell();
     switch (cell.role) {
         case "writer":
@@ -109,7 +148,7 @@ export async function judgeImportWrite(root, read) {
             return "proceed";
         default: {
             const unknownRole = cell;
-            throw new Error(`judgeImportWrite: no arm for ${JSON.stringify(unknownRole)}`);
+            throw new Error(`judgeSessionWrite: no arm for ${JSON.stringify(unknownRole)}`);
         }
     }
 }

package/dist/field-conflict.d.ts

@@ -1,7 +1,7 @@
-/** 冲突的类(闭集)。同一个约束的几个拒点同一个词;新增一类见文件头。 */
-export declare const FIELD_CONFLICT_KINDS: readonly ["cascade_verify", "image_profile", "resume_anchor", "system_prompt_fold", "file_history_restore", "skills_disabled", "existing_session", "fork_target", "scratchpad_root", "ask_answer", "policy_person_ask", "plan_edit", "plan_mode_after", "bound_call_door", "remember_decision", "approval_feedback"];
+/** 冲突的类(闭集;拒体根上的 `reason`)。同一个约束的几个拒点同一个词;新增一类见文件头。 */
+export declare const FIELD_CONFLICT_REASONS: readonly ["cascade_verify", "image_profile", "resume_anchor", "system_prompt_fold", "file_history_restore", "skills_disabled", "existing_session", "fork_target", "scratchpad_root", "ask_answer", "policy_person_ask", "plan_edit", "plan_mode_after", "bound_call_door", "remember_decision", "approval_feedback"];
 /** 冲突的类(闭集词)。 */
-export type FieldConflictKind = (typeof FIELD_CONFLICT_KINDS)[number];
+export type FieldConflictReason = (typeof FIELD_CONFLICT_REASONS)[number];
 /**
  * 每一类允许点名的请求体坐标(铸点的 `fields` 按所属类的行检查)。键序无意义;值是该类可出现的坐标的联合。
  * 动态下标的坐标用模板字面量型(`agents[1].skills`)。
@@ -29,17 +29,13 @@ export interface FieldConflictMeasure {
     readonly count: number;
     readonly cap: number;
 }
-/** 拒体上的 `detail`。 */
-export type FieldConflictDetail<K extends FieldConflictKind = FieldConflictKind> = {
-    readonly kind: K;
+/** 一处冲突的机读位(原样摊在拒体根上:`sendError` 的 extra / `HttpError.extra` / `refusalBody` 的 facts;型别名而不是接口 —— 要能直接当 `Record<string, unknown>` 用)。 */
+export type FieldConflictFacts<K extends FieldConflictReason = FieldConflictReason> = {
+    readonly reason: K;
     readonly fields: readonly FieldConflictCoordinates[K][];
 } & Partial<FieldConflictMeasure>;
-/** 一处冲突的机读位(原样进拒体:`sendError` 的 extra / `HttpError.extra` / 手拼体的展开;型别名而不是接口 —— 要能直接当 `Record<string, unknown>` 用)。 */
-export type FieldConflictFacts<K extends FieldConflictKind = FieldConflictKind> = {
-    readonly detail: FieldConflictDetail<K>;
-};
 /**
  * 铸一处冲突的机读位。`fields` 至少一个坐标、主语在前;`measure` 只有折叠上限那一类给。
  */
-export declare function fieldConflictFacts<K extends FieldConflictKind>(kind: K, fields: readonly [FieldConflictCoordinates[K], ...FieldConflictCoordinates[K][]], measure?: FieldConflictMeasure): FieldConflictFacts<K>;
+export declare function fieldConflictFacts<K extends FieldConflictReason>(reason: K, fields: readonly [FieldConflictCoordinates[K], ...FieldConflictCoordinates[K][]], measure?: FieldConflictMeasure): FieldConflictFacts<K>;
 //# sourceMappingURL=field-conflict.d.ts.map

package/dist/field-conflict.js

@@ -1,4 +1,4 @@
-export const FIELD_CONFLICT_KINDS = [
+export const FIELD_CONFLICT_REASONS = [
     "cascade_verify",
     "image_profile",
     "resume_anchor",
@@ -16,7 +16,7 @@ export const FIELD_CONFLICT_KINDS = [
     "remember_decision",
     "approval_feedback",
 ];
-export function fieldConflictFacts(kind, fields, measure) {
-    return { detail: { kind, fields: [...fields], ...(measure === undefined ? {} : { count: measure.count, cap: measure.cap }) } };
+export function fieldConflictFacts(reason, fields, measure) {
+    return { reason, fields: [...fields], ...(measure === undefined ? {} : { count: measure.count, cap: measure.cap }) };
 }
 //# sourceMappingURL=field-conflict.js.map

package/dist/file-history-capture.d.ts

@@ -12,7 +12,7 @@
  *
  * ## 两件事,两个单点
  *  · 「这台部署有没有文件历史店」只在 {@link assembleFileHistory} 判一次(后端在即在,**与旋钮无关**),产出两张脸:
- *    **店** `store` 喂 core 的 `RunnerDeps.fileHistoryStore`(还原族)、rewind 族能力位(`rewindFiles` / `restoreFiles` /
+ *    **店** `store` 喂 core 的 `RunnerDeps.fileHistoryStore`(还原族)、rewind 族能力位(`restoreFiles` /
  *    `rewindFilesTo` / `sessionSync`)与 2c sync 路由族;**擦除脸** `erasure` = 店的**只有删除类动词**的收窄视图,喂 E21 在线删除
  *    (`boot/session-faces.ts`)与孤儿 blob GC(`boot/reapers.ts`)。旋钮从不管擦除:关掉捕获的部署照样要能删掉已捕获的文件字节。
  *  · 「捕不捕」只在 {@link fileHistoryCaptureOf} 判一次(纯函数,输入 = 店在不在 + 旋钮)。两个消费点喂它同一组输入:
@@ -58,8 +58,8 @@ export declare function assembleFileHistory(backend: StoreBackend | undefined):
  * 「捕不捕」的**唯一**判定(纯函数):能力词。`store` = 装配出来的店(在不在),`knob` = 部署旋钮 `FILE_HISTORY_CAPTURE`
  * (`config.fileHistoryCapture`)。从**装配结果**派生,不照旋钮字面回声:后端本来就没有这只店的部署同样是 `off`。
  *
- * 与 `rewindFiles` 分叉([ref] 当时写下的分叉条件,自本版成真):本词答「这台部署捕不捕、能不能按 run 关掉」,
- * `rewindFiles` 答「这台部署能不能还原」—— 旋钮关的部署本词 `off` 而 `rewindFiles` 仍为真。
+ * 与 `restoreFiles` 分叉([ref] 当时写下的分叉条件,自 [ref] 成真):本词答「这台部署捕不捕、能不能按 run 关掉」,
+ * `restoreFiles` 答「这台部署能不能还原」—— 旋钮关的部署本词 `off` 而 `restoreFiles` 仍为真。
  */
 export declare function fileHistoryCaptureOf(store: object | undefined, knob: boolean): FileHistoryCapture;
 /**

package/dist/file-history-disclosure.js

@@ -49,6 +49,7 @@ function faultOfClass(cls) {
         case "deployment":
             return { permanence: "terminal" };
         case "corrupt":
+        case "defect":
         case "unclassified":
             return {};
         default: {