@pellux/goodvibes-tui 0.28.0 → 1.0.0

package/src/panels/marketplace-panel.ts

@@ -1,6 +1,8 @@
 import type { Line } from '../types/grid.ts';
+import { createEmptyLine } from '../types/grid.ts';
 import { fitDisplay, truncateDisplay } from '../utils/terminal-width.ts';
 import { ScrollableListPanel } from './scrollable-list-panel.ts';
+import { type ConfirmState, handleConfirmInput, renderConfirmLines } from './confirm-state.ts';
 import {
   buildEmptyState,
   buildGuidanceLine,
@@ -12,27 +14,41 @@ import {
 } from './polish.ts';
 import {
   type EcosystemCatalogPathOptions,
+  installEcosystemCatalogEntry,
   listInstalledEcosystemEntries,
   loadEcosystemCatalog,
   reviewEcosystemCatalogEntry,
+  uninstallEcosystemCatalogEntry,
   type EcosystemCatalogEntry,
   type EcosystemEntryKind,
 } from '@/runtime/index.ts';
 import type { UiMarketplaceSnapshot, UiReadModel } from '../runtime/ui-read-models.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
-const C = {
-  ...DEFAULT_PANEL_PALETTE,
-  header: '#e2e8f0',
-  headerBg: '#1f2937',
-} as const;
+// Base chrome only — title band and text tokens come straight from
+// DEFAULT_PANEL_PALETTE (WO-002).
+const C = DEFAULT_PANEL_PALETTE;
+
+type MarketplaceReview = ReturnType<typeof reviewEcosystemCatalogEntry>;
 
 type MarketplaceRow = {
   kind: EcosystemEntryKind;
   entry: EcosystemCatalogEntry;
   installed: boolean;
+  /**
+   * Computed once per refresh() (not per render()) so that render() never
+   * touches disk — see the class-level note on the render()/refresh() split.
+   */
+  review: MarketplaceReview;
 };
 
+/** What a pending install/uninstall confirm will do once the user confirms. */
+interface MarketplaceConfirmSubject {
+  readonly kind: EcosystemEntryKind;
+  readonly entryId: string;
+  readonly action: 'install' | 'uninstall';
+}
+
 function statusColor(installed: boolean): string {
   return installed ? C.good : C.dim;
 }
@@ -40,12 +56,16 @@ function statusColor(installed: boolean): string {
 export class MarketplacePanel extends ScrollableListPanel<MarketplaceRow> {
   private rows: MarketplaceRow[] = [];
   private readonly unsub: (() => void) | null;
+  // I1: confirm state for install/uninstall (destructive-adjacent — mutates disk)
+  private confirm: ConfirmState<MarketplaceConfirmSubject> | null = null;
+  // Entry id whose full review detail is expanded (Enter toggles); cleared on refresh.
+  private expandedEntryId: string | null = null;
 
   public constructor(
     private readonly readModel?: UiReadModel<UiMarketplaceSnapshot>,
     private readonly ecosystemPaths?: EcosystemCatalogPathOptions,
   ) {
-    super('marketplace', 'Marketplace', 'M', 'monitoring');
+    super('marketplace', 'Marketplace', '◩', 'automation-control');
     this.filterEnabled = true;
     this.filterLabel = 'Filter marketplace';
     this.unsub = readModel ? readModel.subscribe(() => this.markDirty()) : null;
@@ -61,11 +81,19 @@ export class MarketplacePanel extends ScrollableListPanel<MarketplaceRow> {
     this.unsub?.();
   }
 
+  // Disk reload happens here (activate) and on explicit 'r' refresh — never
+  // inside render(), which used to reload all four catalogs every frame.
   public override onActivate(): void {
     super.onActivate();
     this.refresh();
   }
 
+  protected override onSelect(row: MarketplaceRow): void {
+    // Enter toggles the full review-detail block for the selected entry.
+    this.expandedEntryId = this.expandedEntryId === row.entry.id ? null : row.entry.id;
+    this.markDirty();
+  }
+
   // ---------------------------------------------------------------------------
   // ScrollableListPanel implementation
   // ---------------------------------------------------------------------------
@@ -101,22 +129,118 @@ export class MarketplacePanel extends ScrollableListPanel<MarketplaceRow> {
     ];
   }
 
+  public override handleInput(key: string): boolean {
+    if (this.lastError !== null) this.clearError();
+
+    const confirmResult = handleConfirmInput(this.confirm, key);
+    if (confirmResult === 'confirmed') {
+      const subject = this.confirm!.subject;
+      this.confirm = null;
+      this._applyConfirmedAction(subject);
+      this.markDirty();
+      return true;
+    }
+    if (confirmResult === 'cancelled') {
+      this.confirm = null;
+      this.markDirty();
+      return true;
+    }
+    if (confirmResult === 'absorbed') return true;
+
+    if (!this.filterActive) {
+      if (key === 'r') {
+        this.refresh();
+        this.markDirty();
+        return true;
+      }
+
+      // selectedIndex is relative to the filtered view, so the acted-on row
+      // must come from getVisibleItems() — this.rows would desync under '/'.
+      const selectedRow = this.getSelectedItem();
+      if (key === 'i' && selectedRow && !selectedRow.installed && this.ecosystemPaths) {
+        this.confirm = {
+          subject: { kind: selectedRow.kind, entryId: selectedRow.entry.id, action: 'install' },
+          label: `${selectedRow.kind} ${selectedRow.entry.name}`,
+          verb: 'Install',
+        };
+        this.markDirty();
+        return true;
+      }
+      if (key === 'u' && selectedRow && selectedRow.installed && this.ecosystemPaths) {
+        this.confirm = {
+          subject: { kind: selectedRow.kind, entryId: selectedRow.entry.id, action: 'uninstall' },
+          label: `${selectedRow.kind} ${selectedRow.entry.name}`,
+          verb: 'Uninstall',
+        };
+        this.markDirty();
+        return true;
+      }
+
+      // Recommendations become actionable jumps: pressing the digit shown next
+      // to a recommendation row jumps the selection to (and expands) that
+      // catalog entry, rather than only printing a static suggestion.
+      if (/^[1-9]$/.test(key)) {
+        const recommendations = this.readModel?.getSnapshot()?.recommendations ?? [];
+        const recommendation = recommendations[Number(key) - 1];
+        if (recommendation) {
+          // Search the visible (possibly filtered) list: selectedIndex is
+          // visible-relative, so a this.rows index would land on the wrong row.
+          const targetIndex = this.getVisibleItems().findIndex((row) => row.kind === recommendation.kind && row.entry.id === recommendation.entry.id);
+          if (targetIndex >= 0) {
+            this.selectedIndex = targetIndex;
+            this.expandedEntryId = recommendation.entry.id;
+            this.markDirty();
+            return true;
+          }
+        }
+      }
+    }
+
+    return super.handleInput(key);
+  }
+
+  private _applyConfirmedAction(subject: MarketplaceConfirmSubject): void {
+    if (!this.ecosystemPaths) return;
+    const verb = subject.action === 'install' ? 'Install' : 'Uninstall';
+    try {
+      const result = subject.action === 'install'
+        ? installEcosystemCatalogEntry(subject.kind, subject.entryId, this.ecosystemPaths)
+        : uninstallEcosystemCatalogEntry(subject.kind, subject.entryId, this.ecosystemPaths);
+      if (!result.ok) {
+        this.setError(`${verb} failed: ${result.error}`);
+        return;
+      }
+      this.clearError();
+      this.refresh();
+    } catch (e) {
+      this.setError(`${verb} failed: ${summarizeError(e)}`);
+    }
+  }
+
   private refresh(): void {
     if (!this.ecosystemPaths) {
       this.rows = [];
       this.clampSelection();
       return;
     }
+    const ecosystemPaths = this.ecosystemPaths;
     try {
-      const installedPlugins = new Set(listInstalledEcosystemEntries('plugin', this.ecosystemPaths).map((receipt) => receipt.entry.id));
-      const installedSkills = new Set(listInstalledEcosystemEntries('skill', this.ecosystemPaths).map((receipt) => receipt.entry.id));
-      const installedHookPacks = new Set(listInstalledEcosystemEntries('hook-pack', this.ecosystemPaths).map((receipt) => receipt.entry.id));
-      const installedPolicyPacks = new Set(listInstalledEcosystemEntries('policy-pack', this.ecosystemPaths).map((receipt) => receipt.entry.id));
+      const installedPlugins = new Set(listInstalledEcosystemEntries('plugin', ecosystemPaths).map((receipt) => receipt.entry.id));
+      const installedSkills = new Set(listInstalledEcosystemEntries('skill', ecosystemPaths).map((receipt) => receipt.entry.id));
+      const installedHookPacks = new Set(listInstalledEcosystemEntries('hook-pack', ecosystemPaths).map((receipt) => receipt.entry.id));
+      const installedPolicyPacks = new Set(listInstalledEcosystemEntries('policy-pack', ecosystemPaths).map((receipt) => receipt.entry.id));
+      const build = (kind: EcosystemEntryKind, installed: Set<string>): MarketplaceRow[] =>
+        loadEcosystemCatalog(kind, ecosystemPaths).map((entry) => ({
+          kind,
+          entry,
+          installed: installed.has(entry.id),
+          review: reviewEcosystemCatalogEntry(entry, ecosystemPaths),
+        }));
       const rows: MarketplaceRow[] = [
-        ...loadEcosystemCatalog('plugin', this.ecosystemPaths).map((entry) => ({ kind: 'plugin' as const, entry, installed: installedPlugins.has(entry.id) })),
-        ...loadEcosystemCatalog('skill', this.ecosystemPaths).map((entry) => ({ kind: 'skill' as const, entry, installed: installedSkills.has(entry.id) })),
-        ...loadEcosystemCatalog('hook-pack', this.ecosystemPaths).map((entry) => ({ kind: 'hook-pack' as const, entry, installed: installedHookPacks.has(entry.id) })),
-        ...loadEcosystemCatalog('policy-pack', this.ecosystemPaths).map((entry) => ({ kind: 'policy-pack' as const, entry, installed: installedPolicyPacks.has(entry.id) })),
+        ...build('plugin', installedPlugins),
+        ...build('skill', installedSkills),
+        ...build('hook-pack', installedHookPacks),
+        ...build('policy-pack', installedPolicyPacks),
       ];
       this.rows = rows.sort((a, b) => a.entry.name.localeCompare(b.entry.name));
       this.clampSelection();
@@ -130,7 +254,16 @@ export class MarketplacePanel extends ScrollableListPanel<MarketplaceRow> {
 
   public render(width: number, height: number): Line[] {
     this.clampSelection();
-    this.refresh();
+
+    if (this.confirm) {
+      const lines = buildPanelWorkspace(width, height, {
+        title: 'Marketplace Control Room',
+        sections: [{ title: 'Confirmation', lines: renderConfirmLines(width, this.confirm) }],
+        palette: C,
+      });
+      while (lines.length < height) lines.push(createEmptyLine(width));
+      return lines.slice(0, height);
+    }
 
     const intro = 'Curated local-first ecosystem with provenance, compatibility, rollback history, and receipt-aware lifecycle review.';
     const installedCount = this.rows.filter((row) => row.installed).length;
@@ -170,14 +303,16 @@ export class MarketplacePanel extends ScrollableListPanel<MarketplaceRow> {
         { label: 'hooks', value: String(this.rows.filter((row) => row.kind === 'hook-pack').length), valueColor: C.info },
         { label: 'policies', value: String(this.rows.filter((row) => row.kind === 'policy-pack').length), valueColor: C.info },
       ], C),
-      buildGuidanceLine(width, '/marketplace open', 'browse curated entries and inspect compatibility, provenance, and receipts', C),
     ];
 
+    // Recommendations become actionable jumps: each row is numbered and the
+    // matching digit key jumps the main selection straight to that entry
+    // (see handleInput) instead of only printing a static suggestion.
     const recommendationLines = recommendations.length > 0
-      ? recommendations.slice(0, 4).map((recommendation) => buildPanelLine(width, [
-          ['  ', C.label],
-          [fitDisplay(`${recommendation.kind} ${recommendation.entry.id}`, 28), C.info],
-          [truncateDisplay(` ${recommendation.title}`, Math.max(0, width - 31)), C.dim],
+      ? recommendations.slice(0, 4).map((recommendation, index) => buildPanelLine(width, [
+          [`  [${index + 1}] `, C.info],
+          [fitDisplay(`${recommendation.kind} ${recommendation.entry.id}`, 26), C.info],
+          [truncateDisplay(` ${recommendation.title}`, Math.max(0, width - 33)), C.dim],
         ]))
       : [buildPanelLine(width, [['  No contextual marketplace recommendations right now.', C.dim]])];
 
@@ -185,10 +320,12 @@ export class MarketplacePanel extends ScrollableListPanel<MarketplaceRow> {
       ? startupIssues.slice(0, 4).map((issue) => buildPanelLine(width, [['  ', C.label], [truncateDisplay(issue, Math.max(0, width - 2)), C.warn]]))
       : [buildPanelLine(width, [['  No startup or lifecycle issues are currently pushing marketplace repair recommendations.', C.dim]])];
 
-    const selectedRow = this.rows[this.selectedIndex];
+    const selectedRow = this.getSelectedItem();
     const selectedLines: Line[] = [];
     if (selectedRow) {
-      const review = reviewEcosystemCatalogEntry(selectedRow.entry, this.ecosystemPaths!);
+      // review is computed once in refresh() (not here) so render() never
+      // touches disk.
+      const review = selectedRow.review;
       selectedLines.push(buildPanelLine(width, [
         ['  Provenance: ', C.label],
         [truncateDisplay(selectedRow.entry.provenance ?? '(none)', Math.max(0, width - 15)), selectedRow.entry.provenance ? C.info : C.dim],
@@ -202,16 +339,46 @@ export class MarketplacePanel extends ScrollableListPanel<MarketplaceRow> {
         { label: 'Risk', value: review.riskLevel, valueColor: review.riskLevel === 'low' ? C.good : C.warn },
         { label: 'State', value: selectedRow.installed ? 'installed' : 'curated', valueColor: statusColor(selectedRow.installed) },
       ], C));
-      selectedLines.push(buildGuidanceLine(width, '/marketplace review <id>', 'inspect full compatibility and receipt detail for the selected entry', C));
+
+      if (this.expandedEntryId === selectedRow.entry.id) {
+        // Enter = full review detail: every field reviewEcosystemCatalogEntry
+        // returns, not just the compact compatibility/risk/state summary above.
+        selectedLines.push(buildPanelLine(width, [
+          ['  Source path: ', C.label],
+          [truncateDisplay(review.sourcePath, Math.max(0, width - 16)), review.sourceExists ? C.good : C.warn],
+        ]));
+        selectedLines.push(buildKeyValueLine(width, [
+          { label: 'Source kind', value: review.sourceKind, valueColor: C.info },
+          { label: 'Source exists', value: review.sourceExists ? 'yes' : 'no', valueColor: review.sourceExists ? C.good : C.warn },
+          { label: 'Recommended scope', value: review.recommendedScope, valueColor: C.info },
+        ], C));
+        selectedLines.push(buildPanelLine(width, [
+          ['  Runtime fit: ', C.label],
+          [review.runtimeFit.status, review.runtimeFit.status === 'supported' ? C.good : C.warn],
+          [review.runtimeFit.reasons.length > 0 ? ` (${review.runtimeFit.reasons.join('; ')})` : '', C.dim],
+        ]));
+        if (review.compatibility.reasons.length > 0) {
+          selectedLines.push(buildPanelLine(width, [
+            ['  Compatibility notes: ', C.label],
+            [truncateDisplay(review.compatibility.reasons.join('; '), Math.max(0, width - 24)), C.warn],
+          ]));
+        }
+      } else {
+        selectedLines.push(buildGuidanceLine(width, 'Enter', 'expand full compatibility, receipt, and runtime-fit detail for the selected entry', C));
+      }
     }
 
-    // Context-aware hints: filter mode vs. browse mode (install only makes sense
-    // when a curated, not-yet-installed entry is selected).
+    // Context-aware hints: filter mode vs. browse mode (install/uninstall only
+    // make sense given the selected entry's current install state).
     const hints = this.filterActive
       ? [{ keys: 'type', label: 'filter' }, { keys: 'Enter', label: 'apply' }, { keys: 'Esc', label: 'clear' }]
       : [
           { keys: 'Up/Down', label: 'move' },
-          ...(selectedRow && !selectedRow.installed ? [{ keys: '/marketplace install', label: 'add' }] : []),
+          { keys: 'Enter', label: 'detail' },
+          ...(selectedRow && !selectedRow.installed ? [{ keys: 'i', label: 'install' }] : []),
+          ...(selectedRow && selectedRow.installed ? [{ keys: 'u', label: 'uninstall' }] : []),
+          ...(recommendations.length > 0 ? [{ keys: '1-9', label: 'jump to recommendation' }] : []),
+          { keys: 'r', label: 'refresh' },
           { keys: '/', label: 'filter' },
         ];
 

package/src/panels/memory-panel.ts

@@ -13,31 +13,26 @@
 import type { Line } from '../types/grid.ts';
 import type { MemoryRegistry } from '@pellux/goodvibes-sdk/platform/state';
 import type { MemoryClass, MemoryRecord, MemoryReviewState } from '@pellux/goodvibes-sdk/platform/state';
-import { ScrollableListPanel, SearchableListPanel } from './scrollable-list-panel.ts';
+import { ScrollableListPanel } from './scrollable-list-panel.ts';
 import { truncateDisplay } from '../utils/terminal-width.ts';
 import { type ConfirmState, handleConfirmInput, renderConfirmLines } from './confirm-state.ts';
 import {
   buildBodyText,
-  buildGuidanceLine,
   buildKeyValueLine,
   buildPanelLine,
   buildPanelWorkspace,
   extendPalette,
   DEFAULT_PANEL_PALETTE,
 } from './polish.ts';
-import {
-  getPanelSearchFocusTransition,
-  isPanelSearchCancel,
-} from './search-focus.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
 // ---------------------------------------------------------------------------
 // Colour palette
 // ---------------------------------------------------------------------------
 
+// Domain accents only — one hue per memory class (base chrome: header/
+// headerBg/selectBg come from DEFAULT_PANEL_PALETTE).
 const C = extendPalette(DEFAULT_PANEL_PALETTE, {
-  header: '#94a3b8',
-  headerBg: '#1e293b',
   decision: '#38bdf8',
   constraint: '#f97316',
   incident: '#ef4444',
@@ -47,9 +42,6 @@ const C = extendPalette(DEFAULT_PANEL_PALETTE, {
   runbook: '#eab308',
   architecture: '#60a5fa',
   ownership: '#14b8a6',
-  selected: '#1e3a5f',
-  searchBg: '#0f172a',
-  searchFg: '#e2e8f0',
 });
 
 // ---------------------------------------------------------------------------
@@ -104,14 +96,13 @@ function formatConfidence(confidence: number): string {
 // MemoryPanel
 // ---------------------------------------------------------------------------
 
-export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
+export class MemoryPanel extends ScrollableListPanel<MemoryRecord> {
   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;
+  // Confirm state (for destructive stale/contradict/delete actions)
+  private confirm: ConfirmState<{ id: string; action: 'stale' | 'contradicted' | 'delete' }> | null = null;
 
   // Cached records for review-mode (reviewQueue-first, same as former KnowledgePanel)
   private reviewRecords: MemoryRecord[] = [];
@@ -119,6 +110,10 @@ export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
   constructor(registry: MemoryRegistry) {
     super('memory', 'Memory', 'M', 'agent');
     this.registry = registry;
+    // WO-153: converged modal '/' filter — only active in 'all' mode; review
+    // mode uses r/s/c/f/d single-letter actions instead of text filtering.
+    this.filterEnabled = true;
+    this.filterLabel = 'Search';
   }
 
   // ---------------------------------------------------------------------------
@@ -127,13 +122,11 @@ export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
 
   override onActivate(): void {
     super.onActivate();
-    this.searchQuery = '';
-    this.invalidateFilter();
-    this.filterFocused = false;
+    this.filterQuery = '';
+    this.filterActive = false;
     this.confirm = null;
     this.refreshReviewRecords();
     this.unsubscribe = this.registry.subscribe(() => {
-      this.invalidateFilter();
       this.refreshReviewRecords();
       this.markDirty();
     });
@@ -149,16 +142,11 @@ export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
   }
 
   // ---------------------------------------------------------------------------
-  // SearchableListPanel implementation (used in 'all' filter mode)
+  // ScrollableListPanel implementation (filter is only enabled in 'all' mode)
   // ---------------------------------------------------------------------------
 
-  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;
+  /** `q` arrives already trimmed + lower-cased from ScrollableListPanel.getVisibleItems(). */
+  protected override filterMatches(record: MemoryRecord, q: string): boolean {
     const haystack = [
       record.summary,
       record.detail ?? '',
@@ -181,7 +169,7 @@ export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
       ]);
     }
     // All-mode row: scope/class + id + time + summary (matches former MemoryPanel row)
-    const bg = selected ? C.selected : undefined;
+    const bg = selected ? C.selectBg : undefined;
     return buildPanelLine(width, [
       ['  ', C.label, bg],
       [`[${record.scope.slice(0, 1).toUpperCase()}/${record.cls.slice(0, 3).toUpperCase()}] `, classColor(record.cls), bg],
@@ -197,9 +185,9 @@ export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
 
   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.';
+    // The filter-narrowed-to-empty case is handled by ScrollableListPanel's
+    // own 'No matches for "..."' message (renderList) before this is reached.
+    return ' No memory records. Use /recall add <class> <summary> to create one.';
   }
 
   protected override getEmptyStateActions() {
@@ -215,14 +203,15 @@ export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
   // ---------------------------------------------------------------------------
 
   /**
-   * 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.
+   * getItems() so that ScrollableListPanel infrastructure (renderList,
+   * clampSelection, navigation bounds, and — in 'all' mode — the modal '/'
+   * filter) all operate on the right data set per 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[] {
+  protected getItems(): readonly MemoryRecord[] {
     if (this.filterMode === 'review') return this.reviewRecords;
-    return super.getItems();
+    return this.registry.search({ limit: 100 });
   }
 
   private refreshReviewRecords(): void {
@@ -230,11 +219,19 @@ export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
     this.clampSelection();
   }
 
+  /** Count of records beyond the 100-record fetch cap in getItems(). */
+  private getHiddenCount(): number {
+    const total = this.registry.search({}).length;
+    return Math.max(0, total - 100);
+  }
+
   private cycleFilter(): void {
     const modes: FilterMode[] = ['all', 'review'];
     const next = modes[(modes.indexOf(this.filterMode) + 1) % modes.length];
     this.filterMode = next;
-    this.invalidateFilter();
+    // The modal '/' filter only applies in 'all' mode — review mode uses
+    // r/s/c/f/d single-letter actions instead of text filtering.
+    this.filterEnabled = next === 'all';
     this.refreshReviewRecords();
     this.markDirty();
   }
@@ -250,6 +247,16 @@ export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
       if (result === 'confirmed') {
         const { id, action } = this.confirm.subject;
         this.confirm = null;
+        if (action === 'delete') {
+          try {
+            this.registry.delete(id);
+          } catch (e) {
+            this.setError(`Delete failed: ${summarizeError(e)}`);
+          }
+          this.refreshReviewRecords();
+          this.markDirty();
+          return true;
+        }
         const record = this.reviewRecords.find((r) => r.id === id);
         if (record) {
           try {
@@ -292,7 +299,9 @@ export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
 
     // Review-mode specific actions (r/s/c/f)
     if (this.filterMode === 'review') {
-      const selected = this.reviewRecords[this.selectedIndex];
+      // In review mode getItems() returns reviewRecords and filterEnabled is
+      // false, so getSelectedItem() resolves the highlighted review record.
+      const selected = this.getSelectedItem();
 
       if (key === 'enter' || key === 'return' || key === 'r') {
         if (!selected) return false;
@@ -328,46 +337,35 @@ export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
         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);
+      if (key === 'd') {
+        if (!selected) return false;
+        this.confirm = { subject: { id: selected.id, action: 'delete' }, label: truncateDisplay(selected.summary, 40) };
+        this.markDirty();
+        return true;
       }
+    }
 
-      const items = this.getItems();
-      const transition = getPanelSearchFocusTransition(key, { selectedIndex: this.selectedIndex, itemCount: items.length });
-      if (transition === 'focus-search') {
-        this.filterFocused = true;
+    // All-mode: 'r' reload and 'd' delete are single-letter actions that
+    // coexist with the modal '/' filter — they only fire outside filter
+    // mode, so they remain typeable into the filter query while it's active.
+    if (this.filterMode === 'all' && !this.filterActive) {
+      if (key === 'r') {
         this.markDirty();
         return true;
       }
 
-      if (key === 'r') {
-        this.invalidateFilter();
+      if (key === 'd') {
+        const selected = this.getSelectedItem();
+        if (!selected) return false;
+        this.confirm = { subject: { id: selected.id, action: 'delete' }, label: truncateDisplay(selected.summary, 40) };
         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);
-    }
+    // Navigation + (in 'all' mode) the modal '/' filter: delegate to
+    // ScrollableListPanel. filterEnabled is false in review mode, so '/' is
+    // inert there and single-char keys like 'j'/'k' navigate normally.
     return super.handleInput(key);
   }
 
@@ -403,13 +401,16 @@ export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
   }
 
   private renderAllMode(width: number, height: number, filterToggleLine: Line): Line[] {
-    const records = this.getItems();
+    // getVisibleItems() applies the modal '/' filter (getItems() is the
+    // unfiltered 100-cap fetch); the filter input line itself is
+    // auto-injected by renderList() below (filterEnabled=true in 'all' mode).
+    const records = this.getVisibleItems();
     const byClass = new Map<MemoryClass, number>();
     for (const record of records) {
       byClass.set(record.cls, (byClass.get(record.cls) ?? 0) + 1);
     }
 
-    const filterInputLine = this.buildFilterInputLine(width, 'Search', this.filterFocused);
+    const hiddenCount = this.getHiddenCount();
 
     const summaryLines: Line[] = [
       buildKeyValueLine(width, [
@@ -420,11 +421,12 @@ export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
         { label: 'runbooks', value: String(byClass.get('runbook') ?? 0), valueColor: C.runbook },
       ], C),
       filterToggleLine,
-      filterInputLine,
-      buildGuidanceLine(width, '/recall review', 'review durable knowledge and queue posture from the command surface', C),
+      ...(hiddenCount > 0
+        ? [buildPanelLine(width, [[`  +${hiddenCount} hidden (100-record cap)`, C.dim]])]
+        : []),
     ];
 
-    const selected = records[this.selectedIndex];
+    const selected = this.getSelectedItem();
     const selectedLines: Line[] = [];
     if (selected) {
       selectedLines.push(buildKeyValueLine(width, [
@@ -450,7 +452,7 @@ export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
       header: summaryLines,
       footer: [
         ...selectedLines,
-        buildPanelLine(width, [['  / search  j/k or Up/Down move  r reload  Tab: Review Queue  Esc clear search', C.dim]]),
+        buildPanelLine(width, [['  / search  j/k or Up/Down move  r reload  d delete  Tab: Review Queue  Esc clear search', C.dim]]),
       ],
     });
   }
@@ -500,10 +502,9 @@ export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
         ['  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 selectedRecord = this.getSelectedItem();
     const selectedLines: Line[] = [];
     if (selectedRecord) {
       selectedLines.push(buildPanelLine(width, [['  Selected', C.label]]));
@@ -550,7 +551,7 @@ export class MemoryPanel extends SearchableListPanel<MemoryRecord> {
       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]]),
+        buildPanelLine(width, [['  Tab: All Records  Up/Down move  r/Enter reviewed  s stale  c contradicted  f fresh  d delete', C.dim]]),
       ],
     });
   }