@pellux/goodvibes-tui 1.1.0 → 1.9.0

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

@@ -14,6 +14,14 @@ import type { McpRegistry } from '@pellux/goodvibes-sdk/platform/mcp';
 import { buildSubscriptionEntries } from './settings-modal-subscriptions.ts';
 import type { SubscriptionManager } from '@pellux/goodvibes-sdk/platform/config';
 import type { ServiceInspectionQuery } from '../runtime/ui-service-queries.ts';
+import { CODE_INDEX_ENABLED_CONFIG_KEY } from '../runtime/code-index-services.ts';
+import {
+  THEME_MODE_CONFIG_KEY,
+  THEME_MODE_VALUES,
+  THEME_MODE_DEFAULT,
+  THEME_MODE_DESCRIPTION,
+  coerceThemeModeSetting,
+} from '../renderer/theme-mode-config.ts';
 import {
   SETTINGS_CATEGORIES,
   type FlagEntry,
@@ -93,6 +101,14 @@ export function buildSettingGroups(
     }
   }
 
+  // DEBT-2: inject the synthetic display.themeMode enum (auto|dark|light). TUI-local
+  // key stored under the existing `display` section (see theme-mode-config.ts for why
+  // not `appearance`), same rationale as the other synthetic settings below.
+  const displayEntries = groups.get('display');
+  if (displayEntries && !displayEntries.some((e) => e.setting.key === (THEME_MODE_CONFIG_KEY as ConfigKey))) {
+    displayEntries.push(buildThemeModeSyntheticEntry(configManager));
+  }
+
   const uiEntries = groups.get('ui');
   if (uiEntries) {
     const uiPriority: Record<string, number> = {
@@ -130,6 +146,25 @@ export function buildSettingGroups(
     behaviorEntries.push(buildNotifyAfterSecondsSyntheticEntry(configManager));
   }
 
+  // Inject the W2.3 alert-class toggles + master focus gate. TUI-local
+  // synthetic settings, same rationale as notifyAfterSeconds above.
+  if (behaviorEntries) {
+    for (const entry of buildNotifyAlertSyntheticEntries(configManager)) {
+      if (!behaviorEntries.some((e) => e.setting.key === entry.setting.key)) {
+        behaviorEntries.push(entry);
+      }
+    }
+  }
+
+  // Wave 5 (wo804): inject the storage.codeIndexEnabled toggle into the
+  // storage category. TUI-local synthetic setting (not in the SDK ConfigKey
+  // union — see code-index-services.ts), same rationale as
+  // notifyAfterSeconds above: opt-in, default off, states its own bounds.
+  const storageEntries = groups.get('storage');
+  if (storageEntries && !storageEntries.some((e) => e.setting.key === (CODE_INDEX_ENABLED_CONFIG_KEY as ConfigKey))) {
+    storageEntries.push(buildCodeIndexEnabledSyntheticEntry(configManager));
+  }
+
   return groups;
 }
 
@@ -179,6 +214,34 @@ export function buildTtsSpeedSyntheticEntry(configManager: Pick<ConfigManager, '
   };
 }
 
+// ---------------------------------------------------------------------------
+// display.themeMode synthetic setting (DEBT-2 light theme)
+// ---------------------------------------------------------------------------
+
+/**
+ * The synthetic ConfigSetting descriptor for display.themeMode. TUI-local (not
+ * in the SDK ConfigKey union); the key is cast to ConfigKey as the other
+ * synthetic settings do. Stored under the existing `display` section so
+ * ConfigManager.setDynamic/get round-trip it with no SDK change.
+ */
+export const THEME_MODE_SYNTHETIC_SETTING: ConfigSetting = {
+  key: THEME_MODE_CONFIG_KEY as ConfigKey,
+  type: 'enum',
+  default: THEME_MODE_DEFAULT,
+  enumValues: [...THEME_MODE_VALUES],
+  description: THEME_MODE_DESCRIPTION,
+};
+
+/** Build the synthetic SettingEntry for display.themeMode. */
+export function buildThemeModeSyntheticEntry(configManager: Pick<ConfigManager, 'get'>): SettingEntry {
+  const currentValue = coerceThemeModeSetting(configManager.get(THEME_MODE_CONFIG_KEY as ConfigKey));
+  return {
+    setting: THEME_MODE_SYNTHETIC_SETTING,
+    currentValue,
+    isDefault: currentValue === THEME_MODE_DEFAULT,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // behavior.notifyAfterSeconds synthetic setting
 // ---------------------------------------------------------------------------
@@ -224,6 +287,81 @@ export function buildNotifyAfterSecondsSyntheticEntry(configManager: Pick<Config
   };
 }
 
+// ---------------------------------------------------------------------------
+// W2.3 alert-class synthetic settings — behavior.notifyOn* + notifyOnlyWhenUnfocused
+// ---------------------------------------------------------------------------
+
+/**
+ * The five W2.3 alert-gating booleans, all TUI-local (not yet in the SDK
+ * ConfigKey union), all defaulting to on. Read/written generically by
+ * core/alert-gating.ts (readBooleanConfig) and the per-alert-class modules
+ * (budget-breach-notifier.ts, approval-alert.ts, turn-event-wiring.ts,
+ * long-task-notifier.ts) — this is only the settings-modal-visible surface.
+ */
+const NOTIFY_ALERT_SYNTHETIC_SETTINGS: ReadonlyArray<{ readonly key: string; readonly description: string }> = [
+  {
+    key: 'behavior.notifyOnBudgetBreach',
+    description: 'Alert when session cost crosses the configured budget (set via the Cost panel\'s "b" key).',
+  },
+  {
+    key: 'behavior.notifyOnAgentFailure',
+    description: 'Alert when a delegated or background agent fails.',
+  },
+  {
+    key: 'behavior.notifyOnChainFailure',
+    description: 'Alert when a WRFC review chain fails.',
+  },
+  {
+    key: 'behavior.notifyOnApprovalPending',
+    description: 'Alert when a tool call is waiting on your approval.',
+  },
+  {
+    key: 'behavior.notifyOnlyWhenUnfocused',
+    description: 'Master gate for the four alerts above: fire only when the terminal window is unfocused, or when focus state was never observed (terminal does not report focus). Turn off to always fire regardless of focus.',
+  },
+];
+
+function buildBooleanSyntheticEntry(
+  configManager: Pick<ConfigManager, 'get'>,
+  key: string,
+  description: string,
+  defaultValue: boolean,
+): SettingEntry {
+  const raw = configManager.get(key as ConfigKey);
+  const currentValue = typeof raw === 'boolean' ? raw : defaultValue;
+  return {
+    setting: { key: key as ConfigKey, type: 'boolean', default: defaultValue, description },
+    currentValue,
+    isDefault: currentValue === defaultValue,
+  };
+}
+
+/** Build the five synthetic SettingEntry rows for the behavior category. */
+export function buildNotifyAlertSyntheticEntries(configManager: Pick<ConfigManager, 'get'>): SettingEntry[] {
+  return NOTIFY_ALERT_SYNTHETIC_SETTINGS.map((spec) => buildBooleanSyntheticEntry(configManager, spec.key, spec.description, true));
+}
+
+// ---------------------------------------------------------------------------
+// Wave 5 (wo804) — storage.codeIndexEnabled synthetic setting
+// ---------------------------------------------------------------------------
+
+/**
+ * The repo source-tree code index's auto-build-on-startup toggle
+ * (code-index-services.ts). TUI-local, default OFF: /codebase build is the
+ * explicit trigger unless a user opts in here. Honest bounds stated inline
+ * so enabling this isn't a surprise — see code-index-services.ts's
+ * CODE_INDEX_MAX_FILES/CODE_INDEX_MAX_FILE_BYTES for the numbers this
+ * description would otherwise duplicate as magic numbers.
+ */
+export function buildCodeIndexEnabledSyntheticEntry(configManager: Pick<ConfigManager, 'get'>): SettingEntry {
+  return buildBooleanSyntheticEntry(
+    configManager,
+    CODE_INDEX_ENABLED_CONFIG_KEY,
+    'Auto-build the repo source-tree code index on startup (bounded file/size scan; see /codebase status for bounds). Off by default — /codebase build indexes on demand.',
+    false,
+  );
+}
+
 // ---------------------------------------------------------------------------
 // buildFlagEntries — snapshot of current feature flag states
 // ---------------------------------------------------------------------------
@@ -306,6 +444,8 @@ export function refreshEntryValues(
       // construction time so isDefault stays accurate.
       if (entry.setting.key === ('tts.speed' as ConfigKey)) {
         entry.currentValue = normalizeTtsSpeedValue(raw);
+      } else if (entry.setting.key === (THEME_MODE_CONFIG_KEY as ConfigKey)) {
+        entry.currentValue = coerceThemeModeSetting(raw);
       } else {
         entry.currentValue = raw;
       }
@@ -327,8 +467,12 @@ export function updateEntryForKey(
     const entry = entries.find((candidate) => candidate.setting.key === key);
     if (entry) {
       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;
+      // Synthetic entries: normalize using the same fallback logic as construction.
+      entry.currentValue = key === ('tts.speed' as ConfigKey)
+        ? normalizeTtsSpeedValue(raw)
+        : key === (THEME_MODE_CONFIG_KEY as ConfigKey)
+          ? coerceThemeModeSetting(raw)
+          : raw;
       entry.isDefault = deepEqual(entry.currentValue, entry.setting.default);
     }
   }

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

@@ -113,13 +113,15 @@ export function persistFlagState(
   if (newState === 'killed') return; // never persist killed state
 
   try {
-    const current = (configManager.getCategory('featureFlags') as Record<string, PersistedFlagState>) ?? {};
     if (newState === defaultState) {
-      delete current[flagId];
+      // Back at the default: the override must be REMOVED, not merged.
+      // getCategory clones and mergeCategory only sets keys, so the old
+      // delete-then-merge approach left the stale override on disk and the
+      // flag silently reloaded in the overridden state on the next start.
+      configManager.removeCategoryKey('featureFlags', flagId);
     } else {
-      current[flagId] = newState;
+      configManager.mergeCategory('featureFlags', { [flagId]: newState } as Record<string, PersistedFlagState>);
     }
-    configManager.mergeCategory('featureFlags', current);
   } catch (e) {
     logger.error('SettingsModal: failed to persist flag state', { flagId, error: summarizeError(e) });
   }

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

@@ -11,11 +11,13 @@ export type SettingsCategory =
   | 'storage'
   | 'permissions'
   | 'orchestration'
+  | 'planner'
   | 'wrfc'
   | 'tools'
   | 'helper'
   | 'tts'
   | 'service'
+  | 'daemon'
   | 'controlPlane'
   | 'httpListener'
   | 'web'
@@ -42,9 +44,9 @@ export const SETTINGS_CATEGORY_GROUPS: ReadonlyArray<{
 }> = [
   { label: 'Interface', categories: ['display', 'ui', 'behavior', 'permissions'] },
   { label: 'AI Routing', categories: ['provider', 'subscriptions', 'helper', 'tools', 'tts'] },
-  { label: 'Service & Network', categories: ['service', 'network', 'controlPlane', 'httpListener', 'web'] },
+  { label: 'Service & Network', categories: ['service', 'daemon', 'network', 'controlPlane', 'httpListener', 'web'] },
   { label: 'Surfaces & Cloud', categories: ['surfaces', 'mcp', 'cloudflare'] },
-  { label: 'Automation', categories: ['batch', 'automation', 'watchers', 'orchestration', 'wrfc'] },
+  { label: 'Automation', categories: ['batch', 'automation', 'watchers', 'orchestration', 'planner', 'wrfc'] },
   { label: 'Runtime & Data', categories: ['storage', 'sandbox', 'runtime', 'cache', 'telemetry'] },
   { label: 'Advanced', categories: ['flags', 'release', 'danger'] },
 ];

package/src/main.ts

@@ -12,7 +12,7 @@ import { registerAllTools } from '@pellux/goodvibes-sdk/platform/tools';
 import { FileUndoManager } from '@pellux/goodvibes-sdk/platform/state';
 import { PermissionManager } from '@pellux/goodvibes-sdk/platform/permissions';
 import { AcpManager } from '@pellux/goodvibes-sdk/platform/acp';
-import { PermissionPromptUI } from './permissions/prompt.ts';
+import { PermissionPromptUI, buildPendingPermissionExtras } from './permissions/prompt.ts';
 import { CommandRegistry } from './input/command-registry.ts';
 import type { CommandContext } from './input/command-registry.ts';
 import { renderProcessIndicator } from './renderer/process-indicator.ts';
@@ -32,16 +32,11 @@ import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import { registerBuiltinPanels } from './panels/builtin-panels.ts';
 import { bootstrapRuntime } from './runtime/bootstrap.ts';
 import type { BootstrapContext } from './runtime/bootstrap.ts';
+import { buildSharedOrchestratorCoreServices } from './runtime/orchestrator-core-services.ts';
 import type { HITLMode } from '@pellux/goodvibes-sdk/platform/state';
-import {
-  checkRecoveryFile,
-  deleteRecoveryFile,
-  loadRecoveryConversation,
-  readLastSessionPointer,
-  writeRecoveryFile,
-} from '@/runtime/index.ts';
+import { readLastSessionPointer, writeRecoveryFile } from '@/runtime/index.ts';
 import { handleBlockingShellInput, type PendingPermissionState } from './shell/blocking-input.ts';
-import { createPersistRecoverySnapshot, createReopenRecoveryPanels, handleErrorAffordanceKey } from './shell/recovery-input-helpers.ts';
+import { createPersistRecoverySnapshot, createRecoveryFileOps, createReopenRecoveryPanels, handleErrorAffordanceKey, resolveStartupRecoveryInfo } from './shell/recovery-input-helpers.ts';
 import { wireShellUiOpeners } from './shell/ui-openers.ts';
 import { deriveComposerState } from './core/composer-state.ts';
 import { buildPersistedSessionContext, formatReturnContextForDisplay, getReturnContextMode, maybeAssistReturnContextSummary } from '@/runtime/index.ts';
@@ -57,17 +52,18 @@ import { installProcessLifecycle } from './runtime/process-lifecycle.ts';
 import { createRenderScheduler } from './runtime/render-scheduler.ts';
 import { buildCommandArgsHint } from './input/command-args-hint.ts';
 import { summarizeRunningAgents } from './renderer/process-summary.ts';
+import { footerFleetCost } from './panels/fleet-read-model.ts';
 import { formatUserFacingErrorLine } from './core/format-user-error.ts';
 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 '@/runtime/index.ts';
+import { createCancelGeneration } from './core/turn-cancellation.ts';
+import { wrapRequestPermissionWithAlert } from './core/approval-alert.ts';
+import { setPanelFrameRequester } from './panels/base-panel.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 { ALT_SCREEN_ENTER, ALT_SCREEN_EXIT, MOUSE_ENABLE, MOUSE_DISABLE, CURSOR_HIDE, CURSOR_SHOW, CLEAR_SCREEN, KEYBOARD_EXT_ENABLE, KEYBOARD_EXT_DISABLE, PASTE_ENABLE, PASTE_DISABLE, FOCUS_ENABLE, FOCUS_DISABLE } from './renderer/terminal-escapes.ts';
+import { installBackgroundThemeProbe } from './renderer/terminal-bg-probe.ts';
 
 async function main() {
   const stdout = process.stdout;
@@ -103,22 +99,17 @@ async function main() {
     permissionPromptRef,
     _writeLastSessionPointer: writeLastSessionPointer,
     systemMessageRouter,
-    setOpenAgentDetail,
   } = ctx;
   const workingDir = ctx.services.workingDirectory;
   const homeDirectory = ctx.services.homeDirectory;
   const { approvalBroker, agentManager, modeManager, processManager, providerRegistry, secretsManager, subscriptionManager } = ctx.services;
   conversation.setSessionMemoryStore(ctx.services.sessionMemoryStore);
   conversation.setSessionLineageTracker(ctx.services.sessionLineageTracker);
+  // Shared payload (single source of truth, includes wo805's memoryRegistry —
+  // see orchestrator-core-services.ts) plus this site's favoritesStore.
   orchestrator.setCoreServices({
-    configManager,
-    providerRegistry,
+    ...buildSharedOrchestratorCoreServices({ services: ctx.services, configManager, providerRegistry }),
     favoritesStore: ctx.services.favoritesStore,
-    planManager: ctx.services.planManager,
-    adaptivePlanner: ctx.services.adaptivePlanner,
-    sessionMemoryStore: ctx.services.sessionMemoryStore,
-    sessionLineageTracker: ctx.services.sessionLineageTracker,
-    idempotencyStore: ctx.services.idempotencyStore,
   });
   ctx.services.wrfcController.setPlanManager(ctx.services.planManager);
   let activeConversationWidth = stdout.columns || 80;
@@ -213,13 +204,15 @@ async function main() {
   let recoveryInterval: ReturnType<typeof setInterval> | null = null;
   let stopSpokenOutputForExit: (() => void) | null = null;
   let recoveryPending = false;
+  // Which file the current recovery prompt should load/delete from (see recovery-input-helpers.ts).
+  let recoverySource: 'live' | 'preserved' = 'live';
 
   const lifecycle = installProcessLifecycle({
     stdin,
     stdout,
     ctx,
     noAltScreen: cli.flags.noAltScreen,
-    ansi: { CLEAR_SCREEN, ALT_SCREEN_EXIT, PASTE_DISABLE, KEYBOARD_EXT_DISABLE, MOUSE_DISABLE, CURSOR_SHOW },
+    ansi: { CLEAR_SCREEN, ALT_SCREEN_EXIT, PASTE_DISABLE, KEYBOARD_EXT_DISABLE, MOUSE_DISABLE, CURSOR_SHOW, FOCUS_DISABLE },
     getInput: () => input,
     render: () => renderScheduler.flushNow(), // resize: synchronous immediate path
     getPromptContentWidth,
@@ -303,12 +296,7 @@ async function main() {
     }
   };
 
-  const cancelGeneration = () => {
-    spokenTurns.stop('Spoken output stopped.');
-    if (orchestrator.isThinking) {
-      orchestrator.abort();
-    }
-  };
+  const cancelGeneration = createCancelGeneration(orchestrator, spokenTurns);
 
   const jumpToBookmark = (key: string) => {
     conversation.getDisplayBlocks();
@@ -337,6 +325,7 @@ async function main() {
   commandContext.pasteFromClipboard = () => input.handlePaste();
   commandContext.executeCommand = (name, args) => commandRegistry.execute(name, args, commandContext);
   commandContext.cancelGeneration = cancelGeneration;
+  commandContext.isGenerating = () => orchestrator.isThinking;
   commandContext.jumpToBookmark = jumpToBookmark;
   commandContext.scrollToLine = scrollToLine;
   commandContext.clearScreen = () => {
@@ -345,14 +334,14 @@ async function main() {
     render();
   };
   commandContext.requestFullRepaint = () => { compositor.resetDiff(); render(); };
-  permissionPromptRef.requestPermission = (request) =>
+  permissionPromptRef.requestPermission = wrapRequestPermissionWithAlert((request) =>
     new Promise((resolve) => {
       pendingPermission = {
         ...request,
-        resolve: (approved: boolean, remember = false) => resolve({ approved, remember }),
+        ...buildPendingPermissionExtras(request, resolve),
       };
       render();
-    });
+    }), { focusTracker: ctx.services.focusTracker, configGet: (k: string) => configManager.get(k as Parameters<typeof configManager.get>[0]), webhookNotifier: ctx.services.webhookNotifier });
 
   const input: InputHandler = new InputHandler(
     () => render(),
@@ -385,7 +374,7 @@ async function main() {
         replayEngine: ctx.services.replayEngine,
         webhookNotifier: ctx.services.webhookNotifier,
         policyRuntimeState: ctx.services.policyRuntimeState,
-        externalServices: uiServices.platform.externalServices,
+        externalServices: uiServices.platform.externalServices, focusTracker: ctx.services.focusTracker,
       },
       shell: {
         bookmarkManager: ctx.services.bookmarkManager,
@@ -396,7 +385,7 @@ async function main() {
       },
       sessions: {
         sessionManager: ctx.services.sessionManager,
-        sessionBroker: ctx.services.sessionBroker,
+        sessionBroker: uiServices.sessions.sessionBroker,
         sessionOrchestration: ctx.services.sessionOrchestration,
         sessionMemoryStore: ctx.services.sessionMemoryStore,
       },
@@ -415,9 +404,8 @@ async function main() {
   input.setConversationManager(conversation);
   input.setContentWidth(getPromptContentWidth());
   input.filePicker.setOnUpdate(() => render());
-  input.agentDetailModal.setOnRefresh(() => render());
-  input.processModal.setOnRefresh(() => render());
-  setOpenAgentDetail((id) => input.agentDetailModal.open(id));
+  // W6.1 retirement: agentDetailModal/processModal setOnRefresh wiring removed —
+  // those modals were deleted (Fleet subsumes the live process tree via F2).
 
   // Model picker callback is handled in bootstrap.ts — do not duplicate here.
   input.setHistory(inputHistory);
@@ -482,7 +470,7 @@ async function main() {
           .slice(0, promptInfo.visibleCursorLine)
           .reduce((sum: number, line: string) => sum + line.length + 1, 0) + promptInfo.visibleCursorCol
         : undefined,
-      usage: { up: orchestrator.usage.input, down: orchestrator.usage.output },
+      usage: { up: orchestrator.usage.input, down: orchestrator.usage.output, fleetCostUsd: footerFleetCost(() => ctx.services.processRegistry.query().nodes, runningAgentCount > 0) },
       showExitNotice: input.showExitNotice,
       lastCopyTime: input.lastCopyTime,
       model: runtime.model,
@@ -509,8 +497,8 @@ async function main() {
       lastInputTokens: orchestrator.lastInputTokens,
       commandArgsHint,
       hitlMode: modeManager.getHITLMode(),
-      runningAgentCount,
-      runningProcessCount,
+      // S3d: cross-surface spine posture segment (adopted-daemon mode only).
+      sessionSpineStatus: (() => { const s = uiServices.platform.externalServices?.inspect(); return s?.sessionSpineActive && s.sessionSpineStatus && s.sessionSpineStatus !== 'unknown' ? s.sessionSpineStatus : undefined; })(), runningAgentCount, runningProcessCount,
       // Composer must not read as focused while the panel/process indicator owns keyboard focus.
       promptFocused: !input.panelFocused && !input.indicatorFocused,
       indicatorFocused: input.indicatorFocused,
@@ -557,7 +545,7 @@ async function main() {
     // Calculate how many rows are consumed by overlays (thinking, permissions, queue, file picker)
     let overlayRows = 0;
     if (orchestrator.isThinking) overlayRows += 2; // spinner + blank
-    if (pendingPermission) overlayRows += PermissionPromptUI.getPromptHeight(pendingPermission);
+    if (pendingPermission) overlayRows += PermissionPromptUI.getPromptHeight(pendingPermission, pendingPermission.hunkState, pendingPermission.detailsExpanded);
     overlayRows += orchestrator.messageQueue.length * 3; // queued messages
     // File picker and model picker overlay rows computed from actual rendered line count below
     // Selection modal overlay rows are computed from actual rendered line count below
@@ -596,6 +584,7 @@ async function main() {
         turnElapsedMs,
         streamMetrics.ttftMs,
         stallInfo,
+        pendingPermission !== null,
       );
       viewport.push(...thinking);
       // Live tool timer: render the currently executing tool row with ticking elapsed.
@@ -606,7 +595,7 @@ async function main() {
     }
 
     if (pendingPermission) {
-      viewport.push(...PermissionPromptUI.createPromptLines(conversationWidth, pendingPermission));
+      viewport.push(...PermissionPromptUI.createPromptLines(conversationWidth, pendingPermission, pendingPermission.hunkState, pendingPermission.detailsExpanded));
     }
 
     orchestrator.messageQueue.forEach(msg => {
@@ -653,10 +642,11 @@ async function main() {
     });
   };
   const renderScheduler = createRenderScheduler(renderNow); // WO-208 same-tick coalescer
-  const render = (): void => renderScheduler.schedule();
-  const terminalOutputGuard = installTuiTerminalOutputGuard({ stdout, stderr: process.stderr, notify: (message) => { systemMessageRouter.low(message); render(); } });
+  const render = (): void => renderScheduler.schedule(); // captured direct writes → activity log + quiet /debug counter, not repeated transcript lines (UX-B 1a)
+  const terminalOutputGuard = installTuiTerminalOutputGuard({ stdout, stderr: process.stderr, onCapture: (total) => { commandContext.session.runtime.terminalWritesIntercepted = total; render(); } });
 
   setRenderRequest(renderNow); // bootstrap's 16ms coalescer calls the composite directly
+  setPanelFrameRequester(render); // live panels repaint when idle (Wave-6 replay: fleet sat stale until keypress)
   orchestratorRefs.requestRender = render;
   commandContext.renderRequest = render;
   wireShellUiOpeners({
@@ -672,6 +662,7 @@ async function main() {
     subscriptionManager,
     secretsManager,
     serviceRegistry: ctx.services.serviceRegistry,
+    memoryEmbeddingRegistry: ctx.services.memoryEmbeddingRegistry,
     workingDirectory: workingDir,
     homeDirectory,
     getConfiguredProviderIds: ctx._getConfiguredProviderIds,
@@ -694,7 +685,7 @@ async function main() {
     gitStatusProvider,
     lastGitInfoRef,
     buildSessionContinuityHints,
-    render, webhookNotifier: ctx.services.webhookNotifier,
+    render, webhookNotifier: ctx.services.webhookNotifier, focusTracker: ctx.services.focusTracker,
   });
   unsubs.push(...turnUnsubs);
 
@@ -714,6 +705,7 @@ async function main() {
     events: uiServices.events, orchestrator, providerRegistry,
     systemMessageRouter, render, metrics: streamMetrics,
     providerOptimizer: ctx.services.providerOptimizer, costLookup: providerRegistry, retryTurn,
+    isApprovalPending: () => pendingPermission !== null,
   });
   unsubs.push(...streamResult.unsubs);
   // Activate one-key retry affordance when a user-visible error surfaces.
@@ -736,16 +728,19 @@ async function main() {
   stdin.setRawMode(true);
   stdin.resume();
   stdin.setEncoding('utf8');
-  allowTerminalWrite(() => stdout.write((cli.flags.noAltScreen ? '' : ALT_SCREEN_ENTER) + CLEAR_SCREEN + CURSOR_HIDE + MOUSE_ENABLE + KEYBOARD_EXT_ENABLE + PASTE_ENABLE));
+  allowTerminalWrite(() => stdout.write((cli.flags.noAltScreen ? '' : ALT_SCREEN_ENTER) + CLEAR_SCREEN + CURSOR_HIDE + MOUSE_ENABLE + KEYBOARD_EXT_ENABLE + PASTE_ENABLE + FOCUS_ENABLE));
+  // DEBT-2: forced dark/light applies before first paint; auto (TTY only) fires the
+  // OSC 11 probe and repaints once if light wins. filterInput strips the reply from stdin.
+  const themeProbe = installBackgroundThemeProbe({ configManager, isTTY: Boolean(stdout.isTTY), env: process.env, writeQuery: (b) => allowTerminalWrite(() => stdout.write(b)), requestRepaint: () => { compositor.resetDiff(); render(); } });
 
   applyInitialTuiCliState({ cli, input, commandRegistry, commandContext, shellPaths: ctx.services.shellPaths, render });
 
-  stdin.on('data', (data: string) => {
+  stdin.on('data', (raw: string) => {
+    const data = themeProbe.filterInput(raw); if (data.length === 0) return;
     const blocking = handleBlockingShellInput({
       data, pendingPermission, recoveryPending, conversation, systemMessageRouter, render,
       abortTurn: () => orchestrator.abort(),
-      loadRecoveryConversation: () => loadRecoveryConversation({ homeDirectory }),
-      deleteRecoveryFile: () => deleteRecoveryFile({ homeDirectory }),
+      ...createRecoveryFileOps(() => recoverySource, { homeDirectory }),
       homeDirectory, sessionId: runtime.sessionId,
       persistSnapshot: createPersistRecoverySnapshot({ sessionManager: ctx.services.sessionManager, runtime, conversation }),
       reopenPanels: createReopenRecoveryPanels({ panelManager, render }),
@@ -772,9 +767,10 @@ async function main() {
   conversation.rebuildHistory();
   render();
 
-  // --- Crash recovery check ---
-  const recoveryInfo = checkRecoveryFile({ workingDirectory: workingDir, homeDirectory });
+  // --- Crash recovery check (also checks the preserve-on-dismiss sibling; see recovery-input-helpers.ts) ---
+  const recoveryInfo = resolveStartupRecoveryInfo({ workingDirectory: workingDir, homeDirectory });
   if (recoveryInfo) {
+    recoverySource = recoveryInfo.source;
     systemMessageRouter.high(`[Recovery] Found unsaved session from ${new Date(recoveryInfo.timestamp).toLocaleString()}. Title: "${recoveryInfo.title}". Press Ctrl+R to restore, Esc to discard, or start typing to ignore it.`);
     for (const line of formatReturnContextForDisplay(recoveryInfo.returnContext)) {
       systemMessageRouter.low(`[Recovery] ${line}`);
@@ -785,6 +781,8 @@ async function main() {
 
   // --- Auto-save to recovery file every 60s ---
   recoveryInterval = setInterval(() => {
+    // Skip while an earlier recovery prompt is unresolved (avoids racing preserve-on-dismiss).
+    if (recoveryPending) return;
     const snapshot = conversation.toJSON() as { messages: Array<import('./core/conversation.ts').ConversationMessageSnapshot> };
     const persisted = buildPersistedSessionContext(snapshot.messages, conversation.getTitleSource(), buildSessionContinuityHints());
     writeRecoveryFile(

package/src/panels/agent-inspector-shared.ts

@@ -7,7 +7,8 @@ export type AgentInspectorEntryKind = 'user' | 'assistant' | 'tool_call' | 'tool
 
 // ---------------------------------------------------------------------------
 // Shared agent status / stall constants
-// Used by AgentInspectorPanel, AgentDetailModal, and cockpit read-model consumers.
+// Used by the Fleet panel's agent views and read-model consumers (formerly also
+// AgentDetailModal, which was retired in W6.1).
 // ---------------------------------------------------------------------------
 
 /** Terminal statuses — cancel not offered; stall check skipped. */

package/src/panels/base-panel.ts

@@ -9,6 +9,20 @@ import { fitDisplay } from '../utils/terminal-width.ts';
 /** Canonical error-surface foreground (bad/red), kept out of the render body. */
 const ERROR_FG = '#ef4444';
 
+/**
+ * Frame requester wired by main.ts to the render scheduler. Without it,
+ * markDirty() only sets a flag the compositor reads when a frame is ALREADY
+ * being composed for another reason (input, streaming) — so a live panel
+ * (fleet ticks, registry subscriptions) sat visibly stale while the app was
+ * idle until the next keypress (Wave-6 replay finding). The scheduler
+ * coalesces same-tick requests, so this stays cheap.
+ */
+let panelFrameRequester: (() => void) | null = null;
+
+export function setPanelFrameRequester(requester: (() => void) | null): void {
+  panelFrameRequester = requester;
+}
+
 export abstract class BasePanel implements Panel {
   public needsRender = true;
   public isTransient = false;
@@ -219,7 +233,14 @@ export abstract class BasePanel implements Panel {
   /** R2: Called by the compositor after a successful render to clear the dirty flag. */
   public markRendered(): void { this.needsRender = false; }
 
-  protected markDirty(): void { this.needsRender = true; }
+  protected markDirty(): void {
+    // Request only on the false→true transition: a pending frame already
+    // covers repeat marks, and a panel that dirties itself mid-render must
+    // not schedule frames forever.
+    const wasDirty = this.needsRender;
+    this.needsRender = true;
+    if (!wasDirty) panelFrameRequester?.();
+  }
 
   /**
    * Check whether the panel is currently permitted to render.