@pellux/goodvibes-tui 1.1.0 → 1.9.0

package/src/panels/cockpit-read-model.ts

@@ -1,238 +0,0 @@
-// ---------------------------------------------------------------------------
-// cockpit-read-model.ts
-//
-// TASK-046: Cockpit agent roster slice + cost/token aggregates + stalledAgentCount
-//
-// Provides a thin read-model over AgentManager.list() / getStatus() so the
-// CockpitPanel can display an agent roster without depending on the full
-// AgentInspectorPanel object.
-//
-// Design notes:
-//   - Per-agent cost delegates to calcSessionCost() from cost-utils.ts (canonical
-//     billing formula) and requires real usage data from AgentRecord.usage.  When
-//     usage is absent (agent spawned but not yet completed), cost/tokens show as n/a
-//     rather than fabricated values (39327f86 honest-UX standard).
-//   - stalledAgentCount delegates to countStalledAgents() from agent-inspector-shared.ts
-//     (canonical stall-count function extracted from TASK-046 review) — no reimplementation.
-//   - The read-model is a plain object (snapshot + subscribe) so it can be
-//     wired in tests without a full runtime.
-// ---------------------------------------------------------------------------
-
-import type { AgentRecord } from '@pellux/goodvibes-sdk/platform/tools';
-import { truncateDisplay } from '../utils/terminal-width.ts';
-import { calcSessionCost, isModelPriced } from '../export/cost-utils.ts';
-import {
-  AGENT_TERMINAL_STATUSES,
-  AGENT_STALL_THRESHOLD_MS,
-  countStalledAgents,
-  hasReportedUsage,
-} from './agent-inspector-shared.ts';
-
-// ---------------------------------------------------------------------------
-// Public types
-// ---------------------------------------------------------------------------
-
-/** Status of a single agent in the cockpit roster. */
-export type CockpitAgentStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
-
-/** A single row in the cockpit agent roster. */
-export interface CockpitAgentRosterEntry {
-  /** Full agent id. */
-  readonly id: string;
-  /** Short task description (truncated at 50 chars). */
-  readonly task: string;
-  /** Model identifier, or 'unknown' when not yet resolved. */
-  readonly model: string;
-  /** Agent lifecycle status. */
-  readonly status: CockpitAgentStatus;
-  /** True when the agent is non-terminal and has exceeded AGENT_STALL_THRESHOLD_MS. */
-  readonly stalled: boolean;
-  /** Input tokens consumed (including cache read+write), or null when unavailable. */
-  readonly inputTokens: number | null;
-  /** Output tokens produced, or null when unavailable. */
-  readonly outputTokens: number | null;
-  /** Estimated cost in USD, or null when token data is unavailable. */
-  readonly cost: number | null;
-}
-
-/** Aggregate snapshot produced by the cockpit roster read-model. */
-export interface CockpitRosterSnapshot {
-  /** All agents in the manager, newest-first by startedAt. */
-  readonly roster: readonly CockpitAgentRosterEntry[];
-  /** Number of non-terminal agents running past AGENT_STALL_THRESHOLD_MS. */
-  readonly stalledAgentCount: number;
-  /**
-   * Sum of all input tokens across agents with real usage data.
-   * null when NO agent has usage data yet (avoids showing 0 when data is simply absent).
-   */
-  readonly totalInputTokens: number | null;
-  /**
-   * Sum of all output tokens across agents with real usage data.
-   * null when NO agent has usage data yet.
-   */
-  readonly totalOutputTokens: number | null;
-  /**
-   * Total estimated cost in USD across agents with real pricing data.
-   * null when NO agent has priceable data yet.
-   */
-  readonly totalCost: number | null;
-}
-
-// ---------------------------------------------------------------------------
-// AgentManager minimal interface (subset used here)
-// ---------------------------------------------------------------------------
-
-export interface CockpitRosterAgentManager {
-  list(): AgentRecord[];
-}
-
-// ---------------------------------------------------------------------------
-// Snapshot builder — pure, testable
-// ---------------------------------------------------------------------------
-
-/**
- * Build a CockpitRosterSnapshot from a raw AgentRecord list.
- * Exported so unit tests can drive it directly without a manager stub.
- */
-export function buildCockpitRosterSnapshot(
-  records: AgentRecord[],
-  now: number = Date.now(),
-): CockpitRosterSnapshot {
-  // Sort newest-first by startedAt
-  const sorted = [...records].sort((a, b) => b.startedAt - a.startedAt);
-
-  let hasUsage = false;
-  let totalInputTokens = 0;
-  let totalOutputTokens = 0;
-  let totalCost = 0;
-
-  const roster: CockpitAgentRosterEntry[] = sorted.map((rec) => {
-    const isTerminal = AGENT_TERMINAL_STATUSES.has(rec.status);
-    const elapsed = now - rec.startedAt;
-    const stalled = !isTerminal && elapsed >= AGENT_STALL_THRESHOLD_MS;
-
-    let inputTokens: number | null = null;
-    let outputTokens: number | null = null;
-    let cost: number | null = null;
-
-    if (hasReportedUsage(rec.usage)) {
-      hasUsage = true;
-      const usage = rec.usage;
-      const inp =
-        usage.inputTokens +
-        (usage.cacheReadTokens ?? 0) +
-        (usage.cacheWriteTokens ?? 0);
-      const out = usage.outputTokens;
-      const agentCost = calcSessionCost(
-        usage.inputTokens,
-        usage.outputTokens,
-        usage.cacheReadTokens ?? 0,
-        usage.cacheWriteTokens ?? 0,
-        rec.model ?? 'unknown',
-      );
-
-      inputTokens = inp;
-      outputTokens = out;
-      // Usage exists but the model never resolved to a real price — reuse the
-      // existing "usage absent" null/n-a convention rather than showing a
-      // fabricated $0.00 (WO-315).
-      cost = isModelPriced(rec.model ?? 'unknown') ? agentCost : null;
-
-      totalInputTokens += inp;
-      totalOutputTokens += out;
-      totalCost += agentCost;
-    }
-
-    const task = truncateDisplay(rec.task, 50);
-
-    return {
-      id: rec.id,
-      task,
-      model: rec.model ?? 'unknown',
-      status: rec.status,
-      stalled,
-      inputTokens,
-      outputTokens,
-      cost,
-    };
-  });
-
-  return {
-    roster,
-    stalledAgentCount: countStalledAgents(sorted, now),
-    totalInputTokens: hasUsage ? totalInputTokens : null,
-    totalOutputTokens: hasUsage ? totalOutputTokens : null,
-    totalCost: hasUsage ? totalCost : null,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Read-model factory
-// ---------------------------------------------------------------------------
-
-/** Minimal read-model interface matching the existing UiReadModel shape. */
-export interface CockpitRosterReadModel {
-  getSnapshot(): CockpitRosterSnapshot;
-  /**
-   * Notify all subscribers that the roster has changed and the cockpit panel
-   * should re-render.  Wire this to an AgentManager event feed so live agent
-   * state changes propagate:
-   *
-   *   const roster = createCockpitRosterReadModel(agentManager);
-   *   agentEvents.subscribe(() => roster.markDirty());
-   *
-   * For static/test fixtures the implementation is a no-op.
-   */
-  markDirty(): void;
-  /**
-   * Subscribe to changes.  The listener is called whenever markDirty() is
-   * invoked.  Returns an unsubscribe function.
-   *
-   * For static/test fixtures, returns a no-op unsubscribe.
-   */
-  subscribe(listener: () => void): () => void;
-}
-
-/**
- * Create a live CockpitRosterReadModel backed by an AgentManager.
- *
- * The returned read-model re-derives its snapshot on every getSnapshot() call
- * so it always reflects the current agent state without needing an event bus.
- * Callers that want reactive updates should poll or wire in their own
- * event-driven markDirty() path.
- */
-export function createCockpitRosterReadModel(
-  agentManager: CockpitRosterAgentManager,
-): CockpitRosterReadModel {
-  const listeners = new Set<() => void>();
-
-  function markDirty(): void {
-    for (const listener of listeners) {
-      listener();
-    }
-  }
-
-  return {
-    getSnapshot(): CockpitRosterSnapshot {
-      return buildCockpitRosterSnapshot(agentManager.list());
-    },
-    markDirty,
-    subscribe(listener: () => void): () => void {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    },
-  };
-}
-
-/**
- * Create a static CockpitRosterReadModel for testing.
- */
-export function createStaticCockpitRosterReadModel(
-  snapshot: CockpitRosterSnapshot,
-): CockpitRosterReadModel {
-  return {
-    getSnapshot: () => snapshot,
-    markDirty: () => {},
-    subscribe: () => () => {},
-  };
-}

package/src/panels/communication-panel.ts

@@ -1,256 +0,0 @@
-import type { Line } from '../types/grid.ts';
-import { ScrollableListPanel } from './scrollable-list-panel.ts';
-import type { PanelIntegrationContext } from './types.ts';
-import type { UiCommunicationSnapshot, UiReadModel } from '../runtime/ui-read-models.ts';
-import { truncateDisplay } from '../utils/terminal-width.ts';
-import {
-  buildBodyText,
-  buildDetailBlock,
-  buildEmptyState,
-  buildGuidanceLine,
-  buildKeyValueLine,
-  buildKeyboardHints,
-  buildPanelLine,
-  buildPanelWorkspace,
-  buildStatusBadge,
-  DEFAULT_PANEL_PALETTE,
-  type PanelPalette,
-  type StatusBadgeKind,
-} from './polish.ts';
-import { createEmptyLine } from '../types/grid.ts';
-
-// Base chrome only — title band, state colors, and text tokens all come
-// straight from DEFAULT_PANEL_PALETTE (WO-002).
-const C = DEFAULT_PANEL_PALETTE;
-
-type CommunicationRecord = UiCommunicationSnapshot['records'][number];
-
-function statusBadgeKind(status: CommunicationRecord['status']): StatusBadgeKind {
-  return status === 'blocked' ? 'blocked' : status === 'delivered' ? 'completed' : 'running';
-}
-
-function fmtAgo(ts: number): string {
-  const sec = Math.max(0, Math.floor((Date.now() - ts) / 1000));
-  if (sec < 60) return `${sec}s`;
-  if (sec < 3600) return `${Math.floor(sec / 60)}m`;
-  return `${Math.floor(sec / 3600)}h`;
-}
-
-// Set by handleInput (enter/o) and consumed on the very next
-// handlePanelIntegrationAction dispatch of that same key — handleInput has
-// no access to the panelManager/openAgentDetail callback.
-type PendingCommunicationAction =
-  | { readonly kind: 'open-orchestration' }
-  | { readonly kind: 'open-agent-detail'; readonly agentId: string };
-
-export class CommunicationPanel extends ScrollableListPanel<CommunicationRecord> {
-  private readonly readModel?: UiReadModel<UiCommunicationSnapshot>;
-  private readonly unsub: (() => void) | null;
-  private readonly openAgentDetail?: (agentId: string) => void;
-  /** When true, the list is narrowed to blocked messages only (b toggles). */
-  private blockedOnly = false;
-  private pendingAction: PendingCommunicationAction | null = null;
-
-  public constructor(
-    readModel?: UiReadModel<UiCommunicationSnapshot>,
-    openAgentDetail?: (agentId: string) => void,
-  ) {
-    super('communication', 'Communication', 'Y', 'runtime-ops');
-    this.showSelectionGutter = true; // I5: non-color selection affordance
-    this.filterEnabled = true;
-    this.filterLabel = 'Filter messages';
-    this.readModel = readModel;
-    this.openAgentDetail = openAgentDetail;
-    this.unsub = readModel ? readModel.subscribe(() => this.markDirty()) : null;
-  }
-
-  public override onDestroy(): void {
-    this.unsub?.();
-  }
-
-  protected override getPalette(): PanelPalette {
-    return C;
-  }
-
-  protected getItems(): readonly CommunicationRecord[] {
-    if (!this.readModel) return [];
-    const records = this.readModel.getSnapshot().records;
-    return this.blockedOnly ? records.filter((r) => r.status === 'blocked') : records;
-  }
-
-  protected override filterMatches(record: CommunicationRecord, q: string): boolean {
-    return (record.content ?? '').toLowerCase().includes(q)
-      || record.kind.toLowerCase().includes(q)
-      || String(record.fromId ?? '').toLowerCase().includes(q)
-      || String(record.toId ?? '').toLowerCase().includes(q);
-  }
-
-  public override handleInput(key: string): boolean {
-    // `b` toggles the blocked-lanes-only view — guarded so it only acts when not
-    // typing into the filter input.
-    if (key === 'b' && !this.filterActive) {
-      this.blockedOnly = !this.blockedOnly;
-      this.selectedIndex = 0;
-      this.markDirty();
-      return true;
-    }
-    // Enter jumps to the orchestration workspace that actually produces this
-    // traffic (a direct panel jump, not a printed "/orchestration" signpost).
-    // Guarded so it doesn't hijack the filter input's commit-on-enter.
-    if ((key === 'enter' || key === 'return') && !this.filterActive) {
-      this.pendingAction = { kind: 'open-orchestration' };
-      return true;
-    }
-    // `o` on a blocked record opens the sender's agent detail (falling back
-    // to the receiver when the sender id is missing) via deps.openAgentDetail.
-    if (key === 'o' && !this.filterActive) {
-      const record = this.getSelectedItem();
-      if (!record || record.status !== 'blocked') return false;
-      const agentId = record.fromId || record.toId;
-      if (!agentId) return false;
-      this.pendingAction = { kind: 'open-agent-detail', agentId };
-      return true;
-    }
-    return super.handleInput(key);
-  }
-
-  public handlePanelIntegrationAction(_key: string, ctx: PanelIntegrationContext): boolean {
-    if (!this.pendingAction) return false;
-    const action = this.pendingAction;
-    this.pendingAction = null;
-    if (action.kind === 'open-orchestration') {
-      ctx.panelManager.open('orchestration');
-      return true;
-    }
-    this.openAgentDetail?.(action.agentId);
-    return true;
-  }
-
-  protected renderItem(record: CommunicationRecord, _index: number, selected: boolean, width: number): Line {
-    const bg = selected ? C.selectBg : undefined;
-    const badge = buildStatusBadge(statusBadgeKind(record.status), record.status)[0]!;
-    const route = truncateDisplay(`${record.fromId} → ${record.toId}`, 26);
-    const contentWidth = Math.max(0, width - 50);
-    // Blocked messages have no delivered content; surface the policy reason
-    // inline so the most important detail (why a lane is blocked) is visible
-    // without selecting the row.
-    const tail = record.status === 'blocked' && record.reason
-      ? { text: record.reason, fg: C.warn }
-      : { text: record.content, fg: C.dim };
-    return buildPanelLine(width, [
-      [' ', C.label, bg],
-      [`${fmtAgo(record.timestamp)} `.padStart(5), C.dim, bg],
-      [` ${badge.text} `.padEnd(12), badge.fg, bg],
-      [`${record.kind} `.padEnd(9), C.info, bg],
-      [`${route} `.padEnd(27), C.value, bg],
-      [truncateDisplay(tail.text, contentWidth), tail.fg, bg],
-    ]);
-  }
-
-  protected override getEmptyStateMessage(): string {
-    return ' No structured communication recorded yet.';
-  }
-
-  protected override getEmptyStateActions(): Array<{ command: string; summary: string }> {
-    return [
-      { command: '/orchestration', summary: 'review graphs and recursive agent activity that emit messages' },
-    ];
-  }
-
-  public render(width: number, height: number): Line[] {
-    const intro = 'Structured agent communication, routing policy outcomes, and delivery status across orchestration trees.';
-
-    if (!this.readModel) {
-      const workspace = buildPanelWorkspace(width, height, {
-        title: 'Communication Control Room',
-        intro,
-        sections: [{
-          lines: buildEmptyState(
-            width,
-            ' Runtime store not wired into this panel yet.',
-            'This workspace needs the live runtime store before it can show communication history and policy outcomes.',
-            [{ command: '/orchestration', summary: 'inspect recursive routing and agent activity while this workspace is unwired' }],
-            C,
-          ),
-        }],
-        palette: C,
-      });
-      while (workspace.length < height) workspace.push(createEmptyLine(width));
-      return workspace;
-    }
-
-    const snapshot = this.readModel.getSnapshot();
-    const records = this.getItems();
-
-    // Posture: blocked lanes / message flow surfaced first per the panel's purpose.
-    const postureLines = (): Line[] => [
-      buildPanelLine(width, [
-        ['  ', C.label],
-        ...buildStatusBadge('blocked', 'blocked', { count: snapshot.totalBlocked }),
-        ['    ', C.dim],
-        ...buildStatusBadge('completed', 'delivered', { count: snapshot.totalDelivered }),
-        ['    ', C.dim],
-        ...buildStatusBadge('running', 'sent', { count: snapshot.totalSent }),
-        ...(this.blockedOnly ? ([['   (blocked-only view)', C.warn]] as Array<[string, string]>) : []),
-      ]),
-      snapshot.totalBlocked > 0
-        ? buildPanelLine(width, [[`  ${snapshot.totalBlocked} message${snapshot.totalBlocked !== 1 ? 's' : ''} blocked by routing policy — press b to isolate blocked lanes.`, C.warn]])
-        : buildPanelLine(width, [['  No blocked lanes — press Enter on a record to inspect routing in the orchestration console.', C.dim]]),
-    ];
-
-    if (records.length === 0) {
-      return this.renderList(width, height, {
-        title: 'Communication Control Room',
-        header: postureLines(),
-        footer: [buildKeyboardHints(width, this.footerHints(false), C)],
-      });
-    }
-
-    this.clampSelection();
-    const selected = this.getSelectedItem();
-
-    const detailLines: Line[] = [];
-    if (selected) {
-      detailLines.push(...buildDetailBlock(width, `Message · ${selected.kind}`, [
-        buildKeyValueLine(width, [
-          { label: 'status', value: selected.status, valueColor: selected.status === 'blocked' ? C.bad : C.good },
-          { label: 'scope', value: selected.scope, valueColor: C.value },
-          { label: 'when', value: `${fmtAgo(selected.timestamp)} ago`, valueColor: C.dim },
-        ], C),
-        buildKeyValueLine(width, [
-          { label: 'from', value: `${selected.fromId} (${selected.fromRole ?? 'unknown'})`, valueColor: C.value },
-          { label: 'to', value: `${selected.toId} (${selected.toRole ?? 'unknown'})`, valueColor: C.value },
-        ], C),
-        ...(selected.reason
-          ? buildBodyText(width, `blocked: ${selected.reason}`, C, C.warn)
-          : []),
-        ...buildBodyText(width, selected.content, C, C.value),
-      ], C));
-    }
-
-    return this.renderList(width, height, {
-      title: 'Communication Control Room',
-      header: postureLines(),
-      footer: [...detailLines, buildKeyboardHints(width, this.footerHints(true, selected?.status === 'blocked'), C)],
-    });
-  }
-
-  // Context-aware hints: filter keys reflect filter state, `b` reflects the
-  // blocked-only toggle, `o` only appears on a blocked selection, and the
-  // inspect hint only appears when rows exist.
-  private footerHints(hasRows: boolean, onBlockedSelection = false): Array<{ keys: string; label: string }> {
-    const hints: Array<{ keys: string; label: string }> = [];
-    if (hasRows) hints.push({ keys: '↑/↓', label: 'select' });
-    hints.push({ keys: 'Enter', label: 'orchestration' });
-    if (onBlockedSelection) hints.push({ keys: 'o', label: 'sender detail' });
-    hints.push({ keys: 'b', label: this.blockedOnly ? 'show all lanes' : 'blocked only' });
-    if (this.filterActive) {
-      hints.push({ keys: 'Esc', label: 'clear filter' });
-    } else if (this.filterQuery) {
-      hints.push({ keys: '/', label: 'edit filter' }, { keys: 'Esc', label: 'clear filter' });
-    } else {
-      hints.push({ keys: '/', label: 'filter' });
-    }
-    return hints;
-  }
-}