@pellux/goodvibes-tui 0.23.0 → 0.24.0

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}` : '';

package/src/renderer/settings-modal.ts

@@ -150,7 +150,7 @@ function buildSettingContext(modal: SettingsModal, entry: SettingEntry): string[
   ];
 
   if (entry.locked) lines.push(`Locked: ${entry.lockReason ?? 'This setting is locked by a higher-priority layer.'}`);
-  if (entry.conflict) lines.push(`Conflict: resolve with /settingssync resolve ${entry.setting.key} local|synced.`);
+  if (entry.conflict) lines.push(`Conflict: resolve with /settings-sync resolve ${entry.setting.key} local|synced.`);
 
   lines.push('', entry.setting.description);
 

package/src/renderer/ui-factory.ts

@@ -243,6 +243,17 @@ export class UIFactory {
     });
     const bottomLine = createBaseLine();
     for (let x = 0; x < boxWidth; x++) bottomLine[boxStartX + x] = { char: GLYPHS.surface.bottom, fg: BORDER_COLOR, bg: '', bold: false, dim: false, underline: false, italic: false, strikethrough: false };
+    // Multi-line indicator lives inside the bottom border (right-aligned) so
+    // the footer height stays invariant while the user adds prompt lines.
+    if (promptLines.length > 1) {
+      const lineCountTag = ` ${promptLines.length}L `;
+      let tx = boxStartX + boxWidth - lineCountTag.length - 2;
+      for (const ch of lineCountTag) {
+        if (tx >= boxStartX + boxWidth - 1) break;
+        bottomLine[tx] = { char: ch, fg: '244', bg: '', bold: false, dim: true, underline: false, italic: false, strikethrough: false };
+        tx += 1;
+      }
+    }
     lines.push(bottomLine);
     lines.push(createBaseLine());
     const composerTokens: Array<{ text: string; fg: string; bold?: boolean; dim?: boolean }> = [];

package/src/runtime/bootstrap-hook-bridge.ts

@@ -13,6 +13,7 @@ import type { SessionManager } from '@pellux/goodvibes-sdk/platform/sessions';
 import type { PanelManager } from '../panels/panel-manager.ts';
 import type { ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { replayJournalForSession } from '../core/session-recovery.ts';
 
 export interface ResumeSessionOptions {
   readonly runtimeBus: RuntimeEventBus;
@@ -27,6 +28,7 @@ export interface ResumeSessionOptions {
   readonly panelManager: PanelManager;
   readonly configManager: Pick<ConfigManager, 'get' | 'getCategory'>;
   readonly providerRegistry: Pick<ProviderRegistry, 'get' | 'getCurrentModel' | 'getForModel' | 'require'>;
+  readonly homeDirectory: string;
 }
 
 export function createResumeSessionHandler(options: ResumeSessionOptions): (sessionId: string) => void {
@@ -47,6 +49,22 @@ export function createResumeSessionHandler(options: ResumeSessionOptions): (sess
         titleSource: meta.titleSource,
       });
       options.runtime.sessionId = sessionId;
+      replayJournalForSession({
+        homeDirectory: options.homeDirectory,
+        sessionId,
+        snapshotTimestamp: meta.timestamp ?? 0,
+        conversation: options.conversation,
+        persistSnapshot: (replayedMessages) => {
+          options.sessionManager.save(sessionId, replayedMessages as never[], {
+            title: options.conversation.title || meta.title,
+            model: meta.model,
+            provider: meta.provider,
+            timestamp: Date.now(),
+            titleSource: meta.titleSource,
+            returnContext: meta.returnContext,
+          });
+        },
+      });
       options.onSessionIdChanged?.(sessionId);
       if (meta?.model) options.runtime.model = meta.model;
       if (meta?.provider) options.runtime.provider = meta.provider;

package/src/runtime/bootstrap-shell.ts

@@ -106,6 +106,7 @@ export function createBootstrapShell(options: BootstrapShellOptions): BootstrapS
     panelManager: services.panelManager,
     configManager,
     providerRegistry: services.providerRegistry,
+    homeDirectory: services.homeDirectory,
   });
 
   const openAgentDetailRef: { fn: (agentId: string) => void } = { fn: (_agentId: string) => {} };

package/src/shell/blocking-input.ts

@@ -2,6 +2,8 @@ import type { ConversationManager } from '../core/conversation';
 import type { PermissionRequest } from '@pellux/goodvibes-sdk/platform/permissions';
 import type { SessionSnapshot } from '@/runtime/index.ts';
 import type { SystemMessageRouter } from '../core/system-message-router.ts';
+import type { ConversationMessageSnapshot } from '@pellux/goodvibes-sdk/platform/core';
+import { replayJournalForSession } from '../core/session-recovery.ts';
 
 export type PendingPermissionState = PermissionRequest & {
   resolve: (approved: boolean, remember?: boolean) => void;
@@ -17,6 +19,22 @@ export type BlockingInputHandlerOptions = {
   render: () => void;
   loadRecoveryConversation: () => SessionSnapshot | null;
   deleteRecoveryFile: () => void;
+  /**
+   * Absolute home directory used to locate the transcript journal for this
+   * recovery session. Required for journal replay on Ctrl+R restore.
+   */
+  homeDirectory: string;
+  /**
+   * The session ID that the recovery file belongs to. Required for journal
+   * replay so the correct journal path can be resolved.
+   */
+  sessionId: string;
+  /**
+   * Persist the post-replay snapshot so the WAL gap is durably closed.
+   * Called with the replayed message list. Best-effort — failures are swallowed
+   * inside replayJournalForSession.
+   */
+  persistSnapshot: (messages: ConversationMessageSnapshot[]) => void;
   /**
    * Optional callback invoked after Ctrl+R restore to reopen panels captured in
    * the recovery snapshot's returnContext. When provided (as wired in main.ts),
@@ -47,6 +65,9 @@ export function handleBlockingShellInput(
     render,
     loadRecoveryConversation,
     deleteRecoveryFile,
+    homeDirectory,
+    sessionId,
+    persistSnapshot,
     reopenPanels,
   } = options;
 
@@ -86,6 +107,17 @@ export function handleBlockingShellInput(
           title: recovery.title,
           titleSource: recovery.titleSource,
         });
+        // Replay journal records that post-date the recovery snapshot so turns
+        // written after the last recovery-file write (but before SIGKILL) are
+        // not silently dropped. snapshotTimestamp=0 when timestamp is absent so
+        // all journal records are replayed — safer than dropping.
+        replayJournalForSession({
+          homeDirectory,
+          sessionId,
+          snapshotTimestamp: recovery.timestamp ?? 0,
+          conversation,
+          persistSnapshot,
+        });
         reopenPanels?.(recovery);
         systemMessageRouter.high('[Recovery] Session restored.');
         deleteRecoveryFile();

package/src/shell/recovery-input-helpers.ts

@@ -0,0 +1,71 @@
+/**
+ * Helper factories for main()'s stdin fast-path: the Ctrl+R recovery
+ * persistence/panel-reopen callbacks and the one-key error-retry
+ * affordance. Extracted from main.ts so the entrypoint stays under the
+ * architecture line ceiling; main() wires these with its live services.
+ */
+
+import type { ConversationMessageSnapshot } from '../core/conversation.ts';
+import type { SessionSnapshot } from '@/runtime/index.ts';
+
+export interface PersistRecoveryDeps {
+  readonly sessionManager: {
+    save(id: string, msgs: never[], meta: { title: string; model: string; provider: string; timestamp: number }): unknown;
+  };
+  readonly runtime: { readonly sessionId: string; readonly model: string; readonly provider: string };
+  readonly conversation: { readonly title?: string | null };
+}
+
+/** Persist a replayed/restored snapshot through the session manager. */
+export function createPersistRecoverySnapshot(deps: PersistRecoveryDeps): (msgs: ConversationMessageSnapshot[]) => void {
+  return (msgs) => void deps.sessionManager.save(deps.runtime.sessionId, msgs as never[], {
+    title: deps.conversation.title ?? '',
+    model: deps.runtime.model,
+    provider: deps.runtime.provider,
+    timestamp: Date.now(),
+  });
+}
+
+export interface ReopenPanelsDeps {
+  readonly panelManager: { open(id: string): void; show(): void };
+  readonly render: () => void;
+}
+
+/** Reopen the panels recorded in a restored session's return context (capped at 4). */
+export function createReopenRecoveryPanels(deps: ReopenPanelsDeps): (snapshot: SessionSnapshot) => void {
+  return (snapshot) => {
+    for (const panelId of (snapshot.returnContext?.openPanels ?? []).slice(0, 4)) {
+      try { deps.panelManager.open(panelId); } catch { /* unknown panel id */ }
+    }
+    if ((snapshot.returnContext?.openPanels?.length ?? 0) > 0) { deps.panelManager.show(); deps.render(); }
+  };
+}
+
+export interface ErrorAffordanceDeps {
+  /** True when the failover retry context is armed (a retry is actually possible). */
+  readonly retryArmed: boolean;
+  /** Re-submit the failed turn via the shared failover retry path (no duplicate user messages). */
+  readonly retry: () => void;
+  readonly openModelPicker: () => void;
+  readonly render: () => void;
+}
+
+/**
+ * Handle one keypress while the error-retry affordance is active.
+ * 'r' retries on the current provider when armed; 'm' opens the model
+ * picker. Returns true when the key was consumed; any other key returns
+ * false so the caller routes it as normal input.
+ */
+export function handleErrorAffordanceKey(data: string, deps: ErrorAffordanceDeps): boolean {
+  if (data === 'r' && deps.retryArmed) {
+    deps.retry();
+    deps.render();
+    return true;
+  }
+  if (data === 'm') {
+    deps.openModelPicker();
+    deps.render();
+    return true;
+  }
+  return false;
+}

package/src/utils/terminal-width.ts

@@ -43,9 +43,16 @@ function stripAnsi(text: string): string {
 
 /**
  * Calculates the visual width of a string in the terminal.
- * Handles CJK characters, emoji (including ZWJ sequences), and
- * variation selectors correctly as double-width.
- * ANSI escape sequences (SGR/CSI/OSC-8) are stripped before measurement.
+ * Handles CJK characters, emoji, and variation selectors correctly as
+ * double-width. ANSI escape sequences (SGR/CSI/OSC-8) are stripped before
+ * measurement.
+ *
+ * NOTE: Width is measured per Unicode scalar value (code point), not per
+ * grapheme cluster. ZWJ sequences (e.g. 👨‍👩‍👧‍👦) are handled component-by-component:
+ * each component's width is summed and ZWJ/VS chars contribute zero width,
+ * so the total is accurate. However, truncation (truncateDisplay) may split
+ * a ZWJ family mid-sequence, leaving dangling ZWJ/VS characters. This is a
+ * cosmetic degradation only — line widths remain correct.
  */
 export function getDisplayWidth(text: string): number {
   text = stripAnsi(text);

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '0.23.0';
+let _version = '0.24.0';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8'));
   _version = pkg.version ?? _version;