@pellux/goodvibes-agent 0.1.0

package/src/renderer/agent-detail-modal.ts

@@ -0,0 +1,331 @@
+import { readFile } from 'fs/promises';
+import { type Line } from '../types/grid.ts';
+import { ModalFactory } from './modal-factory.ts';
+import type { AgentManager } from '@pellux/goodvibes-sdk/platform/tools';
+import type { AgentMessageBus } from '@pellux/goodvibes-sdk/platform/agents';
+import type { WrfcController } from '@pellux/goodvibes-sdk/platform/agents';
+import { formatDuration } from './modal-utils.ts';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils';
+import { getOverlaySurfaceMetrics, getStableOverlayContentRows } from './overlay-viewport.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+
+// ─── Constants ────────────────────────────────────────────────────────────────
+
+const TOKENS_PER_TOOL_CALL = 400;
+const MAX_LOG_ENTRIES = 10;
+const AGENT_ID_DISPLAY_LENGTH = 16;
+
+export interface AgentDetailModalDeps {
+  readonly agentManager: Pick<AgentManager, 'getStatus'>;
+  readonly agentMessageBus: Pick<AgentMessageBus, 'getMessages'>;
+  readonly sessionLogPathResolver: (agentId: string) => string;
+  /** Optional — when supplied, constraint data from the agent's WRFC chain is shown (SDK 0.23.0). */
+  readonly wrfcController?: Pick<WrfcController, 'getChain'>;
+}
+
+// ─── AgentDetailModal ─────────────────────────────────────────────────────────
+
+/**
+ * AgentDetailModal — deep-view modal for a single running/completed agent.
+ *
+ * Displays task description, template, model, status, duration, tool-call
+ * count, estimated token usage, recent messages from AgentMessageBus, and
+ * the agent's current progress note.
+ */
+export class AgentDetailModal {
+  public active = false;
+  public agentId: string | null = null;
+
+  /** Cached JSONL log entries, loaded on open(). */
+  public logEntries: Record<string, unknown>[] = [];
+  public logTotal = 0;
+
+  private refreshTimer: ReturnType<typeof setInterval> | null = null;
+  private onRefresh: (() => void) | null = null;
+
+  constructor(readonly deps: AgentDetailModalDeps) {}
+
+  /** Set a callback to trigger re-render when log data updates. */
+  setOnRefresh(fn: () => void): void {
+    this.onRefresh = fn;
+  }
+
+  open(agentId: string): void {
+    this.agentId = agentId;
+    this.active = true;
+    this.logEntries = [];
+    this.logTotal = 0;
+    this.loadLog().catch((err) => { logger.debug('agent detail log load failed', { err }); });
+    // Auto-refresh log every 500ms while modal is open
+    if (this.refreshTimer) clearInterval(this.refreshTimer);
+    this.refreshTimer = setInterval(() => {
+      this.loadLog().then(() => this.onRefresh?.()).catch((err) => { logger.debug('agent detail log refresh tick failed', { err }); });
+    }, 500);
+  }
+
+  close(): void {
+    this.active = false;
+    this.agentId = null;
+    this.logEntries = [];
+    this.logTotal = 0;
+    if (this.refreshTimer) {
+      clearInterval(this.refreshTimer);
+      this.refreshTimer = null;
+    }
+  }
+
+  async loadLog(): Promise<void> {
+    if (!this.agentId) { this.logEntries = []; this.logTotal = 0; return; }
+    try {
+      const sessionFile = this.deps.sessionLogPathResolver(this.agentId);
+      const logContent = await readFile(sessionFile, 'utf-8');
+      const logLines = logContent.trim().split('\n');
+      this.logTotal = logLines.length;
+      const parsed = logLines.slice(-MAX_LOG_ENTRIES).map(line => {
+        try { return JSON.parse(line) as Record<string, unknown>; } catch { return null; }
+      });
+      const failedCount = parsed.filter(e => e === null).length;
+      if (failedCount > 0) {
+        logger.debug('AgentDetailModal: skipped malformed JSONL lines', { count: failedCount });
+      }
+      this.logEntries = parsed.filter((e): e is Record<string, unknown> => e !== null);
+    } catch (err) {
+      const code = (err as NodeJS.ErrnoException).code;
+      if (code !== 'ENOENT') {
+        logger.debug('AgentDetailModal: failed to load session log', { error: summarizeError(err) });
+      }
+      this.logEntries = [];
+      this.logTotal = 0;
+    }
+  }
+}
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+/** Rough token estimate: toolCallCount * avg tokens per tool exchange. */
+function estimateTokens(toolCallCount: number): number {
+  return toolCallCount * TOKENS_PER_TOOL_CALL;
+}
+
+// ─── renderAgentDetailModal ───────────────────────────────────────────────────
+
+/**
+ * Render the agent detail modal as Line[] for overlay in the viewport.
+ *
+ * Shows a deep view of the selected agent: task, template, model, status,
+ * duration, tool call count, token estimate, recent bus messages, and
+ * progress text.
+ *
+ * @param modal  AgentDetailModal state
+ * @param width  Terminal width
+ */
+export function renderAgentDetailModal(
+  modal: AgentDetailModal,
+  width: number,
+  viewportHeight = 24,
+): Line[] {
+  if (!modal.agentId) return [];
+  const metrics = getOverlaySurfaceMetrics(width, viewportHeight, {
+    margin: 2,
+    maxWidth: width - 4,
+    chromeRows: 6,
+    minContentRows: 10,
+    maxContentRows: 22,
+  });
+  const targetContentRows = Math.max(18, Math.min(22, getStableOverlayContentRows(metrics.contentRows, 12) + 8));
+
+  const rec = modal.deps.agentManager.getStatus(modal.agentId);
+  if (!rec) {
+    return ModalFactory.createModal({
+      title: 'Agent Detail',
+      width: metrics.boxWidth,
+      margin: metrics.margin,
+      targetContentRows,
+      sections: [
+        { type: 'text', content: '(agent not found)' },
+      ],
+      hints: ['[Esc] Close'],
+    }, width);
+  }
+
+  const now = Date.now();
+  const elapsedMs = (rec.completedAt ?? now) - rec.startedAt;
+  const tokenEst = estimateTokens(rec.toolCallCount);
+
+  // ── Build sections ────────────────────────────────────────────────────────
+
+  const sections: import('./modal-factory.ts').ModalSection[] = [];
+
+  // Task — show first line only, capped at 120 chars
+  const taskFirstLine = rec.task.split('\n')[0].replace(/^(WRFC\s+(Fix|Review)\s+Request\s*)/i, '').trim();
+  const taskDisplay = taskFirstLine.length > 120 ? taskFirstLine.slice(0, 117) + '\u2026' : taskFirstLine;
+  sections.push({
+    type: 'text',
+    content: `Task: ${taskDisplay}`,
+    style: { bold: true },
+  });
+  sections.push({ type: 'separator' });
+
+  // Metadata grid
+  const modelStr = rec.model ? `${rec.provider ?? ''}/${rec.model}` : (rec.provider ?? '(default)');
+  sections.push({ type: 'text', content: `Template : ${rec.template}` });
+  sections.push({ type: 'text', content: `Model    : ${modelStr}` });
+  sections.push({ type: 'text', content: `Status   : ${rec.status}` });
+  sections.push({ type: 'text', content: `Duration : ${formatDuration(elapsedMs)}` });
+  sections.push({ type: 'separator' });
+
+  // Metrics
+  sections.push({ type: 'text', content: `Tool calls : ${rec.toolCallCount}` });
+  sections.push({ type: 'text', content: `Est tokens : ~${tokenEst.toLocaleString()}` });
+
+  // SDK 0.23.0: systemPromptAddendum indicator — confirms WRFC constraint addendum was injected
+  if (rec.systemPromptAddendum) {
+    sections.push({
+      type: 'text',
+      content: 'Addendum   : yes (WRFC constraint layer injected)',
+      style: { fg: '#aaffee' },
+    });
+  }
+
+  // SDK 0.23.0: constraint data from WRFC chain (engineer constraints + reviewer findings)
+  if (rec.wrfcId && modal.deps.wrfcController) {
+    try {
+      const chain = modal.deps.wrfcController.getChain(rec.wrfcId);
+      if (chain && chain.constraints.length > 0) {
+        sections.push({ type: 'separator' });
+        sections.push({
+          type: 'text',
+          content: `Constraints (${chain.constraints.length}):`,
+          style: { dim: true },
+        });
+        for (const c of chain.constraints) {
+          const text = c.text.length > 80 ? c.text.slice(0, 77) + '…' : c.text;
+          sections.push({
+            type: 'text',
+            content: `  [${c.id}] ${text}`,
+            style: { fg: '246' },
+          });
+        }
+        // Reviewer constraint findings (if review has completed)
+        const findings = chain.reviewerReport?.constraintFindings;
+        if (findings && findings.length > 0) {
+          const unsatisfied = findings.filter((f) => !f.satisfied);
+          sections.push({
+            type: 'text',
+            content: `Findings   : ${findings.length} checked, ${unsatisfied.length} unsatisfied`,
+            style: { fg: unsatisfied.length > 0 ? '#ff6666' : '#44ff88' },
+          });
+        }
+      }
+    } catch {
+      // wrfcController.getChain throws when chain not found — normal during teardown
+    }
+  }
+
+  // Progress
+  if (rec.progress) {
+    sections.push({ type: 'separator' });
+    sections.push({
+      type: 'text',
+      content: `Progress: ${rec.progress}`,
+      style: { fg: '#00ffcc' },
+    });
+  }
+
+  // Error
+  if (rec.error) {
+    sections.push({ type: 'separator' });
+    sections.push({
+      type: 'text',
+      content: `Error: ${rec.error}`,
+      style: { fg: '#ff6666' },
+    });
+  }
+
+  // Recent messages from AgentMessageBus
+  const recentMessages = modal.deps.agentMessageBus
+    .getMessages(modal.agentId)
+    .slice(-4); // last 4 messages
+
+  if (recentMessages.length > 0) {
+    sections.push({ type: 'separator' });
+    sections.push({
+      type: 'text',
+      content: `Recent messages (${recentMessages.length}):`,
+      style: { dim: true },
+    });
+    for (const msg of recentMessages) {
+      const fromLabel = msg.from === '*' ? 'broadcast' : msg.from.slice(0, 12);
+      const preview = msg.content.length > 50
+        ? msg.content.slice(0, 47) + '\u2026'
+        : msg.content;
+      sections.push({
+        type: 'text',
+        content: `  [${fromLabel}] ${preview}`,
+        style: { fg: '246' },
+      });
+    }
+  }
+
+  // Execution history from cached JSONL session log (loaded on open())
+  if (modal.logEntries.length > 0) {
+    sections.push({ type: 'separator' });
+    sections.push({
+      type: 'text',
+      content: `Execution Log (${modal.logTotal} events, showing last ${modal.logEntries.length}):`,
+      style: { dim: true },
+    });
+    for (const entry of modal.logEntries) {
+      const entryType = String(entry.type ?? 'unknown');
+      const rawTs = entry.timestamp;
+      const ts = typeof rawTs === 'string' && rawTs.length >= 19
+        ? rawTs.slice(11, 19)
+        : '';
+      let detail = '';
+      if (entryType === 'tool_execution') detail = ` ${entry.toolName}`;
+      if (entryType === 'llm_response') detail = ` (${entry.toolCallCount} tools, ${entry.contentLength} chars)`;
+      if (entryType === 'session_end') detail = ` [${entry.status}]`;
+      sections.push({
+        type: 'text',
+        content: `  ${ts} ${entryType}${detail}`,
+        style: { fg: '246' },
+      });
+    }
+  }
+
+  // Streaming content — show live output when agent is actively streaming
+  const STREAMING_MAX_CHARS = 500;
+  if (rec.status === 'running' && rec.streamingContent) {
+    const content = rec.streamingContent;
+    const truncated = content.length > STREAMING_MAX_CHARS;
+    const display = truncated ? content.slice(-STREAMING_MAX_CHARS) : content;
+    sections.push({ type: 'separator' });
+    sections.push({
+      type: 'text',
+      content: truncated
+        ? `Streaming (last ${STREAMING_MAX_CHARS} of ${content.length} chars \u2191 scroll for more):`
+        : 'Streaming:',
+      style: { fg: '#00ffcc', dim: true },
+    });
+    // Split into display lines, capped at width for readability
+    const maxLineWidth = Math.max(width - 10, 40);
+    const streamLines = display.split('\n');
+    for (const line of streamLines) {
+      const trimmed = line.length > maxLineWidth ? line.slice(0, maxLineWidth - 1) + '\u2026' : line;
+      sections.push({
+        type: 'text',
+        content: `  ${trimmed}`,
+        style: { fg: '#aaffee' },
+      });
+    }
+  }
+
+  return ModalFactory.createModal({
+    title: `Agent: ${rec.id.slice(0, AGENT_ID_DISPLAY_LENGTH)}`,
+    width: metrics.boxWidth,
+    margin: metrics.margin,
+    targetContentRows,
+    sections,
+    hints: ['[Esc] Close'],
+  }, width);
+}

package/src/renderer/agent-workspace.ts

@@ -0,0 +1,238 @@
+import type {
+  AgentWorkspace,
+  AgentWorkspaceAction,
+  AgentWorkspaceActionResult,
+  AgentWorkspaceCategory,
+  AgentWorkspaceRuntimeSnapshot,
+} from '../input/agent-workspace.ts';
+import type { Line } from '../types/grid.ts';
+import { wrapText } from '../utils/terminal-width.ts';
+import { GLYPHS } from './ui-primitives.ts';
+import {
+  getFullscreenWorkspaceMetrics,
+  padDisplay,
+  renderFullscreenWorkspace,
+  stableWindow,
+  WORKSPACE_PALETTE as PALETTE,
+  type WorkspaceRow,
+} from './fullscreen-workspace.ts';
+
+function safetyColor(action: AgentWorkspaceAction): string {
+  if (action.safety === 'safe') return PALETTE.good;
+  if (action.safety === 'read-only') return PALETTE.info;
+  if (action.safety === 'delegates') return PALETTE.warn;
+  return PALETTE.bad;
+}
+
+function actionResultColor(result: AgentWorkspaceActionResult): string {
+  if (result.kind === 'blocked' || result.kind === 'error') return PALETTE.bad;
+  if (result.kind === 'dispatched') return PALETTE.info;
+  if (result.kind === 'refreshed') return PALETTE.good;
+  return PALETTE.muted;
+}
+
+function buildLeftRows(workspace: AgentWorkspace, height: number): WorkspaceRow[] {
+  const rows: WorkspaceRow[] = [];
+  let selectedRenderedIndex = 0;
+  let lastGroup = '';
+
+  workspace.categories.forEach((category, index) => {
+    if (category.group !== lastGroup) {
+      rows.push({ text: category.group, kind: 'group', bold: true });
+      lastGroup = category.group;
+    }
+    const selected = index === workspace.selectedCategoryIndex;
+    if (selected) selectedRenderedIndex = rows.length;
+    const marker = selected ? GLYPHS.navigation.selected : ' ';
+    rows.push({
+      text: `  ${marker} ${category.label}`,
+      selected: selected && workspace.focusPane === 'categories',
+      kind: 'item',
+      fg: selected ? PALETTE.text : PALETTE.muted,
+      bold: selected,
+    });
+  });
+
+  const visible = Math.max(1, height);
+  const window = stableWindow(rows.length, selectedRenderedIndex, visible);
+  const visibleRows = rows.slice(window.start, window.end);
+  if (window.start > 0 && visibleRows.length > 0) {
+    visibleRows[0] = { text: `${GLYPHS.navigation.moreAbove} ${window.start} more row(s) above`, kind: 'more', fg: PALETTE.dim, dim: true };
+  }
+  if (window.end < rows.length && visibleRows.length > 0) {
+    visibleRows[visibleRows.length - 1] = { text: `${GLYPHS.navigation.moreBelow} ${rows.length - window.end} more row(s) below`, kind: 'more', fg: PALETTE.dim, dim: true };
+  }
+  while (visibleRows.length < height) visibleRows.push({ text: '', kind: 'empty' });
+  return visibleRows.slice(0, height);
+}
+
+function actionCommand(action: AgentWorkspaceAction): string {
+  return action.command ?? '(guidance)';
+}
+
+type ContextLine = { readonly text: string; readonly fg?: string; readonly bold?: boolean; readonly dim?: boolean };
+
+function snapshotLines(category: AgentWorkspaceCategory, snapshot: AgentWorkspaceRuntimeSnapshot | null): ContextLine[] {
+  if (!snapshot) return [{ text: 'Runtime context is not loaded yet.', fg: PALETTE.warn }];
+  const base: ContextLine[] = [{ text: 'Live Agent Context', fg: PALETTE.title, bold: true }];
+  if (category.id === 'home') {
+    base.push(
+      { text: `Chat route: ${snapshot.provider} / ${snapshot.modelDisplayName}`, fg: PALETTE.info },
+      { text: `Session: ${snapshot.sessionId}`, fg: PALETTE.muted },
+      { text: `Policy: ${snapshot.executionPolicy}; WRFC ${snapshot.wrfcPolicy}`, fg: PALETTE.good },
+    );
+  } else if (category.id === 'setup') {
+    base.push(
+      { text: `External daemon: ${snapshot.daemonBaseUrl}`, fg: PALETTE.info },
+      { text: `Daemon ownership: ${snapshot.daemonOwnership}; Agent never starts or restarts it`, fg: PALETTE.good },
+      { text: `Workspace: ${snapshot.workingDirectory}`, fg: PALETTE.muted },
+      { text: `Home: ${snapshot.homeDirectory}`, fg: PALETTE.muted },
+    );
+  } else if (category.id === 'knowledge') {
+    base.push(
+      { text: `Route family: ${snapshot.knowledgeRoute}/{status,ask,search}`, fg: PALETTE.info },
+      { text: `Isolation: ${snapshot.knowledgeIsolation}; no default Knowledge/Wiki or HomeGraph fallback`, fg: PALETTE.good },
+      { text: 'Agent-owned content appears here only after explicit Agent knowledge ingestion.', fg: PALETTE.muted },
+    );
+  } else if (category.id === 'memory') {
+    base.push(
+      { text: `Session memories: ${snapshot.sessionMemoryCount}`, fg: PALETTE.info },
+      { text: 'Durable memory, skills, and personas remain Agent-local until shared registry contracts exist.', fg: PALETTE.good },
+      { text: 'Secrets are rejected/redacted; store secret references instead of secret values.', fg: PALETTE.warn },
+    );
+  } else if (category.id === 'work') {
+    base.push(
+      { text: 'Work plan and approvals are read or explicitly confirmed through public operator routes.', fg: PALETTE.info },
+      { text: 'This workspace does not approve, deny, cancel, or mutate requests by selection alone.', fg: PALETTE.good },
+    );
+  } else if (category.id === 'automation') {
+    base.push(
+      { text: 'Automation and schedules default to read-only observability.', fg: PALETTE.info },
+      { text: 'Run/pause/resume/cancel/retry require exact explicit commands and confirmation.', fg: PALETTE.warn },
+    );
+  } else if (category.id === 'delegate') {
+    base.push(
+      { text: 'Build/fix/review work is handed to GoodVibes TUI/shared-session contracts.', fg: PALETTE.info },
+      { text: `WRFC policy: ${snapshot.wrfcPolicy}`, fg: PALETTE.warn },
+      { text: 'Agent does not spawn local Engineer/Reviewer/Tester roots.', fg: PALETTE.good },
+    );
+  }
+  if (snapshot.warnings.length > 0) {
+    base.push({ text: '', dim: true }, { text: 'Warnings', fg: PALETTE.warn, bold: true });
+    for (const warning of snapshot.warnings) base.push({ text: warning, fg: PALETTE.warn });
+  }
+  return base;
+}
+
+function buildContextRows(workspace: AgentWorkspace, category: AgentWorkspaceCategory, action: AgentWorkspaceAction | null, width: number): WorkspaceRow[] {
+  const lines: ContextLine[] = [
+    { text: category.label, fg: PALETTE.title, bold: true },
+    { text: category.summary, fg: PALETTE.subtitle },
+    { text: '' },
+    { text: category.detail, fg: PALETTE.text },
+    { text: '' },
+    ...snapshotLines(category, workspace.runtimeSnapshot),
+  ];
+
+  if (action) {
+    lines.push(
+      { text: '' },
+      { text: `Selected: ${action.label}`, fg: PALETTE.title, bold: true },
+      { text: action.detail, fg: PALETTE.text },
+      { text: `Command: ${actionCommand(action)}`, fg: action.kind === 'command' ? PALETTE.info : PALETTE.muted },
+      { text: `Safety: ${action.safety}`, fg: safetyColor(action) },
+    );
+  }
+
+  if (workspace.lastActionResult) {
+    lines.push(
+      { text: '' },
+      { text: 'Action Result', fg: PALETTE.title, bold: true },
+      { text: workspace.lastActionResult.title, fg: actionResultColor(workspace.lastActionResult), bold: true },
+      { text: workspace.lastActionResult.detail, fg: PALETTE.text },
+    );
+    if (workspace.lastActionResult.command) {
+      lines.push({ text: `Command: ${workspace.lastActionResult.command}`, fg: PALETTE.muted });
+    }
+  }
+
+  return lines.flatMap((entry): WorkspaceRow[] => {
+    if (entry.text.length === 0) return [{ text: '', kind: 'empty', dim: true }];
+    return wrapText(entry.text, Math.max(1, width)).map((text, index): WorkspaceRow => ({
+      text,
+      fg: entry.fg,
+      bold: entry.bold && index === 0,
+      dim: entry.dim,
+    }));
+  });
+}
+
+function buildActionRows(workspace: AgentWorkspace, width: number, height: number): WorkspaceRow[] {
+  const rows: WorkspaceRow[] = [];
+  const labelWidth = Math.min(28, Math.max(16, Math.floor(width * 0.30)));
+  const safetyWidth = 10;
+  const commandWidth = Math.max(10, width - labelWidth - safetyWidth - 9);
+  rows.push({
+    text: `  ${padDisplay('Action', labelWidth)}  ${padDisplay('Safety', safetyWidth)}  ${padDisplay('Command', commandWidth)}`,
+    fg: PALETTE.muted,
+    bold: true,
+  });
+
+  const actions = workspace.actions;
+  const visible = Math.max(1, height - 2);
+  const window = stableWindow(actions.length, workspace.selectedActionIndex, visible);
+  if (window.start > 0) rows.push({ text: `${GLYPHS.navigation.moreAbove} ${window.start} more action(s) above`, kind: 'more', fg: PALETTE.dim, dim: true });
+
+  for (let index = window.start; index < window.end; index += 1) {
+    const action = actions[index]!;
+    const selected = index === workspace.selectedActionIndex;
+    const marker = selected ? GLYPHS.navigation.selected : ' ';
+    rows.push({
+      text: `${marker} ${padDisplay(action.label, labelWidth)}  ${padDisplay(action.safety, safetyWidth)}  ${padDisplay(actionCommand(action), commandWidth)}`,
+      selected: selected && workspace.focusPane === 'actions',
+      fg: safetyColor(action),
+      bold: selected,
+    });
+  }
+
+  if (window.end < actions.length) rows.push({ text: `${GLYPHS.navigation.moreBelow} ${actions.length - window.end} more action(s) below`, kind: 'more', fg: PALETTE.dim, dim: true });
+  rows.push({ text: '' });
+  rows.push({ text: `Status: ${workspace.status}`, fg: PALETTE.muted });
+  if (workspace.lastActionResult) {
+    rows.push({ text: '' });
+    rows.push({ text: `Action Result: ${workspace.lastActionResult.title}`, fg: actionResultColor(workspace.lastActionResult), bold: true });
+    for (const line of wrapText(workspace.lastActionResult.detail, Math.max(1, width - 2))) {
+      rows.push({ text: `  ${line}`, fg: PALETTE.text });
+    }
+    if (workspace.lastActionResult.command) {
+      rows.push({ text: `  Command: ${workspace.lastActionResult.command}`, fg: PALETTE.muted });
+    }
+  }
+
+  while (rows.length < height) rows.push({ text: '', kind: 'empty' });
+  return rows.slice(0, height);
+}
+
+function footerText(workspace: AgentWorkspace): string {
+  const focus = workspace.focusPane === 'categories' ? 'categories' : 'actions';
+  return `Agent workspace · focus ${focus} · Up/Down navigate · Left/Right pane · Enter open/action · R refresh · Esc close`;
+}
+
+export function renderAgentWorkspace(workspace: AgentWorkspace, width: number, height: number): Line[] {
+  const metrics = getFullscreenWorkspaceMetrics({ width, height, leftWidth: width < 90 ? undefined : 30, contextRatio: 0.48, minContextRows: 8 });
+  const category = workspace.selectedCategory;
+  const action = workspace.selectedAction;
+
+  return renderFullscreenWorkspace({
+    width,
+    height,
+    title: 'GoodVibes Agent / Operator Workspace',
+    stateLabel: workspace.focusPane === 'categories' ? 'Categories' : 'Actions',
+    leftHeader: 'Operator Areas',
+    mainHeader: `${category.label} · ${category.actions.length} action(s)`,
+    leftRows: buildLeftRows(workspace, metrics.bodyRows),
+    contextRows: buildContextRows(workspace, category, action, metrics.contextWidth),
+    controlRows: buildActionRows(workspace, metrics.contextWidth, metrics.controlRows),
+    footer: footerText(workspace),
+  });
+}

package/src/renderer/ansi-sanitize.ts

@@ -0,0 +1,76 @@
+/**
+ * ANSI sanitizer for untrusted content entering the renderer.
+ *
+ * The TUI grid renders content character-by-character via writeStyledText,
+ * which already drops zero-width characters (including ESC \x1b) by checking
+ * display width. However, that is incidental protection — not a contract.
+ * This module provides explicit, intentional sanitization.
+ *
+ * Strategy:
+ * - STRIP all non-SGR escape sequences (cursor moves, OSC, BEL, alt-screen,
+ *   DECSET/private mode, and any other CSI/ESC sequences).
+ * - PRESERVE SGR color/style codes (\x1b[<params>m) — used legitimately by
+ *   the TUI's own colorized output paths.
+ * - STRIP bare BEL (\x07) characters.
+ *
+ * Safe SGR pattern: \x1b[ followed by digits/semicolons, ending in 'm'.
+ * Everything else that starts with \x1b is dangerous and stripped.
+ */
+
+// Matches safe SGR sequences: ESC [ <digits/semicolons> m
+const SGR_PATTERN = /\x1b\[([0-9;]*)m/g;
+
+// Matches ALL CSI sequences: ESC [ ... <final byte 0x40-0x7E>
+const CSI_SEQUENCE = /\x1b\[[\x20-\x3f]*[\x40-\x7e]/g;
+
+// Matches OSC sequences: ESC ] ... (ESC \ or BEL)
+const OSC_SEQUENCE = /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g;
+
+// Matches other ESC sequences (ESC + single character that is not '[' or ']')
+const ESC_OTHER = /\x1b[^\[\]]/g;
+
+// Matches standalone BEL
+const BEL = /\x07/g;
+
+/**
+ * Strip dangerous ANSI escape sequences from untrusted content.
+ *
+ * Preserves SGR color codes (\x1b[<n>m). Removes:
+ * - Cursor movement CSI sequences (\x1b[<n>A/B/C/D, \x1b[H, etc.)
+ * - OSC sequences (\x1b]...\x07 or \x1b]...\x1b\\)
+ * - Alt-screen and DECSET private mode (\x1b[?...h/l)
+ * - Any other CSI or ESC sequences
+ * - Bare BEL (\x07)
+ *
+ * @param input - Raw string that may contain ANSI escape sequences
+ * @returns Sanitized string safe for grid rendering
+ */
+export function stripDangerousAnsi(input: string): string {
+  // Step 1: Extract and preserve SGR sequences by replacing them with placeholders,
+  // then strip all other escape sequences, then restore SGR sequences.
+  // This approach avoids complex negative lookahead regexes.
+
+  // Collect SGR sequences and replace with unique markers
+  const sgrTokens: string[] = [];
+  const withPlaceholders = input.replace(SGR_PATTERN, (match) => {
+    const idx = sgrTokens.length;
+    sgrTokens.push(match);
+    return `\x00SGR${idx}\x00`;
+  });
+
+  // Strip all remaining dangerous sequences
+  let sanitized = withPlaceholders
+    .replace(CSI_SEQUENCE, '')   // removes cursor moves, alt-screen, DECSET, etc.
+    .replace(OSC_SEQUENCE, '')   // removes OSC
+    .replace(ESC_OTHER, '')      // removes remaining ESC+char sequences
+    .replace(/\x1b/g, '')        // removes any leftover bare ESC
+    .replace(BEL, '');           // removes BEL
+
+  // Restore SGR sequences from placeholders
+  sanitized = sanitized.replace(/\x00SGR(\d+)\x00/g, (_match, idxStr) => {
+    const idx = parseInt(idxStr, 10);
+    return sgrTokens[idx] ?? '';
+  });
+
+  return sanitized;
+}