@sema-agent/server 7.147.0 → 7.149.0

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":
@@ -349,14 +327,28 @@ export function buildLaneHomeBootNote(deployment) {
         return { event: LANE_HOME_UNDECLARED_EVENT, note: buildHomeAbsentNote(homeLane, "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(homeLane, home) };
 }
+export function buildReadDenyFloorSentence(lane, outcome) {
+    const env = `the execution environment (REMOTE_EXEC=${lane}) does not keep the read-deny byte floor`;
+    switch (outcome) {
+        case "ran":
+            return (`This run's read-deny rules are not byte-enforced: ${env} — a path a rule refuses is refused when a command names it, ` +
+                `but a program a command runs can still open it (a recursive read under a directory reads the files below it, denied ones included), ` +
+                `and their bytes can reach the conversation. READ_DENY_FLOOR_REQUIRED is not set, so the run went ahead; set READ_DENY_FLOOR_REQUIRED=true to refuse such runs instead.`);
+        case "refused":
+            return (`READ_DENY_FLOOR_REQUIRED=true, and ${env} (a program a command runs could open a path a read-deny rule refuses): ` +
+                `a run with read-deny rules is refused before any command starts (config.read_deny_floor_unkept; a synchronous submit answers 409). ` +
+                `Run on an execution environment that keeps the floor, or unset READ_DENY_FLOOR_REQUIRED to let such runs go ahead with a notice.`);
+        default: {
+            const unhandled = outcome;
+            throw new Error(`unhandled read-deny floor outcome: ${String(unhandled)}`);
+        }
+    }
+}
 export function buildReadDenyFloorUnkeptNote(deployment) {
     if (!deployment.readDenyFloorRequired)
         return undefined;
     if (capabilitiesFor(deployment)?.keepsReadFloor === true)
         return undefined;
-    return (`READ_DENY_FLOOR_REQUIRED=true, but the "${deployment.remoteExec.provider}" 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.`);
+    return buildReadDenyFloorSentence(deployment.remoteExec.provider, "refused");
 }
 //# sourceMappingURL=execution-lane-caps.js.map

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: {

package/dist/fleet/fleet-bus.d.ts

@@ -47,6 +47,19 @@ export interface FleetTaskRow {
      *  改写成同一串;出生点校验过的字符集里也没有可脱敏的形。残余(已披露)= 有人把真凭据当队友名写进
      *  `Agent({name})`,那一串原样上 fleet 面。展示名 `name` 照旧脱敏。 */
     agentName?: string;
+    /** 这一行**跑在哪个模型上** —— core `BackgroundChildEvent.model`(spawn / tick 帧述它)**逐字**过境:引擎在 spawn 判定点解析出的
+     *  模型(per-call / agent 定义 / 继承;能解析到服务目录的就是服务那个目录 id)。它**不是**同一子代 `task_progress.model`
+     *  (那条腿自己 prepare 出的 id)—— 后者才是权威读数,本键是行级便利位:父 run 的活流结束后只剩 fleet 行的消费端,
+     *  从这里读得到,不必另存一份副本(一个事实一个源)。
+     *  🔴 **缺席是事实,不是缺口**:引擎没述(委派链上没有任何一处点名模型 ⇒ 子代跑 `subagent` 角色、具体 id 到它自己 prepare 才定;
+     *  留存账本的唤醒腿帧不带;老引擎)⇒ 键**不发** —— 不铸、不回落(不拿别处读到的值顶,空串也不补;**空串视同没述**)。
+     *  🔴 **一个事实一个源 = 帧本身 + 总线的 MERGE 底座**,发布方不私存副本:start 与 tick 帧述它;terminal 帧本身不述(core 7.66.0),
+     *  finish 行带的是总线上这一行**已有**的值 —— 与 `name` / `agentType` 同一个底座,所以行已离场之后才到的终态帧(陈述级退场后)是稀疏底座,
+     *  三者同缺席。复活(同 id 再 spawn)是新的一代:行已随终态离场,新一代的值只来自这一代引擎说过的话。前代迟到的 tick 被总线的判代闸
+     *  整帧丢掉,连同它带的 `model`。
+     *  未署名行(无 `sessionId`)在 `?session=` 降权投影里被擦(别的会话的子代跑什么模型 = 会话内容,与 `agentType` 同判)。
+     *  ADDITIVE / tolerate-absent。 */
+    model?: string;
     /** Owning principal (= the run's scope). The `/v1/fleet/stream` route filters to the caller's scope (owner-gated)
      *  unless the caller is fleet-wide (operator / trace-token). NOT rendered — a tenant-isolation field. */
     scope?: string;
@@ -134,8 +147,10 @@ export interface FleetTaskRow {
      *    (`${runId} ${childTaskId}`)。此形只在**没有 BCE 真行**的前台 delegation 上保留(同步腿委派的
      *    子代不过 background-child registry ⇒ 不让位就没有行);tick 点名的是 BCE 真行(后台子代的 tick 带它的行 id;workflow agent 的
      *    tick 带会话 id、经让位登记簿换成行 id),本车道**让位不铸**(双生行退役)。
-     *  消费端读法:带 `sourceLane:"run-leg"` 的行是过渡形,与 a\* 行**不会**同时描述同一个 agent;不需要再
-     *  自己发明「复合 id 首段==parentId 且撞 (parentId,name)」那类集合级判据(cli 侧的防御税)。
+     *  🔴 **这是契约形,不是过渡形**:引擎的契约是前台(同步)委派的子代 —— plain 与 fork 两腿 —— 不登 background-child registry、
+     *  没有 BCE 帧,它在舰队上的身份就是宿主由 `task_progress` 派生的这一行(`taskId` = 子会话 id)。一个子代恰一个行写者,由 id 形决定:
+     *  带 `sourceLane:"run-leg"` 的行与 a\* 行**不会**同时描述同一个 agent(偏离记录:引擎加「前台 → 后台移交」动词那一天,前台子代改登 registry 行,
+     *  本车道随之退役)。消费端不需要再自己发明「复合 id 首段==parentId 且撞 (parentId,name)」那类集合级判据(cli 侧的防御税)。
      *  ADDITIVE / tolerate-absent。 */
     sourceLane?: "run-leg";
     /**
@@ -713,7 +728,10 @@ export declare function fleetRunResiduals(result: {
         toolCalls?: number;
         costMicroUsd?: number;
     };
-} | null | undefined): FleetRunResiduals;
+} | null | undefined, 
+/** 这条 run 的失败码 —— 调用方手上的那一份:run 行喂入的 = 行的码列(`RunRecord.errorCode`,唯一读法;收割 / 判决行的 `result` 是空的,码只在列上),
+ *  活结果喂入的 = `failureCodeOf(result.terminal)`。本函数不再从 blob 读码。 */
+errorCode: string | null | undefined): FleetRunResiduals;
 /**
  * [ref]-B (core 1.240.0) — the PROCESS-LEVEL background-child fleet publisher, wired once
  * onto `RunnerDeps.onBackgroundChildEvent`. Unlike {@link fleetRunPublisher} (per-leg: dies at leg settle —

package/dist/fleet/fleet-bus.js

@@ -1,6 +1,5 @@
 import { EventEmitter } from "node:events";
 import { DURABLE_AGENT_HANDLE_RE, deriveAgentDisplayStatus, runParkedOf } from "@sema-agent/core";
-import { persistedPlaneOf } from "../terminal.js";
 import { takeWorkspaceSnapshotFailure } from "./workspace-snapshot-residual.js";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { redactSecrets } from "../trace/redact.js";
@@ -280,6 +279,30 @@ export function fleetRunPublisher(bus, run) {
             return u.totalTokens;
         return (u.totalInputTokens ?? 0) + (u.outputTokens ?? 0);
     };
+    const mintRunLegRow = (taskId, ev, parentId) => {
+        const cid = childId(taskId);
+        if (yieldToBackgroundChildLane(taskId, cid, ev.name))
+            return;
+        children.add(cid);
+        const childName = ev.name !== undefined ? redactSecrets(ev.name) : undefined;
+        if (!childStartedAt.has(cid))
+            childStartedAt.set(cid, Date.now());
+        const toolUses = toolUsesOf(ev.usage);
+        bus.publishTask({
+            id: cid,
+            sourceLane: "run-leg",
+            ...(childName !== undefined ? { name: childName, agentType: childName } : {}),
+            parentId,
+            scope: run.scope,
+            ...sessionField,
+            ...workflowRunIdField(ev),
+            status: tickStatus(ev.status),
+            tokens: sumTokens(ev.usage),
+            ...(typeof ev.seq === "number" ? { cycleSeq: ev.seq } : {}),
+            ...(toolUses !== undefined ? { toolUses } : {}),
+            elapsedMs: Date.now() - childStartedAt.get(cid),
+        });
+    };
     return {
         onStart() {
             bus.publishTask({ id: run.runId, ...(run.name !== undefined ? { name: run.name } : {}), ...(run.description ? { description: run.description } : {}), scope: run.scope, ...sessionField, status: "running", tokens: 0, elapsedMs: 0 });
@@ -299,14 +322,7 @@ export function fleetRunPublisher(bus, run) {
                 bus.publishTask({ id: run.runId, tokens, elapsedMs: Date.now() - startedAt });
             }
             else if (ev.type === "task_progress" && ev.taskId) {
-                const cid = childId(ev.taskId);
-                if (yieldToBackgroundChildLane(ev.taskId, cid, ev.name))
-                    return;
-                children.add(cid);
-                const childName = ev.name !== undefined ? redactSecrets(ev.name) : undefined;
-                if (!childStartedAt.has(cid))
-                    childStartedAt.set(cid, Date.now());
-                bus.publishTask({ id: cid, sourceLane: "run-leg", ...(childName !== undefined ? { name: childName, agentType: childName } : {}), parentId: run.runId, scope: run.scope, ...sessionField, ...workflowRunIdField(ev), status: tickStatus(ev.status), tokens: sumTokens(ev.usage), ...(typeof ev.seq === "number" ? { cycleSeq: ev.seq } : {}), ...(() => { const t = toolUsesOf(ev.usage); return t !== undefined ? { toolUses: t } : {}; })(), elapsedMs: Date.now() - childStartedAt.get(cid) });
+                mintRunLegRow(ev.taskId, ev, run.runId);
             }
             else if (ev.type === "tool_start" && ev.toolName) {
                 bus.publishTask({ id: run.runId, description: ev.toolName });
@@ -317,15 +333,7 @@ export function fleetRunPublisher(bus, run) {
                 return;
             if (ev.type !== "task_progress" || !ev.taskId)
                 return;
-            const cid = childId(ev.taskId);
-            if (yieldToBackgroundChildLane(ev.taskId, cid, ev.name))
-                return;
-            children.add(cid);
-            const parentId = ev.parentTaskId && ev.parentTaskId !== run.rootTaskId ? (backgroundRowOf(ev.parentTaskId) ?? childId(ev.parentTaskId)) : run.runId;
-            const fwdName = ev.name !== undefined ? redactSecrets(ev.name) : undefined;
-            if (!childStartedAt.has(cid))
-                childStartedAt.set(cid, Date.now());
-            bus.publishTask({ id: cid, sourceLane: "run-leg", ...(fwdName !== undefined ? { name: fwdName, agentType: fwdName } : {}), parentId, scope: run.scope, ...sessionField, ...workflowRunIdField(ev), status: tickStatus(ev.status), tokens: sumTokens(ev.usage), ...(typeof ev.seq === "number" ? { cycleSeq: ev.seq } : {}), ...(() => { const t = toolUsesOf(ev.usage); return t !== undefined ? { toolUses: t } : {}; })(), elapsedMs: Date.now() - childStartedAt.get(cid) });
+            mintRunLegRow(ev.taskId, ev, ev.parentTaskId && ev.parentTaskId !== run.rootTaskId ? (backgroundRowOf(ev.parentTaskId) ?? childId(ev.parentTaskId)) : run.runId);
         },
         onTerminal(status, residuals) {
             settledLeg = true;
@@ -350,9 +358,10 @@ export function fleetRunPublisher(bus, run) {
         },
     };
 }
-export function fleetRunResiduals(result) {
+export function fleetRunResiduals(result, errorCode) {
+    const stoppedBy = errorCode === "cancelled" ? { stoppedBy: "user" } : {};
     if (!result)
-        return {};
+        return stoppedBy;
     const s = result.stats;
     const usage = s
         ? {
@@ -364,7 +373,7 @@ export function fleetRunResiduals(result) {
         : {};
     return {
         ...(Object.keys(usage).length > 0 ? { usage } : {}),
-        ...(persistedPlaneOf(result).errorCode === "cancelled" ? { stoppedBy: "user" } : {}),
+        ...stoppedBy,
         ...(result.sessionId ? { transcriptId: result.sessionId } : {}),
         ...(takeWorkspaceSnapshotFailure(result.sessionId) ? { workspaceSnapshot: "failed" } : {}),
     };
@@ -426,7 +435,7 @@ export function fleetBackgroundChildPublisher(bus, log) {
         }
         return match !== undefined ? { id: match, resolved: true } : { id: parentInput, resolved: false };
     };
-    const rowTags = (m) => {
+    const rowTags = (m, e) => {
         let parentId;
         const parentInput = m.parentTaskId ?? m.parentSessionLink;
         if (parentInput) {
@@ -447,6 +456,7 @@ export function fleetBackgroundChildPublisher(bus, log) {
             ...(parentId !== undefined ? { parentId } : {}),
             ...(m.workflowRunId !== undefined ? { workflowRunId: m.workflowRunId } : {}),
             ...(m.parentToolCallId !== undefined ? { parentToolCallId: m.parentToolCallId } : {}),
+            ...(e.model ? { model: e.model } : {}),
             ...(m.spawnedAt !== undefined ? { startedAt: m.spawnedAt, elapsedMs: Date.now() - m.spawnedAt } : {}),
         };
     };
@@ -485,7 +495,7 @@ export function fleetBackgroundChildPublisher(bus, log) {
         remember(e.taskId, m);
         joinWorkflowAgentNames(e, m);
         const displayName = e.description ?? e.name;
-        bus.publishTask({ id: e.taskId, ...(displayName !== undefined ? { name: redactSecrets(displayName) } : {}), ...(e.agentType ? { agentType: redactSecrets(e.agentType) } : {}), ...(e.spawnName ? { agentName: e.spawnName } : {}), ...rowTags(m), status: "running", tokens: 0, ...(typeof e.seq === "number" ? { cycleSeq: e.seq } : {}), ...(e.transcriptId ? { transcriptId: e.transcriptId } : {}) });
+        bus.publishTask({ id: e.taskId, ...(displayName !== undefined ? { name: redactSecrets(displayName) } : {}), ...(e.agentType ? { agentType: redactSecrets(e.agentType) } : {}), ...(e.spawnName ? { agentName: e.spawnName } : {}), ...rowTags(m, e), status: "running", tokens: 0, ...(typeof e.seq === "number" ? { cycleSeq: e.seq } : {}), ...(e.transcriptId ? { transcriptId: e.transcriptId } : {}) });
         dlog("bg_child_event", { kind: "spawn", taskId: e.taskId, sessionScoped: e.sessionScoped, scope: m.tenantScope, hostSessionId: m.hostSessionId ?? null, parentTaskId: m.parentTaskId ?? null });
     };
     const handleTick = (e, m) => {
@@ -498,12 +508,12 @@ export function fleetBackgroundChildPublisher(bus, log) {
         const currentTool = e.currentTool
             ? { toolName: e.currentTool.toolName, ...(e.currentTool.target !== undefined ? { target: redactSecrets(e.currentTool.target).slice(0, 300) } : {}) }
             : undefined;
-        bus.publishTask({ id: e.taskId, ...rowTags(m), status: "running", ...(tokens !== undefined ? { tokens } : {}), ...(name ? { name } : {}), ...(agentType ? { agentType } : {}), ...(agentName ? { agentName } : {}), ...(currentAction ? { currentAction } : {}), ...(currentTool ? { currentTool } : {}), ...(typeof e.seq === "number" ? { cycleSeq: e.seq } : {}), ...(e.usage?.toolUses !== undefined ? { toolUses: e.usage.toolUses } : {}), ...(e.transcriptId ? { transcriptId: e.transcriptId } : {}) });
+        bus.publishTask({ id: e.taskId, ...rowTags(m, e), status: "running", ...(tokens !== undefined ? { tokens } : {}), ...(name ? { name } : {}), ...(agentType ? { agentType } : {}), ...(agentName ? { agentName } : {}), ...(currentAction ? { currentAction } : {}), ...(currentTool ? { currentTool } : {}), ...(typeof e.seq === "number" ? { cycleSeq: e.seq } : {}), ...(e.usage?.toolUses !== undefined ? { toolUses: e.usage.toolUses } : {}), ...(e.transcriptId ? { transcriptId: e.transcriptId } : {}) });
     };
     const handleTerminal = (e, m) => {
         const status = e.status === "completed" ? "completed" : e.status === "killed" ? "killed" : "failed";
         bus.publishTask({
-            id: e.taskId, ...rowTags(m), status,
+            id: e.taskId, ...rowTags(m, e), status,
             ...(e.spawnName ? { agentName: e.spawnName } : {}),
             ...(typeof e.seq === "number" ? { cycleSeq: e.seq } : {}),
             ...(e.stoppedBy ? { stoppedBy: e.stoppedBy } : {}),

package/dist/fleet/fleet-reconciler.js

@@ -48,7 +48,7 @@ export function createFleetReconciler(deps) {
     const upgradeWatched = (id, w, rec, trigger) => {
         if (!watch.delete(id))
             return false;
-        deps.bus.publishTask({ ...w.row, status: runStatusToFleet(rec.status), retiredBy: "reconcile", ...fleetRunResiduals(rec.result) });
+        deps.bus.publishTask({ ...w.row, status: runStatusToFleet(rec.status), retiredBy: "reconcile", ...fleetRunResiduals(rec.result, rec.errorCode) });
         deps.bus.removeTask(id, { ...(w.row.cycleSeq !== undefined ? { cycleSeq: w.row.cycleSeq } : {}) });
         lastFrameAt.delete(id);
         deps.metrics?.inc("fleet_rows_reconciled_total", { disposition: "retired_deferred", trigger });
@@ -159,7 +159,7 @@ export function createFleetReconciler(deps) {
                 id: row.id,
                 status: runStatusToFleet(rec.status),
                 retiredBy: "reconcile",
-                ...fleetRunResiduals(rec.result),
+                ...fleetRunResiduals(rec.result, rec.errorCode),
             });
             parentsOnBus.delete(row.id);
             deps.bus.removeTask(row.id, { ...(row.cycleSeq !== undefined ? { cycleSeq: row.cycleSeq } : {}) });

package/dist/fleet/serving-lease.js

@@ -5,6 +5,7 @@ import { SERVING_LEASE_TTL_DEFAULT_MS, readServingLeaseResponse } from "@sema-ag
 import { centerFetch } from "../web-admin-client/center-request.js";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { leaseDrainActionId } from "./drain-entry.js";
+import { readUpstreamJson } from "../upstream-body.js";
 export const SERVING_LEASE_FETCH_TIMEOUT_MS = 5_000;
 export const SERVING_LEASE_DENIED_FILE = "fleet-serving-lease-denied.json";
 const RENEW_MIN_INTERVAL_MS = 1_000;
@@ -38,7 +39,6 @@ function denialLeadOf(d) {
 export function createServingLeaseClient(o) {
     const mono = o.clock?.mono ?? (() => performance.now());
     const epoch = o.clock?.epoch ?? Date.now;
-    const f = o.fetchImpl ?? fetch;
     const stickyPath = o.dataRoot === undefined ? undefined : join(o.dataRoot, SERVING_LEASE_DENIED_FILE);
     let capability;
     const enabled = () => capability?.announced === true;
@@ -104,9 +104,9 @@ export function createServingLeaseClient(o) {
         let reading;
         let why = "";
         try {
-            const { res } = await centerFetch(o.center, { kind: "fleet-serving-lease" }, { method: "POST", json: request, timeoutMs: SERVING_LEASE_FETCH_TIMEOUT_MS, fetchImpl: f });
+            const { res } = await centerFetch(o.center, { kind: "fleet-serving-lease" }, { method: "POST", json: request, timeoutMs: SERVING_LEASE_FETCH_TIMEOUT_MS, fetchImpl: o.fetchImpl });
             if (res.ok) {
-                reading = readServingLeaseResponse(await res.json().catch(() => undefined));
+                reading = readServingLeaseResponse(await readUpstreamJson(res).catch(() => undefined));
                 if (reading === undefined)
                     why = "reply is not a serving-lease verdict";
             }