@sema-agent/server 7.149.0 → 7.151.0

package/dist/lane-home-probe.d.ts

@@ -23,6 +23,7 @@
  * 读不了家目录的车道(device:设备协议没有读数)不持座 —— 声明就是座,起服披露「来自声明、未实测」(`execution-lane-caps.ts` `buildLaneHomeBootNote`)。
  * 规则基与 422 门在下单那一刻就要家目录,而那一刻执行环境还没开 —— 它们只读主张(`executionLaneHomeDir`);环境开起来时主张被证,证不了的环境不开。
  */
+import type { ExecutionEnvRefusalCode } from "./execution-env-refusal.js";
 /** 探针答案的行首标记:登录脚本 / profile 往 stdout 打的横幅不会被读成家目录 —— 只认带这个标记的那一行(恰一条,见 `markedHome`)。 */
 export declare const LANE_HOME_PROBE_MARKER = "sema-lane-home=";
 /**
@@ -72,14 +73,9 @@ export type LanePathFlavor = "posix" | "win32";
  */
 export declare function judgeLaneHome(lane: string, claim: LaneHomeClaim, probe: LaneHomeProbe, paths?: LanePathFlavor): LaneHomeVerdict;
 /**
- * 本仓自铸的**执行环境拒码**闭集(`env.*` 族;今天一员)—— 一只执行环境在交给引擎之前就被拒时,工厂抛出的错带的 `code`。引擎在准备期原样再抛、不建环境,
- * run 的 `failed` 终局原样承运码与句;同步提交腿按零工作拒落档(`runs.ts` 的 `EXECUTION_ENV_REFUSAL_HTTP_STATUS`,按本闭集键控:加一员而档没跟 ⇒ tsc 红)。
- *  · `env.home_unconfirmed` —— 家目录主张证不了({@link judgeLaneHome} 的三形拒句:读不出 / 不是绝对路径 / 与实测不一致)。三形一个码:出路都在部署
- *    (声明、环境里的 `HOME`,或会话 `settings.env` 里的 `HOME`),消费端不按形分岔;是哪一形、怎么改,句子里说。
+ * 家目录拒的带码错误:句 = 判官的拒句原文,码 = `env.home_unconfirmed`(本仓 `env.*` 族的一员,闭集属主 `execution-env-refusal.ts`)。读数在铸环境时就到手的车道(host)
+ * 构造时抛它,工厂原样抛出;读数要环境起来才有的车道在建连时以同一码答(建连座的拒因表 `home_unconfirmed`)。
  */
-export declare const EXECUTION_ENV_REFUSAL_CODES: readonly ["env.home_unconfirmed"];
-export type ExecutionEnvRefusalCode = (typeof EXECUTION_ENV_REFUSAL_CODES)[number];
-/** 家目录拒的带码错误:句 = 判官的拒句原文,码 = `env.home_unconfirmed`。读数在铸环境时就到手的车道(host)构造时抛它,工厂原样抛出。 */
 export declare function laneHomeRefusal(verdict: NonNullable<LaneHomeVerdict>): Error & {
     readonly code: Extract<ExecutionEnvRefusalCode, "env.home_unconfirmed">;
 };

package/dist/lane-home-probe.js

@@ -61,7 +61,6 @@ export function judgeLaneHome(lane, claim, probe, paths = "posix") {
         answered: true,
     };
 }
-export const EXECUTION_ENV_REFUSAL_CODES = ["env.home_unconfirmed"];
 export function laneHomeRefusal(verdict) {
     return Object.assign(new Error(verdict.refusal), { code: "env.home_unconfirmed" });
 }

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/leader/leader.d.ts

@@ -70,7 +70,8 @@ export interface ProvisionedWorker {
  * (`runtime-governance.ts` `entryPermissionMode`)得出的入口词(`run-entry.ts` `leaderRunEntry`);地板缺席 ⇒ `{}`。leader 请求不带调用方的模式词,所以入口词就是地板本身(与 run-local 同)。
  * 本 run 铸的每一条 spec 经 {@link withLeaderLeg} 从这一份取词;worker 的续跑体由它展开(`{ ...entry, objective }`)⇒ 首跑、续跑、修复腿同一个词。
  * 入口词是 `plan` 的 run 进不了这条车道(`run-entry.ts` `leaderEntryRefusal`:worker 会话没有计划审阅通道)—— 受理口与出生处同判,到不了 worker。
- * 热改 `AUTONOMY` 只影响之后起的 leader run:在飞的 run 保持它出生时盖下的这一份。
+ * 热改 `AUTONOMY` 只影响之后起的 leader run:在飞的 run(含它后来 provision 的 worker,与经 HTTP 续跑腿赎回的停驻 worker —— 续跑口对带无人值守标的行照写下的体重放,
+ * `http/resume-legs.ts` `replayCtxOf`)保持它出生时盖下的这一份。
  */
 export interface LeaderRunEntry {
     readonly permissionMode?: PermissionMode;

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,9 @@
 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";
+import type { MemorySeed } from "./project-registry.js";
+import type { SessionBindings } from "./session-bindings.js";
 /** 一条腿的部署事实(冻结记录)。 */
 export interface LegFacts {
     /** 执行车道:`none` ⇒ 无手孪生 Runner。读者 = 生产选路器。 */
@@ -27,10 +30,21 @@ export interface LegFacts {
     /** 受理时读根会话行的那一读(会话 id + 住客)。读者 = 腿的会话行记录座(`session-workspace.ts`)。 */
     readonly sessionWitness: DelegationRootWitness;
     /**
-     * 这次提交的根会话登记的工作目录(提交体 `cwd` 经唯一写口 `setSessionCwd` 登记的那一枚;装配器在登记之后读一次)。缺席 = 没登记。
-     * 读者 = 三只组合入口(同步 / 后台 / 续跑腿的梯子与验证门):经 `compositionLegRoot`(`task-cwd.ts`)交给它们驱动的每一条腿当交活方的工作目录。
+     * 这条腿要写在根会话上的绑定(工作目录 · shell 环境 · 继承策略;装配器只算)。读者 = run 认领之后的唯一提交点(`session-bindings.ts` 的 `commitLegBindings`):
+     * 受理的那一刻写这一笔,写了之后才收场 `refused` 的提交由提交出口按回执撤回;以及三只组合入口(同步 / 后台 / 续跑腿的梯子与验证门):工作目录那一格
+     * (这条腿跑在的那一枚)经 `compositionLegRoot`(`task-cwd.ts`)交给它们驱动的每一条腿当交活方的工作目录。
      */
-    readonly registeredCwd?: string;
+    readonly sessionBindings: SessionBindings;
+    /**
+     * 这条 run 继承到的项目上下文(`project-context.ts`):新提交腿在装配器头部判出的那一份,续跑腿是从续跑重建输入重放的那一份。缺席 = 没继承。
+     * 读者 = 提交腿写续跑重建输入的那一笔(`submit-ctx.ts` `persistSubmissionCtx` → `CheckpointCtx.projectContext`):判一次、随 run 冻结。
+     */
+    readonly projectContext?: ProjectContext;
+    /**
+     * 这条 run 的登记簿默认读层种子(`project-registry.ts`:种子项目 + 判出它的那一位观者;`null` = 提交带了项目、判过,无):新提交腿判出的,续跑腿是从续跑重建输入重放的那一份。
+     * 缺席 = 没什么可判(提交没带项目)或没判过(续跑重放的行早于种子判)。读者 = 提交腿写续跑重建输入的那一笔(`submit-ctx.ts` `persistSubmissionCtx` → `CheckpointCtx.memorySeed`):判一次、随 run 冻结。
+     */
+    readonly memorySeed?: MemorySeed | null;
 }
 /**
  * 铸事实(**单一属主**:只允许 `createResolveSpec` 的出口调用)。同一只对象被第二次铸 ⇒ 当场抛 —— 两个写者是漂移的成因,

package/dist/leg-facts.js

@@ -6,7 +6,9 @@ export function mintLegFacts(resolved, facts) {
         hands: facts.hands,
         skills: Object.freeze(facts.skills.map((e) => Object.freeze({ ...e }))),
         sessionWitness: Object.freeze({ ...facts.sessionWitness }),
-        ...(facts.registeredCwd !== undefined ? { registeredCwd: facts.registeredCwd } : {}),
+        sessionBindings: Object.freeze({ ...facts.sessionBindings, ...(facts.sessionBindings.shellEnv !== undefined ? { shellEnv: Object.freeze({ ...facts.sessionBindings.shellEnv }) } : {}) }),
+        ...(facts.projectContext !== undefined ? { projectContext: Object.freeze({ ...facts.projectContext }) } : {}),
+        ...(facts.memorySeed !== undefined ? { memorySeed: facts.memorySeed === null ? null : Object.freeze({ projectId: facts.memorySeed.projectId, viewer: Object.freeze({ ...facts.memorySeed.viewer }) }) } : {}),
     }));
     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-scope.d.ts

@@ -175,8 +175,8 @@ export declare function memoryEngineRootFor(config: Pick<ServiceConfig, "memoryE
  *  记忆搬到 `<localDataRoot>/memory-work`,存量记忆与控制面升级后隐形)。 */
 export declare function fileMemoryEngineRoot(config: Pick<ServiceConfig, "memoryEngineDir">, fallbackRoot?: string): string;
 /**
- * 一条路径的**规范形**(给 {@link judgeMemoryRootOutsideDataRoot} 的 `canonical` 座用的生产实现):
- *  · 既存的绝对路径 ⇒ **原样**交给 `realpath`(`.native`:大小写不敏感的文件系统上返回盘上的拼写;符号链接、macOS 的 `/var` → `/private/var` 在这一步展平)。
+ * 一条路径的**规范形**(给 {@link judgeMemoryRootOutsideDataRoot} 的 `canonical` 座用的生产实现;host 车道的工作区托管判也读它):
+ *  · 既存的绝对路径 ⇒ **原样**交给 `realpath`(core `physicalPathOf` = realpath(3):大小写不敏感的文件系统上返回盘上的拼写;符号链接、macOS 的 `/var` → `/private/var` 在这一步展平)。
  *    不先在字串上折 `..`:操作系统在展开符号链接**之后**才折 `..`,`/link/..` 的真身是链接目标的父目录,字串折叠会把它读成 `/`;
  *  · 其余(尚不存在 / 相对)⇒ 绝对化(**不折叠**)后逐段走:既存的前缀每进一段取一次 `realpath`(符号链接在这一步展开),`..` 折在**已展开**的前缀上 ——
  *    与操作系统同序(`/别名/../新目录` 的真身在链接目标的父目录下;先在字串上折会读成别名的父目录,判到另一只挂载上);第一段不存在起,余下是尚不存在的尾巴
@@ -194,8 +194,9 @@ export declare function canonicalPathOf(p: string): string;
 /**
  * **路径包含**(含相等)的判官:`child` 是不是 `root` 本身或它的后代 —— `path.relative(canonical(root), canonical(child))` 不是 `..`、不以 `..` 加分隔符起头、也不是绝对路径(跨盘符)。
  * `..` 要按**整段**判:名为 `..data` 的子目录在其下;`startsWith("..")` 会把它读成在其外。`canonical` 座缺省 `path.resolve`(字串规范形),boot 递 {@link canonicalPathOf} 取符号链接展平后的形;
- * 两侧同一只座(先 root、后 child)。读者两处:记忆根「在数据根之外」那一判({@link judgeMemoryRootOutsideDataRoot})与起服时「配置根是不是工作区的祖先」那一判(`sema-config-dir.ts`);
- * 树里别处内联的同形表达式(`boot/deployment-mods.ts` · `plugins/local-data-dir-modes-m39.ts` · `plugins/remote-env-host.ts` · `plugins/worktree-isolation.ts`)不在本次收口范围。
+ * 两侧同一只座(先 root、后 child)。读者三处:记忆根「在数据根之外」那一判({@link judgeMemoryRootOutsideDataRoot})、起服时「配置根是不是工作区的祖先」那一判(`sema-config-dir.ts`)
+ * 与 host 车道工厂「腿的目录落在哪只本服务铸的临时根里」那一判(`plugins/remote-env-host.ts`,座 = {@link canonicalPathOf});
+ * 树里别处内联的同形表达式(`boot/deployment-mods.ts` · `plugins/local-data-dir-modes-m39.ts` · `plugins/remote-env-host.ts` 的残余镜像写判 · `plugins/worktree-isolation.ts`)不在本次收口范围。
  */
 export declare function pathIsWithin(root: string, child: string, canonical?: (p: string) => string): boolean;
 /** {@link judgeMemoryRootOutsideDataRoot} 的读数:记忆引擎的根落在本机数据根**之外**。三键即 boot 日志行的字段(`hint` 是一句带两条真路径的人话)。 */

package/dist/memory-scope.js

@@ -1,6 +1,6 @@
-import { existsSync, realpathSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { dirname, isAbsolute, join, parse, relative, resolve, sep } from "node:path";
-import { FileMemoryEngineBackend, readMemoryLedgerForm, resolveMemoryEngineRoot, deriveControlPlaneDir, formatUserScope, formatProjScope, normalizeMemorySpec } from "@sema-agent/core";
+import { FileMemoryEngineBackend, physicalPathOf, readMemoryLedgerForm, resolveMemoryEngineRoot, deriveControlPlaneDir, formatUserScope, formatProjScope, normalizeMemorySpec } from "@sema-agent/core";
 import { capabilitiesFor, executionLaneOf } from "./execution-lane-caps.js";
 import { errorCodeOf, errorKindOf } from "./observability/err-text.js";
 import { assertMemoryScopeWidth } from "./plugins/memory-key-guards.js";
@@ -113,7 +113,7 @@ export function fileMemoryEngineRoot(config, fallbackRoot) {
 }
 export function canonicalPathOf(p) {
     if (isAbsolute(p) && existsSync(p))
-        return realpathSync.native(p);
+        return physicalPathOf(p);
     const abs = isAbsolute(p) ? p : `${process.cwd()}${sep}${p}`;
     const { root } = parse(abs);
     let existing = root;
@@ -134,7 +134,7 @@ export function canonicalPathOf(p) {
         }
         const next = join(existing, seg);
         if (existsSync(next))
-            existing = realpathSync.native(next);
+            existing = physicalPathOf(next);
         else
             tail.push(seg);
     }

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/memory-sync-client.d.ts

@@ -1,4 +1,4 @@
-import { type memorySyncReportOf, type MemorySyncTransport } from "@sema-agent/core";
+import { type memorySyncReportOf, type MemorySyncLayerReport, type MemorySyncTransport } from "@sema-agent/core";
 import type { ServiceConfig } from "./config-types.js";
 import type { MemoryScopeStores } from "./memory-scope-stores.js";
 import { type OneTimeMigrationWindow } from "./plugins/one-time-migrations.js";
@@ -48,10 +48,37 @@ export declare function memorySyncCursorDirFor(memoryEngineDir: string): string;
  * 加一个词 ⇒ {@link wayOutSentence} 的穷尽 switch 编译红(句子先写好,词才上得了 wire)。
  */
 export type MemorySyncWayOut = "delete_cursor";
-/** ⑦ 一层停驻的读数(读面与运维行同读这一只记录;不带盘路径 —— 路径只进运维行)。 */
+/** 引擎游标拒的 `detail`(轴 + 游标在那一轴上是缺席还是别的值);型取自引擎的同步报告,本仓不另写一份。 */
+type CursorRefusalDetail = NonNullable<Extract<MemorySyncLayerReport, {
+    readonly outcome: "refused";
+}>["detail"]>;
+/** 一层为什么停驻(铸记录的输入):`kind` 与引擎读数经记录上 wire,`why` 句只进运维行的 `note`(不在记录里)。 */
+type ParkCause = {
+    readonly kind: "cursor_refused";
+    readonly detail: CursorRefusalDetail | undefined;
+} | {
+    readonly kind: "cursor_unusable";
+    readonly why: string;
+};
+/**
+ * ⑦ 停驻成因的闭集(词 = {@link ParkCause} 的 `kind`):`cursor_refused` = 同步引擎在游标上拒了这一层(轴与读数见 `axis` / `found`);`cursor_unusable` = 游标文件读不成游标。
+ * 与运维行的 `reason`(本轮的触发原因)是两回事 —— 本词答「为什么停」,不答「哪一轮撞上它」。
+ */
+export type MemorySyncParkCause = ParkCause["kind"];
+/** 引擎游标拒读数的两个闭集(型取自引擎的同步报告,本仓不另写一份):被拒的是哪一轴;游标在那一轴上是缺席(`absent`)还是绑着别的值(`other`)。 */
+export type MemorySyncCursorAxis = CursorRefusalDetail["axis"];
+export type MemorySyncCursorFound = CursorRefusalDetail["found"];
+/**
+ * ⑦ 一层停驻的记录(读面与运维行同读这一只;**整条**就是 `memory-status.memorySync.parked[]` 的条目,所以它不带盘路径 —— 路径只进运维行)。
+ * 在场律:`cause` 恒在;`axis` / `found` ⇔ 成因是 `cursor_refused` 且引擎的读数在闭集内(别的成因、读数不在闭集 ⇒ 两键缺席,不是 `undefined` 值)。
+ * 加一个键 ⇒ 它就上 wire:自铸登记表的键集(`memorySyncParkedKey`)按本型 `satisfies`,漏登是编译红。唯一铸点 = {@link parkedLayerOf}。
+ */
 export interface MemorySyncParkedLayer {
     readonly scope: string;
     readonly wayOut: MemorySyncWayOut;
+    readonly cause: MemorySyncParkCause;
+    readonly axis?: MemorySyncCursorAxis;
+    readonly found?: MemorySyncCursorFound;
 }
 /** M31 一次的读数(测试按它断言)。`window: "closed"` ⇒ 一行都没读。 */
 export interface SyncCursorRelocationM31Report {
@@ -134,4 +161,5 @@ export declare function startMemorySyncRunner(deps: {
     stores: MemoryScopeStores;
     log: MemorySyncLog;
 }): MemorySyncRunner;
+export {};
 //# sourceMappingURL=memory-sync-client.d.ts.map

package/dist/memory-sync-client.js

@@ -55,6 +55,18 @@ export function memorySyncCursorDirFor(memoryEngineDir) {
 }
 const CURSOR_AXES = { scope: true, peer: true, store: true, incarnation: true };
 const CURSOR_FOUND = { absent: true, other: true };
+function parkedLayerOf(scope, cause, wayOut) {
+    switch (cause.kind) {
+        case "cursor_refused":
+            return Object.freeze({ scope, wayOut, cause: cause.kind, ...(cause.detail !== undefined ? { axis: cause.detail.axis, found: cause.detail.found } : {}) });
+        case "cursor_unusable":
+            return Object.freeze({ scope, wayOut, cause: cause.kind });
+        default: {
+            const unhandled = cause;
+            throw new Error(`memory sync: unknown park cause ${JSON.stringify(unhandled)}`);
+        }
+    }
+}
 function wayOutSentence(wayOut, cursorPath) {
     switch (wayOut) {
         case "delete_cursor":
@@ -81,16 +93,12 @@ function parkCauseSentence(cause) {
     }
 }
 class MemorySyncLayerParked extends Error {
-    scope;
     cursorPath;
-    parkCause;
-    wayOut;
+    layer;
     constructor(scope, cursorPath, parkCause, wayOut = "delete_cursor") {
         super(`memory sync: layer ${JSON.stringify(scope)} parked — ${parkCauseSentence(parkCause)}; ${wayOutSentence(wayOut, cursorPath)}`);
-        this.scope = scope;
         this.cursorPath = cursorPath;
-        this.parkCause = parkCause;
-        this.wayOut = wayOut;
+        this.layer = parkedLayerOf(scope, parkCause, wayOut);
     }
 }
 function cursorRefusalOf(err) {
@@ -354,8 +362,7 @@ export function createMemorySyncRunner(opts) {
     let parkedLayers = [];
     const logLayerFailure = (reason, scope, err) => {
         if (err instanceof MemorySyncLayerParked) {
-            const refused = err.parkCause.kind === "cursor_refused" ? err.parkCause.detail : undefined;
-            opts.log.warn("memory_sync_layer_parked", { reason, scope, cursorPath: err.cursorPath, ...(refused !== undefined ? { axis: refused.axis, found: refused.found } : {}), wayOut: err.wayOut, note: err.message });
+            opts.log.warn("memory_sync_layer_parked", { reason, cursorPath: err.cursorPath, ...err.layer, note: err.message });
         }
         else {
             opts.log.warn("memory_sync_layer_failed", { reason, scope, cursorPath: memorySyncCursorPath(memoryEngineDir, scope), err: errorText(err) });
@@ -386,7 +393,7 @@ export function createMemorySyncRunner(opts) {
             catch (err) {
                 calls.push({ scope, thrown: err });
                 if (err instanceof MemorySyncLayerParked)
-                    parkedNow.push({ scope, wayOut: err.wayOut });
+                    parkedNow.push(err.layer);
                 logLayerFailure(reason, scope, err);
             }
         }

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/err-text.d.ts

@@ -14,4 +14,11 @@ export declare function errorKindOf(err: unknown): string;
  * 不是串 ⇒ `undefined`(没有码,不编一个)。调用方按自己的形判(什么样的码配进一句拒句)再用它。
  */
 export declare function errorCodeOf(err: unknown): string | undefined;
+/**
+ * 不可信对象上**一个成员**的读口(店边界读 `code` / `errno` / `cause` / `message` 的唯一一只;同一处兜底 {@link readOr}):不是对象 ⇒ 缺席;访问器 / 代理抛 ⇒ 缺席(`undefined`)。
+ * 三问(缺席倒向):错误落到哪 —— 成员被当作不在,不单独记(这一读不是任何一条路的判词);谁受害 —— 没有真实受害者(驱动错误是平面数据对象),只有 getter 会抛的对象读不出码 / 链 / 句;
+ * 缺席倒向 —— 码读不出 ⇒ 没有码扳机、`cause` 读不出 ⇒ 链在此处止步,而**驱动出身扳机按对象身份判、不读任何成员**(`plugins/error-origin.ts`),链深扳机数的是层数 —— 所以带驱动记号的错照样**触发**换形;
+ * 换形本身读 `code` 判类时,成员 getter 会抛的对象仍可能在那一步抛出(店边界既有的限制,不是本读口引入的;真实驱动错误是平面数据对象,不在射程内)。
+ */
+export declare function errorMemberOf(o: unknown, key: string): unknown;
 //# sourceMappingURL=err-text.d.ts.map

package/dist/observability/err-text.js

@@ -30,4 +30,9 @@ export function errorCodeOf(err) {
     }, "");
     return code === "" ? undefined : code;
 }
+export function errorMemberOf(o, key) {
+    if (o === null || typeof o !== "object")
+        return undefined;
+    return readOr(() => o[key], undefined);
+}
 //# sourceMappingURL=err-text.js.map

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

@@ -55,13 +55,13 @@ export declare const FAIL_OPEN_TAGS: {
         readonly cls: "F";
         readonly note: "S-1173(`workflow-notify-journal.ts` 的 `ensurePointersFor`,park 指针的唯一写点):workflow run 记录的 `parks[]` **读不出**(在场却不是列表 / 某条目身份位或持有者两位形坏;读者 = `workflow-agent-session-index.ts` 的 `readRunParks`,整档成败制)⇒ 这一份指针投影派生不出来 ⇒ 写者这次**不写**指针,记录照写(已写过的指针只增不删,原样留着)。修前这一臂静默 `return`。**`parks` 缺席不进这一臂**:那是引擎契约里的合法形(更早引擎写的记录 / 准入没走完的续跑记录),读者答 `[]`(没有条目),没有要写的指针,不计。与指针**写**失败分家:写失败 ⇒ 记录写抛、记录不落(指针先于记录,不 fail-open);本臂没有丢任何一枚已写的指针 —— 读不出的是**记录本身**,引擎对条目形坏的记录整条拒续跑(`park_binding_broken`),读口对已有指针的 run 据记录响亮拒(`unproven/unreadable`),所以要的是查那条记录为什么读不出(投影把它写坏 / 手改)。放行的最坏后果:这条 run 首写就读不出时没有指针 ⇒ 这张卡没有别的指针时 `/decide` 落 legacy 腿、409 响亮拒,方向 fail-closed,不误配、不放行任何东西;例外 —— 同一张卡上另一支的指针在时分叉门判不出、决定投给那一支(引擎从不写坏形,要这一支在首写之前就被写坏);derived cache 没更新、真源读口自带响亮拒 ⇒ F 类。detail = `runId=`;计数非零 = 有记录的 `parks[]` 读不出,按 runId 去查记录。";
     };
-    readonly "server.workflow-live-receipt.channel-unreadable": {
+    readonly "server.workflow-park-holder.read-failed": {
         readonly cls: "F";
-        readonly note: "活 run 收下 workflow 停驻卡的决定之后,本进程回执簿(`parked-decide.ts` 的 `holdLiveReceipt`)等那条 run 的引擎观察通道收场来删簿;等的那一读拒 ⇒ 按收场删掉这条 run 的回执。放行的最坏后果:那条 run 仍在跑、驱动还在等并发槽时,同一决定重点一次答 409 `decide.claim_lost` 而不是首张回执(卡此刻仍 pending,重读列表再决);不重复执行、不放宽任何判定。";
+        readonly note: "workflow 停驻卡持有进程的拉取腿(`orchestration/workflow-park-holder.ts`,维护拍上读本进程执行中、持有停驻卡的 run 的决定行,把立住的决定在本地交给引擎)这一拍对某条候选读不出:决定行的主键读抛或超过期限(`step=decision`)、卡 / 持有者那一读超过期限(`step=card`),或执行器视图等那条 run 的引擎观察通道收场的那一读拒(`step=channel`,core 的观察队列只关不拒,结构上不可达)。放行的最坏后果:这条决定这一拍不交,行留着、卡仍 pending —— 下一拍再来;`channel` 那一形这条 run 出视图,它的行改由 run 的收场送达交给宿主会话的下一跑(交付晚到 run 收场,不丢、不错交)。不放宽任何判定:交不交、交给谁仍由行 + 卡状态 + 引擎判。detail = `step=<decision|card|channel> runId=<持有者> err=<原句,经记录器脱敏>`;计数持续非零 = 决定店 / 检查点店对这几条读不出,按 runId 查。";
     };
     readonly "server.workflow-park-decision.card-unreadable": {
         readonly cls: "F";
-        readonly note: "起跑读者(`parked-decide.ts` 的 `heldWorkflowParkDecisions`,每一只起跑器开跑前一次)读某条已受理的 workflow 子代决定所属的那张卡时 checkpoint 店抛 ⇒ 这一跑**不带**这条决定,行留着给下一跑。放行的最坏后果:这一跑里宿主若续跑那条 workflow run,子代按同一个 token 再停驻一次(卡仍 pending,决定仍在,下一跑照带)—— 方向是少交付一次,不是错交付:这一读失败不代表引擎随后那一读也失败,而引擎对「卡已不 pending、却拿到一条决定」的序数会当确认结算,所以读不出时绝不照供。计数持续非零 = checkpoint 店对这张卡读不出(库故障 / 行坏 / 写者版本更新),按 detail 的 `runId=`(受理那一刻的持有者)去查。detail = `runId=<留存锚> err=<原句,经记录器脱敏>`。";
+        readonly note: "交付决定行的三方(起跑读者 `heldWorkflowParkDecisions`,每一只起跑器开跑前一次;workflow 停驻卡持有进程的拉取腿;run 收场送达)共用的逐行判(`parked-decide.ts` 的 `deliverableEntryOf`)读某条已受理的 workflow 子代决定所属的那张卡(`step=card`)或那张卡的当下持有者(`step=holder`:park 索引 / 记录读)时店抛 ⇒ 这一次**不交付**这条决定,行留着(起跑读者:这一跑不带它,下一跑照带;拉取腿:下一拍再来;收场送达:不 ack、`recover` 重投)。放行的最坏后果:这一跑里宿主若续跑那条 workflow run,子代按同一个 token 再停驻一次(卡仍 pending,决定仍在,下一跑照带)—— 方向是少交付一次,不是错交付:这一读失败不代表引擎随后那一读也失败,而引擎对「卡已不 pending、却拿到一条决定」的序数会当确认结算,所以读不出时绝不照供。计数持续非零 = checkpoint 店 / park 索引 / 记录店对这张卡读不出(库故障 / 行坏 / 写者版本更新),按 detail 的 `runId=`(受理那一刻的持有者)去查。detail = `step=<card|holder> runId=<留存锚> err=<原句,经记录器脱敏>`。";
     };
     readonly "server.workflow-park-decision.store-unreadable": {
         readonly cls: "F";
@@ -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";
@@ -351,6 +351,10 @@ export declare const FAIL_OPEN_TAGS: {
         readonly cls: "F";
         readonly note: "#329 / #343(黑板 [5100] Q3):停驻行迟到决议的**受理回执表**(本副本对「200 丢包后重试」的幂等承诺 + 重叠请求的单飞句柄;键 = 行的键 askId,只在一次赎回真开飞时开格;容量帽只数受理之后留下的回执,在飞的单飞句柄永不被逐)**拒留一张回执**。放行的最坏后果 = 这**一次**受理(照旧生效)没有本副本的回执可依:200 丢包后的重试会再进一次赎回腿、拿到那条腿的 409(那张 checkpoint 已被消费)而不是幂等 200 回放(终局恒由赎回腿的 gate CAS 定,不会错兑也不会双兑);迟到受理本身、`GET /v1/approvals` 列表与 `/v1/approvals/:sessionId/decide` 一个字节不动 ⇒ F 类。为什么方向是「拒新」而不是 FIFO 挤最旧:那个形让**甲的用量决定乙的可用性**(已鉴权租户量产受理即可把别家回执挤出,merge-rescan 744 confirmed 的同一病形)。必须留痕:「表被别人打满」与「这一次本来就没有回执」在 wire 上同形。detail 带 owner(判「压力来自谁」的第一手线索)。臂只有一条:全局回执帽满、本 principal 未到子帽、表里没有过期回执可收 ⇒ 拒留(detail 带 owner)。本 principal 到了子帽的常态臂逐自己最旧的一张回执(量产者自伤,设计内有界表纪律),不走本 tag;在飞的单飞句柄不占帽、永不被逐。";
     };
+    readonly "server.approval.parked-decision-not-recorded": {
+        readonly cls: "F";
+        readonly note: "S-1054 α(`tool-approval.ts` 的 `recordParkedOutcome`,停驻赎回那一飞的落行步):停驻门**已经受理**了这次决定(续跑已开始),而把它的记录(决议向 · 署名 · 理由 · 回决幂等键 · 出处)落到仍 `PARKED` 的问行上没成 —— 店错 / 超时 / 行出了门判过的属主域 / 这把键已被同 task 另一只问占着(detail 带 `reason`)。放行的最坏后果 = 这一问在耐久决断口上的**同键回放**读不到这把键:同键重发得到 `409 conflict.ask_decided`(回显门上站着的那次决定,决议向 / 时刻 / 理由取自门,无署名),而不是 200 回放;审计面少一份署名。决定本身零影响(终局恒在停驻门上,门已决);不改判、不重赎、不双兑。计数非零 = 问账店在受理之后写不动了,运维要去看店。";
+    };
     readonly "server.approvals.stale-echoed-token-unreadable": {
         readonly cls: "F";
         readonly note: "S-02 codex R1-[medium](验真后修):decide 的 409 `approval_stale` 臂对**调用方回显的旧 token** 做归属判定(`cs.get(binding.checkpointToken)`),那次读**抛了**(store 抖动 / 坏 checkpoint 行 / 行恰被清理)。修前这里是静默 `catch(()=>null)`,「读不出」被折成「确认不在库」——叠上 S-02 的 404 收口后,一次 store 抖动就会把合法旧 token 的 409+terminal 谎报成 404「没有这条审批」。修后:unreadable ⇒ **保持 409**(`terminal` 不披露——证不出归属就不说,与 2026-07-26 纪律同向;404 折叠只在读成功且未命中时走,探测方无法自控 store 故障 ⇒ 谕示封闭不破)。放行的最坏后果 = 该次拒体 `terminal` 诚实缺席(`currentPending` 由它自己的读口与属主复核另判,不受本臂牵连),壳退回重拉列表,judgment 面 fail-safe,故 F 类。留痕理由:这次读是 terminal 披露与 404 折叠两个判定的输入,长期抖动必须在遥测显形。";
@@ -569,13 +573,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 +615,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";