@pellux/goodvibes-agent 0.1.0

package/src/panels/hooks-panel.ts

@@ -0,0 +1,239 @@
+import type { Line } from '../types/grid.ts';
+import { ScrollableListPanel } from './scrollable-list-panel.ts';
+import { listHookPointContracts } from '@pellux/goodvibes-sdk/platform/hooks';
+import type { HookDispatcher } from '@pellux/goodvibes-sdk/platform/hooks';
+import type { HookPointContract } from '@pellux/goodvibes-sdk/platform/hooks';
+import type { HookActivityRecord, HookActivityTracker } from '@pellux/goodvibes-sdk/platform/hooks';
+import type { HookAuthoringAction, HookSimulationResult } from '@pellux/goodvibes-sdk/platform/hooks';
+import type { HookChain, HookDefinition } from '@pellux/goodvibes-sdk/platform/hooks';
+import type { HookWorkbench } from '@pellux/goodvibes-sdk/platform/hooks';
+import { truncateDisplay } from '../utils/terminal-width.ts';
+import {
+  buildPanelLine,
+  buildStatusPill,
+  DEFAULT_PANEL_PALETTE,
+} from './polish.ts';
+
+const C = {
+  ...DEFAULT_PANEL_PALETTE,
+  header: '#94a3b8',
+  headerBg: '#1e293b',
+  ok: '#22c55e',
+  warn: '#eab308',
+  error: '#ef4444',
+  info: '#38bdf8',
+  selectBg: '#0f172a',
+} as const;
+
+export interface HooksPanelWorkbenchView {
+  listManagedHooks(): Array<{ pattern: string; hook: HookDefinition }>;
+  listManagedChains(): HookChain[];
+  listRecentActions(limit?: number): HookAuthoringAction[];
+  getLastSimulation(): HookSimulationResult | null;
+  getHooksFilePath(): string;
+}
+
+export interface HooksPanelDataSource {
+  listContracts(): HookPointContract[];
+  listHooks(): Array<{ pattern: string; hook: HookDefinition }>;
+  listChains(): HookChain[];
+  listRecentActivity(limit?: number): readonly HookActivityRecord[];
+  getWorkbench(): HooksPanelWorkbenchView;
+}
+
+function createDefaultDataSource(
+  hookDispatcher: Pick<HookDispatcher, 'listHooks' | 'getChains'>,
+  hookWorkbench: HookWorkbench,
+  hookActivityTracker: Pick<HookActivityTracker, 'listRecent'>,
+): HooksPanelDataSource {
+  return {
+    listContracts: () => listHookPointContracts(),
+    listHooks: () => hookDispatcher.listHooks(),
+    listChains: () => hookDispatcher.getChains(),
+    listRecentActivity: (limit = 3) => hookActivityTracker.listRecent(limit),
+    getWorkbench: () => hookWorkbench,
+  };
+}
+
+type HookEntry = { pattern: string; hook: HookDefinition };
+
+export class HooksPanel extends ScrollableListPanel<HookEntry> {
+  private readonly dataSource: HooksPanelDataSource;
+
+  public constructor(
+    hookDispatcher: Pick<HookDispatcher, 'listHooks' | 'getChains'>,
+    hookWorkbench: HookWorkbench,
+    hookActivityTracker: Pick<HookActivityTracker, 'listRecent'>,
+    dataSource: HooksPanelDataSource = createDefaultDataSource(hookDispatcher, hookWorkbench, hookActivityTracker),
+  ) {
+    super('hooks', 'Hooks', 'H', 'monitoring');
+    this.showSelectionGutter = true; // I5: non-color selection affordance
+    this.dataSource = dataSource;
+  }
+
+  protected override getPalette() { return C; }
+  protected override getEmptyStateMessage() { return ' No hooks are currently registered.'; }
+  protected override getEmptyStateActions() {
+    return [
+      { command: '/hooks', summary: 'review hook contracts and managed authoring actions' },
+      { command: '/settings', summary: 'review hook/runtime behavior in the settings surface' },
+    ];
+  }
+
+  protected getItems(): readonly HookEntry[] {
+    return this.dataSource.listHooks();
+  }
+
+  protected renderItem(entry: HookEntry, index: number, selected: boolean, width: number): Line {
+    const bg = selected ? C.selectBg : undefined;
+    return buildPanelLine(width, [
+      [' ', C.label, bg],
+      [truncateDisplay(entry.hook.name ?? '(unnamed)', 20).padEnd(20), C.value, bg],
+      [` ${truncateDisplay(entry.pattern, 28).padEnd(28)}`, C.info, bg],
+      ...buildStatusPill(entry.hook.enabled === false ? 'warn' : 'good', ` ${(entry.hook.enabled === false ? 'DISABLED' : 'ENABLED').padEnd(8)}`, { bg }),
+      [` ${entry.hook.type}`, C.dim, bg],
+    ]);
+  }
+
+  public handleInput(key: string): boolean {
+    if (key === 'r') {
+      this.markDirty();
+      return true;
+    }
+    return super.handleInput(key);
+  }
+
+  public render(width: number, height: number): Line[] {
+    this.clampSelection();
+    const hooks = this.dataSource.listHooks();
+    const contracts = this.dataSource.listContracts();
+    const chains = this.dataSource.listChains();
+    const recentActivity = this.dataSource.listRecentActivity(3);
+    const workbench = this.dataSource.getWorkbench();
+    const managedHooks = workbench.listManagedHooks();
+    const managedChains = workbench.listManagedChains();
+    const recentAuthoring = workbench.listRecentActions(3);
+    const lastSimulation = workbench.getLastSimulation();
+    const intro = 'Hook contracts, active registrations, managed authoring, recent runtime activity, and simulation matches.';
+
+    const selected = hooks[this.selectedIndex];
+    const contract = selected ? contracts.find((c) => c.pattern === selected.pattern) : undefined;
+
+    const detailLines: Line[] = [];
+    if (selected) {
+      detailLines.push(buildPanelLine(width, [
+        ['  Hook: ', C.label],
+        [selected.hook.name ?? '(unnamed)', C.value],
+        ['  Type: ', C.label],
+        [selected.hook.type, C.info],
+        ['  Match: ', C.label],
+        [selected.hook.matcher ?? selected.hook.match, C.value],
+      ]));
+      detailLines.push(buildPanelLine(width, [
+        ['  Pattern: ', C.label],
+        [truncateDisplay(selected.pattern, Math.max(0, width - 12)), C.value],
+      ]));
+      if (contract) {
+        detailLines.push(buildPanelLine(width, [
+          ['  Contract: ', C.label],
+          [`${contract.authority} / ${contract.executionMode}`, C.info],
+          ['  Policy: ', C.label],
+          [contract.failurePolicy, C.value],
+        ]));
+        detailLines.push(buildPanelLine(width, [
+          ['  Capabilities: ', C.label],
+          [`deny=${contract.canDeny ? 'yes' : 'no'} mutate=${contract.canMutateInput ? 'yes' : 'no'} inject=${contract.canInjectContext ? 'yes' : 'no'}`, C.dim],
+        ]));
+      } else {
+        detailLines.push(buildPanelLine(width, [['  Contract: No exact contract registered for this pattern.', C.warn]]));
+      }
+      detailLines.push(buildPanelLine(width, [
+        ['  Summary: ', C.label],
+        [`hooks=${hooks.length} chains=${chains.length} contracts=${contracts.length} managed=${managedHooks.length}/${managedChains.length}`, C.dim],
+      ]));
+      detailLines.push(buildPanelLine(width, [
+        ['  Hooks file: ', C.label],
+        [truncateDisplay(workbench.getHooksFilePath(), Math.max(0, width - 15)), C.dim],
+      ]));
+    }
+
+    const activityLines: Line[] = recentActivity.length === 0
+      ? [buildPanelLine(width, [['  No hook activity recorded yet.', C.empty]])]
+      : recentActivity.map((record) => {
+          const color = !record.ok ? C.error : record.decision === 'deny' ? C.warn : C.ok;
+          return buildPanelLine(width, [
+            ['  ', C.label],
+            [truncateDisplay(record.hookName, 18).padEnd(18), C.value],
+            ['  ', C.label],
+            [truncateDisplay(record.path, 26).padEnd(26), C.info],
+            ['  ', C.label],
+            [record.ok ? (record.decision ?? 'ok') : 'error', color],
+          ]);
+        });
+
+    const authoringLines: Line[] = recentAuthoring.length === 0
+      ? [buildPanelLine(width, [['  No managed hook authoring actions recorded yet.', C.empty]])]
+      : recentAuthoring.map((action) => buildPanelLine(width, [
+          ['  ', C.label],
+          [truncateDisplay(action.kind, 14).padEnd(14), C.info],
+          ['  ', C.label],
+          [truncateDisplay(action.target, Math.max(0, width - 20)), C.dim],
+        ]));
+    if (lastSimulation) {
+      authoringLines.push(buildPanelLine(width, [
+        ['  Last Simulation: ', C.label],
+        [truncateDisplay(lastSimulation.eventPath, Math.max(0, width - 20)), C.value],
+      ]));
+      authoringLines.push(buildPanelLine(width, [
+        ['  Matches: ', C.label],
+        [`hooks=${lastSimulation.matchedHooks.length} chains=${lastSimulation.matchedChains.length}`, C.dim],
+      ]));
+    }
+
+    // Empty state: show extra context lines (hooks file, contracts, authoring) before base empty state
+    if (hooks.length === 0) {
+      const extraHeader: Line[] = [
+        buildPanelLine(width, [
+          ['  Contracts: ', C.label],
+          [String(contracts.length), C.value],
+          ['  Chains: ', C.label],
+          [String(chains.length), C.value],
+          ['  Managed: ', C.label],
+          [String(managedHooks.length), C.info],
+        ]),
+        buildPanelLine(width, [
+          ['  Hooks file: ', C.label],
+          [truncateDisplay(workbench.getHooksFilePath(), Math.max(0, width - 15)), C.dim],
+        ]),
+      ];
+      if (recentAuthoring.length > 0) {
+        extraHeader.push(buildPanelLine(width, [
+          ['  Authoring: ', C.label],
+          [truncateDisplay(`${recentAuthoring[0]!.kind} ${recentAuthoring[0]!.target}`, Math.max(0, width - 14)), C.info],
+        ]));
+      }
+      if (lastSimulation) {
+        extraHeader.push(buildPanelLine(width, [
+          ['  Last Simulation: ', C.label],
+          [truncateDisplay(lastSimulation.eventPath, Math.max(0, width - 20)), C.value],
+        ]));
+      }
+      return this.renderList(width, height, {
+        title: 'Hooks Control Room',
+        header: extraHeader,
+      });
+    }
+
+    return this.renderList(width, height, {
+      title: 'Hooks Control Room',
+      footer: [
+        ...detailLines,
+        buildPanelLine(width, [['  Recent Activity', C.label]]),
+        ...activityLines,
+        buildPanelLine(width, [['  Authoring', C.label]]),
+        ...authoringLines,
+        buildPanelLine(width, [['  Up/Down move  r refresh  /hooks for full contract listing', C.dim]]),
+      ],
+    });
+  }
+}

package/src/panels/incident-review-panel.ts

@@ -0,0 +1,197 @@
+import type { Line } from '../types/grid.ts';
+import type { ForensicsRegistry } from '@/runtime/index.ts';
+import { ScrollableListPanel } from './scrollable-list-panel.ts';
+import {
+  buildBodyText,
+  buildEmptyState,
+  buildGuidanceLine,
+  buildKeyValueLine,
+  buildPanelLine,
+  buildPanelWorkspace,
+  buildStatusPill,
+  DEFAULT_PANEL_PALETTE,
+  type PanelPalette,
+} from './polish.ts';
+import type { FailureReport } from '@/runtime/index.ts';
+
+const C = {
+  ...DEFAULT_PANEL_PALETTE,
+  header: '#cbd5e1',
+  headerBg: '#0f172a',
+  warn: '#f59e0b',
+  bad: '#ef4444',
+  selectBg: '#111827',
+} as const;
+
+function classificationColor(value: string): string {
+  switch (value) {
+    case 'cancelled':
+      return C.dim;
+    case 'max_tokens':
+    case 'unknown':
+      return C.warn;
+    default:
+      return C.bad;
+  }
+}
+
+export class IncidentReviewPanel extends ScrollableListPanel<FailureReport> {
+  private readonly registry?: ForensicsRegistry;
+  private readonly unsub: (() => void) | null;
+
+  public constructor(registry?: ForensicsRegistry) {
+    super('incident', 'Incident Review', 'N', 'monitoring');
+    this.showSelectionGutter = true; // I5: non-color selection affordance
+    this.registry = registry;
+    this.unsub = registry ? registry.subscribe(() => this.markDirty()) : null;
+  }
+
+  public override onDestroy(): void {
+    this.unsub?.();
+  }
+
+  protected override getPalette(): PanelPalette {
+    return C;
+  }
+
+  protected getItems(): readonly FailureReport[] {
+    return this.registry?.getAll() ?? [];
+  }
+
+  protected renderItem(report: FailureReport, index: number, selected: boolean, width: number): Line {
+    const bg = selected ? C.selectBg : undefined;
+    return buildPanelLine(width, [
+      [' ', C.label, bg],
+      [report.id.slice(0, 8).padEnd(9), C.dim, bg],
+      [report.classification.padEnd(20), classificationColor(report.classification), bg],
+      [report.summary.slice(0, Math.max(0, width - 31)), C.value, bg],
+    ]);
+  }
+
+  protected override getEmptyStateMessage(): string {
+    return ' No incidents recorded yet.';
+  }
+
+  protected override getEmptyStateActions(): Array<{ command: string; summary: string }> {
+    return [
+      { command: '/incident latest', summary: 'inspect the latest report once one exists' },
+      { command: '/recall capture incident latest', summary: 'promote incident evidence into project knowledge' },
+    ];
+  }
+
+  public render(width: number, height: number): Line[] {
+    const intro = 'Failure bundles, replay mismatches, permission fallout, and exportable review evidence.';
+
+    if (!this.registry) {
+      return buildPanelWorkspace(width, height, {
+        title: 'Incident Review Workspace',
+        intro,
+        sections: [{
+          lines: buildEmptyState(
+            width,
+            ' Forensics registry not wired into this panel yet.',
+            'Incident review needs the live forensics registry so it can inspect failure bundles, replay mismatches, and causal evidence.',
+            [
+              { command: '/incident latest', summary: 'inspect the latest incident from the command surface' },
+              { command: '/security', summary: 'open the broader trust and incident posture control room' },
+            ],
+            C,
+          ),
+        }],
+        palette: C,
+      });
+    }
+
+    const reports = this.getItems();
+    if (reports.length === 0) {
+      return this.renderList(width, height, { title: 'Incident Review Workspace' });
+    }
+
+    this.clampSelection();
+    const selected = reports[this.selectedIndex]!;
+    const bundle = this.registry.buildBundle(selected.id);
+
+    const headerLines: Line[] = [
+      buildKeyValueLine(width, [
+        { label: 'incidents', value: String(reports.length), valueColor: C.value },
+        { label: 'selected', value: `${this.selectedIndex + 1}/${reports.length}`, valueColor: C.info },
+        { label: 'classification', value: selected.classification, valueColor: classificationColor(selected.classification) },
+      ], C),
+      buildPanelLine(width, [['  Up/Down move  Home/End jump  selected incident drives the action rail below', C.dim]]),
+    ];
+
+    const footerLines: Line[] = [];
+    if (bundle) {
+      footerLines.push(buildKeyValueLine(width, [
+        { label: 'id', value: selected.id, valueColor: C.dim },
+        { label: 'trace', value: selected.traceId, valueColor: C.dim },
+      ], C));
+      footerLines.push(...buildBodyText(width, `Root cause: ${bundle.evidence.rootCause ?? 'n/a'}`, C, C.value));
+      footerLines.push(buildKeyValueLine(width, [
+        { label: 'Permissions denied', value: String(bundle.evidence.deniedPermissionCount), valueColor: bundle.evidence.deniedPermissionCount > 0 ? C.warn : C.dim },
+        { label: 'Budget breaches', value: String(bundle.evidence.budgetBreachCount), valueColor: bundle.evidence.budgetBreachCount > 0 ? C.warn : C.dim },
+        { label: 'Replay mismatches', value: String(bundle.replay.mismatchCount), valueColor: bundle.replay.mismatchCount > 0 ? C.bad : C.dim },
+      ], C));
+      footerLines.push(buildPanelLine(width, [
+        ['  Related IDs: ', C.label],
+        [`turn=${bundle.evidence.relatedIds.turnId ?? 'n/a'} task=${bundle.evidence.relatedIds.taskId ?? 'n/a'} agent=${bundle.evidence.relatedIds.agentId ?? 'n/a'}`.slice(0, Math.max(0, width - 14)), C.info],
+      ]));
+      if (bundle.evidence.slowPhases.length > 0) {
+        footerLines.push(buildPanelLine(width, [
+          ['  Slow phases: ', C.label],
+          ...buildStatusPill('warn', bundle.evidence.slowPhases.join(', ').slice(0, Math.max(0, width - 15))),
+        ]));
+      }
+      const rootCause = selected.causalChain.find((entry) => entry.isRootCause);
+      if (rootCause) {
+        footerLines.push(buildPanelLine(width, [
+          ['  Root event: ', C.label],
+          [`${rootCause.sourceEventType} - ${rootCause.description}`.slice(0, Math.max(0, width - 14)), C.dim],
+        ]));
+      }
+      const denied = selected.permissionEvidence.find((entry) => entry.approved === false);
+      if (denied) {
+        footerLines.push(buildPanelLine(width, [
+          ['  Permission: ', C.label],
+          [`${denied.tool} denied${denied.riskLevel ? ` (${denied.riskLevel})` : ''}${denied.summary ? ` - ${denied.summary}` : ''}`.slice(0, Math.max(0, width - 14)), C.warn],
+        ]));
+      }
+      if (bundle.replay.relatedMismatches.length > 0) {
+        const mismatch = bundle.replay.relatedMismatches[0]!;
+        const ownerBreakdown = Object.entries(bundle.replay.mismatchBreakdown.byOwnerDomain)
+          .filter(([, count]) => count > 0)
+          .slice(0, 3)
+          .map(([domain, count]) => `${domain}:${count}`)
+          .join(', ');
+        const replayDetail = ownerBreakdown.length > 0
+          ? `Replay link: ${mismatch.kind}${mismatch.ownerDomain ? `/${mismatch.ownerDomain}` : ''} - ${mismatch.description}  Replay owners: ${ownerBreakdown}`
+          : `Replay link: ${mismatch.kind}${mismatch.ownerDomain ? `/${mismatch.ownerDomain}` : ''} - ${mismatch.description}`;
+        footerLines.push(buildPanelLine(width, [
+          ['  ', C.label],
+          ...buildStatusPill('bad', replayDetail.slice(0, Math.max(0, width - 2))),
+        ]));
+      } else {
+        const ownerBreakdown = Object.entries(bundle.replay.mismatchBreakdown.byOwnerDomain)
+          .filter(([, count]) => count > 0)
+          .slice(0, 3)
+          .map(([domain, count]) => `${domain}:${count}`)
+          .join(', ');
+        if (ownerBreakdown.length > 0) {
+          footerLines.push(buildPanelLine(width, [
+            ['  Replay owners: ', C.label],
+            [ownerBreakdown.slice(0, Math.max(0, width - 17)), C.info],
+          ]));
+        }
+      }
+    }
+    footerLines.push(buildPanelLine(width, [['  Action Rail', C.label]]));
+    footerLines.push(buildPanelLine(width, [[`  /incident latest   /incident export ${selected.id}   /recall capture incident ${selected.id}`, C.info]]));
+    footerLines.push(buildGuidanceLine(width, '/security', 'open the broader trust and incident posture control room', C));
+
+    return this.renderList(width, height, {
+      title: 'Incident Review Workspace',
+      header: headerLines,
+      footer: footerLines,
+    });
+  }
+}

package/src/panels/index.ts

@@ -0,0 +1,46 @@
+export type { Panel, PanelCategory, PanelRegistration } from './types.ts';
+export type { Pane } from './panel-manager.ts';
+export { BasePanel } from './base-panel.ts';
+export { PanelManager } from './panel-manager.ts';
+export { TokenBudgetPanel } from './token-budget-panel.ts';
+export { CostTrackerPanel } from './cost-tracker-panel.ts';
+export { AgentInspectorPanel } from './agent-inspector-panel.ts';
+export { AgentLogsPanel } from './agent-logs-panel.ts';
+export { WrfcPanel } from './wrfc-panel.ts';
+export { ProviderHealthPanel } from './provider-health-panel.ts';
+export { ProviderHealthTracker } from './provider-health-tracker.ts';
+export type { ProviderHealth, ProviderStatus } from './provider-health-tracker.ts';
+export { GitPanel } from './git-panel.ts';
+export { SymbolOutlinePanel } from './symbol-outline-panel.ts';
+export type { SymbolEntry, SymbolKind } from './symbol-outline-panel.ts';
+export { ProviderStatsPanel } from './provider-stats-panel.ts';
+export { SessionBrowserPanel } from './session-browser-panel.ts';
+export { DocsPanel } from './docs-panel.ts';
+export { ThinkingPanel } from './thinking-panel.ts';
+export { ToolInspectorPanel } from './tool-inspector-panel.ts';
+export { ContextVisualizerPanel } from './context-visualizer-panel.ts';
+export { DebugPanel } from './debug-panel.ts';
+export type { ApiCallEntry, ApiCallStatus } from './debug-panel.ts';
+export { registerBuiltinPanels } from './builtin-panels.ts';
+export type { BuiltinPanelDeps } from './builtin-panels.ts';
+export { ForensicsPanel } from './forensics-panel.ts';
+export { IncidentReviewPanel } from './incident-review-panel.ts';
+export { PolicyPanel } from './policy-panel.ts';
+export { PluginsPanel } from './plugins-panel.ts';
+export { SkillsPanel } from './skills-panel.ts';
+export { TasksPanel } from './tasks-panel.ts';
+export { OrchestrationPanel } from './orchestration-panel.ts';
+export { CommunicationPanel } from './communication-panel.ts';
+export { CockpitPanel } from './cockpit-panel.ts';
+export { RemotePanel } from './remote-panel.ts';
+export { ServicesPanel } from './services-panel.ts';
+export { SubscriptionPanel } from './subscription-panel.ts';
+export { HooksPanel } from './hooks-panel.ts';
+export { SecurityPanel } from './security-panel.ts';
+export { MarketplacePanel } from './marketplace-panel.ts';
+export { SandboxPanel } from './sandbox-panel.ts';
+export { ApprovalPanel } from './approval-panel.ts';
+export { KnowledgePanel } from './knowledge-panel.ts';
+export { SystemMessagesPanel } from './system-messages-panel.ts';
+export { PanelListPanel } from './panel-list-panel.ts';
+export type { SystemMessageEntry, SystemMessagePriority } from './system-messages-panel.ts';

package/src/panels/intelligence-panel.ts

@@ -0,0 +1,176 @@
+import type { Line } from '../types/grid.ts';
+import { createEmptyLine } from '../types/grid.ts';
+import { BasePanel } from './base-panel.ts';
+import type { UiIntelligenceSnapshot, UiReadModel } from '../runtime/ui-read-models.ts';
+import {
+  buildEmptyState,
+  buildGuidanceLine,
+  buildKeyValueLine,
+  buildPanelLine,
+  buildPanelWorkspace,
+  DEFAULT_PANEL_PALETTE,
+  type PanelWorkspaceSection,
+} from './polish.ts';
+
+const C = {
+  ...DEFAULT_PANEL_PALETTE,
+  good: '#22c55e',
+  warn: '#f59e0b',
+  bad: '#ef4444',
+  info: '#38bdf8',
+  headerBg: '#1e293b',
+} as const;
+
+function statusColor(status: string): string {
+  switch (status) {
+    case 'ready':
+      return C.good;
+    case 'loading':
+      return C.info;
+    case 'degraded':
+      return C.warn;
+    case 'unavailable':
+    default:
+      return C.bad;
+  }
+}
+
+export class IntelligencePanel extends BasePanel {
+  private readonly unsub: (() => void) | null;
+
+  public constructor(private readonly readModel?: UiReadModel<UiIntelligenceSnapshot>) {
+    super('intelligence', 'Intelligence', 'J', 'development');
+    this.unsub = readModel ? readModel.subscribe(() => this.markDirty()) : null;
+  }
+
+  public override onDestroy(): void {
+    this.unsub?.();
+  }
+
+  public render(width: number, height: number): Line[] {
+    this.needsRender = false;
+    if (!this.readModel) {
+      const lines = buildPanelWorkspace(width, height, {
+        title: 'Intelligence Control Room',
+        intro: 'Workspace intelligence posture across diagnostics, symbols, completions, and hover readiness.',
+        sections: [{
+          lines: buildEmptyState(
+            width,
+            ' Intelligence runtime store unavailable.',
+            'This surface needs the live runtime store so it can show diagnostics, symbol readiness, and recovery guidance.',
+            [{ command: '/intelligence review', summary: 'review intelligence readiness from the command surface' }],
+            C,
+          ),
+        }],
+        palette: C,
+      });
+      while (lines.length < height) lines.push(createEmptyLine(width));
+      return lines.slice(0, height);
+    }
+
+    const state = this.readModel.getSnapshot();
+    const degraded = [
+      state.diagnosticsStatus,
+      state.completionsStatus,
+      state.symbolSearchStatus,
+      state.hoverStatus,
+    ].filter((status) => status !== 'ready').length;
+
+    const sections: PanelWorkspaceSection[] = [
+      {
+        title: 'Intelligence posture',
+        lines: [
+          buildKeyValueLine(width, [
+            { label: 'diagnostics', value: state.diagnosticsStatus, valueColor: statusColor(state.diagnosticsStatus) },
+            { label: 'symbols', value: state.symbolSearchStatus, valueColor: statusColor(state.symbolSearchStatus) },
+            { label: 'completions', value: state.completionsStatus, valueColor: statusColor(state.completionsStatus) },
+            { label: 'hover', value: state.hoverStatus, valueColor: statusColor(state.hoverStatus) },
+          ], C),
+          buildKeyValueLine(width, [
+            { label: 'errors', value: String(state.errorCount), valueColor: state.errorCount > 0 ? C.bad : C.dim },
+            { label: 'warnings', value: String(state.warningCount), valueColor: state.warningCount > 0 ? C.warn : C.dim },
+            { label: 'requests', value: String(state.totalRequests), valueColor: C.value },
+            { label: 'avg latency', value: `${Math.round(state.avgLatencyMs)}ms`, valueColor: C.info },
+          ], C),
+        ],
+      },
+      {
+        title: 'Next Actions',
+        lines: [
+          buildGuidanceLine(width, '/intelligence diagnostics', 'review readiness posture and current diagnostics activity', C),
+          buildGuidanceLine(width, '/intelligence repair', 'surface repair-oriented guidance when symbols, hover, or completions degrade', C),
+        ],
+      },
+      {
+        title: 'Readiness',
+        lines: [
+          buildPanelLine(width, [[` Diagnostics are ${state.diagnosticsStatus}. Symbol search is ${state.symbolSearchStatus}.`, state.diagnosticsStatus === 'ready' && state.symbolSearchStatus === 'ready' ? C.dim : C.warn]]),
+          buildPanelLine(width, [[` Hover is ${state.hoverStatus}. Completions are ${state.completionsStatus}.`, state.hoverStatus === 'ready' && state.completionsStatus === 'ready' ? C.dim : C.warn]]),
+          ...(state.hover.active && state.hover.filePath
+            ? [buildPanelLine(width, [[` Active hover: ${state.hover.filePath}`, C.info]])]
+            : []),
+        ],
+      },
+    ];
+
+    const diagnosticFiles = [...state.diagnostics.entries()]
+      .map(([filePath, diagnostics]) => ({
+        filePath,
+        errors: diagnostics.filter((entry) => entry.severity === 'error').length,
+        warnings: diagnostics.filter((entry) => entry.severity === 'warning').length,
+      }))
+      .sort((a, b) => (b.errors - a.errors) || (b.warnings - a.warnings) || a.filePath.localeCompare(b.filePath))
+      .slice(0, 4);
+    sections.push({
+      title: 'Diagnostics',
+      lines: diagnosticFiles.length > 0
+        ? diagnosticFiles.map((entry) => buildPanelLine(width, [[
+            ` ${entry.filePath}  errors=${entry.errors} warnings=${entry.warnings}`,
+            entry.errors > 0 ? C.bad : entry.warnings > 0 ? C.warn : C.dim,
+          ]]))
+        : [buildPanelLine(width, [[' No tracked diagnostics yet.', C.dim]])],
+    });
+
+    sections.push({
+      title: 'Workflows',
+      lines: [
+        buildGuidanceLine(width, '/intelligence symbols <file>', 'inspect document symbols for a file and verify symbol-surface readiness', C),
+        buildGuidanceLine(width, '/intelligence outline <file>', 'review structural outline extraction without leaving the control room', C),
+        buildGuidanceLine(width, '/intelligence definition <file> <line> <column>', 'check definition lookup for an exact source position', C),
+        buildGuidanceLine(width, '/intelligence references <file> <line> <column>', 'review reference lookup for a symbol under the cursor', C),
+        buildGuidanceLine(width, '/intelligence hover <file> <line> <column>', 'inspect hover/details posture for a specific source position', C),
+      ],
+    });
+
+    if (degraded > 0) {
+      sections.push({
+        title: 'Recovery',
+        lines: [
+          buildPanelLine(width, [[' Workspace intelligence is not fully ready. Review LSP/tree-sitter setup and workspace language configuration.', C.warn]]),
+          buildGuidanceLine(width, '/health review', 'check setup and readiness failures that could block diagnostics and symbol search', C),
+          buildGuidanceLine(width, '/setup review', 'review startup and environment posture for intelligence dependencies', C),
+          buildGuidanceLine(width, '/intelligence repair', 'show repair-oriented commands for diagnostics, symbols, hover, and completions', C),
+          buildGuidanceLine(width, '/health repair intelligence', 'show repair commands plus post-repair verification for the intelligence domain', C),
+        ],
+      });
+    } else {
+      sections.push({
+        title: 'Recovery',
+        lines: [
+          buildPanelLine(width, [[' Intelligence surfaces are healthy and ready for code-aware workflows.', C.dim]]),
+          buildGuidanceLine(width, '/health intelligence', 'verify readiness posture after setup changes or dependency recovery', C),
+        ],
+      });
+    }
+
+    const lines = buildPanelWorkspace(width, height, {
+      title: 'Intelligence Control Room',
+      intro: 'Workspace intelligence posture across diagnostics, symbol search, hover, and completion readiness.',
+      sections,
+      footerLines: [buildPanelLine(width, [[' /symbols  /intelligence diagnostics  /intelligence symbols <file>  /intelligence definition <file> <line> <column> ', C.dim]])],
+      palette: C,
+    });
+    while (lines.length < height) lines.push(createEmptyLine(width));
+    return lines.slice(0, height);
+  }
+}