@sema-agent/server 7.147.0 → 7.148.0

package/dist/http/durable-run-leg.js

@@ -1,6 +1,7 @@
 import { uuidv7 } from "@sema-agent/core";
 import { heldWorkflowParkDecisions } from "../parked-decide.js";
-import { HEARTBEAT_MS, runInBackground } from "../runs.js";
+import { runInBackground } from "../runs.js";
+import { recheckClaimBeforeLaunch, refusalAfterLostClaim, startClaimHeartbeat } from "./claim-heartbeat.js";
 import { heldFor } from "../peer-seat.js";
 import { fleetRunPublisher, fleetRunLabels, nameFleetRowOnDelivery } from "../fleet/fleet-bus.js";
 import { cascadeConfig, fillRunPreviewOnDelivery, runMeta } from "./run-meta.js";
@@ -12,7 +13,7 @@ import { timeClaim } from "./claim-latency.js";
 import { commitSessionInheritEnv } from "./session-inherit-env.js";
 import { clearTurnActivity, readTurnActivityMs } from "../turn-activity.js";
 import { recordResourceWindow } from "../resource-window.js";
-import { persistSubmissionCtx } from "./submit-ctx.js";
+import { persistSubmissionCtx, SUBMIT_CTX_CLAIM_LOST } from "./submit-ctx.js";
 import { releaseClaimedRun } from "./claimed-run.js";
 import { headReadOf } from "../session-incarnation.js";
 import { createSessionWorkspaceRecorder, sessionWorkspaceStoreOf } from "../session-workspace.js";
@@ -22,7 +23,7 @@ export async function mintAndDriveDurableRun(ctx, runStore, args) {
     const sessionId = args.prepared.spec.sessionId;
     const taskId = args.clientTaskId ?? uuidv7();
     const trustedInternals = await heldWorkflowParkDecisions(deps, sessionId, args.workflowDecision?.carried);
-    const created = await timeClaim(deps.metrics, "run_claim", runStore.createRun(taskId, sessionId, args.prepared.auth?.principal ?? null, deps.instanceId ?? "default", { ...runMeta(args.prepared, args.source), identity: args.identity, idem: args.idem ?? null }));
+    const created = await timeClaim(deps.metrics, "run_claim", runStore.createRun(taskId, sessionId, args.prepared.auth?.subject ?? null, deps.instanceId ?? "default", { ...runMeta(args.prepared, args.source), identity: args.identity, idem: args.idem ?? null }));
     if (created.ok)
         clearTurnActivity(taskId);
     if (created.ok)
@@ -32,20 +33,20 @@ export async function mintAndDriveDurableRun(ctx, runStore, args) {
     if (created.sessionAbsent)
         return rootSessionAbsentAnswer();
     if (!created.ok) {
-        return { status: 409, body: await buildActiveRunConflict({ runStore, checkpointStore: deps.checkpointStore, governance: deps.config, runStaleSec: deps.config.runStaleSec, turnActivity: readTurnActivityMs }, sessionId, created.activeTaskId) };
+        return { status: 409, body: await buildActiveRunConflict({ runStore, checkpointStore: deps.checkpointStore, governance: deps.config, turnActivity: readTurnActivityMs }, sessionId, created.activeTaskId) };
     }
     fillRunPreviewOnDelivery(args.prepared.acceptance, runStore, taskId);
-    const owner = args.prepared.auth?.principal ?? null;
-    const preLaunchHeartbeat = setInterval(() => {
-        void runStore.heartbeat(taskId, owner).catch(() => { deps.metrics?.inc("run_signal_poll_errors_total", { kind: "heartbeat" }); });
-    }, HEARTBEAT_MS);
-    preLaunchHeartbeat.unref?.();
+    args.prepared.seat.noteOwnRun(taskId);
+    const owner = args.prepared.auth?.subject ?? null;
+    const stopPreLaunchHeartbeat = startClaimHeartbeat(runStore, taskId, owner, deps.metrics);
     try {
         const placementReject = await commitExecutionContext(deps, { kind: "run", runStore, taskId }, args.prepared.execution);
         if (placementReject)
             return placementReject;
         if (deps.checkpointStore) {
             const ctxRefusal = await persistSubmissionCtx(deps.checkpointStore, deps, { runStore, taskId }, args.prepared);
+            if (ctxRefusal === SUBMIT_CTX_CLAIM_LOST)
+                return await refusalAfterLostClaim(deps, runStore, sessionId, taskId);
             if (ctxRefusal)
                 return ctxRefusal;
         }
@@ -60,12 +61,15 @@ export async function mintAndDriveDurableRun(ctx, runStore, args) {
                 throw err;
             }
         }
+        const lostClaim = await recheckClaimBeforeLaunch(deps, runStore, sessionId, taskId);
+        if (lostClaim !== undefined)
+            return lostClaim;
     }
     finally {
-        clearInterval(preLaunchHeartbeat);
+        stopPreLaunchHeartbeat();
     }
     commitSessionInheritEnv(deps, args.prepared.spec.sessionId, args.prepared.body);
-    const anchorOwner = args.prepared.auth?.principal ?? null;
+    const anchorOwner = args.prepared.auth?.subject ?? null;
     const headOf = headReadOf(deps.sessionStorage);
     const captureTurnAnchor = deps.resumeAnchorStore && headOf
         ? async (eventId) => {
@@ -85,7 +89,7 @@ export async function mintAndDriveDurableRun(ctx, runStore, args) {
         ...fleetRunLabels(args.prepared.acceptance.objectiveAtSubmit),
     });
     nameFleetRowOnDelivery(args.prepared.acceptance, fleetPub);
-    void heldFor(args.prepared.peerLease, () => runInBackground(args.prepared.runner, args.prepared.spec, runStore, taskId, deps.metrics, args.prepared.auth?.principal, args.prepared.verify, args.prepared.cascade ? cascadeConfig(deps.config.cascadeLadder, args.prepared.spec.limits?.maxCostUsd) : undefined, deps.instrumentDegenerate, deps.planCacheProbe, deps.config.traceThinking, inflightRuns, preemptableRuns, steerableRuns, deps.modelUsage, deps.elicitation, args.elicitOwner, captureTurnAnchor, fleetPub, captureUserMessageAnchor, deps.question, deps.workflowCompletionInbox, deps.subagentSteerRegistry, (m, x) => deps.logger?.info?.(m, x), deps.sendUserFile, deps.promptManifests, deps.toolApproval
+    void heldFor(args.prepared.peerLease, () => runInBackground(args.prepared.runner, args.prepared.spec, runStore, taskId, deps.metrics, args.prepared.auth?.subject, args.prepared.verify, args.prepared.cascade ? cascadeConfig(deps.config.cascadeLadder, args.prepared.spec.limits?.maxCostUsd) : undefined, deps.instrumentDegenerate, deps.planCacheProbe, deps.config.traceThinking, inflightRuns, preemptableRuns, steerableRuns, deps.modelUsage, deps.elicitation, args.elicitOwner, captureTurnAnchor, fleetPub, captureUserMessageAnchor, deps.question, deps.workflowCompletionInbox, deps.subagentSteerRegistry, (m, x) => deps.logger?.info?.(m, x), deps.sendUserFile, deps.promptManifests, deps.toolApproval
         ? {
             coordinator: deps.toolApproval,
             streamApprovalOn: resolveStreamApprovalGate({
@@ -101,6 +105,7 @@ export async function mintAndDriveDurableRun(ctx, runStore, args) {
         }
         : undefined, deps.checkpointStore, args.prepared.engineNotices, trustedInternals, deps.userInputLedger, args.prepared.acceptance, createSessionWorkspaceRecorder(sessionWorkspaceStoreOf(deps.sessionStorage), args.prepared.legFacts?.sessionWitness), args.prepared.legFacts?.skills));
     args.runSlot?.release();
+    args.prepared.seat.markRecord();
     return { status: 202, body: { taskId, sessionId, status: "running", ...(args.prepared.warnings !== undefined ? { warnings: args.prepared.warnings } : {}) } };
 }
 //# sourceMappingURL=durable-run-leg.js.map

package/dist/http/execution-context.d.ts

@@ -1,42 +1,3 @@
-/**
- * **执行上下文** —— 每条执行起点从这一只解析器取同一型上下文:根会话是谁、这一位住客在根会话行上的执行放置是什么、这条执行走哪条车道、
- * 主体能不能用这条车道;认领之后的初始放置只有一只写口 {@link commitExecutionContext}。
- *
- * ## 规则(一句)
- * 根只有一个来源 = authorizer(`ServiceCoreDeps.authorize` 必填席,唯一铸点即登记点),根进 spec 只有一个写者 = {@link stampSpecRoot};
- * 执行放置**读只有一只** —— 会话店执行席 `seat.read(root)` 一次行读(住客 + 格),解析器读它、提交腿的门交来的 `judged` 比它、设备准入链判的也是这一读;
- * **写只有一只** —— 认领之后的 {@link commitExecutionContext}(按解析器那一读的住客定址,0 行按住客复读分类,永不对现住客重试)。
- *
- * ## 解析步序(设计 §3.2 表 ①–④;⑤ 取 rig 不在本版)
- *  ① 读:会话店不带执行席 ⇒ absent、`occupant` 缺(只一元车道表的部署可能);否则一次行读 —— 行不在 ⇒ 404 `resume.session_not_found`;`judged`(门判过的那一读)
- *     在场而与行头不是同一位住客(化身 ∧ 属主,写口同一只判官 `sameOccupant`)⇒ 同 404(他人在门与解析之间删掉并同 id 重登记,或同一化身的属主变了 ——
- *     local M10 认领 / identical 重戳 / SQL 导入提交点改属主 —— 判到新住客的车道就是错的);local 格是 `forking`
- *     ⇒ 409 `conflict.fork_in_progress`;读故障抛(不吞成 absent)。解析器不建行、不铸根。
- *     随后(同一步,就在那一读之后):这只根会话 id 在本进程被删过、而那一读的住客不是删前的属主 ⇒ 409 `conflict.session_id_retired`
- *     (表与规则 `deleted-session-ids.ts`,这里是它唯一的读点;店不带执行席 ⇒ fresh 判门判过的那一读,continuation 判不出 ⇒ 表里有就拒)。
- *  ② 定车道:`mirror` ⇒ 409 `conflict.session_mirror`(体带 `forkPath`);`writer(L)` 而 L 不在本部署的车道表 ⇒ 409 `execution_lane.not_served{boundLane}`;absent ⇒ 表首。
- *  ③ 授权:主体的执行车道裁定(`gateExecutionLane`,判据与码同 `runtime-caps-resolver.ts`);服务形不判。
- *  ④ 只 fresh:设备准入链(体 `deviceId` 只在 device 车道收;准入链三步 + 首绑目标三读,全读;判的是步 ① 那一读)。
- *
- * 入口三形(判别联合,{@link ExecutionEntry}):`fresh`(提交腿:根 = authorizer 交出的 `auth.sessionId`,`judged` = authorizer 判过的头)·
- * `continuation`(续跑家族与停驻赎回:根 = checkpoint / 停驻行的根;不带 `judged` —— 步 ① 那一读就是这条执行对根的唯一一读,认领之后由写口按它判;
- * run 外回退口 `POST /v1/sessions/:id/rewind-files` 同形:根 = 路径上的会话,它不认领、不提交放置,只取步 ①–③ 的拒)·
- * `service`(服务 run:没有会话根)。
- * `fresh` / `continuation` 两形型上恒带 `root: string`,`service` 形没有 `root` 键 —— 「按一只缺席的根去读行」在型上不可表达。
- *
- * ## 提交({@link commitExecutionContext};设计 §3.2「提交」)
- * 只在认领之后(四个 `createRun` 点、续跑家族 `markResuming` 之后、停驻赎回 `claimParkedAgent` 之后)调,是认领之后改执行放置的唯一写口:
- *  · 有设备意图(fresh ∧ device 车道)⇒ 首绑(设备店一只事务,按住客定址)或已绑臂的再断言(按住客再读 + 准入链再断言设备);
- *  · absent ⇒ place(非 device 车道);命中 = 成立;0 行按住客复读分类:同值 = 成立 · 异车道 ⇒ `execution_lane.tree_bound` · mirror ⇒ `conflict.session_mirror` ·
- *    gone(行不在或住客不是解析器那一位)⇒ 「会话不在」(提交腿 404 `resume.session_not_found`;停驻赎回答它自己的 `decide.not_parked`)—— **不对现住客重试**;
- *  · writer ⇒ 按住客再读断言仍是 writer(L);
- *  · 拒 ⇒ 先释放本次认领(run:终结 + 放认领 + 放幂等键;停驻:回滚认领)再交回拒答;店故障 ⇒ 释放后原样上抛(响亮,不当答案)。
- * claim 之后每一次店往返都带 {@link placementWriteDeadlineMs} 硬时限。
- *
- * ## 便利度不变(clay [ref] 硬约束)
- * 本文件**不产生任何审批**:只做「这条会话放在哪条车道 / 哪台设备上」的读、判与认领之后的一次写。device 车道上 `permissionMode: "bypassPermissions"` 的 run
- * 与 host 车道同构造同读数(判据钉在 device-first-bind 测试的「零额外审批」格)。
- */
 import type { IncomingMessage } from "node:http";
 import type { SessionHead, TaskSpec } from "@sema-agent/core";
 import { type DeviceOwner, type DeviceStore } from "../device-store.js";
@@ -88,8 +49,9 @@ export type ExecutionContext = {
 export type RootedExecutionContext = Extract<ExecutionContext, {
     readonly root: string;
 }>;
-/** 装配器(`resolveSpec`)收的那一半:根、入口形与解析器选定的车道(它不判放置、不选车道 —— `lane` 是解析器那一次的读数,装配器只读:项目包的车道门)。 */
-export type ExecutionRoot = Pick<RootedExecutionContext, "kind" | "root" | "lane">;
+/** 装配器(`resolveSpec`)收的那一半:根、入口形、解析器选定的车道与步 ① 那一读的住客(它不判放置、不选车道 —— `lane` 是解析器那一次的读数,装配器只读:项目包的车道门;
+ *  `occupant` 只给会话登记簿的围栏记「这一位住客」,换住客即清上一位的条目)。 */
+export type ExecutionRoot = Pick<RootedExecutionContext, "kind" | "root" | "lane" | "occupant">;
 /** 解析器读的部署件(全部取自同一只 `ServiceDeps`)。 */
 export interface ExecutionContextDeps {
     readonly config: ServiceConfig;
@@ -120,7 +82,7 @@ export declare function isRootSessionGoneError(err: unknown): boolean;
 /**
  * 调用方 device 域的**唯一铸造点**。`undefined` = 判不出域(无 principal,或凭据不带 tenant claim)—— 消费点必须响亮拒,禁静默空视图。
  *
- * 🔴 位置即契约:`{owner_tenant, owner_subject}` 是 O11 的 device-lane-local 复合身份(全局 principal 一个字节不动)。subject = `gatedPrincipal`(verified 链),
+ * 🔴 位置即契约:`{owner_tenant, owner_subject}` 是 O11 的 device-lane-local 复合身份(全局 principal 一个字节不动)。subject = `gatedPerson`(verified 链),
  * tenant = `ssoVerifiedScope`(registry auth-bridge JWT 的 `scope` claim)—— **两者都是签名真源,不是自报头**。管理面三读三写与首绑写协议全部从这一只函数取域;
  * 派生第二份就是把 O11 的判据本体复制成一份会漂的孪生。
  */
@@ -160,8 +122,20 @@ export type RootedTaskSpec = TaskSpec & {
  * 在场且等于根 ⇒ 同值,照盖;在场而**不等** ⇒ 400 `request.precondition_unmet`(嵌入方的装配器另点了一只会话 —— 它在型上不能这么写,
  * 走到这里只能是擦型或 JS 形;拒在建任何行之前)。续跑家族照它自己的折叠律把这只拒答成 409 `resume_blocked_by_policy`(`blockedBy` = 这只码,
  * `http/resume-legs.ts` 的 `resolveResumeSpecOrBlocked`:装配期的每一只 `HttpError` 在续跑腿上都这么折),同样什么都没续。
+ *
+ * **根「必须已在」的唯一写者也是这里**(`requireExistingSession`;装配器不写它):根是宿主的 ⇒ 引擎取会话时不许「缺行即建」——
+ * 解析器步 ① 读到过这一行(`occupant` 在场),或调用方自己要求了它(`requireExistingSession: true`;店不带执行席时这是唯一的来源)⇒ 盖 `true`:
+ * 门与引擎取会话之间这一行被删(属主删除 / 受理前拒的撤回),引擎答 `resume.session_not_found`,不在原 id 上重建一只无主的空根。
+ * **例外只有一条,来自引擎的派生形**:`cascade: true` 的提交不盖 —— 引擎派生每一级时只删 `sessionId`、其余字段照展开,带着这一位的级就成了
+ * 「没有会话 id 却要求会话已在」,被引擎拒掉(每一级都跑不起来)。引擎把这一位随 `sessionId` 一并剥掉之后,cascade 也盖,这一条例外删去。
+ * 没读到行、调用方也没要求 ⇒ 不盖(与引擎缺省同:没有宿主见过的根可护)。
  */
-export declare function stampSpecRoot(spec: ResolvedTaskSpec, ctx: ExecutionRoot): RootedTaskSpec;
+export declare function stampSpecRoot(spec: ResolvedTaskSpec, ctx: ExecutionRoot, submission: SpecRootSubmission): RootedTaskSpec;
+/** {@link stampSpecRoot} 读的那两位提交事实(受理漏斗交这次的体;续跑家族交 checkpoint 上存的那一份体)。 */
+export interface SpecRootSubmission {
+    readonly cascade?: unknown;
+    readonly requireExistingSession?: unknown;
+}
 /**
  * run 店建行时根会话行已经不在(`CreateRunOutcome.sessionAbsent`:受理之后、认领之前会话被删)的**唯一**答复 ——
  * 四个建行点(同步 / 流式 / durable / wake)、解析期的「行不在 / 住客换了」与提交期的 `gone` 同答 404 `resume.session_not_found`,什么都没建、什么都没跑。

package/dist/http/execution-context.js

@@ -1,5 +1,6 @@
+import { RUN_STALE_SEC_DEFAULT } from "../run-stale-default.js";
 import { HttpError, createCodedHttpError, ssoVerifiedScope } from "../security.js";
-import { gatedPrincipal } from "./principal-gate.js";
+import { gatedPerson } from "./principal-gate.js";
 import { DEVICE_ERROR_CODES, assertDeviceIdShape } from "../device-store.js";
 import { buildDeviceRejection } from "../device-enrollment.js";
 import { sameOccupant } from "../execution-placement.js";
@@ -93,7 +94,7 @@ export function isRootSessionGoneError(err) {
     return err instanceof HttpError && err.code === rootSessionAbsentAnswer().body.errorCode;
 }
 export function deviceOwnerDomainOf(req, config) {
-    const subject = gatedPrincipal(req, config);
+    const subject = gatedPerson(req, config);
     if (subject === undefined)
         return undefined;
     const tenant = ssoVerifiedScope(req);
@@ -163,12 +164,13 @@ async function admitDevicePlacement(deps, entry, lane, seat, reading) {
         throw asHttpError(buildDeviceRejection(DEVICE_ERROR_CODES.OFFLINE, "device is not connected"));
     return { rootSessionId: entry.root, occupant: reading.occupant, owner, admittedDeviceId: requestedDeviceId, firstBind: true };
 }
-export function stampSpecRoot(spec, ctx) {
+export function stampSpecRoot(spec, ctx, submission) {
     const named = spec.sessionId;
     if (named !== undefined && named !== ctx.root) {
         throw createCodedHttpError(400, "request.precondition_unmet", "the deployment's spec resolver named a session other than the one this submission was authorized for — a submission's root session comes only from the authorizer, so resolveSpec must not set sessionId (read opts.execution.root instead)");
     }
-    return { ...spec, sessionId: ctx.root };
+    const requireExisting = submission.cascade !== true && (ctx.occupant !== undefined || submission.requireExistingSession === true);
+    return requireExisting ? { ...spec, sessionId: ctx.root, requireExistingSession: true } : { ...spec, sessionId: ctx.root };
 }
 export function rootSessionAbsentAnswer() {
     return {
@@ -180,7 +182,7 @@ export function rootSessionAbsentAnswer() {
     };
 }
 export function placementWriteDeadlineMs(runStaleSec) {
-    const stale = typeof runStaleSec === "number" && Number.isFinite(runStaleSec) && runStaleSec > 0 ? runStaleSec : 120;
+    const stale = typeof runStaleSec === "number" && Number.isFinite(runStaleSec) && runStaleSec > 0 ? runStaleSec : RUN_STALE_SEC_DEFAULT;
     return Math.min(15_000, Math.max(1_000, Math.floor((stale * 1000) / 4)));
 }
 function deviceRefusal(rej) {

package/dist/http/health-reader.d.ts

@@ -0,0 +1,36 @@
+/**
+ * `GET /health` 的**读者分档** —— 同一张面四种读者(k8s / Docker 探针、壳在带凭据之前读的自报位、嵌入宿主的引擎身份验证、持凭运维),
+ * 键集按**读者**而不是按「这个键敏不敏感」定。
+ *
+ * ## 规则(一条)
+ * 读者三档,答案只有一处:
+ *  · `open`        —— 部署没配任何服务凭据(单机 / loopback 开发形;全局凭据门不武装):全键,字节同分档之前;
+ *  · `credentialed` —— 配了服务凭据,且这次请求出示了**读路谓词**认的凭据(`dispatch.ts` 的 `readCredentialOk`:service token ∨ 只读 trace token ∨ 已验 principal):全键;
+ *  · `anonymous`   —— 配了服务凭据而这次请求没出示:**只拿显式白名单** {@link ANONYMOUS_HEALTH_KEYS}。
+ * 白名单 = 存活位(`status`)+ 壳的 pre-credential 自报位三键(`auth` / `operator` / `center`,`health-self-report.ts` 铸;壳在带凭据**之前**要读的就是它们)。
+ * 其余的键 —— 现有的(`dataRoot` / `pid` / `configHash` / `sessionBackend` / `startedAt` / `port` / `version` / `engineSignal` …)与将来新长的 —— 对匿名读者一律不出:
+ * 这是**白名单**(挑出四键),不是黑名单(剥掉几键)—— 黑名单形下每个新键默认漏出,这一面又恒在凭据门之前、缺省全网卡监听(安全轴 fail-closed)。
+ *
+ * ## 谁读哪一档
+ *  · 探针(k8s `httpGet` / Docker `HEALTHCHECK`):只要 HTTP 200 —— 匿名也是 200,存活位在白名单里;摘流语义的探针读 `/readyz`(不分档,体只有就绪位);
+ *  · 壳的 pre-credential 读路:`auth` / `operator` / `center` 三键(7.121.0)—— 白名单;
+ *  · 嵌入宿主的引擎身份验证(`pid` ∧ `dataRoot`,见 `test/health-identity-contract.test.ts`):宿主就是带着部署的服务凭据起的引擎,身份验证带同一枚凭据读 —— 在 `credentialed` 档;
+ *    没配服务凭据的嵌入形(桌面宿主自起、不配凭据)在 `open` 档,与改前逐字节同;
+ *  · 持凭运维 / 编排器:`credentialed` 档,全键。
+ *
+ * 没有旋钮:一个放宽用的旋钮就是一把「把路径指纹重新开给匿名方」的钥匙,而本规则要的恰是它没有这把钥匙。
+ */
+/** 读者三档(闭集;顺序无语义)。 */
+export declare const HEALTH_READERS: readonly ["open", "credentialed", "anonymous"];
+export type HealthReader = (typeof HEALTH_READERS)[number];
+/**
+ * 匿名读者的**显式白名单**:存活位 + 自报位三键。穷举 —— 加一个进来是一次有意的、要过评审的放宽(它会对没有凭据的任何人可见)。
+ * 每一只都必须是 `/health` 体里真有的键(`test/health-reader-closed-set.test.ts` 逐键钉在场),抄错名字不会悄悄把闭集缩成更小的一个。
+ */
+export declare const ANONYMOUS_HEALTH_KEYS: readonly ["status", "auth", "operator", "center"];
+/**
+ * 键集判官 —— `/health` 体按读者出口的**唯一**一道:`open` / `credentialed` 原样,`anonymous` 只挑白名单。
+ * 入参是按全键铸好的体(铸点不分读者:一个事实一个铸点,读者分档只在出口);返回新对象,不改入参。
+ */
+export declare function projectHealthBody(reader: HealthReader, body: Readonly<Record<string, unknown>>): Readonly<Record<string, unknown>>;
+//# sourceMappingURL=health-reader.d.ts.map

package/dist/http/health-reader.js

@@ -0,0 +1,21 @@
+export const HEALTH_READERS = ["open", "credentialed", "anonymous"];
+export const ANONYMOUS_HEALTH_KEYS = ["status", "auth", "operator", "center"];
+export function projectHealthBody(reader, body) {
+    switch (reader) {
+        case "open":
+        case "credentialed":
+            return body;
+        case "anonymous": {
+            const closed = {};
+            for (const key of ANONYMOUS_HEALTH_KEYS)
+                if (Object.hasOwn(body, key))
+                    closed[key] = body[key];
+            return closed;
+        }
+        default: {
+            const unknownReader = reader;
+            throw new Error(`health reader: unknown reader ${String(unknownReader)}`);
+        }
+    }
+}
+//# sourceMappingURL=health-reader.js.map

package/dist/http/health-self-report.d.ts

@@ -4,11 +4,11 @@
  *
  * ## 规则(一条):自报位是**投影**,不是第二份规则
  * 每一位读的是**门本身读的那只谓词 / 那只取值口**,本模块不判任何东西:
- *  · `auth.kinds` = `IDENTITY_SOURCES`(`identity-source.ts`;`verifiedIdentitySource` 的回值闭集,序 = 判定次序)里,这台部署的装配**能**回的那几个词 —— 取唯一读法 `wiredIdentitySources`
- *    (`principal-gate.ts`;「这台部署有没有身份边界」的门 `devOpenDeployment` 读同一只):
- *    `service_token` ⇐ 全局门武装(`systemFor` 只在配了 service token 时回得出值)· `sso` ⇐ 鉴权桥装了(入口预认证只在
- *    `webAdminJwtVerifier` 在场时挂身份)· `direct_door_jwt` ⇐ 直连门开着(`verifiedIdentitySource` 那一臂的第一个合取项);
- *  · `auth.required` = kinds 里有没有 `service_token` —— 那一词接没接线就是全局凭据门的武装谓词(`hasServiceAuth`;`wiredIdentitySources` 的
+ *  · `auth.kinds` = `IDENTITY_SOURCES`(`identity-source.ts`;`verifiedIdentitySource` 的回值闭集,序 = 判定次序)里,这台部署的配置**能**回的那几个词 —— 取唯一读法 `configuredIdentitySources`
+ *    (`identity-source.ts`;「这台部署有没有身份边界」的部署形表行 `identityBoundary` 读同一只):
+ *    `service_token` ⇐ 全局门武装(`systemFor` 只在配了 service token 时回得出值)· `sso` ⇐ 配置里有鉴权桥 issuer(显式或中心回退;起服第 9 段按同一个读数装验签器,
+ *    验签器与配置里的桥两者不一致的装配(任一方向)在 `createHttpServer` 拒)· `direct_door_jwt` ⇐ 直连门开着(`verifiedIdentitySource` 那一臂的第一个合取项);
+ *  · `auth.required` = kinds 里有没有 `service_token` —— 那一词接没接线就是全局凭据门的武装谓词(`hasServiceAuth`;`configuredIdentitySources` 的
  *    `service_token` 臂读的正是它),所以 `required` 与 `kinds` 是同一次求值的两个投影,不是两个来源;
  *  · `auth.identityAttach` = kinds 里有没有**带调用方身份**的一类({@link carriesCallerIdentity},穷举):`service_token` 认的是系统
  *    (`systemFor` 回系统名或 null),不是人;
@@ -19,7 +19,7 @@
  *  · `center.issuer` = 鉴权桥 issuer 的唯一取值 `authBridgeIssuerOf`(装配 `boot/stage-09-leader.ts` 与 caps `centerWiring.issuer` 同读);
  *  · `center.webBaseUrl` = 运维旋钮 `SEMA_WEB_ADMIN_WEB_URL`(`config.webAdmin.webBaseUrl`,接了中心才挂;起服时已判成固定基址);
  *  · `center.sessionsVisible` = 中心的 web 面能不能列出本引擎的会话 —— 四件接线事实全在才可能:中心车道配齐(`centerLaneConfigured`,
- *    租约 / 用量 / 公告同一只谓词)∧ 公告地址在(配置席 `fleetAdvertiseAddress`:web 面只拨中心登记过的实例地址)∧ 鉴权桥在(web 面带的是
+ *    租约 / 用量 / 公告同一只谓词)∧ 公告地址在(配置席 `fleetAdvertiseAddress`:web 面只拨中心登记过的实例地址)∧ 鉴权桥在(kinds 里有 `sso`;web 面带的是
  *    中心铸的中继令牌,不带 service token)∧ 会话枚举面在(事实 `sessionList`,web 面中继 `GET /v1/sessions`);缺任一 ⇒ `false`。
  *    四件齐时:多租户(`REQUIRE_PRINCIPAL`)每条会话都落着验过的属主 ⇒ `true`;单用户形下一条会话归谁取决于提交它的那次请求带没带
  *    身份(web 面只列调用人自己的会话)—— 部署级答不了 ⇒ `"unknown"`。
@@ -36,7 +36,7 @@
  * 三键**恒在场**;缺席 = 老 worker(≤7.120.x)。`center.issuer` / `center.webBaseUrl` 缺席即缺席(没有鉴权桥 / 没配旋钮),不拼不猜。
  */
 import type { FlatServiceDeps } from "./server.js";
-import type { IdentitySource } from "../identity-source.js";
+import { type IdentitySource } from "../identity-source.js";
 /** `auth.identityAttach` 的词表。 */
 export declare const IDENTITY_ATTACH_WORDS: readonly ["available", "unavailable"];
 export type IdentityAttach = (typeof IDENTITY_ATTACH_WORDS)[number];
@@ -62,8 +62,8 @@ export interface HealthSelfReport {
     };
 }
 /**
- * 三键的**唯一铸点**(`build*`:纯数据)。只读装配本身:`auth` 四位都从一次 `wiredIdentitySources` 求值投出(`required` = 其中有 `service_token`;
+ * 三键的**唯一铸点**(`build*`:纯数据)。只读部署本身:`auth` 四位都从一次 `configuredIdentitySources` 求值投出(`required` = 其中有 `service_token`;
  * `serviceTokenActsForDeployment` = `required` ∧ 门读的那一格声明),不收调用方递进来的第二份布尔 —— 一个事实一次求值。
  */
-export declare function buildHealthSelfReport(deps: Pick<FlatServiceDeps, "config" | "webAdminJwtVerifier" | "sessionStorage" | "runStore">): HealthSelfReport;
+export declare function buildHealthSelfReport(deps: Pick<FlatServiceDeps, "config" | "sessionStorage" | "runStore">): HealthSelfReport;
 //# sourceMappingURL=health-self-report.d.ts.map

package/dist/http/health-self-report.js

@@ -1,6 +1,6 @@
-import { serviceTokenDeclaredActsForDeployment, wiredIdentitySources } from "./principal-gate.js";
+import { serviceTokenDeclaredActsForDeployment } from "./principal-gate.js";
+import { authBridgeIssuerOf, configuredIdentitySources } from "../identity-source.js";
 import { operatorLane, sessionList } from "../capability-facts.js";
-import { authBridgeIssuerOf } from "../auth-bridge.js";
 import { centerLaneConfigured } from "../web-admin-client/center-request.js";
 import { buildDisplaySafeUrl } from "../trace/redact.js";
 export const IDENTITY_ATTACH_WORDS = ["available", "unavailable"];
@@ -21,8 +21,8 @@ function carriesCallerIdentity(kind) {
 }
 export function buildHealthSelfReport(deps) {
     const { config } = deps;
-    const bridgeWired = deps.webAdminJwtVerifier !== undefined;
-    const kinds = wiredIdentitySources(deps);
+    const kinds = configuredIdentitySources(config);
+    const bridgeWired = kinds.includes("sso");
     const issuer = authBridgeIssuerOf(config)?.issuer;
     const webBaseUrl = config.webAdmin?.webBaseUrl;
     const sessionsVisible = centerLaneConfigured(config) && config.fleetAdvertiseAddress !== undefined && bridgeWired && sessionList(deps).available ? (config.requirePrincipal ? true : "unknown") : false;

package/dist/http/idempotency.d.ts

@@ -1,5 +1,6 @@
 import type { IncomingMessage } from "node:http";
 import type { ServiceConfig } from "../config-types.js";
+import type { Subject } from "../owner-brands.js";
 import type { WiringManifestReceipt } from "./wire-types.js";
 import type { SubmitReplayFace } from "./submit-replay.js";
 import type { RunIdemBinding } from "../plugins/store-contracts.js";
@@ -36,8 +37,8 @@ export declare class IdempotencyCache<T> {
  * `Idempotency-Key` 的**资源族**闭集 —— 键的作用域里那一位是**资源族,不是端点**。
  *
  *  · `run`    —— 一条 run(`POST /v1/tasks` · `/v1/tasks/stream` · `/v1/runs` · A2A `message/send` 都建同一种行;
- *                同一条 run 换腿重试仍同键,不会重复计费)。同族的两个动词口(`/v1/runs/:id/steer` · `/interrupt`)
- *                也按本族取键,收成引擎的 `inputId`(它们的去重属主是引擎的输入队列,不是本仓的行)。
+ *                同一条 run 换腿重试仍同键,不会重复计费)。同族的动词口 `/v1/runs/:id/steer`
+ *                也按本族取键,收成引擎的 `inputId`(它的去重属主是引擎的输入队列,不是本仓的行;`/interrupt` 是不带输入的 halt,不取键)。
  *  · `leader` —— 一条 leader run(`leader_run.idem_key`)。
  *  · `bake`   —— 一次镜像烘焙(`image_bake.idem_key`)。
  *
@@ -45,12 +46,14 @@ export declare class IdempotencyCache<T> {
  */
 export type IdemFamily = "run" | "leader" | "bake";
 /**
- * 一次提交的**调用方身份**(幂等的作用域就是它)—— 授权口建立的那两样:验过的 principal(`gatedPrincipal`)与凭据族
+ * 一次提交的**调用方身份**(幂等的作用域就是它)—— 授权口建立的那两样:验过的 principal(`gatedSubject`)与凭据族
  * (`source`:鉴权门由出示的服务凭据派生的系统名,`RouteRequestState.source` 是它唯一的赋值点)。由 {@link idemCallerOf}
  * 从请求一处读出;键里用的那一位由 {@link idemIdentityOf} 一处定。
  */
 export interface IdemCaller {
-    readonly principal: string | null | undefined;
+    /** 验过的主体(分区键;`gatedSubject` 的读数,带 `Subject` 品牌 —— 提交重放与 leader 登记表的属主门直接拿它当调用方,不再另铸;
+     *  幂等身份位读它 ⇒ 同一只 `Idempotency-Key` 在同一个人的两个场景里是两把键)。 */
+    readonly subject: Subject | null | undefined;
     readonly source: string | null | undefined;
 }
 /** 本次请求的 {@link IdemCaller} —— 一处读:验过的 principal + 鉴权门派生的凭据族(两样都是既有的席位,这里不另判身份)。 */
@@ -118,7 +121,8 @@ export declare function inflightKeyOf(idem: RunIdemBinding, face: SubmitReplayFa
  * 就成了「键缺席」,而 present-iff 的读法会把它读成「这台引擎不给回执」。挂在 outcome 上 = 它是**这条 run 的
  * 属性**(哪条腿跑的都一样),由各腿自己的应答构造器在送出那一刻按自己的 wire 形挂。
  * 落定之后的同键重放不走这里:它读行,体是首答的信封 + `replay: true`(`http/submit-replay.ts` → `http/sync-submit-body.ts`)—— 回执是起手那一帧
- * 的活捕获、不落行,所以重放体上**不带** `wiringManifest`(`replay: true` 就是那一形的判别位)。
+ * 的活捕获、不落行,所以读行的重放体上**不带** `wiringManifest`。在飞合流的跟随方拿的是这一只 outcome(回执照带)经 `replayedOutcome` 叠位 ——
+ * `replay: true` 只说「这份结局不是本次请求产出的」,不判别带不带回执。
  *
  * 🔴 **租户面安全(别在复审里当成漏)**:合流的那份回执是按**第一位调用方**的 `explicitOperatorOk` 投的,
  * 而键本身就按身份位分区(`idemKeyOf` 的 `principal ?? source`)⇒ 合流到它的只可能是**同一个** principal(无 principal 时

package/dist/http/idempotency.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { canonicalJsonStringify } from "@sema-agent/core";
-import { gatedPrincipal } from "./principal-gate.js";
+import { gatedSubject } from "./principal-gate.js";
 export class IdempotencyCache {
     ttlMs;
     sweepThreshold;
@@ -66,11 +66,11 @@ function idemFamilyTag(family) {
     }
 }
 export function idemCallerOf(req, ctx) {
-    return { principal: gatedPrincipal(req, ctx.deps.config), source: ctx.req.source };
+    return { subject: gatedSubject(req, ctx.deps.config), source: ctx.req.source };
 }
 export function idemIdentityOf(caller) {
-    if (caller.principal !== undefined && caller.principal !== null)
-        return `principal\x1e${caller.principal}`;
+    if (caller.subject !== undefined && caller.subject !== null)
+        return `principal\x1e${caller.subject}`;
     if (caller.source !== undefined && caller.source !== null)
         return `source\x1e${caller.source}`;
     return "";

package/dist/http/memory-compliance-failure-reply.d.ts

@@ -8,39 +8,38 @@
  * core 的另外三只 409 与 `ControlPlaneCorruptError` 全落 500 `internal.error` —— 「同一个 requestId 拿去抹另一个会话」这种**调用方自己
  * 能改**的错被说成服务器坏了。两份分类 = 两个判官,少的那份恒是静默的一份。现在**码与状态**只在这里判一次,两面同读。
  *
- * ## 规则(三层,与 operator 面既有层序逐字同序)
+ * ## 规则(两层,与 operator 面既有层序逐字同序)
+ *  ⓪ 先于本映射:两面的 catch 先调记忆面的一只收尾 `sentMemoryFaceFault`(`memory-face-fault-reply.ts`:层拒 / 控制面损坏 `ControlPlaneCorruptError`,
+ *     九只记忆面同一只;控制面损坏一码两义的固定句在那里按面分)—— 本映射只接 core 的带码拒;
  *  ① core 的**本口专属**码(闭集穷举 `switch`,见 {@link sentCoreCode})—— 码与状态两面同;文案按受众(下一节,一条规则);
- *  ② **店形拒**一族(按族表读;成员举例 `memory.target_outside_store` / `memory.scope_home_not_directory` / 引擎 7.65.0 起 `memory.control_plane_links_unsupported`)—— 跨面 store 状态码,409、码原样
+ *  ② **店形拒**一族(按族表读;成员举例 `memory.target_outside_store` / `memory.scope_home_not_directory` / 引擎 7.65.0 起 `memory.control_plane_links_unsupported` / 引擎 7.66.0 起 `memory.control_plane_strays`)—— 跨面 store 状态码,409、码原样
  *     (判据 `memory-store-refusal.ts` 一只;运维行 `memory_store_form_refused { code, path?, form? }` 两受众同一只铸点,路径只在那里);
- *  ③ `ControlPlaneCorruptError` —— typed 500 `internal.memory_control_plane_corrupt`(fail-closed 信号,一码两义;映射本体在 `memory-control-plane-corrupt-reply.ts` 那一只,导出导入 / 外源 / 整理 / 合规各口同调);
  *  其余 ⇒ `false`(未分类,调用方发它自己那句 500 且**不回显**内部文本)。
  *
- * ## 文案按受众分(码与状态不分)—— **一条规则,三层同施,不按码挑**(F9,7.108.0 合并复审 opus 腿 O-9)
- * core 原句是写给运维的诊断材料:③ 点名**宿主路径**(控制面账本文件;② 自 core 7.44.0 起句子不带路径、路径在 `detail.path` ⇒ 运维行),① 的 `selector_mismatch` 带**首个请求的
+ * ## 文案按受众分(码与状态不分)—— **一条规则,各层同施,不按码挑**(F9,7.108.0 合并复审 opus 腿 O-9;⓪ 那只收尾同一条规则)
+ * core 原句是写给运维的诊断材料:控制面损坏点名**宿主路径**(控制面账本文件;② 自 core 7.44.0 起句子不带路径、路径在 `detail.path` ⇒ 运维行),① 的 `selector_mismatch` 带**首个请求的
  * 选择子哈希**(`pinned set <selectHash>`,无盐 sha256 —— operator 选择子可字典还原,首个请求未必是这位会话所有者发的):
  *  · operator 受众 ⇒ 原句上 wire(过了 operator 门,这些材料对这个受众不是泄露);
  *  · 会话所有者受众 ⇒ **一律**一句固定指路(每码一句,只说「怎么办」),原句整句交 `withheld` 落运维 warn —— 不逐码判断哪句安全
- *    (逐码挑 = core 改一句文案就可能静默漏出一样新东西)。② ③ 的固定句**两形都真**:
- *    ② 链先于请求在场 ⇒ 提交点之前拒、什么都没做;提交点之后才换上的链 ⇒ 已删的几条算数、journal 留盘(codex 一审 C1);scope home 不是真目录那一句
- *       同样不许诺零删除(home 被换掉的时刻本层判不出),只指路「运维放回真目录后用同一个 requestId 重发」;
- *    ③ 一码两义 —— 操作前账本读不出 ⇒ 什么都没发生;落定后残留枚举失败 ⇒ 抹除已提交、重放收敛(core 原话)。两句都不许诺零删除,
- *    都指路「运维修好后用同一个 requestId 重发」(两义下这句都对)。本层**不**嗅 core 文案分辨前后(拿上游自由文本当判别式是第二真源)。
+ *    (逐码挑 = core 改一句文案就可能静默漏出一样新东西)。② 的固定句**两形都真**:链先于请求在场 ⇒ 提交点之前拒、什么都没做;提交点之后才换上的链
+ *    ⇒ 已删的几条算数、journal 留盘(codex 一审 C1);scope home 不是真目录那一句同样不许诺零删除(home 被换掉的时刻本层判不出),只指路
+ *    「运维放回真目录后用同一个 requestId 重发」。本层**不**嗅 core 文案分辨前后(拿上游自由文本当判别式是第二真源)。
  */
 import type { ServerResponse } from "node:http";
 import type { Logger } from "../observability/logger.js";
+import type { MemoryFaceAudience } from "./memory-face-fault-reply.js";
 /**
  * 已分类拒 → HTTP 状态的**唯一**码表 = 自铸 wire 值登记处的 `sessionMemoryEraseStatus` 集(F3:wire 变更清单从同一张表 diff,状态改一处、
  * 清单跟着列)。两面同读([ref]:码与状态只判一次)。键写错 ⇒ tsc 红(索引的是 `as const` 表的键)。
  */
-/** 读这张映射的受众(闭集)。会话所有者受众必须交一只 `withheld` —— 被换成固定句的 core 原句落到那里(运维材料不许丢)。 */
-export type MemoryComplianceAudience = {
+/** 读这张映射的受众:记忆面受众闭集里 operator 与会话所有者的抹除面(本映射的固定句都是抹除句;会话所有者的状态面不读它 ⇒ 型面上传不进来)。 */
+export type MemoryComplianceAudience = Extract<MemoryFaceAudience, {
     readonly kind: "operator";
 } | {
-    readonly kind: "session_owner";
-    readonly withheld: (coreMessage: string) => void;
-};
+    readonly face: "erase";
+}>;
 /**
- * 按上面三层应答;返回 `true` = 已应答,`false` = 未分类(一个字节都没写,调用方发它自己那句 500 并落它自己的运维 warn)。
+ * 按上面两层应答;返回 `true` = 已应答,`false` = 未分类(一个字节都没写,调用方发它自己那句 500 并落它自己的运维 warn)。
  * `logger` = 店形拒那一条运维行的去处(两受众同一只;缺席 ⇒ 不落)。
  */
 export declare function sentMemoryComplianceFailure(res: ServerResponse, err: unknown, audience: MemoryComplianceAudience, logger: Pick<Logger, "warn"> | undefined): boolean;

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

@@ -1,5 +1,4 @@
 import { logStoreFormRefusal, storeFormRefusalOf } from "../memory-store-refusal.js";
-import { sentControlPlaneCorrupt } from "./memory-control-plane-corrupt-reply.js";
 import { sentMemoryStoreRefusal } from "./memory-store-refusal-reply.js";
 import { sendError } from "./send.js";
 import { assertNever } from "./route-ctx.js";
@@ -66,6 +65,9 @@ export function sentMemoryComplianceFailure(res, err, audience, logger) {
                     case "memory.control_plane_links_unsupported":
                         sendError(res, 409, "memory.control_plane_links_unsupported", "session memory erasure refused — this deployment's memory control plane is on a file system that cannot make hard links, so its memory store does not open and this erasure changed nothing; ask the operator to move the control plane to a volume that supports hard links, then resend with the same requestId");
                         return true;
+                    case "memory.control_plane_strays":
+                        sendError(res, 409, "memory.control_plane_strays", "session memory erasure refused — this deployment's memory engine was not opened because its control plane still holds records from before that its governance store does not read, so this erasure changed nothing; ask the operator to adopt those records into the governance store, then resend with the same requestId");
+                        return true;
                     default:
                         return assertNever(storeForm.code);
                 }
@@ -73,6 +75,6 @@ export function sentMemoryComplianceFailure(res, err, audience, logger) {
                 return assertNever(audience);
         }
     }
-    return sentControlPlaneCorrupt(res, err, audience);
+    return false;
 }
 //# sourceMappingURL=memory-compliance-failure-reply.js.map

package/dist/http/memory-face-fault-reply.d.ts

@@ -0,0 +1,67 @@
+/**
+ * 记忆面的**一只收尾**:「定店 / 读控制面时说不清」这一个故障源的两种形 —— 本服务的层拒 `MemoryLayerRefusal` 与 core 的控制面损坏
+ * `ControlPlaneCorruptError` —— 在 HTTP 上的答法,唯一一处;外加记忆动词的**层座**读法。
+ *
+ * ## 规则(一条)
+ * 一只记忆面的 catch 只调 {@link sentMemoryFaceFault} 一次,先于它自己的码表(两形都是类判别、与 core 的带码拒不相交:层拒的 `code` 是本服务的
+ * `request.memory_layer`,控制面损坏没有 `code`)。挂不挂哪一形不由各面记 —— 两种形同一个故障源(定店 / 读控制面),哪一只面都可能收到哪一形,
+ * 组合是全面律,不按今天能不能构造出来挑面。两只单件是本模块私有的(不导出 ⇒ 面上不可能只挂一半);`instanceof` 判别只住这里。
+ * 调用面(九只):导出 / 导入包 · 外源三口 · 整理 run · 整理状态 · 合规两口(运维)· 记忆导出 · 记忆同步 · 会话记忆状态 · 会话记忆抹除。
+ *
+ * ## 层拒 ⇒ 400 `request.memory_layer`
+ * 一次记忆请求只落一只店(店的那一半在 `src/memory-scope-stores.ts`):请求点名的层读不出 / 点名的几层分住两只店 / 两店部署上没点名层 ——
+ * 请求可以改对,服务器没坏。
+ *
+ * ## 控制面损坏 ⇒ 500 `internal.memory_control_plane_corrupt`
+ * core 的 fail-closed 信号:记忆引擎的控制面(账本 / 事务日志 / 清标账 / 治理账 / 作用域登记簿)说不清,它宁可不答,也不在一个说不清的账上拼一个答案。
+ * 消费端按 `errorCode` 分支,运维有具体动作(修 / 重建之后重试)。
+ *
+ * ## 文案按受众分(码与状态不分;与 `memory-compliance-failure-reply.ts` 同一条规则):受众拿到的句子 = 它看得的材料
+ *  · operator ⇒ 原句上 wire(层拒点名部署配置的层与哪几层住在哪只店;控制面损坏点名**哪一张**账坏了、带宿主路径 —— 过了 operator 门的受众拿它不是泄露);
+ *  · 层属主(中心记忆导出 / 同步上过了层属主门、但不是 operator 的调用方:本人的 user 层 / 本人的项目层 / org 目录成员)⇒ 层拒原句(这两面只点名
+ *    一层,层拒句只带请求自己的层键与引擎的读法句,不带部署配置的层);控制面损坏换固定句(原句带宿主路径),原句整句交 `withheld` 落运维行;
+ *  · 会话所有者 ⇒ 固定句(只说怎么办),原句整句交 `withheld` 落运维行。层拒的固定句面无关(两形都真:点名的层读不出 / 本部署配置的层读不出);
+ *    控制面损坏的固定句按面分(受众闭集的面位,穷举 `switch`):
+ *      - `erase`:一码两义都真 —— 操作前账本读不出 ⇒ 什么都没发生;落定后残留枚举失败 ⇒ 抹除已提交、重放收敛(core 原话)。不许诺零删除,
+ *        指路「运维修好后用同一个 requestId 重发」;
+ *      - `status`:读面,只说「控制面读不清,运维修好后再读」—— 不许诺零删除、不提 requestId。
+ *    本层**不**嗅 core 文案去分辨哪一义(拿上游自由文本当判别式是第二真源)。
+ *
+ * ## 层座的读法({@link readLayerSeat})
+ * 不点名层的动词(条目 id / 会话 id / 店级账本)多一个可选的 `scope`:GET 口在查询串(`?scope=<层键>`),POST 口在体里(`"scope": "<层键>"`);
+ * 点名的层只用来定店,动词本身的语义不变。缺席 ⇒ 没点名;在场 ⇒ 必须是非空串,否则 400 `request.field_invalid`、面一次都不调
+ * (空串与非串不是「没点名」—— 静默当缺席会把请求答在另一只店上)。
+ *
+ * 每处 `sendError` 的码与固定句都写**字面量**:错误码目录门(`test/error-code-catalog-live.test.ts`)与文案冻结门(`test/api-error-text-freeze.test.ts`)
+ * 扫的是源码字面量,变量态的码 / 句对它们隐形。
+ */
+import type { ServerResponse } from "node:http";
+import type { MemoryLayerSeat } from "../memory-operator-faces.js";
+/** 会话所有者受众:面位(控制面损坏的固定句按它分)+ `withheld`(被换成固定句的原句落到那里 —— 运维材料不许丢)。 */
+type SessionOwnerAudience<F extends string> = {
+    readonly kind: "session_owner";
+    readonly face: F;
+    readonly withheld: (coreMessage: string) => void;
+};
+/** 层属主受众(中心记忆导出 `export` / 同步 `sync`;过了层属主门而不是 operator 的调用方)。 */
+type LayerOwnerAudience = {
+    readonly kind: "layer_owner";
+    readonly face: "export" | "sync";
+    readonly withheld: (coreMessage: string) => void;
+};
+/** 读记忆面收尾的受众(闭集)。会话所有者两面:自助抹除 `erase` · 会话记忆状态 `status`;层属主一类(中心导出 / 同步)。 */
+export type MemoryFaceAudience = {
+    readonly kind: "operator";
+} | LayerOwnerAudience | SessionOwnerAudience<"erase"> | SessionOwnerAudience<"status">;
+/**
+ * 层座:`present` = 键在不在(查询串 `has` / 体 `in`),`value` = 它的值。缺席 ⇒ `undefined`;非空串 ⇒ `{ layer }`;
+ * 其余 ⇒ 已答 400 `request.field_invalid`,返回 `null`(调用方 `return`)。
+ */
+export declare function readLayerSeat(res: ServerResponse, present: boolean, value: unknown): MemoryLayerSeat | undefined | null;
+/**
+ * `err` 是这一个故障源的两形之一 ⇒ 已应答,返回 true:层拒 ⇒ 400 `request.memory_layer`;控制面损坏 ⇒ 500 `internal.memory_control_plane_corrupt`
+ * (文案按受众)。否则 false,一个字节都不写(调用方接着走它自己的码表)。
+ */
+export declare function sentMemoryFaceFault(res: ServerResponse, err: unknown, audience: MemoryFaceAudience): boolean;
+export {};
+//# sourceMappingURL=memory-face-fault-reply.d.ts.map