@pellux/goodvibes-tui 1.1.0 → 1.7.0

package/src/panels/panel-manager.ts

@@ -3,6 +3,10 @@
 // ---------------------------------------------------------------------------
 
 import type { Panel, PanelRegistration, PanelCategory } from './types.ts';
+// Type-only, erased at runtime, routed through the `@/` alias (not a relative
+// path) so it stays out of the relative-import graph the architecture
+// cycle-checker walks — same discipline as the PanelManager import in types.ts.
+import type { ConfigModalSurface } from '@/input/config-modal-types.ts';
 
 // ---------------------------------------------------------------------------
 // Pane
@@ -31,6 +35,29 @@ export class PanelManager {
   private retainedPanels = new Map<string, Panel>();
   /** Old/absorbed panel id -> merged target id (WO-1xx console merges). */
   private aliases = new Map<string, string>();
+  /**
+   * Retired panel id -> modal name (W6.1 purge, MIGRATE-TO-MODAL surfaces).
+   * Unlike `aliases` (panel -> panel), a hit here means no panel is ever
+   * constructed for this id — `open()` invokes `openModalCallback` instead
+   * and returns a sentinel. Registrations are added by WO-A/B; this map and
+   * the open()-time check are WO-C's mechanism only.
+   */
+  private modalRedirects = new Map<string, string>();
+  /**
+   * Modal name -> the surface the config-modal host renders (W6.1). Built once
+   * in builtin-modals.ts (closing over read-models) and looked up by
+   * ui-openers' openModal callback. Distinct from `modalRedirects` (panel id ->
+   * modal name): a redirect resolves a legacy panel id to a name; this map
+   * resolves that name to the actual surface data/actions.
+   */
+  private modalSurfaces = new Map<string, ConfigModalSurface>();
+  /**
+   * Late-bound: the modal stack is constructed after PanelManager (same
+   * ordering constraint as the openAgentDetail callback in
+   * builtin/shared.ts), so this is injected via a setter rather than the
+   * constructor.
+   */
+  private openModalCallback?: (modalName: string) => void;
   private _visible: boolean = false;
   private _splitRatio: number = 0.6;
 
@@ -99,10 +126,76 @@ export class PanelManager {
     this.aliases.set(aliasId, targetId);
   }
 
+  /**
+   * Register a redirect so `open(panelId)` opens the named modal instead of
+   * constructing a panel (MIGRATE-TO-MODAL surfaces). Checked in open()
+   * before alias/registry resolution.
+   */
+  registerModalRedirect(panelId: string, modalName: string): void {
+    this.modalRedirects.set(panelId, modalName);
+  }
+
+  /**
+   * Inject the callback `open()` invokes when it hits a modal redirect.
+   * Late-bound via setter because the modal stack is constructed after
+   * PanelManager (mirrors the openAgentDetail callback pattern).
+   */
+  setOpenModalCallback(callback: (modalName: string) => void): void {
+    this.openModalCallback = callback;
+  }
+
+  /**
+   * The modal name `panelIdOrAlias` redirects to, if any — lets callers
+   * (e.g. the `/panel` command) print "moved to the <name> modal" before or
+   * instead of calling open().
+   */
+  getModalRedirect(panelIdOrAlias: string): string | undefined {
+    return this.modalRedirects.get(panelIdOrAlias);
+  }
+
+  /**
+   * Register the surface (data + actions) the config-modal host renders for a
+   * modal name. Called from builtin-modals.ts alongside registerModalRedirect.
+   */
+  registerModalSurface(surface: ConfigModalSurface): void {
+    this.modalSurfaces.set(surface.name, surface);
+  }
+
+  /** Resolve a modal name to its registered surface, if any. */
+  getModalSurface(name: string): ConfigModalSurface | undefined {
+    return this.modalSurfaces.get(name);
+  }
+
   private _resolveId(panelId: string): string {
     return this.aliases.get(panelId) ?? panelId;
   }
 
+  /**
+   * Placeholder returned by open() for a modal-redirected id. Never pushed
+   * into a pane, never retained, never rendered — it exists only so open()
+   * can keep its non-null `Panel` return type without constructing the real
+   * (deleted) panel view. `name` carries the modal name so a caller that
+   * inspects the returned panel's `name` (rather than calling
+   * getModalRedirect() beforehand) still gets an honest answer.
+   */
+  private _modalRedirectSentinel(panelId: string, modalName: string): Panel {
+    return {
+      id: panelId,
+      name: modalName,
+      icon: '·',
+      category: 'session',
+      onActivate: () => {},
+      onDeactivate: () => {},
+      onDestroy: () => {},
+      render: () => [],
+      isTransient: true,
+      isPinned: false,
+      needsRender: false,
+      invalidate: () => {},
+      markRendered: () => {},
+    };
+  }
+
   getRegisteredTypes(): PanelRegistration[] {
     return [...this.registry];
   }
@@ -136,6 +229,11 @@ export class PanelManager {
   }
 
   open(panelIdOrAlias: string, pane?: 'top' | 'bottom'): Panel {
+    const modalName = this.modalRedirects.get(panelIdOrAlias);
+    if (modalName !== undefined) {
+      this.openModalCallback?.(modalName);
+      return this._modalRedirectSentinel(panelIdOrAlias, modalName);
+    }
     const panelId = this._resolveId(panelIdOrAlias);
     this._recordRecent(panelId);
     const existingPane = this._findPaneOf(panelId);
@@ -387,9 +485,12 @@ export class PanelManager {
           this.bottomPane.panels.push(panel);
           this.bottomPane.activeIndex = 0;
         } else {
-          // Open a predictable default panel in the bottom pane (the panel list),
-          // rather than an arbitrary registration-order-dependent panel.
-          const defaultPanel = this._getRegistration('panel-list') ?? this.registry[0];
+          // Open a predictable default panel in the bottom pane. W6.1 purge:
+          // 'panel-list' was deleted (dead weight over a 5-panel registry —
+          // see the DELETE disposition), so the default is explicitly
+          // 'fleet' rather than falling back to registry[0] (whatever
+          // registers first, currently 'git' — see risk 5 in the brief).
+          const defaultPanel = this._getRegistration('fleet') ?? this.registry[0];
           if (defaultPanel) {
             this.open(defaultPanel.id, 'bottom');
           }
@@ -493,9 +594,11 @@ export class PanelManager {
 
   toggle(): void {
     this._visible = !this._visible;
-    // Auto-open a default panel if toggling visible with nothing open
+    // Auto-open a default panel if toggling visible with nothing open.
+    // W6.1 purge: explicitly 'fleet' rather than registry[0] — see the
+    // matching comment in toggleBottomPane() above.
     if (this._visible && this.topPane.panels.length === 0 && this.bottomPane.panels.length === 0) {
-      const defaultPanel = this._getRegistration('panel-list') ?? this.registry[0];
+      const defaultPanel = this._getRegistration('fleet') ?? this.registry[0];
       if (defaultPanel) this.open(defaultPanel.id);
     }
   }

package/src/panels/project-planning-answer-actions.ts

@@ -125,8 +125,10 @@ export function buildAnswerActions(question: ProjectPlanningQuestion, draftAnswe
   });
   actions.push({
     id: 'dismiss-planning',
-    label: 'Close planning and continue without it',
-    detail: 'Pause project planning for this workspace. Normal chat continues; /plan can reopen it later.',
+    // Honest label: there is no /plan subcommand that pauses planning, so this
+    // row only closes the panel — it does NOT change any planning state.
+    label: 'Close (planning unchanged)',
+    detail: 'Close this panel. Pausing project planning is not available as a command yet, so planning state is left unchanged; /plan reopens it later.',
     answer: 'Pause project planning for this workspace and continue without the planning panel.',
     kind: 'dismiss',
   });

package/src/panels/skills-panel.ts

@@ -5,8 +5,6 @@ import { createEmptyLine } from '../types/grid.ts';
 import { type ConfirmState, handleConfirmInput, renderConfirmLines } from './confirm-state.ts';
 import { getDisplayWidth, truncateDisplay } from '../utils/terminal-width.ts';
 import { ScrollableListPanel } from './scrollable-list-panel.ts';
-import { FilePreviewPanel } from './file-preview-panel.ts';
-import type { PanelIntegrationContext } from './types.ts';
 import type { ComponentHealthMonitor } from '../runtime/perf/panel-health-monitor.ts';
 import { listInstalledEcosystemEntries, type EcosystemCatalogPathOptions, type ShellPathService } from '@/runtime/index.ts';
 import {
@@ -257,11 +255,6 @@ export class SkillsPanel extends ScrollableListPanel<SkillRecord> {
   // I1: confirm state for destructive delete
   private confirm: ConfirmState | null = null;
   private readyPromise: Promise<void> | null = null;
-  // Staged pending action consumed by handlePanelIntegrationAction (same
-  // pattern as diff-panel.ts's pendingOpenPreview): Enter marks the intent
-  // here, the actual PanelManager/preview wiring happens once the
-  // integration context is available.
-  private pendingOpenPreview = false;
 
   public constructor(options: SkillsPanelOptions) {
     super('skills', 'Skills', '▩', 'automation-control', options.componentHealthMonitor);
@@ -374,50 +367,13 @@ export class SkillsPanel extends ScrollableListPanel<SkillRecord> {
 
   public override onDestroy(): void {}
 
-  protected override onSelect(_skill: SkillRecord): void {
-    // Enter opens the skill's markdown source in the preview panel — see
-    // handlePanelIntegrationAction for the actual PanelManager wiring
-    // (needs the integration context, not available here). Selection itself
-    // is read back from getVisibleItems() in that hook. onSelect is only
-    // invoked by ScrollableListPanel's navigation handler when the filter is
-    // not active, so no manual guard is needed here.
-    this.pendingOpenPreview = true;
-  }
-
-  /**
-   * Cross-panel integration hook — Enter opens the selected skill's markdown
-   * source in the preview panel via the same open/focus bridge DiffPanel
-   * uses (src/input/panel-integration-actions.ts), without this panel
-   * needing to know about PanelManager pane/focus mechanics beyond what ctx
-   * exposes.
-   */
-  public handlePanelIntegrationAction(_key: string, ctx: PanelIntegrationContext): boolean {
-    if (!this.pendingOpenPreview) return false;
-    this.pendingOpenPreview = false;
-    const skill = this.getSelectedItem();
-    if (!skill) return false;
-
-    const pm = ctx.panelManager;
-    let previewPanel = pm.getPanel('preview');
-    if (previewPanel instanceof FilePreviewPanel) {
-      const pane = pm.getPaneOf('preview');
-      pm.activateById('preview');
-      if (pane) pm.focusPane(pane);
-    } else {
-      const targetPane: 'top' | 'bottom' = pm.isBottomPaneVisible()
-        ? (pm.getFocusedPane() === 'top' ? 'bottom' : 'top')
-        : 'bottom';
-      const opened = pm.open('preview', targetPane);
-      pm.show();
-      pm.focusPane(targetPane);
-      previewPanel = opened instanceof FilePreviewPanel ? opened : null;
-    }
-    if (previewPanel instanceof FilePreviewPanel) {
-      previewPanel.openFile(skill.path);
-      return true;
-    }
-    return false;
-  }
+  // W6.1 (the purge): Enter used to open the skill's markdown source in the
+  // preview panel via a staged pendingOpenPreview flag + handlePanelIntegrationAction
+  // (same pattern diff-panel.ts used). 'preview' is DELETE-disposition with no
+  // successor surface (no file-picker-overlay preview to repoint to either —
+  // verified), so that cross-panel jump was removed rather than repointed;
+  // Enter is currently a no-op on this list (browse-only until WO-B migrates
+  // Skills to a modal).
 
   public handleInput(key: string): boolean {
     // I1: y/n confirmation dialog for delete

package/src/panels/types.ts

@@ -126,6 +126,19 @@ export interface Panel {
    * back to its built-in `instanceof` routing.
    */
   handlePanelIntegrationAction?(key: string, ctx: PanelIntegrationContext): boolean;
+
+  /**
+   * Optional: called by the global Ctrl+X (`panel-close`) shortcut BEFORE it
+   * closes this panel (handler-shortcuts.ts). Return `true` to consume
+   * Ctrl+X for an in-panel action instead — e.g. FleetPanel (Wave-3 session
+   * tabs) detaches its active tab and leaves the panel open. Return `false`
+   * (or omit this hook) to fall through to the ordinary close behavior.
+   * Ctrl+X never reaches a panel's own `handleInput` (ctrl/meta combos are
+   * intercepted earlier — see handlePanelFocusToken in
+   * src/input/handler-feed-routes.ts), so this is the one seam a panel has
+   * to intervene before the global shortcut acts.
+   */
+  interceptPanelClose?(): boolean;
 }
 
 export interface PanelRegistration extends Pick<Panel, 'id' | 'name' | 'icon' | 'category'> {

package/src/permissions/hunk-selection.ts

@@ -0,0 +1,179 @@
+import type { PermissionPromptRequest } from '@pellux/goodvibes-sdk/platform/permissions';
+
+/**
+ * Per-hunk accept/reject at the approval gate (W1.3 v1).
+ *
+ * Scoped to the `edit` tool only: EditInput.edits is already an array of
+ * independent, atomic find/replace units (each a natural "hunk"), so no
+ * diff/hunk-apply primitive is needed here. The `write` (whole-file
+ * overwrite) tool stays whole-payload accept/reject — true whole-file hunk
+ * splitting would require a genuinely new SDK diff/patch-apply primitive,
+ * flagged as an explicit v2 follow-up, not built here.
+ *
+ * NOTE ON SDK TYPES: the installed @pellux/goodvibes-sdk (0.36.0) does not
+ * yet export `EditItem`/`EditInput` from its `platform/tools` subpath (that
+ * export is added in the in-flight SDK change for this work order, landing
+ * in 0.37). Until then this module reads `request.args.edits` defensively
+ * off a narrow local structural type rather than importing a not-yet-published
+ * symbol, per the cross-repo compile contract for this wave.
+ */
+
+/** Structural shape of one EditItem, read defensively — see module doc. */
+export interface EditItemLike {
+  readonly path: string;
+  readonly find: string;
+  readonly replace: string;
+  readonly id?: string | undefined;
+}
+
+export interface HunkSelectionState {
+  readonly hunks: readonly EditItemLike[];
+  readonly cursor: number;
+  readonly selected: ReadonlySet<number>;
+}
+
+export type HunkCommit = 'apply' | 'cancel' | null;
+
+/**
+ * Structural widening of the installed SDK's `PermissionPromptDecision`
+ * (0.36.0, no `modifiedArgs` field yet) so main.ts can resolve a decision
+ * carrying `modifiedArgs` without a nominal import of a not-yet-published
+ * SDK symbol. Assign to a variable of this type before calling the SDK's
+ * typed `resolve(decision: PermissionPromptDecision)` — passing a variable
+ * (not an object literal) sidesteps TypeScript's excess-property check, and
+ * the extra field is invisible to 0.36.0 callers, structurally compatible
+ * once 0.37 adds it for real.
+ */
+export interface PermissionPromptDecisionWithModifiedArgs {
+  approved: boolean;
+  remember?: boolean;
+  modifiedArgs?: Record<string, unknown>;
+}
+
+export interface HunkKeyResult {
+  readonly state: HunkSelectionState;
+  readonly commit: HunkCommit;
+}
+
+/** Runtime guard: is `value` shaped like an EditItem? */
+function isEditItemLike(value: unknown): value is EditItemLike {
+  if (typeof value !== 'object' || value === null) return false;
+  const candidate = value as Record<string, unknown>;
+  return (
+    typeof candidate['path'] === 'string' &&
+    typeof candidate['find'] === 'string' &&
+    typeof candidate['replace'] === 'string' &&
+    (candidate['id'] === undefined || typeof candidate['id'] === 'string')
+  );
+}
+
+/** Extracts a validated EditItemLike[] from a permission request's args, or null if not edit-shaped. */
+function readEditItems(args: Record<string, unknown>): EditItemLike[] | null {
+  const edits = args['edits'];
+  if (!Array.isArray(edits) || edits.length === 0) return null;
+  const items: EditItemLike[] = [];
+  for (const entry of edits) {
+    if (!isEditItemLike(entry)) return null;
+    items.push(entry);
+  }
+  return items;
+}
+
+/**
+ * isHunkSelectable — true iff this is a multi-edit `edit` tool call. Single-edit
+ * `edit` calls, `write` calls, and everything else keep the exact current
+ * y/a/n flow untouched (zero behavior change for the common case).
+ */
+export function isHunkSelectable(request: PermissionPromptRequest): boolean {
+  if (request.tool !== 'edit') return false;
+  const items = readEditItems(request.args);
+  return items !== null && items.length > 1;
+}
+
+/** Builds initial hunk-selection state — all hunks selected by default (matches today's "y = approve everything" expectation as the zero-navigation path). */
+export function buildHunkSelectionState(request: PermissionPromptRequest): HunkSelectionState {
+  const hunks = readEditItems(request.args) ?? [];
+  return {
+    hunks,
+    cursor: 0,
+    selected: new Set(hunks.map((_, i) => i)),
+  };
+}
+
+/**
+ * applyHunkKey — pure reducer over raw stdin `data` for an active hunk-selection
+ * prompt. Mirrors the outer y/a/n prompt's raw-data key routing (not the
+ * normalized panel key vocabulary) since Space must be distinguishable from
+ * the trimmed/lowercased `key` the outer switch uses.
+ */
+export function applyHunkKey(state: HunkSelectionState, data: string): HunkKeyResult {
+  const lower = data.toLowerCase().trim();
+
+  if (data === 'j' || data === '\x1b[B') {
+    return { state: { ...state, cursor: Math.min(state.hunks.length - 1, state.cursor + 1) }, commit: null };
+  }
+  if (data === 'k' || data === '\x1b[A') {
+    return { state: { ...state, cursor: Math.max(0, state.cursor - 1) }, commit: null };
+  }
+  if (data === ' ') {
+    const next = new Set(state.selected);
+    if (next.has(state.cursor)) {
+      next.delete(state.cursor);
+    } else {
+      next.add(state.cursor);
+    }
+    return { state: { ...state, selected: next }, commit: null };
+  }
+  if (lower === 'a') {
+    return { state: { ...state, selected: new Set(state.hunks.map((_, i) => i)) }, commit: null };
+  }
+  if (data === '\r' || data === '\n') {
+    if (state.selected.size === 0) {
+      // No-op: nothing selected, prompt stays open rather than applying an empty edit.
+      return { state, commit: null };
+    }
+    return { state, commit: 'apply' };
+  }
+  if (lower === 'y') {
+    // Bypass-navigation shortcut: preserves muscle memory for non-hunk prompts.
+    return { state: { ...state, selected: new Set(state.hunks.map((_, i) => i)) }, commit: 'apply' };
+  }
+  if (lower === 'n' || data === '\x1b' || data === '\x03') {
+    return { state, commit: 'cancel' };
+  }
+
+  return { state, commit: null };
+}
+
+/**
+ * buildModifiedEditArgs — returns request.args with `edits` filtered to exactly
+ * the selected hunks (in original order), preserving every other EditInput
+ * field (match/transaction/output/dry_run/validate) untouched.
+ */
+export function buildModifiedEditArgs(
+  request: PermissionPromptRequest,
+  state: HunkSelectionState,
+): Record<string, unknown> {
+  const filtered = state.hunks.filter((_, i) => state.selected.has(i));
+  return { ...request.args, edits: filtered };
+}
+
+/**
+ * buildPendingPermissionExtras — the `hunkState` + wrapped `resolve` fields
+ * main.ts spreads onto its PendingPermissionState alongside `...request`.
+ * Bundled into one helper (rather than inlined in main.ts) to keep main.ts's
+ * net line count at zero for this change — main.ts sits at the 800-line
+ * architecture cap and must never grow it.
+ */
+export function buildPendingPermissionExtras(
+  request: PermissionPromptRequest,
+  resolvePromise: (decision: PermissionPromptDecisionWithModifiedArgs) => void,
+): {
+  hunkState: HunkSelectionState | undefined;
+  resolve: (approved: boolean, remember?: boolean, modifiedArgs?: Record<string, unknown>) => void;
+} {
+  return {
+    hunkState: isHunkSelectable(request) ? buildHunkSelectionState(request) : undefined,
+    resolve: (approved, remember = false, modifiedArgs) => resolvePromise({ approved, remember, modifiedArgs }),
+  };
+}

package/src/permissions/prompt.ts

@@ -2,10 +2,29 @@ import { type Line } from '../types/grid.ts';
 import { UIFactory } from '../renderer/ui-factory.ts';
 import type { PermissionCategory, PermissionRequestAnalysis } from '@pellux/goodvibes-sdk/platform/permissions';
 import { buildPermissionApprovalBrief, getDisplayArg } from '@pellux/goodvibes-sdk/platform/permissions';
+import { DIFF_TONES, UI_TONES } from '../renderer/ui-primitives.ts';
+import type { HunkSelectionState } from './hunk-selection.ts';
+export { buildPendingPermissionExtras } from './hunk-selection.ts';
 
 import type { PermissionPromptRequest, PermissionPromptDecision, PermissionRequestHandler, PermissionRequest } from '@pellux/goodvibes-sdk/platform/permissions';
 export type { PermissionPromptRequest, PermissionPromptDecision, PermissionRequestHandler, PermissionRequest };
 
+/** Visible hunk rows before a "+N more" trailer kicks in (Risk 3). */
+const MAX_VISIBLE_HUNKS = 8;
+
+/**
+ * Single source of truth for how many Line rows the hunk-list section
+ * occupies: 1 header row + up to MAX_VISIBLE_HUNKS checkbox rows + 1 trailer
+ * row (rendered as "+N more" when truncated, blank otherwise — always
+ * present so the row count never depends on which branch fires). Both
+ * getPromptHeight and createPromptLines call this SAME function, so they
+ * cannot drift apart (Risk 2 — main.ts's render loop reserves viewport
+ * space from getPromptHeight *before* the real render happens).
+ */
+function hunkListRowCount(hunkState: HunkSelectionState): number {
+  return Math.min(hunkState.hunks.length, MAX_VISIBLE_HUNKS) + 2;
+}
+
 /**
  * PermissionPromptUI - Renders a permission prompt as Line[] fragments.
  *
@@ -30,11 +49,12 @@ export class PermissionPromptUI {
     };
   }
 
-  static getPromptHeight(request: PermissionPromptRequest): number {
+  static getPromptHeight(request: PermissionPromptRequest, hunkState?: HunkSelectionState): number {
     const analysis = this.fallbackAnalysis(request);
     const reasonLines = Math.min(2, Math.max(1, analysis.reasons.length));
     const extraLines = (analysis.host ? 1 : 0) + (analysis.surface ? 1 : 0) + (analysis.sideEffects && analysis.sideEffects.length > 0 ? 1 : 0);
-    return 12 + reasonLines + extraLines;
+    const hunkLines = hunkState ? hunkListRowCount(hunkState) : 0;
+    return 12 + reasonLines + extraLines + hunkLines;
   }
 
   /** Returns the key argument to display for a given tool invocation. */
@@ -64,7 +84,7 @@ export class PermissionPromptUI {
    * createPromptLines - Renders the permission prompt as an array of Lines.
    * Injected into the viewport by the render function when a request is pending.
    */
-  static createPromptLines(width: number, request: PermissionRequest): Line[] {
+  static createPromptLines(width: number, request: PermissionRequest, hunkState?: HunkSelectionState): Line[] {
     const lines: Line[] = [];
     const { tool, args, category } = request;
     const analysis = this.fallbackAnalysis(request);
@@ -153,8 +173,44 @@ export class PermissionPromptUI {
     // Blank spacer
     lines.push(UIFactory.stringToLine(' '.repeat(width), width));
 
+    if (hunkState) {
+      // Hunk list — see hunkListRowCount() for the row-count contract this
+      // block must match exactly (Risk 2: getPromptHeight/createPromptLines
+      // parity is what keeps main.ts's render loop from clipping the
+      // viewport).
+      const { hunks, cursor, selected } = hunkState;
+      const headerLine = `   Hunks (${selected.size}/${hunks.length} selected):`;
+      lines.push(UIFactory.stringToLine(headerLine.padEnd(width), width, { fg: TEXT, bold: true }));
+
+      const visible = hunks.slice(0, MAX_VISIBLE_HUNKS);
+      const maxPreviewLen = Math.max(6, Math.floor((width - 20) / 2));
+      for (let i = 0; i < visible.length; i++) {
+        const hunk = visible[i]!;
+        const box = selected.has(i) ? '[x]' : '[ ]';
+        const findPreview = hunk.find.replace(/\n/g, '⏎').slice(0, maxPreviewLen);
+        const replacePreview = hunk.replace.replace(/\n/g, '⏎').slice(0, maxPreviewLen);
+        const rowText = `   ${box} ${i + 1}. ${hunk.path} — "${findPreview}" -> "${replacePreview}"`;
+        const isCursor = i === cursor;
+        lines.push(UIFactory.stringToLine(
+          rowText.padEnd(width),
+          width,
+          {
+            fg: selected.has(i) ? DIFF_TONES.add : DIFF_TONES.del,
+            bg: isCursor ? UI_TONES.bg.selected : undefined,
+            bold: isCursor,
+          },
+        ));
+      }
+
+      const hiddenCount = hunks.length - visible.length;
+      const trailerLine = hiddenCount > 0 ? `   +${hiddenCount} more` : '';
+      lines.push(UIFactory.stringToLine(trailerLine.padEnd(width), width, { fg: DIM }));
+    }
+
     // Choices row
-    const choicesLine = `   [Y] Allow once    [A] Allow always (session)    [N] Deny`;
+    const choicesLine = hunkState
+      ? `   [j/k] Navigate  [Space] Toggle  [A] All  [Enter] Apply selected  [N] Deny`
+      : `   [Y] Allow once    [A] Allow always (session)    [N] Deny`;
     lines.push(UIFactory.stringToLine(choicesLine.padEnd(width), width, { fg: ACCENT, bold: true }));
 
     // Bottom separator

package/src/renderer/compaction-history-modal.ts

@@ -10,11 +10,22 @@
  */
 
 import { getCompactionEvents } from '@pellux/goodvibes-sdk/platform/core';
+import { getCompactionQualityScore } from './compaction-quality.ts';
 import type { CompactionEvent } from '@pellux/goodvibes-sdk/platform/core';
+import type { CompactionQualityScore } from './compaction-quality.ts';
 
 // ─── formatCompactionEvent ────────────────────────────────────────────────────
 
-function formatCompactionEvent(ev: CompactionEvent, n: number): string {
+/**
+ * Exported for direct unit testing (W5.4/B28) — the grade suffix is a pure
+ * function of the event and an optional score, independent of whichever
+ * runtime lookup (getCompactionQualityScore) supplies that score.
+ */
+export function formatCompactionEvent(
+  ev: CompactionEvent,
+  n: number,
+  qualityScore?: CompactionQualityScore | null,
+): string {
   const date = new Date(ev.timestamp);
   const timeStr = date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
   const savings = Math.max(0, ev.tokensBeforeEstimate - ev.tokensAfterEstimate);
@@ -22,11 +33,15 @@ function formatCompactionEvent(ev: CompactionEvent, n: number): string {
     ? Math.round((savings / ev.tokensBeforeEstimate) * 100)
     : 0;
   const trigger = ev.trigger === 'auto' ? 'auto' : 'manual';
+  // Honest omission: no score means none was computed for this event (e.g. it
+  // pre-dates this feature, or ran through the small-window path, which has
+  // no CompactionEvent to key a score by) — never fabricate a grade.
+  const qualityStr = qualityScore ? `  quality=${qualityScore.grade} (${qualityScore.score.toFixed(2)})` : '';
   return (
     `#${n} ${timeStr} [${trigger}]  ` +
     `${ev.messagesBeforeCompaction}→${ev.messagesAfterCompaction} msgs  ` +
     `~${fmtN(ev.tokensBeforeEstimate)}→~${fmtN(ev.tokensAfterEstimate)} tok  ` +
-    `saved ${savingsPct}%`
+    `saved ${savingsPct}%${qualityStr}`
   );
 }
 
@@ -48,7 +63,8 @@ export function buildCompactionHistoryText(): string {
   ];
   const ordered = [...events].reverse();
   for (let i = 0; i < ordered.length; i++) {
-    lines.push('  ' + formatCompactionEvent(ordered[i], ordered.length - i));
+    const ev = ordered[i]!;
+    lines.push('  ' + formatCompactionEvent(ev, ordered.length - i, getCompactionQualityScore(ev.timestamp)));
   }
   lines.push('  (Restore not available — the SDK does not yet expose a snapshot restore API.)');
   return lines.join('\n');

package/src/renderer/compaction-preview.ts

@@ -18,8 +18,10 @@
 
 import { estimateConversationTokens } from '@pellux/goodvibes-sdk/platform/core';
 import { computeContextUsage } from '../core/context-usage.ts';
+import { formatQualityScoreLine } from './compaction-quality.ts';
 import type { CompactionEvent } from '@pellux/goodvibes-sdk/platform/core';
 import type { ProviderMessage } from '@pellux/goodvibes-sdk/platform/providers';
+import type { CompactionQualityScore } from './compaction-quality.ts';
 
 /**
  * Default compaction totalCeiling from context-compaction DEFAULT_COMPACTION_CONFIG.
@@ -44,6 +46,12 @@ export interface CompactionAfterOptions {
   readonly event: CompactionEvent;
   /** Number of session memories that survived compaction. */
   readonly pinnedMemoryCount: number;
+  /**
+   * Out-of-band quality-score grade for this run (W5.4/B28). Omitted or null
+   * when no score was computed (e.g. the small-window compaction path, which
+   * has no CompactionEvent to key a score by) — no line is rendered then.
+   */
+  readonly qualityScore?: CompactionQualityScore | null | undefined;
 }
 
 /**
@@ -82,7 +90,7 @@ export function buildCompactionPreview(opts: CompactionPreviewOptions): string {
  * after token counts. The trigger field controls wording.
  */
 export function buildCompactionAfterNotice(opts: CompactionAfterOptions): string {
-  const { event, pinnedMemoryCount } = opts;
+  const { event, pinnedMemoryCount, qualityScore } = opts;
   const {
     messagesBeforeCompaction,
     messagesAfterCompaction,
@@ -102,11 +110,14 @@ export function buildCompactionAfterNotice(opts: CompactionAfterOptions): string
 
   const triggerStr = trigger === 'auto' ? 'Auto-compact complete' : 'Compact complete';
 
+  const qualityStr = qualityScore ? `\n  ${formatQualityScoreLine(qualityScore)}` : '';
+
   return (
     `[Context] ${triggerStr}: ${messagesBeforeCompaction} → ${messagesAfterCompaction} messages,` +
     ` ~${fmtN(tokensBeforeEstimate)} → ~${fmtN(tokensAfterEstimate)} tokens` +
     ` (saved ~${fmtN(savings)}, ${savingsPct}%).` +
-    (pinStr ? ` ${pinStr.trim()}` : '')
+    (pinStr ? ` ${pinStr.trim()}` : '') +
+    qualityStr
   );
 }