@pellux/goodvibes-tui 0.21.0 → 0.23.0

package/src/panels/agent-inspector-panel.ts

@@ -21,6 +21,10 @@ import {
   resolveScrollablePanelSection,
   DEFAULT_PANEL_PALETTE,
 } from './polish.ts';
+import {
+  type ConfirmState,
+  handleConfirmInput,
+} from './confirm-state.ts';
 import { truncateDisplay } from '../utils/terminal-width.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import {
@@ -32,6 +36,8 @@ import {
   formatAgentDuration as formatMs,
   formatAgentTime as shortTime,
   jsonlToTimeline,
+  AGENT_TERMINAL_STATUSES,
+  AGENT_STALL_THRESHOLD_MS,
 } from './agent-inspector-shared.ts';
 
 // ---------------------------------------------------------------------------
@@ -77,10 +83,14 @@ const COLOR = {
 // AgentInspectorPanel
 // ---------------------------------------------------------------------------
 
+// AGENT_TERMINAL_STATUSES and AGENT_STALL_THRESHOLD_MS imported from agent-inspector-shared.ts
+
 export interface AgentInspectorPanelDeps {
-  readonly agentManager: Pick<AgentManager, 'list' | 'getStatus'>;
+  readonly agentManager: Pick<AgentManager, 'list' | 'getStatus' | 'cancel'>;
   readonly agentMessageBus: Pick<AgentMessageBus, 'getMessages'>;
   readonly workingDirectory: string;
+  /** Cancel the agent by id. Uses the same orphan-free path as WRFC. Returns true if cancelled. */
+  readonly cancelAgent: (agentId: string) => boolean;
 }
 
 export class AgentInspectorPanel extends BasePanel {
@@ -102,6 +112,9 @@ export class AgentInspectorPanel extends BasePanel {
   // Row cache — cleared on markDirty(), computed once per render cycle
   private _cachedRows: DisplayRow[] | null = null;
 
+  /** Pending cancel confirmation — subject is the agent id to cancel. */
+  private confirmCancel: ConfirmState<string> | null = null;
+
   constructor(private readonly deps: AgentInspectorPanelDeps) {
     super('inspector', 'Inspector', 'I', 'agent');
   }
@@ -157,13 +170,36 @@ export class AgentInspectorPanel extends BasePanel {
   // -------------------------------------------------------------------------
 
   handleInput(key: string): boolean {
+    // Confirm-cancel flow takes priority — same contract as WRFC panel.
+    if (this.confirmCancel) {
+      const result = handleConfirmInput(this.confirmCancel, key);
+      if (result === 'confirmed') {
+        const rec = this.selectedAgentId
+          ? this.deps.agentManager.getStatus(this.selectedAgentId)
+          : null;
+        if (rec && !AGENT_TERMINAL_STATUSES.has(rec.status)) {
+          this.deps.cancelAgent(rec.id);
+        }
+        this.confirmCancel = null;
+        this.markDirty();
+        return true;
+      }
+      if (result === 'cancelled') {
+        this.confirmCancel = null;
+        this.markDirty();
+      }
+      // absorbed: confirm stays pending
+      return true;
+    }
+
     switch (key) {
-      case 'up':       this._moveCursor(-1); return true;
-      case 'down':     this._moveCursor(1);  return true;
-      case 'pageup':   this._scroll(-10);    return true;
-      case 'pagedown': this._scroll(10);     return true;
-      case 'return':   this._toggleExpand(); return true;
-      case 'tab':      this._nextAgent();    return true;
+      case 'up':       this._moveCursor(-1);         return true;
+      case 'down':     this._moveCursor(1);           return true;
+      case 'pageup':   this._scroll(-10);             return true;
+      case 'pagedown': this._scroll(10);              return true;
+      case 'return':   this._toggleExpand();          return true;
+      case 'tab':      this._nextAgent();             return true;
+      case 'c':        this._beginCancelConfirm();    return true;
       default:         return false;
     }
   }
@@ -217,6 +253,11 @@ export class AgentInspectorPanel extends BasePanel {
     }
 
     summaryLines.push(this._renderAgentInfoSummary(width, rec));
+    const now = Date.now();
+    const isStalled = this._isAgentStalled(rec, now);
+    if (isStalled) {
+      summaryLines.push(buildPanelLine(width, [['  STALLED', '#f59e0b'], [' — no activity for 5+ minutes', DEFAULT_PANEL_PALETTE.dim]]));
+    }
     const allRows = this._getCachedRows();
     if (allRows.length === 0) {
       return buildPanelWorkspace(width, height, {
@@ -243,13 +284,42 @@ export class AgentInspectorPanel extends BasePanel {
     }
 
     this.cursorIndex = Math.max(0, Math.min(this.cursorIndex, allRows.length - 1));
+    const selectedRec = this.selectedAgentId
+      ? this.deps.agentManager.getStatus(this.selectedAgentId)
+      : null;
+    const cancellable = selectedRec && !AGENT_TERMINAL_STATUSES.has(selectedRec.status);
     const summarySection = { title: 'Summary', lines: summaryLines } as const;
     const agentsSection = { title: 'Agents', lines: [selectorLine] } as const;
+
+    // Confirm-cancel overlay section.
+    const confirmSection = this.confirmCancel ? {
+      title: 'Confirm Cancel',
+      lines: [
+        buildPanelLine(width, [
+          [' Cancel agent "', DEFAULT_PANEL_PALETTE.warn],
+          [this.confirmCancel.label, DEFAULT_PANEL_PALETTE.value],
+          ['"?', DEFAULT_PANEL_PALETTE.warn],
+        ]),
+        buildPanelLine(width, [
+          [' y', DEFAULT_PANEL_PALETTE.info], ['  confirm', DEFAULT_PANEL_PALETTE.dim],
+          ['   Enter', DEFAULT_PANEL_PALETTE.info], ['  confirm', DEFAULT_PANEL_PALETTE.dim],
+          ['   n / Esc', DEFAULT_PANEL_PALETTE.info], ['  cancel', DEFAULT_PANEL_PALETTE.dim],
+        ]),
+      ],
+    } : null;
+
+    const cancelHintFg = cancellable ? DEFAULT_PANEL_PALETTE.info : DEFAULT_PANEL_PALETTE.dim;
+    const footerLine = buildPanelLine(width, [
+      [` L${this.cursorIndex + 1}/${allRows.length}`, DEFAULT_PANEL_PALETTE.dim],
+      ['   Tab', DEFAULT_PANEL_PALETTE.info], [' cycle agents', DEFAULT_PANEL_PALETTE.dim],
+      ['   Up/Down', DEFAULT_PANEL_PALETTE.info], [' navigate', DEFAULT_PANEL_PALETTE.dim],
+      ['   Enter', DEFAULT_PANEL_PALETTE.info], [' expand', DEFAULT_PANEL_PALETTE.dim],
+      ['   c', cancelHintFg], [cancellable ? ' cancel' : ' cancel (n/a)', DEFAULT_PANEL_PALETTE.dim],
+    ]);
+
     const timelineSection = resolveScrollablePanelSection(width, height, {
       intro: 'Inspect a selected agent timeline, tool activity, expanded details, and live/historical message flow.',
-      footerLines: [
-        buildPanelLine(width, [[` L${this.cursorIndex + 1}/${allRows.length}`, DEFAULT_PANEL_PALETTE.dim], ['   Tab', DEFAULT_PANEL_PALETTE.info], [' cycle agents', DEFAULT_PANEL_PALETTE.dim], ['   Up/Down', DEFAULT_PANEL_PALETTE.info], [' navigate', DEFAULT_PANEL_PALETTE.dim], ['   Enter', DEFAULT_PANEL_PALETTE.info], [' expand', DEFAULT_PANEL_PALETTE.dim]]),
-      ],
+      footerLines: [footerLine],
       palette: DEFAULT_PANEL_PALETTE,
       beforeSections: [summarySection, agentsSection],
       section: {
@@ -259,20 +329,22 @@ export class AgentInspectorPanel extends BasePanel {
         scrollOffset: this.scrollOffset,
         minRows: 8,
       },
+      afterSections: confirmSection ? [confirmSection] : undefined,
     });
     this.scrollOffset = timelineSection.scrollOffset;
 
+    const sections = [
+      summarySection,
+      agentsSection,
+      timelineSection.section,
+      ...(confirmSection ? [confirmSection] : []),
+    ];
+
     return buildPanelWorkspace(width, height, {
       title: ` Inspector [${agents.length} agent${agents.length !== 1 ? 's' : ''}]`,
       intro: 'Inspect a selected agent timeline, tool activity, expanded details, and live/historical message flow.',
-      sections: [
-        summarySection,
-        agentsSection,
-        timelineSection.section,
-      ],
-      footerLines: [
-        buildPanelLine(width, [[` L${this.cursorIndex + 1}/${allRows.length}`, DEFAULT_PANEL_PALETTE.dim], ['   Tab', DEFAULT_PANEL_PALETTE.info], [' cycle agents', DEFAULT_PANEL_PALETTE.dim], ['   Up/Down', DEFAULT_PANEL_PALETTE.info], [' navigate', DEFAULT_PANEL_PALETTE.dim], ['   Enter', DEFAULT_PANEL_PALETTE.info], [' expand', DEFAULT_PANEL_PALETTE.dim]]),
-      ],
+      sections,
+      footerLines: [footerLine],
       palette: DEFAULT_PANEL_PALETTE,
     });
   }
@@ -517,4 +589,34 @@ export class AgentInspectorPanel extends BasePanel {
       this.inspectAgent(next.id);
     }
   }
+
+  // -------------------------------------------------------------------------
+  // Private — cancel + stall
+  // -------------------------------------------------------------------------
+
+  /** Initiate cancel-confirm flow for the selected agent (noop if terminal or none selected). */
+  private _beginCancelConfirm(): void {
+    if (!this.selectedAgentId) return;
+    const rec = this.deps.agentManager.getStatus(this.selectedAgentId);
+    if (!rec || AGENT_TERMINAL_STATUSES.has(rec.status)) return;
+    const label = rec.task.split('\n')[0]?.slice(0, 40) ?? rec.id.slice(-8);
+    this.confirmCancel = { subject: rec.id, label };
+    this.markDirty();
+  }
+
+  /** Returns whether an agent is considered stalled (non-terminal, running past threshold). */
+  private _isAgentStalled(rec: AgentRecord, now: number): boolean {
+    if (AGENT_TERMINAL_STATUSES.has(rec.status)) return false;
+    return (now - rec.startedAt) >= AGENT_STALL_THRESHOLD_MS;
+  }
+
+  /**
+   * Count of all tracked agents that are stalled (non-terminal, no activity
+   * for AGENT_STALL_THRESHOLD_MS). Exposed so callers can aggregate a
+   * stalledAgentCount for cockpit / roster read-models.
+   */
+  getStalledAgentCount(): number {
+    const now = Date.now();
+    return this.deps.agentManager.list().filter(rec => this._isAgentStalled(rec, now)).length;
+  }
 }

package/src/panels/agent-inspector-shared.ts

@@ -1,5 +1,34 @@
 export type AgentInspectorEntryKind = 'user' | 'assistant' | 'tool_call' | 'tool_result' | 'session' | 'error';
 
+// ---------------------------------------------------------------------------
+// Shared agent status / stall constants
+// Used by AgentInspectorPanel, AgentDetailModal, and cockpit read-model consumers.
+// ---------------------------------------------------------------------------
+
+/** Terminal statuses — cancel not offered; stall check skipped. */
+export const AGENT_TERMINAL_STATUSES = new Set(['completed', 'failed', 'cancelled']);
+
+/** Agents in a non-terminal state for longer than this are considered STALLED. */
+export const AGENT_STALL_THRESHOLD_MS = 5 * 60 * 1000;
+
+/**
+ * Count stalled agents from a raw record list.
+ * An agent is stalled when it is non-terminal and has been running for at
+ * least AGENT_STALL_THRESHOLD_MS without completing.
+ *
+ * Extracted as a standalone export so read-models and panels can share the
+ * canonical stall-count logic (TASK-046).
+ */
+export function countStalledAgents(
+  records: ReadonlyArray<{ status: string; startedAt: number }>,
+  now: number = Date.now(),
+): number {
+  return records.filter(
+    (r) => !AGENT_TERMINAL_STATUSES.has(r.status) && (now - r.startedAt) >= AGENT_STALL_THRESHOLD_MS,
+  ).length;
+}
+
+
 export interface AgentTimelineEntry {
   kind: AgentInspectorEntryKind;
   timestamp: number;

package/src/panels/builtin/development.ts

@@ -51,6 +51,7 @@ export function registerDevelopmentPanels(manager: PanelManager, deps: ResolvedB
         agentManager: ui.agents.agentManager,
         agentMessageBus: ui.agents.agentMessageBus,
         workingDirectory: ui.environment.workingDirectory,
+        cancelAgent: (agentId: string) => ui.agents.agentManager.cancel(agentId),
       });
     },
   });

package/src/panels/builtin/knowledge.ts

@@ -1,26 +1,27 @@
 import type { PanelManager } from '../panel-manager.ts';
 import { MemoryPanel } from '../memory-panel.ts';
-import { KnowledgePanel } from '../knowledge-panel.ts';
+import { KnowledgeGraphPanel } from '../knowledge-graph-panel.ts';
 import type { ResolvedBuiltinPanelDeps } from './shared.ts';
 
 export function registerKnowledgePanels(manager: PanelManager, deps: ResolvedBuiltinPanelDeps): void {
-  if (!deps.memoryRegistry) return;
-
-  const { memoryRegistry } = deps;
+  // KnowledgeGraphPanel is a no-arg panel — always register it regardless of memoryRegistry.
   manager.registerType({
     id: 'knowledge',
     name: 'Knowledge',
     icon: 'K',
     category: 'agent',
     description: 'Structured project knowledge: risks, runbooks, architecture notes, incidents, and durable facts',
-    factory: () => new KnowledgePanel(memoryRegistry),
-  });
-  manager.registerType({
-    id: 'memory',
-    name: 'Memory',
-    icon: 'M',
-    category: 'agent',
-    description: 'Project memory: decisions, constraints, incidents, and patterns with provenance links',
-    factory: () => new MemoryPanel(memoryRegistry),
+    factory: () => new KnowledgeGraphPanel(),
   });
+  if (deps.memoryRegistry) {
+    const { memoryRegistry } = deps;
+    manager.registerType({
+      id: 'memory',
+      name: 'Memory',
+      icon: 'M',
+      category: 'agent',
+      description: 'Project memory: decisions, constraints, incidents, and patterns with provenance links',
+      factory: () => new MemoryPanel(memoryRegistry),
+    });
+  }
 }

package/src/panels/builtin/operations.ts

@@ -37,6 +37,7 @@ import {
 import { createRuntimeProviderApi } from '@/runtime/index.ts';
 import type { ResolvedBuiltinPanelDeps } from './shared.ts';
 import { requireAutomationManager, requireControlPlanePanelDeps, requireHookPanelDeps, requirePluginManager, requireUiServices } from './shared.ts';
+import { createCockpitRosterReadModel } from '../cockpit-read-model.ts';
 
 export function registerOperationsPanels(manager: PanelManager, deps: ResolvedBuiltinPanelDeps): void {
   const ui = requireUiServices(deps);
@@ -52,13 +53,33 @@ export function registerOperationsPanels(manager: PanelManager, deps: ResolvedBu
     environment: createEnvironmentVariableQuery(process.env),
   });
 
+  const rosterReadModel = createCockpitRosterReadModel(ui.agents.agentManager);
+  // Subscribe to agent lifecycle events so the roster re-renders on state changes.
+  // AGENT_RUNNING covers status transitions; AGENT_CANCELLED covers the cancellation
+  // terminal state not emitted by AGENT_FAILED. Noisy mid-run events (STREAM_DELTA,
+  // AWAITING_TOOL, etc.) are intentionally excluded — they don't affect roster fields.
+  // Note: stall detection is time-based, so stalled/stalledAgentCount will only refresh
+  // on the next lifecycle event; a periodic tick would be needed for real-time stall display.
+  ui.events.agents.on('AGENT_SPAWNING', () => rosterReadModel.markDirty());
+  ui.events.agents.on('AGENT_RUNNING', () => rosterReadModel.markDirty());
+  ui.events.agents.on('AGENT_COMPLETED', () => rosterReadModel.markDirty());
+  ui.events.agents.on('AGENT_FAILED', () => rosterReadModel.markDirty());
+  ui.events.agents.on('AGENT_CANCELLED', () => rosterReadModel.markDirty());
+
   manager.registerType({
     id: 'cockpit',
     name: 'Cockpit',
     icon: 'O',
     category: 'monitoring',
     description: 'Unified operator summary for orchestration, permissions, communication, MCP, plugins, and integrations',
-    factory: () => new CockpitPanel(ui.readModels.cockpit),
+    factory: () => new CockpitPanel(
+      ui.readModels.cockpit,
+      rosterReadModel,
+      {
+        openAgentDetail: (agentId: string) => deps.openAgentDetail?.(agentId),
+        cancelAgent: (agentId: string) => ui.agents.agentManager.cancel(agentId),
+      },
+    ),
   });
 
   manager.registerType({

package/src/panels/builtin/shared.ts

@@ -114,6 +114,13 @@ export interface BuiltinPanelDeps {
   hookActivityTracker?: Pick<HookActivityTracker, 'listRecent'>;
   /** Shared MCP registry for security panels and MCP workspace commands. */
   mcpRegistry?: McpRegistry;
+  /**
+   * Open the agent detail modal for the given agent id.  Wired from
+   * InputHandler.agentDetailModal.open() at bootstrap — passed to the
+   * CockpitPanel factory so the agents workspace inspect key (i) works
+   * without the panel depending on the modal directly.
+   */
+  openAgentDetail?: (agentId: string) => void;
 }
 
 export type ResolvedBuiltinPanelDeps = Omit<

package/src/panels/cockpit-panel.ts

@@ -2,6 +2,7 @@ import type { Line } from '../types/grid.ts';
 import { createEmptyLine } from '../types/grid.ts';
 import { BasePanel } from './base-panel.ts';
 import type { UiCockpitSnapshot, UiReadModel } from '../runtime/ui-read-models.ts';
+import type { CockpitRosterReadModel } from './cockpit-read-model.ts';
 import {
   buildGuidanceLine,
   buildKeyValueLine,
@@ -11,6 +12,7 @@ import {
   DEFAULT_PANEL_PALETTE,
   type PanelWorkspaceSection,
 } from './polish.ts';
+import { agentStatusColor } from './agent-inspector-shared.ts';
 
 const C = {
   ...DEFAULT_PANEL_PALETTE,
@@ -24,45 +26,160 @@ function pickColor(value: number, warnAt = 1, badAt = 3): string {
   return C.good;
 }
 
-const WORKSPACE_IDS = ['flow', 'governance', 'health', 'domains'] as const;
+export interface CockpitPanelActionCallbacks {
+  readonly openAgentDetail: (agentId: string) => void;
+  readonly cancelAgent: (agentId: string) => boolean;
+}
+
+const WORKSPACE_IDS = ['flow', 'governance', 'health', 'domains', 'agents'] as const;
+type WorkspaceId = (typeof WORKSPACE_IDS)[number];
+
+function formatCost(cost: number | null): string {
+  if (cost === null) return 'n/a';
+  return cost < 0.01 ? '<$0.01' : `$${cost.toFixed(2)}`;
+}
 
 export class CockpitPanel extends BasePanel {
   private readonly unsub: (() => void) | null;
+  private readonly rosterUnsub: (() => void) | null;
+  private readonly actionCallbacks: CockpitPanelActionCallbacks;
   private selectedWorkspaceIndex = 0;
+  private agentCursorIndex = 0;
+  private pendingCancelId: string | null = null;
 
-  public constructor(private readonly readModel?: UiReadModel<UiCockpitSnapshot>) {
+  public constructor(
+    private readonly readModel?: UiReadModel<UiCockpitSnapshot>,
+    private readonly rosterReadModel?: CockpitRosterReadModel,
+    actionCallbacks?: Partial<CockpitPanelActionCallbacks>,
+  ) {
     super('cockpit', 'Cockpit', 'O', 'monitoring');
     this.unsub = readModel ? readModel.subscribe(() => this.markDirty()) : null;
+    this.rosterUnsub = rosterReadModel ? rosterReadModel.subscribe(() => this.markDirty()) : null;
+    this.actionCallbacks = {
+      openAgentDetail: actionCallbacks?.openAgentDetail ?? ((_id: string) => { /* noop */ }),
+      cancelAgent: actionCallbacks?.cancelAgent ?? ((_id: string) => false),
+    };
   }
 
   public override onDestroy(): void {
     this.unsub?.();
+    this.rosterUnsub?.();
+  }
+
+  private get selectedWorkspace(): WorkspaceId {
+    return WORKSPACE_IDS[this.selectedWorkspaceIndex] ?? 'flow';
   }
 
   public handleInput(key: string): boolean {
+    // Confirm-cancel absorb: when a cancel is pending, only y/enter confirm, escape/n dismiss, everything else is consumed
+    if (this.pendingCancelId !== null) {
+      if (key === 'y' || key === 'enter' || key === 'return') {
+        this.actionCallbacks.cancelAgent(this.pendingCancelId);
+        this.pendingCancelId = null;
+        this.markDirty();
+      } else if (key === 'escape' || key === 'n') {
+        this.pendingCancelId = null;
+        this.markDirty();
+      }
+      // All other keys are consumed while confirm is pending
+      return true;
+    }
     if (key === 'left' || key === 'h') {
       this.selectedWorkspaceIndex = Math.max(0, this.selectedWorkspaceIndex - 1);
+      this.agentCursorIndex = 0;
       this.markDirty();
       return true;
     }
     if (key === 'right' || key === 'l') {
       this.selectedWorkspaceIndex = Math.min(WORKSPACE_IDS.length - 1, this.selectedWorkspaceIndex + 1);
+      this.agentCursorIndex = 0;
       this.markDirty();
       return true;
     }
     if (key === 'home') {
       this.selectedWorkspaceIndex = 0;
+      this.agentCursorIndex = 0;
       this.markDirty();
       return true;
     }
     if (key === 'end') {
       this.selectedWorkspaceIndex = WORKSPACE_IDS.length - 1;
+      this.agentCursorIndex = 0;
       this.markDirty();
       return true;
     }
+    // Agents workspace: cursor movement, inspect, and cancel-initiation
+    if (this.selectedWorkspace === 'agents') {
+      const roster = this.rosterReadModel?.getSnapshot().roster ?? [];
+      if (key === 'up' || key === 'k') {
+        this.agentCursorIndex = Math.max(0, this.agentCursorIndex - 1);
+        this.markDirty();
+        return true;
+      }
+      if (key === 'down' || key === 'j') {
+        this.agentCursorIndex = Math.min(Math.max(0, roster.length - 1), this.agentCursorIndex + 1);
+        this.markDirty();
+        return true;
+      }
+      if (key === 'i' || key === 'enter' || key === 'return') {
+        const entry = roster[this.agentCursorIndex];
+        if (entry) {
+          this.actionCallbacks.openAgentDetail(entry.id);
+        }
+        return true;
+      }
+      if (key === 'c') {
+        const entry = roster[this.agentCursorIndex];
+        if (entry && !this.isTerminal(entry.status)) {
+          this.pendingCancelId = entry.id;
+          this.markDirty();
+        }
+        return true;
+      }
+    }
     return false;
   }
 
+  private isTerminal(status: string): boolean {
+    return status === 'completed' || status === 'failed' || status === 'cancelled';
+  }
+
+  private renderAgentsWorkspace(width: number): Line[] {
+    const lines: Line[] = [];
+    if (!this.rosterReadModel) {
+      lines.push(buildPanelLine(width, [[' Agent roster read model not wired.', C.empty]]));
+      return lines;
+    }
+    const { roster, stalledAgentCount, totalCost } = this.rosterReadModel.getSnapshot();
+    lines.push(buildPanelLine(width, [
+      [` ${roster.length} agent${roster.length !== 1 ? 's' : ''}`, C.label],
+      stalledAgentCount > 0 ? [`  ${stalledAgentCount} stalled`, C.bad] : ['', C.dim],
+      [`  cost: ${formatCost(totalCost)}`, C.dim],
+    ]));
+    const colors: Record<string, string> = {
+      pending: C.dim, running: C.value, completed: C.good, failed: C.bad, cancelled: C.dim, system: C.dim,
+    };
+    for (let i = 0; i < roster.length; i++) {
+      const entry = roster[i]!;
+      const cursor = i === this.agentCursorIndex ? '>' : ' ';
+      const shortId = entry.id.length > 8 ? entry.id.slice(-8) : entry.id;
+      const statusColor = agentStatusColor(entry.status, colors);
+      const stalledBadge: [string, string] = entry.stalled ? [' STALLED', C.bad] : ['', C.dim];
+      lines.push(buildPanelLine(width, [
+        [cursor, i === this.agentCursorIndex ? C.value : C.dim],
+        [` ${shortId} `, C.dim],
+        [entry.status, statusColor],
+        stalledBadge,
+        ['  ', C.dim],
+        [entry.task.slice(0, Math.max(0, width - 30)), C.label],
+      ]));
+    }
+    if (roster.length === 0) {
+      lines.push(buildPanelLine(width, [[' No agents tracked yet.', C.empty]]));
+    }
+    return lines;
+  }
+
   public render(width: number, height: number): Line[] {
     this.needsRender = false;
 
@@ -153,7 +270,7 @@ export class CockpitPanel extends BasePanel {
       ], C));
       workspaceLines.push(buildGuidanceLine(width, '/incident latest', 'inspect the latest incident bundle and replay fallout', C));
       workspaceLines.push(buildGuidanceLine(width, '/plugins', 'review errored plugins and provenance posture', C));
-    } else {
+    } else if (selectedWorkspace === 'domains') {
       workspaceLines.push(buildKeyValueLine(width, [
         { label: 'tasks', value: String(snapshot.taskCount), valueColor: C.value },
         { label: 'comms', value: String(snapshot.communicationCount), valueColor: C.value },
@@ -161,6 +278,9 @@ export class CockpitPanel extends BasePanel {
       ], C));
       workspaceLines.push(buildGuidanceLine(width, '/mcp', 'inspect trust, quarantine, and risky server posture', C));
       workspaceLines.push(buildGuidanceLine(width, '/communication', 'review blocked lanes and agent message flow', C));
+    } else {
+      // 'agents' workspace — roster from rosterReadModel
+      workspaceLines.push(...this.renderAgentsWorkspace(width));
     }
 
     const sections: PanelWorkspaceSection[] = [