@sema-agent/server 7.146.0 → 7.148.0

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

@@ -1,65 +1,400 @@
 /**
- * 🔴 **属主存取器**([ref] RH-3 第一期)——「这个调用方读得到这一行 run / 会话吗」的行只经这里取得。
+ * 🔴 **属主存取器**([ref] 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`)。
+ * 律与政策住在叶子 `owner-faces.ts`(一只事实函数 `qualsOf` + 一张面表 `FACES`);本模块做四件事,别处不再各写一份:
+ *  · **铸调用方**:{@link callerOf}(一次请求一次;验过的主体 + 运维 + fleet 两来源 + 只读 trace 凭据 + 部署两格)与 {@link callerOfDecision}(决定口:证明推出的主体替换请求主体,
+ *    运维随之重算、fleet 清空);
+ *  · **路由取面**:{@link ROUTE_FACES}(路由 id → 面,闭集穷举:属主面所在十二个路由域里新增一条路由而不登 = 编译红),路由拿不到更宽的面;
+ *  · **门**:{@link enter}(路由在它的身份前门处调,一次)、{@link admitRunRow} / {@link admitSessionRow}(没有这一行 / 前门 / 看不见三件按序判,run 行再按 {@link RUN_SESSION_ASSERTION} 判会话断言,拒一律经 {@link refuse};
+ *    承认的行属主带 `DurableOwnerKey` 品牌,`owner-faces.ts` 的 `OwnedRow`);列表口的属主视域经 `owner-faces.ts` 的 `listFilterOf`(列表面登在同一张路由表里);
+ *  · **拒的唯一下发口** {@link refuse}:投影按面登记(码随口的既有契约),拒因只进运维日志一行 `owner_gate_refused { policyFace, reason, principalPresent }`(不记任何身份值;
+ *    `policyFace` = 策略面〔面表键〕,与 `session_owner_unreadable` 那一行的 `face` = 口名分开命名:一个字段名一义)。
  *
- * ## 射程(第一期)
- * 迁进来的口: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`(增即红)。
+ * 嵌套可选读(会话面板的上一腿、审批预览)与协议口(A2A、leader、提交重放)用 {@link seesRun} / {@link seesSession}:不下发,看不见 = 没有,由调用点走它自己的缺席路径。
  */
-import type { ServiceConfig } from "../config-types.js";
-import type { Logger } from "../observability/logger.js";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { SessionHead } from "@sema-agent/core";
+import { type Logger } from "../observability/logger.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>;
-/**
- * 会话行读口:属主一读(会话店唯一的按 id 读 `headOf(id)?.owner`)+ 无主时 placement 一格(`sessionOwnerCellOf`,[ref])+ 会话面判官。
- * `undefined` = 没有这只会话(头读答 `undefined`)≡ 读不到。读回的那一格交给调用点(要按属主作答的口用它)。店的读失败照常抛(500,绝不当成「读不到」或「读得到」)。
- */
-export declare function readOwnedSession(w: IdentityWiring & {
-    readonly config: OwnerAccessConfig;
-}, store: Pick<OwnerAwareSessionStore, "placementOf"> & Required<Pick<OwnerAwareSessionStore, "headOf">>, caller: SessionCaller, sessionId: string, arm: OwnerArm): Promise<SessionOwnerCell | undefined>;
-/**
- * 🔴 **会话读面的属主读的第三个结局**:有主 / 无此行 / **属主读不出**(店交出具名拒 {@link SessionOwnerUnreadableError} —— 会话的行事实没有落下,补铸它要读的存档又用不了;
- * 谁也判不了「这是不是你的会话」)。第三个读作第二个:**与「没有这一行」同一个值**(`undefined`),调用点落的就是它们对「不存在 / 非属主」的那一臂 ——
- * 读者拿不到「这个 id 在盘上、且坏了」这件事(对非属主、对属主、对不存在的会话是同一只 404 `not_found.session`,同码同文),也就没有第二种拒绝形可漏存在性。
- * 原故障(码与句)进运维日志一行 `session_owner_unreadable`:这是拒,不是兜底,不走 `recordFailOpen`;被折的读不再经全局兜底,日志里不能因此少一行。
- *
- * 只折这一个具名拒:别的读故障(I/O 级、边档整只拒、SQL 店的读故障、别的 `SessionError`)一概照旧上抛 —— 折的是「属主读不出」这件确定的事,不是「头读抛了」。
- * 读面的所有属主读(会话视图三口共段 / 头探针 / 事件流 / 执行放置)经这一只;写口的属主读不在本只射程(它们对这一形仍答原故障的 500,契约 §17.2)。
+import type { ServiceConfig } from "../config-types.js";
+import { type Admitted, type Caller, type FaceId, type ListFaceId, type ListFilter, type OwnedReading, type Qual, type RunFaceId, type SessionFaceId } from "../owner-faces.js";
+import { type Person, type Subject } from "../owner-brands.js";
+import { type OwnerAwareSessionStore } from "../security.js";
+import { type OperatorRoster } from "./principal-gate.js";
+import type { AgentRosterRouteId } from "./routes/agents-roster.js";
+import type { ApprovalsAssistantRouteId } from "./routes/approvals-assistant.js";
+import type { BackgroundRouteId } from "./routes/background.js";
+import type { FleetRouteId } from "./routes/fleet.js";
+import type { McpReconnectRouteId } from "./routes/mcp-reconnect.js";
+import type { NotifyWakeRouteId } from "./routes/notify-wake.js";
+import type { ProjectsRouteId } from "./routes/projects.js";
+import type { RunMemoryCaptureRouteId } from "./routes/run-memory-capture.js";
+import type { RunPermissionModeRouteId } from "./routes/run-permission-mode.js";
+import type { RunsRouteId, RunVerbsRouteId } from "./routes/runs.js";
+import type { SessionMemorySyncRouteId } from "./routes/session-memory-sync.js";
+import type { SessionSyncRouteId } from "./routes/session-sync.js";
+import type { SessionsListRouteId } from "./routes/sessions-list.js";
+import type { SessionsRouteId } from "./routes/sessions.js";
+import type { TraceUsageRouteId } from "./routes/trace-usage.js";
+/** 存取器读的装配:部署配置(身份来源只从配置读,见 `identity-source.ts` 的 `configuredIdentitySources`)+ 运维日志。`FlatServiceDeps` 结构上满足。 */
+export interface OwnerAccessWiring {
+    readonly config: ServiceConfig;
+    readonly logger?: Pick<Logger, "info" | "warn"> | undefined;
+}
+/**
+ * 🔴 **一次请求的调用方**(唯一铸点之一;另一只是决定口的 {@link callerOfDecision}、提交挂接的 `security.ts` `claimCallerOf`)。
+ * 主体 = `gatedSubject`(验身份的那一只;带场景头 ⇒ 这个人的那一格分区);运维 = `explicitOperatorOk(personOf(主体))`(唯一读法,读人);fleet = 部署没有身份边界(`devOpenDeployment`)或出示 service 凭据、
+ * 不报主体、部署没声明关掉(`actsForDeployment`),两者互斥(前者要求没配凭据);只读 trace 凭据单列(它只在读档算 fleet,见面表 `fleet` 列)。
+ */
+export declare function callerOf(req: IncomingMessage, w: Pick<OwnerAccessWiring, "config">): Caller;
+/**
+ * 决定口的调用方:**这一次决定的证明**推出的人替换请求主体(直连门:证明的 `principal`,`principal-jwt.ts` 的 `verifyDirectDoorProof` 铸人;BFF:就是请求的人),
+ * 与身份相连的资格随之重算 —— 运维按证明的人重读名册;fleet 两格与只读 trace 凭据清空(决定口的面不放 fleet)。请求主体与证明身份是两种身份,不在一只调用方里并存。
+ * 证明只证人,不带场景;请求带了场景头 ⇒ 决定者的主体 = 证明的人在**同一个场景**里的那一格(场景是人之内的自选收窄,证明换了人、场景照旧)。
+ */
+export declare function callerOfDecision(base: Caller, decider: Person | undefined, roster: OperatorRoster): Caller;
+/** 决定者的主体(唯一读法;{@link callerOfDecision} 与只要主体 + 运维位的决断腿同读):证明推出的人 × 请求的场景(请求没带场景 ⇒ 与人逐字节同)。 */
+export declare function deciderSubjectOf(requestSubject: Subject | undefined, decider: Person | undefined): Subject | undefined;
+/** 属主面与列表面所在十六个域的路由 id(全部;无属主门的那几条登 `null`)。 */
+export type OwnedRouteId = RunsRouteId | RunVerbsRouteId | RunPermissionModeRouteId | RunMemoryCaptureRouteId | SessionsRouteId | SessionSyncRouteId | SessionMemorySyncRouteId | BackgroundRouteId | McpReconnectRouteId | NotifyWakeRouteId | TraceUsageRouteId | ApprovalsAssistantRouteId | SessionsListRouteId | FleetRouteId | ProjectsRouteId | AgentRosterRouteId;
+/**
+ * 🔴 **路由 → 面**(闭集穷举;`satisfies Record<…>`:十六个路由域里加一条路由不登 = 编译红,登错资源的面由 {@link admitRunRow} / {@link admitSessionRow} 的签名挡)。
+ * 列表 / 舰队读面登列表面(`list.read` / `session.list`:属主视域经 `owner-faces.ts` 的 `listFilterOf` 从这一行派生)。
+ * `null` = 这条路由不在本表判属主:提交面、ask / 检查点面(属主门在腿里经 `owner-faces.ts` 的 `keyAdmits` 判:决定 / 应答的属主是停驻行与问账行,不是路径上的这一行)。
+ */
+export declare const ROUTE_FACES: {
+    readonly "runs-submit": null;
+    readonly "runs-by-idem": "run.read";
+    readonly "run-detail": "run.read";
+    readonly "run-events": "run.read";
+    readonly "run-cancel": "run.drive";
+    readonly "run-steer": "run.supervise";
+    readonly "run-interrupt": "run.supervise";
+    readonly "run-detach": "run.supervise";
+    readonly "run-compact": "run.supervise";
+    readonly "run-subagent-output": "run.supervise";
+    readonly "run-subagent-stream": "run.supervise";
+    readonly "run-subagent-steer": "run.supervise";
+    readonly "run-subagent-resume": "run.supervise";
+    readonly "run-task-output": "run.supervise";
+    readonly "run-task-stop": "run.supervise";
+    readonly "elicitation-respond": null;
+    readonly "question-respond": null;
+    readonly "tool-approval-respond": null;
+    readonly "tool-approval-read": null;
+    readonly "task-ask-decision": null;
+    readonly "run-permission-mode": "run.supervise";
+    readonly "run-memory-capture-optout": "run.drive";
+    readonly "session-init": null;
+    readonly "session-settings": null;
+    readonly "session-mcp": null;
+    readonly "session-a2a": null;
+    readonly "session-head": "session.read";
+    readonly "session-execution-placement": "session.placement";
+    readonly "session-events": "session.read";
+    readonly "session-fork": "session.own";
+    readonly "session-policy-get": "session.policy";
+    readonly "session-policy-put": "session.policy";
+    readonly "session-memory-erase": "session.erase";
+    readonly "session-memory-status": "session.read";
+    readonly "session-workspace": null;
+    readonly "session-detail": "session.read";
+    readonly "session-rewind-files": "session.supervise";
+    readonly "session-patch": "session.act";
+    readonly "session-delete": "session.delete";
+    readonly "session-sync-manifest": "session.own";
+    readonly "session-sync-entries": "session.own";
+    readonly "session-sync-plan": "session.own";
+    readonly "session-sync-import": "session.own";
+    readonly "session-sync-import-entries": "session.own";
+    readonly "session-sync-blob-put": "session.own";
+    readonly "session-sync-history-blob": "session.own";
+    readonly "session-memory-sync": "session.act";
+    readonly "session-background-list": "session.supervise";
+    readonly "session-background-stop": "session.supervise";
+    readonly "session-children-retire": "session.supervise";
+    readonly "mcp-reconnect": "session.supervise";
+    readonly "session-wake": null;
+    readonly "session-notify": "session.notify";
+    readonly "tasks-source-summary": "list.read";
+    readonly "task-trace-list": "list.read";
+    readonly "task-tool-result": "run.trace";
+    readonly "task-trace-turns": "run.trace";
+    readonly "task-trace-stream": "run.trace";
+    readonly "task-trace-artifacts": "run.trace";
+    readonly "usage-analytics": "list.read";
+    readonly "approvals-list": null;
+    readonly "approvals-stream": null;
+    readonly "assistant-inbox": null;
+    readonly "assistant-tasks": null;
+    readonly "approval-decide": null;
+    readonly "approval-exemptions-list": "session.exemption";
+    readonly "approval-exemption-delete": "session.exemption";
+    readonly "assistant-task-preempt": "run.preempt";
+    readonly "assistant-task-resume": "run.resume";
+    readonly "assistant-task-plan-review": "run.decision";
+    readonly "sessions-list": "session.list";
+    readonly "sendfile-links": "list.read";
+    readonly "fleet-stream": "list.read";
+    readonly "projects-list": "list.read";
+    readonly "project-get": "list.read";
+    readonly "agents-roster": "list.read";
+};
+type RouteFaces = typeof ROUTE_FACES;
+/** 登到 run 面的路由 / 登到会话面的路由(由表派生:把会话路由交给 run 的门 = 编译红)。 */
+export type RunRouteId = {
+    [R in keyof RouteFaces]: RouteFaces[R] extends RunFaceId ? R : never;
+}[keyof RouteFaces];
+export type SessionRouteId = {
+    [R in keyof RouteFaces]: RouteFaces[R] extends SessionFaceId ? R : never;
+}[keyof RouteFaces];
+/** 登到列表面的路由(由表派生:列表面不交给 run / 会话的门)。 */
+export type ListRouteId = {
+    [R in keyof RouteFaces]: RouteFaces[R] extends ListFaceId ? R : never;
+}[keyof RouteFaces];
+type RoutedId = RunRouteId | SessionRouteId | ListRouteId;
+/** 协议口 / 嵌套读的面(不经路由表的那几只;路由面一律经 {@link ROUTE_FACES})。 */
+export type ProtocolFaceId = "run.a2a" | "run.leader" | "run.replay" | "run.preview" | "run.panel" | "run.anchor";
+/** 读 run 行的口:登到 run 面的路由 + 协议口 / 嵌套读(由两张既有闭集派生)。 */
+export type RunStateMouthId = RunRouteId | ProtocolFaceId;
+/**
+ * 🔴 **这一口把 run 的状态答给调用方吗**(闭集穷举;`satisfies Record<RunStateMouthId, …>`:新增一条 run 面路由 / 协议口而不登 = 编译红)。
+ * `observe` = 把 run 的状态 / 位置答给调用方的面 —— 属主门承认之后,行过店的观察口 `observeRun` 一次(心跳过期 ⇒ 当场落死亡判决,与收割器同一句;
+ * 「死了没」的落判决三处之一,另两处 = 收割器与认领冲突)。`raw` = 动词与簿记:按存着的行答,不判(持有者读自己、取消 / steer / 决定、turns / artifacts)。
+ * 授权在判决之前:看不见的调用方在门上就被拒,碰不到观察口(外人拿着别人的 run id 得 404 且什么都不变)。
+ */
+export declare const RUN_STATE_FACES: {
+    readonly "runs-by-idem": "observe";
+    readonly "run-detail": "observe";
+    readonly "run-events": "observe";
+    readonly "run-cancel": "raw";
+    readonly "run-steer": "raw";
+    readonly "run-interrupt": "raw";
+    readonly "run-detach": "raw";
+    readonly "run-compact": "raw";
+    readonly "run-subagent-output": "observe";
+    readonly "run-subagent-stream": "observe";
+    readonly "run-task-output": "observe";
+    readonly "run-task-stop": "observe";
+    readonly "run-subagent-steer": "raw";
+    readonly "run-subagent-resume": "raw";
+    readonly "run-permission-mode": "raw";
+    readonly "run-memory-capture-optout": "raw";
+    readonly "task-tool-result": "raw";
+    readonly "task-trace-turns": "raw";
+    readonly "task-trace-stream": "observe";
+    readonly "task-trace-artifacts": "raw";
+    readonly "assistant-task-preempt": "raw";
+    readonly "assistant-task-resume": "raw";
+    readonly "assistant-task-plan-review": "raw";
+    readonly "run.a2a": "observe";
+    readonly "run.replay": "observe";
+    readonly "run.leader": "raw";
+    readonly "run.preview": "raw";
+    readonly "run.panel": "raw";
+    readonly "run.anchor": "raw";
+};
+/** run 行的观察口(三只 run 店的 `observeRun`)。 */
+export interface RunObserver {
+    observeRun(row: RunRecord): Promise<RunRecord>;
+}
+/** 会话断言(`?session=`)的两相:`enforce` = 断言缺席也拒;`accept` = 缺席放行、按 `label` 落一行运维日志(受理相;`label` 是发过的日志字段 `face` 的值)。 */
+export type SessionAssertion = {
+    readonly phase: "enforce";
+} | {
+    readonly phase: "accept";
+    readonly label: string;
+};
+/**
+ * 🔴 **会话断言在哪几口是这条 run 行的门**(闭集穷举;`satisfies Record<RunStateMouthId, …>`:新增一条 run 面路由 / 协议口而不登 = 编译红)。
+ * 登了相的口:属主门承认之后、观察口之前,门读请求的 `?session=` 判({@link sessionAssertionVerdict});拒经 {@link refuse},与本口「没有这一行」同一答。
+ * `null` = 本口不判会话断言。观察会落判决(写),所以会话断言也在观察之前 —— 拒了的请求不替别人落判决。
+ */
+export declare const RUN_SESSION_ASSERTION: {
+    readonly "runs-by-idem": {
+        readonly phase: "accept";
+        readonly label: "run.poll";
+    };
+    readonly "run-detail": {
+        readonly phase: "accept";
+        readonly label: "run.poll";
+    };
+    readonly "run-events": {
+        readonly phase: "accept";
+        readonly label: "run.events";
+    };
+    readonly "run-cancel": {
+        readonly phase: "accept";
+        readonly label: "run.cancel";
+    };
+    readonly "run-steer": {
+        readonly phase: "accept";
+        readonly label: "run.steer";
+    };
+    readonly "run-interrupt": {
+        readonly phase: "accept";
+        readonly label: "run.interrupt";
+    };
+    readonly "run-detach": {
+        readonly phase: "accept";
+        readonly label: "run.detach";
+    };
+    readonly "run-compact": {
+        readonly phase: "accept";
+        readonly label: "run.compact";
+    };
+    readonly "run-subagent-output": {
+        readonly phase: "enforce";
+    };
+    readonly "run-subagent-stream": {
+        readonly phase: "enforce";
+    };
+    readonly "run-task-output": {
+        readonly phase: "enforce";
+    };
+    readonly "run-task-stop": {
+        readonly phase: "enforce";
+    };
+    readonly "run-subagent-steer": {
+        readonly phase: "accept";
+        readonly label: "subagent.steer";
+    };
+    readonly "run-subagent-resume": {
+        readonly phase: "accept";
+        readonly label: "subagent.resume";
+    };
+    readonly "run-permission-mode": {
+        readonly phase: "accept";
+        readonly label: "run.permission_mode";
+    };
+    readonly "run-memory-capture-optout": null;
+    readonly "task-tool-result": null;
+    readonly "task-trace-turns": null;
+    readonly "task-trace-stream": null;
+    readonly "task-trace-artifacts": null;
+    readonly "assistant-task-preempt": null;
+    readonly "assistant-task-resume": null;
+    readonly "assistant-task-plan-review": null;
+    readonly "run.a2a": null;
+    readonly "run.replay": null;
+    readonly "run.leader": null;
+    readonly "run.preview": null;
+    readonly "run.panel": null;
+    readonly "run.anchor": null;
+};
+/** 一次会话断言的结局:`pass` = 放行;`pass_unasserted` = 受理相上断言缺席、放行(调用点落 warn-once);`refuse` = 拒(本口「没有这一行」那一答)。 */
+export type SessionAssertionVerdict = "pass" | "pass_unasserted" | "refuse";
+/**
+ * 🔴 **会话断言的唯一判法**(纯函数;run 面的门与工作流按 id 四口同读)。`rowSession` = 行属于的会话(空 = 不属任何会话 ⇒ 无可断言);
+ * `asserted` = 请求的 `?session=`(`null` = 缺席);`operator` = 本次承认里的运维位。判序(六格矩阵钉 `test/owner-access.test.ts`):
+ * 行无会话 ⇒ 放行 → 受理相且断言缺席 ⇒ `pass_unasserted`(运维同样落这一行)→ 断言等于行会话 ⇒ 放行 → 运维 ⇒ 放行 → 拒。
+ */
+export declare function sessionAssertionVerdict(rule: SessionAssertion, asserted: string | null, rowSession: string | null | undefined, operator: boolean): SessionAssertionVerdict;
+/**
+ * 一次请求在一条会话断言下过不过(判 = {@link sessionAssertionVerdict},读请求的 `?session=`;`pass_unasserted` 在这里落 warn-once,run 面的门与工作流按 id 四口同调这一只)。
+ * 交回 `false` = 拒:调用点答它那一口「没有这一行」的那一答(run 面经 {@link refuse})。
+ */
+export declare function sessionAsserted(rule: SessionAssertion, req: IncomingMessage, rowSession: string | null | undefined, operator: boolean): boolean;
+/**
+ * 承认之后的那一步(唯一判法):这一口登 `observe` ⇒ 行过观察口;`raw` ⇒ 原样。口不在表里(只可能是非 run 面的口被交到 run 的门上 —— 型上不可达)⇒ 响亮抛。
+ * run 面的门({@link admitRunRow} / {@link admitRunById} / {@link readVisibleRun})都经它;门外的读口(提交重放、流的逐拍复读)按自己的口名调它。
+ */
+export declare function runRowAt(mouth: MouthId, store: RunObserver, row: RunRecord): Promise<RunRecord>;
+/**
+ * 口名:这一次判定从**哪一口**进来 —— 路由入口 = 路由 id({@link ROUTE_FACES} 的键);协议口 / 嵌套读入口 = 它的协议面 id。
+ * 与 `face`(策略面)是两件事:一行面表政策被好几个口共用,运维日志里「哪一口」读口名(`session_owner_unreadable.face`),「按哪行政策判」读面(`owner_gate_refused.policyFace`)。
+ */
+export type MouthId = OwnedRouteId | ProtocolFaceId;
+/** 一次判定的入口:面 + 口名 + 调用方(+ 拒要用的请求与装配)。只由 {@link enter} / {@link callerEntry} / {@link protocolEntry} 铸。 */
+export interface Entry<F extends FaceId = FaceId> {
+    readonly face: F;
+    readonly mouth: MouthId;
+    readonly caller: Caller;
+    readonly req: IncomingMessage;
+    readonly w: OwnerAccessWiring;
+}
+/**
+ * 路由的身份前门(在它今天手写前门的那个位置调,一次):铸调用方、按面的 `door` 列判 —— 拒 ⇒ 已应答、回 `undefined`。
+ * 面由路由 id 查表得来,路由不挑词。
+ */
+export declare function enter<R extends RoutedId>(req: IncomingMessage, res: ServerResponse, w: OwnerAccessWiring, route: R): Entry | undefined;
+/** 没有前置身份前门的路由(前门判在读行之后、与看不见同处 —— 今天的序)取入口:只铸调用方,门由 {@link admitRunRow} / {@link admitSessionRow} 在行读之后判。 */
+export declare function callerEntry<R extends RoutedId>(req: IncomingMessage, w: OwnerAccessWiring, route: R): Entry;
+/** 协议口 / 嵌套读的入口(调用方由调用点按它自己的身份读法铸好交来:请求口用 {@link callerOf})。 */
+export declare function protocolEntry(req: IncomingMessage, w: OwnerAccessWiring, face: ProtocolFaceId, caller: Caller): Entry;
+/** 换一只调用方、同一个面的入口(决定口:证明验过之后用 {@link callerOfDecision} 铸的调用方再判)。 */
+export declare function withCaller(entry: Entry, caller: Caller): Entry;
+/** 拒因(只进运维日志)。 */
+export type RefusalReason = "missing" | "not_visible" | "unreadable" | "session_mismatch";
+/**
+ * 🔴 **拒的唯一下发口**:按面登记的投影答「没有这一行」那一答(看不见 / 没有 / 会话断言不符同一答);拒因一行进运维日志(不记任何身份值,只记有无主体)。
+ * 本体里每一次 `sendError` 的码都写字面量:普查 ⑥ 从这里读出面投影码,本体之外(包括本文件)出现这些码的字面量即红;本体里换成非字面量的写法,门同样红。
+ * `id` = 路由路径上的行 id(run 面的句子按它给 a* / wa* 形句柄的指路;没有路径 id 的口不传)。投影 `omit` / `run_exists` / `attach_absent` 不经本口
+ * (前者调用点自答,后两者是提交管线的回执 / 抛出形,见 `submit-replay.ts` 与 `security.ts`)—— 交到这里 = 编程错,响亮抛。
+ */
+export declare function refuse(entry: Entry, res: ServerResponse, reason: RefusalReason, id?: string): void;
+/** 一次判的结局:承认,或拒因(前门 / 看不见)—— 还没下发。 */
+export type OwnerVerdict<R extends OwnedReading> = Admitted<R> | "door" | "not_visible";
+/** 下发一次判的结局:承认原样交回;前门拒 / 看不见经各自的下发口答(看不见 = 本口的投影),交回 `undefined`(已应答)。 */
+export declare function deliverVerdict<R extends OwnedReading>(entry: Entry, res: ServerResponse, verdict: OwnerVerdict<R>, id?: string): Admitted<R> | undefined;
+/**
+ * run 面的门:调用点读到的行(`undefined` / `null` = 没有)交进来 —— 没有 ⇒ 投影;前门;看不见 ⇒ 同一投影;本口登了会话断言({@link RUN_SESSION_ASSERTION})⇒ 不符同一投影。
+ * 交回承认(行 + 全部资格)或 `undefined`(已应答)。`id` = 路径上的 run id(句子的句柄指路;按幂等键读的口不传)。
+ */
+export declare function admitRunRow(entry: Entry, res: ServerResponse, runStore: RunObserver, row: RunRecord | null | undefined, id?: string): Promise<Admitted<RunRecord> | undefined>;
+/** run 面的门,行由本模块读(店唯一的按 id 读 `getRun`):路由不再自己读行(裸读普查门 ④ 的路由基线据此归零)。 */
+export declare function admitRunById(entry: Entry, res: ServerResponse, runStore: {
+    getRun(taskId: string): Promise<RunRecord | null | undefined>;
+} & RunObserver, taskId: string): Promise<Admitted<RunRecord> | undefined>;
+/** 嵌套可选读 / 协议口的 run 行读(不下发):本模块按 id 读一行并判,看不见 ≡ 没有(`undefined`),调用点走它自己的缺席路径。 */
+export declare function readVisibleRun(entry: Entry, runStore: {
+    getRun(taskId: string): Promise<RunRecord | null | undefined>;
+} & RunObserver, taskId: string): Promise<RunRecord | undefined>;
+/** run 行可见吗(不下发;嵌套可选读与协议口):看不见 ≡ 没有。 */
+export declare function seesRun(entry: Entry, owner: string | null | undefined): boolean;
+/**
+ * 不经请求的协议口判(提交重放、leader 登记表):调用方由调用点按协议口自己的身份读法铸好(认领面 / 协议口不放 fleet、不放运维 ⇒ `security.ts` 的
+ * `claimCallerOf`)。这几只面没有身份前门(`door: "none"`),所以与 {@link seesRun} 同判、不要请求。
+ */
+export declare function seesRunAs(face: "run.replay" | "run.leader", caller: Caller, owner: string | null | undefined): boolean;
+/** run 行的完整判(不下发,交回承认):提交重放等「看不见按自己的形答」的口用。 */
+export declare function judgeRun(entry: Entry, row: RunRecord): Admitted<RunRecord> | undefined;
+/**
+ * 这一读算「有这一行」吗:没读到(`undefined`,或 JS 店惯例的 `null`,见 {@link rowRead})⇒ 没有;读到了却缺属主格(`owner` 键缺席 —— 违约的店形,core 的会话头型恒带它)⇒ 也读作没有这一行
+ * (会话面的行就是属主那一格,判不了归属就没有行可判;fleet 调用方同样拿不到它)。
+ */
+export declare function sessionRowPresent<T extends OwnedReading>(reading: T | null | undefined): reading is T;
+/**
+ * 🔴 **会话行属主读的第三个结局**(「属主读不出」:店交出具名拒 {@link SessionOwnerUnreadableError})按面的 `unreadable` 列读:`fold` ⇒ 读作没有这一行
+ * (与非属主、不存在同一投影),原故障(码与句)进运维日志一行 `session_owner_unreadable { face, sessionId, errorCode, err }` —— 这一行的 `face` 是**口名**
+ * ({@link Entry.mouth}:`session-detail` / `session-head` …,发过的字段契约),不是策略面(策略面在 `owner_gate_refused` 那一行里叫 `policyFace`);`raise` ⇒ 照常上抛(写口答原故障的 500)。
+ * 只折这一个具名拒,别的读故障一律上抛。读期纪律(读期上限、并发许可)在调用点,本函数只包住那一读。
+ */
+export declare function readOwnerCell<T>(entry: Entry, sessionId: string, read: () => Promise<T | undefined>): Promise<T | undefined>;
+/**
+ * 会话面的门:调用点读到的那一读(`undefined` / `null` = 没有;读不出按面折过的也是 `undefined`)交进来 —— 没有 ⇒ 投影;行格(无主、且 placement 改得了判时问一次);
+ * 运维旁路 → 前门 → 看不见 ⇒ 同一投影。交回承认(读数 + 全部资格)或 `undefined`(已应答)。
+ */
+export declare function admitSessionRow<T extends OwnedReading>(entry: Entry, res: ServerResponse, store: Pick<OwnerAwareSessionStore, "placementOf"> | undefined, sessionId: string, reading: T | null | undefined): Promise<Admitted<T> | undefined>;
+/**
+ * 会话行的判(不下发):行格只经 `security.ts` 的 {@link sessionCellFor}(无主行的 placed 位只在两种假设不都放行时问店;存档读不出按面表 `placementUnreadable` 列;
+ * 别的读故障照常上抛)。事件流把这一判整个框进它的读期上限,判完再 {@link deliverVerdict}。
  */
-export declare function foldOwnerUnreadable<T>(logger: Pick<Logger, "warn"> | undefined, face: string, sessionId: string, read: () => Promise<T | undefined>): Promise<T | undefined>;
+export declare function judgeSessionRow<T extends OwnedReading>(entry: Entry, store: Pick<OwnerAwareSessionStore, "placementOf"> | undefined, sessionId: string, reading: T): Promise<OwnerVerdict<T>>;
+/** 会话面的门,头由本模块读(会话店唯一的按 id 读 `headOf`;读不出按面的 `unreadable` 列折):路由不再自己读头。 */
+export declare function admitSessionById(entry: Entry, res: ServerResponse, store: Pick<OwnerAwareSessionStore, "placementOf"> & Required<Pick<OwnerAwareSessionStore, "headOf">>, sessionId: string): Promise<Admitted<SessionHead> | undefined>;
+/** 会话行的完整判(不下发,交回承认 / `undefined`):两读之间要再判一次的口(同步导入的提交前复判)与「看不见按自己的形答」的口用。 */
+export declare function judgeSession<T extends OwnedReading>(entry: Entry, store: Pick<OwnerAwareSessionStore, "placementOf"> | undefined, sessionId: string, reading: T): Promise<Admitted<T> | undefined>;
+/** 这一份承认里的调用方是 fleet 吗(本口 `fleet` 列里的一格成立):fork 新属主「继承源属主」那一支读它。 */
+export declare function admittedAsFleet(entry: Entry, admitted: {
+    readonly quals: ReadonlySet<Qual>;
+}): boolean;
+/** 调用方持有本口 `fleet` 列里的某一格(可见与行无关):trace 口据此跳过逐 id 读。 */
+export declare function entryIsFleet(entry: Entry): boolean;
 /**
- * leader 登记表的判官形(boot 装配一次,`createLeaderEndpoint` 的必填席)—— leader 模块不再自判属主(修前它手抄 `owner == null || owner === requester`,
- * 缺 C8 窄互认臂而注称 mirrors runOwnerOk)。leader 腿的调用方身份经幂等身份结构(`IdemCaller.principal`,即 `gatedPrincipal` 的回值)转手而来,
- * 这里是 `Principal` 的「上游已验」适配铸点(第二期随那只结构带品牌而删)。`config` 是活的配置对象(每次调用现读)。
+ * 列表 / 舰队读面的属主视域(不经身份前门的那几口:它们的拒形按口 —— 401 identity / 401 operator / 主体拒 —— 在路由里,排在各自的店可用性判之前或之后):
+ * 路由 id 查表得列表面,`owner-faces.ts` 的 `listFilterOf` 从那一行派生(一只读法;trace 列表经 {@link enter} 拿入口后同读它)。
  */
-export declare function createLeaderRunVisibility(config: OwnerAccessConfig): (principal: string | null | undefined, owner: string | null | undefined) => boolean;
+export declare function routeListFilter<R extends ListRouteId>(req: IncomingMessage, w: Pick<OwnerAccessWiring, "config">, route: R): ListFilter;
+export {};
 //# sourceMappingURL=owner-access.d.ts.map