@sema-agent/server 7.146.0 → 7.147.0

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

@@ -1,7 +1,7 @@
 /**
  * [ref] A9 域模块 —— 单会话面。
  *
- * 路由:`/v1/sessions/:id` 的 init / settings / mcp / head / events(SSE)/ fork / PATCH(会话行可写位)/ DELETE / policy / workspace,
+ * 路由:`/v1/sessions/:id` 的 init / settings / mcp / head / events(SSE)/ fork / rewind-files(run 外只恢复代码)/ PATCH(会话行可写位)/ DELETE / policy / workspace,
  * 外加同段的 `deps.sessionAudit` 只读审计面。
  *
  * 单域独占状态(lens1 §C2 的 12 条里的 5 条)全部收进 `SessionsLocal`,每个 server 实例一份:
@@ -121,6 +121,12 @@ export declare const SESSIONS_ROUTES: readonly [{
     readonly pattern: RegExp;
     readonly label: "/v1/sessions/:id";
     readonly methods: readonly ["GET"];
+}, {
+    readonly id: "session-rewind-files";
+    readonly pattern: RegExp;
+    readonly label: "/v1/sessions/:id/rewind-files";
+    readonly credentialGated: readonly ["POST"];
+    readonly methods: readonly ["POST"];
 }, {
     readonly id: "session-patch";
     readonly pattern: RegExp;

package/dist/http/routes/sessions.js

@@ -14,18 +14,23 @@ 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 { foldOwnerUnreadable, runRowReadableOnSessionFace } from "../owner-access.js";
+import { foldOwnerUnreadable, readOwnedSessionHead, 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";
 import { projectSessionListRow } from "./sessions-list.js";
 import { readSessionRowPatch } from "../../session-row.js";
-import { forkPathOf } from "../execution-context.js";
+import { forkPathOf, resolveExecutionContext } from "../execution-context.js";
 import { executionPlacementView } from "../../execution-placement.js";
+import { resolveHistoryAnchor } from "../../history-anchor.js";
+import { engineRefusalAnswerOf } from "../engine-refusal.js";
+import { buildRewindFilesReply } from "../rewind-files-reply.js";
 import { ForkTargetUnsettledError, forkKeyOf } from "../../plugins/session-fork.js";
 import { fieldConflictFacts } from "../../field-conflict.js";
 import { buildBoundedToolNames } from "../../panel-tool-names.js";
 import { projectMcpAuthorization } from "../../mcp-authorization-face.js";
+import { presentHostWorkspaceOf } from "../../task-cwd.js";
+import { rewindFilesUnderPurpose } from "../../execution-env-purpose.js";
 const MCP_STATUS_TTL_MS = 5_000;
 const A2A_STATUS_TTL_MS = 5_000;
 const A2A_MATERIALIZE_TIMEOUT_MS = 10_000;
@@ -743,6 +748,82 @@ export async function handleSessions(req, res, match, ctx) {
             }
         }
     }
+    if (match.decl.id === "session-rewind-files") {
+        if (ctx.helpers.rateLimited(req, res))
+            return;
+        const rewind = facts.sessionRewindFiles(deps);
+        if (!rewind.available) {
+            switch (rewind.why) {
+                case "file_history_store_absent":
+                    sendError(res, 501, "capability.snapshot_store_required", "rewinding a session's files is not available on this deployment: no file-history store is wired, so no file history was ever recorded");
+                    return;
+                case "session_head_face_absent":
+                    sendError(res, 501, "capability.session_store_required", "rewinding a session's files requires a durable session store (DB_BACKEND=mysql|pg|local)");
+                    return;
+                case "resume_anchor_store_absent":
+                    sendError(res, 501, "capability.session_store_required", "rewinding a session's files is not available on this deployment: no session-store backend holds the rewind anchor map");
+                    return;
+                case "execution_lane_handless":
+                    sendError(res, 501, "capability.unavailable", "rewinding a session's files is not available on this deployment: it mounts no execution environment (REMOTE_EXEC=none), so a session has no working tree to rewind");
+                    return;
+                case "workspace_rebuilt_per_task":
+                    sendError(res, 501, "capability.unavailable", "rewinding a session's files is not available on this deployment: each task's workspace is rebuilt when the task starts (fresh, or restored from a saved copy that a rewind cannot yet write into), so a rewind would not reach the files the next task works on");
+                    return;
+                case "session_store_shared":
+                    sendError(res, 501, "capability.unavailable", "rewinding a session's files is not available on this deployment yet: its session store is shared by several server instances (DB_BACKEND=mysql|pg), and a rewind cannot yet keep runs started on another instance off the session while it restores");
+                    return;
+                default:
+                    return assertNever(rewind.why);
+            }
+        }
+        const { anchors, sessionStorage } = rewind;
+        const sessionId = safeDecode(match.params.sessionId);
+        if (sessionId === null || !isUuidShape(sessionId)) {
+            sendError(res, 400, "request.id_invalid", "invalid session id (must be a canonical uuid)");
+            return;
+        }
+        const caller = sessionCallerOf(req, deps);
+        if (DEPLOYMENT_SHAPE_PREDICATES.principalRequired.holds(deps.config) && caller.principal === undefined) {
+            sendPrincipalRefusal(res, req, deps.config);
+            return;
+        }
+        const owned = await readOwnedSessionHead(deps, sessionStorage, caller, sessionId, "owner_or_operator");
+        if (owned === undefined) {
+            sendError(res, 404, "not_found.session", SESSION_NOT_FOUND_MESSAGE);
+            return;
+        }
+        const sessionOwner = owned.head.owner;
+        leafOfAdmittedHead(owned.head);
+        const read = readRewindFilesBody(await readJson(req));
+        if (read.kind === "refused") {
+            sendError(res, 400, read.errorCode, read.message);
+            return;
+        }
+        const execution = await resolveExecutionContext(deps, { kind: "continuation", root: sessionId, principal: sessionOwner ?? undefined });
+        if (execution.lane === "host" && (await presentHostWorkspaceOf(deps.perSessionCwd?.get(sessionId))) === undefined) {
+            sendError(res, 409, "conflict.session_workspace_unknown", "this server process does not know a working directory for this session that it can rewind into (no prompt carrying its cwd has been submitted since the server started, or the directory that prompt named no longer exists), so nothing was rewound; submit a prompt with its cwd first, then rewind");
+            return;
+        }
+        const entryId = await resolveHistoryAnchor("rewindFilesTo", anchors, sessionId, read.to, sessionOwner, "to");
+        const activeTaskId = await deps.runStore?.getActiveTaskId(sessionId);
+        if (activeTaskId) {
+            sendError(res, 409, "conflict.session_active_run", `session has an active run (${activeTaskId}); its files cannot be rewound under it — wait for that run to end (or cancel it), then rewind`, { activeTaskId });
+            return;
+        }
+        let result;
+        try {
+            result = await rewindFilesUnderPurpose(deps.runner, { sessionId, to: entryId, dryRun: read.dryRun });
+        }
+        catch (e) {
+            const answer = engineRefusalAnswerOf(e);
+            if (answer === undefined)
+                throw e;
+            sendError(res, answer.status, answer.refusal.errorCode, answer.refusal.message);
+            return;
+        }
+        sendJson(res, 200, buildRewindFilesReply(result));
+        return;
+    }
     {
         if (match.decl.id === "session-fork") {
             const forkFact = facts.sessionFork(deps);
@@ -967,6 +1048,7 @@ export const SESSIONS_ROUTES = [
     { id: "session-memory-status", pattern: /^\/v1\/sessions\/(?<sessionId>[^/]+)\/memory-status$/, label: "/v1/sessions/:id/memory-status", methods: ["GET"] },
     { id: "session-workspace", pattern: /^\/v1\/sessions\/(?<sessionId>[^/]+)\/workspace(?:\/(?<key>[^/]+)(?:\/(?<sub>tree|file|archive))?)?$/, label: "/v1/sessions/:id/workspace", methods: ["GET"] },
     { id: "session-detail", pattern: /^\/v1\/sessions\/(?<sessionId>[^/]+)$/, label: "/v1/sessions/:id", methods: ["GET"] },
+    { id: "session-rewind-files", pattern: /^\/v1\/sessions\/(?<sessionId>[^/]+)\/rewind-files$/, label: "/v1/sessions/:id/rewind-files", credentialGated: ["POST"], methods: ["POST"] },
     { id: "session-patch", pattern: /^\/v1\/sessions\/(?<sessionId>[^/]+)$/, label: "/v1/sessions/:id", methods: ["PATCH"] },
     { id: "session-delete", pattern: /^\/v1\/sessions\/(?<sessionId>[^/]+)$/, label: "/v1/sessions/:id", methods: ["DELETE"] },
 ];
@@ -989,4 +1071,24 @@ function readForkTarget(raw, sourceId) {
     return { kind: "keyed", forkId, forkNonce };
 }
 const FORK_NONCE_MAX_CHARS = 255;
+const REWIND_TO_MAX_CHARS = 255;
+function readRewindFilesBody(raw) {
+    const shape = {
+        kind: "refused",
+        errorCode: "request.body_shape",
+        message: 'the rewind-files body must be an object { to: string, dryRun?: boolean } — acceptPartialRestore is not accepted: the engine\'s out-of-run rewind has no partial-restore policy, so a partial restore answers 200 with restore.outcome "partial" and every refused or failed file on its ledger',
+    };
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return shape;
+    const keys = Object.keys(raw);
+    if (!keys.includes("to") || keys.some((k) => k !== "to" && k !== "dryRun"))
+        return shape;
+    const { to, dryRun } = raw;
+    if (typeof to !== "string" || to.length === 0 || to.length > REWIND_TO_MAX_CHARS) {
+        return { kind: "refused", errorCode: "request.field_invalid", message: `to must be a non-empty string of at most ${REWIND_TO_MAX_CHARS} characters: the handle of a prompt in this session (the handle rewindFilesTo takes)` };
+    }
+    if (dryRun !== undefined && typeof dryRun !== "boolean")
+        return { kind: "refused", errorCode: "request.field_invalid", message: "dryRun must be a boolean when given" };
+    return { kind: "read", to, dryRun: dryRun === true };
+}
 //# sourceMappingURL=sessions.js.map

package/dist/http/routes/tasks.js

@@ -16,7 +16,7 @@ import { buildCancelledLedgerRow, createRunAbort, mintCancelledResult } from "..
 import { recordResourceWindow } from "../../resource-window.js";
 import { redactSecrets } from "../../trace/redact.js";
 import { writeLiveFrame, writeLiveHeartbeat } from "../live-frame.js";
-import { contextUsageEventData, turnEndEventData, toolStartEventData, toolEndEventData, taskProgressEventData, taskStartedEventData, taskNotificationEventData, compactedEventData, diagnosticsEventData, brainStatusEventData, steeringInjectedEventData, compactionOutcomeEventData, compactionStartedEventData, workspaceChangedEventData, wiringManifestFaceEventData, toolRosterDeltaEventData, toolProgressEventData, toolDisclosureEventData, humanInputEventData, appendModelUsageDelta, attachModelUsage, liveIdentityFields } from "../../trace/project.js";
+import { contextUsageEventData, turnEndEventData, toolStartEventData, toolEndEventData, taskProgressEventData, taskStartedEventData, taskNotificationEventData, compactedEventData, diagnosticsEventData, brainStatusEventData, steeringInjectedEventData, compactionOutcomeEventData, compactionStartedEventData, workspaceChangedEventData, wiringManifestFaceEventData, toolRosterDeltaEventData, toolProgressEventData, toolDisclosureEventData, humanInputEventData, appendModelUsageDelta, attachModelUsage, createPromptManifestSeat, liveIdentityFields } from "../../trace/project.js";
 import { cascadeConfig, fillRunPreviewOnDelivery, runMeta } from "../run-meta.js";
 import { idemCallerOf, inflightKeyOf, submissionIdemOf } from "../idempotency.js";
 import { replayOfExistingRun } from "../submit-replay.js";
@@ -27,6 +27,7 @@ import { approvalPreambleReplays, createApprovalCardEmitter, declaredApprovalFra
 import { buildActiveRunConflict, isActiveRunConflictBody, toDoneFrameResult } from "../active-run-conflict.js";
 import { commitExecutionContext } from "../execution-context.js";
 import { rootSessionAbsentAnswer } from "../execution-context.js";
+import { timeClaim } from "../claim-latency.js";
 import { commitSessionInheritEnv } from "../session-inherit-env.js";
 import { headerStr, gatedPrincipal, explicitOperatorOk, runIdentityOf } from "../principal-gate.js";
 import { failOpenTagForDroppedFrame, recordFailOpen } from "../../observability/fail-open.js";
@@ -184,6 +185,7 @@ export async function handleTasks(req, res, match, ctx) {
                 }
                 reqState.streamTaskId = earlyDurableTid;
                 let usageKey;
+                let manifestSeat;
                 reqState.streamDetached = detachOnDisconnect;
                 sseHeaders(res, earlyDurableTid ? { "x-task-id": earlyDurableTid } : undefined);
                 if (earlyDurableTid)
@@ -302,7 +304,7 @@ export async function handleTasks(req, res, match, ctx) {
                     };
                     if (deps.runStore) {
                         const tid = earlyDurableTid ?? uuidv7();
-                        const created = await deps.runStore.createRun(tid, prepared.spec.sessionId, principal ?? null, deps.instanceId ?? "default", { ...runMeta(prepared, source), identity: runIdentityOf(req, deps.config, principal ?? null), idem: idem ?? null });
+                        const created = await timeClaim(deps.metrics, "run_claim", deps.runStore.createRun(tid, prepared.spec.sessionId, principal ?? null, deps.instanceId ?? "default", { ...runMeta(prepared, source), identity: runIdentityOf(req, deps.config, principal ?? null), idem: idem ?? null }));
                         if (created.ok)
                             clearTurnActivity(tid);
                         if (created.ok)
@@ -348,6 +350,7 @@ export async function handleTasks(req, res, match, ctx) {
                         ledgerSink = createLedgerSink({ appendEvent: (seq, type, data) => rs.appendEvent(tid, seq, type, data), persistThinking: deps.config.traceThinking, onActivity: (kind, statusData) => recordTurnActivity(tid, kind, statusData), legSections: legWiringSections, usage: { modelUsage: deps.modelUsage, taskId: tid } });
                         usageKey = tid;
                         deps.modelUsage?.register(tid);
+                        manifestSeat = createPromptManifestSeat(deps.promptManifests, tid);
                         const owner = principal ?? null;
                         const abortFromVerb = () => ac.abort("cancel_verb");
                         durableHeartbeat = setInterval(() => {
@@ -508,6 +511,8 @@ export async function handleTasks(req, res, match, ctx) {
                                     await deps.userInputLedger?.observeLegEvent(liveStream, ev);
                                     await prepared.acceptance.observe(ev);
                                     await liveWorkspace.observe(ev);
+                                    if (ledgerSink)
+                                        await manifestSeat?.drain(ledgerSink.append);
                                     if (ev.type === "done") {
                                         finalResult = await mintSubmitExitResult(ev.result, deps.checkpointStore);
                                         if (durableTaskId && finalResult)
@@ -869,6 +874,7 @@ export async function handleTasks(req, res, match, ctx) {
                     clearInterval(hb);
                     if (usageKey)
                         deps.modelUsage?.clear(usageKey);
+                    manifestSeat?.release();
                 }
                 if (!ranLive && resp && !res.writableEnded) {
                     writeLiveFrame(res, { type: "done", result: doneResultOfOutcome(resp), replay: true });
@@ -889,7 +895,7 @@ export async function handleTasks(req, res, match, ctx) {
                     let durableHeartbeat;
                     if (deps.runStore) {
                         const tid = uuidv7();
-                        const created = await deps.runStore.createRun(tid, prepared.spec.sessionId, principal ?? null, deps.instanceId ?? "default", { ...runMeta(prepared, source), identity: runIdentityOf(req, deps.config, principal ?? null), idem: idem ?? null });
+                        const created = await timeClaim(deps.metrics, "run_claim", deps.runStore.createRun(tid, prepared.spec.sessionId, principal ?? null, deps.instanceId ?? "default", { ...runMeta(prepared, source), identity: runIdentityOf(req, deps.config, principal ?? null), idem: idem ?? null }));
                         if (created.ok)
                             clearTurnActivity(tid);
                         if (created.ok)

package/dist/http/server.d.ts

@@ -21,6 +21,7 @@ import type { SubagentSteerRegistry } from "../orchestration/subagent-steer.js";
 import { type WorkflowCompletionInbox } from "../orchestration/workflow-completion-inbox.js";
 import type { FleetLeaseManager } from "../fleet-lease.js";
 import { type FleetEventBus } from "../fleet/fleet-bus.js";
+import type { SessionResidentCounts } from "../session-resident-background.js";
 import type { ElicitationCoordinator } from "../elicitation.js";
 import type { QuestionCoordinator } from "../question.js";
 import { type ParkedAskRedeem, type ToolApprovalCoordinator } from "../tool-approval.js";
@@ -100,7 +101,9 @@ export interface ServiceCoreDeps {
     /**
      * Map an inbound request body + resolved auth to a TaskSpec. The SERVICE/deployment owns model
      * + tools + mcp here (callers only supply content). `auth` carries the principal-derived memory scope —
-     * prefer it over anything in the body.
+     * prefer it over anything in the body. The root session is not read from `auth` either: the resolver's one reading of
+     * "which session is this leg on" is `opts.execution.root` (`auth.sessionId` is the authorizer's hand-off to the server's
+     * execution-context resolver, not a second reading for the resolver).
      * The root session is NOT the resolver's to write: the return type carries no `sessionId`
      * (`ResolvedTaskSpec`); the server stamps the root the authorizer resolved onto every spec it executes
      * (`http/execution-context.ts` `stampSpecRoot`). A resolver that needs the root reads `opts.execution.root`.
@@ -155,7 +158,8 @@ export interface ServiceCoreDeps {
      * `principalCaps`、同一份部署缺省):凡回答「此主体在此场景能看见哪些 MCP 服务器 / A2A 对端」的口 —— `GET /v1/capabilities/mcp` 的状态面、
      * `GET /v1/sessions/:id/mcp` 与 `…/a2a` 两张会话面板 —— 的场景名都由它给,**点名与缺席都问**:点名 ⇒ 判在册 / allowlist,
      * 拒体(400 `scenario_unknown` 附在册词表 / 400 `scenario_not_allowed` 附 allowlist)与任务提交腿逐字同;缺席 ⇒ 指派链(中心 ruling 胜者,
-     * 否则部署缺省),与这位主体 run 时同一读法(指派悬空 ⇒ 503 `state.scenario_assignment_unknown`,同提交腿)。
+     * 否则部署缺省),与这位主体 run 时同一读法(指派悬空 ⇒ 503 `state.scenario_assignment_unknown`,同提交腿)。中心配了却答不出这位主体的裁定 ⇒
+     * 点名与缺席同答 503 `state.scenario_assignment_unavailable`(同提交腿)。
      * 读面上这只门走**只读腿**(`createScenarioGate(…, "peek")`):问中心裁定时 center 抖动的那一拍,不替这个主体的真提交留下 fail-closed 降级项
      * (提交腿自己是 `"enforce"`)。
      * 🔴 **必填**:读口的场景名只有这一个来源,没有「缺接缝 ⇒ 读部署缺省 / 点名 404」这类第二种读法 —— 漏接是**编译错**(嵌入方自己装配时,工厂与它的型从包根导出:
@@ -717,16 +721,24 @@ export interface ServiceDeploymentDeps {
      * composition root 装起来的夹具)⇒ 两键都缺席,两面与没有声明的部署逐字节同。
      */
     deploymentModPackages?: number;
+    /**
+     * 会话 → 调用方登记的工作目录(提交体 `cwd` 的唯一写口 `setSessionCwd` 写的那一张进程内表,`boot/execution-env.ts` `createSessionScopedRegistries`)。
+     * **只读**,读者只有 run 外回退口(`POST /v1/sessions/:id/rewind-files`):host 工厂按 `effectiveHostWorkspace(本表.get(会话), ctx)` 定根(`execution-env.ts`
+     * host 臂),口在交引擎之前用**同一只函数、同一份入参**问「工厂这一次会不会落到一只用完即删的临时目录」—— 会 ⇒ 拒,不让台账说恢复了而项目没动。
+     * 缺席(夹具 / 嵌入方没接)⇒ 读作「没有登记」⇒ host 车道上口拒(fail-closed)。
+     */
+    perSessionCwd?: ReadonlyMap<string, string>;
     /**
      * Graceful drain — shared mutable state between main.ts (flips `draining` on SIGTERM) and this server:
      *  • while `draining`, NEW model-running submissions (the billable submit paths) get 503 + Retry-After, so an
      *    orchestrator/shell retries against the replacement instance; read paths + in-flight verbs (steer/cancel/
      *    respond/subagent) stay open so the runs we are waiting on can still finish/interact.
      *  • `inflight` is ASSIGNED BY createServer (a live union of this replica's in-flight legs: durable bg/resume
-     *    `inflightRuns` + live sync/resume streams `steerableRuns`, the leader leg, and the session-resident background
-     *    shells/monitors — `inflightBreakdown` is the same read split into its three terms) — an observable fact (`/health.inflight`).
-     *    `blockingInflight` (also ASSIGNED BY createServer) is the same breakdown minus the session-resident term: "is there still work that
-     *    must be waited out" — the drain wait main.ts polls after SIGTERM, the orphan/lease windows and the SIGHUP idle window read THAT.
+     *    `inflightRuns` + live sync/resume streams `steerableRuns`, the leader leg, the background sub-agents that outlived the leg
+     *    that spawned them, and the session-resident background shells/monitors — `inflightBreakdown` is the same read split into its
+     *    four terms) — an observable fact (`/health.inflight`).
+     *    `blockingInflight` (also ASSIGNED BY createServer) is the SAME breakdown function minus the session-resident shell term: "is there still
+     *    work that must be waited out" — the drain wait main.ts polls after SIGTERM, the orphan/lease windows and the SIGHUP idle window read THAT.
      *  • /health carries `draining:true` + `version` (build self-description); draining is a readiness reason
      *    (`http/readiness.ts`) ⇒ `/readyz` 503 + `/health` `ready:false` (the k8s readiness 摘流信号).
      *  • [ref]:`attachedStreams` 同样 ASSIGNED BY createServer —— 本副本当前打开着的 SSE 流条数
@@ -738,11 +750,13 @@ export interface ServiceDeploymentDeps {
      */
     drainState?: import("../fleet/drain-entry.js").DrainState;
     /**
-     * 在飞数第四类的读口:本进程**会话驻留的后台 shell / monitor** 行数(`session-resident-background.ts` 的 `countSessionResidentBackground` 在 composition root 绑上围栏表;
-     * 法与边界见该文件头)。`createHttpServer` 把它作为 `inflightBreakdown.sessionResident` 并进总数 `drainState.inflight` 的**同一次读**;它**不**进阻断集
-     * `drainState.blockingInflight`(排空 / 孤儿窗与附着租约自退 / SIGHUP 空闲窗判停读阻断集)。缺席(嵌入方 / 夹具)= 这一项恒 0,`inflight` 逐字同改前。
+     * 会话驻留后台行的读口:本进程活过起它的腿、仍在跑的**后台子代理**与**后台 shell / monitor**,一次走查交出两项(`session-resident-background.ts` 的
+     * `countSessionResidentBackground` 在 composition root 绑上围栏表;法与边界见该文件头)。`createHttpServer` 把两项并进**唯一的分项函数** `inflightBreakdown`:
+     * `backgroundAgents` 进阻断集 `drainState.blockingInflight`(排空 / 孤儿窗与附着租约自退 / SIGHUP 空闲窗判停读它)与总数,`sessionResident` 只进总数 `drainState.inflight`。
+     * 读口**不许抛**:判停路径每拍读它,排空首读在期限计时器装上之前 —— 一抛就永不硬停(组合根那只按会话收住读失败、计 1 并报出)。
+     * 缺席(嵌入方 / 夹具)= 两项恒 0,两个读数逐字同 7.145.x。
      */
-    sessionResidentBackground?: () => number;
+    sessionResidentBackground?: () => SessionResidentCounts;
     /** 编排器片 2 件 3:服务租约此刻的读数(`fleet/serving-lease.ts` 的客户端交出;引擎信号铸点与计费准入判同读)。缺席 = 没装租约客户端
      *  (非 fleet 成员 / 没接中心 / 测试夹具)⇒ `none`(与没有租约的引擎逐字同)。 */
     servingLease?: () => import("../fleet/engine-signal.js").ServingLeaseView;

package/dist/http/server.js

@@ -26,6 +26,7 @@ import { sqlEngineSeatIssue } from "../sql-engine-posture.js";
 import { parkDecisionStoreRefusal } from "../orchestration/workflow-park-decision.js";
 import { CHECKPOINT_CTX_SEALING_REQUIRED } from "./checkpoint-ctx.js";
 import { PARKED_REVIVE_EXECUTION_SEAT_REQUIRED } from "../parked-decide.js";
+import { operatorDeclarationRefusal } from "../config-invariants.js";
 import { retiredServiceDepsRefusal } from "./retired-service-deps.js";
 import { createAdmission, MAX_SKILL_CONTENT_CHARS, MAX_SYSTEM_PROMPT_CHARS, MAX_OUTPUT_SCHEMA_CHARS, validateUserSkills } from "./admission.js";
 import { createResumeLegs } from "./resume-legs.js";
@@ -76,6 +77,12 @@ export function createHttpServer(rawDeps) {
         if (retired !== undefined)
             throw new Error(retired);
     }
+    {
+        const operatorDeclarationFailure = operatorDeclarationRefusal(deps.config);
+        if (operatorDeclarationFailure !== undefined) {
+            throw new Error(operatorDeclarationFailure);
+        }
+    }
     {
         const issue = sqlEngineSeatIssue(deps.backend, deps.sqlEngine);
         if (issue !== undefined) {
@@ -106,15 +113,19 @@ export function createHttpServer(rawDeps) {
     const steerableRuns = new Map();
     const wakeParkMints = new Map();
     const counters = { uncountedBillableInflight: 0, admittedInflight: 0 };
-    const blockingParts = () => ({
-        http: liveRunIdsOf(inflightRuns, steerableRuns).size + counters.uncountedBillableInflight + counters.admittedInflight,
-        leader: deps.leaderEndpoint?.inflight?.() ?? 0,
-    });
-    const inflightBreakdown = () => ({ ...blockingParts(), sessionResident: deps.sessionResidentBackground?.() ?? 0 });
+    const inflightBreakdown = () => {
+        const resident = deps.sessionResidentBackground?.() ?? { backgroundAgents: 0, sessionResident: 0 };
+        return {
+            http: liveRunIdsOf(inflightRuns, steerableRuns).size + counters.uncountedBillableInflight + counters.admittedInflight,
+            leader: deps.leaderEndpoint?.inflight?.() ?? 0,
+            backgroundAgents: resident.backgroundAgents,
+            sessionResident: resident.sessionResident,
+        };
+    };
     if (deps.drainState) {
         deps.drainState.inflightBreakdown = inflightBreakdown;
         deps.drainState.inflight = () => inflightTotal(inflightBreakdown());
-        deps.drainState.blockingInflight = () => blockingInflightOf(blockingParts());
+        deps.drainState.blockingInflight = () => blockingInflightOf(inflightBreakdown());
     }
     let lastBillableActivityAt = performance.now();
     let firstBillableActivityAt = null;

package/dist/http/stored-body-replay.d.ts

@@ -10,6 +10,7 @@
 import type { PermissionMode } from "@sema-agent/core";
 import { type Autonomy } from "../runtime-governance.js";
 import { type ExecutionConfigRootDeployment } from "../execution-config-root.js";
+import { type UnreadMembersDeployment } from "../unread-request-members.js";
 import { type ModelApiKeyEnvTable } from "../server-secret-env.js";
 import { type StoredBodyReplayRefusal } from "./checkpoint-ctx.js";
 import type { CheckpointCtx } from "./route-ctx.js";
@@ -23,15 +24,16 @@ export declare function permissionModeReadingUnstated(ctx: CheckpointCtx, floor:
     floor: PermissionMode;
 } | undefined;
 /**
- * 预判读的部署配置:`autonomy`(模式词问的模式词地板)、执行车道的 home 两位(`~/` 形规则那一问)与配置根的几位(user 设置层 `/` 规则那一问)。`ServiceConfig` 结构上满足,四个问点传 `deps.config` 整份。
+ * 预判读的部署配置:`autonomy`(模式词问的模式词地板)、执行车道的 home 两位(`~/` 形规则那一问)、配置根的几位(user 设置层 `/` 规则那一问)与「请求成员读不出」那一问的
+ * 租户轴 / 两只注入闸的否决位。`ServiceConfig` 结构上满足,四个问点传 `deps.config` 整份。
  */
-export type StoredReplayDeployment = ExecutionConfigRootDeployment & {
+export type StoredReplayDeployment = ExecutionConfigRootDeployment & UnreadMembersDeployment & {
     readonly autonomy?: Autonomy | undefined;
     /** 生效配置模型条目 name → `apiKeyEnv`(`settings.env` 凭据判据的名单一臂;缺席 = 没有模型条目,与 `serverCredentialValueSources` 的缺省同读)。 */
     readonly modelApiKeyEnv?: ModelApiKeyEnvTable | undefined;
 };
 /**
- * 四问一只判据:不能重放 ⇒ 返回拒的那条规则;能 ⇒ `undefined`。顺序:allow 读法(体里带非空 `allow` 而写者版本证不出 ≥ 7.117.0;常设,按写者版本)→ 请求设置里的条目表(**与拒点同序**:桶门〔形 / 空串 / 超帽〕→ 工具名清单读成空〔**只问限制方向**:放行方向的存量条目读成空,续跑照旧、只留一行运维 warn〕→ deny / ask 的名字层 + 规则文法)→ 模式词读法记号 → 体里的退役请求键(几问同中时答先中的那一问 ——
+ * 四问一只判据:不能重放 ⇒ 返回拒的那条规则;能 ⇒ `undefined`。顺序:allow 读法(体里带非空 `allow` 而写者版本证不出 ≥ 7.117.0;常设,按写者版本)→ 请求设置里的条目表(**与拒点同序**:桶门〔形 / 空串 / 超帽〕→ 工具名清单读成空〔**只问限制方向**:放行方向的存量条目读成空,续跑照旧、只留一行运维 warn〕→ 请求成员读不出〔hooks / env / MCP transport / A2A headers …,判据 `unread-request-members.ts`〕→ deny / ask 的名字层 + 规则文法)→ 模式词读法记号 → 体里的退役请求键(几问同中时答先中的那一问 ——
  * 任一问中都不重放,句子只需一句)。`deployment` = 本部署**此刻**的 `config`(活 config:热改即生效):`autonomy` 的地板由它的唯一属主算,`~/` 形规则的 home 由 `executionLaneHomeDir` 算,问点都不自己算。
  */
 export declare function storedBodyReplayRefusal(ctx: CheckpointCtx, deployment: StoredReplayDeployment): StoredBodyReplayRefusal | undefined;

package/dist/http/stored-body-replay.js

@@ -7,6 +7,8 @@ import { executionLaneHomeDir } from "../execution-lane-caps.js";
 import { executionConfigRootOf } from "../execution-config-root.js";
 import { migrationWindowEnd } from "../plugins/one-time-migrations.js";
 import { storedEnvCredentialsDropM38 } from "../stored-request-env-credentials-m38.js";
+import { storedToolAxesRereadM19 } from "../stored-request-tool-axes-m19.js";
+import { MAX_NAMED_MEMBERS, unreadRequestMembers, unreadRequestMembersRefusal } from "../unread-request-members.js";
 import { serverCredentialValueSources } from "../server-secret-env.js";
 import { allowListWriterUnproven, permissionModeReadingStated, retiredRequestKeyOf } from "./checkpoint-ctx.js";
 export function permissionModeReadingUnstated(ctx, floor) {
@@ -75,7 +77,14 @@ export function storedBodyReplayRefusal(ctx, deployment) {
     const envCredential = storedEnvCredentialRefusal(ctx.body, deployment);
     if (envCredential !== undefined)
         return { kind: "settings_env_credential", refusal: envCredential };
-    const entry = inertToolListEntryOf(ctx.body, ["deny"]) ?? storedRulePolicyRefusal(ctx.body, deployment);
+    const inert = inertToolListEntryOf(ctx.body, ["deny"]);
+    if (inert !== undefined)
+        return { kind: "inert_tool_list", entry: inert };
+    const today = new Date().toISOString().slice(0, 10);
+    const unread = unreadRequestMembers({ settings: ctx.body.settings, mcpServers: ctx.body.mcpServers, a2aPeers: ctx.body.a2aPeers }, deployment, { replay: true, today, storedToolAxes: storedToolAxesRereadM19(today) });
+    if (unread.length > 0)
+        return { kind: "unread_members", refusal: unreadRequestMembersRefusal(unread), members: unread.slice(0, MAX_NAMED_MEMBERS), memberCount: unread.length };
+    const entry = storedRulePolicyRefusal(ctx.body, deployment);
     if (entry !== undefined)
         return { kind: "inert_tool_list", entry };
     const mode = permissionModeReadingUnstated(ctx, autonomyModeFloor(deployment.autonomy));

package/dist/http/wire-types.d.ts

@@ -46,7 +46,8 @@ export interface TaskRequestBody {
      *  `scenario_unknown`, a known-but-not-allowed one a typed 400 `scenario_not_allowed`; absent ⇒ the ruling's
      *  assigned scenario, else `DEFAULT_SCENARIO` (consumed at `boot/resolve-spec.ts` via `gateScenarioRequest`). A name
      *  on that default chain this deployment does not have is NEVER folded to `default`: an assigned one is a typed 503
-     *  `state.scenario_assignment_unknown`, a dangling `DEFAULT_SCENARIO` refuses to boot.
+     *  `state.scenario_assignment_unknown`, a dangling `DEFAULT_SCENARIO` refuses to boot. On a center-wired deployment whose
+     *  center cannot answer for this principal, named or absent alike is a typed 503 `state.scenario_assignment_unavailable`.
      *  ⚠️ scenario-SPECIFIC keys (`repo`/`lenses`/`rounds`, read through `ScenarioRequest`'s index signature) are
      *  deliberately NOT declared here — they belong to one scenario each, not to the shared submit surface. */
     scenario?: string;
@@ -189,10 +190,12 @@ export interface TaskRequestBody {
      *  400 (fail-loud, never silently dropped — the body.model silent-drop bug class). Absent ⇒ core uses the resolved
      *  role's default thinking. NEVER `budgetTokens`/`fast_mode` (provider-neutral by omission). */
     reasoningEffort?: string;
-    /** Resume-at (shell-host contract E18): the E2 message `eventId` to rewind the conversation to — core branches the
-     *  session at that prior message before running the new objective ("rewind to this message, ask differently").
-     *  The service resolves eventId→the persisted SessionTreeEntry.id (the anchor map) in resolveSpec; an unknown
-     *  eventId is a 4xx (never silently dropped). Requires a session. Absent ⇒ continue from the current leaf. */
+    /** Resume-at (shell-host contract E18): the history-anchor handle of the prior message to rewind the conversation to
+     *  (a message's E2 `eventId`, or a prompt's `taskId` — the anchor map holds both) — core branches the session at
+     *  that message before running the new objective ("rewind to this message, ask differently"). The service resolves
+     *  handle → the persisted SessionTreeEntry.id through the ONE anchor reader (`history-anchor.ts`) in resolveSpec; an
+     *  unknown handle is a 404 `resume_at.unknown_event` (never silently dropped). Requires a session. Absent ⇒ continue
+     *  from the current leaf. */
     resumeAt?: string;
     /** [ref] rewind exclusive mode (core 1.292 `TaskSpec.resumeAtMode`): qualifies the `resumeAt` target. `"at"`
      *  (default when absent — zero regression) keeps the target message in the branched context; `"before"` branches at
@@ -224,12 +227,18 @@ export interface TaskRequestBody {
      *  either way. Requires a FileHistoryStore. */
     restoreFiles?: boolean;
     /** DV-15: opt-in tolerance for a PARTIAL file restore (default = loud terminal failure carrying the per-file
-     *  ledger; `true` = keep going and disclose the same ledger on the result's rewindNotes). */
+     *  ledger; `true` = keep going and disclose the same ledger on the result's rewindNotes). A RUN-seat policy only
+     *  ("may the agent keep working on a mixed tree"): the out-of-run `POST /v1/sessions/:id/rewind-files` has no such
+     *  key — the engine's out-of-run rewind has no partial policy and that route answers the ledger as it stands. */
     acceptPartialRestore?: boolean;
     /** R8 code-only rewind (CC "Restore code" mode): converge the TRACKED set to the history boundary at a prior
-     *  USER message WITHOUT forking the conversation (the session leaf is untouched — only the files move). The
-     *  value is the same handle as `resumeAt` (the prompt's taskId); the service resolves it → the entry id. Honored ONLY
-     *  when `resumeAt` is ABSENT (the two modes are mutually exclusive). Requires the anchor map + a FileHistoryStore. */
+     *  USER message WITHOUT forking the conversation (the session leaf is untouched — only the files move). The value is
+     *  a history-anchor handle, NOT a SessionTreeEntry.id: the prompt's `taskId` (`messages[].taskId` on the session view;
+     *  the same handle space `resumeAt` reads) — the service resolves it → the entry id through the one anchor reader
+     *  (unknown ⇒ 404 `rewind_files_to.unknown_event`). Honored ONLY when `resumeAt` is ABSENT (the two modes are mutually
+     *  exclusive). Requires the anchor map + a FileHistoryStore + the session store's head read (capability
+     *  `rewindFilesTo`). Its out-of-run twin — no run, no model call — is `POST /v1/sessions/:id/rewind-files` with the same
+     *  handle in `to` (capability `sessionRewindFiles`). */
     rewindFilesTo?: string;
     /** [ref](core 7.31.0 [ref] `TaskSpec.fileHistory`)—— 请求级的**文件历史关断词**,唯一词 `"disabled"`(core 的拼法,
      *  与 `checkpointStore` 同;没有 `"enabled"` —— 缺席就是「部署说了算」的唯一形,声明只能单向收紧)。`"disabled"` ⇒
@@ -457,7 +466,7 @@ export interface TaskRequestBody {
      *  · `"scrub"` —— 缺省清洗(剥凭据形变量),**任何车道、任何部署**都受理(它就是缺省;7.106.0 合并复审 X7)。
      * **缺席 = 缺省清洗**:不带键的请求把本会话的绑定清掉(不继承上一条请求的声明 —— 这一位是「本条请求要什么」,
      * 粘到下一条上就是替一个没说话的请求放宽)。名单形(`string[]`)**不上 wire**(那是嵌入方构造执行环境的选项)。
-     * 🔒 **只有 host 车道有消费点**:别的车道(e2b / k8s / local-docker / ssh / adb / device / in-process)带 `"all"` ⇒
+     * 🔒 **只有 host 车道有消费点**:别的车道(e2b / k8s / local-docker / ssh / adb / device / none)带 `"all"` ⇒
      * 400 `request.field_invalid`(`reason: lane_not_host`)「applies to the host lane only」,不静默忽略、不映射到别的车道的 env 名单;`"scrub"` 在那些车道上照受理(无消费点,无害)。
      * Rides the persisted body onto resume legs:重放照射程与车道重判(部署由单用户改托管后 revive ⇒ 同一只拒,
      * resume-legs 折成 `409 resume_blocked_by_policy`)。

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 export { loadConfig, type ServiceConfig } from "./config.js";
-export { composeExecutionLane, assertExecutionLaneInvariants, type ExecutionLaneComposeCtx } from "./boot/execution-lane.js";
+export { composeExecutionLane, assertExecutionLaneInvariants, HTTP_SERVICE_LANE_ENTRY, type ExecutionLaneComposeCtx, type ExecutionLaneEntry } from "./boot/execution-lane.js";
 export { createBrain } from "./brain.js";
 export { createSessionStore } from "./plugins/session-store.js";
 export { createStoreBackend, type StoreBackend, type SessionCaptureRecordSource } from "./plugins/store-backend.js";
 export { RetiredSchemaPresentError } from "./plugins/schema-consistency.js";
-export { LocalDataRootSchemaMismatchError, type LocalSidecarMismatch } from "./plugins/local-session-store.js";
+export { LocalDataRootSchemaMismatchError, type LocalDataRootMismatch } from "./plugins/local-session-store.js";
 export { CachingSessionStore, type CachingOptions } from "./plugins/caching-session-store.js";
 export type { RunRecord, RunEvent } from "./plugins/store-contracts.js";
 export { runInBackground } from "./runs.js";

package/dist/index.js

@@ -1,5 +1,5 @@
 export { loadConfig } from "./config.js";
-export { composeExecutionLane, assertExecutionLaneInvariants } from "./boot/execution-lane.js";
+export { composeExecutionLane, assertExecutionLaneInvariants, HTTP_SERVICE_LANE_ENTRY } from "./boot/execution-lane.js";
 export { createBrain } from "./brain.js";
 export { createSessionStore } from "./plugins/session-store.js";
 export { createStoreBackend } from "./plugins/store-backend.js";

package/dist/instruction-source-notice.d.ts

@@ -10,7 +10,7 @@
  *
  * ## 基线 = 会话的服务端元数据
  * 基线是「同一 session 上一次 run 选中的链成员相对路径」(不是指纹:指纹密钥每进程随机,跨进程不可比)。它住在会话店的
- * 服务端元数据面 —— SQL 两孪生是 `session_meta.instruction_source` 一列,local 文件店是一只 sidecar —— 所以重启 /
+ * 服务端元数据面 —— SQL 两孪生是 `session_ext.instruction_source` 一列,local 文件店是一只 sidecar —— 所以重启 /
  * 跨副本都读得到、随会话删除一起消失,且不进模型上下文、不进 wire 会话面。不接这张面的店(core 的内存 dev 店、
  * `run-local` 的 core 文件店)⇒ 席缺席 ⇒ 一帧不发(诚实缺席:那两形的会话本来就活不过进程,或没有会话流可投)。
  *

package/dist/memory-embedder-reembed.d.ts

@@ -0,0 +1,38 @@
+/**
+ * `memory-embedder-reembed.ts` —— 「清列重嵌」**确认口令**的单一属主:`MEMORY_EMBEDDER_REEMBED=<model>/<dimensions>`。
+ *
+ * ## 律(一句)
+ *
+ * embedder 指纹门(`plugins/memory-embedder-fingerprint.ts`)从不凭自己的判断清列:记下的身份与配置的身份对不上
+ * (changed / unattributed / unreadable 三态)⇒ 拒启;唯一出路是运维显式确认「把向量列清掉、按**这个**身份重嵌」——
+ * 口令的值就是**配置的那个身份**。口令绑定身份,所以它天然是一次性的:清完并记下这个身份之后,下一次起服判「相等」,
+ * 口令不再有东西可确认;之后再换一次模型,留着的旧口令对不上新配置 ⇒ 起服拒(不会替下一次换模型静默清列)。
+ *
+ * ## 为什么是一只顶层叶模块
+ *
+ * 两个消费方在不同层:`config.ts` 在 boot 期解析并判口令(拼错 / 对不上配置 ⇒ 拒启),指纹门在拒句里**写出**这条口令。
+ * config 层不得值引 plugins 层;口令的读写形只有一份,两层各按需引 —— 这是本文件存在的全部理由。零依赖。
+ *
+ * 句子里写给运维**照抄**的那条赋值只有一个写者 {@link formatReembedAssignment}:值按 POSIX 单引号包起(模型名可以含空格 / `$` / 引号,
+ * 不包就粘不进 shell);引号只是 shell 的写法,shell 读完赋给 env 的值仍是 `<model>/<dimensions>` 本身(config 读的就是它)。
+ */
+/** 口令那一键的名字(config 读它、门的拒句写它)。 */
+export declare const MEMORY_EMBEDDER_REEMBED_ENV = "MEMORY_EMBEDDER_REEMBED";
+/** 口令所确认的身份形(与指纹门的 `EmbedderIdentity` 同形;本叶不引 zod)。 */
+export interface EmbedderIdentityToken {
+    readonly model: string;
+    readonly dimensions: number;
+}
+/** 身份 → 口令值:`<model>/<dimensions>`。模型名自身可以含 `/`(`BAAI/bge-m3`)—— 维度恒在**最后一个** `/` 之后。 */
+export declare function formatEmbedderIdentityToken(identity: EmbedderIdentityToken): string;
+/**
+ * 运维照抄的那条赋值:`MEMORY_EMBEDDER_REEMBED='<model>/<dimensions>'`。POSIX 单引号:值内唯一的元字符是 `'` 本身,写成 `'\''`
+ * (关引号、转义一个 `'`、再开引号)。拒句与 config 的出路句都经这里写,不各拼一份。
+ */
+export declare function formatReembedAssignment(identity: EmbedderIdentityToken): string;
+/**
+ * 口令值 → 身份;形不对 ⇒ `undefined`(调用方拒启并给出期望形,不猜)。判据:最后一个 `/` 之前非空(模型名),
+ * 之后是十进制正整数(无前导零、无符号、无空白)。`true` / `1` / `yes` 这类「开关形」一律不是口令。
+ */
+export declare function parseEmbedderIdentityToken(raw: string): EmbedderIdentityToken | undefined;
+//# sourceMappingURL=memory-embedder-reembed.d.ts.map

package/dist/memory-embedder-reembed.js

@@ -0,0 +1,20 @@
+export const MEMORY_EMBEDDER_REEMBED_ENV = "MEMORY_EMBEDDER_REEMBED";
+export function formatEmbedderIdentityToken(identity) {
+    return `${identity.model}/${identity.dimensions}`;
+}
+export function formatReembedAssignment(identity) {
+    return `${MEMORY_EMBEDDER_REEMBED_ENV}='${formatEmbedderIdentityToken(identity).replace(/'/g, "'\\''")}'`;
+}
+export function parseEmbedderIdentityToken(raw) {
+    const cut = raw.lastIndexOf("/");
+    if (cut <= 0)
+        return undefined;
+    const digits = raw.slice(cut + 1);
+    if (!/^[1-9][0-9]*$/.test(digits))
+        return undefined;
+    const dimensions = Number(digits);
+    if (!Number.isSafeInteger(dimensions))
+        return undefined;
+    return { model: raw.slice(0, cut), dimensions };
+}
+//# sourceMappingURL=memory-embedder-reembed.js.map

package/dist/memory-incident-sink.d.ts

@@ -1,31 +1,3 @@
-/**
- * 记忆引擎 **incident 席**在本仓的唯一落点形。
- *
- * ## 为什么要一只共用工厂(而不是每个宿主各写一行 `logger.warn`)
- * core 的记忆引擎有**两条**到宿主的披露路:
- *  · **mount 路**——`MemoryEngine` 自己的 `onIncident`,由 core 的 Runner 在 `prepare-memory` 里桥到
- *    `RunnerDeps.onError(err, { phase: "memory", sessionId })`(亲读 `dist/core/runner/prepare-memory.js`
- *    的 `const onEngineIncident = (err) => deps.onError?.(err, { phase: "memory", sessionId })`);
- *  · **无锁公开面路**——`FileMemoryEngineBackend` 的**构造期** `onIncident`,是那条腿上唯一的披露口
- *    (`adoptLayoutLocked` 取 `onIncident ?? this.onIncident`)。
- * 同一条事实(例如一次性的目录布局搬家)会按调用路径落到其中**一条**,而本仓有**两个宿主**
- * (HTTP 服务的 `boot/runner-deps.ts` 与 `run-local.ts`)各自持有 `onError` 座。四个落点各写一行 =
- * 四份会各自漂移的形;实际已经漂过一次:服务腿把整族印成 `memory_consolidation_failed`(只有一支是
- * consolidation),run-local 腿把整族印成 `engine_error` 并用 `String(err)` 抹掉 `err.code`。
- *
- * ## 形(一处定义,四处引用)
- * `memory_engine_incident` + `{ sessionId?, code?, detail }`,并计 `memory_engine_incident_total{code?}`。
- * 🔴 `code` 是**结构化字段**而不是被折进散文:它是运维唯一能按名告警的那一位,而这一族里最要紧的几条
- * (一次性布局搬家、无主根内容、控制面写失败)一辈子只发生一次 —— 折平就等于没说。
- * 码的读法与 `boot/runner-deps.ts` 的 `onError` 汇点其余七条行**同一只**(`terminal.ts` 的 `codeFieldOf`:不抛的读口 + 码判官 `isCodeToken`):是码才带;
- * 无码(core 里有大量不带 `.code` 的记忆相 Error)、不是串 / 空串、非 `Error` 抛出物、读取时抛、或带的不是码(超长 / 含空白 / 凭据形 —— 引擎错上的 `code` 是别人写的串)⇒ 行里**没有** `code` 键、
- * 计数**没有** `code` 标签:不编码,也不写 `null` / `"none"` 之类的占位。
- *
- * ⚠️ 与三只 **operator 面**引擎座(`memory_compliance_incident` / `memory_origin_incident` /
- * `memory_consolidation_incident`)**事件名刻意不合并**:那三条的事件名回答「哪一张操作面」,是三个产品面的
- * 分辨位;本工厂回答「引擎事故席」,是同一件事的四个落点。合并会丢掉前者的分辨位。三座有自己的工厂
- * {@link createOperatorFaceIncidentSink}(事件名由装配处点名),`code` 位与本工厂读同一只 `codeFieldOf`。
- */
 import type { Logger } from "./observability/logger.js";
 import type { Metrics } from "./observability/metrics.js";
 /** 落点依赖。`metrics` 可缺席(run-local 的 backend 构造期座就没有计数面的消费者)。 */