@sema-agent/server 7.43.0 → 7.44.0

package/dist/fleet/fleet-bus.js

@@ -1,74 +1,20 @@
-/**
- * MF-Fleet (shell-host data-contract, the dynamic-stream obligation) — the SERVICE-side live fleet
- * aggregation bus + state, backing `GET /v1/fleet/stream`.
- *
- * The fleet view (CC 187 0616_053) animates a MULTI-ROW tree: every active task's `status/elapsedMs/tokens/
- * queuedCount` and every workflow's `doneCount N/M · failedCount` TRANSITION over time. That is a *push* stream,
- * not a one-shot read: the backend must emit every transition for as long as a run is live, with STABLE per-row
- * identity so the UI updates the right row in place.
- *
- * This bus is the in-process aggregator: the run lifecycle (createRun → queued/running, per-turn token accrual,
- * terminal → completed/failed) and the workflow lifecycle (WorkflowRun put/update → doneCount/status) publish
- * their per-row deltas here; `GET /v1/fleet/stream` subscribes, sends a SNAPSHOT on connect, then forwards every
- * delta. Identity: tasks keyed by `id` (the durable runId/taskId), workflows by their workflow runId, subagent
- * sub-rows (round 5, pending core's `task_progress` arm) by `parentId`+agent id (E2 `parentToolCallId`).
- *
- * 🔒 boundary (design/99 §0): the FLEET aggregation + the SSE wire is **service** (UI/deployment-state view over
- * the runs ledger + workflow store). The engine semantics (a run's own events, a subagent's usage ticks) are
- * core's — the bus only AGGREGATES what the lifecycle already produces. It carries NO new engine state.
- *
- * NOT durable / NOT cross-replica: a live fleet is this replica's active runs (mirrors `steerableRuns` —
- * replica-local). A cross-replica fleet roll-up is a fleet-token-gated trace-API concern (separate), not this.
- */
 import { EventEmitter } from "node:events";
 import { deriveAgentDisplayStatus, isDelegatedAgentTerminal } from "@sema-agent/core";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { redactSecrets } from "../trace/redact.js";
-/** [2687-cli] 幽灵行案的单源判别:一条 `task_notification` 只有在 **agent 族 × 终态** 时才允许打
- *  `onChildTerminal`(fleet「subagent 树」只渲 agent 子代)。`background_bash`/`monitor`/`external`
- *  不属 agent fleet 树——它们此前每条都打,fleet-bus 的「无 tick 无 claim」臂给 b\* 与 m\* handle 合成
- *  agent 形瞬态终帧,壳终态留存池把这帧渲 60s = footer 幽灵子行;monitor 的 `status:"event"` 还被
- *  终态映射折成 `failed`。
- *
- *  🔴 A-033.1(#256):判别**本体已换 core 的 {@link isDelegatedAgentTerminal}**。此前这里是一份手写语义
- *  孪生(自己枚举 `completed|failed|killed|cancelled`),头注自陈「与 core 语义同源——core 根导出后换装
- *  import 删本镜像」。core 现已从包根导出(`index.d.ts:109`),且它的终态集与 pending 店的驱逐偏好共用
- *  同一份 `TERMINAL_STATUSES`(core 原话:「so "terminal" can never mean two things in this module」)——
- *  孪生留在这里等于让 fleet 面板对「终态」的理解可以和引擎分家。本函数保留为**具名的 fleet 语义位**
- *  (调用点读的是「这条通知该不该打 fleet 的 onChildTerminal」,不是「core 怎么判终态」)。 */
 export function isFleetAgentTerminalNotification(n) {
     return isDelegatedAgentTerminal(n);
 }
-/**
- * durable {@link WorkflowRun} → 一条 fleet workflow 行的**纯投影**(`build*`=纯数据,无行为、不发布)。
- *
- * 从 `JournalingWorkflowRunStore.publishFleet` **原样**抽出,因为它现在有两个调用点,而两处各写一遍
- * 必然漂移(本仓在 startedCount 口径上已吃过同款):
- *  ① 活写路径 —— put/update 的写观察点(行的唯一写者,见该类注);
- *  ② `/v1/fleet/stream` 连接时快照的**有界终态行窗**(#189 修方向 1)—— 引擎重启后 boot 扫描把前世
- *     running run 判死,终帧与撤行在同一同步栈内背靠背发出,之后才连上的客户端连快照都看不见那一行。
- */
 export function buildFleetWorkflowRow(id, run) {
     const agents = run.agents ?? [];
-    // [2336] doneCount 与 failedCount **不相交**:done 只数 completed。契约以此为前提(本文件 startedCount
-    // 注的回退式 done+failed ≤ started);把 failed 也计进 done 会让全失败 workflow 的终帧渲成 "N done"
-    // (cli 4.1.3 实测 done=2 failed=2 started=2)。
     const done = agents.filter((a) => a.status === "completed").length;
     const failed = agents.filter((a) => a.status === "failed").length;
-    // cli [1726] 二①:CC 规模告警的分母是 **started**(已启动),而 `totalCount`(= agents.length)是**计划总数**
-    // (含排队中)。判别口径走 core 导出的 `deriveAgentDisplayStatus` —— 一个 agent 已在 `run.agents` 里但
-    // `startedAt` 未置就是排队中。**不自己写 `startedAt !== undefined`**:那是 core 的显示契约,两端各写一遍
-    // 必然漂移,用它的函数则 core 一改、两端同时跟随。
     const started = agents.filter((a) => deriveAgentDisplayStatus(a, run.status) !== "queued").length;
     return {
         id,
-        // [WF2-A parity] redact the workflow label surfaces for parity with the run + subagent-child names (below):
-        // a tool-launched (LLM-authored) workflow's meta.name/description is task-controlled and could carry a secret shape.
         name: redactSecrets(run.name ?? "Dynamic workflow"),
         ...(run.description ? { description: redactSecrets(run.description) } : {}),
         scope: run.scope,
-        // codex-6 F2:sessionId 必须随行——streamFleet 对无 sessionId 的行按「同 principal 全会话可见」
-        // 兜底,漏发=A 会话的 workflow 名/进度/token 泄进 B 会话的 ?session= 过滤流。
         ...(run.originatingSessionId ? { sessionId: run.originatingSessionId } : {}),
         status: run.status,
         doneCount: done,
@@ -76,86 +22,45 @@ export function buildFleetWorkflowRow(id, run) {
         failedCount: failed,
         startedCount: started,
         tokens: (run.stats?.tokens ?? 0) + (run.stats?.nested?.tokens ?? 0),
-        // [1294]:跑动中也带时长(1.232 只在 endedAt 后带——clay 验收轮实锚面板恒显 0s)。终态用
-        // endedAt 定格,活跑用 now-startedAt(每次 put/update 观察点刷新,壳侧读帧即当前时长)。
         elapsedMs: (run.endedAt ?? Date.now()) - run.startedAt,
     };
 }
-/**
- * The process-local fleet aggregation bus. Holds the current active set + fans out deltas to SSE subscribers.
- * Upserts MERGE (a partial delta patches the existing row), so a publisher can emit just the field that changed
- * (e.g. only `tokens`) and the row stays whole. Removal drops the row (terminal). Subscribers get a snapshot of
- * the current set immediately, then every subsequent delta.
- */
 export class FleetEventBus {
     now;
     emitter = new EventEmitter();
     tasks = new Map();
     workflows = new Map();
-    /** #261 / codex R1-F2:**代际墓碑** —— 已离场行的最后已知 `cycleSeq`(行本身已从 `tasks` 删掉,
-     *  代际状态却必须活得比行久一点,否则前代迟到帧会在空 Map 上把幽灵行重铸出来)。有界 LRU。 */
     retiredGen = new Map();
     static RETIRED_GEN_MAX = 4096;
     constructor(now = () => Date.now()) {
         this.now = now;
-        this.emitter.setMaxListeners(0); // unbounded SSE subscribers (each /v1/fleet/stream connection)
+        this.emitter.setMaxListeners(0);
     }
-    /** Upsert a task row (MERGE onto any existing row by `id`) + fan out the merged row. Publishers may send a
-     *  partial `{ id, tokens }` etc.; the row keeps its other fields. */
     publishTask(delta) {
         const existing = this.tasks.get(delta.id);
-        // 🔴 #261 §2 判代闸(**merge 前判**):同 id 上一个**更小**代际的帧 = 前代迟到帧 ⇒ 整帧忽略,
-        // 既不 merge 也不扇出。为什么必须在 merge 之前:MERGE 语义下一个迟到的前代 delta 会把行内累计量
-        // (tokens / elapsedMs / toolUses)**回退**到上一代的读数,而回退过的行再也没人会修正它 ——
-        // 消费端看到的是一条"复活之后 token 越跑越少"的行,且无从判别。判据只在**两边都有**代际号时生效:
-        // 缺席 = 「无此概念」(顶层 run 行恒缺席),不参与比较,行为逐字回落到本闸之前。
         if (delta.cycleSeq !== undefined && existing?.cycleSeq !== undefined && delta.cycleSeq < existing.cycleSeq)
             return;
-        // 🔴 同一条判据在**行已离场**之后的半场(codex 对抗复审 R1-F2 [high],红先复现)。上面那条闸只跟
-        // **内存行**比对,而 `removeTask` 顺手把行连同它的代际状态一起删了 —— 于是 `retire(N)` 之后一条
-        // `frame(N)` 会在空 Map 上把行**重新铸出来**,而那条行的发布方恰恰是已经死了(那就是我们退它的理由),
-        // 面板上于是又立起一条永不离场的幽灵行。墓碑补上这一半:行缺席时与**被退那一代**比,不前进的帧一律
-        // 不铸;更大代际(真复活)照常出生。
-        // ⚠️ 例外恰好一个:带 `retiredBy` 的帧**就是**对账腿对"被退那一代"的结算(行已不在 bus,故它必须
-        // 先瞬时重铸再撤 —— 见 fleet-reconciler.ts 的候补窗 flip-through)。它与墓碑说的是**同一代**,拦掉
-        // 它等于让"陈述级退场 → 后来 durable 翻终局 → 补发成对终帧"这条设计承诺静默失效(红先复现)。
         if (existing === undefined && delta.retiredBy === undefined) {
             const tomb = this.retiredGen.get(delta.id);
             if (tomb !== undefined && delta.cycleSeq !== undefined && delta.cycleSeq <= tomb)
                 return;
         }
-        // [2070]③:懒铸底座**不带 name** —— 一条只有 `{id,…}` 的首帧此前会把行 id 铸成显示名,而这里
-        // 恰恰是「谁都没给过名字」的位置。真名后到时照常 MERGE 上行(见本文件末的 [2070]③ 第 4 条钉)。
         const merged = { ...(existing ?? { id: delta.id, status: "running" }), ...delta };
         this.tasks.set(delta.id, merged);
         this.emit({ type: "task", row: merged, ts: this.now() });
     }
-    /** 推一帧 hook 判定未完成的观测通知(事件语义,不进 snapshot —— 与 `bg_notification` 同族)。 */
     publishHookNotice(notice) {
         this.emit({ type: "hook_notice", notice, ts: this.now() });
     }
-    /** Drop a task row (terminal + swept) + fan out the removal. Idempotent (a no-op if already gone).
-     *
-     *  `opts`(#261,两键均 ADDITIVE):`removeReason:"orphaned"` = **陈述级退场**(没有结算语义,见
-     *  {@link FleetFrame} 的 `task_remove` 臂);`cycleSeq` = 被退那一代的代际号。发布方的常规清场
-     *  (`onTerminal`/`onChildTerminal`)不传 opts ⇒ 帧逐字节与本改动之前相同。 */
     removeTask(id, opts) {
         const existing = this.tasks.get(id);
-        // 🔴 **代际条件删**(codex 对抗复审 R1-F2 反向臂 [high],红先复现):调用方拿的是一份快照,而它
-        // 在 await 里等 durable 读的那几十毫秒里,同一 id 完全可能已经**复活成新一代**(BCE revive spawn /
-        // run-leg 新腿)。无条件删就是拿过期快照把一条**活着的新行**从面板上摘掉 —— 而顶层 run 行没有代际号,
-        // 那一格由调用方的 await-后复核兜(见 fleet-reconciler.ts);有代际号的子代行由这条闸兜。
-        // 请求方没带代际(发布方的常规清场:它就是行的属主,不存在"拿旧快照删新行")⇒ 照旧无条件删。
         if (existing !== undefined && opts?.cycleSeq !== undefined && existing.cycleSeq !== undefined && existing.cycleSeq > opts.cycleSeq)
             return;
         if (this.tasks.delete(id)) {
-            // 代际墓碑:记下**被退那一代**(优先取行上的真值,退化取请求值)。见 publishTask 的墓碑臂。
             const gen = existing?.cycleSeq ?? opts?.cycleSeq;
             if (gen !== undefined) {
                 this.retiredGen.delete(id);
                 this.retiredGen.set(id, gen);
-                // 容量兜底:逐最老。丢一条墓碑 = 那个 id 退回本闸之前的行为(迟到帧可重铸,下一个对账周期再退它一次)
-                // —— 可见性回退,不是错行,与 bceClaims 同一条取舍。
                 if (this.retiredGen.size > FleetEventBus.RETIRED_GEN_MAX) {
                     const oldest = this.retiredGen.keys().next();
                     if (!oldest.done)
@@ -171,81 +76,54 @@ export class FleetEventBus {
             });
         }
     }
-    // ┌─ [2070]①/[2080] 让位登记簿(BCE 车道 → run-leg 车道的单向让位信号)────────────────────────────┐
-    // 为什么登记簿而不是"查快照有没有 a* 行":两条车道用**不同 id 域**给同一个 agent 建行(BCE=`a*`/`wa*`
-    // 稳定 handle;run-leg=`${runId} ${childUuid}` 复合键),快照里没有可直接比对的键。join 键 = core 在
-    // BCE 帧上给的 `progressTaskId`(= run-leg tick 的 `taskId`,即子代 uuid),[2080] 明确它已在 tick/terminal
-    // 帧上。BCE 车道学到 uuid 即 claim,terminal 即 release;run-leg 车道 claim 在场就让位不铸。
-    // 单向 + 只增可见性:claim 丢了(容量逐出/旧 core 不发 progressTaskId)= 退回双生行的旧行为,不会错杀。
-    bceClaims = new Map(); // `${scope}\u0000${childUuid}` → a* 行 id
+    bceClaims = new Map();
     static BCE_CLAIM_MAX = 4096;
     static bceKey(scope, childUuid) { return `${scope ?? "default"}\u0000${childUuid}`; }
-    /** BCE 车道:本车道已为该子代 uuid 建了真行 —— run-leg 车道自此让位。幂等。 */
     claimBackgroundChildLane(scope, childUuid, rowId) {
         const k = FleetEventBus.bceKey(scope, childUuid);
         this.bceClaims.delete(k);
         this.bceClaims.set(k, rowId);
-        // 容量兜底:逐最老。丢一条 claim 只是让那个 agent 退回"双生行"旧行为(可见性回退,不是错行),
-        // 所以这里可以简单逐出——与 Meta 表"活溯源绝不逐出"的取舍不同,因为丢 claim 无归因损失。
         if (this.bceClaims.size > FleetEventBus.BCE_CLAIM_MAX) {
             const oldest = this.bceClaims.keys().next();
             if (!oldest.done)
                 this.bceClaims.delete(oldest.value);
         }
     }
-    /** BCE 车道:该子代已终态离场 —— 让位解除(后续同 uuid 的迟到 tick 回到旧行为)。幂等。 */
     releaseBackgroundChildLane(scope, childUuid) {
         this.bceClaims.delete(FleetEventBus.bceKey(scope, childUuid));
     }
-    /** run-leg 车道:该子代是否已有 BCE 真行(有 ⇒ 让位,不铸复合 id 行)。 */
     backgroundChildLaneRow(scope, childUuid) {
         return this.bceClaims.get(FleetEventBus.bceKey(scope, childUuid));
     }
-    /** [2268] 让位迁移料的读面:迁移「只补缺席位」需要看得见存活行现有什么(BCE 是权威车道,不覆盖)。 */
     taskRow(id) {
         return this.tasks.get(id);
     }
-    // └────────────────────────────────────────────────────────────────────────────────────────────────┘
-    /** Upsert a workflow row (MERGE by `id`) + fan out. */
     publishWorkflow(delta) {
         const merged = { ...(this.workflows.get(delta.id) ?? { id: delta.id, status: "running" }), ...delta };
         this.workflows.set(delta.id, merged);
         this.emit({ type: "workflow", row: merged, ts: this.now() });
     }
-    /** Drop a workflow row + fan out the removal. Idempotent. */
     removeWorkflow(id) {
         if (this.workflows.delete(id))
             this.emit({ type: "workflow_remove", id, ts: this.now() });
     }
-    /** design/129-B 缺口②: fan out a background-child completion notification (EVENT — not stored, never in the
-     *  snapshot; a subscriber that connects later reads the durable inbox instead). */
     publishBgNotification(notification) {
         this.emit({ type: "bg_notification", notification, ts: this.now() });
     }
-    /** The current full state (the connect-time snapshot frame). */
     snapshot() {
         return { type: "snapshot", tasks: [...this.tasks.values()], workflows: [...this.workflows.values()], ts: this.now() };
     }
-    /** Subscribe to deltas. Returns an unsubscribe thunk. The caller typically sends `snapshot()` first, then every
-     *  delta this delivers — the snapshot+delta sequence is the live fleet view.
-     *
-     *  每个回调各自隔离(#183 复审 R3 HIGH):扇出是同步的,修前一个抛错的订阅方会把异常传回**发布方**——
-     *  而发布方是 JournalingWorkflowRunStore.put/update 的投影点,core 持久化对 put 抛错 catch{} 且不推进
-     *  storeRev ⇒ durable 行冻在 running 而 notify 已 ack,无恢复路径。投影消费方永远不该能楔死 durable
-     *  写路;抛错记 {@link recordFailOpen}(F 类,登记闸),不上抛、不影响其余订阅方。 */
     subscribe(cb) {
         const isolated = (frame) => {
             try {
                 cb(frame);
             }
             catch (err) {
-                // detail 构造自身也包住:抛出值若带会抛错的 toString,String() 本身会抛并逃出隔离层(fresh 复审观察项)。
                 let detail = "subscriber threw a value whose String() also threw";
                 try {
                     detail = String(err);
                 }
                 catch {
-                    /* keep the fallback detail */
                 }
                 recordFailOpen("server.fleet.subscriber-callback-threw", detail);
             }
@@ -253,7 +131,6 @@ export class FleetEventBus {
         this.emitter.on("frame", isolated);
         return () => this.emitter.off("frame", isolated);
     }
-    /** Live counts (test/observability). */
     get size() {
         return { tasks: this.tasks.size, workflows: this.workflows.size };
     }
@@ -261,75 +138,33 @@ export class FleetEventBus {
         this.emitter.emit("frame", frame);
     }
 }
-/** A run-scoped lifecycle publisher — wire it into a run's TaskEvent loop so the fleet row TRANSITIONS with the
- *  run. `onStart()` adds the top-level row (running); `onEvent(ev)` accrues tokens (turn_end usage) + adds/updates
- *  subagent CHILD rows (core `task_progress`, keyed by its `taskId`, nested under the run via `parentId`);
- *  `onTerminal(status)` flips the row terminal + removes it (and its children) from the active set. No-op when no
- *  bus is wired. The token accrual is CUMULATIVE across the run's turns (turn_end carries a per-turn delta). */
 export function fleetRunPublisher(bus, run) {
     if (!bus)
         return { onStart: () => undefined, onEvent: () => undefined, onForwardEvent: () => undefined, onChildTerminal: () => false, onTerminal: () => undefined };
     let tokens = 0;
     const startedAt = Date.now();
-    // #3 fleet per-session scope (clay 2026-06-30): tag every row of THIS run with its rootTaskId (= sessionId) so
-    // /v1/fleet/stream can filter to the caller's CURRENT session (a TUI footer no longer shows other sessions of the
-    // same principal). publishTask MERGEs, so tagging the CREATE frame suffices — status/token updates keep the field.
     const sessionField = run.rootTaskId ? { sessionId: run.rootTaskId } : {};
-    const children = new Set(); // subagent child row ids (removed with the run)
-    const childStartedAt = new Map(); // [1332]④:child 行时长轴(首 tick 起表)
-    // codex R2:spawning tool-call id → cid。core 的失败/killed 收尾通知不带 sessionId(成功路径才有条件带),
-    // 此时 task_id(a*)解不到 uuid 键的 tick 行——但 tick 的 ident() 带 parentToolCallId,通知带同源 toolUseId,
-    // 这是两 id 域之外唯一贯穿 spawn→terminal 的关联轴。一次 Task 调用只 spawn 一个 child,键不撞。
+    const children = new Set();
+    const childStartedAt = new Map();
     const childByToolCall = new Map();
-    // Once the leg SETTLED, a LATE subagent tick must not resurrect a child
-    // row — the settle's removeTask IS the shell's release signal (auto-exit watches the evict); a post-settle
-    // re-publish left a zombie "running" row with no terminal/remove ever coming. Freeze all publishes after
-    // onTerminal (a resume runs on a FRESH publisher — this leg's handle is done).
     let settledLeg = false;
     const childId = (taskId) => `${run.runId} ${taskId}`;
-    /** [1415]③:task_progress.status 值域映射(1.354 settle 终态 tick)——completed/failed 直译,其余(含
-     *  undefined/"running"/suspended 不发的诚实面)恒 running(旧 core 行为逐位不变)。 */
     const tickStatus = (st) => (st === "completed" ? "completed" : st === "failed" ? "failed" : "running");
-    /** [1748] 从一拍 usage 里取**累计**工具调用次数。与 `sumTokens` 同样防御式取值(该位在这两处的
-     *  静态类型是 `{}`)。⚠️ 缺席就返回 undefined —— 调用点据此**不发这个键**(缺席 ≠ 0)。 */
     const toolUsesOf = (usage) => {
         const t = usage?.toolUses;
         return typeof t === "number" ? t : undefined;
     };
-    /**
-     * 🔴 [2070]①/[2080] 让位判据(run-leg 侧半场,server 3.6.0)。
-     *
-     * 病灶(cli [2070]① 实测):本车道给**每一条**子代 tick 铸复合 id 行 `${runId} ${childTaskId}`,而
-     * BCE 车道(`fleetBackgroundChildPublisher`)对同一个 agent 已有 `a*`/`wa*` 稳定 handle 真行 ⇒ 同屏两行
-     * (424 次采样 180 次 max=2,连续可见窗约 15s)。BCE 侧此前只有**反应式**清扫(首 tick 一次性后缀扫),
-     * 清完本车道下一拍又铸回来,所以 6 双生帧 : 7 真帧。
-     *
-     * [2080] 裁定=**双生臂让位、不铸新 id 域**(join 键 progressTaskId 已在 BCE 帧上)。本函数即让位闸:
-     * 同 (scope, childTaskId) 已有 BCE claim ⇒ 返回 true,调用点**不发行帧**;并把本车道**先前**可能已铸的
-     * 复合行清场(claim 可能晚于我们第一拍到达),此后该 agent 单源。
-     *
-     * 为什么不是"直接删掉复合行铸造":前台 delegation(同步腿委派的子代)**不过** background-child
-     * registry ⇒ 永远没有 BCE 真行,让位就等于让这些 agent 从面板消失。那一形保留复合行,并在帧上带
-     * `sourceLane:"run-leg"` 明示这是过渡形——消费端不必再自己发明集合级去重判据。
-     */
     const yieldToBackgroundChildLane = (childTaskId, cid, tickName) => {
         const bceRowId = bus.backgroundChildLaneRow(run.scope, childTaskId);
         if (bceRowId === undefined)
             return false;
         if (children.has(cid)) {
-            // 我们早于 claim 铸过一行 —— 清场(BCE 侧的后缀扫是同一意图的反应式兜底,两者幂等叠加无害)
             bus.removeTask(cid);
             children.delete(cid);
-            // ⚠️ childStartedAt 故意不删 —— 它是下面 elapsed 供给的计时基准([2268])
             for (const [k, v] of childByToolCall)
                 if (v === cid)
                     childByToolCall.delete(k);
         }
-        // 🔴 [2268] 迁移料([2269] 认领「迁移」臂):此前让位=删「有名的 run-leg 行」留「无名的 BCE 行」
-        // ((unnamed)/0s/详情空白三症状同源)。tick 手上的显示料补给存活行,**只补缺席位** —— BCE 是权威
-        // 车道,它已有的 name/真 elapsed 一律不碰。elapsed 供给是持续的(本闸每拍都过),不是一次性冻结;
-        // elapsedDonor 记住「这行的 elapsed 是我们供的」,避免把 BCE 自己的真 elapsed 误当缺席重置。
-        // transcriptId 不在 run-leg tick 手上,迁不了(诚实范围;那半归 BCE 行自身后续 tick)。
         const row = bus.taskRow(bceRowId);
         if (row) {
             const donorName = row.name === undefined && tickName !== undefined ? redactSecrets(tickName) : undefined;
@@ -339,9 +174,6 @@ export function fleetRunPublisher(bus, run) {
                 elapsedDonor.add(cid);
             const elapsed = elapsedDonor.has(cid) ? Date.now() - childStartedAt.get(cid) : undefined;
             if (donorName !== undefined || elapsed !== undefined) {
-                // cli [2297]①:donorName 只进 `name` 位。run-leg tick 手上没有独立的类型名([1364]③/core 1.350:
-                // name=display 标签、agentType=类型名),把 display 值同时写进 agentType 会让 fleet 的 TYPE 列显示
-                // description。缺源的键不铸(与「匿名行不铸假名」同一条原则);BCE 行自己的帧带真 agentType 时自然补上。
                 bus.publishTask({
                     id: bceRowId,
                     ...(donorName !== undefined ? { name: donorName } : {}),
@@ -351,24 +183,13 @@ export function fleetRunPublisher(bus, run) {
         }
         return true;
     };
-    const elapsedDonor = new Set(); // [2268] 我们在为哪些 cid 供 elapsed(见上)
+    const elapsedDonor = new Set();
     const sumTokens = (usage) => {
         const u = usage;
         if (!u)
             return 0;
         if (typeof u.totalTokens === "number")
             return u.totalTokens;
-        // core 3.0.0([2296] 装车单 S2, [2298] R#9 二次复审并入):`turn_end.usage.inputTokens` 的语义在 3.0.0
-        // **翻转**——此前(core ≤2.x)它是 NORMALIZED TOTAL INPUT *INCLUDING CACHE*(usage-accounting
-        // promptTokensOf:Anthropic 族 = input+cacheRead+cacheWrite,OpenAI 族已把 cache 折进 input),本函数当时
-        // 直接 `inputTokens + outputTokens` 就是整轮总量;3.0.0 起 `inputTokens` 恒为 cache-MISS 分量,新必填的
-        // `totalInputTokens` 才是那个「含 cache 的归一化总量」(旧 inputTokens 语义的正统继承者)。继续只加
-        // `inputTokens` 会在有 cache 命中时**漏计**(leader 行的展示 token 数偏低)——故总量优先取
-        // `totalInputTokens`,旧核帧(尚未升级到 3.0.0、该键缺席)回落 `inputTokens`(防御性:本引擎恒 ≥3.0.0
-        // 时两键并存;异常帧宁少算不 NaN)。Display-only(leader fleet 行的 token 数);billing(costMicroUsd)+
-        // context/compaction 走 totalTokens,不受影响;child 行走 task_progress.usage.totalTokens(上面的早退臂)。
-        // [2354] 兼容面全清:旧核帧回落臂(?? u.inputTokens)已删——floor ^4.0.0 下 totalInputTokens 恒在;
-        // 键缺席=越契约帧,按 0 计(宁少算不借异语义键充数)。
         return (u.totalInputTokens ?? 0) + (u.outputTokens ?? 0);
     };
     return {
@@ -377,111 +198,48 @@ export function fleetRunPublisher(bus, run) {
         },
         onEvent(ev) {
             if (settledLeg)
-                return; // no post-settle publishes (zombie-row resurrection)
+                return;
             if (ev.type === "turn_end" && !ev.parentToolCallId) {
-                // #9 orchestration token attribution (core 1.180 TaskEventIdentity on turn_end): accrue ONLY the LEADER's own
-                // turns onto the run row. A turn_end WITH a parentToolCallId is an orchestration/subagent SUB-turn (a
-                // run_workflow agent or a spawned subagent) — its usage belongs to that child's own row / the workflow's
-                // budget, NOT the leader. Before core threaded the identity onto turn_end (1.121 left it the only boundary
-                // event without it), the leader row over-counted sub-turn usage on self-orchestration runs.
-                tokens += sumTokens(ev.usage); // turn_end carries a per-turn usage delta → accumulate
+                tokens += sumTokens(ev.usage);
                 bus.publishTask({ id: run.runId, tokens, elapsedMs: Date.now() - startedAt });
             }
             else if (ev.type === "task_progress" && ev.taskId) {
-                // core 1.147 subagent usage tick (per-turn, cumulative) → a CHILD fleet row nested under the run.
                 const cid = childId(ev.taskId);
                 if (yieldToBackgroundChildLane(ev.taskId, cid, ev.name))
-                    return; // [2070]① BCE 真行在场 ⇒ 让位不铸([2268] 随迁显示料)
+                    return;
                 children.add(cid);
-                // BC-2 (core 1.151): use the subagent's sanitized display `name` (taskName/agent-type) for the child row.
-                // [2070]③:name 缺席时**不铸**(此前回落 taskId=子代 uuid,人眼乱码)——行 IDENTITY 一直是 `cid`
-                // (runId+taskId),显示名与身份是两件事,没有显示名就让客户端渲占位。
-                // [WF2-A] redact the subagent display name for PARITY with the top-level run name (fleetRunLabels): core
-                // sanitizes it for RENDERING (ANSI/NUL strip + truncate) but does NOT secret-redact, so a secret-shaped
-                // taskName would leak verbatim on the child row without this.
-                // §K-7: `ev.name` IS the subagent TYPE (BC-2: taskName / selected agent-type) → ALSO surface it as
-                // `agentType` (the picker's short-label field), not only the display `name`. Absent name (anonymous
-                // subagent) → 两位一起缺席(name/agentType 同源同命)。One redacted value (name === agentType).
                 const childName = ev.name !== undefined ? redactSecrets(ev.name) : undefined;
                 if (!childStartedAt.has(cid))
                     childStartedAt.set(cid, Date.now());
                 if (ev.parentToolCallId)
                     childByToolCall.set(ev.parentToolCallId, cid);
-                // [1415]③ 点亮半场:core 1.354 起 settle 时补终态 tick(status 值域 additive 扩 completed|failed;
-                // 此前恒 "running"=行为逐位不变)——workflow 子的 uuid 行终于有完成态可见(running→removed 的
-                // [1414]#3 形就此闭)。
-                // #261 §2:`seq` 透传成行的 `cycleSeq`(**缺席不铸** —— 旧 core 不发这一位,而「缺席禁读作 cycle 1」)。
                 bus.publishTask({ id: cid, sourceLane: "run-leg", ...(childName !== undefined ? { name: childName, agentType: childName } : {}), parentId: run.runId, scope: run.scope, ...sessionField, status: tickStatus(ev.status), tokens: sumTokens(ev.usage), ...(typeof ev.seq === "number" ? { cycleSeq: ev.seq } : {}), ...(() => { const t = toolUsesOf(ev.usage); return t !== undefined ? { toolUses: t } : {}; })(), elapsedMs: Date.now() - childStartedAt.get(cid) });
             }
             else if (ev.type === "tool_start" && ev.toolName) {
-                // BC-1 (clay 2026-06-27): the top-level run row's `description` = LIVE ACTIVITY (the tool now running), NOT
-                // the objective. `name` already carries an objective preview (fleetRunLabels); ALSO putting the objective in
-                // `description` showed it TWICE (the dup the shell flagged). So `description` tracks the current tool, CC-like.
-                // Tool NAME only — args are untrusted/redacted, a row label must never leak them. Subagent CHILD rows keep
-                // their task_progress display name (BC-2); this updates the TOP-LEVEL run row only.
-                // PascalCase double-belt (core 1.176): canonicalize so a legacy snake CONTROL verb (e.g. a
-                // pre-1.176 emit / a stray report_blocked) renders as its CC name (ReportBlocked) and the shell's PascalCase
-                // suppression Set still hides it — never re-leaking a control verb as fleet-row activity.
-                bus.publishTask({ id: run.runId, description: ev.toolName }); // RAW(5.0.0):live 名恒 canonical
+                bus.publishTask({ id: run.runId, description: ev.toolName });
             }
         },
         onForwardEvent(ev) {
-            // core 1.154 (design/99 nested-subagent live tree): a SUBAGENT's `task_progress` tick forwarded from its
-            // ISOLATED stream to the top run's opt-in sink (`RunInternals.onForwardEvent`). This is the ONLY path a
-            // subagent tick reaches the top consumer — the top run's own stream does NOT carry it (the tick lives in the
-            // child's stream, consumed by the parent's runTask). So this builds the fleet's per-subagent CHILD rows at ANY
-            // depth: `parentTaskId` names the spawner — the TOP run (= `rootTaskId` → nest under run.runId) or another
-            // subagent (→ nest under that subagent's row). core sets a child's `parentTaskId` = its spawner's task_progress
-            // `taskId` (prepare-task.ts), so the tree keys line up. Forwarded ticks are UNTRUSTED display hints (name is
-            // core-sanitized; we carry NAME + token rollup only, never args).
-            // 🟡 parentTaskId is NOT validated against known runs (documented as LOW). It needn't be: the
-            // isolation guarantee is the SCOPE BOUND, not a parentTaskId check — every child row we publish is tagged
-            // `scope: run.scope` (this run's owner) and id-prefixed with the real `run.runId`. So a tool forging a
-            // `parentTaskId` can at worst MIS-NEST a row WITHIN this run's own scope view (cosmetic); it can never cross
-            // into another run / tenant. (core corrected its prepare-task note that had over-promised "deployment
-            // validates parentTaskId" — the bound is structural here.) Validation would be optional defense-in-depth only.
             if (settledLeg)
-                return; // a late forwarded tick must not resurrect a removed child row
+                return;
             if (ev.type !== "task_progress" || !ev.taskId)
                 return;
             const cid = childId(ev.taskId);
             if (yieldToBackgroundChildLane(ev.taskId, cid, ev.name))
-                return; // [2070]① BCE 真行在场 ⇒ 让位不铸([2268] 随迁显示料)
+                return;
             children.add(cid);
             const parentId = ev.parentTaskId && ev.parentTaskId !== run.rootTaskId ? childId(ev.parentTaskId) : run.runId;
-            // [WF2-A] redact the forwarded subagent name for parity with the top-level run name (see onEvent above).
-            // §K-7: ev.name IS the subagent type → also surface it as `agentType` (picker short label). Reuse the value.
-            // [2070]③ 同 onEvent 臂:无 name ⇒ name/agentType 两位一起缺席(不拿 taskId 冒充显示名)。
             const fwdName = ev.name !== undefined ? redactSecrets(ev.name) : undefined;
             if (!childStartedAt.has(cid))
                 childStartedAt.set(cid, Date.now());
             if (ev.parentToolCallId)
                 childByToolCall.set(ev.parentToolCallId, cid);
-            bus.publishTask({ id: cid, sourceLane: "run-leg", ...(fwdName !== undefined ? { name: fwdName, agentType: fwdName } : {}), parentId, scope: run.scope, ...sessionField, status: tickStatus(ev.status), tokens: sumTokens(ev.usage), ...(typeof ev.seq === "number" ? { cycleSeq: ev.seq } : {}), ...(() => { const t = toolUsesOf(ev.usage); return t !== undefined ? { toolUses: t } : {}; })(), elapsedMs: Date.now() - childStartedAt.get(cid) }); // [1415]③ 同上;[1748] toolUses 同 bg lane 口径;#261 seq→cycleSeq 缺席不铸
+            bus.publishTask({ id: cid, sourceLane: "run-leg", ...(fwdName !== undefined ? { name: fwdName, agentType: fwdName } : {}), parentId, scope: run.scope, ...sessionField, status: tickStatus(ev.status), tokens: sumTokens(ev.usage), ...(typeof ev.seq === "number" ? { cycleSeq: ev.seq } : {}), ...(() => { const t = toolUsesOf(ev.usage); return t !== undefined ? { toolUses: t } : {}; })(), elapsedMs: Date.now() - childStartedAt.get(cid) });
         },
         onChildTerminal(taskId, status, altId, toolUseId) {
-            // A background subagent/bash CHILD settles — task_progress never emits a terminal tick,
-            // so without this the child row sat "running" until the PARENT leg settled (the shell measured 93s of
-            // phantom running; its auto-exit release condition never fired). Flip the status so subscribers SEE the
-            // terminal frame, then remove (mirroring onTerminal's leave-the-fleet posture). Idempotent on an unknown
-            // child. ⚠️ the notification's task_id is the a* domain while ticks key by the child uuid — a live
-            // mid-turn flip can therefore miss the tick-built row (flip-through mints the a* row instead); id-domain
-            // unification is core's half. Post-settle: rows are ALREADY removed (the settle evict is the
-            // shell's release signal) — a flip-through here would mint a fresh orphan row. No-op.
             if (settledLeg)
                 return false;
-            // [1332]①:id 双域候选——tick 行键域(child sessionId uuid)与通知键域(a* task_id)因 core 版本/
-            // lane 而异,单键押注押错=真行永不落 completed(绿点不回,行滞留 running 到父 settle)。两候选谁
-            // 有活行翻谁;都没有才按首候选合成瞬态终帧(bash 无 tick 形,原语义)。
-            // codex R3:killed 保桶(与 a* 车道 fleetBackgroundChildPublisher 的终态映射一致)——操作员/系统
-            // 取消不得错报为执行失败;同一 child 两车道给订阅者的终态必须同色。
             const fleetStatus = status === "completed" ? "completed" : status === "killed" || status === "cancelled" ? "killed" : "failed";
-            // codex F1:两 id 域可能**同时**各有一行(重复/版本偏斜投递,onEvent 与 onForwardEvent 各按一域建)
-            // ——单选一行会漏掉另一域的行,滞留 running 到父 settle(绿点不回复发)。翻**全部**属本 publisher 的
-            // 候选行,逐一终帧+离场。
-            // codex R2:第三候选 = 通知 toolUseId 经 spawn 关联解出的 cid。core 的失败/killed 收尾通知缺 sessionId
-            // (subagent.js catch 分支两处只带 task_id;成功路径才条件带)——此时前两候选同为 a* 域,tick 建的 uuid
-            // 行押不中;toolUseId↔tick.parentToolCallId 是同一次 Task 调用的同源 id,把真行找回来。
             const candidateCids = [childId(taskId)];
             if (altId !== undefined && altId !== taskId)
                 candidateCids.push(childId(altId));
@@ -490,18 +248,11 @@ export function fleetRunPublisher(bus, run) {
                 candidateCids.push(viaToolCall);
             const liveCids = candidateCids.filter((c) => children.has(c));
             const hadRow = liveCids.length > 0;
-            // 🔴 F1(2026-07-30 复审):无活行时先查 BCE claim——claim 在场 = 该 agent 的全部帧归 BCE 车道
-            // (run-leg 的 tick 臂已全程让位,children 恒空),终态臂同样让位:合成复合 id 瞬态终帧会让
-            // sourceLane 文档承诺废除的「同 agent 双 id 域帧」在终态那一拍回潮(且合成帧不带 sourceLane)。
-            // 返回 true=已被处理(BCE 车道自己发 a* 终帧);无 claim 的 bash 无 tick 形走下方原语义。
             if (!hadRow) {
                 const claimed = [taskId, altId].some((t) => t !== undefined && bus.backgroundChildLaneRow(run.scope, t) !== undefined);
                 if (claimed)
                     return true;
             }
-            // 都没活行 = bash 无 tick 形:按首候选合成瞬态终帧(建即离,诚实且无害)。
-            // [2070]③:合成帧**不铸 name** —— 这条「瞬态」帧会被壳的终态留存池渲 60s,顶上去的 a\* handle
-            // 在那 60s 里就是用户看到的名字。父链接/租户/会话三位照发(它们是归属事实,不是显示名)。
             for (const cid of hadRow ? liveCids : [childId(taskId)]) {
                 const startedAtChild = childStartedAt.get(cid);
                 bus.publishTask({ id: cid, ...(children.has(cid) ? {} : { parentId: run.runId, scope: run.scope, ...sessionField }), status: fleetStatus, ...(startedAtChild !== undefined ? { elapsedMs: Date.now() - startedAtChild } : {}) });
@@ -515,10 +266,9 @@ export function fleetRunPublisher(bus, run) {
             return hadRow;
         },
         onTerminal(status, residuals) {
-            settledLeg = true; // freeze — nothing publishes on this leg's publisher after the settle
+            settledLeg = true;
             const fleetStatus = runStatusToFleet(status);
-            // [1839]①/(a) 案:真终态帧带残局键(有源才带,键逐挑不 spread);parked 帧不带(行还活着)。
-            const terminal = isTerminalFleetStatus(fleetStatus); // A-032 P1-④:removal 集不再手抄(穷举属主谓词)
+            const terminal = isTerminalFleetStatus(fleetStatus);
             const res = terminal && residuals
                 ? {
                     ...(residuals.usage ? { usage: residuals.usage } : {}),
@@ -527,27 +277,17 @@ export function fleetRunPublisher(bus, run) {
                 }
                 : {};
             bus.publishTask({ id: run.runId, status: fleetStatus, tokens, elapsedMs: Date.now() - startedAt, ...res });
-            // Subagent CHILD rows leave on ANY settle — terminal OR parked (TOC review #8: a suspended/needs_review run
-            // keeps its row, but its subagents are NOT running while the parent is parked — their work is checkpointed; a
-            // task_progress never emits a terminal, so without this the child rows leak forever as stale "running" under a
-            // parked parent). On resume, fresh task_progress/onForwardEvent re-adds the active children.
             for (const cid of children)
                 bus.removeTask(cid);
             children.clear();
-            childStartedAt.clear(); // codex F2:长寿 bg child 的计时项不得随 publisher 句柄泄漏累积(晚到回调可达期)
-            childByToolCall.clear(); // codex R2 同理:spawn 关联表随叶 settle 清空
-            // A truly-terminal run LEAVES the fleet (the shell saw the terminal frame first). A PARKED run
-            // (suspended→waiting / needs_review→awaiting approval) is still active → its ROW STAYS in the fleet.
+            childStartedAt.clear();
+            childByToolCall.clear();
             if (terminal) {
                 bus.removeTask(run.runId);
             }
         },
     };
 }
-/** [1839]①/(a) 案:TaskResult → 终态行帧残局键映射(sync/background/resume 三条腿各自 settle,共用一处
- *  映射——键名映射写三遍必漂移)。usage 与 {@link BgNotification.usage} 同形:stats.tokens→totalTokens、
- *  stats.toolCalls→toolUses(名对齐,消费端一个形状)。errorCode "cancelled" ⇒ stoppedBy:"user"(与
- *  markStopSource 的归因值同源);transcriptId 顶层 = run 的 sessionId([1840]§二拍)。缺源的键不铸。 */
 export function fleetRunResiduals(result) {
     if (!result)
         return {};
@@ -566,22 +306,6 @@ export function fleetRunResiduals(result) {
         ...(result.sessionId ? { transcriptId: result.sessionId } : {}),
     };
 }
-/**
- * design/129-B (core 1.240.0) — the PROCESS-LEVEL background-child fleet publisher, wired once
- * onto `RunnerDeps.onBackgroundChildEvent`. Unlike {@link fleetRunPublisher} (per-leg: dies at leg settle —
- * the root cause: a session-scoped bg child outliving its turn had NO forward path, fleet showed zero
- * child frames), this observer lives as long as the process and covers the child's WHOLE lifecycle:
- *   spawn    → row appears the moment the child registers (launch→turn-tail 零帧 fixed: no more waiting for a
- *              first tick that a slow child never emits inside the turn);
- *   tick     → token rollup onto the row; ALSO best-effort removes the per-leg uuid-keyed TWIN row the leg's
- *              onForwardEvent built for the same child (`${parentTaskId} ${progressTaskId}` composite — the
- *              per-leg childId shape), so the child shows ONCE, keyed by its stable a* handle;
- *   terminal → terminal frame under the a* row id, row leaves the fleet, and the contract
- *              `bg_notification` frame rides the always-open stream (缺口②'s immediate idle delivery).
- * Rows are tagged `scope` (tenant filter) from the registry scope and `sessionId` (the `?session=` filter)
- * from the registry owner when session-scoped (owner IS the host sessionId; task-scoped children have no
- * session attribution → unscoped, back-compat visible). Names ride the same redactSecrets discipline.
- */
 export function fleetBackgroundChildPublisher(bus, log) {
     if (!bus)
         return () => undefined;
@@ -590,7 +314,6 @@ export function fleetBackgroundChildPublisher(bus, log) {
             log?.(msg, fields);
         }
         catch {
-            /* observability must never fault the observer */
         }
     };
     const meta = new Map();
@@ -600,11 +323,6 @@ export function fleetBackgroundChildPublisher(bus, log) {
         meta.delete(id);
         meta.set(id, m);
         if (meta.size > MAX) {
-            // codex 两轮([1338]④ 复审):逐出**只打墓碑**(done)。R1:逐最老会把在跑 child 的 spawnedAt 挤掉,
-            // 下个 tick lazy-mint 重起表=elapsedMs 归零。R2(更重):全活时垫底逐活儿,重生条目 tenantScope 落
-            // "default"、owner/parent 全失——**跨租户错归因**(scoped 流按 "default" 键还能收到别家 child 的终态
-            // 通知残料)。活溯源绝不逐出:无墓碑=不逐,活基数由 registry 真并发界定(每条 Meta 极小);病态膨胀
-            // 打一次 warn 供观测。墓碑仍受 MAX 界(terminal 后条目=墓碑,自然轮换)。
             let victim;
             for (const [k, v] of meta) {
                 if (v.done) {
@@ -621,46 +339,18 @@ export function fleetBackgroundChildPublisher(bus, log) {
             }
         }
     };
-    /**
-     * [2070]①/[2080] 让位登记(BCE 侧半场)。把「本车道已为这个子代 uuid 建了真行」登记到 bus 上,
-     * run-leg 车道的 task_progress 臂据此让位(不铸 `${runId} ${uuid}` 复合行)。
-     *
-     * uuid 从哪来(两源,先到先得):①`e.sessionId` —— fork 形 spawn 就带(= forkedId);
-     * ②`e.progressTaskId` —— core 在 tick/terminal 帧上给的 join 键([2080] 逐字确认已在场),普通 bg
-     * producer 要等首 tick 才现。两者都是**同一个** run-leg tick 的 `taskId`,这就是 join 的依据。
-     *
-     * `progressParentTaskId` 判别照 suppressedTwin 同款:只有**本 child 自己**的 tick 才算数——嵌套孙代的
-     * 帧带的是父的 uuid,拿它 claim 会把父的 run-leg 行误让位掉(父在前台 delegation 形下没有 BCE 真行)。
-     * 旧 core 不发这两键 ⇒ 无 claim ⇒ 退回双生行旧行为(可见性回退,不错杀)。
-     */
     const claimIfKnown = (e, m) => {
         const own = !e.progressParentTaskId || e.progressParentTaskId === (m.parentTaskId ?? m.parentSessionLink);
         const uuid = e.sessionId ?? (own ? e.progressTaskId : undefined);
         if (uuid)
             bus.claimBackgroundChildLane(m.tenantScope, uuid, e.taskId);
     };
-    // [1338]③ 换算臂:core spawn emit 现把 hostSessionId 装进 parentTaskId(会话 id,非行 id)→ 子行
-    // parentId 指向不存在的行=孤儿伪影(值域修在 core)。server 兜:parentTaskId 不是现存行 id、却恰是
-    // 某 TOP-LEVEL run 行的 sessionId 时,换算成该 run 行 id。guard 式——core 修后 parentTaskId 直接命中
-    // 行 id,此臂自然失活;无命中(run 行未起/已离场)保持原值,孤儿顶格渲染,不误挂。
-    // codex R3(M1):首次**成功**解析即冻结进 Meta.resolvedParentId——逐拍重解会把跨 run 存活的长寿
-    // child 重挂到同会话后起的 run 行(launch 溯源被静默改写);孤儿(未成功)下拍再试。
     const resolveParentId = (parentInput, domain, childScope) => {
-        // codex R5:**每一条**解析分支都同租户校验(r.scope === childScope)——submit 收任意 sessionId,
-        // 碰撞可让 A 家的孙冻结到 B 家的行(fleet-wide 视图伪嵌套)。跨租户一律按未命中:孤儿顶格,fail-closed。
-        // codex(1.350 四轮):解析带**域标**——session 域链接(parentSessionLink)跳过行 id 直查与 uuid 别名
-        // 两分支(会话 id 由调用方任报,与既有 run 行 id 撞值时直查会把孩子冻到无关 run 上),只走 sessionId
-        // 匹配译臂;task 域三分支全走。
         const rows = bus.snapshot().tasks;
         if (domain === "task") {
             if (rows.some((r) => r.id === parentInput && r.scope === childScope))
                 return { id: parentInput, resolved: true };
         }
-        // codex R4(M-B)+ PAIR-REVIEW F-1:嵌套 bg 孙的父链接=父 **agent 的 uuid**——core 1.350+ 真实帧形里
-        // 该值落 **parentSessionId**(session 域;[1344]② 钳掉了洗域 parentTaskId),所以别名逆查必须对
-        // **两个域**开放(此前只挂 task 域=1.351 下三臂死代码,PAIR-REVIEW F-1 CONFIRMED)。scope-safe:
-        // 别名命中恒要求同租户(R5 的禁令针对**行 id 直查**分支——那才是任报值撞行的面;别名表是本
-        // publisher 自记的 spawn 事实,加租户校验后无跨户面)。
         for (const [aStar, pm] of meta) {
             if (pm.aliasUuid === parentInput && pm.tenantScope === childScope) {
                 if (rows.some((r) => r.id === aStar && r.scope === childScope))
@@ -669,20 +359,14 @@ export function fleetBackgroundChildPublisher(bus, log) {
         }
         let match;
         for (const r of rows) {
-            // codex R7(high):会话译只认**真 run 行**——排除一切本 publisher 记账的 a* child 行(meta 键)。
-            // session-scoped a* 孤儿行同样带 sessionId、R6 后无 parentId、同 scope,不排除则孤儿 tick 会把
-            // **自己**(或同门孤儿)选成父并冻结=自环树,晚到的真 run 行永远接不上。
             if (r.sessionId === parentInput && r.parentId === undefined && r.scope === childScope && !meta.has(r.id))
-                match = r.id; // 后写覆盖=取最近的同租户 run 行
+                match = r.id;
         }
         return match !== undefined ? { id: match, resolved: true } : { id: parentInput, resolved: false };
     };
     const rowTags = (m) => {
-        // codex R6:未解析成功=**不发 parentId**(原值只留 Meta 供下拍重试)。发原值就是 [1338]③ 伪影本身
-        // (悬空 parentId 指向不存在的行),且 fleet-wide 视图上一个撞值的外租户行 id 会在渲染端伪嵌套——
-        // 行早发孤儿顶格、解析成功后 MERGE 升级补 parentId,两边都诚实。
         let parentId;
-        const parentInput = m.parentTaskId ?? m.parentSessionLink; // 1.350 fallback 形:会话域链接同走解析臂(带域标)
+        const parentInput = m.parentTaskId ?? m.parentSessionLink;
         if (parentInput) {
             if (m.resolvedParentId !== undefined) {
                 parentId = m.resolvedParentId;
@@ -699,8 +383,8 @@ export function fleetBackgroundChildPublisher(bus, log) {
             ...(m.tenantScope ? { scope: m.tenantScope } : {}),
             ...(m.hostSessionId ? { sessionId: m.hostSessionId } : {}),
             ...(parentId !== undefined ? { parentId } : {}),
-            ...(m.workflowRunId !== undefined ? { workflowRunId: m.workflowRunId } : {}), // [1440] 附注位透传
-            ...(m.parentToolCallId !== undefined ? { parentToolCallId: m.parentToolCallId } : {}), // P1-2(core 1.432)E2 原值域
+            ...(m.workflowRunId !== undefined ? { workflowRunId: m.workflowRunId } : {}),
+            ...(m.parentToolCallId !== undefined ? { parentToolCallId: m.parentToolCallId } : {}),
             ...(m.spawnedAt !== undefined ? { startedAt: m.spawnedAt, elapsedMs: Date.now() - m.spawnedAt } : {}),
         };
     };
@@ -713,121 +397,39 @@ export function fleetBackgroundChildPublisher(bus, log) {
             return u.tokens;
         return undefined;
     };
-    // design/158 A13: the three event-kind branches below are named local functions — same closure scope/capture
-    // as when they were inline `if (e.kind === "...") { ... }` blocks in the returned dispatcher (behavior
-    // identical), alongside the already-named helpers above (dlog/remember/resolveParentId/rowTags/sumUsage).
     const handleSpawn = (e) => {
-        // PAIR-REVIEW F-3:revive spawn(spawn-after-tombstone)缺父字段时**继承墓碑 Meta 的父链**——
-        // 上一周期已解析冻结的 parentTaskId/resolvedParentId 不因重建丢失(core 1.351 revive spawn 不回放
-        // 父链;1.352 回放件到货后此臂自然让位,双保险)。只在新帧零父字段时继承,新值恒赢。
         const tomb = meta.get(e.taskId);
         const inheritParent = !e.parentTaskId && !e.parentSessionId && tomb?.done === true;
         const m = {
-            // codex 两轮(1.350 适配):core 1.350 起 fallback 形不再发洗域 parentTaskId([1364]②),补偿链接改走
-            // 声明字段 parentSessionId(/v1/tasks/stream 主车道 spec.taskId 未设=恰此形)。**两域分存**——
-            // parentTaskId=真任务域(可直出 wire),parentSessionLink=会话域(仅作行嵌套解析输入,绝不冒充
-            // 任务 id 出 bg_notification)。
             ...(e.parentTaskId ? { parentTaskId: e.parentTaskId } : {}),
             ...(!e.parentTaskId && e.parentSessionId ? { parentSessionLink: e.parentSessionId } : {}),
             ...(inheritParent && tomb?.parentTaskId !== undefined ? { parentTaskId: tomb.parentTaskId } : {}),
             ...(inheritParent && tomb?.parentSessionLink !== undefined ? { parentSessionLink: tomb.parentSessionLink } : {}),
             ...(inheritParent && tomb?.resolvedParentId !== undefined ? { resolvedParentId: tomb.resolvedParentId } : {}),
-            // session-scoped: registry owner IS the host sessionId (design/129 owner key); fork spawns also carry
-            // the child's uuid sessionId — that is the a*↔uuid cross-system anchor, NOT the host session, so it is not used here.
-            // [1522] LOW4 root-first。[2378]/[2380] RB-478 到货:三条 revive 发射腿全部无条件带
-            // `root ?? parent` 链 ⇒ `?? e.owner` 回落臂成纯死臂,删([2370] 补审时显式排除在全清宣称外
-            // 等的就是这一天)。rootSessionId 缺席=不打 host 标(over-filter 方向,durable drain 兜)。
             ...(e.sessionScoped && e.owner && e.rootSessionId ? { hostSessionId: e.rootSessionId } : {}),
-            // 🔴 scope DOMAIN mapping: core's registry scope is `ctx.principal ?? deployment scope` —
-            // UNDEFINED on a single-user no-principal deployment — while the service fleet domain keys the
-            // no-principal caller as "default" (`gatedPrincipal ?? "default"`, streamFleet's callerScope). Without
-            // this map the row/notification carried NO scope and the scoped stream dropped EVERYTHING (fail-closed
-            // — the "terminal/bg_notification 零帧" repro). Same principal string in both domains when
-            // a principal exists, so the map is exact.
             tenantScope: e.scope ?? "default",
             sessionScoped: e.sessionScoped,
-            // [2354] 兼容面全清:旧 core 帧「回落收帧时刻」臂已删——floor ^4.0.0 下 startedAt 恒在;
-            // 缺席=诚实不发(行键 optional,消费端本就容忍缺席)。
             ...(e.startedAt !== undefined ? { spawnedAt: e.startedAt } : {}),
             ...(e.rootSessionId ? { rootSessionId: e.rootSessionId } : {}),
-            ...(e.parentToolCallId ? { parentToolCallId: e.parentToolCallId } : {}), // P1-2(core 1.432,12 发射点全带)
-            ...(e.sessionId ? { aliasUuid: e.sessionId } : {}), // codex R4(M-B):uuid↔a* 别名(fork spawn 带 forkedId)
-            ...(e.workflowRunId ? { workflowRunId: e.workflowRunId } : {}), // [1440] wa* 归属附注
-            // codex 1.240-R1/R2(H 行半场):wa\* 帧 sessionScoped:false 无 host owner → 行无 sessionId=
-            // 「absent=同 principal 全会话可见」(bg 兼容语义,对 wa\* 是泄露面)。归属源两级:①**信任源**
-            // core 帧的 parentSessionId(发起会话,1.350 声明字段——R2:无 runStore 的瞬态 sync 部署没有宿主
-            // fleet 行,行查 fallback 必空);②宿主行 sessionId 查表(同租户)兜底。
+            ...(e.parentToolCallId ? { parentToolCallId: e.parentToolCallId } : {}),
+            ...(e.sessionId ? { aliasUuid: e.sessionId } : {}),
+            ...(e.workflowRunId ? { workflowRunId: e.workflowRunId } : {}),
             ...(e.workflowRunId && !(e.sessionScoped && e.owner)
-                // [2378]/[2380] RB-478:wa* 三级回落(root→parentSessionId→行查表)收单级——core 三条发射腿
-                // 已无条件带 root 锚,后两级成死臂;缺席=不打标(over-filter,durable 兜),不再猜。
                 ? (e.rootSessionId ? { hostSessionId: e.rootSessionId } : {})
                 : {}),
-            // [1493] cross-session isolation: a NON-session-scoped, non-wa* bg child (owner = the run taskId — the
-            // norm when backgroundScope!="session", i.e. every multi-tenant deployment, and any local path where the
-            // session isn't adopted at spawn) STILL carries a host session on core's declared parentSessionId
-            // (subagent.js registerBackgroundAgent). Without promoting it to hostSessionId the row/notification is
-            // session-UNTAGGED → streamFleet's `?session=` filter fails OPEN → the completion is broadcast (and
-            // model-injected) into every same-principal shell (clay's dual-shell repro). Promote it so the filter
-            // narrows precisely. (Session-scoped children already tag via the `owner` arm above; wa* via its own arm
-            // just above — both are excluded by this condition, so no double-write.) The terminal event does NOT
-            // repeat parentSessionId (core emits it on spawn only), so this MUST be captured into Meta here at spawn.
-            //
-            // codex R1 (nested-agent mis-tag): parentSessionId is core's `ctx.sessionId`, which for a NESTED bg child
-            // (spawned BY a subagent) is the PARENT AGENT's child-session uuid, NOT the shell's root session. Tagging
-            // that uuid as hostSessionId would make the outer host shell FAIL the ownerSessionId check (row +
-            // completion suppressed, durable ack fence keyed wrong). So resolve through the alias table (same reverse
-            // lookup resolveParentId uses): if some agent Meta's aliasUuid === parentSessionId, this is nested —
-            // inherit THAT agent's already-resolved hostSessionId (the root shell session), or stay UNTAGGED when the
-            // parent itself is untagged. Only a TOP-LEVEL bg child (parentSessionId is the shell root, aliased by no
-            // agent) uses parentSessionId directly. Tenant-scoped like every other alias/parent resolution (R5).
-            // fable5 R1 (honest residual): a nested child whose parent Meta is ABSENT (restart lazy-mint edge — live
-            // Meta is never evicted, so within one process the parent always exists at spawn time) is
-            // INDISTINGUISHABLE from top-level and gets tagged with the given uuid. That is still SAFE: a
-            // child-session uuid is never any shell's own session, so no scoped subscriber matches it — the failure
-            // direction is over-filtering (the true owner misses live delivery; durable inbox/stream-open drain
-            // compensate), never cross-delivery. Root fix = core carrying an explicit root-host-session (or a
-            // top-level/nested discriminator) on the spawn event — asked as a core seam follow-up ([1493]).
-            // core 1.367 δ:[1493] fable5-R1 注里请的 root fix **到货**——spawn 帧显式带 rootSessionId
-            // (固定点语义,嵌套孙代恒=root shell 会话),信任源直用;alias 反查臂降为旧 core 帧回落。
-            // [2354] 兼容面全清:alias 反查臂(旧 core 帧无 rootSessionId 时经 meta 反查 parentSessionId)已删——
-            // floor ^4.0.0 下 spawn 帧恒带 rootSessionId(core 1.367 δ 固定点语义);缺席=不打 host 标,
-            // 失败方向仍是 over-filtering(durable inbox/stream-open drain 兜),永不 cross-delivery。
             ...(!(e.sessionScoped && e.owner) && !e.workflowRunId && e.rootSessionId
                 ? { hostSessionId: e.rootSessionId }
                 : {}),
         };
         remember(e.taskId, m);
-        // [2070]① 让位登记(spawn 臂):fork 形 spawn 就带 sessionId=子代 uuid;普通 bg producer 的 spawn
-        // 不带,要等首 tick 的 progressTaskId(下方 handleTick 补 claim)。
         claimIfKnown(e, m);
-        // [1364]③:spawn 帧 1.349+ 也带 agentType(类型名)/name——行 name 位保 description(display 标签,
-        // 历史语义),TYPE 列自 spawn 即亮(此前要等首 tick 自愈)。
-        // [1827]①(cli):spawn 行也透传 transcriptId(委派 prompt 的映射,详情页运行中即可取件)。
-        // 现状 core 只在 terminal 事件带此键(三发射点亲核)⇒ 本透传对旧 core 惰性;core 停 spawn/tick
-        // 源头补上即通,tick 臂(下方 :78x)早已同姿。server 不自行以 sessionId 推导——fork lane 的
-        // forkTranscriptId 与 sessionId 的等价关系归 core 所有,不在消费端烙死。
-        // [2400] FLEET-WORKFLOWS-7:[2070]③「名不铸」的第四处——spawn 双缺 description/name 时此前 `?? e.taskId`
-        // 拿 a* handle 冒充显示名;tick 臂只在 name 在场才发 + 总线 MERGE ⇒ 假名永久留行。缺席不铸,与其余三处同判。
         const spawnName = e.description ?? e.name;
-        // #261 §2:core 5.36.0(#258)把 `seq` 从「只在 terminal 帧」放宽到 **spawn/tick 也带**(registry 行
-        // 的 stop-cycle 代际)。本车道是设计稿点名的第二条供给点 —— 三帧一律透传成行的 `cycleSeq`,**缺席不铸**。
         bus.publishTask({ id: e.taskId, ...(spawnName !== undefined ? { name: redactSecrets(spawnName) } : {}), ...(e.agentType ? { agentType: redactSecrets(e.agentType) } : {}), ...rowTags(m), status: "running", tokens: 0, ...(typeof e.seq === "number" ? { cycleSeq: e.seq } : {}), ...(e.transcriptId ? { transcriptId: e.transcriptId } : {}) });
         dlog("bg_child_event", { kind: "spawn", taskId: e.taskId, sessionScoped: e.sessionScoped, scope: m.tenantScope, hostSessionId: m.hostSessionId ?? null, parentTaskId: m.parentTaskId ?? null });
     };
     const handleTick = (e, m) => {
-        // [2070]① 让位登记(tick 臂):普通 bg 形的 uuid 首次可见就在这里。**在**下面任何发布之前 claim,
-        // 这样即便 run-leg 的 forward 与本 tick 同拍到达,run-leg 也已经能看到让位信号。
         claimIfKnown(e, m);
-        // dedup the per-leg uuid-keyed twin ONCE: the leg's onForwardEvent keys the same child's rows by
-        // `${runId} ${uuid}` and on the /v1/runs path runId === the host canonical taskId (spec.taskId is the
-        // durable run id). The tick that carries the child's OWN frame has progressParentTaskId === the host
-        // taskId (a NESTED grandchild carries the child's uuid instead — never suppressed here). A miss is a
-        // no-op remove (best-effort; worst case = a transient duplicate row until the leg settles, old behavior).
         if (!m.suppressedTwin && e.progressTaskId && (!e.progressParentTaskId || e.progressParentTaskId === (m.parentTaskId ?? m.parentSessionLink))) {
-            // The per-leg childId is `${run.runId} ${uuid}` and runId ≠ the core hostTaskId on the
-            // sync-stream/resume paths (durableTaskId vs canonical sessionId), so a composite-key guess misses there.
-            // Scan-by-suffix instead: the uuid tail uniquely names the child across every leg's runId prefix. One-shot
-            // (suppressedTwin) so the O(rows) scan runs once per child.
             const tail = ` ${e.progressTaskId}`;
             for (const row of bus.snapshot().tasks) {
                 if (row.id.endsWith(tail))
@@ -835,13 +437,6 @@ export function fleetBackgroundChildPublisher(bus, log) {
             }
             m.suppressedTwin = true;
         }
-        // codex R8:普通(非 fork)bg producer 的 spawn 不带 sessionId,uuid 别名要等 terminal 才现——嵌套孙
-        // 在父运行期解析全 miss。但 child 本人的 tick 恒带 progressTaskId=其 uuid(与双生抑制同一判别形),
-        // 首 tick 即学别名;孙侧 retry-until-success 语义随后一拍自然接上(spawn 路径已带 sessionId 的 fork 形
-        // 不受影响,??= 只补缺)。
-        // codex R9:别名习得**即回填**——快孙可能已无后续帧(spawn+tick+terminal 全在父首 tick 前),等孙自己
-        // retry 就永远孤儿。习得此刻主动扫在场未解析孤儿,替它们把行升级(rowTags 内解析+冻结)。彻底闭窗
-        // (孙整个生命周期都在别名前走完的瞬态孤儿)在 core:普通形 spawn emit 补 sessionId(fork 形已带)。
         if (m.aliasUuid === undefined && e.progressTaskId && (!e.progressParentTaskId || e.progressParentTaskId === (m.parentTaskId ?? m.parentSessionLink))) {
             m.aliasUuid = e.progressTaskId;
             for (const [cid, cm] of meta) {
@@ -852,33 +447,18 @@ export function fleetBackgroundChildPublisher(bus, log) {
         }
         const tokens = sumUsage(e.usage);
         const name = e.name ? redactSecrets(e.name) : undefined;
-        // [1364]③ K-7 换位:TYPE 列取 tick 帧的行级 `agentType`(core 1.350 定谳)。[2354] 兼容面全清:
-        // 「缺省回落 name」旧 core 兼容臂已删——floor ^4.0.0 下 agentType 恒在;缺席=诚实不发(行键 optional)。
         const agentType = e.agentType ? redactSecrets(e.agentType) : undefined;
-        // The sink tick carries core's currentAction (its only attachment point today) —
-        // UNTRUSTED (tool argument head) → redact, same discipline as name. Additive; absent until a tool runs.
         const currentAction = e.currentAction ? redactSecrets(e.currentAction) : undefined;
-        // [1827]②/core 1.429:结构化同源体。字段 PICKED(不整对象 spread——future core 键不得裸骑);
-        // toolName verbatim,target 与 currentAction 同边界(redact + 300 bound,brainStatus.detail 同惯例)。
         const currentTool = e.currentTool
             ? { toolName: e.currentTool.toolName, ...(e.currentTool.target !== undefined ? { target: redactSecrets(e.currentTool.target).slice(0, 300) } : {}) }
             : undefined;
-        // cli [1748]:两个 additive 位。`toolUses` 是**累计值**(与 turn_end 的每轮增量相反)⇒ 直接上行不累加;
-        // 缺席时**不发这个键**(消费方不得把缺席当 0)。`transcriptId` 是委派 prompt 的**映射** ——
-        // prompt 本身不在 `BackgroundChildEvent` 上,server 收不到就不造。
-        bus.publishTask({ id: e.taskId, ...rowTags(m), status: "running", ...(tokens !== undefined ? { tokens } : {}), ...(name ? { name } : {}), ...(agentType ? { agentType } : {}), ...(currentAction ? { currentAction } : {}), ...(currentTool ? { currentTool } : {}), ...(typeof e.seq === "number" ? { cycleSeq: e.seq } : {}), ...(e.usage?.toolUses !== undefined ? { toolUses: e.usage.toolUses } : {}), ...(e.transcriptId ? { transcriptId: e.transcriptId } : {}) }); // #261 seq→cycleSeq 缺席不铸
+        bus.publishTask({ id: e.taskId, ...rowTags(m), status: "running", ...(tokens !== undefined ? { tokens } : {}), ...(name ? { name } : {}), ...(agentType ? { agentType } : {}), ...(currentAction ? { currentAction } : {}), ...(currentTool ? { currentTool } : {}), ...(typeof e.seq === "number" ? { cycleSeq: e.seq } : {}), ...(e.usage?.toolUses !== undefined ? { toolUses: e.usage.toolUses } : {}), ...(e.transcriptId ? { transcriptId: e.transcriptId } : {}) });
     };
     const handleTerminal = (e, m) => {
-        // terminal: flip the row so subscribers SEE the terminal frame, then leave the fleet — and push the
-        // contract bg_notification on the always-open lane (缺口②: idle delivery is immediate; the durable
-        // inbox park stays as the offline/replay belt, shell dedups by (taskId,status)).
         const status = e.status === "completed" ? "completed" : e.status === "killed" ? "killed" : "failed";
-        // [1839]①/(a) 案:终态**行帧**同带残局键——此前只有 {id,status},看行卡(不订通知帧)的 idle 观察者
-        // 拿不到终局。与下方 bg_notification 同源同姿势:键逐挑不 spread、editedFiles path 过 redactSecrets
-        // + 100 界、缺席不铸。(recentSteps 不进行帧——通知卡语义,行卡不渲染步骤列表。)
         bus.publishTask({
             id: e.taskId, ...rowTags(m), status,
-            ...(typeof e.seq === "number" ? { cycleSeq: e.seq } : {}), // #261 §2:终帧带**被结算那一代**的代际号(缺席不铸)
+            ...(typeof e.seq === "number" ? { cycleSeq: e.seq } : {}),
             ...(e.stoppedBy ? { stoppedBy: e.stoppedBy } : {}),
             ...(e.resumable !== undefined ? { resumable: e.resumable } : {}),
             ...(e.transcriptId ? { transcriptId: e.transcriptId } : {}),
@@ -897,12 +477,8 @@ export function fleetBackgroundChildPublisher(bus, log) {
                 : {}),
         });
         bus.removeTask(e.taskId);
-        // [2070]① 让位解除:本子代已终态离场,同 uuid 的迟到帧回到旧行为(claim 只在活期有效)。
         if (m.aliasUuid)
             bus.releaseBackgroundChildLane(m.tenantScope, m.aliasUuid);
-        // codex 1.240-R1(M2):1.356 的回调序=bceTick 先于 host forward——tick 处的双生抑制扫在 uuid 双生
-        // 行发布**之前**,one-shot 空扫后置旗,双生行永存。terminal 补扫一次(aliasUuid=tick 学到的 child
-        // uuid),把 run-leg 的复合键行清场。
         if (m.aliasUuid) {
             const tail = ` ${m.aliasUuid}`;
             for (const row of bus.snapshot().tasks) {
@@ -910,32 +486,19 @@ export function fleetBackgroundChildPublisher(bus, log) {
                     bus.removeTask(row.id);
             }
         }
-        // codex 1.240-R1(H1):wa\*(workflowRunId 在)不走 bg_notification 契约——该帧族=后台任务完成通知
-        // (壳注入模型),workflow 的完成通知已有 workflow_complete 专链;且 1.356 wa\* 帧 sessionScoped:false
-        // 无 host owner → 通知无 ownerSessionId=同租户**全会话**可见(streamFleet 的 absent-放行是 bg 兼容位,
-        // 不是 wa\* 的授权)。per-agent 完成本就不该打断模型(CC 亦无此形)。
         if (m.workflowRunId !== undefined) {
-            m.done = true; // codex 1.240-R2(M):早退分支必须先落墓碑——迟到/重放 tick 不得复活已离场的 wa* 行
+            m.done = true;
             dlog("bg_child_event", { kind: "terminal-wa-no-notification", taskId: e.taskId, workflowRunId: m.workflowRunId });
             return;
         }
         bus.publishBgNotification({
             taskId: e.taskId,
             ...(e.sessionId ? { sessionId: e.sessionId } : {}),
-            // [1392]①(PAIR-REVIEW F-1@cli 的 wire 前置):终帧 seq(core 1.352 BackgroundChildEvent.terminal 补位,
-            // tolerate-absent——旧 core 无此位=不发,cli 键折 seq 的修依赖它区分 revive 周期)。
             ...(typeof e.seq === "number" ? { seq: e.seq } : {}),
             status: e.status ?? "failed",
             ...(e.summary ? { summary: redactSecrets(e.summary) } : {}),
             scope: (m.sessionScoped || e.sessionScoped) ? "session" : "task",
-            // codex(1.350 二轮):wire 的 parentTaskId 位只出真任务域;fallback 形出解析成功的 run 行 id
-            // (=durable run id,消费者拿它绑父行),解析未成=省略,绝不让会话 id 冒充任务 id 出 wire。
             ...(m.parentTaskId ? { parentTaskId: m.parentTaskId } : m.resolvedParentId ? { parentTaskId: m.resolvedParentId } : {}),
-            // The residual fields must ride THIS lane too (the "kill across turns" main line renders
-            // off it). Same posture as project.ts/inbox; fields picked, arrays defensively bounded.
-            // P1-3(core 1.452,[1925] 一轮批):completionId=子代完成的幂等锚,消费端(cli)按它对同一完成的
-            // 多路通知(bg_notification/task_notification/inbox 重放)去重。verbatim 透传,仅通知帧带
-            // (行帧不带——行的身份是 taskId,幂等锚是通知语义)。
             ...(e.completionId ? { completionId: e.completionId } : {}),
             ...(e.stoppedBy ? { stoppedBy: e.stoppedBy } : {}),
             ...(e.resumable !== undefined ? { resumable: e.resumable } : {}),
@@ -943,7 +506,6 @@ export function fleetBackgroundChildPublisher(bus, log) {
                 ? { recentSteps: e.recentSteps.slice(0, 10).map((s) => ({ tool: s.tool, target: redactSecrets(s.target), outcome: redactSecrets(s.outcome) })) }
                 : {}),
             ...(e.editedFiles !== undefined ? { editedFiles: e.editedFiles.slice(0, 100).map((f) => ({ path: redactSecrets(f.path), edits: f.edits })) } : {}),
-            // [1543]§二 LOW:usage/transcriptId 补齐(fields picked——usage 六数值键逐一挑,不整对象 spread)。
             ...(e.usage
                 ? {
                     usage: {
@@ -957,14 +519,13 @@ export function fleetBackgroundChildPublisher(bus, log) {
                 }
                 : {}),
             ...(e.transcriptId ? { transcriptId: e.transcriptId } : {}),
-            ...(e.parentToolCallId ? { parentToolCallId: e.parentToolCallId } : {}), // P1-2(core 1.432)——通知帧同带,cli「全部生命周期事件在场」
+            ...(e.parentToolCallId ? { parentToolCallId: e.parentToolCallId } : {}),
             ...(m.tenantScope ? { ownerScope: m.tenantScope } : {}),
             ...(m.hostSessionId ? { ownerSessionId: m.hostSessionId } : {}),
             ...(m.rootSessionId ? { rootSessionId: m.rootSessionId } : {}),
         });
-        // One info line per terminal so the emit-vs-filter bisect is a log-grep, not a rerun.
         dlog("bg_child_event", { kind: "terminal", taskId: e.taskId, status, scope: m.tenantScope ?? null, hostSessionId: m.hostSessionId ?? null, childSessionId: e.sessionId ?? null, bgNotificationPublished: true });
-        m.done = true; // tombstone (kept in the bounded map) — see Meta.done
+        m.done = true;
         m.suppressedTwin = true;
     };
     return (e) => {
@@ -972,22 +533,18 @@ export function fleetBackgroundChildPublisher(bus, log) {
             handleSpawn(e);
             return;
         }
-        // [2354] 补审 F2:lazy-mint 不再铸 spawnedAt: Date.now() 假锚(与 spawn 臂同口径——缺 launch 锚=
-        // 诚实缺席,行键 optional;tick/terminal 先到=restart/丢 spawn 边缘,收帧时刻不是 launch 时刻)。
-        const m = meta.get(e.taskId) ?? { sessionScoped: e.sessionScoped, tenantScope: e.scope ?? "default" }; // scope domain map holds on the lazily-minted path too([1338]④ 首见起表);F2(2026-07-30 复审):lazy-mint 曾硬编码 "default",scoped 部署下 claim 落错租户键 ⇒ 让位失效退回双生行
+        const m = meta.get(e.taskId) ?? { sessionScoped: e.sessionScoped, tenantScope: e.scope ?? "default" };
         if (!meta.has(e.taskId)) {
-            remember(e.taskId, m); // tick/terminal without a seen spawn (restart/eviction edge) — row minted lazily
+            remember(e.taskId, m);
             dlog("bg_child_event", { kind: `${e.kind}-lazy-mint`, taskId: e.taskId, sessionScoped: e.sessionScoped });
         }
         else {
-            remember(e.taskId, m); // codex:活儿每拍刷新近度——LRU 兜底永远先挤最久没动静的,不挤在跑的
+            remember(e.taskId, m);
         }
         if (m.done) {
-            // tombstone: this child already settled — a late tick must not resurrect a running row (settle-freeze 同族).
             dlog("bg_child_event", { kind: `${e.kind}-after-terminal-ignored`, taskId: e.taskId });
             return;
         }
-        // P1-2(core 1.432):lazy-mint/spawn 前旧 core 帧路径——parentToolCallId「出生就在场」,首见即补
         if (m.parentToolCallId === undefined && e.parentToolCallId)
             m.parentToolCallId = e.parentToolCallId;
         if (e.kind === "tick") {
@@ -997,32 +554,15 @@ export function fleetBackgroundChildPublisher(bus, log) {
         handleTerminal(e, m);
     };
 }
-/** BC-1 (clay-decided 2026-06-27): a top-level run's fleet-row `name` = a SHORT, single-line **objective preview**
- *  (the readable "what is this task" label) — NOT the full objective dumped in, and NOT duplicated into `description`.
- *  `description` is left to the publisher's LIVE-ACTIVITY update (`onEvent` tool_start → the current tool), so the row
- *  shows `name`=objective + `description`=current activity (two DISTINCT things, killing the earlier "objective shown
- *  twice" dup). Whitespace-collapsed + capped ≤48. (A subagent CHILD row's name = its agent-type — BC-2.)
- *  SECRET-SAFE: redact secret shapes (redactSecrets) BEFORE truncating — a secret in the objective must not leak in
- *  the row name. The durable objective is already redacted; the name preview was asymmetric (raw) until this. */
 export function fleetRunLabels(objective) {
     const oneLine = redactSecrets((objective ?? "").replace(/\s+/g, " ")).trim();
     if (!oneLine)
         return { name: "task" };
-    // [1414]④:控制帧形 objective(注入 turn 的 `<task-notification>…` 等 XML 头)不得当行名——用户底部
-    // 会看到「<task-notifica…」尖括号伪影。以 `<` 开头且形如 XML tag 的 objective 给中性名;真实用户
-    // objective 以 `<` 开头的形(粘贴 HTML 片段)极罕且中性名无害。
     if (/^<[a-z][a-z0-9_-]*[\s>/]/i.test(oneLine))
         return { name: "(notification turn)" };
     const name = oneLine.length > 48 ? `${oneLine.slice(0, 47)}…` : oneLine;
     return { name };
 }
-/**
- * fleet 行的**离场**判据(`onTerminal` 的 removal 集)—— `FleetTaskStatus` 的穷举 switch。
- *
- * 与 {@link runStatusToFleet} 同族(A-032 P1-④ 证据段点名):此前是消费点手抄的
- * `=== "completed" || === "failed" || === "killed"` 三词字面比对,fleet 词表加成员时同样没有编译期钉。
- * park 态(`waiting` / `awaiting approval`)判 false 是承重的:行还活着,必须留在 fleet 上。
- */
 export function isTerminalFleetStatus(status) {
     switch (status) {
         case "completed":
@@ -1037,16 +577,12 @@ export function isTerminalFleetStatus(status) {
         case "idle":
             return false;
         default: {
-            const unhandled = status; // FleetTaskStatus 加成员 ⇒ tsc 红,加成员的人当场回答「这个态算不算离场」
+            const unhandled = status;
             void unhandled;
-            // 运行期保守:未知 ⇒ 不摘行(误摘 = 把一条还在跑的任务从面板上抹掉;漏摘只是多一行)。
-            // 这条臂与 runStatusToFleet 的 miss 臂**不同源**:`FleetTaskStatus` 是本仓自有词表,只会被本仓
-            // 自己加成员,而那是编译期就红的事 —— 所以这里不接留痕(没有"运行期冒出个新词"的来路)。
             return false;
         }
     }
 }
-/** Map a service run status onto the neutral fleet vocabulary the shell renders. */
 export function runStatusToFleet(status, opts) {
     if (opts?.awaitingPlanApproval)
         return "awaiting approval";
@@ -1059,26 +595,17 @@ export function runStatusToFleet(status, opts) {
             return "completed";
         case "failed":
         case "error":
-        case "blocked": // report_blocked = a non-success TERMINAL outcome (agent gave up) → the "failed" bucket (the
-            // neutral fleet vocab has no "blocked"). CRUCIAL: this also lets onTerminal REMOVE the row — the removal set is
-            // {completed,failed,killed}, so without mapping "blocked" here it fell through to the "idle" default and a
-            // terminal blocked run LEAKED a permanent stale "idle" row on the fleet (caught by on-box e2e, 2026-06-28).
+        case "blocked":
             return "failed";
         case "suspended":
-            return "waiting"; // a durable suspend = parked, awaiting resume
+            return "waiting";
         case "needs_review":
             return "awaiting approval";
         case "killed":
         case "cancelled":
             return "killed";
         default: {
-            // 🔴 编译期执法点:词表加成员 ⇒ 这里收不敛到 `never` ⇒ tsc 红,加成员的人必须当场回答
-            // 「这个新态在 fleet 上长什么样、行该不该离场」。
             const unhandled = status;
-            // 运行期防线(#157:runtime miss 臂必须自陈)。这条臂**运行期仍可达**:`rowToRun` 把无约束的
-            // SQL 文本列裸 cast 成联合,滚动升级里更新的副本写入的新状态词会被旧副本读到。方向照旧折 `idle`
-            // (不改行为,改的是「静默」),但每次 miss 必须留痕 —— 否则「fleet 上为什么有一行永远不走的 idle」
-            // 在遥测里没有任何痕迹,只能靠人眼在面板上发现。
             recordFailOpen("server.fleet.run-status-unmapped", String(unhandled));
             return "idle";
         }