@sema-agent/server 7.148.0 → 7.149.0

package/dist/http/execution-context.js

@@ -3,13 +3,16 @@ import { HttpError, createCodedHttpError, ssoVerifiedScope } from "../security.j
 import { gatedPerson } from "./principal-gate.js";
 import { DEVICE_ERROR_CODES, assertDeviceIdShape } from "../device-store.js";
 import { buildDeviceRejection } from "../device-enrollment.js";
-import { sameOccupant } from "../execution-placement.js";
+import { SessionForkInProgressError, sameOccupant } from "../execution-placement.js";
 import { deployedExecutionLanes } from "../execution-lane-caps.js";
 import { gateExecutionLane } from "../runtime-caps-resolver.js";
-import { releaseClaimedRun } from "./claimed-run.js";
+import { releaseClaimedRun, withdrawClaimedRun } from "./claimed-run.js";
 import { sessionIdRetiredFor } from "../deleted-session-ids.js";
 import { refusalBody } from "./refusal-body.js";
 import { timeClaim } from "./claim-latency.js";
+import { storeFaultClassOf } from "../plugins/store-fault.js";
+import { resumeClaimFaultAnswer } from "./resume-ctx-read.js";
+import { resumeAssemblyRefusalAnswer, resumeRefusalWithCard } from "./checkpoint-ctx.js";
 export async function resolveExecutionContext(deps, entry) {
     const lanes = deployedExecutionLanes(deps.config);
     switch (entry.kind) {
@@ -70,8 +73,7 @@ function laneOf(root, cell, lanes) {
     }
 }
 function sessionMirrorError(root) {
-    const answer = sessionMirrorAnswer(root);
-    return createCodedHttpError(answer.status, answer.body.errorCode, answer.body.error, { forkPath: forkPathOf(root) });
+    return refusalHttpError(sessionMirrorAnswer(root));
 }
 export function forkPathOf(root) {
     return `/v1/sessions/${encodeURIComponent(root)}/fork`;
@@ -87,8 +89,7 @@ function sessionMirrorAnswer(root) {
     };
 }
 function rootSessionGoneError() {
-    const absent = rootSessionAbsentAnswer();
-    return createCodedHttpError(absent.status, absent.body.errorCode, absent.body.error);
+    return refusalHttpError(rootSessionAbsentAnswer());
 }
 export function isRootSessionGoneError(err) {
     return err instanceof HttpError && err.code === rootSessionAbsentAnswer().body.errorCode;
@@ -142,8 +143,8 @@ async function admitDevicePlacement(deps, entry, lane, seat, reading) {
     try {
         admitted = await deps.deviceEnrollment.admitSession({ rootSessionId: entry.root, placement: reading, requester: owner, ...(requestedDeviceId === undefined ? {} : { requestedDeviceId }) });
     }
-    catch {
-        throw asHttpError(registryUnavailable());
+    catch (e) {
+        throw asHttpError(faultedAnswerOf(e, registryUnavailable));
     }
     if (admitted.ok)
         return { rootSessionId: entry.root, occupant: reading.occupant, owner, admittedDeviceId: admitted.value.deviceId, firstBind: false };
@@ -153,8 +154,8 @@ async function admitDevicePlacement(deps, entry, lane, seat, reading) {
     try {
         view = await deps.deviceStore.readDeviceForAdmission(requestedDeviceId, owner);
     }
-    catch {
-        throw asHttpError(registryUnavailable());
+    catch (e) {
+        throw asHttpError(faultedAnswerOf(e, registryUnavailable));
     }
     if (!view)
         throw asHttpError(buildDeviceRejection(DEVICE_ERROR_CODES.NOT_FOUND, "device not found"));
@@ -169,8 +170,20 @@ export function stampSpecRoot(spec, ctx, submission) {
     if (named !== undefined && named !== ctx.root) {
         throw createCodedHttpError(400, "request.precondition_unmet", "the deployment's spec resolver named a session other than the one this submission was authorized for — a submission's root session comes only from the authorizer, so resolveSpec must not set sessionId (read opts.execution.root instead)");
     }
-    const requireExisting = submission.cascade !== true && (ctx.occupant !== undefined || submission.requireExistingSession === true);
-    return requireExisting ? { ...spec, sessionId: ctx.root, requireExistingSession: true } : { ...spec, sessionId: ctx.root };
+    switch (submission.use) {
+        case "session": {
+            const mustExist = ctx.occupant !== undefined || submission.requireExistingSession === true;
+            return mustExist ? { ...spec, sessionId: ctx.root, requireExistingSession: true } : { ...spec, sessionId: ctx.root };
+        }
+        case "ladder_host": {
+            const { requireExistingSession: _noAcquireOnALadder, ...ladderSpec } = spec;
+            return { ...ladderSpec, sessionId: ctx.root };
+        }
+        default: {
+            const unhandled = submission;
+            throw new Error(`stampSpecRoot: unhandled root use ${JSON.stringify(unhandled)}`);
+        }
+    }
 }
 export function rootSessionAbsentAnswer() {
     return {
@@ -181,6 +194,62 @@ export function rootSessionAbsentAnswer() {
         }),
     };
 }
+export function isRootSessionGoneRefusal(refusal) {
+    return refusal.body.errorCode === rootSessionAbsentAnswer().body.errorCode;
+}
+export function faultedAnswerOf(e, answer) {
+    const fault = storeFaultClassOf(e);
+    switch (fault) {
+        case "corrupt":
+        case "connection":
+        case "deployment":
+        case "unclassified":
+            return answer();
+        case "defect":
+            throw e;
+        default: {
+            const unhandled = fault;
+            throw new Error(`faultedAnswerOf: the store-fault judge answered a class this reader does not place: ${String(unhandled)}`);
+        }
+    }
+}
+export function runStoreUnavailableAnswer() {
+    return {
+        status: 503,
+        body: refusalBody({ errorCode: "state.run_store_unavailable", message: "this task could not be recorded just now (the store did not answer), so nothing was started. Send it again later; if this keeps happening, ask whoever operates this deployment to check its database." }),
+    };
+}
+export const SUBMISSION_CLAIM_FACE = { refused: (refusal) => refusal, faulted: runStoreUnavailableAnswer };
+export const CONTINUATION_CLAIM_FACE = {
+    refused: (refusal) => (isRootSessionGoneRefusal(refusal) ? refusal : cardWaitingRefusalAnswer(refusal)),
+    faulted: resumeClaimFaultAnswer,
+};
+export function cardWaitingRefusalAnswer(refusal) {
+    const { error, errorCode, ...facts } = refusal.body;
+    return resumeRefusalWithCard(resumeAssemblyRefusalAnswer(refusal.status, { errorCode, message: error, facts }), true);
+}
+export function refusalHttpError(refusal) {
+    const { error, errorCode, ...facts } = refusal.body;
+    return createCodedHttpError(refusal.status, errorCode, error, Object.keys(facts).length > 0 ? facts : undefined);
+}
+export async function resolveBeforeClaim(deps, entry, face) {
+    try {
+        return await resolveExecutionContext(deps, entry);
+    }
+    catch (e) {
+        if (e instanceof HttpError)
+            throw e;
+        throw new ClaimFaultAnswer(faultedAnswerOf(e, face.faulted));
+    }
+}
+export class ClaimFaultAnswer extends HttpError {
+    answer;
+    constructor(answer) {
+        const { error, errorCode: code, ...facts } = answer.body;
+        super(answer.status, error, Object.keys(facts).length > 0 ? { code, extra: facts } : { code });
+        this.answer = answer;
+    }
+}
 export function placementWriteDeadlineMs(runStaleSec) {
     const stale = typeof runStaleSec === "number" && Number.isFinite(runStaleSec) && runStaleSec > 0 ? runStaleSec : RUN_STALE_SEC_DEFAULT;
     return Math.min(15_000, Math.max(1_000, Math.floor((stale * 1000) / 4)));
@@ -209,7 +278,7 @@ export async function commitExecutionContext(deps, claim, ctx) {
     return timeClaim(deps.metrics, "placement_commit", commitPlacement(deps, claim, ctx, seat, occupant));
 }
 async function commitPlacement(deps, claim, ctx, seat, occupant) {
-    const release = (why) => releaseClaim(deps, claim, why);
+    const release = (why, ending) => withdrawClaim(deps, claim, why, ending);
     const deadlineMs = placementWriteDeadlineMs(deps.config?.runStaleSec);
     const withDeadline = async (work) => {
         let timer;
@@ -227,56 +296,64 @@ async function commitPlacement(deps, claim, ctx, seat, occupant) {
                 clearTimeout(timer);
         }
     };
-    const goneAnswer = () => (claim.kind === "parked" ? claim.goneAnswer : rootSessionAbsentAnswer());
     let refusal;
     try {
         refusal =
             ctx.device !== undefined
-                ? await commitDevice(deps, seat, ctx.device, withDeadline, goneAnswer)
+                ? await commitDevice(deps, seat, ctx.device, withDeadline)
                 : ctx.placement === "absent"
-                    ? await commitPlace(seat, ctx, occupant, withDeadline, goneAnswer)
-                    : await reassertWriter(seat, ctx, occupant, withDeadline, goneAnswer);
+                    ? await commitPlace(seat, ctx, occupant, withDeadline)
+                    : await reassertWriter(seat, ctx, occupant, withDeadline);
     }
     catch (err) {
-        deps.logger?.warn("execution_placement_commit_failed", { root: ctx.root, lane: ctx.lane, placement: ctx.placement, deadlineMs, err: err instanceof Error ? err.message : String(err) });
-        await release(`execution placement could not be committed: ${err instanceof Error ? err.message : String(err)}`);
-        if (ctx.device !== undefined) {
-            refusal = deviceRefusal(registryUnavailable());
+        if (err instanceof SessionForkInProgressError) {
+            refusal = { status: 409, body: refusalBody({ errorCode: err.code, message: err.message }) };
             deps.metrics?.inc("execution_placement_rejects_total", { errorCode: refusal.body.errorCode });
+            await release(`execution placement rejected: [${refusal.body.errorCode}] ${refusal.body.error}`, "refused");
             return refusal;
         }
+        deps.logger?.warn("execution_placement_commit_failed", { root: ctx.root, lane: ctx.lane, placement: ctx.placement, deadlineMs, err: err instanceof Error ? err.message : String(err) });
+        await release(`execution placement could not be committed: ${err instanceof Error ? err.message : String(err)}`, "faulted");
         throw err;
     }
     if (refusal === null)
         return null;
     deps.metrics?.inc("execution_placement_rejects_total", { errorCode: refusal.body.errorCode });
-    await release(`execution placement rejected: [${refusal.body.errorCode}] ${refusal.body.error}`);
+    await release(`execution placement rejected: [${refusal.body.errorCode}] ${refusal.body.error}`, isRootSessionGoneRefusal(refusal) ? "gone" : "refused");
     return refusal;
 }
-async function releaseClaim(deps, claim, why) {
+export async function withdrawClaim(deps, claim, why, ending) {
+    const loud = (taskId, step, err) => {
+        deps.logger?.warn("execution_placement_run_release_failed", { taskId, step, err: err instanceof Error ? err.message : String(err) });
+        deps.metrics?.inc("execution_placement_run_release_failed_total");
+    };
     switch (claim.kind) {
         case "run":
-            await releaseClaimedRun(claim.runStore, claim.taskId, why, (err, step) => {
-                deps.logger?.warn("execution_placement_run_release_failed", { taskId: claim.taskId, step, err: err instanceof Error ? err.message : String(err) });
-                deps.metrics?.inc("execution_placement_run_release_failed_total");
-            });
+            await withdrawClaimedRun(claim.runStore, claim.taskId, claim.legId, (err, step) => loud(claim.taskId, step, err));
+            return;
+        case "resumed":
+            if (ending !== "gone") {
+                await claim.restore();
+                return;
+            }
+            await releaseClaimedRun(claim.runStore, claim.taskId, why, (err, step) => loud(claim.taskId, step, err));
             return;
         case "parked":
             await claim.rollback(why);
             return;
         default: {
             const unhandled = claim;
-            throw new Error(`commitExecutionContext: unknown claim ${JSON.stringify(unhandled)}`);
+            throw new Error(`withdrawClaim: unknown claim ${JSON.stringify(unhandled)}`);
         }
     }
 }
-async function commitPlace(seat, ctx, occupant, withDeadline, goneAnswer) {
+async function commitPlace(seat, ctx, occupant, withDeadline) {
     if (ctx.lane === "device") {
         return deviceRefusal(buildDeviceRejection(DEVICE_ERROR_CODES.NOT_BOUND, "this session has no device binding — nothing was started"));
     }
-    return placeOutcomeAnswer(ctx.root, await withDeadline(seat.place(ctx.root, occupant, { role: "writer", lane: ctx.lane })), goneAnswer);
+    return placeOutcomeAnswer(ctx.root, await withDeadline(seat.place(ctx.root, occupant, { role: "writer", lane: ctx.lane })));
 }
-function placeOutcomeAnswer(root, outcome, goneAnswer) {
+function placeOutcomeAnswer(root, outcome) {
     switch (outcome.outcome) {
         case "placed":
         case "same":
@@ -286,17 +363,17 @@ function placeOutcomeAnswer(root, outcome, goneAnswer) {
         case "mirror":
             return sessionMirrorAnswer(root);
         case "gone":
-            return goneAnswer();
+            return rootSessionAbsentAnswer();
         default: {
             const unhandled = outcome;
             throw new Error(`commitExecutionContext: no answer for ${JSON.stringify(unhandled)}`);
         }
     }
 }
-async function reassertWriter(seat, ctx, occupant, withDeadline, goneAnswer) {
+async function reassertWriter(seat, ctx, occupant, withDeadline) {
     const now = await withDeadline(seat.read(ctx.root));
     if (now === undefined || !sameOccupant(now.occupant, occupant))
-        return goneAnswer();
+        return rootSessionAbsentAnswer();
     const cell = now.cell;
     switch (cell.role) {
         case "writer":
@@ -312,20 +389,31 @@ async function reassertWriter(seat, ctx, occupant, withDeadline, goneAnswer) {
         }
     }
 }
-async function commitDevice(deps, seat, intent, withDeadline, goneAnswer) {
+async function commitDevice(deps, seat, intent, withDeadline) {
     const enrollment = deps.deviceEnrollment;
     if (!enrollment) {
         throw new Error("commitExecutionContext: a device placement intent was minted without a DeviceEnrollment — assembly bug (both are read from the same ServiceDeps)");
     }
+    const registry = async (work) => {
+        try {
+            return { ok: true, value: await withDeadline(work) };
+        }
+        catch (e) {
+            return { ok: false, refusal: deviceRefusal(faultedAnswerOf(e, registryUnavailable)) };
+        }
+    };
     if (intent.firstBind) {
-        const bound = await withDeadline(enrollment.bindPlacement({ rootSessionId: intent.rootSessionId, occupant: intent.occupant, deviceId: intent.admittedDeviceId, requester: intent.owner }));
+        const binding = await registry(enrollment.bindPlacement({ rootSessionId: intent.rootSessionId, occupant: intent.occupant, deviceId: intent.admittedDeviceId, requester: intent.owner }));
+        if (!binding.ok)
+            return binding.refusal;
+        const bound = binding.value;
         if (bound.ok)
             return null;
         if ("reject" in bound)
             return deviceRefusal(bound.reject);
         switch (bound.placement) {
             case "gone":
-                return goneAnswer();
+                return rootSessionAbsentAnswer();
             case "mirror":
                 return sessionMirrorAnswer(intent.rootSessionId);
             case "tree_bound":
@@ -338,8 +426,10 @@ async function commitDevice(deps, seat, intent, withDeadline, goneAnswer) {
     }
     const placement = await withDeadline(seat.read(intent.rootSessionId));
     if (placement === undefined || !sameOccupant(placement.occupant, intent.occupant))
-        return goneAnswer();
-    const readmitted = await withDeadline(enrollment.admitSession({ rootSessionId: intent.rootSessionId, placement, requester: intent.owner, requestedDeviceId: intent.admittedDeviceId }));
-    return readmitted.ok ? null : deviceRefusal(readmitted.reject);
+        return rootSessionAbsentAnswer();
+    const readmission = await registry(enrollment.admitSession({ rootSessionId: intent.rootSessionId, placement, requester: intent.owner, requestedDeviceId: intent.admittedDeviceId }));
+    if (!readmission.ok)
+        return readmission.refusal;
+    return readmission.value.ok ? null : deviceRefusal(readmission.value.reject);
 }
 //# sourceMappingURL=execution-context.js.map

package/dist/http/owner-access.d.ts

@@ -43,8 +43,9 @@ export interface OwnerAccessWiring {
 }
 /**
  * 🔴 **一次请求的调用方**(唯一铸点之一;另一只是决定口的 {@link callerOfDecision}、提交挂接的 `security.ts` `claimCallerOf`)。
- * 主体 = `gatedSubject`(验身份的那一只;带场景头 ⇒ 这个人的那一格分区);运维 = `explicitOperatorOk(personOf(主体))`(唯一读法,读人);fleet = 部署没有身份边界(`devOpenDeployment`)或出示 service 凭据、
- * 不报主体、部署没声明关掉(`actsForDeployment`),两者互斥(前者要求没配凭据);只读 trace 凭据单列(它只在读档算 fleet,见面表 `fleet` 列)。
+ * 主体 = `gatedSubject`(验身份的那一只;带场景头 ⇒ 这个人的那一格分区);运维 = `explicitOperatorOk(personOf(主体))`(唯一读法,读人);fleet = `actsForDeployment`
+ * (唯一读法:报了主体 ⇒ 不是 fleet;不报主体 ⇒ 部署没有身份边界时 `dev_open`、出示部署让它代自己说话的 service 凭据时 `deployment_token`,两者互斥 —— 前者要求没配凭据);
+ * 只读 trace 凭据单列(它只在读档算 fleet,见面表 `fleet` 列)。报了主体的调用方因此在每一口都是那位主体,与提交挂接的 `claimCallerOf`(fleet 恒缺)同读。
  */
 export declare function callerOf(req: IncomingMessage, w: Pick<OwnerAccessWiring, "config">): Caller;
 /**

package/dist/http/owner-access.js

@@ -5,16 +5,15 @@ import { mintOwnedRow, partsOf, personOf, subjectOf } from "../owner-brands.js";
 import { sessionCellFor } from "../security.js";
 import { openFaceFaultWire, SessionOwnerUnreadableError } from "../session-error-wire.js";
 import { seatText } from "../trace/exit-seat.js";
-import { actsForDeployment, devOpenDeployment, explicitOperatorOk, gatedSubject, sendPrincipalRefusal, sendUnauthorized, traceTokenPresented } from "./principal-gate.js";
+import { actsForDeployment, explicitOperatorOk, gatedSubject, sendPrincipalRefusal, sendUnauthorized, traceTokenPresented } from "./principal-gate.js";
 import { RUN_NOT_FOUND_MESSAGE, runNotFoundMessage, SESSION_NOT_FOUND_MESSAGE } from "./route-ctx.js";
 import { sendError, sendJson } from "./send.js";
 export function callerOf(req, w) {
     const subject = gatedSubject(req, w.config);
-    const fleet = devOpenDeployment(w.config) ? "dev_open" : actsForDeployment(req, w.config, () => subject) ? "deployment_token" : undefined;
     return {
         subject,
         operator: explicitOperatorOk(subject === undefined ? undefined : personOf(subject), w.config),
-        fleet,
+        fleet: actsForDeployment(req, w.config, () => subject),
         traceRead: traceTokenPresented(req, w.config),
         principalRequired: DEPLOYMENT_SHAPE_PREDICATES.principalRequired.holds(w.config),
         multiTenant: DEPLOYMENT_SHAPE_PREDICATES.multiTenant.holds(w.config),

package/dist/http/principal-gate.d.ts

@@ -1,6 +1,7 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type { ServiceConfig } from "../config-types.js";
 import { type Person, type Subject } from "../owner-brands.js";
+import type { Caller } from "../owner-faces.js";
 import { type IdentitySource, type RunIdentity } from "../identity-source.js";
 import type { Logger } from "../observability/logger.js";
 /** Coerce a possibly-repeated request header to a single string (or undefined). */
@@ -96,22 +97,28 @@ export declare function sendUnauthorized(res: ServerResponse, face: Unauthorized
 /**
  * 🔴 **dev-open 的判据** = 部署形表行 `identityBoundary` 不成立(`deployment-shape.ts`;「这台部署有没有身份边界」的唯一答者):
  * 没声明 `REQUIRE_PRINCIPAL`、配置没接任何已验身份来源(没配 service token、没配鉴权桥 issuer —— 含中心回退、没开直连门)、也没声明只读 trace token:
- * 请求里没有任何东西替主体头作保,头是谁都能自报的**标签**(过滤 / 展示用),不是身份。只读配置:鉴权桥的验签器由起服第 9 段按同一个配置读数建
+ * 请求里没有任何东西替主体头作保,头是谁都能自报的(不是认证)—— 但报了它的请求仍是「为那位主体」,不是为部署本人({@link actsForDeployment})。只读配置:鉴权桥的验签器由起服第 9 段按同一个配置读数建
  * (配置里有桥 ⇔ 装了验签器;验签器与配置里的桥两者不一致的装配(任一方向)在 `createHttpServer` 拒),所以这里与先于验签器的一次性迁移段读到同一个答案。
- * 两处读它、不各写一份:调用方的 fleet 一格(属主存取器 `owner-access.ts` 的 `callerOf` —— 面表的 `dev_open` 资格与 fleet 列表面都经它)、
- * `/metrics` 族的免凭据臂(`dispatch.ts`)—— 于是「调用方是谁」在列表、单行面与指标面上只有一只读法。
+ * 这是部署事实,不是调用方事实:「这位调用方代不代部署本人说话」只有 {@link actsForDeployment} 一只读法(本函数是它的一臂);另一个读者 `dispatch.ts` 的 `/metrics` 族
+ * 只拿它判「配了只读凭据的这台部署上免凭据臂关着,不必读调用方」(凭据先于主体判),不判调用方是谁。
  */
 export declare function devOpenDeployment(config: ServiceConfig): boolean;
+/** 代部署本人说话的那一格 = 属主存取器 `Caller.fleet` 的词(闭集只在 `owner-faces.ts` 拼一次):`dev_open` = 没有身份边界的部署上不报主体的调用方;`deployment_token` = 出示部署让它代自己说话的 service 凭据、不报主体的调用方。 */
+export type DeploymentVoice = NonNullable<Caller["fleet"]>;
 /**
- * 🔴 **律(一句,一个参数)**:出示这台部署的 service 凭据且不报主体的调用方代部署本人说话(fleet),**除非部署声明 `SERVICE_TOKEN_ACTS_FOR_DEPLOYMENT=false`**
- * —— 此时它是无身份调用方,按各面既有的「过了凭据门、没有主体」那一臂答。带主体头的 service 凭据请求是前端(BFF)代那位主体发的 —— 它读那位主体,
- * 不读全舰队(两形同读);部署姿态(单用户 / 多租)不改这一句(单用户形上的主体头同样是「这次请求为谁」)。
- * 本函数是这条律的**唯一实施点**:声明位({@link ServiceConfig.serviceTokenActsForDeployment},env 一处)是这里的一个合取项,两个读者一次继承 ——
- * 调用方的 fleet 一格(属主存取器 `owner-access.ts` 的 `callerOf`)与 `/metrics` 族的 service 臂(`dispatch.ts`);不加拒码、不加闸点。自报位 `/health.auth.serviceTokenActsForDeployment`
- * 投的是同一只读法({@link serviceTokenDeclaredActsForDeployment})与同一只武装谓词(`http/health-self-report.ts`)。先判声明与凭据、后取主体:`subject` 只在两者都成立时才求值(调用点那一次 {@link gatedSubject}),
- * 没带凭据的请求不因主体头的形而改答。
+ * 🔴 **律(一句)**:**报了主体的调用方恒是那位主体** —— 每一口、每一种部署形(单用户 / 多租、有没有身份边界)都不改这一句;只有**不报主体**的调用方才代部署本人说话(fleet):
+ * 部署没有身份边界({@link devOpenDeployment} ⇒ `dev_open`:整台一人,不报主体的就是那一位 —— 「不报」= 没有主体头,也没出示一枚这台部署验不过的凭据
+ * ({@link bearerPresentedButUnverified}:出示了验不过 ≠ 没出示 —— 那枚凭据把主体头抹成「没有可信身份」,不许再落回最宽的那一格)),或出示这台部署的 service 凭据且部署没声明
+ * `SERVICE_TOKEN_ACTS_FOR_DEPLOYMENT=false`(⇒ `deployment_token`;声明了 ⇒ 它是无身份调用方,按各面既有的「过了凭据门、没有主体」那一臂答)。
+ * 带主体头的请求是前端(BFF)代那位主体发的、或调用方自报的「这次请求为谁」—— 它读那位主体、动那位主体的,不读全舰队;dev-open 上主体头谁都能自报,
+ * 那是部署选了不验身份(要隔离就给部署接一个身份来源),不是把头读成「为部署本人」的理由:提交的挂接(`security.ts` 的认领面)一向按它判属主,读面、列表与存续面同读这一句。
+ * 本函数是这条律的**唯一实施点**,两个读者一次继承 —— 调用方的 fleet 一格(属主存取器 `owner-access.ts` 的 `callerOf`)与 `/metrics` 族(`dispatch.ts`:`dev_open` 臂在没配
+ * `METRICS_TOKEN` 时免凭据,`deployment_token` 臂即 service 臂);不加拒码、不加闸点。自报位 `/health.auth.serviceTokenActsForDeployment` 投的是声明位的同一只读法
+ * ({@link serviceTokenDeclaredActsForDeployment})与同一只武装谓词(`http/health-self-report.ts`)。
+ * 主体只在部署那一格成立时求值(调用点那一次 {@link gatedSubject}):有身份边界的部署上没带 service 凭据的请求不因主体头的形而改答;dev-open 上要判「报没报主体」,
+ * 主体头形不合的请求与其余各口同答那一只 400。
  */
-export declare function actsForDeployment(req: IncomingMessage, config: ServiceConfig, subject: () => Subject | undefined): boolean;
+export declare function actsForDeployment(req: IncomingMessage, config: ServiceConfig, subject: () => Subject | undefined): DeploymentVoice | undefined;
 /**
  * 声明位 `SERVICE_TOKEN_ACTS_FOR_DEPLOYMENT` 的**唯一读法**:门({@link actsForDeployment})、自报位(`http/health-self-report.ts`)、起服行
  * ({@link buildServiceTokenPostureNotice})三处都经它,不各写一份真值判断。只有字面 `true` 是「代部署本人」:`loadConfig` 恒写这一格(缺省 `true`),

package/dist/http/principal-gate.js

@@ -152,7 +152,9 @@ export function devOpenDeployment(config) {
     return !DEPLOYMENT_SHAPE_PREDICATES.identityBoundary.holds(config);
 }
 export function actsForDeployment(req, config, subject) {
-    return serviceTokenDeclaredActsForDeployment(config) && systemFor(req, config) !== undefined && subject() === undefined;
+    if (devOpenDeployment(config))
+        return subject() === undefined && !bearerPresentedButUnverified(req, config) ? "dev_open" : undefined;
+    return serviceTokenDeclaredActsForDeployment(config) && systemFor(req, config) !== undefined && subject() === undefined ? "deployment_token" : undefined;
 }
 export function serviceTokenDeclaredActsForDeployment(config) {
     return config.serviceTokenActsForDeployment === true;

package/dist/http/resume-ctx-read.d.ts

@@ -58,10 +58,11 @@ export interface CheckpointCtxOpening {
 }
 export declare function readResumeCtx(load: Promise<StoredCheckpointCtx | null>, opening: CheckpointCtxOpening): Promise<ResumeCtxRead>;
 /**
- * 续跑家族一次店读失败的落点 —— 判官的五词逐词表态,**只在这一处**(本口读续跑上下文那一读,与续跑腿读「这张卡归哪条 run」那一读同读它):
- * `corrupt` ⇒ 坏体(带坐标);`connection` / `deployment` / `unclassified` ⇒ 读不出;`defect` ⇒ 原样上抛。
+ * 续跑家族一次店往返失败的落点 —— 判官的五词逐词表态,**只在这一处**。三个读者同读它:本口读续跑上下文那一读、续跑腿读「这张卡归哪条 run」那一读,
+ * 与续跑腿的认领(`resume-legs.ts` 的 `resumeClaimFaultAnswerOf`:认领那一笔,或认领之后执行席那一次读 / 写失败 —— 后者的认领已由写口撤回)。
+ * `corrupt` ⇒ 坏体(带坐标);`connection` / `deployment` / `unclassified` ⇒ 读不出 / 写不进;`defect` ⇒ 原样上抛。
  */
-export declare function resumeStoreReadFailureOf(e: unknown): {
+export declare function resumeStoreFailureOf(e: unknown): {
     readonly kind: "corrupt";
     readonly where: string;
 } | {
@@ -77,6 +78,16 @@ export declare function resumeCtxUnreadableAnswer(): {
     status: number;
     body: RefusalBody;
 };
+/**
+ * 续跑腿**认领**撞店故障的对外答复 —— 认领那一笔(`markResuming` / wake 现建行的 `createRun`)或认领之后那一次提交(执行席的再读 / 落格)。
+ * 与 {@link resumeCtxUnreadableAnswer} **同码同状态**(503 `state.resume_context_unreadable`:店这一拍没答出来,这一请求没有执行,稍后原样重发;一直如此 ⇒ 请运维查库),
+ * 句子说的是这一形自己的事:读或写这条任务的存储状态失败了,卡仍待决(认领之后那一形的认领已由写口撤回到取来时的样子)。句子不带店层 detail。
+ * 🔴 形是给冻结门看的(与 {@link resumeCtxCorruptAnswer} 同一条):`status: <三位数>, body: refusalBody({ errorCode: "<码>", message: "<整句双引号字面>"`,中间只许有空白。
+ */
+export declare function resumeClaimFaultAnswer(): {
+    status: number;
+    body: RefusalBody;
+};
 /**
  * 开不开的对外答复([ref])—— 409 `conflict.checkpoint_ctx_unsealable`,机读 `field`(哪一个凭据位,提交体路径;键名不是秘密,值从不进来)+ `reason`
  * (闭集 `CHECKPOINT_CTX_UNSEALABLE_REASONS`)。句子说「这条任务的续跑上下文里带的凭据本服务开不开」、五种成因与出路(按 `reason` 修好保管目录后原样重发,

package/dist/http/resume-ctx-read.js

@@ -14,11 +14,11 @@ async function readStoredCtx(load) {
         stored = await load;
     }
     catch (e) {
-        return resumeStoreReadFailureOf(e);
+        return resumeStoreFailureOf(e);
     }
     return stored == null ? { kind: "absent" } : { kind: "ok", ctx: stored };
 }
-export function resumeStoreReadFailureOf(e) {
+export function resumeStoreFailureOf(e) {
     const fault = storeFaultClassOf(e);
     switch (fault) {
         case "corrupt":
@@ -41,6 +41,12 @@ export function resumeCtxUnreadableAnswer() {
         body: refusalBody({ errorCode: "state.resume_context_unreadable", message: "this session's stored resume context could not be read just now (reading it failed), so this request was not carried out. Send it again later; if this keeps happening, ask whoever operates this deployment to check its database." }),
     };
 }
+export function resumeClaimFaultAnswer() {
+    return {
+        status: 503,
+        body: refusalBody({ errorCode: "state.resume_context_unreadable", message: "the stored state of this task could not be read or written just now (the store failed), so this request was not carried out and the task is still waiting for it. Send it again later; if this keeps happening, ask whoever operates this deployment to check its database." }),
+    };
+}
 export function resumeCtxUnsealableAnswer(read) {
     return {
         status: 409,

package/dist/http/resume-legs.d.ts

@@ -12,13 +12,14 @@
  * (`RunRegistry` / `RouteHelpers` / `RouteLegs` / `ReturnType<typeof createRequestGuards>`),不手抄签名 ⇒ 不会漂。
  */
 import type { IncomingMessage } from "node:http";
-import { CheckpointError, type QuestionAnswer, type CheckpointToken, type PendingSteerInput } from "@sema-agent/core";
+import { CheckpointError, type QuestionAnswer, type CheckpointToken, type CheckpointRowVerdict, type PendingSteerInput } from "@sema-agent/core";
 import type { DecideBinding, DecidedAction } from "./wire-types.js";
 import { type KeyCaller } from "../owner-faces.js";
 import { type Subject } from "../owner-brands.js";
 import type { CheckpointStoreFull } from "../plugins/store-backend.js";
 import type { HostDecision } from "../host-decision.js";
 import { type GateSighting } from "../approval-gate-currency.js";
+import { type CancelRunReader } from "../run-cancel-card.js";
 import { type PlanApprovePermissionModeAfter } from "../task-settings.js";
 import type { RouteCtxBase, DriveResumeArgs, PreparedPlanReview, RememberSessionRequest, ResumeCheckpointOutcome, ResumeLegOutcome, WorkflowDecisionDelivery } from "./route-ctx.js";
 import type { RunRegistry, RouteHelpers, RouteLegs } from "./route-ctx.js";
@@ -54,6 +55,34 @@ export declare const CHECKPOINT_ERROR_DISPOSITION: Readonly<Record<CheckpointErr
  * ⇒ `"terminal"`:与 `by_reason` 认不得的词同一条 fail-closed 方向(不宽容默认成可重试),也与修前手列串的缺省逐字相同。
  */
 export declare function resumeRefusalDisposition(e: CheckpointError): "cancelled" | "retriable" | "terminal";
+type NotOkRowVerdict = Exclude<CheckpointRowVerdict, {
+    readonly kind: "ok";
+}>;
+/**
+ * 🔴 **判官判「本引擎续不了」的一张卡,人从哪儿出去 —— 闭集**(这一行在本引擎上不收任何决定,批 / 拒 / 驳 / 改同拒;出路只看判决与这张卡本身,不看门的哪一扇、也不看决定词)。
+ * 唯一铸法 {@link rowWayOutOf};读面 = 决断类续跑拒体上的 `wayOut`(`/decide` 的这一行自己的拒 · `/plan_review` 与 `/resume` 上引擎对这张卡的拒 · 读行臂)。
+ *  · `cancel_run` —— 判决 `damaged`,且取消动词会结算这一张卡:`POST /v1/runs/:id/cancel` 按店 CAS 把卡 expire、再驱 run 终局(不经判官),之后另起任务;
+ *  · `newer_worker` —— 判决 `lacking`:更新引擎停驻的行,不低于停驻它那一版的 worker 续得了它,同一决定在那里落得下;卡留 pending(cancel 在这里是放弃它)。
+ * 缺席 = 本服务说不出一个客户端落得下的出路(判 `damaged` 而取消动词不会结算这张卡 —— 它停在已终局的 run 的纯 park 上、归属说不出的老行,或店此刻答不出这一问)。
+ */
+export type RowWayOut = "cancel_run" | "newer_worker";
+/**
+ * 出路铸法要问店的那一问的座:`cs` + run 店 + 这张卡的令牌 + 铸不成时留痕的日志口(铸法不抛 —— 出路是给客户端的指路,店答不出这一问时拒本身一字不变、只是不指路,并响亮留一行)。
+ * 读行抛的五个读者(读行臂)与载入行的三扇门各自在自己的位置上拿着 `cs` 与令牌,同交一座。
+ */
+export interface WayOutSeat {
+    readonly cs: Pick<CheckpointStoreFull, "hostSessionOfCard" | "findPendingTokenBySession">;
+    /** 取消动词那一问也要看 run 行(只对停着的 run 结算卡);没有耐久 run 店 ⇒ 缺席(取消口恒 501)。 */
+    readonly runs: CancelRunReader | undefined;
+    readonly token: CheckpointToken;
+    readonly logger: FlatServiceDeps["logger"];
+}
+/**
+ * {@link RowWayOut} 的唯一铸法:穷尽 core 的非 ok 判决 kind(core 加一种 ⇒ tsc 红,先来这里定它的出路)。
+ * `damaged` ⇒ `cancel_run` 当且仅当**取消动词会结算这一张卡**({@link cancelSettlesCard}:问的就是取消动词自己那一问,只读店的列,与行体坏成什么样无关 ——
+ * 判坏的卡的行体可以读不成检查点、属主格可以丢,取消照样落得下;投影若另按载入的行体判,就是同一件事的第二个读者)。
+ */
+export declare function rowWayOutOf(seat: WayOutSeat, kind: NotOkRowVerdict["kind"]): Promise<RowWayOut | undefined>;
 /**
  * 🔴 **停驻行读者上「读行抛」的答复 —— 五个读者(决断口含停驻赎回与 SLA 拒扫的 `resumeCheckpoint` · 续跑 `resumePreempted` · 唤醒 `resumeWake` · 计划审阅
  * `preparePlanReview` · 活卡迟到回决 `redeemParkedAsk`)在各自的披露闸(`mayDiscloseRowError` / `decisionRowAdmits`)与各自的 404 句之后,catch 尾同调这一只**([ref])。
@@ -64,14 +93,16 @@ export declare function resumeRefusalDisposition(e: CheckpointError): "cancelled
  *
  * 写者位交空:版本键只长在 `checkpoint.unsupported_version` 上,而一份读不成检查点的字节,判官(core 全函数,读不动的值落 `damaged`)恒判 `damaged`,到不了那一码。
  * 店日后若交出一只 `lacking` 判决,键缺席(不编值);不为这条到不了的臂再开一条读续跑上下文的口(`getCtx` 的结果只交 `readResumeCtx`,读口律;多一个读者就是多一处要记得)。
- * 门型守卫那一臂(行已读出、判官判 `lacking` 可达)自带写者位,见 {@link createResumeLegs} 决断口的 `rowOwnRefusal`。
+ * 载入行那一问(行已读出、判官判 `lacking` 可达)自带写者位,见 {@link loadedRowRefusal}。
+ * `seat` 缺席 ⇒ 这个读者不带出路词(`/wake`:成文律,它的拒从不带 `wayOut`)。
  */
-export declare function rowReadRefusalAnswer(e: unknown): ResumeRefusalAnswer;
+export declare function rowReadRefusalAnswer(e: unknown, seat: WayOutSeat | undefined): Promise<ResumeRefusalAnswer>;
 export declare function checkpointRefusalAnswer(e: CheckpointError, at: {
     readonly gate: string;
     readonly retriable: boolean;
     readonly taskId?: string;
     readonly versionKeys: Readonly<Record<string, string>>;
+    readonly wayOut?: RowWayOut;
 }): ResumeRefusalAnswer;
 /**
  * 一个答案只属于它被展示的那一个动作 —— 决断绑定的**唯一判官**:决断方点名它看到的那一对(`boundCallId` + `boundInputHash`,
@@ -116,4 +147,5 @@ export declare function createResumeLegs(ctx: {
     drivePlanReview: (prepared: PreparedPlanReview, decision: "approve" | "edit" | "reject", editedPlan: string | undefined, reason: string | undefined, hostDecision: HostDecision, req: IncomingMessage | undefined, acceptEarly?: boolean, permissionModeAfter?: PlanApprovePermissionModeAfter) => Promise<ResumeLegOutcome>;
     sessionNotifyDoor: import("../session-notify-door.js").SessionNotifyDoor;
 };
+export {};
 //# sourceMappingURL=resume-legs.d.ts.map