fix(plugins): align host confirmation and refuse managed drafts

# Conflicts:
#	electron/plugins/hostService.cjs
#	packages/plugin-cli/src/manifest.ts
#	packages/plugin-contract/src/index.ts
#	packages/plugin-sdk/src/index.ts

.github/workflows/build.yml

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

.github/workflows/test.yml

@@ -49,6 +49,12 @@ jobs:
       - name: Verify Codex App Server schema
         run: npm run check:codex-app-server-schema
 
+      - name: Verify plugin contract and runtime boundaries
+        run: |
+          npm run check:plugin-contract
+          npm run test:plugin-runtime
+          node --test --import tsx components/settings/tabs/Plugin*.test.tsx
+
       - name: Test
         run: npm test
 
@@ -91,6 +97,9 @@ jobs:
       - name: Install deps
         run: npm ci --ignore-scripts
 
+      - name: Exercise serial named pipe transport on Windows
+        run: node --test electron/bridges/serialNamedPipe.test.cjs
+
       - name: Apply production dependency patches
         run: npx patch-package --error-on-fail
 

AGENTS.md

@@ -106,10 +106,13 @@ Placement rules (`resolveAgentKinds` in `toolSurfaces.cjs`):
 
 **Harness domain (`catalog/harness.cjs`):** Catty executes these locally in `capabilityTools.executeLocalCattyCapability`. The read-only `harness.terminal.read_context` also exposes `netcatty/readContext` to MCP, with scope validation before and after the existing renderer bridge call. It reuses the sidebar reader through the screen snapshot registry (80 rows by default, maximum 300); no script or command runs. Other harness tools remain Catty-only. `harness.web.search` is omitted when web search is not configured.
 
-## Plugin host runtime (internal preview)
+## Plugin host runtime
 
-The phase-2 plugin host lives under `electron/plugins/` and is disabled unless
-`NETCATTY_PLUGIN_DEV=1` is present at application launch. Public wire and package
+The plugin host under `electron/plugins/` exposes browser-only packages in normal
+Settings. `NETCATTY_PLUGIN_DEV=1` admits advanced development packages, without
+granting their permissions. Admission and default placement share
+`domain/pluginRuntimePolicy.cjs`; permission explanations shared with native
+prompts live in `domain/pluginPermissionDescriptions.cjs`. Public wire and package
 types still come only from `packages/plugin-contract/schema/`; do not add a
 second private RPC shape when extending the host.
 

App.tsx

@@ -12,6 +12,8 @@ import { ToastProvider } from './components/ui/toast';
 import { TooltipProvider } from './components/ui/tooltip';
 import { ScriptAutomationRoot } from './components/scripts/ScriptAutomationRoot';
 import { ExternalMcpApprovalsHost } from './components/ai/ExternalMcpApprovalsHost';
+import { PluginHostInteractionHost } from './components/plugins/PluginHostInteractionHost';
+import { PluginHostActionHost } from './components/plugins/PluginHostActionHost';
 import { PluginAuthenticationHost } from './components/plugins/PluginAuthenticationHost';
 import { MultilinePasteConfirmHost } from './components/terminal/MultilinePasteConfirmDialog';
 import { useExternalMcpGrantPersister } from './components/ai/useExternalMcpGrantPersister';
@@ -86,10 +88,12 @@ function AppWithProviders({ settings, appLock }: { settings: SettingsState; appL
               <ScriptAutomationRoot />
               <ExternalMcpApprovalsHost />
               <PluginAuthenticationHost />
+              <PluginHostInteractionHost />
               <MultilinePasteConfirmHost />
               <VaultPublisher>
                 <SessionPublisher persistSessionRestore={!isPeerSessionWindow}>
                   <App />
+                  <PluginHostActionHost />
                 </SessionPublisher>
               </VaultPublisher>
             </TooltipProvider>

application/app/AppHandlers.ts

@@ -1164,6 +1164,7 @@ export function handleConnectToHostImpl(getCtx: AppContextGetter, host: Host, hi
     if (effectiveHost.protocol === 'serial') {
       const portName = host.hostname.split('/').pop() || host.hostname;
       const sessionId = connectToHost(effectiveHost, { hidden });
+      if (!sessionId) return null;
       addConnectionLog({
         sessionId,
         hostId: host.id,
@@ -1183,6 +1184,7 @@ export function handleConnectToHostImpl(getCtx: AppContextGetter, host: Host, hi
     const protocol = resolveEffectiveTerminalProtocol(effectiveHost);
     const resolvedAuth = resolveHostAuth({ host: effectiveHost, keys, identities });
     const sessionId = connectToHost(effectiveHost, { hidden });
+    if (!sessionId) return null;
     addConnectionLog({
       sessionId,
       hostId: host.id,

application/app/AppHandlers.workspaceHostOpen.test.ts

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

application/app/AppSideEffects.tsx

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

application/app/AppView.tsx

@@ -167,7 +167,8 @@ function AppPluginKeybindingThemeHost({
   sessions: any[];
   workspaces: any[];
 }) {
-  const appThemeStyle = useAppThemeStyle();
+  // View environment is global in the current host: publish committed colors only.
+  const appThemeStyle = useAppThemeStyle(false);
   const { resolvedTheme, uiLanguage } = useSettingsChromeStore();
   const pluginThemeTokens = useMemo(
     () => selectPluginThemeTokens(appThemeStyle as Record<string, unknown>),

application/app/__fixtures__/transferQuitRenderer.cjs

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

application/app/publishers/SessionPublisher.tsx

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

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

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

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

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

application/app/useAppStartupEffects.transferQuit.test.ts

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

application/app/useAppStartupEffects.ts

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

application/app/useAppThemeStyle.ts

@@ -1,3 +1,4 @@
+import { usePluginThemeRevision } from '../state/usePluginThemeRuntime';
 import type React from 'react';
 import { useMemo } from 'react';
 
@@ -12,17 +13,20 @@ import { getUiThemeById } from '../../infrastructure/config/uiThemes';
  * settingsChromeStore so accent drags only re-render the leaf that applies the
  * vars, never the App shell.
  */
-export function useAppThemeStyle(): React.CSSProperties {
+export function useAppThemeStyle(includePreview = true): React.CSSProperties {
+  const pluginThemeRevision = usePluginThemeRevision();
   const { accentMode, customAccent } = useAppearanceChromeStore();
   const { resolvedTheme, darkUiThemeId, lightUiThemeId } = useSettingsChromeStore();
   return useMemo(() => {
+    void pluginThemeRevision; // getUiThemeById reads this external registry revision.
     const tokens = getUiThemeById(
       resolvedTheme,
       resolvedTheme === 'dark' ? darkUiThemeId : lightUiThemeId,
+      includePreview,
     ).tokens;
     return {
       ...buildAppThemeCssVars(tokens, accentMode, customAccent),
       colorScheme: resolvedTheme,
     } as React.CSSProperties;
-  }, [accentMode, customAccent, darkUiThemeId, lightUiThemeId, resolvedTheme]);
+  }, [accentMode, customAccent, darkUiThemeId, lightUiThemeId, resolvedTheme, pluginThemeRevision, includePreview]);
 }

application/i18n/locales/en/core.ts

@@ -964,9 +964,53 @@ Highlight the focused split pane:
   'settings.shortcuts.category.terminal': 'Terminal',
   'settings.shortcuts.category.navigation': 'Navigation',
   'settings.shortcuts.category.app': 'App',
-  'settings.shortcuts.binding.toggle-host-tree': 'Toggle Host List',
   'settings.shortcuts.category.sftp': 'SFTP',
 
+  // Settings > Shortcuts -> key bindings
+  'settings.shortcuts.binding.switch-tab-1-9': 'Switch to Tab [1...9]',
+  'settings.shortcuts.binding.next-tab': 'Next Tab',
+  'settings.shortcuts.binding.prev-tab': 'Previous Tab',
+  'settings.shortcuts.binding.close-tab': 'Close Tab',
+  'settings.shortcuts.binding.close-session': 'Close Session Pane',
+  'settings.shortcuts.binding.new-tab': 'New Local Tab',
+  'settings.shortcuts.binding.copy': 'Copy from Terminal',
+  'settings.shortcuts.binding.paste': 'Paste to Terminal',
+  'settings.shortcuts.binding.paste-selection': 'Paste Selection to Terminal',
+  'settings.shortcuts.binding.select-all': 'Select All in Terminal',
+  'settings.shortcuts.binding.clear-buffer': 'Clear Terminal Buffer',
+  'settings.shortcuts.binding.search-terminal': 'Open Terminal Search',
+  'settings.shortcuts.binding.increase-terminal-font-size': 'Increase Terminal Font Size',
+  'settings.shortcuts.binding.decrease-terminal-font-size': 'Decrease Terminal Font Size',
+  'settings.shortcuts.binding.reset-terminal-font-size': 'Reset Terminal Font Size',
+  'settings.shortcuts.binding.move-focus': 'Move focus between Split View panes',
+  'settings.shortcuts.binding.split-horizontal': 'Split Horizontal',
+  'settings.shortcuts.binding.split-vertical': 'Split Vertical',
+  'settings.shortcuts.binding.toggle-pane-zoom': 'Toggle Pane Zoom',
+  'settings.shortcuts.binding.open-hosts': 'Open Hosts Page',
+  'settings.shortcuts.binding.open-local': 'Open Local Terminal',
+  'settings.shortcuts.binding.open-sftp': 'Open SFTP',
+  'settings.shortcuts.binding.port-forwarding': 'Open Port Forwarding',
+  'settings.shortcuts.binding.command-palette': 'Open Command Palette',
+  'settings.shortcuts.binding.quick-switch': 'Quick Switch',
+  'settings.shortcuts.binding.new-workspace': 'New Workspace',
+  'settings.shortcuts.binding.snippets': 'Open Snippets',
+  'settings.shortcuts.binding.broadcast': 'Switch the Broadcast Mode',
+  'settings.shortcuts.binding.toggle-side-panel': 'Toggle Side Panel',
+  'settings.shortcuts.binding.toggle-host-tree': 'Toggle Host List',
+  'settings.shortcuts.binding.open-settings': 'Open Settings',
+  'settings.shortcuts.binding.toggle-opacity': 'Toggle Window Transparency',
+  'settings.shortcuts.binding.sftp-copy': 'Copy Files',
+  'settings.shortcuts.binding.sftp-cut': 'Cut Files',
+  'settings.shortcuts.binding.sftp-paste': 'Paste Files',
+  'settings.shortcuts.binding.sftp-select-all': 'Select All Files',
+  'settings.shortcuts.binding.sftp-rename': 'Rename File',
+  'settings.shortcuts.binding.sftp-delete': 'Delete Files',
+  'settings.shortcuts.binding.sftp-refresh': 'Refresh',
+  'settings.shortcuts.binding.sftp-new-folder': 'New Folder',
+  'settings.shortcuts.binding.sftp-open': 'Open File / Enter Directory',
+  'settings.shortcuts.binding.sftp-go-parent': 'Go to Parent Directory',
+  'settings.shortcuts.binding.sftp-navigate-to': 'Navigate to Selected Directory',
+
   // Context menus / common actions
   'action.newHost': 'New Host',
   'action.newSubfolder': 'New Subfolder',
@@ -1191,8 +1235,123 @@ Highlight the focused split pane:
   'deepLink.jms.invalid': 'Invalid JumpServer link',
   'deepLink.jms.unsupported': 'Unsupported JumpServer protocol: {{protocol}}',
   'settings.tab.plugins': 'Plugins',
-  'settings.plugins.title': 'Plugin settings',
-  'settings.plugins.description': 'Native, validated settings contributed by development plugins.',
+  "settings.plugins.manager.installed": "Installed plugins",
+  "settings.plugins.manager.import": "Import .ncpkg",
+  "settings.plugins.manager.preview": "Imported packages stay disabled until you review and enable them.",
+  "settings.plugins.manager.empty": "Import a local plugin package to get started.",
+  "settings.plugins.manager.enabled": "Enabled",
+  "settings.plugins.manager.disabled": "Disabled",
+  "settings.plugins.manager.enable": "Enable",
+  "settings.plugins.manager.disable": "Disable",
+  "settings.plugins.manager.remove": "Uninstall",
+  "settings.plugins.manager.removeNote": "Uninstall removes package code and local KV data. User-owned settings, secrets and sync sidecars are retained.",
+  "settings.plugins.permissions.statusUnknown": "Status unknown",
+  "plugins.sidebar.extensions": "Extension pages",
+  "plugins.sidebar.selectTerminal": "Select an open terminal first.",
+  "plugins.sidebar.loading": "Loading extension page…",
+  "plugins.vault.loading": "Loading plugin page…",
+  "plugins.vault.extensions": "Extensions",
+  "plugins.vault.back": "Back to hosts",
+  "plugins.interaction.title": "Plugin request",
+  "plugins.interaction.sharing": "Text you share becomes available to this plugin and its granted capabilities, including network access. Reading does not approve a new network destination.",
+  "plugins.interaction.input": "Input text",
+  "plugins.interaction.filter": "Filter choices",
+  "plugins.interaction.preview": "Preview clipboard",
+  "plugins.interaction.previewNote": "The clipboard is read only after you choose Preview. You can then inspect the text and separately confirm sharing it.",
+  "plugins.interaction.previewAction": "Preview clipboard",
+  "plugins.interaction.share": "Share with plugin",
+  "plugins.interaction.copy": "Copy to clipboard",
+  "plugins.interaction.failed": "This request expired or could not be completed.",
+  "settings.plugins.permissions.current": "Matches the current activation",
+  "settings.plugins.permissions.inactive": "Inactive for the current activation",
+  "settings.plugins.permissions.title": "Saved grants",
+  "settings.plugins.permissions.refresh": "Refresh",
+  "settings.plugins.permissions.loading": "Loading grants...",
+  "settings.plugins.permissions.empty": "No saved grants. One-use decisions are not retained.",
+  "settings.plugins.permissions.always": "Until revoked",
+  "settings.plugins.permissions.application": "Until Netcatty exits",
+  "settings.plugins.permissions.session": "Until the session closes",
+  "settings.plugins.permissions.audit": "Recent security events (up to 100)",
+  "settings.plugins.permissions.revoke": "Disable and revoke all grants",
+  "settings.plugins.permissions.revokeNote": "This disables the plugin, cancels its work, and removes saved grants. Enable it again to request new access.",
+  "settings.plugins.permissions.unavailable": "Plugin permission management is unavailable",
+  "settings.plugins.manager.permissions": "Declared permissions",
+  "settings.plugins.manager.permissionNote": "From the manifest, not a grant. Enabled allows lazy activation; required permissions are requested before first activation and optional permissions when used. Sensitive operations still pass host checks.",
+  "settings.plugins.manager.noPermissions": "No privileged permissions declared.",
+  "settings.plugins.manager.required": "Required",
+  "settings.plugins.manager.optional": "Optional",
+  "settings.plugins.themes.title": "Plugin themes",
+  "settings.plugins.themes.description": "Preview changes only this window. Apply saves this device’s selection. Personal accent, fonts and terminal overrides stay in control.",
+  "settings.plugins.themes.empty": "No enabled plugin themes for this mode.",
+  "settings.plugins.themes.choose": "Choose a theme",
+  "settings.plugins.themes.unavailable": "Saved theme unavailable; using the host default",
+  "settings.plugins.themes.applied": "Applied",
+  "settings.plugins.themes.preview": "Preview",
+  "settings.plugins.themes.apply": "Apply",
+  "settings.plugins.themes.cancel": "Cancel preview",
+  "settings.plugins.themes.restore": "Restore default",
+  "settings.plugins.themes.invalid": "Some theme palettes were rejected or unavailable.",
+  "settings.plugins.themes.failed": "Could not apply theme.",
+  "settings.plugins.manager.dataTheme": "Theme pack: validated colors, no executable runtime.",
+  "settings.plugins.manager.browser": "Browser runtime: privileged access goes through host permission brokers.",
+  "settings.plugins.manager.advanced": "Advanced runtime: full Node filesystem and network authority. Broker permissions cannot restrict this access. Development preview only.",
+  "settings.plugins.manager.data": "Local KV stays on this device. Only non-secret settings explicitly marked for sync participate in encrypted cloud sidecars. Packages and permission grants do not sync.",
+  "settings.plugins.market.results": "{count} plugins",
+  "settings.plugins.manager.lastError": "Last recorded error",
+  "settings.plugins.sources.offline": "Source unavailable. If a previously validated catalog exists for this source, it remains available for browsing only. Installation is unavailable until refresh succeeds.",
+  "settings.plugins.sources.note": "This catalog is provided by the selected third party, not curated by Netcatty. Review the source domain and permissions before installing. Updates are manual.",
+  "settings.plugins.sources.sourceOnly": "Source-only entry from this provider. No downloadable package is available; review the author’s build and import instructions.",
+  "settings.plugins.market.offline": "Registry unavailable. Showing the last valid catalog or bundled examples. Installation is unavailable until refresh succeeds.",
+  "settings.plugins.manager.details": "View details",
+  "settings.plugins.manager.noDescription": "No description provided.",
+  "settings.plugins.status": "Notices: {count}",
+  "settings.plugins.info": "Plugin information",
+  "settings.plugins.manager.noVaultShort": "Secret storage unavailable",
+  "settings.plugins.market.offlineShort": "Offline catalog · installation unavailable",
+  "settings.plugins.market.readmeInfo": "About this README",
+  "settings.plugins.market.installed": "Installed",
+  "settings.plugins.market.sourceBadge": "Source example",
+  "settings.plugins.market.title": "Marketplace",
+  "settings.plugins.market.note": "Curated open-source plugins. Review is not a security certification. Updates are manual.",
+  "settings.plugins.market.back": "All plugins",
+  "settings.plugins.market.install": "Install this version (disabled)",
+  "settings.plugins.market.installNote": "This replaces and stops the installed version. Review its permissions in Installed plugins before enabling.",
+  "settings.plugins.market.sourceOnly": "First-party source example. Build with the local CLI and import the .ncpkg; no downloadable release has been published.",
+  "settings.plugins.market.readmeNote": "Pinned to the commit above. HTML is inert and remote images are not loaded. Written by the plugin author.",
+  "settings.plugins.manager.noVault": "System key storage is unavailable. Secret and credential operations are blocked; browsing and non-secret plugins still work.",
+  "settings.plugins.manager.sensitive": "Sensitive access: review the data and resource scope before granting.",
+  "settings.plugins.manager.dual": "Browser is the default runtime. This package also includes a Node entrypoint with full device authority; developer mode only.",
+  "settings.plugins.manager.advancedDeclaration": "Browser entrypoint with advanced permission declarations. Not eligible for normal browser-only mode; review every declared permission.",
+  "settings.plugins.market.retry": "Retry",
+  "settings.plugins.market.empty": "No catalog entries are available. You can still import a local browser plugin.",
+  "settings.plugins.market.emptyReadme": "This README is empty.",
+  "settings.plugins.market.search": "Search name, author or description",
+  "settings.plugins.market.noResults": "No matching plugins. Try another search.",
+  "settings.plugins.market.manifest": "Compatibility and permissions",
+  "settings.plugins.manager.unbounded": "No narrower resource scope is declared. Check the actual scope in the permission prompt.",
+  "settings.plugins.openView": "Open",
+  "settings.plugins.openManager": "Open plugin manager",
+  "settings.plugins.sources.conflict": "This ID is installed from another source. Uninstall and explicitly reset its private data before switching. Existing source:",
+  "settings.plugins.sources.clearPrivate": "Also clear this source’s private data, grants and secrets to reinstall from another source. This cannot be undone.",
+  "settings.plugins.sources.official": "Official marketplace",
+  "settings.plugins.sources.thirdparty": "Third-party marketplace",
+  "settings.plugins.sources.manage": "Manage sources",
+  "settings.plugins.sources.select": "Select a source",
+  "settings.plugins.sources.empty": "Choose or add a third-party source.",
+  "settings.plugins.sources.add": "Add source",
+  "settings.plugins.sources.remove": "Remove source",
+  "settings.plugins.sources.name": "Source name",
+  "settings.plugins.sources.address": "HTTPS source address",
+  "settings.plugins.sources.risk": "Third-party sources are not maintained or endorsed by Netcatty. Review the real domain, package permissions and author before installing.",
+  "settings.plugins.sources.accept": "I trust this domain to supply plugin metadata and packages. This does not grant plugin permissions.",
+  "settings.plugins.sources.removeNote": "Installed plugins and their data remain. Updates from this source stop; another source will not replace it.",
+  "settings.plugins.sources.disablePlugins": "Also disable plugins installed from this source",
+  "settings.plugins.sources.installConfirm": "Review third-party installation",
+  "settings.plugins.sources.source": "Source",
+  "settings.plugins.sources.local": "Local import",
+  "settings.plugins.sources.all": "All sources",
+  "settings.plugins.title": "Plugins",
+  "settings.plugins.description": "Manage your plugins and explore the catalog.",
   'settings.plugins.loading': 'Loading plugin settings…',
   'settings.plugins.empty': 'No enabled plugin contributes settings.',
   'settings.plugins.scopeContext': 'Open this setting in its {scope} context.',
@@ -1221,5 +1380,20 @@ Highlight the focused split pane:
   'plugins.authentication.responseFailed': 'Could not send the authentication response. Try again or cancel the request.',
   'plugins.authentication.responseFailedWithMessage': 'Could not send the authentication response: {message}. Try again or cancel the request.',
   'plugins.authentication.continue': 'Continue',
+  'plugins.hostActions.select': 'Share selected host metadata',
+  'plugins.hostActions.selectionNote': 'Share saved labels, addresses, usernames, protocols, groups and tags with this plugin. Group selection includes only the hosts selected now. Connecting requires a separate confirmation.',
+  'plugins.hostActions.create': 'Review host draft',
+  'plugins.hostActions.edit': 'Review host changes',
+  'plugins.hostActions.connect': 'Confirm connection',
+  'plugins.hostActions.fieldDiff': 'Changes to save',
+  'plugins.hostActions.defaultsWarning': 'Saved connection defaults apply. Changing a group can change inherited authentication, proxy settings and scripts.',
+  'plugins.hostActions.invalidDraft': 'Enter a valid host draft.',
+  'plugins.hostActions.scriptsRun': 'Saved startup, connect or output scripts may run with this connection.',
+  'plugins.hostActions.noScripts': 'No saved startup, connect or output scripts are configured for this host.',
+  'plugins.hostActions.connectionNote': 'Netcatty will open this connection using the saved settings. This does not share session content with the plugin.',
+  'plugins.hostActions.localExecution': 'Local execution: this opens a shell on this device.',
+  'plugins.hostActions.managedUnsupported': 'Managed SSH config changes require the Vault host editor.',
+  'plugins.hostActions.failed': 'The request expired, was revoked, or the host changed. Select the host again.',
+  'plugins.hostActions.selectionLimit': 'Select up to 50 current hosts.',
 
 };

application/i18n/locales/en/terminal.ts

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

application/i18n/locales/en/vault.ts

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

application/i18n/locales/es/ai.ts

@@ -90,6 +90,15 @@ export const esAiMessages: Messages = {
   'ai.providers.advancedParams.hint': 'Déjalo en blanco para usar los valores predeterminados del proveedor.',
   'ai.providers.advancedParams.maxTokens.placeholder': 'p. ej. 4096',
   'ai.providers.advancedParams.default': 'Predeterminado del proveedor',
+  'ai.providers.headers': 'Cabeceras HTTP personalizadas',
+  'ai.providers.headers.help': 'Cabeceras opcionales para este proveedor. Los valores se ocultan y se cifran al guardarlos.',
+  'ai.providers.headers.name': 'Nombre de la cabecera',
+  'ai.providers.headers.value': 'Valor de la cabecera',
+  'ai.providers.headers.add': 'Agregar cabecera',
+  'ai.providers.headers.remove': 'Quitar cabecera',
+  'ai.providers.headers.invalid': 'Usa cabeceras HTTP válidas y únicas. Content-Length y Transfer-Encoding se gestionan automáticamente.',
+  'ai.providers.headers.loadError': 'No se pudieron desbloquear las cabeceras guardadas. Cancela y vuelve a intentarlo después de desbloquear el llavero del sistema.',
+  'ai.providers.headers.saveError': 'No se pudo guardar de forma segura. Comprueba que el llavero del sistema esté disponible y vuelve a intentarlo.',
 
   // AI Codex
   'ai.codex': 'Codex',
@@ -280,6 +289,14 @@ export const esAiMessages: Messages = {
   'ai.opencode.customPathPlaceholder': 'p. ej. /usr/local/bin/opencode',
   'ai.opencode.check': 'Verificar',
   'ai.opencode.resetPath': 'Restablecer',
+  'ai.opencode.v2.startupTimeout': 'OpenCode 2 no estuvo listo a tiempo. Confirma que `opencode serve` funciona en una terminal y vuelve a intentarlo.',
+  'ai.opencode.v2.exited': 'OpenCode 2 se detuvo antes de que el chat pudiera iniciarse.',
+  'ai.opencode.v2.unauthorized': 'OpenCode 2 rechazó la conexión. Vuelve a intentar el chat.',
+  'ai.opencode.v2.unavailable': 'No se pudo contactar con OpenCode 2. Comprueba que esté instalado y vuelve a intentarlo.',
+  'ai.opencode.v2.sessionFailed': 'OpenCode 2 no pudo completar este turno.',
+  'ai.opencode.v2.empty': 'OpenCode 2 devolvió una respuesta vacía. Ejecuta `opencode` en una terminal para configurar la autenticación y los modelos.',
+  'ai.opencode.v2.contextSkipped': 'OpenCode 2 no pudo aplicar el contexto de la conversación de Netcatty.',
+  'ai.opencode.v2.mcpSkipped': 'OpenCode 2 no pudo adjuntar una herramienta MCP. El chat continuará sin ella.',
 
   // AI MiMo Code (CLI de Xiaomi MiMo Code — fork de OpenCode)
   'ai.mimo.title': 'MiMo Code',
@@ -694,6 +711,9 @@ export const esAiMessages: Messages = {
   'terminal.layer.splitHorizontal': 'Dividir arriba y abajo',
   'terminal.layer.splitVertical': 'Dividir izquierda y derecha',
   'terminal.layer.openInNewSplit': 'Abrir en una división nueva',
+  'terminal.layer.saveLayoutAsDefault': 'Guardar diseño como predeterminado',
+  'terminal.layer.layoutSavedAsDefault': 'Diseño guardado como predeterminado',
+  'terminal.layer.layoutSaveFailed': 'No se pudo guardar el diseño',
   'terminal.layer.hostTree.search': 'Buscar hosts...',
   'terminal.layer.hostTree.searchButton': 'Buscar',
   'terminal.layer.hostTree.tagsButton': 'Filtrar por etiquetas',

application/i18n/locales/es/core.ts

@@ -84,6 +84,32 @@ export const esCoreMessages: Messages = {
   '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.',
   'credentials.protectionUnavailable.action': 'Abrir configuración',
 
+  // App Lock
+  'appLock.title': 'Netcatty está bloqueado',
+  'appLock.reason.default': 'Ingresa tu contraseña de bloqueo para continuar.',
+  'appLock.reason.startup': 'Netcatty se bloquea cada vez que se abre esta ventana.',
+  'appLock.reason.idle': 'Netcatty se bloqueó tras el tiempo de inactividad.',
+  'appLock.reason.manual': 'Netcatty se bloqueó manualmente.',
+  'appLock.passwordLabel': 'Contraseña de bloqueo',
+  'appLock.passwordPlaceholder': 'Ingresa la contraseña para desbloquear',
+  'appLock.unlock': 'Desbloquear',
+  'appLock.unlocking': 'Desbloqueando...',
+  'appLock.usePassword': 'Usar contraseña',
+  'appLock.error.emptyPassword': 'Ingresa la contraseña de bloqueo.',
+  'appLock.error.incorrectPassword': 'La contraseña de bloqueo es incorrecta.',
+  'appLock.systemUnlock.unlockWith': 'Desbloquear con {label}',
+  'appLock.systemUnlock.preparing': 'Preparando {label}...',
+  'appLock.systemUnlock.verifying': 'Esperando a {label}...',
+  'appLock.systemUnlock.error': 'No se completó el desbloqueo del sistema. Usa la contraseña de bloqueo para continuar.',
+  'appLock.logoLabel': 'Netcatty',
+  'appLock.reset.title': 'Restablecer el bloqueo de la aplicación',
+  'appLock.reset.description': 'Esto elimina la contraseña de bloqueo actual y desactiva el bloqueo de la aplicación. Crea una nueva contraseña desde Configuración cuando la necesites.',
+  'appLock.reset.cancel': 'Cancelar',
+  'appLock.reset.confirm': 'Restablecer el bloqueo de la aplicación',
+  'appLock.reset.resetting': 'Restableciendo...',
+  'appLock.reset.error': 'No se pudo restablecer el bloqueo de la aplicación. Inténtalo de nuevo.',
+  'topTabs.lockApp': 'Bloquear Netcatty',
+
   // Settings shell
   'settings.title': 'Configuración',
   'settings.tab.application': 'Aplicación',
@@ -119,6 +145,65 @@ export const esCoreMessages: Messages = {
   'settings.system.credentials.unavailableHint': 'Las credenciales cifradas en otro perfil de usuario o máquina no se pueden descifrar aquí. Vuelve a ingresar y guarda las credenciales en este dispositivo.',
   'settings.system.credentials.portabilityHint': 'La sincronización en la nube es portátil porque usa tu cifrado de clave maestra. El cifrado local de safeStorage está limitado al dispositivo y al usuario.',
 
+  // Settings > System > App Lock
+  'settings.appLock.title': 'Bloqueo de la aplicación',
+  'settings.appLock.description': 'Solicita una contraseña de bloqueo local cuando Netcatty se abre, tras un periodo de inactividad o cuando lo bloqueas manualmente.',
+  'settings.appLock.setupTitle': 'Define una contraseña de bloqueo',
+  'settings.appLock.setupDescription': 'Crea la contraseña a continuación. El bloqueo de la aplicación se activa en cuanto se guarda.',
+  'settings.appLock.manageTitle': 'El bloqueo de la aplicación está listo',
+  'settings.appLock.enabledStatus': 'Activado. Netcatty se bloquea al iniciar, tras un periodo de inactividad y cuando lo bloqueas manualmente.',
+  'settings.appLock.disabledStatus': 'Contraseña guardada, pero el bloqueo de la aplicación está desactivado.',
+  'settings.appLock.disableTitle': 'Desactivar el bloqueo de la aplicación',
+  'settings.appLock.disableDescription': 'Ingresa la contraseña de bloqueo actual para dejar de bloquear Netcatty. La contraseña guardada se eliminará; para volver a activar el bloqueo tendrás que crear una nueva.',
+  'settings.appLock.disable': 'Desactivar el bloqueo de la aplicación',
+  'settings.appLock.disabling': 'Desactivando...',
+  'settings.appLock.setupPasswordTitle': 'Crear contraseña de bloqueo',
+  'settings.appLock.setupPasswordDescription': 'Esta contraseña es necesaria para desbloquear Netcatty y para cambiar o desactivar el bloqueo de la aplicación más adelante.',
+  'settings.appLock.changePasswordTitle': 'Cambiar la contraseña de bloqueo',
+  'settings.appLock.changePasswordDescription': 'Ingresa la contraseña de bloqueo actual y luego elige una nueva.',
+  'settings.appLock.enable': 'Activar el bloqueo de la aplicación',
+  'settings.appLock.enableDesc': 'Bloquea al iniciar y tras el tiempo de inactividad seleccionado.',
+  'settings.appLock.timeout': 'Tiempo de inactividad',
+  'settings.appLock.timeoutDesc': 'Bloquea tras un periodo de inactividad o al cerrar la ventana en la bandeja. Nunca omite ambos casos.',
+  'settings.appLock.timeout.0': 'Nunca bloquear automáticamente',
+  'settings.appLock.timeout.1': '1 minuto',
+  'settings.appLock.timeout.5': '5 minutos',
+  'settings.appLock.timeout.15': '15 minutos',
+  'settings.appLock.timeout.30': '30 minutos',
+  'settings.appLock.timeout.60': '60 minutos',
+  'settings.appLock.systemUnlock.label': 'Desbloqueo con {label}',
+  'settings.appLock.systemUnlock.desc': 'Usa {label} como forma alternativa de desbloquear Netcatty en este dispositivo.',
+  'settings.appLock.systemUnlock.unavailableDesc': '{label} no está disponible en este dispositivo ahora mismo.',
+  'settings.appLock.systemUnlock.unavailable': 'El desbloqueo del sistema no está disponible en este dispositivo.',
+  'settings.appLock.systemUnlock.locked': 'Desbloquea Netcatty antes de cambiar el desbloqueo del sistema.',
+  'settings.appLock.systemUnlock.autoPrompt.label': 'Abrir {label} automáticamente',
+  'settings.appLock.systemUnlock.autoPrompt.desc': 'Muestra el aviso de {label} automáticamente cuando Netcatty está esperando para desbloquearse.',
+  'settings.appLock.currentPassword': 'Contraseña actual',
+  'settings.appLock.currentPasswordPlaceholder': 'Necesaria para desactivar o reemplazar',
+  'settings.appLock.currentPasswordForDisablePlaceholder': 'Contraseña actual para desactivar el bloqueo de la aplicación',
+  'settings.appLock.currentPasswordForChangePlaceholder': 'Contraseña actual para cambiarla',
+  'settings.appLock.newPassword': 'Nueva contraseña',
+  'settings.appLock.newPasswordPlaceholder': 'Define la contraseña de bloqueo',
+  'settings.appLock.confirmPassword': 'Confirmar contraseña',
+  'settings.appLock.confirmPasswordPlaceholder': 'Repite la contraseña',
+  'settings.appLock.savePassword': 'Definir y activar',
+  'settings.appLock.savingPassword': 'Guardando...',
+  'settings.appLock.passwordSet': 'Contraseña configurada',
+  'settings.appLock.replacePassword': 'Reemplazar contraseña',
+  'settings.appLock.enableAfterPassword': 'Define una contraseña de bloqueo antes de activar el bloqueo de la aplicación.',
+  'settings.appLock.localOnlyHint': 'Bloqueo de privacidad local del dispositivo. No se sincroniza y no es una barrera de seguridad del sistema operativo.',
+  'settings.appLock.validation.currentRequired': 'Ingresa la contraseña de bloqueo actual.',
+  'settings.appLock.validation.newRequired': 'Ingresa una nueva contraseña de bloqueo.',
+  'settings.appLock.validation.confirmRequired': 'Confirma la nueva contraseña de bloqueo.',
+  'settings.appLock.validation.mismatch': 'Las contraseñas nuevas no coinciden.',
+  'settings.appLock.validation.incorrect': 'La contraseña de bloqueo actual es incorrecta.',
+
+  // Settings > System > Auto Launch
+  'settings.autoLaunch.title': 'Abrir al iniciar sesión',
+  'settings.autoLaunch.enabled': 'Iniciar al arrancar el sistema',
+  'settings.autoLaunch.enabledDesc': 'Inicia Netcatty automáticamente al iniciar sesión, oculto en la bandeja del sistema.',
+  'settings.autoLaunch.unsupportedDesc': 'No disponible en esta plataforma ni en una compilación de desarrollo.',
+
   // Settings > System > Network Proxy
   'settings.system.networkProxy.title': 'Proxy de red',
   'settings.system.networkProxy.description': 'Proxy HTTP(S) para la sincronización en la nube y los proveedores de IA. Esto es independiente de los perfiles de ProxyJump / ProxyCommand de SSH.',
@@ -1150,8 +1235,123 @@ Resalta el panel dividido enfocado:
   'deepLink.jms.invalid': 'Enlace JumpServer inválido',
   'deepLink.jms.unsupported': 'Protocolo JumpServer no compatible: {{protocol}}',
   'settings.tab.plugins': 'Plugins',
-  'settings.plugins.title': 'Configuración de plugins',
-  'settings.plugins.description': 'Ajustes nativos y validados que aportan los plugins de desarrollo.',
+  "settings.plugins.manager.installed": "Plugins instalados",
+  "settings.plugins.manager.import": "Importar .ncpkg",
+  "settings.plugins.manager.preview": "Los paquetes importados permanecen desactivados hasta que los revises y actives.",
+  "settings.plugins.manager.empty": "Importa un paquete local para empezar.",
+  "settings.plugins.manager.enabled": "Activado",
+  "settings.plugins.manager.disabled": "Desactivado",
+  "settings.plugins.manager.enable": "Activar",
+  "settings.plugins.manager.disable": "Desactivar",
+  "settings.plugins.manager.remove": "Desinstalar",
+  "settings.plugins.manager.removeNote": "La desinstalación elimina el código y los datos KV locales. Se conservan los ajustes del usuario, los secretos y los datos auxiliares de sincronización.",
+  "settings.plugins.permissions.statusUnknown": "Estado desconocido",
+  "plugins.sidebar.extensions": "Páginas de extensiones",
+  "plugins.sidebar.selectTerminal": "Selecciona primero un terminal abierto.",
+  "plugins.sidebar.loading": "Cargando página de extensión…",
+  "plugins.vault.loading": "Cargando página del plugin…",
+  "plugins.vault.extensions": "Extensiones",
+  "plugins.vault.back": "Volver a hosts",
+  "plugins.interaction.title": "Solicitud de complemento",
+  "plugins.interaction.sharing": "El texto compartido estará disponible para este complemento y sus capacidades autorizadas, incluida la red. Leer no autoriza un nuevo destino de red.",
+  "plugins.interaction.input": "Introducir texto",
+  "plugins.interaction.filter": "Filtrar opciones",
+  "plugins.interaction.preview": "Vista previa del portapapeles",
+  "plugins.interaction.previewNote": "El portapapeles se lee al elegir Vista previa. Revise el texto y confirme por separado que desea compartirlo.",
+  "plugins.interaction.previewAction": "Vista previa del portapapeles",
+  "plugins.interaction.share": "Compartir con el complemento",
+  "plugins.interaction.copy": "Copiar al portapapeles",
+  "plugins.interaction.failed": "La solicitud caducó o no pudo completarse.",
+  "settings.plugins.permissions.current": "Coincide con la ejecución actual",
+  "settings.plugins.permissions.inactive": "No activa para la ejecución actual",
+  "settings.plugins.permissions.title": "Autorizaciones guardadas",
+  "settings.plugins.permissions.refresh": "Actualizar",
+  "settings.plugins.permissions.loading": "Cargando autorizaciones...",
+  "settings.plugins.permissions.empty": "No hay autorizaciones guardadas. Las decisiones de un solo uso no se conservan.",
+  "settings.plugins.permissions.always": "Hasta su revocación",
+  "settings.plugins.permissions.application": "Hasta cerrar Netcatty",
+  "settings.plugins.permissions.session": "Hasta cerrar la sesión",
+  "settings.plugins.permissions.audit": "Eventos de seguridad recientes (hasta 100)",
+  "settings.plugins.permissions.revoke": "Desactivar y revocar todas las autorizaciones",
+  "settings.plugins.permissions.revokeNote": "Desactiva el complemento, cancela su trabajo y elimina las autorizaciones guardadas. Actívelo para solicitar acceso de nuevo.",
+  "settings.plugins.permissions.unavailable": "La gestión de permisos no está disponible",
+  "settings.plugins.manager.permissions": "Permisos declarados",
+  "settings.plugins.manager.permissionNote": "Del manifiesto, no es una autorización. Activado permite la activación diferida; los permisos obligatorios se solicitan antes del primer uso y los opcionales cuando se necesitan. Las operaciones sensibles siguen verificándose.",
+  "settings.plugins.manager.noPermissions": "No se han declarado permisos privilegiados.",
+  "settings.plugins.manager.required": "Obligatorio",
+  "settings.plugins.manager.optional": "Opcional",
+  "settings.plugins.themes.title": "Temas de plugins",
+  "settings.plugins.themes.description": "La vista previa solo cambia esta ventana. Aplicar guarda la selección en este dispositivo. Se conservan los ajustes personales.",
+  "settings.plugins.themes.empty": "No hay temas habilitados para este modo.",
+  "settings.plugins.themes.choose": "Elegir tema",
+  "settings.plugins.themes.unavailable": "Tema guardado no disponible; se usa el predeterminado",
+  "settings.plugins.themes.applied": "Aplicado",
+  "settings.plugins.themes.preview": "Vista previa",
+  "settings.plugins.themes.apply": "Aplicar",
+  "settings.plugins.themes.cancel": "Cancelar vista previa",
+  "settings.plugins.themes.restore": "Restaurar predeterminado",
+  "settings.plugins.themes.invalid": "Algunas paletas no están disponibles o no son válidas.",
+  "settings.plugins.themes.failed": "No se pudo aplicar el tema.",
+  "settings.plugins.manager.dataTheme": "Paquete de temas: colores validados, sin ejecución de código.",
+  "settings.plugins.manager.browser": "Entorno de navegador: el acceso privilegiado pasa por los controles de permisos del anfitrión.",
+  "settings.plugins.manager.advanced": "Entorno avanzado: acceso completo de Node al sistema de archivos y a la red. Los permisos del intermediario no restringen este acceso. Solo para desarrollo.",
+  "settings.plugins.manager.data": "Los datos KV permanecen en este dispositivo. Solo los ajustes no secretos marcados para sincronización participan en los datos auxiliares cifrados. Los paquetes y las autorizaciones no se sincronizan.",
+  "settings.plugins.market.results": "{count} plugins",
+  "settings.plugins.manager.lastError": "Último error registrado",
+  "settings.plugins.sources.offline": "Fuente no disponible. Si existe un catálogo validado en caché de esta fuente, solo se permite consultarlo. La instalación no estará disponible hasta que se actualice correctamente.",
+  "settings.plugins.sources.note": "Este catálogo lo proporciona el tercero seleccionado; Netcatty no lo selecciona ni revisa. Comprueba el dominio y los permisos antes de instalar. Las actualizaciones son manuales.",
+  "settings.plugins.sources.sourceOnly": "Entrada de código fuente de este proveedor. No hay un paquete descargable; consulta las instrucciones de compilación e importación del autor.",
+  "settings.plugins.market.offline": "El registro no está disponible. Se muestra el último catálogo válido o los ejemplos incluidos. La instalación requiere una actualización correcta.",
+  "settings.plugins.manager.details": "Ver detalles",
+  "settings.plugins.manager.noDescription": "No se proporcionó una descripción.",
+  "settings.plugins.status": "{count} avisos",
+  "settings.plugins.info": "Información de plugins",
+  "settings.plugins.manager.noVaultShort": "Almacenamiento de secretos no disponible",
+  "settings.plugins.market.offlineShort": "Catálogo sin conexión · instalación no disponible",
+  "settings.plugins.market.readmeInfo": "Acerca de este README",
+  "settings.plugins.market.installed": "Instalado",
+  "settings.plugins.market.sourceBadge": "Ejemplo de código",
+  "settings.plugins.market.title": "Catálogo",
+  "settings.plugins.market.note": "Plugins de código abierto seleccionados. La revisión no certifica su seguridad. Las actualizaciones son manuales.",
+  "settings.plugins.market.back": "Todos los plugins",
+  "settings.plugins.market.install": "Instalar esta versión (desactivada)",
+  "settings.plugins.market.installNote": "Esto reemplaza y detiene la versión instalada. Revisa sus permisos antes de activarla.",
+  "settings.plugins.market.sourceOnly": "Ejemplo propio con código fuente. Compílalo con la CLI local e importa el .ncpkg; no hay versión publicada para descargar.",
+  "settings.plugins.market.readmeNote": "Fijado al commit indicado. El HTML no se ejecuta y las imágenes remotas no se cargan. Contenido del autor.",
+  "settings.plugins.manager.noVault": "El almacén de claves del sistema no está disponible. Se bloquean secretos y credenciales; el catálogo y los plugins que no los usan siguen disponibles.",
+  "settings.plugins.manager.sensitive": "Acceso sensible: revisa los datos y el alcance antes de autorizar.",
+  "settings.plugins.manager.dual": "El navegador es la opción predeterminada. El paquete también incluye una entrada Node con acceso completo al dispositivo; solo para desarrollo.",
+  "settings.plugins.manager.advancedDeclaration": "Entrada de navegador con permisos avanzados declarados. No se admite en el modo normal; revisa cada permiso.",
+  "settings.plugins.market.retry": "Reintentar",
+  "settings.plugins.market.empty": "No hay entradas en el catálogo. Puedes importar un plugin local de navegador.",
+  "settings.plugins.market.emptyReadme": "Este README está vacío.",
+  "settings.plugins.market.search": "Buscar nombre, autor o descripción",
+  "settings.plugins.market.noResults": "No hay plugins coincidentes. Prueba otra búsqueda.",
+  "settings.plugins.market.manifest": "Compatibilidad y permisos",
+  "settings.plugins.manager.unbounded": "No se declara un alcance de recursos más limitado. Revisa el alcance real en la solicitud de permiso.",
+  "settings.plugins.openView": "Abrir",
+  "settings.plugins.openManager": "Abrir gestor de plugins",
+  "settings.plugins.sources.conflict": "This ID is installed from another source. Uninstall and explicitly reset its private data before switching. Existing source:",
+  "settings.plugins.sources.clearPrivate": "Also clear this source’s private data, grants and secrets to reinstall from another source. This cannot be undone.",
+  "settings.plugins.sources.official": "Official marketplace",
+  "settings.plugins.sources.thirdparty": "Third-party marketplace",
+  "settings.plugins.sources.manage": "Manage sources",
+  "settings.plugins.sources.select": "Select a source",
+  "settings.plugins.sources.empty": "Choose or add a third-party source.",
+  "settings.plugins.sources.add": "Add source",
+  "settings.plugins.sources.remove": "Remove source",
+  "settings.plugins.sources.name": "Source name",
+  "settings.plugins.sources.address": "HTTPS source address",
+  "settings.plugins.sources.risk": "Third-party sources are not maintained or endorsed by Netcatty. Review the real domain, package permissions and author before installing.",
+  "settings.plugins.sources.accept": "I trust this domain to supply plugin metadata and packages. This does not grant plugin permissions.",
+  "settings.plugins.sources.removeNote": "Installed plugins and their data remain. Updates from this source stop; another source will not replace it.",
+  "settings.plugins.sources.disablePlugins": "Also disable plugins installed from this source",
+  "settings.plugins.sources.installConfirm": "Review third-party installation",
+  "settings.plugins.sources.source": "Source",
+  "settings.plugins.sources.local": "Local import",
+  "settings.plugins.sources.all": "All sources",
+  "settings.plugins.title": "Plugins",
+  "settings.plugins.description": "Gestiona tus plugins y explora el catálogo.",
   'settings.plugins.loading': 'Cargando ajustes del plugin…',
   'settings.plugins.empty': 'Ningún plugin activado aporta ajustes.',
   'settings.plugins.scopeContext': 'Abre este ajuste en su contexto de {scope}.',
@@ -1180,5 +1380,20 @@ Resalta el panel dividido enfocado:
   'plugins.authentication.responseFailed': 'No se pudo enviar la respuesta de autenticación. Inténtalo de nuevo o cancela la solicitud.',
   'plugins.authentication.responseFailedWithMessage': 'No se pudo enviar la respuesta de autenticación: {message}. Inténtalo de nuevo o cancela la solicitud.',
   'plugins.authentication.continue': 'Continuar',
+  'plugins.hostActions.select': 'Compartir metadatos de los equipos seleccionados',
+  'plugins.hostActions.selectionNote': 'Comparte nombres, direcciones, usuarios, protocolos, grupos y etiquetas guardados con este complemento. Los grupos solo incluyen los equipos seleccionados ahora. Conectar requiere otra confirmación.',
+  'plugins.hostActions.create': 'Revisar borrador de equipo',
+  'plugins.hostActions.edit': 'Revisar cambios del equipo',
+  'plugins.hostActions.connect': 'Confirmar conexión',
+  'plugins.hostActions.fieldDiff': 'Cambios que se guardarán',
+  'plugins.hostActions.defaultsWarning': 'Se aplican los ajustes de conexión guardados. Cambiar el grupo puede cambiar la autenticación, el proxy y los scripts heredados.',
+  'plugins.hostActions.invalidDraft': 'Introduce un borrador de equipo válido.',
+  'plugins.hostActions.scriptsRun': 'Esta conexión puede ejecutar scripts guardados de inicio, conexión o salida.',
+  'plugins.hostActions.noScripts': 'Este equipo no tiene scripts guardados de inicio, conexión o salida.',
+  'plugins.hostActions.connectionNote': 'Netcatty abrirá la conexión con los ajustes guardados. Esto no comparte el contenido de la sesión con el complemento.',
+  'plugins.hostActions.localExecution': 'Ejecución local: esto abre una shell en este dispositivo.',
+  'plugins.hostActions.managedUnsupported': 'Los cambios de configuración SSH administrada requieren el editor de equipos de Vault.',
+  'plugins.hostActions.failed': 'La solicitud caducó, se revocó o el equipo cambió. Selecciona el equipo de nuevo.',
+  'plugins.hostActions.selectionLimit': 'Selecciona hasta 50 equipos actuales.',
 
 };

application/i18n/locales/es/systemManager.ts

@@ -33,6 +33,9 @@ export const esSystemManagerMessages: Messages = {
   'systemManager.errors.loadPorts': 'No se pudieron cargar los puertos en escucha',
   'systemManager.errors.loadServices': 'No se pudieron cargar los servicios de systemd',
   'systemManager.errors.sshChannelUnavailable': 'El servidor se negó a abrir un nuevo canal de ejecución. Inténtalo de nuevo más tarde o vuelve a conectar este host.',
+  'systemManager.errors.nerdctlUnreachable': 'nerdctl no puede conectarse a containerd',
+  'systemManager.errors.clusterUnreachable': 'No se puede conectar al clúster para el contexto {{context}}',
+  'systemManager.errors.clusterUnreachableGeneric': 'No se puede conectar al clúster',
   'systemManager.unsupportedRemote': 'Este host no permite canales SSH de ejecución adicionales, por lo que el administrador del sistema no está disponible. Abrir este panel ya no desconectará la terminal.',
 
   'systemManager.overview.empty': 'Aún no hay datos de resumen del sistema.',
@@ -212,6 +215,20 @@ export const esSystemManagerMessages: Messages = {
   'systemManager.k8s.restarts': '{{count}} reinicios',
   'systemManager.k8s.chooseContainer': 'Elegir un contenedor',
   'systemManager.k8s.noContext': 'No hay un contexto de Kubernetes en este host',
+  'systemManager.k8s.status.Running': 'En ejecución',
+  'systemManager.k8s.status.Pending': 'Pendiente',
+  'systemManager.k8s.status.Completed': 'Completado',
+  'systemManager.k8s.status.Succeeded': 'Con éxito',
+  'systemManager.k8s.status.Failed': 'Fallido',
+  'systemManager.k8s.status.Unknown': 'Desconocido',
+  'systemManager.k8s.status.CrashLoopBackOff': 'Bucle de fallos',
+  'systemManager.k8s.status.ContainerCreating': 'Creando contenedor',
+  'systemManager.k8s.status.Terminating': 'Terminando',
+  'systemManager.k8s.status.ImagePullBackOff': 'Reintentando descarga de imagen',
+  'systemManager.k8s.status.ErrImagePull': 'Error al descargar la imagen',
+  'systemManager.k8s.status.Error': 'Error',
+  'systemManager.k8s.status.Evicted': 'Desalojado',
+  'systemManager.k8s.status.OOMKilled': 'Sin memoria',
 
   'systemManager.ports.unavailable': 'No se detectaron herramientas de puertos en escucha (ss / netstat) en este host.',
   'systemManager.ports.loading': 'Cargando puertos en escucha…',

application/i18n/locales/es/terminal.ts

@@ -219,6 +219,7 @@ export const esTerminalMessages: Messages = {
   'terminal.progress.timeoutIn': 'Tiempo de espera en {seconds}s',
   'terminal.progress.waitingForUserInput': 'Esperando entrada del usuario',
   'terminal.progress.disconnected': 'Desconectado',
+  'terminal.progress.connected': 'Conectado',
   'terminal.progress.cancelling': 'Cancelando...',
   'terminal.progress.startOver': 'Empezar de nuevo',
   'terminal.progress.enterReconnectHint': 'Presiona Enter para reconectar',
@@ -675,6 +676,45 @@ export const esTerminalMessages: Messages = {
   'keychain.keyDialog.editTitle': 'Editar clave',
   'keychain.keyDialog.editDesc': 'Actualizar esta clave SSH',
   'keychain.keyDialog.updateKey': 'Actualizar clave',
+  'keychain.generate.standardKeys': 'Claves estándar',
+  'keychain.generate.securityKeys': 'Llaves de seguridad · FIDO2',
+  'keychain.generate.residentDesc': 'Permite recuperar las credenciales desde esta llave de seguridad.',
+  'keychain.generate.verifyRequiredDesc': 'Solicita el PIN del dispositivo antes de firmar.',
+  'keychain.generate.generating': 'Generando…',
+  'keychain.generate.fidoHint': 'Conecta una llave de seguridad FIDO2. Es posible que se te solicite su PIN o un toque.',
+  'keychain.generate.resident': 'Guardar las credenciales en la llave',
+  'keychain.generate.verifyRequired': 'Verificar el PIN cada vez',
+  'keychain.action.loadResident': 'Cargar claves residentes desde la llave de seguridad',
+
+  // FIDO2 security key prompts and recovery states
+  'fido.prompt.pinTouchDesc': 'Ingresa tu PIN y luego toca la llave para confirmar.',
+  'fido.prompt.details': 'Detalles de la solicitud',
+  'fido.prompt.showPin': 'Mostrar PIN',
+  'fido.prompt.hidePin': 'Ocultar PIN',
+  'fido.prompt.verifying': 'Verificando…',
+  'fido.prompt.pinTitle': 'PIN de la llave de seguridad',
+  'fido.prompt.touchTitle': 'Toca tu llave de seguridad',
+  'fido.prompt.pinDesc': 'Ingresa el PIN de tu llave de seguridad para continuar.',
+  'fido.prompt.touchDesc': 'Toca tu llave de seguridad para confirmar tu identidad.',
+  'fido.prompt.pinLabel': 'PIN',
+  'fido.prompt.touchWaiting': 'Esperando tu llave…',
+  'fido.prompt.touchAutomatic': 'Continúa automáticamente después de que la toques',
+  'fido.prompt.cancelled': 'Se canceló la autenticación con llave de seguridad.',
+  'fido.prompt.touchDone': 'Ya la toqué',
+  'fido.prompt.timeout': 'El aviso de FIDO agotó el tiempo de espera. Intenta conectarte de nuevo.',
+  'fido.recovery.device-unavailable.title': 'Conecta la llave de seguridad correspondiente',
+  'fido.recovery.device-unavailable.desc': 'Conecta el dispositivo que contiene la credencial de esta llave y vuelve a intentarlo.',
+  'fido.recovery.timeout.title': 'Se agotó el tiempo de confirmación de la llave de seguridad',
+  'fido.recovery.timeout.desc': 'La operación del dispositivo se detuvo. Comprueba que tu llave esté conectada, vuelve a intentarlo y sigue el aviso de toque o verificación.',
+  'fido.recovery.pin-failed.title': 'No se aceptó el PIN de la llave de seguridad',
+  'fido.recovery.pin-failed.desc': 'Verifica el PIN FIDO2 de este dispositivo antes de reintentar. Varios intentos incorrectos pueden bloquear el dispositivo.',
+  'fido.recovery.failed.title': 'No se completó la verificación de la llave de seguridad',
+  'fido.recovery.failed.desc': 'Comprueba que el dispositivo correspondiente esté conectado y admita esta llave. Reintenta o cancela para revisar el dispositivo y la configuración de OpenSSH.',
+  'fido.recovery.retry': 'Reintentar verificación',
+  'fido.recovery.usePassword': 'Usar la contraseña configurada',
+  'fido.recovery.passwordFallback': 'Probando la contraseña configurada para este host',
+  'fido.error.opensshMissing': 'Se requiere OpenSSH con FIDO/libfido2. En macOS: brew install openssh libfido2.',
+  'fido.error.agentUnavailable': 'No se pudo iniciar un agente SSH compatible con FIDO.',
 
   // Tabs
   'tabs.closeSessionAria': 'Cerrar sesión',
@@ -841,6 +881,7 @@ export const esTerminalMessages: Messages = {
   'serial.field.flowControl': 'Control de flujo',
   'serial.noPorts': 'No se detectaron puertos seriales. Conecta un dispositivo y actualiza.',
   'serial.field.customPort': 'Ruta de puerto personalizada',
+  'serial.field.namedPipeHint': 'Consola de VM en Windows: introduce \\\\.\\pipe\\name. La VM debe crear la canalización como servidor. Se ignoran la velocidad y la trama.',
   'serial.field.customPortPlaceholder': 'p. ej., /dev/ttys001 o COM1',
   'serial.type.hardware': 'Hardware',
   'serial.type.pseudo': 'Pseudoterminal',

application/i18n/locales/es/vault.ts

@@ -370,6 +370,7 @@ export const esVaultMessages: Messages = {
   'sftp.transfers.openTargetFolder': 'Abrir carpeta de destino',
   'sftp.transfers.openTargetFolderError': 'No se pudo abrir la carpeta de destino',
   'sftp.transfers.copyTargetPath': 'Copiar ruta de destino',
+  'sftp.transfers.cleanupWarnings': 'Avisos de limpieza de copias de seguridad: {count}. Muestra los archivos para ver los detalles.',
   'sftp.transfers.copyTargetPathSuccess': 'Ruta de destino copiada',
   'sftp.transfers.copyTargetPathError': 'No se pudo copiar la ruta de destino',
   'sftp.transfers.pathConflict.title': 'Transferencia bloqueada',
@@ -1043,6 +1044,18 @@ export const esVaultMessages: Messages = {
   'hostDetails.addTag': 'Agregar una etiqueta...',
   'hostDetails.createTag': 'Crear etiqueta',
   'hostDetails.createGroup': 'Crear grupo',
+
+  // Host connection test
+  'hostConnectionTest.title': 'Probar conexión',
+  'hostConnectionTest.test': 'Probar',
+  'hostConnectionTest.chainOf': 'Cadena {current} de {total}',
+  'hostConnectionTest.success': 'Conexión correcta',
+  'hostConnectionTest.successHint': 'El host aceptó tus credenciales. Puedes cerrar esta ventana.',
+  'hostConnectionTest.connecting': 'Conectando… tiempo de espera en {seconds}s',
+  'hostConnectionTest.failed': 'No se pudo conectar.',
+  'hostConnectionTest.retry': 'Reintentar',
+  'hostConnectionTest.credentialsUnavailable': 'Las credenciales guardadas no se pueden descifrar en este dispositivo. Vuelve a ingresarlas abajo.',
+
   // Entradas de shell local (CMD) en la bóveda
   'localShell.subtitle': 'Shell local',
   'localShell.panel.title': 'Nueva shell local',

application/i18n/locales/localeParityLocales.test.ts

@@ -0,0 +1,120 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { DEFAULT_KEY_BINDINGS } from "../../../domain/models/keyBindings.ts";
+import en from "./en.ts";
+import es from "./es.ts";
+import ru from "./ru.ts";
+import zhCN from "./zh-CN.ts";
+import zhTW from "./zh-TW.ts";
+
+// Locales that are not at full key parity with `en` yet. They are tracked here
+// so the remaining debt stays visible instead of silently rendering in English
+// through the `DEFAULT_UI_LOCALE` fallback in `I18nProvider.resolveMessage`.
+// Move a locale out of this list once it covers every `en` key.
+const LOCALES_PENDING_PARITY = ["ru", "zh-CN", "zh-TW"] as const;
+
+const hasKey = (messages: Record<string, string>, key: string) =>
+  Object.hasOwn(messages, key);
+
+const interpolationTokens = (value: string) =>
+  [...value.matchAll(/\{\{\s*\w+\s*\}\}|\{\s*\w+\s*\}/g)]
+    .map((match) => match[0].replace(/[{}]/g, "").trim())
+    .sort();
+
+test("es defines every message key that en defines", () => {
+  const missing = Object.keys(en).filter((key) => !hasKey(es, key));
+
+  assert.deepEqual(
+    missing,
+    [],
+    `es is missing ${missing.length} message keys`,
+  );
+});
+
+test("es defines no message keys that en does not define", () => {
+  const extra = Object.keys(es).filter((key) => !hasKey(en, key));
+
+  assert.deepEqual(
+    extra,
+    [],
+    `es defines ${extra.length} keys that no longer exist in en`,
+  );
+});
+
+test("es keeps the same interpolation placeholders as en", () => {
+  const mismatched: string[] = [];
+
+  for (const key of Object.keys(es)) {
+    if (!hasKey(en, key)) continue;
+
+    const expected = interpolationTokens(en[key] ?? "").join(",");
+    const actual = interpolationTokens(es[key] ?? "").join(",");
+    if (expected !== actual) mismatched.push(key);
+  }
+
+  assert.deepEqual(
+    mismatched,
+    [],
+    `es changes interpolation placeholders for ${mismatched.length} keys`,
+  );
+});
+
+test("every default shortcut has a label in en and es", () => {
+  const locales = [
+    { name: "en", messages: en },
+    { name: "es", messages: es },
+  ];
+
+  for (const locale of locales) {
+    const missing = DEFAULT_KEY_BINDINGS.map(
+      (binding) => `settings.shortcuts.binding.${binding.id}`,
+    ).filter((key) => !hasKey(locale.messages, key));
+
+    assert.deepEqual(
+      missing,
+      [],
+      `${locale.name} is missing ${missing.length} shortcut labels`,
+    );
+  }
+});
+
+test("en shortcut labels stay identical to DEFAULT_KEY_BINDINGS", () => {
+  // SettingsShortcutsTab falls back to `binding.label` only while the locale
+  // resolves the key to itself. Once `en` defines the key, the locale becomes
+  // the rendered source, so the two must not drift apart.
+  for (const binding of DEFAULT_KEY_BINDINGS) {
+    const key = `settings.shortcuts.binding.${binding.id}`;
+
+    assert.equal(
+      en[key],
+      binding.label,
+      `en label drifted from DEFAULT_KEY_BINDINGS for ${binding.id}`,
+    );
+  }
+});
+
+test("every locale outside the pending list is at full parity with en", () => {
+  const locales = [
+    { name: "es", messages: es },
+    { name: "ru", messages: ru },
+    { name: "zh-CN", messages: zhCN },
+    { name: "zh-TW", messages: zhTW },
+  ];
+
+  for (const locale of locales) {
+    if ((LOCALES_PENDING_PARITY as readonly string[]).includes(locale.name)) {
+      continue;
+    }
+
+    const missing = Object.keys(en).filter(
+      (key) => !hasKey(locale.messages, key),
+    );
+
+    assert.deepEqual(
+      missing,
+      [],
+      `${locale.name} is missing ${missing.length} message keys`,
+    );
+  }
+});

application/i18n/locales/ru/core.ts

@@ -1130,8 +1130,123 @@ export const ruCoreMessages: Messages = {
   'deepLink.jms.unsupported': 'Неподдерживаемый протокол JumpServer: {{protocol}}',
 
   'settings.tab.plugins': 'Плагины',
-  'settings.plugins.title': 'Настройки плагинов',
-  'settings.plugins.description': 'Проверенные нативные настройки от плагинов разработки.',
+  "settings.plugins.manager.installed": "Установленные плагины",
+  "settings.plugins.manager.import": "Импорт .ncpkg",
+  "settings.plugins.manager.preview": "Импортированные пакеты отключены до проверки и включения.",
+  "settings.plugins.manager.empty": "Импортируйте локальный пакет плагина.",
+  "settings.plugins.manager.enabled": "Включён",
+  "settings.plugins.manager.disabled": "Отключён",
+  "settings.plugins.manager.enable": "Включить",
+  "settings.plugins.manager.disable": "Отключить",
+  "settings.plugins.manager.remove": "Удалить",
+  "settings.plugins.manager.removeNote": "Удаление очищает код пакета и локальные данные KV. Настройки пользователя, секреты и данные синхронизации сохраняются.",
+  "settings.plugins.permissions.statusUnknown": "Состояние неизвестно",
+  "plugins.sidebar.extensions": "Страницы расширений",
+  "plugins.sidebar.selectTerminal": "Сначала выберите открытый терминал.",
+  "plugins.sidebar.loading": "Загрузка страницы расширения…",
+  "plugins.vault.loading": "Загрузка страницы плагина…",
+  "plugins.vault.extensions": "Расширения",
+  "plugins.vault.back": "К хостам",
+  "plugins.interaction.title": "Запрос плагина",
+  "plugins.interaction.sharing": "Переданный текст доступен плагину и его разрешённым возможностям, включая сеть. Чтение не разрешает новый сетевой адрес.",
+  "plugins.interaction.input": "Ввести текст",
+  "plugins.interaction.filter": "Фильтр вариантов",
+  "plugins.interaction.preview": "Предпросмотр буфера обмена",
+  "plugins.interaction.previewNote": "Буфер читается только после нажатия предпросмотра. Затем проверьте текст и отдельно подтвердите передачу.",
+  "plugins.interaction.previewAction": "Предпросмотр буфера обмена",
+  "plugins.interaction.share": "Передать плагину",
+  "plugins.interaction.copy": "Копировать в буфер обмена",
+  "plugins.interaction.failed": "Запрос истёк или не выполнен.",
+  "settings.plugins.permissions.current": "Соответствует текущему запуску",
+  "settings.plugins.permissions.inactive": "Не действует для текущего запуска",
+  "settings.plugins.permissions.title": "Сохранённые разрешения",
+  "settings.plugins.permissions.refresh": "Обновить",
+  "settings.plugins.permissions.loading": "Загрузка разрешений...",
+  "settings.plugins.permissions.empty": "Сохранённых разрешений нет. Одноразовые решения не сохраняются.",
+  "settings.plugins.permissions.always": "До отзыва",
+  "settings.plugins.permissions.application": "До выхода из Netcatty",
+  "settings.plugins.permissions.session": "До закрытия сеанса",
+  "settings.plugins.permissions.audit": "Последние события безопасности (до 100)",
+  "settings.plugins.permissions.revoke": "Отключить и отозвать все разрешения",
+  "settings.plugins.permissions.revokeNote": "Плагин будет отключён, его задачи отменены, а сохранённые разрешения удалены. Включите его для нового запроса доступа.",
+  "settings.plugins.permissions.unavailable": "Управление разрешениями недоступно",
+  "settings.plugins.manager.permissions": "Заявленные разрешения",
+  "settings.plugins.manager.permissionNote": "Из манифеста, а не предоставленные права. Включение допускает отложенную активацию; обязательные разрешения запрашиваются перед ней, необязательные — при использовании. Чувствительные операции проверяются приложением.",
+  "settings.plugins.manager.noPermissions": "Привилегированные разрешения не заявлены.",
+  "settings.plugins.manager.required": "Обязательно",
+  "settings.plugins.manager.optional": "Необязательно",
+  "settings.plugins.themes.title": "Темы плагинов",
+  "settings.plugins.themes.description": "Предпросмотр меняет только это окно. Применение сохраняет выбор на этом устройстве. Личные настройки сохраняются.",
+  "settings.plugins.themes.empty": "Нет включённых тем для этого режима.",
+  "settings.plugins.themes.choose": "Выберите тему",
+  "settings.plugins.themes.unavailable": "Сохранённая тема недоступна; используется стандартная палитра",
+  "settings.plugins.themes.applied": "Применено",
+  "settings.plugins.themes.preview": "Предпросмотр",
+  "settings.plugins.themes.apply": "Применить",
+  "settings.plugins.themes.cancel": "Отменить предпросмотр",
+  "settings.plugins.themes.restore": "Сбросить тему",
+  "settings.plugins.themes.invalid": "Некоторые палитры недоступны или отклонены.",
+  "settings.plugins.themes.failed": "Не удалось применить тему.",
+  "settings.plugins.manager.dataTheme": "Пакет тем: проверенные цвета без выполнения кода.",
+  "settings.plugins.manager.browser": "Браузерная среда: привилегированный доступ проходит через проверку разрешений приложения.",
+  "settings.plugins.manager.advanced": "Расширенная среда: полный доступ Node к файловой системе и сети. Разрешения посредника не ограничивают этот доступ. Только для разработки.",
+  "settings.plugins.manager.data": "Данные KV остаются на устройстве. Синхронизируются только явно отмеченные несекретные настройки в зашифрованных данных. Пакеты и разрешения не синхронизируются.",
+  "settings.plugins.market.results": "Плагинов: {count}",
+  "settings.plugins.manager.lastError": "Последняя записанная ошибка",
+  "settings.plugins.sources.offline": "Источник недоступен. Ранее проверенный каталог этого источника, если он есть в кэше, доступен только для просмотра. Установка недоступна до успешного обновления.",
+  "settings.plugins.sources.note": "Этот каталог предоставляет выбранная третья сторона; Netcatty не отбирает его содержимое. Перед установкой проверьте домен источника и разрешения. Обновления выполняются вручную.",
+  "settings.plugins.sources.sourceOnly": "Запись с исходным кодом от этого поставщика. Пакет для загрузки отсутствует; см. инструкции автора по сборке и импорту.",
+  "settings.plugins.market.offline": "Реестр недоступен. Показан последний корректный каталог или встроенные примеры. Для установки необходимо успешно обновить каталог.",
+  "settings.plugins.manager.details": "Подробнее",
+  "settings.plugins.manager.noDescription": "Описание не предоставлено.",
+  "settings.plugins.status": "Уведомления: {count}",
+  "settings.plugins.info": "Информация о плагинах",
+  "settings.plugins.manager.noVaultShort": "Хранилище секретов недоступно",
+  "settings.plugins.market.offlineShort": "Каталог офлайн · установка недоступна",
+  "settings.plugins.market.readmeInfo": "Об этом README",
+  "settings.plugins.market.installed": "Установлен",
+  "settings.plugins.market.sourceBadge": "Пример исходного кода",
+  "settings.plugins.market.title": "Каталог",
+  "settings.plugins.market.note": "Отобранные плагины с открытым кодом. Проверка не гарантирует безопасность. Обновления выполняются вручную.",
+  "settings.plugins.market.back": "Все плагины",
+  "settings.plugins.market.install": "Установить эту версию (отключённой)",
+  "settings.plugins.market.installNote": "Установленная версия будет заменена и остановлена. Проверьте разрешения перед включением.",
+  "settings.plugins.market.sourceOnly": "Пример из этого проекта. Соберите локальной CLI и импортируйте .ncpkg; готовый пакет для скачивания не опубликован.",
+  "settings.plugins.market.readmeNote": "Зафиксирован указанный коммит. HTML не выполняется, внешние изображения не загружаются. Текст автора плагина.",
+  "settings.plugins.manager.noVault": "Системное хранилище ключей недоступно. Операции с секретами и учётными данными заблокированы; каталог и плагины без секретов доступны.",
+  "settings.plugins.manager.sensitive": "Чувствительный доступ: проверьте данные и область ресурсов перед разрешением.",
+  "settings.plugins.manager.dual": "По умолчанию используется браузерная среда. Пакет также содержит вход Node с полным доступом к устройству; только для разработчиков.",
+  "settings.plugins.manager.advancedDeclaration": "Браузерная точка входа с заявленными расширенными разрешениями. Не допускается в обычном режиме; проверьте все разрешения.",
+  "settings.plugins.market.retry": "Повторить",
+  "settings.plugins.market.empty": "Каталог пуст. Можно импортировать локальный браузерный плагин.",
+  "settings.plugins.market.emptyReadme": "Этот README пуст.",
+  "settings.plugins.market.search": "Поиск по имени, автору или описанию",
+  "settings.plugins.market.noResults": "Совпадений нет. Измените запрос.",
+  "settings.plugins.market.manifest": "Совместимость и разрешения",
+  "settings.plugins.manager.unbounded": "Более узкая область ресурсов не заявлена. Проверьте фактическую область в запросе разрешения.",
+  "settings.plugins.openView": "Открыть",
+  "settings.plugins.openManager": "Открыть управление плагинами",
+  "settings.plugins.sources.conflict": "This ID is installed from another source. Uninstall and explicitly reset its private data before switching. Existing source:",
+  "settings.plugins.sources.clearPrivate": "Also clear this source’s private data, grants and secrets to reinstall from another source. This cannot be undone.",
+  "settings.plugins.sources.official": "Official marketplace",
+  "settings.plugins.sources.thirdparty": "Third-party marketplace",
+  "settings.plugins.sources.manage": "Manage sources",
+  "settings.plugins.sources.select": "Select a source",
+  "settings.plugins.sources.empty": "Choose or add a third-party source.",
+  "settings.plugins.sources.add": "Add source",
+  "settings.plugins.sources.remove": "Remove source",
+  "settings.plugins.sources.name": "Source name",
+  "settings.plugins.sources.address": "HTTPS source address",
+  "settings.plugins.sources.risk": "Third-party sources are not maintained or endorsed by Netcatty. Review the real domain, package permissions and author before installing.",
+  "settings.plugins.sources.accept": "I trust this domain to supply plugin metadata and packages. This does not grant plugin permissions.",
+  "settings.plugins.sources.removeNote": "Installed plugins and their data remain. Updates from this source stop; another source will not replace it.",
+  "settings.plugins.sources.disablePlugins": "Also disable plugins installed from this source",
+  "settings.plugins.sources.installConfirm": "Review third-party installation",
+  "settings.plugins.sources.source": "Source",
+  "settings.plugins.sources.local": "Local import",
+  "settings.plugins.sources.all": "All sources",
+  "settings.plugins.title": "Плагины",
+  "settings.plugins.description": "Управляйте плагинами и просматривайте каталог.",
   'settings.plugins.loading': 'Загрузка настроек плагинов…',
   'settings.plugins.empty': 'Включённые плагины не предоставляют настройки.',
   'settings.plugins.scopeContext': 'Откройте эту настройку в контексте {scope}.',
@@ -1160,4 +1275,19 @@ export const ruCoreMessages: Messages = {
   'plugins.authentication.responseFailed': 'Не удалось отправить ответ аутентификации. Повторите попытку или отмените запрос.',
   'plugins.authentication.responseFailedWithMessage': 'Не удалось отправить ответ аутентификации: {message}. Повторите попытку или отмените запрос.',
   'plugins.authentication.continue': 'Продолжить',
+  'plugins.hostActions.select': 'Передать метаданные выбранных хостов',
+  'plugins.hostActions.selectionNote': 'Плагину будут переданы сохранённые имена, адреса, пользователи, протоколы, группы и теги. Группа включает только выбранные сейчас хосты. Подключение требует отдельного подтверждения.',
+  'plugins.hostActions.create': 'Проверить черновик хоста',
+  'plugins.hostActions.edit': 'Проверить изменения хоста',
+  'plugins.hostActions.connect': 'Подтвердить подключение',
+  'plugins.hostActions.fieldDiff': 'Изменения для сохранения',
+  'plugins.hostActions.defaultsWarning': 'Применяются сохранённые настройки подключения. Смена группы может изменить унаследованные настройки входа, прокси и скрипты.',
+  'plugins.hostActions.invalidDraft': 'Введите корректные данные хоста.',
+  'plugins.hostActions.scriptsRun': 'При подключении могут выполняться сохранённые скрипты запуска, подключения или вывода.',
+  'plugins.hostActions.noScripts': 'Для этого хоста не настроены сохранённые скрипты запуска, подключения или вывода.',
+  'plugins.hostActions.connectionNote': 'Netcatty откроет подключение с сохранёнными настройками. Содержимое сеанса не передаётся плагину.',
+  'plugins.hostActions.localExecution': 'Локальное выполнение: откроется оболочка на этом устройстве.',
+  'plugins.hostActions.managedUnsupported': 'Изменяйте управляемые настройки SSH в редакторе хостов Vault.',
+  'plugins.hostActions.failed': 'Запрос истёк, был отозван или хост изменился. Выберите хост заново.',
+  'plugins.hostActions.selectionLimit': 'Выберите не более 50 текущих хостов.',
 };

application/i18n/locales/ru/terminal.ts

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

application/i18n/locales/ru/vault.ts

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

application/i18n/locales/settingsLocales.test.ts

@@ -18,12 +18,19 @@ const LOCALIZED_SETTINGS_LOCALES = [
 
 const APP_LOCK_LOCALES = [
   { name: "en", messages: en },
-  { name: "zh-CN", messages: zhCN },
+  { name: "es", messages: es },
   { name: "ru", messages: ru },
+  { name: "zh-CN", messages: zhCN },
+  { name: "zh-TW", messages: zhTW },
+];
+
+const ALL_SETTINGS_LOCALES = [
+  { name: "en", messages: en },
+  ...LOCALIZED_SETTINGS_LOCALES,
 ];
 
 test("localized settings include names for every default shortcut", () => {
-  for (const locale of LOCALIZED_SETTINGS_LOCALES) {
+  for (const locale of ALL_SETTINGS_LOCALES) {
     const missing = DEFAULT_KEY_BINDINGS
       .map((binding) => `settings.shortcuts.binding.${binding.id}`)
       .filter((key) => !locale.messages[key]);

application/i18n/locales/sftpCleanupWarningLocales.test.ts

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

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

@@ -1035,6 +1035,7 @@ Vaults 标签保持扁平，不使用这块背景。
   'sftp.transfers.openTargetFolder': '打开目标目录',
   'sftp.transfers.openTargetFolderError': '无法打开目标目录',
   'sftp.transfers.copyTargetPath': '复制目标路径',
+  'sftp.transfers.cleanupWarnings': '备份清理警告：{count}。展开文件列表查看详情。',
   'sftp.transfers.copyTargetPathSuccess': '已复制目标路径',
   'sftp.transfers.copyTargetPathError': '无法复制目标路径',
   'sftp.transfers.pathConflict.title': '无法开始传输',
@@ -1149,8 +1150,123 @@ Vaults 标签保持扁平，不使用这块背景。
   'qs.localShells': '本地 Shell',
   'qs.default': '默认',
   'settings.tab.plugins': '插件',
-  'settings.plugins.title': '插件设置',
-  'settings.plugins.description': '由开发插件提供、经 Netcatty 原生组件验证的设置。',
+  "settings.plugins.manager.installed": "已安装插件",
+  "settings.plugins.manager.import": "导入 .ncpkg",
+  "settings.plugins.manager.preview": "导入的插件保持停用，请检查后再启用。",
+  "settings.plugins.manager.empty": "导入本地插件包以开始使用。",
+  "settings.plugins.manager.enabled": "已启用",
+  "settings.plugins.manager.disabled": "已停用",
+  "settings.plugins.manager.enable": "启用",
+  "settings.plugins.manager.disable": "停用",
+  "settings.plugins.manager.remove": "卸载",
+  "settings.plugins.manager.removeNote": "卸载会移除插件代码和本地 KV 数据，保留用户设置、秘密存储和同步 sidecar。",
+  "settings.plugins.permissions.statusUnknown": "状态未知",
+  "plugins.sidebar.extensions": "扩展页面",
+  "plugins.sidebar.selectTerminal": "请先选择已打开的终端。",
+  "plugins.sidebar.loading": "正在加载扩展页面…",
+  "plugins.vault.loading": "正在加载插件页面…",
+  "plugins.vault.extensions": "扩展",
+  "plugins.vault.back": "返回主机",
+  "plugins.interaction.title": "插件请求",
+  "plugins.interaction.sharing": "分享的文本将交给此插件及其已授权的能力（包括网络访问）。读取文本不代表批准新的网络目标。",
+  "plugins.interaction.input": "输入文本",
+  "plugins.interaction.filter": "筛选选项",
+  "plugins.interaction.preview": "剪贴板预览",
+  "plugins.interaction.previewNote": "仅在点击“预览剪贴板”后读取。检查文本后，还需单独确认才能分享给插件。",
+  "plugins.interaction.previewAction": "预览剪贴板",
+  "plugins.interaction.share": "分享给插件",
+  "plugins.interaction.copy": "复制到剪贴板",
+  "plugins.interaction.failed": "此请求已过期或无法完成。",
+  "settings.plugins.permissions.current": "匹配当前运行实例",
+  "settings.plugins.permissions.inactive": "对当前运行实例不生效",
+  "settings.plugins.permissions.title": "已保存的授权",
+  "settings.plugins.permissions.refresh": "刷新",
+  "settings.plugins.permissions.loading": "正在读取授权...",
+  "settings.plugins.permissions.empty": "没有已保存的授权。单次决定不会保留。",
+  "settings.plugins.permissions.always": "直到撤销",
+  "settings.plugins.permissions.application": "直到退出 Netcatty",
+  "settings.plugins.permissions.session": "直到会话关闭",
+  "settings.plugins.permissions.audit": "最近的安全事件（最多 100 条）",
+  "settings.plugins.permissions.revoke": "停用并撤销全部授权",
+  "settings.plugins.permissions.revokeNote": "此操作会停用插件、取消其工作并删除已保存的授权。重新启用后可申请新授权。",
+  "settings.plugins.permissions.unavailable": "插件授权管理不可用",
+  "settings.plugins.manager.permissions": "声明的权限",
+  "settings.plugins.manager.permissionNote": "来自 manifest，不代表已授权。启用表示允许按需激活；必需权限在首次激活前申请，可选权限在用到时申请。敏感操作仍受宿主检查。",
+  "settings.plugins.manager.noPermissions": "未声明特权权限。",
+  "settings.plugins.manager.required": "必需",
+  "settings.plugins.manager.optional": "可选",
+  "settings.plugins.themes.title": "插件主题",
+  "settings.plugins.themes.description": "预览仅影响当前窗口；应用后保存在本设备。个人强调色、字体和终端覆盖设置仍然优先。",
+  "settings.plugins.themes.empty": "当前模式没有已启用的插件主题。",
+  "settings.plugins.themes.choose": "选择主题",
+  "settings.plugins.themes.unavailable": "已保存的主题不可用，正在使用宿主默认配色",
+  "settings.plugins.themes.applied": "已应用",
+  "settings.plugins.themes.preview": "预览",
+  "settings.plugins.themes.apply": "应用",
+  "settings.plugins.themes.cancel": "取消预览",
+  "settings.plugins.themes.restore": "恢复默认",
+  "settings.plugins.themes.invalid": "部分主题配色未通过验证或不可用。",
+  "settings.plugins.themes.failed": "无法应用主题。",
+  "settings.plugins.manager.dataTheme": "主题包：已验证配色，不启动代码运行时。",
+  "settings.plugins.manager.browser": "浏览器运行时：特权访问通过宿主权限代理。",
+  "settings.plugins.manager.advanced": "高级运行时：拥有完整 Node 文件系统和网络能力，代理权限无法限制这些访问。仅供开发预览。",
+  "settings.plugins.manager.data": "本地 KV 仅保留在此设备。只有明确标记为同步的非秘密设置进入加密云 sidecar。插件包和权限授权不参与同步。",
+  "settings.plugins.market.results": "{count} 个插件",
+  "settings.plugins.manager.lastError": "上次记录的错误",
+  "settings.plugins.sources.offline": "来源暂不可用。如已缓存此来源通过校验的目录，仅可继续浏览；刷新成功前无法安装。",
+  "settings.plugins.sources.note": "此目录由所选第三方提供，不属于 Netcatty 精选目录。安装前请核对来源域名和权限，更新需手动确认。",
+  "settings.plugins.sources.sourceOnly": "此提供方仅提供源码条目，没有可下载插件包；请查看作者的构建和导入说明。",
+  "settings.plugins.market.offline": "官方目录暂时不可用，正在显示上次有效目录或内置示例。刷新成功前不能从市场安装。",
+  "settings.plugins.manager.details": "查看详情",
+  "settings.plugins.manager.noDescription": "作者暂未提供功能简介。",
+  "settings.plugins.status": "{count} 项提醒",
+  "settings.plugins.info": "插件说明",
+  "settings.plugins.manager.noVaultShort": "凭据存储不可用",
+  "settings.plugins.market.offlineShort": "目录离线 · 暂不可安装",
+  "settings.plugins.market.readmeInfo": "README 来源说明",
+  "settings.plugins.market.installed": "已安装",
+  "settings.plugins.market.sourceBadge": "源码示例",
+  "settings.plugins.market.title": "插件市场",
+  "settings.plugins.market.note": "精选开源插件。审核不代表安全认证，更新由你手动确认。",
+  "settings.plugins.market.back": "所有插件",
+  "settings.plugins.market.install": "安装此版本（保持停用）",
+  "settings.plugins.market.installNote": "这会替换并停止已安装版本。请在已安装列表检查权限后再启用。",
+  "settings.plugins.market.sourceOnly": "第一方源码示例。请用本地 CLI 构建并导入 .ncpkg；尚未发布可下载发行包。",
+  "settings.plugins.market.readmeNote": "固定到上面的提交。HTML 不执行，远程图片不加载。内容由插件作者提供。",
+  "settings.plugins.manager.noVault": "系统密钥存储不可用。秘密和凭据操作被阻止；浏览市场和不使用秘密的插件仍可使用。",
+  "settings.plugins.manager.sensitive": "敏感访问：授权前请检查涉及的数据和资源范围。",
+  "settings.plugins.manager.dual": "默认使用浏览器运行时，但包中还包含拥有完整设备权限的 Node 入口；仅限开发者模式。",
+  "settings.plugins.manager.advancedDeclaration": "浏览器入口声明了高级权限。不适用于普通浏览器插件模式；请逐项检查声明权限。",
+  "settings.plugins.market.retry": "重试",
+  "settings.plugins.market.empty": "目录暂无插件，仍可导入本地浏览器插件。",
+  "settings.plugins.market.emptyReadme": "README 内容为空。",
+  "settings.plugins.market.search": "搜索名称、作者或描述",
+  "settings.plugins.market.noResults": "没有匹配插件，请尝试其他关键词。",
+  "settings.plugins.market.manifest": "兼容性与权限",
+  "settings.plugins.manager.unbounded": "未声明更细的资源范围。请在权限提示中检查实际授权范围。",
+  "settings.plugins.openView": "打开",
+  "settings.plugins.openManager": "打开插件管理",
+  "settings.plugins.sources.conflict": "此 ID 已从其他来源安装。请先卸载并明确清理旧来源数据，再换源重装。原来源：",
+  "settings.plugins.sources.clearPrivate": "同时清除本来源的私有数据、授权和秘密，以便显式换源重装。此操作不可撤销。",
+  "settings.plugins.sources.official": "官方市场",
+  "settings.plugins.sources.thirdparty": "第三方市场",
+  "settings.plugins.sources.manage": "管理来源",
+  "settings.plugins.sources.select": "选择来源",
+  "settings.plugins.sources.empty": "选择或添加第三方来源。",
+  "settings.plugins.sources.add": "添加来源",
+  "settings.plugins.sources.remove": "移除来源",
+  "settings.plugins.sources.name": "来源名称",
+  "settings.plugins.sources.address": "HTTPS 来源地址",
+  "settings.plugins.sources.risk": "第三方来源不代表 Netcatty 维护或认可。安装前请核对真实域名、插件权限与作者。",
+  "settings.plugins.sources.accept": "我信任此域名提供插件目录和软件包。此操作不会授予插件权限。",
+  "settings.plugins.sources.removeNote": "保留已安装插件及数据，停止此来源更新，不会自动切换到其他来源。",
+  "settings.plugins.sources.disablePlugins": "同时停用来自该来源的插件",
+  "settings.plugins.sources.installConfirm": "确认第三方安装",
+  "settings.plugins.sources.source": "来源",
+  "settings.plugins.sources.local": "本地导入",
+  "settings.plugins.sources.all": "全部来源",
+  "settings.plugins.title": "插件",
+  "settings.plugins.description": "管理已安装插件，浏览精选目录。",
   'settings.plugins.loading': '正在加载插件设置…',
   'settings.plugins.empty': '当前没有已启用插件提供设置。',
   'settings.plugins.scopeContext': '请在对应的 {scope} 上下文中打开此设置。',
@@ -1179,5 +1295,20 @@ Vaults 标签保持扁平，不使用这块背景。
   'plugins.authentication.responseFailed': '无法发送认证响应。请重试或取消此请求。',
   'plugins.authentication.responseFailedWithMessage': '无法发送认证响应：{message}。请重试或取消此请求。',
   'plugins.authentication.continue': '继续',
+  'plugins.hostActions.select': '分享所选主机的元数据',
+  'plugins.hostActions.selectionNote': '向此插件分享已保存的名称、地址、用户名、协议、分组和标签。选择分组仅包含本次选中的成员。连接主机需要单独确认。',
+  'plugins.hostActions.create': '预览主机草稿',
+  'plugins.hostActions.edit': '预览主机修改',
+  'plugins.hostActions.connect': '确认连接',
+  'plugins.hostActions.fieldDiff': '即将保存的修改',
+  'plugins.hostActions.defaultsWarning': '将应用已保存的连接默认设置。修改分组可能改变继承的认证、代理和脚本设置。',
+  'plugins.hostActions.invalidDraft': '请输入有效的主机草稿。',
+  'plugins.hostActions.scriptsRun': '此连接可能运行已保存的启动、连接或输出触发脚本。',
+  'plugins.hostActions.noScripts': '此主机未配置已保存的启动、连接或输出触发脚本。',
+  'plugins.hostActions.connectionNote': 'Netcatty 将使用已保存的设置打开连接。这不会向插件分享会话内容。',
+  'plugins.hostActions.localExecution': '本地执行：这将在此设备上打开一个 Shell。',
+  'plugins.hostActions.managedUnsupported': '受管理的 SSH 配置变更需在 Vault 主机编辑器中完成。',
+  'plugins.hostActions.failed': '请求已过期、被撤销或主机已改变。请重新选择主机。',
+  'plugins.hostActions.selectionLimit': '最多选择 50 个当前主机。',
 
 };

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

@@ -969,6 +969,7 @@ export const zhCNTerminalMessages: Messages = {
   'serial.field.flowControl': '流控制',
   'serial.noPorts': '未检测到串口设备。请连接设备后刷新。',
   'serial.field.customPort': '自定义串口路径',
+  'serial.field.namedPipeHint': 'Windows 虚拟机控制台：输入 \\\\.\\pipe\\name。虚拟机需作为服务端创建管道，波特率和串口帧设置不生效。',
   'serial.field.customPortPlaceholder': '例如 /dev/ttys001 或 COM1',
   'serial.type.hardware': '硬件',
   'serial.type.pseudo': '虚拟终端',

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

@@ -1037,6 +1037,7 @@ Vaults 分頁維持扁平，不使用這塊背景。
   'sftp.transfers.openTargetFolder': '開啟目標目錄',
   'sftp.transfers.openTargetFolderError': '無法開啟目標目錄',
   'sftp.transfers.copyTargetPath': '複製目標路徑',
+  'sftp.transfers.cleanupWarnings': '備份清理警告：{count}。展開檔案清單查看詳情。',
   'sftp.transfers.copyTargetPathSuccess': '已複製目標路徑',
   'sftp.transfers.copyTargetPathError': '無法複製目標路徑',
   'sftp.transfers.pathConflict.title': '無法開始傳輸',
@@ -1152,9 +1153,124 @@ Vaults 分頁維持扁平，不使用這塊背景。
   'qs.default': '預設',
 
   'settings.tab.plugins': '外掛程式',
-  'settings.plugins.title': '外掛程式設定',
-  'settings.plugins.description': '由開發外掛程式提供、經 Netcatty 原生元件驗證的設定。',
+  "settings.plugins.manager.installed": "已安裝插件",
+  "settings.plugins.manager.import": "導入 .ncpkg",
+  "settings.plugins.manager.preview": "導入的插件保持停用，請檢查後再啟用。",
+  "settings.plugins.manager.empty": "導入本地插件包以開始使用。",
+  "settings.plugins.manager.enabled": "已啟用",
+  "settings.plugins.manager.disabled": "已停用",
+  "settings.plugins.manager.enable": "啟用",
+  "settings.plugins.manager.disable": "停用",
+  "settings.plugins.manager.remove": "卸載",
+  "settings.plugins.manager.removeNote": "卸載會移除插件代碼和本地 KV 數據，保留用戶設置、秘密存儲和同步 sidecar。",
+  "settings.plugins.permissions.statusUnknown": "狀態不明",
+  "plugins.sidebar.extensions": "擴充功能頁面",
+  "plugins.sidebar.selectTerminal": "請先選擇已開啟的終端。",
+  "plugins.sidebar.loading": "正在載入擴充功能頁面…",
+  "plugins.vault.loading": "正在載入擴充功能頁面…",
+  "plugins.vault.extensions": "擴充功能",
+  "plugins.vault.back": "返回主機",
+  "plugins.interaction.title": "外掛請求",
+  "plugins.interaction.sharing": "分享的文字會交給此外掛及其已授權能力（包括網路存取）。讀取文字不代表核准新的網路目的地。",
+  "plugins.interaction.input": "輸入文字",
+  "plugins.interaction.filter": "篩選選項",
+  "plugins.interaction.preview": "剪貼簿預覽",
+  "plugins.interaction.previewNote": "僅在點選「預覽剪貼簿」後讀取。檢查文字後，還需另外確認才能分享給外掛。",
+  "plugins.interaction.previewAction": "預覽剪貼簿",
+  "plugins.interaction.share": "分享給外掛",
+  "plugins.interaction.copy": "複製到剪貼簿",
+  "plugins.interaction.failed": "此請求已過期或無法完成。",
+  "settings.plugins.permissions.current": "符合目前執行個體",
+  "settings.plugins.permissions.inactive": "對目前執行個體不生效",
+  "settings.plugins.permissions.title": "已儲存的授權",
+  "settings.plugins.permissions.refresh": "重新整理",
+  "settings.plugins.permissions.loading": "正在讀取授權...",
+  "settings.plugins.permissions.empty": "沒有已儲存的授權。單次決定不會保留。",
+  "settings.plugins.permissions.always": "直到撤銷",
+  "settings.plugins.permissions.application": "直到退出 Netcatty",
+  "settings.plugins.permissions.session": "直到工作階段關閉",
+  "settings.plugins.permissions.audit": "最近的安全事件（最多 100 筆）",
+  "settings.plugins.permissions.revoke": "停用並撤銷全部授權",
+  "settings.plugins.permissions.revokeNote": "此操作會停用外掛、取消其工作並刪除已儲存的授權。重新啟用後可申請新授權。",
+  "settings.plugins.permissions.unavailable": "外掛授權管理無法使用",
+  "settings.plugins.manager.permissions": "聲明的權限",
+  "settings.plugins.manager.permissionNote": "來自 manifest，不代表已授權。啟用表示允許按需激活；必需權限在首次激活前申請，可選權限在用到時申請。敏感操作仍受宿主檢查。",
+  "settings.plugins.manager.noPermissions": "未聲明特權權限。",
+  "settings.plugins.manager.required": "必需",
+  "settings.plugins.manager.optional": "可選",
+  "settings.plugins.themes.title": "外掛主題",
+  "settings.plugins.themes.description": "預覽僅影響目前視窗；套用後儲存於本機。個人強調色、字型和終端覆寫設定仍然優先。",
+  "settings.plugins.themes.empty": "目前模式沒有已啟用的外掛主題。",
+  "settings.plugins.themes.choose": "選擇主題",
+  "settings.plugins.themes.unavailable": "已儲存的主題無法使用，正在使用宿主預設配色",
+  "settings.plugins.themes.applied": "已套用",
+  "settings.plugins.themes.preview": "預覽",
+  "settings.plugins.themes.apply": "套用",
+  "settings.plugins.themes.cancel": "取消預覽",
+  "settings.plugins.themes.restore": "恢復預設",
+  "settings.plugins.themes.invalid": "部分主題配色未通過驗證或無法使用。",
+  "settings.plugins.themes.failed": "無法套用主題。",
+  "settings.plugins.manager.dataTheme": "主題套件：已驗證配色，不啟動程式執行環境。",
+  "settings.plugins.manager.browser": "瀏覽器運行時：特權訪問通過宿主權限代理。",
+  "settings.plugins.manager.advanced": "高級運行時：擁有完整 Node 文件系統和網絡能力，代理權限無法限制這些訪問。僅供開發預覽。",
+  "settings.plugins.manager.data": "本地 KV 僅保留在此設備。只有明確標記為同步的非秘密設置進入加密雲 sidecar。插件包和權限授權不參與同步。",
+  "settings.plugins.manager.unbounded": "未宣告更細的資源範圍。請在權限提示中檢查實際授權範圍。",
+  "settings.plugins.openView": "開啟",
+  "settings.plugins.openManager": "開啟插件管理",
+  "settings.plugins.sources.conflict": "此 ID 已从其他来源安装。请先卸载并明确清理旧来源数据，再换源重装。原来源：",
+  "settings.plugins.sources.clearPrivate": "同时清除本来源的私有数据、授权和秘密，以便显式换源重装。此操作不可撤销。",
+  "settings.plugins.sources.official": "官方市场",
+  "settings.plugins.sources.thirdparty": "第三方市场",
+  "settings.plugins.sources.manage": "管理来源",
+  "settings.plugins.sources.select": "选择来源",
+  "settings.plugins.sources.empty": "选择或添加第三方来源。",
+  "settings.plugins.sources.add": "添加来源",
+  "settings.plugins.sources.remove": "移除来源",
+  "settings.plugins.sources.name": "来源名称",
+  "settings.plugins.sources.address": "HTTPS 来源地址",
+  "settings.plugins.sources.risk": "第三方来源不代表 Netcatty 维护或认可。安装前请核对真实域名、插件权限与作者。",
+  "settings.plugins.sources.accept": "我信任此域名提供插件目录和软件包。此操作不会授予插件权限。",
+  "settings.plugins.sources.removeNote": "保留已安装插件及数据，停止此来源更新，不会自动切换到其他来源。",
+  "settings.plugins.sources.disablePlugins": "同时停用来自该来源的插件",
+  "settings.plugins.sources.installConfirm": "确认第三方安装",
+  "settings.plugins.sources.source": "来源",
+  "settings.plugins.sources.local": "本地导入",
+  "settings.plugins.sources.all": "全部来源",
+  "settings.plugins.title": "插件",
+  "settings.plugins.description": "管理已安裝插件，瀏覽精選目錄。",
   'settings.plugins.loading': '正在載入外掛程式設定…',
+  "settings.plugins.market.results": "{count} 個插件",
+  "settings.plugins.manager.lastError": "上次記錄的錯誤",
+  "settings.plugins.sources.offline": "來源暫不可用。如已快取此來源通過驗證的目錄，僅可繼續瀏覽；重新整理成功前無法安裝。",
+  "settings.plugins.sources.note": "此目錄由所選第三方提供，不屬於 Netcatty 精選目錄。安裝前請核對來源網域和權限，更新需手動確認。",
+  "settings.plugins.sources.sourceOnly": "此提供方僅提供原始碼項目，沒有可下載外掛套件；請查看作者的建置和匯入說明。",
+  "settings.plugins.market.offline": "官方目錄暫時無法使用，正在顯示上次有效目錄或內建範例。重新整理成功前無法從市場安裝。",
+  "settings.plugins.manager.details": "查看詳情",
+  "settings.plugins.manager.noDescription": "作者尚未提供功能簡介。",
+  "settings.plugins.status": "{count} 項提醒",
+  "settings.plugins.info": "外掛說明",
+  "settings.plugins.manager.noVaultShort": "憑據儲存無法使用",
+  "settings.plugins.market.offlineShort": "目錄離線 · 暫時無法安裝",
+  "settings.plugins.market.readmeInfo": "README 來源說明",
+  "settings.plugins.market.installed": "已安裝",
+  "settings.plugins.market.sourceBadge": "原始碼範例",
+  "settings.plugins.market.title": "插件市場",
+  "settings.plugins.market.note": "精選開源插件。審核不代表安全認證，更新由你手動確認。",
+  "settings.plugins.market.back": "所有插件",
+  "settings.plugins.market.install": "安裝此版本（保持停用）",
+  "settings.plugins.market.installNote": "這會替換並停止已安裝版本。請在已安裝列表檢查權限後再啟用。",
+  "settings.plugins.market.sourceOnly": "第一方源碼示例。請用本地 CLI 構建並導入 .ncpkg；尚未發佈可下載發行包。",
+  "settings.plugins.market.readmeNote": "固定到上面的提交。HTML 不執行，遠程圖片不加載。內容由插件作者提供。",
+  "settings.plugins.manager.noVault": "系統密鑰存儲不可用。秘密和憑據操作被阻止；瀏覽市場和不使用秘密的插件仍可使用。",
+  "settings.plugins.manager.sensitive": "敏感訪問：授權前請檢查涉及的數據和資源範圍。",
+  "settings.plugins.manager.dual": "默認使用瀏覽器運行時，但包中還包含擁有完整設備權限的 Node 入口；僅限開發者模式。",
+  "settings.plugins.manager.advancedDeclaration": "瀏覽器入口聲明瞭高級權限。不適用於普通瀏覽器插件模式；請逐項檢查聲明權限。",
+  "settings.plugins.market.retry": "重試",
+  "settings.plugins.market.empty": "目錄暫無插件，仍可導入本地瀏覽器插件。",
+  "settings.plugins.market.emptyReadme": "README 內容為空。",
+  "settings.plugins.market.search": "搜索名稱、作者或描述",
+  "settings.plugins.market.noResults": "沒有匹配插件，請嘗試其他關鍵詞。",
+  "settings.plugins.market.manifest": "兼容性與權限",
   'settings.plugins.empty': '目前沒有已啟用外掛程式提供設定。',
   'settings.plugins.scopeContext': '請在對應的 {scope} 情境中開啟此設定。',
   'settings.plugins.pressKeybinding': '請按下組合鍵',
@@ -1182,4 +1298,19 @@ Vaults 分頁維持扁平，不使用這塊背景。
   'plugins.authentication.responseFailed': '無法送出驗證回應。請重試或取消此要求。',
   'plugins.authentication.responseFailedWithMessage': '無法送出驗證回應：{message}。請重試或取消此要求。',
   'plugins.authentication.continue': '繼續',
+  'plugins.hostActions.select': '分享所選主機的中繼資料',
+  'plugins.hostActions.selectionNote': '向此外掛分享已儲存的名稱、位址、使用者名稱、協定、群組和標籤。選擇群組僅包含本次選取的成員。連線需要另外確認。',
+  'plugins.hostActions.create': '預覽主機草稿',
+  'plugins.hostActions.edit': '預覽主機修改',
+  'plugins.hostActions.connect': '確認連線',
+  'plugins.hostActions.fieldDiff': '即將儲存的修改',
+  'plugins.hostActions.defaultsWarning': '將套用已儲存的連線預設設定。修改群組可能改變繼承的驗證、代理和指令碼設定。',
+  'plugins.hostActions.invalidDraft': '請輸入有效的主機草稿。',
+  'plugins.hostActions.scriptsRun': '此連線可能執行已儲存的啟動、連線或輸出觸發指令碼。',
+  'plugins.hostActions.noScripts': '此主機未設定已儲存的啟動、連線或輸出觸發指令碼。',
+  'plugins.hostActions.connectionNote': 'Netcatty 將使用已儲存的設定開啟連線。這不會向外掛分享工作階段內容。',
+  'plugins.hostActions.localExecution': '本機執行：這會在此裝置上開啟 Shell。',
+  'plugins.hostActions.managedUnsupported': '受管理的 SSH 設定變更需在 Vault 主機編輯器中完成。',
+  'plugins.hostActions.failed': '請求已過期、被撤銷或主機已變更。請重新選擇主機。',
+  'plugins.hostActions.selectionLimit': '最多選擇 50 部目前的主機。',
 };

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

@@ -969,6 +969,7 @@ export const zhTWTerminalMessages: Messages = {
   'serial.field.flowControl': '流量控制',
   'serial.noPorts': '未偵測到序列埠裝置。請連線裝置後重新整理。',
   'serial.field.customPort': '自訂序列埠路徑',
+  'serial.field.namedPipeHint': 'Windows 虛擬機主控台：輸入 \\\\.\\pipe\\name。虛擬機需作為伺服器端建立管道，鮑率與串口框架設定不生效。',
   'serial.field.customPortPlaceholder': '例如 /dev/ttys001 或 COM1',
   'serial.type.hardware': '硬體',
   'serial.type.pseudo': '虛擬終端',

application/state/editorWindowClient.test.ts

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

application/state/editorWindowClient.ts

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

application/state/hiddenTabEviction.test.ts

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

application/state/hiddenTabEviction.ts

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

application/state/pluginHostActionExecution.test.ts

@@ -0,0 +1,128 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { executePluginHostAction, type PluginHostAction, type PluginHostActionVault } from './pluginHostActionExecution';
+import { PluginHostActionResources } from './pluginHostActionResources';
+import type { Host, ManagedSource } from '../../domain/models';
+
+const synthetic: Host = { id: 'synthetic', label: 'Synthetic', hostname: 'synthetic.invalid', username: 'test', tags: [], os: 'linux', password: 'synthetic-only', startupCommand: 'synthetic-script' };
+
+function fixture() {
+  const resources = new PluginHostActionResources();
+  let active = true, authorized = 0, connections = 0, writes = 0;
+  let beforeRead: (() => void) | undefined;
+  let beforeCommit: (() => void) | undefined;
+  let duringAuthorize: (() => void) | undefined;
+  let storedSources: ManagedSource[] | undefined;
+  const vault: PluginHostActionVault = {
+    hosts: [synthetic], customGroups: [], groupConfigs: [], snippets: [], managedSources: [], isInitialized: true,
+    async readPersistedHosts() { beforeRead?.(); return [structuredClone(synthetic)]; },
+    async commitVaultImportTransaction(next, groups, sources, _configs, _expected, _lock, authorize) {
+      const nextSources = sources(storedSources ?? vault.managedSources);
+      beforeCommit?.();
+      await authorize?.();
+      writes++; vault.hosts = next;
+      return { status: 'persisted', groups: groups([]), sources: nextSources, groupConfigs: [] };
+    },
+  };
+  resources.observe(vault.hosts);
+  const target = resources.metadata(synthetic.id);
+  const options = {
+    getVault: () => vault, resources,
+    assertCurrent() { if (!active) throw new Error('Action cancelled'); },
+    async authorizeCommit() { duringAuthorize?.(); if (!active) throw new Error('Action revoked'); authorized++; },
+    connect(host: Host) { assert.equal(host, synthetic); connections++; return 'private-session-id'; },
+  };
+  return { vault, target, options, get authorized() { return authorized; }, get connections() { return connections; }, get writes() { return writes; },
+    cancel() { active = false; }, beforeRead(fn: () => void) { beforeRead = fn; }, beforeCommit(fn: () => void) { beforeCommit = fn; }, duringAuthorize(fn: () => void) { duringAuthorize = fn; },
+    storedSources(value: ManagedSource[]) { storedSources = value; },
+  };
+}
+
+test('reviewed connection dispatches through existing handler and returns no session data', async () => {
+  const f = fixture();
+  assert.equal(await executePluginHostAction({ kind: 'connect', target: f.target }, f.options), 'requested');
+  assert.equal(f.authorized, 1); assert.equal(f.connections, 1); assert.equal(f.writes, 0);
+});
+
+test('host edit preserves credentials and scripts and claims action authority after preparation', async () => {
+  const f = fixture();
+  assert.equal(await executePluginHostAction({ kind: 'edit', target: f.target, draft: { label: 'Reviewed' } }, f.options), 'saved');
+  assert.equal(f.vault.hosts[0].password, synthetic.password);
+  assert.equal(f.vault.hosts[0].startupCommand, synthetic.startupCommand);
+  assert.equal(f.vault.hosts[0].label, 'Reviewed');
+  assert.equal(f.authorized, 1); assert.equal(f.writes, 1); assert.equal(f.connections, 0);
+});
+
+for (const point of ['beforeRead', 'beforeCommit', 'duringAuthorize'] as const) test(`cancel/revoke at ${point} prevents the Vault write`, async () => {
+  const f = fixture(); f[point](() => f.cancel());
+  await assert.rejects(executePluginHostAction({ kind: 'edit', target: f.target, draft: { label: 'Never saved' } }, f.options), /cancelled|revoked/);
+  assert.equal(f.writes, 0); assert.equal(f.connections, 0);
+});
+
+for (const change of ['remove', 'replace', 'scripts', 'locked'] as const) test(`${change} during awaited connection preparation prevents dispatch`, async () => {
+  const f = fixture();
+  f.beforeRead(() => {
+    if (change === 'remove') f.vault.hosts = [];
+    if (change === 'replace') f.vault.hosts = [{ ...synthetic }];
+    if (change === 'scripts') f.vault.snippets = [];
+    if (change === 'locked') f.cancel();
+  });
+  await assert.rejects(executePluginHostAction({ kind: 'connect', target: f.target }, f.options));
+  assert.equal(f.authorized, 0); assert.equal(f.connections, 0);
+});
+
+test('create produces a saved SSH draft without executable or credential injection', async () => {
+  const f = fixture();
+  const action: PluginHostAction = { kind: 'create', draft: { hostname: 'new.invalid', label: 'New', group: 'Synthetic', password: 'untrusted', startupCommand: 'untrusted' } as never };
+  assert.equal(await executePluginHostAction(action, f.options), 'saved');
+  const created = f.vault.hosts[1];
+  assert.notEqual(created.id, synthetic.id);
+  assert.equal(created.password, undefined); assert.equal(created.startupCommand, undefined);
+});
+
+const managedSources: ManagedSource[] = [
+  { id: 'synthetic-source-a', type: 'ssh_config', filePath: '/synthetic/a.conf', groupName: 'A', lastSyncedAt: 0 },
+  { id: 'synthetic-source-b', type: 'ssh_config', filePath: '/synthetic/b.conf', groupName: 'B', lastSyncedAt: 0 },
+];
+
+for (const destination of ['B', 'Unmanaged', ''] as const) test(`managed A to ${destination || 'no group'} is refused before action authority or persistence`, async () => {
+  const f = fixture();
+  const host = { ...synthetic, group: 'A', managedSourceId: managedSources[0].id };
+  f.vault.hosts = [host]; f.vault.managedSources = managedSources;
+  f.vault.readPersistedHosts = async () => [structuredClone(host)];
+  f.options.resources.observe(f.vault.hosts);
+  const target = f.options.resources.metadata(host.id);
+  await assert.rejects(executePluginHostAction({ kind: 'edit', target, draft: { group: destination } }, f.options), /Managed.*Vault/);
+  assert.equal(f.writes, 0); assert.equal(f.authorized, 0);
+  assert.equal(f.vault.hosts[0].managedSourceId, managedSources[0].id);
+});
+
+for (const kind of ['create', 'edit'] as const) test(`${kind} into a managed destination is refused`, async () => {
+  const f = fixture(); f.vault.managedSources = managedSources;
+  const action: PluginHostAction = kind === 'create'
+    ? { kind, draft: { hostname: 'new.invalid', group: 'B/Child' } }
+    : { kind, target: f.target, draft: { group: 'B/Child' } };
+  await assert.rejects(executePluginHostAction(action, f.options), /Managed.*Vault/);
+  assert.equal(f.writes, 0); assert.equal(f.authorized, 0);
+});
+
+test('ordinary unmanaged moves preserve the managed-source catalog without taking ownership', async () => {
+  const f = fixture(); f.vault.managedSources = managedSources;
+  assert.equal(await executePluginHostAction({ kind: 'edit', target: f.target, draft: { group: 'Unmanaged' } }, f.options), 'saved');
+  assert.equal(f.vault.hosts[0].managedSourceId, undefined);
+  assert.equal(f.vault.hosts[0].group, 'Unmanaged');
+  assert.equal(f.vault.managedSources, managedSources);
+});
+
+test('a managed-source catalog replacement during preparation prevents the write', async () => {
+  const f = fixture();
+  f.beforeCommit(() => { f.vault.managedSources = managedSources; });
+  await assert.rejects(executePluginHostAction({ kind: 'create', draft: { hostname: 'new.invalid', group: 'B' } }, f.options), /Managed sources changed/);
+  assert.equal(f.writes, 0); assert.equal(f.authorized, 0);
+});
+
+test('a newer persisted managed-source catalog rejects a stale unmanaged preview before the claim', async () => {
+  const f = fixture(); f.storedSources(managedSources);
+  await assert.rejects(executePluginHostAction({ kind: 'create', draft: { hostname: 'new.invalid', group: 'B' } }, f.options), /Managed sources changed/);
+  assert.equal(f.writes, 0); assert.equal(f.authorized, 0);
+});

application/state/pluginHostActionExecution.ts

@@ -0,0 +1,102 @@
+import type { Host, GroupConfig, Snippet, ManagedSource } from '../../domain/models';
+import { canonicalJsonString, normalizeJsonValue } from '../../domain/convergentSync/json';
+import { applyPluginHostEdit, normalizePluginHostDraft, pluginHostDraftTouchesManagedSource, type PluginHostDraftFields } from '../../domain/pluginHostActions';
+import { applyVaultHostCreates } from '../../domain/vaultHostCreate';
+import type { PluginHostActionResources } from './pluginHostActionResources';
+import type { AppVaultRuntime } from './appRuntimeBridge';
+
+// Application action model. Public RPC types live only in plugin-contract.
+export type PluginHostAction =
+  | { kind: 'create'; draft: PluginHostDraftFields }
+  | { kind: 'edit'; target: { resourceId: string; revision: string }; draft: PluginHostDraftFields }
+  | { kind: 'connect'; target: { resourceId: string; revision: string } };
+
+export interface PluginHostActionVault {
+  hosts: Host[];
+  customGroups: string[];
+  groupConfigs: GroupConfig[];
+  snippets: Snippet[];
+  managedSources: ManagedSource[];
+  isInitialized: boolean;
+  readPersistedHosts: () => Promise<Host[]>;
+  commitVaultImportTransaction: AppVaultRuntime['commitVaultImportTransaction'];
+}
+
+export interface PluginHostActionExecution {
+  getVault: () => PluginHostActionVault;
+  resources: PluginHostActionResources;
+  assertCurrent: () => void;
+  authorizeCommit: () => Promise<void>;
+  connect: (host: Host) => unknown;
+}
+
+const sameHost = (left: Host, right: Host) => (
+  canonicalJsonString(normalizeJsonValue(left)) === canonicalJsonString(normalizeJsonValue(right))
+);
+
+/** Execute only a host-reviewed action. authorizeCommit claims separate,
+ * one-use main-process action authority after the final asynchronous work. */
+export async function executePluginHostAction(action: PluginHostAction, options: PluginHostActionExecution): Promise<'saved' | 'requested'> {
+  const current = () => {
+    options.assertCurrent();
+    const vault = options.getVault();
+    if (!vault.isInitialized) throw new Error('Vault is unavailable');
+    options.resources.observe(vault.hosts);
+    return vault;
+  };
+  const initialVault = current();
+  const reviewedGroups = initialVault.groupConfigs;
+  const reviewedSnippets = initialVault.snippets;
+  const reviewedSources = initialVault.managedSources;
+  const selected = action.kind === 'create' ? undefined : options.resources.resolve(action.target.resourceId, action.target.revision);
+  const assertSelected = () => {
+    const vault = current();
+    if (action.kind !== 'create' && options.resources.resolve(action.target.resourceId, action.target.revision) !== selected) {
+      throw new Error('Selected host changed');
+    }
+    // A connection preview includes inherited and global automation. Any
+    // settings change while the preview is open requires fresh confirmation.
+    if (action.kind === 'connect' && (vault.groupConfigs !== reviewedGroups || vault.snippets !== reviewedSnippets)) {
+      throw new Error('Saved connection settings changed');
+    }
+    if (action.kind !== 'connect' && vault.managedSources !== reviewedSources) throw new Error('Managed sources changed during draft review');
+    return vault;
+  };
+  const persisted = await initialVault.readPersistedHosts();
+  assertSelected();
+  if (selected) {
+    const persistedHost = persisted.find((host) => host.id === selected.id);
+    if (!persistedHost || !sameHost(selected, persistedHost)) throw new Error('Selected host changed');
+  }
+  if (action.kind === 'connect') {
+    await options.authorizeCommit();
+    assertSelected();
+    // The existing host connection handler owns authentication, saved scripts,
+    // and sessions. Its return value never reaches the sandboxed plugin.
+    options.connect(selected!);
+    return 'requested';
+  }
+  const nextHost = action.kind === 'create'
+    ? normalizePluginHostDraft(action.draft, crypto.randomUUID())
+    : applyPluginHostEdit(selected!, action.draft);
+  if (pluginHostDraftTouchesManagedSource(nextHost, reviewedSources)) {
+    throw new Error('Managed SSH config changes require the Vault host editor');
+  }
+  const nextHosts = action.kind === 'create'
+    ? applyVaultHostCreates(persisted, [], [nextHost]).hosts
+    : persisted.map((host) => host.id === nextHost.id ? nextHost : host);
+  if (action.kind === 'create' && nextHosts.length !== persisted.length + 1) throw new Error('Host already exists');
+  const updateGroups = (groups: string[]) => nextHost.group && !groups.includes(nextHost.group) ? [...groups, nextHost.group] : groups;
+  const sourceSnapshot = canonicalJsonString(normalizeJsonValue(reviewedSources));
+  const keepSources = (sources: ManagedSource[]) => {
+    if (canonicalJsonString(normalizeJsonValue(sources)) !== sourceSnapshot) throw new Error('Managed sources changed during draft review');
+    return sources;
+  };
+  const result = await initialVault.commitVaultImportTransaction(
+    nextHosts, updateGroups, keepSources,
+    undefined, persisted, undefined,
+    async () => { assertSelected(); await options.authorizeCommit(); assertSelected(); },
+  );
+  if (result.status !== 'persisted') throw new Error('Vault changed before the draft was saved');
+  return 'saved';
+}

application/state/pluginHostActionResources.test.ts

@@ -0,0 +1,32 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { PluginHostActionResources } from './pluginHostActionResources';
+import type { Host } from '../../domain/models';
+
+const first: Host = { id: 'synthetic-1', label: 'First', hostname: 'first.invalid', username: 'test', tags: [], os: 'linux', group: 'Synthetic', password: 'synthetic-password', startupCommand: 'synthetic-script', totp: { uri: 'synthetic-totp' } as never };
+
+test('selected metadata projects only the allowlist and replacement invalidates revision', () => {
+  const resources = new PluginHostActionResources();
+  resources.observe([first]);
+  const metadata = resources.metadata(first.id);
+  assert.deepEqual(Object.keys(metadata), ['resourceId', 'revision', 'label', 'hostname', 'username', 'protocol', 'group', 'tags']);
+  assert.equal(JSON.stringify(metadata).includes('synthetic-password'), false);
+  resources.observe([first]);
+  assert.equal(resources.resolve(first.id, metadata.revision), first);
+  resources.observe([{ ...first }]);
+  assert.throws(() => resources.resolve(first.id, metadata.revision), /changed/);
+  const replaced = resources.metadata(first.id);
+  resources.observe([]);
+  assert.throws(() => resources.resolve(first.id, replaced.revision), /changed/);
+  resources.observe([first]);
+  assert.throws(() => resources.resolve(first.id, replaced.revision), /changed/);
+});
+
+test('group choices are explicit current members and never expand to later members', () => {
+  const resources = new PluginHostActionResources();
+  resources.observe([first]);
+  const selection = [resources.metadata(first.id)];
+  resources.observe([first, { ...first, id: 'synthetic-2' }]);
+  assert.deepEqual(selection.map((item) => item.resourceId), [first.id]);
+  assert.equal(resources.resolve(first.id, selection[0].revision), first);
+});

application/state/pluginHostActionResources.ts

@@ -0,0 +1,34 @@
+import type { Host } from '../../domain/models';
+
+/** Renderer-local revisions track replacement as well as visible edits. They
+ * are never authorization handles; only the main-process authority issues one. */
+export class PluginHostActionResources {
+  private entries = new Map<string, { host: Host; revision: string }>();
+
+  observe(hosts: readonly Host[]) {
+    const next = new Map<string, { host: Host; revision: string }>();
+    for (const host of hosts) {
+      const existing = this.entries.get(host.id);
+      next.set(host.id, existing?.host === host ? existing : { host, revision: crypto.randomUUID() });
+    }
+    this.entries = next;
+  }
+
+  resolve(id: string, expectedRevision: string): Host {
+    const entry = this.entries.get(id);
+    if (!entry || entry.revision !== expectedRevision) throw new Error('Selected host changed; select it again');
+    return entry.host;
+  }
+
+  metadata(id: string) {
+    const entry = this.entries.get(id);
+    if (!entry) throw new Error('Selected host is unavailable');
+    const host = entry.host;
+    return {
+      resourceId: host.id, revision: entry.revision,
+      label: host.label, hostname: host.hostname, username: host.username,
+      ...(host.port === undefined ? {} : { port: host.port }), protocol: host.protocol ?? 'ssh',
+      group: host.group ?? '', tags: [...host.tags],
+    };
+  }
+}

application/state/pluginVaultPages.ts

@@ -0,0 +1,27 @@
+export const PLUGIN_VAULT_PAGE_PREFIX = 'plugin-vault:';
+
+export interface PluginVaultPage {
+  key: `plugin-vault:${string}`;
+  pluginId: string;
+  pluginName: string;
+  version: string;
+  viewId: string;
+  title: string;
+  icon?: NetcattyPluginIconReference;
+  order: number;
+}
+
+export function collectPluginVaultPages(plugins: NetcattyPluginContributionSnapshot['plugins']): PluginVaultPage[] {
+  return plugins.flatMap((plugin) => plugin.views
+    .filter((view) => view.location === 'vault-page' && view.visible)
+    .map((view): PluginVaultPage => ({
+      key: `${PLUGIN_VAULT_PAGE_PREFIX}${view.id}`,
+      pluginId: plugin.id, pluginName: plugin.displayName, version: plugin.version,
+      viewId: view.id, title: view.title, icon: view.icon, order: view.order ?? 0,
+    })))
+    .sort((left, right) => left.order - right.order || left.viewId.localeCompare(right.viewId));
+}
+
+export function resolvePluginVaultPage(pages: readonly PluginVaultPage[], section: string): PluginVaultPage | null {
+  return pages.find((page) => page.key === section) ?? null;
+}

application/state/pluginViewOcclusion.ts

@@ -0,0 +1,18 @@
+/** Native child views must yield to host dialogs and overlapping portals. */
+export function isPluginViewOccluded(mount: HTMLElement): boolean {
+  const rect = mount.getBoundingClientRect();
+  if (!mount.isConnected || mount.closest('[hidden], [inert], [aria-hidden="true"]')) return true;
+  const overlays = mount.ownerDocument.querySelectorAll(
+    '[data-app-lock-overlay], [role="dialog"], [role="alertdialog"], '
+    + '[role="menu"][data-state="open"], [data-radix-popper-content-wrapper] > *, [data-native-view-occluder]',
+  );
+  return [...overlays].some((overlay) => {
+    if (mount.contains(overlay)) return false;
+    const style = getComputedStyle(overlay);
+    if (style.display === 'none' || style.visibility === 'hidden' || overlay.closest('[hidden], [inert]')) return false;
+    if (overlay.matches('[data-app-lock-overlay], [role="dialog"][aria-modal="true"], [role="alertdialog"]')) return true;
+    const other = overlay.getBoundingClientRect();
+    return other.width > 0 && other.height > 0 && other.x < rect.right && other.right > rect.x
+      && other.y < rect.bottom && other.bottom > rect.y;
+  });
+}

application/state/sessionSnapshotStore.test.ts

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

application/state/sessionSnapshotStore.ts

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

application/state/settingsStateDefaults.ts

@@ -1,3 +1,4 @@
+import { pluginThemeRegistry } from '../../infrastructure/config/pluginThemeRegistry';
 import {
   DEFAULT_SHIFT_ENTER_NEWLINE_TEXT,
   isLegacyDefaultShiftEnterNewlineText,
@@ -252,6 +253,9 @@ export const applyThemeTokens = (
   accentOverride: string,
 ) => {
   const root = window.document.documentElement;
+  root.toggleAttribute('data-plugin-theme-active', pluginThemeRegistry.isActive(resolvedTheme));
+  const securityVars = buildAppThemeCssVars(pluginThemeRegistry.securityTokens(resolvedTheme), 'theme', '');
+  for (const [key, value] of Object.entries(securityVars)) root.style.setProperty('--host-security' + key.slice(1), value);
   root.classList.remove('light', 'dark');
   root.classList.add(resolvedTheme);
   const cssVars = buildAppThemeCssVars(tokens, accentMode, accentOverride);

application/state/sftp/transferHistoryRestoreMigration.ts

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

application/state/sftp/transferSettlementObservation.test.ts

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

application/state/sftp/types.ts

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

application/state/sftp/uploadTaskCallbacks.ts

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

application/state/sftp/waitForTransferOwner.ts

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

application/state/sftpTransferCenterStore.test.ts

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

application/state/sftpTransferCenterStore.ts

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

application/state/terminalHiddenRendererStore.test.ts

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

application/state/terminalHiddenRendererStore.ts

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

application/state/terminalSidePanelTabs.ts

@@ -13,11 +13,11 @@ import {
 } from '../../infrastructure/config/storageKeys';
 import { localStorageAdapter } from '../../infrastructure/persistence/localStorageAdapter';
 import { useToolbarItemLayout } from './useToolbarItemLayout';
-import type { SidePanelTool } from '../../domain/sidePanelLayout';
+import type { BuiltinSidePanelTool, SidePanelTool } from '../../domain/sidePanelLayout';
 
 export type TerminalSidePanelTabId = SidePanelTool;
 
-export const TERMINAL_SIDE_PANEL_TAB_DEFAULT_ORDER: TerminalSidePanelTabId[] = [
+export const TERMINAL_SIDE_PANEL_TAB_DEFAULT_ORDER: BuiltinSidePanelTool[] = [
   'sftp',
   'browser',
   'scripts',

application/state/useActiveChromeTheme.ts

@@ -1,3 +1,6 @@
+import { pluginThemeRegistry } from '../../infrastructure/config/pluginThemeRegistry';
+import { usePluginThemeRevision } from './usePluginThemeRuntime';
+import { useSettingsChromeStore } from './settingsChromeStore';
 import { useLayoutEffect, useRef } from "react";
 import type { TerminalTheme } from "../../domain/models";
 import {
@@ -271,12 +274,15 @@ export function useActiveChromeTheme({
   activeTheme: TerminalTheme | null;
   applyAppTheme: () => void;
 }) {
+  const pluginThemeRevision = usePluginThemeRevision();
+  const { resolvedTheme } = useSettingsChromeStore();
+  const effectiveTheme = pluginThemeRegistry.isActive(resolvedTheme) ? null : activeTheme;
   const applyAppThemeRef = useRef(applyAppTheme);
   applyAppThemeRef.current = applyAppTheme;
 
   useLayoutEffect(() => {
-    syncActiveChromeTheme(activeTheme, applyAppTheme);
-  }, [activeTheme, applyAppTheme]);
+    syncActiveChromeTheme(effectiveTheme, applyAppTheme);
+  }, [effectiveTheme, applyAppTheme, pluginThemeRevision]);
 
   useLayoutEffect(() => {
     return () => {

application/state/useEmbeddedPluginView.ts

@@ -0,0 +1,119 @@
+import { useEffect, useRef, useState } from 'react';
+import { PluginViewLifecycleController, type HostedPluginViewState } from './pluginViewLifecycle';
+import { resolvePluginViewWindowScope } from './pluginViewScopes';
+import { isPluginViewOccluded } from './pluginViewOcclusion';
+import type { UsePluginContributionsResult } from './usePluginContributions';
+
+type ViewAdapter = Pick<UsePluginContributionsResult, 'openView' | 'closeView' | 'focusView' | 'setViewBounds' | 'setViewVisibility' | 'onViewClosed' | 'onViewFocused'>;
+
+/** Host-owned mounting only. No plugin router, DOM, session or vault data API. */
+export function useEmbeddedPluginView({ viewId, version, slot, active, context, adapter, subscribeHidden, unavailable, focused, focusOnReveal = false }: {
+  viewId: string;
+  version: string;
+  slot: string;
+  active: boolean;
+  context: Record<string, unknown>;
+  adapter: ViewAdapter;
+  subscribeHidden(listener: () => void): () => void;
+  unavailable(): void;
+  focused?(): void;
+  focusOnReveal?: boolean;
+}) {
+  const mountRef = useRef<HTMLDivElement>(null);
+  const [loading, setLoading] = useState(true);
+  const adapterRef = useRef(adapter);
+  const unavailableRef = useRef(unavailable);
+  const focusedRef = useRef(focused);
+  const revealFocusRef = useRef(focusOnReveal);
+  const requestFocusRef = useRef<() => void>(() => {});
+  revealFocusRef.current = focusOnReveal;
+  focusedRef.current = focused;
+  adapterRef.current = adapter;
+  unavailableRef.current = unavailable;
+  useEffect(() => {
+    const mount = mountRef.current;
+    if (!active || !mount) return;
+    let cancelled = false;
+    const lifecycle = new PluginViewLifecycleController<HostedPluginViewState>();
+    const instanceId = crypto.randomUUID();
+    const scopeId = resolvePluginViewWindowScope({ pathname: window.location.pathname,
+      search: window.location.search, hash: `${window.location.hash}|plugin-slot:${slot}` });
+    const { openView, closeView, focusView, setViewBounds, setViewVisibility, onViewClosed, onViewFocused } = adapterRef.current;
+    const close = () => {
+      if (cancelled) return;
+      cancelled = true;
+      lifecycle.markViewClosed(viewId);
+      void closeView(instanceId).catch(() => {});
+    };
+    const failCurrent = () => {
+      if (cancelled) return;
+      close();
+      unavailableRef.current();
+    };
+    const unsubscribe = onViewClosed((event) => {
+      lifecycle.handleHostClose(event.instanceId);
+      if (event.instanceId === instanceId && !cancelled) {
+        close();
+        unavailableRef.current();
+      }
+    });
+    const stopOnHide = subscribeHidden(close);
+    const stopOnFocus = onViewFocused((event) => {
+      if (!cancelled && event.instanceId === instanceId) focusedRef.current?.();
+    });
+    const bounds = () => {
+      const rect = mount.getBoundingClientRect();
+      return { x: Math.round(rect.x), y: Math.round(rect.y), width: Math.max(1, Math.round(rect.width)), height: Math.max(1, Math.round(rect.height)) };
+    };
+    let opened = false;
+    let lastBounds = '';
+    let visible = false;
+    const focus = () => {
+      if (!cancelled && opened && visible && revealFocusRef.current && !isPluginViewOccluded(mount)) void focusView(instanceId).catch(() => {});
+    };
+    requestFocusRef.current = focus;
+    const updateVisibility = () => {
+      if (!opened || cancelled) return;
+      const rect = mount.getBoundingClientRect();
+      const next = rect.width > 0 && rect.height > 0 && !isPluginViewOccluded(mount);
+      if (visible === next) return;
+      visible = next;
+      void setViewVisibility(instanceId, next).then(() => { if (next) focus(); }).catch(failCurrent);
+    };
+    const resize = () => {
+      if (opened && !cancelled) {
+        const next = bounds();
+        const key = JSON.stringify(next);
+        if (key !== lastBounds) { lastBounds = key; void setViewBounds(instanceId, next).catch(failCurrent); }
+      }
+      updateVisibility();
+    };
+    const observer = typeof ResizeObserver === 'undefined' ? null : new ResizeObserver(resize);
+    observer?.observe(mount);
+    const mutations = new MutationObserver(resize);
+    mutations.observe(document.body, { childList: true, subtree: true, attributes: true,
+      attributeFilter: ['class', 'style', 'hidden', 'inert', 'role', 'aria-modal', 'aria-hidden', 'data-state', 'data-app-lock-overlay', 'data-radix-popper-content-wrapper', 'data-native-view-occluder'] });
+    window.addEventListener('resize', resize);
+    document.addEventListener('scroll', resize, true);
+    setLoading(true);
+    const opening = lifecycle.beginOpen({ viewKey: viewId });
+    void openView({ viewId, instanceId, scopeId, bounds: bounds(), context }).then(async (result) => {
+      if (cancelled || lifecycle.shouldCloseOpen(opening) || lifecycle.consumeHostClose(result.instanceId)) {
+        await closeView(result.instanceId);
+        return;
+      }
+      opened = true;
+      lifecycle.setCurrent({ id: result.instanceId, viewId, scopeId, retainContextWhenHidden: false });
+      resize();
+      setLoading(false);
+    }).catch(() => {
+      if (!cancelled) { close(); unavailableRef.current(); }
+    }).finally(() => lifecycle.finishOpen({ token: opening, viewKey: viewId }));
+    return () => {
+      close(); unsubscribe(); stopOnHide(); stopOnFocus(); observer?.disconnect(); mutations.disconnect();
+      window.removeEventListener('resize', resize); document.removeEventListener('scroll', resize, true);
+    };
+  }, [active, context, slot, subscribeHidden, version, viewId]);
+  useEffect(() => { if (focusOnReveal) requestFocusRef.current(); }, [focusOnReveal]);
+  return { mountRef, loading };
+}

application/state/usePluginBrandIcon.ts

@@ -0,0 +1,19 @@
+import { useEffect, useState } from 'react';
+import { netcattyBridge } from '../../infrastructure/services/netcattyBridge';
+
+type Raster = { light: string; dark?: string };
+export function usePluginBrandIcon(plugin?: NetcattyInstalledPlugin): Raster | null {
+  const pluginId = plugin?.id;
+  const kind = plugin?.manifest?.icon?.kind;
+  const key = JSON.stringify([pluginId, plugin?.activeVersion, plugin?.archiveSha256, plugin?.runtime?.quarantinedAt, plugin?.manifest?.icon]);
+  const [loaded, setLoaded] = useState<{ key: string; value: Raster | null } | null>(null);
+  useEffect(() => {
+    if (!pluginId || kind !== 'package') return;
+    let cancelled = false;
+    void netcattyBridge.get()?.getPluginBrandIcon?.(pluginId).then((value) => {
+      if (!cancelled) setLoaded({ key, value });
+    }).catch(() => { if (!cancelled) setLoaded({ key, value: null }); });
+    return () => { cancelled = true; };
+  }, [key, pluginId, kind]);
+  return loaded?.key === key ? loaded.value : null;
+}

application/state/usePluginCatalog.test.ts

@@ -0,0 +1,84 @@
+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 { usePluginCatalog } from './usePluginCatalog';
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  let reject!: (cause: Error) => void;
+  const promise = new Promise<T>((yes, no) => { resolve = yes; reject = no; });
+  return { promise, resolve, reject };
+}
+
+test('README failures clear on retry/switch and stale requests cannot replace the selected entry', async (context) => {
+  const original = Object.getOwnPropertyDescriptor(globalThis, 'window');
+  const calls: Array<{ id: string; request: ReturnType<typeof deferred<string>> }> = [];
+  Object.defineProperty(globalThis, 'window', { configurable: true, value: {
+    netcatty: {
+      listPluginCatalog: async () => ({ entries: [], source: "builtin", error: null }),
+      getPluginCatalogReadme: (id: string) => { const request = deferred<string>(); calls.push({ id, request }); return request.promise; },
+    },
+  } });
+  (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+  context.after(() => {
+    if (original) Object.defineProperty(globalThis, 'window', original); else Reflect.deleteProperty(globalThis, 'window');
+    Reflect.deleteProperty(globalThis, 'IS_REACT_ACT_ENVIRONMENT');
+  });
+  let state!: ReturnType<typeof usePluginCatalog>;
+  let renders = 0;
+  function Probe({ id }: { id: string }) { state = usePluginCatalog(id); renders++; return null; }
+  let renderer!: ReactTestRenderer;
+  await act(async () => { renderer = create(React.createElement(Probe, { id: 'first' })); });
+  assert.equal(state.readmeStatus, 'loading');
+  await act(async () => calls[0].request.reject(new Error('temporary failure')));
+  assert.equal(state.readmeStatus, 'error');
+  assert.match(state.readmeError!, /temporary failure/);
+  await act(async () => state.retryReadme());
+  assert.equal(state.readmeStatus, 'loading'); assert.equal(state.readmeError, null);
+  await act(async () => calls[1].request.resolve(''));
+  assert.equal(state.readmeStatus, 'ready'); assert.equal(state.readme, ''); assert.equal(state.readmeError, null);
+  await act(async () => state.retryReadme());
+  await act(async () => renderer.update(React.createElement(Probe, { id: 'second' })));
+  assert.equal(state.readmeError, null);
+  await act(async () => calls[3].request.resolve('# Second'));
+  await act(async () => calls[2].request.reject(new Error('stale failure')));
+  assert.equal(state.readme, '# Second'); assert.equal(state.readmeError, null);
+  await act(async () => state.retryReadme());
+  await act(async () => renderer.unmount());
+  const unmountedRenders = renders;
+  await act(async () => calls[4].request.resolve('late content'));
+  assert.equal(renders, unmountedRenders);
+});
+
+test('offline snapshot stays browsable, retry clears warning, and operations bind the selected token', async (context) => {
+  const original = Object.getOwnPropertyDescriptor(globalThis, 'window');
+  const entry = { id: 'com.test.registry', selectionToken: 'first' } as NetcattyPluginCatalogEntry;
+  let offline = true;
+  const reads: unknown[][] = []; const installs: unknown[][] = [];
+  Object.defineProperty(globalThis, 'window', { configurable: true, value: {
+    dispatchEvent() {}, netcatty: {
+      listPluginCatalog: async () => ({ entries: [{ ...entry, selectionToken: offline ? 'first' : 'second' }], source: offline ? 'cached' : 'registry', error: offline ? 'offline' : null }),
+      getPluginCatalogReadme: async (...args: unknown[]) => { reads.push(args); return '# Pinned'; },
+      installCatalogPlugin: async (...args: unknown[]) => { installs.push(args); },
+    },
+  } });
+  (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+  context.after(() => {
+    if (original) Object.defineProperty(globalThis, 'window', original); else Reflect.deleteProperty(globalThis, 'window');
+    Reflect.deleteProperty(globalThis, 'IS_REACT_ACT_ENVIRONMENT');
+  });
+  let state!: ReturnType<typeof usePluginCatalog>;
+  function Probe() { state = usePluginCatalog(entry.id); return null; }
+  let renderer!: ReactTestRenderer;
+  await act(async () => { renderer = create(React.createElement(Probe)); });
+  assert.equal(state.entries.length, 1); assert.equal(state.listStatus, 'ready'); assert.equal(state.listError, 'offline');
+  assert.equal(state.source, 'cached');
+  offline = false;
+  await act(async () => state.retryList());
+  assert.equal(state.listError, null); assert.equal(state.source, 'registry');
+  assert.deepEqual(reads.at(-1), [entry.id, 'second', 'official']);
+  await act(async () => state.install(entry.id));
+  assert.deepEqual(installs, [[entry.id, 'second', 'official', undefined]]);
+  await act(async () => renderer.unmount());
+});

application/state/usePluginCatalog.ts

@@ -0,0 +1,82 @@
+import { useEffect, useRef, useState } from 'react';
+import { netcattyBridge } from '../../infrastructure/services/netcattyBridge';
+
+type ReadmeState = { id: string; token?: string; attempt: number; status: 'loading' | 'ready' | 'error'; text: string; error: string | null };
+export function usePluginCatalog(selectedId: string | null, sourceId = 'official') {
+  const [entries, setEntries] = useState<NetcattyPluginCatalogEntry[]>([]);
+  const [listStatus, setListStatus] = useState<'loading' | 'ready' | 'error'>('loading');
+  const [source, setSource] = useState<NetcattyPluginCatalogSnapshot['source']>('builtin');
+  const [listError, setListError] = useState<string | null>(null);
+  const [listAttempt, setListAttempt] = useState(0);
+  const [readmeState, setReadmeState] = useState<ReadmeState | null>(null);
+  const [readmeAttempt, setReadmeAttempt] = useState(0);
+  const [installError, setInstallError] = useState<{ id: string; message: string } | null>(null);
+  const [busy, setBusy] = useState(false);
+  const [sourceBinding, setSourceBinding] = useState<NetcattyPluginSource | null>(null);
+  const installing = useRef(false);
+  const mounted = useRef(false);
+  useEffect(() => { mounted.current = true; return () => { mounted.current = false; }; }, []);
+  useEffect(() => {
+    let active = true;
+    setListStatus('loading'); setListError(null);
+    void (async () => {
+      try {
+        const bridge = netcattyBridge.get();
+        if (!bridge?.listPluginCatalog) throw new Error('Catalog browsing unavailable');
+        const list = await bridge.listPluginCatalog(sourceId);
+        if (active) { setEntries(list.entries); setSource(list.source); setListError(list.error); setListStatus('ready'); }
+      } catch (cause) { if (active) { setListStatus('error'); setListError(String(cause)); } }
+    })();
+    return () => { active = false; };
+  }, [listAttempt, sourceId]);
+  useEffect(() => {
+    let active = true;
+    setSourceBinding(null);
+    if (selectedId) void netcattyBridge.get()?.getPluginSourceBinding?.(selectedId).then((binding) => { if (active) setSourceBinding(binding); }).catch((cause) => { if (active) setInstallError({ id: selectedId, message: String(cause) }); });
+    return () => { active = false; };
+  }, [selectedId, sourceId]);
+  const selectionToken = entries.find((entry) => entry.id === selectedId)?.selectionToken;
+  useEffect(() => {
+    if (!selectedId) return;
+    let active = true;
+    const base = { id: selectedId, token: selectionToken, attempt: readmeAttempt, text: '', error: null };
+    setReadmeState({ ...base, status: 'loading' });
+    void (async () => {
+      try {
+        const bridge = netcattyBridge.get();
+        if (!bridge?.getPluginCatalogReadme) throw new Error('README retrieval unavailable');
+        const text = await bridge.getPluginCatalogReadme(selectedId, selectionToken, sourceId);
+        if (active) setReadmeState({ ...base, status: 'ready', text });
+      } catch (cause) { if (active) setReadmeState({ ...base, status: 'error', error: String(cause) }); }
+    })();
+    return () => { active = false; };
+  }, [selectedId, selectionToken, readmeAttempt, sourceId]);
+  const currentReadme = readmeState?.id === selectedId && readmeState.token === selectionToken && readmeState.attempt === readmeAttempt ? readmeState : null;
+  return {
+    entries, listStatus, listError, source, sourceBinding,
+    readme: currentReadme?.status === 'ready' ? currentReadme.text : null,
+    readmeStatus: currentReadme?.status ?? (selectedId ? 'loading' : 'idle'),
+    readmeError: currentReadme?.error ?? null,
+    error: installError?.id === selectedId ? installError.message : null,
+    busy,
+    retryList: () => setListAttempt((attempt) => attempt + 1),
+    retryReadme: () => setReadmeAttempt((attempt) => attempt + 1),
+    async install(id: string, acceptedSourceId?: string, clearPreviousSource = false) {
+      if (installing.current) return;
+      installing.current = true;
+      setBusy(true); setInstallError(null);
+      try {
+        const bridge = netcattyBridge.require();
+        if (!bridge.installCatalogPlugin) throw new Error('Catalog installation unavailable');
+        if (clearPreviousSource && sourceBinding && sourceBinding.id !== sourceId) {
+          if (!bridge.resetPluginSource) throw new Error('Source reset unavailable');
+          await bridge.resetPluginSource(id, sourceBinding.id);
+          setSourceBinding(null);
+        }
+        await bridge.installCatalogPlugin(id, entries.find((entry) => entry.id === id)?.selectionToken, sourceId, acceptedSourceId);
+        window.dispatchEvent(new Event('netcatty:plugin-packages-changed'));
+      } catch (cause) { if (mounted.current) setInstallError({ id, message: String(cause) }); }
+      finally { installing.current = false; if (mounted.current) setBusy(false); }
+    },
+  };
+}

application/state/usePluginContributions.ts

@@ -88,10 +88,12 @@ export interface UsePluginContributionsResult {
   selectSettingPath(kind: 'file' | 'directory', title: string, defaultPath?: string): Promise<string | null>;
   openView(payload: NetcattyPluginViewOpenRequest): Promise<{ instanceId: string }>;
   closeView(instanceId: string): Promise<void>;
+  focusView(instanceId: string): Promise<void>;
   setViewBounds(instanceId: string, bounds: { x: number; y: number; width: number; height: number }): Promise<void>;
   setViewVisibility(instanceId: string, visible: boolean): Promise<void>;
   setEnvironment(environment: NetcattyPluginEnvironment): Promise<void>;
   onViewClosed(callback: (event: NetcattyPluginViewClosedEvent) => void): () => void;
+  onViewFocused(callback: (event: import('@netcatty/plugin-contract').PluginViewFocusEvent) => void): () => void;
 }
 
 export function usePluginContributions(
@@ -196,6 +198,9 @@ export function usePluginContributions(
     if (!bridge?.closePluginView) return;
     await bridge.closePluginView(instanceId);
   }, [bridge]);
+  const focusView = useCallback(async (instanceId: string) => {
+    await bridge?.focusPluginView?.({ instanceId });
+  }, [bridge]);
 
   const setViewBounds = useCallback(async (
     instanceId: string,
@@ -218,6 +223,9 @@ export function usePluginContributions(
   const onViewClosed = useCallback((callback: (event: NetcattyPluginViewClosedEvent) => void) => (
     bridge?.onPluginViewClosed?.(callback) ?? (() => {})
   ), [bridge]);
+  const onViewFocused = useCallback((callback: (event: import('@netcatty/plugin-contract').PluginViewFocusEvent) => void) => (
+    bridge?.onPluginViewFocused?.(callback) ?? (() => {})
+  ), [bridge]);
 
   const currentLoadState = resolvePluginContributionLoadState({
     currentQueryKey: queryKey,
@@ -239,9 +247,11 @@ export function usePluginContributions(
     selectSettingPath,
     openView,
     closeView,
+    focusView,
     setViewBounds,
     setViewVisibility,
     setEnvironment,
     onViewClosed,
+    onViewFocused,
   };
 }

application/state/usePluginHostActions.ts

@@ -0,0 +1,168 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import type { HostInteractionPrompt, VaultHostActionRequest } from '@netcatty/plugin-contract';
+import { netcattyBridge } from '../../infrastructure/services/netcattyBridge';
+import { getAppHandlers } from '../app/appHandlersBridge';
+import { getAppAppLockRuntime, getAppVaultRuntime } from './appRuntimeBridge';
+import { PluginHostActionResources } from './pluginHostActionResources';
+import { executePluginHostAction, type PluginHostAction } from './pluginHostActionExecution';
+import { pluginHostRunsSavedScripts, type PluginHostDraftFields } from '../../domain/pluginHostActions';
+import type { Host, GroupConfig, ManagedSource, Snippet } from '../../domain/models';
+
+export type VaultHostPrompt = Omit<HostInteractionPrompt, 'request'> & { request: VaultHostActionRequest };
+type Review = {
+  prompt: VaultHostPrompt;
+  candidates: Host[];
+  candidateRevisions: Map<string, string>;
+  customGroups: string[];
+  host?: Host;
+  groups: GroupConfig[];
+  snippets: Snippet[];
+  managedSources: ManagedSource[];
+  scriptsRun: boolean;
+  claimed: boolean;
+  completionToken?: string;
+};
+
+export function usePluginHostActions() {
+  const [review, setReview] = useState<Review | null>(null);
+  const [selectedIds, setSelectedIds] = useState<string[]>([]);
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState(false);
+  const current = useRef<Review | null>(null);
+  const resources = useRef(new PluginHostActionResources());
+  const responding = useRef(false);
+
+  const getVault = useCallback(() => {
+    const vault = getAppVaultRuntime();
+    const lock = getAppAppLockRuntime();
+    if (!vault?.isInitialized || !lock?.initialized || lock.locked) throw new Error('Vault is locked or unavailable');
+    const actionState = vault.readCurrentHostActionState();
+    resources.current.observe(actionState.hosts);
+    return { ...vault, ...actionState };
+  }, []);
+
+  const assertCurrent = useCallback((entry: Review) => {
+    if (current.current !== entry || Date.now() >= entry.prompt.expiresAt) throw new Error('Host action expired');
+    const vault = getVault();
+    const target = entry.prompt.vaultTarget;
+    if (target && resources.current.resolve(target.resourceId, target.revision) !== entry.host) throw new Error('Selected host changed');
+    if (entry.prompt.request.kind === 'vault.requestConnect' && (vault.groupConfigs !== entry.groups || vault.snippets !== entry.snippets)) {
+      throw new Error('Saved connection settings changed');
+    }
+    if (entry.prompt.request.kind === 'vault.requestHostDraft' && vault.managedSources !== entry.managedSources) throw new Error('Managed sources changed during draft review');
+  }, [getVault]);
+
+  const fail = useCallback(async (entry: Review) => {
+    if (current.current !== entry) return;
+    setError(true);
+    try {
+      await netcattyBridge.get()?.respondPluginInteraction?.({
+        requestId: entry.prompt.requestId, actionToken: entry.completionToken ?? entry.prompt.actionToken, action: 'fail',
+      });
+    } catch { /* A stopped runtime or closed window already invalidates it. */ }
+  }, []);
+
+  const execute = useCallback(async (entry: Review) => {
+    const bridge = netcattyBridge.get();
+    if (!bridge?.respondPluginInteraction) return fail(entry);
+    setBusy(true);
+    try {
+      assertCurrent(entry);
+      const request = entry.prompt.request;
+      const target = entry.prompt.vaultTarget;
+      let action: PluginHostAction;
+      if (request.kind === 'vault.requestConnect' && target) action = { kind: 'connect', target };
+      else if (request.kind === 'vault.requestHostDraft' && entry.prompt.reviewedDraft) {
+        action = target ? { kind: 'edit', target, draft: entry.prompt.reviewedDraft } : { kind: 'create', draft: entry.prompt.reviewedDraft };
+      } else throw new Error('Host action is invalid');
+      await executePluginHostAction(action, {
+        getVault, resources: resources.current,
+        assertCurrent: () => assertCurrent(entry),
+        authorizeCommit: async () => {
+          assertCurrent(entry);
+          const receipt = await bridge.respondPluginInteraction!({ requestId: entry.prompt.requestId, actionToken: entry.prompt.actionToken, action: 'commit' });
+          if (!receipt || typeof receipt !== 'object' || !receipt.completionToken) throw new Error('Host action was revoked');
+          entry.completionToken = receipt.completionToken;
+          entry.claimed = true;
+          assertCurrent(entry);
+        },
+        connect: (host) => {
+          const connect = getAppHandlers()?.handleConnectToHost;
+          if (typeof connect !== 'function') throw new Error('Host connection flow unavailable');
+          return connect(host);
+        },
+      });
+      await bridge.respondPluginInteraction({ requestId: entry.prompt.requestId, actionToken: entry.completionToken!, action: 'complete' });
+    } catch { await fail(entry); }
+  }, [assertCurrent, fail, getVault]);
+
+  useEffect(() => {
+    const bridge = netcattyBridge.get();
+    if (!bridge?.onPluginInteraction) return;
+    const unsubscribe = bridge.onPluginInteraction((event) => {
+      if ('closed' in event) {
+        if (current.current?.prompt.requestId !== event.requestId) return;
+        current.current = null; setReview(null); setBusy(false); responding.current = false;
+        return;
+      }
+      if (!event.request.kind.startsWith('vault.')) return;
+      const prompt = event as VaultHostPrompt;
+      try {
+        if (prompt.phase === 'commit') {
+          const entry = current.current;
+          if (!entry || entry.prompt.requestId !== prompt.requestId || entry.prompt.request.kind !== prompt.request.kind) throw new Error('Host review is unavailable');
+          entry.prompt = prompt;
+          setReview({ ...entry });
+          void execute(entry);
+          return;
+        }
+        const vault = getVault();
+        const candidates = [...vault.hosts];
+        const host = prompt.vaultTarget ? resources.current.resolve(prompt.vaultTarget.resourceId, prompt.vaultTarget.revision) : undefined;
+        const entry: Review = {
+          prompt, candidates, candidateRevisions: new Map(candidates.map((candidate) => [candidate.id, resources.current.metadata(candidate.id).revision])),
+          customGroups: vault.customGroups, host, groups: vault.groupConfigs, snippets: vault.snippets,
+          managedSources: vault.managedSources,
+          scriptsRun: host ? pluginHostRunsSavedScripts(host, vault.groupConfigs, vault.snippets) : false,
+          claimed: false,
+        };
+        current.current = entry; setReview(entry); setSelectedIds([]); setBusy(false); setError(false); responding.current = false;
+      } catch {
+        void bridge.respondPluginInteraction?.({ requestId: prompt.requestId, actionToken: prompt.actionToken, action: 'fail' }).catch(() => {});
+      }
+    });
+    return () => {
+      const entry = current.current;
+      current.current = null;
+      unsubscribe();
+      if (entry && !entry.claimed) void bridge.respondPluginInteraction?.({ requestId: entry.prompt.requestId, actionToken: entry.prompt.actionToken, action: 'cancel' }).catch(() => {});
+    };
+  }, [execute, getVault]);
+
+  const respond = useCallback(async (action: 'cancel' | 'submit', draft?: PluginHostDraftFields) => {
+    const entry = current.current;
+    if (!entry || responding.current || (action === 'cancel' && entry.claimed)) return;
+    responding.current = true; setBusy(true); setError(false);
+    try {
+      assertCurrent(entry);
+      const request = entry.prompt.request;
+      const selected = request.kind === 'vault.selectHosts' && action === 'submit' ? selectedIds.map((id) => {
+        const revision = entry.candidateRevisions.get(id);
+        if (!revision) throw new Error('Host was not part of the current selection');
+        resources.current.resolve(id, revision);
+        return resources.current.metadata(id);
+      }) : undefined;
+      await netcattyBridge.require().respondPluginInteraction?.({
+        requestId: entry.prompt.requestId, actionToken: entry.prompt.actionToken, action,
+        ...(selected === undefined ? {} : { resources: selected }),
+        ...(draft === undefined ? {} : { draft }),
+        ...(request.kind === 'vault.requestConnect' && action === 'submit' ? { scriptsRun: entry.scriptsRun } : {}),
+      });
+    } catch { await fail(entry); }
+    finally {
+      if (current.current === entry && entry.prompt.phase === 'request') { responding.current = false; setBusy(false); }
+    }
+  }, [assertCurrent, fail, selectedIds]);
+
+  return { review, selectedIds, setSelectedIds, busy, error, respond };
+}

application/state/usePluginHostInteractions.ts

@@ -0,0 +1,55 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import type { HostInteractionPrompt, HostInteractionRequest, HostInteractionResponse } from '@netcatty/plugin-contract';
+import { netcattyBridge } from '../../infrastructure/services/netcattyBridge';
+
+export function usePluginHostInteractions() {
+  type UiPrompt = Omit<HostInteractionPrompt, 'request'> & { request: HostInteractionRequest };
+  const [prompt, setPrompt] = useState<UiPrompt | null>(null);
+  const [value, setValue] = useState('');
+  const [error, setError] = useState(false);
+  const [busy, setBusy] = useState(false);
+  const current = useRef<UiPrompt | null>(null);
+  const pending = useRef(false);
+  useEffect(() => {
+    const bridge = netcattyBridge.get();
+    if (!bridge?.onPluginInteraction || !bridge.setPluginInteractionReady) return;
+    const unsubscribe = bridge.onPluginInteraction((event) => {
+      if ('closed' in event) {
+        if (current.current?.requestId !== event.requestId) return;
+        current.current = null; setPrompt(null);
+      } else {
+        if (event.request.kind.startsWith('vault.')) return;
+        current.current = event as UiPrompt; setPrompt(event as UiPrompt);
+        setValue(event.request.kind === 'input' ? event.request.initialValue ?? '' : '');
+      }
+      pending.current = false; setBusy(false); setError(false);
+    });
+    void bridge.setPluginInteractionReady(true).catch(() => {});
+    return () => {
+      current.current = null;
+      unsubscribe();
+      void bridge.setPluginInteractionReady?.(false).catch(() => {});
+    };
+  }, []);
+  const respond = useCallback(async (action: HostInteractionResponse['action']) => {
+    const active = current.current;
+    if (!active || pending.current) return;
+    pending.current = true; setBusy(true); setError(false);
+    try {
+      const bridge = netcattyBridge.require();
+      if (!bridge.respondPluginInteraction) throw new Error('Host interactions unavailable');
+      const accepted = await bridge.respondPluginInteraction({
+        requestId: active.requestId, actionToken: active.actionToken, action,
+        ...(action === 'submit' && (active.request.kind === 'input' || active.request.kind === 'quickPick') ? { value } : {}),
+      });
+      if (!accepted && current.current?.actionToken === active.actionToken) {
+        current.current = null; setPrompt(null);
+      }
+    } catch {
+      if (current.current?.actionToken === active.actionToken) setError(true);
+    } finally {
+      if (current.current?.actionToken === active.actionToken) { pending.current = false; setBusy(false); }
+    }
+  }, [value]);
+  return { prompt, value, setValue, error, busy, respond };
+}

application/state/usePluginManager.test.ts

@@ -0,0 +1,39 @@
+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 { usePluginManager } from './usePluginManager';
+
+test('failed manager refresh marks previous enabled state unknown until a successful read', async (context) => {
+  const previous = Object.getOwnPropertyDescriptor(globalThis, 'window');
+  const actPrevious = Object.getOwnPropertyDescriptor(globalThis, 'IS_REACT_ACT_ENVIRONMENT');
+  let fail = false;
+  const plugin = { id: 'com.example.synthetic', enabled: true } as NetcattyInstalledPlugin;
+  Object.defineProperty(globalThis, 'IS_REACT_ACT_ENVIRONMENT', { configurable: true, value: true });
+  Object.defineProperty(globalThis, 'window', { configurable: true, value: {
+    addEventListener() {}, removeEventListener() {}, netcatty: {
+      async getPluginRuntimeStatus() { return { available: true }; },
+      async listPlugins() { if (fail) throw new Error('synthetic status read failed'); return [plugin]; },
+    },
+  } });
+  context.after(() => {
+    if (previous) Object.defineProperty(globalThis, 'window', previous); else Reflect.deleteProperty(globalThis, 'window');
+    if (actPrevious) Object.defineProperty(globalThis, 'IS_REACT_ACT_ENVIRONMENT', actPrevious); else Reflect.deleteProperty(globalThis, 'IS_REACT_ACT_ENVIRONMENT');
+  });
+  let state!: ReturnType<typeof usePluginManager>;
+  function Probe() { state = usePluginManager(); return null; }
+  let renderer!: ReactTestRenderer;
+  await act(async () => { renderer = create(React.createElement(Probe)); });
+  try {
+    assert.equal(state.statusKnown, true);
+    assert.equal(state.plugins[0].enabled, true);
+    fail = true;
+    await act(async () => { await assert.rejects(state.refresh(), /synthetic status read failed/); });
+    assert.equal(state.statusKnown, false);
+    assert.match(state.error ?? '', /synthetic status read failed/);
+    fail = false; plugin.enabled = false;
+    await act(async () => { await state.refresh(); });
+    assert.equal(state.statusKnown, true);
+    assert.equal(state.plugins[0].enabled, false);
+  } finally { await act(async () => { renderer.unmount(); }); }
+});

application/state/usePluginManager.ts

@@ -0,0 +1,74 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { netcattyBridge } from '../../infrastructure/services/netcattyBridge';
+
+export function usePluginManager() {
+  const [plugins, setPlugins] = useState<NetcattyInstalledPlugin[]>([]);
+  const [available, setAvailable] = useState(false);
+  const [statusKnown, setStatusKnown] = useState(false);
+  const [credentialStorageAvailable, setCredentialStorageAvailable] = useState<boolean | undefined>();
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const generation = useRef(0);
+  const mutation = useRef(false);
+  const refresh = useCallback(async () => {
+    const current = ++generation.current;
+    try {
+      const bridge = netcattyBridge.get();
+      const status = await bridge?.getPluginRuntimeStatus?.();
+      const list = status?.available ? await bridge?.listPlugins?.() ?? [] : [];
+      if (current !== generation.current) return;
+      setAvailable(status?.available === true);
+      setStatusKnown(true);
+      setCredentialStorageAvailable(status?.credentialStorageAvailable);
+      setPlugins(list);
+    } catch (cause) {
+      if (current === generation.current) {
+        setStatusKnown(false);
+        setError(cause instanceof Error ? cause.message : String(cause));
+      }
+      throw cause;
+    }
+  }, []);
+  useEffect(() => {
+    const update = () => { void refresh().catch((cause) => setError(String(cause))); };
+    update();
+    const unsubscribe = netcattyBridge.get()?.onPluginContributionsChanged?.(update);
+    window.addEventListener('netcatty:plugin-packages-changed', update);
+    const refreshGeneration = generation;
+    return () => { refreshGeneration.current++; unsubscribe?.(); window.removeEventListener('netcatty:plugin-packages-changed', update); };
+  }, [refresh]);
+  const run = useCallback(async (action: (bridge: NetcattyBridge) => Promise<unknown>) => {
+    if (mutation.current) return;
+    mutation.current = true;
+    setBusy(true);
+    setError(null);
+    try { await action(netcattyBridge.require()); }
+    catch (cause) { setError(cause instanceof Error ? cause.message : String(cause)); }
+    finally {
+      try { await refresh(); } catch (cause) { setError(String(cause)); }
+      mutation.current = false;
+      setBusy(false);
+    }
+  }, [refresh]);
+  return {
+    plugins, available, statusKnown, busy, error, credentialStorageAvailable, refresh,
+    importPackage: () => run(async (bridge) => {
+      if (!bridge.selectFile || !bridge.installPluginPackage) throw new Error('Plugin import unavailable');
+      const path = await bridge.selectFile('Import plugin package', undefined, [{ name: 'Netcatty plugin', extensions: ['ncpkg'] }]);
+      if (path) await bridge.installPluginPackage(path, { enable: false });
+    }),
+    setEnabled: (id: string, enabled: boolean) => run(async (bridge) => {
+      if (!bridge.setPluginEnabled) throw new Error('Plugin management unavailable');
+      return bridge.setPluginEnabled(id, enabled);
+    }),
+    uninstall: (id: string, clearSource = false) => run(async (bridge) => {
+      if (!bridge.uninstallPlugin) throw new Error('Plugin management unavailable');
+      const source = clearSource ? await bridge.getPluginSourceBinding?.(id) : null;
+      await bridge.uninstallPlugin(id);
+      if (clearSource && source) {
+        if (!bridge.resetPluginSource) throw new Error('Private source reset unavailable');
+        await bridge.resetPluginSource(id, source.id);
+      }
+    }),
+  };
+}

application/state/usePluginSources.ts

@@ -0,0 +1,25 @@
+import { useCallback, useEffect, useState } from 'react';
+import { netcattyBridge } from '../../infrastructure/services/netcattyBridge';
+
+export function usePluginSources() {
+  const [sources, setSources] = useState<NetcattyPluginSource[]>([]);
+  const [error, setError] = useState<string | null>(null);
+  const [busy, setBusy] = useState(false);
+  const reload = useCallback(async () => {
+    const values = await netcattyBridge.require().listPluginSources?.();
+    if (!values) throw new Error('Source management unavailable');
+    setSources(values);
+  }, []);
+  useEffect(() => { void reload().catch((cause) => setError(String(cause))); }, [reload]);
+  const mutate = async (operation: () => Promise<unknown>) => {
+    setBusy(true); setError(null);
+    try { await operation(); await reload(); window.dispatchEvent(new Event('netcatty:plugin-packages-changed')); return true; }
+    catch (cause) { setError(String(cause)); return false; }
+    finally { setBusy(false); }
+  };
+  return { sources, error, busy,
+    add: (name: string, address: string) => mutate(async () => netcattyBridge.require().addPluginSource?.({ name, address })),
+    update: (source: NetcattyPluginSource, name: string, enabled: boolean) => mutate(async () => netcattyBridge.require().updatePluginSource?.({ id: source.id, name, enabled })),
+    remove: (id: string, disablePlugins: boolean) => mutate(async () => netcattyBridge.require().removePluginSource?.(id, disablePlugins)),
+  };
+}

application/state/usePluginTerminalSidebar.ts

@@ -0,0 +1,79 @@
+import { useEffect, useMemo, useRef, useSyncExternalStore } from 'react';
+import { useI18n } from '../i18n/I18nProvider';
+import { toast } from '../../components/ui/toast';
+import { collectSidePanelPanes, isPluginSidePanelTool, type SidePanelLayout } from '../../domain/sidePanelLayout';
+import { activeTabStore, useActiveTabId } from './activeTabStore';
+import { getSidePanelLiveSnapshot, subscribeSidePanelLiveSnapshot } from './sidePanelLiveStore';
+import { usePluginContributions } from './usePluginContributions';
+import { OPEN_PLUGIN_VIEW_EVENT, type OpenPluginViewDetail } from './usePluginViewLifecycle';
+
+export const OPEN_PLUGIN_TERMINAL_SIDEBAR_EVENT = 'netcatty:open-plugin-terminal-sidebar';
+export const PLUGIN_TERMINAL_SIDEBAR_CONTEXT = Object.freeze({ 'netcatty.surface': 'terminal-sidebar' });
+/** Required production view-context projection, not a plugin-facing API. */
+export interface PluginSidebarHostActions {
+  getActiveTerminalSessionId(): string | null;
+  handleSwitchSidePanelTab(tool: import('../../domain/sidePanelLayout').SidePanelTool): void;
+  handleWithdrawPluginSidebarPane(tabId: string, paneId: string, expectedTool: import('../../domain/sidePanelLayout').SidePanelTool): void;
+}
+export interface PluginTerminalSidebarPage {
+  tool: `plugin-view:${string}`;
+  viewId: string;
+  pluginId: string;
+  pluginName: string;
+  version: string;
+  title: string;
+  icon?: NetcattyPluginIconReference;
+  order: number;
+}
+export function collectPluginTerminalSidebarPages(plugins: NetcattyPluginContributionSnapshot['plugins']): PluginTerminalSidebarPage[] {
+  return plugins.flatMap((plugin) => plugin.views.filter((view) => view.location === 'terminal-sidebar' && view.visible)
+    .map((view): PluginTerminalSidebarPage => ({ tool: `plugin-view:${view.id}`, viewId: view.id, pluginId: plugin.id,
+      pluginName: plugin.displayName, version: plugin.version, title: view.title, icon: view.icon, order: view.order ?? 0 })))
+    .sort((a, b) => a.order - b.order || a.viewId.localeCompare(b.viewId));
+}
+export function requestOpenPluginTerminalSidebar(viewId: string, sessionId: string) {
+  window.dispatchEvent(new CustomEvent(OPEN_PLUGIN_TERMINAL_SIDEBAR_EVENT, { detail: { viewId, sessionId } }));
+}
+export function usePluginTerminalSidebar(host: {
+  layouts: ReadonlyMap<string, SidePanelLayout>;
+  getSession(): string | null;
+  isTerminalTab(tabId: string): boolean;
+  select(tool: `plugin-view:${string}`): void;
+  withdraw(tabId: string, paneId: string, tool: `plugin-view:${string}`): void;
+}) {
+  const { locale, t } = useI18n();
+  const activeTabId = useActiveTabId();
+  // Follow workspace focus without subscribing the whole sidebar to cwd/title
+  // or forwarding the host's live session DTO to a plugin.
+  useSyncExternalStore((listener) => subscribeSidePanelLiveSnapshot(true, listener),
+    () => getSidePanelLiveSnapshot(true).focusedSessionId, () => null);
+  const hostRef = useRef(host); hostRef.current = host;
+  const contributions = usePluginContributions({ locale, context: PLUGIN_TERMINAL_SIDEBAR_CONTEXT });
+  const pages = useMemo(() => collectPluginTerminalSidebarPages(contributions.snapshot.plugins), [contributions.snapshot.plugins]);
+  const sessionId = activeTabId && host.isTerminalTab(activeTabId) ? host.getSession() : null;
+  useEffect(() => {
+    const open = (event: Event) => {
+      const detail = (event as CustomEvent<OpenPluginViewDetail & { sessionId?: string }>).detail;
+      const page = pages.find((item) => item.viewId === detail?.viewId);
+      if (!page) return;
+      const tabId = activeTabStore.getActiveTabId();
+      const current = hostRef.current.getSession();
+      if (!hostRef.current.isTerminalTab(tabId) || !current || (detail.sessionId && detail.sessionId !== current)) {
+        toast.info(t('plugins.sidebar.selectTerminal'));
+        return;
+      }
+      hostRef.current.select(page.tool);
+    };
+    window.addEventListener(OPEN_PLUGIN_TERMINAL_SIDEBAR_EVENT, open);
+    window.addEventListener(OPEN_PLUGIN_VIEW_EVENT, open);
+    return () => { window.removeEventListener(OPEN_PLUGIN_TERMINAL_SIDEBAR_EVENT, open); window.removeEventListener(OPEN_PLUGIN_VIEW_EVENT, open); };
+  }, [pages, t]);
+  useEffect(() => {
+    if (contributions.loading) return;
+    const allowed = new Set(pages.map((page) => page.tool));
+    for (const [tabId, layout] of host.layouts) for (const pane of collectSidePanelPanes(layout.root)) {
+      if (isPluginSidePanelTool(pane.tool) && !allowed.has(pane.tool)) host.withdraw(tabId, pane.id, pane.tool);
+    }
+  }, [contributions.loading, host, pages]);
+  return { pages, contributions, tabId: activeTabId, sessionId };
+}

application/state/usePluginThemeRuntime.ts

@@ -0,0 +1,77 @@
+import { useEffect, useSyncExternalStore } from "react";
+import { netcattyBridge } from "../../infrastructure/services/netcattyBridge";
+import { pluginThemeRegistry } from "../../infrastructure/config/pluginThemeRegistry";
+export function usePluginThemeRevision() {
+  return useSyncExternalStore(
+    pluginThemeRegistry.subscribe,
+    pluginThemeRegistry.getRevision,
+    pluginThemeRegistry.getRevision,
+  );
+}
+/** Host-owned selection; never stored in plugin KV or cloud sidecars. */
+let runtimeUsers = 0;
+let disconnectRuntime: (() => void) | undefined;
+function connectRuntime() {
+  const bridge = netcattyBridge.get();
+  let active = true,
+    request = 0;
+  const refresh = async () => {
+    const current = ++request;
+    try {
+      const catalog = await bridge?.getPluginThemes?.();
+      if (active && current === request && catalog)
+        pluginThemeRegistry.setCatalog(catalog);
+    } catch {
+      /* Keep the last host-validated selection; never apply unvalidated data. */
+    }
+  };
+  void refresh();
+  const dispose = bridge?.onPluginThemesChanged?.(() => {
+    pluginThemeRegistry.invalidate();
+    void refresh();
+  });
+  const forced = window.matchMedia?.("(forced-colors: active)"),
+    contrast = window.matchMedia?.("(prefers-contrast: more)");
+  const update = () =>
+    pluginThemeRegistry.setHighContrast(
+      Boolean(forced?.matches || contrast?.matches),
+    );
+  update();
+  forced?.addEventListener?.("change", update);
+  contrast?.addEventListener?.("change", update);
+  return () => {
+    active = false;
+    request++;
+    dispose?.();
+    forced?.removeEventListener?.("change", update);
+    contrast?.removeEventListener?.("change", update);
+  };
+}
+export function usePluginThemeRuntime() {
+  const revision = usePluginThemeRevision();
+  useEffect(() => {
+    if (runtimeUsers++ === 0) disconnectRuntime = connectRuntime();
+    return () => {
+      if (--runtimeUsers === 0) {
+        disconnectRuntime?.();
+        disconnectRuntime = undefined;
+      }
+    };
+  }, []);
+  return revision;
+}
+export async function applyPluginThemeSelection(
+  mode: "light" | "dark",
+  choice: import("@netcatty/plugin-contract").ThemePackChoice | null,
+) {
+  if (choice === null && !pluginThemeRegistry.isActive(mode))
+    return pluginThemeRegistry.getCatalog();
+  const bridge = netcattyBridge.require();
+  if (!bridge.applyPluginTheme) throw new Error("Plugin themes unavailable");
+  const next = await bridge.applyPluginTheme({
+    mode,
+    choice,
+    expectedRevision: pluginThemeRegistry.getCatalog().selection.revision,
+  });
+  return next; // The host change event refreshes every window; never publish a potentially stale apply response.
+}

application/state/usePluginVaultPages.ts

@@ -0,0 +1,47 @@
+import { useCallback, useEffect, useMemo, useRef } from 'react';
+import { activeTabStore, useActiveTabId } from './activeTabStore';
+import { collectPluginVaultPages, PLUGIN_VAULT_PAGE_PREFIX, resolvePluginVaultPage } from './pluginVaultPages';
+import { usePluginContributions } from './usePluginContributions';
+import { OPEN_PLUGIN_VIEW_EVENT, type OpenPluginViewDetail } from './usePluginViewLifecycle';
+
+const CONTEXT = Object.freeze({ 'netcatty.surface': 'vault-page' });
+
+export function usePluginVaultPages({ locale, section, select }: {
+  locale: string;
+  section: string;
+  select(section: 'hosts' | `plugin-vault:${string}`): void;
+}) {
+  const active = useActiveTabId() === 'vault';
+  const sectionRef = useRef(section);
+  const focusFrame = useRef<number | null>(null);
+  sectionRef.current = section;
+  useEffect(() => () => { if (focusFrame.current !== null) cancelAnimationFrame(focusFrame.current); }, []);
+  const contributions = usePluginContributions({ locale, context: CONTEXT });
+  const pages = useMemo(() => collectPluginVaultPages(contributions.snapshot.plugins), [contributions.snapshot.plugins]);
+  const selected = resolvePluginVaultPage(pages, section);
+  const fallback = useCallback(() => {
+    select('hosts');
+    if (focusFrame.current !== null) cancelAnimationFrame(focusFrame.current);
+    focusFrame.current = requestAnimationFrame(() => {
+      focusFrame.current = null;
+      if (sectionRef.current === 'hosts' && activeTabStore.getActiveTabId() === 'vault') {
+        document.querySelector<HTMLButtonElement>('[data-plugin-vault-fallback]')?.focus();
+      }
+    });
+  }, [select]);
+  useEffect(() => {
+    if (!contributions.loading && section.startsWith(PLUGIN_VAULT_PAGE_PREFIX) && !selected) fallback();
+  }, [contributions.loading, fallback, section, selected]);
+  useEffect(() => {
+    const open = (event: Event) => {
+      const detail = (event as CustomEvent<OpenPluginViewDetail>).detail;
+      const page = pages.find((item) => item.viewId === detail?.viewId);
+      if (!page) return;
+      activeTabStore.setActiveTabId('vault');
+      select(page.key);
+    };
+    window.addEventListener(OPEN_PLUGIN_VIEW_EVENT, open);
+    return () => window.removeEventListener(OPEN_PLUGIN_VIEW_EVENT, open);
+  }, [pages, select]);
+  return { pages, selected, active, select, fallback, contributions, context: CONTEXT };
+}

application/state/usePluginViewLifecycle.ts

@@ -82,7 +82,7 @@ export function usePluginViewLifecycle({
   const mountRef = useRef<HTMLDivElement>(null);
   const resolvedActiveView = useMemo(() => viewContributions.snapshot.plugins
     .flatMap((plugin) => plugin.views.map((view) => ({ plugin, view })))
-    .find(({ view }) => view.id === effectiveRequested?.viewId && view.visible) ?? null,
+    .find(({ view }) => view.id === effectiveRequested?.viewId && view.visible && !['vault-page', 'terminal-sidebar'].includes(view.location)) ?? null,
   [effectiveRequested?.viewId, viewContributions.snapshot.plugins]);
   const stableActiveViewRef = useRef<PluginViewSnapshotSelection<ResolvedPluginView> | null>(null);
   const activeView = resolvePluginViewSnapshotSelection({

application/state/useSessionState.ts

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

application/state/useSessionState.workspaceHostOpen.test.ts

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

application/state/useSettingsState.ts

@@ -1,3 +1,4 @@
+import { usePluginThemeRuntime } from './usePluginThemeRuntime';
 import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, type SetStateAction } from 'react';
 
 import { runThemeTransition, type ThemeTransitionMode } from './themeTransition';
@@ -217,6 +218,7 @@ import {
 } from './appearanceSync';
 
 export const useSettingsState = (options: { enableSettingsSync?: boolean; enableSystemEffects?: boolean } = {}) => {
+  const pluginThemeRevision = usePluginThemeRuntime();
   const enableSettingsSync = options.enableSettingsSync !== false;
   const enableSystemEffects = options.enableSystemEffects !== false;
   const initialCustomKeyBindingsRecord =
@@ -1212,7 +1214,7 @@ export const useSettingsState = (options: { enableSettingsSync?: boolean; enable
         notifySettingsChanged(STORAGE_KEY_COLOR, customAccentRecord);
       }
     }
-  }, [theme, resolvedTheme, lightUiThemeId, darkUiThemeId, accentMode, customAccent, customAccentRecord, notifySettingsChanged]);
+  }, [theme, resolvedTheme, lightUiThemeId, darkUiThemeId, accentMode, customAccent, customAccentRecord, notifySettingsChanged, pluginThemeRevision]);
 
   // Listen for OS color scheme changes to keep systemPreference in sync
   useEffect(() => {
@@ -1979,9 +1981,10 @@ export const useSettingsState = (options: { enableSettingsSync?: boolean; enable
   }, [setTerminalSettings]);
 
   const applyAppTheme = useCallback(() => {
+    void pluginThemeRevision; // Invalidate the closure when host theme data changes.
     const tokens = getUiThemeById(resolvedTheme, resolvedTheme === 'dark' ? darkUiThemeId : lightUiThemeId).tokens;
     applyThemeTokens(theme, resolvedTheme, tokens, accentMode, customAccent);
-  }, [theme, resolvedTheme, lightUiThemeId, darkUiThemeId, accentMode, customAccent]);
+  }, [theme, resolvedTheme, lightUiThemeId, darkUiThemeId, accentMode, customAccent, pluginThemeRevision]);
 
   const setEditorWordWrap = useCallback((enabled: boolean) => {
     setEditorWordWrapState(enabled);

application/state/useTerminalSidePanelLayoutState.test.tsx

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

application/state/useTerminalSidePanelLayoutState.ts

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

application/state/useVaultAgentBridge.ts

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

application/state/useVaultState.connectionLogTerminalData.test.ts

@@ -25,7 +25,7 @@ test("close-path connection log updates await the indexedDB persist task", () =>
     source,
     /const updateConnectionLog = useCallback\([\s\S]*?return commitConnectionLogs\(/,
   );
-  assert.match(source, /rebaseQueuedConnectionLogs\(\s*next,\s*removedIds,\s*changedIds,/);
+  assert.match(source, /rebaseQueuedConnectionLogs\(\s*memory,\s*removedIds,\s*changedIds,/);
   assert.match(
     source,
     /if \(!options\?\.pruneMainBlob\) \{[\s\S]*?rebaseQueuedConnectionLogs\(/,

application/state/useVaultState.ts

@@ -62,7 +62,8 @@ import {
 } from "../../domain/globalHistory";
 import {
   buildTerminalDataMapFromLogs,
-  mergeConnectionLogsFromStorage,
+  acknowledgePendingConnectionLogWrites,
+  mergeConnectionLogsWithPendingMutations,
   mergeTerminalDataIntoLogs,
   mergeTerminalDataMapsForStorage,
   pruneInMemoryUnsavedTerminalData,
@@ -70,6 +71,7 @@ import {
   retainNewestUnsavedReplays,
   pruneTerminalDataMapForStorage,
   type ConnectionLogTerminalDataMap,
+  type PendingConnectionLogWrite,
 } from "../../domain/connectionLogTerminalData";
 import {
   tryLoadAll as tryLoadConnectionLogTerminalData,
@@ -429,6 +431,8 @@ export const useVaultState = (options?: UseVaultStateOptions) => {
   const proxyProfilesReadSeq = useRef(0);
   const groupConfigsReadSeq = useRef(0);
   const connectionLogsRef = useRef<ConnectionLog[]>([]);
+  const connectionLogWriteGenerationRef = useRef(0);
+  const connectionLogPendingRef = useRef(new Map<string, PendingConnectionLogWrite>());
   const connectionLogTerminalDataRef = useRef<ConnectionLogTerminalDataMap>({});
   const connectionLogTerminalDataPersistedRef = useRef<ConnectionLogTerminalDataMap>({});
   const connectionLogTerminalDataRevRawRef = useRef<string | null>(null);
@@ -518,17 +522,23 @@ export const useVaultState = (options?: UseVaultStateOptions) => {
     const unsavedTerminalDataPending = logs.some(
       (log) => !log.saved && log.terminalData !== undefined,
     );
+    let mainReplay: ConnectionLogTerminalDataMap = {};
+    const writeMain = (value: ConnectionLog[]) => {
+      const written = localStorageAdapter.write(STORAGE_KEY_CONNECTION_LOGS, value);
+      if (written) mainReplay = buildTerminalDataMapFromLogs(value);
+      return written;
+    };
 
     let mainPersisted = true;
     if (options?.pruneMainBlob) {
       const prunedMain = pruneConnectionLogsForStorage(logs);
-      mainPersisted = localStorageAdapter.write(STORAGE_KEY_CONNECTION_LOGS, prunedMain);
+      mainPersisted = writeMain(prunedMain);
       if (!mainPersisted && unsavedTerminalDataPending) {
-        mainPersisted = localStorageAdapter.write(STORAGE_KEY_CONNECTION_LOGS, logs);
+        mainPersisted = writeMain(logs);
       }
     }
 
-    let sidePersisted = true;
+    let sidePersisted = false;
     if (mainPersisted || !options?.pruneMainBlob) {
       sidePersisted = await syncConnectionLogTerminalDataMap(logs, {
         usePersistedLogIdsFromDisk: Boolean(options?.pruneMainBlob && mainPersisted),
@@ -545,11 +555,16 @@ export const useVaultState = (options?: UseVaultStateOptions) => {
           logs,
           options?.removedIds ?? new Set<string>(),
           options?.changedIds ?? new Set<string>(),
-          connectionLogsRef.current,
+          mergeConnectionLogsWithPendingMutations(
+            connectionLogsRef.current,
+            freshLogs,
+            connectionLogTerminalDataPersistedRef.current,
+            connectionLogPendingRef.current,
+          ),
           freshLogs,
         )
         : logs;
-      mainPersisted = localStorageAdapter.write(STORAGE_KEY_CONNECTION_LOGS, toWrite);
+      mainPersisted = writeMain(toWrite);
     } else if (!sidePersisted && unsavedTerminalDataPending && mainPersisted) {
       // IndexedDB rejected the replay after the pruned metadata write. Put the
       // buffers back on the current main blob so a restart still has them,
@@ -560,12 +575,12 @@ export const useVaultState = (options?: UseVaultStateOptions) => {
       let fallbackLogs = freshLogs
         ? mergeTerminalDataIntoLogs(freshLogs, buildTerminalDataMapFromLogs(logs))
         : logs;
-      sidePersisted = localStorageAdapter.write(STORAGE_KEY_CONNECTION_LOGS, fallbackLogs);
+      sidePersisted = writeMain(fallbackLogs);
       let keep = fallbackLogs.filter((log) => !log.saved && log.terminalData).length;
       while (!sidePersisted && keep > 1) {
         keep = Math.max(1, Math.floor(keep / 2));
         fallbackLogs = retainNewestUnsavedReplays(fallbackLogs, keep);
-        sidePersisted = localStorageAdapter.write(STORAGE_KEY_CONNECTION_LOGS, fallbackLogs);
+        sidePersisted = writeMain(fallbackLogs);
       }
     }
 
@@ -578,7 +593,7 @@ export const useVaultState = (options?: UseVaultStateOptions) => {
         "[useVaultState] Failed to persist connection log terminal replay data side store.",
       );
     }
-    return mainPersisted && sidePersisted;
+    return { metadataPersisted: mainPersisted, replayPersisted: sidePersisted, mainReplay };
   }, [syncConnectionLogTerminalDataMap]);
 
   const commitConnectionLogs = useCallback((
@@ -589,28 +604,81 @@ export const useVaultState = (options?: UseVaultStateOptions) => {
     const next = recipe(prev);
     const prevById = new Map(prev.map((log) => [log.id, log]));
     const nextIds = new Set<string>();
-    const changedIds = new Set<string>();
+    const generation = ++connectionLogWriteGenerationRef.current;
     for (const log of next) {
       nextIds.add(log.id);
       const before = prevById.get(log.id);
-      if (!before || before !== log) changedIds.add(log.id);
+      if (!before || before !== log) {
+        const previous = connectionLogPendingRef.current.get(log.id);
+        const changes: Partial<ConnectionLog> = { ...previous?.changes };
+        const fieldGenerations = { ...previous?.fieldGenerations };
+        for (const field of Object.keys({ ...before, ...log }) as Array<keyof ConnectionLog>) {
+          if (!before || before[field] !== log[field]) {
+            Object.assign(changes, { [field]: log[field] });
+            fieldGenerations[field] = generation;
+          }
+        }
+        connectionLogPendingRef.current.set(log.id, {
+          generation, log, changes, fieldGenerations, added: previous?.added ?? !before,
+        });
+      }
+    }
+    for (const log of prev) {
+      if (!nextIds.has(log.id)) {
+        connectionLogPendingRef.current.set(log.id, { generation, log: null });
+      }
     }
-    const removedIds = new Set(prev.filter((log) => !nextIds.has(log.id)).map((log) => log.id));
     connectionLogsRef.current = next;
     setConnectionLogs(next);
-    // The task may run after another window writes. Rebase onto the logs that
-    // exist then. Restore only ids this recipe added or replaced.
-    return enqueueTerminalDataTask(() => persistConnectionLogState(
-      rebaseQueuedConnectionLogs(
-        next,
-        removedIds,
-        changedIds,
+    return enqueueTerminalDataTask(() => withVaultImportLock("connection-logs", async () => {
+      // The shared lock covers the read/rebase as well as both storage writes.
+      // Include uncommitted generations from failed or newer queued captures.
+      await absorbRemoteTerminalDataIfNeeded();
+      const pending = new Map(connectionLogPendingRef.current);
+      const removedIds = new Set<string>();
+      const changedIds = new Set<string>();
+      for (const [id, mutation] of pending) {
+        if (mutation.log === null) removedIds.add(id);
+        else changedIds.add(id);
+      }
+      const storedBefore = localStorageAdapter.read<ConnectionLog[]>(STORAGE_KEY_CONNECTION_LOGS);
+      const memory = mergeConnectionLogsWithPendingMutations(
         connectionLogsRef.current,
-        localStorageAdapter.read<ConnectionLog[]>(STORAGE_KEY_CONNECTION_LOGS),
-      ),
-      { ...options, removedIds, changedIds },
-    ));
-  }, [enqueueTerminalDataTask, persistConnectionLogState]);
+        storedBefore ?? connectionLogsRef.current,
+        connectionLogTerminalDataPersistedRef.current,
+        pending,
+      );
+      const persisted = await persistConnectionLogState(
+        rebaseQueuedConnectionLogs(
+          memory,
+          removedIds,
+          changedIds,
+          memory,
+          storedBefore,
+        ),
+        { ...options, removedIds, changedIds },
+      );
+      // A replay/quota failure must not retain already-committed add or
+      // metadata ownership: retrying it could undo a peer bookmark/deletion.
+      connectionLogPendingRef.current = acknowledgePendingConnectionLogWrites(
+        connectionLogPendingRef.current, pending, persisted,
+      );
+      if (persisted.metadataPersisted || persisted.replayPersisted) {
+        const stored = localStorageAdapter.read<ConnectionLog[]>(STORAGE_KEY_CONNECTION_LOGS);
+        if (stored) {
+          const merged = mergeConnectionLogsWithPendingMutations(
+            connectionLogsRef.current,
+            stored,
+            connectionLogTerminalDataRef.current,
+            connectionLogPendingRef.current,
+          );
+          connectionLogsRef.current = merged;
+          setConnectionLogs(merged);
+        }
+      }
+      return persisted.metadataPersisted && persisted.replayPersisted;
+    }));
+  }, [absorbRemoteTerminalDataIfNeeded, enqueueTerminalDataTask, persistConnectionLogState]);
 
   const applyConnectionLogsFromStorage = useCallback((
     prev: ConnectionLog[],
@@ -618,7 +686,12 @@ export const useVaultState = (options?: UseVaultStateOptions) => {
     terminalDataMap: ConnectionLogTerminalDataMap,
   ) => {
     connectionLogTerminalDataRef.current = terminalDataMap;
-    return mergeConnectionLogsFromStorage(prev, storedLogs, terminalDataMap);
+    return mergeConnectionLogsWithPendingMutations(
+      prev,
+      storedLogs,
+      terminalDataMap,
+      connectionLogPendingRef.current,
+    );
   }, []);
 
   // Encrypt outside the lock, then under the lock prune script bindings against
@@ -703,6 +776,13 @@ export const useVaultState = (options?: UseVaultStateOptions) => {
     }
   }, [waitForPendingVaultWrites]);
 
+  // Host-owned action guards need the synchronous mutation snapshot, including
+  // edits that React has not published yet. This accessor never crosses RPC.
+  const readCurrentHostActionState = useCallback(() => ({
+    hosts: hostsRef.current, groupConfigs: groupConfigsRef.current, snippets: snippetsRef.current,
+    managedSources: managedSourcesRef.current,
+  }), []);
+
   const updateKeys = useCallback((data: SSHKey[]) => {
     const cleaned = normalizeVaultOrder(data);
     setKeys(cleaned);
@@ -1175,6 +1255,7 @@ export const useVaultState = (options?: UseVaultStateOptions) => {
     updateGroupConfigs?: (current: GroupConfig[]) => GroupConfig[],
     expectedHosts?: Host[],
     lock?: VaultLockHandle | null,
+    assertAuthorized?: () => void | Promise<void>,
   ): Promise<
     | {
       status: "persisted";
@@ -1249,6 +1330,10 @@ export const useVaultState = (options?: UseVaultStateOptions) => {
         encryptHosts(cleanedHosts),
         encryptGroupConfigs(nextGroupConfigs),
       ]);
+      // Optional plugin draft guard: runtime/source/revoke/lock authority must
+      // still hold after encryption, immediately before the existing atomic
+      // persistence boundary. Ordinary imports retain their existing behavior.
+      if (assertAuthorized) await assertAuthorized();
       if (
         version !== hostsWriteVersion.current
         || groupConfigsVersion !== groupConfigsWriteVersion.current
@@ -2077,7 +2162,10 @@ export const useVaultState = (options?: UseVaultStateOptions) => {
       }
 
       if (key === STORAGE_KEY_CONNECTION_LOGS) {
-        const next = safeParse<ConnectionLog[]>(event.newValue) ?? [];
+        // A queued peer event may predate our successful commit. Read the
+        // current blob, then preserve only still-owned local generations.
+        const next = localStorageAdapter.read<ConnectionLog[]>(STORAGE_KEY_CONNECTION_LOGS);
+        if (!next) return;
         const merged = applyConnectionLogsFromStorage(
           connectionLogsRef.current,
           next,
@@ -2123,7 +2211,7 @@ export const useVaultState = (options?: UseVaultStateOptions) => {
       if (!syncConnectionLogTerminalData) return;
       if (raw === connectionLogTerminalDataRevRawRef.current) return;
       const seq = ++connectionLogTerminalDataLoadSeq.current;
-      void terminalDataReadyRef.current.then(() => enqueueTerminalDataTask(async () => {
+      void terminalDataReadyRef.current.then(() => enqueueTerminalDataTask(() => withVaultImportLock("connection-logs", async () => {
         if (seq !== connectionLogTerminalDataLoadSeq.current) return;
         const map = await loadConnectionLogTerminalData();
         if (seq !== connectionLogTerminalDataLoadSeq.current) return;
@@ -2133,14 +2221,15 @@ export const useVaultState = (options?: UseVaultStateOptions) => {
         );
         connectionLogTerminalDataPersistedRef.current = map;
         connectionLogTerminalDataRef.current = map;
-        const merged = mergeConnectionLogsFromStorage(
-          connectionLogsRef.current,
+        const merged = mergeConnectionLogsWithPendingMutations(
           connectionLogsRef.current,
+          localStorageAdapter.read<ConnectionLog[]>(STORAGE_KEY_CONNECTION_LOGS) ?? connectionLogsRef.current,
           map,
+          connectionLogPendingRef.current,
         );
         connectionLogsRef.current = merged;
         setConnectionLogs(merged);
-      }));
+      })));
     };
 
     const handleLocalStorageAdapterChanged = (event: Event) => {
@@ -2442,6 +2531,7 @@ export const useVaultState = (options?: UseVaultStateOptions) => {
     groupConfigs,
     updateHosts,
     readPersistedHosts,
+    readCurrentHostActionState,
     updateKeys,
     importOrReuseKey,
     updateIdentities,

components/GlobalSftpTransferCenter.cleanup-warning.test.tsx

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

components/GlobalSftpTransferCenter.tsx

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

components/HistorySidePanel.tsx

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

components/HostDetailsPanel.securityTheme.test.tsx

@@ -0,0 +1,58 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import test from 'node:test';
+import React from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
+import { JSDOM } from 'jsdom';
+import { compile } from '@tailwindcss/node';
+import postcss from 'postcss';
+import HostDetailsPanel from './HostDetailsPanel';
+import { Card } from './ui/card';
+import { TooltipProvider } from './ui/tooltip';
+import { PluginPermissionPanel } from './settings/tabs/PluginPermissionPanel';
+import { I18nProvider } from '../application/i18n/I18nProvider';
+
+test('real Host form cards, inputs and Save consume scoped security aliases without freezing an ordinary card', async () => {
+  const markup = renderToStaticMarkup(<I18nProvider locale="en"><TooltipProvider>
+    <HostDetailsPanel availableKeys={[]} identities={[]} groups={[]} terminalThemeId="default" terminalFontSize={14} onSave={() => assert.fail('test never saves a host')} onCancel={() => {}} />
+    <PluginPermissionPanel pluginId="com.example.synthetic" onChanged={async () => {}} />
+    <Card id="ordinary-card">Outside the security surface</Card>
+  </TooltipProvider></I18nProvider>);
+  const dom = new JSDOM(`<!doctype html><html data-plugin-theme-active><body>${markup}</body></html>`);
+  try {
+    const panel = dom.window.document.querySelector('[data-section="host-details-panel"]')!;
+    assert.ok(panel, 'exercise the actual HostDetailsPanel and AsidePanel');
+    assert.ok(panel.querySelector('.bg-card'), 'General/Address/Credentials use real Card components');
+    assert.ok(panel.querySelector('input.bg-background'), 'exercise actual Input utilities');
+    assert.ok(panel.querySelector('button.bg-primary'), 'exercise the actual Save button');
+    const permissions = dom.window.document.querySelector('[data-host-security-surface]')!;
+    assert.ok(permissions.querySelector('[role="status"]'), 'exercise the real grant-panel security root without loading or changing any grants');
+    const source = await readFile(new URL('../index.css', import.meta.url), 'utf8');
+    const compiler = await compile(source, {base: path.resolve('.'), onDependency() {}});
+    const classes = [...new Set([...dom.window.document.querySelectorAll('[class]')].flatMap(el => [...el.classList]))];
+    const css = compiler.build(classes);
+    const parsed = postcss.parse(css);
+    const rules: postcss.Rule[] = [];
+    parsed.walkRules(rule => { rules.push(rule); });
+    const rule = rules.find(node => node.selector.startsWith(':root[data-plugin-theme-active]'));
+    assert.ok(rule && rule.type === 'rule');
+    const matches = [...dom.window.document.querySelectorAll(rule.selector)];
+    assert.ok(matches.includes(panel));
+    assert.ok(matches.includes(permissions));
+    assert.ok(!matches.includes(dom.window.document.getElementById('ordinary-card')!), 'security selector stays within the existing marked surfaces');
+    const declarations = new Map(rule.nodes.filter(node => node.type === 'decl').map(node => [node.prop, node]));
+    for (const name of ['background','foreground','card','card-foreground','popover','popover-foreground','primary','primary-foreground','secondary','secondary-foreground','muted','muted-foreground','accent','accent-foreground','destructive','destructive-foreground','border','input','ring']) {
+      const declaration = declarations.get(`--color-${name}`);
+      assert.equal(declaration?.value, `hsl(var(--host-security-${name}))`, `Tailwind alias ${name} cannot inherit the plugin value`);
+      assert.equal(declaration.important, true);
+    }
+    for (const name of ['card','background','primary']) {
+      const utility = rules.find(node => node.selector === `.bg-${name}`);
+      assert.ok(utility && utility.type === 'rule');
+      assert.ok(utility.nodes.some(node => node.type === 'decl' && node.prop === 'background-color' && node.value === `var(--color-${name})`), 'verify what the actual compiled utility consumes');
+    }
+    const mutedText = rules.find(node => node.selector === '.text-muted-foreground');
+    assert.ok(mutedText?.nodes.some(node => node.type === 'decl' && node.prop === 'color' && node.value === 'var(--color-muted-foreground)'));
+  } finally { dom.window.close(); }
+});

components/KeychainManager.tsx

@@ -882,6 +882,7 @@ echo $3 >> "$FILE"`);
       {/* Slide-out Panel */}
       {panel.type !== "closed" && (
         <AsidePanel
+          dataSection="keychain-security-panel"
           open={true}
           onClose={closePanel}
           title={panelTitle}

components/PluginHostActions.entrypoint.test.tsx

@@ -0,0 +1,290 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { EventEmitter } from 'node:events';
+import { createRequire } from 'node:module';
+import { mkdtemp, cp, rm } from 'node:fs/promises';
+import path from 'node:path';
+import { tmpdir } from 'node:os';
+import { JSDOM } from 'jsdom';
+import { sanitizeHost } from '../domain/host';
+import type { ConnectionLog, Host, ManagedSource } from '../domain/models';
+import { applyGroupDefaults, resolveGroupDefaults } from '../domain/groupConfig';
+import type { HostInteractionEvent, HostInteractionPrompt, VaultHostSelectionResult, VaultHostActionResult, VaultHostRef } from '@netcatty/plugin-contract';
+
+const require = createRequire(import.meta.url);
+
+test('installed sample entrypoint uses real SDK, source authority, signed host dialogs and renderer action guards', { timeout: 45_000 }, async (t) => {
+  const dom = new JSDOM('<!doctype html><html><body><div id="root"></div></body></html>', { pretendToBeVisual: true, url: 'http://localhost' });
+  const previous = new Map<string, PropertyDescriptor | undefined>();
+  const install = (key: string, value: unknown) => {
+    previous.set(key, Object.getOwnPropertyDescriptor(globalThis, key));
+    Object.defineProperty(globalThis, key, { configurable: true, writable: true, value });
+  };
+  for (const key of ['window', 'document', 'navigator', 'HTMLElement', 'HTMLInputElement', 'HTMLButtonElement', 'Element', 'SVGElement', 'Node', 'NodeFilter', 'MutationObserver', 'CustomEvent', 'Event', 'KeyboardEvent', 'MouseEvent']) {
+    install(key, key === 'window' ? dom.window : dom.window[key as keyof typeof dom.window]);
+  }
+  install('getComputedStyle', dom.window.getComputedStyle.bind(dom.window));
+  install('requestAnimationFrame', dom.window.requestAnimationFrame.bind(dom.window));
+  install('cancelAnimationFrame', dom.window.cancelAnimationFrame.bind(dom.window));
+  install('IS_REACT_ACT_ENVIRONMENT', true);
+  install('ResizeObserver', class { observe() {} unobserve() {} disconnect() {} });
+  const { default: React, act } = await import('react');
+  const { createRoot } = await import('react-dom/client');
+  const { I18nProvider } = await import('../application/i18n/I18nProvider');
+  const { PluginHostActionHost } = await import('./plugins/PluginHostActionHost');
+  const { handleConnectToHostImpl } = await import('../application/app/AppHandlers');
+  const runtime = await import('../application/state/appRuntimeBridge');
+  const { registerAppHandlers } = await import('../application/app/appHandlersBridge');
+  const { createPluginHostService } = require('../electron/plugins/hostService.cjs');
+  const { inProcessBrowserRuntime } = require('../electron/plugins/fixtures/inProcessBrowserRuntime.cjs');
+  const directory = await mkdtemp(path.join(tmpdir(), 'netcatty-host-entry-'));
+  const listeners = new Set<(event: unknown) => void>();
+  const prompts: HostInteractionPrompt[] = [];
+  const sender = Object.assign(new EventEmitter(), { id: 77, isDestroyed: () => false, send(_channel: string, event: HostInteractionEvent) { if (!('closed' in event)) prompts.push(event); for (const listener of listeners) listener(event); } });
+  const owner = Object.assign(new EventEmitter(), { webContents: sender, isFocused: () => true, isVisible: () => true, isDestroyed: () => false });
+  let locked = false;
+  let onLock: ((state: { locked: boolean }) => void) | undefined;
+  const service = createPluginHostService({
+    app: { getAppPath: () => process.cwd(), getPath: () => directory, getVersion: () => '0.0.0' }, electron: {}, env: {},
+    getInteractionWindow: () => owner, isAppLocked: () => locked,
+    subscribeAppLock: (callback: typeof onLock) => { onLock = callback; return () => {}; },
+    requestPermissionDecision: async (request: { requestId: string; permission: string }) => ({ requestId: request.requestId, decision: 'allow', scope: ['vault.metadata', 'vault.write', 'ui.interact'].includes(request.permission) ? 'once' : 'application' }),
+  });
+  let requestClock = Date.now();
+  service.interactionService.clock = () => requestClock;
+  service.runtimeSupervisor.runtimeFactories.browser = inProcessBrowserRuntime;
+  Object.assign(dom.window, { netcatty: {
+    onPluginInteraction(callback: (event: unknown) => void) { listeners.add(callback); return () => listeners.delete(callback); },
+    respondPluginInteraction: (response: unknown) => service.interactionService.respond(sender, response),
+  } });
+  const first = sanitizeHost({ id: 'synthetic-first', label: 'Synthetic first', hostname: 'first.invalid', username: 'test', port: 22, protocol: 'ssh', os: 'linux', tags: ['synthetic'], group: 'Synthetic', password: 'synthetic-password', startupCommand: 'synthetic-script' });
+  const second = sanitizeHost({ ...first, id: 'synthetic-second', label: 'Synthetic second', hostname: 'second.invalid', password: undefined, startupCommand: undefined });
+  let hosts: Host[] = [first, second];
+  let persisted = hosts.map((host) => structuredClone(host));
+  let beforeCommit: (() => Promise<void>) | undefined;
+  let saves = 0;
+  const connections: Host[] = [];
+  const vault = {
+    hosts, customGroups: ['Synthetic'], groupConfigs: [], snippets: [], managedSources: [] as ManagedSource[], isInitialized: true,
+    readCurrentHostActionState: () => ({ hosts, groupConfigs: vault.groupConfigs, snippets: vault.snippets, managedSources: vault.managedSources }),
+    async readPersistedHosts() { return persisted.map((host) => structuredClone(host)); },
+    async commitVaultImportTransaction(next: Host[], groups: (groups: string[]) => string[], sources: (sources: ManagedSource[]) => ManagedSource[], _configs: unknown, _expected: unknown, _lock: unknown, authorize: () => Promise<void>) {
+      const nextSources = sources(vault.managedSources);
+      await beforeCommit?.();
+      await authorize();
+      saves++; hosts = next; persisted = next.map((host) => structuredClone(host));
+      return { status: 'persisted', groups: groups(vault.customGroups), sources: nextSources, groupConfigs: [] };
+    },
+  };
+  const publish = () => {
+    runtime.registerAppVaultRuntime(vault as never);
+    runtime.registerAppAppLockRuntime({ initialized: true, locked } as never);
+  };
+  publish();
+  registerAppHandlers({ handleConnectToHost: (host: Host) => { connections.push(host); return 'private-session-id'; } });
+  const root = createRoot(document.getElementById('root')!);
+  const settle = () => new Promise((resolve) => setTimeout(resolve, 20));
+  const waitFor = async (predicate: () => boolean) => {
+    for (let count = 0; count < 80; count++) { await act(async () => { await settle(); }); if (predicate()) return; }
+    assert.fail(`Expected host UI state; current text: ${document.body.textContent}`);
+  };
+  const button = (text: string) => Array.from(document.querySelectorAll<HTMLButtonElement>('button')).find((item) => item.textContent === text)!;
+  const click = async (element: HTMLElement) => { assert.ok(element); await act(async () => { element.click(); await settle(); }); };
+  const begin = async (name: string) => {
+    requestClock += 60_001;
+    let promise!: Promise<VaultHostSelectionResult | VaultHostActionResult>;
+    await act(async () => { promise = service.contributionService.executeCommand(`com.netcatty.host-actions.${name}`); void promise.catch(() => {}); await settle(); });
+    await waitFor(() => document.querySelector('[role="dialog"]') !== null);
+    return { promise };
+  };
+  const chooseGroup = async () => {
+    await click(document.querySelector<HTMLElement>('[role="option"] button[aria-pressed]')!);
+    await click(Array.from(document.querySelectorAll<HTMLButtonElement>('button')).find((item) => item.textContent?.startsWith('Continue ('))!);
+  };
+  try {
+    await service.manager.initialize();
+    const packageRoot = path.join(directory, 'source');
+    await cp(new URL('../examples/plugins/host-actions/', import.meta.url), packageRoot, { recursive: true });
+    const { buildPluginPackage } = await import('@netcatty/plugin-cli');
+    const archive = path.join(directory, 'fixture.ncpkg');
+    await buildPluginPackage(packageRoot, archive);
+    await service.manager.install(archive, { enable: true });
+    service.interactionService.setReady(sender, true);
+    await act(async () => root.render(<I18nProvider locale="en"><PluginHostActionHost /></I18nProvider>));
+
+    let selectedTarget: VaultHostRef;
+    await t.test('group selection shares only explicit current members and grants no connection', async () => {
+      const run = await begin('select');
+      await click(document.querySelector<HTMLElement>('[role="option"] button[aria-pressed]')!);
+      hosts = [...hosts, sanitizeHost({ ...second, id: 'synthetic-future', hostname: 'future.invalid' })];
+      persisted = hosts.map((host) => structuredClone(host));
+      await click(Array.from(document.querySelectorAll<HTMLButtonElement>('button')).find((item) => item.textContent?.startsWith('Continue ('))!);
+      const result = await run.promise;
+      assert.ok('hosts' in result);
+      assert.equal(result.hosts.length, 2); assert.equal(result.groups[0].members.length, 2);
+      assert.equal(result.hosts.some((host) => host.metadata.hostname === 'future.invalid'), false);
+      assert.equal(result.hosts[0].target.scope, 'metadata');
+      selectedTarget = result.hosts[0].target;
+      for (const text of ['synthetic-password', 'synthetic-script', 'resourceId', 'private-session-id']) assert.equal(JSON.stringify(result).includes(text), false);
+      assert.equal(connections.length, 0); assert.equal(saves, 0);
+    });
+
+    await t.test('registered boundaries reject AI text, caller owners, tampered targets and stale expected revisions', async () => {
+      const identity = service.runtimeSupervisor.getRuntimeIdentity('com.netcatty.host-actions');
+      const routes = service.rpcRegistry.createRoutes({ ...identity, manifest: service.database.getActivePlugin(identity.pluginId).manifest });
+      const transport = { signal: new AbortController().signal };
+      for (const target of [
+        { handle: 'text-only', version: 'v1', scope: 'host' },
+        { ...selectedTarget, handle: 'synthetic-tampered-selection-handle-0000' },
+      ]) await assert.rejects(routes.requestHandlers['vault.requestConnect']({ target, expectedRevision: selectedTarget.revision }, transport), /invalid|expired|changed/);
+      await assert.rejects(routes.requestHandlers['vault.requestConnect']({ target: selectedTarget, expectedRevision: 'stale' }, transport), /expired|changed/);
+      await assert.rejects(routes.requestHandlers['vault.requestHostDraft']({ privateOwner: 'spoof', draft: { hostname: 'synthetic.invalid' } }, transport), /invalid/);
+      assert.equal(service.interactionService.pending.size, 0); assert.equal(connections.length, 0);
+    });
+
+    await t.test('cancel creates no draft or connection', async () => {
+      const run = await begin('create'); await click(button('Cancel'));
+      assert.deepEqual(await run.promise, { cancelled: true }); assert.equal(saves, 0); assert.equal(connections.length, 0);
+    });
+
+    await t.test('reviewed create saves only the synthetic SSH draft', async () => {
+      const run = await begin('create');
+      assert.match(document.body.textContent ?? '', /Changes to save/);
+      await click(button('Save Host'));
+      assert.deepEqual(await run.promise, { cancelled: false, status: 'saved' });
+      assert.equal(saves, 1);
+      const saved = hosts.find((host) => host.hostname === 'synthetic.invalid')!;
+      assert.equal(saved.protocol, 'ssh'); assert.equal(saved.password, undefined); assert.equal(saved.startupCommand, undefined);
+    });
+
+    for (const change of ['remove', 'replace'] as const) await t.test(`${change} after selection prevents a stale edit`, async () => {
+      hosts = [first, second]; persisted = hosts.map((host) => structuredClone(host));
+      const run = await begin('edit'); await chooseGroup();
+      await waitFor(() => document.body.textContent?.includes('Changes to save') === true);
+      hosts = change === 'remove' ? [second] : [{ ...first }, second];
+      await click(button('Save Host'));
+      await assert.rejects(run.promise, /changed|cancelled|complete/);
+      assert.equal(saves, 1); assert.equal(connections.length, 0);
+    });
+
+    await t.test('connection confirmation discloses saved scripts before dispatch and returns no session', async () => {
+      hosts = [first, second]; persisted = hosts.map((host) => structuredClone(host));
+      const run = await begin('connect'); await chooseGroup();
+      await waitFor(() => document.body.textContent?.includes('Saved startup, connect or output scripts may run') === true);
+      assert.equal(connections.length, 0); assert.equal(document.body.textContent?.includes('synthetic-script'), false);
+      await click(button('Connect'));
+      assert.deepEqual(await run.promise, { cancelled: false, status: 'requested' });
+      assert.equal(connections.length, 1); assert.equal(connections[0], first);
+    });
+
+    await t.test('Vault lock cancels a pending connection', async () => {
+      const run = await begin('connect'); await chooseGroup();
+      await waitFor(() => button('Connect') !== undefined);
+      await act(async () => { locked = true; publish(); onLock?.({ locked: true }); await settle(); });
+      await assert.rejects(run.promise, /cancelled/); assert.equal(connections.length, 1);
+      locked = false; publish();
+    });
+
+    await t.test('revoke during asynchronous preparation prevents the write', async () => {
+      hosts = [first, second]; persisted = hosts.map((host) => structuredClone(host));
+      let release!: () => void; let preparing = false;
+      beforeCommit = async () => { preparing = true; await new Promise<void>((resolve) => { release = resolve; }); };
+      const run = await begin('edit'); await chooseGroup();
+      await waitFor(() => button('Save Host') !== undefined); await click(button('Save Host'));
+      await waitFor(() => preparing);
+      await act(async () => { service.permissionEngine.revokeApplication('com.netcatty.host-actions', 'vault.write'); release(); await settle(); });
+      await assert.rejects(run.promise, /revoked|cancelled/); assert.equal(saves, 1); beforeCommit = undefined;
+    });
+
+    await t.test('source replacement during review cannot use the old action authority', async () => {
+      const run = await begin('create');
+      const original = service.database.getRetainedPluginSource;
+      service.database.getRetainedPluginSource = () => ({ id: 'changed-source', kind: 'local', origin: null });
+      try { await click(button('Save Host')); await assert.rejects(run.promise, /source binding/); }
+      finally { service.database.getRetainedPluginSource = original; }
+      assert.equal(saves, 1); assert.equal(connections.length, 1);
+    });
+
+    await t.test('managed A to B stays in the Vault editor and cannot acquire file-write effects', async () => {
+      const candidate = sanitizeHost({ ...first, group: 'A', managedSourceId: 'synthetic-source-a' });
+      hosts = [candidate]; persisted = hosts.map((host) => structuredClone(host));
+      vault.managedSources = [
+        { id: 'synthetic-source-a', type: 'ssh_config', filePath: '/synthetic/a.conf', groupName: 'A', lastSyncedAt: 0 },
+        { id: 'synthetic-source-b', type: 'ssh_config', filePath: '/synthetic/b.conf', groupName: 'B', lastSyncedAt: 0 },
+      ];
+      const run = await begin('edit'); await chooseGroup();
+      await waitFor(() => button('Save Host') !== undefined);
+      const group = Array.from(document.querySelectorAll('label')).find((label) => label.querySelector('span')?.textContent === 'Group')?.querySelector('input');
+      assert.ok(group);
+      const setValue = Object.getOwnPropertyDescriptor(dom.window.HTMLInputElement.prototype, 'value')!.set!;
+      await act(async () => { setValue.call(group, 'B'); group.dispatchEvent(new dom.window.Event('input', { bubbles: true })); await settle(); });
+      assert.match(document.querySelector('[role="dialog"]')?.textContent ?? '', /"A"\s*\u2192\s*"B"/u);
+      assert.match(document.querySelector('[role="alert"]')?.textContent ?? '', /Managed SSH config changes require the Vault host editor/);
+      assert.equal(button('Save Host').disabled, true);
+      await click(button('Save Host')); assert.equal(saves, 1);
+      await click(button('Cancel')); assert.deepEqual(await run.promise, { cancelled: true });
+      assert.equal(hosts[0].group, 'A'); assert.equal(hosts[0].managedSourceId, 'synthetic-source-a');
+      vault.managedSources = [];
+    });
+
+    await t.test('creating into a managed group is explicitly unavailable in the small draft UI', async () => {
+      vault.managedSources = [{ id: 'synthetic-source-b', type: 'ssh_config', filePath: '/synthetic/b.conf', groupName: 'Samples', lastSyncedAt: 0 }];
+      const run = await begin('create');
+      assert.match(document.querySelector('[role="alert"]')?.textContent ?? '', /Managed SSH config changes require the Vault host editor/);
+      assert.equal(button('Save Host').disabled, true);
+      await click(button('Cancel')); assert.deepEqual(await run.promise, { cancelled: true });
+      assert.equal(saves, 1); vault.managedSources = [];
+    });
+
+    for (const transport of [
+      { name: 'Mosh', expected: 'mosh', overrides: { moshEnabled: true } },
+      { name: 'ET', expected: 'et', overrides: { etEnabled: true } },
+      { name: 'implicit localhost shell', expected: 'local', overrides: { hostname: 'localhost' } },
+    ] as const) await t.test(`${transport.name} confirmation matches the real connection handler`, async () => {
+      const candidate = sanitizeHost({ ...second, id: `synthetic-${transport.expected}`, label: `Synthetic ${transport.expected}`, ...transport.overrides });
+      hosts = [candidate]; persisted = hosts.map((host) => structuredClone(host));
+      const dispatched: Host[] = [];
+      const logs: Array<Pick<ConnectionLog, 'protocol'>> = [];
+      registerAppHandlers({ handleConnectToHost: (host: Host) => handleConnectToHostImpl(() => ({
+        resolveEffectiveHost: (saved: Host) => applyGroupDefaults(saved, saved.group ? resolveGroupDefaults(saved.group, vault.groupConfigs) : {}),
+        discoveredShells: [], terminalSettings: {}, resolveShellSetting: () => null,
+        systemInfoRef: { current: { username: 'synthetic-local-user', hostname: 'synthetic-device' } },
+        keys: [], identities: [], resolveHostAuth: () => ({ username: 'synthetic-user' }),
+        connectToHost: (resolved: Host) => { dispatched.push(resolved); return 'synthetic-transport-session'; },
+        addConnectionLog: (entry: Pick<ConnectionLog, 'protocol'>) => logs.push(entry),
+      }), host) });
+      const run = await begin('connect');
+      try {
+        await chooseGroup(); await waitFor(() => button('Connect') !== undefined);
+        const confirmation = document.querySelector('[role="dialog"]')?.textContent ?? '';
+        assert.match(confirmation, new RegExp(`\\(${transport.expected}\\)`));
+        assert.equal(confirmation.includes('Local execution: this opens a shell on this device.'), transport.expected === 'local');
+        if (transport.expected === 'local') assert.doesNotMatch(confirmation, /test@localhost:22/u);
+        assert.equal(dispatched.length, 0);
+        await click(button('Connect'));
+        assert.deepEqual(await run.promise, { cancelled: false, status: 'requested' });
+        assert.equal(dispatched.length, 1);
+        assert.equal(logs[0].protocol, transport.expected);
+      } finally {
+        if (button('Cancel')) await click(button('Cancel'));
+        await run.promise.catch(() => {});
+        registerAppHandlers({ handleConnectToHost: (host: Host) => { connections.push(host); return 'private-session-id'; } });
+      }
+    });
+
+    await t.test('runtime removal rejects old signed replies', async () => {
+      const run = await begin('create');
+      const old = prompts.at(-1)!;
+      await act(async () => { await service.manager.setEnabled('com.netcatty.host-actions', false); await settle(); });
+      await assert.rejects(run.promise);
+      assert.equal(await service.interactionService.respond(sender, { requestId: old.requestId, actionToken: old.actionToken, action: 'submit', draft: { hostname: 'late.invalid' } }), false);
+      assert.equal(saves, 1); assert.equal(connections.length, 1);
+    });
+  } finally {
+    await act(async () => { root.unmount(); await settle(); });
+    await service.manager.shutdown();
+    runtime.registerAppVaultRuntime(null); runtime.registerAppAppLockRuntime(null); registerAppHandlers(null);
+    dom.window.close(); await rm(directory, { recursive: true, force: true });
+    for (const [key, descriptor] of previous) { if (descriptor) Object.defineProperty(globalThis, key, descriptor); else Reflect.deleteProperty(globalThis, key); }
+  }
+});

components/PluginHostDraftPreview.test.tsx

@@ -0,0 +1,38 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import React from 'react';
+import { I18nProvider } from '../application/i18n/I18nProvider';
+import { PluginHostDraftPreview } from './plugins/PluginHostDraftPreview';
+import { createDomRenderer, dispatchDomEvent, installDomEnvironment } from './test-support/renderReactDom';
+import type { Host } from '../domain/models';
+import type { PluginHostDraftFields } from '../domain/pluginHostActions';
+
+test('host-owned draft preview shows a field diff and submits only reviewed editable fields', async () => {
+  const dom = installDomEnvironment();
+  const renderer = await createDomRenderer(dom.document);
+  const host: Host = { id: 'synthetic', label: 'Before', hostname: 'host.invalid', username: 'test', tags: [], os: 'linux', password: 'synthetic-password', startupCommand: 'synthetic-script' };
+  const submitted: PluginHostDraftFields[] = [];
+  try {
+    await renderer.render(<I18nProvider locale="en"><PluginHostDraftPreview before={host} draft={{ label: 'After' }} busy={false} onConfirm={(draft) => submitted.push(draft)} /></I18nProvider>);
+    assert.equal(dom.document.querySelectorAll('input').length, 3);
+    assert.match(renderer.container.textContent ?? '', /Before.*After/u);
+    assert.equal(renderer.container.innerHTML.includes('synthetic-password'), false);
+    assert.equal(renderer.container.innerHTML.includes('synthetic-script'), false);
+    const save = dom.document.querySelector('button');
+    assert.ok(save);
+    await dispatchDomEvent(save, new dom.window.MouseEvent('click', { bubbles: true }));
+    assert.deepEqual(submitted, [{ label: 'After', group: '', tags: [] }]);
+  } finally { await renderer.unmount(); dom.cleanup(); }
+});
+
+test('invalid create draft cannot be confirmed', async () => {
+  const dom = installDomEnvironment();
+  const renderer = await createDomRenderer(dom.document);
+  try {
+    await renderer.render(<I18nProvider locale="en"><PluginHostDraftPreview draft={{ hostname: 'invalid host' }} busy={false} onConfirm={() => { throw new Error('Invalid draft was submitted'); }} /></I18nProvider>);
+    assert.ok(dom.document.querySelector('[role="alert"]'));
+    const save = dom.document.querySelector('button');
+    assert.ok(save?.disabled);
+    await dispatchDomEvent(save, new dom.window.MouseEvent('click', { bubbles: true }));
+  } finally { await renderer.unmount(); dom.cleanup(); }
+});

components/PluginHostInteractionHost.test.tsx

@@ -0,0 +1,91 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { EventEmitter } from 'node:events';
+import { JSDOM } from 'jsdom';
+
+test('host dialog drives choice/input/copy and the two-phase clipboard share using real service action tokens', async () => {
+  const dom = new JSDOM('<!doctype html><html><body><div id="root"></div></body></html>', { pretendToBeVisual: true, url: 'http://localhost' });
+  const previous = new Map<string, PropertyDescriptor | undefined>();
+  const install = (key: string, value: unknown) => {
+    previous.set(key, Object.getOwnPropertyDescriptor(globalThis, key));
+    Object.defineProperty(globalThis, key, { configurable: true, writable: true, value });
+  };
+  for (const key of ['window', 'document', 'navigator', 'HTMLElement', 'HTMLInputElement', 'Element', 'Node', 'NodeFilter', 'MutationObserver', 'CustomEvent', 'Event', 'KeyboardEvent', 'MouseEvent']) {
+    install(key, key === 'window' ? dom.window : dom.window[key as keyof typeof dom.window]);
+  }
+  install('getComputedStyle', dom.window.getComputedStyle.bind(dom.window));
+  install('requestAnimationFrame', dom.window.requestAnimationFrame.bind(dom.window));
+  install('cancelAnimationFrame', dom.window.cancelAnimationFrame.bind(dom.window));
+  install('IS_REACT_ACT_ENVIRONMENT', true);
+  const { default: React, act } = await import('react');
+  const { createRoot } = await import('react-dom/client');
+  const { I18nProvider } = await import('../application/i18n/I18nProvider');
+  const { PluginHostInteractionHost } = await import('./plugins/PluginHostInteractionHost');
+  const { PluginHostInteractionService, assertInteractionRequest } = await import('../electron/plugins/hostInteractionService.cjs');
+  let listener: ((event: unknown) => void) | null = null;
+  let reads = 0;
+  const writes: string[] = [];
+  const audits: unknown[] = [];
+  const sender = Object.assign(new EventEmitter(), { id: 7, isDestroyed: () => false, send(_channel: string, payload: unknown) { listener?.(payload); } });
+  const owner = Object.assign(new EventEmitter(), { webContents: sender, isFocused: () => true, isVisible: () => true, isDestroyed: () => false });
+  const service = new PluginHostInteractionService({
+    getWindow: () => owner, isLocked: () => false,
+    permissionEngine: { onDidRevoke() { return { dispose() {} }; } },
+    database: { recordSecurityAudit(...args: unknown[]) { audits.push(args); } },
+    quotaManager: { chargeBytes() {} },
+    clipboard: { readText() { reads++; return 'synthetic private text'; }, writeText(value: string) { writes.push(value); } },
+  });
+  Object.assign(dom.window, { netcatty: {
+    onPluginInteraction(callback: (event: unknown) => void) { listener = callback; return () => { listener = null; }; },
+    async setPluginInteractionReady(ready: boolean) { return service.setReady(sender, ready); },
+    async respondPluginInteraction(response: unknown) { return service.respond(sender, response); },
+  } });
+  const context = { pluginId: 'com.example.synthetic', pluginVersion: '1.0.0', runtimeId: 'runtime-synthetic', signal: new AbortController().signal, async assertActive() {} };
+  const root = createRoot(document.getElementById('root')!);
+  const settle = () => new Promise((resolve) => setTimeout(resolve, 20));
+  const button = (text: string) => Array.from(document.querySelectorAll<HTMLButtonElement>('button')).find((item) => item.textContent === text)!;
+  const click = async (element: HTMLElement) => { assert.ok(element); await act(async () => { element.click(); await settle(); }); };
+  const begin = async (params: unknown) => {
+    let promise!: Promise<unknown>;
+    await act(async () => { promise = service.request(assertInteractionRequest(params), context); void promise.catch(() => {}); await settle(); });
+    return { promise };
+  };
+  try {
+    await act(async () => root.render(<I18nProvider locale="en"><PluginHostInteractionHost /></I18nProvider>));
+    const choice = await begin({ kind: 'quickPick', title: 'Synthetic choice', items: [{ id: 'compose', label: 'Compose' }] });
+    assert.match(document.querySelector('[role="dialog"]')?.textContent ?? '', /com.example.synthetic/);
+    assert.equal(button('Continue').disabled, true);
+    await click(document.querySelector<HTMLInputElement>('input[type="radio"]')!);
+    await click(button('Continue'));
+    assert.deepEqual(await choice.promise, { cancelled: false, value: 'compose' });
+    await assert.rejects(begin({ kind: 'input', title: 'Invalid hidden newline', initialValue: 'first\nsecond' }), /invalid/);
+    assert.equal(document.querySelector('[role="dialog"]'), null, 'invalid initial text never creates a misleading single-line dialog');
+    const input = await begin({ kind: 'input', title: 'Synthetic input', initialValue: 'synthetic output' });
+    assert.equal(document.querySelector<HTMLInputElement>('input')?.value, 'synthetic output');
+    await click(button('Continue'));
+    assert.deepEqual(await input.promise, { cancelled: false, value: 'synthetic output' });
+    const copy = await begin({ kind: 'clipboard.write', title: 'Copy result', text: 'synthetic output' });
+    assert.deepEqual(writes, []);
+    assert.equal(document.querySelector('textarea')?.value, 'synthetic output');
+    await click(button('Copy to clipboard'));
+    assert.deepEqual(await copy.promise, { cancelled: false, value: true });
+    assert.deepEqual(writes, ['synthetic output']);
+    const share = await begin({ kind: 'clipboard.read', title: 'Share clipboard' });
+    assert.equal(reads, 0);
+    assert.equal(document.querySelector('textarea'), null);
+    await click(button('Preview clipboard'));
+    assert.equal(reads, 1);
+    assert.equal(document.querySelector('textarea')?.value, 'synthetic private text');
+    await click(button('Share with plugin'));
+    assert.deepEqual(await share.promise, { cancelled: false, value: 'synthetic private text' });
+    assert.equal(JSON.stringify(audits).includes('synthetic private text'), false);
+    const cancelled = await begin({ kind: 'clipboard.write', title: 'Cancelled copy', text: 'must not copy' });
+    await click(button('Cancel'));
+    assert.deepEqual(await cancelled.promise, { cancelled: true });
+    assert.deepEqual(writes, ['synthetic output']);
+    assert.equal(service.pending.size, 0);
+  } finally {
+    await act(async () => { root.unmount(); await settle(); }); service.shutdown(); dom.window.close();
+    for (const [key, descriptor] of previous) { if (descriptor) Object.defineProperty(globalThis, key, descriptor); else Reflect.deleteProperty(globalThis, key); }
+  }
+});

components/PluginTerminalSidebar.test.tsx

@@ -0,0 +1,128 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { JSDOM } from 'jsdom';
+
+test('terminal extension pages use actual split panes, focus and session ownership without sharing session data', async () => {
+  const dom = new JSDOM('<!doctype html><html><body><div id="root"></div></body></html>', { pretendToBeVisual: true, url: 'http://localhost' });
+  const previous = new Map<string, PropertyDescriptor | undefined>();
+  const install = (key: string, value: unknown) => {
+    previous.set(key, Object.getOwnPropertyDescriptor(globalThis, key)); Object.defineProperty(globalThis, key, { configurable: true, writable: true, value });
+  };
+  for (const key of ['window', 'document', 'navigator', 'HTMLElement', 'HTMLInputElement', 'Element', 'SVGElement', 'Node', 'NodeFilter', 'MutationObserver', 'CustomEvent', 'Event', 'KeyboardEvent', 'MouseEvent']) {
+    install(key, key === 'window' ? dom.window : dom.window[key as keyof typeof dom.window]);
+  }
+  install('PointerEvent', dom.window.MouseEvent);
+  install('getComputedStyle', dom.window.getComputedStyle.bind(dom.window));
+  install('requestAnimationFrame', dom.window.requestAnimationFrame.bind(dom.window)); install('cancelAnimationFrame', dom.window.cancelAnimationFrame.bind(dom.window)); install('IS_REACT_ACT_ENVIRONMENT', true);
+  let rectX = 200;
+  dom.window.HTMLElement.prototype.getBoundingClientRect = () => new dom.window.DOMRect(rectX, 100, 400, 300);
+  const { default: React, act, useCallback, useRef, useState } = await import('react');
+  const { createRoot } = await import('react-dom/client');
+  const { I18nProvider } = await import('../application/i18n/I18nProvider');
+  const { activeTabStore } = await import('../application/state/activeTabStore');
+  const { sidePanelLiveStore, SIDE_PANEL_INACTIVE_LIVE_SNAPSHOT } = await import('../application/state/sidePanelLiveStore');
+  const { useTerminalSidePanelLayoutState } = await import('../application/state/useTerminalSidePanelLayoutState');
+  const { usePluginTerminalSidebar } = await import('../application/state/usePluginTerminalSidebar');
+  const { PluginTerminalSidebarLauncher, PluginTerminalSidebarPageHost } = await import('./plugins/PluginTerminalSidebar');
+  const { SidePanelLayoutTree } = await import('./terminalLayer/TerminalLayerSidePanelSection');
+  const { PersistentSidePanelPortal } = await import('./terminalLayer/terminalLayerSidePanelSlots');
+  const { collectSidePanelPanes } = await import('../domain/sidePanelLayout');
+  type Tool = import('../domain/sidePanelLayout').SidePanelTool;
+  let selectedSession = 'synthetic-session-a';
+  const getSession = () => selectedSession;
+  const a = { id: 'com.example.sidebar.first', title: 'First page', location: 'terminal-sidebar', entry: 'page.html', visible: true };
+  const b = { ...a, id: 'com.example.sidebar.second', title: 'Second page' };
+  let snapshot = { locale: 'en', plugins: [{ id: 'com.example.sidebar', displayName: 'Synthetic plugin', version: '1.0.0', commands: [], keybindings: [], menus: [], settings: [], views: [a, b] }] };
+  const changed = new Set<() => void>(), focusListeners = new Set<(event: { instanceId: string }) => void>();
+  const opens: NetcattyPluginViewOpenRequest[] = [], closes: string[] = [], focus: string[] = [], bounds: Array<{ instanceId: string; x: number }> = [];
+  const visible = new Map<string, boolean>();
+  Object.assign(dom.window, { netcatty: {
+    async getPluginRuntimeStatus() { return { available: true }; }, async getPluginContributions() { return snapshot; },
+    onPluginContributionsChanged(fn: () => void) { changed.add(fn); return () => { changed.delete(fn); }; },
+    onPluginViewClosed() { return () => {}; },
+    onPluginViewFocused(fn: (event: { instanceId: string }) => void) { focusListeners.add(fn); return () => { focusListeners.delete(fn); }; },
+    async openPluginView(payload: NetcattyPluginViewOpenRequest) { opens.push(payload); return { instanceId: payload.instanceId! }; },
+    async closePluginView(id: string) { closes.push(id); },
+    async setPluginViewBounds(id: string, rect: { x: number }) { bounds.push({ instanceId: id, x: rect.x }); },
+    async setPluginViewVisibility(id: string, value: boolean) { visible.set(id, value); },
+    async focusPluginView(event: { instanceId: string }) { focus.push(event.instanceId); for (const fn of focusListeners) fn(event); },
+  } });
+  let split!: () => void;
+  function Fixture() {
+    const state = useTerminalSidePanelLayoutState(); const latest = useRef(state); latest.current = state;
+    const model = usePluginTerminalSidebar({ layouts: state.sidePanelLayouts, getSession, isTerminalTab: (id) => id === 'workspace-synthetic' || id === 'synthetic-local-terminal',
+      select: (tool) => state.selectSidePanelToolForTab(activeTabStore.getActiveTabId(), tool),
+      withdraw: (tabId, paneId, tool) => {
+        const layout = state.sidePanelLayoutsRef.current.get(tabId);
+        if (layout && collectSidePanelPanes(layout.root).some((pane) => pane.id === paneId && pane.tool === tool)) state.closePane(tabId, paneId);
+      } });
+    const [hosts, setHosts] = useState(new Map<Tool, HTMLElement>()); const parking = useRef<HTMLDivElement>(null);
+    const register = useCallback((tool: Tool, host: HTMLElement | null) => setHosts((prior) => {
+      if ((prior.get(tool) ?? null) === host) return prior;
+      const next = new Map(prior); if (host) next.set(tool, host); else next.delete(tool); return next;
+    }), []);
+    const focusPane = useCallback((id: string) => latest.current.focusPane(activeTabStore.getActiveTabId(), id), []);
+    const closePane = useCallback((id: string) => { latest.current.closePane(activeTabStore.getActiveTabId(), id); }, []);
+    const resize = useCallback(() => {}, []);
+    const layout = model.tabId ? state.sidePanelLayouts.get(model.tabId) : null;
+    const panes = layout ? collectSidePanelPanes(layout.root) : [];
+    split = () => state.splitPane('workspace-synthetic', `plugin-view:${b.id}`, 'vertical', { paneId: 'second-pane', splitId: 'plugin-split' }, 600);
+    return <><PluginTerminalSidebarLauncher sessionId={selectedSession} />
+      {layout && <SidePanelLayoutTree node={layout.root} layout={layout} paneCount={panes.length} labels={new Map(model.pages.map((page) => [page.tool, page.title]))}
+        onClose={closePane} onFocus={focusPane} onHostChange={register} onResize={resize} separator="#777" accent="#4488cc" closePaneLabel="Close pane" resizeLabel="Resize" />}
+      <div ref={parking} hidden aria-hidden="true" />
+      {model.sessionId && panes.map((pane) => {
+        const page = model.pages.find((item) => item.tool === pane.tool); const target = hosts.get(pane.tool) ?? parking.current;
+        if (!page || !target) return null;
+        return <PersistentSidePanelPortal key={`${pane.id}:${model.sessionId}`} portalKey={`plugin-${pane.id}`} target={target}>
+          <PluginTerminalSidebarPageHost page={page} tabId={model.tabId!} sessionId={model.sessionId} getSession={getSession} adapter={model.contributions}
+            focusOnReveal={layout?.focusedPaneId === pane.id} focused={() => focusPane(pane.id)} unavailable={() => closePane(pane.id)} />
+        </PersistentSidePanelPortal>;
+      })}</>;
+  }
+  const root = createRoot(document.getElementById('root')!); const settle = () => new Promise((resolve) => setTimeout(resolve, 40));
+  try {
+    activeTabStore.setActiveTabId('workspace-synthetic'); sidePanelLiveStore.update({ ...SIDE_PANEL_INACTIVE_LIVE_SNAPSHOT, focusedSessionId: selectedSession });
+    await act(async () => { root.render(<I18nProvider locale="en"><Fixture /></I18nProvider>); await settle(); });
+    await act(async () => { document.querySelector<HTMLButtonElement>('button[aria-label="Extension pages"]')!.click(); await settle(); });
+    const firstButton = [...document.querySelectorAll('button')].find((button) => button.textContent?.includes('First page'))!;
+    await act(async () => { firstButton.click(); await settle(); });
+    assert.equal(document.querySelectorAll('[data-section="terminal-side-panel-pane"]').length, 1);
+    assert.ok(document.querySelector('[data-pane-tool] [data-plugin-view-slot="terminal-sidebar"]'));
+    assert.equal(opens.length, 1); assert.deepEqual(opens[0].context, { 'netcatty.surface': 'terminal-sidebar' });
+    await act(async () => { split(); await settle(); });
+    assert.equal(document.querySelectorAll('[data-section="terminal-side-panel-pane"]').length, 2);
+    assert.equal(opens.length, 2);
+    const firstId = opens.find((item) => item.viewId === a.id)!.instanceId!;
+    await act(async () => { for (const fn of focusListeners) fn({ instanceId: firstId }); await settle(); });
+    assert.equal(document.querySelector(`[data-pane-tool="plugin-view:${a.id}"]`)?.getAttribute('data-focused'), 'true');
+    const dialog = document.createElement('div'); dialog.setAttribute('role', 'dialog'); dialog.setAttribute('aria-modal', 'true');
+    await act(async () => { document.body.append(dialog); await settle(); });
+    assert.ok(opens.every((item) => visible.get(item.instanceId!) === false));
+    focus.length = 0;
+    await act(async () => { dialog.remove(); await settle(); });
+    assert.ok(focus.length > 0); assert.ok(focus.every((id) => id === firstId), 'restoring panes focuses only the host-selected pane');
+    const old = opens.map((item) => item.instanceId!);
+    await act(async () => { selectedSession = 'synthetic-session-b'; sidePanelLiveStore.update({ ...SIDE_PANEL_INACTIVE_LIVE_SNAPSHOT, focusedSessionId: selectedSession });
+      assert.ok(old.every((id) => closes.includes(id)), 'workspace focus cancels old native owners synchronously'); await settle(); });
+    assert.equal(opens.length, 4);
+    assert.notEqual(opens[0].scopeId, opens[2].scopeId);
+    assert.ok(opens.every((item) => JSON.stringify(item.context) === JSON.stringify({ 'netcatty.surface': 'terminal-sidebar' })));
+    await act(async () => { rectX = 260; snapshot = { ...snapshot, plugins: [{ ...snapshot.plugins[0], views: [{ ...a, visible: false }, b] }] }; for (const fn of changed) fn(); await settle(); });
+    assert.equal(document.querySelectorAll('[data-section="terminal-side-panel-pane"]').length, 1);
+    assert.equal(document.querySelector('[data-pane-tool]')?.getAttribute('data-pane-tool'), `plugin-view:${b.id}`);
+    assert.ok(bounds.some((item) => item.x === 260), 'portal relocation updates native geometry');
+    const last = opens.at(-1)!.instanceId!;
+    await act(async () => { activeTabStore.setActiveTabId('vault'); assert.ok(closes.includes(last)); await settle(); });
+    assert.equal(document.querySelector('[data-plugin-terminal-sidebar]'), null);
+    await act(async () => { selectedSession = 'synthetic-local-terminal'; activeTabStore.setActiveTabId(selectedSession); await settle(); });
+    await act(async () => { document.querySelector<HTMLButtonElement>('button[aria-label="Extension pages"]')!.click(); await settle(); });
+    const localPage = [...document.querySelectorAll('button')].find((button) => button.textContent?.includes('Second page'))!;
+    await act(async () => { localPage.click(); await settle(); });
+    assert.ok(document.querySelector('[data-plugin-view-slot="terminal-sidebar"]'), 'standalone Local Terminal is a valid navigation owner');
+    assert.deepEqual(opens.at(-1)!.context, { 'netcatty.surface': 'terminal-sidebar' });
+  } finally {
+    await act(async () => { root.unmount(); await settle(); }); dom.window.close();
+    for (const [key, descriptor] of previous) { if (descriptor) Object.defineProperty(globalThis, key, descriptor); else Reflect.deleteProperty(globalThis, key); }
+  }
+});

components/PluginVaultPages.test.tsx

@@ -0,0 +1,101 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { JSDOM } from 'jsdom';
+
+test('Vault navigation mounts a real content slot, yields to host dialogs, and withdraws stale pages', async () => {
+  const dom = new JSDOM('<!doctype html><html><body><div id="root"></div></body></html>', { pretendToBeVisual: true, url: 'http://localhost' });
+  const previous = new Map<string, PropertyDescriptor | undefined>();
+  for (const key of ['window', 'document', 'navigator', 'HTMLElement', 'Element', 'Node', 'MutationObserver', 'CustomEvent', 'Event']) {
+    previous.set(key, Object.getOwnPropertyDescriptor(globalThis, key));
+    Object.defineProperty(globalThis, key, { configurable: true, writable: true, value: key === 'window' ? dom.window : dom.window[key as keyof Window] });
+  }
+  for (const [key, value] of Object.entries({ getComputedStyle: dom.window.getComputedStyle.bind(dom.window),
+    requestAnimationFrame: dom.window.requestAnimationFrame.bind(dom.window), cancelAnimationFrame: dom.window.cancelAnimationFrame.bind(dom.window), IS_REACT_ACT_ENVIRONMENT: true })) {
+    previous.set(key, Object.getOwnPropertyDescriptor(globalThis, key)); Object.defineProperty(globalThis, key, { configurable: true, writable: true, value });
+  }
+  dom.window.HTMLElement.prototype.getBoundingClientRect = () => ({ x: 200, y: 100, width: 640, height: 480, top: 100, left: 200, right: 840, bottom: 580, toJSON() {} });
+  const { default: React, act, useState } = await import('react');
+  const { createRoot } = await import('react-dom/client');
+  const { usePluginVaultPages } = await import('../application/state/usePluginVaultPages');
+  const { PluginVaultNavigation, PluginVaultPage } = await import('./plugins/PluginVaultPages');
+  const { activeTabStore } = await import('../application/state/activeTabStore');
+  const { requestOpenPluginView } = await import('../application/state/usePluginViewLifecycle');
+  const { I18nProvider } = await import('../application/i18n/I18nProvider');
+  const page = { id: 'com.example.page.main', title: 'Synthetic page', location: 'vault-page', entry: 'page.html', visible: true };
+  let snapshot = { locale: 'en', plugins: [{ id: 'com.example.page', version: '1.0.0', displayName: 'Synthetic plugin', commands: [], keybindings: [], menus: [], settings: [], views: [page] }] };
+  let changed: (() => void) | undefined;
+  const listeners = new Set<(event: NetcattyPluginViewClosedEvent) => void>();
+  const opens: NetcattyPluginViewOpenRequest[] = [], closes: string[] = [], visibility: boolean[] = [];
+  let defer: ((value: { instanceId: string }) => void) | undefined;
+  let deferOpen = false;
+  let delayLayout = false;
+  const rejectOldLayout: Array<(error: Error) => void> = [];
+  const layoutResult = () => delayLayout ? new Promise<void>((_resolve, reject) => { rejectOldLayout.push(reject); }) : Promise.resolve();
+  Object.assign(dom.window, { netcatty: {
+    async getPluginRuntimeStatus() { return { available: true }; },
+    async getPluginContributions() { return snapshot; },
+    onPluginContributionsChanged(fn: () => void) { changed = fn; return () => { changed = undefined; }; },
+    onPluginViewClosed(fn: (event: NetcattyPluginViewClosedEvent) => void) { listeners.add(fn); return () => { listeners.delete(fn); }; },
+    async openPluginView(payload: NetcattyPluginViewOpenRequest) { opens.push(payload); return deferOpen ? new Promise<{ instanceId: string }>((resolve) => { defer = resolve; }) : { instanceId: payload.instanceId! }; },
+    async closePluginView(id: string) { closes.push(id); }, async setPluginViewBounds() { await layoutResult(); },
+    async setPluginViewVisibility(_id: string, visible: boolean) { visibility.push(visible); await layoutResult(); },
+  } });
+  let selectSection!: (section: 'hosts' | `plugin-vault:${string}`) => void;
+  function Fixture() {
+    const [section, select] = useState<'hosts' | `plugin-vault:${string}`>('hosts'); selectSection = select;
+    const model = usePluginVaultPages({ locale: 'en', section, select });
+    return <><aside><button data-plugin-vault-fallback onClick={() => select('hosts')}>Hosts</button><PluginVaultNavigation model={model} collapsed={false} /></aside>
+      <main data-section="vault-main">{model.selected ? <PluginVaultPage key={model.selected.key} model={model} /> : <p>Built-in hosts</p>}</main></>;
+  }
+  const root = createRoot(document.getElementById('root')!);
+  const settle = () => new Promise((resolve) => setTimeout(resolve, 35));
+  const clickPage = async () => { await act(async () => { document.querySelector<HTMLButtonElement>('button[aria-label="Synthetic page — Synthetic plugin"]')!.click(); await settle(); }); };
+  try {
+    activeTabStore.setActiveTabId('vault');
+    await act(async () => { root.render(<I18nProvider locale="en"><Fixture /></I18nProvider>); await settle(); });
+    assert.equal(opens.length, 0, 'catalog enumeration does not activate the plugin');
+    await clickPage();
+    assert.ok(document.querySelector('[data-section="vault-main"] [data-plugin-view-slot="vault-page"]'));
+    assert.equal(opens.length, 1);
+    assert.deepEqual(opens[0].context, { 'netcatty.surface': 'vault-page' }, 'no Vault/session data accompanies navigation');
+    assert.equal(visibility.at(-1), true);
+    const dialog = document.createElement('div'); dialog.setAttribute('role', 'dialog'); dialog.setAttribute('aria-modal', 'true');
+    await act(async () => { document.body.append(dialog); await settle(); });
+    assert.equal(visibility.at(-1), false, 'native content yields to host security/settings dialogs');
+    await act(async () => { dialog.remove(); await settle(); });
+    assert.equal(visibility.at(-1), true);
+    await act(async () => { activeTabStore.setActiveTabId('terminal:synthetic'); assert.ok(closes.includes(opens[0].instanceId!)); await settle(); });
+    await act(async () => { activeTabStore.setActiveTabId('vault'); await settle(); });
+    assert.equal(opens.length, 2);
+    await act(async () => { snapshot = { ...snapshot, plugins: [] }; changed?.(); await settle(); });
+    await act(async () => { await settle(); });
+    assert.ok(closes.includes(opens[1].instanceId!));
+    assert.equal(document.querySelector('[data-plugin-vault-page]'), null);
+    assert.equal(document.activeElement?.textContent, 'Hosts');
+    await act(async () => { selectSection('plugin-vault:missing'); await settle(); });
+    assert.match(document.querySelector('main')!.textContent!, /Built-in hosts/);
+    await act(async () => { snapshot = { ...snapshot, plugins: [{ id: 'com.example.page', version: '1.0.0', displayName: 'Synthetic plugin', commands: [], keybindings: [], menus: [], settings: [], views: [page] }] }; changed?.(); await settle(); });
+    deferOpen = true;
+    await act(async () => { requestOpenPluginView({ viewId: page.id }); await settle(); });
+    assert.equal(opens.length, 3);
+    await act(async () => { selectSection('hosts'); await settle(); });
+    assert.ok(closes.includes(opens[2].instanceId!), 'cancel reserved instance before its open response');
+    await act(async () => { defer!({ instanceId: opens[2].instanceId! }); await settle(); });
+    assert.equal(document.querySelector('[data-plugin-vault-page]'), null, 'late open cannot restore withdrawn page');
+    assert.ok(closes.filter((id) => id === opens[2].instanceId).length >= 2, 'late native response is also closed');
+    deferOpen = false;
+    const second = { ...page, id: 'com.example.page.second', title: 'Second page' };
+    await act(async () => { snapshot = { ...snapshot, plugins: [{ ...snapshot.plugins[0], views: [page, second] }] }; changed?.(); await settle(); });
+    delayLayout = true;
+    await clickPage();
+    assert.ok(rejectOldLayout.length >= 2, 'old page has both bounds and visibility IPC in flight');
+    await act(async () => { selectSection('hosts'); await settle(); });
+    delayLayout = false;
+    await act(async () => { document.querySelector<HTMLButtonElement>('button[aria-label="Second page — Synthetic plugin"]')!.click(); await settle(); });
+    await act(async () => { for (const reject of rejectOldLayout) reject(new Error('old page layout failed')); await settle(); });
+    assert.equal(document.querySelector('[data-plugin-vault-page]')?.getAttribute('aria-label'), 'Second page', 'old bounds/visibility failures cannot withdraw the newly selected page');
+  } finally {
+    await act(async () => { root.unmount(); await settle(); }); dom.window.close();
+    for (const [key, descriptor] of previous) { if (descriptor) Object.defineProperty(globalThis, key, descriptor); else Reflect.deleteProperty(globalThis, key); }
+  }
+});

components/QuickSwitcher.pluginContributions.test.tsx

@@ -151,3 +151,24 @@ test('plugin palette items keep repeated placements independently addressable',
     commandId: 'com.example.palette.run',
   }]);
 });
+
+test('packaged Starter contributions are discoverable through the real palette builder', async (context) => {
+  const { createRequire } = await import('node:module');
+  const { mkdtempSync, rmSync } = await import('node:fs');
+  const { tmpdir } = await import('node:os');
+  const { join } = await import('node:path');
+  const require = createRequire(import.meta.url);
+  const { PluginDatabase } = require('../electron/plugins/database.cjs');
+  const { PluginContributionService } = require('../electron/plugins/contributionService.cjs');
+  const manifest = JSON.parse(readFileSync(new URL('../examples/plugins/starter-netcatty/netcatty.plugin.json', import.meta.url), 'utf8'));
+  const root = mkdtempSync(join(tmpdir(), 'starter-palette-'));
+  const database = new PluginDatabase(join(root, 'plugins.sqlite'));
+  context.after(() => { database.close(); rmSync(root, { recursive: true, force: true }); });
+  database.installVersion({ pluginId: manifest.id, version: manifest.version, manifest, archiveSha256: 'a'.repeat(64), packageRelativePath: 'starter' }, { enable: true });
+  const service = new PluginContributionService({ database, runtimeSupervisor: {}, secretStore: {}, getLocale: () => 'en' });
+  const items = buildPluginPaletteItems(service.snapshot().plugins, 'Starter');
+  assert.ok(items.some((item) => item.type === 'plugin-command' && item.commandId === 'com.netcatty.starter.greet'));
+  assert.ok(items.some((item) => item.type === 'plugin-view' && item.id === 'com.netcatty.starter.panel'));
+  database.setEnabled(manifest.id, false);
+  assert.equal(buildPluginPaletteItems(service.snapshot().plugins, 'Starter').length, 0);
+});

components/SelectHostPanelContent.tsx

@@ -50,6 +50,7 @@ export interface SelectHostPanelContentProps {
   /** Preferred multi-select path for host/group toggles (selection resolves to host ids). */
   onSelectionChange?: (selectedHostIds: string[]) => void;
   onConfirm: () => void;
+  confirmDisabled?: boolean;
   onNewHost?: () => void;
   availableKeys?: SSHKey[];
   identities?: import('../domain/models').Identity[];
@@ -79,6 +80,7 @@ export const SelectHostPanelContent: React.FC<SelectHostPanelContentProps> = ({
   onSelect,
   onSelectionChange,
   onConfirm,
+  confirmDisabled = false,
   onNewHost,
   availableKeys = [],
   identities = [],
@@ -643,7 +645,7 @@ export const SelectHostPanelContent: React.FC<SelectHostPanelContentProps> = ({
         <div className="px-4 py-3 border-t border-border/60 shrink-0">
           <Button
             className="w-full"
-            disabled={selectedHostIds.length === 0}
+            disabled={confirmDisabled || selectedHostIds.length === 0}
             onClick={onConfirm}
           >
             {multiSelect

components/SerialConnectModal.tsx

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

components/SerialHostDetailsPanel.test.tsx

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

components/SerialHostDetailsPanel.tsx

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

components/SettingsPage.tsx

@@ -1,3 +1,5 @@
+import { useAppThemeStyle } from "../application/app/useAppThemeStyle";
+import { selectPluginThemeTokens } from "../application/state/pluginContributionEnvironment";
 /**
  * Settings Page - Standalone settings window content
  * This component is rendered in a separate Electron window
@@ -322,6 +324,9 @@ const SettingsSyncTabWithVault: React.FC<{ onSettingsApplied?: () => void }> = (
 };
 
 const SettingsPageContent: React.FC<{ settings: SettingsState; appLock?: AppLockState }> = ({ settings, appLock }) => {
+    // This publisher also runs in detached Settings: never broadcast a local preview.
+    const committedAppThemeStyle = useAppThemeStyle(false);
+    const pluginThemeTokens = useMemo(() => selectPluginThemeTokens(committedAppThemeStyle as Record<string, unknown>), [committedAppThemeStyle]);
     const { t } = useI18n();
     const { request, clearFocus, openSearch } = useSettingsFocus();
     const { notifyRendererReady, closeSettingsWindow, onWindowCommandCloseRequested } = useWindowControls();
@@ -523,7 +528,8 @@ const SettingsPageContent: React.FC<{ settings: SettingsState; appLock?: AppLock
                     </TabsList>
                 </div>
 
-                <div className="flex-1 h-full flex flex-col min-h-0 bg-muted/10">
+                {/* min-w-0: row flex item must shrink so long Agent paths truncate inside the pane. */}
+                <div className="flex-1 h-full flex flex-col min-h-0 min-w-0 bg-muted/10">
                     {mountedTabs.has("application") && (
                         <SettingsLazyTab value="application">
                             <LazySettingsApplicationTab
@@ -714,7 +720,7 @@ const SettingsPageContent: React.FC<{ settings: SettingsState; appLock?: AppLock
             </Tabs>
         </div>
         <ExternalMcpApprovalsHost />
-        <PluginContributionHost locale={settings.uiLanguage} theme={settings.resolvedTheme} />
+        <PluginContributionHost locale={settings.uiLanguage} theme={settings.resolvedTheme} themeTokens={pluginThemeTokens} />
         </>
     );
 };

components/SftpSidePanel.tsx

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

components/SftpTransferItem.test.tsx

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

components/SftpView.tsx

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

components/Terminal.tsx

@@ -243,6 +243,7 @@ import {
 import {
   canHibernateTerminalRuntimeSession,
   canHibernateTerminalRuntimeStatus,
+  decideHiddenTabKeepCountAction,
   isTerminalFileTransferActive,
   resolveHibernateKeepRendererCount,
   resolveHibernatePreferWasmSerialize,
@@ -254,6 +255,7 @@ import {
 } from "../domain/terminalHibernate";
 import { getLastChar, removeLastChar } from "../domain/serialCharMetrics";
 import { stringCellWidth } from "./terminal/autocomplete/terminalStringCellWidth";
+import { retainLeavingTabAfterEviction } from "../application/state/hiddenTabEviction";
 import { terminalHiddenRendererStore } from "../application/state/terminalHiddenRendererStore";
 import {
   wakeTerminalFromHibernate,
@@ -522,6 +524,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
   const hibernateAlternateScreenRef = useRef(false);
   const hibernateRetryTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const fullHibernateRuntimeRef = useRef<(() => Promise<boolean>) | null>(null);
+  const hibernateEvictionAttemptRef = useRef(0);
   const wakeSoftHiddenRuntimeRef = useRef<(() => void) | null>(null);
   const resumeRendererAfterCancelledHibernateUpgradeRef = useRef<(() => void) | null>(null);
   const wakeInProgressRef = useRef(false);
@@ -2297,20 +2300,6 @@ const TerminalComponent: React.FC<TerminalProps> = ({
   ]);
   fullHibernateRuntimeRef.current = fullHibernateRuntime;
 
-  const upgradeSoftHiddenRuntimeToHibernate = useCallback(() => {
-    if (!wakeSoftHiddenRuntimeRef.current) return;
-    wakeSoftHiddenRuntimeRef.current?.();
-    void fullHibernateRuntime().then(
-      (completed) => {
-        if (!completed) resumeRendererAfterCancelledHibernateUpgradeRef.current?.();
-      },
-      (error) => {
-        logger.error("[Terminal] Failed to upgrade soft-hidden runtime to hibernate", { sessionId, error });
-        resumeRendererAfterCancelledHibernateUpgradeRef.current?.();
-      },
-    );
-  }, [fullHibernateRuntime, sessionId]);
-
   const hideRuntimeOnly = useCallback(() => {
     if (hibernatedRef.current || softHiddenRef.current || !hasRuntimeRef.current) return;
     xtermRuntimeRef.current?.suspendWebglRenderer();
@@ -2319,6 +2308,39 @@ const TerminalComponent: React.FC<TerminalProps> = ({
     logger.info("[Terminal] Soft-hidden runtime", { sessionId });
   }, [sessionId]);
 
+  const upgradeSoftHiddenRuntimeToHibernate = useCallback(() => {
+    const pendingEviction = terminalHiddenRendererStore.hasPendingEviction(sessionId);
+    if (!wakeSoftHiddenRuntimeRef.current) {
+      terminalHiddenRendererStore.settleEviction(sessionId, false);
+      return;
+    }
+    wakeSoftHiddenRuntimeRef.current?.();
+    void fullHibernateRuntime().then(
+      (completed) => {
+        if (!completed) {
+          resumeRendererAfterCancelledHibernateUpgradeRef.current?.();
+          // Wake already dropped the marker. Restore the soft-hidden slot only
+          // while this tab is still hidden and hibernate is still enabled.
+          // Selecting the victim during the drain makes fullHibernateRuntime
+          // return false because the tab is visible; soft-hiding it again
+          // would hide the tab the user just opened.
+          if (pendingEviction && !isVisibleRef.current && hibernateEnabledRef.current) {
+            hideRuntimeOnly();
+          }
+        }
+        terminalHiddenRendererStore.settleEviction(sessionId, completed);
+      },
+      (error) => {
+        logger.error("[Terminal] Failed to upgrade soft-hidden runtime to hibernate", { sessionId, error });
+        resumeRendererAfterCancelledHibernateUpgradeRef.current?.();
+        if (pendingEviction && !isVisibleRef.current && hibernateEnabledRef.current) {
+          hideRuntimeOnly();
+        }
+        terminalHiddenRendererStore.settleEviction(sessionId, false);
+      },
+    );
+  }, [fullHibernateRuntime, hideRuntimeOnly, sessionId]);
+
   const hibernateRuntime = useCallback(() => {
     if (hibernatedRef.current || !termRef.current) return;
 
@@ -2333,8 +2355,14 @@ const TerminalComponent: React.FC<TerminalProps> = ({
       return;
     }
 
+    // Disconnected sessions never stay soft-hidden. A connected session whose
+    // keep count dropped to zero takes the same upgrade. A positive count stays
+    // retained until a later leave evicts overflow.
     if (softHiddenRef.current) {
-      if (statusRef.current === "disconnected") {
+      const retainedKeepCount = statusRef.current === "connected"
+        ? resolveHibernateKeepRendererCount(terminalSettingsRef.current)
+        : 0;
+      if (statusRef.current === "disconnected" || !(retainedKeepCount > 0)) {
         upgradeSoftHiddenRuntimeToHibernate();
       }
       return;
@@ -2343,16 +2371,47 @@ const TerminalComponent: React.FC<TerminalProps> = ({
     const keepCount = statusRef.current === "connected"
       ? resolveHibernateKeepRendererCount(terminalSettings)
       : 0;
-    if (keepCount > 0 && terminalHiddenRendererStore.getSoftHiddenCount() < keepCount) {
+    const keepDecision = decideHiddenTabKeepCountAction({
+      keepCount,
+      softHiddenCount: terminalHiddenRendererStore.getSoftHiddenOccupancy(),
+      sessionId,
+      candidatesOldestFirst: keepCount > 0
+        ? terminalHiddenRendererStore.listSoftHiddenOldestFirst()
+        : [],
+    });
+    if (keepDecision.action === "soft-hide") {
       hideRuntimeOnly();
       return;
     }
-
-    if (keepCount > 0) {
-      const victim = terminalHiddenRendererStore.pickEvictionCandidate(keepCount);
-      if (victim && victim !== sessionId) {
-        terminalHiddenRendererStore.requestEviction(victim);
-      }
+    if (keepDecision.action === "await-eviction") {
+      const attempt = ++hibernateEvictionAttemptRef.current;
+      // Reserves this tab's slot before the first await, then soft-hides only
+      // if a victim hibernate completes and the slot still fits. A sync marker
+      // clear is not enough: alt-screen and drain/snapshot failure restore the
+      // victim, and this tab stays out of the soft-hidden set.
+      void retainLeavingTabAfterEviction({
+        sessionId,
+        candidates: keepDecision.candidates,
+        keepCount,
+        // Re-read after the victim drain. The count above was captured when
+        // this timer fired; a zero or tighter setting must full-hibernate.
+        resolveKeepCount: () => (
+          statusRef.current === "connected"
+            ? resolveHibernateKeepRendererCount(terminalSettingsRef.current)
+            : 0
+        ),
+        stillWantsRetention: () => (
+          hibernateEvictionAttemptRef.current === attempt
+          && !isVisibleRef.current
+          && !hibernatedRef.current
+          && !softHiddenRef.current
+        ),
+        softHide: () => hideRuntimeOnly(),
+        fullHibernate: () => {
+          void fullHibernateRuntime();
+        },
+      });
+      return;
     }
 
     void fullHibernateRuntime();
@@ -4710,6 +4769,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
     isSearchOpen,
     hibernateEnabled: hibernateEnabled,
     hibernateDelayMs: resolveTerminalHibernateDelayMs(terminalSettings),
+    hibernateKeepRendererCount: resolveHibernateKeepRendererCount(terminalSettings),
     fileTransferActive: hibernateFileTransferActive,
     hibernatedRef,
     softHiddenRef,

components/TerminalLayer.tsx

@@ -123,6 +123,7 @@ import {
 import { classifyDistroId, hostRestrictsExtraSshChannels, shouldProbeSessionCwd } from '../domain/host';
 import {
   collectSidePanelPanes,
+  isPluginSidePanelTool,
   sidePanelLayoutHasTool,
   type SidePanelLayout,
   type SidePanelSplitDirection,
@@ -319,6 +320,7 @@ const TerminalLayerInner: React.FC<TerminalLayerProps> = ({
     splitPane: splitSidePanelPaneForTab,
     closePane: closeSidePanelPaneForTab,
     resizeSplit: resizeSidePanelSplitForTab,
+    selectSidePanelToolForTab,
   } = useTerminalSidePanelLayoutState();
   useEffect(() => {
     pruneComposeBarHistory(sessions.map((session) => session.id));
@@ -1752,13 +1754,9 @@ const TerminalLayerInner: React.FC<TerminalLayerProps> = ({
     if (!prepareSidePanelTool(tabId, tab)) return;
 
     startTransition(() => {
-      setSidePanelOpenTabs(prev => {
-        const next = new Map(prev);
-        next.set(tabId, tab);
-        return next;
-      });
+      selectSidePanelToolForTab(tabId, tab);
     });
-  }, [prepareSidePanelTool, setSidePanelOpenTabs, sidePanelOpenTabsRef]);
+  }, [prepareSidePanelTool, selectSidePanelToolForTab, sidePanelOpenTabsRef]);
 
   const handleFocusSidePanelPane = useCallback((paneId: string) => {
     const tabId = activeTabIdRef.current;
@@ -1936,6 +1934,16 @@ const TerminalLayerInner: React.FC<TerminalLayerProps> = ({
     resizeSidePanelSplitForTab(tabId, splitId, sizes);
   }, [resizeSidePanelSplitForTab]);
 
+  const handleWithdrawPluginSidebarPane = useCallback((tabId: string, paneId: string, expectedTool: SidePanelTab) => {
+    if (!isPluginSidePanelTool(expectedTool)) return;
+    const layout = sidePanelLayoutsRef.current.get(tabId);
+    const pane = layout && collectSidePanelPanes(layout.root).find((item) => item.id === paneId);
+    if (pane?.tool !== expectedTool) return;
+    setMagnifiedPane((current) => current?.tabId === tabId && current.target.kind === 'side-panel'
+      && current.target.paneId === paneId ? null : current);
+    closeSidePanelPaneForTab(tabId, paneId);
+  }, [closeSidePanelPaneForTab, sidePanelLayoutsRef]);
+
   // Toggle SFTP from activity bar header
   const handleToggleSftpFromBar = useCallback(() => {
     handleSwitchSidePanelTab('sftp');
@@ -2620,6 +2628,9 @@ const TerminalLayerInner: React.FC<TerminalLayerProps> = ({
     handleOpenAI,
     handleOpenSystem,
     handleOpenNotes,
+    getActiveTerminalSessionId,
+    handleSwitchSidePanelTab,
+    handleWithdrawPluginSidebarPane,
     handleOpenBrowser,
     handleFocusSidePanelPane,
     handleMagnifySidePanelPane,