@sema-agent/client-core 0.77.1 → 0.78.0

package/dist/adapt/ids.d.ts

@@ -1,53 +1,7 @@
 import type { AdapterContext, AdapterOutput, ChromeEvent, LaneProof } from '../seam.js';
-/** 帧 = wire 投影出来的中性 arm(cli seam/adapter downstream 的 SDKMessage 形),结构化读取。 */
 export type Frame = Record<string, unknown>;
-/**
- * 主车道证明的**出厂口** —— 每次调用交出一只**新的** `{lane:'main'}`(本批实现的臂全在 leader
- * lane;子代/workflow lane 的 tick 面留 #52b)。
- *
- * 🔴 **为什么是函数不是常量**(0.76.1)。此前这里是一只模块级常量对象,`laneOf(未登记 id)` 与本包
- *    约五十个 `laneProof:` 主车道发点交出去的是**同一只**对象 —— 跨适配器实例、跨流、跨 turn 全是
- *    它。实测(修前,本门 L1/L5 段的同一条路径):两个互不相干的消费者各取一次未登记行的证明,
- *    `===` 为真;给第一只补上卡号之后,第二只当场读出 `{lane:'subagent', parentToolCallId:'…'}`,
- *    开流序幕那四条主车道事件也一起变 —— **一次写打穿整个进程**,而且静默。
- *
- * 🔴 **判据如实**:这是**别名风险**,不是「已经在串味的现场」。修前逐站点穷举(语法树扫写表达式)
- *    的结论是:本包内对车道证明**零就地写**(两处看起来像写的是给局部变量**换绑**新对象,不改旧的);
- *    三个消费端的证明用法全是只读(读 `lane` 位 / 解构丢弃)。⇒ 本批修的是「交出去的可变引用被
- *    当成缺省值别名」这一形,不是在修一条已经在错归因的行。发布文案不许把它写成用户可见的回归。
- *    这条形本身仍然要修:`laneProof` 是**公开输出面**上的一位,拿它做 WeakMap 键 / 身份去重 /
- *    视图层身份记忆的消费者,在两条无关行共享一只对象时会把它们认成同一条 —— **一个字都不写也照错**。
- *    这也正是冻结那条修法救不了的一半。
- *
- * 🔴 **为什么不是冻结**(两条都摆过,这条落选):
- *    ① 冻结只挡「写」,不解「别名」——上一段那三种按身份认物的消费面照错;每次新建两件一起解决。
- *    ② 子代臂 `{lane:'subagent', parentToolCallId}` 与 workflow 臂本来就**逐次新建**且可写,只冻主
- *       车道这一半 ⇒ 同一处写操作会因为「这条行恰好绑没绑卡」而一边抛一边收,失败随行漂成间歇形;
- *       要对称就得连十几处内联字面量一起冻,比每次新建更大的改动换更小的收益。
- *    ③ 证明是在宿主手里被写的:冻结把一条本包的别名缺陷变成宿主侧的抛错,而宿主的抛会顺着
- *       `for await` 打断整条 adapt 流。适配层不该给主链添这种反噬。
- * ⚠️ 代价如实:每条主车道事件多一只小对象(≈ 一个键的字面量)。别为了省它把出厂口缓存成模块级
- *    单例(`const M = mainLane()` 就是把这一形原样种回来)—— 结构反钉门盯着这一形。
- */
 export declare const mainLane: () => LaneProof;
-/** 帧 → 稳定转录 id(`suffix` = 同一帧派生多条消息时的去撞位)。 */
 export type IdOf = (frame: Frame, suffix?: string) => string;
-/**
- * L-215③(0.65.0)—— 一条 assistant 转录消息的**身份键**(`message.id` / `message.model`)。
- *
- * 🔴 **本层不是第二个铸点,是接力点**:上游投影器(`adapter/downstream/eventToSdkMessage.ts` 的
- *    `assistantArm`)已经把这两位铸在 durable 内容帧的 `message` 上;而本层的三个构造点
- *    (tool_use 卡臂 / 散文段 / 思考块)都是**重建** `{role, content}` 的 —— 重建就把上游铸好的
- *    两位原地丢掉了(异源对抗复审实抓:「新增 assistant id/model 到达不了最终转录」)。本函数把
- *    它们接过来,规矩只有两条:
- *      · **帧优先、ctx 兜底**(`model`):durable 内容帧上有,live 分段腿的 `stream_event` 锚上没有
- *        —— 那时回落到宿主开流时钉的 {@link AdapterContext.model};
- *      · **`id` 只认帧**:它是引擎铸的**事件身份**,ctx 上没有、也不该有一个「整条流通用的消息 id」。
- * 🔴 **两位都缺席即键不铸**(不是 `undefined` 在场)。
- * ⚠️ tool_use 卡臂**不**用这里的 `id`:那条臂刻意铸 per-RESPONSE id(CC 的 grouped-agent 渲染按
- *    `${message.id}:${toolName}` 分组,换成 per-event id 会把一张 Agent 卡拆成 N 张)——
- *    两个 `id` 是**两种身份**,那条臂只取 `model`。
- */
 export declare function messageIdentityOf(frame: Frame, ctx: {
     model?: string;
 }): {
@@ -55,17 +9,5 @@ export declare function messageIdentityOf(frame: Frame, ctx: {
     model?: string;
 };
 export declare const chrome: (event: ChromeEvent) => AdapterOutput;
-/**
- * 🔴 入参从裸 `unknown` 收窄成 `Frame`(拆分同批的真收窄,不是搬运):调用点全是「按 CC 词汇
- * 现拼的对象字面量」或「原样透传的 wire 帧」,两者都是 `Record<string, unknown>` ——
- * 裸 `unknown` 把窄化义务外包给了每一个调用点,而这里本来就知道自己收的是什么形。
- * 到 `SDKMessage` 的那一步仍是 cast:CC 词汇的字面形与 SDK 类型有已登记的分歧(DIVERGENCE-2/9),
- * 这条 cast 是**有意**的边界,不是偷懒。
- */
 export declare const transcript: (message: Frame, nowMs: number) => AdapterOutput;
-/**
- * [1653]:稳定键优先序 = 帧 id > seq > toolCallId,全缺才 ctx.uuid()。现役 wire 的稳定键落在
- * `uuid` 字段(§E2 core 铸的 eventId / stamp 铸的帧 id),故映到 `id` 位喂进去(见 SEAM-GAP-1)。
- * `suffix` = 同一帧派生多条消息时的去撞位(如 tool_use 卡 + 同帧的 reject 结果)。
- */
 export declare function makeIdOf(ctx: AdapterContext): IdOf;

package/dist/adapt/ids.js

@@ -1,49 +1,5 @@
 import { deriveTranscriptId } from '../seam.js';
-/**
- * 主车道证明的**出厂口** —— 每次调用交出一只**新的** `{lane:'main'}`(本批实现的臂全在 leader
- * lane;子代/workflow lane 的 tick 面留 #52b)。
- *
- * 🔴 **为什么是函数不是常量**(0.76.1)。此前这里是一只模块级常量对象,`laneOf(未登记 id)` 与本包
- *    约五十个 `laneProof:` 主车道发点交出去的是**同一只**对象 —— 跨适配器实例、跨流、跨 turn 全是
- *    它。实测(修前,本门 L1/L5 段的同一条路径):两个互不相干的消费者各取一次未登记行的证明,
- *    `===` 为真;给第一只补上卡号之后,第二只当场读出 `{lane:'subagent', parentToolCallId:'…'}`,
- *    开流序幕那四条主车道事件也一起变 —— **一次写打穿整个进程**,而且静默。
- *
- * 🔴 **判据如实**:这是**别名风险**,不是「已经在串味的现场」。修前逐站点穷举(语法树扫写表达式)
- *    的结论是:本包内对车道证明**零就地写**(两处看起来像写的是给局部变量**换绑**新对象,不改旧的);
- *    三个消费端的证明用法全是只读(读 `lane` 位 / 解构丢弃)。⇒ 本批修的是「交出去的可变引用被
- *    当成缺省值别名」这一形,不是在修一条已经在错归因的行。发布文案不许把它写成用户可见的回归。
- *    这条形本身仍然要修:`laneProof` 是**公开输出面**上的一位,拿它做 WeakMap 键 / 身份去重 /
- *    视图层身份记忆的消费者,在两条无关行共享一只对象时会把它们认成同一条 —— **一个字都不写也照错**。
- *    这也正是冻结那条修法救不了的一半。
- *
- * 🔴 **为什么不是冻结**(两条都摆过,这条落选):
- *    ① 冻结只挡「写」,不解「别名」——上一段那三种按身份认物的消费面照错;每次新建两件一起解决。
- *    ② 子代臂 `{lane:'subagent', parentToolCallId}` 与 workflow 臂本来就**逐次新建**且可写,只冻主
- *       车道这一半 ⇒ 同一处写操作会因为「这条行恰好绑没绑卡」而一边抛一边收,失败随行漂成间歇形;
- *       要对称就得连十几处内联字面量一起冻,比每次新建更大的改动换更小的收益。
- *    ③ 证明是在宿主手里被写的:冻结把一条本包的别名缺陷变成宿主侧的抛错,而宿主的抛会顺着
- *       `for await` 打断整条 adapt 流。适配层不该给主链添这种反噬。
- * ⚠️ 代价如实:每条主车道事件多一只小对象(≈ 一个键的字面量)。别为了省它把出厂口缓存成模块级
- *    单例(`const M = mainLane()` 就是把这一形原样种回来)—— 结构反钉门盯着这一形。
- */
 export const mainLane = () => ({ lane: 'main' });
-/**
- * L-215③(0.65.0)—— 一条 assistant 转录消息的**身份键**(`message.id` / `message.model`)。
- *
- * 🔴 **本层不是第二个铸点,是接力点**:上游投影器(`adapter/downstream/eventToSdkMessage.ts` 的
- *    `assistantArm`)已经把这两位铸在 durable 内容帧的 `message` 上;而本层的三个构造点
- *    (tool_use 卡臂 / 散文段 / 思考块)都是**重建** `{role, content}` 的 —— 重建就把上游铸好的
- *    两位原地丢掉了(异源对抗复审实抓:「新增 assistant id/model 到达不了最终转录」)。本函数把
- *    它们接过来,规矩只有两条:
- *      · **帧优先、ctx 兜底**(`model`):durable 内容帧上有,live 分段腿的 `stream_event` 锚上没有
- *        —— 那时回落到宿主开流时钉的 {@link AdapterContext.model};
- *      · **`id` 只认帧**:它是引擎铸的**事件身份**,ctx 上没有、也不该有一个「整条流通用的消息 id」。
- * 🔴 **两位都缺席即键不铸**(不是 `undefined` 在场)。
- * ⚠️ tool_use 卡臂**不**用这里的 `id`:那条臂刻意铸 per-RESPONSE id(CC 的 grouped-agent 渲染按
- *    `${message.id}:${toolName}` 分组,换成 per-event id 会把一张 Agent 卡拆成 N 张)——
- *    两个 `id` 是**两种身份**,那条臂只取 `model`。
- */
 export function messageIdentityOf(frame, ctx) {
     const msg = frame.message;
     const inner = typeof msg === 'object' && msg !== null && !Array.isArray(msg)
@@ -58,31 +14,12 @@ export function messageIdentityOf(frame, ctx) {
     };
 }
 export const chrome = (event) => ({ plane: 'chrome', event });
-/**
- * 🔴 入参从裸 `unknown` 收窄成 `Frame`(拆分同批的真收窄,不是搬运):调用点全是「按 CC 词汇
- * 现拼的对象字面量」或「原样透传的 wire 帧」,两者都是 `Record<string, unknown>` ——
- * 裸 `unknown` 把窄化义务外包给了每一个调用点,而这里本来就知道自己收的是什么形。
- * 到 `SDKMessage` 的那一步仍是 cast:CC 词汇的字面形与 SDK 类型有已登记的分歧(DIVERGENCE-2/9),
- * 这条 cast 是**有意**的边界,不是偷懒。
- */
 export const transcript = (message, nowMs) => ({
     plane: 'transcript',
-    // 到达时戳补齐(#185-A1 正位收编,2026-08-08;此前是壳 upstreamBridge.stampTranscriptArrival
-    // 的消费端补偿,注释明记「长线正位在 client-core 的 adapt 臂」):transcript 消息不变式=恒带
-    // timestamp——CC 在 content_block_stop 取 wall-clock,而 transcript 帧正是块收尾时到达,到达
-    // 时刻本身就是同一个量。只补缺席不覆盖(wire 哪天带了就用 wire 的);壳侧补偿臂保留为双保险
-    // (its ③:不覆盖已有值 ⇒ 本补齐生效后壳臂自然零触发)。
-    // [C114] 请托(web jsdom-adapt-parity 门 INCONCLUSIVE 实抓):时钟**必经 ctx.now()**(调用方
-    // 注入 nowMs)——裸 `new Date()` 违 DIVERGENCE-7 可重放纪律,确定性双跑逐字节对拍当场失判别力。
     message: (typeof message.timestamp === 'string'
         ? message
         : { ...message, timestamp: new Date(nowMs).toISOString() }),
 });
-/**
- * [1653]:稳定键优先序 = 帧 id > seq > toolCallId,全缺才 ctx.uuid()。现役 wire 的稳定键落在
- * `uuid` 字段(§E2 core 铸的 eventId / stamp 铸的帧 id),故映到 `id` 位喂进去(见 SEAM-GAP-1)。
- * `suffix` = 同一帧派生多条消息时的去撞位(如 tool_use 卡 + 同帧的 reject 结果)。
- */
 export function makeIdOf(ctx) {
     return (frame, suffix) => {
         const base = typeof frame.id === 'string' && frame.id.length > 0

package/dist/adapt/instanceLedger.d.ts

@@ -1,35 +1,10 @@
-/**
- * adapt/instanceLedger.ts — **适配器实例级台账**(A 族拆分 REF-CC-FIX-05;矩阵 §1.5)。
- *
- * 三个 Set 的持有者。它们与 turn 级状态的区别是**跨 turn 存活**:
- *  · `renderedNotifications` —— 通知去重键(#63 的 export/import 往返面就是它);
- *  · `seenWorkflowToolCallIds` —— W1 三级判据③ 的素材(assistant 臂写、task_progress 臂读,
- *    覆盖 uuid 形子代 id 与**跨 turn 迟到 tick**,所以必须跨 turn 活着);
- *  · `firedSubagentStartHookTaskIds` —— SubagentStart 一生只许一次(frame-lane-matrix #4),
- *    同时是 task_notification 臂发 stop 的门。
- *
- * 🔴 FIX-05 就是本文件存在的理由:拆分前这三个 Set 挂在类上,`adapt()` 里既有 `self.` 又有
- *   `this.` **两条访问路径**(generator 表达式的 this 不是适配器,所以当时固定了一个 `const self`)。
- *   收成一个显式入参对象之后:① `self` 别名与它那条 eslint-disable 一起消失;② 三个 Set 的
- *   每一个读写点都必须经 `inst.` —— 「同一台账两条路径」这件事在结构上不再可能。
- *
- * 🔴 DIVERGENCE-6 的现势(别把它读成「本包所有台账都是实例级」):只有本文件这三件是实例级
- *   (= 一个 session 一份)。`notifiedRuns` / `cardEnqueuedRuns` 是 **module 台账**(notifications.ts),
- *   因为它们的配对半场(队列 port / idle watcher / outstanding 药丸)在那儿 —— 放实例 =
- *   前提不共享 = 双卡/零显示/模型二收(0.6.0 真缺口,[1857])。
- */
 export interface AdapterInstanceLedger {
-    /** 通知去重键:已渲染过? */
     hasRenderedNotification(key: string): boolean;
-    /** 通知去重键:记一条(**必须在对应 yield 之前**落,见矩阵 §2.1④ 的 1377 行判定)。 */
     addRenderedNotification(key: string): void;
-    /** 台账导出/回植用的快照与批量吃入(返回真正新吃进去的条数)。 */
     listRenderedNotifications(): string[];
     takeRenderedNotifications(keys: Iterable<unknown>): number;
-    /** W1 判据③:这个 tool_use id 是本会话见过的 Workflow 工具卡? */
     isWorkflowCard(toolUseId: string): boolean;
     markWorkflowCard(toolUseId: string): void;
-    /** SubagentStart 一生一次的门(fire 前判、fire 时记,两步都在 yield 之前)。 */
     hasFiredSubagentStart(taskId: string): boolean;
     markFiredSubagentStart(taskId: string): void;
 }

package/dist/adapt/instanceLedger.js

@@ -1,23 +1,3 @@
-/**
- * adapt/instanceLedger.ts — **适配器实例级台账**(A 族拆分 REF-CC-FIX-05;矩阵 §1.5)。
- *
- * 三个 Set 的持有者。它们与 turn 级状态的区别是**跨 turn 存活**:
- *  · `renderedNotifications` —— 通知去重键(#63 的 export/import 往返面就是它);
- *  · `seenWorkflowToolCallIds` —— W1 三级判据③ 的素材(assistant 臂写、task_progress 臂读,
- *    覆盖 uuid 形子代 id 与**跨 turn 迟到 tick**,所以必须跨 turn 活着);
- *  · `firedSubagentStartHookTaskIds` —— SubagentStart 一生只许一次(frame-lane-matrix #4),
- *    同时是 task_notification 臂发 stop 的门。
- *
- * 🔴 FIX-05 就是本文件存在的理由:拆分前这三个 Set 挂在类上,`adapt()` 里既有 `self.` 又有
- *   `this.` **两条访问路径**(generator 表达式的 this 不是适配器,所以当时固定了一个 `const self`)。
- *   收成一个显式入参对象之后:① `self` 别名与它那条 eslint-disable 一起消失;② 三个 Set 的
- *   每一个读写点都必须经 `inst.` —— 「同一台账两条路径」这件事在结构上不再可能。
- *
- * 🔴 DIVERGENCE-6 的现势(别把它读成「本包所有台账都是实例级」):只有本文件这三件是实例级
- *   (= 一个 session 一份)。`notifiedRuns` / `cardEnqueuedRuns` 是 **module 台账**(notifications.ts),
- *   因为它们的配对半场(队列 port / idle watcher / outstanding 药丸)在那儿 —— 放实例 =
- *   前提不共享 = 双卡/零显示/模型二收(0.6.0 真缺口,[1857])。
- */
 export function createAdapterInstanceLedger() {
     const renderedNotifications = new Set();
     const seenWorkflowToolCallIds = new Set();

package/dist/adapt/panelTasks.d.ts

@@ -1,87 +1,18 @@
-/**
- * adapt/panelTasks.ts — M3 **面板行台账**(A 族拆分 REF-CC-SPLIT-04;矩阵 §1.3 六行状态)。
- *
- * 收编 `taskCardBinding` / `boundToolCalls` / `livePanelTasks` / `endedPanelTasks` /
- * `liveBoundPanelTasks` / `subagentTypeById` 六行状态 + C5 laneOfTask / C6 bindTaskCard /
- * C7 unboundSubagentCandidates / C8 fireSubagentStart / C9 settlePanelTasks 五个闭包。
- *
- * 引擎侧子代的 tick 只带 rollup 数字({toolUses,totalTokens}) = CC `AgentProgress` 同形,
- * 所以忠实的 CC-187 面是 footer 的 CoordinatorTaskPanel(CC 自己对进程外 agent 的先例:
- * 面板行 + task-notification,从不合成 inline 消息轨)。本模块把「tick → 哪张委派卡」的归属、
- * 行的活性(live/inert/unbound)、以及三处 sweep 全部管起来。
- *
- * 🔴 拆分定案两条(矩阵 §3.2 #4/#6):
- *   ① `endedPanelTasks` 拆分前被 `settlePanelTasks` **和** task_notification 臂两处直写。
- *      现在通知臂那半场收成 `settleFromNotification()`(clearResident + endedPanelTasks 判重 +
- *      panel end + if-started stop 整段;0.65.1 起判重在 end 之前),通知臂只调一次 ⇒ 跨臂直写消失。
- *   ② `firedSubagentStartHookTaskIds` 的读者(通知臂)随之进了本模块内部 —— 通知臂**不再直读**
- *      实例台账,那条跨模块读同批消失。
- *
- * 🔴 module 台账 `engineAgentPanelStore` 的两个写口(mark/clearEnginePanelTaskResident)拆分前有
- *   A4/A9 **双所有者**。按记忆 `paired-mechanisms-must-share-premise` 的「整臂让位」:两处写口
- *   现在**在 adapt 域内只在本文件**(`noteResidency()` 与 `settleFromNotification()`),不许 A 层
- *   两个模块各写各的。
- *   ⚠️ ADAPT-F4 判据纠偏(2026-08-02):原文写的是「只在本文件」,而 `src/notifications.ts:915`
- *   的 bg 合成半场也调 `clearEnginePanelTaskResident`(它自陈是「真终态唯二来源」之一,是设计内的
- *   另一条腿、不是被劈开的臂)。照字面 grep 验这条判据的人当场得到证伪,只能二选一:误判成回归去
- *   删 notifications 那半场,或判定这条钉不可信而整条丢掉 —— 两条都是坏结局。判据的作用域必须写准。
- *
- * 🔴 时序留钉(矩阵 §2.1②):`start()` 里 `markFiredSubagentStart` 必须在 `yield` **之前** ——
- *   yield* 展开后判重+记号与交付在**同一次** `.next()` 里,「已标记」⟺「已交付」原子成立;
- *   改成 add-after-yield ⇒ 消费者收到 start 后早退就没记上 ⇒ 下一 turn 重 fire,直接违反「一生一次」。
- */
 import type { AdapterContext, AdapterOutput, LaneProof } from '../seam.js';
 import type { AdapterInstanceLedger } from './instanceLedger.js';
 import type { OpenCardView } from './toolCards.js';
 export interface PanelTaskLedger {
-    /** T32 行绑定(typed 双键在场恒赢;缺席时 FIFO 猜父)。返回绑到的卡 id。 */
     bind(taskId: string, parentToolCallId?: string): string | undefined;
-    /** 未绑的 subagent 形开卡张数(>1 ⇒ 含糊,上层保持 unbound)。 */
     unboundCandidates(): number;
-    /** 行的车道证明:绑到卡的 = subagent lane(带父卡 id),未绑的 = 主 lane。 */
     laneOf(taskId: string): LaneProof;
-    /** 这条行已经绑过卡了吗(含糊回落的前置判位;别拿「`laneOf(...)` 是不是那只主车道常量」代替 ——
-     *  那是按引用相等在推断,判据锚在会决定结果的量上才对。0.76.1 起主车道证明**逐次新建**,
-     *  那种写法连偶然成立都做不到了)。 */
     isBound(taskId: string): boolean;
-    /**
-     * B-074 —— 这条行绑在一张**本 turn 还开着**的卡上吗(`liveBound`,#6 的 live/inert 判位)。
-     *
-     * 它回答的是「**谁来收这条行的终态**」:
-     *   · `true`  ⇒ 关卡那条腿({@link settle})会收,而且它带着**子代的最终报告**(委派卡的 output);
-     *   · `false` ⇒ 未绑 / inert 绑定(跨 turn bg 子代的典型形)= **session 常驻行**,关卡腿不碰它,
-     *     它的终态今天只认通知帧 —— 这正是 core 的终态 tick 要救的那条 uuid lane。
-     * 🔴 判别力承重:终态 tick 在 `true` 的行上**不许**抢着落终态 —— 抢了会让后到的关卡 settle 撞
-     *    `endedPanelTasks` 判重而整条让位,子代的最终报告从此到不了面板行(异源对抗复审实抓)。
-     */
     isLiveBound(taskId: string): boolean;
-    /** 本 turn 发布过面板行了吗(首 tick 判别 = 子代在壳侧可观测的起点)。 */
     isLive(taskId: string): boolean;
-    /** 登记「本 turn 发布过面板行」。 */
     markLive(taskId: string): void;
-    /** #6 常驻台账:live-bound ⇒ 清常驻;inert/unbound ⇒ 记常驻(module store 的**唯一**写口之一)。 */
-    /** 0.74.3 CC-70:`residentKey` = 常驻标该记在哪把键下(归一后的 fleet 尾段);缺省 = taskId。绑卡判定仍按 tick 的 taskId。 */
     noteResidency(taskId: string, residentKey?: string): void;
-    /**
-     * SubagentStart(类型恒记,fire 一生一次)。
-     * 🔴 0.75.1 CC-95(b):`agentType` **可缺席** —— 调用方查不到诚实来源时就不传,本臂让键缺席,
-     *    绝不在这里编一个占位词(此前传的是 tick 的展示名,子代启动 hook 因此收到的是委派卡的 description)。
-     */
     start(taskId: string, agentType?: string): Generator<AdapterOutput>;
-    /** 关卡 settle(cardId)或 turn 末/abort 防御 sweep(cardId===null)。 */
     settle(cardId: string | null, isError: boolean, report?: string): Generator<AdapterOutput>;
-    /** #6 通知-settle 边(推送半场):真终态在此落行,session 常驻行不再被 turn sweep 假结。 */
     settleFromNotification(taskId: string, isError: boolean): Generator<AdapterOutput>;
-    /**
-     * B-074(0.65.0)**终态 tick 边** —— core 明写的那一拍(`task_progress.status` = `completed`/
-     * `failed`)按 taskId 直接落行。
-     *
-     * 为什么不复用 {@link settleFromNotification}:那一条是**通知帧**那半场,它按**主车道**发
-     * end(bg 子代行本来就是 unbound 的),而终态 tick 的行**可能绑着一张前台委派卡** ⇒ 车道证明
-     * 必须走 {@link laneOf},否则一条 subagent lane 的行会拿 main lane 的证明去落终态(帧×lane
-     * 矩阵那一族的病)。也不复用 {@link settle}:那一条按**卡 id** 收(关卡/防御 sweep 的语义),
-     * 而这里的权威键是 taskId —— 引擎说的是「这个子代结束了」,不是「这张卡关了」。
-     */
     settleFromTerminalTick(taskId: string, isError: boolean): Generator<AdapterOutput>;
 }
 export declare function createPanelTaskLedger(ctx: AdapterContext, cards: OpenCardView, inst: AdapterInstanceLedger): PanelTaskLedger;

package/dist/adapt/panelTasks.js

@@ -2,40 +2,17 @@ import { clearEnginePanelTaskResident, clearEnginePanelTaskResidentByWire, markE
 import { chrome, mainLane } from './ids.js';
 import { SUBAGENT_TOOL_NAMES } from './wireShapes.js';
 export function createPanelTaskLedger(ctx, cards, inst) {
-    /** taskId → 绑定的 open tool_use id。 */
     const taskCardBinding = new Map();
-    /** 已被某 taskId 认领的 tool_use id(一张卡只认一个子代)。 */
     const boundToolCalls = new Set();
-    /** 本 turn 发布过面板行的全部 taskId(绑定与否都算)。 */
     const livePanelTasks = new Set();
-    /** 已落终态的行(settle 幂等)。 */
     const endedPanelTasks = new Set();
-    /**
-     * #6 —— 绑定时那张卡**正开着**的 taskId(= "live" 绑定)。只有这些行属本 turn 生命周期、
-     * 可被 turn 末防御 sweep 结掉。inert(显式父指向已关/没见过的卡 —— 跨 turn bg 子代的典型形)
-     * 与 unbound 行是 **session 常驻**:终态只认 task_notification / bg_notification。
-     */
     const liveBoundPanelTasks = new Set();
-    /** 0.74.3 CC-70(异源复审 R2 [medium] / R3 [high]):常驻标可能记在归一键(fleet 尾段)下 —— 两把键都清,但前代终态不清当代的尾段键(判据在 store,单源)。 */
     const clearResidencyBothKeys = (taskId) => clearEnginePanelTaskResidentByWire(taskId);
-    /** taskId → 子代类型(Stop hook 查它;cli 同为 turn 局部)。 */
     const subagentTypeById = new Map();
     const laneOf = (taskId) => {
         const card = taskCardBinding.get(taskId);
         return card !== undefined ? { lane: 'subagent', parentToolCallId: card } : mainLane();
     };
-    /**
-     * 一条行要发**多条**事件时的车道证明来源(0.76.1,异源对抗复审 R1 [medium] 实测逼出)。
-     *
-     * 病形:终态那两处(关卡 / 终态 tick)此前 `const lane = laneOf(taskId)` 取一次,然后 stop 与
-     * end **两条事件共用那一只** —— 消费者拿到 stop 后改它的归属,同一条行的 end 跟着变;逐条消费
-     * 的宿主甚至能在 end 那一次 `yield` **之前**就把它污染掉(生成器在两条之间是挂起的)。
-     *
-     * 修法**不是**在每条事件那里各调一次 `laneOf`:两次调用之间生成器会挂起,消费者若在这中间绑了卡,
-     * 同一条行的两条事件就会**分流到两个归属**上(一条算主车道、一条算子代)——那比别名更坏。
-     * ⇒ **归属判一次、证明铸多只**:这里把归属(绑到哪张卡 / 没绑)先定死,返回的铸口每次交出一只
-     *   新对象、值恒相同。
-     */
     const laneMinterFor = (taskId) => {
         const card = taskCardBinding.get(taskId);
         return card !== undefined
@@ -46,44 +23,18 @@ export function createPanelTaskLedger(ctx, cards, inst) {
         laneOf,
         isBound: (taskId) => taskCardBinding.has(taskId),
         isLiveBound: (taskId) => liveBoundPanelTasks.has(taskId),
-        /**
-         * T32 行绑定。**typed 双键在场恒赢**(B6 定案):wire 点名了 `parentToolCallId` 时,下面的
-         * FIFO 臂**一次都不会被考虑** —— 连「点名的卡不合格」那一支也是直接返回 unbound,而不是
-         * 退回去猜。判据锚在这里:显式支的两条出口(绑定 / 拒绝)都不落进 else。
-         */
         bind(taskId, parentToolCallId) {
             const existing = taskCardBinding.get(taskId);
             if (existing !== undefined)
                 return existing;
             let target;
             if (parentToolCallId !== undefined) {
-                // P1② 精确绑定 —— wire 点名了委派卡。信但不无条件信([1617]①,frame-lane-matrix #1):
-                // 被点名的卡**开着**且**不是** subagent 形工具(Task/Agent/Fork)时拒绝绑定 —— 否则
-                // workflow/Bash 卡一关就会把这条行 settle 掉、还会收走它的 inline stats(错归因)。
-                // 行保持 unbound(taskId 键的 rollup 仍是真的)。已关/没见过的 id 仍**惰性绑定**(inert):
-                // 终态由通知落,严格优于错绑另一张开着的卡。
                 const named = cards.peek(parentToolCallId);
                 if (named !== undefined && !SUBAGENT_TOOL_NAMES.has(named.name))
                     return undefined;
                 target = parentToolCallId;
             }
             else {
-                // ── old-engine fallback(FIFO 猜父)—— B6 P1-2 归属定案:**不删** ────────────────────
-                // 🔴 判据先摆正:这条臂不是「P1-2 之前的临时权宜」,它是 **tolerate-absent 的保护臂**。
-                //   决定后果方向的量 = 「这条子代行有没有归属」:
-                //     · 回落在 ⇒ 老引擎(不发 parentToolCallId)上行仍绑到唯一那张开着的委派卡 ⇒ 行有归属、
-                //       inline stats 有去处、关卡时被 settle;
-                //     · 回落删掉 ⇒ 老引擎上行恒 unbound ⇒ 转录里那条群组行永远不长统计、卡关了也不结,
-                //       用户看到一条转圈到 turn 末的行。
-                //   ⇒ **保护型缺席 = 漏保护**,与 `parked → awaiting approval` 同判(不删)。
-                //   猜错的风险已被两道门收窄:只考虑**未绑**且**subagent 形**的卡;≥2 张候选时上层
-                //   直接判含糊、保持 unbound(见 task_progress 臂的 unboundCandidates() > 1)。
-                // 退役条件(登记在 compensations.ts T32):P1-2 到货 **且** 达标线 ≥ server 1.290 —— 即
-                //   「不再支持不发 typed 双键的引擎」那一天,才是删它的日子;只要还能连老引擎就得留着。
-                // 覆盖:diff 门 14 条 task_progress 帧里有 6 条不带 parentToolCallId(其中 2 条走 workflow
-                //   lane 门、不到这里),真正压这条回落臂的是 4 条(FIFO 命中 / 含糊拒绝 / settle / 跨 turn)。
-                // 🔴 依赖 `cards.entries()` 的**开卡顺序**(Map 插入序 = FIFO 语义本身),换成任何
-                //   无序容器都会静默改判别结果。
                 for (const [id, p] of cards.entries()) {
                     if (!boundToolCalls.has(id) && SUBAGENT_TOOL_NAMES.has(p.name)) {
                         target = id;
@@ -95,15 +46,11 @@ export function createPanelTaskLedger(ctx, cards, inst) {
                 return undefined;
             taskCardBinding.set(taskId, target);
             boundToolCalls.add(target);
-            // #6 live vs inert:只有绑到**此刻开着**的卡才把行系进本 turn 的生命周期
-            // (FIFO 目标恒开着;显式目标可能已关 = inert)。
             if (cards.has(target))
                 liveBoundPanelTasks.add(taskId);
-            // cli 的 `SEMA_BIND_PROBE` 文件探针 → 注入口(载荷逐字同形,见 ADAPTER_DIVERGENCES-5)。
             ctx.probe?.('bind', `bind ${taskId} -> ${target} via=${parentToolCallId !== undefined ? 'explicit' : 'fifo'}`);
             return target;
         },
-        /** 对抗复审修(w0zwpa251 #1):≥2 张未绑的 subagent 形卡开着且 wire 没点名 ⇒ 任何猜都是错归因。 */
         unboundCandidates() {
             let n = 0;
             for (const [id, p] of cards.entries()) {
@@ -116,35 +63,22 @@ export function createPanelTaskLedger(ctx, cards, inst) {
         markLive: (taskId) => {
             livePanelTasks.add(taskId);
         },
-        // #6 session 常驻台账:live-bound(卡本 turn 开着)= 本 turn 生命周期,turn 末可 sweep;
-        // inert/unbound(跨 turn bg 子代形)= 常驻,两处 sweep 都放行,终态只认通知帧。
         noteResidency: (taskId, residentKey = taskId) => {
             if (liveBoundPanelTasks.has(taskId))
                 clearEnginePanelTaskResident(residentKey);
             else
                 markEnginePanelTaskResident(residentKey);
         },
-        /** SubagentStart(cli fireSubagentStartHook 的臂化):类型恒记,fire 一生一次。 */
         *start(taskId, agentType) {
-            // 0.75.1 CC-95(b):类型**在场才记**(缺席不写空串进表 —— stop 那一半读的是同一份记忆,写了空串
-            //   就等于把「不知道」渲成了一个词)。Stop 的类型查找恒记(fire 与否无关)。
             if (agentType !== undefined)
                 subagentTypeById.set(taskId, agentType);
-            // 🔴 判重 + 记号都在**唯一那条 yield 之前**(矩阵 §2.1②:零残余窗,别挪)。
             if (inst.hasFiredSubagentStart(taskId))
                 return;
             inst.markFiredSubagentStart(taskId);
             ctx.probe?.('hook', `start ${taskId} type=${agentType ?? '-'}`);
             yield chrome({ kind: 'subagent_lifecycle', laneProof: laneOf(taskId), phase: 'start', taskId, ...(agentType !== undefined ? { agentType } : {}) });
         },
-        /**
-         * 结掉一张关闭中的卡所绑的面板行(`cardId`),或 turn 末/abort 结掉**本 turn 活绑**的全部行
-         * (`cardId===null` 的防御 sweep —— 子代从不发终态 tick)。
-         * 拍1 查看态:显式关卡臂携委派卡的 output(= 子代最终报告)到 end 事件上;sweep 无报告。
-         */
         *settle(cardId, isError, report) {
-            // inline 群组行孪生(clay dogfood 2026-07-03):冻结该卡的 tick 终值,免得"N agents finished"
-            // 行把真实工具数/token 重置回 0。null-cardId 的 sweep 结掉每一条活着的 inline 条目。
             if (cardId !== null) {
                 yield chrome({ kind: 'inline_task_stats', laneProof: { lane: 'subagent', parentToolCallId: cardId }, op: 'settle', cardId, isError });
             }
@@ -154,9 +88,6 @@ export function createPanelTaskLedger(ctx, cards, inst) {
             for (const taskId of livePanelTasks) {
                 if (cardId !== null && taskCardBinding.get(taskId) !== cardId)
                     continue;
-                // #6 —— 防御 sweep 只结**本 turn 活绑**的行(流被截断的形)。session 常驻行
-                // (inert 绑定 / unbound = 跨 turn bg 子代)绝不在这里冻成假 completed:它的终态真相
-                // 由 task_notification / bg_notification 落(通知-settle 边)。
                 if (cardId === null && !liveBoundPanelTasks.has(taskId))
                     continue;
                 if (endedPanelTasks.has(taskId))
@@ -183,19 +114,7 @@ export function createPanelTaskLedger(ctx, cards, inst) {
                 });
             }
         },
-        /**
-         * 通知臂(task_notification)那半场,整段收进来 —— 拆分前它在臂里直写 `endedPanelTasks`
-         * 与直读 `firedSubagentStartHookTaskIds`,是矩阵点名的两条跨模块面。
-         * 🔴 **判重在唯一的 yield 之前**(0.65.1 / B-087;test [6961] 对抗复审轨实抓):拆分时这里
-         *    「逐字保持」了拆分前的次序 —— 先发 end 行、再判重 —— 判重只护着 if-started stop,end
-         *    行本身无条件发。B-074 让终态 tick 也能结 bg 行之后,`tick(completed) → task_notification`
-         *    这个顺序就在面板上落**两条** end(反序只有一条,因为 tick 腿判重在前)。三条腿共用
-         *    `endedPanelTasks` 的承诺(§30d G30-11)要在**每条腿**的 yield 之前成立;常驻账照清
-         *    (清一次幂等,真终态权威性不变)。
-         */
         *settleFromNotification(taskId, isError) {
-            // #6 通知-settle 边(推送半场):session 常驻的 bg 子代行不再被 turn sweep 假结,
-            // 真终态在此落行(failed/killed ⇒ isError 真归因)。
             clearResidencyBothKeys(taskId);
             if (endedPanelTasks.has(taskId))
                 return;
@@ -205,9 +124,6 @@ export function createPanelTaskLedger(ctx, cards, inst) {
                 laneProof: mainLane(),
                 event: { kind: 'end', taskId, isError },
             });
-            // SubagentStop 只对**真 fire 过 Start** 的子代(workflow runId / 外来 id 不配对乱 fire)。
-            // cli 同门 `firedSubagentStartHookTaskIds.has(taskId)` —— B4 前本臂无条件发 stop,
-            // 宿主若照 guard 注释自建台账才不会乱 fire;台账在库里就该库来判。
             if (inst.hasFiredSubagentStart(taskId)) {
                 yield chrome({
                     kind: 'subagent_lifecycle',
@@ -218,16 +134,6 @@ export function createPanelTaskLedger(ctx, cards, inst) {
                 });
             }
         },
-        /**
-         * B-074(0.65.0)**终态 tick 边**(契约见端口声明)。
-         *
-         * 🔴 **幂等在最前面**:同一条行可能被三条腿同时收到终态(终态 tick / 关卡 tool_end /
-         *    task_notification),`endedPanelTasks` 是它们共用的那本账 —— 判重放在**唯一的 yield 之前**
-         *    (与 `start()` 同一条零残余窗纪律),否则一条 end 会在面板上重复出现。
-         * 🔴 **inline 群组行孪生同拍冻结**:绑了卡的行要把 tick 终值冻住,否则转录里那条
-         *    "Running N agents…" 会被后到的 `settle_all` 把真实工具数重置回 0(clay dogfood 那一例)。
-         * 🔴 **常驻账要清**:终态 tick 是**权威**终点 ⇒ 这条行不再是「等通知帧收尸」的常驻行。
-         */
         *settleFromTerminalTick(taskId, isError) {
             if (endedPanelTasks.has(taskId))
                 return;
@@ -244,7 +150,6 @@ export function createPanelTaskLedger(ctx, cards, inst) {
                     isError,
                 });
             }
-            // SubagentStop 只对**真 fire 过 Start** 的子代(同 settleFromNotification 的 if-started 门)。
             if (inst.hasFiredSubagentStart(taskId)) {
                 const agentType = subagentTypeById.get(taskId);
                 yield chrome({