@pellux/goodvibes-tui 0.20.3 → 0.22.0

package/src/panels/memory-panel.ts

@@ -1,18 +1,26 @@
 /**
- * MemoryPanel — project memory substrate TUI panel.
+ * MemoryPanel — merged project memory substrate panel.
  *
- * Migrated to SearchableListPanel<MemoryRecord> (Wave B1).
+ * TASK-040: Merged from the former separate MemoryPanel + KnowledgePanel.
+ * One panel, two filter modes toggled with Tab:
+ *   - 'all'    : full record list with search (former MemoryPanel behaviour)
+ *   - 'review' : review-queue view with r/s/c/f actions (former KnowledgePanel behaviour)
+ *
+ * Panel id stays 'memory'; the 'knowledge' id is repointed to the graph view.
+ * No capability removed from either previous surface.
  */
 
 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 type { MemoryClass, MemoryRecord, MemoryReviewState } from '@pellux/goodvibes-sdk/platform/state';
+import { ScrollableListPanel, SearchableListPanel } from './scrollable-list-panel.ts';
+import { type ConfirmState, handleConfirmInput, renderConfirmLines } from './confirm-state.ts';
 import {
   buildBodyText,
   buildGuidanceLine,
   buildKeyValueLine,
   buildPanelLine,
+  buildPanelWorkspace,
   extendPalette,
   DEFAULT_PANEL_PALETTE,
 } from './polish.ts';
@@ -21,6 +29,10 @@ import {
   isPanelSearchCancel,
 } from './search-focus.ts';
 
+// ---------------------------------------------------------------------------
+// Colour palette
+// ---------------------------------------------------------------------------
+
 const C = extendPalette(DEFAULT_PANEL_PALETTE, {
   header: '#94a3b8',
   headerBg: '#1e293b',
@@ -38,6 +50,21 @@ const C = extendPalette(DEFAULT_PANEL_PALETTE, {
   searchFg: '#e2e8f0',
 });
 
+// ---------------------------------------------------------------------------
+// Filter modes
+// ---------------------------------------------------------------------------
+
+type FilterMode = 'all' | 'review';
+
+const FILTER_LABELS: Record<FilterMode, string> = {
+  all:    'All Records',
+  review: 'Review Queue',
+};
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
 function fmtTime(ts: number): string {
   const d = new Date(ts);
   return d.toISOString().slice(0, 16).replace('T', ' ');
@@ -45,50 +72,82 @@ function fmtTime(ts: number): string {
 
 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 '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;
+    case 'ownership':    return C.ownership;
   }
 }
 
+function reviewStateColor(state: MemoryReviewState): string {
+  switch (state) {
+    case 'reviewed':     return C.good;
+    case 'stale':        return C.warn;
+    case 'contradicted': return C.bad;
+    case 'fresh':
+    default:             return C.info;
+  }
+}
+
+function formatConfidence(confidence: number): string {
+  return `${confidence.toString().padStart(3, ' ')}%`;
+}
+
+// ---------------------------------------------------------------------------
+// MemoryPanel
+// ---------------------------------------------------------------------------
+
 export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
-  private registry: MemoryRegistry;
+  private readonly registry: MemoryRegistry;
+  private filterMode: FilterMode = 'all';
   private filterFocused = false;
   private unsubscribe?: () => void;
 
+  // Review-mode confirm state (for destructive stale/contradict actions)
+  private confirm: ConfirmState<{ id: string; action: 'stale' | 'contradicted' }> | null = null;
+
+  // Cached records for review-mode (reviewQueue-first, same as former KnowledgePanel)
+  private reviewRecords: MemoryRecord[] = [];
+
   constructor(registry: MemoryRegistry) {
     super('memory', 'Memory', 'M', 'agent');
     this.registry = registry;
   }
 
-  onActivate(): void {
+  // ---------------------------------------------------------------------------
+  // Lifecycle
+  // ---------------------------------------------------------------------------
+
+  override onActivate(): void {
     super.onActivate();
     this.searchQuery = '';
     this.invalidateFilter();
     this.filterFocused = false;
+    this.confirm = null;
+    this.refreshReviewRecords();
     this.unsubscribe = this.registry.subscribe(() => {
       this.invalidateFilter();
+      this.refreshReviewRecords();
       this.markDirty();
     });
   }
 
-  onDeactivate(): void {
+  override onDeactivate(): void {
     super.onDeactivate();
   }
 
-  onDestroy(): void {
+  override onDestroy(): void {
     this.unsubscribe?.();
     this.unsubscribe = undefined;
   }
 
   // ---------------------------------------------------------------------------
-  // SearchableListPanel implementation
+  // SearchableListPanel implementation (used in 'all' filter mode)
   // ---------------------------------------------------------------------------
 
   protected getAllItems(): readonly MemoryRecord[] {
@@ -109,6 +168,17 @@ export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
   }
 
   protected renderItem(record: MemoryRecord, index: number, selected: boolean, width: number): Line {
+    if (this.filterMode === 'review') {
+      // Review-mode row: reviewState + confidence (matches former KnowledgePanel row)
+      const bg = selected ? C.selectBg : undefined;
+      return buildPanelLine(width, [
+        ['  ', C.label, bg],
+        [record.reviewState.padEnd(13), reviewStateColor(record.reviewState), bg],
+        [` ${formatConfidence(record.confidence)} `, C.value, bg],
+        [record.summary.slice(0, Math.max(0, width - 26)), C.value, bg],
+      ]);
+    }
+    // All-mode row: scope/class + id + time + summary (matches former MemoryPanel row)
     const bg = selected ? C.selected : undefined;
     return buildPanelLine(width, [
       ['  ', C.label, bg],
@@ -122,63 +192,222 @@ export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
   }
 
   protected override getPalette() { return C; }
+
   protected override getEmptyStateMessage() {
+    if (this.filterMode === 'review') return 'No records in the review queue.';
     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' },
+      { command: '/recall capture policy', summary: 'store the current policy posture as durable evidence' },
     ];
   }
 
+  // ---------------------------------------------------------------------------
+  // Internal helpers
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Override getItems() so that ScrollableListPanel infrastructure (renderList,
+   * clampSelection, navigation bounds) all operate on reviewRecords in review
+   * mode — preventing the render/action index desync where rendered list index N
+   * did not correspond to reviewRecords[N] when the two lists differ.
+   */
+  protected override getItems(): readonly MemoryRecord[] {
+    if (this.filterMode === 'review') return this.reviewRecords;
+    return super.getItems();
+  }
+
+  private refreshReviewRecords(): void {
+    this.reviewRecords = this.registry.reviewQueue(24);
+    this.clampSelection();
+  }
+
+  private cycleFilter(): void {
+    const modes: FilterMode[] = ['all', 'review'];
+    const next = modes[(modes.indexOf(this.filterMode) + 1) % modes.length];
+    this.filterMode = next;
+    this.invalidateFilter();
+    this.refreshReviewRecords();
+    this.markDirty();
+  }
+
+  // ---------------------------------------------------------------------------
+  // Input
+  // ---------------------------------------------------------------------------
+
   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;
+    // Review confirm dialog intercepts all input
+    if (this.confirm) {
+      const result = handleConfirmInput(this.confirm, key);
+      if (result === 'confirmed') {
+        const { id, action } = this.confirm.subject;
+        this.confirm = null;
+        const record = this.reviewRecords.find((r) => r.id === id);
+        if (record) {
+          try {
+            if (action === 'stale') {
+              this.registry.review(id, {
+                state: 'stale',
+                confidence: Math.min(record.confidence, 40),
+                reviewedBy: 'operator',
+                staleReason: 'marked stale from the memory panel',
+              });
+            } else {
+              this.registry.review(id, {
+                state: 'contradicted',
+                confidence: 0,
+                reviewedBy: 'operator',
+                staleReason: 'marked contradicted from the memory panel',
+              });
+            }
+          } catch (e) {
+            this.setError(`Review update failed: ${e instanceof Error ? e.message : String(e)}`);
+          }
+        }
+        this.refreshReviewRecords();
         this.markDirty();
         return true;
       }
-      if (isPanelSearchCancel(key)) {
-        this.filterFocused = false;
-        return super.handleInput(key);
+      if (result === 'cancelled') {
+        this.confirm = null;
+        this.markDirty();
+        return true;
       }
-      return super.handleInput(key);
+      if (result === 'absorbed') return true;
     }
 
-    const items = this.getItems();
-    const transition = getPanelSearchFocusTransition(key, { selectedIndex: this.selectedIndex, itemCount: items.length });
-    if (transition === 'focus-search') {
-      this.filterFocused = true;
-      this.markDirty();
+    // Tab cycles filter modes
+    if (key === 'tab') {
+      this.cycleFilter();
       return true;
     }
 
-    if (key === 'r') {
-      this.invalidateFilter();
-      this.markDirty();
-      return true;
+    // Review-mode specific actions (r/s/c/f)
+    if (this.filterMode === 'review') {
+      const selected = this.reviewRecords[this.selectedIndex];
+
+      if (key === 'enter' || key === 'return' || key === 'r') {
+        if (!selected) return false;
+        this.registry.review(selected.id, {
+          state: 'reviewed',
+          confidence: Math.max(selected.confidence, 85),
+          reviewedBy: 'operator',
+        });
+        this.refreshReviewRecords();
+        this.markDirty();
+        return true;
+      }
+      if (key === 's') {
+        if (!selected) return false;
+        this.confirm = { subject: { id: selected.id, action: 'stale' }, label: selected.summary.slice(0, 40) };
+        this.markDirty();
+        return true;
+      }
+      if (key === 'c') {
+        if (!selected) return false;
+        this.confirm = { subject: { id: selected.id, action: 'contradicted' }, label: selected.summary.slice(0, 40) };
+        this.markDirty();
+        return true;
+      }
+      if (key === 'f') {
+        if (!selected) return false;
+        this.registry.review(selected.id, {
+          state: 'fresh',
+          confidence: Math.max(selected.confidence, 60),
+          reviewedBy: 'operator',
+        });
+        this.refreshReviewRecords();
+        this.markDirty();
+        return true;
+      }
+    }
+
+    // All-mode: search filter focus
+    if (this.filterMode === 'all') {
+      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;
+      }
     }
 
+    // In review mode, navigation keys (j/k/up/down/etc.) must bypass
+    // SearchableListPanel's printable-character interception, which would
+    // otherwise swallow single-char keys like 'j' and 'k' as search input.
+    if (this.filterMode === 'review') {
+      return ScrollableListPanel.prototype.handleInput.call(this, key);
+    }
     return super.handleInput(key);
   }
 
+  // ---------------------------------------------------------------------------
+  // Render
+  // ---------------------------------------------------------------------------
+
   render(width: number, height: number): Line[] {
     this.clampSelection();
-    const intro = 'Durable project memory across decisions, constraints, incidents, patterns, risks, runbooks, and related provenance.';
 
+    // Review confirm dialog takes over the full panel
+    if (this.confirm) {
+      return buildPanelWorkspace(width, height, {
+        title: 'Memory',
+        intro: '',
+        sections: [{ title: 'Confirmation', lines: renderConfirmLines(width, this.confirm) }],
+        footerLines: [buildPanelLine(width, [['  y confirm  n / Esc cancel', C.dim]])],
+        palette: C,
+      });
+    }
+
+    const filterLabel = FILTER_LABELS[this.filterMode];
+    const filterToggleLine = buildPanelLine(width, [
+      ['  Filter: ', C.label],
+      [filterLabel, C.info],
+      ['  (Tab to toggle)', C.dim],
+    ]);
+
+    if (this.filterMode === 'review') {
+      return this.renderReviewMode(width, height, filterToggleLine);
+    }
+    return this.renderAllMode(width, height, filterToggleLine);
+  }
+
+  private renderAllMode(width: number, height: number, filterToggleLine: Line): Line[] {
     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 filterInputLine = this.buildFilterInputLine(width, 'Search', this.filterFocused);
 
     const summaryLines: Line[] = [
       buildKeyValueLine(width, [
@@ -188,7 +417,8 @@ export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
         { label: 'incidents', value: String(byClass.get('incident') ?? 0), valueColor: C.incident },
         { label: 'runbooks', value: String(byClass.get('runbook') ?? 0), valueColor: C.runbook },
       ], C),
-      filterLine,
+      filterToggleLine,
+      filterInputLine,
       buildGuidanceLine(width, '/recall review', 'review durable knowledge and queue posture from the command surface', C),
     ];
 
@@ -218,7 +448,107 @@ export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
       header: summaryLines,
       footer: [
         ...selectedLines,
-        buildPanelLine(width, [['  / search  j/k or Up/Down move  r reload  Esc clear search', C.dim]]),
+        buildPanelLine(width, [['  / search  j/k or Up/Down move  r reload  Tab: Review Queue  Esc clear search', C.dim]]),
+      ],
+    });
+  }
+
+  private renderReviewMode(width: number, height: number, filterToggleLine: Line): Line[] {
+    if (this.reviewRecords.length === 0) this.refreshReviewRecords();
+
+    const allRecords = this.registry.search({ limit: 200 });
+    const queue = this.registry.reviewQueue(24);
+    const byClass = new Map<MemoryClass, number>();
+    const byReview = new Map<MemoryReviewState, number>();
+    const byScope = new Map<string, number>();
+    for (const record of allRecords) {
+      byClass.set(record.cls, (byClass.get(record.cls) ?? 0) + 1);
+      byReview.set(record.reviewState, (byReview.get(record.reviewState) ?? 0) + 1);
+      byScope.set(record.scope, (byScope.get(record.scope) ?? 0) + 1);
+    }
+
+    const classLines: Line[] = [
+      buildPanelLine(width, [
+        [' facts ', C.label], [String(byClass.get('fact') ?? 0), C.good],
+        ['  risks ', C.label], [String(byClass.get('risk') ?? 0), (byClass.get('risk') ?? 0) > 0 ? C.warn : C.good],
+        ['  runbooks ', C.label], [String(byClass.get('runbook') ?? 0), C.info],
+        ['  architecture ', C.label], [String(byClass.get('architecture') ?? 0), C.info],
+        ['  incidents ', C.label], [String(byClass.get('incident') ?? 0), (byClass.get('incident') ?? 0) > 0 ? C.bad : C.good],
+      ]),
+      buildPanelLine(width, [
+        [' decisions ', C.label], [String(byClass.get('decision') ?? 0), C.value],
+        ['  constraints ', C.label], [String(byClass.get('constraint') ?? 0), C.value],
+        ['  ownership ', C.label], [String(byClass.get('ownership') ?? 0), C.value],
+        ['  patterns ', C.label], [String(byClass.get('pattern') ?? 0), C.value],
+        ['  total ', C.label], [String(allRecords.length), C.value],
+      ]),
+    ];
+
+    const reviewLines: Line[] = [
+      buildPanelLine(width, [
+        [' reviewed ', C.label], [String(byReview.get('reviewed') ?? 0), C.good],
+        ['  fresh ', C.label], [String(byReview.get('fresh') ?? 0), C.info],
+        ['  stale ', C.label], [String(byReview.get('stale') ?? 0), C.warn],
+        ['  contradicted ', C.label], [String(byReview.get('contradicted') ?? 0), C.bad],
+        ['  Queue ', C.label], [String(queue.length), queue.length > 0 ? C.warn : C.good],
+      ]),
+      buildPanelLine(width, [
+        [' session ', C.label], [String(byScope.get('session') ?? 0), C.info],
+        ['  project ', C.label], [String(byScope.get('project') ?? 0), C.value],
+        ['  team ', C.label], [String(byScope.get('team') ?? 0), C.good],
+      ]),
+      filterToggleLine,
+      buildGuidanceLine(width, '/recall review', 'work the stale and contradicted queue from the command surface', C),
+    ];
+
+    const selectedRecord = this.reviewRecords[this.selectedIndex];
+    const selectedLines: Line[] = [];
+    if (selectedRecord) {
+      selectedLines.push(buildPanelLine(width, [['  Selected', C.label]]));
+      selectedLines.push(buildKeyValueLine(width, [
+        { label: 'Class', value: selectedRecord.cls, valueColor: C.value },
+        { label: 'Scope', value: selectedRecord.scope, valueColor: C.info },
+        { label: 'Review', value: selectedRecord.reviewState, valueColor: reviewStateColor(selectedRecord.reviewState) },
+        { label: 'Confidence', value: formatConfidence(selectedRecord.confidence), valueColor: C.value },
+      ], C));
+      selectedLines.push(...buildBodyText(width, `Summary: ${selectedRecord.summary}`, C, C.value));
+      if (selectedRecord.detail) selectedLines.push(...buildBodyText(width, `Detail: ${selectedRecord.detail}`, C, C.dim));
+      if (selectedRecord.provenance.length) {
+        selectedLines.push(...buildBodyText(
+          width,
+          `Provenance: ${selectedRecord.provenance.map((p) => `${p.kind}:${p.ref}`).join(', ')}`,
+          C,
+          C.dim,
+        ));
+      }
+      if (selectedRecord.staleReason) {
+        selectedLines.push(...buildBodyText(
+          width,
+          `Stale reason: ${selectedRecord.staleReason}`,
+          C,
+          selectedRecord.reviewState === 'contradicted' ? C.bad : C.warn,
+        ));
+      }
+      if (selectedRecord.reviewedAt) {
+        selectedLines.push(buildPanelLine(width, [
+          ['  Reviewed: ', C.label],
+          [new Date(selectedRecord.reviewedAt).toLocaleString(), C.dim],
+        ]));
+        if (selectedRecord.reviewedBy) {
+          selectedLines.push(buildPanelLine(width, [
+            ['  Reviewer: ', C.label],
+            [selectedRecord.reviewedBy, C.dim],
+          ]));
+        }
+      }
+    }
+
+    return this.renderList(width, height, {
+      title: 'Memory',
+      header: [...classLines, ...reviewLines],
+      footer: [
+        ...(selectedLines.length > 0 ? selectedLines : []),
+        buildPanelLine(width, [['  Tab: All Records  Up/Down move  r/Enter reviewed  s stale  c contradicted  f fresh', C.dim]]),
       ],
     });
   }

package/src/panels/project-planning-panel.ts

@@ -9,6 +9,8 @@ import type {
 } from '@pellux/goodvibes-sdk/platform/knowledge';
 import type { Line } from '../types/grid.ts';
 import { BasePanel } from './base-panel.ts';
+import { handleConfirmInput, renderConfirmLines, type ConfirmState } from './confirm-state.ts';
+import { isTextBackspace, isTextForwardDelete } from '../input/delete-key-policy.ts';
 import {
   buildBodyText,
   buildEmptyState,
@@ -69,6 +71,8 @@ export class ProjectPlanningPanel extends BasePanel {
   private scrollOffset = 0;
   private selectedActionIndex = 0;
   private draftAnswer = '';
+  // Pending confirmation for Delete (clear draft). Null when inactive.
+  private clearDraftConfirm: ConfirmState<'clear-draft'> | null = null;
 
   public constructor(options: ProjectPlanningPanelOptions) {
     super('project-planning', 'Planning', 'P', 'agent');
@@ -86,6 +90,26 @@ export class ProjectPlanningPanel extends BasePanel {
 
   public handleInput(key: string): boolean {
     if (this.lastError !== null) this.clearError();
+
+    // ConfirmState gate: Delete (clear draft) requires y/n confirmation.
+    // handleConfirmInput absorbs all keys while a confirmation is pending.
+    const confirmResult = handleConfirmInput(this.clearDraftConfirm, key);
+    if (confirmResult === 'confirmed') {
+      this.draftAnswer = '';
+      this.clearDraftConfirm = null;
+      this.markDirty();
+      return true;
+    }
+    if (confirmResult === 'cancelled') {
+      this.clearDraftConfirm = null;
+      this.markDirty();
+      return true;
+    }
+    if (confirmResult === 'absorbed') {
+      return true;
+    }
+    // confirmResult === 'inactive': proceed with normal dispatch.
+
     const question = this.getCurrentQuestion();
     if (question) {
       const actions = this.getAnswerActions(question);
@@ -104,13 +128,15 @@ export class ProjectPlanningPanel extends BasePanel {
         this.submitSelectedAction(question, actions);
         return true;
       }
-      if (key === 'backspace') {
+      if (isTextBackspace(key)) {
         this.draftAnswer = this.draftAnswer.slice(0, -1);
         this.markDirty();
         return true;
       }
-      if (key === 'delete') {
-        this.draftAnswer = '';
+      // 'delete' opens the clear-draft confirmation gate (per delete-key policy).
+      // The draft is not wiped until the user confirms with y/Enter.
+      if (isTextForwardDelete(key)) {
+        this.clearDraftConfirm = { subject: 'clear-draft', label: 'draft answer' };
         this.markDirty();
         return true;
       }
@@ -244,8 +270,10 @@ export class ProjectPlanningPanel extends BasePanel {
           [' choose answer  ', C.dim],
           ['type', C.info],
           [' draft  ', C.dim],
-          ['Backspace/Delete', C.info],
+          ['Backspace', C.info],
           [' edit  ', C.dim],
+          ['Del', C.info],
+          [' clear draft  ', C.dim],
           ['Enter', C.info],
           [' submit  Esc prompt focus  Ctrl+X close panel', C.dim],
         ]),
@@ -284,6 +312,16 @@ export class ProjectPlanningPanel extends BasePanel {
   private buildQuestionSection(width: number, question: ProjectPlanningQuestion): RenderedPlanningSection {
     const actions = this.getAnswerActions(question);
     this.selectedActionIndex = this.clampActionIndex(actions.length);
+    // When a clear-draft confirmation is pending, show the confirm prompt
+    // inline above the draft line instead of the normal content.
+    if (this.clearDraftConfirm) {
+      const confirmLines = renderConfirmLines(width, this.clearDraftConfirm);
+      const lines: Line[] = [
+        ...buildBodyText(width, question.prompt, C, C.planning),
+        ...confirmLines,
+      ];
+      return { title: 'Answer Current Question', lines, selectedLineIndex: undefined };
+    }
     const lines: Line[] = [
       ...buildBodyText(width, question.prompt, C, C.planning),
     ];

package/src/panels/search-focus.ts

@@ -1,3 +1,5 @@
+import { isTextBackspace } from '../input/delete-key-policy.ts';
+
 export type PanelSearchFocusTransition = 'focus-search' | 'focus-list' | null;
 
 export function getPanelSearchFocusTransition(
@@ -6,25 +8,29 @@ export function getPanelSearchFocusTransition(
 ): PanelSearchFocusTransition {
   const focusKeys = options.focusKeys ?? ['/'];
   if (focusKeys.includes(key)) return 'focus-search';
-  if ((key === 'up' || key === 'ArrowUp') && options.selectedIndex <= 0) {
+  if (key === 'up' && options.selectedIndex <= 0) {
     return 'focus-search';
   }
-  if ((key === 'down' || key === 'ArrowDown') && options.itemCount > 0) {
+  if (key === 'down' && options.itemCount > 0) {
     return 'focus-list';
   }
   return null;
 }
 
+// Panel search filters are end-anchored (no moveable cursor).
+// Per the delete-key policy (src/input/delete-key-policy.ts):
+//   'backspace' removes the last character.
+//   'delete' is a no-op — there is no cursor, so forward-delete is meaningless.
 export function isPanelSearchBackspace(key: string): boolean {
-  return key === 'backspace' || key === 'delete' || key === 'Backspace' || key === 'Delete';
+  return isTextBackspace(key);
 }
 
 export function isPanelSearchCancel(key: string): boolean {
-  return key === 'escape' || key === 'Escape';
+  return key === 'escape';
 }
 
 export function isPanelSearchCommit(key: string): boolean {
-  return key === 'return' || key === 'enter' || key === 'Enter';
+  return key === 'return' || key === 'enter';
 }
 
 export function isPanelSearchPrintable(key: string): boolean {