@pellux/goodvibes-tui 0.19.85 → 0.19.87

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "0.19.85",
+  "version": "0.19.87",
   "description": "Terminal-native GoodVibes product for coding, operations, automation, knowledge, channels, and daemon-backed control-plane workflows.",
   "type": "module",
   "main": "src/main.ts",
@@ -97,7 +97,7 @@
     "@anthropic-ai/vertex-sdk": "^0.16.0",
     "@ast-grep/napi": "^0.42.0",
     "@aws/bedrock-token-generator": "^1.1.0",
-    "@pellux/goodvibes-sdk": "0.33.20",
+    "@pellux/goodvibes-sdk": "0.33.22",
     "bash-language-server": "^5.6.0",
     "fuse.js": "^7.1.0",
     "graphql": "^16.13.2",

package/src/main.ts

@@ -16,7 +16,6 @@ import { PermissionPromptUI } from './permissions/prompt.ts';
 import { CommandRegistry } from './input/command-registry.ts';
 import type { CommandContext } from './input/command-registry.ts';
 import { renderProcessIndicator } from './renderer/process-indicator.ts';
-import { WrfcController } from '@pellux/goodvibes-sdk/platform/agents';
 import { registerBuiltinCommands } from './input/commands.ts';
 import { ScheduleManager } from '@pellux/goodvibes-sdk/platform/tools';
 import { InputHistory } from './input/input-history.ts';
@@ -54,6 +53,7 @@ import { attachSpokenTurnModelRouting, createSpokenTurnInputOptions } from './au
 import { allowTerminalWrite, installTuiTerminalOutputGuard } from './runtime/terminal-output-guard.ts';
 import { ProjectPlanningCoordinator } from './planning/project-planning-coordinator.ts';
 import { buildCommandArgsHint } from './input/command-args-hint.ts';
+import { summarizeRunningAgents } from './renderer/process-summary.ts';
 
 const ALT_SCREEN_ENTER = '\x1b[?1049h';
 const ALT_SCREEN_EXIT  = '\x1b[?1049l';
@@ -483,17 +483,8 @@ async function main() {
       (a) => a.status === 'running' || a.status === 'pending',
     );
     const runtimeAgents = agentSnapshot.active;
-    const runningAgentIds = new Set<string>();
-    let runningAgentProgress: string | undefined;
-    for (const agent of managerAgents) {
-      runningAgentIds.add(agent.id);
-      if (!runningAgentProgress && agent.progress) runningAgentProgress = agent.progress;
-    }
-    for (const agent of runtimeAgents) {
-      runningAgentIds.add(agent.id);
-      if (!runningAgentProgress && agent.latestProgress) runningAgentProgress = agent.latestProgress;
-    }
-    const runningAgentCount = runningAgentIds.size;
+    const runningAgentSummary = summarizeRunningAgents(managerAgents, runtimeAgents, ctx.services.wrfcController.listChains());
+    const runningAgentCount = runningAgentSummary.count;
     const runningProcessCount = processManager.list().filter((p) => !p.status.startsWith('done')).length;
     const cw = getPromptContentWidth();
     const promptInfo = input.getWrappedPromptInfo(cw);
@@ -540,7 +531,7 @@ async function main() {
       runningAgentCount,
       runningProcessCount,
       indicatorFocused: input.indicatorFocused,
-      runningAgentProgress,
+      runningAgentProgress: runningAgentSummary.progress,
       composerMode: composerState.modeLabel,
       composerStatus: composerState.statusLabel,
       composerFlags: composerState.flags,

package/src/renderer/process-modal.ts

@@ -14,6 +14,8 @@ export interface ProcessEntry {
   id: string;
   /** Display label (agent task or exec command) */
   label: string;
+  /** Tree prefix for child processes, e.g. "└─ " under a WRFC owner. */
+  treePrefix?: string;
   /** Process type */
   type: 'agent' | 'exec';
   /** Current status string */
@@ -31,12 +33,32 @@ const MAX_LABEL_LENGTH = 80;
 /** Border and margin width subtracted from terminal width to get modal content width. */
 const MODAL_BORDER_WIDTH = 8;
 
+const WRFC_ROLE_ORDER: Record<string, number> = {
+  owner: 0,
+  engineer: 1,
+  reviewer: 2,
+  fixer: 3,
+  verifier: 4,
+};
+
 export interface ProcessModalDeps {
   readonly agentManager: Pick<AgentManager, 'list' | 'getStatus' | 'cancel'>;
   readonly processManager: Pick<ProcessManager, 'list' | 'getStatus' | 'stop'>;
-  readonly wrfcController: Pick<WrfcController, 'getChain'>;
+  readonly wrfcController: Pick<WrfcController, 'getChain'> & Partial<Pick<WrfcController, 'listChains'>>;
 }
 
+type WrfcChainLike = {
+  readonly id: string;
+  readonly state: string;
+  readonly task: string;
+  readonly ownerAgentId: string;
+  readonly engineerAgentId?: string;
+  readonly reviewerAgentId?: string;
+  readonly fixerAgentId?: string;
+  readonly allAgentIds?: readonly string[];
+  readonly constraints?: readonly unknown[];
+};
+
 /** Build a display label for an agent based on its task and template. */
 function buildAgentLabel(rec: AgentRecord, deps: ProcessModalDeps): string {
   const task = rec.task;
@@ -44,6 +66,21 @@ function buildAgentLabel(rec: AgentRecord, deps: ProcessModalDeps): string {
   // Look up the original task from the WRFC chain if available
   const originalTask = getChainTask(rec.wrfcId, deps);
 
+  if (rec.wrfcRole === 'owner') {
+    const desc = truncateFirst(originalTask ?? task, MAX_LABEL_LENGTH - 13);
+    return `[WRFC owner] ${desc}`;
+  }
+
+  if (rec.wrfcRole === 'engineer') {
+    const desc = truncateFirst(originalTask ?? task, MAX_LABEL_LENGTH - 11);
+    return `[Engineer] ${desc}`;
+  }
+
+  if (rec.wrfcRole === 'verifier') {
+    const desc = truncateFirst(originalTask ?? task, MAX_LABEL_LENGTH - 13);
+    return `[Verifier] ${desc}`;
+  }
+
   // WRFC Review agent
   if (task.startsWith('WRFC Review Request')) {
     const thresholdMatch = task.match(/threshold is (\d+(?:\.\d+)?)/);
@@ -61,8 +98,8 @@ function buildAgentLabel(rec: AgentRecord, deps: ProcessModalDeps): string {
     const attempt = attemptMatch ? attemptMatch[1] : '?';
     const desc = truncateFirst(originalTask ?? 'fix in progress', 45);
     // Show constraint count when the chain has constraints to target (SDK 0.23.0)
-    const chain = rec.wrfcId ? (() => { try { return deps.wrfcController.getChain(rec.wrfcId!); } catch { return null; } })() : null;
-    const constraintCount = chain && chain.constraints.length > 0 ? chain.constraints.length : 0;
+    const chain = rec.wrfcId ? safeGetChain(rec.wrfcId, deps) : null;
+    const constraintCount = chain && (chain.constraints?.length ?? 0) > 0 ? chain.constraints?.length ?? 0 : 0;
     const constraintSuffix = constraintCount > 0 ? `  [${constraintCount}c]` : '';
     return `[Fix #${attempt}] ${desc}  (${fromScore} \u2192 ${toScore}/10)${constraintSuffix}`;
   }
@@ -77,13 +114,331 @@ function buildAgentLabel(rec: AgentRecord, deps: ProcessModalDeps): string {
   return `[${tag}] ${truncateFirst(task, maxDesc)}`;
 }
 
+function isActiveAgent(rec: AgentRecord): boolean {
+  return rec.status !== 'completed' && rec.status !== 'failed' && rec.status !== 'cancelled';
+}
+
+function isActiveWrfcState(state: string): boolean {
+  return state !== 'passed' && state !== 'failed';
+}
+
+function getStreamSnippet(rec: AgentRecord): string | undefined {
+  if (!rec.streamingContent) return undefined;
+  const raw = rec.streamingContent.replace(/\n/g, ' ').trim();
+  return raw.length > 60 ? '...' + raw.slice(-57) : raw;
+}
+
+function compareAgents(a: AgentRecord, b: AgentRecord): number {
+  const roleDelta = (WRFC_ROLE_ORDER[a.wrfcRole ?? ''] ?? 50) - (WRFC_ROLE_ORDER[b.wrfcRole ?? ''] ?? 50);
+  if (roleDelta !== 0) return roleDelta;
+  return a.startedAt - b.startedAt || a.id.localeCompare(b.id);
+}
+
+function buildAgentEntry(
+  rec: AgentRecord,
+  deps: ProcessModalDeps,
+  now: number,
+  treePrefix = '',
+): ProcessEntry {
+  return {
+    id: rec.id,
+    label: buildAgentLabel(rec, deps),
+    treePrefix,
+    type: 'agent',
+    status: rec.status,
+    elapsedMs: now - rec.startedAt,
+    streamSnippet: getStreamSnippet(rec),
+  };
+}
+
+function appendAgentSubtree(
+  result: ProcessEntry[],
+  rec: AgentRecord,
+  childrenByParent: Map<string, AgentRecord[]>,
+  deps: ProcessModalDeps,
+  now: number,
+  prefix: string,
+  connector: string,
+  visited: Set<string>,
+): void {
+  if (visited.has(rec.id)) return;
+  visited.add(rec.id);
+  result.push(buildAgentEntry(rec, deps, now, `${prefix}${connector}`));
+
+  const children = (childrenByParent.get(rec.id) ?? []).slice().sort(compareAgents);
+  const descendantPrefix = connector === '├─ ' ? '│  ' : connector === '└─ ' ? '   ' : '';
+  children.forEach((child, index) => {
+    const last = index === children.length - 1;
+    appendAgentSubtree(
+      result,
+      child,
+      childrenByParent,
+      deps,
+      now,
+      `${prefix}${descendantPrefix}`,
+      last ? '└─ ' : '├─ ',
+      visited,
+    );
+  });
+}
+
+function appendAgentGroupEntries(
+  result: ProcessEntry[],
+  records: AgentRecord[],
+  deps: ProcessModalDeps,
+  now: number,
+): void {
+  const group = records.slice().sort(compareAgents);
+  const byId = new Map(group.map((rec) => [rec.id, rec]));
+  const childrenByParent = new Map<string, AgentRecord[]>();
+
+  for (const rec of group) {
+    if (!rec.parentAgentId || !byId.has(rec.parentAgentId)) continue;
+    const children = childrenByParent.get(rec.parentAgentId) ?? [];
+    children.push(rec);
+    childrenByParent.set(rec.parentAgentId, children);
+  }
+
+  const chain = group[0]?.wrfcId ? safeGetChain(group[0].wrfcId, deps) : null;
+  const owner = group.find((rec) => rec.id === chain?.ownerAgentId)
+    ?? group.find((rec) => rec.wrfcRole === 'owner');
+  const roots = owner
+    ? [owner]
+    : group.filter((rec) => !rec.parentAgentId || !byId.has(rec.parentAgentId));
+  const visited = new Set<string>();
+
+  roots.forEach((root, index) => {
+    const connector = owner || roots.length === 1 ? '' : (index === roots.length - 1 ? '└─ ' : '├─ ');
+    appendAgentSubtree(result, root, childrenByParent, deps, now, '', connector, visited);
+  });
+
+  const leftovers = group.filter((rec) => !visited.has(rec.id));
+  leftovers.forEach((rec, index) => {
+    appendAgentSubtree(
+      result,
+      rec,
+      childrenByParent,
+      deps,
+      now,
+      '',
+      index === leftovers.length - 1 ? '└─ ' : '├─ ',
+      visited,
+    );
+  });
+}
+
+function buildAgentEntries(
+  agents: AgentRecord[],
+  deps: ProcessModalDeps,
+  now: number,
+  getGroupOrder?: (key: string) => number | undefined,
+  ensureGroupOrder?: (key: string) => number,
+): ProcessEntry[] {
+  const result: ProcessEntry[] = [];
+  const displayAgents = prepareAgentRecordsForDisplay(agents, deps);
+  const activeById = new Map(displayAgents.map((agent) => [agent.id, agent]));
+  const groups = new Map<string, AgentRecord[]>();
+
+  for (const agent of displayAgents) {
+    const groupKey = getAgentGroupKey(agent, activeById);
+    const group = groups.get(groupKey) ?? [];
+    group.push(agent);
+    groups.set(groupKey, group);
+  }
+
+  const sortedGroups = Array.from(groups.entries()).sort(([aKey, a], [bKey, b]) => {
+    const aOrder = getGroupOrder?.(aKey);
+    const bOrder = getGroupOrder?.(bKey);
+    if (aOrder !== undefined || bOrder !== undefined) {
+      if (aOrder === undefined) return 1;
+      if (bOrder === undefined) return -1;
+      return aOrder - bOrder;
+    }
+    const aStarted = Math.min(...a.map((rec) => rec.startedAt));
+    const bStarted = Math.min(...b.map((rec) => rec.startedAt));
+    return aStarted - bStarted || aKey.localeCompare(bKey);
+  });
+  for (const [key, group] of sortedGroups) {
+    ensureGroupOrder?.(key);
+    appendAgentGroupEntries(result, group, deps, now);
+  }
+
+  return result;
+}
+
+function prepareAgentRecordsForDisplay(agents: AgentRecord[], deps: ProcessModalDeps): AgentRecord[] {
+  const chains = listWrfcChains(deps);
+  const agentById = new Map(agents.map((agent) => [agent.id, agent]));
+  const normalizedById = new Map<string, AgentRecord>();
+
+  for (const agent of agents) {
+    if (!isActiveAgent(agent)) continue;
+    normalizedById.set(agent.id, normalizeWrfcAgentRecord(agent, chains));
+  }
+
+  // A WRFC owner is the durable root of the chain. Keep it visible until the
+  // chain itself is terminal, even if the underlying owner agent has already
+  // emitted a completed phase event before reviewer/fixer/gate work finishes.
+  for (const chain of chains) {
+    if (!isActiveWrfcState(chain.state)) continue;
+    const owner = agentById.get(chain.ownerAgentId);
+    if (!owner || normalizedById.has(owner.id)) continue;
+    const chainHasActiveMember = agents.some((agent) =>
+      agent.id !== owner.id
+      && isActiveAgent(agent)
+      && isAgentInChain(agent, chain)
+    );
+    if (!chainHasActiveMember) continue;
+    normalizedById.set(owner.id, normalizeWrfcAgentRecord({
+      ...owner,
+      status: 'running',
+      completedAt: undefined,
+      progress: owner.progress ?? `WRFC chain ${chain.state}`,
+    }, chains));
+  }
+
+  const normalized = Array.from(normalizedById.values());
+  return inferDuplicateWrfcOwnerRows(normalized);
+}
+
+function normalizeWrfcAgentRecord(agent: AgentRecord, chains: WrfcChainLike[]): AgentRecord {
+  const chain = findChainForAgent(agent, chains);
+  if (!chain) return agent;
+
+  const role = inferWrfcRole(agent, chain);
+  const parentAgentId = role && role !== 'owner'
+    ? agent.parentAgentId ?? chain.ownerAgentId
+    : agent.parentAgentId;
+
+  return {
+    ...agent,
+    wrfcId: agent.wrfcId ?? chain.id,
+    wrfcRole: agent.wrfcRole ?? role,
+    parentAgentId,
+  };
+}
+
+function inferDuplicateWrfcOwnerRows(agents: AgentRecord[]): AgentRecord[] {
+  const byTask = new Map<string, AgentRecord[]>();
+  for (const agent of agents) {
+    if (agent.wrfcId || agent.wrfcRole || agent.parentAgentId) continue;
+    if (agent.reviewMode !== 'wrfc') continue;
+    const key = agent.task.trim();
+    if (!key) continue;
+    const group = byTask.get(key) ?? [];
+    group.push(agent);
+    byTask.set(key, group);
+  }
+
+  const inferredIds = new Set<string>();
+  const inferred = new Map<string, AgentRecord>();
+  for (const [task, group] of byTask) {
+    if (group.length < 2) continue;
+    const sorted = group.slice().sort((a, b) => a.startedAt - b.startedAt || a.id.localeCompare(b.id));
+    const owner = sorted[0]!;
+    const syntheticWrfcId = `inferred:${owner.id}`;
+    inferred.set(owner.id, {
+      ...owner,
+      wrfcId: syntheticWrfcId,
+      wrfcRole: 'owner',
+    });
+    inferredIds.add(owner.id);
+    for (const child of sorted.slice(1)) {
+      inferred.set(child.id, {
+        ...child,
+        wrfcId: syntheticWrfcId,
+        wrfcRole: child.template === 'reviewer' ? 'reviewer' : 'engineer',
+        parentAgentId: owner.id,
+      });
+      inferredIds.add(child.id);
+    }
+
+    // Avoid accidentally grouping unrelated long-running WRFC roots that just
+    // happen to share an empty or generic task after this exact duplicate group.
+    byTask.delete(task);
+  }
+
+  if (inferredIds.size === 0) return agents;
+  return agents.map((agent) => inferred.get(agent.id) ?? agent);
+}
+
+function listWrfcChains(deps: ProcessModalDeps): WrfcChainLike[] {
+  const controller = deps.wrfcController as ProcessModalDeps['wrfcController'] & {
+    listChains?: () => unknown;
+  };
+  if (typeof controller.listChains !== 'function') return [];
+  try {
+    const value = controller.listChains();
+    return Array.isArray(value) ? value.filter(isWrfcChainLike) : [];
+  } catch {
+    return [];
+  }
+}
+
+function isWrfcChainLike(value: unknown): value is WrfcChainLike {
+  if (!value || typeof value !== 'object') return false;
+  const record = value as Record<string, unknown>;
+  return typeof record.id === 'string'
+    && typeof record.state === 'string'
+    && typeof record.task === 'string'
+    && typeof record.ownerAgentId === 'string';
+}
+
+function findChainForAgent(agent: AgentRecord, chains: WrfcChainLike[]): WrfcChainLike | null {
+  if (agent.wrfcId) {
+    const direct = chains.find((chain) => chain.id === agent.wrfcId);
+    if (direct) return direct;
+  }
+  return chains.find((chain) => isAgentInChain(agent, chain)) ?? null;
+}
+
+function isAgentInChain(agent: AgentRecord, chain: WrfcChainLike): boolean {
+  return chain.ownerAgentId === agent.id
+    || chain.engineerAgentId === agent.id
+    || chain.reviewerAgentId === agent.id
+    || chain.fixerAgentId === agent.id
+    || (chain.allAgentIds?.includes(agent.id) ?? false)
+    || agent.wrfcId === chain.id;
+}
+
+function inferWrfcRole(agent: AgentRecord, chain: WrfcChainLike): AgentRecord['wrfcRole'] {
+  if (agent.wrfcRole) return agent.wrfcRole;
+  if (chain.ownerAgentId === agent.id) return 'owner';
+  if (chain.engineerAgentId === agent.id) return 'engineer';
+  if (chain.reviewerAgentId === agent.id) return 'reviewer';
+  if (chain.fixerAgentId === agent.id) return 'fixer';
+  if (agent.template === 'reviewer') return 'reviewer';
+  return 'engineer';
+}
+
+function getAgentGroupKey(agent: AgentRecord, activeById: Map<string, AgentRecord>): string {
+  if (agent.wrfcId) return `wrfc:${agent.wrfcId}`;
+
+  const seen = new Set<string>();
+  let root = agent;
+  while (root.parentAgentId && activeById.has(root.parentAgentId) && !seen.has(root.parentAgentId)) {
+    seen.add(root.id);
+    root = activeById.get(root.parentAgentId)!;
+  }
+
+  // If the active root is an orphaned child, keep it anchored to its missing parent id
+  // so it does not jump to a new group when the parent exits before its children.
+  return `root:${root.parentAgentId ?? root.id}`;
+}
+
+function safeGetChain(wrfcId: string, deps: Pick<ProcessModalDeps, 'wrfcController'>): WrfcChainLike | null {
+  try {
+    const chain = deps.wrfcController.getChain(wrfcId);
+    return isWrfcChainLike(chain) ? chain : null;
+  } catch {
+    return null;
+  }
+}
+
 /** Get the original task description from a WRFC chain. */
 function getChainTask(wrfcId: string | undefined, deps: Pick<ProcessModalDeps, 'wrfcController'>): string | null {
   if (!wrfcId) return null;
-  try {
-    const chain = deps.wrfcController.getChain(wrfcId);
-    return chain?.task ?? null;
-  } catch { return null; }
+  return safeGetChain(wrfcId, deps)?.task ?? null;
 }
 
 /** Truncate to first line, capped at max chars. */
@@ -113,6 +468,8 @@ export class ProcessModal {
   public entries: ProcessEntry[] = [];
   private refreshTimer: ReturnType<typeof setInterval> | null = null;
   private onRefresh: (() => void) | null = null;
+  private groupOrder = new Map<string, number>();
+  private nextGroupOrder = 0;
 
   constructor(private readonly deps: ProcessModalDeps) {}
 
@@ -147,23 +504,14 @@ export class ProcessModal {
     const now = Date.now();
     const result: ProcessEntry[] = [];
 
-    // Agents — only show active (pending/running)
-    for (const a of manager.list()) {
-      if (a.status === 'completed' || a.status === 'failed' || a.status === 'cancelled') continue;
-      let streamSnippet: string | undefined;
-      if (a.streamingContent) {
-        const raw = a.streamingContent.replace(/\n/g, ' ').trim();
-        streamSnippet = raw.length > 60 ? '...' + raw.slice(-57) : raw;
-      }
-      result.push({
-        id: a.id,
-        label: buildAgentLabel(a, this.deps),
-        type: 'agent',
-        status: a.status,
-        elapsedMs: now - a.startedAt,
-        streamSnippet,
-      });
-    }
+    // Agents — only show active (pending/running), grouped by stable parent/child hierarchy.
+    result.push(...buildAgentEntries(
+      manager.list(),
+      this.deps,
+      now,
+      (key) => this.groupOrder.get(key),
+      (key) => this.ensureGroupOrder(key),
+    ));
 
     // Background exec processes — only show running
     const pm = this.deps.processManager;
@@ -187,6 +535,14 @@ export class ProcessModal {
     }
   }
 
+  private ensureGroupOrder(key: string): number {
+    const existing = this.groupOrder.get(key);
+    if (existing !== undefined) return existing;
+    const next = this.nextGroupOrder++;
+    this.groupOrder.set(key, next);
+    return next;
+  }
+
   moveUp(): void {
     if (this.entries.length === 0) return;
     this.selectedIndex = (this.selectedIndex - 1 + this.entries.length) % this.entries.length;
@@ -270,9 +626,10 @@ export function renderProcessModal(modal: ProcessModal, width: number, viewportH
     const dur = formatDuration(e.elapsedMs);
     const statusStr = e.streamSnippet ? `streaming  ${dur}` : `${e.status}  ${dur}`;
     const suffix = `  ${statusStr}`;
-    const maxDescW = maxLabelW - typeTag.length - suffix.length - 4; // icon + spaces
+    const treePrefix = e.treePrefix ?? '';
+    const maxDescW = maxLabelW - typeTag.length - treePrefix.length - suffix.length - 4; // icon + spaces
     const desc = e.label.length > maxDescW ? e.label.slice(0, Math.max(0, maxDescW - 3)) + '...' : e.label;
-    const label = `${statusIcon} ${typeTag} ${desc}${suffix}`;
+    const label = `${statusIcon} ${typeTag} ${treePrefix}${desc}${suffix}`;
     return {
       label,
       selected: absoluteIndex === modal.selectedIndex,

package/src/renderer/process-summary.ts

@@ -0,0 +1,67 @@
+export type ProcessSummaryAgent = {
+  readonly id: string;
+  readonly progress?: string;
+};
+
+export type RuntimeProcessSummaryAgent = {
+  readonly id: string;
+  readonly latestProgress?: string;
+};
+
+export type WrfcProcessSummaryChain = {
+  readonly state?: string;
+  readonly ownerAgentId?: string;
+  readonly engineerAgentId?: string;
+  readonly reviewerAgentId?: string;
+  readonly fixerAgentId?: string;
+  readonly allAgentIds?: readonly unknown[];
+};
+
+export type RunningAgentSummary = {
+  readonly count: number;
+  readonly progress?: string;
+};
+
+export function summarizeRunningAgents(
+  managerAgents: readonly ProcessSummaryAgent[],
+  runtimeAgents: readonly RuntimeProcessSummaryAgent[],
+  wrfcChains: readonly WrfcProcessSummaryChain[],
+): RunningAgentSummary {
+  const runningAgentIds = new Set<string>();
+  let progress: string | undefined;
+
+  for (const agent of managerAgents) {
+    runningAgentIds.add(agent.id);
+    if (!progress && agent.progress) progress = agent.progress;
+  }
+
+  for (const agent of runtimeAgents) {
+    runningAgentIds.add(agent.id);
+    if (!progress && agent.latestProgress) progress = agent.latestProgress;
+  }
+
+  for (const chain of wrfcChains) {
+    if (isTerminalWrfcState(chain.state)) continue;
+    const chainAgentIds = collectChainAgentIds(chain);
+    const hasVisibleChainWork = Array.from(chainAgentIds).some((id) => runningAgentIds.has(id));
+    if (!hasVisibleChainWork || !chain.ownerAgentId) continue;
+    runningAgentIds.add(chain.ownerAgentId);
+    if (!progress) progress = `WRFC chain ${chain.state ?? 'running'}`;
+  }
+
+  return { count: runningAgentIds.size, progress };
+}
+
+function isTerminalWrfcState(state: string | undefined): boolean {
+  return state === 'passed' || state === 'failed';
+}
+
+function collectChainAgentIds(chain: WrfcProcessSummaryChain): Set<string> {
+  return new Set([
+    chain.ownerAgentId,
+    chain.engineerAgentId,
+    chain.reviewerAgentId,
+    chain.fixerAgentId,
+    ...(chain.allAgentIds ?? []),
+  ].filter((id): id is string => typeof id === 'string' && id.length > 0));
+}