@pellux/goodvibes-tui 0.27.0 → 0.29.0

package/src/panels/builtin/shared.ts

@@ -8,7 +8,7 @@ import type { ApprovalBroker, SharedSessionBroker } from '@pellux/goodvibes-sdk/
 import type { AutomationManager } from '@pellux/goodvibes-sdk/platform/automation';
 import type { ControlPlaneRecentEvent } from '@pellux/goodvibes-sdk/platform/control-plane';
 import type { UiRuntimeServices } from '../../runtime/ui-services.ts';
-import type { PluginManagerObserver } from '@pellux/goodvibes-sdk/platform/plugins';
+import type { PluginManagerControls } from '../plugins-panel.ts';
 import type { HookWorkbench } from '@pellux/goodvibes-sdk/platform/hooks';
 import type { HookDispatcher } from '@pellux/goodvibes-sdk/platform/hooks';
 import type { HookActivityTracker } from '@pellux/goodvibes-sdk/platform/hooks';
@@ -25,6 +25,15 @@ import type { ApiTokenAuditor } from '@pellux/goodvibes-sdk/platform/security';
 import type { ComponentHealthMonitor } from '../../runtime/perf/panel-health-monitor.ts';
 import type { WorktreeRegistry } from '@/runtime/index.ts';
 import type { SandboxSessionRegistry } from '@/runtime/index.ts';
+import type { OpsApi, PlanRuntimeService } from '@/runtime/index.ts';
+import type { WatcherRegistry } from '@pellux/goodvibes-sdk/platform/watchers';
+import type { RuntimeStore } from '../../runtime/store/index.ts';
+import type { KnowledgeApi } from '@pellux/goodvibes-sdk/platform/knowledge';
+import type { SessionChangeTracker } from '@pellux/goodvibes-sdk/platform/sessions';
+import type { Line } from '../../types/grid.ts';
+import type { Panel, PanelCategory } from '../types.ts';
+import { BasePanel } from '../base-panel.ts';
+import { buildEmptyState, buildPanelWorkspace, DEFAULT_PANEL_PALETTE } from '../polish.ts';
 
 export interface BuiltinPanelDeps {
   /** Config manager for settings-sync and other config-backed panels. */
@@ -45,7 +54,7 @@ export interface BuiltinPanelDeps {
   subscriptionManager?: SubscriptionManager;
   /** Shared service registry for services-backed panels. */
   serviceRegistry?: ServiceRegistry;
-  /** Context window size in tokens (for ContextVisualizerPanel). */
+  /** Context window size in tokens. Unused since WO-113 folded ContextVisualizerPanel into TokenBudgetPanel (which reads getCtxWindow instead); kept for source compatibility. */
   contextWindow?: number;
   /** Main Orchestrator instance for TokenBudgetPanel.wire(). */
   orchestrator?: Orchestrator;
@@ -104,8 +113,8 @@ export interface BuiltinPanelDeps {
   systemMessagesPanel?: import('../system-messages-panel.ts').SystemMessagesPanel;
   /** Explicit UI-facing runtime services for agent/process/WRFC/remote panels and modals. */
   uiServices?: UiRuntimeServices;
-  /** Shared plugin manager observer for plugin and security panels. */
-  pluginManager?: PluginManagerObserver;
+  /** Shared plugin manager for plugin and security panels (widened past the read-only observer surface — WO-134 — so PluginsPanel can drive enable/disable/verify/lift-quarantine). */
+  pluginManager?: PluginManagerControls;
   /** Shared hook dispatcher for the hooks control-room panel. */
   hookDispatcher?: Pick<HookDispatcher, 'listHooks' | 'getChains'>;
   /** Shared hook workbench for the hooks control-room panel. */
@@ -114,6 +123,24 @@ export interface BuiltinPanelDeps {
   hookActivityTracker?: Pick<HookActivityTracker, 'listRecent'>;
   /** Shared MCP registry for security panels and MCP workspace commands. */
   mcpRegistry?: McpRegistry;
+  /** Ops control-plane API (cancel/pause/resume/retry) for operator/ops panels to drive real actions. */
+  opsApi?: OpsApi;
+  /** Plan runtime service for plan/ops-strategy panels to drive adaptive-planner actions. */
+  planRuntime?: PlanRuntimeService;
+  /** Watcher registry for the watchers panel to drive watcher lifecycle actions. */
+  watcherRegistry?: WatcherRegistry;
+  /** Root runtime store for panels that need direct selector access to runtime state (see `src/runtime/store/selectors/index.ts`). */
+  runtimeStore?: RuntimeStore;
+  /** Knowledge API surface (graph nodes/sources/issues, search, schedules) for the Knowledge panel. */
+  knowledgeApi?: KnowledgeApi;
+  /** Optional session change tracker for the Git panel's session-changed file highlights. */
+  sessionChangeTracker?: Pick<SessionChangeTracker, 'getChangedFiles'>;
+  /**
+   * Open (or focus) a panel by id, wrapping `PanelManager.open`. Use for direct
+   * cross-panel navigation instead of printing a "/panel open …" signpost
+   * (mirrors the openAgentDetail callback below).
+   */
+  openPanel?: (panelId: string) => void;
   /**
    * Open the agent detail modal for the given agent id.  Wired from
    * InputHandler.agentDetailModal.open() at bootstrap — passed to the
@@ -239,7 +266,7 @@ export function requireControlPlanePanelDeps(deps: BuiltinPanelDeps): ControlPla
 
 export function requireAutomationManager(deps: BuiltinPanelDeps): AutomationManager {
   if (!deps.automationManager) {
-    throw new Error('SchedulePanel requires an automation manager to be wired at bootstrap.');
+    throw new Error('AutomationControlPanel requires an automation manager to be wired at bootstrap.');
   }
   return deps.automationManager;
 }
@@ -251,7 +278,7 @@ export function requireUiServices(deps: BuiltinPanelDeps): UiRuntimeServices {
   return deps.uiServices;
 }
 
-export function requirePluginManager(deps: BuiltinPanelDeps): PluginManagerObserver {
+export function requirePluginManager(deps: BuiltinPanelDeps): PluginManagerControls {
   if (!deps.pluginManager) {
     throw new Error('Plugin manager must be wired at bootstrap for plugin and security panels.');
   }
@@ -279,3 +306,68 @@ export function requireMcpRegistry(deps: BuiltinPanelDeps): McpRegistry {
   }
   return deps.mcpRegistry;
 }
+
+export function requireKnowledgeApi(deps: BuiltinPanelDeps): KnowledgeApi {
+  if (!deps.knowledgeApi) {
+    throw new Error('Knowledge API must be wired at bootstrap for the Knowledge panel.');
+  }
+  return deps.knowledgeApi;
+}
+
+// ---------------------------------------------------------------------------
+// WO-152: always-register conditional panels with a "dependency not
+// configured" empty state instead of skipping registration entirely.
+// ---------------------------------------------------------------------------
+
+/**
+ * Minimal placeholder Panel used when a builtin panel's runtime dependency
+ * (e.g. an orchestrator usage getter, a memory registry, an eval registry)
+ * was not wired at bootstrap for this build/session. Renders a single
+ * "dependency not configured" empty state via `buildEmptyState` so opening
+ * the panel id (`/panel open <id>`, a saved layout, a cross-panel jump)
+ * always resolves to a real panel instead of "Unknown panel" — the panel
+ * type is always registered; only its data source is sometimes absent.
+ */
+class UnconfiguredDependencyPanel extends BasePanel {
+  constructor(
+    id: string,
+    name: string,
+    icon: string,
+    category: PanelCategory,
+    private readonly emptyTitle: string,
+    private readonly emptyBody: string,
+  ) {
+    super(id, name, icon, category);
+  }
+
+  render(width: number, height: number): Line[] {
+    if (width <= 0 || height <= 0) return [];
+    return buildPanelWorkspace(width, height, {
+      title: `${this.name} Workspace`,
+      sections: [{
+        lines: buildEmptyState(width, this.emptyTitle, this.emptyBody, [], DEFAULT_PANEL_PALETTE),
+      }],
+      palette: DEFAULT_PANEL_PALETTE,
+    });
+  }
+}
+
+/**
+ * Build a factory that instantiates `configured()` when `dependencyPresent`
+ * is true, otherwise a placeholder Panel rendering `emptyTitle`/`emptyBody`
+ * via `buildEmptyState`. Use for builtin panels whose registration used to
+ * be gated behind an `if (deps.xyz)` check (cost/memory/incident/eval).
+ */
+export function withUnconfiguredFallback(
+  dependencyPresent: boolean,
+  id: string,
+  name: string,
+  icon: string,
+  category: PanelCategory,
+  emptyTitle: string,
+  emptyBody: string,
+  configured: () => Panel,
+): () => Panel {
+  if (dependencyPresent) return configured;
+  return () => new UnconfiguredDependencyPanel(id, name, icon, category, emptyTitle, emptyBody);
+}

package/src/panels/cockpit-panel.ts

@@ -1,24 +1,29 @@
 import type { Line } from '../types/grid.ts';
 import { createEmptyLine } from '../types/grid.ts';
+import { truncateDisplay } from '../utils/terminal-width.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,
+  buildAlignedRow,
   buildPanelLine,
   buildPanelWorkspace,
   buildStatPill,
   DEFAULT_PANEL_PALETTE,
+  type ColumnSpec,
   type PanelWorkspaceSection,
 } from './polish.ts';
+import { type ConfirmState, handleConfirmInput, renderConfirmLines } from './confirm-state.ts';
 import { agentStatusColor } from './agent-inspector-shared.ts';
 
-const C = {
-  ...DEFAULT_PANEL_PALETTE,
-  header: '#cbd5e1',
-  headerBg: '#0f172a',
-} as const;
+// Base chrome only — title band and text tokens come straight from
+// DEFAULT_PANEL_PALETTE (WO-002).
+const C = DEFAULT_PANEL_PALETTE;
+
+// How often the panel force-refreshes while active so time-based state (the
+// roster's stalled badges, which derive from wall-clock elapsed time rather
+// than an event) stays current even when no agent lifecycle event has fired.
+const STALL_TICK_MS = 5_000;
 
 function pickColor(value: number, warnAt = 1, badAt = 3): string {
   if (value >= badAt) return C.bad;
@@ -27,41 +32,143 @@ function pickColor(value: number, warnAt = 1, badAt = 3): string {
 }
 
 export interface CockpitPanelActionCallbacks {
+  /** Open the quick agent-detail modal (bootstrap-shell openAgentDetail wiring). */
   readonly openAgentDetail: (agentId: string) => void;
+  /** Deep-link into the Inspector panel focused on this agent (WO-110 inspectAgent route). */
+  readonly inspectAgent: (agentId: string) => void;
   readonly cancelAgent: (agentId: string) => boolean;
+  /** Cross-panel jump for a domain mini-summary card (wraps PanelManager.open via deps.openPanel). */
+  readonly openPanel: (panelId: string) => void;
 }
 
 const WORKSPACE_IDS = ['flow', 'governance', 'health', 'domains', 'agents'] as const;
 type WorkspaceId = (typeof WORKSPACE_IDS)[number];
+type DomainWorkspaceId = Exclude<WorkspaceId, 'agents'>;
+
+/** A single live domain mini-summary card. Enter on the focused card jumps to `target` via deps.openPanel. */
+interface DomainCard {
+  readonly label: string;
+  readonly target: string;
+}
+
+// Replaces the old buildGuidanceLine ('/orchestration', '/policy', …) signposts:
+// each non-agents workspace is now a short list of live, jumpable domain cards.
+const DOMAIN_CARDS: Record<DomainWorkspaceId, readonly DomainCard[]> = {
+  flow: [
+    { label: 'Orchestration', target: 'orchestration' },
+    { label: 'Tasks', target: 'tasks' },
+  ],
+  governance: [
+    { label: 'Policy', target: 'policy' },
+    { label: 'Security', target: 'security' },
+  ],
+  health: [
+    { label: 'Incidents', target: 'incident' },
+  ],
+  domains: [
+    { label: 'Communication', target: 'communication' },
+  ],
+};
+
+/** Live stat triplet for a domain card, computed from the current cockpit snapshot. */
+function domainCardStats(target: string, snapshot: UiCockpitSnapshot): ReadonlyArray<readonly [string, string, string]> {
+  switch (target) {
+    case 'orchestration':
+      return [
+        ['graphs', String(snapshot.activeGraphs), pickColor(snapshot.activeGraphs, 1, 4)],
+        ['running', String(snapshot.runningTasks), C.value],
+        ['guards', String(snapshot.guardTrips), pickColor(snapshot.guardTrips)],
+      ];
+    case 'tasks':
+      return [
+        ['running', String(snapshot.runningTasks), C.value],
+        ['blocked', String(snapshot.blockedTasks), pickColor(snapshot.blockedTasks)],
+        ['failed', String(snapshot.failedTasks), pickColor(snapshot.failedTasks)],
+      ];
+    case 'policy':
+      return [
+        ['preflight', snapshot.preflightStatus.toUpperCase(), snapshot.preflightStatus === 'block' ? C.bad : snapshot.preflightStatus === 'warn' ? C.warn : snapshot.preflightStatus === 'pass' ? C.good : C.dim],
+        ['issues', String(snapshot.preflightIssueCount), pickColor(snapshot.preflightIssueCount)],
+        ['lint', String(snapshot.lintFindingCount), pickColor(snapshot.lintFindingCount)],
+      ];
+    case 'security':
+      return [
+        ['token blocked', String(snapshot.tokenBlockedCount), pickColor(snapshot.tokenBlockedCount)],
+        ['overdue', String(snapshot.tokenRotationOverdueCount), pickColor(snapshot.tokenRotationOverdueCount)],
+        ['scope violations', String(snapshot.tokenScopeViolationCount), pickColor(snapshot.tokenScopeViolationCount)],
+      ];
+    case 'incident':
+      return [
+        ['count', String(snapshot.incidentCount), pickColor(snapshot.incidentCount)],
+        ['latest', snapshot.latestIncident ? snapshot.latestIncident.classification : 'none', snapshot.latestIncident ? C.bad : C.dim],
+      ];
+    case 'communication':
+      return [
+        ['messages', String(snapshot.communicationCount), C.value],
+        ['blocked', String(snapshot.blockedMessages), pickColor(snapshot.blockedMessages)],
+      ];
+    default:
+      return [];
+  }
+}
 
 function formatCost(cost: number | null): string {
   if (cost === null) return 'n/a';
   return cost < 0.01 ? '<$0.01' : `$${cost.toFixed(2)}`;
 }
 
+function formatTokens(inputTokens: number | null, outputTokens: number | null): string {
+  if (inputTokens === null && outputTokens === null) return 'n/a';
+  const fmt = (n: number | null) => (n === null ? '-' : n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n));
+  return `${fmt(inputTokens)}/${fmt(outputTokens)}`;
+}
+
 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;
+  private domainCursorIndex = 0;
+  private confirm: ConfirmState<string> | null = null;
+  private stallTickTimer: ReturnType<typeof setInterval> | null = null;
 
   public constructor(
     private readonly readModel?: UiReadModel<UiCockpitSnapshot>,
     private readonly rosterReadModel?: CockpitRosterReadModel,
     actionCallbacks?: Partial<CockpitPanelActionCallbacks>,
   ) {
-    super('cockpit', 'Cockpit', 'O', 'monitoring');
+    super('cockpit', 'Cockpit', 'O', 'runtime-ops');
     this.unsub = readModel ? readModel.subscribe(() => this.markDirty()) : null;
     this.rosterUnsub = rosterReadModel ? rosterReadModel.subscribe(() => this.markDirty()) : null;
     this.actionCallbacks = {
       openAgentDetail: actionCallbacks?.openAgentDetail ?? ((_id: string) => { /* noop */ }),
+      inspectAgent: actionCallbacks?.inspectAgent ?? ((_id: string) => { /* noop */ }),
       cancelAgent: actionCallbacks?.cancelAgent ?? ((_id: string) => false),
+      openPanel: actionCallbacks?.openPanel ?? ((_id: string) => { /* noop */ }),
     };
   }
 
+  public override onActivate(): void {
+    super.onActivate();
+    // Periodic tick so the roster's time-derived stalled badges (see
+    // cockpit-read-model's AGENT_STALL_THRESHOLD_MS) refresh even when no
+    // agent lifecycle event fires while this panel is on screen.
+    if (this.stallTickTimer === null) {
+      this.stallTickTimer = this.registerTimer(setInterval(() => this.markDirty(), STALL_TICK_MS));
+    }
+  }
+
+  public override onDeactivate(): void {
+    super.onDeactivate();
+    if (this.stallTickTimer !== null) {
+      this.clearTimer(this.stallTickTimer);
+      this.stallTickTimer = null;
+    }
+  }
+
   public override onDestroy(): void {
+    super.onDestroy();
     this.unsub?.();
     this.rosterUnsub?.();
   }
@@ -71,45 +178,51 @@ export class CockpitPanel extends BasePanel {
   }
 
   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;
+    // Confirm-cancel absorb: when a cancel is pending, only y/enter/return confirm,
+    // escape/n dismiss, everything else is consumed (canonical ConfirmState contract).
+    if (this.confirm) {
+      const result = handleConfirmInput(this.confirm, key);
+      if (result === 'confirmed') {
+        this.actionCallbacks.cancelAgent(this.confirm.subject);
+        this.confirm = null;
         this.markDirty();
-      } else if (key === 'escape' || key === 'n') {
-        this.pendingCancelId = null;
+      } else if (result === 'cancelled') {
+        this.confirm = null;
         this.markDirty();
       }
-      // All other keys are consumed while confirm is pending
+      // 'absorbed' (and the confirmed/cancelled cases above) all consume the key.
       return true;
     }
     if (key === 'left' || key === 'h') {
       this.selectedWorkspaceIndex = Math.max(0, this.selectedWorkspaceIndex - 1);
       this.agentCursorIndex = 0;
+      this.domainCursorIndex = 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.domainCursorIndex = 0;
       this.markDirty();
       return true;
     }
     if (key === 'home') {
       this.selectedWorkspaceIndex = 0;
       this.agentCursorIndex = 0;
+      this.domainCursorIndex = 0;
       this.markDirty();
       return true;
     }
     if (key === 'end') {
       this.selectedWorkspaceIndex = WORKSPACE_IDS.length - 1;
       this.agentCursorIndex = 0;
+      this.domainCursorIndex = 0;
       this.markDirty();
       return true;
     }
-    // Agents workspace: cursor movement, inspect, and cancel-initiation
     if (this.selectedWorkspace === 'agents') {
+      // Agents workspace: roster cursor movement, inspect, and cancel-initiation.
       const roster = this.rosterReadModel?.getSnapshot().roster ?? [];
       if (key === 'up' || key === 'k') {
         this.agentCursorIndex = Math.max(0, this.agentCursorIndex - 1);
@@ -121,18 +234,50 @@ export class CockpitPanel extends BasePanel {
         this.markDirty();
         return true;
       }
-      if (key === 'i' || key === 'enter' || key === 'return') {
+      if (key === 'i') {
+        // Quick view is only meaningful when the cursor is on a real roster
+        // entry — otherwise leave the key unconsumed instead of absorbing it
+        // as a silent no-op.
+        const entry = roster[this.agentCursorIndex];
+        if (!entry) return false;
+        this.actionCallbacks.openAgentDetail(entry.id);
+        return true;
+      }
+      if (key === 'enter' || key === 'return') {
         const entry = roster[this.agentCursorIndex];
         if (entry) {
-          this.actionCallbacks.openAgentDetail(entry.id);
+          this.actionCallbacks.inspectAgent(entry.id);
         }
         return true;
       }
       if (key === 'c') {
+        // Cancel is only meaningful on a real, non-terminal roster entry —
+        // otherwise leave the key unconsumed instead of absorbing it as a
+        // silent no-op.
         const entry = roster[this.agentCursorIndex];
-        if (entry && !this.isTerminal(entry.status)) {
-          this.pendingCancelId = entry.id;
-          this.markDirty();
+        if (!entry || this.isTerminal(entry.status)) return false;
+        const shortId = entry.id.length > 8 ? entry.id.slice(-8) : entry.id;
+        this.confirm = { subject: entry.id, label: `agent ${shortId}`, verb: 'Cancel' };
+        this.markDirty();
+        return true;
+      }
+    } else {
+      // Domain-summary workspaces: card cursor movement + Enter jump.
+      const cards = DOMAIN_CARDS[this.selectedWorkspace];
+      if (key === 'up' || key === 'k') {
+        this.domainCursorIndex = Math.max(0, this.domainCursorIndex - 1);
+        this.markDirty();
+        return true;
+      }
+      if (key === 'down' || key === 'j') {
+        this.domainCursorIndex = Math.min(cards.length - 1, this.domainCursorIndex + 1);
+        this.markDirty();
+        return true;
+      }
+      if (key === 'enter' || key === 'return') {
+        const card = cards[this.domainCursorIndex];
+        if (card) {
+          this.actionCallbacks.openPanel(card.target);
         }
         return true;
       }
@@ -150,29 +295,45 @@ export class CockpitPanel extends BasePanel {
       lines.push(buildPanelLine(width, [[' Agent roster read model not wired.', C.empty]]));
       return lines;
     }
-    const { roster, stalledAgentCount, totalCost } = this.rosterReadModel.getSnapshot();
+    const { roster, stalledAgentCount, totalCost, totalInputTokens, totalOutputTokens } = 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],
+      [`  tokens: ${formatTokens(totalInputTokens, totalOutputTokens)}`, 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,
     };
+    // Fixed-width columns (id/status/stalled/model/tokens/cost) + task takes the remainder.
+    const columns: ColumnSpec[] = [
+      { width: 9 },
+      { width: 10 },
+      { width: 8 },
+      { width: 14 },
+      { width: 13, align: 'right' },
+      { width: 8, align: 'right' },
+      { width: Math.max(8, width - 68) },
+    ];
     for (let i = 0; i < roster.length; i++) {
       const entry = roster[i]!;
-      const cursor = i === this.agentCursorIndex ? '>' : ' ';
+      const selected = 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],
-      ]));
+      lines.push(buildAlignedRow(
+        width,
+        [
+          { text: shortId, fg: C.dim },
+          { text: entry.status, fg: statusColor },
+          { text: entry.stalled ? 'STALLED' : '', fg: C.bad },
+          { text: entry.model, fg: C.info },
+          { text: formatTokens(entry.inputTokens, entry.outputTokens), fg: C.dim },
+          { text: formatCost(entry.cost), fg: C.value },
+          { text: entry.task, fg: C.label },
+        ],
+        columns,
+        { selected, selectedBg: C.headerBg, marker: '▸' },
+      ));
     }
     if (roster.length === 0) {
       lines.push(buildPanelLine(width, [[' No agents tracked yet.', C.empty]]));
@@ -180,9 +341,42 @@ export class CockpitPanel extends BasePanel {
     return lines;
   }
 
+  /** Live domain mini-summary cards for a non-agents workspace (replaces the old signpost pair). */
+  private renderDomainWorkspace(width: number, workspace: DomainWorkspaceId, snapshot: UiCockpitSnapshot): Line[] {
+    const cards = DOMAIN_CARDS[workspace];
+    const lines: Line[] = [];
+    for (let i = 0; i < cards.length; i++) {
+      const card = cards[i]!;
+      const focused = i === this.domainCursorIndex;
+      const stats = domainCardStats(card.target, snapshot);
+      lines.push(buildPanelLine(width, [
+        [focused ? '▸ ' : '  ', focused ? C.value : C.dim],
+        [card.label, focused ? C.header : C.label, focused ? C.headerBg : undefined],
+        ['  ', C.dim],
+        ...stats.flatMap(([label, value, color]): Array<[string, string, string?]> => [
+          [`${label} `, C.dim],
+          [`${value}  `, color],
+        ]),
+      ]));
+    }
+    lines.push(buildPanelLine(width, [[' ↑/↓ select domain  Enter opens panel', C.dim]]));
+    return lines;
+  }
+
   public render(width: number, height: number): Line[] {
     this.needsRender = false;
 
+    if (this.confirm) {
+      const lines = buildPanelWorkspace(width, height, {
+        title: 'Operator Cockpit',
+        sections: [{ title: 'Confirmation', lines: renderConfirmLines(width, this.confirm) }],
+        footerLines: [buildPanelLine(width, [['  y / Enter confirm  n / Esc cancel', C.dim]])],
+        palette: C,
+      });
+      while (lines.length < height) lines.push(createEmptyLine(width));
+      return lines.slice(0, height);
+    }
+
     if (!this.readModel) {
       const lines: Line[] = [buildPanelLine(width, [[' Runtime read model not wired into this panel yet.', C.empty]])];
       const workspace = buildPanelWorkspace(width, height, {
@@ -238,63 +432,47 @@ export class CockpitPanel extends BasePanel {
         [' latest incident ', C.label],
         [snapshot.latestIncident.classification, C.bad],
         ['  ', C.label],
-        [snapshot.latestIncident.summary.slice(0, Math.max(0, width - 19 - snapshot.latestIncident.classification.length)), C.dim],
+        [truncateDisplay(snapshot.latestIncident.summary, Math.max(0, width - 19 - snapshot.latestIncident.classification.length)), C.dim],
       ]));
     }
     const domainLines: Line[] = [buildPanelLine(width, [[
       `tasks:${snapshot.taskCount} agents:${snapshot.agentCount} graphs:${snapshot.totalGraphs} comms:${snapshot.communicationCount} mcp:${snapshot.mcpServerCount} plugins:${snapshot.pluginCount}`,
       C.dim,
     ]])];
-    const workspaceLines: Line[] = [];
-    if (selectedWorkspace === 'flow') {
-      workspaceLines.push(buildKeyValueLine(width, [
-        { label: 'running', value: String(snapshot.runningTasks), valueColor: C.value },
-        { label: 'blocked', value: String(snapshot.blockedTasks), valueColor: pickColor(snapshot.blockedTasks) },
-        { label: 'graphs', value: String(snapshot.activeGraphs), valueColor: pickColor(snapshot.activeGraphs, 1, 4) },
-      ], C));
-      workspaceLines.push(buildGuidanceLine(width, '/orchestration', 'inspect graph state, retries, and subtree controls', C));
-      workspaceLines.push(buildGuidanceLine(width, '/tasks', 'review active task pressure and task-specific output', C));
-    } else if (selectedWorkspace === 'governance') {
-      workspaceLines.push(buildKeyValueLine(width, [
-        { label: 'preflight', value: snapshot.preflightStatus.toUpperCase(), valueColor: snapshot.preflightStatus === 'block' ? C.bad : snapshot.preflightStatus === 'warn' ? C.warn : snapshot.preflightStatus === 'pass' ? C.good : C.dim },
-        { label: 'lint', value: String(snapshot.lintFindingCount), valueColor: pickColor(snapshot.lintFindingCount) },
-        { label: 'allow-all mcp', value: String(snapshot.elevatedMcp), valueColor: pickColor(snapshot.elevatedMcp) },
-      ], C));
-      workspaceLines.push(buildGuidanceLine(width, '/policy', 'run simulation, preflight, and bundle review', C));
-      workspaceLines.push(buildGuidanceLine(width, '/security', 'inspect trust, tokens, quarantines, and incident pressure', C));
-    } else if (selectedWorkspace === 'health') {
-      workspaceLines.push(buildKeyValueLine(width, [
-        { label: 'incidents', value: String(snapshot.incidentCount), valueColor: pickColor(snapshot.incidentCount) },
-        { label: 'plugins', value: String(snapshot.erroredPlugins), valueColor: pickColor(snapshot.erroredPlugins) },
-        { label: 'integrations', value: String(snapshot.failingIntegrations), valueColor: pickColor(snapshot.failingIntegrations) },
-      ], 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 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 },
-        { label: 'mcp', value: String(snapshot.mcpServerCount), valueColor: C.value },
-      ], 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 workspaceLines: Line[] = selectedWorkspace === 'agents'
+      ? this.renderAgentsWorkspace(width)
+      : this.renderDomainWorkspace(width, selectedWorkspace, snapshot);
+
+    // Visible workspace selector so focus and the available workspaces are
+    // obvious at a glance (not buried in a footer string). Rendered as a
+    // title-less row to keep it compact; the ▸ marker + accent show focus.
+    const selectorLine = buildPanelLine(width, [
+      [' switch ', C.label],
+      ...WORKSPACE_IDS.flatMap((id, i): Array<[string, string, string?]> => {
+        const focused = i === this.selectedWorkspaceIndex;
+        return [
+          [focused ? '▸' : ' ', focused ? C.value : C.dim],
+          [`${id} `, focused ? C.header : C.dim, focused ? C.headerBg : undefined],
+        ];
+      }),
+    ]);
 
     const sections: PanelWorkspaceSection[] = [
+      { lines: [selectorLine] },
       { title: 'Flow', lines: flowLines },
       { title: 'Governance', lines: governanceLines },
       { title: 'Health', lines: healthLines },
       { title: 'Domains', lines: domainLines },
-      { title: 'Selected Workspace', lines: workspaceLines },
+      { title: `Workspace · ${selectedWorkspace}`, lines: workspaceLines },
     ];
+    // Context-aware footer: surface the keys that actually work in this view.
+    const footerHint = selectedWorkspace === 'agents'
+      ? '  ←/→ workspace  ↑/↓ select agent  i quick view  enter inspector  c cancel  Home/End jump'
+      : '  ←/→ workspace  ↑/↓ select domain  enter opens panel  Home/End jump';
     const lines = buildPanelWorkspace(width, height, {
       title: 'Operator Cockpit',
-      intro: 'Live runtime pressure across orchestration, approvals, governance, integrations, and provider trust posture.',
       sections,
-      footerLines: [buildPanelLine(width, [[`  Left/Right move workspace focus  Home/End jump  focus=${selectedWorkspace}`, C.dim]])],
+      footerLines: [buildPanelLine(width, [[footerHint, C.dim]])],
       palette: C,
     });
     while (lines.length < height) lines.push(createEmptyLine(width));

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

@@ -19,6 +19,7 @@
 // ---------------------------------------------------------------------------
 
 import type { AgentRecord } from '@pellux/goodvibes-sdk/platform/tools';
+import { truncateDisplay } from '../utils/terminal-width.ts';
 import { calcSessionCost } from '../export/cost-utils.ts';
 import {
   AGENT_TERMINAL_STATUSES,
@@ -137,7 +138,7 @@ export function buildCockpitRosterSnapshot(
       totalCost += agentCost;
     }
 
-    const task = rec.task.length > 50 ? rec.task.slice(0, 47) + '...' : rec.task;
+    const task = truncateDisplay(rec.task, 50);
 
     return {
       id: rec.id,