@sema-agent/server 7.148.0 → 7.150.0

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";
@@ -303,6 +303,10 @@ export declare const FAIL_OPEN_TAGS: {
         readonly cls: "F";
         readonly note: "`memory-incident-sink.ts` 的 `createMemoryEngineIncidentSink`(两只宿主 `onError` 的 `memory` 相共用的落点):记忆相上到达店形拒族(`STORE_FORM_REFUSAL_CODES`,按族读;引擎 7.65.0 起含控制面所在文件系统不能建硬链接的 `memory.control_plane_links_unsupported`)的码 ⇒ 引擎的一步记忆活被店拒、会话照跑:mount 时开店被拒 ⇒ 这一跑记忆面读作 `memoryless`(`mount-failed`);mount 之后的整理 / 收割撞上 ⇒ 那一步没做(席只认码与相,不分哪一步 —— 是哪一步看同一行 `memory_engine_incident` 的句子)。放行的最坏后果 = 这一跑没有记忆或少做一步记忆活(不召回、不采集、不收割、不整理)—— 少做,不是错做:不开门、不放宽任何判据,模型读不到的是记忆不是别的;不放行的代价是记忆盘一个挂载面的形不对就让每一跑都失败。留痕是因为「这台部署的记忆从来没挂上」与「会话里本来没东西可记」在外部同形:逐次计数 + 探针 + 每进程一次 warn,detail `code=<店形拒码>`(运维行 `memory_engine_incident` 另带码与经出口座的句子);出路 = 把记忆控制面放到支持硬链接的卷上(或按码修挂载形)后重启。";
     };
+    readonly "server.memory.project-marker-unreadable": {
+        readonly cls: "F";
+        readonly note: "单用户记忆项目层的身份(`project-identity.ts` 的 `markerFact`,唯一读者 `projectLayerIdentityOf`;装配期每个任务读一次):检出的 `.sema/project` 记号**读不出** —— 坏记号(`config.memory_project_marker`)、嵌套在仓根之下的记号(`config.memory_project_marker_nested`)、存在性查询或读本身失败 ⇒ 这一任务**没有项目层**(声明席 `{ absent: \"unreadable\" }`):写家落全局层,引擎同拍铸 operator 通知 `memory.project_scope_absent`,并在每条腿上自己报一次记号的错(`onError`,相 `config`)。**不**退回 git 根档 —— 那会在记号读得出之后静默换键。放行的最坏后果 = 这一任务的项目记忆写进全局层(同一用户的其它项目也读得到,单用户部署内,不越属主),记号修好之后 git 根档折进记号档、全局层里这段时间写下的条目不回项目层;不是门、不是凭据、不改任何裁决。反方向(拒整条 run)为一只坏记号打死用户的任务,且引擎自己对不消费项目身份的腿也照跑。detail = `code=<引擎的记号码 | ->`(句子与路径在引擎那一行里)。计数持续非零 = 有检出带着坏 / 嵌套记号,去修记号。";
+    };
     readonly "server.memory.locked-layer-probe-partial": {
         readonly cls: "F";
         readonly note: "O2(7.101.0 合并复审,`memory-layer-legacy-lock.ts announceLockedLegacyMemoryLayers`,boot 期锁住记忆层探测;detail 只报 `unreadable=<条数>`):挂载面或某个层里的目录**读不出**(EACCES 之类 —— 不是 ≤7.30.x 引擎的锁形,那种 0555 目录可读)⇒ 那棵子树看不全,照常起服。放行的最坏后果 = 一个锁住的层在 boot 日志里没被点名 —— 探测是**披露**面,不参与任何门 / 裁决;core 在真正失败的那一次删除上仍给出自己的 `chmod -R u+w` 补救句。不放行的代价严重不对称:为一条 warn 打死起服(混跑窗里能服务的副本)。计数让「这台部署的记忆树有读不出的目录」显形。";
@@ -409,7 +413,7 @@ export declare const FAIL_OPEN_TAGS: {
     };
     readonly "server.runs.terminal-ledger-write-failed": {
         readonly cls: "F";
-        readonly note: "S-107(全量门 silent-degradation 棘轮抓出的五处静默 `catch {}`):run 终局链里**账本腿**(flush 缓冲 text/reasoning、append `failed` 行)与终态翻转(setTerminal)已不共命运——账本 INSERT 抛不再让 run 卡 running 到 reaper;但那条抛掉的账本行之前是**静默**吞的。detail `arm=` 四臂(flush-clean-cancel / append-clean-cancel / flush-catch / append-thrown-cancel / append-failed);S-947 起续跑腿(`http/resume-legs.ts`)两座同 tag:resume-append-resume-aborted / resume-append-thrown-cancel(取消抛出两臂的 `failed` 行,修前那两臂根本不落账本终局行):缺的是 run_events 尾巴(缓冲文本或 failed 事件),run 行本身仍是 durable truth,读面/reaper 容忍缺失,故 F 类;计数=多少次终局账本写失败。";
+        readonly note: "S-107(全量门 silent-degradation 棘轮抓出的五处静默 `catch {}`):run 终局链里**账本腿**(flush 缓冲 text/reasoning、append `failed` 行)与终态翻转(setTerminal)已不共命运——账本 INSERT 抛不再让 run 卡 running 到 reaper;但那条抛掉的账本行之前是**静默**吞的。detail `arm=` 四臂(flush-clean-cancel / append-clean-cancel / flush-catch / append-thrown-cancel / append-failed);S-947 起续跑腿(`http/resume-legs.ts`)两座同 tag:resume-append-resume-aborted / resume-append-thrown-cancel(取消抛出两臂的 `failed` 行,修前那两臂根本不落账本终局行);停驻帧同一条律(卡已提交之后,停驻的账本投影写不下不改判词,行的停驻写是唯一提交点 —— `park-row-commit.ts`):park-usage / park-row(park 行唯一写口 `trace/project.ts` 的 `appendParkRow`,三条腿同经)、park-held(后台腿停驻结果到手之后、进停驻臂之前一笔簿记写抛 ⇒ 照常停驻)、resume-park-projection(续跑 verify 臂停驻形的清单 / 用量 / 停驻帧那一段)、resume-park-held(续跑腿再停结果到手之后一笔簿记写抛 ⇒ 本腿照常再停,detail 带那一抛的原句):缺的是 run_events 尾巴(缓冲文本、failed 事件或停驻帧),run 行本身仍是 durable truth,读面/reaper 容忍缺失,故 F 类;计数=多少次状态帧(终局 / 停驻)账本写失败。";
     };
     readonly "server.live-text.hold-diverged": {
         readonly cls: "P-DEBT";
@@ -565,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";
@@ -607,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";
@@ -657,7 +661,15 @@ export declare const FAIL_OPEN_TAGS: {
     };
     readonly "server.park.held-card-void-failed": {
         readonly cls: "F";
-        readonly note: "停驻没落定就以失败收场的腿(`runs.ts` 的 `voidHeldParkCard`;两处:后台腿 catch 的失败臂 `leg=bg`、续跑腿 catch 放认领的取消 / 普通异常两臂 `leg=resume`):手里的结果是宿主层停驻(引擎交回之前已把卡落进 checkpoint 店,卡在本 run 的会话上),而停驻行 / 用量行 / 结果到手之后的账本写抛 ⇒ 腿以 `failed` 收场、放认领;放认领之前先按卡自己的 scope 店级 `expire` 作废那张卡(动词 = `card-void.ts` 的结算作废)。作废没做成 —— 店读 / 作废抛错(`store_error`)、卡的会话与本 run 的会话对不上(`card_mismatch`,只作废那一张,对不上就不动)、本部署没接 checkpoint 店(`no_checkpoint_store`)—— 照样以 `failed` 收场、放认领,每次记一次。放行的最坏后果 = 那张卡回到修前的形:留在待决面上,兑现它的 run 已经 `failed`、认领已放,决定口照样受理、续跑在没有认领的会话上驱动(`resume-legs.ts` 认领缺席成因 ②),由审批兜底收割收走;前提是停驻簿记写失败,并且这张卡没作废成(三个 reason 任一:checkpoint 店这一笔也失败 / 卡与本 run 的会话对不上 / 没接店 —— 后两者不需要第二次写失败)。不是门、不是凭据、不改 run 的判词。计数非零 = 有一次停驻没落定的失败收场留下了一张卡:按 reason 看 —— `store_error` = checkpoint 店在同一拍也出错,`card_mismatch` = 结果里的卡与本 run 的会话对不上,`no_checkpoint_store` = 这台部署没接 checkpoint 店;去看那只会话。detail = `reason=<词> leg=<bg|resume> [err=<原句>]`(不含凭据)。";
+        readonly note: "卡已提交(引擎交回停驻之前已把卡落进 checkpoint 店,卡在本 run 的会话上)而兑现它的 run 不再等它,本服务按卡自己的 scope 店级 `expire` 作废那张卡(动词 = `card-void.ts` 的结算作废)—— 两个产地:① 手里握着停驻结果、却以终局收场的腿(`runs.ts` 的 `voidHeldParkCard`:后台腿 catch 的失败臂 `leg=bg` —— 取消落在结果到手之后、或结果不是停驻词;续跑腿 catch 放认领的取消 / 普通异常两臂 `leg=resume`),卡的命运先于认领释放;② 停驻的唯一提交点(`park-row-commit.ts` 的 `commitParkRow`,`leg=bg|resume|sync`,detail 多一位 `at=<park_commit_refused|park_commit_cancelled>`):行的停驻写被店答出「不」而读到的行不在或已终局(被收割 / 别处终结 / 接手腿收场)⇒ `park_commit_refused`,卡跟着行作废;读到行归本腿、在跑、挂着取消请求 ⇒ `park_commit_cancelled`,先作废卡、再落取消终局。停驻簿记(账本帧 / 用量差)写不下与行的停驻写撞店故障**都不是**产地(前者只留痕、后者续写,见 `server.park.row-commit-deferred`)。作废没做成 —— 店读 / 作废抛错(`store_error`)、卡的会话与本 run 的会话对不上(`card_mismatch`,只作废那一张,对不上就不动)、本部署没接 checkpoint 店(`no_checkpoint_store`)—— 收场照走,每次记一次。放行的最坏后果 = 那张卡留在待决面上,兑现它的 run 已经终局、认领已放:决定口照样受理、续跑在没有认领的会话上驱动(`resume-legs.ts` 认领缺席成因),由审批兜底收割按卡的截止收走。不是门、不是凭据、不改 run 的判词。计数非零 = 留下了一张兑现不了的卡:按 reason 看 —— `store_error` = checkpoint 店在同一拍也出错,`card_mismatch` = 卡与本 run 的会话对不上,`no_checkpoint_store` = 这台部署没接 checkpoint 店;去看那只会话。detail = `reason=<词> leg=<bg|resume|sync>[ at=<park_commit_refused|park_commit_cancelled>][ err=<原句>]`(不含凭据)。";
+    };
+    readonly "server.park.row-commit-deferred": {
+        readonly cls: "F";
+        readonly note: "停驻的唯一提交点(`park-row-commit.ts` 的 `commitParkRow`;三条腿同经:后台腿 `leg=bg`、续跑腿的再停 / 重开 / 放回 `leg=resume`、同步 detach 腿 `leg=sync`):卡已提交之后 run 行的停驻写(`setSuspended` / `setNeedsReview`)撞店故障(抛:连接 / 超时 / 程序错)。规则「店的故障不是答案」⇒ 不收场:行不落 failed、卡不作废、认领留着,同一笔停驻再提交 —— 当拍一次,仍没答出 ⇒ 按心跳节拍续,店答出即收。停驻写的 CAS = 行仍归本腿(持有腿 `leg_id`,认领铸、交给本腿)∧ 在跑(或已停在本词上)∧ 没挂取消请求;第一笔与每一次再提交是同一个形(一笔抛了的写结局未知,同词重写幂等):写,店答出「不」⇒ 读行、由行答 —— 行不在 / 已终局 ⇒ 卡跟着作废;归别的腿、还活着 ⇒ 接手腿已接走,不再写;归本腿、停在本词上 ⇒ 停驻成立;归本腿、在跑、挂着取消请求 ⇒ 先作废卡、再落取消终局(码 `cancelled`;作废见 `server.park.held-card-void-failed`)。上界 = 两个判活窗(`REAP_RUN_STALE_SEC`);到上界仍没答 ⇒ 停手、交既有出路:行由失联收割按判活窗收成 failed 并放认领,卡由审批兜底收割按它的截止 / 绝对兜底时刻作废。放行的最坏后果 = 续写期间行停在 `running`(没有心跳):这一窗里决定那张卡答 409 `conflict.not_resumable`(行还没落到停驻词),落下之后同一决定照常受理;进程在续写期间退出 ⇒ 直接交既有出路(行被失联收割、卡由兜底收割)。不是门、不是凭据。detail = `leg=<bg|resume|sync> step=<first|again|retry|gave_up> err=<原句>`(不含凭据);计数 = 停驻提交失败的次数(第一笔写 / 再提交的读、写、取消终局写),`gave_up` 非零 = 有一次停驻交给了既有出路,去看那只会话与店。";
+    };
+    readonly "server.park.row-commit-contradicted": {
+        readonly cls: "F";
+        readonly note: "停驻的唯一提交点(`park-row-commit.ts` 的 `commitParkRow`,`leg=bg|resume|sync`)的拒后判之外的那一格:停驻写被店答出「不」,随后读到的行却归本腿、在跑、没挂取消请求 —— CAS 的三件(持有腿 · 在跑或已停在本词上 · 没挂取消)读来都成立而写被拒,店自相矛盾,是不变量破,不是店抖动。本格不猜:当一次店故障处置(不收场、不作废卡、认领留着),交同一条再提交路(当拍一次、心跳节拍续、上界两个判活窗,`server.park.row-commit-deferred` 同计),店答出别的读数即按拒后判收场;一直矛盾 ⇒ 到上界停手、交既有出路(失联收割收行、审批兜底收割收卡)。放行的最坏后果 = 行在续写期间停在 `running`、卡待决到上界。不是门、不是凭据。计数非零 = 本库对同一行的 UPDATE 与 SELECT 答得不一致(读到的不是写判的那一份:读副本 / 隔离级别 / 店的缺陷),去查那只库。detail = `leg=<bg|resume|sync> taskId=<id> word=<suspended|needs_review> status=<读到的词> holder=self cancel=false`(不含凭据)。";
     };
     readonly "server.verifier-pause.card-void-failed": {
         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",
@@ -284,6 +284,10 @@ export const FAIL_OPEN_TAGS = {
         cls: "F",
         note: "`memory-incident-sink.ts` 的 `createMemoryEngineIncidentSink`(两只宿主 `onError` 的 `memory` 相共用的落点):记忆相上到达店形拒族(`STORE_FORM_REFUSAL_CODES`,按族读;引擎 7.65.0 起含控制面所在文件系统不能建硬链接的 `memory.control_plane_links_unsupported`)的码 ⇒ 引擎的一步记忆活被店拒、会话照跑:mount 时开店被拒 ⇒ 这一跑记忆面读作 `memoryless`(`mount-failed`);mount 之后的整理 / 收割撞上 ⇒ 那一步没做(席只认码与相,不分哪一步 —— 是哪一步看同一行 `memory_engine_incident` 的句子)。放行的最坏后果 = 这一跑没有记忆或少做一步记忆活(不召回、不采集、不收割、不整理)—— 少做,不是错做:不开门、不放宽任何判据,模型读不到的是记忆不是别的;不放行的代价是记忆盘一个挂载面的形不对就让每一跑都失败。留痕是因为「这台部署的记忆从来没挂上」与「会话里本来没东西可记」在外部同形:逐次计数 + 探针 + 每进程一次 warn,detail `code=<店形拒码>`(运维行 `memory_engine_incident` 另带码与经出口座的句子);出路 = 把记忆控制面放到支持硬链接的卷上(或按码修挂载形)后重启。",
     },
+    "server.memory.project-marker-unreadable": {
+        cls: "F",
+        note: "单用户记忆项目层的身份(`project-identity.ts` 的 `markerFact`,唯一读者 `projectLayerIdentityOf`;装配期每个任务读一次):检出的 `.sema/project` 记号**读不出** —— 坏记号(`config.memory_project_marker`)、嵌套在仓根之下的记号(`config.memory_project_marker_nested`)、存在性查询或读本身失败 ⇒ 这一任务**没有项目层**(声明席 `{ absent: \"unreadable\" }`):写家落全局层,引擎同拍铸 operator 通知 `memory.project_scope_absent`,并在每条腿上自己报一次记号的错(`onError`,相 `config`)。**不**退回 git 根档 —— 那会在记号读得出之后静默换键。放行的最坏后果 = 这一任务的项目记忆写进全局层(同一用户的其它项目也读得到,单用户部署内,不越属主),记号修好之后 git 根档折进记号档、全局层里这段时间写下的条目不回项目层;不是门、不是凭据、不改任何裁决。反方向(拒整条 run)为一只坏记号打死用户的任务,且引擎自己对不消费项目身份的腿也照跑。detail = `code=<引擎的记号码 | ->`(句子与路径在引擎那一行里)。计数持续非零 = 有检出带着坏 / 嵌套记号,去修记号。",
+    },
     "server.memory.locked-layer-probe-partial": {
         cls: "F",
         note: "O2(7.101.0 合并复审,`memory-layer-legacy-lock.ts announceLockedLegacyMemoryLayers`,boot 期锁住记忆层探测;detail 只报 `unreadable=<条数>`):挂载面或某个层里的目录**读不出**(EACCES 之类 —— 不是 ≤7.30.x 引擎的锁形,那种 0555 目录可读)⇒ 那棵子树看不全,照常起服。放行的最坏后果 = 一个锁住的层在 boot 日志里没被点名 —— 探测是**披露**面,不参与任何门 / 裁决;core 在真正失败的那一次删除上仍给出自己的 `chmod -R u+w` 补救句。不放行的代价严重不对称:为一条 warn 打死起服(混跑窗里能服务的副本)。计数让「这台部署的记忆树有读不出的目录」显形。",
@@ -373,7 +377,7 @@ export const FAIL_OPEN_TAGS = {
     "server.run-terminal.diag-capped": { cls: "F", note: "S-107:诊断文本座(merge details/measure/grader trace、leader 日志座、planner 样本、journal 预览、workflow_run error cut)长度 > DIAG_INPUT_CAP(256KB)⇒ 整段换 «redacted:oversized-diagnostic» [len=N](fail-closed 取证丢弃;固定窗不 fail-closed 故不开窗);计数=多少段诊断文本被整段丢弃" },
     "server.run-terminal.output-truncated": { cls: "F", note: "S-107:持久 error 脱后 UTF-8 字节 > 65,000(TiDB TEXT 65,535 字节)⇒ 脱后切并带标记(切在占位里不是泄漏);计数=多少条终态文案被字节封顶截断" },
     "server.runs.abort-cause-missing": { cls: "F", note: "S-947 候裁 ⑤(主会话裁:默认值保留,miss 臂必须响):续跑腿 `http/resume-legs.ts` 的 `checkpoint.resume_aborted` 臂 —— core 只在本腿递进去的信号**已中止**时铸该码,而那只信号唯一的写者是取消动词(快路 / 耐久旗轮询,句柄登记 `cancel_verb`),所以**只有 core 契约外的形**(桩 / 非 core Runner 直接抛该码,本腿句柄从未中止)才到得了「句柄上读不到成因」这一臂。取消终局照铸,成因取本腿唯一的中止词 `cancel_verb`(取消终局恒带成因由铸点签名保证,不让它缺);detail `task=<taskId>`;计数 = 多少次取消成因是默认值而不是句柄登记的。生产上恒零是证据,不归零 = 有一条不走 core 契约的 Runner 在跑续跑腿。" },
-    "server.runs.terminal-ledger-write-failed": { cls: "F", note: "S-107(全量门 silent-degradation 棘轮抓出的五处静默 `catch {}`):run 终局链里**账本腿**(flush 缓冲 text/reasoning、append `failed` 行)与终态翻转(setTerminal)已不共命运——账本 INSERT 抛不再让 run 卡 running 到 reaper;但那条抛掉的账本行之前是**静默**吞的。detail `arm=` 四臂(flush-clean-cancel / append-clean-cancel / flush-catch / append-thrown-cancel / append-failed);S-947 起续跑腿(`http/resume-legs.ts`)两座同 tag:resume-append-resume-aborted / resume-append-thrown-cancel(取消抛出两臂的 `failed` 行,修前那两臂根本不落账本终局行):缺的是 run_events 尾巴(缓冲文本或 failed 事件),run 行本身仍是 durable truth,读面/reaper 容忍缺失,故 F 类;计数=多少次终局账本写失败。" },
+    "server.runs.terminal-ledger-write-failed": { cls: "F", note: "S-107(全量门 silent-degradation 棘轮抓出的五处静默 `catch {}`):run 终局链里**账本腿**(flush 缓冲 text/reasoning、append `failed` 行)与终态翻转(setTerminal)已不共命运——账本 INSERT 抛不再让 run 卡 running 到 reaper;但那条抛掉的账本行之前是**静默**吞的。detail `arm=` 四臂(flush-clean-cancel / append-clean-cancel / flush-catch / append-thrown-cancel / append-failed);S-947 起续跑腿(`http/resume-legs.ts`)两座同 tag:resume-append-resume-aborted / resume-append-thrown-cancel(取消抛出两臂的 `failed` 行,修前那两臂根本不落账本终局行);停驻帧同一条律(卡已提交之后,停驻的账本投影写不下不改判词,行的停驻写是唯一提交点 —— `park-row-commit.ts`):park-usage / park-row(park 行唯一写口 `trace/project.ts` 的 `appendParkRow`,三条腿同经)、park-held(后台腿停驻结果到手之后、进停驻臂之前一笔簿记写抛 ⇒ 照常停驻)、resume-park-projection(续跑 verify 臂停驻形的清单 / 用量 / 停驻帧那一段)、resume-park-held(续跑腿再停结果到手之后一笔簿记写抛 ⇒ 本腿照常再停,detail 带那一抛的原句):缺的是 run_events 尾巴(缓冲文本、failed 事件或停驻帧),run 行本身仍是 durable truth,读面/reaper 容忍缺失,故 F 类;计数=多少次状态帧(终局 / 停驻)账本写失败。" },
     "server.live-text.hold-diverged": {
         cls: "P-DEBT",
         note: "live 面模型文本的流式口(`trace/model-segment.ts` 的 `createLiveModelText`,三条 live 腿共用;流式口 = `trace/redact.ts` 的 `createRedactionStream`:喂入 / 取已判定前缀 / 收尾冲刷):一段冲刷时,已取出去的逐块字节与整段读法在那一截上的渲染对不上,或有一条整段读法的跨度横跨放行位 —— 流式口的律被打破(某条判定读到了文本之后才定的东西,却没被读口闭集算作开着 —— 交出点 = 读口闭集的交出点,`trace/redact.ts` 的 `FRONTIER_TERMS`)。处置:余下的字节照整段读法出(横跨放行位的跨度整枚换记号,不再出它的原文字节),段末帧照发整段脱敏的正文、消费端按它整段替换;但**已经出门**的那几块收不回 —— 其中可能有整段读法会遮的字节(这就是 P 族的理由)。债:编译期管不到的两处 —— 扫描器「每次尝试的头上都设一次寄存器」靠人审(一次都没设的那一形另记 `server.redact.scan-view-unattributed`),取证级数封顶从整条臂的足迹包络起补遮(另记 `server.redact.forensic-level-cap`)。钉 = 基线语料全前缀两块喂入 + 逐条按块流过流式口拼接 = 整段脱敏 + 判定距离最远的几形逐码元。detail `family=<text|reasoning> len=<段长>`;计数 = 多少段的律被打破(期望恒 0)。",
@@ -516,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",
@@ -558,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",
@@ -608,7 +612,15 @@ export const FAIL_OPEN_TAGS = {
     },
     "server.park.held-card-void-failed": {
         cls: "F",
-        note: "停驻没落定就以失败收场的腿(`runs.ts` 的 `voidHeldParkCard`;两处:后台腿 catch 的失败臂 `leg=bg`、续跑腿 catch 放认领的取消 / 普通异常两臂 `leg=resume`):手里的结果是宿主层停驻(引擎交回之前已把卡落进 checkpoint 店,卡在本 run 的会话上),而停驻行 / 用量行 / 结果到手之后的账本写抛 ⇒ 腿以 `failed` 收场、放认领;放认领之前先按卡自己的 scope 店级 `expire` 作废那张卡(动词 = `card-void.ts` 的结算作废)。作废没做成 —— 店读 / 作废抛错(`store_error`)、卡的会话与本 run 的会话对不上(`card_mismatch`,只作废那一张,对不上就不动)、本部署没接 checkpoint 店(`no_checkpoint_store`)—— 照样以 `failed` 收场、放认领,每次记一次。放行的最坏后果 = 那张卡回到修前的形:留在待决面上,兑现它的 run 已经 `failed`、认领已放,决定口照样受理、续跑在没有认领的会话上驱动(`resume-legs.ts` 认领缺席成因 ②),由审批兜底收割收走;前提是停驻簿记写失败,并且这张卡没作废成(三个 reason 任一:checkpoint 店这一笔也失败 / 卡与本 run 的会话对不上 / 没接店 —— 后两者不需要第二次写失败)。不是门、不是凭据、不改 run 的判词。计数非零 = 有一次停驻没落定的失败收场留下了一张卡:按 reason 看 —— `store_error` = checkpoint 店在同一拍也出错,`card_mismatch` = 结果里的卡与本 run 的会话对不上,`no_checkpoint_store` = 这台部署没接 checkpoint 店;去看那只会话。detail = `reason=<词> leg=<bg|resume> [err=<原句>]`(不含凭据)。",
+        note: "卡已提交(引擎交回停驻之前已把卡落进 checkpoint 店,卡在本 run 的会话上)而兑现它的 run 不再等它,本服务按卡自己的 scope 店级 `expire` 作废那张卡(动词 = `card-void.ts` 的结算作废)—— 两个产地:① 手里握着停驻结果、却以终局收场的腿(`runs.ts` 的 `voidHeldParkCard`:后台腿 catch 的失败臂 `leg=bg` —— 取消落在结果到手之后、或结果不是停驻词;续跑腿 catch 放认领的取消 / 普通异常两臂 `leg=resume`),卡的命运先于认领释放;② 停驻的唯一提交点(`park-row-commit.ts` 的 `commitParkRow`,`leg=bg|resume|sync`,detail 多一位 `at=<park_commit_refused|park_commit_cancelled>`):行的停驻写被店答出「不」而读到的行不在或已终局(被收割 / 别处终结 / 接手腿收场)⇒ `park_commit_refused`,卡跟着行作废;读到行归本腿、在跑、挂着取消请求 ⇒ `park_commit_cancelled`,先作废卡、再落取消终局。停驻簿记(账本帧 / 用量差)写不下与行的停驻写撞店故障**都不是**产地(前者只留痕、后者续写,见 `server.park.row-commit-deferred`)。作废没做成 —— 店读 / 作废抛错(`store_error`)、卡的会话与本 run 的会话对不上(`card_mismatch`,只作废那一张,对不上就不动)、本部署没接 checkpoint 店(`no_checkpoint_store`)—— 收场照走,每次记一次。放行的最坏后果 = 那张卡留在待决面上,兑现它的 run 已经终局、认领已放:决定口照样受理、续跑在没有认领的会话上驱动(`resume-legs.ts` 认领缺席成因),由审批兜底收割按卡的截止收走。不是门、不是凭据、不改 run 的判词。计数非零 = 留下了一张兑现不了的卡:按 reason 看 —— `store_error` = checkpoint 店在同一拍也出错,`card_mismatch` = 卡与本 run 的会话对不上,`no_checkpoint_store` = 这台部署没接 checkpoint 店;去看那只会话。detail = `reason=<词> leg=<bg|resume|sync>[ at=<park_commit_refused|park_commit_cancelled>][ err=<原句>]`(不含凭据)。",
+    },
+    "server.park.row-commit-deferred": {
+        cls: "F",
+        note: "停驻的唯一提交点(`park-row-commit.ts` 的 `commitParkRow`;三条腿同经:后台腿 `leg=bg`、续跑腿的再停 / 重开 / 放回 `leg=resume`、同步 detach 腿 `leg=sync`):卡已提交之后 run 行的停驻写(`setSuspended` / `setNeedsReview`)撞店故障(抛:连接 / 超时 / 程序错)。规则「店的故障不是答案」⇒ 不收场:行不落 failed、卡不作废、认领留着,同一笔停驻再提交 —— 当拍一次,仍没答出 ⇒ 按心跳节拍续,店答出即收。停驻写的 CAS = 行仍归本腿(持有腿 `leg_id`,认领铸、交给本腿)∧ 在跑(或已停在本词上)∧ 没挂取消请求;第一笔与每一次再提交是同一个形(一笔抛了的写结局未知,同词重写幂等):写,店答出「不」⇒ 读行、由行答 —— 行不在 / 已终局 ⇒ 卡跟着作废;归别的腿、还活着 ⇒ 接手腿已接走,不再写;归本腿、停在本词上 ⇒ 停驻成立;归本腿、在跑、挂着取消请求 ⇒ 先作废卡、再落取消终局(码 `cancelled`;作废见 `server.park.held-card-void-failed`)。上界 = 两个判活窗(`REAP_RUN_STALE_SEC`);到上界仍没答 ⇒ 停手、交既有出路:行由失联收割按判活窗收成 failed 并放认领,卡由审批兜底收割按它的截止 / 绝对兜底时刻作废。放行的最坏后果 = 续写期间行停在 `running`(没有心跳):这一窗里决定那张卡答 409 `conflict.not_resumable`(行还没落到停驻词),落下之后同一决定照常受理;进程在续写期间退出 ⇒ 直接交既有出路(行被失联收割、卡由兜底收割)。不是门、不是凭据。detail = `leg=<bg|resume|sync> step=<first|again|retry|gave_up> err=<原句>`(不含凭据);计数 = 停驻提交失败的次数(第一笔写 / 再提交的读、写、取消终局写),`gave_up` 非零 = 有一次停驻交给了既有出路,去看那只会话与店。",
+    },
+    "server.park.row-commit-contradicted": {
+        cls: "F",
+        note: "停驻的唯一提交点(`park-row-commit.ts` 的 `commitParkRow`,`leg=bg|resume|sync`)的拒后判之外的那一格:停驻写被店答出「不」,随后读到的行却归本腿、在跑、没挂取消请求 —— CAS 的三件(持有腿 · 在跑或已停在本词上 · 没挂取消)读来都成立而写被拒,店自相矛盾,是不变量破,不是店抖动。本格不猜:当一次店故障处置(不收场、不作废卡、认领留着),交同一条再提交路(当拍一次、心跳节拍续、上界两个判活窗,`server.park.row-commit-deferred` 同计),店答出别的读数即按拒后判收场;一直矛盾 ⇒ 到上界停手、交既有出路(失联收割收行、审批兜底收割收卡)。放行的最坏后果 = 行在续写期间停在 `running`、卡待决到上界。不是门、不是凭据。计数非零 = 本库对同一行的 UPDATE 与 SELECT 答得不一致(读到的不是写判的那一份:读副本 / 隔离级别 / 店的缺陷),去查那只库。detail = `leg=<bg|resume|sync> taskId=<id> word=<suspended|needs_review> status=<读到的词> holder=self cancel=false`(不含凭据)。",
     },
     "server.verifier-pause.card-void-failed": {
         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/metrics.js

@@ -239,7 +239,7 @@ export function createMetrics() {
     m.counter("cost_quota_rejected_total", "Tasks refused because the principal is over its cumulative cost quota");
     m.counter("deny_sweep_resume_blocked_total", "SLA deny-sweep resumes the resume leg refused (every attempt; the deny_sweep_resume_blocked warn is logged once per row and refusal)");
     m.counter("deny_sweep_policy_blocked_expired_total", "approvals the SLA deny-sweep expired because the resume leg refused them for an admission-policy reason (resume_blocked_by_policy: the stored request is refused in this version for good, so the model-continuing deny cannot be delivered; counted once per card, only when this sweep won the settle)");
-    m.counter("submit_ctx_run_release_failed_total", "Submissions whose resume-input write failed AND whose just-claimed run could not be released, by step (terminal|idem_key); the session stays held until REAP_RUN_STALE_SEC (one submit_ctx_run_release_failed warn per failure)");
+    m.counter("submit_ctx_run_release_failed_total", "Submissions whose resume-input write failed AND whose just-claimed run could not be withdrawn (step=withdraw: the store did not delete the run this submission minted); the session stays held until REAP_RUN_STALE_SEC (one submit_ctx_run_release_failed warn per failure)");
     m.counter("deny_sweep_list_failed_total", "SLA deny-sweep ticks whose read of the expired approvals failed (that tick denies nothing; one deny_sweep_list_failed warn per failure)");
     m.counter("deny_sweep_row_failed_total", "SLA deny-sweep rows whose stored request could not be read this tick (a projection-drift throw); that row is not resumed this tick, the rest of the page is swept (one deny_sweep_row_failed warn per failure)");
     m.counter("degraded_total", "Tasks degraded to a cheaper model (1.40), by reason (budget/rate_limit/breaker_open)");

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/observability/run-terminal.js

@@ -175,6 +175,7 @@ export const RESULT_TEXT_LEAVES = {
     "cancelContext.lastEventKind": "verbatim",
     "cancelContext.lastBrainStatus.phase": "verbatim",
     "cancelContext.lastBrainStatus.errClass": "verbatim",
+    "readDenyFloor.message": "verbatim",
 };
 const DROP_LEAF = Symbol("drop-leaf");
 function textLeafAct(treatment) {

package/dist/observability/secret-env-scrub.d.ts

@@ -90,7 +90,7 @@ export declare const SECRET_ENV_SCRUB_SITES: {
     };
     readonly "server.hooks.spawn-env": {
         readonly told: "log";
-        readonly note: "settings hooks 的命令腿(请求带来的命令跑在宿主上)的 env —— 严格名单(`PATH` / `HOME` / 终端 / locale 等十二名)经引擎的 `hostChildEnv` 组合:名单外一律不交,本服务自有凭据任何情况都不交;请求的有效环境层(`settings.env`)作授予叠在上面;请求给工具 shell 的继承词对它不作用";
+        readonly note: "settings hooks 的命令腿(请求带来的命令跑在宿主上)的 env —— 严格名单(`PATH` / `HOME` / 终端 / locale 等十二名)∪ 部署方 `HOOK_ENV_ALLOW` 点名放回的变量,经引擎的 `hostChildEnv` 组合:其余一律不交,本服务自有凭据(名与值副本)任何情况都不交;请求的有效环境层(`settings.env`)作授予叠在上面;请求给工具 shell 的继承词对它不作用";
         readonly remedy: null;
     };
     readonly "server.project-memory.git-subprocess": {

package/dist/observability/secret-env-scrub.js

@@ -20,7 +20,7 @@ export const SECRET_ENV_SCRUB_SITES = {
     },
     "server.hooks.spawn-env": {
         told: "log",
-        note: "settings hooks 的命令腿(请求带来的命令跑在宿主上)的 env —— 严格名单(`PATH` / `HOME` / 终端 / locale 等十二名)经引擎的 `hostChildEnv` 组合:名单外一律不交,本服务自有凭据任何情况都不交;请求的有效环境层(`settings.env`)作授予叠在上面;请求给工具 shell 的继承词对它不作用",
+        note: "settings hooks 的命令腿(请求带来的命令跑在宿主上)的 env —— 严格名单(`PATH` / `HOME` / 终端 / locale 等十二名)∪ 部署方 `HOOK_ENV_ALLOW` 点名放回的变量,经引擎的 `hostChildEnv` 组合:其余一律不交,本服务自有凭据(名与值副本)任何情况都不交;请求的有效环境层(`settings.env`)作授予叠在上面;请求给工具 shell 的继承词对它不作用",
         remedy: null,
     },
     "server.project-memory.git-subprocess": {

package/dist/org-delivery-gate.d.ts

@@ -15,7 +15,9 @@
  *    + 可选 `urgent` 与显示名;不写 `fromSession / fromMode / hopChain`)。本仓不另铸任何记录形。
  *  · **限流是配额店的两个原子动作,各管一件事**:`admitAttempt` 记发件人的每一次尝试(碰目录之前;界住刷目录的速率),
  *    `take` 在同一把锁下判并记 (from→to) 对偶界与收件人聚合界(投递额度)。SQL 两方言各是一个事务,见
- *    `plugins/org-delivery-quota-store.ts` 头注;File / Memory = 单进程。
+ *    `plugins/org-delivery-quota-store.ts` 头注;File / Memory = 单进程。两个动作的拒都带店算的重试秒数,门原样放进 `rate_limited` 的答案里。
+ *  · **答案是 core 闭集的答案加一个本服务的成员**:core 的 `OrgDeliveryOutcome` 对 `rate_limited` 只有码与句;本服务的 wire 另带 `retryAfterSec`,
+ *    所以门交出的是 {@link ServerOrgDeliveryOutcome} —— 对 core 的类型结构上是子型(多一个成员,别的词不变),`rate_limited` 一只词多一个必填成员。
  *  · **收件人的 scope 就是收件人主体串本身**:本服务的引擎 scope = `spec.principal`(`resolve-spec.ts` 落
  *    `auth.principal`;同一事实的推导见 `peer-directory.ts` 的「scope 轴」段)。门不另造编解码。
  *
@@ -33,7 +35,8 @@
  *     本仓不另抄宽度公式。部署没声明收件箱消费方(`no_consumer`)或别的铸信失败 ⇒ 门抛(core:「the gate maps that to its own failure」),HTTP 面答 500,同样没吃额度。
  *  3. **收件箱上界**(`peekCount` 读):满 ⇒ `inbox_full`,在吃配额之前判,满箱不烧发件人的额度。与引擎同主体车道的
  *     `maxQueuedPeerMessages` 同一形(入口处读一次占用);两封并发信最多越界并发数那么多,上界由配额再界一次。
- *  4. **配额**(原子判并记):任一界满 ⇒ `rate_limited`,与第 0 步同一句(不让发件人从拒句里分辨出「收件人这一小时收了多少」)。
+ *  4. **配额**(原子判并记):任一界满 ⇒ `rate_limited`,与第 0 步同一句(不让发件人从拒句里分辨出「收件人这个窗里收了多少」);
+ *     同一个 `retryAfterSec` 口径 —— 配额店答的、到店钟当前窗结束的整秒数(第 0 步与第 4 步读同一口钟、同一道算式,数里也分辨不出是哪一界)。
  *  5. **追加**:`append(收件人 scope, PRINCIPAL_INBOX_HANDLE, 记录)`。店的预删除态拒码(`mailbox.recipient_tombstoned`)
  *     原样转成 `recipient_tombstoned`(core 对这只词的定义:「the store's own pre-delete code, relayed」);其余错误抛。
  * 被拒的投递在任何地方都不追加任何东西(core 契约原句);投递额度(第 4 步)在之后只有追加失败这一种「吃了额度没投到」—— 方向是收紧;
@@ -44,13 +47,14 @@
  * 跨 scope 写径:受理口(`POST /v1/principal-inbox/messages`)只调门,本仓源码里拼得出 `principal.inbox` 这只箱址的只有本文件
  * (`test/org-delivery-gate-single-path.test.ts` 按源码钉)。
  */
-import { type MailboxStore, type OrgDeliveryGate, type OrgDeliveryRefusalCode, type PrincipalInboxConsumer } from "@sema-agent/core";
+import { type CrossPrincipalBody, type MailboxStore, type OrgAuthenticatedSender, type OrgDeliveryGate, type OrgDeliveryOutcome, type OrgDeliveryRefusalCode, type PrincipalInboxConsumer } from "@sema-agent/core";
 import type { OrgMemoryDirectory } from "./org-memory-admission.js";
 import type { OrgDeliveryQuotaPolicy, OrgDeliveryQuotaStore } from "./plugins/org-delivery-quota-store.js";
 /**
  * 跨主体配额(**唯一**的数字源;店只按它数)。默认显著紧于同主体车道(引擎 `PEER_LANE_DEFAULTS`:每发件人突发 30、
- * 每秒回填 0.5):同一对主体每小时 10 封,一位收件人每小时合计 30 封 —— org 里一个吵闹的主体淹不了别人的箱;
- * 一个发件人每小时 60 次尝试(成没成都算)—— 拿收件人串去问组织目录的速率有界(头注「次序」第 0 步)。
+ * 每秒回填 0.5):同一对主体每个挂钟整点桶 10 封,一位收件人每个挂钟整点桶合计 30 封 —— org 里一个吵闹的主体淹不了别人的箱;
+ * 一个发件人每个挂钟整点桶 60 次尝试(成没成都算)—— 拿收件人串去问组织目录的速率有界(头注「次序」第 0 步)。
+ * 「桶」= 店钟对齐的固定窗(窗宽一小时,`floor(店钟 / windowMs)` 一处公式,`plugins/org-delivery-quota-store.ts` 头注),不是滑动的「过去 60 分钟」。
  */
 export declare const ORG_DELIVERY_QUOTA: OrgDeliveryQuotaPolicy;
 /** 收件箱上界(在箱、未被消费方确认的信封数)。与引擎同主体车道的箱上界缺省(`maxQueuedPeerMessages`)同值。 */
@@ -61,6 +65,27 @@ export declare const PRINCIPAL_INBOX_BOUND = 50;
  * `not_member` 一句同时服务「不同 org / 查无此人 / 目录答不上来 / 收件人串不成形 / 发件人主体拼不进信封的发件人位」—— 改它要保持各臂同字节。
  */
 export declare const ORG_DELIVERY_REFUSAL_MESSAGES: Readonly<Record<OrgDeliveryRefusalCode, string>>;
+/**
+ * 本服务的投递答案 = core 的 {@link OrgDeliveryOutcome} 加上额度拒的重试指引:`rate_limited` 一只词必带 `retryAfterSec`(配额店算的、到店钟当前窗结束的整秒数,
+ * ≥ 1),另三只词的答案与 core 的形逐字相同。对 core 的 `OrgDeliveryGate` 契约结构上是子型,所以这只门照样能交给任何读 core 契约的人。
+ * 数只在配额店算一次;HTTP 面把它投影成体里的 `retryAfterSec` 与同值 `Retry-After` 头(`routes/principal-inbox.ts`,不再算)。
+ */
+export type ServerOrgDeliveryOutcome = Extract<OrgDeliveryOutcome, {
+    ok: true;
+}> | {
+    readonly ok: false;
+    readonly code: Exclude<OrgDeliveryRefusalCode, "org_delivery.rate_limited">;
+    readonly message: string;
+} | {
+    readonly ok: false;
+    readonly code: "org_delivery.rate_limited";
+    readonly message: string;
+    readonly retryAfterSec: number;
+};
+/** {@link createOrgDeliveryGate} 交出的门:core 契约的子型,答案是 {@link ServerOrgDeliveryOutcome}。装配点、`ServiceDeps.orgDeliveryGate` 与受理口读这一只型。 */
+export interface ServerOrgDeliveryGate extends OrgDeliveryGate {
+    deliverCrossPrincipal(authedFrom: OrgAuthenticatedSender, toPrincipal: string, body: CrossPrincipalBody): Promise<ServerOrgDeliveryOutcome>;
+}
 export interface OrgDeliveryGateDeps {
     /** org 成员目录 —— **必须**与记忆准入 seam / memory-policy / 共享记忆读面同一个实例(头注)。 */
     readonly directory: OrgMemoryDirectory;
@@ -78,7 +103,7 @@ export interface OrgDeliveryGateDeps {
 /**
  * 活对象(闭包持有目录 / 两只店 / 消费方)⇒ `create*`(CLAUDE.md 工厂命名律)。
  */
-export declare function createOrgDeliveryGate(deps: OrgDeliveryGateDeps): OrgDeliveryGate;
+export declare function createOrgDeliveryGate(deps: OrgDeliveryGateDeps): ServerOrgDeliveryGate;
 /**
  * 箱址的读侧映射也归门(单一属主:箱址常量只在本文件出现,`test/org-delivery-gate-single-path.test.ts` ①):
  * 被扣的跨会话信在收信会话的哪条车道上 ⇄ core 队列键的 `box`。消费方 = `src/peer-inbound-face.ts`。

package/dist/org-delivery-gate.js

@@ -11,6 +11,7 @@ export const ORG_DELIVERY_REFUSAL_MESSAGES = Object.freeze({
     "org_delivery.recipient_tombstoned": "the recipient is being deleted — nothing was delivered",
 });
 const refuse = (code) => ({ ok: false, code, message: ORG_DELIVERY_REFUSAL_MESSAGES[code] });
+const refuseRateLimited = (retryAfterSec) => ({ ok: false, code: "org_delivery.rate_limited", message: ORG_DELIVERY_REFUSAL_MESSAGES["org_delivery.rate_limited"], retryAfterSec });
 async function shareAnOrg(directory, a, b) {
     const [la, lb] = await Promise.all([directory.lookup(a), directory.lookup(b)]);
     if (la.kind !== "granted" || lb.kind !== "granted")
@@ -24,8 +25,9 @@ export function createOrgDeliveryGate(deps) {
     return {
         async deliverCrossPrincipal(authedFrom, toPrincipal, body) {
             const senderPerson = personOf(recoveredSubject(authedFrom.scope));
-            if (!(await deps.quota.admitAttempt(senderPerson, ORG_DELIVERY_QUOTA)))
-                return refuse("org_delivery.rate_limited");
+            const attempt = await deps.quota.admitAttempt(senderPerson, ORG_DELIVERY_QUOTA);
+            if (!attempt.granted)
+                return refuseRateLimited(attempt.retryAfterSec);
             if (!principalShaped(toPrincipal) || !(await shareAnOrg(deps.directory, senderPerson, toPrincipal))) {
                 return refuse("org_delivery.not_member");
             }
@@ -42,8 +44,9 @@ export function createOrgDeliveryGate(deps) {
             }
             if ((await deps.mailbox.peekCount(toScope, PRINCIPAL_INBOX_HANDLE)) >= PRINCIPAL_INBOX_BOUND)
                 return refuse("org_delivery.inbox_full");
-            if (!(await deps.quota.take(senderPerson, toScope, ORG_DELIVERY_QUOTA)))
-                return refuse("org_delivery.rate_limited");
+            const taken = await deps.quota.take(senderPerson, toScope, ORG_DELIVERY_QUOTA);
+            if (!taken.granted)
+                return refuseRateLimited(taken.retryAfterSec);
             let seq;
             try {
                 seq = await deps.mailbox.append(toScope, PRINCIPAL_INBOX_HANDLE, record);

package/dist/owner-faces.d.ts

@@ -31,7 +31,7 @@ import type { SessionOwnerCell } from "./security.js";
 import { type DurableOwnerKey, type Subject } from "./owner-brands.js";
 /** 行资格:调用方对**这一行**的关系(四格,见 {@link qualsOf})。 */
 export type RowQual = "owner" | "open" | "j4" | "anon_tree";
-/** fleet 资格:与行无关的调用方事实 —— 没有身份边界的部署(`dev_open`)、代部署本人说话的 service 凭据(`deployment_token`)、只读 trace 凭据(`trace_read`)。 */
+/** fleet 资格:与行无关的调用方事实 —— 没有身份边界的部署上不报主体的调用方(`dev_open`)、代部署本人说话的 service 凭据(`deployment_token`)、只读 trace 凭据(`trace_read`)。 */
 export type FleetQual = "dev_open" | "deployment_token" | "trace_read";
 /** 资格闭集:行资格 ∪ fleet 资格 ∪ 运维(`operator`,与行无关的调用方事实)。 */
 export type Qual = RowQual | FleetQual | "operator";
@@ -39,7 +39,8 @@ export type Qual = RowQual | FleetQual | "operator";
  * 一次判定的调用方(四格事实 + 部署两格)。铸点闭集:`http/owner-access.ts` 的 `callerOf`(请求口)/ `callerOfDecision`(决定口),`security.ts` 的 `claimCallerOf`(认领面与协议口:不放 fleet、不放运维),别处不手搓。
  *  · `subject` —— 验过的主体(分区键,`owner-brands.ts`;`gatedSubject`;决定口是证明推出的人的主体);载体只带这一格,人经 `personOf(subject)` 读;
  *  · `operator` —— `explicitOperatorOk(personOf(subject))`(运维名册的唯一读法:读人,不读分区),与 `subject` 同一次铸;
- *  · `fleet` —— `dev_open`(装配没接任何身份来源)/ `deployment_token`(出示 service 凭据、不报主体、部署没声明关掉)/ 缺席;两来源互斥;
+ *  · `fleet` —— `dev_open`(装配没接任何身份来源 ∧ 不报主体)/ `deployment_token`(出示 service 凭据、不报主体、部署没声明关掉)/ 缺席;两来源互斥,报了主体 ⇒ 恒缺席
+ *    (唯一读法 `http/principal-gate.ts` 的 `actsForDeployment`:报了主体的调用方在每一口都是那位主体);
  *  · `traceRead` —— 出示了只读 trace 凭据;
  *  · `principalRequired` / `multiTenant` —— 部署形表的两只谓词(身份前门的条件 / `j4` 的条件)。
  */
@@ -111,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";
 /**
@@ -125,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 列,见模块头注)。 */
@@ -384,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"];
@@ -455,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" },