@sema-agent/client-core 0.63.0 → 0.63.2

package/CHANGELOG.md

@@ -49,6 +49,103 @@
 > 挡住 ⇒ 本批把它机械化——④a0 对 `pending` 行**要求段头已是日期形**(`(未发布)` 直接红),阶段一
 > commit 漏转在发布前就红,不再靠人记。
 
+## 0.63.2(2026-09-09)
+
+### 修复
+
+- **终答补差臂在「工具卡后零散文」形下把整段终帧再渲一遍**(cli 1.0.105 收官 daemon-reattach 套实撞:
+  mock 车道「散文 → Config 卡 → turn 收口」屏上同一段话两遍;真引擎上 turn 收在工具之后同形)。根因:工具
+  边界把「当前消息已上屏正文」重置成空串,而 provider 一条 assistant 消息 = `[text, tool_use]`,引擎「最后一条
+  消息的文本」正是卡**之前**那段;空串是任何终帧的前缀 ⇒ 补差臂把整段终帧当缺的后缀补出。修:比较对象改为
+  `lastCommittedAnswerText`(当前消息零上屏时回退到上一条真有正文的消息;有字时与修前逐字同)。门:
+  `run-result-text-backfill` +G5/G5b(卡后零散文 + 终帧 = 卡前那段 ⇒ 零补;终帧多一截 ⇒ 只补后缀);变异
+  (比较源改回 `committedAnswerText`)⇒ G5 红。§26g 加订正段。宿主零换装。
+
+## 0.63.1(2026-09-09)
+
+test 对 0.63.0 的黑盒回执(G-1…G-20 五路交叉)提了六项;逐项亲核后 **四修二订**。本段只记内容,
+不含任何 bump。
+
+### 修复
+
+- 🔴 **workflow 监视器把「停在审批门上」渲成「在跑」**(G-20)。engine core 7.10.0 起一条 workflow
+  **agent 腿**可以耐久挂在审批卡上(`WorkflowItemStatus` +`parked`,`deriveAgentDisplayStatus` 直接产
+  `"parked"`),而本包监视器车道的窄读把它折进了开集兜底 —— 屏上那一行说的是「等它跑完」,实际它在
+  有人做决定之前**永远不会**自己往前走一步。修:四处窄读各给 `parked` 一条自己的臂
+  (`coerceAgentState` / `agentDisplayStatus` / `coerceRunStatus` / `coercePhaseStatus` + 合成格三元式),
+  开集兜底一个字节不动。🔴 **`agentDisplayStatus` 的这条臂必须排在 `!workflowActive` 之前** —— park
+  之后整只 run 收在 `failed`,排在后面就永远被 `interrupted` 抢答。
+  型面(additive,端的穷尽形要各加一条 case):`AgentState` / `DisplayStatus` /
+  `WorkflowRunState['status']` / `WorkflowPhase['status']` 各 +`parked`。详见 §27h3、换装清单 §27i ⑨。
+
+- **同一条 wire 的同一个 `status`,三处在场判不同形**(G-20 附带②)。`parseWorkflowPollEnvelope` 判
+  `length > 0`(空串=缺席),而 `projectWorkflowTaskOutput` 的 per-agent 与 `projectAgent` 的
+  `displayStatus` 只判 `typeof`(空串=在场)。后果:前者把空串渲成 `[]` —— 一对什么也没说的方括号,
+  却长得像一个真答案;后者更坏 —— `'' ?? row.status` 恒取空串(`??` 只挡 null/undefined),那条腿的
+  raw `status` 被**静默丢掉**,连回落都走不到(`parked` 正是从这条缝里漏的)。三处统一成
+  **空串 = 缺席**;纯空白仍不 trim(两侧同尺)。
+
+### 文档 / 门
+- **异源对抗复审 R2 三条 [medium] 全采纳**(仍全部打在 E 段这条 G-8 承重腿上,三条都真能复现):
+  ①`underAnyBranch` 漏了**循环** —— 零次循环里的铸点被认作「无条件」⇒ 补 `for`/`for-of`/`for-in`/
+  `while`/`do` 五形;②**铸点与 `/health` 之间的接线没验** —— 把引擎 deployment 对象里的
+  `instanceId,` 删掉,两条断言照样绿而实际 `deps.instanceId` 已是 `undefined`、条件 spread 会把这一位
+  整只省掉 ⇒ 新增 E3 接线断言(铸出的值必须真被挂到一只对象上);③**条件 spread 被当成必然输出** ——
+  守卫换成别的旗子、或经包装调用摊进来,都被判成「带上了」⇒ 改成只认「守卫就是那个值本身」的形,
+  包装调用一律判不出(返回形状是运行期的事,不替它编答案)。
+  同批把射程边界写进段头与 §27d:**证的是源码形**(挡上游改锚/改铸法/断接线),**不证**「这段码真被
+  执行」——那要一次真启动的 `/health` 响应,不在本包射程内(本包不起引擎)。
+- **自查同批补两条**(不在复审名单里,同一条病形):①`hasProp` 原是整棵子树遍历 ⇒ `restart: {…}`
+  这类**嵌套值**里的同名键会被算进 `/health` 的键空间,改成「直挂 + 沿 spread 下行」;
+  ②①c 的 `statedTableSize` 取第一处命中 ⇒ 同名两处各写一个数时放过另一处,改成**恰一处**才作数;
+  并加「档里每一处带表长的签名行都必须已登记」的漏登即红(新增一张带数字的表时门不再沉默)。
+
+- **异源对抗复审 R1 三条 [medium] 全采纳**(都打在本批**新加的门**上,三条都是假绿):
+  ①`run-engine-identity-test.mjs` E 段原是两条裸正则 —— 条件里铸、注释残留、挂在别的对象上三类反例
+  都骗得过去 ⇒ 改锚 AST(控制流 + 路由两轴),并把三类反例做成常驻反向正控;
+  ②同段见证缺席时仍报「全绿」⇒ 改成未注入打 `SKIPPED-SECTION`(汇总显形 PARTIAL)、注入了却拿不到
+  物料**判红**,结语逐字说清这一段跑没跑;
+  ③`run-integration-doc-freshness-test.mjs` ①c 把 AST 节点数当运行期表长 —— 展开元素算一员、任意
+  单参调用都收 ⇒ 改成逐条 fail-closed(只认 `Object.freeze(<全字符串字面量数组>)`),复审给的原样
+  反例(把一员换成展开)现在当场判工具红。
+
+- **`/health` 的 `pid` 单锚碰撞**(G-8):裁读 = **设计不改,判据收窄 + 取证入门**。「只剩 `pid` 可比
+  且相等」要求 `instanceId` 在两侧都缺席,而 `instanceId` 在引擎里是**无条件铸**的、`/health` 一路
+  带着它 ⇒ 那种读数在生产上到不了;反过来把它判成 `unknown`,会让一台只报得出 `pid` 的老 worker
+  **每一次心跳**都触发重握手 —— 那是拿一个每拍都发生的代价去换一个到不了的风险。
+  落点:§27d 加一段写清「pid 是最弱锚、从不落单」+ 端的兜底句;`run-engine-identity-test.mjs` 加
+  **D 段**(设计钉:pid 单锚相等仍 same / pid 相等压不住更强的锚 / 优先序里 pid 是表尾)与
+  **E 段**(引擎产物第二见证,**锚 AST 不锚子串**:铸点不在任何 `if`/`switch`/三元/`??` 里,且
+  `instanceId` 挂在 `/health` **那一只**响应体上 —— 按 `status:"ok"` + `pid: process.pid` 两键定位。
+  🔴 `SEMA_FENCE_ENGINE_DIR` 未注入 ⇒ 打 `SKIPPED-SECTION`(汇总显形 PARTIAL,不冒充全绿);
+  注入了却拿不到物料 ⇒ **判红**。发布批必须注入一次引擎树把这一段跑绿,才能引用本条的结论)。
+
+- **§27h 的 `engine_notice` 码册数字滞后**(G-16):档写「四十八码」,源码那张表(与它的头注)早就是
+  **50** 员 —— 上游加了两个码,档没跟。修:数字订正,**并把它变成有牙的** —— `run-integration-doc-
+  freshness-test.mjs` 新增 **①c 段**:签名块里的表长数字 ⟷ 源码那张表的真实成员数(TS AST 取
+  `Object.freeze([...])` 的元素个数)。同批把同形的五张表全部登记进去(`ENGINE_NOTICE_CODES` /
+  `MCP_INJECTION_DROP_REASONS` / `GATE_DENIED_BY_WORDS` / `ASK_ORIGIN_WORDS` /
+  `PERMISSION_RULE_ISSUE_CODES`),并把这几处的中文数词改成阿拉伯数字 —— 读不出来的门等于没有门,
+  所以抽取器读不出时判**工具红**而不是静默放过。
+
+- 🔴 **表外 lint 码被 60 字符封长,与文档「原样带上」冲突**(G-11)。码是**引擎产的标识符**不是散文 ——
+  运维要拿它整只去问上游,截一半的码谁也查不出来,还长得像一个完整答案。修:码**原样带上不封长**,
+  呈前只走本包同一只不可见字符消毒器(不封长 ≠ 不消毒);`message` 半场的封长照旧(那半场确实是
+  散文)。同族其余三处 `capForDisplay` 的词位(posture / read-face / write-protection 的来源词)
+  刻意不动:那些是**有界词表**里的词、且文档从未承诺「原样」,与本条不同形。详见 §27f、§27i ⑤。
+
+- 🔴 **`postureKnobDetail` 的判序反了**(G-3)。旧序先看「读数在不在」再看 `reachable` ⇒ 端拿着上一拍
+  的 view、这一拍 operator 探测打不通、只翻 `reachable:false` 时,屏上照渲**上一拍的值和来源词**,
+  一个字都看不出这一次根本没读到 —— 拿陈读数冒充现势。修:**`!reachable` 先判**,压过任何在手的
+  读数(打不通时旧读数不是现势),那一句仍是既有的「未观测」原文,值与来源词一个都不漏。
+  端因此**不必**再为打不通而先把 view 清空。详见 §27b、换装清单 §27i ①。
+
+
+- **§27h3 整节重写**:0.63.0 原文两处失真留痕订正 —— ①「core 7.10.0 给 **run** 状态加了 parked」错,
+  加的是 **agent 行**那一级(run 词表今天仍闭在 running|completed|failed);②「本包零改」只对
+  TaskOutput 文本车道成立,监视器投影车道当时正在折它。同节把 `readWorkflowRunLine`(本包零命中)
+  订正成真名 `parseWorkflowPollEnvelope`。§27j 的 G-20 判据同批订正口径(park 落在腿上)。
+
 ## 0.63.0(2026-09-09)
 
 对表 **sdk 8.8.0 / engine ≥7.67.0 / core 7.10.0**(devDep core `~7.3.0` → `~7.10.0`)。sdk 地板 `>=8.5.0` → `>=8.8.0`

package/README.md

@@ -35,7 +35,7 @@ Renamed from **`@sema-agent/wire-cc-adapter`** (0.1.x, deprecated — see *Migra
 
 ## Scope
 
-**Version:** 0.63.0
+**Version:** 0.63.2
 
 - **Today** — the adapter seam, the whole `adapt()` pipeline (all 14 A-layer arms plus the
   B/D/E tool-card layers), the notification/caps/model families, the adapter kernel (stream driver

package/dist/adapt/arms.js

@@ -652,7 +652,9 @@ const resultArm = function* (m, { ctx, idOf, text, cards, panel, flags }) {
     yield* text.takeAnswerSegment();
     // 具名成 terminalText:M1 收编后 `text` 是流合并器的名字,原来的同名局部会遮蔽它。
     const terminalText = typeof m.result === 'string' ? m.result : '';
-    const committed = text.committedAnswerText;
+    // 🔴 比较对象 = 引擎「最后一条 assistant 消息」在屏上那段(0.63.2):卡后零散文时回退到卡前那条
+    //    (provider 一条消息 = [text, tool_use];空串是任何终帧的前缀 ⇒ 拿空串比会把整段终帧再渲一遍)。
+    const committed = text.lastCommittedAnswerText;
     const emitTerminal = function* (body, tag) {
         yield transcript({
             type: 'assistant',

package/dist/adapt/textStream.d.ts

@@ -87,6 +87,16 @@ export interface TextStream {
      *    这一个记的是「屏上这条消息已经有了哪些字」,是**补差判据的输入**。
      */
     readonly committedAnswerText: string;
+    /**
+     * 引擎「最后一条 assistant 消息」在屏上对应的那段正文 —— 终答补差的**正确比较对象**(0.63.2)。
+     *
+     * 🔴 与 {@link TextStream.committedAnswerText} 的差别只在一格:工具卡是这一轮最后一件事、卡后
+     *    **零散文**时,`committedAnswerText` 已被边界重置成空串,而 provider 的一条 assistant 消息 =
+     *    [text, tool_use] 两块 —— 引擎取的「最后一条消息的文本」正是卡**之前**那段。空串是任何终帧的
+     *    前缀,拿它去比会把整段终帧当「缺的后缀」再渲一遍(同一段话上屏两遍)。⇒ 当前消息一个字都没
+     *    上屏时,回退到**上一条真有正文的消息**那段;当前消息有字时与 `committedAnswerText` 逐字同。
+     */
+    readonly lastCommittedAnswerText: string;
     /**
      * **一条新的 assistant 消息从这里开始**(重置 {@link TextStream.committedAnswerText})。
      *

package/dist/adapt/textStream.js

@@ -49,6 +49,8 @@ export function createTextStream(ctx, idOf) {
     let emittedAssistantText = false;
     /** **当前这条 assistant 消息**已提交上屏的正文(补差判据的输入;与 `answer` 刻意分家,见接口注)。 */
     let committedText = '';
+    /** 上一条**真有正文**的 assistant 消息在屏上的那段(见 lastCommittedAnswerText 头注)。 */
+    let previousCommittedText = '';
     let textPending = '';
     let thinkingPending = '';
     let textBlockOpen = false;
@@ -203,11 +205,16 @@ export function createTextStream(ctx, idOf) {
                 committedText += committed;
         },
         beginAssistantMessage: () => {
+            if (committedText.length > 0)
+                previousCommittedText = committedText;
             committedText = '';
         },
         get committedAnswerText() {
             return committedText;
         },
+        get lastCommittedAnswerText() {
+            return committedText.length > 0 ? committedText : previousCommittedText;
+        },
         get emittedAssistantText() {
             return emittedAssistantText;
         },

package/dist/permissionRuleIssue.js

@@ -34,7 +34,7 @@
  * `message` 是引擎/用户 settings 侧的内容(里面会带用户自己写的规则文本):只渲染,呈前**先转义、
  * 后按转义结果封长**(与本包其余 detail 铸点同一条纪律),绝不当码用、绝不做等值匹配。
  */
-import { capForDisplay } from './fleetTaskDesc.js';
+import { capForDisplay, escapeDisplayControlChars } from './fleetTaskDesc.js';
 /**
  * 引擎**真会铸**的规则 lint 拒因码(core `PermissionRuleIssue.code`,7.9.x = 十五码)。
  * 顺序与 core 声明同源。
@@ -114,8 +114,13 @@ export function permissionRuleIssueDetail(code, message) {
     const text = typeof message === 'string' && message.length > 0
         ? capForDisplay(message, ISSUE_MESSAGE_MAX)
         : '';
+    // 🔴 **码原样带上,不封长**(0.63.1,G-11):`code` 是**引擎产的标识符**,不是散文 —— 运维要拿它
+    //    整只去问上游,截一半的码谁也查不出来,而且长得像一个完整答案。呈前只做**不可见字符消毒**
+    //    (走本包同一只 {@link escapeDisplayControlChars};不封长 ≠ 不消毒)。`message` 半场的封长
+    //    照旧:那半场确实是散文,屏上的列宽预算是给它的。两半场判据分家是刻意的。
+    const codeWord = typeof code === 'string' && code.length > 0 ? escapeDisplayControlChars(code) : '(no code)';
     const head = known !== undefined
         ? known
-        : `this rule was refused with ${typeof code === 'string' && code.length > 0 ? capForDisplay(code, 60) : '(no code)'}, a code newer than this client`;
+        : `this rule was refused with ${codeWord}, a code newer than this client`;
     return text.length > 0 ? `${head} — ${text}` : head;
 }

package/dist/postureKnob.d.ts

@@ -75,7 +75,9 @@ export declare function projectServerGateKnobs(wiring: unknown): ServerGateKnobs
  *   ① 读数在场 —— `<旋钮> <值> (source: <来源> — <指路句>)`;
  *   ② 读数在场但来自老 worker 的裸值(`legacy`)—— 报得出**值**,但逐字点明「这台 worker 说不出
  *      是谁定的」;**句中不出现任何来源词**(冒称来源比不说更坏:它会让人以为查过了);
- *   ③ `opts.reachable === false` —— 「未观测」:这一次进程没读到 operator 响应;
+ *   ③ `opts.reachable === false` —— 「未观测」:这一次进程没读到 operator 响应。
+ *      🔴 **这一格先判**(0.63.1):它压过任何在手的读数 —— 宿主拿着上一拍的 view、这一拍探测
+ *      打不通时,它能翻的只有这一位;先看读数在不在会照渲上一拍的值,等于拿陈读数冒充现势;
  *   ④ `reachable:true` 但读数仍缺席 —— 「不报」:响应读到了,只是这一位读不出来。
  *      **不武断咎为版本**:整键缺席(老引擎)与在场却形坏折成同一个缺席,句子不能替一种情形撒谎。
  * 🔴 ③④ 两句**一个值都不报** —— 它们要是顺口说了 `off`,消费端就会把「读不出」当成「关着」。

package/dist/postureKnob.js

@@ -131,7 +131,9 @@ function knobValueWord(value) {
  *   ① 读数在场 —— `<旋钮> <值> (source: <来源> — <指路句>)`;
  *   ② 读数在场但来自老 worker 的裸值(`legacy`)—— 报得出**值**,但逐字点明「这台 worker 说不出
  *      是谁定的」;**句中不出现任何来源词**(冒称来源比不说更坏:它会让人以为查过了);
- *   ③ `opts.reachable === false` —— 「未观测」:这一次进程没读到 operator 响应;
+ *   ③ `opts.reachable === false` —— 「未观测」:这一次进程没读到 operator 响应。
+ *      🔴 **这一格先判**(0.63.1):它压过任何在手的读数 —— 宿主拿着上一拍的 view、这一拍探测
+ *      打不通时,它能翻的只有这一位;先看读数在不在会照渲上一拍的值,等于拿陈读数冒充现势;
  *   ④ `reachable:true` 但读数仍缺席 —— 「不报」:响应读到了,只是这一位读不出来。
  *      **不武断咎为版本**:整键缺席(老引擎)与在场却形坏折成同一个缺席,句子不能替一种情形撒谎。
  * 🔴 ③④ 两句**一个值都不报** —— 它们要是顺口说了 `off`,消费端就会把「读不出」当成「关着」。
@@ -145,6 +147,14 @@ export function postureKnobDetail(knob, opts) {
     //    塞进 `toString`,裸下标会命中 `Object.prototype` 上的函数并被拼进句子。读不出名字时退到
     //    一个中性词:**名字读不出不该让「这根旋钮的值是什么」也一起说不出来**。
     const label = Object.hasOwn(KNOB_LABELS, opts.knob) ? KNOB_LABELS[opts.knob] : 'posture knob';
+    // 🔴 **判序承重**(0.63.1,G-3):`!reachable` **先判**,压过任何在手的读数。调用惯例上宿主手里
+    //    就只有上一拍那一只 view —— 探测这一拍打不通时它能翻的只有 `reachable`,别的没得换。先看
+    //    `knob !== undefined` 的旧序会照渲**上一拍的读数**,屏上一个字都看不出这一次根本没读到,
+    //    等于把陈读数冒充现势。打不通时旧读数不是现势:值与来源词一个都不许漏出去。
+    //    ⇒ 求值序是 ③ → ①/② → ④(与上方四句的编号次序无关,编号只是四种情形的清单)。
+    if (!opts.reachable) {
+        return `${label} not observed (this end could not read the engine's diagnostics)`;
+    }
     if (knob !== undefined) {
         const word = knobValueWord(knob.value);
         if (knob.legacy === true) {
@@ -156,9 +166,6 @@ export function postureKnobDetail(knob, opts) {
             ? `${label} ${word} (source: ${source} — ${note})`
             : `${label} ${word} (source: ${source})`;
     }
-    if (!opts.reachable) {
-        return `${label} not observed (this end could not read the engine's diagnostics)`;
-    }
     return `${label} not reported by this engine (an engine below 7.67.0, or a response this end could not parse)`;
 }
 /**

package/dist/workflow.js

@@ -96,7 +96,10 @@ export function projectWorkflowTaskOutput(jsonSrc) {
                 if (!r || typeof r !== 'object')
                     continue;
                 const label = typeof r.label === 'string' && r.label.length > 0 ? r.label : '(agent)';
-                const st = typeof r.status === 'string' ? r.status : '?';
+                // 🔴 与 `parseWorkflowPollEnvelope` **同一判**(0.63.1,G-20 附带②):同一条 wire 上的
+                //    同一个字段,两条链路的「在场」判据必须同形。空串走 `typeof` 单门会被当成一个读数
+                //    渲成 `[]` —— 一对什么也没说的方括号,还长得像一个真答案。空串 = 缺席。
+                const st = typeof r.status === 'string' && r.status.length > 0 ? r.status : '?';
                 const errLine = typeof r.error === 'string' && r.error.length > 0
                     ? ` — ${r.error.split('\n')[0].slice(0, 120)}`
                     : '';

package/dist/workflowClient.js

@@ -67,9 +67,23 @@ import { hostLog } from './host.js';
 // (workflowMonitor.ts) is the 187-faithful consumed set. We read the known fields, coerce
 // the vocabularies, and fill the shell-local render defaults the wire does not carry — same discipline as
 // projectTasks/projectWorkflows in fleet/fleetProjection.ts.
+/**
+ * ── `parked` 在这一族投影里的纪律(0.63.1;G-20)────────────────────────────────────────────
+ * 「停在审批门上」是一个**说得出口的状态词**,不是一个未知的未来值:那条腿在有人做决定之前
+ * **永远不会**自己往前走一步,而 `running` 承诺的恰恰是「等着就好」。⇒ 下面四处窄读一律给它
+ * 一条**自己的臂**,开集兜底(未知未来值 → 活跃)一个字节都不动。
+ *
+ * 三级词表今天各自的真实供给(engine core 7.10.0,亲核):
+ *   · **agent 行** —— `WorkflowItemStatus` 含 `parked`(#642),`deriveAgentDisplayStatus` 直接产
+ *     `"parked"`(`AgentDisplayStatus` 六词)⇒ 这是**今天就会到**的读数。
+ *   · **run 级** —— 仍闭在 running|completed|failed;一条腿 park ⇒ 整只 run 按
+ *     `WorkflowAgentParkedError` 收在 `failed` ⇒ `parked` 今天到不了这一位,那条臂是**前向预挂**。
+ *   · **phase 级** —— 上游明说「a phase or group never parks」,同为前向预挂;本包另从桶里的腿
+ *     **推**出这一格(见 `projectPhases`)。
+ */
 /** run status → the monitor's run-level vocabulary. SDK: queued|running|completed|failed|(open). The monitor
- *  run status is running|done|failed|stopped|paused — there is no run-level 'queued', so a queued run reads as
- *  'running' (the header shows the raw status text anyway; the box treats non-done/failed as active). */
+ *  run status is running|done|failed|stopped|paused|parked — there is no run-level 'queued', so a queued run
+ *  reads as 'running' (the header shows the raw status text anyway; the box treats non-done/failed as active). */
 function coerceRunStatus(s) {
     switch (s) {
         case 'completed':
@@ -78,6 +92,8 @@ function coerceRunStatus(s) {
             return 'failed';
         case 'running':
             return 'running';
+        case 'parked':
+            return 'parked'; // 前向预挂(见上方族头注):词真到了就原样透出,绝不折成「在跑」
         default:
             return 'running'; // queued / unknown-future → render as an active run (open-set fallback)
     }
@@ -94,6 +110,8 @@ function coercePhaseStatus(s) {
         case 'queued':
         case 'pending':
             return 'not-started';
+        case 'parked':
+            return 'parked'; // 前向预挂,同 coerceRunStatus
         default:
             return 'running';
     }
@@ -123,6 +141,11 @@ function coerceAgentState(s) {
         // !workflowActive — the run IS terminal whenever core emits this).
         case 'interrupted':
             return 'inactive';
+        // 🔴 core 7.10.0 #642:这条腿耐久挂在一张审批卡上(行上记着 checkpoint token)。**今天就会到**
+        // 的读数(raw `status` 与 `displayStatus` 两条腿都会带),原词透出——折进 `progress` 就是把
+        // 「要人去批」渲成「等它跑完」。
+        case 'parked':
+            return 'parked';
         default:
             return 'progress'; // unknown-future live status → render as an active agent (open-set fallback)
     }
@@ -174,7 +197,10 @@ function projectAgent(row, index) {
     // queued|running|done|failed|interrupted) over the RAW record `status` (running|completed|failed): the raw
     // vocabulary carries no queued/interrupted arm — a queued agent's record status is literally 'running', so
     // coercing `row.status` alone rendered every queued agent as "Running" (the [840] parity gap).
-    const displayStatus = typeof rec.displayStatus === 'string' ? rec.displayStatus : undefined;
+    // 🔴 空串 = 缺席(0.63.1,G-20 同形存量⑤):`??` 只挡 null/undefined,一个空串的 `displayStatus`
+    //    会把 raw `status` 整个静默吃掉(`'' ?? row.status` === `''`)—— 那条腿真正的状态词连回落
+    //    这条路都走不到。与 `workflow.ts` 两条链路同尺:空串不是读数。
+    const displayStatus = typeof rec.displayStatus === 'string' && rec.displayStatus.length > 0 ? rec.displayStatus : undefined;
     const state = coerceAgentState(displayStatus ?? row.status);
     const activity = projectActivity(row.activity);
     const last = activity.length ? activity[activity.length - 1] : undefined;
@@ -276,10 +302,9 @@ function projectPhases(run, agents) {
     if (distinct.length > 0) {
         return distinct.map(title => {
             const bucket = agents.filter(a => a._phase === title);
-            const allDone = bucket.every(a => a.state === 'done');
             return {
                 title,
-                status: bucket.some(a => a.state === 'error') ? 'failed' : allDone ? 'done' : 'running',
+                status: bucketStatus(bucket),
                 doneCount: bucket.filter(a => a.state === 'done').length,
                 totalCount: bucket.length,
                 agents: bucket.map(stripPhase),
@@ -289,13 +314,45 @@ function projectPhases(run, agents) {
     return [
         {
             title: 'Workflow',
-            status: run.status === 'completed' ? 'done' : run.status === 'failed' ? 'failed' : 'running',
+            // 同形第二处(G-20):这条三元式与 `coerceRunStatus` 读的是同一位 run 状态,兜底也同形 ——
+            // 只修一处等于把病搬个家。`parked` 走 `coerceRunStatus` 的同一条臂,不在这里另写一遍判据。
+            status: synthPhaseStatus(run.status, agents),
             doneCount: agents.filter(a => a.state === 'done').length,
             totalCount: agents.length,
             agents: agents.map(stripPhase),
         },
     ];
 }
+/**
+ * 一桶腿 → 这一格的状态词。
+ *
+ * 🔴 `parked` 的判据是「**这一格里没有一条腿能自己往前走**」:全员不是完成就是停在门上,且至少有
+ *    一条真停着。混着还在跑的腿时**仍报 running** —— 那一格确实还在跑,渲成 parked 是另一个方向的谎。
+ * 🔴 `failed` 仍先判:一格里既有失败又有停着的腿时,先要人看的是那条失败的。
+ */
+function bucketStatus(bucket) {
+    if (bucket.some(a => a.state === 'error'))
+        return 'failed';
+    if (bucket.length > 0 && bucket.every(a => a.state === 'done'))
+        return 'done';
+    if (bucket.some(a => a.state === 'parked') && bucket.every(a => a.state === 'parked' || a.state === 'done')) {
+        return 'parked';
+    }
+    return 'running';
+}
+/** 合成 `Workflow` 单格(路径三:wire 既无结构化 phases 也无 agent 上的 phase 标)的状态词。
+ *  跟 run 走(同 {@link coerceRunStatus} 的臂),run 说不出 `parked` 时再从腿上推一次 —— 今天真正
+ *  会带 `parked` 的正是腿那一级,而路径三的这一格代表的就是整只 run 的全部腿。 */
+function synthPhaseStatus(runStatus, agents) {
+    if (runStatus === 'completed')
+        return 'done';
+    if (runStatus === 'parked')
+        return 'parked';
+    const derived = bucketStatus(agents);
+    if (derived === 'parked')
+        return 'parked';
+    return runStatus === 'failed' ? 'failed' : 'running';
+}
 /** THE projector: SDK `WorkflowRun` (client.workflows.get) → the monitor's `WorkflowRunState`. Pure/total —
  *  tolerates absent/permissive fields and never throws (the graceful-degrade contract lives above, in the
  *  source loop; this just maps a well-formed run). Exported for the mock-parity unit cross-check. */

package/dist/workflowMonitor.d.ts

@@ -14,8 +14,13 @@
  *    留在 TUI 的:`computeVisibleWindow`(滚动窗口数学 = 视口概念,端专属)、glyph/color 映射、
  *    以及整棵 JSX。壳侧 shim = 那个 tsx 改成从本包 re-export 这两样,自己不再定义。
  */
-export type AgentState = 'start' | 'progress' | 'queued' | 'done' | 'error' | 'inactive';
-export type DisplayStatus = 'queued' | 'running' | 'done' | 'failed' | 'skipped' | 'interrupted';
+export type AgentState = 'start' | 'progress' | 'queued' | 'done' | 'error' | 'inactive'
+/** sema 超集:这条腿耐久挂在一张审批卡上(engine core 7.10.0 #642)。见上方头注。 */
+ | 'parked';
+export type DisplayStatus = 'queued' | 'running' | 'done' | 'failed' | 'skipped' | 'interrupted'
+/** sema 超集:同上。🔴 端的 glyph/颜色映射是**穷尽形**,加这一词就必须同批加一条 case
+ *  (措辞按「waiting for approval」一类,别复用 running 的字与色)。 */
+ | 'parked';
 export interface WorkflowToolCall {
     name: string;
     summary?: string;
@@ -61,7 +66,10 @@ export interface WorkflowAgent {
 }
 export interface WorkflowPhase {
     title: string;
-    status: 'not-started' | 'running' | 'done' | 'failed';
+    /** 🔴 `parked` = 这一格里没有一条腿能自己往前走(全员不是完成就是停在审批门上)。见 `AgentState`
+     *  的同名头注;上游今天不给 phase 铸这个词(core:「a phase or group never parks」),本包这一位有两个
+     *  来路:①上游哪天真铸了 ⇒ 原词透出而不是折成 running;②本包从桶里的腿**推**出来。 */
+    status: 'not-started' | 'running' | 'done' | 'failed' | 'parked';
     doneCount: number;
     totalCount: number;
     agents: WorkflowAgent[];
@@ -73,7 +81,11 @@ export interface WorkflowRunState {
     summary?: string;
     script: string;
     scriptPath?: string;
-    status: 'running' | 'done' | 'failed' | 'stopped' | 'paused';
+    /** 🔴 `parked`(0.63.1,additive):**前向预挂** —— engine core 7.10.0 的 run 级词表仍闭在
+     *  running|completed|failed(一条腿 park ⇒ 整只 run 按 `WorkflowAgentParkedError` 收在 `failed`),
+     *  所以今天没有任何受支持的引擎在这一位上发 `parked`。留这条臂是为了「词真到了就原样透出」,
+     *  绝不是说它现在会到 —— 判「这条 run 停着等人批」今天要看**腿**那一级(见 `AgentState.parked`)。 */
+    status: 'running' | 'done' | 'failed' | 'stopped' | 'paused' | 'parked';
     cloud?: boolean;
     agentCount: number;
     totalTokens: number;
@@ -97,5 +109,9 @@ export interface WorkflowRunState {
  * fields on the active path. The AgentState type carries exactly this input set, so the type contract now
  * matches the atlas vocabulary 1:1 — the branches below consume only atlas input states and the output
  * DisplayStatus set + glyph/color mapping ($jn) is identical.
+ *
+ * 🔴 **`parked` 是这条规则上唯一的 sema 超集臂**(0.63.1):atlas 没有它,因为 CC 的编排里没有耐久
+ * 审批这一层。它**不派生**——上游直接铸这个词(engine core 7.10.0 #642 的 agent 行 `status` 与
+ * `deriveAgentDisplayStatus` 产物),这里只是不许把它折掉。臂的**位置**是承重的,理由写在分支处。
  */
 export declare function agentDisplayStatus(a: WorkflowAgent, workflowActive: boolean): DisplayStatus;

package/dist/workflowMonitor.js

@@ -29,6 +29,10 @@
  * fields on the active path. The AgentState type carries exactly this input set, so the type contract now
  * matches the atlas vocabulary 1:1 — the branches below consume only atlas input states and the output
  * DisplayStatus set + glyph/color mapping ($jn) is identical.
+ *
+ * 🔴 **`parked` 是这条规则上唯一的 sema 超集臂**(0.63.1):atlas 没有它,因为 CC 的编排里没有耐久
+ * 审批这一层。它**不派生**——上游直接铸这个词(engine core 7.10.0 #642 的 agent 行 `status` 与
+ * `deriveAgentDisplayStatus` 产物),这里只是不许把它折掉。臂的**位置**是承重的,理由写在分支处。
  */
 export function agentDisplayStatus(a, workflowActive) {
     if (a.state === 'done')
@@ -36,6 +40,12 @@ export function agentDisplayStatus(a, workflowActive) {
     // atlas: `state==="error"` → skipped?"skipped":"failed".
     if (a.state === 'error')
         return a.skipped ? 'skipped' : 'failed';
+    // 🔴 sema 超集臂,**位置承重**:必须在 `!workflowActive` 之前判。一条腿 park 之后 run 自己收在
+    //    `failed`(core `WorkflowAgentParkedError`)⇒ `workflowActive` 恒假 ⇒ 放到后面就永远被
+    //    `interrupted` 吃掉,而 interrupted 说的是「run 结束时它还没跑完」——那是一件**已经过去**的事,
+    //    parked 说的是「它还挂在那儿,等一个人做决定」,是一件**还能动手**的事。两句下一步不同。
+    if (a.state === 'parked')
+        return 'parked';
     // atlas `!t` (workflow not active) → interrupted (also the `inactive`-state landing).
     if (!workflowActive)
         return 'interrupted';

package/docs/INTEGRATION-CLIENTS.md

@@ -4175,6 +4175,13 @@ readonly detachArmed?: boolean | undefined
 「本轮全部正文」去比,一个「散文 → 工具 → 散文」的**正常多步回答**会被判成分岔,只差首尾空白的回答
 同理。⇒ 左边必须是**当前这条 assistant 消息**已上屏的正文(工具边界重置),相等判定先过一次 `trim()`。
 
+**0.63.2 订正(卡后零散文)**:provider 的一条 assistant 消息 = `[text, tool_use]` 两块。工具卡是这一轮
+**最后**一件事、卡后一个字都没有时,引擎「最后一条消息的文本」正是卡**之前**那段;而工具边界已把
+「当前消息已上屏正文」重置成空串,空串是任何终帧的前缀 ⇒ 修前补差臂把整段终帧当「缺的后缀」再渲一遍
+(同一段话上屏两遍;cli 1.0.105 收官 mock 车道「散文 → Config 卡 → 收口」实撞)。⇒ 左边现在是
+「当前消息已上屏正文,**当前消息一个字都没上屏时回退到上一条真有正文的消息**」(`lastCommittedAnswerText`);
+当前消息有字时与修前逐字同。宿主零换装。
+
 **新 chrome 臂**:
 
 ```ts
@@ -4359,6 +4366,12 @@ POSTURE_SOURCE_WORDS: readonly string[]   // ['env','center','posture','engine-d
 版本**)。🔴 后两句**一个值都不报** —— 顺口说了 `off`,消费端就会把「读不出」当成「关着」。
 数值一律按毫秒渲人话(`24h` / `5m`;除不尽就报毫秒,`1.5h` 比 `90m` 容易读错)。
 
+🔴 **判序:`reachable:false` 先判,压过任何在手的读数**(0.63.1 订正 —— 0.63.0 是先看读数在不在)。
+这是一条**调用惯例**上的事实:端手里就只有上一拍那一只 view,探测这一拍打不通时它能翻的只有
+`reachable`,别的没得换。旧序下「旧 knob + `reachable:false`」照渲**上一拍的值和来源词**,屏上一个字
+都看不出这一次根本没读到 —— 那是拿陈读数冒充现势。⇒ 端**不必**为了这个自己把 view 清空,
+传旧 view + `reachable:false` 就是正解,四句里出的一定是「未观测」那一句。
+
 ---
 
 ### 27c. ② 三态规则身份:`behavior` 必填且不给默认(BREAKING 迁移②)
@@ -4437,6 +4450,33 @@ ENGINE_IDENTITY_ANCHORS: readonly ['startedAt', 'instanceId', 'pid']
   一只锚可比且相同,判词照给 `same`。
 - **归层**:「换代之后要做什么」(丢连接、重握手、提示用户)是**宿主的状态机**,不在本包。
 
+🔴 **`pid` 是最弱锚,而「只剩 pid 可比」不是任何受支持引擎的读数**(0.63.1 补记,收窄 G-8 的判据口径)
+
+有人会问:两次 `/health` 的 `pid` 恰好相同(端口复用、容器里 pid 恒 `1`)时判 `same`,会不会把一次
+真换代读成「同一条命」?**会 —— 但那要求 `instanceId` 在两侧都缺席**,而那种读数在生产上到不了:
+
+- `instanceId` 在引擎里是**无条件铸**的(不是可选特性,不由任何开关关掉),`/health` 体一路带着它;
+  常驻门 `run-engine-identity-test.mjs` 的 **E 段**用引擎产物**锚 AST**盯着这条外部事实,**三节全验**:
+  ①**铸** —— `const instanceId = uuidv7()` 不在任何 `if`/`switch`/`try`/三元/`&&`/`??`/循环里;
+  ②**接线** —— 铸出的那个值真被挂到一只对象上(否则 `deps.instanceId` 就是 `undefined`);
+  ③**发射** —— `instanceId` 真在 `/health` **那一只**响应体的键空间上(按 `status:"ok"` +
+  `pid: process.pid` 两键定位;挂在别的对象上、长在嵌套值里、经包装调用摊进来,一律判**判不出**)。
+  条件 spread 只认「守卫就是那个值本身」(`...(deps.instanceId ? { instanceId: deps.instanceId } : {})`)
+  —— 那种形说的是「只在它自己缺席时才省」,配上 ①② 就是恒在场;换成别的旗子只是「可能带上」。
+  🔴 **射程边界**:这三节证的是**源码形**,挡的是「上游把这条锚改成可选 / 改了铸法 / 断了接线」这一类
+  漂移;它**证不了**「这段代码真的被执行」——那要一次真启动的 `/health` 响应,不在本包射程内。
+  🔴 **这条见证是 G-8 裁读的承重腿**:`SEMA_FENCE_ENGINE_DIR` 未注入时那一段打 `SKIPPED-SECTION`
+  (汇总里显形成 PARTIAL),**发布批必须注入一次引擎树把它跑绿**才能引用本段的结论。
+- 只要 `instanceId` 在两侧都在场,它就压过 `pid` —— `pid` 相同而 `instanceId` 不同**判 `changed`**,
+  优先序里 `pid` 排表尾(D 段两条钉)。
+
+⇒ 本包**刻意不**把「只剩 `pid` 可比且相等」判成 `unknown`。那样做的代价是**真实且每拍发生的**:
+一台报得出 `pid`、报不出另两只锚的老 worker,每一次心跳都会被判「判不出」⇒ 宿主按最坏情况重握手。
+拿一个每拍都发生的代价,去换一个上面两条证明到不了的风险,不划算。
+
+🔴 端要记住的一句:`pid` **从不落单** —— 它旁边总有 `instanceId`。哪天真读到一份**只有 `pid`** 的
+`/health`,那不是「老引擎」,那是一个本文档没有覆盖的形,按最坏情况处理(重握手)而不是按 `same`。
+
 ---
 
 ### 27e. ④ 门词汇两张表 +2 与唯一措辞铸点
@@ -4449,9 +4489,9 @@ core 7.9.0 各加一词:`DeniedBy` **+`persisted_rule`**(这个人自己名下
 **签名**
 
 ```ts
-GATE_DENIED_BY_WORDS: readonly DeniedBy[]   // 九词,顺序同源
+GATE_DENIED_BY_WORDS: readonly DeniedBy[]   // 9 词,顺序同源
 gateDeniedByDetail(deniedBy: unknown): string
-ASK_ORIGIN_WORDS: readonly string[]         // 十一词,顺序同源
+ASK_ORIGIN_WORDS: readonly string[]         // 11 词,顺序同源
 askOriginDetail(origin: unknown): string
 ```
 
@@ -4482,7 +4522,7 @@ askOriginDetail(origin: unknown): string
 **签名**
 
 ```ts
-PERMISSION_RULE_ISSUE_CODES: readonly string[]          // 十五码
+PERMISSION_RULE_ISSUE_CODES: readonly string[]          // 15 码
 RETIRED_PERMISSION_RULE_ISSUE_CODES: readonly string[]  // 记账座,查码别查它
 permissionRuleIssueDetail(code: unknown, message: unknown): string
 ```
@@ -4493,9 +4533,12 @@ permissionRuleIssueDetail(code: unknown, message: unknown): string
 `unsupported.*` = 规则本身合法但**这条车道不接**(换写法、或落到规则店而不是策略折叠)。上游把它们
 分成两个前缀,正是因为「以为挡住了」比没挡更危险。
 
-**缺席语义**:表外码 ⇒ 那一句说「这个码比这一端新」,原样带上那个码,**并照样带上 `message`**
-(码读不懂不代表引擎那句话读不懂,而那句话往往才是能动手改的那条信息)。`message` 是**散文不是码**:
-只渲染、呈前**先转义后封长**,绝不做等值匹配、绝不当分类位。坏码 / 坏 `message` 一律**不抛**
+**缺席语义**:表外码 ⇒ 那一句说「这个码比这一端新」,**原样**带上那个码,**并照样带上 `message`**
+(码读不懂不代表引擎那句话读不懂,而那句话往往才是能动手改的那条信息)。🔴 **「原样」是逐字的**
+(0.63.1 订正:0.63.0 实际把码封在 60 字符内,与本句冲突)—— 码是**引擎产的标识符**,运维要拿它
+整只去问上游,截一半的码谁也查不出来、还长得像一个完整答案。呈前只做**不可见字符消毒**,**不封长**
+(不封长 ≠ 不消毒)。`message` 是**散文不是码**:只渲染、呈前**先转义后封长**(封长只给这半场),
+绝不做等值匹配、绝不当分类位。坏码 / 坏 `message` 一律**不抛**
 (这条路径跑在「用户规则写错了」那一刻,读器再抛一次只会把一个说得清的错误换成一个说不清的崩)。
 
 ---
@@ -4554,11 +4597,11 @@ an argument」。audience 答另一问:这条事实**说给谁听**。
 **签名**
 
 ```ts
-ENGINE_NOTICE_CODES: readonly string[]                              // 四十八码,顺序同源
+ENGINE_NOTICE_CODES: readonly string[]                              // 50 码,顺序同源
 ENGINE_NOTICE_AUDIENCE: Readonly<Record<string, 'user' | 'operator'>>
 noticeAudienceOf(code: unknown): 'user' | 'operator'
 engineNoticeInCatalog(code: unknown): boolean
-MCP_INJECTION_DROP_REASONS: readonly string[]                       // 四个原因词
+MCP_INJECTION_DROP_REASONS: readonly string[]                       // 4 个原因词
 readMcpInjectionDrop(notice: unknown): McpInjectionDropFactsView | undefined
 ```
 
@@ -4624,13 +4667,49 @@ core 双向对账)。**候上游导出即整只退役改成从 sdk 取**。
 
 ---
 
-### 27h3. `WorkflowRunStatus` 的 `parked`:**零改**,原词透出
+### 27h3. `parked`:一条腿停在审批门上(0.63.1 订正 —— 0.63.0 这一节写错了两处)
+
+**0.63.0 原文的两处失真,先说清楚**(留痕不删,免得下一个人再按原文接线):
 
-core 7.10.0 给 workflow run 的状态开放联合加了 `parked`。本包**一个字节都不用改**:
-`src/workflow.ts` 的两处读法本来就把 `status` 当**开集字符串**原样透出(`typeof === 'string' &&
-length > 0` 即收),从不窄读成枚举 —— 所以 `parked` 自动逐字到达端上,端按自己的行渲染即可。
-📋 **如实记一笔已知形**(不是本批引入,也不在本批射程):`readWorkflowRunLine` 在 `status` 读不出时
-回落 `'completed'` —— 那是把「说不出」渲成「完成了」。它先于本批存在,登记在此供后续独立处置。
+1. 写的是「core 7.10.0 给 **workflow run 的状态**开放联合加了 `parked`」——**不对**。上游加的是
+   **agent 行**那一级:`WorkflowItemStatus` +`parked`(#642),且 `deriveAgentDisplayStatus` 直接产
+   `"parked"`(`AgentDisplayStatus` 六词)。**run 级**词表今天仍闭在 running|completed|failed ——
+   一条腿 park 之后整只 run 按 `WorkflowAgentParkedError` 收在 `failed`。
+2. 写的是「本包**零改**,`src/workflow.ts` 两处读法原样透出」——那两处(`parseWorkflowPollEnvelope`
+   / `projectWorkflowTaskOutput`,**不是**原文写的 `readWorkflowRunLine`,那个名字在本包里零命中)
+   确实原样透出,但它们是 **TaskOutput 文本车道**;**监视器投影车道**(`src/workflowClient.ts`)是
+   另一条,而它当时把 `parked` 折进了「在跑」。
+
+**0.63.1 改了什么**:监视器车道的四处窄读各给 `parked` 一条**自己的臂**,开集兜底一个字节不动。
+
+| 车道 / 位 | 0.63.0 | 0.63.1 | 今天真会到吗 |
+|---|---|---|---|
+| agent 行 `status` / `displayStatus`(`coerceAgentState`) | 折 `progress` | `parked` | 🔴 **会** —— 上游今天就铸 |
+| `agentDisplayStatus()`(WPe) | 落 `interrupted` | `parked` | 🔴 **会**(park 之后 run 恒非活跃,所以这条臂**必须排在** `!workflowActive` 之前) |
+| run 级 `status`(`coerceRunStatus`) | 折 `running` | `parked` | ❌ 前向预挂(run 词表未开) |
+| phase 级 `status`(`coercePhaseStatus` + 合成格三元式) | 折 `running` | `parked` | ❌ 前向预挂;另由本包**从桶里的腿推**出来 |
+
+**型面**(三处 additive,端的穷尽形要各加一条 case):`AgentState` +`parked` · `DisplayStatus`
++`parked` · `WorkflowRunState['status']` / `WorkflowPhase['status']` +`parked`。
+
+**桶推导的判据**(本包自己加的那一格,`projectPhases`):一格报 `parked` ⇔ **这一格里没有一条腿能
+自己往前走** —— 全员不是完成就是停在门上,且至少一条真停着。混着还在跑的腿时**仍报 `running`**
+(那一格确实还在跑,渲成 parked 是另一个方向的谎);`failed` 仍先判。
+
+- 🔴 **为什么不能折**:`parked` 的下一步是**去批它**,`running` 的下一步是**等着**。这条腿在有人
+  做决定之前**永远不会**自己往前走一步 —— 折过去等于把一件要人动手的事渲成一件不用管的事。
+- 🔴 **开集兜底没动**:未知未来值照旧落活跃臂(run/phase → `running`,agent → `progress`)。
+  `parked` 是**加了一条案臂**,不是把兜底改宽。
+**同批把「空串算不算读数」在这一族里拉齐**(G-20 附带②):同一条 wire 上的同一个 `status` 字段,
+三处在场判此前不同形 —— `parseWorkflowPollEnvelope` 判 `length > 0`(空串=缺席),
+`projectWorkflowTaskOutput` 的 per-agent 与 `projectAgent` 的 `displayStatus` 只判 `typeof`
+(空串=在场)。后两处的后果各不相同但都是谎:前者把空串渲成 `[]`(一对什么也没说的方括号,
+却长得像一个真答案),后者更坏 —— `'' ?? row.status` 恒取空串(`??` 只挡 null/undefined),
+那条腿的 raw `status` 被**静默丢掉**,连回落都走不到。三处现在同一判:**空串 = 缺席**;
+纯空白**不** trim(两侧同尺,仍算在场)。端侧无需改动,只是不会再收到 `[]` 与被吞掉的状态词。
+
+- 📋 **如实记一笔已知形**(不是本批引入,也不在本批射程):`parseWorkflowPollEnvelope` 在 `status`
+  读不出时回落 `'completed'` —— 那是把「说不出」渲成「完成了」。它先于本批存在,登记在此供后续独立处置。
 
 ---
 
@@ -4638,15 +4717,16 @@ length > 0` 即收),从不窄读成枚举 —— 所以 `parked` 自动逐字到
 
 | 件 | 壳(cli 1.0.106) | web 端 |
 |---|---|---|
-| ① | `doctor` 的 Permissions 段加**三行**:`postureKnobDetail(view.durableApproval, {reachable, knob:'durableApproval'})` / 同形的 `streamAskWindowMs` / `sessionAutoTitle`;`reachable` 由壳自己那次 operator 探测的结果给。🔴 分类读一律走 `postureKnobSourceOf()`,**别直读** `.source` | 诊断面同左;无 operator 权限的部署上这一面整段不渲(端点本身 operator-gated) |
+| ① | `doctor` 的 Permissions 段加**三行**:`postureKnobDetail(view.durableApproval, {reachable, knob:'durableApproval'})` / 同形的 `streamAskWindowMs` / `sessionAutoTitle`;`reachable` 由壳自己那次 operator 探测的结果给 —— 🆕 0.63.1 起**不必**为打不通而先把 view 清空,旧 view + `reachable:false` 直接渲「未观测」(`!reachable` 先判)。🔴 分类读一律走 `postureKnobSourceOf()`,**别直读** `.source` | 诊断面同左;无 operator 权限的部署上这一面整段不渲(端点本身 operator-gated) |
 | ② | `/permissions` 治理表加「态」一列 = `persistedRuleBehaviorLabel(row)`;撤销按钮改经 `revokeTargetFromPersistedRule(row)` —— **铸不出体就把那一行的撤销入口藏掉**(别退化成两元组撤销) | 同左 |
 | ③ | 三条 uplift 锚 `*-startedat-*`:①引擎 spawn 后的首探记下 `engineIdentityOf(health)`;②重连 / 定期心跳时 `engineIdentityVerdict(prev, now)`,`changed` ⇒ 走既有的 `engineReplacedGate`;③`unknown` **不许**走「没换」那条臂(它要么再探一次、要么按最坏情况重握手) | 同左;web 端没有 spawn 半场,只有 ②③ |
 | ④ | 门记录那一行:`gateDeniedByDetail(gateDeniedBy(g))`(九词);审批卡的出身行:`askOriginDetail(frame.origin)`(十一词)。壳侧同族自拼句子一律退役 | 同左 |
-| ⑤ | `/permissions` 的规则报错行:`permissionRuleIssueDetail(issue.code, issue.message)` | 同左 |
+| ⑤ | `/permissions` 的规则报错行:`permissionRuleIssueDetail(issue.code, issue.message)`。🆕 0.63.1:表外码**整只**进那一句(不再封 60 字符),端的行渲染要给它留得下换行/截断的余地 —— 🔴 别在端上再截一刀,那等于把这次修的病搬到端里 | 同左 |
 | ⑥ | `wiring_manifest` 帧到达时 `projectToolRoster(manifest)`;**在场**则自报面与工具卡 shim 走 `toolRosterNames()` / `toolShimFromRoster()`,**缺席**才回落 `liveInitToolFace` 三表。`tool_roster_delta` 帧走 `applyToolRosterDelta()`,`skew` 时**记一次偏斜并按快照重同步**(别拿 summary 算位置) | 同左 |
 | ⑦ | `engine_notice` 呈现闸改按 `engineNoticeInCatalog(code)`;投递面按 `noticeAudienceOf(code)` 分流(`user` 上屏 / `operator` 落运维面)。壳自己的 `CORE_ENGINE_NOTICE_CODES` / `PENDING_ENGINE_NOTICE_CODES` 两表**可以退役成一张「明拒表」**(本包这张是上游码册的机械镜像,壳只需保留它**刻意不渲**的那几个码)。🔴 `mcp.injection_dropped` 的转录**直接用 `message`**,别自拼 | 同左 |
 
 | ⑧ | 审批卡上「为什么问我」那一行:`classifierUnavailableDetail(classifierUnavailableOf(ask)?.cause)`;durable park 行的卡走**同一只**读器(键路同形)。🔴 这一格是**显示元数据**,别据它翻转任何裁决;缺席**不许**渲成「分类器跑成了」 | 同左 |
+| ⑨ | `workflowMonitor` 的 agent 行:`DisplayStatus` 的 **`parked`** 是一条新臂,glyph/颜色映射与状态词是**穷尽形** —— 必须同批加一条 case,措辞按「waiting for approval」一类,🔴 **别复用 `running`**的字与色(那正是 0.63.0 的病)。`AgentState` 侧同理。合成格/phase 行拿到 `parked` 时同样别渲成在跑 | 同左 |
 
 ---
 
@@ -4694,8 +4774,10 @@ length > 0` 即收),从不窄读成枚举 —— 所以 `parked` 自动逐字到
 - **G-19**:让分类器**答了但答在契约之外**(parse_error)—— 卡上**不出现**「分类器跑不了」那一族的
   任何一句(引擎在这一形上根本不盖那一格);而**不武装** auto 模式跑同样的调用 —— 卡上同样没有那一行
   (缺席 ≠「分类器跑成了」)。
-- **G-20**:让一条 workflow run 进入 `parked` —— 端上那一行显示的状态词**逐字是 `parked`**
-  (不是被折成 `running` / `completed` / 或一个 `?`)。
+- **G-20**(0.63.1 订正判据口径:park 落在**腿**上不落在 run 上)——让一条 workflow **agent 腿**停在
+  审批门上:监视器里那一行的状态词**逐字是 `parked`**(不是 `running`,也不是 `interrupted` —— 那条腿
+  park 之后整只 run 就收在 `failed`,所以「run 不活跃 ⇒ interrupted」那条老臂会抢答);批掉那张卡之后
+  那一行**不再**是 `parked`。反向:随便造一个这一端没见过的状态词,那一行仍渲成在跑(开集兜底没被改宽)。
 
 ---
 
@@ -4704,7 +4786,7 @@ length > 0` 即收),从不窄读成枚举 —— 所以 `parked` 自动逐字到
 | 门 | 守什么 |
 |---|---|
 | 🆕 `scripts/run-posture-knob-projection-test.mjs` | ① 三旋钮窄读 / 裸值折壳但来源不冒称 / 主锚坏整段缺席·旁枝坏只丢一根 / 四句逐字互异 + 毫秒人话 / 转义后封长 / sdk spec + d.ts 真字节(含「本面数值旋钮恰一根」的措辞前提钉) |
-| 🆕 `scripts/run-engine-identity-test.mjs` | ③ 三锚逐格窄读 / 三态判词 + 优先序 / **锚交集为空 ⇒ unknown 而非 same** / 布尔口只对 changed 说 true / sdk `health.d.ts` 真字节含缺席语义注 |
+| 🆕 `scripts/run-engine-identity-test.mjs` | ③ 三锚逐格窄读 / 三态判词 + 优先序 / **锚交集为空 ⇒ unknown 而非 same** / 布尔口只对 changed 说 true / sdk `health.d.ts` 真字节含缺席语义注;🆕 **D 段**(0.63.1)G-8 的设计钉 —— pid 单锚相等仍判 same、pid 相等压不住更强的锚、优先序里 pid 是表尾;🆕 **E 段** 引擎产物第二见证(锚 AST 不锚子串,**铸/接线/发射三节全验**)—— 铸点不在任何条件构造或循环里 · 铸出的值真被挂到一只对象上 · `instanceId` 真在 `/health` 那只体的键空间上(`status:"ok"` + `pid: process.pid` 两键定位;别的对象/嵌套值/包装调用/别的旗子做守卫,一律判不出)。🔴 `SEMA_FENCE_ENGINE_DIR` **未注入 ⇒ 打 `SKIPPED-SECTION`**(汇总里显形成 PARTIAL,不冒充全绿);**注入了却拿不到物料 ⇒ 判红**(显式配置却无见证 = 配置坏了)。射程边界:证的是源码形,不证「这段码真被执行」 |
 | 🆕 `scripts/run-gate-vocabulary-test.mjs` | ④ 两张表对 sdk 联合成员**双向等值**(缺一词红、多一词红、乱序红)/ 措辞逐词覆盖 + 句句互异 / **两张表的开闭兜底逐字分家** |
 | 🆕 `scripts/run-permission-rule-issue-codes-test.mjs` | ⑤ 表 ⟷ core 真铸码双向等值 / 表 ∪ 退役表 ⟷ core 声明联合(显形改名遗留)/ `invalid`·`unsupported` 两族措辞逐字互斥 / 散文消毒 + 转义后封长 / 可选 `SEMA_FENCE_ENGINE_DIR` 第二见证 |
 | 🆕 `scripts/run-tool-roster-projection-test.mjs` | ⑥ **绝不半张名册** / digest 恰 16 位小写 hex / `pathTarget` 三新键可选且缺席不铸默认 / shim 只从名册取(轴缺席不填 false·never)/ **skew 不是拒绝** / 坏帧什么都不发生 / 纯函数不改入参 |
@@ -4713,6 +4795,6 @@ length > 0` 即收),从不窄读成枚举 —— 所以 `parked` 自动逐字到
 | `scripts/run-sdk-floor-test.mjs` | `FLOOR` 8.5.0 → **8.8.0**,抬版理由逐条记账(编译期对账钉 / 撤销体铸点 / `startedAt` / `pathTarget` 三键 / 两张闭集加员) |
 | `scripts/run-client-core-portability-test.mjs` | index 闭包上限 148 → **154**(六件新读器叶,逐件登记;`EXPECTED_PACKAGES_INDEX` 一字未动) |
 | `scripts/run-public-surface-test.mjs` | 公面导出基线 **869 → 901** |
-| `scripts/run-integration-doc-freshness-test.mjs` | 本节新增坐标在盘 + 入库;§0a/§2/§2b 计数与基线等值 |
+| `scripts/run-integration-doc-freshness-test.mjs` | 本节新增坐标在盘 + 入库;§0a/§2/§2b 计数与基线等值;🆕 **①c**(0.63.1):签名块里的**表长数字** ⟷ 源码那张表的真实成员数(TS AST 取 `Object.freeze([...])` 的元素个数)。档里一律写阿拉伯数字 —— 中文数词读不出来的门等于没有门,抽取器读不出即判工具红 |
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/client-core",
-  "version": "0.63.0",
+  "version": "0.63.2",
   "description": "Client-side session runtime shared by every sema human client (TUI / web / desktop): sema wire frames (AgentEvent) -> CC session vocabulary (SDKMessage) with dual-plane output (transcript/chrome), deterministic transcript ids, lane discipline as a type, and the notification/dedup ledgers. Every CC-skin shape is collected here so the wire itself stays neutral. Renamed from @sema-agent/wire-cc-adapter (0.1.x).",
   "license": "MIT",
   "type": "module",