@sema-agent/server 7.149.0 → 7.150.0

package/dist/http/submit-replay.d.ts

@@ -9,7 +9,8 @@
  *
  * ## 判定(三条,按序;别的一律不放)
  *  · 这次提交自带 taskId 而命中的行**不是**那一条(`Idempotency-Key` 指向别的行)⇒ 冲突;
- *  · 调用方读不到这一行(属主门 = `qualsOf`,「这个调用方读得到这一行 run 吗」的唯一谓词,经属主存取器 `owner-access.ts` 读)⇒ 冲突;
+ *  · 调用方读不到这一行(属主门 = `qualsOf`,「这个调用方读得到这一行 run 吗」的唯一谓词,经属主存取器 `owner-access.ts` 读与判 —— 按钥匙读行也只在那里:
+ *    `readReplayHit`;建行撞唯一键时观察到的行经同一只判 `replayHitOf`)⇒ 冲突;
  *    冲突 ⇒ `409 conflict.run_exists`,体里**不回显**那条行的任何标识(不给跨租户预言机)。先于下一条判:读不到的行不比体。
  *  · 这次提交带 `Idempotency-Key`(`caller.idem` 在场)、那一行绑的**就是这把键**,而它记着的请求体指纹与这次不同 ⇒
  *    `409 conflict.idempotency_payload_mismatch`(同形 `{ error, errorCode }`,不回显键与那一行);**不**回放首发、不新建、那一行不动。
@@ -33,6 +34,7 @@ import type { RunIdemBinding, RunRecord } from "../plugins/store-contracts.js";
 import type { RunStore } from "../plugins/store-backend.js";
 import type { ServiceConfig } from "../config-types.js";
 import type { SubmitOutcome } from "./idempotency.js";
+import { type ReplayHit } from "./owner-access.js";
 import type { Subject } from "../owner-brands.js";
 /** 提交腿的回执形(闭集;穷举 `switch`,加一形不写这里 = 编译红)。 */
 export type SubmitReplayFace = "durable" | "sync";
@@ -56,7 +58,18 @@ export declare function isReplayedOutcome(outcome: SubmitOutcome): boolean;
 /** 一份提交回执是不是 {@link replayOfExistingRun} 铸的**冲突**体(判别位 = 机器码;铸点就在下面,码与它同文件)—— 把回执渲成别的协议形的
  *  调用方(A2A)按它分句,不另抄码。 */
 export declare function isRunExistsConflictBody(body: unknown): boolean;
+/** 进门按一把提交钥匙(`Idempotency-Key` 铸的键 / 调用方自铸的 `body.taskId`)读行作答:没命中 ⇒ `undefined`(这是一次新提交);命中 ⇒ 本文件的唯一回执。 */
+export declare function replayOfKey(key: {
+    readonly idemKey: string;
+} | {
+    readonly taskId: string;
+}, caller: ReplayCaller, face: SubmitReplayFace, deps: {
+    config: ServiceConfig;
+}, runStore: Pick<RunStore, "getRun" | "getRunByIdem" | "bindIdemBodyFingerprint" | "observeRun">): Promise<SubmitOutcome | undefined>;
+/** 建行撞唯一键时观察到的那一行(店的观察臂交回的既有行)作答:与按钥匙读到的同一只判、同一张回执。 */
 export declare function replayOfExistingRun(seen: RunRecord, caller: ReplayCaller, face: SubmitReplayFace, deps: {
     config: ServiceConfig;
-}, runStore: RunStore): Promise<SubmitOutcome>;
+}, runStore: Pick<RunStore, "bindIdemBodyFingerprint" | "observeRun">): Promise<SubmitOutcome>;
+/** 一次命中的回执(判已在属主存取器里落成 {@link ReplayHit}):占用 ⇒ 冲突;读得到 ⇒ 体指纹 → 观察口 → 按提交腿的形答。 */
+export declare function answerReplay(hit: ReplayHit, caller: ReplayCaller, face: SubmitReplayFace, runStore: Pick<RunStore, "bindIdemBodyFingerprint" | "observeRun">): Promise<SubmitOutcome>;
 //# sourceMappingURL=submit-replay.d.ts.map

package/dist/http/submit-replay.js

@@ -1,5 +1,4 @@
-import { runRowAt, seesRunAs } from "./owner-access.js";
-import { claimCallerOf } from "../security.js";
+import { readReplayHit, replayHitOf, runRowAt } from "./owner-access.js";
 import { syncSubmitBodyOfRow } from "./sync-submit-body.js";
 import { refusalBody } from "./refusal-body.js";
 export function replayedOutcome(outcome) {
@@ -15,11 +14,18 @@ export function isReplayedOutcome(outcome) {
 export function isRunExistsConflictBody(body) {
     return typeof body === "object" && body !== null && body.errorCode === "conflict.run_exists";
 }
+export async function replayOfKey(key, caller, face, deps, runStore) {
+    const hit = await readReplayHit(caller.subject, deps.config, runStore, key, caller.clientTaskId);
+    return hit === undefined ? undefined : answerReplay(hit, caller, face, runStore);
+}
 export async function replayOfExistingRun(seen, caller, face, deps, runStore) {
-    const sameRun = caller.clientTaskId === undefined || caller.clientTaskId === seen.taskId;
-    if (!sameRun || !seesRunAs("run.replay", claimCallerOf(caller.subject, deps.config), seen.owner)) {
+    return answerReplay(replayHitOf(caller.subject, deps.config, seen, caller.clientTaskId), caller, face, runStore);
+}
+export async function answerReplay(hit, caller, face, runStore) {
+    if (hit.kind === "occupied") {
         return { status: 409, body: refusalBody({ errorCode: "conflict.run_exists", message: "a run already exists for this submission's taskId or Idempotency-Key" }) };
     }
+    const seen = hit.row;
     if (caller.idem !== undefined) {
         const held = await runStore.bindIdemBodyFingerprint(seen.taskId, caller.idem);
         if (held !== null && held !== caller.idem.bodyFingerprint) {

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

@@ -109,7 +109,8 @@ export interface TaskRequestBody {
      *  `RunnerDeps.loadProjectMemory` —— 项目层、声明的指令文件、它们喂的那几处一并缺席(引擎自己的 git 状态车道、记忆引擎、技能 / hooks / MCP 不受影响)。
      *  原样投给引擎;拼写门与 `fileHistory` 同一张单成员关断词表(`request-value-closure.ts`:别的值 fresh 400 `request.field_invalid`、续跑重放同判),
      *  引擎读到的恒是这一个词;子代随父继承(引擎的夹紧表)。
-     *  本服务自铸的 `wiring_manifest.instructions` 段在这样的腿上缺席(loader 没被调就没有陈述)。能力位 `projectMemory`。 */
+     *  本服务自铸的 `wiring_manifest.instructions` 段在这样的腿上缺席(loader 没被调就没有陈述)。能力位 `projectMemory`。
+     *  7.150.0 起同一个词也关掉这条 run 从项目登记簿继承的项目简报(`project-context.ts`;继承来的 `cwd` 不受它管 —— 位置不是上下文内容)。 */
     projectMemory?: TaskSpec["projectMemory"];
     /** Explicit model selection (CLI `/model` picker + `run --model <ref>`). An INTENT by catalog
      *  name (e.g. "deepseek-pro") — resolveSpec gates it against the SAME allow-list as an inline `@name` mention
@@ -450,7 +451,9 @@ export interface TaskRequestBody {
      *  同一个 id 的两种大小写写法落同一只记忆盘)。多租户 DB 记忆面下它把派生
      *  scope 从 user 盘切到项目盘(`proj:<tenant>/<projectId>`)并以 config.projects[projectId].defaultScopes
      *  作 memory.scopes 种子;单用户部署忽略派生(memoryScopeFor 不变),仅 defaultScopes 种子生效。
-     *  Rides the persisted body onto resume legs(与 memoryWrite 同姿势)。 */
+     *  Rides the persisted body onto resume legs(与 memoryWrite 同姿势)。
+     *  7.150.0 起它(或会话行上声明过的项目)也选这条 run **继承的项目上下文**(`project-context.ts`;能力位 `projectInheritance`):登记对提交者可见且带内容证明 ⇒
+     *  项目简报进系统提示追加折叠的中段、射程内第一条 folder 填缺席的 `cwd`;判一次、随 run 冻结。项目继承来的成员参与的拒,`fields` 以本键为坐标。 */
     projectId?: string;
     /** [#40 / TOC cwd seam, SDK 0.0.36] The TOC client's launch directory — the agent's HOST execution-env workspace
      *  runs HERE (CC-parity: `sema` in a project dir operates on THAT project). An ABSOLUTE host path. 🔒 honored ONLY
@@ -572,7 +575,7 @@ export interface TaskRequestBody {
      *  `transport.env`(stdio)/ `transport.headers`(http)是这台 server 的**件**:server 交给引擎的声明里不带它们,件由部署的对端座在起子进程 / 发请求时按原字节作答
      *  (只对胜出部署同名判的条目登记;件的名与值由引擎在每次发送时判,不合 ⇒ 那一台不连、兄弟照挂)。 */
     mcpServers?: RequestMcpServerSpec[];
-    /** [DESIGN-269 车1] Caller-supplied per-request A2A peers (remote agents this task may call), aligned to
+    /** [[ref] 车1] Caller-supplied per-request A2A peers (remote agents this task may call), aligned to
      *  core `A2aServerSpec`. 🔒 honored on a SINGLE-USER deployment (task-a2a.ts `a2aInjectionHonored`, the same
      *  predicate `capabilities.a2aInjection` advertises) — the requester is the super-admin of their OWN worker,
      *  on ANY execution lane (an A2A call is a plain outbound HTTPS request from the worker, so the lane where

package/dist/leader/endpoint.js

@@ -6,6 +6,7 @@ import { idemKeyOf } from "../http/idempotency.js";
 import { refusalBody } from "../http/refusal-body.js";
 import { LIVENESS_HEARTBEAT_MS } from "../config-invariants.js";
 import { seatText } from "../trace/exit-seat.js";
+import { readVisibleLeaderRow } from "../http/owner-access.js";
 function statusForLeaderResult(result) {
     if (result.conflict)
         return "needs_human";
@@ -62,7 +63,7 @@ export function createLeaderEndpoint(runLeader, opts) {
             ? setInterval(() => {
                 if (ac.signal.aborted)
                     return;
-                void readRow(id).then((row) => {
+                void readDrivenRow(id).then((row) => {
                     if (row === undefined || row.status !== "running")
                         abortLocal(id, "stall_verdict");
                     else if (row.cancelRequested)
@@ -139,13 +140,13 @@ export function createLeaderEndpoint(runLeader, opts) {
             }
         })();
     }
-    function readRow(id) {
+    function readDrivenRow(id) {
         return opts.store.getRun(id);
     }
     const opErr = (e) => seatText("operator-log-error", e instanceof Error ? e.message : String(e));
     async function cancelFlagAfterSettle(id) {
         try {
-            return (await readRow(id))?.cancelRequested === true;
+            return (await readDrivenRow(id))?.cancelRequested === true;
         }
         catch (e) {
             opts.logger?.error?.("leader_cancel_flag_reread_failed", { id, err: opErr(e), effect: "if a cancel landed on this run just before its terminal write, its worker parks are expired only when the cancel is re-sent" });
@@ -305,8 +306,8 @@ export function createLeaderEndpoint(runLeader, opts) {
         if (m) {
             const id = m[1];
             if (opts.store) {
-                const run = await readRow(id);
-                if (!run || !ownerOk(run.owner))
+                const run = await readVisibleLeaderRow(opts.store, id, ownerOk);
+                if (!run)
                     return NOT_FOUND;
                 return getBody(run);
             }
@@ -327,15 +328,15 @@ export function createLeaderEndpoint(runLeader, opts) {
     }
     async function cancel(id, ownerOk) {
         if (opts.store) {
-            const row = await readRow(id);
-            if (!row || !ownerOk(row.owner))
+            const row = await readVisibleLeaderRow(opts.store, id, ownerOk);
+            if (!row)
                 return NOT_FOUND;
             if (row.status === "running") {
                 if (await opts.store.requestCancel(id)) {
                     abortLocal(id, "cancel_verb");
                     return { status: 202, body: { leaderRunId: id, status: "cancelling", cancelRequested: true } };
                 }
-                const now = await readRow(id);
+                const now = await readVisibleLeaderRow(opts.store, id, ownerOk);
                 if (!now)
                     return NOT_FOUND;
                 return answerTerminal(id, now);

package/dist/leg-facts.d.ts

@@ -1,7 +1,7 @@
 /**
- * 一条腿的**部署事实**(执行车道 · run 技能名册 · 受理见证 · 登记的工作目录)—— server 自有的载体,**不搭引擎 spec 的车**。
+ * 一条腿的**部署事实**(执行车道 · run 技能名册 · 受理见证 · 登记的工作目录 · 继承的项目上下文)—— server 自有的载体,**不搭引擎 spec 的车**。
  *
- * 规则:`TaskSpec` 是引擎的类型面,上面只放引擎读的成员。本仓装配器(`boot/resolve-spec.ts` 的 `createResolveSpec`)同时还判出四件
+ * 规则:`TaskSpec` 是引擎的类型面,上面只放引擎读的成员。本仓装配器(`boot/resolve-spec.ts` 的 `createResolveSpec`)同时还判出五件
  * 只有 server 自己读的事实 —— 它们以装配器**自己的输出对象**为键登记在这一张表里(单一铸点 {@link mintLegFacts}),由两只漏斗
  * (受理 `http/admission.ts` 的 `prepareSpec` · 续跑 `http/resume-legs.ts` 的 `resolveResumeSpec`)在拿到装配输出的**同一只对象**时
  * 读一次(唯一读口 {@link legFactsOf},读在 `stampSpecRoot` 复制之前),此后作普通值随 `PreparedTaskSubmission.legFacts` /
@@ -18,6 +18,7 @@
 import type { ScenarioHands } from "./capabilities/hands-lane.js";
 import type { RunSkillEntry } from "./capabilities/skills.js";
 import type { DelegationRootWitness } from "./delegated-session-owner.js";
+import type { ProjectContext } from "./project-context.js";
 /** 一条腿的部署事实(冻结记录)。 */
 export interface LegFacts {
     /** 执行车道:`none` ⇒ 无手孪生 Runner。读者 = 生产选路器。 */
@@ -31,6 +32,11 @@ export interface LegFacts {
      * 读者 = 三只组合入口(同步 / 后台 / 续跑腿的梯子与验证门):经 `compositionLegRoot`(`task-cwd.ts`)交给它们驱动的每一条腿当交活方的工作目录。
      */
     readonly registeredCwd?: string;
+    /**
+     * 这条 run 继承到的项目上下文(`project-context.ts`):新提交腿在装配器头部判出的那一份,续跑腿是从续跑重建输入重放的那一份。缺席 = 没继承。
+     * 读者 = 提交腿写续跑重建输入的那一笔(`submit-ctx.ts` `persistSubmissionCtx` → `CheckpointCtx.projectContext`):判一次、随 run 冻结。
+     */
+    readonly projectContext?: ProjectContext;
 }
 /**
  * 铸事实(**单一属主**:只允许 `createResolveSpec` 的出口调用)。同一只对象被第二次铸 ⇒ 当场抛 —— 两个写者是漂移的成因,

package/dist/leg-facts.js

@@ -7,6 +7,7 @@ export function mintLegFacts(resolved, facts) {
         skills: Object.freeze(facts.skills.map((e) => Object.freeze({ ...e }))),
         sessionWitness: Object.freeze({ ...facts.sessionWitness }),
         ...(facts.registeredCwd !== undefined ? { registeredCwd: facts.registeredCwd } : {}),
+        ...(facts.projectContext !== undefined ? { projectContext: Object.freeze({ ...facts.projectContext }) } : {}),
     }));
     return resolved;
 }

package/dist/mcp-authorization-face.d.ts

@@ -1,14 +1,19 @@
 /**
- * MCP 授权事实(core 7.59.0 `McpAuthorization`:`{ reason, authorizeUrl?, resourceMetadataUrl? }`,与 `errorCode: "unauthorized"` 同行)的**出门投影** ——
- * 本仓三张面(`wiring_manifest.mcp[]` 行、重拨回执的 `status`、`//mcp` 面板的 `servers[]`)同读这一只。
+ * MCP 授权记录(core 7.59.0 `McpAuthorization`:`{ reason, authorizeUrl?, resourceMetadataUrl? }`,与 `errorCode: "unauthorized"` 同在)的**出门投影** ——
+ * 一条记录无论坐在哪个投影载体里,离开本服务只经这一张处置表、这一只投影。五个投影点同读它:状态行投影(`wiring_manifest.mcp[]` 行;账本帧、面板的
+ * `lastLegMcp.mcp[]`、能力面两口读的都是它的产物)、重拨回执的 `status`、会话 MCP 面板的 `servers[]`、通告 `mcp.authorization_required` 的 `detail`
+ * (登记 `NOTICE_DETAIL_RECORDS`,`trace/engine-notice-wire.ts`)、会话历史读面里工具结果卡的 `details.authorization`(登记 `TOOL_CARD_RECORDS`,`trace/tool-card.ts`)。
+ * (工具卡的读者 `trace/tool-card.ts` 是后者的那一只:活面 `tool_end.structured` 上挂着授权记录的自注册卡同读。)记录成员是**结构位**:只经本表出门,
+ * 不过自由文本的脱敏、深扫与截断。会话同步拉取口不是投影:它把存档逐字复制给属主,存档里带不带远端的地址由引擎的写入决定。
  *
- * 只投闭集词 `reason`(`rejected` = 端点答 401 且授权座的重问没给出能过的凭据 / `scope` = 403 `insufficient_scope` / `none` = 授权座答「未授权」):
- * 判据直读引擎的 `MCP_AUTHORIZATION_REASONS`(不抄词表);词出闭集、非串、整只不是对象 ⇒ 整格缺席(最弱断言,不铸词)。
- * 两只地址**不出门**:`authorizeUrl` 只来自部署的授权座,本部署今天没有授权座;`resourceMetadataUrl` 是远端在挑战头里自报的地址,不可信 —— 两只地址的去向
- * (授权座 + 出口座)是授权记录面的设计,不在本投影里放行。用户面的「去授权」由会话通告 `mcp.authorization_required` 承载。
+ * `reason` 是闭集词(`rejected` = 端点答 401 且对端座的重问没给出能过的凭据 / `scope` = 403 `insufficient_scope` / `none` = 对端座答「未授权」):
+ * 判据直读引擎的 `MCP_AUTHORIZATION_REASONS`(不抄词表);词出闭集、非串、整只不是对象 ⇒ 整条记录缺席(最弱断言,不铸词)。
+ * 两只地址今天不出门:`authorizeUrl` 只来自对端座 —— 座在,但今天没有会答需授权的凭据来源(地址的唯一入口与它的判法随那一臂立);
+ * `resourceMetadataUrl` 是远端在挑战头里自报的地址(终态 `strip`:没有消费方需要它 —— 客户端不跑授权发现;摆在「去授权」旁边的远端地址是钓鱼面)。
  */
-import { type McpAuthorizationReason } from "@sema-agent/core";
-/** 授权记录的处置表(三面同读;`core-keyset-guard.ts` 读表 —— 门与投影一个写者):`reason` 认得才出门(闭集词;在场而认不得 ⇒ 丢并计一次),两只地址本面不出现。 */
+import { type McpAuthorization, type McpAuthorizationReason } from "@sema-agent/core";
+import { type FaceOf } from "./trace/projection-table.js";
+/** 授权记录的处置表(五个投影点同读;`core-keyset-guard.ts` 读表 —— 门与投影一个写者):`reason` 认得才出门(闭集词;在场而认不得 ⇒ 丢并计一次),两只地址不出门。 */
 export declare const MCP_AUTHORIZATION_DISPOSITIONS: {
     readonly reason: {
         readonly forward: (w: unknown) => w is McpAuthorizationReason;
@@ -16,12 +21,11 @@ export declare const MCP_AUTHORIZATION_DISPOSITIONS: {
     readonly authorizeUrl: "strip";
     readonly resourceMetadataUrl: "strip";
 };
-/** 处置表一格的放行谓词所窄化到的型(`forward: (w: unknown) => w is T` ⇒ `T`):表放行什么,出门值就是什么型。 */
-type ForwardedAs<F> = F extends (w: unknown) => w is infer T ? T : never;
-/** 本投影的产物 = 表里 `reason` 一格放行后的型。词的型只有表这一个写者,出口不再判第二遍。 */
-export type McpAuthorizationFace = {
-    readonly reason: ForwardedAs<(typeof MCP_AUTHORIZATION_DISPOSITIONS)["reason"]["forward"]>;
-};
+/** 记录的成员名 = 表的键(冻结拷贝;成员集只有表一处写)。平铺载体(通告 `detail`)按它认哪几位是这条记录。 */
+export declare const MCP_AUTHORIZATION_MEMBERS: readonly string[];
+type TableFace = FaceOf<McpAuthorization, typeof MCP_AUTHORIZATION_DISPOSITIONS>;
+/** 本投影的产物 = 表的出门型({@link FaceOf}:表翻一格,型随之变);记录级规则「`reason` 在 ⇔ 记录在」在出口上,所以 `reason` 必在。 */
+export type McpAuthorizationFace = TableFace & Required<Pick<TableFace, "reason">>;
 export declare function projectMcpAuthorization(v: unknown): McpAuthorizationFace | undefined;
 export {};
 //# sourceMappingURL=mcp-authorization-face.d.ts.map

package/dist/mcp-authorization-face.js

@@ -6,10 +6,11 @@ export const MCP_AUTHORIZATION_DISPOSITIONS = {
     authorizeUrl: "strip",
     resourceMetadataUrl: "strip",
 };
+export const MCP_AUTHORIZATION_MEMBERS = Object.freeze(Object.keys(MCP_AUTHORIZATION_DISPOSITIONS));
 export function projectMcpAuthorization(v) {
     if (typeof v !== "object" || v === null || Array.isArray(v))
         return undefined;
-    const { reason } = projectByTable("mcp.authorization", MCP_AUTHORIZATION_DISPOSITIONS, v, undefined);
-    return reason !== undefined ? { reason } : undefined;
+    const face = projectByTable("mcp.authorization", MCP_AUTHORIZATION_DISPOSITIONS, v, undefined);
+    return face.reason === undefined ? undefined : { ...face, reason: face.reason };
 }
 //# sourceMappingURL=mcp-authorization-face.js.map

package/dist/memory-store-refusal.d.ts

@@ -30,7 +30,7 @@
  *     找码;这一半候 core 的结构化码位(登记在案,codex 一审 C3)。
  *
  * ## 不是这一族的形(core 同表「different surface」,本仓**不**自拼码,如实走各自既有臂;今两形 + 一只已退的形)
- *  · journal 重放目标目录成链 ⇒ `ControlPlaneCorruptError`(无 `.code`,KL-1094-b)⇒ 路由 typed 500 `internal.memory_control_plane_corrupt`
+ *  · journal 重放目标目录成链 ⇒ `ControlPlaneCorruptError`(无 `.code`,[ref])⇒ 路由 typed 500 `internal.memory_control_plane_corrupt`
  *    (core 7.44.0 起 scope home 非目录**不再**走这一类 —— 它有了自己的码,见上;`ControlPlaneCorruptError` 只剩真控制面损坏);
  *  · (已不存在的一形)引擎原地写撞硬链(nlink>1):≤ 引擎 7.55.x 是无码文本 `has N names (a hard link) … not written`、走该写点既有的失败车道;
  *    引擎 7.56.0 起那只写给**这个名字**另建一个新文件(原子改名落位,其余名字保留原文件),拒绝与那句文本一并消失 —— 本仓从未读过那句文本,零码;

package/dist/observability/corrupt-read-seat.d.ts

@@ -41,7 +41,7 @@ export declare function createCorruptReadFailOpenSeat(tag: FailOpenTag, leg?: (i
  * 这一座里有安全轴的脸(session-policy),所以每命中一行 warn 保留(降成「每进程一次」是降级,[ref] 的裁定);**在此之上**,认出的脸另记账:
  *  · session-policy 脸 ⇒ R 类 tag(`server.session-policy.corrupt-read-fail-open`)—— 计数逐次 + 探针行 + 一次性 warn。core 7.39.2 起按键读拒;
  *    core 7.41.0 [ref] 起本会话的枚举拒、别的会话的抹除不动它、重绑带走它 —— 但只对**有归属**的坏行(行里的 `__sid`,否则同名高水位标记的 `__sid`);
- *    无从归属的坏行仍按「无规则」(core 已知限制 KL-1299-a 接受:无从归属 ≠ 本会话);座上分不出读法 ⇒ 这一脸每一发都计(含已拒的)。
+ *    无从归属的坏行仍按「无规则」(core 已知限制 [ref] 接受:无从归属 ≠ 本会话);座上分不出读法 ⇒ 这一脸每一发都计(含已拒的)。
  *    抹除扫走无归属坏行那一形 core 是否披露、座上数不数得到,未亲核。放行是 core 的裁定、本仓不包层(源头修复纪律),所以**只记账、不改放行**(R 类:有界放行,计数长期保留);
  *  · 其余脸 ⇒ 不计(见 {@link DurableAbsenceFace})。
  * 记账**先于** warn:记账是总函数,warn 可能抛(core 的 guard 会吞掉那个抛),一次日志故障不许吃掉计数。

package/dist/observability/fail-open.d.ts

@@ -197,7 +197,7 @@ export declare const FAIL_OPEN_TAGS: {
     };
     readonly "server.approvals.queue-row-agent-unreadable": {
         readonly cls: "F";
-        readonly note: "S-3000(`routes/approvals-assistant.ts` 的 `sessionAgentsOf`):运维待批队列(`GET /v1/approvals` 的 `pending[]` 与 `/v1/approvals/stream` 的 `pending` 帧)每一只停驻行带它那只会话在委派树里的位置 `agent`(会话视图的同名键,唯一读口 `session-agent.ts` 的 `readSessionAgent` = 会话店的 `placementOf` 一读)。某一只会话那一读抛(店瞬断 / 超时 / local 后端的会话存档行头读不出)⇒ **这只会话的行**缺 `agent` 键,列表其余照常。放行的最坏后果 = 这一行这一次没有委派归属线索:壳的归属判官认不到它(行照列、人从队列照样决得了 —— 与本键存在之前同形);`agent` 不是授权事实(队列行本就只列调用方 scope 的卡,决断口另有属主门)。不放行的代价是一只读不出的会话打掉整张待批列表(订阅流上每一拍都是读失败)。故 F 类;必须留痕,否则「这一次没读成」与「这不是一只 placed 委派子代」在 wire 上同形。detail = 会话 id 与经出口座的错误句。计数按次(订阅流每一拍各计一次)。";
+        readonly note: "S-3000(`routes/approvals-assistant.ts` 的 `sessionAgentsOf`):运维待批队列(`GET /v1/approvals` 的 `pending[]` 与 `/v1/approvals/stream` 的 `pending` 帧)每一只停驻行带它那只会话在委派树里的位置 `agent`(会话视图的同名键,唯一读口 `http/owner-access.ts` 的 `readSessionAgent` = 会话店的 `placementOf` 一读)。某一只会话那一读抛(店瞬断 / 超时 / local 后端的会话存档行头读不出)⇒ **这只会话的行**缺 `agent` 键,列表其余照常。放行的最坏后果 = 这一行这一次没有委派归属线索:壳的归属判官认不到它(行照列、人从队列照样决得了 —— 与本键存在之前同形);`agent` 不是授权事实(队列行本就只列调用方 scope 的卡,决断口另有属主门)。不放行的代价是一只读不出的会话打掉整张待批列表(订阅流上每一拍都是读失败)。故 F 类;必须留痕,否则「这一次没读成」与「这不是一只 placed 委派子代」在 wire 上同形。detail = 会话 id 与经出口座的错误句。计数按次(订阅流每一拍各计一次)。";
     };
     readonly "server.approvals.durable-row-checkpoint-id-missing": {
         readonly cls: "F";
@@ -569,13 +569,13 @@ export declare const FAIL_OPEN_TAGS: {
         readonly cls: "R";
         readonly ruling: "C-R296";
         readonly bound: "FLEET_LEASE_OUTAGE_MAX_MS";
-        readonly note: "`fleet/serving-lease.ts` 的 `renewOnce`(租约生效时每一次续租;detail = `worker=<w> generation=<g> why=<不可达句 | verdict=unknown>`):中心这一次**没有确认**本实例该不该服务 —— 不可达 / 超时 / 非 2xx / 答复读不成判决,或答 `unknown`(此刻没有本实例的生命周期对象)。按设计**什么都不改**(规则 2 第三臂):到期之前照常 `granted`,过期后 `expired` 照常接单,直到过期满 `FLEET_LEASE_OUTAGE_MAX_MS`(`T_max`)才拒新工作(503 `state.lease_expired`,在飞不动、永不自停)。归 R:方向与上界由裁定写定 —— 实例只在中心权威终止(`denied`)或运维覆盖时被替换,`T_max` 只是引擎自己「失联后最多再接单多久」的准入上界,不是替换依据;没确认不是被拒。放行的最坏后果 = 一只其实已被取代的实例在中心失联期间多服务至多「租约剩余 + `T_max`」(中心的代际下限持久,恢复后第一次续租即拒)。计数长期保留:持续非零 = 中心长时间没确认本实例,去看 detail 的 why(连不上 / 中心不认识这只实例)。";
+        readonly note: "`fleet/serving-lease.ts` 的「没确认」一段(两个调用点一只函数、一行 warn `fleet_serving_lease_unconfirmed`、一只连败计数;detail = `worker=<w> generation=<g> why=<…>`):① `renewOnce`(中心宣告了位之后每一次续租;`why=<不可达句 | HTTP <状态> | verdict=unknown>`)—— 中心这一次**没有确认**本实例该不该服务:不可达 / 超时 / 非 2xx / 答复读不成判决,或答 `unknown`(此刻没有本实例的生命周期对象);② `noteHeartbeat` 的沉默臂(fleet 成员还没听到任何声明的推定期,每一拍心跳;`why=heartbeat:<HTTP <状态> | 请求抛出的那句 | reply-unreadable:<因> | not-sent:<那句>>`,不带中心体片段)—— 成员起步即推定在围栏内,心跳没换来中心的声明。按设计**什么都不改**(规则 2 第三臂):到期之前照常 `granted`,过期后 / 推定期 `expired` 照常接单,直到最后一次授予的到期(没有授予 ⇒ 围栏在本进程生效的时刻,推定 = 本进程起点)满 `FLEET_LEASE_OUTAGE_MAX_MS`(`T_max`)才拒新工作(503 `state.lease_expired`,在飞不动、永不自停)。只在围栏生效时计(中心以不带位的声明解除围栏之后,在飞续租迟到的失败不计)。一段的收尾 = 续租判决(`granted` / `denied`)或中心以不带位的声明解除围栏,一行 `fleet_serving_lease_recovered`(`by: verdict | not-enforced`);宣告本身不是确认。归 R:方向与上界由裁定写定 —— 实例只在中心权威终止(`denied`)或运维覆盖时被替换,`T_max` 只是引擎自己「失联后最多再接单多久」的准入上界,不是替换依据;没确认不是被拒。放行的最坏后果 = 一只其实已被取代的实例在中心失联期间多服务至多「租约剩余 + `T_max`」(中心的代际下限持久,恢复后第一次续租即拒);从起步起一直没听到中心的成员**每个不间断进程**至多服务 `T_max`(钟不跨重启:重启即重计)。计数长期保留:持续非零 = 中心长时间没确认本实例,去看 detail 的 why(连不上 / 令牌被拒 / 中心不认识这只实例 / 答复不是声明)。";
     };
     readonly "server.fleet.serving-lease-capability-absent": {
         readonly cls: "R";
         readonly ruling: "C-R296";
         readonly bound: "FLEET_LEASE_OUTAGE_MAX_MS";
-        readonly note: "`fleet/serving-lease.ts` 的 `noteCenterCapabilities`(fleet 成员每一次中心能力读数;detail = `worker=<w> generation=<g> was=<enabled|none>`):中心答复体读得出、却**没有宣告** `servingLease`(老中心 `{ ok: true }` / 降级中心 / 位撤掉)⇒ 规则 1:租约不生效,`leaseState: none`,零续租、零 503 —— 这只 fleet 成员此刻**不受围栏**。答复体读不出不进这一臂(那是「没有读数」,上一次的位与钟原样,`fleet-client.ts` `capabilityReadingOf`);已被拒的实例不进(拒是黏的,位消失不复活)。归 R:能力门控是契约规则(中心不宣告 = 中心不执行围栏),裁定写定替换只来自中心权威终止或运维覆盖;位只开关围栏、不碰钟 —— 位缺席期间 `T_max` 的钟照走(最后一次授予的到期 / 本进程第一次见到位的时刻),位一回来即按它判,所以位的抖动绕不过 `FLEET_LEASE_OUTAGE_MAX_MS`。放行的最坏后果 = 中心不执行围栏期间,一只被取代的实例照常服务(这一段由中心的选择定界,不由引擎)。计数长期保留:非零 = 这台中心没宣告租约能力。";
+        readonly note: "`fleet/serving-lease.ts` 的 `noteHeartbeat` 读数臂(fleet 成员每一次中心能力声明;detail = `worker=<w> generation=<g> was=<presumed|on|off>`):中心心跳答复里**显式的** `capabilities` 声明对象在、却**没有宣告** `servingLease`(中心关着围栏开关 / 共享令牌 / 降级中心 / 位撤掉)⇒ 规则 1:租约不生效,`leaseState: none`,零续租、零 503 —— 这只 fleet 成员此刻**不受围栏**。推定期的第一条声明就不带位(`was=presumed`)⇒ 推定作废(`expired → none`),钟不起,之后不限时(直到中心第一次宣告,那一拍起钟)。不是声明的答复不进这一臂(体读不出 / 不是对象 / 没有 `capabilities` 键 / 形坏 —— 那是沉默,推定、位与钟原样,`fleet-client.ts` `capabilityReadingOf`);已被拒的实例不进(拒是黏的,位消失不复活)。归 R:能力门控是契约规则(中心声明不执行 = 中心不执行围栏),裁定写定替换只来自中心权威终止或运维覆盖;位只开关围栏、不碰钟 —— 位缺席期间 `T_max` 的钟照走(最后一次授予的到期 / 围栏在本进程第一次生效的时刻),位一回来即按它判,所以位的抖动绕不过 `FLEET_LEASE_OUTAGE_MAX_MS`。放行的最坏后果 = 中心声明不执行围栏期间,一只被取代的实例照常服务(这一段由中心的选择定界,不由引擎)。计数长期保留:非零 = 这台中心没宣告租约能力。";
     };
     readonly "server.workspace-cache.unavailable": {
         readonly cls: "F";
@@ -611,11 +611,11 @@ export declare const FAIL_OPEN_TAGS: {
     };
     readonly "server.fleet.announce-reply-unreadable": {
         readonly cls: "P-DEBT";
-        readonly note: "7.121.0 修复验证轮(`fleet-client.ts` 的公告环,fleet 成员每一拍心跳 2xx 答复;detail = `why=<body|not-an-object|invalid-capabilities> leaseState=<此刻的租约态>`):答复不是能力读数(体读不出 / 不是对象 / `capabilities` 键在场而形坏 —— settings-schema 9.0.0 `readCapabilityReading` 的 `unreadable`,外加本仓的 `body`)⇒ 当作没有这一拍答复,租约的状态与钟原样。**一律**计数(不论租约生效与否):租约还没生效(`leaseState=none`)时这只成员**一直不受围栏**,而修前这一形零计数(中心每拍答 `<html>` ⇒ 成员恒 none、零痕迹);租约已生效时计数说明中心的答复在坏、围栏靠的是上一次读数。归 P 类:围栏轴;归 DEBT:本进程判不出中心为什么答坏体,收口条件 = 中心契约 / 监控(中心侧对心跳答复形的执法)落地。每段连拍另有一行 warn `fleet_announce_reply_unreadable`(带 `why`)。";
+        readonly note: "7.121.0 修复验证轮(`fleet-client.ts` 的公告环,fleet 成员每一拍心跳 2xx 答复;detail = `why=<body|not-an-object|capabilities-absent|invalid-capabilities> leaseState=<此刻的租约态>`):答复不是能力声明(体读不出 / 不是对象 / 没有 `capabilities` 键 / `capabilities` 键在场而形坏 —— settings-schema `readCapabilityReading` 的 `unreadable`〔没有键那一因自 25.0.0 起〕,外加本仓的 `body`)⇒ 这一拍是沉默(交租约客户端 `silent`,`why=reply-unreadable:<因>`),推定、租约的状态与钟原样。**一律**计数(不论租约此刻什么态):推定期(成员还没听到任何声明,`leaseState=expired`)的坏答复同时是一拍「没确认」(另计 `server.fleet.serving-lease-unconfirmed`),推定与钟照走、满 `T_max` 拒新工作;租约已生效时计数说明中心的答复在坏、围栏靠的是上一次声明。归 P 类:围栏轴;归 DEBT:本进程判不出中心为什么答坏体,收口条件 = 中心契约 / 监控(中心侧对心跳答复形的执法)落地。每段连拍另有一行 warn `fleet_announce_reply_unreadable`(带 `why`)。";
     };
     readonly "server.fleet.denied-marker-unpersisted": {
         readonly cls: "P-DEBT";
-        readonly note: "7.121.0(`fleet/serving-lease.ts` 的 `enterDenied`,中心以正面证据拒了本实例的服务租约那一拍;detail = `worker=<w> generation=<g>`):拒要落成数据根下一只文件(重启后起步即排空),而这一次**没落下** —— 没有数据根,或写失败(盘满 / 只读挂载 / 目录不在)。本进程照样被拒、照样当拍排空、到期自停;放行的是**重启之后**:同代际重启的实例不记得被拒,在第一次续租得到答复之前会接新工作(中心宣告了能力位时,第一次续租就再被拒一次 —— 中心的代际下限是持久的;中心那时不可达则一直接单到过期满 `FLEET_LEASE_OUTAGE_MAX_MS`)。归 P 类:这是围栏的记忆;归 DEBT:进程内无法把「记不住」变成 fail-closed(起步不接单直到第一次答复,是对租约不可达容忍规则的改动,另案)。denied 行的 `sticky` 同拍说 `process-only`,不声称跨重启记得。计数非零 = 这台机器的数据根写不进,或部署没有数据根。";
+        readonly note: "7.121.0(`fleet/serving-lease.ts` 的 `enterDenied`,中心以正面证据拒了本实例的服务租约那一拍;detail = `worker=<w> generation=<g>`):拒要落成数据根下一只文件(重启后起步即排空),而这一次**没落下** —— 没有数据根,或写失败(盘满 / 只读挂载 / 目录不在)。本进程照样被拒、照样当拍排空、到期自停;放行的是**重启之后**:同代际重启的实例不记得被拒,在第一次续租得到答复之前会接新工作(中心宣告了能力位时,第一次续租就再被拒一次 —— 中心的代际下限是持久的;中心那时不可达 / 心跳一直不通则按推定围栏接单到本进程起点满 `FLEET_LEASE_OUTAGE_MAX_MS`,每个进程各一段;重启后第一条声明就不带位 ⇒ 中心的话,不限时)。归 P 类:这是围栏的记忆;归 DEBT:进程内无法把「记不住」变成 fail-closed(「起步首次答复之前零容忍」形已否决:中心宕几秒 + 一次重启就停数据面),收口条件 = 契约给出持久拒位的公告位(心跳 / `/health` 上说「这一次拒只在本进程」,中心据此对该实例下一次续租照拒、并能看见它)。denied 行的 `sticky` 同拍说 `process-only`,不声称跨重启记得。计数非零 = 这台机器的数据根写不进,或部署没有数据根。";
     };
     readonly "server.sql.tidb-row-cap-unread": {
         readonly cls: "F";

package/dist/observability/fail-open.js

@@ -178,7 +178,7 @@ export const FAIL_OPEN_TAGS = {
     },
     "server.approvals.queue-row-agent-unreadable": {
         cls: "F",
-        note: "S-3000(`routes/approvals-assistant.ts` 的 `sessionAgentsOf`):运维待批队列(`GET /v1/approvals` 的 `pending[]` 与 `/v1/approvals/stream` 的 `pending` 帧)每一只停驻行带它那只会话在委派树里的位置 `agent`(会话视图的同名键,唯一读口 `session-agent.ts` 的 `readSessionAgent` = 会话店的 `placementOf` 一读)。某一只会话那一读抛(店瞬断 / 超时 / local 后端的会话存档行头读不出)⇒ **这只会话的行**缺 `agent` 键,列表其余照常。放行的最坏后果 = 这一行这一次没有委派归属线索:壳的归属判官认不到它(行照列、人从队列照样决得了 —— 与本键存在之前同形);`agent` 不是授权事实(队列行本就只列调用方 scope 的卡,决断口另有属主门)。不放行的代价是一只读不出的会话打掉整张待批列表(订阅流上每一拍都是读失败)。故 F 类;必须留痕,否则「这一次没读成」与「这不是一只 placed 委派子代」在 wire 上同形。detail = 会话 id 与经出口座的错误句。计数按次(订阅流每一拍各计一次)。",
+        note: "S-3000(`routes/approvals-assistant.ts` 的 `sessionAgentsOf`):运维待批队列(`GET /v1/approvals` 的 `pending[]` 与 `/v1/approvals/stream` 的 `pending` 帧)每一只停驻行带它那只会话在委派树里的位置 `agent`(会话视图的同名键,唯一读口 `http/owner-access.ts` 的 `readSessionAgent` = 会话店的 `placementOf` 一读)。某一只会话那一读抛(店瞬断 / 超时 / local 后端的会话存档行头读不出)⇒ **这只会话的行**缺 `agent` 键,列表其余照常。放行的最坏后果 = 这一行这一次没有委派归属线索:壳的归属判官认不到它(行照列、人从队列照样决得了 —— 与本键存在之前同形);`agent` 不是授权事实(队列行本就只列调用方 scope 的卡,决断口另有属主门)。不放行的代价是一只读不出的会话打掉整张待批列表(订阅流上每一拍都是读失败)。故 F 类;必须留痕,否则「这一次没读成」与「这不是一只 placed 委派子代」在 wire 上同形。detail = 会话 id 与经出口座的错误句。计数按次(订阅流每一拍各计一次)。",
     },
     "server.approvals.durable-row-checkpoint-id-missing": {
         cls: "F",
@@ -520,13 +520,13 @@ export const FAIL_OPEN_TAGS = {
         cls: "R",
         ruling: "C-R296",
         bound: "FLEET_LEASE_OUTAGE_MAX_MS",
-        note: "`fleet/serving-lease.ts` 的 `renewOnce`(租约生效时每一次续租;detail = `worker=<w> generation=<g> why=<不可达句 | verdict=unknown>`):中心这一次**没有确认**本实例该不该服务 —— 不可达 / 超时 / 非 2xx / 答复读不成判决,或答 `unknown`(此刻没有本实例的生命周期对象)。按设计**什么都不改**(规则 2 第三臂):到期之前照常 `granted`,过期后 `expired` 照常接单,直到过期满 `FLEET_LEASE_OUTAGE_MAX_MS`(`T_max`)才拒新工作(503 `state.lease_expired`,在飞不动、永不自停)。归 R:方向与上界由裁定写定 —— 实例只在中心权威终止(`denied`)或运维覆盖时被替换,`T_max` 只是引擎自己「失联后最多再接单多久」的准入上界,不是替换依据;没确认不是被拒。放行的最坏后果 = 一只其实已被取代的实例在中心失联期间多服务至多「租约剩余 + `T_max`」(中心的代际下限持久,恢复后第一次续租即拒)。计数长期保留:持续非零 = 中心长时间没确认本实例,去看 detail 的 why(连不上 / 中心不认识这只实例)。",
+        note: "`fleet/serving-lease.ts` 的「没确认」一段(两个调用点一只函数、一行 warn `fleet_serving_lease_unconfirmed`、一只连败计数;detail = `worker=<w> generation=<g> why=<…>`):① `renewOnce`(中心宣告了位之后每一次续租;`why=<不可达句 | HTTP <状态> | verdict=unknown>`)—— 中心这一次**没有确认**本实例该不该服务:不可达 / 超时 / 非 2xx / 答复读不成判决,或答 `unknown`(此刻没有本实例的生命周期对象);② `noteHeartbeat` 的沉默臂(fleet 成员还没听到任何声明的推定期,每一拍心跳;`why=heartbeat:<HTTP <状态> | 请求抛出的那句 | reply-unreadable:<因> | not-sent:<那句>>`,不带中心体片段)—— 成员起步即推定在围栏内,心跳没换来中心的声明。按设计**什么都不改**(规则 2 第三臂):到期之前照常 `granted`,过期后 / 推定期 `expired` 照常接单,直到最后一次授予的到期(没有授予 ⇒ 围栏在本进程生效的时刻,推定 = 本进程起点)满 `FLEET_LEASE_OUTAGE_MAX_MS`(`T_max`)才拒新工作(503 `state.lease_expired`,在飞不动、永不自停)。只在围栏生效时计(中心以不带位的声明解除围栏之后,在飞续租迟到的失败不计)。一段的收尾 = 续租判决(`granted` / `denied`)或中心以不带位的声明解除围栏,一行 `fleet_serving_lease_recovered`(`by: verdict | not-enforced`);宣告本身不是确认。归 R:方向与上界由裁定写定 —— 实例只在中心权威终止(`denied`)或运维覆盖时被替换,`T_max` 只是引擎自己「失联后最多再接单多久」的准入上界,不是替换依据;没确认不是被拒。放行的最坏后果 = 一只其实已被取代的实例在中心失联期间多服务至多「租约剩余 + `T_max`」(中心的代际下限持久,恢复后第一次续租即拒);从起步起一直没听到中心的成员**每个不间断进程**至多服务 `T_max`(钟不跨重启:重启即重计)。计数长期保留:持续非零 = 中心长时间没确认本实例,去看 detail 的 why(连不上 / 令牌被拒 / 中心不认识这只实例 / 答复不是声明)。",
     },
     "server.fleet.serving-lease-capability-absent": {
         cls: "R",
         ruling: "C-R296",
         bound: "FLEET_LEASE_OUTAGE_MAX_MS",
-        note: "`fleet/serving-lease.ts` 的 `noteCenterCapabilities`(fleet 成员每一次中心能力读数;detail = `worker=<w> generation=<g> was=<enabled|none>`):中心答复体读得出、却**没有宣告** `servingLease`(老中心 `{ ok: true }` / 降级中心 / 位撤掉)⇒ 规则 1:租约不生效,`leaseState: none`,零续租、零 503 —— 这只 fleet 成员此刻**不受围栏**。答复体读不出不进这一臂(那是「没有读数」,上一次的位与钟原样,`fleet-client.ts` `capabilityReadingOf`);已被拒的实例不进(拒是黏的,位消失不复活)。归 R:能力门控是契约规则(中心不宣告 = 中心不执行围栏),裁定写定替换只来自中心权威终止或运维覆盖;位只开关围栏、不碰钟 —— 位缺席期间 `T_max` 的钟照走(最后一次授予的到期 / 本进程第一次见到位的时刻),位一回来即按它判,所以位的抖动绕不过 `FLEET_LEASE_OUTAGE_MAX_MS`。放行的最坏后果 = 中心不执行围栏期间,一只被取代的实例照常服务(这一段由中心的选择定界,不由引擎)。计数长期保留:非零 = 这台中心没宣告租约能力。",
+        note: "`fleet/serving-lease.ts` 的 `noteHeartbeat` 读数臂(fleet 成员每一次中心能力声明;detail = `worker=<w> generation=<g> was=<presumed|on|off>`):中心心跳答复里**显式的** `capabilities` 声明对象在、却**没有宣告** `servingLease`(中心关着围栏开关 / 共享令牌 / 降级中心 / 位撤掉)⇒ 规则 1:租约不生效,`leaseState: none`,零续租、零 503 —— 这只 fleet 成员此刻**不受围栏**。推定期的第一条声明就不带位(`was=presumed`)⇒ 推定作废(`expired → none`),钟不起,之后不限时(直到中心第一次宣告,那一拍起钟)。不是声明的答复不进这一臂(体读不出 / 不是对象 / 没有 `capabilities` 键 / 形坏 —— 那是沉默,推定、位与钟原样,`fleet-client.ts` `capabilityReadingOf`);已被拒的实例不进(拒是黏的,位消失不复活)。归 R:能力门控是契约规则(中心声明不执行 = 中心不执行围栏),裁定写定替换只来自中心权威终止或运维覆盖;位只开关围栏、不碰钟 —— 位缺席期间 `T_max` 的钟照走(最后一次授予的到期 / 围栏在本进程第一次生效的时刻),位一回来即按它判,所以位的抖动绕不过 `FLEET_LEASE_OUTAGE_MAX_MS`。放行的最坏后果 = 中心声明不执行围栏期间,一只被取代的实例照常服务(这一段由中心的选择定界,不由引擎)。计数长期保留:非零 = 这台中心没宣告租约能力。",
     },
     "server.workspace-cache.unavailable": {
         cls: "F",
@@ -562,11 +562,11 @@ export const FAIL_OPEN_TAGS = {
     },
     "server.fleet.announce-reply-unreadable": {
         cls: "P-DEBT",
-        note: "7.121.0 修复验证轮(`fleet-client.ts` 的公告环,fleet 成员每一拍心跳 2xx 答复;detail = `why=<body|not-an-object|invalid-capabilities> leaseState=<此刻的租约态>`):答复不是能力读数(体读不出 / 不是对象 / `capabilities` 键在场而形坏 —— settings-schema 9.0.0 `readCapabilityReading` 的 `unreadable`,外加本仓的 `body`)⇒ 当作没有这一拍答复,租约的状态与钟原样。**一律**计数(不论租约生效与否):租约还没生效(`leaseState=none`)时这只成员**一直不受围栏**,而修前这一形零计数(中心每拍答 `<html>` ⇒ 成员恒 none、零痕迹);租约已生效时计数说明中心的答复在坏、围栏靠的是上一次读数。归 P 类:围栏轴;归 DEBT:本进程判不出中心为什么答坏体,收口条件 = 中心契约 / 监控(中心侧对心跳答复形的执法)落地。每段连拍另有一行 warn `fleet_announce_reply_unreadable`(带 `why`)。",
+        note: "7.121.0 修复验证轮(`fleet-client.ts` 的公告环,fleet 成员每一拍心跳 2xx 答复;detail = `why=<body|not-an-object|capabilities-absent|invalid-capabilities> leaseState=<此刻的租约态>`):答复不是能力声明(体读不出 / 不是对象 / 没有 `capabilities` 键 / `capabilities` 键在场而形坏 —— settings-schema `readCapabilityReading` 的 `unreadable`〔没有键那一因自 25.0.0 起〕,外加本仓的 `body`)⇒ 这一拍是沉默(交租约客户端 `silent`,`why=reply-unreadable:<因>`),推定、租约的状态与钟原样。**一律**计数(不论租约此刻什么态):推定期(成员还没听到任何声明,`leaseState=expired`)的坏答复同时是一拍「没确认」(另计 `server.fleet.serving-lease-unconfirmed`),推定与钟照走、满 `T_max` 拒新工作;租约已生效时计数说明中心的答复在坏、围栏靠的是上一次声明。归 P 类:围栏轴;归 DEBT:本进程判不出中心为什么答坏体,收口条件 = 中心契约 / 监控(中心侧对心跳答复形的执法)落地。每段连拍另有一行 warn `fleet_announce_reply_unreadable`(带 `why`)。",
     },
     "server.fleet.denied-marker-unpersisted": {
         cls: "P-DEBT",
-        note: "7.121.0(`fleet/serving-lease.ts` 的 `enterDenied`,中心以正面证据拒了本实例的服务租约那一拍;detail = `worker=<w> generation=<g>`):拒要落成数据根下一只文件(重启后起步即排空),而这一次**没落下** —— 没有数据根,或写失败(盘满 / 只读挂载 / 目录不在)。本进程照样被拒、照样当拍排空、到期自停;放行的是**重启之后**:同代际重启的实例不记得被拒,在第一次续租得到答复之前会接新工作(中心宣告了能力位时,第一次续租就再被拒一次 —— 中心的代际下限是持久的;中心那时不可达则一直接单到过期满 `FLEET_LEASE_OUTAGE_MAX_MS`)。归 P 类:这是围栏的记忆;归 DEBT:进程内无法把「记不住」变成 fail-closed(起步不接单直到第一次答复,是对租约不可达容忍规则的改动,另案)。denied 行的 `sticky` 同拍说 `process-only`,不声称跨重启记得。计数非零 = 这台机器的数据根写不进,或部署没有数据根。",
+        note: "7.121.0(`fleet/serving-lease.ts` 的 `enterDenied`,中心以正面证据拒了本实例的服务租约那一拍;detail = `worker=<w> generation=<g>`):拒要落成数据根下一只文件(重启后起步即排空),而这一次**没落下** —— 没有数据根,或写失败(盘满 / 只读挂载 / 目录不在)。本进程照样被拒、照样当拍排空、到期自停;放行的是**重启之后**:同代际重启的实例不记得被拒,在第一次续租得到答复之前会接新工作(中心宣告了能力位时,第一次续租就再被拒一次 —— 中心的代际下限是持久的;中心那时不可达 / 心跳一直不通则按推定围栏接单到本进程起点满 `FLEET_LEASE_OUTAGE_MAX_MS`,每个进程各一段;重启后第一条声明就不带位 ⇒ 中心的话,不限时)。归 P 类:这是围栏的记忆;归 DEBT:进程内无法把「记不住」变成 fail-closed(「起步首次答复之前零容忍」形已否决:中心宕几秒 + 一次重启就停数据面),收口条件 = 契约给出持久拒位的公告位(心跳 / `/health` 上说「这一次拒只在本进程」,中心据此对该实例下一次续租照拒、并能看见它)。denied 行的 `sticky` 同拍说 `process-only`,不声称跨重启记得。计数非零 = 这台机器的数据根写不进,或部署没有数据根。",
     },
     "server.sql.tidb-row-cap-unread": {
         cls: "F",

package/dist/observability/logger.d.ts

@@ -1,4 +1,11 @@
 export type LogLevel = "debug" | "info" | "warn" | "error";
+/**
+ * **启动协议行**(闭集):起本进程的那一方(壳 / 嵌入宿主 / 测试夹具)从 stdout 读这几行起步 —— `listening` 带内核分给本进程的口(`port`)与
+ * 实绑地址(`boundAddress`),读者拿它们找到并认出自己起的这只引擎。它们是协议,不是诊断:**在不在不随 `LOG_LEVEL`**(档位只滤诊断行;
+ * 档位调高而协议行跟着消失 ⇒ 读者要么拒起、要么各自替部署把档位压回 info,同一个事实多出几份读法)。除此之外与任何一行同路:同一只出口座
+ * (脱敏)、同一条流(按行上的 `level` 分流)、行上的 `level` 照写 —— 按 `level` 字段筛日志的管道照旧筛得掉它。
+ */
+export declare const STARTUP_PROTOCOL_EVENTS: readonly ["listening"];
 export interface Logger {
     debug(msg: string, fields?: Record<string, unknown>): void;
     info(msg: string, fields?: Record<string, unknown>): void;

package/dist/observability/logger.js

@@ -3,6 +3,8 @@ import { OVERSIZED_REDACTION_PLACEHOLDER, seatText } from "../trace/exit-seat.js
 import { errorKindOf } from "./err-text.js";
 import { buildFailOpenAnchor, installFailOpenAnnounceExit } from "./fail-open.js";
 const ORDER = { debug: 0, info: 1, warn: 2, error: 3 };
+export const STARTUP_PROTOCOL_EVENTS = ["listening"];
+const STARTUP_PROTOCOL = new Set(STARTUP_PROTOCOL_EVENTS);
 const LOG_LINE_WITHHELD = "log_line_withheld";
 const SECRET_SCREEN_FAILED = "secret_screen_failed";
 const UNFORMATTABLE = "unformattable";
@@ -61,7 +63,7 @@ const diagnosticStream = (stream) => (stdoutReservedForAnswer ? "stderr" : strea
 export function createLogger(minLevel = "info") {
     swallowStdioErrors();
     const emit = (level, msg, fields) => {
-        if (ORDER[level] < ORDER[minLevel])
+        if (ORDER[level] < ORDER[minLevel] && !STARTUP_PROTOCOL.has(msg))
             return;
         const ts = new Date().toISOString();
         const line = serializeEntry({ ts, level, msg }, fields);

package/dist/observability/run-terminal.d.ts

@@ -132,7 +132,7 @@ export declare function redactModelText(raw: string, before?: string): string;
  * 它进引擎之前已**准入一次**:三只 brain 在建调用的那一行(`brain/tool-call-id.js` 的 `admitToolCallId`)—— 缺席 ⇒ 车道兜底铸;
  * 在形(可见 ASCII 1–128 且不含 `~`)⇒ 原样;越界 ⇒ 单射折叠成引擎 id(`<前 32 码元,越界字符记 `-`>~<sha256 前 32 hex>`),原字节只挂在
  * 转录的 `ToolCall.wireId` 上、只回给 provider。⇒ 一方 brain 在 7.107.0 起新铸的调用,到达本仓任何一张脸的 `toolCallId` 恒在形。
- * 残余两条([ref],如实):① ≤7.106.0 写下的存量行(待批 park 行 `boundCallId` / 检查点 `pendingAction.toolCallId` / 转录)是服务商原串逐字 —— 新版不对存量行二次准入(e2e G4 钉);② 宿主自己的 `Brain`(不经三只一方 adapter)铸的 id 不准入(core KL-1207-a;本仓生产装配的 brain 恒是 `createBrain` 的一方 adapter 外套委托装饰,这一形只经嵌入 / 测试注入的 brain 到达)。两条残余里的 id 仍是跨面 join 键、每张脸同值,只是形状不保证(本闸照旧不动它们:动一张脸 = join 断)。
+ * 残余两条([ref],如实):① ≤7.106.0 写下的存量行(待批 park 行 `boundCallId` / 检查点 `pendingAction.toolCallId` / 转录)是服务商原串逐字 —— 新版不对存量行二次准入(e2e G4 钉);② 宿主自己的 `Brain`(不经三只一方 adapter)铸的 id 不准入(core [ref];本仓生产装配的 brain 恒是 `createBrain` 的一方 adapter 外套委托装饰,这一形只经嵌入 / 测试注入的 brain 到达)。两条残余里的 id 仍是跨面 join 键、每张脸同值,只是形状不保证(本闸照旧不动它们:动一张脸 = join 断)。
  *
  * 🔴 **本闸只施加在「这个值出现的每一张脸都被覆盖到」的回声上**(codex r1 F1,实测成立的回归后改判):工具调用 id 是
  * **跨面 join 键** —— 同一枚 id 同时逐字出现在 `tool_start` / `tool_end` / 审批卡等逐帧面上。只在结果面动它 ⇒ 结果面与逐帧面

package/dist/owner-faces.d.ts

@@ -112,9 +112,10 @@ export type FaceDoor = "P401" | "I401" | "I401r" | "none";
  *  · `deleted_false` —— 200 `{deleted:false}`(删除口幂等形:没删到东西);
  *  · `run_exists` —— 409 `conflict.run_exists`(提交重放:这把键 / 这只 taskId 已被占用);
  *  · `attach_absent` —— 404 `resume.session_not_found`「requireExistingSession: session does not exist …」(提交挂接:认领面没有「没有就建」可镜像,占用 = 不存在那一体);
+ *  · `workflow_missing` —— 404 `not_found.workflow` "workflow not found"(工作流按 id 四口;没有 / 看不见 / 会话断言不符同体);
  *  · `omit` —— 本模块不下发:调用点把「看不见」当「没有」走它自己的缺席路径(协议口的 RpcError / leader 404 / 嵌套可选字段省略)。
  */
-export type FaceProjection = "run_missing" | "task_missing" | "decision_missing" | "session_missing" | "exemption_missing" | "deleted_false" | "run_exists" | "attach_absent" | "omit";
+export type FaceProjection = "run_missing" | "task_missing" | "decision_missing" | "session_missing" | "exemption_missing" | "deleted_false" | "workflow_missing" | "run_exists" | "attach_absent" | "omit";
 /** 属主读不出(会话店交出具名拒「属主读不出」)时本口怎么读:`fold` = 读作没有这一行(同一只投影,原故障进运维日志一行);`raise` = 原故障照常上抛。 */
 export type FaceUnreadable = "fold" | "raise";
 /**
@@ -126,8 +127,8 @@ export type FaceUnreadable = "fold" | "raise";
  */
 export type FacePlacementUnreadable = "raise" | "ordinary";
 export interface Face {
-    /** 行的种类:run / 会话行(路由经 `http/owner-access.ts` 的门判)、停驻行 scope 列(`scope`)、ask 行 / 活登记 / 活问(`ask`)、收件条目(`inbox`)、列表面(`list`)。 */
-    readonly resource: "run" | "session" | "scope" | "ask" | "inbox" | "list";
+    /** 行的种类:run / 会话行(路由经 `http/owner-access.ts` 的门判)、工作流行(`workflow`:属主 = 引擎写下的 `scope` 列)、停驻行 scope 列(`scope`)、ask 行 / 活登记 / 活问(`ask`)、收件条目(`inbox`)、列表面(`list`)。 */
+    readonly resource: "run" | "session" | "workflow" | "scope" | "ask" | "inbox" | "list";
     /** 行资格里本口放哪几格。 */
     readonly grants: readonly RowQual[];
     /** fleet 资格里本口放哪几格(D1 列,见模块头注)。 */
@@ -385,6 +386,26 @@ export declare const FACES: {
         readonly unreadable: "raise";
         readonly placementUnreadable: "ordinary";
     };
+    readonly "workflow.read": {
+        readonly resource: "workflow";
+        readonly grants: readonly ["owner"];
+        readonly fleet: readonly [];
+        readonly operator: false;
+        readonly door: "P401";
+        readonly projection: "workflow_missing";
+        readonly unreadable: "raise";
+        readonly placementUnreadable: "raise";
+    };
+    readonly "workflow.steer": {
+        readonly resource: "workflow";
+        readonly grants: readonly ["owner"];
+        readonly fleet: readonly [];
+        readonly operator: false;
+        readonly door: "P401";
+        readonly projection: "workflow_missing";
+        readonly unreadable: "raise";
+        readonly placementUnreadable: "raise";
+    };
     readonly "scope.decide": {
         readonly resource: "scope";
         readonly grants: readonly ["owner", "open"];
@@ -456,6 +477,9 @@ export type SessionFaceId = {
 export type ListFaceId = {
     [F in FaceId]: (typeof FACES)[F]["resource"] extends "list" ? F : never;
 }[FaceId];
+export type WorkflowFaceId = {
+    [F in FaceId]: (typeof FACES)[F]["resource"] extends "workflow" ? F : never;
+}[FaceId];
 /**
  * **只看「验过的主体 + 运维位」的面**(派生型:行资格 ⊆ {owner, open} ∧ fleet 列空):这几只面的可见性与部署形、fleet 事实都无关 ——
  * 面表里给其中一行加上 `j4` / 任一 fleet 格,它就掉出本型,{@link keyAdmits} 的调用点编译红(那时它要一只完整的 {@link Caller})。

package/dist/owner-faces.js

@@ -74,6 +74,8 @@ export const FACES = {
     "session.policy": { resource: "session", grants: ["owner", "open", "anon_tree"], fleet: ["dev_open"], operator: true, door: "I401r", projection: "session_missing", unreadable: "raise", placementUnreadable: "ordinary" },
     "session.notify": { resource: "session", grants: ["owner", "open", "anon_tree"], fleet: ["dev_open"], operator: true, door: "P401", projection: "session_missing", unreadable: "raise", placementUnreadable: "raise" },
     "session.attach": { resource: "session", grants: ["owner", "open"], fleet: [], operator: false, door: "none", projection: "attach_absent", unreadable: "raise", placementUnreadable: "ordinary" },
+    "workflow.read": { resource: "workflow", grants: ["owner"], fleet: [], operator: false, door: "P401", projection: "workflow_missing", unreadable: "raise", placementUnreadable: "raise" },
+    "workflow.steer": { resource: "workflow", grants: ["owner"], fleet: [], operator: false, door: "P401", projection: "workflow_missing", unreadable: "raise", placementUnreadable: "raise" },
     "scope.decide": { resource: "scope", grants: ["owner", "open"], fleet: [], operator: true, door: "none", projection: "omit", unreadable: "raise", placementUnreadable: "raise" },
     "ask.decide": { resource: "ask", grants: ["owner", "open"], fleet: [], operator: true, door: "none", projection: "omit", unreadable: "raise", placementUnreadable: "raise" },
     "ask.answer": { resource: "ask", grants: ["owner", "open"], fleet: [], operator: false, door: "none", projection: "omit", unreadable: "raise", placementUnreadable: "raise" },

package/dist/peer-seat.d.ts

@@ -66,7 +66,7 @@ export type PeerBinding = {
     readonly url: string;
     readonly cardUrl?: string;
 };
-/** Why the seat refused a question. Closed: a new word is a new arm of `answer`'s switch. */
+/** Why the seat refused a question. Closed: a word belongs to a row of the seat's per-kind table (or to the handle row's own two refusals). */
 export type PeerSeatRefusalReason = "handle_not_held" | "binding_mismatch" | "kind_env" | "kind_vault" | "kind_assertion" | "kind_unknown";
 /**
  * The desk's own failures, each loud: