@sema-agent/server 7.149.0 → 7.151.0

package/dist/http/route-ctx.d.ts

@@ -39,6 +39,7 @@ import type { RememberLaneCannotRecord } from "../parked-decide.js";
 import type { RowWayOut } from "./resume-legs.js";
 import type { KeyCaller } from "../owner-faces.js";
 import type { Subject } from "../owner-brands.js";
+import type { RouteBackend, RouteRunStore, RouteSessionStore } from "./owner-access.js";
 /** 跨域可变状态 = lens1 §C2 实测的那 8 条「运行期登记簿」,一个对象。
  *  [ref]:`cancelledViaVerb`(按 taskId 键控的「这次是取消动词」旁表)删除 —— 中止成因改挂在每条腿自己的
  *  {@link RunAbort} 句柄上(`inflightRuns` 的值),同寿同删,不再有一张与腿不同寿的旁表。 */
@@ -199,14 +200,6 @@ export interface CheckpointCtx {
      * 传原 ctx / 其展开 ⇒ 标随行。缺席 = 不是无人值守腿(HTTP 提交腿;7.106.0 前落盘的行 —— 那时这些腿不铸模式,checkpoint 里也没有)。
      */
     unattendedLeg?: true;
-    /**
-     * 体里**模式词的读法记号**(闭集只有当前一词 `"entry_word"`):在场 = 这一行体的顶层 `permissionMode` 是这条 run 模式词唯一的源(提交入口盖过运维
-     * `AUTONOMY=plan` 的地板;`plan_review` 写回改它),续跑照它读。**服务端写、不来自请求体**。缺席(7.121.x 及以前写下的行 —— 那时运维的 plan 由治理层每段重钳)
-     * 而本部署此刻有入口地板、体的词被地板钳会变 ⇒ 续跑腿响亮拒、行字节不动(规则与删除条件的属主 = `http/checkpoint-ctx.ts` 顶注「模式词问」)。
-     * 写点两个(写模式词的人盖记号,同模块):`buildCheckpointCtx`(每一次新的持久化写都写)与 `withPermissionModeRewritten`(`plan_review` 改词的写回);
-     * 不改词的续跑腿写回传原 ctx ⇒ 记号随行。
-     */
-    permissionModeReading?: import("./checkpoint-ctx.js").PermissionModeReading;
     /**
      * 🔴 [ref] —— **写这份上下文的服务版本**(`package.json` 的 `version`),**服务端写、不来自请求体**(与 {@link unattendedLeg} 同为 `body` 的兄弟键)。
      * 写点两个:`buildCheckpointCtx`(每一次新的持久化写)与续跑腿的写回({@link DriveResumeArgs.resumeCtx} 的唯一写点,CAS 赢点盖本进程的版本 —— 接下来写下一张停车行的就是它)。
@@ -226,6 +219,24 @@ export interface CheckpointCtx {
      * 缺席 = 体里的目标就是交付的那一份(腿上没有屏)。
      */
     promptScreened?: true;
+    /**
+     * 这条 run 继承到的**项目上下文**(`project-context.ts` 的 {@link import("../project-context.js").ProjectContext}:项目 id · 继承的 `cwd` · 项目简报)——
+     * 新提交腿在装配器头部判一次,**服务端写、不来自请求体**(与 {@link memoryScope} 同为 `body` 的兄弟键,先例同形:提交腿推导、落盘,续跑原样读回)。
+     * 写点:`buildCheckpointCtx`(提交腿那一笔,经 `persistSubmissionCtx` 读这条腿的部署事实);leader worker 的写者不带(它的 spec 不经新提交腿的判)。续跑腿的写回传原 ctx / 其展开 ⇒ 随行。
+     * 读者只有一只:`resume-legs.ts` `resolveResumeSpec` 把它原样递给装配器(`opts.projectContext`)—— 续跑腿不再读登记簿、不再推观者(停驻期间登记被改 / 被删 / 看不见了,续跑照旧用这一份)。
+     * 缺席 = 没继承(含 7.150.0 之前写下的行:不回填,续跑不继承 = 那时的行为)。
+     */
+    projectContext?: import("../project-context.js").ProjectContext;
+    /**
+     * 这条 run 的**登记簿默认读层种子**(`project-registry.ts` 的 {@link import("../project-registry.js").MemorySeed}:种子项目 + 判出它的那一位观者)—— 新提交腿判一次:
+     * 这次提交带的项目对提交者可见(与 `GET /v1/projects/:id` 同一只判,观者 = 读面同一只推导)⇒ 种子;带了而判不出 ⇒ `null`(判过,无);没带项目 ⇒ 缺席。**服务端写、不来自请求体**(与 {@link memoryScope} 同为
+     * `body` 的兄弟键:提交腿推导、落盘,续跑原样读回)。冻结的是**观者**不是词:续跑以这一位观者经同一只可见性判重读此刻的登记(停驻期间改了词 ⇒ 新词;删了 / 换了主人 /
+     * 不再对他可见 ⇒ 没有种子)。写点:`buildCheckpointCtx`(提交腿那一笔,经 `persistSubmissionCtx` 读这条腿的部署事实);leader worker 的写者不带(它的体不带项目)。
+     * 续跑腿的写回传原 ctx / 其展开 ⇒ 随行。读者只有一只:`resume-legs.ts` `resolveResumeSpec` 把它原样递给装配器(`opts.memorySeed`)—— 续跑腿不推观者、不按 `body.projectId` 现查。
+     * 缺席而存体带了项目 = 本格出现之前写下的行(不回填:那时的提交腿没有判过可见性)⇒ 续跑不取种子,装配器记运维一行 `resume_memory_seed_unjudged`。
+     * 形只有一种读法(`frozenMemorySeedOf`,读口 `resume-ctx-read.ts`)。
+     */
+    memorySeed?: import("../project-registry.js").MemorySeed | null;
 }
 /**
  * `/decide` 第三条车道交给宿主投递腿(wake:`DriveResumeArgs` / fresh:`DurableRunLegArgs`)的**一件**:这一跑在内存里带着的决定,
@@ -377,7 +388,8 @@ export interface DriveResumeArgs {
     /**
      * 🔴 **[ref](codex 交叉复审 r2-[medium] 验真后修):这条腿是**调用方发起**的吗?**
      *
-     * `true` = 有人在 HTTP 上点了按钮(resume / plan_review / wake / decide / 赎回席)⇒ 吃按**付费方**
+     * `true` = 有人在 HTTP 上点了按钮(resume / plan_review / wake / decide / 赎回席),或这一跑交付的是一条**已受理的人的决定**
+     * (workflow 停驻卡的 run 收场送达把它交给宿主会话的下一跑 —— 没有请求,但花的是卡属主的钱)⇒ 吃按**付费方**
      * (卡属主)判的成本配额准入(`ownerCostQuotaDenied`)。缺席/`false` = **部署自己的结算腿**
      * (内部 D-D SLA deny-sweep)⇒ **不吃**那道门。
      *
@@ -391,9 +403,8 @@ export interface DriveResumeArgs {
      * 并且整段时间攥着会话 claim。**方向也自洽**:deny 是**停下**这条 run 的动作,为了省钱而拒绝执行「停」
      * 与 preempt 路由早就成文的那句同一条(「否则超顶租户连自己的花费都停不下来」)。
      *
-     * 判别子取 `req` 的在场与否 —— 这在 `resumeCheckpoint` 里**已经是**「系统腿 vs 调用方腿」的既有判据
-     * (绑定强制、parked 分流两处都写着 `req !== undefined` 与「内部 D-D SLA deny-sweep(req 缺席)豁免」),
-     * 本位只是把同一条判据显式化成一个有名字的位,而不是让下游去猜。
+     * 判别子**不再**只是 `req` 的在场与否:`req` 缺席的腿有两种 —— SLA 拒扫(结算,不吃门)与 workflow 停驻卡的 run 收场送达(交付一条人的决定,
+     * 吃门,fail-closed)。所以本位是一个**有名字的事实**,由起腿的那一处写明(wake 腿:`req` 在场 ∨ 这一跑带着一件决定投递),下游只读这一位、不去猜 `req`。
      * ⚠️ **射程覆盖两道门**:紧邻的 fleet-lease 准入(`ownerFleetLeaseDenied`)读**同一位** —— [ref] 件⑤②
      * (codex r3-[high])把它一并改吃了 `callerInitiated`,理由与三问逐字同 cost 半场。
      * 🔴 本句是 [ref] R4 改写的(2026-09-03,7.57.0 发车前合并重扫 wf_1abaaa9a):此处原文写着「紧邻的
@@ -416,7 +427,7 @@ export interface DriveResumeArgs {
      *
      * 所以由上游把「已受理」这个事实传下来,`driveResumeLeg` 据此跳过重复协商。**安全性**:两处的键是
      * **同一个表达式**(`decodeCheckpointScope(cp.scope)`,上游门与下游 `auth.principal` 同源),射程条件也
-     * 同一条(`req !== undefined` ⇔ `callerInitiated`)⇒ 跳过的是一次**逐字相同**的判定,不是一道门。
+     * 同一条(上游判过两门 ⇔ 下游 `callerInitiated`:`/decide` 与 workflow 停驻卡的 run 收场送达都在交下来之前按卡属主判过)⇒ 跳过的是一次**逐字相同**的判定,不是一道门。
      * 缺席/`false` ⇒ 照常自己判(其余三条驱动腿与 sweep 一字不变)。
      */
     ownerLeaseAdmitted?: boolean;
@@ -442,13 +453,13 @@ export interface RouteLegs {
     /** POST /v1/tasks · /v1/tasks/stream · /v1/runs 的共同前段:读体 → 校验 → resolveSpec。null = 已应答(400/…)。
      *
      *  `body` = **已解析好的**请求体,给那些体不是「这条 HTTP 请求的 JSON 正文」的调用方
-     *  (DESIGN-269 车2:A2A JSON-RPC 腿已经把正文读成了一条 `message/send` 请求,再 `readJson(req)`
+     *  ([ref] 车2:A2A JSON-RPC 腿已经把正文读成了一条 `message/send` 请求,再 `readJson(req)`
      *  一次只会读到空流)。缺席 ⇒ 照旧自己读体,既有三个调用方一字不改。
      *  ⚠️ 这是**入口形**的分歧,不是校验面的分歧:传进来的体与自己读的体走**同一段**校验/授权/
      *  resolveSpec —— 分叉出第二条校验路径正是本参数存在的理由的反面。
      *
      *  `onTypedFailure` = 「typed 拒绝**别写响应**,交回给我」。默认(缺席)行为不变:`HttpError` 走
-     *  `sendError` 连 `extra` 一起回显。DESIGN-269 车2 的 A2A 腿必须传它 —— 那些 `extra`(尤其
+     *  `sendError` 连 `extra` 一起回显。[ref] 车2 的 A2A 腿必须传它 —— 那些 `extra`(尤其
      *  `scenario_unknown` 的**全部场景名**)对壳是指路材料,对一个外部 peer 是内部词表外泄。 */
     prepareSpec(req: IncomingMessage, res: ServerResponse, body?: TaskRequestBody, onTypedFailure?: (err: import("../security.js").HttpError) => void, 
     /** [ref] 件C:**腿身份**(不是能力表态)。`liveStream: true` 只由 `POST /v1/tasks/stream` 的装配点按
@@ -600,8 +611,19 @@ export declare function sendResumeOutcome(res: ServerResponse, out: {
 }, logger: {
     info?: (msg: string, fields?: Record<string, unknown>) => void;
 } | undefined, extraBody?: Record<string, unknown>): void;
+/**
+ * 🔴 **路由层的服务 deps(类型墙,[ref] 第二阶段)**:run 店 / 会话店上带属主的读口(按 id / 按键 / 按会话 / 列表 —— `owner-access.ts` 的 {@link RouteRunStore} /
+ * {@link RouteSessionStore})、会话视图读 `sessionAudit` 与后端铸这两只店的工厂(`backend.run()` / `backend.session()`,{@link RouteBackend})在型上调不了:路由在不在照判(能力事实只问方法在不在,见证随视图封着),带属主的行只经属主存取器读。
+ * 值上就是服务的那一只 deps,只在 `owner-access.ts` 的 `sealRouteDeps` 铸一次;视图是完整 deps 的子型(交给持认领腿的写口照常)。
+ */
+export type RouteDeps = Omit<FlatServiceDeps, "runStore" | "sessionStorage" | "sessionAudit" | "backend"> & {
+    runStore?: RouteRunStore;
+    sessionStorage?: RouteSessionStore;
+    sessionAudit?: never;
+    backend?: RouteBackend;
+};
 export interface RouteCtxBase {
-    deps: FlatServiceDeps;
+    deps: RouteDeps;
     registry: RunRegistry;
     helpers: RouteHelpers;
     local: RouteLocals;
@@ -663,15 +685,15 @@ export interface RouteDeclFacts {
      *  编排器片 2 件 2:值 = 这一种计费请求的**种类**(`submit` 新工作 / `hitl-answer` 对等人的卡作答 / `resume` 续跑;闭集属主
      *  `http/readiness.ts` 的 `BILLABLE_KINDS`)—— 排空与租约过期只拒 `submit`(放行闭集表 `ADMISSION_TABLE`),无凭证门不看种类。 */
     readonly billable?: import("./readiness.js").BillableKind;
-    /** 「本条 url 在**没有任何 service credential** 的部署形下,这几个方法必须 fail-closed」。
+    /** 「本条 url 上这几个方法在**请求没带凭据门认的凭据**(service 凭据 / 鉴权桥验过的登录令牌;`identity-source.ts` 头注律 5)时必须 fail-closed」。
      *  判据(两个合取项)= 「授权的唯一输入是 principal 头」∧「持久改写,或爆炸半径跨租户的治理读」;
      *  逐口论证在各 `routes/*.ts` 的头注里,声明行只记结论。 */
     readonly credentialGated?: readonly RouteMethod[];
     /** 「这条 url **是**计费提交面,但它到底提不提交由**请求体里的方法**决定」—— 单 URL 多方法的
      *  JSON-RPC 端点。两道**可用性** 503(drain / roster-pending)按 url 一刀切会把同端点上的纯读一起
      *  关掉,所以分派器对本行**跳过**那两道,改由域模块在写分支里施加同样的两道(文案逐字同源)。
-     *  🔴 只豁免那两道,**不豁免安全轴**:`billable` 本身仍为 true,无 service token 那道 fail-closed
-     *  503 照旧罩着(它判的是「这台机能不能收写」,与方法无关,且必须在解析请求体之前)。 */
+     *  🔴 只豁免那两道,**不豁免安全轴**:`billable` 本身仍为 true,写门那道 fail-closed
+     *  503 照旧罩着(它判的是「这次请求带没带过门的凭据」,与方法无关,且必须在解析请求体之前)。 */
     readonly methodDispatched?: true;
 }
 /** **可分派行**多出来的列([ref] 第三刀):身份 + 它真认的方法(+ [ref] 的订阅类)。纯门行一列都没有(见下)。 */

package/dist/http/route-table.d.ts

@@ -136,7 +136,7 @@ export declare function routeLabel(_method: string, url: string): string;
 export declare function isBillableSubmitPath(url: string): boolean;
 /** 编排器片 2 件 2:这条 url 是哪一**种**计费请求(`undefined` = 不在计费面)。声明序第一条命中的行定种类(今天每条 url 至多命中一行)。 */
 export declare function billableKindOf(url: string): BillableKind | undefined;
-/** [ref]([ref] 件5)—— **改写门**:不烧模型、但在没有任何 service credential 的部署形下必须
+/** [ref]([ref] 件5)—— **改写门**:不烧模型、但在请求没带凭据门认的凭据时(`identity-source.ts` 头注律 5)必须
  *  与 billable / bake 两族一样 fail-closed 的写门。与 `isBillableSubmitPath` **刻意分开**:这几扇门
  *  `billable=false`(零模型工作),塞进那张名单会让它们连带吃 drain 与 roster-pending 两道 503 ——
  *  而收编与规则读写在排空期/roster 未落时做完全无害。 */

package/dist/http/routes/a2a-serve.js

@@ -4,12 +4,13 @@ import { memoRedactedRead, redactErrorMessage } from "../../observability/run-te
 import { isParkedRunStatus, isTerminalRunStatus } from "../../plugins/store-contracts.js";
 import { HttpError } from "../../security.js";
 import { idemCallerOf, idemIdentityOf, idemKeyOf, inflightKeyOf } from "../idempotency.js";
-import { isRunExistsConflictBody, replayOfExistingRun } from "../submit-replay.js";
+import { answerReplay, isRunExistsConflictBody } from "../submit-replay.js";
 import { isActiveRunConflictBody } from "../active-run-conflict.js";
 import { sendJson, sendError, sendHttpError } from "../send.js";
 import { admissionRefusalOf, readinessOf, sendBillableRefusal } from "../readiness.js";
+import { memberLeaseOf } from "../../fleet/engine-signal.js";
 import { gatedPerson, gatedSubject, sendPrincipalRefusal, verifiedIdentitySource } from "../principal-gate.js";
-import { callerOf, protocolEntry, readVisibleRun, runRowAt } from "../owner-access.js";
+import { callerOf, protocolEntry, readReplayHit, readVisibleRun, runRowAt } from "../owner-access.js";
 import { assertNever } from "../route-ctx.js";
 import * as facts from "../../capability-facts.js";
 import { createDurableRun } from "./runs.js";
@@ -181,7 +182,7 @@ function rpcErrorFromTypedFailure(err) {
 }
 function submitUnavailable(res, ctx) {
     const { deps } = ctx;
-    const refusal = admissionRefusalOf(readinessOf(deps), deps.servingLease?.(), "submit");
+    const refusal = admissionRefusalOf(readinessOf(deps), memberLeaseOf(deps), "submit");
     if (refusal === undefined)
         return false;
     sendBillableRefusal(res, refusal);
@@ -197,15 +198,14 @@ function readBlocking(params) {
         throw new RpcError(JSONRPC_INVALID_PARAMS, "params.configuration.blocking must be a boolean");
     return c.blocking;
 }
-async function waitForRun(ctx, store, res, taskId, budgetMs) {
+async function waitForRun(ctx, entry, store, res, taskId, budgetMs) {
     const { deps } = ctx;
     const deadline = Date.now() + budgetMs;
     let last = null;
     for (;;) {
         let run;
         try {
-            const raw = await store.getRun(taskId);
-            run = raw ? await runRowAt("run.a2a", store, raw) : null;
+            run = (await readVisibleRun(entry, store, taskId))?.row ?? null;
         }
         catch (e) {
             deps.logger?.warn?.("a2a_serve_wait_read_failed", { error: e?.message });
@@ -254,10 +254,11 @@ async function handleMessageSend({ req, res, ctx, params, serve, runStore }) {
         ...(contextId !== undefined ? { sessionId: contextId } : {}),
         ...(scenario !== undefined ? { scenario } : {}),
     };
-    const keyed = (await runStore.getRunByIdem(idem.key).catch(() => undefined)) ?? (await runStore.getRun(body.taskId).catch(() => undefined));
-    const replay = keyed ? await replayOfExistingRun(keyed, { subject: submitter, clientTaskId: body.taskId, idem }, "durable", deps, runStore) : undefined;
-    if (keyed && replay?.status === 202) {
-        return taskFromRun(await runRowAt("run.a2a", runStore, keyed));
+    const keyed = (await readReplayHit(submitter, deps.config, runStore, { idemKey: idem.key }, body.taskId).catch(() => undefined)) ??
+        (await readReplayHit(submitter, deps.config, runStore, { taskId: body.taskId }, body.taskId).catch(() => undefined));
+    const replay = keyed ? await answerReplay(keyed, { subject: submitter, clientTaskId: body.taskId, idem }, "durable", runStore) : undefined;
+    if (keyed?.kind === "visible" && replay?.status === 202) {
+        return taskFromRun(await runRowAt("run.a2a", runStore, keyed.row));
     }
     const inflight = replay === undefined ? ctx.registry.idemCache.peek(inflightKeyOf(idem, "durable", body.taskId)) : undefined;
     let receipt;
@@ -298,7 +299,7 @@ async function handleMessageSend({ req, res, ctx, params, serve, runStore }) {
     }
     const taskId = receiptBody.taskId;
     const sessionId = receiptBody.sessionId;
-    const run = await waitForRun(ctx, runStore, res, taskId, blocking ? serve.blockingWaitMs : 0);
+    const run = await waitForRun(ctx, protocolEntry(req, deps, "run.a2a", callerOf(req, deps)), runStore, res, taskId, blocking ? serve.blockingWaitMs : 0);
     if (run)
         return taskFromRun(run);
     return {
@@ -330,10 +331,10 @@ function durableIdempotencyTaskId(scope, messageId) {
 async function handleTasksGet({ req, ctx, params, runStore }) {
     const { deps } = ctx;
     const id = asNonEmptyString(params.id, "params.id", MAX_TASK_ID_CHARS);
-    const run = await readVisibleRun(protocolEntry(req, deps, "run.a2a", callerOf(req, deps)), runStore, id);
-    if (!run)
+    const admitted = await readVisibleRun(protocolEntry(req, deps, "run.a2a", callerOf(req, deps)), runStore, id);
+    if (!admitted)
         throw new RpcError(A2A_TASK_NOT_FOUND, A2A_TASK_NOT_FOUND_MESSAGE);
-    return taskFromRun(run);
+    return taskFromRun(admitted.row);
 }
 async function handleExtendedCard({ req, ctx, serve }) {
     return buildAgentCard(serve, cardReaderOf(req, ctx.deps.config), A2A_METHODS);

package/dist/http/routes/admin-memory-optout.d.ts

@@ -26,7 +26,7 @@
  * 的调用方不该从「这台有没有授权表」上读出部署形态。
  * 🔴 四口都在 `isCredentialGatedRewrite`(server.ts)门内(codex R1-[high] 验真后补):授权的**唯一**输入是
  * principal 头 ∧ 一次调用的爆炸半径跨租户(改缺省行 = 改整台部署每个 principal 的 verdict;读面 = 全部授权行 +
- * operator 手写的 note)—— 无 service 凭证且未开 `ALLOW_UNAUTHED_WRITES` 的 worker 上那个头**可自造**,与
+ * operator 手写的 note)—— 请求没带凭据门认的凭据(且部署未开 `ALLOW_UNAUTHED_WRITES`)时那个头**可自造**,与
  * `/v1/memory/erase` / `POST /v1/memory/export` 同一条论证。
  *
  * ── 为什么缺席形是 **501 `capability.*`** 而不是 404(与 consolidation 阀门刻意分家)──────────────────

package/dist/http/routes/agents-roster.js

@@ -2,8 +2,7 @@ import { chosenAgentName } from "@sema-agent/core";
 import { sendJson, sendError } from "../send.js";
 import { gatedSubject, sendUnauthorized } from "../principal-gate.js";
 import { PRINCIPAL_MAX_BYTES } from "../../principal-shape.js";
-import { partsOf } from "../../owner-brands.js";
-import { taskSpecIdentityOf } from "../../engine-identity.js";
+import { engineScopeOf } from "../../engine-identity.js";
 import { routeListFilter } from "../owner-access.js";
 import { assertNever } from "../route-ctx.js";
 import * as facts from "../../capability-facts.js";
@@ -99,7 +98,7 @@ export async function handleAgentRoster(req, res, match, ctx) {
             }
             const status = statusRaw === null ? undefined : statusRaw;
             const subject = gatedSubject(req, deps.config);
-            const ownScope = taskSpecIdentityOf(subject === undefined ? undefined : partsOf(subject)).principal ?? "default";
+            const ownScope = engineScopeOf(subject);
             let scope;
             if (gateOwner !== null) {
                 scope = ownScope;

package/dist/http/routes/approvals-assistant.d.ts

@@ -2,12 +2,13 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import type { QuestionAnswer } from "@sema-agent/core";
 import type { CheckpointStoreFull } from "../../plugins/store-backend.js";
 import { type ToolApprovalCoordinator } from "../../tool-approval.js";
+import { type RouteSessionStore } from "../owner-access.js";
 import { type GovernancePosture } from "../../runtime-governance.js";
 import { type GateIntentView } from "../../approval.js";
 import { type RouteCtx, type RouteDecl, type RouteMatch, type RouteIdsOf } from "../route-ctx.js";
 import { type KeyClosureIssue } from "../../request-key-closure.js";
 import { type PeerInboundPendingRow } from "../../peer-inbound-face.js";
-import { type PlacementReadingSessionStore, type SessionAgent } from "../../session-agent.js";
+import type { SessionAgent } from "../../session-agent.js";
 /** 族的成员 = 路由表行 id(改名 / 删行 ⇒ 下表的键当场编译红)。 */
 export type DecisionDoorId = Extract<ApprovalsAssistantRouteId, "approval-decide" | "assistant-task-plan-review">;
 /** 一道门的静态描述 —— 只写**这道门自己**的东西;路径、路径段、别门的键一概不在这里写(从来源读)。 */
@@ -164,7 +165,7 @@ peerInbound: (() => readonly PeerInboundPendingRow[]) | undefined,
  * 🔴 [ref]:停驻行 `agent` 的会话店面 —— 与 `GET /v1/approvals` 同一只(`deps.sessionStorage`),经同一只整批投影 {@link projectDurableQueue}。
  * `undefined` / 店不交 `placementOf` = 这台部署不存委派元组 ⇒ 没有一帧带 `agent`(帧字节与 [ref] 之前逐字相同)。位置在 `scope` 之前、与 `live` 并列:每个生产调用点都必须表态。
  */
-sessions: PlacementReadingSessionStore | undefined, scope: string | undefined, 
+sessions: Pick<RouteSessionStore, "placementOf"> | undefined, scope: string | undefined, 
 /** [ref]②:出身归因的部署侧一半 + 三张审批名单(问的属主)。缺席 ⇒ 归不出治理出身(键缺席,与 best-effort 同方向)、没有一行读作
  *  部署名单的问(记不住,方向是多问)。**位置在 `pollMs` 之前**是刻意的:`pollMs` 只有测试传,而本参数是每个生产调用点都必须给的那一个。 */
 governance?: PendingProjectionDeployment, pollMs?: number): Promise<void>;

package/dist/http/routes/approvals-assistant.js

@@ -8,7 +8,7 @@ import { approvalPayloadFingerprint } from "../../plugins/approval-payload-finge
 import { carriesDeploymentListQuestion, standingAnswerDurablyRecordable } from "../../tool-approval.js";
 import { APPROVAL_GATE_KINDS } from "../../approval-content-kind.js";
 import { isParkedRunStatus } from "../../plugins/store-contracts.js";
-import { principalFrom, ownerOfCheckpointScope, scopeCellOf, CHECKPOINT_PUBLIC_SCOPE, PRINCIPAL_TOKEN_HEADER, APPROVAL_MAC_HEADER, APPROVAL_MAC_KID_HEADER } from "../../security.js";
+import { principalFrom, scopeCellOf, CHECKPOINT_PUBLIC_SCOPE, PRINCIPAL_TOKEN_HEADER, APPROVAL_MAC_HEADER, APPROVAL_MAC_KID_HEADER } from "../../security.js";
 import { keyAdmits } from "../../owner-faces.js";
 import { personOf } from "../../owner-brands.js";
 import { editedPlanBinding, verifyDirectDoorProof } from "../../principal-jwt.js";
@@ -23,7 +23,7 @@ import { sleep } from "../sse-log.js";
 import { bindSseLifecycle } from "../sse-lifecycle.js";
 import { sendJson, sendError, sseHeaders, logRequestError, SSE_MAX_STREAM_MS, SSE_HEARTBEAT_IDLE_MS } from "../send.js";
 import { gatedSubject, explicitOperatorOk, sendPrincipalRefusal } from "../principal-gate.js";
-import { admitRunById, admitSessionById, callerEntry, callerOf, callerOfDecision, deciderSubjectOf, enter, judgeRun, protocolEntry, readVisibleRun, refuse, withCaller } from "../owner-access.js";
+import { admitRunById, admitSessionById, callerEntry, callerOf, callerOfDecision, deciderSubjectOf, enter, latestRunIdOf, listRunsOfScope, protocolEntry, readSessionAgent, readVisibleRun, refuse, runFactsOf, withCaller } from "../owner-access.js";
 import { governanceOriginOf } from "../../runtime-governance.js";
 import { deploymentListAsks } from "../../approval.js";
 import { grantBindingOf } from "../../standing-answer-grant.js";
@@ -38,9 +38,9 @@ import { fieldConflictFacts } from "../../field-conflict.js";
 import { buildSettlementEvidence } from "../../gate-settlement.js";
 import { seatText } from "../../trace/exit-seat.js";
 import { approvalQueueKindOfDoorId } from "../../approval-queue-kind.js";
-import { defaultPeerInboundFace, parsePeerInboundId, peerBoxScope } from "../../peer-inbound-face.js";
+import { defaultPeerInboundFace, parsePeerInboundId } from "../../peer-inbound-face.js";
+import { engineScopeOfOwner } from "../../engine-identity.js";
 import { RESUME_RESTATABLE_KEYS, readResumeRestatement } from "../resume-restatement.js";
-import { readSessionAgent } from "../../session-agent.js";
 const DECIDE_BODY_DECLARED_KEYS = [
     "answer", "boundCallId", "boundInputHash", "checkpointToken", "decidedBy", "decidedVia", "decision", "feedback", "reason", "remember", "updatedInput",
     ...RESUME_RESTATABLE_KEYS,
@@ -280,8 +280,8 @@ async function decideIdempotentReplay(cs, args) {
     };
 }
 async function gateObjectivePreview(reader, runStore, agentStore, gate, runSessionId) {
-    const previewOf = (taskId) => readVisibleRun(reader, runStore, taskId);
-    const own = typeof runSessionId === "string" ? ((await runStore.getActiveTaskId(runSessionId)) ?? (await runStore.latestRunForSession(runSessionId))?.taskId) : undefined;
+    const previewOf = async (taskId) => (await readVisibleRun(reader, runStore, taskId))?.row;
+    const own = typeof runSessionId === "string" ? ((await runStore.getActiveTaskId(runSessionId)) ?? (await latestRunIdOf(runStore, runSessionId))) : undefined;
     if (own !== undefined)
         return (await previewOf(own))?.objectivePreview ?? null;
     if (agentStore === undefined)
@@ -462,7 +462,7 @@ export async function handleApprovalsAssistant(req, res, match, ctx) {
                 if (typeof host === "string")
                     byGate.set(host, s);
             });
-            const runs = await runStore.listRuns({ owner: ownerOfCheckpointScope(scope), limit: 100 });
+            const runs = await listRunsOfScope(runStore, scope, 100);
             const tasks = runs
                 .filter((r) => r.status === "running" || isParkedRunStatus(r.status))
                 .map((r) => {
@@ -511,7 +511,7 @@ export async function handleApprovalsAssistant(req, res, match, ctx) {
                 let flagged = await runStore.requestPreempt(taskId, run.owner);
                 const PREEMPT_RECLASSIFY_ATTEMPTS = 3;
                 for (let attempt = 0; !flagged; attempt++) {
-                    const now = await runStore.getRun(taskId);
+                    const now = (await readVisibleRun(preemptEntry, runStore, taskId))?.row;
                     if (now !== undefined && isParkedRunStatus(now.status)) {
                         sendError(res, 409, "conflict.already_suspended", "task is already suspended", { taskId, status: now.status });
                         return;
@@ -661,7 +661,7 @@ export async function handleApprovalsAssistant(req, res, match, ctx) {
             }
             const sighting = typeof body.checkpointId === "string" ? { face: "checkpointId", value: body.checkpointId } : undefined;
             const decisionEntry = callerEntry(req, deps, match.decl.id);
-            const run = await runStore.getRun(taskId);
+            const run = await runFactsOf(runStore, taskId);
             if (!run) {
                 if (!deps.config.directDoorActive)
                     deps.logger?.info?.("decide_404", { reason: "no-row", taskId, principalPresent: principal !== undefined });
@@ -694,7 +694,7 @@ export async function handleApprovalsAssistant(req, res, match, ctx) {
                 singleUse = proof.singleUse === undefined ? undefined : { proof: proof.singleUse, store };
             }
             const deciderEntry = withCaller(decisionEntry, callerOfDecision(decisionEntry.caller, deciderPrincipal, deps.config));
-            const decisionAdmitted = judgeRun(deciderEntry, run);
+            const decisionAdmitted = await readVisibleRun(deciderEntry, runStore, taskId);
             if (decisionAdmitted === undefined) {
                 deps.logger?.info?.("decide_404", { reason: "owner-mismatch", taskId, principalPresent: principal !== undefined });
                 refuse(deciderEntry, res, "not_visible");
@@ -950,7 +950,7 @@ async function decidePeerInbound(req, res, id, env) {
         decider = proof.principal;
     }
     const coord = parsePeerInboundId(id);
-    const outcome = coord === undefined ? { kind: "not_found" } : await env.face.decide(peerBoxScope(decider), coord, decision);
+    const outcome = coord === undefined ? { kind: "not_found" } : await env.face.decide(engineScopeOfOwner(decider), coord, decision);
     switch (outcome.kind) {
         case "not_found":
             sendError(res, 404, "not_found.approval", "approval not found");
@@ -1017,7 +1017,7 @@ function redactPendingDisclosures(row) {
 function peerInboundRowsFor(face, principal, operatorOwnerParam) {
     if (operatorOwnerParam !== undefined && operatorOwnerParam !== principal)
         return () => [];
-    const scope = peerBoxScope(principal);
+    const scope = engineScopeOfOwner(principal);
     return () => face.list(scope);
 }
 function projectPendingForWire(row, deployment, agent) {

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

@@ -9,7 +9,7 @@
  *
  * ── 读口:逐字投 core `list()` 行 ─────────────────────────────────────────────────────────────────
  * 读的是**进程内**注册表(`defaultTaskRegistry.list`),访问元组 = 会话自己的 `{ owner: sid, sessionId: sid, scope }`
- * (scope = 会话行属主 `owner ?? "default"`,与 core 注册铸值同源)⇒ 可见集完全由 core 的 `canAccess` 判(fail-closed:
+ * (scope = 会话的引擎租户分区 `sessionTenantScope`,经唯一换算 `engineScopeOfOwner`,与 core 注册铸值同源)⇒ 可见集完全由 core 的 `canAccess` 判(fail-closed:
  * 缺轴即拒;本会话的会话驻留行、task id 即会话 id 的 run 行、本会话发起的 workflow、根会话是本会话的后台 agent)。
  * 键逐个处置(下面的 {@link ROW_KEY_DISPOSITION},core 给行加键 ⇒ 编译红):`task_id` 改名 `id`;`retained` **真才带**
  * (core:缺席 ⇒ 这一行在 `includeRetained:false` 的硬面上会停);`description` 是模型写的描述、缺席时是启动时的命令文本 ——
@@ -40,8 +40,8 @@
  *
  * 🔴 **停止口在无凭据写门内**(`credentialGated: ["POST"]`;车OL F1 = 7.102.0 合并复审 gpt-6 腿 [high]):门的两个合取项它都中
  *   —— ① 授权的唯一输入是 principal 头(属主判 `admitSessionRow` 与 operator 臂 `explicitOperatorOk` 读的都是 `gatedSubject`,
- *   无 service 凭证的部署上它收调用方自报的头);② 不可撤销、爆炸半径跨租户(知道会话 id + 自报它的属主 ⇒ 停掉那个会话的后台
- *   进程,`includeRetained:true` 连显式 retain 的活服务一起停)。于是无 service 凭证且未开 `ALLOW_UNAUTHED_WRITES` 的部署上它与
+ *   没带过门凭据的请求上它收调用方自报的头);② 不可撤销、爆炸半径跨租户(知道会话 id + 自报它的属主 ⇒ 停掉那个会话的后台
+ *   进程,`includeRetained:true` 连显式 retain 的活服务一起停)。于是无 service 凭证且未开 `ALLOW_UNAUTHED_WRITES` 的部署上,不带过门凭据的请求打它与
  *   其余改写门同码同句 503 `auth.service_token_required`(在路由之前,`dispatch.ts` 那一道),同一只会话级收敛函数的另一个调用点
  *   `DELETE /v1/sessions/:id` 早在同一形下被 `isDestructiveSessionWrite` 拒。读口 `GET …/background` 不进:它有属主门兜底、只读、
  *   只列本会话,与 `GET /v1/rules` 同判。已知同族缺口(不在本口单独打补丁):能力位 `exitFaces` 不含「凭据就绪」这一项,见契约

package/dist/http/routes/capabilities.js

@@ -19,7 +19,7 @@ import { sendJson, sendError } from "../send.js";
 import { codeFieldOf } from "../../terminal.js";
 import { engineRefusalAnswerOf } from "../engine-refusal.js";
 import { assertNever } from "../route-ctx.js";
-import { fileHistoryCaptureOf } from "../../file-history-capture.js";
+import { fileHistoryCaptureOf, fileHistoryWired } from "../../file-history-capture.js";
 import { projectMemoryEngineCapability } from "../../memory-posture.js";
 import { projectWriteProtectionCapability } from "../../write-protection.js";
 import { projectStoreCapability, unwiredStorePosture } from "../../store-posture.js";
@@ -27,6 +27,7 @@ import { projectWebSearchCapability } from "../../plugins/web-search.js";
 import { projectExecutionLaneCapability } from "../../capabilities/execution-lane.js";
 import { SETTINGS_CONTRACT_CAPABILITY } from "../../capabilities/settings-contract.js";
 import { judgeSandboxGitPlane, sandboxGitPlanePremisesOf } from "../../sandbox-git-plane.js";
+import { SESSION_KINDS } from "../../session-kind.js";
 import { MCP_ASSERTION_HEADER_SENT, MCP_REQUEST_TRANSPORT_KINDS } from "../../mcp-assertion-header.js";
 import { gateCompositeMembers } from "../../capabilities/composite-members.js";
 import { projectApprovalsStreamLiveCapability } from "../../capabilities/approvals-push.js";
@@ -37,7 +38,7 @@ import { judgeAutoModeArming } from "../../auto-mode-face.js";
 import { coercePermissionModeStrict, PERMISSION_MODE_WORDS, taskHooksHonored } from "../../task-settings.js";
 import { gatedPerson, sendPrincipalRefusal } from "../principal-gate.js";
 import { readAdoptionImportCapability } from "../../adoption/import.js";
-import { headReadOf } from "../../session-incarnation.js";
+import { headReadPresent } from "../../session-incarnation.js";
 import { callerTrust } from "../caller-trust.js";
 import { sessionRulesNamespaceFormsHonored } from "../../session-policy-wire.js";
 function routePairingOf(deps, name, m) {
@@ -84,6 +85,7 @@ export async function handleCapabilities(req, res, match, ctx) {
                 deps.logger?.warn("auto_mode_face_resolver_fault", { fault: autoModeFault });
             const rulesLaneForCaller = facts.ruleLaneForCaller(deps, gatedPerson(req, deps.config)).available;
             const streamApprovalFact = facts.streamApproval(deps);
+            const historyWired = fileHistoryWired(deps.backend);
             sendJson(res, 200, gateCompositeMembers({
                 ...deps.capabilities,
                 ...facts.engineCapabilityBits(),
@@ -207,22 +209,24 @@ export async function handleCapabilities(req, res, match, ctx) {
                 sideQuery: true,
                 agentRoster: facts.agentRoster(deps).available,
                 projects: facts.projectRegistry(deps).available,
+                projectInheritance: facts.projectRegistry(deps).available,
                 retention: retentionAdvertisement(deps.config),
                 peerLane: Boolean(deps.peerDirectory),
                 scenarioSubject: true,
                 sessionList: facts.sessionList(deps).available,
                 sessionSearch: facts.sessionList(deps).available,
+                sessionKinds: facts.sessionKinds(deps).available ? [...SESSION_KINDS] : [],
                 sessionFork: facts.sessionFork(deps).available,
                 sessionDelete: facts.sessionDelete(deps).available,
-                resumeAt: Boolean(deps.resumeAnchorStore && headReadOf(deps.sessionStorage)),
+                resumeAt: deps.backend !== undefined && headReadPresent(deps.sessionStorage),
                 promptSuggestions: true,
                 sessionPolicy: facts.sessionPolicy(deps).available,
                 sessionRulesNamespaceForms: sessionRulesNamespaceFormsHonored(),
-                restoreFiles: Boolean(deps.fileHistoryStore),
-                rewindFilesTo: Boolean(deps.fileHistoryStore && deps.resumeAnchorStore && headReadOf(deps.sessionStorage)),
+                restoreFiles: historyWired,
+                rewindFilesTo: historyWired && headReadPresent(deps.sessionStorage),
                 sessionRewindFiles: facts.sessionRewindFiles(deps).available,
                 sessionRewindFilesPreview: facts.sessionRewindFilesPreview(deps).available,
-                fileHistoryCapture: fileHistoryCaptureOf(deps.fileHistoryStore, deps.config.fileHistoryCapture),
+                fileHistoryCapture: fileHistoryCaptureOf(historyWired, deps.config.fileHistoryCapture),
                 scheduler: facts.hostScheduler(deps.config).available,
                 sessionSync: facts.sessionSync(deps).available,
                 sessionSyncFileHistory: facts.sessionSyncFileHistory(deps).available,

package/dist/http/routes/config-catalog.d.ts

@@ -1,5 +1,5 @@
 /**
- * DESIGN-278 §5 S2([ref])—— `GET /v1/config/catalog`:配置目录自描述端点(operator lane)。
+ * [ref] §5 S2([ref])—— `GET /v1/config/catalog`:配置目录自描述端点(operator lane)。
  *
  * TOB 运维在 web 上要一个**不撒谎**的配置目录:哪个键、什么腿(env/center)、改了何时生效
  * (hot/restart-片名/deploy/inert)、本机实际值 —— 今天这些事实散在 config.ts 数千行与三份文档里,

package/dist/http/routes/fleet.js

@@ -3,7 +3,7 @@ import { FLEET_SNAPSHOT_TERMINAL_MAX_ROWS, isTerminalWorkflowRowStatus, recentTe
 import { taskNotificationFoldKey } from "../../orchestration/workflow-completion-inbox.js";
 import { sendJson, sendError, sseHeaders } from "../send.js";
 import { gatedSubject, sendPrincipalRefusal } from "../principal-gate.js";
-import { routeListFilter } from "../owner-access.js";
+import { routeListFilter, workflowScopeOf } from "../owner-access.js";
 import { assertNever } from "../route-ctx.js";
 import * as facts from "../../capability-facts.js";
 export async function handleFleet(req, res, match, ctx) {
@@ -24,22 +24,24 @@ export async function handleFleet(req, res, match, ctx) {
             const fleetParams = new URLSearchParams(match.search);
             const callerSession = fleetParams.get("session");
             const observeOnly = fleetParams.get("observe") === "1";
-            await streamFleet(req, res, fleet.fleetBus, fleetWide ? null : (principal ?? "default"), callerSession || null, observeOnly ? undefined : deps.workflowCompletionInbox, { store: deps.workflowRunStore, scope: fleetWide ? null : (principal ?? "default"), pullScope: principal ?? "default", ready: deps.fleetRecoveryDone });
+            const workflowScope = workflowScopeOf(principal);
+            const viewer = fleetWide ? null : { rows: principal ?? "default", workflows: workflowScope };
+            await streamFleet(req, res, fleet.fleetBus, viewer, callerSession || null, observeOnly ? undefined : deps.workflowCompletionInbox, { store: deps.workflowRunStore, scope: viewer?.workflows ?? null, pullScope: workflowScope, ready: deps.fleetRecoveryDone });
             return;
         }
         default:
             return assertNever(match.decl.id);
     }
 }
-function streamFleet(req, res, bus, callerScope, callerSession = null, completionInbox, terminal) {
+function streamFleet(req, res, bus, viewer, callerSession = null, completionInbox, terminal) {
     return new Promise((resolve) => {
         sseHeaders(res);
-        res.write(`event: meta\ndata: ${JSON.stringify({ type: "meta", version: 1, scoped: callerScope !== null, sessionScoped: callerSession !== null, ...(callerSession !== null ? { session: callerSession } : {}), bgNotifyFailClosed: true })}\n\n`);
+        res.write(`event: meta\ndata: ${JSON.stringify({ type: "meta", version: 1, scoped: viewer !== null, sessionScoped: callerSession !== null, ...(callerSession !== null ? { session: callerSession } : {}), bgNotifyFailClosed: true })}\n\n`);
         const seenTasks = new Set();
         const seenWf = new Set();
         const sessionOk = (rowSession) => callerSession === null || rowSession === undefined || rowSession === callerSession;
-        const visT = (r) => (callerScope === null || r.scope === callerScope) && sessionOk(r.sessionId);
-        const visW = (r) => (callerScope === null || r.scope === callerScope) && sessionOk(r.sessionId);
+        const visT = (r) => (viewer === null || r.scope === viewer.rows) && sessionOk(r.sessionId);
+        const visW = (r) => (viewer === null || r.scope === viewer.workflows) && sessionOk(r.sessionId);
         const SCOPED_TASK_KEY_DISPOSITION = {
             id: "keep", parentId: "keep", parentToolCallId: "keep", workflowRunId: "keep", status: "keep",
             startedAt: "keep", elapsedMs: "keep", tokens: "keep",
@@ -144,7 +146,7 @@ function streamFleet(req, res, bus, callerScope, callerSession = null, completio
                     break;
                 case "hook_notice": {
                     const hn = frame.notice;
-                    const hScopeOk = callerScope === null || hn.ownerScope === callerScope;
+                    const hScopeOk = viewer === null || hn.ownerScope === viewer.rows;
                     const hSessionOk = callerSession === null || hn.ownerSessionId === callerSession;
                     if (hScopeOk && hSessionOk) {
                         send("hook_notice", { type: "hook_notice", ...hookNoticeWire(hn), ts: frame.ts });
@@ -153,7 +155,7 @@ function streamFleet(req, res, bus, callerScope, callerSession = null, completio
                 }
                 case "bg_notification": {
                     const n = frame.notification;
-                    const scopeOk = callerScope === null || n.ownerScope === callerScope;
+                    const scopeOk = viewer === null || n.ownerScope === viewer.rows;
                     const sessionInjectOk = callerSession === null || n.ownerSessionId === callerSession;
                     if (scopeOk && sessionInjectOk) {
                         const { ownerScope: _os, ownerSessionId: _osid, ...wire } = n;

package/dist/http/routes/mcp-reconnect.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { isParkedRunStatus, isTerminalRunStatus, runProvenElsewhere } from "../../plugins/store-contracts.js";
 import { DeadlineExceeded, MCP_DIAL_DEADLINE_MS, raceDeadline } from "../mcp-dial-deadline.js";
 import { sendJson, sendError } from "../send.js";
-import { admitSessionById, enter } from "../owner-access.js";
+import { admitSessionById, enter, runFactsOf } from "../owner-access.js";
 import { assertNever } from "../route-ctx.js";
 import * as facts from "../../capability-facts.js";
 import { seatText } from "../../trace/exit-seat.js";
@@ -118,7 +118,7 @@ export async function handleMcpReconnect(req, res, match, ctx) {
                     }
                 }
             }
-            const run = activeTaskId === undefined ? undefined : await runStore.getRun(activeTaskId);
+            const run = activeTaskId === undefined ? undefined : await runFactsOf(runStore, activeTaskId);
             if (run && isParkedRunStatus(run.status)) {
                 sendError(res, 409, "steering.not_running", "run is waiting on a pending decision — the MCP re-dial verb needs a live turn; a resumed continuation dials every declared server afresh (the re-dial applies to the current turn only and is not persisted), so resume this run first — a re-dial cannot be queued behind the decision");
                 return;

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

@@ -116,7 +116,7 @@ export declare function buildClearanceRowWire(r: OriginClearanceRow): {
     baseRev: string;
     origin: {
         at: number;
-        cause?: "static" | "unattributed" | "observed" | "derived" | undefined;
+        cause?: "static" | "observed" | "derived" | "unattributed" | undefined;
         taint: "external";
     };
 };

package/dist/http/routes/notify-wake.js

@@ -1,6 +1,6 @@
 import { sendJson, sendError } from "../send.js";
 import { gatedSubject, sendPrincipalRefusal } from "../principal-gate.js";
-import { admitSessionRow, enter, refuse } from "../owner-access.js";
+import { admitSessionById, enter, refuse } from "../owner-access.js";
 import { sendResumeOutcome } from "../route-ctx.js";
 import { assertNever } from "../route-ctx.js";
 import * as facts from "../../capability-facts.js";
@@ -54,8 +54,7 @@ export async function handleNotifyWake(req, res, match, ctx) {
                 sendError(res, 501, "capability.session_ownership_required", "external notify requires the session-ownership face (sessionStorage.headOf)");
                 return;
             }
-            const notifyHead = await owned.sessionStorage.headOf(notifySession);
-            const notifyAdmitted = await admitSessionRow(notifyEntry, res, owned.sessionStorage, notifySession, notifyHead);
+            const notifyAdmitted = await admitSessionById(notifyEntry, res, owned.sessionStorage, notifySession);
             if (notifyAdmitted === undefined)
                 return;
             const payload = {

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

@@ -9,8 +9,9 @@
  *  · **登记簿只由配置中心下发**:settings-schema 的本地读取集不收 `projects` 域 ⇒ 没有中心腿在应用配置的部署上没有登记簿 —— 两口 501
  *    `capability.unavailable`,能力位 `capabilities.projects`(布尔)读同一只事实(`capability-facts.ts` 的 `projectRegistry`)答 `false`;
  *    有登记簿时答 `true`。本面不开写动词(写到哪里由另一张设计定;写面到货时另立一位,本位不改义)。
- *  · **可见性 fail-closed**:身份判在登记簿在场判**之前**(否则「这台有没有登记簿」先于 401 泄出去);fleet 调用方(列表面 `list.read` 读档(`listFilterOf`))看全部;
- *    带验过主体的调用方只看 `registeredBy` 恰是自己的登记;看不见的与不存在的同码同句(404 `not_found.project`,不给存在性预言机)。
+ *  · **可见性 fail-closed**:身份判在登记簿在场判**之前**(否则「这台有没有登记簿」先于 401 泄出去);判与按 id 取只有一只(`project-registry.ts`:
+ *    fleet 调用方(列表面 `list.read` 读档(`listFilterOf`))看全部,带验过主体的调用方只看 `registeredBy` 恰是自己的登记 —— 项目上下文继承与登记簿默认读层种子同读它);
+ *    看不见的与不存在的同码同句(404 `not_found.project`,不给存在性预言机)。
  *
  * 归档:`archivedAt` 在场 = 已归档。列表缺省不列,`?archived=true` 只列已归档的,`?archived=false` 与缺省同;单项读不论归档与否都答(会话行引用它)。
  */
@@ -48,6 +49,7 @@ export declare const PROJECT_ROW_DISPOSITIONS: {
     readonly registeredBy: "forward";
     readonly registeredAt: "forward";
     readonly archivedAt: "forward";
+    readonly contentAttestedAt: "forward";
 };
 /** 项目行的键全集(处置表的键 = wire 上可能出现的每一个键;自铸登记表 `trace/self-minted-wire.ts` 的 `projectRowKey` 按它 `satisfies`)。 */
 export type ProjectRowKey = keyof typeof PROJECT_ROW_DISPOSITIONS;