@pellux/goodvibes-tui 0.22.0 → 0.24.0

package/src/main.ts

@@ -40,6 +40,7 @@ import {
   writeRecoveryFile,
 } from '@/runtime/index.ts';
 import { handleBlockingShellInput, type PendingPermissionState } from './shell/blocking-input.ts';
+import { createPersistRecoverySnapshot, createReopenRecoveryPanels, handleErrorAffordanceKey } from './shell/recovery-input-helpers.ts';
 import { wireShellUiOpeners } from './shell/ui-openers.ts';
 import { deriveComposerState } from './core/composer-state.ts';
 import { buildPersistedSessionContext, formatReturnContextForDisplay, getReturnContextMode, maybeAssistReturnContextSummary } from '@/runtime/index.ts';
@@ -54,22 +55,16 @@ import { allowTerminalWrite, installTuiTerminalOutputGuard } from './runtime/ter
 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';
+import { wireStreamEventMetrics, type StreamMetrics, type WireStreamEventMetricsResult } from './core/stream-event-wiring.ts';
 import { wireTurnEventHandlers } from './core/turn-event-wiring.ts';
 import { buildContextStatusHint } from './renderer/context-status-hint.ts';
 import { evaluateSessionMaintenance } from './panels/session-maintenance.ts';
 
-const ALT_SCREEN_ENTER = '\x1b[?1049h';
-const ALT_SCREEN_EXIT  = '\x1b[?1049l';
-const MOUSE_ENABLE     = '\x1b[?1000h\x1b[?1002h\x1b[?1006h';
-const MOUSE_DISABLE    = '\x1b[?1006l\x1b[?1002l\x1b[?1000l';
-const CURSOR_HIDE      = '\x1b[?25l';
-const CURSOR_SHOW      = '\x1b[?25h';
-const CLEAR_SCREEN     = '\x1b[2J\x1b[3J\x1b[H';
-const KEYBOARD_EXT_ENABLE  = '\x1b[>4;2m' + '\x1b[?1u';
-const KEYBOARD_EXT_DISABLE = '\x1b[>4;0m' + '\x1b[?1l';
-const PASTE_ENABLE     = '\x1b[?2004h';
-const PASTE_DISABLE    = '\x1b[?2004l';
+const ALT_SCREEN_ENTER = '\x1b[?1049h'; const ALT_SCREEN_EXIT  = '\x1b[?1049l';
+const MOUSE_ENABLE     = '\x1b[?1000h\x1b[?1002h\x1b[?1006h'; const MOUSE_DISABLE    = '\x1b[?1006l\x1b[?1002l\x1b[?1000l';
+const CURSOR_HIDE      = '\x1b[?25l'; const CURSOR_SHOW = '\x1b[?25h'; const CLEAR_SCREEN = '\x1b[2J\x1b[3J\x1b[H';
+const KEYBOARD_EXT_ENABLE  = '\x1b[>4;2m' + '\x1b[?1u'; const KEYBOARD_EXT_DISABLE = '\x1b[>4;0m' + '\x1b[?1l';
+const PASTE_ENABLE = '\x1b[?2004h'; const PASTE_DISABLE = '\x1b[?2004l';
 
 async function main() {
   const stdout = process.stdout;
@@ -315,10 +310,11 @@ async function main() {
     }
     if (processedText || content) {
       void (async () => {
-        let inputOptions = options.spokenOutput ? createSpokenTurnInputOptions() : undefined;
-        if (options.spokenOutput && processedText) {
-          spokenTurns.submitNextTurn(processedText);
-        }
+        const inputOptions = options.spokenOutput ? createSpokenTurnInputOptions() : undefined;
+        if (options.spokenOutput && processedText) { spokenTurns.submitNextTurn(processedText); }
+        // Snapshot pre-submission state for failover retryTurn; also clears visited set.
+        retryCtx = { count: conversation.getMessageCount(), text: processedText, content, opts: inputOptions };
+        streamResult.clearFailoverVisited();
         orchestrator.handleUserInput(processedText, content, inputOptions).catch((err: unknown) => {
           logger.debug('handleUserInput safety catch (already handled by runTurn)', { error: summarizeError(err) });
         });
@@ -689,7 +685,6 @@ async function main() {
     render,
   });
 
-  // --- Turn-completed / git-refresh event wiring ---
   const { refreshGit, unsubs: turnUnsubs } = wireTurnEventHandlers({
     events: uiServices.events,
     conversation,
@@ -705,20 +700,37 @@ async function main() {
     gitStatusProvider,
     lastGitInfoRef,
     buildSessionContinuityHints,
-    render,
+    render, webhookNotifier: ctx.services.webhookNotifier,
   });
   unsubs.push(...turnUnsubs);
 
-  // --- Stream metrics + tool-timer event wiring ---
-  const streamUnsubs = wireStreamEventMetrics({
-    events: uiServices.events,
-    orchestrator,
-    providerRegistry,
-    systemMessageRouter,
-    render,
-    metrics: streamMetrics,
+  // Stable turn context for failover retry — set in submitInput, read by retryTurn.
+  let retryCtx: { count: number; text: string; content?: ContentPart[]; opts?: Parameters<typeof orchestrator.handleUserInput>[2] } | null = null;
+  // One-key retry affordance: active immediately after a user-visible TURN_ERROR.
+  // While active, 'r' re-submits on the current provider, 'm' opens the model
+  // picker. Any other character clears the affordance and routes normally.
+  let errorAffordanceActive = false;
+  const retryTurn = (): void => {
+    if (!retryCtx) return;
+    const { count, text, content: rContent, opts: rOpts } = retryCtx;
+    // Roll back to pre-submission count, then re-submit. SDK gap — no retry-in-place (see handoff).
+    conversation.removeMessagesAfter(count);
+    orchestrator.handleUserInput(text, rContent, rOpts).catch((e: unknown) => logger.debug('retryTurn', { error: summarizeError(e) }));
+  };
+  const streamResult: WireStreamEventMetricsResult = wireStreamEventMetrics({
+    events: uiServices.events, orchestrator, providerRegistry,
+    systemMessageRouter, render, metrics: streamMetrics,
+    providerOptimizer: ctx.services.providerOptimizer, costLookup: providerRegistry, retryTurn,
+  });
+  unsubs.push(...streamResult.unsubs);
+  // Activate one-key retry affordance when a user-visible error surfaces.
+  streamResult.onErrorSurfaced((exhausted) => {
+    if (retryCtx) {
+      errorAffordanceActive = true;
+      systemMessageRouter.low(exhausted ? '[Retry] r retry same provider · m switch model' : '[Retry] r retry · m switch model');
+      render();
+    }
   });
-  unsubs.push(...streamUnsubs);
 
   // --- Terminal setup ---
   stdin.setRawMode(true);
@@ -726,35 +738,17 @@ async function main() {
   stdin.setEncoding('utf8');
   allowTerminalWrite(() => stdout.write((cli.flags.noAltScreen ? '' : ALT_SCREEN_ENTER) + CLEAR_SCREEN + CURSOR_HIDE + MOUSE_ENABLE + KEYBOARD_EXT_ENABLE + PASTE_ENABLE));
 
-  applyInitialTuiCliState({
-    cli,
-    input,
-    commandRegistry,
-    commandContext,
-    shellPaths: ctx.services.shellPaths,
-    render,
-  });
+  applyInitialTuiCliState({ cli, input, commandRegistry, commandContext, shellPaths: ctx.services.shellPaths, render });
 
   stdin.on('data', (data: string) => {
     const blocking = handleBlockingShellInput({
-      data,
-      pendingPermission,
-      recoveryPending,
+      data, pendingPermission, recoveryPending, conversation, systemMessageRouter, render,
       abortTurn: () => orchestrator.abort(),
-      conversation,
-      systemMessageRouter,
-      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();
-      },
+      homeDirectory, sessionId: runtime.sessionId,
+      persistSnapshot: createPersistRecoverySnapshot({ sessionManager: ctx.services.sessionManager, runtime, conversation }),
+      reopenPanels: createReopenRecoveryPanels({ panelManager, render }),
     });
     pendingPermission = blocking.pendingPermission;
     recoveryPending = blocking.recoveryPending;
@@ -762,6 +756,12 @@ async function main() {
       return;
     }
 
+    // One-key retry affordance: armed after a user-visible TURN_ERROR; any key other than r/m dismisses it and routes normally.
+    if (errorAffordanceActive) {
+      errorAffordanceActive = false;
+      if (handleErrorAffordanceKey(data, { retryArmed: retryCtx !== null, retry: retryTurn, openModelPicker: () => commandContext.openModelPicker?.(), render })) return;
+    }
+
     input.feed(data);
   });
   process.on('SIGINT', sigintHandler);

package/src/panels/base-panel.ts

@@ -4,6 +4,7 @@ import type { ComponentResourceContract, ComponentHealthState } from '../runtime
 import type { ComponentHealthMonitor } from '../runtime/perf/panel-health-monitor.ts';
 import { UIFactory } from '../renderer/ui-factory.ts';
 import { SPINNER_FRAMES } from '../renderer/progress.ts';
+import { fitDisplay } from '../utils/terminal-width.ts';
 
 export abstract class BasePanel implements Panel {
   public needsRender = true;
@@ -143,7 +144,7 @@ export abstract class BasePanel implements Panel {
     if (this.loadingState !== 'loading') return null;
     const spinner = SPINNER_FRAMES[frame % SPINNER_FRAMES.length] ?? SPINNER_FRAMES[0]!;
     const text = ` ${spinner} ${this._loadingLabel}`;
-    return UIFactory.stringToLine(text.padEnd(width).slice(0, width), width, { fg: '135', bold: true });
+    return UIFactory.stringToLine(fitDisplay(text, width), width, { fg: '135', bold: true });
   }
 
   /**

package/src/panels/provider-health-domains.ts

@@ -73,7 +73,7 @@ export function buildProviderHealthDomainSummaries(
       : settingIssueCount > 0
         ? `${settings.conflictCount} conflicts / ${settings.recentFailureCount} failures${settings.hasStagedManagedBundle ? ' / staged bundle' : ''}`
         : 'settings control plane clean',
-    next: settingIssueCount > 0 ? '/settingssync panel' : '/settingssync show <key>',
+    next: settingIssueCount > 0 ? '/settings-sync panel' : '/settings-sync show <key>',
     details: [
       settings.conflictCount > 0 ? `${settings.conflictCount} unresolved import conflict(s)` : '',
       settings.recentFailureCount > 0 ? `${settings.recentFailureCount} recent sync or managed failure(s)` : '',
@@ -81,8 +81,8 @@ export function buildProviderHealthDomainSummaries(
       settings.managedLockCount > 0 ? `${settings.managedLockCount} managed lock(s) enforced` : '',
     ].filter(Boolean),
     nextSteps: settingIssueCount > 0
-      ? ['/settingssync panel', '/settingssync show <key>', '/managed staged']
-      : ['/settingssync show <key>'],
+      ? ['/settings-sync panel', '/settings-sync show <key>', '/managed staged']
+      : ['/settings-sync show <key>'],
   });
 
   summaries.push({

package/src/panels/provider-health-panel.ts

@@ -88,18 +88,22 @@ const LATENCY_BAD_MS  = 5_000;
 
 function statusDot(status: ProviderStatus): { char: string; color: string } {
   switch (status) {
-    case 'online':       return { char: '●', color: C.online };
-    case 'rate-limited': return { char: '◐', color: C.rateLimit };
-    case 'error':        return { char: '✕', color: C.error };
+    case 'healthy':      return { char: '●', color: C.online };
+    case 'degraded':     return { char: '◑', color: C.rateLimit };
+    case 'rate_limited': return { char: '◐', color: C.rateLimit };
+    case 'auth_error':   return { char: '✕', color: C.error };
+    case 'unavailable':  return { char: '✕', color: C.error };
     default:             return { char: '○', color: C.unknown };
   }
 }
 
 function statusLabel(status: ProviderStatus): string {
   switch (status) {
-    case 'online':       return 'online';
-    case 'rate-limited': return 'rate-limited';
-    case 'error':        return 'error';
+    case 'healthy':      return 'online';
+    case 'degraded':     return 'degraded';
+    case 'rate_limited': return 'rate-limited';
+    case 'auth_error':   return 'auth error';
+    case 'unavailable':  return 'unavailable';
     default:             return 'unknown';
   }
 }
@@ -562,9 +566,9 @@ export class ProviderHealthPanel extends BasePanel {
     let expiringAuth = 0;
     for (const name of providers) {
       const status = this.providerHealthTracker.get(name)?.status ?? 'unknown';
-      if (status === 'online') online++;
-      else if (status === 'rate-limited') rateLimited++;
-      else if (status === 'error') errored++;
+      if (status === 'healthy') online++;
+      else if (status === 'rate_limited') rateLimited++;
+      else if (status === 'degraded' || status === 'auth_error' || status === 'unavailable') errored++;
       const account = this._accountRecords.get(name);
       if (account) {
         accountIssues += account.issues.length;

package/src/panels/provider-health-tracker.ts

@@ -1,4 +1,7 @@
-export type ProviderStatus = 'online' | 'rate-limited' | 'error' | 'unknown';
+// ProviderStatus is the shared SDK type — imported from the runtime barrel
+// to eliminate the duplicate local definition that diverged from the SDK shape.
+import type { ProviderStatus } from '@/runtime/index.ts';
+export type { ProviderStatus };
 
 export interface ProviderHealth {
   name: string;
@@ -81,7 +84,7 @@ export class ProviderHealthTracker {
 
   private recordSuccess(name: string, latencyMs?: number): void {
     const record = this.ensureRecord(name);
-    record.status = 'online';
+    record.status = 'healthy';
     record.lastSuccessAt = Date.now();
     record.lastErrorMessage = undefined;
     if (latencyMs !== undefined) {
@@ -97,11 +100,11 @@ export class ProviderHealthTracker {
     record.lastErrorAt = Date.now();
     record.lastErrorMessage = message.slice(0, 120);
     if (isRateLimit) {
-      record.status = 'rate-limited';
+      record.status = 'rate_limited';
       record.rateLimitExpiresAt = Date.now() + ProviderHealthTracker.DEFAULT_COOLDOWN_MS;
       return;
     }
-    record.status = 'error';
+    record.status = 'degraded';
   }
 
   private isRateLimitMessage(message: string): boolean {

package/src/panels/settings-sync-panel.ts

@@ -56,7 +56,7 @@ export class SettingsSyncPanel extends ScrollableListPanel<ResolvedEntry> {
     const postureLines: Line[] = [
       buildPanelLine(width, [[' resolved keys ', C.label], [String(snapshot.resolvedEntries.length), C.value], ['  conflicts ', C.label], ...buildStatusPill(snapshot.conflicts.length > 0 ? 'bad' : 'good', String(snapshot.conflicts.length)), ['  failures ', C.label], ...buildStatusPill(snapshot.recentFailures.length > 0 ? 'warn' : 'good', String(snapshot.recentFailures.length))]),
       buildPanelLine(width, [[' managed locks ', C.label], [String(snapshot.managedLockCount), snapshot.managedLockCount > 0 ? C.warn : C.dim], ['  staged bundle ', C.label], [snapshot.stagedManagedBundle ? snapshot.stagedManagedBundle.profileName : 'none', snapshot.stagedManagedBundle ? C.info : C.dim]]),
-      buildGuidanceLine(width, '/settingssync conflicts', 'review conflicting synced values before they silently shape effective configuration', C),
+      buildGuidanceLine(width, '/settings-sync conflicts', 'review conflicting synced values before they silently shape effective configuration', C),
       buildGuidanceLine(width, '/managed review', 'inspect staged managed changes, risk posture, and rollback records', C),
     ];
 
@@ -86,7 +86,7 @@ export class SettingsSyncPanel extends ScrollableListPanel<ResolvedEntry> {
         : [buildPanelLine(width, [[' No recent sync or managed-setting failures.', C.dim]])]),
       // Conflicts
       ...(snapshot.conflicts.length > 0
-        ? snapshot.conflicts.map((conflict) => buildPanelLine(width, [[` ${conflict.key}`.padEnd(30), C.value], [` ${conflict.source}`.padEnd(10), C.warn], [` resolve: /settingssync resolve ${conflict.key} local|synced`.slice(0, Math.max(0, width - 42)), C.dim]]))
+        ? snapshot.conflicts.map((conflict) => buildPanelLine(width, [[` ${conflict.key}`.padEnd(30), C.value], [` ${conflict.source}`.padEnd(10), C.warn], [` resolve: /settings-sync resolve ${conflict.key} local|synced`.slice(0, Math.max(0, width - 42)), C.dim]]))
         : [buildPanelLine(width, [[' No settings conflicts detected.', C.dim]])]),
       // Rollback History
       ...(snapshot.rollbackHistory.length > 0
@@ -108,7 +108,7 @@ export class SettingsSyncPanel extends ScrollableListPanel<ResolvedEntry> {
             buildPanelLine(width, [[' managed ', C.label], [String(selectedEntry.managedValue ?? '(unset)').slice(0, Math.max(0, width - 11)), C.warn]]),
           ], C)
         : []),
-      buildPanelLine(width, [[' ↑/↓ browse  /settingssync show <key>  /settingssync resolve <key> <local|synced>  /managed apply-staged [key...] ', C.dim]]),
+      buildPanelLine(width, [[' ↑/↓ browse  /settings-sync show <key>  /settings-sync resolve <key> <local|synced>  /managed apply-staged [key...] ', C.dim]]),
     ];
 
     return this.renderList(width, height, {

package/src/panels/work-plan-panel.ts

@@ -109,8 +109,8 @@ export class WorkPlanPanel extends ScrollableListPanel<WorkPlanItem> {
 
   protected getEmptyStateActions(): Array<{ command: string; summary: string }> {
     return [
-      { command: '/workplan add <title>', summary: 'add a persistent item' },
-      { command: '/workplan list', summary: 'print the current plan' },
+      { command: '/work-plan add <title>', summary: 'add a persistent item' },
+      { command: '/work-plan list', summary: 'print the current plan' },
     ];
   }
 

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

@@ -0,0 +1,55 @@
+/**
+ * Compaction history text builder.
+ *
+ * Renders a read-only list of past compaction events sourced from the SDK's
+ * module-level compaction event log (`getCompactionEvents()`).
+ *
+ * The SDK records CompactionEvent data (timestamps, token counts,
+ * trigger, message counts) but does not expose a snapshot restore API.
+ * Restore is list-only; users can view what compactions ran but cannot roll back.
+ */
+
+import { getCompactionEvents } from '@pellux/goodvibes-sdk/platform/core';
+import type { CompactionEvent } from '@pellux/goodvibes-sdk/platform/core';
+
+// ─── formatCompactionEvent ────────────────────────────────────────────────────
+
+function formatCompactionEvent(ev: CompactionEvent, n: number): 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);
+  const savingsPct = ev.tokensBeforeEstimate > 0
+    ? Math.round((savings / ev.tokensBeforeEstimate) * 100)
+    : 0;
+  const trigger = ev.trigger === 'auto' ? 'auto' : 'manual';
+  return (
+    `#${n} ${timeStr} [${trigger}]  ` +
+    `${ev.messagesBeforeCompaction}→${ev.messagesAfterCompaction} msgs  ` +
+    `~${fmtN(ev.tokensBeforeEstimate)}→~${fmtN(ev.tokensAfterEstimate)} tok  ` +
+    `saved ${savingsPct}%`
+  );
+}
+
+function fmtN(n: number): string {
+  return n.toLocaleString();
+}
+
+/**
+ * Build a plain-text compaction history summary suitable for ctx.print().
+ * Useful as the output of /compact-history when not in overlay mode.
+ */
+export function buildCompactionHistoryText(): string {
+  const events = getCompactionEvents();
+  if (events.length === 0) {
+    return '[Context] No compactions recorded this session. (Restore is not available — the SDK does not yet expose a snapshot restore API.)';
+  }
+  const lines: string[] = [
+    `[Context] Compaction history (${events.length} total, most recent first):`,
+  ];
+  const ordered = [...events].reverse();
+  for (let i = 0; i < ordered.length; i++) {
+    lines.push('  ' + formatCompactionEvent(ordered[i], ordered.length - i));
+  }
+  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

@@ -0,0 +1,146 @@
+/**
+ * Compaction preview and after-notice builders.
+ *
+ * Pre-compact: shows an honest estimate of what compaction will do
+ * (message count and token estimate before → after). The SDK has no dry-run
+ * API; we derive the after-estimate from the DEFAULT_COMPACTION_CONFIG
+ * totalCeiling (6500 tokens) — clearly labelled as an ESTIMATE.
+ *
+ * Post-compact: shows a before/after notice using the CompactionEvent
+ * data returned by compactMessages(), which contains the real
+ * tokensBeforeEstimate and tokensAfterEstimate figures.
+ *
+ * Honest wording policy:
+ *  - Pre-compact notice says "estimate" every time; never claims certainty.
+ *  - Post-compact notice uses "~N" prefix on every token figure.
+ *  - Pinned session memories that survive are mentioned by count.
+ */
+
+import { estimateConversationTokens } from '@pellux/goodvibes-sdk/platform/core';
+import type { CompactionEvent } from '@pellux/goodvibes-sdk/platform/core';
+import type { ProviderMessage } from '@pellux/goodvibes-sdk/platform/providers';
+
+/**
+ * Default compaction totalCeiling from context-compaction DEFAULT_COMPACTION_CONFIG.
+ * Kept local so we don't take a runtime dependency on the internal config object.
+ * Used only for the pre-compact ESTIMATE; the real figure comes from CompactionEvent.
+ */
+const COMPACTION_OUTPUT_CEILING_ESTIMATE = 6500;
+
+export interface CompactionPreviewOptions {
+  /** Messages currently in the conversation. */
+  readonly messages: readonly ProviderMessage[];
+  /** Context window size for the current model (0 if unknown). */
+  readonly contextWindow: number;
+  /** Number of session memories that will survive compaction. */
+  readonly pinnedMemoryCount: number;
+  /** Whether this is triggered automatically or manually. */
+  readonly trigger: 'auto' | 'manual';
+}
+
+export interface CompactionAfterOptions {
+  /** The CompactionEvent returned by the SDK after compaction completes. */
+  readonly event: CompactionEvent;
+  /** Number of session memories that survived compaction. */
+  readonly pinnedMemoryCount: number;
+}
+
+/**
+ * Build the pre-compaction notice string.
+ *
+ * Returned as a plain string intended for `ctx.print()` or `systemMessageRouter`.
+ * Always labelled as an estimate; uses the SDK totalCeiling as the after-estimate.
+ */
+export function buildCompactionPreview(opts: CompactionPreviewOptions): string {
+  const { messages, contextWindow, pinnedMemoryCount, trigger } = opts;
+  const msgCount = messages.length;
+  const tokensBefore = estimateConversationTokens(messages as ProviderMessage[]);
+  const tokensAfterEstimate = COMPACTION_OUTPUT_CEILING_ESTIMATE;
+
+  const contextStr = contextWindow > 0
+    ? ` (${Math.round((tokensBefore / contextWindow) * 100)}% of ${fmtN(contextWindow)} context window)`
+    : '';
+
+  const pinStr = pinnedMemoryCount > 0
+    ? ` ${pinnedMemoryCount} pinned session memor${pinnedMemoryCount === 1 ? 'y' : 'ies'} will be preserved.`
+    : '';
+
+  const triggerStr = trigger === 'auto' ? 'Auto-compacting' : 'Compacting';
+
+  return (
+    `[Context] ${triggerStr} conversation: ~${fmtN(tokensBefore)} tokens across ${msgCount} message${msgCount === 1 ? '' : 's'}${contextStr}.` +
+    ` Estimated result: ~${fmtN(tokensAfterEstimate)} tokens (estimate — actual depends on content).` +
+    (pinStr ? ` ${pinStr.trim()}` : '')
+  );
+}
+
+/**
+ * Build the post-compaction before/after notice string.
+ *
+ * Uses the real CompactionEvent figures (not estimates) for both before and
+ * after token counts. The trigger field controls wording.
+ */
+export function buildCompactionAfterNotice(opts: CompactionAfterOptions): string {
+  const { event, pinnedMemoryCount } = opts;
+  const {
+    messagesBeforeCompaction,
+    messagesAfterCompaction,
+    tokensBeforeEstimate,
+    tokensAfterEstimate,
+    trigger,
+  } = event;
+
+  const savings = Math.max(0, tokensBeforeEstimate - tokensAfterEstimate);
+  const savingsPct = tokensBeforeEstimate > 0
+    ? Math.round((savings / tokensBeforeEstimate) * 100)
+    : 0;
+
+  const pinStr = pinnedMemoryCount > 0
+    ? ` ${pinnedMemoryCount} pinned memor${pinnedMemoryCount === 1 ? 'y' : 'ies'} preserved.`
+    : '';
+
+  const triggerStr = trigger === 'auto' ? 'Auto-compact complete' : 'Compact complete';
+
+  return (
+    `[Context] ${triggerStr}: ${messagesBeforeCompaction} → ${messagesAfterCompaction} messages,` +
+    ` ~${fmtN(tokensBeforeEstimate)} → ~${fmtN(tokensAfterEstimate)} tokens` +
+    ` (saved ~${fmtN(savings)}, ${savingsPct}%).` +
+    (pinStr ? ` ${pinStr.trim()}` : '')
+  );
+}
+
+/** Format a number with thousands separators. */
+function fmtN(n: number): string {
+  return n.toLocaleString();
+}
+
+/**
+ * Build the /keep command usage text (shown when no args are provided).
+ *
+ * Exported for testability — the shell-core handler renders this string directly.
+ */
+export function buildPinUsageText(): string {
+  return (
+    '[Pin] Usage: /keep <text>\n' +
+    'Pinned entries are stored as session memories and included in the compaction handoff as pinned memories.\n' +
+    'What pinning guarantees: the text survives the next compaction.\n' +
+    'What pinning does NOT guarantee: recovery after process restart (session memories are in-memory only).'
+  );
+}
+
+/**
+ * Build the /keep command success text.
+ *
+ * @param id - The assigned memory ID (e.g. "mem-1")
+ * @param text - The pinned text
+ * @param count - Total pinned memory count after adding
+ *
+ * Exported for testability — the shell-core handler renders this string directly.
+ */
+export function buildPinSuccessText(id: string, text: string, count: number): string {
+  return (
+    `[Pin] Pinned as ${id}: "${text.slice(0, 60)}${text.length > 60 ? '...' : ''}"\n` +
+    `  ${count} pinned memor${count === 1 ? 'y' : 'ies'} will survive the next compaction.\n` +
+    '  Note: session memories are in-memory only and do not persist across restarts.'
+  );
+}

package/src/renderer/diff-view.ts

@@ -1,6 +1,6 @@
 import { type Line, type Cell, createStyledCell } from '../types/grid.ts';
 import { UIFactory } from './ui-factory.ts';
-import { getDisplayWidth } from '../utils/terminal-width.ts';
+import { getDisplayWidth, padDisplayEnd } from '../utils/terminal-width.ts';
 
 /**
  * renderDiffView - Render a unified diff string as styled Line[].
@@ -13,7 +13,7 @@ export function renderDiffView(diffText: string, width: number, filename?: strin
   // Filename header
   if (filename) {
     const header = ` ≡ ${filename} `;
-    lines.push(UIFactory.stringToLine(header.padEnd(width), width, { fg: '#1a1a1a', bg: '#569cd6', bold: true }));
+    lines.push(UIFactory.stringToLine(padDisplayEnd(header, width), width, { fg: '#1a1a1a', bg: '#569cd6', bold: true }));
   }
 
   const diffLines = diffText.split('\n');

package/src/renderer/help-overlay.ts

@@ -202,6 +202,7 @@ export function renderShortcutsOverlay(
     row('PageUp / PageDn', 'Scroll by full page'),
     row('Home / End', 'Jump to start / end of line'),
     row(kb('search'), 'Search conversation'),
+    row('n / N (search)', 'Next / previous match'),
     row('Mouse wheel', 'Scroll conversation or hovered panel'),
     '',
     '  Editing',

package/src/renderer/model-picker-overlay.ts

@@ -234,17 +234,29 @@ export function renderModelPickerOverlay(
       putRowText(providerLine, layout.margin + 2, contentW, fitDisplay(`Provider: ${selected.provider}`, contentW), '244');
       lines.push(providerLine);
 
-      const caps = selected.capabilities ?? { reasoning: false, multimodal: false, toolCalling: false, codeEditing: false };
-      const ctxStr = `Context: ${fmtContext(selected.contextWindow)}`;
-      const capParts: string[] = [ctxStr];
-      if (caps.reasoning)  capParts.push('Reasoning: \u2713');
-      if (caps.multimodal) capParts.push('Vision: \u2713');
-      if (caps.toolCalling) capParts.push('Tools: \u2713');
-      if (caps.codeEditing) capParts.push('Code: \u2713');
-      const capText = capParts.join('  ');
-      const capLine = createOverlayContentLine(width, layout, borderFg, DEFAULT_OVERLAY_PALETTE.bodyBg);
-      putRowText(capLine, layout.margin + 2, contentW, fitDisplay(truncateDisplay(capText, contentW), contentW), '244');
-      lines.push(capLine);
+      // Synthetic models show fallback ladder rungs instead of capabilities.
+      const syntheticChain = selected.provider === 'synthetic' ? picker.getSyntheticChain(selected.id) : null;
+      if (syntheticChain !== null && syntheticChain.length > 0) {
+        const rung0 = syntheticChain[0];
+        const rest = syntheticChain.length - 1;
+        const rung0Base = `  0. ${rung0.provider}/${rung0.model}`;
+        const rung0Label = rest > 0 ? `${rung0Base}  (+${rest} more)` : rung0Base;
+        const chainLine0 = createOverlayContentLine(width, layout, borderFg, DEFAULT_OVERLAY_PALETTE.bodyBg);
+        putRowText(chainLine0, layout.margin + 2, contentW, fitDisplay(truncateDisplay(rung0Label, contentW), contentW), '244');
+        lines.push(chainLine0);
+      } else {
+        const caps = selected.capabilities ?? { reasoning: false, multimodal: false, toolCalling: false, codeEditing: false };
+        const ctxStr = `Context: ${fmtContext(selected.contextWindow)}`;
+        const capParts: string[] = [ctxStr];
+        if (caps.reasoning)  capParts.push('Reasoning: \u2713');
+        if (caps.multimodal) capParts.push('Vision: \u2713');
+        if (caps.toolCalling) capParts.push('Tools: \u2713');
+        if (caps.codeEditing) capParts.push('Code: \u2713');
+        const capText = capParts.join('  ');
+        const capLine = createOverlayContentLine(width, layout, borderFg, DEFAULT_OVERLAY_PALETTE.bodyBg);
+        putRowText(capLine, layout.margin + 2, contentW, fitDisplay(truncateDisplay(capText, contentW), contentW), '244');
+        lines.push(capLine);
+      }
     } else {
       lines.push(createOverlayContentLine(width, layout, borderFg, DEFAULT_OVERLAY_PALETTE.bodyBg));
       lines.push(createOverlayContentLine(width, layout, borderFg, DEFAULT_OVERLAY_PALETTE.bodyBg));

package/src/renderer/progress.ts

@@ -1,6 +1,6 @@
 import { type Line } from '../types/grid.ts';
 import { UIFactory } from './ui-factory.ts';
-import { getDisplayWidth } from '../utils/terminal-width.ts';
+import { getDisplayWidth, padDisplayEnd } from '../utils/terminal-width.ts';
 
 // Rich spinner frames (used by progress indicators)
 export const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
@@ -17,7 +17,7 @@ export function renderSpinner(
   fg: string = '135'
 ): Line {
   const text = ` ${frame} ${label}`;
-  return UIFactory.stringToLine(text.padEnd(width), width, { fg, bold: true });
+  return UIFactory.stringToLine(padDisplayEnd(text, width), width, { fg, bold: true });
 }
 
 /**
@@ -33,7 +33,7 @@ export function renderToolProgress(
   const counter = `[${current}/${total}]`;
   const text = ` ${counter} ${label}`;
   return [
-    UIFactory.stringToLine(text.padEnd(width), width, { fg: '#ffcc00', bold: true }),
+    UIFactory.stringToLine(padDisplayEnd(text, width), width, { fg: '#ffcc00', bold: true }),
   ];
 }
 

package/src/renderer/search-overlay.ts

@@ -5,16 +5,19 @@ import { createBottomBarLine, writeBottomBarText } from './bottom-bar.ts';
 
 /**
  * Render the search bar as a single Line[] overlay at the bottom of the viewport.
- * Format: [ Find: <query>   3/17 up/down  [n] next [N] prev [Esc] close ]
+ * Format: [ Find: <query>   3/17  [n/N] next/prev  [Esc] close ]
  * The match count is dim grey; the rest of the bar is teal.
+ *
+ * Case-insensitive search (query lowercased before matching rendered cell text).
  */
 export function renderSearchOverlay(
   manager: SearchManager,
   width: number
 ): Line[] {
-  // Match count text — displayed in dim grey, right of query, left of hints
-  const matchCount = manager.matches?.length > 0
-    ? `${manager.currentMatch + 1}/${manager.matches.length} up/down`
+  // Match count / status text — displayed in dim grey, right of query
+  const hasMatches = manager.matches.length > 0;
+  const matchCount = hasMatches
+    ? `${manager.currentMatch + 1}/${manager.matches.length}${manager.wrapAround ? ' (wrap)' : ''}`
     : manager.query.length > 0
       ? 'No matches'
       : '';
@@ -23,7 +26,7 @@ export function renderSearchOverlay(
   const cursor = locked ? '' : '█';
   const queryDisplay = manager.query + cursor;
   const hints = locked
-    ? '  [Up/Down] or [jk] navigate  [Bksp] edit  [Esc] close'
+    ? '  [n/N] next/prev  [jk] navigate  [Bksp] edit  [Esc] close'
     : '  [Enter/Tab] lock  [Esc] close';
   const label = ' Find: ';
   const matchStr = matchCount ? ` ${matchCount}` : '';