@pellux/goodvibes-tui 0.22.0 → 0.24.0

package/src/input/handler-feed-routes.ts

@@ -14,6 +14,7 @@ import {
 import { cleanupMarkerRegistry, expandPrompt, findMarkerAtPos, registerPaste } from './handler-content-actions.ts';
 import type { PanelManager } from '../panels/panel-manager.ts';
 import type { KeybindingsManager } from './keybindings.ts';
+import type { KillRing } from './kill-ring.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
 export type PanelFocusRouteState = {
@@ -184,9 +185,12 @@ export type TextRouteState = {
   filePicker: { open: (insertPos: number, injectMode?: boolean) => void };
   modalOpened: (name: string) => void;
   saveUndoState: () => void;
+  /** Coalescing undo snapshot for plain text insertions. */
+  saveUndoStateForText: () => void;
   ensureInputCursorVisible: () => void;
   registerPaste: (content: string) => string;
   requestRender: () => void;
+  killRing: KillRing;
 };
 
 export function handlePromptTextToken(state: TextRouteState, token: InputToken): {
@@ -210,7 +214,8 @@ export function handlePromptTextToken(state: TextRouteState, token: InputToken):
   if (state.inputHistory?.isBrowsing) {
     state.inputHistory.resetPosition();
   }
-  state.saveUndoState();
+  state.killRing.clearYankState();
+  state.saveUndoStateForText();
   const text = state.registerPaste(token.value);
   let prompt = state.prompt.slice(0, state.cursorPos) + text + state.prompt.slice(state.cursorPos);
   let cursorPos = state.cursorPos + text.length;
@@ -261,6 +266,8 @@ export type KeyRouteState = {
   processModal: { open: () => void };
   modalOpened: (name: string) => void;
   saveUndoState: () => void;
+  /** Break the undo coalescing group (call on cursor moves). */
+  breakUndoCoalesce: () => void;
   ensureInputCursorVisible: (contentWidth?: number) => void;
   getWrappedPromptInfo: (contentWidth: number) => WrappedPromptInfo;
   moveCursorVertical: (direction: -1 | 1) => boolean;
@@ -272,6 +279,7 @@ export type KeyRouteState = {
   scroll: (delta: number) => void;
   exitApp: () => void;
   requestRender: () => void;
+  killRing: KillRing;
 };
 
 export function handlePromptKeyToken(state: KeyRouteState, token: InputToken): {
@@ -372,6 +380,7 @@ export function handlePromptKeyToken(state: KeyRouteState, token: InputToken): {
 
   if (token.logicalName === 'backspace') {
     if (cursorPos > 0) {
+      state.killRing.clearYankState();
       state.saveUndoState();
       let marker = state.findMarkerAtPos(cursorPos);
       if (!marker) {
@@ -396,6 +405,7 @@ export function handlePromptKeyToken(state: KeyRouteState, token: InputToken): {
 
   if (token.logicalName === 'delete') {
     if (cursorPos < prompt.length) {
+      state.killRing.clearYankState();
       state.saveUndoState();
       const marker = state.findMarkerAtPos(cursorPos + 1);
       if (marker) {
@@ -417,6 +427,8 @@ export function handlePromptKeyToken(state: KeyRouteState, token: InputToken): {
       cursorPos = marker ? marker.start : cursorPos - 1;
       ensureLocalInputCursorVisible();
     }
+    state.killRing.clearYankState();
+    state.breakUndoCoalesce();
     state.requestRender();
     return { handled: true, prompt, cursorPos, inputScrollTop, commandMode, indicatorFocused };
   }
@@ -427,18 +439,24 @@ export function handlePromptKeyToken(state: KeyRouteState, token: InputToken): {
       cursorPos = marker ? marker.end : cursorPos + 1;
       ensureLocalInputCursorVisible();
     }
+    state.killRing.clearYankState();
+    state.breakUndoCoalesce();
     state.requestRender();
     return { handled: true, prompt, cursorPos, inputScrollTop, commandMode, indicatorFocused };
   }
 
   if (token.logicalName === 'home') {
     cursorPos = 0;
+    state.killRing.clearYankState();
+    state.breakUndoCoalesce();
     ensureLocalInputCursorVisible();
     return { handled: true, prompt, cursorPos, inputScrollTop, commandMode, indicatorFocused };
   }
 
   if (token.logicalName === 'end') {
     cursorPos = prompt.length;
+    state.killRing.clearYankState();
+    state.breakUndoCoalesce();
     ensureLocalInputCursorVisible();
     return { handled: true, prompt, cursorPos, inputScrollTop, commandMode, indicatorFocused };
   }

package/src/input/handler-feed.ts

@@ -44,6 +44,7 @@ import { SelectionManager } from './selection.ts';
 import type { PanelManager } from '../panels/panel-manager.ts';
 import type { KeybindingsManager } from './keybindings.ts';
 import type { ModelPickerTarget } from './model-picker.ts';
+import type { KillRing } from './kill-ring.ts';
 
 /**
  * InputFeedContext — The single long-lived context object passed to feedInputTokens
@@ -129,6 +130,7 @@ export interface InputFeedContext {
   readonly modalStack: string[];
   inputHistory: InputHistory | null;
   conversationManager: ConversationManager | null;
+  readonly killRing: KillRing;
   readonly getHistory: () => InfiniteBuffer;
   readonly getViewportHeight: () => number;
   readonly getScrollTop: () => number;
@@ -146,6 +148,10 @@ export interface InputFeedContext {
   readonly handleRedo: () => void;
   readonly handlePaste: () => void;
   readonly saveUndoState: () => void;
+  /** Coalescing variant: consecutive text insertions within UNDO_COALESCE_MS merge into one group. */
+  readonly saveUndoStateForText: () => void;
+  /** Break the current coalescing group (cursor moves call this). */
+  readonly breakUndoCoalesce: () => void;
   readonly ensureInputCursorVisible: (contentWidth?: number) => void;
   readonly registerPaste: (content: string) => string;
   readonly executeBlockAction: (id: string) => void;
@@ -283,6 +289,7 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
         cyclePanelTab: context.cyclePanelTab,
         panelManager: context.panelManager,
         keybindingsManager: context.keybindingsManager,
+        killRing: context.killRing,
       };
       if (handleGlobalShortcutToken(shortcutState, token, viewportHeight)) {
         context.prompt = shortcutState.prompt;
@@ -336,9 +343,11 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
       filePicker: context.filePicker,
       modalOpened: context.modalOpened,
       saveUndoState: context.saveUndoState,
+      saveUndoStateForText: context.saveUndoStateForText,
       ensureInputCursorVisible: () => context.ensureInputCursorVisible(),
       registerPaste: context.registerPaste,
       requestRender: context.requestRender,
+      killRing: context.killRing,
     }, token);
     if (textRoute.handled) {
       context.prompt = textRoute.prompt;
@@ -395,6 +404,7 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
         processModal: context.processModal,
         modalOpened: context.modalOpened,
         saveUndoState: context.saveUndoState,
+        breakUndoCoalesce: context.breakUndoCoalesce,
         ensureInputCursorVisible: context.ensureInputCursorVisible,
         getWrappedPromptInfo: context.getWrappedPromptInfo,
         moveCursorVertical: context.moveCursorVertical,
@@ -406,6 +416,7 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
         scroll: context.scroll,
         exitApp: context.exitApp,
         requestRender: context.requestRender,
+        killRing: context.killRing,
       }, token);
       if (keyRoute.handled) {
         context.prompt = keyRoute.prompt;

package/src/input/handler-prompt-buffer.ts

@@ -12,6 +12,34 @@ export type WrappedPromptInfo = {
 
 export type UndoState = { prompt: string; cursorPos: number };
 
+// ---------------------------------------------------------------------------
+// Undo coalescing support
+// ---------------------------------------------------------------------------
+
+/** Milliseconds within which consecutive text insertions are merged into one
+ *  undo group. Cursor moves or kill/yank operations always break the group. */
+export const UNDO_COALESCE_MS = 500;
+
+export type EditKind = 'text' | 'kill' | 'yank' | 'other';
+
+/**
+ * shouldCoalesceUndo — returns true when the new edit should be merged into
+ * the most recent undo group rather than creating a new snapshot.
+ *
+ * Coalesces only when:
+ *   - Both the last edit and the incoming edit are plain text insertions
+ *   - The time delta is within UNDO_COALESCE_MS
+ */
+export function shouldCoalesceUndo(
+  lastEditKind: EditKind,
+  incomingKind: EditKind,
+  lastEditMs: number,
+  nowMs: number,
+): boolean {
+  if (lastEditKind !== 'text' || incomingKind !== 'text') return false;
+  return (nowMs - lastEditMs) < UNDO_COALESCE_MS;
+}
+
 export function wordWrapLine(line: string, maxW: number): string[] {
   if (maxW <= 0) return [line];
   if (line.length === 0) return [''];

package/src/input/handler-shortcuts.ts

@@ -6,6 +6,8 @@ import type { ConversationManager } from '../core/conversation';
 import type { AutocompleteEngine } from './autocomplete.ts';
 import type { PanelManager } from '../panels/panel-manager.ts';
 import type { KeybindingsManager } from './keybindings.ts';
+import type { KillRing } from './kill-ring.ts';
+import { wordBoundaryBack, wordBoundaryForward } from './kill-ring.ts';
 
 type WrappedPromptInfo = {
   wrappedLines: string[];
@@ -43,6 +45,7 @@ export type GlobalShortcutRouteState = {
   handlePaste: () => void;
   handleEscape: () => void;
   cyclePanelTab: (direction: 'next' | 'prev') => void;
+  killRing: KillRing;
 };
 
 export function handleGlobalShortcutToken(
@@ -148,6 +151,8 @@ export function handleGlobalShortcutToken(
       let pos = state.cursorPos;
       while (pos > 0 && state.prompt[pos - 1] === ' ') pos--;
       while (pos > 0 && state.prompt[pos - 1] !== ' ') pos--;
+      const killedWord = state.prompt.slice(pos, state.cursorPos);
+      if (killedWord) { state.killRing.push(killedWord); state.killRing.clearYankState(); }
       state.prompt = state.prompt.slice(0, pos) + state.prompt.slice(state.cursorPos);
       state.cursorPos = pos;
       state.ensureInputCursorVisible();
@@ -179,13 +184,18 @@ export function handleGlobalShortcutToken(
       return true;
     }
 
-    case 'kill-line':
+    case 'kill-line': {
+      const killed = state.prompt.slice(state.cursorPos);
       state.saveUndoState();
+      state.killRing.push(killed);
+      state.killRing.clearYankState();
       state.prompt = state.prompt.slice(0, state.cursorPos);
       state.ensureInputCursorVisible();
       return true;
+    }
 
-    case 'clear-prompt':
+    case 'clear-prompt': {
+      // Legacy full-clear: keep as alias but do NOT call this when kill-to-start is bound.
       state.saveUndoState();
       state.prompt = '';
       state.cursorPos = 0;
@@ -194,6 +204,82 @@ export function handleGlobalShortcutToken(
         state.autocomplete?.reset();
       }
       return true;
+    }
+
+    case 'kill-to-start': {
+      // Kill from start of buffer to cursor, push to ring.
+      const killed = state.prompt.slice(0, state.cursorPos);
+      state.saveUndoState();
+      state.killRing.push(killed);
+      state.killRing.clearYankState();
+      state.prompt = state.prompt.slice(state.cursorPos);
+      state.cursorPos = 0;
+      state.ensureInputCursorVisible();
+      return true;
+    }
+
+    case 'kill-word-forward': {
+      // Kill from cursor to end of next word, push to ring.
+      const end = wordBoundaryForward(state.prompt, state.cursorPos);
+      const killed = state.prompt.slice(state.cursorPos, end);
+      if (killed) {
+        state.saveUndoState();
+        state.killRing.push(killed);
+        state.killRing.clearYankState();
+        state.prompt = state.prompt.slice(0, state.cursorPos) + state.prompt.slice(end);
+        state.ensureInputCursorVisible();
+      }
+      return true;
+    }
+
+    case 'word-back': {
+      const newPos = wordBoundaryBack(state.prompt, state.cursorPos);
+      if (newPos !== state.cursorPos) {
+        state.killRing.clearYankState();
+        state.cursorPos = newPos;
+        state.ensureInputCursorVisible();
+      }
+      return true;
+    }
+
+    case 'word-forward': {
+      const newPos = wordBoundaryForward(state.prompt, state.cursorPos);
+      if (newPos !== state.cursorPos) {
+        state.killRing.clearYankState();
+        state.cursorPos = newPos;
+        state.ensureInputCursorVisible();
+      }
+      return true;
+    }
+
+    case 'yank': {
+      const text = state.killRing.yank();
+      if (text) {
+        state.saveUndoState();
+        state.prompt = state.prompt.slice(0, state.cursorPos) + text + state.prompt.slice(state.cursorPos);
+        state.cursorPos += text.length;
+        state.ensureInputCursorVisible();
+      }
+      return true;
+    }
+
+    case 'yank-pop': {
+      // Only valid immediately after a yank or yank-pop.
+      if (!state.killRing.lastActionWasYank) return false;
+      // Undo the previous yank by restoring: we store the pre-yank snapshot on
+      // the undo stack so a single undo covers the whole yank sequence.
+      // For yank-pop: replace the last yanked text with the next ring entry.
+      // We rely on the undo stack having the pre-yank state at the top.
+      state.handleUndo();
+      const text = state.killRing.yankPop();
+      if (text) {
+        state.saveUndoState();
+        state.prompt = state.prompt.slice(0, state.cursorPos) + text + state.prompt.slice(state.cursorPos);
+        state.cursorPos += text.length;
+        state.ensureInputCursorVisible();
+      }
+      return true;
+    }
 
     case 'undo':
       state.handleUndo();

package/src/input/handler-ui-state.ts

@@ -267,13 +267,13 @@ export function handleSearchModeToken(
         searchManager.unlock();
       }
     } else if (token.type === 'text') {
-      if (token.value === 'j' || token.value === 'l') {
+      if (token.value === 'n' || token.value === 'j' || token.value === 'l') {
         searchManager.nextMatch();
         const matchLine = searchManager.getCurrentMatchLine();
         if (matchLine >= 0) {
           state.scroll(matchLine - state.getScrollTop() - Math.floor(state.getViewportHeight() / 2));
         }
-      } else if (token.value === 'k' || token.value === 'h') {
+      } else if (token.value === 'N' || token.value === 'k' || token.value === 'h') {
         searchManager.prevMatch();
         const matchLine = searchManager.getCurrentMatchLine();
         if (matchLine >= 0) {

package/src/input/handler.ts

@@ -76,10 +76,12 @@ import {
   moveCursorVertical,
   redoPromptState,
   saveUndoState,
+  shouldCoalesceUndo,
   undoPromptState,
   wordWrapLine,
   type WrappedPromptInfo,
 } from './handler-prompt-buffer.ts';
+import { KillRing } from './kill-ring.ts';
 import { clearModalStack, handleEscape, modalOpened } from './handler-modal-stack.ts';
 import { handleModalTokenRoutes } from './handler-modal-token-routes.ts';
 import {
@@ -198,7 +200,15 @@ export class InputHandler implements InputHandlerLike {
   // ── Undo / Redo ────────────────────────────────────────────────────────────
   public undoStack: Array<{ prompt: string; cursorPos: number }> = [];
   public redoStack: Array<{ prompt: string; cursorPos: number }> = [];
-  public static readonly MAX_UNDO = 50;
+  /** Maximum undo groups retained. Oldest are evicted when the limit is hit. */
+  public static readonly MAX_UNDO = 100;
+  /** Timestamp (Date.now()) of the last saveUndoState call, used for coalescing. */
+  public lastUndoMs = 0;
+  /** Edit kind of the last saveUndoState call, used for coalescing. */
+  public lastUndoKind: import('./handler-prompt-buffer.ts').EditKind = 'other';
+
+  // ── Kill ring ───────────────────────────────────────────────────────────────
+  public killRing = new KillRing();
 
   // ── Path completion (Tab on path-like token) ───────────────────────────────
   /** Current list of path completions cycling on repeated Tab presses. */
@@ -301,6 +311,7 @@ export class InputHandler implements InputHandlerLike {
         conversationManager: this.conversationManager,
         panelManager: this.uiServices.shell.panelManager,
         keybindingsManager: this.uiServices.shell.keybindingsManager,
+        killRing: this.killRing,
         getHistory: this.getHistory,
         getViewportHeight: this.getViewportHeight,
         getScrollTop: this.getScrollTop,
@@ -320,6 +331,8 @@ export class InputHandler implements InputHandlerLike {
         handleRedo: () => { this.handleRedo(); this.syncFeedContextMutableFields(); },
         handlePaste: () => { this.handlePaste(); this.syncFeedContextMutableFields(); },
         saveUndoState: () => this.saveUndoState(),
+        saveUndoStateForText: () => this.saveUndoStateForText(),
+        breakUndoCoalesce: () => { this.lastUndoKind = 'other'; },
         ensureInputCursorVisible: (contentWidth?: number) => this.ensureInputCursorVisible(contentWidth),
         registerPaste: (content: string) => this.registerPaste(content),
         executeBlockAction: (id: string) => this.executeBlockAction(id),
@@ -612,11 +625,34 @@ export class InputHandler implements InputHandlerLike {
   // ── Undo / Redo methods ─────────────────────────────────────────────────
 
   /**
-   * saveUndoState - Snapshot current prompt + cursor onto the undo stack.
-   * Clears the redo stack because a new edit invalidates future states.
+   * saveUndoState - Unconditionally snapshot current prompt + cursor onto the
+   * undo stack (kill, yank, delete, or other non-text edits). Clears redo stack.
    */
   public saveUndoState(): void {
     saveUndoState(this.undoStack, this.redoStack, this.prompt, this.cursorPos, InputHandler.MAX_UNDO);
+    this.lastUndoMs = Date.now();
+    this.lastUndoKind = 'other';
+  }
+
+  /**
+   * saveUndoStateForText - Snapshot with coalescing for plain text insertions.
+   * Consecutive text edits within UNDO_COALESCE_MS are merged into one group
+   * (the snapshot is skipped; the group absorbs the characters typed in the
+   * burst). Cursor moves, kill, and yank operations break the group.
+   *
+   * Call this instead of saveUndoState() from the text-insertion path only.
+   */
+  public saveUndoStateForText(): void {
+    const now = Date.now();
+    if (shouldCoalesceUndo(this.lastUndoKind, 'text', this.lastUndoMs, now)) {
+      // Coalesce: skip the snapshot but update the timestamp so the window
+      // keeps sliding until the burst ends.
+      this.lastUndoMs = now;
+      return;
+    }
+    saveUndoState(this.undoStack, this.redoStack, this.prompt, this.cursorPos, InputHandler.MAX_UNDO);
+    this.lastUndoMs = now;
+    this.lastUndoKind = 'text';
   }
 
   /**

package/src/input/keybindings.ts

@@ -51,7 +51,13 @@ export type KeyAction =
   | 'undo'
   | 'redo'
   | 'paste'
-  | 'replay-panel';
+  | 'replay-panel'
+  | 'word-back'
+  | 'word-forward'
+  | 'kill-to-start'
+  | 'kill-word-forward'
+  | 'yank'
+  | 'yank-pop';
 
 /** Human-readable description for each action (used in /keybindings display). */
 export const ACTION_DESCRIPTIONS: Record<KeyAction, string> = {
@@ -72,11 +78,17 @@ export const ACTION_DESCRIPTIONS: Record<KeyAction, string> = {
   'apply-diff-line-start': 'Apply nearest diff / move to line start',
   'next-error-line-end':   'Navigate to next error / move to line end',
   'kill-line':             'Kill to end of line',
-  'clear-prompt':          'Clear the prompt',
+  'clear-prompt':          'Clear the entire prompt (Alt+U; kill-to-start owns Ctrl+U)',
   'undo':                  'Undo last prompt edit',
   'redo':                  'Redo last undone edit',
   'paste':                 'Paste from clipboard (image priority)',
   'replay-panel':          'Open / close the Replay panel',
+  'word-back':             'Move cursor to start of previous word (Alt+B)',
+  'word-forward':          'Move cursor to end of next word (Alt+F)',
+  'kill-to-start':         'Kill from cursor to start of line into kill ring (Ctrl+U)',
+  'kill-word-forward':     'Kill word forward into kill ring (Alt+D)',
+  'yank':                  'Yank (paste) from kill ring (Ctrl+Shift+Y)',
+  'yank-pop':              'Rotate kill ring and yank next entry (Alt+Y)',
 };
 
 /** Default key bindings for all actions. */
@@ -98,11 +110,29 @@ export const DEFAULT_KEYBINDINGS: Record<KeyAction, KeyCombo[]> = {
   'apply-diff-line-start': [{ key: 'a', ctrl: true }],
   'next-error-line-end':   [{ key: 'e', ctrl: true }],
   'kill-line':             [{ key: 'k', ctrl: true }],
-  'clear-prompt':          [{ key: 'u', ctrl: true }],
+  // Alt+U: clear entire prompt. Ctrl+U is owned by kill-to-start (readline
+  // convention). Alt+U is unused by any other default and is representable by
+  // the tokenizer's { key, alt } combo form.
+  'clear-prompt':          [{ key: 'u', alt: true }],
   'undo':                  [{ key: 'z', ctrl: true }],
   'redo':                  [{ key: 'z', ctrl: true, shift: true }],
   'paste':                 [{ key: 'v', ctrl: true }],
   'replay-panel':          [{ key: 'r', ctrl: true, shift: true }],
+  // Word navigation (Alt+B / Alt+F — emacs readline standard)
+  'word-back':             [{ key: 'b', alt: true }],
+  'word-forward':          [{ key: 'f', alt: true }],
+  // Kill-ring operations.
+  // Note: 'kill-line' (Ctrl+K) kills to end; 'kill-to-start' (Ctrl+U) kills to start.
+  // 'clear-prompt' (Alt+U) clears the entire buffer regardless of cursor position.
+  // kill-to-start owns Ctrl+U (readline convention); clear-prompt uses Alt+U.
+  'kill-to-start':         [{ key: 'u', ctrl: true }],
+  // Alt+D: kill word forward (no prior conflict)
+  'kill-word-forward':     [{ key: 'd', alt: true }],
+  // Ctrl+Shift+Y: yank from kill ring.
+  // CONFLICT RESOLVED: Ctrl+Y was 'block-copy'; yank moved to Ctrl+Shift+Y.
+  'yank':                  [{ key: 'y', ctrl: true, shift: true }],
+  // Alt+Y: yank-pop (rotate ring after yank)
+  'yank-pop':              [{ key: 'y', alt: true }],
 };
 
 /** Resolved overrides type: each key can be a single combo or array. */

package/src/input/kill-ring.ts

@@ -0,0 +1,134 @@
+// ---------------------------------------------------------------------------
+// KillRing — emacs/readline-compatible kill ring implementation.
+//
+// The ring holds up to MAX_ENTRIES text strings. Kill commands push to the
+// head. Yank pastes from the current yank pointer (default: head). Yank-pop
+// rotates the pointer one step further into the ring without adding a new
+// entry. Consecutive yank-pops cycle through all ring entries.
+//
+// Word-boundary helpers are co-located here because they are used by both
+// kill-word-back (Ctrl+W) and kill-word-forward (Alt+D).
+// ---------------------------------------------------------------------------
+
+export const KILL_RING_MAX = 32;
+
+/**
+ * KillRing — bounded circular ring of killed text segments.
+ *
+ * All public mutation methods are pure-functional helpers at module level;
+ * this class owns the mutable state so the handler can hold a single ref.
+ */
+export class KillRing {
+  private entries: string[] = [];
+  /** Index into `entries` for the next yank. -1 means the ring is empty. */
+  private yankPointer = -1;
+  /** Whether the last edit action was a yank (enables yank-pop). */
+  public lastActionWasYank = false;
+
+  /**
+   * Push a text segment onto the head of the ring.
+   * Trims the ring to MAX_ENTRIES. Resets the yank pointer to 0 (head).
+   * Empty strings are silently ignored.
+   */
+  push(text: string): void {
+    if (!text) return;
+    this.entries.unshift(text);
+    if (this.entries.length > KILL_RING_MAX) {
+      this.entries.length = KILL_RING_MAX;
+    }
+    this.yankPointer = 0;
+    this.lastActionWasYank = false;
+  }
+
+  /**
+   * Yank — return the entry at the current yank pointer.
+   * Returns '' if the ring is empty.
+   * Sets lastActionWasYank so a subsequent yank-pop is valid.
+   */
+  yank(): string {
+    if (this.entries.length === 0) return '';
+    this.yankPointer = Math.max(0, Math.min(this.yankPointer, this.entries.length - 1));
+    this.lastActionWasYank = true;
+    return this.entries[this.yankPointer] ?? '';
+  }
+
+  /**
+   * YankPop — advance the yank pointer by one step (wrapping) and return the
+   * new entry. Only valid after a yank; if the ring has <=1 entry, returns the
+   * same string. Returns '' if the ring is empty.
+   */
+  yankPop(): string {
+    if (this.entries.length === 0) return '';
+    this.yankPointer = (this.yankPointer + 1) % this.entries.length;
+    this.lastActionWasYank = true;
+    return this.entries[this.yankPointer] ?? '';
+  }
+
+  /** True when there is at least one entry in the ring. */
+  get hasEntries(): boolean {
+    return this.entries.length > 0;
+  }
+
+  /** Current ring contents (newest first). Read-only snapshot for tests. */
+  getEntries(): readonly string[] {
+    return this.entries;
+  }
+
+  /** Reset yank state when the user makes a non-yank edit. */
+  clearYankState(): void {
+    this.lastActionWasYank = false;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Word boundary helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * isWordChar — true when the character is a "word" character.
+ * Word = letter (Unicode), digit, or underscore. This is the emacs/readline
+ * word boundary definition used for Alt+B, Alt+F, Ctrl+W, Alt+D.
+ */
+function isWordChar(ch: string): boolean {
+  return /[\p{L}\p{N}_]/u.test(ch);
+}
+
+/**
+ * wordBoundaryBack — find the start of the word that the cursor is in, or the
+ * start of the previous word if the cursor is at a non-word character.
+ *
+ * Emacs Alt+B semantics:
+ *   - Skip non-word chars backward
+ *   - Skip word chars backward
+ *   - Return resulting position
+ *
+ * Returns the new cursor position (>= 0).
+ */
+export function wordBoundaryBack(text: string, pos: number): number {
+  let p = pos;
+  // Skip non-word chars first (move past punctuation/spaces)
+  while (p > 0 && !isWordChar(text[p - 1]!)) p--;
+  // Then skip word chars (the word body)
+  while (p > 0 && isWordChar(text[p - 1]!)) p--;
+  return p;
+}
+
+/**
+ * wordBoundaryForward — find the position just past the end of the next word.
+ *
+ * Emacs Alt+F semantics:
+ *   - Skip non-word chars forward
+ *   - Skip word chars forward
+ *   - Return resulting position
+ *
+ * Returns the new cursor position (<= text.length).
+ */
+export function wordBoundaryForward(text: string, pos: number): number {
+  let p = pos;
+  const len = text.length;
+  // Skip non-word chars first
+  while (p < len && !isWordChar(text[p]!)) p++;
+  // Then skip word chars
+  while (p < len && isWordChar(text[p]!)) p++;
+  return p;
+}

package/src/input/model-picker.ts

@@ -67,7 +67,7 @@ export class ModelPickerModal {
   constructor(
     private readonly favoritesStore: Pick<FavoritesStore, 'getRecentModels'>,
     private readonly benchmarkStore: Pick<BenchmarkStore, 'getBenchmarks'>,
-    private readonly providerRegistry: Pick<ProviderRegistry, 'getSyntheticModelInfoFromCatalog'>,
+    private readonly providerRegistry: Pick<ProviderRegistry, 'getSyntheticModelInfoFromCatalog' | 'getSyntheticCanonicalModels'>,
   ) {}
 
   public active = false;
@@ -547,6 +547,23 @@ export class ModelPickerModal {
     return this.providerRegistry.getSyntheticModelInfoFromCatalog(modelId);
   }
 
+  /**
+   * Returns the ordered backend ladder for a synthetic model.
+   * Each entry describes a real provider/model that the synthetic model routes to.
+   * Returns null when the model ID is not found in the synthetic catalog.
+   */
+  getSyntheticChain(modelId: string): Array<{ position: number; provider: string; model: string; registryKey: string }> | null {
+    const canonical = this.providerRegistry.getSyntheticCanonicalModels();
+    const entry = canonical.find((m) => m.id === modelId);
+    if (!entry) return null;
+    return entry.backends.map((b, idx) => ({
+      position: idx,
+      provider: b.providerName,
+      model: b.modelId,
+      registryKey: b.registryKey ?? `${b.providerName}:${b.modelId}`,
+    }));
+  }
+
   getBenchmarkEntry(model: ModelDefinition) {
     return this.benchmarkStore.getBenchmarks(model.id) ?? this.benchmarkStore.getBenchmarks(model.displayName);
   }