@pellux/goodvibes-agent 0.1.69 → 0.1.71

package/src/panels/ops-strategy-panel.ts

@@ -1,235 +0,0 @@
-/**
- * Ops Strategy Timeline Panel.
- *
- * Renders the Adaptive Execution Planner state: current strategy, reason
- * code, mode, override status, and a scrollable history of past decisions.
- *
- * Registered as panel id 'ops' in builtin-panels.
- */
-
-import { BasePanel } from './base-panel.ts';
-import type { Line } from '../types/grid.ts';
-import type { PlannerDecision, ExecutionStrategy } from '@pellux/goodvibes-sdk/platform/core';
-import type { PlannerEvent } from '@/runtime/index.ts';
-import type { UiEventFeed } from '../runtime/ui-events.ts';
-import type { OpsStrategyQuery } from '../runtime/ui-service-queries.ts';
-import {
-  buildEmptyState,
-  buildPanelLine,
-  buildStyledPanelLine,
-  buildPanelWorkspace,
-  resolveScrollablePanelSection,
-  DEFAULT_PANEL_PALETTE,
-} from './polish.ts';
-
-const STRATEGY_FG: Record<ExecutionStrategy, string> = {
-  auto:       '#00cccc',
-  single:     '#00cc66',
-  cohort:     '#cccc00',
-  background: '#cc66cc',
-  remote:     '#cccccc',
-};
-
-const STRATEGY_ICON: Record<ExecutionStrategy, string> = {
-  auto:       '~',
-  single:     '▸',
-  cohort:     '◆',
-  background: '.',
-  remote:     '▸',
-};
-
-// ---------------------------------------------------------------------------
-// OpsStrategyPanel
-// ---------------------------------------------------------------------------
-
-export class OpsStrategyPanel extends BasePanel {
-  private unsubscribers: Array<() => void> = [];
-  private scrollOffset = 0;
-  private history: PlannerDecision[] = [];
-  private readonly adaptivePlanner: OpsStrategyQuery;
-
-  constructor(
-    private readonly plannerEvents: UiEventFeed<PlannerEvent>,
-    adaptivePlanner: OpsStrategyQuery,
-  ) {
-    super('ops', 'Ops', 'O', 'agent');
-    this.adaptivePlanner = adaptivePlanner;
-  }
-
-  override onActivate(): void {
-    super.onActivate();
-    this._syncHistory();
-    this.unsubscribers.push(
-      this.plannerEvents.on('PLAN_STRATEGY_SELECTED', () => {
-        this._syncHistory();
-        this.markDirty();
-      }),
-      this.plannerEvents.on('PLAN_STRATEGY_OVERRIDDEN', () => {
-        this._syncHistory();
-        this.markDirty();
-      }),
-    );
-  }
-
-  override onDestroy(): void {
-    for (const unsub of this.unsubscribers) unsub();
-    this.unsubscribers = [];
-  }
-
-  handleInput(key: string): boolean {
-    if (key === 'up' || key === 'k') {
-      this.scrollOffset = Math.max(0, this.scrollOffset - 1);
-      this.markDirty();
-      return true;
-    }
-    if (key === 'down' || key === 'j') {
-      this.scrollOffset++;
-      this.markDirty();
-      return true;
-    }
-    if (key === 'g') {
-      this.scrollOffset = 0;
-      this.markDirty();
-      return true;
-    }
-    if (key === 'G') {
-      this.scrollOffset = Math.max(0, this.history.length - 1);
-      this.markDirty();
-      return true;
-    }
-    return false;
-  }
-
-  render(width: number, height: number): Line[] {
-    const latest   = this.adaptivePlanner.getLatest();
-    const mode     = this.adaptivePlanner.getMode();
-    const override = this.adaptivePlanner.getOverride();
-    const statusLines: Line[] = [
-      buildPanelLine(width, [
-        [' Mode ', DEFAULT_PANEL_PALETTE.label],
-        [mode.toUpperCase(), DEFAULT_PANEL_PALETTE.value],
-        ['   Override ', DEFAULT_PANEL_PALETTE.label],
-        [override ? `${override.toUpperCase()} [ACTIVE]` : 'none', override ? DEFAULT_PANEL_PALETTE.warn : DEFAULT_PANEL_PALETTE.dim],
-      ]),
-    ];
-
-    if (latest) {
-      statusLines.push(buildPanelLine(width, [
-        [' Last ', DEFAULT_PANEL_PALETTE.label],
-        [`${STRATEGY_ICON[latest.selected]} ${latest.selected.toUpperCase()}`, STRATEGY_FG[latest.selected]],
-        ['   Reason ', DEFAULT_PANEL_PALETTE.label],
-        [latest.reasonCode, DEFAULT_PANEL_PALETTE.dim],
-      ]));
-    }
-
-    if (this.history.length === 0) {
-      return buildPanelWorkspace(width, height, {
-        title: ' Ops Strategy',
-        intro: 'Review adaptive execution planner decisions, overrides, and recent strategy history.',
-        sections: [
-          { title: 'Status', lines: statusLines },
-          {
-            lines: buildEmptyState(
-              width,
-              ' No decisions recorded yet',
-              'Adaptive planner decisions appear here once the planner begins selecting strategies.',
-              [],
-              DEFAULT_PANEL_PALETTE,
-            ),
-          },
-        ],
-        footerLines: [
-          buildPanelLine(width, [[' Up/Down', DEFAULT_PANEL_PALETTE.info], [' scroll history', DEFAULT_PANEL_PALETTE.dim], ['   g/G', DEFAULT_PANEL_PALETTE.info], [' top/bottom', DEFAULT_PANEL_PALETTE.dim]]),
-        ],
-        palette: DEFAULT_PANEL_PALETTE,
-      });
-    }
-
-    const historyLines = this._renderHistory(width);
-    const statusSection = { title: 'Status', lines: statusLines } as const;
-    const historySection = resolveScrollablePanelSection(width, height, {
-      intro: 'Review adaptive execution planner decisions, overrides, and recent strategy history.',
-      footerLines: [
-        buildPanelLine(width, [[' Up/Down', DEFAULT_PANEL_PALETTE.info], [' scroll history', DEFAULT_PANEL_PALETTE.dim], ['   g/G', DEFAULT_PANEL_PALETTE.info], [' top/bottom', DEFAULT_PANEL_PALETTE.dim]]),
-      ],
-      palette: DEFAULT_PANEL_PALETTE,
-      beforeSections: [statusSection],
-      section: {
-        title: 'Decision History',
-        scrollableLines: historyLines,
-        scrollOffset: Math.min(this.scrollOffset, Math.max(0, historyLines.length - 1)),
-        minRows: 8,
-      },
-    });
-    this.scrollOffset = historySection.scrollOffset;
-
-    return buildPanelWorkspace(width, height, {
-      title: ' Ops Strategy',
-      intro: 'Review adaptive execution planner decisions, overrides, and recent strategy history.',
-      sections: [
-        statusSection,
-        historySection.section,
-      ],
-      footerLines: [
-        buildPanelLine(width, [[' Up/Down', DEFAULT_PANEL_PALETTE.info], [' scroll history', DEFAULT_PANEL_PALETTE.dim], ['   g/G', DEFAULT_PANEL_PALETTE.info], [' top/bottom', DEFAULT_PANEL_PALETTE.dim]]),
-      ],
-      palette: DEFAULT_PANEL_PALETTE,
-    });
-  }
-
-  // -------------------------------------------------------------------------
-  // Private helpers
-  // -------------------------------------------------------------------------
-
-  private _syncHistory(): void {
-    this.history = this.adaptivePlanner.getHistory(50);
-  }
-
-  private _renderHistory(width: number): Line[] {
-    if (this.history.length === 0) {
-      return [buildStyledPanelLine(width, [{ text: '  No history yet.', fg: DEFAULT_PANEL_PALETTE.dim, dim: true }])];
-    }
-
-    const lines: Line[] = [];
-    lines.push(buildStyledPanelLine(width, [{ text: ' Decision History', fg: DEFAULT_PANEL_PALETTE.value, bold: true }]));
-
-    const reversed = [...this.history].reverse();
-    for (let i = 0; i < reversed.length; i++) {
-      const d    = reversed[i]!;
-      const ts   = new Date(d.timestamp).toLocaleTimeString();
-      const fg   = STRATEGY_FG[d.selected];
-      const icon = STRATEGY_ICON[d.selected];
-      const num  = String(i + 1).padStart(3);
-      const overrideMark = d.overrideActive ? ' [O]' : '';
-
-      // Row 1: index + icon + strategy + timestamp (right-aligned)
-      const leftBase  = ` ${num}. ${icon} ${d.selected.toUpperCase()}${overrideMark}`;
-      const rightText = `  ${ts}`;
-      const pad       = Math.max(1, width - leftBase.length - rightText.length);
-      lines.push(buildStyledPanelLine(width, [
-        { text: ` ${num}. `, fg: DEFAULT_PANEL_PALETTE.dim, dim: true },
-        { text: `${icon} ${d.selected.toUpperCase()}`, fg, bold: true },
-        { text: overrideMark, fg: DEFAULT_PANEL_PALETTE.warn },
-        { text: ' '.repeat(pad), fg: DEFAULT_PANEL_PALETTE.dim },
-        { text: rightText, fg: DEFAULT_PANEL_PALETTE.dim, dim: true },
-      ]));
-
-      // Row 2: reason code
-      lines.push(buildStyledPanelLine(width, [{ text: `       ${d.reasonCode}`, fg: DEFAULT_PANEL_PALETTE.dim, dim: true }]));
-
-      // Row 3+: top-2 scored candidates (auto mode only)
-      if (!d.overrideActive && d.candidates.length > 1) {
-        const top2 = d.candidates.slice(0, 2);
-        for (const c of top2) {
-          lines.push(buildStyledPanelLine(width, [
-            { text: '         ', fg: DEFAULT_PANEL_PALETTE.dim, dim: true },
-            { text: c.strategy.padEnd(12), fg: STRATEGY_FG[c.strategy] },
-            { text: ` score ${c.score}`, fg: DEFAULT_PANEL_PALETTE.dim, dim: true },
-          ]));
-        }
-      }
-    }
-
-    return lines;
-  }
-}

package/src/panels/orchestration-panel.ts

@@ -1,272 +0,0 @@
-/**
- * OrchestrationPanel — displays task graphs, node contracts, and recursion guards.
- *
- * Migrated (Wave B2): extends ScrollableListPanel<OrchestrationGraphRecord>.
- * Navigation (up/down/j/k) is handled by the base class.
- */
-
-import type { Line } from '../types/grid.ts';
-import { createEmptyLine } from '../types/grid.ts';
-import { ScrollableListPanel } from './scrollable-list-panel.ts';
-import type { UiOrchestrationSnapshot, UiReadModel } from '../runtime/ui-read-models.ts';
-import type { OrchestrationGraphRecord } from '@/runtime/index.ts';
-import {
-  buildEmptyState,
-  buildGuidanceLine,
-  buildKeyValueLine,
-  buildPanelLine,
-  buildPanelWorkspace,
-  resolveScrollablePanelSection,
-  DEFAULT_PANEL_PALETTE,
-  extendPalette,
-  type PanelPalette,
-  type PanelWorkspaceSection,
-} from './polish.ts';
-
-const C = extendPalette(DEFAULT_PANEL_PALETTE, {
-  header: '#94a3b8',
-  headerBg: '#1e293b',
-  running: '#22c55e',
-  ready: '#38bdf8',
-  blocked: '#f59e0b',
-  failed: '#ef4444',
-  completed: '#a78bfa',
-  selectBg: '#0f172a',
-} as const);
-
-function statusColor(status: string): string {
-  switch (status) {
-    case 'ready':     return C.ready;
-    case 'running':   return C.running;
-    case 'blocked':   return C.blocked;
-    case 'failed':    return C.failed;
-    case 'completed': return C.completed;
-    default:          return C.dim;
-  }
-}
-
-export class OrchestrationPanel extends ScrollableListPanel<OrchestrationGraphRecord> {
-  private readonly readModel?: UiReadModel<UiOrchestrationSnapshot>;
-  private readonly unsub: (() => void) | null;
-
-  public constructor(readModel?: UiReadModel<UiOrchestrationSnapshot>) {
-    super('orchestration', 'Orchestration', 'Q', 'monitoring');
-    this.readModel = readModel;
-    this.unsub = readModel ? readModel.subscribe(() => this.markDirty()) : null;
-  }
-
-  public override onDestroy(): void {
-    this.unsub?.();
-  }
-
-  // ---------------------------------------------------------------------------
-  // ScrollableListPanel contract
-  // ---------------------------------------------------------------------------
-
-  protected getItems(): readonly OrchestrationGraphRecord[] {
-    if (!this.readModel) return [];
-    return [...this.readModel.getSnapshot().graphs].sort((a, b) => b.createdAt - a.createdAt);
-  }
-
-  protected renderItem(
-    graph: OrchestrationGraphRecord,
-    index: number,
-    selected: boolean,
-    width: number,
-  ): Line {
-    const bg = selected ? C.selectBg : undefined;
-    return buildPanelLine(width, [
-      [' ', C.label, bg],
-      [graph.status.padEnd(10), statusColor(graph.status), bg],
-      [` ${graph.mode.padEnd(17)}`, C.value, bg],
-      [` ${graph.id.slice(0, 8)} `, C.dim, bg],
-      [graph.title.slice(0, Math.max(0, width - 39)), C.value, bg],
-    ]);
-  }
-
-  protected override getPalette(): PanelPalette {
-    return C;
-  }
-
-  protected override getEmptyStateMessage(): string {
-    return ' No orchestration graphs recorded yet.';
-  }
-
-  // ---------------------------------------------------------------------------
-  // Input — base class handles all navigation (up/down/j/k/pageup/pagedown/g/G)
-  // ---------------------------------------------------------------------------
-
-  // ---------------------------------------------------------------------------
-  // Render — multi-section layout (posture + scrollable graphs + detail + nodes)
-  // ---------------------------------------------------------------------------
-
-  public render(width: number, height: number): Line[] {
-    const intro = 'Read-only task graph posture, node contracts, and recursion guard state. Agent does not start local worker chains.';
-
-    if (!this.readModel) {
-      this.needsRender = false;
-      const workspace = buildPanelWorkspace(width, height, {
-        title: 'Orchestration Control Room',
-        intro,
-        sections: [{
-          lines: buildEmptyState(
-            width,
-            ' Runtime store not wired into this panel yet.',
-            'The orchestration workspace needs the live runtime store before it can show graphs, nodes, and recursion guard events.',
-            [{ command: '/orchestration', summary: 'reopen from the shell-owned runtime once orchestration is active' }],
-            C,
-          ),
-        }],
-        palette: C,
-      });
-      while (workspace.length < height) workspace.push(createEmptyLine(width));
-      return workspace;
-    }
-
-    const snapshot = this.readModel.getSnapshot();
-    const graphs = this.getItems();
-    const postureLines = [
-      buildKeyValueLine(width, [
-        { label: 'graphs', value: String(snapshot.totalGraphs), valueColor: snapshot.totalGraphs > 0 ? C.value : C.dim },
-        { label: 'active', value: String(snapshot.activeGraphIds.length), valueColor: snapshot.activeGraphIds.length > 0 ? C.running : C.dim },
-        { label: 'completed', value: String(snapshot.totalCompletedGraphs), valueColor: snapshot.totalCompletedGraphs > 0 ? C.completed : C.dim },
-        { label: 'failed', value: String(snapshot.totalFailedGraphs), valueColor: snapshot.totalFailedGraphs > 0 ? C.failed : C.dim },
-        { label: 'guards', value: String(snapshot.recursionGuardTrips), valueColor: snapshot.recursionGuardTrips > 0 ? C.blocked : C.dim },
-      ], C),
-      buildGuidanceLine(width, '/orchestration', 'inspect graph health without spawning local workers', C),
-    ];
-    if (graphs.length === 0) {
-      this.needsRender = false;
-      const workspace = buildPanelWorkspace(width, height, {
-        title: 'Orchestration Control Room',
-        intro,
-        sections: [{
-          title: 'Orchestration posture',
-          lines: [
-            ...postureLines,
-            ...buildEmptyState(
-              width,
-              this.getEmptyStateMessage(),
-              'Graphs, nodes, child contracts, and recursion guard trips appear here only if a runtime record already exists.',
-              [
-                { command: '/tasks', summary: 'create or inspect task flows that feed orchestration graphs' },
-                { command: '/communication', summary: 'review structured agent communication alongside graph execution' },
-              ],
-              C,
-            ),
-          ],
-        }],
-        palette: C,
-      });
-      while (workspace.length < height) workspace.push(createEmptyLine(width));
-      return workspace;
-    }
-
-    this.clampSelection();
-    const selected = graphs[this.selectedIndex]!;
-    const detailLines: Line[] = [
-      buildPanelLine(width, [
-        ['  Title: ', C.label],
-        [selected.title, C.value],
-        ['  Status: ', C.label],
-        [selected.status, statusColor(selected.status)],
-        ['  Mode: ', C.label],
-        [selected.mode, C.value],
-      ]),
-      buildPanelLine(width, [
-        ['  Nodes: ', C.label],
-        [String(selected.nodeOrder.length), C.value],
-        ['  Started: ', C.label],
-        [selected.startedAt ? new Date(selected.startedAt).toLocaleTimeString() : 'n/a', C.dim],
-        ['  Ended: ', C.label],
-        [selected.endedAt ? new Date(selected.endedAt).toLocaleTimeString() : 'n/a', C.dim],
-      ]),
-    ];
-    if (selected.lastRecursionGuard) {
-      detailLines.push(buildPanelLine(width, [
-        ['  Recursion guard: ', C.label],
-        [`depth ${selected.lastRecursionGuard.depth} active ${selected.lastRecursionGuard.activeAgents} ${selected.lastRecursionGuard.reason}`, C.blocked],
-      ]));
-    }
-
-    const nodes = selected.nodeOrder
-      .map((nodeId) => selected.nodes.get(nodeId))
-      .filter((node): node is NonNullable<typeof node> => Boolean(node));
-    const focusNode = nodes[0];
-    if (focusNode?.contract) {
-      const toolCount = focusNode.contract.allowedTools?.length ?? 0;
-      const evidenceCount = focusNode.contract.requiredEvidence?.length ?? 0;
-      const scopeCount = focusNode.contract.writeScope?.length ?? 0;
-      detailLines.push(buildPanelLine(width, [
-        ['  Contract: ', C.label],
-        [`tools ${toolCount}`, C.value],
-        ['  evidence ', C.label],
-        [String(evidenceCount), C.value],
-        ['  write scope ', C.label],
-        [String(scopeCount), C.value],
-      ]));
-      detailLines.push(buildPanelLine(width, [
-        ['  Flow: ', C.label],
-        [focusNode.contract.executionProtocol ?? 'direct', C.value],
-        ['  Review: ', C.label],
-        [focusNode.contract.reviewMode ?? 'none', C.value],
-        ['  Lane: ', C.label],
-        [focusNode.contract.communicationLane ?? 'default', C.value],
-        ['  Inherits: ', C.label],
-        [focusNode.contract.inheritsParentConstraints ? 'yes' : 'no', C.value],
-      ]));
-    }
-
-    const nodeLines: Line[] = nodes.length === 0
-      ? [buildPanelLine(width, [['  No nodes recorded yet.', C.dim]])]
-      : nodes.map((node) => {
-          const depends = node.dependencyNodeIds.length > 0 ? ` deps:${node.dependencyNodeIds.length}` : '';
-          return buildPanelLine(width, [
-            ['  ', C.label],
-            [node.status.padEnd(10), statusColor(node.status)],
-            [` ${node.role.padEnd(10)}`, C.value],
-            [` ${node.id.slice(0, 8)} `, C.dim],
-            [`${node.title}${depends}`.slice(0, Math.max(0, width - 34)), C.value],
-          ]);
-        });
-
-    const scrollableLines: Line[] = graphs.map((graph, index) =>
-      this.renderItem(graph, index, index === this.selectedIndex, width),
-    );
-
-    const postureSection: PanelWorkspaceSection = { title: 'Orchestration posture', lines: postureLines };
-    const selectedGraphSection: PanelWorkspaceSection = { title: 'Selected Graph', lines: detailLines };
-    const nodesSection: PanelWorkspaceSection = { title: 'Nodes', lines: nodeLines };
-    const graphsSection = resolveScrollablePanelSection(width, height, {
-      intro,
-      palette: C,
-      beforeSections: [postureSection],
-      section: {
-        title: 'Graphs',
-        scrollableLines,
-        selectedIndex: this.selectedIndex,
-        scrollOffset: this.scrollStart,
-        minRows: 4,
-        appendWindowSummary: { dimColor: C.dim },
-      },
-      afterSections: [selectedGraphSection, nodesSection],
-    });
-    this.scrollStart = graphsSection.scrollOffset;
-
-    const sections: PanelWorkspaceSection[] = [
-      postureSection,
-      graphsSection.section,
-      selectedGraphSection,
-      nodesSection,
-    ];
-    this.needsRender = false;
-    const lines = buildPanelWorkspace(width, height, {
-      title: 'Orchestration Control Room',
-      intro,
-      sections,
-      palette: C,
-    });
-    while (lines.length < height) lines.push(createEmptyLine(width));
-    return lines.slice(0, height);
-  }
-}

package/src/panels/plugins-panel.ts

@@ -1,178 +0,0 @@
-import type { Line } from '../types/grid.ts';
-import { createEmptyLine } from '../types/grid.ts';
-import { ScrollableListPanel } from './scrollable-list-panel.ts';
-import type { PluginManagerObserver, PluginStatus } from '@pellux/goodvibes-sdk/platform/plugins';
-import {
-  buildEmptyState,
-  buildPanelLine,
-  buildPanelWorkspace,
-  DEFAULT_PANEL_PALETTE,
-  type PanelPalette,
-} from './polish.ts';
-
-const C = {
-  ...DEFAULT_PANEL_PALETTE,
-  header: '#94a3b8',
-  headerBg: '#1e293b',
-  ok: '#22c55e',
-  warn: '#eab308',
-  error: '#ef4444',
-  info: '#38bdf8',
-  selectBg: '#0f172a',
-} as const;
-
-function trustColor(tier: PluginStatus['trustTier']): string {
-  switch (tier) {
-    case 'trusted':
-      return C.ok;
-    case 'limited':
-      return C.warn;
-    case 'untrusted':
-      return C.error;
-  }
-}
-
-function statusColor(status: PluginStatus): string {
-  if (status.quarantined) return C.error;
-  if (status.active) return C.ok;
-  if (status.enabled) return C.warn;
-  return C.dim;
-}
-
-function statusLabel(status: PluginStatus): string {
-  if (status.quarantined) return 'QUARANTINED';
-  if (status.active) return 'ACTIVE';
-  if (status.enabled) return 'ENABLED';
-  return 'DISABLED';
-}
-
-export class PluginsPanel extends ScrollableListPanel<PluginStatus> {
-  private readonly manager: PluginManagerObserver;
-  private readonly unsub: (() => void) | null;
-
-  public constructor(manager: PluginManagerObserver) {
-    super('plugins', 'Plugins', 'P', 'monitoring');
-    this.showSelectionGutter = true; // I5: non-color selection affordance
-    this.manager = manager;
-    this.unsub = manager.subscribe(() => this.markDirty());
-  }
-
-  public override onActivate(): void {
-    super.onActivate();
-    this.selectedIndex = 0;
-  }
-
-  public override onDestroy(): void {
-    this.unsub?.();
-  }
-
-  protected override getPalette(): PanelPalette {
-    return C;
-  }
-
-  protected getItems(): readonly PluginStatus[] {
-    return this.manager.list();
-  }
-
-  protected renderItem(plugin: PluginStatus, _index: number, selected: boolean, width: number): Line {
-    const bg = selected ? C.selectBg : undefined;
-    return buildPanelLine(width, [
-      [' ', C.label, bg],
-      [plugin.name.padEnd(22), C.value, bg],
-      [` ${statusLabel(plugin).padEnd(11)}`, statusColor(plugin), bg],
-      [` ${plugin.trustTier.toUpperCase().padEnd(10)}`, trustColor(plugin.trustTier), bg],
-      [` ${plugin.version}`, C.dim, bg],
-    ]);
-  }
-
-  protected override getEmptyStateMessage(): string {
-    return ' No plugins discovered.';
-  }
-
-  protected override getEmptyStateActions(): Array<{ command: string; summary: string }> {
-    return [
-      { command: '/plugin list', summary: 'inspect plugin discovery paths and current registry state' },
-      { command: '/marketplace', summary: 'review curated ecosystem entries and provenance posture' },
-    ];
-  }
-
-  public render(width: number, height: number): Line[] {
-    const intro = 'Plugin trust, capabilities, signatures, and quarantine posture for the active ecosystem surface.';
-    const plugins = this.getItems();
-
-    if (plugins.length === 0) {
-      const workspace = buildPanelWorkspace(width, height, {
-        title: 'Plugin Control Room',
-        intro,
-        sections: [{
-          lines: buildEmptyState(
-            width,
-            ' No plugins discovered.',
-            'Use /plugin list for search paths, install hints, and trust review before activating plugin-backed flows.',
-            [
-              { command: '/plugin list', summary: 'inspect plugin discovery paths and current registry state' },
-              { command: '/marketplace', summary: 'review curated ecosystem entries and provenance posture' },
-            ],
-            C,
-          ),
-        }],
-        palette: C,
-      });
-      while (workspace.length < height) workspace.push(createEmptyLine(width));
-      return workspace;
-    }
-
-    this.clampSelection();
-    const selected = plugins[this.selectedIndex]!;
-    const selectedCaps = this.manager.capabilities(selected.name);
-    const trustRecord = this.manager.getTrustRecord(selected.name);
-    const quarantineRecord = this.manager.getQuarantineRecord(selected.name);
-    const detailLines: Line[] = [
-      buildPanelLine(width, [
-        ['  Plugin: ', C.label],
-        [selected.name, C.value],
-        ['  State: ', C.label],
-        [statusLabel(selected), statusColor(selected)],
-        ['  Trust: ', C.label],
-        [selected.trustTier, trustColor(selected.trustTier)],
-      ]),
-      buildPanelLine(width, [
-        ['  Description: ', C.label],
-        [selected.description.slice(0, Math.max(0, width - 15)), C.dim],
-      ]),
-    ];
-
-    if (selectedCaps) {
-      detailLines.push(buildPanelLine(width, [
-        ['  Capabilities: ', C.label],
-        [String(selectedCaps.requested.length), C.value],
-        ['  High-risk: ', C.label],
-        [String(selectedCaps.highRisk.length), selectedCaps.highRisk.length > 0 ? C.warn : C.ok],
-        ['  Blocked: ', C.label],
-        [String(selectedCaps.blocked.length), selectedCaps.blocked.length > 0 ? C.error : C.ok],
-      ]));
-    }
-
-    if (trustRecord?.signatureFingerprint) {
-      detailLines.push(buildPanelLine(width, [
-        ['  Signature: ', C.label],
-        [trustRecord.signatureFingerprint, C.info],
-      ]));
-    }
-
-    if (quarantineRecord) {
-      detailLines.push(buildPanelLine(width, [
-        ['  Quarantine: ', C.label],
-        [quarantineRecord.reason.slice(0, Math.max(0, width - 14)), C.error],
-      ]));
-    }
-
-    detailLines.push(buildPanelLine(width, [['  Inspect trust and capability state here, then use /plugin to take action.', C.dim]]));
-    detailLines.push(buildPanelLine(width, [['  Up/Down move through discovered plugins', C.dim]]));
-
-    return this.renderList(width, height, {
-      title: 'Plugin Control Room',
-      footer: detailLines,
-    });
-  }
-}