@sema-agent/client-core 0.77.1 → 0.77.2

package/dist/engineAgentPanelStore.js

@@ -1,45 +1,10 @@
-/**
- * ⇄ B1 批搬迁(2026-07-27,多端改造设计稿 §2.4.1-B):cli src/sema/engineAgentPanelStore.ts 逐字搬入(零 import;壳侧改 re-export)。
- * 🔴 同 subagentContentStore:buffer/listener/residentTaskIds 是单实例语义,发布侧(bridge/fleet
- * 投影)与订阅侧(chrome-agentprogress 的面板 hook)必须同实例,否则事件发进一个副本、面板订另一个。
- */
-/**
- * engineAgentPanelStore — dep-free side-channel store bridging ENGINE-side subagent progress
- * (`task_progress` ticks, design/99 MF-10) to CC's CoordinatorTaskPanel (the footer live-agent panel).
- *
- * WHY A STORE (the retryStatusStore / liveQuestionStore pattern): the upstream bridge is a plain
- * generator with no React/AppState access, while the panel reads `AppState.tasks` — so the bridge
- * PUBLISHES neutral events here and a sema-owned hook inside chrome-agentprogress.tsx (already mounted
- * under the footer) SUBSCRIBES and applies them to AppState via registerTask/updateTaskState. CC files
- * stay verbatim; the AppState write side lives in the sema override that owns the panel.
- *
- * WHY THE PANEL (CC-187 parity): a local sync AgentTool renders an inline progress TRAIL from the
- * subagent's real messages. An engine tick carries ONLY rollup numbers ({toolUses, totalTokens}) — the
- * exact shape of CC's `AgentProgress` — and CC's own precedent for out-of-process agents (remote agent
- * tasks) is the TASK PANEL + task-notification, not a synthetic inline trail. Faithful mapping, no
- * fabricated subagent messages.
- *
- * Buffering: ticks published before the panel mounts are buffered (bounded) and replayed to the first
- * subscriber, so early frames in a fast turn aren't lost to mount timing.
- */
 import { retirePanelRowRunning, notePanelRowEnded, panelRowEndedIdentity, peekHeldNewbornTerminalRow, takeHeldNewbornTerminalRow, dropHeldNewbornTerminalRow, heldNewbornTerminalRefs } from './panelRunningHistory.js';
 const _panelToolUsesLanePins = [true, true];
 void _panelToolUsesLanePins;
-/**
- * 两条 lane 对 `toolUses` 的口径(运行期读面,给门用;上面的编译钉保证它没在撒谎)。
- * `required-engine-always-emits` = 缺席不可达 ⇒ 兜底值合法;
- * `optional-tolerate-absent`     = 缺席即「不知道」⇒ 必须传播缺席(键不落)。
- */
 export const PANEL_TOOLUSES_LANE_POLICY = {
     tick: 'required-engine-always-emits',
     'fleet-row': 'optional-tolerate-absent',
 };
-// ── #6(frame-lane-matrix)session 常驻行台账 ─────────────────────────────────────────────────
-// 行寿命 ≠ turn 寿命:跨 turn 存活的 bg 子代行(tick 绑不到本 turn 开着的卡 = inert/unbound)不该被
-// turn 末防御 sweep(bridge settlePanelTasks(null) / seamQuery 'sweep' 事件)结成假 completed——一旦
-// 假结,消费端 tick 门(status!=='running' ⇒ return prev)会把后续真 tick 全丢,真终态(failed)也
-// 改不动(冻死)。台账 module-level(publisher=bridge 按绑定活性写;两个 sweep 消费点按它跳过;
-// 真终态通知(task_notification 帧 / enqueueBgChildNotification 合成)settle 时摘除)。
 const residentTaskIds = new Set();
 export function markEnginePanelTaskResident(taskId) {
     residentTaskIds.add(taskId);
@@ -53,19 +18,11 @@ export function isEnginePanelTaskResident(taskId) {
 const MAX_BUFFER = 200;
 let listener = null;
 const buffer = [];
-/** 两条 fleet-row 都带同一种周期身份(launch 锚 / 代际号)且不相等 ⇒ 新周期(任一条没带 = 这一帧没说,不算变化)。 */
 function launchAnchorChanged(prev, next) {
     if (prev.kind !== 'fleet-row' || next.kind !== 'fleet-row')
         return false;
     return isNewEngineAgentPanelCycle(prev, next);
 }
-/**
- * 0.74.5 CC-87 —— 「这一帧是不是**新周期**」的单源判据(`isStaleEngineAgentPanelEnd` 的对偶,壳侧此前各拼一份):
- *   · 两边都带 `cycleSeq` ⇒ **只**比它:不等 ⇒ 新周期;
- *   · 否则两边都带 `startedAt` ⇒ 不等 ⇒ 新周期;
- *   · 任一边判不出 ⇒ **不是**新周期(这一帧没说,不算变化 —— 方向与陈旧判据相同:缺席不制造周期)。
- * 与缓冲合并屏障(`launchAnchorChanged`)同一条规则;消费端在 `fleet-row` 到时拿行上记的身份与帧上的身份调它。
- */
 export function isNewEngineAgentPanelCycle(prev, next) {
     const pc = cycleSeqOf(prev);
     const nc = cycleSeqOf(next);
@@ -83,15 +40,6 @@ function startedAtOf(v) {
     const n = v?.startedAt;
     return typeof n === 'number' && Number.isFinite(n) && n > 0 ? n : undefined;
 }
-/**
- * 0.74.0 —— 这条 `end` 是不是**上一周期迟到的**(单源判据,三端共用)。`current` = 消费端记在行上的当前周期
- * (取自最近一条 `fleet-row` 的 `cycleSeq` / `startedAt`)。
- *   · 两边都有 `cycleSeq` ⇒ **只**比它:`end` 更小 ⇒ 陈旧;
- *   · 否则两边都有 `startedAt` ⇒ `end` 更早 ⇒ 陈旧;
- *   · 任一边判不出(流内 close 臂的 `end` / 没有代际概念的行 / 老引擎 / 坏形)⇒ **不陈旧** —— 按现行为 settle。
- *     方向是宁可照旧也不因为缺席丢掉一条真终态。
- * 陈旧的 `end`:忽略(不 settle、不写 report、不摘所有权)。
- */
 export function isStaleEngineAgentPanelEnd(end, current) {
     const ec = cycleSeqOf(end);
     const cc = cycleSeqOf(current);
@@ -103,51 +51,16 @@ export function isStaleEngineAgentPanelEnd(end, current) {
         return es < cs;
     return false;
 }
-// ── 0.74.3 CC-70:子代身份归一(所有 lane 的唯一漏斗)────────────────────────────────────────
-//
-// 病(cli L-407 / test 定谳,三端同撞):同一个后台子代在 wire 上有**两把身份** —— fleet 行 id 尾段(17 位,= 注册表 task_id
-// = 壳本地 agentId,core #948 按构造)与主流 `task_progress.taskId`(引擎 UUIDv7 = transcriptId = childSessionId)。本包的
-// `fleet-row` / 通知 `end` 用前者,tick / 流内 close 臂的 `end` 用后者 ⇒ 壳面板按 `ev.taskId` 落 Map 长成两行;包内常驻标也是
-// 「UUID 记、17 位清」永不清。修法 = 在这一只漏斗里把 tick / end 的 `taskId` 归一到 fleet 尾段(消费端零改):
-//   · 钥匙两把,fleet-row 一到就登记:`transcriptId → 尾段`(主)、`parentToolCallId → 尾段`(退路);
-//   · 查得到 ⇒ 改写 `taskId`,原词进 `wireTaskId`,`taskIdOrigin:'fleet-row'`;常驻标若记在 UUID 下随之迁移;
-//   · 查不到:绑卡的 tick(同步委派,`cardBound`)直发;未绑的 tick **缓一拍**等 fleet-row(常态 fleet-row 先到几十秒,但非保证)——
-//     触发 = 同 UUID 的 fleet-row 到(归一发)/ 同 UUID 第二条 tick(新的原样发,旧的丢)/ 同 UUID `end`(先 tick 后 end 原样发)/
-//     缓冲满(最旧的原样发);原样发的带 `taskIdOrigin:'wire'`。🔴 `sweep` **不放**缓着的 tick:那条 tick 还没有行,sweep 没有东西可结;
-//     在「tick 先到、父 turn 先结、行帧后到」的窗里放出去反而把 UUID 行造出来、接着行帧再造第二行 —— 正是要修的病。
-//   · 两张钥匙表与缓一拍都有界(常量),溢出先进先出 —— 上限是内存约束不是语义,超出只退化成「原样发」;
-//   · 缓一拍还按**节拍**有界(异源复审 R1 [medium]):别的 fleet-row / end / sweep 每过一条算一拍(别的 tick 不算 —— 它说明不了行帧车道
-//     活不活,一阵子代同时起步时也不该互相挤),过 MAX_HELD_WIRE_TICK_BEATS 拍还没等到自己的行帧 ⇒ 原样放(store 无计时器,拍是唯一可数的时间);
-//   · 钥匙带**周期身份**(复审 R1 [high]):行帧登记时连 cycleSeq / startedAt 一起记,归一后的 end 若自己不带周期就借钥匙上的
-//     (流内 close 臂的 end 恒不带)—— 复活后旧 transcriptId 的钥匙仍在,迟到的 end{旧 UUID} 归一后带着旧代际,
-//     isStaleEngineAgentPanelEnd 才判得出它是前代;
-//   · tick 经退路键(parentToolCallId)归一时,顺手把 UUID → 尾段 记进主表(复审 R1 [high]):随后的 end{UUID} 不带 parentToolCallId,
-//     没有这一步它永远归不了一。
-//   · 🔴 **先发布的键为准**(0.74.4 CC-83;test [7702] N-3 证伪「零改」:tick 归不了一而原样发出之后,行帧再按尾段发 = 消费端仍两行):
-//     一条 tick 已按 UUID 原样发出(第二拍 / 拍数耗尽 / 绑卡),这个子代在消费端的键就是 UUID —— 之后到的 fleet-row / fleet 侧 end
-//     改写成 UUID(原词进 wireTaskId,taskIdOrigin:'wire'),不再把尾段当第二把键发出去。消费端从此在任何到达序上都只见一把键;
-//     常态序(行帧先到)仍归一到尾段。
-//   · 🔴 前代 UUID 的迟到 tick **丢弃**(0.74.4 CC-84;test [7702] W2 tick 腿):钥匙上的周期比最近行帧旧 ⇒ 这条 progress 属已结束的
-//     周期,归一发出去会把前代的累计数写进复活行;end 有陈旧判据(消费端按周期挡),tick 没有 ⇒ 在漏斗里挡。
-/** 钥匙表上限(LRU:命中即续命,真在飞的子代不会被一阵新登记挤掉;超出只退化成「原样发」)。 */
 const MAX_IDENTITY_KEYS = 2048;
 const MAX_HELD_WIRE_TICKS = 64;
-/** 缓一拍的节拍上限:别的 fleet-row / end / sweep 每过一条算一拍(别的 tick 不算)。 */
 export const MAX_HELD_WIRE_TICK_BEATS = 16;
 const fleetIdByTranscriptId = new Map();
 const fleetIdByParentToolCallId = new Map();
 const heldWireTicks = new Map();
-/** 每个 fleet 尾段最近一条行帧带的周期身份(在场才记):清常驻标时用它判「这条终态是不是前代的」(异源复审 R3 [high])。 */
 const latestCycleByFleetId = new Map();
-/**
- * 已按 UUID 原样发出过 tick 的子代(先发布的键为准,CC-83):transcriptId(= UUID)与 parentToolCallId 两把钥匙都记。
- * 🔴 所有权表**按生命周期退役、不按容量改写**(异源复审 0.74.4 R1 [medium]):一把已发布的键在消费端就是一行,容量到了把它忘掉 =
- * 同一子代重新长成两行。所以 `retired`(收到 end)的条目先让位;都没退役时才让最旧的(上限 MAX_OWNERSHIP_KEYS,远大于同时在飞的子代数)。
- */
 const MAX_OWNERSHIP_KEYS = 8192;
 const publishedWireIds = new Map();
 const publishedWireByParent = new Map();
-/** 尾段 → 已发布的 UUID(CC-83):fleet 侧的 fleet-row / end / 缺席 到时改写成 UUID;带登记时行帧的周期,复活的新周期不继承。 */
 const wireIdByFleetId = new Map();
 function bounded(map, key, value) {
     map.delete(key);
@@ -158,7 +71,6 @@ function bounded(map, key, value) {
             map.delete(oldest);
     }
 }
-/** 所有权表的有界:退役的先让位,都没退役才让最旧的。 */
 function boundedOwnership(map, key, value) {
     map.delete(key);
     map.set(key, value);
@@ -174,14 +86,11 @@ function boundedOwnership(map, key, value) {
     if (oldest !== undefined)
         map.delete(oldest);
 }
-/** 一条 tick 按 UUID 原样发出去了:从此这个子代的键 = UUID。 */
 function notePublishedWire(ev) {
-    // 已退役的键不因一条迟到 tick 复活(异源复审 R3 [high]):退役 = 它的行已结,迟到帧落在它自己的行上,所有权不回来
     boundedOwnership(publishedWireIds, ev.taskId, { retired: publishedWireIds.get(ev.taskId)?.retired ?? false });
     if (ev.parentToolCallId !== undefined && ev.parentToolCallId.length > 0)
         bounded(publishedWireByParent, ev.parentToolCallId, ev.taskId);
 }
-/** 这把 UUID 的子代收到了终态:所有权可退役(容量满时先让位;不删 —— 迟到的同周期行帧 / end 仍要改写到它)。 */
 function retireWire(wireId) {
     const w = publishedWireIds.get(wireId);
     if (w !== undefined)
@@ -190,7 +99,6 @@ function retireWire(wireId) {
         if (o.wireId === wireId)
             o.retired = true;
 }
-/** fleet-row 对应的子代是否已经按 UUID 发布过;transcriptId 命中不看退役(同一子代的迟到行帧),parentToolCallId 只认未退役(复活会沿用同一张卡)。 */
 function publishedWireFor(ev) {
     if (ev.transcriptId !== undefined && publishedWireIds.has(ev.transcriptId))
         return ev.transcriptId;
@@ -201,16 +109,14 @@ function publishedWireFor(ev) {
     }
     return undefined;
 }
-/** 尾段今天归哪把 UUID(在场 = 这个子代已按 UUID 上屏;复活的新周期不算)。 */
 function wireOwnerOf(fleetId, current, transcriptId) {
     const o = wireIdByFleetId.get(fleetId);
     if (o === undefined)
         return undefined;
-    // 0.74.5(test [7718] 契约层反例):行帧的 transcriptId 换了 = 新一代子会话,即使两个周期键全缺 —— 所有权同样到此为止
-    const newTranscript = transcriptId !== undefined && transcriptId !== (o.transcriptId ?? o.wireId); // 父键登记没记 transcriptId 时,wireId 本身就是那一代的转录身份(复审 R3)
+    const newTranscript = transcriptId !== undefined && transcriptId !== (o.transcriptId ?? o.wireId);
     if (newTranscript || (current !== undefined && isStaleEngineAgentPanelEnd(o, current))) {
-        wireIdByFleetId.delete(fleetId); // 行帧已是更新的周期:旧 UUID 的所有权到此为止,新周期按常态登记
-        retireWire(o.wireId); // 旧周期已过:那把 UUID 退役,退路键(同一张卡)不再把新周期的行帧拉回它(异源复审 R2 [high])
+        wireIdByFleetId.delete(fleetId);
+        retireWire(o.wireId);
         return undefined;
     }
     return o.wireId;
@@ -224,14 +130,10 @@ function remember(map, key, alias) {
             map.delete(oldest);
     }
 }
-/**
- * 0.74.3 CC-70:把 wire 上的子代 id(task_progress 的 UUID)反查成 fleet 行 id 尾段;`transcriptId` 表优先,退 `parentToolCallId` 表;
- * 都查不到 ⇒ 原样(`origin:'wire'`)。fleet 尾段本身传进来也原样(它就是目标键)。
- */
 export function resolveEnginePanelTaskId(wireTaskId, parentToolCallId) {
     const byTranscript = fleetIdByTranscriptId.get(wireTaskId);
     if (byTranscript !== undefined) {
-        remember(fleetIdByTranscriptId, wireTaskId, byTranscript); // LRU 续命(异源复审 R2 [high]:FIFO 会把仍在飞的子代挤掉)
+        remember(fleetIdByTranscriptId, wireTaskId, byTranscript);
         return identityOf(byTranscript);
     }
     const byParent = parentToolCallId !== undefined ? fleetIdByParentToolCallId.get(parentToolCallId) : undefined;
@@ -249,7 +151,6 @@ function identityOf(alias) {
         ...(alias.startedAt !== undefined ? { startedAt: alias.startedAt } : {}),
     };
 }
-/** 经退路键归一的 tick:把 UUID → 尾段 记进主表,随后不带 parentToolCallId 的 end{UUID} 才归得了一。 */
 function rememberResolvedWire(wireTaskId, id) {
     if (fleetIdByTranscriptId.has(wireTaskId))
         return;
@@ -259,7 +160,6 @@ function rememberResolvedWire(wireTaskId, id) {
         ...(id.startedAt !== undefined ? { startedAt: id.startedAt } : {}),
     });
 }
-/** 别的事件过了一拍:缓着的 tick 各记一拍,过上限的原样放出(先进先出)。 */
 function ageHeld(except) {
     for (const [wireId, held] of [...heldWireTicks]) {
         if (wireId === except)
@@ -289,7 +189,6 @@ function asIsTick(ev) {
     notePublishedWire(ev);
     return { ...rest, taskIdOrigin: 'wire' };
 }
-/** 钥匙上的周期比最近行帧旧 = 这条 tick 属已结束的周期(CC-84);判不出 ⇒ 不算陈旧。 */
 function staleWireTick(id) {
     return isStaleEngineAgentPanelEnd(id, latestCycleByFleetId.get(id.taskId));
 }
@@ -305,23 +204,16 @@ function flushHeld(wireTaskId) {
     const id = resolveEnginePanelTaskId(held.ev.taskId, held.ev.parentToolCallId);
     if (id.origin === 'fleet-row') {
         if (staleWireTick(id))
-            return; // 前代周期的 progress:丢
+            return;
         rememberResolvedWire(held.ev.taskId, id);
         deliverEngineAgentPanelEvent(normalizedTick(held.ev, id.taskId));
         return;
     }
     deliverEngineAgentPanelEvent(asIsTick(held.ev));
 }
-/**
- * 0.74.3 CC-70(异源复审 R3 [high]):按 wire 上的子代 id 清常驻标 —— 原键照清;归一到 fleet 尾段的那把键**只在这条终态属当代时**才清:
- * 复活后迟到的前代终态(旧 UUID 的流内 close / 终态 tick)归一后带旧代际,清了尾段键 = 撤掉复活行的 sweep 保护 ⇒ 下一次 sweep 假结它。
- * 判据与 `end` 的陈旧判据同一只(`isStaleEngineAgentPanelEnd`,拿钥匙上的周期对最近一条行帧的周期);判不出 ⇒ 照清(不因缺席留下永久常驻)。
- * `cycle`(0.74.4):调用方(通知车道)带得出这条终态的周期时传进来 —— 尾段归某把 UUID 所有而通知比所有权旧 ⇒ 不清那把 UUID 的常驻标。
- */
 export function clearEnginePanelTaskResidentByWire(wireTaskId, cycle) {
     residentTaskIds.delete(wireTaskId);
-    const owner = wireIdByFleetId.get(wireTaskId); // 传进来的是尾段而尾段归某把 UUID 所有(通知车道)⇒ 那把键下的常驻标一起清
-    // 通知带周期(seq)且比所有权登记时的周期旧 = 前代的终态 ⇒ 不清当代 UUID 的常驻标(异源复审 R3 [high])
+    const owner = wireIdByFleetId.get(wireTaskId);
     if (owner !== undefined && !(cycle !== undefined && isStaleEngineAgentPanelEnd(cycle, owner)))
         residentTaskIds.delete(owner.wireId);
     const id = resolveEnginePanelTaskId(wireTaskId);
@@ -331,12 +223,6 @@ export function clearEnginePanelTaskResidentByWire(wireTaskId, cycle) {
         return;
     residentTaskIds.delete(id.taskId);
 }
-/**
- * 测试钩。逐表清单(每加一张表同批更新这里):① 转录钥匙表(UUID → 行尾段)② 父调用钥匙表(parentToolCallId → 行尾段)
- * ③ 缓着的未绑卡 tick ④ 每行最近一次行帧的周期水位 ⑤ 「先发布的键」集合(UUID)⑥ 同上按父调用记的那一份 ⑦ 反向所有权表(行尾段 → UUID)。
- * 🔴 不清:订阅者 / 回放缓冲、常驻标、running 历史(那一本由 `__resetPanelRunningHistoryForTests` 清)。
- * 🔴 连续场景(同一只子代跨多步的用例)**中途别调**:清掉 ④–⑦ 之后,陈旧判据与「先发布的键为准」都会从零开始,前后两半不再是同一段历史。
- */
 export function __resetEngineAgentPanelIdentityForTests() {
     fleetIdByTranscriptId.clear();
     fleetIdByParentToolCallId.clear();
@@ -346,30 +232,12 @@ export function __resetEngineAgentPanelIdentityForTests() {
     publishedWireByParent.clear();
     wireIdByFleetId.clear();
 }
-/**
- * 0.75.0 W2:一条 end 递达之前,先把投影缓着的「首见即终态」行放出来(它带这一行唯一的一份最终用量),经漏斗原路发布(身份归一照走);
- * 递达之后记「本进程结过这一行」—— 投影据此把之后到的终态行当成短命子代的收尾(照发用量)而不是历史行。两步都只对当代 end(陈旧判据与销 running 历史同一只)。
- */
-/**
- * 这一条缓行**放出去会落在哪把消费端键上**(纯读口,不动表;与 fleet-row 臂的改写次序同序:
- * 反向所有权 → 已发布的 wire 键 → 自己的行尾段)。第四条腿据它核「行与 end 是否同键」。
- * 🔴 保守方向:所有权在表里就按它答(`wireOwnerOf` 遇到新一代会把它删掉再落到下一档 —— 那一档答错只会让本腿
- *    **少放**一次,不会让一只子代分成两行)。
- */
 function heldRowConsumerKey(tail, held) {
     const owner = wireIdByFleetId.get(tail);
     if (owner !== undefined)
         return owner.wireId;
     return publishedWireFor(held) ?? tail;
 }
-/**
- * 这一条 end 对那一行缓着的终态行的**代际三向**(纯读口,不动表)。先 peek 再决定:先 take 会让前代
- * end 把当代唯一的缓行取走丢掉;
- *   · `'keep'`    = end 可证比缓行**旧** ⇒ 缓行留着(等当代的那条 end);
- *   · `'drop'`    = end 可证比缓行**新** ⇒ 缓行作废(前代的用量不许盖当代行);
- *   · `'release'` = 同代 / 判不出 ⇒ 可以放出;
- *   · `'none'`    = 这一行没有缓着的终态行。
- */
 function heldNewbornTerminalVerdict(taskId, endCycle) {
     const held = peekHeldNewbornTerminalRow(taskId);
     if (held === undefined || held.kind !== 'fleet-row')
@@ -381,19 +249,6 @@ function heldNewbornTerminalVerdict(taskId, endCycle) {
         return 'drop';
     return 'release';
 }
-/**
- * 🔴 放行前的**同键核**:这一条缓行放出去,行帧与随后那条 end 会不会落在**同一把消费端键**上?
- *
- * 反例(实测):一只子代的委派卡被复用 —— `tick{V, 卡 P}` 已按 V 上过屏;缓着的终态行是
- * `{尾段 X, 转录锚 U, 卡 P}`;来的是 `end{U}`。第四条腿按转录锚找到唯一候选 X,可它一放行就被
- * 「先发布的键为准」经卡 P 改写到 **V** 上,而这条 `end{U}` 在主路上谁也不命中、原样落在 **U**:
- * 用量记到了 V,X 的终态却发给了 U,消费端还可能凭 `end{U}` 另开一行。
- *
- * 所以只在两种形下放行(其余留着缓行,等真正属于它的那条 end —— 宁可晚交一份用量,不让一只子代分成两行):
- *   ① 行会被改写到**这条 end 自己那把键**上(随后主路也落在同一把键,`ownedFleetIds` 连带结账);
- *   ② 行按**自己的尾段**上屏,而这条 end 的键正是它的转录锚且那把键没被发布过 —— 放行登记了转录钥匙,
- *      主路随即经钥匙表归一到同一条尾段。
- */
 function heldRowReleasesOntoSameKey(tail, end) {
     const held = peekHeldNewbornTerminalRow(tail);
     if (held === undefined || held.kind !== 'fleet-row')
@@ -401,9 +256,6 @@ function heldRowReleasesOntoSameKey(tail, end) {
     const rowKey = heldRowConsumerKey(tail, held);
     if (rowKey === end.taskId)
         return true;
-    // 末一项 `!publishedWireIds.has(...)` 是**可证冗余**的写方守卫(删掉行为不变:若这把键发布过,
-    // 上面的 `heldRowConsumerKey` 就会把 rowKey 算成它、第一档已经返回 true,走不到这里)。留着是把
-    // 「② 只成立于那把键没上过屏」这句话钉在代码里,别当成活判据去删第一档。
     return rowKey === tail && held.transcriptId === end.taskId && !publishedWireIds.has(end.taskId);
 }
 function releaseHeldNewbornTerminal(taskId, endCycle) {
@@ -418,24 +270,18 @@ function releaseHeldNewbornTerminal(taskId, endCycle) {
     if (held !== undefined)
         publishEngineAgentPanelEvent(held);
 }
-/** 结算(end 已递达):running 历史销、ended 账单调写(可证比已结周期旧的 end 不倒写)。 */
 function settleRowHistory(taskId, cycle) {
     retirePanelRowRunning(taskId);
     notePanelRowEnded(taskId, cycle, isStaleEngineAgentPanelEnd(cycle, panelRowEndedIdentity(taskId)));
 }
-/** end 的陈旧判据同时参考行帧水位与 ended 账(短命子代常常没有行帧水位 —— 异源复审 R3 [high])。 */
 function endOlderThanKnown(end, taskId, rowCycle) {
     return isStaleEngineAgentPanelEnd(end, rowCycle) || isStaleEngineAgentPanelEnd(end, panelRowEndedIdentity(taskId));
 }
-/** 宿主的唯一发布口(三条 lane 都经这里):先归一身份,再进主通道(订阅者 / 缓冲)。 */
 export function publishEngineAgentPanelEvent(ev) {
-    // 行帧先登记、先放自己匹配的 tick,再给别的缓着的 tick 记拍(异源复审 R2 [high]:先记拍会让第 16 拍那条正好是自己行帧的 tick 过期);
-    // end / sweep 没有「自己的」匹配 ⇒ 先记拍。
     if (ev.kind === 'end' || ev.kind === 'sweep')
         ageHeld(ev.kind === 'sweep' ? undefined : ev.taskId);
     switch (ev.kind) {
         case 'fleet-row': {
-            // 先发布的键为准(CC-83):这个子代已经按 UUID 上过屏 ⇒ 行帧改写成 UUID 发,并记 尾段 → UUID 供 fleet 侧 end 改写;不登记尾段钥匙。
             const rowCycle = { ...(ev.cycleSeq !== undefined ? { cycleSeq: ev.cycleSeq } : {}), ...(ev.startedAt !== undefined ? { startedAt: ev.startedAt } : {}) };
             const published = wireOwnerOf(ev.taskId, rowCycle, ev.transcriptId) ?? publishedWireFor(ev);
             if (published !== undefined && published !== ev.taskId) {
@@ -463,7 +309,6 @@ export function publishEngineAgentPanelEvent(ev) {
                 remember(fleetIdByTranscriptId, ev.transcriptId, alias);
             if (ev.parentToolCallId !== undefined && ev.parentToolCallId.length > 0)
                 remember(fleetIdByParentToolCallId, ev.parentToolCallId, alias);
-            // 先发行帧再放缓着的 tick:tick 一到 fleet lane 就永久让位,行帧说的话(transcriptId / startedAt)得先落在行上。
             deliverEngineAgentPanelEvent(ev);
             for (const [wireId, held] of [...heldWireTicks]) {
                 if (wireId === ev.transcriptId || (held.ev.parentToolCallId !== undefined && held.ev.parentToolCallId === ev.parentToolCallId))
@@ -473,8 +318,6 @@ export function publishEngineAgentPanelEvent(ev) {
             return;
         }
         case 'tick': {
-            // 先发布的键为准也管 tick 自己(异源复审 R2 [high]):这把 UUID 已经是消费端的键,之后的 tick 不再经退路键归一到尾段
-            //(否则复活后同一张卡的退路键把前代 UUID 的迟到 tick 拉进新周期的行)。
             if (publishedWireIds.has(ev.taskId)) {
                 heldWireTicks.delete(ev.taskId);
                 deliverEngineAgentPanelEvent(asIsTick(ev));
@@ -484,7 +327,7 @@ export function publishEngineAgentPanelEvent(ev) {
             if (id.origin === 'fleet-row') {
                 heldWireTicks.delete(ev.taskId);
                 if (staleWireTick(id))
-                    return; // CC-84:前代 UUID 的迟到 tick 不进复活行
+                    return;
                 rememberResolvedWire(ev.taskId, id);
                 deliverEngineAgentPanelEvent(normalizedTick(ev, id.taskId));
                 return;
@@ -494,7 +337,6 @@ export function publishEngineAgentPanelEvent(ev) {
                 return;
             }
             if (heldWireTicks.has(ev.taskId)) {
-                // 第二拍还没等到 fleet-row ⇒ 不再等:新的原样发,旧的丢(progress 合并语义,旧拍没有信息)。
                 heldWireTicks.delete(ev.taskId);
                 deliverEngineAgentPanelEvent(asIsTick(ev));
                 return;
@@ -508,11 +350,6 @@ export function publishEngineAgentPanelEvent(ev) {
             return;
         }
         case 'end': {
-            // 0.75.0 W2:缓着的「首见即终态」行**先于一切归一**放出(异源复审 R3 [high]:放出的行帧会登记钥匙 / 所有权,之后的 end 归一必须看到它,
-            //    否则同一子代长成 UUID 行 + 尾段行两行)。
-            // 🔴 0.75.1 —— 前三把键的**真实射程**(实测反例):尾段本身 / UUID 经钥匙解析到的尾段 / 这把 UUID 名下的反向所有权尾段,
-            //    后两把**只在行帧真发布过时才登记**,而缓行的定义就是「还没发布」⇒ `tick{UUID}` 先上屏、终态行 `{尾段, transcriptId: UUID}`
-            //    被缓住时,这三把全查不到,缓行永远放不出。所以有第四条腿:按缓行**自带的** wire 侧键(transcriptId / 退路键)反查。
             releaseHeldNewbornTerminal(ev.taskId, ev);
             {
                 const pre = resolveEnginePanelTaskId(ev.taskId);
@@ -525,13 +362,10 @@ export function publishEngineAgentPanelEvent(ev) {
                 for (const [fleetId, o] of wireIdByFleetId)
                     if (o.wireId === ev.taskId && !o.retired)
                         releaseHeldNewbornTerminal(fleetId, ev);
-                // 第四条腿:缓着的行自带 `transcriptId`(主键)与委派卡 id(退路键)—— 两把与 `publishedWireFor` 的**同一条律**:
-                //   转录键命中不看退役(同一子代的迟到终态);退路键只认**未退役**的那把 wire 键(复活沿用同一张卡)。
-                //   放行仍走 `releaseHeldNewbornTerminal`(代际三向 peek + 经原漏斗归一),所以前代的缓行会被当代终态作废而不是盖上去。
                 const heldMatches = [];
                 for (const ref of heldNewbornTerminalRefs()) {
                     if (ref.taskId === ev.taskId)
-                        continue; // 第一条腿已经试过这把键
+                        continue;
                     const byTranscript = ref.transcriptId !== undefined && ref.transcriptId === ev.taskId;
                     const byParent = ref.parentToolCallId !== undefined &&
                         publishedWireByParent.get(ref.parentToolCallId) === ev.taskId &&
@@ -539,30 +373,6 @@ export function publishEngineAgentPanelEvent(ev) {
                     if (byTranscript || byParent)
                         heldMatches.push(ref.taskId);
                 }
-                // 命中之后**先逐条按代际三向判、不动表**,再决定放谁:
-                //   · 可证更旧的缓行(前代那一行)⇒ 当场作废(它的用量不许盖当代);
-                //   · end 可证更旧 ⇒ 那条缓行留着,等属于它自己的那条 end;
-                //   · 剩下的「可放行」候选**恰一条** ⇒ 放行 —— 它一上屏就登记了自己的钥匙 / 所有权,本条 end 随后在主路上
-                //     归一到同一把键,所以仍是「一行一条 end」。
-                //   · 🔴 候选 **≥2**(两个行尾段自称同一个转录锚 / 同一张委派卡)= **身份两义 ⇒ 一条都不放**:转录钥匙表是
-                //     **单值**的(后写覆盖先写),放两条就会各自上屏成两行而主路只归一到最后那一条 ⇒ 前面那些行永远收不到结算;
-                //     换成「每行各自补一条 end」则要在这里替主路决定消费端键,会吞掉原 wire 键那一行自己的终态。身份对不上就
-                //     **一帧都不摘**是本包扣留表的既有律(见 `hitl/gateLedger.ts` 的「判不出 ⇒ 一条都不摘」)。代价 = 这种形下
-                //     那几条行的用量仍缺席(与本件修之前同),换来的是绝不凭空多长一行、绝不替谁编一条终态。
-                //     🔴 **理由更正(0.76.0;外部验收方 [7764] 逐条回一级源码亲核后证伪了本句旧版)**:旧注释写的是「两个行尾段共享一个
-                //     **转录锚**不成立(转录锚按代际唯一),所以这一支是防御面」—— 那句话**只论证了转录钥匙那条腿**,而 `heldMatches`
-                //     是**转录锚腿 ∪ 委派卡腿**的并集,两条腿异质:
-                //       · 委派卡那条腿的前提**为假** —— workflow 扇出下一张卡整跑冻结成常量、尾段逐 callKey 不同,**最多 50 个**
-                //         尾段共享同一张卡且可同时在飞(上游坐标:core `workflow.ts` 的 `bceParentToolCall` 与 `waIdOf(callKey)`;
-                //         默认 `maxAgents` 50)。这正是本包 lane 判据里 `workflow-card-parent` 那一支的上游本体。
-                //         🔴 上游当事方 09-20 直讯确认了这一形:**一次扇出的全部子代共享同一张 `parentToolCallId`**(那次 workflow
-                //         工具调用自己的卡),逐子代能区分的键**只有 `taskId`**(`wa*` 形)—— 也就是说委派卡这条腿在扇出下**天然多对一**。
-                //       · 更要紧:**凑够 ≥2 根本不需要两行共享任何一个键** —— 一行只经转录锚命中、另一行只经委派卡命中即可。
-                //     ⇒ 今天这一支之所以罕见,**靠的不是上面那条律**,而是「workflow 子代的 tick 被 lane 门拦掉 ⇒ 委派卡那条腿的
-                //     `publishedWireByParent` 没有写入」这条**更脆**的保证 —— 它历史上塌过(上游投影白名单曾把 `workflowRunId` 整个剥掉)。
-                //     **失效条件**:workflow 子代的 tick 一旦上屏(白名单变宽 / lane 门放行),这一支立刻变成常态路径。
-                //     所以本分支**不是**「理论上才会走到的防御面」,它是**有真上游机制**的一支,只是今天被一条脆保证挡着。
-                // 🔴 无论放没放,**主路照走**:原 wire 键那一行(它可能早就上过屏)自己的 end 绝不能被这条腿吞掉。
                 const releasable = [];
                 for (const tail of heldMatches) {
                     const verdict = heldNewbornTerminalVerdict(tail, ev);
@@ -574,13 +384,11 @@ export function publishEngineAgentPanelEvent(ev) {
                 if (releasable.length === 1)
                     releaseHeldNewbornTerminal(releasable[0], ev);
             }
-            // 先发布的键为准(CC-83):尾段已被改写成 UUID 的子代,fleet 侧(投影 / 通知)的 end{尾段} 也改写成 UUID
             const wireOwner = wireOwnerOf(ev.taskId, ev);
             if (wireOwner !== undefined) {
                 const ownerRec = wireIdByFleetId.get(ev.taskId);
                 const staleA = endOlderThanKnown(ev, ev.taskId, ownerRec) || isStaleEngineAgentPanelEnd(ev, panelRowEndedIdentity(wireOwner));
                 deliverEngineAgentPanelEvent({ ...ev, taskId: wireOwner, wireTaskId: ev.taskId, taskIdOrigin: 'wire' });
-                // 前代迟到的 end(比所有权登记时的周期旧)只过境让消费端判陈旧,不退役当代所有权(异源复审 R3)、不销当代 running 历史
                 if (!staleA) {
                     retireWire(wireOwner);
                     settleRowHistory(ev.taskId, ev);
@@ -589,9 +397,7 @@ export function publishEngineAgentPanelEvent(ev) {
                 return;
             }
             if (publishedWireIds.has(ev.taskId)) {
-                // 这把 UUID 是先发布的键 ⇒ 它的 end 落在它自己的行上(不归一;一把已发布的键永远不改写)
                 flushHeld(ev.taskId);
-                // 这把 UUID 名下的尾段(反向所有权 / 转录别名)在投影里以尾段记账(复审 R3 [medium]),各自带周期守卫:先放缓着的终态行,end 之后再销
                 const ownedFleetIds = [];
                 for (const [fleetId, o] of wireIdByFleetId) {
                     if (o.wireId === ev.taskId && !endOlderThanKnown(ev, fleetId, o))
@@ -602,7 +408,6 @@ export function publishEngineAgentPanelEvent(ev) {
                     ownedFleetIds.push(alias.fleetId);
                 deliverEngineAgentPanelEvent(ev);
                 retireWire(ev.taskId);
-                // UUID 自己的 ended 账也带守卫(end(U,2) 之后的 end(U,1) 不倒写)
                 if (!isStaleEngineAgentPanelEnd(ev, panelRowEndedIdentity(ev.taskId)))
                     settleRowHistory(ev.taskId, ev);
                 for (const fleetId of ownedFleetIds)
@@ -611,10 +416,8 @@ export function publishEngineAgentPanelEvent(ev) {
             }
             const id = resolveEnginePanelTaskId(ev.taskId);
             if (id.origin === 'fleet-row' && id.taskId !== ev.taskId) {
-                flushHeld(ev.taskId); // 同 UUID 还缓着一条 tick ⇒ 先归一放出(行先有最后一拍的数字与名字),再结
+                flushHeld(ev.taskId);
                 migrateResidency(ev.taskId, id.taskId);
-                // 任何 lane 的 end 到漏斗 = 这一行结了 ⇒ running 历史销账(只销当代:前代迟到的 end 不擦新一代;异源复审 0.74.5 R2)
-                // 🔴 用与递达**同一个**有效身份判(事件自带的周期优先、缺席才借钥匙;复审 R3 [high]:按钥匙判会把 end{cycle 1} 当成当代)
                 const effectiveEnd = {
                     ...(ev.cycleSeq !== undefined ? { cycleSeq: ev.cycleSeq } : id.cycleSeq !== undefined ? { cycleSeq: id.cycleSeq } : {}),
                     ...(ev.startedAt !== undefined ? { startedAt: ev.startedAt } : id.startedAt !== undefined ? { startedAt: id.startedAt } : {}),
@@ -625,7 +428,6 @@ export function publishEngineAgentPanelEvent(ev) {
                     taskId: id.taskId,
                     wireTaskId: ev.taskId,
                     taskIdOrigin: 'fleet-row',
-                    // end 自己不带周期身份(流内 close 臂恒不带)⇒ 借钥匙上的:复活后迟到的 end{旧 UUID} 由此带着旧代际,消费端按 isStaleEngineAgentPanelEnd 挡掉
                     ...(ev.cycleSeq === undefined && id.cycleSeq !== undefined ? { cycleSeq: id.cycleSeq } : {}),
                     ...(ev.startedAt === undefined && id.startedAt !== undefined ? { startedAt: id.startedAt } : {}),
                 });
@@ -633,23 +435,19 @@ export function publishEngineAgentPanelEvent(ev) {
                     settleRowHistory(id.taskId, effectiveEnd);
                 return;
             }
-            flushHeld(ev.taskId); // 缓着的 tick 先落行,终态才有行可结
-            // 通知车道 / fleet 投影铸的 end(尾段键):只对当代(前代迟到的 end 带旧 seq / cycleSeq ⇒ 不擦历史、不放缓着的行)
+            flushHeld(ev.taskId);
             const staleD = endOlderThanKnown(ev, ev.taskId, latestCycleByFleetId.get(ev.taskId));
             deliverEngineAgentPanelEvent(ev);
-            retireWire(ev.taskId); // 这把 UUID 若是先发布的键,所有权退役(容量满时先让位)
+            retireWire(ev.taskId);
             if (!staleD)
                 settleRowHistory(ev.taskId, ev);
             return;
         }
         default:
-            // sweep:缓着的 tick 不放(见头注)—— 原样进主通道。
             deliverEngineAgentPanelEvent(ev);
     }
 }
 function deliverEngineAgentPanelEvent(ev) {
-    // 同 taskId 的任何主通道事实(tick / fleet-row = 行在场;end = 真终态)都让**缓冲里**那条缺席过期 —— 迟订阅的消费者
-    // 不许先恢复了行、再被一条旧缺席标成 unknown(已递达订阅者的缺席由订阅者按契约在这些事件上撤标)。
     if (ev.kind !== 'sweep')
         absenceBuffer.delete(ev.taskId);
     if (listener) {
@@ -657,53 +455,15 @@ function deliverEngineAgentPanelEvent(ev) {
             listener(ev);
         }
         catch {
-            // A consumer render error must never tear down the bridge's stream drain.
         }
         return;
     }
-    // Buffered (panel not mounted yet / temporarily unmounted).
-    //
-    // Two event CLASSES, and every buffering rule below keys off the class (not off one kind):
-    //   · PROGRESS ('tick' / 'fleet-row') — cumulative rollups off the two live lanes. Only the latest
-    //     one per taskId carries information, so they COALESCE per (kind, taskId) and they are the ones
-    //     that yield when the buffer is full.
-    //   · LIFECYCLE ('end' / 'sweep') — each one is a distinct fact that settles a row. They are never
-    //     the ones squeezed out by a long unmount (adversarial review w0zwpa251 #4: dropping a buffered
-    //     'end' left a row running forever).
-    //
-    // 🔴 [F4957-2] (0.41.0) the full-buffer arm used to look ONLY for a 'tick' to evict and then pushed
-    // UNCONDITIONALLY even when it found none — so a stream carrying no ticks at all (the 'fleet-row'
-    // lane is exactly that: background subagents never reach the panel through 'task_progress', see the
-    // fleet-row arm's own header) grew the buffer without bound. MAX_BUFFER is a memory bound on
-    // UNTRUSTED wire volume; it has to hold for every kind mix, not just the one the first version had
-    // in mind.
-    // Adjacent 'sweep' dedup. A sweep settles every row the consumer still has running and its own doc
-    // calls it idempotent, so a sweep whose immediate predecessor is a sweep is a strict no-op — nothing
-    // happened in between that it could settle differently. Dropping it is not a micro-optimisation: a
-    // long unmount publishes one sweep per turn, and 200 of them fill the buffer with pure lifecycle
-    // events, after which every post-barrier progress event has to yield (that is the other half of the
-    // bounded policy) — a subagent that starts at that point would replay as "still settled", forever.
     if (ev.kind === 'sweep' && buffer.length > 0 && buffer[buffer.length - 1]?.kind === 'sweep')
         return;
     const progress = ev.kind === 'tick' || ev.kind === 'fleet-row';
     if (progress) {
         const kind = ev.kind;
         const taskId = ev.taskId;
-        // Search BACKWARDS for a merge target and STOP at the first barrier. The bar for the whole buffer
-        // is "replaying it leaves the consumer in the same state as if the panel had been mounted all
-        // along", and each barrier below is a place where the consumer's state machine changes what a
-        // later event means — so an event on the far side of one cannot be folded into an event on this
-        // side (0.41.0 adversarial review #5 and #6):
-        //   · 'sweep' (global) and 'end' for this taskId — they SETTLE the row, and the consumer ignores
-        //     progress for a settled row. Live: `tick(v1) → sweep → tick(v2)` builds the row, settles it,
-        //     then drops v2 → the row ends settled. Folded into `sweep → tick(v2)` the replay sweeps an
-        //     empty table and then v2 BUILDS a running row — a ghost that live delivery never produces.
-        //   · the OTHER progress lane for this taskId — the fleet-row arm's own header states that a
-        //     'tick' makes the fleet lane hand the row over PERMANENTLY, so what the fleet lane said
-        //     BEFORE the handover (transcriptId / startedAt, often carried by exactly one frame) would
-        //     land after it and never be applied.
-        // Barriers cost buffer slots, and that is the right trade: the bound is still enforced by the
-        // eviction policy below, while a wrong fold is silently wrong forever.
         let i = -1;
         for (let at = buffer.length - 1; at >= 0; at--) {
             const b = buffer[at];
@@ -717,29 +477,13 @@ function deliverEngineAgentPanelEvent(ev) {
                 continue;
             }
             if (b.taskId !== taskId)
-                continue; // another task's progress — irrelevant to this row
-            // 0.73.0:launch 锚变了 = 同一个 taskId 的**新周期**,也是一道屏障。逐键合并的「省略的键沿用旧值」只在同一周期内
-            // 成立;跨周期合并会把上一周期的 totalTokens / toolUses 继承进新周期(投影层刻意省略的键被缓冲层补了回来)。
+                continue;
             if (b.kind === kind && !launchAnchorChanged(b, ev))
                 i = at;
-            break; // same lane & same cycle ⇒ merge target; other lane / new cycle ⇒ barrier
+            break;
         }
         if (i >= 0) {
-            // 🔴 Coalescing must not DROP sticky keys either (0.41.0 adversarial review #4). Both progress
-            // lanes are published as PARTIAL frames — the projection emits `...(toolUses !== undefined ?
-            // { toolUses } : {})` and friends, and an absent key means "this frame didn't say, keep what the
-            // row already has" (the three-state rule on the fleet-row arm above). A mounted panel therefore
-            // still shows the `toolUses` that arrived on v1 after a v2 that only moved `totalTokens`; a
-            // replay that kept only v2 would lose it for good. So the surviving copy is a per-key merge
-            // (later frame wins per key, keys it omits are inherited), not a wholesale replacement.
             const merged = { ...buffer[i], ...ev };
-            // 🔴 Coalescing must not REORDER across a lifecycle barrier (0.41.0 adversarial review #2).
-            // Overwriting in place rewrites `progress(A,v1) → end(A) → progress(A,v2)` into
-            // `progress(A,v2) → end(A)` — the post-settle rollup is moved BEFORE the settle, so a row that
-            // was revived (the fleet projection explicitly allows a settled row to run again) gets settled
-            // by the replay again, with the revived progress applied to the dead cycle. The bar for a
-            // buffered replay is "same result as if the panel had been mounted the whole time", so the
-            // surviving copy has to keep the LATEST event's arrival position: drop the old one, append.
             buffer.splice(i, 1);
             buffer.push(merged);
             return;
@@ -749,31 +493,15 @@ function deliverEngineAgentPanelEvent(ev) {
         buffer.push(ev);
         return;
     }
-    // Full: the oldest PROGRESS event yields (its taskId's next rollup supersedes it anyway).
     const evictAt = buffer.findIndex(b => b.kind === 'tick' || b.kind === 'fleet-row');
     if (evictAt >= 0) {
         buffer.splice(evictAt, 1);
         buffer.push(ev);
         return;
     }
-    // Nothing but lifecycle events in a full buffer (MAX_BUFFER rows settled while the panel stayed
-    // unmounted — 200 distinct 'end's is the realistic way there, the adjacent-sweep dedup above having
-    // removed the cheap one). At a finite bound something must give, and the rule is NEWEST-WINS for
-    // every kind: the oldest event yields, whatever it is.
-    //
-    // 🔴 Why not "progress yields here too" (which is what this arm used to do — adversarial review
-    // round 7, finding #4): a progress event arriving at this point is the ONLY word the panel will
-    // ever get about a row that was created or revived after the barrier — `projectFleetAgentRows`
-    // emits on CHANGE, so a row that then goes quiet never speaks again. Dropping it makes that row
-    // permanently invisible after a remount, which is a strictly worse loss than dropping the OLDEST
-    // lifecycle event: that one settles a row that finished ~MAX_BUFFER events ago, and the sweep that
-    // every turn publishes (newest ⇒ always survives) settles whatever is still running anyway.
-    // The residual — an old 'end' can be dropped, taking its `report`/`isError` with it — is the honest
-    // price of a bounded buffer and is registered in CHANGELOG 0.41.0 "已知局限".
     buffer.shift();
     buffer.push(ev);
 }
-/** Single consumer (the panel hook). Replays any buffered events, returns an unsubscribe. */
 export function subscribeEngineAgentPanel(fn) {
     listener = fn;
     if (buffer.length > 0) {
@@ -783,7 +511,6 @@ export function subscribeEngineAgentPanel(fn) {
                 fn(ev);
             }
             catch {
-                // ignore — same guard as publish
             }
         }
     }
@@ -794,11 +521,8 @@ export function subscribeEngineAgentPanel(fn) {
 }
 const MAX_ABSENCE_BUFFER = 200;
 let absenceListener = null;
-/** 未订阅时的缓冲:按 taskId 留最新一条(同一行只有最新一次缺席有信息),有上界(最旧的先让位)。 */
 const absenceBuffer = new Map();
-/** 发布一条缺席上报(由 `projectFleetAgentRows` 的缺席路径调;消费者抛错不反噬投影)。 */
 export function publishEngineAgentPanelAbsence(ev) {
-    // 0.74.4 CC-83(异源复审 R1 [medium]):尾段已归先发布的 UUID 所有 ⇒ 缺席也按那把键发(主通道与侧信道同一把键),原尾段进 wireTaskId
     const owner = wireOwnerOf(ev.taskId);
     if (owner !== undefined)
         ev = { ...ev, taskId: owner, wireTaskId: ev.taskId };
@@ -807,7 +531,6 @@ export function publishEngineAgentPanelAbsence(ev) {
             absenceListener(ev);
         }
         catch {
-            // A consumer render error must never tear down the projection.
         }
         return;
     }
@@ -819,7 +542,6 @@ export function publishEngineAgentPanelAbsence(ev) {
             absenceBuffer.delete(oldest);
     }
 }
-/** 单消费者(面板 hook)。订阅即回放缓冲,返回取消订阅。不订阅 = 行为与 0.72.11 的壳完全相同(行停在最后已知态)。 */
 export function subscribeEngineAgentPanelAbsence(fn) {
     absenceListener = fn;
     if (absenceBuffer.size > 0) {
@@ -830,7 +552,6 @@ export function subscribeEngineAgentPanelAbsence(fn) {
                 fn(ev);
             }
             catch {
-                // ignore — same guard as publish
             }
         }
     }
@@ -839,7 +560,6 @@ export function subscribeEngineAgentPanelAbsence(fn) {
             absenceListener = null;
     };
 }
-/** 测试钩:清缺席口的订阅与缓冲。 */
 export function __resetEngineAgentPanelAbsenceForTests() {
     absenceListener = null;
     absenceBuffer.clear();