@sema-agent/server 7.139.0 → 7.140.0

package/dist/http/memory-compliance-failure-reply.js

@@ -3,6 +3,7 @@ import { logStoreFormRefusal, storeFormRefusalOf } from "../memory-store-refusal
 import { sentMemoryStoreRefusal } from "./memory-store-refusal-reply.js";
 import { sendError } from "./send.js";
 import { assertNever } from "./route-ctx.js";
+import { MemoryErasureStoreUnjudged } from "../memory-operator-faces.js";
 function sentCoreCode(res, coreCode, coreMessage, audience) {
     switch (coreCode) {
         case "config.memory_erasure_request":
@@ -42,6 +43,10 @@ function codeOf(err) {
     return typeof code === "string" ? code : undefined;
 }
 export function sentMemoryComplianceFailure(res, err, audience, logger) {
+    if (err instanceof MemoryErasureStoreUnjudged) {
+        sendError(res, 409, "memory.erasure_store_unjudged", textFor(audience, err.message, "session memory erasure refused — this erasure reaches memory kept in this deployment's second memory store, which this build does not erase from (an erasure requestId is judged on the deployment's main store only); nothing was erased — it becomes available with the next engine update, or ask the operator"));
+        return true;
+    }
     const coreCode = codeOf(err);
     if (coreCode !== undefined && sentCoreCode(res, coreCode, err instanceof Error ? err.message : String(err), audience))
         return true;

package/dist/http/memory-layer-reply.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 记忆动词的**层座**与「这次请求落不到一只记忆店」的拒 —— 两件的 HTTP 半场,唯一一处。
+ *
+ * ## 规则(店的那一半在 `src/memory-scope-stores.ts`)
+ * 一次记忆请求只落一只店:请求点名的层住的那一只;不点名层的动词(条目 id / 店级账本)答在本部署点名的层与部署的店共处的那一只上,
+ * 两只店分住时不猜、拒。会话 id 的两口不点名层时不拒:记忆状态读本部署的每一只店再折成一份,按会话抹除落部署的店(`memory-operator-faces.ts`)。
+ * 不点名层的动词因此多一个可选的**层座** `scope`:GET 口在查询串(`?scope=<层键>`),POST 口在体里(`"scope": "<层键>"`);
+ * 点名的层只用来定店,动词本身的语义不变。点名层的动词(导出 / 导入 / 外源列表 / 整理 / operator 抹除的 `select.scope` 与 `expectedScopes`)
+ * 本来就点名,不加座。
+ *
+ * ## 层座的读法({@link readLayerSeat})
+ * 缺席 ⇒ 没点名;在场 ⇒ 必须是非空串,否则 400 `request.field_invalid`、面一次都不调(空串与非串不是「没点名」—— 静默当缺席会把请求答在
+ * 另一只店上)。
+ *
+ * ## 拒的映射({@link sentMemoryLayerRefusal})
+ * `MemoryLayerRefusal` ⇒ 400 `request.memory_layer`:请求可以改对(点名层 / 按店拆成几次),服务器没坏,也不是盘形问题。
+ * 文案按受众分(与 `memory-compliance-failure-reply.ts` 同一条规则):operator ⇒ 原句(点名部署配置的层、哪几层住在哪只店 —— 运维要的就是它);
+ * 会话所有者 ⇒ 固定一句(只说怎么办),原句交 `withheld` 落运维行 —— 部署配置的层键不是这个受众的材料。
+ */
+import type { ServerResponse } from "node:http";
+import type { MemoryLayerSeat } from "../memory-operator-faces.js";
+import type { MemoryComplianceAudience } from "./memory-compliance-failure-reply.js";
+/**
+ * 层座:`present` = 键在不在(查询串 `has` / 体 `in`),`value` = 它的值。缺席 ⇒ `undefined`;非空串 ⇒ `{ layer }`;
+ * 其余 ⇒ 已答 400 `request.field_invalid`,返回 `null`(调用方 `return`)。
+ */
+export declare function readLayerSeat(res: ServerResponse, present: boolean, value: unknown): MemoryLayerSeat | undefined | null;
+/** `err` 是本服务的层拒 ⇒ 400 `request.memory_layer`(文案按受众),返回 true;否则 false,一个字节都不写。 */
+export declare function sentMemoryLayerRefusal(res: ServerResponse, err: unknown, audience: MemoryComplianceAudience): boolean;
+//# sourceMappingURL=memory-layer-reply.d.ts.map

package/dist/http/memory-layer-reply.js

@@ -0,0 +1,24 @@
+import { MemoryLayerRefusal } from "../memory-scope-stores.js";
+import { sendError } from "./send.js";
+export function readLayerSeat(res, present, value) {
+    if (!present)
+        return undefined;
+    if (typeof value === "string" && value.length > 0)
+        return { layer: value };
+    sendError(res, 400, "request.field_invalid", "scope must be a non-empty memory layer key when present — it names the layer whose memory store this request is answered on");
+    return null;
+}
+export function sentMemoryLayerRefusal(res, err, audience) {
+    if (!(err instanceof MemoryLayerRefusal))
+        return false;
+    switch (audience.kind) {
+        case "operator":
+            sendError(res, 400, "request.memory_layer", err.message);
+            return true;
+        case "session_owner":
+            audience.withheld(err.message);
+            sendError(res, 400, "request.memory_layer", "the memory store this request reaches cannot be told — the `scope` in the request is not a memory layer this deployment can read, or this deployment's own memory layer configuration cannot be read; resend without `scope` (or with a readable layer), or ask the operator");
+            return true;
+    }
+}
+//# sourceMappingURL=memory-layer-reply.js.map

package/dist/http/resume-legs.js

@@ -1,6 +1,6 @@
 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";
@@ -8,7 +8,7 @@ import { createSessionWorkspaceRecorder, legSessionWitnessOf, sessionWorkspaceSt
 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 { atHostBoundary, failureCodeOf, nestedPauseOf, sealResultForExit, outwardPlane } from "../terminal.js";
 import { buildCancelledLedgerRow, createRunAbort, mintCancelledResult } from "../run-cancel-context.js";
 import { isTerminalRunStatus } from "../plugins/store-contracts.js";
 import { readTurnActivityMs, recordTurnActivity } from "../turn-activity.js";
@@ -51,6 +51,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 +62,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,
@@ -855,12 +850,14 @@ 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;
+                    const vrJudged = atHostBoundary(vrEngine, sessionId);
+                    const vr = vrCause !== undefined && taskId !== undefined ? mintCancelledResult({ taskId, sessionId, startedAtMs: resumeLegStartedAt, message: "cancelled by user", engineResult: vrJudged, cause: vrCause }) : vrJudged;
                     await commitResumeCtx();
                     let safe = sealResultForExit(vr);
-                    const vrNested = nestedPauseOf(vr.terminal);
-                    const reParkStatus = nestedParkStatusOf(vr);
-                    const reSuspended = vrNested !== 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;
                     const vrReopened = await reopenedAfterLeg(vr, vrCause !== undefined);
                     if (vrReopened)
                         reopenConfirmedPark = true;
@@ -871,8 +868,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 +881,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;

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/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/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;

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) });
@@ -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) {
@@ -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");
             }
@@ -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");
             }

package/dist/http/routes/sessions.js

@@ -7,6 +7,8 @@ import { seatText } from "../../trace/exit-seat.js";
 import { recordFailOpen } from "../../observability/fail-open.js";
 import { MCP_DIAL_DEADLINE_MS, raceDeadline } from "../mcp-dial-deadline.js";
 import { sentMemoryComplianceFailure } from "../memory-compliance-failure-reply.js";
+import { readLayerSeat, sentMemoryLayerRefusal } from "../memory-layer-reply.js";
+import { foldPlaneStatuses } from "../../memory-operator-faces.js";
 import { MAX_SETTINGS_OUTPUT_STYLE_CHARS, MAX_SETTINGS_ENV_VARS, MAX_SETTINGS_ENV_KEY_CHARS, MAX_SETTINGS_ENV_VALUE_CHARS } from "../../task-settings.js";
 import { readWritableSessionPermissionRules } from "../../session-policy-wire.js";
 import { sendJson, sendError, sendSessionError, sendSessionPolicyError, sseHeaders, httpErrorBody } from "../send.js";
@@ -551,11 +553,17 @@ export async function handleSessions(req, res, match, ctx) {
                 sendError(res, 400, "request.field_invalid", "allowUnevidenced must be a boolean when present");
                 return;
             }
+            const at = readLayerSeat(res, Object.prototype.hasOwnProperty.call(raw, "scope"), raw.scope);
+            if (at === null)
+                return;
+            const withheld = (coreMessage) => deps.logger?.warn?.("session_memory_erase_refused", { sessionId, err: coreMessage });
             try {
-                sendJson(res, 200, await faces.erase({ requestId: raw.requestId, select: { sessionId }, ...(raw.allowUnevidenced !== undefined ? { allowUnevidenced: raw.allowUnevidenced } : {}) }));
+                const input = { requestId: raw.requestId, select: { sessionId }, ...(raw.allowUnevidenced !== undefined ? { allowUnevidenced: raw.allowUnevidenced } : {}) };
+                sendJson(res, 200, await (at !== undefined ? faces.erase(input, at) : faces.erase(input)));
             }
             catch (err) {
-                const withheld = (coreMessage) => deps.logger?.warn?.("session_memory_erase_refused", { sessionId, err: coreMessage });
+                if (sentMemoryLayerRefusal(res, err, { kind: "session_owner", withheld }))
+                    return;
                 if (sentMemoryComplianceFailure(res, err, { kind: "session_owner", withheld }, deps.logger))
                     return;
                 deps.logger?.warn?.("session_memory_erase_failed", { sessionId, err: String(err) });
@@ -587,20 +595,27 @@ export async function handleSessions(req, res, match, ctx) {
                 sendError(res, 501, "capability.memory_engine_required", "session memory status is not available on this deployment — it requires 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)");
                 return;
             }
+            const query = new URLSearchParams(match.search);
+            const at = readLayerSeat(res, query.has("scope"), query.get("scope"));
+            if (at === null)
+                return;
             try {
                 const { memoryStatusCache } = ctx.local.sessions;
-                let entry = memoryStatusCache.get(sessionId);
-                if (!entry || Date.now() - entry.at > MEMORY_STATUS_TTL_MS) {
+                const statusOf = (store) => {
+                    const cacheKey = JSON.stringify([sessionId, store.controlPlane]);
+                    const cached = memoryStatusCache.get(cacheKey);
+                    if (cached && Date.now() - cached.at <= MEMORY_STATUS_TTL_MS)
+                        return cached.status;
                     if (memoryStatusCache.size > 1024)
                         memoryStatusCache.clear();
-                    const status = face.status(sessionId);
+                    const status = store.status(sessionId);
                     const fresh = { at: Date.now(), status };
-                    memoryStatusCache.set(sessionId, fresh);
-                    status.catch(() => { if (memoryStatusCache.get(sessionId) === fresh)
-                        memoryStatusCache.delete(sessionId); });
-                    entry = fresh;
-                }
-                const s = await entry.status;
+                    memoryStatusCache.set(cacheKey, fresh);
+                    status.catch(() => { if (memoryStatusCache.get(cacheKey) === fresh)
+                        memoryStatusCache.delete(cacheKey); });
+                    return status;
+                };
+                const s = foldPlaneStatuses(await Promise.all(face.storesAt(at).map(statusOf)));
                 sendJson(res, 200, {
                     sessionId,
                     autoConsolidationArmed: deps.memoryAutoConsolidationArmed,
@@ -612,6 +627,8 @@ export async function handleSessions(req, res, match, ctx) {
                 });
             }
             catch (err) {
+                if (sentMemoryLayerRefusal(res, err, { kind: "session_owner", withheld: (message) => deps.logger?.warn?.("session_memory_status_refused", { sessionId, err: message }) }))
+                    return;
                 deps.logger?.warn?.("session_memory_status_failed", { sessionId, err: String(err) });
                 sendError(res, 500, "internal.error", "session memory status read failed");
             }

package/dist/http/routes/tasks.js

@@ -2,7 +2,7 @@ import { redactErrorMessage, redactHead, redactTerminalResult } from "../../obse
 import { runWithVerification, runCascade, taskNotificationDedupKey, uuidv7 } from "@sema-agent/core";
 import { heldFor } from "../../peer-seat.js";
 import { graftParkToolCallId, markChildrenStoppedByUserOnAbort, syncRefusalHttpStatus, zeroWorkRefusalFacts, releaseKeyIfZeroWorkRefusal, createPromptCommitReader, HEARTBEAT_MS } from "../../runs.js";
-import { sealResultForExit, outwardPlane } from "../../terminal.js";
+import { atHostBoundary, sealResultForExit, outwardPlane } from "../../terminal.js";
 import { withPrincipal } from "../../observability/principal-context.js";
 import { fleetRunPublisher, fleetRunLabels, fleetRunResiduals, isFleetAgentTerminalNotification } from "../../fleet/fleet-bus.js";
 import { defaultSubagentTailBus } from "../../fleet/subagent-tail-bus.js";
@@ -969,7 +969,7 @@ export async function handleTasks(req, res, match, ctx) {
                             }
                             return stream.result();
                         };
-                        result = await instructionLeg.run(prepared.spec.sessionId, () => withPrincipal(principal, () => prepared.verify ? verifyLeg(prepared.verify) : prepared.cascade ? cascadeLeg() : plainLeg()));
+                        result = atHostBoundary(await instructionLeg.run(prepared.spec.sessionId, () => withPrincipal(principal, () => prepared.verify ? verifyLeg(prepared.verify) : prepared.cascade ? cascadeLeg() : plainLeg())), prepared.spec.sessionId);
                     }
                     finally {
                         counters.uncountedBillableInflight--;
@@ -1006,10 +1006,12 @@ export async function handleTasks(req, res, match, ctx) {
                     const syncPlane = outwardPlane(result.terminal);
                     if (syncPlane.status === "suspended" && deps.checkpointStore && deps.runStore && durableTaskId) {
                         await deps.runStore.setSuspended(durableTaskId, exitResult);
+                        prepared.acceptance.settle(result);
                         return { status: 200, body: withSyncSubmitKeys(buildSyncSubmitBody(exitResult, { taskId: durableTaskId, sessionId: prepared.spec.sessionId, status: "suspended" })) };
                     }
                     if (syncPlane.status === "needs_review" && deps.checkpointStore && deps.runStore && durableTaskId) {
                         await deps.runStore.setNeedsReview(durableTaskId, exitResult);
+                        prepared.acceptance.settle(result);
                         return { status: 200, body: withSyncSubmitKeys(buildSyncSubmitBody(exitResult, { taskId: durableTaskId, sessionId: prepared.spec.sessionId, status: "needs_review" })) };
                     }
                     if (durableTaskId && deps.runStore)

package/dist/http/server.d.ts

@@ -1,8 +1,8 @@
 import http from "node:http";
-import type { MemoryComplianceFaces } from "../memory-operator-faces.js";
+import type { MemoryComplianceFaces, MemoryOriginFaces, SessionMemoryStatusFace } from "../memory-operator-faces.js";
 import type { SideQueryAccounting } from "../budget.js";
 import type { IncomingMessage } from "node:http";
-import { type Runner, type TaskSpec, type TaskResult, type WorkflowRunStore, type MemoryEntry, type MemoryExportBundle, type MemoryImportReport, type EntryProvenanceAccount, type MemoryEntryOrigin, type OriginClearanceRow, type SessionMemoryStatus, type ConsolidationRunReceipt, type ConsolidationDriverRunRow, type SideQuerySpec, type SideQueryResult, type Brain, type EngineNotice } from "@sema-agent/core";
+import { type Runner, type TaskSpec, type TaskResult, type WorkflowRunStore, type MemoryEntry, type MemoryExportBundle, type MemoryImportReport, type ConsolidationRunReceipt, type ConsolidationDriverRunRow, type SideQuerySpec, type SideQueryResult, type Brain, type EngineNotice } from "@sema-agent/core";
 import type { TaskRequestBody } from "./wire-types.js";
 import type { ServiceConfig } from "../config-types.js";
 import { type SessionMirrorRuling } from "../web-admin-client/facade.js";
@@ -518,9 +518,7 @@ export interface ServiceSeamDeps {
      *  (工厂返 undefined),与 compliance/origin 两族同一条 F-9 裁。
      *  🔴 face 的五键**全可选**(core `SessionMemoryStatus`):absent = 该事实源不可读,路由逐键透传缺席,
      *  恒不铸 false/0 替身;`optOutSource:"fault"` = capture 态 indeterminate(383 片2/3 轴直投)。 */
-    sessionMemoryStatus?: {
-        status: (sessionId: string) => Promise<SessionMemoryStatus>;
-    };
+    sessionMemoryStatus?: SessionMemoryStatusFace;
     /**
      * [ref](core 7.22.0 [ref] W1)—— 本**部署**的自动整理武装事实,`GET /v1/sessions/:id/memory-status`
      * 的 `autoConsolidationArmed` 格。
@@ -552,25 +550,7 @@ export interface ServiceSeamDeps {
      *  ——落在副本本地盘上 = pod 重建即永久丢失。全文见 src/memory-operator-faces.ts 头注。
      *  🔴 `listClearances` 是**同步**的(core 的读面就是一次严格 sidecar 读),且账本损坏时**抛**
      *  `ControlPlaneCorruptError` —— 那是 fail-closed 信号,不是空数组。 */
-    memoryOriginFace?: {
-        listExternal: (scopes: readonly string[]) => Promise<Array<{
-            id: string;
-            slug: string;
-            scope: string;
-            origin: MemoryEntryOrigin;
-            provenance: EntryProvenanceAccount;
-        }>>;
-        listClearances: () => OriginClearanceRow[];
-        clear: (entryId: string, input: {
-            requestId: string;
-            reason: string;
-        }) => Promise<{
-            entryId: string;
-            clearanceId: string;
-            origin: MemoryEntryOrigin;
-            landedSlug: string;
-        }>;
-    };
+    memoryOriginFace?: MemoryOriginFaces;
     /** [ref](core 5.58.0 `runMemoryConsolidationDriver`):记忆 **consolidation 阀门**的操作面。
      *  启用 `POST /v1/admin/memory/consolidation/run` 与 `GET /v1/admin/memory/consolidation`(两口 operator-only)。
      *  main.ts 把它接到 `createMemoryConsolidationFaces` 的产物上。
@@ -827,7 +807,7 @@ export interface ServiceDeploymentDeps {
      *  7.132.0 前这一席是 `sqlEngineFacts: () => SqlEngineFacts | null`(只给事实、不给方言);照旧传它 ⇒ `createHttpServer` 起服拒。
      *  🔴 **SQL 后端在场(`backend` 交出了 `mysqlPool()` / `pgPool()`)⇒ 本席必填**,缺席 ⇒ `createHttpServer` 起服拒(席缺席只表示「没有 SQL 后端」,不能是「忘了给」);
      *  本服务自己的装配(`boot/stores.ts` → `stage-10`)按同一个谓词(`sqlPoolsOf`)建立它,恒给。值形也在起服时判(同一只判官 `sqlEngineSeatIssue` 的另一臂):
-     *  `{ dialect: "tidb" | "pg", facts }`,`facts` 是 `null` 或带 `maxRowBytes` / `maxPacketBytes` / `wallSources` 的引擎事实;只改了键名的 `() => facts` 之类 ⇒ 起服拒。 */
+     *  `{ dialect: "mysql" | "pg", facts }`,`facts` 是 `null` 或带 `maxRowBytes` / `maxPacketBytes` / `wallSources` 的引擎事实;只改了键名的 `() => facts` 之类 ⇒ 起服拒。 */
     sqlEngine?: import("../plugins/sql-driver.js").SqlEngineReading;
     /** [ref]:**写保护名表**的姿态(`write-protection.ts` 的 boot 期单一推导点 —— 与递给每只 Runner 的
      *  `writeProtectedPaths` 座同一份 config 决定)。两个读面共用:`GET /v1/diagnostics/wiring` 的

package/dist/http/server.js

@@ -76,9 +76,9 @@ export function createHttpServer(rawDeps) {
         if (issue !== undefined) {
             switch (issue) {
                 case "required":
-                    throw new Error("createHttpServer: sqlEngine is required when a SQL store backend is wired (the backend hands out a SQL pool) — pass the 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; refusing to start rather than read the database's row and statement limits as absent and admit task bodies the database cannot store");
+                    throw new Error("createHttpServer: sqlEngine is required when a SQL store backend is wired (the backend hands out a SQL pool) — pass the 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; refusing to start rather than read the database's row and statement limits as absent and admit task bodies the database cannot store");
                 case "bad_shape":
-                    throw new Error(`createHttpServer: sqlEngine must be the SQL pool's engine reading \`{ dialect: "tidb" | "pg", facts }\` where \`facts\` is read live (a getter) and is null while the pool's connection setup has not succeeded, otherwise the engine facts object (maxRowBytes, maxPacketBytes and wallSources included) — got ${typeof deps.sqlEngine === "function" ? "a function (the 7.131.x reader \`() => facts\` goes in as \`{ dialect, get facts() { return f(); } }\`)" : describeValueShape(deps.sqlEngine)}; refusing to start rather than answer every task submission with a 500`);
+                    throw new Error(`createHttpServer: sqlEngine must be the SQL pool's engine reading \`{ dialect: "mysql" | "pg", facts }\` where \`facts\` is read live (a getter) and is null while the pool's connection setup has not succeeded, otherwise the engine facts object (maxRowBytes, maxPacketBytes and wallSources included) — got ${typeof deps.sqlEngine === "function" ? "a function (the 7.131.x reader \`() => facts\` goes in as \`{ dialect, get facts() { return f(); } }\`)" : describeValueShape(deps.sqlEngine)}; refusing to start rather than answer every task submission with a 500`);
                 default: {
                     const unhandled = issue;
                     throw new Error(`sqlEngine seat issue without a refusal: ${String(unhandled)}`);

package/dist/identity-source.d.ts

@@ -43,7 +43,7 @@ export declare const RUN_IDENTITY_PRINCIPAL_INC_MAX_CHARS = 64;
  * (身份键按字节判等,与 MySQL 协议表级 `utf8mb4_bin` 同形)。
  */
 export declare const RUN_IDENTITY_COLUMNS: {
-    readonly tidb: string;
+    readonly mysql: string;
     readonly pg: string;
 };
 /** 元组落盘的三格(SQL 三列 / File 车道 run.json 的三键,同名同义)。 */

package/dist/identity-source.js

@@ -2,7 +2,7 @@ export const IDENTITY_SOURCES = ["service_token", "sso", "direct_door_jwt"];
 export const RUN_IDENTITY_SCOPE_MAX_CHARS = 190;
 export const RUN_IDENTITY_PRINCIPAL_INC_MAX_CHARS = 64;
 export const RUN_IDENTITY_COLUMNS = {
-    tidb: [
+    mysql: [
         "identity_source VARCHAR(32) NULL",
         `identity_scope VARCHAR(${RUN_IDENTITY_SCOPE_MAX_CHARS}) NULL`,
         `identity_principal_inc VARCHAR(${RUN_IDENTITY_PRINCIPAL_INC_MAX_CHARS}) NULL`,