@sema-agent/client-core 0.77.1 → 0.77.2

package/dist/adapt/textStream.js

@@ -1,60 +1,12 @@
 import { chrome, mainLane, transcript, messageIdentityOf } from './ids.js';
 import { estimateCjkTokens, FLUSH_INTERVAL_MS } from './wireShapes.js';
-// L-318:六形判决单源(两条车道同吃;落账各归各层,见 textSegmentAuthority.ts 头注)。
 import { resolveTextSegmentAuthority } from './textSegmentAuthority.js';
-/**
- * **段身份键**(CC-01,0.68.2)—— 打在 committed assistant **文本**转录行**顶层**的 `_sema_` 超集键。
- *
- * ── 为什么有它(归层修,不是新功能)──────────────────────────────────────────────────────────
- * `text_segment_end` 到达时若已提交前缀自己也过期(`committedPrefixDiverged`),宿主要在**自己持有的**
- * 转录里找出「这一段交出去的那一行」把它换掉。按字节相等去找会被**同后缀的独立行**冒充(实撞过);
- * 按 uuid 找只证明「是这一行」,不证明「是这一段的」。⇒ 归属要两把钥匙:行身份(`uuid`)∧ **段身份**。
- * 段身份此前由壳在自己的过境口铸(先壳后包);段的边界(开场 / 收口 / 轮换)本来就只有本模块知道,
- * 铸点归这里,壳只读。
- *
- * ── 语义(一句话)────────────────────────────────────────────────────────────────────────────
- * **一个身份覆盖「上一次段收口 → 本次段收口」之间过境的全部 committed 文本行**:流开场一个初值;
- * idle-flush 提交的半段与终态提交的同段共享一个身份(归属正要这个);`text_segment_end` 臂处理完之后
- * 轮换(帧上带的是轮换**前**的那一个,与它盖过的行同值);思考→回答边界**不**轮换;子流(带
- * `parentToolCallId`)的段边界不轮换(它们不产 leader 事件,见臂头注)。
- *
- * ── 铸法与形 ──────────────────────────────────────────────────────────────────────────────
- * 派生自本窗口的**第一帧**锚 + 窗口序号(`idOf(anchor, 'segment<n>')`)⇒ **同流重放同身份**
- * (与 committed 行的 uuid 同一条确定性纪律;宿主的双跑对拍门靠它)。🔴 它是**转录格式**上的键,
- * 不是 wire 键:只出现在宿主落盘的转录行上,不进 provider 请求(顶层自铸键不外溢,与
- * `_sema_degraded` 同律)。🔴 **只盖尾块是 `text` 的 assistant 行**:只带 `tool_use` 的行永远不可能是
- * 替换目标,盖了只是往转录里加噪;思考块同理。缺席 = 「这条不属于任何引擎段」,不是「属于某个未知段」。
- * 🔴 **只加不减**:非本形消息一个字节不动。
- */
 export const SEMA_SEGMENT_ID_KEY = '_sema_segment_id';
-/**
- * 件 A(#323 症状①)判据 (b) 的句末字符集 —— 中英文各一套,**闭集**(开集匹配会把「代码里的点」
- * 之外的一切标点都当句末,等于没收紧)。换行单独在 {@link endsAtSentenceBoundary} 里判(段末)。
- */
 const SENTENCE_END_CHARS = new Set(['。', '！', '？', '…', '.', '!', '?']);
-/**
- * 句末标点**之后**还可以合法跟着的收尾符(闭集):引号 / 括号 / markdown 强调与行内代码标记。
- * 🔴 有它的理由(异源复审 finding 采纳):真句末很常见地**不以句末标点结尾** ——
- * `他说:“完成了。”` 的末字符是右引号、`**Done.**` 的末字符是 `*`。不剥这一层,判据 (b) 会把
- * 这些**真句末**永久判否(每一拍 idle 都返回 false),等于对带引号/强调的回复整条腿失效。
- * 🔴 只剥**收尾**符,不做括号配对分析:未闭合的行内代码 `` `a.b `` 末字符是 `b`,本来就判否;
- * 而 `` `a.b` `` 剥掉反引号后是 `b`,同样判否 —— 代码跨度里的点不会被误当句末。
- */
 const SENTENCE_CLOSING_CHARS = new Set([
     '"', "'", '”', '’', '』', '」', '》', '〉', '】', '〕', ')', '）', ']', '］', '}', '｝', '*', '_', '~', '`',
 ]);
-/** 收尾符最多剥这么多层 —— 剥的是收尾符,不是「一直回溯到找得着句号为止」。 */
 const MAX_TRAILING_CLOSERS = 8;
-/**
- * 段尾是不是句末/段末边界(件 A 判据 (b))。
- * 行末空格/制表符先剥掉再看最后一个字符 —— 流式 delta 常把 `". "` 拆成两拍,不剥就恒判否。
- * 然后剥一层 {@link SENTENCE_CLOSING_CHARS} 收尾符,最后一次性判「换行(段末)∪ 句末标点」。
- *
- * 🔴 **换行判在剥尾之后**(异源复审第四轮 finding 采纳):换行检查若只做在剥尾**之前**,
- * `Done.\n**`、整块围栏代码块(```` ```\nx\n``` ````)、`“完成了\n”` 这些**剥掉收尾符才露出换行**
- * 的形会全部判否 —— 恰好是「已经写完一段」最常见的三种收尾,判否等于把它们永久押到工具边界/
- * turn 收口。换行本身不在收尾符集里,所以「先剥后判」对「换行就在最外层」那些形是恒等的。
- */
 function endsAtSentenceBoundary(s) {
     let t = s.replace(/[ \t]+$/u, '');
     if (t.length === 0)
@@ -69,101 +21,30 @@ function endsAtSentenceBoundary(s) {
     return last === '\n' || last === '\r' || SENTENCE_END_CHARS.has(last);
 }
 export function createTextStream(ctx, idOf) {
-    // ── turn 级状态(cli generator 局部变量的等价;矩阵 §1.1 逐行对位)──────────────────────────
     let answer = '';
     let answerSegment = '';
     let thinking = '';
     let emittedAssistantText = false;
-    /** **当前这条 assistant 消息**已提交上屏的正文(补差判据的输入;与 `answer` 刻意分家,见接口注)。 */
     let committedText = '';
-    /** 上一条**真有正文**的 assistant 消息在屏上的那段(见 lastCommittedAnswerText 头注)。 */
     let previousCommittedText = '';
-    /**
-     * CC-16(0.71.0):**本段身份窗口里已提交的文本行**(正文 + 本包铸的 uuid,按序)—— 与思考面的
-     * `committedThinking`(CC-11)同律。写于 `emitAnswerSegment` 铸行那一拍;`replaceAnswerSegment` 用过即清;
-     * 窗口轮换(`rotateSegmentIdentity`)整只清。修前 `text_segment_end` 只带 `segmentId`,持有转录的端要自己跟踪
-     * 「本窗口过境了哪几条盖着该 id 的行」,窗口内 ≥2 条(两个工具卡)时端整发放弃 = 未脱敏字节留盘;包在铸行处
-     * 确知每一条,交全就不用端猜。常态段的定稿行在轮换**之后**才提交 ⇒ 天然属下一窗口、不在本列。
-     */
     let committedTextRows = [];
-    /** 消息序号(`beginAssistantMessage` 递增):行账按消息分组重建两本补差账用。 */
     let messageSerial = 0;
     let textPending = '';
     let thinkingPending = '';
     let textBlockOpen = false;
     let thinkingBlockOpen = false;
     let lastFlushAt = 0;
-    /**
-     * 件 A 判据 (a):**本段已经用掉 idle 的那一刀**。写于 `takeAnswerSegmentOnIdle` 真提交那一拍,
-     * 复位于 `takeAnswerSegment`(= 正常边界到达 ⇒ 重开新段)——**空段的正常边界也复位**:
-     * 「工具帧来过」本身就是重开新段的事实,与那一拍有没有散文可提交无关。
-     */
     let idleFlushUsedInSegment = false;
-    /**
-     * L-310:**当前引擎段**里已经 committed 上屏的那一截(idle-flush 的刀)。
-     *
-     * 🔴 与 `committedText` 刻意分家(两个量、两件事,别合并):`committedText` 记的是「**这条
-     *    assistant 消息**屏上已经有了哪些字」(跨段累加,补差判据的输入);这一个记的是「**这一段**
-     *    有多少字节已经撤不回了」——它是权威段替换唯一能算出「尾段该换成什么」的量。
-     * 写于 `emitAnswerSegment`(提交本体,**只计当前段那一截**,不含 {@link segmentSealed});
-     * 归零于三处**段到此为止**的事实发生地:正常边界(`takeAnswerSegment`)、权威替换
-     * (`replaceAnswerSegment`)、新消息划界(`beginAssistantMessage`)。
-     * idle 入口**不**归零 —— 那正是「段还没完、只是先上屏半截」这件事本身。
-     */
     let segmentCommitted = '';
-    /**
-     * 🔴 **上一个包侧边界带走的那一截**(L-310 / 异源复审 finding①,0.68.1)。
-     *
-     * 存在的理由是一条**上游实测的时序**:openai 车道的 `text_end` 是在 `finalize()` 里 push 的
-     * (装机 core `dist/brain/openai.js` 的 `finalize` 真字节),而 `toolcall_end` 会先触发
-     * `executor.maybeAdmit`(`dist/engine/loop/agent-loop.js`)⇒ **工具卡先到、段边界后到**。
-     * 那一拍包侧的工具卡臂已经 `takeAnswerSegment()` 把卡前散文提交进**上一条** assistant 消息,
-     * 于是 `segmentCommitted` 与 `answerSegment` 双双为空 —— 若据此判「本包没经手过这一段」,
-     * 一段**未脱敏**的正文就会静静留在转录里、且三个分歧键一个都不发(宿主连纠正的机会都没有)。
-     * ⇒ 边界带走那一截时把它记在这里,迟到的 `text_end` 据它**算分歧、发信号**;
-     *    但**不铸任何消息**(那些字节在上一条消息里,在这里补一条只会落到工具卡**之后**)。
-     * 与 `previousCommittedText` 是同一条思路的两个量,刻意分开:那一个是「上一条消息的全部正文」
-     * (终答补差用),这一个是「上一个包侧边界带走的**本段**那一截」(分歧判据用)。
-     */
     let previousSegmentCommitted = '';
-    /**
-     * 🔴 **已由引擎明报收尾、但还没提交的段正文**(L-310 / 异源复审 finding②,0.68.1)。
-     *
-     * 病形(复审实抓):`delta(A) → text_end(A) → delta(B) → text_end(B)` 中间没有工具卡也没有
-     * idle 提交时,若替换只是把 `content` 写回 `answerSegment`,B 的 delta 会**接着往同一个缓冲里加**,
-     * 然后被 `contentB` 整段覆盖 —— **A 段的正文凭空消失**,而且 B 那一帧还会误报 `diverged`。
-     * 这条时序在 anthropic 车道是**常态**(装机 core `dist/brain/anthropic.js` 在
-     * `content_block_stop` 上逐块 push `text_end`,一条消息可以有多个 text 块)。
-     * ⇒ 替换把定稿正文移进本缓冲(「封存」),`answerSegment` 清空给下一段用;段提交本体交的是
-     *    `segmentSealed + answerSegment`。分段行为**零改动**(整 turn 仍只提交一条 assistant 文本
-     *    消息,除非有工具卡/idle 边界)—— 撤 idle-flush 启发式仍是另一批的事。
-     */
     let segmentSealed = '';
-    /** T29 攒批节拍:宿主策略优先(桌面/web 可传 16ms 对齐 CC 桌面端),缺席=207 CLI 口径 100ms。 */
     const flushEveryMs = typeof ctx.coalesceIntervalMs === 'number' && ctx.coalesceIntervalMs >= 0
         ? ctx.coalesceIntervalMs
         : FLUSH_INTERVAL_MS;
-    /** committed 消息的 id 锚 —— 该段/该思考块的**第一帧**(重放确定性:同流同 id)。 */
     let segmentAnchor = null;
     let thinkingAnchor = null;
-    /**
-     * CC-02:**当前窗口里最近一次整块提交的思考行**(正文 + 本包铸的 uuid)—— `reasoning_end` 迟到时
-     * (`text_delta` 先触发了思考→回答边界的提交)唯一能拿来算分歧、指认行的对照物。
-     * 写于 `takeThinking` 提交那一拍;清于 `replaceThinkingSegment` 用过之后、以及下一块思考开始
-     * (`feedThinking` 首条)—— 上一块的提交不是这一块的对照物。
-     */
     let committedThinking = [];
-    /**
-     * CC-14(0.69.2):活体思考块已被 `reasoning_end` **定稿**(形 (a) 整块换 / 形 (b1) 尾段换)但还没提交。
-     * 段账按「行所属的引擎段」记,不按「提交时间落在哪一段」:定稿块迟交(tool_use / 下一段 text_delta 才提交)时
-     * **不**登进下一段的 `committedThinking` —— 修前登进去,宿主按义务把上一段定稿行换成下一段权威、其余行清空,
-     * 上一段定稿内容丢失而披露仍说成功(cli 1.0.115 合并树对抗复审实抓)。
-     */
     let thinkingSettled = false;
-    /**
-     * 段身份窗口(见 {@link SEMA_SEGMENT_ID_KEY} 头注):窗口的第一帧锚 + 序号 + 派生结果缓存。
-     * 🔴 缓存不是优化:锚缺席那一形派生落到 `ctx.uuid()`,不缓存的话同一窗口两次读会得到两个身份。
-     */
     let segmentWindowAnchor = null;
     let segmentWindowSerial = 0;
     let segmentIdCache = null;
@@ -172,44 +53,33 @@ export function createTextStream(ctx, idOf) {
             segmentIdCache = idOf(segmentWindowAnchor ?? {}, `segment${segmentWindowSerial}`);
         return segmentIdCache;
     };
-    /** 提交累积的思考块(cli takeThinking:committed 形 + 关活体块 + 收活动行)。 */
     function* takeThinking() {
         if (thinking.length === 0)
             return;
         const anchor = thinkingAnchor ?? {};
         const msg = {
             type: 'assistant',
-            // L-215③:上游投影器铸在 durable 内容帧上的两个身份位在这里**接力**,不是重铸
-            // (本构造点是重建 `{role,content}` 的,不接就原地丢掉;见 `ids.ts` 的 messageIdentityOf)。
             message: { role: 'assistant', content: [{ type: 'thinking', thinking }], ...messageIdentityOf(anchor, ctx) },
             uuid: idOf(anchor, 'thinking'),
             session_id: ctx.sessionId,
             parent_tool_use_id: null,
         };
-        // CC-11(0.69.1):**按序累积**,不覆盖 —— 一段推理可以跨工具卡(openai 车道 finalize 时序),每一块提交都是
-        //    这一段的一部分;`reasoning_end` 到达时把它们全部交出去(`committedUuids`),宿主才有整段的归属。
-        //    CC-14:定稿块属上一段,不登本段账(它的权威已经在正文里)。
         if (!thinkingSettled)
             committedThinking.push({ text: thinking, uuid: msg.uuid });
         thinkingSettled = false;
         thinking = '';
         thinkingAnchor = null;
         thinkingBlockOpen = false;
-        // P2d:活体 "∴ Thinking…" 行在 committed 块落地的**同一刻**收掉(先收行再上消息,cli 同序)
         yield chrome({ kind: 'thinking_activity', laneProof: mainLane(), active: false });
         yield transcript(msg, ctx.now());
     }
-    /** 段提交的**唯一本体**(两个入口 `takeAnswerSegment` / `takeAnswerSegmentOnIdle` 共用;
-     *  两个入口的差别只在准入判据,提交出来的消息一个字节都不分叉)。 */
     function* emitAnswerSegment() {
-        // L-310:提交的是「已封存的定稿段 + 还在攒的当前段」。分段行为零改动 —— 封存只换字节,不切消息。
         const body = segmentSealed + answerSegment;
         if (body.length === 0)
             return;
         const anchor = segmentAnchor ?? {};
         const msg = {
             type: 'assistant',
-            // L-215③:同 takeThinking —— 身份位接力(帧优先、ctx 兜底;两位都读不出就一个都不铸)。
             message: { role: 'assistant', content: [{ type: 'text', text: body }], ...messageIdentityOf(anchor, ctx) },
             uuid: idOf(anchor, 'text'),
             session_id: ctx.sessionId,
@@ -217,14 +87,7 @@ export function createTextStream(ctx, idOf) {
         };
         const committedTextBeforeRow = committedText;
         committedText += body;
-        // L-310:🔴 **只有当前段那一截**算进「本段已提交前缀」—— 已封存的定稿段属于**上一个**引擎段,
-        //    把它算进来会让下一帧 `text_end` 拿一个跨段的前缀去比 `content`,当场误报前缀分歧。
         segmentCommitted += answerSegment;
-        // CC-16:本窗口行账 —— 与上一行的前缀账**同律**:只有携带本窗口字节(`answerSegment` 那截)的行才登记;
-        //    正文全是已封存定稿段(`segmentSealed`)的行属**上一个**引擎段,登进来会让下一帧 `text_end` 把它当
-        //    本窗口的已提交行去换 —— 那是思考面 CC-14 的同形病(定稿迟交行误登下一段账)。
-        //    `sealedPrefix` = 该行里属上一段的定稿那截(封存只换字节不切消息 ⇒ 混合行);端写回时必须保住它。
-        //    `msgTextBefore` = 该行提交前所属消息已有的正文(窗口之外独立提交的定稿前缀也在里面),写回后按消息重建账本用。
         if (answerSegment.length > 0)
             committedTextRows.push({ text: body, uuid: msg.uuid, sealedPrefix: segmentSealed, msgSerial: messageSerial, msgTextBefore: committedTextBeforeRow });
         segmentSealed = '';
@@ -234,21 +97,13 @@ export function createTextStream(ctx, idOf) {
         textBlockOpen = false;
         yield transcript(msg, ctx.now());
     }
-    /** 提交累积的文本段(cli takeAnswerSegment:#27 段序铁律——工具卡前/turn 末各 flush 一次)。
-     *  🔴 **正常边界**入口:除了复位件 A 的 idle 配额,行为与拆分前逐字一致(零改动面)。 */
     function* takeAnswerSegment() {
         idleFlushUsedInSegment = false;
         yield* emitAnswerSegment();
-        // L-310:正常边界带走了当前段的那一截 ⇒ 本段前缀账归零(下一段的替换不许把上一段的字节
-        // 算成自己的前缀),但**记进** `previousSegmentCommitted` —— 这是包侧边界,不是引擎段边界:
-        // openai 车道的 `text_end` 会在这之后才到,那一拍还得拿它算分歧(见 replaceAnswerSegment)。
         previousSegmentCommitted += segmentCommitted;
         segmentCommitted = '';
     }
-    /** 件 A:IDLE-FLUSH 专用入口(准入 = 每段一刀 + 句末/段末边界;两条都过才提交)。 */
     function* takeAnswerSegmentOnIdle() {
-        // L-310:准入判的是**提交本体真要交的那份**(封存段 + 当前段),不是只看当前段 ——
-        // 否则「定稿段已封存、当前段还空着」那一拍会被判成没东西可交,把已定稿的正文继续押着。
         const body = segmentSealed + answerSegment;
         if (body.length === 0)
             return;
@@ -259,7 +114,6 @@ export function createTextStream(ctx, idOf) {
         idleFlushUsedInSegment = true;
         yield* emitAnswerSegment();
     }
-    /** 合并后的活体增量下泄(cli drainLive:思考先于文本 = 持久臂序)。 */
     function* drainLive() {
         if (thinkingPending.length > 0) {
             const opening = !thinkingBlockOpen;
@@ -277,9 +131,6 @@ export function createTextStream(ctx, idOf) {
         if (textPending.length > 0) {
             const opening = !textBlockOpen;
             textBlockOpen = true;
-            // B3:cli 的 `SEMA_STREAM_PROBE` 文件探针换成 ctx.probe 口(体检 #5 同款用途:Ink 挂载后
-            // console 被吞,harness 只能靠这条证明「引擎是**逐 token 增量**到的」而不是整块一次性 dump)。
-            // 载荷格式与 cli 逐字同形,只把 Date.now() 换成 ctx.now()(注入时钟纪律)。
             ctx.probe?.('stream', `${ctx.now()} text_flush len=${textPending.length}`);
             yield chrome({
                 kind: 'stream_delta',
@@ -294,12 +145,10 @@ export function createTextStream(ctx, idOf) {
     }
     return {
         *feedText(delta, frame) {
-            // MOD-1 思考→回答边界:回答一起头就把思考块 committed 上屏(它推理的内容之前)。
             if (thinking.length > 0 || thinkingPending.length > 0) {
                 yield* drainLive();
                 yield* takeThinking();
             }
-            // L-310:已封存的定稿段也算「这条消息已经开了头」⇒ 锚不重置(同流重放同 id)。
             if (answerSegment.length === 0 && segmentSealed.length === 0)
                 segmentAnchor = frame;
             if (segmentWindowAnchor === null)
@@ -311,8 +160,6 @@ export function createTextStream(ctx, idOf) {
         *feedThinking(delta, frame) {
             if (segmentWindowAnchor === null)
                 segmentWindowAnchor = frame;
-            // CC-14:定稿块还押着、下一段增量直接叠上来(中间无提交边界)⇒ 先按它自己的段提交,新块另起;
-            //    两段推理绝不同行(同行 = 下一段 end 的归属会把上一段定稿一并换掉)。
             if (thinkingSettled) {
                 if (thinking.length > 0) {
                     yield* drainLive();
@@ -324,10 +171,6 @@ export function createTextStream(ctx, idOf) {
             }
             if (thinking.length === 0) {
                 thinkingAnchor = frame;
-                // CC-11:新一块开始**不**清对照物(修前这里清了 —— 跨工具卡的推理段只剩末条归属,cli 接入回执 ② 实抓);
-                //    对照物只在 `reasoning_end` 用过之后清(段界由引擎说了算),turn 结束整只丢,天然有界。
-                // P2d:elapsed 锚在**首条** leader 推理增量(token 累计由 stream_delta.estimatedTokens
-                // 承载,宿主自加;>30s 无增量的 stall 提示同样由宿主按增量时间戳判)。
                 yield chrome({ kind: 'thinking_activity', laneProof: mainLane(), active: true });
             }
             thinking += delta;
@@ -339,28 +182,7 @@ export function createTextStream(ctx, idOf) {
         takeAnswerSegmentOnIdle,
         replaceAnswerSegment: (content, anchor) => {
             const prevSegment = answerSegment;
-            /**
-             * 本段**已经撤不回**的那一截 = 包侧边界带走的(可能跨了工具卡 / 消息划界,见
-             * {@link previousSegmentCommitted})+ 本消息内 idle-flush 掉的。
-             * 🔴 **两本账必须相加,不是二选一**(异源对抗复审轮二 finding① 实抓):修前只在「当前缓冲
-             *    全空」时才去读前一本,于是 `delta(含凭据) → 工具卡 → 同段后续 delta → text_end` 这条
-             *    **openai 车道真实交错**(brain 持续累加文本直到 `finalize`,而 streamingToolExecution
-             *    允许工具先执行)上,卡前那截明文**不算进前缀** ⇒ 两个前缀键双双缺席、旧明文消息留存,
-             *    而权威全文又被完整提交一次(同一段话上屏两遍 + 明文没人清)。实测复现过。
-             */
             const livePrefix = previousSegmentCommitted + segmentCommitted;
-            /**
-             * 🔴 **判决单源**(L-318,0.68.2):六形判据整只让位给 `adapt/textSegmentAuthority.ts` 的
-             *    {@link resolveTextSegmentAuthority} —— 与 `-p` 形车道(宿主的 CC stdout 投影器)吃的是
-             *    **同一只**。修前这里是本包这一份,壳里另有逐形对照的第二份(cli 1.0.114 B-122 热修),
-             *    上游改口时两边各走各的。判据语义**逐字未变**:
-             *      · 形 (f)「本层一个字节都没经手」⇒ `form: 'untouched'`,三位全报否;
-             *      · `diverged` = 缝出来的那一段 ≠ 权威全文;
-             *      · `committedPrefixLen` = 已撤不回那一截的 UTF-16 长度;
-             *      · `committedPrefixDiverged` 锚 `content.startsWith(前缀)`(不锚「有没有 flush 过」)。
-             *    **落账仍归本模块**:下面的 handOffOnly / 活体尾巴重算 / 封存 / 补差账同步,一行未动
-             *    (两条车道的账本形状不同,理由见 textSegmentAuthority.ts 头注「判决与落账刻意分家」)。
-             */
             const verdict = resolveTextSegmentAuthority(content, {
                 committedPrefix: livePrefix,
                 openSegment: prevSegment,
@@ -372,17 +194,11 @@ export function createTextStream(ctx, idOf) {
             const diverged = verdict.diverged;
             const committedPrefixLen = verdict.committedPrefixLen;
             const committedPrefixDiverged = verdict.committedPrefixDiverged;
-            // CC-16:本窗口已提交行的归属一次交全(用过即清;轮换也清)。`[]` 是正面事实,不是缺席。
             const rowsAll = committedTextRows;
             committedTextRows = [];
-            // B-133 / CC-29(0.71.2):行 uuid 由 wire 帧 uuid 派生,只有上游帧 uuid 重复才会让两条行同 uuid;端按 uuid 找行,
-            //    重复 = 归属**说不出** ⇒ 整键缺席(形 f),且不交 committedRows、不清尾巴不同步账(退回零经手行为)。
-            //    不去重、不取首:任一种都是替上游把「两条行一个身份」这件事湮灭掉。
             const uuidsUnique = new Set(rowsAll.map((r) => r.uuid)).size === rowsAll.length;
             const rows = uuidsUnique ? rowsAll : [];
             const rowUuids = rows.map((r) => r.uuid);
-            // 只有「已提交前缀自己也过期」这一形端才有东西要写回:首行 = 前段定稿前缀 + content(混合行的上一段正文保住),
-            // 其余行清空(它们的字节全在 content 里)。b1 形已提交行本来就对,不给;形 (a) 零行,不给。
             const committedRowsOut = committedPrefixDiverged && rows.length > 0
                 ? rows.map((r, i) => ({ uuid: r.uuid, text: i === 0 ? r.sealedPrefix + content : r.sealedPrefix }))
                 : undefined;
@@ -393,54 +209,12 @@ export function createTextStream(ctx, idOf) {
                     ...(committedRowsOut !== undefined ? { committedRows: committedRowsOut } : {}),
                 }
                 : {};
-            /**
-             * 🔴 **段跨过包侧边界、而且已提交那截自己也过期** ⇒ 本模块**一个字节都不动**(只发信号)。
-             *
-             * 理由是**不许把一条既有行为改坏**(异源对抗复审轮五 finding② 实抓,基线对照确认):这一形下
-             * 那一截的字节在**别的** assistant 消息里,而本模块能动的只有当前这条 —— 清掉未提交尾段会让
-             * `lastCommittedAnswerText` 回退到上一条,`result` 臂据它落第④臂**补吐一整段**;而 e4cd371
-             * 基线上同一条时序只是提交那截尾段 + 落第⑤臂报一行分岔(不补吐)。⇒ 清空在这里是**新增**的
-             * 重复转录路径,不是「更安全」。
-             * ⇒ 分界线一句话:**整段都在自己手里(同一条消息内)时才改自己交的字节;段一旦跨过包侧边界,
-             *    就只发信号、不动任何既有行为**。宿主照三个键把那截过期前缀换掉,其余与 0.68.0 逐字相同。
-             */
             const handOffOnly = committedPrefixDiverged && previousSegmentCommitted.length > 0;
             if (handOffOnly) {
-                // ── CC-17(0.70.1,cli 接入回执两形;整链实测复现)────────────────────────────────────
-                // 🔴 「只发信号」曾被写成「两本账一行都不动」,那是**漏账**不是克制:权威全文这一刻已经
-                //    交给宿主去换了,包却还按「屏上只有那截原始前缀」继续算,于是
-                //      形一(卡后有增量):`answerSegment` 里那截**原始未脱敏**尾段照常被 `takeAnswerSegment`
-                //        提交上屏落盘 —— 它属于一个已经作废的段,宿主换的是**另一条**消息,没人会来清它;
-                //      形二(卡后零增量):`lastCommittedAnswerText` 回退到上一条消息的原始正文,`result` 臂
-                //        的第④臂据此把尾段当「屏上缺的后缀」再吐一遍(终帧未脱敏时连字节都残留)。
-                // ⇒ 同步两本补差账(前缀落在哪本就换哪本,`endsWith` 守卫不匹配就不动,与非跨界形逐字同律)
-                //    + 清掉本段还没交出去的那一截。**仍然一个字节都不新交**(不铸任何消息):那些字节在别的
-                //    消息里,宿主按三键换;本分支改的只是「包自己以为屏上有什么」。
-                // 🔴 旧注释(异源复审轮五 finding②)说「清未提交尾段会让 `lastCommittedAnswerText` 回退 ⇒
-                //    第④臂补吐一整段」—— 那个后果的**前提正是账没同步**;上面一行同步之后前提消失。这句话
-                //    不是推理,是判据:`run-text-segment-authority-test.mjs` 的 Y4 就跑那条时序。
-                // 🔴 **只在「宿主确定会把某一整条换成 `content`」时才认账**(收窄,实测逼出):这两本账是
-                //    **按消息**记的,而 `livePrefix` 可能跨了**多条**消息(两个工具卡 ⇒ 段身份覆盖多行)。
-                //    那一形下宿主自己也换不了(段身份对上多行 = 归属歧义,端按「证明不了就不动手」整发放弃),
-                //    包若照样清账清尾段,`lastCommittedAnswerText` 会回退到中间那条,`result` 臂反而从第⑤臂
-                //    (只报分岔)掉进第④臂(补吐一整段)—— 那正是轮五 finding② 抓到的**新增重复转录路径**,
-                //    实测确认过(D35/D36 两格钉的就是它)。⇒ 对不上就退回 0.68.0 行为:只发信号,一个字节不动。
-                //    多行跨界那一形的正解是把整段归属交全(`committedUuids[]`,CC-16),不是包单方面清。
-                // 🔴 CC-16 `committedRows` 起(异源对抗复审第 2 轮 finding①):多行跨界的归属**已经交全**、端按行写回
-                //    (首行 = 前缀 + content、其余行空)⇒ 上面那句「对不上就一个字节不动」的前提消失 —— 再把本段
-                //    原始尾巴提交成又一条,就是重复正文 + 未脱敏残留。所以 `syncedBook === null` 而 `committedRows`
-                //    已交出时,两本账按**端写回后的屏**同步(最后一行 = 当前消息那本,首行 = 上一条真有正文的那本),
-                //    尾巴照清;`result` 臂拿到的 `lastCommittedAnswerText` 就是权威全文,落第③格不补吐(Z9 钉)。
-                // 🔴 第 4 轮 finding①:`committedRows` 在场时**一律**按消息分组重建(行归属确定,零启发式);`endsWith` 快捷分支只在
-                //    零行(没有行归属可用)时回退 —— 重复正文(两条消息都是「Intro. 」)会让 endsWith 误命中、跳过重建,消息二那本账没清 ⇒ 终帧再补一次。
                 let booksSynced = false;
                 if (!uuidsUnique) {
-                    // B-133 / CC-29:重复 uuid ⇒ 归属说不出 ⇒ **一个字节不动**:既不进分组重建,也不走 endsWith 回退(复审实抓:回退会把
-                    //    previousCommittedText 同步成从未提交的权威全文,再把尾段清掉 —— 端按缺席契约零写回,尾段就此消失)。
                 }
                 else if (committedRowsOut !== undefined) {
-                    // 按**消息**重建(第 3 轮 finding②):一条消息的正文 = 窗口之外已独立提交的那截(`msgTextBefore`)+ 该消息里
-                    //    各行写回后的正文;只按首行写回正文重建会丢掉独立提交的定稿前缀,终帧再落第⑤臂误报分岔。
                     const groups = new Map();
                     rows.forEach((r, i) => {
                         const g = groups.get(r.msgSerial) ?? { before: r.msgTextBefore, parts: [] };
@@ -458,8 +232,7 @@ export function createTextStream(ctx, idOf) {
                         if (txt.length > 0)
                             lastNonEmpty = txt;
                     }
-                    // 当前消息不在窗口里却有已提交字节 ⇒ 那是本段之外的东西,不动(`currentTouched` 为假时只同步「上一条」那本)。
-                    if (!currentTouched && committedText.length > 0) { /* 保持 */ }
+                    if (!currentTouched && committedText.length > 0) { }
                     if (committedText.length === 0 && lastNonEmpty.length > 0)
                         previousCommittedText = lastNonEmpty;
                     booksSynced = true;
@@ -481,8 +254,6 @@ export function createTextStream(ctx, idOf) {
                     answer = answer.slice(0, answer.length - liveSegment.length) + content;
                 }
                 if (booksSynced) {
-                    // 活体面:本段还押着没吐的那一截也作废(`textPending` 是段缓冲的后缀,前面那截 `carry`
-                    // 属于上一段,与本次替换无关 ⇒ 原样留)。
                     const staleTailLen = Math.min(textPending.length, prevSegment.length);
                     textPending = textPending.slice(0, textPending.length - staleTailLen);
                     answerSegment = '';
@@ -492,74 +263,37 @@ export function createTextStream(ctx, idOf) {
                 idleFlushUsedInSegment = false;
                 return { diverged, committedPrefixLen, committedPrefixDiverged, ...attribution };
             }
-            // ── ① 活体面:已泄出去的那一截撤不回 ⇒ 尾巴按替换后的段重算(判据见接口注「活体面」段)──
-            //    `textPending` 是段缓冲的**后缀**;工具卡边界只提交不 drain,所以它也可能还押着**上一段**
-            //    的尾巴(那一截与本次替换无关,原样留着)。
             const segTailLen = Math.min(textPending.length, prevSegment.length);
             const carry = textPending.slice(0, textPending.length - segTailLen);
             const emittedForSegment = livePrefix + prevSegment.slice(0, prevSegment.length - segTailLen);
             textPending = content.startsWith(emittedForSegment)
                 ? carry + content.slice(emittedForSegment.length)
                 : carry;
-            // ── ② 转录面:**封存**这一段的定稿正文,`answerSegment` 清空给下一段用 ──────────────────
-            //    🔴 清空是轮一 finding② 的修复本体:不清空的话,下一段的 delta 会接着往同一个缓冲里加,
-            //    然后被下一帧的 `content` 整段覆盖 —— 上一段的正文凭空消失(anthropic 车道逐块发
-            //    `text_end`,这条时序是常态)。封存**不切消息**:段提交本体交的是 `sealed + segment`。
-            //    🔴 `committedPrefixDiverged` 那一形**一个字节都不交**(统一规则,见接口注):已提交的
-            //    那截撤不回,而切片拼不出 `content` —— 再补一条就是同一段话上屏两遍;该段唯一算数的
-            //    那一份在帧上,由宿主按 `committedPrefixLen` 指的那一截换掉(单位见回执头注)。
             if (committedPrefixDiverged) {
-                // 🔴 **同步终答补差账 —— 但只在「整截都在当前这条消息里」那一形**(轮三 finding② 采纳,
-                //    轮四 finding①② 收窄)。这一形下本包不交正文,而屏上那一段在宿主照契约换过之后**就是**
-                //    `content`;补差账若还留着旧的那一份,`result` 臂会把权威全文当成「屏上缺的后缀」
-                //    再渲一遍(第④臂),正好违反三处文案承诺的「不再交正文」。
-                //
-                // 🔴 **为什么只同步这一形**(轮四两条 finding 的根因,记明免得下一棒又去「补全」它):
-                //    段跨过包侧边界(工具卡 / 消息划界)时,这一截的字节落在**别的** assistant 消息里,而
-                //    `committedText` / `previousCommittedText` 是**按消息**记的两本账 —— 把 `content` 往当前
-                //    这本账上写,就等于把上一条消息的正文算进当前这条:轮四实测 ① 迟到边界那一形会让随后
-                //    正常的 B 段被误报 `result_text_diverged`、甚至把该补的后缀压掉;② 同段跨两张卡时
-                //    `previousCommittedText` 只留得下最后一条,守卫直接不成立、同步静默跳过。
-                //    ⇒ 跨消息那几形**不碰账**。代价如实认领:那里的补差基线与「宿主换过之后的屏」对不齐,
-                //    `result` 可能落第④臂补一截或落第⑤臂报一行 `result_text_diverged` —— 而这两者
-                //    **都是本批之前就有的行为**(主树 0.68.0 上同一条时序实测同形:卡后有散文时
-                //    `lastCommittedAnswerText` 取的就是卡**之后**那一条,终帧却是整条消息的全文)。
-                //    根因是「包按自己的边界切消息、引擎按 content block 切段」这两套边界对不齐,根治 =
-                //    「每个引擎段各自一条 committed 消息」(= CC 原生做法),那是分段行为改动,单独走。
                 if (committedText.endsWith(livePrefix)) {
                     committedText = committedText.slice(0, committedText.length - livePrefix.length) + content;
                 }
             }
             else {
-                // L-318:尾段切片也走判决那一份(`content.slice(committedPrefixLen)` 逐字等价),
-                // 免得「怎么切」这件事在两条车道上各留一个算式。
                 segmentSealed += verdict.tail;
             }
             answerSegment = '';
-            // ── ③ `answer`(D8 调试行的长度读位)跟着换尾 —— 只在尾巴真对得上时换 ──────────────────
-            //    `appendAnswer`(durable 整条腿)会往同一个累加器里加字,那一形下本段已经不是它的后缀;
-            //    猜着改一个诊断计数器比让它原样更坏,所以对不上就不动(它只喂 `answerLen=` 那一行)。
             if (answer.endsWith(liveSegment)) {
                 answer = answer.slice(0, answer.length - liveSegment.length) + content;
             }
-            // 段锚缺席(整段已被 idle 提交光、或整段零 delta)才用本帧兜底 —— 在场**不覆盖**,
-            // 否则同一条流重放两次会拿到两个不同的 committed 消息 id(replay-id 不变量)。
             if (segmentAnchor === null && anchor !== undefined)
                 segmentAnchor = anchor;
-            // ── ④ 段账收口:这一段由引擎明说已经写完 ⇒ 两本前缀账都归零、idle 配额重开 ──────────────
             segmentCommitted = '';
             previousSegmentCommitted = '';
             idleFlushUsedInSegment = false;
             return { diverged, committedPrefixLen, committedPrefixDiverged, ...attribution };
         },
         hasPendingContent: () => thinking.length > 0 ||
-            // L-310:已封存的定稿段同样是「有已生成未提交的内容」(不算进来会让它一直押到 turn 收口)。
             segmentSealed.length > 0 ||
             answerSegment.length > 0 ||
             thinkingPending.length > 0 ||
             textPending.length > 0,
         *maybeFlushOnBeat(nowMs) {
-            // COALESCER 节拍:一个间隔至多一次 flush(同步 SSE 突发先攒着,过闸再一次泄干)。
             if ((textPending.length > 0 || thinkingPending.length > 0) && nowMs - lastFlushAt >= flushEveryMs) {
                 yield* drainLive();
                 lastFlushAt = nowMs;
@@ -574,33 +308,25 @@ export function createTextStream(ctx, idOf) {
                 committedText += committed;
         },
         replaceThinkingSegment: (content) => {
-            // CC-11:段 = 段内**全部**已提交思考行(按序)+ 还押着的缓冲。分歧按整段拼文比;归属一次交出全部 uuid。
             const rows = committedThinking;
             committedThinking = [];
             const prefix = rows.map((r) => r.text).join('');
             const uuids = rows.map((r) => r.uuid);
             const last = uuids.length > 0 ? uuids[uuids.length - 1] : undefined;
-            // (f) 本包没经手过这一段(durable 整块臂铸过 transcript 行 / 宿主只喂 end)。
             if (prefix.length === 0 && thinking.length === 0) {
                 return { diverged: false, committedPrefixLen: 0, committedPrefixDiverged: false };
             }
             const live = prefix + thinking;
             const diverged = live !== content;
             if (prefix.length === 0) {
-                // (a) 全部还押在缓冲里:整块换,活体尾巴按已泄前缀重算。
                 const emitted = thinking.slice(0, thinking.length - thinkingPending.length);
                 thinkingPending = content.startsWith(emitted) ? content.slice(emitted.length) : '';
                 thinking = content;
                 thinkingSettled = content.length > 0;
-                // CC-15(0.69.3,cli 接入回执):形 (a) 透传 `committedUuids: []` —— **在场但空** = 本包判定「本段零已提交行」
-                //    的正面事实;整键缺席只留给形 (f)(本包零经手,说不出)。壳靠这条才能不自己数窗口里过境的行
-                //    (那会把上一段迟交行 / durable 行数进去 = 假披露)。
                 return { diverged, committedPrefixLen: 0, committedPrefixDiverged: false, committedUuids: [] };
             }
-            // (b) 有已提交行(一条或跨卡多条):已提交那截撤不回。
             const committedPrefixDiverged = !content.startsWith(prefix);
             if (!committedPrefixDiverged) {
-                // (b1) 已提交前缀逐字对得上 ⇒ 只换还押着的尾段(跨卡后段);`thinking` 为空时零字节可换,只报归属。
                 if (thinking.length > 0) {
                     const tail = content.slice(prefix.length);
                     const emitted = thinking.slice(0, thinking.length - thinkingPending.length);
@@ -610,7 +336,6 @@ export function createTextStream(ctx, idOf) {
                 }
                 return { diverged, committedPrefixLen: prefix.length, committedPrefixDiverged: false, ...(last !== undefined ? { committedUuid: last } : {}), committedUuids: uuids };
             }
-            // (b2) 已提交那截自己也过期 ⇒ 一个字节都不再交(还押着的尾段清掉,别让它落成第二份),整段归宿主换。
             thinking = '';
             thinkingPending = '';
             thinkingAnchor = null;
@@ -619,7 +344,7 @@ export function createTextStream(ctx, idOf) {
         },
         segmentId: segmentIdNow,
         rotateSegmentIdentity: (anchor) => {
-            committedTextRows = []; // CC-16:窗口结束,本窗口的行账整只清(常态段定稿行随后提交 ⇒ 属下一窗口)
+            committedTextRows = [];
             segmentWindowSerial += 1;
             segmentWindowAnchor = anchor;
             segmentIdCache = null;
@@ -627,8 +352,6 @@ export function createTextStream(ctx, idOf) {
         stampSegmentIdentity: (out) => {
             if (out.plane !== 'transcript')
                 return out;
-            // ⚠️ 局部名刻意不叫 `msg`/`content`:message-branching 门把 `msg.message` 读成「错误文案」,
-            //    并按名字把污染扩到整个文件 —— 同名的 `content.startsWith` 会被误判成按文案分支。
             const row = out.message;
             if (row.type !== 'assistant')
                 return out;
@@ -646,8 +369,6 @@ export function createTextStream(ctx, idOf) {
             if (committedText.length > 0)
                 previousCommittedText = committedText;
             committedText = '';
-            // L-310:新消息开始 = 旧段的已提交前缀与**新**段无关 ⇒ 本段账归零;同 takeAnswerSegment,
-            // 归零前记进 `previousSegmentCommitted`(迟到的 `text_end` 还要拿它算分歧)。
             previousSegmentCommitted += segmentCommitted;
             segmentCommitted = '';
         },

package/dist/adapt/toolCards.d.ts

@@ -1,30 +1,5 @@
-/**
- * adapt/toolCards.ts — M2 **工具卡台账**(A 族拆分 REF-CC-SPLIT-03;矩阵 §1.2 三行状态)。
- *
- * 收编 `pending`(开卡表)/ `assistantResponseId`(S1 per-RESPONSE id)/ `lastLiveTodos`
- * (TodoWrite 划删线 diff 的 oldTodos)三行状态 + C4 mintResponseId / C10 buildToolResult /
- * C11 sweepOpenCards 三个闭包 + `PendingToolUse` 形本身。
- *
- * 🔴 拆分硬约束(SPLIT-03,复审结论 2 采纳形):**S1 复位在 `close()` 内部、第一个 `yield`
- *   之前**。理由是生成器语义 —— yield 之后的语句只有消费者再要下一个值时才跑,消费者早退
- *   (`it.return()` / break)时永不执行。把复位留在调用方,调用方就还能写出「yield 后复位」的形;
- *   收进被调方之后,这条时序由**一处**保证。原 `tool_end_result` 臂 :1054-1056(delete → 复位 →
- *   yield)与 sweep :743-747 是同一个三步,现在是同一段代码。
- *
- * 🔴 同批把 assistant 臂 reject/cancel(:970)与 error(:990)两条路径的复位**前移到各自 yield 之前**
- *   —— 矩阵 §2.2 的定性:那两处是**形不一致的技术债、不是缺陷**(`assistantResponseId` 是 L1
- *   turn 级,两行之后紧跟 `break`,早退时生成器已死、再无读者 ⇒ 零可观测后果),所以前移是
- *   **纯一致性改动、零行为差**。反钉见矩阵 §2.2:前移不影响 mint —— 影响窗口只有
- *   「复位语句与原复位点(yield 之后)」之间那几行,窗口内无 mint 点;三条支随即退出本臂,
- *   后续帧的 mint 走各自臂的常规路径,与拆分前同(对抗复审校准:break 退出的是臂不是 turn)。
- *
- * 🔴 `pending` 是唯一跨 M2→M3 的数据面(矩阵 §1.2 注):面板族只读两个字段(`name` 判
- *   SUBAGENT_TOOL_NAMES / `rawInput` T50 双形读)。所以对外给的是 `OpenCardView` **只读视图**,
- *   不交 Map 本体 —— 交出去 M3 就能 `delete`,而「一张开卡一条 tool_result」是本模块的不变量。
- */
 import type { AdapterContext, AdapterOutput } from '../seam.js';
 import { type Frame, type IdOf } from './ids.js';
-/** 一张开着的卡(assistant tool_use 臂开、tool_end_result 臂关)。 */
 export interface PendingToolUse {
     id: string;
     name: string;
@@ -32,18 +7,6 @@ export interface PendingToolUse {
     eventId?: string;
     parentToolCallId?: string;
 }
-/**
- * `tool_end_result` 帧上**与关卡有关的那几位**(原 `buildToolResult` 的内联入参形,具名化)。
- *
- * 🔴 本形**不是** `tool_end_result` 臂的镜像,是它的**关卡切片** —— 只收「铸这张 tool_result 卡真正
- * 要读的位」。臂上另有若干**开集观察位**按设计**不进本形**:`errorCode`(core 5.9.0 W3)、
- * `gate`(整条门记录,engine ≥7.64.0 / sdk 8.4.0 —— 取代退役的四个正交词)、`delivered`
- * (MCP 投递判词,core ≥7.6.0)、`gatedCallId`(core ≥5.55.0)。它们由
- * `eventToSdkMessage` 的 `case 'tool_end'` 臂原样上臂、由**宿主/桥**直接从臂上读(壳 upstreamBridge、
- * print 车道 {@link import('../printToolResultFrame.js').ToolEndResultArmLike}),卡台账一位都不消费。
- * 往本形加一个没有落点的键 = 一句「关卡会用到它」的假话(声明与产物对不上,且没有任何门会响);
- * 真要让转录卡带上结算归属,那是一件**新的呈现设计**(需定 `_sema_` 超集键 + 台账登记),不是透传。
- */
 export interface ToolEndPayload {
     output?: unknown;
     structured?: unknown;
@@ -52,25 +15,16 @@ export interface ToolEndPayload {
     eventId?: string | undefined;
     parentToolCallId?: string | undefined;
 }
-/** 交给面板族(M3)的**只读**视图 —— 不含任何写口。 */
 export interface OpenCardView {
-    /** 这张卡此刻还开着吗(#6 live vs inert 的判位)。 */
     has(id: string): boolean;
-    /** 读卡(面板族只用 `name` 与 `rawInput` 两个字段)。 */
     peek(id: string): PendingToolUse | undefined;
-    /** 按**开卡顺序**遍历(FIFO 猜父臂依赖这个顺序)。 */
     entries(): Iterable<readonly [string, PendingToolUse]>;
 }
 export interface ToolCardLedger extends OpenCardView {
-    /** 开卡(assistant tool_use 臂)。 */
     open(p: PendingToolUse): void;
-    /** 关一张卡:出栈 + S1 复位 + 铸 tool_result(三步都在第一个 yield 之前完成前两步)。 */
     close(p: PendingToolUse, end?: ToolEndPayload): Generator<AdapterOutput>;
-    /** 关掉所有还开着的卡(流被截断 / 无 result 收尾;abort 路径**不做**)。 */
     sweep(): Generator<AdapterOutput>;
-    /** S1:per-RESPONSE 铸 id(同一个 model response 内的多张卡共用)。 */
     mintResponseId(frame: Frame): string;
-    /** S1:一个结果关闭该 model response(reject/cancel/error 三支的显式复位口)。 */
     resetResponseId(): void;
 }
 export declare function createToolCardLedger(ctx: AdapterContext, idOf: IdOf): ToolCardLedger;