@pellux/goodvibes-sdk 0.38.0 → 1.0.0

package/dist/platform/runtime/feature-flags/flags.js

@@ -207,6 +207,26 @@ export const FEATURE_FLAGS = [
         tier: 9,
         runtimeToggleable: true,
     },
+    {
+        id: 'agent-passive-code-injection',
+        name: 'Agent Passive Code Injection',
+        description: 'Enables per-turn passive retrieval from the repo SOURCE-TREE CODE INDEX (CodeIndexStore) '
+            + 'alongside project-memory knowledge, sharing the SAME token budget and relevance floor. '
+            + 'When the query would benefit and the index is built, similarity-ranked code chunks are '
+            + 'injected as untrusted reference pointers, each recorded on the turn injection record with '
+            + 'source=code-index and its honest match label (semantic/lexical). Never injects from an '
+            + 'empty or provider-mismatched index, or from a hashed-only (no real semantic) provider — '
+            + 'the store exposes each of those and the turn record states which. '
+            + 'DEFAULT OFF (unlike agent-passive-knowledge-injection, which defaults on): code injection '
+            + 'is a newer, higher-variance signal than reviewed project memory — code chunks carry no '
+            + 'review/trust provenance and a weak similarity match can pull in a plausibly-worded but '
+            + 'wrong chunk — so this first landing is opt-in, earned on by the same hard-budget + '
+            + 'honest-record discipline before it becomes a default. Also respects the embedder’s '
+            + 'storage.codeIndexEnabled setting; disable either to revert to memory-only injection.',
+        defaultState: 'disabled',
+        tier: 9,
+        runtimeToggleable: true,
+    },
     {
         id: 'output-schema-fingerprint',
         name: 'Output Schema Fingerprints',
@@ -323,11 +343,29 @@ export const FEATURE_FLAGS = [
         runtimeToggleable: true,
     },
     {
+        // NOTE: control-plane-gateway is the ONE tier-10 flag that defaults ON (One-Platform
+        // Wave 1). A stock daemon (no config) must be able to stream companion chat over SSE;
+        // leaving this OFF made a fresh daemon return 503 on the live-stream path (the W1
+        // "stock daemon is dead" bug).
+        //
+        // HONEST SURFACE STATEMENT: flipping this default ON DOES expose surface — just not
+        // an UNAUTHENTICATED one. Concretely it turns on: (1) the auth-gated streaming surface
+        // — SSE `/api/control-plane/events`, the companion-chat `.../events` stream, and the WS
+        // control channel — every one of which returns 401 before any principal is resolved
+        // (daemon-sdk/control-routes.ts), and per-channel scopes are enforced on the fan-out
+        // (e.g. read:sessions on session-update); and (2) the inert pre-auth login shell — the
+        // handful of unauthenticated bootstrap endpoints that carry NO session/runtime data and
+        // exist only to establish auth. The default bind stays loopback and the 60/min + 5/min
+        // rate limiters are unchanged. It remains runtimeToggleable, so an operator who wants a
+        // request/response-only daemon can turn it back off via config
+        // (`flags: { 'control-plane-gateway': 'disabled' }`), which the manager honours over
+        // this default. Do NOT generalise this to the other tier-10 siblings (slack/discord/web
+        // surfaces, delivery-engine, etc.) — they stay OFF until individually validated.
         id: 'control-plane-gateway',
         name: 'Control-Plane Gateway',
         description: 'Enables the shared gateway/control-plane host that serves state snapshots, live streams, '
             + 'and authenticated automation control APIs to terminal hosts and remote clients.',
-        defaultState: 'disabled',
+        defaultState: 'enabled',
         tier: 10,
         runtimeToggleable: true,
     },

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

@@ -1,19 +1,30 @@
 /** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+import type { Phase, WorkItem, WorkItemUsage, Workstream } from '../../../orchestration/types.js';
+import type { ProcessCostState, ProcessNode, ProcessUsage } from '../types.js';
+import { workItemNodeId } from './agent.js';
 /**
- * Orchestration-engine fleet adapters (Wave 4, wo701) — 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.
+ * Live in-flight usage of a work-item's currently-active agent, read from that
+ * agent's fleet node at snapshot time (DEBT-4 item 2). Overlaid onto the
+ * item's phase-boundary-committed `item.usage` so a RUNNING phase shows real,
+ * growing numbers instead of n/a until it completes.
  */
-import type { Phase, WorkItem, Workstream } from '../../../orchestration/types.js';
-import type { ProcessNode } from '../types.js';
-import { workItemNodeId } from './agent.js';
+export interface LiveItemUsage {
+    readonly usage?: ProcessUsage | undefined;
+    readonly costUsd?: number | null | undefined;
+    readonly costState?: ProcessCostState | undefined;
+}
+/**
+ * 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 declare function displayWorkItemUsage(item: WorkItem, live: LiveItemUsage | undefined): WorkItemUsage;
 /** Workstream node ids are namespaced to avoid colliding with agent/process ids. */
 export declare function workstreamNodeId(workstreamId: string): string;
 /**
@@ -25,9 +36,16 @@ export declare function phaseNodeId(workstreamId: string, phaseId: string): stri
 export { workItemNodeId };
 /** The work-item's currently-active agent, i.e. the one driving its live phase run. Undefined once terminal or between phases. */
 export declare function activeWorkItemAgentId(item: WorkItem): string | undefined;
-/** 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 declare function adaptWorkItem(item: WorkItem, workstreamId: string, parentId: string, opts: {
     steerable: boolean;
+    live?: LiveItemUsage | undefined;
 }): ProcessNode;
 /**
  * Phase -> ProcessNode. Deliberately reports NO usage/cost (mirrors
@@ -39,9 +57,13 @@ export declare function adaptWorkItem(item: WorkItem, workstreamId: string, pare
  */
 export declare function adaptPhase(phase: Phase, workstream: Workstream): ProcessNode;
 /**
- * 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 declare function adaptWorkstream(workstream: Workstream, now: number): ProcessNode;
+export declare function adaptWorkstream(workstream: Workstream, now: number, liveByItemId?: ReadonlyMap<string, LiveItemUsage>): ProcessNode;
 //# sourceMappingURL=orchestration.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"orchestration.d.ts","sourceRoot":"","sources":["../../../../../src/platform/runtime/fleet/adapters/orchestration.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAErF;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AACnF,OAAO,KAAK,EAAE,WAAW,EAA8B,MAAM,aAAa,CAAC;AAC3E,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5C,oFAAoF;AACpF,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAEzE;AAED,OAAO,EAAE,cAAc,EAAE,CAAC;AAI1B,kIAAkI;AAClI,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,SAAS,CAExE;AA6FD,iIAAiI;AACjI,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE;IAAE,SAAS,EAAE,OAAO,CAAA;CAAE,GAAG,WAAW,CA6C/H;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,UAAU,GAAG,WAAW,CAuB5E;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW,CA+BhF"}
+{"version":3,"file":"orchestration.d.ts","sourceRoot":"","sources":["../../../../../src/platform/runtime/fleet/adapters/orchestration.ts"],"names":[],"mappings":"AAAA,qFAAqF;AAerF,OAAO,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAClG,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAgB,YAAY,EAAE,MAAM,aAAa,CAAC;AAC7F,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5C;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,YAAY,GAAG,SAAS,CAAC;IAC1C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC7C,QAAQ,CAAC,SAAS,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAC;CACnD;AA2CD;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,aAAa,GAAG,SAAS,GAAG,aAAa,CAOnG;AAED,oFAAoF;AACpF,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAEzE;AAED,OAAO,EAAE,cAAc,EAAE,CAAC;AAI1B,kIAAkI;AAClI,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,SAAS,CAExE;AA0GD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,aAAa,GAAG,SAAS,CAAA;CAAE,GAAG,WAAW,CAqDjK;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,UAAU,GAAG,WAAW,CAuB5E;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,WAAW,CAgCnI"}

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 (Wave 4, wo701) — 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/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':
@@ -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.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":"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"}

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) {