@pellux/goodvibes-sdk 0.38.0 → 1.1.0

package/dist/platform/runtime/fleet/adapters/orchestration.js

@@ -1,5 +1,77 @@
 /** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+/**
+ * Orchestration-engine fleet adapters — Workstream/Phase/
+ * WorkItem -> ProcessNode, mirroring adapters/wrfc.ts's chain/subtask
+ * pattern: a workstream is a root node (no native cancel of its own, so kill
+ * is DERIVED — cascades AgentManager.cancel over every agent any item ever
+ * spawned, same shape as adaptChain/cancelAgents), a phase is a pure grouping
+ * node (no lifecycle, no usage — same "report nothing" choice adaptSubtask
+ * makes, since attributing a work-item's CUMULATIVE usage to whichever phase
+ * it currently sits in would double-count across phases), and a work-item is
+ * the WRFC-subtask analogue: it delegates interrupt/kill/steer to its
+ * current live agent when it has one.
+ */
+import { mergeWorkItemUsage } from '../../../orchestration/types.js';
 import { workItemNodeId } from './agent.js';
+/** True once a ProcessUsage carries any non-zero count worth surfacing. */
+function hasAnyUsage(u) {
+    return u !== undefined && (u.inputTokens > 0 || u.outputTokens > 0 || u.cacheReadTokens > 0 || u.cacheWriteTokens > 0
+        || u.llmCallCount > 0 || u.turnCount > 0 || u.toolCallCount > 0);
+}
+/**
+ * True when a committed WorkItemUsage carries no real data yet (the untouched
+ * emptyWorkItemUsage placeholder — zero counts, unpriced, no cost). Such a
+ * placeholder must NOT be folded into a live overlay: merging an 'unpriced'
+ * zero into a priced overlay would honestly-but-uselessly degrade the result to
+ * 'estimated' and drop it from the priced cost rollup (aggregateWorkItemCost),
+ * re-introducing the very n/a this overlay removes. When committed is empty the
+ * overlay stands alone.
+ */
+function isEmptyCommittedUsage(u) {
+    return u.costUsd === null && !hasAnyUsage(u);
+}
+/** Convert a live overlay into WorkItemUsage shape, or undefined when it carries nothing real yet. */
+function liveOverlayUsage(live) {
+    if (!live)
+        return undefined;
+    const u = live.usage;
+    const hasCost = live.costUsd !== undefined && live.costUsd !== null;
+    if (!hasAnyUsage(u) && !hasCost)
+        return undefined;
+    return {
+        inputTokens: u?.inputTokens ?? 0,
+        outputTokens: u?.outputTokens ?? 0,
+        cacheReadTokens: u?.cacheReadTokens ?? 0,
+        cacheWriteTokens: u?.cacheWriteTokens ?? 0,
+        reasoningTokens: u?.reasoningTokens,
+        llmCallCount: u?.llmCallCount ?? 0,
+        turnCount: u?.turnCount ?? 0,
+        toolCallCount: u?.toolCallCount ?? 0,
+        costUsd: live.costUsd ?? null,
+        costState: live.costState ?? (hasCost ? 'priced' : 'unpriced'),
+    };
+}
+/**
+ * The usage the fleet DISPLAYS for a work-item: its committed phase-boundary
+ * total, plus — only while it is actively 'in-phase' — the live in-flight
+ * usage of its current agent. The overlay is applied ONLY for an 'in-phase'
+ * item, which is exactly the window in which `item.usage` does NOT yet include
+ * the running phase (the engine folds that in at completion — see
+ * runItemPhase), so committed + live never double-counts and the two hand off
+ * atomically at the phase boundary. Because both operands only ever grow and
+ * merge through {@link mergeWorkItemUsage}, presence is MONOTONE: once usage
+ * has appeared for an item it never blinks back to n/a (DEBT-4 item 2).
+ */
+export function displayWorkItemUsage(item, live) {
+    const overlay = item.state === 'in-phase' ? liveOverlayUsage(live) : undefined;
+    if (!overlay)
+        return item.usage;
+    // First-phase window: no committed usage yet, so the live overlay is the
+    // whole truth — don't let the empty 'unpriced' placeholder degrade it.
+    if (isEmptyCommittedUsage(item.usage))
+        return overlay;
+    return mergeWorkItemUsage(item.usage, overlay);
+}
 /** Workstream node ids are namespaced to avoid colliding with agent/process ids. */
 export function workstreamNodeId(workstreamId) {
     return `workstream:${workstreamId}`;
@@ -37,6 +109,14 @@ function workItemState(item) {
             // reconsideration is automatic the instant the ceiling changes, but a
             // fixed ceiling on its own never lifts the block (usage only grows).
             return 'stalled';
+        case 'blocked-dependency':
+            // Same "stuck, not progressing" signal as blocked-budget, for the same
+            // reason (BIG-3 item 2): the item is out of the claimable set until every
+            // dependency reaches 'passed'. Distinct from 'queued' (which WILL be
+            // claimed by free capacity) — a dependency-blocked item waits on other
+            // items, or on engine.retryItem reviving a failed dependency. blockedReason
+            // carries the honest 'waiting on: …' / 'dependency failed: …' detail.
+            return 'stalled';
         case 'in-phase':
             return 'executing-tool';
     }
@@ -48,7 +128,7 @@ function workstreamState(workstream) {
         return 'executing-tool';
     if (workstream.items.some((item) => item.state === 'pending' || item.state === 'awaiting-capacity'))
         return 'queued';
-    if (workstream.items.some((item) => item.state === 'blocked-budget'))
+    if (workstream.items.some((item) => item.state === 'blocked-budget' || item.state === 'blocked-dependency'))
         return 'stalled';
     return workstream.items.some((item) => item.state === 'failed') ? 'failed' : 'done';
 }
@@ -62,9 +142,15 @@ function phaseState(workstream, phase) {
     const allTerminal = workstream.items.every((item) => TERMINAL_ITEM_STATES.has(item.state));
     return allTerminal ? 'done' : 'idle';
 }
-/** token-count-only rollup over a workstream's items (cost handled separately — see aggregateWorkItemCost). */
-function sumWorkItemUsage(items) {
-    if (items.length === 0)
+/**
+ * token-count-only rollup over a workstream's per-item DISPLAY usages (cost
+ * handled separately — see aggregateWorkItemCost). Takes resolved display
+ * usages (committed + any live overlay) rather than raw items so the workstream
+ * total reflects live in-flight work, not just phase-boundary snapshots
+ * (DEBT-4 item 2).
+ */
+function sumWorkItemUsage(usages) {
+    if (usages.length === 0)
         return undefined;
     const total = {
         inputTokens: 0,
@@ -77,8 +163,7 @@ function sumWorkItemUsage(items) {
         toolCallCount: 0,
     };
     let sawReasoning = false;
-    for (const item of items) {
-        const usage = item.usage;
+    for (const usage of usages) {
         total.inputTokens += usage.inputTokens;
         total.outputTokens += usage.outputTokens;
         total.cacheReadTokens += usage.cacheReadTokens;
@@ -102,22 +187,29 @@ function sumWorkItemUsage(items) {
         toolCallCount: total.toolCallCount,
     };
 }
-/** Honest cost rollup: all-priced -> 'priced'; none -> null/'unpriced'; mixed -> summed subset, 'estimated'. Mirrors adapters/wrfc.ts aggregateCost. */
-function aggregateWorkItemCost(items) {
-    const withUsage = items.filter((item) => item.usage.costState !== 'unpriced' || item.usage.inputTokens > 0 || item.usage.outputTokens > 0);
+/** Honest cost rollup: all-priced -> 'priced'; none -> null/'unpriced'; mixed -> summed subset, 'estimated'. Mirrors adapters/wrfc.ts aggregateCost. Operates on resolved display usages (committed + live overlay). */
+function aggregateWorkItemCost(usages) {
+    const withUsage = usages.filter((usage) => usage.costState !== 'unpriced' || usage.inputTokens > 0 || usage.outputTokens > 0);
     if (withUsage.length === 0)
         return { costUsd: null, costState: 'unpriced' };
-    const priced = withUsage.filter((item) => item.usage.costState === 'priced' && item.usage.costUsd !== null);
+    const priced = withUsage.filter((usage) => usage.costState === 'priced' && usage.costUsd !== null);
     if (priced.length === 0)
         return { costUsd: null, costState: 'unpriced' };
-    const total = priced.reduce((sum, item) => sum + item.usage.costUsd, 0);
+    const total = priced.reduce((sum, usage) => sum + usage.costUsd, 0);
     return { costUsd: total, costState: priced.length === withUsage.length ? 'priced' : 'estimated' };
 }
-/** WorkItem -> ProcessNode. Delegates interruptible/killable/steerable to its currently-active agent, mirroring adaptSubtask. */
+/**
+ * WorkItem -> ProcessNode. Delegates interruptible/killable/steerable to its
+ * currently-active agent, mirroring adaptSubtask. `opts.live` supplies the
+ * currently-active agent's in-flight usage so a running phase shows real,
+ * growing numbers instead of n/a until it completes (DEBT-4 item 2); omit it
+ * (or pass undefined) for the committed-only view.
+ */
 export function adaptWorkItem(item, workstreamId, parentId, opts) {
     const state = workItemState(item);
     const killable = !TERMINAL_ITEM_STATES.has(item.state);
     const activeAgentId = activeWorkItemAgentId(item);
+    const usage = displayWorkItemUsage(item, opts.live);
     return {
         id: workItemNodeId(item.id),
         kind: 'work-item',
@@ -128,26 +220,33 @@ export function adaptWorkItem(item, workstreamId, parentId, opts) {
         startedAt: item.createdAt,
         completedAt: item.completedAt,
         elapsedMs: Math.max(0, (item.completedAt ?? Date.now()) - item.createdAt),
-        usage: item.usage.inputTokens > 0 || item.usage.outputTokens > 0
+        usage: usage.inputTokens > 0 || usage.outputTokens > 0
             ? {
-                inputTokens: item.usage.inputTokens,
-                outputTokens: item.usage.outputTokens,
-                cacheReadTokens: item.usage.cacheReadTokens,
-                cacheWriteTokens: item.usage.cacheWriteTokens,
-                reasoningTokens: item.usage.reasoningTokens,
-                llmCallCount: item.usage.llmCallCount,
-                turnCount: item.usage.turnCount,
-                toolCallCount: item.usage.toolCallCount,
+                inputTokens: usage.inputTokens,
+                outputTokens: usage.outputTokens,
+                cacheReadTokens: usage.cacheReadTokens,
+                cacheWriteTokens: usage.cacheWriteTokens,
+                reasoningTokens: usage.reasoningTokens,
+                llmCallCount: usage.llmCallCount,
+                turnCount: usage.turnCount,
+                toolCallCount: usage.toolCallCount,
             }
             : undefined,
-        costUsd: item.usage.costUsd,
-        costState: item.usage.costState,
-        // Blocked-budget items surface their reason (set/cleared by the engine
-        // alongside the state transition, types.ts WorkItem.blockedReason) in
-        // place of the bare phase id — the phase id alone doesn't tell an
-        // operator WHY the item stopped moving.
+        costUsd: usage.costUsd,
+        costState: usage.costState,
+        // Blocked items surface their reason (set/cleared by the engine alongside
+        // the state transition, types.ts WorkItem.blockedReason) in place of the
+        // bare phase id — the phase id alone doesn't tell an operator WHY the item
+        // stopped moving. Covers both budget blocks and dependency blocks (BIG-3
+        // item 2: 'waiting on: …' / 'dependency failed: …').
         currentActivity: item.currentPhaseId
-            ? { kind: 'phase', text: item.state === 'blocked-budget' && item.blockedReason ? item.blockedReason : item.currentPhaseId, at: item.createdAt }
+            ? {
+                kind: 'phase',
+                text: (item.state === 'blocked-budget' || item.state === 'blocked-dependency') && item.blockedReason
+                    ? item.blockedReason
+                    : item.currentPhaseId,
+                at: item.createdAt,
+            }
             : undefined,
         capabilities: {
             interruptible: activeAgentId !== undefined,
@@ -190,17 +289,22 @@ export function adaptPhase(phase, workstream) {
     };
 }
 /**
- * Workstream -> ProcessNode. Root node (no parentId). Sums every item's
- * usage/cost exactly once (never through an intermediate phase bucket — see
- * adaptPhase) so this total can never double-count.
+ * Workstream -> ProcessNode. Root node (no parentId). Sums every item's DISPLAY
+ * usage/cost (committed total + any live in-flight overlay, resolved once per
+ * item) exactly once — never through an intermediate phase bucket (see
+ * adaptPhase) — so this total can never double-count and never shows n/a while
+ * an item is actively producing usage (DEBT-4 item 2). `liveByItemId` supplies
+ * the active agents' in-flight usage keyed by item id; omit it for the
+ * committed-only view.
  */
-export function adaptWorkstream(workstream, now) {
+export function adaptWorkstream(workstream, now, liveByItemId) {
     const state = workstreamState(workstream);
     const killable = state !== 'done' && state !== 'failed';
     const completedAt = (state === 'done' || state === 'failed')
         ? workstream.items.reduce((latest, item) => (item.completedAt !== undefined && (latest === undefined || item.completedAt > latest) ? item.completedAt : latest), undefined)
         : undefined;
-    const { costUsd, costState } = aggregateWorkItemCost(workstream.items);
+    const displayUsages = workstream.items.map((item) => displayWorkItemUsage(item, liveByItemId?.get(item.id)));
+    const { costUsd, costState } = aggregateWorkItemCost(displayUsages);
     return {
         id: workstreamNodeId(workstream.id),
         kind: 'workstream',
@@ -210,7 +314,7 @@ export function adaptWorkstream(workstream, now) {
         startedAt: workstream.createdAt,
         completedAt,
         elapsedMs: Math.max(0, (completedAt ?? now) - workstream.createdAt),
-        usage: sumWorkItemUsage(workstream.items),
+        usage: sumWorkItemUsage(displayUsages),
         costUsd,
         costState,
         currentActivity: undefined,

package/dist/platform/runtime/fleet/adapters/schedule.d.ts

@@ -5,10 +5,10 @@ import type { ProcessNode } from '../types.js';
 export declare function scheduleNodeId(name: string): string;
 /**
  * ScheduleEntry → ProcessNode. A schedule between runs is honestly 'idle'
- * (not force-fit into an active state); disabled maps to 'paused' (Wave 6,
- * wo-F item d2 — NOT 'killed': the entry still exists and ScheduleManager.
- * enable() can re-arm it, so collapsing it into a terminal state was
- * dishonest). resumable mirrors the inverse of pausable.
+ * (not force-fit into an active state); disabled maps to 'paused' (NOT
+ * 'killed': the entry still exists and ScheduleManager.enable() can re-arm
+ * it, so collapsing it into a terminal state was dishonest). resumable
+ * mirrors the inverse of pausable.
  */
 export declare function adaptSchedule(entry: ScheduleEntry): ProcessNode;
 //# sourceMappingURL=schedule.d.ts.map

package/dist/platform/runtime/fleet/adapters/schedule.js

@@ -5,10 +5,10 @@ export function scheduleNodeId(name) {
 }
 /**
  * ScheduleEntry → ProcessNode. A schedule between runs is honestly 'idle'
- * (not force-fit into an active state); disabled maps to 'paused' (Wave 6,
- * wo-F item d2 — NOT 'killed': the entry still exists and ScheduleManager.
- * enable() can re-arm it, so collapsing it into a terminal state was
- * dishonest). resumable mirrors the inverse of pausable.
+ * (not force-fit into an active state); disabled maps to 'paused' (NOT
+ * 'killed': the entry still exists and ScheduleManager.enable() can re-arm
+ * it, so collapsing it into a terminal state was dishonest). resumable
+ * mirrors the inverse of pausable.
  */
 export function adaptSchedule(entry) {
     return {

package/dist/platform/runtime/fleet/adapters/trigger.d.ts

@@ -3,10 +3,9 @@ import type { TriggerDefinition } from '../../../tools/workflow/index.js';
 import type { ProcessNode } from '../types.js';
 /**
  * TriggerDefinition → ProcessNode. Triggers have no timestamps and no run
- * state — enabled means armed ('idle'), disabled maps to 'paused' (Wave 6,
- * wo-F item d2 — NOT 'killed': the definition still exists and
- * TriggerManager.enable() can re-arm it). resumable mirrors the inverse of
- * pausable.
+ * state — enabled means armed ('idle'), disabled maps to 'paused' (NOT
+ * 'killed': the definition still exists and TriggerManager.enable() can
+ * re-arm it). resumable mirrors the inverse of pausable.
  */
 export declare function adaptTrigger(def: TriggerDefinition): ProcessNode;
 //# sourceMappingURL=trigger.d.ts.map

package/dist/platform/runtime/fleet/adapters/trigger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trigger.d.ts","sourceRoot":"","sources":["../../../../../src/platform/runtime/fleet/adapters/trigger.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,iBAAiB,GAAG,WAAW,CAahE"}
+{"version":3,"file":"trigger.d.ts","sourceRoot":"","sources":["../../../../../src/platform/runtime/fleet/adapters/trigger.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,iBAAiB,GAAG,WAAW,CAahE"}

package/dist/platform/runtime/fleet/adapters/trigger.js

@@ -1,10 +1,9 @@
 /** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
 /**
  * TriggerDefinition → ProcessNode. Triggers have no timestamps and no run
- * state — enabled means armed ('idle'), disabled maps to 'paused' (Wave 6,
- * wo-F item d2 — NOT 'killed': the definition still exists and
- * TriggerManager.enable() can re-arm it). resumable mirrors the inverse of
- * pausable.
+ * state — enabled means armed ('idle'), disabled maps to 'paused' (NOT
+ * 'killed': the definition still exists and TriggerManager.enable() can
+ * re-arm it). resumable mirrors the inverse of pausable.
  */
 export function adaptTrigger(def) {
     return {

package/dist/platform/runtime/fleet/adapters/wrfc.d.ts

@@ -1,6 +1,19 @@
 /** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
 import type { WrfcChain, WrfcSubtask } from '../../../agents/wrfc-types.js';
 import type { ProcessNode } from '../types.js';
+/**
+ * Reprice a WRFC owner agent node for honest DISPLAY. The owner runs no LLM turn
+ * itself; at completion its usage is backfilled from aggregateChainUsage — a
+ * mixed-model rollup of its children — so pricing it with a single owner model is
+ * wrong and leaving it "unpriced" while its children priced fine is misleading.
+ * Instead adopt the chain node's per-child-summed cost (and its model descriptor).
+ *
+ * Returns the SAME node reference when no reprice applies (owner already priced, or
+ * the chain has no priced cost), so callers can skip untouched nodes. The owner is
+ * excluded from every leaf-sum (registry aggregateCost / isWrfcOwnerAgentNode), so
+ * adopting the chain total here can never double-count.
+ */
+export declare function repriceWrfcOwnerNode(ownerNode: ProcessNode, chainNode: ProcessNode): ProcessNode;
 /**
  * The subtask's currently-active member agent, i.e. whichever role is
  * driving its current phase. Undefined when the subtask has no phase

package/dist/platform/runtime/fleet/adapters/wrfc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wrfc.d.ts","sourceRoot":"","sources":["../../../../../src/platform/runtime/fleet/adapters/wrfc.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,KAAK,EAAE,WAAW,EAA8B,MAAM,aAAa,CAAC;AAmJ3E;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CAWnF;AAED,2DAA2D;AAC3D,wBAAgB,YAAY,CAAC,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE;IAAE,SAAS,EAAE,OAAO,CAAA;CAAE,GAAG,WAAW,CAwB9G;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,WAAW,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW,CAgC1G"}
+{"version":3,"file":"wrfc.d.ts","sourceRoot":"","sources":["../../../../../src/platform/runtime/fleet/adapters/wrfc.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,KAAK,EAAE,WAAW,EAA8B,MAAM,aAAa,CAAC;AAuK3E;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,GAAG,WAAW,CAShG;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CAWnF;AAED,2DAA2D;AAC3D,wBAAgB,YAAY,CAAC,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE;IAAE,SAAS,EAAE,OAAO,CAAA;CAAE,GAAG,WAAW,CAwB9G;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,WAAW,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW,CAiC1G"}

package/dist/platform/runtime/fleet/adapters/wrfc.js

@@ -11,7 +11,11 @@ function chainState(chain, memberNodes) {
         case 'passed':
             return { state: 'done' };
         case 'failed':
-            return { state: 'failed' };
+            // An operator-cancelled chain is terminal-'failed' internally but must read
+            // as cancelled, not a failure — map it to 'killed' (⊘) so the chain row and
+            // the cohort tally match the cancelled owner/leaf agents instead of showing
+            // '✗ failed' for an intended stop.
+            return chain.failureKind === 'cancelled' ? { state: 'killed' } : { state: 'failed' };
         case 'pending':
             return { state: 'queued' };
         case 'awaiting_gates':
@@ -131,7 +135,7 @@ function sumUsage(nodes) {
  *
  * The owner agent is EXCLUDED from aggregation: it runs no LLM turns itself —
  * its AgentRecord.usage is populated FROM the phase children at completion
- * time (Wave-0/1), so including it would double-count.
+ * time, so including it would double-count.
  */
 function aggregateCost(members) {
     const withUsage = members.filter((node) => node.usage !== undefined);
@@ -143,6 +147,48 @@ function aggregateCost(members) {
     const total = priced.reduce((sum, node) => sum + node.costUsd, 0);
     return { costUsd: total, costState: priced.length === withUsage.length ? 'priced' : 'estimated' };
 }
+/**
+ * An honest model descriptor for a chain node, derived from its member agents
+ * (which carry the real model that ran each phase — the owner itself often has no
+ * resolved model). One distinct model → that model; several → "N models"; none →
+ * undefined. Fixes the "model unknown" chain-detail readout.
+ */
+function chainModelDescriptor(members) {
+    const models = new Set();
+    for (const node of members) {
+        if (typeof node.model === 'string' && node.model.length > 0)
+            models.add(node.model);
+    }
+    if (models.size === 0)
+        return undefined;
+    if (models.size === 1)
+        return [...models][0];
+    return `${models.size} models`;
+}
+/**
+ * Reprice a WRFC owner agent node for honest DISPLAY. The owner runs no LLM turn
+ * itself; at completion its usage is backfilled from aggregateChainUsage — a
+ * mixed-model rollup of its children — so pricing it with a single owner model is
+ * wrong and leaving it "unpriced" while its children priced fine is misleading.
+ * Instead adopt the chain node's per-child-summed cost (and its model descriptor).
+ *
+ * Returns the SAME node reference when no reprice applies (owner already priced, or
+ * the chain has no priced cost), so callers can skip untouched nodes. The owner is
+ * excluded from every leaf-sum (registry aggregateCost / isWrfcOwnerAgentNode), so
+ * adopting the chain total here can never double-count.
+ */
+export function repriceWrfcOwnerNode(ownerNode, chainNode) {
+    if (ownerNode.costState !== 'unpriced')
+        return ownerNode;
+    if (chainNode.costUsd === null || chainNode.costUsd === undefined)
+        return ownerNode;
+    return {
+        ...ownerNode,
+        costUsd: chainNode.costUsd,
+        costState: chainNode.costState,
+        model: ownerNode.model ?? chainNode.model,
+    };
+}
 /**
  * The subtask's currently-active member agent, i.e. whichever role is
  * driving its current phase. Undefined when the subtask has no phase
@@ -215,6 +261,7 @@ export function adaptChain(chain, memberNodes, now) {
         completedAt,
         elapsedMs: Math.max(0, (completedAt ?? now) - chain.createdAt),
         usage: sumUsage(memberNodes),
+        model: chainModelDescriptor(memberNodes),
         costUsd,
         costState,
         // Silent source: anchored to createdAt (no phase-transition timestamp).

package/dist/platform/runtime/fleet/registry.d.ts

@@ -1,6 +1,6 @@
 /** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
 /**
- * Live process registry (W2.1) — one queryable + subscribable aggregation
+ * Live process registry — one queryable + subscribable aggregation
  * surface over the already-composed runtime managers. ZERO new store state:
  * every query is an aggregate-on-read over the managers' in-memory maps, and
  * the only registry-owned mutable state is the agent activity side-table fed
@@ -49,7 +49,7 @@ export interface ProcessRegistryDeps {
     readonly agentManager: Pick<AgentManager, 'list' | 'cancel'>;
     readonly wrfcController: Pick<WrfcController, 'listChains'>;
     /**
-     * Optional (Wave 4, wo701): folds workstream/phase/work-item nodes into
+     * Optional: folds workstream/phase/work-item nodes into
      * the fleet, nested workstream -> phase -> work-item, mirroring the
      * wrfc-chain/subtask nesting. Without this dep the registry degrades to
      * exactly today's behavior — no orchestration nodes, no new capability.
@@ -67,23 +67,23 @@ export interface ProcessRegistryDeps {
     readonly watcherRegistry: Pick<WatcherRegistry, 'list' | 'stopWatcher'>;
     readonly workflow: {
         readonly workflowManager: Pick<WorkflowManager, 'list' | 'cancel'>;
-        /** `enable` (Wave 6, wo-F item d2) backs ProcessRegistry.resume() — the inverse of `disable`'s interrupt/pause. */
+        /** `enable` backs ProcessRegistry.resume() — the inverse of `disable`'s interrupt/pause. */
         readonly triggerManager: Pick<TriggerManager, 'list' | 'remove' | 'disable' | 'enable'>;
         readonly scheduleManager: Pick<ScheduleManager, 'list' | 'remove' | 'disable' | 'enable'>;
     };
     /** Optional: awaiting-approval derivation. Non-control-plane runtimes still build a fleet. */
     readonly approvalBroker?: Pick<ApprovalBroker, 'listApprovals'> | undefined;
-    /** Optional: populates ProcessNode.sessionRef.sessionId (Wave-3 tab attach point). */
+    /** Optional: populates ProcessNode.sessionRef.sessionId (tab attach point). */
     readonly sessionBroker?: Pick<SharedSessionBroker, 'listSessions'> | undefined;
     /**
-     * Optional: the repo source-tree code index (Wave-5 wo802, W5.3 Stage A).
+     * Optional: the repo source-tree code index (Stage A).
      * When present, its build/idle state surfaces as a single 'code-index'
      * ProcessNode. Without this dep the fleet degrades to exactly today's
      * behavior — zero code-index nodes, no new capability.
      */
     readonly codeIndexService?: CodeIndexProcessSource | undefined;
     /**
-     * Optional (Wave 6, wo-F item d4): folds `/schedule` automation jobs
+     * Optional: folds `/schedule` automation jobs
      * (platform/automation, a SEPARATE subsystem from the workflow-tool's
      * ScheduleManager above) into the fleet as 'schedule'-kind nodes — see
      * adapters/automation.ts. Without this dep the fleet degrades to exactly
@@ -91,7 +91,7 @@ export interface ProcessRegistryDeps {
      */
     readonly automationManager?: Pick<AutomationManager, 'listJobs' | 'setEnabled' | 'removeJob'> | undefined;
     /**
-     * Optional: backs `steer()` and the `steerable` capability (Wave-3). The
+     * Optional: backs `steer()` and the `steerable` capability. The
      * bus already exists in the composed runtime and already feeds every
      * in-process agent's per-turn inbox drain (orchestrator-runner.ts) — this
      * just hands the registry a narrow `send`-only pick of it. Without this

package/dist/platform/runtime/fleet/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/platform/runtime/fleet/registry.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/platform/runtime/fleet/registry.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAe,MAAM,8BAA8B,CAAC;AAC9E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAEtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAC5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,KAAK,EAEV,eAAe,EACf,cAAc,EACd,eAAe,EAChB,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AAC7E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,KAAK,EAAE,eAAe,EAAwB,MAAM,oBAAoB,CAAC;AAEhF,OAAO,KAAK,EAKV,eAAe,EACf,YAAY,EAEb,MAAM,YAAY,CAAC;AAoBpB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAGvE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAIzE,+FAA+F;AAC/F,eAAO,MAAM,4BAA4B,QAAS,CAAC;AACnD,mEAAmE;AACnE,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAC5C;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,QAAiB,CAAC;AAE3C,2EAA2E;AAC3E,MAAM,WAAW,cAAc;IAC7B,WAAW,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/D,aAAa,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;CACtC;AAED;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,YAAY,EAAE,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,QAAQ,CAAC,CAAC;IAC7D,QAAQ,CAAC,cAAc,EAAE,IAAI,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC;IAC5D;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,IAAI,CAAC,mBAAmB,EAAE,iBAAiB,GAAG,MAAM,CAAC,GAAG,SAAS,CAAC;IACjG,QAAQ,CAAC,cAAc,EAAE,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,GAAG,WAAW,CAAC,CAAC;IAC7E,QAAQ,CAAC,eAAe,EAAE,IAAI,CAAC,eAAe,EAAE,MAAM,GAAG,aAAa,CAAC,CAAC;IACxE,QAAQ,CAAC,QAAQ,EAAE;QACjB,QAAQ,CAAC,eAAe,EAAE,IAAI,CAAC,eAAe,EAAE,MAAM,GAAG,QAAQ,CAAC,CAAC;QACnE,4FAA4F;QAC5F,QAAQ,CAAC,cAAc,EAAE,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC,CAAC;QACxF,QAAQ,CAAC,eAAe,EAAE,IAAI,CAAC,eAAe,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC,CAAC;KAC3F,CAAC;IACF,8FAA8F;IAC9F,QAAQ,CAAC,cAAc,CAAC,EAAE,IAAI,CAAC,cAAc,EAAE,eAAe,CAAC,GAAG,SAAS,CAAC;IAC5E,+EAA+E;IAC/E,QAAQ,CAAC,aAAa,CAAC,EAAE,IAAI,CAAC,mBAAmB,EAAE,cAAc,CAAC,GAAG,SAAS,CAAC;IAC/E;;;;;OAKG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,sBAAsB,GAAG,SAAS,CAAC;IAC/D;;;;;;OAMG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,UAAU,GAAG,YAAY,GAAG,WAAW,CAAC,GAAG,SAAS,CAAC;IAC1G;;;;;;;OAOG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IAChE,qHAAqH;IACrH,QAAQ,CAAC,UAAU,CAAC,EAAE,eAAe,GAAG,SAAS,CAAC;IAClD,8FAA8F;IAC9F,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,EAAE,YAAY,KAAK,MAAM,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC;IACtG,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,MAAM,CAAC,GAAG,SAAS,CAAC;IAC1C,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjD,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7C,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;CAC9C;AAkDD,2EAA2E;AAC3E,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,mBAAmB,GAAG,eAAe,CA0lBhF"}

package/dist/platform/runtime/fleet/registry.js

@@ -1,6 +1,6 @@
 /** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
 import { adaptAgent } from './adapters/agent.js';
-import { activeSubtaskMemberAgentId, adaptChain, adaptSubtask } from './adapters/wrfc.js';
+import { activeSubtaskMemberAgentId, adaptChain, adaptSubtask, repriceWrfcOwnerNode } from './adapters/wrfc.js';
 import { adaptWorkflow } from './adapters/workflow.js';
 import { adaptTrigger } from './adapters/trigger.js';
 import { adaptSchedule } from './adapters/schedule.js';
@@ -204,6 +204,9 @@ export function createProcessRegistry(deps) {
             agentNodeById.set(node.id, node);
             nodes.push(node);
         }
+        // Owner agent nodes to replace with a repriced copy after the chain loop
+        // (ProcessNode is readonly — collect overrides, apply in one pass at the end).
+        const ownerNodeOverrides = new Map();
         for (const chain of chains) {
             // Members exclude the owner: its usage is populated FROM phase children
             // at completion time, so including it would double-count (see wrfc.ts).
@@ -215,7 +218,18 @@ export function createProcessRegistry(deps) {
                 if (node)
                     memberNodes.push(node);
             }
-            nodes.push(adaptChain(chain, memberNodes, capturedAt));
+            const chainNode = adaptChain(chain, memberNodes, capturedAt);
+            nodes.push(chainNode);
+            // Owner cost honesty: a WRFC owner runs no LLM turn itself, so its own model
+            // is often unresolved and it prices as "unpriced" even though its children
+            // priced fine. Adopt the chain's per-child-summed cost + model descriptor for
+            // the owner ROW. Excluded from every leaf-sum, so this never double-counts.
+            const ownerNode = agentNodeById.get(chain.ownerAgentId);
+            if (ownerNode) {
+                const repriced = repriceWrfcOwnerNode(ownerNode, chainNode);
+                if (repriced !== ownerNode)
+                    ownerNodeOverrides.set(ownerNode.id, repriced);
+            }
             for (const subtask of chain.subtasks ?? []) {
                 // Steerable only when the subtask's currently-active member agent is
                 // both present in this snapshot and not terminal, AND a messageBus
@@ -230,7 +244,24 @@ export function createProcessRegistry(deps) {
             }
         }
         for (const workstream of workstreams) {
-            nodes.push(adaptWorkstream(workstream, capturedAt));
+            // Resolve each item's active-agent in-flight usage ONCE up front, keyed
+            // by item id, so both the workstream rollup and the per-item nodes show
+            // live mid-phase usage instead of n/a until the phase boundary lands
+            // (DEBT-4 item 2). displayWorkItemUsage applies the overlay only while an
+            // item is 'in-phase', so this never double-counts committed usage.
+            const liveByItemId = new Map();
+            for (const item of workstream.items) {
+                const activeAgentId = activeWorkItemAgentId(item);
+                const activeAgentNode = activeAgentId ? agentNodeById.get(activeAgentId) : undefined;
+                if (activeAgentNode) {
+                    liveByItemId.set(item.id, {
+                        usage: activeAgentNode.usage,
+                        costUsd: activeAgentNode.costUsd ?? null,
+                        costState: activeAgentNode.costState,
+                    });
+                }
+            }
+            nodes.push(adaptWorkstream(workstream, capturedAt, liveByItemId));
             for (const phase of workstream.phases) {
                 nodes.push(adaptPhase(phase, workstream));
             }
@@ -244,7 +275,7 @@ export function createProcessRegistry(deps) {
                 const parentId = item.currentPhaseId
                     ? phaseNodeId(workstream.id, item.currentPhaseId)
                     : workstreamNodeId(workstream.id);
-                nodes.push(adaptWorkItem(item, workstream.id, parentId, { steerable: deps.messageBus !== undefined && memberLive }));
+                nodes.push(adaptWorkItem(item, workstream.id, parentId, { steerable: deps.messageBus !== undefined && memberLive, live: liveByItemId.get(item.id) }));
             }
         }
         for (const instance of deps.workflow.workflowManager.list()) {
@@ -272,6 +303,9 @@ export function createProcessRegistry(deps) {
         if (deps.codeIndexService) {
             nodes.push(adaptCodeIndex(deps.codeIndexService, capturedAt));
         }
+        if (ownerNodeOverrides.size > 0) {
+            return { capturedAt, nodes: nodes.map((node) => ownerNodeOverrides.get(node.id) ?? node) };
+        }
         return { capturedAt, nodes };
     }
     function query(filter) {
@@ -353,8 +387,8 @@ export function createProcessRegistry(deps) {
         return affected;
     }
     /**
-     * Fire-and-forget an AutomationManager async control call (Wave 6, wo-F
-     * item d4): the registry's own kill/interrupt/resume verbs are
+     * Fire-and-forget an AutomationManager async control call: the
+     * registry's own kill/interrupt/resume verbs are
      * synchronous, but AutomationManager.removeJob/setEnabled are Promises —
      * dispatch without awaiting rather than making every registry verb async,
      * but never let a rejection vanish silently. The next tick's assemble()
@@ -511,7 +545,7 @@ export function createProcessRegistry(deps) {
         }
     }
     /**
-     * Wave 6 (wo-F item d2): re-arm a `paused` trigger/schedule via the owning
+     * Re-arm a `paused` trigger/schedule via the owning
      * manager's `enable()` — the inverse of interrupt()'s disable. Re-assemble
      * + dispatch-by-kind mirrors interrupt()/kill()'s own shape exactly (same
      * synchronous, no-owned-state pattern as every other control verb here).