feat(shortcuts): Ctrl+W closes the tab directly + add configurable side-panel toggle (#1098 )

* feat(shortcuts): add resolveSidePanelToggleIntent pure resolver * feat(shortcuts): Ctrl+W closes the tab directly (drop side-panel priority) Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com> * feat(shortcuts): register toggle-side-panel binding (default ⌘/Ctrl+\) * feat(shortcuts): add side-panel toggle handler + last-panel memory in TerminalLayer * feat(shortcuts): dispatch toggleSidePanel hotkey to TerminalLayer --------- Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>
feat(autocomplete): make snippets a first-class terminal completion source (#1097 )
2026-05-26 02:42:41 +08:00 · 2026-05-26 02:03:33 +08:00 · 2026-05-26 00:47:00 +08:00 · 2026-05-25 23:59:48 +08:00 · 2026-05-25 22:20:45 +08:00 · 2026-05-25 15:19:27 +08:00
208 changed files with 16975 additions and 2323 deletions
--- a/App.tsx
+++ b/App.tsx
@@ -28,7 +28,12 @@ import { upsertKnownHost } from './domain/knownHosts';
 import { materializeHostProxyProfile } from './domain/proxyProfiles';
 import { resolveHostAuth } from './domain/sshAuth';
 import { isEncryptedCredentialPlaceholder } from './domain/credentials';
-import { applyCustomAccentToTerminalTheme, resolveHostTerminalThemeId } from './domain/terminalAppearance';
+import {
+  applyCustomAccentToTerminalTheme,
+  mergeTerminalHostUpdate,
+  resolveHostTerminalThemeId,
+} from './domain/terminalAppearance';
+import { selectConnectionLogForTerminalDataCapture } from './domain/connectionLog';
 import { collectSessionIds } from './domain/workspace';
 import { resolveCloseIntent } from './application/state/resolveCloseIntent';
 import { resolveSnippetsShortcutIntent } from './application/state/resolveSnippetsShortcutIntent';
@@ -177,12 +182,22 @@ const TerminalLayerMount: React.FC<TerminalLayerProps> = (props) => {

  useEffect(() => {
    if (shouldMount) return;
-    // Warm up the terminal layer shortly after first paint to reduce latency when opening a session.
-    const id = window.setTimeout(() => setShouldMount(true), 1200);
+    type IdleWindow = Window & {
+      requestIdleCallback?: (callback: () => void, options?: { timeout: number }) => number;
+      cancelIdleCallback?: (id: number) => void;
+    };
+    const idleWindow = window as IdleWindow;
+    if (typeof idleWindow.requestIdleCallback === "function") {
+      const id = idleWindow.requestIdleCallback(() => setShouldMount(true), { timeout: 5000 });
+      return () => idleWindow.cancelIdleCallback?.(id);
+    }
+    const id = window.setTimeout(() => setShouldMount(true), 5000);
    return () => window.clearTimeout(id);
  }, [shouldMount]);

-  if (!shouldMount) return null;
+  const shouldRender = shouldMount || isVisible;
+
+  if (!shouldRender) return null;

  return (
    <Suspense fallback={null}>
@@ -346,6 +361,7 @@ function App({ settings }: { settings: SettingsState }) {
    splitSession,
    toggleWorkspaceViewMode,
    setWorkspaceFocusedSession,
+    reorderWorkspaceSessions,
    moveFocusInWorkspace,
    runSnippet,
    orphanSessions,
@@ -1181,12 +1197,11 @@ function App({ settings }: { settings: SettingsState }) {
  const addConnectionLogRef = useRef(addConnectionLog);
  addConnectionLogRef.current = addConnectionLog;

-  const closeSidePanelRef = useRef<(() => void) | null>(null);
  const toggleScriptsSidePanelRef = useRef<(() => void) | null>(null);
+  const toggleSidePanelRef = useRef<(() => void) | null>(null);
  // Populated below so the hotkey dispatcher can open the Settings window
  // even though `handleOpenSettings` is declared further down in the file.
  const handleOpenSettingsRef = useRef<() => void>(() => {});
-  const activeSidePanelTabRef = useRef<string | null>(null);
  const closeTabInFlightRef = useRef(false);
  // Populated by UnsavedChangesProvider render-prop below so that the hotkey
  // dispatcher (defined outside that scope) can still reach the dirty-confirm
@@ -1366,13 +1381,11 @@ function App({ settings }: { settings: SettingsState }) {
        const workspace = workspaces.find((w) => w.id === currentId) ?? null;

        const focusIsInsideTerminal = !!document.activeElement?.closest('[data-session-id]');
-        const activeSidePanel = activeSidePanelTabRef.current;

        const intent = resolveCloseIntent({
          activeTabId: currentId,
          workspace: workspace ? { id: workspace.id, focusedSessionId: workspace.focusedSessionId } : null,
          sessionForTab: session,
-          activeSidePanelTab: activeSidePanel,
          focusIsInsideTerminal,
        });

@@ -1386,10 +1399,6 @@ function App({ settings }: { settings: SettingsState }) {
                if (ok) closeSession(intent.sessionId);
                return;
              }
-              case 'closeSidePanel': {
-                closeSidePanelRef.current?.();
-                return;
-              }
              case 'closeWorkspace': {
                const ids = sessions.filter((s) => s.workspaceId === intent.workspaceId).map((s) => s.id);
                const ok = await confirmIfBusyLocalTerminal(ids);
@@ -1465,6 +1474,9 @@ function App({ settings }: { settings: SettingsState }) {
          setNavigateToSection('snippets');
        }
        break;
+      case 'toggleSidePanel':
+        toggleSidePanelRef.current?.();
+        break;
      case 'broadcast': {
        // Toggle broadcast mode for the active workspace
        const currentId = activeTabStore.getActiveTabId();
@@ -1715,6 +1727,12 @@ function App({ settings }: { settings: SettingsState }) {
    }
  }, [updateSessionStatus, updateHostLastConnected]);

+  const handleUpdateHostFromTerminal = useCallback((host: Host) => {
+    updateHosts(hosts.map((h) => (
+      h.id === host.id ? mergeTerminalHostUpdate(h, host) : h
+    )));
+  }, [hosts, updateHosts]);
+
  // Wrapper to create serial session with logging
  const handleConnectSerial = useCallback((config: SerialConfig, options?: { charset?: string }) => {
    const { username, hostname } = systemInfoRef.current;
@@ -1741,15 +1759,10 @@ function App({ settings }: { settings: SettingsState }) {
    if (IS_DEV) console.log('[handleTerminalDataCapture] Session', session);
    if (IS_DEV) console.log('[handleTerminalDataCapture] All logs:', connectionLogs.map(l => ({ id: l.id, sessionId: l.sessionId, hostname: l.hostname, endTime: l.endTime, hasTerminalData: !!l.terminalData })));

-    // Prefer the persisted sessionId because the session may already have been
-    // removed from state by the time the terminal unmount cleanup runs.
-    const matchingLog = connectionLogs
-      .filter((log) => {
-        if (log.endTime || log.terminalData) return false;
-        if (log.sessionId) return log.sessionId === sessionId;
-        return !!session && log.hostname === session.hostname;
-      })
-      .sort((a, b) => b.startTime - a.startTime)[0];
+    const matchingLog = selectConnectionLogForTerminalDataCapture(
+      connectionLogs,
+      { sessionId, hostname: session?.hostname },
+    );

    if (IS_DEV) console.log('[handleTerminalDataCapture] Matching log', matchingLog);

@@ -2011,7 +2024,7 @@ function App({ settings }: { settings: SettingsState }) {
            shellHistory={shellHistory}
            connectionLogs={connectionLogs}
            managedSources={managedSources}
-            sessions={sessions}
+            sessionCount={sessions.length}
            hotkeyScheme={hotkeyScheme}
            keyBindings={keyBindings}
            terminalThemeId={terminalThemeId}
@@ -2099,7 +2112,7 @@ function App({ settings }: { settings: SettingsState }) {
          onCloseSession={closeSession}
          onUpdateSessionStatus={handleSessionStatusChange}
          onUpdateHostDistro={updateHostDistro}
-          onUpdateHost={(host) => updateHosts(hosts.map(h => h.id === host.id ? host : h))}
+          onUpdateHost={handleUpdateHostFromTerminal}
          onAddKnownHost={handleAddKnownHost}
          onCommandExecuted={(command, hostId, hostLabel, sessionId) => {
            addShellHistoryEntry({ command, hostId, hostLabel, sessionId });
@@ -2114,6 +2127,7 @@ function App({ settings }: { settings: SettingsState }) {
          onSetDraggingSessionId={setDraggingSessionId}
          onToggleWorkspaceViewMode={toggleWorkspaceViewMode}
          onSetWorkspaceFocusedSession={setWorkspaceFocusedSession}
+          onReorderWorkspaceSessions={reorderWorkspaceSessions}
          onSplitSession={splitSessionWithCurrentShell}
          isBroadcastEnabled={isBroadcastEnabled}
          onToggleBroadcast={toggleBroadcast}
@@ -2129,9 +2143,8 @@ function App({ settings }: { settings: SettingsState }) {
          sessionLogsEnabled={sessionLogsEnabled}
          sessionLogsDir={sessionLogsDir}
          sessionLogsFormat={sessionLogsFormat}
-          closeSidePanelRef={closeSidePanelRef}
          toggleScriptsSidePanelRef={toggleScriptsSidePanelRef}
-          activeSidePanelTabRef={activeSidePanelTabRef}
+          toggleSidePanelRef={toggleSidePanelRef}
        />

        {/* Log Views - readonly terminal replays */}
--- a/application/i18n/locales/en.ts
+++ b/application/i18n/locales/en.ts
@@ -264,6 +264,10 @@ const en: Messages = {
  'settings.terminal.theme.selectButton': 'Select Theme',
  'settings.terminal.theme.followApp': 'Follow Application Theme',
  'settings.terminal.theme.followApp.desc': 'Automatically match the terminal background to the current app theme for a seamless look.',
+  'settings.terminal.theme.darkTheme': 'Dark mode terminal theme',
+  'settings.terminal.theme.lightTheme': 'Light mode terminal theme',
+  'settings.terminal.theme.auto': 'Auto (match app theme)',
+  'settings.terminal.theme.autoDesc': 'Follows the active UI theme preset',
  'settings.terminal.section.font': 'Font',
  'settings.terminal.section.cursor': 'Cursor',
  'settings.terminal.section.keyboard': 'Keyboard',
@@ -301,6 +305,9 @@ const en: Messages = {
  'settings.terminal.keyboard.altAsMeta': 'Use Option as Meta key',
  'settings.terminal.keyboard.altAsMeta.desc':
    'Use Option (Alt) as the Meta key instead of for special characters',
+  'settings.terminal.keyboard.optionArrowWordJump': 'Option+←/→ jumps by word',
+  'settings.terminal.keyboard.optionArrowWordJump.desc':
+    'Send Meta-b / Meta-f on Option+Left/Right so the shell moves by word, instead of the default ^[[1;3D / ^[[1;3C',
  'settings.terminal.accessibility.minimumContrastRatio': 'Minimum contrast ratio',
  'settings.terminal.accessibility.minimumContrastRatio.desc':
    'Adjust colors to meet contrast requirements (1 = disabled, 21 = max)',
@@ -323,6 +330,9 @@ const en: Messages = {
  'settings.terminal.behavior.preserveSelectionOnInput': 'Keep selection while typing',
  'settings.terminal.behavior.preserveSelectionOnInput.desc':
    'Don\'t clear mouse-selected text when typing — useful for selecting a path then pasting it after a command prefix like `sz `.',
+  'settings.terminal.behavior.forcePromptNewLine': 'Prompt on a new line',
+  'settings.terminal.behavior.forcePromptNewLine.desc':
+    'When the final line of command output is not terminated by a newline, move the recognized shell prompt to the next visual line.',
  'settings.terminal.behavior.osc52Clipboard': 'OSC-52 clipboard',
  'settings.terminal.behavior.osc52Clipboard.desc':
    'Allow remote programs (tmux, vim, etc.) to access the local clipboard via OSC-52 escape sequences.',
@@ -356,6 +366,9 @@ const en: Messages = {
  'settings.terminal.behavior.linkModifier.meta': 'Cmd / Win',
  'settings.terminal.scrollback.desc': 'Limit number of terminal rows. Set to 0 for no limit.',
  'settings.terminal.scrollback.rows': 'Number of rows *',
+  'settings.terminal.section.startupCommand': 'Startup command',
+  'settings.terminal.startupCommandDelay.label': 'Startup command delay (ms)',
+  'settings.terminal.startupCommandDelay.desc': 'How long to wait after connecting before sending the startup command. Also used between lines when the startup command has multiple lines. Increase for slow connections.',
  'settings.terminal.keywordHighlight.title': 'Keyword highlighting',
  'settings.terminal.keywordHighlight.resetColors': 'Reset to default colors',
  'settings.terminal.keywordHighlight.resetDefaults': 'Reset built-ins to defaults',
@@ -819,6 +832,11 @@ const en: Messages = {
  'sftp.transfers.collapseChildList': 'Hide',
  'sftp.transfers.retryAction': 'Retry',
  'sftp.transfers.dismissAction': 'Dismiss',
+  'sftp.transfers.openTargetFolder': 'Open target folder',
+  'sftp.transfers.openTargetFolderError': 'Could not open target folder',
+  'sftp.transfers.copyTargetPath': 'Copy target path',
+  'sftp.transfers.copyTargetPathSuccess': 'Target path copied',
+  'sftp.transfers.copyTargetPathError': 'Could not copy target path',
  'sftp.transfers.resizeNameColumn': 'Resize file name column',
  'sftp.transfers.dragToResize': 'Drag to resize',
  'sftp.goUp': 'Go up',
@@ -1323,6 +1341,7 @@ const en: Messages = {
  'terminal.menu.paste': 'Paste',
  'terminal.menu.pasteSelection': 'Paste Selection',
  'terminal.menu.selectAll': 'Select All',
+  'terminal.menu.reconnect': 'Reconnect',
  'terminal.menu.splitHorizontal': 'Split Horizontal',
  'terminal.menu.splitVertical': 'Split Vertical',
  'terminal.menu.clearBuffer': 'Clear Buffer',
@@ -1926,13 +1945,20 @@ const en: Messages = {

  // AI Claude Code
  'ai.claude.title': 'Claude Code',
-  'ai.claude.description': "Anthropic's agentic coding assistant. Uses claude-agent-acp for ACP protocol streaming.",
+  'ai.claude.description': "Anthropic's agentic coding assistant. Requires the system Claude Code CLI.",
  'ai.claude.detecting': 'Detecting...',
  'ai.claude.detected': 'Detected',
  'ai.claude.notFound': 'Not found',
  'ai.claude.path': 'Path:',
  'ai.claude.notFoundHint': 'Could not find claude in PATH. Install it or specify the executable path below.',
  'ai.claude.customPathPlaceholder': 'e.g. /usr/local/bin/claude',
+  'ai.claude.configSection': 'Authentication & config (optional)',
+  'ai.claude.configDir': 'Config directory',
+  'ai.claude.configDir.placeholder': '~/.claude (leave blank for default)',
+  'ai.claude.configDir.hint': 'Sets CLAUDE_CONFIG_DIR — point at a folder where you have run `claude` login (contains settings.json + credentials).',
+  'ai.claude.envVars': 'Environment variables',
+  'ai.claude.envVars.placeholder': 'ANTHROPIC_BASE_URL=https://...\nANTHROPIC_MODEL=...',
+  'ai.claude.envVars.hint': 'One KEY=VALUE per line, passed to the Claude agent. Stored locally in plaintext — for API keys / credentials, prefer the config directory above (a `claude` login).',
  'ai.claude.check': 'Check',

  // AI GitHub Copilot CLI
@@ -2083,6 +2109,11 @@ const en: Messages = {
  'zmodem.uploading': 'Uploading',
  'zmodem.downloading': 'Downloading',
  'zmodem.cancelTransfer': 'Cancel transfer (Ctrl+C)',
+  'zmodem.overwrite.title': 'Remote file already exists',
+  'zmodem.overwrite.applyToRest': 'Apply to remaining conflicts',
+  'zmodem.overwrite.overwrite': 'Overwrite',
+  'zmodem.overwrite.skip': 'Skip',
+  'zmodem.overwrite.cancel': 'Cancel',
  'settings.shortcuts.resetToDefault': 'Reset to default',
 };

--- a/application/i18n/locales/ru.ts
+++ b/application/i18n/locales/ru.ts
--- a/application/i18n/locales/zh-CN.ts
+++ b/application/i18n/locales/zh-CN.ts
@@ -586,6 +586,11 @@ const zhCN: Messages = {
  'sftp.transfers.collapseChildList': '收起',
  'sftp.transfers.retryAction': '重试',
  'sftp.transfers.dismissAction': '移除',
+  'sftp.transfers.openTargetFolder': '打开目标目录',
+  'sftp.transfers.openTargetFolderError': '无法打开目标目录',
+  'sftp.transfers.copyTargetPath': '复制目标路径',
+  'sftp.transfers.copyTargetPathSuccess': '已复制目标路径',
+  'sftp.transfers.copyTargetPathError': '无法复制目标路径',
  'sftp.transfers.resizeNameColumn': '调整文件名列宽',
  'sftp.transfers.dragToResize': '拖拽调整高度',
  'sftp.goUp': '上一级',
@@ -900,6 +905,7 @@ const zhCN: Messages = {
  'terminal.menu.paste': '粘贴',
  'terminal.menu.pasteSelection': '粘贴选中文本',
  'terminal.menu.selectAll': '全选',
+  'terminal.menu.reconnect': '重新连接',
  'terminal.menu.splitHorizontal': '水平分屏',
  'terminal.menu.splitVertical': '垂直分屏',
  'terminal.menu.clearBuffer': '清空缓冲区',
@@ -1403,6 +1409,10 @@ const zhCN: Messages = {
  'settings.terminal.theme.selectButton': '选择主题',
  'settings.terminal.theme.followApp': '跟随应用主题',
  'settings.terminal.theme.followApp.desc': '终端背景色自动匹配当前应用主题，保持视觉一致性。',
+  'settings.terminal.theme.darkTheme': '深色模式终端主题',
+  'settings.terminal.theme.lightTheme': '浅色模式终端主题',
+  'settings.terminal.theme.auto': '自动（跟随界面主题）',
+  'settings.terminal.theme.autoDesc': '跟随当前界面主题预设',
  'settings.terminal.section.font': '字体',
  'settings.terminal.section.cursor': '光标',
  'settings.terminal.section.keyboard': '键盘',
@@ -1439,6 +1449,8 @@ const zhCN: Messages = {
  'settings.terminal.cursor.blink': '光标闪烁',
  'settings.terminal.keyboard.altAsMeta': '将 Option 作为 Meta 键',
  'settings.terminal.keyboard.altAsMeta.desc': '使用 Option (Alt) 作为 Meta 键，而不是用于输入特殊字符',
+  'settings.terminal.keyboard.optionArrowWordJump': 'Option+←/→ 按单词跳转',
+  'settings.terminal.keyboard.optionArrowWordJump.desc': '按 Option+左/右 时发送 Meta-b / Meta-f，让 Shell 按单词移动光标（而非默认的 ^[[1;3D / ^[[1;3C）',
  'settings.terminal.accessibility.minimumContrastRatio': '最小对比度',
  'settings.terminal.accessibility.minimumContrastRatio.desc': '调整颜色以满足对比度要求 (1 = 禁用, 21 = 最大)',
  'settings.terminal.behavior.rightClick': '右键行为',
@@ -1459,6 +1471,9 @@ const zhCN: Messages = {
  'settings.terminal.behavior.preserveSelectionOnInput': '输入时保留选区',
  'settings.terminal.behavior.preserveSelectionOnInput.desc':
    '键盘输入时不清除鼠标选中的文本，方便选中路径后输入 `sz ` 之类命令再粘贴。',
+  'settings.terminal.behavior.forcePromptNewLine': '提示符另起一行',
+  'settings.terminal.behavior.forcePromptNewLine.desc':
+    '当命令输出的最后一行未以换行符结束时，将识别到的 shell 提示符移动到下一行显示。',
  'settings.terminal.behavior.osc52Clipboard': 'OSC-52 剪贴板',
  'settings.terminal.behavior.osc52Clipboard.desc':
    '允许远程程序（tmux、vim 等）通过 OSC-52 转义序列访问本地剪贴板。',
@@ -1488,6 +1503,9 @@ const zhCN: Messages = {
  'settings.terminal.behavior.linkModifier.meta': 'Cmd / Win',
  'settings.terminal.scrollback.desc': '限制终端行数。设为 0 表示不限制。',
  'settings.terminal.scrollback.rows': '行数 *',
+  'settings.terminal.section.startupCommand': '启动命令',
+  'settings.terminal.startupCommandDelay.label': '启动命令延迟（毫秒）',
+  'settings.terminal.startupCommandDelay.desc': '连接建立后等待多久再发送启动命令；启动命令为多行时，行与行之间也使用该间隔。慢连接可调大。',
  'settings.terminal.keywordHighlight.title': '关键字高亮',
  'settings.terminal.keywordHighlight.resetColors': '重置为默认颜色',
  'settings.terminal.keywordHighlight.resetDefaults': '把内置规则恢复为默认',
@@ -1588,6 +1606,7 @@ const zhCN: Messages = {
  'settings.shortcuts.binding.new-workspace': '新建工作区',
  'settings.shortcuts.binding.snippets': '打开代码片段',
  'settings.shortcuts.binding.broadcast': '切换广播模式',
+  'settings.shortcuts.binding.toggle-side-panel': '切换侧边栏',
  'settings.shortcuts.binding.sftp-copy': '复制文件',
  'settings.shortcuts.binding.sftp-cut': '剪切文件',
  'settings.shortcuts.binding.sftp-paste': '粘贴文件',
@@ -1935,13 +1954,20 @@ const zhCN: Messages = {

  // AI Claude Code
  'ai.claude.title': 'Claude Code',
-  'ai.claude.description': 'Anthropic 的智能编程助手。使用 claude-agent-acp 进行 ACP 协议流式传输。',
+  'ai.claude.description': 'Anthropic 的智能编程助手。需要系统中已安装 Claude Code CLI。',
  'ai.claude.detecting': '检测中...',
  'ai.claude.detected': '已检测到',
  'ai.claude.notFound': '未找到',
  'ai.claude.path': '路径：',
  'ai.claude.notFoundHint': '在 PATH 中未找到 claude。请安装或在下方指定可执行文件路径。',
  'ai.claude.customPathPlaceholder': '例如 /usr/local/bin/claude',
+  'ai.claude.configSection': '认证与配置（可选）',
+  'ai.claude.configDir': '配置目录',
+  'ai.claude.configDir.placeholder': '~/.claude（留空用默认）',
+  'ai.claude.configDir.hint': '设置 CLAUDE_CONFIG_DIR —— 指向你已运行 `claude` 登录的目录（含 settings.json 和凭据）。',
+  'ai.claude.envVars': '环境变量',
+  'ai.claude.envVars.placeholder': 'ANTHROPIC_BASE_URL=https://...\nANTHROPIC_MODEL=...',
+  'ai.claude.envVars.hint': '每行一个 KEY=VALUE，传给 Claude agent。明文存在本地——API key／凭据建议用上面的「配置目录」（claude 登录），不要放这里。',
  'ai.claude.check': '检查',

  // AI GitHub Copilot CLI
@@ -2092,6 +2118,11 @@ const zhCN: Messages = {
  'zmodem.uploading': '上传中',
  'zmodem.downloading': '下载中',
  'zmodem.cancelTransfer': '取消传输 (Ctrl+C)',
+  'zmodem.overwrite.title': '远端已存在同名文件',
+  'zmodem.overwrite.applyToRest': '应用到其余冲突文件',
+  'zmodem.overwrite.overwrite': '覆盖',
+  'zmodem.overwrite.skip': '跳过',
+  'zmodem.overwrite.cancel': '取消',
  'settings.shortcuts.resetToDefault': '重置为默认',
 };

--- a/application/i18n/messages.ts
+++ b/application/i18n/messages.ts
@@ -1,11 +1,13 @@
 import en, { type Messages } from './locales/en';
 import zhCN from './locales/zh-CN';
+import ru from './locales/ru';

 // Keep keys stable; add new locales by adding another import and map entry.
 export { type Messages };

 export const MESSAGES_BY_LOCALE: Record<string, Messages> = {
  en,
+  ru,
  'zh-CN': zhCN,
 };

--- a/application/state/activeTabStore.ts
+++ b/application/state/activeTabStore.ts
@@ -1,4 +1,4 @@
-import { useCallback,useSyncExternalStore } from 'react';
+import { useCallback, useSyncExternalStore } from 'react';

 // Simple store for active tab that allows fine-grained subscriptions
 type Listener = () => void;
@@ -92,7 +92,11 @@ export const useIsEditorTabActive = (tabId: string): boolean => {
 // Check if terminal layer should be visible
 // Editor tabs are NOT terminal tabs, so exclude them from the visibility condition.
 export const useIsTerminalLayerVisible = (draggingSessionId: string | null) => {
-  const activeTabId = useActiveTabId();
-  const isTerminalTab = activeTabId !== 'vault' && activeTabId !== 'sftp' && !isEditorTabId(activeTabId);
-  return isTerminalTab || !!draggingSessionId;
+  const getSnapshot = useCallback(() => {
+    const activeTabId = activeTabStore.getActiveTabId();
+    const isTerminalTab = activeTabId !== 'vault' && activeTabId !== 'sftp' && !isEditorTabId(activeTabId);
+    return isTerminalTab || !!draggingSessionId;
+  }, [draggingSessionId]);
+
+  return useSyncExternalStore(activeTabStore.subscribe, getSnapshot);
 };
--- a/application/state/autoSyncRemoteSchedule.test.ts
+++ b/application/state/autoSyncRemoteSchedule.test.ts
@@ -0,0 +1,111 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  getRuntimeRemoteCheckIntervalMs,
+  shouldRunRuntimeRemoteCheck,
+} from './autoSyncRemoteSchedule';
+
+test("runtime remote checks wait for the startup check to finish", () => {
+  assert.equal(
+    shouldRunRuntimeRemoteCheck({
+      hasAnyConnectedProvider: true,
+      autoSyncEnabled: true,
+      isUnlocked: true,
+      startupRemoteCheckDone: false,
+      isSyncing: false,
+      isSyncRunning: false,
+      remoteCheckInFlight: false,
+      now: 10_000,
+      lastRemoteCheckAt: null,
+      minIntervalMs: 30_000,
+    }),
+    false,
+  );
+});
+
+test("runtime remote checks run immediately after startup gate opens", () => {
+  assert.equal(
+    shouldRunRuntimeRemoteCheck({
+      hasAnyConnectedProvider: true,
+      autoSyncEnabled: true,
+      isUnlocked: true,
+      startupRemoteCheckDone: true,
+      isSyncing: false,
+      isSyncRunning: false,
+      remoteCheckInFlight: false,
+      now: 10_000,
+      lastRemoteCheckAt: null,
+      minIntervalMs: 30_000,
+    }),
+    true,
+  );
+});
+
+test("runtime remote checks respect the minimum interval", () => {
+  const common = {
+    hasAnyConnectedProvider: true,
+    autoSyncEnabled: true,
+    isUnlocked: true,
+    startupRemoteCheckDone: true,
+    isSyncing: false,
+    isSyncRunning: false,
+    remoteCheckInFlight: false,
+    minIntervalMs: 30_000,
+  };
+
+  assert.equal(
+    shouldRunRuntimeRemoteCheck({
+      ...common,
+      now: 35_000,
+      lastRemoteCheckAt: 10_000,
+    }),
+    false,
+  );
+  assert.equal(
+    shouldRunRuntimeRemoteCheck({
+      ...common,
+      now: 40_000,
+      lastRemoteCheckAt: 10_000,
+    }),
+    true,
+  );
+});
+
+test("forced runtime remote checks bypass only the interval gate", () => {
+  const common = {
+    hasAnyConnectedProvider: true,
+    autoSyncEnabled: true,
+    isUnlocked: true,
+    startupRemoteCheckDone: true,
+    isSyncing: false,
+    isSyncRunning: false,
+    remoteCheckInFlight: false,
+    minIntervalMs: 30_000,
+    force: true,
+  };
+
+  assert.equal(
+    shouldRunRuntimeRemoteCheck({
+      ...common,
+      now: 35_000,
+      lastRemoteCheckAt: 10_000,
+    }),
+    true,
+  );
+  assert.equal(
+    shouldRunRuntimeRemoteCheck({
+      ...common,
+      isSyncing: true,
+      now: 35_000,
+      lastRemoteCheckAt: 10_000,
+    }),
+    false,
+  );
+});
+
+test("configured auto-sync intervals map to bounded remote recheck intervals", () => {
+  assert.equal(getRuntimeRemoteCheckIntervalMs(1), 30_000);
+  assert.equal(getRuntimeRemoteCheckIntervalMs(10), 300_000);
+  assert.equal(getRuntimeRemoteCheckIntervalMs(120), 300_000);
+});
--- a/application/state/autoSyncRemoteSchedule.ts
+++ b/application/state/autoSyncRemoteSchedule.ts
@@ -0,0 +1,35 @@
+const MIN_RUNTIME_REMOTE_CHECK_MS = 30_000;
+const MAX_RUNTIME_REMOTE_CHECK_MS = 5 * 60_000;
+
+export function getRuntimeRemoteCheckIntervalMs(autoSyncIntervalMinutes: number): number {
+  const configuredMs = Math.max(1, Number(autoSyncIntervalMinutes) || 1) * 60_000;
+  return Math.max(
+    MIN_RUNTIME_REMOTE_CHECK_MS,
+    Math.min(MAX_RUNTIME_REMOTE_CHECK_MS, Math.floor(configuredMs / 2)),
+  );
+}
+
+export interface RuntimeRemoteCheckInput {
+  hasAnyConnectedProvider: boolean;
+  autoSyncEnabled: boolean;
+  isUnlocked: boolean;
+  startupRemoteCheckDone: boolean;
+  isSyncing: boolean;
+  isSyncRunning: boolean;
+  remoteCheckInFlight: boolean;
+  force?: boolean;
+  now: number;
+  lastRemoteCheckAt: number | null;
+  minIntervalMs: number;
+}
+
+export function shouldRunRuntimeRemoteCheck(input: RuntimeRemoteCheckInput): boolean {
+  if (!input.hasAnyConnectedProvider) return false;
+  if (!input.autoSyncEnabled) return false;
+  if (!input.isUnlocked) return false;
+  if (!input.startupRemoteCheckDone) return false;
+  if (input.isSyncing || input.isSyncRunning || input.remoteCheckInFlight) return false;
+  if (input.force === true) return true;
+  if (input.lastRemoteCheckAt == null) return true;
+  return input.now - input.lastRemoteCheckAt >= input.minIntervalMs;
+}
--- a/application/state/editorTabStore.ts
+++ b/application/state/editorTabStore.ts
@@ -244,16 +244,3 @@ export const useEditorTab = (id: EditorTabId): EditorTab | undefined => {
  const getSnapshot = useCallback(() => editorTabStore.getTab(id), [id]);
  return useSyncExternalStore(editorTabStore.subscribe, getSnapshot);
 };
-
-export const useEditorDirty = (id: EditorTabId): boolean => {
-  const getSnapshot = useCallback(() => editorTabStore.isDirty(id), [id]);
-  return useSyncExternalStore(editorTabStore.subscribe, getSnapshot);
-};
-
-export const useAnyEditorDirty = (): boolean => {
-  const getSnapshot = useCallback(
-    () => editorTabStore.getTabs().some((t) => t.content !== t.baselineContent),
-    [],
-  );
-  return useSyncExternalStore(editorTabStore.subscribe, getSnapshot);
-};
--- a/application/state/resolveCloseIntent.test.ts
+++ b/application/state/resolveCloseIntent.test.ts
@@ -3,33 +3,27 @@ import assert from "node:assert/strict";

 import { resolveCloseIntent } from "./resolveCloseIntent.ts";

-const baseWorkspace = {
-  id: "w1",
-  focusedSessionId: "s1",
-};
-
+const baseWorkspace = { id: "w1", focusedSessionId: "s1" };
 const baseSession = { id: "s1" };

 test("non-workspace tab → closeSingleTab with session id", () => {
-  const result = resolveCloseIntent({
+  const r = resolveCloseIntent({
    activeTabId: "s1",
    workspace: null,
    sessionForTab: baseSession,
-    activeSidePanelTab: null,
    focusIsInsideTerminal: true,
  });
-  assert.deepEqual(result, { kind: "closeSingleTab", sessionId: "s1" });
+  assert.deepEqual(r, { kind: "closeSingleTab", sessionId: "s1" });
 });

-test("non-workspace session tab + sidebar open → closeSidePanel (sidebar beats session close)", () => {
+test("non-workspace session tab → closeSingleTab even when focus is outside the terminal", () => {
  const r = resolveCloseIntent({
    activeTabId: "s1",
    workspace: null,
    sessionForTab: { id: "s1" },
-    activeSidePanelTab: "ai",
-    focusIsInsideTerminal: true, // focus IS in terminal, but sidebar wins
+    focusIsInsideTerminal: false,
  });
-  assert.deepEqual(r, { kind: "closeSidePanel" });
+  assert.deepEqual(r, { kind: "closeSingleTab", sessionId: "s1" });
 });

 test("vault/sftp tab → noop", () => {
@@ -37,74 +31,37 @@ test("vault/sftp tab → noop", () => {
    activeTabId: "vault",
    workspace: null,
    sessionForTab: null,
-    activeSidePanelTab: null,
    focusIsInsideTerminal: false,
  });
  assert.deepEqual(r, { kind: "noop" });
 });

-test("workspace + focus in terminal + sidebar open → closeSidePanel wins (sidebar beats focus)", () => {
+test("workspace + focus in terminal → closeTerminal (side panel no longer intercepts)", () => {
  const r = resolveCloseIntent({
    activeTabId: "w1",
    workspace: baseWorkspace,
    sessionForTab: null,
-    activeSidePanelTab: "ai",
-    focusIsInsideTerminal: true,
-  });
-  assert.deepEqual(r, { kind: "closeSidePanel" });
-});
-
-test("workspace + focus NOT in terminal + sidebar open → closeSidePanel", () => {
-  const r = resolveCloseIntent({
-    activeTabId: "w1",
-    workspace: baseWorkspace,
-    sessionForTab: null,
-    activeSidePanelTab: "sftp",
-    focusIsInsideTerminal: false,
-  });
-  assert.deepEqual(r, { kind: "closeSidePanel" });
-});
-
-test("workspace + sidebar closed + focus in terminal → closeTerminal", () => {
-  const r = resolveCloseIntent({
-    activeTabId: "w1",
-    workspace: baseWorkspace,
-    sessionForTab: null,
-    activeSidePanelTab: null,
    focusIsInsideTerminal: true,
  });
  assert.deepEqual(r, { kind: "closeTerminal", sessionId: "s1" });
 });

-test("workspace + sidebar closed + focus NOT in terminal → closeWorkspace", () => {
+test("workspace + focus NOT in terminal → closeWorkspace", () => {
  const r = resolveCloseIntent({
    activeTabId: "w1",
    workspace: baseWorkspace,
    sessionForTab: null,
-    activeSidePanelTab: null,
    focusIsInsideTerminal: false,
  });
  assert.deepEqual(r, { kind: "closeWorkspace", workspaceId: "w1" });
 });

-test("workspace with no focused session + sidebar closed → closeWorkspace", () => {
+test("workspace with no focused session → closeWorkspace", () => {
  const r = resolveCloseIntent({
    activeTabId: "w1",
    workspace: { id: "w1", focusedSessionId: undefined },
    sessionForTab: null,
-    activeSidePanelTab: null,
-    focusIsInsideTerminal: true, // even if flag true, no focused id → cannot closeTerminal
+    focusIsInsideTerminal: true,
  });
  assert.deepEqual(r, { kind: "closeWorkspace", workspaceId: "w1" });
 });
-
-test("workspace with no focused session + sidebar open → closeSidePanel", () => {
-  const r = resolveCloseIntent({
-    activeTabId: "w1",
-    workspace: { id: "w1", focusedSessionId: undefined },
-    sessionForTab: null,
-    activeSidePanelTab: "ai",
-    focusIsInsideTerminal: false,
-  });
-  assert.deepEqual(r, { kind: "closeSidePanel" });
-});
--- a/application/state/resolveCloseIntent.ts
+++ b/application/state/resolveCloseIntent.ts
@@ -1,6 +1,5 @@
 export type CloseIntent =
  | { kind: 'closeTerminal'; sessionId: string }
-  | { kind: 'closeSidePanel' }
  | { kind: 'closeWorkspace'; workspaceId: string }
  | { kind: 'closeSingleTab'; sessionId: string }
  | { kind: 'noop' };
@@ -9,22 +8,14 @@ export interface ResolveCloseInput {
  activeTabId: string | null;
  workspace: { id: string; focusedSessionId?: string } | null;
  sessionForTab: { id: string } | null;
-  activeSidePanelTab: string | null;
  focusIsInsideTerminal: boolean;
 }

 export function resolveCloseIntent(input: ResolveCloseInput): CloseIntent {
-  const { activeTabId, workspace, sessionForTab, activeSidePanelTab, focusIsInsideTerminal } = input;
+  const { activeTabId, workspace, sessionForTab, focusIsInsideTerminal } = input;

  if (!activeTabId) return { kind: 'noop' };

-  // Sidebar always wins — applies to any tab type (workspace, single-session, etc.).
-  // Modals take priority over this but are intercepted upstream in App.tsx before the
-  // hotkey reaches resolveCloseIntent.
-  if (activeSidePanelTab !== null) {
-    return { kind: 'closeSidePanel' };
-  }
-
  if (sessionForTab && !workspace) {
    return { kind: 'closeSingleTab', sessionId: sessionForTab.id };
  }
--- a/application/state/resolveSidePanelToggleIntent.test.ts
+++ b/application/state/resolveSidePanelToggleIntent.test.ts
@@ -0,0 +1,19 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { resolveSidePanelToggleIntent } from "./resolveSidePanelToggleIntent.ts";
+
+test("open: closed with a remembered tab → open that tab", () => {
+  const r = resolveSidePanelToggleIntent({ isOpen: false, lastTab: "sftp", fallbackTab: "scripts" });
+  assert.deepEqual(r, { kind: "open", tab: "sftp" });
+});
+
+test("open: closed with no memory → open the fallback tab", () => {
+  const r = resolveSidePanelToggleIntent({ isOpen: false, lastTab: null, fallbackTab: "scripts" });
+  assert.deepEqual(r, { kind: "open", tab: "scripts" });
+});
+
+test("close: already open → close", () => {
+  const r = resolveSidePanelToggleIntent({ isOpen: true, lastTab: "theme", fallbackTab: "sftp" });
+  assert.deepEqual(r, { kind: "close" });
+});
--- a/application/state/resolveSidePanelToggleIntent.ts
+++ b/application/state/resolveSidePanelToggleIntent.ts
@@ -0,0 +1,18 @@
+export type SidePanelToggleIntent<T extends string> =
+  | { kind: 'close' }
+  | { kind: 'open'; tab: T };
+
+/**
+ * Decide what the "toggle side panel" shortcut should do.
+ * - If a panel is open → close it.
+ * - If closed → reopen the last-shown sub-panel for the tab, falling back to
+ *   `fallbackTab` when the tab has no remembered panel.
+ */
+export function resolveSidePanelToggleIntent<T extends string>(input: {
+  isOpen: boolean;
+  lastTab: T | null;
+  fallbackTab: T;
+}): SidePanelToggleIntent<T> {
+  if (input.isOpen) return { kind: 'close' };
+  return { kind: 'open', tab: input.lastTab ?? input.fallbackTab };
+}
--- a/application/state/resolveTerminalSessionExitIntent.test.ts
+++ b/application/state/resolveTerminalSessionExitIntent.test.ts
@@ -0,0 +1,32 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { resolveTerminalSessionExitIntent } from "./resolveTerminalSessionExitIntent.ts";
+
+test("normal backend exited events close the session tab", () => {
+  assert.deepEqual(
+    resolveTerminalSessionExitIntent({ reason: "exited", exitCode: 0 }),
+    { kind: "closeSession" },
+  );
+});
+
+test("backend timeout events keep the tab and mark it disconnected", () => {
+  assert.deepEqual(
+    resolveTerminalSessionExitIntent({ reason: "timeout", error: "idle timeout" }),
+    { kind: "markDisconnected" },
+  );
+});
+
+test("backend error events keep the tab and mark it disconnected", () => {
+  assert.deepEqual(
+    resolveTerminalSessionExitIntent({ reason: "error", error: "connection reset" }),
+    { kind: "markDisconnected" },
+  );
+});
+
+test("backend closed events keep the tab and mark it disconnected", () => {
+  assert.deepEqual(
+    resolveTerminalSessionExitIntent({ reason: "closed", exitCode: 0 }),
+    { kind: "markDisconnected" },
+  );
+});
--- a/application/state/resolveTerminalSessionExitIntent.ts
+++ b/application/state/resolveTerminalSessionExitIntent.ts
@@ -0,0 +1,22 @@
+export type TerminalSessionExitEvent = {
+  exitCode?: number;
+  signal?: number;
+  error?: string;
+  reason?: "exited" | "error" | "timeout" | "closed";
+};
+
+export type TerminalSessionExitIntent =
+  | { kind: "closeSession" }
+  | { kind: "markDisconnected" };
+
+export function resolveTerminalSessionExitIntent(
+  evt: TerminalSessionExitEvent,
+): TerminalSessionExitIntent {
+  if (evt.reason === "exited") {
+    return { kind: "closeSession" };
+  }
+
+  // Timeouts, transport errors, and channel closes should keep the tab visible
+  // so the user can inspect output and reconnect.
+  return { kind: "markDisconnected" };
+}
--- a/application/state/sftp/bookmarkHelpers.ts
+++ b/application/state/sftp/bookmarkHelpers.ts
@@ -0,0 +1,23 @@
+import type { SftpBookmark } from "../../../domain/models";
+
+const ROOT_PATH_RE = /^[A-Za-z]:[\\/]?$/;
+
+export function getSftpBookmarkLabel(path: string): string {
+  const trimmed = path.trim();
+  if (trimmed === "/" || ROOT_PATH_RE.test(trimmed)) return trimmed;
+  return trimmed.split(/[\\/]/).filter(Boolean).pop() || trimmed;
+}
+
+export function createSftpBookmark(
+  path: string,
+  options: { global?: boolean; idPrefix?: string } = {},
+): SftpBookmark {
+  const global = options.global === true;
+  const idPrefix = options.idPrefix ?? (global ? "gbm" : "bm");
+  return {
+    id: `${idPrefix}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+    path,
+    label: getSftpBookmarkLabel(path),
+    ...(global ? { global: true } : {}),
+  };
+}
--- a/application/state/sftp/globalSftpBookmarks.ts
+++ b/application/state/sftp/globalSftpBookmarks.ts
@@ -0,0 +1,45 @@
+import type { SftpBookmark } from "../../../domain/models";
+import { STORAGE_KEY_SFTP_GLOBAL_BOOKMARKS } from "../../../infrastructure/config/storageKeys";
+import { localStorageAdapter } from "../../../infrastructure/persistence/localStorageAdapter";
+
+type Listener = () => void;
+
+const listeners = new Set<Listener>();
+
+let snapshot: SftpBookmark[] =
+  localStorageAdapter.read<SftpBookmark[]>(STORAGE_KEY_SFTP_GLOBAL_BOOKMARKS) ?? [];
+
+export function subscribeGlobalSftpBookmarks(listener: Listener) {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+export function getGlobalSftpBookmarksSnapshot() {
+  return snapshot;
+}
+
+export function rehydrateGlobalSftpBookmarks() {
+  snapshot = localStorageAdapter.read<SftpBookmark[]>(STORAGE_KEY_SFTP_GLOBAL_BOOKMARKS) ?? [];
+  for (const listener of listeners) listener();
+}
+
+export function setGlobalSftpBookmarks(
+  next: SftpBookmark[] | ((prev: SftpBookmark[]) => SftpBookmark[]),
+) {
+  snapshot = typeof next === "function" ? next(snapshot) : next;
+  localStorageAdapter.write(STORAGE_KEY_SFTP_GLOBAL_BOOKMARKS, snapshot);
+  for (const listener of listeners) listener();
+  if (typeof window !== "undefined") {
+    window.dispatchEvent(new CustomEvent("sftp-bookmarks-changed"));
+  }
+}
+
+if (typeof window !== "undefined") {
+  window.addEventListener("storage", (event) => {
+    if (event.key === STORAGE_KEY_SFTP_GLOBAL_BOOKMARKS) {
+      rehydrateGlobalSftpBookmarks();
+    }
+  });
+}
--- a/application/state/sftp/utils.test.ts
+++ b/application/state/sftp/utils.test.ts
@@ -0,0 +1,11 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { isConcreteTransferTargetPath } from "./utils";
+
+test("concrete transfer target paths exclude temporary placeholders", () => {
+  assert.equal(isConcreteTransferTargetPath({ targetPath: "/Users/alice/Downloads/report.pdf" }), true);
+  assert.equal(isConcreteTransferTargetPath({ targetPath: "C:\\Users\\alice\\Downloads\\report.pdf" }), true);
+  assert.equal(isConcreteTransferTargetPath({ targetPath: "(temp)" }), false);
+  assert.equal(isConcreteTransferTargetPath({ targetPath: "   " }), false);
+});
--- a/application/state/sftp/utils.ts
+++ b/application/state/sftp/utils.ts
@@ -1,4 +1,4 @@
-import { SftpFileEntry } from "../../../domain/models";
+import { SftpFileEntry, TransferTask } from "../../../domain/models";

 export const formatFileSize = (bytes: number): string => {
  if (bytes === 0) return "--";
@@ -76,6 +76,11 @@ export const getParentPath = (path: string): string => {
  return result;
 };

+export const isConcreteTransferTargetPath = (task: Pick<TransferTask, "targetPath">): boolean => {
+  const targetPath = task.targetPath.trim();
+  return targetPath.length > 0 && targetPath !== "(temp)";
+};
+
 export const getFileName = (path: string): string => {
  const parts = path.split(/[\\/]/).filter(Boolean);
  return parts[parts.length - 1] || "";
--- a/application/state/useAgentDiscovery.ts
+++ b/application/state/useAgentDiscovery.ts
@@ -52,14 +52,19 @@ export function useAgentDiscovery(
        );
        if (!match) return ea;

-        // Check if args or ACP config differ
+        // Check if args, ACP config, or Claude's resolved system path differ
        const currentArgs = JSON.stringify(ea.args || []);
        const newArgs = JSON.stringify(match.args);
        const acpChanged = ea.acpCommand !== match.acpCommand
          || JSON.stringify(ea.acpArgs || []) !== JSON.stringify(match.acpArgs || []);
-        if (currentArgs !== newArgs || acpChanged) {
+        const env = match.command === 'claude'
+          ? { ...(ea.env ?? {}), CLAUDE_CODE_EXECUTABLE: match.path }
+          : ea.env;
+        const envChanged = match.command === 'claude'
+          && ea.env?.CLAUDE_CODE_EXECUTABLE !== match.path;
+        if (currentArgs !== newArgs || acpChanged || envChanged) {
          changed = true;
-          return { ...ea, args: match.args, acpCommand: match.acpCommand, acpArgs: match.acpArgs };
+          return { ...ea, args: match.args, acpCommand: match.acpCommand, acpArgs: match.acpArgs, ...(env ? { env } : {}) };
        }
        return ea;
      });
@@ -86,6 +91,7 @@ export function useAgentDiscovery(
        enabled: true,
        acpCommand: agent.acpCommand,
        acpArgs: agent.acpArgs,
+        ...(agent.command === 'claude' ? { env: { CLAUDE_CODE_EXECUTABLE: agent.path } } : {}),
      };
    },
    [],
--- a/application/state/useAutoSync.ts
+++ b/application/state/useAutoSync.ts
@@ -16,14 +16,15 @@ import {
  findSyncPayloadEncryptedCredentialPaths,
 } from '../../domain/credentials';
 import { isProviderReadyForSync, type CloudProvider, type SyncPayload } from '../../domain/sync';
+import { mergeSyncPayloads } from '../../domain/syncMerge';
 import {
  SYNCABLE_SETTING_STORAGE_KEYS,
  collectSyncableSettings,
+  getEffectivePortForwardingRulesForSync,
  hasMeaningfulCloudSyncData,
 } from '../syncPayload';
 import { readInterruptedVaultApply } from '../localVaultBackups';
 import {
-  STORAGE_KEY_PORT_FORWARDING,
  STORAGE_KEY_VAULT_RESTORE_IN_PROGRESS_UNTIL,
 } from '../../infrastructure/config/storageKeys';
 import {
@@ -31,6 +32,10 @@ import {
  localStorageAdapter,
 } from '../../infrastructure/persistence/localStorageAdapter';
 import { notify } from '../notification';
+import {
+  getRuntimeRemoteCheckIntervalMs,
+  shouldRunRuntimeRemoteCheck,
+} from './autoSyncRemoteSchedule';

 interface AutoSyncConfig {
  // Data to sync
@@ -95,6 +100,11 @@ interface SyncNowOptions {
  trigger?: SyncTrigger;
 }

+interface RemoteVersionCheckOptions {
+  force?: boolean;
+  notifyOnFailure?: boolean;
+}
+
 export const useAutoSync = (config: AutoSyncConfig) => {
  const { t } = useI18n();
  const sync = useCloudSync();
@@ -156,21 +166,6 @@ export const useAutoSync = (config: AutoSyncConfig) => {
  }, []);

  const getSyncSnapshot = useCallback(() => {
-    let effectivePFRules = config.portForwardingRules;
-    if (!effectivePFRules || effectivePFRules.length === 0) {
-      const stored = localStorageAdapter.read<SyncPayload['portForwardingRules']>(
-        STORAGE_KEY_PORT_FORWARDING,
-      );
-      if (stored && Array.isArray(stored) && stored.length > 0) {
-        effectivePFRules = stored.map((rule) => ({
-          ...rule,
-          status: 'inactive' as const,
-          error: undefined,
-          lastUsedAt: undefined,
-        }));
-      }
-    }
-
    return {
      hosts: config.hosts,
      keys: config.keys,
@@ -179,7 +174,7 @@ export const useAutoSync = (config: AutoSyncConfig) => {
      snippets: config.snippets,
      customGroups: config.customGroups,
      snippetPackages: config.snippetPackages,
-      portForwardingRules: effectivePFRules,
+      portForwardingRules: getEffectivePortForwardingRulesForSync(config.portForwardingRules),
      groupConfigs: config.groupConfigs,
    };
  }, [
@@ -417,17 +412,20 @@ export const useAutoSync = (config: AutoSyncConfig) => {
  // windows but does NOT serialize same-window re-entry, so this
  // in-flight guard closes that gap at the top of the call.
  const checkRemoteInFlightRef = useRef(false);
+  const lastRuntimeRemoteCheckAtRef = useRef<number | null>(null);

  // Check remote version and pull if newer (on startup)
-  const checkRemoteVersion = useCallback(async () => {
+  const checkRemoteVersion = useCallback(async (options?: RemoteVersionCheckOptions) => {
    if (checkRemoteInFlightRef.current) {
      return;
    }
+    const force = options?.force === true;
+    const notifyOnFailure = options?.notifyOnFailure !== false;
    const state = manager.getState();
    const hasProvider = Object.values(state.providers).some((provider) => isProviderReadyForSync(provider));
    const unlocked = state.securityState === 'UNLOCKED';

-    if (!hasProvider || !unlocked || hasCheckedRemoteRef.current || startupReadyRef.current === false) {
+    if (!hasProvider || !unlocked || (!force && hasCheckedRemoteRef.current) || startupReadyRef.current === false) {
      return;
    }

@@ -509,7 +507,6 @@ export const useAutoSync = (config: AutoSyncConfig) => {
        return;
      }

-      const { mergeSyncPayloads } = await import('../../domain/syncMerge');
      const mergeResult = mergeSyncPayloads(base, localPayload, remotePayload);

      // Apply merged payload to local state BEFORE committing. If the apply
@@ -563,14 +560,16 @@ export const useAutoSync = (config: AutoSyncConfig) => {
      }
    } catch (error) {
      console.error('[AutoSync] Failed to check remote version:', error);
-      // Surface a degraded-sync hint to the user rather than silently
-      // opening the auto-sync gate. Auto-sync will still retry on next
-      // data change (see finally block), but without this toast the user
-      // has no visible signal that startup reconciliation failed.
-      notify.error(
-        t('sync.autoSync.inspectFailedMessage'),
-        t('sync.autoSync.inspectFailedTitle'),
-      );
+      if (notifyOnFailure) {
+        // Surface a degraded-sync hint to the user rather than silently
+        // opening the auto-sync gate. Auto-sync will still retry on next
+        // data change (see finally block), but without this toast the user
+        // has no visible signal that startup reconciliation failed.
+        notify.error(
+          t('sync.autoSync.inspectFailedMessage'),
+          t('sync.autoSync.inspectFailedTitle'),
+        );
+      }
      // Leave hasCheckedRemoteRef=false so the next startup (or the next
      // provider/unlock transition) can retry.
    } finally {
@@ -741,12 +740,86 @@ export const useAutoSync = (config: AutoSyncConfig) => {
      if (timerId) clearTimeout(timerId);
    };
  }, [sync.hasAnyConnectedProvider, sync.isUnlocked, config.startupReady, checkRemoteVersion]);
+
+  const runRuntimeRemoteCheck = useCallback(async (options?: { force?: boolean }) => {
+    const now = Date.now();
+    const minIntervalMs = getRuntimeRemoteCheckIntervalMs(sync.autoSyncInterval);
+    if (!shouldRunRuntimeRemoteCheck({
+      hasAnyConnectedProvider: sync.hasAnyConnectedProvider,
+      autoSyncEnabled: sync.autoSyncEnabled,
+      isUnlocked: sync.isUnlocked,
+      startupRemoteCheckDone: remoteCheckDoneRef.current,
+      isSyncing: sync.isSyncing,
+      isSyncRunning: isSyncRunningRef.current,
+      remoteCheckInFlight: checkRemoteInFlightRef.current,
+      force: options?.force === true,
+      now,
+      lastRemoteCheckAt: lastRuntimeRemoteCheckAtRef.current,
+      minIntervalMs,
+    })) {
+      return;
+    }
+
+    lastRuntimeRemoteCheckAtRef.current = now;
+    await checkRemoteVersion({ force: true, notifyOnFailure: false });
+  }, [
+    checkRemoteVersion,
+    sync.autoSyncEnabled,
+    sync.autoSyncInterval,
+    sync.hasAnyConnectedProvider,
+    sync.isSyncing,
+    sync.isUnlocked,
+  ]);
+
+  // Keep checking the cloud while the app is open. This closes the gap where
+  // another device uploads changes after our startup inspection but before
+  // this device edits anything locally.
+  useEffect(() => {
+    if (!sync.hasAnyConnectedProvider || !sync.autoSyncEnabled || !sync.isUnlocked) {
+      return;
+    }
+
+    const intervalMs = getRuntimeRemoteCheckIntervalMs(sync.autoSyncInterval);
+    const timerId = window.setInterval(() => {
+      void runRuntimeRemoteCheck();
+    }, intervalMs);
+
+    return () => window.clearInterval(timerId);
+  }, [
+    runRuntimeRemoteCheck,
+    sync.autoSyncEnabled,
+    sync.autoSyncInterval,
+    sync.hasAnyConnectedProvider,
+    sync.isUnlocked,
+  ]);
+
+  // Also re-check when the user returns to the app or the network comes back.
+  useEffect(() => {
+    if (typeof window === 'undefined' || typeof document === 'undefined') return;
+
+    const handleVisibilityChange = () => {
+      if (document.visibilityState === 'visible') {
+        void runRuntimeRemoteCheck({ force: true });
+      }
+    };
+    const handleOnline = () => {
+      void runRuntimeRemoteCheck({ force: true });
+    };
+
+    document.addEventListener('visibilitychange', handleVisibilityChange);
+    window.addEventListener('online', handleOnline);
+    return () => {
+      document.removeEventListener('visibilitychange', handleVisibilityChange);
+      window.removeEventListener('online', handleOnline);
+    };
+  }, [runRuntimeRemoteCheck]);
  
  // Reset check flags when provider disconnects
  useEffect(() => {
    if (!sync.hasAnyConnectedProvider) {
      hasCheckedRemoteRef.current = false;
      remoteCheckDoneRef.current = false;
+      lastRuntimeRemoteCheckAtRef.current = null;
    }
  }, [sync.hasAnyConnectedProvider]);

--- a/application/state/useGlobalHotkeys.ts
+++ b/application/state/useGlobalHotkeys.ts
@@ -1,41 +1,5 @@
-import { useCallback, useEffect, useRef } from 'react';
 import { KeyBinding, matchesKeyBinding } from '../../domain/models';

-interface HotkeyActions {
-  // Tab management
-  switchToTab: (tabIndex: number) => void;
-  nextTab: () => void;
-  prevTab: () => void;
-  closeTab: () => void;
-  newTab: () => void;
-  
-  // Navigation
-  openHosts: () => void;
-  openSftp: () => void;
-  quickSwitch: () => void;
-  newWorkspace: () => void;
-  commandPalette: () => void;
-  portForwarding: () => void;
-  snippets: () => void;
-  
-  // Terminal actions (handled per-terminal)
-  copy: () => void;
-  paste: () => void;
-  selectAll: () => void;
-  clearBuffer: () => void;
-  searchTerminal: () => void;
-  
-  // Workspace/split actions
-  splitHorizontal: () => void;
-  splitVertical: () => void;
-  moveFocus: (direction: 'up' | 'down' | 'left' | 'right') => void;
-  
-  // App features
-  broadcast: () => void;
-  openLocal: () => void;
-  openSettings: () => void;
-}
-
 // Check if keyboard event matches our app-level shortcuts
 // Returns the matched binding action or null
 export const checkAppShortcut = (
@@ -87,163 +51,3 @@ export const getTerminalPassthroughActions = (): Set<string> => {
    'searchTerminal',
  ]);
 };
-
-interface UseGlobalHotkeysOptions {
-  hotkeyScheme: 'disabled' | 'mac' | 'pc';
-  keyBindings: KeyBinding[];
-  actions: Partial<HotkeyActions>;
-  orderedTabs: string[];
-  sessions: { id: string }[];
-  workspaces: { id: string }[];
-  isSettingsOpen?: boolean;
-}
-
-export const useGlobalHotkeys = ({
-  hotkeyScheme,
-  keyBindings,
-  actions,
-  orderedTabs,
-  sessions,
-  workspaces,
-  isSettingsOpen = false,
-}: UseGlobalHotkeysOptions) => {
-  const actionsRef = useRef(actions);
-  actionsRef.current = actions;
-
-  const orderedTabsRef = useRef(orderedTabs);
-  orderedTabsRef.current = orderedTabs;
-
-  const sessionsRef = useRef(sessions);
-  sessionsRef.current = sessions;
-
-  const workspacesRef = useRef(workspaces);
-  workspacesRef.current = workspaces;
-
-  const handleGlobalKeyDown = useCallback((e: KeyboardEvent) => {
-    if (hotkeyScheme === 'disabled') return;
-    if (isSettingsOpen) return; // Don't handle hotkeys when settings is open
-
-    const isMac = hotkeyScheme === 'mac';
-    const appLevelActions = getAppLevelActions();
-
-    // Check if this is an app-level shortcut
-    const matched = checkAppShortcut(e, keyBindings, isMac);
-    if (!matched) return;
-
-    const { action, binding: _binding } = matched;
-
-    // Only handle app-level actions here
-    // Terminal-level actions are handled by the terminal itself
-    if (!appLevelActions.has(action)) return;
-
-    e.preventDefault();
-    e.stopPropagation();
-
-    const currentActions = actionsRef.current;
-    switch (action) {
-      case 'switchToTab': {
-        const num = parseInt(e.key, 10);
-        if (num >= 1 && num <= 9) {
-          currentActions.switchToTab?.(num);
-        }
-        break;
-      }
-      case 'nextTab':
-        currentActions.nextTab?.();
-        break;
-      case 'prevTab':
-        currentActions.prevTab?.();
-        break;
-      case 'closeTab':
-        currentActions.closeTab?.();
-        break;
-      case 'newTab':
-        currentActions.newTab?.();
-        break;
-      case 'openHosts':
-        currentActions.openHosts?.();
-        break;
-      case 'openSftp':
-        currentActions.openSftp?.();
-        break;
-      case 'openLocal':
-        currentActions.openLocal?.();
-        break;
-      case 'quickSwitch':
-        currentActions.quickSwitch?.();
-        break;
-      case 'newWorkspace':
-        currentActions.newWorkspace?.();
-        break;
-      case 'commandPalette':
-        currentActions.commandPalette?.();
-        break;
-      case 'portForwarding':
-        currentActions.portForwarding?.();
-        break;
-      case 'snippets':
-        currentActions.snippets?.();
-        break;
-      case 'splitHorizontal':
-        currentActions.splitHorizontal?.();
-        break;
-      case 'splitVertical':
-        currentActions.splitVertical?.();
-        break;
-      case 'moveFocus': {
-        // Determine direction from arrow key
-        const key = e.key;
-        if (key === 'ArrowUp') currentActions.moveFocus?.('up');
-        else if (key === 'ArrowDown') currentActions.moveFocus?.('down');
-        else if (key === 'ArrowLeft') currentActions.moveFocus?.('left');
-        else if (key === 'ArrowRight') currentActions.moveFocus?.('right');
-        break;
-      }
-      case 'broadcast':
-        currentActions.broadcast?.();
-        break;
-      case 'openSettings':
-        currentActions.openSettings?.();
-        break;
-    }
-  }, [hotkeyScheme, keyBindings, isSettingsOpen]);
-
-  useEffect(() => {
-    // Use capture phase to intercept before xterm
-    window.addEventListener('keydown', handleGlobalKeyDown, true);
-    return () => window.removeEventListener('keydown', handleGlobalKeyDown, true);
-  }, [handleGlobalKeyDown]);
-};
-
-// Helper to create key event handler for xterm's attachCustomKeyEventHandler
-// Returns false to let xterm handle the key, true to prevent xterm from handling
-export const createXtermKeyHandler = (
-  keyBindings: KeyBinding[],
-  isMac: boolean,
-  onTerminalAction?: (action: string, e: KeyboardEvent) => void
-) => {
-  const appLevelActions = getAppLevelActions();
-  const terminalActions = getTerminalPassthroughActions();
-
-  return (e: KeyboardEvent): boolean => {
-    const matched = checkAppShortcut(e, keyBindings, isMac);
-    if (!matched) return true; // Let xterm handle it
-
-    const { action } = matched;
-
-    // App-level actions: prevent xterm from handling, let global handler take over
-    if (appLevelActions.has(action)) {
-      return false; // Don't let xterm handle, will bubble to global handler
-    }
-
-    // Terminal-level actions: handle here and prevent default
-    if (terminalActions.has(action)) {
-      e.preventDefault();
-      e.stopPropagation();
-      onTerminalAction?.(action, e);
-      return false;
-    }
-
-    return true; // Let xterm handle other keys
-  };
-};
--- a/application/state/useSessionState.ts
+++ b/application/state/useSessionState.ts
@@ -9,6 +9,7 @@ FocusDirection,
 getNextFocusSessionId,
 insertPaneIntoWorkspace,
 pruneWorkspaceNode,
+reorderWorkspaceFocusSessionOrder,
 SplitDirection,
 SplitHint,
 updateWorkspaceSplitSizes,
@@ -759,6 +760,27 @@ export const useSessionState = () => {
    }));
  }, []);

+  const reorderWorkspaceSessions = useCallback((
+    workspaceId: string,
+    draggedSessionId: string,
+    targetSessionId: string,
+    position: 'before' | 'after' = 'before',
+  ) => {
+    setWorkspaces(prev => prev.map(ws => {
+      if (ws.id !== workspaceId) return ws;
+      return {
+        ...ws,
+        focusSessionOrder: reorderWorkspaceFocusSessionOrder(
+          ws.root,
+          ws.focusSessionOrder,
+          draggedSessionId,
+          targetSessionId,
+          position,
+        ),
+      };
+    }));
+  }, []);
+
  // Move focus between panes in a workspace
  const moveFocusInWorkspace = useCallback((workspaceId: string, direction: FocusDirection): boolean => {
    const workspace = workspaces.find(w => w.id === workspaceId);
@@ -1049,6 +1071,7 @@ export const useSessionState = () => {
    splitSession,
    toggleWorkspaceViewMode,
    setWorkspaceFocusedSession,
+    reorderWorkspaceSessions,
    moveFocusInWorkspace,
    runSnippet,
    orphanSessions,
--- a/application/state/useSettingsState.ts
+++ b/application/state/useSettingsState.ts
@@ -1,10 +1,12 @@
 import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, type SetStateAction } from 'react';
-import { SyncConfig, TerminalTheme, TerminalSettings, HotkeyScheme, CustomKeyBindings, DEFAULT_KEY_BINDINGS, KeyBinding, UILanguage, SessionLogFormat, normalizeTerminalSettings } from '../../domain/models';
+import { SyncConfig, TerminalSettings, HotkeyScheme, CustomKeyBindings, DEFAULT_KEY_BINDINGS, KeyBinding, UILanguage, SessionLogFormat, normalizeTerminalSettings } from '../../domain/models';
 import {
  STORAGE_KEY_COLOR,
  STORAGE_KEY_SYNC,
  STORAGE_KEY_TERM_THEME,
  STORAGE_KEY_TERM_FOLLOW_APP_THEME,
+  STORAGE_KEY_TERM_THEME_DARK,
+  STORAGE_KEY_TERM_THEME_LIGHT,
  STORAGE_KEY_THEME,
  STORAGE_KEY_TERM_FONT_FAMILY,
  STORAGE_KEY_TERM_FONT_SIZE,
@@ -49,7 +51,7 @@ import {
  shouldApplyIncomingCustomKeyBindingsRecord,
  updateCustomKeyBinding as updateCustomKeyBindingRecord,
 } from '../../domain/customKeyBindings';
-import { applyCustomAccentToTerminalTheme, getTerminalThemeForUiTheme } from '../../domain/terminalAppearance';
+import { applyCustomAccentToTerminalTheme, resolveFollowedTerminalThemeId, TERMINAL_THEME_AUTO } from '../../domain/terminalAppearance';
 import { customThemeStore, useCustomThemes } from '../state/customThemeStore';
 import { DEFAULT_FONT_SIZE, isDeprecatedPrimaryFontId } from '../../infrastructure/config/fonts';
 import { DARK_UI_THEMES, LIGHT_UI_THEMES, UiThemeTokens, getUiThemeById } from '../../infrastructure/config/uiThemes';
@@ -254,6 +256,12 @@ export const useSettingsState = () => {
    const isUpgrade = !!localStorageAdapter.readString(STORAGE_KEY_TERM_THEME);
    return !isUpgrade;
  });
+  const [terminalThemeDarkId, setTerminalThemeDarkId] = useState<string>(
+    () => localStorageAdapter.readString(STORAGE_KEY_TERM_THEME_DARK) || TERMINAL_THEME_AUTO,
+  );
+  const [terminalThemeLightId, setTerminalThemeLightId] = useState<string>(
+    () => localStorageAdapter.readString(STORAGE_KEY_TERM_THEME_LIGHT) || TERMINAL_THEME_AUTO,
+  );
  const [terminalFontFamilyId, setTerminalFontFamilyId] = useState<string>(() => {
    const stored = localStorageAdapter.readString(STORAGE_KEY_TERM_FONT_FAMILY);
    return migrateIncomingTerminalFontId(stored) ?? DEFAULT_FONT_FAMILY;
@@ -536,6 +544,10 @@ export const useSettingsState = () => {
    // Terminal
    const storedTermTheme = readStoredString(STORAGE_KEY_TERM_THEME);
    if (storedTermTheme) setTerminalThemeId(storedTermTheme);
+    const storedTermThemeDark = readStoredString(STORAGE_KEY_TERM_THEME_DARK);
+    if (storedTermThemeDark) setTerminalThemeDarkId(storedTermThemeDark);
+    const storedTermThemeLight = readStoredString(STORAGE_KEY_TERM_THEME_LIGHT);
+    if (storedTermThemeLight) setTerminalThemeLightId(storedTermThemeLight);
    const storedTermFont = readStoredString(STORAGE_KEY_TERM_FONT_FAMILY);
    const migratedTermFont = migrateIncomingTerminalFontId(storedTermFont);
    if (migratedTermFont) setTerminalFontFamilyId(migratedTermFont);
@@ -669,6 +681,12 @@ export const useSettingsState = () => {
      if (key === STORAGE_KEY_TERM_THEME && typeof value === 'string') {
        setTerminalThemeId(value);
      }
+      if (key === STORAGE_KEY_TERM_THEME_DARK && typeof value === 'string') {
+        setTerminalThemeDarkId(value);
+      }
+      if (key === STORAGE_KEY_TERM_THEME_LIGHT && typeof value === 'string') {
+        setTerminalThemeLightId(value);
+      }
      if (key === STORAGE_KEY_TERM_FOLLOW_APP_THEME) {
        const next = value === true || value === 'true';
        setFollowAppTerminalThemeState((prev) => (prev === next ? prev : next));
@@ -862,6 +880,15 @@ export const useSettingsState = () => {
          setTerminalThemeId(e.newValue);
        }
      }
+      // Sync per-mode follow terminal themes from other windows
+      if (e.key === STORAGE_KEY_TERM_THEME_DARK && e.newValue) {
+        const next = e.newValue;
+        setTerminalThemeDarkId((prev) => (prev === next ? prev : next));
+      }
+      if (e.key === STORAGE_KEY_TERM_THEME_LIGHT && e.newValue) {
+        const next = e.newValue;
+        setTerminalThemeLightId((prev) => (prev === next ? prev : next));
+      }
      // Sync follow-app-theme toggle from other windows
      if (e.key === STORAGE_KEY_TERM_FOLLOW_APP_THEME && e.newValue) {
        const next = e.newValue === 'true';
@@ -1011,6 +1038,18 @@ export const useSettingsState = () => {
    notifySettingsChanged(STORAGE_KEY_TERM_FOLLOW_APP_THEME, String(followAppTerminalTheme));
  }, [followAppTerminalTheme, notifySettingsChanged]);

+  useEffect(() => {
+    localStorageAdapter.writeString(STORAGE_KEY_TERM_THEME_DARK, terminalThemeDarkId);
+    if (!persistMountedRef.current) return;
+    notifySettingsChanged(STORAGE_KEY_TERM_THEME_DARK, terminalThemeDarkId);
+  }, [terminalThemeDarkId, notifySettingsChanged]);
+
+  useEffect(() => {
+    localStorageAdapter.writeString(STORAGE_KEY_TERM_THEME_LIGHT, terminalThemeLightId);
+    if (!persistMountedRef.current) return;
+    notifySettingsChanged(STORAGE_KEY_TERM_THEME_LIGHT, terminalThemeLightId);
+  }, [terminalThemeLightId, notifySettingsChanged]);
+
  useEffect(() => {
    localStorageAdapter.writeString(STORAGE_KEY_TERM_FONT_FAMILY, terminalFontFamilyId);
    if (!persistMountedRef.current) return;
@@ -1293,25 +1332,32 @@ export const useSettingsState = () => {
  const customThemes = useCustomThemes();

  const currentTerminalTheme = useMemo(() => {
-    let baseTheme: TerminalTheme;
-    // When "Follow Application Theme" is enabled, pick the terminal theme
-    // whose background matches the active UI theme preset.
+    // When "Follow Application Theme" is enabled, honor the per-mode override
+    // (or auto-match the active UI theme preset when set to auto).
    if (followAppTerminalTheme) {
-      const activeUiThemeId = resolvedTheme === 'dark' ? darkUiThemeId : lightUiThemeId;
-      const mapped = getTerminalThemeForUiTheme(activeUiThemeId);
-      if (mapped) {
-        const found = TERMINAL_THEMES.find(t => t.id === mapped);
-        if (found) {
-          baseTheme = found;
-          return applyCustomAccentToTerminalTheme(baseTheme, accentMode, customAccent);
-        }
+      const followedId = resolveFollowedTerminalThemeId({
+        resolvedTheme,
+        terminalThemeDarkId,
+        terminalThemeLightId,
+        lightUiThemeId,
+        darkUiThemeId,
+        fallbackThemeId: terminalThemeId,
+      });
+      const followed = TERMINAL_THEMES.find(t => t.id === followedId)
+        || customThemes.find(t => t.id === followedId);
+      if (followed) {
+        return applyCustomAccentToTerminalTheme(followed, accentMode, customAccent);
      }
+      // Explicit override pointing at a deleted theme: fall through to the
+      // manual theme below.
    }
-    baseTheme = TERMINAL_THEMES.find(t => t.id === terminalThemeId)
+    const baseTheme = TERMINAL_THEMES.find(t => t.id === terminalThemeId)
      || customThemes.find(t => t.id === terminalThemeId)
      || TERMINAL_THEMES[0];
    return applyCustomAccentToTerminalTheme(baseTheme, accentMode, customAccent);
-  }, [terminalThemeId, customThemes, followAppTerminalTheme, resolvedTheme, lightUiThemeId, darkUiThemeId, accentMode, customAccent]);
+  }, [terminalThemeId, terminalThemeDarkId, terminalThemeLightId, customThemes,
+      followAppTerminalTheme, resolvedTheme, lightUiThemeId, darkUiThemeId,
+      accentMode, customAccent]);

  const updateTerminalSetting = useCallback(<K extends keyof TerminalSettings>(
    key: K,
@@ -1348,6 +1394,10 @@ export const useSettingsState = () => {
    setTerminalThemeId,
    followAppTerminalTheme,
    setFollowAppTerminalTheme: setFollowAppTerminalThemeState,
+    terminalThemeDarkId,
+    setTerminalThemeDarkId,
+    terminalThemeLightId,
+    setTerminalThemeLightId,
    currentTerminalTheme,
    terminalFontFamilyId,
    setTerminalFontFamilyId,
--- a/application/state/useSftpBackend.ts
+++ b/application/state/useSftpBackend.ts
@@ -154,6 +154,12 @@ export const useSftpBackend = () => {
    return await netcattyBridge.get()?.listDrives?.() ?? [];
  }, []);

+  const openPath = useCallback(async (path: string) => {
+    const bridge = netcattyBridge.get();
+    if (!bridge?.openPath) throw new Error("openPath unavailable");
+    return bridge.openPath(path);
+  }, []);
+
  const startStreamTransfer = useCallback(
    async (
      options: Parameters<NonNullable<NetcattyBridge["startStreamTransfer"]>>[0],
@@ -273,6 +279,7 @@ export const useSftpBackend = () => {
    statLocal,
    getHomeDir,
    listDrives,
+    openPath,

    startStreamTransfer,
    cancelTransfer,
--- a/application/state/useTerminalBackend.ts
+++ b/application/state/useTerminalBackend.ts
@@ -73,6 +73,11 @@ export const useTerminalBackend = () => {
    bridge?.resizeSession?.(sessionId, cols, rows);
  }, []);

+  const setSessionFlowPaused = useCallback((sessionId: string, paused: boolean) => {
+    const bridge = netcattyBridge.get();
+    bridge?.setSessionFlowPaused?.(sessionId, paused);
+  }, []);
+
  const closeSession = useCallback((sessionId: string) => {
    const bridge = netcattyBridge.get();
    bridge?.closeSession?.(sessionId);
@@ -208,6 +213,7 @@ export const useTerminalBackend = () => {
      getServerStats,
      writeToSession,
      resizeSession,
+      setSessionFlowPaused,
      closeSession,
      setSessionEncoding,
      onSessionData,
@@ -240,6 +246,7 @@ export const useTerminalBackend = () => {
      getServerStats,
      writeToSession,
      resizeSession,
+      setSessionFlowPaused,
      closeSession,
      setSessionEncoding,
      onSessionData,
--- a/application/syncPayload.ts
+++ b/application/syncPayload.ts
@@ -18,7 +18,12 @@ import type {
  Snippet,
  SSHKey,
 } from '../domain/models';
-import type { SyncPayload } from '../domain/sync';
+import {
+  CLOUD_SYNC_PAYLOAD_ENTITY_KEYS,
+  SYNC_PAYLOAD_ENTITY_KEYS,
+  hasSyncPayloadEntityData,
+  type SyncPayload,
+} from '../domain/sync';
 import {
  nextCustomKeyBindingsSyncVersion,
  parseCustomKeyBindingsStorageRecord,
@@ -26,7 +31,7 @@ import {
 } from '../domain/customKeyBindings';
 import { isEncryptedCredentialPlaceholder } from '../domain/credentials';
 import { localStorageAdapter } from '../infrastructure/persistence/localStorageAdapter';
-import { rehydrateGlobalBookmarks } from '../components/sftp/hooks/useGlobalSftpBookmarks';
+import { rehydrateGlobalSftpBookmarks } from './state/sftp/globalSftpBookmarks';
 import {
  STORAGE_KEY_THEME,
  STORAGE_KEY_UI_THEME_LIGHT,
@@ -38,6 +43,8 @@ import {
  STORAGE_KEY_CUSTOM_CSS,
  STORAGE_KEY_TERM_THEME,
  STORAGE_KEY_TERM_FOLLOW_APP_THEME,
+  STORAGE_KEY_TERM_THEME_DARK,
+  STORAGE_KEY_TERM_THEME_LIGHT,
  STORAGE_KEY_TERM_FONT_FAMILY,
  STORAGE_KEY_TERM_FONT_SIZE,
  STORAGE_KEY_TERM_SETTINGS,
@@ -67,6 +74,7 @@ import {
  STORAGE_KEY_AI_MAX_ITERATIONS,
  STORAGE_KEY_AI_AGENT_MODEL_MAP,
  STORAGE_KEY_AI_WEB_SEARCH,
+  STORAGE_KEY_PORT_FORWARDING,
 } from '../infrastructure/config/storageKeys';

 // ---------------------------------------------------------------------------
@@ -94,19 +102,7 @@ export interface SyncableVaultData {
 * protecting or syncing.
 */
 export function hasMeaningfulSyncData(payload: SyncPayload): boolean {
-  const hasEntities =
-    (payload.hosts?.length ?? 0) > 0 ||
-    (payload.keys?.length ?? 0) > 0 ||
-    (payload.snippets?.length ?? 0) > 0 ||
-    (payload.identities?.length ?? 0) > 0 ||
-    (payload.proxyProfiles?.length ?? 0) > 0 ||
-    (payload.customGroups?.length ?? 0) > 0 ||
-    (payload.snippetPackages?.length ?? 0) > 0 ||
-    (payload.portForwardingRules?.length ?? 0) > 0 ||
-    (payload.knownHosts?.length ?? 0) > 0 ||
-    (payload.groupConfigs?.length ?? 0) > 0;
-
-  if (hasEntities) return true;
+  if (hasSyncPayloadEntityData(payload, SYNC_PAYLOAD_ENTITY_KEYS)) return true;

  return Boolean(
    payload.settings && Object.values(payload.settings).some((value) => value !== undefined),
@@ -118,24 +114,39 @@ export function hasMeaningfulSyncData(payload: SyncPayload): boolean {
 * Local-only trust records are intentionally ignored.
 */
 export function hasMeaningfulCloudSyncData(payload: SyncPayload): boolean {
-  const hasEntities =
-    (payload.hosts?.length ?? 0) > 0 ||
-    (payload.keys?.length ?? 0) > 0 ||
-    (payload.snippets?.length ?? 0) > 0 ||
-    (payload.identities?.length ?? 0) > 0 ||
-    (payload.proxyProfiles?.length ?? 0) > 0 ||
-    (payload.customGroups?.length ?? 0) > 0 ||
-    (payload.snippetPackages?.length ?? 0) > 0 ||
-    (payload.portForwardingRules?.length ?? 0) > 0 ||
-    (payload.groupConfigs?.length ?? 0) > 0;
-
-  if (hasEntities) return true;
+  if (hasSyncPayloadEntityData(payload, CLOUD_SYNC_PAYLOAD_ENTITY_KEYS)) return true;

  return Boolean(
    payload.settings && Object.values(payload.settings).some((value) => value !== undefined),
  );
 }

+export function sanitizePortForwardingRulesForSync(
+  rules: PortForwardingRule[] | undefined,
+): PortForwardingRule[] | undefined {
+  if (!rules) return rules;
+  return rules.map((rule) => ({
+    ...rule,
+    status: 'inactive' as const,
+    error: undefined,
+    lastUsedAt: undefined,
+  }));
+}
+
+export function getEffectivePortForwardingRulesForSync(
+  rules: PortForwardingRule[] | undefined,
+): PortForwardingRule[] | undefined {
+  let effectiveRules = rules;
+  if (!effectiveRules || effectiveRules.length === 0) {
+    const stored = localStorageAdapter.read<PortForwardingRule[]>(STORAGE_KEY_PORT_FORWARDING);
+    if (Array.isArray(stored) && stored.length > 0) {
+      effectiveRules = stored;
+    }
+  }
+
+  return sanitizePortForwardingRulesForSync(effectiveRules);
+}
+
 /** Callbacks used by `applySyncPayload` to import data into local state. */
 interface SyncPayloadImporters {
  /** Import vault data. Cloud sync excludes local-only known hosts by default. */
@@ -152,15 +163,16 @@ interface SyncPayloadImporters {

 /** Terminal settings keys that are safe to sync (platform-agnostic). */
 const SYNCABLE_TERMINAL_KEYS = [
+  'startupCommandDelayMs',
  'scrollback', 'drawBoldInBrightColors', 'terminalEmulationType',
  'fontLigatures', 'fontWeight', 'fontWeightBold', 'fallbackFont',
  'linePadding', 'cursorShape', 'cursorBlink', 'minimumContrastRatio',
-  'altAsMeta', 'scrollOnInput', 'scrollOnOutput', 'scrollOnKeyPress', 'scrollOnPaste',
+  'altAsMeta', 'optionArrowWordJump', 'scrollOnInput', 'scrollOnOutput', 'scrollOnKeyPress', 'scrollOnPaste',
  'smoothScrolling',
  'rightClickBehavior', 'copyOnSelect', 'middleClickPaste', 'wordSeparators',
  'linkModifier', 'keywordHighlightEnabled', 'keywordHighlightRules',
  'keepaliveInterval', 'keepaliveCountMax', 'disableBracketedPaste', 'clearWipesScrollback',
-  'preserveSelectionOnInput', 'osc52Clipboard', 'showServerStats',
+  'preserveSelectionOnInput', 'forcePromptNewLine', 'osc52Clipboard', 'showServerStats',
  'serverStatsRefreshInterval', 'rendererType',
  'autocompleteEnabled', 'autocompleteGhostText', 'autocompletePopupMenu',
  'autocompleteDebounceMs', 'autocompleteMinChars', 'autocompleteMaxSuggestions',
@@ -177,6 +189,8 @@ export const SYNCABLE_SETTING_STORAGE_KEYS = [
  STORAGE_KEY_CUSTOM_CSS,
  STORAGE_KEY_TERM_THEME,
  STORAGE_KEY_TERM_FOLLOW_APP_THEME,
+  STORAGE_KEY_TERM_THEME_DARK,
+  STORAGE_KEY_TERM_THEME_LIGHT,
  STORAGE_KEY_TERM_FONT_FAMILY,
  STORAGE_KEY_TERM_FONT_SIZE,
  STORAGE_KEY_TERM_SETTINGS,
@@ -300,6 +314,10 @@ export function collectSyncableSettings(): SyncPayload['settings'] {
  if (followAppTermTheme === 'true' || followAppTermTheme === 'false') {
    settings.followAppTerminalTheme = followAppTermTheme === 'true';
  }
+  const termThemeDark = localStorageAdapter.readString(STORAGE_KEY_TERM_THEME_DARK);
+  if (termThemeDark) settings.terminalThemeDark = termThemeDark;
+  const termThemeLight = localStorageAdapter.readString(STORAGE_KEY_TERM_THEME_LIGHT);
+  if (termThemeLight) settings.terminalThemeLight = termThemeLight;
  const termFont = localStorageAdapter.readString(STORAGE_KEY_TERM_FONT_FAMILY);
  if (termFont) settings.terminalFontFamily = termFont;
  const termSize = localStorageAdapter.readNumber(STORAGE_KEY_TERM_FONT_SIZE);
@@ -423,6 +441,8 @@ function applySyncableSettings(settings: NonNullable<SyncPayload['settings']>):
  if (settings.followAppTerminalTheme != null) {
    localStorageAdapter.writeString(STORAGE_KEY_TERM_FOLLOW_APP_THEME, String(settings.followAppTerminalTheme));
  }
+  if (settings.terminalThemeDark != null) localStorageAdapter.writeString(STORAGE_KEY_TERM_THEME_DARK, settings.terminalThemeDark);
+  if (settings.terminalThemeLight != null) localStorageAdapter.writeString(STORAGE_KEY_TERM_THEME_LIGHT, settings.terminalThemeLight);
  if (settings.terminalFontFamily != null) localStorageAdapter.writeString(STORAGE_KEY_TERM_FONT_FAMILY, settings.terminalFontFamily);
  if (settings.terminalFontSize != null) localStorageAdapter.writeString(STORAGE_KEY_TERM_FONT_SIZE, String(settings.terminalFontSize));

@@ -550,7 +570,7 @@ export function buildSyncPayload(
    customGroups: vault.customGroups,
    snippetPackages: vault.snippetPackages,
    groupConfigs: vault.groupConfigs,
-    portForwardingRules,
+    portForwardingRules: sanitizePortForwardingRulesForSync(portForwardingRules),
    settings: collectSyncableSettings(),
    syncedAt: Date.now(),
  };
@@ -611,7 +631,7 @@ function applyPayload(
    if (payload.settings) {
      applySyncableSettings(payload.settings);
      // Rehydrate in-memory bookmark snapshot after localStorage was updated
-      if (payload.settings.sftpGlobalBookmarks != null) rehydrateGlobalBookmarks();
+      if (payload.settings.sftpGlobalBookmarks != null) rehydrateGlobalSftpBookmarks();
      importers.onSettingsApplied?.();
    }
  });
--- a/components/AIChatSidePanel.tsx
+++ b/components/AIChatSidePanel.tsx
@@ -637,6 +637,7 @@ const AIChatSidePanelInner: React.FC<AIChatSidePanelProps> = ({
      undefined,
      undefined,
      `models_${currentAgentId}`,
+      currentAgentConfig.env,
    ).then((result) => {
      if (cancelled || !result?.ok || !Array.isArray(result.models)) return;
      // If the probe came back empty, drop any stale cached catalog for this
--- a/components/FileOpenerDialog.tsx
+++ b/components/FileOpenerDialog.tsx
@@ -17,7 +17,7 @@ interface FileOpenerDialogProps {
  onSelectSystemApp: () => Promise<SystemAppInfo | null>;
 }

-export const FileOpenerDialog: React.FC<FileOpenerDialogProps> = ({
+const FileOpenerDialog: React.FC<FileOpenerDialogProps> = ({
  open,
  onClose,
  fileName,
--- a/components/SettingsPage.tsx
+++ b/components/SettingsPage.tsx
@@ -12,6 +12,7 @@ import { useWindowControls } from "../application/state/useWindowControls";
 import { useUpdateCheck } from "../application/state/useUpdateCheck";
 import { useAIState } from "../application/state/useAIState";
 import { I18nProvider, useI18n } from "../application/i18n/I18nProvider";
+import { sanitizePortForwardingRulesForSync } from "../application/syncPayload";
 import SettingsApplicationTab from "./SettingsApplicationTab";
 import SettingsAppearanceTab from "./settings/tabs/SettingsAppearanceTab";
 import SettingsFileAssociationsTab from "./settings/tabs/SettingsFileAssociationsTab";
@@ -50,6 +51,11 @@ type SettingsState = ReturnType<typeof useSettingsState>;

 const SettingsSyncTab = React.lazy(() => import("./settings/tabs/SettingsSyncTab"));

+const settingsTabTriggerClassName =
+    "w-full justify-start gap-2 px-3 py-2 text-sm data-[state=active]:bg-background hover:bg-background/60 rounded-md transition-colors overflow-hidden";
+const settingsTabIconClassName = "shrink-0";
+const settingsTabLabelClassName = "min-w-0 truncate";
+
 const SettingsTerminalTabContainer: React.FC<{ settings: SettingsState }> = ({ settings }) => {
    const availableFonts = useAvailableFonts();

@@ -59,6 +65,12 @@ const SettingsTerminalTabContainer: React.FC<{ settings: SettingsState }> = ({ s
            setTerminalThemeId={settings.setTerminalThemeId}
            followAppTerminalTheme={settings.followAppTerminalTheme}
            setFollowAppTerminalTheme={settings.setFollowAppTerminalTheme}
+            terminalThemeDarkId={settings.terminalThemeDarkId}
+            setTerminalThemeDarkId={settings.setTerminalThemeDarkId}
+            terminalThemeLightId={settings.terminalThemeLightId}
+            setTerminalThemeLightId={settings.setTerminalThemeLightId}
+            lightUiThemeId={settings.lightUiThemeId}
+            darkUiThemeId={settings.darkUiThemeId}
            terminalFontFamilyId={settings.terminalFontFamilyId}
            setTerminalFontFamilyId={settings.setTerminalFontFamilyId}
            terminalFontSize={settings.terminalFontSize}
@@ -128,13 +140,7 @@ const SettingsSyncTabWithVault: React.FC<{ onSettingsApplied?: () => void }> = (

    // Strip transient runtime fields before passing to sync
    const portForwardingRulesForSync = useMemo(
-        () =>
-            portForwardingRules.map((rule) => ({
-                ...rule,
-                status: "inactive" as const,
-                error: undefined,
-                lastUsedAt: undefined,
-            })),
+        () => sanitizePortForwardingRulesForSync(portForwardingRules) ?? [],
        [portForwardingRules],
    );

@@ -213,51 +219,59 @@ const SettingsPageContent: React.FC<{ settings: SettingsState }> = ({ settings }
                    <TabsList className="flex flex-col h-auto bg-transparent gap-1 p-0 justify-start">
                        <TabsTrigger
                            value="application"
-                            className="w-full justify-start gap-2 px-3 py-2 text-sm data-[state=active]:bg-background hover:bg-background/60 rounded-md transition-colors"
+                            className={settingsTabTriggerClassName}
                        >
-                            <AppWindow size={14} /> {t("settings.tab.application")}
+                            <AppWindow size={14} className={settingsTabIconClassName} />
+                            <span className={settingsTabLabelClassName}>{t("settings.tab.application")}</span>
                        </TabsTrigger>
                        <TabsTrigger
                            value="appearance"
-                            className="w-full justify-start gap-2 px-3 py-2 text-sm data-[state=active]:bg-background hover:bg-background/60 rounded-md transition-colors"
+                            className={settingsTabTriggerClassName}
                        >
-                            <Palette size={14} /> {t("settings.tab.appearance")}
+                            <Palette size={14} className={settingsTabIconClassName} />
+                            <span className={settingsTabLabelClassName}>{t("settings.tab.appearance")}</span>
                        </TabsTrigger>
                        <TabsTrigger
                            value="terminal"
-                            className="w-full justify-start gap-2 px-3 py-2 text-sm data-[state=active]:bg-background hover:bg-background/60 rounded-md transition-colors"
+                            className={settingsTabTriggerClassName}
                        >
-                            <TerminalSquare size={14} /> {t("settings.tab.terminal")}
+                            <TerminalSquare size={14} className={settingsTabIconClassName} />
+                            <span className={settingsTabLabelClassName}>{t("settings.tab.terminal")}</span>
                        </TabsTrigger>
                        <TabsTrigger
                            value="shortcuts"
-                            className="w-full justify-start gap-2 px-3 py-2 text-sm data-[state=active]:bg-background hover:bg-background/60 rounded-md transition-colors"
+                            className={settingsTabTriggerClassName}
                        >
-                            <Keyboard size={14} /> {t("settings.tab.shortcuts")}
+                            <Keyboard size={14} className={settingsTabIconClassName} />
+                            <span className={settingsTabLabelClassName}>{t("settings.tab.shortcuts")}</span>
                        </TabsTrigger>
                        <TabsTrigger
                            value="file-associations"
-                            className="w-full justify-start gap-2 px-3 py-2 text-sm data-[state=active]:bg-background hover:bg-background/60 rounded-md transition-colors"
+                            className={settingsTabTriggerClassName}
                        >
-                            <FileType size={14} /> {t("settings.tab.sftpFileAssociations")}
+                            <FileType size={14} className={settingsTabIconClassName} />
+                            <span className={settingsTabLabelClassName}>{t("settings.tab.sftpFileAssociations")}</span>
                        </TabsTrigger>
                        <TabsTrigger
                            value="ai"
-                            className="w-full justify-start gap-2 px-3 py-2 text-sm data-[state=active]:bg-background hover:bg-background/60 rounded-md transition-colors"
+                            className={settingsTabTriggerClassName}
                        >
-                            <Sparkles size={14} /> AI
+                            <Sparkles size={14} className={settingsTabIconClassName} />
+                            <span className={settingsTabLabelClassName}>AI</span>
                        </TabsTrigger>
                        <TabsTrigger
                            value="sync"
-                            className="w-full justify-start gap-2 px-3 py-2 text-sm data-[state=active]:bg-background hover:bg-background/60 rounded-md transition-colors"
+                            className={settingsTabTriggerClassName}
                        >
-                            <Cloud size={14} /> {t("settings.tab.syncCloud")}
+                            <Cloud size={14} className={settingsTabIconClassName} />
+                            <span className={settingsTabLabelClassName}>{t("settings.tab.syncCloud")}</span>
                        </TabsTrigger>
                        <TabsTrigger
                            value="system"
-                            className="w-full justify-start gap-2 px-3 py-2 text-sm data-[state=active]:bg-background hover:bg-background/60 rounded-md transition-colors"
+                            className={settingsTabTriggerClassName}
                        >
-                            <HardDrive size={14} /> {t("settings.tab.system")}
+                            <HardDrive size={14} className={settingsTabIconClassName} />
+                            <span className={settingsTabLabelClassName}>{t("settings.tab.system")}</span>
                        </TabsTrigger>
                    </TabsList>
                </div>
--- a/components/SftpSidePanel.tsx
+++ b/components/SftpSidePanel.tsx
@@ -19,7 +19,7 @@ import { editorTabStore } from "../application/state/editorTabStore";
 import { releaseEditorTabSaveCoordinator } from "../application/state/editorTabSave";
 import { useSftpBackend } from "../application/state/useSftpBackend";
 import { useSftpFileAssociations } from "../application/state/useSftpFileAssociations";
-import { getParentPath } from "../application/state/sftp/utils";
+import { getParentPath, isConcreteTransferTargetPath } from "../application/state/sftp/utils";
 import { buildCacheKey } from "../application/state/sftp/sharedRemoteHostCache";
 import { logger } from "../lib/logger";
 import type { DropEntry } from "../lib/sftpFileUtils";
@@ -135,6 +135,7 @@ const SftpSidePanelInner: React.FC<SftpSidePanelProps> = ({
    deleteLocalFile,
    listLocalDir,
    listDrives,
+    openPath,
  } = useSftpBackend();

  const sftpRef = useRef(sftp);
@@ -576,18 +577,35 @@ const SftpSidePanelInner: React.FC<SftpSidePanelProps> = ({

  const handleRevealTransferTarget = useCallback(
    async (task: TransferTask) => {
+      if (!isConcreteTransferTargetPath(task)) return;
      const connection = sftpRef.current.leftPane.connection;
+      const revealPath = task.isDirectory ? task.targetPath : getParentPath(task.targetPath);
+
+      if (task.targetConnectionId === "local") {
+        try {
+          const result = await openPath(revealPath);
+          if (result.success) return;
+        } catch {
+          // Show the localized error below.
+        }
+        toast.error(t("sftp.transfers.openTargetFolderError"), "SFTP");
+        return;
+      }
+
      if (!connection || connection.isLocal) return;

-      const revealPath = task.isDirectory ? task.targetPath : getParentPath(task.targetPath);
      await sftpRef.current.navigateTo("left", revealPath, { force: true });
    },
-    [],
+    [openPath, t],
  );

  const canRevealTransferTarget = useCallback(
    (task: TransferTask) => {
      if (task.status !== "completed") return false;
+      if (!isConcreteTransferTargetPath(task)) return false;
+      if (task.targetConnectionId === "local") {
+        return true;
+      }
      if (task.direction !== "upload" && task.direction !== "remote-to-remote") return false;

      const connection = sftp.leftPane.connection;
@@ -608,6 +626,24 @@ const SftpSidePanelInner: React.FC<SftpSidePanelProps> = ({
    [sftp.leftPane.connection],
  );

+  const canCopyTransferTargetPath = useCallback(
+    (task: TransferTask) => task.status === "completed" && isConcreteTransferTargetPath(task),
+    [],
+  );
+
+  const handleCopyTransferTargetPath = useCallback(
+    async (task: TransferTask) => {
+      if (!isConcreteTransferTargetPath(task)) return;
+      try {
+        await navigator.clipboard.writeText(task.targetPath);
+        toast.success(t("sftp.transfers.copyTargetPathSuccess"), "SFTP");
+      } catch {
+        toast.error(t("sftp.transfers.copyTargetPathError"), "SFTP");
+      }
+    },
+    [t],
+  );
+
  // When the auto-connect effect defers a switch (active transfers or open
  // editor), the panel still operates on the current connection, not
  // activeHost.  Use the connected host for the header so the label matches
@@ -706,6 +742,8 @@ const SftpSidePanelInner: React.FC<SftpSidePanelProps> = ({
          allTransfers={sftp.transfers}
          canRevealTransferTarget={canRevealTransferTarget}
          onRevealTransferTarget={handleRevealTransferTarget}
+          canCopyTransferTargetPath={canCopyTransferTargetPath}
+          onCopyTransferTargetPath={handleCopyTransferTargetPath}
        />
      </div>

@@ -715,6 +753,10 @@ const SftpSidePanelInner: React.FC<SftpSidePanelProps> = ({
          sftp={sftp}
          visibleTransfers={visibleTransfers}
          showTransferQueue={false}
+          canRevealTransferTarget={canRevealTransferTarget}
+          onRevealTransferTarget={handleRevealTransferTarget}
+          canCopyTransferTargetPath={canCopyTransferTargetPath}
+          onCopyTransferTargetPath={handleCopyTransferTargetPath}
          showHostPickerLeft={showHostPickerLeft}
          showHostPickerRight={showHostPickerRight}
          hostSearchLeft={hostSearchLeft}
--- a/components/SftpTransferItem.test.tsx
+++ b/components/SftpTransferItem.test.tsx
@@ -136,3 +136,31 @@ test("keeps reveal target and child toggle as separate buttons", () => {
  assert.match(markup, /aria-expanded="false"/);
  assert.match(markup, /aria-controls="children-transfer-1"/);
 });
+
+test("renders explicit target actions for completed local downloads", () => {
+  const markup = renderTransferItem(
+    {
+      ...baseTask,
+      id: "download-1",
+      fileName: "report.pdf",
+      sourcePath: "/remote/report.pdf",
+      targetPath: "/Users/alice/Downloads/report.pdf",
+      targetConnectionId: "local",
+      direction: "download",
+      status: "completed",
+      error: undefined,
+      transferredBytes: 1024,
+    },
+    {
+      canRevealTarget: true,
+      onRevealTarget: () => {},
+      canCopyTargetPath: true,
+      onCopyTargetPath: () => {},
+    },
+  );
+
+  assert.match(markup, /aria-label="Open target folder: report\.pdf"/);
+  assert.match(markup, /aria-label="Copy target path: report\.pdf"/);
+  assert.match(markup, /lucide-folder-open/);
+  assert.match(markup, /lucide-clipboard-copy/);
+});
--- a/components/SftpView.tsx
+++ b/components/SftpView.tsx
@@ -19,12 +19,13 @@ import { useI18n } from "../application/i18n/I18nProvider";
 import { useIsSftpActive } from "../application/state/activeTabStore";
 import { useSftpState } from "../application/state/useSftpState";
 import { useSftpBackend } from "../application/state/useSftpBackend";
+import { getParentPath, isConcreteTransferTargetPath } from "../application/state/sftp/utils";
 import { HotkeyScheme, KeyBinding } from "../domain/models";
 import { logger } from "../lib/logger";
 import { useRenderTracker } from "../lib/useRenderTracker";
 import { cn } from "../lib/utils";
 import { useInstantThemeSwitch } from "../lib/useInstantThemeSwitch";
-import { Host, Identity, ProxyProfile, SSHKey } from "../types";
+import { Host, Identity, ProxyProfile, SSHKey, TransferTask } from "../types";
 import { resolveGroupDefaults, applyGroupDefaults } from "../domain/groupConfig";
 import { materializeHostProxyProfile } from "../domain/proxyProfiles";
 import { useSftpFileAssociations } from "../application/state/useSftpFileAssociations";
@@ -137,6 +138,7 @@ const SftpViewInner: React.FC<SftpViewProps> = ({
    deleteLocalFile,
    listLocalDir,
    listDrives,
+    openPath,
  } = useSftpBackend();

  // Store sftp in a ref so callbacks can access the latest instance
@@ -271,6 +273,75 @@ const SftpViewInner: React.FC<SftpViewProps> = ({
    [sftp.transfers],
  );

+  const getTransferTargetDirectory = useCallback(
+    (task: TransferTask) => (task.isDirectory ? task.targetPath : getParentPath(task.targetPath)),
+    [],
+  );
+
+  const findRemoteTransferTargetTab = useCallback((task: TransferTask) => {
+    const state = sftpRef.current;
+    for (const side of ["left", "right"] as const) {
+      const tabs = side === "left" ? state.leftTabs.tabs : state.rightTabs.tabs;
+      const pane = tabs.find((tab) => tab.connection?.id === task.targetConnectionId);
+      if (pane?.connection && !pane.connection.isLocal) {
+        return { side, tabId: pane.id };
+      }
+    }
+    return null;
+  }, []);
+
+  const canRevealTransferTarget = useCallback(
+    (task: TransferTask) => {
+      if (task.status !== "completed") return false;
+      if (!isConcreteTransferTargetPath(task)) return false;
+      if (task.targetConnectionId === "local") {
+        return true;
+      }
+      return !!findRemoteTransferTargetTab(task);
+    },
+    [findRemoteTransferTargetTab],
+  );
+
+  const handleRevealTransferTarget = useCallback(
+    async (task: TransferTask) => {
+      if (!isConcreteTransferTargetPath(task)) return;
+      const targetDirectory = getTransferTargetDirectory(task);
+      if (task.targetConnectionId === "local") {
+        try {
+          const result = await openPath(targetDirectory);
+          if (result.success) return;
+        } catch {
+          // Show the localized error below.
+        }
+        toast.error(t("sftp.transfers.openTargetFolderError"), "SFTP");
+        return;
+      }
+
+      const targetTab = findRemoteTransferTargetTab(task);
+      if (!targetTab) return;
+      await sftpRef.current.navigateTo(targetTab.side, targetDirectory, { force: true, tabId: targetTab.tabId });
+    },
+    [findRemoteTransferTargetTab, getTransferTargetDirectory, openPath, t],
+  );
+
+  const canCopyTransferTargetPath = useCallback(
+    (task: TransferTask) => task.status === "completed" && isConcreteTransferTargetPath(task),
+    [],
+  );
+
+  const handleCopyTransferTargetPath = useCallback(
+    async (task: TransferTask) => {
+      if (!isConcreteTransferTargetPath(task)) return;
+      try {
+        await navigator.clipboard.writeText(task.targetPath);
+        toast.success(t("sftp.transfers.copyTargetPathSuccess"), "SFTP");
+      } catch {
+        toast.error(t("sftp.transfers.copyTargetPathError"), "SFTP");
+      }
+    },
+    [t],
+  );
+
  const containerStyle: React.CSSProperties = isActive
    ? {}
    : {
@@ -475,6 +546,10 @@ const SftpViewInner: React.FC<SftpViewProps> = ({
          hosts={effectiveHosts}
          sftp={sftp}
          visibleTransfers={visibleTransfers}
+          canRevealTransferTarget={canRevealTransferTarget}
+          onRevealTransferTarget={handleRevealTransferTarget}
+          canCopyTransferTargetPath={canCopyTransferTargetPath}
+          onCopyTransferTargetPath={handleCopyTransferTargetPath}
          showHostPickerLeft={showHostPickerLeft}
          showHostPickerRight={showHostPickerRight}
          hostSearchLeft={hostSearchLeft}
--- a/components/Terminal.tsx
+++ b/components/Terminal.tsx
@@ -5,7 +5,6 @@ import { SearchAddon } from "@xterm/addon-search";
 import "@xterm/xterm/css/xterm.css";
 import { Cpu, Copy, HardDrive, Maximize2, MemoryStick, Radio, ArrowDownToLine, ArrowUpFromLine } from "lucide-react";
 import React, { memo, useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
-import ReactDOM from "react-dom";
 import { useI18n } from "../application/i18n/I18nProvider";
 import { logger } from "../lib/logger";
 import { cn, normalizeLineEndings, wrapBracketedPaste } from "../lib/utils";
@@ -29,7 +28,7 @@ import {
  applyCustomAccentToTerminalTheme,
  resolveHostTerminalThemeId,
 } from "../domain/terminalAppearance";
-import { classifyDistroId } from "../domain/host";
+import { classifyDistroId, shouldProbeSessionCwd } from "../domain/host";
 import { resolveHostAuth } from "../domain/sshAuth";
 import { useTerminalBackend } from "../application/state/useTerminalBackend";
 // SFTPModal removed - SFTP is now handled by SftpSidePanel in TerminalLayer
@@ -49,11 +48,20 @@ import { TerminalToolbar } from "./terminal/TerminalToolbar";
 import { TerminalComposeBar } from "./terminal/TerminalComposeBar";
 import { TerminalContextMenu } from "./terminal/TerminalContextMenu";
 import { TerminalSearchBar } from "./terminal/TerminalSearchBar";
+import { ZmodemOverwriteDialog } from "./terminal/ZmodemOverwriteDialog";
 import { ZmodemProgressIndicator } from "./terminal/ZmodemProgressIndicator";
+import { createReplaySafeTerminalLogSanitizer } from "./terminal/replaySafeTerminalLog";
+import { createConnectionLogBuffer } from "./terminal/connectionLogBuffer";
 import { useZmodemTransfer } from "./terminal/hooks/useZmodemTransfer";
 import { createTerminalSessionStarters, type PendingAuth } from "./terminal/runtime/createTerminalSessionStarters";
 import { createXTermRuntime, primaryFontFamily, type XTermRuntime } from "./terminal/runtime/createXTermRuntime";
 import { applyUserCursorPreference } from "./terminal/runtime/cursorPreference";
+import { terminalAltKeyOptions } from "./terminal/runtime/altKeyOptions";
+import {
+  createPromptLineBreakState,
+  type PromptLineBreakState,
+} from "./terminal/runtime/promptLineBreak";
+import { recordTerminalCommandExecution } from "./terminal/runtime/terminalCommandExecution";
 import { shouldPreserveTerminalFocusOnMouseDown } from "./terminal/toolbarFocus";
 import { preserveTerminalViewportInScrollback } from "./terminal/clearTerminalViewport";
 import { XTERM_PERFORMANCE_CONFIG } from "../infrastructure/config/xtermPerformance";
@@ -62,7 +70,10 @@ import { useTerminalContextActions } from "./terminal/hooks/useTerminalContextAc
 import { useTerminalAuthState } from "./terminal/hooks/useTerminalAuthState";
 import { useServerStats } from "./terminal/hooks/useServerStats";
 import { extractDropEntries, getPathForFile, DropEntry } from "../lib/sftpFileUtils";
-import { useTerminalAutocomplete, AutocompletePopup } from "./terminal/autocomplete";
+import { TerminalAutocomplete } from "./terminal/TerminalAutocomplete";
+import { createTerminalCwdTracker, resolvePreferredTerminalCwd } from "./terminal/sftpCwd";
+
+const MAX_CONNECTION_LOG_DATA_CHARS = 1_000_000;

 /**
 * Extract unique root paths from drop entries for local terminal path insertion.
@@ -163,6 +174,7 @@ interface TerminalProps {
    pendingUploadEntries?: DropEntry[],
    sourceSessionId?: string,
  ) => void;
+  onTerminalCwdChange?: (sessionId: string, cwd: string | null) => void;
  onOpenScripts?: () => void;
  onOpenTheme?: () => void;
  isBroadcastEnabled?: boolean;
@@ -253,6 +265,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
  onSplitHorizontal,
  onSplitVertical,
  onOpenSftp,
+  onTerminalCwdChange,
  onOpenScripts,
  onOpenTheme,
  isBroadcastEnabled,
@@ -273,6 +286,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
  const serializeAddonRef = useRef<SerializeAddon | null>(null);
  const searchAddonRef = useRef<SearchAddon | null>(null);
  const xtermRuntimeRef = useRef<XTermRuntime | null>(null);
+  const terminalCwdTracker = useMemo(() => createTerminalCwdTracker(), []);
  const knownCwdRef = useRef<string | undefined>(undefined);
  const disposeDataRef = useRef<(() => void) | null>(null);
  const disposeExitRef = useRef<(() => void) | null>(null);
@@ -285,8 +299,11 @@ const TerminalComponent: React.FC<TerminalProps> = ({
  // cancelled retry can't fire a startNewSession after the fact.
  const retryTokenRef = useRef<symbol | null>(null);
  const terminalDataCapturedRef = useRef(false);
+  const connectionLogBufferRef = useRef(createConnectionLogBuffer(MAX_CONNECTION_LOG_DATA_CHARS));
+  const terminalLogSanitizerRef = useRef(createReplaySafeTerminalLogSanitizer());
  const onTerminalDataCaptureRef = useRef(onTerminalDataCapture);
  const commandBufferRef = useRef<string>("");
+  const promptLineBreakStateRef = useRef<PromptLineBreakState>(createPromptLineBreakState());
  const [hasMouseTracking, setHasMouseTracking] = useState(false);
  const mouseTrackingRef = useRef(false);
  const serialLineBufferRef = useRef<string>("");
@@ -300,6 +317,26 @@ const TerminalComponent: React.FC<TerminalProps> = ({
  const lastFittedSizeRef = useRef<{ width: number; height: number } | null>(null);
  const fontWeightFixupDoneRef = useRef(false);

+  const captureTerminalLogData = useCallback((data: string) => {
+    const replaySafeData = terminalLogSanitizerRef.current.append(data);
+    if (!replaySafeData) return;
+    connectionLogBufferRef.current.append(replaySafeData);
+  }, []);
+
+  const finalizeTerminalLogData = useCallback(() => {
+    const replaySafeData = terminalLogSanitizerRef.current.finish();
+    if (replaySafeData) {
+      connectionLogBufferRef.current.append(replaySafeData);
+    }
+    return connectionLogBufferRef.current.toString();
+  }, []);
+
+  const writeLocalTerminalData = useCallback((data: string) => {
+    if (!data) return;
+    captureTerminalLogData(data);
+    termRef.current?.write(data);
+  }, [captureTerminalLogData]);
+
  useEffect(() => {
    if (xtermRuntimeRef.current) {
      // Merge global rules with host-level rules
@@ -346,10 +383,13 @@ const TerminalComponent: React.FC<TerminalProps> = ({
  const snippetsRef = useRef(snippets);
  snippetsRef.current = snippets;

-  // Autocomplete handler refs (set after hook initialization)
+  // Autocomplete handler refs — populated by <TerminalAutocomplete> so the
+  // xterm runtime (and a few effects here) can drive the hook without making
+  // Terminal re-render on every suggestion update.
  const autocompleteKeyEventRef = useRef<((e: KeyboardEvent) => boolean) | undefined>(undefined);
  const autocompleteInputRef = useRef<((data: string) => void) | undefined>(undefined);
  const autocompleteRepositionRef = useRef<(() => void) | undefined>(undefined);
+  const autocompleteCloseRef = useRef<(() => void) | undefined>(undefined);

  const terminalBackend = useTerminalBackend();
  const { resizeSession, setSessionEncoding } = terminalBackend;
@@ -437,20 +477,20 @@ const TerminalComponent: React.FC<TerminalProps> = ({
            const line = serialLineBufferRef.current + "\r";
            terminalBackend.writeToSession(id, line);
            serialLineBufferRef.current = "";
-            if (serialConfig?.localEcho) termRef.current?.write("\r\n");
+            if (serialConfig?.localEcho) writeLocalTerminalData("\r\n");
          } else if (ch === "\x15") {
            if (serialConfig?.localEcho && serialLineBufferRef.current.length > 0) {
-              termRef.current?.write("\b \b".repeat(serialLineBufferRef.current.length));
+              writeLocalTerminalData("\b \b".repeat(serialLineBufferRef.current.length));
            }
            serialLineBufferRef.current = "";
          } else if (ch === "\b" || ch === "\x7f") {
            if (serialLineBufferRef.current.length > 0) {
              serialLineBufferRef.current = serialLineBufferRef.current.slice(0, -1);
-              if (serialConfig?.localEcho) termRef.current?.write("\b \b");
+              if (serialConfig?.localEcho) writeLocalTerminalData("\b \b");
            }
          } else if (ch.charCodeAt(0) >= 32) {
            serialLineBufferRef.current += ch;
-            if (serialConfig?.localEcho) termRef.current?.write(ch);
+            if (serialConfig?.localEcho) writeLocalTerminalData(ch);
          }
        }
        // Still update commandBuffer and broadcast for serial line mode
@@ -460,9 +500,9 @@ const TerminalComponent: React.FC<TerminalProps> = ({
        terminalBackend.writeToSession(id, text);
        for (const ch of text) {
          if (ch === "\r") {
-            termRef.current?.write("\r\n");
+            writeLocalTerminalData("\r\n");
          } else if (ch.charCodeAt(0) >= 32) {
-            termRef.current?.write(ch);
+            writeLocalTerminalData(ch);
          }
        }
      } else {
@@ -477,9 +517,14 @@ const TerminalComponent: React.FC<TerminalProps> = ({
      // Update command buffer for onCommandExecuted tracking
      for (const ch of text) {
        if (ch === "\r" || ch === "\n") {
-          const cmd = commandBufferRef.current.trim();
-          if (cmd && onCommandExecuted) onCommandExecuted(cmd, host.id, host.label, sessionId);
-          commandBufferRef.current = "";
+          const rawCommand = commandBufferRef.current;
+          recordTerminalCommandExecution(rawCommand, {
+            host,
+            sessionId,
+            onCommandExecuted,
+            commandBufferRef,
+            promptLineBreakStateRef,
+          }, termRef.current);
        } else if (ch === "\x15") {
          // Ctrl+U: clear line — reset command buffer (fuzzy match sends this)
          commandBufferRef.current = "";
@@ -493,35 +538,54 @@ const TerminalComponent: React.FC<TerminalProps> = ({
    }
  };

-  const autocomplete = useTerminalAutocomplete({
-    termRef,
-    sessionId,
-    hostId: host.id,
-    hostOs: host.os || (host.protocol === "local"
-      ? (navigator.platform?.startsWith("Win") ? "windows" : navigator.platform?.startsWith("Mac") ? "macos" : "linux")
-      : "linux"),
-    settings: terminalSettings ? {
-      enabled: terminalSettings.autocompleteEnabled ?? true,
-      showGhostText: terminalSettings.autocompleteGhostText ?? true,
-      showPopupMenu: terminalSettings.autocompletePopupMenu ?? true,
-      debounceMs: terminalSettings.autocompleteDebounceMs ?? 100,
-      minChars: terminalSettings.autocompleteMinChars ?? 1,
-      maxSuggestions: terminalSettings.autocompleteMaxSuggestions ?? 8,
-    } : undefined,
-    onAcceptText: (text) => autocompleteAcceptTextRef.current?.(text),
-    protocol: host.protocol,
-    getCwd: () => knownCwdRef.current ?? xtermRuntimeRef.current?.currentCwd,
-  });
+  // Autocomplete config — the hook itself lives in <TerminalAutocomplete> so
+  // its state updates don't re-render this component (see render below).
+  const autocompleteHostOs: "linux" | "windows" | "macos" = host.os || (host.protocol === "local"
+    ? (navigator.platform?.startsWith("Win") ? "windows" : navigator.platform?.startsWith("Mac") ? "macos" : "linux")
+    : "linux");
+  const autocompleteSettings = terminalSettings ? {
+    enabled: terminalSettings.autocompleteEnabled ?? true,
+    showGhostText: terminalSettings.autocompleteGhostText ?? true,
+    showPopupMenu: terminalSettings.autocompletePopupMenu ?? true,
+    debounceMs: terminalSettings.autocompleteDebounceMs ?? 100,
+    minChars: terminalSettings.autocompleteMinChars ?? 1,
+    maxSuggestions: terminalSettings.autocompleteMaxSuggestions ?? 8,
+  } : undefined;

-  // Wire up autocomplete handler refs so createXTermRuntime can use them
-  autocompleteKeyEventRef.current = autocomplete.handleKeyEvent;
-  autocompleteInputRef.current = autocomplete.handleInput;
-  autocompleteRepositionRef.current = autocomplete.repositionPopup;
-  const autocompleteClosePopup = autocomplete.closePopup;
+  const resolveSftpInitialPath = useCallback(async (): Promise<string | undefined> => {
+    const cwd = await resolvePreferredTerminalCwd({
+      rendererCwd: terminalCwdTracker.getRendererCwd(),
+      sessionId: sessionRef.current,
+      getSessionPwd: (id) => terminalBackend.getSessionPwd(id),
+    });
+    return cwd ?? undefined;
+  }, [terminalBackend, terminalCwdTracker]);
+
+  const clearTerminalCwd = useCallback(() => {
+    terminalCwdTracker.clearRendererCwd();
+    knownCwdRef.current = undefined;
+    onTerminalCwdChange?.(sessionId, null);
+  }, [onTerminalCwdChange, sessionId, terminalCwdTracker]);

  useEffect(() => {
-    knownCwdRef.current = undefined;
-  }, [sessionId, host.id]);
+    clearTerminalCwd();
+    return clearTerminalCwd;
+  }, [clearTerminalCwd, host.id]);
+
+  // Classify the host's device family from the *detected* distro and the
+  // explicit deviceType only. This intentionally bypasses
+  // getEffectiveHostDistro(): the manual distro override (`distroMode:
+  // 'manual'` + `manualDistro`) is a purely cosmetic icon choice, and a
+  // user who pinned e.g. an "ubuntu" icon on what is actually a Cisco /
+  // Huawei host must not silently re-enable POSIX-shell probes against it.
+  // Several features gate on this — the working-directory probe below, the
+  // /etc/os-release probe, and the periodic server-stats poll (#674) —
+  // because each opens an extra exec channel that strict network-device
+  // CLIs reject or log as a new AAA session, and on Huawei VRP closes the
+  // whole session (#1043).
+  const detectedDeviceClass = classifyDistroId(host.distro);
+  const isNetworkDevice =
+    host.deviceType === 'network' || detectedDeviceClass === 'network-device';

  useEffect(() => {
    if (host.protocol === "local" || host.protocol === "serial" || host.protocol === "telnet") {
@@ -531,10 +595,21 @@ const TerminalComponent: React.FC<TerminalProps> = ({

    let cancelled = false;
    const timer = setTimeout(async () => {
-      if (!sessionRef.current) return;
+      const id = sessionRef.current;
+      if (!id) return;
      try {
-        const result = await terminalBackend.getSessionPwd(sessionRef.current);
-        if (!cancelled && result.success && result.cwd) {
+        // The pwd probe opens an extra POSIX-shell exec channel, which strict
+        // network-device CLIs like Huawei VRP answer by closing the whole
+        // session (#1043). Skip it for known network devices; for a brand-new
+        // host (distro not classified yet on the first connect) consult the
+        // SSH banner, which is captured for free at handshake time.
+        const info = await terminalBackend.getSessionRemoteInfo?.(id);
+        if (cancelled || id !== sessionRef.current) return;
+        if (!shouldProbeSessionCwd({ isNetworkDevice, remoteSshVersion: info?.remoteSshVersion })) {
+          return;
+        }
+        const result = await terminalBackend.getSessionPwd(id);
+        if (!cancelled && !terminalCwdTracker.getRendererCwd() && result.success && result.cwd) {
          knownCwdRef.current = result.cwd;
        }
      } catch {
@@ -546,37 +621,22 @@ const TerminalComponent: React.FC<TerminalProps> = ({
      cancelled = true;
      clearTimeout(timer);
    };
-  }, [host.protocol, status, terminalBackend]);
+  }, [host.protocol, status, terminalBackend, terminalCwdTracker, isNetworkDevice]);

  useEffect(() => {
    if (!isVisible) {
-      autocompleteClosePopup();
+      autocompleteCloseRef.current?.();
    }
-  }, [isVisible, autocompleteClosePopup]);
+  }, [isVisible]);

  // Check if this is a local or serial connection (doesn't need connection dialog during connecting)
  const isLocalConnection = host.protocol === "local";
  const isSerialConnection = host.protocol === "serial";

-  // Server stats (CPU, Memory, Disk) — only for Linux/macOS, and never
-  // for hosts classified as network devices (either via explicit
-  // deviceType='network' or via SSH banner detection that populated
-  // host.distro with a network-vendor ID). See #674: polling the stats
-  // command on Cisco / Huawei / Juniper etc. generates one AAA session
-  // log entry per poll because each exec channel is counted as a new
-  // session on those devices.
-  //
-  // IMPORTANT: this gating must NOT go through getEffectiveHostDistro()
-  // because that honors the manual distro override (`distroMode: 'manual'`
-  // + `manualDistro`) which is purely a cosmetic icon choice. A user who
-  // pinned an "ubuntu" icon on what is actually a Cisco host would
-  // otherwise silently re-enable the polling loop and re-introduce the
-  // AAA log flood this patch is meant to eliminate. The display icon can
-  // still be overridden (see DistroAvatar) — gating uses the raw detected
-  // `host.distro` and the explicit `host.deviceType` only.
-  const detectedDeviceClass = classifyDistroId(host.distro);
-  const isNetworkDevice =
-    host.deviceType === 'network' || detectedDeviceClass === 'network-device';
+  // Server stats (CPU, Memory, Disk) — only for Linux/macOS, never for
+  // network devices. See isNetworkDevice above for why the gating uses the
+  // raw detected distro / explicit deviceType (not getEffectiveHostDistro);
+  // #674 covers the AAA-log-flood motivation for stats specifically.
  const isSupportedOs =
    !isNetworkDevice &&
    (host.os === 'linux' || host.os === 'macos' || detectedDeviceClass === 'linux-like');
@@ -754,12 +814,15 @@ const TerminalComponent: React.FC<TerminalProps> = ({
    hasConnectedRef.current = next === "connected";
    onStatusChange?.(sessionId, next);
  };
+
  const handleTerminalDataCaptureOnce = useCallback((capturedSessionId: string, data: string) => {
    const captureHandler = onTerminalDataCaptureRef.current;
    if (!captureHandler || terminalDataCapturedRef.current) return;
    terminalDataCapturedRef.current = true;
-    captureHandler(capturedSessionId, data);
-  }, []);
+    const replaySafeLogData = finalizeTerminalLogData();
+    const capturedData = replaySafeLogData || data;
+    captureHandler(capturedSessionId, capturedData);
+  }, [finalizeTerminalLogData]);

  const cleanupSession = () => {
    disposeDataRef.current?.();
@@ -811,6 +874,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
    fitAddonRef,
    serializeAddonRef,
    pendingAuthRef,
+    promptLineBreakStateRef,
    updateStatus,
    setStatus,
    setError,
@@ -822,6 +886,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
    setChainProgress,
    t,
    onSessionAttached: (id: string) => {
+      clearTerminalCwd();
      // SSH: always sync. Its backend starts in utf-8 regardless of
      // host.charset, so the push is what keeps the UI state aligned
      // across reconnects — including localhost SSH targets, hence
@@ -845,8 +910,12 @@ const TerminalComponent: React.FC<TerminalProps> = ({
        setSessionEncoding(id, terminalEncodingRef.current);
      }
    },
-    onSessionExit,
+    onSessionExit: (closedSessionId, evt) => {
+      clearTerminalCwd();
+      onSessionExit?.(closedSessionId, evt);
+    },
    onTerminalDataCapture: handleTerminalDataCaptureOnce,
+    onTerminalLogData: captureTerminalLogData,
    onOsDetected,
    onCommandExecuted,
    sessionLog,
@@ -856,6 +925,8 @@ const TerminalComponent: React.FC<TerminalProps> = ({
  useEffect(() => {
    let disposed = false;
    terminalDataCapturedRef.current = false;
+    connectionLogBufferRef.current.reset();
+    terminalLogSanitizerRef.current = createReplaySafeTerminalLogSanitizer();
    setError(null);
    hasConnectedRef.current = false;
    pendingOutputScrollRef.current = false;
@@ -863,6 +934,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
    setShowLogs(false);
    setIsCancelling(false);
    setIsDisconnectedDialogDismissed(false);
+    promptLineBreakStateRef.current = createPromptLineBreakState();

    const boot = async () => {
      try {
@@ -887,13 +959,17 @@ const TerminalComponent: React.FC<TerminalProps> = ({
          statusRef,
          onCommandExecuted,
          commandBufferRef,
+          promptLineBreakStateRef,
          setIsSearchOpen,
          // Serial-specific options
          serialLocalEcho: serialConfig?.localEcho,
          serialLineMode: serialConfig?.lineMode,
          serialLineBufferRef,
+          onTerminalLogData: captureTerminalLogData,
          onCwdChange: (cwd: string) => {
+            terminalCwdTracker.setRendererCwd(cwd);
            knownCwdRef.current = cwd;
+            onTerminalCwdChange?.(sessionId, cwd);
          },
          onOsc52ReadRequest: handleOsc52ReadRequest,
          // Autocomplete integration
@@ -1158,11 +1234,18 @@ const TerminalComponent: React.FC<TerminalProps> = ({
            : 0;
        termRef.current.options.scrollOnUserInput =
          shouldEnableNativeUserInputAutoScroll(terminalSettings);
-        termRef.current.options.altClickMovesCursor = !terminalSettings.altAsMeta;
+        const altKeyOpts = terminalAltKeyOptions(terminalSettings.altAsMeta);
+        termRef.current.options.macOptionIsMeta = altKeyOpts.macOptionIsMeta;
+        termRef.current.options.altClickMovesCursor = altKeyOpts.altClickMovesCursor;
        termRef.current.options.wordSeparator = terminalSettings.wordSeparators;
        termRef.current.options.ignoreBracketedPasteMode = terminalSettings.disableBracketedPaste ?? false;
      }

+      // Changing the font can leave the WebGL renderer drawing stale glyphs from
+      // the old metrics (xterm.js #3280), surfacing as garbled text (issue #1049).
+      // Clear the texture atlas so glyphs re-rasterize with the new font.
+      xtermRuntimeRef.current?.clearTextureAtlas();
+
      if (isVisibleRef.current) {
        setTimeout(() => safeFit({ force: true, requireVisible: true }), 50);
      } else {
@@ -1175,6 +1258,18 @@ const TerminalComponent: React.FC<TerminalProps> = ({
    if (!isVisible) return;
    const timer = setTimeout(() => {
      safeFit({ requireVisible: true });
+      // Recover the WebGL renderer now that this tab is visible again. Hidden
+      // panes stay mounted off-screen (visibility:hidden) so each keeps a live
+      // WebGL context; creating another terminal's context — or the GPU dropping
+      // a non-composited off-screen canvas — can leave this terminal's drawing
+      // buffer corrupted ("花屏", issue #1063). Because a hidden pane keeps its
+      // dimensions, becoming visible triggers no resize and therefore no redraw,
+      // so the corruption persists until the user resizes the window. Force the
+      // same recovery a resize performs: clear the texture atlas (no-op on the
+      // DOM renderer) and synchronously repaint every row.
+      xtermRuntimeRef.current?.clearTextureAtlas();
+      const visibleTerm = termRef.current;
+      if (visibleTerm) forceSyncRenderAfterResize(visibleTerm);
      if (pendingOutputScrollRef.current) {
        termRef.current?.scrollToBottom();
        if (typeof requestAnimationFrame === "function") {
@@ -1396,6 +1491,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({

    const handleContextMenuCapture = (e: MouseEvent) => {
      if (!mouseTrackingRef.current) return;
+      if (statusRef.current !== 'connected') return;
      e.preventDefault();
      e.stopImmediatePropagation();

@@ -1419,7 +1515,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
    };

    const handleMouseUpCapture = (e: MouseEvent) => {
-      if (e.button === 2 && mouseTrackingRef.current) {
+      if (e.button === 2 && mouseTrackingRef.current && statusRef.current === 'connected') {
        e.stopImmediatePropagation();
      }
    };
@@ -1487,10 +1583,21 @@ const TerminalComponent: React.FC<TerminalProps> = ({
    }
    if (!noAutoRun) data = `${data}\r`;

+    // Broadcast the exact bytes the active session receives so peers mirror it,
+    // including the bracketed-paste wrapping and the auto-run \r. Broadcasting
+    // the raw (un-wrapped) form would let a multi-line noAutoRun snippet run
+    // line-by-line on peers, since handleBroadcastInput writes bytes directly
+    // without re-wrapping. Without broadcasting at all, accepting a snippet in
+    // broadcast mode would clear peer input (the clear keystrokes already go
+    // through the broadcast-aware path) but never send the command.
+    if (isBroadcastEnabledRef.current && onBroadcastInputRef.current) {
+      onBroadcastInputRef.current(data, sessionId);
+    }
+
    terminalBackend.writeToSession(id, data);
    scrollToBottomAfterProgrammaticInput(data);
    term.focus();
-  }, [scrollToBottomAfterProgrammaticInput, terminalBackend]);
+  }, [scrollToBottomAfterProgrammaticInput, terminalBackend, sessionId]);

  // Only register the snippet executor once the terminal session is ready.
  // Before that, TerminalLayer falls back to raw writeToSession which is the
@@ -1506,9 +1613,12 @@ const TerminalComponent: React.FC<TerminalProps> = ({

  const terminalContextActions = useTerminalContextActions({
    termRef,
+    sourceSessionId: sessionId,
    sessionRef,
    onHasSelectionChange: setHasSelection,
    scrollOnPasteRef,
+    isBroadcastEnabledRef,
+    onBroadcastInputRef,
  });
  // Kept fresh on every render so the mouseTracking capture handler at
  // handleContextMenuCapture (which is bound once per sessionId) can
@@ -1528,17 +1638,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
  const handleOpenSFTP = async () => {
    if (onOpenSftp) {
      // Delegate to parent (TerminalLayer) for shared SFTP side panel
-      let initialPath: string | undefined = undefined;
-      if (sessionRef.current) {
-        try {
-          const result = await terminalBackend.getSessionPwd(sessionRef.current);
-          if (result.success && result.cwd) {
-            initialPath = result.cwd;
-          }
-        } catch {
-          // Silently fail
-        }
-      }
+      const initialPath = await resolveSftpInitialPath();
      onOpenSftp(host, initialPath, undefined, sessionId);
      return;
    }
@@ -1751,17 +1851,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
      } else {
        // Remote terminal: Trigger SFTP upload via parent
        if (onOpenSftp) {
-          let initialPath: string | undefined = undefined;
-          if (sessionRef.current) {
-            try {
-              const result = await terminalBackend.getSessionPwd(sessionRef.current);
-              if (result.success && result.cwd) {
-                initialPath = result.cwd;
-              }
-            } catch {
-              // Silently fail
-            }
-          }
+          const initialPath = await resolveSftpInitialPath();
          onOpenSftp(host, initialPath, dropEntries, sessionId);
        }
      }
@@ -1820,6 +1910,8 @@ const TerminalComponent: React.FC<TerminalProps> = ({
      onSelectWord={terminalContextActions.onSelectWord}
      onSplitHorizontal={onSplitHorizontal}
      onSplitVertical={onSplitVertical}
+      isReconnectable={status === "disconnected"}
+      onReconnect={handleRetry}
      onClose={inWorkspace ? () => onCloseSession?.(sessionId) : undefined}
    >
      <div
@@ -2288,29 +2380,29 @@ const TerminalComponent: React.FC<TerminalProps> = ({
            }}
          />

-          {/* Autocomplete popup — rendered via Portal to escape overflow:hidden */}
-          {isVisible && autocomplete.state.popupVisible && autocomplete.state.suggestions.length > 0 &&
-            ReactDOM.createPortal(
-              <AutocompletePopup
-                suggestions={autocomplete.state.suggestions}
-                selectedIndex={autocomplete.state.selectedIndex}
-                position={autocomplete.state.popupPosition}
-                cursorLineTop={autocomplete.state.popupCursorLineTop}
-                cursorLineBottom={autocomplete.state.popupCursorLineBottom}
-                visible={autocomplete.state.popupVisible}
-                expandUpward={autocomplete.state.expandUpward}
-                themeColors={effectiveTheme.colors}
-                onSelect={autocomplete.selectSuggestion}
-                subDirPanels={autocomplete.state.subDirPanels}
-                subDirFocusLevel={autocomplete.state.subDirFocusLevel}
-                containerRef={containerRef}
-                onRequestReposition={autocomplete.repositionPopup}
-                searchBarOffset={isSearchOpen ? 64 : 30}
-                onDismiss={autocompleteClosePopup}
-              />,
-              document.body,
-            )
-          }
+          {/* Autocomplete — owns the hook + popup in its own component so
+              suggestion/selection updates don't re-render Terminal. Mounted
+              unconditionally; it gates the popup on `visible` internally. */}
+          <TerminalAutocomplete
+            termRef={termRef}
+            sessionId={sessionId}
+            hostId={host.id}
+            hostOs={autocompleteHostOs}
+            settings={autocompleteSettings}
+            protocol={host.protocol}
+            getCwd={() => terminalCwdTracker.getRendererCwd() ?? knownCwdRef.current}
+            onAcceptText={(text) => autocompleteAcceptTextRef.current?.(text)}
+            snippets={snippets}
+            onAcceptSnippet={(snippet) => executeSnippetCommand(snippet.command, snippet.noAutoRun)}
+            visible={isVisible}
+            themeColors={effectiveTheme.colors}
+            containerRef={containerRef}
+            searchBarOffset={isSearchOpen ? 64 : 30}
+            keyEventRef={autocompleteKeyEventRef}
+            inputRef={autocompleteInputRef}
+            repositionRef={autocompleteRepositionRef}
+            closeRef={autocompleteCloseRef}
+          />

          {/* OSC-52 clipboard read prompt */}
          {osc52ReadPromptVisible && (
@@ -2401,6 +2493,13 @@ const TerminalComponent: React.FC<TerminalProps> = ({
              />
            </div>
          )}
+          {/* ZMODEM overwrite conflict dialog */}
+          {zmodem.overwriteRequest && (
+            <ZmodemOverwriteDialog
+              filename={zmodem.overwriteRequest.filename}
+              onRespond={zmodem.respondOverwrite}
+            />
+          )}
        </div>

        {/* Compose Bar (solo sessions only; workspace uses TerminalLayer's global bar) */}
--- a/components/TerminalLayer.memo.test.tsx
+++ b/components/TerminalLayer.memo.test.tsx
@@ -35,6 +35,8 @@ const baseProps = {
  onAddKnownHost: () => {},
  onToggleWorkspaceViewMode: () => {},
  onSetWorkspaceFocusedSession: () => {},
+  isBroadcastEnabled: () => false,
+  onToggleBroadcast: () => {},
  onSplitSession: () => {},
  toggleScriptsSidePanelRef: { current: null },
 };
@@ -96,3 +98,23 @@ test("TerminalLayer re-renders when proxy profiles change", () => {
    false,
  );
 });
+
+test("TerminalLayer re-renders when broadcast state changes", () => {
+  assert.equal(
+    terminalLayerAreEqual(
+      baseProps as never,
+      { ...baseProps, isBroadcastEnabled: () => true } as never,
+    ),
+    false,
+  );
+});
+
+test("TerminalLayer re-renders when broadcast toggle handler changes", () => {
+  assert.equal(
+    terminalLayerAreEqual(
+      baseProps as never,
+      { ...baseProps, onToggleBroadcast: () => {} } as never,
+    ),
+    false,
+  );
+});
--- a/components/TerminalLayer.tsx
+++ b/components/TerminalLayer.tsx
--- a/components/TextEditorModal.tsx
+++ b/components/TextEditorModal.tsx
@@ -73,7 +73,7 @@ interface TextEditorModalProps {
  onPromoteToTab?: (snapshot: TextEditorModalSnapshot) => void;
 }

-export const TextEditorModal: React.FC<TextEditorModalProps> = ({
+const TextEditorModal: React.FC<TextEditorModalProps> = ({
  open,
  onClose,
  fileName,
--- a/components/ThemeList.tsx
+++ b/components/ThemeList.tsx
@@ -2,15 +2,16 @@
 * Shared theme list component used by both ThemeSelectPanel and ThemeSelectModal
 */
 import React, { memo, useMemo } from 'react';
-import { Check } from 'lucide-react';
+import { Check, Wand2 } from 'lucide-react';
 import { useI18n } from '../application/i18n/I18nProvider';
 import { TERMINAL_THEMES, USER_VISIBLE_TERMINAL_THEMES, isUiMatchTerminalThemeId } from '../infrastructure/config/terminalThemes';
+import { TERMINAL_THEME_AUTO } from '../domain/terminalAppearance';
 import { useCustomThemes } from '../application/state/customThemeStore';
 import { cn } from '../lib/utils';
 import { TerminalTheme } from '../types';

 // Memoized theme item component
-export const ThemeItem = memo(({
+const ThemeItem = memo(({
    theme,
    isSelected,
    onSelect
@@ -53,13 +54,18 @@ ThemeItem.displayName = 'ThemeItem';
 interface ThemeListProps {
    selectedThemeId: string;
    onSelect: (themeId: string) => void;
+    /** Restrict the list to a single type; omit to show both sections. */
+    filterType?: 'dark' | 'light';
+    /** Render an "Auto (match app theme)" entry at the top. */
+    showAutoOption?: boolean;
 }

-export const ThemeList: React.FC<ThemeListProps> = ({ selectedThemeId, onSelect }) => {
+export const ThemeList: React.FC<ThemeListProps> = ({ selectedThemeId, onSelect, filterType, showAutoOption }) => {
    const { t } = useI18n();
    const customThemes = useCustomThemes();
    const deletedSelectedTheme = useMemo(
        () => (selectedThemeId
+            && selectedThemeId !== TERMINAL_THEME_AUTO
            && !isUiMatchTerminalThemeId(selectedThemeId)
            && !TERMINAL_THEMES.some((theme) => theme.id === selectedThemeId)
            && !customThemes.some((theme) => theme.id === selectedThemeId)
@@ -80,8 +86,33 @@ export const ThemeList: React.FC<ThemeListProps> = ({ selectedThemeId, onSelect
        return { darkThemes: dark, lightThemes: light };
    }, []);

+    const visibleCustomThemes = filterType
+        ? customThemes.filter(theme => theme.type === filterType)
+        : customThemes;
+    const isAutoSelected = selectedThemeId === TERMINAL_THEME_AUTO;
+
    return (
        <>
+            {showAutoOption && (
+                <button
+                    onClick={() => onSelect(TERMINAL_THEME_AUTO)}
+                    className={cn(
+                        'w-full flex items-center gap-3 px-3 py-2.5 mb-3 rounded-md text-left transition-all',
+                        isAutoSelected ? 'bg-primary/10' : 'hover:bg-muted',
+                    )}
+                >
+                    <div className="w-12 h-8 rounded-[4px] flex-shrink-0 flex items-center justify-center border border-border/50 bg-gradient-to-br from-muted to-background">
+                        <Wand2 size={14} className="text-muted-foreground" />
+                    </div>
+                    <div className="flex-1 min-w-0">
+                        <div className={cn('text-sm font-medium truncate', isAutoSelected ? 'text-primary' : 'text-foreground')}>
+                            {t('settings.terminal.theme.auto')}
+                        </div>
+                        <div className="text-[10px] text-muted-foreground">{t('settings.terminal.theme.autoDesc')}</div>
+                    </div>
+                    {isAutoSelected && <Check size={16} className="text-primary flex-shrink-0" />}
+                </button>
+            )}
            {hiddenSelectedTheme && (
                <div className="mb-4 rounded-lg border border-border/60 bg-muted/30 px-3 py-2.5">
                    <div className="text-[10px] uppercase tracking-wider text-muted-foreground mb-1 font-semibold">
@@ -105,6 +136,7 @@ export const ThemeList: React.FC<ThemeListProps> = ({ selectedThemeId, onSelect
                </div>
            )}
            {/* Dark Themes Section */}
+            {(!filterType || filterType === 'dark') && (
            <div className="mb-4">
                <div className="text-[10px] uppercase tracking-wider text-muted-foreground mb-2 font-semibold px-3">
                    {t('settings.terminal.themeModal.darkThemes')}
@@ -120,8 +152,10 @@ export const ThemeList: React.FC<ThemeListProps> = ({ selectedThemeId, onSelect
                    ))}
                </div>
            </div>
+            )}

            {/* Light Themes Section */}
+            {(!filterType || filterType === 'light') && (
            <div>
                <div className="text-[10px] uppercase tracking-wider text-muted-foreground mb-2 font-semibold px-3">
                    {t('settings.terminal.themeModal.lightThemes')}
@@ -137,15 +171,16 @@ export const ThemeList: React.FC<ThemeListProps> = ({ selectedThemeId, onSelect
                    ))}
                </div>
            </div>
+            )}

            {/* Custom Themes Section */}
-            {customThemes.length > 0 && (
+            {visibleCustomThemes.length > 0 && (
                <div className="mt-4">
                    <div className="text-[10px] uppercase tracking-wider text-muted-foreground mb-2 font-semibold px-3">
                        {t('terminal.customTheme.section')}
                    </div>
                    <div className="space-y-1">
-                        {customThemes.map(theme => (
+                        {visibleCustomThemes.map(theme => (
                            <ThemeItem
                                key={theme.id}
                                theme={theme}
--- a/components/TopTabs.tsx
+++ b/components/TopTabs.tsx
--- a/components/TrafficDiagram.tsx
+++ b/components/TrafficDiagram.tsx
@@ -190,5 +190,3 @@ export const TrafficDiagram: React.FC<TrafficDiagramProps> = ({ type, isAnimatin
        </div>
    );
 };
-
-export default TrafficDiagram;
--- a/components/VaultView.sortPersistence.test.tsx
+++ b/components/VaultView.sortPersistence.test.tsx
@@ -0,0 +1,142 @@
+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.tsx";
+import { STORAGE_KEY_VAULT_HOSTS_SORT_MODE } from "../infrastructure/config/storageKeys.ts";
+import type { Host, SSHKey } from "../types.ts";
+import { VaultView } from "./VaultView.tsx";
+import { TooltipProvider } from "./ui/tooltip.tsx";
+
+const installStorageStub = (sortMode: string | null) => {
+  const values = new Map<string, string>();
+  if (sortMode !== null) {
+    values.set(STORAGE_KEY_VAULT_HOSTS_SORT_MODE, sortMode);
+  }
+
+  Object.defineProperty(globalThis, "localStorage", {
+    configurable: true,
+    value: {
+      getItem: (key: string) => values.get(key) ?? null,
+      setItem: (key: string, value: string) => {
+        values.set(key, value);
+      },
+      removeItem: (key: string) => {
+        values.delete(key);
+      },
+    },
+  });
+};
+
+const host = (id: string, label: string, createdAt: number, group = ""): Host => ({
+  id,
+  label,
+  hostname: `${id}.example.com`,
+  username: "root",
+  tags: [],
+  os: "linux",
+  port: 22,
+  protocol: "ssh",
+  authMethod: "password",
+  createdAt,
+  group,
+});
+
+const fallbackKey: SSHKey = {
+  id: "key-1",
+  label: "Fallback key",
+  type: "ED25519",
+  privateKey: "",
+  source: "generated",
+  category: "key",
+  created: 1,
+};
+
+const renderVault = (sortMode: string | null, hosts: Host[]) => {
+  installStorageStub(sortMode);
+  const noop = () => {};
+
+  return renderToStaticMarkup(
+    React.createElement(
+      I18nProvider,
+      { locale: "en" },
+      React.createElement(
+        TooltipProvider,
+        null,
+        React.createElement(VaultView, {
+          hosts,
+          keys: [],
+          identities: [],
+          proxyProfiles: [],
+          snippets: [],
+          snippetPackages: [],
+          customGroups: [],
+          knownHosts: [],
+          shellHistory: [],
+          connectionLogs: [],
+          managedSources: [],
+          sessionCount: 0,
+          hotkeyScheme: "mac",
+          keyBindings: [],
+          terminalThemeId: "default",
+          terminalFontSize: 14,
+          onOpenSettings: noop,
+          onOpenQuickSwitcher: noop,
+          onCreateLocalTerminal: noop,
+          onDeleteHost: noop,
+          onConnect: noop,
+          onUpdateHosts: noop,
+          onUpdateKeys: noop,
+          onImportOrReuseKey: () => fallbackKey,
+          onUpdateIdentities: noop,
+          onUpdateProxyProfiles: noop,
+          onUpdateSnippets: noop,
+          onUpdateSnippetPackages: noop,
+          onUpdateCustomGroups: noop,
+          onUpdateKnownHosts: noop,
+          onUpdateManagedSources: noop,
+          onConvertKnownHost: noop,
+          onToggleConnectionLogSaved: noop,
+          onDeleteConnectionLog: noop,
+          onClearUnsavedConnectionLogs: noop,
+          onOpenLogView: noop,
+          groupConfigs: [],
+          onUpdateGroupConfigs: noop,
+          showRecentHosts: false,
+          showOnlyUngroupedHostsInRoot: false,
+        }),
+      ),
+    ),
+  );
+};
+
+test("Hosts sort mode is restored from storage", () => {
+  const markup = renderVault("za", [
+    host("alpha", "Alpha Host", 1),
+    host("zulu", "Zulu Host", 2),
+  ]);
+
+  assert.ok(markup.indexOf("Zulu Host") < markup.indexOf("Alpha Host"));
+});
+
+test("Hosts grouped sort mode is restored from storage", () => {
+  const markup = renderVault("group", [
+    host("beta", "Beta Host", 1, "Beta Group"),
+    host("alpha", "Alpha Host", 2, "Alpha Group"),
+  ]);
+
+  assert.match(
+    markup,
+    /<span class="text-sm font-medium text-muted-foreground">Alpha Group<\/span><span class="text-xs text-muted-foreground\/60">\(1\)<\/span>/,
+  );
+});
+
+test("Hosts sort mode falls back safely when storage contains an invalid value", () => {
+  const markup = renderVault("unknown-sort", [
+    host("zulu", "Zulu Host", 2),
+    host("alpha", "Alpha Host", 1),
+  ]);
+
+  assert.ok(markup.indexOf("Alpha Host") < markup.indexOf("Zulu Host"));
+});
--- a/components/VaultView.tsx
+++ b/components/VaultView.tsx
@@ -35,6 +35,7 @@ import React, { Suspense, lazy, memo, startTransition, useCallback, useEffect, u
 import { useI18n } from "../application/i18n/I18nProvider";
 import { useStoredViewMode } from "../application/state/useStoredViewMode";
 import { useStoredBoolean } from "../application/state/useStoredBoolean";
+import { useStoredString } from "../application/state/useStoredString";
 import { useTreeExpandedState } from "../application/state/useTreeExpandedState";
 import { sanitizeCredentialValue } from "../domain/credentials";
 import { resolveGroupDefaults, applyGroupDefaults } from "../domain/groupConfig";
@@ -50,6 +51,7 @@ import { upsertKnownHost } from "../domain/knownHosts";
 import { importVaultHostsFromText, exportHostsToCsvWithStats } from "../domain/vaultImport";
 import type { VaultImportFormat } from "../domain/vaultImport";
 import {
+  STORAGE_KEY_VAULT_HOSTS_SORT_MODE,
  STORAGE_KEY_VAULT_HOSTS_TREE_EXPANDED,
  STORAGE_KEY_VAULT_HOSTS_VIEW_MODE,
  STORAGE_KEY_VAULT_SIDEBAR_COLLAPSED,
@@ -70,7 +72,6 @@ import {
  SSHKey,
  ShellHistoryEntry,
  Snippet,
-  TerminalSession,
 } from "../types";
 import { AppLogo } from "./AppLogo";
 import { DistroAvatar } from "./DistroAvatar";
@@ -122,6 +123,13 @@ type DropTarget =
  | { kind: "root" }
  | { kind: "group"; path: string };

+const isSortMode = (value: string): value is SortMode =>
+  value === "az" ||
+  value === "za" ||
+  value === "newest" ||
+  value === "oldest" ||
+  value === "group";
+
 // Props without isActive - it's now subscribed internally
 interface VaultViewProps {
  hosts: Host[];
@@ -135,7 +143,7 @@ interface VaultViewProps {
  shellHistory: ShellHistoryEntry[];
  connectionLogs: ConnectionLog[];
  managedSources: ManagedSource[];
-  sessions: TerminalSession[];
+  sessionCount: number;
  hotkeyScheme: HotkeyScheme;
  keyBindings: KeyBinding[];
  terminalThemeId: string;
@@ -187,7 +195,7 @@ const VaultViewInner: React.FC<VaultViewProps> = ({
  shellHistory,
  connectionLogs,
  managedSources,
-  sessions,
+  sessionCount,
  hotkeyScheme,
  keyBindings,
  terminalThemeId,
@@ -281,7 +289,11 @@ const VaultViewInner: React.FC<VaultViewProps> = ({
    "grid",
  );
  const treeExpandedState = useTreeExpandedState(STORAGE_KEY_VAULT_HOSTS_TREE_EXPANDED);
-  const [sortMode, setSortMode] = useState<SortMode>("az");
+  const [sortMode, setSortMode] = useStoredString<SortMode>(
+    STORAGE_KEY_VAULT_HOSTS_SORT_MODE,
+    "az",
+    isSortMode,
+  );
  const [selectedTags, setSelectedTags] = useState<string[]>([]);
  const [selectedHostIds, setSelectedHostIds] = useState<Set<string>>(new Set());
  const [isMultiSelectMode, setIsMultiSelectMode] = useState(false);
@@ -2511,7 +2523,7 @@ const VaultViewInner: React.FC<VaultViewProps> = ({
                        {t("vault.hosts.header.entries", { count: viewMode === "tree" ? treeViewHosts.length : visibleDisplayedHosts.length })}
                      </span>
                      <div className="bg-secondary/80 border border-border/70 rounded-md px-2 py-1 text-[11px]">
-                        {t("vault.hosts.header.live", { count: sessions.length })}
+                        {t("vault.hosts.header.live", { count: sessionCount })}
                      </div>
                    </div>
                  </div>
@@ -3291,7 +3303,7 @@ export const vaultViewAreEqual = (
    prev.knownHosts === next.knownHosts &&
    prev.shellHistory === next.shellHistory &&
    prev.connectionLogs === next.connectionLogs &&
-    prev.sessions === next.sessions &&
+    prev.sessionCount === next.sessionCount &&
    prev.managedSources === next.managedSources &&
    prev.groupConfigs === next.groupConfigs &&
    prev.terminalThemeId === next.terminalThemeId &&
--- a/components/ai-elements/message.tsx
+++ b/components/ai-elements/message.tsx
@@ -4,6 +4,7 @@ import { code } from '@streamdown/code';
 import type { ComponentProps, HTMLAttributes } from 'react';
 import { memo } from 'react';
 import { Streamdown } from 'streamdown';
+import { createSafeCodeHighlighter } from './streamdownCodeHighlighter';

 export type MessageProps = HTMLAttributes<HTMLDivElement> & {
  from: 'user' | 'assistant' | 'system' | 'tool';
@@ -46,21 +47,8 @@ export const MessageContent = ({ children, className, from, ...props }: MessageC
  </div>
 );

-export type MessageActionsProps = ComponentProps<'div'>;
-
-export const MessageActions = ({ className, children, ...props }: MessageActionsProps) => (
-  <div
-    className={cn(
-      'flex items-center gap-1 opacity-0 group-hover:opacity-100 transition-opacity',
-      className,
-    )}
-    {...props}
-  >
-    {children}
-  </div>
-);
-
-const streamdownPlugins = { cjk, code };
+const safeCode = createSafeCodeHighlighter(code);
+const streamdownPlugins = { cjk, code: safeCode };

 export type MessageResponseProps = ComponentProps<typeof Streamdown>;

--- a/components/ai-elements/prompt-input.tsx
+++ b/components/ai-elements/prompt-input.tsx
@@ -11,7 +11,6 @@ import type {
  FormEvent,
  HTMLAttributes,
  KeyboardEvent,
-  ReactNode,
 } from 'react';
 import { forwardRef, useCallback, useRef } from 'react';
 import { cn } from '../../lib/utils';
@@ -145,37 +144,6 @@ export const PromptInputTools = forwardRef<HTMLDivElement, PromptInputToolsProps
 );
 PromptInputTools.displayName = 'PromptInputTools';

-// ---------------------------------------------------------------------------
-// PromptInputButton (toolbar button with optional tooltip)
-// ---------------------------------------------------------------------------
-
-export interface PromptInputButtonProps extends ComponentProps<typeof InputGroupButton> {
-  tooltip?: ReactNode;
-  tooltipSide?: 'top' | 'bottom' | 'left' | 'right';
-}
-
-export const PromptInputButton = forwardRef<HTMLButtonElement, PromptInputButtonProps>(
-  ({ tooltip, tooltipSide = 'top', ...props }, ref) => {
-    const button = <InputGroupButton ref={ref} {...props} />;
-
-    if (!tooltip) return button;
-
-    return (
-      <TooltipProvider>
-        <Tooltip>
-          <TooltipTrigger asChild>{button}</TooltipTrigger>
-          <TooltipContent side={tooltipSide}>{tooltip}</TooltipContent>
-        </Tooltip>
-      </TooltipProvider>
-    );
-  },
-);
-PromptInputButton.displayName = 'PromptInputButton';
-
-// ---------------------------------------------------------------------------
-// PromptInputSubmit
-// ---------------------------------------------------------------------------
-
 export type PromptInputStatus = 'idle' | 'submitted' | 'streaming' | 'error';

 export interface PromptInputSubmitProps extends ComponentProps<typeof InputGroupButton> {
@@ -244,4 +212,3 @@ export const PromptInputSubmit = forwardRef<HTMLButtonElement, PromptInputSubmit
  },
 );
 PromptInputSubmit.displayName = 'PromptInputSubmit';
-
--- a/components/ai-elements/streamdownCodeHighlighter.ts
+++ b/components/ai-elements/streamdownCodeHighlighter.ts
@@ -0,0 +1,76 @@
+import type {
+  CodeHighlighterPlugin,
+  HighlightOptions,
+  HighlightResult,
+} from 'streamdown';
+import type { BundledLanguage } from 'shiki';
+
+const PLAIN_TEXT_LANGUAGES = new Set([
+  '',
+  'plain',
+  'plaintext',
+  'text',
+  'txt',
+]);
+
+const LANGUAGE_ALIASES: Record<string, BundledLanguage> = {
+  cfg: 'ini',
+  conf: 'ini',
+  config: 'ini',
+};
+
+export const createPlainCodeHighlightResult = (source: string): HighlightResult => {
+  const code = source.replace(/\n+$/, '');
+  return {
+    bg: 'transparent',
+    fg: 'inherit',
+    tokens: code.split('\n').map((line) => [
+      {
+        content: line,
+        color: 'inherit',
+        bgColor: 'transparent',
+        htmlStyle: {},
+        offset: 0,
+      },
+    ]),
+  };
+};
+
+const normalizeLanguageKey = (language: string): string =>
+  language.trim().toLowerCase();
+
+export const resolveSupportedCodeLanguage = (
+  highlighter: CodeHighlighterPlugin,
+  language: string,
+): BundledLanguage | null => {
+  const key = normalizeLanguageKey(language);
+  if (PLAIN_TEXT_LANGUAGES.has(key)) return null;
+
+  const direct = key as BundledLanguage;
+  if (highlighter.supportsLanguage(direct)) return direct;
+
+  const alias = LANGUAGE_ALIASES[key];
+  if (alias && highlighter.supportsLanguage(alias)) return alias;
+
+  return null;
+};
+
+export const createSafeCodeHighlighter = (
+  highlighter: CodeHighlighterPlugin,
+): CodeHighlighterPlugin => ({
+  ...highlighter,
+  supportsLanguage(language) {
+    return resolveSupportedCodeLanguage(highlighter, language) !== null;
+  },
+  highlight(options: HighlightOptions, callback?: (result: HighlightResult) => void) {
+    const supportedLanguage = resolveSupportedCodeLanguage(highlighter, options.language);
+    if (!supportedLanguage) {
+      return createPlainCodeHighlightResult(options.code);
+    }
+
+    return highlighter.highlight(
+      { ...options, language: supportedLanguage },
+      callback,
+    );
+  },
+});
--- a/components/ai/claudeConfigEnv.test.ts
+++ b/components/ai/claudeConfigEnv.test.ts
@@ -0,0 +1,61 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  splitClaudeEnv,
+  buildClaudeEnv,
+  parseEnvLines,
+  serializeEnvLines,
+} from "../settings/tabs/ai/claudeConfigEnv";
+
+test("splitClaudeEnv pulls out config dir and hides CLAUDE_CODE_EXECUTABLE", () => {
+  const result = splitClaudeEnv({
+    CLAUDE_CONFIG_DIR: "/cfg",
+    CLAUDE_CODE_EXECUTABLE: "/usr/bin/claude",
+    ANTHROPIC_API_KEY: "sk-x",
+  });
+  assert.equal(result.configDir, "/cfg");
+  assert.equal(result.envText, "ANTHROPIC_API_KEY=sk-x");
+});
+
+test("splitClaudeEnv handles undefined env", () => {
+  assert.deepEqual(splitClaudeEnv(undefined), { configDir: "", envText: "" });
+});
+
+test("parseEnvLines parses KEY=VALUE, trims keys, keeps value as-is, skips blanks/comments", () => {
+  assert.deepEqual(
+    parseEnvLines("ANTHROPIC_API_KEY = sk-x\n# comment\n\nANTHROPIC_BASE_URL=https://h/?a=b"),
+    { ANTHROPIC_API_KEY: "sk-x", ANTHROPIC_BASE_URL: "https://h/?a=b" },
+  );
+});
+
+test("serializeEnvLines is the inverse for simple entries", () => {
+  assert.equal(serializeEnvLines({ A: "1", B: "2" }), "A=1\nB=2");
+});
+
+test("buildClaudeEnv merges config dir + parsed env, preserves CLAUDE_CODE_EXECUTABLE, drops empties", () => {
+  const prev = { CLAUDE_CODE_EXECUTABLE: "/usr/bin/claude", OLD: "x" };
+  const next = buildClaudeEnv(prev, "/cfg", "ANTHROPIC_API_KEY=sk-x");
+  assert.deepEqual(next, {
+    CLAUDE_CODE_EXECUTABLE: "/usr/bin/claude",
+    CLAUDE_CONFIG_DIR: "/cfg",
+    ANTHROPIC_API_KEY: "sk-x",
+  });
+});
+
+test("buildClaudeEnv omits config dir when blank and returns undefined when empty", () => {
+  assert.equal(buildClaudeEnv(undefined, "  ", ""), undefined);
+});
+
+test("buildClaudeEnv ignores managed keys typed into the env editor", () => {
+  const next = buildClaudeEnv(
+    { CLAUDE_CODE_EXECUTABLE: "/usr/bin/claude" },
+    "/cfg",
+    "CLAUDE_CODE_EXECUTABLE=/evil/claude\nCLAUDE_CONFIG_DIR=/evil/dir\nANTHROPIC_API_KEY=sk-x",
+  );
+  assert.deepEqual(next, {
+    CLAUDE_CODE_EXECUTABLE: "/usr/bin/claude",
+    CLAUDE_CONFIG_DIR: "/cfg",
+    ANTHROPIC_API_KEY: "sk-x",
+  });
+});
--- a/components/ai/hooks/useAIChatStreaming.ts
+++ b/components/ai/hooks/useAIChatStreaming.ts
@@ -143,6 +143,7 @@ export interface PanelBridge extends NetcattyBridge {
    cwd?: string,
    providerId?: string,
    chatSessionId?: string,
+    agentEnv?: Record<string, string>,
  ) => Promise<{ ok: boolean; models?: Array<{ id: string; name: string; description?: string; thinkingLevels?: string[] }>; currentModelId?: string | null; error?: string }>;
  aiAcpCleanup?: (chatSessionId: string) => Promise<{ ok: boolean }>;
  aiUserSkillsGetStatus?: () => Promise<{
--- a/components/ai/managedAgentState.test.ts
+++ b/components/ai/managedAgentState.test.ts
@@ -68,6 +68,21 @@ test('buildManagedAgentState keeps unrelated defaults when removing stale manage
  assert.equal(state.defaultAgentId, 'custom-agent');
 });

+test('buildManagedAgentState stores the system Claude executable for ACP runs', () => {
+  const state = buildManagedAgentState(
+    [],
+    'catty',
+    'claude',
+    { path: '/opt/homebrew/bin/claude', version: '2.1.145 (Claude Code)', available: true },
+  );
+
+  assert.equal(state.agents.length, 1);
+  assert.equal(state.agents[0].command, '/opt/homebrew/bin/claude');
+  assert.deepEqual(state.agents[0].env, {
+    CLAUDE_CODE_EXECUTABLE: '/opt/homebrew/bin/claude',
+  });
+});
+
 test('buildManagedAgentState does not remove user-created matching agents', () => {
  const agents: ExternalAgentConfig[] = [
    {
--- a/components/ai/streamdownCodeHighlighter.test.ts
+++ b/components/ai/streamdownCodeHighlighter.test.ts
@@ -0,0 +1,90 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import type {
+  CodeHighlighterPlugin,
+  HighlightOptions,
+  HighlightResult,
+} from 'streamdown';
+import {
+  createPlainCodeHighlightResult,
+  createSafeCodeHighlighter,
+  resolveSupportedCodeLanguage,
+} from '../ai-elements/streamdownCodeHighlighter';
+
+const createFakeHighlighter = (
+  supportedLanguages: string[],
+  highlightImpl?: CodeHighlighterPlugin['highlight'],
+): CodeHighlighterPlugin => ({
+  name: 'shiki',
+  type: 'code-highlighter',
+  getSupportedLanguages: () => supportedLanguages as ReturnType<CodeHighlighterPlugin['getSupportedLanguages']>,
+  getThemes: () => ['github-light', 'github-dark'],
+  supportsLanguage: (language) => supportedLanguages.includes(language),
+  highlight: highlightImpl ?? ((options: HighlightOptions): HighlightResult => ({
+    tokens: [[{ content: options.language, offset: 0 }]],
+  })),
+});
+
+test('maps generic conf fences to ini for Streamdown highlighting', () => {
+  const highlighter = createFakeHighlighter(['ini']);
+
+  assert.equal(resolveSupportedCodeLanguage(highlighter, 'conf'), 'ini');
+  assert.equal(resolveSupportedCodeLanguage(highlighter, ' config '), 'ini');
+});
+
+test('falls back to plain tokens for unsupported languages', () => {
+  const highlighter = createSafeCodeHighlighter(
+    createFakeHighlighter([], () => {
+      throw new Error('delegate should not be called for unsupported languages');
+    }),
+  );
+
+  const result = highlighter.highlight({
+    code: '*.* action(type="omfwd"\n           Target="10.185.3.1")\n',
+    language: 'conf',
+    themes: ['github-light', 'github-dark'],
+  });
+
+  assert.deepEqual(
+    result?.tokens.map((line) => line.map((token) => token.content).join('')),
+    ['*.* action(type="omfwd"', '           Target="10.185.3.1")'],
+  );
+});
+
+test('uses supported aliases when highlighting generic config blocks', () => {
+  let receivedLanguage: string | null = null;
+  const highlighter = createSafeCodeHighlighter(
+    createFakeHighlighter(['ini'], (options: HighlightOptions): HighlightResult => {
+      receivedLanguage = options.language;
+      return createPlainCodeHighlightResult(options.code);
+    }),
+  );
+
+  const result = highlighter.highlight({
+    code: '*.* action(type="omfwd")',
+    language: 'conf',
+    themes: ['github-light', 'github-dark'],
+  });
+
+  assert.equal(receivedLanguage, 'ini');
+  assert.equal(result?.tokens[0][0].content, '*.* action(type="omfwd")');
+});
+
+test('treats text fences as plain code without calling the delegate', () => {
+  const highlighter = createSafeCodeHighlighter(
+    createFakeHighlighter(['ini'], () => {
+      throw new Error('delegate should not be called for text fences');
+    }),
+  );
+
+  const result = highlighter.highlight({
+    code: 'hello\nworld',
+    language: 'text',
+    themes: ['github-light', 'github-dark'],
+  });
+
+  assert.deepEqual(
+    result?.tokens.map((line) => line[0].content),
+    ['hello', 'world'],
+  );
+});
--- a/components/keychain/index.ts
+++ b/components/keychain/index.ts
@@ -6,8 +6,7 @@

 // Utilities and types
 export {
-copyToClipboard,detectKeyType,generateMockKeyPair,getKeyIcon,
-getKeyTypeDisplay,isMacOS,type FilterTab,type PanelMode
+isMacOS,type FilterTab,type PanelMode
 } from './utils';

 // Card components
--- a/components/keychain/utils.ts
+++ b/components/keychain/utils.ts
@@ -7,33 +7,6 @@ import React from 'react';
 import { logger } from '../../lib/logger';
 import { KeyType, SSHKey } from '../../types';

-/**
- * Generate mock key pair (for fallback when Electron backend is unavailable)
- */
-export const generateMockKeyPair = (type: KeyType, label: string, keySize?: number): { privateKey: string; publicKey: string } => {
-    const typeMap: Record<KeyType, string> = {
-        'ED25519': 'ed25519',
-        'ECDSA': `ecdsa-sha2-nistp${keySize || 256}`,
-        'RSA': 'rsa',
-    };
-
-    const randomId = crypto.randomUUID().replace(/-/g, '').substring(0, 32);
-
-    // Generate size-appropriate random data for more realistic keys
-    const keyLength = type === 'RSA' ? (keySize || 4096) / 8 : 32;
-    const randomData = Array.from(crypto.getRandomValues(new Uint8Array(keyLength)))
-        .map(b => b.toString(16).padStart(2, '0')).join('');
-
-    const privateKey = `-----BEGIN OPENSSH PRIVATE KEY-----
-b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW
-QyNTUxOQAAACB${randomId}AAAEC${randomData.substring(0, 64)}
-----END OPENSSH PRIVATE KEY-----`;
-
-    const publicKey = `ssh-${typeMap[type]} AAAAC3NzaC1lZDI1NTE5AAAAI${randomId.substring(0, 20)} ${label}@netcatty`;
-
-    return { privateKey, publicKey };
-};
-
 /**
 * Get icon element for key source
 */
--- a/components/port-forwarding/index.ts
+++ b/components/port-forwarding/index.ts
@@ -1,29 +1,17 @@
 /**
 * Port Forwarding components module
- * Re-exports all port forwarding sub-components
+ * Re-exports the entries consumed by the top-level port forwarding view.
 */

 export {
-  TYPE_DESCRIPTION_KEYS,
-  TYPE_LABEL_KEYS,
-  TYPE_MENU_LABEL_KEYS,
-  TYPE_ICONS,
  generateRuleLabel,
-  getStatusColor,
-  getTypeColor,
-  getTypeDescription,
-  getTypeLabel,
  getTypeMenuLabel,
 } from './utils';

 export { RuleCard } from './RuleCard';
-export type { RuleCardProps,ViewMode } from './RuleCard';

 export { WizardContent } from './WizardContent';
-export type { WizardContentProps,WizardStep } from './WizardContent';

 export { EditPanel } from './EditPanel';
-export type { EditPanelProps } from './EditPanel';

 export { NewFormPanel } from './NewFormPanel';
-export type { NewFormPanelProps } from './NewFormPanel';
--- a/components/port-forwarding/utils.tsx
+++ b/components/port-forwarding/utils.tsx
@@ -1,23 +1,21 @@
 /**
 * Port Forwarding utilities and constants
 */
-import { Globe,Server,Shuffle } from 'lucide-react';
-import React from 'react';
 import { PortForwardingType } from '../../domain/models';

-export const TYPE_LABEL_KEYS: Record<PortForwardingType, string> = {
+const TYPE_LABEL_KEYS: Record<PortForwardingType, string> = {
  local: 'pf.type.local',
  remote: 'pf.type.remote',
  dynamic: 'pf.type.dynamic',
 };

-export const TYPE_MENU_LABEL_KEYS: Record<PortForwardingType, string> = {
+const TYPE_MENU_LABEL_KEYS: Record<PortForwardingType, string> = {
  local: 'pf.type.menu.local',
  remote: 'pf.type.menu.remote',
  dynamic: 'pf.type.menu.dynamic',
 };

-export const TYPE_DESCRIPTION_KEYS: Record<PortForwardingType, string> = {
+const TYPE_DESCRIPTION_KEYS: Record<PortForwardingType, string> = {
  local: 'pf.type.local.desc',
  remote: 'pf.type.remote.desc',
  dynamic: 'pf.type.dynamic.desc',
@@ -44,12 +42,6 @@ export function getTypeDescription(
  return t(TYPE_DESCRIPTION_KEYS[type]);
 }

-export const TYPE_ICONS: Record<PortForwardingType, React.ReactNode> = {
-  local: <Globe size={16} />,
-  remote: <Server size={16} />,
-  dynamic: <Shuffle size={16} />,
-};
-
 /**
 * Get status color class for a rule
 */
--- a/components/settings/ThemeSelectModal.tsx
+++ b/components/settings/ThemeSelectModal.tsx
@@ -15,6 +15,8 @@ interface ThemeSelectModalProps {
    onClose: () => void;
    selectedThemeId: string;
    onSelect: (themeId: string) => void;
+    filterType?: 'dark' | 'light';
+    showAutoOption?: boolean;
 }

 export const ThemeSelectModal: React.FC<ThemeSelectModalProps> = ({
@@ -22,6 +24,8 @@ export const ThemeSelectModal: React.FC<ThemeSelectModalProps> = ({
    onClose,
    selectedThemeId,
    onSelect,
+    filterType,
+    showAutoOption,
 }) => {
    const { t } = useI18n();

@@ -85,6 +89,8 @@ export const ThemeSelectModal: React.FC<ThemeSelectModalProps> = ({
                    <ThemeList
                        selectedThemeId={selectedThemeId}
                        onSelect={handleThemeSelect}
+                        filterType={filterType}
+                        showAutoOption={showAutoOption}
                    />
                </div>

--- a/components/settings/tabs/SettingsAITab.tsx
+++ b/components/settings/tabs/SettingsAITab.tsx
@@ -48,6 +48,7 @@ import {
  buildManagedAgentState,
  getInitialManagedAgentPaths,
 } from "./ai/managedAgentState";
+import { splitClaudeEnv, buildClaudeEnv } from "./ai/claudeConfigEnv";

 // ---------------------------------------------------------------------------
 // Props
@@ -125,6 +126,29 @@ const SettingsAITab: React.FC<SettingsAITabProps> = ({
  const [claudePathInfo, setClaudePathInfo] = useState<AgentPathInfo | null>(null);
  const [claudeCustomPath, setClaudeCustomPath] = useState("");
  const [isResolvingClaude, setIsResolvingClaude] = useState(false);
+
+  const claudeManagedEnv = useMemo(
+    () => externalAgents.find((a) => a.id === "discovered_claude")?.env,
+    [externalAgents],
+  );
+  const { configDir: claudeConfigDir, envText: claudeEnvText } = useMemo(
+    () => splitClaudeEnv(claudeManagedEnv),
+    [claudeManagedEnv],
+  );
+
+  const updateClaudeEnv = useCallback(
+    (nextConfigDir: string, nextEnvText: string) => {
+      setExternalAgents((prev) =>
+        prev.map((a) =>
+          a.id === "discovered_claude"
+            ? { ...a, env: buildClaudeEnv(a.env, nextConfigDir, nextEnvText) }
+            : a,
+        ),
+      );
+    },
+    [setExternalAgents],
+  );
+
  const initialManagedPathsRef = useRef<{
    codex: string;
    claude: string;
@@ -542,6 +566,10 @@ const SettingsAITab: React.FC<SettingsAITabProps> = ({
              customPath={claudeCustomPath}
              onCustomPathChange={setClaudeCustomPath}
              onRecheckPath={() => void handleCheckCustomPath("claude")}
+              configDir={claudeConfigDir}
+              onConfigDirChange={(v) => updateClaudeEnv(v, claudeEnvText)}
+              envText={claudeEnvText}
+              onEnvTextChange={(v) => updateClaudeEnv(claudeConfigDir, v)}
            />
          </div>

--- a/components/settings/tabs/SettingsSyncTab.tsx
+++ b/components/settings/tabs/SettingsSyncTab.tsx
@@ -6,12 +6,11 @@ import {
  buildLocalVaultPayload,
  buildSyncPayload,
  applySyncPayload,
+  getEffectivePortForwardingRulesForSync,
 } from "../../../application/syncPayload";
 import { applyProtectedSyncPayload } from "../../../application/localVaultBackups";
 import type { SyncableVaultData } from "../../../application/syncPayload";
 import { useI18n } from "../../../application/i18n/I18nProvider";
-import { STORAGE_KEY_PORT_FORWARDING } from "../../../infrastructure/config/storageKeys";
-import { localStorageAdapter } from "../../../infrastructure/persistence/localStorageAdapter";
 import { getEffectiveKnownHosts } from "../../../infrastructure/syncHelpers";
 import { CloudSyncSettings } from "../../CloudSyncSettings";
 import { SettingsTabContent } from "../settings-ui";
@@ -35,28 +34,7 @@ export default function SettingsSyncTab(props: {
  const { t } = useI18n();

  const getEffectivePortForwardingRules = useCallback((): PortForwardingRule[] => {
-    // If hook state is empty but localStorage has data, the async store
-    // initialization hasn't finished yet.  Read from localStorage directly
-    // to avoid uploading empty arrays and overwriting the remote snapshot.
-    let effectiveRules = portForwardingRules;
-    if (effectiveRules.length === 0) {
-      const stored = localStorageAdapter.read<PortForwardingRule[]>(
-        STORAGE_KEY_PORT_FORWARDING,
-      );
-      if (stored && Array.isArray(stored) && stored.length > 0) {
-        // Strip transient per-device fields (status, error, lastUsedAt)
-        // that setGlobalRules persists to localStorage but shouldn't be
-        // included in the cloud sync snapshot.
-        effectiveRules = stored.map(({ status: _status, error: _error, ...rest }) => ({
-          ...rest,
-          status: "inactive" as const,
-          error: undefined,
-          lastUsedAt: undefined,
-        }));
-      }
-    }
-
-    return effectiveRules;
+    return getEffectivePortForwardingRulesForSync(portForwardingRules) ?? [];
  }, [portForwardingRules]);

  const onBuildPayload = useCallback((): SyncPayload => {
--- a/components/settings/tabs/SettingsTerminalTab.tsx
+++ b/components/settings/tabs/SettingsTerminalTab.tsx
@@ -27,6 +27,7 @@ import { TerminalFontSelect } from "../TerminalFontSelect";
 import { TerminalCjkFontSelect } from "../TerminalCjkFontSelect";
 import { CustomThemeModal } from "../../terminal/CustomThemeModal";
 import type { TerminalTheme } from "../../../domain/models";
+import { resolveFollowedTerminalThemeId, TERMINAL_THEME_AUTO } from "../../../domain/terminalAppearance";

 // Keyword highlight rules editor for global settings
 const DEFAULT_NEW_RULE_COLOR = '#F87171';
@@ -315,6 +316,12 @@ export default function SettingsTerminalTab(props: {
  setTerminalThemeId: (id: string) => void;
  followAppTerminalTheme: boolean;
  setFollowAppTerminalTheme: (value: boolean) => void;
+  terminalThemeDarkId: string;
+  setTerminalThemeDarkId: (id: string) => void;
+  terminalThemeLightId: string;
+  setTerminalThemeLightId: (id: string) => void;
+  lightUiThemeId: string;
+  darkUiThemeId: string;
  terminalFontFamilyId: string;
  setTerminalFontFamilyId: (id: string) => void;
  terminalFontSize: number;
@@ -333,6 +340,12 @@ export default function SettingsTerminalTab(props: {
    setTerminalThemeId,
    followAppTerminalTheme,
    setFollowAppTerminalTheme,
+    terminalThemeDarkId,
+    setTerminalThemeDarkId,
+    terminalThemeLightId,
+    setTerminalThemeLightId,
+    lightUiThemeId,
+    darkUiThemeId,
    terminalFontFamilyId,
    setTerminalFontFamilyId,
    terminalFontSize,
@@ -364,6 +377,7 @@ export default function SettingsTerminalTab(props: {
    setShowCustomShellInput(!discoveredShells.some(s => s.id === terminalSettings.localShell));
  }, [discoveredShells, terminalSettings.localShell]);
  const [themeModalOpen, setThemeModalOpen] = useState(false);
+  const [themeModalSlot, setThemeModalSlot] = useState<'dark' | 'light' | null>(null);

  // Subscribe to custom theme changes so editing in-place triggers re-render
  const customThemes = useCustomThemes();
@@ -375,6 +389,38 @@ export default function SettingsTerminalTab(props: {
      || TERMINAL_THEMES[0];
  }, [terminalThemeId, customThemes]);

+  // Preview themes for the follow-app per-mode pickers. resolvedTheme is
+  // forced per slot so each preview reflects exactly that mode's selection.
+  const darkPreviewTheme = useMemo(() => {
+    const id = resolveFollowedTerminalThemeId({
+      resolvedTheme: 'dark',
+      terminalThemeDarkId, terminalThemeLightId,
+      lightUiThemeId, darkUiThemeId, fallbackThemeId: terminalThemeId,
+    });
+    return TERMINAL_THEMES.find(t => t.id === id)
+      || customThemes.find(t => t.id === id)
+      // Mirror the runtime fallback in useSettingsState.currentTerminalTheme:
+      // a deleted per-mode override falls back to the manual theme, not [0].
+      || TERMINAL_THEMES.find(t => t.id === terminalThemeId)
+      || customThemes.find(t => t.id === terminalThemeId)
+      || TERMINAL_THEMES[0];
+  }, [terminalThemeDarkId, terminalThemeLightId, lightUiThemeId, darkUiThemeId, terminalThemeId, customThemes]);
+
+  const lightPreviewTheme = useMemo(() => {
+    const id = resolveFollowedTerminalThemeId({
+      resolvedTheme: 'light',
+      terminalThemeDarkId, terminalThemeLightId,
+      lightUiThemeId, darkUiThemeId, fallbackThemeId: terminalThemeId,
+    });
+    return TERMINAL_THEMES.find(t => t.id === id)
+      || customThemes.find(t => t.id === id)
+      // Mirror the runtime fallback in useSettingsState.currentTerminalTheme:
+      // a deleted per-mode override falls back to the manual theme, not [0].
+      || TERMINAL_THEMES.find(t => t.id === terminalThemeId)
+      || customThemes.find(t => t.id === terminalThemeId)
+      || TERMINAL_THEMES[0];
+  }, [terminalThemeDarkId, terminalThemeLightId, lightUiThemeId, darkUiThemeId, terminalThemeId, customThemes]);
+
  const handleAutocompleteGhostTextChange = useCallback((enabled: boolean) => {
    updateTerminalSetting("autocompleteGhostText", enabled);
    if (enabled) {
@@ -556,7 +602,34 @@ export default function SettingsTerminalTab(props: {
          />
        </SettingRow>
      </div>
-      {!followAppTerminalTheme && (
+      {followAppTerminalTheme ? (
+        <div className="space-y-2">
+          <div>
+            <div className="text-xs text-muted-foreground mb-1.5 px-1">
+              {t("settings.terminal.theme.darkTheme")}
+            </div>
+            <ThemePreviewButton
+              theme={darkPreviewTheme}
+              onClick={() => setThemeModalSlot('dark')}
+              buttonLabel={terminalThemeDarkId === TERMINAL_THEME_AUTO
+                ? t("settings.terminal.theme.auto")
+                : t("settings.terminal.theme.selectButton")}
+            />
+          </div>
+          <div>
+            <div className="text-xs text-muted-foreground mb-1.5 px-1">
+              {t("settings.terminal.theme.lightTheme")}
+            </div>
+            <ThemePreviewButton
+              theme={lightPreviewTheme}
+              onClick={() => setThemeModalSlot('light')}
+              buttonLabel={terminalThemeLightId === TERMINAL_THEME_AUTO
+                ? t("settings.terminal.theme.auto")
+                : t("settings.terminal.theme.selectButton")}
+            />
+          </div>
+        </div>
+      ) : (
        <ThemePreviewButton
          theme={currentTheme}
          onClick={() => setThemeModalOpen(true)}
@@ -570,6 +643,17 @@ export default function SettingsTerminalTab(props: {
        selectedThemeId={terminalThemeId}
        onSelect={setTerminalThemeId}
      />
+      <ThemeSelectModal
+        open={themeModalSlot !== null}
+        onClose={() => setThemeModalSlot(null)}
+        selectedThemeId={themeModalSlot === 'dark' ? terminalThemeDarkId : terminalThemeLightId}
+        onSelect={(id) => {
+          if (themeModalSlot === 'dark') setTerminalThemeDarkId(id);
+          else if (themeModalSlot === 'light') setTerminalThemeLightId(id);
+        }}
+        filterType={themeModalSlot === 'light' ? 'light' : 'dark'}
+        showAutoOption
+      />

      {/* Theme action buttons */}
      <div className="flex items-center gap-2 -mt-1">
@@ -810,6 +894,12 @@ export default function SettingsTerminalTab(props: {
        >
          <Toggle checked={terminalSettings.altAsMeta} onChange={(v) => updateTerminalSetting("altAsMeta", v)} />
        </SettingRow>
+        <SettingRow
+          label={t("settings.terminal.keyboard.optionArrowWordJump")}
+          description={t("settings.terminal.keyboard.optionArrowWordJump.desc")}
+        >
+          <Toggle checked={terminalSettings.optionArrowWordJump} onChange={(v) => updateTerminalSetting("optionArrowWordJump", v)} />
+        </SettingRow>
      </div>

      <SectionHeader title={t("settings.terminal.section.accessibility")} />
@@ -890,6 +980,13 @@ export default function SettingsTerminalTab(props: {
          <Toggle checked={terminalSettings.preserveSelectionOnInput ?? false} onChange={(v) => updateTerminalSetting("preserveSelectionOnInput", v)} />
        </SettingRow>

+        <SettingRow
+          label={t("settings.terminal.behavior.forcePromptNewLine")}
+          description={t("settings.terminal.behavior.forcePromptNewLine.desc")}
+        >
+          <Toggle checked={terminalSettings.forcePromptNewLine ?? false} onChange={(v) => updateTerminalSetting("forcePromptNewLine", v)} />
+        </SettingRow>
+
        <SettingRow
          label={t("settings.terminal.behavior.osc52Clipboard")}
          description={t("settings.terminal.behavior.osc52Clipboard.desc")}
@@ -983,6 +1080,29 @@ export default function SettingsTerminalTab(props: {
        </div>
      </div>

+      <SectionHeader title={t("settings.terminal.section.startupCommand")} />
+      <div className="rounded-lg border bg-card p-4">
+        <p className="text-sm text-muted-foreground mb-3">
+          {t("settings.terminal.startupCommandDelay.desc")}
+        </p>
+        <div className="space-y-1">
+          <Label className="text-xs">{t("settings.terminal.startupCommandDelay.label")}</Label>
+          <Input
+            type="number"
+            min={0}
+            max={10000}
+            value={terminalSettings.startupCommandDelayMs}
+            onChange={(e) => {
+              const val = parseInt(e.target.value);
+              if (!isNaN(val) && val >= 0 && val <= 10000) {
+                updateTerminalSetting("startupCommandDelayMs", val);
+              }
+            }}
+            className="w-full"
+          />
+        </div>
+      </div>
+
      <SectionHeader title={t("settings.terminal.section.keywordHighlight")} />
      <div className="rounded-lg border bg-card p-4">
        <div className="flex items-center justify-between mb-4">
--- a/components/settings/tabs/ai/ClaudeCodeCard.tsx
+++ b/components/settings/tabs/ai/ClaudeCodeCard.tsx
@@ -1,10 +1,11 @@
-import React from "react";
-import { RefreshCw } from "lucide-react";
+import React, { useEffect, useState } from "react";
+import { ChevronDown, RefreshCw } from "lucide-react";
 import { useI18n } from "../../../../application/i18n/I18nProvider";
 import { Button } from "../../../ui/button";
 import { cn } from "../../../../lib/utils";
 import type { AgentPathInfo } from "./types";
 import { ProviderIconBadge } from "./ProviderIconBadge";
+import { parseEnvLines, serializeEnvLines } from "./claudeConfigEnv";

 export const ClaudeCodeCard: React.FC<{
  pathInfo: AgentPathInfo | null;
@@ -12,15 +13,40 @@ export const ClaudeCodeCard: React.FC<{
  customPath: string;
  onCustomPathChange: (path: string) => void;
  onRecheckPath: () => void;
+  configDir: string;
+  onConfigDirChange: (value: string) => void;
+  envText: string;
+  onEnvTextChange: (value: string) => void;
 }> = ({
  pathInfo,
  isResolvingPath,
  customPath,
  onCustomPathChange,
  onRecheckPath,
+  configDir,
+  onConfigDirChange,
+  envText,
+  onEnvTextChange,
 }) => {
  const { t } = useI18n();
  const found = pathInfo?.available;
+  // Collapsed by default; auto-expand when the user already has config so it
+  // isn't hidden. Local UI state — not persisted.
+  const [configOpen, setConfigOpen] = useState(
+    () => Boolean(configDir.trim() || envText.trim()),
+  );
+
+  // The env editor keeps the raw text the user types. Persisting parses it into
+  // a record (dropping incomplete lines), so binding the textarea directly to
+  // the persisted value would erase a key the moment it's typed before its "=".
+  // Only resync from the persisted value when it changes for some reason other
+  // than our own parse→serialize round-trip.
+  const [envDraft, setEnvDraft] = useState(envText);
+  useEffect(() => {
+    setEnvDraft((prev) =>
+      serializeEnvLines(parseEnvLines(prev)) === envText ? prev : envText,
+    );
+  }, [envText]);

  const statusText = isResolvingPath
    ? t('ai.claude.detecting')
@@ -83,6 +109,53 @@ export const ClaudeCodeCard: React.FC<{
          </div>
        </div>
      ) : null}
+
+      {/* Authentication & config (optional, collapsible) */}
+      <div className="border-t border-border/60 pt-3">
+        <button
+          type="button"
+          onClick={() => setConfigOpen((v) => !v)}
+          aria-expanded={configOpen}
+          className="flex w-full items-center justify-between gap-2 text-left"
+        >
+          <span className="text-xs font-medium text-muted-foreground">
+            {t('ai.claude.configSection')}
+          </span>
+          <ChevronDown
+            size={14}
+            className={cn("text-muted-foreground transition-transform", configOpen && "rotate-180")}
+          />
+        </button>
+        {configOpen && (
+          <div className="space-y-3 mt-3">
+            <div className="space-y-1.5">
+              <label htmlFor="claude-config-dir" className="text-xs text-muted-foreground">{t('ai.claude.configDir')}</label>
+              <input
+                id="claude-config-dir"
+                type="text"
+                value={configDir}
+                onChange={(e) => onConfigDirChange(e.target.value)}
+                placeholder={t('ai.claude.configDir.placeholder')}
+                className="w-full h-8 rounded-md border border-input bg-background px-3 text-sm font-mono placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring"
+              />
+              <p className="text-[11px] text-muted-foreground leading-4">{t('ai.claude.configDir.hint')}</p>
+            </div>
+            <div className="space-y-1.5">
+              <label htmlFor="claude-env-vars" className="text-xs text-muted-foreground">{t('ai.claude.envVars')}</label>
+              <textarea
+                id="claude-env-vars"
+                value={envDraft}
+                onChange={(e) => { setEnvDraft(e.target.value); onEnvTextChange(e.target.value); }}
+                placeholder={t('ai.claude.envVars.placeholder')}
+                rows={3}
+                spellCheck={false}
+                className="w-full rounded-md border border-input bg-background px-3 py-2 text-sm font-mono placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring resize-y"
+              />
+              <p className="text-[11px] text-muted-foreground leading-4">{t('ai.claude.envVars.hint')}</p>
+            </div>
+          </div>
+        )}
+      </div>
    </div>
  );
 };
--- a/components/settings/tabs/ai/claudeConfigEnv.ts
+++ b/components/settings/tabs/ai/claudeConfigEnv.ts
@@ -0,0 +1,65 @@
+/**
+ * Pure helpers for the Claude Code card's "config directory + environment
+ * variables" editor. The managed Claude agent stores everything in its
+ * ExternalAgentConfig.env; this splits that into the editable pieces and
+ * recombines them. CLAUDE_CODE_EXECUTABLE is owned by path discovery, so it
+ * is preserved across edits but never shown in the env editor.
+ */
+
+const CONFIG_DIR_KEY = "CLAUDE_CONFIG_DIR";
+const MANAGED_KEYS = new Set(["CLAUDE_CODE_EXECUTABLE", CONFIG_DIR_KEY]);
+
+export function parseEnvLines(text: string): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const rawLine of String(text || "").split("\n")) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    const key = line.slice(0, eq).trim();
+    const value = line.slice(eq + 1).trim();
+    if (key) out[key] = value;
+  }
+  return out;
+}
+
+export function serializeEnvLines(env: Record<string, string>): string {
+  return Object.entries(env)
+    .map(([k, v]) => `${k}=${v}`)
+    .join("\n");
+}
+
+export function splitClaudeEnv(
+  env: Record<string, string> | undefined,
+): { configDir: string; envText: string } {
+  if (!env) return { configDir: "", envText: "" };
+  const configDir = env[CONFIG_DIR_KEY] ?? "";
+  const rest: Record<string, string> = {};
+  for (const [k, v] of Object.entries(env)) {
+    if (MANAGED_KEYS.has(k)) continue;
+    rest[k] = v;
+  }
+  return { configDir, envText: serializeEnvLines(rest) };
+}
+
+export function buildClaudeEnv(
+  prevEnv: Record<string, string> | undefined,
+  configDir: string,
+  envText: string,
+): Record<string, string> | undefined {
+  const next: Record<string, string> = {};
+  // Preserve discovery-owned key if present.
+  const exe = prevEnv?.CLAUDE_CODE_EXECUTABLE;
+  if (exe) next.CLAUDE_CODE_EXECUTABLE = exe;
+
+  const trimmedDir = String(configDir || "").trim();
+  if (trimmedDir) next[CONFIG_DIR_KEY] = trimmedDir;
+
+  // Drop managed keys if a user typed them into the free-text editor — the
+  // config-dir field and path discovery own CLAUDE_CONFIG_DIR / CLAUDE_CODE_EXECUTABLE.
+  const parsed = parseEnvLines(envText);
+  for (const key of MANAGED_KEYS) delete parsed[key];
+  Object.assign(next, parsed);
+
+  return Object.keys(next).length > 0 ? next : undefined;
+}
--- a/components/settings/tabs/ai/index.ts
+++ b/components/settings/tabs/ai/index.ts
@@ -1,9 +0,0 @@
-export { ProviderIconBadge } from "./ProviderIconBadge";
-export { ModelSelector } from "./ModelSelector";
-export { ProviderConfigForm } from "./ProviderConfigForm";
-export { ProviderCard } from "./ProviderCard";
-export { AddProviderDropdown } from "./AddProviderDropdown";
-export { CodexConnectionCard } from "./CodexConnectionCard";
-export { ClaudeCodeCard } from "./ClaudeCodeCard";
-export { CopilotCliCard } from "./CopilotCliCard";
-export { SafetySettings } from "./SafetySettings";
--- a/components/settings/tabs/ai/managedAgentState.ts
+++ b/components/settings/tabs/ai/managedAgentState.ts
@@ -47,11 +47,15 @@ export function buildManagedAgentState(

  const existingManaged = managedAgents.find((agent) => agent.id === managedId);
  const defaults = AGENT_DEFAULTS[agentKey];
+  const managedEnv = agentKey === "claude"
+    ? { ...(existingManaged?.env ?? {}), CLAUDE_CODE_EXECUTABLE: pathInfo.path }
+    : existingManaged?.env;
  const nextManagedAgent: ExternalAgentConfig = {
    ...existingManaged,
    ...defaults,
    id: managedId,
    command: pathInfo.path,
+    ...(managedEnv ? { env: managedEnv } : {}),
    enabled: managedAgents.length === 0 ? true : managedAgents.some((agent) => agent.enabled),
  };

--- a/components/sftp/SftpContext.tsx
+++ b/components/sftp/SftpContext.tsx
@@ -104,12 +104,6 @@ export const useActiveTabId = (side: "left" | "right"): string | null => {
    );
 };

-// Hook to check if a specific pane is active (for CSS control)
-export const useIsPaneActive = (side: "left" | "right", paneId: string): boolean => {
-    const activeTabId = useActiveTabId(side);
-    return activeTabId === paneId || (activeTabId === null && paneId !== null);
-};
-
 export interface SftpContextValue {
    // Hosts list for connection picker
    hosts: Host[];
--- a/components/sftp/SftpOverlays.tsx
+++ b/components/sftp/SftpOverlays.tsx
@@ -3,10 +3,13 @@ import type { Host, SftpFileEntry } from "../../types";
 import type { FileOpenerType, SystemAppInfo } from "../../lib/sftpFileUtils";
 import type { useSftpState } from "../../application/state/useSftpState";
 import type { HotkeyScheme, KeyBinding } from "../../domain/models";
+import type { TransferTask } from "../../types";
 import FileOpenerDialog from "../FileOpenerDialog";
 import TextEditorModal from "../TextEditorModal";
 import type { TextEditorModalSnapshot } from "../TextEditorModal";
-import { SftpConflictDialog, SftpHostPicker, SftpPermissionsDialog } from "./index";
+import { SftpConflictDialog } from "./SftpConflictDialog";
+import { SftpHostPicker } from "./SftpHostPicker";
+import { SftpPermissionsDialog } from "./SftpPermissionsDialog";
 import { SftpTransferQueue } from "./SftpTransferQueue";

 type SftpState = ReturnType<typeof useSftpState>;
@@ -16,6 +19,10 @@ interface SftpOverlaysProps {
  sftp: SftpState;
  visibleTransfers: SftpState["transfers"];
  showTransferQueue?: boolean;
+  canRevealTransferTarget?: (task: TransferTask) => boolean;
+  onRevealTransferTarget?: (task: TransferTask) => void | Promise<void>;
+  canCopyTransferTargetPath?: (task: TransferTask) => boolean;
+  onCopyTransferTargetPath?: (task: TransferTask) => void | Promise<void>;
  showHostPickerLeft: boolean;
  showHostPickerRight: boolean;
  hostSearchLeft: string;
@@ -54,6 +61,10 @@ export const SftpOverlays: React.FC<SftpOverlaysProps> = React.memo(({
  sftp,
  visibleTransfers,
  showTransferQueue = true,
+  canRevealTransferTarget,
+  onRevealTransferTarget,
+  canCopyTransferTargetPath,
+  onCopyTransferTargetPath,
  showHostPickerLeft,
  showHostPickerRight,
  hostSearchLeft,
@@ -111,7 +122,15 @@ export const SftpOverlays: React.FC<SftpOverlaysProps> = React.memo(({
      />

      {showTransferQueue && (
-        <SftpTransferQueue sftp={sftp} visibleTransfers={visibleTransfers} allTransfers={sftp.transfers} />
+        <SftpTransferQueue
+          sftp={sftp}
+          visibleTransfers={visibleTransfers}
+          allTransfers={sftp.transfers}
+          canRevealTransferTarget={canRevealTransferTarget}
+          onRevealTransferTarget={onRevealTransferTarget}
+          canCopyTransferTargetPath={canCopyTransferTargetPath}
+          onCopyTransferTargetPath={onCopyTransferTargetPath}
+        />
      )}

      <SftpConflictDialog
--- a/components/sftp/SftpPaneDialogs.tsx
+++ b/components/sftp/SftpPaneDialogs.tsx
@@ -12,7 +12,7 @@ import {
 import { Input } from "../ui/input";
 import { Label } from "../ui/label";
 import { getFileName, getParentPath } from "../../application/state/sftp/utils";
-import { SftpHostPicker } from "./index";
+import { SftpHostPicker } from "./SftpHostPicker";
 import type { Host } from "../../types";

 interface SftpPaneDialogsProps {
--- a/components/sftp/SftpPaneFileList.tsx
+++ b/components/sftp/SftpPaneFileList.tsx
@@ -14,10 +14,9 @@ import type { SftpFileEntry } from "../../types";
 import type { SftpPane } from "../../application/state/sftp/types";
 import type { SftpTransferSource } from "./SftpContext";
 import { sftpListOrderStore } from "./hooks/useSftpListOrderStore";
-import { buildSftpColumnTemplate, type ColumnWidths, type SortField, type SortOrder } from "./utils";
-import { isNavigableDirectory } from "./index";
+import { buildSftpColumnTemplate, isNavigableDirectory, type ColumnWidths, type SortField, type SortOrder } from "./utils";
 import { isKnownBinaryFile } from "../../lib/sftpFileUtils";
-import { SftpFileRow } from "./index";
+import { SftpFileRow } from "./SftpFileRow";
 import {
  getSftpListUploadFilesTargetPath,
  getSftpUploadFilesLabelKey,
--- a/components/sftp/SftpPaneToolbar.tsx
+++ b/components/sftp/SftpPaneToolbar.tsx
@@ -6,7 +6,7 @@ import { Popover, PopoverClose, PopoverContent, PopoverTrigger } from "../ui/pop
 import { Dropdown, DropdownContent, DropdownTrigger } from "../ui/dropdown";
 import { cn } from "../../lib/utils";
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "../ui/tooltip";
-import { SftpBreadcrumb } from "./index";
+import { SftpBreadcrumb } from "./SftpBreadcrumb";
 import type { SftpFilenameEncoding } from "../../types";
 import type { SftpPane } from "../../application/state/sftp/types";
 import type { SftpBookmark } from "../../domain/models";
--- a/components/sftp/SftpPaneView.tsx
+++ b/components/sftp/SftpPaneView.tsx
@@ -15,7 +15,7 @@ import {
  useSftpPaneCallbacks,
  useSftpUpdateHosts,
  useSftpWritableHosts,
-} from "./index";
+} from "./SftpContext";
 import type { SftpPane } from "../../application/state/sftp/types";
 import { joinPath } from "../../application/state/sftp/utils";
 import type { Host } from "../../domain/models";
--- a/components/sftp/SftpTabBar.tsx
+++ b/components/sftp/SftpTabBar.tsx
@@ -20,6 +20,7 @@ import React, {
 } from "react";
 import { useI18n } from "../../application/i18n/I18nProvider";
 import { logger } from "../../lib/logger";
+import { handleTabMiddleClickClose, handleTabMiddleMouseDown } from "../../lib/tabInteractions";
 import { useRenderTracker } from "../../lib/useRenderTracker";
 import { Tooltip, TooltipContent, TooltipTrigger } from "../ui/tooltip";
 import { cn } from "../../lib/utils";
@@ -322,6 +323,8 @@ const SftpTabBarInner: React.FC<SftpTabBarProps> = ({
                data-tab-type="sftp"
                data-state={isActive ? 'active' : 'inactive'}
                onClick={(e) => handleSelectTabClick(e, tab.id)}
+                onMouseDown={handleTabMiddleMouseDown}
+                onAuxClick={(e) => handleTabMiddleClickClose(e, () => onCloseTab(tab.id))}
                draggable
                onDragStart={(e) => handleTabDragStart(e, tab.id)}
                onDragEnd={handleTabDragEnd}
--- a/components/sftp/SftpTransferItem.tsx
+++ b/components/sftp/SftpTransferItem.tsx
@@ -8,7 +8,9 @@ import {
    CheckCircle2,
    ChevronDown,
    ChevronUp,
+    ClipboardCopy,
    File,
+    FolderOpen,
    FolderUp,
    GripVertical,
    Loader2,
@@ -35,6 +37,8 @@ interface SftpTransferItemProps {
    onDismiss: () => void;
    canRevealTarget?: boolean;
    onRevealTarget?: () => void;
+    canCopyTargetPath?: boolean;
+    onCopyTargetPath?: () => void;
    canToggleChildren?: boolean;
    isExpanded?: boolean;
    visibleChildCount?: number;
@@ -84,6 +88,8 @@ const SftpTransferItemInner: React.FC<SftpTransferItemProps> = ({
    onDismiss,
    canRevealTarget = false,
    onRevealTarget,
+    canCopyTargetPath = false,
+    onCopyTargetPath,
    canToggleChildren = false,
    isExpanded = false,
    visibleChildCount: _visibleChildCount = 0,
@@ -209,6 +215,8 @@ const SftpTransferItemInner: React.FC<SftpTransferItemProps> = ({
    const dismissActionLabel = t('sftp.transfers.dismissAction');
    const resizeNameColumnLabel = t('sftp.transfers.resizeNameColumn');
    const toggleChildrenLabel = isExpanded ? t('sftp.transfers.collapseChildList') : t('sftp.transfers.expandChildList');
+    const revealTargetLabel = t('sftp.transfers.openTargetFolder');
+    const copyTargetPathLabel = t('sftp.transfers.copyTargetPath');
    const actionButtonClass = "h-6 w-6 focus-visible:ring-1 focus-visible:ring-primary/50";
    const actionAriaLabel = (label: string) => `${label}: ${task.fileName}`;

@@ -238,6 +246,20 @@ const SftpTransferItemInner: React.FC<SftpTransferItemProps> = ({

    const actionButtons = (
        <div className="flex items-center gap-1 shrink-0">
+            {canRevealTarget && onRevealTarget && (
+                <IconButtonWithTooltip label={revealTargetLabel}>
+                    <Button variant="ghost" size="icon" className={actionButtonClass} onClick={onRevealTarget} aria-label={actionAriaLabel(revealTargetLabel)}>
+                        <FolderOpen size={12} />
+                    </Button>
+                </IconButtonWithTooltip>
+            )}
+            {canCopyTargetPath && onCopyTargetPath && (
+                <IconButtonWithTooltip label={copyTargetPathLabel}>
+                    <Button variant="ghost" size="icon" className={actionButtonClass} onClick={onCopyTargetPath} aria-label={actionAriaLabel(copyTargetPathLabel)}>
+                        <ClipboardCopy size={12} />
+                    </Button>
+                </IconButtonWithTooltip>
+            )}
            {task.status === 'failed' && task.retryable !== false && (
                <IconButtonWithTooltip label={retryActionLabel}>
                    <Button variant="ghost" size="icon" className={actionButtonClass} onClick={onRetry} aria-label={actionAriaLabel(retryActionLabel)}>
@@ -355,6 +377,7 @@ const SftpTransferItemInner: React.FC<SftpTransferItemProps> = ({
                        type="button"
                        className="flex min-w-0 flex-1 rounded-sm text-left transition-colors hover:bg-primary/5 focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-primary/50"
                        onClick={onRevealTarget}
+                        aria-label={actionAriaLabel(revealTargetLabel)}
                    >
                        {titleBlock}
                    </button>
@@ -440,6 +463,7 @@ const arePropsEqual = (
    if (prev.targetPath !== next.targetPath) return false;
    if (prev.totalBytes !== next.totalBytes) return false;
    if ((prevProps.canRevealTarget ?? false) !== (nextProps.canRevealTarget ?? false)) return false;
+    if ((prevProps.canCopyTargetPath ?? false) !== (nextProps.canCopyTargetPath ?? false)) return false;
    if ((prevProps.isChild ?? false) !== (nextProps.isChild ?? false)) return false;
    if ((prevProps.childNameColumnWidth ?? 260) !== (nextProps.childNameColumnWidth ?? 260)) return false;
    if ((prevProps.canToggleChildren ?? false) !== (nextProps.canToggleChildren ?? false)) return false;
--- a/components/sftp/SftpTransferQueue.tsx
+++ b/components/sftp/SftpTransferQueue.tsx
@@ -20,6 +20,8 @@ interface SftpTransferQueueProps {
  allTransfers: SftpState["transfers"];
  canRevealTransferTarget?: (task: TransferTask) => boolean;
  onRevealTransferTarget?: (task: TransferTask) => void | Promise<void>;
+  canCopyTransferTargetPath?: (task: TransferTask) => boolean;
+  onCopyTransferTargetPath?: (task: TransferTask) => void | Promise<void>;
 }

 const MIN_PANEL_HEIGHT = 112;
@@ -151,6 +153,8 @@ export const SftpTransferQueue: React.FC<SftpTransferQueueProps> = ({
  allTransfers,
  canRevealTransferTarget,
  onRevealTransferTarget,
+  canCopyTransferTargetPath,
+  onCopyTransferTargetPath,
 }) => {
  const { t } = useI18n();
  const [expandedParents, setExpandedParents] = useState<Record<string, boolean>>({});
@@ -417,6 +421,14 @@ export const SftpTransferQueue: React.FC<SftpTransferQueueProps> = ({
                      }
                    : undefined
                }
+                canCopyTargetPath={canCopyTransferTargetPath?.(task) ?? false}
+                onCopyTargetPath={
+                  onCopyTransferTargetPath
+                    ? () => {
+                        void onCopyTransferTargetPath(task);
+                      }
+                    : undefined
+                }
              />

              {isExpanded && childTasks.length > 0 && (
--- a/components/sftp/hooks/useGlobalSftpBookmarks.ts
+++ b/components/sftp/hooks/useGlobalSftpBookmarks.ts
@@ -1,44 +1,10 @@
 import { useCallback, useMemo, useSyncExternalStore } from "react";
-import type { SftpBookmark } from "../../../domain/models";
-import { localStorageAdapter } from "../../../infrastructure/persistence/localStorageAdapter";
-import { STORAGE_KEY_SFTP_GLOBAL_BOOKMARKS } from "../../../infrastructure/config/storageKeys";
-
-type Listener = () => void;
-const listeners = new Set<Listener>();
-
-let snapshot: SftpBookmark[] =
-    localStorageAdapter.read<SftpBookmark[]>(STORAGE_KEY_SFTP_GLOBAL_BOOKMARKS) ?? [];
-
-function subscribe(listener: Listener) {
-    listeners.add(listener);
-    return () => { listeners.delete(listener); };
-}
-
-function getSnapshot() {
-    return snapshot;
-}
-
-/** Re-read bookmarks from localStorage (e.g. after cloud sync import). */
-export function rehydrateGlobalBookmarks() {
-    snapshot = localStorageAdapter.read<SftpBookmark[]>(STORAGE_KEY_SFTP_GLOBAL_BOOKMARKS) ?? [];
-    for (const l of listeners) l();
-}
-
-// Rehydrate when another window updates the same localStorage key
-if (typeof window !== 'undefined') {
-    window.addEventListener('storage', (e) => {
-        if (e.key === STORAGE_KEY_SFTP_GLOBAL_BOOKMARKS) {
-            rehydrateGlobalBookmarks();
-        }
-    });
-}
-
-function setBookmarks(next: SftpBookmark[] | ((prev: SftpBookmark[]) => SftpBookmark[])) {
-    snapshot = typeof next === "function" ? next(snapshot) : next;
-    localStorageAdapter.write(STORAGE_KEY_SFTP_GLOBAL_BOOKMARKS, snapshot);
-    for (const l of listeners) l();
-    window.dispatchEvent(new CustomEvent('sftp-bookmarks-changed'));
-}
+import {
+    getGlobalSftpBookmarksSnapshot,
+    setGlobalSftpBookmarks,
+    subscribeGlobalSftpBookmarks,
+} from "../../../application/state/sftp/globalSftpBookmarks";
+import { createSftpBookmark } from "../../../application/state/sftp/bookmarkHelpers";

 interface UseGlobalSftpBookmarksParams {
    currentPath: string | undefined;
@@ -47,7 +13,11 @@ interface UseGlobalSftpBookmarksParams {
 export const useGlobalSftpBookmarks = ({
    currentPath,
 }: UseGlobalSftpBookmarksParams) => {
-    const bookmarks = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+    const bookmarks = useSyncExternalStore(
+        subscribeGlobalSftpBookmarks,
+        getGlobalSftpBookmarksSnapshot,
+        getGlobalSftpBookmarksSnapshot,
+    );

    const isCurrentPathBookmarked = useMemo(
        () => !!currentPath && bookmarks.some((b) => b.path === currentPath),
@@ -57,21 +27,11 @@ export const useGlobalSftpBookmarks = ({
    const addBookmark = useCallback((path: string) => {
        if (!path) return;
        if (bookmarks.some((b) => b.path === path)) return;
-        const isRoot = path === "/" || /^[A-Za-z]:\\?$/.test(path);
-        const label = isRoot
-            ? path
-            : path.split(/[\\/]/).filter(Boolean).pop() || path;
-        const newBookmark: SftpBookmark = {
-            id: `gbm-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
-            path,
-            label,
-            global: true,
-        };
-        setBookmarks((prev) => [...prev, newBookmark]);
+        setGlobalSftpBookmarks((prev) => [...prev, createSftpBookmark(path, { global: true })]);
    }, [bookmarks]);

    const deleteBookmark = useCallback((id: string) => {
-        setBookmarks((prev) => prev.filter((b) => b.id !== id));
+        setGlobalSftpBookmarks((prev) => prev.filter((b) => b.id !== id));
    }, []);

    return {
--- a/components/sftp/hooks/useLocalSftpBookmarks.ts
+++ b/components/sftp/hooks/useLocalSftpBookmarks.ts
@@ -2,6 +2,7 @@ import { useCallback, useMemo, useSyncExternalStore } from "react";
 import type { SftpBookmark } from "../../../domain/models";
 import { localStorageAdapter } from "../../../infrastructure/persistence/localStorageAdapter";
 import { STORAGE_KEY_SFTP_LOCAL_BOOKMARKS } from "../../../infrastructure/config/storageKeys";
+import { createSftpBookmark } from "../../../application/state/sftp/bookmarkHelpers";

 // ── Shared external store so every hook instance sees the same bookmarks ──

@@ -47,16 +48,7 @@ export const useLocalSftpBookmarks = ({
        if (isCurrentPathBookmarked) {
            setBookmarks((prev) => prev.filter((b) => b.path !== currentPath));
        } else {
-            const isRoot = currentPath === "/" || /^[A-Za-z]:\\?$/.test(currentPath);
-            const label = isRoot
-                ? currentPath
-                : currentPath.split(/[\\/]/).filter(Boolean).pop() || currentPath;
-            const newBookmark: SftpBookmark = {
-                id: `bm-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
-                path: currentPath,
-                label,
-            };
-            setBookmarks((prev) => [...prev, newBookmark]);
+            setBookmarks((prev) => [...prev, createSftpBookmark(currentPath)]);
        }
    }, [currentPath, isCurrentPathBookmarked]);

--- a/components/sftp/hooks/useSftpBookmarks.ts
+++ b/components/sftp/hooks/useSftpBookmarks.ts
@@ -1,5 +1,6 @@
 import { useCallback, useMemo } from "react";
 import type { Host, SftpBookmark } from "../../../domain/models";
+import { createSftpBookmark } from "../../../application/state/sftp/bookmarkHelpers";

 interface UseSftpBookmarksParams {
    host: Host | undefined;
@@ -40,16 +41,7 @@ export const useSftpBookmarks = ({
        if (isCurrentPathBookmarked) {
            updateHostBookmarks(bookmarks.filter((b) => b.path !== currentPath));
        } else {
-            const label =
-                currentPath === "/"
-                    ? "/"
-                    : currentPath.split("/").filter(Boolean).pop() || currentPath;
-            const newBookmark: SftpBookmark = {
-                id: `bm-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
-                path: currentPath,
-                label,
-            };
-            updateHostBookmarks([...bookmarks, newBookmark]);
+            updateHostBookmarks([...bookmarks, createSftpBookmark(currentPath)]);
        }
    }, [currentPath, host, isCurrentPathBookmarked, bookmarks, updateHostBookmarks]);

--- a/components/sftp/hooks/useSftpKeyboardShortcuts.ts
+++ b/components/sftp/hooks/useSftpKeyboardShortcuts.ts
@@ -16,7 +16,7 @@ import { sftpTreeSelectionStore } from "./useSftpTreeSelectionStore";
 import { sftpListOrderStore } from "./useSftpListOrderStore";
 import { keepOnlyPaneSelections } from "./selectionScope";
 import type { SftpStateApi } from "../../../application/state/useSftpState";
-import { filterHiddenFiles, isNavigableDirectory } from "../index";
+import { filterHiddenFiles, isNavigableDirectory } from "../utils";
 import type { SftpFileEntry } from "../../../types";
 import { toast } from "../../ui/toast";

--- a/components/sftp/hooks/useSftpPaneDragAndSelect.ts
+++ b/components/sftp/hooks/useSftpPaneDragAndSelect.ts
@@ -1,7 +1,7 @@
 import React, { useCallback, useEffect, useRef, useState } from "react";
 import type { SftpFileEntry } from "../../../types";
 import type { SftpPaneCallbacks, SftpDragCallbacks, SftpTransferSource } from "../SftpContext";
-import { isNavigableDirectory } from "../index";
+import { isNavigableDirectory } from "../utils";
 import { joinPath } from "../../../application/state/sftp/utils";

 interface UseSftpPaneDragAndSelectParams {
--- a/components/sftp/hooks/useSftpPaneFiles.ts
+++ b/components/sftp/hooks/useSftpPaneFiles.ts
@@ -2,7 +2,7 @@ import { useMemo } from "react";
 import type { SftpFileEntry } from "../../../types";
 import type { SftpPane } from "../../../application/state/sftp/types";
 import type { SortField, SortOrder } from "../utils";
-import { filterHiddenFiles, sortSftpEntries } from "../index";
+import { filterHiddenFiles, sortSftpEntries } from "../utils";

 interface UseSftpPaneFilesParams {
  files: SftpFileEntry[];
--- a/components/sftp/hooks/useSftpPanePath.ts
+++ b/components/sftp/hooks/useSftpPanePath.ts
@@ -1,7 +1,7 @@
 import React, { useCallback, useMemo, useRef, useState } from "react";
 import type { SftpFileEntry } from "../../../types";
 import type { SftpPane } from "../../../application/state/sftp/types";
-import { filterHiddenFiles, isNavigableDirectory } from "../index";
+import { filterHiddenFiles, isNavigableDirectory } from "../utils";

 interface UseSftpPanePathParams {
  connection: SftpPane["connection"] | null;
--- a/components/sftp/hooks/useSftpViewFileOps.ts
+++ b/components/sftp/hooks/useSftpViewFileOps.ts
@@ -6,7 +6,7 @@ import type { SftpStateApi } from "../../../application/state/useSftpState";
 import { logger } from "../../../lib/logger";
 import { toast } from "../../ui/toast";
 import { getFileExtension, getLanguageId, FileOpenerType, SystemAppInfo } from "../../../lib/sftpFileUtils";
-import { isNavigableDirectory } from "../index";
+import { isNavigableDirectory } from "../utils";
 import { editorTabStore } from "../../../application/state/editorTabStore";
 import { toEditorTabId, activeTabStore } from "../../../application/state/activeTabStore";
 import type { TextEditorModalSnapshot } from "../../TextEditorModal";
--- a/components/sftp/index.ts
+++ b/components/sftp/index.ts
@@ -1,38 +1,13 @@
 /**
 * SFTP Components - Index
 * 
- * Re-exports all SFTP-related components and utilities for easy importing
+ * Re-exports the SFTP entries consumed by top-level views.
 */

-// Utilities
-export {
-  formatBytes, formatDate,
-  formatSpeed, formatTransferBytes, getFileIcon, isNavigableDirectory, isHiddenFile, isWindowsHiddenFile, filterHiddenFiles, sortSftpEntries, type ColumnWidths, type SortField,
-  type SortOrder
-} from './utils';
-
 // Context
 export {
  SftpContextProvider,
-  useSftpContext,
-  useSftpPaneCallbacks,
-  useSftpDrag,
-  useSftpHosts,
-  useSftpWritableHosts,
-  useSftpUpdateHosts,
-  useActiveTabId,
-  useIsPaneActive,
  activeTabStore,
-  type SftpPaneCallbacks,
-  type SftpDragCallbacks,
-  type SftpContextValue,
 } from './SftpContext';

-// Components
-export { SftpBreadcrumb } from './SftpBreadcrumb';
-export { SftpConflictDialog } from './SftpConflictDialog';
-export { SftpFileRow } from './SftpFileRow';
-export { SftpHostPicker } from './SftpHostPicker';
-export { SftpPermissionsDialog } from './SftpPermissionsDialog';
-export { SftpTabBar, type SftpTab } from './SftpTabBar';
-export { SftpTransferItem } from './SftpTransferItem';
+export { SftpTabBar } from './SftpTabBar';
--- a/components/sftp/utils.ts
+++ b/components/sftp/utils.ts
@@ -329,7 +329,7 @@ export const isNavigableDirectory = (entry: SftpFileEntry): boolean => {
 *
 * The ".." parent directory entry is never considered hidden.
 */
-export const isHiddenFile = <T extends { name: string; hidden?: boolean }>(
+const isHiddenFile = <T extends { name: string; hidden?: boolean }>(
    file: T,
 ): boolean => {
    if (file.name === "..") return false;
@@ -340,10 +340,6 @@ export const isHiddenFile = <T extends { name: string; hidden?: boolean }>(
    return false;
 };

-/** @deprecated Use isHiddenFile instead */
-export const isWindowsHiddenFile = <T extends { name: string; hidden?: boolean }>(file: T): boolean =>
-    isHiddenFile(file);
-
 /**
 * Filter files based on hidden file visibility setting.
 * Filters Windows hidden files and Unix/Linux dotfiles on all connections.
--- a/components/terminal/GhostTextAddon.test.ts
+++ b/components/terminal/GhostTextAddon.test.ts
@@ -450,3 +450,32 @@ test("applyKeystroke: ignores non-typing data (escape sequences, control codes)"
    restoreDocument();
  }
 });
+
+test("hides the ghost on render when the device echoed untracked input (#1013)", () => {
+  const restoreDocument = installFakeDocument();
+  const { term, ghostElement, fireRender } = createFakeTerm();
+  const addon = new GhostTextAddon();
+
+  try {
+    addon.activate(term as never);
+    // We believe only "network in" is typed; suggestion is the full command.
+    addon.show("network interface show", "network in");
+    assert.equal(addon.isActive(), true);
+
+    // The real line shows MORE than we tracked: a bastion host echoed the
+    // next char ("t") that our client-side buffer never recorded.
+    const line = "ecOS# network int";
+    const active = term.buffer.active as Record<string, unknown>;
+    active.baseY = 0;
+    active.cursorX = line.length;
+    active.getLine = () => ({ translateToString: () => line });
+
+    fireRender();
+
+    assert.equal(addon.isActive(), false);
+    assert.equal(ghostElement()?.style.display, "none");
+  } finally {
+    addon.dispose();
+    restoreDocument();
+  }
+});
--- a/components/terminal/PromptDetector.test.ts
+++ b/components/terminal/PromptDetector.test.ts
--- a/components/terminal/TerminalAutocomplete.tsx
+++ b/components/terminal/TerminalAutocomplete.tsx
@@ -0,0 +1,118 @@
+import ReactDOM from "react-dom";
+import type { ComponentProps, RefObject } from "react";
+import type { Terminal as XTerm } from "@xterm/xterm";
+import {
+  useTerminalAutocomplete,
+  AutocompletePopup,
+  type AutocompleteSettings,
+} from "./autocomplete";
+import type { Snippet } from "../../domain/models";
+
+type PopupProps = ComponentProps<typeof AutocompletePopup>;
+
+/** A mutable handler ref Terminal hands down for the xterm runtime to call. */
+type HandlerRef<T> = { current: T | undefined };
+
+interface TerminalAutocompleteProps {
+  termRef: RefObject<XTerm | null>;
+  sessionId: string;
+  hostId: string;
+  hostOs: "linux" | "windows" | "macos";
+  settings?: Partial<AutocompleteSettings>;
+  protocol?: string;
+  getCwd?: () => string | undefined;
+  onAcceptText: (text: string) => void;
+  snippets?: Snippet[];
+  onAcceptSnippet?: (snippet: Snippet) => void;
+  /** Whether this terminal tab is the visible one. */
+  visible: boolean;
+  themeColors: PopupProps["themeColors"];
+  containerRef: PopupProps["containerRef"];
+  searchBarOffset: number;
+  // Handlers exposed back to Terminal so createXTermRuntime can drive them.
+  keyEventRef: HandlerRef<(e: KeyboardEvent) => boolean>;
+  inputRef: HandlerRef<(data: string) => void>;
+  repositionRef: HandlerRef<() => void>;
+  closeRef: HandlerRef<() => void>;
+}
+
+/**
+ * Owns the terminal autocomplete hook and renders its popup.
+ *
+ * Kept as its own component so the frequent autocomplete state updates
+ * (suggestions, selection, live-preview navigation) re-render only this small
+ * subtree rather than the whole Terminal component. The hook's handlers are
+ * surfaced back to Terminal through refs so the xterm runtime can call them.
+ *
+ * Must be mounted unconditionally for the terminal session's lifetime: the hook
+ * records command history on Enter and intercepts completion keys even while no
+ * popup is visible. Visibility only gates the rendered popup, not the hook.
+ */
+export function TerminalAutocomplete({
+  termRef,
+  sessionId,
+  hostId,
+  hostOs,
+  settings,
+  protocol,
+  getCwd,
+  onAcceptText,
+  snippets,
+  onAcceptSnippet,
+  visible,
+  themeColors,
+  containerRef,
+  searchBarOffset,
+  keyEventRef,
+  inputRef,
+  repositionRef,
+  closeRef,
+}: TerminalAutocompleteProps) {
+  const autocomplete = useTerminalAutocomplete({
+    termRef,
+    sessionId,
+    hostId,
+    hostOs,
+    settings,
+    onAcceptText,
+    snippets,
+    onAcceptSnippet,
+    protocol,
+    getCwd,
+  });
+
+  // Surface the handlers for runtime wiring. They have stable identities
+  // (useCallback over refs), so assigning during render is cheap and mirrors
+  // the wiring Terminal did inline before this was extracted.
+  keyEventRef.current = autocomplete.handleKeyEvent;
+  inputRef.current = autocomplete.handleInput;
+  repositionRef.current = autocomplete.repositionPopup;
+  closeRef.current = autocomplete.closePopup;
+
+  const { state } = autocomplete;
+  if (!visible || !state.popupVisible || state.suggestions.length === 0) {
+    return null;
+  }
+
+  // Portal to body so the popup escapes the terminal container's overflow.
+  return ReactDOM.createPortal(
+    <AutocompletePopup
+      suggestions={state.suggestions}
+      selectedIndex={state.selectedIndex}
+      position={state.popupPosition}
+      cursorLineTop={state.popupCursorLineTop}
+      cursorLineBottom={state.popupCursorLineBottom}
+      visible={state.popupVisible}
+      expandUpward={state.expandUpward}
+      themeColors={themeColors}
+      onSelect={autocomplete.selectSuggestion}
+      subDirPanels={state.subDirPanels}
+      subDirFocusLevel={state.subDirFocusLevel}
+      containerRef={containerRef}
+      onRequestReposition={autocomplete.repositionPopup}
+      searchBarOffset={searchBarOffset}
+      onDismiss={autocomplete.closePopup}
+    />,
+    document.body,
+  );
+}
--- a/components/terminal/TerminalContextMenu.test.ts
+++ b/components/terminal/TerminalContextMenu.test.ts
@@ -0,0 +1,69 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import en from "../../application/i18n/locales/en.ts";
+import zhCN from "../../application/i18n/locales/zh-CN.ts";
+import * as terminalContextMenu from "./TerminalContextMenu.tsx";
+
+const shouldShowReconnectAction = (
+  terminalContextMenu as {
+    shouldShowReconnectAction?: (options: {
+      isReconnectable?: boolean;
+      onReconnect?: () => void;
+    }) => boolean;
+  }
+).shouldShowReconnectAction;
+const shouldSuppressMouseTrackingContextMenu = (
+  terminalContextMenu as {
+    shouldSuppressMouseTrackingContextMenu?: (options: {
+      isAlternateScreen?: boolean;
+      showReconnectAction?: boolean;
+    }) => boolean;
+  }
+).shouldSuppressMouseTrackingContextMenu;
+
+test("shows reconnect only for reconnectable terminals with a handler", () => {
+  assert.equal(typeof shouldShowReconnectAction, "function");
+  if (typeof shouldShowReconnectAction !== "function") return;
+
+  assert.equal(
+    shouldShowReconnectAction({
+      isReconnectable: true,
+      onReconnect: () => {},
+    }),
+    true,
+  );
+  assert.equal(
+    shouldShowReconnectAction({
+      isReconnectable: false,
+      onReconnect: () => {},
+    }),
+    false,
+  );
+  assert.equal(shouldShowReconnectAction({ isReconnectable: true }), false);
+});
+
+test("localizes the reconnect context menu label", () => {
+  assert.equal(en["terminal.menu.reconnect"], "Reconnect");
+  assert.equal(zhCN["terminal.menu.reconnect"], "重新连接");
+});
+
+test("allows reconnect menu while stale mouse tracking is still active", () => {
+  assert.equal(typeof shouldSuppressMouseTrackingContextMenu, "function");
+  if (typeof shouldSuppressMouseTrackingContextMenu !== "function") return;
+
+  assert.equal(
+    shouldSuppressMouseTrackingContextMenu({
+      isAlternateScreen: true,
+      showReconnectAction: true,
+    }),
+    false,
+  );
+  assert.equal(
+    shouldSuppressMouseTrackingContextMenu({
+      isAlternateScreen: true,
+      showReconnectAction: false,
+    }),
+    true,
+  );
+});
--- a/components/terminal/TerminalContextMenu.tsx
+++ b/components/terminal/TerminalContextMenu.tsx
@@ -5,6 +5,7 @@
 import {
  ClipboardPaste,
  Copy,
+  RefreshCcw,
  SplitSquareHorizontal,
  SplitSquareVertical,
  Terminal as TerminalIcon,
@@ -36,10 +37,28 @@ export interface TerminalContextMenuProps {
  onClear?: () => void;
  onSplitHorizontal?: () => void;
  onSplitVertical?: () => void;
+  isReconnectable?: boolean;
+  onReconnect?: () => void;
  onClose?: () => void;
  onSelectWord?: () => void;
 }

+export const shouldShowReconnectAction = ({
+  isReconnectable,
+  onReconnect,
+}: {
+  isReconnectable?: boolean;
+  onReconnect?: () => void;
+}): boolean => Boolean(isReconnectable && onReconnect);
+
+export const shouldSuppressMouseTrackingContextMenu = ({
+  isAlternateScreen,
+  showReconnectAction,
+}: {
+  isAlternateScreen?: boolean;
+  showReconnectAction?: boolean;
+}): boolean => Boolean(isAlternateScreen && !showReconnectAction);
+
 export const TerminalContextMenu: React.FC<TerminalContextMenuProps> = ({
  children,
  hasSelection = false,
@@ -54,6 +73,8 @@ export const TerminalContextMenu: React.FC<TerminalContextMenuProps> = ({
  onClear,
  onSplitHorizontal,
  onSplitVertical,
+  isReconnectable,
+  onReconnect,
  onClose,
  onSelectWord,
 }) => {
@@ -88,6 +109,7 @@ export const TerminalContextMenu: React.FC<TerminalContextMenuProps> = ({
  const splitHShortcut = getShortcut('split-horizontal');
  const splitVShortcut = getShortcut('split-vertical');
  const clearShortcut = getShortcut('clear-buffer');
+  const showReconnectAction = shouldShowReconnectAction({ isReconnectable, onReconnect });

  // Handle right-click: intercept for paste/select-word unless Shift is held
  // or rightClickBehavior is 'context-menu'. The ContextMenuTrigger stays always
@@ -95,8 +117,9 @@ export const TerminalContextMenu: React.FC<TerminalContextMenuProps> = ({
  const handleRightClick = useCallback(
    (e: React.MouseEvent) => {
      // In alternate screen (tmux, vim, etc.), let the terminal application
-      // handle right-click natively to avoid conflicting menus
-      if (isAlternateScreen) {
+      // handle right-click natively to avoid conflicting menus. Reconnect is
+      // still available after disconnect, even if mouse tracking was left on.
+      if (shouldSuppressMouseTrackingContextMenu({ isAlternateScreen, showReconnectAction })) {
        e.preventDefault();
        return;
      }
@@ -120,7 +143,7 @@ export const TerminalContextMenu: React.FC<TerminalContextMenuProps> = ({
        onSelectWord?.();
      }
    },
-    [rightClickBehavior, onPaste, onSelectWord, isAlternateScreen],
+    [rightClickBehavior, onPaste, onSelectWord, isAlternateScreen, showReconnectAction],
  );

  // Always use ContextMenu wrapper to maintain consistent React tree structure
@@ -133,7 +156,7 @@ export const TerminalContextMenu: React.FC<TerminalContextMenuProps> = ({
      >
        {children}
      </ContextMenuTrigger>
-      {!isAlternateScreen && (
+      {!shouldSuppressMouseTrackingContextMenu({ isAlternateScreen, showReconnectAction }) && (
        <ContextMenuContent className="w-56">
          <ContextMenuItem onClick={onCopy} disabled={!hasSelection}>
            <Copy size={14} className="mr-2" />
@@ -158,6 +181,16 @@ export const TerminalContextMenu: React.FC<TerminalContextMenuProps> = ({
            <ContextMenuShortcut>{selectAllShortcut}</ContextMenuShortcut>
          </ContextMenuItem>

+          {showReconnectAction && (
+            <>
+              <ContextMenuSeparator />
+              <ContextMenuItem onClick={onReconnect}>
+                <RefreshCcw size={14} className="mr-2" />
+                {t('terminal.menu.reconnect')}
+              </ContextMenuItem>
+            </>
+          )}
+
          <ContextMenuSeparator />

          <ContextMenuItem onClick={onSplitVertical}>
--- a/components/terminal/ZmodemOverwriteDialog.tsx
+++ b/components/terminal/ZmodemOverwriteDialog.tsx
@@ -0,0 +1,33 @@
+import React, { useState } from "react";
+import { useI18n } from "../../application/i18n/I18nProvider";
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from "../ui/dialog";
+import { Button } from "../ui/button";
+
+interface Props {
+  filename: string;
+  onRespond: (action: "overwrite" | "skip" | "cancel", applyToRest: boolean) => void;
+}
+
+export const ZmodemOverwriteDialog: React.FC<Props> = ({ filename, onRespond }) => {
+  const { t } = useI18n();
+  const [applyToRest, setApplyToRest] = useState(false);
+  return (
+    <Dialog open onOpenChange={(o) => { if (!o) onRespond("cancel", false); }}>
+      <DialogContent>
+        <DialogHeader>
+          <DialogTitle>{t("zmodem.overwrite.title")}</DialogTitle>
+        </DialogHeader>
+        <p className="text-sm text-muted-foreground break-all">{filename}</p>
+        <label className="flex items-center gap-2 text-sm mt-2">
+          <input type="checkbox" checked={applyToRest} onChange={(e) => setApplyToRest(e.target.checked)} />
+          {t("zmodem.overwrite.applyToRest")}
+        </label>
+        <DialogFooter>
+          <Button variant="ghost" onClick={() => onRespond("cancel", applyToRest)}>{t("zmodem.overwrite.cancel")}</Button>
+          <Button variant="outline" onClick={() => onRespond("skip", applyToRest)}>{t("zmodem.overwrite.skip")}</Button>
+          <Button onClick={() => onRespond("overwrite", applyToRest)}>{t("zmodem.overwrite.overwrite")}</Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+};
--- a/components/terminal/autocomplete/AutocompletePopup.tsx
+++ b/components/terminal/autocomplete/AutocompletePopup.tsx
@@ -59,6 +59,7 @@ const SOURCE_LABELS: Record<SuggestionSource, { label: string; fullLabel: string
  option: { label: "o", fullLabel: "Option", fallbackColor: "#A78BFA" },
  arg: { label: "a", fullLabel: "Argument", fallbackColor: "#F87171" },
  path: { label: "p", fullLabel: "Path", fallbackColor: "#38BDF8" },
+  snippet: { label: "{}", fullLabel: "Snippet", fallbackColor: "#C084FC" },
 };

 /** Lucide icon components for file types in path suggestions */
@@ -91,6 +92,32 @@ const DirExpandIndicator: React.FC<{ visible: boolean; color: string }> = ({ vis
  <span style={{ fontSize: "10px", color, opacity: visible ? 0.6 : 0, flexShrink: 0, marginLeft: "2px" }}>›</span>
 );

+/** Small key-cap badge shown on the selected row to hint the actionable key. */
+const KeyCap: React.FC<{ label: string; color: string; bg: string }> = ({ label, color, bg }) => (
+  <span
+    style={{
+      display: "inline-flex",
+      alignItems: "center",
+      justifyContent: "center",
+      boxSizing: "border-box",
+      height: "16px",
+      minWidth: "16px",
+      padding: "0 4px",
+      fontSize: "11px",
+      lineHeight: 1,
+      borderRadius: "4px",
+      border: `1px solid color-mix(in srgb, ${color} 35%, transparent)`,
+      color: `color-mix(in srgb, ${color} 80%, ${bg})`,
+      backgroundColor: `color-mix(in srgb, ${color} 12%, ${bg})`,
+      flexShrink: 0,
+      fontFamily:
+        'ui-sans-serif, -apple-system, "Segoe UI", system-ui, sans-serif',
+    }}
+  >
+    {label}
+  </span>
+);
+
 const AutocompletePopup: React.FC<AutocompletePopupProps> = ({
  suggestions,
  selectedIndex,
@@ -327,8 +354,9 @@ const AutocompletePopup: React.FC<AutocompletePopupProps> = ({
                {suggestion.displayText}
              </span>

-              {/* Inline description (truncated) */}
-              {suggestion.description && (
+              {/* Inline description (truncated). Snippets show only their label
+                  in the row — the full command lives in the detail preview. */}
+              {suggestion.source !== "snippet" && suggestion.description && (
                <span
                  style={{
                    fontSize: "11px",
@@ -361,6 +389,16 @@ const AutocompletePopup: React.FC<AutocompletePopupProps> = ({
              {suggestion.source === "path" && suggestion.fileType === "directory" && (
                <DirExpandIndicator visible={isSelected || isHovered} color={dimTextColor} />
              )}
+
+              {/* Key hint on the selected row: → expands directories, ↵ runs. */}
+              {isSelected && (
+                <span style={{ display: "flex", gap: "3px", marginLeft: "4px", flexShrink: 0 }}>
+                  {suggestion.source === "path" && suggestion.fileType === "directory" && (
+                    <KeyCap label="→" color={dimTextColor} bg={popupBg} />
+                  )}
+                  <KeyCap label="⏎" color={dimTextColor} bg={popupBg} />
+                </span>
+              )}
            </div>
          );
        })}
@@ -445,7 +483,22 @@ const AutocompletePopup: React.FC<AutocompletePopupProps> = ({
            </span>
          </div>
          <div style={{ fontSize: "12px", color: dimTextColor, lineHeight: "1.5", wordBreak: "break-word" }}>
-            {detailItem.description}
+            {detailItem.source === "snippet" ? (
+              <pre
+                style={{
+                  margin: 0,
+                  whiteSpace: "pre-wrap",
+                  wordBreak: "break-word",
+                  fontFamily: "var(--terminal-font, monospace)",
+                  fontSize: "11px",
+                  lineHeight: 1.4,
+                }}
+              >
+                {detailItem.description}
+              </pre>
+            ) : (
+              detailItem.description
+            )}
          </div>
        </div>
      )}
--- a/components/terminal/autocomplete/GhostTextAddon.ts
+++ b/components/terminal/autocomplete/GhostTextAddon.ts
@@ -9,6 +9,7 @@

 import type { Terminal as XTerm, IDisposable } from "@xterm/xterm";
 import { getXTermCellDimensions, invalidateCellDimensionCache } from "./xtermUtils";
+import { lineHasUntrackedTrailingInput } from "./ghostTextConsistency";

 /**
 * Minimal East-Asian-Width-style classifier: returns 2 for wide glyphs
@@ -112,9 +113,16 @@ export class GhostTextAddon implements IDisposable {

    this.disposables.push(
      term.onRender(() => {
-        if (this.isVisible()) {
-          this.updatePosition();
+        if (!this.isVisible()) return;
+        // Fail-safe: if the device echoed input we didn't track (some bastion
+        // hosts / network OS, #1013), hide rather than draw the ghost over
+        // already-typed text. Done here (post-echo render) rather than in
+        // show()/adjustToInput so it never fights the keystroke-time path.
+        if (this.realLineHasUntrackedInput()) {
+          this.hide();
+          return;
        }
+        this.updatePosition();
      }),
    );

@@ -291,6 +299,23 @@ export class GhostTextAddon implements IDisposable {
    return ghost.substring(0, leadingSpace + 1 + wordEnd + 1);
  }

+  /**
+   * True when the real terminal line has more input than we tracked, so
+   * rendering the ghost would paint over already-typed characters. See
+   * ./ghostTextConsistency and issue #1013. Returns false on hosts/inputs
+   * we can't judge (non-ASCII, echo still catching up), so the ghost only
+   * gets suppressed when corruption is actually imminent.
+   */
+  private realLineHasUntrackedInput(): boolean {
+    if (!this.term || !this.currentInput) return false;
+    const buf = this.term.buffer.active;
+    if (typeof buf?.getLine !== "function") return false;
+    const line = buf.getLine(buf.baseY + buf.cursorY);
+    if (!line || typeof line.translateToString !== "function") return false;
+    const beforeCursor = line.translateToString(false).slice(0, buf.cursorX);
+    return lineHasUntrackedTrailingInput(this.currentInput, beforeCursor);
+  }
+
  private updatePosition(): void {
    if (!this.term || !this.ghostElement) return;

--- a/components/terminal/autocomplete/commandHistoryStore.ts
+++ b/components/terminal/autocomplete/commandHistoryStore.ts
@@ -388,17 +388,6 @@ function fuzzyScore(query: string, target: string): number {
  return queryIdx === query.length ? score : 0;
 }

-/**
- * Delete a specific command from history for a host.
- */
-export function deleteHistoryEntry(command: string, hostId: string): void {
-  const store = loadStore();
-  store.entries = store.entries.filter(
-    (e) => !(e.command === command && e.hostId === hostId),
-  );
-  saveStore(store);
-}
-
 /**
 * Clear all history for a specific host, or all history if no hostId given.
 */
@@ -411,14 +400,3 @@ export function clearHistory(hostId?: string): void {
  }
  saveStore(store);
 }
-
-/**
- * Get total number of stored history entries.
- */
-export function getHistoryCount(hostId?: string): number {
-  const store = loadStore();
-  if (hostId) {
-    return store.entries.filter((e) => e.hostId === hostId).length;
-  }
-  return store.entries.length;
-}
--- a/components/terminal/autocomplete/completionEngine.ts
+++ b/components/terminal/autocomplete/completionEngine.ts
@@ -30,9 +30,11 @@ import {
  getPathSuggestions,
  resolvePathComponents,
 } from "./remotePathCompleter";
+import { getSnippetSuggestions } from "./snippetCompleter";
+import type { Snippet } from "../../../domain/models";

 /** Source indicator for where a suggestion came from */
-export type SuggestionSource = "history" | "command" | "subcommand" | "option" | "arg" | "path";
+export type SuggestionSource = "history" | "command" | "subcommand" | "option" | "arg" | "path" | "snippet";

 export interface CompletionSuggestion {
  /** The text to insert */
@@ -49,6 +51,8 @@ export interface CompletionSuggestion {
  frequency?: number;
  /** For path suggestions: file type */
  fileType?: "file" | "directory" | "symlink";
+  /** For snippet suggestions: the source snippet (used by the accept path). */
+  snippet?: Snippet;
 }

 export interface CompletionContext {
@@ -168,6 +172,8 @@ export async function getCompletions(
    protocol?: string;
    /** Current working directory (from OSC 7) */
    cwd?: string;
+    /** Custom snippets to surface at the command position */
+    snippets?: Snippet[];
  } = {},
 ): Promise<CompletionSuggestion[]> {
  const { hostId, maxResults = 15 } = options;
@@ -238,6 +244,7 @@ export async function getCompletions(
    ? await getPathSuggestions(ctx, {
      sessionId: options.sessionId,
      protocol: options.protocol,
+      os: options.os,
      cwd: options.cwd,
      foldersOnly: pathCheck.foldersOnly,
    })
@@ -289,6 +296,16 @@ export async function getCompletions(
    }
  }

+  // Snippets: only at the command position (typing the command name).
+  // Push without the early seen-text skip: snippets score above history, so if
+  // a snippet's label collides with an existing history entry's text, the
+  // score-sort + final dedup below keeps the snippet (the higher-scored one).
+  if (options.snippets && options.snippets.length > 0 && ctx.wordIndex === 0) {
+    for (const snippetSuggestion of getSnippetSuggestions(input, options.snippets, { hostId })) {
+      suggestions.push(snippetSuggestion);
+    }
+  }
+
  // Sort by score descending
  suggestions.sort((a, b) => b.score - a.score);

--- a/components/terminal/autocomplete/ghostTextConsistency.ts
+++ b/components/terminal/autocomplete/ghostTextConsistency.ts
@@ -0,0 +1,42 @@
+/**
+ * Fail-safe consistency check for inline (ghost-text) suggestions.
+ *
+ * Ghost text renders `suggestion.substring(trackedInput.length)` after the
+ * cursor, where `trackedInput` is what the client thinks the user has typed.
+ * On hosts with non-standard echo (hardware bastion hosts / network OS such as
+ * `ecOS#`, issue #1013, previously #756 / #906) that tracked value drifts out
+ * of sync with what is actually on the terminal line, and the ghost ends up
+ * painted over characters the user already typed (`int` + ghost `terface` →
+ * `intterface`).
+ *
+ * This detects the one direction that produces visible corruption: the real
+ * line being AHEAD of the tracked input (it contains the tracked input
+ * followed by more, untracked characters). SSH echo latency is the opposite
+ * case — the line is a prefix-behind of the tracked input — and is
+ * intentionally NOT flagged, so the ghost stays responsive on slow links.
+ *
+ * Returns true when the caller should hide the ghost.
+ */
+export function lineHasUntrackedTrailingInput(
+  trackedInput: string,
+  lineBeforeCursor: string,
+): boolean {
+  // Single chars match too loosely to judge reliably; let them through.
+  if (trackedInput.length < 2) return false;
+  // Column↔string mapping is only unambiguous for narrow (ASCII) input, so the
+  // existing wide-char (CJK / emoji) handling is left untouched.
+  if (!/^[\x20-\x7e]+$/.test(trackedInput)) return false;
+
+  // Use the last occurrence so a prompt or command that repeats the same token
+  // earlier on the line doesn't shadow the freshly-typed input.
+  const idx = lineBeforeCursor.lastIndexOf(trackedInput);
+  if (idx < 0) {
+    // Tracked input isn't on screen yet — the echo is still catching up
+    // (latency). Keep the ghost; reality being behind never corrupts.
+    return false;
+  }
+
+  // Non-whitespace characters between the tracked input and the cursor mean the
+  // device echoed input we never tracked → the ghost would overlap real text.
+  return lineBeforeCursor.slice(idx + trackedInput.length).trimEnd().length > 0;
+}
--- a/components/terminal/autocomplete/index.ts
+++ b/components/terminal/autocomplete/index.ts
@@ -2,5 +2,5 @@ export { useTerminalAutocomplete, DEFAULT_AUTOCOMPLETE_SETTINGS } from "./useTer
 export type { AutocompleteSettings, AutocompleteState, TerminalAutocompleteHandle } from "./useTerminalAutocomplete";
 export { default as AutocompletePopup } from "./AutocompletePopup";
 export type { CompletionSuggestion, SuggestionSource } from "./completionEngine";
-export { recordCommand, clearHistory, deleteHistoryEntry, getHistoryCount } from "./commandHistoryStore";
+export { recordCommand, clearHistory } from "./commandHistoryStore";
 export { shellEscape } from "./completionEngine";
--- a/components/terminal/autocomplete/livePreviewSequence.ts
+++ b/components/terminal/autocomplete/livePreviewSequence.ts
@@ -0,0 +1,24 @@
+/**
+ * Compute the keystrokes to send so the terminal input line becomes exactly
+ * `candidate`, given what is currently on the line. Drives the popup
+ * autocomplete live-preview (#1005): moving the selection renders the chosen
+ * suggestion into the command line, and switching / reverting rewrites it.
+ *
+ * - Forward prefix (candidate continues the line): append only the new tail.
+ * - Otherwise: clear the current input, then write the full candidate. POSIX
+ *   shells use Ctrl-U (kill-line); Windows (cmd/PowerShell) uses backspaces
+ *   sized to the current line length.
+ */
+export function computeLivePreviewWrite(input: {
+  currentLine: string;
+  candidate: string;
+  os: string;
+}): string {
+  const { currentLine, candidate, os } = input;
+  if (candidate === currentLine) return "";
+  if (candidate.startsWith(currentLine)) {
+    return candidate.slice(currentLine.length);
+  }
+  const clear = os === "windows" ? "\b".repeat(currentLine.length) : "\x15";
+  return clear + candidate;
+}
--- a/components/terminal/autocomplete/promptDetector.ts
+++ b/components/terminal/autocomplete/promptDetector.ts
@@ -20,7 +20,29 @@ const NON_PROMPT_PATTERNS = [
  /^:\s*$/,                      // vim command mode
  /^\s*~\s*$/,                   // vim tilde lines
  /^>{1,3}\s/,                   // Bare > (bash PS2 continuation), >> or >>> (python REPL)
-  /^\w+>\s/,                     // mysql> / sqlite> / redis-cli> REPL prompts
+  /^\s{4}(?:->|['"`]>)\s/,       // mysql / mariadb continuation prompts
+  /^(?:mysql|sqlite(?:3)?|redis(?:-cli)?|psql|mariadb)>\s/i, // mysql> / sqlite> / redis-cli> prompts
+  /^SQL>\s/i,                      // sqlplus SQL> prompts
+  /^(?:sftp|ftp|lftp|ghci|node|mongo|mongosh|deno|irb|pry|julia|scala|gdb|lldb|cqlsh|hive|spark-sql|jshell|ksql|trino|presto|duckdb)>\s/i,
+  /^irb\([^)]*\):\d+[:*]?\d*>\s/i,
+  /^pry\([^)]*\)>\s/i,
+  /^\[\d+\]\s+pry\([^)]*\)>\s/i,
+  /^lftp\s+\S+>\s/i,
+  /^\s{3}\.{3}>\s/,
+  /^cqlsh(?::[\w.-]+)?>\s/i,
+  /^(?:hive|spark-sql)\s+\([^)]+\)>\s/i,
+  /^(?:\d+:\s*)?jdbc:hive2?:\/\/\S+>\s/i,
+  /^(?:test|admin|local|config)>\s+(?:db(?:\.|\s*$)|rs\.|print\s*\(|(?:const|let|var|await)\b|\d+\s*[-+*/]\s*\d*)/i,
+  /^[\w.-]+:[A-Z]+>\s+(?:db\.|rs\.|exit\b|(?:const|let|var|await)\b|show\s+(?:dbs?|collections|users|roles)|use\s+\w+|it\b)/i,
+  /^(?:[\w.-]+\s+){0,5}\[[^\]]+\]\s+[\w.-]+>\s+(?:db\.|rs\.|exit\b|hel(?:p)?\b|print\s*\(|(?:const|let|var|await)\b|\d+\s*[-+*/]\s*\d*|show\s+(?:dbs?|collections|users|roles)|use\s+\w+|it\b)/i,
+  /^(?:[\w.-]+\s+){1,5}[\w.-]+>\s+(?:db\.|rs\.|exit\b|hel(?:p)?\b|print\s*\(|(?:const|let|var|await)\b|\d+\s*[-+*/]\s*\d*|show\s+(?:dbs?|collections|users|roles)|use\s+\w+|it\b)/i,
+  /^(?:trino|presto)(?::[\w.-]+){1,2}>\s/i,
+  /^[\w.-]+@(?:[\w.-]+|\d{1,3}(?:\.\d{1,3}){3}):\d+>\s/i,
+  /^(?:[\w.-]+|\d{1,3}(?:\.\d{1,3}){3})(?::\d+)(?:\[\d+\])?>\s/, // redis host:port> prompts
+  /^MariaDB\s+\[[^\]]+\]>\s/i,   // MariaDB [(none)]> prompts
+  /^[\w.-]+=[#>]\s/,             // postgres=# / postgres=> REPL prompts
+  /^[\w.-]+[-'"][#>]\s/,         // postgres-# / postgres'# continuation prompts
+  /^[\w.-]+(?:\([^)]*|\*|!|\^|\$[^$]*\$)[#>]\s/, // postgres multiline prompt states
 ];

 export interface PromptDetectionResult {
@@ -38,30 +60,48 @@ const NO_PROMPT: PromptDetectionResult = {
  isAtPrompt: false, promptText: "", userInput: "", cursorOffset: 0,
 };

+export function isNonPromptLine(lineText: string): boolean {
+  return NON_PROMPT_PATTERNS.some((pattern) => pattern.test(lineText));
+}
+
+function isSpecificShellPromptCandidate(
+  promptText: string,
+  options: { allowGreaterThanTerminator?: boolean } = {},
+): boolean {
+  const trimmed = promptText.trim();
+  if (
+    !options.allowGreaterThanTerminator &&
+    (trimmed.endsWith(">") || trimmed.endsWith("›"))
+  ) {
+    return false;
+  }
+  return trimmed.length >= 6 && /[@:\\/~\])]/.test(trimmed);
+}
+
+function isLikelyNoSpaceShellPromptText(promptText: string): boolean {
+  const trimmed = promptText.trim();
+  if (/^root[#%$]$/.test(trimmed)) return true;
+  if (trimmed.length < 3) return false;
+
+  const marker = trimmed[trimmed.length - 1];
+  if (!PROMPT_CHARS.has(marker) && !isPuaChar(marker)) return false;
+
+  const prev = trimmed[trimmed.length - 2] ?? "";
+  return /[~:/\\\])]/.test(prev);
+}
+
 export interface AlignedPromptResult {
  /** The prompt view every consumer should use for parsing / suggestion lookup / line rewrites. */
  prompt: PromptDetectionResult;
  /**
   * The keystroke buffer, but only when it's both marked reliable AND
-   * actually matches the tail of the raw detected userInput. Returns
-   * null otherwise — the single signal downstream uses to decide
-   * whether to record it as the executed command.
+   * can be validated against the live terminal line. Returns null
+   * otherwise - the single signal downstream uses to decide whether
+   * to record it as the executed command.
   */
  alignedTyped: string | null;
 }

-function replacePromptUserInput(
-  prompt: PromptDetectionResult,
-  userInput: string,
-): PromptDetectionResult {
-  return {
-    isAtPrompt: true,
-    promptText: prompt.promptText,
-    userInput,
-    cursorOffset: userInput.length,
-  };
-}
-
 function getCursorLinePrefix(term: XTerm): string | null {
  const buffer = term.buffer.active;
  const cursorY = buffer.cursorY + buffer.baseY;
@@ -72,6 +112,499 @@ function getCursorLinePrefix(term: XTerm): string | null {
  return line.translateToString(false).substring(0, Math.max(0, buffer.cursorX));
 }

+function getWrappedCursorPrefix(term: XTerm): string | null {
+  const buffer = term.buffer.active;
+  const cursorY = buffer.cursorY + buffer.baseY;
+  const cursorX = buffer.cursorX;
+  const line = buffer.getLine(cursorY);
+
+  if (!line?.isWrapped) return null;
+
+  let promptRow = cursorY - 1;
+  while (promptRow >= 0) {
+    const prevLine = buffer.getLine(promptRow);
+    if (!prevLine) return null;
+    if (!prevLine.isWrapped) break;
+    promptRow--;
+  }
+
+  const promptLine = buffer.getLine(promptRow);
+  if (!promptLine) return null;
+
+  let prefix = promptLine.translateToString(false);
+  for (let row = promptRow + 1; row < cursorY; row++) {
+    const rowLine = buffer.getLine(row);
+    if (!rowLine) return null;
+    prefix += rowLine.translateToString(false);
+  }
+
+  return prefix + line.translateToString(false).substring(0, Math.max(0, cursorX));
+}
+
+function inferPromptTextBeforeTypedInput(
+  cursorPrefix: string,
+  typedBuffer: string,
+  allowPartialEcho: boolean,
+): string | null {
+  if (cursorPrefix.endsWith(typedBuffer)) {
+    const promptText = cursorPrefix.slice(0, cursorPrefix.length - typedBuffer.length);
+    return promptText.length > 0 ? promptText : null;
+  }
+
+  if (!allowPartialEcho) return null;
+
+  const maxEchoLength = Math.min(cursorPrefix.length, typedBuffer.length);
+  const minPartialEchoLength = Math.max(6, typedBuffer.length - 2);
+  for (let echoLength = maxEchoLength - 1; echoLength >= minPartialEchoLength; echoLength--) {
+    const echoedInput = typedBuffer.slice(0, echoLength);
+    if (!cursorPrefix.endsWith(echoedInput)) continue;
+
+    const promptText = cursorPrefix.slice(0, cursorPrefix.length - echoLength);
+    if (promptText.length > 0) return promptText;
+  }
+
+  const noSpacePromptMinEchoLength = typedBuffer.trim().length <= 2 ? 1 : 3;
+  for (
+    let echoLength = Math.min(maxEchoLength - 1, minPartialEchoLength - 1);
+    echoLength >= noSpacePromptMinEchoLength;
+    echoLength--
+  ) {
+    const echoedInput = typedBuffer.slice(0, echoLength);
+    if (!cursorPrefix.endsWith(echoedInput)) continue;
+    const hasReliablePartialEcho =
+      typedBuffer.trim().length <= 2 ||
+      echoedInput.endsWith(" ") ||
+      (echoedInput.includes(" ") && echoedInput.length >= 4);
+    if (!hasReliablePartialEcho) continue;
+
+    const promptText = cursorPrefix.slice(0, cursorPrefix.length - echoLength);
+    if (isLikelyNoSpaceShellPromptText(promptText)) return promptText;
+  }
+
+  return null;
+}
+
+function hasSwallowedCommandAfterPrompt(promptText: string, promptBoundary: number): boolean {
+  const candidate = promptText.slice(0, promptBoundary).trimEnd();
+  const finalIndex = candidate.length - 1;
+  const finalChar = finalIndex >= 0 ? candidate[finalIndex] : "";
+
+  for (let i = 0; i < finalIndex; i++) {
+    const ch = candidate[i];
+    if (!PROMPT_CHARS.has(ch) && !isPuaChar(ch)) continue;
+
+    const nextChar = i + 1 < candidate.length ? candidate[i + 1] : null;
+    if (nextChar === null || nextChar === " ") continue;
+
+    const earlierPrompt = candidate.slice(0, i + 1);
+    if (isLikelyNoSpaceShellPromptText(earlierPrompt)) return true;
+    if (isEmbeddedPromptMarkerAt(candidate, i)) continue;
+    if (!isSpecificShellPromptCandidate(earlierPrompt)) continue;
+    if (PROMPT_CHARS.has(nextChar) || isPuaChar(nextChar)) return true;
+    if (startsWithCommonShellCommand(candidate.slice(i + 1))) return true;
+    if (finalChar !== "$") return true;
+  }
+
+  return false;
+}
+
+function canUseInferredPromptText(promptText: string, rawIsAtPrompt: boolean): boolean {
+  if (promptText.length === 0) return false;
+  if (rawIsAtPrompt) return true;
+
+  const promptBoundary = findPromptBoundary(promptText);
+  const promptEndsAtBoundary =
+    promptBoundary >= 0 && promptText.slice(promptBoundary).trim().length === 0;
+  return (
+    promptEndsAtBoundary &&
+    !hasSwallowedCommandAfterPrompt(promptText, promptBoundary) &&
+    isSpecificShellPromptCandidate(promptText)
+  );
+}
+
+function isThemedPromptText(promptText: string): boolean {
+  for (const ch of promptText) {
+    if (isPuaChar(ch)) return true;
+  }
+  return /[❯❮→➜➤⟩»›]/.test(promptText);
+}
+
+function isPromptPathDecoration(trimmed: string): boolean {
+  return (
+    trimmed === "~" ||
+    trimmed.startsWith("~/") ||
+    trimmed.startsWith("/") ||
+    /^[A-Za-z]:[\\/]/.test(trimmed) ||
+    trimmed.includes("\\")
+  );
+}
+
+function isPromptBareDirectoryText(trimmed: string): boolean {
+  if (trimmed.startsWith("./") || trimmed.startsWith("../")) return false;
+  return /^[\w.-]+$/.test(trimmed);
+}
+
+function isPromptStatusToken(token: string): boolean {
+  return (
+    /^git:\([^)]*\)$/.test(token) ||
+    /^[+$#%>!?*]$/.test(token) ||
+    token === "✗" ||
+    token === "✔"
+  );
+}
+
+function isPromptStatusText(trimmed: string): boolean {
+  const [first = "", ...rest] = trimmed.split(/\s+/);
+  if (rest.length === 0) return false;
+  if (!isPromptBareDirectoryText(first) && !isPromptPathDecoration(first)) return false;
+  return rest.every(isPromptStatusToken);
+}
+
+function isPromptStatusDecoration(extra: string): boolean {
+  if (!/^\s+/.test(extra) || !/\s+$/.test(extra)) return false;
+
+  return isPromptStatusText(extra.trim());
+}
+
+function isPromptDecorationExtra(extra: string, promptText: string): boolean {
+  const trimmed = extra.trim();
+  if (trimmed.length === 0) return false;
+  if (!isThemedPromptText(promptText)) return false;
+  if (startsWithCommonShellCommand(extra)) return false;
+  if (/^\s*\S+\s+$/.test(extra)) {
+    return isPromptPathDecoration(trimmed) || (
+      isPromptBareDirectoryText(trimmed) &&
+      !startsWithCommonShellCommand(trimmed)
+    );
+  }
+  if (isPromptStatusDecoration(extra)) return true;
+  for (const ch of extra) {
+    if (isPuaChar(ch)) return true;
+  }
+  return false;
+}
+
+function getFinalPromptBoundary(promptText: string): number {
+  const trimmedEnd = promptText.trimEnd().length;
+  if (trimmedEnd === 0) return -1;
+
+  const markerIndex = trimmedEnd - 1;
+  const marker = promptText[markerIndex];
+  if (!PROMPT_CHARS.has(marker) && !isPuaChar(marker)) return -1;
+
+  const nextChar = markerIndex + 1 < promptText.length ? promptText[markerIndex + 1] : null;
+  if (nextChar !== null && nextChar !== " ") return -1;
+  return nextChar === " " ? markerIndex + 2 : markerIndex + 1;
+}
+
+function endsAtFinalPromptBoundary(promptText: string): boolean {
+  const promptBoundary = getFinalPromptBoundary(promptText);
+  return promptBoundary >= 0 && promptText.slice(promptBoundary).trim().length === 0;
+}
+
+const COMMON_SHELL_COMMANDS = new Set([
+  "alias",
+  "awk",
+  "az",
+  "brew",
+  "bun",
+  "bundle",
+  "cargo",
+  "cat",
+  "cd",
+  "chmod",
+  "chown",
+  "code",
+  "composer",
+  "cp",
+  "curl",
+  "docker",
+  "echo",
+  "emacs",
+  "env",
+  "export",
+  "find",
+  "gcloud",
+  "gh",
+  "git",
+  "go",
+  "gradle",
+  "grep",
+  "helm",
+  "java",
+  "javac",
+  "kubectl",
+  "less",
+  "ls",
+  "make",
+  "mkdir",
+  "mvn",
+  "mv",
+  "nano",
+  "node",
+  "npm",
+  "npx",
+  "nvim",
+  "php",
+  "pip",
+  "pip3",
+  "pnpm",
+  "printf",
+  "python",
+  "python3",
+  "rails",
+  "rm",
+  "rsync",
+  "ruby",
+  "rustc",
+  "scp",
+  "screen",
+  "sed",
+  "ssh",
+  "sudo",
+  "tail",
+  "tar",
+  "terraform",
+  "tmux",
+  "touch",
+  "uv",
+  "vi",
+  "vim",
+  "yarn",
+]);
+
+function getLeadingShellCommandWord(text: string): string | null {
+  return text.trimStart().match(/^[\w.-]+(?=\s|$)/)?.[0] ?? null;
+}
+
+function startsWithCommonShellCommand(text: string): boolean {
+  const command = getLeadingShellCommandWord(text);
+  return command !== null && COMMON_SHELL_COMMANDS.has(command);
+}
+
+function isCompleteSpecificPrompt(promptText: string): boolean {
+  const promptBoundary = getFinalPromptBoundary(promptText);
+  return (
+    promptBoundary >= 0 &&
+    promptText.slice(promptBoundary).trim().length === 0 &&
+    isSpecificShellPromptCandidate(promptText) &&
+    !isEmbeddedPromptMarker(promptText, promptBoundary)
+  );
+}
+
+function looksLikeCommandAfterCompletePrompt(promptText: string, extra: string): boolean {
+  return isCompleteSpecificPrompt(promptText) && extra.trim().length > 0;
+}
+
+function hasShellCommandAfterOptionalDecoration(text: string): boolean {
+  const trimmedStart = text.trimStart();
+  if (startsWithCommonShellCommand(trimmedStart)) return true;
+
+  const [, afterDecoration = ""] = trimmedStart.match(/^\S+\s+(.+)$/) ?? [];
+  return startsWithCommonShellCommand(afterDecoration);
+}
+
+function isSingleBareDirectoryExtra(extra: string): boolean {
+  const trimmed = extra.trim();
+  return /^\s*\S+\s+$/.test(extra) && isPromptBareDirectoryText(trimmed);
+}
+
+function hasExplicitThemedDirectorySpacing(extra: string): boolean {
+  return /^\s+\S+\s+$/.test(extra);
+}
+
+type PromptDecorationReconcileOptions = {
+  allowSingleWordCommandDirectory?: boolean;
+};
+
+function canTreatCommonCommandNameAsThemedDirectory(
+  extra: string,
+  typedInput: string,
+  options: PromptDecorationReconcileOptions = {},
+): boolean {
+  const trimmedInput = typedInput.trim();
+  return (
+    isSingleBareDirectoryExtra(extra) &&
+    (
+      /\s/.test(trimmedInput) ||
+      /^(?:ls|cd|pwd)$/.test(trimmedInput) ||
+      (
+        options.allowSingleWordCommandDirectory === true &&
+        hasExplicitThemedDirectorySpacing(extra)
+      )
+    )
+  );
+}
+
+function canReconcilePromptDecoration(
+  prompt: PromptDetectionResult,
+  typedInput: string,
+  options: PromptDecorationReconcileOptions = {},
+): boolean {
+  if (
+    !prompt.isAtPrompt ||
+    !typedInput ||
+    prompt.userInput.length <= typedInput.length ||
+    !prompt.userInput.endsWith(typedInput)
+  ) {
+    return false;
+  }
+
+  const extra = prompt.userInput.slice(0, prompt.userInput.length - typedInput.length);
+  if (looksLikeCommandAfterCompletePrompt(prompt.promptText, extra)) return false;
+  if (
+    isThemedPromptText(prompt.promptText) &&
+    canTreatCommonCommandNameAsThemedDirectory(extra, typedInput, options)
+  ) {
+    return true;
+  }
+  if (isThemedPromptText(prompt.promptText) && hasShellCommandAfterOptionalDecoration(extra)) {
+    return false;
+  }
+
+  const candidatePromptText = prompt.promptText + extra;
+  const promptEndsAtBoundary =
+    endsAtFinalPromptBoundary(candidatePromptText) &&
+    isSpecificShellPromptCandidate(candidatePromptText);
+  return promptEndsAtBoundary || isPromptDecorationExtra(extra, prompt.promptText);
+}
+
+function alignTypedInputFromCursorPrefix(
+  raw: PromptDetectionResult,
+  cursorPrefix: string | null,
+  typedBuffer: string,
+): AlignedPromptResult | null {
+  if (!cursorPrefix) return null;
+  if (!raw.isAtPrompt && isNonPromptLine(cursorPrefix)) return null;
+
+  const promptText = inferPromptTextBeforeTypedInput(cursorPrefix, typedBuffer, !raw.isAtPrompt);
+  if (!promptText || !canUseInferredPromptText(promptText, raw.isAtPrompt)) {
+    return null;
+  }
+
+  return {
+    prompt: {
+      isAtPrompt: true,
+      promptText,
+      userInput: typedBuffer,
+      cursorOffset: typedBuffer.length,
+    },
+    alignedTyped: typedBuffer,
+  };
+}
+
+function canUseReliablePromptPrefix(
+  raw: PromptDetectionResult,
+  typedBuffer: string,
+): boolean {
+  if (!raw.isAtPrompt || typedBuffer.length === 0 || raw.userInput.length === 0) {
+    return false;
+  }
+  if (typedBuffer.length <= raw.userInput.length) return false;
+  return isReliableTypedPrefix(raw.userInput, typedBuffer, {
+    allowShortEcho: allowsShortPromptEcho(raw.promptText),
+  });
+}
+
+function isLikelyBareMongoPromptName(promptName: string): boolean {
+  return /^(?:test|admin|local|config)$/i.test(promptName);
+}
+
+function endsWithHostStyleGreaterThanPrompt(promptText: string): boolean {
+  const trimmed = promptText.trimEnd();
+  if (!trimmed.endsWith(">")) return false;
+  const promptName = trimmed.slice(0, -1).trim();
+  return /^[\w.-]+$/.test(promptName) && !isLikelyBareMongoPromptName(promptName);
+}
+
+function endsWithStandardShellPrompt(promptText: string): boolean {
+  const finalChar = promptText.trimEnd().at(-1);
+  return finalChar === "$" || finalChar === "#" || finalChar === "%";
+}
+
+function allowsShortPromptEcho(promptText: string): boolean {
+  return endsWithStandardShellPrompt(promptText) || endsWithHostStyleGreaterThanPrompt(promptText);
+}
+
+function isReliableTypedPrefix(
+  echoedInput: string,
+  typedBuffer: string,
+  options: { allowShortEcho?: boolean } = {},
+): boolean {
+  if (!typedBuffer.startsWith(echoedInput)) return false;
+  if (
+    options.allowShortEcho &&
+    typedBuffer.trim().length <= 2 &&
+    echoedInput.trim().length >= 1
+  ) {
+    return true;
+  }
+  return (
+    echoedInput.length >= Math.max(4, typedBuffer.length - 2) ||
+    (echoedInput.endsWith(" ") && echoedInput.trim().length >= 2) ||
+    (echoedInput.includes(" ") && echoedInput.length >= 4)
+  );
+}
+
+function withTypedUserInput(
+  prompt: PromptDetectionResult,
+  typedBuffer: string,
+): PromptDetectionResult {
+  return {
+    ...prompt,
+    userInput: typedBuffer,
+    cursorOffset: typedBuffer.length,
+  };
+}
+
+function alignThemedDecorationWithPartialEcho(
+  raw: PromptDetectionResult,
+  typedBuffer: string,
+): AlignedPromptResult | null {
+  if (!raw.isAtPrompt || !isThemedPromptText(raw.promptText)) return null;
+
+  const maxEchoLength = Math.min(raw.userInput.length, typedBuffer.length);
+  for (let echoLength = maxEchoLength; echoLength > 0; echoLength--) {
+    const echoedInput = typedBuffer.slice(0, echoLength);
+    if (!raw.userInput.endsWith(echoedInput)) continue;
+
+    const extra = raw.userInput.slice(0, raw.userInput.length - echoLength);
+    if (extra.length === 0) continue;
+    const hasReliableThemedDirectoryPrefix =
+      isSingleBareDirectoryExtra(extra) &&
+      hasExplicitThemedDirectorySpacing(extra) &&
+      typedBuffer.trim().length <= 3 &&
+      echoedInput.trim().length >= 1;
+
+    const syntheticPrompt = {
+      ...raw,
+      userInput: extra + typedBuffer,
+      cursorOffset: extra.length + typedBuffer.length,
+    };
+    if (
+      !hasReliableThemedDirectoryPrefix &&
+      !isReliableTypedPrefix(echoedInput, typedBuffer)
+    ) {
+      continue;
+    }
+    if (!canReconcilePromptDecoration(syntheticPrompt, typedBuffer, {
+      allowSingleWordCommandDirectory: true,
+    })) continue;
+
+    return {
+      prompt: {
+        isAtPrompt: true,
+        promptText: raw.promptText + extra,
+        userInput: typedBuffer,
+        cursorOffset: typedBuffer.length,
+      },
+      alignedTyped: typedBuffer,
+    };
+  }
+
+  return null;
+}
+
 /**
 * Detect whether the terminal cursor is at a shell prompt and extract the current user input.
 */
@@ -88,15 +621,26 @@ export function detectPrompt(term: XTerm): PromptDetectionResult {
  const lineText = line.translateToString(false);

  // Check for non-prompt patterns (pagers, editors, etc.)
-  for (const pattern of NON_PROMPT_PATTERNS) {
-    if (pattern.test(lineText)) return NO_PROMPT;
+  if (isNonPromptLine(lineText)) return NO_PROMPT;
+  if (line.isWrapped) {
+    const wrappedPrefix = getWrappedCursorPrefix(term);
+    if (wrappedPrefix && isNonPromptLine(wrappedPrefix)) return NO_PROMPT;
  }

  // Empty line
  if (lineText.trim().length === 0) return NO_PROMPT;

-  // Try to find the prompt boundary on the current line
-  const promptEnd = findPromptBoundary(lineText);
+  const cursorLinePrefix = lineText.substring(0, Math.max(0, cursorX));
+  // Try to find the prompt boundary on the current line. xterm buffer rows are
+  // padded with blank cells; when the cursor is at the visible row end, scan
+  // only up to the cursor so prompts like "root@host:~#" do not inherit a fake
+  // trailing space. If there is command text to the right of the cursor, keep
+  // the full line so "$" / ">" inside mid-line edits are validated against
+  // their real following character.
+  const promptScanText = lineText.slice(Math.max(0, cursorX)).trim().length > 0
+    ? lineText
+    : cursorLinePrefix;
+  const promptEnd = findPromptBoundary(promptScanText);
  if (promptEnd >= 0) {
    const promptText = lineText.substring(0, promptEnd);
    // Use cursor position to determine actual input length — don't trim trailing
@@ -125,6 +669,7 @@ export function detectPrompt(term: XTerm): PromptDetectionResult {
    const promptLine = buffer.getLine(promptRow);
    if (promptLine) {
      const promptLineText = promptLine.translateToString(false);
+      if (isNonPromptLine(promptLineText)) return NO_PROMPT;
      const pEnd = findPromptBoundary(promptLineText);
      if (pEnd >= 0) {
        const promptText = promptLineText.substring(0, pEnd);
@@ -139,6 +684,7 @@ export function detectPrompt(term: XTerm): PromptDetectionResult {
        const charsBeforeCursorRow = (cursorY - promptRow) * totalCols - pEnd;
        const userInput = fullInput.substring(0, charsBeforeCursorRow + cursorX);
        const cursorOffset = userInput.length;
+        if (isNonPromptLine(promptText + userInput)) return NO_PROMPT;

        return { isAtPrompt: true, promptText, userInput, cursorOffset };
      }
@@ -165,6 +711,56 @@ function isPuaChar(ch: string): boolean {
  return code >= 0xE000 && code <= 0xF8FF;
 }

+function getBoundaryMarkerIndex(lineText: string, boundary: number): number {
+  if (boundary <= 0) return -1;
+  return lineText[boundary - 1] === " " ? boundary - 2 : boundary - 1;
+}
+
+function isEmbeddedPromptMarkerAt(lineText: string, markerIndex: number): boolean {
+  if (markerIndex <= 0) return false;
+
+  const marker = lineText[markerIndex];
+  if (marker !== "#" && marker !== "%" && marker !== ">" && marker !== "$") return false;
+
+  const prev = lineText[markerIndex - 1];
+  return !/[\s~:\])}]/.test(prev);
+}
+
+function isEmbeddedPromptMarker(lineText: string, boundary: number): boolean {
+  return isEmbeddedPromptMarkerAt(lineText, getBoundaryMarkerIndex(lineText, boundary));
+}
+
+function canSupersedeThemedPromptBoundary(
+  lineText: string,
+  previousBoundary: number,
+  markerIndex: number,
+): boolean {
+  if (!isThemedPromptText(lineText.slice(0, previousBoundary))) return false;
+
+  const rawBetween = lineText.slice(previousBoundary, markerIndex);
+  const between = rawBetween.trim();
+  return (
+    between.length === 0 ||
+    isPromptPathDecoration(between) ||
+    isPromptStatusText(between) ||
+    (
+      /^\s/.test(rawBetween) &&
+      isPromptBareDirectoryText(between)
+    )
+  );
+}
+
+function canPromptMarkerSupersedePreviousBoundary(ch: string): boolean {
+  return ch === "$" || ch === "#" || ch === "%" || ch === ">" || ch === "›";
+}
+
+function isSpacedPromptSegment(lineText: string, boundary: number): boolean {
+  const markerIndex = getBoundaryMarkerIndex(lineText, boundary);
+  if (markerIndex <= 0) return false;
+  if (lineText[markerIndex - 1] !== " ") return false;
+  return lineText[markerIndex + 1] === " ";
+}
+
 /**
 * Find the boundary between prompt and user input.
 * Scans left-to-right within the first 200 chars for a prompt character followed by space.
@@ -193,6 +789,15 @@ function findPromptBoundary(lineText: string): number {

    // For ambiguous prompt chars like >, only accept in the first 60% of the line
    if ((ch === ">" || ch === "›") && i >= ambiguousScanLimit) continue;
+    if (
+      (ch === ">" || ch === "›") &&
+      lastStandardBoundary >= 0 &&
+      /\s/.test(lineText.slice(0, i).trim()) &&
+      !isEmbeddedPromptMarker(lineText, lastStandardBoundary) &&
+      !canSupersedeThemedPromptBoundary(lineText, lastStandardBoundary, i)
+    ) {
+      continue;
+    }

    // Must be followed by a space or end-of-line.
    const nextChar = i + 1 < lineText.length ? lineText[i + 1] : null;
@@ -252,6 +857,31 @@ function findPromptBoundary(lineText: string): number {
    // Record this as a candidate boundary. A standard shell prompt terminator
    // is more reliable than a later Powerline/Nerd Font glyph in command text.
    const boundary = nextChar === " " ? i + 2 : i + 1;
+    const candidatePromptText = lineText.slice(0, boundary);
+    if (isStandard && hasSwallowedCommandAfterPrompt(candidatePromptText, boundary)) {
+      continue;
+    }
+    if (isStandard && lastStandardBoundary >= 0) {
+      const themedPromptCanSupersede = canSupersedeThemedPromptBoundary(
+        lineText,
+        lastStandardBoundary,
+        getBoundaryMarkerIndex(lineText, boundary),
+      );
+      const canSupersedePreviousBoundary =
+        canPromptMarkerSupersedePreviousBoundary(ch) &&
+        (
+          isEmbeddedPromptMarker(lineText, lastStandardBoundary) ||
+          isSpacedPromptSegment(lineText, lastStandardBoundary) ||
+          themedPromptCanSupersede
+        ) &&
+        (
+          themedPromptCanSupersede ||
+          isSpecificShellPromptCandidate(candidatePromptText, {
+            allowGreaterThanTerminator: ch === ">" || ch === "›",
+          })
+        );
+      if (!canSupersedePreviousBoundary) continue;
+    }
    if (isStandard) {
      lastStandardBoundary = boundary;
    } else {
@@ -291,6 +921,11 @@ export function reconcilePromptWithTypedInput(
    prompt.userInput.length > typedInput.length &&
    prompt.userInput.endsWith(typedInput)
  ) {
+    if (!canReconcilePromptDecoration(prompt, typedInput, {
+      allowSingleWordCommandDirectory: true,
+    })) {
+      return prompt;
+    }
    const extra = prompt.userInput.slice(0, prompt.userInput.length - typedInput.length);
    return {
      isAtPrompt: true,
@@ -302,6 +937,36 @@ export function reconcilePromptWithTypedInput(
  return prompt;
 }

+export function reconcilePromptWithExternalCommand(
+  prompt: PromptDetectionResult,
+  command: string,
+): PromptDetectionResult | null {
+  const typedInput = command.trim();
+  if (!prompt.isAtPrompt || typedInput.length === 0) return null;
+
+  const syntheticPrompt = {
+    ...prompt,
+    userInput: `${prompt.userInput}${typedInput}`,
+    cursorOffset: prompt.userInput.length + typedInput.length,
+  };
+  if (!canReconcilePromptDecoration(syntheticPrompt, typedInput, {
+    allowSingleWordCommandDirectory: true,
+  })) {
+    return null;
+  }
+
+  const extra = syntheticPrompt.userInput.slice(
+    0,
+    syntheticPrompt.userInput.length - typedInput.length,
+  );
+  return {
+    isAtPrompt: true,
+    promptText: prompt.promptText + extra,
+    userInput: typedInput,
+    cursorOffset: typedInput.length,
+  };
+}
+
 /**
 * Unified entry point for any autocomplete code path that needs a prompt
 * view. Every consumer (fetchSuggestions, insertSuggestion,
@@ -312,13 +977,11 @@ export function reconcilePromptWithTypedInput(
 * pre-#806 behavior, not a worse pollution.
 *
 * Alignment rule: the keystroke buffer is usable only when it's marked
- * reliable AND the raw detected prompt still looks like the same shell
- * line. When the raw buffer has either over-captured prompt chrome
- * (`raw.userInput.endsWith(typedBuffer)`) or under-captured because the
- * shell echo/render is lagging behind local keystrokes
- * (`typedBuffer.startsWith(raw.userInput)`), prefer the typed buffer.
- * Otherwise the buffer is ignored and the raw detector result passes
- * through.
+ * reliable and it can be reconciled with the live line. Exact raw
+ * matches are safe, over-captured prompt chrome can be moved back into
+ * promptText, and no-space prompts can be inferred from the cursor line
+ * when the inferred prompt still looks like a shell prompt. Otherwise
+ * the buffer is ignored and the raw detector result passes through.
 */
 export function getAlignedPrompt(
  term: XTerm | null,
@@ -327,57 +990,40 @@ export function getAlignedPrompt(
 ): AlignedPromptResult {
  if (!term) return { prompt: NO_PROMPT, alignedTyped: null };
  const raw = detectPrompt(term);
-  if (!typedReliable || typedBuffer.length === 0 || !raw.isAtPrompt) {
+  if (!typedReliable || typedBuffer.length === 0) {
    return { prompt: raw, alignedTyped: null };
  }
-  if (raw.userInput === typedBuffer) {
-    return { prompt: raw, alignedTyped: typedBuffer };
-  }
-  if (raw.userInput.length > typedBuffer.length && raw.userInput.endsWith(typedBuffer)) {
-    return {
-      prompt: reconcilePromptWithTypedInput(raw, typedBuffer),
-      alignedTyped: typedBuffer,
-    };
-  }
-  if (typedBuffer.length > raw.userInput.length && typedBuffer.startsWith(raw.userInput)) {
-    return {
-      prompt: replacePromptUserInput(raw, typedBuffer),
-      alignedTyped: typedBuffer,
-    };
-  }
-  const cursorLinePrefix = getCursorLinePrefix(term);
-  if (cursorLinePrefix?.endsWith(typedBuffer)) {
-    const promptText = cursorLinePrefix.slice(0, cursorLinePrefix.length - typedBuffer.length);
-    if (promptText.length > 0) {
+
+  if (raw.isAtPrompt) {
+    if (raw.userInput === typedBuffer) {
+      return { prompt: raw, alignedTyped: typedBuffer };
+    }
+    if (raw.userInput.length > typedBuffer.length && raw.userInput.endsWith(typedBuffer)) {
+      const prompt = reconcilePromptWithTypedInput(raw, typedBuffer);
+      if (prompt === raw) return { prompt: raw, alignedTyped: null };
      return {
-        prompt: {
-          isAtPrompt: true,
-          promptText,
-          userInput: typedBuffer,
-          cursorOffset: typedBuffer.length,
-        },
+        prompt,
+        alignedTyped: typedBuffer,
+      };
+    }
+    const themedDecorationAlignment = alignThemedDecorationWithPartialEcho(raw, typedBuffer);
+    if (themedDecorationAlignment) return themedDecorationAlignment;
+    if (canUseReliablePromptPrefix(raw, typedBuffer)) {
+      return {
+        prompt: withTypedUserInput(raw, typedBuffer),
        alignedTyped: typedBuffer,
      };
    }
  }
-  return { prompt: raw, alignedTyped: null };
-}

-/**
- * Simplified prompt detection: just check if we're likely at a prompt.
- */
-export function isLikelyAtPrompt(term: XTerm): boolean {
-  const buffer = term.buffer.active;
-  const cursorY = buffer.cursorY + buffer.baseY;
-  const line = buffer.getLine(cursorY);
-  if (!line) return false;
-
-  const lineText = line.translateToString(false);
-  if (lineText.trim().length === 0) return false;
-
-  for (const pattern of NON_PROMPT_PATTERNS) {
-    if (pattern.test(lineText)) return false;
+  const cursorPrefixCandidates = [
+    getWrappedCursorPrefix(term),
+    getCursorLinePrefix(term),
+  ];
+  for (const cursorPrefix of cursorPrefixCandidates) {
+    const aligned = alignTypedInputFromCursorPrefix(raw, cursorPrefix, typedBuffer);
+    if (aligned) return aligned;
  }

-  return findPromptBoundary(lineText) >= 0;
+  return { prompt: raw, alignedTyped: null };
 }
--- a/components/terminal/autocomplete/remotePathCompleter.ts
+++ b/components/terminal/autocomplete/remotePathCompleter.ts
@@ -13,6 +13,10 @@ export interface DirEntry {
  type: "file" | "directory" | "symlink";
 }

+interface ResolvePathOptions {
+  preferRelativeCwd?: boolean;
+}
+
 /** Bridge interface for directory listing */
 interface PathBridge {
  listAutocompleteRemoteDir?: (
@@ -130,18 +134,20 @@ export function shouldDoPathCompletion(
 export function resolvePathComponents(
  currentWord: string,
  cwd: string | undefined,
+  options: ResolvePathOptions = {},
 ): { dirToList: string; filterPrefix: string; pathPrefix: string; quoteSuffix: string } {
  const quotePrefix = getLeadingQuote(currentWord);
  const quoteSuffix = getTrailingMatchingQuote(currentWord, quotePrefix);
  const unquotedWord = stripWrappingQuotes(currentWord);
+  const preferRelativeCwd = options.preferRelativeCwd === true;

  // Handle empty input — list CWD
  if (!unquotedWord || unquotedWord === "." || unquotedWord === "~" || unquotedWord === "..") {
    const dir = unquotedWord === "~"
      ? "~"
      : unquotedWord === ".."
-        ? resolveDirLookup("../", cwd)
-        : (cwd || ".");
+        ? resolveDirLookup("../", cwd, preferRelativeCwd)
+        : resolveDirLookup("", cwd, preferRelativeCwd);
    const visiblePrefix = unquotedWord ? `${quotePrefix}${unquotedWord}/` : quotePrefix;
    return { dirToList: dir, filterPrefix: "", pathPrefix: visiblePrefix, quoteSuffix };
  }
@@ -155,22 +161,26 @@ export function resolvePathComponents(
    const decodedDirPart = decodeShellPathFragment(dirPart);
    const decodedFilterPart = decodeShellPathFragment(filterPart);

-    const dirToList = resolveDirLookup(decodedDirPart, cwd);
+    const dirToList = resolveDirLookup(decodedDirPart, cwd, preferRelativeCwd);

    return { dirToList, filterPrefix: decodedFilterPart, pathPrefix: quotePrefix + dirPart, quoteSuffix };
  }

  // No slash — filter CWD entries by the typed prefix
  return {
-    dirToList: cwd || ".",
+    dirToList: resolveDirLookup("", cwd, preferRelativeCwd),
    filterPrefix: decodeShellPathFragment(unquotedWord),
    pathPrefix: quotePrefix,
    quoteSuffix,
  };
 }

-export function normalizePathTokenForLookup(token: string, cwd?: string): string {
-  const { dirToList, filterPrefix } = resolvePathComponents(token, cwd);
+export function normalizePathTokenForLookup(
+  token: string,
+  cwd?: string,
+  options: ResolvePathOptions = {},
+): string {
+  const { dirToList, filterPrefix } = resolvePathComponents(token, cwd, options);
  if (!filterPrefix) return dirToList;

  if (!dirToList || dirToList === ".") {
@@ -189,16 +199,20 @@ export async function getPathSuggestions(
  options: {
    sessionId?: string;
    protocol?: string;
+    os?: "linux" | "windows" | "macos";
    cwd?: string;
    foldersOnly: boolean;
  },
 ): Promise<{ name: string; type: DirEntry["type"] }[]> {
-  const { sessionId, protocol, cwd, foldersOnly } = options;
-  const { dirToList, filterPrefix } = resolvePathComponents(ctx.currentWord, cwd);
+  const { sessionId, protocol, os, cwd, foldersOnly } = options;
+  const { dirToList, filterPrefix } = resolvePathComponents(ctx.currentWord, cwd, {
+    preferRelativeCwd: shouldUseRemoteShellCwd(protocol, sessionId, os),
+  });

  const entries = await listDirectoryEntries(dirToList, {
    sessionId,
    protocol,
+    os,
    foldersOnly,
    filterPrefix,
    limit: 100,
@@ -215,6 +229,7 @@ export async function listDirectoryEntries(
  options: {
    sessionId?: string;
    protocol?: string;
+    os?: "linux" | "windows" | "macos";
    foldersOnly: boolean;
    filterPrefix?: string;
    limit?: number;
@@ -223,6 +238,7 @@ export async function listDirectoryEntries(
  const {
    sessionId,
    protocol,
+    os,
    foldersOnly,
    filterPrefix = "",
    limit = 100,
@@ -232,28 +248,32 @@ export async function listDirectoryEntries(
  const baseKey = `${protocol || "auto"}:${sessionId || "local"}:${dirPath}:${foldersOnly}`;
  const fullCacheKey = `${baseKey}:all`;
  const filteredCacheKey = `${baseKey}:prefix:${normalizedPrefix}:${maxEntries}`;
+  const bypassCache = shouldBypassCache(protocol, sessionId, os, dirPath);

  // Full directory cache can satisfy both full and filtered lookups.
-  const fullCached = fullDirCache.get(fullCacheKey);
-  if (isFresh(fullCached)) {
-    return filterEntries(fullCached.entries, normalizedPrefix, maxEntries);
-  }
-
-  if (normalizedPrefix) {
-    const filteredCached = filteredDirCache.get(filteredCacheKey);
-    if (isFresh(filteredCached)) {
-      return filteredCached.entries;
+  if (!bypassCache) {
+    const fullCached = fullDirCache.get(fullCacheKey);
+    if (isFresh(fullCached)) {
+      return filterEntries(fullCached.entries, normalizedPrefix, maxEntries);
    }
-  }

-  const inFlightFull = inFlightRequests.get(fullCacheKey);
-  if (inFlightFull) {
-    return filterEntries(await inFlightFull, normalizedPrefix, maxEntries);
+    if (normalizedPrefix) {
+      const filteredCached = filteredDirCache.get(filteredCacheKey);
+      if (isFresh(filteredCached)) {
+        return filteredCached.entries;
+      }
+    }
+
+    const inFlightFull = inFlightRequests.get(fullCacheKey);
+    if (inFlightFull) {
+      return filterEntries(await inFlightFull, normalizedPrefix, maxEntries);
+    }
+
+    const inFlight = inFlightRequests.get(normalizedPrefix ? filteredCacheKey : fullCacheKey);
+    if (inFlight) return inFlight;
  }

  const requestKey = normalizedPrefix ? filteredCacheKey : fullCacheKey;
-  const inFlight = inFlightRequests.get(requestKey);
-  if (inFlight) return inFlight;

  // Make IPC call
  const promise = (async (): Promise<DirEntry[]> => {
@@ -284,6 +304,9 @@ export async function listDirectoryEntries(

      if (result.success) {
        const timestamp = Date.now();
+        if (bypassCache) {
+          return result.entries;
+        }
        if (normalizedPrefix) {
          filteredDirCache.set(requestKey, { entries: result.entries, timestamp });
          evictOldest(filteredDirCache, MAX_FILTERED_CACHE_SIZE);
@@ -299,11 +322,15 @@ export async function listDirectoryEntries(
    } catch {
      return [];
    } finally {
-      inFlightRequests.delete(requestKey);
+      if (!bypassCache) {
+        inFlightRequests.delete(requestKey);
+      }
    }
  })();

-  inFlightRequests.set(requestKey, promise);
+  if (!bypassCache) {
+    inFlightRequests.set(requestKey, promise);
+  }
  return promise;
 }

@@ -312,14 +339,33 @@ function clampLimit(limit: number): number {
  return Math.max(1, Math.min(200, Math.floor(limit)));
 }

-function resolveDirLookup(pathToken: string, cwd: string | undefined): string {
-  if (!pathToken) return cwd || ".";
+function resolveDirLookup(pathToken: string, cwd: string | undefined, preferRelativeCwd = false): string {
+  if (!pathToken) return preferRelativeCwd ? "." : (cwd || ".");
  if (pathToken.startsWith("/")) return normalizePosixLikePath(pathToken);
  if (pathToken === "~" || pathToken.startsWith("~/")) return normalizePosixLikePath(pathToken);
+  if (preferRelativeCwd) return normalizePosixLikePath(pathToken);
  if (cwd) return normalizePosixLikePath(`${cwd}/${pathToken}`);
  return normalizePosixLikePath(pathToken);
 }

+function shouldUseRemoteShellCwd(
+  protocol: string | undefined,
+  sessionId: string | undefined,
+  os?: "linux" | "windows" | "macos",
+): boolean {
+  return Boolean(sessionId && protocol !== "local" && os === "linux");
+}
+
+function shouldBypassCache(
+  protocol: string | undefined,
+  sessionId: string | undefined,
+  os: "linux" | "windows" | "macos" | undefined,
+  dirPath: string,
+): boolean {
+  if (!shouldUseRemoteShellCwd(protocol, sessionId, os)) return false;
+  return !dirPath.startsWith("/") && dirPath !== "~" && !dirPath.startsWith("~/");
+}
+
 function normalizePosixLikePath(input: string): string {
  if (!input) return ".";

--- a/components/terminal/autocomplete/snippetCompleter.ts
+++ b/components/terminal/autocomplete/snippetCompleter.ts
@@ -0,0 +1,49 @@
+/**
+ * Snippet completion source. Surfaces custom snippets in terminal autocomplete
+ * when the user is typing the command name. Matches against the snippet label
+ * and the first line of its command (case-insensitive; prefix matches rank
+ * above substring matches). Each suggestion carries the full Snippet so the
+ * accept path can run it through the canonical executeSnippetCommand.
+ */
+import type { Snippet } from "../../../domain/models";
+import type { CompletionSuggestion } from "./completionEngine";
+
+const SNIPPET_BASE_SCORE = 2000; // Above history (1000+freq) per "snippet > history".
+const SNIPPET_PREFIX_BONUS = 100;
+
+function appliesToHost(snippet: Snippet, hostId?: string): boolean {
+  if (!snippet.targets || snippet.targets.length === 0) return true;
+  return hostId !== undefined && snippet.targets.includes(hostId);
+}
+
+export function getSnippetSuggestions(
+  input: string,
+  snippets: Snippet[],
+  options: { hostId?: string } = {},
+): CompletionSuggestion[] {
+  const needle = input.trim().toLowerCase();
+  if (!needle || !Array.isArray(snippets)) return [];
+
+  const out: CompletionSuggestion[] = [];
+  for (const snippet of snippets) {
+    if (!appliesToHost(snippet, options.hostId)) continue;
+    const label = (snippet.label || "").toLowerCase();
+    const firstLine = (snippet.command || "").split("\n")[0].trim().toLowerCase();
+
+    const labelPrefix = label.startsWith(needle);
+    const matches = labelPrefix || label.includes(needle) || firstLine.startsWith(needle);
+    if (!matches) continue;
+
+    out.push({
+      text: snippet.label,
+      displayText: snippet.label,
+      description: snippet.command,
+      source: "snippet",
+      score: SNIPPET_BASE_SCORE + (labelPrefix ? SNIPPET_PREFIX_BONUS : 0),
+      snippet,
+    });
+  }
+
+  out.sort((a, b) => b.score - a.score);
+  return out;
+}
--- a/components/terminal/autocomplete/useTerminalAutocomplete.ts
+++ b/components/terminal/autocomplete/useTerminalAutocomplete.ts
@@ -11,14 +11,21 @@
 import { startTransition, useCallback, useEffect, useRef, useState, type RefObject } from "react";
 import type { Terminal as XTerm } from "@xterm/xterm";
 import { GhostTextAddon } from "./GhostTextAddon";
-import { getAlignedPrompt, type PromptDetectionResult } from "./promptDetector";
+import {
+  getAlignedPrompt,
+  isNonPromptLine,
+  reconcilePromptWithExternalCommand,
+  type PromptDetectionResult,
+} from "./promptDetector";
 import { getCompletions, parseCommandLine, type CompletionSuggestion } from "./completionEngine";
+import type { Snippet } from "../../../domain/models";
 import { recordCommand } from "./commandHistoryStore";
 import { shellEscape } from "./completionEngine";
 import { preloadCommonSpecs } from "./figSpecLoader";
 import { getXTermCellDimensions } from "./xtermUtils";
 import { listDirectoryEntries, normalizePathTokenForLookup } from "./remotePathCompleter";
 import { decideGhostSuggestion } from "./ghostSuggestionPolicy";
+import { computeLivePreviewWrite } from "./livePreviewSequence";

 export interface AutocompleteSettings {
  enabled: boolean;
@@ -41,6 +48,18 @@ export const DEFAULT_AUTOCOMPLETE_SETTINGS: AutocompleteSettings = {
  fastTypingThresholdMs: 40,
 };

+/**
+ * Whether completion work is worth doing — i.e. whether anything would
+ * actually be rendered. With both the popup and ghost text disabled, querying
+ * completions only to discard the result is pure main-thread waste, so callers
+ * skip it entirely.
+ */
+export function shouldQueryCompletions(
+  settings: Pick<AutocompleteSettings, "showPopupMenu" | "showGhostText">,
+): boolean {
+  return settings.showPopupMenu || settings.showGhostText;
+}
+
 /** Shared empty state to avoid creating new objects on every reset */
 const EMPTY_STATE: AutocompleteState = Object.freeze({
  suggestions: [],
@@ -94,6 +113,10 @@ interface UseTerminalAutocompleteOptions {
  protocol?: string;
  /** Get current working directory (from OSC 7 or other source) */
  getCwd?: () => string | undefined;
+  /** Custom snippets to surface at the command position */
+  snippets?: Snippet[];
+  /** Accept a snippet — clears typed input then runs it (host-canonical send) */
+  onAcceptSnippet?: (snippet: Snippet) => void;
 }

 export interface TerminalAutocompleteHandle {
@@ -107,10 +130,100 @@ export interface TerminalAutocompleteHandle {
  dispose: () => void;
 }

+const THEMED_PROMPT_MARKERS = /[❯❮→➜➤⟩»›]/;
+
+function hasStandardShellPromptTerminator(promptText: string): boolean {
+  return /[$#%>]$/.test(promptText.trimEnd());
+}
+
+function isSingleThemedPromptTerminator(promptText: string): boolean {
+  const trimmed = promptText.trim();
+  if (trimmed.length !== 1) return false;
+  const code = trimmed.charCodeAt(0);
+  return THEMED_PROMPT_MARKERS.test(trimmed) || (code >= 0xE000 && code <= 0xF8FF);
+}
+
+function isThemedPromptPathToken(token: string): boolean {
+  return (
+    token === "~" ||
+    token.startsWith("~/") ||
+    token.startsWith("/") ||
+    /^[A-Za-z]:[\\/]/.test(token) ||
+    token.includes("\\")
+  );
+}
+
+function hasThemedPromptDecorationInInput(prompt: PromptDetectionResult): boolean {
+  const hasThemedPromptMarker =
+    THEMED_PROMPT_MARKERS.test(prompt.promptText) ||
+    Array.from(prompt.promptText).some((ch) => {
+      const code = ch.charCodeAt(0);
+      return code >= 0xE000 && code <= 0xF8FF;
+    });
+  if (hasThemedPromptMarker && hasStandardShellPromptTerminator(prompt.promptText)) {
+    return false;
+  }
+  if (hasThemedPromptMarker && isSingleThemedPromptTerminator(prompt.promptText)) {
+    const firstToken = prompt.userInput.trimStart().match(/^\S+/)?.[0] ?? "";
+    return (
+      (prompt.userInput.startsWith(" ") || isThemedPromptPathToken(firstToken)) &&
+      /\S+\s+\S/.test(prompt.userInput)
+    );
+  }
+  return hasThemedPromptMarker && /\S+\s+\S/.test(prompt.userInput);
+}
+
+export function getCommandToRecordOnEnter(
+  livePrompt: PromptDetectionResult,
+  alignedTyped: string | null,
+  typedBuffer: string,
+  typedBufferReliable: boolean,
+): string | null {
+  if (!livePrompt.isAtPrompt) return null;
+  const alignedCommand = alignedTyped?.trim();
+  if (alignedCommand) return alignedCommand;
+
+  const reliableTypedCommand = typedBufferReliable ? typedBuffer.trim() : "";
+  if (reliableTypedCommand) {
+    const reconciledPrompt = reconcilePromptWithExternalCommand(
+      livePrompt,
+      reliableTypedCommand,
+    );
+    if (reconciledPrompt) return reliableTypedCommand;
+  }
+
+  const liveCommand = livePrompt.userInput.trim();
+  if (!liveCommand && reliableTypedCommand) {
+    return isNonPromptLine(`${livePrompt.promptText}${reliableTypedCommand}`)
+      ? null
+      : reliableTypedCommand;
+  }
+  if (!liveCommand) return null;
+  if (!typedBufferReliable && hasThemedPromptDecorationInInput(livePrompt)) return null;
+
+  const liveInputMayIncludePromptDecoration =
+    typedBufferReliable &&
+    typedBuffer.trim().length > 0 &&
+    liveCommand !== typedBuffer.trim() &&
+    liveCommand.endsWith(typedBuffer.trim());
+  if (liveInputMayIncludePromptDecoration) return null;
+
+  const liveInputMayBeLagging =
+    typedBufferReliable &&
+    typedBuffer.trim().length > 0 &&
+    typedBuffer.length > livePrompt.userInput.length &&
+    typedBuffer.startsWith(livePrompt.userInput);
+  if (liveInputMayBeLagging) return null;
+
+  if (typedBufferReliable && hasThemedPromptDecorationInInput(livePrompt)) return null;
+
+  return liveCommand;
+}
+
 export function useTerminalAutocomplete(
  options: UseTerminalAutocompleteOptions,
 ): TerminalAutocompleteHandle {
-  const { termRef, sessionId, hostId, hostOs, settings: userSettings, onAcceptText, protocol, getCwd } = options;
+  const { termRef, sessionId, hostId, hostOs, settings: userSettings, onAcceptText, protocol, getCwd, snippets, onAcceptSnippet } = options;
  const rawSettings: AutocompleteSettings = {
    ...DEFAULT_AUTOCOMPLETE_SETTINGS,
    ...userSettings,
@@ -132,6 +245,10 @@ export function useTerminalAutocomplete(
  settingsRef.current = settings;
  const onAcceptTextRef = useRef(onAcceptText);
  onAcceptTextRef.current = onAcceptText;
+  const snippetsRef = useRef(snippets);
+  snippetsRef.current = snippets;
+  const onAcceptSnippetRef = useRef(onAcceptSnippet);
+  onAcceptSnippetRef.current = onAcceptSnippet;
  const hostIdRef = useRef(hostId);
  hostIdRef.current = hostId;
  const hostOsRef = useRef(hostOs);
@@ -158,6 +275,10 @@ export function useTerminalAutocomplete(
  const fetchVersionRef = useRef(0);
  /** Last accepted suggestion text — for accurate history recording on fast Enter after accept */
  const lastAcceptedCommandRef = useRef<string | null>(null);
+  /** The user's typed input that produced the current popup suggestions (live-preview baseline). */
+  const previewBaselineRef = useRef<string>("");
+  /** Whether a popup candidate is currently rendered into the command line (#1005). */
+  const previewActiveRef = useRef(false);
  /** Monotonic counter to invalidate stale async sub-dir fetches */
  const subDirFetchVersionRef = useRef(0);
  /**
@@ -275,6 +396,7 @@ export function useTerminalAutocomplete(
    return listDirectoryEntries(dirPath, {
      sessionId: sessionIdRef.current,
      protocol: protocolRef.current,
+      os: hostOsRef.current,
      foldersOnly: false,
      limit: 50,
    });
@@ -308,7 +430,11 @@ export function useTerminalAutocomplete(
      getCwdRef.current?.(),
      hostOsRef.current,
    );
-    const dirPath = normalizePathTokenForLookup(parseCommandLine(item.text).currentWord, cwd);
+    const dirPath = normalizePathTokenForLookup(parseCommandLine(item.text).currentWord, cwd, {
+      preferRelativeCwd: Boolean(
+        sessionIdRef.current && protocolRef.current !== "local" && hostOsRef.current === "linux",
+      ),
+    });
    if (!dirPath) return;

    const requestVersion = ++subDirFetchVersionRef.current;
@@ -436,6 +562,41 @@ export function useTerminalAutocomplete(
    });
  }, [termRef]);

+  /**
+   * Render the full path for a sub-dir entry into the line WITHOUT finalizing
+   * (no clearState). Used for live-preview while navigating sub-dir panels (#1005).
+   */
+  const renderSubDirPath = useCallback((level: number, entry: SubDirEntry) => {
+    const s = stateRef.current;
+    const term = termRef.current;
+    if (!term) return;
+    const panel = s.subDirPanels[level];
+    if (!panel) return;
+    const { prompt } = getAlignedPrompt(
+      term, typedInputBufferRef.current, typedBufferReliableRef.current,
+    );
+    if (!prompt.isAtPrompt) return;
+    const parsed = parseCommandLine(prompt.userInput);
+    const cmdPrefix = parsed.tokens.slice(0, parsed.wordIndex).join(" ")
+      + (parsed.wordIndex > 0 ? " " : "");
+    const currentToken = parsed.currentWord;
+    const quotePrefix = currentToken.startsWith('"') || currentToken.startsWith("'")
+      ? currentToken[0] : "";
+    const quoteSuffix = quotePrefix && currentToken.endsWith(quotePrefix) ? quotePrefix : "";
+    const suffix = entry.type === "directory" ? "/" : "";
+    const entryName = quotePrefix || !/[\\$'"|!<>;#~` ]/.test(entry.name)
+      ? entry.name : shellEscape(entry.name);
+    const newCommand = cmdPrefix + `${quotePrefix}${panel.dirPath}${entryName}${suffix}${quoteSuffix}`;
+    const seq = computeLivePreviewWrite({
+      currentLine: prompt.userInput, candidate: newCommand, os: hostOsRef.current,
+    });
+    if (seq) writeToTerminal(seq);
+    typedInputBufferRef.current = newCommand;
+    typedBufferReliableRef.current = true;
+    previewActiveRef.current = true;
+    lastAcceptedCommandRef.current = newCommand;
+  }, [termRef, writeToTerminal]);
+
  /** Handle selecting a file/directory from any sub-dir panel.
   *  Builds the full path from the panel stack and replaces the current input. */
  const handleSubDirSelect = useCallback((level: number, entry: SubDirEntry) => {
@@ -500,6 +661,15 @@ export function useTerminalAutocomplete(
      return;
    }

+    // Nothing will be rendered when both the popup and ghost text are off, so
+    // don't run the (potentially expensive) completion query just to throw the
+    // result away. Clear any stale state and bail before touching history,
+    // fig specs, or remote path lookups.
+    if (!shouldQueryCompletions(settingsRef.current)) {
+      clearState();
+      return;
+    }
+
    // Capture version at start — if it changes during async work, discard results
    const version = ++fetchVersionRef.current;

@@ -538,6 +708,7 @@ export function useTerminalAutocomplete(
      sessionId: sessionIdRef.current,
      protocol: protocolRef.current,
      cwd,
+      snippets: snippetsRef.current,
    });

    if (disposedRef.current || version !== fetchVersionRef.current) return;
@@ -555,7 +726,8 @@ export function useTerminalAutocomplete(
    if (settingsRef.current.showGhostText) {
      const ghost = ghostAddonRef.current;
      const activeSuggestion = ghost?.isActive() ? ghost.getSuggestion() : null;
-      const nextSuggestion = completions.length > 0 ? completions[0].text : null;
+      // Snippets are popup-only — never used as inline ghost text.
+      const nextSuggestion = completions.find((c) => c.source !== "snippet")?.text ?? null;
      const ghostDecision = decideGhostSuggestion(activeSuggestion, input, nextSuggestion);
      if (ghostDecision.type === "show") {
        ghost?.show(ghostDecision.suggestion, input);
@@ -566,6 +738,9 @@ export function useTerminalAutocomplete(

    // Popup
    if (settingsRef.current.showPopupMenu && completions.length > 0) {
+      // Live-preview baseline: the typed input these suggestions completed.
+      previewBaselineRef.current = input;
+      previewActiveRef.current = false;
      const { position, cursorLineTop, cursorLineBottom, expandUpward } = calculatePopupPosition(term, completions.length);
      startTransition(() => {
        setState((prev) => {
@@ -638,29 +813,21 @@ export function useTerminalAutocomplete(
            // Require a live prompt before trusting either keystroke buffer
            // or buffer-based detection — otherwise sudo password Enter
            // would record the typed password as a command.
+            const typedBuffer = typedInputBufferRef.current;
+            const typedBufferReliable = typedBufferReliableRef.current;
            const { prompt: livePrompt, alignedTyped } = getAlignedPrompt(
              termRef.current,
-              typedInputBufferRef.current,
-              typedBufferReliableRef.current,
+              typedBuffer,
+              typedBufferReliable,
            );
-            if (livePrompt.isAtPrompt) {
-              // alignedTyped is only non-null when the buffer is reliable
-              // AND matches the live line's tail — that single signal
-              // covers both the robbyrussell "~ " case (#806) and the
-              // stale-buffer cases from out-of-band pastes / history
-              // recall (#814 P1/P2). When it's null we fall back to the
-              // reconciled livePrompt.userInput, which for paste-bypass
-              // scenarios lands on pre-PR behavior (no regression).
-              if (alignedTyped && alignedTyped.trim()) {
-                recordCommand(alignedTyped.trim(), hostIdRef.current, hostOsRef.current);
-              } else if (livePrompt.userInput.trim()) {
-                recordCommand(livePrompt.userInput.trim(), hostIdRef.current, hostOsRef.current);
-              }
-            } else if (lastPromptRef.current?.isAtPrompt && lastPromptRef.current.userInput.trim()) {
-              // Only fall back to the cached prompt when we have no live
-              // reading at all — guards against recording during interactive
-              // prompts where detectPrompt correctly bails out.
-              recordCommand(lastPromptRef.current.userInput.trim(), hostIdRef.current, hostOsRef.current);
+            const commandToRecord = getCommandToRecordOnEnter(
+              livePrompt,
+              alignedTyped,
+              typedBuffer,
+              typedBufferReliable,
+            );
+            if (commandToRecord) {
+              recordCommand(commandToRecord, hostIdRef.current, hostOsRef.current);
            }
          }
          lastAcceptedCommandRef.current = null;
@@ -784,6 +951,10 @@ export function useTerminalAutocomplete(
      // User is typing more — invalidate accepted command fallback since the
      // command is being edited further (e.g., accepted "git status" then added " --short")
      lastAcceptedCommandRef.current = null;
+      // The previewed candidate is now edited, so the line is the user's own
+      // text. Drop preview-active so Escape dismisses the popup without
+      // reverting these edits back to the stale baseline (#1005).
+      previewActiveRef.current = false;

      // Re-align any visible ghost text to the freshly-updated buffer
      // immediately. Without this the ghost keeps the tail it captured at
@@ -963,10 +1134,11 @@ export function useTerminalAutocomplete(
      // which is otherwise shadowed by our single-Tab ghost accept.
      if (e.key === "Tab" && !e.ctrlKey && !e.metaKey && !e.altKey && s.subDirFocusLevel < 0) {
        if (s.popupVisible && s.suggestions.length > 0) {
-          e.preventDefault();
-          const selected = s.suggestions[Math.max(0, s.selectedIndex)];
-          if (selected) insertSuggestion(selected, false);
-          return false;
+          // #1005: don't intercept Tab. Keep whatever is currently rendered on
+          // the line and let Tab reach the shell for native completion.
+          clearState();
+          previewActiveRef.current = false;
+          return true;
        }
        // Hide stale ghost text before Tab reaches the shell — the shell's
        // completion will rewrite the line and the old ghost would mislead.
@@ -995,8 +1167,10 @@ export function useTerminalAutocomplete(
              panels[focusLevel] = { ...p, selectedIndex: newIdx };
              return { ...prev, subDirPanels: panels.slice(0, focusLevel + 1) };
            });
-            // Auto-expand next level if the newly selected item is a directory
+            // Live-render the highlighted entry's full path into the line (#1005).
            const newEntry = focusedPanel.entries[newIdx];
+            if (newEntry) renderSubDirPath(focusLevel, newEntry);
+            // Auto-expand next level if the newly selected item is a directory
            if (newEntry?.type === "directory") {
              expandSubDir(focusLevel, newEntry);
            }
@@ -1052,39 +1226,44 @@ export function useTerminalAutocomplete(
          return true;
        }

-        // Main panel navigation
-        if (e.key === "ArrowUp") {
+        // Main panel navigation. The cycle includes a -1 "no selection" slot so
+        // ↑ off the top / ↓ off the bottom reverts to the typed baseline. Moving
+        // the selection live-renders the candidate into the command line (#1005).
+        if (e.key === "ArrowUp" || e.key === "ArrowDown") {
          e.preventDefault();
+          const n = s.suggestions.length;
+          const cur = s.selectedIndex;
+          const next =
+            e.key === "ArrowDown"
+              ? (cur >= n - 1 ? -1 : cur + 1)
+              : (cur <= -1 ? n - 1 : cur - 1);
          setState((prev) => ({
            ...prev,
-            selectedIndex: prev.selectedIndex <= 0 ? prev.suggestions.length - 1 : prev.selectedIndex - 1,
+            selectedIndex: next,
            subDirPanels: [], subDirFocusLevel: -1,
          }));
-          fetchSubDirForIndex(s.selectedIndex <= 0 ? s.suggestions.length - 1 : s.selectedIndex - 1);
-          return false;
-        }
-        if (e.key === "ArrowDown") {
-          e.preventDefault();
-          setState((prev) => ({
-            ...prev,
-            selectedIndex: prev.selectedIndex >= prev.suggestions.length - 1 ? 0 : prev.selectedIndex + 1,
-            subDirPanels: [], subDirFocusLevel: -1,
-          }));
-          fetchSubDirForIndex(s.selectedIndex >= s.suggestions.length - 1 ? 0 : s.selectedIndex + 1);
+          renderPreviewSelection(next);
+          if (next >= 0) fetchSubDirForIndex(next);
          return false;
        }

-        // Enter on popup
+        // Enter on popup. The selected candidate is already rendered into the
+        // line by live-preview, so let Enter reach the shell. Don't record here:
+        // handleInput's Enter path records the *actual* line — it uses
+        // lastAcceptedCommandRef (set on select) but falls back to the live
+        // buffer when the user edited the previewed command (typing nulls that
+        // ref), so recording stays accurate in both cases.
        if (e.key === "Enter") {
-          if (s.selectedIndex >= 0) {
-            const selected = s.suggestions[s.selectedIndex];
-            if (selected) {
-              e.preventDefault();
-              insertSuggestion(selected, true);
-              return false;
-            }
+          const selected = s.selectedIndex >= 0 ? s.suggestions[s.selectedIndex] : null;
+          if (selected?.source === "snippet" && selected.snippet) {
+            e.preventDefault();
+            previewActiveRef.current = false;
+            acceptSnippet(selected.snippet);
+            return false; // consume — run the snippet, not the typed text
          }
          clearState();
+          previewActiveRef.current = false;
+          return true;
        }
      }

@@ -1093,8 +1272,12 @@ export function useTerminalAutocomplete(
      // when only ghost text is showing (ghost text is passive/non-intrusive)
      if (e.key === "Escape" && s.popupVisible) {
        e.preventDefault();
+        if (previewActiveRef.current) {
+          renderPreviewSelection(-1); // restore the typed baseline
+        }
        ghost?.hide();
        clearState();
+        previewActiveRef.current = false;
        return false;
      }

@@ -1104,6 +1287,59 @@ export function useTerminalAutocomplete(
    [writeToTerminal],
  );

+  /**
+   * Render the suggestion at `index` straight into the command line (Termius
+   * live-preview, #1005). `index < 0` restores the user's typed baseline.
+   */
+  const renderPreviewSelection = useCallback((index: number) => {
+    const s = stateRef.current;
+    const term = termRef.current;
+    if (!term) return;
+    const baseline = previewBaselineRef.current;
+    const selected = index >= 0 ? s.suggestions[index] : null;
+    // Snippets aren't literal completions — keep the user's typed text in the
+    // line (the popup detail panel shows the full command instead).
+    const candidate =
+      selected && selected.source !== "snippet" ? selected.text : baseline;
+    const { prompt } = getAlignedPrompt(
+      term,
+      typedInputBufferRef.current,
+      typedBufferReliableRef.current,
+    );
+    if (!prompt.isAtPrompt) return;
+    const seq = computeLivePreviewWrite({
+      currentLine: prompt.userInput,
+      candidate,
+      os: hostOsRef.current,
+    });
+    if (seq) writeToTerminal(seq);
+    typedInputBufferRef.current = candidate;
+    typedBufferReliableRef.current = true;
+    const isPreview = index >= 0 && candidate !== baseline;
+    previewActiveRef.current = isPreview;
+    lastAcceptedCommandRef.current = isPreview ? candidate : null;
+  }, [termRef, writeToTerminal]);
+
+  /** Accept a snippet: clear the user's typed input, then run it via the
+   *  host-canonical send path (onAcceptSnippet). */
+  const acceptSnippet = useCallback((snippet: Snippet) => {
+    const term = termRef.current;
+    if (term) {
+      const { prompt } = getAlignedPrompt(term, typedInputBufferRef.current, typedBufferReliableRef.current);
+      if (prompt.isAtPrompt && prompt.userInput.length > 0) {
+        const clearSequence = hostOsRef.current === "windows"
+          ? "\b".repeat(prompt.userInput.length)
+          : "\x15"; // Ctrl+U (readline kill-line)
+        writeToTerminal(clearSequence);
+      }
+    }
+    typedInputBufferRef.current = "";
+    typedBufferReliableRef.current = true;
+    onAcceptSnippetRef.current?.(snippet);
+    clearState();
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- clearState is stable
+  }, [termRef, writeToTerminal]);
+
  /**
   * Insert a suggestion into the terminal.
   * @param execute If true, also sends \r to execute the command.
@@ -1176,9 +1412,13 @@ export function useTerminalAutocomplete(
   */
  const selectSuggestion = useCallback(
    (suggestion: CompletionSuggestion) => {
+      if (suggestion.source === "snippet" && suggestion.snippet) {
+        acceptSnippet(suggestion.snippet);
+        return;
+      }
      insertSuggestion(suggestion, false);
    },
-    [insertSuggestion],
+    [insertSuggestion, acceptSnippet],
  );

  const closePopup = useCallback(() => {
--- a/components/terminal/completionEngine.test.ts
+++ b/components/terminal/completionEngine.test.ts
@@ -52,8 +52,14 @@ const storySpec: FigSpec = {
    },
  ],
 };
-const bridgeState: { localEntries: MockDirEntry[] } = {
+const bridgeState: {
+  localEntries: MockDirEntry[];
+  remoteEntriesByPath: Map<string, MockDirEntry[]>;
+  remoteCalls: string[];
+} = {
  localEntries: [],
+  remoteEntriesByPath: new Map(),
+  remoteCalls: [],
 };

 Object.defineProperty(globalThis, "window", {
@@ -74,6 +80,22 @@ Object.defineProperty(globalThis, "window", {
          .slice(0, limit ?? bridgeState.localEntries.length);
        return { success: true, entries };
      },
+      listAutocompleteRemoteDir: async (
+        _sessionId: string,
+        path: string,
+        foldersOnly: boolean,
+        filterPrefix?: string,
+        limit?: number,
+      ) => {
+        bridgeState.remoteCalls.push(path);
+        const prefix = (filterPrefix ?? "").toLowerCase();
+        const remoteEntries = bridgeState.remoteEntriesByPath.get(path) ?? [];
+        const entries = remoteEntries
+          .filter((entry) => !foldersOnly || entry.type === "directory")
+          .filter((entry) => !prefix || entry.name.toLowerCase().startsWith(prefix))
+          .slice(0, limit ?? remoteEntries.length);
+        return { success: true, entries };
+      },
    },
  },
  configurable: true,
@@ -86,6 +108,8 @@ test.beforeEach(() => {
  localStorage.clear();
  clearHistory();
  bridgeState.localEntries = [{ name: "package.json", type: "file" }];
+  bridgeState.remoteEntriesByPath = new Map();
+  bridgeState.remoteCalls = [];
 });

 test("getCompletions prioritizes spec-driven path suggestions over history", async () => {
@@ -121,3 +145,44 @@ test("getCompletions does not treat generator-only spec args as path contexts",
  assert.equal(completions[0]?.text, "story pick package-choice");
  assert.equal(completions.some((entry) => entry.source === "path"), false);
 });
+
+test("getCompletions uses the remote shell cwd for relative path arguments instead of stale home", async () => {
+  bridgeState.remoteEntriesByPath.set("~", [{ name: "home-only.txt", type: "file" }]);
+  bridgeState.remoteEntriesByPath.set(".", [{ name: "worktree.txt", type: "file" }]);
+
+  const completions = await getCompletions("cat wo", {
+    hostId: "host-1",
+    os: "linux",
+    protocol: "ssh",
+    sessionId: "session-1",
+    cwd: "~",
+  });
+
+  assert.deepEqual(bridgeState.remoteCalls, ["."]);
+  assert.equal(completions[0]?.source, "path");
+  assert.equal(completions[0]?.text, "cat worktree.txt");
+  assert.equal(completions.some((entry) => entry.text.includes("~")), false);
+});
+
+test("getCompletions does not reuse cached remote relative listings after cwd changes", async () => {
+  bridgeState.remoteEntriesByPath.set(".", [{ name: "home-only.txt", type: "file" }]);
+
+  await getCompletions("cat ", {
+    hostId: "host-1",
+    os: "linux",
+    protocol: "ssh",
+    sessionId: "session-1",
+  });
+
+  bridgeState.remoteEntriesByPath.set(".", [{ name: "worktree.txt", type: "file" }]);
+
+  const completions = await getCompletions("cat wo", {
+    hostId: "host-1",
+    os: "linux",
+    protocol: "ssh",
+    sessionId: "session-1",
+  });
+
+  assert.equal(bridgeState.remoteCalls.length, 2);
+  assert.equal(completions[0]?.text, "cat worktree.txt");
+});
--- a/components/terminal/completionEngineSnippets.test.ts
+++ b/components/terminal/completionEngineSnippets.test.ts
@@ -0,0 +1,19 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { getCompletions } from "./autocomplete/completionEngine";
+import type { Snippet } from "../../domain/models";
+
+const deploySnippet: Snippet = { id: "d", label: "deploy", command: "kubectl apply -f ." };
+
+test("getCompletions includes snippet suggestions at the command position", async () => {
+  const out = await getCompletions("dep", { snippets: [deploySnippet] });
+  const snip = out.find((s) => s.source === "snippet");
+  assert.ok(snip, "expected a snippet suggestion");
+  assert.equal(snip?.displayText, "deploy");
+});
+
+test("getCompletions does not surface snippets past the command position", async () => {
+  const out = await getCompletions("git dep", { snippets: [deploySnippet] });
+  assert.equal(out.find((s) => s.source === "snippet"), undefined);
+});
--- a/components/terminal/completionGate.test.ts
+++ b/components/terminal/completionGate.test.ts
@@ -0,0 +1,25 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { shouldQueryCompletions } from "./autocomplete/useTerminalAutocomplete.ts";
+
+test("queries completions when the popup menu is enabled", () => {
+  assert.equal(
+    shouldQueryCompletions({ showPopupMenu: true, showGhostText: false }),
+    true,
+  );
+});
+
+test("queries completions when ghost text is enabled", () => {
+  assert.equal(
+    shouldQueryCompletions({ showPopupMenu: false, showGhostText: true }),
+    true,
+  );
+});
+
+test("skips completion work when both popup and ghost text are off", () => {
+  assert.equal(
+    shouldQueryCompletions({ showPopupMenu: false, showGhostText: false }),
+    false,
+  );
+});
--- a/Show More
+++ b/Show More