@sema-agent/server 7.142.0 → 7.143.0

package/dist/http/routes/notify-wake.js

@@ -1,13 +1,12 @@
-import { externalNotificationInboxEntry } from "../../orchestration/workflow-completion-inbox.js";
 import { sendJson, sendError } from "../send.js";
 import { gatedPrincipal, explicitOperatorOk, sendPrincipalRefusal, sessionCallerOf } from "../principal-gate.js";
 import { ownerlessRowOpen, sessionOwnerCellOf } from "../../security.js";
 import { sendResumeOutcome } from "../route-ctx.js";
 import { assertNever, SESSION_NOT_FOUND_MESSAGE } from "../route-ctx.js";
 import * as facts from "../../capability-facts.js";
+import { readResumeRestatement } from "../resume-restatement.js";
 export async function handleNotifyWake(req, res, match, ctx) {
     const { deps } = ctx;
-    const { steerableRuns } = ctx.registry;
     const { readJson, rateLimited, quotaExceeded, leaseDenied, safeDecode } = ctx.helpers;
     const { resumeWake } = ctx.legs;
     switch (match.decl.id) {
@@ -57,11 +56,12 @@ export async function handleNotifyWake(req, res, match, ctx) {
                 sendError(res, 501, "capability.session_ownership_required", "external notify requires the session-ownership face (sessionStorage.headOf)");
                 return;
             }
-            const notifyOwner = (await owned.sessionStorage.headOf(notifySession))?.owner;
-            if (notifyOwner === undefined) {
+            const notifyHead = await owned.sessionStorage.headOf(notifySession);
+            if (notifyHead === undefined) {
                 sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
                 return;
             }
+            const notifyOwner = notifyHead.owner;
             const notifyOperator = explicitOperatorOk(principal, deps.config);
             if (!notifyOperator && notifyOwner !== principal && !ownerlessRowOpen(await sessionOwnerCellOf(owned.sessionStorage, notifySession, notifyOwner), sessionCallerOf(req, deps))) {
                 sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
@@ -75,29 +75,26 @@ export async function handleNotifyWake(req, res, match, ctx) {
                 ...(nb.seq !== undefined ? { seq: nb.seq } : {}),
                 ...(nb.source !== undefined ? { source: nb.source } : {}),
             };
-            const liveTaskId = await deps.runStore?.getActiveTaskId?.(notifySession).catch(() => undefined);
-            const liveStream = liveTaskId !== undefined && liveTaskId !== null ? steerableRuns.get(liveTaskId) : undefined;
-            if (liveStream) {
-                try {
-                    await liveStream.notify(payload, { priority: "next" });
+            const out = await ctx.legs.sessionNotify.deliver({ sessionId: notifySession, occupant: notifyHead, ownerlessEntryOwner: principal ?? null }, payload);
+            switch (out.delivery) {
+                case "live":
                     sendJson(res, 200, { sessionId: notifySession, delivery: "live" });
                     return;
-                }
-                catch (e) {
-                    const code = e.code;
-                    if (typeof code === "string" && code.startsWith("notify.")) {
-                        sendError(res, 400, code, e instanceof Error ? e.message : "invalid notification");
-                        return;
-                    }
-                }
-            }
-            if (!deps.workflowCompletionInbox) {
-                sendError(res, 501, "capability.workflow_store_required", "external notify requires the workflow completion inbox (WORKFLOW_RUN_STORE)");
-                return;
+                case "refused":
+                    sendError(res, 400, out.code, out.message);
+                    return;
+                case "no_inbox":
+                    sendError(res, 501, "capability.workflow_store_required", "external notify requires the workflow completion inbox (WORKFLOW_RUN_STORE)");
+                    return;
+                case "parked":
+                    sendJson(res, 202, { sessionId: notifySession, delivery: "parked", note: "no live stream — parked in the session inbox; drained as a task_notification on the next stream open" });
+                    return;
+                case "withdrawn":
+                    sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
+                    return;
+                default:
+                    return assertNever(out);
             }
-            await deps.workflowCompletionInbox.enqueue(externalNotificationInboxEntry(notifySession, notifyOwner ?? principal ?? null, { task_type: "external", ...payload }, Date.now()));
-            sendJson(res, 202, { sessionId: notifySession, delivery: "parked", note: "no live stream — parked in the session inbox; drained as a task_notification on the next stream open" });
-            return;
         }
         case "session-wake": {
             if (!facts.checkpointPark(deps).available) {
@@ -121,7 +118,8 @@ export async function handleNotifyWake(req, res, match, ctx) {
                 sendError(res, 400, "request.field_invalid", "message must be a non-empty string when present");
                 return;
             }
-            const out = await resumeWake(wakeSession, wakeBody.message, principal, req, true);
+            const restatement = readResumeRestatement(wakeBody);
+            const out = await resumeWake(wakeSession, wakeBody.message, principal, req, true, undefined, undefined, restatement);
             sendResumeOutcome(res, out, deps.logger);
             return;
         }

package/dist/http/routes/rules.js

@@ -18,23 +18,33 @@ const RULES_PAGE_DEFAULT = 50;
 const RULES_PAGE_MAX = 200;
 const MAX_LAYER_CONTENT_CHARS = 16_384;
 const MAX_LAYERS = 3;
+const CC_IMPORT_ROOTED_LAYERS = IMPORTED_SETTINGS_LAYERS.filter((l) => l !== "userSettings");
 const CcImportPrepareBodySchema = z
     .object({
     layers: z
-        .array(z
-        .object({
-        layer: z.enum(IMPORTED_SETTINGS_LAYERS),
-        path: z.string().min(1).max(1024),
-        root: z.string().max(1024),
-        content: z.string().max(MAX_LAYER_CONTENT_CHARS),
-    })
-        .strict())
+        .array(z.discriminatedUnion("layer", [
+        z
+            .object({
+            layer: z.literal("userSettings"),
+            path: z.string().min(1).max(1024),
+            content: z.string().max(MAX_LAYER_CONTENT_CHARS),
+        })
+            .strict(),
+        z
+            .object({
+            layer: z.enum(CC_IMPORT_ROOTED_LAYERS),
+            path: z.string().min(1).max(1024),
+            root: z.string().max(1024),
+            content: z.string().max(MAX_LAYER_CONTENT_CHARS),
+        })
+            .strict(),
+    ]))
         .min(1)
         .max(MAX_LAYERS),
 })
     .strict();
 function ccImportRootRefused(layer) {
-    return !isValidDurableScope({ kind: "project", root: layer.root });
+    return layer.root !== undefined && !isValidDurableScope({ kind: "project", root: layer.root });
 }
 const TicketStringSchema = z.string().min(1).max(190).refine((t) => !hasControlOrBidi(t));
 const CcImportRedeemBodySchema = z.object({ ticket: TicketStringSchema }).strict();
@@ -122,9 +132,21 @@ export async function handleRules(req, res, match, ctx) {
         }
         const prepared = await lane.prepareLocalImport(principal, parsed.data.rows);
         if (!prepared.ok) {
-            logger.info("local rule import batch refused", prepared.reason === "too-many-rows" ? { reason: prepared.reason, rows: prepared.rows } : { reason: prepared.reason, bytes: prepared.bytes });
-            sendError(res, 413, "request.payload_too_large", "too many rule rows in this batch — split it and import again");
-            return;
+            switch (prepared.reason) {
+                case "too-many-rows":
+                case "batch-too-large":
+                    logger.info("local rule import batch refused", prepared.reason === "too-many-rows" ? { reason: prepared.reason, rows: prepared.rows } : { reason: prepared.reason, bytes: prepared.bytes });
+                    sendError(res, 413, "request.payload_too_large", "too many rule rows in this batch — split it and import again");
+                    return;
+                case "tightening-write-failed":
+                    logger.info("local rule import tightening write failed", { detail: prepared.detail, committed: prepared.committed });
+                    sendRuleWriteFailure(res, "import-tightening", prepared.committed);
+                    return;
+                default: {
+                    const unknown = prepared;
+                    throw new Error(`unknown local import refusal: ${JSON.stringify(unknown)}`);
+                }
+            }
         }
         sendJson(res, 200, { preview: prepared.preview, ...(prepared.ticket !== undefined ? { ticket: prepared.ticket, expiresAtMs: prepared.expiresAtMs } : {}) });
         return;
@@ -157,7 +179,7 @@ export async function handleRules(req, res, match, ctx) {
     if (match.decl.id === "rules-cc-import-prepare") {
         const parsed = CcImportPrepareBodySchema.safeParse(rawBody);
         if (!parsed.success) {
-            sendError(res, 400, "request.body_shape", "body must be {layers:[{layer,path,root,content}]}");
+            sendError(res, 400, "request.body_shape", "body must be {layers:[{layer:\"userSettings\",path,content} | {layer:\"projectSettings\"|\"localSettings\",path,root,content}]}");
             return;
         }
         const refusedLayer = parsed.data.layers.findIndex(ccImportRootRefused);
@@ -268,6 +290,19 @@ function sendRuleWriteFailure(res, verb, committed) {
                     throw new Error(`unknown rule-write committed word: ${JSON.stringify(unknownWord)}`);
                 }
             }
+        case "import-tightening":
+            switch (committed) {
+                case "no":
+                    sendError(res, 503, "state.rule_write_failed", "a deny / ask row of this batch was not written (that row is not in the store); deny / ask rows before it in the batch may already be in force, and the batch's allow rows were withheld (no ticket) — send the same batch again (rows already in force answer no-op)", { committed });
+                    return;
+                case "unknown":
+                    sendError(res, 503, "state.rule_write_failed", "a deny / ask row of this batch may or may not have landed; deny / ask rows before it in the batch may already be in force, and the batch's allow rows were withheld (no ticket) — reconcile with GET /v1/rules, or send the same batch again (rows already in force answer no-op)", { committed });
+                    return;
+                default: {
+                    const unknownWord = committed;
+                    throw new Error(`unknown rule-write committed word: ${JSON.stringify(unknownWord)}`);
+                }
+            }
         case "revoke":
             switch (committed) {
                 case "no":

package/dist/http/routes/runs.js

@@ -13,7 +13,7 @@ import { idemCallerOf, idemKeyOf, inflightKeyOf, submissionIdemOf } from "../ide
 import { streamSseLog } from "../sse-log.js";
 import { bindSseLifecycle } from "../sse-lifecycle.js";
 import { buildApprovalPreamble, buildApprovalPreambleSseFrames, readClosedWordSeat, storedCardDemandsAPerson } from "../../approval-card.js";
-import { heldAskOf, liveSettledBy, readDecidedBy, retiredDecisionKeyFacts, DECIDED_BY_NOT_IN_PROOF, DECIDED_BY_OUTSIDE_CLOSED_SET, POLICY_CANNOT_ALLOW_PERSON_ASK } from "../../host-decision.js";
+import { heldAskOf, liveHostSource, readDecider, retiredDecisionKeyFacts, DECIDED_BY_NOT_IN_PROOF, POLICY_CANNOT_ALLOW_PERSON_ASK } from "../../host-decision.js";
 import { ASK_DECISION_CONSUMER_ABSENT, approvalPreambleReplays, outcomeOfDecidedRow, presentedApprovalFrameFamily, resolveStreamApprovalGate } from "../../tool-approval.js";
 import { MAX_DECISION_NOTE_CHARS, noteLandedOnRow, noteRecordedReceipt } from "../../approval-ask-machine.js";
 import { askRowEndingCause } from "../../approval-deny-reasons.js";
@@ -57,6 +57,7 @@ const AskDecisionBodySchema = z
         .optional(),
     actor: z.object({ label: z.string().max(ASK_ACTOR_LABEL_MAX) }).strict().optional(),
     decidedBy: z.unknown().optional(),
+    decidedVia: z.unknown().optional(),
 })
     .strict();
 const ASK_DECISION_CONFIRM_TIMEOUT_MS = 2_000;
@@ -658,7 +659,7 @@ export async function handleRuns(req, res, match, ctx) {
                     state: { activeTools: [], nestedStats: { tokens: 0, turns: 0, tasks: 0, costMicroUsd: 0, anyUnpriced: false } },
                     status: "pending",
                     createdAt: Date.now(),
-                    sourceTaskId: taskId,
+                    sourceSessionId: run.sessionId,
                 });
                 const stillRead = await readResumeCtx(cs.getCtx(run.sessionId), { sessionId: run.sessionId, opener: deps.checkpointCtxSealing });
                 if (stillRead.kind === "corrupt" || stillRead.kind === "unsealable") {
@@ -1320,17 +1321,17 @@ export async function handleRunVerbs(req, res, match, ctx) {
                 sendError(res, 400, "request.body_shape", retired.error, retired.extra);
                 return;
             }
-            sendError(res, 400, "request.body_shape", "invalid ask decision body — expected decision=approve|deny plus optional updatedInput / note / idempotencyKey / actor.label / decidedBy");
+            sendError(res, 400, "request.body_shape", "invalid ask decision body — expected decision=approve|deny plus optional updatedInput / note / idempotencyKey / actor.label / decidedBy / decidedVia");
             return;
         }
         const body = parsedBody.data;
-        const decidedByReading = readDecidedBy(body.decidedBy, deps.config.directDoorActive);
+        const decidedByReading = readDecider(body, deps.config.directDoorActive);
         switch (decidedByReading.kind) {
             case "not_in_proof":
                 sendError(res, 400, "decided_by_not_in_proof", DECIDED_BY_NOT_IN_PROOF);
                 return;
             case "outside_closed_set":
-                sendError(res, 400, "request.field_invalid", DECIDED_BY_OUTSIDE_CLOSED_SET);
+                sendError(res, 400, "request.field_invalid", decidedByReading.message);
                 return;
             case "accepted":
                 break;
@@ -1339,7 +1340,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
                 throw new Error(`unhandled decidedBy reading: ${JSON.stringify(unreachable)}`);
             }
         }
-        const decidedBy = decidedByReading.decidedBy;
+        const decider = decidedByReading.decider;
         const hasUpdatedInput = typeof rawBody === "object" && rawBody !== null && "updatedInput" in rawBody;
         const taskId = match.params.taskId;
         const askId = match.params.askId;
@@ -1473,7 +1474,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
             sendTerminal(row0);
             return;
         }
-        if (body.decision === "approve" && policyCannotAnswer(heldAskOf(storedCardDemandsAPerson(row0.cardJson)), decidedBy)) {
+        if (body.decision === "approve" && policyCannotAnswer(heldAskOf(storedCardDemandsAPerson(row0.cardJson)), decider.decidedBy)) {
             sendError(res, 400, "request.field_conflict", POLICY_CANNOT_ALLOW_PERSON_ASK, fieldConflictFacts("policy_person_ask", ["decidedBy", "decision"]));
             return;
         }
@@ -1485,7 +1486,7 @@ export async function handleRunVerbs(req, res, match, ctx) {
                 decisionActor: actor,
                 decisionNote: body.note ?? null,
                 idempotencyKey: body.idempotencyKey ?? null,
-                ...((sb) => (sb !== undefined ? { settledBy: sb } : {}))(liveSettledBy(decidedBy)),
+                ...liveHostSource(decider),
                 ...(body.decision === "approve" && hasUpdatedInput ? { updatedInput: body.updatedInput } : {}),
             });
         }

package/dist/http/routes/session-memory-sync.d.ts

@@ -13,9 +13,14 @@
  *  R5 可用性 = 能力事实 `sessionMemorySync`(本机同步腿 ∧ 持久 run 账面 ∧ 会话头读),与能力位同读一只;不从后端名推。
  *
  * ── 读集(这个会话读哪几层)────────────────────────────────────────────────────────────────────
- * = 会话**最近一条已结腿**结果里引擎铸的记忆观测(run 店 `latestMemoryObservationForSession`;规则属主 `store-contracts.ts` 的
- * `SettledLegMemoryObservation`):`mounted` ⇒ `scopes[].scope` 按服务序;`memoryless` / `none` ⇒ `[]`(那一腿没挂上记忆 —— 是值)。
- * 那一腿没有观测(prepare 没走完)/ 会话还没有已结腿 / 会话没有叶子 ⇒ 409 `conflict.session_memory_unobserved`(有在飞 run 时带 `activeTaskId`)。
+ * = 会话**最近一条已结腿**的记忆观测(run 店 `latestMemoryObservationForSession`;规则属主 `store-contracts.ts` 的
+ * `SettledLegMemoryObservation`,四态闭集 `LegMemoryObservation`):`mounted` ⇒ `scopes[].scope` 按服务序;`none`(那一腿没配记忆:`no-spec` / `disabled`)⇒ `[]` —— 是值;
+ * `memoryless`(S-2855B:那一腿配了记忆而没挂上 —— 它本该读哪几层在挂载失败时不可知,答 `[]` 就是把故障洗成「不读记忆」)与
+ * `absent`([ref] 空观测:那一腿的记录里没有观测 —— 因由只说记录里有什么,不推断它停在哪一步)⇒ 读集取不到。**不往更早的腿找**(一条律,一只读法)。
+ * 读集取不到 ⇒ 409 `conflict.session_memory_unobserved`,体恒带 `reason`(闭集 {@link SESSION_MEMORY_UNOBSERVED_REASONS},判序 = 读的先后):
+ * 会话还没有已结腿 ⇒ `no_settled_run`;那一腿是空观测 ⇒ 它的因由(`run_result_missing` / `run_result_unobserved`);那一腿没挂上记忆 ⇒ `memory_not_mounted`
+ * (引擎的两只因由 `mount-failed` / `no-backend` 不在本体上复述 —— 它们在那条 run 的结果里,`GET /v1/runs/:id` 的 `result.effectiveMemoryScopes.reason`);观测在、会话没有叶子 ⇒ `no_leaf`。
+ * 句子由 `reason` 定(一张表 {@link SESSION_MEMORY_UNOBSERVED_MESSAGES});有在飞 run 时另带 `activeTaskId`。
  * 路由不重铸 spec:spec 只在受理时铸、不落会话行,重铸 = 重启前后两种答案。
  *
  * ── 门序(编号即执行序)──────────────────────────────────────────────────────────────────────────
@@ -46,11 +51,34 @@
  */
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { type RouteCtx, type RouteMatch, type RouteIdsOf } from "../route-ctx.js";
-import type { EffectiveMemoryScopes } from "../../plugins/store-contracts.js";
+import { type SettledLegMemoryObservation } from "../../plugins/store-contracts.js";
 /** 收割栅栏的句(本服务铸;码 `session_active` 是引擎报告闭集的成员)。 */
 export declare const SESSION_ACTIVE_SYNC_MESSAGE = "a run in this session is in flight, or the session moved on after the memory it reads was observed (a run was admitted or its transcript advanced) \u2014 wait for it to finish on its own, then sync again (do not cancel it to sync sooner)";
-/** 读集 = 最近一条已结腿的记忆观测(三态穷举;引擎加第四态 ⇒ 编译红)。 */
-export declare function sessionReadSetOf(observation: EffectiveMemoryScopes): readonly string[];
+/**
+ * 409 `conflict.session_memory_unobserved` 体上的 `reason`(闭集;判序 = 读的先后):会话没有已结腿 → 那一腿的观测取不出读集(空观测的因由,词表属主 = `store-contracts.ts`
+ * 的 `MEMORY_OBSERVATION_ABSENT_REASONS`,本表不另写;或引擎观测说配了记忆而没挂上)→ 观测在、会话没有叶子。自铸 wire 值登记 = `trace/self-minted-wire.ts` 的 `sessionMemoryUnobservedReason`。
+ */
+export declare const SESSION_MEMORY_UNOBSERVED_REASONS: readonly ["no_settled_run", "run_result_missing", "run_result_unobserved", "memory_not_mounted", "no_leaf"];
+export type SessionMemoryUnobservedReason = (typeof SESSION_MEMORY_UNOBSERVED_REASONS)[number];
+/** 每个 `reason` 的句子(wire 文案,冻结在 `test/api-error-text-freeze.test.ts` 的常量锚格;句子由 `reason` 定,调用点不另写一句)。 */
+export declare const SESSION_MEMORY_UNOBSERVED_MESSAGES: {
+    readonly no_settled_run: "this session has no settled run with a memory observation yet, so there is nothing to say about which memory it reads — run a task in it (or let the run in flight finish), then sync";
+    readonly run_result_missing: "the latest settled run in this session has no memory observation on record, and an earlier run is never read in its place — run another task in this session (if that run was refused, fix what refused it first), then sync";
+    readonly run_result_unobserved: "the latest settled run in this session has no memory observation on record, and an earlier run is never read in its place — run another task in this session (if that run was refused, fix what refused it first), then sync";
+    readonly memory_not_mounted: "memory was configured for the latest settled run in this session but did not mount, so which memory this session reads is unknown, and an earlier run is never read in its place — run another task in this session (if its memory fails to mount again, fix that first), then sync";
+    readonly no_leaf: "this session has no transcript yet, so there is no revision to sync from — run a task in it (or let the run in flight finish), then sync";
+};
+/** 第 7 步的读数:读集(观测所在那一腿 + 层键),或取不到的那一臂(叶子臂在调用点判 —— 它读的是头,不是观测)。 */
+export type SessionReadSet = {
+    readonly kind: "read";
+    readonly taskId: string;
+    readonly scopes: readonly string[];
+} | {
+    readonly kind: "unobserved";
+    readonly reason: Exclude<SessionMemoryUnobservedReason, "no_leaf">;
+};
+/** 读集 = 最近一条已结腿的记忆观测(四态穷举;引擎加一态 / 本服务加一态 ⇒ 编译红):只有 `mounted` 与 `none` 说得出读集。 */
+export declare function sessionReadSetOf(observed: SettledLegMemoryObservation | undefined): SessionReadSet;
 export declare function handleSessionMemorySync(req: IncomingMessage, res: ServerResponse, match: RouteMatch<SessionMemorySyncRouteId>, ctx: RouteCtx): Promise<void>;
 export declare const SESSION_MEMORY_SYNC_ROUTES: readonly [{
     readonly id: "session-memory-sync";

package/dist/http/routes/session-memory-sync.js

@@ -7,14 +7,30 @@ import * as facts from "../../capability-facts.js";
 import { sessionOwnerCellOf } from "../../security.js";
 import { leafOfAdmittedHead } from "../../session-incarnation.js";
 import { declaredMemorySyncIdentityFlaw, memorySyncIdentityRule } from "../../memory-sync-identity.js";
+import { MEMORY_OBSERVATION_ABSENT_REASONS } from "../../plugins/store-contracts.js";
 export const SESSION_ACTIVE_SYNC_MESSAGE = "a run in this session is in flight, or the session moved on after the memory it reads was observed (a run was admitted or its transcript advanced) — wait for it to finish on its own, then sync again (do not cancel it to sync sooner)";
-export function sessionReadSetOf(observation) {
+export const SESSION_MEMORY_UNOBSERVED_REASONS = ["no_settled_run", ...MEMORY_OBSERVATION_ABSENT_REASONS, "memory_not_mounted", "no_leaf"];
+const LATEST_RUN_UNOBSERVED_MESSAGE = "the latest settled run in this session has no memory observation on record, and an earlier run is never read in its place — run another task in this session (if that run was refused, fix what refused it first), then sync";
+export const SESSION_MEMORY_UNOBSERVED_MESSAGES = {
+    no_settled_run: "this session has no settled run with a memory observation yet, so there is nothing to say about which memory it reads — run a task in it (or let the run in flight finish), then sync",
+    run_result_missing: LATEST_RUN_UNOBSERVED_MESSAGE,
+    run_result_unobserved: LATEST_RUN_UNOBSERVED_MESSAGE,
+    memory_not_mounted: "memory was configured for the latest settled run in this session but did not mount, so which memory this session reads is unknown, and an earlier run is never read in its place — run another task in this session (if its memory fails to mount again, fix that first), then sync",
+    no_leaf: "this session has no transcript yet, so there is no revision to sync from — run a task in it (or let the run in flight finish), then sync",
+};
+export function sessionReadSetOf(observed) {
+    if (observed === undefined)
+        return { kind: "unobserved", reason: "no_settled_run" };
+    const { taskId, observation } = observed;
     switch (observation.state) {
         case "mounted":
-            return observation.scopes.map((s) => s.scope);
-        case "memoryless":
+            return { kind: "read", taskId, scopes: observation.scopes.map((s) => s.scope) };
         case "none":
-            return [];
+            return { kind: "read", taskId, scopes: [] };
+        case "memoryless":
+            return { kind: "unobserved", reason: "memory_not_mounted" };
+        case "absent":
+            return { kind: "unobserved", reason: observation.reason };
         default:
             return assertNever(observation);
     }
@@ -101,17 +117,18 @@ export async function handleSessionMemorySync(req, res, match, ctx) {
                 sendError(res, 400, "request.field_invalid", `target ${memorySyncIdentityRule(flaw)} — send the target engine's memorySyncServe.identity exactly as GET /v1/capabilities publishes it`, { field: "target", reason: flaw });
                 return;
             }
-            const observed = await runStore.latestMemoryObservationForSession(sessionId);
-            if (observed?.effectiveMemoryScopes === undefined || sourceRevision === null) {
+            const readSet = sessionReadSetOf(await runStore.latestMemoryObservationForSession(sessionId));
+            if (readSet.kind === "unobserved" || sourceRevision === null) {
+                const reason = readSet.kind === "unobserved" ? readSet.reason : "no_leaf";
                 const activeTaskId = await runStore.getActiveTaskId(sessionId);
-                sendError(res, 409, "conflict.session_memory_unobserved", "this session has no settled run with a memory observation yet, so there is nothing to say about which memory it reads — run a task in it (or let the run in flight finish), then sync", activeTaskId !== undefined ? { activeTaskId } : undefined);
+                sendError(res, 409, "conflict.session_memory_unobserved", SESSION_MEMORY_UNOBSERVED_MESSAGES[reason], { reason, ...(activeTaskId !== undefined ? { activeTaskId } : {}) });
                 return;
             }
-            const scopes = sessionReadSetOf(observed.effectiveMemoryScopes);
+            const { taskId: observedTaskId, scopes } = readSet;
             const quiet = async () => {
                 if ((await runStore.getActiveTaskId(sessionId)) !== undefined)
                     return false;
-                if ((await runStore.latestRunForSession(sessionId))?.taskId !== observed.taskId)
+                if ((await runStore.latestRunForSession(sessionId))?.taskId !== observedTaskId)
                     return false;
                 const now = await readHead();
                 return now !== undefined && leafOfAdmittedHead(now) === sourceRevision;
@@ -129,7 +146,7 @@ export async function handleSessionMemorySync(req, res, match, ctx) {
                     report = reportOf({ target, sourceRevision, scopes, layers: [] });
                 }
                 else {
-                    report = await mergedRound(leg, JSON.stringify([sessionId, sourceRevision, observed.taskId, target]), async () => {
+                    report = await mergedRound(leg, JSON.stringify([sessionId, sourceRevision, observedTaskId, target]), async () => {
                         const round = await leg.syncOnce("session-trigger", { reading: scopes });
                         if (!(await quiet()))
                             return fenced();

package/dist/http/routes/session-sync.js

@@ -1,5 +1,5 @@
 import { once } from "node:events";
-import { randomBytes, createHash } from "node:crypto";
+import { randomBytes } from "node:crypto";
 import { sessionLogDigest, sessionLogDigestsComparable, StreamingImportValidator, validateFileHistoryExport } from "@sema-agent/core";
 import { StringDecoder } from "node:string_decoder";
 import { FileHistoryUnreadableError, blobGetterOf, exportSessionManifest, exportedFileHistory, fileHistoryImportFace, replayFileHistory, replayPolicyRecords, wipeSessionAttendants } from "../../session-sync.js";
@@ -222,6 +222,7 @@ export async function handleSessionSync(req, res, match, ctx) {
                     return;
                 }
                 const fs = blobs.historyStore;
+                const exchange = blobs.blobExchange;
                 let envelope;
                 try {
                     envelope = await exportedFileHistory(fs, sessionId);
@@ -238,7 +239,7 @@ export async function handleSessionSync(req, res, match, ctx) {
                 }
                 let bytes;
                 try {
-                    bytes = await fs.getBlob(hash);
+                    bytes = await exchange.get(hash);
                 }
                 catch (e) {
                     if (sendPullUnreadable(req, res, deps.logger, e))
@@ -268,16 +269,15 @@ export async function handleSessionSync(req, res, match, ctx) {
                     sendError(res, 400, "request.id_invalid", "blob hash must be 64 lowercase-hex chars");
                     return;
                 }
-                const fs = blobs.historyStore;
                 const body = await readRawBody(req, SYNC_BLOB_MAX_BYTES);
-                if (createHash("sha256").update(body).digest("hex") !== hash) {
-                    sendError(res, 400, "request.hash_mismatch", "blob hash mismatch");
-                    return;
-                }
-                const put = await fs.putBlob(hash, new Uint8Array(body));
+                const put = await blobs.blobExchange.put(hash, new Uint8Array(body));
                 if (!put.ok) {
-                    if (put.error.code === "blob_too_large_for_sql") {
-                        sendError(res, 413, "blob_too_large_for_sql", put.error.message, { wallSource: put.error.wallSource });
+                    if (put.error.blobCap !== undefined) {
+                        sendError(res, 413, "blob_too_large_for_sql", put.error.message, { wallSource: put.error.blobCap.wallSource });
+                        return;
+                    }
+                    if (put.error.code === "adopt_failed") {
+                        sendError(res, 400, "request.hash_mismatch", "blob hash mismatch");
                         return;
                     }
                     sendError(res, 502, put.error.code, "blob store write failed");
@@ -751,15 +751,8 @@ async function firstMissingBlob(blobFaces, referenced) {
         return undefined;
     if (!blobFaces.available)
         return referenced[0];
-    const store = blobFaces.historyStore;
-    if (typeof store.hasBlobs === "function") {
-        const present = await store.hasBlobs([...referenced]);
-        return referenced.find((h) => !present.has(h));
-    }
-    for (const hash of referenced)
-        if (!(await store.getBlob(hash)))
-            return hash;
-    return undefined;
+    const present = await blobFaces.blobExchange.has(referenced);
+    return referenced.find((h) => !present.has(h));
 }
 function sendSessionSyncUnavailable(res, why) {
     switch (why) {
@@ -779,7 +772,7 @@ function sendSessionSyncUnavailable(res, why) {
         case "policy_purge_absent":
             sendError(res, 501, "capability.policy_purge_required", "session sync is not available on this deployment: the session-policy store has no deleteBySession purge verb, so an overwrite-dst import could not wipe the destination's stale policy rows. Every in-tree policy store carries it since core 1.423 — upgrade the policy store");
             return;
-        case "sync_blob_faces_absent":
+        case "blob_exchange_absent":
             sendError(res, 501, "capability.snapshot_store_required", "file-history blob transfer is not available on this deployment: its file-history store has no blob faces (SQL backends only; capabilities.sessionSyncFileHistory is false here). Sync the conversation without fileHistory");
             return;
         default:

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

@@ -12,7 +12,7 @@
  * `sse.sseConnections` / `sse.sseOwnerLookups`——`let` 无法跨模块共享自增。判据/时机/配对释放逐字未动。
  */
 import type { IncomingMessage, ServerResponse } from "node:http";
-import { type SessionMemoryStatus } from "@sema-agent/core";
+import type { SessionMemoryView } from "../../memory-operator-faces.js";
 import type { RouteCtx, RouteMatch, RouteIdsOf } from "../route-ctx.js";
 /** 单域独占状态。每个 server 实例一份——模块级会把连接坑/缓存跨实例串味。 */
 export interface SessionsLocal {
@@ -42,7 +42,7 @@ export interface SessionsLocal {
      *  mcp/a2a 按 (scenario, principal) 分键是因为它们的面按人裁,这张面不按人裁,分键只会白扩表)。 */
     memoryStatusCache: Map<string, {
         at: number;
-        status: Promise<SessionMemoryStatus>;
+        status: Promise<SessionMemoryView>;
     }>;
 }
 export declare function createSessionsLocal(): SessionsLocal;

package/dist/http/routes/sessions.js

@@ -8,13 +8,12 @@ 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";
 import { fleetViewOf, gatedPrincipal, explicitOperatorOk, sessionCallerOf, sessionOwnerReadable, sendPrincipalRefusal, sendUnauthorized } from "../principal-gate.js";
 import { headReadOf, leafOfAdmittedHead, sessionFaceOfHead } from "../../session-incarnation.js";
-import { runRowReadableOnSessionFace } from "../owner-access.js";
+import { foldOwnerUnreadable, runRowReadableOnSessionFace } from "../owner-access.js";
 import { assertNever, SESSION_NOT_FOUND_MESSAGE } from "../route-ctx.js";
 import * as facts from "../../capability-facts.js";
 import { rosterAgentId } from "./agents-roster.js";
@@ -84,7 +83,7 @@ export async function handleSessions(req, res, match, ctx) {
     const readOwnedSessionView = async (sessionAudit, sessionId, readOpts) => {
         const headOf = headReadOf(deps.sessionStorage);
         if (headOf !== undefined) {
-            const owner = (await headOf(sessionId))?.owner;
+            const owner = (await foldOwnerUnreadable(deps.logger, match.decl.id, sessionId, () => headOf(sessionId)))?.owner;
             if (owner === undefined) {
                 sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
                 return undefined;
@@ -274,7 +273,7 @@ export async function handleSessions(req, res, match, ctx) {
                 sendError(res, 400, "request.path_malformed", "session id segment is not valid percent-encoding");
                 return;
             }
-            const head = await headOf(headSession);
+            const head = await foldOwnerUnreadable(deps.logger, match.decl.id, headSession, () => headOf(headSession));
             if (head === undefined) {
                 sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
                 return;
@@ -304,7 +303,7 @@ export async function handleSessions(req, res, match, ctx) {
                 sendError(res, 400, "request.path_malformed", "session id segment is not valid percent-encoding");
                 return;
             }
-            const reading = await placementFact.seat.read(placementSession);
+            const reading = await foldOwnerUnreadable(deps.logger, match.decl.id, placementSession, () => placementFact.seat.read(placementSession));
             if (reading === undefined) {
                 sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
                 return;
@@ -322,7 +321,7 @@ export async function handleSessions(req, res, match, ctx) {
                 sendError(res, 501, "capability.session_store_required", "session events require a durable session store (DB_BACKEND=mysql|pg|local)");
                 return;
             }
-            const readHead = (id) => evFact.sessionStorage.headOf(id);
+            const readHead = (id) => foldOwnerUnreadable(deps.logger, match.decl.id, id, () => evFact.sessionStorage.headOf(id));
             const readOwner = async (id) => (await readHead(id))?.owner;
             const watch = evFact.watch;
             const evSession = safeDecode(match.params.sessionId);
@@ -541,6 +540,10 @@ export async function handleSessions(req, res, match, ctx) {
                 sendError(res, 400, "request.body_shape", "invalid session memory erase body — expected { requestId: string, allowUnevidenced?: boolean } (no `select`: this face erases exactly this session's own contributions)");
                 return;
             }
+            if ("scope" in raw) {
+                sendError(res, 400, "request.body_shape", "invalid session memory erase body — `scope` is not accepted: this face erases this session's own contributions in every memory store of the deployment, so there is no layer to name; resend without `scope`");
+                return;
+            }
             if ("select" in raw) {
                 sendError(res, 400, "request.body_shape", "invalid session memory erase body — `select` is not accepted on the self-service face: the selector is fixed to { sessionId: <this session> } by the path; the operator face POST /v1/memory/erase takes explicit selectors");
                 return;
@@ -553,17 +556,12 @@ 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 {
                 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)));
+                sendJson(res, 200, await faces.erase(input));
             }
             catch (err) {
-                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) });
@@ -601,21 +599,22 @@ export async function handleSessions(req, res, match, ctx) {
                 return;
             try {
                 const { memoryStatusCache } = ctx.local.sessions;
-                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;
+                const reading = face.readingAt(at);
+                const cacheKey = JSON.stringify([sessionId, reading.key]);
+                const cached = memoryStatusCache.get(cacheKey);
+                let pending;
+                if (cached && Date.now() - cached.at <= MEMORY_STATUS_TTL_MS)
+                    pending = cached.status;
+                else {
                     if (memoryStatusCache.size > 1024)
                         memoryStatusCache.clear();
-                    const status = store.status(sessionId);
-                    const fresh = { at: Date.now(), status };
+                    pending = reading.status(sessionId);
+                    const fresh = { at: Date.now(), status: pending };
                     memoryStatusCache.set(cacheKey, fresh);
-                    status.catch(() => { if (memoryStatusCache.get(cacheKey) === fresh)
+                    pending.catch(() => { if (memoryStatusCache.get(cacheKey) === fresh)
                         memoryStatusCache.delete(cacheKey); });
-                    return status;
-                };
-                const s = foldPlaneStatuses(await Promise.all(face.storesAt(at).map(statusOf)));
+                }
+                const s = await pending;
                 sendJson(res, 200, {
                     sessionId,
                     autoConsolidationArmed: deps.memoryAutoConsolidationArmed,