@sema-agent/client-core 0.77.1 → 0.78.0

package/dist/fleet/workflowSizeWarning.js

@@ -1,54 +1,21 @@
-/**
- * src/fleet/workflowSizeWarning.ts —— workflow **规模告警**的判定(0.73.5)。
- *
- * 三端 footer / 面板都要回答同一个问题:「这条 workflow 是不是大到该提醒用户了」。判定与 CC 同形
- * (三个缺省帽、每 agent 用量估算、guideline 表、两个 env 覆盖、三档文案与宽度阶梯),属于客户端公共逻辑,
- * 由本包单源;端只负责读环境、读设置、量宽度与渲染。
- *
- * 🔴 **入参按 fleet 视图的三态键读**(`FleetWorkflowView`:`totalCount` / `startedCount` / `doneCount` /
- *    `failedCount` / `tokens` 全是可选位,缺席 = wire 没报 = 不知道)。出参三态:
- *      · `warn`    —— 有**正向证据**证明至少一条轴超帽(别的键缺席不挡它;下界分母算出的上界**不算**证据);
- *      · `ok`      —— 两条轴都判得出,且都在帽内(或 ultracode 压掉了整条告警);
- *      · `unknown` —— 没有超帽的正向证据,且至少一条轴判不出。**未知的规模不能被当作规模正常**:
- *                     `unknown` 绝不折成 `ok`,`missing` 点名缺了哪几键。
- *
- * 🔴 **分母口径**(每 agent 用量 `u = tokens / started`):
- *      · `startedCount` 在场且不小于 `doneCount + failedCount` ⇒ 用引擎真值(含真 0:「一个都还没起」是一条真信息
- *        ⇒ 用先验);比已完成数还小(帧间竞态)⇒ 这份读数是陈旧的,按下面的下界处置;
- *      · 缺席 ⇒ 只有 `doneCount` / `failedCount` **两键都在场**才回退成下界,结果标 `startedIsLowerBound`。
- *        下界偏小 ⇒ `u` 偏大 ⇒ 算出来的是投影的**上界**(`projectedTokensUpperBound`,不是 `projectedTokens`):
- *        上界在帽内 ⇒ 真的在帽内 ⇒ 可以判 `ok`;上界超帽**不是**超帽的证据(同一份读数补上真 `startedCount`
- *        可能远在帽内)⇒ 投影轴判不出,`unknown`。想保守一点的端可以自己拿上界去提示,判词不替它撒谎;
- *      · 下界为 0 ⇒ 每 agent 用量判不出:「0 个完成」不是「一个没起」的证据,先验只在引擎**亲口**报
- *        `startedCount = 0` 时可用;
- *      · 只有一键在场 ⇒ 不回退(缺席的那键不读作 0)。
- */
-/** 缺省 agent 数帽。 */
 export const WORKFLOW_SIZE_WARNING_AGENT_CAP = 25;
-/** 缺省 token 帽(已花 ∨ 投影)。 */
 export const WORKFLOW_SIZE_WARNING_TOKEN_CAP = 1_500_000;
-/** 还没有任何 agent 起跑时的每 agent 用量先验。 */
 export const WORKFLOW_SIZE_WARNING_TOKENS_PER_AGENT = 70_000;
-/** 显式 `workflowSizeGuideline` → agent 数帽。`unrestricted` 与缺省(未配置)**不贡献帽**,故不在表里。 */
 export const WORKFLOW_SIZE_GUIDELINE_AGENT_CAPS = Object.freeze({
     small: 5,
     medium: 15,
     large: 50,
 });
-/** 两个 env 覆盖各自的名字,按读取优先级排(品牌名在前,兼容名在后)。本包不读 `process.env`,名字单源在这里。 */
 export const WORKFLOW_SIZE_WARNING_ENV_NAMES = Object.freeze({
     agents: Object.freeze(['SEMA_CODE_WORKFLOW_SIZE_WARNING_AGENTS', 'CLAUDE_CODE_WORKFLOW_SIZE_WARNING_AGENTS']),
     tokens: Object.freeze(['SEMA_CODE_WORKFLOW_SIZE_WARNING_TOKENS', 'CLAUDE_CODE_WORKFLOW_SIZE_WARNING_TOKENS']),
 });
-/** 三档文案(宽 → 窄)。 */
 export const WORKFLOW_SIZE_WARNING_TEXT_LONG = '⚠ Large workflow · /workflows to stop';
 export const WORKFLOW_SIZE_WARNING_TEXT_SHORT = '⚠ Large workflow';
 export const WORKFLOW_SIZE_WARNING_TEXT_MIN = '⚠';
-/** 有限非负数,否则缺席(坏形按缺席,不猜)。 */
 function count(v) {
     return typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : undefined;
 }
-/** 正有限数,否则缺席。 */
 function positive(v) {
     return typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : undefined;
 }
@@ -57,7 +24,6 @@ function guidelineCap(size) {
         ? WORKFLOW_SIZE_GUIDELINE_AGENT_CAPS[size]
         : undefined;
 }
-/** 规模判定。纯函数:每个环境量都由调用方注入。 */
 export function evaluateWorkflowSize(input) {
     const agentCap = positive(input.envAgentCap) ?? guidelineCap(input.guidelineSize) ?? WORKFLOW_SIZE_WARNING_AGENT_CAP;
     const tokenCap = positive(input.envTokenCap) ?? WORKFLOW_SIZE_WARNING_TOKEN_CAP;
@@ -71,7 +37,6 @@ export function evaluateWorkflowSize(input) {
     };
     if (input.ultracodeActive === true)
         return { kind: 'ok', suppressed: true, ...base };
-    // 分母:真值 / 两键下界 / 判不出。
     const startedWire = count(input.startedCount);
     const done = count(input.doneCount);
     const failed = count(input.failedCount);
@@ -82,12 +47,9 @@ export function evaluateWorkflowSize(input) {
         started = startedWire;
     }
     else if (bound !== undefined) {
-        // `startedCount` 缺席,或它比已完成数还小(帧间竞态:已完成的 agent 必然起过 ⇒ 这份 started 是陈旧的)。
-        // 顶上来的 `done + failed` 只是**下界**,不是真值 —— 与缺席同一处置。
         started = bound;
         lowerBound = true;
     }
-    // 投影:分母是真值 ⇒ 投影;分母是下界(> 0)⇒ 只有上界;其余判不出。
     let projected;
     let upperBound;
     if (scheduled !== undefined && tokens !== undefined && started !== undefined) {
@@ -104,7 +66,6 @@ export function evaluateWorkflowSize(input) {
         ...(upperBound !== undefined ? { projectedTokensUpperBound: upperBound } : {}),
         ...(lowerBound && scheduled !== undefined && tokens !== undefined ? { startedIsLowerBound: true } : {}),
     };
-    /** 投影轴在帽内的证据:真投影在帽内,或上界在帽内。 */
     const projectionWithinCap = (projected !== undefined && projected <= tokenCap) || (upperBound !== undefined && upperBound <= tokenCap);
     const overAgents = scheduled !== undefined && scheduled > agentCap;
     const overTokens = (tokens !== undefined && tokens > tokenCap) || (projected !== undefined && projected > tokenCap);
@@ -122,11 +83,6 @@ export function evaluateWorkflowSize(input) {
         return { kind: 'unknown', missing, ...facts };
     return { kind: 'ok', ...facts };
 }
-/**
- * 两个 env 覆盖的读口。`env` 由调用方交(本包不碰 `process.env`)。每组按 {@link WORKFLOW_SIZE_WARNING_ENV_NAMES}
- * 的顺序取**第一个在场的名字**;那个名字的值不是正有限数 ⇒ 该键不在场,**不回落**到第二个名字
- * (显式写错不该被悄悄换源)。
- */
 export function readWorkflowSizeWarningEnvCaps(env) {
     const pick = (names) => {
         if (env === undefined || env === null)
@@ -134,7 +90,7 @@ export function readWorkflowSizeWarningEnvCaps(env) {
         for (const n of names) {
             const raw = env[n];
             if (typeof raw !== 'string')
-                continue; // 空串也是「在场」:在场的坏值就地止步,不回落
+                continue;
             return positive(Number(raw));
         }
         return undefined;
@@ -143,7 +99,6 @@ export function readWorkflowSizeWarningEnvCaps(env) {
     const t = pick(WORKFLOW_SIZE_WARNING_ENV_NAMES.tokens);
     return { ...(a !== undefined ? { envAgentCap: a } : {}), ...(t !== undefined ? { envTokenCap: t } : {}) };
 }
-/** 宽度阶梯:挑放得下的最长一档;连字形都放不下 ⇒ `undefined`(整段不渲)。`width` 由调用方注入(与渲染器同一把尺)。 */
 export function workflowSizeWarningTextForWidth(available, width) {
     if (available >= width(WORKFLOW_SIZE_WARNING_TEXT_LONG))
         return WORKFLOW_SIZE_WARNING_TEXT_LONG;

package/dist/fleetAgentPanelProjection.d.ts

@@ -1,71 +1,23 @@
-/** 行帧投影后的最小 agent 行形(fleet-tree 的 FleetTask 是它的超集)。 */
 export interface FleetAgentRowLike {
     id: string;
-    /** fleet 行 label 列 = agent identity(agentName ?? agentType),如 'fork'。 */
     name?: string;
-    /** fleet 行描述列 = 任务描述,如 'alpha-probe'(面板行 label 用它)。 */
     description?: string;
     status?: string;
     tokens?: number;
-    /**
-     * server 1.278.0 `toolUses` —— 子代**累计**工具调用数。🔴 三态:有键真值(含真 0)/
-     * 无键 `undefined` = 老引擎不知道。**本层绝不 `?? 0`**(那等于把「不知道」冒充成「跑了 0 个」,
-     * 而且会把台账里已知的累计值擦回 0)。
-     *
-     * ⚠️ **这句话只对本层成立 —— 分层实情**(2026-07-31 更正:原文写成绝对句「绝不在本层 `?? 0`」,
-     * 读起来像是全包禁令,于是与 `adapt.ts` tick 臂那句 `: 0` 构成一处**包内自相矛盾**;真相是两条
-     * lane 的供给形不同,判据见 `engineAgentPanelStore.ts` 的 `PANEL_TOOLUSES_LANE_POLICY`):
-     *   · **本 lane(fleet 行帧)**:该键是 server 1.278.0 **新加**的可选位,老引擎真的不发 ⇒
-     *     缺席 = 不知道 ⇒ 必须传播缺席(键不落)。
-     *   · **tick lane(`task_progress`)**:`usage` 在 core 的事件类型里是**必填**
-     *     (core 2.12.0 `core/types.d.ts:606-610`),两处发帧点无条件构造它
-     *     (`core/runner/runtask.js:1080` / `:2925`),server 白名单整键透传
-     *     (`trace/project.js:118`)⇒ 那条 lane 上「缺席」不是「不知道」,是没有这种帧;那里的
-     *     `: 0` 是对一个**恒发的累计计数**兜底,不是编造一个不知道的值。
-     * 两条 lane 的可选性差异由 `engineAgentPanelStore.ts` 的编译钉锁住:谁想把两层「统一」成
-     * 同一种形,先在那里撞红。
-     */
     toolUses?: number;
-    /** server 1.278.0 `transcriptId`(子代 childSessionId)—— 委派 prompt 的取件锚,不是 prompt 本身。 */
     transcriptId?: string;
-    /** server 1.288.0 / core 1.429.0([1831]②)—— 子代当前工具的结构化形。缺席=旧端或从未跑过工具。 */
     currentTool?: {
         toolName: string;
         target?: string;
     };
-    /** server 1.250 起行带的 launch 真锚(epoch ms)。R4(clay 五报 07-31):此前投影载荷丢弃它,
-     *  详情页 elapsed 只能锚「壳建行时刻」——遗留行上渲出 1h+ 的假时长。缺席=老引擎,消费端保持现状。 */
     startedAt?: number;
-    /** 0.74.0 —— 行的代际号(fleet 视图 `FleetTaskView.cycleSeq` 原样交)。缺席 = 这一行没有代际概念,不是第一代。 */
     cycleSeq?: number;
-    /** 0.74.3 CC-70:行帧上的委派卡 id(sdk `FleetTaskRow.parentToolCallId`);身份归一的退路键,在场才投影。 */
     parentToolCallId?: string;
 }
-/** 行从投影集消失多久之后上报 `absent`(0.72.12 起不再 settle;重连空窗 / snapshot 清表远小于此)。名字沿用(公面导出)。 */
 export declare const ABSENT_SETTLE_MS = 30000;
-/**
- * 测试钩:清投影台账 —— **全部 sessionKey**,不是只清 default 桶。
- *
- * 🔴 回炉定谳(P3 wave2 复审 blocker④):per-session 化那一批一度把它收窄成
- * `resetFleetAgentPanelProjectionFor(DEFAULT_SESSION_KEY)`。它的契约是「清投影台账」,不是一个
- * 会话语义位 —— 收窄等于给多会话宿主的用例之间留一条跨用例串扰通道(用例 A 先
- * `projectFleetAgentRowsFor('sess-b', …)`,用例间调零参 reset,`sess-b` 桶存活 ⇒ 下个用例首次
- * 投影同 taskId 时 `prev` 非空且 `settled:true`,`fleet-row`/`end` 被去重门吞掉)。
- * 对位实现同形:`fleet/fleetLedger.__resetFleetLedgerRegistryForTests()` = `liveBgViews.clear()`;
- * W1 段五个槽位的现成规约也逐个钉的是「reset 清全部键」。
- * 要只清一个会话请用 `resetFleetAgentPanelProjectionFor(sessionKey)`。
- */
 export declare function resetFleetAgentPanelProjection(): void;
-/** W1 keyed variant(REF-CC-045):只清**这一个会话**的桶。 */
 export declare function resetFleetAgentPanelProjectionFor(sessionKey: string): void;
-/** 台账读面(测试/诊断):当前记着的行数。 */
 export declare function fleetAgentProjectionSize(): number;
-/** W1 keyed variant。 */
 export declare function fleetAgentProjectionSizeFor(sessionKey: string): number;
-/**
- * 把一次 fleet 投影(已经过 own 判别 + workflow belt 的 FleetTask[])喂给面板事件流。
- * 幂等、无副作用地重复调用安全 —— 每秒被 footer 调用两次就是常态。
- */
 export declare function projectFleetAgentRows(rows: readonly FleetAgentRowLike[], nowMs?: number): void;
-/** W1 keyed variant(REF-CC-045):多会话宿主每会话一份台账,互不顶盖。 */
 export declare function projectFleetAgentRowsFor(sessionKey: string, rows: readonly FleetAgentRowLike[], nowMs?: number): void;

package/dist/fleetAgentPanelProjection.js

@@ -1,88 +1,17 @@
-/**
- * ⇄ B1 批搬迁(2026-07-27,多端改造设计稿 §2.4.1-B):cli src/sema/fleetAgentPanelProjection.ts 逐字搬入(唯一 import = 同批搬入的
- * engineAgentPanelStore,包内相对路径不变;壳侧改 re-export)。
- * 🔴 REF-CC-041/042(P3 wave2,fleet2-03/04):P1 迁移之后本文件不再是「唯一 import」——同批把
- * `TERMINAL_STATUSES` 改成 import `./fleet/fleetProjection.js` 的 `TERMINAL_FLEET_TASK_STATUSES`
- * (单源,原副本零测试锁着,分叉理由已不成立)、`rowIdTail` 改 import `./workflow.js`(同包另两个
- * 消费者 `fleet/fleetLedger.ts` / `fleet/fleetProjection.ts` 早就这么做,只有本文件是例外)。
- * ⚠️ 本文件含**两个字面 NUL 字节**(`${ct.toolName}\0${ct.target}` 的 currentTool 判等键分隔符,
- * 语义承载位,搬迁时逐字节保留)—— 副作用:BSD `grep`/`file` 把本文件当二进制,`grep` 不加 `-a`
- * 会**静默零命中**(不是「没有」,是「没在找」)。改本文件的探针一律 `grep -a`。
- */
-/**
- * src/sema/fleetAgentPanelProjection.ts — fleet 行帧 lane → Background 面板 local_agent 行的**投影闸**
- * (2026-07-26「后台 Agent 子代不进 Background 面板」案;零依赖叶模块,mock 钉直测面)。
- *
- * ══ 为什么需要这条腿(分诊 = B 类,一手取证)═══════════════════════════════════════════════════
- * verify/_bgagent-panel-lane-live-pty.mjs 首跑(engine 1.277.4 真机,真 deepseek):两个
- * `run_in_background:true` 的 fork 子代**整跑活跃干活**(footer fleet 树 `◯ fork alpha-probe … 47.8k
- * tokens`,token 在涨),同一跑里
- *     task_progress tick 探针 = 0 条   ·   fleet 行帧探针 = 24 条
- * 面板的 local_agent 行此前**只**由 `task_progress` tick 注册(chrome-agentprogress
- * useEngineAgentPanelBridge),而后台子代的 tick 从来没有通道到壳(父 turn 秒收口即关 SSE)——
- * 于是产品自印的「N background agents launched (↓ to manage)」把用户指向一个**看不到它们**的面板,
- * 且 `ctrl+x ctrl+k … stop all agents` 的渲染门(> 1 running local_agent)在真产品里永不成立。
- * 帧**到了壳**、只是走了另一条 lane ⇒ 壳侧可修:把行帧 lane 的 agent 事实也投影进 AppState.tasks。
- *
- * ══ CC 220 对位 ═══════════════════════════════════════════════════════════════════════════════
- * CC 2.1.220 `esi`(BackgroundTasksDialog)的 Local agents 分节就是
- *     Object.values(tasks).filter(isBackgroundTask) → .filter(ge => ge.type === "local_agent" && ge.id !== i)
- *     → { key:"local-agents", header: zEt({label:"Local agents", size: y.length}) }
- * (cc-decoded/pretty220.js:860404 起的 filter 串 + 860812 的分节表)。所以正确的修法是**让这些子代
- * 成为 running 的 local_agent 行**,而不是新造分节/新造行形 —— 面板形状一个字都不动。
- *
- * ══ 本模块的规矩 ═══════════════════════════════════════════════════════════════════════════════
- * ① 只发**变化**:同一行 status/tokens 没变就不发事件(footer 每秒 tick 两次,无脑发 = 每秒两次
- *    setAppState 全树重渲)。
- * ② 终态行发一次 `end`(幂等台账),并摘除常驻标 —— 与 bg_notification 合成链同一个 settle 边,
- *    两边先到先得,消费端 settle 本身幂等(running 才动)。
- * ③ 缺席上报(0.72.12 CC-50 改形):行从投影集里消失且**超过宽限窗**仍没见终态 ⇒ 经**独立缺席口**(`publishEngineAgentPanelAbsence`,0.72.13;不上主通道)
- *    上报一条(**不是** `end`、**不** settle)。此前这里「按 completed settle」= 把「引擎不再上报这一行」
- *    编成「成功」—— 本包手上没有任何载体说明它完没完成(test [7541] 两条现场腿秒级实测:屏上
- *    ✔ Completed 的真实来源就是这一格;server [7545]:子行随父 run 离场被 `orphaned` 移除,真终局由
- *    后续对账周期补发,结构性晚于这个窗)。真终态帧迟到照发那唯一一次 `end`;行回来照发 `fleet-row`。
- *    宽限窗内的重连空窗(snapshot 清表)不上报;lastSeen 恒**先**按本次在场行刷新、再判缺席,所以
- *    footer 长时间卸载后重挂也不误报。
- * ④ 行 id 尾段判(`${runId} ${taskId}` 复合形取尾;真机 1.277.4 上子行 id 是裸 a+16hex,复合形是
- *    run 发布器双生行的形)——REF-CC-042:与同包 `workflow.rowIdTail` 同一个函数(import,不再
- *    就地维护第二份;该函数出过等价性事故,0.1.1 修,见 `workflow.ts` 头注)。
- */
 import { isStaleEngineAgentPanelEnd, publishEngineAgentPanelAbsence, publishEngineAgentPanelEvent } from './engineAgentPanelStore.js';
 import { __resetPanelRunningHistoryForTests, notePanelRowRunning, panelRowUnknownToConsumer, panelRowEndedIdentity, holdNewbornTerminalRow, peekHeldNewbornTerminalRow, dropHeldNewbornTerminalRow } from './panelRunningHistory.js';
 import { rowIdTail } from './workflow.js';
 import { TERMINAL_FLEET_TASK_STATUSES } from './fleet/fleetProjection.js';
 import { DEFAULT_SESSION_KEY } from './sessionSlot.js';
-// L-215+(0.65.0;core [6908]):「非成功终局」的单铸谓词(与 notifications 的同名位同源)。
 import { isTerminalNotSuccess } from './runTerminal.js';
-/** 行从投影集消失多久之后上报 `absent`(0.72.12 起不再 settle;重连空窗 / snapshot 清表远小于此)。名字沿用(公面导出)。 */
 export const ABSENT_SETTLE_MS = 30_000;
-/** REF-CC-045(fleet2-07):settled 条目的回收期 —— settle 后这么久仍未再被投影 ⇒ 台账整条
- *  delete,给 `fleetAgentProjectionSizeFor()` 一个上界(此前 `seen` 只增不减,长会话里每个
- *  跑过的 bg 子代永久占一条)。settle 事件已经发过,消费端 settle 幂等,delete 对外无事件。
- *
- *  🔴 [2393] notif-F13 / sweep-F7(2026-08-03 全窗复审)**两处纠**(判据换轴 + 范围如实):
- *   (a) 回收判据从 `lastSeenAt` 换成 **`settledAtMs`**(settle 那一刻的钟)。上一版 ③ 缺席兜底
- *       把条目标 `settled:true` 时**保留旧的 lastSeenAt**,紧接着 ④ 在**同一次调用**里用
- *       `nowMs - lastSeenAt > 120s` 判回收 ⇒ 面板卸载超过 120s 再挂回来时,那条行「刚被 settle
- *       就立刻被删」,而 `prev?.settled` 正是「终态 end 只发一次」的**唯一**判据 —— 去重记号随
- *       条目一起消失,同 taskId 的迟到终态帧会再发一次 `fleet-row`+`end`。
- *       换轴之后「settle 后至少保留一个回收期」成为真的。
- *   (b) 回收只对**本次投影里已不在场**的条目成立(`!present.has(taskId)`)。仍在场的终态行不删:
- *       删了它下一拍 `prev === undefined` 会**重发 end**,每拍一次,比不删坏得多。
- *       ⇒ 上界的如实表述:**不再被投影的条目会被回收**;仍被持续投影的终态行由投影集自身定界
- *       (它的大小是引擎/宿主列出来的行数,不是本台账的无界累积)。ledger 里 REF-CC-045 的问题
- *       陈述「只增不减」覆盖的正是前半场,后半场此前被说成也已解决,那句话不成立。 */
 const SETTLED_RETENTION_MS = ABSENT_SETTLE_MS * 4;
-/** currentTool 判等键(POST-MERGE 行每秒重发同值,只有键变了才算变化)。 */
 function currentToolKeyOf(ct) {
     if (!ct || typeof ct.toolName !== 'string' || ct.toolName.length === 0)
         return undefined;
     return `${ct.toolName}\u0000${ct.target ?? ''}`;
 }
-/** REF-CC-045(fleet2-07):per-sessionKey 台账(W1 同款 `Map<sessionKey, Map<...>>` 形)。 */
 const seen = new Map();
-// 0.74.5 CC-86:「发布过 running 而尚未结掉」的行 id 在 `panelRunningHistory.ts`(进程级共享叶;写方 = 本投影的非终态帧,
-// 销账方 = 面板漏斗的任何 lane 的 end(通知车道的 end 不经本投影),读方 = 下面的终态分支)。
 function seenFor(sessionKey) {
     let m = seen.get(sessionKey);
     if (!m) {
@@ -91,42 +20,22 @@ function seenFor(sessionKey) {
     }
     return m;
 }
-/**
- * 测试钩:清投影台账 —— **全部 sessionKey**,不是只清 default 桶。
- *
- * 🔴 回炉定谳(P3 wave2 复审 blocker④):per-session 化那一批一度把它收窄成
- * `resetFleetAgentPanelProjectionFor(DEFAULT_SESSION_KEY)`。它的契约是「清投影台账」,不是一个
- * 会话语义位 —— 收窄等于给多会话宿主的用例之间留一条跨用例串扰通道(用例 A 先
- * `projectFleetAgentRowsFor('sess-b', …)`,用例间调零参 reset,`sess-b` 桶存活 ⇒ 下个用例首次
- * 投影同 taskId 时 `prev` 非空且 `settled:true`,`fleet-row`/`end` 被去重门吞掉)。
- * 对位实现同形:`fleet/fleetLedger.__resetFleetLedgerRegistryForTests()` = `liveBgViews.clear()`;
- * W1 段五个槽位的现成规约也逐个钉的是「reset 清全部键」。
- * 要只清一个会话请用 `resetFleetAgentPanelProjectionFor(sessionKey)`。
- */
 export function resetFleetAgentPanelProjection() {
     seen.clear();
     __resetPanelRunningHistoryForTests();
 }
-/** W1 keyed variant(REF-CC-045):只清**这一个会话**的桶。 */
 export function resetFleetAgentPanelProjectionFor(sessionKey) {
     seen.delete(sessionKey);
 }
-/** 台账读面(测试/诊断):当前记着的行数。 */
 export function fleetAgentProjectionSize() {
     return fleetAgentProjectionSizeFor(DEFAULT_SESSION_KEY);
 }
-/** W1 keyed variant。 */
 export function fleetAgentProjectionSizeFor(sessionKey) {
     return seen.get(sessionKey)?.size ?? 0;
 }
-/**
- * 把一次 fleet 投影(已经过 own 判别 + workflow belt 的 FleetTask[])喂给面板事件流。
- * 幂等、无副作用地重复调用安全 —— 每秒被 footer 调用两次就是常态。
- */
 export function projectFleetAgentRows(rows, nowMs = Date.now()) {
     projectFleetAgentRowsFor(DEFAULT_SESSION_KEY, rows, nowMs);
 }
-/** W1 keyed variant(REF-CC-045):多会话宿主每会话一份台账,互不顶盖。 */
 export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
     const seenMap = seenFor(sessionKey);
     const present = new Set();
@@ -138,74 +47,40 @@ export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
             continue;
         present.add(taskId);
         const status = row.status ?? 'running';
-        // 0.73.0:三态 —— 帧上真给了非负整数才算数;缺席 / 坏形 ⇒ 沿用已知值(粘性),从没报过就是 undefined。
-        //   此前 `?? 0`:首帧发布 `totalTokens:0`(面板渲「0 tokens」),已知之后来一帧缺席又发布 0 把用量清零。
         const wireTokens = typeof row.tokens === 'number' && Number.isInteger(row.tokens) && row.tokens >= 0 ? row.tokens : undefined;
-        const tokens = wireTokens; // 粘性在下面(拿到 prev 与周期锚之后)补
-        // 🔴 三态直取:`row.toolUses` 缺席就是 undefined,这里**不许**兜 0(见 FleetAgentRowLike 注)。
+        const tokens = wireTokens;
         const toolUses = typeof row.toolUses === 'number' ? row.toolUses : undefined;
         const transcriptId = row.transcriptId || undefined;
         const parentToolCallId = typeof row.parentToolCallId === 'string' && row.parentToolCallId.length > 0 ? row.parentToolCallId : undefined;
-        // 🔴 形核与周期判据(`isStaleEngineAgentPanelEnd` / `isNewEngineAgentPanelCycle`)**逐字同源**:
-        //    有限正数才算数。少一个 `Number.isFinite` 就会让 `Infinity` 进台账 —— 那两只判据按缺席看它,
-        //    而本层按在场看它,同一帧在两处得出相反的「可比不可比」。
-        //    `Infinity` 还会被序列化成 `null` 发给消费端,渲成一个不存在的 launch 时刻。
         const startedAt = typeof row.startedAt === 'number' && Number.isFinite(row.startedAt) && row.startedAt > 0 ? row.startedAt : undefined;
-        // 0.74.0:代际号(正整数才算;坏形 / 缺席 ⇒ undefined,绝不补 1)。
         const cycleSeq = typeof row.cycleSeq === 'number' && Number.isInteger(row.cycleSeq) && row.cycleSeq >= 1 ? row.cycleSeq : undefined;
         const currentTool = currentToolKeyOf(row.currentTool) !== undefined ? row.currentTool : undefined;
         const currentToolKey = currentToolKeyOf(row.currentTool);
         const prev = seenMap.get(taskId);
-        // 0.74.0(异源对抗复审 R1):行上已是更新的一代,这一帧却是更早的一代 ⇒ 前代迟到帧。整只跳过:不发 fleet-row
-        //   (它会把消费端记的周期身份改写回旧代,让随后的 end{旧代} 过陈旧判据)、不发 end、不动台账(否则台账被标
-        //   settled,新一代的真终态就被去重吞掉)。在场已记 ⇒ 不会因此误报缺席。
-        //   判据与消费端同一条(`isStaleEngineAgentPanelEnd`:cycleSeq 优先,startedAt 回退)—— 只比 cycleSeq 会让只带
-        //   startedAt 的前代帧漏网(异源对抗复审 R2)。
         const rowIdentity = { ...(cycleSeq !== undefined ? { cycleSeq } : {}), ...(startedAt !== undefined ? { startedAt } : {}) };
         const prevIdentity = prev !== undefined
             ? { ...(prev.cycleSeq !== undefined ? { cycleSeq: prev.cycleSeq } : {}), ...(prev.startedAt !== undefined ? { startedAt: prev.startedAt } : {}) }
             : undefined;
         if (prev !== undefined && isStaleEngineAgentPanelEnd(rowIdentity, prevIdentity))
             continue;
-        /** 这一帧的周期身份**可证明**比台账上的新(同一条规则反向)。 */
         const rowNewerCycle = prev !== undefined && isStaleEngineAgentPanelEnd(prevIdentity, rowIdentity);
-        // 🔴 粘性只在**同一周期**内成立:上一条已 settle(同 id 复活 = 新周期)或 launch 锚换了 ⇒ 不继承上一周期的用量
-        //    (否则新周期首帧没报 tokens 时会把上一周期的数当成当前读数发布;异源对抗复审)。
         const sameCycle = prev !== undefined &&
             !prev.settled &&
             (startedAt === undefined || prev.startedAt === undefined || prev.startedAt === startedAt) &&
-            // 0.74.0:代际号变了同样是新周期(两条都报了才比;任一条没报 = 这一帧没说)
             (cycleSeq === undefined || prev.cycleSeq === undefined || prev.cycleSeq === cycleSeq);
         const knownTokens = tokens !== undefined ? tokens : sameCycle ? prev?.tokens : undefined;
-        // 本周期已知的 launch 锚:帧上给了用帧上的,没给则同周期沿用。🔴 它随**每一条** fleet-row 发布(不只是变化那一帧)——
-        // 事件缓冲靠它判「这两条部分帧是不是同一周期」;缺锚的部分帧会让跨周期合并绕过屏障(异源对抗复审 [high])。
-        // 🔴 身份的沿用与用量的沿用是两回事(异源对抗复审 R3):用量只在**活着的同周期**内粘(`sameCycle` 要求
-        //    !prev.settled);身份只要这一帧**不可证更新**就沿用 —— 同周期重复的终态帧若把记住的 startedAt / cycleSeq
-        //    抹掉,下一代只带另一半身份时就判不出「更新」,被 settled 吞掉。
         const carryIdentity = prev !== undefined && !rowNewerCycle;
         const knownStartedAt = startedAt !== undefined ? startedAt : carryIdentity ? prev.startedAt : undefined;
         const knownCycleSeq = cycleSeq !== undefined ? cycleSeq : carryIdentity ? prev.cycleSeq : undefined;
         if (TERMINAL_FLEET_TASK_STATUSES.has(status)) {
-            // ② 终态一次性 settle(幂等台账;消费端 settle 也幂等)。0.74.0:去重按**周期** —— 已 settle 的是上一代、这一帧是
-            //    更新的一代(中间没见到 running 帧)⇒ 新周期的终态照发,不被上一代的 settled 吞掉。
-            // 🔴 0.74.5 CC-86(cli L-415):**首次见到就已终态**的行(prev 缺席)零事件 —— 只在台账记 settled。此前先发 fleet-row
-            //    (交最终用量)再发 end ⇒ 宿主为本会话从没跑过的任务建行随即 settle = 面板幽灵完成行(reattach / resume 后引擎
-            //    fleet 列表里的历史终态行全部上屏)。本会话内起步又结束、面板从没见过 running 的后台任务由通知车道的 end 收尸;
-            //    复活(prev 已 settled 且这一帧周期更新)不在此列,照发。
-            // 0.75.0 W2:「首见」= 消费端没有这一行(没发布过 running **也没递达过 end**);通知 end 先到的短命子代 ⇒ 终态行照发(交最终用量,不再第二次 end)。
             const newbornTerminal = prev === undefined && panelRowUnknownToConsumer(taskId);
             const settledThisCycle = prev?.settled === true && !rowNewerCycle;
-            // 结过的行(本进程递达过 end)再来终态帧:同代或判不出代际 = 短命子代的最终用量到了 ⇒ 只发 fleet-row、不再第二次 end;
-            // 可证更新的一代 = 结过之后复活又结束 ⇒ 照发 fleet-row + end。
             const endedRec = prev === undefined ? panelRowEndedIdentity(taskId) : undefined;
             const frameCycle = { ...(cycleSeq !== undefined ? { cycleSeq } : {}), ...(startedAt !== undefined ? { startedAt } : {}) };
-            // 方向判(异源复审 R3 [high]:只判「不等」会把迟到的前代终态当成新一代 ⇒ 倒写用量 + 第二次 end):
-            //   帧可证比已结周期**旧** ⇒ 整帧丢(不进台账,不发);可证**新** ⇒ 复活又结束,fleet-row + end;同代 / 判不出 ⇒ 只补用量。
             if (endedRec !== undefined && isStaleEngineAgentPanelEnd(frameCycle, endedRec))
                 continue;
             const endedSameCycle = endedRec !== undefined && !isStaleEngineAgentPanelEnd(endedRec, frameCycle);
             if (newbornTerminal) {
-                // 反序保护:end 也许下一拍才到 ⇒ 终态行(带用量)缓在历史叶里,end 到漏斗时先放它再放 end;真历史行永远等不到 end,缓着直到被挤掉。
                 holdNewbornTerminalRow(taskId, {
                     kind: 'fleet-row',
                     taskId,
@@ -220,13 +95,8 @@ export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
                 });
             }
             else if (!settledThisCycle) {
-                // 终态行也把最后一拍的累计工具数/转录锚带上:详情页在行翻终态后仍要显示真计数与
-                // 委派 prompt,而终态帧常常是这一行**唯一**带全 usage 的一帧(bg lane 只在活动边界发行帧)。
-                if (
-                // 0.74.0:周期身份本身推进(或首帧就带身份)也是变化 —— 消费端要先记下身份才能对 end 判陈旧。
-                rowNewerCycle ||
-                    (cycleSeq !== undefined && prev?.cycleSeq !== cycleSeq) || // 含首帧(prev 缺席)就带身份的终态
-                    // 最终用量也算(终态帧常是唯一带全 usage 的一帧;消费端不更新非 running 行 ⇒ 必须赶在 end 之前发)
+                if (rowNewerCycle ||
+                    (cycleSeq !== undefined && prev?.cycleSeq !== cycleSeq) ||
                     (tokens !== undefined && prev?.tokens !== tokens) ||
                     (toolUses !== undefined && prev?.toolUses !== toolUses) ||
                     (transcriptId !== undefined && prev?.transcriptId !== transcriptId) ||
@@ -249,11 +119,7 @@ export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
                     publishEngineAgentPanelEvent({
                         kind: 'end',
                         taskId,
-                        // L-215② 族扫(0.65.0):与 `notifications.enqueueBgChildNotification` 的 `isError` 位
-                        //    **同一个病形**(内联两词 ⇒ core [6908] 的 `blocked` 漏成「成功」)。两处一次改齐,
-                        //    读同一个单铸谓词;只修当格 = 下一次加词又漏一处。
                         isError: isTerminalNotSuccess(status),
-                        // 0.74.0:这条终态属于哪个周期(在场才带)—— 消费端据此挡掉上一周期迟到的 end。
                         ...(knownCycleSeq !== undefined ? { cycleSeq: knownCycleSeq } : {}),
                         ...(knownStartedAt !== undefined ? { startedAt: knownStartedAt } : {}),
                     });
@@ -269,36 +135,18 @@ export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
                 currentToolKey: currentToolKey !== undefined ? currentToolKey : prev?.currentToolKey,
                 lastSeenAt: nowMs,
                 settled: true,
-                // notif-F13:settle 时刻只在**首次** settle 时铸(重复投影的终态行不许一路续命回收期)。
                 settledAtMs: prev?.settled ? prev.settledAtMs : nowMs,
                 absentReportedAtMs: undefined,
             });
             continue;
         }
-        // 🔴 0.75.1:缓着一条「首见即终态」的行时,后到的 running 帧有**三向**(0.75.0 是无条件作废 ⇒ 同代陈旧快照
-        //    把终态那条的最终用量顶掉,面板最后显示的是快照里的小数字):
-        //      · **可证同代**(两侧有可比的同一种周期键且相等)= 陈旧快照 —— 与终态分支 `settledThisCycle` 同律:
-        //        整帧不落地(零事件、台账保持 settled),缓行留着等 end;
-        //      · **可证更新** ⇒ 真复活:照发 running 行,缓着的前代终态行作废(下面那句 drop);
-        //      · **判不出**(任一侧没有可比的周期键)⇒ 维持 0.75.0 的行为(当复活、作废缓行)—— 缺席不制造周期,
-        //        这一向是**已知并接受**的限制(接入文档的缺口行有记)。
-        //    「可证更旧」不在这三向里:它在本循环开头就被 `isStaleEngineAgentPanelEnd(rowIdentity, prevIdentity)` 整只跳过了。
-        //    可比性只由**帧自带的**两键与台账里记着的两键决定(不能用 `knownCycleSeq` / `knownStartedAt` —— 那两位会把
-        //    缺席沿用成「与台账相等」,把「判不出」误判成「可证同代」)。判据与 `isNewEngineAgentPanelCycle` 的前件同形。
         const cycleComparable = (cycleSeq !== undefined && prev?.cycleSeq !== undefined) || (startedAt !== undefined && prev?.startedAt !== undefined);
-        //    🔴 再加一道 `prev.settled` 的窄化:缓行只由**终态**分支铸(铸完台账即 settled),所以「缓着行而台账说它在跑」
-        //    在本会话的台账里不可达;写出来是为了让这一格永远只对**结过的行**生效 —— 缓行表是进程级、seenMap 是按
-        //    sessionKey 分桶的两个作用域,不写这一句的话,别的会话缓的行会让本会话一条真在跑的行被判成陈旧快照。
         const staleSnapshotOverHeldRow = prev !== undefined && prev.settled === true && cycleComparable && !rowNewerCycle && peekHeldNewbornTerminalRow(taskId) !== undefined;
         if (staleSnapshotOverHeldRow)
             continue;
-        // ① 只发变化(新行 / status 翻 / token 涨 / 累计工具数涨 / 转录锚首次到)。
-        // 🔴 后两项的比较是**单向**的:只有「这一帧真给了值且与台账不同」才算变化。帧上**缺席**
-        //    不算变化(缺席=引擎这帧没说,不是「回到不知道」)——否则新旧引擎混发时台账会在
-        //    值↔undefined 之间来回抖,每秒白发两次事件。
         if (!prev ||
             prev.settled ||
-            prev.absentReportedAtMs !== undefined || // 行回来了:即使值未变也发一条,消费端据此撤掉 absent 标
+            prev.absentReportedAtMs !== undefined ||
             prev.status !== status ||
             prev.tokens !== knownTokens ||
             (toolUses !== undefined && prev.toolUses !== toolUses) ||
@@ -307,15 +155,14 @@ export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
             (startedAt !== undefined && prev.startedAt !== startedAt) ||
             (cycleSeq !== undefined && prev.cycleSeq !== cycleSeq) ||
             (currentToolKey !== undefined && prev.currentToolKey !== currentToolKey)) {
-            notePanelRowRunning(taskId); // CC-86:真发布了这一行在跑才记历史(未变的陈旧快照零事件也零记账,复审 R3)
-            dropHeldNewbornTerminalRow(taskId); // 复活为 running ⇒ 缓着的旧终态行作废(用量以新一代为准);可证同代的陈旧快照到不了这里(三向判定,见上)
+            notePanelRowRunning(taskId);
+            dropHeldNewbornTerminalRow(taskId);
             publishEngineAgentPanelEvent({
                 kind: 'fleet-row',
                 taskId,
                 ...(row.name ? { name: row.name } : {}),
                 ...(row.description ? { description: row.description } : {}),
                 ...(knownTokens !== undefined ? { totalTokens: knownTokens } : {}),
-                // 🔴 缺席即不落键(消费端据「键在不在」判三态)。
                 ...(toolUses !== undefined ? { toolUses } : {}),
                 ...(transcriptId !== undefined ? { transcriptId } : {}),
                 ...(parentToolCallId !== undefined ? { parentToolCallId } : {}),
@@ -324,7 +171,6 @@ export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
                 ...(currentTool !== undefined ? { currentTool } : {}),
             });
         }
-        // 台账对这几位是**粘性**的:缺席帧不擦掉已知值(同上的单向语义)。
         seenMap.set(taskId, {
             status,
             tokens: knownTokens,
@@ -336,30 +182,19 @@ export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
             currentToolKey: currentToolKey !== undefined ? currentToolKey : prev?.currentToolKey,
             lastSeenAt: nowMs,
             settled: false,
-            settledAtMs: undefined, // 又活了 ⇒ 回收钟归零(重新 settle 时重铸)
-            absentReportedAtMs: undefined, // 在场 ⇒ 缺席周期结束(下次再消失是新周期,会再上报一次)
+            settledAtMs: undefined,
+            absentReportedAtMs: undefined,
         });
     }
-    // ③ 缺席上报 —— 必须在【本次在场行全部刷完 lastSeen 之后】判,否则 footer 长时间卸载后重挂
-    //    会把仍在跑的行按「陈旧」误报。🔴 0.72.12 CC-50:这里只发 `absent`,**不** settle、不铸 end ——
-    //    缺席不是终局,本包不替引擎下这个断言;真终态帧迟到照走 ② 发那唯一一次 end(去重记号不被缺席占用)。
     for (const [taskId, s] of seenMap) {
         if (present.has(taskId) || s.settled || s.absentReportedAtMs !== undefined)
             continue;
         const absentForMs = nowMs - s.lastSeenAt;
         if (absentForMs <= ABSENT_SETTLE_MS)
             continue;
-        // 🔴 0.72.13:走**独立缺席口**,不上主通道(老消费者的裸 else = sweep 体,会把新 kind 当 sweep;见 store 头注 / DS-07)。
         publishEngineAgentPanelAbsence({ taskId, lastSeenAtMs: s.lastSeenAt, absentForMs });
         seenMap.set(taskId, { ...s, absentReportedAtMs: nowMs });
     }
-    // ④ REF-CC-045(fleet2-07):settled 条目回收 —— 给台账一个上界(此前只增不减)。settle 已发过
-    //    事件,delete 对外无事件,消费端 settle 本身幂等。
-    //    [2393] notif-F13/sweep-F7 两处纠(判据见 SETTLED_RETENTION_MS 头注):
-    //      · 锚 `settledAtMs`(settle 那一刻)而不是 `lastSeenAt`(最后一次被投影);
-    //      · 只回收**已不在场**的条目 —— 仍在场的终态行删了会每拍重发 end。
-    //    0.72.12:已上报 absent 且始终不再在场的条目同样有上界 —— 锚 `absentReportedAtMs`(上报那一刻),
-    //    回收后迟到的终态帧仍会发恰一次 end(prev 缺席 ⇒ 首次 settle),行回来则按新行重建。
     for (const [taskId, s] of seenMap) {
         if (present.has(taskId))
             continue;

package/dist/fleetTaskDesc.d.ts

@@ -1,43 +1,4 @@
-/**
- * ⇄ B1 批搬迁(2026-07-27,多端改造设计稿 §2.4.1-B):cli src/sema/fleetTaskDesc.ts 逐字搬入(零依赖;壳侧改 re-export)。
- */
-/**
- * src/sema/fleetTaskDesc.ts — footer fleet 行「label/描述列」纯投影助手(零依赖,从 fleetClient.ts 提出
- * 供单测直取——fleetClient 拖 SDK/appState/notification 重图,无法轻量 bundle;行为与提出前逐字同源)。
- */
 export declare function escapeDisplayControlChars(s: string): string;
-/**
- * UNTRUSTED-for-display 呈前处理的**共用铸点**:**先转义、后按转义结果封长**。
- *
- * 🔴 顺序反过来会让承诺的显示预算失守 —— {@link escapeDisplayControlChars} 把每个不可见字符
- *    改写成 6 字符的 `\uXXXX`,先按原文截长再转义,会把一段纯控制字符的 `max` 个原始字符送成
- *    `6 × max` 个显示字符。屏上的列宽预算是按**显示字符**给的,所以封长必须量转义后的那一份。
- * 🔴 相反方向的顾虑(「先转义后截会把一枚转义序列拦腰截断」)由下面两条避让解掉,不构成
- *    改回先截后转义的理由:
- *      · 截点落在一枚 `\uXXXX` token 中间 ⇒ 回退到该 token 之前(留半截 `\u00` 比整枚不渲更坏,
- *        它看起来像一个完整答案的开头);
- *      · 截点落在一对合法代理对(如 emoji)中间 ⇒ 回退一位。`DISPLAY_UNSAFE` 只转义**孤**代理项,
- *        合法对被放行原样透传,在这里截断等于人为造一枚裸高位代理项留在末尾。
- *
- * 语义:返回值恒是**已消毒**的串,长度 ≤ `max`(可能因避让短于 `max`)。`max <= 0` ⇒ 空串。
- *
- * ⇄ 本函数是本包该族的**唯一**实现(0.62.0 起):operator 面的 READ 档位读器、写保护姿态行、
- *   SQL 姿态行四处此前各写一份,其中三份是先截后转义 —— 同形存量清剿后一律接这一只。
- */
 export declare function capForDisplay(raw: string, max: number): string;
-/** collapse a wire label to a single trimmed line (drops embedded newlines/runs). 187 row labels are always
- *  one short line; the <FleetTree/> column (Math.min(28,…) + wrap="truncate") does the visible ellipsis, so we
- *  only normalize here — no double-ellipsis, faithful to the 187 render.
- *  #307:折叠之后再过 {@link escapeDisplayControlChars} —— `\s+` 折叠管不到 C0 非空白段/C1(NEL)/
- *  双向控制符/孤代理项,那四族原样透到终端就是「一行」这个结构账被绕过。空/非空判定不变
- *  (可见转义不产生空白,`|| fallback` 那些调用点的真假面照旧)。 */
 export declare function collapseLabel(s: string): string;
-/** CC row-body fallback(CC 真身锚 2026-07-20 人类剧本帧:`◯ general-purpose  t1calc`——row body 从第一帧
- *  起就是 Agent 工具的 description)。引擎子行帧不带 `description` 字段,任务描述只在 `name` 里,且有两形
- *  (07-24 D2 wire 实证,engine 1.271.0 帧 dump):
- *    ① 出生帧:name = `${agentType}: ${description}` 合成形(如 "fork: t1calc")→ 剥前缀复原;
- *    ② 后续帧:引擎把 name 重写为【裸任务描述】(如 "t1calc",无前缀)→ 直接按描述投影——
- *      修前只认①,②一到描述列即塌空(footer 只剩 `◯ fork`,D2 症状)。
- *  防重复列 belt:裸 name 恰为 identity 回声(=agentType 或 =agentName)时不当描述(label 列已渲它)。
- *  纯投影非双源;真进度(last tool name)到帧后仍然优先(调用侧 projectDescription 先行)。 */
 export declare function taskDescFromName(name: string | undefined, agentType: string | undefined, agentName?: string): string;