@sema-agent/server 7.142.0 → 7.143.0

package/dist/fleet/fleet-bus.d.ts

@@ -1,18 +1,5 @@
-import type { TaskNotificationPayload, TerminalCause, WorkflowRun } from "@sema-agent/core";
+import type { TerminalCause, WorkflowRun } from "@sema-agent/core";
 import type { RunRecord } from "../plugins/store-contracts.js";
-/** [ref] 幽灵行案的单源判别:一条 `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`。
- *
- *  🔴 [ref]([ref]):判别**本体已换 core 的 {@link isDelegatedAgentTerminal}**。此前这里是一份手写语义
- *  孪生(自己枚举 `completed|failed|killed|cancelled`),头注自陈「与 core 语义同源——core 根导出后换装
- *  import 删本镜像」。core 现已从包根导出(`index.d.ts`),且它的终态集与 pending 店的驱逐偏好共用
- *  同一份 `TERMINAL_STATUSES`(core 原话:「so "terminal" can never mean two things in this module」)——
- *  孪生留在这里等于让 fleet 面板对「终态」的理解可以和引擎分家。本函数保留为**具名的 fleet 语义位**
- *  (调用点读的是「这条通知该不该打 fleet 的 onChildTerminal」,不是「core 怎么判终态」)。 */
-export declare function isFleetAgentTerminalNotification(n: Pick<TaskNotificationPayload, "task_type" | "status">): boolean;
 /** The fleet vocabulary the shell renders (MF-Fleet `FleetTask.status`). The service maps its run/workflow status
  *  onto this neutral set; `awaiting approval` = a needs-review/plan-approval park, `waiting` = a durable suspend.
  *
@@ -144,8 +131,8 @@ export interface FleetTaskRow {
      *  - 缺席 = BCE 车道(`fleetBackgroundChildPublisher`)的 a\* 与 wa\* 真行,或顶层 run 行 —— 单源,常态。
      *  - `"run-leg"` = 由每腿的 `fleetRunPublisher` 从 `task_progress` tick 铸的**复合 id 行**
      *    (`${runId} ${childTaskId}`)。此形只在**没有 BCE 真行**的前台 delegation 上保留(同步腿委派的
-     *    子代不过 background-child registry ⇒ 不让位就没有行);同 (scope, progressTaskId) 一旦有 BCE 真行,
-     *    本车道**让位不铸**(双生行退役)。
+     *    子代不过 background-child registry ⇒ 不让位就没有行);tick 点名的是 BCE 真行(后台子代的 tick 带它的行 id;workflow agent 的
+     *    tick 带会话 id、经让位登记簿换成行 id),本车道**让位不铸**(双生行退役)。
      *  消费端读法:带 `sourceLane:"run-leg"` 的行是过渡形,与 a\* 行**不会**同时描述同一个 agent;不需要再
      *  自己发明「复合 id 首段==parentId 且撞 (parentId,name)」那类集合级判据(cli 侧的防御税)。
      *  ADDITIVE / tolerate-absent。 */
@@ -247,15 +234,14 @@ export type FleetFrame = {
      * 车HW 逐条亲读本文件的七处 `removeTask` 铸点后改成真话,消费方面的成文版 =
      * `docs/ASSISTANT-WIRE-CONTRACT.md` 附录 H)。缺席形其实是**两族**:
      * (**按臂名找,不给行号** —— 本注与铸点同住一个文件,写死数字会被下一次改注自己顶歪。)
-     *  · **结算级** —— 这一行**自己的**终态 `task` 帧刚发过,remove 只是成对的后半。四处:
-     *    `fleetRunPublisher.onChildTerminal` 的「bash 无 tick 形」合成瞬态帧(publish → remove 同一个
-     *    `for` 体)、`fleetRunPublisher.onTerminal` 的顶层行(`publishTask(run.runId, fleetStatus)` →
+     *  · **结算级** —— 这一行**自己的**终态 `task` 帧刚发过,remove 只是成对的后半。三处:
+     *    `fleetRunPublisher.onTerminal` 的顶层行(`publishTask(run.runId, fleetStatus)` →
      *    `if (terminal) removeTask(run.runId)`)、`fleetBackgroundChildPublisher` 的子代终局
      *    (带残局键的行帧 → `removeTask(e.taskId)`)、以及对账腿 `fleet-reconciler.ts` 的 `retire` 与
      *    候补窗 `upgradeWatched`(两者都先帧后撤)。
-     *  · **投影级 —— 没有自己的终态帧,但也不是「这个任务结束了」**:① **双生让位 / 双生抑制**
-     *    (`yieldToBackgroundChildLane` 把 run-leg 行让给 BCE 权威行;tick 期与子代终局期两处按
-     *    ` ${uuid}` 后缀扫掉 run-leg 复合键双生)—— 同一个实体改由**另一行**渲染,终局会落在**那一行**上;
+     *  · **投影级 —— 没有自己的终态帧,但也不是「这个任务结束了」**:① **双生让位**
+     *    (`yieldToBackgroundChildLane` 把本车道先前铸的 run-leg 行让给 BCE 权威行,由 run-leg 车道自己收)
+     *    —— 同一个实体改由**另一行**渲染,终局会落在**那一行**上;
      *    ② **父 leg settle 时把子代行收走**(`onTerminal` 里的 `for (const cid of children) removeTask(cid)`),
      *    **含父 parked 的形**(理由逐字在该处:子代在父 park 期间并不在跑,resume 后新的 `task_progress`
      *    会重新建行;而子代本来就从不发终态 tick)。
@@ -585,7 +571,7 @@ export declare class FleetEventBus {
      *
      *  `opts`([ref],两键均 ADDITIVE):`removeReason:"orphaned"` = **陈述级退场**(没有结算语义,见
      *  {@link FleetFrame} 的 `task_remove` 臂;[ref] 起**不封被退那一代**,同代帧 = 复活);`cycleSeq` = 被退那一代的代际号。发布方的常规清场
-     *  (`onTerminal`/`onChildTerminal`)不传 opts ⇒ 帧逐字节与本改动之前相同。 */
+     *  (`onTerminal`、BCE 车道的子代终局)不传 opts ⇒ 帧逐字节与本改动之前相同。 */
     removeTask(id: string, opts?: {
         removeReason?: "orphaned";
         cycleSeq?: number;
@@ -593,30 +579,28 @@ export declare class FleetEventBus {
     private readonly bceClaims;
     private static readonly BCE_CLAIM_MAX;
     private static bceKey;
-    /** BCE 车道:本车道已为该子代 uuid 建了真行 —— run-leg 车道自此让位。幂等。 */
-    claimBackgroundChildLane(scope: string | undefined, childUuid: string, rowId: string): void;
-    /** BCE 车道:该子代已终态离场 —— 让位解除(后续同 uuid 的迟到 tick 回到旧行为)。幂等。 */
-    releaseBackgroundChildLane(scope: string | undefined, childUuid: string): void;
-    /** run-leg 车道:该子代是否已有 BCE 真行(有 ⇒ 让位,不铸复合 id 行)。 */
-    backgroundChildLaneRow(scope: string | undefined, childUuid: string): string | undefined;
+    /** BCE 车道:腿的这个名字(会话 id 或腿 task id)点名的是本车道的这一行 —— run-leg 车道自此让位。幂等。 */
+    claimBackgroundChildLane(scope: string | undefined, legName: string, rowId: string): void;
+    /** BCE 车道:该行已终态离场 —— 撤它名下的**每一个**名字(重试换过会话的,几只都撤;后续同名的迟到 tick 回到旧行为)。幂等。 */
+    releaseBackgroundChildLane(scope: string | undefined, rowId: string): void;
+    /** 腿的这个名字点名的 BCE 行(有 ⇒ run-leg 让位、孙代挂它下面、审批归它)。 */
+    backgroundChildLaneRow(scope: string | undefined, legName: string): string | undefined;
     /** [ref] 让位迁移料的读面:迁移「只补缺席位」需要看得见存活行现有什么(BCE 是权威车道,不覆盖)。 */
     taskRow(id: string): Readonly<FleetTaskRow> | undefined;
     /**
-     * [ref]:一条子代行在它两只**属主账**上的键。三个 id 域互不相同,换算只有本类做得了(两种行 id 都是本文件
-     * 铸的,两域之间唯一的 join —— 让位登记簿 —— 也住在这里),所以换算只写这一处:
-     *  · 行 id —— BCE 车道 = registry handle 本身(`e.taskId`);run-leg 车道 = `${runId} ${子代 task_progress taskId}`
-     *    (`fleetRunPublisher` 的 `childId`);
-     *  · `handle` —— core bg registry / `BackgroundAgentStore` 的行键,**只认** `DURABLE_AGENT_HANDLE_RE` 形
-     *    (`wa*` 不在 bg 账上);
-     *  · `sessionIds` —— 子代自己的 core session id(uuid 域)= 待决审批 `originTaskId` 的值域
-     *    (core `AskRequest.sourceTaskId`:「the issuing task's session id」),**不是** handle。是**集合**:同一行名下
-     *    可以先后挂过几个子代 session(`wa*` 重试换 session、复活换 session),让位登记簿对每一个都留着 claim ——
-     *    只取其一(此前取最早那个)会漏掉当前这一次的卡(codex r1 F3)。
-     * 换不出的键就缺席 / 空(不猜):父链接行 / 顶层 run 行两者皆无;BCE 行在本车道学到子代 uuid 之前 `sessionIds` 为空。
+     * [ref]:一条子代行在它两只**属主账**上的键。行 → 键的换算只写这一处(两种行 id 都是本文件铸的,会话 id 那张 join 表也住在这里):
+     *  · `handle` —— core bg registry / `BackgroundAgentStore` 的行键:行 id 本身是引擎的句柄形(`DURABLE_AGENT_HANDLE_RE`)才有
+     *    (`wa*` 与 run-leg 复合行不在 bg 账上);
+     *  · `names` —— 这一行那条腿的名字,待决审批按它们认发起者(问上带它那条腿的名字:`agentId` = 腿 task id,委派子代的问另带
+     *    发起会话 `sourceSessionId`;任一个是这一行的名字 ⇒ 这一问是这一行的)。同一条读法点名 tick 的行,所以三形各取各的:句柄形的行 ⇒
+     *    行 id 本身(后台子代的会话 id 不是它的名字,本表不登);run-leg 复合行 `${runId} ${前台子代的腿 id}` ⇒ 尾段(前台子代的腿 id
+     *    就是它的会话 id);其余 BCE 行(`wa*`)⇒ 登记在它名下的**每一个**名字(会话 id,重试换了会话两次都在 —— 只取其一会漏掉当前这一次的卡,
+     *    codex r1 F3;脚本声明的腿 task id,首拍起)。
+     * 换不出的键就缺席 / 空(不猜):顶层 run 行两者皆无。
      */
     childOwnerKeys(row: Pick<FleetTaskRow, "id" | "scope">): {
         handle?: string;
-        sessionIds: readonly string[];
+        names: readonly string[];
     };
     /**
      * Publish a workflow row + fan out. **The row is the whole row and REPLACES the previous one** (by `id`). A workflow row has exactly one producer,
@@ -691,14 +675,6 @@ export declare function fleetRunPublisher(bus: FleetEventBus | undefined, run: {
         status?: string;
         seq?: number;
     }) => void;
-    /** Flip + remove one subagent CHILD row when its background completion notification arrives
-     *  (task_progress never emits a terminal tick — without this a bg child sat "running" until parent settle).
-     *  FLIP-THROUGH: publishes the terminal frame even when the row no longer exists — the parent leg's
-     *  settle removes ALL child rows (it cannot tell a settled sync child from a still-running bg child), so a bg
-     *  child that completes after parent settle otherwise had NO row to flip and the shell (auto-exit's fourth
-     *  release condition watches the viewed cid's terminal) never saw a terminal transition. Returns whether the
-     *  row EXISTED (hadRow — the observer logs it; false = the frame was synthesized flip-through). */
-    onChildTerminal: (taskId: string, status: string, altId?: string, toolUseId?: string) => boolean;
     /** [ref]①/(a) 案:`residuals` = 顶层 run 的终局残局键(有源才传,见 FleetTaskRow 上的键注)。
      *  只有**真终态**(completed/failed/killed)帧带残局——parked(suspended/needs_review)的行还活着,
      *  没有「终局」可言,误传也不上帧。 */
@@ -739,9 +715,9 @@ export declare function fleetRunResiduals(result: {
  * 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;
+ *   tick     → token rollup onto the row. The child shows ONCE, keyed by its row id: a background agent's
+ *              ticks carry that id (core 7.61.0), a workflow agent's carry its session id, registered here from
+ *              the frame's `sessionId` — either way the per-leg lane yields; this lane writes only its own rows;
  *   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)

package/dist/fleet/fleet-bus.js

@@ -1,13 +1,10 @@
 import { EventEmitter } from "node:events";
-import { DURABLE_AGENT_HANDLE_RE, deriveAgentDisplayStatus, isDelegatedAgentTerminal, runParkedOf } from "@sema-agent/core";
+import { DURABLE_AGENT_HANDLE_RE, deriveAgentDisplayStatus, runParkedOf } from "@sema-agent/core";
 import { persistedPlaneOf } from "../terminal.js";
 import { takeWorkspaceSnapshotFailure } from "./workspace-snapshot-residual.js";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { redactSecrets } from "../trace/redact.js";
 import { buildRunObjectivePreview } from "../user-authored-text.js";
-export function isFleetAgentTerminalNotification(n) {
-    return isDelegatedAgentTerminal(n);
-}
 export function buildFleetWorkflowRow(id, run) {
     const agents = run.agents ?? [];
     const done = agents.filter((a) => a.status === "completed").length;
@@ -156,9 +153,9 @@ export class FleetEventBus {
     }
     bceClaims = new Map();
     static BCE_CLAIM_MAX = 4096;
-    static bceKey(scope, childUuid) { return `${scope ?? "default"}\u0000${childUuid}`; }
-    claimBackgroundChildLane(scope, childUuid, rowId) {
-        const k = FleetEventBus.bceKey(scope, childUuid);
+    static bceKey(scope, legName) { return `${scope ?? "default"}\u0000${legName}`; }
+    claimBackgroundChildLane(scope, legName, rowId) {
+        const k = FleetEventBus.bceKey(scope, legName);
         this.bceClaims.delete(k);
         this.bceClaims.set(k, rowId);
         if (this.bceClaims.size > FleetEventBus.BCE_CLAIM_MAX) {
@@ -167,28 +164,30 @@ export class FleetEventBus {
                 this.bceClaims.delete(oldest.value);
         }
     }
-    releaseBackgroundChildLane(scope, childUuid) {
-        this.bceClaims.delete(FleetEventBus.bceKey(scope, childUuid));
+    releaseBackgroundChildLane(scope, rowId) {
+        const prefix = FleetEventBus.bceKey(scope, "");
+        for (const [k, v] of this.bceClaims)
+            if (v === rowId && k.startsWith(prefix))
+                this.bceClaims.delete(k);
     }
-    backgroundChildLaneRow(scope, childUuid) {
-        return this.bceClaims.get(FleetEventBus.bceKey(scope, childUuid));
+    backgroundChildLaneRow(scope, legName) {
+        return this.bceClaims.get(FleetEventBus.bceKey(scope, legName));
     }
     taskRow(id) {
         return this.tasks.get(id);
     }
     childOwnerKeys(row) {
+        if (DURABLE_AGENT_HANDLE_RE.test(row.id))
+            return { handle: row.id, names: [row.id] };
         const sp = row.id.lastIndexOf(" ");
-        if (sp > 0) {
-            const sessionId = row.id.slice(sp + 1);
-            const claimed = this.bceClaims.get(FleetEventBus.bceKey(row.scope, sessionId));
-            return { sessionIds: [sessionId], ...(claimed !== undefined && DURABLE_AGENT_HANDLE_RE.test(claimed) ? { handle: claimed } : {}) };
-        }
+        if (sp > 0)
+            return { names: [row.id.slice(sp + 1)] };
         const prefix = FleetEventBus.bceKey(row.scope, "");
-        const sessionIds = [];
+        const names = [];
         for (const [k, rowId] of this.bceClaims)
             if (rowId === row.id && k.startsWith(prefix))
-                sessionIds.push(k.slice(prefix.length));
-        return { sessionIds, ...(DURABLE_AGENT_HANDLE_RE.test(row.id) ? { handle: row.id } : {}) };
+                names.push(k.slice(prefix.length));
+        return { names };
     }
     publishWorkflow(row) {
         this.workflows.set(row.id, row);
@@ -231,15 +230,15 @@ export class FleetEventBus {
 }
 export function fleetRunPublisher(bus, run) {
     if (!bus)
-        return { onStart: () => undefined, onEvent: () => undefined, onForwardEvent: () => undefined, onChildTerminal: () => false, onTerminal: () => undefined };
+        return { onStart: () => undefined, onEvent: () => undefined, onForwardEvent: () => undefined, onTerminal: () => undefined };
     let tokens = 0;
     const startedAt = Date.now();
     const sessionField = run.sessionId ? { sessionId: run.sessionId } : {};
     const children = new Set();
     const childStartedAt = new Map();
-    const childByToolCall = new Map();
     let settledLeg = false;
     const childId = (taskId) => `${run.runId} ${taskId}`;
+    const backgroundRowOf = (taskId) => (DURABLE_AGENT_HANDLE_RE.test(taskId) ? taskId : bus.backgroundChildLaneRow(run.scope, taskId));
     const tickStatus = (st) => (st === "completed" ? "completed" : st === "failed" ? "failed" : "running");
     const workflowRunIdField = (ev) => (ev.workflowRunId ? { workflowRunId: ev.workflowRunId } : {});
     const toolUsesOf = (usage) => {
@@ -247,15 +246,12 @@ export function fleetRunPublisher(bus, run) {
         return typeof t === "number" ? t : undefined;
     };
     const yieldToBackgroundChildLane = (childTaskId, cid, tickName) => {
-        const bceRowId = bus.backgroundChildLaneRow(run.scope, childTaskId);
+        const bceRowId = backgroundRowOf(childTaskId);
         if (bceRowId === undefined)
             return false;
         if (children.has(cid)) {
             bus.removeTask(cid);
             children.delete(cid);
-            for (const [k, v] of childByToolCall)
-                if (v === cid)
-                    childByToolCall.delete(k);
         }
         const row = bus.taskRow(bceRowId);
         if (row) {
@@ -303,8 +299,6 @@ export function fleetRunPublisher(bus, run) {
                 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);
                 bus.publishTask({ id: cid, sourceLane: "run-leg", ...(childName !== undefined ? { name: childName, agentType: childName } : {}), parentId: run.runId, scope: run.scope, ...sessionField, ...workflowRunIdField(ev), 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) {
@@ -320,43 +314,12 @@ export function fleetRunPublisher(bus, run) {
             if (yieldToBackgroundChildLane(ev.taskId, cid, ev.name))
                 return;
             children.add(cid);
-            const parentId = ev.parentTaskId && ev.parentTaskId !== run.rootTaskId ? childId(ev.parentTaskId) : run.runId;
+            const parentId = ev.parentTaskId && ev.parentTaskId !== run.rootTaskId ? (backgroundRowOf(ev.parentTaskId) ?? childId(ev.parentTaskId)) : run.runId;
             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, ...workflowRunIdField(ev), 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) {
-            if (settledLeg)
-                return false;
-            const fleetStatus = status === "completed" ? "completed" : status === "killed" || status === "cancelled" ? "killed" : "failed";
-            const candidateCids = [childId(taskId)];
-            if (altId !== undefined && altId !== taskId)
-                candidateCids.push(childId(altId));
-            const viaToolCall = toolUseId !== undefined ? childByToolCall.get(toolUseId) : undefined;
-            if (viaToolCall !== undefined && !candidateCids.includes(viaToolCall))
-                candidateCids.push(viaToolCall);
-            const liveCids = candidateCids.filter((c) => children.has(c));
-            const hadRow = liveCids.length > 0;
-            if (!hadRow) {
-                const claimed = [taskId, altId].some((t) => t !== undefined && bus.backgroundChildLaneRow(run.scope, t) !== undefined);
-                if (claimed)
-                    return true;
-            }
-            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 } : {}) });
-                bus.removeTask(cid);
-                children.delete(cid);
-                childStartedAt.delete(cid);
-                for (const [k, v] of childByToolCall)
-                    if (v === cid)
-                        childByToolCall.delete(k);
-            }
-            return hadRow;
-        },
         onTerminal(status, residuals) {
             settledLeg = true;
             const fleetStatus = runStatusToFleet(status);
@@ -374,7 +337,6 @@ export function fleetRunPublisher(bus, run) {
                 bus.removeTask(cid);
             children.clear();
             childStartedAt.clear();
-            childByToolCall.clear();
             if (terminal) {
                 bus.removeTask(run.runId);
             }
@@ -433,11 +395,13 @@ export function fleetBackgroundChildPublisher(bus, log) {
             }
         }
     };
-    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);
+    const joinWorkflowAgentNames = (e, m) => {
+        if (DURABLE_AGENT_HANDLE_RE.test(e.taskId))
+            return;
+        if (e.sessionId)
+            bus.claimBackgroundChildLane(m.tenantScope, e.sessionId, e.taskId);
+        if (e.kind === "tick" && e.progressTaskId && e.progressParentTaskId === m.parentTaskId)
+            bus.claimBackgroundChildLane(m.tenantScope, e.progressTaskId, e.taskId);
     };
     const resolveParentId = (parentInput, domain, childScope) => {
         const rows = bus.snapshot().tasks;
@@ -445,12 +409,9 @@ export function fleetBackgroundChildPublisher(bus, log) {
             if (rows.some((r) => r.id === parentInput && r.scope === childScope))
                 return { id: parentInput, resolved: true };
         }
-        for (const [aStar, pm] of meta) {
-            if (pm.aliasUuid === parentInput && pm.tenantScope === childScope) {
-                if (rows.some((r) => r.id === aStar && r.scope === childScope))
-                    return { id: aStar, resolved: true };
-            }
-        }
+        const joined = bus.backgroundChildLaneRow(childScope, parentInput);
+        if (joined !== undefined && rows.some((r) => r.id === joined && r.scope === childScope))
+            return { id: joined, resolved: true };
         let match;
         for (const r of rows) {
             if (r.sessionId === parentInput && r.parentId === undefined && r.scope === childScope && !meta.has(r.id))
@@ -506,7 +467,6 @@ export function fleetBackgroundChildPublisher(bus, log) {
             ...(e.startedAt !== undefined ? { spawnedAt: e.startedAt } : {}),
             ...(e.rootSessionId ? { rootSessionId: e.rootSessionId } : {}),
             ...(e.parentToolCallId ? { parentToolCallId: e.parentToolCallId } : {}),
-            ...(e.sessionId ? { aliasUuid: e.sessionId } : {}),
             ...(e.workflowRunId ? { workflowRunId: e.workflowRunId } : {}),
             ...(e.workflowRunId && !(e.sessionScoped && e.owner)
                 ? (e.rootSessionId ? { hostSessionId: e.rootSessionId } : {})
@@ -516,29 +476,13 @@ export function fleetBackgroundChildPublisher(bus, log) {
                 : {}),
         };
         remember(e.taskId, m);
-        claimIfKnown(e, m);
+        joinWorkflowAgentNames(e, m);
         const displayName = e.description ?? e.name;
         bus.publishTask({ id: e.taskId, ...(displayName !== undefined ? { name: redactSecrets(displayName) } : {}), ...(e.agentType ? { agentType: redactSecrets(e.agentType) } : {}), ...(e.spawnName ? { agentName: e.spawnName } : {}), ...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) => {
-        claimIfKnown(e, m);
-        if (!m.suppressedTwin && e.progressTaskId && (!e.progressParentTaskId || e.progressParentTaskId === (m.parentTaskId ?? m.parentSessionLink))) {
-            const tail = ` ${e.progressTaskId}`;
-            for (const row of bus.snapshot().tasks) {
-                if (row.id.endsWith(tail))
-                    bus.removeTask(row.id);
-            }
-            m.suppressedTwin = true;
-        }
-        if (m.aliasUuid === undefined && e.progressTaskId && (!e.progressParentTaskId || e.progressParentTaskId === (m.parentTaskId ?? m.parentSessionLink))) {
-            m.aliasUuid = e.progressTaskId;
-            for (const [cid, cm] of meta) {
-                if ((cm.parentTaskId ?? cm.parentSessionLink) === m.aliasUuid && cm.resolvedParentId === undefined && !cm.done) {
-                    bus.publishTask({ id: cid, ...rowTags(cm) });
-                }
-            }
-        }
+        joinWorkflowAgentNames(e, m);
         const tokens = sumUsage(e.usage);
         const name = e.name ? redactSecrets(e.name) : undefined;
         const agentType = e.agentType ? redactSecrets(e.agentType) : undefined;
@@ -573,15 +517,7 @@ export function fleetBackgroundChildPublisher(bus, log) {
                 : {}),
         });
         bus.removeTask(e.taskId);
-        if (m.aliasUuid)
-            bus.releaseBackgroundChildLane(m.tenantScope, m.aliasUuid);
-        if (m.aliasUuid) {
-            const tail = ` ${m.aliasUuid}`;
-            for (const row of bus.snapshot().tasks) {
-                if (row.id.endsWith(tail))
-                    bus.removeTask(row.id);
-            }
-        }
+        bus.releaseBackgroundChildLane(m.tenantScope, e.taskId);
         if (m.workflowRunId !== undefined) {
             m.done = true;
             dlog("bg_child_event", { kind: "terminal-wa-no-notification", taskId: e.taskId, workflowRunId: m.workflowRunId });
@@ -623,7 +559,6 @@ export function fleetBackgroundChildPublisher(bus, log) {
         });
         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;
-        m.suppressedTwin = true;
     };
     return (e) => {
         if (e.kind === "spawn") {

package/dist/fleet/fleet-reconciler.d.ts

@@ -3,7 +3,7 @@
  *
  * ## 它修什么(§0 病灶机制链)
  * fleet 总线是进程内纯内存聚合(`fleet-bus.ts` 头注自陈 NOT durable / NOT cross-replica),行的**唯一**
- * 离场路径是发布方主动打 `onTerminal`/`onChildTerminal`。发布方没走到终态臂(run 事件环异常中断、引擎
+ * 离场路径是发布方主动打终态臂(run-leg 的 `onTerminal`、BCE 车道的子代终局)。发布方没走到终态臂(run 事件环异常中断、引擎
  * 被壳 reuse 而旧 run 对象已死、BCE 终态通知丢失),行就**永久僵在** `tasks` Map 里 —— 此后每个订阅方
  * (含 snapshot 新连接)看到一条永远 "running" 的幽灵行。壳侧只能靠 overlay 防御(cli 1.0.74 过渡件)。
  *
@@ -147,10 +147,10 @@ export interface FleetReconcilerDeps {
     agents?: FleetReconcileAgentPort;
     /**
      * [ref]:子代活性的属主②:这只子代此刻有没有**待决**审批卡。只问是非(与 {@link isLiveOnThisReplica} 同姿势,
-     * 不搬 Map)。入参是 ask 发起者域(子代自己的 core session id,= 卡上的 `originTaskId`),**不是**行 id ——
-     * 行 id → 该域的换算只在 `FleetEventBus.childOwnerKeys`。生产 = `ToolApprovalCoordinator.hasLivePendingFrom`。
+     * 不搬 Map)。入参是这一行那条腿的名字,**不总是**行 id(前台子代 = 会话 id;`wa*` = 会话 id 与脚本声明的腿 task id)——
+     * 行 id → 名字的换算只在 `FleetEventBus.childOwnerKeys`。生产 = `ToolApprovalCoordinator.hasLivePendingFromLeg`。
      */
-    hasPendingAsk?: (originTaskId: string) => boolean;
+    hasPendingAsk?: (names: readonly string[]) => boolean;
     /** 本副本 id(与 `RunRecord.instanceId` 同域)。只进日志/读数 —— 两条 `running` 臂的**处置相同**
      *  (都是陈述级退场),分不分得出 claim 属谁不改变行为,故它不是判据。 */
     instanceId?: string;

package/dist/fleet/fleet-reconciler.js

@@ -146,7 +146,7 @@ export function createFleetReconciler(deps) {
                 }
             }
             const hasPendingAsk = deps.hasPendingAsk;
-            if (hasPendingAsk !== undefined && deps.bus.childOwnerKeys(row).sessionIds.some((id) => hasPendingAsk(id))) {
+            if (hasPendingAsk !== undefined && hasPendingAsk(deps.bus.childOwnerKeys(row).names)) {
                 keptAlive(row, "pending_ask");
                 return "settled";
             }

package/dist/fleet/subagent-tail-bus.d.ts

@@ -6,10 +6,9 @@
 export type SubagentTailFrame = Record<string, unknown> & {
     type: string;
 };
-/** core forward 事件 → wire 投影(sync 主流五分支同源;不认识的帧类型=null 不发——tail 面只承诺
- *  content 六类,新 core 帧类型先经这里显式收编再出 wire)。
- *  ⚠️ **本函数是无状态逐帧投影**:`reasoning_end`([ref] 的推理权威段)不在这里 —— 它要按句柄攒段,
- *  住在 {@link SubagentTailBus.onForwardFrame}(publish 侧是唯一知道句柄的地方)。 */
+/** core forward 事件 → wire 投影(sync 主流同源;不认识的帧类型=null 不发——新 core 帧类型先经这里显式收编再出 wire)。
+ *  ⚠️ **本函数是无状态逐帧投影**:模型文本(`text_delta` / `reasoning_delta` / `text_end` 与段界上的 `reasoning_end`)不在这里 ——
+ *  它们要按句柄攒段、经同一只脱敏器放行,住在 {@link SubagentTailBus.onForwardFrame} 的登记册里(publish 侧是唯一知道句柄的地方);本函数对它们答 null。 */
 export declare function projectTailFrame(e: Record<string, unknown> & {
     type?: string;
 }): SubagentTailFrame | null;
@@ -53,16 +52,20 @@ export declare class SubagentTailBus {
      */
     private readonly modeByHandle;
     /**
-     * 句柄 → 该句柄这条 tail 流上**在攒的推理段**([ref])。
+     * 句柄 → 该句柄这条 tail 流的**模型文本登记册**(`trace/model-segment.ts` 的 `createLiveModelText`:按流身份分账攒段、经同一只脱敏器放行)。
      *
-     * 键必须是句柄,理由与 {@link modeByHandle} 同源再加一条硬的:两个并发子代的 `reasoning_delta` 在
-     * **同一个** forward sink 上交错到达,一只累积器会把两份思考拼成一段、再盖上其中一个的身份键。
+     * 键必须是句柄,理由与 {@link modeByHandle} 同源再加一条硬的:两个并发子代的逐块帧在**同一个** forward sink 上交错到达,
+     * 一只累积器会把两份文字拼成一段、再盖上其中一个的身份键(登记册内部再按流身份分账)。
      *
-     * 生命期 = **有人在听的那段时间**:攒段住在 `hasSubscribers` 快门之内(tail 是 live-only 面,没人听
-     * 就不投影也不攒),最后一个订阅者走掉或句柄终态({@link forgetHandle})时整条删掉 ⇒ 本表恒被
-     * 订阅者数量所界,不需要第二道容量闸。
+     * 🔴 **生命期 = 句柄活着的那段时间,不是有人在听的那段时间**:没人听时登记册照样攒原文、照样按段界收段(只是不扫描、不出帧 —— 免投影快门仍在),
+     * 订阅者半路进来,放行位从**此刻**起,而判定仍按**整段**的上下文:否则一个在 `password=` 之后才开始听的订阅者拿到的是一段没有锚的值,认不出、原样出门
+     * (同一段在 `done` / 账本上早已遮掉)。
+     * 🔴 **条目只活在开着的段上,没有容量逐出**:一条段的上下文只被**它自己的**段界 / 终态收走(登记册分账律的同一句,`trace/model-segment.ts`)——
+     * 按容量逐出一只开着的登记册 = 别的句柄替它收了段,它的下一块从一段没有锚的新文本算起、值原样出门(对抗复审 r1 high:4096 只只报进度的句柄就够)。
+     * 所以:段全收了(登记册空着,与新建的一只等价)就删条目;只报进度、从没开过段的句柄不留条目。条目数 = 此刻有开着的模型文本段的句柄数,
+     * 每条的量 = 那几段到此刻的原文 —— 在途的模型输出本身;句柄终态({@link forgetHandle})收段并删。
      */
-    private readonly segByHandle;
+    private readonly textByHandle;
     /** 三条 run 腿的 forward 回调里逐帧调(在 `hasSubscribers` 快门**之前**——没人在听时也要学,
      *  否则晚开的 tail 永远读不到供给形)。同值重复写是 no-op(热路径只付一次 Map.get)。 */
     noteHandleContentMode(bgAgentId: string, mode: TailContentMode): void;

package/dist/fleet/subagent-tail-bus.js

@@ -1,7 +1,6 @@
-import { redactSecrets } from "../trace/redact.js";
-import { taskProgressEventData, taskStartedEventData, toolStartEventData, toolEndEventData, textEndEventData } from "../trace/project.js";
+import { taskProgressEventData, taskStartedEventData, toolStartEventData, toolEndEventData } from "../trace/project.js";
 import { liveMediaBytesOf, liveToolEndForBacklog } from "../trace/tool-output-media.js";
-import { createReasoningSegments } from "../trace/model-segment.js";
+import { createLiveModelText } from "../trace/model-segment.js";
 const TAIL_QUEUE_CAP = 512;
 export function projectTailFrame(e) {
     const t = e.type;
@@ -19,18 +18,6 @@ export function projectTailFrame(e) {
         const te = e;
         return { type: "tool_end", ...toolEndEventData(te) };
     }
-    if (t === "text_delta") {
-        const td = e;
-        return { type: "text_delta", delta: td.delta, ...(td.eventId ? { eventId: td.eventId } : {}), ...(td.parentToolCallId ? { parentToolCallId: td.parentToolCallId } : {}) };
-    }
-    if (t === "text_end") {
-        const f = textEndEventData(e);
-        return f === null ? null : { type: "text_end", ...f };
-    }
-    if (t === "reasoning_delta") {
-        const rd = e;
-        return { type: "reasoning_delta", delta: redactSecrets(rd.delta), ...(rd.eventId ? { eventId: rd.eventId } : {}), ...(rd.parentToolCallId ? { parentToolCallId: rd.parentToolCallId } : {}) };
-    }
     return null;
 }
 function putBounded(map, key, value) {
@@ -46,7 +33,7 @@ const HOST_MODE_CAP = 4096;
 export class SubagentTailBus {
     subs = new Map();
     modeByHandle = new Map();
-    segByHandle = new Map();
+    textByHandle = new Map();
     noteHandleContentMode(bgAgentId, mode) {
         if (this.modeByHandle.get(bgAgentId) === mode)
             return;
@@ -54,23 +41,24 @@ export class SubagentTailBus {
     }
     onForwardFrame(bgAgentId, mode, e) {
         this.noteHandleContentMode(bgAgentId, mode);
-        if (!this.hasSubscribers(bgAgentId))
+        const deliver = this.hasSubscribers(bgAgentId);
+        const text = this.textByHandle.get(bgAgentId) ?? createLiveModelText();
+        for (const f of text.onEvent(e, deliver))
+            this.publish(bgAgentId, f);
+        if (text.isIdle())
+            this.textByHandle.delete(bgAgentId);
+        else
+            this.textByHandle.set(bgAgentId, text);
+        if (!deliver)
             return;
-        let segs = this.segByHandle.get(bgAgentId);
-        if (segs === undefined) {
-            segs = createReasoningSegments();
-            this.segByHandle.set(bgAgentId, segs);
-        }
-        for (const end of segs.onEvent(e))
-            this.publish(bgAgentId, end);
         const f = projectTailFrame(e);
         if (f)
             this.publish(bgAgentId, f);
     }
     forgetHandle(bgAgentId) {
-        for (const end of this.segByHandle.get(bgAgentId)?.cut() ?? [])
-            this.publish(bgAgentId, end);
-        this.segByHandle.delete(bgAgentId);
+        for (const f of this.textByHandle.get(bgAgentId)?.cut(undefined, this.hasSubscribers(bgAgentId)) ?? [])
+            this.publish(bgAgentId, f);
+        this.textByHandle.delete(bgAgentId);
         this.modeByHandle.delete(bgAgentId);
     }
     handleContentMode(bgAgentId) {
@@ -114,7 +102,6 @@ export class SubagentTailBus {
             set.delete(sub);
             if (set.size === 0 && this.subs.get(bgAgentId) === set) {
                 this.subs.delete(bgAgentId);
-                this.segByHandle.delete(bgAgentId);
             }
         };
         const it = {