@sema-agent/server 7.141.0 → 7.143.0

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

@@ -1,7 +1,7 @@
 /**
  * [ref] A9 域模块 —— memory 导出/同步 + 只读策略面。
  *
- * 路由:`GET /v1/memory/export`、`POST /v1/memory/sync/:scope`、`GET /v1/policy`。
+ * 路由:`GET /v1/memory/export`、`POST /v2/memory/sync/:scope`、`GET /v1/policy`。
  * owner 门 = 「本人 user scope / 本人的项目层 / 显式 operator / `org:` 键的目录成员」(见 {@link gateMemoryScope}),
  * 越界一律 404(零存在性 oracle)。本域零可变状态。
  */
@@ -35,7 +35,7 @@ export declare const MEMORY_POLICY_ROUTES: readonly [{
 }, {
     readonly id: "memory-sync-scope";
     readonly pattern: RegExp;
-    readonly label: "/v1/memory/sync/:scope";
+    readonly label: "/v2/memory/sync/:scope";
     readonly methods: readonly ["POST"];
 }];
 /** 本域可分派行的 `id` 闭集 —— handler 的 `switch` 按它判穷尽(漏一口 = 编译红)。 */

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

@@ -1,5 +1,7 @@
 import { formatUserScope } from "@sema-agent/core";
 import { parseMemorySyncRequest } from "../../memory-sync.js";
+import { memorySyncIdentityRule } from "../../memory-sync-identity.js";
+import * as facts from "../../capability-facts.js";
 import { sendJson, sendError } from "../send.js";
 import { buildOriginFence, readOriginAware } from "../../memory-origin-fence.js";
 import { parseProjectLayerKey } from "../../project-layer-key.js";
@@ -73,7 +75,8 @@ export async function handleMemoryPolicy(req, res, match, ctx) {
                 sendUnauthorized(res, "identity");
                 return;
             }
-            if (deps.config.memoryEngineBackend === "file" || !deps.memoryExport) {
+            const exportFact = facts.memoryExport(deps);
+            if (!exportFact.available) {
                 sendError(res, 501, "capability.memory_store_required", "memory export requires a DB memory backend (MEMORY_ENGINE_BACKEND=pg|mysql)");
                 return;
             }
@@ -101,7 +104,7 @@ export async function handleMemoryPolicy(req, res, match, ctx) {
                 return;
             }
             try {
-                const fence = buildOriginFence(await deps.memoryExport(scope), readOriginAware(new URLSearchParams(match.search)));
+                const fence = buildOriginFence(await exportFact.read(scope), readOriginAware(new URLSearchParams(match.search)));
                 const entries = fence.entries;
                 const withheld = fence.withheldOriginTagged !== undefined ? { withheldOriginTagged: fence.withheldOriginTagged } : {};
                 if (limitRaw === null) {
@@ -135,9 +138,18 @@ export async function handleMemoryPolicy(req, res, match, ctx) {
                 sendUnauthorized(res, "identity");
                 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|mysql)");
-                return;
+            const serve = facts.memorySyncServe(deps);
+            if (!serve.available) {
+                switch (serve.why) {
+                    case "memory_db_plane_absent":
+                        sendError(res, 501, "capability.memory_store_required", "memory sync requires a DB memory backend (MEMORY_ENGINE_BACKEND=pg|mysql)");
+                        return;
+                    case "memory_sync_identity_undeclared":
+                        sendError(res, 501, "feature.memory_sync_serve_disabled", "this center serves no memory sync — it declares no sync identity: set MEMORY_SYNC_SERVE_IDENTITY to the base address clients reach this center at");
+                        return;
+                    default:
+                        return assertNever(serve.why);
+                }
             }
             const scope = safeDecode(match.params.scope);
             if (scope === null) {
@@ -153,11 +165,19 @@ export async function handleMemoryPolicy(req, res, match, ctx) {
             const body = await readJson(req);
             const parsed = parseMemorySyncRequest(body, scope);
             if (!parsed.ok) {
+                if ("peerFlaw" in parsed) {
+                    sendError(res, 400, "request.field_invalid", `peer ${memorySyncIdentityRule(parsed.peerFlaw)} — it must be the sync identity this client reaches the center at (the center's GET /v1/capabilities memorySyncServe.identity)`, { field: "peer", reason: parsed.peerFlaw });
+                    return;
+                }
                 sendError(res, 422, "memory_sync_invalid_body", parsed.error);
                 return;
             }
+            if (parsed.value.peer !== serve.identity) {
+                sendError(res, 409, "config.memory_sync_target_mismatch", `this center's sync identity is ${JSON.stringify(serve.identity)} and the round names another peer — nothing was read or written: set the client's MEMORY_SYNC_URL to that address (the client reaches this center under another address — a different hostname, port or path)`);
+                return;
+            }
             try {
-                const out = await deps.memorySync(scope, parsed.value);
+                const out = await serve.perform(scope, parsed.value);
                 sendJson(res, 200, out);
             }
             catch (err) {
@@ -194,6 +214,6 @@ export async function handleMemoryPolicy(req, res, match, ctx) {
 export const MEMORY_POLICY_ROUTES = [
     { id: "memory-export", path: "/v1/memory/export", methods: ["GET"] },
     { id: "policy", path: "/v1/policy", methods: ["GET"] },
-    { id: "memory-sync-scope", pattern: /^\/v1\/memory\/sync\/(?<scope>.*)$/, label: "/v1/memory/sync/:scope", methods: ["POST"] },
+    { id: "memory-sync-scope", pattern: /^\/v2\/memory\/sync\/(?<scope>.*)$/, label: "/v2/memory/sync/:scope", methods: ["POST"] },
 ];
 //# sourceMappingURL=memory-policy.js.map

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,10 +13,10 @@ 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 { causeOfAskRow } from "../../approval-deny-reasons.js";
+import { askRowEndingCause } from "../../approval-deny-reasons.js";
 import { normalizeRunEventType, screenedStoredEventData } from "../../trace/project.js";
 import { invalidJsonError, sendJson, sendError, sendHttpError, sseHeaders } from "../send.js";
 import { mintCancelledResult } from "../../run-cancel-context.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;
@@ -1429,10 +1430,10 @@ export async function handleRunVerbs(req, res, match, ctx) {
                     return;
                 case "DENIED":
                 case "VOID": {
-                    const rowCause = causeOfAskRow(row);
+                    const endingCause = askRowEndingCause(row);
                     sendError(res, 410, "gone.ask", "this ask reached a terminal state without a human decision (cause says why: a routing failure, a cancellation or batch withdrawal or abort, or the process that held it ended) and can no longer be decided", {
                         state: row.state,
-                        ...(rowCause?.kind === "ending" ? { cause: rowCause.cause } : {}),
+                        ...(endingCause !== undefined ? { cause: endingCause } : {}),
                     });
                     return;
                 }
@@ -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

@@ -0,0 +1,91 @@
+/**
+ * [ref] —— **会话记忆同步触发口**:`POST /v1/sessions/:id/memory/sync`  body `{ target: string }`
+ *   → 200 引擎的同步报告(core `memorySyncReportOf` 的产物,原样)
+ *
+ * 一口一件事:让本机的记忆同步腿**现在**对会话要去的那台引擎同步一轮,只回报这个会话读的那几层。壳在把会话推上云(fork)之前调它。
+ *
+ * ── 规则(规则账只减)────────────────────────────────────────────────────────────────────────────
+ *  R1 一轮 = 同步腿的一轮(`MemorySyncRunner.syncOnce`):交回每层每次调用如它落定的那样,从不整轮 reject —— 部分层失败落在报告的逐层结局里。
+ *  R2 同步身份一只铸点(`memory-sync-identity.ts`):`target` 必须**就是**目标引擎能力面公开的 `memorySyncServe.identity`(规范形、不带凭据),
+ *     与本机腿的 `peer` 按串相等比。壳不拼、本口不规范化。
+ *  R4 门之后的一切答复都是 core 报告:200 带 `layers`(每层恰一个结局)或整轮 `refused`(目标不符 / 会话有在飞的 run)。
+ *     HTTP 错误只留给报告产生之前的门(能力 / 身份 / id / 属主 / 体)与「读集不可取得」。本口不铸汇总键、不加第五种结局。
+ *  R5 可用性 = 能力事实 `sessionMemorySync`(本机同步腿 ∧ 持久 run 账面 ∧ 会话头读),与能力位同读一只;不从后端名推。
+ *
+ * ── 读集(这个会话读哪几层)────────────────────────────────────────────────────────────────────
+ * = 会话**最近一条已结腿**的记忆观测(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 只在受理时铸、不落会话行,重铸 = 重启前后两种答案。
+ *
+ * ── 门序(编号即执行序)──────────────────────────────────────────────────────────────────────────
+ *  1. 事实 `sessionMemorySync` 为假 ⇒ 501(码按 why)。先于身份:「这台部署有没有这一口」本由能力位公开。
+ *  2. 多租户部署上没有验过的身份 ⇒ 401/403(`sendPrincipalRefusal`,会话面同一只)。
+ *  3. 限流(本口会向远端发请求)。
+ *  4. 会话 id 段解码不了 ⇒ 400 `request.path_malformed`。
+ *  5. 一次头读:没有这只会话 / 不是你的 ⇒ 404 `not_found.session`(同码同串,无存在性 oracle;属主判据 = 会话面唯一谓词 `sessionOwnerOk`);
+ *     同一次头读的叶子 = `sourceRevision`(与 `GET /v1/sessions/:id/head` 的 `leafId` 同一读法)。
+ *  6. 体:闭集一键 `{ target }`,否则 400 `request.body_shape`;`target` 不是声明的同步身份 ⇒ 400 `request.field_invalid`(`field` / `reason`,不回显值)。
+ *  7. 读集(上一节)。
+ *  8. 目标比对:`target` ≠ 本机腿的 `peer` ⇒ 报告 `refused: config.memory_sync_target_mismatch`(句由 core 铸;零请求零本地写)。先于空读集出口。
+ *  9. 收割栅栏(前检):会话**不静** ⇒ 报告 `refused: session_active`(句由本服务铸)。零请求。
+ *     **静** = 一只谓词,前检与后检同读,三格合取:会话没有认领 ∧ 最近受理的腿**就是**观测所在的那一条(读完观测之后没有新 run 被受理)∧ 会话叶子仍是 `sourceRevision`
+ *     (会话的记录没有前进)。次序 = 认领 → 最近受理的腿 → 叶子:run 行在受理时同步落库、消息在那之后才追加,所以认领读之后才受理的 run 在第二只读里看得见;
+ *     第三格不靠建行时刻 —— 「最近受理」按建行时刻排序,副本之间钟偏 / 时钟回拨时一条后受理的 run 可以排在观测腿之前,而它只要跑过就挪动了叶子。
+ * 10. 一轮:读集为空 ⇒ 空报告(同一只铸点);否则 `syncOnce("session-trigger", { reading })`,只挑读集里的层的调用交给引擎出报告。
+ * 11. 收割栅栏(后检):轮落定后会话不静 ⇒ 第 9 步的报告 —— 这一轮的请求与写已经发生(幂等,下次触发重放),报告只是不再为这份读集作保。
+ *     报告之后、fork 之前的源前进不由本口封闭:壳拿 `sourceRevision` 与它推上云的会话头比。
+ * 12. 引擎的报告铸点自己抛 `TypeError`(名字带凭据 / 空串)⇒ 500 + 运维 warn(拒句不引原值)。同步层名起服时已过同一只凭据判官(`config.ts`),这一臂按构造不可达。
+ *
+ * ── 并发 ───────────────────────────────────────────────────────────────────────────────────────
+ * 同一会话、同一 `sourceRevision`、同一观测腿、同一 `target` 的请求各自走完 1–9,再**并入**在飞的那一轮,拿同一份报告(只减少重复工作,不延长等待)。
+ * 别的会话 / 后台轮经腿的同一条串行链(`exclusive`):会话触发的轮起跑晚于本请求到达。请求方断开不取消轮。本口不设自己的截止(= 各调用的传输超时之和)。
+ *
+ * ── 计费 / 门 ──────────────────────────────────────────────────────────────────────────────────
+ * 零模型工作(不 billable、不吃 drain 503);写的是调用方自己的记忆到它自己配置的中心 ⇒ 属主门兜底,不进无凭据改写门(会话自助抹除同判)。
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { type RouteCtx, type RouteMatch, type RouteIdsOf } from "../route-ctx.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)";
+/**
+ * 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";
+    readonly pattern: RegExp;
+    readonly label: "/v1/sessions/:id/memory/sync";
+    readonly methods: readonly ["POST"];
+}];
+/** 本域可分派行的 `id` 闭集 —— handler 的 `switch` 按它判穷尽(漏一口 = 编译红)。 */
+export type SessionMemorySyncRouteId = RouteIdsOf<typeof SESSION_MEMORY_SYNC_ROUTES>;
+//# sourceMappingURL=session-memory-sync.d.ts.map