@sema-agent/server 7.147.0 → 7.149.0

package/dist/observability/fail-open.js

@@ -1,5 +1,4 @@
 import { appendFileSync } from "node:fs";
-import { createLogger } from "./logger.js";
 export const FAIL_OPEN_TAGS = {
     "server.approval-ask-journal.compaction-failed": {
         cls: "F",
@@ -31,12 +30,16 @@ export const FAIL_OPEN_TAGS = {
     },
     "server.memory-consolidation.operator-valve-layers-unfed": {
         cls: "P-DEBT",
-        note: "core 7.51.0 #1718 提货(`boot/memory-consolidation.ts` `createOperatorValveWriteJudge`):运维手动整理阀门的写判官座已是引擎的那一只构造器,但三层没喂 —— 人的持久规则层(阀门没有「库属于谁」的来源,无 principal / 不声明 local-owner)、部署的调用方策略层(`APPROVAL_REQUIRE` / `APPROVAL_DENY` / `AUTONOMY` / 敏感路径守卫集是每任务现合成的活配置、无部署级单例;敏感路径层另需引擎豁免根入参,宿主构造器输入没有这一位)、项目根(项目层 scope 键是任务根的单向散列,反推不出)。每被问一次(早问库目录一次 + 每个产物一次)记一次。放行的最坏后果 = 运维手动整理时,一条点名记忆库路径的人的持久规则或部署写策略(例如 `APPROVAL_DENY=Write`)拦不住这一轮折叠(与 7.128.x 逐字同;只是判官不再是代答);自动整理腿走引擎腿自己的判官,不在本 tag 射程。收口 = 三层各自有了来源(人:「读谁的桶」裁定;策略:一份设计 + 向 core 请托引擎豁免根入参;根:无来源则永久缺席并改写本债)那一版,本 tag 删。",
+        note: "core 7.51.0 #1718 提货(`boot/memory-consolidation.ts` `createOperatorValveWriteJudge`):运维手动整理阀门的写判官座是引擎的那一只构造器,按次现铸(单飞里起跑的那一次),喂了人(发起这一轮的调用方的规则桶;不带主体 ⇒ 部署声明了本机属主桶时读那只桶,与 Runner 的 `localOwnerRules` 同一只判据);还没喂的两样 —— 部署的调用方策略层(`callerPolicy`:腿上是任务的整条部署治理链 —— 审批名单 `APPROVAL_DENY` / `APPROVAL_REQUIRE` / `APPROVAL_NEVER_AUTO`、敏感路径守卫 `SENSITIVE_WRITE_PATTERNS` 与誊本门、命令策略;只喂一层是半条链,整条喂又卡在敏感路径守卫:腿上靠引擎盖在每个请求上的豁免根放过记忆库自己的写,宿主构造器的输入没有这一位,不带它喂进去会把库里的写当守卫目标拒掉,与腿不同答)与项目根(项目层 scope 键是任务根的单向散列,反推不出;人持有的相对行因此无处锚定、按异议拒闭)。每被问一次(早问库目录一次 + 每个产物一次)记一次。放行的最坏后果 = 运维手动整理时,部署的写策略(例如 `APPROVAL_DENY=Write`、点名记忆库路径的敏感路径守卫)拦不住这一轮折叠;人的 deny 行拦得住。自动整理腿走引擎腿自己的判官,不在本 tag 射程。收口 = 引擎的宿主输入收豁免根、整条部署治理链喂上并挂部署旋钮矩阵的一条腿那一版,本 tag 删(项目根改写成永久缺席的披露)。",
     },
     "server.workflow-park-index.parks-unreadable": {
         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": {
+        cls: "F",
+        note: "活 run 收下 workflow 停驻卡的决定之后,本进程回执簿(`parked-decide.ts` 的 `holdLiveReceipt`)等那条 run 的引擎观察通道收场来删簿;等的那一读拒 ⇒ 按收场删掉这条 run 的回执。放行的最坏后果:那条 run 仍在跑、驱动还在等并发槽时,同一决定重点一次答 409 `decide.claim_lost` 而不是首张回执(卡此刻仍 pending,重读列表再决);不重复执行、不放宽任何判定。",
+    },
     "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=<原句,经记录器脱敏>`。",
@@ -59,7 +62,7 @@ export const FAIL_OPEN_TAGS = {
     },
     "server.task-mcp.source-label-dropped": {
         cls: "F",
-        note: "B-036 / S-143(`mcp-source-label.ts readMcpSourceLabel`,请求腿 + center 腿共用):`mcpServers[].source`(分组标签,显示用、开集)坏形——空串 / 超 80 字 / 非字符串——**丢键留 server**。放行的最坏后果=这台 server 在 wiring_manifest.mcp[] 里没有分组标签(难看),不是门/权限/凭证;本地 config.d 腿由 settings-schema 1.7.0 在解析处拒,故本臂只在请求腿与远端 /effective 直读 JSON 腿可达。",
+        note: "B-036 / S-143(`mcp-source-label.ts readMcpSourceLabel`,请求腿 + center 腿共用):`mcpServers[].source`(分组标签,显示用、开集)坏形——空串 / 超 80 字 / 非字符串——**丢键留 server**。放行的最坏后果=这台 server 在 wiring_manifest.mcp[] 里没有分组标签(难看),不是门/权限/凭证;契约读腿不判这一键的形(1.7.1 起解析透明),本地 config.d 腿与远端 /effective 腿交同一形、都在挂载那一刻(`skills-mcp.ts resolveMcpServers`)判,请求腿在 `task-mcp.ts` 判。",
     },
     "server.memory-optout-grant.onfault-hook-threw": {
         cls: "F",
@@ -85,13 +88,9 @@ export const FAIL_OPEN_TAGS = {
         cls: "F",
         note: "#292 placement 半场:host-fallback 命中后顺手读 meta 入 placed 名册失败(stub 会话无 getMetadata / 读故障)。名册只是省探针的缓存,不是判定 —— 缺一条=该 id 下次 acquire 多付一次 hostPlacedProbe,正确性零影响。计数留痕是为了让「meta 读一直在失败」这种环境病显形。",
     },
-    "server.hitl.frame-undelivered-stream-closed": {
-        cls: "P-DEBT",
-        note: "HITL 的 **open** 帧写向一条已断/已关的 SSE 连接 ⇒ 静默丢弃,上游据此把投递记成成功,该 ask 挂到 TTL 才按无人应答结算。⚠️ #173 后 question 开帧改走断流 THROW(立即结算 unavailable),因此本 tag 在产的只剩 **elicitation** 一族,且只在**无账本孪生**(无 durable run 行)的部署上——有孪生的腿直写面已死时帧在账本里、不算丢——读计数时勿把它当作 question 的人在环缺口。no-op 而非 throw 对 elicitation 仍是既有的刻意决定,本条只保证它不再无声。",
-    },
     "server.stream.frame-dropped-stream-closed": {
         cls: "F",
-        note: "非 HITL-open 的运行流帧写向已断连接 ⇒ 丢弃。连接都没了,这一帧本就无人可看;单独立项是为了不让它挤进上面那条保护型计数。⚠️ `frame=engine_notice` 与 `frame=file_link` **只在本腿没有账本口的部署上计**(无 durable run 行):配了账本口的腿,这一帧在账本里,账本孪生即送达,死直写不再另记 —— 丢没丢由账本那一笔判(通告 `server.engine-notice.durable-append-failed`、文件卡 `server.ledger.forward-append-failed`),所以本计数里的这两型就是真丢。读遥测时别拿本 tag 当「壳在通告到达前断流」的旁证:有账本口的腿上那件事要从账本行时间与接入日志的 499 对出来。",
+        note: "非人在环的运行流帧(人在环三族的帧走腿的人在环传输,不经这条直写口)写向已断连接 ⇒ 丢弃。连接都没了,这一帧本就无人可看。⚠️ `frame=engine_notice` 与 `frame=file_link` **只在本腿没有账本口的部署上计**(无 durable run 行):配了账本口的腿,这一帧在账本里,账本孪生即送达,死直写不再另记 —— 丢没丢由账本那一笔判(通告 `server.engine-notice.durable-append-failed`、文件卡 `server.ledger.forward-append-failed`),所以本计数里的这两型就是真丢。读遥测时别拿本 tag 当「壳在通告到达前断流」的旁证:有账本口的腿上那件事要从账本行时间与接入日志的 499 对出来。",
     },
     "server.question.open-frame-undelivered": {
         cls: "P-DEBT",
@@ -101,13 +100,9 @@ export const FAIL_OPEN_TAGS = {
         cls: "F",
         note: "MCP elicitation 的 open 帧投递失败 ⇒ 按没人应答放掉(cancel)。方向本身是 fail-closed(问不到人就是没授予),缺的只是留痕。",
     },
-    "server.question.complete-breadcrumb-dropped": {
+    "server.hitl.close-frame-dropped": {
         cls: "F",
-        note: "question_complete 面包屑(对话框消解提示)持久化失败。答案本身走的是另一条路且早已返回,丢的只是壳里一次收尾渲染。",
-    },
-    "server.elicitation.complete-breadcrumb-dropped": {
-        cls: "F",
-        note: "elicitation_complete 面包屑持久化失败。同上——答案已经在壳手里,丢的是收尾渲染。",
+        note: "人在环三族(问题 / 表单 / 审批)的**收帧或撤卡帧**没送到(探针行带 `frame=<型>` 与身份):有账本的腿上 = 本 run 账本那一笔落不下(按律直写也不写);无账本的腿上 = 直写写不出 / 连接已死。只投给接下过开帧的 sink,所以本计数不含「开帧本就没送到」的那几只。答案 / 决议早已走另一条路回到引擎、卡的终局是行上(或协调器里)的事实,丢的是壳里一次收尾渲染:活连接上那张卡留到它自己的 `expiresAtMs` 或下一次 preamble(审批卡的全量对账基准);回放里开帧在、收帧缺,按待答判法读作窗到即失效。",
     },
     "server.session-titler.gateway-unreachable": {
         cls: "F",
@@ -175,7 +170,7 @@ export const FAIL_OPEN_TAGS = {
     },
     "server.approvals.risk-descriptor-cell-unreadable": {
         cls: "F",
-        note: "运维待批队列(`GET /v1/approvals` / `/stream`)的某一行,`checkpoint.risk_descriptor` 这一格**不是合法 JSON 文本**(手改过的行 / 回滚残留 / 列语义漂;与同一 `rows.map` 里的 `rule_suggestions` 是同族坏法,两方言都是 TEXT 列)。放行的最坏后果 = **这一行**的分诊 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.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 与候选那格**分开计**,并计会让「哪一格在坏」在遥测里读不出来。",
     },
     "server.approvals.park-row-blob-unreadable": {
         cls: "F",
@@ -187,7 +182,7 @@ export const FAIL_OPEN_TAGS = {
     },
     "server.approvals.durable-row-checkpoint-id-missing": {
         cls: "F",
-        note: "7.133.0(`checkpoint-identity.ts` 的 `durableRowIdentity`;两只店的 `listPending` + `/v1/assistant/inbox` handler):三处 durable 读面(运维队列行 `GET /v1/approvals` 与 `/v1/approvals/stream` 的 `pending` 帧;停驻收件 `GET /v1/assistant/inbox` 的行)读到一行停驻门**没有可用的 `checkpointId`** ⇒ 这一行**照列、`checkpointId` 键缺席**(消费方按「这一行没有可 join 的身份」处理)。detail = `face=<approvals-queue|assistant-inbox> why=<absent|untrusted>`:`absent` = 行上没有这一格(core 5.42.0 之前停驻的老行 —— core 明写不回填);`untrusted` = 在场却没过信任边界(非串 / 空串 / 超长 / 含 resume token —— 数据污染;没过边界的值不上 wire)。放行(列、键缺席)的最坏后果 = 消费方对这一行做不了跨面 join(三面对账少一行)—— 行本身、决断口(`/v1/approvals/:sessionId/decide`,按会话)、到期收割都照常。不放行有两种形:整只拒的代价是一行老 / 坏行打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远停在旧帧);把这一行藏起来的代价更糟 —— 人看不到要批的东西(审批面上的 fail-open,方向反了)。故 F 类;必须留痕(两种成因从此可分)。计数非零 = 有老 / 坏行在飞(列着、没身份);`/stream` 每 3s 一拍重读,同一行每拍计一次(量值 = 行 × 拍数,在场才是信号)。 7.137.0 起第四面:park 账本行(`GET /v1/runs/:id/events` 的 `suspended` / `needs_review`;唯一构造器 `trace/project.ts` 的 `parkEventData`,写时判一次,detail `face=run-events-park`)—— 暂停因由上的门身份没过信任边界 ⇒ 行照写、`checkpointId` 键缺席(决断方回显不了这道门,退回不带键的决断或从 run 结果取原值;行本身、门、待批调用身份照常)。 第五面:回决门族的 200 体(`/decide` / `/resume` / `/plan_review` 执行之前从选中的那一行捕获一次,`http/resume-legs.ts` 三处;detail `face=decision-receipt`)—— 选中那一行的门身份没过信任边界 ⇒ 结清证据照铸、体上 `checkpointId` 键缺席(决断方只是对不上身份;位、决定、续跑都照常)。每次走到捕获点的决断计一次(计的是选中那一行的事实,与这次决断随后走哪条车道无关)。",
+        note: "7.133.0(`checkpoint-identity.ts` 的 `durableRowIdentity`;两只店的 `listPending` + `/v1/assistant/inbox` handler):三处 durable 读面(运维队列行 `GET /v1/approvals` 与 `/v1/approvals/stream` 的 `pending` 帧;停驻收件 `GET /v1/assistant/inbox` 的行)读到一行停驻门**没有可用的 `checkpointId`** ⇒ 这一行**照列、`checkpointId` 键缺席**(消费方按「这一行没有可 join 的身份」处理)。detail = `face=<approvals-queue|assistant-inbox> why=<absent|untrusted>`:`absent` = 行上没有这一格(core 5.42.0 之前停驻的老行 —— core 明写不回填),或 `DB_BACKEND=local` 上这一行引擎的摘要读不动(摘要只带身份,join 键不在其中;收件箱与运维队列同读这一份摘要、同计);`untrusted` = 在场却没过信任边界(非串 / 空串 / 超长 / 含 resume token —— 数据污染;没过边界的值不上 wire)。放行(列、键缺席)的最坏后果 = 消费方对这一行做不了跨面 join(三面对账少一行)—— 行本身、决断口(`/v1/approvals/:sessionId/decide`,按会话)、到期收割都照常。不放行有两种形:整只拒的代价是一行老 / 坏行打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远停在旧帧);把这一行藏起来的代价更糟 —— 人看不到要批的东西(审批面上的 fail-open,方向反了)。故 F 类;必须留痕(两种成因从此可分)。计数非零 = 有老 / 坏行在飞(列着、没身份);`/stream` 每 3s 一拍重读,同一行每拍计一次(量值 = 行 × 拍数,在场才是信号)。 7.137.0 起第四面:park 账本行(`GET /v1/runs/:id/events` 的 `suspended` / `needs_review`;唯一构造器 `trace/project.ts` 的 `parkEventData`,写时判一次,detail `face=run-events-park`)—— 暂停因由上的门身份没过信任边界 ⇒ 行照写、`checkpointId` 键缺席(决断方回显不了这道门,退回不带键的决断或从 run 结果取原值;行本身、门、待批调用身份照常)。 第五面:回决门族的 200 体(`/decide` / `/resume` / `/plan_review` 执行之前从选中的那一行捕获一次,`http/resume-legs.ts` 三处;detail `face=decision-receipt`)—— 选中那一行的门身份没过信任边界 ⇒ 结清证据照铸、体上 `checkpointId` 键缺席(决断方只是对不上身份;位、决定、续跑都照常)。每次走到捕获点的决断计一次(计的是选中那一行的事实,与这次决断随后走哪条车道无关)。",
     },
     "server.peer-inbound.queue-box-unknown": {
         cls: "F",
@@ -261,6 +256,14 @@ export const FAIL_OPEN_TAGS = {
         cls: "F",
         note: "#213 陈旧 claim 接管:claim 已 rename 进 tmp/ 隔离名(接管本体已完成、正确性不受影响),但隔离件 rmSync 失败留在 tmp。放行的最坏后果 = tmp 里多一个死文件(不在 activeDir,hydrate 永不把它当 claim 复活);故 F 类。必须留痕:反复删不掉 = tmp 权限/fs 病灶,静默吞掉会让 tmp 无声膨胀。",
     },
+    "server.run-store.stall-verdict-unlanded": {
+        cls: "F",
+        note: "run 存活判决单源:一条心跳过期的 running 行在**观察口**(属主门之后把 run 的状态答给调用方的面)或**认领冲突**(新提交撞上它)处该落死亡判决(`failed` + `run.stalled` + 放认领,与收割器同一句 SQL),而这一笔写失败(库一时不通 / 锁超时)⇒ 行**原样**交回:读面答 `running`、认领冲突照答 409。放行的最坏后果 = 这一次读 / 提交看到的仍是「死了还没落」的旧行,收割器下一拍(`REAP_INTERVAL_SEC`)按同一判决补落;行是唯一来源,读面不再自己折叠。故 F 类。留痕是承重的:持续命中 = 写路径坏了、读路径还好,死 run 的会话被攥到收割器补上为止。",
+    },
+    "server.run-store.m44-result-unreadable": {
+        cls: "F",
+        note: "一次性迁移 M44(run 的 `errorCode` 只读列)的改写半场读到一格**体坏了**的 `task_run.result`(不是合法的 JSON 对象)⇒ 跳过这一行、码列不动。放行的最坏后果 = 这一行的码列仍是改写前的值;而店的读腿对这一行照旧响亮拒(`GET /v1/runs/:id` 不会把一格坏结果答成任何码),所以没有错读。故 F 类。留痕理由:命中 = 库里有坏结果行,运维该看一眼;窗关随 M44 删。",
+    },
     "server.otel.export-failed": {
         cls: "F",
         note: "#193 车5(staleness-sweep P1-3):OTLP 周期导出失败(HTTP 非 2xx 或 fetch 拒绝)⇒ 丢弃本轮快照继续服务。导出本就 best-effort(collector 打嗝绝不影响 serving,方向不改),但此前唯一留痕是装配层 onError 的一条 warn——**metrics 轴零信号**,而 USAGE 力荐的 Prometheus-only 部署恰好只看 metrics ⇒ collector 持续宕机对运维完全不可见(遥测腿自盲)。放行的最坏后果 = 一段时间的指标断供;计数让「断供正在发生」本身成为一条指标。",
@@ -281,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 打死起服(混跑窗里能服务的副本)。计数让「这台部署的记忆树有读不出的目录」显形。",
@@ -359,7 +366,7 @@ export const FAIL_OPEN_TAGS = {
     },
     "server.run-terminal.redact-threw": {
         cls: "F",
-        note: "三个发射座(errorMessage 终态文案 / 诊断文本 diag / 工件 artifact,probe 前缀判别;普查 56 行;补丁头 patch-head 那座随 7.83.0 / S-113 的 redactPatchHead 一并退役)+ 出口座(S-485 / RH-1:`trace/exit-seat.ts` 的 `seatText`,probe 前缀 `seat=<座表行>`;trace 帧自由文本位上抛 ⇒ 这一位换同一枚占位、投影不抛)+ 活面放行窗(`trace/model-segment.ts` 的 `createLiveModelText`,probe 前缀 `live-hold`:逐块放行口抛 ⇒ 这一拍不放、字节留在窗里;段末整段读法抛 ⇒ 余下的字节整段换同一枚占位;块界上扫描窗前移的认证扫描抛 ⇒ 窗不动,只是没省,交出的字节一个不变):S-105 最终轮 [medium]:终态 errorMessage/blockedReason/remoteEnvFailures[].message 脱敏抛出(RangeError:关键字/前缀臂那一形由 S-219 的 atLeast 铸点闭掉;JSON 秘密字段臂的转义对循环与 PEM 栅栏臂的标签交替循环由 S-265 换成手写线性扫描器闭掉 —— 已知形全部闭掉,本臂留作结构性兜底,计数恒零是证据、不归零即新形)⇒ 落固定占位 «redacted:oversized»——绝不落原文(安全轴 fail-closed),也绝不阻断终态翻转与 claim 释放(可用性)。方向刻意:一条超大错误体不得把 run 卡在 running。",
+        note: "三个发射座(errorMessage 终态文案 / 诊断文本 diag / 工件 artifact,probe 前缀判别;普查 56 行;补丁头 patch-head 那座随 7.83.0 / S-113 的 redactPatchHead 一并退役)+ 出口座(S-485 / RH-1:`trace/exit-seat.ts` 的 `seatText`,probe 前缀 `seat=<座表行>`;trace 帧自由文本位上抛 ⇒ 这一位换同一枚占位、投影不抛;声明了 JSON 读法的座行遮过的产物解析不出 JSON 同走此臂,`err=SyntaxError`)+ 活面放行窗(`trace/model-segment.ts` 的 `createLiveModelText`,probe 前缀 `live-hold`:逐块放行口抛 ⇒ 这一拍不放、字节留在窗里;段末整段读法抛 ⇒ 余下的字节整段换同一枚占位;块界上扫描窗前移的认证扫描抛 ⇒ 窗不动,只是没省,交出的字节一个不变):S-105 最终轮 [medium]:终态 errorMessage/blockedReason/remoteEnvFailures[].message 脱敏抛出(RangeError:关键字/前缀臂那一形由 S-219 的 atLeast 铸点闭掉;JSON 秘密字段臂的转义对循环与 PEM 栅栏臂的标签交替循环由 S-265 换成手写线性扫描器闭掉 —— 已知形全部闭掉,本臂留作结构性兜底,计数恒零是证据、不归零即新形)⇒ 落固定占位 «redacted:oversized»——绝不落原文(安全轴 fail-closed),也绝不阻断终态翻转与 claim 释放(可用性)。方向刻意:一条超大错误体不得把 run 卡在 running。",
     },
     "server.run-terminal.provider-echo-shaped": {
         cls: "F",
@@ -370,13 +377,15 @@ 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`:喂入 / 取已判定前缀 / 收尾冲刷):一段冲刷时,已取出去的逐块字节与整段读法在那一截上的渲染对不上,或有一条整段读法的跨度横跨放行位 —— 流式口的律被打破(某条臂的判定在脱敏器读出的未决尾上界 `PENDING_TAIL_UNITS` 之外落定,而它没有把那一支标成未决尾)。处置:余下的字节照整段读法出(横跨放行位的跨度整枚换记号,不再出它的原文字节),段末帧照发整段脱敏的正文、消费端按它整段替换;但**已经出门**的那几块收不回 —— 其中可能有整段读法会遮的字节(这就是 P 族的理由)。债:未决尾上界是候选池成员判定距离的最大值,正则臂从正则源读出,手写扫描器的那一项是成员处的陈述(它起头要读全的字面锚),不是从扫描器的代码机械读出;已知一形是多遮方向(方案词锚的头值在文本末尾被读成「收在行尾」,其后隔着长过上界的行内空白又跟了词 ⇒ 整段读法不遮、活流已出记号)。钉 = 基线语料逐条按块流过流式口拼接 = 整段脱敏 + 判定距离最远的几形逐码元。detail `family=<text|reasoning> len=<段长>`;计数 = 多少段的律被打破(期望恒 0)。",
+        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)。",
     },
     "server.redact.ppk-eat-to-end": { cls: "F", note: "S-107 第三十二轮重扫:PuTTY .ppk 容器扫描器(redact.ts redactPpkContainers)在「无合格终止 / 收口后同容器范围再见私钥字段 / 收口后到下一版本头之间夹非空白」三形下从头**吃到输入末尾**(fail-closed 取证丢弃)——终态 errorMessage 座上=整条错误文案变成 «redacted:private-key»,与 redactions_applied_total{private-key} 的诚实替换同形不可分,故要有自己的计数/探针;影子扫不计;出口座有界行的 head 读法(只扫一段头)上「窗内无合格终止」是终止可能在窗外的未决 —— 照样遮到窗尾,但不是兜底,不计;计数=多少次整段吃尾。" },
+    "server.redact.display-safe-fail-closed": { cls: "F", note: "配置型 URL 的展示铸点(redact.ts buildDisplaySafeUrl / buildDisplaySafeRefusal)判定某一段带凭据、却无法按字节粒度遮 ⇒ 整段扣下(query 与 fragment 换一枚 «redacted» / path 段换记号 / 引用这条 URL 的拒因整句换固定文案)—— 产物安全,但这台部署有输入撞到了合成缝,该报上游;detail level= 是扣下的那一级(query-and-fragment-withheld / path-segment-withheld / refusal-text-withheld),零原文;计数=扣下次数。修前是一条每进程一次的 process warning(Node 默认处理器直写 stderr,不经日志出口接缝)。" },
     "server.redact.forensic-level-cap": { cls: "F", note: "脱敏器取证相(redact.ts armPool 第二相)跑满级数界 FORENSIC_LEVEL_MAX 仍没收敛(证据链里层被认出、外层才认得出,刻意交替嵌套的私钥块 / URL 每层多一级,深过 31 层才够得着;现役语料最深 3 级)⇒ 下一级本会重跑的取证臂各自从它读证据的起点遮到窗尾(fail-closed:多遮可见、不少遮),不再升级;每次调用至多一条;影子扫不计;detail from=/len= 是视图坐标。" },
+    "server.redact.scan-view-unattributed": { cls: "F", note: "脱敏器手写扫描器经扫描器读口(redact.ts ScanView)读原文:一次尝试真读到了文本末尾 ⇒ 记在这一次尝试的寄存器(跨度起点下界)上,活流交出点据它扣住那一截。某只扫描器在设寄存器之前就读到了末尾(编译期管不到的那一处:每次尝试的头上都要设一次)⇒ 那一读按视图起点记开着(fail-closed:活流整读扣到段末才出,不少扣),每次调用至多一条;影子扫不计(同一段扫描器代码在整段读法里同样走到,在那里计);detail len= 是文本长。生产上恒零是证据,不归零 = 有一只扫描器漏设寄存器。" },
     "server.approval-card.closed-word-out-of-set": {
         cls: "F",
         note: "S-249(`approval-card.ts` 的边界窄读族;今天四个成员:`readRuleOffersAbsence`、S-934 ② 起的 `readAskClassPair`(core 7.37.0 #1214 的类对 `askClass` / `classes`,活卡帧 / 呈卡帧的卡 / 运维队列行同一只,判法 = core 屏 `screenAskClassMembers`(S-955 ⑥ / core 7.38.0 #1249,本仓零自写对判),两键同在同缺,半对 / 集外 / 首员不符 / 重复员 = 屏拒 = 读不出;detail 前缀 `askClass=` / `classes=`),与 S-721 起的 `readClosedWordSeat` —— 一座一只 core 成员筛,座是参数:`mandate`(core 7.32.0 #1092,活卡帧 / 活挂起行 / 运维队列行同一只,闭集筛 = core `isPersistedRuleMandate`)与 S-755 起的 `origin`(运维队列行读 park 行孪生座,闭集筛 = core `isAskOrigin`,与 inbox 行 core 投影处同一只筛)、S-1170 起的 `classifierNoRuling`(core 7.43.0 #1353 的成因词,活卡帧读 `AskRequest.classifierNoRuling`,闭集筛 = core `isAutoModeFallbackCause`)与 `differs`(core 7.44.0 #1374,载体是 `runs.ts` 的 409 `steering.duplicate_input_id` 体读的引擎拒错 `detail.differs`,闭集筛 = core `STEER_REPLAY_FACETS` 的非空子集;集外成员 / 空 / 非数组 ⇒ 不铸 `detail`,码仍是契约);detail 前缀 `ruleOffersAbsence=` / `mandate=` / `origin=` / `classifierNoRuling=` / `differs=` 判别是哪一座;第四个成员是 `approval-content-kind.ts` 的 `readApprovalCard` —— 卡词 `approvalCard` 自己的闭集窄读,活 ask / LOCAL 店停驻门 / SQL 店读出的门子树三个载体共用一只,闭集 = core `TOOL_APPROVAL_CARDS`,detail 前缀 `approvalCard=`):活卡帧 / `card_json` / (S-700 起)运维队列行(`parkRowFacts` 读寄存行上的 park 孪生座;队列是热读面 ⇒ 同一行每读一次计一次)的一个**闭集词**座上,键在场而词不在本仓认得的那张表里(世代差,或第三方 producer)⇒ 该座**按缺席**处置。放行的最坏后果=卡上少一行「为什么这次没有规则候选」的解释(壳退回不显示该行),它**不改变任何裁决**——门在引擎里早已判完,本座是展示/观测面;反方向(把一个消费端词表外的值原样上卡)更坏:下游按闭集写的分支会落进 default 臂或渲染出生词。本臂存在的全部理由是**判别**:修前「上游发了个生词」与「上游根本没发这个键」在遥测上同形,而前者意味着本仓的词表该跟着 core 加词了(型面另有两向编译围栏,但那只在**重新编译**时说话,跑在线上的那一版不会自己红)。detail 带座名与那个词(经 redactSecrets 截 40);数 / 布尔等原始值原样,对象 / 数组 / 函数 / null 只报形名(`<object>` / `<array>` / `<function>` / `<null>`,S-700 codex r1:格式化从不调用值自己的转换方法 —— 持久层里一格 `{\"toString\":null}` 曾让诊断本身抛出、打掉整只队列)。",
@@ -401,6 +410,10 @@ export const FAIL_OPEN_TAGS = {
         cls: "F",
         note: "S-1874 / S-2137(`routes/approvals-assistant.ts` 的 `GET /v1/assistant/inbox`):每行的 `objective` = 这道门所属 run 的目标预览 —— 按 run id 直读那一行的 `objectivePreview` 列(写入时已脱敏 + 截断;`GET /v1/assistant/tasks` 读同一列)。门 → run 是按键直读:门所在会话的认领持有者 / 最近一条腿,委派子代的门读派它的那条 run(停驻子代行上的 `parentTaskId`,行经判别器 `findParkedAgentForCheckpoint` 取)。某一行这几次直读失败(店抖动 / 那一行 run 的 `result` 格读不出 —— SQL `getRun` 对坏格刻意抛)⇒ **这一行**的 `objective` 落 `null`,列表其余照常。放行的最坏后果 = inbox 上这一张卡这一次不显示它属于哪个任务(纯展示位;不参与任何决裁、续跑或门判)。不放行的代价是一行 run 读不出就打掉整个用户的待批列表(人看不到要批的卡)。故 F 类;必须留痕,否则「这一次没读成」与「这道门本来就没有 run」同形。detail = 那一行的会话 id 与错误句。前身(7.97.0–7.135.x):同一格读停驻上下文、坏体落 null 的那一只 tag(objective-ctx-corrupt),随 S-1874 退役(inbox 不再读续跑上下文)。",
     },
+    "server.submission-exit.withdraw-failed": {
+        cls: "F",
+        note: "`submission-exit.ts` 的收场:一次没被引擎受理、也没把查询责任交给自己耐久 run 的提交,出口在终局应答之前条件撤回它铸下的会话 —— 撤回事务抛了(店抖动 / 语句期限 / 本地删序某一步落不了盘)。放行的最坏后果 = 这只会话**留下**(无标题、零消息的一条,与撤回出口之前的读数同):撤回的方向是删,失败按「留」答是 fail-closed 的那一边 —— 不会删掉任何人写过的东西,应答照发、码不变。不放行的代价是一次清理失败把这次提交的应答也打掉。故 F 类;必须留痕,否则「撤回失败留下的空会话」与「保留条件命中留下的会话」同形。local 店的删序在落「删除中」标记之后失败 ⇒ 会话已不可见、待恢复,下一次取这只 id 的锁或起服收完(既有删序律)。detail = `session=<会话 id> err=<错误句,经运维日志出口座>`。",
+    },
     "server.objective-delivery.face-fill-failed": {
         cls: "F",
         note: "`run-acceptance.ts` 的补写口(腿上装着 prompt 屏时,本服务存 / 转目标的面在提交时不写,引擎交付之后以交付的那一份补写):某一张面的补写抛错 —— `run-preview`(run 行预览列的写一次补写,店抖动 / 行已被收割删除)、`fleet-name`(进程内 fleet 行的名;不会抛,列在闭集里是为了词全)。放行的最坏后果 = 那张面保持提交时的**空**:预览缺席(列表 / 收件箱 / fleet 行不显示这条 run 是什么任务)—— 少写,不是写错:不会写出屏前原文,不参与任何门判、续跑决裁或模型输入。不放行的代价是一次展示面的写失败打断这条正在跑的 run。故 F 类;必须留痕,否则「补写失败」与「屏改写过、本来就没有可写的那一份」同形。detail = `face=<面> err=<错误句,经运维日志出口座>`。",
@@ -461,6 +474,10 @@ export const FAIL_OPEN_TAGS = {
         cls: "F",
         note: "S-928(`plugins/user-input-ledger-file.ts`,local 车道 File 孪生的 boot 重放;登记名 `user-input-ledger`):账本中间一行读不出形(`42` / 缺键 / 词表外的 `kind`·`input`·`how`·`cause` / 半截 JSON;撕尾不走本 tag)⇒ 跳过它继续。S-969 L6 起 SQL 孪生(`plugins/user-input-ledger-sql.ts` `readRows`)同一只 tag:三只读口取到的行上读不出的列(`input_kind` 词表外 —— 新版本写的输入族 / 手改;收敛行缺 `state_at_ms`)⇒ 逐行跳过、其余照交,`listOpen` 的续翻游标按原始行推进(修前整页抛:收敛断点不前进、同会话通告与读面一并失效);坏行留在表里 ⇒ 每读一次计一次,非零 = 表里有本版本读不懂的行。最坏后果按行种:丢 `accepted` ⇒ 那次受理若真随崩溃丢了,不会被告知(= 本账之前的状态);丢 `settled` ⇒ 该受理在账上仍 open,下一趟收敛按 run 行判(S-969 L8,两车道同一只判词):本进程写的 / run 行已正常收场、已 park、易手 ⇒ 补结清、不告知;只有 run 行仍 `running` 且持有者是写者(local)、带死亡落款且持有者是写者、或行不在(local:File 店藏了读不出的行)⇒ 当成崩溃丢失告知一次;丢 `converged` ⇒ 下一次 boot 重收一次(幂等);丢 `announced` ⇒ 再告知一次;丢 `erased`(S-965,7.111.0 起的会话级墓碑;缺 `sessionId` 的那一行**不**读成「擦全部」)⇒ 被删会话的受理行在本进程的折叠里复现 —— 只有身份 + 时刻(无用户文本),读面 / 通告按 sessionId 取,同一个 id 被重新登记时新住客可见上一位的 `crashed` 告知(= 7.110.x 无级联时的状态);撕尾的 `erased` 不在此列:墓碑写在会话本体删除**之前**,撕掉 ⇒ DELETE 没有成功、会话还在,幂等重试重写。全在告知面,不开门 ⇒ F。修前不存在(本账本 S-928 新立)。",
     },
+    "server.sql-json.background-agent.unreadable-row-skipped": {
+        cls: "F",
+        note: "S-2406(`stores-sql/background-agent-store-sql.ts` 的 `listReadable` / `staleRowOrSkip`,两方言同调;披露口由组合座 `boot/stores.ts` 注入 —— 店构造参必填、交本函数):一行后台子代读不出(`usage_json` / `record_json` 坏体,或无名且句柄不是引擎形 ⇒ 名字派生不出)。列表读(`listBySession` / `listByScope`)**只在状态列证得它不活**(completed / failed / killed)时跳过它、其余照出,带上限的读按跳过数补足(上限计可读行);状态是 running / parked(或词表外)⇒ 整只读口带码拒(`StoreCorruptError`),不跳 —— 这一读也是活子代判据(会话删除 / 换绑 / 导入之前列活子代),跳过一只可能活着的行就是让破坏性操作看不见它。收割的陈旧臂跳过坏行、不删(删会绕过 core 收割的信箱 / 会话协同清理),行留着。最坏后果:一只终态子代从名册 / 任务列表上消失(展示面)、core 留存收割按列表枚举收不到它(行留在表里,每读一次计一次 —— 非零 = 表里有本版本读不出的终态行,运维修或删那一行);一只陈旧的坏 running 行不被翻成 failed(随后对它所在会话 / 作用域的列表读带码拒,直到修行)。不开任何门 ⇒ F。修前:一行坏 ⇒ `get` / `listBySession` / `listByScope` / `reap` 整只抛(名字那一种是裸 `TypeError`)。",
+    },
     "server.session-repo.corrupt-record-skipped": {
         cls: "F",
         note: "S-990(`plugins/local-session-store.ts` `createLocalSessionRepo` 的 `FileSessionRepo` 座,local 车道的会话存档;`LocalSessionStore` 与会话视图口 `audit.ts` 共用,S-879):一份会话存档里有记录读不出(整行毁 / 半截 JSON / 形不对,core 记成 `kind:\"record\"` 逐条披露)或存档文件 / 目录整体读不出(`kind:\"file\"`)⇒ core 的成文处置是跳过 + 披露,会话照常打开、列表少一行。最坏后果 = 模型读到的历史少了一截 / 列表静默少一份会话 —— 都是**可用性**损失,不开任何门;发起这一轮的人另有 wire 面披露(core 7.62.0 起引擎在 run 里说 `engine_notice` 码 `session.lineage_rerooted`,丢失账读自 core 交出的存储 `getReplayLoss`,与本 tag 无关;7.104.0–7.143.0 是本仓自铸的 `session.records_skipped`)⇒ F。**计数单位 = 一条被跳过的记录 = 一次命中**(`replay` 级是同一批记录的汇总,不计,S-616 同教训);**每命中一行探针**(`SEMA_FAILOPEN_PROBE`)带 `path` / `sessionId` / `line` / `form` / `reason` 逐条明细 —— 运维要看「哪份存档的哪一行坏了」读探针,不读本条 warn:本条是每进程每 tag 一次的告警(`detail` 是首条明细,不是全部)。修前:每命中一行 warn,一份 113 行坏记录的存档做一次列表 + 一次查看打出 342 行,存档没修好每读再发。",
@@ -478,8 +495,10 @@ export const FAIL_OPEN_TAGS = {
         note: "S-990(`boot/stores.ts` 的 `FileMailboxStore` 座,local 车道的邮箱 `<scope>/<handle>.jsonl`):一条邮箱事件读不出 ⇒ 跳过(撕尾静默是 core 的有意边界,不走本 tag)。最坏后果 = 一条消息读不到 —— 丢的是投递,不是授权,不开任何门 ⇒ F。单位 / 探针 / warn 同上。修前:每命中一行 warn(事件名 `mailbox_corrupt_read`)。",
     },
     "server.session-policy.corrupt-read-fail-open": {
-        cls: "P-DEBT",
-        note: "S-999(`observability/corrupt-read-seat.ts` 的 `createDurableAbsenceSeat`,`file_store_corrupt_read` 那只多脸座里认出的 **session-policy 脸**;local 车道,HTTP 服务的 local 腿与 run-local 同铸点):会话规则文件(数据根 `session-policy/` 下的行文件)坏了。core 7.39.2(#1299,本仓请托)起**按键读**(任务装规则、`GET` / `PUT /v1/sessions/:id/policy`)拒 —— `SessionPolicyError` 码 `corrupt`;core 7.41.0(#1309)起另三张脸对**有归属**的坏行(行里的 `__sid`,否则同名高水位标记的 `__sid`)也收紧了:① 本会话的 `listBySession` 拒(`corrupt`;会话同步导出 `GET /v1/sessions/:id/sync/manifest` 转 500 `corrupt`);② 别的会话的 `deleteBySession` 不动它;③ 数据根重绑带走它(新键上按键读照拒)。**仍按「无规则」的只剩无归属的坏行**(行里读不出 `__sid`、同名高水位标记也不在;core 包内 CHANGELOG 逐字「keeps its old fate」):枚举略过并披露、它「根本不是 JSON」时被任一会话的抹除扫掉(此后按键读得 ENOENT = 无规则)、重绑留在旧键下 —— 钉 `test/corrupt-read-f-seats-s990.test.ts` 的 🚧「S-1016 残余」格。会话规则**只许收紧** ⇒ 丢的恰是调用方加的收紧(部署策略 / hooks / shell 门仍在)。方向 = fail-open,**明知不对**;SQL 孪生(`plugins/session-policy-store-sql.ts`)对同形响亮抛(CENSUS 第 81 行 P 终态)。归 P 类的理由是它决定权限门读到的规则层;归 DEBT 的理由是放行是 **core 的裁定**,源头修复纪律下本仓不包层,只让债在遥测里显形:计数逐次 + 探针行(`kind` / `path` / `sessionId` / `principal` / `reason`)+ 一次性 warn;逐命中 warn(`file_store_corrupt_read`)原样保留。⚠️ **如实全记**:座上分不出是哪一只读法披露的(载荷不带读法),所以这一脸的每一发都计 —— 含已被拒的按键读与枚举(那些发本身是 fail-closed);抹除扫走无归属坏行那一形座上数不数得到未亲核。**出路 = core 把无归属行也改成拒,届时撤本 tag**(7.116.0 读不出能撤 ⇒ 照实留着)。计数非零 = 有会话的规则文件坏了:运维按探针里的 `sessionId` / `path` 去修(删文件即放弃那层规则,删前先看 `reason`)。认脸判据见 `durableAbsenceFaceOf`(披露路径落在本数据根的 `session-policy/` 之下);认不出的脸不计。7.114.0 合流时车 UY 曾以「core 已修」整只撤掉本 tag,修复轮恢复(那次删除未发版)。",
+        cls: "R",
+        ruling: "C-R1252",
+        bound: "只剩无从归属的坏行(行里读不出 `__sid`,同名高水位标记也不在、坏了或不带 `__sid`);有归属的坏行在按键读 / 枚举 / 别的会话抹除 / 数据根重绑四条读路上都拒",
+        note: "S-999(`observability/corrupt-read-seat.ts` 的 `createDurableAbsenceSeat`,`file_store_corrupt_read` 那只多脸座里认出的 **session-policy 脸**;local 车道,HTTP 服务的 local 腿与 run-local 同铸点):会话规则文件(数据根 `session-policy/` 下的行文件)坏了。core 7.39.2(#1299)起**按键读**(任务装规则、`GET` / `PUT /v1/sessions/:id/policy`)拒 —— `SessionPolicyError` 码 `corrupt`;core 7.41.0(#1309)起另三张脸对**有归属**的坏行(行里的 `__sid`,否则同名高水位标记的 `__sid`)也收紧了:① 本会话的 `listBySession` 拒(`corrupt`;会话同步导出 `GET /v1/sessions/:id/sync/manifest` 转 500 `corrupt`);② 别的会话的 `deleteBySession` 不动它;③ 数据根重绑带走它(新键上按键读照拒)。**按「无规则」放行的只剩无从归属的坏行**(行里读不出 `__sid`,同名高水位标记也不在、坏了或不带 `__sid`):枚举略过并披露、它「根本不是 JSON」时被任一会话的抹除扫掉(此后按键读得 ENOENT = 无规则)、重绑留在旧键下 —— 钉 `test/corrupt-read-f-seats-s990.test.ts` 的「无从归属坏行 = core 已知限制」格。归 R:core 已知限制 KL-1299-a 接受 —— 无从归属 ≠ 本会话,按会话拒读会把别的会话 / 无主的坏文件算到本会话头上,省略 + 披露是这一臂的终形;上界(结构式)= 只剩无从归属的坏行(行里读不出 `__sid`,同名高水位标记也不在、坏了或不带 `__sid`);有归属的坏行在按键读 / 枚举 / 别的会话抹除 / 数据根重绑四条读路上都拒。放行的最坏后果 = 一条无从归属的坏行上的会话收紧(调用方加的规则层)不生效;部署策略 / hooks / shell 门仍在;SQL 孪生(`plugins/session-policy-store-sql.ts`)对同形响亮抛(CENSUS 第 81 行 P 终态)。计数逐次 + 探针行(`kind` / `path` / `sessionId` / `principal` / `reason`)+ 一次性 warn,长期保留(它数的是有界放行实际发生了多少次,不期望归零);逐命中 warn(`file_store_corrupt_read`)原样保留。⚠️ **如实全记**:座上分不出是哪一只读法披露的(载荷不带读法),所以这一脸的每一发都计 —— 含已被拒的按键读与枚举(那些发本身是 fail-closed);抹除扫走无归属坏行那一形座上数不数得到未亲核。计数非零 = 有会话的规则文件坏了:运维按探针里的 `sessionId` / `path` 去修(删文件即放弃那层规则,删前先看 `reason`)。认脸判据见 `durableAbsenceFaceOf`(披露路径落在本数据根的 `session-policy/` 之下);认不出的脸不计。",
     },
     "server.approval-crash-convergence.cause-unreadable": {
         cls: "F",
@@ -529,6 +548,10 @@ export const FAIL_OPEN_TAGS = {
         cls: "F",
         note: "k8s 车道沙箱 Pod 回收器(`plugins/k8s-pod-reaper.ts` `reapOnce`,维护 tick 每副本每 5 分钟一轮)按身份标签列沙箱命名空间的 Pod **失败**(API 不可达 / 403 / 非 2xx)⇒ 这一轮一只都不删、不抛,下一轮一个周期后照常再列。最坏后果 = 已结束的沙箱 Pod 与已终 run 的 Pod(连同它们以 `ownerReferences` 挂着的 Secret —— 部署名单值 / 成员凭据租约)在 etcd 里多留至少一个周期:是**静态数据**多留,不是凭据被用 —— 成员凭据的使用界是代理的租约(到点 destroy,不随回收器);run 收尾的正常删除路不经本腿。不是门 / 凭据的放宽 ⇒ F。计数逐轮一次 + 探针行(`namespace=` + 原因)+ 同拍一行 warn `sandbox_pod_reap_list_failed`;修前只一行 info 轮次行(`listed:false`),不计数、不响。计数持续非零 = 回收器连续列不到 Pod,按原因核 API 可达性与 Role 的 pods `list`。",
     },
+    "server.local-docker-reaper.degraded": {
+        cls: "F",
+        note: "local-docker 车道无主容器回收器(`plugins/local-docker-reaper.ts` `reapOnce`,维护 tick 每副本每 5 分钟一轮;detail = `why=<list_failed|delete_unconfirmed> worker=<标签> <原因 | container=<名>>`)两种退化各计一次:`list_failed` —— 按本 worker 标签列 daemon 上的容器**失败**(docker 二进制起不来 / daemon 不可达 / 超时)⇒ 这一轮一只都不删、不抛,下一轮一个周期后照常再列;`delete_unconfirmed` —— 判了删的那一只 `docker rm -f` 按实例 id 退非零且答的不是「没有这只容器」⇒ 不挡同轮其余,这一只仍欠着(适配器的欠着机:此后永不附着、下一轮 / 下一只同身份环境先删它)。最坏后果 = 已终局 run 的容器(带着它的工作区)在宿主上多留至少一个周期,开了 `DOCKER_MAX_CONTAINERS` 的部署里多占一格:是**可用性 / 卫生**多留,不是门 / 凭据的放宽(容器的使用界 = 它那条 run 的终局 + 引擎终局之后的收尾窗,回收器等过保持窗才删);缺席倒向**不删**。归 F。",
+    },
     "server.sandbox-pod.delete-failed": {
         cls: "F",
         note: "k8s 车道**删一只沙箱 pod 却没删成**,两个座一只上报口(`plugins/k8s-pod-delete-failure.ts` `reportPodDeleteFailed`;detail = `namespace=<ns> pod=<名> why=<原因词> cause=<http_<状态>|request_failed>`):①连接清理座(`plugins/remote-env-k8s.ts` `discardRefusedPod`,`why` = `env_secret_unsealed|lease_secret_unsealed|broker_image_pull_failed`):env Secret / 租约 Secret 建不成、或代理镜像拉不下 ⇒ 连接被拒、该 pod 要删,而这一删本身失败(请求抛 / API 回 403、5xx 等非 2xx 非 404)⇒ 拒答不变(仍是原来那一条),pod 与挂在它名下的 Secret(部署名单值 / 租约占位)留在命名空间里,由回收器兜(`plugins/k8s-pod-reaper.ts`:带 run 标签的按 run 终态删,不带的等容器全部结束后删);②回收器座(`plugins/k8s-pod-reaper.ts` `reapOnce` 的删一步,`why` = `reaper_containers_ended|reaper_run_ended_past_hold`):兜底本身删失败 ⇒ 这一只留到下一轮(一个周期后)再判再删,一只失败不挡同轮其余。最坏后果 = **静态数据**多留至少一个回收周期(与 `server.sandbox-pod-reaper.list-failed` 同一件事的另一半):没有值进 pod spec、没有连接被放过、成员凭据的使用界是代理的租约 ⇒ 不是门 / 凭据的放宽 ⇒ F。计数逐次 + 探针行 + 同拍一行 error `sandbox_pod_delete_failed`(pod / 命名空间 / 原因词 / 原因码,不带值、不带 API 文本;运维行座缺席或只有 warn 的座上行不发、计数照记);修前连接清理三处 `.catch(() => {})` 吞,零日志零计数,回收器的删失败只落一行 warn(不计数)。计数持续非零 = 删 pod 的 Role 动词(pods `delete`)或 API 可达性有问题,按 `cause` 核;`why` 以 `reaper_` 起头的计数持续非零 = 兜底本身删不动,残留会随轮次累积。",
@@ -565,7 +588,11 @@ export const FAIL_OPEN_TAGS = {
     },
     "server.config-dir-trust.win32-owner-mode-unverifiable": {
         cls: "P-DEBT",
-        note: "S-163(`config-dir-trust.ts` `judgeWin32`,本地配置源 `config.d` 读之前的目录信任判官在 win32 上的那一半):Node 在 win32 上 `uid` 恒 0、模式位是只读属性的投影 ⇒ 「属主 ∈ {本服务用户, root, CONFIG_LOCAL_OWNER_UID}」与「不得组 / 他人可写」两判不可做;结构判(常规文件 / 16 MiB 上界 / 链接成环)照做。每一次读照常进行(起服一次 + 每拍一次)记一次。放行的最坏后果 = 一台多用户 Windows 机器上,别的本机用户若能写这台服务的 `config.d`(缺省的用户目录 ACL 不允许),改一份 `mcp.json` 就能让本服务以它的身份起命令 —— 与 7.132.x 逐字同。照 POSIX 拒启会让每个 Windows 本机引擎(含 cli 起的)升级即起不来,而让 cli 替用户设豁免键是中间层替部署者设安全旋钮。收口 = 有了 ACL 判据或一次裁定(改 R 或改拒启)那一版,本 tag 删或改类。detail = `config.d=<物理路径>`。",
+        note: "S-163(`config-dir-trust.ts` `judgeWin32` / `judgeWin32File`,本地配置源 `config.d` 读之前、LKG 读回与调度共享店读写之前的同一只目录信任判官在 win32 上的那一半;detail 前缀 `lkg=` / `scheduler-store=` 指后两只读者):Node 在 win32 上 `uid` 恒 0、模式位是只读属性的投影 ⇒ 「属主 ∈ {本服务用户, root, CONFIG_LOCAL_OWNER_UID}」与「不得组 / 他人可写」两判不可做;结构判(常规文件 / 16 MiB 上界 / 链接成环)照做。每一次读照常进行(起服一次 + 每拍一次)记一次。放行的最坏后果 = 一台多用户 Windows 机器上,别的本机用户若能写这台服务的 `config.d`(缺省的用户目录 ACL 不允许),改一份 `mcp.json` 就能让本服务以它的身份起命令 —— 与 7.132.x 逐字同。照 POSIX 拒启会让每个 Windows 本机引擎(含 cli 起的)升级即起不来,而让 cli 替用户设豁免键是中间层替部署者设安全旋钮。收口 = 有了 ACL 判据或一次裁定(改 R 或改拒启)那一版,本 tag 删或改类。detail = `config.d=<物理路径>`。",
+    },
+    "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、挂载形不常见)或路径上有权限竞态。",
     },
     "server.remote-write.staging-dir-left": {
         cls: "F",
@@ -573,7 +600,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/runs`)、续跑腿。锚店写抛(库抖 / 表缺 / 盘满),或单行店操作期限(`BASELINE_IO_DEADLINE_MS`,2 s;与项目指令基线读写同一只数、同一只 `withinIoDeadline`)内没落定(锚店挂住:锚店的写口自己不带期限)⇒ 这一次提示词(或这一轮助手文本)此刻没有回退手柄,run 照常收尾、终帧照发、不改任何终局;到期只放手不取消,那次写照常在飞、迟到落定的锚照样可用(迟到的失败被吞,不重复计数)。放行的最坏后果 = 用户拿这次 run 的 taskId 去 `resumeAt` 得 404 `resume_at.unknown_event`、会话视图里那条用户消息行不带 `taskId` 手柄(用户面的读数只有这一处真源,本臂不另铸第二份);不是门、不是凭据。不放行(抛)的代价是让一次锚写失败把整条已经跑完的 run 判成失败。计数持续非零 = 锚店写不进(去看库)。计数里 `reason=timeout` 占多数 = 锚店慢到秒级(去看库的锁 / 连接池)。detail = `leg=<stream|bg|resume> kind=<prompt|turn> reason=error error=<写口的错误句>` 或 `… reason=timeout boundMs=<期限>`。",
+        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=<期限>`。",
+    },
+    "server.resume-anchor.cause-read-failed": {
+        cls: "F",
+        note: "未知回退手柄的 404 成因半句(`history-anchor.ts` 的唯一组句器;提交体 `resumeAt` / `rewindFilesTo` 与 run 外回退口 `to` 三处同调):锚店里没有这只手柄 ⇒ 经属主存取器读一次 run 行(嵌套可选读,看不见 ≡ 没有)、同会话 ⇒ 按这条提问自己的属主键再问一次锚店,只为选句(调用方看得见的本会话提问、它自己也没落锚 ⇒ 「没有锚的提问」并点名带附件不落锚那一类;否则只说没有锚)。这两读任一抛(库抖 / 表缺)⇒ 404 的码与状态照旧,句子退回只说没有锚。放行的最坏后果 = 一条真实存在、没有锚的提问,其 404 少了那半句说明(调用方可能当成手柄写错);不影响任何判定、不放行任何请求。",
     },
     "server.remote-write.stage-seal-fallback": {
         cls: "F",
@@ -581,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",
@@ -596,26 +635,21 @@ export const FAIL_OPEN_TAGS = {
         note: "能力位 `adoptionImport`(`adoption/import.ts` 的 `readAdoptionImportCapability`,`GET /v1/capabilities` 每请求一读):按调用者读它作为源主体的那一条收编行时库读抛(断连 / 超时 / 池断)⇒ 这一位缺席、能力面照常 200。放行的是**藏**的方向:缺席 = 「你还没被收编」,触发臂不出导入入口,导入口本身不受影响(它自己读行、读失败照常 5xx)。最坏后果 = 这一拍用户看不到「一键收编」,下一次读能力面恢复。计数非零 = 收编日志所在的库在这台副本上读不动。",
     },
 };
-export function failOpenTagForDroppedFrame(frameType) {
-    switch (frameType) {
-        case "question":
-        case "elicitation":
-            return "server.hitl.frame-undelivered-stream-closed";
-        case "question_complete":
-            return "server.question.complete-breadcrumb-dropped";
-        case "elicitation_complete":
-            return "server.elicitation.complete-breadcrumb-dropped";
-        default:
-            return "server.stream.frame-dropped-stream-closed";
-    }
-}
 export function buildFailOpenAnchor(tag) {
     return `[sema] fail-open: ${tag}`;
 }
-let announceEmitter;
+let announceExit;
+const pendingAnnouncements = [];
 function announceAsJsonLine(facts) {
-    announceEmitter ??= createLogger("warn");
-    announceEmitter.warn(buildFailOpenAnchor(facts.tag), { tag: facts.tag, count: facts.count });
+    if (announceExit === undefined)
+        pendingAnnouncements.push(facts);
+    else
+        announceExit(facts);
+}
+export function installFailOpenAnnounceExit(exit) {
+    announceExit = exit;
+    for (const facts of pendingAnnouncements.splice(0))
+        exit(facts);
 }
 export const FAIL_OPEN_PROBE_ENV = "SEMA_FAILOPEN_PROBE";
 const FAIL_OPEN_COUNTER = "fail_open_total";

package/dist/observability/logger.d.ts

@@ -1,4 +1,3 @@
-/** Minimal structured (JSON-line) logger. One line per event → stdout/stderr, scraper-friendly. */
 export type LogLevel = "debug" | "info" | "warn" | "error";
 export interface Logger {
     debug(msg: string, fields?: Record<string, unknown>): void;
@@ -6,5 +5,27 @@ export interface Logger {
     warn(msg: string, fields?: Record<string, unknown>): void;
     error(msg: string, fields?: Record<string, unknown>): void;
 }
+/** 一行诊断去哪条流(`console.log` / `info` 那一支 = stdout,`warn` / `error` = stderr)。 */
+export type LogStream = "stdout" | "stderr";
+export declare function reserveStdoutForAnswer(): void;
 export declare function createLogger(minLevel?: LogLevel): Logger;
+/**
+ * 一段诊断散文(`util.format(...parts)`,与 `console.*` 逐字同一种格式化)+ 换行,过座表的 `log-text` 行。
+ *
+ * 返回的 promise 在这一行的字节**交给流之后**才 settle(流坏了 ⇒ 当场 settle;**从不 reject**)—— 与 {@link writeCliResult} 同形:写完就退出的入口等它
+ * (macOS 上管道是异步写,`process.exit` 会截断还在缓冲里的较长句子);不关心的调用点丢弃返回值即可(promise 永不 reject,丢弃它不会冒未处理的拒绝)。
+ * 过座途中到达的行排队后写出(见头注「重入」),它的 promise 在它自己的写回调到了之后 settle。
+ */
+export declare function writeLogText(stream: LogStream, ...parts: unknown[]): Promise<void>;
+/**
+ * 非日志输出 ①:一次性入口交给调用者的结果(stdout,产品输出)—— `run-local` 的任务结果(与 `claude -p` 打印最终回答同形)、起服前模型面探针的那一行
+ * `modelPlane` 读数(闭集词,零自由文本)。返回的 promise 在字节交给流之后 settle(从不 reject),写完就退的入口等它。**不过座**:那是用户自己
+ * 这次任务的产物,不是运维日志;脱它 = 改写回答(修前同样逐字)。
+ */
+export declare function writeCliResult(text: string): Promise<void>;
+/**
+ * 非日志输出 ②:`run-local` y/N 问句的输出流(readline 写问句;stderr)。**不过座**:人批的是问句里那一份参数,
+ * 被脱了就批不了看不见的东西(问句的终端安全化在 `run-local.ts`)。
+ */
+export declare function ttyPromptOutput(): NodeJS.WritableStream;
 //# sourceMappingURL=logger.d.ts.map

package/dist/observability/logger.js

@@ -1,4 +1,12 @@
+import { format } from "node:util";
+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 };
+const LOG_LINE_WITHHELD = "log_line_withheld";
+const SECRET_SCREEN_FAILED = "secret_screen_failed";
+const UNFORMATTABLE = "unformattable";
+const FIELDS_WITHHELD = "fieldsWithheld";
 let stdioErrorsSwallowed = false;
 function swallowStdioErrors() {
     if (stdioErrorsSwallowed)
@@ -7,23 +15,60 @@ function swallowStdioErrors() {
     process.stdout.on("error", () => { });
     process.stderr.on("error", () => { });
 }
+function writeOut(stream, text, flushed) {
+    swallowStdioErrors();
+    try {
+        process[stream].write(text, () => flushed?.());
+    }
+    catch {
+        flushed?.();
+    }
+}
+let screening = false;
+const deferred = [];
+function screened(emitLine) {
+    if (screening) {
+        deferred.push(emitLine);
+        return;
+    }
+    for (let next = emitLine; next !== undefined; next = deferred.shift()) {
+        screening = true;
+        try {
+            next();
+        }
+        finally {
+            screening = false;
+        }
+    }
+}
+function screenJsonLine(line, withheld) {
+    const out = seatText("log-record", line);
+    return out === OVERSIZED_REDACTION_PLACEHOLDER ? withheld() : out;
+}
+function serializeEntry(head, fields) {
+    try {
+        return JSON.stringify({ ...head, ...fields });
+    }
+    catch (err) {
+        return JSON.stringify({ ...head, [FIELDS_WITHHELD]: errorKindOf(err) });
+    }
+}
+let stdoutReservedForAnswer = false;
+export function reserveStdoutForAnswer() {
+    stdoutReservedForAnswer = true;
+}
+const diagnosticStream = (stream) => (stdoutReservedForAnswer ? "stderr" : stream);
 export function createLogger(minLevel = "info") {
     swallowStdioErrors();
     const emit = (level, msg, fields) => {
         if (ORDER[level] < ORDER[minLevel])
             return;
-        let line;
-        try {
-            line = JSON.stringify({ ts: new Date().toISOString(), level, msg, ...fields });
-        }
-        catch {
-            line = JSON.stringify({ ts: new Date().toISOString(), level, msg });
-        }
-        try {
-            (level === "error" || level === "warn" ? process.stderr : process.stdout).write(line + "\n");
-        }
-        catch {
-        }
+        const ts = new Date().toISOString();
+        const line = serializeEntry({ ts, level, msg }, fields);
+        screened(() => {
+            const out = screenJsonLine(line, () => JSON.stringify({ ts, level, msg: LOG_LINE_WITHHELD, reason: SECRET_SCREEN_FAILED }));
+            writeOut(diagnosticStream(level === "error" || level === "warn" ? "stderr" : "stdout"), `${out}\n`);
+        });
     };
     return {
         debug: (m, f) => emit("debug", m, f),
@@ -32,4 +77,36 @@ export function createLogger(minLevel = "info") {
         error: (m, f) => emit("error", m, f),
     };
 }
+let failOpenAnnouncer;
+installFailOpenAnnounceExit((facts) => {
+    failOpenAnnouncer ??= createLogger("warn");
+    failOpenAnnouncer.warn(buildFailOpenAnchor(facts.tag), { tag: facts.tag, count: facts.count });
+});
+export function writeLogText(stream, ...parts) {
+    let text;
+    try {
+        text = format(...parts);
+    }
+    catch {
+        text = `${LOG_LINE_WITHHELD}: ${UNFORMATTABLE}`;
+    }
+    let flushed;
+    const settled = new Promise((resolve) => {
+        flushed = resolve;
+    });
+    try {
+        screened(() => writeOut(diagnosticStream(stream), `${seatText("log-text", text)}\n`, flushed));
+    }
+    catch (err) {
+        flushed();
+        throw err;
+    }
+    return settled;
+}
+export function writeCliResult(text) {
+    return new Promise((resolve) => writeOut("stdout", `${text}\n`, resolve));
+}
+export function ttyPromptOutput() {
+    return process.stderr;
+}
 //# sourceMappingURL=logger.js.map

package/dist/observability/metrics.js

@@ -215,6 +215,7 @@ export function createMetrics() {
     m.counter("http_requests_total", "HTTP requests by route/method/status");
     m.histogram("http_request_duration_seconds", "HTTP request duration");
     m.counter("rate_limited_total", "Requests rejected by the rate limiter");
+    m.counter("submission_exit_total", "Submission exit closes by end word (accepted|record|refused) and verdict (withdrawn | kept_<word>): what happened to the session a submission minted when it ended — withdrawn = a refused submission's fresh session removed before the terminal answer; kept_upgrade_pending = the database has no withdraw mark yet (an earlier-version replica may still be serving); kept_withdraw_failed = the withdraw threw and the session stayed (see the fail-open tag)");
     m.counter("brain_echo_dropped_total", "Provider echo fields (response request-id header / reported model name) the engine's brain dropped at write time for failing the echo shape (visible ASCII, 1-128 chars), by field (requestId|responseModel|apiErrorCode — the last is the provider's own refusal word on a 4xx, core 7.38.0); non-zero = the endpoint or a gateway in front of it echoes out-of-shape bytes");
     m.counter("mcp_probe_total", `No-run MCP status face outcomes by outcome (${MCP_PROBE_OUTCOMES.join("/")} — see src/capabilities/mcp-probe.ts MCP_PROBE_OUTCOMES; rate_limited has TWO causes: the per-identity fixed window AND the replica-wide in-flight cap, which can refuse caller B because of caller A)`);
     m.counter("tasks_total", "Finished tasks by terminal status");
@@ -238,8 +239,9 @@ 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)");
     m.counter("task_model_not_allowlisted_resume_total", "Resumed legs whose model/compactionModel is outside the @-mention allowlist (allowed to keep running by design — the allowlist gates fresh picks only)");
     m.counter("task_model_unavailable_fallback_total", "Resumed legs whose explicit model pick names a catalog entry that is unavailable on this deployment (no brain mounted for its provider / entry fails its schema) — the leg runs on the default model; fresh submits get 400 request.model_unavailable");
@@ -272,10 +274,6 @@ export function createMetrics() {
     m.counter("brain_calls_total", "Brain calls by provider/model (S18); provider=unknown = unrecognized routing fallthrough");
     m.gauge("fleet_counter_bucket_skew_ms", "DB clock minus local clock in ms (S10) — skew splits cross-replica counter windows");
     m.gauge("fleet_clock_probe_ok", "1 = last DB clock probe succeeded, 0 = failing (skew gauge is stale while 0)");
-    m.counter("lsp_bridge_start_total", "LSP sandbox bridge (re)starts attempted, by provider and generation");
-    m.counter("lsp_bridge_dead_total", "LSP sandbox bridge generations that died, by reason (the word IS the model-facing unavailableReason)");
-    m.counter("lsp_session_open_total", "LSP session opens, by language and outcome (ok/failed)");
-    m.counter("lsp_session_heal_total", "LSP session heals (dead-transport reopen), by outcome (ok/failed)");
     m.gauge("snapshot_blob_backend", "1 on the active snapshot-blob backend series (S21), by backend (minio|sql)");
     m.counter("memory_embed_failed_total", "Memory embedding calls that failed at runtime (S22), by backend (the memory-engine dialect that owns the embedder)");
     m.counter("memory_knn_query_failed_total", "Memory KNN searchScored queries that failed at runtime (S22)");
@@ -303,6 +301,7 @@ export function createMetrics() {
     m.counter("remote_env_file_timeout_total", "Remote-env file-op timeouts, by provider");
     m.counter("remote_env_rpc_timeout_total", "Remote-env RPC timeouts, by provider");
     m.counter("sandbox_pods_reaped_total", "Sandbox pods deleted by the k8s lane's pod reaper, by reason (containers_ended: every container finished; run_ended_past_hold: the pod's run ended longer ago than the hold)");
+    m.counter("local_docker_containers_reaped_total", "Containers deleted by the local-docker lane's orphan-container reaper, by reason (run_ended: the container's run row is terminal — nothing can use its workspace any more)");
     m.counter("task_outcomes_total", "Task outcome-ledger rows recorded, by status and oracle green flag");
     m.counter("workflow_runs_total", "Self-orchestration workflow runs, by status");
     m.histogram(EXECUTION_CLAIM_METRIC, "Execution-claim round-trip latency by step (run_claim: RunStore.createRun incl. the SQL root-session row lock; placement_commit: the one post-claim execution-placement write)", [0.001, 0.005, 0.02, 0.1, 0.5, 2, 10]);

package/dist/observability/otel-exporter.js

@@ -1,4 +1,5 @@
 import { recordFailOpen } from "./fail-open.js";
+import { createEgressFetch } from "../egress-redirect.js";
 const CUMULATIVE = 2;
 const nano = (ms) => (BigInt(ms) * 1000000n).toString();
 const attrs = (labels) => Object.entries(labels).map(([key, v]) => ({ key, value: { stringValue: String(v) } }));
@@ -61,7 +62,7 @@ export function buildOtlpPayload(snap, opts) {
 export function startOtlpExporter(metrics, opts) {
     const startMs = Date.now();
     const url = `${opts.endpoint}/v1/metrics`;
-    const fetchImpl = opts.fetchImpl ?? fetch;
+    const fetchImpl = createEgressFetch("declare the final collector address as OTEL_EXPORTER_OTLP_ENDPOINT", opts.fetchImpl);
     let inFlight = false;
     const exportOnce = async () => {
         if (inFlight)