@sema-agent/client-core 0.43.1 → 0.45.0

package/dist/hitl/toolApprovalWire.js

@@ -295,6 +295,12 @@ parkGatedCallId) {
         ...(pending.governanceForced === true ? { governanceForced: true } : {}),
         ...(ruleOffersReadOnly !== undefined ? { ruleOffersReadOnly } : {}),
         ...(isWireRecordCarrier(durableProbeCause) ? { probeCause: durableProbeCause } : {}),
+        // #348(0.44.0)durable 腿的对偶:行上**本来就存着**这个值(server `parked-decide.ts`;SDK
+        // `PendingCheckpoint.toolCallId?: string | null` 直证)。与活卡帧腿同一个卡位、同一条缺席纪律 ——
+        // `null`(SDK 声明的第二种缺席形)与空串一并降键缺席,绝不把 `null` 折成串。
+        ...(typeof pending.toolCallId === 'string' && pending.toolCallId !== ''
+            ? { toolCallId: pending.toolCallId }
+            : {}),
     });
     switch (card.kind) {
         case 'failed':
@@ -540,6 +546,11 @@ export function readToolApprovalRespondAck(v) {
         // 🔴 **整只判形**(不逐条丢):合取批的回执是一份清单,漏掉一条就是对人少报了一次授权 ——
         //    非数组 / 空 / 含非串或空串成员 ⇒ 整只降缺席(诚实「不知道」优先于半份清单)。
         ...(isNonEmptyStringArray(o.persistedRules) ? { persistedRules: o.persistedRules } : {}),
+        // P-39 归属锚(server ≥7.48.0):同样**整只判形**,理由见该位注。
+        ...(() => {
+            const anchors = readPersistedRuleAnchors(o.persistedRuleAnchors);
+            return anchors !== undefined ? { persistedRuleAnchors: anchors } : {};
+        })(),
     };
     // 🔴 **两位规范文本回显的「同份 ack 内矛盾形」**(异源对抗复审 [high] 采纳,0.43.0)——
     //    这与本函数不做的**相关性**判定(「这个 ack 是不是这一次审批的回执」,归编排层)是两件事:
@@ -551,13 +562,35 @@ export function readToolApprovalRespondAck(v) {
     //       而 `rulePersisted` 那一位同时在说没存上。
     //    两形都**只丢这两位**(不牵连整份 ack):`rememberApplied`/`updatedInputForwarded` 是更重的
     //    安全告知位,不该被一条规则回显的坏形连坐掉。
-    if (out.persistedRule !== undefined && out.persistedRules !== undefined) {
+    // 🔴 归属锚随它所归属的那份清单一起判:单数回显是**编辑臂**的产物,批臂的归属锚与它同场 =
+    //    这份回执在说两次不同的授权(与下面①同一条理由,只是多一位要一起丢)。
+    if (out.persistedRule !== undefined && (out.persistedRules !== undefined || out.persistedRuleAnchors !== undefined)) {
         delete out.persistedRule;
         delete out.persistedRules;
+        delete out.persistedRuleAnchors;
     }
-    else if ((out.persistedRule !== undefined || out.persistedRules !== undefined) && out.rulePersisted !== true) {
+    else if ((out.persistedRule !== undefined || out.persistedRules !== undefined || out.persistedRuleAnchors !== undefined) &&
+        out.rulePersisted !== true) {
         delete out.persistedRule;
         delete out.persistedRules;
+        delete out.persistedRuleAnchors;
+    }
+    // 🔴 **跨位自洽**(P-39,0.44.0):锚是 `persistedRules` 的逐成员分解 —— server 两处铸点都在同一个
+    //    `persisted` 结果上取 `rules` 与 `members`,所以条数恒等。不等 = 这份回执对「到底存了什么」
+    //    自相矛盾。**只丢锚、保留 `persistedRules`**:additive 位到货绝不回头削弱既有位的现行为
+    //    (老 server 上本来就没有锚,那条路仍按基数门走)。
+    // 🔴 **逐位置同文本**(异源对抗复审二轮 [high] 采纳):server 侧两位是**同一个数组**的两种投影 ——
+    //    dist `rules-consent.js` 逐字 `{ rules: anchored.map(a => a.rule), members: anchored }`,且两者
+    //    同按 `memberIndex` 排序 ⇒ `persistedRules[i] === anchors[i].rule` 是**铸造期保证**,不等只可能
+    //    来自被改过/串了台的回执。
+    //    ⚠️ 与本文件「**不复判文本**」那条纪律不冲突:那条禁的是拿回执文本去比 **offer 上的**文本
+    //    (落盘的是规范化后的字节,与 offer 按设计可以不同 —— 比它就是装第二个判官);这里比的是
+    //    **同一份回执内部**两个位互相说的话,属「这个对象自己说不通」的形的范畴。
+    if (out.persistedRuleAnchors !== undefined &&
+        (out.persistedRules === undefined ||
+            out.persistedRules.length !== out.persistedRuleAnchors.length ||
+            out.persistedRuleAnchors.some((a, i) => a.rule !== out.persistedRules?.[i]))) {
+        delete out.persistedRuleAnchors;
     }
     return out;
 }
@@ -565,6 +598,61 @@ export function readToolApprovalRespondAck(v) {
 function isNonEmptyStringArray(v) {
     return Array.isArray(v) && v.length > 0 && v.every(x => typeof x === 'string' && x !== '');
 }
+/**
+ * {@link ToolApprovalRespondAckView.persistedRuleAnchors} 的**整只**判形(P-39,server ≥7.48.0)。
+ *
+ * 逐条要求三键齐、`offerIndex`/`memberIndex` 是**非负安全整数**、`rule` 非空串;再加两条**同只回执内
+ * 自洽**:
+ *  · `offerIndex` **整表同值** —— server 的 map 闭包捕获的是同一个 `persistRule.batchOfferIndex`
+ *    (dist 直证),混合值的表不可能由合规 server 铸出;
+ *  · `memberIndex` **不重复** —— 两条锚认领同一个成员,那份归属表就不是它自称的逐成员分解。
+ * 任一条不满足 ⇒ **整只降缺席**(不逐条丢):半份归属表会让相关性门拿着残表放行,比没有锚更坏。
+ *
+ * 🔴 下标**绝不折算**(不 `|0`、不 `Math.trunc`):一个被折过的下标指向的是**另一条** offer /
+ *    另一个成员,那正是本位要证伪的东西。
+ */
+function readPersistedRuleAnchors(v) {
+    if (!Array.isArray(v) || v.length === 0)
+        return undefined;
+    const out = [];
+    const seenMembers = new Set();
+    let firstOfferIndex;
+    for (const raw of v) {
+        if (raw === null || typeof raw !== 'object')
+            return undefined;
+        const o = raw;
+        const { offerIndex, memberIndex, rule } = o;
+        if (!isNonNegativeSafeInt(offerIndex) || !isNonNegativeSafeInt(memberIndex))
+            return undefined;
+        if (typeof rule !== 'string' || rule === '')
+            return undefined;
+        if (firstOfferIndex === undefined)
+            firstOfferIndex = offerIndex;
+        else if (offerIndex !== firstOfferIndex)
+            return undefined;
+        if (seenMembers.has(memberIndex))
+            return undefined;
+        seenMembers.add(memberIndex);
+        out.push({ offerIndex, memberIndex, rule });
+    }
+    // 🔴 **座位必须恰好铺满 `0..n-1`**(异源对抗复审二轮 [high] 采纳)。这不是本包发明的严格,是
+    //    **server 自己的不变量**(dist `rules-consent.js` 的 `anchorBatchMembers`,逐字):
+    //      · `anchored.length !== displayed.rules.length || distinctSeats !== anchored.length`
+    //        ⇒ **整个不发 members**(锚要么是与人看见的那只 offer **一一对应的满覆盖**,要么缺席);
+    //      · 发之前还 `anchored.sort((a,b) => a.memberIndex - b.memberIndex)`。
+    //    ⇒ 合规锚表的 memberIndex 集合恒 = `{0..n-1}`。越界座位是 server 铸不出的形。
+    //    ⚠️ 只校**集合**不校**顺序**:排序是 server 今天的实现细节,而集合是它成文的不变量
+    //    ([verdict-must-accept-stronger-form]:别把一个合法的更强形判成回归)。
+    //    ⚠️ 「7.48 引擎 + 锚缺席」是**合法形**(上面两条 warn 分支就是它)⇒ 缺席绝不可读作可疑。
+    for (const seat of seenMembers)
+        if (seat >= out.length)
+            return undefined;
+    return out;
+}
+/** 非负安全整数(下标位共用;`Number.isSafeInteger` 已排除 NaN/Infinity/小数)。 */
+function isNonNegativeSafeInt(v) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
+}
 /**
  * 从 respond 抛出来的东西上读 {@link ToolApprovalRespondRefusal}。**永不抛、永不造**。
  *
@@ -900,6 +988,12 @@ export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamA
         args: args,
         // A-028.3:live 帧腿的卡身份键经 gateIdentity 唯一铸口(帧上无 gatedCallId,以 approvalId 铸)。
         callKey: liveFrameCallKey(frame.approvalId),
+        // #348(0.44.0):帧上的 core tool-call id 透传到卡口 —— 卡与 transcript 里 `tool_use` 块之间唯一的
+        // wire 事实锚。**非空串才 stamp**(空串是坏值不是「没有调用」,同文件既有窄读同族纪律);
+        // 缺席 ⇒ 键缺席,宿主按缺席降级(绝不拿 approvalId 冒充,那正是 #348 的病形)。
+        ...(typeof frame.toolCallId === 'string' && frame.toolCallId !== ''
+            ? { toolCallId: frame.toolCallId }
+            : {}),
         ...(signal ? { signal } : {}),
         ...(isFromSubagent(frame) ? { workerBadge: subagentBadgeFor(frame) } : {}),
         ...(wireNote !== undefined ? { wireNote } : {}),
@@ -1123,7 +1217,8 @@ export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamA
         // 🔴 **只丢这两位、不牵连整份 ack**(与上面那道 id/decision 相关性门刻意不同姿势):那道门管的是
         //    「整份回执根本不是我的」,这道门管的是「回执是我的,但其中一格与我发出的臂矛盾」——
         //    整份丢会把 `rememberApplied`/`updatedInputForwarded` 这两个更重的安全告知位一起连坐掉。
-        if (ack !== undefined && (ack.persistedRule !== undefined || ack.persistedRules !== undefined)) {
+        if (ack !== undefined &&
+            (ack.persistedRule !== undefined || ack.persistedRules !== undefined || ack.persistedRuleAnchors !== undefined)) {
             // 🔴 单数回显**只属编辑臂**(异源对抗复审二轮 [medium] 采纳,server `editedArmEcho` 逐字:
             //    `persistRule.kind !== 'text' || !persistRule.edited || …` ⇒ 返 `{}`)——候选臂成功时
             //    server **不铸**这一位,所以候选臂上收到它同样是「一次没发生过的授权」。
@@ -1135,27 +1230,64 @@ export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamA
             //    ⚠️ 只做**基数**相关性,**不复判文本**:规范化是引擎的活(`Bash(adb *)` → `Bash(adb:*)`),
             //    在这里比对文本就是装第二个判官。
             const expectedBatchCount = batchArmTarget?.rules.length;
+            // 🔴 **P-39 归属锚门**(server ≥7.48.0,0.44.0):锚在场时,相关性从「基数」升级到「身份」——
+            //    `offerIndex` 必须等于**这一次真发出去**的 `persistRuleBatchOfferIndex`,`memberIndex` 必须
+            //    落在所选 offer 的成员表范围内。这正是 P-39 登记里基数门**抓不到**的那一形:
+            //    「条数对,但这份回执说的是另一只 offer 的规则」。
+            //    ⚠️ 锚**缺席**(≤7.47 引擎)⇒ 本门整条让位,回落既有基数门 —— additive 位不许把老引擎判红。
+            // 🔴 **absent / valid / invalid 必须是三态,不是两态**(异源对抗复审 [high] 采纳,本批):
+            //    读器把「在场但坏形」也降成 `undefined`,若这里只看 `ack.persistedRuleAnchors === undefined`
+            //    就把它与「老引擎真没这个键」混成一格 ⇒ 让位基数门。于是**「另一只 offer + 规则条数恰好相同
+            //    + 故意发一份坏锚」这条回执可以精确绕过本门刚加的身份校验** —— 攻击面正是本门要封的那一形。
+            //    ⇒ 判据取**wire 上键在不在**(raw),不取窄化产物在不在:
+            //      · 键真缺席      ⇒ 让位基数门(老引擎兼容);
+            //      · 键在场 ∧ 合形 ⇒ 走身份门;
+            //      · 键在场 ∧ 坏形 ⇒ **不许让位**,连同 `persistedRules` 一起丢(一份自称带归属却给不出
+            //        合法归属的回执,不配驱动任何「已存了什么」的强断言)。
+            //    (结构视图读:SDK 的 respond 返回型上没有这个 additive 键,与同文件 `pending.ruleOffers`
+            //     / `riskDescriptor.probeCause` 同款姿势 —— 不引入新的宽 cast。)
+            // 🔴 判据是**键在不在**(`hasOwnProperty`),**不是**「值是不是 `undefined`」(异源对抗复审
+            //    二轮 [high] 采纳):注入面是**宿主给的 JS 函数**,不是 `JSON.parse` 的产物 —— 一个自铸
+            //    `{persistedRuleAnchors: undefined}` 的回执在 JS 里**键是在场的**,用值判会把它读成
+            //    「老引擎真没这个键」而让位基数门,恰好绕过身份门。同仓 `engineCapState` 用 `in` 而不用
+            //    `!== undefined` 的成文理由与此同源(那处头注:「本表也接宿主注入的对象」)。
+            const anchorKeyOnWire = typeof raw === 'object' &&
+                raw !== null &&
+                Object.prototype.hasOwnProperty.call(raw, 'persistedRuleAnchors');
+            const anchors = ack.persistedRuleAnchors;
+            const anchorsOk = anchors !== undefined
+                ? persistRuleBatchOfferIndex !== undefined &&
+                    expectedBatchCount !== undefined &&
+                    anchors.every(a => a.offerIndex === persistRuleBatchOfferIndex && a.memberIndex < expectedBatchCount)
+                : !anchorKeyOnWire;
             const batchEchoOk = ack.persistedRules !== undefined &&
                 expectedBatchCount !== undefined &&
-                ack.persistedRules.length === expectedBatchCount;
+                ack.persistedRules.length === expectedBatchCount &&
+                anchorsOk;
             const strayEchoes = [];
             if (ack.persistedRule !== undefined && !sentEditedArm)
                 strayEchoes.push('persistedRule');
             if (ack.persistedRules !== undefined && !batchEchoOk)
                 strayEchoes.push('persistedRules');
+            if (anchors !== undefined && !(anchorsOk && batchEchoOk))
+                strayEchoes.push('persistedRuleAnchors');
             if (strayEchoes.length > 0) {
                 hostLog('error', `liveToolApprovalWire: DISCARDING persisted-rule echo(es) [${strayEchoes.join(', ')}] on the ack for ` +
                     `${frame.approvalId} — they do not correlate with the persistence arm actually sent ` +
                     `(editedArm=${String(sentEditedArm)} batchArmMembers=${String(expectedBatchCount ?? 'none')} ` +
-                    `echoedRules=${String(ack.persistedRules?.length ?? 'none')}); never telling the user a rule ` +
+                    `sentOfferIndex=${String(persistRuleBatchOfferIndex ?? 'none')} ` +
+                    `echoedRules=${String(ack.persistedRules?.length ?? 'none')} ` +
+                    `echoedAnchorOffer=${String(anchors?.[0]?.offerIndex ?? 'none')}); never telling the user a rule ` +
                     'was stored off a receipt that does not line up with what this client actually sent');
-                const { persistedRule: _pr, persistedRules: _prs, ...rest } = ack;
+                const { persistedRule: _pr, persistedRules: _prs, persistedRuleAnchors: _pra, ...rest } = ack;
                 void _pr;
                 void _prs;
+                void _pra;
                 ack = {
                     ...rest,
                     ...(ack.persistedRule !== undefined && sentEditedArm ? { persistedRule: ack.persistedRule } : {}),
                     ...(ack.persistedRules !== undefined && batchEchoOk ? { persistedRules: ack.persistedRules } : {}),
+                    ...(anchors !== undefined && anchorsOk && batchEchoOk ? { persistedRuleAnchors: anchors } : {}),
                 };
             }
         }

package/dist/hooksWireCaps.d.ts

@@ -1,3 +1,4 @@
+import { type HookFailureNotice } from './notifications.js';
 import type { WireHooksConfig } from './finalVerifyWire.js';
 export { GOAL_STOP_HOOK_WIRE_ENV, CC_STOP_SEMANTICS_MIN_SERVER, ccStopSemanticsFromVersion, engineCcStopSemantics, isGoalStopHookWireArmed, setWireSessionStopHook, getWireSessionStopHook, getWireSessionStopHookCcSemantics, buildGoalStopHookPrompt, } from './goalStopHook.js';
 export type { WireHooksConfig };
@@ -8,3 +9,39 @@ export type { WireHooksConfig };
 export declare function hooksForWire(): WireHooksConfig | undefined;
 /** 测试钩:清 `/goal` 锁存(壳里靠进程边界隔离;包内同进程多组断言必须能清)。 */
 export declare function __resetHooksWireCapsForTests(): void;
+/**
+ * 这台引擎会不会发 `hook_non_blocking_failure` 观测帧(hook 自己坏了的那一族)。
+ *
+ * 🔴 **能力位嵌在 `fleet` 对象里**,不是顶层键 —— server `dist/http/routes/capabilities.js:52`:
+ * `fleet: { stream, sessionScope, observe, resume, bgNotifyFailClosed, steerPriority,
+ *  hookFailureNotice: true }`。拿平铺口 `engineCapTrue(base,'hookFailureNotice')` 去读**恒 false**
+ * (白读),而白读的后果不是报错、是安静地把新车道判成没有。
+ * 🔴 未判/父键缺席/父键为 `false`(整族不供)/子键缺席 ⇒ **false** = fail-closed。
+ *
+ * 🔴 **它是 affordance 判据,不是上屏闸**:一帧真到货的故障通知**不该**被本位闸掉 —— 帧在手里
+ * 就是最强证据,而能力位在探测落地前恒 false,拿它闸会把早到的真实故障静默掉(方向与 #281 相反)。
+ * 本位的正当用途 = 「要不要在设置/状态面声称有这项监测」。判定口见 `notifications.ts`
+ * 的 `classifyHookFailureFrame`(那里刻意不读本位)。
+ */
+export declare function fleetHookFailureNoticeCapable(baseUrl: string | undefined): boolean;
+/** footer 横幅文案前缀(测试锁字面;与 `HOOK_NOTICE_WARN_PREFIX` 同族风格)。 */
+export declare const HOOK_FAILURE_WARN_PREFIX = "Hook error";
+/**
+ * 「这个 hook 自己坏了」的**单行**横幅文案(hook 名 + 故障形/退出码 + stderr 摘要)。
+ *
+ * 🔴 **为什么在本文件而不是 `notifications.ts`**:文案口要过展示消毒单源 `collapseLabel`
+ * (在 `fleetTaskDesc.ts`),而 `notifications.ts` 在 **A 层闭包**内(portability 门只降棘轮)——
+ * 从那里 import 会让闭包涨一格,手抄第二份字符集又是 `fleetTaskDesc` 顶注点名禁止的形。
+ * ⇒ 判定留 `notifications.ts`(它只交出**原文**),展示归本层。
+ *
+ * 🔴 **绝不编造退出码**:`timeout` / `spawn_failed` 上没有 `exitCode`,那两形只报故障词
+ * (写 `exit 0` 会让人去查一个根本不存在的退出码)。
+ * 🔴 **两位都是 UNTRUSTED-for-display**(异源对抗复审二轮 [medium] 采纳):`hookName` 的一手源是
+ * **用户 settings 里自己写的** `statusMessage` / command / url / prompt;`stderr` 是**坏 hook 自己吐的
+ * 流**。server 只做脱敏 + 截断、**不做控制符消毒**(与 `workerBadge.name` / fleet 行标签同一条分工)。
+ * 不消毒的后果不是难看:一个带 `\n` / ESC / RLO 的 hook 名能把「**哪个**安全 hook 失效了」这条
+ * **唯一**告警重排、截断或整段藏掉,而这条横幅存在的全部理由就是让那件事看得见。
+ * 🔴 **单行**:渲染面是 `wrap="truncate"` 的一行;`collapseLabel` 同时做 `\s+` 折平与控制符/双向符/
+ * 孤代理项可见化转义,两件事一把做完(不在这里手抄第二份字符集)。
+ */
+export declare function hookFailureNoticeText(n: HookFailureNotice): string;

package/dist/hooksWireCaps.js

@@ -62,7 +62,10 @@
  * and never inherit engine secrets; user-defined variables must ride `settings.env` — nothing for the
  * shell to scrub here (commands are the user's own text).
  */
+import { engineCapNestedTrue } from './engineCapsCache.js';
+import { collapseLabel } from './fleetTaskDesc.js';
 import { hostLog, hostSettings } from './host.js';
+import { MAX_HOOK_NOTICE_TEXT_CHARS } from './notifications.js';
 // REF-CC-156(split):`/goal` 版本判档 + prompt 组装 + 模块状态搬到 goalStopHook.ts。
 // `goalStopHookMatcher`/`__resetGoalStopHookForTests` 是两文件间的私有接口(不 re-export);
 // 其余七个名字原样 re-export,外部 import 路径(index 的 `export *`)零改动。
@@ -164,3 +167,49 @@ export function hooksForWire() {
 export function __resetHooksWireCapsForTests() {
     __resetGoalStopHookForTests();
 }
+// ── hook 观测面的能力位(#281 / server ≥7.48.0)──────────────────────────────────────────────
+/**
+ * 这台引擎会不会发 `hook_non_blocking_failure` 观测帧(hook 自己坏了的那一族)。
+ *
+ * 🔴 **能力位嵌在 `fleet` 对象里**,不是顶层键 —— server `dist/http/routes/capabilities.js:52`:
+ * `fleet: { stream, sessionScope, observe, resume, bgNotifyFailClosed, steerPriority,
+ *  hookFailureNotice: true }`。拿平铺口 `engineCapTrue(base,'hookFailureNotice')` 去读**恒 false**
+ * (白读),而白读的后果不是报错、是安静地把新车道判成没有。
+ * 🔴 未判/父键缺席/父键为 `false`(整族不供)/子键缺席 ⇒ **false** = fail-closed。
+ *
+ * 🔴 **它是 affordance 判据,不是上屏闸**:一帧真到货的故障通知**不该**被本位闸掉 —— 帧在手里
+ * 就是最强证据,而能力位在探测落地前恒 false,拿它闸会把早到的真实故障静默掉(方向与 #281 相反)。
+ * 本位的正当用途 = 「要不要在设置/状态面声称有这项监测」。判定口见 `notifications.ts`
+ * 的 `classifyHookFailureFrame`(那里刻意不读本位)。
+ */
+export function fleetHookFailureNoticeCapable(baseUrl) {
+    return engineCapNestedTrue(baseUrl, 'fleet', 'hookFailureNotice');
+}
+/** footer 横幅文案前缀(测试锁字面;与 `HOOK_NOTICE_WARN_PREFIX` 同族风格)。 */
+export const HOOK_FAILURE_WARN_PREFIX = 'Hook error';
+/**
+ * 「这个 hook 自己坏了」的**单行**横幅文案(hook 名 + 故障形/退出码 + stderr 摘要)。
+ *
+ * 🔴 **为什么在本文件而不是 `notifications.ts`**:文案口要过展示消毒单源 `collapseLabel`
+ * (在 `fleetTaskDesc.ts`),而 `notifications.ts` 在 **A 层闭包**内(portability 门只降棘轮)——
+ * 从那里 import 会让闭包涨一格,手抄第二份字符集又是 `fleetTaskDesc` 顶注点名禁止的形。
+ * ⇒ 判定留 `notifications.ts`(它只交出**原文**),展示归本层。
+ *
+ * 🔴 **绝不编造退出码**:`timeout` / `spawn_failed` 上没有 `exitCode`,那两形只报故障词
+ * (写 `exit 0` 会让人去查一个根本不存在的退出码)。
+ * 🔴 **两位都是 UNTRUSTED-for-display**(异源对抗复审二轮 [medium] 采纳):`hookName` 的一手源是
+ * **用户 settings 里自己写的** `statusMessage` / command / url / prompt;`stderr` 是**坏 hook 自己吐的
+ * 流**。server 只做脱敏 + 截断、**不做控制符消毒**(与 `workerBadge.name` / fleet 行标签同一条分工)。
+ * 不消毒的后果不是难看:一个带 `\n` / ESC / RLO 的 hook 名能把「**哪个**安全 hook 失效了」这条
+ * **唯一**告警重排、截断或整段藏掉,而这条横幅存在的全部理由就是让那件事看得见。
+ * 🔴 **单行**:渲染面是 `wrap="truncate"` 的一行;`collapseLabel` 同时做 `\s+` 折平与控制符/双向符/
+ * 孤代理项可见化转义,两件事一把做完(不在这里手抄第二份字符集)。
+ */
+export function hookFailureNoticeText(n) {
+    const code = n.exitCode !== undefined ? `exit ${n.exitCode}` : n.reason;
+    const name = collapseLabel(n.hookName);
+    const tail = n.stderr !== undefined ? `: ${collapseLabel(n.stderr)}` : '';
+    const line = `${HOOK_FAILURE_WARN_PREFIX}: ${name} (${code})${tail}`;
+    // 有界兜底(与铸点同上限;消毒在前、截断在后 —— 反过来会把一个转义序列切成半截)。
+    return line.length <= MAX_HOOK_NOTICE_TEXT_CHARS ? line : line.slice(0, MAX_HOOK_NOTICE_TEXT_CHARS);
+}

package/dist/notifications.d.ts

@@ -291,7 +291,13 @@ export declare function splitApiErrorSupplement(text: string): {
     main: string;
     supplement?: string;
 };
-/** SSE 平铺 wire 形(server 1.280.0 http/server.js:6347-6355 直证;ownerScope/ownerSessionId 上 wire 前剥掉)。 */
+/** SSE 平铺 wire 形(server 1.280.0 http/server.js:6347-6355 直证;ownerScope/ownerSessionId 上 wire 前剥掉)。
+ *  🔴 平铺形在 7.48.0 仍逐字成立:`dist/http/routes/fleet.js:146` =
+ *     `send("hook_notice", { type:"hook_notice", ...hookNoticeWire(hn), ts })`(spread,不是 `notice:` 嵌套)。
+ *  🔴 本形是**第一族**(`hook_decision_unavailable`)的平铺视图,**刻意不为第二族加宽**:
+ *     两族只共用 `type`/`kind`/`event`/`ts`,而 `reason` 的**值域各自闭集**(同名不同义)。
+ *     第二族的专有键走本文件内部视图 `HookFailureWireView`(不出包边界)—— 把两族的键混进同一个
+ *     导出形,等于对外承诺一个「哪一族都不完全对」的形,消费端读哪一位都得再猜一次 kind。 */
 export interface HookNoticeWire {
     type?: unknown;
     kind?: unknown;
@@ -338,4 +344,59 @@ export declare function isHookNoticeFrame(frame: unknown): boolean;
 export declare function hookNoticeLastCheckText(n: GoalHookNotice): string;
 /** footer 通知条文案前缀(测试锁字面;宿主拼 ` (${reason})`)。 */
 export declare const HOOK_NOTICE_WARN_PREFIX = "Goal check: couldn't evaluate this turn \u2014 proceeded";
+/** 机器可判的故障形(dist 逐字闭集)。 */
+export type HookFailureReason = 'exit_nonzero' | 'timeout' | 'spawn_failed' | 'bad_json';
+/** 条目类型 —— 没有它,`hookName` 是命令还是 URL 还是提示词全靠猜(dist 逐字闭集)。 */
+export type HookEntryType = 'command' | 'http' | 'prompt' | 'agent';
+/** 宿主写 store / 渲横幅的形(与 {@link GoalHookNotice} 平级,但**不是**同一件事)。 */
+export interface HookFailureNotice {
+    /** 哪个 hook 事件(`PreToolUse` / `Stop` / …)。开集:server 不闭这一位。 */
+    event: string;
+    reason: HookFailureReason;
+    /** hook 身份(server 侧 `statusMessage` 优先,否则 command / url / prompt),已脱敏 + 有界。 */
+    hookName: string;
+    entryType: HookEntryType;
+    /** 🔴 **超时 / spawn 失败没有退出码 ⇒ 缺席**(绝不铸 0 那种看着合法的假读数)。 */
+    exitCode?: number;
+    /** 工具事件才有(PreToolUse/PostToolUse/PostToolUseFailure);非工具事件缺席。 */
+    toolName?: string;
+    /** hook 的 stderr 摘要(server 已脱敏 + 截断;本包边界再兜底一次)。空 ⇒ 缺席。 */
+    stderr?: string;
+    detail?: string;
+    at: number;
+}
+/**
+ * 观测帧自由文本上限 —— 与 server `MAX_HOOK_NOTICE_TEXT_CHARS`(`fleet/fleet-bus.d.ts`)同值。
+ * 🔴 server 已截过一遍(那一遍拿得到原文,是**承重**的);本包这一遍是**边界兜底**,挡住忘了截断的
+ *    未来生产者把一条无界流灌进单行横幅。幂等:输出恒 ≤ 上限。
+ */
+export declare const MAX_HOOK_NOTICE_TEXT_CHARS = 512;
+/** 第二族的判定结果。drop 原因供宿主打 SEMA_DEBUG 档。 */
+export type HookFailureVerdict = {
+    ok: true;
+    failure: HookFailureNotice;
+} | {
+    ok: false;
+    drop: 'not-hook-notice' | 'unknown-kind' | 'not-session-scoped' | 'unknown-reason' | 'unknown-entry-type' | 'no-hook-name';
+    kind?: string;
+};
+/**
+ * `hook_non_blocking_failure` 帧的判定本体(#281 的客户端半场)。
+ *
+ * 🔴 **与 {@link classifyHookNoticeFrame} 是两个口,不是一个口的两条臂**:两族的载荷形不同
+ * (那族出 {@link GoalHookNotice},本族出 {@link HookFailureNotice}),把它们塞进同一个返回联合会
+ * **破坏既有消费端**(现在 `v.ok` 之后直接读 `v.notice` 的写法要全部改窄化)。分口 ⇒ 姊妹口的行为
+ * **逐字节不变**(它对本族仍报 `unknown-kind`,常驻套对这一格有钉),宿主按 `kind` 分派一次即可。
+ *
+ * 🔴 **闭集位一律「不认就丢」,绝不折成某一档**:与姊妹族「表外 reason 归一到 `skipped`」刻意不同 ——
+ * 那一族的 `skipped` 有真兜底语义(「跳过了」),本族**没有**「兜底故障形」这种东西,把一个没见过的
+ * 词折成 `exit_nonzero` 就是替引擎编一个它没说过的故障。
+ *
+ * 🔴 `hookName` 缺席即丢:一条「某个 hook 坏了、但不知道是哪个」的横幅,用户拿它什么都做不了,
+ * 只会制造焦虑 —— 而 server 侧这一位是**必填**,缺席意味着这不是一帧合规的本族帧。
+ */
+export declare function classifyHookFailureFrame(frame: unknown, opts: {
+    sessionScoped: boolean;
+    now?: number;
+}): HookFailureVerdict;
 export {};

package/dist/notifications.js

@@ -1090,3 +1090,71 @@ export function hookNoticeLastCheckText(n) {
 }
 /** footer 通知条文案前缀(测试锁字面;宿主拼 ` (${reason})`)。 */
 export const HOOK_NOTICE_WARN_PREFIX = 'Goal check: couldn\'t evaluate this turn — proceeded';
+const KNOWN_FAILURE_REASONS = new Set(['exit_nonzero', 'timeout', 'spawn_failed', 'bad_json']);
+const KNOWN_ENTRY_TYPES = new Set(['command', 'http', 'prompt', 'agent']);
+/**
+ * 观测帧自由文本上限 —— 与 server `MAX_HOOK_NOTICE_TEXT_CHARS`(`fleet/fleet-bus.d.ts`)同值。
+ * 🔴 server 已截过一遍(那一遍拿得到原文,是**承重**的);本包这一遍是**边界兜底**,挡住忘了截断的
+ *    未来生产者把一条无界流灌进单行横幅。幂等:输出恒 ≤ 上限。
+ */
+export const MAX_HOOK_NOTICE_TEXT_CHARS = 512;
+function boundedNoticeText(s) {
+    return s.length <= MAX_HOOK_NOTICE_TEXT_CHARS ? s : s.slice(0, MAX_HOOK_NOTICE_TEXT_CHARS);
+}
+/**
+ * `hook_non_blocking_failure` 帧的判定本体(#281 的客户端半场)。
+ *
+ * 🔴 **与 {@link classifyHookNoticeFrame} 是两个口,不是一个口的两条臂**:两族的载荷形不同
+ * (那族出 {@link GoalHookNotice},本族出 {@link HookFailureNotice}),把它们塞进同一个返回联合会
+ * **破坏既有消费端**(现在 `v.ok` 之后直接读 `v.notice` 的写法要全部改窄化)。分口 ⇒ 姊妹口的行为
+ * **逐字节不变**(它对本族仍报 `unknown-kind`,常驻套对这一格有钉),宿主按 `kind` 分派一次即可。
+ *
+ * 🔴 **闭集位一律「不认就丢」,绝不折成某一档**:与姊妹族「表外 reason 归一到 `skipped`」刻意不同 ——
+ * 那一族的 `skipped` 有真兜底语义(「跳过了」),本族**没有**「兜底故障形」这种东西,把一个没见过的
+ * 词折成 `exit_nonzero` 就是替引擎编一个它没说过的故障。
+ *
+ * 🔴 `hookName` 缺席即丢:一条「某个 hook 坏了、但不知道是哪个」的横幅,用户拿它什么都做不了,
+ * 只会制造焦虑 —— 而 server 侧这一位是**必填**,缺席意味着这不是一帧合规的本族帧。
+ */
+export function classifyHookFailureFrame(frame, opts) {
+    const f = frame;
+    if (f?.type !== 'hook_notice')
+        return { ok: false, drop: 'not-hook-notice' };
+    if (f.kind !== 'hook_non_blocking_failure')
+        return { ok: false, drop: 'unknown-kind', kind: String(f.kind) };
+    // 🔴 归属镜像(与姊妹族同一条 fail-CLOSED):server 只对 scoped 连接过滤。
+    if (!opts.sessionScoped)
+        return { ok: false, drop: 'not-session-scoped' };
+    if (typeof f.reason !== 'string' || !KNOWN_FAILURE_REASONS.has(f.reason))
+        return { ok: false, drop: 'unknown-reason' };
+    if (typeof f.entryType !== 'string' || !KNOWN_ENTRY_TYPES.has(f.entryType))
+        return { ok: false, drop: 'unknown-entry-type' };
+    if (typeof f.hookName !== 'string' || f.hookName === '')
+        return { ok: false, drop: 'no-hook-name' };
+    return {
+        ok: true,
+        failure: {
+            event: typeof f.event === 'string' ? f.event : '',
+            reason: f.reason,
+            hookName: boundedNoticeText(f.hookName),
+            entryType: f.entryType,
+            // 🔴 非整数/非数一律降缺席 —— 退出码是给人照着查的,一个 1.5 或 'x' 比没有更坏。
+            ...(typeof f.exitCode === 'number' && Number.isSafeInteger(f.exitCode) ? { exitCode: f.exitCode } : {}),
+            ...(typeof f.toolName === 'string' && f.toolName ? { toolName: boundedNoticeText(f.toolName) } : {}),
+            ...(typeof f.stderr === 'string' && f.stderr ? { stderr: boundedNoticeText(f.stderr) } : {}),
+            ...(typeof f.detail === 'string' && f.detail ? { detail: boundedNoticeText(f.detail) } : {}),
+            at: typeof f.ts === 'number' ? f.ts : (opts.now ?? Date.now()),
+        },
+    };
+}
+// 🔴 本族的**横幅文案口** `hookFailureNoticeText` / `HOOK_FAILURE_WARN_PREFIX` 与能力位读口一样,
+//    刻意**不在本文件**,而在 `hooksWireCaps.ts` —— 理由同 `fleetHookFailureNoticeCapable`:本文件在
+//    **A 层闭包**内(portability 门 ①b,只降棘轮),而文案口必须过展示消毒单源 `collapseLabel`
+//    (在 `fleetTaskDesc.ts`),把那个文件拉进闭包会让棘轮当场涨一格;在本文件手抄第二份字符集
+//    则正是 `fleetTaskDesc` 顶注点名禁止的形(「改一处必须改另一处」)。
+//    ⇒ **判定留本文件、展示归那一层**,与包内既有分工一致(本文件只交出**原文** `hookName`/`stderr`,
+//    UNTRUSTED-for-display 的消毒责任在渲染侧)。
+// 🔴 本族的**能力位读口** `fleetHookFailureNoticeCapable` 刻意**不放在本文件**,而在
+//    `hooksWireCaps.ts` —— 本文件在 **A 层闭包**内(portability 门 ①b,只降棘轮),而能力位要读
+//    `engineCapsCache`,把那个文件拉进闭包会让棘轮当场涨一格。能力位本就属 `*WireCaps` 那一层
+//    (与 `hooksForWire` 同域),放那里是归位不是绕道。

package/dist/seam.d.ts

@@ -389,7 +389,47 @@ export type ChromeEvent = {
  * `actor.hostAsserted` 是消费端唯一能判「这个署名可信吗」的位:渲署名而不渲这个位 = 把一个
  * 未经验证的名字渲成可信的(core 自己的 `[from …]` 渲染就是靠它决定加不加 `(unverified)`)。
  */
- | HumanInputChromeEvent | EngineNoticeChromeEvent;
+ | HumanInputChromeEvent | EngineNoticeChromeEvent | TextSegmentEndChromeEvent;
+/**
+ * {@link ChromeEvent} 的 `text_segment_end` 臂(#323 / core #447,core ≥5.63 / server ≥7.50)——
+ * 「**assistant 的这一段散文写完了**」,由引擎明说,不是由本包猜。
+ *
+ * ── 它替代的是什么 ──────────────────────────────────────────────────────────────────────────
+ * 本包的 `adapt/textStream.ts` 至今用**启发式**猜段边界:静默 ≥1.5s + 段尾是句末/段末字符 +
+ * 每段至多一刀(`takeAnswerSegmentOnIdle`,#323 症状① 的止血件)。那是猜 —— 慢模型的一次卡顿会
+ * 被当成段结束,一轮回复被切成 N 条 assistant 消息。本臂是**引擎报的真边界**:模型关掉了那个
+ * text content block。CC 对位:CC 在 provider 的 `content_block_stop` 上把每个写完的块当作一条
+ * 独立 assistant 消息 —— 块结束**就是**分段信号,本臂把同一个边界搬到了 wire 上。
+ *
+ * 🔴 **宿主消费义务**(全部可选、fail-soft;本臂存在的第一价值 = 边界信号不再落 `unknown_arm`):
+ *  ① **它是信号,不是内容**。`content` = 那一段的**权威全文**,而这些字节**已经**以 `stream_delta`
+ *     活体增量流过、并且会由 transcript 平面的 assistant 消息给出 committed 形。
+ *     🔴 拿 `content` 再渲一行 = **同一段文字上屏两遍**。它的正当用途是**对账**(用引擎的权威全文
+ *     校/换掉自己缝合出来的那一段)与**定界**(现在可以提交这一段了)。
+ *  ② **诚实缺席,不可反推**(core 臂注逐字):只有会报块结束的 Brain 才发它 —— 三个一方 brain 都发,
+ *     自定义 brain 可能整条流一帧都没有。⇒ 缺席 = 「**没报**」,**永远不等于**「这一段没结束」。
+ *     消费方按**每条流**判「这条流带不带边界帧」,只在整条流一帧都没有时才回落自己的启发式;
+ *     按**单帧**缺席就回落 = 把「这一拍还没到边界」误当「引擎不支持」。
+ *  ③ **空段无帧**:引擎只为**有字节**的段发帧(空 text block 静默关闭)—— 所以宿主永远不会收到
+ *     空 `content`,收到了也不该提交一个幻影段(本包投影层已按 `empty_payload` 拦下)。
+ *  ④ 🔴 **子流让位**:带 `parentToolCallId` 的段边界属于子代/编排流,拿它去提交 leader 的段就是
+ *     跨 lane 状态破坏(与 `stream_delta` 的 thinking 半场、`retry_status` 同一条纪律)。所以本臂
+ *     在库内**已经断闸** —— 子流的段边界**根本不产出本 chrome 事件**,本臂因此没有
+ *     `parentToolCallId` 位(有位才是可疑的:那意味着 leader 面上会出现别人的边界)。
+ *     要消费子流边界的宿主读 SDKMessage 平面的 `text_end` 内部臂,那一层原样带 `parentToolCallId`。
+ *
+ * ⚠️ **UNTRUSTED、仅展示**:`content` 是模型输出,契约与活体增量同 —— 渲染,绝不回喂模型。
+ * 📋 如实留白:本包的 `takeAnswerSegmentOnIdle` 启发式**本批不撤**(撤它要按 ② 做一条 per-stream
+ *    的状态化策略,属行为面改动,按宪法三问单独走)。本批只把边界送到宿主手上。
+ */
+export interface TextSegmentEndChromeEvent {
+    kind: 'text_segment_end';
+    laneProof: LaneProof;
+    /** 该段的**权威全文**(与那一段活体增量的拼接逐字节相等)。🔴 对账/定界用,别拿它再渲一行。 */
+    content: string;
+    /** core 铸的事件身份(uuidv7 形);wire 未必带 ⇒ 缺席时本键不在场。 */
+    eventId?: string;
+}
 /**
  * {@link ChromeEvent} 的 `engine_notice` 臂(#310 / #318 件①,server ≥7.36;契约 = server
  * `ASSISTANT-WIRE-CONTRACT` 附录 D)——「**引擎想让这条会话的人知道一件事**」。

package/dist/seam.js

@@ -48,6 +48,10 @@ const CHROME_ARM_TABLE = {
         required: false,
         duty: '可选:渲引擎通告(按 code+detail,message 仅 fallback;未知 code 也必须渲不许丢;durable 重放按 eventId 幂等;harvest 的 moved/escalated 并列呈现绝不相减)',
     },
+    text_segment_end: {
+        required: false,
+        duty: '可选:引擎明报的 assistant 散文段边界(#323/core #447)。🔴 content 是对账/定界用的权威全文,拿它再渲一行 = 同一段上屏两遍;缺席只表示「没报」,绝不等于「段没结束」——要退回自家启发式必须按整条流判、不按单帧判',
+    },
 };
 /**
  * chrome 臂**覆盖率断言出口**(§8-1 裁决的一半:client-core 定接口不定实现)。

package/dist/subagent/engineCompactWire.d.ts

@@ -1,12 +1,39 @@
-/** Test/introspection hook. */
-export declare function isEngineCompactPending(): boolean;
-/** Test hook: reset the cached capability (fresh engine / respawn). */
+/** Test/introspection hook(缺省 = 默认槽,与 0.44.0 逐字同)。 */
+export declare function isEngineCompactPending(sessionKey?: string): boolean;
+/**
+ * Test hook: reset the cached capability (fresh engine / respawn)。
+ *
+ * 🔴 **只清能力面,绝不动 arm 台账**(异源对抗复审第四轮 [medium] 采纳,修回归):本口是**生产口**
+ *    (引擎重启 / respawn 的能力失效),不是「取消用户的 /compact」。一度顺手加的 `pendingCompactKeys.clear()`
+ *    会让「idle 时 `/compact` 回过 armed → 引擎 respawn → 下一条 run 不再压缩」——用户的命令无声蒸发,
+ *    而且那是**默认槽**上的行为改变,与本批「单会话宿主逐字节零变化」的声明直接矛盾。
+ *    要清 arm 走 {@link __resetEngineCompactArmForTests}(测试钩,生产面没有这个动作)。
+ */
 export declare function resetManualCompactCapability(): void;
+/** 测试钩:清 arm 台账(module 级单例,同进程多组断言必须能清)。生产面**没有**这个动作。 */
+export declare function __resetEngineCompactArmForTests(): void;
 /**
  * The /compact command's live half. Mid-turn: fire now. Idle: arm for the next run bind.
  * Returns what it did (for the command's display line / tests). No-op ('offline') without a live
  * wire; 'unsupported' when the engine's capabilities said manualCompact:false ([488] TOC-local) —
  * the client-side projection compaction still runs, but the ENGINE session context does not shrink.
+ *
+ * 🔴 design/285 批 3(D7b):本族三处零参 `engineWireTarget()` 全部换成 `engineWireTargetFor(sessionKey)`。
+ *    /compact 打的是**这个会话此刻在飞的那条 run**,不是某一行子代 —— owner 台账里没有它,所以槽键
+ *    只能由调用方给(多会话宿主每个 REPL 面板一个槽)。缺省 `DEFAULT_SESSION_KEY` ⇒ 与 0.44.0 逐字同。
+ * 📋 **带反证的驳回半场(异源对抗复审第三轮 [high] 的另一半,如实记)**:复审还要求把快照提前到
+ *    **request(arm)那一拍**,理由是「arm 与 bind 之间槽可能被重绑,意图属于 A 却在 B 上执行」。
+ *    **不采**,反证:arm 那一拍**根本没有 taskId** —— `/compact` 在 idle 下的语义是成文的
+ *    「**这个槽的下一条 run**」(见本文件头注的 arm-then-fire 段),槽的身份就是 key 本身。
+ *    槽真被重绑到另一台引擎时,「下一条 run」就在那台引擎上,压它才是意图;把 request 那一刻的
+ *    target 冻下来反而会去压一台**已经不再跑这条会话**的引擎。⇒ 冻结的正确起点是**拿到 taskId 的
+ *    那一拍**(bind),那之后的每一次延迟与重试都必须用同一份 —— 那正是上面这一条。
+ *    现状由常驻钉 `B3-P31/R6i` 钉住(arm 之后换槽装配 ⇒ 发射打的是**换后**那台,且带换后的会话)。
+ * 🔴 **一条动词的槽键必须一以贯之**(异源对抗复审 [high] 采纳):目标、`?session=`、**run id**
+ *    (`activeEngineRunIdFor`)、**能力位**(per-baseUrl 分桶)、**arm 状态**(per-key 分桶)——
+ *    五件全按同一个 key。只换其中几件就是**半 keyed 形**:那比换锚之前更坏(之前五件一致地错在同一个
+ *    槽上,一眼可见;半 keyed 是「A 的 run id 发到 B 的服务器」「B 的 arm 被 A 的 bind 吃掉」这类只在
+ *    多会话下现形的错)。这条正是 plan 决策链本批**豁免**的同一条理由 —— 那边整条链搬不动,这边搬得动。
  */
-export declare function requestEngineCompact(): 'fired' | 'armed' | 'offline' | 'unsupported';
-export declare function onEngineTaskBound(taskId: string): void;
+export declare function requestEngineCompact(sessionKey?: string): 'fired' | 'armed' | 'offline' | 'unsupported';
+export declare function onEngineTaskBound(taskId: string, sessionKey?: string): void;