@pellux/goodvibes-agent 0.1.0

package/src/panels/memory-panel.ts

@@ -0,0 +1,225 @@
+/**
+ * MemoryPanel — project memory substrate TUI panel.
+ *
+ * Migrated to SearchableListPanel<MemoryRecord> (Wave B1).
+ */
+
+import type { Line } from '../types/grid.ts';
+import type { MemoryRegistry } from '@pellux/goodvibes-sdk/platform/state';
+import type { MemoryRecord, MemoryClass } from '@pellux/goodvibes-sdk/platform/state';
+import { SearchableListPanel } from './scrollable-list-panel.ts';
+import {
+  buildBodyText,
+  buildGuidanceLine,
+  buildKeyValueLine,
+  buildPanelLine,
+  extendPalette,
+  DEFAULT_PANEL_PALETTE,
+} from './polish.ts';
+import {
+  getPanelSearchFocusTransition,
+  isPanelSearchCancel,
+} from './search-focus.ts';
+
+const C = extendPalette(DEFAULT_PANEL_PALETTE, {
+  header: '#94a3b8',
+  headerBg: '#1e293b',
+  decision: '#38bdf8',
+  constraint: '#f97316',
+  incident: '#ef4444',
+  pattern: '#a78bfa',
+  fact: '#22c55e',
+  risk: '#f43f5e',
+  runbook: '#eab308',
+  architecture: '#60a5fa',
+  ownership: '#14b8a6',
+  selected: '#1e3a5f',
+  searchBg: '#0f172a',
+  searchFg: '#e2e8f0',
+});
+
+function fmtTime(ts: number): string {
+  const d = new Date(ts);
+  return d.toISOString().slice(0, 16).replace('T', ' ');
+}
+
+function classColor(cls: MemoryClass): string {
+  switch (cls) {
+    case 'decision': return C.decision;
+    case 'constraint': return C.constraint;
+    case 'incident': return C.incident;
+    case 'pattern': return C.pattern;
+    case 'fact': return C.fact;
+    case 'risk': return C.risk;
+    case 'runbook': return C.runbook;
+    case 'architecture': return C.architecture;
+    case 'ownership': return C.ownership;
+  }
+}
+
+export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
+  private registry: MemoryRegistry;
+  private filterFocused = false;
+  private unsubscribe?: () => void;
+
+  constructor(registry: MemoryRegistry) {
+    super('memory', 'Memory', 'M', 'agent');
+    this.registry = registry;
+  }
+
+  onActivate(): void {
+    super.onActivate();
+    this.searchQuery = '';
+    this.invalidateFilter();
+    this.filterFocused = false;
+    this.unsubscribe = this.registry.subscribe(() => {
+      this.invalidateFilter();
+      this.markDirty();
+    });
+  }
+
+  onDeactivate(): void {
+    super.onDeactivate();
+  }
+
+  onDestroy(): void {
+    this.unsubscribe?.();
+    this.unsubscribe = undefined;
+  }
+
+  // ---------------------------------------------------------------------------
+  // SearchableListPanel implementation
+  // ---------------------------------------------------------------------------
+
+  protected getAllItems(): readonly MemoryRecord[] {
+    return this.registry.search({ limit: 100 });
+  }
+
+  protected matchesSearch(record: MemoryRecord, query: string): boolean {
+    const q = query.trim().toLowerCase();
+    if (!q) return true;
+    const haystack = [
+      record.summary,
+      record.detail ?? '',
+      record.cls,
+      record.scope,
+      record.tags.join(' '),
+    ].join(' ').toLowerCase();
+    return haystack.includes(q);
+  }
+
+  protected renderItem(record: MemoryRecord, index: number, selected: boolean, width: number): Line {
+    const bg = selected ? C.selected : undefined;
+    return buildPanelLine(width, [
+      ['  ', C.label, bg],
+      [`[${record.scope.slice(0, 1).toUpperCase()}/${record.cls.slice(0, 3).toUpperCase()}] `, classColor(record.cls), bg],
+      [record.id.slice(-8), C.dim, bg],
+      ['  ', C.label, bg],
+      [fmtTime(record.createdAt), C.dim, bg],
+      ['  ', C.label, bg],
+      [record.summary.slice(0, Math.max(0, width - 33)), C.value, bg],
+    ]);
+  }
+
+  protected override getPalette() { return C; }
+  protected override getEmptyStateMessage() {
+    return this.searchQuery
+      ? ` No records matching "${this.searchQuery}"`
+      : ' No memory records. Use /recall add <class> <summary> to create one.';
+  }
+  protected override getEmptyStateActions() {
+    return [
+      { command: '/recall add fact <summary>', summary: 'capture a durable fact directly' },
+      { command: '/recall capture incident latest', summary: 'promote the latest incident into memory' },
+    ];
+  }
+
+  handleInput(key: string): boolean {
+    // Filter-focus mode: typing goes into the search query
+    if (this.filterFocused) {
+      const items = this.getItems();
+      const transition = getPanelSearchFocusTransition(key, { selectedIndex: this.selectedIndex, itemCount: items.length });
+      if (transition === 'focus-list') {
+        this.filterFocused = false;
+        this.markDirty();
+        return true;
+      }
+      if (isPanelSearchCancel(key)) {
+        this.filterFocused = false;
+        return super.handleInput(key);
+      }
+      return super.handleInput(key);
+    }
+
+    const items = this.getItems();
+    const transition = getPanelSearchFocusTransition(key, { selectedIndex: this.selectedIndex, itemCount: items.length });
+    if (transition === 'focus-search') {
+      this.filterFocused = true;
+      this.markDirty();
+      return true;
+    }
+
+    if (key === 'r') {
+      this.invalidateFilter();
+      this.markDirty();
+      return true;
+    }
+
+    return super.handleInput(key);
+  }
+
+  render(width: number, height: number): Line[] {
+    this.clampSelection();
+    const intro = 'Durable project memory across decisions, constraints, incidents, patterns, risks, runbooks, and related provenance.';
+
+    const records = this.getItems();
+    const byClass = new Map<MemoryClass, number>();
+    for (const record of records) {
+      byClass.set(record.cls, (byClass.get(record.cls) ?? 0) + 1);
+    }
+
+    const filterLine = this.buildFilterInputLine(width, 'Filter', this.filterFocused);
+
+    const summaryLines: Line[] = [
+      buildKeyValueLine(width, [
+        { label: 'records', value: String(records.length), valueColor: C.value },
+        { label: 'facts', value: String(byClass.get('fact') ?? 0), valueColor: C.fact },
+        { label: 'decisions', value: String(byClass.get('decision') ?? 0), valueColor: C.decision },
+        { label: 'incidents', value: String(byClass.get('incident') ?? 0), valueColor: C.incident },
+        { label: 'runbooks', value: String(byClass.get('runbook') ?? 0), valueColor: C.runbook },
+      ], C),
+      filterLine,
+      buildGuidanceLine(width, '/recall review', 'review durable knowledge and queue posture from the command surface', C),
+    ];
+
+    const selected = records[this.selectedIndex];
+    const selectedLines: Line[] = [];
+    if (selected) {
+      selectedLines.push(buildKeyValueLine(width, [
+        { label: 'scope', value: selected.scope, valueColor: C.info },
+        { label: 'class', value: selected.cls, valueColor: classColor(selected.cls) },
+        { label: 'created', value: fmtTime(selected.createdAt), valueColor: C.dim },
+      ], C));
+      selectedLines.push(...buildBodyText(width, selected.summary, C, C.value));
+      if (selected.detail) selectedLines.push(...buildBodyText(width, `Detail: ${selected.detail}`, C, C.dim));
+      if (selected.tags.length) selectedLines.push(buildPanelLine(width, [[`  Tags: ${selected.tags.join(', ')}`, C.good]]));
+      if (selected.provenance.length) {
+        selectedLines.push(...buildBodyText(
+          width,
+          `Provenance: ${selected.provenance.map((p) => `${p.kind}:${p.ref}`).join('  ')}`,
+          C,
+          C.dim,
+        ));
+      }
+    }
+
+    return this.renderList(width, height, {
+      title: 'Memory',
+      header: summaryLines,
+      footer: [
+        ...selectedLines,
+        buildPanelLine(width, [['  / search  j/k or Up/Down move  r reload  Esc clear search', C.dim]]),
+      ],
+    });
+  }
+}

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

@@ -0,0 +1,150 @@
+/**
+ * OpsControlPanel — operator control plane UI panel.
+ *
+ * Renders the ops audit log sourced from the OpsPanel diagnostics subscriber.
+ * Each entry shows: seq, timestamp, action, target, outcome, and optional note.
+ *
+ * Requires the `operator-control-plane` feature flag to be enabled.
+ * Open via Ctrl+O keybind or `/ops view` command.
+ */
+import type { Line } from '../types/grid.ts';
+import type { OpsEvent } from '@/runtime/index.ts';
+import type { UiEventFeed } from '../runtime/ui-events.ts';
+import type { OpsAuditEntry } from '../runtime/diagnostics/panels/ops.ts';
+import { OpsPanel } from '../runtime/diagnostics/panels/ops.ts';
+import { ScrollableListPanel } from './scrollable-list-panel.ts';
+import {
+  buildPanelLine,
+  DEFAULT_PANEL_PALETTE,
+  type PanelPalette,
+} from './polish.ts';
+
+// ── Colour palette ──────────────────────────────────────────────────────────
+const C = {
+  ...DEFAULT_PANEL_PALETTE,
+  header:     '#94a3b8',
+  headerBg:   '#1e293b',
+  success:    '#22c55e',
+  rejected:   '#f97316',
+  error:      '#ef4444',
+  dim:        '#4b5563',
+  label:      '#64748b',
+  value:      '#cbd5e1',
+  note:       '#eab308',
+  seq:        '#475569',
+  taskColor:  '#22d3ee',
+  agentColor: '#a78bfa',
+  empty:      '#334155',
+  selectBg:   '#0f172a',
+} as const;
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function fmtTime(ts: number): string {
+  const d = new Date(ts);
+  const hh = String(d.getHours()).padStart(2, '0');
+  const mm = String(d.getMinutes()).padStart(2, '0');
+  const ss = String(d.getSeconds()).padStart(2, '0');
+  return `${hh}:${mm}:${ss}`;
+}
+
+function outcomeColor(outcome: OpsAuditEntry['outcome']): string {
+  switch (outcome) {
+    case 'success':  return C.success;
+    case 'rejected': return C.rejected;
+    case 'error':    return C.error;
+  }
+}
+
+function outcomeLabel(outcome: OpsAuditEntry['outcome']): string {
+  switch (outcome) {
+    case 'success':  return 'OK    ';
+    case 'rejected': return 'REJECT';
+    case 'error':    return 'ERR   ';
+  }
+}
+
+function targetColor(kind: OpsAuditEntry['targetKind']): string {
+  return kind === 'task' ? C.taskColor : C.agentColor;
+}
+
+// ── OpsControlPanel ──────────────────────────────────────────────────────────
+
+export class OpsControlPanel extends ScrollableListPanel<OpsAuditEntry> {
+  private readonly _opsPanel: OpsPanel;
+  private _unsub: (() => void) | null = null;
+
+  public constructor(eventFeed: UiEventFeed<OpsEvent>) {
+    super('ops-control', 'Ops Control', 'Q', 'agent');
+    this.showSelectionGutter = true; // I5: non-color selection affordance
+    this._opsPanel = new OpsPanel(eventFeed);
+    this._unsub = this._opsPanel.subscribe(() => this.markDirty());
+  }
+
+  public override onActivate(): void {
+    super.onActivate();
+    this.selectedIndex = 0;
+  }
+
+  public override onDestroy(): void {
+    if (this._unsub) {
+      this._unsub();
+      this._unsub = null;
+    }
+    this._opsPanel.dispose();
+  }
+
+  protected override getPalette(): PanelPalette {
+    return C;
+  }
+
+  protected getItems(): readonly OpsAuditEntry[] {
+    // Return reversed so newest entries appear at top
+    return [...this._opsPanel.getSnapshot()].reverse();
+  }
+
+  protected renderItem(entry: OpsAuditEntry, _index: number, _selected: boolean, width: number): Line {
+    const seqStr   = String(entry.seq).padStart(4, ' ');
+    const timeStr  = fmtTime(entry.ts);
+    const action   = entry.action.slice(0, 15).padEnd(15, ' ');
+    const kindTag  = entry.targetKind === 'task' ? 'T:' : 'A:';
+    // Truncation is intentional: TUI column width limits target ID display to 14 chars
+    const shortId  = entry.targetId.slice(-10);
+    const target   = (kindTag + shortId).slice(0, 14).padEnd(14, ' ');
+    const outLabel = outcomeLabel(entry.outcome);
+    const noteRaw  = (entry.note ?? entry.errorMessage ?? '').slice(0, Math.max(0, width - 63));
+
+    const segs: Array<[string, string, string?]> = [
+      [` ${seqStr} `, C.seq],
+      [`${timeStr} `, C.dim],
+      [`${action} `, C.value],
+      [`${target}  `, targetColor(entry.targetKind)],
+      [outLabel, outcomeColor(entry.outcome)],
+    ];
+    if (noteRaw) segs.push([` ${noteRaw}`, C.note]);
+    return buildPanelLine(width, segs);
+  }
+
+  protected override getEmptyStateMessage(): string {
+    return ' No operator interventions recorded.';
+  }
+
+  protected override getEmptyStateActions(): Array<{ command: string; summary: string }> {
+    return [{ command: '/cockpit', summary: 'open the cockpit and drive runtime interventions from the control rooms' }];
+  }
+
+  public render(width: number, height: number): Line[] {
+    const headerLines: Line[] = [
+      buildPanelLine(width, [['  SEQ  TIME      ACTION          TARGET             OUT    NOTE', C.label]]),
+    ];
+    const footerLines: Line[] = [
+      buildPanelLine(width, [['  Up/Down scroll the intervention log', C.dim]]),
+    ];
+
+    return this.renderList(width, height, {
+      title: 'Operator Control Plane',
+      header: headerLines,
+      footer: footerLines,
+    });
+  }
+}

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

@@ -0,0 +1,235 @@
+/**
+ * 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;
+  }
+}