@pellux/goodvibes-tui 0.23.0 → 0.24.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);
   }

package/src/input/search.ts

@@ -17,6 +17,12 @@ export class SearchManager {
   public query = '';
   public matches: SearchMatch[] = [];
   public currentMatch = 0;
+  /**
+   * Set to true when nextMatch/prevMatch wraps around the match list.
+   * Cleared on each navigation call before the wrap check, so it only
+   * reflects the most recent navigation step.
+   */
+  public wrapAround = false;
 
   /** Open search mode. */
   open(): void {
@@ -25,6 +31,7 @@ export class SearchManager {
     this.query = '';
     this.matches = [];
     this.currentMatch = 0;
+    this.wrapAround = false;
   }
 
   /** Lock the query — switches from typing mode to navigation mode. */
@@ -49,6 +56,7 @@ export class SearchManager {
     this.matches = [];
     this.currentMatch = 0;
 
+    this.wrapAround = false;
     if (query.length === 0) return;
 
     const lowerQuery = query.toLowerCase();
@@ -68,16 +76,20 @@ export class SearchManager {
     }
   }
 
-  /** Jump to next match. */
+  /** Jump to next match. Wraps around; sets wrapAround when it does. */
   nextMatch(): void {
-    if (this.matches.length === 0) return;
-    this.currentMatch = (this.currentMatch + 1) % this.matches.length;
+    if (this.matches.length === 0) { this.wrapAround = false; return; }
+    const next = (this.currentMatch + 1) % this.matches.length;
+    this.wrapAround = next < this.currentMatch || (this.currentMatch === this.matches.length - 1);
+    this.currentMatch = next;
   }
 
-  /** Jump to previous match. */
+  /** Jump to previous match. Wraps around; sets wrapAround when it does. */
   prevMatch(): void {
-    if (this.matches.length === 0) return;
-    this.currentMatch = (this.currentMatch - 1 + this.matches.length) % this.matches.length;
+    if (this.matches.length === 0) { this.wrapAround = false; return; }
+    const prev = (this.currentMatch - 1 + this.matches.length) % this.matches.length;
+    this.wrapAround = prev > this.currentMatch || (this.currentMatch === 0);
+    this.currentMatch = prev;
   }
 
   /** Get the line number of the current match (for scroll). */

package/src/input/settings-modal-activation.ts

@@ -0,0 +1,134 @@
+/**
+ * settings-modal-activation — pure action helpers for SettingsModal.
+ *
+ * These functions encapsulate the two activation/interaction operations:
+ *   - activateSelected: toggle boolean, cycle enum, enter edit mode, launch pickers
+ *   - handleSubscriptionLogoutKey: route a keypress through the logout confirm gate
+ *
+ * Each function takes its dependencies as explicit arguments rather than
+ * accessing class-level state directly, following the same pattern as
+ * settings-modal-reset.ts and settings-modal-mutations.ts.
+ */
+
+import { handleConfirmInput } from '../panels/confirm-state.ts';
+import type { FlagEntry, McpEntry, SettingEntry, SubscriptionEntry } from './settings-modal-types.ts';
+import { buildMcpEntries, buildSubscriptionEntries } from './settings-modal-data.ts';
+import { modelPickerLaunchForKey } from './settings-modal-behavior.ts';
+import type { ConfigKey } from '@pellux/goodvibes-sdk/platform/config';
+import type { SubscriptionManager } from '@pellux/goodvibes-sdk/platform/config';
+import type { ServiceInspectionQuery } from '../runtime/ui-service-queries.ts';
+import type { ModelPickerTarget } from './model-picker.ts';
+
+// ---------------------------------------------------------------------------
+// activateSelected
+// ---------------------------------------------------------------------------
+
+export interface ActivateSelectedContext {
+  readonly currentCategory: string;
+  readonly configManager: { get(key: ConfigKey): unknown } | null;
+  getSelectedMcp(): McpEntry | null;
+  getSelectedSubscription(): SubscriptionEntry | null;
+  getSelected(): SettingEntry | null;
+  setValue(key: ConfigKey, value: unknown): void;
+  setEditingMode(value: boolean): void;
+  setEditBuffer(value: string): void;
+  setMcpAllowAllConfirmationTarget(value: string | null): void;
+  setSubscriptionLogoutConfirmationTarget(value: string | null): void;
+  setPendingSettingsPickerAction(value: 'tts-provider' | 'tts-voice' | null): void;
+  setPendingModelPickerTarget(value: ModelPickerTarget | null): void;
+  setPendingProviderModelPickerTarget(value: ModelPickerTarget | null): void;
+}
+
+export function activateSelected(ctx: ActivateSelectedContext): void {
+  if (ctx.currentCategory === 'mcp') {
+    const entry = ctx.getSelectedMcp();
+    if (!entry) return;
+    ctx.setEditingMode(true);
+    ctx.setEditBuffer(entry.trustMode);
+    ctx.setMcpAllowAllConfirmationTarget(null);
+    return;
+  }
+
+  if (ctx.currentCategory === 'subscriptions') {
+    const entry = ctx.getSelectedSubscription();
+    if (!entry) return;
+    if (entry.state === 'active' || entry.state === 'pending') {
+      // First press: arm the confirm gate. Subsequent key handling routes
+      // through handleSubscriptionLogoutKey() before normal dispatch.
+      ctx.setSubscriptionLogoutConfirmationTarget(entry.provider);
+    }
+    return;
+  }
+
+  const entry = ctx.getSelected();
+  if (!entry || !ctx.configManager) return;
+
+  const { setting } = entry;
+
+  // Delegate provider/model picker settings to the model picker UI
+  if (setting.key === 'tts.provider') {
+    ctx.setPendingSettingsPickerAction('tts-provider');
+    return;
+  }
+  if (setting.key === 'tts.voice') {
+    ctx.setPendingSettingsPickerAction('tts-voice');
+    return;
+  }
+
+  const pickerLaunch = modelPickerLaunchForKey(setting.key);
+  if (pickerLaunch !== null) {
+    if (pickerLaunch.flow === 'providerModel') {
+      ctx.setPendingProviderModelPickerTarget(pickerLaunch.target);
+    } else {
+      ctx.setPendingModelPickerTarget(pickerLaunch.target);
+    }
+    return;
+  }
+
+  if (setting.type === 'boolean') {
+    const newVal = !entry.currentValue;
+    ctx.setValue(setting.key as ConfigKey, newVal);
+  } else if (setting.type === 'enum' && setting.enumValues) {
+    const idx = setting.enumValues.indexOf(entry.currentValue as string);
+    const nextIdx = (idx + 1) % setting.enumValues.length;
+    ctx.setValue(setting.key as ConfigKey, setting.enumValues[nextIdx]);
+  } else if (setting.type === 'string' || setting.type === 'number') {
+    // Enter inline edit mode
+    ctx.setEditingMode(true);
+    ctx.setEditBuffer(String(entry.currentValue ?? ''));
+  }
+}
+
+// ---------------------------------------------------------------------------
+// handleSubscriptionLogoutKey
+// ---------------------------------------------------------------------------
+
+export interface HandleSubscriptionLogoutKeyContext {
+  readonly subscriptionLogoutConfirmationTarget: string | null;
+  readonly subscriptionManager: SubscriptionManager | null;
+  readonly serviceRegistry: Pick<ServiceInspectionQuery, 'getAll'> | null;
+  setSubscriptionEntries(entries: SubscriptionEntry[]): void;
+  setSubscriptionLogoutConfirmationTarget(value: string | null): void;
+}
+
+export function handleSubscriptionLogoutKey(
+  ctx: HandleSubscriptionLogoutKeyContext,
+  key: string,
+): 'confirmed' | 'cancelled' | 'absorbed' | 'inactive' {
+  const target = ctx.subscriptionLogoutConfirmationTarget;
+  if (!target) return 'inactive';
+  const confirmState = { subject: target, label: target };
+  const result = handleConfirmInput(confirmState, key);
+  if (result === 'confirmed') {
+    ctx.subscriptionManager?.logout(target);
+    ctx.setSubscriptionEntries(buildSubscriptionEntries(ctx.subscriptionManager, ctx.serviceRegistry));
+    ctx.setSubscriptionLogoutConfirmationTarget(null);
+  } else if (result === 'cancelled') {
+    ctx.setSubscriptionLogoutConfirmationTarget(null);
+  }
+  // 'absorbed': confirm remains pending
+  return result;
+}
+
+// Re-export FlagEntry so callers need not import from two modules.
+export type { FlagEntry };

package/src/input/settings-modal-adjustment.ts

@@ -0,0 +1,124 @@
+/**
+ * settings-modal-adjustment — pure adjustment helpers for SettingsModal.
+ *
+ * These functions encapsulate the two directional-adjustment operations:
+ *   - adjustSelected: cycle enum/boolean/number values via left/right arrow keys
+ *   - toggleSelectedFlag: toggle a feature flag between enabled and disabled
+ *
+ * Each function takes its dependencies as explicit arguments rather than
+ * accessing class-level state directly, following the same pattern as
+ * settings-modal-reset.ts and settings-modal-mutations.ts.
+ */
+
+import type { ConfigKey } from '@pellux/goodvibes-sdk/platform/config';
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import type { FeatureFlagManager } from '@/runtime/index.ts';
+import type { FlagState } from '@/runtime/index.ts';
+import type { FlagEntry, McpEntry, SettingEntry } from './settings-modal-types.ts';
+import { buildMcpEntries } from './settings-modal-data.ts';
+import { getNumericAdjustmentMeta, roundToPrecision } from './settings-modal-behavior.ts';
+import { applyFlagState } from './settings-modal-mutations.ts';
+import type { McpRegistry } from '@pellux/goodvibes-sdk/platform/mcp';
+
+// ---------------------------------------------------------------------------
+// adjustSelected
+// ---------------------------------------------------------------------------
+
+export interface AdjustSelectedContext {
+  readonly editingMode: boolean;
+  readonly currentCategory: string;
+  readonly configManager: ConfigManager | null;
+  readonly featureFlagManager: FeatureFlagManager | null;
+  readonly mcpRegistry: McpRegistry | null;
+  getSelectedFlag(): FlagEntry | null;
+  getSelectedMcp(): McpEntry | null;
+  getSelected(): SettingEntry | null;
+  setValue(key: ConfigKey, value: unknown): void;
+  setMcpEntries(entries: McpEntry[]): void;
+  setMcpAllowAllConfirmationTarget(value: string | null): void;
+}
+
+export function adjustSelected(
+  ctx: AdjustSelectedContext,
+  direction: 'left' | 'right',
+  step = 1,
+): void {
+  if (ctx.editingMode) return;
+
+  if (ctx.currentCategory === 'flags') {
+    const flagEntry = ctx.getSelectedFlag();
+    if (!flagEntry || flagEntry.state === 'killed' || !ctx.featureFlagManager || !ctx.configManager) return;
+    const targetState: FlagState = direction === 'right' ? 'enabled' : 'disabled';
+    if (flagEntry.state !== targetState) applyFlagState(flagEntry, targetState, ctx.featureFlagManager, ctx.configManager);
+    return;
+  }
+
+  if (ctx.currentCategory === 'mcp') {
+    const entry = ctx.getSelectedMcp();
+    if (!entry || !ctx.mcpRegistry) return;
+    const modes: McpEntry['trustMode'][] = ['constrained', 'ask-on-risk', 'allow-all', 'blocked'];
+    const currentIndex = Math.max(0, modes.indexOf(entry.trustMode));
+    const nextIndex = direction === 'right'
+      ? (currentIndex + 1) % modes.length
+      : (currentIndex - 1 + modes.length) % modes.length;
+    ctx.mcpRegistry.setServerTrustMode(entry.name, modes[nextIndex]!);
+    ctx.setMcpEntries(buildMcpEntries(ctx.mcpRegistry));
+    ctx.setMcpAllowAllConfirmationTarget(null);
+    return;
+  }
+
+  const entry = ctx.getSelected();
+  if (!entry || !ctx.configManager) return;
+  const { setting } = entry;
+
+  if (setting.type === 'boolean') {
+    ctx.setValue(setting.key as ConfigKey, direction === 'right');
+    return;
+  }
+
+  if (setting.type === 'enum' && setting.enumValues && setting.enumValues.length > 0) {
+    const currentIndex = Math.max(0, setting.enumValues.indexOf(String(entry.currentValue)));
+    const nextIndex = direction === 'right'
+      ? (currentIndex + 1) % setting.enumValues.length
+      : (currentIndex - 1 + setting.enumValues.length) % setting.enumValues.length;
+    ctx.setValue(setting.key as ConfigKey, setting.enumValues[nextIndex]!);
+    return;
+  }
+
+  if (setting.type === 'number') {
+    const currentNumber = Number(entry.currentValue ?? 0);
+    if (!Number.isFinite(currentNumber)) return;
+    const adjustment = getNumericAdjustmentMeta(setting);
+    const delta = adjustment.step * step;
+    const rounded = roundToPrecision(currentNumber + (direction === 'right' ? delta : -delta), adjustment.precision);
+    const nextValue = Math.min(
+      adjustment.max ?? rounded,
+      Math.max(adjustment.min ?? rounded, rounded),
+    );
+    if (setting.validate && !setting.validate(nextValue)) return;
+    ctx.setValue(setting.key as ConfigKey, nextValue);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// toggleSelectedFlag
+// ---------------------------------------------------------------------------
+
+export interface ToggleSelectedFlagContext {
+  readonly featureFlagManager: FeatureFlagManager | null;
+  readonly configManager: ConfigManager | null;
+  getSelectedFlag(): FlagEntry | null;
+}
+
+export function toggleSelectedFlag(ctx: ToggleSelectedFlagContext): void {
+  const flagEntry = ctx.getSelectedFlag();
+  if (!flagEntry || !ctx.featureFlagManager || !ctx.configManager) return;
+
+  const { state } = flagEntry;
+
+  // Killed flags are blocked
+  if (state === 'killed') return;
+
+  const newState: FlagState = state === 'enabled' ? 'disabled' : 'enabled';
+  applyFlagState(flagEntry, newState, ctx.featureFlagManager, ctx.configManager);
+}