@sema-agent/server 7.139.0 → 7.141.0

package/dist/http/resume-legs.js

@@ -1,15 +1,16 @@
 import { redactErrorMessage, redactHead } from "../observability/run-terminal.js";
 import { createHash } from "node:crypto";
-import { uuidv7, resumeWithVerification, CheckpointError, defaultTaskRegistry, taskNotificationDedupKey, validatePendingSteer, GLOBAL_USAGE_KEY, PAUSE_REGISTRY } from "@sema-agent/core";
+import { uuidv7, resumeWithVerification, CheckpointError, defaultTaskRegistry, taskNotificationDedupKey, validatePendingSteer, GLOBAL_USAGE_KEY } from "@sema-agent/core";
 import { decideParkedAgent, denyWorkflowParkForked, denyWorkflowParksUnreadable, findParkOrigin, heldWorkflowParkDecisions, planWorkflowParkedDecide } from "../parked-decide.js";
 import { parkDecisionFingerprint } from "../orchestration/workflow-park-decision.js";
 import { headReadOf } from "../session-incarnation.js";
 import { createSessionWorkspaceRecorder, legSessionWitnessOf, 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, decodeCheckpointScope, CHECKPOINT_PUBLIC_SCOPE } from "../security.js";
-import { graftParkToolCallId, parkToolCallId, TurnAnchorCapture, HEARTBEAT_MS, markChildrenStoppedByUserOnAbort } from "../runs.js";
-import { failureCodeOf, nestedPauseOf, sealResultForExit, outwardPlane } from "../terminal.js";
-import { buildCancelledLedgerRow, createRunAbort, mintCancelledResult } from "../run-cancel-context.js";
+import { graftParkToolCallId, parkToolCallId, TurnAnchorCapture, HEARTBEAT_MS, markChildrenStoppedByUserOnAbort, voidHeldParkCard } from "../runs.js";
+import { atHostBoundary, failureCodeOf, nestedPauseOf, sealResultForExit, outwardPlane } from "../terminal.js";
+import { voidVerifierPauseCard } from "../verifier-pause-card.js";
+import { buildCancelledLedgerRow, CARD_SETTLED_BY_CANCEL_MESSAGE, createRunAbort, mintCancelledResult, withCardSettledByCancelMessage } from "../run-cancel-context.js";
 import { isTerminalRunStatus } from "../plugins/store-contracts.js";
 import { readTurnActivityMs, recordTurnActivity } from "../turn-activity.js";
 import { recordResumeResourceWindow } from "../resource-window.js";
@@ -51,6 +52,7 @@ import { commitExecutionContext, isRootSessionGoneError, resolveExecutionContext
 import { commitSessionInheritEnv } from "./session-inherit-env.js";
 import { ASK_USER_QUESTION_TOOL_NAME, isApprovalGateKind, isEngineQuestionRow } from "../approval-content-kind.js";
 import { deploymentListAsks } from "../approval.js";
+import { isParkLedgerEventType } from "../trace/ledger-events.js";
 import { readResumeCtx, resumeCtxCorruptAnswer, resumeCtxUnsealableAnswer } from "./resume-ctx-read.js";
 import { buildCheckpointVersionKeys, resumeBlockedByPolicyAnswer, resumeRefusalWithCard, sealCheckpointCtx, storedBodyReplayAnswer, storedBodyReplayLogFields, withPermissionModeRewritten } from "./checkpoint-ctx.js";
 import { refusalBody, resumeRefusalFacts } from "./refusal-body.js";
@@ -61,12 +63,6 @@ import { fieldConflictFacts } from "../field-conflict.js";
 function legMayHaveReopenedCheckpoint(r) {
     return r.terminal.kind === "failed" && nestedPauseOf(r.terminal) === undefined;
 }
-function nestedParkStatusOf(r) {
-    const paused = nestedPauseOf(r.terminal);
-    if (paused === undefined)
-        return undefined;
-    return PAUSE_REGISTRY[paused.gate.kind].taskStatus;
-}
 const WORKER_SWAP_REDEEMABLE = {
     version_newer: true,
     env_factory_missing: true,
@@ -684,6 +680,7 @@ export function createResumeLegs(ctx) {
             fleetPub?.onTerminal(status, residuals);
         };
         let result;
+        let heldPark;
         let reopenConfirmedPark = false;
         const confirmCheckpointReopened = async () => {
             const store = deps.checkpointStore;
@@ -700,28 +697,32 @@ export function createResumeLegs(ctx) {
         const settleCardForCancel = async () => {
             const cs2 = deps.checkpointStore;
             if (!cs2)
-                return;
+                return false;
             try {
                 const live = await cs2.get(token);
-                if (live?.status === "pending" && !(await cs2.expire(token, live.scope))) {
-                    deps.logger?.warn?.("resume_cancel_checkpoint_settle_lost", { taskId, sessionId });
-                }
+                if (live?.status !== "pending")
+                    return false;
+                if (await cs2.expire(token, live.scope))
+                    return true;
+                deps.logger?.warn?.("resume_cancel_checkpoint_settle_lost", { taskId, sessionId });
+                return false;
             }
             catch (cancelSettleErr) {
                 deps.logger?.warn?.("resume_cancel_checkpoint_settle_failed", {
                     taskId, sessionId, err: cancelSettleErr instanceof Error ? cancelSettleErr.message : String(cancelSettleErr),
                 });
+                return false;
             }
         };
         const reopenedAfterLeg = async (leg, cancelledAtDone) => {
             if (freshRunClaimed || !legMayHaveReopenedCheckpoint(leg))
-                return false;
+                return { reopened: false, leg };
             const pending = cancelledAtDone ? false : await confirmCheckpointReopened();
             if (cancelledAtDone || cancelCtrl.cause() !== undefined) {
-                await settleCardForCancel();
-                return false;
+                const expired = await settleCardForCancel();
+                return { reopened: false, leg: expired ? withCardSettledByCancelMessage(leg) : leg };
             }
-            return pending;
+            return { reopened: pending, leg };
         };
         let resumeHeartbeat;
         let resumeManifestLease = 0;
@@ -855,13 +856,18 @@ export function createResumeLegs(ctx) {
                     resumeLegLive = true;
                     const vrEngine = await resumeWithVerification(legRunner, token, outcome, { ...resumeTaskConfig, signal: cancelCtrl.signal, preemptSignal: preemptCtrl.signal }, resumeObjective, verifyRounds, verifyInternals);
                     const vrCause = cancelCtrl.cause();
-                    const vr = vrCause !== undefined && taskId !== undefined ? mintCancelledResult({ taskId, sessionId, startedAtMs: resumeLegStartedAt, message: "cancelled by user", engineResult: vrEngine, cause: vrCause }) : vrEngine;
+                    await voidVerifierPauseCard(vrEngine, deps.checkpointStore);
+                    const vrJudged = atHostBoundary(vrEngine, sessionId);
+                    if (vrJudged.terminal.kind === "paused")
+                        heldPark = vrJudged;
+                    const vrMinted = vrCause !== undefined && taskId !== undefined ? mintCancelledResult({ taskId, sessionId, startedAtMs: resumeLegStartedAt, message: "cancelled by user", engineResult: vrJudged, cause: vrCause }) : vrJudged;
                     await commitResumeCtx();
+                    const { reopened: vrReopened, leg: vr } = await reopenedAfterLeg(vrMinted, vrCause !== undefined);
                     let safe = sealResultForExit(vr);
-                    const vrNested = nestedPauseOf(vr.terminal);
-                    const reParkStatus = nestedParkStatusOf(vr);
-                    const reSuspended = vrNested !== undefined;
-                    const vrReopened = await reopenedAfterLeg(vr, vrCause !== undefined);
+                    const vrPaused = vr.terminal.kind === "paused" ? vr.terminal : undefined;
+                    const vrParkWord = vrPaused !== undefined ? outwardPlane(vrPaused).status : undefined;
+                    const reParkEvent = vrParkWord !== undefined && isParkLedgerEventType(vrParkWord) ? vrParkWord : undefined;
+                    const reSuspended = reParkEvent !== undefined;
                     if (vrReopened)
                         reopenConfirmedPark = true;
                     if (taskId && deps.runStore) {
@@ -871,8 +877,8 @@ export function createResumeLegs(ctx) {
                             await appendPromptManifest(ap, deps.promptManifests, taskId);
                             if (reSuspended || vrReopened) {
                                 await appendModelUsageDelta(ap, deps.modelUsage, taskId);
-                                const vrParkCallId = vrNested !== undefined ? await parkToolCallId({ terminal: vrNested }, deps.checkpointStore) : undefined;
-                                await ap(reParkStatus ?? reparkStatus, parkEventData({ terminal: vrNested, ...(vrParkCallId !== undefined ? { toolCallId: vrParkCallId } : {}) }, vrReopened ? (failureCodeOf(vr.terminal) ?? null) : undefined));
+                                const vrParkCallId = reSuspended ? await parkToolCallId(vr, deps.checkpointStore) : undefined;
+                                await ap(reParkEvent ?? reparkStatus, parkEventData({ terminal: vrPaused, ...(vrParkCallId !== undefined ? { toolCallId: vrParkCallId } : {}) }, vrReopened ? (failureCodeOf(vr.terminal) ?? null) : undefined));
                             }
                             else {
                                 safe = await attachModelUsage(safe, { append: ap, getEvents: (id, a) => rs2.getEvents(id, a), modelUsage: deps.modelUsage, taskId });
@@ -884,8 +890,8 @@ export function createResumeLegs(ctx) {
                                 throw e;
                         }
                     }
-                    if (vrNested !== undefined)
-                        return { ...safe, terminal: vrNested };
+                    if (reSuspended)
+                        return safe;
                     if (vr.verification?.verdict)
                         deps.metrics?.inc("verifications_total", { verdict: vr.verification.verdict });
                     return safe;
@@ -919,7 +925,7 @@ export function createResumeLegs(ctx) {
                 const captureUserMessageAnchor = deps.resumeAnchorStore && taskId
                     ? async (entryId) => { await deps.resumeAnchorStore.put(sessionId, taskId, entryId, anchorOwner); }
                     : undefined;
-                const anchor = new TurnAnchorCapture(captureTurnAnchor, () => deps.metrics?.inc("resume_anchor_capture_failed"), captureUserMessageAnchor);
+                const anchor = new TurnAnchorCapture(captureTurnAnchor, "resume", captureUserMessageAnchor);
                 const flush = async () => {
                     if (reasoning) {
                         await append("reasoning", modelTextEventData({ text: reasoning, eventId: reasoningEventId }));
@@ -1000,15 +1006,18 @@ export function createResumeLegs(ctx) {
                         for await (const ev of stream)
                             await resumeWorkspace.observe(ev);
                         const rNoRow = await stream.result();
-                        if (await reopenedAfterLeg(rNoRow, cancelCtrl.cause() !== undefined))
+                        const noRowLeg = await reopenedAfterLeg(rNoRow, cancelCtrl.cause() !== undefined);
+                        if (noRowLeg.reopened)
                             reopenConfirmedPark = true;
-                        return sealResultForExit(rNoRow);
+                        return sealResultForExit(noRowLeg.leg);
                     }
                     onAccepted?.(acceptedResumingReceipt(taskId, sessionId, buildSettlementEvidence({ at: "engine_accepted", commitment: args.commitment })));
                     let causeAtDone;
                     for await (const ev of stream) {
                         if (ev.type === "done")
                             causeAtDone = cancelCtrl.cause();
+                        if (ev.type === "done" && ev.result.terminal.kind === "paused")
+                            heldPark = ev.result;
                         recordTurnActivity(taskId);
                         fleetPub?.onEvent(ev);
                         await deps.userInputLedger?.observeLegEvent(stream, ev);
@@ -1128,6 +1137,8 @@ export function createResumeLegs(ctx) {
                     await flush();
                     const rEngine = await stream.result();
                     const r = causeAtDone !== undefined ? mintCancelledResult({ taskId, sessionId, startedAtMs: resumeLegStartedAt, message: "cancelled by user", engineResult: rEngine, cause: causeAtDone }) : rEngine;
+                    if (r.terminal.kind === "paused")
+                        heldPark = r;
                     const rPark = r.terminal.kind === "paused" ? outwardPlane(r.terminal).status : undefined;
                     if (rPark === "suspended") {
                         await append("suspended", parkEventData(await graftParkToolCallId(r, deps.checkpointStore)));
@@ -1139,7 +1150,8 @@ export function createResumeLegs(ctx) {
                         await appendModelUsageDelta(append, deps.modelUsage, taskId);
                         return r;
                     }
-                    if (await reopenedAfterLeg(r, causeAtDone !== undefined)) {
+                    const settledLeg = await reopenedAfterLeg(r, causeAtDone !== undefined);
+                    if (settledLeg.reopened) {
                         reopenConfirmedPark = true;
                         try {
                             await append(reparkStatus, parkEventData(r, failureCodeOf(r.terminal) ?? null));
@@ -1149,7 +1161,7 @@ export function createResumeLegs(ctx) {
                         }
                         return r;
                     }
-                    const safe = await attachModelUsage(sealResultForExit(r), { append, getEvents: (id, a) => rs.getEvents(id, a), modelUsage: deps.modelUsage, taskId });
+                    const safe = await attachModelUsage(sealResultForExit(settledLeg.leg), { append, getEvents: (id, a) => rs.getEvents(id, a), modelUsage: deps.modelUsage, taskId });
                     await append("done", { result: safe });
                     if (taskConfig.suggestNextPrompts && safe.terminal.kind === "completed") {
                         const suggestions = await stream.suggestions().catch(() => []);
@@ -1187,14 +1199,14 @@ export function createResumeLegs(ctx) {
             if (e instanceof CheckpointError) {
                 const disposition = resumeRefusalDisposition(e);
                 if (disposition === "cancelled") {
-                    await settleCardForCancel();
+                    const abortedText = (await settleCardForCancel()) ? CARD_SETTLED_BY_CANCEL_MESSAGE : e.message;
                     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: e.message, cause: handleCause ?? "cancel_verb" });
+                        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, e.message).catch(() => undefined);
+                        await deps.runStore.setTerminal(taskId, "failed", c, abortedText).catch(() => undefined);
                     }
                     settleFleet("failed");
                     return { status: 200, body: { taskId, sessionId, status: "failed", errorCode: "cancelled" } };
@@ -1222,6 +1234,7 @@ export function createResumeLegs(ctx) {
             const thrownCause = cancelCtrl.cause();
             if (thrownCause !== undefined) {
                 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);
@@ -1230,6 +1243,7 @@ export function createResumeLegs(ctx) {
                 return { status: 200, body: { taskId, sessionId, status: "failed", errorCode: "cancelled" } };
             }
             if (claimedRow && taskId && deps.runStore) {
+                await voidHeldParkCard(heldPark, sessionId, deps.checkpointStore, "resume");
                 await deps.runStore.setTerminal(taskId, "failed", null, errorText(e)).catch(() => undefined);
             }
             settleFleet("failed");

package/dist/http/retired-service-deps.d.ts

@@ -22,7 +22,7 @@ export interface RetiredServiceDep {
 export declare const RETIRED_SERVICE_DEPS: {
     readonly sqlEngineFacts: {
         readonly retiredIn: "7.132.0";
-        readonly wayOut: "replaced by sqlEngine — pass the SQL pool's engine reading as sqlEngine: `{ dialect: \"tidb\" | \"pg\", facts }` where `facts` is read live (a getter) and is null while the pool's connection setup has not succeeded, or leave both unset when there is no SQL store";
+        readonly wayOut: "replaced by sqlEngine — pass the SQL pool's engine reading as sqlEngine: `{ dialect: \"mysql\" | \"pg\", facts }` where `facts` is read live (a getter) and is null while the pool's connection setup has not succeeded, or leave both unset when there is no SQL store";
     };
     readonly snapshotBlobSqlCapBytes: {
         readonly retiredIn: "7.132.0";

package/dist/http/retired-service-deps.js

@@ -2,7 +2,7 @@ const BLOB_CAP_WAY_OUT = "the HTTP surface no longer holds a blob cap of its own
 export const RETIRED_SERVICE_DEPS = {
     sqlEngineFacts: {
         retiredIn: "7.132.0",
-        wayOut: "replaced by sqlEngine — pass the SQL pool's engine reading as sqlEngine: `{ dialect: \"tidb\" | \"pg\", facts }` where `facts` is read live (a getter) and is null while the pool's connection setup has not succeeded, or leave both unset when there is no SQL store",
+        wayOut: "replaced by sqlEngine — pass the SQL pool's engine reading as sqlEngine: `{ dialect: \"mysql\" | \"pg\", facts }` where `facts` is read live (a getter) and is null while the pool's connection setup has not succeeded, or leave both unset when there is no SQL store",
     },
     snapshotBlobSqlCapBytes: { retiredIn: "7.132.0", wayOut: BLOB_CAP_WAY_OUT },
     snapshotBlobSqlCap: { retiredIn: "7.133.0", wayOut: BLOB_CAP_WAY_OUT },

package/dist/http/route-table.js

@@ -29,6 +29,7 @@ import { handleNotifyWake, NOTIFY_WAKE_ROUTES } from "./routes/notify-wake.js";
 import { handleApprovalsAssistant, APPROVALS_ASSISTANT_ROUTES } from "./routes/approvals-assistant.js";
 import { handleRuns, handleRunVerbs, RUNS_ROUTES, RUN_VERBS_ROUTES } from "./routes/runs.js";
 import { handleRunMemoryCapture, RUN_MEMORY_CAPTURE_ROUTES } from "./routes/run-memory-capture.js";
+import { handlePermissionMode, RUN_PERMISSION_MODE_ROUTES } from "./routes/run-permission-mode.js";
 import { handleMcpReconnect, MCP_RECONNECT_ROUTES } from "./routes/mcp-reconnect.js";
 import { handleBackground, BACKGROUND_ROUTES } from "./routes/background.js";
 import { handleSideQuery, SIDE_QUERY_ROUTES } from "./routes/side-query.js";
@@ -51,6 +52,7 @@ export const ROUTES = [
     row({ handler: handleWorkflowAgentSteer, decls: WORKFLOW_AGENT_STEER_ROUTES, position: "post-credential", label: "workflow-agent-steer" }),
     row({ handler: handleRunVerbs, decls: RUN_VERBS_ROUTES, position: "post-credential", label: "run-verbs" }),
     row({ handler: handleRunMemoryCapture, decls: RUN_MEMORY_CAPTURE_ROUTES, position: "post-credential", label: "run-memory-capture" }),
+    row({ handler: handlePermissionMode, decls: RUN_PERMISSION_MODE_ROUTES, position: "post-credential", label: "permission-mode" }),
     row({ handler: handleMcpReconnect, decls: MCP_RECONNECT_ROUTES, position: "post-credential", label: "mcp-reconnect" }),
     row({ handler: handleBackground, decls: BACKGROUND_ROUTES, position: "post-credential", label: "background" }),
     row({ handler: handleLeader, decls: LEADER_ROUTES, position: "post-credential", label: "leader" }),

package/dist/http/routes/adoption.js

@@ -69,7 +69,7 @@ export async function handleAdoption(req, res, match, ctx) {
         }
     }
     const store = fact.backend.adoptionLog();
-    const runner = createAdoptionRunner({ store, dialect: deps.backend?.kind === "pg" ? "pg" : "tidb", now: Date.now, logger: deps.logger });
+    const runner = createAdoptionRunner({ store, dialect: deps.backend?.kind === "pg" ? "pg" : "mysql", now: Date.now, logger: deps.logger });
     switch (match.decl.id) {
         case "adoption-detail": {
             const id = ctx.helpers.safeDecode(match.params.id);

package/dist/http/routes/approvals-assistant.js

@@ -408,6 +408,7 @@ export async function handleApprovalsAssistant(req, res, match, ctx) {
                     ...(s.mandate !== undefined ? { mandate: s.mandate } : {}),
                     ...(s.denialLimitFallback !== undefined ? { denialLimitFallback: s.denialLimitFallback } : {}),
                     ...(s.origin !== undefined ? { origin: s.origin } : {}),
+                    ...(s.boundGrantDigest !== undefined ? { boundGrantDigest: s.boundGrantDigest } : {}),
                     ...skillCardFacts(s),
                     ...(s.boundGrantAbsence !== undefined ? { boundGrantAbsence: s.boundGrantAbsence } : {}),
                     objective,

package/dist/http/routes/capabilities.js

@@ -24,7 +24,7 @@ import { projectStoreCapability } from "../../store-posture.js";
 import { projectWebSearchCapability } from "../../plugins/web-search.js";
 import { projectExecutionLaneCapability } from "../../capabilities/execution-lane.js";
 import { judgeSandboxGitPlane, sandboxGitPlanePremisesOf } from "../../sandbox-git-plane.js";
-import { MCP_ASSERTION_HEADER_SENT } from "../../mcp-assertion-header.js";
+import { MCP_ASSERTION_HEADER_SENT, MCP_REQUEST_TRANSPORT_KINDS } from "../../mcp-assertion-header.js";
 import { gateCompositeMembers } from "../../capabilities/composite-members.js";
 import { projectApprovalsStreamLiveCapability } from "../../capabilities/approvals-push.js";
 import { workflowModelAllowlistFor } from "../../task-workflow.js";
@@ -96,7 +96,7 @@ export async function handleCapabilities(req, res, match, ctx) {
                         maxInflightPerDevice: deps.config.remoteExec?.provider === "device" ? (deps.config.remoteExec.maxInflightPerDevice ?? 4) : 4,
                         wsPath: DEVICE_WS_PATH,
                         management: facts.deviceManagement(deps).available,
-                        ...(deps.config.remoteExec?.provider === "device" && deps.config.remoteExec.relayUrl !== undefined ? { relayUrl: deps.config.remoteExec.relayUrl } : {}),
+                        ...(deps.config.remoteExec?.provider === "device" && deps.config.remoteExec.relay.kind === "url" ? { relayUrl: deps.config.remoteExec.relay.url } : {}),
                     }
                     : false,
                 sessionEvents: facts.sessionEventStream(deps).available,
@@ -133,7 +133,7 @@ export async function handleCapabilities(req, res, match, ctx) {
                 oneShot: true,
                 policy: true,
                 usage: Boolean(deps.costQuota),
-                permissionModeWrite: false,
+                permissionModeWrite: facts.permissionModeWrite(deps).available,
                 modelSelection: true,
                 effortSelection: true,
                 toolOutput: true,
@@ -143,7 +143,7 @@ export async function handleCapabilities(req, res, match, ctx) {
                 subagentSteer: facts.subagentSteer(deps).available,
                 subagentResume: facts.subagentSteer(deps).available,
                 taskSettings: { permissions: true, permissionMode: true, model: true, outputStyle: true, env: DEPLOYMENT_SHAPE_PREDICATES.callerCwd.holds(deps.config), hooks: taskHooksHonored(deps.config), pluginHooks: taskHooksHonored(deps.config), managedHookGroups: taskHooksHonored(deps.config), tightenOnlySeats: true, approvalFrameFamilies: true },
-                settings: { permissions: { allowGrant: true, allowLayer: true, callerTrust: callerTrust(req, deps.config).trust } },
+                settings: { permissions: { allowGrant: true, allowLayer: true, layers: true, callerTrust: callerTrust(req, deps.config).trust } },
                 permissionModeAuto: {
                     accepted: true,
                     classifierSeat: deps.autoModeFace?.seatMounted === true,
@@ -181,6 +181,7 @@ export async function handleCapabilities(req, res, match, ctx) {
                 mcp: true,
                 mcpProbe: true,
                 mcpAssertionHeaderSent: MCP_ASSERTION_HEADER_SENT,
+                mcpTransportKinds: [...MCP_REQUEST_TRANSPORT_KINDS],
                 mcpElicitation: facts.elicitation(deps).available,
                 askUserQuestion: facts.askUserQuestion(deps).available,
                 toolApproval: facts.toolApproval(deps).available,

package/dist/http/routes/diagnostics.d.ts

@@ -73,25 +73,6 @@ export interface StaticWiringFacts {
     /** store backend 的种类;`undefined` = env-only worker(无 backend)。 */
     backendKind: "mysql" | "pg" | "local" | undefined;
 }
-/**
- * 三项对表(设计稿件二)。判据全是**两个独立谓词对同一件事的答案**,矛盾即装配谎言 —— 装配谎言不是
- * 「配置不理想」,是「服务端对自己接了什么线的两套说法互斥」,继续启动只会把矛盾带进运行期的每一条腿。
- *
- *  ① park 设施:core 从 `spec.checkpointStore ?? deps.checkpointStore` 判 `parkLane.capable`,我方从
- *     `backend.checkpoint ∧ DURABLE_APPROVAL` 判 `parkFacility` 并据此决定流内审批协议上不上场。两者
- *     不等 ⇒ 协议按「窗到期能 park」上场而引擎侧根本不 park(结局是 core fail-closed deny),或反之
- *     白白关掉一个可用的协议。`capable` 真而 `effective` 不真同样致命:能力在、这条部署形上却不会真的
- *     park,窗到期依旧无降级目的地。
- *  ② 会话店持久性:manifest 声明 `declared_durable` 而后端是 local / 根本没有后端 ⇒ 「重启存活」的声明
- *     没有介质兑现。这条与 memory+durable 两条既有拒启同族(声明与介质必须对得上)。
- *  ③ interaction posture 声明 `interactive` 却没有任何 question 投递面 ⇒ 只 **warn**:core 在 prepare 时
- *     会按腿拒,boot 先一步把话说成人话。不拒启,因为部署形本身可能只是暂时没接活体面,而 core 侧已有
- *     兜底门 —— 拒启会把一个可运行的部署挡在门外。
- *  ④ park 车道的持久性读数不可信时 ⇒ **warn**(理由与这条判据为什么不是拒启,见其行内注)。
- *
- * 判决分两级是有判据的:**拒启**留给「两个谓词对同一件事互斥」(其中一个必错,继续跑就是带着谎言服务);
- * **警告**留给「读数不可信/声明不完整」(信号本身还不足以断定谁错,据此拒启会挡住正常部署)。
- */
 export declare function buildStaticWiringAudit(facts: StaticWiringFacts): StaticWiringAudit;
 /**
  * boot 消费口:`refusals` 非空即抛(拒启,与 memory+durable 两条既有拒启同族的 fail-loud 形),

package/dist/http/routes/diagnostics.js

@@ -43,6 +43,20 @@ export function buildServerWiringGates(input) {
         approvalGrant: [...input.approvalGrant],
     };
 }
+function durableSessionMedium(kind) {
+    switch (kind) {
+        case "mysql":
+        case "pg":
+        case "local":
+            return true;
+        case undefined:
+            return false;
+        default: {
+            const unknownKind = kind;
+            throw new Error(`durableSessionMedium: no ruling for store backend kind ${JSON.stringify(unknownKind)}`);
+        }
+    }
+}
 export function buildStaticWiringAudit(facts) {
     const refusals = [];
     const warnings = [];
@@ -56,9 +70,9 @@ export function buildStaticWiringAudit(facts) {
         refusals.push(`park facility contradiction: this server assembled its approval gates with parkFacility=true, but the engine's static wiring resolves parkLane.effective=${JSON.stringify(park.effective)} (reasons: ${park.reasons.join(", ") || "none"}). ` +
             `A window expiry would then have no degradation target and adjudicate as a fail-closed deny — refusing to start.`);
     }
-    if (facts.manifest.session.store === "declared_durable" && facts.backendKind !== "mysql" && facts.backendKind !== "pg") {
+    if (facts.manifest.session.store === "declared_durable" && !durableSessionMedium(facts.backendKind)) {
         refusals.push(`session store durability contradiction: the engine's static wiring reports session.store="declared_durable" while the store backend is ${facts.backendKind === undefined ? "absent (env-only worker)" : `"${facts.backendKind}"`}. ` +
-            `A durable declaration with no durable medium is a claim nothing can honor — refusing to start. Wire DB_BACKEND=mysql|pg, or fix the store's durability declaration.`);
+            `A durable declaration with no durable medium is a claim nothing can honor — refusing to start. Wire DB_BACKEND=mysql|pg|local, or fix the store's durability declaration.`);
     }
     if (facts.parkFacility && facts.manifest.parkLane.checkpointDurability !== "declared_durable") {
         warnings.push(`park facility is enabled but the checkpoint store does not declare durable storage ` +

package/dist/http/routes/memory-bundle.d.ts

@@ -20,12 +20,12 @@
  * 不该从「这个部署有没有记忆引擎」上读出部署形态。
  *
  * ── 能力面的诚实形(与 GET 面**方向相反**,这不是笔误)──────────────────────────────────────
- * `GET /v1/memory/export` 要的是 **DB 记忆平面**(pg|tidb),file 形态 501。本面要的是 core 的
+ * `GET /v1/memory/export` 要的是 **DB 记忆平面**(pg|mysql),file 形态 501。本面要的是 core 的
  * **bundle 复合面**(`exportSnapshotOf` / `importBundleCommit`),而它今天只在 core 自带的 **File**
  * 后端上实装:本仓的两只 SQL 记忆孪生(plugins/memory-engine-{pg,tidb}.ts)没有实现这两个可选面。
  * 因此**两个成因同落 501** `capability.memory_engine_required`(都是「换部署形态才行」,消费端分支相同):
  *  · 记忆引擎整个没接线(`MEMORY_ENGINE=off` / 多租 file 底座等暗态);
- *  · 引擎接了但后端没有 bundle 复合面(pg/tidb 孪生)—— 这一支在**挂载期**就判掉了
+ *  · 引擎接了但后端没有 bundle 复合面(pg/mysql 孪生)—— 这一支在**挂载期**就判掉了
  *    (`createMemoryBundleFaces` 返回 undefined ⇒ 两口整个不挂),能力位 `memoryBundle` 因此与「路由真能用」
  *    严格同真。🔴 首版把它当运行期事实(照常挂载、让 core 每次抛 409/422),被 codex 交叉复审驳倒并改此形:
  *    面在不在是一次**属性检查**、boot 期判得出、且是**永久**缺席 ⇒ 照常挂着就是一个恒假的 yes,

package/dist/http/routes/memory-bundle.js

@@ -4,6 +4,7 @@ import { sentMemoryStoreRefusal } from "../memory-store-refusal-reply.js";
 import { buildOriginFencedBundle, readOriginAware } from "../../memory-origin-fence.js";
 import { gatedPrincipal, explicitOperatorOk, sendOperatorPrincipalsRequired, sendPrincipalRefusal } from "../principal-gate.js";
 import { assertNever } from "../route-ctx.js";
+import { sentMemoryLayerRefusal } from "../memory-layer-reply.js";
 import * as facts from "../../capability-facts.js";
 export const MEMORY_BUNDLE_EXPORT_PATH = "/v1/memory/export";
 export const MEMORY_BUNDLE_IMPORT_PATH = "/v1/memory/import";
@@ -34,6 +35,8 @@ function codeOf(err) {
     return typeof code === "string" ? code : undefined;
 }
 function sentClassifiedFailure(res, ctx, face, err) {
+    if (sentMemoryLayerRefusal(res, err, { kind: "operator" }))
+        return true;
     const code = codeOf(err);
     if (code !== undefined && sentCoreCode(res, code, err instanceof Error ? err.message : String(err)))
         return true;
@@ -80,7 +83,7 @@ export async function handleMemoryBundle(req, res, match, ctx) {
     if (!fact.available) {
         switch (fact.why) {
             case "memory_bundle_faces_absent":
-                sendError(res, 501, "capability.memory_engine_required", "memory governance bundles are not available on this deployment — they require a wired memory engine (MEMORY_ENGINE=on) whose backend implements the v2-c bundle composite (exportSnapshotOf / importBundleCommit); the file memory backend does, the pg/tidb memory backends do not");
+                sendError(res, 501, "capability.memory_engine_required", "memory governance bundles are not available on this deployment — they require a wired memory engine (MEMORY_ENGINE=on) whose backend implements the v2-c bundle composite (exportSnapshotOf / importBundleCommit); the file memory backend does, the pg/mysql memory backends do not");
                 return;
             case "operator_principals_empty":
                 sendOperatorPrincipalsRequired(res);

package/dist/http/routes/memory-compliance.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { erasureInputSmugglesPrototypeKey } from "../../memory-operator-faces.js";
 import { sentMemoryComplianceFailure } from "../memory-compliance-failure-reply.js";
+import { readLayerSeat, sentMemoryLayerRefusal } from "../memory-layer-reply.js";
 import { sendJson, sendError } from "../send.js";
 import { gatedPrincipal, explicitOperatorOk, sendOperatorPrincipalsRequired, sendPrincipalRefusal } from "../principal-gate.js";
 import { assertNever } from "../route-ctx.js";
@@ -12,6 +13,8 @@ const EraseRequestSchema = z.object({
     allowUnevidenced: z.boolean().optional(),
 });
 function sentClassifiedFailure(res, ctx, face, err) {
+    if (sentMemoryLayerRefusal(res, err, { kind: "operator" }))
+        return true;
     if (sentMemoryComplianceFailure(res, err, { kind: "operator" }, ctx.deps.logger))
         return true;
     ctx.deps.logger?.warn?.(`memory_compliance_${face}_failed`, { err: String(err) });
@@ -36,7 +39,7 @@ export async function handleMemoryCompliance(req, res, match, ctx) {
     if (!fact.available) {
         switch (fact.why) {
             case "memory_compliance_faces_absent":
-                sendError(res, 501, "capability.memory_engine_required", "memory provenance and erasure are not available on this deployment — they require a wired memory engine (MEMORY_ENGINE=on) whose backend owns the engine control plane (controlPlaneRoot); the file memory backend does, the pg/tidb memory backends do not (their control plane would land on a replica's local disk)");
+                sendError(res, 501, "capability.memory_engine_required", "memory provenance and erasure are not available on this deployment — they require a wired memory engine (MEMORY_ENGINE=on) whose backend owns the engine control plane (controlPlaneRoot); the file memory backend does, the pg/mysql memory backends do not (their control plane would land on a replica's local disk)");
                 return;
             case "operator_principals_empty":
                 sendOperatorPrincipalsRequired(res);
@@ -53,8 +56,12 @@ export async function handleMemoryCompliance(req, res, match, ctx) {
                 sendError(res, 400, "request.id_invalid", "invalid memory entry id");
                 return;
             }
+            const query = new URLSearchParams(match.search);
+            const at = readLayerSeat(res, query.has("scope"), query.get("scope"));
+            if (at === null)
+                return;
             try {
-                sendJson(res, 200, await faces.provenanceOf(entryId));
+                sendJson(res, 200, await (at !== undefined ? faces.provenanceOf(entryId, at) : faces.provenanceOf(entryId)));
             }
             catch (err) {
                 if (!sentClassifiedFailure(res, ctx, "provenance", err))

package/dist/http/routes/memory-consolidation.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { ControlPlaneCorruptError } from "@sema-agent/core";
 import { sendJson, sendError } from "../send.js";
+import { sentMemoryLayerRefusal } from "../memory-layer-reply.js";
 import { gatedPrincipal, explicitOperatorOk, sendPrincipalRefusal, sendOperatorPrincipalsRequired } from "../principal-gate.js";
 import { assertNever } from "../route-ctx.js";
 import * as facts from "../../capability-facts.js";
@@ -101,7 +102,15 @@ export async function handleMemoryConsolidation(req, res, match, ctx) {
             const q = new URLSearchParams(match.search).get("scope") ?? undefined;
             const decided = decideScope(q, faces.scopes);
             const scope = "scope" in decided ? decided.scope : undefined;
-            const row = scope !== undefined ? faces.lastRun(scope) : undefined;
+            let row;
+            try {
+                row = scope !== undefined ? faces.lastRun(scope) : undefined;
+            }
+            catch (err) {
+                if (sentMemoryLayerRefusal(res, err, { kind: "operator" }))
+                    return;
+                throw err;
+            }
             sendJson(res, 200, {
                 enabled: true,
                 seat: faces.seat,
@@ -144,6 +153,8 @@ export async function handleMemoryConsolidation(req, res, match, ctx) {
                 sendJson(res, 200, buildRunSummary(r));
             }
             catch (err) {
+                if (sentMemoryLayerRefusal(res, err, { kind: "operator" }))
+                    return;
                 const coreCode = codeOf(err);
                 if (coreCode !== undefined) {
                     sendError(res, 409, "memory.consolidation_refused", `memory consolidation refused (${coreCode}): ${err instanceof Error ? err.message : String(err)}`);

package/dist/http/routes/memory-origin.js

@@ -3,6 +3,7 @@ import { ControlPlaneCorruptError } from "@sema-agent/core";
 import { sendJson, sendError } from "../send.js";
 import { sentMemoryStoreRefusal } from "../memory-store-refusal-reply.js";
 import { buildOriginFence, readOriginAware } from "../../memory-origin-fence.js";
+import { readLayerSeat, sentMemoryLayerRefusal } from "../memory-layer-reply.js";
 import { gatedPrincipal, explicitOperatorOk, sendOperatorPrincipalsRequired, sendPrincipalRefusal } from "../principal-gate.js";
 import { assertNever } from "../route-ctx.js";
 import * as facts from "../../capability-facts.js";
@@ -49,6 +50,8 @@ function codeOf(err) {
     return typeof code === "string" ? code : undefined;
 }
 function sentClassifiedFailure(res, ctx, face, err) {
+    if (sentMemoryLayerRefusal(res, err, { kind: "operator" }))
+        return true;
     if (face === "clear") {
         const coreCode = codeOf(err);
         if (coreCode !== undefined && sentClearCode(res, coreCode, err instanceof Error ? err.message : String(err)))
@@ -157,8 +160,12 @@ export async function handleMemoryOrigin(req, res, match, ctx) {
             return;
         }
         case "memory-origin-clearances": {
+            const query = new URLSearchParams(match.search);
+            const at = readLayerSeat(res, query.has("scope"), query.get("scope"));
+            if (at === null)
+                return;
             try {
-                sendJson(res, 200, { clearances: faces.listClearances().map(buildClearanceRowWire) });
+                sendJson(res, 200, { clearances: (at !== undefined ? faces.listClearances(at) : faces.listClearances()).map(buildClearanceRowWire) });
             }
             catch (err) {
                 if (!sentClassifiedFailure(res, ctx, "clearances", err))
@@ -182,8 +189,13 @@ export async function handleMemoryOrigin(req, res, match, ctx) {
                 sendError(res, 400, "request.body_shape", "invalid memory origin clearance request — expected an object with a non-empty `requestId` and a `reason` string (whether an EMPTY reason is acceptable is the engine's judgment, not this layer's)");
                 return;
             }
+            const body = raw;
+            const at = readLayerSeat(res, Object.prototype.hasOwnProperty.call(body, "scope"), body.scope);
+            if (at === null)
+                return;
             try {
-                const receipt = await faces.clear(entryId, { requestId: parsed.data.requestId, reason: parsed.data.reason });
+                const input = { requestId: parsed.data.requestId, reason: parsed.data.reason };
+                const receipt = await (at !== undefined ? faces.clear(entryId, input, at) : faces.clear(entryId, input));
                 ctx.deps.logger?.info?.("memory_origin_cleared", {
                     principal: principal ?? null,
                     entryId,

package/dist/http/routes/memory-policy.js

@@ -5,6 +5,7 @@ import { buildOriginFence, readOriginAware } from "../../memory-origin-fence.js"
 import { parseProjectLayerKey } from "../../project-layer-key.js";
 import { gatedPrincipal, explicitOperatorOk, sendPrincipalRefusal, sendUnauthorized } from "../principal-gate.js";
 import { assertNever } from "../route-ctx.js";
+import { sentMemoryLayerRefusal } from "../memory-layer-reply.js";
 const ORG_PREFIX = "org:";
 export const MEMORY_EXPORT_MAX_LIMIT = 500;
 function encodeExportCursor(c) {
@@ -73,7 +74,7 @@ export async function handleMemoryPolicy(req, res, match, ctx) {
                 return;
             }
             if (deps.config.memoryEngineBackend === "file" || !deps.memoryExport) {
-                sendError(res, 501, "capability.memory_store_required", "memory export requires a DB memory backend (MEMORY_ENGINE_BACKEND=pg|tidb)");
+                sendError(res, 501, "capability.memory_store_required", "memory export requires a DB memory backend (MEMORY_ENGINE_BACKEND=pg|mysql)");
                 return;
             }
             const q = new URLSearchParams(match.search);
@@ -121,6 +122,8 @@ export async function handleMemoryPolicy(req, res, match, ctx) {
                 });
             }
             catch (err) {
+                if (sentMemoryLayerRefusal(res, err, { kind: "operator" }))
+                    return;
                 deps.logger?.warn?.("memory_export_failed", { scope, err: String(err) });
                 sendError(res, 500, "internal.error", "memory export failed");
             }
@@ -133,7 +136,7 @@ export async function handleMemoryPolicy(req, res, match, ctx) {
                 return;
             }
             if (deps.config.memoryEngineBackend === "file" || !deps.memorySync) {
-                sendError(res, 501, "capability.memory_store_required", "memory sync requires a DB memory backend (MEMORY_ENGINE_BACKEND=pg|tidb)");
+                sendError(res, 501, "capability.memory_store_required", "memory sync requires a DB memory backend (MEMORY_ENGINE_BACKEND=pg|mysql)");
                 return;
             }
             const scope = safeDecode(match.params.scope);
@@ -158,6 +161,8 @@ export async function handleMemoryPolicy(req, res, match, ctx) {
                 sendJson(res, 200, out);
             }
             catch (err) {
+                if (sentMemoryLayerRefusal(res, err, { kind: "operator" }))
+                    return;
                 deps.logger?.warn?.("memory_sync_failed", { scope, peer: parsed.value.peer, err: String(err) });
                 sendError(res, 500, "internal.error", "memory sync failed");
             }