@sema-agent/server 7.138.0 → 7.140.0

package/dist/execution-placement.js

@@ -0,0 +1,199 @@
+import { sessionRowMatches } from "@sema-agent/core";
+export 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 function isUnusableArchive(x) {
+    return x !== undefined && x.state === "unusable";
+}
+export function executionPlacementView(cell) {
+    switch (cell.role) {
+        case "absent":
+            return { role: "absent" };
+        case "writer":
+            return cell.device === undefined ? { role: "writer", lane: cell.lane } : { role: "writer", lane: cell.lane, device: { deviceId: cell.device.id, rev: cell.device.rev } };
+        case "mirror":
+            return { role: "mirror" };
+        case "forking":
+            return { role: "forking" };
+        default: {
+            const unknownRole = cell;
+            throw new Error(`executionPlacementView: no projection for ${JSON.stringify(unknownRole)}`);
+        }
+    }
+}
+export function sameOccupant(a, b) {
+    return sessionRowMatches({ row: { owner: a.owner ?? null, incarnation: a.incarnation } }, b, noLogMark);
+}
+function noLogMark() {
+    throw new Error("sameOccupant: an occupant check carries no log mark, yet the judge asked for one");
+}
+export class SessionWriterPresentError extends Error {
+    sessionId;
+    lane;
+    code = "conflict.session_writer";
+    constructor(sessionId, lane) {
+        super(`session ${sessionId} is written here on the ${lane} lane — an import cannot turn it into a mirror; nothing was written`);
+        this.sessionId = sessionId;
+        this.lane = lane;
+        this.name = "SessionWriterPresentError";
+    }
+}
+export class SessionForkInProgressError extends Error {
+    sessionId;
+    code = "conflict.fork_in_progress";
+    constructor(sessionId) {
+        super(`session ${sessionId} is the target of a fork that has not finished copying — retry that fork with the same key, or delete the session`);
+        this.sessionId = sessionId;
+        this.name = "SessionForkInProgressError";
+    }
+}
+export class SessionActiveRunError extends Error {
+    sessionId;
+    activeTaskId;
+    constructor(sessionId, activeTaskId) {
+        super(`session ${sessionId} has an active run (${activeTaskId}) — this write was refused inside its transaction; nothing was written`);
+        this.sessionId = sessionId;
+        this.activeTaskId = activeTaskId;
+        this.name = "SessionActiveRunError";
+    }
+}
+export const WRITABLE = "writable";
+export function settledPlaceOutcome(root, reading, occupant, wanted) {
+    if (reading === undefined || !sameOccupant(reading.occupant, occupant))
+        return { outcome: "gone" };
+    const cell = reading.cell;
+    switch (cell.role) {
+        case "absent":
+            return WRITABLE;
+        case "writer":
+            return cell.lane === wanted.lane ? { outcome: "same" } : { outcome: "tree_bound", boundLane: cell.lane };
+        case "mirror":
+            return { outcome: "mirror" };
+        case "forking":
+            throw new SessionForkInProgressError(root);
+        default: {
+            const unknownRole = cell;
+            throw new Error(`settledPlaceOutcome: no arm for ${JSON.stringify(unknownRole)}`);
+        }
+    }
+}
+export function settledMirrorOutcome(root, reading, occupant) {
+    if (reading === undefined || !sameOccupant(reading.occupant, occupant))
+        return { outcome: "gone" };
+    const cell = reading.cell;
+    switch (cell.role) {
+        case "absent":
+            return WRITABLE;
+        case "writer":
+            return { outcome: "writer" };
+        case "mirror":
+            return { outcome: "mirrored" };
+        case "forking":
+            throw new SessionForkInProgressError(root);
+        default: {
+            const unknownRole = cell;
+            throw new Error(`settledMirrorOutcome: no arm for ${JSON.stringify(unknownRole)}`);
+        }
+    }
+}
+export function settledDeviceBindOutcome(root, reading, occupant, deviceId) {
+    if (reading === undefined || !sameOccupant(reading.occupant, occupant))
+        return { outcome: "gone" };
+    const cell = reading.cell;
+    switch (cell.role) {
+        case "absent":
+            return WRITABLE;
+        case "writer":
+            if (cell.lane !== "device")
+                return { outcome: "tree_bound", boundLane: cell.lane };
+            if (cell.device === undefined)
+                return WRITABLE;
+            return cell.device.id === deviceId ? { outcome: "same", device: cell.device } : { outcome: "device_conflict", device: cell.device };
+        case "mirror":
+            return { outcome: "mirror" };
+        case "forking":
+            throw new SessionForkInProgressError(root);
+        default: {
+            const unknownRole = cell;
+            throw new Error(`settledDeviceBindOutcome: no arm for ${JSON.stringify(unknownRole)}`);
+        }
+    }
+}
+export function settledDeviceRebindOutcome(reading, occupant, owner, expectedRev, targetDeviceId) {
+    if (reading === undefined || !sameOccupant(reading.occupant, occupant))
+        return { outcome: "gone" };
+    const device = boundDeviceOf(reading.cell);
+    if (device === undefined)
+        return { outcome: "gone" };
+    if (device.owner.tenant !== owner.tenant || device.owner.subject !== owner.subject)
+        return { outcome: "gone" };
+    if (device.rev !== expectedRev)
+        return { outcome: "rev_conflict", device };
+    return device.id === targetDeviceId ? { outcome: "idempotent", device } : WRITABLE;
+}
+export function boundDeviceOf(cell) {
+    switch (cell.role) {
+        case "writer":
+            return cell.lane === "device" ? cell.device : undefined;
+        case "absent":
+        case "mirror":
+        case "forking":
+            return undefined;
+        default: {
+            const unknownRole = cell;
+            throw new Error(`boundDeviceOf: no arm for ${JSON.stringify(unknownRole)}`);
+        }
+    }
+}
+export function assertPlaceableLane(root, cell) {
+    if (cell.lane === "device" || cell.device !== undefined) {
+        throw new Error(`execution placement of session ${root}: the device lane is placed by the device store (it judges the device row in the same transaction), not by the session store's seat`);
+    }
+}
+export class InMemoryExecutionPlacementSeat {
+    rows = new Map();
+    seatRow(root, occupant) {
+        if (!this.rows.has(root))
+            this.rows.set(root, { occupant, cell: { role: "absent" } });
+    }
+    dropRow(root) {
+        this.rows.delete(root);
+    }
+    async read(root) {
+        return this.rows.get(root);
+    }
+    async place(root, occupant, cell) {
+        assertPlaceableLane(root, cell);
+        const settled = settledPlaceOutcome(root, this.rows.get(root), occupant, cell);
+        if (settled !== WRITABLE)
+            return settled;
+        this.rows.set(root, { occupant, cell: { role: "writer", lane: cell.lane } });
+        return { outcome: "placed" };
+    }
+    async markMirror(root, occupant) {
+        const settled = settledMirrorOutcome(root, this.rows.get(root), occupant);
+        if (settled !== WRITABLE)
+            return settled;
+        this.rows.set(root, { occupant, cell: { role: "mirror" } });
+        return { outcome: "mirrored" };
+    }
+    bindDevice(root, occupant, device, placedAt) {
+        const settled = settledDeviceBindOutcome(root, this.rows.get(root), occupant, device.id);
+        if (settled !== WRITABLE)
+            return settled;
+        const placed = { id: device.id, owner: device.owner, rev: 0, placedAt };
+        this.rows.set(root, { occupant, cell: { role: "writer", lane: "device", device: placed } });
+        return { outcome: "bound", device: placed };
+    }
+    rebindDevice(root, occupant, owner, expectedRev, targetDeviceId, placedAt) {
+        const row = this.rows.get(root);
+        const settled = settledDeviceRebindOutcome(row, occupant, owner, expectedRev, targetDeviceId);
+        if (settled !== WRITABLE)
+            return settled;
+        const from = row !== undefined ? boundDeviceOf(row.cell)?.id : undefined;
+        if (from === undefined)
+            throw new Error(`execution placement of session ${root}: the rebind judge found a device cell that is no longer there — refusing to guess`);
+        const placed = { id: targetDeviceId, owner, rev: expectedRev + 1, placedAt };
+        this.rows.set(root, { occupant, cell: { role: "writer", lane: "device", device: placed } });
+        return { outcome: "rebound", device: placed, from };
+    }
+}
+//# sourceMappingURL=execution-placement.js.map

package/dist/field-conflict.d.ts

@@ -1,5 +1,5 @@
 /** 冲突的类(闭集)。同一个约束的几个拒点同一个词;新增一类见文件头。 */
-export declare const FIELD_CONFLICT_KINDS: readonly ["cascade_verify", "image_profile", "resume_anchor", "system_prompt_fold", "file_history_restore", "skills_disabled", "existing_session", "scratchpad_root", "ask_answer", "policy_person_ask", "plan_edit", "plan_mode_after", "bound_call_door", "remember_decision", "approval_feedback"];
+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"];
 /** 冲突的类(闭集词)。 */
 export type FieldConflictKind = (typeof FIELD_CONFLICT_KINDS)[number];
 /**
@@ -11,9 +11,10 @@ export interface FieldConflictCoordinates {
     readonly image_profile: "capabilitiesNeeded" | "sandboxImageProfile";
     readonly resume_anchor: "resumeAtMode" | "resumeAt";
     readonly system_prompt_fold: "appendSystemPrompt" | "settings.outputStyle";
-    readonly file_history_restore: "fileHistory" | "restoreFiles" | "rewindFilesTo" | "rewindFiles";
+    readonly file_history_restore: "fileHistory" | "restoreFiles" | "rewindFilesTo";
     readonly skills_disabled: "disableSkills" | "skills" | `agents[${number}].skills`;
     readonly existing_session: "requireExistingSession" | "sessionId";
+    readonly fork_target: "forkId" | "forkNonce";
     readonly scratchpad_root: "cwd" | "scratchpadDir";
     readonly ask_answer: "decision" | "answer";
     readonly policy_person_ask: "decision" | "decidedBy";

package/dist/field-conflict.js

@@ -6,6 +6,7 @@ export const FIELD_CONFLICT_KINDS = [
     "file_history_restore",
     "skills_disabled",
     "existing_session",
+    "fork_target",
     "scratchpad_root",
     "ask_answer",
     "policy_person_ask",

package/dist/hosted-posture.d.ts

@@ -17,7 +17,7 @@
  *       `multiTenant` 的反面 ⇒ 采纳,否则忽略(**不看车道**,任何 `REMOTE_EXEC` 都一样);
  *     · `additionalDirectories` / `additionalReadDirectories` —— 表行 `callerOwnsWorkerDisk`(手在本 worker 盘上 ∧ 单主 = 今天只有 host);
  *     · `settings.env` / `cwd` —— 表行 `callerCwd`(读能力表 `callerCwd` 位:host 单主才开,**device 不读租户**:那条路径落在
- *       **发起者自己的设备**上,归属由 `device_session` 绑定行验过 ⇒ 跨租户面结构性不存在)。
+ *       **发起者自己的设备**上,归属由根会话行执行格上的设备绑定验过 ⇒ 跨租户面结构性不存在)。
  *
  * ⇒ 先把这个判定位铸成**一处**,再让各条腿都读它(clay 裁定③,2026-09-22):**不许各自加特判**——
  * 每加一条特判,「这台机器算不算托管」在本仓就多一个可以自己漂的答案。
@@ -106,7 +106,7 @@ export declare const HOST_POSTURE_REFUSED_CODE = "request.host_posture_refused";
  * [ref] 前还有腿③(`approverPosture`,忽略 + 留声),随那个请求键一起退役。射程只铸在这一处,同族声明读同一只。
  *
  * 🔴 **device 车道不适用(clay 裁定③ 2026-09-22)**:device 车道上 host 闸防的那个跨租户宿主穿越**结构性不存在**
- * (路径落在**发起者自己的设备**上,归属由 `device_session` 绑定行 + 准入链的 owner 谓词验过),叠加 clay [ref]
+ * (路径落在**发起者自己的设备**上,归属由根会话行执行格上的设备绑定 + 准入链的 owner 谓词验过),叠加 clay [ref]
  * 「device 零额外审批」⇒ 在那条车道上拿租户声明当判据就是**用错轴**。与 `settings.env` / `cwd` 两键在那条车道上的既有臂同源同形。
  * [ref] 起射程判据 = 部署形表行 `taskHostPostureDeclarations`(device 车道 ∨ 单主;轴列 lane + principal);下面是它读的键集(托管证据 + 车道)。
  */

package/dist/http/admission.js

@@ -1,4 +1,4 @@
-import { APPROVAL_REACH, MCP_IMAGE_MAX_BASE64, isApprovalReach, isPermissionMode, isThinkingLevel, expandTiers } from "@sema-agent/core";
+import { APPROVAL_REACH, IMAGE_ADMISSION, isApprovalReach, isPermissionMode, isThinkingLevel, expandTiers } from "@sema-agent/core";
 import { isAtMentionable, matchCatalogModel, refusedCatalogEntry, selectableCatalog } from "../model-select.js";
 import { echoModelRef, modelUnavailableMessage } from "../model-entry-refusal.js";
 import { HttpError, sessionIdShapeIssue } from "../security.js";
@@ -20,7 +20,7 @@ import { echoCallerText, quotedCallerText } from "../caller-text-echo.js";
 import { MAX_ADDITIONAL_DIRS } from "../task-cwd.js";
 import { verifyRoundsFromBody } from "./verify-rounds.js";
 import { skillCarriesRetiredManifest } from "./retired-skill-manifest.js";
-import { resolveDevicePlacementIntent } from "./device-placement.js";
+import { resolveExecutionContext, stampSpecRoot } from "./execution-context.js";
 import { callerTrust, requestTrustRefusal } from "./caller-trust.js";
 import { createRunAcceptance } from "../run-acceptance.js";
 import { sendError, sendHttpError } from "./send.js";
@@ -88,7 +88,7 @@ function userSkillShapeIssue(item, index) {
 }
 export const SKILL_MANIFEST_RETIRED = "skill.manifest was retired in core 7.41.0 — a skill's tools are its allowedTools / disallowedTools now (an allow-rule and a deny-rule source for the run the skill is activated in, never a fence); move manifest.allowTools to allowedTools. To fence tools use deny rules (settings.permissions.deny) or a delegated agent's allowTools; to fence write paths use the session rules' allowDirs";
 const MAX_IMAGES_PER_REQUEST = 20;
-const MAX_IMAGE_BASE64_BYTES = MCP_IMAGE_MAX_BASE64;
+const MAX_IMAGE_BASE64_BYTES = IMAGE_ADMISSION.hard.imageBase64Chars;
 function mentionableNames(config, catalog) {
     return Object.keys(catalog).filter((n) => n !== "default" && isAtMentionable(n, catalog, config.atMention, config.modelRefusals));
 }
@@ -433,10 +433,6 @@ export function createAdmission(ctx) {
                 return null;
             }
         }
-        if (body.rewindFiles !== undefined && typeof body.rewindFiles !== "boolean") {
-            sendError(res, 400, "request.field_invalid", "rewindFiles must be a boolean");
-            return null;
-        }
         if (body.restoreFiles !== undefined && typeof body.restoreFiles !== "boolean") {
             sendError(res, 400, "request.field_invalid", "restoreFiles must be a boolean");
             return null;
@@ -745,23 +741,16 @@ export function createAdmission(ctx) {
         const { body: admitted, entry: entryMode } = stampEntryPermissionMode(body, autonomyModeFloor(deps.config.autonomy));
         const lease = deps.peerDesk.lease("fresh");
         try {
-            const auth = deps.authorize ? await deps.authorize({ req, body: admitted }) : undefined;
+            const auth = await deps.authorize({ req, body: admitted });
+            const execution = await resolveExecutionContext(deps, { kind: "fresh", root: auth.sessionId, principal: auth.principal, judged: auth.head, req, deviceId: admitted.deviceId });
             const engineNotices = [];
-            const spec = await deps.resolveSpec(admitted, req, auth, { leg: "fresh", ...(legFacts?.liveStream === true ? { liveStream: true } : {}), onNotice: (n) => engineNotices.push(n), lease });
-            const bindingIntent = await resolveDevicePlacementIntent({
-                config: deps.config,
-                req,
-                rootSessionId: spec.sessionId,
-                deviceId: admitted.deviceId,
-                store: deps.deviceStore,
-                enrollment: deps.deviceEnrollment,
-            });
+            const spec = stampSpecRoot(await deps.resolveSpec(admitted, req, auth, { leg: "fresh", ...(legFacts?.liveStream === true ? { liveStream: true } : {}), onNotice: (n) => engineNotices.push(n), lease, execution }), execution);
             const model = modelIdOf(spec.model);
-            const acceptance = createRunAcceptance({ sessionTitler: deps.sessionTitler }, { ...(spec.sessionId ? { sessionId: spec.sessionId } : {}), objective: spec.objective, ...(model !== undefined ? { model } : {}) });
+            const acceptance = createRunAcceptance({ sessionTitler: deps.sessionTitler }, { sessionId: spec.sessionId, objective: spec.objective, ...(model !== undefined ? { model } : {}) });
             const clampNotice = buildEntryModeClampNotice(entryMode, spec.sessionId);
             const pendingNotices = clampNotice !== undefined ? [clampNotice, ...engineNotices] : engineNotices;
             const warnings = allowSelectorWarningsOf(admitted, spec.tools ?? []);
-            return { spec, runner: runnerFor(spec), auth, verify, cascade, jobId: admitted.jobId, body: admitted, acceptance, peerLease: lease, ...(bindingIntent === undefined ? {} : { bindingIntent }), ...(pendingNotices.length > 0 ? { engineNotices: pendingNotices } : {}), ...(warnings.length > 0 ? { warnings } : {}) };
+            return { spec, runner: runnerFor(spec), auth, verify, cascade, jobId: admitted.jobId, body: admitted, acceptance, peerLease: lease, execution, ...(pendingNotices.length > 0 ? { engineNotices: pendingNotices } : {}), ...(warnings.length > 0 ? { warnings } : {}) };
         }
         catch (err) {
             lease.release();

package/dist/http/checkpoint-ctx.d.ts

@@ -32,10 +32,15 @@
  * 与 7.121.x 的 `AUTONOMY=plan` 同一个结局,且没有入口地板 ⇒ 不拒)。删除条件登记在 `plugins/one-time-migrations.ts` 的 M12 行。
  *
  * ## 第四问(7.137.0):体里的退役请求键
- * 请求键退役之后(今天一只:`promptProfile` 换成布尔 `promptLean`,{@link RETIRED_REQUEST_KEYS}),新提交带它在键闭集门 400;存体里的旧键由一次性迁移在起服时原地改写
- * (M30,`stored-request-prompt-profile-m30.ts`,行改写经本模块的 {@link rewriteStoredBodyKeys})。改写不到的残留行(窗内从没起过服的部署;起服扫描之后滚动升级里
- * 旧副本才写下的行)体里仍带旧键 ⇒ 拒({@link retiredRequestKeyRefusal},码同前两只读法拒:`checkpoint.unsupported_version`)。**没有**续跑时按旧键读的第二种读法,
- * 也**没有**「旧键无人读、静默续跑」的臂:旧键还在 = 这份体没被改写过,它当年要的形本版读不出来。
+ * 请求键退役之后({@link RETIRED_REQUEST_KEYS}:今天两只 —— `promptProfile` 换成布尔 `promptLean`,`rewindFiles` 是退役的旧文件还原拼法),新提交带它在键闭集门 400。存体里的旧键怎么办,闭集里每个键有
+ * **一个处置格**,住在哪张表就是哪个处置:**拒**表({@link REPLAY_REFUSED_RETIRED_KEYS},今天 `promptProfile`)是塑形过任务本身的键,**惰性**表({@link INERT_RETIRED_KEYS},今天 `rewindFiles`)是一次性键。
+ *  · 拒表的键:存体里的旧键由一次性迁移在起服时原地改写
+ *    (M30,`stored-request-prompt-profile-m30.ts`,行改写经本模块的 {@link rewriteStoredBodyKeys})。改写不到的残留行(窗内从没起过服的部署;起服扫描之后滚动升级里
+ *    旧副本才写下的行)体里仍带旧键 ⇒ 拒({@link retiredRequestKeyRefusal},码同前两只读法拒:`checkpoint.unsupported_version`)。**没有**续跑时按旧键读的第二种读法,
+ *    也**没有**「旧键无人读、静默续跑」的臂:旧键还在 = 这份体没被改写过,它当年要的形本版读不出来。
+ *  · 惰性表的键:一次性键 —— 只在提交的那一拍起作用(文件还原的一次性动作),续跑重建里没有任何一条腿读它,存体里留着它不要求任何事、不改变重放要做的事 ⇒ 不拒、不改写、续跑照常。
+ *    这不是上面那条「旧键无人读、静默续跑」的臂:那一臂的前提是读不出旧键会让续跑做一件提交时没要的事,惰性格的判据恰是「没有这个键,重放做的事一字不差」。
+ * 加一个退役键必须选格 —— 进拒表 ⇒ {@link retiredRequestKeyRefusal} 的 switch 与 `stored-body-replay.ts` 的迁移 id 表编译红,直到给它一句拒句和改写它的迁移;进惰性表 ⇒ 改动里要写明它为什么是一次性的。
  *
  * ## 一只判据、五个问点(`http/stored-body-replay.ts` 的 `storedBodyReplayRefusal` / 本模块的 {@link storedBodyReplayAnswer})
  * 「这条停驻行的持久化体在本版上能否重放」只有**一个**读法:上面四问合在 `stored-body-replay.ts` 的 `storedBodyReplayRefusal` 一处(前两问的判据在本模块、第三问读请求设置
@@ -117,13 +122,17 @@ export declare function permissionModeReadingStated(ctx: CheckpointCtx): boolean
  */
 export declare function permissionModeReadingRefusal(): ResumeRefusalAnswer;
 /**
- * 第四问:**退役的请求键**闭集(新提交在键闭集门 400;存体里还带着它 = 这份体是更早的写者写下、一次性迁移没改写到的)。加一个 ⇒ 加一行,
- * {@link retiredRequestKeyRefusal} 的 switch 编译红直到给它一句拒句。今天一只:`promptProfile`(7.137.0 起换成布尔 `promptLean`;存体由 M30 起服改写)。
+ * 第四问:**退役的请求键**闭集 = 两张处置表之并(新提交在键闭集门 400;存体里还带着它 = 这份体是更早的写者写下的)。键住在哪张表就是它的处置格,规则全文见头注第四问。
+ * 拒表:存体仍带它 ⇒ 续跑重放拒({@link retiredRequestKeyRefusal});加一个 ⇒ 加一行,那只函数的 switch 编译红直到给它一句拒句。今天一只:`promptProfile`(7.137.0 起换成布尔 `promptLean`;存体由 M30 起服改写)。
  */
-export declare const RETIRED_REQUEST_KEYS: readonly ["promptProfile"];
+export declare const REPLAY_REFUSED_RETIRED_KEYS: readonly ["promptProfile"];
+export type ReplayRefusedRetiredKey = (typeof REPLAY_REFUSED_RETIRED_KEYS)[number];
+/** 惰性表:**一次性键**(只在提交那一拍起作用,续跑重建里没有任何一条腿读它)—— 存体里带着它不改变重放要做的事 ⇒ 不拒、不改写。今天一只:`rewindFiles`(旧的文件还原拼法;现役拼法 `restoreFiles` / `rewindFilesTo` 同为一次性动作,续跑重建整族剥掉)。 */
+export declare const INERT_RETIRED_KEYS: readonly ["rewindFiles"];
+export declare const RETIRED_REQUEST_KEYS: readonly ["promptProfile", "rewindFiles"];
 export type RetiredRequestKey = (typeof RETIRED_REQUEST_KEYS)[number];
-/** 存体顶层带的第一只退役请求键(闭集序);没有 ⇒ `undefined`。只看自有键(原型上的同名不算)。 */
-export declare function retiredRequestKeyOf(body: unknown): RetiredRequestKey | undefined;
+/** 存体顶层带的第一只**需要拒**的退役请求键(拒表序);惰性键不算,没有 ⇒ `undefined`。只看自有键(原型上的同名不算)。 */
+export declare function retiredRequestKeyOf(body: unknown): ReplayRefusedRetiredKey | undefined;
 /**
  * 第四问的拒答复 —— 码与落点同另两只读法拒(`checkpoint.unsupported_version`,409;卡仍 pending 时的 `retriable:true` 由 {@link resumeRefusalWithCard} 追加,本铸点不带)。
  * 句子说键、它换成了什么、为什么不续跑,与两条出路(运维在一次性迁移的窗内重启本服务 ⇒ 起服改写存体、同一请求可再发;否则作为新任务重提,仍停驻的先取消)。不回显值。
@@ -132,7 +141,7 @@ export declare function retiredRequestKeyOf(body: unknown): RetiredRequestKey |
  * 句子写绝对日期(过了这一天读句子的人一眼看出出路已关,不靠「本版发布日」这种随版漂的说法)。
  * 删法见登记表 M30 的 `removal`(唯一来源)。
  */
-export declare function retiredRequestKeyRefusal(key: RetiredRequestKey, rewriteWindowEnd: string): ResumeRefusalAnswer;
+export declare function retiredRequestKeyRefusal(key: ReplayRefusedRetiredKey, rewriteWindowEnd: string): ResumeRefusalAnswer;
 /**
  * 本行能否被按当前读法重放:体里 `allow` 在生效而行上的记号不是当前这一个词 ⇒ **不能**(`true` = 拒)。
  * 记号缺席、是旧词(`"statement"`)或认不得(手改 / 将来的写者)⇒ 同样拒:只有当前这个词是「按当前读法写下」的证据。
@@ -166,7 +175,7 @@ export type StoredBodyReplayRefusal = {
     readonly writerVersion?: string;
 } | {
     readonly kind: "retired_request_key";
-    readonly key: RetiredRequestKey;
+    readonly key: ReplayRefusedRetiredKey;
     /** 改写这只退役键的一次性迁移窗的最后一天(UTC 日历日 YYYY-MM-DD)—— 登记表那一行的 `removableAfter`,由判据(`stored-body-replay.ts`)读来:本模块的闭包只许 node 内建 / 引擎包根,读不了登记表,日期只能由调用方交。 */
     readonly rewriteWindowEnd: string;
     readonly writerVersion?: string;
@@ -230,7 +239,7 @@ export declare function storedBodyReplayLogFields(refusal: StoredBodyReplayRefus
     layer?: InertToolListEntry["layer"];
     storedMode?: PermissionMode | null;
     floor?: PermissionMode;
-    key?: RetiredRequestKey;
+    key?: ReplayRefusedRetiredKey;
     note: string;
 };
 /**

package/dist/http/checkpoint-ctx.js

@@ -39,11 +39,13 @@ export function permissionModeReadingRefusal() {
         }),
     };
 }
-export const RETIRED_REQUEST_KEYS = ["promptProfile"];
+export const REPLAY_REFUSED_RETIRED_KEYS = ["promptProfile"];
+export const INERT_RETIRED_KEYS = ["rewindFiles"];
+export const RETIRED_REQUEST_KEYS = [...REPLAY_REFUSED_RETIRED_KEYS, ...INERT_RETIRED_KEYS];
 export function retiredRequestKeyOf(body) {
     if (body === null || typeof body !== "object" || Array.isArray(body))
         return undefined;
-    return RETIRED_REQUEST_KEYS.find((key) => Object.hasOwn(body, key));
+    return REPLAY_REFUSED_RETIRED_KEYS.find((key) => Object.hasOwn(body, key));
 }
 export function retiredRequestKeyRefusal(key, rewriteWindowEnd) {
     switch (key) {

package/dist/http/claimed-run.d.ts

@@ -1,6 +1,6 @@
 /**
  * 一条提交腿**刚认领**的 run 在起跑之前就收场 —— 撤掉本请求建的东西的**唯一**写法。三个调用点:device 落点拒
- * (`device-placement.ts` `commitPlacement`)、续跑输入写不进(`submit-ctx.ts` `persistSubmitCtx`)与 workflow 决定行没落成
+ * (`execution-context.ts` `commitExecutionContext`)、续跑输入写不进(`submit-ctx.ts` `persistSubmitCtx`)与 workflow 决定行没落成
  * (`durable-run-leg.ts` 的 fresh 投递腿;此刻认领可能已被收割归了别人 —— 两步都按这一跑自己的 taskId,碰不到别人的认领)。
  *
  * 撤两步,**各自独立**(一步失败不拦另一步,残余最小):

package/dist/http/durable-run-leg.js

@@ -6,7 +6,8 @@ import { fleetRunPublisher, fleetRunLabels } from "../fleet/fleet-bus.js";
 import { cascadeConfig, runMeta } from "./run-meta.js";
 import { declaredApprovalFrameFamilies, resolveStreamApprovalGate } from "../tool-approval.js";
 import { buildActiveRunConflict } from "./active-run-conflict.js";
-import { commitPlacement, devicePlacementErrorBody } from "./device-placement.js";
+import { commitExecutionContext } from "./execution-context.js";
+import { rootSessionAbsentAnswer } from "./execution-context.js";
 import { commitSessionInheritEnv } from "./session-inherit-env.js";
 import { clearTurnActivity, readTurnActivityMs } from "../turn-activity.js";
 import { recordResourceWindow } from "../resource-window.js";
@@ -18,7 +19,7 @@ import { createSessionWorkspaceRecorder, legSessionWitnessOf, sessionWorkspaceSt
 export async function mintAndDriveDurableRun(ctx, runStore, args) {
     const { deps } = ctx;
     const { inflightRuns, preemptableRuns, steerableRuns } = ctx.registry;
-    const sessionId = args.prepared.spec.sessionId ?? uuidv7();
+    const sessionId = args.prepared.spec.sessionId;
     const taskId = args.clientTaskId ?? uuidv7();
     const trustedInternals = await heldWorkflowParkDecisions(deps, sessionId, args.workflowDecision?.carried);
     const created = await runStore.createRun(taskId, sessionId, args.prepared.auth?.principal ?? null, deps.instanceId ?? "default", { ...runMeta(args.prepared, args.source), identity: args.identity, idem: args.idem ?? null });
@@ -28,6 +29,8 @@ export async function mintAndDriveDurableRun(ctx, runStore, args) {
         recordResourceWindow(taskId, args.prepared.spec.resourceSuspend);
     if (created.existing)
         return { existing: created.existing };
+    if (created.sessionAbsent)
+        return rootSessionAbsentAnswer();
     if (!created.ok) {
         return { status: 409, body: await buildActiveRunConflict({ runStore, checkpointStore: deps.checkpointStore, governance: deps.config, runStaleSec: deps.config.runStaleSec, turnActivity: readTurnActivityMs }, sessionId, created.activeTaskId) };
     }
@@ -37,9 +40,9 @@ export async function mintAndDriveDurableRun(ctx, runStore, args) {
     }, HEARTBEAT_MS);
     preLaunchHeartbeat.unref?.();
     try {
-        const placementReject = await commitPlacement(deps, runStore, taskId, args.prepared.bindingIntent);
+        const placementReject = await commitExecutionContext(deps, { kind: "run", runStore, taskId }, args.prepared.execution);
         if (placementReject)
-            return { status: placementReject.status, body: devicePlacementErrorBody(placementReject) };
+            return placementReject;
         if (deps.checkpointStore) {
             const ctxRefusal = await persistSubmitCtx(deps.checkpointStore, deps, { runStore, taskId }, sessionId, { body: args.prepared.body, memoryScope: args.prepared.auth?.memoryScope, writerVersion: serviceVersion() });
             if (ctxRefusal)
@@ -80,7 +83,7 @@ export async function mintAndDriveDurableRun(ctx, runStore, args) {
         sessionId,
         ...fleetRunLabels(args.prepared.spec.objective),
     });
-    void heldFor(args.prepared.peerLease, () => runInBackground(args.prepared.runner, { ...args.prepared.spec, sessionId }, runStore, taskId, deps.metrics, args.prepared.auth?.principal, args.prepared.verify, args.prepared.cascade ? cascadeConfig(deps.config.cascadeLadder, args.prepared.spec.limits?.maxCostUsd) : undefined, deps.instrumentDegenerate, deps.planCacheProbe, deps.config.traceThinking, inflightRuns, preemptableRuns, steerableRuns, deps.modelUsage, deps.elicitation, args.elicitOwner, captureTurnAnchor, fleetPub, captureUserMessageAnchor, deps.question, deps.workflowCompletionInbox, deps.subagentSteerRegistry, (m, x) => deps.logger?.info?.(m, x), deps.sendUserFile, deps.promptManifests, deps.toolApproval
+    void heldFor(args.prepared.peerLease, () => runInBackground(args.prepared.runner, args.prepared.spec, runStore, taskId, deps.metrics, args.prepared.auth?.principal, args.prepared.verify, args.prepared.cascade ? cascadeConfig(deps.config.cascadeLadder, args.prepared.spec.limits?.maxCostUsd) : undefined, deps.instrumentDegenerate, deps.planCacheProbe, deps.config.traceThinking, inflightRuns, preemptableRuns, steerableRuns, deps.modelUsage, deps.elicitation, args.elicitOwner, captureTurnAnchor, fleetPub, captureUserMessageAnchor, deps.question, deps.workflowCompletionInbox, deps.subagentSteerRegistry, (m, x) => deps.logger?.info?.(m, x), deps.sendUserFile, deps.promptManifests, deps.toolApproval
         ? {
             coordinator: deps.toolApproval,
             streamApprovalOn: resolveStreamApprovalGate({
@@ -92,6 +95,7 @@ export async function mintAndDriveDurableRun(ctx, runStore, args) {
             windowMs: deps.config.streamApproval?.windowMs,
             windowMarginMs: deps.config.streamAskWindowMarginMs,
             declaredFamilies: declaredApprovalFrameFamilies(args.prepared.body.settings),
+            executionLane: args.prepared.execution.lane,
         }
         : undefined, deps.checkpointStore, args.prepared.engineNotices, trustedInternals, deps.userInputLedger, args.prepared.acceptance, createSessionWorkspaceRecorder(sessionWorkspaceStoreOf(deps.sessionStorage), legSessionWitnessOf(args.prepared.spec))));
     return { status: 202, body: { taskId, sessionId, status: "running", ...(args.prepared.warnings !== undefined ? { warnings: args.prepared.warnings } : {}) } };