chore: retrigger CI after unrelated TERM-SSHD flake

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

.github/workflows/build.yml

@@ -82,6 +82,8 @@ on:
       - "scripts/resolve-et-bin-release.cjs"
       - "scripts/resolve-mosh-bin-release.cjs"
       - "scripts/tray-panel-layout.live.test.cjs"
+      - "scripts/serial-named-pipe.live.test.cjs"
+      - "scripts/fixtures/serial/**"
       - "scripts/verify-linux-*.sh"
       - "scripts/xterm-macos-column-selection.live.test.cjs"
       - "skills/**"
@@ -251,6 +253,10 @@ jobs:
       - name: Install deps
         run: npm ci
 
+      - name: Test Windows serial pipe through native Electron
+        if: matrix.name == 'windows'
+        run: npx electron scripts/serial-named-pipe.live.test.cjs
+
       - name: Test macOS Option column selection
         if: matrix.name == 'macos'
         run: npm run test:xterm-macos-selection

.github/workflows/test.yml

@@ -91,6 +91,9 @@ jobs:
       - name: Install deps
         run: npm ci --ignore-scripts
 
+      - name: Exercise serial named pipe transport on Windows
+        run: node --test electron/bridges/serialNamedPipe.test.cjs
+
       - name: Apply production dependency patches
         run: npx patch-package --error-on-fail
 

README.md

@@ -181,7 +181,9 @@ Organize and navigate your hosts using the view that best fits the moment: grid
 
 ## Monitoring View
 
-Inspect CPU, memory, disk, network, and latency readings, with GPU details where available. Choose visible columns, resize them, adjust refresh controls, and open a terminal directly from a monitored host.
+Inspect CPU, memory, disk, network, and latency readings, with GPU details where available. Choose visible columns, resize them, select refresh intervals down to 1 second, and open a terminal directly from a monitored host.
+
+Disk I/O shows aggregate read/write throughput for Linux hardware-backed block devices, without counting partitions or stacked virtual devices twice. Rates use two consecutive samples; `--` means unavailable or warming up, not zero activity. Disk I/O is currently unavailable on macOS; existing macOS monitoring is unchanged. The terminal system overview uses the same shared measurements.
 
 <img width="3364" height="1982" alt="image" src="docs/assets/readme/monitoring.webp" />
 

application/AppHandlers.globalHotkeys.test.ts

@@ -1,4 +1,5 @@
 import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
 import test from 'node:test';
 
 import {
@@ -8,6 +9,11 @@ import {
   handleGlobalHotkeyKeyDownImpl,
   markForwardedNativeShortcutEvent,
 } from './app/AppHandlers.ts';
+import {
+  DEFAULT_SETTINGS_CHROME_SNAPSHOT,
+  getSettingsChromeSnapshot,
+  publishSettingsChromeSnapshot,
+} from './state/settingsChromeStore.ts';
 import { matchesKeyBinding } from '../domain/models.ts';
 import { DEFAULT_KEY_BINDINGS } from '../domain/models/keyBindings.ts';
 
@@ -829,3 +835,201 @@ for (const scenario of [
     });
   }
 }
+
+for (const scheme of ['pc', 'mac'] as const) {
+  test(`focused terminal ${scheme} consumes Shift+B for the host list and leaves plain B to broadcast`, () => {
+    const target = new FakeHTMLElement();
+    const shiftedActions: string[] = [];
+    let shiftedPrevented = false;
+    let shiftedStopped = false;
+    handleGlobalHotkeyKeyDownImpl(() => ({
+      HOTKEY_DEBUG: false,
+      closeTabKeyStr: '',
+      executeHotkeyAction: (action: string) => {
+        shiftedActions.push(action);
+        return action === 'toggleHostTree';
+      },
+      hotkeyScheme: scheme,
+      keyBindings: DEFAULT_KEY_BINDINGS,
+      matchesKeyBinding,
+    }), {
+      key: 'b',
+      code: 'KeyB',
+      ctrlKey: scheme === 'pc',
+      metaKey: scheme === 'mac',
+      altKey: false,
+      shiftKey: true,
+      target,
+      composedPath: () => [target],
+      preventDefault: () => { shiftedPrevented = true; },
+      stopPropagation: () => { shiftedStopped = true; },
+    } as unknown as KeyboardEvent);
+
+    assert.deepEqual(shiftedActions, ['toggleHostTree']);
+    assert.equal(shiftedPrevented, true);
+    assert.equal(shiftedStopped, true);
+
+    const plainActions: string[] = [];
+    let plainPrevented = false;
+    handleGlobalHotkeyKeyDownImpl(() => ({
+      HOTKEY_DEBUG: false,
+      closeTabKeyStr: '',
+      executeHotkeyAction: (action: string) => {
+        plainActions.push(action);
+        return undefined;
+      },
+      hotkeyScheme: scheme,
+      keyBindings: DEFAULT_KEY_BINDINGS,
+      matchesKeyBinding,
+    }), {
+      key: 'b',
+      code: 'KeyB',
+      ctrlKey: scheme === 'pc',
+      metaKey: scheme === 'mac',
+      altKey: false,
+      shiftKey: false,
+      target,
+      composedPath: () => [target],
+      preventDefault: () => { plainPrevented = true; },
+      stopPropagation: () => {},
+    } as unknown as KeyboardEvent);
+
+    assert.deepEqual(plainActions, ['broadcast']);
+    assert.equal(plainPrevented, false);
+  });
+}
+
+test('focused terminal leaves the host-list chord alone when the toggle does not run', () => {
+  const target = new FakeHTMLElement();
+  const actions: string[] = [];
+  let prevented = false;
+  let stopped = false;
+  handleGlobalHotkeyKeyDownImpl(() => ({
+    HOTKEY_DEBUG: false,
+    closeTabKeyStr: '',
+    executeHotkeyAction: (action: string) => {
+      actions.push(action);
+      return false;
+    },
+    hotkeyScheme: 'pc',
+    keyBindings: DEFAULT_KEY_BINDINGS,
+    matchesKeyBinding,
+  }), {
+    key: 'b',
+    code: 'KeyB',
+    ctrlKey: true,
+    metaKey: false,
+    altKey: false,
+    shiftKey: true,
+    target,
+    composedPath: () => [target],
+    preventDefault: () => { prevented = true; },
+    stopPropagation: () => { stopped = true; },
+  } as unknown as KeyboardEvent);
+
+  assert.deepEqual(actions, ['toggleHostTree']);
+  assert.equal(prevented, false);
+  assert.equal(stopped, false);
+});
+
+test('host list shortcut reaches a focused Monaco editor and stays out of plain text fields', () => {
+  const monaco = new FakeMonacoHTMLElement();
+  const monacoActions: string[] = [];
+  let monacoPrevented = false;
+  handleGlobalHotkeyKeyDownImpl(() => ({
+    HOTKEY_DEBUG: false,
+    closeTabKeyStr: '',
+    executeHotkeyAction: (action: string) => {
+      monacoActions.push(action);
+      return true;
+    },
+    hotkeyScheme: 'pc',
+    keyBindings: DEFAULT_KEY_BINDINGS,
+    matchesKeyBinding,
+  }), {
+    key: 'b',
+    code: 'KeyB',
+    ctrlKey: true,
+    metaKey: false,
+    altKey: false,
+    shiftKey: true,
+    target: monaco,
+    composedPath: () => [monaco],
+    preventDefault: () => { monacoPrevented = true; },
+    stopPropagation: () => {},
+  } as unknown as KeyboardEvent);
+
+  assert.deepEqual(monacoActions, ['toggleHostTree']);
+  assert.equal(monacoPrevented, true);
+
+  const input = new FakeInputHTMLElement();
+  const inputActions: string[] = [];
+  let inputPrevented = false;
+  handleGlobalHotkeyKeyDownImpl(() => ({
+    HOTKEY_DEBUG: false,
+    closeTabKeyStr: '',
+    executeHotkeyAction: (action: string) => {
+      inputActions.push(action);
+      return true;
+    },
+    hotkeyScheme: 'pc',
+    keyBindings: DEFAULT_KEY_BINDINGS,
+    matchesKeyBinding,
+  }), {
+    key: 'b',
+    code: 'KeyB',
+    ctrlKey: true,
+    metaKey: false,
+    altKey: false,
+    shiftKey: true,
+    target: input,
+    composedPath: () => [input],
+    preventDefault: () => { inputPrevented = true; },
+    stopPropagation: () => {},
+  } as unknown as KeyboardEvent);
+
+  assert.deepEqual(inputActions, []);
+  assert.equal(inputPrevented, false);
+});
+
+test('toggleHostTree uses the host list toggle only while that list can show', () => {
+  const previous = getSettingsChromeSnapshot();
+  const calls: string[] = [];
+  const toggleHostTree = () => { calls.push('toggle'); };
+  const event = {} as KeyboardEvent;
+  const contextFor = (activeTabId: string, orderedTabs: string[] = [activeTabId]) => ({
+    activeTabStore: { getActiveTabId: () => activeTabId },
+    editorTabs: [],
+    orderedTabs,
+    sessions: [{ id: 'session-1' }],
+    settings: {},
+    toEditorTabId: (id: string) => id,
+    toggleHostTree,
+    workspaces: [{ id: 'workspace-1' }],
+  });
+
+  try {
+    publishSettingsChromeSnapshot({ ...DEFAULT_SETTINGS_CHROME_SNAPSHOT, showHostTreeSidebar: true });
+    assert.equal(executeHotkeyActionImpl(() => contextFor('session-1'), 'toggleHostTree', event), true);
+    assert.equal(executeHotkeyActionImpl(() => contextFor('editor:note', []), 'toggleHostTree', event), true);
+    assert.equal(executeHotkeyActionImpl(() => contextFor('workspace-1'), 'toggleHostTree', event), true);
+    assert.deepEqual(calls, ['toggle', 'toggle', 'toggle']);
+
+    calls.length = 0;
+    assert.equal(executeHotkeyActionImpl(() => contextFor('vault', []), 'toggleHostTree', event), false);
+    assert.equal(executeHotkeyActionImpl(() => contextFor('sftp', []), 'toggleHostTree', event), false);
+    assert.equal(executeHotkeyActionImpl(() => contextFor('plugin-view:demo:main', ['plugin-view:demo:main']), 'toggleHostTree', event), false);
+    assert.deepEqual(calls, []);
+
+    publishSettingsChromeSnapshot({ ...DEFAULT_SETTINGS_CHROME_SNAPSHOT, showHostTreeSidebar: false });
+    assert.equal(executeHotkeyActionImpl(() => contextFor('session-1'), 'toggleHostTree', event), false);
+    assert.deepEqual(calls, []);
+  } finally {
+    publishSettingsChromeSnapshot(previous);
+  }
+});
+
+test('host list shortcut calls the same store toggle as the toolbar button', () => {
+  const source = readFileSync(new URL('./app/AppSideEffects.tsx', import.meta.url), 'utf8');
+  assert.match(source, /toggleHostTree:\s*\(\)\s*=>\s*terminalHostTreeStore\.toggle\(\)/);
+});

application/app/AppHandlers.ts

@@ -9,6 +9,8 @@ import { getAvailablePaneMagnificationController } from '../../domain/paneMagnif
 import { sanitizeHostIconFields } from '../../domain/hostIcon';
 import { resolveEffectiveTerminalProtocol } from '../../domain/terminalProtocol';
 import { getTerminalPassthroughActions } from '../state/useGlobalHotkeys';
+import { getSettingsChromeSnapshot } from '../state/settingsChromeStore';
+import { isHostTreeWorkTabSurface } from './workTabSurface';
 import { tabShortcutDigitFromEvent } from '../../domain/models/keyBindings';
 import { isPortForwardingAutoReconnectEnabled } from '../../domain/portForwardingReconnect';
 import { buildNumberShortcutTabTargets } from './tabShortcutTargets';
@@ -276,6 +278,9 @@ export function handleGlobalHotkeyKeyDownImpl(getCtx: AppContextGetter, e: Keybo
     const paneZoomBinding = keyBindings.find((binding) => binding.action === 'togglePaneZoom');
     const paneZoomKeyStr = paneZoomBinding ? (isMac ? paneZoomBinding.mac : paneZoomBinding.pc) : null;
     const isPaneZoomHotkey = paneZoomKeyStr ? matchesKeyBinding(e, paneZoomKeyStr, isMac) : false;
+    const hostTreeBinding = keyBindings.find((binding) => binding.action === 'toggleHostTree');
+    const hostTreeKeyStr = hostTreeBinding ? (isMac ? hostTreeBinding.mac : hostTreeBinding.pc) : null;
+    const isHostTreeHotkey = hostTreeKeyStr ? matchesKeyBinding(e, hostTreeKeyStr, isMac) : false;
 
     if (
       (isFormElement || isMonacoElement)
@@ -283,6 +288,7 @@ export function handleGlobalHotkeyKeyDownImpl(getCtx: AppContextGetter, e: Keybo
       && e.key !== 'Escape'
       && !isQuickSwitchHotkey
       && !isPaneZoomHotkey
+      && !(isMonacoElement && isHostTreeHotkey)
       && !forwardedNativeShortcutEvents.has(e)
     ) {
       return;
@@ -322,9 +328,10 @@ export function handleGlobalHotkeyKeyDownImpl(getCtx: AppContextGetter, e: Keybo
         continue;
       }
 
-      // An unavailable broadcast action must leave the chord to the terminal
-      // (notably tmux's Ctrl+B prefix). Dispatch once before consuming it.
-      if (binding.action === 'broadcast') {
+      // An unavailable action must leave the chord to the terminal.
+      // Broadcast keeps Ctrl/Cmd+B for tmux; the host list keeps Ctrl/Cmd+Shift+B
+      // when the sidebar cannot show. Dispatch once before consuming it.
+      if (binding.action === 'broadcast' || binding.action === 'toggleHostTree') {
         if (executeHotkeyAction(binding.action, e) === true) {
           e.preventDefault();
           e.stopPropagation();
@@ -801,7 +808,7 @@ export async function closeTabsBatchImpl(getCtx: AppContextGetter, targetIds: st
 }
 
 export function executeHotkeyActionImpl(getCtx: AppContextGetter, action: string, e: KeyboardEvent) {
-  const { IS_DEV, MOVE_FOCUS_DEBOUNCE_MS, activeTabStore, addConnectionLogRef, canUseGlobalBroadcast, closePluginViewTab, closeSession, closeTabInFlightRef, closeWorkspace, collectSessionIds, confirmIfBusyLocalTerminal, createLocalTerminalWithCurrentShell, editorTabs, fromEditorTabId, handleOpenSettingsRef, handleRequestCloseEditorTabRef, isEditorTabId, isPluginViewTabId, isQuickSwitcherOpen, lastMoveFocusTimeRef, moveFocusInWorkspace, orderedTabs, resolveCloseIntent, resolveSnippetsShortcutIntent, sessions, setActiveTabId, setAddToWorkspaceDialog, setIsQuickSwitcherOpen, setNavigateToSection, settings, sftpPaneMagnificationRef, splitSessionWithCurrentShell, systemInfoRef, terminalPaneMagnificationRef, toEditorTabId, toggleBroadcast, toggleGlobalBroadcast, toggleScriptsSidePanelRef, toggleSidePanelRef, toggleWindowOpacity, workspaces } = getCtx();
+  const { IS_DEV, MOVE_FOCUS_DEBOUNCE_MS, activeTabStore, addConnectionLogRef, canUseGlobalBroadcast, closePluginViewTab, closeSession, closeTabInFlightRef, closeWorkspace, collectSessionIds, confirmIfBusyLocalTerminal, createLocalTerminalWithCurrentShell, editorTabs, fromEditorTabId, handleOpenSettingsRef, handleRequestCloseEditorTabRef, isEditorTabId, isPluginViewTabId, isQuickSwitcherOpen, lastMoveFocusTimeRef, moveFocusInWorkspace, orderedTabs, resolveCloseIntent, resolveSnippetsShortcutIntent, sessions, setActiveTabId, setAddToWorkspaceDialog, setIsQuickSwitcherOpen, setNavigateToSection, settings, sftpPaneMagnificationRef, splitSessionWithCurrentShell, systemInfoRef, terminalPaneMagnificationRef, toEditorTabId, toggleBroadcast, toggleGlobalBroadcast, toggleHostTree, toggleScriptsSidePanelRef, toggleSidePanelRef, toggleWindowOpacity, workspaces } = getCtx();
 {
     const shortcutTabs = buildNumberShortcutTabTargets({
       showSftpTab: settings.showSftpTab ?? true,
@@ -997,6 +1004,18 @@ export function executeHotkeyActionImpl(getCtx: AppContextGetter, action: string
       case 'toggleSidePanel':
         toggleSidePanelRef.current?.();
         break;
+      case 'toggleHostTree': {
+        const currentId = activeTabStore.getActiveTabId();
+        if (!isHostTreeWorkTabSurface({
+          enabled: getSettingsChromeSnapshot().showHostTreeSidebar,
+          activeTabId: currentId,
+          orderedTabs: orderedTabs ?? [],
+          sessionIds: new Set((sessions ?? []).map((session: TerminalSession) => session.id)),
+          workspaceIds: new Set((workspaces ?? []).map((workspace: { id: string }) => workspace.id)),
+        }) || typeof toggleHostTree !== 'function') return false;
+        toggleHostTree();
+        return true;
+      }
       case 'broadcast': {
         // Workspace tabs keep their local broadcast state; orphan tabs share
         // the global state when at least two visible orphan tabs exist.
@@ -1145,6 +1164,7 @@ export function handleConnectToHostImpl(getCtx: AppContextGetter, host: Host, hi
     if (effectiveHost.protocol === 'serial') {
       const portName = host.hostname.split('/').pop() || host.hostname;
       const sessionId = connectToHost(effectiveHost, { hidden });
+      if (!sessionId) return null;
       addConnectionLog({
         sessionId,
         hostId: host.id,
@@ -1164,6 +1184,7 @@ export function handleConnectToHostImpl(getCtx: AppContextGetter, host: Host, hi
     const protocol = resolveEffectiveTerminalProtocol(effectiveHost);
     const resolvedAuth = resolveHostAuth({ host: effectiveHost, keys, identities });
     const sessionId = connectToHost(effectiveHost, { hidden });
+    if (!sessionId) return null;
     addConnectionLog({
       sessionId,
       hostId: host.id,
@@ -1184,7 +1205,7 @@ export function handleConnectToHostImpl(getCtx: AppContextGetter, host: Host, hi
   }
 }
 
-export function handleTerminalDataCaptureImpl(getCtx: AppContextGetter, sessionId: string, data: string) {
+export async function handleTerminalDataCaptureImpl(getCtx: AppContextGetter, sessionId: string, data: string) {
   const { IS_DEV, connectionLogs, selectConnectionLogForTerminalDataCapture, sessions, updateConnectionLog } = getCtx();
 {
     if (IS_DEV) console.log('[handleTerminalDataCapture] Called', { sessionId, dataLength: data.length });
@@ -1200,7 +1221,10 @@ export function handleTerminalDataCaptureImpl(getCtx: AppContextGetter, sessionI
     if (IS_DEV) console.log('[handleTerminalDataCapture] Matching log', matchingLog);
 
     if (matchingLog) {
-      updateConnectionLog(matchingLog.id, {
+      // The IndexedDB replay write commits asynchronously. Waiting here keeps
+      // a crash during session teardown from dropping the newest capture any
+      // more often than the old synchronous localStorage write.
+      await updateConnectionLog(matchingLog.id, {
         endTime: Date.now(),
         terminalData: data,
       });

application/app/AppHandlers.workspaceHostOpen.test.ts

@@ -0,0 +1,67 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import type { ConnectionLog, Host } from '../../domain/models';
+import { createLocalShellHost } from '../../domain/localShellHost';
+import { selectConnectionLogForTerminalDataCapture } from '../../domain/connectionLog';
+import { handleConnectToHostImpl, handleTerminalDataCaptureImpl } from './AppHandlers';
+
+test('workspace host launch records resolved metadata and associates replay with its acknowledged session', async () => {
+  const host = createLocalShellHost({ id: 'saved-local', label: 'Work shell' });
+  const connectionLogs: ConnectionLog[] = [];
+  let appendedHost: Host | undefined;
+  const getCtx = () => ({
+    resolveEffectiveHost: (candidate: Host) => candidate,
+    discoveredShells: [{ id: 'zsh', name: 'Z shell', command: '/bin/zsh' }],
+    terminalSettings: { localShell: 'zsh', localShellArgs: ['-l'], localStartDir: '/tmp/work' },
+    resolveShellSetting: () => ({ command: '/bin/zsh', args: ['-l'] }),
+    systemInfoRef: { current: { username: 'local-user', hostname: 'local-machine' } },
+    keys: [], identities: [], resolveHostAuth: () => ({ username: 'ignored-ssh-user' }),
+    // The App adapts this creation callback to appendHostToWorkspaceConfirmed.
+    connectToHost: (candidate: Host) => {
+      assert.equal(connectionLogs.length, 0, 'do not record history before insertion is acknowledged');
+      appendedHost = candidate;
+      return 'workspace-session';
+    },
+    addConnectionLog: (entry: Omit<ConnectionLog, 'id'>) => {
+      connectionLogs.push({ ...entry, id: 'workspace-log' });
+    },
+  });
+  assert.equal(handleConnectToHostImpl(getCtx, host), 'workspace-session');
+  assert.equal(appendedHost?.localShell, '/bin/zsh');
+  assert.deepEqual(appendedHost?.localShellArgs, ['-l']);
+  assert.equal(appendedHost?.localStartDir, '/tmp/work');
+  assert.equal(connectionLogs.length, 1);
+  assert.equal(connectionLogs[0].sessionId, 'workspace-session');
+  assert.equal(connectionLogs[0].hostId, host.id);
+  assert.equal(connectionLogs[0].hostLabel, 'Work shell');
+  assert.equal(connectionLogs[0].username, 'local-user');
+  assert.equal(connectionLogs[0].protocol, 'local');
+  assert.equal(connectionLogs[0].localHostname, 'local-machine');
+  const updates: Array<{ id: string; terminalData: string }> = [];
+  await handleTerminalDataCaptureImpl(() => ({
+    IS_DEV: false,
+    sessions: [{ id: 'workspace-session', hostname: 'localhost' }],
+    // A newer, same-host log must not steal this session's capture.
+    connectionLogs: [...connectionLogs, { ...connectionLogs[0], id: 'other-log', sessionId: 'other-session', startTime: Date.now() + 100 }],
+    selectConnectionLogForTerminalDataCapture,
+    updateConnectionLog: async (id: string, entry: { terminalData: string }) => { updates.push({ id, terminalData: entry.terminalData }); },
+  }), 'workspace-session', 'captured terminal output');
+  assert.deepEqual(updates, [{ id: 'workspace-log', terminalData: 'captured terminal output' }]);
+});
+
+for (const protocol of ['local', 'ssh', 'serial'] as const) {
+  test(`refused workspace insertion creates no ${protocol} connection log`, () => {
+    let logs = 0;
+    const host = { id: 'host', label: 'Host', hostname: 'target', protocol } as Host;
+    const sessionId = handleConnectToHostImpl(() => ({
+      resolveEffectiveHost: (candidate: Host) => candidate,
+      discoveredShells: [], terminalSettings: {}, resolveShellSetting: () => null,
+      systemInfoRef: { current: { username: 'local-user', hostname: 'local-machine' } },
+      keys: [], identities: [], resolveHostAuth: () => ({ username: 'remote-user' }),
+      connectToHost: () => null,
+      addConnectionLog: () => { logs += 1; },
+    }), host);
+    assert.equal(sessionId, null);
+    assert.equal(logs, 0);
+  });
+}

application/app/AppSideEffects.tsx

@@ -56,6 +56,7 @@ import {
 } from '../../domain/terminalAppearance';
 import { selectConnectionLogForTerminalDataCapture } from '../../domain/connectionLog';
 import { collectSessionIds } from '../../domain/workspace';
+import { resolveAgentHostWorkspace } from '../../domain/agentHostWorkspace';
 import { useHostOpenSessionReuse } from '../state/useHostOpenSessionReuse';
 import type { PaneMagnificationController } from '../../domain/paneMagnification';
 import { resolveCloseIntent } from '../state/resolveCloseIntent';
@@ -70,6 +71,7 @@ import {
 import { getCredentialProtectionAvailability } from '../../infrastructure/services/credentialProtection';
 import { netcattyBridge } from '../../infrastructure/services/netcattyBridge';
 import { localStorageAdapter } from '../../infrastructure/persistence/localStorageAdapter';
+import { terminalHostTreeStore } from '../state/terminalHostTreeStore';
 import {
   markExternalMcpStartupReady,
   readExternalMcpFocusOnHostOpen,
@@ -254,6 +256,7 @@ export function AppSideEffects() {
     createLocalTerminal,
     createSerialSession,
     connectToHost,
+    appendHostToWorkspaceConfirmed,
     closeSession,
     closeSessions,
     closeWorkspace,
@@ -1126,6 +1129,7 @@ export function AppSideEffects() {
       toggleBroadcast,
       toggleGlobalBroadcast,
       canUseGlobalBroadcast: canUseGlobalBroadcastRef.current,
+      toggleHostTree: () => terminalHostTreeStore.toggle(),
       toggleScriptsSidePanelRef,
       toggleSidePanelRef,
       toggleWindowOpacity,
@@ -1456,7 +1460,7 @@ export function AppSideEffects() {
   temporaryConnectionSettingsRef.current = terminalSettings;
 
   // Wrapper to connect to host with logging
-  const handleConnectToHost = useCallback((host: Host, alreadyEffective = false, hidden = false) => {
+  const handleConnectToHost = useCallback((host: Host, alreadyEffective = false, hidden = false, workspaceId?: string) => {
     const liveTerminalSettings = temporaryConnectionSettingsRef.current;
     const connectionHost = prepareConnectionHost(
       host,
@@ -1474,7 +1478,9 @@ export function AppSideEffects() {
       : resolveEffectiveHost;
     return handleConnectToHostImpl(() => ({
       addConnectionLog,
-      connectToHost,
+      connectToHost: workspaceId
+        ? (candidate: Host) => appendHostToWorkspaceConfirmed(workspaceId, candidate)
+        : connectToHost,
       discoveredShells,
       host: connectionHost,
       identities,
@@ -1485,7 +1491,7 @@ export function AppSideEffects() {
       systemInfoRef,
       terminalSettings: liveTerminalSettings,
     }), connectionHost, hidden);
-  }, [addConnectionLog, connectToHost, resolveEffectiveHost, identities, keys, discoveredShells]);
+  }, [addConnectionLog, appendHostToWorkspaceConfirmed, connectToHost, resolveEffectiveHost, identities, keys, discoveredShells]);
 
   const handleConnectToHostWithTabName = useCallback((host: Host, tabName?: string) => {
     const sessionId = handleConnectToHost(host);
@@ -1495,12 +1501,14 @@ export function AppSideEffects() {
     return sessionId;
   }, [handleConnectToHost, renameSessionInline]);
 
-  const openHostForVaultAgent = useCallback((host: Host, isExternalMcpCall: boolean) => {
+  const openHostForVaultAgent = useCallback((host: Host, isExternalMcpCall: boolean, options?: { workspaceId?: string }) => {
+    const target = resolveAgentHostWorkspace(options?.workspaceId, activeTabStore.getActiveTabId(), workspaces.map(workspace => workspace.id));
+    if (target.error) return { ok: false as const, error: target.error };
     // Silent sessions only apply to actual external MCP clients (chatSessionId
     // equals the reserved external-MCP scope). The in-app Catty AI chat's
     // host_open always opens a visible tab, as documented.
     const hidden = isExternalMcpCall && readExternalMcpSilentSessions();
-    const sessionId = handleConnectToHost(host, true, hidden);
+    const sessionId = handleConnectToHost(host, true, hidden, target.workspaceId);
     if (!sessionId) {
       return { ok: false as const, error: `Failed to open host "${host.id}".` };
     }
@@ -1509,8 +1517,8 @@ export function AppSideEffects() {
     if (readExternalMcpFocusOnHostOpen()) {
       void netcattyBridge.get()?.openMainWindow?.();
     }
-    return { ok: true as const, sessionId, host };
-  }, [handleConnectToHost]);
+    return { ok: true as const, sessionId, host, workspaceId: target.workspaceId };
+  }, [handleConnectToHost, workspaces]);
 
   const findExistingSessionForHostForVaultAgent = useHostOpenSessionReuse({
     sessions, hosts, keys, identities, resolveEffectiveHost,

application/app/__fixtures__/transferQuitRenderer.cjs

@@ -0,0 +1,43 @@
+// A separate renderer thread lets the real main-process timeout run while
+// window.confirm is synchronously blocked, just like Electron's native dialog.
+require("tsx/cjs");
+const { parentPort, workerData } = require("node:worker_threads");
+const { EventEmitter } = require("node:events");
+const React = require("react");
+const { act, create } = require("react-test-renderer");
+const { useAppStartupEffects } = require("../useAppStartupEffects.ts");
+const { sftpTransferCenterStore } = require("../../state/sftpTransferCenterStore.ts");
+const { netcattyBridge } = require("../../../infrastructure/services/netcattyBridge.ts");
+const { createPreloadApi } = require("../../../electron/preload/api.cjs");
+const signal = new Int32Array(workerData.signal);
+let resumes = 0;
+global.IS_REACT_ACT_ENVIRONMENT = true;
+global.window = {
+  confirm() {
+    parentPort.postMessage({ type: "prompt" });
+    Atomics.wait(signal, 0, 0, 10000);
+    return workerData.accept;
+  },
+};
+sftpTransferCenterStore.getSnapshot = () => ({ tasks: [{ id: "held-prompt", status: "transferring" }] });
+sftpTransferCenterStore.pause = async () => {};
+sftpTransferCenterStore.resume = async () => { resumes++; };
+const ipcRenderer = Object.assign(new EventEmitter(), {
+  send(channel, payload) { parentPort.postMessage({ type: "reply", channel, payload }); },
+});
+const preload = createPreloadApi({ ipcRenderer, webUtils: {} });
+netcattyBridge.get = () => ({
+  onCheckDirtyEditors(callback) {
+    return preload.onCheckDirtyEditors((request) => {
+      void callback(request).then(() => parentPort.postMessage({ type: "done", resumes }));
+    });
+  },
+  reportDirtyEditorsResult: preload.reportDirtyEditorsResult,
+});
+function Probe() {
+  useAppStartupEffects({ enabled: false, updateState: {}, sessions: [], hosts: [], keys: [], identities: [], knownHosts: [], proxyProfiles: [], groupConfigs: [], workspaces: [], portForwardingRules: [], t: (key) => key });
+  return null;
+}
+parentPort.on("message", ({ channel, payload }) => ipcRenderer.emit(channel, {}, payload));
+void act(async () => { create(React.createElement(Probe)); })
+  .then(() => parentPort.postMessage({ type: "ready" }));

application/app/publishers/SessionPublisher.tsx

@@ -59,6 +59,7 @@ export function SessionPublisher({ persistSessionRestore, children }: SessionPub
     createWorkspaceFromSessions,
     addSessionToWorkspace,
     appendHostToWorkspace,
+    appendHostToWorkspaceConfirmed,
     appendLocalTerminalToWorkspace,
     createWorkspaceFromTargets,
     updateSplitSizes,
@@ -143,6 +144,7 @@ export function SessionPublisher({ persistSessionRestore, children }: SessionPub
     createWorkspaceFromSessions,
     addSessionToWorkspace,
     appendHostToWorkspace,
+    appendHostToWorkspaceConfirmed,
     appendLocalTerminalToWorkspace,
     createWorkspaceFromTargets,
     updateSplitSizes,
@@ -171,6 +173,7 @@ export function SessionPublisher({ persistSessionRestore, children }: SessionPub
   }), [
     addSessionToWorkspace,
     appendHostToWorkspace,
+    appendHostToWorkspaceConfirmed,
     appendLocalTerminalToWorkspace,
     clearSessionFontSizeOverride,
     closeLogView,

application/app/strictModeIdempotency.test.ts

@@ -165,8 +165,12 @@ test('vault init cancels the superseded StrictMode effect before publishing read
   );
   const initAt = vaultSource.indexOf('let cancelled = false;');
   assert.notEqual(initAt, -1, 'vault init must track cancellation');
-  const initSlice = vaultSource.slice(initAt, initAt + 12000);
-  assert.match(initSlice, /return \(\) => \{\s*\n\s*cancelled = true;\s*\n\s*\};/);
+  const initSlice = vaultSource.slice(initAt, initAt + 20000);
+  assert.match(
+    initSlice,
+    /return \(\) => \{\s*\n\s*cancelled = true;\s*\n\s*resolveTerminalDataReady\(\);\s*\n\s*\};/,
+    'StrictMode cleanup cancels init and unblocks the terminal-data ready promise',
+  );
   assert.match(
     initSlice,
     /if \(!cancelled\) \{\s*\n\s*setIsInitialized\(true\);\s*\n\s*setVaultInitialized\(true\);\s*\n\s*\}/,

application/app/useAppStartupEffects.transferQuit.integration.test.ts

@@ -0,0 +1,114 @@
+/* eslint-disable @typescript-eslint/no-explicit-any -- Electron boundary doubles exercise production modules. */
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import { createRequire } from 'node:module';
+import { useAppStartupEffects } from './useAppStartupEffects.ts';
+import { sftpTransferCenterStore } from '../state/sftpTransferCenterStore.ts';
+import { netcattyBridge } from '../../infrastructure/services/netcattyBridge.ts';
+const require = createRequire(import.meta.url);
+const React = require('react');
+const { act, create } = require('react-test-renderer');
+const { createMainWindowApi } = require('../../electron/bridges/windowManager/mainWindow.cjs');
+const { queryDirtyEditors } = require('../../electron/bridges/dirtyEditorGuard.cjs');
+const { createPreloadApi } = require('../../electron/preload/api.cjs');
+
+// No Electron UI, sockets, real transfers, or preferences. Only the network
+// pause completion is held. Actual renderer hook, window close callback, and
+// dirty-query helper run together with the actual 5000ms production deadline.
+for (const slowPause of [true, false]) test(`${slowPause ? 'slow pause refuses close at the production deadline' : 'control: fast pause preserves Cancel'}`, { timeout: 8000 }, async t => {
+  const oldWindow = Object.getOwnPropertyDescriptor(globalThis, 'window');
+  const oldAct = Object.getOwnPropertyDescriptor(globalThis, 'IS_REACT_ACT_ENVIRONMENT');
+  let confirmations = 0, reports = 0, resumeCalls = 0;
+  Object.defineProperty(globalThis, 'window', { configurable: true, value: { confirm() { confirmations++; return false; } } });
+  Object.defineProperty(globalThis, 'IS_REACT_ACT_ENVIRONMENT', { configurable: true, value: true });
+  let renderer: any, releasePause: any;
+  const queryPromises: Promise<void>[] = [];
+  const pause = new Promise<void>(resolve => { releasePause = resolve; });
+  if (!slowPause) releasePause();
+  const ipcMain = new EventEmitter();
+  let win: any;
+  t.after(async () => {
+    releasePause(); await Promise.allSettled(queryPromises);
+    await act(async () => renderer?.unmount());
+    if (oldWindow) Object.defineProperty(globalThis, 'window', oldWindow); else Reflect.deleteProperty(globalThis, 'window');
+    if (oldAct) Object.defineProperty(globalThis, 'IS_REACT_ACT_ENVIRONMENT', oldAct); else Reflect.deleteProperty(globalThis, 'IS_REACT_ACT_ENVIRONMENT');
+  });
+  t.mock.method(sftpTransferCenterStore, 'getSnapshot', () => ({ tasks: [{ id: 'slow-upload', status: 'transferring' }] }) as any);
+  t.mock.method(sftpTransferCenterStore, 'pause', () => pause);
+  t.mock.method(sftpTransferCenterStore, 'resume', async () => { resumeCalls++; });
+  const ipcRenderer = Object.assign(new EventEmitter(), {
+    send(channel: string, payload: any) { reports++; ipcMain.emit(channel, { sender: win.webContents }, payload); },
+  });
+  const preload = createPreloadApi({ ipcRenderer, webUtils: {} });
+  t.mock.method(netcattyBridge, 'get', () => ({
+    onCheckDirtyEditors(callback: any) {
+      return preload.onCheckDirtyEditors((request: any) => { queryPromises.push(callback(request)); });
+    },
+    reportDirtyEditorsResult: preload.reportDirtyEditorsResult,
+  }));
+  function Probe() {
+    useAppStartupEffects({ enabled: false, updateState: {}, sessions: [], hosts: [], keys: [], identities: [], knownHosts: [], proxyProfiles: [], groupConfigs: [], workspaces: [], portForwardingRules: [], t: (key: string) => key } as any);
+    return null;
+  }
+  await act(async () => { renderer = create(React.createElement(Probe)); });
+  class Window extends EventEmitter {
+    destroyed = false;
+    webContents = Object.assign(new EventEmitter(), {
+      id: 71, isDestroyed: () => this.destroyed, isCrashed: () => false,
+      setWindowOpenHandler() {}, openDevTools() {},
+      send(channel: string, payload: any) { ipcRenderer.emit(channel, {}, payload); },
+    });
+    close() { const event = { prevented: false, preventDefault() { this.prevented = true; } }; this.emit('close', event); if (!event.prevented) { this.destroyed = true; this.emit('closed'); } }
+    isDestroyed() { return this.destroyed; }
+    isMaximized() { return false; }
+    isFullScreen() { return false; }
+    getBounds() { return { width: 1000, height: 700 }; }
+    setBackgroundColor() {}
+    loadURL() { return Promise.resolve(); }
+  }
+  const api = createMainWindowApi({
+    mainWindow: null, electronApp: null, currentTheme: 'light', isQuitting: false,
+    pendingWindowStateWrite: null, queuedWindowState: null,
+    DEFAULT_WINDOW_WIDTH: 1400, DEFAULT_WINDOW_HEIGHT: 900, MIN_WINDOW_WIDTH: 1100, MIN_WINDOW_HEIGHT: 640,
+    V8_CACHE_OPTIONS: 'code', THEME_COLORS: { light: {} },
+    unhealthyWebContentsIds: new Set(), rendererReadySeenByWebContentsId: new Set(),
+    __dirname: '/unused/electron/bridges', URL, require, console, setTimeout, clearTimeout,
+    getGlobalShortcutBridge: () => ({ handleWindowClose: () => false }), getMainWindowCount: () => 1,
+    debugLog() {}, resolveFrontendBackgroundColor() { return null; }, loadWindowState() { return null; },
+    getDevRendererBaseUrl: (url: string) => url, getWindowBoundsState() { return null; },
+    queueWindowStateSave() {}, saveWindowStateSync() {}, setupDeferredShow() {},
+    createExternalOnlyWindowOpenHandler() { return {}; }, createAppWindowOpenHandler() { return {}; },
+    attachOAuthLoadingOverlay() {}, registerWindowHandlers() {}, requestWindowCommandClose() {}, shouldCloseWindowFromInput() { return false; },
+    registerMainWindow() {}, unregisterMainWindow() {}, registerAppContentWindow() {}, unregisterAppContentWindow() {},
+    notifyAppContentWindowClosed() {}, applyWindowOpacityToWindow() {}, closeSettingsWindow() {}, hideSettingsWindow() {},
+    hasEditorTabsForSource: () => false, closeEditorTabsForSource: async () => ({ success: true }),
+    queryDirtyEditors(wc: any, timeout: number, options: any) {
+      assert.equal(timeout, 5000, 'real close callback supplies the 5-second timeout');
+      return queryDirtyEditors(wc, timeout, options);
+    },
+  });
+  win = await api.createWindow({ BrowserWindow: Window, nativeTheme: {}, app: {}, screen: {}, shell: {}, ipcMain }, {
+    preload: '/tmp/unused-preload.cjs', devServerUrl: 'http://localhost:5173', isDev: true, isMac: false,
+    electronDir: '/unused/electron', registerAsMainWindow: true,
+  });
+  win.close();
+  assert.equal(win.destroyed, false, 'first close is correctly guarded');
+  await new Promise(resolve => setTimeout(resolve, slowPause ? 5250 : 50));
+  if (!slowPause) {
+    assert.equal(confirmations, 1); assert.equal(reports, 2); assert.equal(resumeCalls, 1);
+    assert.equal(win.destroyed, false, 'Cancel keeps owner alive when pause settles before deadline');
+    console.log('QUIT_FAST_CONTROL', JSON.stringify({ ownerAlive: true, confirmations, reports, resumeCalls }));
+    return;
+  }
+  assert.equal(confirmations, 0, 'slow pause prevents prompt');
+  assert.equal(win.destroyed, false, 'deadline refuses close while the pause is pending');
+  assert.equal(reports, 1, 'only the pending-transfer acknowledgement has been sent');
+  assert.equal(ipcMain.listenerCount('app:dirty-editors-result'), 0, 'main query is settled, not hung');
+  releasePause(); await Promise.allSettled(queryPromises);
+  await new Promise(resolve => setTimeout(resolve, 10));
+  assert.equal(confirmations, 0, 'the expired request must not show a late prompt');
+  assert.equal(win.destroyed, false);
+  assert.equal(resumeCalls, 1);
+  console.log('QUIT_TIMEOUT_REGRESSION', JSON.stringify({ ownerAlive: true, productionDeadlineMs: 5000, scaling: false, resumeCalls }));
+});

application/app/useAppStartupEffects.transferQuit.prompt.test.cjs

@@ -0,0 +1,52 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const { EventEmitter, once } = require("node:events");
+const { Worker } = require("node:worker_threads");
+const { queryDirtyEditors } = require("../../electron/bridges/dirtyEditorGuard.cjs");
+
+for (const accept of [false, true]) {
+  test(`native confirmation held beyond deadline: late ${accept ? "Accept" : "Cancel"} keeps the owner alive`, { timeout: 10000 }, async (t) => {
+    const signal = new SharedArrayBuffer(4);
+    const worker = new Worker(require.resolve("./__fixtures__/transferQuitRenderer.cjs"), {
+      workerData: { accept, signal },
+    });
+    const ipcMain = new EventEmitter();
+    const events = new EventEmitter();
+    const replies = [];
+    let promptShown = false;
+    let closed = false;
+    const wc = {
+      isDestroyed: () => closed,
+      isCrashed: () => false,
+      send(channel, payload) { worker.postMessage({ channel, payload }); },
+    };
+    t.after(async () => { Atomics.store(new Int32Array(signal), 0, 1); Atomics.notify(new Int32Array(signal), 0); await worker.terminate(); });
+    worker.on("message", (message) => {
+      if (message.type === "reply") {
+        replies.push(message.payload);
+        ipcMain.emit(message.channel, { sender: wc }, message.payload);
+      } else {
+        if (message.type === "prompt") promptShown = true;
+        events.emit(message.type, message);
+      }
+    });
+    worker.on("error", (error) => events.emit("error", error));
+    await once(events, "ready");
+    const started = Date.now();
+    const result = await queryDirtyEditors(wc, 5000, { ipcMain });
+    if (!result) closed = true;
+    assert.equal(promptShown, true);
+    assert.equal(result, "transfers");
+    assert.equal(closed, false, "main refuses close while the renderer is blocked in its native prompt");
+    assert.ok(Date.now() - started >= 4900, "use the unchanged five-second production deadline");
+    assert.equal(ipcMain.listenerCount("app:dirty-editors-result"), 0, "main settled without hanging");
+    const done = once(events, "done");
+    Atomics.store(new Int32Array(signal), 0, 1);
+    Atomics.notify(new Int32Array(signal), 0);
+    const [completed] = await done;
+    assert.equal(completed.resumes, 1);
+    assert.equal(replies.at(-1).hasDirty, true, "an expired Accept cannot authorize a later close");
+    assert.equal(replies.at(-1).reason, "transfers");
+    assert.equal(closed, false);
+  });
+}

application/app/useAppStartupEffects.transferQuit.test.ts

@@ -1,11 +1,28 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import React from "react";
+import type { TransferTask } from "../../domain/models";
 import { act, create, type ReactTestRenderer } from "react-test-renderer";
 import { useAppStartupEffects } from "./useAppStartupEffects.ts";
 import { sftpTransferCenterStore } from "../state/sftpTransferCenterStore.ts";
 import { netcattyBridge } from "../../infrastructure/services/netcattyBridge.ts";
 
+const makeTask = (id: string, status: TransferTask["status"]): TransferTask => ({
+  id,
+  fileName: `${id}.txt`,
+  sourcePath: `/source/${id}.txt`,
+  targetPath: `/target/${id}.txt`,
+  sourceConnectionId: "local",
+  targetConnectionId: "remote",
+  direction: "upload",
+  status,
+  totalBytes: 10,
+  transferredBytes: 2,
+  speed: 1,
+  startTime: 1,
+  isDirectory: false,
+});
+
 for (const accept of [false, true]) {
   test(`app Quit with an unfinished transfer: ${accept ? "confirm quits" : "declining reports \"transfers\" before resuming only transferring and queued tasks"}`, async (t) => {
     const previous = Object.getOwnPropertyDescriptor(globalThis, "IS_REACT_ACT_ENVIRONMENT");
@@ -13,7 +30,8 @@ for (const accept of [false, true]) {
     const g = globalThis as unknown as { window?: { confirm?: (m: string) => boolean } };
     const hadWindow = "window" in g; const previousConfirm = g.window?.confirm;
     if (!g.window) g.window = {};
-    g.window.confirm = () => accept;
+    let prompts = 0;
+    g.window.confirm = () => { prompts++; return accept; };
     let renderer: ReactTestRenderer | undefined;
     let releaseResume!: () => void;
     const resumeGate = new Promise<void>((resolve) => { releaseResume = resolve; });
@@ -76,12 +94,159 @@ for (const accept of [false, true]) {
     }
     assert.equal(resumeSettled, false, "the dirty-check reply must not wait for resume");
     if (accept) {
-      assert.deepEqual(reports, [[false, undefined]]);
-      assert.deepEqual(calls, [...paused, "report"], "accepted quit leaves every prompted task paused");
+      assert.deepEqual(reports, [[true, "transfers"], [false, undefined]]);
+      assert.deepEqual(calls, ["report", ...paused, "report"], "accepted quit leaves every prompted task paused");
     } else {
-      assert.deepEqual(reports, [[true, "transfers"]], "main must be told the prompt was already answered");
-      assert.deepEqual(calls, [...paused, "report", "resume:running", "resume:queued"],
+      assert.deepEqual(reports, [[true, "transfers"], [true, "transfers"]], "main must be told the prompt was already answered");
+      assert.deepEqual(calls, ["report", ...paused, "report", "resume:running", "resume:queued"],
         "report precedes resume, and only transferring/queued rows the prompt paused are resumed");
+      // Dedicated resume promises can represent the whole transfer lifetime.
+      // A second close must still prompt while those promises remain pending.
+      await query();
+      assert.equal(prompts, 2);
+      assert.equal(resumeSettled, false);
+      assert.equal(reports.length, 4);
     }
   });
 }
+
+for (const outcome of ["pause-rejected", "pause-expired", "prompt-expired"] as const) {
+  test(`transfer quit refuses ${outcome} and resumes only the formerly active task`, async (t) => {
+    const previousWindow = Object.getOwnPropertyDescriptor(globalThis, "window");
+    const previousAct = Object.getOwnPropertyDescriptor(globalThis, "IS_REACT_ACT_ENVIRONMENT");
+    let renderer: ReactTestRenderer | undefined;
+    let now = 0;
+    let prompts = 0;
+    let resumes = 0;
+    const replies: Array<{ dirty: boolean; reason?: string; requestId?: string; pending?: boolean }> = [];
+    let query!: (request: { requestId: string; deadline: number }) => Promise<void>;
+    t.mock.method(Date, "now", () => now);
+    Object.defineProperty(globalThis, "IS_REACT_ACT_ENVIRONMENT", { configurable: true, value: true });
+    Object.defineProperty(globalThis, "window", { configurable: true, value: {
+      confirm() { prompts++; now = 6000; return true; },
+    } });
+    t.after(async () => {
+      await act(async () => renderer?.unmount());
+      if (previousWindow) Object.defineProperty(globalThis, "window", previousWindow); else Reflect.deleteProperty(globalThis, "window");
+      if (previousAct) Object.defineProperty(globalThis, "IS_REACT_ACT_ENVIRONMENT", previousAct); else Reflect.deleteProperty(globalThis, "IS_REACT_ACT_ENVIRONMENT");
+    });
+    t.mock.method(sftpTransferCenterStore, "getSnapshot", () => ({ activeCount: 1, queuedCount: 0, attentionCount: 0, tasks: [makeTask("running", "transferring")] }));
+    t.mock.method(sftpTransferCenterStore, "pause", async () => {
+      if (outcome === "pause-rejected") throw new Error("pause failed");
+      if (outcome === "pause-expired") now = 6000;
+    });
+    t.mock.method(sftpTransferCenterStore, "resume", async () => { resumes++; });
+    t.mock.method(netcattyBridge, "get", () => ({
+      onCheckDirtyEditors: (callback: typeof query) => { query = callback; return () => {}; },
+      reportDirtyEditorsResult: (dirty: boolean, reason?: string, options?: { requestId?: string; pending?: boolean }) => {
+        replies.push({ dirty, reason, ...options });
+      },
+    }));
+    function Probe() {
+      useAppStartupEffects({ enabled: false, updateState: {}, sessions: [], hosts: [], keys: [], identities: [], knownHosts: [], proxyProfiles: [], groupConfigs: [], workspaces: [], portForwardingRules: [], t: (key: string) => key });
+      return null;
+    }
+    await act(async () => { renderer = create(React.createElement(Probe)); });
+    await query({ requestId: outcome, deadline: 5000 });
+    assert.deepEqual(replies, [
+      { dirty: true, reason: "transfers", requestId: outcome, pending: true },
+      { dirty: true, reason: "transfers", requestId: outcome },
+    ]);
+    assert.equal(prompts, outcome === "prompt-expired" ? 1 : 0);
+    assert.equal(resumes, 1);
+  });
+}
+
+test("a cancelled task can close after an expired stuck pause, and its late completion cannot resume it", async (t) => {
+  const previousWindow = Object.getOwnPropertyDescriptor(globalThis, "window");
+  const previousAct = Object.getOwnPropertyDescriptor(globalThis, "IS_REACT_ACT_ENVIRONMENT");
+  let renderer: ReactTestRenderer | undefined;
+  let now = 0;
+  let cancelled = false;
+  let prompts = 0;
+  let resumes = 0;
+  let releasePause!: () => void;
+  const pause = new Promise<void>((resolve) => { releasePause = resolve; });
+  const replies: Array<{ dirty: boolean; requestId?: string; pending?: boolean }> = [];
+  let query!: (request: { requestId: string; deadline: number }) => Promise<void>;
+  t.mock.method(Date, "now", () => now);
+  Object.defineProperty(globalThis, "IS_REACT_ACT_ENVIRONMENT", { configurable: true, value: true });
+  Object.defineProperty(globalThis, "window", { configurable: true, value: { confirm() { prompts++; return false; } } });
+  t.after(async () => {
+    releasePause();
+    await act(async () => renderer?.unmount());
+    if (previousWindow) Object.defineProperty(globalThis, "window", previousWindow); else Reflect.deleteProperty(globalThis, "window");
+    if (previousAct) Object.defineProperty(globalThis, "IS_REACT_ACT_ENVIRONMENT", previousAct); else Reflect.deleteProperty(globalThis, "IS_REACT_ACT_ENVIRONMENT");
+  });
+  t.mock.method(sftpTransferCenterStore, "getSnapshot", () => ({ activeCount: cancelled ? 0 : 1, queuedCount: 0, attentionCount: 0, tasks: [makeTask("stuck", cancelled ? "cancelled" : "transferring")] }));
+  t.mock.method(sftpTransferCenterStore, "pause", () => pause);
+  t.mock.method(sftpTransferCenterStore, "resume", async () => { resumes++; });
+  t.mock.method(netcattyBridge, "get", () => ({
+    onCheckDirtyEditors: (callback: typeof query) => { query = callback; return () => {}; },
+    reportDirtyEditorsResult: (dirty: boolean, _reason?: string, options?: { requestId?: string; pending?: boolean }) => replies.push({ dirty, ...options }),
+  }));
+  function Probe() {
+    useAppStartupEffects({ enabled: false, updateState: {}, sessions: [], hosts: [], keys: [], identities: [], knownHosts: [], proxyProfiles: [], groupConfigs: [], workspaces: [], portForwardingRules: [], t: (key: string) => key });
+    return null;
+  }
+  await act(async () => { renderer = create(React.createElement(Probe)); });
+  const first = query({ requestId: "stuck", deadline: 5000 });
+  await query({ requestId: "overlap", deadline: 5000 });
+  assert.deepEqual(replies.at(-1), { dirty: true, requestId: "overlap" });
+  now = 6000;
+  cancelled = true;
+  await query({ requestId: "after-cancel", deadline: 11000 });
+  assert.deepEqual(replies.at(-1), { dirty: false, requestId: "after-cancel" });
+  const replyCount = replies.length;
+  releasePause();
+  await first;
+  assert.equal(replies.length, replyCount, "superseded attempt must not reply again");
+  assert.equal(prompts, 0);
+  assert.equal(resumes, 0, "late completion must not undo the user's cancellation");
+});
+
+test("retry Cancel preserves the expired attempt auto-resume ownership", async (t) => {
+  const previousWindow = Object.getOwnPropertyDescriptor(globalThis, "window");
+  const previousAct = Object.getOwnPropertyDescriptor(globalThis, "IS_REACT_ACT_ENVIRONMENT");
+  let renderer: ReactTestRenderer | undefined;
+  let now = 0;
+  let status: TransferTask["status"] = "transferring";
+  let prompts = 0;
+  let resumes = 0;
+  let releasePause!: () => void;
+  const pause = new Promise<void>((resolve) => { releasePause = resolve; });
+  const replies: Array<{ dirty: boolean; requestId?: string; pending?: boolean }> = [];
+  let query!: (request: { requestId: string; deadline: number }) => Promise<void>;
+  t.mock.method(Date, "now", () => now);
+  Object.defineProperty(globalThis, "IS_REACT_ACT_ENVIRONMENT", { configurable: true, value: true });
+  Object.defineProperty(globalThis, "window", { configurable: true, value: { confirm() { prompts++; return false; } } });
+  t.after(async () => {
+    releasePause();
+    await act(async () => renderer?.unmount());
+    if (previousWindow) Object.defineProperty(globalThis, "window", previousWindow); else Reflect.deleteProperty(globalThis, "window");
+    if (previousAct) Object.defineProperty(globalThis, "IS_REACT_ACT_ENVIRONMENT", previousAct); else Reflect.deleteProperty(globalThis, "IS_REACT_ACT_ENVIRONMENT");
+  });
+  t.mock.method(sftpTransferCenterStore, "getSnapshot", () => ({ activeCount: status === "transferring" || status === "pausing" ? 1 : 0, queuedCount: 0, attentionCount: 0, tasks: [makeTask("stuck", status)] }));
+  t.mock.method(sftpTransferCenterStore, "pause", () => { status = "pausing"; return pause; });
+  t.mock.method(sftpTransferCenterStore, "resume", async () => { resumes++; });
+  t.mock.method(netcattyBridge, "get", () => ({
+    onCheckDirtyEditors: (callback: typeof query) => { query = callback; return () => {}; },
+    reportDirtyEditorsResult: (dirty: boolean, _reason?: string, options?: { requestId?: string; pending?: boolean }) => replies.push({ dirty, ...options }),
+  }));
+  function Probe() {
+    useAppStartupEffects({ enabled: false, updateState: {}, sessions: [], hosts: [], keys: [], identities: [], knownHosts: [], proxyProfiles: [], groupConfigs: [], workspaces: [], portForwardingRules: [], t: (key: string) => key });
+    return null;
+  }
+  await act(async () => { renderer = create(React.createElement(Probe)); });
+  const first = query({ requestId: "stuck", deadline: 5000 });
+  await query({ requestId: "overlap", deadline: 5000 });
+  assert.deepEqual(replies.at(-1), { dirty: true, requestId: "overlap" });
+  now = 6000;
+  const retry = query({ requestId: "retry", deadline: 11000 });
+  status = "paused";
+  releasePause();
+  await Promise.all([first, retry]);
+  assert.equal(prompts, 1);
+  assert.equal(resumes, 1, "Cancel must restore work running before the first attempt");
+  assert.deepEqual(replies.at(-1), { dirty: true, requestId: "retry" });
+});

application/app/useAppStartupEffects.ts

@@ -344,12 +344,26 @@ export function useAppStartupEffects(ctx: StartupEffectsContext) {
     };
   }, [enabled, hasRuntimeTunnel, hosts, sessions, portForwardingRules, workspaces]);
 
+  const transferQuitPendingRef = useRef<{ deadline: number; resumeTaskIds: Set<string> } | null>(null);
+
   // Quit guard: block app exit while any editor tab has unsaved changes.
   // Main process sends "app:query-dirty-editors"; we respond with the result.
   useEffect(() => {
     const bridge = netcattyBridge.get();
     if (!bridge?.onCheckDirtyEditors) return;
-    const unsub = bridge.onCheckDirtyEditors(async () => {
+    const unsub = bridge.onCheckDirtyEditors(async (request) => {
+      const response = { requestId: request?.requestId };
+      // Another close request must not start a second pause/prompt while the
+      // first attempt is still pausing or awaiting a decision.
+      const previousAttempt = transferQuitPendingRef.current;
+      if (previousAttempt && Date.now() < previousAttempt.deadline) {
+        bridge.reportDirtyEditorsResult?.(true, "transfers", response);
+        return;
+      }
+      // An expired pause may never settle. Let a retry re-check current tasks
+      // (including a user's cancellation), without granting the old attempt
+      // permission to prompt or resume over that newer decision.
+      let attempt: typeof previousAttempt = null;
       // Always report SOMETHING so the main process doesn't time out for
       // 5 s on an unhandled exception. If we can't determine the state,
       // fail open — losing unsaved work is bad, but stranding the user
@@ -374,24 +388,44 @@ export function useAppStartupEffects(ctx: StartupEffectsContext) {
           if (unfinishedTasks.length > 0) {
             const resumable = unfinishedTasks.filter((task) => (
               task.status === "transferring" || task.status === "queued"
+              || previousAttempt?.resumeTaskIds.has(task.id)
             ));
-            await Promise.allSettled(unfinishedTasks.map((task) => sftpTransferCenterStore.pause(task.id)));
-            hasDirty = !window.confirm(t('sftp.transferCenter.quitConfirm', { count: unfinishedTasks.length }));
-            if (hasDirty) {
-              // The user chose to stay. Main must hear that before any resume:
-              // resume can outlive the 5s dirty-check timeout, and a late reply
-              // lets the app quit anyway. The synchronous dialog is also skipped
-              // because this prompt was already answered.
-              reason = "transfers";
-              tasksToResume = resumable;
+            // A slow pause must never turn the main-process timeout into
+            // permission to quit before the user has made a decision.
+            hasDirty = true;
+            reason = "transfers";
+            tasksToResume = resumable;
+            // A retry inherits the still-unfinished rows the expired attempt
+            // auto-paused. Their current status may already be pausing/paused.
+            attempt = {
+              deadline: request?.deadline ?? Date.now() + 5000,
+              resumeTaskIds: new Set(resumable.map((task) => task.id)),
+            };
+            transferQuitPendingRef.current = attempt;
+            bridge.reportDirtyEditorsResult?.(true, reason, { ...response, pending: true });
+            const paused = await Promise.allSettled(unfinishedTasks.map((task) => sftpTransferCenterStore.pause(task.id)));
+            if (transferQuitPendingRef.current !== attempt) return;
+            const expired = () => request && Date.now() >= request.deadline;
+            if (!expired() && paused.every((result) => result.status === "fulfilled")) {
+              hasDirty = !window.confirm(t('sftp.transferCenter.quitConfirm', { count: unfinishedTasks.length }));
+              // The native prompt can itself outlive the main-process deadline.
+              // An expired acceptance is not permission for a later close attempt.
+              if (expired()) hasDirty = true;
             }
+            if (!hasDirty) {
+              reason = undefined;
+              tasksToResume = [];
+            }
+          } else {
+            // All prior work was finished/cancelled; invalidate its late pause.
+            transferQuitPendingRef.current = null;
           }
         }
       } catch (err) {
         console.error('[App] dirty-editors check failed:', err);
       }
       try {
-        bridge.reportDirtyEditorsResult?.(hasDirty, reason);
+        bridge.reportDirtyEditorsResult?.(hasDirty, reason, response);
       } catch (err) {
         // Reporting itself shouldn't throw, but if the IPC bridge is in a
         // bad state we'd rather log than bubble out of the listener and
@@ -399,8 +433,12 @@ export function useAppStartupEffects(ctx: StartupEffectsContext) {
         console.error('[App] reportDirtyEditorsResult failed:', err);
       }
       if (tasksToResume.length > 0) {
+        // Report refusal before recovery, which may itself take a long time.
+        // A resume promise can span the entire transfer, so do not hold the
+        // close gate until it settles. A later close must be able to pause again.
         void Promise.allSettled(tasksToResume.map((task) => sftpTransferCenterStore.resume(task.id)));
       }
+      if (transferQuitPendingRef.current === attempt) transferQuitPendingRef.current = null;
     });
     return unsub;
   }, [enabled, t]);

application/i18n/locales/en/ai.ts

@@ -582,6 +582,7 @@ export const enAiMessages: Messages = {
   'ai.chat.modelCatalogSourceCached': 'Cached · last success {time}',
   'ai.chat.modelCatalogSourceCachedNoTime': 'Cached',
   'ai.chat.modelCatalogSourcePresets': 'Built-in default list',
+  'ai.chat.refreshModelList': 'Refresh model list',
   'ai.chat.noMatchingModels': 'No matching models',
   'ai.chat.recent': 'Recent',
   'ai.chat.viewAll': 'View All',

application/i18n/locales/en/core.ts

@@ -964,6 +964,7 @@ Highlight the focused split pane:
   'settings.shortcuts.category.terminal': 'Terminal',
   'settings.shortcuts.category.navigation': 'Navigation',
   'settings.shortcuts.category.app': 'App',
+  'settings.shortcuts.binding.toggle-host-tree': 'Toggle Host List',
   'settings.shortcuts.category.sftp': 'SFTP',
 
   // Context menus / common actions

application/i18n/locales/en/monitor.ts

@@ -1,4 +1,9 @@
 export const enMonitorMessages = {
+  "monitor.diskIo": "Disk I/O",
+  "monitor.diskRead": "Read",
+  "monitor.diskWrite": "Write",
+  "monitor.diskIoHint": "Aggregate Linux hardware-backed block-device I/O, excluding partitions and stacked virtual devices. Unavailable until two valid samples; not supported on macOS.",
+
   "monitor.actions": "Panel actions",
   "monitor.unavailable": "Monitoring is unavailable. Try starting again when the connection is restored.",
   "monitor.username": "Username",

application/i18n/locales/en/terminal.ts

@@ -879,6 +879,7 @@ export const enTerminalMessages: Messages = {
   'serial.field.flowControl': 'Flow Control',
   'serial.noPorts': 'No serial ports detected. Connect a device and refresh.',
   'serial.field.customPort': 'Custom Port Path',
+  'serial.field.namedPipeHint': 'Windows VM console: enter \\\\.\\pipe\\name. The VM must create the pipe as a server. Baud rate and framing are ignored.',
   'serial.field.customPortPlaceholder': 'e.g. /dev/ttys001 or COM1',
   'serial.type.hardware': 'Hardware',
   'serial.type.pseudo': 'Pseudo Terminal',

application/i18n/locales/en/vault.ts

@@ -370,6 +370,7 @@ export const enVaultMessages: Messages = {
   'sftp.transfers.openTargetFolder': 'Open target folder',
   'sftp.transfers.openTargetFolderError': 'Could not open target folder',
   'sftp.transfers.copyTargetPath': 'Copy target path',
+  'sftp.transfers.cleanupWarnings': 'Backup cleanup warnings: {count}. Show files for details.',
   'sftp.transfers.copyTargetPathSuccess': 'Target path copied',
   'sftp.transfers.copyTargetPathError': 'Could not copy target path',
   'sftp.transfers.pathConflict.title': 'Transfer blocked',

application/i18n/locales/es/ai.ts

@@ -565,6 +565,7 @@ export const esAiMessages: Messages = {
   'ai.chat.modelCatalogSourceCached': 'En caché · último éxito {time}',
   'ai.chat.modelCatalogSourceCachedNoTime': 'En caché',
   'ai.chat.modelCatalogSourcePresets': 'Lista predeterminada integrada',
+  'ai.chat.refreshModelList': 'Actualizar la lista de modelos',
   'ai.chat.noMatchingModels': 'No hay modelos coincidentes',
   'ai.chat.recent': 'Recientes',
   'ai.chat.viewAll': 'Ver todo',

application/i18n/locales/es/core.ts

@@ -913,6 +913,7 @@ Resalta el panel dividido enfocado:
   'settings.shortcuts.binding.broadcast': 'Alternar modo de transmisión',
   'settings.shortcuts.binding.toggle-opacity': 'Alternar la transparencia de la ventana',
   'settings.shortcuts.binding.toggle-side-panel': 'Alternar panel lateral',
+  'settings.shortcuts.binding.toggle-host-tree': 'Alternar lista de hosts',
   'settings.shortcuts.binding.sftp-copy': 'Copiar archivos',
   'settings.shortcuts.binding.sftp-cut': 'Cortar archivos',
   'settings.shortcuts.binding.sftp-paste': 'Pegar archivos',

application/i18n/locales/es/monitor.ts

@@ -1,4 +1,9 @@
 export const esMonitorMessages = {
+  "monitor.diskIo": "E/S de disco",
+  "monitor.diskRead": "Lectura",
+  "monitor.diskWrite": "Escritura",
+  "monitor.diskIoHint": "E/S agregada de dispositivos de bloques físicos de Linux, sin contar particiones ni capas virtuales. No disponible hasta tener dos muestras válidas; no compatible con macOS.",
+
   "monitor.actions": "Acciones del panel",
   "monitor.unavailable": "La monitorización no está disponible. Iníciala de nuevo cuando se restablezca la conexión.",
   "monitor.username": "Usuario",

application/i18n/locales/es/terminal.ts

@@ -841,6 +841,7 @@ export const esTerminalMessages: Messages = {
   'serial.field.flowControl': 'Control de flujo',
   'serial.noPorts': 'No se detectaron puertos seriales. Conecta un dispositivo y actualiza.',
   'serial.field.customPort': 'Ruta de puerto personalizada',
+  'serial.field.namedPipeHint': 'Consola de VM en Windows: introduce \\\\.\\pipe\\name. La VM debe crear la canalización como servidor. Se ignoran la velocidad y la trama.',
   'serial.field.customPortPlaceholder': 'p. ej., /dev/ttys001 o COM1',
   'serial.type.hardware': 'Hardware',
   'serial.type.pseudo': 'Pseudoterminal',

application/i18n/locales/es/vault.ts

@@ -370,6 +370,7 @@ export const esVaultMessages: Messages = {
   'sftp.transfers.openTargetFolder': 'Abrir carpeta de destino',
   'sftp.transfers.openTargetFolderError': 'No se pudo abrir la carpeta de destino',
   'sftp.transfers.copyTargetPath': 'Copiar ruta de destino',
+  'sftp.transfers.cleanupWarnings': 'Avisos de limpieza de copias de seguridad: {count}. Muestra los archivos para ver los detalles.',
   'sftp.transfers.copyTargetPathSuccess': 'Ruta de destino copiada',
   'sftp.transfers.copyTargetPathError': 'No se pudo copiar la ruta de destino',
   'sftp.transfers.pathConflict.title': 'Transferencia bloqueada',

application/i18n/locales/ru/ai.ts

@@ -521,6 +521,7 @@ export const ruAiMessages: Messages = {
   'ai.chat.modelCatalogSourceCached': 'Кэш · обновлён {time}',
   'ai.chat.modelCatalogSourceCachedNoTime': 'Кэш',
   'ai.chat.modelCatalogSourcePresets': 'Встроенный список моделей',
+  'ai.chat.refreshModelList': 'Обновить список моделей',
   'ai.chat.noMatchingModels': 'Нет подходящих моделей',
   'ai.chat.recent': 'Недавние',
   'ai.chat.viewAll': 'Показать всё',

application/i18n/locales/ru/core.ts

@@ -938,6 +938,7 @@ export const ruCoreMessages: Messages = {
   'settings.shortcuts.binding.broadcast': 'Переключить режим трансляции',
   'settings.shortcuts.binding.toggle-opacity': 'Переключить прозрачность окна',
   'settings.shortcuts.binding.toggle-side-panel': 'Переключить боковую панель',
+  'settings.shortcuts.binding.toggle-host-tree': 'Переключить список хостов',
   'settings.shortcuts.binding.sftp-copy': 'Копировать файл',
   'settings.shortcuts.binding.sftp-cut': 'Вырезать файл',
   'settings.shortcuts.binding.sftp-paste': 'Вставить файл',

application/i18n/locales/ru/monitor.ts

@@ -1,4 +1,9 @@
 export const ruMonitorMessages = {
+  "monitor.diskIo": "Дисковый ввод-вывод",
+  "monitor.diskRead": "Чтение",
+  "monitor.diskWrite": "Запись",
+  "monitor.diskIoHint": "Суммарный ввод-вывод физических блочных устройств Linux, без разделов и виртуальных слоёв. Доступен после двух корректных замеров; macOS не поддерживается.",
+
   "monitor.actions": "Действия панели",
   "monitor.unavailable": "Мониторинг недоступен. Запустите его снова после восстановления связи.",
   "monitor.username": "Пользователь",

application/i18n/locales/ru/terminal.ts

@@ -886,6 +886,7 @@ export const ruTerminalMessages: Messages = {
   'serial.field.flowControl': 'Управление потоком',
   'serial.noPorts': 'Последовательные порты не обнаружены. Подключите устройство и обновите список.',
   'serial.field.customPort': 'Путь к пользовательскому порту',
+  'serial.field.namedPipeHint': 'Консоль ВМ Windows: введите \\\\.\\pipe\\name. ВМ должна создать канал как сервер. Скорость и параметры кадра игнорируются.',
   'serial.field.customPortPlaceholder': 'например, /dev/ttys001 или COM1',
   'serial.type.hardware': 'Аппаратный',
   'serial.type.pseudo': 'Псевдотерминал',

application/i18n/locales/ru/vault.ts

@@ -413,6 +413,7 @@ export const ruVaultMessages: Messages = {
   'sftp.transfers.openTargetFolder': 'Открыть целевую папку',
   'sftp.transfers.openTargetFolderError': 'Не удалось открыть целевую папку',
   'sftp.transfers.copyTargetPath': 'Копировать целевой путь',
+  'sftp.transfers.cleanupWarnings': 'Предупреждения об удалении резервных копий: {count}. Откройте список файлов для подробностей.',
   'sftp.transfers.copyTargetPathSuccess': 'Целевой путь скопирован',
   'sftp.transfers.copyTargetPathError': 'Не удалось скопировать целевой путь',
   'sftp.transfers.pathConflict.title': 'Передача заблокирована',

application/i18n/locales/sftpCleanupWarningLocales.test.ts

@@ -0,0 +1,13 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import en from "./en";
+import es from "./es";
+import ru from "./ru";
+import zhCN from "./zh-CN";
+import zhTW from "./zh-TW";
+
+test("folder cleanup-warning counts are localized in every supported locale", () => {
+  for (const [locale, messages] of Object.entries({ en, es, ru, zhCN, zhTW })) {
+    assert.match(messages["sftp.transfers.cleanupWarnings"] ?? "", /\{count\}/, locale);
+  }
+});

application/i18n/locales/zh-CN/ai.ts

@@ -582,6 +582,7 @@ export const zhCNAiMessages: Messages = {
   'ai.chat.modelCatalogSourceCached': '缓存 · 上次成功 {time}',
   'ai.chat.modelCatalogSourceCachedNoTime': '缓存',
   'ai.chat.modelCatalogSourcePresets': '内置默认列表',
+  'ai.chat.refreshModelList': '刷新模型列表',
   'ai.chat.noMatchingModels': '没有匹配的模型',
   'ai.chat.recent': '最近',
   'ai.chat.viewAll': '查看全部',

application/i18n/locales/zh-CN/core.ts

@@ -1035,6 +1035,7 @@ Vaults 标签保持扁平，不使用这块背景。
   'sftp.transfers.openTargetFolder': '打开目标目录',
   'sftp.transfers.openTargetFolderError': '无法打开目标目录',
   'sftp.transfers.copyTargetPath': '复制目标路径',
+  'sftp.transfers.cleanupWarnings': '备份清理警告：{count}。展开文件列表查看详情。',
   'sftp.transfers.copyTargetPathSuccess': '已复制目标路径',
   'sftp.transfers.copyTargetPathError': '无法复制目标路径',
   'sftp.transfers.pathConflict.title': '无法开始传输',

application/i18n/locales/zh-CN/monitor.ts

@@ -1,4 +1,9 @@
 export const zhCNMonitorMessages = {
+  "monitor.diskIo": "磁盘 I/O",
+  "monitor.diskRead": "读取",
+  "monitor.diskWrite": "写入",
+  "monitor.diskIoHint": "Linux 底层块设备的汇总 I/O，不重复统计分区和叠加的虚拟设备。取得两次有效采样前不可用；暂不支持 macOS。",
+
   "monitor.actions": "面板操作",
   "monitor.unavailable": "监控暂不可用，连接恢复后请重新开始。",
   "monitor.username": "用户名",

application/i18n/locales/zh-CN/terminal.ts

@@ -621,6 +621,7 @@ export const zhCNTerminalMessages: Messages = {
   'settings.shortcuts.binding.broadcast': '切换广播模式',
   'settings.shortcuts.binding.toggle-opacity': '切换窗口透明度',
   'settings.shortcuts.binding.toggle-side-panel': '切换侧边栏',
+  'settings.shortcuts.binding.toggle-host-tree': '切换主机列表',
   'settings.shortcuts.binding.sftp-copy': '复制文件',
   'settings.shortcuts.binding.sftp-cut': '剪切文件',
   'settings.shortcuts.binding.sftp-paste': '粘贴文件',
@@ -968,6 +969,7 @@ export const zhCNTerminalMessages: Messages = {
   'serial.field.flowControl': '流控制',
   'serial.noPorts': '未检测到串口设备。请连接设备后刷新。',
   'serial.field.customPort': '自定义串口路径',
+  'serial.field.namedPipeHint': 'Windows 虚拟机控制台：输入 \\\\.\\pipe\\name。虚拟机需作为服务端创建管道，波特率和串口帧设置不生效。',
   'serial.field.customPortPlaceholder': '例如 /dev/ttys001 或 COM1',
   'serial.type.hardware': '硬件',
   'serial.type.pseudo': '虚拟终端',

application/i18n/locales/zh-TW/ai.ts

@@ -572,6 +572,7 @@ export const zhTWAiMessages: Messages = {
   'ai.chat.modelCatalogSourceCached': '快取 · 上次成功 {time}',
   'ai.chat.modelCatalogSourceCachedNoTime': '快取',
   'ai.chat.modelCatalogSourcePresets': '內建預設清單',
+  'ai.chat.refreshModelList': '重新整理模型清單',
   'ai.chat.noMatchingModels': '沒有符合的模型',
   'ai.chat.recent': '最近',
   'ai.chat.viewAll': '檢視全部',

application/i18n/locales/zh-TW/core.ts

@@ -1037,6 +1037,7 @@ Vaults 分頁維持扁平，不使用這塊背景。
   'sftp.transfers.openTargetFolder': '開啟目標目錄',
   'sftp.transfers.openTargetFolderError': '無法開啟目標目錄',
   'sftp.transfers.copyTargetPath': '複製目標路徑',
+  'sftp.transfers.cleanupWarnings': '備份清理警告：{count}。展開檔案清單查看詳情。',
   'sftp.transfers.copyTargetPathSuccess': '已複製目標路徑',
   'sftp.transfers.copyTargetPathError': '無法複製目標路徑',
   'sftp.transfers.pathConflict.title': '無法開始傳輸',

application/i18n/locales/zh-TW/monitor.ts

@@ -1,4 +1,9 @@
 export const zhTWMonitorMessages = {
+  "monitor.diskIo": "磁碟 I/O",
+  "monitor.diskRead": "讀取",
+  "monitor.diskWrite": "寫入",
+  "monitor.diskIoHint": "Linux 底層區塊裝置的彙總 I/O，不重複統計分割區與疊加的虛擬裝置。取得兩次有效取樣前無法使用；暫不支援 macOS。",
+
   "monitor.actions": "面板操作",
   "monitor.unavailable": "監控暫時無法使用，連線恢復後請重新開始。",
   "monitor.username": "使用者名稱",

application/i18n/locales/zh-TW/terminal.ts

@@ -621,6 +621,7 @@ export const zhTWTerminalMessages: Messages = {
   'settings.shortcuts.binding.broadcast': '切換廣播模式',
   'settings.shortcuts.binding.toggle-opacity': '切換視窗透明度',
   'settings.shortcuts.binding.toggle-side-panel': '切換側邊欄',
+  'settings.shortcuts.binding.toggle-host-tree': '切換主機列表',
   'settings.shortcuts.binding.sftp-copy': '複製檔案',
   'settings.shortcuts.binding.sftp-cut': '剪下檔案',
   'settings.shortcuts.binding.sftp-paste': '貼上檔案',
@@ -968,6 +969,7 @@ export const zhTWTerminalMessages: Messages = {
   'serial.field.flowControl': '流量控制',
   'serial.noPorts': '未偵測到序列埠裝置。請連線裝置後重新整理。',
   'serial.field.customPort': '自訂序列埠路徑',
+  'serial.field.namedPipeHint': 'Windows 虛擬機主控台：輸入 \\\\.\\pipe\\name。虛擬機需作為伺服器端建立管道，鮑率與串口框架設定不生效。',
   'serial.field.customPortPlaceholder': '例如 /dev/ttys001 或 COM1',
   'serial.type.hardware': '硬體',
   'serial.type.pseudo': '虛擬終端',

application/state/editorWindowClient.test.ts

@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { netcattyBridge } from "../../infrastructure/services/netcattyBridge.ts";
 import { editorTabStore } from "./editorTabStore.ts";
-import { dockDetachedEditorTab, installEditorWindowSourceListeners, popOutEditorTab, saveDetachedEditorTab } from "./editorWindowClient.ts";
+import { dockDetachedEditorTab, installEditorWindowSourceListeners, popOutEditorTab, saveDetachedEditorTab, subscribeEditorWindowDirtyCheck } from "./editorWindowClient.ts";
 import { registerEditorSftpWriterScoped } from "./editorSftpBridge.ts";
 import { releaseEditorTabSaveCoordinator } from "./editorTabSave.ts";
 import type { EditorWindowSaveRequest, EditorWindowSaveResult } from "./editorWindowTypes.ts";
@@ -145,3 +145,16 @@ test("a closing destination rejects a popout without releasing source content",
   assert.equal(tab.baselineContent, "v1");
   assert.equal(editorTabStore.isDirty(tab.id), true);
 });
+
+
+test("detached editor dirty-check replies echo the main-process request", (t) => {
+  let query!: (request: { requestId: string; deadline: number }) => void;
+  const replies: unknown[] = [];
+  t.mock.method(netcattyBridge, "get", () => ({
+    onCheckDirtyEditors: (callback: typeof query) => { query = callback; return () => {}; },
+    reportDirtyEditorsResult: (...args: unknown[]) => replies.push(args),
+  }));
+  t.after(subscribeEditorWindowDirtyCheck(() => true));
+  query({ requestId: "detached-check", deadline: Date.now() + 5000 });
+  assert.deepEqual(replies, [[true, undefined, { requestId: "detached-check" }]]);
+});

application/state/editorWindowClient.ts

@@ -200,7 +200,7 @@ export function reportEditorWindowCloseTabsResult(
 export function subscribeEditorWindowDirtyCheck(cb: () => boolean): () => void {
   const bridge = netcattyBridge.get();
   if (!bridge?.onCheckDirtyEditors) return () => {};
-  return bridge.onCheckDirtyEditors(() => {
+  return bridge.onCheckDirtyEditors((request) => {
     let hasDirty = false;
     try {
       hasDirty = cb() === true;
@@ -208,7 +208,7 @@ export function subscribeEditorWindowDirtyCheck(cb: () => boolean): () => void {
       hasDirty = false;
     }
     try {
-      bridge.reportDirtyEditorsResult?.(hasDirty);
+      bridge.reportDirtyEditorsResult?.(hasDirty, undefined, { requestId: request?.requestId });
     } catch {
       // ignore
     }

application/state/hiddenTabEviction.test.ts

@@ -0,0 +1,255 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { decideHiddenTabKeepCountAction } from "../../domain/terminalHibernate.ts";
+import { retainLeavingTabAfterEviction } from "./hiddenTabEviction.ts";
+import { terminalHiddenRendererStore } from "./terminalHiddenRendererStore.ts";
+
+test("a refused eviction tries the next candidate, then full-hibernates", async () => {
+  const attempts: string[] = [];
+  const outcomes: string[] = [];
+  await retainLeavingTabAfterEviction({
+    sessionId: "leaving",
+    candidates: ["images", "plain"],
+    keepCount: 2,
+    stillWantsRetention: () => true,
+    softHide: () => outcomes.push("soft-hide"),
+    fullHibernate: () => outcomes.push("full-hibernate"),
+    evict: async (sessionId) => {
+      attempts.push(sessionId);
+      return sessionId === "plain";
+    },
+  });
+  assert.deepEqual(attempts, ["images", "plain"]);
+  assert.deepEqual(outcomes, ["soft-hide"]);
+
+  const blocked: string[] = [];
+  const blockedOutcomes: string[] = [];
+  await retainLeavingTabAfterEviction({
+    sessionId: "leaving",
+    candidates: ["images", "also-images"],
+    keepCount: 2,
+    stillWantsRetention: () => true,
+    softHide: () => blockedOutcomes.push("soft-hide"),
+    fullHibernate: () => blockedOutcomes.push("full-hibernate"),
+    evict: async (sessionId) => {
+      blocked.push(sessionId);
+      return false;
+    },
+  });
+  assert.deepEqual(blocked, ["images", "also-images"]);
+  assert.deepEqual(blockedOutcomes, ["full-hibernate"]);
+  assert.equal(terminalHiddenRendererStore.getSoftHiddenOccupancy(), 0);
+});
+
+test("hibernate failure after the soft-hidden marker drops does not retain the leaving tab", async () => {
+  const attempts: string[] = [];
+  const outcomes: string[] = [];
+  await retainLeavingTabAfterEviction({
+    sessionId: "leaving",
+    candidates: ["victim"],
+    keepCount: 2,
+    stillWantsRetention: () => true,
+    softHide: () => outcomes.push("soft-hide"),
+    fullHibernate: () => outcomes.push("full-hibernate"),
+    evict: async (sessionId) => {
+      attempts.push(sessionId);
+      await Promise.resolve();
+      return false;
+    },
+  });
+  assert.deepEqual(attempts, ["victim"]);
+  assert.deepEqual(outcomes, ["full-hibernate"]);
+
+  const recovered: string[] = [];
+  const recoveredOutcomes: string[] = [];
+  await retainLeavingTabAfterEviction({
+    sessionId: "leaving",
+    candidates: ["victim", "next"],
+    keepCount: 2,
+    stillWantsRetention: () => true,
+    softHide: () => recoveredOutcomes.push("soft-hide"),
+    fullHibernate: () => recoveredOutcomes.push("full-hibernate"),
+    evict: async (sessionId) => {
+      recovered.push(sessionId);
+      await Promise.resolve();
+      return sessionId === "next";
+    },
+  });
+  assert.deepEqual(recovered, ["victim", "next"]);
+  assert.deepEqual(recoveredOutcomes, ["soft-hide"]);
+});
+
+test("a live keep count that still fits after eviction soft-hides the leaving tab", async () => {
+  let keepCount = 0;
+  const outcomes: string[] = [];
+  await retainLeavingTabAfterEviction({
+    sessionId: "leaving",
+    candidates: ["victim"],
+    keepCount,
+    resolveKeepCount: () => keepCount,
+    stillWantsRetention: () => true,
+    softHide: () => outcomes.push("soft-hide"),
+    fullHibernate: () => outcomes.push("full-hibernate"),
+    evict: async () => {
+      keepCount = 2;
+      await Promise.resolve();
+      return true;
+    },
+  });
+  assert.deepEqual(outcomes, ["soft-hide"]);
+  assert.equal(terminalHiddenRendererStore.getSoftHiddenOccupancy(), 0);
+});
+
+test("a keep count dropped to zero during eviction full-hibernates the leaving tab", async () => {
+  let keepCount = 2;
+  const outcomes: string[] = [];
+  await retainLeavingTabAfterEviction({
+    sessionId: "leaving",
+    candidates: ["victim"],
+    keepCount,
+    resolveKeepCount: () => keepCount,
+    stillWantsRetention: () => true,
+    softHide: () => outcomes.push("soft-hide"),
+    fullHibernate: () => outcomes.push("full-hibernate"),
+    evict: async () => {
+      keepCount = 0;
+      await Promise.resolve();
+      return true;
+    },
+  });
+  assert.deepEqual(outcomes, ["full-hibernate"]);
+  assert.equal(terminalHiddenRendererStore.getSoftHiddenOccupancy(), 0);
+});
+
+test("a keep count that no longer fits after eviction full-hibernates the leaving tab", async () => {
+  const sessions = ["victim", "other", "leaving"];
+  for (const sessionId of sessions) terminalHiddenRendererStore.clearSoftHidden(sessionId);
+  terminalHiddenRendererStore.markSoftHidden("other");
+  let keepCount = 2;
+  const outcomes: string[] = [];
+  try {
+    await retainLeavingTabAfterEviction({
+      sessionId: "leaving",
+      candidates: ["victim"],
+      keepCount,
+      resolveKeepCount: () => keepCount,
+      stillWantsRetention: () => true,
+      softHide: () => outcomes.push("soft-hide"),
+      fullHibernate: () => outcomes.push("full-hibernate"),
+      evict: async () => {
+        keepCount = 1;
+        await Promise.resolve();
+        return true;
+      },
+    });
+    assert.deepEqual(outcomes, ["full-hibernate"]);
+    assert.equal(terminalHiddenRendererStore.isSoftHidden("leaving"), false);
+  } finally {
+    for (const sessionId of sessions) terminalHiddenRendererStore.clearSoftHidden(sessionId);
+  }
+});
+
+test("a leaving tab that no longer wants retention is not soft-hidden or hibernated", async () => {
+  const outcomes: string[] = [];
+  await retainLeavingTabAfterEviction({
+    sessionId: "leaving",
+    candidates: ["victim"],
+    keepCount: 2,
+    stillWantsRetention: () => false,
+    softHide: () => outcomes.push("soft-hide"),
+    fullHibernate: () => outcomes.push("full-hibernate"),
+    evict: async () => true,
+  });
+  assert.deepEqual(outcomes, []);
+  assert.equal(terminalHiddenRendererStore.getSoftHiddenOccupancy(), 0);
+});
+
+test("a pending reservation keeps a second tab from seeing spare capacity", async () => {
+  const sessions = ["victim", "other", "leaving"];
+  for (const sessionId of sessions) terminalHiddenRendererStore.clearSoftHidden(sessionId);
+  terminalHiddenRendererStore.markSoftHidden("victim");
+  terminalHiddenRendererStore.markSoftHidden("other");
+
+  const unsubscribe = terminalHiddenRendererStore.subscribe(() => {
+    if (!terminalHiddenRendererStore.consumeEvictionRequest("victim")) return;
+    terminalHiddenRendererStore.clearSoftHidden("victim");
+  });
+
+  const outcomes: string[] = [];
+  const pending = retainLeavingTabAfterEviction({
+    sessionId: "leaving",
+    candidates: ["victim"],
+    keepCount: 2,
+    stillWantsRetention: () => true,
+    softHide: () => {
+      terminalHiddenRendererStore.markSoftHidden("leaving");
+      outcomes.push("soft-hide");
+    },
+    fullHibernate: () => outcomes.push("full-hibernate"),
+    evict: (sessionId) => terminalHiddenRendererStore.evictSoftHidden(sessionId),
+  });
+
+  try {
+    assert.equal(terminalHiddenRendererStore.isSoftHidden("victim"), false);
+    assert.equal(terminalHiddenRendererStore.getSoftHiddenCount(), 1);
+    assert.equal(terminalHiddenRendererStore.getSoftHiddenOccupancy(), 2);
+    assert.deepEqual(decideHiddenTabKeepCountAction({
+      keepCount: 2,
+      softHiddenCount: terminalHiddenRendererStore.getSoftHiddenOccupancy(),
+      sessionId: "second",
+      candidatesOldestFirst: terminalHiddenRendererStore.listSoftHiddenOldestFirst(),
+    }), { action: "await-eviction", candidates: ["other"] });
+
+    terminalHiddenRendererStore.settleEviction("victim", true);
+    await pending;
+    assert.deepEqual(outcomes, ["soft-hide"]);
+    assert.equal(terminalHiddenRendererStore.getSoftHiddenCount(), 2);
+    assert.equal(terminalHiddenRendererStore.getSoftHiddenOccupancy(), 2);
+  } finally {
+    unsubscribe();
+    terminalHiddenRendererStore.settleEviction("victim", false);
+    for (const sessionId of sessions) terminalHiddenRendererStore.clearSoftHidden(sessionId);
+    await pending.catch(() => undefined);
+  }
+});
+
+test("two leaving tabs share one freed slot and stay within keep-count", async () => {
+  const sessions = ["victim", "other", "leaving-a", "leaving-b"];
+  for (const sessionId of sessions) terminalHiddenRendererStore.clearSoftHidden(sessionId);
+  terminalHiddenRendererStore.markSoftHidden("victim");
+  terminalHiddenRendererStore.markSoftHidden("other");
+
+  const unsubscribe = terminalHiddenRendererStore.subscribe(() => {
+    if (!terminalHiddenRendererStore.consumeEvictionRequest("victim")) return;
+    terminalHiddenRendererStore.clearSoftHidden("victim");
+    queueMicrotask(() => {
+      terminalHiddenRendererStore.settleEviction("victim", true);
+    });
+  });
+
+  const retained: string[] = [];
+  const hibernated: string[] = [];
+  const retain = (sessionId: string) => retainLeavingTabAfterEviction({
+    sessionId,
+    candidates: ["victim"],
+    keepCount: 2,
+    stillWantsRetention: () => true,
+    softHide: () => {
+      terminalHiddenRendererStore.markSoftHidden(sessionId);
+      retained.push(sessionId);
+    },
+    fullHibernate: () => hibernated.push(sessionId),
+  });
+
+  try {
+    await Promise.all([retain("leaving-a"), retain("leaving-b")]);
+    assert.equal(retained.length, 1);
+    assert.equal(hibernated.length, 1);
+    assert.equal(terminalHiddenRendererStore.getSoftHiddenCount(), 2);
+    assert.equal(terminalHiddenRendererStore.getSoftHiddenOccupancy(), 2);
+  } finally {
+    unsubscribe();
+    for (const sessionId of sessions) terminalHiddenRendererStore.clearSoftHidden(sessionId);
+  }
+});

application/state/hiddenTabEviction.ts

@@ -0,0 +1,53 @@
+import { terminalHiddenRendererStore } from "./terminalHiddenRendererStore.ts";
+
+/**
+ * Walk keep-count victims until one hibernate completes, then retain the
+ * leaving tab only if its reserved slot still fits.
+ *
+ * The reservation is taken before the first await. Clearing a victim marker
+ * during wake would otherwise look like spare capacity to a second hidden-tab
+ * timer, and both tabs would soft-hide once the same eviction resolved.
+ */
+export async function retainLeavingTabAfterEviction(input: {
+  sessionId: string;
+  candidates: readonly string[];
+  /** Count captured when this leave started. Used only if resolveKeepCount is absent. */
+  keepCount: number;
+  /**
+   * Live keep-count read after eviction settles. Settings can change while the
+   * victim drains or serializes; retaining against the captured count would
+   * soft-hide a tab the user no longer wants kept.
+   */
+  resolveKeepCount?: () => number;
+  stillWantsRetention: () => boolean;
+  softHide: () => void;
+  fullHibernate: () => void;
+  evict?: (sessionId: string) => Promise<boolean> | boolean;
+}): Promise<void> {
+  const token = terminalHiddenRendererStore.reserveLeavingSlot(input.sessionId);
+  try {
+    const evict = input.evict ?? ((sessionId: string) => (
+      terminalHiddenRendererStore.evictSoftHidden(sessionId)
+    ));
+    let completed = false;
+    for (const candidate of input.candidates) {
+      if (!candidate || candidate === input.sessionId) continue;
+      if (await evict(candidate)) {
+        completed = true;
+        break;
+      }
+    }
+    if (!input.stillWantsRetention()) return;
+    const keepCount = input.resolveKeepCount?.() ?? input.keepCount;
+    if (
+      completed
+      && terminalHiddenRendererStore.leavingSlotStillFits(input.sessionId, keepCount)
+    ) {
+      input.softHide();
+      return;
+    }
+    input.fullHibernate();
+  } finally {
+    terminalHiddenRendererStore.releaseLeavingSlot(input.sessionId, token);
+  }
+}

application/state/sessionSnapshotStore.test.ts

@@ -91,6 +91,7 @@ test('session actions register and unregister', () => {
     createWorkspaceFromSessions: noop,
     addSessionToWorkspace: noop,
     appendHostToWorkspace: noop,
+    appendHostToWorkspaceConfirmed: noop,
     appendLocalTerminalToWorkspace: noop,
     createWorkspaceFromTargets: noop,
     updateSplitSizes: noop,

application/state/sessionSnapshotStore.ts

@@ -57,6 +57,7 @@ export type SessionSnapshotActions = Pick<
   | 'createWorkspaceFromSessions'
   | 'addSessionToWorkspace'
   | 'appendHostToWorkspace'
+  | 'appendHostToWorkspaceConfirmed'
   | 'appendLocalTerminalToWorkspace'
   | 'createWorkspaceFromTargets'
   | 'updateSplitSizes'

application/state/sftp/retryFromCheckpoint.test.ts

@@ -10,6 +10,18 @@ const failed = (over: Partial<TransferTask> = {}): TransferTask => ({
   speed: 0, startTime: 1, isDirectory: false, error: "SFTP channel closed", ...over,
 });
 
+test("canRetryFromCheckpoint resumes the channel-loss forms the bridge already classifies", () => {
+  for (const error of [
+    "read ECONNABORTED",
+    "socket hang up",
+    "ERR_SFTP_CHANNEL_CLOSED",
+    "SFTP pipelined upload failed: socket hang up",
+    "client-socket",
+  ]) {
+    assert.equal(canRetryFromCheckpoint(failed({ error })), true, error);
+  }
+});
+
 test("canRetryFromCheckpoint only for a top-level file that lost its connection with progress", () => {
   assert.equal(canRetryFromCheckpoint(failed()), true);
   assert.equal(canRetryFromCheckpoint(failed({ error: "read ECONNRESET" })), true);

application/state/sftp/retryFromCheckpoint.ts

@@ -4,7 +4,11 @@ import type { TransferTask } from "../../../domain/models";
 // .part is intact up to the checkpoint, so Retry can continue from it instead
 // of restarting at byte 0 (which also strands the old stage on the server,
 // because the new attempt stages under a fresh transfer id).
-const SESSION_LOSS_ERROR = /SFTP (channel closed|session lost)|ECONNRESET|EPIPE|Not connected|No response from server|Keepalive timeout|connection (lost|closed|reset)/i;
+// Keep this identical to UPLOAD_PREFIX_SESSION_LOSS in transferBridge.cjs, and
+// cover every code or message isSftpChannelLossError already treats as channel
+// loss (including ECONNABORTED, socket hang up, ERR_SFTP_CHANNEL_CLOSED, and
+// client-socket). A miss here restarts at byte 0 and strands the .part.
+const SESSION_LOSS_ERROR = /SFTP (channel closed|session lost)|ERR_SFTP_CHANNEL_CLOSED|ECONNRESET|ECONNABORTED|EPIPE|Not connected|No response from server|Keepalive timeout|socket hang up|client-socket|connection (lost|closed|reset)/i;
 
 /**
  * True when Retry should resume the same task from its checkpoint.

application/state/sftp/transferHistoryRestoreMigration.ts

@@ -163,6 +163,9 @@ export async function restoreSftpTransferHistoryCooperatively(
       const child = parentChildren[childIndex];
       if (
         child.status === "completed"
+        // Match canonical pruning: warning rows carry recovery paths that
+        // cannot be represented by the directory's compact manifest.
+        && !child.warning
         && Number.isSafeInteger(child.directoryEntryIndex)
         && (child.directoryEntryIndex ?? checkpoint.coveredEntries) < checkpoint.coveredEntries
         && /^[a-f0-9]{64}$/.test(child.directoryEntryIdentity ?? "")

application/state/sftp/transferSettlementObservation.test.ts

@@ -135,6 +135,34 @@ test("completed dispatch consumes only exact identity and never restarts", async
   assert.equal(store.getTask(task.id)?.status, "completed");
 });
 
+test("successful invoke warnings reach the child before local completion can compact it", async (t) => {
+  const { sftpTransferCenterStore: store } = await import("../sftpTransferCenterStore");
+  const { runTransferAndWaitForOwner } = await import("./waitForTransferOwner");
+  const task = { ...child(), id: "warning-result-child", parentTaskId: "warning-result-root" };
+  const root = { ...task, id: task.parentTaskId, parentTaskId: undefined, isDirectory: true };
+  const warning = "Upload completed; remove backup /target/.netcatty-backup-a manually.";
+  store.upsertTasks([root, task]);
+  t.after(() => store.dismiss(root.id));
+  const result = await runTransferAndWaitForOwner(task, async () => ({ warning }), () => false);
+  assert.equal(result?.warning, warning);
+  assert.equal(store.getTask(task.id)?.warning, warning, "capture metadata before the caller finishes the child");
+  store.patchTask(task.id, { status: "completed", transferredBytes: 1 });
+  assert.equal(store.getTask(task.id)?.status, "completed", "warning-bearing children stay available for inspection");
+  assert.equal(store.getTask(task.id)?.warning, warning);
+});
+
+for (const outcome of [{ error: "write failed" }, { cancelled: true }]) {
+  test(`unsuccessful invoke results do not add cleanup warnings (${JSON.stringify(outcome)})`, async (t) => {
+    const { sftpTransferCenterStore: store } = await import("../sftpTransferCenterStore");
+    const { runTransferAndWaitForOwner } = await import("./waitForTransferOwner");
+    const task = { ...child(), id: `unsuccessful-warning-${"error" in outcome ? "failed" : "cancelled"}`, parentTaskId: undefined };
+    store.upsertTasks([task]);
+    t.after(() => store.dismiss(task.id));
+    await runTransferAndWaitForOwner(task, async () => ({ ...outcome, warning: "not a committed upload" }), () => false);
+    assert.equal(store.getTask(task.id)?.warning, undefined);
+  });
+}
+
 test("a resumed retry does not inherit failed settlement captured while admission was paused", async (t) => {
   const { sftpTransferCenterStore: store } = await import("../sftpTransferCenterStore");
   const { runTransferAndWaitForOwner } = await import("./waitForTransferOwner");

application/state/sftp/types.ts

@@ -65,6 +65,7 @@ export interface FileWatchSyncedEvent {
   localPath: string;
   remotePath: string;
   bytesWritten: number;
+  warning?: string;
 }
 
 export interface FileWatchErrorEvent {

application/state/sftp/uploadTaskCallbacks.ts

@@ -156,6 +156,10 @@ export const createUploadTaskCallbacks = ({
       phase: phase === "compressed" ? "transferring" : phase as TransferTask["phase"],
     });
   },
+  onTaskWarning: (taskId: string, warning: string) => {
+    // Preserve cleanup details before completion can compact a child row.
+    store.patchTask(taskId, { warning });
+  },
   onTaskCompleted: (taskId: string, totalBytes: number) => {
     store.patchTask(taskId, {
       status: "completed" as TransferStatus,

application/state/sftp/waitForTransferOwner.ts

@@ -6,7 +6,7 @@ export class TransferOwnerChangedError extends Error {}
 
 export type TransferOwnerObservation = ReturnType<typeof sftpTransferCenterStore.observeTaskSettlement>;
 
-type StreamResult = { error?: string; cancelled?: boolean; superseded?: boolean } | undefined;
+type StreamResult = { error?: string; cancelled?: boolean; superseded?: boolean; warning?: string } | undefined;
 
 /** A live waiter owns bounded settlement evidence; persisted history stays compact. */
 export async function runTransferAndWaitForOwner(
@@ -37,7 +37,17 @@ export async function runTransferAndWaitForOwner(
     observation = sftpTransferCenterStore.observeTaskSettlement(task, undefined, onOwnerChanged);
     const result = await start();
     if (observation.hasIdentityConflict()) throw new TransferOwnerChangedError("Transfer identity changed while waiting for its owner");
-    if (!result?.superseded) return result;
+    if (!result?.superseded) {
+      // The invoke response may arrive before completed IPC. Preserve cleanup
+      // details before the caller completes (and may compact) this child.
+      if (result?.warning && !result.error && !result.cancelled) {
+        const latest = sftpTransferCenterStore.getTask(task.id);
+        if (latest && latest.status !== "failed" && latest.status !== "cancelled") {
+          sftpTransferCenterStore.patchTask(task.id, { warning: result.warning });
+        }
+      }
+      return result;
+    }
     for (;;) {
       if (shouldAbort()) throw new Error("Transfer cancelled");
       if (observation.hasIdentityConflict()) throw new TransferOwnerChangedError("Transfer identity changed while waiting for its owner");

application/state/sftpTransferCenterStore.test.ts

@@ -33,6 +33,85 @@ test("store aggregates owner snapshots without duplicating tasks", () => {
   ]);
 });
 
+test("completion cleanup warnings survive owner snapshots and restored history", () => {
+  let persisted: string | null = null;
+  const store = createSftpTransferCenterStore({ read: () => persisted, write: (value) => { persisted = value; } });
+  const source = makeTask("cleanup-warning");
+  const warning = "Upload completed; remove backup /target/.netcatty-backup-file manually.";
+  store.publishOwner("panel", [source]);
+  store.ingestBackgroundEvent({ type: "completed", transferId: source.id, transferred: 10, warning });
+  assert.equal(store.getTask(source.id)?.status, "completed");
+  assert.equal(store.getTask(source.id)?.warning, warning);
+  assert.equal(store.getTask(source.id)?.reconnectRequired, false);
+  store.publishOwner("panel", [{ ...source, status: "completed", transferredBytes: 10, endTime: Date.now() }]);
+  assert.equal(store.getTask(source.id)?.warning, warning, "a stale renderer completion cannot erase cleanup details");
+  const restored = createSftpTransferCenterStore({ read: () => persisted, write: () => {} });
+  assert.equal(restored.getTask(source.id)?.warning, warning);
+  assert.equal(restored.getTask(source.id)?.status, "completed");
+  assert.equal(restored.getTask(source.id)?.error, undefined);
+});
+
+test("invoke cleanup warnings survive stale live and completion snapshots until an explicit restart", () => {
+  const store = createSftpTransferCenterStore();
+  const source = makeTask("invoke-warning-snapshot");
+  const warning = "Upload completed; remove backup /target/.netcatty-backup-file manually.";
+  store.publishOwner("panel", [source]);
+  store.patchTask(source.id, { warning });
+  store.publishOwner("panel", [{ ...source, transferredBytes: 9 }]);
+  assert.equal(store.getTask(source.id)?.warning, warning);
+  store.publishOwner("panel", [{ ...source, status: "completed", transferredBytes: 10, endTime: Date.now() }]);
+  assert.equal(store.getTask(source.id)?.warning, warning);
+  store.publishOwner("panel", [{ ...source, status: "queued", transferredBytes: 0, checkpointBytes: 0 }]);
+  assert.equal(store.getTask(source.id)?.warning, undefined, "new attempts do not inherit cleanup warnings");
+});
+
+test("a clean completed event cannot erase a warning already returned by the invoke", () => {
+  const store = createSftpTransferCenterStore();
+  const source = makeTask("invoke-warning-event");
+  const warning = "Upload completed; remove backup /target/.netcatty-backup-file manually.";
+  store.publishOwner("panel", [source]);
+  store.patchTask(source.id, { warning });
+  store.ingestBackgroundEvent({ type: "completed", transferId: source.id, transferred: 10 });
+  assert.equal(store.getTask(source.id)?.status, "completed");
+  assert.equal(store.getTask(source.id)?.warning, warning);
+});
+
+test("late completion enriches a locally completed task with its cleanup warning", () => {
+  let persisted: string | null = null;
+  const store = createSftpTransferCenterStore({ read: () => persisted, write: (value) => { persisted = value; } });
+  const source = { ...makeTask("result-first-warning"), phase: "transferring" as const };
+  const warning = "Upload completed; remove backup /target/.netcatty-backup-file manually.";
+  const endTime = Date.now();
+  store.publishOwner("panel", [source]);
+  // The invoke response can settle the renderer before the completed IPC arrives.
+  store.patchTask(source.id, { status: "completed", transferredBytes: 10, endTime });
+  let notifications = 0;
+  const unsubscribe = store.subscribe(() => { notifications += 1; });
+  store.ingestBackgroundEvent({ type: "completed", transferId: source.id, transferred: 10, endedAt: endTime + 1, warning });
+  assert.equal(store.getTask(source.id)?.warning, warning);
+  assert.equal(store.getTask(source.id)?.status, "completed");
+  assert.equal(store.getTask(source.id)?.endTime, endTime, "late metadata does not replace the terminal outcome");
+  assert.equal(notifications, 1, "the warning is visible without another transfer triggering a render");
+  store.ingestBackgroundEvent({ type: "completed", transferId: source.id, transferred: 10 });
+  assert.equal(store.getTask(source.id)?.warning, warning, "a duplicate clean event cannot erase the warning");
+  const restored = createSftpTransferCenterStore({ read: () => persisted, write: () => {} });
+  assert.equal(restored.getTask(source.id)?.warning, warning);
+  unsubscribe();
+});
+
+for (const status of ["failed", "cancelled"] as const) {
+  test(`late cleanup warnings cannot replace a ${status} terminal outcome`, () => {
+    const store = createSftpTransferCenterStore();
+    const endTime = Date.now();
+    const task = { ...makeTask(`late-warning-${status}`, status), error: "original outcome", endTime };
+    store.publishOwner("panel", [task]);
+    store.ingestBackgroundEvent({ type: "completed", transferId: task.id, warning: "cleanup warning" });
+    assert.equal(store.getTask(task.id)?.status, status);
+    assert.equal(store.getTask(task.id)?.error, "original outcome");
+    assert.equal(store.getTask(task.id)?.warning, undefined);
+  });
+}
+
 test("store routes cancel/retry/prioritize/dismiss to the task owner; pause/resume are process-global", async () => {
   const calls: string[] = [];
   const store = createSftpTransferCenterStore();
@@ -100,6 +179,10 @@ test("background-agent retry after restart uses fresh dedicated recovery instead
 for (const [label, error, expectResume] of [
   ["dead channel", "SFTP channel closed", true],
   ["lost session", "SFTP session lost. Please reconnect.", true],
+  ["aborted socket", "read ECONNABORTED", true],
+  ["hung up socket", "socket hang up", true],
+  ["closed channel code", "ERR_SFTP_CHANNEL_CLOSED", true],
+  ["client socket", "client-socket", true],
   ["content failure", "Permission denied", false],
 ] as const) {
   test(`panel Retry after ${label} ${expectResume ? "resumes the same task from its checkpoint" : "keeps the restart-from-0 retry"}`, async () => {
@@ -3572,6 +3655,46 @@ test("legacy 50,000-file history restores cooperatively and converges to one per
   assert.ok(persisted.length < 10_000, "migrated localStorage payload must stay bounded");
 });
 
+for (const indexed of [false, true]) {
+  test(`cooperative ${indexed ? "indexed" : "legacy"} restore retains completed child cleanup warnings`, async () => {
+    const now = Date.now();
+    const warning = "Upload completed; remove backup /target/.netcatty-backup-file manually.";
+    const parent: TransferTask = { ...makeTask("restore-warning-folder", "paused"), isDirectory: true };
+    const children: TransferTask[] = [0, 1].map((index) => ({
+      ...makeTask(`restore-warning-child-${index}`, "completed"),
+      parentTaskId: parent.id, endTime: now,
+      warning: index === 0 ? warning : undefined,
+      ...(indexed ? { directoryEntryIndex: index, directoryEntryIdentity: String(index).padStart(64, "0") } : {}),
+    }));
+    let persisted = JSON.stringify({ version: 1, padding: "x".repeat(600_000), tasks: [parent, ...children] });
+    const store = createSftpTransferCenterStore({ read: () => persisted, write: (value) => { persisted = value; } });
+    assert.equal(store.getSnapshot().tasks.length, 0, "large history must take cooperative restoration");
+    await new Promise<void>((resolve, reject) => {
+      let unsubscribe = () => {};
+      const timeout = setTimeout(() => {
+        unsubscribe();
+        reject(new Error("timed out waiting for cleanup-warning history migration"));
+      }, 10_000);
+      const check = () => {
+        if (!store.getTask(parent.id)) return;
+        clearTimeout(timeout);
+        unsubscribe();
+        resolve();
+      };
+      unsubscribe = store.subscribe(check);
+      check();
+    });
+    assert.equal(store.getTask("restore-warning-child-0")?.warning, warning);
+    assert.equal(store.getTask("restore-warning-child-0")?.status, "completed");
+    assert.equal(store.getTask("restore-warning-child-1"), undefined, "clean completed children still compact");
+    assert.equal(store.getTask(parent.id)?.directoryResumeCheckpoint?.coveredEntries, 2);
+    assert.equal(store.getTask(parent.id)?.directoryResumeCheckpoint?.completedEntries, 1);
+    const restarted = createSftpTransferCenterStore({ read: () => persisted, write: () => {} });
+    assert.equal(restarted.getTask("restore-warning-child-0")?.warning, warning);
+    assert.equal(restarted.getTask(parent.id)?.directoryResumeCheckpoint?.completedEntries, 1);
+  });
+}
+
 test("live mutations wait for cooperative restore and merge without erasing old rows", async () => {
   const legacyOnly = makeTask("legacy-only", "paused");
   const staleCollision = makeTask("collision", "paused");

application/state/sftpTransferCenterStore.ts

@@ -152,6 +152,7 @@ export interface SftpTransferCenterStore {
     startedAt?: number;
     endedAt?: number;
     error?: string;
+    warning?: string;
     transferred?: number;
     totalBytes?: number;
     speed?: number;
@@ -289,6 +290,12 @@ export function mergeOwnerPublishedTask(
     updatedAt: incoming.updatedAt ?? Date.now(),
   };
 
+  // A panel snapshot may predate cleanup metadata returned by the invoke or
+  // completed IPC. Keep it through this attempt, but not a restart or failure.
+  if (!incomingReset && incoming.status !== "failed" && incoming.status !== "cancelled") {
+    merged.warning = incoming.warning ?? existing.warning;
+  }
+
   if (incomingReset || incomingTerminal) {
     return merged;
   }
@@ -2274,6 +2281,15 @@ export function createSftpTransferCenterStore(persistence?: StorePersistence): S
       if (terminal && event.type !== "cancelled") {
         // Allow a late explicit cancel to stick; ignore everything else.
         if (event.type === "completed" || event.type === "failed") {
+          // An invoke response can complete the renderer row before its IPC
+          // event arrives. Enrich that same success with cleanup metadata,
+          // without replacing any terminal outcome or reviving stopped work.
+          if (existing.status === "completed" && event.type === "completed"
+            && event.warning && event.warning !== existing.warning) {
+            tasks = tasks.map((task) => task.id === existing.id ? { ...task, warning: event.warning } : task);
+            emit(true);
+            return;
+          }
           // Keep existing terminal state (prefer cancelled over late completed).
           publishRepairedHierarchy();
           return;
@@ -2561,6 +2577,7 @@ export function createSftpTransferCenterStore(persistence?: StorePersistence): S
             ? task.checkpointBytes
             : Math.max(task.checkpointBytes ?? 0, Number(event.checkpointBytes) || 0),
           error: event.error,
+          warning: event.type === "completed" ? event.warning ?? task.warning : undefined,
           endTime: event.endedAt ?? Date.now(),
           speed: 0,
           reconnectRequired: event.type === "failed" ? task.reconnectRequired : false,

application/state/terminalHiddenRendererStore.test.ts

@@ -9,6 +9,106 @@ test("terminalHiddenRendererStore evicts oldest soft-hidden session", () => {
   terminalHiddenRendererStore.markSoftHidden("a");
   terminalHiddenRendererStore.markSoftHidden("b");
   assert.equal(terminalHiddenRendererStore.pickEvictionCandidate(2), "a");
+  assert.deepEqual(terminalHiddenRendererStore.listSoftHiddenOldestFirst(), ["a", "b"]);
   terminalHiddenRendererStore.clearSoftHidden("a");
   terminalHiddenRendererStore.clearSoftHidden("b");
 });
+
+test("evictSoftHidden reports refusal and drops an unconsumed request", async () => {
+  const sessions = ["images", "plain", "other"];
+  for (const sessionId of sessions) terminalHiddenRendererStore.clearSoftHidden(sessionId);
+  terminalHiddenRendererStore.markSoftHidden("images");
+  terminalHiddenRendererStore.markSoftHidden("plain");
+
+  const unsubscribe = terminalHiddenRendererStore.subscribe(() => {
+    if (terminalHiddenRendererStore.consumeEvictionRequest("images")) return;
+    if (terminalHiddenRendererStore.consumeEvictionRequest("plain")) {
+      terminalHiddenRendererStore.clearSoftHidden("plain");
+      terminalHiddenRendererStore.settleEviction("plain", true);
+    }
+  });
+
+  try {
+    assert.equal(await terminalHiddenRendererStore.evictSoftHidden("images"), false);
+    assert.equal(terminalHiddenRendererStore.isSoftHidden("images"), true);
+    assert.equal(await terminalHiddenRendererStore.evictSoftHidden("plain"), true);
+    assert.equal(terminalHiddenRendererStore.isSoftHidden("plain"), false);
+  } finally {
+    unsubscribe();
+    for (const sessionId of sessions) terminalHiddenRendererStore.clearSoftHidden(sessionId);
+  }
+
+  terminalHiddenRendererStore.markSoftHidden("images");
+  assert.equal(await terminalHiddenRendererStore.evictSoftHidden("images"), false);
+  const delivered: string[] = [];
+  const later = terminalHiddenRendererStore.subscribe(() => {
+    if (terminalHiddenRendererStore.consumeEvictionRequest("images")) delivered.push("images");
+  });
+  try {
+    terminalHiddenRendererStore.markSoftHidden("other");
+    assert.deepEqual(delivered, []);
+    assert.equal(terminalHiddenRendererStore.isSoftHidden("images"), true);
+  } finally {
+    later();
+    for (const sessionId of sessions) terminalHiddenRendererStore.clearSoftHidden(sessionId);
+  }
+});
+
+test("a reserved leaving slot counts toward occupancy until it is released", () => {
+  const sessions = ["a", "b", "c", "d"];
+  for (const sessionId of sessions) terminalHiddenRendererStore.clearSoftHidden(sessionId);
+  terminalHiddenRendererStore.markSoftHidden("a");
+  terminalHiddenRendererStore.markSoftHidden("b");
+  assert.equal(terminalHiddenRendererStore.getSoftHiddenOccupancy(), 2);
+
+  const alreadyHidden = terminalHiddenRendererStore.reserveLeavingSlot("a");
+  assert.equal(terminalHiddenRendererStore.getSoftHiddenOccupancy(), 2);
+  terminalHiddenRendererStore.releaseLeavingSlot("a", alreadyHidden);
+
+  const tokenC = terminalHiddenRendererStore.reserveLeavingSlot("c");
+  assert.equal(terminalHiddenRendererStore.getSoftHiddenOccupancy(), 3);
+  assert.equal(terminalHiddenRendererStore.leavingSlotStillFits("c", 2), false);
+
+  terminalHiddenRendererStore.clearSoftHidden("a");
+  assert.equal(terminalHiddenRendererStore.getSoftHiddenOccupancy(), 2);
+  assert.equal(terminalHiddenRendererStore.leavingSlotStillFits("c", 2), true);
+
+  const tokenD = terminalHiddenRendererStore.reserveLeavingSlot("d");
+  assert.equal(terminalHiddenRendererStore.getSoftHiddenOccupancy(), 3);
+  assert.equal(terminalHiddenRendererStore.leavingSlotStillFits("c", 2), false);
+  assert.equal(terminalHiddenRendererStore.leavingSlotStillFits("d", 2), false);
+  terminalHiddenRendererStore.releaseLeavingSlot("c", tokenD);
+  assert.equal(terminalHiddenRendererStore.getSoftHiddenOccupancy(), 3);
+  terminalHiddenRendererStore.releaseLeavingSlot("c", tokenC);
+  assert.equal(terminalHiddenRendererStore.getSoftHiddenOccupancy(), 2);
+  terminalHiddenRendererStore.releaseLeavingSlot("d", tokenD);
+  assert.equal(terminalHiddenRendererStore.getSoftHiddenOccupancy(), 1);
+
+  for (const sessionId of sessions) terminalHiddenRendererStore.clearSoftHidden(sessionId);
+  assert.equal(terminalHiddenRendererStore.getSoftHiddenOccupancy(), 0);
+});
+
+test("evictSoftHidden waits for hibernate after the marker is cleared", async () => {
+  terminalHiddenRendererStore.clearSoftHidden("victim");
+  terminalHiddenRendererStore.markSoftHidden("victim");
+  let markerClearedBeforeSettle = false;
+  const unsubscribe = terminalHiddenRendererStore.subscribe(() => {
+    if (!terminalHiddenRendererStore.consumeEvictionRequest("victim")) return;
+    terminalHiddenRendererStore.clearSoftHidden("victim");
+    markerClearedBeforeSettle = !terminalHiddenRendererStore.isSoftHidden("victim");
+    queueMicrotask(() => {
+      terminalHiddenRendererStore.markSoftHidden("victim");
+      terminalHiddenRendererStore.settleEviction("victim", false);
+    });
+  });
+
+  try {
+    const completed = await terminalHiddenRendererStore.evictSoftHidden("victim");
+    assert.equal(markerClearedBeforeSettle, true);
+    assert.equal(completed, false);
+    assert.equal(terminalHiddenRendererStore.isSoftHidden("victim"), true);
+  } finally {
+    unsubscribe();
+    terminalHiddenRendererStore.clearSoftHidden("victim");
+  }
+});

application/state/terminalHiddenRendererStore.ts

@@ -3,14 +3,85 @@ type Listener = () => void;
 const softHiddenSessions = new Map<string, number>();
 const listeners = new Set<Listener>();
 let evictionRequestSessionId: string | null = null;
+/** Leaving tabs that have claimed a keep slot while a victim hibernate is in flight. */
+const reservedLeavingSlots = new Map<string, number>();
+let reservationToken = 0;
+
+function reservedLeavingCount(): number {
+  let extra = 0;
+  for (const sessionId of reservedLeavingSlots.keys()) {
+    if (!softHiddenSessions.has(sessionId)) extra += 1;
+  }
+  return extra;
+}
+
+type EvictionWaiter = {
+  promise: Promise<boolean>;
+  resolve: (completed: boolean) => void;
+  settled: boolean;
+};
+
+const evictionWaiters = new Map<string, EvictionWaiter>();
+
+function finishEviction(sessionId: string, completed: boolean): void {
+  const waiter = evictionWaiters.get(sessionId);
+  if (!waiter || waiter.settled) return;
+  waiter.settled = true;
+  evictionWaiters.delete(sessionId);
+  if (evictionRequestSessionId === sessionId) evictionRequestSessionId = null;
+  waiter.resolve(completed);
+}
 
 function emit(): void {
   listeners.forEach((listener) => listener());
 }
 
+function listSoftHiddenOldestFirst(): string[] {
+  return [...softHiddenSessions.entries()]
+    .sort((left, right) => left[1] - right[1])
+    .map(([sessionId]) => sessionId);
+}
+
 export const terminalHiddenRendererStore = {
   getSoftHiddenCount: () => softHiddenSessions.size,
 
+  /**
+   * Soft-hidden markers plus leaving tabs that reserved a slot and are not
+   * yet in the marker set. Keep-count decisions use this so a second timer
+   * cannot take the slot a pending eviction already claimed.
+   */
+  getSoftHiddenOccupancy: () => softHiddenSessions.size + reservedLeavingCount(),
+
+  /**
+   * Claim one keep slot for a leaving tab before awaiting eviction.
+   * A session already in the marker set is not counted twice. A later claim
+   * for the same id replaces the token; only that token can release it.
+   */
+  reserveLeavingSlot: (sessionId: string): number => {
+    const token = ++reservationToken;
+    if (sessionId && !softHiddenSessions.has(sessionId)) {
+      reservedLeavingSlots.set(sessionId, token);
+    }
+    return token;
+  },
+
+  releaseLeavingSlot: (sessionId: string, token: number) => {
+    if (reservedLeavingSlots.get(sessionId) === token) {
+      reservedLeavingSlots.delete(sessionId);
+    }
+  },
+
+  /**
+   * True when retaining this leaving tab would stay within keepCount.
+   * Its own reservation is not counted against the slots held by others.
+   */
+  leavingSlotStillFits: (sessionId: string, keepCount: number): boolean => {
+    if (!(keepCount > 0)) return false;
+    const reservedHere = reservedLeavingSlots.has(sessionId) && !softHiddenSessions.has(sessionId);
+    const others = softHiddenSessions.size + reservedLeavingCount() - (reservedHere ? 1 : 0);
+    return others < keepCount;
+  },
+
   isSoftHidden: (sessionId: string) => softHiddenSessions.has(sessionId),
 
   markSoftHidden: (sessionId: string) => {
@@ -23,18 +94,12 @@ export const terminalHiddenRendererStore = {
     emit();
   },
 
+  listSoftHiddenOldestFirst: (): string[] => listSoftHiddenOldestFirst(),
+
   /** Returns the oldest soft-hidden session id when over the keep limit. */
   pickEvictionCandidate: (keepCount: number): string | null => {
     if (softHiddenSessions.size < keepCount) return null;
-    let oldestId: string | null = null;
-    let oldestTs = Number.POSITIVE_INFINITY;
-    for (const [sessionId, ts] of softHiddenSessions) {
-      if (ts < oldestTs) {
-        oldestTs = ts;
-        oldestId = sessionId;
-      }
-    }
-    return oldestId;
+    return listSoftHiddenOldestFirst()[0] ?? null;
   },
 
   requestEviction: (sessionId: string) => {
@@ -42,6 +107,44 @@ export const terminalHiddenRendererStore = {
     emit();
   },
 
+  /** True while this session's hibernate has been requested and not settled. */
+  hasPendingEviction: (sessionId: string): boolean => {
+    const waiter = evictionWaiters.get(sessionId);
+    return waiter != null && !waiter.settled;
+  },
+
+  /**
+   * Ask one soft-hidden session to upgrade. Resolves true only when
+   * settleEviction reports that hibernation finished. Clearing the marker
+   * during wake is not success: drain, snapshot, or alternate-screen failure
+   * can still restore that renderer. A synchronous refusal (marker still
+   * present, including inline images) resolves false and drops an unconsumed
+   * request so a later emit cannot upgrade it.
+   */
+  evictSoftHidden: (sessionId: string): Promise<boolean> => {
+    const existing = evictionWaiters.get(sessionId);
+    if (existing) return existing.promise;
+    if (!softHiddenSessions.has(sessionId)) return Promise.resolve(false);
+
+    let resolvePromise!: (completed: boolean) => void;
+    const promise = new Promise<boolean>((resolve) => {
+      resolvePromise = resolve;
+    });
+    const waiter: EvictionWaiter = { promise, resolve: resolvePromise, settled: false };
+    evictionWaiters.set(sessionId, waiter);
+    evictionRequestSessionId = sessionId;
+    emit();
+    if (!waiter.settled && softHiddenSessions.has(sessionId)) {
+      finishEviction(sessionId, false);
+    }
+    return promise;
+  },
+
+  /** Record whether the in-flight eviction's hibernate actually completed. */
+  settleEviction: (sessionId: string, completed: boolean) => {
+    finishEviction(sessionId, completed);
+  },
+
   consumeEvictionRequest: (sessionId: string): boolean => {
     if (evictionRequestSessionId !== sessionId) return false;
     evictionRequestSessionId = null;

application/state/useServerStats.ts

@@ -54,6 +54,8 @@ export interface ServerStats {
   swapTotal: number | null;     // Total swap in MB
   swapUsed: number | null;      // Used swap in MB
   topProcesses: ProcessInfo[];  // Top 10 processes by memory
+  diskReadSpeed?: number | null; // Aggregate Linux hardware-backed block I/O, bytes/sec
+  diskWriteSpeed?: number | null;
   diskPercent: number | null;   // Disk usage percentage for root partition
   diskUsed: number | null;      // Disk used in GB
   diskTotal: number | null;     // Total disk in GB
@@ -240,6 +242,8 @@ function normalizeServerStats(stats: Partial<ServerStats>): ServerStats {
     diskPercent: stats.diskPercent ?? null,
     diskUsed: stats.diskUsed ?? null,
     diskTotal: stats.diskTotal ?? null,
+    diskReadSpeed: stats.diskReadSpeed ?? null,
+    diskWriteSpeed: stats.diskWriteSpeed ?? null,
     disks: stats.disks || [],
     netRxSpeed: stats.netRxSpeed || 0,
     netTxSpeed: stats.netTxSpeed || 0,

application/state/useSessionState.ts

@@ -1,4 +1,5 @@
 import { MouseEvent,useCallback,useEffect,useMemo,useRef,useState } from 'react';
+import { flushSync } from 'react-dom';
 import { ConnectionLog,Host,SerialConfig,Snippet,TerminalSession,Workspace,WorkspaceNode,WorkspaceViewMode } from '../../domain/models';
 import { addLogView, getLogViewTabId, removeLogView, type LogView } from './logViewState';
 import {
@@ -915,6 +916,25 @@ export const useSessionState = ({
     return newSessionId;
   }, [setActiveTabId]);
 
+  // Agent callers bind scope immediately, so they need committed insertion,
+  // not just the ID allocated by the ordinary batched UI append operation.
+  const appendHostToWorkspaceConfirmed = useCallback((
+    workspaceId: string,
+    host: Host,
+    direction: SplitDirection = 'vertical',
+  ): string | null => {
+    let sessionId: string | null = null;
+    flushSync(() => {
+      sessionId = appendHostToWorkspace(workspaceId, host, direction);
+    });
+    if (!sessionId) return null;
+    const committedWorkspace = workspacesRef.current.find(w => w.id === workspaceId);
+    const inserted = committedWorkspace
+      && collectSessionIds(committedWorkspace.root).includes(sessionId)
+      && sessionsRef.current.some(s => s.id === sessionId && s.workspaceId === workspaceId);
+    return inserted ? sessionId : null;
+  }, [appendHostToWorkspace]);
+
   // Atomic "append a local terminal pane" — mirror of appendHostToWorkspace
   // but constructs a local-protocol session instead of an SSH one.
   const appendLocalTerminalToWorkspace = useCallback((
@@ -1453,6 +1473,7 @@ export const useSessionState = ({
     addSessionToWorkspace,
     removeSessionFromWorkspace,
     appendHostToWorkspace,
+    appendHostToWorkspaceConfirmed,
     appendLocalTerminalToWorkspace,
     updateSplitSizes,
     splitSession,

application/state/useSessionState.workspaceHostOpen.test.ts

@@ -0,0 +1,85 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import test from 'node:test';
+import React, { act } from 'react';
+import { createRoot } from 'react-dom/client';
+import { JSDOM } from 'jsdom';
+import { createLocalShellHost, resolveHostDefaultLocalShell } from '../../domain/localShellHost';
+import { collectSessionIds } from '../../domain/workspace';
+import { activeTabStore } from './activeTabStore';
+import { useSessionState } from './useSessionState';
+
+test('workspace host opening acknowledges committed insertion and rejects queued closure', async (t) => {
+  const dom = new JSDOM('<div id="root"></div>', { url: 'http://localhost' });
+  const globals = {
+    window: dom.window,
+    document: dom.window.document,
+    localStorage: dom.window.localStorage,
+    CustomEvent: dom.window.CustomEvent,
+    Event: dom.window.Event,
+    IS_REACT_ACT_ENVIRONMENT: true,
+  };
+  const previous = new Map<string, PropertyDescriptor | undefined>();
+  for (const [key, value] of Object.entries(globals)) {
+    previous.set(key, Object.getOwnPropertyDescriptor(globalThis, key));
+    Object.defineProperty(globalThis, key, { configurable: true, value });
+  }
+  const root = createRoot(document.getElementById('root')!);
+  t.after(async () => {
+    await act(async () => root.unmount());
+    dom.window.close();
+    for (const [key, descriptor] of previous) {
+      if (descriptor) Object.defineProperty(globalThis, key, descriptor);
+      else Reflect.deleteProperty(globalThis, key);
+    }
+    activeTabStore.setActiveTabId('vault');
+  });
+  let state: ReturnType<typeof useSessionState>;
+  function Probe() {
+    state = useSessionState({ persistSessionRestore: false });
+    return null;
+  }
+  await act(async () => root.render(React.createElement(React.StrictMode, null, React.createElement(Probe))));
+  const host = createLocalShellHost({ id: 'local-inheriting' });
+  await act(async () => state.createWorkspaceWithHosts('Target', [host]));
+  const workspaceId = state!.workspaces[0].id;
+  const resolvedHost = resolveHostDefaultLocalShell(host, {
+    terminalSettings: { localShell: '/bin/zsh', localShellArgs: ['-l'], localStartDir: '/tmp/project' },
+  });
+  let ordinaryId: string | null = null;
+  await act(async () => {
+    ordinaryId = state.appendHostToWorkspace(workspaceId, resolvedHost);
+  });
+  assert.ok(ordinaryId);
+  assert.ok(state!.sessions.some(session => session.id === ordinaryId));
+  assert.ok(collectSessionIds(state!.workspaces[0].root).includes(ordinaryId));
+  let insertedId: string | null = null;
+  await act(async () => {
+    insertedId = state.appendHostToWorkspaceConfirmed(workspaceId, resolvedHost);
+    assert.ok(insertedId, 'success is returned after both state updates commit');
+    const session = state.sessions.find(s => s.id === insertedId);
+    assert.equal(session?.localShell, '/bin/zsh');
+    assert.deepEqual(session?.localShellArgs, ['-l']);
+    assert.equal(session?.localStartDir, '/tmp/project');
+    assert.equal(state.sessions.filter(s => s.id === insertedId).length, 1);
+    assert.equal(collectSessionIds(state.workspaces[0].root).filter(id => id === insertedId).length, 1);
+  });
+  await act(async () => {
+    // The rendered ref still contains the workspace; its close updater is queued.
+    state.closeWorkspace(workspaceId);
+    const result = state.appendHostToWorkspaceConfirmed(workspaceId, resolvedHost);
+    assert.equal(result, null, 'must not acknowledge an allocated but uninserted ID');
+  });
+  assert.equal(state!.workspaces.length, 0);
+  assert.equal(state!.sessions.length, 0, 'no orphan session survives the queued close');
+  assert.equal(activeTabStore.getActiveTabId(), 'vault');
+  await act(async () => {
+    assert.equal(state.appendHostToWorkspaceConfirmed(workspaceId, resolvedHost), null);
+  });
+});
+
+test('agent workspace host opening uses the common launch and history handler', () => {
+  const source = readFileSync(new URL('../app/AppSideEffects.tsx', import.meta.url), 'utf8');
+  assert.match(source, /const sessionId = handleConnectToHost\(host, true, hidden, target\.workspaceId\)/);
+  assert.match(source, /connectToHost: workspaceId\s*\? \(candidate: Host\) => appendHostToWorkspaceConfirmed\(workspaceId, candidate\)\s*: connectToHost/);
+});

application/state/useTerminalSidePanelLayoutState.test.tsx

@@ -1,8 +1,13 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import React from 'react';
+import React, { startTransition, useState } from 'react';
+import { flushSync } from 'react-dom';
+import { createRoot, type Root } from 'react-dom/client';
+import { JSDOM } from 'jsdom';
 import { act, create, type ReactTestRenderer } from 'react-test-renderer';
 
+import { readFileSync } from 'node:fs';
+
 import { collectSidePanelPanes } from '../../domain/sidePanelLayout.ts';
 import { useTerminalSidePanelLayoutState } from './useTerminalSidePanelLayoutState.ts';
 
@@ -130,3 +135,231 @@ test('closing the final pane removes only that terminal side panel state', async
     actEnvironment.IS_REACT_ACT_ENVIRONMENT = previousActEnvironment;
   }
 });
+
+test('selecting a side panel tool commits open tabs and layout in one render', async () => {
+  const actEnvironment = globalThis as typeof globalThis & {
+    IS_REACT_ACT_ENVIRONMENT?: boolean;
+  };
+  const previousActEnvironment = actEnvironment.IS_REACT_ACT_ENVIRONMENT;
+  actEnvironment.IS_REACT_ACT_ENVIRONMENT = true;
+  let state: ReturnType<typeof useTerminalSidePanelLayoutState> | null = null;
+  let renderer: ReactTestRenderer | null = null;
+  let renders = 0;
+
+  const Probe = () => {
+    state = useTerminalSidePanelLayoutState();
+    renders += 1;
+    return null;
+  };
+
+  try {
+    await act(async () => {
+      renderer = create(React.createElement(Probe));
+    });
+    renders = 0;
+    await act(async () => {
+      state?.selectSidePanelToolForTab('terminal-a', 'notes');
+    });
+    assert.equal(renders, 1, 'open tabs and layout share one commit');
+    assert.equal(state!.sidePanelOpenTabs.get('terminal-a'), 'notes');
+    const layout = state!.sidePanelLayouts.get('terminal-a')!;
+    assert.equal(
+      collectSidePanelPanes(layout.root).find((pane) => pane.id === layout.focusedPaneId)?.tool,
+      'notes',
+    );
+
+    await act(async () => {
+      state?.splitPane('terminal-a', 'ai', 'vertical', {
+        paneId: 'pane-ai',
+        splitId: 'split-a',
+      }, 400);
+    });
+    const beforeFocus = state!.sidePanelLayouts.get('terminal-a')!;
+    await act(async () => {
+      state?.selectSidePanelToolForTab('terminal-a', 'notes');
+    });
+    const focusedExisting = state!.sidePanelLayouts.get('terminal-a')!;
+    assert.deepEqual(
+      collectSidePanelPanes(focusedExisting.root).map((pane) => pane.tool),
+      ['notes', 'ai'],
+    );
+    assert.equal(
+      collectSidePanelPanes(focusedExisting.root).find((pane) => pane.id === focusedExisting.focusedPaneId)?.tool,
+      'notes',
+    );
+    assert.equal(state!.sidePanelOpenTabs.get('terminal-a'), 'notes');
+    assert.notEqual(focusedExisting, beforeFocus);
+    assert.equal(focusedExisting.root, beforeFocus.root, 'focusing an open tool must not rebuild the split');
+
+    const settled = state!.sidePanelLayouts;
+    renders = 0;
+    await act(async () => {
+      state?.selectSidePanelToolForTab('terminal-a', 'notes');
+    });
+    assert.equal(renders, 0);
+    assert.equal(state!.sidePanelLayouts, settled);
+  } finally {
+    await act(async () => {
+      renderer?.unmount();
+    });
+    actEnvironment.IS_REACT_ACT_ENVIRONMENT = previousActEnvironment;
+  }
+});
+
+test('a pending side-panel write survives an urgent render on another tab', async () => {
+  const dom = new JSDOM('<!doctype html><html><body></body></html>', { url: 'http://localhost' });
+  const previousWindow = globalThis.window;
+  const previousDocument = globalThis.document;
+  Object.defineProperty(globalThis, 'window', { configurable: true, value: dom.window });
+  Object.defineProperty(globalThis, 'document', { configurable: true, value: dom.window.document });
+  const actEnvironment = globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean };
+  const previousActEnvironment = actEnvironment.IS_REACT_ACT_ENVIRONMENT;
+  actEnvironment.IS_REACT_ACT_ENVIRONMENT = true;
+
+  let state: ReturnType<typeof useTerminalSidePanelLayoutState> | null = null;
+  let bump: ((value: number) => void) | null = null;
+  const Probe = () => {
+    state = useTerminalSidePanelLayoutState();
+    const [, setTick] = useState(0);
+    bump = setTick;
+    return null;
+  };
+
+  const container = document.createElement('div');
+  document.body.appendChild(container);
+  const root: Root = createRoot(container);
+  const tools = (tabId: string, fromRef = false) => {
+    const layout = fromRef
+      ? state?.sidePanelLayoutsRef.current.get(tabId)
+      : state?.sidePanelLayouts.get(tabId);
+    return layout ? collectSidePanelPanes(layout.root).map((pane) => pane.tool) : [];
+  };
+
+  try {
+    await act(async () => {
+      root.render(React.createElement(Probe));
+    });
+    await act(async () => {
+      state?.selectSidePanelToolForTab('terminal-a', 'notes');
+      state?.selectSidePanelToolForTab('terminal-b', 'scripts');
+    });
+    await act(async () => {
+      state?.splitPane('terminal-a', 'ai', 'vertical', {
+        paneId: 'pane-ai',
+        splitId: 'split-a',
+      }, 400);
+    });
+
+    await act(async () => {
+      startTransition(() => {
+        state?.selectSidePanelToolForTab('terminal-a', 'history');
+      });
+      flushSync(() => {
+        bump?.(1);
+      });
+      assert.deepEqual(tools('terminal-a'), ['notes', 'ai']);
+      assert.deepEqual(tools('terminal-a', true), ['notes', 'history']);
+      startTransition(() => {
+        state?.selectSidePanelToolForTab('terminal-b', 'sftp');
+      });
+    });
+
+    assert.deepEqual(tools('terminal-a'), ['notes', 'history']);
+    assert.equal(state!.sidePanelOpenTabs.get('terminal-a'), 'history');
+    assert.deepEqual(tools('terminal-b'), ['sftp']);
+    assert.equal(state!.sidePanelOpenTabs.get('terminal-b'), 'sftp');
+  } finally {
+    await act(async () => {
+      root.unmount();
+    });
+    actEnvironment.IS_REACT_ACT_ENVIRONMENT = previousActEnvironment;
+    Object.defineProperty(globalThis, 'window', { configurable: true, value: previousWindow });
+    Object.defineProperty(globalThis, 'document', { configurable: true, value: previousDocument });
+    dom.window.close();
+  }
+});
+
+test('a pending tool switch does not leave another tab ref behind an urgent open', async () => {
+  const dom = new JSDOM('<!doctype html><html><body></body></html>', { url: 'http://localhost' });
+  const previousWindow = globalThis.window;
+  const previousDocument = globalThis.document;
+  Object.defineProperty(globalThis, 'window', { configurable: true, value: dom.window });
+  Object.defineProperty(globalThis, 'document', { configurable: true, value: dom.window.document });
+  const actEnvironment = globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean };
+  const previousActEnvironment = actEnvironment.IS_REACT_ACT_ENVIRONMENT;
+  actEnvironment.IS_REACT_ACT_ENVIRONMENT = true;
+
+  let state: ReturnType<typeof useTerminalSidePanelLayoutState> | null = null;
+  const Probe = () => {
+    state = useTerminalSidePanelLayoutState();
+    return null;
+  };
+
+  const container = document.createElement('div');
+  document.body.appendChild(container);
+  const root: Root = createRoot(container);
+  const focusedTool = (tabId: string, fromRef = false) => {
+    const layout = fromRef
+      ? state?.sidePanelLayoutsRef.current.get(tabId)
+      : state?.sidePanelLayouts.get(tabId);
+    if (!layout) return null;
+    return collectSidePanelPanes(layout.root).find((pane) => pane.id === layout.focusedPaneId)?.tool ?? null;
+  };
+
+  try {
+    await act(async () => {
+      root.render(React.createElement(Probe));
+    });
+    await act(async () => {
+      state?.selectSidePanelToolForTab('terminal-a', 'notes');
+      state?.selectSidePanelToolForTab('terminal-b', 'scripts');
+    });
+
+    await act(async () => {
+      startTransition(() => {
+        state?.selectSidePanelToolForTab('terminal-a', 'history');
+      });
+      flushSync(() => {
+        state?.setSidePanelOpenTabs((previous) => new Map(previous).set('terminal-b', 'browser'));
+      });
+    });
+
+    assert.equal(state!.sidePanelOpenTabs.get('terminal-a'), 'history');
+    assert.equal(state!.sidePanelOpenTabs.get('terminal-b'), 'browser');
+    assert.equal(state!.sidePanelOpenTabsRef.current.get('terminal-a'), 'history');
+    assert.equal(
+      state!.sidePanelOpenTabsRef.current.get('terminal-b'),
+      'browser',
+      'B stays rendered as browser while its ref still reports the pre-queue tool',
+    );
+    assert.equal(focusedTool('terminal-b', true), 'browser');
+
+    // handleSwitchSidePanelTab returns before select when the ref already
+    // matches the clicked tool. A stale scripts ref would ignore this click.
+    assert.notEqual(state!.sidePanelOpenTabsRef.current.get('terminal-b'), 'scripts');
+    await act(async () => {
+      state?.selectSidePanelToolForTab('terminal-b', 'scripts');
+    });
+    assert.equal(state!.sidePanelOpenTabs.get('terminal-b'), 'scripts');
+    assert.equal(state!.sidePanelOpenTabsRef.current.get('terminal-b'), 'scripts');
+    assert.equal(focusedTool('terminal-b'), 'scripts');
+    assert.equal(state!.sidePanelOpenTabs.get('terminal-a'), 'history');
+  } finally {
+    await act(async () => {
+      root.unmount();
+    });
+    actEnvironment.IS_REACT_ACT_ENVIRONMENT = previousActEnvironment;
+    Object.defineProperty(globalThis, 'window', { configurable: true, value: previousWindow });
+    Object.defineProperty(globalThis, 'document', { configurable: true, value: previousDocument });
+    dom.window.close();
+  }
+});
+
+test('side panel icon clicks write the tool through selectSidePanelToolForTab', () => {
+  const layerSource = readFileSync(new URL('../../components/TerminalLayer.tsx', import.meta.url), 'utf8');
+  const start = layerSource.indexOf('const handleSwitchSidePanelTab = useCallback');
+  const end = layerSource.indexOf('const handleFocusSidePanelPane = useCallback');
+  const body = layerSource.slice(start, end);
+  assert.match(body, /startTransition\(\(\) => \{\s*selectSidePanelToolForTab\(tabId, tab\);/);
+  assert.doesNotMatch(body, /setSidePanelOpenTabs/);
+});

application/state/useTerminalSidePanelLayoutState.ts

@@ -13,55 +13,215 @@ import {
   type SidePanelTool,
 } from '../../domain/sidePanelLayout';
 
+function replaceMapEntry<T>(previous: Map<string, T>, key: string, value: T): Map<string, T> {
+  if (previous.get(key) === value) return previous;
+  const next = new Map(previous);
+  next.set(key, value);
+  return next;
+}
+
+function deleteMapEntry<T>(previous: Map<string, T>, key: string): Map<string, T> {
+  if (!previous.has(key)) return previous;
+  const next = new Map(previous);
+  next.delete(key);
+  return next;
+}
+
+function entryMatches<T>(left: Map<string, T>, right: Map<string, T>, key: string): boolean {
+  return left.has(key) === right.has(key) && left.get(key) === right.get(key);
+}
+
+/**
+ * Keep a ref aligned with committed state without dropping a write React has
+ * not rendered yet. An urgent update can rebase onto a transition: the
+ * transition updater stores an intermediate map in the ref, and the later
+ * updater changes only state. Copy committed entries the pending map did not
+ * change, and follow committed once it moves past that pending value.
+ */
+function syncTrackedMap<T>(
+  pending: Map<string, T>,
+  lastRendered: Map<string, T>,
+  committed: Map<string, T>,
+): Map<string, T> {
+  if (pending === lastRendered) return committed;
+  if (pending === committed) return pending;
+
+  let changed = false;
+  const merged = new Map(pending);
+
+  for (const key of committed.keys()) {
+    if (entryMatches(pending, committed, key)) continue;
+    const pendingMatchesRendered = entryMatches(pending, lastRendered, key);
+    const committedMatchesRendered = entryMatches(committed, lastRendered, key);
+    if (pendingMatchesRendered || !committedMatchesRendered) {
+      merged.set(key, committed.get(key) as T);
+      changed = true;
+    }
+  }
+
+  for (const key of pending.keys()) {
+    if (committed.has(key)) continue;
+    if (entryMatches(pending, lastRendered, key)) {
+      merged.delete(key);
+      changed = true;
+    }
+  }
+
+  return changed ? merged : pending;
+}
+
+function publishQueuedMap<T>(
+  live: Map<string, T>,
+  capturedBase: Map<string, T>,
+  previous: Map<string, T>,
+  stateNext: Map<string, T>,
+  tabId: string,
+  value: T | null,
+): Map<string, T> {
+  // The captured map is the synchronous write. Replaying it after an
+  // intervening render drops entries that render already merged. When the ref
+  // has moved ahead of this updater's base, reapply only this tab.
+  if (live === capturedBase || live === previous) return stateNext;
+  return value === null ? deleteMapEntry(live, tabId) : replaceMapEntry(live, tabId, value);
+}
+
+function reconcileSidePanelLayouts(
+  layouts: Map<string, SidePanelLayout>,
+  openTabs: Map<string, SidePanelTool>,
+): Map<string, SidePanelLayout> | null {
+  let changed = false;
+  const next = new Map(layouts);
+
+  for (const tabId of layouts.keys()) {
+    if (!openTabs.has(tabId)) {
+      next.delete(tabId);
+      changed = true;
+    }
+  }
+
+  for (const [tabId, tool] of openTabs) {
+    const current = next.get(tabId);
+    const updated = current
+      ? selectSidePanelTool(current, tool)
+      : createSidePanelLayout(tool, crypto.randomUUID());
+    if (updated !== current) {
+      next.set(tabId, updated);
+      changed = true;
+    }
+  }
+
+  return changed ? next : null;
+}
+
 export function useTerminalSidePanelLayoutState() {
   const [sidePanelOpenTabs, setSidePanelOpenTabs] = useState<Map<string, SidePanelTool>>(new Map());
   const [sidePanelLayouts, setSidePanelLayouts] = useState<Map<string, SidePanelLayout>>(new Map());
   const sidePanelOpenTabsRef = useRef(sidePanelOpenTabs);
   const sidePanelLayoutsRef = useRef(sidePanelLayouts);
-  sidePanelOpenTabsRef.current = sidePanelOpenTabs;
-  sidePanelLayoutsRef.current = sidePanelLayouts;
+  // Last maps this hook rendered. A transition can update the refs before React
+  // commits them; an urgent render in between must not copy the stale state
+  // back over that pending write. Once the queue commits, entries the pending
+  // write did not touch still have to catch up, or the ref stays on the
+  // transition updater's intermediate map.
+  const renderedOpenTabsRef = useRef(sidePanelOpenTabs);
+  const renderedLayoutsRef = useRef(sidePanelLayouts);
+  sidePanelOpenTabsRef.current = syncTrackedMap(
+    sidePanelOpenTabsRef.current,
+    renderedOpenTabsRef.current,
+    sidePanelOpenTabs,
+  );
+  renderedOpenTabsRef.current = sidePanelOpenTabs;
+  sidePanelLayoutsRef.current = syncTrackedMap(
+    sidePanelLayoutsRef.current,
+    renderedLayoutsRef.current,
+    sidePanelLayouts,
+  );
+  renderedLayoutsRef.current = sidePanelLayouts;
 
   // Legacy and external open paths write the focused-tool map. Reconcile that
   // public application boundary into the per-tab tree without disturbing the
-  // other panes in an existing layout.
+  // other panes in an existing layout. Skip the setState when the click path
+  // already stored this selection: scheduling an identical update still
+  // renders again after a paired openTabs write.
   useEffect(() => {
+    const base = sidePanelLayoutsRef.current;
+    const reconciled = reconcileSidePanelLayouts(base, sidePanelOpenTabs);
+    if (!reconciled) return;
+    sidePanelLayoutsRef.current = reconciled;
     setSidePanelLayouts((previous) => {
-      let changed = false;
-      const next = new Map(previous);
-
-      for (const tabId of previous.keys()) {
-        if (!sidePanelOpenTabs.has(tabId)) {
-          next.delete(tabId);
-          changed = true;
-        }
+      const next = previous === base
+        ? reconciled
+        : reconcileSidePanelLayouts(previous, sidePanelOpenTabs);
+      if (!next) {
+        sidePanelLayoutsRef.current = previous;
+        return previous;
       }
-
-      for (const [tabId, tool] of sidePanelOpenTabs) {
-        const current = next.get(tabId);
-        const updated = current
-          ? selectSidePanelTool(current, tool)
-          : createSidePanelLayout(tool, crypto.randomUUID());
-        if (updated !== current) {
-          next.set(tabId, updated);
-          changed = true;
-        }
-      }
-
-      if (changed) sidePanelLayoutsRef.current = next;
-      return changed ? next : previous;
+      sidePanelLayoutsRef.current = next;
+      return next;
     });
   }, [sidePanelOpenTabs]);
 
-  const commitLayout = useCallback((tabId: string, layout: SidePanelLayout) => {
-    const layouts = new Map(sidePanelLayoutsRef.current).set(tabId, layout);
-    const focusedTool = getFocusedSidePanelPane(layout).tool;
-    const openTabs = new Map(sidePanelOpenTabsRef.current).set(tabId, focusedTool);
+  const commitMap = useCallback((
+    tabId: string,
+    layout: SidePanelLayout,
+    openTab: SidePanelTool | null,
+  ) => {
+    const layoutBase = sidePanelLayoutsRef.current;
+    const openTabBase = sidePanelOpenTabsRef.current;
+    const layouts = openTab === null
+      ? deleteMapEntry(layoutBase, tabId)
+      : replaceMapEntry(layoutBase, tabId, layout);
+    const openTabs = openTab === null
+      ? deleteMapEntry(openTabBase, tabId)
+      : replaceMapEntry(openTabBase, tabId, openTab);
     sidePanelLayoutsRef.current = layouts;
     sidePanelOpenTabsRef.current = openTabs;
-    setSidePanelLayouts(layouts);
-    setSidePanelOpenTabs(openTabs);
+    setSidePanelLayouts((previous) => {
+      const next = previous === layoutBase
+        ? layouts
+        : (openTab === null ? deleteMapEntry(previous, tabId) : replaceMapEntry(previous, tabId, layout));
+      sidePanelLayoutsRef.current = publishQueuedMap(
+        sidePanelLayoutsRef.current,
+        layoutBase,
+        previous,
+        next,
+        tabId,
+        openTab === null ? null : layout,
+      );
+      return next;
+    });
+    setSidePanelOpenTabs((previous) => {
+      const next = previous === openTabBase
+        ? openTabs
+        : (openTab === null ? deleteMapEntry(previous, tabId) : replaceMapEntry(previous, tabId, openTab));
+      sidePanelOpenTabsRef.current = publishQueuedMap(
+        sidePanelOpenTabsRef.current,
+        openTabBase,
+        previous,
+        next,
+        tabId,
+        openTab,
+      );
+      return next;
+    });
   }, []);
 
+  const commitLayout = useCallback((tabId: string, layout: SidePanelLayout) => {
+    commitMap(tabId, layout, getFocusedSidePanelPane(layout).tool);
+  }, [commitMap]);
+
+  // Click path writes the focused tool and the layout together. The effect
+  // above still reconciles external openTabs writes, and skips when
+  // selectSidePanelTool returns the layout this call just stored.
+  const selectSidePanelToolForTab = useCallback((tabId: string, tool: SidePanelTool) => {
+    const current = sidePanelLayoutsRef.current.get(tabId);
+    const updated = current
+      ? selectSidePanelTool(current, tool)
+      : createSidePanelLayout(tool, crypto.randomUUID());
+    if (updated === current && sidePanelOpenTabsRef.current.get(tabId) === tool) return;
+    commitLayout(tabId, updated);
+  }, [commitLayout]);
+
   const focusPane = useCallback((tabId: string, paneId: string) => {
     const layout = sidePanelLayoutsRef.current.get(tabId);
     if (!layout) return;
@@ -97,25 +257,23 @@ export function useTerminalSidePanelLayoutState() {
       return false;
     }
 
-    const layouts = new Map(sidePanelLayoutsRef.current);
-    const openTabs = new Map(sidePanelOpenTabsRef.current);
-    layouts.delete(tabId);
-    openTabs.delete(tabId);
-    sidePanelLayoutsRef.current = layouts;
-    sidePanelOpenTabsRef.current = openTabs;
-    setSidePanelLayouts(layouts);
-    setSidePanelOpenTabs(openTabs);
+    commitMap(tabId, layout, null);
     return true;
-  }, [commitLayout]);
+  }, [commitLayout, commitMap]);
 
   const resizeSplit = useCallback((tabId: string, splitId: string, sizes: number[]) => {
     const layout = sidePanelLayoutsRef.current.get(tabId);
     if (!layout) return;
     const nextLayout = resizeSidePanelSplit(layout, splitId, sizes);
     if (nextLayout === layout) return;
-    const layouts = new Map(sidePanelLayoutsRef.current).set(tabId, nextLayout);
+    const base = sidePanelLayoutsRef.current;
+    const layouts = replaceMapEntry(base, tabId, nextLayout);
     sidePanelLayoutsRef.current = layouts;
-    setSidePanelLayouts(layouts);
+    setSidePanelLayouts((previous) => {
+      const next = previous === base ? layouts : replaceMapEntry(previous, tabId, nextLayout);
+      sidePanelLayoutsRef.current = next;
+      return next;
+    });
   }, []);
 
   return {
@@ -129,5 +287,6 @@ export function useTerminalSidePanelLayoutState() {
     splitPane,
     closePane,
     resizeSplit,
+    selectSidePanelToolForTab,
   };
 }

application/state/useVaultAgentBridge.ts

@@ -270,7 +270,7 @@ export function useVaultAgentBridge(input: UseVaultAgentBridgeInput): void {
         stopTunnel: current.stopTunnel,
         stopRuleTunnels: current.stopRuleTunnels,
         openHost: current.openHost
-          ? (host, isExternalMcpCall) => current.openHost!(host, isExternalMcpCall)
+          ? (host, isExternalMcpCall, options) => current.openHost!(host, isExternalMcpCall, options)
           : undefined,
         findExistingSessionForHost: current.findExistingSessionForHost,
         closeSession: current.closeSession

application/state/useVaultState.connectionLogTerminalData.test.ts

@@ -0,0 +1,60 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { readFileSync } from "node:fs";
+
+const source = readFileSync(new URL("./useVaultState.ts", import.meta.url), "utf8");
+const terminalLayerSource = readFileSync(
+  new URL("../../components/TerminalLayer.tsx", import.meta.url),
+  "utf8",
+);
+
+test("connection log replay blobs persist through IndexedDB instead of the legacy localStorage blob", () => {
+  assert.match(source, /await migrateLegacyConnectionLogTerminalData\(/);
+  assert.match(source, /await writeTerminalDataMapDiff\(/);
+  assert.match(source, /STORAGE_KEY_CONNECTION_LOG_TERMINAL_DATA_REV/);
+  assert.match(source, /syncConnectionLogTerminalData !== false|syncConnectionLogTerminalData\)/);
+  assert.doesNotMatch(source, /writeTerminalDataMapWithQuotaRetry/);
+  assert.doesNotMatch(
+    source,
+    /localStorageAdapter\.write\(\s*STORAGE_KEY_CONNECTION_LOG_TERMINAL_DATA\s*,/,
+  );
+});
+
+test("close-path connection log updates await the indexedDB persist task", () => {
+  assert.match(
+    source,
+    /const updateConnectionLog = useCallback\([\s\S]*?return commitConnectionLogs\(/,
+  );
+  assert.match(source, /rebaseQueuedConnectionLogs\(\s*memory,\s*removedIds,\s*changedIds,/);
+  assert.match(
+    source,
+    /if \(!options\?\.pruneMainBlob\) \{[\s\S]*?rebaseQueuedConnectionLogs\(/,
+  );
+  assert.match(source, /retainNewestUnsavedReplays\(fallbackLogs, keep\)/);
+  assert.match(source, /if \(!map\) return;/);
+  assert.match(
+    source,
+    /if \(key === STORAGE_KEY_CONNECTION_LOGS\) \{\s*\/\/ This window already updated connectionLogsRef before setItem\.[\s\S]*?return;\s*\}/,
+  );
+  assert.match(
+    terminalLayerSource,
+    /const handleTerminalDataCapture = useCallback\(\(sessionId: string, data: string\) => \{\s*return onTerminalDataCapture\?\.\(sessionId, data\);/,
+  );
+});
+
+test("boot re-reads connection logs after indexedDB load and falls back to the main blob", () => {
+  const revAt = source.indexOf("let revSeen = readTerminalDataRev()");
+  const bootAt = source.indexOf("const loaded = await migrateLegacyConnectionLogTerminalData");
+  assert.notEqual(revAt, -1);
+  assert.ok(revAt < bootAt);
+  const bootSlice = source.slice(bootAt, bootAt + 2800);
+  assert.match(bootSlice, /revNow !== revSeen[\s\S]*?await loadConnectionLogTerminalData\(\)/);
+  assert.match(
+    bootSlice,
+    /localStorageAdapter\.read<ConnectionLog\[\]>\(\s*STORAGE_KEY_CONNECTION_LOGS,\s*\)[\s\S]*?pruneTerminalDataMapForStorage\(connectionLogsForBoot/,
+  );
+  assert.match(
+    source,
+    /!sidePersisted && unsavedTerminalDataPending && mainPersisted\) \{\s*\/\/[\s\S]*?localStorageAdapter\.read<ConnectionLog\[\]>\(\s*STORAGE_KEY_CONNECTION_LOGS\s*\)[\s\S]*?mergeTerminalDataIntoLogs\(freshLogs, buildTerminalDataMapFromLogs\(logs\)\)/,
+  );
+});

application/state/useVaultState.ts

@@ -37,6 +37,7 @@ import {
 import {
   STORAGE_KEY_CONNECTION_LOGS,
   STORAGE_KEY_CONNECTION_LOG_TERMINAL_DATA,
+  STORAGE_KEY_CONNECTION_LOG_TERMINAL_DATA_REV,
   STORAGE_KEY_GROUP_CONFIGS,
   STORAGE_KEY_GROUPS,
   STORAGE_KEY_HOSTS,
@@ -61,13 +62,23 @@ import {
 } from "../../domain/globalHistory";
 import {
   buildTerminalDataMapFromLogs,
-  mergeConnectionLogsFromStorage,
+  acknowledgePendingConnectionLogWrites,
+  mergeConnectionLogsWithPendingMutations,
   mergeTerminalDataIntoLogs,
   mergeTerminalDataMapsForStorage,
   pruneInMemoryUnsavedTerminalData,
-  writeTerminalDataMapWithQuotaRetry,
+  rebaseQueuedConnectionLogs,
+  retainNewestUnsavedReplays,
+  pruneTerminalDataMapForStorage,
   type ConnectionLogTerminalDataMap,
+  type PendingConnectionLogWrite,
 } from "../../domain/connectionLogTerminalData";
+import {
+  tryLoadAll as tryLoadConnectionLogTerminalData,
+  migrateLegacyConnectionLogTerminalData,
+  writeTerminalDataMapDiff,
+  type ConnectionLogTerminalDataRev,
+} from "../../infrastructure/persistence/connectionLogTerminalDataStore";
 import { getNextVaultOrder, normalizeVaultOrder } from "../../domain/vaultOrder";
 import {
   deleteSelectedSnippetsFromVault,
@@ -229,6 +240,13 @@ const safeParse = <T,>(value: string | null): T | null => {
   }
 };
 
+/** `null` means the read failed. `{}` is a successful empty store. Retries once. */
+const loadConnectionLogTerminalData = async (): Promise<ConnectionLogTerminalDataMap | null> => {
+  const first = await tryLoadConnectionLogTerminalData();
+  if (first) return first;
+  return tryLoadConnectionLogTerminalData();
+};
+
 /**
  * Strip the bulky `terminalData` replay buffer from transient (unsaved)
  * connection logs before persisting. `terminalData` is the full terminal
@@ -257,9 +275,6 @@ const readLegacyLineTimestampsEnabled = (): boolean => {
   return stored?.showLineTimestamps === true;
 };
 
-const readConnectionLogTerminalDataMap = (): ConnectionLogTerminalDataMap =>
-  localStorageAdapter.read<ConnectionLogTerminalDataMap>(STORAGE_KEY_CONNECTION_LOG_TERMINAL_DATA) ?? {};
-
 const readPersistedConnectionLogIds = (): Set<string> => {
   const stored = localStorageAdapter.read<ConnectionLog[]>(STORAGE_KEY_CONNECTION_LOGS) ?? [];
   return new Set(stored.map((log) => log.id));
@@ -278,45 +293,6 @@ const buildPersistedLogIds = (
   return ids;
 };
 
-/**
- * Same result as comparing `JSON.stringify` of both maps (own keys in the
- * same order, equal values) without serializing the multi-MB replay data.
- */
-const isSameTerminalDataMap = (
-  a: ConnectionLogTerminalDataMap,
-  b: ConnectionLogTerminalDataMap,
-): boolean => {
-  if (typeof a !== "object" || a === null || Array.isArray(a)) {
-    return JSON.stringify(a) === JSON.stringify(b);
-  }
-  const aKeys = Object.keys(a);
-  const bKeys = Object.keys(b);
-  if (aKeys.length !== bKeys.length) return false;
-  for (let i = 0; i < aKeys.length; i += 1) {
-    if (aKeys[i] !== bKeys[i] || a[aKeys[i]] !== b[bKeys[i]]) return false;
-  }
-  return true;
-};
-
-const writeConnectionLogTerminalDataMap = (
-  existing: ConnectionLogTerminalDataMap,
-  pruned: ConnectionLogTerminalDataMap,
-  logs: ConnectionLog[],
-  quotaFailedCharsRef: { current: number | null },
-): boolean => {
-  if (isSameTerminalDataMap(existing, pruned)) return true;
-  // On quota failure keep the newest replay buffers instead of none.
-  // The hint stays on the hook so the domain helper remains a pure calculation.
-  const result = writeTerminalDataMapWithQuotaRetry(
-    logs,
-    pruned,
-    (next) => localStorageAdapter.write(STORAGE_KEY_CONNECTION_LOG_TERMINAL_DATA, next),
-    quotaFailedCharsRef.current,
-  );
-  quotaFailedCharsRef.current = result.quotaFailedChars;
-  return result.persisted;
-};
-
 export type UseVaultStateOptions = {
   /**
    * When false, skip loading and cross-window sync of the bulky
@@ -454,65 +430,158 @@ export const useVaultState = (options?: UseVaultStateOptions) => {
   const identitiesReadSeq = useRef(0);
   const proxyProfilesReadSeq = useRef(0);
   const groupConfigsReadSeq = useRef(0);
+  const connectionLogsRef = useRef<ConnectionLog[]>([]);
+  const connectionLogWriteGenerationRef = useRef(0);
+  const connectionLogPendingRef = useRef(new Map<string, PendingConnectionLogWrite>());
   const connectionLogTerminalDataRef = useRef<ConnectionLogTerminalDataMap>({});
-  const connectionLogQuotaFailedCharsRef = useRef<number | null>(null);
+  const connectionLogTerminalDataPersistedRef = useRef<ConnectionLogTerminalDataMap>({});
+  const connectionLogTerminalDataRevRawRef = useRef<string | null>(null);
+  const connectionLogTerminalDataLoadSeq = useRef(0);
+  const terminalDataQueueRef = useRef<Promise<void>>(Promise.resolve());
+  const terminalDataReadyRef = useRef<Promise<void>>(Promise.resolve());
   const pluginCredentialCatalogVersion = useRef(0);
 
-  const syncConnectionLogTerminalDataMap = useCallback((
+  const enqueueTerminalDataTask = useCallback(<T,>(task: () => Promise<T>): Promise<T> => {
+    const run = terminalDataQueueRef.current.then(task, task);
+    terminalDataQueueRef.current = run.then(() => undefined, () => undefined);
+    return run;
+  }, []);
+
+  const bumpConnectionLogTerminalDataRev = useCallback((ids: readonly string[]) => {
+    const current = localStorageAdapter.read<ConnectionLogTerminalDataRev>(
+      STORAGE_KEY_CONNECTION_LOG_TERMINAL_DATA_REV,
+    );
+    const prev = typeof current?.rev === "number" && Number.isFinite(current.rev) ? current.rev : 0;
+    const payload: ConnectionLogTerminalDataRev = {
+      rev: Math.max(prev + 1, Date.now()),
+      ids: [...ids].sort(),
+      nonce: crypto.randomUUID(),
+    };
+    // Record the exact JSON before setItem so this window ignores its own echo.
+    connectionLogTerminalDataRevRawRef.current = JSON.stringify(payload);
+    const written = localStorageAdapter.write(STORAGE_KEY_CONNECTION_LOG_TERMINAL_DATA_REV, payload);
+    if (!written) {
+      connectionLogTerminalDataRevRawRef.current = localStorageAdapter.readString(
+        STORAGE_KEY_CONNECTION_LOG_TERMINAL_DATA_REV,
+      );
+    }
+  }, []);
+
+  const absorbRemoteTerminalDataIfNeeded = useCallback(async () => {
+    const raw = localStorageAdapter.readString(STORAGE_KEY_CONNECTION_LOG_TERMINAL_DATA_REV);
+    if (raw === connectionLogTerminalDataRevRawRef.current) return;
+    const map = await loadConnectionLogTerminalData();
+    if (!map) return;
+    connectionLogTerminalDataRevRawRef.current = raw;
+    connectionLogTerminalDataPersistedRef.current = map;
+    connectionLogTerminalDataRef.current = {
+      ...map,
+      ...connectionLogTerminalDataRef.current,
+    };
+  }, []);
+
+  const syncConnectionLogTerminalDataMap = useCallback(async (
     logs: ConnectionLog[],
     options?: { usePersistedLogIdsFromDisk?: boolean },
   ) => {
-    const usePersistedLogIdsFromDisk = options?.usePersistedLogIdsFromDisk ?? false;
-    const localMaps = [
-      connectionLogTerminalDataRef.current,
-      buildTerminalDataMapFromLogs(logs),
-    ];
-    const existing = readConnectionLogTerminalDataMap();
+    if (!syncConnectionLogTerminalData) return true;
+    await absorbRemoteTerminalDataIfNeeded();
+    const baseline = connectionLogTerminalDataPersistedRef.current;
     const merged = mergeTerminalDataMapsForStorage(
       logs,
-      existing,
-      localMaps,
-      buildPersistedLogIds(logs, usePersistedLogIdsFromDisk),
+      baseline,
+      [
+        connectionLogTerminalDataRef.current,
+        buildTerminalDataMapFromLogs(logs),
+      ],
+      buildPersistedLogIds(logs, options?.usePersistedLogIdsFromDisk ?? false),
     );
-    const persisted = writeConnectionLogTerminalDataMap(
-      existing,
-      merged,
-      logs,
-      connectionLogQuotaFailedCharsRef,
-    );
-    // On a failed write (e.g. QuotaExceeded once the side store nears ~50 MB)
-    // keep the same capped map instead of accumulating every log's replay
-    // buffer in memory; anything outside it would be pruned on the next write.
+    const written = await writeTerminalDataMapDiff(baseline, merged);
+    // Keep the capped map in memory even when IndexedDB rejects the write, so
+    // the next close retries from the last committed baseline.
     connectionLogTerminalDataRef.current = merged;
-    return { map: connectionLogTerminalDataRef.current, persisted };
-  }, []);
+    if (!written.changed) return true;
+    if (!written.persisted) return false;
+    connectionLogTerminalDataPersistedRef.current = merged;
+    bumpConnectionLogTerminalDataRev(Object.keys(merged));
+    return true;
+  }, [
+    absorbRemoteTerminalDataIfNeeded,
+    bumpConnectionLogTerminalDataRev,
+    syncConnectionLogTerminalData,
+  ]);
 
-  const persistConnectionLogState = useCallback((
+  const persistConnectionLogState = useCallback(async (
     logs: ConnectionLog[],
-    options?: { pruneMainBlob?: boolean },
+    options?: {
+      pruneMainBlob?: boolean;
+      removedIds?: ReadonlySet<string>;
+      changedIds?: ReadonlySet<string>;
+    },
   ) => {
     const unsavedTerminalDataPending = logs.some(
       (log) => !log.saved && log.terminalData !== undefined,
     );
+    let mainReplay: ConnectionLogTerminalDataMap = {};
+    const writeMain = (value: ConnectionLog[]) => {
+      const written = localStorageAdapter.write(STORAGE_KEY_CONNECTION_LOGS, value);
+      if (written) mainReplay = buildTerminalDataMapFromLogs(value);
+      return written;
+    };
 
     let mainPersisted = true;
     if (options?.pruneMainBlob) {
       const prunedMain = pruneConnectionLogsForStorage(logs);
-      mainPersisted = localStorageAdapter.write(STORAGE_KEY_CONNECTION_LOGS, prunedMain);
+      mainPersisted = writeMain(prunedMain);
       if (!mainPersisted && unsavedTerminalDataPending) {
-        mainPersisted = localStorageAdapter.write(STORAGE_KEY_CONNECTION_LOGS, logs);
+        mainPersisted = writeMain(logs);
       }
     }
 
-    let sidePersisted = true;
+    let sidePersisted = false;
     if (mainPersisted || !options?.pruneMainBlob) {
-      ({ persisted: sidePersisted } = syncConnectionLogTerminalDataMap(logs, {
+      sidePersisted = await syncConnectionLogTerminalDataMap(logs, {
         usePersistedLogIdsFromDisk: Boolean(options?.pruneMainBlob && mainPersisted),
-      }));
+      });
     }
 
     if (!options?.pruneMainBlob) {
-      mainPersisted = localStorageAdapter.write(STORAGE_KEY_CONNECTION_LOGS, logs);
+      // The side-store await can overlap another window's metadata write.
+      // Rebase this snapshot onto the blob that exists now, immediately before
+      // replacing it. A failed read keeps the snapshot already rebased at enqueue.
+      const freshLogs = localStorageAdapter.read<ConnectionLog[]>(STORAGE_KEY_CONNECTION_LOGS);
+      const toWrite = freshLogs
+        ? rebaseQueuedConnectionLogs(
+          logs,
+          options?.removedIds ?? new Set<string>(),
+          options?.changedIds ?? new Set<string>(),
+          mergeConnectionLogsWithPendingMutations(
+            connectionLogsRef.current,
+            freshLogs,
+            connectionLogTerminalDataPersistedRef.current,
+            connectionLogPendingRef.current,
+          ),
+          freshLogs,
+        )
+        : logs;
+      mainPersisted = writeMain(toWrite);
+    } else if (!sidePersisted && unsavedTerminalDataPending && mainPersisted) {
+      // IndexedDB rejected the replay after the pruned metadata write. Put the
+      // buffers back on the current main blob so a restart still has them,
+      // without replacing logs another window wrote during the await.
+      // If that blob exceeds quota, drop older unsaved replays and retry so
+      // the newest capture still has a durable copy.
+      const freshLogs = localStorageAdapter.read<ConnectionLog[]>(STORAGE_KEY_CONNECTION_LOGS);
+      let fallbackLogs = freshLogs
+        ? mergeTerminalDataIntoLogs(freshLogs, buildTerminalDataMapFromLogs(logs))
+        : logs;
+      sidePersisted = writeMain(fallbackLogs);
+      let keep = fallbackLogs.filter((log) => !log.saved && log.terminalData).length;
+      while (!sidePersisted && keep > 1) {
+        keep = Math.max(1, Math.floor(keep / 2));
+        fallbackLogs = retainNewestUnsavedReplays(fallbackLogs, keep);
+        sidePersisted = writeMain(fallbackLogs);
+      }
     }
 
     if (!mainPersisted && unsavedTerminalDataPending) {
@@ -524,15 +593,105 @@ export const useVaultState = (options?: UseVaultStateOptions) => {
         "[useVaultState] Failed to persist connection log terminal replay data side store.",
       );
     }
+    return { metadataPersisted: mainPersisted, replayPersisted: sidePersisted, mainReplay };
   }, [syncConnectionLogTerminalDataMap]);
 
+  const commitConnectionLogs = useCallback((
+    recipe: (prev: ConnectionLog[]) => ConnectionLog[],
+    options?: { pruneMainBlob?: boolean },
+  ) => {
+    const prev = connectionLogsRef.current;
+    const next = recipe(prev);
+    const prevById = new Map(prev.map((log) => [log.id, log]));
+    const nextIds = new Set<string>();
+    const generation = ++connectionLogWriteGenerationRef.current;
+    for (const log of next) {
+      nextIds.add(log.id);
+      const before = prevById.get(log.id);
+      if (!before || before !== log) {
+        const previous = connectionLogPendingRef.current.get(log.id);
+        const changes: Partial<ConnectionLog> = { ...previous?.changes };
+        const fieldGenerations = { ...previous?.fieldGenerations };
+        for (const field of Object.keys({ ...before, ...log }) as Array<keyof ConnectionLog>) {
+          if (!before || before[field] !== log[field]) {
+            Object.assign(changes, { [field]: log[field] });
+            fieldGenerations[field] = generation;
+          }
+        }
+        connectionLogPendingRef.current.set(log.id, {
+          generation, log, changes, fieldGenerations, added: previous?.added ?? !before,
+        });
+      }
+    }
+    for (const log of prev) {
+      if (!nextIds.has(log.id)) {
+        connectionLogPendingRef.current.set(log.id, { generation, log: null });
+      }
+    }
+    connectionLogsRef.current = next;
+    setConnectionLogs(next);
+    return enqueueTerminalDataTask(() => withVaultImportLock("connection-logs", async () => {
+      // The shared lock covers the read/rebase as well as both storage writes.
+      // Include uncommitted generations from failed or newer queued captures.
+      await absorbRemoteTerminalDataIfNeeded();
+      const pending = new Map(connectionLogPendingRef.current);
+      const removedIds = new Set<string>();
+      const changedIds = new Set<string>();
+      for (const [id, mutation] of pending) {
+        if (mutation.log === null) removedIds.add(id);
+        else changedIds.add(id);
+      }
+      const storedBefore = localStorageAdapter.read<ConnectionLog[]>(STORAGE_KEY_CONNECTION_LOGS);
+      const memory = mergeConnectionLogsWithPendingMutations(
+        connectionLogsRef.current,
+        storedBefore ?? connectionLogsRef.current,
+        connectionLogTerminalDataPersistedRef.current,
+        pending,
+      );
+      const persisted = await persistConnectionLogState(
+        rebaseQueuedConnectionLogs(
+          memory,
+          removedIds,
+          changedIds,
+          memory,
+          storedBefore,
+        ),
+        { ...options, removedIds, changedIds },
+      );
+      // A replay/quota failure must not retain already-committed add or
+      // metadata ownership: retrying it could undo a peer bookmark/deletion.
+      connectionLogPendingRef.current = acknowledgePendingConnectionLogWrites(
+        connectionLogPendingRef.current, pending, persisted,
+      );
+      if (persisted.metadataPersisted || persisted.replayPersisted) {
+        const stored = localStorageAdapter.read<ConnectionLog[]>(STORAGE_KEY_CONNECTION_LOGS);
+        if (stored) {
+          const merged = mergeConnectionLogsWithPendingMutations(
+            connectionLogsRef.current,
+            stored,
+            connectionLogTerminalDataRef.current,
+            connectionLogPendingRef.current,
+          );
+          connectionLogsRef.current = merged;
+          setConnectionLogs(merged);
+        }
+      }
+      return persisted.metadataPersisted && persisted.replayPersisted;
+    }));
+  }, [absorbRemoteTerminalDataIfNeeded, enqueueTerminalDataTask, persistConnectionLogState]);
+
   const applyConnectionLogsFromStorage = useCallback((
     prev: ConnectionLog[],
     storedLogs: ConnectionLog[],
     terminalDataMap: ConnectionLogTerminalDataMap,
   ) => {
     connectionLogTerminalDataRef.current = terminalDataMap;
-    return mergeConnectionLogsFromStorage(prev, storedLogs, terminalDataMap);
+    return mergeConnectionLogsWithPendingMutations(
+      prev,
+      storedLogs,
+      terminalDataMap,
+      connectionLogPendingRef.current,
+    );
   }, []);
 
   // Encrypt outside the lock, then under the lock prune script bindings against
@@ -1326,67 +1485,56 @@ export const useVaultState = (options?: UseVaultStateOptions) => {
         ...log,
         id: crypto.randomUUID(),
       };
-      setConnectionLogs((prev) => {
+      void commitConnectionLogs((prev) => {
         // Keep only the last 500 non-saved entries plus all saved entries
         const savedLogs = prev.filter((l) => l.saved);
         const unsavedLogs = prev.filter((l) => !l.saved);
         const updated = [newLog, ...unsavedLogs].slice(0, 500);
-        const final = pruneInMemoryUnsavedTerminalData(
+        return pruneInMemoryUnsavedTerminalData(
           [...updated, ...savedLogs].sort(
             (a, b) => b.startTime - a.startTime
           ),
         );
-        persistConnectionLogState(final, { pruneMainBlob: true });
-        return final;
-      });
+      }, { pruneMainBlob: true });
       return newLog.id;
     },
-    [persistConnectionLogState],
+    [commitConnectionLogs],
   );
 
   const updateConnectionLog = useCallback(
     (id: string, updates: Partial<ConnectionLog>) => {
-      setConnectionLogs((prev) => {
-        const updated = pruneInMemoryUnsavedTerminalData(
+      return commitConnectionLogs((prev) => (
+        pruneInMemoryUnsavedTerminalData(
           prev.map((log) => (log.id === id ? { ...log, ...updates } : log)),
-        );
-        persistConnectionLogState(updated, { pruneMainBlob: true });
-        return updated;
-      });
+        )
+      ), { pruneMainBlob: true });
     },
-    [persistConnectionLogState],
+    [commitConnectionLogs],
   );
 
   const toggleConnectionLogSaved = useCallback((id: string) => {
-    setConnectionLogs((prev) => {
-      const updated = pruneInMemoryUnsavedTerminalData(
+    void commitConnectionLogs((prev) => (
+      pruneInMemoryUnsavedTerminalData(
         prev.map((log) =>
           log.id === id ? { ...log, saved: !log.saved } : log
         ),
-      );
-      persistConnectionLogState(updated, { pruneMainBlob: false });
-      return updated;
-    });
-  }, [persistConnectionLogState]);
+      )
+    ), { pruneMainBlob: false });
+  }, [commitConnectionLogs]);
 
   const deleteConnectionLog = useCallback((id: string) => {
-    setConnectionLogs((prev) => {
-      const updated = prev.filter((log) => log.id !== id);
-      const map = { ...connectionLogTerminalDataRef.current };
-      delete map[id];
-      connectionLogTerminalDataRef.current = map;
-      persistConnectionLogState(updated, { pruneMainBlob: true });
-      return updated;
-    });
-  }, [persistConnectionLogState]);
+    void commitConnectionLogs(
+      (prev) => prev.filter((log) => log.id !== id),
+      { pruneMainBlob: true },
+    );
+  }, [commitConnectionLogs]);
 
   const clearUnsavedConnectionLogs = useCallback(() => {
-    setConnectionLogs((prev) => {
-      const saved = prev.filter((log) => log.saved);
-      persistConnectionLogState(saved, { pruneMainBlob: true });
-      return saved;
-    });
-  }, [persistConnectionLogState]);
+    void commitConnectionLogs(
+      (prev) => prev.filter((log) => log.saved),
+      { pruneMainBlob: true },
+    );
+  }, [commitConnectionLogs]);
 
   // Connection logs for Vault logs section — keep App domain bags off session churn.
   useLayoutEffect(() => {
@@ -1453,6 +1601,11 @@ export const useVaultState = (options?: UseVaultStateOptions) => {
 
   useEffect(() => {
     let cancelled = false;
+    let resolveTerminalDataReady = () => {};
+    const terminalDataReady = new Promise<void>((resolve) => {
+      resolveTerminalDataReady = resolve;
+    });
+    terminalDataReadyRef.current = terminalDataReady;
     const init = async () => {
       try {
         await withVaultImportLock("vault", async () => {
@@ -1662,18 +1815,91 @@ export const useVaultState = (options?: UseVaultStateOptions) => {
           publishShellHistorySnapshot(savedShellHistory);
         }
 
-        // Load connection logs
+        // Load connection logs. Replay blobs live in IndexedDB, one row per
+        // log id. Windows that never render replay skip that read
+        // (Settings / tray / popup).
         const savedConnectionLogs = localStorageAdapter.read<ConnectionLog[]>(
           STORAGE_KEY_CONNECTION_LOGS,
         );
-        // Windows that never render connection-log replay skip the ~30–50 MB
-        // side-store parse on boot (Settings / tray / popup).
-        const terminalDataMap = syncConnectionLogTerminalData
-          ? readConnectionLogTerminalDataMap()
-          : {};
+        let connectionLogsForBoot = savedConnectionLogs;
+        let terminalDataMap: ConnectionLogTerminalDataMap = {};
+        let durableTerminalData = true;
+        if (syncConnectionLogTerminalData) {
+          const readTerminalDataRev = () => localStorageAdapter.readString(
+            STORAGE_KEY_CONNECTION_LOG_TERMINAL_DATA_REV,
+          );
+          // A peer can commit replay and bump the rev while this load is in
+          // flight. Capture the rev first and reload when it moves, so stamping
+          // the key later does not mark an unread snapshot as consumed.
+          let revSeen = readTerminalDataRev();
+          const loaded = await migrateLegacyConnectionLogTerminalData({
+            read: () => localStorageAdapter.read<ConnectionLogTerminalDataMap>(
+              STORAGE_KEY_CONNECTION_LOG_TERMINAL_DATA,
+            ),
+            remove: () => {
+              localStorageAdapter.remove(STORAGE_KEY_CONNECTION_LOG_TERMINAL_DATA);
+            },
+          });
+          if (cancelled) return;
+          terminalDataMap = loaded.map;
+          let revNow = readTerminalDataRev();
+          if (revNow !== revSeen) {
+            const reloaded = await loadConnectionLogTerminalData();
+            if (cancelled) return;
+            if (reloaded) {
+              if (Object.keys(reloaded).length > 0) {
+                terminalDataMap = { ...terminalDataMap, ...reloaded };
+              }
+              revSeen = revNow;
+            }
+          }
+          // Another window can append a log while IndexedDB is opening. Prune
+          // against that newer metadata so this boot does not delete its replay.
+          connectionLogsForBoot = localStorageAdapter.read<ConnectionLog[]>(
+            STORAGE_KEY_CONNECTION_LOGS,
+          ) ?? savedConnectionLogs;
+          const pruned = connectionLogsForBoot
+            ? pruneTerminalDataMapForStorage(connectionLogsForBoot, terminalDataMap)
+            : terminalDataMap;
+          // A legacy map that never reached IndexedDB is not a diff baseline.
+          // Comparing against it would persist only the changed ids and then
+          // drop the rest of the legacy blob on the next boot.
+          const baseline = loaded.durable ? terminalDataMap : {};
+          const written = await writeTerminalDataMapDiff(baseline, pruned);
+          if (cancelled) return;
+          if (written.persisted) {
+            terminalDataMap = pruned;
+            if (!loaded.durable) {
+              localStorageAdapter.remove(STORAGE_KEY_CONNECTION_LOG_TERMINAL_DATA);
+            }
+          }
+          durableTerminalData = written.persisted || loaded.durable;
+          if (loaded.migrated || (written.changed && written.persisted)) {
+            bumpConnectionLogTerminalDataRev(Object.keys(terminalDataMap));
+          } else {
+            revNow = readTerminalDataRev();
+            if (revNow !== revSeen) {
+              const reloaded = await loadConnectionLogTerminalData();
+              if (cancelled) return;
+              if (reloaded) {
+                if (Object.keys(reloaded).length > 0) {
+                  terminalDataMap = { ...terminalDataMap, ...reloaded };
+                }
+                revSeen = revNow;
+                connectionLogsForBoot = localStorageAdapter.read<ConnectionLog[]>(
+                  STORAGE_KEY_CONNECTION_LOGS,
+                ) ?? connectionLogsForBoot;
+              }
+            }
+            connectionLogTerminalDataRevRawRef.current = revSeen;
+          }
+        }
         connectionLogTerminalDataRef.current = terminalDataMap;
-        if (savedConnectionLogs) {
-          setConnectionLogs(mergeTerminalDataIntoLogs(savedConnectionLogs, terminalDataMap));
+        connectionLogTerminalDataPersistedRef.current = durableTerminalData ? terminalDataMap : {};
+        if (connectionLogsForBoot) {
+          const hydrated = mergeTerminalDataIntoLogs(connectionLogsForBoot, terminalDataMap);
+          connectionLogsRef.current = hydrated;
+          setConnectionLogs(hydrated);
         }
 
         // Load managed sources
@@ -1702,6 +1928,7 @@ export const useVaultState = (options?: UseVaultStateOptions) => {
           }
         }
       } finally {
+        resolveTerminalDataReady();
         // StrictMode remount cancels the first init; only the surviving effect
         // may publish "vault ready" or terminals can boot against empty keys.
         if (!cancelled) {
@@ -1714,8 +1941,15 @@ export const useVaultState = (options?: UseVaultStateOptions) => {
     void init();
     return () => {
       cancelled = true;
+      resolveTerminalDataReady();
     };
-  }, [commitEncryptedHostsUnderVaultLock, syncConnectionLogTerminalData, updateHosts, updateSnippets]);
+  }, [
+    bumpConnectionLogTerminalDataRev,
+    commitEncryptedHostsUnderVaultLock,
+    syncConnectionLogTerminalData,
+    updateHosts,
+    updateSnippets,
+  ]);
 
   useEffect(() => {
     if (!isInitialized) return;
@@ -1916,20 +2150,22 @@ export const useVaultState = (options?: UseVaultStateOptions) => {
       }
 
       if (key === STORAGE_KEY_CONNECTION_LOGS) {
-        const next = safeParse<ConnectionLog[]>(event.newValue) ?? [];
-        setConnectionLogs((prev) =>
-          applyConnectionLogsFromStorage(prev, next, connectionLogTerminalDataRef.current),
+        // A queued peer event may predate our successful commit. Read the
+        // current blob, then preserve only still-owned local generations.
+        const next = localStorageAdapter.read<ConnectionLog[]>(STORAGE_KEY_CONNECTION_LOGS);
+        if (!next) return;
+        const merged = applyConnectionLogsFromStorage(
+          connectionLogsRef.current,
+          next,
+          connectionLogTerminalDataRef.current,
         );
+        connectionLogsRef.current = merged;
+        setConnectionLogs(merged);
         return;
       }
 
-      if (key === STORAGE_KEY_CONNECTION_LOG_TERMINAL_DATA) {
-        // Other windows still receive the storage event; skip the multi-MB
-        // JSON.parse when this mount does not show connection-log replay.
-        if (!syncConnectionLogTerminalData) return;
-        const next = safeParse<ConnectionLogTerminalDataMap>(event.newValue) ?? {};
-        connectionLogTerminalDataRef.current = next;
-        setConnectionLogs((prev) => mergeConnectionLogsFromStorage(prev, prev, next));
+      if (key === STORAGE_KEY_CONNECTION_LOG_TERMINAL_DATA_REV) {
+        applyTerminalDataRev(event.newValue);
         return;
       }
 
@@ -1957,20 +2193,47 @@ export const useVaultState = (options?: UseVaultStateOptions) => {
       }
     };
 
+    const applyTerminalDataRev = (raw: string | null) => {
+      // Settings, tray, and popup mounts never replay logs and must not
+      // pull the side store across windows.
+      if (!syncConnectionLogTerminalData) return;
+      if (raw === connectionLogTerminalDataRevRawRef.current) return;
+      const seq = ++connectionLogTerminalDataLoadSeq.current;
+      void terminalDataReadyRef.current.then(() => enqueueTerminalDataTask(() => withVaultImportLock("connection-logs", async () => {
+        if (seq !== connectionLogTerminalDataLoadSeq.current) return;
+        const map = await loadConnectionLogTerminalData();
+        if (seq !== connectionLogTerminalDataLoadSeq.current) return;
+        if (!map) return;
+        connectionLogTerminalDataRevRawRef.current = localStorageAdapter.readString(
+          STORAGE_KEY_CONNECTION_LOG_TERMINAL_DATA_REV,
+        );
+        connectionLogTerminalDataPersistedRef.current = map;
+        connectionLogTerminalDataRef.current = map;
+        const merged = mergeConnectionLogsWithPendingMutations(
+          connectionLogsRef.current,
+          localStorageAdapter.read<ConnectionLog[]>(STORAGE_KEY_CONNECTION_LOGS) ?? connectionLogsRef.current,
+          map,
+          connectionLogPendingRef.current,
+        );
+        connectionLogsRef.current = merged;
+        setConnectionLogs(merged);
+      })));
+    };
+
     const handleLocalStorageAdapterChanged = (event: Event) => {
       const key = (event as CustomEvent<{ key?: string }>).detail?.key;
       if (key === STORAGE_KEY_CONNECTION_LOGS) {
-        const next = localStorageAdapter.read<ConnectionLog[]>(STORAGE_KEY_CONNECTION_LOGS) ?? [];
-        setConnectionLogs((prev) =>
-          applyConnectionLogsFromStorage(prev, next, connectionLogTerminalDataRef.current),
-        );
+        // This window already updated connectionLogsRef before setItem. The
+        // adapter notifies on a timer, so this blob can be older than a log
+        // added or finalized while that write was still queued. Applying it
+        // would drop that log from the ref, and the follow-up recipe would
+        // record no changed id. Other windows still arrive through "storage".
         return;
       }
-      if (key === STORAGE_KEY_CONNECTION_LOG_TERMINAL_DATA) {
-        if (!syncConnectionLogTerminalData) return;
-        const next = readConnectionLogTerminalDataMap();
-        connectionLogTerminalDataRef.current = next;
-        setConnectionLogs((prev) => mergeConnectionLogsFromStorage(prev, prev, next));
+      if (key === STORAGE_KEY_CONNECTION_LOG_TERMINAL_DATA_REV) {
+        applyTerminalDataRev(localStorageAdapter.readString(
+          STORAGE_KEY_CONNECTION_LOG_TERMINAL_DATA_REV,
+        ));
       }
     };
 
@@ -1980,7 +2243,7 @@ export const useVaultState = (options?: UseVaultStateOptions) => {
       window.removeEventListener("storage", handleStorage);
       window.removeEventListener(LOCAL_STORAGE_ADAPTER_CHANGED_EVENT, handleLocalStorageAdapterChanged);
     };
-  }, [applyConnectionLogsFromStorage, syncConnectionLogTerminalData]);
+  }, [applyConnectionLogsFromStorage, enqueueTerminalDataTask, syncConnectionLogTerminalData]);
 
   const updateHostLastConnected = useCallback((hostId: string) => {
     setHosts((prev) => {

components/AIChatPanelContent.tsx

@@ -411,6 +411,8 @@ export const AIChatPanelContent: React.FC<AIChatPanelContentProps> = ({
                   modelCatalogLoading={modelCatalogLoading}
                   modelCatalogSource={modelCatalogSource}
                   modelCatalogFetchedAt={modelCatalogFetchedAt}
+                  modelCatalogWarning={modelCatalogWarning}
+                  onRefreshModelCatalog={handleModelCatalogRetry}
                   allowCustomModelEntry={allowCustomModelEntry}
                   selectedModelId={selectedAgentModel}
                   onModelSelect={handleAgentModelSelect}

components/AIChatSidePanel.tsx

@@ -1090,6 +1090,9 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
           target.agentEnv,
           target.agentCommand,
           target.codexRuntime,
+          // Manual refresh (retry banner / picker button) must bypass the
+          // main-side LKG-first policy and go live.
+          options.force === true,
         );
         if (!result?.ok || !Array.isArray(result.models)) {
           throw new Error(result?.error || 'Failed to load SDK agent models');

components/AIChatSidePanelHelpers.test.tsx

@@ -620,6 +620,34 @@ test('SDK runtime model cache preserves degraded warnings until a successful ret
   assert.equal(cache.read('copilot')?.warning, undefined);
 });
 
+test('SDK runtime model cache re-queries main past the TTL so a clean LKG serve clears a stale banner', async () => {
+  let now = 1_000;
+  const cache = createSdkRuntimeModelCache({ ttlMs: 100, now: () => now });
+
+  // A degraded serve (warning) is cached and replayed within the TTL.
+  await cache.refresh('claude:/opt/bin/claude', async () => ({
+    currentModelId: 'claude-opus-5-5',
+    models: [{ id: 'claude-opus-5-5', name: 'Opus 5.5' }],
+    warning: 'live fetch failed',
+  }));
+  assert.equal(cache.read('claude:/opt/bin/claude')?.warning, 'live fetch failed');
+
+  // Past the TTL the entry is evicted and the next automatic load re-queries
+  // main; with the LKG-first policy that round-trip returns a clean
+  // last-known-good serve, so the stale banner clears.
+  now = 1_150;
+  const cleared = await cache.refresh('claude:/opt/bin/claude', async () => ({
+    currentModelId: 'claude-opus-5-5',
+    models: [{ id: 'claude-opus-5-5', name: 'Opus 5.5' }],
+    source: 'last-known-good',
+    fetchedAt: '2026-10-23T08:00:00.000Z',
+  }));
+  assert.equal(cleared.source, 'last-known-good');
+  assert.equal(cleared.warning, undefined);
+  assert.equal(cache.read('claude:/opt/bin/claude')?.warning, undefined);
+  assert.equal(cache.read('claude:/opt/bin/claude')?.fetchedAt, '2026-10-23T08:00:00.000Z');
+});
+
 // #3584 alignment: OpenCode must render build-time presets while its live
 // catalog load is pending, exactly like every other backend. The old host
 // code suppressed presets for opencode while `runtimeModelLoading` was set,

components/AIChatSidePanelHelpers.ts

@@ -247,6 +247,10 @@ export function createSdkRuntimeModelCache(options: SdkRuntimeModelCacheOptions
       pruneEntries();
       const cached = entries.get(key);
       if (!refreshOptions.force && cached && now() - cached.updatedAt < ttlMs) {
+        // The LKG-first policy lives in main: once a persisted catalog exists
+        // there, a TTL-expired non-force refresh is answered from disk with a
+        // clean last-known-good serve (no live attempt, no warning), so the
+        // next automatic load here clears a stale banner.
         touchEntry(key, cached);
         return Promise.resolve(cloneCatalog(cached));
       }

components/GlobalSftpTransferCenter.cleanup-warning.test.tsx

@@ -0,0 +1,59 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import React from "react";
+import { createDomRenderer, dispatchDomEvent, flushEffects, installDomEnvironment } from "./test-support/renderReactDom";
+
+test("global completed rows and expanded folder children show cleanup paths without a failed status", async (t) => {
+  const env = installDomEnvironment();
+  const previous = new Map<string, PropertyDescriptor | undefined>();
+  for (const [key, value] of Object.entries({
+    MutationObserver: env.window.MutationObserver, NodeFilter: env.window.NodeFilter,
+    HTMLInputElement: env.window.HTMLInputElement, Element: env.window.Element,
+    requestAnimationFrame: (callback: FrameRequestCallback) => setTimeout(() => callback(Date.now()), 0),
+    cancelAnimationFrame: clearTimeout,
+  })) {
+    previous.set(key, Object.getOwnPropertyDescriptor(globalThis, key));
+    Object.defineProperty(globalThis, key, { configurable: true, writable: true, value });
+  }
+  const { I18nProvider } = await import("../application/i18n/I18nProvider");
+  const { sftpTransferCenterStore: store } = await import("../application/state/sftpTransferCenterStore");
+  const { GlobalSftpTransferCenter } = await import("./GlobalSftpTransferCenter");
+  const { TooltipProvider } = await import("./ui/tooltip");
+  const renderer = await createDomRenderer(env.document);
+  t.after(async () => {
+    await renderer.unmount();
+    for (const [key, descriptor] of previous) {
+      if (descriptor) Object.defineProperty(globalThis, key, descriptor);
+      else Reflect.deleteProperty(globalThis, key);
+    }
+    env.cleanup();
+  });
+  const warning = "Upload completed; remove backup /remote/.netcatty-backup-file.bin manually.";
+  const base = {
+    fileName: "file.bin", sourcePath: "/local/file.bin", targetPath: "/remote/file.bin",
+    sourceConnectionId: "local", targetConnectionId: "remote", direction: "upload" as const,
+    status: "completed" as const, totalBytes: 10, transferredBytes: 10, speed: 0,
+    startTime: Date.now(), endTime: Date.now(), isDirectory: false,
+  };
+  store.publishOwner("cleanup-ui", [
+    { ...base, id: "warning-file", warning },
+    { ...base, id: "warning-folder", fileName: "folder", isDirectory: true },
+    { ...base, id: "warning-child", parentTaskId: "warning-folder", warning },
+  ]);
+  await renderer.render(<I18nProvider locale="en"><TooltipProvider><GlobalSftpTransferCenter /></TooltipProvider></I18nProvider>);
+  const click = async (selector: string) => {
+    const node = env.document.querySelector(selector);
+    assert.ok(node, selector);
+    await dispatchDomEvent(node, new env.window.MouseEvent("click", { bubbles: true }));
+    await flushEffects();
+  };
+  await click("[data-section=global-sftp-transfer-toggle]");
+  assert.match(env.document.body.textContent ?? "", /Backup cleanup warnings: 1/);
+  await click('button[aria-label="Show files"]');
+  const notices = env.document.querySelectorAll('[data-section="sftp-transfer-warning"]');
+  assert.equal(notices.length, 2);
+  for (const notice of notices) assert.equal(notice.textContent, warning);
+  assert.equal(env.document.querySelector('[data-transfer-status="failed"]'), null);
+  assert.equal(store.getTask("warning-child")?.status, "completed");
+  await click("[data-section=global-sftp-transfer-toggle]");
+});

components/GlobalSftpTransferCenter.tsx

@@ -37,6 +37,7 @@ import { cn } from "../lib/utils";
 import { Button } from "./ui/button";
 import { Popover, PopoverContent, PopoverTrigger } from "./ui/popover";
 import { Tooltip, TooltipContent, TooltipTrigger } from "./ui/tooltip";
+import { SftpTransferWarning } from "./sftp/SftpTransferWarning";
 
 /** Stable empty snapshot while the popover is closed — progress ticks must not
  * re-render TopTabs just to update hidden list rows. */
@@ -350,7 +351,9 @@ const TransferChildRow = React.memo(function TransferChildRow({ task: snapshotTa
     return (
       <div className="flex h-6 items-center gap-2 rounded px-1 text-[10px] hover:bg-muted/40" data-transfer-status={task.status}>
         <TruncatedTextWithTooltip text={task.fileName} tooltip={task.targetPath || task.fileName} className="flex-1 text-muted-foreground" />
-        <span className="shrink-0 font-mono text-muted-foreground">{detail}</span>
+        {task.status === "completed" && task.warning
+          ? <div className="min-w-0 flex-1"><SftpTransferWarning warning={task.warning} compact /></div>
+          : <span className="shrink-0 font-mono text-muted-foreground">{detail}</span>}
         {task.status === "transferring" && <Loader2 size={10} className="shrink-0 animate-spin text-primary" />}
       </div>
     );
@@ -658,6 +661,13 @@ function TransferRow({
         </span>
       </div>
 
+      {task.status === "completed" && task.warning && <div className="mt-1"><SftpTransferWarning warning={task.warning} /></div>}
+      {childTasks.some((child) => child.status === "completed" && !!child.warning) && (
+        <p className="mt-1 text-[10px] text-amber-600 dark:text-amber-400">
+          {t("sftp.transfers.cleanupWarnings", { count: childTasks.filter((child) => child.status === "completed" && !!child.warning).length })}
+        </p>
+      )}
+
       {/* Collapsed: show currently transferring child file(s) without expanding the whole tree. */}
       {isDirParent && !expanded && displayChildren.length > 0 && (
         <div

components/HistorySidePanel.tsx

@@ -270,8 +270,8 @@ const HistorySidePanelInner: React.FC<HistorySidePanelProps> = ({
     && state.entries.length === 0;
   const showNoGlobalHistory = scope === 'global' && globalEntries.length === 0;
 
-  if (!isVisible) return null;
-
+  // Stay mounted when the side panel parks this tree. Returning null here
+  // would remount the virtual list on every Notes <-> History switch.
   return (
     <div
       className="h-full flex flex-col bg-background overflow-hidden"
@@ -394,6 +394,7 @@ const HistorySidePanelInner: React.FC<HistorySidePanelProps> = ({
           <VariableSizeVirtualList
             ref={listRef}
             items={listRows}
+            measureEnabled={isVisible}
             getItemHeight={getRowHeight}
             getItemKey={(row, index) =>
               row.type === 'entry' ? row.entry.id : `detail-${row.entry.id}-${index}`}

components/SerialConnectModal.tsx

@@ -8,6 +8,7 @@ import { useI18n } from '../application/i18n/I18nProvider';
 import { useTerminalBackend } from '../application/state/useTerminalBackend';
 import type { Host, SerialConfig, SerialFlowControl, SerialParity } from '../domain/models';
 import { prepareSerialConfigForSavedHost } from '../domain/serialBackspace';
+import { isSerialEndpointPath, isWindowsNamedPipePath } from '../domain/serialEndpoint';
 import { cn } from '../lib/utils';
 import { Button } from './ui/button';
 import { Combobox, type ComboboxOption } from './ui/combobox';
@@ -111,7 +112,7 @@ export const SerialConnectModal: React.FC<SerialConnectModalProps> = ({
     if (!selectedPort) return;
 
     const config: SerialConfig = {
-      path: selectedPort,
+      path: selectedPort.trim(),
       baudRate,
       dataBits,
       stopBits,
@@ -129,7 +130,7 @@ export const SerialConnectModal: React.FC<SerialConnectModalProps> = ({
       const host: Host = {
         id: `serial-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`,
         label: configLabel.trim() || `Serial: ${portName}`,
-        hostname: selectedPort,
+        hostname: selectedPort.trim(),
         // For serial hosts, port field stores baud rate as a numeric identifier.
         // The full configuration is stored in serialConfig for actual connection.
         port: baudRate,
@@ -157,18 +158,15 @@ export const SerialConnectModal: React.FC<SerialConnectModalProps> = ({
     }));
   }, [ports]);
 
-  // Validate: port path must start with /dev/ (Unix/macOS) or COM/\\.\COM (Windows)
   const trimmedPort = selectedPort.trim();
-  const isPortValid =
-    trimmedPort.startsWith('/dev/') ||
-    /^COM\d+$/i.test(trimmedPort) ||
-    /^\\\\\.\\COM\d+$/i.test(trimmedPort);
+  const isNamedPipe = isWindowsNamedPipePath(trimmedPort);
+  const isPortValid = isSerialEndpointPath(trimmedPort);
   // Allow custom baud rates as long as they are positive integers
   const isBaudRateValid = Number.isInteger(baudRate) && baudRate > 0;
 
   // Check if using 1.5 stop bits (limited Windows support)
   const isStopBits15 = stopBits === 1.5;
-  const isValid = isPortValid && isBaudRateValid;
+  const isValid = isPortValid && (isNamedPipe || isBaudRateValid);
 
   return (
     <Dialog open={open} onOpenChange={(isOpen) => !isOpen && onClose()}>
@@ -212,6 +210,9 @@ export const SerialConnectModal: React.FC<SerialConnectModalProps> = ({
               icon={<Usb size={14} className="text-muted-foreground" />}
             />
 
+            <p className="text-xs text-muted-foreground">
+              {t('serial.field.namedPipeHint')}
+            </p>
             {!isPortValid && selectedPort && (
               <p className="text-xs text-destructive">
                 {t('serial.field.customPortPlaceholder')}
@@ -219,32 +220,34 @@ export const SerialConnectModal: React.FC<SerialConnectModalProps> = ({
             )}
           </div>
 
-          {/* Baud Rate */}
-          <div className="space-y-2">
-            <Label htmlFor="baud-rate">{t('serial.field.baudRate')}</Label>
-            <Combobox
-              options={BAUD_RATES.map((rate) => ({
-                value: String(rate),
-                label: String(rate),
-              }))}
-              value={String(baudRate)}
-              onValueChange={(val) => {
-                const parsed = parseInt(val, 10);
-                if (!isNaN(parsed) && parsed > 0) {
-                  setBaudRate(parsed);
-                }
-              }}
-              placeholder={t('serial.field.baudRatePlaceholder')}
-              emptyText={t('serial.field.baudRateEmpty')}
-              allowCreate
-              createText={t('common.use')}
-            />
-            {baudRate > 0 && !BAUD_RATES.includes(baudRate) && (
-              <p className="text-xs text-muted-foreground">
-                {t('serial.field.customBaudRate')}
-              </p>
-            )}
-          </div>
+          {/* Baud Rate (not used by named pipes) */}
+          {!isNamedPipe && (
+            <div className="space-y-2">
+              <Label htmlFor="baud-rate">{t('serial.field.baudRate')}</Label>
+              <Combobox
+                options={BAUD_RATES.map((rate) => ({
+                  value: String(rate),
+                  label: String(rate),
+                }))}
+                value={String(baudRate)}
+                onValueChange={(val) => {
+                  const parsed = parseInt(val, 10);
+                  if (!isNaN(parsed) && parsed > 0) {
+                    setBaudRate(parsed);
+                  }
+                }}
+                placeholder={t('serial.field.baudRatePlaceholder')}
+                emptyText={t('serial.field.baudRateEmpty')}
+                allowCreate
+                createText={t('common.use')}
+              />
+              {baudRate > 0 && !BAUD_RATES.includes(baudRate) && (
+                <p className="text-xs text-muted-foreground">
+                  {t('serial.field.customBaudRate')}
+                </p>
+              )}
+            </div>
+          )}
 
           {/* Advanced Options */}
           <Collapsible open={showAdvanced} onOpenChange={setShowAdvanced}>
@@ -264,92 +267,98 @@ export const SerialConnectModal: React.FC<SerialConnectModalProps> = ({
               </Button>
             </CollapsibleTrigger>
             <CollapsibleContent className="space-y-4 pt-2">
-              {/* Data Bits */}
-              <div className="grid grid-cols-2 gap-4">
+              {/* Hardware-only serial framing is not used by named pipes. */}
+              {!isNamedPipe && (
+                <>
+                {/* Data Bits */}
+                <div className="grid grid-cols-2 gap-4">
+                  <div className="space-y-2">
+                    <Label htmlFor="data-bits">{t('serial.field.dataBits')}</Label>
+                    <Select
+                      value={String(dataBits)}
+                      onValueChange={(v) => setDataBits(parseInt(v, 10) as 5 | 6 | 7 | 8)}
+                    >
+                      <SelectTrigger id="data-bits">
+                        <SelectValue />
+                      </SelectTrigger>
+                      <SelectContent>
+                        {DATA_BITS.map((bits) => (
+                          <SelectItem key={bits} value={String(bits)}>
+                            {bits}
+                          </SelectItem>
+                        ))}
+                      </SelectContent>
+                    </Select>
+                  </div>
+
+                  {/* Stop Bits */}
+                  <div className="space-y-2">
+                    <Label htmlFor="stop-bits">{t('serial.field.stopBits')}</Label>
+                    <Select
+                      value={String(stopBits)}
+                      onValueChange={(v) => setStopBits(parseFloat(v) as 1 | 1.5 | 2)}
+                    >
+                      <SelectTrigger id="stop-bits">
+                        <SelectValue />
+                      </SelectTrigger>
+                      <SelectContent>
+                        {STOP_BITS.map((bits) => (
+                          <SelectItem key={bits} value={String(bits)}>
+                            {bits}
+                          </SelectItem>
+                        ))}
+                      </SelectContent>
+                    </Select>
+                    {isStopBits15 && (
+                      <p className="text-xs text-yellow-500">
+                        {t('serial.field.stopBits15Warning')}
+                      </p>
+                    )}
+                  </div>
+                </div>
+
+                {/* Parity */}
                 <div className="space-y-2">
-                  <Label htmlFor="data-bits">{t('serial.field.dataBits')}</Label>
+                  <Label htmlFor="parity">{t('serial.field.parity')}</Label>
                   <Select
-                    value={String(dataBits)}
-                    onValueChange={(v) => setDataBits(parseInt(v, 10) as 5 | 6 | 7 | 8)}
+                    value={parity}
+                    onValueChange={(v) => setParity(v as SerialParity)}
                   >
-                    <SelectTrigger id="data-bits">
+                    <SelectTrigger id="parity">
                       <SelectValue />
                     </SelectTrigger>
                     <SelectContent>
-                      {DATA_BITS.map((bits) => (
-                        <SelectItem key={bits} value={String(bits)}>
-                          {bits}
+                      {PARITY_OPTIONS.map((option) => (
+                        <SelectItem key={option} value={option}>
+                          {t(`serial.parity.${option}`)}
                         </SelectItem>
                       ))}
                     </SelectContent>
                   </Select>
                 </div>
 
-                {/* Stop Bits */}
+                {/* Flow Control */}
                 <div className="space-y-2">
-                  <Label htmlFor="stop-bits">{t('serial.field.stopBits')}</Label>
+                  <Label htmlFor="flow-control">{t('serial.field.flowControl')}</Label>
                   <Select
-                    value={String(stopBits)}
-                    onValueChange={(v) => setStopBits(parseFloat(v) as 1 | 1.5 | 2)}
+                    value={flowControl}
+                    onValueChange={(v) => setFlowControl(v as SerialFlowControl)}
                   >
-                    <SelectTrigger id="stop-bits">
+                    <SelectTrigger id="flow-control">
                       <SelectValue />
                     </SelectTrigger>
                     <SelectContent>
-                      {STOP_BITS.map((bits) => (
-                        <SelectItem key={bits} value={String(bits)}>
-                          {bits}
+                      {FLOW_CONTROL_OPTIONS.map((option) => (
+                        <SelectItem key={option} value={option}>
+                          {t(`serial.flowControl.${option}`)}
                         </SelectItem>
                       ))}
                     </SelectContent>
                   </Select>
-                  {isStopBits15 && (
-                    <p className="text-xs text-yellow-500">
-                      {t('serial.field.stopBits15Warning')}
-                    </p>
-                  )}
                 </div>
-              </div>
 
-              {/* Parity */}
-              <div className="space-y-2">
-                <Label htmlFor="parity">{t('serial.field.parity')}</Label>
-                <Select
-                  value={parity}
-                  onValueChange={(v) => setParity(v as SerialParity)}
-                >
-                  <SelectTrigger id="parity">
-                    <SelectValue />
-                  </SelectTrigger>
-                  <SelectContent>
-                    {PARITY_OPTIONS.map((option) => (
-                      <SelectItem key={option} value={option}>
-                        {t(`serial.parity.${option}`)}
-                      </SelectItem>
-                    ))}
-                  </SelectContent>
-                </Select>
-              </div>
-
-              {/* Flow Control */}
-              <div className="space-y-2">
-                <Label htmlFor="flow-control">{t('serial.field.flowControl')}</Label>
-                <Select
-                  value={flowControl}
-                  onValueChange={(v) => setFlowControl(v as SerialFlowControl)}
-                >
-                  <SelectTrigger id="flow-control">
-                    <SelectValue />
-                  </SelectTrigger>
-                  <SelectContent>
-                    {FLOW_CONTROL_OPTIONS.map((option) => (
-                      <SelectItem key={option} value={option}>
-                        {t(`serial.flowControl.${option}`)}
-                      </SelectItem>
-                    ))}
-                  </SelectContent>
-                </Select>
-              </div>
+                </>
+              )}
 
               {/* Terminal Options */}
               <div className="space-y-3 pt-2 border-t border-border/60">

components/SerialHostDetailsPanel.test.tsx

@@ -0,0 +1,34 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import React from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
+import { I18nProvider } from '../application/i18n/I18nProvider';
+import type { Host } from '../domain/models';
+import { SerialHostDetailsPanel } from './SerialHostDetailsPanel';
+
+function renderPanel(path: string, hostname = path) {
+  const host: Host = {
+    id: 'serial-test', label: 'VM console', hostname, protocol: 'serial',
+    port: 115200, username: '', tags: [], os: 'linux',
+    serialConfig: { path, baudRate: 115200, dataBits: 8, stopBits: 1, parity: 'none', flowControl: 'none' },
+  };
+  return renderToStaticMarkup(<I18nProvider locale="en"><SerialHostDetailsPanel
+    initialData={host} onSave={() => {}} onCancel={() => {}}
+  /></I18nProvider>);
+}
+
+test('saved named-pipe host is editable without hardware baud controls', () => {
+  const html = renderPanel(String.raw`\\.\pipe\vm-console`);
+  assert.match(html, /VM must create the pipe as a server/);
+  assert.doesNotMatch(html, /for="baud-rate"/);
+  assert.doesNotMatch(html, /text-destructive/);
+});
+
+test('hardware serial host retains its baud-rate controls', () => {
+  assert.match(renderPanel('COM3'), /for="baud-rate"/);
+});
+
+test('editor prefers the stored pipe path over a stale hardware hostname', () => {
+  const html = renderPanel(String.raw`\\.\pipe\VM console`, 'COM3');
+  assert.doesNotMatch(html, /for="baud-rate"/);
+});

components/SerialHostDetailsPanel.tsx

@@ -12,6 +12,8 @@ import {
   resolveSerialBackspaceOverrideOnSave,
 } from '../domain/serialBackspace';
 
+import { isSerialEndpointPath, isWindowsNamedPipePath } from '../domain/serialEndpoint';
+
 import { Button } from './ui/button';
 import { Combobox, ComboboxOption, MultiCombobox } from './ui/combobox';
 import { Input } from './ui/input';
@@ -91,7 +93,7 @@ export const SerialHostDetailsPanel: React.FC<SerialHostDetailsPanelPropsWithRes
   // input alone cannot restore `password` to undefined — the user needs a
   // dedicated control to delete the credential entirely.
   const [passwordCleared, setPasswordCleared] = useState(false);
-  const [selectedPort, setSelectedPort] = useState(initialData.hostname || initialData.serialConfig?.path || '');
+  const [selectedPort, setSelectedPort] = useState(initialData.serialConfig?.path || initialData.hostname || '');
   const [baudRate, setBaudRate] = useState(initialData.serialConfig?.baudRate || initialData.port || 115200);
   const [dataBits, setDataBits] = useState<5 | 6 | 7 | 8>(initialData.serialConfig?.dataBits || 8);
   const [stopBits, setStopBits] = useState<1 | 1.5 | 2>(initialData.serialConfig?.stopBits || 1);
@@ -131,7 +133,7 @@ export const SerialHostDetailsPanel: React.FC<SerialHostDetailsPanelPropsWithRes
     if (!selectedPort) return;
 
     const config: SerialConfig = {
-      path: selectedPort,
+      path: selectedPort.trim(),
       baudRate,
       dataBits,
       stopBits,
@@ -151,7 +153,7 @@ export const SerialHostDetailsPanel: React.FC<SerialHostDetailsPanelPropsWithRes
     const updatedHost: Host = {
       ...initialData,
       label: label.trim() || `Serial: ${portName}`,
-      hostname: selectedPort,
+      hostname: selectedPort.trim(),
       port: baudRate,
       username: username.trim() || undefined,
       // An empty password is meaningful for serial auto-login: the detector
@@ -206,12 +208,10 @@ export const SerialHostDetailsPanel: React.FC<SerialHostDetailsPanelPropsWithRes
 
   // Validation
   const trimmedPort = selectedPort.trim();
-  const isPortValid =
-    trimmedPort.startsWith('/dev/') ||
-    /^COM\d+$/i.test(trimmedPort) ||
-    /^\\\\\.\\COM\d+$/i.test(trimmedPort);
+  const isNamedPipe = isWindowsNamedPipePath(trimmedPort);
+  const isPortValid = isSerialEndpointPath(trimmedPort);
   const isBaudRateValid = Number.isInteger(baudRate) && baudRate > 0;
-  const isValid = isPortValid && isBaudRateValid;
+  const isValid = isPortValid && (isNamedPipe || isBaudRateValid);
 
   // Check if using 1.5 stop bits (limited Windows support)
   const isStopBits15 = stopBits === 1.5;
@@ -265,6 +265,9 @@ export const SerialHostDetailsPanel: React.FC<SerialHostDetailsPanelPropsWithRes
             createText={t('common.use')}
             icon={<Usb size={14} className="text-muted-foreground" />}
           />
+          <p className="text-xs text-muted-foreground">
+            {t('serial.field.namedPipeHint')}
+          </p>
           {!isPortValid && selectedPort && (
             <p className="text-xs text-destructive">
               {t('serial.field.customPortPlaceholder')}
@@ -272,32 +275,34 @@ export const SerialHostDetailsPanel: React.FC<SerialHostDetailsPanelPropsWithRes
           )}
         </div>
 
-        {/* Baud Rate */}
-        <div className="space-y-2">
-          <Label htmlFor="baud-rate">{t('serial.field.baudRate')}</Label>
-          <Combobox
-            options={BAUD_RATES.map((rate) => ({
-              value: String(rate),
-              label: String(rate),
-            }))}
-            value={String(baudRate)}
-            onValueChange={(val) => {
-              const parsed = parseInt(val, 10);
-              if (!isNaN(parsed) && parsed > 0) {
-                setBaudRate(parsed);
-              }
-            }}
-            placeholder={t('serial.field.baudRatePlaceholder')}
-            emptyText={t('serial.field.baudRateEmpty')}
-            allowCreate
-            createText={t('common.use')}
-          />
-          {baudRate > 0 && !BAUD_RATES.includes(baudRate) && (
-            <p className="text-xs text-muted-foreground">
-              {t('serial.field.customBaudRate')}
-            </p>
-          )}
-        </div>
+        {/* Baud Rate (not used by named pipes) */}
+        {!isNamedPipe && (
+          <div className="space-y-2">
+            <Label htmlFor="baud-rate">{t('serial.field.baudRate')}</Label>
+            <Combobox
+              options={BAUD_RATES.map((rate) => ({
+                value: String(rate),
+                label: String(rate),
+              }))}
+              value={String(baudRate)}
+              onValueChange={(val) => {
+                const parsed = parseInt(val, 10);
+                if (!isNaN(parsed) && parsed > 0) {
+                  setBaudRate(parsed);
+                }
+              }}
+              placeholder={t('serial.field.baudRatePlaceholder')}
+              emptyText={t('serial.field.baudRateEmpty')}
+              allowCreate
+              createText={t('common.use')}
+            />
+            {baudRate > 0 && !BAUD_RATES.includes(baudRate) && (
+              <p className="text-xs text-muted-foreground">
+                {t('serial.field.customBaudRate')}
+              </p>
+            )}
+          </div>
+        )}
 
         {/* Login credentials (auto-login) */}
         <div className="space-y-2">
@@ -408,92 +413,98 @@ export const SerialHostDetailsPanel: React.FC<SerialHostDetailsPanelPropsWithRes
             </Button>
           </CollapsibleTrigger>
           <CollapsibleContent className="space-y-4 pt-2">
-            {/* Data Bits */}
-            <div className="grid grid-cols-2 gap-4">
+            {/* Hardware-only serial framing is not used by named pipes. */}
+            {!isNamedPipe && (
+              <>
+              {/* Data Bits */}
+              <div className="grid grid-cols-2 gap-4">
+                <div className="space-y-2">
+                  <Label htmlFor="data-bits">{t('serial.field.dataBits')}</Label>
+                  <Select
+                    value={String(dataBits)}
+                    onValueChange={(v) => setDataBits(parseInt(v, 10) as 5 | 6 | 7 | 8)}
+                  >
+                    <SelectTrigger id="data-bits">
+                      <SelectValue />
+                    </SelectTrigger>
+                    <SelectContent>
+                      {DATA_BITS.map((bits) => (
+                        <SelectItem key={bits} value={String(bits)}>
+                          {bits}
+                        </SelectItem>
+                      ))}
+                    </SelectContent>
+                  </Select>
+                </div>
+
+                {/* Stop Bits */}
+                <div className="space-y-2">
+                  <Label htmlFor="stop-bits">{t('serial.field.stopBits')}</Label>
+                  <Select
+                    value={String(stopBits)}
+                    onValueChange={(v) => setStopBits(parseFloat(v) as 1 | 1.5 | 2)}
+                  >
+                    <SelectTrigger id="stop-bits">
+                      <SelectValue />
+                    </SelectTrigger>
+                    <SelectContent>
+                      {STOP_BITS.map((bits) => (
+                        <SelectItem key={bits} value={String(bits)}>
+                          {bits}
+                        </SelectItem>
+                      ))}
+                    </SelectContent>
+                  </Select>
+                  {isStopBits15 && (
+                    <p className="text-xs text-yellow-500">
+                      {t('serial.field.stopBits15Warning')}
+                    </p>
+                  )}
+                </div>
+              </div>
+
+              {/* Parity */}
               <div className="space-y-2">
-                <Label htmlFor="data-bits">{t('serial.field.dataBits')}</Label>
+                <Label htmlFor="parity">{t('serial.field.parity')}</Label>
                 <Select
-                  value={String(dataBits)}
-                  onValueChange={(v) => setDataBits(parseInt(v, 10) as 5 | 6 | 7 | 8)}
+                  value={parity}
+                  onValueChange={(v) => setParity(v as SerialParity)}
                 >
-                  <SelectTrigger id="data-bits">
+                  <SelectTrigger id="parity">
                     <SelectValue />
                   </SelectTrigger>
                   <SelectContent>
-                    {DATA_BITS.map((bits) => (
-                      <SelectItem key={bits} value={String(bits)}>
-                        {bits}
+                    {PARITY_OPTIONS.map((option) => (
+                      <SelectItem key={option} value={option}>
+                        {t(`serial.parity.${option}`)}
                       </SelectItem>
                     ))}
                   </SelectContent>
                 </Select>
               </div>
 
-              {/* Stop Bits */}
+              {/* Flow Control */}
               <div className="space-y-2">
-                <Label htmlFor="stop-bits">{t('serial.field.stopBits')}</Label>
+                <Label htmlFor="flow-control">{t('serial.field.flowControl')}</Label>
                 <Select
-                  value={String(stopBits)}
-                  onValueChange={(v) => setStopBits(parseFloat(v) as 1 | 1.5 | 2)}
+                  value={flowControl}
+                  onValueChange={(v) => setFlowControl(v as SerialFlowControl)}
                 >
-                  <SelectTrigger id="stop-bits">
+                  <SelectTrigger id="flow-control">
                     <SelectValue />
                   </SelectTrigger>
                   <SelectContent>
-                    {STOP_BITS.map((bits) => (
-                      <SelectItem key={bits} value={String(bits)}>
-                        {bits}
+                    {FLOW_CONTROL_OPTIONS.map((option) => (
+                      <SelectItem key={option} value={option}>
+                        {t(`serial.flowControl.${option}`)}
                       </SelectItem>
                     ))}
                   </SelectContent>
                 </Select>
-                {isStopBits15 && (
-                  <p className="text-xs text-yellow-500">
-                    {t('serial.field.stopBits15Warning')}
-                  </p>
-                )}
               </div>
-            </div>
 
-            {/* Parity */}
-            <div className="space-y-2">
-              <Label htmlFor="parity">{t('serial.field.parity')}</Label>
-              <Select
-                value={parity}
-                onValueChange={(v) => setParity(v as SerialParity)}
-              >
-                <SelectTrigger id="parity">
-                  <SelectValue />
-                </SelectTrigger>
-                <SelectContent>
-                  {PARITY_OPTIONS.map((option) => (
-                    <SelectItem key={option} value={option}>
-                      {t(`serial.parity.${option}`)}
-                    </SelectItem>
-                  ))}
-                </SelectContent>
-              </Select>
-            </div>
-
-            {/* Flow Control */}
-            <div className="space-y-2">
-              <Label htmlFor="flow-control">{t('serial.field.flowControl')}</Label>
-              <Select
-                value={flowControl}
-                onValueChange={(v) => setFlowControl(v as SerialFlowControl)}
-              >
-                <SelectTrigger id="flow-control">
-                  <SelectValue />
-                </SelectTrigger>
-                <SelectContent>
-                  {FLOW_CONTROL_OPTIONS.map((option) => (
-                    <SelectItem key={option} value={option}>
-                      {t(`serial.flowControl.${option}`)}
-                    </SelectItem>
-                  ))}
-                </SelectContent>
-              </Select>
-            </div>
+              </>
+            )}
 
             {/* Terminal Options */}
             <div className="space-y-3 pt-2 border-t border-border/60">

components/SftpSidePanel.tsx

@@ -265,9 +265,10 @@ const SftpSidePanelInner: React.FC<SftpSidePanelProps> = ({
   }, [activeHost, activeSessionId, resolveTransferSourceSessionId, sessions]);
 
   const fileWatchHandlers = useMemo(() => ({
-    onFileWatchSynced: (payload: { remotePath: string }) => {
+    onFileWatchSynced: (payload: { remotePath: string; warning?: string }) => {
       const fileName = payload.remotePath.split('/').pop() || payload.remotePath;
-      toast.success(t('sftp.autoSync.success', { fileName }));
+      if (payload.warning) toast.warning(payload.warning);
+      else toast.success(t('sftp.autoSync.success', { fileName }));
       logger.info("[SFTP] File auto-synced to remote", payload);
     },
     onFileWatchError: (payload: { error: string }) => {

components/SftpTransferItem.test.tsx

@@ -52,6 +52,27 @@ test("renders failed transfer actions with custom tooltips and readable labels",
   assert.match(markup, /focus-visible:ring-1/);
 });
 
+for (const isChild of [false, true]) {
+  test(`completed ${isChild ? "child" : "file"} shows the cleanup path without a retry action`, () => {
+    const warning = "Upload completed; remove backup /remote/.netcatty-backup-archive.tar.gz manually.";
+    const markup = renderTransferItem({
+      ...baseTask, status: "completed", error: undefined, warning, transferredBytes: 1024,
+    }, { isChild });
+    assert.match(markup, /data-transfer-status="completed"/);
+    assert.match(markup, /data-section="sftp-transfer-warning"/);
+    assert.ok(markup.includes(warning));
+    assert.doesNotMatch(markup, /aria-label="Retry:/);
+    assert.doesNotMatch(markup, /text-destructive/);
+  });
+}
+
+test("folder rows disclose retained child cleanup warnings", () => {
+  const markup = renderTransferItem({ ...baseTask, status: "completed", error: undefined, isDirectory: true }, {
+    childWarningCount: 2, canToggleChildren: true, onToggleChildren: () => {},
+  });
+  assert.match(markup, /Backup cleanup warnings: 2/);
+});
+
 test("renders active transfer cancel action with an item-specific label", () => {
   const markup = renderTransferItem({
     ...baseTask,

components/SftpView.tsx

@@ -119,9 +119,10 @@ const SftpViewInner: React.FC<SftpViewProps> = ({
 
   // File watch event handlers (stable refs to avoid re-creating the useSftpState options)
   const fileWatchHandlers = useMemo(() => ({
-    onFileWatchSynced: (payload: { remotePath: string }) => {
+    onFileWatchSynced: (payload: { remotePath: string; warning?: string }) => {
       const fileName = payload.remotePath.split('/').pop() || payload.remotePath;
-      toast.success(t('sftp.autoSync.success', { fileName }));
+      if (payload.warning) toast.warning(payload.warning);
+      else toast.success(t('sftp.autoSync.success', { fileName }));
       logger.info("[SFTP] File auto-synced to remote", payload);
     },
     onFileWatchError: (payload: { error: string }) => {

components/Terminal.tsx

@@ -243,6 +243,7 @@ import {
 import {
   canHibernateTerminalRuntimeSession,
   canHibernateTerminalRuntimeStatus,
+  decideHiddenTabKeepCountAction,
   isTerminalFileTransferActive,
   resolveHibernateKeepRendererCount,
   resolveHibernatePreferWasmSerialize,
@@ -254,6 +255,7 @@ import {
 } from "../domain/terminalHibernate";
 import { getLastChar, removeLastChar } from "../domain/serialCharMetrics";
 import { stringCellWidth } from "./terminal/autocomplete/terminalStringCellWidth";
+import { retainLeavingTabAfterEviction } from "../application/state/hiddenTabEviction";
 import { terminalHiddenRendererStore } from "../application/state/terminalHiddenRendererStore";
 import {
   wakeTerminalFromHibernate,
@@ -522,6 +524,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
   const hibernateAlternateScreenRef = useRef(false);
   const hibernateRetryTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const fullHibernateRuntimeRef = useRef<(() => Promise<boolean>) | null>(null);
+  const hibernateEvictionAttemptRef = useRef(0);
   const wakeSoftHiddenRuntimeRef = useRef<(() => void) | null>(null);
   const resumeRendererAfterCancelledHibernateUpgradeRef = useRef<(() => void) | null>(null);
   const wakeInProgressRef = useRef(false);
@@ -1618,7 +1621,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
     const capturedData = options?.finalized
       ? data
       : (finalizeTerminalLogData() || data);
-    captureHandler(capturedSessionId, capturedData);
+    return captureHandler(capturedSessionId, capturedData);
   }, [finalizeTerminalLogData]);
 
   const attachHomeWebContentsIdRef = useRef<number | null | undefined>(undefined);
@@ -1796,6 +1799,14 @@ const TerminalComponent: React.FC<TerminalProps> = ({
 
     if (!closingSessionId) {
       disposeSessionListeners();
+      // Close preparation already cleared sessionRef after the display handoff.
+      // Unmount teardown calls cleanup again. An attach popup must not
+      // closeSession on that second pass: worker mode emits netcatty:exit to
+      // the home renderer before the boot-epoch check, which drops home input
+      // (sessionRef = null) while a mismatched epoch leaves the PTY alive.
+      if (attachExistingSession) {
+        return;
+      }
       // Still notify main so in-flight SSH passphrase prompts for this UI
       // sessionId are aborted even before a backend session was attached.
       try {
@@ -1965,10 +1976,11 @@ const TerminalComponent: React.FC<TerminalProps> = ({
   }, [sessionId]);
 
   const forceCloseHibernatedSession = useCallback(() => {
+    let pendingCapture: void | Promise<void>;
     if (!terminalDataCapturedRef.current) {
       const hibernatedData = hibernateSnapshotRef.current + hibernatePendingBufferRef.current;
       if (hibernatedData) {
-        handleTerminalDataCaptureOnce(sessionId, hibernatedData);
+        pendingCapture = handleTerminalDataCaptureOnce(sessionId, hibernatedData);
       }
     }
     disposeDataRef.current?.();
@@ -2011,6 +2023,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
     }
     sessionRef.current = null;
     clearHibernateRuntimeState();
+    return pendingCapture;
   }, [attachAuthorization, attachExistingSession, clearHibernateRuntimeState, handleTerminalDataCaptureOnce, sessionId, terminalBackend]);
 
   const observeTerminalInputPrompt = useCallback((
@@ -2287,20 +2300,6 @@ const TerminalComponent: React.FC<TerminalProps> = ({
   ]);
   fullHibernateRuntimeRef.current = fullHibernateRuntime;
 
-  const upgradeSoftHiddenRuntimeToHibernate = useCallback(() => {
-    if (!wakeSoftHiddenRuntimeRef.current) return;
-    wakeSoftHiddenRuntimeRef.current?.();
-    void fullHibernateRuntime().then(
-      (completed) => {
-        if (!completed) resumeRendererAfterCancelledHibernateUpgradeRef.current?.();
-      },
-      (error) => {
-        logger.error("[Terminal] Failed to upgrade soft-hidden runtime to hibernate", { sessionId, error });
-        resumeRendererAfterCancelledHibernateUpgradeRef.current?.();
-      },
-    );
-  }, [fullHibernateRuntime, sessionId]);
-
   const hideRuntimeOnly = useCallback(() => {
     if (hibernatedRef.current || softHiddenRef.current || !hasRuntimeRef.current) return;
     xtermRuntimeRef.current?.suspendWebglRenderer();
@@ -2309,6 +2308,39 @@ const TerminalComponent: React.FC<TerminalProps> = ({
     logger.info("[Terminal] Soft-hidden runtime", { sessionId });
   }, [sessionId]);
 
+  const upgradeSoftHiddenRuntimeToHibernate = useCallback(() => {
+    const pendingEviction = terminalHiddenRendererStore.hasPendingEviction(sessionId);
+    if (!wakeSoftHiddenRuntimeRef.current) {
+      terminalHiddenRendererStore.settleEviction(sessionId, false);
+      return;
+    }
+    wakeSoftHiddenRuntimeRef.current?.();
+    void fullHibernateRuntime().then(
+      (completed) => {
+        if (!completed) {
+          resumeRendererAfterCancelledHibernateUpgradeRef.current?.();
+          // Wake already dropped the marker. Restore the soft-hidden slot only
+          // while this tab is still hidden and hibernate is still enabled.
+          // Selecting the victim during the drain makes fullHibernateRuntime
+          // return false because the tab is visible; soft-hiding it again
+          // would hide the tab the user just opened.
+          if (pendingEviction && !isVisibleRef.current && hibernateEnabledRef.current) {
+            hideRuntimeOnly();
+          }
+        }
+        terminalHiddenRendererStore.settleEviction(sessionId, completed);
+      },
+      (error) => {
+        logger.error("[Terminal] Failed to upgrade soft-hidden runtime to hibernate", { sessionId, error });
+        resumeRendererAfterCancelledHibernateUpgradeRef.current?.();
+        if (pendingEviction && !isVisibleRef.current && hibernateEnabledRef.current) {
+          hideRuntimeOnly();
+        }
+        terminalHiddenRendererStore.settleEviction(sessionId, false);
+      },
+    );
+  }, [fullHibernateRuntime, hideRuntimeOnly, sessionId]);
+
   const hibernateRuntime = useCallback(() => {
     if (hibernatedRef.current || !termRef.current) return;
 
@@ -2323,8 +2355,14 @@ const TerminalComponent: React.FC<TerminalProps> = ({
       return;
     }
 
+    // Disconnected sessions never stay soft-hidden. A connected session whose
+    // keep count dropped to zero takes the same upgrade. A positive count stays
+    // retained until a later leave evicts overflow.
     if (softHiddenRef.current) {
-      if (statusRef.current === "disconnected") {
+      const retainedKeepCount = statusRef.current === "connected"
+        ? resolveHibernateKeepRendererCount(terminalSettingsRef.current)
+        : 0;
+      if (statusRef.current === "disconnected" || !(retainedKeepCount > 0)) {
         upgradeSoftHiddenRuntimeToHibernate();
       }
       return;
@@ -2333,16 +2371,47 @@ const TerminalComponent: React.FC<TerminalProps> = ({
     const keepCount = statusRef.current === "connected"
       ? resolveHibernateKeepRendererCount(terminalSettings)
       : 0;
-    if (keepCount > 0 && terminalHiddenRendererStore.getSoftHiddenCount() < keepCount) {
+    const keepDecision = decideHiddenTabKeepCountAction({
+      keepCount,
+      softHiddenCount: terminalHiddenRendererStore.getSoftHiddenOccupancy(),
+      sessionId,
+      candidatesOldestFirst: keepCount > 0
+        ? terminalHiddenRendererStore.listSoftHiddenOldestFirst()
+        : [],
+    });
+    if (keepDecision.action === "soft-hide") {
       hideRuntimeOnly();
       return;
     }
-
-    if (keepCount > 0) {
-      const victim = terminalHiddenRendererStore.pickEvictionCandidate(keepCount);
-      if (victim && victim !== sessionId) {
-        terminalHiddenRendererStore.requestEviction(victim);
-      }
+    if (keepDecision.action === "await-eviction") {
+      const attempt = ++hibernateEvictionAttemptRef.current;
+      // Reserves this tab's slot before the first await, then soft-hides only
+      // if a victim hibernate completes and the slot still fits. A sync marker
+      // clear is not enough: alt-screen and drain/snapshot failure restore the
+      // victim, and this tab stays out of the soft-hidden set.
+      void retainLeavingTabAfterEviction({
+        sessionId,
+        candidates: keepDecision.candidates,
+        keepCount,
+        // Re-read after the victim drain. The count above was captured when
+        // this timer fired; a zero or tighter setting must full-hibernate.
+        resolveKeepCount: () => (
+          statusRef.current === "connected"
+            ? resolveHibernateKeepRendererCount(terminalSettingsRef.current)
+            : 0
+        ),
+        stillWantsRetention: () => (
+          hibernateEvictionAttemptRef.current === attempt
+          && !isVisibleRef.current
+          && !hibernatedRef.current
+          && !softHiddenRef.current
+        ),
+        softHide: () => hideRuntimeOnly(),
+        fullHibernate: () => {
+          void fullHibernateRuntime();
+        },
+      });
+      return;
     }
 
     void fullHibernateRuntime();
@@ -4700,6 +4769,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
     isSearchOpen,
     hibernateEnabled: hibernateEnabled,
     hibernateDelayMs: resolveTerminalHibernateDelayMs(terminalSettings),
+    hibernateKeepRendererCount: resolveHibernateKeepRendererCount(terminalSettings),
     fileTransferActive: hibernateFileTransferActive,
     hibernatedRef,
     softHiddenRef,
@@ -4721,7 +4791,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
 
   return (
     <>
-      <TerminalView ctx={{ Activity, ArrowDownToLine, ArrowUpFromLine, Button, Clock3, Copy, Cpu, HardDrive, HoverCard, HoverCardContent, HoverCardTrigger, Maximize2, MemoryStick, Radio, RefreshCcw, Sparkles, SquareArrowOutUpRight, Unplug, TerminalAutocomplete, TerminalComposeBar, TerminalConnectionDialog, TerminalContextMenu, TerminalSearchBar, Tooltip, TooltipContent, TooltipTrigger, ZmodemOverwriteDialog, ZmodemProgressIndicator, auth, autocompleteAcceptTextRef, autocompleteCloseRef, autocompleteHostOs, autocompleteInputRef, autocompleteKeyEventRef, autocompleteRepositionRef, autocompleteSettings, canUpdateHost: !!onUpdateHost, chainProgress, cn, compactToolbar, lineTimestampsAvailable, containerRef, effectiveFontSize, effectiveFontWeight, effectiveTheme, error, executeSnippet, executeSnippetCommand, handleAddSelectionToAI: onAddSelectionToAI ? handleAddSelectionToAI : undefined, handleCancelConnect, handleCloseDisconnectedSession, handleCloseSearch, handleDisconnect: (attachExistingSession || compactToolbar) ? undefined : handleDisconnect, handleDismissDisconnectedDialog, handleDragEnter, handleDragLeave, handleDragOver, handleDrop, handleFindNext, handleFindPrevious, handleHostKeyAddAndContinue, handleHostKeyClose, handleHostKeyContinue, handleOpenHostBrowser, handleOsc52ReadResponse, handleOsc7SetupConfirm, handleOsc7SetupOpenChange, handleReceiveYmodem, handleRetry, handleSearch, handleSendYmodem, handleTopOverlayMouseDownCapture, hasMouseTracking, host, hotkeyScheme, inWorkspace, isBroadcastEnabled, composeSendToAll, onToggleComposeSendTarget, isCancelling, isComposeBarOpen: effectiveComposeBarOpen, isConnectionAwaitingUserInput, isDraggingOver, isFocusMode, isFocusedPane, isLocalConnection, remoteDragDropUsesZmodem, isPluginTerminalProviderAvailable, isReconnectActive, isSerialConnection, isSearchOpen, isSupportedOs, isSystemSidebarEligible, isVisible, keyBindings, keys, identities, knownCwdRef, needsHostKeyVerification, onAddSelectionToAI, onBroadcastInput, onCloseSession, onDetach, onDetachDragEnd, onDetachDragStart, onDetachPointerDown, onEndSessionDrag, onExpandToFocus, onTogglePaneMagnification, onOpenSystem, onRename, onSplitHorizontal, onSplitVertical, onStartSessionDrag, onToggleBroadcast, onUpdateHost: handleUpdateHostFromTerminal, osc52ReadPromptVisible, osc7SetupOpen, osc7SetupRunning, passwordPromptActiveRef, pendingHostKeyInfo, progressLogs, progressValue, renderControls, resolvedFontFamily, restoreState, scrollToBottomAfterProgrammaticInput, searchMatchCount, searchFocusToken, scriptExecutionOverlay: activeScriptRun ? (
+      <TerminalView ctx={{ Activity, ArrowDownToLine, ArrowUpFromLine, Button, Clock3, Copy, Cpu, HardDrive, HoverCard, HoverCardContent, HoverCardTrigger, Maximize2, MemoryStick, Radio, RefreshCcw, Sparkles, SquareArrowOutUpRight, Unplug, TerminalAutocomplete, TerminalComposeBar, TerminalConnectionDialog, TerminalContextMenu, TerminalSearchBar, Tooltip, TooltipContent, TooltipTrigger, ZmodemOverwriteDialog, ZmodemProgressIndicator, auth, autocompleteAcceptTextRef, autocompleteCloseRef, autocompleteHostOs, autocompleteInputRef, autocompleteKeyEventRef, autocompleteRepositionRef, autocompleteSettings, canUpdateHost: !!onUpdateHost, chainProgress, cn, compactToolbar, lineTimestampsAvailable, containerRef, effectiveFontSize, effectiveFontWeight, effectiveTheme, error, executeSnippet, executeSnippetCommand, handleAddSelectionToAI: onAddSelectionToAI ? handleAddSelectionToAI : undefined, handleCancelConnect, handleCloseDisconnectedSession, handleCloseSearch, handleDisconnect: (attachExistingSession || compactToolbar) ? undefined : handleDisconnect, handleDismissDisconnectedDialog, handleDragEnter, handleDragLeave, handleDragOver, handleDrop, handleFindNext, handleFindPrevious, handleHostKeyAddAndContinue, handleHostKeyClose, handleHostKeyContinue, handleOpenHostBrowser, handleOpenSFTP, handleOsc52ReadResponse, handleOsc7SetupConfirm, handleOsc7SetupOpenChange, handleReceiveYmodem, handleRetry, handleSearch, handleSendYmodem, handleTopOverlayMouseDownCapture, hasMouseTracking, host, hotkeyScheme, inWorkspace, isBroadcastEnabled, composeSendToAll, onToggleComposeSendTarget, isCancelling, isComposeBarOpen: effectiveComposeBarOpen, isConnectionAwaitingUserInput, isDraggingOver, isFocusMode, isFocusedPane, isLocalConnection, remoteDragDropUsesZmodem, isPluginTerminalProviderAvailable, isReconnectActive, isSerialConnection, isSearchOpen, isSupportedOs, isSystemSidebarEligible, isVisible, keyBindings, keys, identities, knownCwdRef, needsHostKeyVerification, onAddSelectionToAI, onBroadcastInput, onCloseSession, onDetach, onDetachDragEnd, onDetachDragStart, onDetachPointerDown, onEndSessionDrag, onExpandToFocus, onTogglePaneMagnification, onOpenSystem, onRename, onSplitHorizontal, onSplitVertical, onStartSessionDrag, onToggleBroadcast, onUpdateHost: handleUpdateHostFromTerminal, osc52ReadPromptVisible, osc7SetupOpen, osc7SetupRunning, passwordPromptActiveRef, pendingHostKeyInfo, progressLogs, progressValue, renderControls, resolvedFontFamily, restoreState, scrollToBottomAfterProgrammaticInput, searchMatchCount, searchFocusToken, scriptExecutionOverlay: activeScriptRun ? (
         <ScriptExecutionOverlay
           run={activeScriptRun}
           onPause={() => { void pauseScriptRun(activeScriptRun.runId); }}

components/TerminalLayer.tsx

@@ -319,6 +319,7 @@ const TerminalLayerInner: React.FC<TerminalLayerProps> = ({
     splitPane: splitSidePanelPaneForTab,
     closePane: closeSidePanelPaneForTab,
     resizeSplit: resizeSidePanelSplitForTab,
+    selectSidePanelToolForTab,
   } = useTerminalSidePanelLayoutState();
   useEffect(() => {
     pruneComposeBarHistory(sessions.map((session) => session.id));
@@ -704,7 +705,7 @@ const TerminalLayerInner: React.FC<TerminalLayerProps> = ({
   }, [onAddKnownHost]);
 
   const handleTerminalDataCapture = useCallback((sessionId: string, data: string) => {
-    onTerminalDataCapture?.(sessionId, data);
+    return onTerminalDataCapture?.(sessionId, data);
   }, [onTerminalDataCapture]);
 
   // Terminal backend for broadcast writes
@@ -1752,13 +1753,9 @@ const TerminalLayerInner: React.FC<TerminalLayerProps> = ({
     if (!prepareSidePanelTool(tabId, tab)) return;
 
     startTransition(() => {
-      setSidePanelOpenTabs(prev => {
-        const next = new Map(prev);
-        next.set(tabId, tab);
-        return next;
-      });
+      selectSidePanelToolForTab(tabId, tab);
     });
-  }, [prepareSidePanelTool, setSidePanelOpenTabs, sidePanelOpenTabsRef]);
+  }, [prepareSidePanelTool, selectSidePanelToolForTab, sidePanelOpenTabsRef]);
 
   const handleFocusSidePanelPane = useCallback((paneId: string) => {
     const tabId = activeTabIdRef.current;

components/TopTabs.test.ts

@@ -281,6 +281,75 @@ test("duplicate double-click behavior falls back to copying when unavailable", (
   assert.deepEqual(copiedSessionIds, ["session-1"]);
 });
 
+test("draggable top-tab close buttons cancel the drag gesture on mousedown", () => {
+  const closeButtonLabels = [
+    "tabs.closePluginViewAria",
+    "Close editor tab",
+    "tabs.closeSessionAria",
+    "tabs.closeLogViewAria",
+  ];
+
+  for (const label of closeButtonLabels) {
+    const labelIndex = topTabItemsSource.indexOf(label);
+    assert.notEqual(labelIndex, -1, `missing close label ${label}`);
+    const buttonStart = topTabItemsSource.lastIndexOf("<button", labelIndex);
+    const buttonEnd = topTabItemsSource.indexOf(">", labelIndex);
+    const openingTag = topTabItemsSource.slice(buttonStart, buttonEnd);
+    assert.match(
+      openingTag,
+      /onMouseDown=\{handleTabCloseButtonMouseDown\}/,
+      `${label} close button must guard mousedown`,
+    );
+  }
+
+  assert.equal(
+    topTabItemsSource.match(/onMouseDown=\{handleTabCloseButtonMouseDown\}/g)?.length,
+    4,
+  );
+
+  const workspaceSource = topTabItemsSource.slice(
+    topTabItemsSource.indexOf("export const WorkspaceTopTab"),
+    topTabItemsSource.indexOf("WorkspaceTopTab.displayName"),
+  );
+  assert.equal(workspaceSource.includes("handleTabCloseButtonMouseDown"), false);
+  assert.equal(workspaceSource.includes("<button"), false);
+});
+
+test("draggable top tab roots activate sub-threshold presses and still reorder past the threshold", () => {
+  const tabTypes = ["plugin-view", "editor", "session", "workspace", "logView"];
+
+  for (const tabType of tabTypes) {
+    const marker = `data-tab-type="${tabType}"`;
+    const start = topTabItemsSource.indexOf(marker);
+    assert.notEqual(start, -1, marker);
+    const classNameAt = topTabItemsSource.indexOf("className={cn(", start);
+    assert.notEqual(classNameAt, -1, tabType);
+    const openingHandlers = topTabItemsSource.slice(start, classNameAt);
+    assert.match(openingHandlers, /onMouseDown=\{handleTabDragThresholdMouseDown\}/, tabType);
+    assert.match(openingHandlers, /onMouseUp=\{\(event\) => handleTabDragThresholdRelease\(event,/, tabType);
+    assert.match(
+      openingHandlers,
+      /onDragStart=\{\(event\) => \{\s*handleTabDragThresholdDragStart\(event\);\s*onTabDragStart\(event,/,
+      tabType,
+    );
+    assert.match(
+      openingHandlers,
+      /onDrag=\{\(event\) => \{\s*if \(!handleTabDragThresholdDrag\(event\)\) return;\s*onTabDragStart\(event,/,
+      tabType,
+    );
+    assert.match(
+      openingHandlers,
+      /onDragEnd=\{\(event\) => \{\s*handleTabDragThresholdRelease\(event,[\s\S]*?onTabDragEnd\(\);\s*\}\}/,
+      tabType,
+    );
+    assert.equal(openingHandlers.includes("handleTabCloseButtonMouseDown"), false, tabType);
+    assert.equal(openingHandlers.includes("preventDefault"), false, tabType);
+  }
+
+  assert.equal(topTabItemsSource.match(/onMouseDown=\{handleTabMiddleMouseDown\}/g)?.length ?? 0, 0);
+  assert.equal(topTabItemsSource.match(/handleTabDragThresholdRelease\(/g)?.length, 10);
+});
+
 test("session close button double click stays on the close button", () => {
   let stopPropagationCount = 0;
 

components/TopTabs.tsx

@@ -24,6 +24,7 @@ import { useWindowControls } from '../application/state/useWindowControls';
 import { useSettingsChromeStore } from '../application/state/settingsChromeStore';
 import { useI18n } from '../application/i18n/I18nProvider';
 import { Host, TerminalSession, Workspace } from '../types';
+import { isTabDragReorderStarted } from '../lib/tabInteractions';
 import { cn } from '../lib/utils';
 import { Button } from './ui/button';
 import { ContextMenuItem, ContextMenuSeparator } from './ui/context-menu';
@@ -520,14 +521,20 @@ const TopTabsInner: React.FC<TopTabsProps> = ({
   ]);
 
   const handleTabDragStart = useCallback((e: React.DragEvent, tabId: string) => {
-    e.dataTransfer.effectAllowed = 'move';
-    e.dataTransfer.setData('tab-reorder-id', tabId);
-    // Also set session-id for backward compatibility with workspace split functionality
-    // Only orphan sessions can be dragged to create workspaces
-    const isOrphanSession = orphanSessionMap.has(tabId);
-    if (isOrphanSession) {
-      e.dataTransfer.setData('session-id', tabId);
+    // Payload must be written on the original dragstart. A slow reorder calls
+    // this again from `drag`, when DataTransfer is already read-only.
+    try {
+      e.dataTransfer.effectAllowed = 'move';
+      e.dataTransfer.setData('tab-reorder-id', tabId);
+      // Also set session-id for backward compatibility with workspace split functionality
+      // Only orphan sessions can be dragged to create workspaces
+      if (orphanSessionMap.has(tabId)) {
+        e.dataTransfer.setData('session-id', tabId);
+      }
+    } catch (error) {
+      if (!(error instanceof DOMException)) throw error;
     }
+    if (!isTabDragReorderStarted()) return;
     draggedTabIdRef.current = tabId;
     // Use setTimeout to allow the drag image to be captured before we change styles
     setTimeout(() => {

components/ai/ChatInput.tsx

@@ -212,6 +212,10 @@ interface ChatInputProps {
   modelCatalogSource?: 'live' | 'last-known-good' | 'presets';
   /** ISO timestamp of the successful fetch backing `modelCatalogSource`. */
   modelCatalogFetchedAt?: string;
+  /** The catalog warning text behind the host's retry banner, when present. */
+  modelCatalogWarning?: string;
+  /** Manual refresh action for the picker's refresh button (force path). */
+  onRefreshModelCatalog?: () => void;
   /**
    * Offer the picker's "use custom model" action. Disable when the current
    * agent locks the model (e.g. managed Codex `model` config overrides the
@@ -286,6 +290,8 @@ const ChatInput: React.FC<ChatInputProps> = ({
   modelCatalogLoading = false,
   modelCatalogSource,
   modelCatalogFetchedAt,
+  modelCatalogWarning,
+  onRefreshModelCatalog,
   allowCustomModelEntry = true,
   selectedModelId,
   onModelSelect,
@@ -1608,6 +1614,8 @@ const ChatInput: React.FC<ChatInputProps> = ({
                     loading={!hasProviderSwitcher ? modelCatalogLoading : undefined}
                     catalogSource={!hasProviderSwitcher ? modelCatalogSource : undefined}
                     catalogFetchedAt={!hasProviderSwitcher ? modelCatalogFetchedAt : undefined}
+                    catalogWarning={!hasProviderSwitcher ? modelCatalogWarning : undefined}
+                    onRefreshCatalog={!hasProviderSwitcher ? onRefreshModelCatalog : undefined}
                     allowCustomEntry={allowCustomModelEntry}
                     prefs={modelPrefs}
                     onSelectProviderModel={(providerId, modelId, contextWindow) => {
@@ -1824,6 +1832,8 @@ function chatInputPropsAreEqual(prev: ChatInputProps, next: ChatInputProps): boo
     && prev.modelCatalogLoading === next.modelCatalogLoading
     && prev.modelCatalogSource === next.modelCatalogSource
     && prev.modelCatalogFetchedAt === next.modelCatalogFetchedAt
+    && prev.modelCatalogWarning === next.modelCatalogWarning
+    && prev.onRefreshModelCatalog === next.onRefreshModelCatalog
     && prev.allowCustomModelEntry === next.allowCustomModelEntry
     && prev.selectedModelId === next.selectedModelId
     && prev.onModelSelect === next.onModelSelect

components/ai/ComposerModelPicker.test.tsx

@@ -156,3 +156,36 @@ test('external agent picker shows the loading row while the live catalog is pend
   // keeps built-in presets visible during loading and passes them through.
   assert.doesNotMatch(html, /gpt-5\.1/);
 });
+
+test('manual refresh button renders for any fetched catalog or warning and stays localized', () => {
+  const base = {
+    modelPresets: [{ id: 'm-1', name: 'M1' }],
+    selectedModelId: 'm-1',
+    prefs: { recent: [], pinned: [] },
+    onSelectModel: () => {},
+    onTogglePinned: () => {},
+  };
+  for (const [locale, refreshLabel] of [
+    ['en', 'Refresh model list'],
+    ['zh-CN', '刷新模型列表'],
+    ['zh-TW', '重新整理模型清單'],
+    ['es', 'Actualizar la lista de modelos'],
+    ['ru', 'Обновить список моделей'],
+  ]) {
+    const html = renderToStaticMarkup(
+      <I18nProvider locale={locale}>
+        <ComposerModelPicker {...base} catalogSource="last-known-good" onRefreshCatalog={() => {}} />
+      </I18nProvider>,
+    );
+    assert.ok(html.includes(`aria-label="${refreshLabel}"`));
+  }
+
+  // A plain preset list without a host refresh action stays buttonless.
+  assert.doesNotMatch(renderToStaticMarkup(<ComposerModelPicker {...base} />), /refreshModelList/);
+
+  // A degraded preset serve (warning, no source) still offers the refresh.
+  const warned = renderToStaticMarkup(
+    <ComposerModelPicker {...base} catalogWarning="live fetch failed" onRefreshCatalog={() => {}} />,
+  );
+  assert.match(warned, /aria-label="ai\.chat\.refreshModelList"/);
+});

components/ai/ComposerModelPicker.tsx

@@ -1,4 +1,4 @@
-import { Check, ChevronLeft, ChevronRight, Loader2, Pin, Search, Star } from 'lucide-react';
+import { Check, ChevronLeft, ChevronRight, Loader2, Pin, RotateCw, Search, Star } from 'lucide-react';
 import React, { useEffect, useMemo, useState } from 'react';
 import { useI18n } from '../../application/i18n/I18nProvider';
 import {
@@ -37,6 +37,18 @@ export interface ComposerModelPickerProps {
   catalogSource?: 'live' | 'last-known-good' | 'presets';
   /** ISO timestamp of the successful fetch backing `catalogSource`. */
   catalogFetchedAt?: string;
+  /**
+   * The catalog warning text behind the host's retry banner, when present.
+   * Together with `catalogSource` it decides whether the manual refresh
+   * button renders: any fetched catalog (live or last-known-good) or a
+   * degraded preset fallback offers a refresh; a plain preset list does not.
+   */
+  catalogWarning?: string | null;
+  /**
+   * Manual refresh action (LKG-first policy: the picker hydrates from disk
+   * and the user refreshes explicitly). Triggers the host's force refresh.
+   */
+  onRefreshCatalog?: () => void;
   prefs: ComposerModelPrefs;
   /**
    * Offer the "use custom model" action. Disable when the host locks the
@@ -107,6 +119,8 @@ export const ComposerModelPicker: React.FC<ComposerModelPickerProps> = ({
   loading = false,
   catalogSource,
   catalogFetchedAt,
+  catalogWarning,
+  onRefreshCatalog,
   prefs,
   allowCustomEntry = true,
   onSelectProviderModel,
@@ -174,6 +188,18 @@ export const ComposerModelPicker: React.FC<ComposerModelPickerProps> = ({
       ? t('ai.chat.modelCatalogSourceCached').replace('{time}', time)
       : t('ai.chat.modelCatalogSourceCachedNoTime');
   }, [loading, catalogSource, catalogFetchedAt, t]);
+  // Manual refresh (LKG-first): offered whenever a fetched catalog (any
+  // source) or the degraded-preset warning is present. Hidden while loading —
+  // the spinner row is the in-flight feedback — and in provider mode, where
+  // neither a catalog chip nor a host refresh action exists.
+  const showRefreshButton = useMemo(() => (
+    !loading
+    && Boolean(onRefreshCatalog)
+    && (catalogSource === 'live'
+      || catalogSource === 'last-known-good'
+      || Boolean(catalogWarning))
+  ), [loading, onRefreshCatalog, catalogSource, catalogWarning]);
+  const refreshLabel = t('ai.chat.refreshModelList');
   // Manual model ids are accepted in both modes: provider-bound catalogs and
   // preset lists from external CLI agents whose catalogs lag new models.
   const showCustom = Boolean(
@@ -384,9 +410,22 @@ export const ComposerModelPicker: React.FC<ComposerModelPickerProps> = ({
         )}
       </div>
 
-      {catalogChipText && (
-        <div className="border-t border-border/40 px-2.5 py-1 text-[10px] text-muted-foreground/45" title={catalogChipText}>
-          {catalogChipText}
+      {(catalogChipText || showRefreshButton) && (
+        <div className="flex items-center gap-1 border-t border-border/40 px-2.5 py-1 text-[10px] text-muted-foreground/45">
+          {catalogChipText && (
+            <span className="min-w-0 flex-1 truncate" title={catalogChipText}>{catalogChipText}</span>
+          )}
+          {showRefreshButton && (
+            <button
+              type="button"
+              aria-label={refreshLabel}
+              title={refreshLabel}
+              onClick={onRefreshCatalog}
+              className="shrink-0 rounded p-0.5 text-muted-foreground/55 transition-colors hover:bg-muted/40 hover:text-foreground/75 cursor-pointer"
+            >
+              <RotateCw size={11} />
+            </button>
+          )}
         </div>
       )}
     </div>

components/notes/NotesManager.perf.test.ts

@@ -43,6 +43,26 @@ test("note content drafts stay in refs so MDX keystrokes do not rebuild the shel
   );
 });
 
+test("hidden notes flush drafts on the isActive edge without rebuilding the tree", () => {
+  assert.match(
+    managerSource,
+    /useLayoutEffect\(\(\) => \{\s*if \(isActive\) return;\s*flushNoteDraftRef\.current\(\);\s*\}, \[isActive\]\);/,
+  );
+  assert.match(managerSource, /const NotesTreePane = memo\(/);
+  assert.match(managerSource, /notesTreePanePropsEqual/);
+  assert.match(managerSource, /prev\.selectedNoteId === next\.selectedNoteId/);
+  assert.match(managerSource, /prev\.editingNoteId === next\.editingNoteId/);
+  assert.match(managerSource, /prev\.editingGroupPath === next\.editingGroupPath/);
+  assert.match(managerSource, /prev\.expandedGroups === next\.expandedGroups/);
+  assert.match(managerSource, /<NotesTreePane/);
+  assert.doesNotMatch(managerSource, /key=\{isActive\}/);
+  assert.doesNotMatch(
+    managerSource,
+    /if \(!isActive\) return null;/,
+    "hiding notes must not unmount NotesManager",
+  );
+});
+
 test("NotesManager teardown flush uses a stable ref under StrictMode", () => {
   assert.match(managerSource, /flushNoteDraftRef\.current = flushNoteDraft/);
   assert.match(
@@ -73,6 +93,21 @@ test("hidden terminal notes side panel does not subscribe to notes publishes", (
     "utf8",
   );
   assert.match(slotsSource, /useNotesStore\(\{\s*enabled:\s*isVisible\s*\}\)/);
+  const notesSlot = slotsSource.slice(
+    slotsSource.indexOf("function SidePanelNotesSlotInner"),
+    slotsSource.indexOf("export const SidePanelNotesSlot"),
+  );
+  assert.doesNotMatch(notesSlot, /if \(!isVisible\) return null/);
+  assert.match(notesSlot, /<NotesManager/);
+  const notesStoreSource = readFileSync(
+    new URL("../../application/state/notesStore.ts", import.meta.url),
+    "utf8",
+  );
+  assert.doesNotMatch(
+    notesStoreSource,
+    /enabled \? getNotesSnapshot : getEmptyNotesSnapshot/,
+    "enabled:false must keep the live snapshot so reopen does not flash empty",
+  );
 });
 
 test("notes manager prefetches the MDXEditor chunk when becoming active", () => {

components/notes/NotesManager.test.tsx

@@ -22,7 +22,9 @@ import {
   isNoteFolderTreeSelected,
   isNoteEditorMode,
   normalizeNoteEditorMode,
+  notesTreePanePropsEqual,
   NotesManager,
+  type NotesTreePaneProps,
 } from "./NotesManager.tsx";
 
 const note = (overrides: Partial<VaultNote> = {}): VaultNote => ({
@@ -369,10 +371,40 @@ test("NotesManager flushes drafts when retained mounts become inactive", () => {
   const source = readFileSync(new URL("./NotesManager.tsx", import.meta.url), "utf8");
   assert.match(source, /isActive\?: boolean/);
   assert.match(source, /if \(isActive\) return;/);
-  assert.match(source, /useLayoutEffect\(\(\) => \{\s*if \(isActive\) return;/);
+  assert.match(source, /useLayoutEffect\(\(\) => \{\s*if \(isActive\) return;\s*flushNoteDraftRef\.current\(\);/);
   assert.match(source, /visibilitychange/);
 });
 
+const treePaneProps = (overrides: Partial<NotesTreePaneProps> = {}): NotesTreePaneProps => ({
+  notes: [note()],
+  noteGroups: ["Ops"],
+  selectedNoteId: "note-1",
+  selectedGroup: null,
+  expandedGroups: new Set(["Ops"]),
+  editingNoteId: null,
+  editingGroupPath: null,
+  query: "",
+  locale: "en",
+  hosts: [],
+  draggingNoteId: null,
+  draggingGroupPath: null,
+  creatingGroupParent: undefined,
+  isSidebarMode: true,
+  renderRows: () => null,
+  ...overrides,
+});
+
+test("notes tree pane equality ignores render callbacks and compares selection state", () => {
+  const base = treePaneProps();
+  assert.equal(notesTreePanePropsEqual(base, { ...base, renderRows: () => "other" }), true);
+  assert.equal(notesTreePanePropsEqual(base, { ...base, selectedNoteId: "note-2" }), false);
+  assert.equal(notesTreePanePropsEqual(base, { ...base, selectedGroup: "Ops" }), false);
+  assert.equal(notesTreePanePropsEqual(base, { ...base, editingNoteId: "note-1" }), false);
+  assert.equal(notesTreePanePropsEqual(base, { ...base, editingGroupPath: "Ops" }), false);
+  assert.equal(notesTreePanePropsEqual(base, { ...base, expandedGroups: new Set(["Ops"]) }), false);
+  assert.equal(notesTreePanePropsEqual(base, { ...base, notes: [note({ title: "Renamed" })] }), false);
+});
+
 test("NotesManager tree rename allows clearing note titles", () => {
   const source = readFileSync(new URL("./NotesManager.tsx", import.meta.url), "utf8");
   const renameBlock = source.match(/onRenameCommit=\{\(name\) => \{[\s\S]*?\}\}/)?.[0] ?? "";

components/notes/NotesManager.tsx

@@ -16,7 +16,7 @@ import {
   Upload,
   X,
 } from "lucide-react";
-import React, { lazy, Suspense, useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
+import React, { lazy, memo, Suspense, useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { useI18n } from "../../application/i18n/I18nProvider";
 import { useApplicationBackend } from "../../application/state/useApplicationBackend";
 import { useStoredNumber } from "../../application/state/useStoredNumber";
@@ -357,6 +357,57 @@ export const getValidatedNoteSelectionState = (
   return null;
 };
 
+export type NotesTreePaneProps = {
+  notes: VaultNote[];
+  noteGroups: string[];
+  selectedNoteId: string | null;
+  selectedGroup: string | null;
+  expandedGroups: ReadonlySet<string>;
+  editingNoteId: string | null;
+  editingGroupPath: string | null;
+  query: string;
+  locale: string;
+  hosts: Host[];
+  draggingNoteId: string | null;
+  draggingGroupPath: string | null;
+  creatingGroupParent: string | null | undefined;
+  isSidebarMode: boolean;
+  /**
+   * Row elements. Identity changes every parent render; equality ignores it so
+   * a visibility flip does not rebuild the tree. Event handlers close over the
+   * render that last changed one of the compared fields.
+   */
+  renderRows: () => React.ReactNode;
+};
+
+/**
+ * Hide/show passes a new `isActive` into NotesManager, but that flag is not a
+ * tree input. Equality therefore keys off the data the rows actually paint.
+ * `selected` / `editing` / `expanded` are required so a memo bailout cannot
+ * freeze selection, rename, or folder expansion.
+ */
+export function notesTreePanePropsEqual(prev: NotesTreePaneProps, next: NotesTreePaneProps): boolean {
+  return prev.notes === next.notes
+    && prev.noteGroups === next.noteGroups
+    && prev.selectedNoteId === next.selectedNoteId
+    && prev.selectedGroup === next.selectedGroup
+    && prev.expandedGroups === next.expandedGroups
+    && prev.editingNoteId === next.editingNoteId
+    && prev.editingGroupPath === next.editingGroupPath
+    && prev.query === next.query
+    && prev.locale === next.locale
+    && prev.hosts === next.hosts
+    && prev.draggingNoteId === next.draggingNoteId
+    && prev.draggingGroupPath === next.draggingGroupPath
+    && prev.creatingGroupParent === next.creatingGroupParent
+    && prev.isSidebarMode === next.isSidebarMode;
+}
+
+const NotesTreePane = memo(function NotesTreePane({ renderRows }: NotesTreePaneProps) {
+  return <>{renderRows()}</>;
+}, notesTreePanePropsEqual);
+NotesTreePane.displayName = "NotesTreePane";
+
 export const getNotesGroupDropAction = (
   sourceGroup: string | null,
   targetGroup: string,
@@ -381,7 +432,7 @@ export const NotesManager: React.FC<NotesManagerProps> = ({
   openNoteRequestId = null,
   onOpenNoteIdHandled,
 }) => {
-  const { t } = useI18n();
+  const { t, locale } = useI18n();
   const { openExternal } = useApplicationBackend();
   const isSidebarMode = displayMode === "sidebar";
   const initialOpenNoteId = openNoteId && notes.some((note) => note.id === openNoteId)
@@ -561,10 +612,12 @@ export const NotesManager: React.FC<NotesManagerProps> = ({
     flushNoteDraftRef.current();
   }, []);
 
+  // Hide edge only. The ref is the latest flush, so this does not subscribe
+  // the tree render to draft-writer identity, and it does not remount the editor.
   useLayoutEffect(() => {
     if (isActive) return;
-    flushNoteDraft();
-  }, [flushNoteDraft, isActive]);
+    flushNoteDraftRef.current();
+  }, [isActive]);
 
   useEffect(() => {
     if (!isActive) return;
@@ -1486,11 +1539,28 @@ export const NotesManager: React.FC<NotesManagerProps> = ({
     );
   };
 
-  const visibleRootNotes = noteTree.rootNotes.filter(noteMatches);
-  const visibleTree = noteTree.children
-    .map((child) => renderFolderRow(child, 0))
-    .filter(Boolean);
-  const treeIsEmpty = visibleRootNotes.length === 0 && visibleTree.length === 0;
+  // Built only when NotesTreePane's compared props change. isActive / the
+  // hidden class stay on the parent, so a side-panel hide does not reconcile rows.
+  const renderTreeRows = () => {
+    const visibleRootNotes = noteTree.rootNotes.filter(noteMatches);
+    const visibleTree = noteTree.children
+      .map((child) => renderFolderRow(child, 0))
+      .filter(Boolean);
+    const treeIsEmpty = visibleRootNotes.length === 0 && visibleTree.length === 0;
+    return (
+      <>
+        {renderCreateGroupRow(null, 0)}
+        {visibleTree}
+        {visibleRootNotes.map((note) => renderNoteRow(note, 0))}
+        {treeIsEmpty && (
+          <div className="rounded-lg border border-dashed border-border/70 p-4 text-center text-sm text-muted-foreground">
+            <Search size={20} className="mx-auto mb-2 opacity-60" />
+            {query.trim() ? t("notes.search.noResults") : t("notes.empty.group")}
+          </div>
+        )}
+      </>
+    );
+  };
   const hasSearch = query.trim().length > 0;
   const canExpandCollapse = allGroupPaths.length > 0 && !hasSearch;
   const shouldShowNotesTree = isSidebarMode || sortedNotes.length > 0;
@@ -1750,15 +1820,23 @@ export const NotesManager: React.FC<NotesManagerProps> = ({
               }}
               onDrop={(event) => handleGroupDrop(null, event)}
             >
-              {renderCreateGroupRow(null, 0)}
-              {visibleTree}
-              {visibleRootNotes.map((note) => renderNoteRow(note, 0))}
-              {treeIsEmpty && (
-                <div className="rounded-lg border border-dashed border-border/70 p-4 text-center text-sm text-muted-foreground">
-                  <Search size={20} className="mx-auto mb-2 opacity-60" />
-                  {query.trim() ? t("notes.search.noResults") : t("notes.empty.group")}
-                </div>
-              )}
+              <NotesTreePane
+                notes={sortedNotes}
+                noteGroups={groups}
+                selectedNoteId={selectedNoteId}
+                selectedGroup={selectedGroup}
+                expandedGroups={expandedGroups}
+                editingNoteId={editingNoteId}
+                editingGroupPath={editingGroupPath}
+                query={query}
+                locale={locale}
+                hosts={hosts}
+                draggingNoteId={draggingNoteId}
+                draggingGroupPath={draggingGroupPath}
+                creatingGroupParent={creatingGroupParent}
+                isSidebarMode={isSidebarMode}
+                renderRows={renderTreeRows}
+              />
             </div>
           </ScrollArea>
           </div>
@@ -2048,6 +2126,7 @@ export const NotesManager: React.FC<NotesManagerProps> = ({
         )}
       </div>
 
+      {/* Kept mounted while the panel is hidden. Do not key this on isActive. */}
       {isSidebarMode && overlayNoteView && (
         <div className="absolute inset-0 z-30 flex min-h-0 flex-col bg-background text-foreground">
           <div className={cn(

components/settings/tabs/ai/types.ts

@@ -158,7 +158,7 @@ export interface NetcattyAiBridge {
   aiCodexCancelLogin?: (sessionId: string) => Promise<{ ok: boolean; found?: boolean; session?: CodexLoginSession; error?: string }>;
   aiCodexLogout?: (options?: { codexPath?: string; agentEnv?: Record<string, string> }) => Promise<{ ok: boolean; state?: CodexIntegrationState; isConnected?: boolean; rawOutput?: string; logoutOutput?: string; error?: string }>;
   aiResolveCli?: (params: { command: string; customPath?: string; refreshShellEnv?: boolean; apiKeyPresent?: boolean }) => Promise<AgentPathInfo>;
-  aiSdkAgentListModels?: (sdkBackend: string, cwd?: string, providerId?: string, chatSessionId?: string, agentEnv?: Record<string, string>, agentCommand?: string, codexRuntime?: 'sdk' | 'app-server') => Promise<{ ok: boolean; models?: Array<{ id: string; name: string; description?: string; thinkingLevels?: string[]; defaultThinkingLevel?: string }>; currentModelId?: string | null; warning?: string; source?: 'live' | 'last-known-good'; fetchedAt?: string; error?: string }>;
+  aiSdkAgentListModels?: (sdkBackend: string, cwd?: string, providerId?: string, chatSessionId?: string, agentEnv?: Record<string, string>, agentCommand?: string, codexRuntime?: 'sdk' | 'app-server', force?: boolean) => Promise<{ ok: boolean; models?: Array<{ id: string; name: string; description?: string; thinkingLevels?: string[]; defaultThinkingLevel?: string }>; currentModelId?: string | null; warning?: string; source?: 'live' | 'last-known-good'; fetchedAt?: string; error?: string }>;
   codexAppServerGetStatus?: (agentCommand?: string, agentEnv?: Record<string, string>) => Promise<{ ok: boolean; available: boolean; error?: string }>;
   aiUserSkillsGetStatus?: () => Promise<UserSkillsStatusResult>;
   aiUserSkillsOpenFolder?: () => Promise<UserSkillsStatusResult>;

components/sftp/SftpTransferItem.tsx

@@ -33,6 +33,7 @@ import {
 import { Button } from '../ui/button';
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '../ui/tooltip';
 import { formatSpeed, formatTransferBytes } from './utils';
+import { SftpTransferWarning } from './SftpTransferWarning';
 
 /** Child rows need room for Pause + Cancel (2×24px icons + gap). */
 const CHILD_ACTIONS_COLUMN_PX = 56;
@@ -54,6 +55,7 @@ interface SftpTransferItemProps {
     canToggleChildren?: boolean;
     isExpanded?: boolean;
     visibleChildCount?: number;
+    childWarningCount?: number;
     onToggleChildren?: () => void;
     onSetNameColumnWidth?: (width: number) => void;
     childNameColumnMinWidth?: number;
@@ -124,6 +126,7 @@ const SftpTransferItemInner: React.FC<SftpTransferItemProps> = ({
     canToggleChildren = false,
     isExpanded = false,
     visibleChildCount: _visibleChildCount = 0,
+    childWarningCount = 0,
     onToggleChildren,
     onSetNameColumnWidth,
     childNameColumnMinWidth = 160,
@@ -288,7 +291,8 @@ const SftpTransferItemInner: React.FC<SftpTransferItemProps> = ({
     // pause button never looks dead when the backend refuses.
     const showPauseUnavailable = !!task.pauseUnavailableReason
         && (task.status === 'transferring' || task.status === 'queued' || task.status === 'pending');
-    const hasFooterContent = showTransferSizeCalculation || showFailedError || showPauseUnavailable;
+    const showWarning = task.status === 'completed' && !!task.warning;
+    const hasFooterContent = showTransferSizeCalculation || showFailedError || showPauseUnavailable || showWarning || childWarningCount > 0;
     const retryActionLabel = t('sftp.transfers.retryAction');
     const cancelActionLabel = t('common.cancel');
     const pauseActionLabel = t('sftp.transferCenter.pause');
@@ -480,7 +484,7 @@ const SftpTransferItemInner: React.FC<SftpTransferItemProps> = ({
                     <TooltipContent side="top">{resizeNameColumnLabel}</TooltipContent>
                 </Tooltip>
                 <div className="min-w-0 overflow-hidden">
-                    {childProgressBar}
+                    {showWarning ? <SftpTransferWarning warning={task.warning} compact /> : childProgressBar}
                 </div>
                 <div className="flex h-full min-w-0 items-center justify-end gap-0.5 pl-1">
                     {actionButtons}
@@ -609,6 +613,10 @@ const SftpTransferItemInner: React.FC<SftpTransferItemProps> = ({
                 {showPauseUnavailable && (
                     <span className="text-amber-600 dark:text-amber-400">{task.pauseUnavailableReason}</span>
                 )}
+                {showWarning && <SftpTransferWarning warning={task.warning} />}
+                {childWarningCount > 0 && (
+                    <span className="text-amber-600 dark:text-amber-400">{t('sftp.transfers.cleanupWarnings', { count: childWarningCount })}</span>
+                )}
                 </div>
             )}
         </div>
@@ -631,6 +639,7 @@ const arePropsEqual = (
 
     if (prev.status !== next.status) return false;
     if (prev.error !== next.error) return false;
+    if (prev.warning !== next.warning) return false;
     if (prev.pauseUnavailableReason !== next.pauseUnavailableReason) return false;
     if (prev.reconnectRequired !== next.reconnectRequired) return false;
     if (prev.resumable !== next.resumable) return false;
@@ -647,6 +656,7 @@ const arePropsEqual = (
     if ((prevProps.canToggleChildren ?? false) !== (nextProps.canToggleChildren ?? false)) return false;
     if ((prevProps.isExpanded ?? false) !== (nextProps.isExpanded ?? false)) return false;
     if ((prevProps.visibleChildCount ?? 0) !== (nextProps.visibleChildCount ?? 0)) return false;
+    if ((prevProps.childWarningCount ?? 0) !== (nextProps.childWarningCount ?? 0)) return false;
     if ((prevProps.childNameColumnMinWidth ?? 160) !== (nextProps.childNameColumnMinWidth ?? 160)) return false;
     if ((prevProps.childNameColumnMaxWidth ?? 480) !== (nextProps.childNameColumnMaxWidth ?? 480)) return false;
     if ((prevProps.childListId ?? '') !== (nextProps.childListId ?? '')) return false;

components/sftp/SftpTransferQueue.tsx

@@ -423,6 +423,7 @@ export const SftpTransferQueue: React.FC<SftpTransferQueueProps> = ({
                 canToggleChildren={childTasks.length > 0}
                 isExpanded={isExpanded}
                 visibleChildCount={childTasks.length}
+                childWarningCount={childTasks.filter((child) => child.status === 'completed' && !!child.warning).length}
                 childListId={childListId}
                 onToggleChildren={() => toggleExpanded(task.id)}
                 onCancel={() => {

components/sftp/SftpTransferWarning.tsx

@@ -0,0 +1,21 @@
+import { AlertTriangle } from "lucide-react";
+import React from "react";
+import { cn } from "../../lib/utils";
+import { Tooltip, TooltipContent, TooltipTrigger } from "../ui/tooltip";
+
+/** Cleanup warnings are not transfer errors: retain the completed lifecycle. */
+export function SftpTransferWarning({ warning, compact = false }: { warning?: string; compact?: boolean }) {
+  if (!warning) return null;
+  const content = (
+    <span className={cn("flex min-w-0 items-start gap-1 text-[10px] text-amber-600 dark:text-amber-400", !compact && "select-text")} data-section="sftp-transfer-warning">
+      <AlertTriangle size={12} className="mt-0.5 shrink-0" aria-hidden="true" />
+      <span className={compact ? "truncate" : "break-all"}>{warning}</span>
+    </span>
+  );
+  return compact ? (
+    <Tooltip>
+      <TooltipTrigger asChild><span className="block min-w-0" tabIndex={0}>{content}</span></TooltipTrigger>
+      <TooltipContent className="max-w-md select-text break-all">{warning}</TooltipContent>
+    </Tooltip>
+  ) : content;
+}

components/sftp/reportSftpUploadResults.test.ts

@@ -58,6 +58,21 @@ test("toasts multi-file success count", () => {
   assert.deepEqual(calls, [{ type: "success", message: "sftp.uploadFiles: 2" }]);
 });
 
+test("successful uploads surface cleanup warnings rather than upload failures", () => {
+  const calls: Array<{ type: string; message: string }> = [];
+  const warning = "Upload completed; remove backup /remote/.netcatty-backup-a manually.";
+  reportSftpUploadResults({
+    results: [{ fileName: "a", success: true, warning }], t,
+    toast: {
+      success: (message) => calls.push({ type: "success", message }),
+      error: (message) => calls.push({ type: "error", message }),
+      info: (message) => calls.push({ type: "info", message }),
+      warning: (message) => calls.push({ type: "warning", message }),
+    },
+  });
+  assert.deepEqual(calls, [{ type: "warning", message: warning }, { type: "success", message: "sftp.upload: a" }]);
+});
+
 test("terminal drop success names the exact remote destination", () => {
   const calls: Array<{ type: string; message: string }> = [];
   reportSftpUploadResults({

components/sftp/reportSftpUploadResults.ts

@@ -7,6 +7,7 @@ export type ReportSftpUploadResultsOptions = {
     success: (message: string, title?: string) => void;
     error: (message: string, title?: string) => void;
     info: (message: string, title?: string) => void;
+    warning?: (message: string, title?: string) => void;
   };
   /** Optional single-item success message override (e.g. folder name). */
   successMessage?: string;
@@ -28,6 +29,11 @@ export function reportSftpUploadResults({
   const withTargetPath = (message: string): string => (
     targetPath ? `${message} (${targetPath})` : message
   );
+  for (const result of results) {
+    if (result.success && result.warning) {
+      (toast.warning ?? toast.info)(result.warning, "SFTP");
+    }
+  }
   if (results.some((result) => result.cancelled)) {
     toast.info(t("sftp.upload.cancelled"), "SFTP");
     return;

components/systemManager/DiskIoSummary.tsx

@@ -0,0 +1,23 @@
+import React from "react";
+import { useI18n } from "../../application/i18n/I18nProvider";
+
+function rate(value: number | null | undefined) {
+  if (value == null || !Number.isFinite(value) || value < 0) return "--";
+  if (value >= 1024 ** 2) return `${(value / 1024 ** 2).toFixed(1)} MiB/s`;
+  if (value >= 1024) return `${(value / 1024).toFixed(1)} KiB/s`;
+  return `${Math.round(value)} B/s`;
+}
+
+/** Same shared-sampler rates in monitor cards, tables, and terminal overview. */
+export function DiskIoSummary({ stats }: {
+  stats?: { diskReadSpeed?: number | null; diskWriteSpeed?: number | null } | null;
+}) {
+  const { t } = useI18n();
+  return (
+    <div data-disk-io className="flex flex-wrap gap-x-3 gap-y-0.5 text-[10px] tabular-nums text-muted-foreground" title={t("monitor.diskIoHint")}>
+      <span>{t("monitor.diskIo")}</span>
+      <span>{t("monitor.diskRead")} {rate(stats?.diskReadSpeed)}</span>
+      <span>{t("monitor.diskWrite")} {rate(stats?.diskWriteSpeed)}</span>
+    </div>
+  );
+}

components/systemManager/SystemOverviewTab.tsx

@@ -12,6 +12,7 @@ import { aggregateMountedDiskUsage } from '../../domain/systemDiskUsage';
 import { cn } from '../../lib/utils';
 import { useServerStats } from '../../application/state/useServerStats';
 import { ResourceBar } from './ResourceBar';
+import { DiskIoSummary } from './DiskIoSummary';
 import {
   SystemPanelEmpty,
   SystemPanelError,
@@ -335,6 +336,8 @@ export const SystemOverviewTab = memo(function SystemOverviewTab({
             />
           </div>
 
+          <div className="mt-3"><DiskIoSummary stats={stats} /></div>
+
           <div className="mt-3 grid grid-cols-2 gap-2">
             <InfoPill label={t('systemManager.overview.load')} value={formatLoad(stats.loadAverage)} />
             <InfoPill label={t('systemManager.overview.uptime')} value={formatDuration(stats.uptimeSeconds, t)} />

components/terminal/TerminalContextMenu.sftp.test.tsx

@@ -0,0 +1,123 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { JSDOM } from 'jsdom';
+
+test('SFTP menu opens the clicked pane without a selection and is absent without a handler', async () => {
+  const dom = new JSDOM('<!doctype html><html><body><div id="root"></div></body></html>', {
+    pretendToBeVisual: true,
+    url: 'http://localhost',
+  });
+  const window = dom.window;
+  const previousGlobals = new Map<string, PropertyDescriptor | undefined>();
+  const installGlobal = (key: string, value: unknown) => {
+    previousGlobals.set(key, Object.getOwnPropertyDescriptor(globalThis, key));
+    Object.defineProperty(globalThis, key, {
+      configurable: true,
+      writable: true,
+      value,
+    });
+  };
+
+  class ResizeObserverStub {
+    observe() {}
+    unobserve() {}
+    disconnect() {}
+  }
+
+  installGlobal('window', window);
+  installGlobal('document', window.document);
+  installGlobal('navigator', window.navigator);
+  installGlobal('HTMLElement', window.HTMLElement);
+  installGlobal('HTMLInputElement', window.HTMLInputElement);
+  installGlobal('HTMLTextAreaElement', window.HTMLTextAreaElement);
+  installGlobal('Element', window.Element);
+  installGlobal('SVGElement', window.SVGElement);
+  installGlobal('Node', window.Node);
+  installGlobal('NodeFilter', window.NodeFilter);
+  installGlobal('MutationObserver', window.MutationObserver);
+  installGlobal('CustomEvent', window.CustomEvent);
+  installGlobal('DOMRect', window.DOMRect);
+  installGlobal('Event', window.Event);
+  installGlobal('KeyboardEvent', window.KeyboardEvent);
+  installGlobal('MouseEvent', window.MouseEvent);
+  installGlobal('getComputedStyle', window.getComputedStyle.bind(window));
+  installGlobal('requestAnimationFrame', window.requestAnimationFrame.bind(window));
+  installGlobal('cancelAnimationFrame', window.cancelAnimationFrame.bind(window));
+  installGlobal('ResizeObserver', ResizeObserverStub);
+  installGlobal('IS_REACT_ACT_ENVIRONMENT', true);
+
+  const { default: React, act } = await import('react');
+  const { createRoot } = await import('react-dom/client');
+  const { I18nProvider } = await import('../../application/i18n/I18nProvider.tsx');
+  const { TerminalContextMenu } = await import('./TerminalContextMenu.tsx');
+  const rootNode = window.document.getElementById('root');
+  assert.ok(rootNode);
+  const root = createRoot(rootNode);
+  const actions: string[] = [];
+
+  const openMenu = async (hostId: string) => {
+    const surface = window.document.querySelector<HTMLElement>(`[data-testid="${hostId}"]`);
+    assert.ok(surface);
+    await act(async () => {
+      surface.dispatchEvent(new window.MouseEvent('contextmenu', {
+        bubbles: true,
+        button: 2,
+        clientX: 20,
+        clientY: 20,
+      }));
+    });
+  };
+
+  const findMenuItem = (label: string): HTMLElement => {
+    const item = Array.from(window.document.querySelectorAll<HTMLElement>('[role="menuitem"]'))
+      .find((candidate) => candidate.textContent?.includes(label));
+    assert.ok(item, `${label} menu item should be visible`);
+    return item;
+  };
+
+  const renderPanes = async (enabled = true) => {
+    await act(async () => {
+      root.render(
+        <I18nProvider locale="zh-CN">
+          {['host-a', 'host-b'].map((hostId) => (
+            <TerminalContextMenu
+              key={hostId}
+              sessionId={hostId}
+              hostId={hostId}
+              status="connected"
+              hasSelection={false}
+              onOpenSftp={enabled ? () => actions.push(hostId) : undefined}
+            >
+              <div data-testid={hostId}>Terminal</div>
+            </TerminalContextMenu>
+          ))}
+        </I18nProvider>,
+      );
+    });
+  };
+
+  try {
+    await renderPanes();
+    for (const hostId of ['host-b', 'host-a', 'host-b']) {
+      await openMenu(hostId);
+      const item = findMenuItem('打开 SFTP');
+      assert.notEqual(item.getAttribute('aria-disabled'), 'true');
+      assert.equal(findMenuItem('复制').getAttribute('aria-disabled'), 'true');
+      await act(async () => item.click());
+      assert.equal(window.document.querySelector('[role="menu"]'), null);
+    }
+    assert.deepEqual(actions, ['host-b', 'host-a', 'host-b']);
+
+    await renderPanes(false);
+    await openMenu('host-a');
+    assert.equal(window.document.body.textContent?.includes('打开 SFTP'), false);
+  } finally {
+    await act(async () => root.unmount());
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    dom.window.close();
+    for (const [key, descriptor] of previousGlobals) {
+      if (descriptor) Object.defineProperty(globalThis, key, descriptor);
+      else delete (globalThis as Record<string, unknown>)[key];
+    }
+  }
+});

components/terminal/TerminalContextMenu.tsx

@@ -7,6 +7,7 @@ import {
   Copy,
   Download,
   Globe2,
+  FolderInput,
   Pencil,
   RefreshCcw,
   Sparkles,
@@ -67,6 +68,7 @@ export interface TerminalContextMenuProps {
   onReconnect?: () => void;
   onClose?: () => void;
   onOpenBrowser?: () => void;
+  onOpenSftp?: () => void;
   onSelectWord?: () => void;
   onAddSelectionToAI?: () => void;
   onRename?: () => void;
@@ -227,6 +229,7 @@ export const TerminalContextMenu: React.FC<TerminalContextMenuProps> = ({
   onReconnect,
   onClose,
   onOpenBrowser,
+  onOpenSftp,
   onSelectWord,
   onAddSelectionToAI,
   onRename,
@@ -413,6 +416,14 @@ export const TerminalContextMenu: React.FC<TerminalContextMenuProps> = ({
             {t('terminal.menu.selectAll')}
             <ContextMenuShortcut>{selectAllShortcut}</ContextMenuShortcut>
           </ContextMenuItem>
+          {onOpenSftp && (
+            <>
+              <ContextMenuSeparator />
+              <ContextMenuItem onClick={onOpenSftp}>
+                <FolderInput size={14} className="mr-2" /> {t('terminal.toolbar.openSftp')}
+              </ContextMenuItem>
+            </>
+          )}
           {onOpenBrowser && (
             <>
               <ContextMenuSeparator />

components/terminal/TerminalView.test.tsx

@@ -652,6 +652,16 @@ test("terminal boot is cancelable and closes eagerly on cleanup", () => {
   );
   // Owner panes close the pending backend; attach popups only dispose xterm.
   assert.match(neverConnectedBranch, /if \(!attachExistingSession\)/);
+  const emptySessionBranch = readFileSync(new URL("../Terminal.tsx", import.meta.url), "utf8");
+  const emptyStart = emptySessionBranch.indexOf("if (!closingSessionId)");
+  const emptyEnd = emptySessionBranch.indexOf("Observe/attach popups must not kill", emptyStart);
+  const emptyBranch = emptySessionBranch.slice(emptyStart, emptyEnd);
+  const attachGuardAt = emptyBranch.indexOf("if (attachExistingSession)");
+  const emptyCloseAt = emptyBranch.indexOf("terminalBackend.closeSession(");
+  assert.ok(
+    attachGuardAt !== -1 && emptyCloseAt !== -1 && attachGuardAt < emptyCloseAt,
+    "a second attach cleanup after sessionRef is cleared must not closeSession",
+  );
   assert.match(effectsSource, /let ownedRuntime:/);
   assert.match(
     cleanup,
@@ -731,3 +741,11 @@ test("terminal theme updates force xterm renderer to repaint immediately", () =>
   assert.match(schedulerSource, /term\.options\.theme = \{/);
   assert.match(schedulerSource, /forceSyncRenderAfterResize\(term\)/);
 });
+
+test("SFTP context action reuses the pane toolbar handler and its availability", () => {
+  const source = readFileSync(new URL("./TerminalView.tsx", import.meta.url), "utf8");
+  const terminalSource = readFileSync(new URL("../Terminal.tsx", import.meta.url), "utf8");
+  assert.match(source, /onOpenSftp=\{status === "connected" && !isSerialConnection && !host\?\.id\?\.startsWith\("serial-"\) && !isPluginHostProtocol\(host\?\.protocol\) \? ctx\.handleOpenSFTP : undefined\}/);
+  assert.match(terminalSource, /onOpenSFTP=\{handleOpenSFTP\}/);
+  assert.match(terminalSource, /<TerminalView ctx=\{\{[^\n]*handleOpenSFTP,/);
+});

components/terminal/TerminalView.tsx

@@ -591,6 +591,7 @@ function TerminalViewInner({ ctx, isPaneMagnified = false }: { ctx: TerminalView
       onSaveScreen={terminalContextActions.onSaveScreen}
       onCopy={terminalContextActions.onCopy}
       onOpenBrowser={(!host?.protocol || ['ssh', 'mosh', 'local'].includes(host.protocol)) ? () => { void ctx.handleOpenHostBrowser(); } : undefined}
+      onOpenSftp={status === "connected" && !isSerialConnection && !host?.id?.startsWith("serial-") && !isPluginHostProtocol(host?.protocol) ? ctx.handleOpenSFTP : undefined}
       onPaste={terminalContextActions.onPaste}
       onUploadClipboardImage={status === "connected" ? terminalContextActions.onUploadClipboardImage : undefined}
       onPasteSelection={terminalContextActions.onPasteSelection}

components/terminal/inlineImageRendering.test.ts

@@ -84,7 +84,7 @@ test("a session holding inline images degrades to soft-hide instead of full hibe
   const gateIndex = hibernateBody.indexOf("if (runtimeHasInlineImages()) {");
   const softHideIndex = hibernateBody.indexOf("hideRuntimeOnly();", gateIndex);
   const keepCountIndex = hibernateBody.indexOf("resolveHibernateKeepRendererCount(terminalSettings)");
-  const evictionIndex = hibernateBody.indexOf("terminalHiddenRendererStore.pickEvictionCandidate(");
+  const evictionIndex = hibernateBody.indexOf("retainLeavingTabAfterEviction(");
   const fullHibernateIndex = hibernateBody.indexOf("void fullHibernateRuntime()");
 
   assert.notEqual(gateIndex, -1, "hibernate must check for inline images");

components/terminal/runtime/createTerminalSessionStarters.serial.test.ts

@@ -348,6 +348,62 @@ test("startSerial does not arm the fallback when auto-login is cancelled before
   assert.deepEqual(writtenCommands, []);
 });
 
+test("restored serial attach ignores a startup command hydrated while the port open is pending", async () => {
+  const writtenCommands: string[] = [];
+  let autoLoginComplete: ((evt: { sessionId: string }) => void) | null = null;
+  let releaseOpen: (() => void) | undefined;
+  const openPending = new Promise<void>((resolve) => {
+    releaseOpen = resolve;
+  });
+  const bootHost = {
+    id: "serial-1",
+    hostname: "/dev/ttyUSB0",
+    protocol: "serial" as const,
+    username: "admin",
+    password: "secret",
+  };
+  const hostRef = { current: bootHost };
+
+  const backend = buildBackend({
+    startSerialSession: async () => {
+      await openPending;
+      return "serial-session";
+    },
+    onTelnetAutoLoginComplete: (
+      _sessionId: string,
+      cb: (evt: { sessionId: string }) => void,
+    ) => {
+      autoLoginComplete = cb;
+      return noop;
+    },
+    onTelnetAutoLoginCancelled: () => noop,
+    writeToSession: (_sessionId: string, data: string) => {
+      writtenCommands.push(data);
+    },
+  });
+
+  const ctx = buildCtx(backend, {
+    host: bootHost,
+    hostRef,
+    terminalSettings: { startupCommandDelayMs: 0 },
+  });
+
+  const started = createTerminalSessionStarters(ctx as never).startSerial(term as never);
+  // Vault hydration can replace the fallback host after preflight has already
+  // decided there is no command to hold for auto-login.
+  hostRef.current = { ...bootHost, startupCommand: "show version" };
+  releaseOpen?.();
+  await started;
+
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  autoLoginComplete?.({ sessionId: "session-1" });
+  await new Promise((resolve) => setTimeout(resolve, 0));
+
+  assert.equal(autoLoginComplete, null);
+  assert.equal(ctx.hasRunStartupCommandRef.current, false);
+  assert.deepEqual(writtenCommands, []);
+});
+
 for (const runMode of ['paste', 'lineDelay', 'noAutoRun']) {
   test(`serial reconnect discards the previous delayed startup command (${runMode})`, async (t) => {
     t.mock.timers.enable({ apis: ['setTimeout'] });
@@ -417,3 +473,19 @@ for (const sleepBeforeCompletion of [true, false]) {
     assert.deepEqual(writes, ['show version\r']);
   });
 }
+
+test("named pipe sessions preserve the endpoint and omit hardware baud information", async () => {
+  const pipePath = String.raw`\\.\pipe\vm-console`;
+  const output: string[] = [];
+  let capturedPath: unknown;
+  const backend = buildBackend({ startSerialSession: async (options: Record<string, unknown>) => {
+    capturedPath = options.path;
+    return "pipe-session";
+  } });
+  const ctx = buildCtx(backend);
+  ctx.serialConfig.path = pipePath;
+  await createTerminalSessionStarters(ctx as never).startSerial({ ...term, write: (line: string, done?: () => void) => { output.push(line); done?.(); } } as never);
+  assert.equal(capturedPath, pipePath);
+  assert.ok(output.some((line) => line.includes(`[Connected to ${pipePath}]`)));
+  assert.ok(output.every((line) => !line.includes('baud')));
+});