@pellux/goodvibes-tui 0.20.2 → 0.21.0

package/src/main.ts

@@ -48,12 +48,15 @@ import { buildPersistedSessionContext, formatReturnContextForDisplay, getReturnC
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { prepareShellCliRuntime } from './cli/entrypoint.ts';
 import { applyInitialTuiCliState } from './cli/tui-startup.ts';
+import { applyRuntimeConfigDefault, applyRuntimeConfigValue } from './cli/config-overrides.ts';
+import { renderToolCallBlock } from './renderer/tool-call.ts';
 import { wireSpokenTurnRuntime } from './audio/spoken-turn-wiring.ts';
 import { attachSpokenTurnModelRouting, createSpokenTurnInputOptions } from './audio/spoken-turn-model-routing.ts';
 import { allowTerminalWrite, installTuiTerminalOutputGuard } from './runtime/terminal-output-guard.ts';
-import { ProjectPlanningCoordinator } from './planning/project-planning-coordinator.ts';
 import { buildCommandArgsHint } from './input/command-args-hint.ts';
 import { summarizeRunningAgents } from './renderer/process-summary.ts';
+import { formatUserFacingErrorLine } from './core/format-user-error.ts';
+import { wireStreamEventMetrics, type StreamMetrics } from './core/stream-event-wiring.ts';
 
 const ALT_SCREEN_ENTER = '\x1b[?1049h';
 const ALT_SCREEN_EXIT  = '\x1b[?1049l';
@@ -127,6 +130,15 @@ async function main() {
     }
   }
 
+  // TUI default: show token speed ON. The SDK schema default is false;
+  // applyRuntimeConfigDefault reads both the global settings file and the project
+  // settings file from disk before deciding whether to apply the default. If the
+  // user has explicitly set this key to false in EITHER their global or project
+  // persisted config, their value is respected and the default is NOT applied.
+  // Only when the key is absent from both files (e.g. a new install) does the
+  // TUI default of true take effect in-memory — no disk write occurs either way.
+  applyRuntimeConfigDefault(configManager, 'display.showTokenSpeed', true);
+
   const panelManager = ctx.services.panelManager;
   const buildSessionContinuityHints = () => {
     const sessionSnapshot = uiServices.readModels.session.getSnapshot();
@@ -154,12 +166,18 @@ async function main() {
     render();
   });
 
-  let streamStartTime = 0;
-  let streamDeltaCount = 0;
-  let streamTokenSpeed = 0;
-
   let scrollTop = 0;
   let scrollLocked = true;
+  // Stream and tool-timer state; mutated by wireStreamEventMetrics handlers, read during render.
+  const streamMetrics: StreamMetrics = {
+    startTime: 0,
+    deltaCount: 0,
+    tokenSpeed: 0,
+    ttftMs: undefined,
+    ttftRecorded: false,
+    activeToolStartedAtMs: undefined,
+    activeToolName: undefined,
+  };
 
   const getPromptContentWidth = () => {
     const w = stdout.columns || 80;
@@ -213,7 +231,8 @@ async function main() {
         `[Critical] Multiple errors detected (${_unhandledRejectionCount} in 10s). If the issue persists, please restart. Latest: ${msg}`
       );
     } else {
-      systemMessageRouter.high(`[Error] ${msg}`);
+      const formatted = formatUserFacingErrorLine(reason);
+      systemMessageRouter.high(`[Error] ${formatted}`);
       logger.error('unhandledRejection', { error: String(reason) });
     }
     render();
@@ -260,18 +279,6 @@ async function main() {
     configManager,
     notify: (message) => { systemMessageRouter.high(message); render(); },
   }));
-  const projectPlanningCoordinator = new ProjectPlanningCoordinator({
-    service: ctx.services.projectPlanningService,
-    projectId: ctx.services.projectPlanningProjectId,
-    workingDirectory: workingDir,
-    notify: (message) => { systemMessageRouter.high(message); render(); },
-    openPanel: () => {
-      panelManager.open('project-planning');
-      panelManager.show();
-      render();
-    },
-  });
-
   const submitInput = (text: string, content?: ContentPart[], options: { readonly spokenOutput?: boolean } = {}) => {
     input.clearModalStack();
     scrollLocked = true; // Re-lock on any user input
@@ -307,32 +314,6 @@ async function main() {
     if (processedText || content) {
       void (async () => {
         let inputOptions = options.spokenOutput ? createSpokenTurnInputOptions() : undefined;
-        if (!options.spokenOutput && processedText) {
-          try {
-            const planning = await projectPlanningCoordinator.prepareTurn(processedText);
-            if (planning) {
-              if (planning.handledLocally) {
-                systemMessageRouter.high(planning.statusMessage);
-                render();
-                return;
-              }
-              conversation.addSystemMessage(planning.systemMessage);
-              inputOptions = {
-                origin: {
-                  source: 'project-planning',
-                  surface: 'tui',
-                  metadata: {
-                    projectId: ctx.services.projectPlanningProjectId,
-                    knowledgeSpaceId: planning.state.knowledgeSpaceId,
-                    readiness: planning.evaluation.readiness,
-                  },
-                },
-              };
-            }
-          } catch (err) {
-            systemMessageRouter.high(`[Planning] ${summarizeError(err)}`);
-          }
-        }
         if (options.spokenOutput && processedText) {
           spokenTurns.submitNextTurn(processedText);
         }
@@ -515,7 +496,9 @@ async function main() {
       workingDir,
       provider: runtime.provider,
       contextWindow: currentModel.contextWindow,
-      compactThreshold: configManager.get('behavior.autoCompactThreshold') as number,
+      // behavior.autoCompactThreshold is stored as a percent integer (e.g. 80);
+      // the meter expects a fraction [0..1]. Clamp to [0,1] to guard nonsense values.
+      compactThreshold: Math.min(1, Math.max(0, (configManager.get('behavior.autoCompactThreshold') as number) / 100)),
       dangerMode: (() => {
         if (configManager.get('behavior.autoApprove')) return true;
         const permMode = configManager.get('permissions.mode');
@@ -598,16 +581,25 @@ async function main() {
       const showSpeed = configManager.get('display.showTokenSpeed') as boolean;
       const showPreview = configManager.get('display.showToolPreview') as boolean;
       const partialToolPreview = showPreview ? sessionSnapshot.streamToolPreview : undefined;
+      // Elapsed from turn start (stream or tool execution), used for the thinking indicator timer.
+      const turnElapsedMs = streamMetrics.startTime > 0 ? Date.now() - streamMetrics.startTime : undefined;
       const thinking = UIFactory.createThinkingFragment(
         conversationWidth,
         orchestrator.getSpinner(),
         orchestrator.thinkingFrame,
-        showSpeed ? streamTokenSpeed : undefined,
+        showSpeed ? streamMetrics.tokenSpeed : undefined,
         showPreview ? partialToolPreview : undefined,
         orchestrator.streamingInputTokens > 0 ? orchestrator.streamingInputTokens : undefined,
         orchestrator.streamingOutputTokens > 0 ? orchestrator.streamingOutputTokens : undefined,
+        turnElapsedMs,
+        streamMetrics.ttftMs,
       );
       viewport.push(...thinking);
+      // Live tool timer: render the currently executing tool row with ticking elapsed.
+      if (streamMetrics.activeToolName !== undefined && streamMetrics.activeToolStartedAtMs !== undefined) {
+        const liveToolCall = { id: 'live', name: streamMetrics.activeToolName, arguments: {} };
+        viewport.push(...renderToolCallBlock(liveToolCall, 'executing', undefined, conversationWidth, undefined, undefined, undefined, streamMetrics.activeToolStartedAtMs));
+      }
     }
 
     if (pendingPermission) {
@@ -709,17 +701,16 @@ async function main() {
     refreshGit();
   }));
 
-  unsubs.push(uiServices.events.turns.on('STREAM_START', () => {
-    streamStartTime = Date.now();
-    streamDeltaCount = 0;
-    streamTokenSpeed = 0;
-  }));
-  unsubs.push(uiServices.events.turns.on('STREAM_DELTA', () => {
-    streamDeltaCount++;
-    const elapsed = (Date.now() - streamStartTime) / 1000;
-    // Note: counts stream deltas, not actual tokens. ~1 delta per token for most providers.
-    streamTokenSpeed = elapsed > 0 ? streamDeltaCount / elapsed : 0;
-  }));
+  // --- Stream metrics + tool-timer event wiring ---
+  const streamUnsubs = wireStreamEventMetrics({
+    events: uiServices.events,
+    orchestrator,
+    providerRegistry,
+    systemMessageRouter,
+    render,
+    metrics: streamMetrics,
+  });
+  unsubs.push(...streamUnsubs);
 
   // --- Terminal setup ---
   stdin.setRawMode(true);
@@ -747,6 +738,15 @@ async function main() {
       render,
       loadRecoveryConversation: () => loadRecoveryConversation({ homeDirectory }),
       deleteRecoveryFile: () => deleteRecoveryFile({ homeDirectory }),
+      reopenPanels: (snapshot) => {
+        const panels = snapshot.returnContext?.openPanels;
+        if (!panels || panels.length === 0) return;
+        for (const panelId of panels.slice(0, 4)) {
+          try { panelManager.open(panelId); } catch { /* unknown panel id — skip */ }
+        }
+        panelManager.show();
+        render();
+      },
     });
     pendingPermission = blocking.pendingPermission;
     recoveryPending = blocking.recoveryPending;

package/src/panels/builtin/agent.ts

@@ -76,7 +76,10 @@ export function registerAgentPanels(manager: PanelManager, deps: ResolvedBuiltin
     preload: true,
     factory: () => {
       const ui = requireUiServices(deps);
-      return new WrfcPanel(ui.events.workflows, { controller: ui.agents.wrfcController });
+      return new WrfcPanel(ui.events.workflows, {
+        controller: ui.agents.wrfcController,
+        cancelChain: (agentId: string) => ui.agents.agentManager.cancel(agentId),
+      });
     },
   });
 

package/src/panels/builtin/development.ts

@@ -65,7 +65,10 @@ export function registerDevelopmentPanels(manager: PanelManager, deps: ResolvedB
       description: 'Estimated costs per session, agent, and plan with budget alerts',
       factory: () => {
         const ui = requireUiServices(deps);
-        return new CostTrackerPanel(ui.events.turns, ui.events.agents, getOrchestratorUsage, { budgetThreshold });
+        return new CostTrackerPanel(ui.events.turns, ui.events.agents, getOrchestratorUsage, {
+          budgetThreshold,
+          getAgentStatus: (id) => ui.agents.agentManager.getStatus(id),
+        });
       },
     });
   }

package/src/panels/confirm-state.ts

@@ -1,12 +1,22 @@
 // ---------------------------------------------------------------------------
-// useConfirmState<T> — reusable inline y/n confirmation helper
+// useConfirmState<T> — reusable inline confirm/cancel helper
 //
-// Pattern (chosen over ConfirmableListPanel base class):
-//   - Composable: any panel holds a ConfirmState field, not a new base class
-//   - Identical y/n UX everywhere: y confirms, n/Esc cancels, any other key
-//     is absorbed (does nothing) while confirm is active
-//   - Render: caller calls renderConfirmLines(width, state) to get the two
-//     lines that replace the normal content area when confirming
+// ── Project-standard confirm contract (all panels must match) ──────────────
+//
+// CONFIRM:  Enter, Return, or y
+// CANCEL:   Esc or n
+// ABSORBED: any other key while confirm is active (keeps confirm pending)
+//
+// Implementation:
+//   - Composable: any panel holds a ConfirmState<T> field; no new base class
+//   - Call handleConfirmInput(confirm, key) BEFORE normal key dispatch.
+//     It handles all four outcomes and returns one of the four result tokens.
+//   - Call renderConfirmLines(width, state) to render the two-line overlay
+//     that replaces normal content while a confirm is pending.
+//
+// ── This file is the canonical contract for all confirm flows ─────────────
+// Any new panel confirm flow must use ConfirmState<T> and handleConfirmInput;
+// do not implement a bespoke two-press or Enter-only variant.
 // ---------------------------------------------------------------------------
 
 import type { Line } from '../types/grid.ts';
@@ -23,9 +33,14 @@ export interface ConfirmState<T = string> {
 /**
  * Call this from a panel's handleInput() BEFORE any other key handling.
  *
+ * Project-standard confirm contract:
+ *   - CONFIRM:  Enter, Return, or y
+ *   - CANCEL:   Esc or n
+ *   - ABSORBED: any other key while confirm is active (keeps confirm pending)
+ *
  * Returns:
- *   - `'confirmed'` — user pressed y; caller must execute the action and
- *     clear state (set confirm to null)
+ *   - `'confirmed'` — user pressed Enter, Return, or y; caller must execute
+ *     the action and clear state (set confirm to null)
  *   - `'cancelled'` — user pressed n or Esc; caller must clear state
  *   - `'absorbed'`  — any other key while confirm is active; caller returns true
  *   - `'inactive'`  — no confirm pending; caller continues normal dispatch
@@ -35,7 +50,7 @@ export function handleConfirmInput<T = string>(
   key: string,
 ): 'confirmed' | 'cancelled' | 'absorbed' | 'inactive' {
   if (!confirm) return 'inactive';
-  if (key === 'y') return 'confirmed';
+  if (key === 'y' || key === 'enter' || key === 'return') return 'confirmed';
   if (key === 'n' || key === 'escape') return 'cancelled';
   return 'absorbed';
 }
@@ -52,8 +67,8 @@ export function renderConfirmLines<T = string>(width: number, state: ConfirmStat
       palette.warn,
     ]]),
     buildPanelLine(width, [
-      [' y', palette.info],
-      ['  confirm delete', palette.dim],
+      [' Enter / y', palette.info],
+      ['  confirm', palette.dim],
       ['   n / Esc', palette.info],
       ['  cancel', palette.dim],
     ]),

package/src/panels/cost-tracker-panel.ts

@@ -7,6 +7,7 @@ import { createStyledCell, createEmptyLine } from '../types/grid.ts';
 import { BasePanel } from './base-panel.ts';
 import type { AgentEvent, TurnEvent } from '@/runtime/index.ts';
 import type { UiEventFeed } from '../runtime/ui-events.ts';
+import type { AgentRecord } from '@pellux/goodvibes-sdk/platform/tools';
 import {
   buildEmptyState,
   buildPanelLine,
@@ -16,68 +17,9 @@ import {
   DEFAULT_PANEL_PALETTE,
   type PanelWorkspaceSection,
 } from './polish.ts';
+import { getPricing } from '../export/cost-utils.ts';
 
-// ---------------------------------------------------------------------------
-// Pricing table  (USD per 1M tokens)
-// ---------------------------------------------------------------------------
-
-interface ModelPricing {
-  input: number;
-  output: number;
-}
-
-const MODEL_PRICING: Record<string, ModelPricing> = {
-  // Free tier
-  'openrouter/free': { input: 0, output: 0 },
-
-  // InceptionLabs
-  'mercury-2':    { input: 0.50, output: 1.50 },
-  'mercury-edit': { input: 0.50, output: 1.50 },
-
-  // OpenAI
-  'gpt-5.4':              { input: 5,    output: 15 },
-  'gpt-5.3-chat-latest':  { input: 3,    output: 10 },
-  'gpt-5-mini':           { input: 0.15, output: 0.60 },
-  'gpt-5-nano':           { input: 0.05, output: 0.20 },
-  'gpt-oss-120b':         { input: 0,    output: 0 },
-
-  // Anthropic (correct registry IDs)
-  'claude-opus-4-6':   { input: 15,   output: 75 },
-  'claude-sonnet-4-6': { input: 3,    output: 15 },
-  'claude-haiku-4-5':  { input: 0.80, output: 4 },
-
-  // Google
-  'gemini-3.1-pro':        { input: 1.25,  output: 5 },
-  'gemini-3-flash':        { input: 0.075, output: 0.30 },
-  'gemini-3.1-flash-lite': { input: 0.02,  output: 0.10 },
-  'gemini-2.5-pro':        { input: 1.25,  output: 5 },
-};
-
-/**
- * Look up pricing from the model catalog.
- * Returns { input: 0, output: 0 } for free models and unknown models.
- */
-function getCostFromCatalogForPanel(modelId: string): ModelPricing {
-  if (modelId.endsWith(':free')) return { input: 0, output: 0 };
-  return { input: 0, output: 0 };
-}
-
-function getPricing(modelId: string): ModelPricing {
-  // 2. Hardcoded table — exact match
-  if (MODEL_PRICING[modelId]) return MODEL_PRICING[modelId]!;
-  // 1. OpenRouter :free suffix — treat as free
-  if (modelId.endsWith(':free')) return { input: 0, output: 0 };
-  // 2. Prefix match (e.g. "openrouter/free:..." or "claude-sonnet-4-6-20..")
-  for (const [key, pricing] of Object.entries(MODEL_PRICING)) {
-    if (modelId.startsWith(key) || modelId.includes(key)) return pricing;
-  }
-  // 3. Unknown model — default to free-ish safe fallback
-  return getCostFromCatalogForPanel(modelId);
-}
-
-function calcCost(inputTokens: number, outputTokens: number, pricing: ModelPricing): number {
-  return (inputTokens * pricing.input + outputTokens * pricing.output) / 1_000_000;
-}
+// Pricing lookups are provided by ../export/cost-utils.ts (single source of truth).
 
 function formatCost(usd: number): string {
   if (usd === 0) return '$0.00';
@@ -176,14 +118,19 @@ export class CostTrackerPanel extends BasePanel {
   // Getter for live orchestrator usage
   private readonly getOrchestratorUsage: () => UsageSnapshot & { model?: string };
 
+  // Optional resolver for agent usage on completion — enables real cost attribution.
+  // When omitted, completed agents show $0 (honest: data unavailable).
+  private readonly getAgentStatus: ((agentId: string) => AgentRecord | null) | undefined;
+
   constructor(
     turnEvents: UiEventFeed<TurnEvent>,
     agentEvents: UiEventFeed<AgentEvent>,
     getOrchestratorUsage: () => UsageSnapshot & { model?: string },
-    opts: { budgetThreshold?: number } = {},
+    opts: { budgetThreshold?: number; getAgentStatus?: (agentId: string) => AgentRecord | null } = {},
   ) {
     super('cost', 'Cost', '$', 'monitoring');
     this.getOrchestratorUsage = getOrchestratorUsage;
+    this.getAgentStatus = opts.getAgentStatus;
     this.budgetThreshold = opts.budgetThreshold ?? 0;
     this.attachEvents(turnEvents, agentEvents);
   }
@@ -214,12 +161,22 @@ export class CostTrackerPanel extends BasePanel {
       }),
     );
 
-    // Agent completed — capture token data from result if available
+    // Agent completed — capture real token usage via AgentRecord when available
     this.unsubs.push(
       agentEvents.on('AGENT_COMPLETED', (payload) => {
         const entry = this.agents.get(payload.agentId);
         if (entry) {
           entry.status = 'done';
+          if (this.getAgentStatus) {
+            const rec = this.getAgentStatus(payload.agentId);
+            if (rec?.usage) {
+              entry.inputTokens = rec.usage.inputTokens + (rec.usage.cacheReadTokens ?? 0) + (rec.usage.cacheWriteTokens ?? 0);
+              entry.outputTokens = rec.usage.outputTokens;
+              const pricing = getPricing(rec.model ?? 'unknown');
+              entry.cost = (entry.inputTokens * pricing.input + entry.outputTokens * pricing.output) / 1_000_000;
+              if (rec.model && rec.model !== 'unknown') entry.model = rec.model;
+            }
+          }
           this.markDirty();
         }
       }),
@@ -248,9 +205,9 @@ export class CostTrackerPanel extends BasePanel {
     if (usage.model) this.sessionModel = usage.model;
 
     // Record cost delta for sparkline
-    const sessionProvider = this.sessionModel.includes('/') ? this.sessionModel.split('/')[0]! : '';
     const pricing = getPricing(this.sessionModel);
-    const totalCost = calcCost(usage.input + usage.cacheRead + usage.cacheWrite, usage.output, pricing);
+    const billableInput = usage.input + usage.cacheRead + usage.cacheWrite;
+    const totalCost = (billableInput * pricing.input + usage.output * pricing.output) / 1_000_000;
     const delta = Math.max(0, totalCost - this.lastSessionCost);
     this.lastSessionCost = totalCost;
     this.costHistory.push(delta);
@@ -310,10 +267,9 @@ export class CostTrackerPanel extends BasePanel {
   render(width: number, height: number): Line[] {
     if (height <= 0 || width <= 0) return [];
 
-    const sessionProvider = this.sessionModel.includes('/') ? this.sessionModel.split('/')[0]! : '';
     const pricing = getPricing(this.sessionModel);
     const totalInputTokens = this.sessionUsage.input + this.sessionUsage.cacheRead + this.sessionUsage.cacheWrite;
-    const sessionCost = calcCost(this.sessionUsage.input + this.sessionUsage.cacheRead + this.sessionUsage.cacheWrite, this.sessionUsage.output, pricing);
+    const sessionCost = (totalInputTokens * pricing.input + this.sessionUsage.output * pricing.output) / 1_000_000;
     const overBudget = this.budgetThreshold > 0 && sessionCost > this.budgetThreshold;
     const sparkline = buildSparkline(this.costHistory);
     const costStr = formatCost(sessionCost);

package/src/panels/eval-panel.ts

@@ -7,6 +7,7 @@
 
 import { BasePanel } from './base-panel.ts';
 import type { Line } from '../types/grid.ts';
+import type { KeyName } from './types.ts';
 import { createEmptyLine } from '../types/grid.ts';
 import {
   buildEmptyState,
@@ -136,21 +137,21 @@ export class EvalPanel extends BasePanel {
     this._unsub = null;
   }
 
-  public handleInput(key: string): boolean {
+  public handleInput(key: KeyName): boolean {
     const suites = this._registry.getSuiteResults();
 
     if (this._mode === 'list') {
-      if (key === 'ArrowUp' || key === 'k') {
+      if (key === 'up' || key === 'k') {
         this._selectedSuiteIdx = Math.max(0, this._selectedSuiteIdx - 1);
         this.markDirty();
         return true;
       }
-      if (key === 'ArrowDown' || key === 'j') {
+      if (key === 'down' || key === 'j') {
         this._selectedSuiteIdx = Math.min(suites.length - 1, this._selectedSuiteIdx + 1);
         this.markDirty();
         return true;
       }
-      if ((key === 'Enter' || key === 'Return' || key === 'l') && suites.length > 0) {
+      if ((key === 'enter' || key === 'return' || key === 'l') && suites.length > 0) {
         this._mode = 'detail';
         this._selectedScenarioIdx = 0;
         this._scrollOffset = 0;
@@ -161,12 +162,12 @@ export class EvalPanel extends BasePanel {
     }
 
     // detail mode
-    if (key === 'Escape' || key === 'q' || key === 'h') {
+    if (key === 'escape' || key === 'q' || key === 'h') {
       this._mode = 'list';
       this.markDirty();
       return true;
     }
-    if (key === 'ArrowUp' || key === 'k') {
+    if (key === 'up' || key === 'k') {
       const suite = suites[this._selectedSuiteIdx];
       if (suite) {
         this._selectedScenarioIdx = Math.max(0, this._selectedScenarioIdx - 1);
@@ -175,7 +176,7 @@ export class EvalPanel extends BasePanel {
       }
       return true;
     }
-    if (key === 'ArrowDown' || key === 'j') {
+    if (key === 'down' || key === 'j') {
       const suite = suites[this._selectedSuiteIdx];
       if (suite) {
         this._selectedScenarioIdx = Math.min(
@@ -187,12 +188,12 @@ export class EvalPanel extends BasePanel {
       }
       return true;
     }
-    if (key === 'PageUp') {
+    if (key === 'pageup') {
       this._scrollOffset = Math.max(0, this._scrollOffset - 5);
       this.markDirty();
       return true;
     }
-    if (key === 'PageDown') {
+    if (key === 'pagedown') {
       this._scrollOffset += 5;
       this.markDirty();
       return true;

package/src/panels/knowledge-panel.ts

@@ -1,5 +1,6 @@
 import type { Line } from '../types/grid.ts';
 import { ScrollableListPanel } from './scrollable-list-panel.ts';
+import type { KeyName } from './types.ts';
 import { type ConfirmState, handleConfirmInput, renderConfirmLines } from './confirm-state.ts';
 import type { MemoryClass, MemoryRecord, MemoryRegistry, MemoryReviewState } from '@pellux/goodvibes-sdk/platform/state';
 import {
@@ -102,7 +103,7 @@ export class KnowledgePanel extends ScrollableListPanel<MemoryRecord> {
   // Input
   // ---------------------------------------------------------------------------
 
-  public handleInput(key: string): boolean {
+  public handleInput(key: KeyName): boolean {
     // I1: y/n confirm for stale/contradict
     if (this.confirm) {
       const result = handleConfirmInput(this.confirm, key);
@@ -149,7 +150,7 @@ export class KnowledgePanel extends ScrollableListPanel<MemoryRecord> {
 
     const selected = this.records[this.selectedIndex];
 
-    if (key === 'Enter' || key === 'return' || key === 'r') {
+    if (key === 'enter' || key === 'return' || key === 'r') {
       if (!selected) return false;
       this.registry.review(selected.id, {
         state: 'reviewed',
@@ -186,9 +187,6 @@ export class KnowledgePanel extends ScrollableListPanel<MemoryRecord> {
       return true;
     }
 
-    // Normalize arrow keys to base class format
-    if (key === 'ArrowUp') return super.handleInput('up');
-    if (key === 'ArrowDown') return super.handleInput('down');
     return super.handleInput(key);
   }