@pellux/goodvibes-tui 0.21.0 → 0.23.0

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

@@ -7,7 +7,7 @@
  */
 
 import { CONFIG_SCHEMA, type ConfigKey } from '@pellux/goodvibes-sdk/platform/config';
-import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
+import type { ConfigManager, ConfigSetting } from '@pellux/goodvibes-sdk/platform/config';
 import { getResolvedSettingLookup } from '@/runtime/index.ts';
 import type { FeatureFlagManager } from '@/runtime/index.ts';
 import type { McpRegistry } from '@pellux/goodvibes-sdk/platform/mcp';
@@ -114,9 +114,63 @@ export function buildSettingGroups(
     }
   }
 
+  // Inject the synthetic tts.speed entry into the tts category.
+  // tts.speed is not yet a ConfigKey in the SDK schema (pending SDK addition).
+  // The entry is surfaced here with an honest description caveat so users can
+  // see and understand the setting before the SDK schema catches up.
+  if (ttsEntries && !ttsEntries.some((e) => e.setting.key === ('tts.speed' as ConfigKey))) {
+    ttsEntries.push(buildTtsSpeedSyntheticEntry(configManager));
+  }
+
   return groups;
 }
 
+// ---------------------------------------------------------------------------
+// TTS_SPEED_DEFAULT — the pending-SDK default for tts.speed
+// ---------------------------------------------------------------------------
+
+/**
+ * Pending default for tts.speed. Matches the value the SDK will use once
+ * the schema field is added: 1 (normal speed, provider default).
+ * Used for the synthetic settings-modal entry and isDefault comparisons.
+ */
+export const TTS_SPEED_DEFAULT = 1;
+
+/**
+ * The synthetic ConfigSetting descriptor for tts.speed.
+ * `tts.speed` is not yet a ConfigKey in the SDK schema. This descriptor is
+ * TUI-local and is injected into the tts settings group so users can see
+ * and interact with the setting before the SDK schema catches up.
+ *
+ * The key is cast to ConfigKey because ConfigSetting requires it and the SDK
+ * will add this key in a future release. The cast is safe: configManager.get
+ * returns undefined for unknown keys rather than throwing.
+ */
+export const TTS_SPEED_SYNTHETIC_SETTING: ConfigSetting = {
+  key: 'tts.speed' as ConfigKey,
+  type: 'number',
+  default: TTS_SPEED_DEFAULT,
+  description: 'Playback speed multiplier passed to the TTS provider (1.0 = normal). Takes effect immediately via the TUI bridge; SDK schema registration is pending (native typing only).',
+};
+
+/**
+ * Build the synthetic SettingEntry for tts.speed.
+ *
+ * Reads the raw value from configManager using a cast key (tts.speed is not
+ * yet a valid ConfigKey). If the value is absent or not a positive finite
+ * number, falls back to TTS_SPEED_DEFAULT and marks isDefault true.
+ */
+export function buildTtsSpeedSyntheticEntry(configManager: Pick<ConfigManager, 'get'>): SettingEntry {
+  const raw = configManager.get('tts.speed' as ConfigKey);
+  const parsed = typeof raw === 'number' ? raw : parseFloat(String(raw ?? ''));
+  const currentValue: number = isFinite(parsed) && parsed > 0 ? parsed : TTS_SPEED_DEFAULT;
+  return {
+    setting: TTS_SPEED_SYNTHETIC_SETTING,
+    currentValue,
+    isDefault: deepEqual(currentValue, TTS_SPEED_DEFAULT),
+  };
+}
+
 // ---------------------------------------------------------------------------
 // buildFlagEntries — snapshot of current feature flag states
 // ---------------------------------------------------------------------------
@@ -177,13 +231,31 @@ export function buildNetworkFilteredItems(
 // refreshEntryValues — re-reads currentValue/isDefault for all loaded entries
 // ---------------------------------------------------------------------------
 
+/**
+ * Normalize a raw config value for the tts.speed synthetic entry.
+ * Returns the raw value if it is a positive finite number, otherwise falls
+ * back to TTS_SPEED_DEFAULT. Mirrors the logic in buildTtsSpeedSyntheticEntry.
+ */
+function normalizeTtsSpeedValue(raw: unknown): number {
+  const parsed = typeof raw === 'number' ? raw : parseFloat(String(raw ?? ''));
+  return isFinite(parsed) && parsed > 0 ? parsed : TTS_SPEED_DEFAULT;
+}
+
 export function refreshEntryValues(
   groups: Map<SettingsCategory, SettingEntry[]>,
   configManager: ConfigManager,
 ): void {
   for (const entries of groups.values()) {
     for (const entry of entries) {
-      entry.currentValue = configManager.get(entry.setting.key as ConfigKey);
+      const raw = configManager.get(entry.setting.key as ConfigKey);
+      // Synthetic entries (e.g. tts.speed) that have no SDK schema key return
+      // undefined from configManager. Normalize using the same logic used at
+      // construction time so isDefault stays accurate.
+      if (entry.setting.key === ('tts.speed' as ConfigKey)) {
+        entry.currentValue = normalizeTtsSpeedValue(raw);
+      } else {
+        entry.currentValue = raw;
+      }
       entry.isDefault = deepEqual(entry.currentValue, entry.setting.default);
     }
   }
@@ -201,7 +273,9 @@ export function updateEntryForKey(
   for (const entries of groups.values()) {
     const entry = entries.find((candidate) => candidate.setting.key === key);
     if (entry) {
-      entry.currentValue = configManager.get(key);
+      const raw = configManager.get(key);
+      // Synthetic tts.speed entry: normalize using the same fallback logic.
+      entry.currentValue = key === ('tts.speed' as ConfigKey) ? normalizeTtsSpeedValue(raw) : raw;
       entry.isDefault = deepEqual(entry.currentValue, entry.setting.default);
     }
   }

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

@@ -55,6 +55,9 @@ export function applySettingValue({
   refreshGroups: () => void;
 }): ApplyValueResult {
   const previousValue = configManager.get(key);
+  // REQUIRES_RESTART: SDK's ConfigSetting has no requiresRestart field yet (see
+  // goodvibes-sdk HANDOFF-FROM-TUI-SESSION-20260611.md §Item 8). Until it does,
+  // we detect restart-triggering keys by sub-key name heuristic below.
   const isRestartKey = ['host', 'port', 'hostMode', 'enabled'].includes(key.split('.')[1] ?? '');
 
   try {

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

@@ -0,0 +1,154 @@
+/**
+ * settings-modal-reset — pure reset helpers for SettingsModal.
+ *
+ * These functions encapsulate the three reset operations:
+ *   - resetSelected: reset the currently selected setting to its schema default
+ *   - initiateResetCategory: arm the category-reset confirmation gate
+ *   - initiateResetAll: arm the reset-all confirmation gate
+ *   - handleResetConfirmKey: route a keypress through the active gate
+ *
+ * Each function takes its dependencies as explicit arguments rather than
+ * accessing class-level state. resetCategoryConfirm and resetAllConfirm
+ * remain public class fields on SettingsModal — the renderer reads them
+ * directly to decide the footer state.
+ */
+
+import type { ConfigKey } from '@pellux/goodvibes-sdk/platform/config';
+import { logger, summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { buildGoodVibesSecretKey, isSecretConfigKey } from '../config/secret-config.ts';
+import type { SettingEntry, SettingsCategory } from './settings-modal-types.ts';
+import type { SettingsSecretsManager } from './settings-modal-secrets.ts';
+
+// ---------------------------------------------------------------------------
+// resetSelected
+// ---------------------------------------------------------------------------
+
+export function resetSelected({
+  editingMode,
+  hasConfigManager,
+  selected,
+  secretsManager,
+  setValue,
+}: {
+  editingMode: boolean;
+  hasConfigManager: boolean;
+  selected: SettingEntry | null;
+  secretsManager: SettingsSecretsManager | null;
+  setValue: (key: ConfigKey, value: unknown) => void;
+}): { key: ConfigKey; value: unknown } | null {
+  if (editingMode || !hasConfigManager) return null;
+  if (!selected) return null;
+  const key = selected.setting.key as ConfigKey;
+  setValue(key, selected.setting.default);
+  if (isSecretConfigKey(key) && secretsManager) {
+    void secretsManager.delete(buildGoodVibesSecretKey(key), { scope: 'user' }).catch((error) => {
+      logger.error('SettingsModal: failed to clear secret while resetting setting', { key, error: summarizeError(error) });
+    });
+  }
+  return { key, value: selected.setting.default };
+}
+
+// ---------------------------------------------------------------------------
+// initiateResetCategory
+// ---------------------------------------------------------------------------
+
+export function initiateResetCategory({
+  hasConfigManager,
+  currentCategory,
+  setResetCategoryConfirm,
+  setResetAllConfirm,
+}: {
+  hasConfigManager: boolean;
+  currentCategory: string;
+  setResetCategoryConfirm: (value: { readonly subject: string } | null) => void;
+  setResetAllConfirm: (value: { readonly subject: 'all' } | null) => void;
+}): void {
+  if (!hasConfigManager) return;
+  setResetCategoryConfirm({ subject: currentCategory });
+  setResetAllConfirm(null);
+}
+
+// ---------------------------------------------------------------------------
+// initiateResetAll
+// ---------------------------------------------------------------------------
+
+export function initiateResetAll({
+  hasConfigManager,
+  setResetCategoryConfirm,
+  setResetAllConfirm,
+}: {
+  hasConfigManager: boolean;
+  setResetCategoryConfirm: (value: { readonly subject: string } | null) => void;
+  setResetAllConfirm: (value: { readonly subject: 'all' } | null) => void;
+}): void {
+  if (!hasConfigManager) return;
+  setResetAllConfirm({ subject: 'all' });
+  setResetCategoryConfirm(null);
+}
+
+// ---------------------------------------------------------------------------
+// handleResetConfirmKey
+// ---------------------------------------------------------------------------
+
+export type ResetConfirmKeyResult =
+  | { result: 'confirmed'; entries: ReadonlyArray<{ key: string; value: unknown }> }
+  | 'cancelled'
+  | 'absorbed'
+  | 'inactive';
+
+export function handleResetConfirmKey({
+  key,
+  resetCategoryConfirm,
+  resetAllConfirm,
+  hasConfigManager,
+  currentItems,
+  groups,
+  setValue,
+  setResetCategoryConfirm,
+  setResetAllConfirm,
+}: {
+  key: string;
+  resetCategoryConfirm: { readonly subject: string } | null;
+  resetAllConfirm: { readonly subject: 'all' } | null;
+  hasConfigManager: boolean;
+  currentItems: () => SettingEntry[];
+  groups: Map<SettingsCategory, SettingEntry[]>;
+  setValue: (key: ConfigKey, value: unknown) => void;
+  setResetCategoryConfirm: (value: { readonly subject: string } | null) => void;
+  setResetAllConfirm: (value: { readonly subject: 'all' } | null) => void;
+}): ResetConfirmKeyResult {
+  const gate = resetCategoryConfirm ?? resetAllConfirm;
+  if (!gate || !hasConfigManager) return 'inactive';
+
+  if (key === 'enter' || key === 'y') {
+    const entries: Array<{ key: string; value: unknown }> = [];
+    if (resetCategoryConfirm) {
+      // Reset all settings in the current category to defaults.
+      const items = currentItems();
+      for (const item of items) {
+        setValue(item.setting.key as ConfigKey, item.setting.default);
+        entries.push({ key: item.setting.key, value: item.setting.default });
+      }
+      setResetCategoryConfirm(null);
+    } else {
+      // Reset ALL settings across all categories to defaults.
+      for (const [, items] of groups) {
+        for (const item of items) {
+          setValue(item.setting.key as ConfigKey, item.setting.default);
+          entries.push({ key: item.setting.key, value: item.setting.default });
+        }
+      }
+      setResetAllConfirm(null);
+    }
+    return { result: 'confirmed', entries };
+  }
+
+  if (key === 'escape' || key === 'n') {
+    setResetCategoryConfirm(null);
+    setResetAllConfirm(null);
+    return 'cancelled';
+  }
+
+  // All other keys are absorbed while the gate is active.
+  return 'absorbed';
+}

package/src/input/settings-modal.ts

@@ -19,7 +19,7 @@ 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 { buildGoodVibesSecretKey, isSecretConfigKey } from '../config/secret-config.ts';
+import { isSecretConfigKey } from '../config/secret-config.ts';
 import {
   getNumericAdjustmentMeta,
   modelPickerLaunchForKey,
@@ -32,7 +32,7 @@ import {
 import type { FeatureFlagManager } from '@/runtime/index.ts';
 import type { FlagState } from '@/runtime/index.ts';
 import type { McpRegistry } from '@pellux/goodvibes-sdk/platform/mcp';
-import { logger, summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+
 import {
   SETTINGS_CATEGORIES,
   SETTINGS_CATEGORY_GROUPS,
@@ -60,6 +60,13 @@ import {
   persistFlagState,
   type SettingAppliedCallback,
 } from './settings-modal-mutations.ts';
+import {
+  resetSelected as _resetSelected,
+  initiateResetCategory as _initiateResetCategory,
+  initiateResetAll as _initiateResetAll,
+  handleResetConfirmKey as _handleResetConfirmKey,
+  type ResetConfirmKeyResult,
+} from './settings-modal-reset.ts';
 
 export interface SettingsModalChange {
   readonly key: ConfigKey;
@@ -124,6 +131,11 @@ export class SettingsModal {
   /** Provider awaiting explicit logout confirmation, if any. */
   public subscriptionLogoutConfirmationTarget: string | null = null;
 
+  /** Pending category-reset confirmation gate, or null when inactive. */
+  public resetCategoryConfirm: { readonly subject: string } | null = null;
+  /** Pending reset-all confirmation gate, or null when inactive. */
+  public resetAllConfirm: { readonly subject: 'all' } | null = null;
+
   /** Settings grouped by category. */
   public groups: Map<SettingsCategory, SettingEntry[]> = new Map();
 
@@ -674,17 +686,47 @@ export class SettingsModal {
   }
 
   resetSelected(): { key: ConfigKey; value: unknown } | null {
-    if (this.editingMode || !this.configManager) return null;
-    const entry = this.getSelected();
-    if (!entry) return null;
-    const key = entry.setting.key as ConfigKey;
-    this._setValue(key, entry.setting.default);
-    if (isSecretConfigKey(key) && this.secretsManager) {
-      void this.secretsManager.delete(buildGoodVibesSecretKey(key), { scope: 'user' }).catch((error) => {
-        logger.error('SettingsModal: failed to clear secret while resetting setting', { key, error: summarizeError(error) });
-      });
-    }
-    return { key, value: entry.setting.default };
+    return _resetSelected({
+      editingMode: this.editingMode,
+      hasConfigManager: this.configManager !== null,
+      selected: this.getSelected(),
+      secretsManager: this.secretsManager,
+      setValue: (key, value) => this._setValue(key, value),
+    });
+  }
+
+  /** Arm a category-reset confirmation gate for the current category. */
+  initiateResetCategory(): void {
+    _initiateResetCategory({
+      hasConfigManager: this.configManager !== null,
+      currentCategory: this.currentCategory,
+      setResetCategoryConfirm: (v) => { this.resetCategoryConfirm = v; },
+      setResetAllConfirm: (v) => { this.resetAllConfirm = v; },
+    });
+  }
+
+  /** Arm a reset-all confirmation gate. */
+  initiateResetAll(): void {
+    _initiateResetAll({
+      hasConfigManager: this.configManager !== null,
+      setResetCategoryConfirm: (v) => { this.resetCategoryConfirm = v; },
+      setResetAllConfirm: (v) => { this.resetAllConfirm = v; },
+    });
+  }
+
+  /** Route a key through the active reset confirm gate. See ResetConfirmKeyResult for the return contract. */
+  handleResetConfirmKey(key: string): ResetConfirmKeyResult {
+    return _handleResetConfirmKey({
+      key,
+      resetCategoryConfirm: this.resetCategoryConfirm,
+      resetAllConfirm: this.resetAllConfirm,
+      hasConfigManager: this.configManager !== null,
+      currentItems: () => this._currentItems(),
+      groups: this.groups,
+      setValue: (k, value) => this._setValue(k, value),
+      setResetCategoryConfirm: (v) => { this.resetCategoryConfirm = v; },
+      setResetAllConfirm: (v) => { this.resetAllConfirm = v; },
+    });
   }
 
   /** Handle a keystroke in edit mode: regular chars appended, Backspace removes last char. */

package/src/main.ts

@@ -33,12 +33,10 @@ import { renderPanelTabBar } from './renderer/panel-tab-bar.ts';
 import { bootstrapRuntime } from './runtime/bootstrap.ts';
 import type { BootstrapContext } from './runtime/bootstrap.ts';
 import type { HITLMode } from '@pellux/goodvibes-sdk/platform/state';
-import type { HookPhase, HookCategory, HookEventPath } from '@pellux/goodvibes-sdk/platform/hooks';
 import {
   checkRecoveryFile,
   deleteRecoveryFile,
   loadRecoveryConversation,
-  persistConversation,
   writeRecoveryFile,
 } from '@/runtime/index.ts';
 import { handleBlockingShellInput, type PendingPermissionState } from './shell/blocking-input.ts';
@@ -56,19 +54,16 @@ import { allowTerminalWrite, installTuiTerminalOutputGuard } from './runtime/ter
 import { buildCommandArgsHint } from './input/command-args-hint.ts';
 import { summarizeRunningAgents } from './renderer/process-summary.ts';
 import { formatUserFacingErrorLine } from './core/format-user-error.ts';
-import { wireStreamEventMetrics, type StreamMetrics } from './core/stream-event-wiring.ts';
-
-const ALT_SCREEN_ENTER = '\x1b[?1049h';
-const ALT_SCREEN_EXIT  = '\x1b[?1049l';
-const MOUSE_ENABLE     = '\x1b[?1000h\x1b[?1002h\x1b[?1006h';
-const MOUSE_DISABLE    = '\x1b[?1006l\x1b[?1002l\x1b[?1000l';
-const CURSOR_HIDE      = '\x1b[?25l';
-const CURSOR_SHOW      = '\x1b[?25h';
-const CLEAR_SCREEN     = '\x1b[2J\x1b[3J\x1b[H';
-const KEYBOARD_EXT_ENABLE  = '\x1b[>4;2m' + '\x1b[?1u';
-const KEYBOARD_EXT_DISABLE = '\x1b[>4;0m' + '\x1b[?1l';
-const PASTE_ENABLE     = '\x1b[?2004h';
-const PASTE_DISABLE    = '\x1b[?2004l';
+import { wireStreamEventMetrics, type StreamMetrics, type WireStreamEventMetricsResult } from './core/stream-event-wiring.ts';
+import { wireTurnEventHandlers } from './core/turn-event-wiring.ts';
+import { buildContextStatusHint } from './renderer/context-status-hint.ts';
+import { evaluateSessionMaintenance } from './panels/session-maintenance.ts';
+
+const ALT_SCREEN_ENTER = '\x1b[?1049h'; const ALT_SCREEN_EXIT  = '\x1b[?1049l';
+const MOUSE_ENABLE     = '\x1b[?1000h\x1b[?1002h\x1b[?1006h'; const MOUSE_DISABLE    = '\x1b[?1006l\x1b[?1002l\x1b[?1000l';
+const CURSOR_HIDE      = '\x1b[?25l'; const CURSOR_SHOW = '\x1b[?25h'; const CLEAR_SCREEN = '\x1b[2J\x1b[3J\x1b[H';
+const KEYBOARD_EXT_ENABLE  = '\x1b[>4;2m' + '\x1b[?1u'; const KEYBOARD_EXT_DISABLE = '\x1b[>4;0m' + '\x1b[?1l';
+const PASTE_ENABLE = '\x1b[?2004h'; const PASTE_DISABLE = '\x1b[?2004l';
 
 async function main() {
   const stdout = process.stdout;
@@ -104,6 +99,7 @@ async function main() {
     permissionPromptRef,
     _writeLastSessionPointer: writeLastSessionPointer,
     systemMessageRouter,
+    setOpenAgentDetail,
   } = ctx;
   const workingDir = ctx.services.workingDirectory;
   const homeDirectory = ctx.services.homeDirectory;
@@ -313,10 +309,11 @@ async function main() {
     }
     if (processedText || content) {
       void (async () => {
-        let inputOptions = options.spokenOutput ? createSpokenTurnInputOptions() : undefined;
-        if (options.spokenOutput && processedText) {
-          spokenTurns.submitNextTurn(processedText);
-        }
+        const inputOptions = options.spokenOutput ? createSpokenTurnInputOptions() : undefined;
+        if (options.spokenOutput && processedText) { spokenTurns.submitNextTurn(processedText); }
+        // Snapshot pre-submission state for failover retryTurn; also clears visited set.
+        retryCtx = { count: conversation.getMessageCount(), text: processedText, content, opts: inputOptions };
+        streamResult.clearFailoverVisited();
         orchestrator.handleUserInput(processedText, content, inputOptions).catch((err: unknown) => {
           logger.debug('handleUserInput safety catch (already handled by runTurn)', { error: summarizeError(err) });
         });
@@ -439,6 +436,7 @@ async function main() {
   input.filePicker.setOnUpdate(() => render());
   input.agentDetailModal.setOnRefresh(() => render());
   input.processModal.setOnRefresh(() => render());
+  setOpenAgentDetail((id) => input.agentDetailModal.open(id));
 
   // Model picker callback is handled in bootstrap.ts — do not duplicate here.
   input.setHistory(inputHistory);
@@ -479,6 +477,17 @@ async function main() {
       hasAttachments: input.getImageAttachments().size > 0,
       turnState: sessionSnapshot.turnState,
     });
+    const maintenanceStatus = evaluateSessionMaintenance({
+      configManager,
+      currentTokens: orchestrator.lastInputTokens,
+      contextWindow: currentModel.contextWindow,
+      sessionMemoryCount: ctx.services.sessionMemoryStore.list().length,
+    });
+    const contextStatusHint = buildContextStatusHint({
+      level: maintenanceStatus.level,
+      autoCompactEnabled: maintenanceStatus.autoCompactEnabled,
+      usagePct: maintenanceStatus.usagePct,
+    });
     const footerLines = buildShellFooter({
       width,
       promptText: promptInfo.visibleLines.join('\n'),
@@ -496,6 +505,7 @@ async function main() {
       workingDir,
       provider: runtime.provider,
       contextWindow: currentModel.contextWindow,
+      contextStatusHint,
       // behavior.autoCompactThreshold is stored as a percent integer (e.g. 80);
       // the meter expects a fraction [0..1]. Clamp to [0,1] to guard nonsense values.
       compactThreshold: Math.min(1, Math.max(0, (configManager.get('behavior.autoCompactThreshold') as number) / 100)),
@@ -674,43 +684,41 @@ async function main() {
     render,
   });
 
-  // --- Streaming speed + tool preview wiring ---
-  const refreshGit = () => gitStatusProvider.refresh().then((info) => { lastGitInfoRef.value = info; render(); }).catch(() => { /* non-fatal */ });
-  // Refresh git status after each turn completes or after tool results arrive
-  unsubs.push(uiServices.events.turns.on('TURN_COMPLETED', () => {
-    // Auto-save after every LLM turn so kills don't lose the session
-    try {
-      const snapshot = conversation.toJSON() as { messages: Array<import('./core/conversation.ts').ConversationMessageSnapshot>; timestamp?: number };
-      const persisted = buildPersistedSessionContext(snapshot.messages, conversation.getTitleSource(), buildSessionContinuityHints());
-      persistConversation(
-        runtime.sessionId,
-        { ...snapshot, ...persisted },
-        runtime.model,
-        runtime.provider,
-        conversation.title || '',
-        { workingDirectory: workingDir, homeDirectory, sessionManager: ctx.services.sessionManager },
-      );
-      hookDispatcher.fire({ path: 'Lifecycle:session:save' as HookEventPath, phase: 'Lifecycle' as HookPhase, category: 'session' as HookCategory, specific: 'save', sessionId: runtime.sessionId, timestamp: Date.now(), payload: { sessionId: runtime.sessionId } }).catch((err: unknown) => logger.debug('hook fire error', { error: summarizeError(err) }));
-    } catch (e) { logger.debug('auto-save on turn:complete failed', { error: summarizeError(e) }); }
-    refreshGit();
-  }));
-  unsubs.push(uiServices.events.tools.on('TOOL_SUCCEEDED', () => {
-    refreshGit();
-  }));
-  unsubs.push(uiServices.events.tools.on('TOOL_FAILED', () => {
-    refreshGit();
-  }));
-
-  // --- Stream metrics + tool-timer event wiring ---
-  const streamUnsubs = wireStreamEventMetrics({
+  const { refreshGit, unsubs: turnUnsubs } = wireTurnEventHandlers({
     events: uiServices.events,
+    conversation,
+    runtime,
     orchestrator,
+    configManager,
     providerRegistry,
     systemMessageRouter,
+    hookDispatcher,
+    workingDir,
+    homeDirectory,
+    sessionManager: ctx.services.sessionManager,
+    gitStatusProvider,
+    lastGitInfoRef,
+    buildSessionContinuityHints,
     render,
-    metrics: streamMetrics,
   });
-  unsubs.push(...streamUnsubs);
+  unsubs.push(...turnUnsubs);
+
+  // Stable turn context for failover retry — set in submitInput, read by retryTurn.
+  let retryCtx: { count: number; text: string; content?: ContentPart[]; opts?: Parameters<typeof orchestrator.handleUserInput>[2] } | null = null;
+  const streamResult: WireStreamEventMetricsResult = wireStreamEventMetrics({
+    events: uiServices.events, orchestrator, providerRegistry,
+    systemMessageRouter, render, metrics: streamMetrics,
+    providerOptimizer: ctx.services.providerOptimizer,
+    retryTurn: () => {
+      if (!retryCtx) return;
+      const { count, text, content: rContent, opts: rOpts } = retryCtx;
+      // Roll back to pre-submission count (strips error system messages), then
+      // re-submit. SDK gap — no retry-in-place; see HANDOFF item (Issue 2).
+      conversation.removeMessagesAfter(count);
+      orchestrator.handleUserInput(text, rContent, rOpts).catch((e: unknown) => logger.debug('retryTurn', { error: summarizeError(e) }));
+    },
+  });
+  unsubs.push(...streamResult.unsubs);
 
   // --- Terminal setup ---
   stdin.setRawMode(true);