@sema-agent/server 7.150.0 → 7.152.0

package/dist/observability/fail-open.js

@@ -36,13 +36,13 @@ export const FAIL_OPEN_TAGS = {
         cls: "F",
         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 去查记录。",
     },
-    "server.workflow-live-receipt.channel-unreadable": {
+    "server.workflow-park-holder.read-failed": {
         cls: "F",
-        note: "活 run 收下 workflow 停驻卡的决定之后,本进程回执簿(`parked-decide.ts` 的 `holdLiveReceipt`)等那条 run 的引擎观察通道收场来删簿;等的那一读拒 ⇒ 按收场删掉这条 run 的回执。放行的最坏后果:那条 run 仍在跑、驱动还在等并发槽时,同一决定重点一次答 409 `decide.claim_lost` 而不是首张回执(卡此刻仍 pending,重读列表再决);不重复执行、不放宽任何判定。",
+        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 查。",
     },
     "server.workflow-park-decision.card-unreadable": {
         cls: "F",
-        note: "起跑读者(`parked-decide.ts` 的 `heldWorkflowParkDecisions`,每一只起跑器开跑前一次)读某条已受理的 workflow 子代决定所属的那张卡时 checkpoint 店抛 ⇒ 这一跑**不带**这条决定,行留着给下一跑。放行的最坏后果:这一跑里宿主若续跑那条 workflow run,子代按同一个 token 再停驻一次(卡仍 pending,决定仍在,下一跑照带)—— 方向是少交付一次,不是错交付:这一读失败不代表引擎随后那一读也失败,而引擎对「卡已不 pending、却拿到一条决定」的序数会当确认结算,所以读不出时绝不照供。计数持续非零 = checkpoint 店对这张卡读不出(库故障 / 行坏 / 写者版本更新),按 detail 的 `runId=`(受理那一刻的持有者)去查。detail = `runId=<留存锚> err=<原句,经记录器脱敏>`。",
+        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=<原句,经记录器脱敏>`。",
     },
     "server.workflow-park-decision.store-unreadable": {
         cls: "F",
@@ -78,7 +78,7 @@ export const FAIL_OPEN_TAGS = {
     },
     "server.run-store.file-active-claims-unreadable": {
         cls: "P-DEBT",
-        note: "`FileRunStore.hydrate()` 的第二处 `readdirSync(runs/active/)`(claim 平面 = 单活索引)失败,且 `RUN_STORE_STRICT_HYDRATE` 关(缺省)⇒ 服务照常起动、单活索引为**空**。放行的后果两条,都不报错:① 已有 run 行仍可读(`GET /v1/runs/:id` 照常答),但此后对这些会话的审批决定在请求里同步跑完、却找不到要更新的 run 行 —— run 行停在决前的 `suspended`;② 读单活索引的各处读到「没人占用」—— `getActiveTaskId` 恒答空,例如会话同步推送前的「会话有在飞 run」检查(与 `server.run-store.file-hydrate-unreadable` 同一句错话:「证不出有占用 ⇒ 没有占用」,只是换了一个盘面);新提交不读这张索引,claim 文件完好时仍按盘上的 claim 裁定,不受影响。同一条债的另一个盘面:缺省不拒启是刻意保留的行为,所以留作 P-DEBT —— error 级启动日志(`file_run_store_active_claims_unreadable`,带 `runs/active/` 绝对路径)早已在,本计数补的是遥测轴(此前 `runs/` 臂有计数、这一臂没有)。`RUN_STORE_STRICT_HYDRATE=on` 把这一格换成 fail-closed 启动门,本计数因此只在缺省 off 档的真放行时产生(拒启那一形不记)—— 读遥测时「计数为零」也可能是部署开了拒启门、根本起不来。",
+        note: "`FileRunStore.hydrate()` 的第二处 `readdirSync(runs/active/)`(claim 平面 = 单活索引)失败,且 `RUN_STORE_STRICT_HYDRATE` 关(缺省)⇒ 服务照常起动、单活索引为**空**。放行的后果两条,都不报错:① 已有 run 行仍可读(`GET /v1/runs/:id` 照常答),但此后对这些会话的审批决定在请求里同步跑完、却找不到要更新的 run 行 —— run 行停在决前的 `suspended`;② 读单活索引的各处读到「没人占用」—— `getActiveTaskId` 恒答空,例如会话同步推送前的「会话有在飞 run」检查、会话头探针 `GET /v1/sessions/:id/head` 的 `activeTaskId`(这一档里答 `null`,而提交照旧按盘上的 claim 文件 409)(与 `server.run-store.file-hydrate-unreadable` 同一句错话:「证不出有占用 ⇒ 没有占用」,只是换了一个盘面);新提交不读这张索引,claim 文件完好时仍按盘上的 claim 裁定,不受影响。同一条债的另一个盘面:缺省不拒启是刻意保留的行为,所以留作 P-DEBT —— error 级启动日志(`file_run_store_active_claims_unreadable`,带 `runs/active/` 绝对路径)早已在,本计数补的是遥测轴(此前 `runs/` 臂有计数、这一臂没有)。`RUN_STORE_STRICT_HYDRATE=on` 把这一格换成 fail-closed 启动门,本计数因此只在缺省 off 档的真放行时产生(拒启那一形不记)—— 读遥测时「计数为零」也可能是部署开了拒启门、根本起不来。",
     },
     "server.fork-routing.placed-probe-host-error": {
         cls: "F",
@@ -164,17 +164,13 @@ export const FAIL_OPEN_TAGS = {
         cls: "F",
         note: "CC 规则导入票的**认领回滚**失败(认领之后的某一步没成 ⇒ 本该把认领放回去,而这次放回本身也抛了)。放行的最坏后果 = 这张票留在已认领态、属主这一轮不能重试 —— 恰好等于加认领回滚**之前**的行为,不是新损失;票随 TTL 自然消失,属主重走一次 prepare 即可拿新票(导入按 core 的设计幂等:同一条规则再兑付只是同一个 dot 的重放)。方向上没有任何权限被放宽(规则**没有**落地才走到这条臂),故 F 类;必须留痕,否则「票为什么突然不能用了」在遥测里没有任何痕迹。",
     },
-    "server.approvals.rule-suggestions-cell-unreadable": {
-        cls: "F",
-        note: "运维待批队列(`GET /v1/approvals` / `/stream`)的某一行,`checkpoint.rule_suggestions` 这一格**不是合法 JSON 文本**(手改过的行 / 未来列语义漂了 / 回滚残留)。放行的最坏后果 = **这一行**的「不再询问」候选缺席(展示/分诊材料,永不参与 resume、也不是任何判据),队列其余部分照常;不放行的代价是整只 `rows.map` 抛出 ⇒ 一行坏 cell 打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远空)。故 F 类,但必须留痕:静默吞掉之后「候选为什么消失了」在遥测里没有任何痕迹,而本键存在的全部理由就是「缺席 = 真的没有候选」。",
-    },
     "server.approvals.risk-descriptor-cell-unreadable": {
         cls: "F",
-        note: "运维待批队列(`GET /v1/approvals` / `/stream`)的某一行,`checkpoint.risk_descriptor` 这一格**不是合法 JSON 文本**(手改过的行 / 回滚残留 / 列语义漂;与同一 `rows.map` 里的 `rule_suggestions` 是同族坏法,两方言都是 TEXT 列)—— 或解得出却不是一只对象;`DB_BACKEND=local` 上同一读面读存储体里门上的 `gate.riskDescriptor`,在场却不是一只对象同样计在本 tag(两孪生同一只形读者 `checkpoint-store-face.ts` 的 `readRiskDescriptorBody`,修前 local 把原值原样上 wire)。放行的最坏后果 = **这一行**的分诊 descriptor 落 null:severity 折 0 排到有 descriptor 的行之后、披露位(`allowRuleShadowed`;7.117.0 前叫 `shadowedRule`)无可脱敏、读面派生的 `governanceForced` 徽章不亮 —— 三者都是**展示/分诊**,不是执法判据(门早已 park,真按 `shellGateDoctrine` 判的 `active-run-conflict.ts` 读的是 checkpoint blob 的 `get()`,不经本读面),且 `governanceForced` 的成文语义本就是「缺席 = 没有治理来源的**证据**」。不放行的代价是整只 `rows.map` 抛出 ⇒ 一行坏 cell 打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远空),连同其余所有行一起消失。故 F 类;tag 与候选那格**分开计**,并计会让「哪一格在坏」在遥测里读不出来。",
+        note: "运维待批队列(`GET /v1/approvals` / `/stream`;两孪生同一只投影 `checkpoint-store-face.ts` 的 `buildQueueActionFacts`)的某一行,停驻文档门上的风险描述(引擎派生 `checkpointIndexFacts` 那一格,只在审批门上)**在场却读不成一只对象**(手改 / 带外写者写下的文档)。7.152.0 起只有这一座:描述不再落列,队列行在读时从续跑执行的同一次整行解码取(此前 SQL 孪生读 `checkpoint.risk_descriptor` 列、列文本坏也计在本 tag;那一列随一次性迁移 M54 删)。放行的最坏后果 = **这一行**的分诊 descriptor 落 null:severity 折 0 排到有 descriptor 的行之后、披露位(`allowRuleShadowed`)无可脱敏、读面派生的 `governanceForced` 徽章不亮 —— 三者都是**展示/分诊**,不是执法判据(门早已 park,真按 `shellGateDoctrine` 判的 `active-run-conflict.ts` 读的是 `get()`,不经本读面),且 `governanceForced` 的成文语义本就是「缺席 = 没有治理来源的**证据**」。不放行的代价是一行坏描述打掉整个租户的队列。故 F 类。计数口径:SQL 孪生每份字节每进程一次(动作事实按字节记忆),local 每次列表一次。",
     },
     "server.approvals.park-row-blob-unreadable": {
         cls: "F",
-        note: "S-700(`stores-sql/checkpoint-store-sql.ts` 的 `readParkRowActionCell`):运维待批队列(`GET /v1/approvals` / `/stream`)的某一行,`checkpoint` 列里寄存行的 **`pendingAction` 子树**(NP-3 / 7.100.0 起引擎内只取这一棵、整只快照不出库;只为 park 行事实 `requiresRealApproval` / `ruleOffersAbsence` / `mandated`(S-663 二段,core #1079)/ `mandate`(S-721)/ `origin`(S-755)而读 —— 事实位的真源是 `approval-card.ts` 的 `ParkRowFacts`)**在场却不是一只对象**(JSON `null` 字面 / 串 / 数 —— 手改 / 迁移脚本改过)。子树**缺席**(SQL NULL:成员不在,或整只文档不是对象 —— 后者 `get()` 照旧拒;MariaDB 文本承载上的非 JSON 字节同样答 SQL NULL)⇒ 事实缺席、不计数。放行的最坏后果 = **这一行**的 park 行事实(`ParkRowFacts` 各位)缺席(展示/分诊材料;core 定性 display metadata,resume 的带子读 gate 自己的位),队列其余部分照常 —— 而这一行本来就 resume 不了(`get()` 对同一格拒)。不放行的代价是整只 `rows.map` 抛出 ⇒ 一行坏 blob 打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远空),与同一 `rows.map` 里 `rule_suggestions` / `risk_descriptor` 两格同族同判。故 F 类;tag 与那两格**分开计**(哪一格在坏要读得出来)。计数非零 = 这一行的 decide 同样读不动(`get()` 对同一格拒),去按 session 查那一行。 7.144.0 起同 tag 另有一座:停驻行的**整行读**(`readStoredRow`;按快照摘要记忆,未命中才读)—— 运维队列行的判决 `rowVerdict` 与技能卡两位、7.145.0 起还有收件箱 / 任务视图 `listByScope` 的行投影,同经这一只读法、同一失败方向(行级隔离):整行解不出 ⇒ 判官对读回的原样值作答(恒 `damaged`),行照列、带判决;体是对象但 core 摘要读不动(`{}` / 缺 `state` 等手改行)⇒ 判官对这只对象作答;两形都只丢摘要派生的位(队列行的技能卡两位 / 收件箱行的摘要键,收件箱行退回列组事实),逐次计、不进记忆,一行坏体在子树与整行两读上各计一次。修前收件箱对同一行整张拒(500 / 503)。 (`member=gate` 那第二座随 core 7.55.0 #1468 P1 阶段二退役:队列行的卡与到期分法改读 `approval_card` / `gate_kind` 两列 —— 写口与 M29 回填同一只派生落下的格 —— 本读面不再读 blob 的 `gate` 子树。)(S-2076 的 `readParkedSkillCardFacts` 两座已由上面那次 `projectStoredRow` 整行读取代,树上零命中。)",
+        note: "运维待批队列(`GET /v1/approvals` / `/stream`)、收件箱 / 任务视图(`listByScope`)与按会话读口的某一行,停驻行的**整行读**(`stores-sql/checkpoint-store-sql.ts` 的 `readStoredRow`;队列行的全部动作事实 —— 工具名、绑定、入参、卡、描述、候选、bidi 位、park 行事实、`checkpointId`、技能卡两位、判决 —— 都出自这一次解码,两孪生同一只投影 `buildQueueActionFacts`)读不动:字节解不出 ⇒ 判官对读回的原样值作答(恒 `damaged`);体是对象但 core 摘要读不动(`{}` / 缺 `state` 等手改行)或 core 的投影自己抛 ⇒ 判官对这只对象作答。行照列、带判决,动作事实 `null` / 缺席(与 local 孪生同形),逐次计、不进记忆。放行的最坏后果 = **这一行**少了动作事实(这样的行续跑同样读不动它 —— `get()` 对同一份字节拒),队列其余部分照常;不放行的代价是一行坏字节打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远停在旧帧)。故 F 类。7.152.0 起不再有「`pendingAction` 子树」那一座(引擎内的成员提取退役,同一份文档只有一只 parser)。计数非零 = 这一行的 decide 同样读不动,去按 session 查那一行。",
     },
     "server.approvals.queue-row-agent-unreadable": {
         cls: "F",
@@ -274,7 +270,7 @@ export const FAIL_OPEN_TAGS = {
     },
     "server.approvals.active-run-conflict-material-unavailable": {
         cls: "F",
-        note: "A-057.47:`buildActiveRunConflict` 的材料装配段(getRun / turnActivity / peekPendingScope / findPendingTokenBySession / checkpoint `get`)任一失败 ⇒ 整段退化成裸 409(只剩 error + errorCode + activeTaskId),`activeTaskStatus` / `msSinceLastActivity` / `pendingGate`(kind·decidePath·governanceForced·checkpointId)全部蒸发。放行的最坏后果 = **展示/分诊**面缺料:壳画不出「这条 run 卡在哪道门、去哪儿决」,人退回 `POST /v1/runs/{activeTaskId}/cancel` 这条保底真路 —— 不参与任何门/CAS/resume 判定(执法面读的是 checkpoint blob 的 `get()`,不经本材料;与 census 第 21 行同一条判据),故 F 类。方向刻意不改:本材料是 best-effort 增强,让它抛会把一次 store 抖动变成整个 409 路径的 500(顶注第 11 行逐字成文「store 面任何失败都不得挡 409 本体」)。必须留痕的理由:本文件零 logger 席、pool 层无 per-query 错误日志、调用侧(tasks.ts / runs.ts / server.ts 五处)因本函数恒不 reject 结构上拿不到信号 ⇒ 「approval 出路材料系统性丢失」此前在遥测里与「一切正常」同形;滚动升级期 `checkpoint-store-sql.ts` 的 version-too-new throw 与 strict parseJson 也一并被吞在这里。",
+        note: "A-057.47:409 `conflict.session_active_run` 的材料读失败,分两层(7.152.0 起):① 持有者那一行读不出(`refusalOccupantOf` 的 getRun —— 提交 / 续跑面的 `buildActiveRunConflict`、删除口、run 外回退口三处同调)⇒ 体只剩 error + errorCode + activeTaskId,`activeTaskStatus` / `msSinceLastActivity` / `pendingGate` 不在;② 持有者行读到了而出路材料读不出(turnActivity / peekPendingScope / findPendingTokenBySession / checkpoint `get`)⇒ 占用两键照留,只少 `msSinceLastActivity` 或 `pendingGate`(kind·decidePath·governanceForced·checkpointId)。放行的最坏后果 = **展示/分诊**面缺料:壳画不出「这条 run 卡在哪道门、去哪儿决」,人退回 `POST /v1/runs/{activeTaskId}/cancel` 这条保底真路 —— 不参与任何门/CAS/resume 判定(执法面读的是 checkpoint blob 的 `get()`,不经本材料;与 census 第 21 行同一条判据),故 F 类。方向刻意不改:本材料是 best-effort 增强,让它抛会把一次 store 抖动变成整个 409 路径的 500(顶注第 11 行逐字成文「store 面任何失败都不得挡 409 本体」)。必须留痕的理由:本文件零 logger 席、pool 层无 per-query 错误日志、调用侧(tasks.ts / runs.ts / server.ts 五处)因本函数恒不 reject 结构上拿不到信号 ⇒ 「approval 出路材料系统性丢失」此前在遥测里与「一切正常」同形;滚动升级期 `checkpoint-store-sql.ts` 的 version-too-new throw 与 strict parseJson 也一并被吞在这里。",
     },
     "server.engine-notice.durable-append-failed": {
         cls: "F",
@@ -328,14 +324,18 @@ export const FAIL_OPEN_TAGS = {
         cls: "P-DEBT",
         note: "#296(A-052.2,clay 裁定 C-R21):`REMOTE_EXEC=ssh` 且**两只主机密钥旋钮都缺席**(`SSH_HOST_FINGERPRINT` / `SSH_KNOWN_HOSTS`)⇒ 本次连接接受**任何**主机密钥,等价 `ssh -o StrictHostKeyChecking=no`。放行的最坏后果:一次中间人拿到这条会话的**全部命令、全部产物、以及 agent 在那台机器上的全部动作**(私钥仍在控制面手里、拿不走,design/61 §5 #2)。⇒ 保护型欠账,不是体验回退。**方向是裁定的、不是遗漏**:本 lane 的既有部署形是「AI 编排批量部署到一批 SSH 可达的机器」,那些机器的指纹通常不在任何 known_hosts 里,默认拒连 = 一次静默的可用性断裂;C-R21 裁「在场即严格,缺席即响亮」。补偿三件:①**每连接**一条 `ssh_host_key_unverified` warn(不是每进程一次 —— 一条长期裸连的 lane 必须在每条连接上都看得见);②本计数(遥测里「有多少条连接是裸连」是一个可观测的数,曲线应当只降不升);③两旋钮任一在场即**严格校验、不符拒连**(拒因带两半指纹 + `ssh-keyscan` 指路)。终局 = 部署把旋钮配上(那时本计数归零);旋钮不配而想收紧的部署级开关(「无旋钮即拒启」)是下一件,不在 C-R21 射程。",
     },
-    "server.approval.park-redemption-cap-refused": {
+    "server.approval.parked-decision-not-recorded": {
         cls: "F",
-        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;在飞的单飞句柄不占帽、永不被逐。",
+        note: "S-1054 α(`tool-approval.ts` 的 `recordParkedOutcome`,停驻赎回那一飞的落行步):停驻门**已经受理**了这次决定(续跑已开始),而把它的记录(决议向 · 署名 · 理由 · 回决幂等键 · 出处)落到仍 `PARKED` 的问行上没成 —— 店错 / 超时 / 行出了门判过的属主域 / 这把键已被同 task 另一只问占着(detail 带 `reason`)。放行的最坏后果 = 这一问在耐久决断口上的**同键回放**读不到这把键:同键重发得到 `409 conflict.ask_decided`(回显门上站着的那次决定,决议向 / 时刻 / 理由取自门,无署名),而不是 200 回放;审计面少一份署名。决定本身零影响(终局恒在停驻门上,门已决);不改判、不重赎、不双兑。计数非零 = 问账店在受理之后写不动了,运维要去看店。",
     },
     "server.approvals.stale-echoed-token-unreadable": {
         cls: "F",
         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 折叠两个判定的输入,长期抖动必须在遥测显形。",
     },
+    "server.resume.cancel-answer-row-unreadable": {
+        cls: "F",
+        note: "续跑腿(`http/resume-legs.ts` 的 `landedTerminalRow`)两只本腿铸取消终局的取消臂(`checkpoint.resume_aborted` 臂 / 交给引擎之后抛出的取消臂):驱行终局之后读回那一行,200 体的词 / 码 / 句读行上落下的那一份(run 店终局写先到者得,先到的可以是收割 / 判死),那一读抛。放行 = 体读本腿铸的那一份取消终局(读回之前的形);最坏后果 = 先到者不是本腿时体上的码 / 句与 `GET /v1/runs/:id` 不同 —— 行、账本、读面一个字节不受它管,门 / 裁决不读这只体 ⇒ F 类。detail `task=<taskId> arm=<resume-aborted|thrown-cancel> err=<原句>`;计数 = 多少次答复没读到行。",
+    },
     "server.resume.reopen-confirm-unreadable": {
         cls: "F",
         note: "S-447(#60 M2 自查项,`http/resume-legs.ts` 的 `confirmCheckpointReopened`):续跑腿交回一条没 park 的失败结果后(7.129.0 起每一条都问,不再只在三个重开码上问)按 **token** 复核「这张 checkpoint 是不是又 pending 了」,这一读抛(库拖/版本太新/店不可达)。**方向本来就是 fail-closed**:读不出 ⇒ `return true` ⇒ 「不写任何终局、重新 park」(`:1206-1212` 头注已把取舍与有界代价写死:错 park 由 `reapSuspended` 兑,错终局会孤儿化一张活 park 到 TTL)—— 所以这条腿不是 P 类,缺的只是**留痕**。放行的最坏后果 = 多一次多余的 re-park(一张已经被决掉的卡重新挂到 reaper 窗里),人面上是「这条续跑没动」而不是谁被放行了。必须登记的理由是 **uniformity**:同文件三只同形读(`:249` `server.approvals.stale-echoed-token-unreadable` · `:288` `server.approvals.stale-current-pending-unreadable` · 本腿)中只有它是黑的,于是「店一直读不出所以每条续跑都在白白 re-park」与「一切正常」在遥测上同形。计数非零 = 这台机器的 checkpoint 店在拖,运维要去看库。",
@@ -516,6 +516,10 @@ export const FAIL_OPEN_TAGS = {
         cls: "F",
         note: "S-1195(7.119.0;`plugins/snapshot-bucket-presence.ts` 的 `ensureSnapshotBucket`,boot 期核一次快照桶 `SESSION_SNAPSHOT_BUCKET`;S-2021〔7.136.0〕起同一只探针、同一条规则、同一个 tag 也核 k8s 车道的工作区快照桶 `WORKSPACE_SNAPSHOT_BUCKET`——detail 里的 `bucket=` 就是被核的那只桶名;detail = `bucket=… endpoint=<buildDisplaySafeUrl 的显示形> <HTTP 状态 | request failed: 错类>`):presigned 列举对 `MINIO_ENDPOINT` **连不上 / 403 / 5xx / 没有 NoSuchBucket 的 404**,或探针到窗尾一次都没答过(detail 写 `probe still pending when the window ended`)⇒ **证明不了桶缺**,不拒启、照常起服(只有 404 + `NoSuchBucket` 才是「缺」,那一形窗内重试、到窗拒启,不走本 tag)。三问:①错误落到哪 —— 本 tag 的计数 / 探针行 / 记录器的一次性 warn,detail 带端点显示形与状态或错类;②谁受害 —— 桶其实不存在、或凭据不能列举的部署:之后每一次快照 offload 写与 SendUserFile 私有 presigned 请求会答 404 / 403,孤儿 sweep 每分钟一条失败,运维读到的是一串失败请求而不是「桶没建」(与 7.118.x 的既有形状同形,不是新损失);工作区快照桶则是每条 run 读 `latest` 得 404/403——404 + NoSuchBucket 在运行期由 `workspace_snapshot_bucket_missing` 响亮拒绝,403/5xx 走既有的非 404 读失败臂(同样响亮);③缺席倒向哪边 —— 倒向**放行起服**:没有证据既不拒启、也不伪造「桶在场」或「桶缺」,不是门 / 权限 / 凭证。最坏后果 = 缺桶的部署晚一步才暴露;不放行的代价是对象存储一次抖动 / 一次 403 就让整只服务起不来。计数非零 = 这台部署启动时没能确认快照桶,按 detail 的端点与状态去核对网络 / 凭据 / 桶。",
     },
+    "server.session-blob-namespace.claim-unproven": {
+        cls: "F",
+        note: "`plugins/session-blob-namespace.ts` 的 `establish`(开店时对会话 blob 命名空间认领一次:`plugins/store-backend.ts` `openStoreBackendWithFallback` 在 SQL 店开好之后调,一次尝试、不在 `STORE_LOCK_WAIT_MS` 窗里重试,每个请求的上界与快照桶探针同一只常量 `SNAPSHOT_BUCKET_PROBE_TIMEOUT_MS`;detail = `bucket=… prefix=<SESSION_SNAPSHOT_PREFIX 的显示形 | unset> endpoint=<buildDisplaySafeUrl 的显示形> <claim read answered HTTP <状态> | claim write answered HTTP <状态> | the claim just written does not read back | claim request failed: 错类>`):认领物件 `{SESSION_SNAPSHOT_PREFIX}blob-namespace-claim` **读不动 / 写不进 / 连不上 / 写了读不回** ⇒ 证明不了这只命名空间是不是本库的,不拒启、照常起服(只有读到别的库的认领才是「不是」,那一形开店即拒、不走本 tag)。三问:①错误落到哪 —— 本 tag 的计数 / 探针行 / 记录器的一次性 warn;数据轴不随之放开:之后每一次删除(附件孤儿清扫、附件释放、文件历史清扫、退役 blob 清扫)各自重读认领,读不成本库的就拒删,抛出点名桶、前缀旋钮与该授权限的拒句(响亮;那是 fail-closed,不计本 tag);②谁受害 —— 引擎的键缺认领物件 GetObject / PutObject 权限的最小权限部署,或起服那一刻对象存储不通的部署:附件与文件历史的字节不再被回收(桶只涨不减),直到权限补齐或存储答复 —— 恢复后的第一次删除当场认领(缺 ⇒ create-only 写、回读相符)再删,读到别的库的认领 ⇒ 拒删、不改写;③缺席倒向哪边 —— 倒向**放行起服**:没有证据既不拒启,也不当作「是本库的」去删任何字节,不是门 / 权限 / 凭证。最坏后果 = 回收停摆到权限补齐(存储成本,不是数据丢失);不放行的代价是对象存储一次抖动 / 一条缺的权限就让整只服务起不来。计数非零 = 这台部署启动时没能确认命名空间的归属,按 detail 的端点与原因去核对网络 / 凭据 / 认领物件的权限。",
+    },
     "server.fleet.serving-lease-unconfirmed": {
         cls: "R",
         ruling: "C-R296",
@@ -558,7 +562,11 @@ export const FAIL_OPEN_TAGS = {
     },
     "server.sandbox-egress.policy-gap": {
         cls: "P-DEBT",
-        note: "k8s 车道沙箱出网的起服自检(`plugins/remote-env-k8s.ts` `checkSandboxEgressPolicy` 读节点表与沙箱 ns 的 NetworkPolicy,判法 `sandbox-egress-policy.ts` `sandboxEgressGaps`;起服一次、不挡起服)读出一个缺口 —— 某节点的 InternalIP / ExternalIP 落在一条放行 ipBlock 内(`kind=node_address_open`)、没有策略以 Egress 选中沙箱 pod(`kind=policy_absent`)、pod 保留 IPv6 而策略层担保不了 v6(`kind=ipv6_enabled`)、节点表或策略表读不到(`kind=unreadable what=nodes|networkpolicies`)⇒ 车道**照常起**,每个缺口一行 `sandbox_egress_policy_gap`(带后果句与去哪改)。归 P 类:出网策略是保护面,缺口意味着沙箱里的代码可能够到节点上的服务;归 DEBT 的理由:修法都在集群配置里(节点地址点名、kubelet 放行 v6 sysctl、CNI 的 v6 执行、RBAC),本服务改不了,而拒起车道会让缺省单节点装法(恒有 `ipv6_enabled`)升级即停摆沙箱执行 —— 车道自己的隔离(VM 边界、零 SA token)仍在。放行的最坏后果 = 读出缺口的那一面照旧可达,直到运维按行里的后果句改配置。计数非零 = 这台部署的沙箱出网面有读得出的缺口。读不出的面(宿主 DNAT 发布端口、「pod 所在节点恒放行」的实现差异、CNI 根本不执行策略)不在本 tag 的射程里。",
+        note: "k8s 车道沙箱出网的起服自检(`plugins/remote-env-k8s.ts` `checkSandboxEgressPolicy` 读节点表与沙箱 ns 的 NetworkPolicy,判法 `sandbox-egress-policy.ts` `sandboxEgressGaps`;起服一次、不挡起服)读出一个缺口 —— 某节点的 InternalIP / ExternalIP 落在一条放行 ipBlock 内(`kind=node_address_open`)、没有策略以 Egress 选中沙箱 pod(`kind=policy_absent`)、pod 保留 IPv6 而策略层担保不了 v6(`kind=ipv6_enabled`)、节点表或策略表读不到(`kind=unreadable what=nodes|networkpolicies`:RBAC 缺 / API 不可达 / 答体不成形;**集群 API 凭据缺不在其内** —— 凭据缺是起服拒 `config.k8s_api_credentials_missing`,自检不发、不记入本 tag,这一臂已退役)⇒ 车道**照常起**,每个缺口一行 `sandbox_egress_policy_gap`(带后果句与去哪改)。归 P 类:出网策略是保护面,缺口意味着沙箱里的代码可能够到节点上的服务;归 DEBT 的理由:修法都在集群配置里(节点地址点名、kubelet 放行 v6 sysctl、CNI 的 v6 执行、RBAC),本服务改不了,而拒起车道会让缺省单节点装法(恒有 `ipv6_enabled`)升级即停摆沙箱执行 —— 车道自己的隔离(VM 边界、零 SA token)仍在。放行的最坏后果 = 读出缺口的那一面照旧可达,直到运维按行里的后果句改配置。计数非零 = 这台部署的沙箱出网面有读得出的缺口。读不出的面(宿主 DNAT 发布端口、「pod 所在节点恒放行」的实现差异、CNI 根本不执行策略)不在本 tag 的射程里。",
+    },
+    "server.sandbox-credentials.probe-unanswered": {
+        cls: "F",
+        note: "k8s 车道每条 run 铸环境之前读一次集群 API 凭据(`boot/execution-env.ts` `createK8sRunEnvFactory` ← `plugins/remote-env-k8s.ts` `apiCredentialReading`:判官说缺 ⇒ 拒;一次 SelfSubjectAccessReview 答 401 ⇒ 拒;答 2xx ⇒ 放行),而这一次探问**没有证出结论**(HTTP 403 / 5xx / 其余非 2xx 非 401、请求抛 / 超时;detail = `namespace=<ns> HTTP <状态> | <错误句>`)⇒ 这条 run 的环境照铸,凭据到底行不行由车道自己的连接答(pod 创建被 401 / 403 拒 ⇒ 响亮的 `shell_unavailable`、瞬时的 API 抖动在车道自己的重试界内重来)。只有正面证据才拒 —— 为一次没答的探问拒 run,会把每次 API 抖动变成失败的 run,把没给已认证调用方留 SSAR 权限的集群变成永远起不了 run。最坏后果 = 凭据真已失效而探问恰好没答的那条 run,落回修前的形(每条 Bash `shell_unavailable`、run `completed`)—— 可用性 / 可见性,不是门 / 凭据的放宽(没有沙箱、没有执行、没有凭据被多给一份)。归 F。计数持续非零 = 这台部署的服务账号问不了 SelfSubjectAccessReview 或 API 常不可达,按 detail 核。",
     },
     "server.fleet.announce-reply-unreadable": {
         cls: "P-DEBT",
@@ -592,7 +600,7 @@ export const FAIL_OPEN_TAGS = {
     },
     "server.store-durability.evidence-unreadable": {
         cls: "F",
-        note: "店的持久性起服取证(`store-posture.ts` `captureStoreEvidence`,起服第 2 段段首一次):`/proc/self/mountinfo` 读不出(`why=mountinfo_unreadable err=<码>`)/ 有读不懂的行(`why=mountinfo_malformed lines=<n>`)/ 一根的路径展不平成物理路径(`why=path_unresolvable err=<码> path=<路径>`)/ 挂载表读得出、却找不到走那条路径看见的那一只挂载(`why=mount_unresolved path=<路径>`:空表、同父同点的影子挂载)⇒ 那几根(读不出挂载表时是三根全部)判 `unknown`。只影响自报:能力位 `store.durability`、`/health.store.durability`、诊断 `storeDurability.roots` 如实说 `unknown`,起服布线审计对 `unknown` 只 warn、不拒启。放行的最坏后果 = 一只真落在易失介质(容器可写层 / emptyDir)上的 local 数据根因证据读不到而报 `unknown`、照常起服 —— 与本版之前「按后端种类恒报持久」同向且更诚实,不开门、不碰凭据。计数非零 = 本进程读不到 / 读不懂自己的挂载表(受限 procfs、挂载形不常见)或路径上有权限竞态。",
+        note: "店的持久性起服取证(`store-posture.ts` `captureStoreEvidence`,起服第 2 段段首一次):`/proc/self/mountinfo` 读不出(`why=mountinfo_unreadable err=<码>`)/ 有读不懂的行(`why=mountinfo_malformed lines=<n>`)/ 一根的路径展不平成物理路径(`why=path_unresolvable err=<码> path=<路径>`)/ 挂载表读得出、却找不到走那条路径看见的那一只挂载(`why=mount_unresolved path=<路径>`:空表、同父同点的影子挂载)⇒ 那几根(读不出挂载表时是三根全部)判 `unknown`。只影响自报:能力位 `store.durability`、`/health.store.durability`、诊断 `storeDurability.roots` 如实说 `unknown`,起服布线审计对 `unknown` 只 warn、不拒启。放行的最坏后果 = 一只真落在易失介质(容器可写层 / emptyDir)上的 local 数据根因证据读不到而报 `unknown`、照常起服 —— 与本版之前「按后端种类恒报持久」同向且更诚实,不开门、不碰凭据。计数非零 = 本进程读不到 / 读不懂自己的挂载表(受限 procfs、挂载形不常见)或路径上有读不出的段(没有搜索权限 / 链接成环 —— 规范形读不出即抛,不当成「还不存在」)/ 权限竞态。",
     },
     "server.remote-write.staging-dir-left": {
         cls: "F",
@@ -600,11 +608,11 @@ export const FAIL_OPEN_TAGS = {
     },
     "server.resume-anchor.capture-failed": {
         cls: "F",
-        note: "回退锚(`resumeAt` 的提示词 / 助手文本手柄)写入失败 —— 四条腿同一只写法 `runs.ts` 的 `settleResumeAnchor`:流式腿(`POST /v1/tasks/stream`,done 帧之前 / 断连收尾时 await)、同步腿(非流式 `POST /v1/tasks` 的 plain 形,200 应答之前 await)、后台腿(`POST /v1/runs`)、续跑腿。锚店写抛(库抖 / 表缺 / 盘满),或单行店操作期限(`BASELINE_IO_DEADLINE_MS`,2 s;与项目指令基线读写同一只数、同一只 `withinIoDeadline`)内没落定(锚店挂住:锚店的写口自己不带期限)⇒ 这一次提示词(或这一轮助手文本)此刻没有回退手柄,run 照常收尾、终帧照发、不改任何终局;到期只放手不取消,那次写照常在飞、迟到落定的锚照样可用(迟到的失败被吞,不重复计数)。放行的最坏后果 = 用户拿这次 run 的 taskId 去 `resumeAt` 得 404 `resume_at.unknown_event`、会话视图里那条用户消息行不带 `taskId` 手柄(用户面的读数只有这一处真源,本臂不另铸第二份);不是门、不是凭据。不放行(抛)的代价是让一次锚写失败把整条已经跑完的 run 判成失败。计数持续非零 = 锚店写不进(去看库)。计数里 `reason=timeout` 占多数 = 锚店慢到秒级(去看库的锁 / 连接池)。detail = `leg=<stream|sync|bg|resume> kind=<prompt|turn> reason=error error=<写口的错误句>` 或 `… reason=timeout boundMs=<期限>`。",
+        note: "回退锚(`resumeAt` 的提示词 / 助手文本手柄)写入失败 —— 四条腿同一只写法 `runs.ts` 的 `settleResumeAnchor`,经同一只 `TurnAnchorCapture` 在决定这只锚的那一帧到手时 await(流式腿 `POST /v1/tasks/stream`、同步腿非流式 `POST /v1/tasks` 的 plain 形、后台腿 `POST /v1/runs`、续跑腿;提示锚在开场提示的提交上,早于终帧;要关窗校正的那一形同一把键写两次,后一笔等前一笔落定再发 —— 提示锚至多两个期限;后台 / 续跑腿另有每个可锚的助手文本轮各一个)。锚店写抛(库抖 / 表缺 / 盘满),或单行店操作期限(`BASELINE_IO_DEADLINE_MS`,2 s;与项目指令基线读写同一只数、同一只 `withinIoDeadline`)内没落定(锚店挂住:锚店的写口自己不带期限)⇒ 这一次提示词(或这一轮助手文本)此刻没有回退手柄,run 照常收尾、终帧照发、不改任何终局;到期只放手不取消,那次写照常在飞、迟到落定的锚照样可用(迟到的失败被吞,不重复计数)。放行的最坏后果 = 用户拿这次 run 的 taskId 去 `resumeAt` 得 404 `resume_at.unknown_event`、会话视图里那条用户消息行不带 `taskId` 手柄(用户面的读数只有这一处真源,本臂不另铸第二份);不是门、不是凭据。不放行(抛)的代价是让一次锚写失败把整条已经跑完的 run 判成失败。计数持续非零 = 锚店写不进(去看库)。计数里 `reason=timeout` 占多数 = 锚店慢到秒级(去看库的锁 / 连接池)。detail = `leg=<stream|sync|bg|resume> kind=<prompt|turn> reason=error error=<写口的错误句>` 或 `… reason=timeout boundMs=<期限>`。",
     },
     "server.resume-anchor.cause-read-failed": {
         cls: "F",
-        note: "未知回退手柄的 404 成因半句(`history-anchor.ts` 的唯一组句器;提交体 `resumeAt` / `rewindFilesTo` 与 run 外回退口 `to` 三处同调):锚店里没有这只手柄 ⇒ 经属主存取器读一次 run 行(嵌套可选读,看不见 ≡ 没有)、同会话 ⇒ 按这条提问自己的属主键再问一次锚店,只为选句(调用方看得见的本会话提问、它自己也没落锚 ⇒ 「没有锚的提问」并点名带附件不落锚那一类;否则只说没有锚)。这两读任一抛(库抖 / 表缺)⇒ 404 的码与状态照旧,句子退回只说没有锚。放行的最坏后果 = 一条真实存在、没有锚的提问,其 404 少了那半句说明(调用方可能当成手柄写错);不影响任何判定、不放行任何请求。",
+        note: "未知回退手柄的 404 成因半句(`history-anchor.ts` 的唯一组句器;提交体 `resumeAt` / `rewindFilesTo` 与 run 外回退口 `to` 三处同调):锚店里没有这只手柄 ⇒ 经属主存取器读一次 run 行(嵌套可选读,看不见 ≡ 没有)、同会话 ⇒ 按这条提问自己的属主键再问一次锚店,只为选句(调用方看得见的本会话提问、它自己也没落锚 ⇒ 「没有锚的提问」,只陈述这一事实、不点名成因;否则只说没有锚)。这两读任一抛(库抖 / 表缺)⇒ 404 的码与状态照旧,句子退回只说没有锚。放行的最坏后果 = 一条真实存在、没有锚的提问,其 404 少了那半句说明(调用方可能当成手柄写错);不影响任何判定、不放行任何请求。",
     },
     "server.remote-write.stage-seal-fallback": {
         cls: "F",

package/dist/observability/logger.js

@@ -49,7 +49,9 @@ function screenJsonLine(line, withheld) {
 }
 function serializeEntry(head, fields) {
     try {
-        return JSON.stringify({ ...head, ...fields });
+        const record = { ...head, ...fields, ...head };
+        Reflect.deleteProperty(record, "toJSON");
+        return JSON.stringify(record);
     }
     catch (err) {
         return JSON.stringify({ ...head, [FIELDS_WITHHELD]: errorKindOf(err) });

package/dist/observability/metrics.js

@@ -279,6 +279,7 @@ export function createMetrics() {
     m.counter("memory_knn_query_failed_total", "Memory KNN searchScored queries that failed at runtime (S22)");
     m.counter("memory_dedup_folded_total", "Memory writes folded into an existing near-duplicate row (LOW)");
     m.counter("memory_dedup_probe_failed_total", "Memory dedup KNN probes that failed and fell through to INSERT (LOW)");
+    m.counter("store_boundary_fault_total", "SQL-store failures whose driver error was rewritten at the store boundary (code + fixed sentence leave the store; the driver's own sentence goes to the at=store log line), by site (store.method) and class (store fault judge word)");
     m.counter("redactions_applied_total", "redactSecrets rewrites (S24), by pattern label and `arm` (S-88: full vs prefix-fragment arm — which RULE fired, NOT proof the text was upstream-truncated)");
     m.counter("session_cache_stale_hit_total", "Warm session-cache hits dropped because the store had moved past the cached leaf (written by another replica, or gone); the session was re-woken from the store");
     m.counter("breaker_writethrough_failed_total", "Circuit-breaker cross-replica write-through failures (LOW), by backend");

package/dist/operator-roster.d.ts

@@ -0,0 +1,68 @@
+/**
+ * 🔴 **运维名册的档表**(唯一一张)——「这位验过的人在这台部署上持哪几只运维权力」只在这里答。
+ *
+ * ## 律(一句)
+ * 一张闭集档表、一只读法({@link rosterTierOf}:读验过的人、读部署配置里的名册);档表一行 = 名单在哪格配置(`field` / `env`)· 这一档持哪几只权力(`powers`)·
+ * 持有者是不是人(`person`)。**不是人的档**(服务主体)的身份只在声明了它所持权力的路由上算数(路由声明行的 `power` 列,`http/route-ctx.ts`),别处整次请求
+ * 403 `auth.principal_confined`(判官 `http/principal-gate.ts` 的 `confinedTierOf`:请求的人、决定证明推出的决定者、设备行的属主三个读点同判 —— 最后一个在设备 hello 准入,
+ * 设备车道不经 HTTP、没有声明过权力的路由,落在非人档的属主登记的设备连不上),`GET /health` 按没出示凭据分档。
+ * 全运维档(`operator`)持 {@link OPERATOR_POWERS} 全集 —— 加一只权力词,现有运维不掉权。
+ *
+ * ## 读者
+ *  · 档:{@link rosterTierOf}(人 → 档;单用户声明 `OPERATOR_SINGLE_USER=true` ⇒ 每个调用方落 `operator` 档)。
+ *  · 授权 / 有无 / 圈禁 / 出路句:`http/principal-gate.ts` 的 `explicitOperatorOk(人, 名册, 权力)` / `operatorRosterPresent(名册, 权力)` / `confinedTierOf` /
+ *    `buildOperatorRosterWayOut(权力)`,都经本表的 {@link rosterTierOf} / {@link tierHolds} / {@link rosterNamesOf},不另写一份「哪几格是名单」。
+ *  · 起服不变量:`config-invariants.ts` 的 `operator-roster-well-formed`(名单是名字列表 · 非人档的名字是主体名 · 一个名字只在一档)与 `operator-single-user`(单用户声明与任一档名单互斥)按本表逐档读。
+ *
+ * 叶子:只取型(`config-types` / `owner-brands`),不 import http 层 —— 配置层(不变量)与门(`principal-gate`)读同一张表。
+ */
+import type { ServiceConfig } from "./config-types.js";
+import type { Person } from "./owner-brands.js";
+/** 运维权力(闭集)。加词 ⇒ 档表与每个按权力穷举的读者编译红。`operate` = 运维面的全部门与放宽位;`drain` = 排空口 `POST /v1/admin/drain`。 */
+export declare const OPERATOR_POWERS: readonly ["operate", "drain"];
+export type OperatorPower = (typeof OPERATOR_POWERS)[number];
+/** 名册读的几格配置:各档的名单 + 单用户声明(只住在部署配置里;env 独有、起服冻结)。 */
+export type OperatorRoster = Pick<ServiceConfig, "operatorPrincipals" | "operatorDrainPrincipals" | "operatorSingleUser">;
+/** 档表(闭集;一档一格配置、一格 env)。 */
+export declare const ROSTER_TIERS: {
+    readonly operator: {
+        readonly field: "operatorPrincipals";
+        readonly env: "OPERATOR_PRINCIPALS";
+        readonly holders: "operator principals";
+        readonly powers: readonly ["operate", "drain"];
+        readonly person: true;
+    };
+    readonly drain: {
+        readonly field: "operatorDrainPrincipals";
+        readonly env: "OPERATOR_DRAIN_PRINCIPALS";
+        readonly holders: "drain-only service principals";
+        readonly powers: readonly ["drain"];
+        readonly person: false;
+    };
+};
+export type RosterTier = keyof typeof ROSTER_TIERS;
+/** 不是人的档(圈禁的那几档)。 */
+export type NonPersonTier = {
+    [T in RosterTier]: (typeof ROSTER_TIERS)[T]["person"] extends false ? T : never;
+}[RosterTier];
+/** 档的规范序(出路句按它列档;判档时人档排在非人档之后,见 {@link rosterTierOf})。漏一档 / 名册多一格名单不进表 ⇒ 编译红。 */
+export declare const ROSTER_TIER_ORDER: readonly ["operator", "drain"];
+/**
+ * 一档的名单(缺席 ≡ 空 = 这一档没人)。名单必须是列表:绕过类型手搓的配置在这一格放一串字符串 ⇒ 响亮抛(`includes` 会把它读成子串匹配 = 放宽;
+ * 读成空又会让非人档的服务主体落回普通身份 = 也是放宽)。装配座与起服在此之前已按 `operator-roster-well-formed` 拒,这一臂只是读法本身不说假话。
+ */
+export declare function rosterNamesOf(tier: RosterTier, roster: OperatorRoster): readonly string[];
+/** 这一档持不持这只权力。 */
+export declare function tierHolds(tier: RosterTier, power: OperatorPower): boolean;
+/** 这一档是不是人档。 */
+export declare function tierIsPerson(tier: RosterTier): boolean;
+/**
+ * 🔴 **人 → 档的唯一读法**。`person` 必须是验过的人(`gatedPerson` / `personOf(主体)` / 决定证明推出的人),绝不是自述头,也不是带场景的主体(名册登记的是人)。
+ *  · 人在某档名单里 ⇒ 那一档(非人档先判,见 {@link TIER_MATCH_ORDER});
+ *  · 否则单用户声明 `OPERATOR_SINGLE_USER=true` ⇒ `operator`(单用户形只有一位用户,能到这台部署的就是他;没有人也成立 —— 与改前 `explicitOperatorOk` 同读);
+ *  · 否则 ⇒ 不在名册(空名单 = 没人在)。
+ */
+export declare function rosterTierOf(person: Person | undefined, roster: OperatorRoster): RosterTier | undefined;
+/** 名册里有没有**非人档**的名字(圈禁判只在它为真时读人 —— 没声明非人档的部署零新读、逐字节同今天)。 */
+export declare function rosterHasNonPersonNames(roster: OperatorRoster): boolean;
+//# sourceMappingURL=operator-roster.d.ts.map

package/dist/operator-roster.js

@@ -0,0 +1,32 @@
+export const OPERATOR_POWERS = ["operate", "drain"];
+export const ROSTER_TIERS = {
+    operator: { field: "operatorPrincipals", env: "OPERATOR_PRINCIPALS", holders: "operator principals", powers: OPERATOR_POWERS, person: true },
+    drain: { field: "operatorDrainPrincipals", env: "OPERATOR_DRAIN_PRINCIPALS", holders: "drain-only service principals", powers: ["drain"], person: false },
+};
+export const ROSTER_TIER_ORDER = ["operator", "drain"];
+const TIER_MATCH_ORDER = [...ROSTER_TIER_ORDER.filter((t) => !ROSTER_TIERS[t].person), ...ROSTER_TIER_ORDER.filter((t) => ROSTER_TIERS[t].person)];
+export function rosterNamesOf(tier, roster) {
+    const names = roster[ROSTER_TIERS[tier].field];
+    if (names === undefined)
+        return [];
+    if (!Array.isArray(names))
+        throw new Error(`operator roster: ${ROSTER_TIERS[tier].env} is not a list of principal names (invariant operator-roster-well-formed)`);
+    return names;
+}
+export function tierHolds(tier, power) {
+    return ROSTER_TIERS[tier].powers.includes(power);
+}
+export function tierIsPerson(tier) {
+    return ROSTER_TIERS[tier].person;
+}
+export function rosterTierOf(person, roster) {
+    if (person !== undefined)
+        for (const tier of TIER_MATCH_ORDER)
+            if (rosterNamesOf(tier, roster).includes(person))
+                return tier;
+    return roster.operatorSingleUser === true ? "operator" : undefined;
+}
+export function rosterHasNonPersonNames(roster) {
+    return ROSTER_TIER_ORDER.some((t) => !ROSTER_TIERS[t].person && rosterNamesOf(t, roster).length > 0);
+}
+//# sourceMappingURL=operator-roster.js.map

package/dist/orchestration/workflow-notify-journal.d.ts

@@ -278,6 +278,15 @@ export declare class InMemoryWorkflowNotifyJournalStore implements WorkflowNotif
     get(runId: string): Promise<WorkflowNotifyJournalEntry | null>;
     get size(): number;
 }
+/** 一笔**落成**的记录写的观察者(执行器视图;型属主在这里,实现 = `workflow-park-holder.ts` 的 `HeldParksHere`)。 */
+export interface LandedRecordObserver {
+    noteLanded(runId: string, run: WorkflowRun): void;
+}
+/**
+ * 「本服务的 workflow 记录写者经哪一只记录店写」的唯一读法:交给引擎的那只记录店是 journaling 装饰器 ⇒ 它里面那一只(notify 门的收养翻转也经它写);
+ * 否则就是它自己。起服判官(`workflow-park-decision.ts` 的 `parkDecisionStoreRefusal`)拿它与决定店的记录栅栏按身份比。
+ */
+export declare function recordWriterOf(store: object): object;
 /**
  * A {@link WorkflowRunStore} DECORATOR that journals a run the instant core persists it at START. core's
  * `startWorkflow` `put`s the run row (`status: "running"`) synchronously before the body runs, carrying both the
@@ -304,6 +313,9 @@ export declare class JournalingWorkflowRunStore implements WorkflowRunStore {
      *  的派生投影,写点必须与 fleet 行投影/notify journal 同一个(见 index 模块的文件头「单写者」段)。
      *  可选:缺席 ⇒ 一位不维护(与 fleet 半场同姿势,行为逐字不变)。 */
     private readonly agentSessionIndex?;
+    /** 本进程执行器视图(`workflow-park-holder.ts` 的 `HeldParksHere`):本装饰器在本进程引擎每一笔**落成**的记录写之后把记录交给它(它读其中本记录持有的停驻 token)。
+     *  写抛 / CAS 输 ⇒ 不交(视图保留上一份)。可选:缺席 ⇒ 不维护(没有 workflow 停驻车道的部署)。 */
+    private readonly landedRecords?;
     constructor(inner: WorkflowRunStore, 
     /** [ref] optional since the fleet decoupling: undefined ⇒ no start-time journal (ephemeral memory
      *  backend has nothing to recover), the FLEET half still publishes — the panel is replica-local UI
@@ -316,7 +328,12 @@ export declare class JournalingWorkflowRunStore implements WorkflowRunStore {
     /** [ref] 车CM:workflow 出身 park 的 join 索引。**本装饰器是它全仓唯一的写者** —— 索引是 `WorkflowRun`
      *  的派生投影,写点必须与 fleet 行投影/notify journal 同一个(见 index 模块的文件头「单写者」段)。
      *  可选:缺席 ⇒ 一位不维护(与 fleet 半场同姿势,行为逐字不变)。 */
-    agentSessionIndex?: WorkflowAgentSessionIndex | undefined);
+    agentSessionIndex?: WorkflowAgentSessionIndex | undefined, 
+    /** 本进程执行器视图(`workflow-park-holder.ts` 的 `HeldParksHere`):本装饰器在本进程引擎每一笔**落成**的记录写之后把记录交给它(它读其中本记录持有的停驻 token)。
+     *  写抛 / CAS 输 ⇒ 不交(视图保留上一份)。可选:缺席 ⇒ 不维护(没有 workflow 停驻车道的部署)。 */
+    landedRecords?: LandedRecordObserver | undefined);
+    /** 本装饰器的每一笔记录写经它落下的那只记录店(起服判官按身份比:决定店的记录栅栏必须就是它 —— {@link recordWriterOf})。 */
+    get records(): WorkflowRunStore;
     /** 本进程**亲眼看着落进索引**的指针:run → 它点名过的子会话。只用来跳过重复的 upsert,不是缓存(指针只增不删,记着的必在索引里)。
      *
      *  为什么需要:workflow 的进度写是每只 agent 状态变化一次,而 park 是罕见事件 ⇒ 无条件 upsert 会给每一次写多打几发语句(SQL)

package/dist/orchestration/workflow-notify-journal.js

@@ -270,16 +270,24 @@ export class InMemoryWorkflowNotifyJournalStore {
         return this.entries.size;
     }
 }
+export function recordWriterOf(store) {
+    return store instanceof JournalingWorkflowRunStore ? store.records : store;
+}
 export class JournalingWorkflowRunStore {
     inner;
     gate;
     fleetBus;
     agentSessionIndex;
-    constructor(inner, gate, fleetBus, agentSessionIndex) {
+    landedRecords;
+    constructor(inner, gate, fleetBus, agentSessionIndex, landedRecords) {
         this.inner = inner;
         this.gate = gate;
         this.fleetBus = fleetBus;
         this.agentSessionIndex = agentSessionIndex;
+        this.landedRecords = landedRecords;
+    }
+    get records() {
+        return this.inner;
     }
     pointedSessions = new Map();
     async ensurePointersFor(id, run) {
@@ -338,10 +346,13 @@ export class JournalingWorkflowRunStore {
             scope: run.scope,
         });
         await this.writeWithPointers(id, run, () => this.inner.put(id, run), () => true);
+        this.landedRecords?.noteLanded(id, run);
         this.publishFleet(id, run);
     }
     async update(id, scope, run, expect) {
         const ok = await this.writeWithPointers(id, run, () => this.inner.update(id, scope, run, expect), (won) => won);
+        if (ok)
+            this.landedRecords?.noteLanded(id, run);
         if (ok)
             this.publishFleet(id, run);
         return ok;

package/dist/orchestration/workflow-park-decision.d.ts

@@ -1,4 +1,4 @@
-import { type CheckpointToken, type ResumeOutcome } from "@sema-agent/core";
+import { type CheckpointToken, type ResumeOutcome, type WorkflowRun } from "@sema-agent/core";
 import type { ResumeRestatement } from "../http/resume-restatement.js";
 import { type JsonColumnReader } from "../plugins/sql-json-column.js";
 import { type InProcessClaimFence } from "../plugins/store-contracts.js";
@@ -15,25 +15,68 @@ export interface WorkflowParkDecision {
     /** 带着它的会话 = 受理那一刻那条 run 的发起会话(宿主)。 */
     readonly hostSessionId: string;
     readonly outcome: WorkflowParkOutcome;
-    /** {@link parkDecisionFingerprint}:同一决定的判据(回执幂等用)。 */
+    /** {@link parkDecisionFingerprint}:同一决定的判据(先受理者立 / 回执幂等 / 收场转交的条件)。 */
     readonly fingerprint: string;
-    /** 受理它的那一次投递跑(回执上的 `taskId`)。 */
+    /** 承运者(回执上的 `taskId`):记录栅栏下 = 持有这张卡的那条 workflow run;认领栅栏下 = 投递那一跑。读者不按它的种类分支(文件头)。 */
     readonly deliveredTaskId: string;
-    /** 受理时刻(受理那台副本的墙钟,记录值;不当任何条件 —— 序由认领栅栏的提交序定,见文件头律二)。 */
+    /** 受理时刻(受理那台副本的墙钟,记录值;不当任何条件)。 */
     readonly acceptedAtMs: number;
 }
 /**
- * 决定行的店契约(SQL 两方言 / local 文件 / 内存三形同律)。写者只有 `/decide` 的 workflow 车道(开跑之前那一笔);读者是起跑读者与
- * `/decide` 自己的回执幂等判;删除只有 SQL 收割的级联。
+ * 记录栅栏下一次决断的结局(闭集;`switch` 穷尽):
+ *  · `not_running`    —— 记录已不读作 `running`(或不在)⇒ 承运者换成续跑车道的投递那一跑,零写;
+ *  · `not_held`       —— 仍在跑,本记录的 `parks[]` 已不持有这个 token(或读不出)⇒ 零写;
+ *  · `restated`       —— 仍在跑、仍持有,请求带续跑重述键(`mcpServers` / `a2aPeers`)⇒ 零写(活 run 上的子代带着它停驻时的表继续,重述盖不上);
+ *  · `other_decision` —— 行上已是**另一个**决定(先受理者立)⇒ 零写;
+ *  · `stands`         —— 本决定落下了,或行上就是同一决定(指纹相等)。
+ */
+export type HolderFenceVerdict = "not_running" | "not_held" | "restated" | "other_decision" | "stands";
+/** 记录栅栏的结局:`running: false` = 记录此刻不读作 `running`(或不在),`fn` 一次都没调。 */
+export type RecordFenced<T> = {
+    readonly running: true;
+    readonly value: T;
+} | {
+    readonly running: false;
+};
+/**
+ * **workflow 记录的「仍在跑」原子段 —— 进程内那一形**(属主 = `workflow-record-fence.ts` 的 `FencedWorkflowRecordStore`:本服务全部记录写者 ——
+ * 引擎经 journaling 装饰器、notify 门的收养翻转 —— 都经它写,它按 runId 互斥)。`whileRunning(runId, fn)`:在这条 run 的互斥段里读记录;读作 `running`
+ * 才调 `fn`(同步:判与写同一段,型上不许把写挪到段外)、答 `{ running: true, value }`,否则答 `{ running: false }`。
+ * SQL 孪生是一个事务(`SqlWorkflowRunStore.whileRunning`:锁住 `workflow_run` 行,`fn` 收那只事务连接),不是本型。
+ */
+export interface InProcessRecordFence {
+    whileRunning<T>(runId: string, fn: (run: WorkflowRun) => T): Promise<RecordFenced<T>>;
+}
+/** 记录栅栏的两形(闭集,与认领栅栏 `ClaimFenceStore` 同形):SQL 孪生一只行锁事务 / 进程内按 runId 互斥。决定店的两形各绑各的那一形。 */
+export type WorkflowRecordFenceStore = import("../plugins/workflow-run-store-sql.js").SqlWorkflowRunStore | InProcessRecordFence;
+/**
+ * 记录栅栏判的那一半(两形同一只纯函数;写那一半各形自己的原子段):本记录持有这个 token 吗(`heldParksOf`,`parks[]` 读不出 ⇒ 证不出持有),
+ * 请求带重述键吗。交回 `land` ⇒ 进「行上没有就落、有就比指纹」那一步。
+ */
+export declare function holderFenceAdmits(run: WorkflowRun, d: Pick<WorkflowParkDecision, "runId" | "token">, restated: boolean): "not_held" | "restated" | "land";
+/**
+ * 决定行的店契约(SQL 两方言 / local 文件 / 内存三形同律)。写者两个:`/decide` 与决断口停驻形的 workflow 车道(7.151.x 及以前:应答口的)(记录栅栏那一笔 / 续跑车道开跑之前那一笔)、
+ * run 收场送达的转交(续跑车道那一笔,带条件);读者是起跑读者、持有进程的拉取腿、收场送达与 `/decide` 自己的回执幂等判;删除只有 SQL 收割的级联。
  */
 export interface WorkflowParkDecisionStore {
-    /** 这只店每一笔写所在的认领栅栏 = 构造时绑定的那只 run 店。起服判官要它**就是**部署的 run 店({@link parkDecisionStoreRefusal})。 */
+    /** 认领栅栏 = 构造时绑定的那只 run 店。起服判官要它**就是**部署的 run 店({@link parkDecisionStoreRefusal})。 */
     readonly claims: object;
+    /** 记录栅栏 = 构造时绑定的那只 workflow 记录店。起服判官要它**就是**本服务记录写者共用的那一只。 */
+    readonly records: object;
+    /**
+     * 认领栅栏的原子段里写(律的第二个取值):投递那一跑此刻持有宿主会话的认领且在跑 ⇒ 写并答 `true`;否则什么都不写、答 `false`。
+     * `condition` 缺席 ⇒ 整行写(没有行插入、有行整行取代);在场 ⇒ 行上的指纹仍等于 `expect` 才整行写,否则不写、答 `false`(收场转交:一个更新的决定已在行上)。
+     */
+    record(decision: WorkflowParkDecision, condition?: {
+        readonly expect: string;
+    }): Promise<boolean>;
     /**
-     * 认领栅栏的原子段里整行写(律二,文件头):投递那一跑此刻持有宿主会话的认领且在跑 ⇒ 写(没有行插入、有行整行取代)并答 `true`;
-     * 否则什么都不写、答 `false`。
+     * 记录栅栏的原子段里判与写(律的第一个取值;`decision.deliveredTaskId` = `decision.runId` = 持有这张卡的那条 run):结局见 {@link HolderFenceVerdict}。
+     * 只有 `stands` 可能写过(行上本来没有时插入),其余零写。
      */
-    record(decision: WorkflowParkDecision): Promise<boolean>;
+    recordForRunningHolder(decision: WorkflowParkDecision, request: {
+        readonly restated: boolean;
+    }): Promise<HolderFenceVerdict>;
     get(token: CheckpointToken): Promise<WorkflowParkDecision | null>;
     /** 带着这个会话的全部决定行(顺序不承重)。 */
     listByHostSession(hostSessionId: string): Promise<WorkflowParkDecision[]>;
@@ -41,15 +84,17 @@ export interface WorkflowParkDecisionStore {
 /** 起服判官读的那几座(`ServiceDeps` 的子集)。 */
 export interface ParkDecisionLaneSeats {
     readonly runStore?: object | undefined;
+    readonly workflowRunStore?: object | undefined;
     readonly workflowAgentSessionIndex?: unknown;
     readonly workflowParkDecisions?: WorkflowParkDecisionStore | undefined;
 }
 /**
- * 🔴 **「决定店绑对了 run 店吗」的唯一判官**(`createHttpServer` 起服时调;拒 ⇒ 拒启)。判的是**递进来的对象**(按身份比),不是配置组合 ——
+ * 🔴 **「决定店绑对了两只栅栏吗」的唯一判官**(`createHttpServer` 起服时调;拒 ⇒ 拒启)。判的是**递进来的对象**(按身份比),不是配置组合 ——
  * 本服务自己那一形(SQL 后端配 `WORKFLOW_RUN_STORE=file|memory` 且开自编排)由配置不变量 `workflow-park-decision-domain` 在第 1 段、一次性迁移之前拒,走不到这里;
  * 走到这里的不相等只来自嵌入方递错了座。
- * 期望的绑定:workflow 子代停驻车道装了(park 索引在场)且部署有 run 店 ⇒ 决定店在场、绑的**就是**那只 run 店;否则不该有决定店。不相等的三形各一句:
- * ①车道与 run 店都在而决定店缺席;②决定店绑的是别的 run 店(两只店各取各的:决定写进一只库、认领与读在另一只);③有决定店,而车道没装或部署没有 run 店。
+ * 期望的绑定:workflow 子代停驻车道装了(park 索引在场)且部署有 run 店 ⇒ 决定店在场、`claims` **就是**那只 run 店、`records` **就是**本服务记录写者经它写的那只记录店
+ * ({@link recordWriterOf}:journaling 装饰器里面那一只);否则不该有决定店。不相等的四形各一句:
+ * ①车道与 run 店都在而决定店缺席;②决定店绑的是别的 run 店;③有决定店,而车道没装或部署没有 run 店;④决定店的记录栅栏不是本服务记录写者经它写的那一只。
  */
 export declare function parkDecisionStoreRefusal(seats: ParkDecisionLaneSeats): string | undefined;
 /**
@@ -68,24 +113,31 @@ export declare function parkDecisionFingerprint(outcome: WorkflowParkOutcome, re
  */
 export declare const readWorkflowParkOutcome: JsonColumnReader<WorkflowParkOutcome>;
 /**
- * 单机车道的决定店(`LocalWorkflowAgentSessionIndex` 的同室孪生),绑在进程内的 run 店上({@link InProcessClaimFence}:Memory / File run 店)。
+ * 单机车道的决定店(`LocalWorkflowAgentSessionIndex` 的同室孪生),绑在进程内的两只栅栏上:run 店({@link InProcessClaimFence}:Memory / File run 店)与
+ * 记录栅栏装饰器({@link InProcessRecordFence})。
  * `root` 在场 ⇒ 追加式 JSONL 账本(0o700 目录 + 0o600 账本,一行 = 一条决定行的整份快照,每一笔写都追加);重放按行序、**末行胜**
- * (写序就是认领栅栏的序:每一笔都在栅栏的同步段里追加,同一宿主会话上的受理由认领串行);缺席 ⇒ 纯内存(`WORKFLOW_RUN_STORE=memory` 的易失车道)。
+ * (写序就是栅栏的序:每一笔都在栅栏的段里追加);缺席 ⇒ 纯内存(`WORKFLOW_RUN_STORE=memory` 的易失车道)。
  *
  * 🔴 **坏行 fail-closed**(登记座 `workflow-park-decisions`):读不出的一行可能正是**取代**了一条旧决定的那一笔 —— 跳过它重放其余行,
- * 会把被取代的旧决定复活成当下的决定,在下一次起跑时交给引擎。闸合上之后三个动词都响亮拒,直到有人处理那只文件;
+ * 会把被取代的旧决定复活成当下的决定,在下一次交付时交给引擎。闸合上之后四个动词都响亮拒,直到有人处理那只文件;
  * 起跑读者(`parked-decide.ts`)把这一拒读成「本店没有可供的行」(F tag `server.workflow-park-decision.store-unreadable`)—— 起跑不连带拒,写与按 token 读照旧拒。
  * SQL 孪生同律:某一行 `outcome` 坏体 ⇒ 读口拒,起跑读者同一臂。
  */
 export declare class LocalWorkflowParkDecisionStore implements WorkflowParkDecisionStore {
     readonly claims: InProcessClaimFence;
+    readonly records: InProcessRecordFence;
     private readonly fsyncEnabled;
     private readonly ledgerPath;
     private readonly gate;
     private readonly rows;
     private log;
-    constructor(claims: InProcessClaimFence, root?: string, fsyncEnabled?: boolean);
-    record(decision: WorkflowParkDecision): Promise<boolean>;
+    constructor(claims: InProcessClaimFence, records: InProcessRecordFence, root?: string, fsyncEnabled?: boolean);
+    record(decision: WorkflowParkDecision, condition?: {
+        readonly expect: string;
+    }): Promise<boolean>;
+    recordForRunningHolder(decision: WorkflowParkDecision, request: {
+        readonly restated: boolean;
+    }): Promise<HolderFenceVerdict>;
     /** 整行写(同步):落盘**先于**内存翻转(调用方观察到的状态背后一定有耐久记录)。交回栅栏的落定记号(同步交回,型上不许让出)。 */
     private landNow;
     get(token: CheckpointToken): Promise<WorkflowParkDecision | null>;