@sema-agent/server 7.131.0 → 7.133.0

package/dist/http/claimed-run.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 一条提交腿**刚认领**的 run 在起跑之前就收场 —— 撤掉本请求建的东西的**唯一**写法。三个调用点:device 落点拒
+ * (`device-placement.ts` `commitPlacement`)、续跑输入写不进(`submit-ctx.ts` `persistSubmitCtx`)与 workflow 决定行没落成
+ * (`durable-run-leg.ts` 的 fresh 投递腿;此刻认领可能已被收割归了别人 —— 两步都按这一跑自己的 taskId,碰不到别人的认领)。
+ *
+ * 撤两步,**各自独立**(一步失败不拦另一步,残余最小):
+ *  · 终结这条 run 行(`setTerminal` 是按 taskId 的 CAS,首写者赢 ⇒ 重复调用是 no-op)—— 随之释放它的 `task_active` 认领;
+ *  · 放开它占的提交幂等键(拒绝答复邀请重试;同键重试必须真跑,不是回放这次拒绝 —— `RunStore.releaseIdemKey`)。
+ * 撤不掉不致命、但要响:每一步的失败各交给调用方按自己的名字留痕(`onFailure`)。终结没落下 ⇒ 起跑前的心跳随调用腿收场停下(或从没起过),`reapStale`
+ * 在 `REAP_RUN_STALE_SEC` 之后把这条行翻 failed 并释放会话;幂等键没放开 ⇒ 同键重提回放这条行的回执(两形都是修前每一次的样子)。
+ */
+import type { RunStore } from "../plugins/store-backend.js";
+export declare function releaseClaimedRun(runStore: Pick<RunStore, "setTerminal" | "releaseIdemKey">, taskId: string, why: string, onFailure: (err: unknown, step: "terminal" | "idem_key") => void): Promise<void>;
+//# sourceMappingURL=claimed-run.d.ts.map

package/dist/http/claimed-run.js

@@ -0,0 +1,15 @@
+export async function releaseClaimedRun(runStore, taskId, why, onFailure) {
+    try {
+        await runStore.setTerminal(taskId, "failed", null, why);
+    }
+    catch (err) {
+        onFailure(err, "terminal");
+    }
+    try {
+        await runStore.releaseIdemKey(taskId);
+    }
+    catch (err) {
+        onFailure(err, "idem_key");
+    }
+}
+//# sourceMappingURL=claimed-run.js.map

package/dist/http/device-placement.d.ts

@@ -53,6 +53,7 @@ import { type DeviceOwner } from "../device-store.js";
 import { type DeviceEnrollment, type DeviceRejection } from "../device-enrollment.js";
 import type { ServiceConfig } from "../config.js";
 import type { RunStore } from "../plugins/store-backend.js";
+import { type RefusalBody } from "./refusal-body.js";
 /**
  * 调用方 device 域的**唯一铸造点**。`undefined` = 判不出域(无 principal,或凭据不带 tenant claim)——
  * 消费点必须响亮拒,禁静默空视图。
@@ -170,8 +171,5 @@ export declare function placementWriteDeadlineMs(runStaleSec: number | undefined
  */
 export declare function commitPlacement(ctx: PlacementCommitCtx, runStore: RunStore, taskId: string, intent: DevicePlacementIntent | undefined): Promise<DeviceRejection | null>;
 /** 拒绝的**唯一** wire 体铸点(四个消费点各自用自己协议的发送姿势,但体的键集只有这一份)。 */
-export declare function devicePlacementErrorBody(rej: DeviceRejection): {
-    error: string;
-    errorCode: string;
-};
+export declare function devicePlacementErrorBody(rej: DeviceRejection): RefusalBody;
 //# sourceMappingURL=device-placement.d.ts.map

package/dist/http/device-placement.js

@@ -2,6 +2,8 @@ import { createCodedHttpError, ssoVerifiedScope } from "../security.js";
 import { gatedPrincipal } from "./principal-gate.js";
 import { DEVICE_ERROR_CODES, assertDeviceIdShape, } from "../device-store.js";
 import { buildDeviceRejection } from "../device-enrollment.js";
+import { releaseClaimedRun } from "./claimed-run.js";
+import { refusalBody } from "./refusal-body.js";
 export function deviceOwnerDomainOf(req, config) {
     const subject = gatedPrincipal(req, config);
     if (subject === undefined)
@@ -89,16 +91,10 @@ export async function commitPlacement(ctx, runStore, taskId, intent) {
     if (intent === undefined)
         return null;
     const enrollment = ctx.deviceEnrollment;
-    const releaseRun = async (why) => {
-        try {
-            await runStore.setTerminal(taskId, "failed", null, why);
-            await runStore.releaseIdemKey(taskId);
-        }
-        catch (err) {
-            ctx.logger?.warn("device_placement_run_release_failed", { taskId, err: err instanceof Error ? err.message : String(err) });
-            ctx.metrics?.inc("device_placement_run_release_failed_total");
-        }
-    };
+    const releaseRun = (why) => releaseClaimedRun(runStore, taskId, why, (err, step) => {
+        ctx.logger?.warn("device_placement_run_release_failed", { taskId, step, err: err instanceof Error ? err.message : String(err) });
+        ctx.metrics?.inc("device_placement_run_release_failed_total");
+    });
     if (!enrollment) {
         await releaseRun("device placement could not be committed: the device lane's admission chain is not wired");
         throw new Error("commitPlacement: a device placement intent was minted without a DeviceEnrollment — assembly bug (both are read from the same ServiceDeps)");
@@ -144,6 +140,6 @@ export async function commitPlacement(ctx, runStore, taskId, intent) {
     return rejection;
 }
 export function devicePlacementErrorBody(rej) {
-    return { error: rej.message, errorCode: rej.code };
+    return refusalBody({ errorCode: rej.code, message: rej.message });
 }
 //# sourceMappingURL=device-placement.js.map

package/dist/http/dispatch.d.ts

@@ -18,10 +18,6 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import type { ServiceConfig } from "../config-types.js";
 import type { RouteCtxBase, RunRegistry } from "./route-ctx.js";
 import type { FlatServiceDeps } from "./server.js";
-/** 「这台部署配了任何一把 service 凭证吗」—— fail-closed 写门族的真值源。**单一属主**:`handle()` 的
- *  凭证门、[ref] 的 parked 赎回席、以及 [ref] 的 consolidation 阀门启动期告警读同一句(手抄迟早
- *  只改一处,而这条判据决定的是「无凭证部署上写口开不开」)。导出仅为最后一个消费点(main.ts)。 */
-export declare function hasServiceAuth(config: ServiceConfig): boolean;
 /**
  * 🔴 S-672(test T-72 [ref];主会话裁 ①,分诊 [ref])—— 全局服务凭据门**之前**那几族只读路
  * (`route-table.ts` 里 `position: "read-credential"` 的行)的**唯一**鉴权谓词:「服务凭据 ∨ 已验 principal」。

package/dist/http/dispatch.js

@@ -1,18 +1,15 @@
 import { createHash } from "node:crypto";
-import { setSsoPrincipal, ssoVerifiedPrincipal, setSsoScope, isDestructiveSessionWrite, PRINCIPAL_TOKEN_HEADER, APPROVAL_MAC_HEADER, APPROVAL_MAC_KID_HEADER } from "../security.js";
+import { setSsoPrincipal, ssoVerifiedPrincipal, setSsoScope, setSsoRole, isDestructiveSessionWrite, PRINCIPAL_TOKEN_HEADER, APPROVAL_MAC_HEADER, APPROVAL_MAC_KID_HEADER } from "../security.js";
 import { publicStoreProbeError } from "../store-live-probe.js";
 import { looksLikeJwt } from "@sema-agent/settings-schema/api/auth-bridge";
 import { ROUTE_METHOD_ORDER } from "./route-ctx.js";
 import { READ_CREDENTIAL_ROUTES, PUBLIC_ROUTES, POST_CREDENTIAL_ROUTES, routeLabel, isBillableSubmitPath, billableKindOf, isCredentialGatedRewrite, isMethodDispatchedSubmitPath, lookupRoute, isProbePath, isSubscriptionRequest } from "./route-table.js";
 import { sendJson, sendError, isSseResponse, endSseWithError } from "./send.js";
-import { admissionRefusalOf, readinessOf, healthReadinessKeys, sendReadyz, sendBillableRefusal, billableRefusalOf } from "./readiness.js";
+import { admissionRefusalOf, readinessOf, healthReadinessKeys, sendReadyz, sendBillableRefusal, billableRefusalOf, billableRefusalFrame } from "./readiness.js";
 import { ENGINE_SIGNAL_KEY, buildEngineSignal, fleetMembershipKeys, healthConfigLedgerKeys, healthDrainingKeys, mintEngineSignal, restartActionable } from "../fleet/engine-signal.js";
 import { buildHealthSelfReport } from "./health-self-report.js";
-import { authorized, systemFor, gatedPrincipal, sendPrincipalRefusal, sendUnauthorized, verifiedIdentitySource } from "./principal-gate.js";
+import { authorized, systemFor, gatedPrincipal, sendPrincipalRefusal, sendUnauthorized, verifiedIdentitySource, hasServiceAuth, devOpenDeployment } from "./principal-gate.js";
 const PROCESS_STARTED_AT_MS = Date.now() - Math.round(process.uptime() * 1000);
-export function hasServiceAuth(config) {
-    return Boolean(config.authToken) || Object.keys(config.authTokens ?? {}).length > 0;
-}
 export function readCredentialOk(req, config) {
     if (!hasServiceAuth(config))
         return true;
@@ -54,10 +51,10 @@ export function createDispatch(ctx) {
         };
         deps.drainState.lastAttachEndedAt = () => lastAttachEndedAt;
         deps.drainState.endSubscriptions = () => {
-            const { errorCode, message } = billableRefusalOf("draining").body;
+            const frame = billableRefusalFrame(billableRefusalOf("draining"));
             for (const r of [...openSubscriptions])
                 if (isSseResponse(r))
-                    endSseWithError(r, { errorCode, message });
+                    endSseWithError(r, frame);
         };
     }
     async function dispatchSegment(rows, req, res, url, search, method, allow, ctx, admit) {
@@ -151,7 +148,7 @@ export function createDispatch(ctx) {
                 startedAt: PROCESS_STARTED_AT_MS,
                 port: req.socket.localPort,
                 ...(deps.config.directDoorActive ? { directDoorActive: true } : {}),
-                ...buildHealthSelfReport(deps, hasServiceAuth(deps.config)),
+                ...buildHealthSelfReport(deps),
                 ...(signal.restart ? { ...(restartActionable(signal) ? { restartRequired: true } : {}), restart: signal.restart } : {}),
                 ...(() => {
                     const configHandoff = deps.configHandoffState?.();
@@ -162,6 +159,10 @@ export function createDispatch(ctx) {
                     const credential = deps.centerCredentialState?.();
                     return credential ? { centerCredential: credential } : {};
                 })(),
+                ...(() => {
+                    const identityNotice = deps.centerIdentityNoticeState?.();
+                    return identityNotice ? { centerIdentityNotice: identityNotice } : {};
+                })(),
                 ...(() => {
                     const modelRefusals = deps.modelRefusalsState?.();
                     return modelRefusals ? { modelRefusals } : {};
@@ -188,10 +189,9 @@ export function createDispatch(ctx) {
                 sendError(res, 404, "feature.metrics_disabled", "metrics disabled");
                 return;
             }
-            const { authToken: t, metricsToken: mt } = deps.config;
-            const anyT = Boolean(t) || Object.keys(deps.config.authTokens ?? {}).length > 0;
-            const devOpen = !anyT && !mt && !deps.config.requirePrincipal;
-            const ok = devOpen || (anyT && systemFor(req, deps.config) !== undefined) || (!!mt && authorized(req, mt));
+            const mt = deps.config.metricsToken;
+            const devOpen = devOpenDeployment(deps) && !mt;
+            const ok = devOpen || systemFor(req, deps.config) !== undefined || (!!mt && authorized(req, mt));
             if (!ok) {
                 sendUnauthorized(res, "operator");
                 return;
@@ -218,6 +218,8 @@ export function createDispatch(ctx) {
                     req.headers[deps.config.principalHeader.toLowerCase()] = v.identity.principal;
                     if (v.identity.scope)
                         setSsoScope(req, v.identity.scope);
+                    if (v.identity.role)
+                        setSsoRole(req, v.identity.role);
                     deps.logger?.info?.("auth_bridge_principal_accepted", { principal: v.identity.principal, ...(v.identity.scope ? { scope: v.identity.scope } : {}) });
                 }
             }

package/dist/http/durable-run-leg.d.ts

@@ -1,35 +1,6 @@
-/**
- * **一条 durable run 的「建行 + 驱动」单一属主**(S-218 提取;此前整段住在 `routes/runs.ts` 的
- * `createDurableRun` 里,只服务 HTTP/A2A 两条提交门)。
- *
- * 🔴 为什么提成模块:`/decide` 的 workflow 第三条车道在**宿主不在 park 上**时,同样要在宿主会话上起
- * 一跑新 turn 把决定交给宿主的模型(S-218)。这条链上挂着 `createRun` 的会话 claim(以及它唯一诚实的
- * 409 出路)、checkpoint ctx 落库、fleet 行发布、resume/rewind 两族锚点捕获、审批 ALS、通告投递……
- * 手抄第二份 = 把这十来件事复制成两份会漂的实现,而漂开的那天没有任何东西会说话(`createDurableRun`
- * 当年从路由体里提取出来时,头注写的就是同一条判词)。方向:`routes/runs.ts` 与 `http/server.ts`
- * 都 import 本模块,本模块谁都不 import —— 与 `http/run-meta.ts` 同一条「两个域共用一件 ⇒ 单独成文件」。
- *
- * 边界(本腿**不**含的东西,留给各自的门):同键重放的回执(`http/submit-replay.ts`)、`Idempotency-Key` 的在飞合流、
- * lease / 治理窗 pre-admission、属主门。它们是**提交面**的判据(读请求、写响应),而本腿只吃已经备好的
- * `PreparedTaskSubmission` 并交回一份收据 —— 这正是它能被一条没有 `ServerResponse` 的内部车道复用的原因。
- */
-import { type RunInternals } from "@sema-agent/core";
 import type { RunStore } from "../plugins/store-backend.js";
 import type { RunIdemBinding, RunRecord } from "../plugins/store-contracts.js";
-import type { PreparedTaskSubmission, RouteCtxBase } from "./route-ctx.js";
-/**
- * 🔴 **TRUSTED run internals** —— 由**部署方**(不是模型、不是请求体、不是工具参数)铸给这一跑的
- * core 内部席位。今天唯一成员 `workflowParkedResume` = 人对一条 parked workflow 子代的决定
- * (语义属主 = core `RunInternals.workflowParkedResume` 的 d.ts 顶注:「A host that decided a workflow
- * child's parked checkpoint launches the run that re-invokes `Workflow({resumeFromRunId})` with the
- * decision here」)。
- *
- * 为什么单独命名而不是直接摊 `RunInternals`:`RunInternals` 里绝大多数席位是**执行腿自己**铸的
- * (onForwardEvent / onTaskNotification / onActivity …),把整只类型开给调用方等于邀请第二个写者;
- * 本类型只开「部署方可以决定的那一格」,新增一格时**必须**在这里显式点名,编译期看得见。
- * 缺席 ⇒ 对两条腿都是完整 no-op。
- */
-export type TrustedRunInternals = Pick<RunInternals, "workflowParkedResume">;
+import type { PreparedTaskSubmission, RouteCtxBase, WorkflowDecisionDelivery } from "./route-ctx.js";
 export interface DurableRunLegArgs {
     /** `prepareSpec` 的产物,或内部车道按同一条 `resolveSpec` 装配出来的等价形。 */
     prepared: PreparedTaskSubmission;
@@ -49,8 +20,9 @@ export interface DurableRunLegArgs {
     elicitOwner: string | null;
     /** run 行元数据的 `source` 列(调用方的系统身份;内部车道传自己的车道名)。 */
     source: string | null;
-    /** 见 {@link TrustedRunInternals}。缺席 ⇒ 与本位存在之前逐字相同。 */
-    trustedInternals?: TrustedRunInternals;
+    /** `/decide` 第三条车道的 fresh 投递腿交来的那一件决定投递(带着的决定 + 起跑之前落行的那一笔;语义与 TRUSTED 纪律的属主 =
+     *  `route-ctx.ts` 的 {@link WorkflowDecisionDelivery} 顶注)。缺席 ⇒ 只摊本会话已受理的决定行。 */
+    workflowDecision?: WorkflowDecisionDelivery;
 }
 /**
  * 本腿的结局:一份收据,或「这次提交的一把幂等钥匙已经指向一条行」(店的原子赢或观察的**观察**臂 —— 本腿不碰
@@ -72,7 +44,8 @@ export type DurableRunLegOutcome = {
 /**
  * 建行 + 驱动。返回 `202` = 新行已建并在跑(体带 `taskId`/`sessionId`);`409` = 会话被别的 run 占着,
  * **没有**建行(体 = `buildActiveRunConflict` 的既有形,含 `errorCode: "conflict.session_active_run"`);
- * `existing` = 这次提交的钥匙(`idem.key` / `clientTaskId`)已经指向一条行,没建新行。
+ * `existing` = 这次提交的钥匙(`idem.key` / `clientTaskId`)已经指向一条行,没建新行;落点拒(device 车道)与续跑输入一行装不下
+ * (`413 request.payload_too_large`,`submit-ctx.ts`)= 行建了又撤了(终结 + 放认领 + 放幂等键),什么都没跑。
  * 协议渲染归调用方(HTTP `sendJson` / A2A 协议对象 / `/decide` 的受理体)。
  */
 export declare function mintAndDriveDurableRun(ctx: RouteCtxBase, runStore: RunStore, args: DurableRunLegArgs): Promise<DurableRunLegOutcome>;

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

@@ -1,5 +1,6 @@
 import { uuidv7 } from "@sema-agent/core";
-import { runInBackground } from "../runs.js";
+import { heldWorkflowParkDecisions } from "../parked-decide.js";
+import { HEARTBEAT_MS, runInBackground } from "../runs.js";
 import { fleetRunPublisher, fleetRunLabels } from "../fleet/fleet-bus.js";
 import { cascadeConfig, runMeta } from "./run-meta.js";
 import { resolveStreamApprovalGate } from "../tool-approval.js";
@@ -8,13 +9,15 @@ import { commitPlacement, devicePlacementErrorBody } from "./device-placement.js
 import { commitSessionInheritEnv } from "./session-inherit-env.js";
 import { clearTurnActivity, readTurnActivityMs } from "../turn-activity.js";
 import { recordResourceWindow } from "../resource-window.js";
-import { buildCheckpointCtx } from "./checkpoint-ctx.js";
+import { persistSubmitCtx } from "./submit-ctx.js";
+import { releaseClaimedRun } from "./claimed-run.js";
 import { serviceVersion } from "../service-version.js";
 export async function mintAndDriveDurableRun(ctx, runStore, args) {
     const { deps } = ctx;
     const { inflightRuns, preemptableRuns, steerableRuns } = ctx.registry;
     const sessionId = args.prepared.spec.sessionId ?? uuidv7();
     const taskId = args.clientTaskId ?? uuidv7();
+    const trustedInternals = await heldWorkflowParkDecisions(deps, sessionId, args.workflowDecision?.carried);
     const created = await runStore.createRun(taskId, sessionId, args.prepared.auth?.principal ?? null, deps.instanceId ?? "default", { ...runMeta(args.prepared, args.source), idem: args.idem ?? null });
     if (created.ok)
         clearTurnActivity(taskId);
@@ -25,13 +28,36 @@ export async function mintAndDriveDurableRun(ctx, runStore, args) {
     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) };
     }
-    const placementReject = await commitPlacement(deps, runStore, taskId, args.prepared.bindingIntent);
-    if (placementReject)
-        return { status: placementReject.status, body: devicePlacementErrorBody(placementReject) };
-    commitSessionInheritEnv(deps, args.prepared.spec.sessionId, args.prepared.body);
-    if (deps.checkpointStore) {
-        await deps.checkpointStore.putCtx(sessionId, buildCheckpointCtx({ body: args.prepared.body, memoryScope: args.prepared.auth?.memoryScope, writerVersion: serviceVersion() }));
+    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?.();
+    try {
+        const placementReject = await commitPlacement(deps, runStore, taskId, args.prepared.bindingIntent);
+        if (placementReject)
+            return { status: placementReject.status, body: devicePlacementErrorBody(placementReject) };
+        if (deps.checkpointStore) {
+            const ctxRefusal = await persistSubmitCtx(deps.checkpointStore, deps, { runStore, taskId }, sessionId, { body: args.prepared.body, memoryScope: args.prepared.auth?.memoryScope, writerVersion: serviceVersion() });
+            if (ctxRefusal)
+                return ctxRefusal;
+        }
+        if (args.workflowDecision !== undefined) {
+            try {
+                await args.workflowDecision.commitBeforeLaunch(taskId);
+            }
+            catch (err) {
+                await releaseClaimedRun(runStore, taskId, `the workflow decision this run delivers could not be recorded: ${err instanceof Error ? err.message : String(err)}`, (releaseErr, step) => {
+                    deps.logger?.warn?.("workflow_decision_run_release_failed", { taskId, sessionId, step, err: releaseErr instanceof Error ? releaseErr.message : String(releaseErr) });
+                });
+                throw err;
+            }
+        }
     }
+    finally {
+        clearInterval(preLaunchHeartbeat);
+    }
+    commitSessionInheritEnv(deps, args.prepared.spec.sessionId, args.prepared.body);
     const anchorOwner = args.prepared.auth?.principal ?? null;
     const getLeafId = deps.sessionStorage?.getLeafId?.bind(deps.sessionStorage);
     const captureTurnAnchor = deps.resumeAnchorStore && getLeafId
@@ -63,7 +89,7 @@ export async function mintAndDriveDurableRun(ctx, runStore, args) {
             windowMs: deps.config.streamApproval?.windowMs,
             windowMarginMs: deps.config.streamAskWindowMarginMs,
         }
-        : undefined, deps.checkpointStore, args.prepared.engineNotices, args.trustedInternals, deps.userInputLedger, args.prepared.acceptance);
-    return { status: 202, body: { taskId, sessionId, status: "running" } };
+        : undefined, deps.checkpointStore, args.prepared.engineNotices, trustedInternals, deps.userInputLedger, args.prepared.acceptance);
+    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/health-self-report.d.ts

@@ -4,10 +4,12 @@
  *
  * ## 规则(一条):自报位是**投影**,不是第二份规则
  * 每一位读的是**门本身读的那只谓词 / 那只取值口**,本模块不判任何东西:
- *  · `auth.required` = 全局凭据门的武装谓词(`hasServiceAuth`,由 `dispatch.ts` 交进来 —— 门与本位读同一次求值的同一只函数);
- *  · `auth.kinds` = {@link IDENTITY_SOURCES}(`verifiedIdentitySource` 的回值闭集)里,这台部署的装配**能**回的那几个词:
+ *  · `auth.kinds` = `IDENTITY_SOURCES`(`verifiedIdentitySource` 的回值闭集)里,这台部署的装配**能**回的那几个词 —— 取唯一读法 `wiredIdentitySources`
+ *    (`principal-gate.ts`;「这台部署有没有身份边界」的门 `devOpenDeployment` 读同一只):
  *    `service_token` ⇐ 全局门武装(`systemFor` 只在配了 service token 时回得出值)· `sso` ⇐ 鉴权桥装了(入口预认证只在
  *    `webAdminJwtVerifier` 在场时挂身份)· `direct_door_jwt` ⇐ 直连门开着(`verifiedIdentitySource` 那一臂的第一个合取项);
+ *  · `auth.required` = kinds 里有没有 `service_token` —— 那一词接没接线就是全局凭据门的武装谓词(`hasServiceAuth`;`wiredIdentitySources` 的
+ *    `service_token` 臂读的正是它),所以 `required` 与 `kinds` 是同一次求值的两个投影,不是两个来源;
  *  · `auth.identityAttach` = kinds 里有没有**带调用方身份**的一类({@link carriesCallerIdentity},穷举):`service_token` 认的是系统
  *    (`systemFor` 回系统名或 null),不是人;
  *  · `operator` = 能力事实 `operatorLane`(operator 面族的 501 门读的同一只;名单本身不上 wire);
@@ -56,8 +58,8 @@ export interface HealthSelfReport {
     };
 }
 /**
- * 三键的**唯一铸点**(`build*`:纯数据)。`credentialGateArmed` 由 `dispatch.ts` 交进来 —— 它是全局凭据门自己的那一句
- * (`hasServiceAuth`),本模块不另求一遍(另求就是第二个写者)。
+ * 三键的**唯一铸点**(`build*`:纯数据)。只读装配本身:`auth` 三位都从一次 `wiredIdentitySources` 求值投出(`required` = 其中有 `service_token`),
+ * 不收调用方递进来的第二份布尔 —— 一个事实一次求值。
  */
-export declare function buildHealthSelfReport(deps: Pick<FlatServiceDeps, "config" | "webAdminJwtVerifier" | "sessionStorage" | "runStore">, credentialGateArmed: boolean): HealthSelfReport;
+export declare function buildHealthSelfReport(deps: Pick<FlatServiceDeps, "config" | "webAdminJwtVerifier" | "sessionStorage" | "runStore">): HealthSelfReport;
 //# sourceMappingURL=health-self-report.d.ts.map

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

@@ -1,4 +1,4 @@
-import { IDENTITY_SOURCES } from "./principal-gate.js";
+import { wiredIdentitySources } from "./principal-gate.js";
 import { operatorLane, sessionList } from "../capability-facts.js";
 import { authBridgeIssuerOf } from "../auth-bridge.js";
 import { centerLaneConfigured } from "../web-admin-client/center-request.js";
@@ -19,29 +19,15 @@ function carriesCallerIdentity(kind) {
         }
     }
 }
-function identitySourceWired(kind, a) {
-    switch (kind) {
-        case "service_token":
-            return a.credentialGateArmed;
-        case "sso":
-            return a.bridgeWired;
-        case "direct_door_jwt":
-            return a.directDoorActive;
-        default: {
-            const unknownKind = kind;
-            throw new Error(`health self-report: unknown identity source ${String(unknownKind)}`);
-        }
-    }
-}
-export function buildHealthSelfReport(deps, credentialGateArmed) {
+export function buildHealthSelfReport(deps) {
     const { config } = deps;
     const bridgeWired = deps.webAdminJwtVerifier !== undefined;
-    const kinds = IDENTITY_SOURCES.filter((k) => identitySourceWired(k, { credentialGateArmed, bridgeWired, directDoorActive: config.directDoorActive }));
+    const kinds = wiredIdentitySources(deps);
     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;
     return {
-        auth: { required: credentialGateArmed, kinds, identityAttach: kinds.some(carriesCallerIdentity) ? "available" : "unavailable" },
+        auth: { required: kinds.includes("service_token"), kinds, identityAttach: kinds.some(carriesCallerIdentity) ? "available" : "unavailable" },
         operator: operatorLane(deps).available ? "present" : "absent",
         center: {
             ...(issuer !== undefined ? { issuer: buildDisplaySafeUrl(issuer) } : {}),

package/dist/http/owner-access.d.ts

@@ -0,0 +1,56 @@
+/**
+ * 🔴 **属主存取器**(S-487 RH-3 第一期)——「这个调用方读得到这一行 run / 会话吗」的行只经这里取得。
+ *
+ * ## 律(一条)
+ * 判官只有一只:run 行 = `principal-gate.ts` 的 `runOwnerReadable`(三条放行臂,含 [ref] C8 窄互认),会话行 = `sessionOwnerReadable`
+ * (dev-open 不钉人;无主行经 `security.ts` 的 `ownerlessRowOpen`;有主行就是 run 那一只)。本模块**不判第二遍、不另写一条**:它只做三件事 ——
+ *  · 取行(或收下调用点已读到的行)并把行上的属主铸成 `DurableOwnerKey`(品牌铸点之一,见 `security.ts`);
+ *  · 过判官,读不到 ⇒ `undefined` —— 与「没有这一行」**同一个值**,路由手里拿不到它无权看的行,也就没有第二种拒绝形可漏存在性;
+ *  · operator 臂由调用点以闭集 {@link OwnerArm} 声明,这里统一并 `explicitOperatorOk`(此前各口手抄 `explicitOperatorOk(...) || owner === principal`)。
+ *
+ * ## 射程(第一期)
+ * 迁进来的口:leader 登记表的读与幂等重放、A2A `tasks/get`、preempt、审批豁免面;`request-guards.ts` 的 `runOwnerOk` 与提交撞键的回执函数
+ * (`submit-replay.ts`)经 {@link runRowReadable} 读同一只判官。其余按 run / 会话寻址的口(`runOwnerOk` 16 处、`sessionOwnerOk` 10 处)第二期整体换成
+ * {@link readOwnedRun} / {@link readOwnedSession} 并删两只 helper;裸 store 读口按文件计数钉在 `test/owner-gate-single-owner.test.ts`(增即红)。
+ */
+import type { ServiceConfig } from "../config-types.js";
+import type { RunRecord } from "../plugins/store-contracts.js";
+import { type OwnerAwareSessionStore, type Principal, type SessionCaller, type SessionOwnerCell } from "../security.js";
+import { type IdentityWiring, type OperatorRoster } from "./principal-gate.js";
+/** 调用点挂哪条臂(闭集):`owner` = 只有属主判官;`owner_or_operator` = 属主判官 ∨ 显式运维(`explicitOperatorOk`,唯一读法)。 */
+export type OwnerArm = "owner" | "owner_or_operator";
+/** 存取器读的配置格:判官要 `requirePrincipal`(C8 臂的单用户条件),operator 臂要运维名册。 */
+export type OwnerAccessConfig = Pick<ServiceConfig, "requirePrincipal"> & OperatorRoster;
+/**
+ * 一行 run 行的属主过判官。`owner`:串 = 有主,`null` = 无主(开放);**`undefined` = 属主格坏了**(型上是 `string | null`,盘上的 run.json 少了这个键时
+ * 运行期会读成缺席 —— 文件店的形判据不验它)⇒ 谁都读不到(fail-closed,不猜成无主;operator 臂照常并)。leader 登记行的 `owner` 是可选键、缺席 = 无主,
+ * 那是 leader 记录型自己的语义,由 {@link createLeaderRunVisibility} 在 leader 边界上显式折成 `null`,不在这里混读。
+ */
+export declare function runRowReadable(config: OwnerAccessConfig, principal: Principal | undefined, owner: string | null | undefined, arm: OwnerArm): boolean;
+/**
+ * 按**会话**寻址的面上读一行 run 行(会话面板的上一腿 MCP 投影:读的是这只会话最新那条 run 的账本行):判官 = 会话面那一只(`sessionOwnerReadable`:
+ * dev-open 不钉人,与会话列表同读);run 行不是委派子代的 placed 会话行 ⇒ 无主时 `placed: false`(与 run 面对无主 run 的读法同)。
+ */
+export declare function runRowReadableOnSessionFace(w: IdentityWiring & {
+    readonly config: OwnerAccessConfig;
+}, caller: SessionCaller, owner: string | null, arm: OwnerArm): boolean;
+/** run 行读口:行 | `undefined`(没有这一行 ≡ 读不到,同一个值)。 */
+export declare function readOwnedRun(config: OwnerAccessConfig, runStore: {
+    getRun(taskId: string): Promise<RunRecord | undefined>;
+}, principal: Principal | undefined, taskId: string, arm: OwnerArm): Promise<RunRecord | undefined>;
+/**
+ * 会话行读口:属主一读 + 无主时 placement 一格(`sessionOwnerCellOf`,S-1770)+ 会话面判官。`undefined` = 没有这只会话(`ownerOf` 答 `undefined`)≡ 读不到。
+ * 读回的那一格交给调用点(要按属主作答的口用它)。店的读失败照常抛(500,绝不当成「读不到」或「读得到」)。
+ */
+export declare function readOwnedSession(w: IdentityWiring & {
+    readonly config: OwnerAccessConfig;
+}, store: Pick<OwnerAwareSessionStore, "placementOf"> & {
+    ownerOf(sessionId: string): Promise<string | null | undefined>;
+}, caller: SessionCaller, sessionId: string, arm: OwnerArm): Promise<SessionOwnerCell | undefined>;
+/**
+ * leader 登记表的判官形(boot 装配一次,`createLeaderEndpoint` 的必填席)—— leader 模块不再自判属主(修前它手抄 `owner == null || owner === requester`,
+ * 缺 C8 窄互认臂而注称 mirrors runOwnerOk)。leader 腿的调用方身份经幂等身份结构(`IdemCaller.principal`,即 `gatedPrincipal` 的回值)转手而来,
+ * 这里是 `Principal` 的「上游已验」适配铸点(第二期随那只结构带品牌而删)。`config` 是活的配置对象(每次调用现读)。
+ */
+export declare function createLeaderRunVisibility(config: OwnerAccessConfig): (principal: string | null | undefined, owner: string | null | undefined) => boolean;
+//# sourceMappingURL=owner-access.d.ts.map

package/dist/http/owner-access.js

@@ -0,0 +1,42 @@
+import { mintDurableOwnerKey, mintPrincipal, sessionOwnerCellOf } from "../security.js";
+import { explicitOperatorOk, runOwnerReadable, sessionOwnerReadable } from "./principal-gate.js";
+function operatorArmHolds(config, principal, arm) {
+    switch (arm) {
+        case "owner":
+            return false;
+        case "owner_or_operator":
+            return explicitOperatorOk(principal, config);
+        default: {
+            const unknownArm = arm;
+            throw new Error(`owner access: unknown arm ${String(unknownArm)}`);
+        }
+    }
+}
+export function runRowReadable(config, principal, owner, arm) {
+    if (operatorArmHolds(config, principal, arm))
+        return true;
+    if (owner === undefined)
+        return false;
+    return runOwnerReadable(principal, owner === null ? null : mintDurableOwnerKey(owner), config);
+}
+export function runRowReadableOnSessionFace(w, caller, owner, arm) {
+    if (operatorArmHolds(w.config, caller.principal, arm))
+        return true;
+    const cell = owner === null ? { owner: null, placed: false } : { owner: mintDurableOwnerKey(owner) };
+    return sessionOwnerReadable(caller, cell, w);
+}
+export async function readOwnedRun(config, runStore, principal, taskId, arm) {
+    const row = await runStore.getRun(taskId);
+    return row !== undefined && runRowReadable(config, principal, row.owner, arm) ? row : undefined;
+}
+export async function readOwnedSession(w, store, caller, sessionId, arm) {
+    const owner = await store.ownerOf(sessionId);
+    if (owner === undefined)
+        return undefined;
+    const cell = await sessionOwnerCellOf(store, sessionId, owner);
+    return operatorArmHolds(w.config, caller.principal, arm) || sessionOwnerReadable(caller, cell, w) ? cell : undefined;
+}
+export function createLeaderRunVisibility(config) {
+    return (principal, owner) => runRowReadable(config, principal == null ? undefined : mintPrincipal(principal), owner ?? null, "owner");
+}
+//# sourceMappingURL=owner-access.js.map

package/dist/http/principal-gate.d.ts

@@ -1,5 +1,6 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type { ServiceConfig } from "../config-types.js";
+import { type DurableOwnerKey, type Principal, type SessionCaller, type SessionOwnerCell } from "../security.js";
 /** Coerce a possibly-repeated request header to a single string (or undefined). */
 export declare function headerStr(v: string | string[] | undefined): string | undefined;
 export declare function safeEqual(a: string, b: string): boolean;
@@ -27,7 +28,7 @@ export type IdentitySource = (typeof IDENTITY_SOURCES)[number];
  * 有可验身份时才是身份,零凭据下它只是谁都能写的字符串;而 JWT 身份不依赖静态 token 的在场。
  */
 export declare function verifiedIdentitySource(req: IncomingMessage, config: ServiceConfig): IdentitySource | undefined;
-export declare function gatedPrincipal(req: IncomingMessage, config: ServiceConfig): string | undefined;
+export declare function gatedPrincipal(req: IncomingMessage, config: ServiceConfig): Principal | undefined;
 /**
  * 「**出示了凭证但验不过** ≠ **没出示**」在 **direct-door principal JWT** 面上的形 —— 本仓
  * {@link bearerPresentedButUnverified} 早就是同一条律在 Bearer 面的形,这里只是把它推到另一面。
@@ -91,40 +92,81 @@ export declare function sendUnauthorized(res: ServerResponse, face: Unauthorized
  * 放宽它是一次独立裁定。需要 operator 臂的读面在**自己的调用点**显式并上 {@link explicitOperatorOk} ——
  * 那样「谁多给了 operator 一条路」在代码上看得见,而不是被偷偷塞进共享谓词里。
  */
-export declare function runOwnerReadable(principal: string | undefined, owner: string | null, config: ServiceConfig): boolean;
+export declare function runOwnerReadable(principal: Principal | undefined, owner: DurableOwnerKey | null, config: Pick<ServiceConfig, "requirePrincipal">): boolean;
+/** 「这台部署配了任何一把 service 凭证吗」—— fail-closed 写门族的真值源,也是身份来源 `service_token` 接没接线的那一句。**单一属主**:`handle()` 的
+ *  凭证门、[ref] 的 parked 赎回席、[ref] 的 consolidation 阀门启动期告警、以及下面 {@link wiredIdentitySources} 读同一句(手抄迟早只改一处,而这条判据
+ *  决定的是「无凭证部署上写口开不开」)。住在本叶(与 {@link systemFor} 同处)而不是 `dispatch.ts`:身份原语只依赖本叶。 */
+export declare function hasServiceAuth(config: ServiceConfig): boolean;
+/** {@link wiredIdentitySources} 读的装配:部署配置 + 入口预认证的鉴权桥(装了才挂身份;`FlatServiceDeps` 结构上满足)。 */
+export interface IdentityWiring {
+    readonly config: ServiceConfig;
+    readonly webAdminJwtVerifier?: object | undefined;
+}
 /**
- * 🔴 **「这台部署有没有身份边界」的唯一判据**(S-1452)。dev-open = 没配 service token(单一或 per-system)、没配只读 trace token、
- * 也没开 `REQUIRE_PRINCIPAL`:请求里没有任何东西替主体头作保,头是谁都能自报的**标签**(过滤 / 展示用),不是身份。
- * 三处读它、不各写一份:会话列表的 fleet-wide 第一臂(`isFleetWide`)、会话写面的 fleet-wide 第一臂(`sessionOwnerScopeForWrite`)、
- * 会话面的属主谓词({@link sessionOwnerReadable})—— 于是「调用方是谁」在列表与单会话面上只有一只读法。
+ * 🔴 **「这台部署的装配能回哪几个身份来源」的唯一读法**({@link IDENTITY_SOURCES} 里接了线的那几个词,序同表)。两处读它、不各写一份:
+ * `/health.auth`(自报位,`http/health-self-report.ts`:`kinds` 与 `required` 同一次求值 —— `required` = 其中有 `service_token`)与 {@link devOpenDeployment}(门)
+ * —— 于是「这台部署认不认身份、门武没武装」在自报面与门上只有一只答案。
  */
-export declare function devOpenDeployment(config: ServiceConfig): boolean;
+export declare function wiredIdentitySources(w: IdentityWiring): readonly IdentitySource[];
+/**
+ * 🔴 **「这台部署有没有身份边界」的唯一判据**(S-1452;S-1509 改读身份来源)。dev-open = 装配**没接任何身份来源**({@link wiredIdentitySources} 为空:
+ * 没配 service token、没装鉴权桥、没开直连门)、**也没声明**只读 trace token 或 `REQUIRE_PRINCIPAL`:请求里没有任何东西替主体头作保,头是谁都能自报的
+ * **标签**(过滤 / 展示用),不是身份。装了鉴权桥的部署(SSO 单开)带登录令牌的调用方是验过的身份 ⇒ 不是 dev-open(修前只看 token / `REQUIRE_PRINCIPAL`,
+ * 这一形被读成 dev-open,任何人 fleet-wide 读全部会话)。
+ * 四处读它、不各写一份:会话列表的 fleet-wide 第一臂(`isFleetWide`)、会话写面的 fleet-wide 第一臂(`sessionOwnerScopeForWrite`)、
+ * 会话面的属主谓词({@link sessionOwnerReadable})、`/metrics` 族的免凭据臂(`dispatch.ts`)—— 于是「调用方是谁」在列表、单会话面与指标面上只有一只读法。
+ */
+export declare function devOpenDeployment(w: IdentityWiring): boolean;
+/** 会话行属主门的调用方的唯一铸点({@link SessionCaller}):验过的主体 + 是不是 fleet 调用方 —— {@link devOpenDeployment} 上的任何调用方,
+ *  或出示了这台部署的 service 凭据(`systemFor`)、不报主体的调用方(带主体头的是那位主体,不是 fleet;只读 trace token 不是 service 凭据)。 */
+export declare function sessionCallerOf(req: IncomingMessage, w: IdentityWiring): SessionCaller;
 /**
  * **「这个调用方能不能动这只会话」的唯一谓词**(会话面:视图 / head / 事件流 / 记忆状态与自助抹除 / 改名置顶 / 后台任务 / MCP 重连 /
- * 面板的上一腿 MCP 投影)。= {@link devOpenDeployment} ∨ {@link runOwnerReadable}:没有身份边界的部署上不钉任何人(与会话列表同读,
- * 列表把这只会话列给谁,谁就读得到它);有身份边界的部署上就是 run 面那一条谓词,一字不变。
+ * 面板的上一腿 MCP 投影)。没有身份边界的部署({@link devOpenDeployment})上不钉任何人(与会话列表同读,列表把这只会话列给谁,谁就读得到它);
+ * 有身份边界的部署上:
+ *  · **无主的行**经无主臂的唯一判据 `ownerlessRowOpen`(`security.ts`):普通会话照旧对任何调用方开放;委派子代的 placed 行只对 fleet 调用方
+ *    ({@link sessionCallerOf})开放 —— 任何具名主体、没有 service 凭据的无身份调用方都与别人的行同体(调用点答 404)(S-1770)。
+ *    代价如实:属主还没定下的子代行连它将来的属主也暂时读不到(由一次性迁移 M23 / 那一行的下一次停驻定下);
+ *  · 有主的行就是 run 面那一条谓词({@link runOwnerReadable}),一字不变。
  * run 面(poll / events / cancel …)不读本谓词 —— 那是 run 资源的门,另一只。
  */
-export declare function sessionOwnerReadable(principal: string | undefined, owner: string | null, config: ServiceConfig): boolean;
-/** The EXPLICIT operator gate (IMAGE-API-DESIGN.md §P2.4a MUST-FIX) — NOT the bare `isOperator` (whose empty-list
- *  "true-for-all" is an unrestricted-write exec door the instant OPERATOR_PRINCIPALS is empty). Requires a non-empty
- *  operator set AND a present principal IN it. The same form the preempt/resume endpoints already use.
- *  🔴 SINGLE mint point (E1): a byte-identical twin `explicitOperator` used to live below (image-visibility lane)
- *  and two more hand-inlined copies sat in approvals-assistant — a future hardening of this judgment would have
- *  missed them. All call sites now consume THIS function; do not re-introduce a sibling. */
-export declare function explicitOperatorOk(principal: string | undefined, operatorPrincipals: readonly string[]): boolean;
+export declare function sessionOwnerReadable(caller: SessionCaller, cell: SessionOwnerCell, w: IdentityWiring): boolean;
+/**
+ * 运维名册 —— 「谁是 operator」读的两格(都住在部署配置里):具名名单 `OPERATOR_PRINCIPALS` 与单用户形的显式声明 `OPERATOR_SINGLE_USER`。
+ * 两者互斥(声明只在单用户形、名单为空时成立;否则拒启 —— 一个事实一个来源,`config-invariants.ts` 的 `operator-single-user`)。
+ */
+export type OperatorRoster = Pick<ServiceConfig, "operatorPrincipals" | "operatorSingleUser">;
+/**
+ * 🔴 **「谁是 operator」的唯一读法**(S-1050,[ref] ① 裁 A;IMAGE-API-DESIGN.md §P2.4a MUST-FIX 的那一只门)。
+ *  · 名单为空 ⇒ **没人是**(没有任何形把「空名单」读成「人人是」—— 那条读法 `isOperator` 已删);
+ *  · 名单非空 ⇒ 验过的主体在名单里才是;
+ *  · 单用户形显式声明 `OPERATOR_SINGLE_USER=true` ⇒ 这台部署的**每个调用方**都是(单用户形只有一位用户,能到这台部署的就是他;边界是部署自己的
+ *    凭据门 —— 没配凭据的部署上,能连上端口的都是)。声明只在单用户形成立(起服不变量)。
+ * `principal` 必须是验过的身份(`gatedPrincipal`),绝不是自述头。全部运维面(审批队列、steer.trusted、记忆运维口、bake 门……)读这一只;
+ * 🔴 SINGLE mint point (E1):不要再造兄弟。
+ */
+export declare function explicitOperatorOk(principal: string | undefined, roster: OperatorRoster): boolean;
+/** 「这台部署**有没有**运维」的唯一读法(名单非空 ∨ 单用户声明在场)—— 能力事实 `operatorLane`、整理阀门的可达性告警、起服提示同读这一只。 */
+export declare function operatorRosterPresent(roster: OperatorRoster): boolean;
+/**
+ * 起服提示(S-1050):单用户形(`REQUIRE_PRINCIPAL` 未开)+ 没有运维名册 + 这台部署有审批底座 ⇒ 一行 warn。这一形在「空名单 = 人人是」那条读法退役之后
+ * 丢的东西就是审批队列的运维视图(跨 scope 列表 / `?owner=` / 无主体调用方的整个队列),补回它只要一行配置 —— 不拒启:升级那一拍打掉一台今天跑得好好的
+ * 单用户机器比一条提示重。多租形不提示(它另有拒启不变量);没有审批底座的形什么都没少。
+ */
+export declare function buildOperatorUndeclaredNotice(config: OperatorRoster & Pick<ServiceConfig, "requirePrincipal">, approvalFaceWired: boolean): {
+    event: "operator_undeclared_single_user";
+    fields: {
+        detail: string;
+    };
+} | undefined;
 /** operator 面族在「名单为空」这一形上的**唯一**拒发口:事实 `operatorLane`(`capability-facts.ts`)为假 ⇒ 这一面对任何
  *  身份都打不通 = 这台部署上不可用 ⇒ 501,不是鉴权拒(403 只留给「名单非空而你不在名单上」)。能力位读的是同一只事实。 */
 export declare function sendOperatorPrincipalsRequired(res: ServerResponse): void;
-/** May `principal` act as an OPERATOR on the F4 approval queue? Empty `operatorPrincipals` = legacy
- *  behavior (the shared service token IS the operator boundary → everyone authenticated is an operator).
- *  Otherwise only listed principals are operators. */
-export declare function isOperator(principal: string | undefined, operatorPrincipals: readonly string[]): boolean;
-/** Operator check WITHOUT the empty-list "everyone is an operator" legacy fallback — an EMPTY `operatorPrincipals`
- *  yields `false` (no one is an operator). Use this where empty-operators-means-all would be a SECURITY hole rather
- *  than a back-compat convenience: image VISIBILITY scoping (a tenant-scoped image must not leak to every caller
- *  just because OPERATOR_PRINCIPALS is unset). Adversarial-review HIGH: `isOperator([], p)=true` made
- *  `latestPublished(..., {operator:true})` bypass tenant visibility for any caller on an operator-less deployment.
- *  (The byte-identical `explicitOperator` twin that used to live here was folded into `explicitOperatorOk` above —
- *  one judgment, one mint point.) */
+/**
+ * 「这台部署没有运维名册」时**唯一**的出路句 —— 与 {@link operatorRosterPresent} 同一对旋钮,所以句子不比事实少说一条出路:
+ * 名单 `OPERATOR_PRINCIPALS`(具名运维;多租形只有这一条),或单用户形的显式声明 `OPERATOR_SINGLE_USER=true`(只在 `REQUIRE_PRINCIPAL` 未开且名单为空时成立,
+ * 否则起服拒 —— 句子把它限定在单用户部署上)。拒发口 {@link sendOperatorPrincipalsRequired}、能力事实闭集 `operator_principals_empty` 的义、记忆整理阀门的起服告警
+ * 都说这一句,别处不再各写一份。
+ */
+export declare function buildOperatorRosterWayOut(): string;
 //# sourceMappingURL=principal-gate.d.ts.map