@sema-agent/client-core 0.74.4 → 0.75.0

package/CHANGELOG.md

@@ -49,6 +49,44 @@
 > 挡住 ⇒ 本批把它机械化——④a0 对 `pending` 行**要求段头已是日期形**(`(未发布)` 直接红),阶段一
 > commit 漏转在发布前就红,不再靠人记。
 
+## 0.75.0(2026-09-20)
+
+> 主题:**压缩的非 compacted 结局上 chrome 面**(CC-89;此前三端都看不见压缩失败)+ **peer sdk 地板 `>=9.8.1`**(CC-81)+ **短命子代的最终用量不再丢**(0.74.5 首见即终态零事件的代价面,外部复验读数)。**minor**:① 新内部臂 `compaction_outcome` 进 `INTERNAL_SDK_ARM_TYPES` —— 自建 print / stream-json 出口的端**必须**先给它表态(吞或转),否则它会顺着兜底透传成越界帧;② peer 地板抬升。型面 additive(`ChromeEvent` +1 臂 `CompactionOutcomeChromeEvent`;值导出零增)。接入面 §74。
+
+### Added
+
+- **chrome 臂 `compaction_outcome`(CC-89)**:引擎的 `compaction_outcome` 帧(一次压缩**没有**以 compacted 收尾:被任务终态抢先而作废、熔断开着而失败等)此前在投影口落 `not_in_slice`,包内与三端零消费者 —— 压缩失败对用户不可见。现在:投影口出内部臂 `{type:'compaction_outcome', outcome, trigger?, reason?, …identity}`,适配层出 `ChromeEvent{kind:'compaction_outcome', laneProof, outcome, trigger?, reason?, eventId?}`,转录面零行(CC 转录里只有成功压缩的 `compact_boundary`,不替它编消息)。`outcome` / `trigger` 是引擎开集原词,逐字不折;`trigger` / `reason` 非空串才在场;`outcome` 缺席 / 非串 / 空串 ⇒ malformed。lane 如实:`parentToolCallId` 在场 ⇒ `laneProof.lane === 'subagent'`;只能靠 `sourceTaskId` / `bgAgentId` 归因的帧不发(没有诚实的 lane 可挂,不落到主会话名下;KNOWN-LIMITS KL-22)。臂表 `required:false`。
+
+### Fixed
+
+- **短命子代的最终用量不再被「首见即终态零事件」吞掉(0.74.5 CC-86 的代价面;外部复验 W2 读数)**:子代在面板两拍之间起步并结束、从没投影过 running 时,通知车道的 `end` 已递达(消费端建了行、状态 ended),终态 `fleet-row` 却被当成历史行零事件 ⇒ 行在、`totalTokens` / `toolUses` 两位空。「首见」的判据从「本进程没发布过 running」改成「消费端没有这一行」= 没发布过 running **也没递达过 end**:历史叶加第二本账(漏斗里任何 lane 的当代 `end` 递达后记 ended{周期身份},有界 4096)。结过的行再来终态帧:同代 / 判不出代际 ⇒ 恰一条 `fleet-row` 交最终用量、**不再第二次 `end`**;可证更新的一代(结过之后复活又结束)⇒ 照发 `fleet-row` + `end`。反序(终态 `fleet-row` 先到、`end` 后到)⇒ 终态行先缓住(有界 4096),`end` 到漏斗时**先于一切身份归一**放出(放出的行帧登记的钥匙 / 所有权,后面的 `end` 归一必须看到)、按代际 peek 后再放(`end` 可证更旧 ⇒ 缓行留着;可证更新 ⇒ 作废;同代 / 判不出 ⇒ 放);复活为 running 作废缓行;真历史行永远等不到 `end`,不上屏。结过的行再来的终态帧按**方向**判:可证更旧 ⇒ 整帧丢(不倒写用量、不第二次 `end`);ended 账单调写、`end` 的陈旧判据同时参考行帧水位与 ended 账(短命子代常没有行帧水位)。0.74.5 的两格「零事件」改口为「零 `end`、至多一条 `fleet-row`」。
+- `compacted.freedTokens` 负值 / 非有限在本包按缺席(不夹到 0):注释此前写「夹 ≥ 0」与代码不符,改注释不改代码 —— 缺席比编一个 0 诚实(外部复验读数)。
+
+### Changed
+
+- **peer `@sema-agent/sdk` 地板 `>=9.7.1` → `>=9.8.1`(CC-81)**:9.8.x 给 `Capabilities.deviceExecutor` 的对象臂声明了 `management?: boolean`(本包 0.74.2 起的读器此前按结构读),包现在对 9.8.1 编译,消费端实装全在 9.8.1 ⇒ 9.7.1 失去物料见证。读器运行时行为零变化(入参仍按不可信结构防御读);device 读器门 +7 格把 sdk 声明形(可选键 / false 臂 / `management` 可选布尔;readonly / `| undefined` 算兼容形)钉住,声明删除 / 行注释伪证 / string 退化 / 改必填 各一枚负控;读器本身仍按不可信结构读,关联只在门。
+- 两只测试钩(`__resetEngineAgentPanelIdentityForTests` / `__resetPanelRunningHistoryForTests`)的注释逐表列出清什么、不清什么,并写明连续场景中途别调(外部验收方的请求)。
+
+### Guards
+
+- panel-cycle 门 +19 格(S1v / S1w / S1x / S1y / S1z 族:两序 / 真历史行 / 复活新一代 / 前代 end 不放当代缓行 / 前代迟到帧不作废缓行;S1α–S1δ 族:异源对抗复审第三轮四条 [high] 反例 —— 缓行放出后重新归一 / 迟到前代终态帧整帧丢 / ended 账不倒写 / 前代 end 不取走当代缓行)、pure 门与身份归一门两格改口;singleton +2 high(ended 账 / 缓行表,上限 116 → 118)。
+- 新门 `scripts/run-compaction-outcome-projection-test.mjs` 18 格(投影口 10 / 适配层 8;异源对抗复审 R1 [medium] 采修 —— 投影器不浅拷帧:展开会擦掉原型链上的身份键、还执行无关的可枚举 getter,与兄弟臂同律逐键读);device 读器门 +7(T1–T7);sdk 地板门 FLOOR 9.8.1,负控锚同批。新门 A3 改成同序列有 / 无结局帧的转录面逐字对拍(异源对抗复审 R2 [medium]:只排除同名 type 的行守不住「零新增转录行」)。
+
+## 0.74.5(2026-09-19)
+
+> 主题:**core 7.24.0 提货**(CC-85 `compacted.freedTokens?`)+ **首见即终态的行零事件**(CC-86;cli L-415 幽灵完成行)+ **`isNewEngineAgentPanelCycle` 上公面**(CC-87)。**patch**:型面 additive(+2 常量 +2 函数,公面 1061 → 1065;`compact_metadata._sema_freed_tokens?` 超集键;零 wire 新键 —— `freedTokens` 由 core 7.24.0 铸;peer 不动)。接入面 §73。
+
+### Added
+
+- **`compact_metadata._sema_freed_tokens?`(CC-85;core 7.24.0 #946)**:`compacted.freedTokens?` 是引擎自己测的结构性差值(夹 ≥ 0),旧的 `tokensBefore` / `tokensAfter` **不是可相减的一对**;在场(有限非负数)才带,缺席 = 没测出来 ⇒ 键不落,渲「未知」不是 0。CC 同名键 `pre_tokens` 一字不动(它是 CC 必填数,`tokensBefore` 缺席仍兜 0 —— 记 KNOWN-LIMITS)。
+- **`approvalOutcomeNoteOf(frame, outcome)`(CC-88;cli 归包候票)**:流内帧腿审批结局 → 宿主便签 `{approvalId, settled, retracted?, detail?}` 的单源映射(三端装配点此前各手拼一份;语义按 cli 1.0.123 现行:`settled = decision !== 'unresolved'`,`retracted` 只在 true 时带键且不含 editRefused,`detail` 三支优先序撤卡句 / 编辑被拒句 / `respondRefusal` 码·文案,空 ⇒ 缺席);两句固定文案作常量出。
+- **`isNewEngineAgentPanelCycle(prev, next)`(CC-87)**:「这一帧是不是新周期」的单源判据(`isStaleEngineAgentPanelEnd` 的对偶;两边都带 `cycleSeq` 只比它,否则比 `startedAt`,任一边判不出 ⇒ 不是新周期);缓冲合并屏障 `launchAnchorChanged` 改为委托它。
+
+### Fixed
+
+- **反向所有权按 transcriptId 到期(test [7718] 契约层反例)**:0.74.4 的「尾段 → 先发布的 UUID」所有权只按周期键到期,行帧两个周期键全缺(真字节里只有 root 形行如此,子代行恒带)时复活的新一代被改写到旧 UUID ⇒ 消费端一条已结的行又收新帧;现在登记时记 transcriptId,换了 = 新一代子会话,所有权同样到此为止。
+- **首次见到就已终态的 fleet 行零事件(CC-86;cli L-415)**:此前对 prev 缺席且 status 终态的行先发 `fleet-row`(交最终用量)再发 `end` ⇒ 宿主为本会话从没跑过的任务建行随即 settle = 面板幽灵完成行(reattach / resume 后引擎 fleet 列表里的历史终态行全部上屏)。现在只在台账记 settled、不发事件;「首见」= **本进程**从没发布过它在跑(历史作用域 = 面板订阅作用域,不按会话分桶 —— A 会话发的 running 行由 B 会话的终态帧结掉是常态;发布过 running 的行即使台账已回收,迟到终态仍照发 end;历史结掉即删 —— **任何 lane 的 `end` 到漏斗都销账**(通知车道的 end 不经投影;只销当代,前代迟到的 end 不擦新一代)、有界 4096、溢出后转保守不再压制,直到整表重置;共享叶 `src/panelRunningHistory.ts`;异源对抗复审 R1 / R2 三条所抓;R3 四条:父键登记的所有权按 wireId 作转录身份到期 / 归一 end 的退役按**事件自带**周期判(缺席才借钥匙,与递达同一身份)/ 已发布 UUID 的 end 连它名下尾段的历史一起销 / 只在真发布了 running 行帧时记历史,未变的陈旧快照不把结掉的 id 记回去);本会话内起步又结束而面板从没见过 running 的后台任务由通知车道的 `end` 收尸;复活(已 settled 且周期更新)照发。
+
 ## 0.74.4(2026-09-19)
 
 > 主题:**面板键「先发布的键为准」**(CC-83;test [7702] 证伪 0.74.3「面板桥零改」)+ **前代 UUID 的迟到 tick 丢弃**(CC-84;test [7702] W2 tick 腿)+ `readRunCancelContext` 下钻收紧。**patch**:型面 additive(`fleet-row` 臂 +`wireTaskId?` / `taskIdOrigin?`,`end` 臂 `taskIdOrigin` 多一词 `'wire'`,`EngineAgentPanelAbsence` +`wireTaskId?`;公面导出名零增减 1061;零 wire 新键;peer 不动)。接入面 §72。

package/README.md

@@ -35,7 +35,7 @@ Renamed from **`@sema-agent/wire-cc-adapter`** (0.1.x, deprecated — see *Migra
 
 ## Scope
 
-**Version:** 0.74.4
+**Version:** 0.75.0
 
 - **Today** — the adapter seam, the whole `adapt()` pipeline (all 14 A-layer arms plus the
   B/D/E tool-card layers), the notification/caps/model families, the adapter kernel (stream driver
@@ -67,7 +67,7 @@ Renamed from **`@sema-agent/wire-cc-adapter`** (0.1.x, deprecated — see *Migra
     against — the tables live upstream precisely so this package does not keep a second copy that can
     fall behind. The browser bundle really bundles the SDK through (the portability guard would
     exit 3 rather than quietly mark it external).
-  - The declared floor is `>=9.7.1` (raised from `>=9.6.0` in 0.74.0: `Capabilities.approvalsStreamLive` / `.executionLane`, `LivePendingRow.frame`, the `live_*` approval-stream events and `gates[].toolCallId` are typed from 9.7.x on, and no consumer ships 9.6.0 any more, so the older floor lost its witness; before that raised from `>=9.4.0` in 0.71.0: the `tool_disclosure` / `tool_progress` frames and `ToolApprovalFrame.readRootCandidate` are typed there; earlier: raised from `>=8.8.0` in 0.69.0: the `reasoning_end` frame and `McpStatusPanel.lastLegMcp` are typed from 9.4.0 on), and it is *witnessed*: the guard checks that an actually
+  - The declared floor is `>=9.8.1` (raised from `>=9.7.1` in 0.75.0: `Capabilities.deviceExecutor.management` is typed from 9.8.x on, the package now compiles against 9.8.1, and no consumer ships 9.7.x any more, so the older floor lost its witness; before that raised from `>=9.6.0` in 0.74.0: `Capabilities.approvalsStreamLive` / `.executionLane`, `LivePendingRow.frame`, the `live_*` approval-stream events and `gates[].toolCallId` are typed from 9.7.x on, and no consumer ships 9.6.0 any more, so the older floor lost its witness; before that raised from `>=9.4.0` in 0.71.0: the `tool_disclosure` / `tool_progress` frames and `ToolApprovalFrame.readRootCandidate` are typed there; earlier: raised from `>=8.8.0` in 0.69.0: the `reasoning_end` frame and `McpStatusPanel.lastLegMcp` are typed from 9.4.0 on), and it is *witnessed*: the guard checks that an actually
     installed SDK at that line still exports every value-level symbol this package imports and still
     declares `TaskStats.costMicroUsd` (the key `costOrNull` reads). A floor nobody ever ran is a
     promise, not a contract.
@@ -317,7 +317,8 @@ public-surface guard checks that last one).
 | `scripts/run-run-cancel-context-test.mjs` | The run record's `cancelContext` side-note (engine ≥7.87.3) read structurally, and the cause of a `turn_aborted{engine_error}` classified from machine-readable evidence only: `cancelled` (code `cancelled`, with the cancel-time context when present) / `engine_error` (any other failure code, passed through verbatim) / `run_still_live` (the record is not terminal — a dropped stream is a client-side fact, not the run's cause) / `unknown` (never guessed). An absent `cancelContext` reads as *not reported*, never as "not cancelled"; `elapsedMs` is never folded to 0. |
 | `scripts/run-suspended-reopen-projection-test.mjs` | The durable `suspended` event's `reopened` key read as three distinct states — `reopened` (with the engine's code, verbatim), `not_reopened` (an explicit `null`), `unstated` (key absent or unreadable) — and carried on the HITL bridge's active gate (`currentGateReopen()`), re-read on every `suspended` and cleared with the gate. |
 | `scripts/run-panel-identity-normalization-test.mjs` | One background subagent has two ids on the wire — the fleet row id tail and the `task_progress` task id (its transcript id). Every panel event goes through one funnel that rewrites the `tick` / `end` task id onto the fleet row's id once a `fleet-row` has registered the key (`transcriptId` first, `parentToolCallId` as the fallback), carrying the original as `wireTaskId` and marking `taskIdOrigin`; an unbound tick whose row has not arrived yet waits one beat (bounded) and is released verbatim on the next tick / `end`, when the buffer is full, or after `MAX_HELD_WIRE_TICK_BEATS` other fleet-row / end / sweep events (a `sweep` itself leaves it alone: there is no row to settle yet); a normalized `end` that carries no cycle identity borrows the registering row's, so a late close of a revived task is recognized as stale; the key table is an LRU (a task that keeps ticking is never evicted by newer registrations); the residency mark migrates with the id and both keys are cleared on settle — except that a stale (previous-cycle) terminal never clears the revived row's mark — so the notification lane can clear it. Once a tick has been delivered verbatim under its UUID, that UUID is the subagent's key: later fleet rows and fleet-side ends are rewritten onto it (the tail kept in `wireTaskId`), so a consumer sees one row in every arrival order; a late tick from a previous cycle is dropped rather than folded into the revived row. |
-| `scripts/run-approval-card-retract-test.mjs` | The approval card's **decision-free retraction** and the in-stream frame leg's **outcome hand-back**: a host that must withdraw a card that no longer has a decision channel (session switch, engine switch, a tracker reporting the ask gone) answers `{ kind: 'retracted' }` and the package sends nothing on any of the three legs (in-stream frame, suspended ask, durable park), reporting `decision: 'unresolved'` with a `retracted` flag; `aborted` / `failed` / `deny` keep their meaning (a real deny is still posted), and `onToolApprovalOutcome` hands every in-stream outcome back to the host exactly once, tolerating a throwing or rejecting callback |
+| `scripts/run-compaction-outcome-projection-test.mjs` | The `compaction_outcome` frame (a compaction that did **not** end as compacted: mooted by the task ending, failed, …) projected to an internal arm and then to the additive `compaction_outcome` chrome event — `outcome` required and verbatim (open set), `trigger` / `reason` present only when the engine sent a non-empty string, malformed frames dropped, zero transcript rows, the lane told honestly (`parentToolCallId` ⇒ subagent lane; a frame attributable only by `sourceTaskId` / `bgAgentId` is not surfaced on the main lane). |
+| `scripts/run-approval-card-retract-test.mjs` | The approval card's **decision-free retraction** and the in-stream frame leg's **outcome hand-back**: a host that must withdraw a card that no longer has a decision channel (session switch, engine switch, a tracker reporting the ask gone) answers `{ kind: 'retracted' }` and the package sends nothing on any of the three legs (in-stream frame, suspended ask, durable park), reporting `decision: 'unresolved'` with a `retracted` flag; `aborted` / `failed` / `deny` keep their meaning (a real deny is still posted), and `onToolApprovalOutcome` hands every in-stream outcome back to the host exactly once, tolerating a throwing or rejecting callback Also the single source for the host-side approval-outcome note (`approvalOutcomeNoteOf`): `settled` is whether the decision was delivered, `retracted` is an independent key present only when the card was retracted, and `detail` is the retraction / edit-refused sentence or the refusal code and message — never a fabricated sentence. |
 | `scripts/run-panel-cycle-identity-test.mjs` | The **cycle identity** on agent-panel events and the fleet ledger's **departure read-out**: a background agent may be revived under the same id, so `fleet-row` and `end` events now carry the wire's own `cycleSeq` / `startedAt` when present (absent means the row has no notion of generations, never "generation one"), `isStaleEngineAgentPanelEnd` is the single rule for ignoring a late `end` from a previous cycle (only when both sides carry a comparable identity; absence never drops a real terminal), a changed `cycleSeq` is a new cycle for usage stickiness and buffer coalescing, the notification lane carries `cycleSeq` only when the wire really sent `seq`, and `task_remove` frames reach the host through `onTaskRemoved` with `removeReason` / `cycleSeq` verbatim, a stale previous-generation removal leaving the newer row in place |
 | `scripts/run-workflow-size-warning-test.mjs` | The **workflow size warning** verdict shared by every host footer / panel: a three-state result (`warn` / `ok` / `unknown`) read off the optional fleet view keys, where an unknown size is never reported as a normal one (absent `totalCount` / `tokens` without positive over-cap evidence is `unknown`, naming the missing keys), positive evidence on either axis wins regardless of absent keys, the per-agent denominator uses the engine's started count only when it is not below done+failed (a smaller value is a stale reading), otherwise falls back to the done+failed lower bound only when both keys are present — and a lower-bound denominator only yields an upper bound of the projection, which can prove *within cap* (`ok`, flagged) but never *over cap* (`unknown`, with the upper bound exposed) — and the prior is used only when the engine itself reports zero started agents; cap precedence env > explicit guideline > default, prototype keys never act as a guideline, the env reader is pure and does not fall through to the second name on a bad first value; caps, guideline table, env names and the three copy variants are single-sourced |
 | `scripts/run-approvals-stream-live-capability-test.mjs` | The engine's live-approval-push self-description (`capabilities.approvalsStreamLive`, engine ≥7.87.1), read the same four-state way as its four sibling capability readers: an absent key is reported as not reported (never folded into `false`), the value must be a strict boolean, and the one decision the feed consumer needs — whether it must keep pulling suspended asks itself — is answered by `livePendingNeedsReconcile`, which only says no when the engine explicitly says it pushes. |

package/dist/adapt/arms.js

@@ -557,6 +557,35 @@ const contextUsageArm = function* (m) {
         ...(typeof m.eventId === 'string' && m.eventId.length > 0 ? { eventId: m.eventId } : {}),
     });
 };
+/**
+ * CC-89(0.75.0):`compaction_outcome` 内部臂 → chrome `compaction_outcome`。每帧一条;转录面零行。
+ * 🔴 lane 如实:`parentToolCallId` 非空串 ⇒ subagent;只有 `sourceTaskId` / `bgAgentId`(或父键空串)的帧没有诚实的 lane 可挂 ⇒ 不发,
+ *    绝不落到主会话名下。`outcome` 非空串才发(非投影口喂进来的坏帧兜底)。
+ */
+const compactionOutcomeArm = function* (m) {
+    const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+    const outcome = str(m.outcome);
+    if (outcome === undefined)
+        return;
+    let laneProof = MAIN;
+    if (isSubFlowSegmentEnd(m)) {
+        const parent = str(m.parentToolCallId);
+        if (parent === undefined)
+            return;
+        laneProof = { lane: 'subagent', parentToolCallId: parent };
+    }
+    const trigger = str(m.trigger);
+    const reason = str(m.reason);
+    const eventId = str(m.eventId);
+    yield chrome({
+        kind: 'compaction_outcome',
+        laneProof,
+        outcome,
+        ...(trigger !== undefined ? { trigger } : {}),
+        ...(reason !== undefined ? { reason } : {}),
+        ...(eventId !== undefined ? { eventId } : {}),
+    });
+};
 const textSegmentEndArm = function* (m, { text }) {
     // 🔴 断闸按「**键在不在**」判,不按「是不是串」判(异源对抗复审第三轮 [medium] 采纳)。
     //    投影层已对坏 lane 位整帧 fail-closed;这一道是给**非投影口**喂进来的帧(宿主自建管线 /
@@ -1269,6 +1298,8 @@ export const ARMS = new Map([
     ['tool_progress', toolProgressArm],
     ['tool_roster_delta', toolRosterDeltaArm],
     ['context_usage', contextUsageArm],
+    // CC-89(0.75.0):压缩的非 compacted 结局(additive;不接 = 压缩失败对用户不可见)。
+    ['compaction_outcome', compactionOutcomeArm],
     ['wiring_manifest', wiringManifestArm],
     // B-078 / L-208(0.65.0):design/172 流内审批两帧 —— 修前它们在投影层就 `dropped`,
     // 壳自己另接一份 ⇒ desktop/web 拿不到卡集与撤卡(归层违例)。

package/dist/adapter/downstream/eventToSdkMessage.js

@@ -44,6 +44,8 @@ export const INTERNAL_SDK_ARM_TYPES = new Set([
     'tool_progress',
     'tool_roster_delta',
     'context_usage',
+    // CC-89(0.75.0):压缩的非 compacted 结局 → 中性内部臂(print 车道同律:吞或转,裸透传 = 越界帧)。
+    'compaction_outcome',
     'workflow_complete',
     'tool_end_result',
     'retry_status',
@@ -338,6 +340,9 @@ export function eventToSdkMessage(ev, ctx) {
         //      sdk 补上该位的当天,`run-compaction-boundary-projection-test.mjs` F10 行当场红逼复核。
         case 'compacted': {
             const raw = ev;
+            // 0.74.5 CC-85(core 7.24.0 #946):引擎自己测的结构性差值(core 侧夹 ≥ 0);旧的 tokensBefore / tokensAfter **不是可相减的一对**。
+            // 缺席 = 没测出来 ⇒ 键不落(渲「未知」不是 0);在场才带超集键。**负值 / 非有限在本包同样按缺席**(不夹到 0 —— 缺席比编一个 0 诚实;test 0.74.5 复验读数)。
+            const freedTokens = typeof raw.freedTokens === 'number' && Number.isFinite(raw.freedTokens) && raw.freedTokens >= 0 ? raw.freedTokens : undefined;
             const attachedFiles = raw.attachedFiles;
             const seg = raw.preserved_segment;
             const firstKeptEntryId = typeof seg === 'object' && seg !== null && !Array.isArray(seg)
@@ -360,6 +365,7 @@ export function eventToSdkMessage(ev, ctx) {
                     ...(typeof clampedRatio === 'number' && Number.isFinite(clampedRatio)
                         ? { _sema_clamped_ratio: clampedRatio }
                         : {}),
+                    ...(freedTokens !== undefined ? { _sema_freed_tokens: freedTokens } : {}),
                 },
                 ...(Array.isArray(attachedFiles) && attachedFiles.length > 0 ? { attachedFiles } : {}),
             })));
@@ -822,8 +828,8 @@ export function eventToSdkMessage(ev, ctx) {
         case 'failed':
             return nothing('terminal_delegated');
         // ── 已入 SDK union、本切片**有意**不投影的臂(REF-CC-060:进 switch 才受穷举保护)────────
-        // `meta`:流首帧的 taskId/sessionId 一等信号 —— 身份面由 SDK/传输层自己消费(runStream 只按
-        //   `eventSeq` 去重),没有可渲染内容。
+        // `meta`:流首帧的 taskId/sessionId 一等信号 —— 本切片无可渲染内容(runStream 只按 `eventSeq` 去重)。
+        //   ⚠️ 活性普查(2026-09-19)更正:传输层**不**替宿主消费它;需要 sessionId / taskId 的端(desktop / web-client)各自直读本帧。
         case 'meta':
         // `file_link` / `prompt_assembled` / `model_usage` / `context_usage` / `config_assembled`:
         //   引擎的可观测/审计面帧,本切片(CC transcript 投影)无对位渲染物;
@@ -836,12 +842,8 @@ export function eventToSdkMessage(ev, ctx) {
         case 'config_assembled':
         // `needs_review`:plan-review park 的**事件**形;壳消费的是 done{status:'needs_review'} 终帧
         //   (runStream 的 plan_review_park chrome 臂),事件形在本切片重复且更早,故不投影。
+        //   ⚠️ 活性普查(2026-09-19):web-client 仍直读事件形;本切片不投的理由不变(终帧是权威),但「没人消费」这句不成立。
         case 'needs_review':
-        // `compaction_outcome`(sdk 4.0.1 新臂,[2373]A-2 三腿同源):压缩**非 compacted 结局**报告
-        //   (mooted/failed 等)。CC transcript 无对位物(compact_boundary 只对成功压缩,由 `compacted`
-        //   臂投)——本切片不投影。⚠️ 「压缩失败让用户看见」是 chrome/HUD 面的活,今天两端都还没接
-        //   (adapt 臂表同样无此臂),缺口记 0.13.0 候选,不许由本切片顺手编一个假 transcript 形。
-        case 'compaction_outcome':
         // ── sdk 6.9.0 提货批(2026-08-08)新入 union 的四条臂 ─────────────────────────────────────
         // `tool_approval` / `tool_approval_complete`:HITL 审批帧。**#185a 起它们是 `AgentEvent` 的臂**
         //   (此前只是 named SSE frame),但本切片不是它们的消费口 —— 它们由
@@ -914,6 +916,10 @@ export function eventToSdkMessage(ev, ctx) {
         //   由哪些段组成、哪一段大」,fleet/HUD 面要渲;三个标量走 finite 门(非有限即缺席,永不 null)。
         case 'context_usage':
             return contextUsageProjection(ev, ctx);
+        // CC-89(0.75.0):`compaction_outcome` 从 not_in_slice 组里拿出来 —— 压缩的**非 compacted 结局**(被终态抢先 / 失败等)此前
+        //   没有任何一端看得见。转录里没有对位物(`compact_boundary` 只对成功压缩)⇒ 走内部臂 → chrome 臂,不编消息。
+        case 'compaction_outcome':
+            return compactionOutcomeProjection(ev, ctx);
         case 'tool_progress':
             return toolProgressProjection(ev, ctx);
         default:
@@ -1290,6 +1296,8 @@ function projectLspSection(raw) {
         return undefined;
     return { mounted: o.mounted, ...(typeof o.lane === 'string' && o.lane.length > 0 ? { lane: o.lane } : {}) };
 }
+/** 内部臂的唯一铸出口(内部臂不在 CC 的 SDKMessage 联合里,出境只此一处铸;新臂走这里,不再各写一处铸链)。 */
+const internalArmExit = (body) => body;
 function contextUsageProjection(ev, ctx) {
     const { identity, bad } = identityOrMalformed(ev, 'context_usage');
     if (bad !== null)
@@ -1315,14 +1323,39 @@ function contextUsageProjection(ev, ctx) {
     }
     if (usedTokens === undefined && windowTokens === undefined && compactAtTokens === undefined && sections === undefined)
         return nothing('empty_payload');
-    return projected(stamp(ctx, armBody({
+    return projected(internalArmExit(stamp(ctx, armBody({
         type: 'context_usage',
         ...(usedTokens !== undefined ? { usedTokens } : {}),
         ...(windowTokens !== undefined ? { windowTokens } : {}),
         ...(compactAtTokens !== undefined ? { compactAtTokens } : {}),
         ...(sections !== undefined ? { sections } : {}),
         ...identity,
-    })));
+    }))));
+}
+/**
+ * CC-89(0.75.0):`outcome` 是主事实,非空串必在(否则 malformed —— 不投一条没有结局的结局帧),原词逐字(引擎开集,不按成员过滤);
+ * `trigger` / `reason` 非空串才在场,缺席 / 坏形 ⇒ 键不在场(不编 'auto'、不编空串;主事实不因旁键丢)。
+ */
+function compactionOutcomeProjection(frame, ctx) {
+    // 🔴 不浅拷(异源复审 R1 [medium]):展开会擦掉原型链上的身份键(进程内对象把子代帧洗成主会话)、还会执行无关的可枚举 getter;
+    //    与兄弟臂同律 —— 就在同一份记录上逐键各读一次。
+    const ev = frame;
+    const { identity, bad } = identityOrMalformed(ev, 'compaction_outcome');
+    if (bad !== null)
+        return bad;
+    const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+    const outcome = str(ev.outcome);
+    if (outcome === undefined)
+        return dropped('malformed', 'compaction_outcome');
+    const trigger = str(ev.trigger);
+    const reason = str(ev.reason);
+    return projected(internalArmExit(stamp(ctx, armBody({
+        type: 'compaction_outcome',
+        outcome,
+        ...(trigger !== undefined ? { trigger } : {}),
+        ...(reason !== undefined ? { reason } : {}),
+        ...identity,
+    }))));
 }
 function engineNoticeProjection(ev, ctx) {
     const code = typeof ev.code === 'string' && ev.code.length > 0 ? ev.code : undefined;

package/dist/deviceExecutorManagementCapability.d.ts

@@ -1,7 +1,7 @@
 /**
  * deviceExecutorManagementCapability — `GET /v1/capabilities.deviceExecutor.management`(server ≥7.88.0;契约附录 B.1
  * `deviceExecutor` 行 + §14)的三端共用读面(0.74.2;与 sql / writeProtection / webSearch.backend / executionLane /
- * approvalsStreamLive 五只兄弟同一套四态词汇)。sdk 对该位无型(9.7.1)⇒ 按契约结构读,sdk 补型当拍对表。
+ * approvalsStreamLive 五只兄弟同一套四态词汇)。sdk 9.7.1 对该位无型 ⇒ 按契约结构读;9.8.x 起声明 `management?: boolean`(0.75.0 CC-81 对表:读器不改,门钉声明形)。
  *
  * ── 这一位答的是哪一个问题 ────────────────────────────────────────────────────────────────
  * 「`/v1/devices/*` 的管理动词在这台 server 上在不在」(present-iff:与该族 501 判据逐字同源)。它挂在 `deviceExecutor`

package/dist/deviceExecutorManagementCapability.js

@@ -1,7 +1,7 @@
 /**
  * deviceExecutorManagementCapability — `GET /v1/capabilities.deviceExecutor.management`(server ≥7.88.0;契约附录 B.1
  * `deviceExecutor` 行 + §14)的三端共用读面(0.74.2;与 sql / writeProtection / webSearch.backend / executionLane /
- * approvalsStreamLive 五只兄弟同一套四态词汇)。sdk 对该位无型(9.7.1)⇒ 按契约结构读,sdk 补型当拍对表。
+ * approvalsStreamLive 五只兄弟同一套四态词汇)。sdk 9.7.1 对该位无型 ⇒ 按契约结构读;9.8.x 起声明 `management?: boolean`(0.75.0 CC-81 对表:读器不改,门钉声明形)。
  *
  * ── 这一位答的是哪一个问题 ────────────────────────────────────────────────────────────────
  * 「`/v1/devices/*` 的管理动词在这台 server 上在不在」(present-iff:与该族 501 判据逐字同源)。它挂在 `deviceExecutor`

package/dist/engineAgentPanelStore.d.ts

@@ -164,6 +164,14 @@ export declare function markEnginePanelTaskResident(taskId: string): void;
 export declare function clearEnginePanelTaskResident(taskId: string): void;
 export declare function isEnginePanelTaskResident(taskId: string): boolean;
 type Listener = (ev: EngineAgentPanelEvent) => void;
+/**
+ * 0.74.5 CC-87 —— 「这一帧是不是**新周期**」的单源判据(`isStaleEngineAgentPanelEnd` 的对偶,壳侧此前各拼一份):
+ *   · 两边都带 `cycleSeq` ⇒ **只**比它:不等 ⇒ 新周期;
+ *   · 否则两边都带 `startedAt` ⇒ 不等 ⇒ 新周期;
+ *   · 任一边判不出 ⇒ **不是**新周期(这一帧没说,不算变化 —— 方向与陈旧判据相同:缺席不制造周期)。
+ * 与缓冲合并屏障(`launchAnchorChanged`)同一条规则;消费端在 `fleet-row` 到时拿行上记的身份与帧上的身份调它。
+ */
+export declare function isNewEngineAgentPanelCycle(prev: EngineAgentPanelCycleIdentity | null | undefined, next: EngineAgentPanelCycleIdentity | null | undefined): boolean;
 /** 周期身份的一格(`end` 事件上的,或消费端记在行上的当前周期)。 */
 export interface EngineAgentPanelCycleIdentity {
     readonly cycleSeq?: number;
@@ -201,7 +209,12 @@ export declare function resolveEnginePanelTaskId(wireTaskId: string, parentToolC
  * `cycle`(0.74.4):调用方(通知车道)带得出这条终态的周期时传进来 —— 尾段归某把 UUID 所有而通知比所有权旧 ⇒ 不清那把 UUID 的常驻标。
  */
 export declare function clearEnginePanelTaskResidentByWire(wireTaskId: string, cycle?: EngineAgentPanelCycleIdentity): void;
-/** 测试钩:清两张钥匙表、缓一拍与周期水位。 */
+/**
+ * 测试钩。逐表清单(每加一张表同批更新这里):① 转录钥匙表(UUID → 行尾段)② 父调用钥匙表(parentToolCallId → 行尾段)
+ * ③ 缓着的未绑卡 tick ④ 每行最近一次行帧的周期水位 ⑤ 「先发布的键」集合(UUID)⑥ 同上按父调用记的那一份 ⑦ 反向所有权表(行尾段 → UUID)。
+ * 🔴 不清:订阅者 / 回放缓冲、常驻标、running 历史(那一本由 `__resetPanelRunningHistoryForTests` 清)。
+ * 🔴 连续场景(同一只子代跨多步的用例)**中途别调**:清掉 ④–⑦ 之后,陈旧判据与「先发布的键为准」都会从零开始,前后两半不再是同一段历史。
+ */
 export declare function __resetEngineAgentPanelIdentityForTests(): void;
 /** 宿主的唯一发布口(三条 lane 都经这里):先归一身份,再进主通道(订阅者 / 缓冲)。 */
 export declare function publishEngineAgentPanelEvent(ev: EngineAgentPanelEvent): void;

package/dist/engineAgentPanelStore.js

@@ -22,6 +22,7 @@
  * 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 } from './panelRunningHistory.js';
 const _panelToolUsesLanePins = [true, true];
 void _panelToolUsesLanePins;
 /**
@@ -56,9 +57,23 @@ const buffer = [];
 function launchAnchorChanged(prev, next) {
     if (prev.kind !== 'fleet-row' || next.kind !== 'fleet-row')
         return false;
-    if (prev.cycleSeq !== undefined && next.cycleSeq !== undefined && prev.cycleSeq !== next.cycleSeq)
-        return true;
-    return prev.startedAt !== undefined && next.startedAt !== undefined && prev.startedAt !== next.startedAt;
+    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);
+    if (pc !== undefined && nc !== undefined)
+        return pc !== nc;
+    const ps = startedAtOf(prev);
+    const ns = startedAtOf(next);
+    return ps !== undefined && ns !== undefined && ps !== ns;
 }
 function cycleSeqOf(v) {
     const n = v?.cycleSeq;
@@ -187,11 +202,13 @@ function publishedWireFor(ev) {
     return undefined;
 }
 /** 尾段今天归哪把 UUID(在场 = 这个子代已按 UUID 上屏;复活的新周期不算)。 */
-function wireOwnerOf(fleetId, current) {
+function wireOwnerOf(fleetId, current, transcriptId) {
     const o = wireIdByFleetId.get(fleetId);
     if (o === undefined)
         return undefined;
-    if (current !== undefined && isStaleEngineAgentPanelEnd(o, current)) {
+    // 0.74.5(test [7718] 契约层反例):行帧的 transcriptId 换了 = 新一代子会话,即使两个周期键全缺 —— 所有权同样到此为止
+    const newTranscript = transcriptId !== undefined && transcriptId !== (o.transcriptId ?? o.wireId); // 父键登记没记 transcriptId 时,wireId 本身就是那一代的转录身份(复审 R3)
+    if (newTranscript || (current !== undefined && isStaleEngineAgentPanelEnd(o, current))) {
         wireIdByFleetId.delete(fleetId); // 行帧已是更新的周期:旧 UUID 的所有权到此为止,新周期按常态登记
         retireWire(o.wireId); // 旧周期已过:那把 UUID 退役,退路键(同一张卡)不再把新周期的行帧拉回它(异源复审 R2 [high])
         return undefined;
@@ -314,7 +331,12 @@ export function clearEnginePanelTaskResidentByWire(wireTaskId, cycle) {
         return;
     residentTaskIds.delete(id.taskId);
 }
-/** 测试钩:清两张钥匙表、缓一拍与周期水位。 */
+/**
+ * 测试钩。逐表清单(每加一张表同批更新这里):① 转录钥匙表(UUID → 行尾段)② 父调用钥匙表(parentToolCallId → 行尾段)
+ * ③ 缓着的未绑卡 tick ④ 每行最近一次行帧的周期水位 ⑤ 「先发布的键」集合(UUID)⑥ 同上按父调用记的那一份 ⑦ 反向所有权表(行尾段 → UUID)。
+ * 🔴 不清:订阅者 / 回放缓冲、常驻标、running 历史(那一本由 `__resetPanelRunningHistoryForTests` 清)。
+ * 🔴 连续场景(同一只子代跨多步的用例)**中途别调**:清掉 ④–⑦ 之后,陈旧判据与「先发布的键为准」都会从零开始,前后两半不再是同一段历史。
+ */
 export function __resetEngineAgentPanelIdentityForTests() {
     fleetIdByTranscriptId.clear();
     fleetIdByParentToolCallId.clear();
@@ -324,6 +346,35 @@ export function __resetEngineAgentPanelIdentityForTests() {
     publishedWireByParent.clear();
     wireIdByFleetId.clear();
 }
+/**
+ * 0.75.0 W2:一条 end 递达之前,先把投影缓着的「首见即终态」行放出来(它带这一行唯一的一份最终用量),经漏斗原路发布(身份归一照走);
+ * 递达之后记「本进程结过这一行」—— 投影据此把之后到的终态行当成短命子代的收尾(照发用量)而不是历史行。两步都只对当代 end(陈旧判据与销 running 历史同一只)。
+ */
+function releaseHeldNewbornTerminal(taskId, endCycle) {
+    // 先 peek 比周期再决定(异源复审 R3 [high]:先 take 会让前代 end 把当代唯一的缓行取走丢掉):
+    //   end 可证比缓行**旧** ⇒ 缓行留着(等当代的 end);end 可证比缓行**新** ⇒ 缓行作废(前代用量不盖当代行);同代 / 判不出 ⇒ 放出。
+    const held = peekHeldNewbornTerminalRow(taskId);
+    if (held === undefined || held.kind !== 'fleet-row')
+        return;
+    const heldCycle = { ...(held.cycleSeq !== undefined ? { cycleSeq: held.cycleSeq } : {}), ...(held.startedAt !== undefined ? { startedAt: held.startedAt } : {}) };
+    if (isStaleEngineAgentPanelEnd(endCycle, heldCycle))
+        return;
+    if (isStaleEngineAgentPanelEnd(heldCycle, endCycle)) {
+        dropHeldNewbornTerminalRow(taskId);
+        return;
+    }
+    takeHeldNewbornTerminalRow(taskId);
+    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 过期);
@@ -334,10 +385,10 @@ export function publishEngineAgentPanelEvent(ev) {
         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) ?? publishedWireFor(ev);
+            const published = wireOwnerOf(ev.taskId, rowCycle, ev.transcriptId) ?? publishedWireFor(ev);
             if (published !== undefined && published !== ev.taskId) {
                 const prev = wireIdByFleetId.get(ev.taskId);
-                boundedOwnership(wireIdByFleetId, ev.taskId, { wireId: published, retired: prev?.wireId === published ? prev.retired : false, ...rowCycle });
+                boundedOwnership(wireIdByFleetId, ev.taskId, { wireId: published, retired: prev?.wireId === published ? prev.retired : false, ...(ev.transcriptId !== undefined ? { transcriptId: ev.transcriptId } : prev?.transcriptId !== undefined ? { transcriptId: prev.transcriptId } : {}), ...rowCycle });
                 deliverEngineAgentPanelEvent({ ...ev, taskId: published, wireTaskId: ev.taskId, taskIdOrigin: 'wire' });
                 ageHeld(undefined);
                 return;
@@ -405,27 +456,67 @@ export function publishEngineAgentPanelEvent(ev) {
             return;
         }
         case 'end': {
+            // 0.75.0 W2:缓着的「首见即终态」行**先于一切归一**放出(异源复审 R3 [high]:放出的行帧会登记钥匙 / 所有权,之后的 end 归一必须看到它,
+            //    否则同一子代长成 UUID 行 + 尾段行两行)。三把可能的键:尾段本身 / UUID 经钥匙解析到的尾段 / 这把 UUID 名下的尾段。
+            releaseHeldNewbornTerminal(ev.taskId, ev);
+            {
+                const pre = resolveEnginePanelTaskId(ev.taskId);
+                if (pre.origin === 'fleet-row' && pre.taskId !== ev.taskId) {
+                    releaseHeldNewbornTerminal(pre.taskId, {
+                        ...(ev.cycleSeq !== undefined ? { cycleSeq: ev.cycleSeq } : pre.cycleSeq !== undefined ? { cycleSeq: pre.cycleSeq } : {}),
+                        ...(ev.startedAt !== undefined ? { startedAt: ev.startedAt } : pre.startedAt !== undefined ? { startedAt: pre.startedAt } : {}),
+                    });
+                }
+                for (const [fleetId, o] of wireIdByFleetId)
+                    if (o.wireId === ev.taskId && !o.retired)
+                        releaseHeldNewbornTerminal(fleetId, 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)
-                if (!isStaleEngineAgentPanelEnd(ev, ownerRec))
+                // 前代迟到的 end(比所有权登记时的周期旧)只过境让消费端判陈旧,不退役当代所有权(异源复审 R3)、不销当代 running 历史
+                if (!staleA) {
                     retireWire(wireOwner);
+                    settleRowHistory(ev.taskId, ev);
+                    settleRowHistory(wireOwner, 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))
+                        ownedFleetIds.push(fleetId);
+                }
+                const alias = fleetIdByTranscriptId.get(ev.taskId);
+                if (alias !== undefined && !endOlderThanKnown(ev, alias.fleetId, alias) && !ownedFleetIds.includes(alias.fleetId))
+                    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)
+                    settleRowHistory(fleetId, ev);
                 return;
             }
             const id = resolveEnginePanelTaskId(ev.taskId);
             if (id.origin === 'fleet-row' && id.taskId !== ev.taskId) {
                 flushHeld(ev.taskId); // 同 UUID 还缓着一条 tick ⇒ 先归一放出(行先有最后一拍的数字与名字),再结
                 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 } : {}),
+                };
+                const staleC = endOlderThanKnown(effectiveEnd, id.taskId, latestCycleByFleetId.get(id.taskId));
                 deliverEngineAgentPanelEvent({
                     ...ev,
                     taskId: id.taskId,
@@ -435,11 +526,17 @@ export function publishEngineAgentPanelEvent(ev) {
                     ...(ev.cycleSeq === undefined && id.cycleSeq !== undefined ? { cycleSeq: id.cycleSeq } : {}),
                     ...(ev.startedAt === undefined && id.startedAt !== undefined ? { startedAt: id.startedAt } : {}),
                 });
+                if (!staleC)
+                    settleRowHistory(id.taskId, effectiveEnd);
                 return;
             }
             flushHeld(ev.taskId); // 缓着的 tick 先落行,终态才有行可结
+            // 通知车道 / fleet 投影铸的 end(尾段键):只对当代(前代迟到的 end 带旧 seq / cycleSeq ⇒ 不擦历史、不放缓着的行)
+            const staleD = endOlderThanKnown(ev, ev.taskId, latestCycleByFleetId.get(ev.taskId));
             deliverEngineAgentPanelEvent(ev);
             retireWire(ev.taskId); // 这把 UUID 若是先发布的键,所有权退役(容量满时先让位)
+            if (!staleD)
+                settleRowHistory(ev.taskId, ev);
             return;
         }
         default:

package/dist/fleetAgentPanelProjection.js

@@ -48,6 +48,7 @@
  *    就地维护第二份;该函数出过等价性事故,0.1.1 修,见 `workflow.ts` 头注)。
  */
 import { isStaleEngineAgentPanelEnd, publishEngineAgentPanelAbsence, publishEngineAgentPanelEvent } from './engineAgentPanelStore.js';
+import { __resetPanelRunningHistoryForTests, notePanelRowRunning, panelRowUnknownToConsumer, panelRowEndedIdentity, holdNewbornTerminalRow, 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';
@@ -80,6 +81,8 @@ function currentToolKeyOf(ct) {
 }
 /** 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) {
@@ -102,6 +105,7 @@ function seenFor(sessionKey) {
  */
 export function resetFleetAgentPanelProjection() {
     seen.clear();
+    __resetPanelRunningHistoryForTests();
 }
 /** W1 keyed variant(REF-CC-045):只清**这一个会话**的桶。 */
 export function resetFleetAgentPanelProjectionFor(sessionKey) {
@@ -180,8 +184,38 @@ export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
         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;
-            if (!settledThisCycle) {
+            // 结过的行(本进程递达过 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,
+                    ...(row.name ? { name: row.name } : {}),
+                    ...(row.description ? { description: row.description } : {}),
+                    ...(knownTokens !== undefined ? { totalTokens: knownTokens } : {}),
+                    ...(toolUses !== undefined ? { toolUses } : {}),
+                    ...(transcriptId !== undefined ? { transcriptId } : {}),
+                    ...(parentToolCallId !== undefined ? { parentToolCallId } : {}),
+                    ...(knownStartedAt !== undefined ? { startedAt: knownStartedAt } : {}),
+                    ...(knownCycleSeq !== undefined ? { cycleSeq: knownCycleSeq } : {}),
+                });
+            }
+            else if (!settledThisCycle) {
                 // 终态行也把最后一拍的累计工具数/转录锚带上:详情页在行翻终态后仍要显示真计数与
                 // 委派 prompt,而终态帧常常是这一行**唯一**带全 usage 的一帧(bg lane 只在活动边界发行帧)。
                 if (
@@ -207,17 +241,18 @@ export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
                         ...(knownCycleSeq !== undefined ? { cycleSeq: knownCycleSeq } : {}),
                     });
                 }
-                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 } : {}),
-                });
+                if (!endedSameCycle)
+                    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 } : {}),
+                    });
             }
             seenMap.set(taskId, {
                 status,
@@ -251,6 +286,8 @@ 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 ⇒ 缓着的旧终态行作废(用量以新一代为准)
             publishEngineAgentPanelEvent({
                 kind: 'fleet-row',
                 taskId,