@sema-agent/server 7.132.0 → 7.134.0

package/dist/observability/fail-open.js

@@ -28,13 +28,17 @@ export const FAIL_OPEN_TAGS = {
         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 删。",
     },
-    "server.workflow-park-index.sync-failed": {
-        cls: "P-DEBT",
-        note: "S-185 车CM(codex r1-F2 [high],验真后登记):workflow 出身 park 的 join 索引(`workflow_agent_session` / local 账本)在**一次成功的 run 写之后**同步失败 ⇒ 该次同步被吞,重试要等这条 run 的**下一次**写。而 park 恰好常常是这条 run 的**最后**一次写(park = run 终局 `failed`)⇒ 那条 park 可能永久 join 不到。**多数情形**是诚实 miss:这张卡没有别的指针 ⇒ `/decide` 结构性退回本批之前的行为(409 `conflict.resume_context_unavailable`),不误配、不伪造、不放行,丢的是「人能不能把这条批准送出去」这个能力。**7.118.0 起不止于此**:路由把指针候选当持有者的全集读,并有分叉门(两条同代次持有者 ⇒ 409 `decide.workflow_park_forked`);同一张卡上一枚**竞争**指针没写上(本臂的写失败,或写记录与写指针之间进程崩溃 —— 后者不经本臂、不计数)⇒ 分叉被判成唯一持有者 ⇒ 决定投给幸存的那一支(它确实持有这张卡,但另一支同样站在上面,引擎把这种形交给消费方拒)。归 P 类的理由:缺指针决定**车道选择**(缺行 ⇒ 选中 legacy 腿),且能让分叉门失效;归 DEBT 的理由是真正的解要一条**按子代 checkpoint 键的耐久决议回执 + 重启期回填**(与 codex r1-F3 同一件欠账,另车),分叉门失效那一形另有设计票。计数非零 = 有 park 可能决不掉、或这张卡的分叉门可能失效,运维要按 detail 里的 runId 去查那条 run 的续跑链。",
-    },
     "server.workflow-park-index.parks-unreadable": {
         cls: "F",
-        note: "S-1173(`workflow-notify-journal.ts` 的 `syncAgentSessionIndex`,与上一条 `sync-failed` 同一个写点、另一臂):workflow run 记录的 `parks[]` **读不出**(在场却不是列表 / 某条目身份位或持有者两位形坏;读者 = `workflow-agent-session-index.ts` 的 `readRunParks`,整档成败制)⇒ 这一份指针投影派生不出来 ⇒ 写者**不动**这条 run 已有的指针(上一份已知良好的投影留着)。修前这一臂静默 `return`。**`parks` 缺席不进这一臂**:那是引擎契约里的合法形(更早引擎写的记录 / 准入没走完的续跑记录),读者答 `[]`(没有条目),写者照常收敛成空指针集,不计。**与 `sync-failed` 分家的理由(后果不同句,不并成一个 tag)**:`sync-failed` 是索引**写**挂了、丢的是一份已知良好的投影(park 常常是 run 的最后一次写 ⇒ 永久 join 不到,归 P-DEBT);本臂没有丢任何一份已知良好的投影 —— 读不出的是**记录本身**,引擎对条目形坏的记录整条拒续跑(`park_binding_broken`),读口对已有指针的 run 据记录响亮拒(`unproven/unreadable`),所以无需「重试这次写」,要的是查那条记录为什么读不出(投影把它写坏 / 手改)。放行的最坏后果:这条 run 的指针不被刷新(从没写过则没有指针 ⇒ 这张卡没有别的指针时 `/decide` 落 legacy 腿、409 响亮拒),多数情形方向是 fail-closed,不误配、不放行任何东西;例外与上一条同形 —— 首写就读不出的这一支没有指针,同一张卡上另一支的指针在时分叉门判不出、决定投给那一支(引擎从不写坏形,要这一支在首写之前就被写坏,比上一条的写失败更罕见);derived cache 没更新、真源读口自带响亮拒 ⇒ F 类。detail = `runId=`;计数非零 = 有记录的 `parks[]` 读不出,按 runId 去查记录。",
+        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-park-decision.card-unreadable": {
+        cls: "F",
+        note: "起跑读者(`parked-decide.ts` 的 `heldWorkflowParkDecisions`,每一只起跑器开跑前一次)读某条已受理的 workflow 子代决定所属的那张卡时 checkpoint 店抛 ⇒ 这一跑**不带**这条决定,行留着给下一跑。放行的最坏后果:这一跑里宿主若续跑那条 workflow run,子代按同一个 token 再停驻一次(卡仍 pending,决定仍在,下一跑照带)—— 方向是少交付一次,不是错交付:这一读失败不代表引擎随后那一读也失败,而引擎对「卡已不 pending、却拿到一条决定」的序数会当确认结算,所以读不出时绝不照供。计数持续非零 = checkpoint 店对这张卡读不出(库故障 / 行坏 / 写者版本更新),按 detail 的 `runId=`(受理那一刻的持有者)去查。detail = `runId=<留存锚> err=<原句,经记录器脱敏>`。",
+    },
+    "server.workflow-park-decision.store-unreadable": {
+        cls: "F",
+        note: "起跑读者(`parked-decide.ts` 的 `heldWorkflowParkDecisions`,每一只起跑器开跑前一次)读这个会话的 workflow 子代决定行时**决定店抛**(local 账本中间一行读不出 ⇒ 闸合上;SQL 这个会话的某一行 `outcome` 坏体 ⇒ 行读者拒)⇒ 与同一读者读卡失败那一臂同律:这一店当「没有可供的行」,这一跑只带调用方带来的那一份(`/decide` 的投递跑带着刚受理的那一条),起跑照常。放行的最坏后果:这个会话里已受理、还没被引擎用掉的决定这一跑都不带 —— 宿主若续跑那条 workflow run,子代按同一个 token 再停驻一次,卡仍 pending、可再决;方向是少交付,不是错交付(读不出的那一行可能正是**取代**了旧决定的那一笔,所以绝不跳过坏行照供其余)。决定的写口与按 token 读(`/decide` 的回执幂等判)照旧带码拒 —— 账本修好之前决不掉 workflow 子代卡,但不再连带拒掉每一跑(修前:local 上整台部署、SQL 上该会话的每一只起跑器都拒)。计数持续非零 = 决定店读不出,local 按披露 `workflow_park_decisions_corrupt_read` 去看账本文件,SQL 按 detail 的会话去查那几行。detail = `hostSessionId=<宿主会话> err=<原句,经记录器脱敏>`。",
     },
     "server.trace.gate-outcome-defective": {
         cls: "F",
@@ -160,6 +164,10 @@ export const FAIL_OPEN_TAGS = {
         cls: "F",
         note: "S-700(`plugins/checkpoint-store-sql.ts` 的 `readParkRowFactsCell`):运维待批队列(`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 查那一行。 **第二座 `member=gate`**(`readParkGateCell`:同一列的 **`gate` 子树**在场却不是一只对象 —— 队列行的卡词与到期两条腿的分法都读它):读不出 = 门上无卡,队列行不带卡词,**到期改道** —— core `facetOf` 读「无卡 = 不是一问」为 `A`,所以一张本该到期**作废**的问答行改走 SLA **拒扫腿**(模型拿到一次「拒」而不是整条 run 作废);改道后的续跑 `get()` 对同一份坏 blob 响亮拒(拒扫腿每拍一条失败),行留停驻、由 `terminal_at_ms` 兜底收割 —— 所以最坏后果**不是**「只少展示」,是一张问答行的到期去向变了、最长挂到绝对上限。放行仍对:不放行的代价与 pendingAction 座同(一行坏 blob 打掉整个租户的队列与到期读腿)。计数 detail = `member=gate` 时,去按 session 查那一行的 `checkpoint.gate`。",
     },
+    "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 一拍重读,同一行每拍计一次(量值 = 行 × 拍数,在场才是信号)。",
+    },
     "server.approvals.queue-row-gate-kind-missing": {
         cls: "F",
         note: "S-1681(`plugins/checkpoint-store-sql.ts` 的 `queueRowGateKind`,7.132.0;SQL 与 local 两只孪生的 `listPending` 同调这一只判官):运维待批队列(`GET /v1/approvals` / `/stream`)读到一行 pending 的门型(SQL 孪生:`checkpoint.gate_kind` 列;local 孪生:快照上的门)是 NULL 或不是 core 登记的门型 ⇒ 这一行**不列**。按构造不可达:每次停驻都把门型反范式进这一列,一次性迁移 M21 把没有它的存量行从门子树补齐(读不出登记门型的置 expired)。放行(不列、队列其余照常)的最坏后果 = 一行谁也决不了的行不出现在队列上 —— 它本来就不可决:每一条决断口按门型绑定取行(`gate_kind IN (…)`),证不出门型就不当它是这道门;不放行(整只拒)的代价是一行坏行打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远停在旧帧)。也不按缺键投出去:消费方按 `gateKind` 路由、缺键即 fail-closed,队列行的契约是 `gateKind` 恒在场。故 F 类;计数非零 = 写腿或手改出了错,`SELECT session_id FROM checkpoint WHERE status = 'pending' AND gate_kind IS NULL` 查那一行(置 expired 或删会话)。",
@@ -268,9 +276,9 @@ 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-tombstone-global-cap-refused": {
+    "server.approval.park-redemption-cap-refused": {
         cls: "F",
-        note: "#343(黑板 [5100] Q3):park 墓碑表(#329 迟到回决的 wire approvalId → 店内坐标指路条)**全局帽已满、而本 principal 还没到自己的 per-principal 子帽** ⇒ 这条新墓碑**不落**(拒新,一格都不挤别人)。放行的最坏后果 = 这一只 ask 的 **live 腿指路便利**缺席,壳按 Yes 拿到的是 404 `unknown_or_other_replica` —— 也就是 #329 之前的那一格逐字行为,既不会错兑也不会双兑;**完整兑付面一个字节没动**(park 行本体在 durable 店未失,`GET /v1/approvals` 列表 + `/v1/approvals/:sessionId/decide` 仍可回决),故 F 类而不是保护型。为什么方向是「拒新」而不是修前的「FIFO 挤最旧」:那个形让**甲的用量决定乙的可用性**(已鉴权租户量产 park 终局 ask 即可把别家墓碑全部挤出,merge-rescan 744 confirmed),而 park 是常态路由、不需要任何异常手法。必须留痕:「表被别人打满」与「这张卡本来就没有墓碑」在 wire 上完全同形,不计数则运维只能靠「用户说按 Yes 老是 404」这种间接症状发现,而那正是 [4845] 排障代价实证过的那条路。detail 带 owner(判「压力来自谁」的第一手线索)。本 tag 有**两条臂、两个根因**,detail 判别:(a) 全局帽满且本 principal 未超子帽 ⇒ 拒新(detail 带 owner);(b) 本 principal 超子帽但名下条目**全在飞**、无一可逐 ⇒ 拒新(detail 带 `reason=all-inflight`)。超子帽且**有**可逐条目的常态臂逐自己最旧的一条(量产者自伤,设计内有界表纪律)才不走本 tag。",
+        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;在飞的单飞句柄不占帽、永不被逐。",
     },
     "server.approvals.stale-echoed-token-unreadable": {
         cls: "F",
@@ -306,7 +314,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-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 帧自由文本位上抛 ⇒ 这一位换同一枚占位、投影不抛):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",
@@ -351,6 +359,10 @@ export const FAIL_OPEN_TAGS = {
         cls: "F",
         note: "S-582(`plugins/send-file-ledger.ts`,local 车道的发文件账本):一条账行读不出形(`42` / 缺 id·scope·objectKey 三元组 / 中间半截 JSON)⇒ 跳过它继续。最坏后果 = 那条已签发的链接在它租户的列表里**看不见**(对象本身没动;账本本来就不存 URL)。治理面少一行是可见性损失,不是放行 ⇒ F;但它恰是治理面要看的那一类事实,所以必须留痕 —— 修前零披露。",
     },
+    "server.approval-ask-audit.rotate-dir-fsync-failed": {
+        cls: "F",
+        note: "S-322(`approval-ask-audit-store.ts` `rotateOlderThan`,审批账本留存律的审计账半场):轮转把留下的行原字节写进暂存文件(core `writeThenLink`:数据已 fsync)并 `rename` 盖上之后,目录 fsync 失败。换文件**已经落定且可见**、内存索引与 `crashConverged` 读面已经跟上,所以不回滚(也回滚不了)、读数照交。放行的最坏后果:掉电后目录项可能还指旧账本 ⇒ 删掉的行回来(下一拍再删,无害),轮转之后追加、在下一次目录落盘之前掉电的行可能丢(与 `append-failed` 同类后果:痕迹缺几条,审批结算不受影响)。与 core 原子写对目录 fsync 的尽力而为同一姿态(core 吞掉),这里改为留痕。审计店不开门、不改任何审批结算 ⇒ F。",
+    },
     "server.approval-ask-audit.corrupt-record-skipped": {
         cls: "F",
         note: "S-967(`approval-ask-audit-store.ts`,local 车道 File ask 审计店的 boot 重放;登记名 `approval-ask-audit`):账本**中间**一行读不出形(`42` / 数组 / 缺键 / 词表外 `kind`·`outcome`·`orphanState` / 半截 JSON;撕尾不走本 tag)⇒ 跳过它继续。最坏后果按行种:丢 `ask` ⇒ 那只孤儿在崩溃收敛读面缺席(无身份可列);丢 `settle` ⇒ 该组按 pending 臂收(审批门在执行之前 ⇒ 若这条 settle 其实是 `allowed` 且工具已执行,`resumeSafe:true` 是错的 —— 与头注「双故障窗」同族);丢 `leg_closed` ⇒ decided 臂多收一行(保守方向);丢 `crash_converged` ⇒ 下一次 boot 重收(幂等);丢 `interrupted_by_shutdown` / `late_settle` ⇒ 成因注退回 `crashed_before_park` / 少一行取证。审计店不开门、不改任何审批结算 ⇒ F。修前:重放坏行只计入 `convergeCrashedAsks().corruptLines`(boot 日志一个数),**无逐条披露、无 tag**。",
@@ -461,7 +473,21 @@ export const FAIL_OPEN_TAGS = {
     },
     "server.sql.packet-cap-unread": {
         cls: "F",
-        note: "MySQL 协议连接初始化读不出语句级包墙(`plugins/sql-driver.ts` `readMaxAllowedPacket`,InnoDB 与 TiDB 同一处初始化;detail = `assumed=<字节> engine=<tidb|innodb> <读不出的原因>`):会话变量 `@@max_allowed_packet` 不认识 / 读它的查询失败 / 读到的不是正整数 ⇒ 按该服务器族的文档缺省当本库的包墙(`SqlEngineFacts.maxPacketBytes`;tidb 67108864,innodb 取 MariaDB 与 MySQL 8 两个缺省里小的 16777216),SQL 快照 blob 的缺省帽据它扣语句余量(1 KiB)再折半(文本协议 2× 膨胀)后与单行墙取小。每条池连接初始化各记一次。放行的最坏后果:库的真包墙比落点小(DBA 调小而没读到)⇒ 缺省帽放进了装不进一条语句的 blob,库在写的那一刻以 `ER_NET_PACKET_TOO_LARGE` 拒,快照 blob 写走各自既有的失败面(店的 never-throw 结果形折成 502);比落点大(调大而没读到)⇒ 缺省帽多拒(413 `blob_too_large_for_sql`,出路 = 显式旋钮 `SNAPSHOT_BLOB_SQL_MAX_BYTES` 或配对象存储)。不是门、不是凭据、不改任何裁决;计数非零 = 去看库账号能不能读 `@@max_allowed_packet`(普通账号都读得到,读不出多半是代理 / 中间件拦了这句)。",
+        note: "MySQL 协议连接初始化读不出语句级包墙(`plugins/sql-driver.ts` `readMaxAllowedPacket`,InnoDB 与 TiDB 同一处初始化;detail = `assumed=<字节> engine=<tidb|innodb> <读不出的原因>`):会话变量 `@@max_allowed_packet` 不认识 / 读它的查询失败 / 读到的不是正整数 ⇒ 按该服务器族的文档缺省当**这条连接**的包墙(`SqlEngineFacts.maxPacketBytes`,随连接保存;tidb 67108864,innodb 取 MariaDB 与 MySQL 8 两个缺省里小的 16777216),在这条连接上写的 SQL 快照 blob 的缺省帽据它扣语句余量(1 KiB)再折半(文本协议 2× 膨胀)后与单行墙取小。每条池连接初始化各记一次。放行的最坏后果:库的真包墙比落点小(DBA 调小而没读到)⇒ 缺省帽放进了装不进一条语句的 blob,库在写的那一刻以 `ER_NET_PACKET_TOO_LARGE` 拒,快照 blob 写走各自既有的失败面(店的 never-throw 结果形折成 502);比落点大(调大而没读到)⇒ 缺省帽多拒(413 `blob_too_large_for_sql`,出路 = 显式旋钮 `SNAPSHOT_BLOB_SQL_MAX_BYTES` 或配对象存储)。不是门、不是凭据、不改任何裁决;计数非零 = 去看库账号能不能读 `@@max_allowed_packet`(普通账号都读得到,读不出多半是代理 / 中间件拦了这句)。",
+    },
+    "server.sql.packet-wall-log-unwritten": {
+        cls: "F",
+        note: "包墙连接自愈的运维日志写不出(`plugins/sql-driver.ts` `warnPacketWall`,blob 判官借出口 `connectJudged` 的两行日志共用这一只出口:旧连接被换掉的 `sql_connection_packet_wall_stale`、全局包墙查询失败的 `sql_connection_packet_wall_global_unread`;detail = `event=<事件名> err=<日志汇抛出的错误类名>`):logger 抛(日志汇坏了 / 传输断了)⇒ 那一行没写出去,判决与连接处置不动 —— 旧连接已销毁在先、写照常重判,拒照旧是 413。放行的最坏后果 = 运维少看到一行诊断:一条过时连接被换掉、或全局包墙读不出这件事没有日志痕迹(判决本身不变,413 的帽照样由那条连接的包墙折算)。不放行的代价是把一次本该是 413(或照常重判后成功)的写变成日志汇故障的 500,并且若销毁在日志之后还会漏连接。故 F 类;登记口不经那只坏掉的 logger(计数 + stderr 契约行 + 探针),所以「日志丢了」本身仍可见。计数非零 = 去看这台副本的日志汇(stdout/stderr 传输)为什么抛。",
+    },
+    "server.config-dir-trust.kubelet-volume-node-side-unverifiable": {
+        cls: "R",
+        ruling: "C-R658",
+        bound: "残余写者只有节点特权方(节点 root、GID 0 的进程、被授予该 kubelet 卷目录读写 hostPath 的另一只 pod):它们的权限都由节点管理方授予,本 pod 内取不到,也看不见",
+        note: "本地配置源 `config.d` 读之前的目录信任判官(`config-dir-trust.ts` `projectedVolumeRoot`)认了一只 kubelet ConfigMap 卷的卷根(卷根 0777 是 kubelet 包卷的磁盘 emptyDir 的模式):卷根下只有原子写者的链接农场、走路径看见的那一只挂载恰挂在这里且只读、来源(mountinfo 第 4 格)是 kubelet configMap 卷目录的整形,且来源在本进程挂载命名空间里没有可写露出(同一文件系统的可写挂载把来源映射到的路径、走那条路径看见的正是那只挂载 —— 有一处即拒 `exposed`,走不到这里;容器里通常一条都没有)。判不了的两半:来源在节点那一侧的祖先目录(kubelet 的数据目录)不在本命名空间里,本进程看不见它们的属主与模式 —— 认它靠的是「kubelet 把数据目录建成 root:root 0750,本 pod 看不见的写者都是节点管理方授予了权限的节点特权方」这一节点侧事实;另一个超级块转出同一批字节的露出(overlay 的 lower / upper 层、FUSE、网络盘)也不在视野里,同记本标签(在本命名空间建这种挂载要 root)。每次认(起服一次 + 每拍一次)记一次。归 R:方向 = 认(不拒启),上界(结构式)= 残余写者只有节点特权方(节点 root、GID 0 的进程、被授予该 kubelet 卷目录读写 hostPath 的另一只 pod):它们的权限都由节点管理方授予,本 pod 内取不到,也看不见。放行的最坏后果 = 这一类残余写者(节点特权方)在判与读之间换掉 `..data`,让本服务读到它写的 `mcp.json`、以本服务的身份起其中的命令 —— 这类写者的权限不是 pod 内的进程自己取得到的,要节点管理方先授予。照拒会让每个以 ConfigMap 卷挂配置的 k8s 部署升级即拒启(出路只剩 `subPath` 逐文件挂)。计数长期保留(它数的是有界放行实际发生了多少次,不期望归零),非零 = 这台部署以 ConfigMap 卷挂配置。detail = `volume=<卷根物理路径> source=<来源路径>`。",
+    },
+    "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=<物理路径>`。",
     },
 };
 export function failOpenTagForDroppedFrame(frameType) {

package/dist/observability/metrics.js

@@ -236,6 +236,7 @@ export function createMetrics() {
     m.counter("limit_ceiling_after_answer_total", "Runs where a walltime/turns ceiling fired AFTER the run had already answered (engine 7.13.0: these end completed with NO limits.* code). Dual of budget_exceeded_total, but NOT over the same population: this one is minted on the deps-level notice sink so it sees EVERY engine run (background children, delegated/nested legs, leader lanes); budget_exceeded_total is incremented only by the HTTP submit legs finalizeTaskResult, i.e. top-level HTTP-submitted runs. Sum them only within that narrower population; see the forwarder comment, by origin");
     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("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("degraded_total", "Tasks degraded to a cheaper model (1.40), by reason (budget/rate_limit/breaker_open)");

package/dist/observability/prompt-manifest.d.ts

@@ -1,4 +1,5 @@
 import type { TraceEvent } from "@sema-agent/core";
+import { WIRE_PROJECTION_FACES } from "../trace/wire-projection-faces.js";
 /**
  * 引擎的清单帧 `prompt.assembled`(引擎 7.52.0 起 `version: 3`):这条腿的提示**是哪一份**(`identity` + 它的选择器值 `selectors`)、
  * 由哪些块与段组成、每一段的文本从哪里来(`chain`,被取代的 overlay 另在 `superseded`)。只有 id / 尺寸 / 摘要,没有提示正文。
@@ -7,7 +8,7 @@ export type PromptAssembledEvent = Extract<TraceEvent, {
     kind: "prompt.assembled";
 }>;
 /** 帧上**不上行**的键。唯一一簿在 `trace/wire-projection-faces.ts` 的 `prompt_manifest` 行(逐键理由在那里);这里只做类型查询。 */
-type NotOnTheRow = (typeof import("../trace/wire-projection-faces.js").WIRE_PROJECTION_FACES)["prompt_manifest"]["excluded"][number];
+type NotOnTheRow = (typeof WIRE_PROJECTION_FACES)["prompt_manifest"]["excluded"][number];
 /** 引擎的型,**词读成开集串**:投影判形,不判词表(档名、激活方式、来源类、渲染器……每一张词表的属主都是引擎,新词原样过境)。 */
 type OpenWords<T> = T extends string ? string : T extends readonly (infer U)[] ? OpenWords<U>[] : T extends object ? {
     [K in keyof T]: OpenWords<T[K]>;
@@ -23,24 +24,9 @@ export type PromptManifestRecord = {
 export type PromptManifestInput = {
     readonly [K in keyof PromptAssembledEvent]?: unknown;
 };
-/** 读一个值:读得出 ⇒ 值;读不出 ⇒ `undefined`;可选成员缺席 ⇒ {@link ABSENT}(不铸、不计)。 */
-type Read<V> = (v: unknown) => V | undefined;
-declare const ABSENT: unique symbol;
-/** 可选格的记号:只有 {@link optional} 铸得出带它的读器 —— 一只裸读器的回值型是可选格回值型的子型,单靠回值型拦不住它。 */
-declare const OPTIONAL_CELL: unique symbol;
-type OptionalRead<V> = Read<V | typeof ABSENT> & {
-    readonly [OPTIONAL_CELL]: true;
-};
-/**
- * 每张读表按引擎型的**每一个键**写一格(`-?`:可选键也必须有格,引擎给哪一层加成员 ⇒ 这里编译红);可选键的格必须经 {@link optional} —— 格型要求
- * {@link OPTIONAL_CELL} 记号,裸读器写进可选键 ⇒ 编译红(否则缺席的成员被裸读器读成「读不出」,整句被丢)。
- */
-export type ReadTable<T> = {
-    [K in keyof T]-?: undefined extends T[K] ? OptionalRead<Exclude<T[K], undefined>> : Read<T[K]>;
-};
 /**
  * 把一帧 `prompt.assembled` 读成耐久行(记录时白名单:tracer 同步、无 IO,未来的引擎键不随帧上行)。
- * 规则一句:**只挑引擎型里有的键,逐层判形;在场却读不出 ⇒ 计一次 `server.trace.projection-input-malformed` 并丢;缺席从不计数**。
+ * 规则一句:**只挑登记表声明的键,逐层判形;在场却读不出 ⇒ 计一次 `server.trace.projection-input-malformed` 并丢;缺席从不计数**。
  * 词原样过境(不判词表);`identity` 是这条腿的提示身份的唯一读法 —— 本仓不另铸第二种(v2 的 `constitution` 随引擎退役)。
  */
 export declare function promptManifestRecordOf(e: PromptManifestInput): PromptManifestRecord;
@@ -67,12 +53,23 @@ export declare function configAssembledRecordOf(e: {
     overrideReasons?: unknown;
     ts?: unknown;
 }): Record<string, unknown> | undefined;
+/**
+ * 一条 run 级的**伴随记录**:trace 帧在白名单读法之后要落成的那一行耐久事件(与清单行同生命周期:register 同门、drain 同拍、lease clear 同清)。
+ * 种类是一张闭表 —— 帧与账本行一一对应,加一种伴随记录 = 加一个词(`ledger-events.ts` 的账本行名闭集同批加),不另开一对 record / drain。
+ *  · `config_assembled` —— [ref]③ `config.assembled` 帧(生效配置逐字段来源);
+ *  · `cross_boundary_taint` —— core 7.54.0 [ref] O9b S1 `permission.cross_boundary_taint` 帧(设备车道发射闸:树的污染位与 governed;
+ *    只在执行于目标设备的树上发,宿主车道零帧;投影器 `trace/project.ts` `crossBoundaryTaintEventData`)。
+ */
+export type RunCompanionRecordType = "config_assembled" | "cross_boundary_taint";
+export interface RunCompanionRecord {
+    readonly type: RunCompanionRecordType;
+    readonly data: Record<string, unknown>;
+}
 export declare class PromptManifestTracker {
     private readonly byTask;
-    /** [ref]③:config.assembled 的同生命周期伴随记录(register 同门、drainConfig 同拍)。队列形
-     *  (codex F2):cascade 每 rung 独立解析配置,后到覆盖会把先前已计费 rung 的生效配置抹掉——与
-     *  prompt manifests 同姿势逐条保序。 */
-    private readonly configByTask;
+    /** 伴随记录({@link RunCompanionRecord}):清单之外、与清单同生命周期的 run 级耐久行。**一只**按发射序的队列(codex F2 当年给 config 一族立的保序律 ——
+     *  cascade 每 rung 各自成帧,后到覆盖会抹掉先前 rung 的那一份 —— 对每一种伴随记录同样成立,所以是一只队列,不是每种一只)。 */
+    private readonly companionsByTask;
     private readonly active;
     private leaseCounter;
     /** Mark a TOP-LEVEL run active (same fence as `ModelUsageTracker.register`, budget.ts). Returns this leg's
@@ -80,10 +77,10 @@ export declare class PromptManifestTracker {
     register(taskId: string): number;
     /** Queue this prepare's manifest — ONLY for a registered top-level run (else a no-op). Sync, never throws. */
     record(taskId: string, m: PromptManifestRecord): void;
-    /** [ref]③:队一条 config.assembled 投影(同 register 门;逐条保序——cascade 每 rung 各留其形)。 */
-    recordConfig(taskId: string, rec: Record<string, unknown>): void;
-    /** Return-and-clear ALL pending config records in emission order; `undefined` when none. */
-    drainConfig(taskId: string): Array<Record<string, unknown>> | undefined;
+    /** 队一条伴随记录(同 register 门;按发射序保序)。Sync, never throws. */
+    recordCompanion(taskId: string, type: RunCompanionRecordType, data: Record<string, unknown>): void;
+    /** Return-and-clear ALL pending companion records in emission order; `undefined` when none. */
+    drainCompanions(taskId: string): RunCompanionRecord[] | undefined;
     /** Return-and-clear ALL pending manifests in emission order; `undefined` when none. */
     drain(taskId: string): PromptManifestRecord[] | undefined;
     /** Drop pending + unregister (run end / abandoned leg) — but ONLY while `lease` still owns the slot;

package/dist/observability/prompt-manifest.js

@@ -1,21 +1,21 @@
 import { dropProjectedFace } from "../trace/projection-drop.js";
+import { WIRE_PROJECTION_FACES } from "../trace/wire-projection-faces.js";
 const ABSENT = Symbol("absent");
-const OPTIONAL_CELL = Symbol("optional-cell");
 const text = (v) => (typeof v === "string" ? v : undefined);
 const finite = (v) => (typeof v === "number" && Number.isFinite(v) ? v : undefined);
 const flag = (v) => (typeof v === "boolean" ? v : undefined);
 const onlyTrue = (v) => (v === true ? true : undefined);
 const plainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v : undefined;
 function optional(read) {
-    return Object.assign((v) => (v === undefined ? ABSENT : read(v)), { [OPTIONAL_CELL]: true });
+    return (v) => (v === undefined ? ABSENT : read(v));
 }
-function objectOf(table) {
+function objectOf(cells) {
     return (v) => {
         const o = plainObject(v);
         if (o === undefined)
             return undefined;
         const out = {};
-        for (const [key, read] of Object.entries(table)) {
+        for (const [key, read] of cells) {
             const r = read(o[key]);
             if (r === undefined)
                 return undefined;
@@ -72,46 +72,49 @@ function rowsOf(member, read) {
         return v.length > 0 && out.length === 0 ? ABSENT : out;
     };
 }
-const readIdentity = objectOf({
-    artifact: text,
-    layers: objectOf({ catalog: text, renderers: entriesOf(finite), center: optional(text), deploy: optional(text), task: optional(text), binding: text }),
-    epoch: finite,
-    activatedBy: text,
-});
-const readSelectors = objectOf({
-    binding: optional(text),
-    traits: listOf(text),
-    host: objectOf({ role: text, form: text }),
-    facts: entriesOf(flag),
-});
-const readSection = objectOf({
-    id: text,
-    band: text,
-    rank: finite,
-    variant: optional(text),
-    renderer: optional(objectOf({ id: text, version: finite })),
-    chars: finite,
-    locale: text,
-    contentHash: text,
-    chain: listOf(objectOf({ source: text, overlay: optional(text), op: optional(text), superseded: optional(onlyTrue) })),
-});
-const ROW = {
-    identity: readIdentity,
-    selectors: readSelectors,
-    blocks: rowsOf("blocks", objectOf({ id: text, chars: finite, hash: text })),
-    sections: rowsOf("sections", readSection),
-    superseded: rowsOf("superseded", objectOf({ id: text, source: text, by: text, target: text, supersededBy: text })),
-    tools: rowsOf("tools", objectOf({ wireName: text, aliases: listOf(text), contractId: text, implementationRevision: text, cardId: text, shapeDigest: text, wireSchemaDigest: text })),
-    toolDisclosure: objectOf({ deferredTools: finite, strategy: text, source: text }),
-    totalChars: finite,
-};
+const FACES = WIRE_PROJECTION_FACES;
+function exhausted(shape) {
+    throw new Error("清单行声明里有不认得的值形:" + JSON.stringify(shape));
+}
+function readerOfShape(shape, member, building) {
+    switch (shape.is) {
+        case "text":
+            return text;
+        case "count":
+            return finite;
+        case "flag":
+            return flag;
+        case "true":
+            return onlyTrue;
+        case "object":
+            return objectOf(cellsOfFace(shape.face, building));
+        case "list":
+            return listOf(readerOfShape(shape.of, member, building));
+        case "rows":
+            return rowsOf(member, readerOfShape(shape.of, member, building));
+        case "entries":
+            return entriesOf(readerOfShape(shape.of, member, building));
+        default:
+            return exhausted(shape);
+    }
+}
+function cellsOfFace(face, building) {
+    if (building.includes(face))
+        throw new Error("清单行声明成环:" + [...building, face].join(" → "));
+    const keys = FACES[face]?.keys;
+    if (keys === undefined)
+        throw new Error("清单行声明引用了没有 keys 的面:" + face);
+    return Object.entries(keys).map(([key, declared]) => {
+        const read = readerOfShape(declared, key, [...building, face]);
+        return [key, declared.optional === true ? optional(read) : read];
+    });
+}
+const ROW = cellsOfFace("prompt_manifest", []);
 export function promptManifestRecordOf(e) {
+    const frame = e;
     const out = {};
-    for (const [member, read] of Object.entries(ROW)) {
-        const v = e[member];
-        if (v === undefined)
-            continue;
-        const r = read(v);
+    for (const [member, read] of ROW) {
+        const r = read(frame[member]);
         if (r === undefined)
             drop(member, "does not read as the engine's type");
         else if (r !== ABSENT)
@@ -137,7 +140,7 @@ export function configAssembledRecordOf(e) {
 }
 export class PromptManifestTracker {
     byTask = new Map();
-    configByTask = new Map();
+    companionsByTask = new Map();
     active = new Map();
     leaseCounter = 0;
     register(taskId) {
@@ -156,20 +159,21 @@ export class PromptManifestTracker {
         else
             this.byTask.set(taskId, [m]);
     }
-    recordConfig(taskId, rec) {
+    recordCompanion(taskId, type, data) {
         if (!taskId || !this.active.has(taskId))
             return;
-        const q = this.configByTask.get(taskId);
+        const q = this.companionsByTask.get(taskId);
+        const rec = { type, data };
         if (q)
             q.push(rec);
         else
-            this.configByTask.set(taskId, [rec]);
+            this.companionsByTask.set(taskId, [rec]);
     }
-    drainConfig(taskId) {
-        const q = this.configByTask.get(taskId);
+    drainCompanions(taskId) {
+        const q = this.companionsByTask.get(taskId);
         if (!q || q.length === 0)
             return undefined;
-        this.configByTask.delete(taskId);
+        this.companionsByTask.delete(taskId);
         return q;
     }
     drain(taskId) {
@@ -184,7 +188,7 @@ export class PromptManifestTracker {
             return;
         this.byTask.delete(taskId);
         this.active.delete(taskId);
-        this.configByTask.delete(taskId);
+        this.companionsByTask.delete(taskId);
     }
 }
 //# sourceMappingURL=prompt-manifest.js.map

package/dist/observability/tool-trace.js

@@ -1,6 +1,7 @@
 import { isClassifierDenyCause, isDeniedBy } from "@sema-agent/core";
 import { observeClassic } from "../hooks/classic-stations.js";
-import { redactSecrets } from "../trace/redact.js";
+import { seatText } from "../trace/exit-seat.js";
+import { echoCallerText } from "../caller-text-echo.js";
 export const PERMISSION_DENIED_METER_REGISTRATION = "server.permission-denied-meter";
 export const TOOL_TRACE_REGISTRATION = "server.tool-trace";
 function deniedByLabel(gate) {
@@ -50,7 +51,7 @@ export function createToolTracer(logger) {
                     isError: true,
                     isInterrupt: e.failure.isInterrupt,
                     ...(e.failure.durationMs !== undefined ? { durationMs: e.failure.durationMs } : {}),
-                    out: clip(redactSecrets(e.failure.error), 200),
+                    out: seatText("operator-log-text", e.failure.error),
                 });
             });
             observeClassic(on, "classic.PermissionDenied", (payload) => {
@@ -61,34 +62,32 @@ export function createToolTracer(logger) {
                     deniedBy: deniedByLabel(payload.gate),
                     ...(payload.gate.origin === undefined ? {} : { origin: payload.gate.origin }),
                     ...(payload.gate.settlement === undefined ? {} : { settlement: payload.gate.settlement.kind }),
-                    reason: clip(redactSecrets(payload.reason), 200),
+                    reason: seatText("operator-log-text", payload.reason),
                     arg: summarize(payload.input),
                 });
             });
         },
     };
 }
+const TRACE_KEY_ECHO_CHARS = 120;
 function summarize(input) {
     if (!input || typeof input !== "object")
-        return { v: clip(String(input), 120) };
+        return { v: seatText("operator-log-arg", String(input)) };
     const o = input;
     const s = {};
     for (const k of ["path", "file_path", "command", "cmd", "pattern", "glob", "old_string", "new_string"]) {
         if (typeof o[k] === "string")
-            s[k] = clip(redactSecrets(o[k]), 120);
+            s[k] = seatText("operator-log-arg", o[k]);
     }
     if (typeof o.content === "string")
         s.contentLen = o.content.length;
-    return Object.keys(s).length ? s : { keys: Object.keys(o) };
+    return Object.keys(s).length ? s : { keys: Object.keys(o).map((k) => echoCallerText(k, { maxChars: TRACE_KEY_ECHO_CHARS })) };
 }
 function textOf(content) {
     const text = content
         .map((c) => (c && typeof c === "object" && typeof c.text === "string" ? c.text : ""))
         .join("")
         .trim();
-    return clip(redactSecrets(text), 200);
-}
-function clip(s, n) {
-    return s.length > n ? `${s.slice(0, n)}…(${s.length})` : s;
+    return seatText("operator-log-text", text);
 }
 //# sourceMappingURL=tool-trace.js.map

package/dist/operator-ask.d.ts

@@ -66,6 +66,16 @@ export declare function operatorAsk(rule: string, message: string): OperatorAskR
  * 名单卡要带「本会话放行」,而强制卡上没有。「恒问人」两类盖出身 ⇒ core 读 `operator_forced`、盖 `mandated`,站着的答案在哪一层都退不掉它们。
  */
 export declare function operatorAlwaysHumanAsk(rule: string, message: string): OperatorAskResult;
+/**
+ * 🔴 **S-1351 —— 请求写下的「恒问人」**(`settings.permissions.neverAuto`):在 {@link operatorAsk} 之上再盖 `requiresRealApproval: true`(core 的治理位 ——
+ * 「只有判断能清它」:空白的 `onAsk: "allow"`、任何站着的答案(持久规则、会话授权)、auto 分类器都清不掉,只有**这一次**的真人应答能答),不盖部署出身。
+ *
+ * 为什么不盖 `authoredBy: "deployment"`:出身位说的是「部署自己的治理层写的」,请求里的声明不是部署写的 —— 盖了就是在审计面冒名。`requiresRealApproval` 是 core 明文开给
+ * 策略自报的位(顶注:自报只会把**自己的** ask 退出自动裁决,方向是收紧、冒报安全),它把这一问推进「只有判断能清」的那一门(`ruleClearanceOf` 的治理门),
+ * 效果与部署的 `APPROVAL_NEVER_AUTO` 同级 —— 每个权限模式词下的仲裁读数逐位相同(`test/tighten-only-seats-assembly.test.ts` 逐词钉住)。
+ * 出处串(`rule` 写 `settings.permissions.neverAuto(<命中的名>)`,不写成 `APPROVAL_NEVER_AUTO(…)`)进 `matchedAskRule`:引擎闸内部消费、不上卡(同部署那一条),审计 / 单测读它区分来源。
+ */
+export declare function requestAlwaysHumanAsk(rule: string, message: string): OperatorAskResult;
 /**
  * 🔴 **S-958 —— 治理层的叶策略包装**:`leaf` 产的每一只 ask 盖部署出身(经 {@link withDeploymentAuthorship}),allow / deny 原物交回;
  * 成员(`projection` / `pathRules` / `writeTargetGuard` / `nameSets`)经 core `wrapToolPolicy` 随行(契约「包装至少拒内层所拒」:

package/dist/operator-ask.js

@@ -5,6 +5,9 @@ export function operatorAsk(rule, message) {
 export function operatorAlwaysHumanAsk(rule, message) {
     return withDeploymentAuthorship(operatorAsk(rule, message));
 }
+export function requestAlwaysHumanAsk(rule, message) {
+    return { ...operatorAsk(rule, message), requiresRealApproval: true };
+}
 function withDeploymentAuthorship(ask) {
     return { ...ask, authoredBy: "deployment" };
 }

package/dist/orchestration/workflow-agent-session-index.d.ts

@@ -15,11 +15,12 @@ export interface WorkflowAgentSessionRow {
 /**
  * 索引面的两个动词。**写者只有一个**(见文件头),读者是判别式。
  *
- * `syncRun` 语义 = 「这条 run 当前的指针集**就是** rows」:多出来的旧行删,rows 里的行 upsert。幂等、可重放、与 run 的一次成功写同拍。
- * `listByAgentSession` = 点名这个子会话的**全部**指针(各 run 一行;顺序不承重)。
+ * `ensurePointers` 语义 = 「rows 里的每一枚指针此后都在」:upsert,**从不删**(唯一的删除是 run 收割的级联)。幂等、可重放;写者在记录落盘
+ * **之前**调它(文件头「指针先于记录」)。
+ * `listByAgentSession` = 点名这个子会话的**全部**指针(各 run 一行;顺序不承重)—— 点名者的超集。
  */
 export interface WorkflowAgentSessionIndex {
-    syncRun(runId: string, rows: readonly WorkflowAgentSessionRow[]): Promise<void>;
+    ensurePointers(runId: string, rows: readonly WorkflowAgentSessionRow[]): Promise<void>;
     listByAgentSession(sessionId: string): Promise<WorkflowAgentSessionRow[]>;
 }
 /**
@@ -50,8 +51,8 @@ export declare function readRunParks(run: unknown): WorkflowRunParkKey[] | undef
 export declare function heldParksOf(recordId: string, parks: readonly WorkflowRunParkKey[]): WorkflowRunParkKey[];
 /**
  * 派生的**唯一属主**:一只 `WorkflowRun` 的指针行 = 它 `parks[]` 里点名的每一个子会话(一个子会话一行)。`parks` 缺席 ⇒ 零条
- * ({@link readRunParks}:没有条目)⇒ 写者按「这条 run 的指针集就是这一份」清掉它已有的指针。
- * `parks[]` 读不出 ⇒ `undefined`(**派生不出来**,不是「零条」):写者据此不动这条 run 已有的指针(文件头「单写者」段)。
+ * ({@link readRunParks}:没有条目)⇒ 没有要写的指针。
+ * `parks[]` 读不出 ⇒ `undefined`(**派生不出来**,不是「零条」):写者据此不写指针(文件头「指针先于记录」段)。
  */
 export declare function buildParkSessionRows(runId: string, run: {
     scope: string;
@@ -99,9 +100,7 @@ export type WorkflowParkRoute = {
  * 🔴 **窗与删码**:规则 ③ 的 `older_engine` 读臂是一次性迁移 M9 的读侧半场(升级那一刻还停驻着的存量记录)。窗口与删码清单见 `plugins/one-time-migrations.ts` 登记表 M9 一行,随 M9 一起删;这里不写第二份窗。
  */
 export declare function routeWorkflowPark(sessionId: string, candidates: readonly WorkflowRun[]): WorkflowParkRoute;
-/** 两处(装饰器的变更检测、local 后端的重放)共用的行集等值判据 —— 顺序无关的集合比较,单一属主。 */
-export declare function sameAgentSessionRows(a: readonly WorkflowAgentSessionRow[], b: readonly WorkflowAgentSessionRow[]): boolean;
-/** 账本一行的**内域形**:一次 `syncRun` 的整份行集快照(`{runId, rows}`)。 */
+/** 账本一行的**内域形**:一条 run 当时的整份指针快照(`{runId, rows}`;同一条 run 后写的一行整份覆盖先写的 —— 本仓只增不删,所以后一行恒是前一行的超集)。 */
 export interface WorkflowAgentSessionLedgerLine {
     runId: string;
     rows: WorkflowAgentSessionRow[];
@@ -112,7 +111,7 @@ export interface WorkflowAgentSessionLedgerLine {
  * 姿态与 SQL 孪生逐字同源:那边 `listByAgentSession` 逐字段收窄(`String(r.session_id)` …),这边逐字段
  * 判形 —— 一张索引面、两个后端、**一种**入域姿态。
  *
- * **整行成败制**(与既有的撕裂行臂同一条规则):一行 = 一次 syncRun 的**整份**快照,任一位读不出来就说明
+ * **整行成败制**(与既有的撕裂行臂同一条规则):一行 = 一条 run 的**整份**快照,任一位读不出来就说明
  * 这份快照重建不出来 ⇒ 整行不 apply(那条 run 保留上一份已知良好的快照)。不做「丢掉坏成员、留下好成员」
  * ——那会静默铸出一份**比真相少几条 park** 的行集,而这条索引的消费面正是 park 的赎回路由。
  * 读不出来 ⇒ 调用方**响亮**记一笔([ref]:安全轴不许静默),不吞整档。
@@ -125,7 +124,7 @@ export declare function readAgentSessionLedgerLine(v: unknown): WorkflowAgentSes
  * 逐字同形:0o700 目录 + 0o600 账本、按行重放),重启后 park 仍可 join;缺席 ⇒ 纯内存
  * (`WORKFLOW_RUN_STORE=memory` 的显式易失车道,与它的 run 店同寿命)。
  *
- * 账本的一行 = **一次 `syncRun` 的整份行集**(按 runId 后写覆盖),所以重放即收敛,不需要压缩腿。
+ * 账本的一行 = **一条 run 当时的整份指针集**(按 runId 后写覆盖;指针只增不删 ⇒ 后一行恒是前一行的超集),所以重放即收敛,不需要压缩腿。
  *
  * 追加 / 重放走本仓 JSONL 店的**共用口**(S-977;此前 ctor 里自写 `truncateTornTail` + 手写 `split("\n") + JSON.parse` 重放):
  * 追加 = core `AppendLog`(惰性打开、撕尾在**打开与每次追加前**修 —— 修前只在 boot 修,运行期半写后的下一次成功写仍会被粘进残尾),
@@ -141,9 +140,10 @@ export declare class LocalWorkflowAgentSessionIndex implements WorkflowAgentSess
     private readonly bySession;
     private log;
     constructor(root?: string, fsyncEnabled?: boolean);
-    /** 内存两张表的收敛(重放与写路径共用一份逻辑):先摘这条 run 的旧指针,再挂新的。 */
+    /** 内存两张表的收敛(重放与写路径共用一份逻辑):这条 run 的指针集 = 这一行的整份快照。 */
     private apply;
-    syncRun(runId: string, rows: readonly WorkflowAgentSessionRow[]): Promise<void>;
+    /** 只增不删:这条 run 已有的指针 ∪ 这几枚,写成一行整份快照(盘上一行仍是「这条 run 的指针集」,与早年的账本行同一种读法)。 */
+    ensurePointers(runId: string, rows: readonly WorkflowAgentSessionRow[]): Promise<void>;
     listByAgentSession(sessionId: string): Promise<WorkflowAgentSessionRow[]>;
 }
 //# sourceMappingURL=workflow-agent-session-index.d.ts.map

package/dist/orchestration/workflow-agent-session-index.js

@@ -88,16 +88,6 @@ function highestHolders(sessionId, readable) {
     }
     return top;
 }
-export function sameAgentSessionRows(a, b) {
-    if (a.length !== b.length)
-        return false;
-    const key = (r) => `${r.sessionId}\u0000${r.runId}\u0000${r.agentKey}\u0000${r.scope}`;
-    const left = new Set(a.map(key));
-    for (const r of b)
-        if (!left.has(key(r)))
-            return false;
-    return true;
-}
 export function readAgentSessionLedgerLine(v) {
     if (typeof v !== "object" || v === null)
         return undefined;
@@ -173,12 +163,18 @@ export class LocalWorkflowAgentSessionIndex {
             runs.set(runId, r);
         }
     }
-    async syncRun(runId, rows) {
+    async ensurePointers(runId, rows) {
+        const held = this.byRun.get(runId) ?? [];
+        const named = new Set(held.map((r) => r.sessionId));
+        const added = rows.filter((r) => !named.has(r.sessionId));
+        if (added.length === 0)
+            return;
+        const merged = [...held, ...added];
         if (this.ledgerPath !== undefined) {
             this.log ??= new AppendLog(this.ledgerPath);
-            this.log.append({ runId, rows }, this.fsyncEnabled);
+            this.log.append({ runId, rows: merged }, this.fsyncEnabled);
         }
-        this.apply(runId, rows);
+        this.apply(runId, merged);
     }
     async listByAgentSession(sessionId) {
         return [...(this.bySession.get(sessionId)?.values() ?? [])];