fix: keep group notes visible during tree multi-select

feat: add Markdown notes to host groups
fix: prevent AI command truncation on OpenWrt BusyBox (#3342 )
2026-10-31 19:02:31 +00:00 · 2026-09-12 17:28:27 +08:00 · 2026-09-12 17:10:59 +08:00 · 2026-09-12 13:52:09 +08:00 · 2026-09-12 13:47:34 +08:00 · 2026-09-12 13:45:19 +08:00
217 changed files with 10564 additions and 1091 deletions
@@ -76,6 +76,7 @@ on:
      - "scripts/mosh-extra-resources.cjs"
      - "scripts/nodePtyConptyPatch.cjs"
      - "scripts/patch-xterm-macos-column-selection.cjs"
+      - "scripts/patch-xterm-foreground-intense.cjs"
      - "scripts/patch-xterm-webgl-atlas.cjs"
      - "scripts/rebuildPatchedNodePty.cjs"
      - "scripts/resolve-et-bin-release.cjs"
@@ -695,11 +696,11 @@ jobs:
        shell: bash
        run: |
          set -euo pipefail
-          # Security CDN endpoints can lack files advertised in their indexes.
-          # Fall back per file, with the final Bullseye security snapshot for packages only.
-          # Live signed indexes still select versions and verify every download.
-          printf 'http://deb.debian.org/debian-security\tpriority:1\nhttp://security.debian.org/debian-security\tpriority:2\nhttp://snapshot.debian.org/archive/debian-security/20260901T000000Z/\tpriority:3 type:deb\n' > /etc/apt/security-mirrors.txt
-          sed -i 's|http://deb.debian.org/debian-security|mirror+file:/etc/apt/security-mirrors.txt|g' /etc/apt/sources.list
+          # Bullseye LTS ended on 2026-08-31; its security index is now frozen.
+          # Pin the final snapshot and waive expiry only for this archived source.
+          # APT still verifies its signature and every package's checksum.
+          sed -i '/ bullseye-security /d' /etc/apt/sources.list
+          printf 'deb [check-valid-until=no] http://snapshot.debian.org/archive/debian-security/20260901T000000Z/ bullseye-security main\n' >> /etc/apt/sources.list
          apt-get -o Acquire::Retries=4 update
          apt-get -o Acquire::Retries=4 install -y curl build-essential python3 git libfuse2 file rpm \
            libarchive-tools \
@@ -1,57 +1,111 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-
 import { closeTabsBatchImpl } from './app/AppHandlers.ts';

-test('batch tab close removes standalone sessions in one state update', async () => {
-  const closedSessionBatches: string[][] = [];
-  const probedSessionBatches: string[][] = [];
-  const closeTabsInFlightRef = { current: false };
-  const sessions = [
-    { id: 's1', protocol: 'ssh' },
-    { id: 's2', protocol: 'ssh' },
-    { id: 's3', protocol: 'ssh' },
-  ];
+function setup() {
+  const closed: string[] = [];
+  const probes: string[][] = [];
+  const editors = [{ id: 'e', sessionId: 'connection', sftpTabId: 'pane' }];
+  let active = 's1';
+  const ctx = {
+    closeLogView: (id: string) => { closed.push(id); },
+    closeSessions: (ids: string[]) => { closed.push(...ids); },
+    closeTabsInFlightRef: { current: false },
+    closeWorkspace: (id: string) => { closed.push(id); },
+    confirmIfBusyLocalTerminal: async (ids: string[]) => { probes.push(ids); return true; },
+    logViews: [{ id: 'log' }],
+    sessions: [{ id: 's1', workspaceId: null as string | null }, { id: 's2', workspaceId: null as string | null }],
+    workspaces: [{ id: 'ws' }],
+    activeTabStore: { getActiveTabId: () => active, setActiveTabId: (id: string) => { active = id; } },
+    editorTabStore: { getTabs: () => editors },
+    pluginViewTabStore: {
+      getTab: (id: string) => id === 'plugin',
+      close: (id: string) => { closed.push(id); },
+    },
+    handleRequestCloseEditorTabRef: { current: async (id: string) => {
+      closed.push(`editor:${id}`);
+      editors.splice(editors.findIndex((editor) => editor.id === id), 1);
+      return true;
+    } },
+    findEditorSftpOwnerTabId: (_connection?: string, _pane?: string): string | null => null,
+    orderedTabsWithEditors: ['s1', 's2', 'ws', 'editor:e', 'log', 'plugin'],
+  };
+  return { ctx, closed, probes, run: (ids: string[]) => closeTabsBatchImpl(() => ctx, ids) };
+}

-  const result = await closeTabsBatchImpl(
-    () => ({
-      closeLogView: () => {},
-      closeSessions: (sessionIds: string[]) => closedSessionBatches.push(sessionIds),
-      closeTabsInFlightRef,
-      closeWorkspace: () => {},
-      confirmIfBusyLocalTerminal: async (sessionIds: string[]) => {
-        probedSessionBatches.push(sessionIds);
-        return true;
-      },
-      logViews: [],
-      sessions,
-      workspaces: [],
-    }),
-    ['s1', 's2', 's3'],
-  );
-
-  assert.deepEqual(probedSessionBatches, [['s1', 's2', 's3']]);
-  assert.deepEqual(closedSessionBatches, [['s1', 's2', 's3']]);
-  assert.equal(closeTabsInFlightRef.current, false);
-  assert.equal(result, true);
+test('batch closes sessions, workspaces, editors, logs and plugins and selects surviving tab', async () => {
+  const { ctx, closed, probes, run } = setup();
+  assert.equal(await run(['s1', 'ws', 'editor:e', 'log', 'plugin']), true);
+  assert.deepEqual(closed, ['editor:e', 's1', 'ws', 'log', 'plugin']);
+  assert.deepEqual(probes, [['s1']]);
+  assert.equal(ctx.activeTabStore.getActiveTabId(), 's2');
+  assert.equal(ctx.closeTabsInFlightRef.current, false);
 });

-test('batch tab close reports cancellation before mutating any tab', async () => {
-  let mutated = false;
-  const result = await closeTabsBatchImpl(
-    () => ({
-      closeLogView: () => { mutated = true; },
-      closeSessions: () => { mutated = true; },
-      closeTabsInFlightRef: { current: false },
-      closeWorkspace: () => { mutated = true; },
-      confirmIfBusyLocalTerminal: async () => false,
-      logViews: [],
-      sessions: [{ id: 's1', protocol: 'local' }],
-      workspaces: [],
-    }),
-    ['s1'],
-  );
+test('busy cancellation happens before any editor or other tab mutation', async () => {
+  const { ctx, closed, run } = setup();
+  ctx.confirmIfBusyLocalTerminal = async () => false;
+  assert.equal(await run(ctx.orderedTabsWithEditors), false);
+  assert.deepEqual(closed, []);
+  assert.equal(ctx.activeTabStore.getActiveTabId(), 's1');
+  assert.equal(ctx.closeTabsInFlightRef.current, false);
+});

-  assert.equal(result, false);
-  assert.equal(mutated, false);
+test('cancelled editor preserves its owner and active focus', async () => {
+  const { ctx, closed, run } = setup();
+  ctx.findEditorSftpOwnerTabId = () => 's1';
+  ctx.handleRequestCloseEditorTabRef.current = async () => false;
+  await run(ctx.orderedTabsWithEditors);
+  assert.deepEqual(closed, ['s2', 'ws', 'log', 'plugin']);
+  assert.equal(ctx.activeTabStore.getActiveTabId(), 's1');
+});
+
+test('editor outside close-left range preserves its owner', async () => {
+  const { ctx, closed, run } = setup();
+  ctx.findEditorSftpOwnerTabId = () => 's1';
+  await run(['s1']);
+  assert.deepEqual(closed, []);
+});
+
+test('preserved workspace containing an editor owner remains focused', async () => {
+  const { ctx, closed, probes, run } = setup();
+  ctx.sessions[0].workspaceId = 'ws';
+  ctx.findEditorSftpOwnerTabId = () => 's1';
+  ctx.activeTabStore.setActiveTabId('ws');
+  await run(['ws']);
+  assert.deepEqual(closed, []);
+  assert.deepEqual(probes, [['s1']]);
+  assert.equal(ctx.activeTabStore.getActiveTabId(), 'ws');
+});
+
+test('cancelled editor becomes focus destination when other tabs close', async () => {
+  const { ctx, run } = setup();
+  ctx.handleRequestCloseEditorTabRef.current = async () => false;
+  await run(ctx.orderedTabsWithEditors);
+  assert.equal(ctx.activeTabStore.getActiveTabId(), 'editor:e');
+});
+
+for (const phase of ['busy', 'editor'] as const) {
+  test(`overlapping batch is ignored during ${phase} prompt, including editor-only batches`, async () => {
+    const { ctx, closed, run } = setup();
+    let release!: (result: boolean) => void;
+    const pending = new Promise<boolean>((resolve) => { release = resolve; });
+    if (phase === 'busy') ctx.confirmIfBusyLocalTerminal = () => pending;
+    else ctx.handleRequestCloseEditorTabRef.current = () => pending;
+    const first = run(phase === 'busy' ? ['s1'] : ['editor:e']);
+    assert.equal(ctx.closeTabsInFlightRef.current, true);
+    assert.equal(await run(['s2', 'plugin']), false);
+    assert.deepEqual(closed, []);
+    release(false);
+    await first;
+    assert.equal(ctx.closeTabsInFlightRef.current, false);
+  });
+}
+
+test('failed prompt releases guard so next batch can run', async () => {
+  const { ctx, run } = setup();
+  ctx.handleRequestCloseEditorTabRef.current = async () => { throw new Error('save failed'); };
+  await assert.rejects(run(['editor:e']), /save failed/);
+  assert.equal(ctx.closeTabsInFlightRef.current, false);
+  assert.equal(await run(['s1']), true);
 });
@@ -9,8 +9,11 @@ import { sanitizeHostIconFields } from '../../domain/hostIcon';
 import { resolveEffectiveTerminalProtocol } from '../../domain/terminalProtocol';
 import { getTerminalPassthroughActions } from '../state/useGlobalHotkeys';
 import { tabShortcutDigitFromEvent } from '../../domain/models/keyBindings';
+import { isPortForwardingAutoReconnectEnabled } from '../../domain/portForwardingReconnect';
 import { buildNumberShortcutTabTargets } from './tabShortcutTargets';
 import { captureInheritedCwd } from '../state/inheritedCwd';
+import { fromEditorTabId, isEditorTabId } from '../state/activeTabStore';
+import { resolveBatchTabCloseFocus } from '../state/pluginViewTabStore';

 type AppContextGetter = () => Record<string, any>;
 const TERMINAL_PASSTHROUGH_ACTIONS = getTerminalPassthroughActions();
@@ -151,7 +154,7 @@ export function handleTrayTogglePortForwardImpl(getCtx: AppContextGetter, ruleId
        const effectiveHost = resolveEffectiveHost(host);
        void startTunnel(rule, effectiveHost, hosts.map(resolveEffectiveHost), keys, identities, (status, error) => {
          if (status === "error" && error) toast.error(error);
-        }, rule.autoStart, terminalSettings, knownHosts);
+        }, isPortForwardingAutoReconnectEnabled(rule), terminalSettings, knownHosts);
      }
      return;
    }
@@ -677,48 +680,86 @@ export async function confirmIfBusyLocalTerminalImpl(getCtx: AppContextGetter, s
    }
 }

-export async function closeTabsBatchImpl(getCtx: AppContextGetter, targetIds: string[]) {
-  const { closeLogView, closeSessions, closeTabsInFlightRef, closeWorkspace, confirmIfBusyLocalTerminal, logViews, sessions, workspaces } = getCtx();
-{
-      if (targetIds.length === 0) return true;
-      if (closeTabsInFlightRef.current) return false;
-
-      // Expand workspace ids into their constituent session ids so the busy
-      // probe sees every local shell that's about to be killed.
-      const sessionIdsToProbe: string[] = [];
-      for (const tabId of targetIds) {
-        const ws = workspaces.find((w) => w.id === tabId);
-        if (ws) {
-          for (const s of sessions) {
-            if (s.workspaceId === tabId) sessionIdsToProbe.push(s.id);
-          }
-        } else if (sessions.find((s) => s.id === tabId)) {
-          sessionIdsToProbe.push(tabId);
-        }
-      }
-
-      closeTabsInFlightRef.current = true;
-      try {
-        const ok = await confirmIfBusyLocalTerminal(sessionIdsToProbe);
-        if (!ok) return false;
-        const standaloneSessionIds = targetIds.filter((tabId) => (
-          sessions.some((session) => session.id === tabId)
-        ));
-        if (standaloneSessionIds.length > 0) {
-          closeSessions(standaloneSessionIds);
-        }
-        for (const tabId of targetIds) {
-          if (workspaces.find((w) => w.id === tabId)) {
-            closeWorkspace(tabId);
-          } else if (logViews.find((lv) => lv.id === tabId)) {
-            closeLogView(tabId);
-          }
-        }
-        return true;
-      } finally {
-        closeTabsInFlightRef.current = false;
+/**
+ * Expand batch-close target ids into the terminal session ids whose local
+ * shells the busy probe must inspect: workspace ids contribute every session
+ * they contain; standalone session ids pass through.
+ */
+export function collectBatchBusyProbeSessionIds(
+  sessions: readonly { id: string; workspaceId?: string | null }[],
+  workspaces: readonly { id: string }[],
+  targetIds: readonly string[],
+): string[] {
+  const sessionIdsToProbe: string[] = [];
+  for (const tabId of targetIds) {
+    const ws = workspaces.find((w) => w.id === tabId);
+    if (ws) {
+      for (const s of sessions) {
+        if (s.workspaceId === tabId) sessionIdsToProbe.push(s.id);
      }
+    } else if (sessions.find((s) => s.id === tabId)) {
+      sessionIdsToProbe.push(tabId);
    }
+  }
+  return sessionIdsToProbe;
+}
+
+export async function closeTabsBatchImpl(getCtx: AppContextGetter, targetIds: string[]) {
+  const {
+    closeLogView, closeSessions, closeTabsInFlightRef, closeWorkspace,
+    confirmIfBusyLocalTerminal, logViews, sessions, workspaces,
+    activeTabStore, editorTabStore, pluginViewTabStore,
+    handleRequestCloseEditorTabRef, findEditorSftpOwnerTabId, orderedTabsWithEditors,
+  } = getCtx();
+  if (targetIds.length === 0) return true;
+  if (closeTabsInFlightRef.current) return false;
+  closeTabsInFlightRef.current = true;
+  try {
+    const activeBeforeClose = activeTabStore.getActiveTabId();
+    const pluginIds = targetIds.filter((id) => pluginViewTabStore.getTab(id));
+    const editorIds = targetIds.filter(isEditorTabId);
+    const regularIds = targetIds.filter((id) => !pluginViewTabStore.getTab(id) && !isEditorTabId(id));
+    // Cancel busy-terminal confirmation before making any changes, including editors.
+    if (regularIds.length && !await confirmIfBusyLocalTerminal(
+      collectBatchBusyProbeSessionIds(sessions, workspaces, regularIds),
+    )) return false;
+
+    const closedEditorIds: string[] = [];
+    for (const id of editorIds) {
+      if (await handleRequestCloseEditorTabRef.current(fromEditorTabId(id))) closedEditorIds.push(id);
+    }
+
+    // Owners must remain mounted while any editor survives (cancelled or outside
+    // the range), because unmounting their SFTP panel discards its editors.
+    const keepTabIds = new Set<string>();
+    for (const editor of editorTabStore.getTabs()) {
+      const owner = findEditorSftpOwnerTabId(editor.sessionId, editor.sftpTabId);
+      if (owner) keepTabIds.add(owner);
+    }
+    const effectiveRegularIds = regularIds.filter((id) => !keepTabIds.has(id) && !(
+      workspaces.some((workspace) => workspace.id === id) &&
+      sessions.some((session) => session.workspaceId === id && keepTabIds.has(session.id))
+    ));
+    const standaloneSessionIds = effectiveRegularIds.filter((id) => sessions.some((session) => session.id === id));
+    if (standaloneSessionIds.length) closeSessions(standaloneSessionIds);
+    for (const id of effectiveRegularIds) {
+      if (workspaces.some((workspace) => workspace.id === id)) closeWorkspace(id);
+      else if (logViews.some((logView) => logView.id === id)) closeLogView(id);
+    }
+    for (const id of pluginIds) pluginViewTabStore.close(id);
+
+    const closingTabIds = new Set([...effectiveRegularIds, ...closedEditorIds, ...pluginIds]);
+    if (closingTabIds.has(activeBeforeClose)) {
+      activeTabStore.setActiveTabId(resolveBatchTabCloseFocus({
+        orderedTabIds: orderedTabsWithEditors,
+        closingTabIds,
+        activeTabId: activeBeforeClose,
+      }));
+    }
+    return true;
+  } finally {
+    closeTabsInFlightRef.current = false;
+  }
 }

 export function executeHotkeyActionImpl(getCtx: AppContextGetter, action: string, e: KeyboardEvent) {
@@ -0,0 +1,28 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import test from 'node:test';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const appSideEffectsSource = readFileSync(join(here, 'AppSideEffects.tsx'), 'utf8');
+
+test('terminal keyboard focus tracking is always published to the main process', () => {
+  assert.match(
+    appSideEffectsSource,
+    /useTerminalKeyboardFocus\(\s*\)/,
+    'the terminal keyboard focus signal must be unconditional',
+  );
+});
+
+test('terminal keyboard focus is not gated on hotkey scheme or font zoom settings', () => {
+  // When the signal is turned off, the main process falls back to window zoom
+  // for Ctrl+= / Ctrl+- / Ctrl+0 while the user is typing in a terminal, so
+  // "disable terminal zoom" and per-binding overrides stop having any effect
+  // on those chords (#3327).
+  assert.doesNotMatch(appSideEffectsSource, /useTerminalKeyboardFocus\(\s*hotkeyScheme/);
+  assert.doesNotMatch(
+    appSideEffectsSource,
+    /useTerminalKeyboardFocus\(\s*[^)\s][^)]*disableTerminalFontZoom/,
+  );
+});
@@ -21,11 +21,11 @@ import { getNotesSnapshot } from '../state/notesStore';
 import { useVaultAgentBridge } from '../state/useVaultAgentBridge';
 import { useWindowControls } from '../state/useWindowControls';
 import { useTerminalKeyboardFocus } from '../state/useTerminalKeyboardFocus';
-import { useEditorTabChromeList } from '../state/editorTabStore';
+import { editorTabStore, useEditorTabChromeList } from '../state/editorTabStore';
+import { findEditorSftpOwnerTabId } from '../state/editorSftpOwnerRegistry';
 import {
  isPluginViewTabId,
  pluginViewTabStore,
-  resolveBatchTabCloseFocus,
  usePluginViewTabs,
 } from '../state/pluginViewTabStore';
 import {
@@ -139,14 +139,17 @@ export function AppSideEffects() {
    terminalSettings,
    hotkeyScheme,
    keyBindings,
-    disableTerminalFontZoom,
    isHotkeyRecording,
    showSftpTab,
    shellOnlyTabNumberShortcuts,
    workspaceFocusStyle,
  } = settings;

-  useTerminalKeyboardFocus(hotkeyScheme !== 'disabled' && !disableTerminalFontZoom);
+  // Always publish terminal keyboard focus to the main process. When font zoom
+  // is disabled (or hotkeys are off) the renderer ignores the font chords, so
+  // the main process must keep handing them to the page instead of falling
+  // back to window zoom while the user is typing in a terminal (#3327).
+  useTerminalKeyboardFocus();

  const discoveredShells = useDiscoveredShells();

@@ -1010,27 +1013,18 @@ export function AppSideEffects() {
  }, [orderedTabsWithEditors]);

  // Close many tabs at once with a single batched busy-shell confirmation.
-  // Used by the "Close all / Close others / Close to the right" context-menu
-  // actions on tabs (#748).
+  // Used by the "Close all / Close others / Close to the left / Close to the
+  // right" context-menu actions on tabs (#748).
  const closeTabsBatch = useCallback(
-    async (targetIds: string[]) => {
-      const closingTabIds = new Set(targetIds);
-      const activeBeforeClose = activeTabStore.getActiveTabId();
-      const focusAfterClose = resolveBatchTabCloseFocus({
-        orderedTabIds: orderedTabsWithEditors,
-        closingTabIds,
-        activeTabId: activeBeforeClose,
-      });
-      const pluginIds = targetIds.filter((id) => pluginViewTabStore.getTab(id));
-      const regularIds = targetIds.filter((id) => !pluginViewTabStore.getTab(id));
-      const canClose = !regularIds.length || await closeTabsBatchImpl(
-        () => ({ closeLogView, closeSessions, closeTabsInFlightRef, closeWorkspace, confirmIfBusyLocalTerminal, logViews, sessions, targetIds: regularIds, workspaces }),
-        regularIds,
-      );
-      if (!canClose) return;
-      for (const id of pluginIds) pluginViewTabStore.close(id);
-      if (closingTabIds.has(activeBeforeClose)) activeTabStore.setActiveTabId(focusAfterClose);
-    },
+    (targetIds: string[]) => closeTabsBatchImpl(
+      () => ({
+        closeLogView, closeSessions, closeTabsInFlightRef, closeWorkspace,
+        confirmIfBusyLocalTerminal, logViews, sessions, workspaces,
+        activeTabStore, editorTabStore, pluginViewTabStore,
+        handleRequestCloseEditorTabRef, findEditorSftpOwnerTabId, orderedTabsWithEditors,
+      }),
+      targetIds,
+    ),
    [workspaces, sessions, logViews, confirmIfBusyLocalTerminal, closeWorkspace, closeSessions, closeLogView, orderedTabsWithEditors],
  );

@@ -77,7 +77,7 @@ export const enCoreMessages: Messages = {
  'field.selectHosts': 'Select Hosts',
  'placeholder.workspaceName': 'Workspace name',
  'placeholder.sessionName': 'Session name',
-  'placeholder.searchHosts': 'Search hosts...',
+  'placeholder.searchHosts': 'Search hosts or tags...',
  'toast.settingsUnavailable': 'Settings window is unavailable on this platform.',
  'credentials.protectionUnavailable.title': 'Credential Protection Unavailable',
  'credentials.protectionUnavailable.message': 'Saved passwords and keys cannot be auto-decrypted on this device. Re-enter credentials before connecting.',
@@ -251,6 +251,7 @@ export const enTerminalMessages: Messages = {
  'terminal.customTheme.group.bright': 'Bright Colors',
  'terminal.customTheme.color.background': 'Background',
  'terminal.customTheme.color.foreground': 'Foreground',
+  'terminal.customTheme.color.foregroundIntense': 'Intense foreground (bold)',
  'terminal.customTheme.color.cursor': 'Cursor',
  'terminal.customTheme.color.selection': 'Selection',
  'terminal.customTheme.color.black': 'Black',
@@ -637,6 +638,7 @@ export const enTerminalMessages: Messages = {
  'tabs.copyTabToNewWindow': 'Copy Tab to New Window',
  'tabs.copyTabToNewWindowFailed': 'Failed to open tab in a new window',
  'tabs.closeOthers': 'Close Others',
+  'tabs.closeToLeft': 'Close Tabs to the Left',
  'tabs.closeToRight': 'Close Tabs to the Right',
  'tabs.closeAll': 'Close All',
  'keychain.edit.labelRequired': 'Label *',
@@ -807,6 +809,9 @@ export const enTerminalMessages: Messages = {
  'serial.field.lineModeDesc': 'Buffer input and send on Enter (instead of character-by-character)',
  'serial.field.backspaceBehavior': 'Backspace key',
  'serial.field.backspaceBehaviorDesc': 'Use Ctrl+H for network devices that do not respond to the default Backspace code.',
+  'serial.encoding.pendingInput': 'Submit or clear the current input before changing the encoding.',
+  'serial.field.byteOrientedBackspace': 'Byte-Oriented Backspace',
+  'serial.field.byteOrientedBackspaceDesc': 'Send one DEL per byte so the device deletes a whole multi-byte character (for devices that delete bytes). Disable for character-aware line editors (e.g. Linux readline).',
  'serial.backspace.default': 'Default (DEL, 0x7F)',
  'serial.backspace.ctrlH': 'Ctrl+H (BS, 0x08)',
  'serial.field.charset': 'Charset',
@@ -116,6 +116,11 @@ export const enVaultMessages: Messages = {
  'vault.import.securecrt.folderDesc': 'Import every session and keep the folder structure.',
  'vault.import.securecrt.file': 'Single session file',
  'vault.import.securecrt.fileDesc': 'Import one SecureCRT .ini session.',
+  'vault.import.finalshell.promptTitle': 'Import from FinalShell',
+  'vault.import.finalshell.folder': 'conn folder',
+  'vault.import.finalshell.folderDesc': 'Import every JSON connection and keep the folder structure.',
+  'vault.import.finalshell.file': 'Single connection file',
+  'vault.import.finalshell.fileDesc': 'Import one FinalShell JSON connection.',
  'vault.import.csv.tip': 'Bulk import: use the CSV template.',
  'vault.import.csv.downloadTemplate': 'Download CSV template',
  'vault.import.toast.start': 'Importing from {format}...',
@@ -261,6 +266,8 @@ export const enVaultMessages: Messages = {
  'pf.deleteActive.confirm': 'Stop and Delete',
  'pf.form.autoStart': 'Auto Start',
  'pf.form.autoStartDesc': 'Automatically start this rule when the app launches',
+  'pf.form.autoReconnect': 'Auto Reconnect',
+  'pf.form.autoReconnectDesc': 'Automatically reconnect when the connection drops',

  // SFTP
  'sftp.newFolder': 'New Folder',
@@ -77,7 +77,7 @@ export const esCoreMessages: Messages = {
  'field.selectHosts': 'Seleccionar hosts',
  'placeholder.workspaceName': 'Nombre del espacio de trabajo',
  'placeholder.sessionName': 'Nombre de la sesión',
-  'placeholder.searchHosts': 'Buscar hosts...',
+  'placeholder.searchHosts': 'Buscar hosts o etiquetas...',
  'toast.settingsUnavailable': 'La ventana de configuración no está disponible en esta plataforma.',
  'credentials.protectionUnavailable.title': 'Protección de credenciales no disponible',
  'credentials.protectionUnavailable.message': 'Las contraseñas y claves guardadas no se pueden descifrar automáticamente en este dispositivo. Vuelve a ingresar las credenciales antes de conectarte.',
@@ -251,6 +251,7 @@ export const esTerminalMessages: Messages = {
  'terminal.customTheme.group.bright': 'Colores brillantes',
  'terminal.customTheme.color.background': 'Fondo',
  'terminal.customTheme.color.foreground': 'Primer plano',
+  'terminal.customTheme.color.foregroundIntense': 'Primer plano intenso (negrita)',
  'terminal.customTheme.color.cursor': 'Cursor',
  'terminal.customTheme.color.selection': 'Selección',
  'terminal.customTheme.color.black': 'Negro',
@@ -637,6 +638,7 @@ export const esTerminalMessages: Messages = {
  'tabs.copyTabToNewWindow': 'Copiar pestaña a una nueva ventana',
  'tabs.copyTabToNewWindowFailed': 'No se pudo abrir la pestaña en una nueva ventana',
  'tabs.closeOthers': 'Cerrar las demás',
+  'tabs.closeToLeft': 'Cerrar pestañas a la izquierda',
  'tabs.closeToRight': 'Cerrar pestañas a la derecha',
  'tabs.closeAll': 'Cerrar todas',
  'keychain.edit.labelRequired': 'Etiqueta *',
@@ -807,6 +809,9 @@ export const esTerminalMessages: Messages = {
  'serial.field.lineModeDesc': 'Almacenar en búfer la entrada y enviarla al presionar Enter (en lugar de carácter por carácter)',
  'serial.field.backspaceBehavior': 'Tecla de retroceso',
  'serial.field.backspaceBehaviorDesc': 'Usa Ctrl+H para dispositivos de red que no responden al código de Retroceso predeterminado.',
+  'serial.encoding.pendingInput': 'Envía o borra la entrada actual antes de cambiar la codificación.',
+  'serial.field.byteOrientedBackspace': 'Retroceso orientado a bytes',
+  'serial.field.byteOrientedBackspaceDesc': 'Envía un DEL por byte para que el dispositivo elimine un carácter multibyte completo (para dispositivos que eliminan por bytes). Desactívelo para editores de línea conscientes de caracteres (p. ej. readline de Linux).',
  'serial.backspace.default': 'Predeterminado (DEL, 0x7F)',
  'serial.backspace.ctrlH': 'Ctrl+H (BS, 0x08)',
  'serial.field.charset': 'Codificación de caracteres',
@@ -116,6 +116,11 @@ export const esVaultMessages: Messages = {
  'vault.import.securecrt.folderDesc': 'Importa todas las sesiones y conserva la estructura de carpetas.',
  'vault.import.securecrt.file': 'Archivo de sesión único',
  'vault.import.securecrt.fileDesc': 'Importa una sesión .ini de SecureCRT.',
+  'vault.import.finalshell.promptTitle': 'Importar desde FinalShell',
+  'vault.import.finalshell.folder': 'Carpeta conn',
+  'vault.import.finalshell.folderDesc': 'Importa todas las conexiones JSON y conserva la estructura de carpetas.',
+  'vault.import.finalshell.file': 'Archivo de conexión único',
+  'vault.import.finalshell.fileDesc': 'Importa una conexión JSON de FinalShell.',
  'vault.import.csv.tip': 'Importación masiva: usa la plantilla CSV.',
  'vault.import.csv.downloadTemplate': 'Descargar plantilla CSV',
  'vault.import.toast.start': 'Importando desde {format}...',
@@ -261,6 +266,8 @@ export const esVaultMessages: Messages = {
  'pf.deleteActive.confirm': 'Detener y eliminar',
  'pf.form.autoStart': 'Inicio automático',
  'pf.form.autoStartDesc': 'Inicia automáticamente esta regla cuando se abra la aplicación',
+  'pf.form.autoReconnect': 'Reconexión automática',
+  'pf.form.autoReconnectDesc': 'Vuelve a conectar automáticamente si se pierde la conexión',

  // SFTP
  'sftp.newFolder': 'Nueva carpeta',
@@ -76,7 +76,7 @@ export const ruCoreMessages: Messages = {
  'field.selectHosts': 'Выбрать хосты',
  'placeholder.workspaceName': 'Имя рабочего пространства',
  'placeholder.sessionName': 'Имя сессии',
-  'placeholder.searchHosts': 'Поиск хостов...',
+  'placeholder.searchHosts': 'Поиск хостов или тегов...',
  'toast.settingsUnavailable': 'Окно настроек недоступно на этой платформе.',
  'credentials.protectionUnavailable.title': 'Защита учётных данных недоступна',
  'credentials.protectionUnavailable.message': 'Сохранённые пароли и ключи не могут быть автоматически расшифрованы на этом устройстве. Перед подключением введите учётные данные заново.',
@@ -269,6 +269,7 @@ export const ruTerminalMessages: Messages = {
  'terminal.customTheme.group.bright': 'Яркие цвета',
  'terminal.customTheme.color.background': 'Фон',
  'terminal.customTheme.color.foreground': 'Текст',
+  'terminal.customTheme.color.foregroundIntense': 'Яркий текст (жирный)',
  'terminal.customTheme.color.cursor': 'Курсор',
  'terminal.customTheme.color.selection': 'Выделение',
  'terminal.customTheme.color.black': 'Чёрный',
@@ -652,6 +653,7 @@ export const ruTerminalMessages: Messages = {
  'tabs.copyTabToNewWindow': 'Копировать вкладку в новое окно',
  'tabs.copyTabToNewWindowFailed': 'Не удалось открыть вкладку в новом окне',
  'tabs.closeOthers': 'Закрыть остальные',
+  'tabs.closeToLeft': 'Закрыть вкладки слева',
  'tabs.closeToRight': 'Закрыть вкладки справа',
  'tabs.closeAll': 'Закрыть все',
  'keychain.edit.labelRequired': 'Метка *',
@@ -814,6 +816,9 @@ export const ruTerminalMessages: Messages = {
  'serial.field.lineModeDesc': 'Буферизовать ввод и отправлять по Enter (вместо посимвольной отправки)',
  'serial.field.backspaceBehavior': 'Клавиша Backspace',
  'serial.field.backspaceBehaviorDesc': 'Используйте Ctrl+H для сетевых устройств, которые не реагируют на код Backspace по умолчанию.',
+  'serial.encoding.pendingInput': 'Отправьте или очистите текущий ввод перед сменой кодировки.',
+  'serial.field.byteOrientedBackspace': 'Побайтовый Backspace',
+  'serial.field.byteOrientedBackspaceDesc': 'Отправляет по одному DEL на байт, чтобы устройство удалило весь многобайтовый символ (для устройств, удаляющих побайтово). Отключите для редакторов, удаляющих посимвольно (например, readline в Linux).',
  'serial.backspace.default': 'По умолчанию (DEL, 0x7F)',
  'serial.backspace.ctrlH': 'Ctrl+H (BS, 0x08)',
  'serial.field.charset': 'Кодировка',
@@ -154,6 +154,11 @@ export const ruVaultMessages: Messages = {
  'vault.import.securecrt.folderDesc': 'Импортировать все сеансы с сохранением структуры папок.',
  'vault.import.securecrt.file': 'Один файл сеанса',
  'vault.import.securecrt.fileDesc': 'Импортировать один файл сеанса SecureCRT .ini.',
+  'vault.import.finalshell.promptTitle': 'Импорт из FinalShell',
+  'vault.import.finalshell.folder': 'Папка conn',
+  'vault.import.finalshell.folderDesc': 'Импортировать все JSON-подключения с сохранением структуры папок.',
+  'vault.import.finalshell.file': 'Один файл подключения',
+  'vault.import.finalshell.fileDesc': 'Импортировать одно JSON-подключение FinalShell.',
  'vault.import.csv.tip': 'Массовый импорт: используйте шаблон CSV.',
  'vault.import.csv.downloadTemplate': 'Скачать шаблон CSV',
  'vault.import.toast.start': 'Импорт из {format}...',
@@ -299,6 +304,8 @@ export const ruVaultMessages: Messages = {
  'pf.deleteActive.confirm': 'Остановить и удалить',
  'pf.form.autoStart': 'Автозапуск',
  'pf.form.autoStartDesc': 'Автоматически запускать это правило при запуске приложения',
+  'pf.form.autoReconnect': 'Автопереподключение',
+  'pf.form.autoReconnectDesc': 'Автоматически восстанавливать соединение при обрыве',

  // SFTP
  'sftp.newFolder': 'Новая папка',
@@ -61,6 +61,7 @@ export const zhCNCoreMessages: Messages = {
  'field.name': '名称',
  'placeholder.workspaceName': '工作区名称',
  'placeholder.sessionName': '会话名称',
+  'placeholder.searchHosts': '搜索主机或标签...',
  'toast.settingsUnavailable': '当前平台无法打开设置窗口。',
  'credentials.protectionUnavailable.title': '凭据保护不可用',
  'credentials.protectionUnavailable.message': '当前设备无法自动解密已保存的密码和密钥。连接前请重新输入凭据。',
@@ -781,6 +782,11 @@ export const zhCNCoreMessages: Messages = {
  'vault.import.securecrt.folderDesc': '一次导入全部会话，并保留目录结构。',
  'vault.import.securecrt.file': '单个会话文件',
  'vault.import.securecrt.fileDesc': '导入一个 SecureCRT .ini 会话。',
+  'vault.import.finalshell.promptTitle': '从 FinalShell 导入',
+  'vault.import.finalshell.folder': 'conn 文件夹',
+  'vault.import.finalshell.folderDesc': '导入全部 JSON 连接，并保留目录结构。',
+  'vault.import.finalshell.file': '单个连接文件',
+  'vault.import.finalshell.fileDesc': '导入一个 FinalShell JSON 连接。',
  'vault.import.csv.tip': '批量导入：可使用 CSV 模板填写后导入。',
  'vault.import.csv.downloadTemplate': '下载 CSV 模板',
  'vault.import.toast.start': '正在从 {format} 导入...',
@@ -722,6 +722,7 @@ export const zhCNTerminalMessages: Messages = {
  'tabs.copyTabToNewWindow': '复制标签页到新窗口',
  'tabs.copyTabToNewWindowFailed': '无法在新窗口打开标签页',
  'tabs.closeOthers': '关闭其他标签',
+  'tabs.closeToLeft': '关闭左侧标签',
  'tabs.closeToRight': '关闭右侧标签',
  'tabs.closeAll': '关闭所有标签',
  'keychain.edit.labelRequired': 'Label *',
@@ -892,6 +893,9 @@ export const zhCNTerminalMessages: Messages = {
  'serial.field.lineModeDesc': '缓冲输入，按回车后发送（而不是逐字符发送）',
  'serial.field.backspaceBehavior': '回退键',
  'serial.field.backspaceBehaviorDesc': '如果网络设备不响应默认回退键，请改用 Ctrl+H。',
+  'serial.encoding.pendingInput': '请先提交或清空当前输入，再切换编码。',
+  'serial.field.byteOrientedBackspace': '按字节退格',
+  'serial.field.byteOrientedBackspaceDesc': '发送与字符字节数相同的 DEL，使设备删除整个多字节字符（适用于按字节删除的设备）。若为逐字符删除的行编辑器（如 Linux readline），请关闭。',
  'serial.backspace.default': '默认（DEL，0x7F）',
  'serial.backspace.ctrlH': 'Ctrl+H（BS，0x08）',
  'serial.field.charset': '字符编码',
@@ -644,6 +644,7 @@ export const zhCNVaultMessages: Messages = {
  'terminal.customTheme.group.bright': '高亮色',
  'terminal.customTheme.color.background': '背景',
  'terminal.customTheme.color.foreground': '前景',
+  'terminal.customTheme.color.foregroundIntense': '高亮前景（粗体）',
  'terminal.customTheme.color.cursor': '光标',
  'terminal.customTheme.color.selection': '选区',
  'terminal.customTheme.color.black': '黑色',
@@ -979,6 +980,8 @@ export const zhCNVaultMessages: Messages = {
  'pf.deleteActive.confirm': '关闭并删除',
  'pf.form.autoStart': '自动启动',
  'pf.form.autoStartDesc': '应用启动时自动开启此规则',
+  'pf.form.autoReconnect': '自动重连',
+  'pf.form.autoReconnectDesc': '连接断开后自动尝试重新连接',

  // SFTP (pane + conflict)
  'sftp.pane.local': '本地',
@@ -63,7 +63,7 @@ export const zhTWCoreMessages: Messages = {
  'field.selectHosts': '選擇主機',
  'placeholder.workspaceName': '工作區名稱',
  'placeholder.sessionName': '工作階段名稱',
-  'placeholder.searchHosts': '搜尋主機...',
+  'placeholder.searchHosts': '搜尋主機或標籤...',
  'toast.settingsUnavailable': '目前平台無法開啟設定視窗。',
  'credentials.protectionUnavailable.title': '憑證保護不可用',
  'credentials.protectionUnavailable.message': '目前裝置無法自動解密已儲存的密碼和金鑰。連線前請重新輸入憑證。',
@@ -784,6 +784,11 @@ export const zhTWCoreMessages: Messages = {
  'vault.import.securecrt.folderDesc': '一次匯入全部工作階段，並保留目錄結構。',
  'vault.import.securecrt.file': '單一工作階段檔案',
  'vault.import.securecrt.fileDesc': '匯入一個 SecureCRT .ini 工作階段。',
+  'vault.import.finalshell.promptTitle': '從 FinalShell 匯入',
+  'vault.import.finalshell.folder': 'conn 資料夾',
+  'vault.import.finalshell.folderDesc': '匯入全部 JSON 連線，並保留目錄結構。',
+  'vault.import.finalshell.file': '單一連線檔案',
+  'vault.import.finalshell.fileDesc': '匯入一個 FinalShell JSON 連線。',
  'vault.import.csv.tip': '批次匯入：可使用 CSV 模板填寫後匯入。',
  'vault.import.csv.downloadTemplate': '下載 CSV 模板',
  'vault.import.toast.start': '正在從 {format} 匯入...',
@@ -722,6 +722,7 @@ export const zhTWTerminalMessages: Messages = {
  'tabs.copyTabToNewWindow': '複製分頁到新視窗',
  'tabs.copyTabToNewWindowFailed': '無法在新視窗開啟分頁',
  'tabs.closeOthers': '關閉其他分頁',
+  'tabs.closeToLeft': '關閉左側分頁',
  'tabs.closeToRight': '關閉右側分頁',
  'tabs.closeAll': '關閉所有分頁',
  'keychain.edit.labelRequired': 'Label *',
@@ -892,6 +893,9 @@ export const zhTWTerminalMessages: Messages = {
  'serial.field.lineModeDesc': '緩衝輸入，按 Enter 鍵後傳送（而不是逐字元傳送）',
  'serial.field.backspaceBehavior': '退格鍵',
  'serial.field.backspaceBehaviorDesc': '如果網路裝置不回應預設退格鍵，請改用 Ctrl+H。',
+  'serial.encoding.pendingInput': '請先提交或清空目前輸入，再切換編碼。',
+  'serial.field.byteOrientedBackspace': '按位元組退格',
+  'serial.field.byteOrientedBackspaceDesc': '傳送與字元位元組數相同的 DEL，使裝置刪除整個多位元組字元（適用於按位元組刪除的裝置）。若為逐字元刪除的行編輯器（如 Linux readline），請關閉。',
  'serial.backspace.default': '預設（DEL，0x7F）',
  'serial.backspace.ctrlH': 'Ctrl+H（BS，0x08）',
  'serial.field.charset': '字元編碼',
@@ -644,6 +644,7 @@ export const zhTWVaultMessages: Messages = {
  'terminal.customTheme.group.bright': '標示色',
  'terminal.customTheme.color.background': '背景',
  'terminal.customTheme.color.foreground': '前景',
+  'terminal.customTheme.color.foregroundIntense': '高亮前景（粗體）',
  'terminal.customTheme.color.cursor': '游標',
  'terminal.customTheme.color.selection': '選區',
  'terminal.customTheme.color.black': '黑色',
@@ -979,6 +980,8 @@ export const zhTWVaultMessages: Messages = {
  'pf.deleteActive.confirm': '關閉並刪除',
  'pf.form.autoStart': '自動啟動',
  'pf.form.autoStartDesc': '應用程式啟動時自動開啟此規則',
+  'pf.form.autoReconnect': '自動重連',
+  'pf.form.autoReconnectDesc': '連線中斷後自動嘗試重新連線',

  // SFTP (pane + conflict)
  'sftp.pane.local': '本機',
@@ -0,0 +1,58 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { findEditorSftpOwnerTabId, registerEditorSftpOwnerResolver } from "./editorSftpOwnerRegistry";
+
+test("resolves the owning tab for a registered SFTP connection id", () => {
+  const unregister = registerEditorSftpOwnerResolver(() => ({
+    connectionIds: ["left-abc", "right-def"],
+    ownerTabId: "session-1",
+  }));
+  try {
+    assert.equal(findEditorSftpOwnerTabId("left-abc"), "session-1");
+    assert.equal(findEditorSftpOwnerTabId("right-def"), "session-1");
+    assert.equal(findEditorSftpOwnerTabId("left-unknown"), null);
+    assert.equal(findEditorSftpOwnerTabId(undefined), null);
+  } finally {
+    unregister();
+  }
+});
+
+test("falls back to the stable pane tab id when the connection id is stale", () => {
+  // Browse reconnects regenerate connection ids; an unsaved editor may still
+  // reference the pre-reconnect id, so owner resolution must also match on the
+  // stable pane tab id.
+  const unregister = registerEditorSftpOwnerResolver(() => ({
+    connectionIds: ["conn_new"],
+    paneTabIds: ["pane_1"],
+    ownerTabId: "session-1",
+  }));
+  try {
+    assert.equal(findEditorSftpOwnerTabId("conn_old", "pane_1"), "session-1");
+    assert.equal(findEditorSftpOwnerTabId(undefined, "pane_1"), "session-1");
+    assert.equal(findEditorSftpOwnerTabId("conn_old", "pane_unknown"), null);
+    assert.equal(findEditorSftpOwnerTabId(undefined, undefined), null);
+  } finally {
+    unregister();
+  }
+});
+
+test("unregistering a resolver stops it from resolving owners", () => {
+  const unregister = registerEditorSftpOwnerResolver(() => ({
+    connectionIds: ["conn-x"],
+    ownerTabId: "tab-x",
+  }));
+  unregister();
+  assert.equal(findEditorSftpOwnerTabId("conn-x"), null);
+});
+
+test("resolvers without an owner tab id never match", () => {
+  const unregister = registerEditorSftpOwnerResolver(() => ({
+    connectionIds: ["conn-y"],
+    ownerTabId: null,
+  }));
+  try {
+    assert.equal(findEditorSftpOwnerTabId("conn-y"), null);
+  } finally {
+    unregister();
+  }
+});
@@ -0,0 +1,55 @@
+/**
+ * Maps live SFTP connection ids to the top-level tab that owns the panel
+ * hosting them (a terminal/workspace tab for SftpSidePanel instances).
+ *
+ * Editor tabs record the SFTP `connection.id` as their `sessionId` — not the
+ * owning terminal session id — so batch-close logic that wants to keep an
+ * editor's owning tab open after a cancelled dirty-save prompt must resolve
+ * the owner through this registry instead of comparing `editorTab.sessionId`
+ * against terminal session ids.
+ *
+ * Each mounted SftpSidePanel registers a resolver that reports the connection
+ * ids it currently owns plus its host tab id; the top-level SftpView either
+ * registers nothing (its owner is not a closable terminal tab) or registers
+ * with a non-terminal owner id that simply never matches.
+ */
+export interface EditorSftpOwnerSnapshot {
+  connectionIds: readonly string[];
+  /**
+   * Stable SFTP pane tab ids (pane.id) hosted by this panel. Unlike connection
+   * ids these survive browse reconnects that regenerate connection ids, so
+   * owner resolution can fall back to them when an editor still references a
+   * pre-reconnect connection id.
+   */
+  paneTabIds?: readonly string[];
+  ownerTabId: string | null;
+}
+
+type EditorSftpOwnerResolver = () => EditorSftpOwnerSnapshot;
+
+const resolvers = new Set<EditorSftpOwnerResolver>();
+
+export const registerEditorSftpOwnerResolver = (resolver: EditorSftpOwnerResolver): (() => void) => {
+  resolvers.add(resolver);
+  return () => {
+    resolvers.delete(resolver);
+  };
+};
+
+export const findEditorSftpOwnerTabId = (
+  connectionId: string | undefined,
+  paneTabId?: string,
+): string | null => {
+  if (!connectionId && !paneTabId) return null;
+  for (const resolve of resolvers) {
+    const snapshot = resolve();
+    if (!snapshot.ownerTabId) continue;
+    if (connectionId && snapshot.connectionIds.includes(connectionId)) {
+      return snapshot.ownerTabId;
+    }
+    if (paneTabId && snapshot.paneTabIds?.includes(paneTabId)) {
+      return snapshot.ownerTabId;
+    }
+  }
+  return null;
+};
@@ -101,6 +101,28 @@ test("workspace host factory creates a complete serial session", () => {
  });
 });

+test("serial session factories preserve byteOrientedBackspace", () => {
+  const quickSession = createSerialTerminalSession("session-q", {
+    path: "COM4",
+    baudRate: 9600,
+    byteOrientedBackspace: false,
+  });
+  const savedHostSession = createHostTerminalSession("session-h", host({
+    protocol: "serial",
+    hostname: "COM3",
+    port: 115200,
+    username: "",
+    serialConfig: {
+      path: "COM3",
+      baudRate: 115200,
+      byteOrientedBackspace: false,
+    },
+  }));
+
+  assert.equal(quickSession.serialConfig?.byteOrientedBackspace, false);
+  assert.equal(savedHostSession.serialConfig?.byteOrientedBackspace, false);
+});
+
 test("workspace append snapshots serial Backspace behavior inherited from a group", () => {
  const savedHost = host({
    protocol: "serial",
@@ -0,0 +1,82 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import React from "react";
+import { act, create, type ReactTestRenderer } from "react-test-renderer";
+import type { SftpFileEntry, TransferTask } from "../../../domain/models";
+import { createSftpDirectoryTraversalBudget } from "../../../domain/sftpDirectoryCheckpoint";
+import { netcattyBridge } from "../../../infrastructure/services/netcattyBridge";
+import { useSftpDirectoryTransferOps } from "./transferDirectoryOps";
+
+const modes = [
+  { name: "ordinary local upload", sourceLocal: true, targetLocal: false, sameConnection: false, bounded: false },
+  { name: "cross-pane local copy", sourceLocal: true, targetLocal: true, sameConnection: false, bounded: false },
+  { name: "same-pane local copy", sourceLocal: true, targetLocal: true, sameConnection: true, bounded: true },
+  { name: "remote download", sourceLocal: false, targetLocal: true, sameConnection: false, bounded: true },
+] as const;
+
+for (const mode of modes) {
+  for (const limit of ["entries", "directories"] as const) {
+    test(`${mode.name} ${mode.bounded ? "enforces" : "does not inherit"} the ${limit} budget`, async () => {
+      const previousGet = netcattyBridge.get;
+      const globals = globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean };
+      const previousAct = globals.IS_REACT_ACT_ENVIRONMENT;
+      globals.IS_REACT_ACT_ENVIRONMENT = true;
+      let renderer: ReactTestRenderer | undefined;
+      let ops!: ReturnType<typeof useSftpDirectoryTransferOps>;
+      const listed: string[] = [];
+      const root: TransferTask = {
+        id: crypto.randomUUID(), fileName: "source", sourcePath: "/source", targetPath: "/target",
+        sourceConnectionId: "source", targetConnectionId: mode.sameConnection ? "source" : "target",
+        direction: mode.sourceLocal ? "upload" : "download", status: "transferring",
+        totalBytes: 0, transferredBytes: 0, speed: 0, startTime: 0, isDirectory: true,
+      };
+      const transfersRef = { current: [root] };
+      const list = async (value: string): Promise<SftpFileEntry[]> => {
+        listed.push(value);
+        return value === "/source" ? ["one", "two"].map(name => ({
+          name, type: "directory", size: 0, sizeFormatted: "0 B", lastModified: 0, lastModifiedFormatted: "",
+        })) : [];
+      };
+      netcattyBridge.get = () => ({
+        mkdirLocal: async () => undefined,
+        mkdirSftp: async () => undefined,
+        realpathSftp: async (_id: string, value: string) => value,
+      } as unknown as NetcattyBridge);
+      function Probe() {
+        ops = useSftpDirectoryTransferOps({
+          ownerId: root.id, cancelledTasksRef: { current: new Set() }, pausedTasksRef: { current: new Set() },
+          waitUntilTransferResumed: async () => undefined, activeChildIdsRef: { current: new Map() },
+          transfersRef,
+          setTransfers: update => { transfersRef.current = typeof update === "function" ? update(transfersRef.current) : update; },
+          listLocalFiles: list, listRemoteFiles: (_id, value) => list(value),
+        });
+        return null;
+      }
+      try {
+        await act(async () => { renderer = create(React.createElement(Probe)); });
+        // Three empty directories exercise real recursion without large fixtures or file streams.
+        const budget = createSftpDirectoryTraversalBudget({
+          maxEntries: limit === "entries" ? 1 : 10,
+          maxDirectories: limit === "directories" ? 1 : 10,
+        });
+        const run = ops.transferDirectory(root, mode.sourceLocal ? null : "remote-source",
+          mode.targetLocal ? null : "remote-target", mode.sourceLocal, mode.targetLocal,
+          "auto", "auto", root.id, false, 0, false, undefined, budget);
+        if (mode.bounded) {
+          await assert.rejects(run, limit === "entries" ? /entry limit exceeded/ : /directory limit exceeded/);
+          assert.deepEqual(listed, ["/source"]);
+        } else {
+          assert.equal(await run, 0);
+          assert.deepEqual(listed, ["/source", "/source/one", "/source/two"]);
+          assert.equal(budget.visitedDirectories, 0);
+          assert.equal(budget.visitedEntries, 0);
+        }
+        assert.equal(budget.activeCanonicalDirectories.size, 0);
+      } finally {
+        await act(async () => { renderer?.unmount(); });
+        netcattyBridge.get = previousGet;
+        globals.IS_REACT_ACT_ENVIRONMENT = previousAct;
+      }
+    });
+  }
+}
@@ -0,0 +1,105 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+import test from "node:test";
+import React from "react";
+import { act, create, type ReactTestRenderer } from "react-test-renderer";
+import { useSftpTransfers } from "./useSftpTransfers";
+import { createEmptyPane } from "./types";
+import { sftpTransferCenterStore } from "../sftpTransferCenterStore";
+
+for (const action of ["merge", "replace", "duplicate"] as const) {
+  test(`same-directory ${action} preserves source links through the real transfer hook`, async () => {
+    const dir = await fs.mkdtemp(path.join(process.cwd(), ".same-directory-copy-"));
+    const ownerId = `self-copy-${action}-${crypto.randomUUID()}`;
+    const previousWindow = globalThis.window;
+    const previousStorage = globalThis.localStorage;
+    const globals = globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean };
+    const previousAct = globals.IS_REACT_ACT_ENVIRONMENT;
+    globals.IS_REACT_ACT_ENVIRONMENT = true;
+    let writes = 0;
+    let listings = 0;
+    let renderer: ReactTestRenderer | undefined;
+    let ops!: ReturnType<typeof useSftpTransfers>;
+    const names = ["one", "two"];
+    for (const name of names) {
+      await fs.mkdir(path.join(dir, name));
+      await fs.writeFile(path.join(dir, name, "file"), "original data");
+      await fs.symlink("file", path.join(dir, name, "link"));
+    }
+    const pane = createEmptyPane("self-copy-pane");
+    pane.connection = { id: ownerId, isLocal: true, currentPath: dir, status: "connected" } as NonNullable<typeof pane.connection>;
+    const statPath = async (value: string) => {
+      const stat = await fs.lstat(value);
+      return { type: stat.isSymbolicLink() ? "symlink" : stat.isDirectory() ? "directory" : "file", size: stat.size, lastModified: stat.mtimeMs };
+    };
+    (globalThis as { window?: unknown }).window = { requestAnimationFrame: (callback: () => void) => setTimeout(callback, 0), cancelAnimationFrame: clearTimeout, netcatty: {
+      realpathLocal: fs.realpath, statLocal: statPath, lstatLocal: statPath,
+      mkdirLocal: async (value: string) => { writes++; await fs.mkdir(value, { recursive: true }); },
+      deleteLocalFile: async (value: string) => { writes++; await fs.rm(value, { recursive: true, force: true }); },
+      renameLocalFile: async (source: string, target: string) => { writes++; await fs.rename(source, target); },
+      startStreamTransfer: async (options: { sourcePath: string; targetPath: string; transferId: string }) => {
+        writes++;
+        await fs.copyFile(options.sourcePath, options.targetPath);
+        sftpTransferCenterStore.ingestBackgroundEvent({ type: "completed", transferId: options.transferId, transferred: 13, totalBytes: 13, lifecycleEpoch: 0 });
+        return {};
+      },
+    } };
+    (globalThis as { localStorage?: unknown }).localStorage = { getItem: () => null, setItem: () => undefined, removeItem: () => undefined };
+    function Probe() {
+      ops = useSftpTransfers({
+        ownerId, getActivePane: () => pane, getPaneByConnectionId: () => pane, getTabByConnectionId: () => ({ side: "left", tabId: pane.id, pane }),
+        updateTab: () => undefined, refresh: async () => undefined,
+        clearCacheForConnection: () => undefined, handleSessionError: () => undefined,
+        sftpSessionsRef: { current: new Map() }, connectionCacheKeyMapRef: { current: new Map() },
+        listRemoteFiles: async () => [],
+        listLocalFiles: async (value: string) => {
+          listings++;
+          return Promise.all((await fs.readdir(value)).map(async name => {
+            const stat = await fs.lstat(path.join(value, name));
+            return { name, type: stat.isSymbolicLink() ? "symlink" as const : "file" as const, size: stat.size, sizeFormatted: "", lastModified: stat.mtimeMs, lastModifiedFormatted: "" };
+          }));
+        },
+      });
+      return null;
+    }
+    try {
+      await act(async () => { renderer = create(React.createElement(Probe)); });
+      await act(async () => { await ops.startTransfer(names.map(name => ({ name, isDirectory: true })), "left", "left"); });
+      assert.equal(ops.conflicts.length, 2, JSON.stringify(sftpTransferCenterStore.getOwnerTasks(ownerId)));
+      const firstId = ops.conflicts[0].transferId;
+      // Apply to all exercises shared batch resolution rather than just one row.
+      await act(async () => { await ops.resolveConflict(firstId, action, true); });
+      await act(async () => {
+        const deadline = Date.now() + 3000;
+        while (Date.now() < deadline) {
+          const rows = sftpTransferCenterStore.getOwnerTasks(ownerId).filter(row => !row.parentTaskId);
+          if (rows.length === 2 && rows.every(row => ["completed", "failed"].includes(row.status))) break;
+          await new Promise(resolve => setTimeout(resolve, 20));
+        }
+      });
+      for (const name of names) {
+        assert.equal(await fs.readlink(path.join(dir, name, "link")), "file");
+        assert.equal(await fs.readFile(path.join(dir, name, "file"), "utf8"), "original data");
+      }
+      const roots = sftpTransferCenterStore.getOwnerTasks(ownerId).filter(row => !row.parentTaskId);
+      assert.equal(roots.length, 2);
+      assert.ok(roots.every(row => row.status === "completed"), JSON.stringify(roots.map(row => ({ status: row.status, error: row.error }))));
+      if (action === "duplicate") {
+        assert.ok(writes > 0);
+        assert.ok(listings > 0);
+        for (const name of names) assert.equal(await fs.readFile(path.join(dir, `${name} (copy)`, "file"), "utf8"), "original data");
+      } else {
+        assert.equal(writes, 0, "self merge/replace must never write or unlink anything");
+        assert.equal(listings, 0, "self merge/replace must not walk the source tree");
+      }
+    } finally {
+      await act(async () => { renderer?.unmount(); });
+      for (const row of sftpTransferCenterStore.getOwnerTasks(ownerId)) sftpTransferCenterStore.dismiss(row.id);
+      (globalThis as { window?: unknown }).window = previousWindow;
+      (globalThis as { localStorage?: unknown }).localStorage = previousStorage;
+      globals.IS_REACT_ACT_ENVIRONMENT = previousAct;
+      await fs.rm(dir, { recursive: true, force: true });
+    }
+  });
+}
@@ -0,0 +1,232 @@
+import { netcattyBridge } from "../../../infrastructure/services/netcattyBridge";
+import {
+  getWindowsUncRoot,
+  isSameSftpPath,
+  isSftpDescendantPath,
+  isWindowsPath,
+  joinPath,
+} from "./utils";
+
+export type SamePanePasteAction = "allow" | "block-same-folder" | "block-into-source";
+
+export interface SamePanePasteFile {
+  name: string;
+  isDirectory: boolean;
+}
+
+/** Filesystem identity of a directory (stat dev/ino). */
+export interface SamePanePasteIdentity {
+  dev: number;
+  ino: number;
+}
+
+/**
+ * Lexically resolve "." / ".." segments and repeated separators so equivalent
+ * spellings of the same directory (e.g. /home/user/., /home//user) compare
+ * equal in the same-pane paste guards. Purely string-level: it never touches
+ * the server, and it is only used to make the guards stricter, never to build
+ * transfer paths.
+ */
+const canonicalizeSftpPath = (path: string): string => {
+  const isWindows = isWindowsPath(path);
+  const separator = isWindows ? "\\" : "/";
+  const unified = isWindows ? path.replace(/\//g, "\\") : path;
+
+  let root = "";
+  let rest = unified;
+  if (isWindows) {
+    const uncRoot = getWindowsUncRoot(unified, { acceptForwardSlashUnc: true });
+    const driveRoot = unified.match(/^[A-Za-z]:\\/)?.[0];
+    if (uncRoot) {
+      root = uncRoot;
+      rest = unified.slice(uncRoot.length);
+    } else if (driveRoot) {
+      root = driveRoot;
+      rest = unified.slice(driveRoot.length);
+    }
+  } else if (unified.startsWith("/")) {
+    // Collapse a leading "//" to "/" for comparisons: on ordinary POSIX
+    // filesystems "//home/user" names the same directory as "/home/user", and
+    // treating it as a distinct root would let a same-pane cut reach the
+    // replace/delete flow. This helper never builds transfer paths, so the
+    // guards stay strict either way.
+    root = "/";
+    rest = unified.replace(/^\/+/, "");
+  }
+
+  const parts: string[] = [];
+  for (const segment of rest.split(separator)) {
+    if (!segment || segment === ".") continue;
+    if (segment === "..") {
+      parts.pop();
+      continue;
+    }
+    parts.push(segment);
+  }
+
+  // UNC roots come back without a trailing separator, so re-insert one before
+  // joining the segments; without it \\server\share\docs would collapse to
+  // \\server\sharedocs and collide with an unrelated share's path.
+  if (root) {
+    return root.endsWith(separator)
+      ? root + parts.join(separator)
+      : root + separator + parts.join(separator);
+  }
+  return parts.join(separator) || ".";
+};
+
+/**
+ * Decide whether an internal SFTP paste that targets the same connection as the
+ * clipboard source can proceed. Copying files into their own source folder is
+ * allowed (the conflict dialog handles same-name collisions), but pasting a
+ * clipboard directory into itself or one of its descendants is blocked for both
+ * copy and cut: the transfer creates the destination before listing the source,
+ * so the fresh copy would be rediscovered and nested until the traversal limit.
+ * For cuts, pasting into the clipboard's source folder is also blocked because
+ * the post-move source delete would remove the freshly moved items. Note that
+ * `sourcePath` is the folder containing every clipboard item, so the per-item
+ * checks must join it with each selected entry's name.
+ *
+ * Lexical canonicalization alone cannot see through symlinks: when the
+ * destination reaches the copied directory through an alias (e.g.
+ * `/a/link -> /a/docs/sub`), a purely string-level comparison would allow the
+ * paste and the recursive transfer would rediscover its own output. When
+ * `resolvePath` is provided (SFTP realpath for remote connections, the local
+ * realpath bridge for local panes), both sides are resolved through the
+ * filesystem before comparing. If that resolution fails, the guard fails
+ * closed and blocks the paste rather than risking a runaway transfer.
+ *
+ * realpath also cannot see through bind mounts: two mount paths for the same
+ * directory resolve to different strings. When `statIdentity` is provided
+ * (local panes only — remote SFTP stats carry no dev/ino), both sides' stat
+ * identities are compared as a final check; equal identities block the paste.
+ * The check only ever blocks on a positive identity match — an unavailable
+ * stat falls through to the symlink guards above rather than blocking
+ * unrelated pastes on transient stat failures.
+ */
+export const resolveSamePanePasteAction = async (params: {
+  operation: "copy" | "cut";
+  sourcePath: string;
+  targetPath: string;
+  files: readonly SamePanePasteFile[];
+  /** Optional filesystem resolver (e.g. realpath). Throws → unresolvable. */
+  resolvePath?: (path: string) => Promise<string>;
+  /** Optional stat identity provider (dev/ino). Returns null → unknown. */
+  statIdentity?: (path: string) => Promise<SamePanePasteIdentity | null>;
+}): Promise<SamePanePasteAction> => {
+  const { resolvePath, statIdentity } = params;
+
+  // Canonicalize first so equivalent spellings of the same directory (dot
+  // segments, repeated separators) are still caught by the guards below, then
+  // resolve through the filesystem when a resolver is available so symlink
+  // aliases compare equal to their real targets. Returns null when resolution
+  // fails, which callers treat as fail-closed.
+  const canonicalizeForComparison = async (path: string): Promise<string | null> => {
+    const lexical = canonicalizeSftpPath(path);
+    if (!resolvePath) return lexical;
+    try {
+      return canonicalizeSftpPath(await resolvePath(path));
+    } catch {
+      return null;
+    }
+  };
+
+  const [targetPath, sourcePath] = await Promise.all([
+    canonicalizeForComparison(params.targetPath),
+    canonicalizeForComparison(params.sourcePath),
+  ]);
+  // A files-only copy has no nesting hazard, so an unresolvable path only
+  // blocks pastes that could actually recurse (directory items, or a cut).
+  const failClosed = !targetPath || !sourcePath;
+  if (failClosed && (params.operation === "cut" || params.files.some((file) => file.isDirectory))) {
+    return "block-into-source";
+  }
+  if (failClosed) return "allow";
+
+  if (params.operation === "cut" && isSameSftpPath(targetPath, sourcePath)) {
+    return "block-same-folder";
+  }
+
+  // Bind-mount alias detection: realpath above maps each mount path to itself,
+  // so a cut (whose post-transfer source delete would destroy the only copy)
+  // must additionally compare filesystem identities. A positive match means
+  // both paths name the same directory. dev/ino are only trusted when at least
+  // one side is non-zero — Windows stats report meaningless 0 identities, and
+  // the local bridge omits them there.
+  const identityOf = async (path: string): Promise<SamePanePasteIdentity | null> => {
+    if (!statIdentity) return null;
+    try {
+      const identity = await statIdentity(path);
+      if (!identity || identity.dev === undefined || identity.ino === undefined) return null;
+      if (identity.dev === 0 && identity.ino === 0) return null;
+      return identity;
+    } catch {
+      return null;
+    }
+  };
+  const sameIdentity = (a: SamePanePasteIdentity, b: SamePanePasteIdentity): boolean =>
+    a.dev === b.dev && a.ino === b.ino;
+
+  if (params.operation === "cut") {
+    const [targetIdentity, sourceIdentity] = await Promise.all([
+      identityOf(params.targetPath),
+      identityOf(params.sourcePath),
+    ]);
+    if (targetIdentity && sourceIdentity && sameIdentity(targetIdentity, sourceIdentity)) {
+      return "block-same-folder";
+    }
+  }
+
+  for (const file of params.files) {
+    if (!file.isDirectory) continue;
+    const itemPath = await canonicalizeForComparison(joinPath(params.sourcePath, file.name));
+    if (!itemPath) return "block-into-source";
+    if (
+      isSameSftpPath(targetPath, itemPath)
+      || isSftpDescendantPath(targetPath, itemPath)
+    ) {
+      return "block-into-source";
+    }
+    // A bind-mount alias of the directory item itself also names the paste
+    // destination, for both copy (recursive rediscovery) and cut (source
+    // delete would remove the freshly pasted entry).
+    if (statIdentity) {
+      const [targetIdentity, itemIdentity] = await Promise.all([
+        identityOf(params.targetPath),
+        identityOf(joinPath(params.sourcePath, file.name)),
+      ]);
+      if (targetIdentity && itemIdentity && sameIdentity(targetIdentity, itemIdentity)) {
+        return "block-into-source";
+      }
+    }
+  }
+  return "allow";
+};
+
+/** Application boundary for filesystem checks used by every internal paste entry. */
+export const resolveSameConnectionPasteAction = async (params: {
+  operation: "copy" | "cut";
+  sourcePath: string;
+  targetPath: string;
+  files: readonly SamePanePasteFile[];
+  isLocal: boolean;
+  sftpId: string | null;
+}): Promise<SamePanePasteAction> => {
+  const bridge = netcattyBridge.get();
+  let resolvePath: ((path: string) => Promise<string>) | undefined;
+  let statIdentity: ((path: string) => Promise<SamePanePasteIdentity | null>) | undefined;
+  if (params.isLocal) {
+    if (bridge?.realpathLocal) resolvePath = (path) => bridge.realpathLocal!(path);
+    if (bridge?.statLocal) {
+      statIdentity = async (path) => {
+        const stat = await bridge.statLocal!(path);
+        if (stat.dev === undefined || stat.ino === undefined) return null;
+        return { dev: stat.dev, ino: stat.ino };
+      };
+    }
+  } else if (params.sftpId && bridge?.realpathSftp) {
+    const sftpId = params.sftpId;
+    resolvePath = (path) => bridge.realpathSftp!(sftpId, path);
+  }
+  return resolveSamePanePasteAction({ ...params, resolvePath, statIdentity });
+};
@@ -0,0 +1,104 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+import test from "node:test";
+import React from "react";
+import { act, create, type ReactTestRenderer } from "react-test-renderer";
+import type { TransferTask } from "../../../domain/models";
+import { netcattyBridge } from "../../../infrastructure/services/netcattyBridge";
+import type { SftpPane } from "./types";
+import { useSftpTransferConflictOps } from "./transferConflictOps";
+
+test("bind-mounted parents cannot cause replacement to delete the source link", async (t) => {
+  const originalGet = netcattyBridge.get;
+  const globals = globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean };
+  const previousAct = globals.IS_REACT_ACT_ENVIRONMENT;
+  globals.IS_REACT_ACT_ENVIRONMENT = true;
+  let renderer: ReactTestRenderer | undefined;
+  let ops!: ReturnType<typeof useSftpTransferConflictOps>;
+  let deletes = 0;
+  t.after(async () => {
+    await act(async () => renderer?.unmount());
+    netcattyBridge.get = originalGet;
+    globals.IS_REACT_ACT_ENVIRONMENT = previousAct;
+  });
+  netcattyBridge.get = () => ({
+    // Bind mounts retain different realpaths but expose the same parent identity.
+    realpathLocal: async (value: string) => value,
+    statLocal: async (value: string) => ({
+      type: "directory", size: 0, lastModified: 0, dev: 42,
+      ino: value === "/a" || value === "/mnt/alias" ? 7 : 8,
+    }),
+    deleteLocalFile: async () => { deletes++; },
+  } as unknown as NetcattyBridge);
+  function Probe() { ops = useSftpTransferConflictOps(); return null; }
+  await act(async () => { renderer = create(React.createElement(Probe)); });
+  const pane = { connection: { id: "local-pane", isLocal: true } } as SftpPane;
+  const task = {
+    sourceConnectionId: "local-pane", targetConnectionId: "local-pane",
+    sourcePath: "/a/link", targetPath: "/mnt/alias/link", fileName: "link", isDirectory: false,
+  } as TransferTask;
+  await assert.rejects(ops.deleteTargetPath(task, pane, null, "auto", "symlink"), /Choose Duplicate or Skip/);
+  assert.equal(deletes, 0);
+  assert.equal(await ops.isSameSourceEntry(task, pane, null, "auto"), true);
+  // Different entries and genuinely different parents must remain replaceable.
+  for (const targetPath of ["/mnt/alias/another-link", "/other/link"]) {
+    const other = { ...task, targetPath };
+    assert.equal(await ops.isSameSourceEntry(other, pane, null, "auto"), false);
+    await ops.deleteTargetPath(other, pane, null, "auto", "symlink");
+  }
+  assert.equal(deletes, 2);
+});
+
+test("same-pane link replacement preserves the source, including aliased parent paths", async (t) => {
+  const dir = await fs.mkdtemp(path.join(process.cwd(), ".pr3318-links-"));
+  const actGlobal = globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean };
+  const previousAct = actGlobal.IS_REACT_ACT_ENVIRONMENT;
+  actGlobal.IS_REACT_ACT_ENVIRONMENT = true;
+  const originalGet = netcattyBridge.get;
+  let renderer: ReactTestRenderer;
+  let ops!: ReturnType<typeof useSftpTransferConflictOps>;
+  let deletes = 0;
+  t.after(async () => {
+    await act(async () => renderer?.unmount());
+    netcattyBridge.get = originalGet;
+    actGlobal.IS_REACT_ACT_ENVIRONMENT = previousAct;
+    await fs.rm(dir, { recursive: true, force: true });
+  });
+  await fs.mkdir(path.join(dir, "source"));
+  await fs.mkdir(path.join(dir, "other"));
+  await fs.writeFile(path.join(dir, "source", "file"), "keep original contents");
+  await fs.symlink("file", path.join(dir, "source", "link"));
+  await fs.symlink("source", path.join(dir, "alias"));
+  netcattyBridge.get = () => ({
+    realpathLocal: fs.realpath,
+    lstatLocal: async (value: string) => {
+      const stat = await fs.lstat(value);
+      return { type: stat.isSymbolicLink() ? "symlink" : "file", size: stat.size, lastModified: stat.mtimeMs };
+    },
+    deleteLocalFile: async (value: string) => { deletes++; await fs.unlink(value); },
+  } as unknown as NetcattyBridge);
+  function Probe() { ops = useSftpTransferConflictOps(); return null; }
+  await act(async () => { renderer = create(React.createElement(Probe)); });
+  const pane = { connection: { id: "local-pane", isLocal: true } } as SftpPane;
+  const task = {
+    sourceConnectionId: "local-pane", targetConnectionId: "local-pane",
+    sourcePath: path.join(dir, "source", "link"),
+    targetPath: path.join(dir, "source", "link"),
+    fileName: "link", isDirectory: false,
+  } as TransferTask;
+  for (const parent of ["source", "alias", "source/."]) {
+    await assert.rejects(ops.deleteTargetPath(
+      { ...task, targetPath: `${dir}/${parent}/link` }, pane, null, "auto", "symlink",
+    ), /Choose Duplicate or Skip/);
+    assert.equal(await fs.readlink(task.sourcePath), "file");
+    assert.equal(await fs.readFile(task.sourcePath, "utf8"), "keep original contents");
+  }
+  assert.equal(deletes, 0);
+  const duplicate = await ops.getDuplicateTarget(task, pane, null, "auto");
+  assert.equal(duplicate.fileName, "link (copy)");
+  await fs.symlink("../source/file", path.join(dir, "other", "link"));
+  await ops.deleteTargetPath({ ...task, targetPath: path.join(dir, "other", "link") }, pane, null, "auto", "symlink");
+  assert.equal(deletes, 1);
+  assert.equal(await fs.readlink(task.sourcePath), "file");
+});
@@ -3,7 +3,7 @@ import type { SftpFilenameEncoding, TransferTask } from "../../../domain/models"
 import { netcattyBridge } from "../../../infrastructure/services/netcattyBridge";
 import { isMissingStatError } from "./errors";
 import type { SftpPane } from "./types";
-import { getParentPath, joinPath } from "./utils";
+import { getFileName, getParentPath, isSameSftpPath, joinPath } from "./utils";

 export function useSftpTransferConflictOps() {
  const splitNameForDuplicate = useCallback((fileName: string, isDirectory: boolean) => {
@@ -84,6 +84,42 @@ export function useSftpTransferConflictOps() {
    [splitNameForDuplicate, statTargetPath],
  );

+  const isSameSourceEntry = useCallback(async (
+    task: TransferTask,
+    targetPane: SftpPane,
+    targetSftpId: string | null,
+    targetEncoding: SftpFilenameEncoding,
+  ): Promise<boolean> => {
+    if (!targetPane.connection || task.sourceConnectionId !== task.targetConnectionId) return false;
+    if (isSameSftpPath(task.sourcePath, task.targetPath)) return true;
+    const bridge = netcattyBridge.get();
+    const resolve = targetPane.connection.isLocal
+      ? bridge?.realpathLocal
+      : targetSftpId && bridge?.realpathSftp
+        ? (value: string) => bridge.realpathSftp!(targetSftpId, value, targetEncoding)
+        : undefined;
+    const [sourceParent, targetParent] = await Promise.all(
+      [getParentPath(task.sourcePath), getParentPath(task.targetPath)].map(
+        (value) => resolve ? resolve(value) : Promise.resolve(value),
+      ),
+    );
+    if (isSameSftpPath(
+      joinPath(sourceParent, getFileName(task.sourcePath)),
+      joinPath(targetParent, getFileName(task.targetPath)),
+    )) return true;
+    // Bind mounts keep distinct realpaths while naming the same directory.
+    // Compare parents so a symlink is identified as an entry, not its referent.
+    if (targetPane.connection.isLocal && bridge?.statLocal
+      && getFileName(task.sourcePath) === getFileName(task.targetPath)) {
+      const [sourceStat, targetStat] = await Promise.all([
+        bridge.statLocal(sourceParent), bridge.statLocal(targetParent),
+      ]);
+      return sourceStat.dev !== undefined && sourceStat.ino !== undefined
+        && sourceStat.dev === targetStat.dev && sourceStat.ino === targetStat.ino;
+    }
+    return false;
+  }, []);
+
  const deleteTargetPath = useCallback(
    async (
      task: TransferTask,
@@ -93,6 +129,11 @@ export function useSftpTransferConflictOps() {
      expectedType?: "file" | "directory" | "symlink",
    ) => {
      if (!targetPane.connection) return;
+      // Replace unlinks symlinks before copying. Never unlink the source entry
+      // when a clipboard copy is pasted back into its own directory.
+      if (expectedType === "symlink" && await isSameSourceEntry(task, targetPane, targetSftpId, targetEncoding)) {
+        throw new Error("Cannot replace the source link with itself. Choose Duplicate or Skip.");
+      }
      if (targetPane.connection.isLocal) {
        const deleteLocalFile = netcattyBridge.get()?.deleteLocalFile;
        if (!deleteLocalFile) throw new Error("Local delete unavailable");
@@ -104,9 +145,9 @@ export function useSftpTransferConflictOps() {
      if (!deleteSftp) throw new Error("SFTP delete unavailable");
      await deleteSftp(targetSftpId, task.targetPath, targetEncoding, expectedType);
    },
-    [],
+    [isSameSourceEntry],
  );


-  return { statTargetPath, getDuplicateTarget, deleteTargetPath };
+  return { statTargetPath, getDuplicateTarget, deleteTargetPath, isSameSourceEntry };
 }
@@ -558,11 +558,20 @@ export function useSftpDirectoryTransferOps({
    }
    const listingGate = progress.listingGate;
    const traversal = traversalBudget ?? createSftpDirectoryTraversalBudget();
+    // Only the newly supported same-pane local copy needs this fallback.
+    // Preserve existing large local uploads and cross-pane copies.
+    const boundLocalTraversal = sourceIsLocal && targetIsLocal
+      && task.sourceConnectionId === task.targetConnectionId;
    let claimedCanonicalPath: string | null = null;
    let regularFiles: SftpFileEntry[] = [];
    // Keep the current remote ancestor active through child discovery.
    try {
-      if (!sourceIsLocal && sourceSftpId) {
+      // Bound same-pane local copies that rediscover their own output through
+      // filesystem aliases not detected by the paste guard.
+      if (boundLocalTraversal) {
+        claimedCanonicalPath = claimSftpDirectoryVisit(traversal, task.sourcePath);
+        if (!claimedCanonicalPath) return totalErrors;
+      } else if (!sourceIsLocal && sourceSftpId) {
        const bridge = netcattyBridge.get();
        const canonicalPath = await bridge?.realpathSftp?.(sourceSftpId, task.sourcePath, sourceEncoding)
          .catch(() => task.sourcePath) ?? task.sourcePath;
@@ -611,7 +620,7 @@ export function useSftpDirectoryTransferOps({

      // Filter both "." and ".." — some SFTP servers include "." in readdir
      const filtered = files.filter((f) => f.name !== ".." && f.name !== ".");
-      if (!sourceIsLocal) accountSftpDirectoryEntries(traversal, filtered.length);
+      if (!sourceIsLocal || boundLocalTraversal) accountSftpDirectoryEntries(traversal, filtered.length);
      // Separate directories from files.
      // Symlink directories are only followed when followSymlinks is true
      // (downloadToLocal). Uploads/copies treat symlinks as regular entries
@@ -442,7 +442,7 @@ export const useSftpTransfers = ({
    cleanupTaskArtifacts,
  });

-  const { statTargetPath, getDuplicateTarget, deleteTargetPath } = useSftpTransferConflictOps();
+  const { statTargetPath, getDuplicateTarget, deleteTargetPath, isSameSourceEntry } = useSftpTransferConflictOps();

  const { transferFile, transferDirectory } = useSftpDirectoryTransferOps({
    ownerId,
@@ -840,9 +840,14 @@ export const useSftpTransfers = ({

      // Try same-host directory optimization first; falls back to recursive transfer
      // if remote cp is unavailable (e.g. Windows SSH servers).
-      let dirHandledBySameHost = false;
+      // Merge/Replace onto the source directory is already satisfied. Walking
+      // it would rewrite its children (including replacing links with files).
+      // Duplicate has a different target and continues through normal copying.
+      let directoryHandled = task.isDirectory
+        && await isSameSourceEntry(task, targetPane, targetSftpId, targetEncoding);
      if (
        task.isDirectory
+        && !directoryHandled
        && !task.replaceExistingTarget
        && task.resumable === false
        && sameHost
@@ -862,10 +867,10 @@ export const useSftpTransfers = ({
        if (cancelledTasksRef.current.has(task.id)) {
          throw new Error("Transfer cancelled");
        }
-        dirHandledBySameHost = result.success;
+        directoryHandled = result.success;
      }

-      if (task.isDirectory && !dirHandledBySameHost) {
+      if (task.isDirectory && !directoryHandled) {
        // For directory transfers, parent task uses:
        //   totalBytes = total file count (discovered async)
        //   transferredBytes = completed file count (incremented by child completions)
@@ -0,0 +1,63 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import React from 'react';
+import TestRenderer, { act } from 'react-test-renderer';
+import { useCodexConfigModel } from './useCodexConfigModel';
+import type { ExternalAgentConfig } from '../../infrastructure/ai/types';
+
+(globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+const agent: ExternalAgentConfig = {
+  id: 'discovered_codex', name: 'Codex', command: 'codex', sdkBackend: 'codex', enabled: true,
+  env: { CODEX_HOME: '/fixture/custom' },
+};
+
+for (const codexRuntime of ['sdk', 'app-server'] as const) {
+  test(`${codexRuntime}: quick send waits for the picker probe and receives its custom model`, async () => {
+    let resolve!: (result: unknown) => void;
+    const calls: unknown[] = [];
+    const originalWindow = Object.getOwnPropertyDescriptor(globalThis, 'window');
+    Object.defineProperty(globalThis, 'window', { configurable: true, value: { netcatty: {
+      aiCodexGetIntegration: (opts: unknown) => { calls.push(opts); return new Promise(done => { resolve = done; }); },
+    } } });
+    let result!: ReturnType<typeof useCodexConfigModel>;
+    function Harness({ config }: { config: ExternalAgentConfig }) {
+      result = useCodexConfigModel(config, true);
+      return null;
+    }
+    let root!: TestRenderer.ReactTestRenderer;
+    try {
+      const config = { ...agent, codexRuntime };
+      await act(async () => { root = TestRenderer.create(React.createElement(Harness, { config })); });
+      assert.equal(result.model, null);
+      let sent = false;
+      const sending = result.loadModel().then(model => { sent = true; return model; });
+      await Promise.resolve();
+      assert.equal(sent, false);
+      assert.equal(calls.length, 1);
+      assert.deepEqual((calls[0] as { agentEnv: unknown }).agentEnv, agent.env);
+      await act(async () => { resolve({ customConfig: { model: 'glm-5' } }); await sending; });
+      assert.equal(await sending, 'glm-5');
+      assert.equal(result.model, 'glm-5');
+      // A different agent must not inherit the previous home/model or promise.
+      await act(async () => { root.update(React.createElement(Harness, { config: { ...config, env: { CODEX_HOME: '/fixture/other' } } })); });
+      assert.equal(result.model, null);
+      assert.equal(calls.length, 2);
+      await act(async () => { resolve({ customConfig: null }); await result.loadModel(); });
+      assert.equal(result.model, null);
+    } finally {
+      await act(async () => root?.unmount());
+      if (originalWindow) Object.defineProperty(globalThis, 'window', originalWindow);
+      else Reflect.deleteProperty(globalThis, 'window');
+    }
+  });
+}
+
+test('non-Codex agents keep their model flow without probing Codex', async () => {
+  let result!: ReturnType<typeof useCodexConfigModel>;
+  function Harness() { result = useCodexConfigModel(undefined, true); return null; }
+  let root!: TestRenderer.ReactTestRenderer;
+  try {
+    await act(async () => { root = TestRenderer.create(React.createElement(Harness)); });
+    assert.equal(await result.loadModel(), null);
+  } finally { await act(async () => root.unmount()); }
+});
@@ -0,0 +1,33 @@
+import { useEffect, useMemo, useState } from 'react';
+import { getNetcattyBridge } from '../../infrastructure/ai/aiChatStreamingSupport';
+import { getManualAgentCommand, matchesManagedAgentConfig } from '../../infrastructure/ai/managedAgents';
+import type { ExternalAgentConfig } from '../../infrastructure/ai/types';
+
+/** Share the config probe between the picker and sends, scoped to this agent. */
+export function useCodexConfigModel(agent: ExternalAgentConfig | undefined, isVisible: boolean) {
+  const loadModel = useMemo(() => {
+    let pending: Promise<string | null> | undefined;
+    return () => {
+      pending ??= Promise.resolve().then(async () => {
+        if (!isVisible || !agent || !matchesManagedAgentConfig(agent, 'codex')) return null;
+        const info = await getNetcattyBridge()?.aiCodexGetIntegration?.({
+          codexPath: getManualAgentCommand(agent),
+          agentEnv: agent.env,
+        });
+        return info?.customConfig?.model || null;
+      }).catch(() => null);
+      return pending;
+    };
+  // Reopening the panel refreshes config changed outside Netcatty.
+  }, [agent, isVisible]);
+  const [result, setResult] = useState<{ loadModel: typeof loadModel; model: string | null }>();
+  useEffect(() => {
+    if (!isVisible) return;
+    let cancelled = false;
+    void loadModel().then(model => {
+      if (!cancelled) setResult({ loadModel, model });
+    });
+    return () => { cancelled = true; };
+  }, [isVisible, loadModel]);
+  return { model: result?.loadModel === loadModel ? result.model : null, loadModel };
+}
@@ -8,6 +8,7 @@ import {
  isPluginTerminalProviderRefreshCurrent,
  mergePluginTerminalThemeColors,
  resolvePluginTerminalTheme,
+  toPluginTerminalTheme,
  waitForProviderResponse,
 } from './usePluginTerminalProviders.ts';

@@ -24,6 +25,15 @@ const baseTheme = {
  },
 } as const satisfies TerminalTheme;

+test('theme provider requests keep the existing palette contract with intense color enabled or disabled', () => {
+  for (const foregroundIntense of ['#ff8800', undefined]) {
+    const theme = { ...baseTheme, colors: { ...baseTheme.colors, foregroundIntense } };
+    assert.deepEqual(toPluginTerminalTheme(theme), { type: baseTheme.type, colors: baseTheme.colors });
+    assert.equal(theme.colors.foregroundIntense, foregroundIntense);
+    assert.equal(resolvePluginTerminalTheme(theme, { background: '#112233' }).colors.foregroundIntense, foregroundIntense);
+  }
+});
+
 test('terminal theme Providers merge deterministically over the host theme', () => {
  const merged = mergePluginTerminalThemeColors([
    { background: '#102030', cursor: '#abcdef' },
@@ -51,6 +51,13 @@ interface UsePluginTerminalProvidersOptions extends PluginTerminalProviderRefres
  getSnapshotState(): Partial<NetcattyTerminalSessionSnapshot>;
 }

+export function toPluginTerminalTheme(theme: TerminalTheme) {
+  // The preview plugin contract exposes the existing palette only. Keep the
+  // host-only optional color out of its strictly validated request payload.
+  const { foregroundIntense: _foregroundIntense, ...colors } = theme.colors;
+  return { type: theme.type, colors };
+}
+
 export function mergePluginTerminalThemeColors(
  results: readonly PluginTerminalThemeColors[],
 ): PluginTerminalThemeColors {
@@ -211,10 +218,7 @@ export function usePluginTerminalProviders(options: UsePluginTerminalProvidersOp
    if (hasProvider('terminal.theme')) {
      tasks.push(applyCurrentProviderResponse(waitForProviderResponse(request('terminal.theme', 'provideTheme', {
        reason,
-        currentTheme: {
-          type: metadata.baseTheme.type,
-          colors: metadata.baseTheme.colors,
-        },
+        currentTheme: toPluginTerminalTheme(metadata.baseTheme),
      }, PROVIDER_DEADLINE_MS, undefined, controller.signal), controller), isCurrent,
        (response) => {
          setThemeColors(mergePluginTerminalThemeColors(response.results.map((result) => result.status === 'ok'
@@ -7,6 +7,7 @@ import {
  getAutoStartRuleBlockReason,
  isAutoStartProxyReady,
  isPortForwardingAutoStartEnabled,
+  isPortForwardingReconnectRequested,
 } from "./usePortForwardingAutoStart.ts";
 import type { GroupConfig, Host, PortForwardingRule, ProxyProfile } from "../../domain/models.ts";
 import { STORAGE_KEY_PORT_FORWARDING } from "../../infrastructure/config/storageKeys.ts";
@@ -177,6 +178,15 @@ test("reconnect eligibility follows the current auto-start setting", () => {
  assert.equal(isPortForwardingAutoStartEnabled([], "rule-1"), false);
 });

+test("reconnect is requested for auto-start and auto-reconnect rules only", () => {
+  assert.equal(isPortForwardingReconnectRequested([rule({ autoStart: true })], "rule-1"), true);
+  assert.equal(isPortForwardingReconnectRequested([rule({ autoStart: true, autoReconnect: false })], "rule-1"), false);
+  assert.equal(isPortForwardingReconnectRequested([rule({ autoStart: false, autoReconnect: true })], "rule-1"), true);
+  assert.equal(isPortForwardingReconnectRequested([rule({ autoStart: false, autoReconnect: false })], "rule-1"), false);
+  assert.equal(isPortForwardingReconnectRequested([rule({ autoStart: false })], "rule-1"), false);
+  assert.equal(isPortForwardingReconnectRequested([], "rule-1"), false);
+});
+
 test("network recovery starts an exhausted auto-start rule through the real service path", async (t) => {
  const env = installStorage();
  const previousWindow = Object.getOwnPropertyDescriptor(globalThis, "window");
@@ -8,6 +8,7 @@ import { GroupConfig, Host, Identity, KnownHost, PortForwardingRule, ProxyProfil
 import { resolveGroupDefaults, applyGroupDefaults } from "../../domain/groupConfig";
 import { materializeHostProxyProfile } from "../../domain/proxyProfiles";
 import { STORAGE_KEY_PORT_FORWARDING } from "../../infrastructure/config/storageKeys";
+import { isPortForwardingAutoReconnectEnabled } from "../../domain/portForwardingReconnect";
 import { localStorageAdapter } from "../../infrastructure/persistence/localStorageAdapter";
 import {
  getActiveConnection,
@@ -103,6 +104,11 @@ export const isPortForwardingAutoStartEnabled = (
  ruleId: string,
 ): boolean => rules.some((rule) => rule.id === ruleId && rule.autoStart === true);

+export const isPortForwardingReconnectRequested = (
+  rules: PortForwardingRule[],
+  ruleId: string,
+): boolean => rules.some((rule) => rule.id === ruleId && isPortForwardingAutoReconnectEnabled(rule));
+
 export const shouldStartPortForwardingAutoStartRule = (
  rule: PortForwardingRule,
  connection?: { status: PortForwardingRule["status"] },
@@ -110,6 +116,18 @@ export const shouldStartPortForwardingAutoStartRule = (
  !connection || connection.status === "inactive" || connection.status === "error"
 );

+/**
+ * Network-recovery counterpart of `shouldStartPortForwardingAutoStartRule`:
+ * unlike launch-time auto-start, rules that only opt in via `autoReconnect`
+ * are also restarted after network restoration.
+ */
+export const shouldRestartPortForwardingReconnectRule = (
+  rule: PortForwardingRule,
+  connection?: { status: PortForwardingRule["status"] },
+): boolean => isPortForwardingAutoReconnectEnabled(rule) && (
+  !connection || connection.status === "inactive" || connection.status === "error"
+);
+
 export const recoverPortForwardingAutoStartAfterNetworkRestore = async (
  restartAutoStartRules: (recoverableRuleIds: ReadonlySet<string>) => Promise<void>,
 ): Promise<void> => {
@@ -118,7 +136,7 @@ export const recoverPortForwardingAutoStartAfterNetworkRestore = async (
  ) ?? [];
  const recoverableRuleIds = new Set<string>();
  for (const rule of rules) {
-    if (rule.autoStart && resetReconnectAttempts(rule.id)) {
+    if (isPortForwardingAutoReconnectEnabled(rule) && resetReconnectAttempts(rule.id)) {
      recoverableRuleIds.add(rule.id);
    }
  }
@@ -184,7 +202,7 @@ export const runPortForwardingAutoStart = async ({
  recoveryRuleIds,
 }: RunPortForwardingAutoStartOptions): Promise<void> => {
  await syncWithBackend({
-    shouldReconnect: (ruleId) => isPortForwardingAutoStartEnabled(
+    shouldReconnect: (ruleId) => isPortForwardingReconnectRequested(
      localStorageAdapter.read<PortForwardingRule[]>(STORAGE_KEY_PORT_FORWARDING) ?? [],
      ruleId,
    ),
@@ -197,9 +215,11 @@ export const runPortForwardingAutoStart = async ({
    STORAGE_KEY_PORT_FORWARDING,
  ) ?? [];
  const autoStartRules = rules.filter((rule) =>
-    (!recoveryRuleIds || recoveryRuleIds.has(rule.id)) &&
-    (!recoveryRuleIds || isReconnectRecoveryEligible(rule.id)) &&
-    shouldStartPortForwardingAutoStartRule(rule, getActiveConnection(rule.id)),
+    recoveryRuleIds
+      ? recoveryRuleIds.has(rule.id) &&
+        isReconnectRecoveryEligible(rule.id) &&
+        shouldRestartPortForwardingReconnectRule(rule, getActiveConnection(rule.id))
+      : shouldStartPortForwardingAutoStartRule(rule, getActiveConnection(rule.id)),
  );

  if (autoStartRules.length === 0) return;
@@ -385,7 +405,7 @@ export const usePortForwardingAutoStart = ({
      return startPortForward(rule, host, resolveEffectiveHosts(hostsRef.current), keysRef.current, identitiesRef.current, onStatusChange, true, terminalSettingsRef.current, knownHostsRef.current);
    };

-    setReconnectCallback(handleReconnect, (ruleId) => isPortForwardingAutoStartEnabled(
+    setReconnectCallback(handleReconnect, (ruleId) => isPortForwardingReconnectRequested(
      localStorageAdapter.read<PortForwardingRule[]>(STORAGE_KEY_PORT_FORWARDING) ?? [],
      ruleId,
    ));
@@ -47,7 +47,7 @@ export interface ServerStats {
  disks: DiskInfo[];            // All mounted disks
  netRxSpeed: number;           // Total network receive speed (bytes/sec)
  netTxSpeed: number;           // Total network transmit speed (bytes/sec)
-  latencyMs: number | null;     // TCP connection establishment latency to the SSH endpoint
+  latencyMs: number | null;     // SSH transport ping round-trip to the SSH endpoint
  netInterfaces: NetInterfaceInfo[];  // Per-interface network stats
  lastUpdated: number | null;   // Timestamp of last successful update
 }
@@ -32,6 +32,11 @@ export const useTrayPanelBackend = () => {
    await bridge?.connectToHostFromTrayPanel?.(hostId);
  }, []);

+  const startPortForwardFromTrayPanel = useCallback(async (ruleId: string) => {
+    const bridge = netcattyBridge.get();
+    return bridge?.startPortForwardFromTrayPanel?.(ruleId);
+  }, []);
+
  const onTrayPanelCloseRequest = useCallback((callback: () => void) => {
    const bridge = netcattyBridge.get();
    return bridge?.onTrayPanelCloseRequest?.(callback);
@@ -71,6 +76,7 @@ export const useTrayPanelBackend = () => {
    quitApp,
    jumpToSession,
    closeSessionFromTrayPanel,
+    startPortForwardFromTrayPanel,
    connectToHostFromTrayPanel,
    onTrayPanelCloseRequest,
    onTrayPanelRefresh,
@@ -111,6 +111,7 @@ export function useVaultImportHandlers({

  const handleImportFileSelected = useCallback(
      async (format: VaultImportFormat, files: File[], options?: VaultImportOptions) => {
+        const preserveProfiles = format === "securecrt" || format === "finalshell";
        const file = files[0];
        if (!file) return;
        if (importInFlightRef.current) return;
@@ -141,7 +142,9 @@ export function useVaultImportHandlers({
                ? "CSV"
                : format === "securecrt"
                  ? "SecureCRT"
-                  : "ssh_config";
+                  : format === "finalshell"
+                    ? "FinalShell"
+                    : "ssh_config";
        const updateProgress = (next: Partial<VaultImportProgress>) => {
          setImportProgress((current) => ({
            status: "running",
@@ -183,9 +186,9 @@ export function useVaultImportHandlers({
            result = applyVaultImportDestination(
              result,
              options?.destination ?? { mode: "preserve" },
-              // SecureCRT keeps distinct session files that share an endpoint;
+              // Folder imports keep distinct profiles that share an endpoint;
              // only rewrite their group when the user picks an import location.
-              { collapseDuplicateEndpoints: format !== "securecrt" },
+              { collapseDuplicateEndpoints: !preserveProfiles },
            );
          }
          updateProgress({ stage: "preparing", percent: 70 });
@@ -321,7 +324,7 @@ export function useVaultImportHandlers({

          const existingKeys = new Set(currentHosts.map(makeKey));
          // Filter out duplicates for both managed and non-managed imports
-          let newHosts = format === "securecrt"
+          let newHosts = preserveProfiles
            ? result.hosts
            : result.hosts.filter((h) => !existingKeys.has(makeKey(h)));

@@ -486,7 +489,7 @@ export function useVaultImportHandlers({
              importBaselineHosts,
              importBaselineGroups,
              result,
-              { skipDuplicates: format !== "securecrt" },
+              { skipDuplicates: !preserveProfiles },
            );
            newHosts = merged.addedHosts;
            addedHostIds = new Set(merged.addedHosts.map((host) => host.id));
@@ -25,6 +25,23 @@ test("SecureCRT uses a directory picker and keeps every selected session file",
  assert.deepEqual(selectVaultImportFiles("csv", files), [files[0]]);
 });

+test("FinalShell supports conn directory and single JSON file selection", () => {
+  const files = [
+    new File(["{}"], "one.json"),
+    new File(["{}"], "two.json"),
+  ];
+
+  assert.deepEqual(getVaultImportPickerMode("finalshell"), {
+    directory: true,
+    multiple: true,
+  });
+  assert.deepEqual(getVaultImportPickerMode("finalshell", "file"), {
+    directory: false,
+    multiple: false,
+  });
+  assert.deepEqual(selectVaultImportFiles("finalshell", files), files);
+});
+
 test("vault import destination supports preserve, existing, and new groups", () => {
  assert.deepEqual(buildVaultImportDestination({ mode: "preserve" }), {
    mode: "preserve",
@@ -7,15 +7,16 @@ export type VaultImportDestinationMode = "preserve" | "existing" | "new";

 export function getVaultImportPickerMode(
  format: VaultImportFormat,
-  secureCrtSource: "folder" | "file" = "folder",
+  source: "folder" | "file" = "folder",
 ): {
  directory: boolean;
  multiple: boolean;
 } {
-  const isSecureCrtFolder = format === "securecrt" && secureCrtSource === "folder";
+  const isBatchFolder = (format === "securecrt" || format === "finalshell")
+    && source === "folder";
  return {
-    directory: isSecureCrtFolder,
-    multiple: isSecureCrtFolder,
+    directory: isBatchFolder,
+    multiple: isBatchFolder,
  };
 }

@@ -24,7 +25,9 @@ export function selectVaultImportFiles(
  files: ArrayLike<File>,
 ): File[] {
  const selected = Array.from(files);
-  return format === "securecrt" ? selected : selected.slice(0, 1);
+  return format === "securecrt" || format === "finalshell"
+    ? selected
+    : selected.slice(0, 1);
 }

 const normalizeGroup = (raw: string | undefined): string | undefined => {
@@ -48,7 +48,7 @@ import {
  isInlineTextAttachment,
 } from '../application/state/terminalSelectionAttachment';
 import { createVaultNoteAttachment, isVaultNoteAttachment, vaultNoteReferencesFit } from '../application/state/vaultNoteAttachment';
-import type { CodexIntegrationStatus } from './settings/tabs/ai/types';
+import { useCodexConfigModel } from '../application/state/useCodexConfigModel';
 import {
  useAIChatStreaming,
  getNetcattyBridge,
@@ -843,35 +843,9 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
    [currentAgentConfig],
  );

-  const [codexConfigModel, setCodexConfigModel] = useState<string | null>(null);
-  const [codexCustomConfigResolved, setCodexCustomConfigResolved] = useState(false);
-  useEffect(() => {
-    if (!isVisible) return;
-    setCodexCustomConfigResolved(false);
-    if (!isCodexManagedAgent) {
-      setCodexConfigModel(null);
-      return;
-    }
-    const bridge = getNetcattyBridge();
-    if (!bridge?.aiCodexGetIntegration) return;
-    let cancelled = false;
-    void Promise.resolve(
-      bridge.aiCodexGetIntegration({ codexPath: getManualAgentCommand(currentAgentConfig) }) as Promise<CodexIntegrationStatus>,
-    ).then((info) => {
-      if (cancelled) return;
-      const hasCustom = info?.state === 'connected_custom_config';
-      setCodexConfigModel(info?.customConfig?.model ?? null);
-      setCodexCustomConfigResolved(hasCustom);
-    }).catch(() => {
-      if (!cancelled) {
-        setCodexConfigModel(null);
-        setCodexCustomConfigResolved(false);
-      }
-    });
-    return () => {
-      cancelled = true;
-    };
-  }, [isVisible, isCodexManagedAgent, currentAgentId, currentAgentConfig]);
+  const { model: codexConfigModel, loadModel: loadCodexConfigModel } = useCodexConfigModel(
+    currentAgentConfig, isVisible,
+  );

  const agentModelMapRef = useRef(agentModelMap);
  agentModelMapRef.current = agentModelMap;
@@ -1035,18 +1009,12 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({

  const isCodexAppServer = isCodexManagedAgent && currentAgentConfig?.codexRuntime === 'app-server';
  const canSteerCurrentTurn = Boolean(activeSessionId && isStreaming && isCodexAppServer);
-  const hasCodexCustomConfig = codexCustomConfigResolved && isCodexManagedAgent && !isCodexAppServer;
+  const hasCodexCustomConfig = Boolean(codexConfigModel) && isCodexManagedAgent;

  const agentModelPresets = useMemo(() => {
    const runtimePresets = runtimeAgentModelPresets[currentAgentId];
-    if (hasCodexCustomConfig) {
-      if (runtimePresets) {
-        return runtimePresets;
-      }
-      if (codexConfigModel) {
-        return [{ id: codexConfigModel, name: codexConfigModel }];
-      }
-      return [];
+    if (hasCodexCustomConfig && codexConfigModel) {
+      return [{ id: codexConfigModel, name: codexConfigModel }];
    }
    if (runtimePresets) return runtimePresets;
    const presets = getAgentModelPresets(
@@ -1236,8 +1204,11 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
      if (sendBridge?.aiSyncWebSearch) {
        await sendBridge.aiSyncWebSearch(webSearchConfig?.apiHost || null, webSearchConfig?.apiKey || null);
      }
-      let sendSelectedAgentModel = selectedAgentModel;
-      if (currentAgentConfig && shouldLoadSdkRuntimeModels(currentAgentConfig)) {
+      // A quick send must await the same config probe as the picker. Its model
+      // also takes precedence over App Server's built-in model catalog.
+      const configModel = await loadCodexConfigModel();
+      let sendSelectedAgentModel = configModel ?? selectedAgentModel;
+      if (!configModel && currentAgentConfig && shouldLoadSdkRuntimeModels(currentAgentConfig)) {
        const runtimeTarget = buildExternalAgentRuntimeModelTarget(currentAgentConfig);
        if (runtimeTarget) {
          const catalog = await loadSdkRuntimeModelCatalog(runtimeTarget);
@@ -1421,7 +1392,7 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
      }
    }
  }, [
-    validateNoteMentions,
+    validateNoteMentions, loadCodexConfigModel,
    isStreaming, activeProvider, effectiveActiveProvider, effectiveActiveModelId, selectedCattyThinking, scopeKey, currentAgentId,
    activeModelId, externalAgents,
    createSession, addMessageToSession, updateMessageById, updateLastMessage,
@@ -28,6 +28,15 @@ test('checked targets keep a visible background after the cursor moves away', ()
  assert.equal(getWorkspaceTargetRowStateClass(true, true), 'bg-primary/20');
 });

+test('workspace host picker search matches tags through the shared matcher', () => {
+  const source = readFileSync(
+    new URL('./workspace/AddToWorkspaceDialog.tsx', import.meta.url),
+    'utf8',
+  );
+  assert.match(source, /matchesWorkspaceHostPickerQuery/);
+  assert.doesNotMatch(source, /h\.label\?\.toLowerCase\(\)\.includes\(term\)/);
+});
+
 test('clicking a target aligns the keyboard cursor with that target', () => {
  const source = readFileSync(
    new URL('./workspace/AddToWorkspaceDialog.tsx', import.meta.url),
@@ -1,6 +1,7 @@
 import { Search } from 'lucide-react';
 import React, { useMemo, useState, useEffect, useCallback } from 'react';
 import { useI18n } from '../application/i18n/I18nProvider';
+import { matchesWorkspaceHostPickerQuery } from '../lib/searchMatcher';
 import { Host } from '../types';
 import { DistroAvatar } from './DistroAvatar';
 import { Button } from './ui/button';
@@ -30,13 +31,9 @@ export const CreateWorkspaceDialog: React.FC<CreateWorkspaceDialogProps> = ({
  const [selectedHostIds, setSelectedHostIds] = useState<Set<string>>(new Set());

  const filteredHosts = useMemo(() => {
-    if (!search.trim()) return hosts;
-    const term = search.toLowerCase();
-    return hosts.filter(h =>
-      h.label.toLowerCase().includes(term) ||
-      h.hostname.toLowerCase().includes(term) ||
-      (h.group || '').toLowerCase().includes(term)
-    );
+    const term = search.trim();
+    if (!term) return hosts;
+    return hosts.filter((host) => matchesWorkspaceHostPickerQuery(term, host));
  }, [hosts, search]);

  const toggleHost = useCallback((hostId: string) => {
@@ -109,7 +106,7 @@ export const CreateWorkspaceDialog: React.FC<CreateWorkspaceDialogProps> = ({
            <div className="relative">
                <Search className="absolute left-2 top-2.5 h-4 w-4 text-muted-foreground" />
                <Input
-                placeholder={t('placeholder.searchHosts', { defaultValue: 'Search hosts...' })}
+                placeholder={t('placeholder.searchHosts', { defaultValue: 'Search hosts or tags...' })}
                value={search}
                onChange={(e) => setSearch(e.target.value)}
                className="pl-8"
@@ -57,6 +57,7 @@ import { Switch } from "./ui/switch";
 import { TerminalFontSelect } from "./settings/TerminalFontSelect";
 import { useAvailableFonts } from "../application/state/fontStore";
 import { toast } from "./ui/toast";
+import { HostNotesEditor } from "./host/HostNotesEditor";
 import { GroupSshSettingsSection } from "./GroupSshSettingsSection";
 import { prepareProxyConfigForSave } from "./HostDetailsPanel.helpers";
 import { TerminalEncodingSelect } from "./TerminalEncodingSelect";
@@ -547,6 +548,7 @@ const GroupDetailsPanel: React.FC<GroupDetailsPanelPropsWithResize> = ({

    const result: GroupConfig = {
      path: newPath,
+      notes: form.notes?.trim() || undefined,
      // Only include SSH fields if SSH section is enabled
      ...(sshEnabled && {
        protocol: 'ssh' as const,
@@ -994,6 +996,12 @@ const GroupDetailsPanel: React.FC<GroupDetailsPanelPropsWithResize> = ({
        </HostDetailsSection>
        </>)}

+        <HostNotesEditor
+          panelKey={groupPath}
+          value={form.notes ?? ""}
+          onChange={(notes) => update("notes", notes)}
+        />
+
        {/* Add Protocol Button — always at the bottom */}
        {addableProtocols.length > 0 && (
          <Dropdown open={addProtocolOpen} onOpenChange={setAddProtocolOpen}>
@@ -168,6 +168,7 @@ test("HostTreeView shows selected groups in multi-select mode", () => {
        children: {},
        hosts: [],
      }]}
+      groupConfigs={[{ path: "production", notes: "# VPN instructions" }]}
      hosts={[]}
      expandedPaths={new Set<string>()}
      onTogglePath={() => undefined}
@@ -188,6 +189,7 @@ test("HostTreeView shows selected groups in multi-select mode", () => {
    />,
  );

+  assert.match(markup, /aria-label="Group notes"/);
  assert.match(markup, /data-selected="true"/);
  assert.match(markup, /data-group-path="production"/);
  assert.match(markup, /role="tree"/);
@@ -538,19 +538,24 @@ const TreeNode: React.FC<TreeNodeProps> = ({
                    ? <CheckSquare size={16} />
                    : <Square size={16} />
                  : undefined}
-                labelActions={!isMultiSelectMode && (
-                  <button
-                    aria-label={`Edit ${node.name}`}
-                    tabIndex={-1}
-                    data-host-tree-group-edit-button={node.path}
-                    className="flex h-5 w-5 shrink-0 items-center justify-center rounded opacity-0 transition-colors hover:bg-secondary/80 group-hover:opacity-100"
-                    onClick={(e) => {
-                      e.stopPropagation();
-                      onEditGroup(node.path);
-                    }}
-                  >
-                    <Edit2 size={12} />
-                  </button>
+                labelActions={(
+                  <span className="inline-flex items-center gap-1">
+                    <HostNotesIndicator notes={groupConfigs.find((config) => config.path === node.path)?.notes} label="Group notes" />
+                    {!isMultiSelectMode && (
+                      <button
+                        aria-label={`Edit ${node.name}`}
+                        tabIndex={-1}
+                        data-host-tree-group-edit-button={node.path}
+                        className="flex h-5 w-5 shrink-0 items-center justify-center rounded opacity-0 transition-colors hover:bg-secondary/80 group-hover:opacity-100"
+                        onClick={(e) => {
+                          e.stopPropagation();
+                          onEditGroup(node.path);
+                        }}
+                      >
+                        <Edit2 size={12} />
+                      </button>
+                    )}
+                  </span>
                )}
              />
            </CollapsibleTrigger>
@@ -30,6 +30,7 @@ import {
  isPortForwardingRuleStartable,
  isPortForwardingRuleStoppable,
 } from "../domain/portForwardingBulkActions";
+import { isPortForwardingAutoReconnectEnabled } from "../domain/portForwardingReconnect";
 import { materializeHostProxyProfile } from "../domain/proxyProfiles";
 import { cn } from "../lib/utils";
 import SelectHostPanel from "./SelectHostPanel";
@@ -207,7 +208,7 @@ const PortForwarding: React.FC<PortForwardingProps> = ({
              );
            }
          },
-          rule.autoStart, // Enable reconnect for auto-start rules
+          isPortForwardingAutoReconnectEnabled(rule), // Enable reconnect for auto-reconnect rules (auto-start implies reconnect)
          terminalSettings,
          knownHosts,
        );
@@ -516,6 +517,8 @@ const PortForwarding: React.FC<PortForwardingProps> = ({
      remoteHost: newFormDraft.remoteHost,
      remotePort: newFormDraft.remotePort,
      hostId: newFormDraft.hostId,
+      autoStart: newFormDraft.autoStart ?? false,
+      autoReconnect: isPortForwardingAutoReconnectEnabled(newFormDraft),
    });

    setShowNewForm(false);
@@ -714,6 +717,8 @@ const PortForwarding: React.FC<PortForwardingProps> = ({
        remoteHost: draftRule.remoteHost,
        remotePort: draftRule.remotePort,
        hostId: draftRule.hostId,
+        autoStart: draftRule.autoStart ?? false,
+        autoReconnect: isPortForwardingAutoReconnectEnabled(draftRule),
      });
    }

@@ -68,6 +68,7 @@ export const SerialConnectModal: React.FC<SerialConnectModalProps> = ({
  const [localEcho, setLocalEcho] = useState(false);
  const [lineMode, setLineMode] = useState(false);
  const [backspaceBehavior, setBackspaceBehavior] = useState<SerialConfig['backspaceBehavior']>('default');
+  const [byteOrientedBackspace, setByteOrientedBackspace] = useState(false);
  const [charset, setCharset] = useState('UTF-8');

  // Save configuration state
@@ -119,6 +120,7 @@ export const SerialConnectModal: React.FC<SerialConnectModalProps> = ({
      localEcho,
      lineMode,
      backspaceBehavior,
+      byteOrientedBackspace,
    };

    // Save as host if checkbox is checked and onSaveHost is provided
@@ -370,6 +372,24 @@ export const SerialConnectModal: React.FC<SerialConnectModalProps> = ({
                  </p>
                </div>

+                <div className="flex items-center justify-between">
+                  <div className="space-y-0.5">
+                    <Label htmlFor="byte-oriented-backspace" className="text-sm font-medium cursor-pointer">
+                      {t('serial.field.byteOrientedBackspace')}
+                    </Label>
+                    <p className="text-xs text-muted-foreground">
+                      {t('serial.field.byteOrientedBackspaceDesc')}
+                    </p>
+                  </div>
+                  <input
+                    type="checkbox"
+                    id="byte-oriented-backspace"
+                    checked={byteOrientedBackspace}
+                    onChange={(e) => setByteOrientedBackspace(e.target.checked)}
+                    className="h-4 w-4 rounded border-input"
+                  />
+                </div>
+
                <div className="flex items-center justify-between">
                  <div className="space-y-0.5">
                    <Label htmlFor="local-echo" className="text-sm font-medium cursor-pointer">
@@ -90,6 +90,9 @@ export const SerialHostDetailsPanel: React.FC<SerialHostDetailsPanelPropsWithRes
    resolveSerialBackspaceFormValue(initialData, groupDefaults),
  );
  const [backspaceBehaviorChanged, setBackspaceBehaviorChanged] = useState(false);
+  const [byteOrientedBackspace, setByteOrientedBackspace] = useState(
+    initialData.serialConfig?.byteOrientedBackspace ?? false,
+  );
  const [charset, setCharset] = useState(initialData.charset || 'UTF-8');
  const [tags, setTags] = useState<string[]>(initialData.tags || []);
  const [group, setGroup] = useState(initialData.group || '');
@@ -128,6 +131,7 @@ export const SerialHostDetailsPanel: React.FC<SerialHostDetailsPanelPropsWithRes
        selectedBehavior: backspaceBehavior,
        behaviorChanged: backspaceBehaviorChanged,
      }),
+      byteOrientedBackspace,
    };

    const portName = selectedPort.split('/').pop() || selectedPort;
@@ -436,6 +440,24 @@ export const SerialHostDetailsPanel: React.FC<SerialHostDetailsPanelPropsWithRes
                </p>
              </div>

+              <div className="flex items-center justify-between">
+                <div className="space-y-0.5">
+                  <Label htmlFor="byte-oriented-backspace" className="text-sm font-medium cursor-pointer">
+                    {t('serial.field.byteOrientedBackspace')}
+                  </Label>
+                  <p className="text-xs text-muted-foreground">
+                    {t('serial.field.byteOrientedBackspaceDesc')}
+                  </p>
+                </div>
+                <input
+                  type="checkbox"
+                  id="byte-oriented-backspace"
+                  checked={byteOrientedBackspace}
+                  onChange={(e) => setByteOrientedBackspace(e.target.checked)}
+                  className="h-4 w-4 rounded border-input"
+                />
+              </div>
+
              <div className="flex items-center justify-between">
                <div className="space-y-0.5">
                  <Label htmlFor="local-echo" className="text-sm font-medium cursor-pointer">
@@ -31,6 +31,7 @@ import {
 import { useSftpFollowTerminalCwd } from "../application/state/sftp/useSftpFollowTerminalCwd";
 import { usePendingSftpUploadRebind } from "../application/state/sftp/usePendingSftpUploadRebind";
 import { registerEditorSftpWriterScoped } from "../application/state/editorSftpBridge";
+import { registerEditorSftpOwnerResolver } from "../application/state/editorSftpOwnerRegistry";
 import {
  editorTabStore,
  useEditorTabPresenceRevision,
@@ -147,6 +148,9 @@ interface SftpSidePanelProps {
   * focused). Keeps browse SFTP sessions warm across History/System switches.
   */
  ownerPanelOpen?: boolean;
+  /** Top-level tab id hosting this panel (terminal/workspace tab), used to
+   * resolve which tab owns an editor's SFTP connection. */
+  ownerTabId?: string | null;
  renderOverlays?: boolean;
  pendingUpload?: {
    requestId: string;
@@ -201,6 +205,7 @@ const SftpSidePanelInner: React.FC<SftpSidePanelProps> = ({
  showWorkspaceHostHeader = false,
  isVisible = true,
  ownerPanelOpen = false,
+  ownerTabId = null,
  renderOverlays = true,
  pendingUpload = null,
  onPendingUploadHandled,
@@ -478,6 +483,32 @@ const SftpSidePanelInner: React.FC<SftpSidePanelProps> = ({
    );
  }, []);

+  const ownerTabIdRef = useRef(ownerTabId);
+  ownerTabIdRef.current = ownerTabId;
+
+  // While mounted, report which SFTP connections this panel owns and which
+  // top-level tab hosts it, so batch-close logic can keep the owning tab open
+  // when an editor bound to one of those connections survives its close
+  // prompt. Intentionally no deps — go through sftpRef so connection churn
+  // doesn't register/unregister on every re-render.
+  useEffect(() => {
+    return registerEditorSftpOwnerResolver(() => {
+      const s = sftpRef.current;
+      if (!s) return { connectionIds: [], ownerTabId: ownerTabIdRef.current };
+      const connectionIds: string[] = [];
+      const paneTabIds: string[] = [];
+      for (const tab of [...(s.leftTabs?.tabs ?? []), ...(s.rightTabs?.tabs ?? [])]) {
+        const id = tab.connection?.id;
+        if (id) connectionIds.push(id);
+        // Pane tab ids are stable across browse reconnects (unlike connection
+        // ids), so owner resolution can match editors bound to a stale
+        // pre-reconnect connection id.
+        if (tab.id) paneTabIds.push(tab.id);
+      }
+      return { connectionIds, paneTabIds, ownerTabId: ownerTabIdRef.current };
+    });
+  }, []);
+
  // When this side panel unmounts (its hosting terminal tab was closed) we
  // force-close any editor tabs bound to connections this panel owned — the
  // save channel is gone with the SFTP session and there's no way to recover
@@ -1,5 +1,7 @@
+import { createTerminalReflowReadingPosition } from "./terminal/terminalReflowReadingPosition";
 import { resolveHostOs } from '../domain/host';
 import { Terminal as XTerm } from "@xterm/xterm";
+import type { IMarker } from "@xterm/xterm";
 import { FitAddon } from "@xterm/addon-fit";
 import { SerializeAddon } from "@xterm/addon-serialize";
 import { SearchAddon } from "@xterm/addon-search";
@@ -232,6 +234,8 @@ import {
  resolveTerminalHibernateReplayChunkBytes,
  type TerminalHibernateWakePayload,
 } from "../domain/terminalHibernate";
+import { getLastChar, removeLastChar } from "../domain/serialCharMetrics";
+import { stringCellWidth } from "./terminal/autocomplete/terminalStringCellWidth";
 import { terminalHiddenRendererStore } from "../application/state/terminalHiddenRendererStore";
 import {
  wakeTerminalFromHibernate,
@@ -255,6 +259,7 @@ import {
 import {
  alignTerminalViewportScroll,
  createSynchronizedOutputFitScheduler,
+  resolveTerminalReflowScrollAnchor,
  AUTO_RUN_SNIPPET_LINE_DELAY_MS,
  forceSyncRenderAfterResize,
  MAX_CONNECTION_LOG_DATA_CHARS,
@@ -642,6 +647,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
  const isRendererActiveRef = useRef(isRendererActive);
  isRendererActiveRef.current = isRendererActive;
  const pendingOutputScrollRef = useRef(false);
+  const reflowReadingPositionRef = useRef(createTerminalReflowReadingPosition());
  const lastFittedSizeRef = useRef<{ width: number; height: number } | null>(null);
  const fontWeightFixupDoneRef = useRef(false);

@@ -1019,8 +1025,10 @@ const TerminalComponent: React.FC<TerminalProps> = ({
            serialLineBufferRef.current = "";
          } else if (ch === "\b" || ch === "\x7f") {
            if (serialLineBufferRef.current.length > 0) {
-              serialLineBufferRef.current = serialLineBufferRef.current.slice(0, -1);
-              if (serialConfig?.localEcho) writeLocalTerminalData("\b \b");
+              const lastChar = getLastChar(serialLineBufferRef.current);
+              const cells = stringCellWidth(lastChar, termRef.current);
+              serialLineBufferRef.current = removeLastChar(serialLineBufferRef.current);
+              if (serialConfig?.localEcho) writeLocalTerminalData("\b \b".repeat(cells));
            }
          } else if (ch.charCodeAt(0) >= 32) {
            serialLineBufferRef.current += ch;
@@ -2424,6 +2432,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
    isNetworkDevice,
    startupCommand,
    noAutoRun,
+    recordSerialSnippetInput: (data) => xtermRuntimeRef.current?.recordSerialSnippetInput(data),
    multiLineRunMode,
    shellType,
    suppressHostStartupCommandRef,
@@ -3009,6 +3018,48 @@ const TerminalComponent: React.FC<TerminalProps> = ({
        const dimensions = fitAddon.proposeDimensions();
        if (!dimensions || Number.isNaN(dimensions.cols) || Number.isNaN(dimensions.rows)) return;

+        // A column change rewraps the scrollback, moving rows above the
+        // reading position, so a saved row index no longer points at the same
+        // content after the resize. Capture the content instead of an index.
+        // Row-only and pixel-only fits never rewrap, so skip the O(scrollback)
+        // anchor scan on those frames.
+        const previousCols = term.cols;
+        const reflowAnchor = wasPinnedToBottom || term.cols === dimensions.cols
+          ? null
+          : reflowReadingPositionRef.current.capture(buffer, {
+              // xterm keeps at most rows + scrollback buffer rows and trims
+              // from the top beyond that (Buffer._getCorrectBufferLength), so
+              // these bounds let the capture skip its whole-line measurement
+              // when no trim can reach the anchored line.
+              maxRows: dimensions.rows + (term.options.scrollback ?? 1000),
+              oldCols: previousCols,
+              newCols: dimensions.cols,
+            });
+
+        // Markers pinned to the viewed row and to the viewed logical line's
+        // start. xterm adjusts marker rows through the rewrap (and disposes
+        // them when their row is deleted or trimmed), so after the resize a
+        // surviving marker marks where the viewed content moved without
+        // scanning for it. Each rewrap direction deletes a different row:
+        // a column grow merges a wrapped continuation into its predecessor
+        // (disposing a marker on the viewed continuation row), while a column
+        // shrink on a full scrollback trims the line's first physical rows
+        // (disposing a marker on the start row; the viewed content survives).
+        // Pinning one marker to each of those rows keeps the resolver seeded
+        // in both directions.
+        let reflowMarker: IMarker | null = null;
+        let reflowStartMarker: IMarker | null = null;
+        if (reflowAnchor) {
+          reflowMarker = term.registerMarker(
+            savedViewportY - (buffer.baseY + buffer.cursorY),
+          );
+          if (reflowAnchor.startRow !== savedViewportY) {
+            reflowStartMarker = term.registerMarker(
+              reflowAnchor.startRow - (buffer.baseY + buffer.cursorY),
+            );
+          }
+        }
+
        lastFittedSizeRef.current = { width, height };
        // addon-fit 0.11 clears the renderer before resizing, which can show
        // as a one-frame WebGL blink during layout changes. Resize directly
@@ -3030,15 +3081,95 @@ const TerminalComponent: React.FC<TerminalProps> = ({
        // Align first so the relative restore below does not apply that delta twice.
        alignTerminalViewportScroll(term);

+        let anchoredViewportY: number | null = null;
        // Preserve scroll position across resize (superset/Tabby pattern).
        if (wasPinnedToBottom) {
          term.scrollToBottom();
        } else {
-          const targetY = Math.min(savedViewportY, term.buffer.active.baseY);
+          // Re-locate the anchored content; fall back to the saved row index
+          // when the anchored content is gone (scrollback trim). Prefer the
+          // viewport-row marker (it marks the viewed row itself) over the
+          // line-start marker, which only seeds the scan.
+          const viewedMarkerRow = reflowMarker && !reflowMarker.isDisposed && reflowMarker.line >= 0
+            ? reflowMarker.line
+            : null;
+          const startMarkerRow = reflowStartMarker && !reflowStartMarker.isDisposed
+            && reflowStartMarker.line >= 0
+            ? reflowStartMarker.line
+            : null;
+          const markerRow = viewedMarkerRow ?? startMarkerRow;
+          reflowMarker?.dispose();
+          reflowMarker = null;
+          reflowStartMarker?.dispose();
+          reflowStartMarker = null;
+          // A continuation anchor registers both markers, so both coming back
+          // disposed means the trim deleted the rows they pin — but marker
+          // disposal alone is not proof the anchored content is gone: a
+          // narrowing rewrap relocates the viewed characters into newly
+          // appended continuation rows before the trim cuts the same number
+          // of rows from the top, so the characters can survive at the buffer
+          // top while both pinned rows are gone. `trimReachedStart` switches
+          // the resolver to that remnant check (a trim removes from the top,
+          // so a line whose start row it reached leaves any surviving part at
+          // row 0) instead of letting it sweep the stale row for repetitive
+          // duplicates on every divider-drag frame. A single disposed
+          // viewport marker keeps the seeded resolve: a column-grow merge
+          // disposes it while the merged line still matches the anchor.
+          const trimReachedStart = reflowAnchor !== null
+            && reflowAnchor.startRow !== savedViewportY
+            && viewedMarkerRow === null
+            && startMarkerRow === null;
+          anchoredViewportY = reflowAnchor === null
+            ? null
+            : resolveTerminalReflowScrollAnchor(
+                term.buffer.active,
+                reflowAnchor,
+                markerRow,
+                trimReachedStart,
+              );
+          // Content matching can still fail when the viewed line is the
+          // cursor's own logical line: with the pinned `reflowCursorLine:
+          // false` default a narrowing resize skips rewrapping that line and
+          // truncates its rows, so the captured prefix no longer matches even
+          // though the viewport-row marker survived and tracks the exact
+          // viewed row. Restore the marker position there rather than the
+          // stale saved index, which would jump upward by the accumulated
+          // reflow delta of the rewrapped lines above. (The line-start marker
+          // must not stand in for a failed match: its row only seeds the
+          // scan, and the column-grow merge disposes the viewport marker
+          // while the merged line still matches the anchor.)
+          // Only those two cases may trust the viewport-row marker. When the
+          // viewport sits partway into a wrapped non-cursor line, a column
+          // shrink rewraps that line and xterm appends the group's newly
+          // created rows after the existing ones, so the marker keeps its old
+          // within-line row while the viewed characters move deeper — even
+          // though xterm still adjusts the marker through unrelated
+          // insertions and would have disposed it only if its row were
+          // trimmed. That mismatch is unobservable through marker disposal,
+          // so trust the marker as a restore position only when the anchored
+          // line is the cursor's own (row indices survive truncation) or the
+          // marker sits at the anchored line's start (the group's new rows
+          // are appended below it, and insertions above shift it onto the
+          // relocated start). Anything else falls back to the plain row
+          // restore.
+          const markerTrackedViewport = reflowAnchor !== null
+            && (reflowAnchor.startRow === savedViewportY
+              || reflowAnchor.containsCursor === true)
+            ? viewedMarkerRow
+            : null;
+          const targetY = Math.min(
+            anchoredViewportY ?? markerTrackedViewport ?? savedViewportY,
+            term.buffer.active.baseY,
+          );
          if (term.buffer.active.viewportY !== targetY) {
            term.scrollToLine(targetY);
          }
        }
+        if (term.cols !== previousCols) {
+          reflowReadingPositionRef.current.remember(
+            term.buffer.active, anchoredViewportY === null ? null : reflowAnchor,
+          );
+        }
        term.refresh(0, Math.max(0, term.rows - 1));

        if (typeof requestAnimationFrame === "function") {
@@ -3195,12 +3326,16 @@ const TerminalComponent: React.FC<TerminalProps> = ({
      sensitive,
      ...(lineDelayMs ? { lineDelayMs } : {}),
    });
+    // Snippets left for editing share the serial typed-input buffer.
+    if (host.protocol === 'serial' && noAutoRun && !serialConfig?.lineMode) {
+      xtermRuntimeRef.current?.recordSerialSnippetInput(data);
+    }
    scrollToBottomAfterProgrammaticInput(data);
    if (options?.focus !== false) {
      term.focus();
    }
    return true;
-  }, [prepareProgrammaticSudoInput, scrollToBottomAfterProgrammaticInput, terminalBackend, sessionId]);
+  }, [prepareProgrammaticSudoInput, scrollToBottomAfterProgrammaticInput, terminalBackend, sessionId, host.protocol, serialConfig?.lineMode]);

  const executeSnippet = useCallback(async (snippet: Snippet) => {
    if (isScriptSnippet(snippet)) {
@@ -3278,6 +3413,13 @@ const TerminalComponent: React.FC<TerminalProps> = ({
  }, [onAddSelectionToAI, sessionId, terminalSettings?.normalizeTextOnCopy]);

  const handleSetTerminalEncoding = useCallback((encoding: TerminalEncodingPreference) => {
+    // A byte-oriented device still holds bytes in the previous encoding.
+    // Require an empty input line before changing that encoding.
+    if (host.protocol === 'serial' && serialConfig?.byteOrientedBackspace === true
+      && !serialConfig?.lineMode && commandBufferRef.current) {
+      toast.info(t('serial.encoding.pendingInput'));
+      return;
+    }
    setTerminalEncoding(encoding);
    setRememberedTerminalEncoding(encoding);
    userPickedEncodingRef.current = true;
@@ -3290,7 +3432,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
    if (sessionRef.current) {
      setSessionEncoding(sessionRef.current, encoding);
    }
-  }, [handleUpdateHostFromTerminal, host.id, host.protocol, setRememberedTerminalEncoding, setSessionEncoding]);
+  }, [handleUpdateHostFromTerminal, host.id, host.protocol, serialConfig?.byteOrientedBackspace, serialConfig?.lineMode, setRememberedTerminalEncoding, setSessionEncoding, t]);

  const handleOpenSFTP = useCallback(async () => {
    if (onOpenSftp) {
@@ -4086,6 +4228,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
    requestSearchFocus,
    serialLocalEcho: serialConfig?.localEcho,
    serialLineMode: serialConfig?.lineMode,
+    serialByteOrientedBackspace: serialConfig?.byteOrientedBackspace ?? false,
    serialLineBufferRef,
    telnetLocalEchoRef,
    onTerminalLogData: captureTerminalLogData,
@@ -634,3 +634,24 @@ test("App shell retains presentation-stable sessions for domain memos", () => {
  assert.match(appSource, /sessions: sessionsForShell/);
  assert.match(appSource, /orphanSessions: orphanSessionsForShell/);
 });
+
+test("bulk close context menu offers symmetric close-to-left option", () => {
+  const bulkCloseBlock = topTabsSource.slice(
+    topTabsSource.indexOf("Bulk-close menu items shared by session and workspace context menus"),
+    topTabsSource.indexOf("// Render the tabs"),
+  );
+  // Left of the anchor is symmetric with close-to-right: slice(0, anchorIdx).
+  assert.match(bulkCloseBlock, /orderedTabs\.slice\(0, anchorIdx\)/);
+  assert.match(bulkCloseBlock, /tabs\.closeToLeft/);
+  assert.match(bulkCloseBlock, /onCloseTabsBatch\(leftIds\)/);
+
+  // Locale parity: the new key is translated in every terminal locale.
+  const locales = ["en", "es", "ru", "zh-CN", "zh-TW"] as const;
+  for (const locale of locales) {
+    const source = readFileSync(
+      new URL(`../application/i18n/locales/${locale}/terminal.ts`, import.meta.url),
+      "utf8",
+    );
+    assert.match(source, /'tabs\.closeToLeft':/);
+  }
+});
@@ -769,6 +769,7 @@ const TopTabsInner: React.FC<TopTabsProps> = ({
    const anchorIdx = orderedTabs.indexOf(anchorId);
    const othersIds = orderedTabs.filter((id) => id !== anchorId);
    const rightIds = anchorIdx >= 0 ? orderedTabs.slice(anchorIdx + 1) : [];
+    const leftIds = anchorIdx > 0 ? orderedTabs.slice(0, anchorIdx) : [];
    return (
      <>
        <ContextMenuSeparator />
@@ -778,6 +779,12 @@ const TopTabsInner: React.FC<TopTabsProps> = ({
        >
          {t('tabs.closeOthers')}
        </ContextMenuItem>
+        <ContextMenuItem
+          disabled={leftIds.length === 0}
+          onClick={() => onCloseTabsBatch(leftIds)}
+        >
+          {t('tabs.closeToLeft')}
+        </ContextMenuItem>
        <ContextMenuItem
          disabled={rightIds.length === 0}
          onClick={() => onCloseTabsBatch(rightIds)}
@@ -10,10 +10,8 @@ import { useI18n } from "../application/i18n/I18nProvider";
 import { I18nProvider } from "../application/i18n/I18nProvider";
 import { useTrayPanelBackend } from "../application/state/useTrayPanelBackend";
 import { useActiveTabId } from "../application/state/activeTabStore";
-import { resolveGroupDefaults, applyGroupDefaults } from "../domain/groupConfig";
-import { materializeHostProxyProfile } from "../domain/proxyProfiles";
 import { upsertKnownHost } from "../domain/knownHosts";
-import type { Host, KnownHost } from "../domain/models";
+import type { KnownHost } from "../domain/models";
 import { getEffectiveKnownHosts } from "../infrastructure/syncHelpers";
 import { PortForwardHostKeyTrayPrompt } from "./port-forwarding";
 import { X, Maximize2, ChevronRight, ChevronDown, Power } from "lucide-react";
@@ -136,11 +134,7 @@ const WorkspaceGroup: React.FC<{
  );
 };

-interface TrayPanelContentProps {
-  terminalSettings?: { verifyHostKeys: boolean; keepaliveInterval: number; keepaliveCountMax: number };
-}
-
-const TrayPanelContent: React.FC<TrayPanelContentProps> = ({ terminalSettings }) => {
+const TrayPanelContent: React.FC = () => {
  const { t } = useI18n();
  const {
    hideTrayPanel,
@@ -148,27 +142,23 @@ const TrayPanelContent: React.FC<TrayPanelContentProps> = ({ terminalSettings })
    quitApp,
    jumpToSession,
    closeSessionFromTrayPanel,
+    startPortForwardFromTrayPanel,
    onTrayPanelCloseRequest,
    onTrayPanelRefresh,
    onTrayPanelMenuData,
  } = useTrayPanelBackend();

-  const { hosts, keys, identities, proxyProfiles, groupConfigs, knownHosts, updateKnownHosts } = useVaultState();
+  const { hosts, knownHosts, updateKnownHosts } = useVaultState();
  // TrayPanel runs in its own BrowserWindow, so this hook's session state is
  // independent from (and typically empty compared to) the main App's — it's
  // used here only for its storage-sync side effects, never for closeSession.
  useSessionState({ persistSessionRestore: false });
  const {
    rules: portForwardingRules,
-    startTunnel,
    stopTunnel,
    hasRuntimeTunnel,
  } = usePortForwardingState();
  const activeTabId = useActiveTabId();
-  const proxyProfileIdSet = useMemo(
-    () => new Set(proxyProfiles.map((profile) => profile.id)),
-    [proxyProfiles],
-  );
  const effectiveKnownHosts = useMemo(
    () => getEffectiveKnownHosts(knownHosts) ?? [],
    [knownHosts],
@@ -444,16 +434,9 @@ const TrayPanelContent: React.FC<TrayPanelContentProps> = ({ terminalSettings })
                              if (!result.success && result.error) toast.error(result.error);
                            });
                          } else {
-                            const resolveEffectiveHost = (host: Host) => {
-                              const withGroupDefaults = host.group
-                                ? applyGroupDefaults(host, resolveGroupDefaults(host.group, groupConfigs, { validProxyProfileIds: proxyProfileIdSet }), { validProxyProfileIds: proxyProfileIdSet })
-                                : applyGroupDefaults(host, {}, { validProxyProfileIds: proxyProfileIdSet });
-                              return materializeHostProxyProfile(withGroupDefaults, proxyProfiles);
-                            };
-                            const host = resolveEffectiveHost(rawHost);
-                            void startTunnel(rule, host, hosts.map(resolveEffectiveHost), keys, identities, (status, error) => {
-                              if (status === "error" && error) toast.error(error);
-                            }, rule.autoStart, terminalSettings, effectiveKnownHosts);
+                            void startPortForwardFromTrayPanel(rule.id).then((result) => {
+                              if (result && !result.success && result.error) toast.error(result.error);
+                            });
                          }
                        }}
                        className={cn(
@@ -519,7 +502,7 @@ type SettingsState = AppLockGateRenderContext["settings"];
 const TrayPanel: React.FC<{ settings: SettingsState }> = ({ settings }) => {
  return (
    <I18nProvider locale={settings.uiLanguage}>
-      <TrayPanelContent terminalSettings={settings.terminalSettings} />
+      <TrayPanelContent />
    </I18nProvider>
  );
 };
@@ -0,0 +1,11 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import React from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import { HostNotesIndicator } from "./HostNotesIndicator";
+
+test("notes indicators distinguish groups from hosts and hide empty notes", () => {
+  assert.match(renderToStaticMarkup(<HostNotesIndicator notes="Host" />), /aria-label="Host notes"/);
+  assert.match(renderToStaticMarkup(<HostNotesIndicator notes="# Project" label="Group notes" />), /aria-label="Group notes"/);
+  assert.equal(renderToStaticMarkup(<HostNotesIndicator notes="  " label="Group notes" />), "");
+});
@@ -7,11 +7,13 @@ import { HoverCard, HoverCardContent, HoverCardTrigger } from "../ui/hover-card"
 export interface HostNotesIndicatorProps {
  notes?: string;
  className?: string;
+  label?: string;
 }

 export const HostNotesIndicator: React.FC<HostNotesIndicatorProps> = ({
  notes,
  className,
+  label = "Host notes",
 }) => {
  const trimmed = notes?.trim();
  if (!trimmed) return null;
@@ -25,7 +27,7 @@ export const HostNotesIndicator: React.FC<HostNotesIndicatorProps> = ({
            "inline-flex h-4 w-4 shrink-0 items-center justify-center rounded border-0 bg-transparent p-0 text-muted-foreground transition-colors hover:text-foreground",
            className,
          )}
-          aria-label="Host notes"
+          aria-label={label}
          onClick={(e) => e.stopPropagation()}
          onPointerDown={(e) => e.stopPropagation()}
        >
@@ -83,6 +83,7 @@ test('AddToWorkspaceDialog virtualizes and clamps selection on shrink', () => {
  const source = read('workspace/AddToWorkspaceDialog.tsx');
  assert.match(source, /VariableSizeVirtualList/);
  assert.match(source, /data-host-picker-virtual="add-workspace"/);
+  assert.match(source, /matchesWorkspaceHostPickerQuery/);
  assert.match(source, /clampListIndex\(prev, items\.length\)/);
  assert.match(source, /onClick=\{\(\) => handleTargetClick\(idx, LOCAL_ITEM_ID\)\}/);
  assert.match(source, /onClick=\{\(\) => handleTargetClick\(idx, host\.id\)\}/);
@@ -96,6 +97,7 @@ test('CreateWorkspaceDialog virtualizes selectable hosts', () => {
  const source = read('CreateWorkspaceDialog.tsx');
  assert.match(source, /FixedSizeVirtualList/);
  assert.match(source, /data-host-picker-virtual="create-workspace"/);
+  assert.match(source, /matchesWorkspaceHostPickerQuery/);
  assert.doesNotMatch(source, /filteredHosts\.map\(host =>/);
 });

@@ -4,6 +4,7 @@
 */
 import { ChevronDown,Copy,Trash2 } from 'lucide-react';
 import React from 'react';
+import { isPortForwardingAutoReconnectEnabled } from '../../domain/portForwardingReconnect';
 import { useI18n } from '../../application/i18n/I18nProvider';
 import { Host,PortForwardingRule } from '../../domain/models';
 import { DistroAvatar } from '../DistroAvatar';
@@ -182,6 +183,18 @@ export const EditPanel: React.FC<EditPanelProps> = ({
                        onCheckedChange={checked => onDraftChange({ autoStart: checked })}
                    />
                </div>
+
+                {/* Auto Reconnect Toggle */}
+                <div className="flex items-center justify-between py-2">
+                    <div className="space-y-0.5">
+                        <Label className="text-sm font-medium">{t('pf.form.autoReconnect')}</Label>
+                        <p className="text-[10px] text-muted-foreground">{t('pf.form.autoReconnectDesc')}</p>
+                    </div>
+                    <Switch
+                        checked={isPortForwardingAutoReconnectEnabled(draft)}
+                        onCheckedChange={checked => onDraftChange({ autoReconnect: checked })}
+                    />
+                </div>
            </AsidePanelContent>
            <AsidePanelFooter className="space-y-2">
                <Button
@@ -4,6 +4,7 @@
 */
 import { ChevronDown,Zap } from 'lucide-react';
 import React from 'react';
+import { isPortForwardingAutoReconnectEnabled } from '../../domain/portForwardingReconnect';
 import { useI18n } from '../../application/i18n/I18nProvider';
 import { Host,PortForwardingRule,PortForwardingType } from '../../domain/models';
 import { cn } from '../../lib/utils';
@@ -182,6 +183,18 @@ export const NewFormPanel: React.FC<NewFormPanelProps> = ({
                        onCheckedChange={checked => onDraftChange({ autoStart: checked })}
                    />
                </div>
+
+                {/* Auto Reconnect Toggle */}
+                <div className="flex items-center justify-between py-2">
+                    <div className="space-y-0.5">
+                        <Label className="text-sm font-medium">{t('pf.form.autoReconnect')}</Label>
+                        <p className="text-[10px] text-muted-foreground">{t('pf.form.autoReconnectDesc')}</p>
+                    </div>
+                    <Switch
+                        checked={isPortForwardingAutoReconnectEnabled(draft)}
+                        onCheckedChange={checked => onDraftChange({ autoReconnect: checked })}
+                    />
+                </div>
            </AsidePanelContent>
            <AsidePanelFooter className="space-y-2">
                <Button
@@ -645,6 +645,11 @@ const SettingsAITab: React.FC<SettingsAITabProps> = ({
    }, 900);
  }, []);

+  const codexManagedAgent = useMemo(
+    () => externalAgents.find((agent) => agent.id === "discovered_codex"),
+    [externalAgents],
+  );
+
  const refreshCodexIntegration = useCallback(async (opts?: { refreshShellEnv?: boolean; validateChatGptAuth?: boolean; codexPath?: string }) => {
    const bridge = getBridge();
    if (!bridge?.aiCodexGetIntegration) return;
@@ -655,7 +660,7 @@ const SettingsAITab: React.FC<SettingsAITabProps> = ({
    setIsCodexLoading(true);
    setCodexError(null);
    try {
-      const integration = await bridge.aiCodexGetIntegration(opts);
+      const integration = await bridge.aiCodexGetIntegration({ ...opts, agentEnv: codexManagedAgent?.env });
      if (!isCurrentRequest()) return;
      setCodexIntegration(integration);
    } catch (err) {
@@ -667,7 +672,7 @@ const SettingsAITab: React.FC<SettingsAITabProps> = ({
        setIsCodexLoading(false);
      }
    }
-  }, []);
+  }, [codexManagedAgent?.env]);

  const codexCommittedPath = useMemo(
    () => getManagedAgentCommandPath(externalAgents, "codex") || codexPathInfo?.path || undefined,
@@ -682,10 +687,6 @@ const SettingsAITab: React.FC<SettingsAITabProps> = ({
    codexCommittedPath
  ), [codexCommittedPath]);

-  const codexManagedAgent = useMemo(
-    () => externalAgents.find((agent) => agent.id === "discovered_codex"),
-    [externalAgents],
-  );
  const codexRuntime = codexManagedAgent?.codexRuntime ?? 'sdk';

  const refreshCodexAppServerStatus = useCallback(async () => {
@@ -861,7 +862,7 @@ const SettingsAITab: React.FC<SettingsAITabProps> = ({
    setCodexError(null);
    setIsCodexLoading(true);
    try {
-      const result = await bridge.aiCodexStartLogin({ codexPath: getCodexPathOverride() });
+      const result = await bridge.aiCodexStartLogin({ codexPath: getCodexPathOverride(), agentEnv: codexManagedAgent?.env });
      if (!isCurrentRequest()) return;
      if (!result.ok || !result.session) {
        throw new Error(result.error || "Failed to start Codex login");
@@ -876,7 +877,7 @@ const SettingsAITab: React.FC<SettingsAITabProps> = ({
        setIsCodexLoading(false);
      }
    }
-  }, [getCodexPathOverride]);
+  }, [getCodexPathOverride, codexManagedAgent?.env]);

  const handleCancelCodexLogin = useCallback(async () => {
    const bridge = getBridge();
@@ -912,7 +913,7 @@ const SettingsAITab: React.FC<SettingsAITabProps> = ({
    setCodexError(null);
    setIsCodexLoading(true);
    try {
-      const result = await bridge.aiCodexLogout({ codexPath: getCodexPathOverride() });
+      const result = await bridge.aiCodexLogout({ codexPath: getCodexPathOverride(), agentEnv: codexManagedAgent?.env });
      if (!isCurrentRequest()) return;
      if (!result.ok) {
        throw new Error(result.error || "Failed to log out from Codex");
@@ -928,7 +929,7 @@ const SettingsAITab: React.FC<SettingsAITabProps> = ({
        setIsCodexLoading(false);
      }
    }
-  }, [getCodexPathOverride, refreshCodexIntegration]);
+  }, [getCodexPathOverride, refreshCodexIntegration, codexManagedAgent?.env]);

  const refreshUserSkillsStatus = useCallback(async () => {
    const bridge = getBridge();
@@ -152,11 +152,11 @@ export interface FetchBridge {
 export interface NetcattyAiBridge {
  aiDiscoverAgents?: (options?: { refreshShellEnv?: boolean; apiKeyPresent?: boolean }) => Promise<Array<AgentPathInfo & { command: string }>>;
  aiPrewarmShellEnv?: () => Promise<{ ok: boolean; error?: string }>;
-  aiCodexGetIntegration?: (options?: { refreshShellEnv?: boolean; validateChatGptAuth?: boolean; codexPath?: string }) => Promise<CodexIntegrationStatus>;
-  aiCodexStartLogin?: (options?: { codexPath?: string }) => Promise<{ ok: boolean; session?: CodexLoginSession; error?: string }>;
+  aiCodexGetIntegration?: (options?: { refreshShellEnv?: boolean; validateChatGptAuth?: boolean; codexPath?: string; agentEnv?: Record<string, string> }) => Promise<CodexIntegrationStatus>;
+  aiCodexStartLogin?: (options?: { codexPath?: string; agentEnv?: Record<string, string> }) => Promise<{ ok: boolean; session?: CodexLoginSession; error?: string }>;
  aiCodexGetLoginSession?: (sessionId: string) => Promise<{ ok: boolean; session?: CodexLoginSession; error?: string }>;
  aiCodexCancelLogin?: (sessionId: string) => Promise<{ ok: boolean; found?: boolean; session?: CodexLoginSession; error?: string }>;
-  aiCodexLogout?: (options?: { codexPath?: string }) => Promise<{ ok: boolean; state?: CodexIntegrationState; isConnected?: boolean; rawOutput?: string; logoutOutput?: string; error?: string }>;
+  aiCodexLogout?: (options?: { codexPath?: string; agentEnv?: Record<string, string> }) => Promise<{ ok: boolean; state?: CodexIntegrationState; isConnected?: boolean; rawOutput?: string; logoutOutput?: string; error?: string }>;
  aiResolveCli?: (params: { command: string; customPath?: string; refreshShellEnv?: boolean; apiKeyPresent?: boolean }) => Promise<AgentPathInfo>;
  aiSdkAgentListModels?: (sdkBackend: string, cwd?: string, providerId?: string, chatSessionId?: string, agentEnv?: Record<string, string>, agentCommand?: string, codexRuntime?: 'sdk' | 'app-server') => Promise<{ ok: boolean; models?: Array<{ id: string; name: string; description?: string; thinkingLevels?: string[]; defaultThinkingLevel?: string }>; currentModelId?: string | null; error?: string }>;
  codexAppServerGetStatus?: (agentCommand?: string, agentEnv?: Record<string, string>) => Promise<{ ok: boolean; available: boolean; error?: string }>;
@@ -5,6 +5,7 @@ import {
  requireCopyToOtherPaneTarget,
  type SftpPaneSide,
 } from "./copyToOtherPane";
+import { resolveSamePanePasteAction } from "../../application/state/sftp/samePanePaste";

 test("copy to other pane is unavailable when the destination pane is missing", () => {
  assert.equal(canCopyToOtherPane({ getActivePane: () => null }, "right"), false);
@@ -62,3 +63,414 @@ test("copy to other pane reports why it cannot start instead of silently returni
  );
  assert.equal(unavailableCount, 1);
 });
+
+test("same-pane copy of files into their own source folder is allowed", async () => {
+  const files = [
+    { name: "report.txt", isDirectory: false },
+    { name: "notes.txt", isDirectory: false },
+  ];
+  assert.equal(
+    await resolveSamePanePasteAction({ operation: "copy", sourcePath: "/home/user", targetPath: "/home/user", files }),
+    "allow",
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({ operation: "copy", sourcePath: "/home/user", targetPath: "/home/user/docs", files }),
+    "allow",
+  );
+});
+
+test("same-pane copy of a directory into itself or a descendant is blocked", async () => {
+  const files = [{ name: "docs", isDirectory: true }];
+  assert.equal(
+    await resolveSamePanePasteAction({ operation: "copy", sourcePath: "/a", targetPath: "/a/docs", files }),
+    "block-into-source",
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({ operation: "copy", sourcePath: "/a", targetPath: "/a/docs/sub", files }),
+    "block-into-source",
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({ operation: "copy", sourcePath: "/a", targetPath: "/a/docs/sub/deep", files }),
+    "block-into-source",
+  );
+});
+
+test("same-pane copy of a directory into a sibling is allowed", async () => {
+  const files = [{ name: "docs", isDirectory: true }];
+  assert.equal(
+    await resolveSamePanePasteAction({ operation: "copy", sourcePath: "/a/docs", targetPath: "/a/sub", files }),
+    "allow",
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({ operation: "copy", sourcePath: "/a/docs", targetPath: "/a/docsx", files }),
+    "allow",
+  );
+});
+
+test("same-pane cut into the source folder is blocked", async () => {
+  const files = [{ name: "report.txt", isDirectory: false }];
+  assert.equal(
+    await resolveSamePanePasteAction({ operation: "cut", sourcePath: "/home/user", targetPath: "/home/user", files }),
+    "block-same-folder",
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({ operation: "cut", sourcePath: "/home/user", targetPath: "/home/user/", files }),
+    "block-same-folder",
+  );
+});
+
+test("same-pane cut of files into a child of the source folder is allowed", async () => {
+  const files = [
+    { name: "report.txt", isDirectory: false },
+    { name: "photos", isDirectory: false },
+  ];
+  assert.equal(
+    await resolveSamePanePasteAction({ operation: "cut", sourcePath: "/home/user", targetPath: "/home/user/docs", files }),
+    "allow",
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({ operation: "cut", sourcePath: "/home/user", targetPath: "/home/user/docs/sub", files }),
+    "allow",
+  );
+});
+
+test("same-pane cut of a directory into itself or a descendant is blocked", async () => {
+  const files = [{ name: "docs", isDirectory: true }];
+  assert.equal(
+    await resolveSamePanePasteAction({ operation: "cut", sourcePath: "/home/user", targetPath: "/home/user/docs", files }),
+    "block-into-source",
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({ operation: "cut", sourcePath: "/home/user", targetPath: "/home/user/docs/sub", files }),
+    "block-into-source",
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({ operation: "cut", sourcePath: "/home/user", targetPath: "/home/user/docs/sub/deep", files }),
+    "block-into-source",
+  );
+});
+
+test("same-pane cut into a sibling folder is allowed", async () => {
+  const files = [{ name: "docs", isDirectory: true }];
+  assert.equal(
+    await resolveSamePanePasteAction({ operation: "cut", sourcePath: "/home/user", targetPath: "/home/other", files }),
+    "allow",
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({ operation: "cut", sourcePath: "/home/user", targetPath: "/home/user2", files }),
+    "allow",
+  );
+});
+
+test("same-pane paste guard understands Windows paths", async () => {
+  const files = [{ name: "docs", isDirectory: true }];
+  assert.equal(
+    await resolveSamePanePasteAction({
+      operation: "cut",
+      sourcePath: "C:\\Users\\me",
+      targetPath: "C:/Users/me",
+      files,
+    }),
+    "block-same-folder",
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({
+      operation: "cut",
+      sourcePath: "C:\\Users\\me",
+      targetPath: "C:\\Users\\me\\docs",
+      files,
+    }),
+    "block-into-source",
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({
+      operation: "copy",
+      sourcePath: "C:\\Users\\me",
+      targetPath: "C:\\Users\\me\\docs",
+      files: [{ name: "report.txt", isDirectory: false }],
+    }),
+    "allow",
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({
+      operation: "cut",
+      sourcePath: "C:\\Users\\me",
+      targetPath: "C:\\Users\\other",
+      files,
+    }),
+    "allow",
+  );
+});
+
+test("same-pane guards canonicalize equivalent path spellings", async () => {
+  const files = [{ name: "docs", isDirectory: true }];
+  assert.equal(
+    await resolveSamePanePasteAction({ operation: "cut", sourcePath: "/home/user", targetPath: "/home/user/.", files }),
+    "block-same-folder",
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({ operation: "cut", sourcePath: "/home/user", targetPath: "/home//user", files }),
+    "block-same-folder",
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({ operation: "cut", sourcePath: "/home/user", targetPath: "/home/user/../user", files }),
+    "block-same-folder",
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({
+      operation: "cut",
+      sourcePath: "/home/user",
+      targetPath: "/home/./user/docs",
+      files,
+    }),
+    "block-into-source",
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({ operation: "cut", sourcePath: "/home/user", targetPath: "/home/userx", files }),
+    "allow",
+  );
+});
+
+test("same-pane guards collapse a leading double slash for POSIX comparisons", async () => {
+  const files = [{ name: "docs", isDirectory: true }];
+  assert.equal(
+    await resolveSamePanePasteAction({ operation: "cut", sourcePath: "/home/user", targetPath: "//home/user", files }),
+    "block-same-folder",
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({
+      operation: "cut",
+      sourcePath: "/home/user",
+      targetPath: "//home/user/docs",
+      files,
+    }),
+    "block-into-source",
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({ operation: "cut", sourcePath: "//home/user", targetPath: "/home/user", files }),
+    "block-same-folder",
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({ operation: "cut", sourcePath: "/home/user", targetPath: "/home/other", files }),
+    "allow",
+  );
+});
+
+test("same-pane guards canonicalize equivalent Windows path spellings", async () => {
+  const files = [{ name: "docs", isDirectory: true }];
+  assert.equal(
+    await resolveSamePanePasteAction({
+      operation: "cut",
+      sourcePath: "C:\\Users\\me",
+      targetPath: "C:\\Users\\me\\.",
+      files,
+    }),
+    "block-same-folder",
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({
+      operation: "cut",
+      sourcePath: "C:\\Users\\me",
+      targetPath: "C:\\Users\\\\me",
+      files,
+    }),
+    "block-same-folder",
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({
+      operation: "cut",
+      sourcePath: "C:\\Users\\me",
+      targetPath: "C:\\Users\\me\\docs\\sub\\..\\docs",
+      files,
+    }),
+    "block-into-source",
+  );
+});
+
+test("same-pane guards keep the separator after UNC share roots", async () => {
+  const files = [{ name: "docs", isDirectory: true }];
+  // Copying docs from \\server\share into \\server\sharedocs (a different
+  // share) must not collide with the source item \\server\share\docs.
+  assert.equal(
+    await resolveSamePanePasteAction({
+      operation: "copy",
+      sourcePath: "\\\\server\\share",
+      targetPath: "\\\\server\\sharedocs",
+      files,
+    }),
+    "allow",
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({
+      operation: "copy",
+      sourcePath: "\\\\server\\share",
+      targetPath: "\\\\server\\share\\docs",
+      files,
+    }),
+    "block-into-source",
+  );
+});
+
+test("same-pane guards resolve filesystem aliases before comparing", async () => {
+  const files = [{ name: "docs", isDirectory: true }];
+  // /a/link -> /a/docs/sub: pasting /a/docs from /a/link must be blocked even
+  // though the lexical paths look unrelated.
+  const aliasedResolver = (path: string) => {
+    const aliases: Record<string, string> = {
+      "/a/link": "/a/docs/sub",
+      "/a/docs": "/a/docs",
+      "/a": "/a",
+    };
+    return Promise.resolve(aliases[path] ?? path);
+  };
+  assert.equal(
+    await resolveSamePanePasteAction({
+      operation: "copy",
+      sourcePath: "/a",
+      targetPath: "/a/link",
+      files,
+      resolvePath: aliasedResolver,
+    }),
+    "block-into-source",
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({
+      operation: "cut",
+      sourcePath: "/a",
+      targetPath: "/a/link",
+      files,
+      resolvePath: aliasedResolver,
+    }),
+    "block-into-source",
+  );
+});
+
+test("same-pane guards still allow unrelated real paths when resolving", async () => {
+  const files = [{ name: "docs", isDirectory: true }];
+  const resolver = (path: string) => {
+    const resolved: Record<string, string> = {
+      "/a/docs": "/data/docs",
+      "/a/other": "/data/other",
+      "/a/docs/docs": "/data/docs/docs",
+    };
+    return Promise.resolve(resolved[path] ?? path);
+  };
+  assert.equal(
+    await resolveSamePanePasteAction({
+      operation: "copy",
+      sourcePath: "/a/docs",
+      targetPath: "/a/other",
+      files,
+      resolvePath: resolver,
+    }),
+    "allow",
+  );
+});
+
+test("same-pane guards fail closed when filesystem resolution fails", async () => {
+  const files = [{ name: "docs", isDirectory: true }];
+  assert.equal(
+    await resolveSamePanePasteAction({
+      operation: "copy",
+      sourcePath: "/a/docs",
+      targetPath: "/a/other",
+      files,
+      resolvePath: () => Promise.reject(new Error("realpath unavailable")),
+    }),
+    "block-into-source",
+  );
+});
+
+test("files-only copy still passes when path resolution is unavailable", async () => {
+  const files = [{ name: "report.txt", isDirectory: false }];
+  assert.equal(
+    await resolveSamePanePasteAction({
+      operation: "copy",
+      sourcePath: "/a",
+      targetPath: "/b",
+      files,
+      resolvePath: () => Promise.reject(new Error("realpath unavailable")),
+    }),
+    "allow",
+  );
+});
+
+test("same-pane cut into a bind-mount alias of the source folder is blocked", async () => {
+  const files = [{ name: "report.txt", isDirectory: false }];
+  // realpath cannot see through bind mounts: /mnt/alias is bind-mounted to /a,
+  // so both sides resolve to themselves and only stat identities match.
+  const resolver = (path: string) => Promise.resolve(path);
+  const statIdentity = (path: string) => Promise.resolve(
+    path === "/a" || path === "/mnt/alias" ? { dev: 42, ino: 7 } : { dev: 42, ino: 9 },
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({
+      operation: "cut",
+      sourcePath: "/a",
+      targetPath: "/mnt/alias",
+      files,
+      resolvePath: resolver,
+      statIdentity,
+    }),
+    "block-same-folder",
+  );
+  // Distinct filesystem identities must not block the cut.
+  assert.equal(
+    await resolveSamePanePasteAction({
+      operation: "cut",
+      sourcePath: "/a",
+      targetPath: "/mnt/other",
+      files,
+      resolvePath: resolver,
+      statIdentity: (path) => Promise.resolve(
+        path === "/a" ? { dev: 42, ino: 7 } : { dev: 42, ino: 8 },
+      ),
+    }),
+    "allow",
+  );
+  // A provider that cannot stat falls through instead of blocking.
+  assert.equal(
+    await resolveSamePanePasteAction({
+      operation: "cut",
+      sourcePath: "/a",
+      targetPath: "/mnt/alias",
+      files,
+      resolvePath: resolver,
+      statIdentity: () => Promise.resolve(null),
+    }),
+    "allow",
+  );
+});
+
+test("same-pane paste into a bind-mount alias of a clipboard directory is blocked", async () => {
+  const files = [{ name: "docs", isDirectory: true }];
+  // /mnt/docs-alias is bind-mounted to /a/docs: pasting /a/docs there names
+  // the same directory, for copy (recursive rediscovery) and cut (the source
+  // delete would remove the freshly pasted entry).
+  const resolver = (path: string) => Promise.resolve(path);
+  const statIdentity = (path: string) => Promise.resolve(
+    path === "/a/docs" || path === "/mnt/docs-alias" ? { dev: 42, ino: 11 } : { dev: 42, ino: 3 },
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({
+      operation: "copy",
+      sourcePath: "/a",
+      targetPath: "/mnt/docs-alias",
+      files,
+      resolvePath: resolver,
+      statIdentity,
+    }),
+    "block-into-source",
+  );
+  assert.equal(
+    await resolveSamePanePasteAction({
+      operation: "cut",
+      sourcePath: "/a",
+      targetPath: "/mnt/docs-alias",
+      files,
+      resolvePath: resolver,
+      statIdentity,
+    }),
+    "block-into-source",
+  );
+});
@@ -21,6 +21,7 @@ import { keepOnlyPaneSelections } from "./selectionScope";
 import type { SftpStateApi } from "../../../application/state/useSftpState";
 import type { UploadEndpointPin } from "../../../application/state/sftp/uploadTargetPin";
 import { filterHiddenFiles, isNavigableDirectory } from "../utils";
+import { resolveSameConnectionPasteAction } from "../../../application/state/sftp/samePanePaste";
 import type { SftpFileEntry } from "../../../types";
 import { extractDropEntries, type DropEntry } from "../../../lib/sftpFileUtils";
 import { toast } from "../../ui/toast";
@@ -351,14 +352,51 @@ export const useSftpKeyboardShortcuts = ({
    const clipboard = sftpClipboardStore.get();
    if (!clipboard || clipboard.files.length === 0) return;

+    // Pin the destination this paste was validated against. Native pastes may
+    // await clipboard reads before reaching here, and the user can navigate or
+    // switch tabs meanwhile — startTransfer would otherwise resolve the
+    // then-active pane and could land inside a directory this guard approved
+    // as safe.
+    const targetConnectionId = pane.connection!.id;
+    const targetPath = pane.connection!.currentPath;
+
    const isSameConnection = clipboard.sourceSide === focusedSide
      && clipboard.sourceConnectionId === pane.connection!.id;
    if (isSameConnection) {
-      toast.info("Paste within the same pane is not supported. Use copy to other pane instead.", "SFTP");
-      return;
+      const connection = pane.connection!;
+      const pasteAction = await resolveSameConnectionPasteAction({
+        operation: clipboard.operation,
+        sourcePath: clipboard.sourcePath,
+        targetPath,
+        files: clipboard.files,
+        isLocal: connection.isLocal,
+        sftpId: connection.isLocal ? null : (sftp.getSftpIdForConnection(connection.id) ?? null),
+      });
+      if (pasteAction === "block-same-folder") {
+        toast.info("The cut items are already in this folder.", "SFTP");
+        return;
+      }
+      if (pasteAction === "block-into-source") {
+        toast.info(
+          clipboard.operation === "cut"
+            ? "A folder can't be moved into itself. Choose a different folder."
+            : "A folder can't be copied into itself or one of its subfolders. Choose a different folder.",
+          "SFTP",
+        );
+        return;
+      }
+      // Same-pane copy (and cut into a different folder) falls through to the
+      // shared transfer path below.
    }

-    const sourceTabs = clipboard.sourceSide === "left" ? sftp.leftTabs.tabs : sftp.rightTabs.tabs;
+    // Re-read live state, not the pre-await snapshot: the same-connection
+    // guard above can await realpath while the user switches tabs, and
+    // startTransfer resolves the currently active pane. Comparing against the
+    // stale snapshot would let the pinned targetPath land on a different
+    // connection (and a cut would then delete the original after the wrong
+    // host received the data).
+    const liveSftp = sftpRef.current;
+    const sourceTabs = clipboard.sourceSide === "left" ? liveSftp.leftTabs.tabs : liveSftp.rightTabs.tabs;
    const sourcePane = sourceTabs.find((tab) => tab.connection?.id === clipboard.sourceConnectionId);

    if (!sourcePane?.connection) {
@@ -426,10 +464,24 @@ export const useSftpKeyboardShortcuts = ({
        updateClipboardAfterCompletion(pendingNames.size === 0);
      };

+      // Abandon the paste when the destination pane changed while the paste
+      // was pending: startTransfer resolves the currently active pane, and a
+      // different connection would receive a path pinned from another host.
+      // Read the live tabs (see the liveSftp note above), not the snapshot
+      // captured before the await.
+      const activeTargetPane = focusedSide === "left"
+        ? liveSftp.leftTabs.tabs.find((tab) => tab.id === liveSftp.leftTabs.activeTabId)
+        : liveSftp.rightTabs.tabs.find((tab) => tab.id === liveSftp.rightTabs.activeTabId);
+      if (!activeTargetPane?.connection || activeTargetPane.connection.id !== targetConnectionId) {
+        toast.info("Paste cancelled: the destination connection changed.", "SFTP");
+        return;
+      }
+
      await sftp.startTransfer(clipboard.files, clipboard.sourceSide, focusedSide, {
        sourcePane,
        sourcePath: clipboard.sourcePath,
        sourceConnectionId: clipboard.sourceConnectionId,
+        targetPath,
        onTransferComplete: handleTransferComplete,
      });
    } catch {
@@ -0,0 +1,53 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import React from 'react';
+import { act, create } from 'react-test-renderer';
+import { CustomThemeEditor } from './CustomThemeEditor';
+import { TERMINAL_THEMES } from '../../infrastructure/config/terminalThemes';
+import type { TerminalTheme } from '../../domain/models';
+
+(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+
+test('intense foreground can be enabled, edited, disabled and saved without changing the palette', async () => {
+  let theme: TerminalTheme = structuredClone(TERMINAL_THEMES[0]);
+  delete theme.colors.foregroundIntense;
+  const palette = { ...theme.colors };
+  let renderer: ReturnType<typeof create>;
+  function Editor() {
+    const [current, setCurrent] = React.useState(theme);
+    return <CustomThemeEditor theme={current} onChange={(next) => { theme = next; setCurrent(next); }} />;
+  }
+  await act(async () => { renderer = create(<Editor />); });
+  const toggle = () => renderer.root.findByProps({ role: 'switch' });
+  const color = () => renderer.root.findAllByType('input').find((input) =>
+    input.props.type === 'color' && input.props['aria-label'] === 'terminal.customTheme.color.foregroundIntense')!;
+  assert.equal(toggle().props['aria-checked'], false);
+  assert.equal(color().props.disabled, true);
+  await act(async () => toggle().props.onClick());
+  assert.equal(theme.colors.foregroundIntense, theme.colors.foreground);
+  await act(async () => color().props.onChange({ target: { value: '#ff8800' } }));
+  assert.equal(theme.colors.foregroundIntense, '#ff8800');
+  assert.equal(JSON.parse(JSON.stringify(theme)).colors.foregroundIntense, '#ff8800');
+  await act(async () => toggle().props.onClick());
+  assert.equal(theme.colors.foregroundIntense, undefined);
+  assert.deepEqual(JSON.parse(JSON.stringify(theme.colors)), palette);
+  await act(async () => renderer.unmount());
+});
+
+test('iTerm import preserves Bold Color and leaves older themes disabled', async () => {
+  const { JSDOM } = await import('jsdom');
+  const { parseItermcolors } = await import('../../infrastructure/parsers/itermcolorsParser');
+  const dom = new JSDOM();
+  const original = globalThis.DOMParser;
+  globalThis.DOMParser = dom.window.DOMParser;
+  const color = (key: string, r: number, g: number, b: number) => `<key>${key}</key><dict><key>Red Component</key><real>${r}</real><key>Green Component</key><real>${g}</real><key>Blue Component</key><real>${b}</real></dict>`;
+  const essential = color('Background Color', 0, 0, 0) + color('Foreground Color', 1, 1, 1);
+  try {
+    assert.equal(parseItermcolors(`<plist><dict>${essential}${color('Bold Color', 1, 0.5, 0)}</dict></plist>`, 'imported')?.colors.foregroundIntense, '#ff8000');
+    assert.equal(parseItermcolors(`<plist><dict>${essential}</dict></plist>`, 'older')?.colors.foregroundIntense, undefined);
+  } finally {
+    if (original === undefined) delete (globalThis as { DOMParser?: typeof DOMParser }).DOMParser;
+    else globalThis.DOMParser = original;
+    dom.window.close();
+  }
+});
@@ -7,16 +7,24 @@
 import React, { useCallback, memo } from 'react';
 import { TerminalTheme } from '../../domain/models';
 import { useI18n } from '../../application/i18n/I18nProvider';
+import { Switch } from '../ui/switch';


 interface ColorFieldDef {
    key: keyof TerminalTheme['colors'];
    labelKey: string;
+    /** Fallback shown when the (optional) field has no value yet. */
+    fallbackKey?: keyof TerminalTheme['colors'];
 }

 const GENERAL_COLORS: ColorFieldDef[] = [
    { key: 'background', labelKey: 'terminal.customTheme.color.background' },
    { key: 'foreground', labelKey: 'terminal.customTheme.color.foreground' },
+    {
+        key: 'foregroundIntense',
+        labelKey: 'terminal.customTheme.color.foregroundIntense',
+        fallbackKey: 'foreground',
+    },
    { key: 'cursor', labelKey: 'terminal.customTheme.color.cursor' },
    { key: 'selection', labelKey: 'terminal.customTheme.color.selection' },
 ];
@@ -47,10 +55,14 @@ const ColorInput = memo(({
    label,
    value,
    onChange,
+    enabled,
+    onEnabledChange,
 }: {
    label: string;
    value: string;
    onChange: (value: string) => void;
+    enabled?: boolean;
+    onEnabledChange?: (enabled: boolean) => void;
 }) => {
    // Local state for text input — allows partial hex while typing
    const [textValue, setTextValue] = React.useState(value);
@@ -76,9 +88,14 @@ const ColorInput = memo(({

    return (
        <div className="flex items-center gap-2">
+            {onEnabledChange && (
+                <Switch checked={enabled} onCheckedChange={onEnabledChange} aria-label={label} />
+            )}
            <div className="relative">
                <input
                    type="color"
+                    aria-label={label}
+                    disabled={enabled === false}
                    value={value}
                    onChange={(e) => onChange(e.target.value)}
                    className="w-6 h-6 rounded cursor-pointer border border-border/50 p-0"
@@ -88,6 +105,8 @@ const ColorInput = memo(({
            <span className="text-[10px] text-muted-foreground flex-1 truncate">{label}</span>
            <input
                type="text"
+                aria-label={label}
+                disabled={enabled === false}
                value={textValue}
                onChange={handleTextChange}
                onBlur={handleBlur}
@@ -114,7 +133,7 @@ export const CustomThemeEditor: React.FC<CustomThemeEditorProps> = ({
 }) => {
    const { t } = useI18n();

-    const updateColor = useCallback((key: keyof TerminalTheme['colors'], value: string) => {
+    const updateColor = useCallback((key: keyof TerminalTheme['colors'], value: string | undefined) => {
        onChange({
            ...theme,
            colors: { ...theme.colors, [key]: value },
@@ -135,12 +154,16 @@ export const CustomThemeEditor: React.FC<CustomThemeEditorProps> = ({
                {title}
            </div>
            <div className="space-y-1">
-                {fields.map(({ key, labelKey }) => (
+                {fields.map(({ key, labelKey, fallbackKey }) => (
                    <ColorInput
                        key={key}
                        label={t(labelKey)}
-                        value={theme.colors[key]}
+                        value={theme.colors[key] ?? (fallbackKey ? theme.colors[fallbackKey] : '') ?? ''}
                        onChange={(v) => updateColor(key, v)}
+                        enabled={key === 'foregroundIntense' ? theme.colors.foregroundIntense !== undefined : undefined}
+                        onEnabledChange={key === 'foregroundIntense'
+                            ? (enabled) => updateColor(key, enabled ? theme.colors.foreground : undefined)
+                            : undefined}
                    />
                ))}
            </div>
@@ -59,6 +59,13 @@ function codePointCellWidth(cp: number): number {
 }

 function graphemeCellWidth(grapheme: string): number {
+  // Emoji-presentation graphemes (base + VS16 / U+FE0F) always render as
+  // 2 cells regardless of the base character's text width.  xterm's
+  // 15-graphemes Unicode provider handles this via getStringCellWidth;
+  // the fallback must detect VS16 explicitly because codePointCellWidth
+  // returns 0 for the variation selector itself and 1 for bases like
+  // U+2764 (heavy black heart) that are outside the standard emoji range.
+  if (grapheme.includes("\uFE0F")) return 2;
  let max = 0;
  for (const ch of grapheme) {
    const w = codePointCellWidth(ch.codePointAt(0) ?? 0);
@@ -176,6 +176,7 @@ export type TerminalSessionStartersContext = {
  isNetworkDevice?: boolean;
  startupCommand?: string;
  noAutoRun?: boolean;
+  recordSerialSnippetInput?: (data: string) => void;
  multiLineRunMode?: TerminalSession["multiLineRunMode"];
  shellType?: TerminalSession["shellType"];
  suppressHostStartupCommandRef?: RefObject<boolean>;
@@ -998,7 +998,7 @@ test("multi-character plain text goes out as per-character writes (#3077)", asyn
  assert.ok(writeLoopIdx >= 0);
  const writeLoop = source.slice(writeLoopIdx, writeLoopIdx + 320);
  assert.match(writeLoop, /for \(const chunk of/);
-  assert.match(writeLoop, /writeToSession\(id, chunk, \{ sensitive \}\)/);
+  assert.match(writeLoop, /writeToSession\(id, chunk, \{ sensitive, serialEraseChar \}\)/);

  // IME commits split the committed glyph, not the Kitty CSI-u encoding.
  assert.match(
@@ -119,6 +119,7 @@ import {
  shouldFlushStaleDeferredImeTextInput,
 } from "./terminalImeTextInput";
 import { formatSerialLocalEcho } from "./serialLocalEcho";
+import { getLastChar, removeLastChar, isPrintableInput } from "../../../domain/serialCharMetrics";
 import { mapTerminalBackspaceInput } from "./terminalBackspaceInput";
 import {
  getTextInputWireChunks,
@@ -239,6 +240,8 @@ export type XTermRuntime = {
  serializeAddon: SerializeAddon;
  searchAddon: SearchAddon;
  dispose: () => void;
+  /** Track the pending final line of a serial snippet left for editing. */
+  recordSerialSnippetInput: (data: string) => void;
  /** Current working directory detected via OSC 7 */
  currentCwd: string | undefined;
  keywordHighlighter: KeywordHighlighter;
@@ -365,6 +368,8 @@ export type CreateXTermRuntimeContext = {
  // Serial-specific options
  serialLocalEcho?: boolean;
  serialLineMode?: boolean;
+  /** Opt-in for devices whose line editor deletes bytes instead of characters. */
+  serialByteOrientedBackspace?: boolean;
  serialLineBufferRef?: RefObject<string>;
  telnetLocalEchoRef?: RefObject<boolean>;
  onTerminalLogData?: (data: string) => void;
@@ -1140,6 +1145,46 @@ export const createXTermRuntime = (ctx: CreateXTermRuntimeContext): XTermRuntime
    writeLocalTerminalDataInOrder(term, nextData, ctx.onTerminalLogData);
  };

+  // Tracks whether the most recent non-backspace input was a printable
+  // character (not an escape sequence or control char).  Backspace byte
+  // expansion is only safe when the cursor is at the end of the typed
+  // buffer — i.e. the last input advanced the cursor, not moved it.
+  //
+  // Starts true when the buffer is empty (new session: cursor is at the
+  // beginning of an empty buffer).  Starts false when the buffer is
+  // nonempty (hibernation wake: the pre-hibernation cursor may have been
+  // moved away from the tail, so we conservatively assume it is not).
+  let lastInputWasPrintable = !ctx.commandBufferRef?.current;
+
+  const restoreSerialTailForEmptyInput = (data: string) => {
+    // Apply the same rule to typed text, pasted text, and editable snippets.
+    // Preserve uncertainty when inserting into an existing edited line.
+    if (!ctx.commandBufferRef.current &&
+      (isPrintableInput(data) || getSingleBracketedPasteLine(data))) {
+      lastInputWasPrintable = true;
+    }
+  };
+
+  const recordSerialTextInput = (data: string) => {
+    const text = data.startsWith("\x1b[200~") && data.endsWith("\x1b[201~")
+      ? data.slice(6, -6)
+      : data;
+    const lastLineBreak = Math.max(text.lastIndexOf("\r"), text.lastIndexOf("\n"));
+    if (lastLineBreak >= 0) {
+      ctx.commandBufferRef.current = "";
+      lastInputWasPrintable = true;
+    }
+    const pendingText = text.slice(lastLineBreak + 1);
+    restoreSerialTailForEmptyInput(pendingText);
+    ctx.commandBufferRef.current += pendingText;
+    return text;
+  };
+
+  const recordSerialSnippetInput = (data: string) => {
+    const text = recordSerialTextInput(data);
+    if (ctx.serialLocalEcho) writeLocalTerminalData(formatSerialLocalEcho(text));
+  };
+
  const handleTerminalInputData = (
    data: string,
    options?: {
@@ -1179,6 +1224,8 @@ export const createXTermRuntime = (ctx: CreateXTermRuntimeContext): XTermRuntime
      ctx.sudoAutofillRef?.current?.dismissOnUserContentInput(logicalData);
    }

+    if (logicalData !== null) restoreSerialTailForEmptyInput(logicalData);
+
    const inputSource = options?.source ?? "terminal";
    const id = ctx.sessionRef.current;
    const dataToWrite = data;
@@ -1263,6 +1310,9 @@ export const createXTermRuntime = (ctx: CreateXTermRuntimeContext): XTermRuntime
      }
    }

+    // Both Enter and a submitted paste start a new, empty input line.
+    if (handledSubmittedInput) lastInputWasPrintable = true;
+
    if (id) {
      prioritizeTerminalInput(
        term,
@@ -1286,25 +1336,80 @@ export const createXTermRuntime = (ctx: CreateXTermRuntimeContext): XTermRuntime
            ctx.terminalBackend.writeToSession(id, nextData, { sensitive });
          },
          writeToTerminal: writeLocalTerminalData,
+          term,
        });
      } else {
-        // Character mode (default): send immediately
-        // When backspaceBehavior is configured, remap the Backspace key output
+        // Character mode sends input immediately. Byte-oriented devices opt in
+        // to expansion in the backend, using the session's actual wire encoder.
+        const isBackspace = dataToWrite === "\x7f" || dataToWrite === "\b";
        const outData = mapTerminalBackspaceInput(dataToWrite, ctx.host.backspaceBehavior);
+        let serialEraseChar: string | undefined;
+        let backspaceCells = 1;
+
+        if (
+          isBackspace &&
+          ctx.host.protocol === "serial" &&
+          ctx.commandBufferRef &&
+          ctx.commandBufferRef.current.length > 0 &&
+          lastInputWasPrintable
+        ) {
+          const lastChar = getLastChar(ctx.commandBufferRef.current);
+          // Always compute display width for local echo, independently of
+          // whether wire-level byte expansion is enabled.  A wide CJK or
+          // emoji grapheme needs its full cell count erased even when
+          // byteOrientedBackspace is disabled (character-aware endpoint).
+          backspaceCells = stringCellWidth(lastChar, term);
+
+          if (ctx.serialByteOrientedBackspace === true) {
+            serialEraseChar = lastChar;
+          }
+        }
+
        ctx.onOutputTriggerUserInputRef?.current?.(outData);
        for (const chunk of getTextInputWireChunks(outData, options?.perCharacterWrites === true)) {
-          ctx.terminalBackend.writeToSession(id, chunk, { sensitive });
+          ctx.terminalBackend.writeToSession(id, chunk, { sensitive, serialEraseChar });
        }

        // Local echo for serial connections only when explicitly enabled
        if (inputSource !== "kitty" && ctx.host.protocol === "serial" && ctx.serialLocalEcho) {
-          const localEcho = formatSerialLocalEcho(dataToWrite);
+          const localEcho = formatSerialLocalEcho(dataToWrite, isBackspace ? backspaceCells : undefined);
          if (localEcho) writeLocalTerminalData(localEcho);
        }
        if (inputSource !== "kitty" && ctx.host.protocol === "telnet" && ctx.telnetLocalEchoRef?.current) {
          const localEcho = formatTelnetLocalEcho(dataToWrite);
          if (localEcho) writeLocalTerminalData(localEcho);
        }
+
+        // Update printable tracking.  Backspace is not printable.
+        // Escape sequences (cursor movements, special keys) and control
+        // chars set lastInputWasPrintable to false — the cursor position
+        // is now unknown.  Printable characters keep the flag as-is:
+        // typing at the end advances the cursor to the end (stays true),
+        // but typing after a cursor movement inserts at the cursor
+        // position, not the buffer end (stays false).
+        //
+        // Bracketed paste (\x1b[200~...\x1b[201~) is special: xterm wraps
+        // pasted text in these markers, so the data starts with ESC and
+        // isPrintableInput returns false.  But the pasted content is
+        // printable.  However, the cursor may not be at the buffer tail
+        // (e.g. after a left-arrow movement), so we keep the flag as-is:
+        // paste at the end keeps confidence, paste after a cursor movement
+        // keeps it unknown.
+        if (!isBackspace) {
+          const isBracketedPaste =
+            dataToWrite.startsWith("\x1b[200~") && dataToWrite.endsWith("\x1b[201~");
+          if (!isBracketedPaste && !isPrintableInput(dataToWrite) && !handledSubmittedInput) {
+            // Escape sequence or control char: cursor position unknown.
+            // Skip when handledSubmittedInput is true: the submission handler
+            // already set lastInputWasPrintable = true (buffer cleared, cursor
+            // at next prompt), and the same \r/\n should not reset it.
+            lastInputWasPrintable = false;
+          }
+          // If printable (non-backspace, non-escape, non-bracketed-paste),
+          // keep flag as-is: typing at the end keeps cursor at end; typing
+          // after a cursor movement keeps cursor not at end.
+          // If bracketed paste, also keep flag as-is (see above).
+        }
      }

      // Use logical data for raw-string broadcast. Transport-specific wire
@@ -1332,17 +1437,25 @@ export const createXTermRuntime = (ctx: CreateXTermRuntimeContext): XTermRuntime
          // Command recording and sudo command preparation happen before the
          // input is written so sudo can receive a one-time prompt marker.
        } else if (logicalData === "\x7f" || logicalData === "\b") {
-          ctx.commandBufferRef.current = ctx.commandBufferRef.current.slice(0, -1);
+          ctx.commandBufferRef.current = removeLastChar(ctx.commandBufferRef.current);
          ctx.scriptRecorderRef?.current?.recordBackspace();
        } else if (logicalData === "\x03") {
          ctx.commandBufferRef.current = "";
          ctx.scriptRecorderRef?.current?.recordClearLine();
+          lastInputWasPrintable = true; // buffer cleared, cursor at start
          // Hard-abort password assist when Ctrl+C reaches the input path
          // (e.g. broadcast peers) so a later su re-arms cleanly (#2191).
          ctx.sudoAutofillRef?.current?.abort();
        } else if (logicalData === "\x15") {
          ctx.commandBufferRef.current = "";
          ctx.scriptRecorderRef?.current?.recordClearLine();
+          lastInputWasPrintable = true;
+        } else if (ctx.host.protocol === "serial" && (
+          isPrintableInput(logicalData) || /[\r\n]/.test(logicalData) ||
+          (logicalData.startsWith("\x1b[200~") && logicalData.endsWith("\x1b[201~"))
+        )) {
+          recordSerialTextInput(logicalData);
+          ctx.scriptRecorderRef?.current?.recordInput(logicalData);
        } else if (logicalData.length === 1 && logicalData.charCodeAt(0) >= 32) {
          ctx.commandBufferRef.current += logicalData;
          ctx.scriptRecorderRef?.current?.recordInput(logicalData);
@@ -1893,6 +2006,7 @@ export const createXTermRuntime = (ctx: CreateXTermRuntimeContext): XTermRuntime
          serialLineBufferRef: ctx.serialLineBufferRef,
          onAutocompleteInput: ctx.onAutocompleteInput,
        });
+        lastInputWasPrintable = true;
        if (ctx.passwordPromptActiveRef) {
          ctx.passwordPromptActiveRef.current = false;
        }
@@ -2858,6 +2972,7 @@ export const createXTermRuntime = (ctx: CreateXTermRuntimeContext): XTermRuntime
    ),
    getKittyKeyboardProtocolEnabled: () => kittyKeyboardProtocolEnabled,
    setKittyKeyboardProtocolEnabled,
+    recordSerialSnippetInput,
    dispose: () => {
      runtimeDisposed = true;
      resizeScheduler.dispose();
@@ -0,0 +1,55 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import test from 'node:test';
+import {fileURLToPath} from 'node:url';
+import vm from 'node:vm';
+import {createRequire} from 'node:module';
+const root=fileURLToPath(new URL('../../../', import.meta.url)).replace(/\/$/, '');
+const require=createRequire(root+'/package.json');
+const ts=require('typescript');
+const bridge=require(root+'/electron/bridges/terminalBridge.cjs');
+test('serial input combinations preserve the preceding device bytes after CJK deletion', async () => {
+const modules = await Promise.all([
+'domain/serialCharMetrics.ts', 'components/terminal/runtime/terminalInputSanitize.ts',
+'components/terminal/runtime/terminalBackspaceInput.ts', 'components/terminal/runtime/terminalPerCharacterInput.ts',
+'components/terminal/runtime/terminalSudoAutofill.ts', 'components/terminal/runtime/terminalCommandExecution.ts',
+'components/terminal/runtime/serialLocalEcho.ts', 'components/terminal/autocomplete/terminalStringCellWidth.ts',
+'components/terminal/runtime/shiftEnterText.ts', 'components/terminal/runtime/terminalStartupCommands.ts',
+].map(p=>import(root+'/'+p)));
+const source=fs.readFileSync(root+'/components/terminal/runtime/createXTermRuntime.ts','utf8');
+const start=source.indexOf('let lastInputWasPrintable =');
+const end=source.indexOf('  let kittyCompositionPending',start);
+const code=ts.transpileModule(source.slice(start,end)+ '\n globalThis.api = {handleTerminalInputData,recordSerialSnippetInput,getConfidence:()=>lastInputWasPrintable};',{compilerOptions:{target:ts.ScriptTarget.ES2022}}).outputText;
+for (const encoding of ['utf-8','gb18030']) {
+for (const insert of ['typed','raw','bracketed','snippet','startup','multi-snippet','multi-startup','bracketed-snippet','multi-raw','multi-bracketed']) {
+for (const prefix of ['fresh','empty-arrow','submit','paste-submit','interrupt','clear']) {
+ let wire=Buffer.alloc(0);
+ const session={encoding, serialPort:{write(data: string | Buffer){for(const byte of Buffer.from(data)) { if(byte===127||byte===8) wire=wire.subarray(0,Math.max(0,wire.length-1)); else wire=Buffer.concat([wire,Buffer.from([byte])]);}}}};
+ bridge.init({sessions:new Map([['s',session]]),electronModule:{}});
+ const ctx={host:{protocol:'serial',id:'h',label:'h'},sessionId:'s',sessionRef:{current:'s'},statusRef:{current:'connected'},commandBufferRef:{current:''},onBroadcastInputRef:{current:null},isBroadcastEnabledRef:{current:false},terminalBackend:{writeToSession(id:string,data:string,opts: {serialEraseChar?: string; sensitive?: boolean}){bridge.writeToSession({}, {sessionId:id,data,...opts})}},serialByteOrientedBackspace:true,serialLocalEcho:false};
+ const env={...Object.assign({},...modules),api: undefined as unknown as {handleTerminalInputData: (data: string) => void; recordSerialSnippetInput: (data: string) => void},ctx,term:{buffer:{active:{cursorX:0,cursorY:0,baseY:0,getLine:()=>undefined}},cols:80},suppressNextTerminalDataBroadcast:false,handlingKittyBroadcast:false,shouldBroadcastTerminalUserInput:()=>false,prioritizeTerminalInput:()=>{},getFlowControllerForTerm:()=>null,shouldSuppressTerminalInputScrollForUserPaste:()=>true,scrollToBottomAfterInput:()=>{},writeLocalTerminalData:()=>{}};
+ vm.runInNewContext(code,env); const {handleTerminalInputData:input,recordSerialSnippetInput:snippet}=env.api;
+ if(prefix==='empty-arrow') input('\x1b[D');
+ if(prefix==='submit') {input('旧');input('\x1b[D');input('\r');}
+ if(prefix==='paste-submit') {input('\x1b[D');input('旧\r');}
+ if(prefix==='interrupt') {input('旧');input('\x1b[D');input('\x03');}
+ if(prefix==='clear') {input('旧');input('\x1b[D');input('\x15');}
+ assert.equal(ctx.commandBufferRef.current,''); wire=Buffer.alloc(0);
+ if(insert==='typed') {input('a');input('b');input('你');input('好');}
+ if(insert==='raw') input('ab你好');
+ if(insert==='multi-raw') input('旧\nab你好');
+ if(insert==='multi-bracketed') input('\x1b[200~旧\nab你好\x1b[201~');
+ if(insert==='bracketed') input('\x1b[200~ab你好\x1b[201~');
+ if(insert==='snippet') {ctx.terminalBackend.writeToSession('s','ab你好',{});snippet('ab你好');}
+ if(insert==='multi-snippet'||insert==='bracketed-snippet') {const text=insert==='multi-snippet'?'旧\nab你好':'\x1b[200~旧\nab你好\x1b[201~';ctx.terminalBackend.writeToSession('s',text,{});snippet(text);}
+ if(insert==='startup'||insert==='multi-startup') await new Promise<void>(resolve => {Object.assign({}, ...modules).scheduleStartupCommand({...ctx, noAutoRun:true, startupCommand:insert==='multi-startup'?'旧\nab你好':'ab你好', hasRunStartupCommandRef:{current:false}, terminalSettings:{startupCommandDelayMs:0}, recordSerialSnippetInput:snippet}, env.term, 's', resolve);});
+ // Device paste framing is a transport protocol, remove it from our byte-deleting model.
+ if(insert==='bracketed'||insert==='bracketed-snippet'||insert==='multi-bracketed') wire=wire.subarray(6,wire.length-6);
+ if(insert==='multi-snippet'||insert==='multi-startup'||insert==='bracketed-snippet'||insert==='multi-raw'||insert==='multi-bracketed') wire=wire.subarray(wire.lastIndexOf(10)+1);
+ input('\x7f');input('\x7f');
+ assert.equal(ctx.commandBufferRef.current,'ab',`${encoding}/${insert}/${prefix} buffer`);
+ assert.equal(wire.toString(),'ab',`${encoding}/${insert}/${prefix} device`);
+}
+}
+}
+});
@@ -35,3 +35,97 @@ test("serial line mode sends every completed line when pasted text ends with ent
  assert.equal(bufferRef.current, "");
  assert.deepEqual(echoes, ["show version", "\r\n", "show clock", "\r\n"]);
 });
+
+test("serial line mode backspace erases one cell for ASCII characters", () => {
+  const echoes: string[] = [];
+  const bufferRef = { current: "abc" };
+
+  handleSerialLineModeInput("\x7f", {
+    bufferRef,
+    localEcho: true,
+    writeToSession: () => {},
+    writeToTerminal: (data) => echoes.push(data),
+  });
+
+  assert.equal(bufferRef.current, "ab");
+  assert.deepEqual(echoes, ["\b \b"]); // 1 cell erased
+});
+
+test("serial line mode backspace erases two cells for CJK characters", () => {
+  const echoes: string[] = [];
+  const bufferRef = { current: "你好" };
+
+  handleSerialLineModeInput("\x7f", {
+    bufferRef,
+    localEcho: true,
+    writeToSession: () => {},
+    writeToTerminal: (data) => echoes.push(data),
+  });
+
+  assert.equal(bufferRef.current, "你");
+  assert.deepEqual(echoes, ["\b \b\b \b"]); // 2 cells erased
+});
+
+test("serial line mode backspace erases two cells for fullwidth characters", () => {
+  const echoes: string[] = [];
+  const bufferRef = { current: "test！" };
+
+  handleSerialLineModeInput("\b", {
+    bufferRef,
+    localEcho: true,
+    writeToSession: () => {},
+    writeToTerminal: (data) => echoes.push(data),
+  });
+
+  assert.equal(bufferRef.current, "test");
+  assert.deepEqual(echoes, ["\b \b\b \b"]); // 2 cells erased
+});
+
+test("serial line mode backspace on empty buffer does nothing", () => {
+  const echoes: string[] = [];
+  const bufferRef = { current: "" };
+
+  handleSerialLineModeInput("\x7f", {
+    bufferRef,
+    localEcho: true,
+    writeToSession: () => {},
+    writeToTerminal: (data) => echoes.push(data),
+  });
+
+  assert.equal(bufferRef.current, "");
+  assert.deepEqual(echoes, []);
+});
+
+test("serial line mode backspace removes full surrogate pair for CJK Extension B", () => {
+  const echoes: string[] = [];
+  const extB = "\u{20000}"; // CJK Extension B, stored as surrogate pair
+  const bufferRef = { current: "a" + extB };
+
+  handleSerialLineModeInput("\x7f", {
+    bufferRef,
+    localEcho: true,
+    writeToSession: () => {},
+    writeToTerminal: (data) => echoes.push(data),
+  });
+
+  // Buffer should have "a" remaining (surrogate pair fully removed).
+  assert.equal(bufferRef.current, "a");
+  // Two cells erased for the wide character.
+  assert.deepEqual(echoes, ["\b \b\b \b"]);
+});
+
+test("serial line mode backspace removes full surrogate pair for emoji", () => {
+  const echoes: string[] = [];
+  const emoji = "\u{1F600}"; // Grinning face, stored as surrogate pair
+  const bufferRef = { current: "hi" + emoji };
+
+  handleSerialLineModeInput("\x7f", {
+    bufferRef,
+    localEcho: true,
+    writeToSession: () => {},
+    writeToTerminal: (data) => echoes.push(data),
+  });
+
+  assert.equal(bufferRef.current, "hi");
+  assert.deepEqual(echoes, ["\b \b\b \b"]);
+});
@@ -1,3 +1,7 @@
+import { getLastChar, removeLastChar } from '../../../domain/serialCharMetrics';
+import { stringCellWidth } from '../autocomplete/terminalStringCellWidth';
+import type { Terminal as XTerm } from '@xterm/xterm';
+
 type StringRef = {
  current: string;
 };
@@ -7,6 +11,8 @@ type SerialLineModeInputOptions = {
  localEcho?: boolean;
  writeToSession: (data: string) => void;
  writeToTerminal: (data: string) => void;
+  /** xterm instance for grapheme-accurate width via UnicodeService. */
+  term?: XTerm | null;
 };

 const submitLine = ({
@@ -52,8 +58,10 @@ export function handleSerialLineModeInput(

  if (data === "\x7f" || data === "\b") {
    if (options.bufferRef.current.length > 0) {
-      options.bufferRef.current = options.bufferRef.current.slice(0, -1);
-      if (options.localEcho) options.writeToTerminal("\b \b");
+      const lastChar = getLastChar(options.bufferRef.current);
+      const cells = stringCellWidth(lastChar, options.term);
+      options.bufferRef.current = removeLastChar(options.bufferRef.current);
+      if (options.localEcho) options.writeToTerminal("\b \b".repeat(cells));
    }
    return;
  }
@@ -1,6 +1,8 @@
-import test from "node:test";
 import assert from "node:assert/strict";
+import test from "node:test";

+import { isPrintableInput } from "../../../domain/serialCharMetrics";
+import { getSingleBracketedPasteLine } from "./terminalSudoAutofill";
 import { formatSerialLocalEcho } from "./serialLocalEcho";

 test("formatSerialLocalEcho echoes printable input and normalizes newlines", () => {
@@ -20,3 +22,109 @@ test("formatSerialLocalEcho renders local editing control keys", () => {
 test("formatSerialLocalEcho ignores single non-display control input", () => {
  assert.equal(formatSerialLocalEcho("\x15"), "");
 });
+
+test("formatSerialLocalEcho returns empty for empty input", () => {
+  assert.equal(formatSerialLocalEcho(""), "");
+});
+
+test("formatSerialLocalEcho erases 1 cell by default for backspace", () => {
+  assert.equal(formatSerialLocalEcho("\x7f"), "\b \b");
+  assert.equal(formatSerialLocalEcho("\x7f", 1), "\b \b");
+});
+
+test("formatSerialLocalEcho erases 2 cells for wide-character backspace", () => {
+  // CJK ideograph = 2 cells; backspace must erase both.
+  assert.equal(formatSerialLocalEcho("\x7f", 2), "\b \b\b \b");
+  assert.equal(formatSerialLocalEcho("\b", 2), "\b \b\b \b");
+});
+
+test("serial byte deletion metadata is forwarded through the runtime input loop", async () => {
+  const { readFile } = await import("node:fs/promises");
+  const source = await readFile(new URL("./createXTermRuntime.ts", import.meta.url), "utf8");
+  assert.match(source, /writeToSession\(id, chunk, \{ sensitive, serialEraseChar \}\)/);
+});
+
+test("both Enter and submitted paste restore serial tail confidence", async () => {
+  const { readFile } = await import("node:fs/promises");
+  const source = await readFile(new URL("./createXTermRuntime.ts", import.meta.url), "utf8");
+  const pasteBranch = source.indexOf("const pastedCommand = logicalData");
+  const restoreTail = source.indexOf("if (handledSubmittedInput) lastInputWasPrintable = true;");
+  const writeInput = source.indexOf("prioritizeTerminalInput(", pasteBranch);
+  assert.ok(pasteBranch > 0 && restoreTail > pasteBranch && restoreTail < writeInput);
+});
+
+test("byte-oriented serial input prevents encoding changes while wire bytes are pending", async () => {
+  const { readFile } = await import("node:fs/promises");
+  const { runInNewContext } = await import("node:vm");
+  const source = await readFile(new URL("../../Terminal.tsx", import.meta.url), "utf8");
+  const handlerStart = source.indexOf("const handleSetTerminalEncoding = useCallback");
+  const start = source.indexOf("if (host.protocol === 'serial'", handlerStart);
+  const end = source.indexOf("setTerminalEncoding(encoding);", start);
+  assert.ok(handlerStart > 0 && start > handlerStart && end > start);
+  const guard = source.slice(start, end);
+  for (const [protocol, byteMode, lineMode, pending, blocked] of [
+    ["serial", true, false, "abc你", true],
+    ["serial", true, false, "", false],
+    ["serial", false, false, "abc你", false],
+    ["serial", true, true, "abc你", false],
+    ["ssh", true, false, "abc你", false],
+  ] as const) {
+    const notices: string[] = [];
+    const state = {host: {protocol}, serialConfig: {byteOrientedBackspace: byteMode, lineMode}, commandBufferRef: {current: pending}, toast: {info: (text: string) => notices.push(text)}, t: (key: string) => key};
+    const changed = runInNewContext(`(() => { ${guard} return true; })()`, state);
+    assert.equal(changed, blocked ? undefined : true);
+    assert.equal(notices.length, blocked ? 1 : 0);
+  }
+});
+
+test("urgent Ctrl+C restores serial tail confidence when it clears pending input", async () => {
+  const { readFile } = await import("node:fs/promises");
+  const source = await readFile(new URL("./createXTermRuntime.ts", import.meta.url), "utf8");
+  assert.match(source, /clearTerminalInputStateForInterrupt\(\{[^]*?\}\);\s*lastInputWasPrintable = true;/);
+});
+
+test("pending serial snippets share runtime editing bookkeeping", async () => {
+  const { readFile } = await import("node:fs/promises");
+  const { runInNewContext } = await import("node:vm");
+  const source = await readFile(new URL("../../Terminal.tsx", import.meta.url), "utf8");
+  const start = source.indexOf("if (host.protocol === 'serial' && noAutoRun");
+  const end = source.indexOf("scrollToBottomAfterProgrammaticInput(data);", start);
+  assert.ok(start > 0 && end > start);
+  for (const [protocol, noAutoRun, isMultiLine, lineMode, tracked] of [
+    ["serial", true, false, false, true],
+    ["serial", false, false, false, false],
+    ["serial", true, true, false, true],
+    ["serial", true, false, true, false],
+    ["ssh", true, false, false, false],
+  ] as const) {
+    const recorded: string[] = [];
+    const state = {host: {protocol}, noAutoRun, isMultiLine, serialConfig: {lineMode}, data: "你", xtermRuntimeRef: {current: {recordSerialSnippetInput: (text: string) => recorded.push(text)}}};
+    runInNewContext(source.slice(start, end), state);
+    assert.deepEqual(recorded, tracked ? ["你"] : []);
+  }
+});
+
+test("serial snippets restore an empty tail but preserve uncertainty on an edited line", async () => {
+  const { readFile } = await import("node:fs/promises");
+  const { runInNewContext } = await import("node:vm");
+  const source = await readFile(new URL("./createXTermRuntime.ts", import.meta.url), "utf8");
+  const start = source.indexOf("const recordSerialSnippetInput = (data: string) => {");
+  const end = source.indexOf("\n  };", start);
+  assert.ok(start > 0 && end > start);
+  const body = source.slice(source.indexOf("{", start) + 1, end);
+  const helperStart = source.indexOf("const restoreSerialTailForEmptyInput = (data: string) => {");
+  const helper = source.slice(helperStart, start).replaceAll("data: string", "data");
+  for (const [pending, confident, localEcho, expected] of [
+    ["", false, true, true],
+    ["", false, false, true],
+    ["abc", false, true, false],
+    ["abc", true, true, true],
+  ] as const) {
+    const echoed: string[] = [];
+    const state = {ctx: {commandBufferRef: {current: pending}, serialLocalEcho: localEcho}, lastInputWasPrintable: confident, data: "你", writeLocalTerminalData: (text: string) => echoed.push(text)};
+    runInNewContext(`(() => { ${helper} ${body} })()`, {...state, isPrintableInput, getSingleBracketedPasteLine, formatSerialLocalEcho, ctx: state.ctx, get lastInputWasPrintable() {return state.lastInputWasPrintable;}, set lastInputWasPrintable(value) {state.lastInputWasPrintable = value;}});
+    assert.equal(state.lastInputWasPrintable, expected);
+    assert.equal(state.ctx.commandBufferRef.current, pending + "你");
+    assert.deepEqual(echoed, localEcho ? ["你"] : []);
+  }
+});
@@ -14,9 +14,17 @@ function normalizeSerialLocalEchoLineEndings(data: string): string {
  return output;
 }

-export function formatSerialLocalEcho(data: string): string {
+/**
+ * Format a terminal input string as local echo for serial connections.
+ *
+ * When `backspaceCells` is provided it overrides the default 1-cell erase
+ * for backspace.  CJK ideographs occupy 2 terminal cells, so the caller
+ * should pass 2 when the character being deleted is wide — otherwise the
+ * local echo only erases half the glyph and leaves a hidden remnant.
+ */
+export function formatSerialLocalEcho(data: string, backspaceCells?: number): string {
  if (!data) return "";
-  if (data === "\x7f" || data === "\b") return "\b \b";
+  if (data === "\x7f" || data === "\b") return "\b \b".repeat(backspaceCells ?? 1);
  if (data === "\x03") return "^C";
  if (data === "\r" || data === "\n" || data.charCodeAt(0) >= 32 || data.length > 1) {
    return normalizeSerialLocalEchoLineEndings(data);
@@ -38,7 +38,7 @@ test("password-prompt input is classified before prompt state reset and cannot b
  );
  assert.match(
    runtimeSource,
-    /for \(const chunk of getTextInputWireChunks\(outData, options\?\.perCharacterWrites === true\)\) \{\s*ctx\.terminalBackend\.writeToSession\(id, chunk, \{ sensitive \}\);\s*\}/u,
+    /for \(const chunk of getTextInputWireChunks\(outData, options\?\.perCharacterWrites === true\)\) \{\s*ctx\.terminalBackend\.writeToSession\(id, chunk, \{ sensitive, serialEraseChar \}\);\s*\}/u,
  );
  assert.match(
    runtimeSource,
@@ -74,6 +74,9 @@ export const scheduleStartupCommand = (
        return;
      }
      ctx.terminalBackend.writeToSession(ctx.sessionRef.current, commandToRun, { automated: true });
+      if (ctx.host.protocol === "serial" && !ctx.serialConfig?.lineMode) {
+        ctx.recordSerialSnippetInput?.(commandToRun);
+      }
      onSettled?.();
    }, delayMs);
    return () => {
@@ -56,3 +56,17 @@ test("terminal memo refreshes when terminal context reader callback changes", ()
    false,
  );
 });
+
+test('terminal memo refreshes for intense foreground edits and toggles', async () => {
+  const { TERMINAL_THEMES } = await import('../../infrastructure/config/terminalThemes');
+  const theme = TERMINAL_THEMES[0];
+  for (const field of ['terminalTheme', 'appearanceTheme'] as const) {
+    const props = { ...baseProps, [field]: theme };
+    const enabled = { ...props, [field]: { ...theme, colors: { ...theme.colors, foregroundIntense: '#ff8800' } } };
+    const recolored = { ...props, [field]: { ...theme, colors: { ...theme.colors, foregroundIntense: '#00ff00' } } };
+    assert.equal(terminalPropsAreEqual(props, enabled), false);
+    assert.equal(terminalPropsAreEqual(enabled, recolored), false);
+    assert.equal(terminalPropsAreEqual(enabled, props), false);
+    assert.equal(terminalPropsAreEqual(enabled, { ...enabled }), true);
+  }
+});
@@ -1,7 +1,7 @@
 import type { TerminalProps } from './terminalHelpers';

 const themeFingerprint = (theme: TerminalProps['terminalTheme'] | undefined): string => (
-  theme?.colors ? `${theme.id}:${theme.colors.background}:${theme.colors.foreground}:${theme.colors.cursor}` : ''
+  theme?.colors ? `${theme.id}:${theme.colors.background}:${theme.colors.foreground}:${theme.colors.foregroundIntense ?? ''}:${theme.colors.cursor}` : ''
 );

 export const terminalPropsAreEqual = (
@@ -0,0 +1,55 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createTerminalReflowReadingPosition } from './terminalReflowReadingPosition';
+import { resolveTerminalReflowScrollAnchor } from './terminalHelpers';
+
+function fixture() {
+  let cols = 80;
+  let text = Array.from({ length: 1000 }, (_, i) => String(i).padStart(4, '0') + ' ').join('');
+  const buffer = {
+    viewportY: 30,
+    get length() { return Math.ceil(text.length / cols) + 30; },
+    get baseY() { return this.length - 25; },
+    getLine(row: number) {
+      const count = Math.ceil(text.length / cols);
+      if (row >= this.length) return undefined;
+      return {
+        isWrapped: row > 0 && row < count,
+        translateToString: () => row < count ? text.slice(row * cols, (row + 1) * cols) : `follower ${row - count}`,
+      };
+    },
+  };
+  const tracker = createTerminalReflowReadingPosition();
+  return {
+    buffer,
+    changeText() { text = text.replace('0480', 'EDIT'); },
+    fit(nextCols: number) {
+      const anchor = tracker.capture(buffer, { oldCols: cols, newCols: nextCols, maxRows: 1030 });
+      cols = nextCols;
+      const row = anchor ? resolveTerminalReflowScrollAnchor(buffer, anchor, 0) : null;
+      if (row !== null) buffer.viewportY = row;
+      tracker.remember(buffer, row === null ? null : anchor);
+    },
+  };
+}
+
+test('continuous shrink and grow retain the original character within the top row', () => {
+  const f = fixture();
+  for (const cols of [...Array.from({ length: 40 }, (_, i) => 79 - i), ...Array.from({ length: 40 }, (_, i) => 41 + i)]) {
+    f.fit(cols);
+    assert.equal(f.buffer.viewportY, Math.floor(2400 / cols));
+  }
+});
+
+test('user scroll and changed visible output establish a new reading position', () => {
+  const f = fixture();
+  f.fit(79);
+  f.buffer.viewportY = 20;
+  f.fit(78);
+  assert.equal(f.buffer.viewportY, Math.floor(20 * 79 / 78));
+  const g = fixture();
+  g.fit(79);
+  g.changeText();
+  g.fit(78);
+  assert.equal(g.buffer.viewportY, Math.floor(30 * 79 / 78));
+});
@@ -0,0 +1,51 @@
+import { captureTerminalReflowScrollAnchor } from './terminalHelpers';
+import type { TerminalReflowScrollAnchor } from './terminalHelpers';
+
+type Buffer = Parameters<typeof captureTerminalReflowScrollAnchor>[0];
+
+/** Keep the character within the top row across consecutive resize frames. */
+export function createTerminalReflowReadingPosition() {
+  let previous: {
+    buffer: Buffer;
+    viewportY: number;
+    anchor: TerminalReflowScrollAnchor;
+    remainder: number;
+  } | null = null;
+
+  return {
+    capture(buffer: Buffer, limits: Parameters<typeof captureTerminalReflowScrollAnchor>[1]) {
+      const anchor = captureTerminalReflowScrollAnchor(buffer, limits);
+      const saved = previous;
+      previous = null;
+      if (!anchor || anchor.containsCursor) return anchor;
+      // A user scroll or changed output establishes a new reading position.
+      if (saved?.buffer === buffer && saved.viewportY === buffer.viewportY
+        && saved.anchor.startRow === anchor.startRow
+        && saved.anchor.charOffset === anchor.charOffset
+        && saved.anchor.textPrefix === anchor.textPrefix
+        && saved.anchor.viewedText === anchor.viewedText
+        && saved.anchor.contextSuffix === anchor.contextSuffix) {
+        anchor.charOffset += saved.remainder;
+        anchor.viewedText = anchor.viewedText?.slice(saved.remainder);
+      }
+      return anchor;
+    },
+    // The caller passes null unless content resolution succeeded. A cursor
+    // follower may change during resize; the resolver already validates that
+    // tolerance. Save its new identity for the next pre-fit comparison.
+    remember(buffer: Buffer, anchor: TerminalReflowScrollAnchor | null) {
+      previous = null;
+      if (!anchor || anchor.containsCursor) return;
+      const current = captureTerminalReflowScrollAnchor(buffer, {
+        maxRows: Number.MAX_SAFE_INTEGER, oldCols: 1, newCols: 1,
+      });
+      // Trim, clamping and failed content resolution must not carry a stale
+      // offset into the next frame. Only retain the sub-row rounding loss.
+      if (!current || current.containsCursor || current.textPrefix !== anchor.textPrefix) return;
+      const remainder = anchor.charOffset - current.charOffset;
+      const rowLength = buffer.getLine(buffer.viewportY)?.translateToString(false).length ?? 0;
+      if (remainder < 0 || remainder >= rowLength) return;
+      previous = { buffer, viewportY: buffer.viewportY, anchor: current, remainder };
+    },
+  };
+}
@@ -37,6 +37,25 @@ test("stringCellWidth ignores combining marks inside a grapheme", () => {
  assert.equal(stringCellWidth("e\u0301"), 1);
 });

+test("stringCellWidth fallback returns 2 for VS16 emoji-presentation grapheme", () => {
+  // Without xterm, the fallback must detect VS16 (U+FE0F) and return 2
+  // even when the base character is outside the standard emoji range.
+  // U+2764 (text heart, not in 0x1F300-0x1FAFF) + U+FE0F → emoji (2 cells)
+  assert.equal(stringCellWidth("\u2764\uFE0F"), 2);
+  // U+00A9 (copyright) + U+FE0F → emoji (2 cells)
+  assert.equal(stringCellWidth("\u00A9\uFE0F"), 2);
+});
+
+test("stringCellWidth fallback returns 2 for VS16 keycap grapheme", () => {
+  // digit + VS16 + combining keycap → emoji-presentation keycap (2 cells)
+  assert.equal(stringCellWidth("1\uFE0F\u20E3"), 2);
+});
+
+test("stringCellWidth fallback returns 1 for text heart without VS16", () => {
+  // U+2764 alone is text presentation, not emoji
+  assert.equal(stringCellWidth("\u2764"), 1);
+});
+
 test("stringCellWidth matches xterm 15-graphemes for common emoji clusters", () => {
  class El {
    tagName: string;
@@ -519,6 +519,7 @@ export function useTerminalEffects(ctx: TerminalEffectsContext) {
          // Serial-specific options
          serialLocalEcho: serialConfig?.localEcho,
          serialLineMode: serialConfig?.lineMode,
+          serialByteOrientedBackspace: serialConfig?.byteOrientedBackspace ?? false,
          serialLineBufferRef,
          telnetLocalEchoRef,
          onTerminalLogData: captureTerminalLogData,
@@ -1047,7 +1048,7 @@ export function useTerminalEffects(ctx: TerminalEffectsContext) {
  }, [status]);


-  const effectiveThemeKey = `${effectiveTheme.id}:${effectiveTheme.colors.background}:${effectiveTheme.colors.foreground}:${effectiveTheme.colors.cursor}`;
+  const effectiveThemeKey = `${effectiveTheme.id}:${effectiveTheme.colors.background}:${effectiveTheme.colors.foreground}:${effectiveTheme.colors.foregroundIntense ?? ""}:${effectiveTheme.colors.cursor}`;

  // Sync xterm theme before browser paint; apply synchronously on visible panes.
  useLayoutEffect(() => {
@@ -196,6 +196,7 @@ function SidePanelSftpSlotInner({
    <div className={sidePanelHiddenPanelClassName(!isVisible)}>
      <SftpSidePanel
        transferOwnerId={`terminal:${tabId}`}
+        ownerTabId={tabId}
        hosts={effectiveHosts}
        writableHosts={hosts}
        sessions={sessions}
@@ -187,7 +187,7 @@ test("import format step keeps destination settings off the main card grid", asy
    "utf8",
  );
  assert.match(source, /data-import-destination-settings="true"/);
-  assert.match(source, /data-import-securecrt-prompt="true"/);
+  assert.match(source, /data-import-source-prompt=\{step === "securecrt-source" \? "securecrt" : "finalshell"\}/);
  assert.match(source, /step === "destination"/);
  assert.match(source, /FolderTree/);
  assert.doesNotMatch(
@@ -70,6 +70,12 @@ const OPTIONS: ImportOption[] = [
    iconSrc: "/import/securecrt.png",
    accept: ".ini,.txt",
  },
+  {
+    format: "finalshell",
+    label: "FinalShell",
+    iconSrc: "/import/file.png",
+    accept: ".json",
+  },
  {
    format: "ssh_config",
    label: "ssh_config",
@@ -106,7 +112,8 @@ type ImportDialogStep =
  | "destination"
  | "ssh-mode"
  | "moba-encoding"
-  | "securecrt-source";
+  | "securecrt-source"
+  | "finalshell-source";

 export function VaultImportDestinationControls({
  mode,
@@ -466,11 +473,11 @@ export const ImportVaultDialog: React.FC<ImportVaultDialogProps> = ({
      format: VaultImportFormat,
      accept: string,
      options?: ImportOptions,
-      secureCrtSource: "folder" | "file" = "folder",
+      source: "folder" | "file" = "folder",
    ) => {
      const input = fileInputRef.current;
      if (!input || !destination) return;
-      const pickerMode = getVaultImportPickerMode(format, secureCrtSource);
+      const pickerMode = getVaultImportPickerMode(format, source);
      pendingFormatRef.current = format;
      pendingOptionsRef.current = { ...options, destination };
      input.accept = accept;
@@ -496,6 +503,8 @@ export const ImportVaultDialog: React.FC<ImportVaultDialogProps> = ({
        setStep("moba-encoding");
      } else if (opt.format === "securecrt") {
        setStep("securecrt-source");
+      } else if (opt.format === "finalshell") {
+        setStep("finalshell-source");
      } else {
        pickFile(opt.format, opt.accept);
      }
@@ -522,10 +531,10 @@ export const ImportVaultDialog: React.FC<ImportVaultDialogProps> = ({
    [mobaMasterPassword, pickFile],
  );

-  const handleSecureCrtChoice = useCallback(
-    (source: "folder" | "file") => {
+  const handleBatchSourceChoice = useCallback(
+    (format: "securecrt" | "finalshell", source: "folder" | "file") => {
      setStep("format");
-      pickFile("securecrt", ".ini", undefined, source);
+      pickFile(format, format === "securecrt" ? ".ini" : ".json", undefined, source);
    },
    [pickFile],
  );
@@ -582,10 +591,10 @@ export const ImportVaultDialog: React.FC<ImportVaultDialogProps> = ({
                <div className="mx-auto flex h-12 w-12 items-center justify-center rounded-2xl border border-border/60 bg-muted/60 text-muted-foreground">
                  <FolderTree className="h-6 w-6" />
                </div>
-              ) : step === "securecrt-source" ? (
+              ) : step === "securecrt-source" || step === "finalshell-source" ? (
                <div className="mx-auto flex h-14 w-14 items-center justify-center">
                  <img
-                    src="/import/securecrt.png"
+                    src={step === "securecrt-source" ? "/import/securecrt.png" : "/import/file.png"}
                    alt=""
                    className="h-10 w-10 object-contain"
                  />
@@ -599,14 +608,16 @@ export const ImportVaultDialog: React.FC<ImportVaultDialogProps> = ({
                  />
                </div>
              )}
-              <DialogTitle className={step === "destination" || step === "securecrt-source" ? "text-lg" : "text-xl"}>
+              <DialogTitle className={step === "destination" || step.endsWith("-source") ? "text-lg" : "text-xl"}>
                {step === "securecrt-source"
                  ? t("vault.import.securecrt.promptTitle")
-                  : step === "destination"
-                    ? t("vault.import.destination.settings")
-                    : t("vault.import.title")}
+                  : step === "finalshell-source"
+                    ? t("vault.import.finalshell.promptTitle")
+                    : step === "destination"
+                      ? t("vault.import.destination.settings")
+                      : t("vault.import.title")}
              </DialogTitle>
-              {step !== "destination" && step !== "securecrt-source" && (
+              {step !== "destination" && !step.endsWith("-source") && (
                <DialogDescription className="mx-auto max-w-xl">
                  {step === "ssh-mode"
                    ? t("vault.import.sshConfig.chooseMode")
@@ -879,11 +890,11 @@ export const ImportVaultDialog: React.FC<ImportVaultDialogProps> = ({
                    {t("common.back")}
                  </button>
                </>
-              ) : step === "securecrt-source" ? (
+              ) : step === "securecrt-source" || step === "finalshell-source" ? (
                <>
                  <div
                    className="grid grid-cols-2 gap-3"
-                    data-import-securecrt-prompt="true"
+                    data-import-source-prompt={step === "securecrt-source" ? "securecrt" : "finalshell"}
                  >
                    <button
                      type="button"
@@ -892,16 +903,19 @@ export const ImportVaultDialog: React.FC<ImportVaultDialogProps> = ({
                        "px-3 py-5 hover:bg-primary/10 hover:border-primary transition-colors",
                        "flex flex-col items-center gap-2.5",
                      )}
-                      onClick={() => handleSecureCrtChoice("folder")}
+                      onClick={() => handleBatchSourceChoice(
+                        step === "securecrt-source" ? "securecrt" : "finalshell",
+                        "folder",
+                      )}
                    >
                      <div className="flex h-11 w-11 items-center justify-center rounded-xl bg-primary/10">
                        <FolderOpen className="h-5 w-5 text-primary" />
                      </div>
                      <div className="text-sm font-medium text-foreground">
-                        {t("vault.import.securecrt.folder")}
+                        {t(`vault.import.${step === "securecrt-source" ? "securecrt" : "finalshell"}.folder`)}
                      </div>
                      <div className="text-xs leading-4 text-muted-foreground text-center">
-                        {t("vault.import.securecrt.folderDesc")}
+                        {t(`vault.import.${step === "securecrt-source" ? "securecrt" : "finalshell"}.folderDesc`)}
                      </div>
                    </button>
                    <button
@@ -911,16 +925,19 @@ export const ImportVaultDialog: React.FC<ImportVaultDialogProps> = ({
                        "px-3 py-5 hover:bg-muted/30 hover:border-border transition-colors",
                        "flex flex-col items-center gap-2.5",
                      )}
-                      onClick={() => handleSecureCrtChoice("file")}
+                      onClick={() => handleBatchSourceChoice(
+                        step === "securecrt-source" ? "securecrt" : "finalshell",
+                        "file",
+                      )}
                    >
                      <div className="flex h-11 w-11 items-center justify-center rounded-xl bg-muted/60">
                        <FileText className="h-5 w-5 text-muted-foreground" />
                      </div>
                      <div className="text-sm font-medium text-foreground">
-                        {t("vault.import.securecrt.file")}
+                        {t(`vault.import.${step === "securecrt-source" ? "securecrt" : "finalshell"}.file`)}
                      </div>
                      <div className="text-xs leading-4 text-muted-foreground text-center">
-                        {t("vault.import.securecrt.fileDesc")}
+                        {t(`vault.import.${step === "securecrt-source" ? "securecrt" : "finalshell"}.fileDesc`)}
                      </div>
                    </button>
                  </div>
@@ -985,7 +1002,7 @@ export const ImportVaultDialog: React.FC<ImportVaultDialogProps> = ({
                    {t("vault.import.chooseFormat")}
                  </div>

-                  <div className="grid grid-cols-2 sm:grid-cols-5 gap-3">
+                  <div className="grid grid-cols-2 sm:grid-cols-3 gap-3">
                    {OPTIONS.map((opt) => (
                      <button
                        key={opt.format}
@@ -893,6 +893,7 @@ export function VaultHostListSection({ ctx }: { ctx: VaultHostListSectionContext
                                <div className="flex-1 min-w-0">
                                  <div className="text-sm font-semibold flex items-center gap-1.5 min-w-0">
                                    <span className="truncate">{node.name}</span>
+                                    <HostNotesIndicator notes={groupConfigs.find((config) => config.path === node.path)?.notes} label="Group notes" />
                                    {!isMultiSelectMode && viewMode !== "grid" && renderGroupEditButton(node.path, true)}
                                    {managedGroupPaths.has(node.path) && (
                                      <span className="inline-flex items-center gap-1 text-[10px] font-medium px-1.5 py-0.5 rounded bg-primary/15 text-primary shrink-0">
@@ -6,6 +6,7 @@
 */
 import { Check, Search, Terminal } from 'lucide-react';
 import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { matchesWorkspaceHostPickerQuery } from '../../lib/searchMatcher';
 import { Host } from '../../types';
 import { DistroAvatar } from '../DistroAvatar';
 import { Button } from '../ui/button';
@@ -112,14 +113,9 @@ export const AddToWorkspaceDialog: React.FC<AddToWorkspaceDialogProps> = ({
  }, [query]);

  const filteredHosts = useMemo(() => {
-    const term = query.trim().toLowerCase();
+    const term = query.trim();
    if (!term) return selectableHosts;
-    return selectableHosts.filter((h) =>
-      (h.label?.toLowerCase().includes(term))
-      || (h.hostname?.toLowerCase().includes(term))
-      || (h.username?.toLowerCase().includes(term))
-      || (h.group?.toLowerCase().includes(term)),
-    );
+    return selectableHosts.filter((host) => matchesWorkspaceHostPickerQuery(term, host));
  }, [selectableHosts, query]);

  const { items, visualRows, itemIndexToVisualIndex } = useMemo(() => {
@@ -305,7 +301,7 @@ export const AddToWorkspaceDialog: React.FC<AddToWorkspaceDialogProps> = ({
              setSelectedIndex(0);
            }}
            onKeyDown={handleKeyDown}
-            placeholder="Search hosts or local shells..."
+            placeholder="Search hosts, tags, or local shells..."
            className="flex-1 h-8 border-0 bg-transparent focus-visible:ring-0 focus-visible:ring-offset-0 px-0 text-sm"
          />
          {workspaceTitle && (
@@ -0,0 +1,238 @@
+const JAVA_RANDOM_MULTIPLIER = 0x5deece66dn;
+const JAVA_RANDOM_ADDEND = 0xbn;
+const JAVA_RANDOM_MASK = (1n << 48n) - 1n;
+
+class JavaRandom {
+  private seed: bigint;
+
+  constructor(seed: bigint) {
+    this.seed = (BigInt.asIntN(64, seed) ^ JAVA_RANDOM_MULTIPLIER) & JAVA_RANDOM_MASK;
+  }
+
+  private next(bits: number): number {
+    this.seed = (this.seed * JAVA_RANDOM_MULTIPLIER + JAVA_RANDOM_ADDEND) & JAVA_RANDOM_MASK;
+    return Number(this.seed >> BigInt(48 - bits));
+  }
+
+  nextInt(bound: number): number {
+    if ((bound & -bound) === bound) {
+      return Math.floor((bound * this.next(31)) / 0x80000000);
+    }
+    let bits: number;
+    let value: number;
+    do {
+      bits = this.next(31);
+      value = bits % bound;
+    } while (((bits - value + (bound - 1)) | 0) < 0);
+    return value;
+  }
+
+  nextLong(): bigint {
+    const high = BigInt.asIntN(32, BigInt(this.next(32)));
+    const low = BigInt.asIntN(32, BigInt(this.next(32)));
+    return BigInt.asIntN(64, (high << 32n) + low);
+  }
+}
+
+const IP = [58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4, 62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48, 40, 32, 24, 16, 8, 57, 49, 41, 33, 25, 17, 9, 1, 59, 51, 43, 35, 27, 19, 11, 3, 61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7];
+const FP = [40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23, 63, 31, 38, 6, 46, 14, 54, 22, 62, 30, 37, 5, 45, 13, 53, 21, 61, 29, 36, 4, 44, 12, 52, 20, 60, 28, 35, 3, 43, 11, 51, 19, 59, 27, 34, 2, 42, 10, 50, 18, 58, 26, 33, 1, 41, 9, 49, 17, 57, 25];
+const E = [32, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9, 8, 9, 10, 11, 12, 13, 12, 13, 14, 15, 16, 17, 16, 17, 18, 19, 20, 21, 20, 21, 22, 23, 24, 25, 24, 25, 26, 27, 28, 29, 28, 29, 30, 31, 32, 1];
+const P = [16, 7, 20, 21, 29, 12, 28, 17, 1, 15, 23, 26, 5, 18, 31, 10, 2, 8, 24, 14, 32, 27, 3, 9, 19, 13, 30, 6, 22, 11, 4, 25];
+const PC1 = [57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18, 10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36, 63, 55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22, 14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4];
+const PC2 = [14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10, 23, 19, 12, 4, 26, 8, 16, 7, 27, 20, 13, 2, 41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48, 44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32];
+const SHIFTS = [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1];
+const SBOXES = [
+  [14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7,0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8,4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0,15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13],
+  [15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10,3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5,0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15,13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9],
+  [10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8,13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1,13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7,1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12],
+  [7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15,13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9,10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4,3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14],
+  [2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9,14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6,4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14,11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3],
+  [12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11,10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8,9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6,4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13],
+  [4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1,13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6,1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2,6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12],
+  [13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7,1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2,7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8,2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11],
+];
+
+const permute = (value: bigint, inputBits: number, table: number[]): bigint => {
+  let result = 0n;
+  for (const position of table) {
+    result = (result << 1n) | ((value >> BigInt(inputBits - position)) & 1n);
+  }
+  return result;
+};
+
+const bytesToBigInt = (bytes: Uint8Array): bigint => {
+  let value = 0n;
+  for (const byte of bytes) value = (value << 8n) | BigInt(byte);
+  return value;
+};
+
+const bigIntToBytes = (value: bigint, length: number): Uint8Array => {
+  const result = new Uint8Array(length);
+  for (let index = length - 1; index >= 0; index--) {
+    result[index] = Number(value & 0xffn);
+    value >>= 8n;
+  }
+  return result;
+};
+
+const createSubkeys = (key: Uint8Array): bigint[] => {
+  const selected = permute(bytesToBigInt(key), 64, PC1);
+  let left = Number((selected >> 28n) & 0xfffffffn);
+  let right = Number(selected & 0xfffffffn);
+  return SHIFTS.map((shift) => {
+    left = ((left << shift) | (left >>> (28 - shift))) & 0xfffffff;
+    right = ((right << shift) | (right >>> (28 - shift))) & 0xfffffff;
+    return permute((BigInt(left) << 28n) | BigInt(right), 56, PC2);
+  });
+};
+
+const feistel = (right: number, subkey: bigint): number => {
+  const expanded = permute(BigInt(right >>> 0), 32, E) ^ subkey;
+  let output = 0;
+  for (let box = 0; box < 8; box++) {
+    const sixBits = Number((expanded >> BigInt(42 - box * 6)) & 0x3fn);
+    const row = ((sixBits & 0x20) >> 4) | (sixBits & 1);
+    const column = (sixBits >> 1) & 0xf;
+    output = (output << 4) | SBOXES[box][row * 16 + column];
+  }
+  return Number(permute(BigInt(output >>> 0), 32, P));
+};
+
+const decryptDesBlock = (block: Uint8Array, subkeys: bigint[]): Uint8Array => {
+  const initial = permute(bytesToBigInt(block), 64, IP);
+  let left = Number((initial >> 32n) & 0xffffffffn);
+  let right = Number(initial & 0xffffffffn);
+  for (let round = 15; round >= 0; round--) {
+    const next = (left ^ feistel(right, subkeys[round])) >>> 0;
+    left = right;
+    right = next;
+  }
+  return bigIntToBytes(permute((BigInt(right) << 32n) | BigInt(left), 64, FP), 8);
+};
+
+const add32 = (...values: number[]): number => values.reduce((sum, value) => (sum + value) >>> 0, 0);
+const rotateLeft = (value: number, shift: number): number => ((value << shift) | (value >>> (32 - shift))) >>> 0;
+
+const md5 = (input: Uint8Array): Uint8Array => {
+  const bitLength = BigInt(input.length) * 8n;
+  const paddedLength = Math.ceil((input.length + 9) / 64) * 64;
+  const padded = new Uint8Array(paddedLength);
+  padded.set(input);
+  padded[input.length] = 0x80;
+  for (let index = 0; index < 8; index++) padded[paddedLength - 8 + index] = Number((bitLength >> BigInt(index * 8)) & 0xffn);
+
+  let a0 = 0x67452301;
+  let b0 = 0xefcdab89;
+  let c0 = 0x98badcfe;
+  let d0 = 0x10325476;
+  const shifts = [7,12,17,22,7,12,17,22,7,12,17,22,7,12,17,22,5,9,14,20,5,9,14,20,5,9,14,20,5,9,14,20,4,11,16,23,4,11,16,23,4,11,16,23,4,11,16,23,6,10,15,21,6,10,15,21,6,10,15,21,6,10,15,21];
+  const constants = Array.from({ length: 64 }, (_, index) => Math.floor(Math.abs(Math.sin(index + 1)) * 0x100000000) >>> 0);
+
+  for (let offset = 0; offset < padded.length; offset += 64) {
+    const words = new Uint32Array(16);
+    for (let index = 0; index < 16; index++) {
+      const start = offset + index * 4;
+      words[index] = padded[start] | (padded[start + 1] << 8) | (padded[start + 2] << 16) | (padded[start + 3] << 24);
+    }
+    let a = a0;
+    let b = b0;
+    let c = c0;
+    let d = d0;
+    for (let index = 0; index < 64; index++) {
+      let f: number;
+      let wordIndex: number;
+      if (index < 16) {
+        f = (b & c) | (~b & d);
+        wordIndex = index;
+      } else if (index < 32) {
+        f = (d & b) | (~d & c);
+        wordIndex = (5 * index + 1) % 16;
+      } else if (index < 48) {
+        f = b ^ c ^ d;
+        wordIndex = (3 * index + 5) % 16;
+      } else {
+        f = c ^ (b | ~d);
+        wordIndex = (7 * index) % 16;
+      }
+      const previousD = d;
+      d = c;
+      c = b;
+      b = add32(b, rotateLeft(add32(a, f, constants[index], words[wordIndex]), shifts[index]));
+      a = previousD;
+    }
+    a0 = add32(a0, a);
+    b0 = add32(b0, b);
+    c0 = add32(c0, c);
+    d0 = add32(d0, d);
+  }
+
+  const output = new Uint8Array(16);
+  [a0, b0, c0, d0].forEach((word, wordIndex) => {
+    for (let byte = 0; byte < 4; byte++) output[wordIndex * 4 + byte] = (word >>> (byte * 8)) & 0xff;
+  });
+  return output;
+};
+
+const signedByte = (value: number): bigint => BigInt(value > 127 ? value - 256 : value);
+
+const decodeBase64 = (value: string): Uint8Array | undefined => {
+  if (!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(value)) return undefined;
+  try {
+    const binary = atob(value);
+    const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+    const canonical = btoa(String.fromCharCode(...bytes));
+    return canonical === value ? bytes : undefined;
+  } catch {
+    return undefined;
+  }
+};
+
+const deriveKey = (head: Uint8Array): Uint8Array | undefined => {
+  const divisor = new JavaRandom(signedByte(head[5])).nextInt(127);
+  if (divisor === 0) return undefined;
+  const random = new JavaRandom(BigInt.asIntN(64, 3680984568597093857n / BigInt(divisor)));
+  const iterations = Number(signedByte(head[0]));
+  for (let index = 0; index < iterations; index++) random.nextLong();
+  const secondRandom = new JavaRandom(random.nextLong());
+  const longs = [
+    signedByte(head[4]),
+    secondRandom.nextLong(),
+    signedByte(head[7]),
+    signedByte(head[3]),
+    secondRandom.nextLong(),
+    signedByte(head[1]),
+    random.nextLong(),
+    signedByte(head[2]),
+  ];
+  const source = new Uint8Array(64);
+  longs.forEach((value, index) => source.set(bigIntToBytes(BigInt.asUintN(64, value), 8), index * 8));
+  return md5(source).slice(0, 8);
+};
+
+export const decodeFinalShellPassword = (encoded: string): string | undefined => {
+  const decoded = decodeBase64(encoded);
+  if (!decoded || decoded.length < 16 || (decoded.length - 8) % 8 !== 0) return undefined;
+  const key = deriveKey(decoded.slice(0, 8));
+  if (!key) return undefined;
+  const subkeys = createSubkeys(key);
+  const ciphertext = decoded.slice(8);
+  const plaintext = new Uint8Array(ciphertext.length);
+  for (let offset = 0; offset < ciphertext.length; offset += 8) {
+    plaintext.set(decryptDesBlock(ciphertext.slice(offset, offset + 8), subkeys), offset);
+  }
+  const padding = plaintext[plaintext.length - 1];
+  if (padding < 1 || padding > 8) return undefined;
+  for (let index = plaintext.length - padding; index < plaintext.length; index++) {
+    if (plaintext[index] !== padding) return undefined;
+  }
+  try {
+    const password = new TextDecoder("utf-8", { fatal: true }).decode(plaintext.slice(0, -padding));
+    const hasControlCharacters = Array.from(password).some((character) => {
+      const code = character.charCodeAt(0);
+      return code <= 0x1f || (code >= 0x7f && code <= 0x9f);
+    });
+    return password && !hasControlCharacters ? password : undefined;
+  } catch {
+    return undefined;
+  }
+};
@@ -581,3 +581,10 @@ test("applyGroupDefaults keeps host algorithm overrides instead of inheriting",
  );
  assert.deepEqual(result.algorithms, hostOverrides);
 });
+
+test("group notes survive sanitization but are not connection defaults", () => {
+  const config = { path: "Project", notes: "# VPN\nConnect before SSH.", username: "admin" };
+  assert.equal(sanitizeGroupConfig(config).notes, config.notes);
+  assert.equal(resolveGroupDefaults("Project", [config]).notes, undefined);
+  assert.equal(resolveGroupDefaults("Project/Servers", [config]).notes, undefined);
+});
@@ -116,7 +116,7 @@ export function resolveGroupDefaults(
        ) {
          continue;
        }
-        if (key !== 'path' && value !== undefined) {
+        if (key !== 'path' && key !== 'notes' && value !== undefined) {
          if (key === 'proxyProfileId') {
            delete merged.proxyConfig;
          }
@@ -127,6 +127,12 @@ export interface SerialConfig {
  lineMode?: boolean; // Line mode - buffer input and send on Enter (default: false)
  // Store the default explicitly so an open/restored session keeps its launch-time behavior.
  backspaceBehavior?: 'default' | 'ctrl-h';
+  // Byte-oriented backspace: when explicitly enabled, a Backspace deletes the
+  // whole multi-byte character by sending one DEL per wire byte (correct for
+  // MCUs/routers that remove bytes).  Set to false for character-aware line
+  // editors (e.g. a Linux console with readline) where one DEL already
+  // removes a whole character and repeating it would over-delete.
+  byteOrientedBackspace?: boolean;
 }

 // Per-protocol configuration
@@ -406,6 +412,8 @@ export interface GroupNode {
 /** Default configuration for a group. Hosts in this group inherit these values when not explicitly set. */
 export interface GroupConfig {
  path: string;
+  /** Markdown notes for this group only; not inherited by hosts or subgroups. */
+  notes?: string;
  order?: number;
  username?: string;
  password?: string;
@@ -27,6 +27,9 @@ export interface PortForwardingRule {
  hostId?: string;
  // Auto-start: if true, this rule will automatically start when the app launches
  autoStart?: boolean;
+  // Auto-reconnect: if true, the tunnel automatically reconnects (with bounded
+  // retries) after an unexpected disconnect, regardless of auto-start
+  autoReconnect?: boolean;
  /**
   * Runtime projection for the UI. Authoritative phase lives in the Electron
   * main-process registry; this field is rebuilt from snapshots / events and
@@ -569,6 +569,13 @@ export interface TerminalTheme {
  colors: {
    background: string;
    foreground: string;
+    /**
+     * Optional intense variant for bold text drawn with the default foreground
+     * (SGR 1 / SGR 39;1). When set and different from `foreground`, bold text
+     * without an explicit ANSI color renders with this color instead (#3352).
+     * Explicit ANSI colors keep the existing normal/bright palette behavior.
+     */
+    foregroundIntense?: string;
    cursor: string;
    selection: string;
    black: string;
@@ -23,6 +23,15 @@ const parsePort = (value: unknown, name: string): Result<number> => {
    : { ok: false, error: `${name} must be an integer between 1 and 65535.` };
 };

+const parseToggle = (value: unknown, name: string): Result<boolean | undefined> => {
+  if (value === undefined) return { ok: true, value: undefined };
+  if (typeof value === 'boolean') return { ok: true, value };
+  const normalized = String(value).trim().toLowerCase();
+  if (['true', '1', 'yes'].includes(normalized)) return { ok: true, value: true };
+  if (['false', '0', 'no'].includes(normalized)) return { ok: true, value: false };
+  return { ok: false, error: `${name} must be true or false.` };
+};
+
 export const validatePortForwardingHost = (
  hosts: Host[],
  hostId: string | undefined,
@@ -61,16 +70,12 @@ function buildRule(
    remotePort = parsedRemotePort.value;
  }
  if (!existing && !newRule) return { ok: false, error: 'New rule id and timestamp are required.' };
-  let autoStart = existing?.autoStart ?? false;
-  if (source.autoStart !== undefined) {
-    if (typeof source.autoStart === 'boolean') autoStart = source.autoStart;
-    else {
-      const normalized = String(source.autoStart).trim().toLowerCase();
-      if (['true', '1', 'yes'].includes(normalized)) autoStart = true;
-      else if (['false', '0', 'no'].includes(normalized)) autoStart = false;
-      else return { ok: false, error: 'autoStart must be true or false.' };
-    }
-  }
+  const autoStartToggle = parseToggle(source.autoStart, 'autoStart');
+  if ('error' in autoStartToggle) return autoStartToggle;
+  const autoStart = autoStartToggle.value ?? existing?.autoStart ?? false;
+  const autoReconnectToggle = parseToggle(source.autoReconnect, 'autoReconnect');
+  if ('error' in autoReconnectToggle) return autoReconnectToggle;
+  const autoReconnect = autoReconnectToggle.value ?? existing?.autoReconnect;
  return {
    ok: true,
    value: {
@@ -82,6 +87,7 @@ function buildRule(
      ...(type === 'dynamic' ? {} : { remoteHost, remotePort }),
      hostId,
      autoStart,
+      ...(autoReconnect === undefined ? {} : { autoReconnect }),
      status: existing?.status ?? 'inactive',
      error: existing?.error,
      lastUsedAt: existing?.lastUsedAt,
@@ -0,0 +1,23 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { isPortForwardingAutoReconnectEnabled } from "./portForwardingReconnect";
+
+describe("isPortForwardingAutoReconnectEnabled", () => {
+  it("returns true when autoReconnect is enabled", () => {
+    assert.equal(isPortForwardingAutoReconnectEnabled({ autoReconnect: true }), true);
+  });
+
+  it("returns true for auto-start rules (pre-existing behavior)", () => {
+    assert.equal(isPortForwardingAutoReconnectEnabled({ autoStart: true }), true);
+  });
+
+  it("honors explicit disable even for auto-start rules", () => {
+    assert.equal(isPortForwardingAutoReconnectEnabled({ autoStart: true, autoReconnect: false }), false);
+  });
+
+  it("returns false when neither flag opts in", () => {
+    assert.equal(isPortForwardingAutoReconnectEnabled({}), false);
+    assert.equal(isPortForwardingAutoReconnectEnabled({ autoStart: false }), false);
+    assert.equal(isPortForwardingAutoReconnectEnabled({ autoReconnect: false }), false);
+  });
+});
@@ -0,0 +1,12 @@
+import type { PortForwardingRule } from "./models";
+
+/**
+ * Whether a port-forwarding rule should automatically reconnect (with bounded
+ * retries) after an unexpected disconnect.
+ *
+ * Legacy rules without `autoReconnect` retain their auto-start reconnect
+ * behavior. An explicit choice always takes precedence.
+ */
+export const isPortForwardingAutoReconnectEnabled = (
+  rule: Pick<PortForwardingRule, "autoStart" | "autoReconnect">,
+): boolean => rule.autoReconnect ?? rule.autoStart === true;
@@ -7,6 +7,7 @@ import {
  getHostSearchMatch,
  matchesHostSearchQuery,
  matchesSearchQuery,
+  matchesWorkspaceHostPickerQuery,
  resetPinyinCacheForTests,
 } from "../lib/searchMatcher.ts";

@@ -136,6 +137,57 @@ test("host search avoids compact hostname false positives on numeric segments",
  );
 });

+test("host search matches tags without requiring the label or group", () => {
+  assert.equal(
+    matchesHostSearchQuery("prod", {
+      label: "web-1",
+      hostname: "10.0.0.8",
+      group: "infra",
+      tags: ["prod", "k8s"],
+    }),
+    true,
+  );
+  assert.equal(
+    matchesHostSearchQuery("prod", {
+      label: "web-1",
+      hostname: "10.0.0.8",
+      group: "infra",
+      tags: ["staging"],
+    }),
+    false,
+  );
+});
+
+test("workspace picker search matches tags and usernames", () => {
+  assert.equal(
+    matchesWorkspaceHostPickerQuery("k8s", {
+      label: "api-gateway",
+      hostname: "10.0.0.9",
+      group: "edge",
+      tags: ["k8s", "prod"],
+    }),
+    true,
+  );
+  assert.equal(
+    matchesWorkspaceHostPickerQuery("deploy", {
+      label: "api-gateway",
+      hostname: "10.0.0.9",
+      username: "deploy",
+      tags: [],
+    }),
+    true,
+  );
+  assert.equal(
+    matchesWorkspaceHostPickerQuery("k8s", {
+      label: "api-gateway",
+      hostname: "10.0.0.9",
+      username: "deploy",
+      tags: ["prod"],
+    }),
+    false,
+  );
+});
+
 test("host search scoring favors label over group when both match", () => {
  const labelHit = getHostSearchMatch("山东 6-1", {
    label: "山东-业务交换机6-1",