@pellux/goodvibes-tui 0.22.0 → 0.24.0

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);
+}

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

@@ -122,6 +122,14 @@ export function buildSettingGroups(
     ttsEntries.push(buildTtsSpeedSyntheticEntry(configManager));
   }
 
+  // Inject the synthetic behavior.notifyAfterSeconds entry into the behavior
+  // category. This key is TUI-local (not in the SDK ConfigKey union) and
+  // controls the long-task push notification threshold.
+  const behaviorEntries = groups.get('behavior');
+  if (behaviorEntries && !behaviorEntries.some((e) => e.setting.key === ('behavior.notifyAfterSeconds' as ConfigKey))) {
+    behaviorEntries.push(buildNotifyAfterSecondsSyntheticEntry(configManager));
+  }
+
   return groups;
 }
 
@@ -171,6 +179,51 @@ export function buildTtsSpeedSyntheticEntry(configManager: Pick<ConfigManager, '
   };
 }
 
+// ---------------------------------------------------------------------------
+// behavior.notifyAfterSeconds synthetic setting
+// ---------------------------------------------------------------------------
+
+/** Default threshold in seconds for the synthetic notifyAfterSeconds setting. */
+export const NOTIFY_AFTER_SECONDS_DEFAULT_SETTING = 60;
+
+/**
+ * The synthetic ConfigSetting descriptor for behavior.notifyAfterSeconds.
+ *
+ * This key is TUI-local and is not yet in the SDK ConfigKey union. The
+ * descriptor is injected into the behavior settings group so users can
+ * configure the long-task push notification threshold from /config behavior.
+ *
+ * 0 = off (no notifications). Any positive integer = threshold in seconds.
+ * Default 60s matches the default in long-task-notifier.ts.
+ *
+ * The key is cast to ConfigKey because ConfigSetting requires it. The cast
+ * is safe: configManager.get returns undefined for unknown keys rather than
+ * throwing.
+ */
+export const NOTIFY_AFTER_SECONDS_SYNTHETIC_SETTING: ConfigSetting = {
+  key: 'behavior.notifyAfterSeconds' as ConfigKey,
+  type: 'number',
+  default: NOTIFY_AFTER_SECONDS_DEFAULT_SETTING,
+  description: 'Seconds a turn must run before a push notification fires (0 = off). Delivers to desktop (notify-send/osascript) and configured ntfy/webhook URLs.',
+};
+
+/**
+ * Build the synthetic SettingEntry for behavior.notifyAfterSeconds.
+ *
+ * Reads the raw value from configManager using a cast key. Falls back to
+ * NOTIFY_AFTER_SECONDS_DEFAULT_SETTING when absent or invalid.
+ */
+export function buildNotifyAfterSecondsSyntheticEntry(configManager: Pick<ConfigManager, 'get'>): SettingEntry {
+  const raw = configManager.get('behavior.notifyAfterSeconds' as ConfigKey);
+  const parsed = typeof raw === 'number' ? raw : parseFloat(String(raw ?? ''));
+  const currentValue: number = Number.isFinite(parsed) && parsed >= 0 ? Math.round(parsed) : NOTIFY_AFTER_SECONDS_DEFAULT_SETTING;
+  return {
+    setting: NOTIFY_AFTER_SECONDS_SYNTHETIC_SETTING,
+    currentValue,
+    isDefault: currentValue === NOTIFY_AFTER_SECONDS_DEFAULT_SETTING,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // buildFlagEntries — snapshot of current feature flag states
 // ---------------------------------------------------------------------------

package/src/input/settings-modal.ts

@@ -14,23 +14,16 @@
  */
 
 import { type ConfigKey } from '@pellux/goodvibes-sdk/platform/config';
-import { handleConfirmInput } from '../panels/confirm-state.ts';
 import type { ModelPickerTarget } from './model-picker.ts';
 import type { ConfigManager } 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 { isSecretConfigKey } from '../config/secret-config.ts';
-import {
-  getNumericAdjustmentMeta,
-  modelPickerLaunchForKey,
-  roundToPrecision,
-} from './settings-modal-behavior.ts';
 import {
   setSecretBackedSettingValue,
   type SettingsSecretsManager,
 } from './settings-modal-secrets.ts';
 import type { FeatureFlagManager } from '@/runtime/index.ts';
-import type { FlagState } from '@/runtime/index.ts';
 import type { McpRegistry } from '@pellux/goodvibes-sdk/platform/mcp';
 
 import {
@@ -50,16 +43,21 @@ import {
   buildSubscriptionEntries,
   buildNetworkFilteredItems,
   refreshEntryValues,
-  updateEntryForKey,
   searchSettingEntries,
 } from './settings-modal-data.ts';
 import { getSettingLabel } from '../renderer/settings-modal-helpers.ts';
 import {
   applySettingValue,
-  applyFlagState,
-  persistFlagState,
   type SettingAppliedCallback,
 } from './settings-modal-mutations.ts';
+import {
+  activateSelected as _activateSelected,
+  handleSubscriptionLogoutKey as _handleSubscriptionLogoutKey,
+} from './settings-modal-activation.ts';
+import {
+  adjustSelected as _adjustSelected,
+  toggleSelectedFlag as _toggleSelectedFlag,
+} from './settings-modal-adjustment.ts';
 import {
   resetSelected as _resetSelected,
   initiateResetCategory as _initiateResetCategory,
@@ -436,63 +434,21 @@ export class SettingsModal {
    * Toggle boolean or begin cycling enum values, or enter edit mode for string/number.
    */
   activateSelected(): void {
-    if (this.currentCategory === 'mcp') {
-      const entry = this.getSelectedMcp();
-      if (!entry) return;
-      this.editingMode = true;
-      this.editBuffer = entry.trustMode;
-      this.mcpAllowAllConfirmationTarget = null;
-      return;
-    }
-
-    if (this.currentCategory === 'subscriptions') {
-      const entry = this.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.
-        this.subscriptionLogoutConfirmationTarget = entry.provider;
-      }
-      return;
-    }
-
-    const entry = this.getSelected();
-    if (!entry || !this.configManager) return;
-
-    const { setting } = entry;
-
-    // Delegate provider/model picker settings to the model picker UI
-    if (setting.key === 'tts.provider') {
-      this.pendingSettingsPickerAction = 'tts-provider';
-      return;
-    }
-    if (setting.key === 'tts.voice') {
-      this.pendingSettingsPickerAction = 'tts-voice';
-      return;
-    }
-
-    const pickerLaunch = modelPickerLaunchForKey(setting.key);
-    if (pickerLaunch !== null) {
-      if (pickerLaunch.flow === 'providerModel') {
-        this.pendingProviderModelPickerTarget = pickerLaunch.target;
-      } else {
-        this.pendingModelPickerTarget = pickerLaunch.target;
-      }
-      return;
-    }
-
-    if (setting.type === 'boolean') {
-      const newVal = !entry.currentValue;
-      this._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;
-      this._setValue(setting.key as ConfigKey, setting.enumValues[nextIdx]);
-    } else if (setting.type === 'string' || setting.type === 'number') {
-      // Enter inline edit mode
-      this.editingMode = true;
-      this.editBuffer = String(entry.currentValue ?? '');
-    }
+    _activateSelected({
+      currentCategory: this.currentCategory,
+      configManager: this.configManager,
+      getSelectedMcp: () => this.getSelectedMcp(),
+      getSelectedSubscription: () => this.getSelectedSubscription(),
+      getSelected: () => this.getSelected(),
+      setValue: (key, value) => this._setValue(key, value),
+      setEditingMode: (v) => { this.editingMode = v; },
+      setEditBuffer: (v) => { this.editBuffer = v; },
+      setMcpAllowAllConfirmationTarget: (v) => { this.mcpAllowAllConfirmationTarget = v; },
+      setSubscriptionLogoutConfirmationTarget: (v) => { this.subscriptionLogoutConfirmationTarget = v; },
+      setPendingSettingsPickerAction: (v) => { this.pendingSettingsPickerAction = v; },
+      setPendingModelPickerTarget: (v) => { this.pendingModelPickerTarget = v; },
+      setPendingProviderModelPickerTarget: (v) => { this.pendingProviderModelPickerTarget = v; },
+    });
   }
 
   /**
@@ -505,77 +461,29 @@ export class SettingsModal {
    *   - INACTIVE: no confirm pending   → returns 'inactive' (caller continues)
    */
   handleSubscriptionLogoutKey(key: string): 'confirmed' | 'cancelled' | 'absorbed' | 'inactive' {
-    const target = this.subscriptionLogoutConfirmationTarget;
-    if (!target) return 'inactive';
-    const confirmState = { subject: target, label: target };
-    const result = handleConfirmInput(confirmState, key);
-    if (result === 'confirmed') {
-      this.subscriptionManager?.logout(target);
-      this.subscriptionEntries = buildSubscriptionEntries(this.subscriptionManager, this.serviceRegistry);
-      this.subscriptionLogoutConfirmationTarget = null;
-    } else if (result === 'cancelled') {
-      this.subscriptionLogoutConfirmationTarget = null;
-    }
-    // 'absorbed': confirm remains pending
-    return result;
+    return _handleSubscriptionLogoutKey({
+      subscriptionLogoutConfirmationTarget: this.subscriptionLogoutConfirmationTarget,
+      subscriptionManager: this.subscriptionManager,
+      serviceRegistry: this.serviceRegistry,
+      setSubscriptionEntries: (entries) => { this.subscriptionEntries = entries; },
+      setSubscriptionLogoutConfirmationTarget: (v) => { this.subscriptionLogoutConfirmationTarget = v; },
+    }, key);
   }
 
   adjustSelected(direction: 'left' | 'right', step = 1): void {
-    if (this.editingMode) return;
-
-    if (this.currentCategory === 'flags') {
-      const flagEntry = this.getSelectedFlag();
-      if (!flagEntry || flagEntry.state === 'killed' || !this.featureFlagManager || !this.configManager) return;
-      const targetState: FlagState = direction === 'right' ? 'enabled' : 'disabled';
-      if (flagEntry.state !== targetState) applyFlagState(flagEntry, targetState, this.featureFlagManager, this.configManager);
-      return;
-    }
-
-    if (this.currentCategory === 'mcp') {
-      const entry = this.getSelectedMcp();
-      if (!entry || !this.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;
-      this.mcpRegistry.setServerTrustMode(entry.name, modes[nextIndex]!);
-      this.mcpEntries = buildMcpEntries(this.mcpRegistry);
-      this.mcpAllowAllConfirmationTarget = null;
-      return;
-    }
-
-    const entry = this.getSelected();
-    if (!entry || !this.configManager) return;
-    const { setting } = entry;
-
-    if (setting.type === 'boolean') {
-      this._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;
-      this._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;
-      this._setValue(setting.key as ConfigKey, nextValue);
-    }
+    _adjustSelected({
+      editingMode: this.editingMode,
+      currentCategory: this.currentCategory,
+      configManager: this.configManager,
+      featureFlagManager: this.featureFlagManager,
+      mcpRegistry: this.mcpRegistry,
+      getSelectedFlag: () => this.getSelectedFlag(),
+      getSelectedMcp: () => this.getSelectedMcp(),
+      getSelected: () => this.getSelected(),
+      setValue: (key, value) => this._setValue(key, value),
+      setMcpEntries: (entries) => { this.mcpEntries = entries; },
+      setMcpAllowAllConfirmationTarget: (v) => { this.mcpAllowAllConfirmationTarget = v; },
+    }, direction, step);
   }
 
   /**
@@ -585,16 +493,11 @@ export class SettingsModal {
    * only (require restart). runtimeToggleable flags toggle immediately.
    */
   toggleSelectedFlag(): void {
-    const flagEntry = this.getSelectedFlag();
-    if (!flagEntry || !this.featureFlagManager || !this.configManager) return;
-
-    const { state } = flagEntry;
-
-    // Killed flags are blocked
-    if (state === 'killed') return;
-
-    const newState: FlagState = state === 'enabled' ? 'disabled' : 'enabled';
-    applyFlagState(flagEntry, newState, this.featureFlagManager, this.configManager);
+    _toggleSelectedFlag({
+      featureFlagManager: this.featureFlagManager,
+      configManager: this.configManager,
+      getSelectedFlag: () => this.getSelectedFlag(),
+    });
   }
 
   /**