@pellux/goodvibes-agent 0.1.59 → 0.1.60

package/src/input/commands/intelligence-runtime.ts

@@ -1,223 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import type { CommandContext, CommandRegistry } from '../command-registry.ts';
-import { CodeIntelligence } from '@pellux/goodvibes-sdk/platform/intelligence';
-import type { DocumentSymbol } from '@pellux/goodvibes-sdk/platform/intelligence';
-import type { SymbolInfo } from '@pellux/goodvibes-sdk/platform/intelligence';
-import { openCommandPanel, requireReadModels, requireShellPaths } from './runtime-services.ts';
-
-function resolveTargetPath(pathArg: string, ctx: CommandContext): string {
-  return requireShellPaths(ctx).resolveWorkspacePath(pathArg);
-}
-
-function parsePosition(lineArg: string | undefined, columnArg: string | undefined): { line: number; column: number } | null {
-  const line = Number.parseInt(lineArg ?? '', 10);
-  const column = Number.parseInt(columnArg ?? '', 10);
-  if (!Number.isFinite(line) || line < 1 || !Number.isFinite(column) || column < 1) return null;
-  return { line: line - 1, column: column - 1 };
-}
-
-function formatSymbolKind(kind: number | string | undefined): string {
-  if (typeof kind === 'number') return `kind=${kind}`;
-  if (typeof kind === 'string' && kind.trim().length > 0) return kind;
-  return 'symbol';
-}
-
-function formatDocumentSymbol(symbol: DocumentSymbol): string {
-  const line = (symbol.selectionRange?.start.line ?? symbol.range.start.line) + 1;
-  const column = (symbol.selectionRange?.start.character ?? symbol.range.start.character) + 1;
-  return `  ${symbol.name}  ${formatSymbolKind(symbol.kind)}  ${line}:${column}`;
-}
-
-function formatTreeSitterSymbol(symbol: SymbolInfo): string {
-  return `  ${symbol.name}  ${formatSymbolKind(symbol.kind)}  ${symbol.line + 1}:${symbol.column + 1}`;
-}
-
-function ensureExistingFile(pathArg: string | undefined, ctx: CommandContext): string | null {
-  if (!pathArg) {
-    ctx.print('Intelligence Review\n  Missing file path.');
-    return null;
-  }
-  const targetPath = resolveTargetPath(pathArg, ctx);
-  if (!existsSync(targetPath)) {
-    ctx.print(`Intelligence Review\n  File not found: ${targetPath}`);
-    return null;
-  }
-  return targetPath;
-}
-
-export function registerIntelligenceRuntimeCommands(registry: CommandRegistry): void {
-  registry.register({
-    name: 'intelligence',
-    aliases: ['intel'],
-    description: 'Review workspace intelligence readiness, diagnostics posture, and symbol search availability',
-    usage: '[review|panel|diagnostics [file]|symbols <file>|outline <file>|definition <file> <line> <column>|references <file> <line> <column>|hover <file> <line> <column>|repair]',
-    async handler(args, ctx) {
-      const sub = (args[0] ?? 'review').toLowerCase();
-      if (sub === 'panel' || sub === 'open') {
-        openCommandPanel(ctx, 'intelligence');
-        return;
-      }
-
-      const intelligence = new CodeIntelligence();
-      const state = requireReadModels(ctx).intelligence.getSnapshot();
-
-      if (sub === 'symbols' || sub === 'outline') {
-        const targetPath = ensureExistingFile(args[1], ctx);
-        if (!targetPath) return;
-        const content = readFileSync(targetPath, 'utf-8');
-        if (sub === 'symbols') {
-          const symbols = await intelligence.getDocumentSymbols(targetPath, content);
-          const entries = symbols.slice(0, 12).map((symbol) => ('selectionRange' in symbol ? formatDocumentSymbol(symbol) : formatTreeSitterSymbol(symbol)));
-          ctx.print([
-            `Intelligence Symbols: ${targetPath}`,
-            `  source: ${state.symbolSearchStatus === 'ready' ? 'LSP/tree-sitter' : 'best-effort tree-sitter/LSP fallback'}`,
-            `  status: ${state.symbolSearchStatus}`,
-            `  results: ${symbols.length}`,
-            ...(entries.length > 0 ? entries : ['  No symbols available for this file.']),
-            '  next: /health intelligence',
-          ].join('\n'));
-          return;
-        }
-
-        const outline = await intelligence.getOutline(targetPath, content);
-        ctx.print([
-          `Intelligence Outline: ${targetPath}`,
-          `  source: tree-sitter outline extraction`,
-          `  language ready: ${intelligence.hasTreeSitter(targetPath) ? 'yes' : 'no'}`,
-          `  results: ${outline.length}`,
-          ...(outline.slice(0, 12).map((entry) => `  ${entry.signature || entry.name}  line ${entry.line}`)),
-          ...(outline.length === 0 ? ['  No outline entries available for this file.'] : []),
-          '  next: /intelligence symbols ' + targetPath,
-        ].join('\n'));
-        return;
-      }
-
-      if (sub === 'definition' || sub === 'references' || sub === 'hover') {
-        const targetPath = ensureExistingFile(args[1], ctx);
-        if (!targetPath) return;
-        const position = parsePosition(args[2], args[3]);
-        if (!position) {
-          ctx.print(`Intelligence ${sub[0]!.toUpperCase()}${sub.slice(1)}\n  Usage: /intelligence ${sub} <file> <line> <column>`);
-          return;
-        }
-
-        if (sub === 'definition') {
-          const definition = await intelligence.getDefinition(targetPath, position.line, position.column);
-          ctx.print([
-            `Intelligence Definition: ${targetPath}:${position.line + 1}:${position.column + 1}`,
-            `  status: ${state.hoverStatus === 'ready' || state.symbolSearchStatus === 'ready' ? 'available' : 'best-effort'}`,
-            ...(definition
-              ? [
-                  `  target: ${definition.uri}`,
-                  `  line: ${definition.range.start.line + 1}`,
-                  `  column: ${definition.range.start.character + 1}`,
-                  '  next: open the target file or use /intelligence references on the same symbol',
-                ]
-              : ['  No definition was returned for that position.', '  next: /health intelligence']),
-          ].join('\n'));
-          return;
-        }
-
-        if (sub === 'references') {
-          const references = await intelligence.getReferences(targetPath, position.line, position.column);
-          ctx.print([
-            `Intelligence References: ${targetPath}:${position.line + 1}:${position.column + 1}`,
-            `  status: ${state.symbolSearchStatus}`,
-            `  results: ${references.length}`,
-            ...(references.slice(0, 12).map((reference) => `  ${reference.uri}  ${reference.range.start.line + 1}:${reference.range.start.character + 1}`)),
-            ...(references.length === 0 ? ['  No references were returned for that position.'] : []),
-            '  next: /intelligence definition ' + `${targetPath} ${position.line + 1} ${position.column + 1}`,
-          ].join('\n'));
-          return;
-        }
-
-        const hover = await intelligence.getHover(targetPath, position.line, position.column);
-        const hoverLines = typeof hover?.contents === 'string'
-          ? hover.contents.split('\n')
-          : Array.isArray(hover?.contents)
-            ? hover.contents.flatMap((entry) => typeof entry === 'string' ? entry : entry.value.split('\n'))
-            : hover?.contents && 'value' in hover.contents
-              ? hover.contents.value.split('\n')
-              : [];
-        ctx.print([
-          `Intelligence Hover: ${targetPath}:${position.line + 1}:${position.column + 1}`,
-          `  status: ${state.hoverStatus}`,
-          ...(hoverLines.length > 0 ? hoverLines.slice(0, 8).map((line) => `  ${line}`) : ['  No hover information was returned for that position.']),
-          '  next: /health intelligence',
-        ].join('\n'));
-        return;
-      }
-
-      if (sub === 'diagnostics') {
-        const file = args[1];
-        const entries = [...state.diagnostics.entries()]
-          .map(([filePath, diagnostics]) => ({
-            filePath,
-            diagnostics,
-            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));
-        const selected = file
-          ? entries.find((entry) => entry.filePath === file)
-          : entries[0];
-        if (!selected) {
-          ctx.print('Intelligence Diagnostics\n  No diagnostics are currently tracked.');
-          return;
-        }
-        ctx.print([
-          `Intelligence Diagnostics: ${selected.filePath}`,
-          `  errors: ${selected.errors}`,
-          `  warnings: ${selected.warnings}`,
-          ...selected.diagnostics.slice(0, 8).map((diagnostic) => (
-            `  [${diagnostic.severity}] ${diagnostic.line + 1}:${diagnostic.column + 1} ${diagnostic.message}`
-          )),
-          ...(entries.length > 1 ? [`  next: /intelligence diagnostics ${entries[1]!.filePath}`] : []),
-        ].join('\n'));
-        return;
-      }
-
-      if (sub === 'repair') {
-        const lines = [
-          'Intelligence Repair',
-          '  verify: /health intelligence',
-          ...(state.diagnosticsStatus !== 'ready' ? ['  /setup review', '  /health intelligence'] : []),
-          ...(state.symbolSearchStatus !== 'ready' ? ['  /symbols', '  /intelligence symbols <file>', '  /health intelligence'] : []),
-          ...(state.completionsStatus !== 'ready' || state.hoverStatus !== 'ready'
-            ? ['  /intelligence review', '  /intelligence hover <file> <line> <column>', '  /setup onboarding']
-            : []),
-        ];
-        ctx.print(lines.length > 1 ? lines.join('\n') : 'Intelligence Repair\n  No active repair actions suggested.');
-        return;
-      }
-
-      const issues: string[] = [];
-      if (state.diagnosticsStatus !== 'ready') issues.push(`diagnostics=${state.diagnosticsStatus}`);
-      if (state.symbolSearchStatus !== 'ready') issues.push(`symbols=${state.symbolSearchStatus}`);
-      if (state.completionsStatus !== 'ready') issues.push(`completions=${state.completionsStatus}`);
-      if (state.hoverStatus !== 'ready') issues.push(`hover=${state.hoverStatus}`);
-
-      ctx.print([
-        'Intelligence Review',
-        `  diagnostics: ${state.diagnosticsStatus}`,
-        `  symbols: ${state.symbolSearchStatus}`,
-        `  completions: ${state.completionsStatus}`,
-        `  hover: ${state.hoverStatus}`,
-        `  errors: ${state.errorCount}`,
-        `  warnings: ${state.warningCount}`,
-        `  requests: ${state.totalRequests}`,
-        `  avg latency: ${Math.round(state.avgLatencyMs)}ms`,
-        ...(issues.length > 0 ? [`  issues: ${issues.join(', ')}`] : ['  issues: none']),
-        `  diagnostic files: ${state.diagnostics.size}`,
-        ...(state.diagnostics.size > 0 ? ['  next: /intelligence diagnostics'] : []),
-        '  next: /intelligence symbols <file>',
-        '  next: /intelligence outline <file>',
-        '  next: /intelligence references <file> <line> <column>',
-        '  next: /intelligence definition <file> <line> <column>',
-        '  next: /intelligence hover <file> <line> <column>',
-        '  next: /intelligence repair',
-      ].join('\n'));
-    },
-  });
-}

package/src/panels/debug-panel.ts

@@ -1,432 +0,0 @@
-import { BasePanel } from './base-panel.ts';
-import { createEmptyLine, createStyledCell, type Line } from '../types/grid.ts';
-import type { TurnEvent } from '@/runtime/index.ts';
-import type { UiEventFeed } from '../runtime/ui-events.ts';
-import type { Orchestrator } from '../core/orchestrator';
-import {
-  buildEmptyState,
-  buildPanelLine,
-  buildStyledPanelLine,
-  buildPanelWorkspace,
-  resolveScrollablePanelSection,
-  resolveStackedScrollableSections,
-  DEFAULT_PANEL_PALETTE,
-  type PanelWorkspaceSection,
-} from './polish.ts';
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export type ApiCallStatus = 'ok' | 'error';
-
-export interface ApiCallEntry {
-  /** Wall-clock timestamp when the call completed. */
-  ts: number;
-  /** Provider name (e.g. "anthropic"). */
-  provider: string;
-  /** Model id (e.g. "claude-sonnet-4-5"). */
-  model: string;
-  /** Input tokens for this call. */
-  inputTokens: number;
-  /** Output tokens for this call. */
-  outputTokens: number;
-  /** End-to-end latency in ms (stream-start → llm-response, or turn-start → llm-response). */
-  latencyMs: number;
-  /** HTTP-level status code hint; 0 when unknown. */
-  statusCode: number;
-  /** 'ok' | 'error' */
-  status: ApiCallStatus;
-  /** Trimmed error message when status === 'error'. */
-  errorMessage?: string;
-}
-
-// ---------------------------------------------------------------------------
-// Constants / limits
-// ---------------------------------------------------------------------------
-
-const MAX_CALL_LOG   = 50;
-const MAX_ERROR_LOG  = 20;
-
-// ---------------------------------------------------------------------------
-// Colors
-// ---------------------------------------------------------------------------
-
-const C = {
-  title:      '#00ffff',
-  ok:         '#5fd700',
-  error:      '#ff5f5f',
-  warn:       '#ffaf00',
-  label:      '244',
-  value:      '252',
-  dim:        '240',
-  provName:   '#e2e8f0',
-  separator:  '#374151',
-  input:      '#00ffff',
-  output:     '#d000ff',
-  latGood:    '#5fd700',
-  latWarn:    '#ffaf00',
-  latBad:     '#ff5f5f',
-  sectionHdr: '238',
-  colHdr:     '242',
-} as const;
-
-const LATENCY_WARN_MS = 2_000;
-const LATENCY_BAD_MS  = 5_000;
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function fmtTok(n: number): string {
-  if (n < 10_000) return String(n);
-  if (n < 1_000_000) return (n / 1000).toFixed(1) + 'k';
-  return (n / 1_000_000).toFixed(2) + 'M';
-}
-
-function fmtMs(ms: number): string {
-  if (ms <= 0)       return 'n/a';
-  if (ms >= 10_000)  return `${(ms / 1000).toFixed(1)}s`;
-  if (ms >= 1_000)   return `${(ms / 1000).toFixed(2)}s`;
-  return `${Math.round(ms)}ms`;
-}
-
-function fmtAgo(ts: number): string {
-  const sec = Math.floor((Date.now() - ts) / 1000);
-  if (sec < 60)   return `${sec}s ago`;
-  if (sec < 3600) return `${Math.floor(sec / 60)}m ago`;
-  return `${Math.floor(sec / 3600)}h ago`;
-}
-
-function latColor(ms: number): string {
-  if (ms >= LATENCY_BAD_MS)  return C.latBad;
-  if (ms >= LATENCY_WARN_MS) return C.latWarn;
-  return C.latGood;
-}
-
-function statusCodeFromError(msg: string): number {
-  const m = msg.match(/\b(4\d{2}|5\d{2})\b/);
-  return m ? parseInt(m[1]!, 10) : 0;
-}
-
-// ---------------------------------------------------------------------------
-// DebugPanel
-// ---------------------------------------------------------------------------
-
-/**
- * Real-time API debug panel.
- *
- * Shows per-call log (model, provider, input/output tokens, latency, status code),
- * running session call total, and error history.
- *
- * Subscribes to typed turn runtime events.
- */
-export class DebugPanel extends BasePanel {
-  private _unsubs: Array<() => void> = [];
-
-  // Timing state
-  private _turnStartMs: number | null = null;
-  private _streamStartMs: number | null = null;
-
-  // Token delta tracking (requires wired orchestrator)
-  private _orchestrator: Orchestrator | null = null;
-  private _prevInput  = 0;
-  private _prevOutput = 0;
-
-  // Session data
-  private _calls: ApiCallEntry[]  = [];
-  private _errors: ApiCallEntry[] = [];
-  private _totalCalls = 0;
-  private _totalErrors = 0;
-
-  constructor(
-    private readonly turnEvents: UiEventFeed<TurnEvent>,
-    private readonly requestRender: () => void = () => {},
-  ) {
-    super('debug', 'Debug', 'B', 'monitoring');
-    this._subscribe();
-  }
-
-  // -------------------------------------------------------------------------
-  // External wiring
-  // -------------------------------------------------------------------------
-
-  /**
-   * Optionally wire to the main Orchestrator so per-call token deltas can be
-   * computed. Call once after construction.
-   */
-  wireOrchestrator(orchestrator: Orchestrator): void {
-    this._orchestrator = orchestrator;
-  }
-
-  // -------------------------------------------------------------------------
-  // Event subscription
-  // -------------------------------------------------------------------------
-
-  private _subscribe(): void {
-    this._unsubs.push(
-      this.turnEvents.on('TURN_SUBMITTED', () => {
-        this._turnStartMs  = Date.now();
-        this._streamStartMs = null;
-      }),
-    );
-
-    this._unsubs.push(
-      this.turnEvents.on('STREAM_START', () => {
-        this._streamStartMs = Date.now();
-      }),
-    );
-
-    this._unsubs.push(
-      this.turnEvents.on('LLM_RESPONSE_RECEIVED', (env) => {
-        const now = Date.now();
-        const latencyMs =
-          this._streamStartMs !== null
-            ? now - this._streamStartMs
-            : this._turnStartMs !== null
-              ? now - this._turnStartMs
-              : 0;
-        this._streamStartMs = null;
-
-        // Compute per-call token delta if orchestrator is wired
-        let inputTokens  = env.inputTokens + (env.cacheReadTokens ?? 0) + (env.cacheWriteTokens ?? 0);
-        let outputTokens = env.outputTokens;
-        if (this._orchestrator) {
-          const cu = this._orchestrator.usage;
-          inputTokens  = Math.max(0, cu.input  - this._prevInput);
-          outputTokens = Math.max(0, cu.output - this._prevOutput);
-          this._prevInput  = cu.input;
-          this._prevOutput = cu.output;
-        }
-
-        const entry: ApiCallEntry = {
-          ts: now,
-          provider: env.provider,
-          model: env.model,
-          inputTokens,
-          outputTokens,
-          latencyMs,
-          statusCode: 200,
-          status: 'ok',
-        };
-        this._pushCall(entry);
-        this.markDirty();
-        this.requestRender();
-      }),
-    );
-
-    this._unsubs.push(
-      this.turnEvents.on('TURN_ERROR', (env) => {
-        this._streamStartMs = null;
-        this._turnStartMs   = null;
-
-        const msg  = env.error;
-        const code = statusCodeFromError(msg);
-
-        const entry: ApiCallEntry = {
-          ts: Date.now(),
-          provider: 'unknown',
-          model: 'unknown',
-          inputTokens:  0,
-          outputTokens: 0,
-          latencyMs:    0,
-          statusCode:   code,
-          status:       'error',
-          errorMessage: msg.slice(0, 120),
-        };
-        this._pushCall(entry);
-        this._pushError(entry);
-        this.markDirty();
-        this.requestRender();
-      }),
-    );
-  }
-
-  private _pushCall(entry: ApiCallEntry): void {
-    this._totalCalls++;
-    this._calls.push(entry);
-    if (this._calls.length > MAX_CALL_LOG) this._calls.shift();
-  }
-
-  private _pushError(entry: ApiCallEntry): void {
-    this._totalErrors++;
-    this._errors.push(entry);
-    if (this._errors.length > MAX_ERROR_LOG) this._errors.shift();
-  }
-
-  // -------------------------------------------------------------------------
-  // Lifecycle
-  // -------------------------------------------------------------------------
-
-  override onDestroy(): void {
-    for (const unsub of this._unsubs) unsub();
-    this._unsubs = [];
-  }
-
-  // -------------------------------------------------------------------------
-  // Rendering
-  // -------------------------------------------------------------------------
-
-  override render(width: number, height: number): Line[] {
-    const sections: PanelWorkspaceSection[] = [
-      {
-        title: 'Session',
-        lines: this._renderSummary(width),
-      },
-    ];
-
-    if (this._calls.length === 0) {
-      sections.push({
-        title: 'API Call Log',
-        lines: buildEmptyState(
-          width,
-          ' No calls yet',
-          'Completed provider calls and API failures will appear here with timing, token counts, and status codes.',
-          [],
-          DEFAULT_PANEL_PALETTE,
-        ),
-      });
-    } else {
-      const rows = this._renderCallLog(width);
-      if (this._errors.length > 0) {
-        const errors = this._renderErrorHistory(width);
-        const [callSection, errorSection] = resolveStackedScrollableSections(width, height, {
-          palette: DEFAULT_PANEL_PALETTE,
-          beforeSections: sections,
-          sections: [
-            {
-              title: 'API Call Log',
-              scrollableLines: rows,
-              scrollOffset: Math.max(0, rows.length - 1),
-              minRows: 8,
-              weight: 2,
-            },
-            {
-              title: 'Error History',
-              scrollableLines: errors,
-              scrollOffset: Math.max(0, errors.length - 1),
-              minRows: 4,
-              weight: 1,
-            },
-          ],
-        });
-        sections.push(callSection!.section, errorSection!.section);
-      } else {
-        const callSection = resolveScrollablePanelSection(width, height, {
-          palette: DEFAULT_PANEL_PALETTE,
-          beforeSections: sections,
-          section: {
-            title: 'API Call Log',
-            scrollableLines: rows,
-            scrollOffset: Math.max(0, rows.length - 1),
-            minRows: 8,
-          },
-        });
-        sections.push(callSection.section);
-      }
-    }
-
-    return buildPanelWorkspace(width, height, {
-      title: ' API Debug',
-      intro: 'Recent provider calls, token deltas, latency, status codes, and error history.',
-      sections,
-      palette: DEFAULT_PANEL_PALETTE,
-    });
-  }
-
-  // -------------------------------------------------------------------------
-  // Section renderers
-  // -------------------------------------------------------------------------
-
-  private _renderSummary(width: number): Line[] {
-    const errCount = this._totalErrors;
-    const okCount  = this._totalCalls - this._totalErrors;
-    return [
-      buildStyledPanelLine(width, [
-        { text: ' Calls: ', fg: C.label },
-        { text: String(this._totalCalls), fg: C.value },
-        { text: '  OK: ', fg: C.label },
-        { text: String(okCount), fg: C.ok },
-        { text: '  Errors: ', fg: C.label },
-        { text: String(errCount), fg: errCount > 0 ? C.error : C.dim },
-      ]),
-    ];
-  }
-
-  private _renderCallLog(width: number): Line[] {
-    const lines: Line[] = [];
-    lines.push(this._callLogHeader(width));
-    for (const entry of this._calls) {
-      lines.push(this._callLogRow(entry, width));
-    }
-
-    return lines;
-  }
-
-  private _callLogHeader(width: number): Line {
-    // Layout: time(8) status(2) provider(12) model(20) in(8) out(8) lat(8)
-    const header = '  Time    S Provider     Model               In       Out      Lat';
-    return this._textLine(header.slice(0, width), C.colHdr, width, { dim: true });
-  }
-
-  private _callLogRow(e: ApiCallEntry, width: number): Line {
-    const timeStr    = fmtAgo(e.ts).padEnd(8);
-    const statusChar = e.status === 'ok' ? '✓' : '✕';
-    const statusFg   = e.status === 'ok' ? C.ok : C.error;
-    const provStr    = e.provider.slice(0, 11).padEnd(12);
-    const modelStr   = e.model.slice(0, 19).padEnd(20);
-    const inStr      = fmtTok(e.inputTokens).padStart(8);
-    const outStr     = fmtTok(e.outputTokens).padStart(8);
-    const latStr     = fmtMs(e.latencyMs).padStart(8);
-
-    const segments: Array<{ text: string; fg: string; bold?: boolean }> = [
-      { text: '  ' + timeStr, fg: C.dim },
-      { text: statusChar + ' ', fg: statusFg },
-      { text: provStr, fg: C.provName },
-      { text: modelStr, fg: C.value },
-      { text: inStr, fg: C.input },
-      { text: outStr, fg: C.output },
-      { text: latStr, fg: latColor(e.latencyMs) },
-    ];
-
-    // Append status code for errors
-    if (e.status === 'error' && e.statusCode > 0) {
-      segments.push({ text: ` [${e.statusCode}]`, fg: C.error });
-    }
-
-    return buildStyledPanelLine(
-      width,
-      segments.map((seg) => ({ text: seg.text, fg: seg.fg, bold: seg.bold })),
-    );
-  }
-
-  private _renderErrorHistory(width: number): Line[] {
-    const lines: Line[] = [];
-    for (const e of this._errors) {
-      lines.push(this._errorRow(e, width));
-    }
-
-    return lines;
-  }
-
-  private _errorRow(e: ApiCallEntry, width: number): Line {
-    const timeStr  = fmtAgo(e.ts).padEnd(8);
-    const codeStr  = e.statusCode > 0 ? `[${e.statusCode}] ` : '';
-    const msgStr   = (e.errorMessage ?? 'unknown error').slice(0, width - 12 - codeStr.length);
-    const full     = `  ${timeStr} ${codeStr}${msgStr}`;
-    return this._textLine(full.slice(0, width), C.error, width);
-  }
-
-  // -------------------------------------------------------------------------
-  // Line-builder helpers
-  // -------------------------------------------------------------------------
-
-  private _textLine(
-    text: string,
-    fg: string,
-    width: number,
-    opts: { dim?: boolean } = {},
-  ): Line {
-    return buildStyledPanelLine(width, [{ text, fg, dim: opts.dim }]);
-  }
-}