@sema-agent/server 7.151.0 → 7.152.0

package/dist/http/request-channel.js

@@ -0,0 +1,9 @@
+export const REQUEST_CHANNELS = ["tcp", "control-socket"];
+const controlSocketRequests = new WeakSet();
+export function markControlSocketRequest(req) {
+    controlSocketRequests.add(req);
+}
+export function requestChannelOf(req) {
+    return controlSocketRequests.has(req) ? "control-socket" : "tcp";
+}
+//# sourceMappingURL=request-channel.js.map

package/dist/http/request-guards.js

@@ -9,6 +9,7 @@ import { escapedStatementBytes, packetWallStatementBytes, rowWallPayloadBytes }
 import { MAX_JSON_BODY_BYTES } from "../json-body-limit.js";
 import { deliverVia } from "../submission-exit.js";
 import { canonicalAddress } from "../net-address.js";
+import { requestChannelOf } from "./request-channel.js";
 export function refuseSubmitBody(walls, body) {
     const rowWall = walls.maxRowBytes;
     const packetWall = walls.maxPacketBytes;
@@ -171,8 +172,7 @@ export function createRequestGuards(ctx) {
     function rateLimited(req, res) {
         if (!deps.rateLimiter)
             return false;
-        const peer = req.socket.remoteAddress;
-        const key = (deps.config.directDoorActive ? undefined : principalFrom(req, deps.config)) ?? (peer === undefined ? "anon" : (canonicalAddress(peer) ?? peer));
+        const key = (deps.config.directDoorActive ? undefined : principalFrom(req, deps.config)) ?? rateLimitAddressKeyOf(req);
         const d = deps.rateLimiter.check(key);
         if (d.allowed)
             return false;
@@ -220,4 +220,19 @@ export function createRequestGuards(ctx) {
     }
     return { quotaExceeded, ownerCostQuotaDenied, ownerFleetLeaseDenied, ownerLeaseDenied, ownerQuotaDenied, leaseDenied, usageWindowDenialFor, usageWindowDenied, rateLimited, safeDecode, readJson, readRawBody };
 }
+function rateLimitAddressKeyOf(req) {
+    const channel = requestChannelOf(req);
+    switch (channel) {
+        case "tcp": {
+            const peer = req.socket.remoteAddress;
+            return peer === undefined ? "anon" : (canonicalAddress(peer) ?? peer);
+        }
+        case "control-socket":
+            return "control-socket";
+        default: {
+            const unknownChannel = channel;
+            throw new Error(`rate limit: request channel ${String(unknownChannel)} has no address key`);
+        }
+    }
+}
 //# sourceMappingURL=request-guards.js.map

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

@@ -3,6 +3,7 @@ import { storeFaultClassOf } from "../plugins/store-fault.js";
 import { refusalBody } from "./refusal-body.js";
 import { frozenProjectContextOf } from "../project-context.js";
 import { frozenMemorySeedOf } from "../project-registry.js";
+import { permissionModeWriteOf } from "../permission-mode-admission.js";
 export async function readResumeCtx(load, opening) {
     const read = await readStoredCtx(load);
     if (read.kind !== "ok")
@@ -11,9 +12,10 @@ export async function readResumeCtx(load, opening) {
     if (opened.kind !== "ok")
         return { kind: "unsealable", field: opened.field, reason: opened.reason };
     const where = (key) => ({ kind: "corrupt", where: `checkpoint ctx for session ${JSON.stringify(opening.sessionId)}: ${key}` });
-    const { memorySeed: _storedSeed, projectContext: _storedContext, ...rest } = opened.ctx;
+    const { memorySeed: _storedSeed, projectContext: _storedContext, permissionModeWrite: _storedWrite, ...rest } = opened.ctx;
     const seed = frozenMemorySeedOf(opened.ctx.memorySeed);
     const frozen = frozenProjectContextOf(opened.ctx.projectContext);
+    const written = permissionModeWriteOf(opened.ctx.permissionModeWrite);
     let seedPart;
     switch (seed.kind) {
         case "absent":
@@ -32,18 +34,33 @@ export async function readResumeCtx(load, opening) {
             throw new Error(`resume-ctx-read: unplaced frozen memory seed reading ${JSON.stringify(unhandled)}`);
         }
     }
+    let contextPart;
     switch (frozen.kind) {
         case "absent":
-            return { kind: "ok", ctx: { ...rest, ...seedPart } };
+            contextPart = {};
+            break;
         case "malformed":
             return where("projectContext");
         case "ok":
-            return { kind: "ok", ctx: { ...rest, ...seedPart, projectContext: frozen.context } };
+            contextPart = { projectContext: frozen.context };
+            break;
         default: {
             const unhandled = frozen;
             throw new Error(`resume-ctx-read: unplaced frozen project context reading ${JSON.stringify(unhandled)}`);
         }
     }
+    switch (written.kind) {
+        case "absent":
+            return { kind: "ok", ctx: { ...rest, ...seedPart, ...contextPart } };
+        case "malformed":
+            return where("permissionModeWrite");
+        case "ok":
+            return { kind: "ok", ctx: { ...rest, ...seedPart, ...contextPart, permissionModeWrite: written.write } };
+        default: {
+            const unhandled = written;
+            throw new Error(`resume-ctx-read: unplaced permission-mode write reading ${JSON.stringify(unhandled)}`);
+        }
+    }
 }
 async function readStoredCtx(load) {
     let stored;

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

@@ -21,7 +21,7 @@ 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 { RouteCtxBase, DriveResumeArgs, PersistRuleRequest, PreparedPlanReview, RememberSessionRequest, ResumeCheckpointOutcome, ResumeLegOutcome, WorkflowDecisionDelivery } from "./route-ctx.js";
 import type { RunRegistry, RouteHelpers, RouteLegs } from "./route-ctx.js";
 import type { createRequestGuards } from "./request-guards.js";
 import type { FlatServiceDeps } from "./server.js";
@@ -121,7 +121,7 @@ export declare function createResumeLegs(ctx: {
     runnerFor: FlatServiceDeps["runnerFor"];
 } & RunRegistry & RouteHelpers & Pick<RouteLegs, "prepareSpec" | "finalizeTaskResult"> & Pick<ReturnType<typeof createRequestGuards>, "ownerCostQuotaDenied" | "ownerFleetLeaseDenied" | "usageWindowDenialFor">): {
     routeCtxBase: RouteCtxBase;
-    resumeCheckpoint: (sessionId: string, decision: "approve" | "deny", reason: string | undefined, hostDecision: HostDecision, req: IncomingMessage | undefined, answer: QuestionAnswer | undefined, binding: DecideBinding, remember?: RememberSessionRequest, acceptEarly?: boolean, decider?: KeyCaller, restatement?: ResumeRestatement) => Promise<ResumeCheckpointOutcome>;
+    resumeCheckpoint: (sessionId: string, decision: "approve" | "deny", reason: string | undefined, hostDecision: HostDecision, req: IncomingMessage | undefined, answer: QuestionAnswer | undefined, binding: DecideBinding, remember?: RememberSessionRequest, acceptEarly?: boolean, decider?: KeyCaller, restatement?: ResumeRestatement, persistRule?: PersistRuleRequest) => Promise<ResumeCheckpointOutcome>;
     driveResumeIntoRunLog: (args: DriveResumeArgs) => Promise<ResumeLegOutcome>;
     driveResumeLeg: (args: DriveResumeArgs, onAccepted?: (receipt: {
         status: number;

package/dist/http/resume-legs.js

@@ -8,7 +8,7 @@ import { isAdoptionQuiescing, trackMaintenanceLeg } from "../adoption/quiesce.js
 import { runFactsOf, sealRouteDeps, sessionFactsReadOf, sessionOccupantReadOf } from "./owner-access.js";
 import { createSessionWorkspaceRecorder, sessionWorkspaceStoreOf } from "../session-workspace.js";
 const DELIVERY_NOT_RECORDED = "workflow park decide: this delivery no longer holds the host session (its claim was released) — the decision was not recorded and this delivery was not started";
-import { HttpError, checkpointPartsOf, decodeCheckpointScope, scopeCellOf, CHECKPOINT_PUBLIC_SCOPE } from "../security.js";
+import { HttpError, checkpointPartsOf, decodeCheckpointScope, ownerOfCheckpointScope, scopeCellOf, CHECKPOINT_PUBLIC_SCOPE } from "../security.js";
 import { keyAdmits } from "../owner-faces.js";
 import { personOf } from "../owner-brands.js";
 import { recoveredSubject } from "../owner-faces.js";
@@ -24,7 +24,7 @@ import { emitPendingWorkflowCompletions, taskNotificationInboxEntry, taskNotific
 import { fleetRunPublisher, fleetRunLabels, fleetRunResiduals } from "../fleet/fleet-bus.js";
 import { defaultSubagentTailBus } from "../fleet/subagent-tail-bus.js";
 import { currentApprovalGateToken, currentGateFacesOf, sightsCurrentGate } from "../approval-gate-currency.js";
-import { approverFacingArgs, declaredApprovalFrameFamilies, parkRowStandingAnswerFacts, resolveApprovalLeg, resolveStreamApprovalGate, standingAnswerDurablyRecordable } from "../tool-approval.js";
+import { approverFacingArgs, declaredApprovalFrameFamilies, parkRowStandingAnswerFacts, readCardRuleRecordOfAskRow, readCardRuleRecordOfParkRow, redeemCardRule, resolveApprovalLeg, resolveStreamApprovalGate, standingAnswerDurablyRecordable } from "../tool-approval.js";
 import { createHitlTransport } from "../hitl-delivery.js";
 import { buildCheckpointAnchorHash } from "../approval-ask-audit-store.js";
 import { APPROVAL_ENDING_CAUSES } from "../approval-deny-reasons.js";
@@ -72,7 +72,7 @@ import { buildCheckpointVersionKeys, resumeAssemblyRefusalAnswer, resumeRefusalW
 import { refusalBody, resumeRefusalFacts } from "./refusal-body.js";
 import { storedBodyReplayRefusal } from "./stored-body-replay.js";
 import { restateResumeCtx } from "./resume-restatement.js";
-import { stampReplayEntryMode } from "../permission-mode-admission.js";
+import { stampReplayEntryMode, withStoredPermissionMode } from "../permission-mode-admission.js";
 import { httpErrorRefusal } from "./send.js";
 import { createRunAcceptance } from "../run-acceptance.js";
 import { createSubmissionSeat } from "../submission-exit.js";
@@ -219,6 +219,35 @@ function decisionRefusalCauseOf(e, gate) {
 function notResumableAnswer() {
     return { status: 409, body: refusalBody({ errorCode: "conflict.not_resumable", message: "run is not in a resumable (suspended) state (already resumed, decided, or expired)" }) };
 }
+function planeOfEndedRow(row) {
+    return { status: row?.status ?? "failed", errorCode: row?.errorCode ?? undefined, errorMessage: row?.error ?? undefined };
+}
+async function landedTerminalRow(runStore, taskId, arm) {
+    let row;
+    try {
+        row = await runStore.getRun(taskId);
+    }
+    catch (e) {
+        recordFailOpen("server.resume.cancel-answer-row-unreadable", `task=${taskId} arm=${arm} err=${errorText(e)}`);
+        return undefined;
+    }
+    return row !== undefined && isTerminalRunStatus(row.status) ? row : undefined;
+}
+function settledLegAnswer(o) {
+    return {
+        status: 200,
+        body: {
+            ...(o.taskId !== undefined ? { taskId: o.taskId } : {}),
+            sessionId: o.sessionId,
+            status: o.plane.status,
+            bindingEnforced: true,
+            ...(o.plane.errorCode ? { errorCode: o.plane.errorCode } : {}),
+            ...(o.plane.errorMessage ? { errorMessage: redactErrorMessage(o.plane.errorMessage) ?? "" } : {}),
+            ...(o.reparked ? { retriable: true } : {}),
+            ...o.evidence,
+        },
+    };
+}
 function resumeClaimFaultAnswerOf(e) {
     return faultedAnswerOf(e, CONTINUATION_CLAIM_FACE.faulted);
 }
@@ -279,7 +308,7 @@ function acceptableFormFacts(detail) {
     const rewritten = detail !== null && typeof detail === "object" ? detail.editRewritten : undefined;
     if (rewritten === null || typeof rewritten !== "object" || !Object.hasOwn(rewritten, "acceptableForm"))
         return {};
-    const shown = approverFacingArgs(rewritten.acceptableForm);
+    const shown = approverFacingArgs(rewritten.acceptableForm, undefined);
     return shown === undefined ? {} : { acceptableForm: shown };
 }
 export function checkpointRefusalAnswer(e, at) {
@@ -315,8 +344,7 @@ export function createResumeLegs(ctx) {
         const restated = restateResumeCtx(stored, restatement);
         if (restated.unattendedLeg === true)
             return restated;
-        const body = stampReplayEntryMode(restated.body, deps.config);
-        return body === restated.body ? restated : { ...restated, body };
+        return stampReplayEntryMode(restated, deps.config);
     };
     const resumeFleetScope = (req, auth) => req ? (gatedSubject(req, deps.config) ?? "default") : (auth.subject ?? "default");
     function createRememberIntent(sessionId, remember) {
@@ -343,9 +371,23 @@ export function createResumeLegs(ctx) {
             },
         };
     }
-    async function resumeCheckpoint(sessionId, decision, reason, hostDecision, req, answer, binding, remember, acceptEarly, decider, restatement) {
+    function createRuleIntent(persistRule) {
+        let reading;
+        return {
+            record: (r) => {
+                reading = r;
+            },
+            settle: async (committed) => {
+                if (!committed || reading === undefined)
+                    return { rulePersisted: false, ruleRefusal: "rule_lane_unavailable" };
+                return redeemCardRule(deps.ruleConsent, reading, persistRule.slot, { inputWasEdited: persistRule.inputWasEdited, eligible: true });
+            },
+        };
+    }
+    async function resumeCheckpoint(sessionId, decision, reason, hostDecision, req, answer, binding, remember, acceptEarly, decider, restatement, persistRule) {
         const cs = deps.checkpointStore;
         const intent = remember !== undefined ? createRememberIntent(sessionId, remember) : undefined;
+        const ruleIntent = persistRule !== undefined ? createRuleIntent(persistRule) : undefined;
         const token = await currentApprovalGateToken(cs, sessionId);
         if (binding.checkpointToken && !sightsCurrentGate({ face: "checkpointToken", value: binding.checkpointToken }, token ? { checkpointToken: token } : null)) {
             let seenUnreadable = false;
@@ -476,12 +518,36 @@ export function createResumeLegs(ctx) {
             return approvalStaleAnswer(s57CurrentPending ? { currentPending: s57CurrentPending } : {});
         }
         const paForGrant = cp.pendingAction.kind === "tool_approval" ? cp.pendingAction : undefined;
+        const parkFacts = paForGrant !== undefined && paForGrant.toolName ? parkRowStandingAnswerFacts(paForGrant, cp.gate, deps.config, deploymentListAsks(deps.config, { toolName: paForGrant.toolName })) : undefined;
         const rememberableTool = paForGrant !== undefined &&
-            paForGrant.toolName &&
+            parkFacts !== undefined &&
             paForGrant.toolName !== ASK_USER_QUESTION_TOOL_NAME &&
-            standingAnswerDurablyRecordable(parkRowStandingAnswerFacts(paForGrant, cp.gate, deps.config, deploymentListAsks(deps.config, { toolName: paForGrant.toolName })))
+            standingAnswerDurablyRecordable(parkFacts)
             ? paForGrant.toolName
             : null;
+        if (ruleIntent !== undefined) {
+            const owner = ownerOfCheckpointScope(cp.scope);
+            if (paForGrant === undefined || parkFacts === undefined || !token || !paForGrant.toolCallId || !paForGrant.boundInputHash)
+                ruleIntent.record({ kind: "absent", refusal: "rule_material_absent" });
+            else {
+                const asked = deps.toolApproval !== undefined ? await deps.toolApproval.readParkedAskOfGate(cp.sessionId, { boundCallId: paForGrant.toolCallId, boundInputHash: paForGrant.boundInputHash }) : { kind: "none" };
+                switch (asked.kind) {
+                    case "row":
+                        ruleIntent.record(readCardRuleRecordOfAskRow(asked.row, owner));
+                        break;
+                    case "unreadable":
+                        ruleIntent.record({ kind: "absent", refusal: "rule_store_error" });
+                        break;
+                    case "none":
+                        ruleIntent.record(readCardRuleRecordOfParkRow(paForGrant, { owner, governanceForced: parkFacts.governanceForced, scopeRoot: await cs.cardScopeRootOf(token) }));
+                        break;
+                    default: {
+                        const unhandled = asked;
+                        throw new Error(`resumeCheckpoint: unhandled parked-ask reading ${JSON.stringify(unhandled)}`);
+                    }
+                }
+            }
+        }
         const boundGrant = intent
             ? (overrideSessionId) => intent.record({ ...(overrideSessionId !== undefined ? { overrideSessionId } : {}), rememberableToolName: rememberableTool })
             : undefined;
@@ -506,7 +572,11 @@ export function createResumeLegs(ctx) {
         const landAfterCommit = async (out) => {
             const committed = decisionCommittedOf(out);
             noteLateSettleIfAccepted(committed);
-            return intent === undefined ? out : { ...out, rememberApplied: await intent.settle(committed) };
+            return {
+                ...out,
+                ...(intent !== undefined ? { rememberApplied: await intent.settle(committed) } : {}),
+                ...(ruleIntent !== undefined ? { ruleReceipt: await ruleIntent.settle(committed) } : {}),
+            };
         };
         const parkedForkQuotaDenial = req !== undefined ? ownerCostQuotaDenied(checkpointPartsOf(cp.scope)?.person) : undefined;
         if (parkedForkQuotaDenial)
@@ -771,7 +841,6 @@ export function createResumeLegs(ctx) {
         const legKey = createHash("sha256").update(String(token)).digest("hex");
         const streamApprovalOn = resolveStreamApprovalGate({
             toolApprovalEnabled: Boolean(deps.toolApproval),
-            streamApprovalEnabled: deps.config.streamApproval?.enabled === true,
             backend: deps.backend,
             checkpointStore: deps.checkpointStore,
         }).active;
@@ -797,7 +866,7 @@ export function createResumeLegs(ctx) {
         let legClaim;
         let engineHandedOff = false;
         let restored;
-        const cancelledInClaimWindow = () => restored?.kind === "ended" && restored.row?.errorCode === CANCELLED_CODE;
+        const claimWindowCancelRow = () => (restored?.kind === "ended" && restored.row?.errorCode === CANCELLED_CODE ? restored.row : undefined);
         if (args.mintFreshRun && taskId && deps.runStore) {
             return { status: 409, body: await buildActiveRunConflict({ runStore: deps.runStore, checkpointStore: deps.checkpointStore, governance: deps.config, turnActivity: readTurnActivityMs }, sessionId, taskId) };
         }
@@ -948,7 +1017,8 @@ export function createResumeLegs(ctx) {
                 if (placementReject) {
                     if (inflightRuns.get(claimedTask) === cancelCtrl)
                         inflightRuns.delete(claimedTask);
-                    return cancelledInClaimWindow() ? { status: 200, body: { taskId: claimedTask, sessionId, status: "failed", errorCode: "cancelled" } } : placementReject;
+                    const cancelledRow = claimWindowCancelRow();
+                    return cancelledRow !== undefined ? settledLegAnswer({ taskId: claimedTask, sessionId, plane: planeOfEndedRow(cancelledRow), reparked: false, evidence: NO_SETTLEMENT_EVIDENCE }) : placementReject;
                 }
             }
             markChildrenStoppedByUserOnAbort(cancelCtrl.signal, taskId, subject);
@@ -1433,16 +1503,19 @@ export function createResumeLegs(ctx) {
                 const disposition = resumeRefusalDisposition(e);
                 if (disposition === "cancelled") {
                     const abortedText = (await settleCardForCancel()) ? CARD_SETTLED_BY_CANCEL_MESSAGE : e.message;
+                    const handleCause = cancelCtrl.cause();
+                    if (handleCause === undefined)
+                        recordFailOpen("server.runs.abort-cause-missing", `task=${taskId ?? ""} arm=resume-aborted`);
+                    const c = mintCancelledResult({ taskId: taskId ?? "", sessionId, startedAtMs: resumeLegStartedAt, message: abortedText, cause: handleCause ?? "cancel_verb" });
+                    const cancelled = outwardPlane(c.terminal);
+                    let landed;
                     if (claimedRow && taskId && deps.runStore) {
-                        const handleCause = cancelCtrl.cause();
-                        if (handleCause === undefined)
-                            recordFailOpen("server.runs.abort-cause-missing", `task=${taskId} arm=resume-aborted`);
-                        const c = mintCancelledResult({ taskId, sessionId, startedAtMs: resumeLegStartedAt, message: abortedText, cause: handleCause ?? "cancel_verb" });
                         await cancelLedgerAppend?.("failed", buildCancelledLedgerRow(c)).catch((err) => recordFailOpen("server.runs.terminal-ledger-write-failed", `arm=resume-append-resume-aborted ${errorText(err)}`));
-                        await deps.runStore.setTerminal(taskId, "failed", c, abortedText).catch(() => undefined);
+                        await deps.runStore.setTerminal(taskId, "failed", c, cancelled.errorMessage ?? null).catch(() => undefined);
+                        landed = await landedTerminalRow(deps.runStore, taskId, "resume-aborted");
                     }
                     settleFleet("failed");
-                    return { status: 200, body: { taskId, sessionId, status: "failed", errorCode: "cancelled" } };
+                    return settledLegAnswer({ taskId, sessionId, plane: landed !== undefined ? planeOfEndedRow(landed) : cancelled, reparked: false, evidence: NO_SETTLEMENT_EVIDENCE });
                 }
                 const retriable = disposition === "retriable";
                 let reparkEnded = false;
@@ -1469,22 +1542,26 @@ export function createResumeLegs(ctx) {
             }
             const thrownCause = cancelCtrl.cause();
             if (thrownCause !== undefined) {
+                const c = mintCancelledResult({ taskId: taskId ?? "", sessionId, startedAtMs: resumeLegStartedAt, message: "cancelled by user", cause: thrownCause });
+                const cancelled = outwardPlane(c.terminal);
+                let landed;
                 if (taskId && deps.runStore) {
                     await voidHeldParkCard(heldPark, sessionId, deps.checkpointStore, "resume");
-                    const c = mintCancelledResult({ taskId, sessionId, startedAtMs: resumeLegStartedAt, message: "cancelled by user", cause: thrownCause });
                     await cancelLedgerAppend?.("failed", buildCancelledLedgerRow(c)).catch((err) => recordFailOpen("server.runs.terminal-ledger-write-failed", `arm=resume-append-thrown-cancel ${errorText(err)}`));
-                    await deps.runStore.setTerminal(taskId, "failed", c, "cancelled by user").catch(() => undefined);
+                    await deps.runStore.setTerminal(taskId, "failed", c, cancelled.errorMessage ?? null).catch(() => undefined);
+                    landed = await landedTerminalRow(deps.runStore, taskId, "thrown-cancel");
                 }
                 settleFleet("failed");
-                return { status: 200, body: { taskId, sessionId, status: "failed", errorCode: "cancelled" } };
+                return settledLegAnswer({ taskId, sessionId, plane: landed !== undefined ? planeOfEndedRow(landed) : cancelled, reparked: false, evidence: NO_SETTLEMENT_EVIDENCE });
             }
             if (!engineHandedOff && legClaim !== undefined) {
                 const claim = legClaim;
                 await withdrawClaim(deps, claim, `the resume could not be handed to the engine: ${outwardThrownMessage(e, errorText(e))}`, "faulted");
                 const parkedAgain = claim.kind === "resumed" && restored?.kind !== "ended";
                 settleFleet(parkedAgain ? reparkStatus : "failed");
-                if (cancelledInClaimWindow())
-                    return { status: 200, body: { taskId, sessionId, status: "failed", errorCode: "cancelled" } };
+                const cancelledRow = claimWindowCancelRow();
+                if (cancelledRow !== undefined)
+                    return settledLegAnswer({ taskId, sessionId, plane: planeOfEndedRow(cancelledRow), reparked: false, evidence: NO_SETTLEMENT_EVIDENCE });
                 return resumeClaimFaultAnswerOf(e);
             }
             const heldParkWord = heldPark === undefined ? undefined : heldParkOf(heldPark);
@@ -1539,20 +1616,13 @@ export function createResumeLegs(ctx) {
                 await deps.runStore.setTerminal(taskId, resumePlane.status, sealed, resumePlane.errorMessage ?? null);
         }
         settleFleet(parkEnded !== undefined ? "failed" : checkpointReopened ? reparkStatus : resumePlane.status, fleetRunResiduals(sealed, sealed ? failureCodeOf(sealed.terminal) : undefined));
-        const answered = parkEnded !== undefined
-            ? { status: parkEnded.row?.status ?? "failed", errorCode: parkEnded.row?.errorCode ?? undefined, errorMessage: parkEnded.row?.error ?? undefined }
-            : { status: resumePlane.status, errorCode: resumePlane.errorCode, errorMessage: resumePlane.errorMessage };
-        return {
-            status: 200,
-            body: {
-                taskId, sessionId, status: answered.status,
-                bindingEnforced: true,
-                ...(answered.errorCode ? { errorCode: answered.errorCode } : {}),
-                ...(answered.errorMessage ? { errorMessage: redactErrorMessage(answered.errorMessage) ?? "" } : {}),
-                ...(checkpointReopened && parkEnded === undefined ? { retriable: true } : {}),
-                ...buildSettlementEvidence({ at: "engine_terminal", commitment: args.commitment }),
-            },
-        };
+        return settledLegAnswer({
+            taskId,
+            sessionId,
+            plane: parkEnded !== undefined ? planeOfEndedRow(parkEnded.row) : resumePlane,
+            reparked: checkpointReopened && parkEnded === undefined,
+            evidence: buildSettlementEvidence({ at: "engine_terminal", commitment: args.commitment }),
+        });
     }
     async function mayDiscloseRowError(cs, token, decider) {
         if (decider === undefined || decider.operator)
@@ -1683,7 +1753,7 @@ export function createResumeLegs(ctx) {
             const { spec, engineNotices } = resolved;
             const hostSpec = { ...spec, objective };
             const out = await mintAndDriveDurableRun(routeCtxBase, deps.runStore, {
-                prepared: { spec: hostSpec, runner: resolved.runner, legFacts: resolved.legFacts, auth, body: ctx.body, ...(objectiveWithheldIn(ctx) ? { bodyFromScreenedCtx: true } : {}), seat: createSubmissionSeat({ deployment: deps.config }), acceptance: createRunAcceptance({}, { objective, screened: false }), peerLease: resolved.peerLease, execution: resolved.execution, ...(engineNotices.length > 0 ? { engineNotices } : {}) },
+                prepared: { spec: hostSpec, runner: resolved.runner, legFacts: resolved.legFacts, auth, body: ctx.body, ...(objectiveWithheldIn(ctx) ? { bodyFromScreenedCtx: true } : {}), bodyPermissionModeWrite: { stored: ctx.permissionModeWrite }, seat: createSubmissionSeat({ deployment: deps.config }), acceptance: createRunAcceptance({}, { objective, screened: false }), peerLease: resolved.peerLease, execution: resolved.execution, ...(engineNotices.length > 0 ? { engineNotices } : {}) },
                 fleetScope: resumeFleetScope(req, auth),
                 elicitOwner: subject ?? null,
                 source: "workflow_parked_decide",
@@ -1709,7 +1779,7 @@ export function createResumeLegs(ctx) {
         const token = (await cs.findPendingTokenBySession(sessionId, undefined, wakeBinding)) ?? (await cs.findPendingTokenBySession(sessionId));
         if (!token)
             return { status: 404, body: refusalBody({ errorCode: "not_found.parked_checkpoint", message: "no parked checkpoint for this session (nothing to wake)" }) };
-        const who = { subject: caller, operator: explicitOperatorOk(caller === undefined ? undefined : personOf(caller), deps.config) };
+        const who = { subject: caller, operator: explicitOperatorOk(caller === undefined ? undefined : personOf(caller), deps.config, "operate") };
         if (!who.operator) {
             const scope = await cs.peekPendingScope(sessionId, wakeBinding).then((s) => (s === undefined ? cs.peekPendingScope(sessionId) : s)).catch(() => undefined);
             if (!keyAdmits("scope.decide", who, scopeCellOf(scope ?? CHECKPOINT_PUBLIC_SCOPE))) {
@@ -2061,7 +2131,7 @@ export function createResumeLegs(ctx) {
             throw new Error("drivePlanReview: permissionModeAfter was passed for a task whose stored permission mode is not \"plan\" — the caller must refuse this before any state changes (see the plan_review route's pre-nonce gate)");
         }
         const approvedMode = planReviewDecisionExitsPlan(decision) && effMode === "plan" ? (permissionModeAfter ?? "default") : undefined;
-        const rebuildCtx = approvedMode === undefined ? ctx : { ...ctx, body: { ...ctx.body, permissionMode: approvedMode } };
+        const rebuildCtx = approvedMode === undefined ? ctx : withStoredPermissionMode(ctx, approvedMode, "plan_review");
         const resolved = await resolveResumeSpecOrBlocked(rebuildCtx, req, auth);
         if (!resolved.ok)
             return resolved.answer;

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

@@ -16,6 +16,7 @@
  */
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type { HostDecision } from "../host-decision.js";
+import type { Refusal } from "./refusal-body.js";
 import type { EntryProblem } from "../entry-problems.js";
 import type { SessionNotifyDoor } from "../session-notify-door.js";
 import type { TaskStream, TaskSpec, TaskResult, QuestionAnswer, Checkpoint, CheckpointToken, ResumeOutcome, RunInternals, Runner, EngineNotice, PendingSteerInput } from "@sema-agent/core";
@@ -26,7 +27,9 @@ import type { ImagesLocal } from "./routes/images.js";
 import type { CapabilitiesLocal } from "./routes/capabilities.js";
 import type { SessionsLocal } from "./routes/sessions.js";
 import type { SessionSyncLocal } from "./routes/session-sync.js";
+import type { OperatorPower } from "../operator-roster.js";
 import type { PlanApprovePermissionModeAfter } from "../task-settings.js";
+import type { PermissionModeWrite } from "../permission-mode-admission.js";
 import type { GateSighting } from "../approval-gate-currency.js";
 import type { VerifyRoundsSpec } from "./verify-rounds.js";
 import type { RunAbort } from "../run-cancel-context.js";
@@ -36,6 +39,7 @@ import type { RootedTaskSpec } from "./execution-context.js";
 import type { GateCommitment, GateSettlementEvidence } from "../gate-settlement.js";
 import type { ResumeRestatement } from "./resume-restatement.js";
 import type { RememberLaneCannotRecord } from "../parked-decide.js";
+import type { ParsedPersistRule, RuleSlotReceipt } from "../tool-approval.js";
 import type { RowWayOut } from "./resume-legs.js";
 import type { KeyCaller } from "../owner-faces.js";
 import type { Subject } from "../owner-brands.js";
@@ -156,6 +160,14 @@ export interface PreparedTaskSubmission {
      * 它能不能展示在它第一次落盘时就定了,这一跑的受理座答不了。缺席 = 体是这次请求自己的,标不标由受理座定。
      */
     bodyFromScreenedCtx?: true;
+    /**
+     * `body` 是从一份存量续跑输入里取回的(与 {@link bodyFromScreenedCtx} 同一种提交:`/decide` 的宿主新 turn)⇒ 这一跑新写的续跑输入**照抄**那一份的写据
+     * (`CheckpointCtx.permissionModeWrite`):这一跑没有写体顶层 `permissionMode` 那一格,只是抄了体。`stored` 缺席 = 那一份没有写据(7.152.0 之前写下的)⇒ 照缺席。
+     * 本位缺席 = 体是这次请求自己的 ⇒ 写据是提交写者的那一张(`submit-ctx.ts` `persistSubmissionCtx`)。
+     */
+    bodyPermissionModeWrite?: {
+        readonly stored: PermissionModeWrite | undefined;
+    };
     /**
      * 这次执行的**执行上下文**(唯一解析器 `http/execution-context.ts` `resolveExecutionContext` 的产物:根 · 住客 · 放置态 · 车道 · device 车道的设备意图)。
      * 提交门在装配之前铸(fresh);`/decide` 的宿主新 turn 交续跑折叠器铸的那一只(continuation)。每个 `runStore.createRun(` 成功点**必须**把它交给
@@ -237,6 +249,15 @@ export interface CheckpointCtx {
      * 形只有一种读法(`frozenMemorySeedOf`,读口 `resume-ctx-read.ts`)。
      */
     memorySeed?: import("../project-registry.js").MemorySeed | null;
+    /**
+     * **写据**:谁写了 `body` 顶层 `permissionMode` 那一格、写下的是什么(形与规则的属主 = `permission-mode-admission.ts` 顶注「写据」)。**服务端写、不来自请求体**
+     * (与 {@link unattendedLeg} 同为 `body` 的兄弟键,客户端够不着)。写点:`buildCheckpointCtx`(必填键:提交写口写 `submission`;`/decide` 宿主新 turn 照抄宿主那一行的,
+     * 见 {@link PreparedTaskSubmission.bodyPermissionModeWrite};leader worker 写 `submission`)与改写口 `withStoredPermissionMode`(切档 `switch` · 续跑口的钳 `replay` ·
+     * `plan_review` 出口 `plan_review`)。续跑腿的写回传原 ctx / 其展开 ⇒ 随行。读者只有一只:续跑口 `stampReplayEntryMode`(地板在场时问「这一格是不是这块地板的出口写下的、
+     * 且还是它写下的那一格」)。形只有一种读法(`permissionModeWriteOf`,读口 `resume-ctx-read.ts`:读不出 ⇒ 坏体)。
+     * 缺席 = 7.152.0 之前写下的行(不回填:没有证据可补),或从这样的行照抄的体 ⇒ 不是出口写的,地板在场时照钳。
+     */
+    permissionModeWrite?: PermissionModeWrite;
 }
 /**
  * `/decide` 第三条车道交给宿主投递腿(wake:`DriveResumeArgs` / fresh:`DurableRunLegArgs`)的**一件**:这一跑在内存里带着的决定,
@@ -489,7 +510,9 @@ export interface RouteLegs {
      *  同一属主判(缺席 ⇒ 恒不造键;判据属主=server.ts 铸键点注)。 */
     decider?: KeyCaller, 
     /** 续跑请求的重述键(`mcpServers` / `a2aPeers`),门读出并判过的那一份;缺席 = 冻结读法。语义属主 = `resume-restatement.ts` 顶注。 */
-    restatement?: ResumeRestatement): Promise<ResumeCheckpointOutcome>;
+    restatement?: ResumeRestatement, 
+    /** 这次决定带着「不再询问」请求({@link PersistRuleRequest})⇒ 本函数是它的**唯一铸点**,结局的 `ruleReceipt` 是它的回执({@link ResumeCheckpointOutcome})。 */
+    persistRule?: PersistRuleRequest): Promise<ResumeCheckpointOutcome>;
     /** 全 resume 家族的共同下半场(lease admission + 写 run log + fleet 发布)。 */
     driveResumeIntoRunLog(args: DriveResumeArgs): Promise<ResumeLegOutcome>;
     /** assistant 抢占腿的复位(gate-kind 守卫 + 行级属主复核 + 驱动)。 */
@@ -719,6 +742,12 @@ interface RouteDeclIdentity {
      * 不带它 —— 那条流就是 sync 腿本身(关流 = 断连语义),照旧算在飞。漏标一条订阅的方向是**多算在飞**(排空多等),不是少等。
      */
     readonly subscription?: true;
+    /**
+     * 「本路由对持这只运维权力的**非人档**开放;本口的运维门按它判」(档表 `operator-roster.ts`)。缺席 = 没声明 —— 非人档(服务主体)的身份在本路由上不算数,
+     * 分派层整次请求 403 `auth.principal_confined`(`principal-gate.ts` 的 `requestConfinedTier`,只扫带本列的行)。只住在可分派行上(纯门行是前缀、比任何路由都宽,
+     * 型上就开不出一段前缀的权力)。今天只有排空口声明 `power: "drain"`。
+     */
+    readonly power?: OperatorPower;
 }
 /**
  * **可分派行**:一条真路由。匹配式二选一 —— `path`(精确;标签**就是** path 自身,所以没有 label 列,
@@ -760,23 +789,60 @@ export interface ResumeLegOutcome {
     body: object;
 }
 /**
- * 「本会话不再询问」的请求 —— **两扇门同一只**:`/decide` 体上的 `remember:"session"`、应答口(`POST /v1/tool-approvals/:id/respond`)命中停驻行的
- * `allow_session`。铸点只有一只:{@link RouteLegs.resumeCheckpoint} —— 可记与否从**已属主校验的载入停驻行**判(`standingAnswerDurablyRecordable`,
+ * 「本会话不再询问」的请求 —— **两扇门同一只**:`/decide` 体上的 `remember:"session"`、决断口(`POST /v1/tasks/:taskId/asks/:askId/decision`)命中停驻行的
+ * `remember:"session"`。铸点只有一只:{@link RouteLegs.resumeCheckpoint} —— 可记与否从**已属主校验的载入停驻行**判(`standingAnswerDurablyRecordable`,
  * 与运维队列行的 `rememberRefused` 同一只判据)、锚由车道定(任务级 = 这个会话;bg 停驻子代 = 行的 root/host 会话)、落豁免店**只在**这次决定
  * 被证明已结清之后(`decisionCommittedOf`)、`rememberApplied` = 落没落(店抛 ⇒ `false` + warn,这次的放行不回滚)。门自己不写店、不判可记。
  * 两口唯一的差 = `laneCannotRecord`(记不住的车道上怎么答;闭集与理由的属主 = `parked-decide.ts` 的 {@link RememberLaneCannotRecord})。
  */
 export interface RememberSessionRequest {
-    /** 豁免行的签发人(`grantedBy`)= 门已验的身份(`/decide` 的决断方 / 应答口的调用方);匿名开放部署 ⇒ `null`。 */
+    /** 豁免行的签发人(`grantedBy`)= 门已验的身份(`/decide` 的决断方 / 决断口的调用方);匿名开放部署 ⇒ `null`。 */
     readonly grantedBy: string | null;
     readonly laneCannotRecord: RememberLaneCannotRecord;
 }
-/** {@link RouteLegs.resumeCheckpoint} 的结局 = 腿的应答 + 带了「本会话放行」请求时铸点的答(`rememberApplied`:落没落)。键只在证得出提交的两条车道
- *  (bg 停驻子代赎回 / 任务级续跑)的结清点上铸;其余出口(拒 / workflow 投递 / 抛)键缺席 ⇒ 门读作「没记住」(`=== true`)。
- *  这一位是进程内的结局位,不进 `body` —— 由门决定挂不挂到回执上(两扇门都只挂在这次真做了授予判定的回执上;幂等回放不挂)。 */
+/**
+ * 决定体上「本会话放行」那一键(`remember`)的**唯一读法** —— 两扇人决口同调:有问行的卡的决断口(`POST /v1/tasks/:taskId/asks/:askId/decision`)与
+ * 运维队列的耐久门(`POST /v1/approvals/:sessionId/decide`)。闭集一词 `"session"`;只配 `approve`(「记住的拒」是另一种语义,不从这一键带进来)。
+ * 拒句与码两口逐字同一(由本读法铸);各口自己的门(直连门的签名覆盖、豁免店在场)在本读法之后各判各的。
+ * 拒 = 一只 {@link Refusal}(码 + 句 + 机读位在本读法一处铸,冲突形的机读位随拒同铸),两扇口原样发 `400`、不再按码二次分支。
+ */
+export type RememberSlotReading = {
+    readonly kind: "absent";
+} | {
+    readonly kind: "session";
+} | {
+    readonly kind: "refused";
+    readonly refusal: Refusal;
+};
+/** `remember` 闭集外的拒句(`400 request.field_invalid`;两扇人决口同一句,由 {@link readRememberSlot} 铸)。 */
+export declare const REMEMBER_MUST_BE_SESSION = "remember must be \"session\"";
+/** `remember` 配 deny 的拒句(`400 request.field_conflict` + 机读位 `remember_decision`;同上)。 */
+export declare const REMEMBER_REQUIRES_APPROVE = "remember requires decision 'approve'";
+export declare function readRememberSlot(raw: unknown, decision: "approve" | "deny"): RememberSlotReading;
+/**
+ * 「不再询问」的请求 —— **两扇门同一只**(「本会话放行」{@link RememberSessionRequest} 的孪生):`/decide` 体上的 `persistRule`、赎回席交来的那一问(活卡回决口
+ * 命中停驻行时卡上的 `persistRule`)。体形判官只有一只(`tool-approval.ts` 的 `readPersistRuleSlot`)。铸点只有一只:{@link RouteLegs.resumeCheckpoint} 在已属主
+ * 校验的载入停驻行上读这张卡的记录(有问行读问行,没有读停驻行),在结清点(`landAfterCommit`,与「本会话放行」同一读 `decisionCommittedOf`)交唯一兑付函数
+ * `redeemCardRule`。证不出提交 ⇒ 不兑,回执 `rulePersisted:false` + `rule_lane_unavailable`;**不 400**:规则位的成文律是「裁决本身绝不因规则没存上而改判」
+ * (与 `remember` 在 `/decide` 上「硬意图键,记不住就 400」刻意不同 —— 两个键各守各的成文律)。
+ */
+export interface PersistRuleRequest {
+    readonly slot: ParsedPersistRule;
+    /** 这次决定带了 `updatedInput`(编辑放行)⇒ 兑付答 `rule_input_edited`:生效的是编辑后的调用,候选是从原始命令铸的。 */
+    readonly inputWasEdited: boolean;
+}
+/** {@link RouteLegs.resumeCheckpoint} 的结局 = 腿的应答 + 带了「本会话放行」请求时铸点的答(`rememberApplied`:落没落)+ 带了「不再询问」请求时铸点的回执(`ruleReceipt`)。
+ *  两位只在证得出提交的两条车道(bg 停驻子代赎回 / 任务级续跑)的结清点上铸;其余出口(拒 / workflow 投递 / 抛)缺席 ⇒ 门读作「没记住」(`=== true`)/ 规则位
+ *  由 {@link ruleReceiptOf} 补成「没存上」。两位都是进程内的结局位,不进 `body` —— 由门挂到这次真做了授予判定的回执上(幂等回放不挂)。 */
 export type ResumeCheckpointOutcome = ResumeLegOutcome & {
     readonly rememberApplied?: boolean;
+    readonly ruleReceipt?: RuleSlotReceipt;
 };
+/**
+ * 一次带了 `persistRule` 的续跑在回执上的规则位(两扇门同调这一只:`/decide` 与赎回席)—— 结清点铸了就是它;没铸(不经结清点的出口:workflow 投递 / 证不出提交)
+ * ⇒ `rulePersisted:false` + `rule_lane_unavailable`(「请求带了、结局没答」只在这里补一处)。没带 ⇒ `undefined`(一个键都不加)。只在 2xx 上挂(调用方判)。
+ */
+export declare function ruleReceiptOf(out: ResumeCheckpointOutcome, persistRule: PersistRuleRequest | undefined): RuleSlotReceipt | undefined;
 /**
  * **「决定/续跑已受理」那一枚 200 收据的单一铸点**([ref])。
  *

package/dist/http/route-ctx.js

@@ -1,4 +1,5 @@
 import { sendJson } from "./send.js";
+import { fieldConflictFacts } from "../field-conflict.js";
 export function noteResumeClientGone(res, out, logger) {
     if (out.status !== 200 || out.body.status !== "resuming")
         return;
@@ -21,6 +22,22 @@ export function assertNever(x) {
     throw new Error(`unreachable route id: ${String(x)}`);
 }
 export const ROUTE_METHOD_ORDER = ["GET", "POST", "PUT", "PATCH", "DELETE"];
+export const REMEMBER_MUST_BE_SESSION = `remember must be "session"`;
+export const REMEMBER_REQUIRES_APPROVE = "remember requires decision 'approve'";
+export function readRememberSlot(raw, decision) {
+    if (raw === undefined)
+        return { kind: "absent" };
+    if (raw !== "session")
+        return { kind: "refused", refusal: { errorCode: "request.field_invalid", message: REMEMBER_MUST_BE_SESSION } };
+    if (decision !== "approve")
+        return { kind: "refused", refusal: { errorCode: "request.field_conflict", message: REMEMBER_REQUIRES_APPROVE, facts: fieldConflictFacts("remember_decision", ["remember", "decision"]) } };
+    return { kind: "session" };
+}
+export function ruleReceiptOf(out, persistRule) {
+    if (persistRule === undefined)
+        return undefined;
+    return out.ruleReceipt ?? { rulePersisted: false, ruleRefusal: "rule_lane_unavailable" };
+}
 export function acceptedResumingReceipt(taskId, sessionId, evidence) {
     return { status: 200, body: { taskId, sessionId, status: "resuming", bindingEnforced: true, ...evidence } };
 }

package/dist/http/route-table.d.ts

@@ -55,6 +55,7 @@ import type { FlatServiceDeps } from "./server.js";
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type { RouteDecl, RouteDispatchDecl, RouteMatch, RouteCtx, RouteMethod } from "./route-ctx.js";
 import type { BillableKind } from "./readiness.js";
+import type { OperatorPower } from "../operator-roster.js";
 /** 一只域 handler 相对**全局服务凭据门**的位置。门前 = 未鉴权可达(每一只都要单独论证),门后 = 先过凭据。 */
 /**
  * 一行路由在全局服务凭据门的哪一侧、吃哪道门(闭集,三员;[ref] 起由两员拆成三员):
@@ -144,6 +145,9 @@ export declare function isCredentialGatedRewrite(method: string, url: string): b
 /** [ref]:这次请求是不是一条**只读订阅**(`RouteDeclFacts.subscription` 那一列;方法也要对上 —— 订阅行恒只认 GET)。
  *  分派器在 admission 那一拍(第一个 await 之前)同步判它:订阅不进在飞计数,只进附着集与订阅集。 */
 export declare function isSubscriptionRequest(method: string, url: string): boolean;
+/** 这次请求(方法 + 路径)命中的那一行声明的运维权力(声明行的 `power` 列;`undefined` = 没命中任何带 `power` 的行)—— 分派层的圈禁判只读这一只
+ *  (`principal-gate.ts` 的 `requestConfinedTier`)。方法也要对上:路径命中而方法不在列的请求对非人档同答圈禁(不再区分 404 / 405)。 */
+export declare function declaredPowerOf(method: string, url: string): OperatorPower | undefined;
 /** 见 `RouteDeclFacts.methodDispatched` 的头注(单 URL 多方法端点)。 */
 export declare function isMethodDispatchedSubmitPath(url: string): boolean;
 /** 一次分派查找的结果:命中的行与它的参数,外加**这条路径上所有行**的方法并集(405 的 `Allow`)。 */