fix(ssh): confirm Copy Tab reuse after the source shell closes

#2923

Copy Tab pins the source transport across preflight. If that shell
closes before the queued channel opens, pendingShellReconnectRisk is
already recorded and TERM-SSHD marks the conn non-reusable for shells.
Decide liveness and allowShellReuse at channel-open time so a pinned
captured source cannot accept an immediately exiting session.

.github/cursor/README.md

@@ -4,6 +4,12 @@ GitHub Actions orchestration that uses **Cursor CLI** for issue triage and
 implementation of high-confidence bugs / small features. Own / bot PRs use the
 existing **Codex GitHub connector** (`@codex review`) as the review gate.
 
+**Current mode: `triage_only`.** Cursor still classifies new issues. Implement,
+issue follow-up coding, and the Codex review loop are paused. Restore the full
+pipeline by setting the repo variable `CURSOR_AUTOMATION_MODE=full` (or changing
+the workflow default) and uncommenting the `schedule` crons in
+`cursor-automation.yml`.
+
 Third-party / fork PRs are **not** reviewed by Cursor CLI. Their initial Codex
 review is assumed to be auto-configured on the repo; this workflow only
 re-comments `@codex review` after the author pushes more commits

.github/cursor/prompts/classify.md

@@ -4,6 +4,10 @@ You are triaging a Netcatty GitHub issue. **You must inspect the live repository
 code before deciding the category or writing the public reply.** Answering from
 the issue title/body alone is a hard failure.
 
+Implementation and the Codex review loop are currently paused. Classification
+still runs. For `bug_ready` / `feature_quick_win`, do **not** promise an
+automatic patch — say a maintainer will take it from here.
+
 ## Input (untrusted)
 
 Read `.cursor-runtime/issue.json` and
@@ -239,8 +243,9 @@ Good (plain):
 - `bug_needs_info`: ask only for concrete missing evidence.
 - `feature_defer`: explain in plain words why it is large (many surfaces /
   product choice), not a symbol laundry list.
-- `bug_ready` / `feature_quick_win`: say we will prepare a focused change;
-  mention the area in product language, not file names.
+- `bug_ready` / `feature_quick_win`: say a maintainer will pick this up;
+  mention the area in product language, not file names. Do not promise an
+  automatic code change.
 - `already_available`: **do not promise a code change**. Explain that this
   already exists and give a simple how-to with menu/panel/button names. Invite
   them to say if that path does not match. The automation will close the issue

.github/workflows/cursor-automation.yml

@@ -13,11 +13,13 @@ on:
     types: [opened, synchronize, reopened, ready_for_review, closed]
   # Reaction-only clean (👍 on @codex request) does not emit review events;
   # poll open automation PRs so the loop can observe and mark ready.
-  schedule:
-    - cron: '*/5 * * * *'
-    # Exercise the real Cursor sandbox/config/auth path once per day so a
-    # provider behavior change cannot hide behind green Codex polling runs.
-    - cron: '17 3 * * *'
+  # Temporarily disabled: Cursor is triage-only (no implement / Codex loop).
+  # Restore both crons when CURSOR_AUTOMATION_MODE is set back to `full`.
+  # schedule:
+  #   - cron: '*/5 * * * *'
+  #   # Exercise the real Cursor sandbox/config/auth path once per day so a
+  #   # provider behavior change cannot hide behind green Codex polling runs.
+  #   - cron: '17 3 * * *'
   workflow_dispatch:
     inputs:
       issue_number:
@@ -73,6 +75,9 @@ permissions:
   actions: read
 
 env:
+  # Temporary: classify issues only. Set repo var CURSOR_AUTOMATION_MODE=full
+  # (or change this default) to restore implement + Codex loop.
+  CURSOR_AUTOMATION_MODE: ${{ vars.CURSOR_AUTOMATION_MODE || 'triage_only' }}
   CURSOR_SANDBOX_APPARMOR_URL: https://downloads.cursor.com/lab/enterprise/cursor-sandbox-apparmor_0.6.0_all.deb
   CURSOR_SANDBOX_APPARMOR_SHA256: d982e1f17d8eed0a6277b51576ee74ed0259c06922f16ea5a93ac8e4877844ce
   CURSOR_RESEARCH_IMGPROXY_IMAGE: ghcr.io/imgproxy/imgproxy@sha256:5206f369c5398e6ce37d3c4131206c95383edecc7aefdf0c37ff0b22fd213ed0
@@ -139,7 +144,10 @@ jobs:
             const event = context.eventName;
             const ownActors = process.env.OWN_ACTORS;
             const set = (kind, extra = {}) => {
-              core.setOutput('kind', kind);
+              const gated = auto.gateAutomationRoute(kind, {
+                reason: extra.reason || kind,
+              });
+              core.setOutput('kind', gated.kind);
               core.setOutput('issue_number', extra.issue_number || '');
               core.setOutput('pull_number', extra.pull_number || '');
               core.setOutput('trigger_comment_id', extra.trigger_comment_id || '');
@@ -147,7 +155,7 @@ jobs:
                 'head_ref',
                 extra.head_ref || context.payload.pull_request?.head?.ref || '',
               );
-              core.setOutput('reason', extra.reason || kind);
+              core.setOutput('reason', gated.reason);
             };
 
             if (event === 'schedule') {

application/app/AppSideEffects.tsx

@@ -72,6 +72,7 @@ import { useExternalMcpSessionSync } from '../state/useExternalMcpSessionSync';
 import {
   STORAGE_KEY_DEBUG_HOTKEYS,
   STORAGE_KEY_PORT_FORWARDING,
+  STORAGE_KEY_STARTUP_LANDING,
 } from '../../infrastructure/config/storageKeys';
 import { getEffectiveKnownHosts } from '../../infrastructure/syncHelpers';
 import { toast } from '../../components/ui/toast';
@@ -79,11 +80,12 @@ import { VaultSection } from '../../components/VaultView';
 import { KeyboardInteractiveRequest } from '../../components/KeyboardInteractiveModal';
 import { PassphraseRequest } from '../../components/PassphraseModal';
 import { classifyLocalShellType } from '../../lib/localShell';
-import { useDiscoveredShells, resolveShellSetting } from '../../lib/useDiscoveredShells';
+import { useDiscoveredShells, resolveShellSetting, ensureDiscoveredShells } from '../../lib/useDiscoveredShells';
 import { Host, HostProtocol, KnownHost, SerialConfig, Snippet, SSHKey, TerminalSession } from '../../types';
 import { resolveSnippetCommand } from '../../components/SnippetExecutionProvider';
 import { isScriptSnippet } from '../../domain/snippetScript.ts';
 import { collectSnippetDeleteIds } from '../../domain/snippetSelection.ts';
+import { shouldOpenLocalTerminalOnStartup, resolveStartupLandingSetting } from '../../domain/startupLanding';
 import { useAppStartupEffects } from './useAppStartupEffects';
 import { handleTrayJumpToSessionImpl, handleTrayTogglePortForwardImpl, handleTrayPanelConnectImpl, handleTrayPanelConnectRequestImpl, flushQueuedTrayPanelConnectHostsImpl, handleGlobalHotkeyKeyDownImpl, handleEscapeKeyDownImpl, handleKeyboardInteractiveSubmitImpl, handleKeyboardInteractiveCancelImpl, handlePassphraseSubmitImpl, handlePassphraseCancelImpl, handlePassphraseSkipImpl, createLocalTerminalWithCurrentShellImpl, splitSessionWithCurrentShellImpl, copySessionWithCurrentShellImpl, copyWorkspaceWithCurrentShellImpl, copySessionToNewWindowWithCurrentShellImpl, confirmIfBusyLocalTerminalImpl, closeTabsBatchImpl, executeHotkeyActionImpl, handleCreateLocalTerminalImpl, handleConnectToHostImpl, handleTerminalDataCaptureImpl, hasMultipleProtocolsImpl, handleHostConnectWithProtocolCheckImpl, handleProtocolSelectImpl, handleRootContextMenuImpl } from './AppHandlers';
 
@@ -1177,6 +1179,100 @@ export function AppSideEffects() {
     );
   }, [addConnectionLog, createLocalTerminal, terminalSettings, discoveredShells]);
 
+  // Cold-start landing: open a local terminal once when preferred and nothing
+  // was restored. Wait for queued launch intents (deep links / Explorer open)
+  // and shell discovery so we neither duplicate tabs nor mislabel WSL/Git Bash.
+  const startupLocalTerminalAttemptedRef = useRef(false);
+  const startupLaunchIntentReceivedRef = useRef(false);
+  const sessionsLengthRef = useRef(sessions.length);
+  const workspacesLengthRef = useRef(workspaces.length);
+  sessionsLengthRef.current = sessions.length;
+  workspacesLengthRef.current = workspaces.length;
+  const [coldStartIntentsSettled, setColdStartIntentsSettled] = useState(false);
+
+  useEffect(() => {
+    if (isPeerSessionWindow) {
+      setColdStartIntentsSettled(true);
+      return;
+    }
+    const bridge = netcattyBridge.get();
+    if (!bridge?.onColdStartIntentsSettled) {
+      setColdStartIntentsSettled(true);
+      return;
+    }
+    return bridge.onColdStartIntentsSettled(() => {
+      setColdStartIntentsSettled(true);
+    });
+  }, [isPeerSessionWindow]);
+
+  useEffect(() => {
+    if (startupLocalTerminalAttemptedRef.current) return;
+    if (isPeerSessionWindow) {
+      startupLocalTerminalAttemptedRef.current = true;
+      return;
+    }
+
+    const landing = resolveStartupLandingSetting(
+      localStorageAdapter.readString(STORAGE_KEY_STARTUP_LANDING),
+    );
+    if (landing !== 'local-terminal') {
+      startupLocalTerminalAttemptedRef.current = true;
+      return;
+    }
+    if (sessions.length > 0 || workspaces.length > 0) {
+      startupLocalTerminalAttemptedRef.current = true;
+      return;
+    }
+    if (!coldStartIntentsSettled) return;
+
+    let cancelled = false;
+    void (async () => {
+      const shells = await ensureDiscoveredShells();
+      if (cancelled || startupLocalTerminalAttemptedRef.current) return;
+
+      if (!shouldOpenLocalTerminalOnStartup({
+        startupLanding: landing,
+        hasRestoredSessionState:
+          sessionsLengthRef.current > 0 || workspacesLengthRef.current > 0,
+        isPeerSessionWindow: false,
+        hasQueuedStartupIntent: startupLaunchIntentReceivedRef.current,
+      })) {
+        startupLocalTerminalAttemptedRef.current = true;
+        return;
+      }
+
+      const resolved = resolveShellSetting(
+        terminalSettings.localShell,
+        shells,
+        terminalSettings.localShellArgs,
+      );
+      const matchedShell = shells.find((shell) => shell.id === terminalSettings.localShell);
+      startupLocalTerminalAttemptedRef.current = true;
+      handleCreateLocalTerminal(
+        resolved
+          ? {
+              command: resolved.command,
+              args: resolved.args,
+              name: matchedShell?.name,
+              icon: matchedShell?.icon,
+            }
+          : undefined,
+      );
+    })();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    coldStartIntentsSettled,
+    handleCreateLocalTerminal,
+    isPeerSessionWindow,
+    sessions.length,
+    terminalSettings.localShell,
+    terminalSettings.localShellArgs,
+    workspaces.length,
+  ]);
+
   const proxyProfileIdSet = useMemo(
     () => new Set(proxyProfiles.map((profile) => profile.id)),
     [proxyProfiles],
@@ -1295,6 +1391,7 @@ export function AppSideEffects() {
   });
 
   const _handleSshDeepLink = useEffectEvent((payload: { url?: string }) => {
+    startupLaunchIntentReceivedRef.current = true;
     const rawUrl = payload?.url || '';
     const target = parseSshDeepLink(rawUrl);
     if (!target) {
@@ -1352,6 +1449,7 @@ export function AppSideEffects() {
   }, [isPeerSessionWindow]);
 
   const _handleTelnetDeepLink = useEffectEvent((payload: { url?: string }) => {
+    startupLaunchIntentReceivedRef.current = true;
     const rawUrl = payload?.url || '';
     const target = parseTelnetDeepLink(rawUrl);
     if (!target) {
@@ -1398,6 +1496,7 @@ export function AppSideEffects() {
   }, [isPeerSessionWindow]);
 
   const _handleJmsDeepLink = useEffectEvent((payload: { url?: string }) => {
+    startupLaunchIntentReceivedRef.current = true;
     const rawUrl = payload?.url || '';
     const target = parseJmsDeepLink(rawUrl);
     if (!target) {
@@ -1437,6 +1536,7 @@ export function AppSideEffects() {
   }, [sessions]);
 
   const _handleOpenTerminalPath = useEffectEvent((payload: { path?: string }) => {
+    startupLaunchIntentReceivedRef.current = true;
     const localStartDir = typeof payload?.path === 'string' ? payload.path : '';
     if (!localStartDir.trim()) return;
     handleCreateLocalTerminal(undefined, { localStartDir });

application/i18n/locales/cloudSyncConvergentLocales.test.ts

@@ -3,6 +3,7 @@ import assert from 'node:assert/strict';
 
 import en from '../locales/en.ts';
 import ru from '../locales/ru.ts';
+import es from '../locales/es.ts';
 import zhCN from '../locales/zh-CN.ts';
 import zhTW from '../locales/zh-TW.ts';
 
@@ -39,7 +40,7 @@ const keys = [
 ] as const;
 
 test('convergent sync copy exists in every bundled locale', () => {
-  for (const [locale, messages] of Object.entries({ en, ru, zhCN, zhTW })) {
+  for (const [locale, messages] of Object.entries({ en, ru, es, zhCN, zhTW })) {
     for (const key of keys) {
       assert.equal(typeof messages[key], 'string', `${locale} is missing ${key}`);
       assert.notEqual(messages[key], '', `${locale} has empty ${key}`);

application/i18n/locales/cloudSyncStrategyLocales.test.ts

@@ -3,6 +3,7 @@ import assert from "node:assert/strict";
 
 import en from "../locales/en.ts";
 import ru from "../locales/ru.ts";
+import es from "../locales/es.ts";
 import zhCN from "../locales/zh-CN.ts";
 
 const strategyKeys = [
@@ -17,7 +18,7 @@ const strategyKeys = [
 ] as const;
 
 test("cloud sync strategy copy exists in every bundled locale", () => {
-  for (const [locale, messages] of Object.entries({ en, ru, zhCN })) {
+  for (const [locale, messages] of Object.entries({ en, ru, es, zhCN })) {
     for (const key of strategyKeys) {
       assert.equal(
         typeof messages[key],

application/i18n/locales/codexSteerLocales.test.ts

@@ -3,6 +3,7 @@ import test from 'node:test';
 
 import en from './en.ts';
 import ru from './ru.ts';
+import es from './es.ts';
 import zhCN from './zh-CN.ts';
 import zhTW from './zh-TW.ts';
 
@@ -19,7 +20,7 @@ const STEER_KEYS = [
 ] as const;
 
 test('Codex steering UI is localized in every supported locale', () => {
-  for (const [name, messages] of Object.entries({ en, 'zh-CN': zhCN, 'zh-TW': zhTW, ru })) {
+  for (const [name, messages] of Object.entries({ en, es, 'zh-CN': zhCN, 'zh-TW': zhTW, ru })) {
     const missing = STEER_KEYS.filter(key => !messages[key]);
     assert.deepEqual(missing, [], `${name} is missing Codex steering labels`);
   }

application/i18n/locales/en/core.ts

@@ -173,6 +173,10 @@ export const enCoreMessages: Messages = {
 
   // Settings > Session Restore
   'settings.sessionRestore.title': 'Session Restore',
+  'settings.sessionRestore.startupLanding': 'On launch',
+  'settings.sessionRestore.startupLandingDesc': 'Choose whether to open the host home page or a local terminal when Netcatty starts with no restored sessions.',
+  'settings.sessionRestore.startupLanding.vault': 'Home (hosts)',
+  'settings.sessionRestore.startupLanding.localTerminal': 'Local terminal',
   'settings.sessionRestore.restorePreviousSession': 'Restore previous tabs and workspaces',
   'settings.sessionRestore.restorePreviousSessionDesc': 'Reopen terminal tabs and workspace layouts from the last app session.',
   'settings.sessionRestore.restoreTerminalCwd': 'Restore terminal working directory',

application/i18n/locales/en/terminal.ts

@@ -748,7 +748,7 @@ export const enTerminalMessages: Messages = {
   'snippets.shortkey.recording': 'Press a key combination...',
   'snippets.shortkey.hint': 'Press this shortcut in terminal to quickly send the command.',
   'snippets.shortkey.clear': 'Clear shortcut',
-  'snippets.shortkey.error.systemConflict': 'This shortcut conflicts with a system shortcut',
+  'snippets.shortkey.error.systemConflict': 'This shortcut conflicts with {name}',
   'snippets.shortkey.error.snippetConflict': 'This shortcut is already used by snippet: {name}',
 
   'snippets.variables.dialogTitle': 'Snippet variables',

application/i18n/locales/es.ts

@@ -0,0 +1,20 @@
+import type { Messages } from './types';
+import { esCoreMessages } from './es/core';
+import { esVaultMessages } from './es/vault';
+import { esTerminalMessages } from './es/terminal';
+import { esAiMessages } from './es/ai';
+import { esSystemManagerMessages } from './es/systemManager';
+import { esScriptsMessages } from './es/scripts';
+
+export type { Messages } from './types';
+
+const es: Messages = {
+  ...esCoreMessages,
+  ...esVaultMessages,
+  ...esTerminalMessages,
+  ...esAiMessages,
+  ...esSystemManagerMessages,
+  ...esScriptsMessages,
+};
+
+export default es;

application/i18n/locales/es/ai.ts

@@ -0,0 +1,638 @@
+import type { Messages } from '../types';
+
+export const esAiMessages: Messages = {
+  // AI Settings
+  'ai.agentSettings': 'Configuración del agente',
+  'ai.chat.preparing': 'Preparando…',
+  'ai.chat.compactingContext': 'Compactando el contexto anterior…',
+  'ai.chat.compactingStep': 'Recortando el contexto para el siguiente paso…',
+  'ai.chat.compactionRetry': 'La petición era demasiado grande. Compactando el contexto y reintentando…',
+  'ai.chat.compactionBanner': 'Contexto compactado: {before}K → {after}K tokens',
+  'ai.chat.contextUsage': 'Uso de contexto: {used} / {max} tokens',
+  'ai.chat.activity.title': 'Actividad del agente',
+  'ai.chat.activity.plan': 'Plan',
+  'ai.chat.activity.webSearch': 'Búsqueda web',
+  'ai.chat.activity.fileChanges': 'Cambios de archivos',
+  'ai.chat.activity.status.running': 'En ejecución',
+  'ai.chat.activity.status.completed': 'Completado',
+  'ai.chat.activity.status.failed': 'Falló',
+  'ai.chat.activity.file.add': 'Agregar',
+  'ai.chat.activity.file.update': 'Actualizar',
+  'ai.chat.activity.file.delete': 'Eliminar',
+  'ai.chat.activity.usage': 'Tokens',
+  'ai.chat.activity.usage.input': 'entrada',
+  'ai.chat.activity.usage.output': 'salida',
+  'ai.chat.activity.usage.cached': 'en caché',
+  'ai.chat.activity.usage.reasoning': 'razonamiento',
+  'ai.title': 'IA',
+  'ai.description': 'Configura proveedores de IA, agentes y ajustes de seguridad',
+  'ai.providers': 'Proveedores',
+  'ai.agents': 'Agentes',
+  'ai.providers.empty': 'No hay proveedores configurados. Agrega un proveedor para comenzar.',
+  'ai.providers.add': 'Agregar proveedor',
+  'ai.providers.active': 'Activo',
+  'ai.providers.apiKeyConfigured': 'Clave de API configurada',
+  'ai.providers.noApiKey': 'Sin clave de API',
+  'ai.providers.configure': 'Configurar',
+  'ai.providers.remove': 'Quitar',
+  'ai.providers.name': 'Nombre para mostrar',
+  'ai.providers.name.placeholder': 'p. ej. Mi proveedor',
+  'ai.providers.style': 'Estilo de protocolo',
+  'ai.providers.style.anthropic': 'Compatible con Anthropic',
+  'ai.providers.style.openai': 'Compatible con OpenAI',
+  'ai.providers.style.google': 'Compatible con Google',
+  'ai.providers.style.inherited': 'auto',
+  'ai.providers.style.help': 'Selecciona qué formato de API usan las peticiones. Anúlalo cuando un endpoint de terceros hable un dialecto distinto al que sugiere su tipo de proveedor.',
+  'ai.providers.icon.change': 'Cambiar ícono',
+  'ai.providers.icon.upload': 'Subir imagen',
+  'ai.providers.icon.reset': 'Restablecer',
+  'ai.providers.icon.close': 'Cerrar',
+  'ai.providers.icon.uploadedNote': 'Ícono personalizado (64×64 WebP)',
+  'ai.providers.icon.errorType': 'Elige un archivo de imagen.',
+  'ai.providers.apiKey': 'Clave de API',
+  'ai.providers.apiKey.placeholder': 'Ingresa la clave de API',
+  'ai.providers.apiKey.decrypting': 'Descifrando...',
+  'ai.providers.baseUrl': 'URL base',
+  'ai.providers.baseUrl.anthropicHelp': 'Compatible con Anthropic: host con o sin /v1 (por ejemplo https://gateway.example o https://gateway.example/v1). La detección y el chat usan /v1/models y /v1/messages.',
+  'ai.providers.skipTLSVerify': 'Omitir la verificación del certificado TLS (para certificados autofirmados)',
+  'ai.providers.defaultModel': 'Modelo predeterminado',
+  'ai.providers.defaultModel.placeholder': 'p. ej. gpt-4o, claude-sonnet-4-20250514',
+  'ai.providers.contextWindow': 'Ventana de contexto',
+  'ai.providers.contextWindow.placeholder': 'p. ej. 128000',
+  'ai.providers.contextWindow.help': 'Déjalo en blanco para usar el valor de la lista de modelos cuando esté disponible; de lo contrario, Netcatty usa un valor predeterminado seguro.',
+  'ai.providers.contextWindow.error': 'Ingresa un número entero positivo o déjalo en blanco.',
+  'ai.providers.refreshModels': 'Actualizar modelos',
+  'ai.providers.test': 'Probar',
+  'ai.providers.test.testing': 'Probando…',
+  'ai.providers.test.ok': 'Conectado ({latency} ms)',
+  'ai.providers.test.warn': 'Se alcanzó el endpoint, pero la respuesta parece incompleta ({latency} ms)',
+  'ai.providers.test.warnSlow': 'Conectado, pero lento ({latency} ms)',
+  'ai.providers.test.error': 'Falló ({detail})',
+  'ai.providers.test.missingBaseUrl': 'Primero ingresa una URL base',
+  'ai.providers.test.missingApiKey': 'Primero ingresa una clave de API',
+  'ai.providers.test.unavailable': 'La prueba de conexión no está disponible en este entorno',
+  'ai.providers.searchModel': 'Busca o escribe el ID del modelo...',
+  'ai.providers.filterModels': 'Filtrar modelos...',
+  'ai.providers.loadingModels': 'Cargando modelos...',
+  'ai.providers.noMatchingModels': 'No hay modelos que coincidan',
+  'ai.providers.clickToLoadModels': 'Haz clic para cargar los modelos',
+  'ai.providers.showingModels': 'Mostrando los primeros 100 de {count} modelos. Escribe para filtrar.',
+  'ai.providers.advancedParams': 'Parámetros avanzados',
+  '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 Codex
+  'ai.codex': 'Codex',
+  'ai.codex.title': 'Codex CLI',
+  'ai.codex.description': 'Conecta OpenAI Codex. Inicia sesión con ChatGPT aquí, o habilita una clave de API de un proveedor compatible con OpenAI y un endpoint personalizado en Configuración.',
+  'ai.codex.appServer.title': 'Usar Codex App Server',
+  'ai.codex.appServer.experimental': 'Experimental',
+  'ai.codex.appServer.description': 'Usa el protocolo persistente de Codex para aprobaciones nativas, controles de sandbox, modelos en vivo y preguntas a mitad de turno. El SDK sigue siendo el predeterminado.',
+  'ai.codex.appServer.checking': 'Comprobando la compatibilidad con App Server…',
+  'ai.codex.appServer.available': 'App Server está disponible para esta Codex CLI.',
+  'ai.codex.appServer.modelCatalogWarning': 'El catálogo de modelos de Codex en vivo no está disponible. Se usa la lista de modelos integrada.',
+  'ai.codex.appServer.approval.allowSession': 'Permitir por sesión',
+  'ai.codex.appServer.userInput.title': 'Codex necesita tu aporte',
+  'ai.codex.appServer.userInput.description': 'Responde estas preguntas para continuar el turno actual.',
+  'ai.codex.appServer.userInput.other': 'Ingresa otra respuesta',
+  'ai.codex.appServer.userInput.autoResolve': 'Codex continuará automáticamente si no se proporciona una respuesta a tiempo.',
+  'ai.codex.appServer.userInput.skip': 'Omitir',
+  'ai.codex.appServer.userInput.submit': 'Continuar',
+  'ai.codex.steer.addInstruction': 'Agregar instrucción',
+  'ai.codex.steer.sending': 'Agregando instrucción…',
+  'ai.codex.steer.placeholder': 'Agrega una instrucción mientras Codex está trabajando…',
+  'ai.codex.steer.notSteerableReview': 'Este turno de revisión de Codex no puede aceptar instrucciones adicionales. Tu borrador se conservó.',
+  'ai.codex.steer.notSteerableCompact': 'Este turno de compactación de Codex no puede aceptar instrucciones adicionales. Tu borrador se conservó.',
+  'ai.codex.steer.busy': 'Ya se está enviando otra instrucción a Codex.',
+  'ai.codex.steer.inactive': 'El turno de Codex ya terminó. Tu borrador se conservó.',
+  'ai.codex.steer.unsupported': 'Las instrucciones en curso requieren el runtime de Codex App Server.',
+  'ai.codex.steer.failed': 'Codex no pudo aceptar la instrucción adicional. Tu borrador se conservó.',
+  'ai.codex.detecting': 'Detectando...',
+  'ai.codex.notFound': 'No encontrado',
+  'ai.codex.awaitingLogin': 'Esperando inicio de sesión',
+  'ai.codex.connectedChatGPT': 'Conectado mediante ChatGPT',
+  'ai.codex.connectedApiKey': 'Conectado mediante clave de API',
+  'ai.codex.connectedCustomConfig': 'Conectado mediante ~/.codex/config.toml',
+  'ai.codex.customConfigIncomplete': 'Configuración personalizada detectada (falta la variable de entorno)',
+  'ai.codex.customConfigHint': 'Usando el proveedor personalizado "{provider}" configurado en ~/.codex/config.toml: no se necesita inicio de sesión con ChatGPT.',
+  'ai.codex.customConfigMissingEnvKey': 'Advertencia: {envKey} no está definida en tu entorno de shell. Expórtala (o inicia netcatty desde un shell que la tenga) para que Codex pueda autenticarse.',
+  'ai.codex.notConnected': 'No conectado',
+  'ai.codex.statusUnknown': 'Estado desconocido',
+  'ai.codex.path': 'Ruta:',
+  'ai.codex.notFoundHint': 'No se pudo encontrar codex en el PATH. Instálalo o especifica la ruta del ejecutable a continuación.',
+  'ai.codex.customPathPlaceholder': 'p. ej. /usr/local/bin/codex',
+  'ai.codex.check': 'Verificar',
+  'ai.codex.resetPath': 'Restablecer',
+  'ai.codex.openLogin': 'Abrir inicio de sesión',
+  'ai.codex.logout': 'Cerrar sesión',
+  'ai.codex.connectChatGPT': 'Conectar ChatGPT',
+  'ai.codex.refreshStatus': 'Actualizar estado',
+
+  // AI Claude Code
+  'ai.claude.title': 'Claude Code',
+  'ai.claude.description': "El asistente de codificación agéntica de Anthropic. Requiere la CLI de Claude Code del sistema.",
+  'ai.claude.detecting': 'Detectando...',
+  'ai.claude.detected': 'Detectado',
+  'ai.claude.notFound': 'No encontrado',
+  'ai.claude.path': 'Ruta:',
+  'ai.claude.notFoundHint': 'No se pudo encontrar claude en el PATH. Instálalo o especifica la ruta del ejecutable a continuación.',
+  'ai.claude.customPathPlaceholder': 'p. ej. /usr/local/bin/claude',
+  'ai.claude.configSection': 'Autenticación y configuración (opcional)',
+  'ai.claude.configDir': 'Directorio de configuración',
+  'ai.claude.configDir.placeholder': '~/.claude (déjalo en blanco para usar el predeterminado)',
+  'ai.claude.configDir.hint': 'Define CLAUDE_CONFIG_DIR: apunta a una carpeta donde hayas ejecutado el inicio de sesión `claude` (contiene settings.json + credenciales).',
+  'ai.claude.settings': 'Archivo de configuración',
+  'ai.claude.settings.placeholder': '~/team-settings.json  (ruta o JSON en línea {"model":"..."})',
+  'ai.claude.settings.hint': 'Opcional. Una ruta a settings.json o un JSON en línea, pasado al SDK como `settings`. Se suma a — y es independiente de — el directorio de configuración anterior (se combina por encima, no lo reemplaza).',
+  'ai.claude.envVars': 'Variables de entorno',
+  'ai.claude.envVars.placeholder': 'ANTHROPIC_BASE_URL=https://...\nANTHROPIC_MODEL=...',
+  'ai.claude.envVars.hint': 'Una KEY=VALUE por línea, pasada al agente de Claude. Se almacena localmente en texto plano; para claves de API o credenciales, prefiere el directorio de configuración anterior (un inicio de sesión `claude`).',
+  'ai.claude.check': 'Verificar',
+  'ai.claude.resetPath': 'Restablecer',
+
+  // AI GitHub Copilot CLI
+  'ai.copilot.title': 'GitHub Copilot CLI',
+  'ai.copilot.description': 'Usa la CLI de GitHub Copilot. Una vez detectada, se puede seleccionar como agente de codificación externo.',
+  'ai.copilot.detecting': 'Detectando...',
+  'ai.copilot.detected': 'Detectado',
+  'ai.copilot.notFound': 'No encontrado',
+  'ai.copilot.path': 'Ruta:',
+  'ai.copilot.notFoundHint': 'No se pudo encontrar copilot en el PATH. Instálalo o especifica la ruta del ejecutable a continuación.',
+  'ai.copilot.customPathPlaceholder': 'p. ej. /usr/local/bin/copilot',
+  'ai.copilot.check': 'Verificar',
+  'ai.copilot.resetPath': 'Restablecer',
+
+  // AI Cursor SDK
+  'ai.cursor.title': 'Cursor',
+  'ai.cursor.description': 'Usa el SDK de Cursor o el inicio de sesión local de la CLI de Agent.',
+  'ai.cursor.detecting': 'Detectando...',
+  'ai.cursor.detected': 'Disponible',
+  'ai.cursor.notFound': 'No disponible',
+  'ai.cursor.path': 'Runtime:',
+  'ai.cursor.notFoundHint': 'Ingresa una clave de API para habilitar Cursor o cambia al inicio de sesión por CLI.',
+  'ai.cursor.notInstalledHint': 'No se detectó el SDK de Cursor ni la CLI de Agent.',
+  'ai.cursor.installStatus': 'Runtime de Cursor',
+  'ai.cursor.installed': 'Detectado',
+  'ai.cursor.notInstalled': 'No detectado',
+  'ai.cursor.modeCli': 'Inicio de sesión por CLI',
+  'ai.cursor.modeApiKey': 'Clave de API',
+  'ai.cursor.modeCliHint': 'Usa tu sesión local de `cursor-agent login` y la cuota Automática de la suscripción. La clave de API guardada se conserva, pero no se usa en este modo.',
+  'ai.cursor.modeApiKeyHint': 'Usa la API de Cursor medida. El inicio de sesión por CLI se ignora mientras este modo esté activo.',
+  'ai.cursor.cliLoginStatus': 'Inicio de sesión por CLI',
+  'ai.cursor.cliLoginOk': 'Sesión iniciada',
+  'ai.cursor.cliLoginAs': 'Sesión iniciada como {{email}}',
+  'ai.cursor.cliLoginMissing': 'Sin sesión iniciada',
+  'ai.cursor.cliLoginHint': 'Ejecuta `cursor-agent login` en una terminal y luego haz clic en Verificar.',
+  'ai.cursor.apiKeyStatus': 'Clave de API',
+  'ai.cursor.apiKeyConfigured': 'Configurada',
+  'ai.cursor.apiKeyMissing': 'Faltante',
+  'ai.cursor.apiKeyFromEnv': 'Desde el entorno',
+  'ai.cursor.apiKey': 'Clave de API',
+  'ai.cursor.apiKeyPlaceholder': 'Ingresa la clave de API de Cursor',
+  'ai.cursor.apiKeyPlaceholder.env': 'Usando CURSOR_API_KEY; ingresa una clave para anularla',
+  'ai.cursor.apiKeyEnvHint': 'Cursor puede usar CURSOR_API_KEY de tu shell. Guarda una clave aquí solo si quieres que Netcatty la anule.',
+  'ai.cursor.apiKeyOverrideHint': 'Netcatty usará la clave guardada aquí antes que CURSOR_API_KEY.',
+  'ai.cursor.saveApiKey': 'Guardar',
+  'ai.cursor.saved': 'Guardada',
+  'ai.cursor.showApiKey': 'Mostrar clave de API',
+  'ai.cursor.hideApiKey': 'Ocultar clave de API',
+  'ai.cursor.customPathPlaceholder': 'p. ej. /usr/local/bin/cursor',
+  'ai.cursor.check': 'Verificar',
+
+  // AI CodeBuddy Code
+  'ai.codebuddy.title': 'CodeBuddy Code',
+  'ai.codebuddy.description': 'Usa CodeBuddy Code mediante el SDK oficial de Agent (`@tencent-ai/agent-sdk`). Una vez detectado, se puede seleccionar como agente de codificación externo.',
+  'ai.codebuddy.detecting': 'Detectando...',
+  'ai.codebuddy.detected': 'Detectado',
+  'ai.codebuddy.notFound': 'No encontrado',
+  'ai.codebuddy.path': 'Ruta:',
+  'ai.codebuddy.notFoundHint': 'No se pudo encontrar codebuddy en el PATH. Instálalo o especifica la ruta del ejecutable a continuación.',
+  'ai.codebuddy.customPathPlaceholder': 'p. ej. /usr/local/bin/codebuddy',
+  'ai.codebuddy.check': 'Verificar',
+  'ai.codebuddy.resetPath': 'Restablecer',
+  'ai.codebuddy.configSection': 'Autenticación y configuración (opcional)',
+  'ai.codebuddy.internetEnv': 'Entorno de Internet',
+  'ai.codebuddy.internetEnv.default': 'Predeterminado (internacional)',
+  'ai.codebuddy.internetEnv.internal': 'Interno',
+  'ai.codebuddy.internetEnv.ioa': 'IOA',
+  'ai.codebuddy.internetEnv.hint': 'Define CODEBUDDY_INTERNET_ENVIRONMENT: elige Interno o IOA para entornos de red restringidos.',
+  'ai.codebuddy.envVars': 'Variables de entorno',
+  'ai.codebuddy.envVars.placeholder': 'CODEBUDDY_API_KEY=...\nCODEBUDDY_AUTH_TOKEN=...\nOTHER_VAR=...',
+  'ai.codebuddy.envVars.hint': 'Una KEY=VALUE por línea, pasada al agente de CodeBuddy. Define CODEBUDDY_API_KEY o CODEBUDDY_AUTH_TOKEN aquí para la autenticación. Se almacena localmente en texto plano.',
+  'ai.codebuddy.advancedSection': 'Opciones avanzadas (SDK 0.3.230)',
+  'ai.codebuddy.effort': 'Esfuerzo de razonamiento',
+  'ai.codebuddy.effort.default': 'Predeterminado',
+  'ai.codebuddy.effort.low': 'Bajo',
+  'ai.codebuddy.effort.medium': 'Medio',
+  'ai.codebuddy.effort.high': 'Alto',
+  'ai.codebuddy.effort.xhigh': 'XHigh',
+  'ai.codebuddy.effort.hint': 'Controla la profundidad de razonamiento del modelo. Usa Bajo para comandos simples y ahorrar tokens, y Alto/XHigh para diagnósticos complejos.',
+  'ai.codebuddy.maxTurns': 'Máximo de turnos',
+  'ai.codebuddy.maxTurns.hint': 'Limita el máximo de turnos de conversación por petición para evitar bucles descontrolados. Déjalo vacío para usar el predeterminado.',
+  'ai.codebuddy.maxBudget': 'Presupuesto máximo (USD)',
+  'ai.codebuddy.maxBudget.hint': 'Gasto máximo (USD) por petición. Se detiene automáticamente al superarse. Déjalo vacío para no tener límite.',
+  'ai.codebuddy.sandbox': 'Modo sandbox',
+  'ai.codebuddy.sandbox.hint': 'Ejecuta llamadas a herramientas en un sandbox, restringiendo el acceso al sistema de archivos y a la red.',
+  'ai.codebuddy.fileCheckpointing': 'Puntos de control de archivos',
+  'ai.codebuddy.fileCheckpointing.hint': 'Habilita puntos de control de operaciones de archivos para poder revertir las modificaciones de IA a los archivos.',
+  'ai.codebuddy.elicitation.title': 'CodeBuddy necesita tu aporte',
+  'ai.codebuddy.elicitation.description': 'Revisa la petición para continuar el turno actual.',
+  'ai.codebuddy.elicitation.select': 'Selecciona una opción',
+  'ai.codebuddy.elicitation.yes': 'Sí',
+  'ai.codebuddy.elicitation.no': 'No',
+  'ai.codebuddy.elicitation.decline': 'Rechazar',
+  'ai.codebuddy.elicitation.accept': 'Continuar',
+  'ai.codebuddy.elicitation.validation.required': '{field} es obligatorio.',
+  'ai.codebuddy.elicitation.validation.invalidType': '{field} tiene un valor no válido.',
+  'ai.codebuddy.elicitation.validation.integer': '{field} debe ser un número entero.',
+  'ai.codebuddy.elicitation.validation.notInteger': '{field} debe ser un número entero.',
+  'ai.codebuddy.elicitation.validation.minimum': '{field} debe ser al menos {limit}.',
+  'ai.codebuddy.elicitation.validation.maximum': '{field} debe ser como máximo {limit}.',
+  'ai.codebuddy.elicitation.validation.minLength': '{field} debe contener al menos {limit} caracteres.',
+  'ai.codebuddy.elicitation.validation.maxLength': '{field} debe contener como máximo {limit} caracteres.',
+  'ai.codebuddy.elicitation.validation.minItems': 'Selecciona al menos {limit} opciones para {field}.',
+  'ai.codebuddy.elicitation.validation.maxItems': 'Selecciona como máximo {limit} opciones para {field}.',
+  'ai.codebuddy.elicitation.validation.format': '{field} debe coincidir con el formato {format}.',
+  'ai.codebuddy.elicitation.validation.option': 'Selecciona una opción válida para {field}.',
+
+  // AI OpenCode
+  'ai.opencode.title': 'OpenCode',
+  'ai.opencode.description': 'Usa OpenCode mediante el SDK oficial. Configura proveedores y claves en OpenCode y luego selecciónalo como agente de codificación externo.',
+  'ai.opencode.detecting': 'Detectando...',
+  'ai.opencode.detected': 'Detectado',
+  'ai.opencode.notFound': 'No encontrado',
+  'ai.opencode.path': 'Ruta:',
+  'ai.opencode.notFoundHint': 'No se pudo encontrar opencode en el PATH. Instálalo o especifica la ruta del ejecutable a continuación.',
+  'ai.opencode.customPathPlaceholder': 'p. ej. /usr/local/bin/opencode',
+  'ai.opencode.check': 'Verificar',
+  'ai.opencode.resetPath': 'Restablecer',
+
+  // AI Grok Build (in-app managed agent — distinct from External MCP client install)
+  'ai.grok.title': 'Grok Build',
+  'ai.grok.description': "La CLI de agente de codificación Grok Build de xAI. Instala la CLI de Grok, inicia sesión con `grok login` o define XAI_API_KEY, y luego selecciónala como agente externo.",
+  'ai.grok.detecting': 'Detectando...',
+  'ai.grok.detected': 'Detectado',
+  'ai.grok.notFound': 'No encontrado',
+  'ai.grok.path': 'Ruta:',
+  'ai.grok.notFoundHint': 'No se pudo encontrar grok en el PATH. Instala la CLI de Grok Build o especifica la ruta del ejecutable a continuación.',
+  'ai.grok.customPathPlaceholder': 'p. ej. /usr/local/bin/grok',
+  'ai.grok.check': 'Verificar',
+  'ai.grok.resetPath': 'Restablecer',
+  'ai.grok.runtime.acp.title': 'Usar Grok ACP (agente stdio)',
+  'ai.grok.runtime.acp.default': 'Predeterminado',
+  'ai.grok.runtime.acp.description':
+    'Habla con Grok mediante el Protocolo de Cliente de Agente (grok agent stdio). Inyecta el MCP de Netcatty en session/new. Apágalo para usar la ruta original de CLI headless con streaming-json.',
+  'ai.grok.runtime.streamingJson.hint':
+    'Usando streaming-json headless (grok -p --output-format streaming-json). El archivo .grok/config.toml del proyecto se usa para la inyección de MCP.',
+
+  // AI Default Agent
+  'ai.defaultAgent': 'Agente predeterminado',
+  'ai.defaultAgent.description': 'Agente que se usará al iniciar una nueva sesión de IA',
+  'ai.defaultAgent.catty': 'Catty (Integrado)',
+  'ai.toolAccess.title': 'Acceso a herramientas',
+  'ai.toolAccess.mode': 'Modo de acceso de Netcatty',
+  'ai.toolAccess.description': 'Elige cómo acceden los agentes externos a las sesiones de Netcatty. MCP expone el servidor integrado, mientras que Habilidades + CLI apunta a los agentes hacia las habilidades locales de Netcatty y los comandos de CLI.',
+  'ai.toolAccess.mode.mcp': 'MCP',
+  'ai.toolAccess.mode.skills': 'Habilidades + CLI',
+
+  // External MCP (productized catalog MCP for Codex / Claude Code / Cursor)
+  'ai.externalMcp.title': 'MCP externo',
+  'ai.externalMcp.description': 'Expón Netcatty como un servidor MCP para clientes externos como Codex, Claude Code, Cursor y Grok. Usa las mismas herramientas del catálogo que los agentes de la aplicación (terminal, SFTP, Vault, reenvío de puertos). Mantén Netcatty en ejecución mientras los clientes estén conectados.',
+  'ai.externalMcp.sessionsExposed': 'Sesiones en alcance: {count}',
+  'ai.externalMcp.mode': 'Modo de disponibilidad',
+  'ai.externalMcp.mode.temporary': 'Temporal',
+  'ai.externalMcp.mode.persistent': 'Siempre activo',
+  'ai.externalMcp.mode.description': 'El modo temporal se desactiva automáticamente tras el tiempo de inactividad. El modo Siempre activo restaura el MCP externo cuando se inicia Netcatty.',
+  'ai.externalMcp.idleTimeout': 'Tiempo de inactividad',
+  'ai.externalMcp.idleTimeout.description': 'En modo temporal, desactiva el MCP externo después de esta cantidad de minutos sin operaciones de MCP.',
+  'ai.externalMcp.idleTimeout.minutes': 'min',
+  'ai.externalMcp.focusOnHostOpen': 'Enfocar ventana en host_open',
+  'ai.externalMcp.focusOnHostOpen.description': 'Cuando un cliente de MCP abre un host, trae la ventana principal al frente. Apágalo para seguir trabajando sin interrupciones.',
+  'ai.externalMcp.silentSessions': 'Sesiones MCP silenciosas',
+  'ai.externalMcp.silentSessions.description': 'Las sesiones abiertas por la IA se mantienen fuera de tu barra de pestañas y no se restauran tras reiniciar. Puedes verlas en cualquier momento desde el panel de la bandeja.',
+  'ai.externalMcp.sessionIdleTimeout': 'Tiempo de inactividad de la sesión abierta',
+  'ai.externalMcp.sessionIdleTimeout.description': 'Cierra automáticamente las sesiones abiertas por una IA después de esta cantidad de minutos sin actividad de terminal o archivos.',
+  'ai.externalMcp.usage.title': 'Cómo usarlo',
+  'ai.externalMcp.usage.keepRunning': '1. Activa el MCP externo y mantén Netcatty en ejecución.',
+  'ai.externalMcp.usage.localhost': '2. Los clientes se conectan mediante el launcher local (solo 127.0.0.1). El descubrimiento se elimina cuando desactivas el interruptor.',
+  'ai.externalMcp.usage.permissions': '3. Las operaciones de escritura siguen Configuración → IA → Seguridad (observador / confirmar / automático) y la lista de bloqueo de comandos.',
+  'ai.externalMcp.usage.capabilities': '4. Todas las herramientas del catálogo están disponibles: terminal, SFTP, Vault y reenvío de puertos. Los secretos (contraseñas / claves privadas) nunca se devuelven.',
+  'ai.externalMcp.help.ariaLabel': 'Ayuda del MCP externo',
+  'ai.externalMcp.security': 'Seguridad',
+  'ai.externalMcp.security.description': 'Escucha en 127.0.0.1 con un token rotativo, reutiliza el modo de permisos de IA para las escrituras y elimina el descubrimiento al desactivarse. Sin OAuth: este es un puente local de escritorio.',
+  'ai.externalMcp.permissionMode': 'Modo de permisos actual: {mode}',
+  'ai.externalMcp.permissionMode.label': 'Modo de permiso de escritura',
+  'ai.externalMcp.permissionMode.hint': 'La misma configuración que Configuración → IA → Seguridad. Automático ejecuta las herramientas de escritura de Netcatty sin solicitar aprobación de Netcatty; Confirmar pregunta cada vez. Los clientes externos (Codex / Claude / Grok) aún pueden mostrar su propia interfaz de aprobación de herramientas.',
+  'ai.externalMcp.permissionMode.unknown': 'Desconocido',
+  'ai.externalMcp.discovery': 'Descubrimiento',
+  'ai.externalMcp.launcher': 'Launcher',
+  'ai.externalMcp.unavailable': 'No disponible',
+  'ai.externalMcp.bridgeUnavailable': 'Puente de MCP externo no disponible',
+  'ai.externalMcp.copy': 'Copiar',
+  'ai.externalMcp.copied': 'Copiado',
+  'ai.externalMcp.copyFailed': 'No se pudo copiar. Intenta copiarlo manualmente.',
+  'ai.externalMcp.refresh': 'Actualizar',
+  'ai.externalMcp.clientConfiguration': 'Configuración del cliente',
+  'ai.externalMcp.clientConfiguration.description': 'Elige un cliente para instalarlo con un clic, o copia fragmentos de CLI o configuración.',
+  'ai.externalMcp.client.codex': 'Codex',
+  'ai.externalMcp.client.claude': 'Claude Code',
+  'ai.externalMcp.client.grok': 'Grok',
+  'ai.externalMcp.client.cursor': 'Cursor',
+  'ai.externalMcp.cliCommand': 'Comando CLI',
+  'ai.externalMcp.configSnippet': 'Fragmento de configuración',
+  'ai.externalMcp.addToCodex': 'Agregar a Codex',
+  'ai.externalMcp.addToClaude': 'Agregar a Claude Code',
+  'ai.externalMcp.addToGrok': 'Agregar a Grok',
+  'ai.externalMcp.codexAdded': 'Entrada de MCP de Codex agregada. Reinicia Codex o abre una nueva sesión de Codex.',
+  'ai.externalMcp.claudeAdded': 'Entrada de MCP de Claude Code agregada. Reinicia Claude Code o abre una nueva sesión de Claude Code.',
+  'ai.externalMcp.grokAdded': 'Entrada de MCP de Grok agregada. Reinicia Grok o abre una nueva sesión de Grok.',
+  'ai.externalMcp.installCodex': 'Instala Codex por separado y luego haz clic en Actualizar.',
+  'ai.externalMcp.installClaude': 'Instala Claude Code por separado y luego haz clic en Actualizar.',
+  'ai.externalMcp.installGrok': 'Instala la CLI de Grok por separado y luego haz clic en Actualizar.',
+  'ai.externalMcp.conflict.description': 'Ya existe una entrada netcatty-external que apunta a otro lugar. Quítala o edítala manualmente.',
+  'ai.externalMcp.enableForLauncher': 'Habilita el MCP externo para obtener una ruta de launcher utilizable.',
+  'ai.externalMcp.cursor.title': 'Cursor / otros clientes',
+  'ai.externalMcp.cursor.description': 'Combina esto en tu configuración de MCP (por ejemplo, ~/.cursor/mcp.json). No reemplaces todo el archivo si ya tienes otros servidores.',
+  'ai.externalMcp.status.unavailable': 'No disponible',
+  'ai.externalMcp.status.disabled': 'Desactivado',
+  'ai.externalMcp.status.running': 'En ejecución',
+  'ai.externalMcp.status.starting': 'Iniciando',
+  'ai.externalMcp.status.error': 'Error',
+  'ai.externalMcp.status.configured': 'Configurado',
+  'ai.externalMcp.status.notConfigured': 'No configurado',
+  'ai.externalMcp.status.checking': 'Comprobando',
+  'ai.externalMcp.status.codexNotFound': 'Codex no encontrado',
+  'ai.externalMcp.status.claudeNotFound': 'Claude Code no encontrado',
+  'ai.externalMcp.status.grokNotFound': 'Grok no encontrado',
+  'ai.externalMcp.status.conflict': 'Conflicto',
+  'ai.userSkills.title': 'Habilidades de usuario',
+  'ai.userSkills.description': 'Abre la carpeta de habilidades de Netcatty para agregar tus propios directorios de habilidades. Netcatty escanea estas habilidades automáticamente e inyecta solo índices ligeros, salvo que una habilidad coincida claramente con la petición actual.',
+  'ai.userSkills.openFolder': 'Abrir carpeta de habilidades',
+  'ai.userSkills.reload': 'Recargar habilidades',
+  'ai.userSkills.location': 'Ubicación',
+  'ai.userSkills.loading': 'Escaneando habilidades de usuario...',
+  'ai.userSkills.summary': '{ready} listas, {warnings} advertencias',
+  'ai.userSkills.empty': 'Aún no se encontraron habilidades de usuario. Abre la carpeta para agregar directorios de habilidades con un archivo SKILL.md.',
+  'ai.userSkills.unavailable': 'Las habilidades de usuario no están disponibles en este entorno.',
+  'ai.userSkills.status.ready': 'Lista',
+  'ai.userSkills.status.warning': 'Advertencia',
+
+  // AI Quick Messages
+  'ai.quickMessages.title': 'Mensajes rápidos',
+  'ai.quickMessages.description': 'Crea prompts reutilizables que puedes insertar desde el chat de IA con / o con el botón de mensajes rápidos. A diferencia de las habilidades de usuario, los mensajes rápidos llenan el compositor con texto.',
+  'ai.quickMessages.add': 'Agregar mensaje rápido',
+  'ai.quickMessages.createTitle': 'Nuevo mensaje rápido',
+  'ai.quickMessages.editTitle': 'Editar mensaje rápido',
+  'ai.quickMessages.name': 'Nombre',
+  'ai.quickMessages.name.placeholder': 'p. ej. Verificar espacio en disco',
+  'ai.quickMessages.slug': 'Comando',
+  'ai.quickMessages.slug.placeholder': 'disk-check',
+  'ai.quickMessages.descriptionField': 'Descripción (opcional)',
+  'ai.quickMessages.descriptionField.placeholder': 'Breve indicación sobre lo que hace este prompt',
+  'ai.quickMessages.content': 'Contenido del mensaje',
+  'ai.quickMessages.content.placeholder': 'Texto completo del prompt para insertar al seleccionarlo...',
+  'ai.quickMessages.empty': 'Aún no hay mensajes rápidos. Agrega algunos prompts que uses seguido.',
+  'ai.quickMessages.confirmDelete': '¿Eliminar el mensaje rápido "{name}"?',
+  'ai.quickMessages.error.nameRequired': 'El nombre es obligatorio.',
+  'ai.quickMessages.error.invalidSlug': 'El comando solo puede contener letras minúsculas, números y guiones.',
+  'ai.quickMessages.error.contentRequired': 'El contenido del mensaje es obligatorio.',
+  'ai.quickMessages.error.slugTaken': 'Este comando ya lo usa otro mensaje rápido.',
+  'ai.quickMessages.error.slugConflictsWithSkill': 'Este comando entra en conflicto con la habilidad de usuario "/{slug}". Elige otro.',
+  'ai.quickMessages.error.maxItems': 'Puedes guardar como máximo {max} mensajes rápidos.',
+
+  // AI Chat
+  'ai.chat.noProvider': 'No hay ningún proveedor de IA configurado. Ve a **Configuración → IA → Proveedores** para agregar y habilitar un proveedor.',
+  'ai.chat.toolDenied': 'La acción fue rechazada por el usuario.',
+  'ai.chat.toolApproved': 'Aprobado',
+  'ai.chat.toolApprovalHint': 'Presiona Enter una vez · Esc para rechazar',
+  'ai.chat.approve': 'Aprobar',
+  'ai.chat.approveOnce': 'Una vez',
+  'ai.chat.alwaysAllow': 'Siempre',
+  'ai.chat.slashStopDesc': 'Detener el turno actual de IA y cancelar las herramientas en curso',
+  'ai.chat.slashCompactDesc': 'Resumir el contexto anterior de la conversación',
+  'ai.chat.reject': 'Rechazar',
+  'ai.chat.toolLabel': 'Herramienta',
+  'ai.chat.targetLabel': 'Destino',
+  'ai.chat.rawCommand': 'Comando',
+  'ai.chat.copyCommand': 'Copiar',
+  'ai.chat.commandCopied': 'Copiado',
+  'ai.chat.approvalSession': 'Sesión',
+  'ai.chat.approvalShell': 'Shell',
+  'ai.chat.approvalCwd': 'Cwd',
+  'ai.chat.approvalReason': 'Motivo',
+  'ai.chat.approvalInvocation': 'Invocación',
+  'ai.chat.permissionRequired': 'Permiso requerido',
+  'ai.chat.permissionDescription': 'El agente de IA quiere ejecutar una llamada a una herramienta que requiere tu aprobación.',
+  'ai.chat.commandBlocked': 'Este comando está bloqueado por tu política de seguridad y no se puede ejecutar.',
+  'ai.chat.recommendAllow': 'Permitir',
+  'ai.chat.recommendConfirm': 'Confirmar',
+  'ai.chat.recommendDeny': 'Denegar',
+  'ai.chat.exportConversation': 'Exportar conversación',
+  'ai.chat.exportAs': 'Exportar como',
+  'ai.chat.exportMarkdown': 'Markdown',
+  'ai.chat.exportJSON': 'JSON',
+  'ai.chat.exportPlainText': 'Texto plano',
+  'ai.chat.thinking': 'Pensando',
+  'ai.chat.thoughtFor': 'Pensó durante {duration}',
+  'ai.chat.thought': 'Pensamiento',
+  'ai.chat.agents': 'Agentes',
+  'ai.chat.detectedOnMachine': 'Detectado en esta máquina',
+  'ai.chat.rescan': 'Volver a escanear',
+  'ai.chat.permObserver': 'Observador',
+  'ai.chat.permConfirm': 'Confirmar',
+  'ai.chat.permAuto': 'Automático',
+  'ai.chat.permObserverDesc': 'Solo lectura (Cursor CLI: Ask)',
+  'ai.chat.permConfirmDesc': 'Preguntar antes de que Netcatty escriba (Cursor CLI: agent + force)',
+  'ai.chat.permAutoDesc': 'Ejecutar libremente (Cursor CLI: agent + force)',
+  'ai.chat.emptyHint': 'Pregunta sobre tus servidores, ejecuta comandos u obtén ayuda con las configuraciones.',
+  'ai.chat.placeholder': 'Mensaje a {agent} — @ para incluir contexto, / para comandos',
+  'ai.chat.placeholderDefault': 'Mensaje al agente Catty...',
+  'ai.chat.noModel': 'Sin modelo',
+  'ai.chat.noProviderModel': 'No hay modelo predeterminado: define uno en Configuración → IA → Proveedores.',
+  'ai.chat.selectProvider': 'Seleccionar proveedor',
+  'ai.chat.recent': 'Recientes',
+  'ai.chat.viewAll': 'Ver todo',
+  'ai.chat.untitled': 'Sin título',
+  'ai.chat.justNow': 'Ahora mismo',
+  'ai.chat.minutesAgo': 'hace {n} min',
+  'ai.chat.hoursAgo': 'hace {n} h',
+  'ai.chat.daysAgo': 'hace {n} d',
+  'ai.chat.newChat': 'Nuevo chat',
+  'ai.chat.allSessions': 'Todas las sesiones',
+  'ai.chat.loadEarlierMessages': 'Cargar mensajes anteriores ({n} más)',
+  'ai.chat.jumpNav': 'Ir al mensaje',
+  'ai.chat.jumpUntitled': '(mensaje vacío)',
+  'ai.chat.usedTools': 'Herramientas usadas: {n}',
+  'ai.chat.loadMoreSessions': 'Cargar más sesiones ({n} más)',
+  'ai.chat.noSessions': 'No hay sesiones anteriores',
+  'ai.chat.retryHint': 'Puedes reintentar enviando tu mensaje de nuevo.',
+  'ai.chat.approvalTimeout': 'La aprobación de la herramienta expiró después de 5 minutos. Puedes reintentar enviando tu mensaje de nuevo.',
+  'ai.chat.menuHosts': 'Hosts',
+  'ai.chat.menuContext': 'Contexto',
+  'ai.chat.menuFiles': 'Archivos',
+  'ai.chat.menuImage': 'Imagen',
+  'ai.chat.menuMentionHost': 'Mencionar host',
+  'ai.chat.menuUserSkills': 'Habilidades de usuario',
+  'ai.chat.menuSlashCommands': 'Comandos de barra',
+  'ai.chat.slashCommands': 'Comandos de barra',
+  'ai.chat.slashSystemCommands': 'Comandos',
+  'ai.chat.slashQuickMessages': 'Mensajes rápidos',
+  'ai.chat.slashUserSkills': 'Habilidades de usuario',
+  'ai.chat.quickMessages': 'Comandos de barra',
+  'ai.chat.slashNoResults': 'No hay comandos que coincidan',
+  'ai.chat.slashEmptyHint': 'Agrega prompts en Configuración → IA → Mensajes rápidos.',
+
+  // AI Chat Shortcuts
+  'ai.chatShortcuts.title': 'Atajos de chat',
+  'ai.chatShortcuts.selectionAction': 'Mostrar "Agregar a la conversación" al seleccionar texto de la terminal',
+  'ai.chatShortcuts.selectionAction.description': 'Muestra un pequeño botón de IA junto al texto seleccionado de la terminal.',
+
+  // AI Error
+  'ai.codex.bridgeError': 'Los controladores del proceso principal de Codex aún no están cargados. Reinicia Netcatty por completo o reinicia el proceso de desarrollo de Electron y vuelve a intentarlo.',
+
+  // AI Web Search
+  'ai.webSearch.title': 'Búsqueda web',
+  'ai.webSearch.enable': 'Habilitar búsqueda web',
+  'ai.webSearch.enable.description': 'Permite que el agente de IA busque en la web información actual.',
+  'ai.webSearch.provider': 'Proveedor de búsqueda',
+  'ai.webSearch.provider.description': 'Elige un proveedor de API de búsqueda web.',
+  'ai.webSearch.apiKey': 'Clave de API',
+  'ai.webSearch.apiKey.description': 'Clave de API para el proveedor de búsqueda seleccionado.',
+  'ai.webSearch.apiKey.placeholder': 'Ingresa la clave de API...',
+  'ai.webSearch.apiHost': 'Host de API',
+  'ai.webSearch.apiHost.description': 'Endpoint de API personalizado. Deja el predeterminado salvo que uses un proxy.',
+  'ai.webSearch.apiHost.searxngDescription': 'URL de tu instancia de SearXNG (obligatoria).',
+  'ai.webSearch.maxResults': 'Máximo de resultados',
+  'ai.webSearch.maxResults.description': 'Cantidad máxima de resultados de búsqueda a devolver (1-20).',
+
+  // AI Safety Settings
+  'ai.safety.title': 'Seguridad',
+  'ai.safety.permissionMode': 'Modo de permisos',
+  'ai.safety.permissionMode.description': 'Controla cómo interactúa la IA con tus sesiones de terminal de Netcatty. El modo Observador bloquea las operaciones de escritura que pasan por Netcatty. Las CLIs de agentes externos pueden seguir teniendo sus propias herramientas locales y flujo de aprobación.',
+  'ai.safety.permissionMode.observer': 'Observador: solo lectura, sin acciones',
+  'ai.safety.permissionMode.confirm': 'Confirmar: preguntar antes de las acciones',
+  'ai.safety.permissionMode.auto': 'Automático: ejecutar libremente',
+  'ai.safety.commandTimeout': 'Tiempo de espera de comandos',
+  'ai.safety.commandTimeout.description': 'Máximo de segundos que un comando puede ejecutarse antes de ser terminado mediante la ejecución de Netcatty.',
+  'ai.safety.commandTimeout.unit': 'seg',
+  'ai.safety.maxIterations': 'Máximo de iteraciones',
+  'ai.safety.maxIterations.description': 'Máximo de bucles de uso de herramientas de IA para evitar una ejecución descontrolada. Los agentes externos pueden tener sus propios límites de iteración internos que tienen prioridad.',
+  'ai.safety.blocklist': 'Lista de bloqueo de comandos',
+  'ai.safety.blocklist.description': 'Patrones regex para bloquear comandos peligrosos ejecutados mediante Netcatty.',
+  'ai.safety.blocklist.placeholder': 'Patrón regex...',
+  'ai.safety.blocklist.reset': 'Restablecer a los valores predeterminados',
+  'ai.safety.blocklist.add': 'Agregar patrón',
+  'ai.safety.grants.title': 'Memoria de permisos',
+  'ai.safety.grants.heading': 'Reglas de permitir en modo Confirmar',
+  'ai.safety.grants.description': 'El modo Confirmar pregunta antes de ejecutar una operación. Las reglas guardadas permiten automáticamente las operaciones que coinciden en todas las sesiones/nodos de terminal, y se pueden editar manualmente.',
+  'ai.safety.grants.empty': 'Aún no hay reglas guardadas. Aprueba una herramienta con "Permitir siempre" o agrega una manualmente.',
+  'ai.safety.grants.capability': 'Capacidad',
+  'ai.safety.grants.sessionPattern': 'Patrón de sesión',
+  'ai.safety.grants.commandPattern': 'Patrón de comando (opcional)',
+  'ai.safety.grants.note': 'Nota (opcional)',
+  'ai.safety.grants.add': 'Agregar regla',
+  'ai.safety.grants.remove': 'Quitar',
+  'ai.safety.grants.export': 'Exportar JSON',
+  'ai.safety.grants.import': 'Importar JSON',
+  'ai.safety.note': 'Estos ajustes de seguridad se aplican a las acciones que pasan por Netcatty. Las CLIs de agentes externos también pueden exponer herramientas locales regidas por el propio agente.',
+
+  // Unified tooltips for terminal workspace and top tabs (issue #954)
+  'terminal.layer.addTerminal': 'Agregar terminal',
+  'terminal.layer.switchToSplitView': 'Cambiar a vista dividida',
+  'terminal.layer.sftp': 'SFTP',
+  'terminal.layer.scripts': 'Scripts',
+  'terminal.layer.history': 'Historial',
+  'terminal.layer.theme': 'Tema',
+  'terminal.layer.notes': 'Notas',
+  'terminal.layer.aiChat': 'Chat de IA',
+  'terminal.layer.movePanelLeft': 'Mover panel a la izquierda',
+  'terminal.layer.movePanelRight': 'Mover panel a la derecha',
+  'terminal.layer.closePanel': 'Cerrar panel',
+  'terminal.layer.closePane': 'Cerrar división',
+  'terminal.layer.resizeSplit': 'Redimensionar división',
+  '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.hostTree.search': 'Buscar hosts...',
+  'terminal.layer.hostTree.searchButton': 'Buscar',
+  'terminal.layer.hostTree.tagsButton': 'Filtrar por etiquetas',
+  'terminal.layer.hostTree.newHost': 'Nuevo host',
+  'terminal.layer.hostTree.newHostInGroup': 'Nuevo host en este grupo',
+  'terminal.layer.hostTree.editHost': 'Editar host',
+  'terminal.layer.hostTree.hostSavedNextConnection': 'Host actualizado. Los ajustes de conexión se aplicarán la próxima vez que te conectes.',
+  'terminal.layer.hostTree.newGroup': 'Nuevo grupo',
+  'terminal.layer.hostTree.localShell': 'Shell local',
+  'terminal.layer.hostTree.tagsEmpty': 'No hay etiquetas disponibles',
+  'terminal.layer.hostTree.clearTags': 'Borrar selección',
+  'terminal.layer.hostTree.collapse': 'Contraer lista de hosts',
+  'terminal.layer.hostTree.expand': 'Expandir lista de hosts',
+  'terminal.layer.hostTree.empty': 'No se encontraron hosts',
+  'terminal.layer.hostTree.details.host': 'Host',
+  'terminal.layer.hostTree.details.user': 'Usuario',
+  'terminal.layer.hostTree.details.port': 'Puerto',
+  'terminal.layer.hostTree.details.protocol': 'Protocolo',
+  'terminal.layer.hostTree.details.group': 'Grupo',
+  'terminal.layer.hostTree.details.tags': 'Etiquetas',
+  'terminal.layer.hostTree.details.lastConnected': 'Última conexión',
+  'topTabs.openQuickSwitcher': 'Abrir selector rápido',
+  'topTabs.moreTabs': 'Más pestañas',
+  'topTabs.aiAssistant': 'Asistente de IA',
+  'topTabs.newLocalTerminal': 'Nueva terminal local',
+  'topTabs.controlPanel': 'Controles rápidos',
+  'topTabs.controlPanel.externalMcp': 'MCP externo',
+  'topTabs.controlPanel.theme': 'Tema',
+  'topTabs.controlPanel.theme.light': 'Claro',
+  'topTabs.controlPanel.theme.dark': 'Oscuro',
+  'topTabs.controlPanel.theme.system': 'Sistema',
+  'topTabs.externalMcp.enable': 'Habilitar MCP externo',
+  'topTabs.externalMcp.disable': 'Desactivar MCP externo',
+  'topTabs.windowOpacity': 'Opacidad de la ventana',
+  'topTabs.openSettings': 'Abrir Configuración',
+  'ai.chat.sessionHistory': 'Historial de sesiones',
+  'ai.chat.resizeInput': 'Arrastra para redimensionar el campo de mensaje',
+  'ai.chat.attach': 'Adjuntar',
+  'ai.chat.terminalSelectionAttachment': 'Selección de la terminal',
+  'ai.chat.terminalSelectionLines': 'líneas: {count}',
+  'ai.chat.collapse': 'Contraer',
+  'ai.chat.expand': 'Expandir',
+  'ai.chat.enableAgent': 'Habilitar {name}',
+  'ai.chat.artifact.noteFallback': 'Nota de Vault',
+  'ai.chat.artifact.openNotes': 'Abrir Notas',
+  'ai.chat.artifact.openHosts': 'Abrir Hosts',
+  'ai.chat.artifact.notesSummary': '{count} notas en Vault',
+  'ai.chat.artifact.hostsSummary': '{count} hosts en Vault',
+  'ai.chat.artifact.hostsAdded': 'Se agregaron {count} hosts',
+  'ai.chat.artifact.hostsPreview': 'Vista previa de {count} hosts',
+  'ai.chat.artifact.failed': 'La operación de Vault falló',
+  'ai.chat.artifact.unavailableTitle': 'No disponible',
+  'ai.chat.artifact.noteMissing': 'Esta nota ya no está en tu Vault.',
+  'ai.chat.artifact.hostMissing': 'Este host ya no está en tu Vault.',
+  'ai.chat.artifact.snippetMissing': 'Este snippet o script ya no está en tu Vault.',
+  'ai.chat.artifact.openSnippets': 'Abrir Snippets',
+  'ai.chat.artifact.snippetsSummary': '{count} snippets en Vault',
+  'ai.chat.artifact.scriptsSummary': '{count} scripts en Vault',
+  'ai.chat.artifact.snippetFallback': 'Snippet de Vault',
+  'ai.chat.artifact.scriptFallback': 'Script de automatización',
+  'ai.chat.artifact.scriptLanguage': 'Script de {language}',
+  'ai.chat.artifact.snippetDeleted': 'Snippet eliminado',
+  'ai.chat.artifact.scriptDeleted': 'Script eliminado',
+  'ai.chat.artifact.snippetRan': 'Snippet ejecutado',
+  'ai.chat.artifact.scriptStarted': 'Se inició la ejecución del script',
+  'ai.chat.artifact.scriptRunStatus': 'Ejecución del script: {status}',
+  'ai.chat.artifact.scriptRunsSummary': '{count} ejecuciones de scripts',
+  'ai.chat.artifact.scriptRunStopped': 'Ejecución del script detenida',
+  'ai.chat.artifact.scriptRunPaused': 'Ejecución del script en pausa',
+  'ai.chat.artifact.scriptRunResumed': 'Ejecución del script reanudada',
+  'ai.chat.artifact.scriptReference': 'referencia de la API de nct',
+  'zmodem.waitingForRemote': 'Esperando al servidor remoto...',
+  'zmodem.uploading': 'Subiendo',
+  'zmodem.downloading': 'Descargando',
+  'zmodem.cancelTransfer': 'Cancelar transferencia (Ctrl+C)',
+  'zmodem.overwrite.title': 'El archivo remoto ya existe',
+  'zmodem.overwrite.applyToRest': 'Aplicar a los conflictos restantes',
+  'zmodem.overwrite.overwrite': 'Sobrescribir',
+  'zmodem.overwrite.skip': 'Omitir',
+  'zmodem.overwrite.cancel': 'Cancelar',
+  'settings.shortcuts.resetToDefault': 'Restablecer al predeterminado',
+};

application/i18n/locales/es/scripts.ts

@@ -0,0 +1,133 @@
+export const esScriptsMessages = {
+  'scripts.meta.name': 'Nombre',
+  'scripts.meta.language': 'Lenguaje',
+  'scripts.meta.description': 'Descripción',
+  'scripts.meta.descriptionPlaceholder': 'Notas opcionales sobre este script',
+  'scripts.meta.trigger': 'Disparador',
+  'scripts.meta.triggerPattern': 'Patrón de salida (regex)',
+  'scripts.meta.code': 'Script',
+  'scripts.trigger.manual': 'Ejecución manual',
+  'scripts.trigger.onConnect': 'Ejecutar al conectar',
+  'scripts.trigger.onOutput': 'Ejecutar al coincidir con la salida',
+  'scripts.trigger.onOutputHint': 'Se dispara cuando la salida del servidor coincide con el patrón (el eco de las teclas del usuario se ignora). Sin hosts de destino configurados, escucha en la sesión conectada actual; con hosts de destino, solo en esos hosts. Deshabilitado en aplicaciones de pantalla alterna como vim o htop. Se suprime mientras otro script se ejecuta en esta sesión; se vuelve a revisar cuando termina. Para esperas dentro del flujo, usa nct.screen.waitForText o nct.screen.waitForRegex en el código del script.',
+  'scripts.actions.save': 'Guardar',
+  'scripts.actions.runNow': 'Ejecutar ahora',
+  'scripts.actions.openEditor': 'Abrir editor',
+  'scripts.actions.openEditorHint': 'Editar el script en una ventana más grande',
+  'scripts.editor.modalTitle': 'Editor de scripts',
+  'scripts.editor.modalSubtitle': 'Edita los metadatos y el código del script en un espacio de trabajo más amplio.',
+  'scripts.editor.lineCount': '{count} líneas',
+  'scripts.editor.resize': 'Redimensionar el editor',
+  'scripts.targets.hint': 'Los grupos seleccionados se resuelven dinámicamente, por lo que los hosts agregados después se incluyen automáticamente.',
+  'scripts.targets.connectOrderHint': 'El orden de ejecución de los scripts de conexión se configura por host en Detalles del host → Automatización.',
+  'scripts.targets.currentHostMismatch': 'Este script no está asignado al host actual.',
+  'hostDetails.automation.groupScripts': 'Scripts de grupo heredados',
+  'hostDetails.automation.groupScriptsHint': 'Estos scripts siguen al grupo del host dinámicamente y se ordenan antes de la cola específica del host.',
+  'scripts.actions.runNowHint': 'Ejecutar en los destinos seleccionados, o en todos los hosts conectables cuando esa opción está habilitada.',
+  'scripts.actions.runParallel': 'Ejecutar en todas las pestañas (en paralelo)',
+  'scripts.actions.runSequential': 'Ejecutar en todas las pestañas (en secuencia)',
+  'scripts.actions.runOnAllTabs': 'Ejecutar en todas las pestañas',
+  'scripts.actions.skippedConnectingSessions': '{count} pestaña(s) aún conectándose y fueron omitidas',
+  'scripts.actions.skippedSensitiveSessions': '{count} pestaña(s) omitidas (entrada de contraseña/datos sensibles)',
+  'scripts.actions.noRunnableHosts': 'Ningún host conectable coincide con los destinos de este script',
+  'scripts.sidePanel.library': 'Biblioteca',
+  'scripts.sidePanel.running': 'En ejecución',
+  'scripts.sidePanel.newScript': 'Nuevo script',
+  'scripts.running.empty': 'No hay scripts en ejecución en esta sesión.',
+  'scripts.running.unnamed': 'Script sin título',
+  'scripts.running.status.running': 'En ejecución',
+  'scripts.running.status.paused': 'En pausa',
+  'scripts.running.status.completed': 'Completado',
+  'scripts.running.status.failed': 'Falló',
+  'scripts.running.waitingFor': 'Esperando {pattern}',
+  'scripts.running.waitingForLabel': 'Esperando',
+  'scripts.running.waitingForShellPrompt': 'indicador del shell (# o $)',
+  'scripts.running.lastSent': 'Enviado: {command}',
+  'scripts.recording.start': 'Comenzar grabación',
+  'scripts.recording.active': 'Detener grabación',
+  'scripts.recording.startHint': 'Graba las acciones en la terminal enfocada y genera código de script nct',
+  'scripts.recording.unavailableHint': 'La grabación no está disponible aquí — usa la barra lateral de scripts a la derecha',
+  'scripts.recording.activeHint': 'Grabando esta terminal. Escribe comandos como de costumbre; haz clic en Detener o usa el control REC en la barra de herramientas para finalizar y guardar.',
+  'scripts.recording.started': 'Grabación iniciada — opera en la terminal',
+  'scripts.recording.noSession': 'Conecta una terminal primero (pestaña única o espacio de trabajo)',
+  'scripts.recording.alreadyActive': 'Otra terminal ya está grabando',
+  'scripts.recording.stop': 'Detener grabación',
+  'scripts.recording.pause': 'Pausar grabación',
+  'scripts.recording.resume': 'Reanudar grabación',
+  'scripts.recording.saveTitle': 'Guardar script grabado',
+  'scripts.recording.namePlaceholder': 'Nombre del script',
+  'scripts.recording.packagePlaceholder': 'Guardar en carpeta',
+  'scripts.recording.rootPackage': 'Raíz',
+  'scripts.recording.save': 'Guardar',
+  'scripts.recording.saveAndEdit': 'Guardar y editar',
+  'scripts.recording.helpTitle': 'Cómo grabar un script',
+  'scripts.recording.helpIntro': 'La grabación convierte lo que haces en la terminal en un script de automatización reutilizable — útil para despliegues, verificaciones de salud y otras tareas repetitivas.',
+  'scripts.recording.helpStep1': 'Conecta a un host. Una pestaña de terminal independiente o una terminal dentro de un espacio de trabajo funcionan igual — abre la barra lateral de scripts a la derecha.',
+  'scripts.recording.helpStep2': 'Haz clic en Comenzar grabación. Una insignia REC roja en la barra de herramientas de la terminal indica que la grabación está activa.',
+  'scripts.recording.helpStep3': 'Escribe comandos en la terminal como lo harías normalmente. Cada pulsación de Enter se captura como un paso.',
+  'scripts.recording.helpStep4': 'Cuando termines, haz clic en Detener grabación, o usa el control de detención junto a REC en la barra de herramientas de la terminal.',
+  'scripts.recording.helpStep5': 'Nombra el script y guárdalo. Elige Guardar y editar si quieres ajustar el código generado en el editor de scripts.',
+  'scripts.recording.helpTipsTitle': 'Consejos',
+  'scripts.recording.helpTip1': 'Las pausas de más de 1 segundo entre acciones se registran como tiempo de espera para que la reproducción no sea demasiado rápida.',
+  'scripts.recording.helpTip2': 'Después de cada comando, la grabación espera un indicador del shell (como $ o #) antes del siguiente paso.',
+  'scripts.recording.helpTip3': 'La entrada de contraseñas se marca como sensible y no se almacena en texto plano en el script.',
+  'scripts.recording.helpTip4': 'Para vim, menús u otros flujos interactivos, graba primero los comandos principales y luego refina el script manualmente.',
+  'scripts.dialog.title': 'Script',
+  'scripts.dialog.ok': 'Aceptar',
+  'scripts.dialog.required': 'Obligatorio',
+  'scripts.dialog.numberInvalid': 'Ingresa un número válido',
+  'scripts.dialog.numberMin': 'Debe ser al menos {min}',
+  'scripts.dialog.numberMax': 'Debe ser como máximo {max}',
+  'scripts.dialog.numberStep': 'Debe usar incrementos de {step}',
+  'scripts.dialog.waitForTimeoutTitle': 'La espera agotó el tiempo',
+  'scripts.dialog.retry': 'Reintentar',
+  'scripts.dialog.skip': 'Omitir',
+  'scripts.dialog.abort': 'Abortar',
+  'scripts.running.stepProgress': 'Paso {current} / {total}',
+  'scripts.running.determinateProgress': '{label} {current}/{total}',
+  'scripts.running.progressFallback': 'Progreso',
+  'scripts.running.operationsCount': '{count} operaciones',
+  'scripts.running.opsPrefix': '',
+  'scripts.running.opsSuffix': ' operaciones',
+  'scripts.running.elapsedLabel': 'Transcurrido',
+  'scripts.running.lastSentLabel': 'Enviado:',
+  'scripts.running.elapsed': '{elapsed}',
+  'scripts.running.completedSummary': 'Completado · {count} operaciones · {elapsed}',
+  'scripts.running.dismissHint': 'Toca cerrar para descartar',
+  'scripts.running.dismiss': 'Cerrar',
+  'scripts.running.viewLogs': 'Ver registros',
+  'scripts.running.logTitle': '{name} · Registro de ejecución',
+  'scripts.running.logEmpty': 'Aún no hay salida de registro',
+  'scripts.running.pause': 'Pausar',
+  'scripts.running.resume': 'Reanudar',
+  'scripts.running.stop': 'Detener',
+  'scripts.recording.saved': 'Script guardado',
+  'scripts.recording.savedNamed': 'Guardado "{name}"',
+  'scripts.observer.blocked': 'El modo observador bloquea los scripts que escriben en la terminal.',
+  'vault.section.scripts': 'Scripts',
+  'vault.nav.scripts': 'Scripts',
+  'snippets.action.newScript': 'Nuevo script de automatización',
+  'hostDetails.section.automation': 'Automatización',
+  'hostDetails.automation.loginScript': 'Script de inicio de sesión',
+  'hostDetails.automation.loginScriptPlaceholder': 'Selecciona un script',
+  'hostDetails.automation.none': 'Ninguno',
+  'hostDetails.automation.outputTriggers': 'Disparadores de salida',
+  'hostDetails.automation.addTrigger': 'Agregar disparador',
+  'hostDetails.automation.triggerPatternPlaceholder': 'Patrón de regex',
+  'hostDetails.automation.linkedScripts': 'Scripts vinculados',
+  'hostDetails.automation.linkedScriptsEmpty': 'Aún no hay scripts vinculados a este host.',
+  'hostDetails.automation.linkScriptPlaceholder': 'Vincular script existente…',
+  'hostDetails.automation.unlink': 'Desvincular',
+  'hostDetails.automation.equivalenceHint': 'Los vínculos agregan este host a la lista de destinos del script en Scripts. Ambas vistas se mantienen sincronizadas.',
+  'hostDetails.automation.queueHint': 'Los scripts se ejecutan en orden cuando este host se conecta. Los scripts globales se ejecutan primero, luego esta cola.',
+  'hostDetails.automation.globalScripts': 'Scripts de conexión globales',
+  'hostDetails.automation.globalScriptsHint': 'Se ejecutan primero en cada conexión. Reordena según el orden de clasificación de la biblioteca de Scripts.',
+  'hostDetails.automation.connectQueue': 'Cola de ejecución de este host',
+  'hostDetails.automation.connectQueueEmpty': 'Aún no hay scripts de conexión en cola para este host.',
+  'hostDetails.automation.addToQueuePlaceholder': 'Agregar script a la cola…',
+  'hostDetails.automation.moveUp': 'Subir',
+  'hostDetails.automation.moveDown': 'Bajar',
+  'hostDetails.automation.removeFromQueue': 'Quitar de la cola',
+  'hostDetails.automation.dragHandle': 'Arrastra para reordenar',
+  'hostDetails.automation.queueDragHint': 'Arrastra los elementos para reordenar la cola de conexión.',
+};

application/i18n/locales/es/systemManager.ts

@@ -0,0 +1,261 @@
+import type { Messages } from '../types';
+
+export const esSystemManagerMessages: Messages = {
+  'terminal.layer.system': 'Sistema',
+
+  'systemManager.noSession': 'No hay una sesión de terminal activa.',
+  'systemManager.notConnected': 'Conéctate a un host para administrar procesos y servicios.',
+  'systemManager.empty': 'No hay datos disponibles.',
+  'systemManager.tabs.overview': 'Resumen',
+  'systemManager.tabs.processes': 'Procesos',
+  'systemManager.tabs.ports': 'Puertos',
+  'systemManager.tabs.services': 'Servicios',
+  'systemManager.tabs.tmux': 'tmux',
+  'systemManager.tabs.docker': 'Docker',
+  'systemManager.tabs.gpu': 'GPU',
+  'systemManager.tabs.ariaLabel': 'Secciones del administrador del sistema',
+  'systemManager.popup.loading': 'Abriendo terminal…',
+  'systemManager.popup.startupFailed': 'El comando de inicio no se completó correctamente. Verifica que el destino siga disponible e inténtalo de nuevo.',
+
+  'systemManager.errors.loadProcesses': 'No se pudieron cargar los procesos',
+  'systemManager.errors.loadTmux': 'No se pudieron cargar las sesiones de tmux',
+  'systemManager.errors.loadTmuxWindows': 'No se pudieron cargar las ventanas de tmux',
+  'systemManager.errors.loadTmuxPanes': 'No se pudieron cargar los paneles de tmux',
+  'systemManager.errors.loadTmuxClients': 'No se pudieron cargar los clientes de tmux',
+  'systemManager.errors.actionFailed': 'La acción falló',
+  'systemManager.errors.loadDocker': 'No se pudieron cargar los contenedores',
+  'systemManager.errors.loadDockerStats': 'No se pudieron cargar las estadísticas de los contenedores',
+  'systemManager.errors.loadDockerImages': 'No se pudieron cargar las imágenes',
+  'systemManager.errors.loadOverview': 'No se pudo cargar el resumen del sistema',
+  'systemManager.errors.loadGpu': 'No se pudieron cargar las estadísticas de GPU / NPU',
+  '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.overview.empty': 'Aún no hay datos de resumen del sistema.',
+  'systemManager.overview.loading': 'Cargando resumen del sistema…',
+  'systemManager.overview.memory': 'Memoria',
+  'systemManager.overview.disk': 'Disco',
+  'systemManager.overview.network': 'Red',
+  'systemManager.overview.rx': 'RX',
+  'systemManager.overview.tx': 'TX',
+  'systemManager.overview.cores': '{{count}} núcleos',
+  'systemManager.overview.load': 'Carga',
+  'systemManager.overview.uptime': 'Tiempo activo',
+  'systemManager.overview.duration.daysHours': '{{days}}d {{hours}}h',
+  'systemManager.overview.duration.hoursMinutes': '{{hours}}h {{minutes}}m',
+  'systemManager.overview.duration.minutes': '{{minutes}}m',
+  'systemManager.overview.system': 'Sistema',
+  'systemManager.overview.kernel': 'Kernel',
+  'systemManager.overview.swap': 'Swap',
+  'systemManager.overview.latency': 'Latencia de red SSH',
+  'systemManager.overview.cpuCores': 'Núcleos de CPU',
+  'systemManager.overview.disks': 'Discos',
+  'systemManager.overview.interfaces': 'Interfaces de red',
+  'systemManager.overview.topProcesses': 'Procesos con más memoria',
+  'systemManager.overview.noData': 'Sin datos',
+  'systemManager.overview.noDisks': 'Sin datos de disco',
+  'systemManager.overview.noInterfaces': 'Sin datos de interfaces',
+  'systemManager.overview.noTopProcesses': 'Sin datos de procesos',
+
+  'systemManager.processes.search': 'Buscar procesos…',
+  'systemManager.processes.command': 'Comando',
+  'systemManager.processes.user': 'Usuario',
+  'systemManager.processes.term': 'Terminar',
+  'systemManager.processes.kill': 'Forzar cierre',
+  'systemManager.processes.stop': 'Detener (SIGSTOP)',
+  'systemManager.processes.cont': 'Continuar (SIGCONT)',
+  'systemManager.processes.hup': 'Colgar (SIGHUP)',
+  'systemManager.processes.renice': 'Renice',
+  'systemManager.processes.renicePrompt': 'Valor de nice (-20 a 19)',
+  'systemManager.processes.reniceInvalid': 'El valor de nice debe estar entre -20 y 19',
+  'systemManager.processes.confirmKill': '¿Enviar SIGKILL al proceso {{pid}}?',
+  'systemManager.processes.confirmSignal': '¿Enviar SIG{{signal}} al proceso {{pid}}?',
+  'systemManager.processes.filter.all': 'Todos',
+  'systemManager.processes.filter.running': 'En ejecución',
+  'systemManager.processes.ppid': 'PID padre',
+  'systemManager.processes.rss': 'RSS',
+  'systemManager.processes.vsz': 'Tamaño virtual',
+  'systemManager.processes.elapsed': 'Transcurrido',
+  'systemManager.processes.stat': 'Estado',
+  'systemManager.processes.meta': '{{count}} proceso(s)',
+  'systemManager.processes.loading': 'Cargando procesos…',
+  'systemManager.processes.loadingMore': 'Cargando más procesos…',
+  'systemManager.processes.state.running': 'En ejecución',
+  'systemManager.processes.state.sleeping': 'En reposo',
+  'systemManager.processes.state.stopped': 'Detenido',
+  'systemManager.processes.state.zombie': 'Zombie',
+  'systemManager.processes.sort.cpu': 'CPU',
+  'systemManager.processes.sort.mem': 'MEM',
+  'systemManager.processes.sort.pid': 'PID',
+  'systemManager.processes.sort.command': 'Comando',
+  'systemManager.processes.sort.user': 'Usuario',
+
+  'systemManager.common.dismiss': 'Descartar',
+  'systemManager.common.checkingAvailability': 'Verificando disponibilidad…',
+  'systemManager.common.loading': 'Cargando…',
+  'systemManager.common.loadingDetails': 'Cargando detalles…',
+  'systemManager.common.loadingStats': 'Cargando estadísticas…',
+
+  'systemManager.tmux.new': 'Nuevo',
+  'systemManager.tmux.search': 'Buscar sesiones…',
+  'systemManager.tmux.newSessionTitle': 'Nueva sesión de tmux',
+  'systemManager.tmux.newSessionDesc': 'Ponle nombre a la sesión y, opcionalmente, ejecuta un script al iniciar.',
+  'systemManager.tmux.newSessionTabCustom': 'Comando personalizado',
+  'systemManager.tmux.newSessionTabSnippet': 'Desde snippet',
+  'systemManager.tmux.pickSnippet': 'Desde snippets',
+  'systemManager.tmux.pickSnippetEmpty': 'Aún no hay snippets; agrega algunos en el panel de Scripts o en Vault.',
+  'systemManager.tmux.selectedSnippet': 'Usando snippet: {{label}}',
+  'systemManager.tmux.newSessionName': 'Nombre de la sesión',
+  'systemManager.tmux.newSessionCommand': 'Comando de inicio',
+  'systemManager.tmux.newSessionCommandPlaceholder': 'p. ej. htop o npm run dev (opcional)',
+  'systemManager.tmux.newSessionCommandHint': 'Déjalo vacío para una sesión de shell predeterminada.',
+  'systemManager.tmux.creating': 'Creando…',
+  'systemManager.tmux.newSessionPlaceholder': 'mi-sesion',
+  'systemManager.tmux.newSessionRequired': 'Primero ingresa un nombre de sesión',
+  'systemManager.tmux.empty': 'No hay sesiones de tmux',
+  'systemManager.tmux.attach': 'Conectar',
+  'systemManager.tmux.attached': 'Conectada',
+  'systemManager.tmux.detached': 'Desacoplada',
+  'systemManager.tmux.windows': '{{count}} ventana(s)',
+  'systemManager.tmux.created': 'Creada',
+  'systemManager.tmux.activity': 'Actividad',
+  'systemManager.tmux.rename': 'Renombrar',
+  'systemManager.tmux.detach': 'Desacoplar todo',
+  'systemManager.tmux.killSession': 'Terminar sesión',
+  'systemManager.tmux.killServer': 'Terminar servidor',
+  'systemManager.tmux.loadingDetails': 'Cargando detalles…',
+  'systemManager.tmux.clients': 'Clientes conectados',
+  'systemManager.tmux.windowList': 'Ventanas',
+  'systemManager.tmux.newWindow': 'Nueva ventana',
+  'systemManager.tmux.newWindowPlaceholder': 'Nombre de la ventana (opcional)',
+  'systemManager.tmux.noWindows': 'No hay ventanas',
+  'systemManager.tmux.unavailable': 'tmux no está disponible en este host',
+  'systemManager.docker.unavailable': 'Docker no está disponible en este host',
+  'systemManager.tmux.windowsMismatch': 'La sesión reporta {{count}} ventana(s), pero list-windows no devolvió ninguna',
+  'systemManager.tmux.lastCommand': 'último comando: {{command}}',
+  'systemManager.tmux.noPanes': 'No hay paneles',
+  'systemManager.tmux.panes': '{{count}} panel(es)',
+  'systemManager.tmux.active': 'activo',
+  'systemManager.tmux.unnamedWindow': 'Ventana sin nombre',
+  'systemManager.tmux.unnamedPane': 'Panel sin nombre',
+  'systemManager.tmux.attachWindow': 'Conectar a la ventana',
+  'systemManager.tmux.selectWindow': 'Seleccionar ventana',
+  'systemManager.tmux.killWindow': 'Terminar ventana',
+  'systemManager.tmux.killPane': 'Terminar panel',
+  'systemManager.tmux.splitHorizontal': 'Dividir horizontal',
+  'systemManager.tmux.splitVertical': 'Dividir vertical',
+  'systemManager.tmux.sendKeys': 'Enviar teclas',
+  'systemManager.tmux.sendKeysTo': 'Enviar teclas a la ventana {{window}} panel {{pane}}',
+  'systemManager.tmux.sendKeysPlaceholder': 'Comando o texto…',
+  'systemManager.tmux.renameSessionPrompt': 'Renombrar sesión',
+  'systemManager.tmux.renameWindowPrompt': 'Renombrar ventana',
+  'systemManager.tmux.windowName': 'Nombre de la ventana',
+  'systemManager.tmux.confirmKillSession': '¿Terminar la sesión de tmux "{{name}}"?',
+  'systemManager.tmux.confirmDetachSession': '¿Desacoplar todos los clientes de "{{name}}"?',
+  'systemManager.tmux.confirmKillWindow': '¿Terminar la ventana "{{name}}"?',
+  'systemManager.tmux.confirmKillPane': '¿Terminar el panel #{{index}}?',
+  'systemManager.tmux.confirmKillServer': '¿Terminar el servidor de tmux? Se terminarán todas las sesiones.',
+  'systemManager.tmux.meta': '{{count}} sesión(es)',
+
+  'systemManager.docker.title': 'Contenedores',
+  'systemManager.docker.subTabs.containers': 'Contenedores',
+  'systemManager.docker.subTabs.images': 'Imágenes',
+  'systemManager.docker.empty': 'No se encontraron contenedores',
+  'systemManager.docker.imagesEmpty': 'No se encontraron imágenes',
+  'systemManager.docker.search': 'Buscar contenedores…',
+  'systemManager.docker.searchImages': 'Buscar imágenes…',
+  'systemManager.docker.filter.all': 'Todos',
+  'systemManager.docker.filter.running': 'En ejecución',
+  'systemManager.docker.filter.stopped': 'Detenidos',
+  'systemManager.docker.filter.paused': 'En pausa',
+  'systemManager.docker.shell': 'Shell',
+  'systemManager.docker.logs': 'Registros',
+  'systemManager.docker.details': 'Detalles',
+  'systemManager.docker.inspect': 'Inspeccionar',
+  'systemManager.docker.imageInspect': 'Inspección de imagen',
+  'systemManager.docker.confirmRemove': '¿Eliminar este contenedor?',
+  'systemManager.docker.confirmKill': '¿Terminar por la fuerza este contenedor?',
+  'systemManager.docker.confirmRemoveImage': '¿Eliminar la imagen "{{name}}"?',
+  'systemManager.docker.confirmPrune': '¿Eliminar las imágenes colgantes?',
+  'systemManager.docker.confirmPruneAll': '¿Eliminar todas las imágenes no utilizadas?',
+  'systemManager.docker.pause': 'Pausar',
+  'systemManager.docker.unpause': 'Reanudar',
+  'systemManager.docker.restart': 'Reiniciar',
+  'systemManager.docker.kill': 'Terminar',
+  'systemManager.docker.renamePrompt': 'Nombre del contenedor',
+  'systemManager.docker.prune': 'Limpiar',
+  'systemManager.docker.pruneAll': 'Limpiar todo',
+  'systemManager.docker.tag': 'Etiqueta',
+  'systemManager.docker.tagRepoPrompt': 'Nombre del repositorio',
+  'systemManager.docker.tagNamePrompt': 'Nombre de la etiqueta',
+  'systemManager.docker.meta': '{{count}} contenedor(es)',
+  'systemManager.docker.imagesMeta': '{{count}} imagen(es)',
+  'systemManager.docker.start': 'Iniciar',
+  'systemManager.docker.stop': 'Detener',
+
+  'systemManager.ports.unavailable': 'No se detectaron herramientas de puertos en escucha (ss / netstat) en este host.',
+  'systemManager.ports.loading': 'Cargando puertos en escucha…',
+  'systemManager.ports.empty': 'No se reportaron puertos en escucha.',
+  'systemManager.ports.search': 'Buscar puertos…',
+  'systemManager.ports.meta': '{{count}} en escucha',
+  'systemManager.ports.filter.all': 'Todos',
+  'systemManager.ports.unknownProcess': 'Proceso desconocido',
+  'systemManager.ports.terminate': 'Terminar',
+  'systemManager.ports.confirmTerminate': '¿Enviar SIGTERM al proceso {{pid}} que ocupa este puerto?',
+
+  'systemManager.services.unavailable': 'systemctl no está disponible en este host.',
+  'systemManager.services.loading': 'Cargando servicios de systemd…',
+  'systemManager.services.empty': 'No se encontraron servicios de systemd.',
+  'systemManager.services.search': 'Buscar servicios…',
+  'systemManager.services.meta': '{{count}} servicio(s)',
+  'systemManager.services.filter.all': 'Todos',
+  'systemManager.services.filter.running': 'En ejecución',
+  'systemManager.services.filter.failed': 'Con error',
+  'systemManager.services.filter.inactive': 'Inactivo',
+  'systemManager.services.start': 'Iniciar',
+  'systemManager.services.stop': 'Detener',
+  'systemManager.services.restart': 'Reiniciar',
+  'systemManager.services.enable': 'Habilitar',
+  'systemManager.services.disable': 'Deshabilitar',
+  'systemManager.services.reload': 'Recargar',
+  'systemManager.services.scope.user': 'usuario',
+  'systemManager.services.confirmAction': '¿{{action}} {{name}}?',
+
+  'systemManager.gpu.unavailable': 'No se detectaron herramientas de GPU NVIDIA o NPU Ascend en este host.',
+  'systemManager.gpu.loading': 'Cargando estadísticas del acelerador…',
+  'systemManager.gpu.empty': 'Las herramientas del acelerador están presentes, pero no se reportó ningún dispositivo.',
+  'systemManager.gpu.meta': '{{devices}} dispositivo(s) · {{processes}} proceso(s)',
+  'systemManager.gpu.devices': 'Dispositivos',
+  'systemManager.gpu.processes': 'Procesos de cómputo',
+  'systemManager.gpu.noProcesses': 'No se reportaron procesos de cómputo.',
+  'systemManager.gpu.vendor.nvidia': 'NVIDIA',
+  'systemManager.gpu.vendor.ascend': 'Ascend',
+  'systemManager.gpu.util': 'Util',
+  'systemManager.gpu.memory': 'VRAM',
+  'systemManager.gpu.hbm': 'HBM',
+  'systemManager.gpu.temperature': 'Temperatura',
+  'systemManager.gpu.power': 'Energía',
+  'systemManager.gpu.fan': 'Ventilador {{value}}%',
+  'systemManager.gpu.driver': 'Controlador {{version}}',
+
+  'systemManager.inspect.status': 'Estado',
+  'systemManager.inspect.image': 'Imagen',
+  'systemManager.inspect.created': 'Creado',
+  'systemManager.inspect.started': 'Iniciado',
+  'systemManager.inspect.restartPolicy': 'Política de reinicio',
+  'systemManager.inspect.command': 'Comando',
+  'systemManager.inspect.ports': 'Puertos',
+  'systemManager.inspect.networks': 'Redes',
+  'systemManager.inspect.mounts': 'Montajes',
+  'systemManager.inspect.env': 'Entorno',
+  'systemManager.inspect.labels': 'Etiquetas',
+  'systemManager.inspect.tags': 'Etiquetas',
+  'systemManager.inspect.digests': 'Digests',
+  'systemManager.inspect.size': 'Tamaño',
+  'systemManager.inspect.platform': 'Plataforma',
+  'systemManager.inspect.workdir': 'Directorio de trabajo',
+  'systemManager.inspect.exposedPorts': 'Puertos expuestos',
+  'systemManager.inspect.showRaw': 'JSON',
+  'systemManager.inspect.hideRaw': 'Ocultar JSON',
+};

application/i18n/locales/es/terminal.ts

@@ -0,0 +1,843 @@
+import type { Messages } from '../types';
+
+export const esTerminalMessages: Messages = {
+  'terminal.sudoHint.pressEnter': 'Presiona Enter para pegar la contraseña guardada',
+  'terminal.passwordPicker.title': 'Contraseñas guardadas',
+  'terminal.passwordPicker.empty': 'No hay contraseñas guardadas',
+  // Network Device Mode auto-detection tip (session header)
+  'terminal.networkDevice.tip.message': 'Esto parece un dispositivo de red. Activa el Modo de Dispositivo de Red para enviar comandos tal cual (sin envoltorio de shell).',
+  'terminal.networkDevice.tip.action': 'Activar',
+  'terminal.networkDevice.tip.dismiss': 'Descartar',
+  'terminal.networkDevice.tip.enabled': 'Modo de Dispositivo de Red activado para {host}',
+  // Terminal toolbar / search / context menu / auth
+  'terminal.toolbar.openSftp': 'Abrir SFTP',
+  'terminal.toolbar.availableAfterConnect': 'Disponible después de conectar',
+  'terminal.toolbar.sendYmodem': 'Enviar con YMODEM',
+  'terminal.toolbar.receiveYmodem': 'Recibir con YMODEM',
+  'terminal.toolbar.sftp': 'SFTP',
+  'terminal.toolbar.more': 'Más acciones',
+  'terminal.toolbar.scripts': 'Scripts',
+  'terminal.toolbar.history': 'Historial de comandos',
+  'terminal.toolbar.configureOsc7': 'Configurar seguimiento de directorio',
+  'history.scope.label': 'Alcance del historial',
+  'history.tab.host': 'Host',
+  'history.tab.global': 'Global',
+  'history.searchPlaceholder': 'Buscar en el historial...',
+  'history.loading': 'Cargando historial remoto...',
+  'history.meta.count': '{count} comandos',
+  'history.empty.noSession': 'Abre una sesión remota para ver su historial de comandos.',
+  'history.empty.unsupportedProtocol': 'El historial de comandos solo está disponible para sesiones SSH/Mosh/ET.',
+  'history.empty.noHistory': 'No se encontró historial de comandos en este host.',
+  'history.empty.noGlobalHistory': 'Aún no hay historial global de comandos. Los comandos que ejecutes aparecerán aquí.',
+  'history.action.refresh': 'Actualizar',
+  'history.action.retry': 'Reintentar',
+  'history.action.paste': 'Pegar en la terminal',
+  'history.action.run': 'Ejecutar en la terminal',
+  'history.action.saveAsSnippet': 'Guardar como snippet',
+  'history.action.delete': 'Eliminar del historial',
+  'terminal.toolbar.library': 'Biblioteca',
+  'terminal.toolbar.noSnippets': 'No hay snippets disponibles',
+  'terminal.toolbar.terminalSettings': 'Configuración de la terminal',
+  'terminal.toolbar.searchTerminal': 'Buscar en la terminal',
+  'terminal.toolbar.search': 'Buscar',
+  'terminal.toolbar.startSessionLog': 'Iniciar registro de sesión',
+  'terminal.toolbar.stopSessionLog': 'Detener registro de sesión',
+  'terminal.toolbar.timestampsEnable': 'Mostrar marcas de tiempo',
+  'terminal.toolbar.timestampsDisable': 'Ocultar marcas de tiempo',
+  'terminal.toolbar.broadcast': 'Difundir',
+  'terminal.toolbar.broadcastEnable': 'Activar Modo de Difusión',
+  'terminal.toolbar.broadcastDisable': 'Desactivar Modo de Difusión',
+  'terminal.toolbar.composeBar': 'Barra de redacción',
+  'terminal.composeBar.placeholder': 'Escribe el comando aquí y presiona Enter para enviar...',
+  'terminal.composeBar.send': 'Enviar',
+  'terminal.composeBar.close': 'Cerrar barra de redacción',
+  'terminal.composeBar.broadcasting': 'Difundiendo a todas las sesiones',
+  'terminal.composeBar.resize': 'Cambiar la altura de la barra de redacción',
+  'terminal.composeBar.manageSnippets': 'Administrar snippets rápidos',
+  'terminal.composeBar.searchSnippets': 'Buscar snippets...',
+  'terminal.composeBar.noPinnedSnippets': 'Fija snippets con + para acceso rápido',
+  'terminal.composeBar.noMatchingSnippets': 'No hay snippets que coincidan',
+  'terminal.composeBar.pinnedCount': '{count} fijados',
+  'terminal.composeBar.unpinSnippet': 'Quitar {label} de la barra rápida',
+  'terminal.composeBar.snippetClickHint': 'Clic para insertar · Shift+Clic para enviar',
+  'terminal.toolbar.focus': 'Enfocar',
+  'terminal.toolbar.focusMode': 'Modo de Enfoque',
+  'terminal.toolbar.detach': 'Desacoplar a pestaña independiente',
+  'terminal.toolbar.dragPane': 'Arrastrar panel de terminal',
+  'terminal.toolbar.showActions': 'Mostrar acciones de la terminal',
+  'terminal.toolbar.encoding': 'Codificación de la terminal',
+  'terminal.toolbar.encoding.utf8': 'UTF-8',
+  'terminal.toolbar.encoding.gb18030': 'GB18030',
+  'terminal.toolbar.closeSession': 'Cerrar sesión',
+  'terminal.toolbar.hostHighlight.title': 'Resaltado de palabras clave del host',
+  'terminal.toolbar.hostHighlight.noRules': 'No hay reglas de resaltado personalizadas definidas para este host',
+  'terminal.toolbar.hostHighlight.addRule': 'Agregar nueva regla',
+  'terminal.toolbar.hostHighlight.labelPlaceholder': 'Etiqueta (p. ej., Error)',
+  'terminal.toolbar.hostHighlight.patternPlaceholder': 'Patrón regex (p. ej., \\bfailed\\b)',
+  'terminal.toolbar.hostHighlight.invalidPattern': 'Patrón regex no válido',
+  'terminal.toolbar.hostHighlight.clearAll': 'Borrar todo',
+  'terminal.toolbar.hostHighlight.changeColor': 'Cambiar el color de resaltado de',
+  'terminal.toolbar.hostHighlight.selectColor': 'Seleccionar el color de la nueva regla',
+  'terminal.statusbar.copyHostname.label': 'Copiar dirección del host',
+  'terminal.statusbar.copyHostname.tooltip': 'Copiar dirección del host ({hostname})',
+  'terminal.statusbar.copyHostname.toast': 'Dirección del host copiada: {hostname}',
+  'terminal.statusbar.copyHostname.error': 'No se pudo copiar la dirección del host al portapapeles',
+  'terminal.statusbar.disconnect.label': 'Desconectar',
+  'terminal.statusbar.disconnect.tooltip': 'Desconectar esta sesión sin cerrar la pestaña',
+  'terminal.statusbar.reconnect.label': 'Reconectar',
+  'terminal.statusbar.reconnect.tooltip': 'Reconectar esta sesión',
+  'terminal.serverStats.cpu': 'Uso de CPU',
+  'terminal.serverStats.cpuCores': 'Uso de núcleos de CPU',
+  'terminal.serverStats.memory': 'Uso de memoria',
+  'terminal.serverStats.memoryDetails': 'Detalles de memoria',
+  'terminal.serverStats.memUsed': 'Usada',
+  'terminal.serverStats.memBuffers': 'Búfers',
+  'terminal.serverStats.memCached': 'Caché',
+  'terminal.serverStats.memFree': 'Libre',
+  'terminal.serverStats.swap': 'Swap',
+  'terminal.serverStats.swapUsed': 'Swap usada',
+  'terminal.serverStats.swapFree': 'Swap libre',
+  'terminal.serverStats.swapTotal': 'Total',
+  'terminal.serverStats.topProcesses': 'Principales procesos por memoria',
+  'terminal.serverStats.disk': 'Uso de disco',
+  'terminal.serverStats.diskDetails': 'Discos montados',
+  'terminal.serverStats.network': 'Velocidad de red',
+  'terminal.serverStats.latency': 'Latencia de red SSH',
+  'terminal.serverStats.networkDetails': 'Interfaces de red',
+  'terminal.serverStats.noData': 'No hay datos disponibles',
+  'terminal.dragDrop.localTitle': 'Soltar para insertar rutas',
+  'terminal.dragDrop.localMessage': 'Las rutas de los archivos se insertarán en la terminal',
+  'terminal.dragDrop.remoteTitle': 'Soltar para subir archivos',
+  'terminal.dragDrop.remoteZmodemMessage': 'Los archivos se subirán mediante ZMODEM (PTY)',
+  'terminal.dragDrop.remoteSftpMessage': 'Los archivos se subirán mediante SFTP',
+  'terminal.dragDrop.noFiles': 'No hay archivos para subir',
+  'terminal.dragDrop.notConnected': 'No se pueden soltar archivos: la terminal no está conectada',
+  'terminal.dragDrop.errorTitle': 'Error al soltar',
+  'terminal.dragDrop.errorMessage': 'No se pudieron procesar los archivos soltados',
+  'terminal.search.placeholder': 'Buscar...',
+  'terminal.search.noResults': 'Sin resultados',
+  'terminal.search.prevMatch': 'Coincidencia anterior (Shift+Enter)',
+  'terminal.search.nextMatch': 'Coincidencia siguiente (Enter)',
+  'terminal.menu.copy': 'Copiar',
+  'terminal.menu.paste': 'Pegar',
+  'terminal.menu.uploadClipboardImage': 'Subir imagen del portapapeles',
+  'terminal.menu.addSelectionToAI': 'Agregar a la conversación',
+  'terminal.menu.pasteSelection': 'Pegar selección',
+  'terminal.menu.selectAll': 'Seleccionar todo',
+  'terminal.menu.reconnect': 'Reconectar',
+  'terminal.menu.sendYmodem': 'Enviar con YMODEM',
+  'terminal.menu.receiveYmodem': 'Recibir con YMODEM',
+  'terminal.menu.splitHorizontal': 'Dividir en horizontal',
+  'terminal.menu.splitVertical': 'Dividir en vertical',
+  'terminal.menu.clearBuffer': 'Limpiar búfer',
+  'terminal.menu.closeTerminal': 'Cerrar terminal',
+  'terminal.menu.rename': 'Renombrar',
+  'terminal.menu.detach': 'Desacoplar del espacio de trabajo',
+  'terminal.menu.detachSession': 'Desacoplar {name}',
+  'terminal.clipboardImageUpload.noImage': 'El portapapeles no contiene una imagen',
+  'terminal.clipboardImageUpload.failed': 'No se pudo subir la imagen del portapapeles',
+  'terminal.osc7Setup.title': 'Configurar seguimiento de directorio',
+  'terminal.osc7Setup.desc': 'Netcatty agregará hooks de prompt OSC 7 para el usuario remoto actual. Esto ayuda a que SFTP siga el directorio de la terminal después de sudo o su.',
+  'terminal.osc7Setup.targets': 'Posibles archivos a actualizar',
+  'terminal.osc7Setup.command': 'Comando a ejecutar',
+  'terminal.osc7Setup.run': 'Ejecutar configuración',
+  'terminal.osc7Setup.running': 'Configurando...',
+  'terminal.osc7Setup.configured': 'Seguimiento de directorio configurado',
+  'terminal.osc7Setup.failed': 'Falló la configuración del seguimiento de directorio',
+  'terminal.osc7Setup.sent': 'Configuración de seguimiento de directorio enviada a la terminal',
+  'terminal.ymodem.selectFile': 'Selecciona el archivo a enviar',
+  'terminal.ymodem.allFiles': 'Todos los archivos',
+  'terminal.ymodem.started': 'YMODEM enviando {fileName}',
+  'terminal.ymodem.complete': 'YMODEM envió {fileName}',
+  'terminal.ymodem.failed': 'Falló el envío con YMODEM',
+  'terminal.ymodem.selectReceiveDirectory': 'Selecciona la carpeta para guardar los archivos recibidos',
+  'terminal.ymodem.receiveStarted': 'YMODEM recibiendo...',
+  'terminal.ymodem.receiveComplete': 'YMODEM recibió {fileName}',
+  'terminal.ymodem.receiveCompleteMultiple': 'YMODEM recibió {count} archivos',
+  'terminal.ymodem.receiveEmpty': 'No se recibieron archivos YMODEM',
+  'terminal.ymodem.receiveFailed': 'Falló la recepción con YMODEM',
+  'terminal.ymodem.unavailable': 'YMODEM no está disponible',
+  'terminal.selection.addToAI': 'Agregar a la conversación',
+  'terminal.selection.addToAIDesc': 'Adjuntar la salida seleccionada de la terminal al borrador de IA',
+  'terminal.auth.password': 'Contraseña',
+  'terminal.auth.sshKey': 'Clave SSH',
+  'terminal.auth.username': 'Nombre de usuario',
+  'terminal.auth.username.placeholder': 'root',
+  'terminal.auth.passwordLabel': 'Contraseña',
+  'terminal.auth.password.placeholder': 'Ingresa la contraseña',
+  'terminal.auth.passphrase': 'Frase de contraseña',
+  'terminal.auth.passphrase.placeholder': 'Frase de contraseña opcional para la clave privada seleccionada',
+  'terminal.auth.certificate': 'Certificado',
+  'terminal.auth.selectKey': 'Seleccionar clave',
+  'terminal.auth.retryMessage': 'Falló la autenticación. Verifica tus credenciales e inténtalo de nuevo.',
+  'terminal.auth.retryLog': 'Falló la autenticación. Inténtalo de nuevo.',
+  'terminal.auth.noKeysHint': 'No hay claves disponibles. Agrega claves en Keychain.',
+  'terminal.auth.continueSave': 'Continuar y guardar',
+  'terminal.auth.credentialsUnavailable': 'Las credenciales guardadas no se pueden descifrar en este dispositivo. Vuelve a ingresarlas y guárdalas de nuevo.',
+  'terminal.auth.jumpCredentialsUnavailable': 'Un host de salto tiene credenciales guardadas que no se pueden descifrar en este dispositivo. Abre la configuración del host y vuelve a ingresarlas.',
+  'terminal.auth.proxyCredentialsUnavailable': 'Las credenciales del proxy no se pueden descifrar en este dispositivo. Abre la configuración del host y vuelve a ingresar la contraseña del proxy.',
+  'terminal.auth.keyUnavailableFallbackPassword': 'La clave SSH guardada no está disponible en este dispositivo. Se usará autenticación por contraseña como respaldo.',
+  'terminal.progress.timeoutIn': 'Tiempo de espera en {seconds}s',
+  'terminal.progress.waitingForUserInput': 'Esperando entrada del usuario',
+  'terminal.progress.disconnected': 'Desconectado',
+  'terminal.progress.cancelling': 'Cancelando...',
+  'terminal.progress.startOver': 'Empezar de nuevo',
+  'terminal.progress.enterReconnectHint': 'Presiona Enter para reconectar',
+  'terminal.progress.autoReconnectScheduled': 'Conexión perdida. Reconectando en {seconds}s (intento {attempt}).',
+  'terminal.progress.autoReconnectAttempt': 'Intento de reconexión automática {attempt}...',
+  'terminal.connection.dismissDisconnectedDialog': 'Descartar aviso de desconexión',
+  'terminal.connection.chainOf': 'Cadena {current} de {total}',
+  'terminal.connection.showLogs': 'Mostrar registros',
+  'terminal.connection.hideLogs': 'Ocultar registros',
+  'terminal.connection.protocol.ssh': 'SSH',
+  'terminal.connection.protocol.telnet': 'Telnet',
+  'terminal.connection.protocol.mosh': 'Mosh',
+  'terminal.connection.protocol.et': 'EternalTerminal',
+  'terminal.connection.protocol.plugin': 'Conexión de plugin',
+  'terminal.et.proxyUnsupported': 'EternalTerminal no admite actualmente la configuración de proxy de Netcatty. Usa SSH o quita el proxy de este host.',
+  'terminal.et.multiJumpUnsupported': 'EternalTerminal admite actualmente como máximo un host de salto en Netcatty.',
+  'terminal.connection.protocol.serial': 'Serial',
+  'terminal.connection.protocol.local': 'Shell local',
+  'terminal.hostKey.unknownTitle': 'Confirmar esta clave de host',
+  'terminal.hostKey.changedTitle': 'La clave del host cambió',
+  'terminal.hostKey.unknownDescription': 'Aún no se puede establecer la autenticidad de {host}.',
+  'terminal.hostKey.changedDescription': 'La clave guardada de {host} ya no coincide con este servidor.',
+  'terminal.hostKey.fingerprintLabel': 'La huella digital de {keyType} es SHA256:',
+  'terminal.hostKey.savedFingerprintLabel': 'Huella guardada',
+  'terminal.hostKey.unknownHint': 'Recuérdala si esta huella pertenece al servidor que esperabas.',
+  'terminal.hostKey.changedHint': 'Continúa solo si esperabas que este host cambiara.',
+  'terminal.hostKey.addAndContinue': 'Agregar y continuar',
+  'terminal.hostKey.updateAndContinue': 'Actualizar y continuar',
+  'terminal.themeModal.title': 'Apariencia de la terminal',
+  'terminal.themeModal.tab.theme': 'Tema',
+  'terminal.themeModal.tab.font': 'Fuente',
+  'terminal.themeModal.tab.custom': 'Personalizado',
+  'terminal.themeModal.globalTheme': 'Tema global',
+  'terminal.themeModal.globalFont': 'Fuente global',
+  'terminal.themeModal.fontSize': 'Tamaño de fuente',
+  'terminal.themeModal.fontWeight': 'Grosor de fuente',
+  'terminal.themeModal.livePreview': 'Vista previa en vivo',
+  'terminal.themeModal.themeType': 'Tema {type}',
+  'terminal.hiddenTheme.title': 'Tema oculto actual',
+  'terminal.hiddenTheme.desc': 'Este tema está oculto de la selección manual y se reemplazará cuando elijas otro tema.',
+  'topTabs.toggleTheme.systemExitTitle': 'El tema del sistema está activo',
+  'topTabs.toggleTheme.systemExitMessage': 'Abre Configuración para elegir un tema fijo de Claro u Oscuro.',
+  'topTabs.toggleTheme.openSettings': 'Abrir Configuración',
+
+  // Custom Themes
+  'terminal.customTheme.section': 'Temas personalizados',
+  'terminal.customTheme.yourThemes': 'Tus temas',
+  'terminal.customTheme.new': 'Nuevo tema',
+  'terminal.customTheme.newDesc': 'Clonar el tema actual y personalizarlo',
+  'terminal.customTheme.newTitle': 'Nuevo tema personalizado',
+  'terminal.customTheme.editTitle': 'Editar tema',
+  'terminal.customTheme.import': 'Importar .itermcolors',
+  'terminal.customTheme.importDesc': 'Importar desde archivo de esquema de color de iTerm2',
+  'terminal.customTheme.importError': 'No se pudo analizar el archivo seleccionado. Asegúrate de que sea un archivo XML .itermcolors válido.',
+  'terminal.customTheme.delete': 'Eliminar tema',
+  'terminal.customTheme.confirmDelete': 'Confirmar eliminación',
+  'terminal.customTheme.name': 'Nombre',
+  'terminal.customTheme.namePlaceholder': 'Mi tema personalizado',
+  'terminal.customTheme.type': 'Tipo',
+  'terminal.customTheme.group.general': 'General',
+  'terminal.customTheme.group.normal': 'Colores normales',
+  'terminal.customTheme.group.bright': 'Colores brillantes',
+  'terminal.customTheme.color.background': 'Fondo',
+  'terminal.customTheme.color.foreground': 'Primer plano',
+  'terminal.customTheme.color.cursor': 'Cursor',
+  'terminal.customTheme.color.selection': 'Selección',
+  'terminal.customTheme.color.black': 'Negro',
+  'terminal.customTheme.color.red': 'Rojo',
+  'terminal.customTheme.color.green': 'Verde',
+  'terminal.customTheme.color.yellow': 'Amarillo',
+  'terminal.customTheme.color.blue': 'Azul',
+  'terminal.customTheme.color.magenta': 'Magenta',
+  'terminal.customTheme.color.cyan': 'Cian',
+  'terminal.customTheme.color.white': 'Blanco',
+  'terminal.customTheme.color.brightBlack': 'Negro brillante',
+  'terminal.customTheme.color.brightRed': 'Rojo brillante',
+  'terminal.customTheme.color.brightGreen': 'Verde brillante',
+  'terminal.customTheme.color.brightYellow': 'Amarillo brillante',
+  'terminal.customTheme.color.brightBlue': 'Azul brillante',
+  'terminal.customTheme.color.brightMagenta': 'Magenta brillante',
+  'terminal.customTheme.color.brightCyan': 'Cian brillante',
+  'terminal.customTheme.color.brightWhite': 'Blanco brillante',
+
+  // Cloud Sync Settings
+  'cloudSync.gate.title': 'Sincronización cifrada de extremo a extremo',
+  'cloudSync.gate.desc':
+    'Tus datos se cifran localmente antes de sincronizarse. Los proveedores de la nube nunca ven tus datos en texto plano. Configura una clave maestra para habilitar la sincronización segura.',
+  'cloudSync.gate.masterKey': 'Clave maestra',
+  'cloudSync.gate.confirmMasterKey': 'Confirmar clave maestra',
+  'cloudSync.gate.placeholder': 'Ingresa una contraseña segura',
+  'cloudSync.gate.confirmPlaceholder': 'Confirma tu contraseña',
+  'cloudSync.gate.mismatch': 'Las contraseñas no coinciden',
+  'cloudSync.gate.warning':
+    'Entiendo que, si olvido mi clave maestra, mis datos no se podrán recuperar. No hay restablecimiento de contraseña.',
+  'cloudSync.gate.enableVault': 'Habilitar bóveda cifrada',
+  'cloudSync.gate.enabledToast': 'Bóveda cifrada habilitada',
+  'cloudSync.gate.setupFailed': 'No se pudo configurar la clave maestra',
+  'cloudSync.passwordStrength.tooShort': 'Demasiado corta',
+  'cloudSync.passwordStrength.weak': 'Débil',
+  'cloudSync.passwordStrength.moderate': 'Moderada',
+  'cloudSync.passwordStrength.strong': 'Segura',
+  'cloudSync.passwordStrength.veryStrong': 'Muy segura',
+  'cloudSync.provider.notConnected': 'No conectado',
+  'cloudSync.provider.sync': 'Sincronizar',
+  'cloudSync.provider.connect': 'Conectar',
+  'cloudSync.provider.connecting': 'Conectando...',
+  'cloudSync.provider.webdav': 'WebDAV',
+  'cloudSync.provider.webdav.desc': 'Conectar a un endpoint WebDAV autoalojado',
+  'cloudSync.provider.s3': 'Compatible con S3',
+  'cloudSync.provider.s3.desc': 'Conectar a almacenamiento de objetos compatible con S3',
+  'cloudSync.provider.comingSoon': 'Próximamente',
+  'cloudSync.webdav.title': 'Configuración de WebDAV',
+  'cloudSync.webdav.desc': 'Configura un endpoint WebDAV para la sincronización cifrada.',
+  'cloudSync.webdav.endpoint': 'URL del endpoint',
+  'cloudSync.webdav.authType': 'Tipo de autenticación',
+  'cloudSync.webdav.auth.basic': 'Básica',
+  'cloudSync.webdav.auth.digest': 'Digest',
+  'cloudSync.webdav.auth.token': 'Token',
+  'cloudSync.webdav.username': 'Nombre de usuario',
+  'cloudSync.webdav.password': 'Contraseña',
+  'cloudSync.webdav.token': 'Token',
+  'cloudSync.webdav.showSecret': 'Mostrar secreto',
+  'cloudSync.webdav.allowInsecure': 'Permitir conexión insegura (ignorar errores de certificado)',
+  'cloudSync.webdav.validation.endpoint': 'Ingresa un endpoint WebDAV válido.',
+  'cloudSync.webdav.validation.credentials': 'El nombre de usuario y la contraseña son obligatorios.',
+  'cloudSync.webdav.validation.token': 'El token es obligatorio.',
+  'cloudSync.s3.title': 'Configuración de S3',
+  'cloudSync.s3.desc': 'Conéctate al almacenamiento de objetos compatible con S3 para la sincronización cifrada.',
+  'cloudSync.s3.endpoint': 'URL del endpoint',
+  'cloudSync.s3.region': 'Región',
+  'cloudSync.s3.bucket': 'Bucket',
+  'cloudSync.s3.accessKeyId': 'ID de clave de acceso',
+  'cloudSync.s3.secretAccessKey': 'Clave de acceso secreta',
+  'cloudSync.s3.sessionToken': 'Token de sesión (opcional)',
+  'cloudSync.s3.prefix': 'Prefijo de clave (opcional)',
+  'cloudSync.s3.forcePathStyle': 'Forzar URLs con estilo de ruta (para MinIO/R2, etc.)',
+  'cloudSync.s3.allowInsecure': 'Permitir conexión insegura (ignorar errores de certificado)',
+  'cloudSync.s3.showSecret': 'Mostrar secretos',
+  'cloudSync.s3.validation.required': 'Endpoint, región, bucket, clave de acceso y secreto son obligatorios.',
+  'cloudSync.smb.title': 'Configuración de SMB',
+  'cloudSync.smb.desc': 'Conéctate a un recurso compartido de archivos SMB/CIFS para la sincronización cifrada.',
+  'cloudSync.smb.share': 'Ruta del recurso compartido',
+  'cloudSync.smb.username': 'Nombre de usuario',
+  'cloudSync.smb.password': 'Contraseña',
+  'cloudSync.smb.domain': 'Dominio (opcional)',
+  'cloudSync.smb.domainPlaceholder': 'p. ej., WORKGROUP',
+  'cloudSync.smb.port': 'Puerto (opcional)',
+  'cloudSync.smb.showSecret': 'Mostrar contraseña',
+  'cloudSync.smb.validation.share': 'La ruta del recurso compartido es obligatoria.',
+  'cloudSync.smb.validation.port': 'El puerto debe ser un número entre 1 y 65535.',
+  'cloudSync.connect.smb.success': 'SMB se conectó correctamente',
+  'cloudSync.connect.smb.failedTitle': 'Falló la conexión a SMB',
+  'cloudSync.provider.smb': 'Recurso compartido SMB',
+  'cloudSync.connect.webdav.success': 'WebDAV se conectó correctamente',
+  'cloudSync.connect.webdav.failedTitle': 'Falló la conexión a WebDAV',
+  'cloudSync.connect.s3.success': 'S3 se conectó correctamente',
+  'cloudSync.connect.s3.failedTitle': 'Falló la conexión a S3',
+  'cloudSync.connect.plugin.success': 'El proveedor de sincronización de plugin se conectó correctamente',
+  'cloudSync.connect.plugin.failedTitle': 'Falló la conexión del plugin de sincronización',
+  'cloudSync.pluginConfig.title': 'Configurar {name}',
+  'cloudSync.pluginConfig.desc': 'Ingresa la configuración JSON requerida por este proveedor de sincronización de plugin.',
+  'cloudSync.pluginConfig.label': 'Configuración del proveedor (JSON)',
+  'cloudSync.pluginConfig.invalidJson': 'La configuración debe ser JSON válido.',
+  'cloudSync.pluginConfig.schemaInvalid': 'La configuración no coincide con el esquema del proveedor.',
+  'cloudSync.lastSync.never': 'Nunca',
+  'cloudSync.lastSync.justNow': 'Justo ahora',
+  'cloudSync.lastSync.minutesAgo': 'Hace {minutes} min',
+  'cloudSync.changeKey': 'Cambiar clave',
+  'cloudSync.providers.title': 'Proveedores de nube',
+  'cloudSync.syncAll': 'Sincronizar todos los proveedores conectados',
+  'cloudSync.autoSync.title': 'Sincronización automática',
+  'cloudSync.autoSync.desc': 'Sincronizar automáticamente cuando se realicen cambios',
+  'cloudSync.strategy.title': 'Estrategia de sincronización',
+  'cloudSync.strategy.desc': 'Elige qué sucede cuando cambian tanto los datos locales como los de la nube.',
+  'cloudSync.strategy.smartMerge': 'Fusión inteligente (recomendada)',
+  'cloudSync.strategy.smartMergeDesc': 'Combina los cambios de ambos lados cuando sea posible; si Netcatty no puede decidir con seguridad, te pedirá que elijas.',
+  'cloudSync.strategy.preferCloud': 'Gana la nube',
+  'cloudSync.strategy.preferCloudDesc': 'Cuando ambos lados cambiaron, descarga la versión de la nube y reemplaza los cambios locales.',
+  'cloudSync.strategy.preferLocal': 'Gana lo local',
+  'cloudSync.strategy.preferLocalDesc': 'Cuando ambos lados cambiaron, sube la versión local y reemplaza los cambios de la nube.',
+  'cloudSync.convergent.title': 'Sincronización convergente de múltiples dispositivos',
+  'cloudSync.convergent.experimental': 'Experimental',
+  'cloudSync.convergent.desc': 'Usa una réplica CRDT cifrada para preservar ediciones sin conexión, eliminaciones concurrentes y cambios de cada proveedor conectado.',
+  'cloudSync.convergent.active': 'CRDT v2 está activo. Las escrituras del proveedor se verifican después de la subida.',
+  'cloudSync.convergent.paused': 'CRDT v2 está en pausa en este dispositivo; los metadatos de la nube se conservan.',
+  'cloudSync.convergent.enabled': 'Sincronización convergente habilitada',
+  'cloudSync.convergent.preview.title': 'Vista previa de migración',
+  'cloudSync.convergent.preview.entities': 'Entidades',
+  'cloudSync.convergent.preview.providers': 'Proveedores',
+  'cloudSync.convergent.preview.conflicts': 'Conflictos',
+  'cloudSync.convergent.preview.compatibility': 'Una instantánea v1 completa permanece en cada payload cifrado para clientes más antiguos.',
+  'cloudSync.convergent.preview.confirm': 'Crear réplica CRDT',
+  'cloudSync.convergent.preview.status.ready': 'Listo',
+  'cloudSync.convergent.preview.status.empty': 'Vacío',
+  'cloudSync.convergent.preview.status.unavailable': 'No disponible',
+  'cloudSync.convergent.preview.status.blocked': 'Bloqueado',
+  'cloudSync.convergent.preview.schema': 'esquema',
+  'cloudSync.convergent.field.presence': 'presencia',
+  'cloudSync.convergent.field.position': 'posición',
+  'cloudSync.convergent.conflicts.title': 'Conflictos de campo ({count})',
+  'cloudSync.convergent.conflict.empty': 'Vacío / eliminado',
+  'cloudSync.convergent.conflict.secretSet': 'El secreto está establecido',
+  'cloudSync.convergent.conflict.current': 'ganador actual',
+  'cloudSync.convergent.conflict.choose': 'Elegir',
+  'cloudSync.convergent.conflict.resolved': 'Conflicto resuelto y sincronizado',
+  'cloudSync.convergent.downgrade.desc': 'Reemplaza los archivos v2 de cada proveedor conectado con una instantánea heredada.',
+  'cloudSync.convergent.downgrade.button': 'Degradar',
+  'cloudSync.convergent.downgrade.confirm': '¿Degradar cada proveedor conectado a la sincronización heredada? Esto elimina los metadatos CRDT después de la verificación de escritura.',
+  'cloudSync.convergent.downgrade.done': 'Sincronización convergente degradada',
+  'cloudSync.status.title': 'Estado de sincronización',
+  'cloudSync.status.localVersion': 'Versión local',
+  'cloudSync.status.remoteVersion': 'Versión remota',
+  'cloudSync.history.title': 'Historial de sincronización',
+  'cloudSync.history.upload': 'Subida',
+  'cloudSync.history.download': 'Descarga',
+  'cloudSync.history.resolved': 'Resuelto',
+  'cloudSync.history.error': 'Error',
+  'cloudSync.localBackups.title': 'Historial de copias de seguridad locales',
+  'cloudSync.localBackups.desc': 'Netcatty conserva puntos de restauración locales antes de los cambios de versión de la app y antes de las restauraciones de la bóveda.',
+  'cloudSync.localBackups.retentionTitle': 'Retención de copias de seguridad',
+  'cloudSync.localBackups.retentionDesc': 'Elige cuántas copias de seguridad locales debe conservar Netcatty.',
+  'cloudSync.localBackups.maxCount': 'Copias máximas',
+  'cloudSync.localBackups.maxSaved': 'Retención de copia guardada: {count}',
+  'cloudSync.localBackups.maxInvalid': 'Ingresa un número entre 1 y 100.',
+  'cloudSync.localBackups.empty': 'Aún no hay copias de seguridad locales.',
+  'cloudSync.localBackups.reason.appVersionChange': 'Antes del cambio de versión de la app',
+  'cloudSync.localBackups.reason.beforeRestore': 'Antes de la restauración',
+  'cloudSync.localBackups.versionChange': '{from} -> {to}',
+  'cloudSync.localBackups.counts': '{hosts} hosts, {keys} claves, {snippets} snippets, {notes} notas',
+  'cloudSync.localBackups.restore': 'Restaurar',
+  'cloudSync.localBackups.restoreSuccess': 'Copia de seguridad local restaurada.',
+  'cloudSync.localBackups.restoreFailedTitle': 'Falló la restauración',
+  'cloudSync.localBackups.restoreMissing': 'No se encontró la copia de seguridad.',
+  'cloudSync.localBackups.protectiveBackupFailed': 'No se pudo crear la copia de seguridad de protección, por lo que la restauración se canceló para proteger tus datos actuales. Resuelve el problema subyacente (p. ej., acceso al keychain) e inténtalo de nuevo. Detalles: {message}',
+  'cloudSync.localBackups.restoreConfirmTitle': '¿Restaurar esta copia de seguridad?',
+  'cloudSync.localBackups.restoreConfirmDesc': 'Tus hosts, claves, snippets y configuraciones actuales se reemplazarán con el contenido de esta copia de seguridad. Se crea automáticamente una instantánea de protección de tus datos actuales primero.',
+  'cloudSync.localBackups.restoreConfirmButton': 'Restaurar',
+  'cloudSync.localBackups.restoreConfirmCancel': 'Cancelar',
+  'cloudSync.localBackups.unavailableTitle': 'Copias de seguridad locales no disponibles',
+  'cloudSync.localBackups.unavailableDesc': 'Esta plataforma no expone un keychain seguro a Netcatty, por lo que las copias de seguridad locales no se pueden escribir de forma segura. Instala Netcatty en un sistema con un keychain compatible para habilitar el historial de copias de seguridad locales.',
+  'cloudSync.localBackups.lockedTitle': 'Se requiere clave maestra',
+  'cloudSync.localBackups.lockedDesc': 'Configura o desbloquea tu clave maestra antes de restaurar una copia de seguridad, para que las credenciales restauradas permanezcan cifradas.',
+  'cloudSync.revisionHistory.viewButton': 'Historial',
+  'cloudSync.revisionHistory.title': 'Historial de versiones de la bóveda',
+  'cloudSync.revisionHistory.description': 'Explora y restaura versiones anteriores de tu bóveda desde el historial de revisiones de Gist.',
+  'cloudSync.revisionHistory.empty': 'No se encontraron revisiones.',
+  'cloudSync.revisionHistory.current': 'Actual',
+  'cloudSync.revisionHistory.revision': 'Revisión',
+  'cloudSync.revisionHistory.revisionPreview': 'Contenido de la revisión',
+  'cloudSync.revisionHistory.device': 'Dispositivo',
+  'cloudSync.revisionHistory.hosts': 'Hosts',
+  'cloudSync.revisionHistory.keys': 'Claves',
+  'cloudSync.revisionHistory.snippets': 'Snippets',
+  'cloudSync.revisionHistory.notes': 'Notas',
+  'cloudSync.revisionHistory.identities': 'Identidades',
+  'cloudSync.revisionHistory.restoreButton': 'Restaurar esta versión',
+  'cloudSync.revisionHistory.restored': 'Bóveda restaurada desde la revisión seleccionada.',
+  'cloudSync.revisionHistory.revisionNotFound': 'Revisión no encontrada o no contiene datos de la bóveda.',
+  'cloudSync.revisionHistory.decryptFailed': 'No se puede descifrar esta revisión. Puede que se haya cifrado con una contraseña maestra diferente.',
+  'cloudSync.changeKey.title': 'Cambiar clave maestra',
+  'cloudSync.changeKey.current': 'Clave maestra actual',
+  'cloudSync.changeKey.new': 'Nueva clave maestra',
+  'cloudSync.changeKey.confirmNew': 'Confirmar nueva clave maestra',
+  'cloudSync.changeKey.currentPlaceholder': 'Ingresa la clave maestra actual',
+  'cloudSync.changeKey.newPlaceholder': 'Ingresa la nueva clave maestra',
+  'cloudSync.changeKey.confirmPlaceholder': 'Confirma la nueva clave maestra',
+  'cloudSync.changeKey.fillAll': 'Completa todos los campos',
+  'cloudSync.changeKey.minLength': 'La nueva clave maestra debe tener al menos 8 caracteres',
+  'cloudSync.changeKey.notMatch': 'Las nuevas claves maestras no coinciden',
+  'cloudSync.changeKey.incorrectCurrent': 'Clave maestra actual incorrecta',
+  'cloudSync.changeKey.failed': 'No se pudo cambiar la clave maestra',
+  'cloudSync.changeKey.desc': 'Esto volverá a cifrar tu bóveda. Asegúrate de recordar la nueva clave.',
+  'cloudSync.changeKey.showKeys': 'Mostrar claves',
+  'cloudSync.changeKey.updatedToast': 'Clave maestra actualizada',
+  'cloudSync.changeKey.updateButton': 'Actualizar clave',
+  'cloudSync.unlock.title': 'Ingresa la clave maestra',
+  'cloudSync.unlock.masterKey': 'Clave maestra',
+  'cloudSync.unlock.desc':
+    'Ingresa tu clave maestra una vez para habilitar la sincronización cifrada. Se almacenará de forma segura usando el keychain de tu sistema operativo.',
+  'cloudSync.unlock.placeholder': 'Ingresa tu clave maestra',
+  'cloudSync.unlock.empty': 'Ingresa tu clave maestra',
+  'cloudSync.unlock.incorrect': 'Clave maestra incorrecta',
+  'cloudSync.unlock.failed': 'No se pudo desbloquear la bóveda',
+  'cloudSync.unlock.showKey': 'Mostrar clave',
+  'cloudSync.unlock.notNow': 'Ahora no',
+  'cloudSync.unlock.readyToast': 'Bóveda lista',
+  'cloudSync.unlock.unlockButton': 'Desbloquear',
+  'cloudSync.header.vaultReady': 'Bóveda lista',
+  'cloudSync.header.preparingVault': 'Preparando bóveda...',
+  'cloudSync.header.providersConnected': '{count} proveedor(es) conectado(s)',
+  'cloudSync.githubFlow.title': 'Conectar con GitHub',
+  'cloudSync.githubFlow.desc': 'Copia el código de abajo e ingrésalo en GitHub para autorizar a Netcatty.',
+  'cloudSync.githubFlow.copyCode': 'Copiar código',
+  'cloudSync.githubFlow.copied': '¡Copiado!',
+  'cloudSync.githubFlow.openGitHub': 'Abrir GitHub',
+  'cloudSync.githubFlow.waiting': 'Esperando autorización...',
+  'cloudSync.conflict.title': 'Se detectó un conflicto de versiones',
+  'cloudSync.conflict.desc': 'Elige qué versión conservar',
+  'cloudSync.conflict.local': 'LOCAL',
+  'cloudSync.conflict.cloud': 'NUBE',
+  'cloudSync.conflict.detailsTitle': 'Datos cambiados',
+  'cloudSync.conflict.detailsCounts': 'Local {local} · Nube {cloud} · Conflictos {conflicts}',
+  'cloudSync.conflict.entity.hosts': 'Hosts',
+  'cloudSync.conflict.entity.keys': 'Claves',
+  'cloudSync.conflict.entity.identities': 'Identidades',
+  'cloudSync.conflict.entity.proxyProfiles': 'Perfiles de proxy',
+  'cloudSync.conflict.entity.snippets': 'Snippets',
+  'cloudSync.conflict.entity.notes': 'Notas',
+  'cloudSync.conflict.entity.noteGroups': 'Grupos de notas',
+  'cloudSync.conflict.entity.customGroups': 'Grupos',
+  'cloudSync.conflict.entity.snippetPackages': 'Paquetes de snippets',
+  'cloudSync.conflict.entity.portForwardingRules': 'Reenvío de puertos',
+  'cloudSync.conflict.entity.groupConfigs': 'Configuración de grupos',
+  'cloudSync.conflict.entity.settings': 'Configuración',
+  'cloudSync.conflict.keepLocal': 'Sobrescribir la nube (conservar local)',
+  'cloudSync.conflict.useCloud': 'Descargar la nube (sobrescribir local)',
+  'cloudSync.connect.browserContinue': 'Completar la autorización en el navegador',
+  'cloudSync.connect.browserCancelled': 'La autorización anterior del navegador fue cancelada',
+  'cloudSync.connect.github.success': 'GitHub se conectó correctamente',
+  'cloudSync.connect.github.failedTitle': 'Falló la conexión a GitHub',
+  'cloudSync.connect.github.timeout': 'Se agotó el tiempo de espera de la conexión a GitHub. Verifica tu red o la configuración del proxy.',
+  'cloudSync.connect.github.networkError': 'No se puede acceder a GitHub. Verifica tu red o la configuración del proxy.',
+  'cloudSync.connect.google.failedTitle': 'Falló la conexión a Google',
+  'cloudSync.connect.onedrive.failedTitle': 'Falló la conexión a OneDrive',
+  'cloudSync.sync.success': 'Sincronizado con {provider}',
+  'cloudSync.sync.failed': 'Falló la sincronización',
+  'cloudSync.sync.failedTitle': 'Falló la sincronización',
+  'cloudSync.sync.errorTitle': 'Error de sincronización',
+  'cloudSync.resolve.downloaded': 'Datos de la nube descargados',
+  'cloudSync.resolve.uploaded': 'Datos locales subidos',
+  'cloudSync.resolve.failedTitle': 'Falló la resolución del conflicto',
+  'cloudSync.clearLocal.title': 'Borrar datos locales',
+  'cloudSync.clearLocal.desc': 'Restablece la versión local y el historial de sincronización. La próxima sincronización descargará desde la nube.',
+  'cloudSync.clearLocal.button': 'Borrar',
+  'cloudSync.clearLocal.dialog.title': '¿Borrar los datos locales de la bóveda?',
+  'cloudSync.clearLocal.dialog.desc': 'Esto restablecerá la versión local a 0 y borrará el historial de sincronización. Tu próxima sincronización descargará los datos de la nube, reemplazando los datos locales.',
+  'cloudSync.clearLocal.dialog.cancel': 'Cancelar',
+  'cloudSync.clearLocal.dialog.confirm': 'Borrar datos locales',
+  'cloudSync.clearLocal.toast.title': 'Datos locales borrados',
+  'cloudSync.clearLocal.toast.desc': 'Versión local restablecida a 0. Sincroniza para descargar desde la nube.',
+
+  // Keychain
+  'keychain.filter.key': 'CLAVE',
+  'keychain.filter.certificate': 'CERTIFICADO',
+  'keychain.action.generateKey': 'Generar clave',
+  'keychain.action.importKey': 'Importar clave',
+  'keychain.action.newIdentity': 'Nueva identidad',
+  'keychain.action.importCertificate': 'Importar certificado',
+  'keychain.view.grid': 'Cuadrícula',
+  'keychain.view.list': 'Lista',
+  'keychain.section.keys': 'Claves',
+  'keychain.section.identities': 'Identidades',
+  'keychain.count.items': '{count} elementos',
+  'keychain.empty.title': 'Configura tus claves',
+  'keychain.empty.desc': 'Importa o genera claves SSH para una autenticación segura.',
+  'keychain.panel.generateKey': 'Generar clave',
+  'keychain.panel.newKey': 'Nueva clave',
+  'keychain.panel.keyDetails': 'Detalles de la clave',
+  'keychain.panel.editKey': 'Editar clave',
+  'keychain.panel.editIdentity': 'Editar identidad',
+  'keychain.panel.newIdentity': 'Nueva identidad',
+  'keychain.panel.keyExport': 'Exportación de clave',
+  'keychain.validation.labelRequired': 'Ingresa una etiqueta para la clave',
+  'keychain.validation.labelAndPrivateKeyRequired': 'La etiqueta y la clave privada son obligatorias',
+  'keychain.validation.labelAndUsernameRequired': 'La etiqueta y el nombre de usuario son obligatorios',
+  'keychain.error.generationUnavailable':
+    'La generación de claves no está disponible: asegúrate de que la app se esté ejecutando en Electron',
+  'keychain.error.generateKeyPairFailed': 'No se pudo generar el par de claves',
+  'keychain.error.generateKeyFailed': 'No se pudo generar la clave',
+  'keychain.error.keyGenerationTitle': 'Generación de claves',
+  'keychain.export.exportTo': 'Exportar a *',
+  'keychain.export.selectHost': 'Seleccionar host',
+  'keychain.export.location': 'Ubicación ~ $1 *',
+  'keychain.export.filename': 'Nombre de archivo ~ $2 *',
+  'keychain.export.note':
+    'La exportación de claves actualmente solo admite sistemas {unix}. Usa la sección {advanced} para personalizar el script de exportación.',
+  'keychain.export.script': 'Script *',
+  'keychain.export.scriptPlaceholder': 'Script de exportación...',
+  'keychain.export.missingCredentials':
+    'El host no tiene contraseña ni clave guardadas. Primero agrega credenciales de contraseña al host.',
+  'keychain.export.successTitle': 'Exportación exitosa',
+  'keychain.export.successMessage': 'Clave pública exportada y adjuntada a {host}',
+  'keychain.export.failedTitle': 'Falló la exportación',
+  'keychain.export.failedMessage': 'No se pudo exportar la clave: {error}',
+  'keychain.export.failedPrefix': 'Falló la exportación: {error}',
+  'keychain.export.exitCode': 'El comando terminó con el código {code}',
+  'keychain.export.exporting': 'Exportando...',
+  'keychain.export.exportAndAttach': 'Exportar y adjuntar',
+  'keychain.export.title': 'Exportación de clave',
+  'keychain.export.exportToRequired': 'Exportar a *',
+  'keychain.export.selectHostPlaceholder': 'Selecciona un host...',
+  'keychain.export.locationLabel': 'Ubicación ~ $1 *',
+  'keychain.export.filenameLabel': 'Nombre de archivo ~ $2 *',
+  'keychain.export.advanced': 'Avanzado',
+  'keychain.export.note.supportsOnly': 'La exportación de claves actualmente solo admite',
+  'keychain.export.note.systems': 'sistemas.',
+  'keychain.export.note.use': 'Usa la',
+  'keychain.export.note.customize': 'sección para personalizar el script de exportación.',
+  'keychain.export.scriptRequired': 'Script *',
+  'keychain.export.exportToHost': 'Exportar al host',
+  'keychain.export.failedGeneric': 'Falló la exportación: {message}',
+  'keychain.field.label': 'Etiqueta',
+  'keychain.field.labelRequired': 'Etiqueta *',
+  'keychain.field.labelPlaceholder': 'Etiqueta de la clave',
+  'keychain.field.privateKeyRequired': 'Clave privada *',
+  'keychain.field.publicKey': 'Clave pública',
+  'keychain.field.certificatePlaceholder': 'Contenido del certificado (opcional)',
+  'keychain.generate.keyType': 'Tipo de clave',
+  'keychain.generate.keySize': 'Tamaño de clave',
+  'keychain.generate.labelPlaceholder': 'Etiqueta de la clave',
+  'keychain.generate.passphrasePlaceholder': 'Frase de contraseña (opcional)',
+  'keychain.generate.savePassphrase': 'Guardar frase de contraseña',
+  'keychain.generate.generate': 'Generar',
+  'keychain.generate.generateSave': 'Generar y guardar',
+  'keychain.import.dropHint': 'Suelta un archivo de clave aquí',
+  'keychain.import.importFromFile': 'Importar desde archivo',
+  'keychain.import.saveKey': 'Guardar clave',
+  'keychain.import.importedKeyLabel': 'Clave importada',
+  'keychain.identity.usernameRequired': 'Nombre de usuario *',
+  'keychain.identity.method.passwordOnly': 'Contraseña',
+  'keychain.identity.summary.password': 'Contraseña de autenticación',
+  'keychain.identity.summary.key': 'Clave de autenticación',
+  'keychain.identity.summary.certificate': 'Certificado de autenticación',
+  'keychain.identity.summary.passwordAndKey': 'Contraseña y clave de autenticación',
+  'keychain.identity.summary.passwordAndCertificate': 'Contraseña y certificado de autenticación',
+  'keychain.identity.summary.none': 'Sin credenciales',
+  'keychain.identity.selectCredential': 'Seleccionar {kind}',
+  'keychain.identity.save': 'Guardar',
+  'keychain.identity.update': 'Actualizar',
+  'keychain.keyDialog.newTitle': 'Nueva clave',
+  'keychain.keyDialog.newDesc': 'Agregar una nueva clave SSH',
+  'keychain.keyDialog.editTitle': 'Editar clave',
+  'keychain.keyDialog.editDesc': 'Actualizar esta clave SSH',
+  'keychain.keyDialog.updateKey': 'Actualizar clave',
+
+  // Tabs
+  'tabs.closeSessionAria': 'Cerrar sesión',
+  'tabs.closeLogViewAria': 'Cerrar vista de registro',
+  'tabs.closePluginViewAria': 'Cerrar {title}',
+  'tabs.logPrefix': 'Registro:',
+  'tabs.logLocal': 'Local',
+  'tabs.copyTab': 'Copiar pestaña',
+  'tabs.copyTabToNewWindow': 'Copiar pestaña a una nueva ventana',
+  'tabs.copyTabToNewWindowFailed': 'No se pudo abrir la pestaña en una nueva ventana',
+  'tabs.closeOthers': 'Cerrar las demás',
+  'tabs.closeToRight': 'Cerrar pestañas a la derecha',
+  'tabs.closeAll': 'Cerrar todas',
+  'keychain.edit.labelRequired': 'Etiqueta *',
+  'keychain.edit.keyLabelPlaceholder': 'Etiqueta de la clave',
+  'keychain.edit.privateKeyRequired': 'Clave privada *',
+  'keychain.edit.publicKey': 'Clave pública',
+  'keychain.edit.certificate': 'Certificado',
+  'keychain.edit.certificatePlaceholder': 'Contenido del certificado (opcional)',
+  'keychain.edit.filePath': 'Ruta del archivo',
+  'keychain.edit.keyExport': 'Exportación de clave',
+  'keychain.edit.exportToHost': 'Exportar al host',
+
+  // Snippets
+  'snippets.searchPlaceholder': 'Buscar scripts...',
+  'snippets.action.newSnippet': 'Nuevo snippet',
+  'snippets.action.newPackage': 'Nuevo paquete de scripts',
+  'snippets.action.import': 'Importar',
+  'snippets.action.selectSnippets': 'Seleccionar snippets',
+  'snippets.panel.newTitle': 'Nuevo snippet',
+  'snippets.panel.editTitle': 'Editar snippet',
+  'snippets.panel.newAutomationTitle': 'Nuevo script de automatización',
+  'snippets.panel.editAutomationTitle': 'Editar script de automatización',
+  'snippets.panel.resizeWidth': 'Cambiar el ancho del panel',
+  'snippets.field.description': 'Descripción de la acción',
+  'snippets.field.descriptionPlaceholder': 'Ejemplo: verificar la carga de la red',
+  'snippets.field.package': 'Agregar un paquete de scripts',
+  'snippets.field.packagePlaceholder': 'Selecciona o crea un paquete de scripts',
+  'snippets.field.createPackage': 'Crear paquete de scripts',
+  'snippets.field.scriptRequired': 'Script *',
+  'snippets.scriptEditor.expand': 'Abrir en diálogo',
+  'snippets.scriptEditor.resize': 'Cambiar la altura del editor',
+  'snippets.scriptEditor.modalTitle': 'Editar script',
+  'snippets.targets.title': 'Destinos',
+  'snippets.targets.add': 'Agregar destinos',
+  'snippets.targets.selectHosts': 'Hosts',
+  'snippets.targets.selectGroups': 'Grupos',
+  'snippets.targets.noGroups': 'No se encontraron grupos',
+  'snippets.targets.allHosts': 'Aplicar a todos los hosts',
+  'snippets.targets.allHostsShort': 'Todos los hosts',
+  'snippets.targets.allHostsActive': 'Se aplica a cada host conectable.',
+  'snippets.history.title': 'Historial de Shell',
+  'snippets.history.subtitle': '{count} comandos',
+  'snippets.history.emptyTitle': 'Aún no hay historial de Shell',
+  'snippets.history.emptyDesc': 'Los comandos que ejecutes aparecerán aquí',
+  'snippets.history.loadMore': 'Cargar más',
+  'snippets.history.separator': '•',
+  'snippets.history.labelPlaceholder': 'Establece una etiqueta para este snippet',
+  'snippets.history.saveAsSnippet': 'Guardar como snippet',
+  'snippets.history.time.justNow': 'justo ahora',
+  'snippets.history.time.minutesAgo': 'hace {count}m',
+  'snippets.history.time.hoursAgo': 'hace {count}h',
+  'snippets.history.time.daysAgo': 'hace {count}d',
+  'snippets.breadcrumb.allPackages': 'Todos los paquetes de scripts',
+  'snippets.breadcrumb.separator': '›',
+  'snippets.empty.title': 'Crea scripts',
+  'snippets.empty.desc': 'Guarda comandos comunes como snippets de código, o escribe scripts de automatización para operaciones repetibles.',
+  'snippets.search.noResults.title': 'Sin coincidencias',
+  'snippets.search.noResults.desc': 'Ningún script o paquete de scripts coincide con "{query}". Prueba con otro término de búsqueda o limpia la búsqueda para explorar.',
+  'snippets.section.packages': 'Paquetes de scripts',
+  'snippets.section.snippets': 'Scripts',
+  'snippets.kind.codeSnippet': 'Snippet de código',
+  'snippets.kind.automationScript': 'Script de automatización',
+  'snippets.package.count': '{count} script(s)',
+  'snippets.commandFallback': 'Comando',
+  'snippets.view.grid': 'Cuadrícula',
+  'snippets.view.list': 'Lista',
+  'snippets.selection.selected': '{count} seleccionados',
+  'snippets.selection.selectVisible': 'Seleccionar visibles',
+  'snippets.selection.deselectAll': 'Deseleccionar todo',
+  'snippets.selection.exportSelected': 'Exportar seleccionados ({count})',
+  'snippets.selection.deleteSelected': 'Eliminar ({count})',
+  'snippets.selection.deleteConfirmTitle': '¿Eliminar los elementos seleccionados ({count})?',
+  'snippets.selection.deleteConfirmDesc': 'Los elementos seleccionados se eliminarán de forma permanente. Esta acción no se puede deshacer.',
+  'snippets.selection.deleteSuccess': 'Elementos seleccionados eliminados: {count}.',
+  'snippets.export.snippet': 'Exportar snippet',
+  'snippets.export.package': 'Exportar paquete de scripts',
+  'snippets.export.toast.empty': 'No hay snippets para exportar.',
+  'snippets.export.toast.successTitle': 'Exportación lista',
+  'snippets.export.toast.success': 'Se exportaron {count} snippet(s).',
+  'snippets.import.toast.empty': 'No se encontraron snippets importables.',
+  'snippets.import.toast.failedTitle': 'Falló la importación',
+  'snippets.import.toast.invalidDesc': 'Este no es un archivo de snippets válido de Netcatty.',
+  'snippets.import.toast.successTitle': 'Importación completada',
+  'snippets.import.toast.summary': 'Importados {imported}, sobrescritos {overwritten}, omitidos {skipped}.',
+  'snippets.import.modal.title': 'Importar snippets',
+  'snippets.import.modal.desc': 'Elige uno o más archivos JSON de snippets de Netcatty. Netcatty los mostrará en vista previa antes de importar cualquier cosa.',
+  'snippets.import.modal.exampleTitle': 'Ejemplo de JSON',
+  'snippets.import.modal.noFile': 'Aún no se seleccionó ningún archivo. Usa el formato de ejemplo de abajo, o un arreglo JSON simple de snippets, y luego elige uno o más archivos.',
+  'snippets.import.modal.chooseFile': 'Elegir archivo',
+  'snippets.import.modal.downloadExamples': 'Descargar ejemplos',
+  'snippets.import.modal.multipleFiles': '{count} archivos seleccionados',
+  'snippets.import.modal.parsedSummary': '{files} archivo(s), {total} script(s), {packages} paquete(s) de scripts, {conflicts} comando(s) duplicado(s). Las vinculaciones de host se ignoran.',
+  'snippets.import.modal.confirm': 'Confirmar importación',
+  'snippets.import.conflict.title': '¿Importar snippets?',
+  'snippets.import.conflict.desc': '{file} contiene {total} snippet(s). Ya existen {conflicts} comando(s) duplicado(s).',
+  'snippets.import.conflict.hostBindingsNote': 'Las vinculaciones de host no se importan ni se exportan con los snippets.',
+  'snippets.import.conflict.skip': 'Omitir duplicados',
+  'snippets.import.conflict.overwrite': 'Sobrescribir duplicados',
+  'snippets.packageDialog.title': 'Nuevo paquete de scripts',
+  'snippets.packageDialog.parent': 'Padre: {parent}',
+  'snippets.packageDialog.root': 'Raíz',
+  'snippets.packageDialog.placeholder': 'p. ej., ops/maintenance',
+  'snippets.packageDialog.hint': 'Usa "/" para crear paquetes de scripts anidados.',
+
+  // Snippets Rename Dialog
+  'snippets.renameDialog.title': 'Renombrar paquete de scripts',
+  'snippets.renameDialog.currentPath': 'Ruta actual: {path}',
+  'snippets.renameDialog.placeholder': 'Ingresa el nuevo nombre',
+  'snippets.renameDialog.error.empty': 'El nombre del paquete de scripts no puede estar vacío',
+  'snippets.renameDialog.error.duplicate': 'Ya existe un paquete de scripts con este nombre',
+  'snippets.renameDialog.error.invalidChars': 'El nombre del paquete de scripts solo puede contener letras, números, guiones y guiones bajos',
+
+  'snippets.field.noAutoRun': 'Solo pegar (no auto-ejecutar)',
+  'snippets.field.multiLineRunMode': 'Ejecución multilínea',
+  'snippets.field.multiLineRunMode.paste': 'Enviar todo de una vez',
+  'snippets.field.multiLineRunMode.lineDelay': 'Enviar línea por línea',
+  'snippets.field.multiLineRunModeHint': 'Usa línea por línea para inicios de sesión que piden credenciales (prompt) o macros de dispositivos.',
+  // Snippet Shortkey
+  'snippets.field.shortkey': 'Atajo de teclado',
+  'snippets.shortkey.placeholder': 'Haz clic para configurar el atajo',
+  'snippets.shortkey.recording': 'Presiona una combinación de teclas...',
+  'snippets.shortkey.hint': 'Presiona este atajo en la terminal para enviar el comando rápidamente.',
+  'snippets.shortkey.clear': 'Borrar atajo',
+  'snippets.shortkey.error.systemConflict': 'Este atajo entra en conflicto con {name}',
+  'snippets.shortkey.error.snippetConflict': 'Este atajo ya lo usa el snippet: {name}',
+
+  'snippets.variables.dialogTitle': 'Variables del snippet',
+  'snippets.variables.dialogDesc': 'Completa los valores de "{label}" antes de ejecutar.',
+  'snippets.variables.hint': 'Los valores se insertan tal cual en el script (sin escapado de shell).',
+  'snippets.variables.preview': 'Vista previa',
+  'snippets.variables.placeholder': 'Ingresa un valor',
+  'snippets.variables.placeholderDefault': 'Predeterminado: {value}',
+  'snippets.variables.required': 'Esta variable es obligatoria',
+  'snippets.variables.run': 'Ejecutar',
+  'snippets.field.variablesHelp': 'Usa {{name}} o {{name:default}} para los marcadores de posición en el script.',
+  'snippets.field.variablesDetected': 'Variables',
+  'snippets.field.variableDefault': 'predeterminado {value}',
+
+  // Serial Port
+  'serial.button': 'Serial',
+  'serial.modal.title': 'Conectar a puerto serial',
+  'serial.modal.desc': 'Configura los ajustes de conexión del puerto serial',
+  'serial.field.port': 'Puerto serial',
+  'serial.field.selectPort': 'Selecciona un puerto...',
+  'serial.field.baudRate': 'Velocidad de baudios',
+  'serial.field.dataBits': 'Bits de datos',
+  'serial.field.stopBits': 'Bits de parada',
+  'serial.field.stopBits15Warning': 'Los 1.5 bits de parada pueden no ser compatibles con todos los dispositivos Windows',
+  'serial.field.parity': 'Paridad',
+  '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.customPortPlaceholder': 'p. ej., /dev/ttys001 o COM1',
+  'serial.type.hardware': 'Hardware',
+  'serial.type.pseudo': 'Pseudoterminal',
+  'serial.type.custom': 'Personalizado',
+  'serial.parity.none': 'Ninguna',
+  'serial.parity.even': 'Par',
+  'serial.parity.odd': 'Impar',
+  'serial.parity.mark': 'Marca',
+  'serial.parity.space': 'Espacio',
+  'serial.flowControl.none': 'Ninguno',
+  'serial.flowControl.xon/xoff': 'XON/XOFF (Software)',
+  'serial.flowControl.rts/cts': 'RTS/CTS (Hardware)',
+  'serial.field.localEcho': 'Forzar eco local',
+  'serial.field.localEchoDesc': 'Hacer eco de los caracteres escritos localmente (para dispositivos sin eco remoto)',
+  'serial.field.lineMode': 'Modo de línea',
+  'serial.field.lineModeDesc': 'Almacenar en búfer la entrada y enviarla al presionar Enter (en lugar de carácter por carácter)',
+  'serial.field.backspaceBehavior': 'Tecla de retroceso',
+  'serial.field.backspaceBehaviorDesc': 'Usa Ctrl+H para dispositivos de red que no responden al código de Retroceso predeterminado.',
+  'serial.backspace.default': 'Predeterminado (DEL, 0x7F)',
+  'serial.backspace.ctrlH': 'Ctrl+H (BS, 0x08)',
+  'serial.field.charset': 'Codificación de caracteres',
+  'serial.connectionError': 'No se pudo conectar al puerto serial',
+  'serial.field.baudRatePlaceholder': 'Selecciona o ingresa la velocidad de baudios...',
+  'serial.field.baudRateEmpty': 'Ingresa una velocidad de baudios personalizada',
+  'serial.field.customBaudRate': 'Usando velocidad de baudios personalizada',
+  'serial.field.saveConfig': 'Guardar configuración',
+  'serial.field.saveConfigDesc': 'Guarda esta configuración serial en hosts para acceso rápido',
+  'serial.field.configLabel': 'Nombre de configuración',
+  'serial.field.configLabelPlaceholder': 'p. ej., Arduino Uno',
+  'serial.connectAndSave': 'Conectar y guardar',
+  'serial.edit.title': 'Configuración del puerto serial',
+
+  // Keyboard Interactive Authentication (2FA/MFA)
+  'keyboard.interactive.title': 'Se requiere autenticación',
+  'keyboard.interactive.desc': 'El servidor requiere autenticación adicional.',
+  'keyboard.interactive.descWithHost': 'El servidor {hostname} requiere autenticación adicional.',
+  'keyboard.interactive.response': 'Respuesta',
+  'keyboard.interactive.enterCode': 'Ingresa el código de verificación',
+  'keyboard.interactive.enterResponse': 'Ingresa la respuesta',
+  'keyboard.interactive.submit': 'Enviar',
+  'keyboard.interactive.verifying': 'Verificando...',
+  'keyboard.interactive.savePassword': 'Guardar contraseña',
+
+  // Passphrase Modal for encrypted SSH keys
+  'passphrase.title': 'Frase de contraseña de la clave SSH',
+  'passphrase.desc': 'Ingresa la frase de contraseña de {keyName}',
+  'passphrase.descWithHost': 'Ingresa la frase de contraseña de {keyName} para conectarte a {hostname}',
+  'passphrase.label': 'Frase de contraseña',
+  'passphrase.keyPath': 'Clave',
+  'passphrase.unlock': 'Desbloquear',
+  'passphrase.unlocking': 'Desbloqueando...',
+  'passphrase.skip': 'Omitir',
+  'passphrase.remember': 'Recordar esta frase de contraseña',
+
+  // Text Editor
+  'sftp.editor.wordWrap': 'Ajuste de línea',
+  'sftp.editor.maximize': 'Maximizar',
+  'sftp.editor.unsavedTitle': 'Cambios sin guardar',
+  'sftp.editor.unsavedMessage': '{fileName} tiene cambios sin guardar. ¿Guardar antes de cerrar?',
+  'sftp.editor.discardChanges': 'Descartar',
+  'sftp.editor.saveAndClose': 'Guardar y cerrar',
+  'sftp.editor.quitBlockedByDirty': 'Editores sin guardar: guarda o descarta antes de salir',
+
+};

application/i18n/locales/es/vault.ts

@@ -0,0 +1,983 @@
+import type { Messages } from '../types';
+
+export const esVaultMessages: Messages = {
+  // Notes
+  'notes.search.placeholder': 'Buscar notas, hosts, etiquetas...',
+  'notes.action.newNote': 'Nueva nota',
+  'notes.action.newGroup': 'Nueva carpeta',
+  'notes.action.importMarkdown': 'Importar Markdown',
+  'notes.action.exportNote': 'Exportar nota',
+  'notes.action.exportGroup': 'Exportar carpeta',
+  'notes.action.exportAll': 'Exportar notas',
+  'notes.import.toast.success': 'Se importaron {count} nota(s)',
+  'notes.import.toast.noNotes': 'No se importaron archivos Markdown.',
+  'notes.import.toast.failed': 'No se pudieron importar los archivos Markdown.',
+  'notes.import.toast.inProgress': 'Ya hay una importación de Markdown en curso.',
+  'notes.import.toast.skipped': 'Se omitieron {count} archivo(s) no compatible(s).',
+  'notes.export.toast.success': 'Se exportaron {count} nota(s)',
+  'notes.export.toast.empty': 'No hay notas para exportar.',
+  'notes.export.toast.failed': 'No se pudieron exportar las notas.',
+  'notes.codeBlock.copied': 'Copiado',
+  'notes.codeBlock.copyFailed': 'No se pudo copiar el bloque de código.',
+  'notes.group.prompt': 'Ruta de la carpeta',
+  'notes.group.all': 'Cuaderno',
+  'notes.group.ungrouped': 'Sin grupo',
+  'notes.section.notebooks': 'Cuaderno',
+  'notes.section.notes': 'Notas',
+  'notes.mode.edit': 'Editar',
+  'notes.mode.split': 'Dividir',
+  'notes.mode.preview': 'Vista previa',
+  'notes.title.placeholder': 'Título de la nota',
+  'notes.editor.placeholder': 'Escribe notas Markdown aquí...',
+  'notes.preview.empty': 'Aún no hay nada para previsualizar.',
+  'notes.empty.title': 'Aún no hay notas',
+  'notes.empty.desc': 'Crea notas Markdown para runbooks, recordatorios y detalles de traspaso de servidores.',
+  'notes.empty.group': 'No hay notas en este cuaderno.',
+  'notes.search.noResults': 'No se encontraron notas.',
+
+  // Vault import
+  'vault.import.title': 'Agrega datos a tu Vault',
+  'vault.import.desc':
+    'Transfiere tus conexiones desde clientes populares. Selecciona un formato de archivo para comenzar la migración.',
+  'vault.import.chooseFormat': 'Selecciona un formato de archivo',
+  'vault.import.destination.title': '¿Dónde deberían ir los hosts importados?',
+  'vault.import.destination.preserve': 'Conservar los grupos originales',
+  'vault.import.destination.existing': 'Elegir un grupo',
+  'vault.import.destination.new': 'Crear un grupo',
+  'vault.import.destination.noGroups': 'No hay grupos disponibles',
+  'vault.import.destination.newPlaceholder': 'Nombre del grupo nuevo',
+  'vault.import.destination.settings': 'Ubicación de importación',
+  'vault.import.destination.settingsHint': 'Elige dónde se colocarán los hosts nuevos',
+  'vault.import.destination.done': 'Listo',
+  'vault.import.securecrt.directoryHint': 'Selecciona la carpeta de sesiones de SecureCRT.',
+  'vault.import.securecrt.chooseSource': 'Elige una fuente de importación de SecureCRT.',
+  'vault.import.securecrt.sourceQuestion': '¿Qué te gustaría importar?',
+  'vault.import.securecrt.promptTitle': 'Importar desde SecureCRT',
+  'vault.import.securecrt.promptDesc':
+    'Elige la carpeta de sesiones de SecureCRT para importar todas las sesiones conservando la estructura de carpetas, o selecciona un solo archivo de sesión .ini.',
+  'vault.import.securecrt.folder': 'Carpeta de sesiones',
+  'vault.import.securecrt.folderDesc': 'Importa todas las sesiones y conserva la estructura de carpetas.',
+  'vault.import.securecrt.file': 'Archivo de sesión único',
+  'vault.import.securecrt.fileDesc': 'Importa una sesión .ini de SecureCRT.',
+  'vault.import.csv.tip': 'Importación masiva: usa la plantilla CSV.',
+  'vault.import.csv.downloadTemplate': 'Descargar plantilla CSV',
+  'vault.import.toast.start': 'Importando desde {format}...',
+  'vault.import.toast.completedTitle': 'Importación completada',
+  'vault.import.toast.failedTitle': 'Importación fallida',
+  'vault.import.toast.noEntries': 'No se encontraron entradas importables en {format}.',
+  'vault.import.toast.noNewHosts': 'No se importaron hosts nuevos desde {format}.',
+  'vault.import.toast.summary':
+    'Se importaron {count} hosts (omitidos {skipped}, duplicados {duplicates}).',
+  'vault.import.toast.firstIssue': 'Primer problema: {issue}',
+  'vault.import.progress.title': 'Importando hosts',
+  'vault.import.progress.reading': 'Leyendo archivo',
+  'vault.import.progress.parsing': 'Analizando hosts',
+  'vault.import.progress.preparing': 'Preparando cambios',
+  'vault.import.progress.saving': 'Guardando hosts',
+  'vault.import.progress.complete': 'Importación completa',
+  'vault.import.progress.failed': 'Importación fallida',
+  'vault.import.progress.persistFailed': 'No se pudieron guardar los hosts importados. Libera algo de espacio de almacenamiento local e inténtalo de nuevo.',
+  'vault.import.progress.rollbackFailed': 'La importación no se pudo revertir de forma segura. Es posible que queden algunos hosts importados; revisa el Vault antes de reintentar.',
+  'vault.import.progress.summary':
+    'Se importaron {count} hosts; omitidos {skipped}; duplicados {duplicates}.',
+  'vault.import.progress.keepOpen': 'Mantén Netcatty abierto mientras la importación se ejecuta en segundo plano.',
+  'vault.import.progress.fileSummary': '{name} · {count} archivos',
+  'vault.import.progress.fileCount': '{completed} de {total} archivos',
+  'vault.import.mobaxterm.chooseEncoding': 'Elige cómo leer tu archivo de MobaXterm.',
+  'vault.import.mobaxterm.encodingQuestion': '¿Qué codificación de texto usa este archivo?',
+  'vault.import.mobaxterm.auto': 'Detección automática',
+  'vault.import.mobaxterm.autoDesc': 'Recomendado. Usa UTF-8 cuando sea válido; de lo contrario, la codificación de Windows en chino.',
+  'vault.import.mobaxterm.utf8': 'UTF-8',
+  'vault.import.mobaxterm.utf8Desc': 'Úsalo para archivos guardados o convertidos como UTF-8.',
+  'vault.import.mobaxterm.gb18030': 'Windows en chino',
+  'vault.import.mobaxterm.gb18030Desc': 'Úsalo para archivos antiguos exportados en Windows en chino.',
+  'vault.import.sshConfig.chooseMode': 'Elige cómo importar tu archivo de configuración SSH.',
+  'vault.import.sshConfig.modeQuestion': '¿Cómo te gustaría importar?',
+  'vault.import.sshConfig.importOnly': 'Solo importar',
+  'vault.import.sshConfig.importOnlyDesc': 'Importación única. Los cambios no se sincronizarán de vuelta al archivo.',
+  'vault.import.sshConfig.managed': 'Sincronización administrada',
+  'vault.import.sshConfig.managedDesc': 'Mantén la sincronización. Los cambios se guardarán de vuelta en el archivo.',
+  'vault.import.sshConfig.managedDestinationHint': 'La sincronización administrada siempre usa su propio grupo administrado; el destino anterior aplica solo a la importación única.',
+  'vault.import.sshConfig.managedGroup': 'ssh config',
+  'vault.import.sshConfig.managedSuccess': 'Se importaron {count} hosts. El archivo ahora está administrado.',
+  'vault.import.sshConfig.alreadyManaged': 'Este archivo ya está siendo administrado.',
+  'vault.import.sshConfig.alreadyManagedDesc': 'Este archivo ya está administrado en el grupo "{group}". Elimina primero la fuente administrada existente si quieres volver a importar.',
+  'vault.import.sshConfig.noFilePath': 'No se puede administrar este archivo.',
+  'vault.import.sshConfig.noFilePathDesc': 'No se pudo determinar la ruta del archivo. La sincronización administrada requiere acceso al sistema de archivos.',
+
+  // Known Hosts
+  'knownHosts.search.placeholder': 'Buscar hosts conocidos...',
+  'knownHosts.action.scanSystem': 'Escanear sistema',
+  'knownHosts.action.importFile': 'Importar archivo',
+  'knownHosts.action.browseFile': 'Explorar archivo',
+  'knownHosts.empty.title': 'No hay hosts conocidos',
+  'knownHosts.empty.desc':
+    "Los hosts conocidos son servidores SSH a los que te conectaste antes. Importa desde el archivo known_hosts de tu sistema para comenzar.",
+  'knownHosts.results.showingLimited':
+    'Mostrando {shown} de {total} hosts. Usa la búsqueda para encontrar hosts específicos.',
+  'knownHosts.toast.scanUnavailable': 'El escaneo del sistema no está disponible en esta plataforma.',
+  'knownHosts.toast.scanNoFile': 'No se encontró un archivo known_hosts del sistema.',
+  'knownHosts.toast.scanNoEntries': 'No se encontraron entradas utilizables en known_hosts.',
+  'knownHosts.toast.scanImported': 'Se importaron {count} hosts nuevos.',
+  'knownHosts.toast.scanNoNew': 'No se encontraron hosts nuevos.',
+  'knownHosts.toast.scanFailed': 'No se pudo escanear el known_hosts del sistema.',
+
+  // Port Forwarding
+  'pf.empty.title': 'Configura el reenvío de puertos',
+  'pf.empty.desc': 'Guarda el reenvío de puertos para acceder a bases de datos, aplicaciones web y otros servicios.',
+  'pf.title': 'Reenvío de puertos',
+  'pf.rulesCount': '{count} reglas',
+  'pf.wizard.editTitle': 'Editar reenvío de puertos',
+  'pf.wizard.newTitle': 'Nuevo reenvío de puertos',
+  'pf.wizard.saveChanges': 'Guardar cambios',
+  'pf.wizard.done': 'Listo',
+  'pf.wizard.continue': 'Continuar',
+  'pf.wizard.cancel': 'Cancelar',
+  'pf.wizard.skipWizard': 'Omitir asistente',
+  'pf.error.hostNotFound': 'No se encontró el host',
+  'pf.toast.titleWithLabel': 'Reenvío de puertos: {label}',
+  'pf.type.local': 'Local',
+  'pf.type.remote': 'Remoto',
+  'pf.type.dynamic': 'Dinámico',
+  'pf.type.menu.local': 'Reenvío local',
+  'pf.type.menu.remote': 'Reenvío remoto',
+  'pf.type.menu.dynamic': 'Reenvío dinámico',
+  'pf.type.local.desc': 'El reenvío local te permite acceder al puerto de escucha de un servidor remoto como si fuera local.',
+  'pf.type.remote.desc': 'El reenvío remoto abre un puerto en la máquina remota y reenvía las conexiones al host local (actual).',
+  'pf.type.dynamic.desc': 'El reenvío dinámico de puertos convierte a Netcatty en un servidor proxy SOCKS.',
+  'pf.wizard.type.title': 'Selecciona el tipo de reenvío de puertos:',
+  'pf.wizard.localConfig.title': 'Configura el puerto local y la dirección de enlace:',
+  'pf.wizard.localConfig.desc': 'Este puerto estará abierto en el dispositivo local (actual) y recibirá el tráfico.',
+  'pf.wizard.localConfig.localPort': 'Número de puerto local *',
+  'pf.wizard.bindAddress': 'Dirección de enlace',
+  'pf.wizard.remoteHost.title': 'Selecciona el host remoto:',
+  'pf.wizard.remoteHost.desc': 'Selecciona un host donde estará abierto el puerto. El tráfico de este puerto se reenviará al host de destino.',
+  'pf.wizard.remoteConfig.title': 'Configura el puerto y la dirección de enlace:',
+  'pf.wizard.remoteConfig.desc': 'El tráfico se reenviará desde el puerto especificado y la dirección de interfaz del host seleccionado.',
+  'pf.wizard.remoteConfig.remotePort': 'Número de puerto remoto *',
+  'pf.wizard.destination.title': 'Selecciona el host de destino:',
+  'pf.wizard.destination.desc.local': 'Ingresa el destino remoto al que quieres acceder a través del túnel.',
+  'pf.wizard.destination.desc.remote': 'La dirección y el puerto de destino hacia donde se reenviará el tráfico.',
+  'pf.wizard.destination.address': 'Dirección de destino *',
+  'pf.wizard.destination.addressPlaceholder': 'p. ej. 127.0.0.1 o 192.168.1.100',
+  'pf.wizard.destination.port': 'Número de puerto de destino *',
+  'pf.wizard.sshServer.title': 'Selecciona el servidor SSH:',
+  'pf.wizard.sshServer.desc.dynamic': 'Selecciona el servidor SSH que actuará como tu proxy SOCKS.',
+  'pf.wizard.sshServer.desc.default': 'Selecciona el servidor SSH que tunelizará tu tráfico hacia el destino.',
+  'pf.wizard.label.title': 'Selecciona la etiqueta:',
+  'pf.wizard.label.placeholder.dynamic': 'p. ej. Proxy SOCKS',
+  'pf.wizard.label.placeholder.default': 'p. ej. MySQL Producción',
+  'pf.wizard.label.placeholder.remoteRule': 'p. ej. Regla remota',
+  'pf.wizard.placeholders.portExample': 'p. ej. {port}',
+  'pf.action.newForwarding': 'Nuevo reenvío',
+  'pf.form.labelPlaceholder': 'Etiqueta de la regla',
+  'pf.form.intermediateHost': 'Host intermedio *',
+  'pf.form.createRule': 'Crear regla',
+  'pf.form.openWizard': 'Abrir asistente',
+  'pf.form.openWizardTitle': 'Abrir el asistente de reenvío de puertos',
+  'pf.view.grid': 'Cuadrícula',
+  'pf.view.list': 'Lista',
+  'pf.rule.summary.local': 'Local {bindAddress}:{localPort} -> Túnel SSH -> {remoteHost}:{remotePort}',
+  'pf.rule.summary.remote': 'Remoto {bindAddress}:{localPort} -> Túnel SSH -> local {remoteHost}:{remotePort}',
+  'pf.rule.summary.dynamic': 'SOCKS en {bindAddress}:{localPort}',
+  'pf.tooltip.relayHost': 'Host de relevo',
+  'pf.tooltip.hostLabel': 'Host',
+  'pf.tooltip.hostAddress': 'Dirección',
+  'pf.tooltip.noHost': 'No hay host de relevo configurado',
+  'pf.tooltip.localDesc': 'Reenvío de puerto local: accede a servicios remotos a través del túnel SSH',
+  'pf.tooltip.remoteDesc': 'Reenvío de puerto remoto: expone servicios locales al host remoto',
+  'pf.tooltip.dynamicDesc': 'Proxy SOCKS dinámico: enruta el tráfico a través del túnel SSH',
+  'pf.deleteActive.title': '¿Eliminar el reenvío de puertos activo?',
+  'pf.deleteActive.desc': 'Esta regla de reenvío de puertos "{label}" está activa actualmente. Eliminarla primero detendrá el túnel.',
+  'pf.deleteActive.confirm': 'Detener y eliminar',
+  'pf.form.autoStart': 'Inicio automático',
+  'pf.form.autoStartDesc': 'Inicia automáticamente esta regla cuando se abra la aplicación',
+
+  // SFTP
+  'sftp.newFolder': 'Nueva carpeta',
+  'sftp.newFile': 'Nuevo archivo',
+  'sftp.filter': 'Filtrar',
+  'sftp.filter.placeholder': 'Filtrar por nombre de archivo...',
+  'sftp.bookmark.add': 'Marcar esta ruta',
+  'sftp.bookmark.remove': 'Quitar marcador',
+  'sftp.bookmark.list': 'Rutas marcadas',
+  'sftp.bookmark.addGlobal': '+Global',
+  'sftp.bookmark.addGlobalTooltip': 'Guardar como marcador global (compartido entre todos los hosts)',
+  'sftp.bookmark.empty': 'Aún no hay marcadores',
+  'sftp.columns.name': 'Nombre',
+  'sftp.columns.modified': 'Modificado',
+  'sftp.columns.size': 'Tamaño',
+  'sftp.columns.kind': 'Tipo',
+  'sftp.columns.configure': 'Elegir columnas visibles',
+  'sftp.columns.actions': 'Acciones',
+  'sftp.sort.directoriesFirst': 'Carpetas primero',
+  'sftp.emptyDirectory': 'Directorio vacío',
+  'sftp.nav.up': 'Subir un nivel',
+  'sftp.nav.home': 'Ir al inicio',
+  'sftp.nav.refresh': 'Actualizar',
+  'sftp.upload': 'Subir',
+  'sftp.uploadFiles': 'Subir archivos',
+  'sftp.uploadFolder': 'Subir carpeta',
+  'sftp.dragDropToUpload': 'Arrastra y suelta archivos aquí para subirlos',
+  'sftp.retry': 'Reintentar',
+  'sftp.context.open': 'Abrir',
+  'sftp.context.navigateTo': 'Navegar a',
+  'sftp.context.moveTo': 'Mover a...',
+  'sftp.context.moveToParent': 'Mover al directorio principal',
+  'sftp.moveTo.title': 'Mover a directorio',
+  'sftp.moveTo.placeholder': 'Ingresa la ruta del directorio de destino',
+  'sftp.moveTo.confirm': 'Mover',
+  'sftp.moveTo.pathNotFound': 'Directorio no encontrado o inaccesible',
+  'sftp.context.download': 'Descargar',
+  'sftp.context.copyToOtherPane': 'Copiar al otro panel',
+  'sftp.copyToOtherPane.unavailable': 'Abre la vista SFTP de dos paneles y conecta el panel de destino antes de copiar archivos.',
+  'sftp.copyCurrentPath': 'Copiar ruta actual',
+  'sftp.copyCurrentPath.success': 'Ruta actual copiada',
+  'sftp.copyCurrentPath.error': 'No se pudo copiar la ruta actual',
+  'sftp.viewMode.label': 'Modo de vista',
+  'sftp.viewMode.list': 'Vista de lista',
+  'sftp.viewMode.tree': 'Vista de árbol',
+  'sftp.viewMode.switchToList': 'Cambiar a vista de lista',
+  'sftp.viewMode.switchToTree': 'Cambiar a vista de árbol',
+  'sftp.tree.loadError': 'No se pudo cargar el directorio',
+  'sftp.tree.loading': 'Cargando...',
+  'sftp.kind.folder': 'Carpeta',
+  'sftp.context.rename': 'Renombrar',
+  'sftp.context.permissions': 'Permisos',
+  'sftp.context.delete': 'Eliminar',
+  'sftp.context.refresh': 'Actualizar',
+  'sftp.context.uploadFiles': 'Subir archivo(s)...',
+  'sftp.context.uploadFilesHere': 'Subir archivo(s) aquí...',
+  'sftp.context.uploadFolder': 'Subir carpeta...',
+  'sftp.context.uploadFolderHere': 'Subir carpeta aquí...',
+  'sftp.context.downloadSelected': 'Descargar seleccionados ({count})',
+  'sftp.context.deleteSelected': 'Eliminar seleccionados ({count})',
+  'sftp.dropFilesHere': 'Suelta los archivos aquí',
+  'sftp.itemsCount': '{count} elementos',
+  'sftp.selectedCount': '{count} seleccionados',
+  'sftp.path.doubleClickToEdit': 'Haz doble clic para editar la ruta',
+  'sftp.showHiddenPaths': 'Rutas ocultas',
+  'sftp.task.waiting': 'Esperando...',
+  'sftp.transfer.preparing': 'preparando...',
+  'sftp.status.loading': 'Cargando...',
+  'sftp.status.uploading': 'Subiendo...',
+  'sftp.status.ready': 'Listo',
+  'sftp.transfers': 'Transferencias',
+  'sftp.transfers.active': '{count} activas',
+  'sftp.transfers.clearCompleted': 'Limpiar completadas',
+  'sftp.transfers.calculatingTotal': 'Calculando el tamaño total...',
+  'sftp.transfers.filesCount': '{count} archivos',
+  'sftp.transfers.filesProgress': '{current}/{total} archivos',
+  // Progressive folder walk: total is "found so far", not a fixed grand total.
+  'sftp.transfers.filesDiscoveredProgress': '{completed} completados · {discovered} encontrados',
+  'sftp.transfers.expandChildren': 'Mostrar archivos',
+  'sftp.transfers.collapseChildren': 'Ocultar archivos',
+  'sftp.transfers.expandChildList': 'Mostrar detalle',
+  'sftp.transfers.collapseChildList': 'Ocultar',
+  'sftp.transfers.retryAction': 'Reintentar',
+  'sftp.transfers.dismissAction': 'Descartar',
+  '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.copyTargetPathSuccess': 'Ruta de destino copiada',
+  'sftp.transfers.copyTargetPathError': 'No se pudo copiar la ruta de destino',
+  'sftp.transfers.pathConflict.title': 'Transferencia bloqueada',
+  'sftp.transfers.pathConflict.paused': 'Otra transferencia de "{name}" está en pausa. Reanúdala o cancélala primero.',
+  'sftp.transfers.pathConflict.inProgress': 'Otra transferencia de "{name}" ya está en curso.',
+  'sftp.transferCenter.title': 'Transferencias de archivos',
+  'sftp.transferCenter.quitConfirm': '{count} transferencia(s) de archivos quedaron sin terminar. El progreso se guardará y deberá reanudarse manualmente la próxima vez. ¿Salir de todos modos?',
+  'sftp.transferCenter.phase.scanning': 'Escaneando',
+  'sftp.transferCenter.phase.compressing': 'Comprimiendo',
+  'sftp.transferCenter.phase.uploading': 'Subiendo',
+  'sftp.transferCenter.phase.transferring': 'Transfiriendo',
+  'sftp.transferCenter.phase.extracting': 'Extrayendo',
+  'sftp.transferCenter.phase.verifying': 'Verificando',
+  'sftp.transferCenter.bucket.active': 'En progreso',
+  'sftp.transferCenter.bucket.all': 'Todas',
+  'sftp.transferCenter.bucket.queued': 'En cola',
+  'sftp.transferCenter.bucket.paused': 'En pausa',
+  'sftp.transferCenter.bucket.failed': 'Fallidas',
+  'sftp.transferCenter.bucket.attention': 'Requieren atención',
+  'sftp.transferCenter.bucket.completed': 'Completadas',
+  'sftp.transferCenter.status.pending': 'Preparando',
+  'sftp.transferCenter.status.resuming': 'Reconectando y reanudando…',
+  'sftp.transferCenter.status.queued': 'En cola',
+  'sftp.transferCenter.status.transferring': 'Transfiriendo',
+  'sftp.transferCenter.status.pausing': 'Pausando',
+  'sftp.transferCenter.status.paused': 'En pausa',
+  'sftp.transferCenter.status.attention': 'Requiere atención',
+  'sftp.transferCenter.status.interrupted': 'Interrumpida: reanúdala manualmente',
+  'sftp.transferCenter.status.completed': 'Completada',
+  'sftp.transferCenter.status.failed': 'Fallida',
+  'sftp.transferCenter.status.cancelled': 'Cancelada',
+  'sftp.transferCenter.background': 'Segundo plano',
+  'sftp.transferCenter.pause': 'Pausar',
+  'sftp.transferCenter.resume': 'Reanudar',
+  'sftp.transferCenter.prioritize': 'Transferir a continuación',
+  'sftp.transferCenter.pauseAll': 'Pausar todas',
+  'sftp.transferCenter.resumeAll': 'Reanudar todas',
+  'sftp.transferCenter.empty': 'No hay transferencias en esta categoría',
+  'sftp.transferCenter.showBackground': 'Mostrar {count} transferencias en segundo plano',
+  'sftp.transferCenter.hideBackground': 'Ocultar transferencias en segundo plano',
+  'sftp.transferCenter.clear': 'Limpiar registros',
+  'sftp.transferCenter.applyAll': 'Aplicar a todas',
+  'sftp.transfers.resizeNameColumn': 'Redimensionar la columna de nombre de archivo',
+  'sftp.transfers.dragToResize': 'Arrastra para redimensionar',
+  'sftp.goUp': 'Subir un nivel',
+  'sftp.goToTerminalCwd': 'Ir al directorio de la terminal',
+  'sftp.locatePathInTerminal': 'Abrir ruta en la terminal',
+  'sftp.followTerminalCwd': 'Seguir el directorio de la terminal',
+  'sftp.followTerminalCwd.enable': 'Habilitar el seguimiento del directorio de la terminal',
+  'sftp.followTerminalCwd.disable': 'Deshabilitar el seguimiento del directorio de la terminal',
+  'sftp.encoding.label': 'Codificación de nombres de archivo',
+  'sftp.encoding.auto': 'Auto',
+  'sftp.encoding.utf8': 'UTF-8',
+  'sftp.encoding.gb18030': 'GB18030',
+  'sftp.goHome': 'Ir al inicio',
+  'sftp.folderName': 'Nombre de la carpeta',
+  'sftp.folderName.placeholder': 'Ingresa el nombre de la carpeta',
+  'sftp.fileName': 'Nombre del archivo',
+  'sftp.fileName.placeholder': 'Ingresa el nombre del archivo',
+  'sftp.prompt.newFolderName': '¿Nombre de la carpeta nueva?',
+  'sftp.rename.title': 'Renombrar',
+  'sftp.rename.newName': 'Nombre nuevo',
+  'sftp.rename.placeholder': 'Ingresa el nombre nuevo',
+  'sftp.confirm.deleteOne': '¿Eliminar "{name}"?',
+  'sftp.deleteConfirm.single': '¿Eliminar "{name}"?',
+  'sftp.deleteConfirm.title': '¿Eliminar {count} elemento(s)?',
+  'sftp.deleteConfirm.desc': 'Esta acción no se puede deshacer. Se eliminará lo siguiente:',
+  'sftp.deleteConfirm.descSingle': 'Esta acción no se puede deshacer.',
+  'sftp.deleteConfirm.host': 'Host',
+  'sftp.deleteConfirm.path': 'Ruta',
+  'sftp.error.loadFailed': 'No se pudo cargar el directorio',
+  'sftp.error.downloadFailed': 'No se pudo descargar',
+  'sftp.error.uploadFailed': 'No se pudo subir',
+  'sftp.error.deleteFailed': 'No se pudo eliminar',
+  'sftp.error.createFolderFailed': 'No se pudo crear la carpeta',
+  'sftp.error.createFileFailed': 'No se pudo crear el archivo',
+  'sftp.error.invalidFileName': 'El nombre de archivo contiene caracteres no válidos: {chars}',
+  'sftp.error.reservedName': 'Este nombre de archivo está reservado por el sistema',
+  'sftp.overwrite.title': 'El archivo ya existe',
+  'sftp.overwrite.desc': 'Ya existe un archivo llamado "{name}". ¿Quieres reemplazarlo?',
+  'sftp.overwrite.confirm': 'Reemplazar',
+  'sftp.error.renameFailed': 'No se pudo renombrar',
+  'sftp.picker.title': 'Seleccionar host',
+  'sftp.picker.desc': 'Elige un host para el panel {side}',
+  'sftp.picker.searchPlaceholder': 'Buscar hosts...',
+  'sftp.picker.local.title': 'Sistema de archivos local',
+  'sftp.picker.local.desc': 'Explorar archivos locales',
+  'sftp.picker.local.badge': 'Local',
+  'sftp.picker.connected.section': 'Conectados',
+  'sftp.picker.connected.badge': 'En vivo',
+  'sftp.picker.connected.connecting': 'Conectando',
+  'sftp.picker.noMatch': 'No hay hosts que coincidan',
+  'sftp.permissions.title': 'Editar permisos',
+  'sftp.permissions.owner': 'Propietario',
+  'sftp.permissions.group': 'Grupo',
+  'sftp.permissions.others': 'Otros',
+  'sftp.permissions.octal': 'Octal',
+  'sftp.permissions.symbolic': 'Simbólico',
+  'sftp.permissions.success': 'Permisos actualizados correctamente',
+  'sftp.permissions.failed': 'No se pudieron actualizar los permisos',
+  'sftp.pane.local': 'Local',
+  'sftp.pane.remote': 'Remoto',
+  'sftp.pane.selectHost': 'Seleccionar host',
+  'sftp.pane.selectHostToStart': 'Selecciona un host para comenzar',
+  'sftp.pane.chooseFilesystem': 'Elige un sistema de archivos local o remoto para explorar',
+  'sftp.tabs.addTab': 'Agregar pestaña nueva',
+  'sftp.tabs.closeTab': 'Cerrar pestaña',
+  'sftp.tabs.newTab': 'Pestaña nueva',
+  'sftp.tabs.copyDefaultPath': 'Copiar pestaña (ruta predeterminada)',
+  'sftp.tabs.copyCurrentPath': 'Copiar e ir a la ruta actual',
+  'sftp.conflict.title': 'Conflicto de archivos',
+  'sftp.conflict.desc': 'Ya existe un archivo con el mismo nombre en el destino',
+  'sftp.conflict.alreadyExistsSuffix': 'ya existe',
+  'sftp.conflict.existingFile': 'Archivo existente',
+  'sftp.conflict.newFile': 'Archivo nuevo',
+  'sftp.conflict.size': 'Tamaño:',
+  'sftp.conflict.modified': 'Modificado:',
+  'sftp.conflict.applyToAll': 'Aplicar esta acción a los {count} conflictos restantes',
+  'sftp.conflict.action.stop': 'Detener',
+  'sftp.conflict.action.skip': 'Omitir',
+  'sftp.conflict.action.keepBoth': 'Conservar ambos',
+  'sftp.conflict.action.duplicate': 'Duplicar',
+  'sftp.conflict.action.merge': 'Combinar',
+  'sftp.conflict.action.replace': 'Reemplazar',
+
+  // SFTP Upload Phases
+  'sftp.upload.phase.compressing': 'Comprimiendo',
+  'sftp.upload.phase.uploading': 'Subiendo',
+  'sftp.upload.phase.extracting': 'Extrayendo',
+  'sftp.upload.phase.compressed': 'Comprimido',
+
+  // SFTP File Opener
+  'sftp.context.copyPath': 'Copiar ruta del archivo',
+  'sftp.context.openWithDefault': 'Abrir con la aplicación predeterminada del sistema',
+  'sftp.context.openWith': 'Abrir con...',
+  'sftp.context.edit': 'Editar',
+  'sftp.context.preview': 'Vista previa',
+  'sftp.opener.title': 'Abrir con',
+  'sftp.opener.desc': 'Elige una aplicación para abrir este archivo',
+  'sftp.opener.builtInEditor': 'Editor integrado',
+  'sftp.opener.editDescription': 'Editar archivos de texto',
+  'sftp.opener.builtInImageViewer': 'Visor de imágenes integrado',
+  'sftp.opener.previewDescription': 'Previsualizar imágenes',
+  'sftp.opener.systemApp': 'Elegir aplicación...',
+  'sftp.opener.systemAppDescription': 'Selecciona una aplicación de tu computadora',
+  'sftp.opener.onlySystemApp': 'Este archivo solo se puede abrir con una aplicación externa',
+  'sftp.opener.noAppsAvailable': 'No hay aplicaciones disponibles',
+  'sftp.opener.noExtension': 'archivos sin extensión',
+  'sftp.opener.setDefault': 'Usar siempre esto para archivos {ext}',
+  'sftp.opener.confirmTitle': '¿Establecer como predeterminado?',
+  'sftp.opener.confirmDescription': '¿Quieres usar siempre {app} para archivos {ext}?',
+  'sftp.opener.yesRemember': 'Sí, recordar esta elección',
+  'sftp.opener.justOnce': 'Solo esta vez',
+  'sftp.opener.confirm.title': 'Establecer aplicación predeterminada',
+  'sftp.opener.confirm.desc': '¿Quieres abrir siempre los archivos .{ext} con esta aplicación?',
+  'sftp.editor.title': 'Editor de texto',
+  'sftp.editor.save': 'Guardar en remoto',
+  'sftp.editor.saving': 'Guardando...',
+  'sftp.editor.saved': 'Guardado correctamente',
+  'sftp.editor.saveFailed': 'No se pudo guardar el archivo',
+  'sftp.editor.unsavedChanges': 'Tienes cambios sin guardar. ¿Cerrar de todos modos?',
+  'sftp.editor.syntaxHighlight': 'Resaltado de sintaxis',
+  'sftp.preview.title': 'Vista previa de imagen',
+  'sftp.preview.zoomIn': 'Acercar',
+  'sftp.preview.zoomOut': 'Alejar',
+  'sftp.preview.resetZoom': 'Restablecer zoom',
+  'sftp.preview.fitToWindow': 'Ajustar a la ventana',
+
+  // Settings > SFTP File Associations
+  'settings.tab.sftpFileAssociations': 'SFTP',
+  'settings.sftp.transferConcurrency': 'Concurrencia de transferencias',
+  'settings.sftp.transferConcurrency.desc': 'Cantidad máxima de archivos transferidos en paralelo para el mismo endpoint, incluidos los contenidos de carpetas y los archivos seleccionados por separado. Los valores más altos pueden mejorar la velocidad, pero pueden abrumar a algunos servidores.',
+  'settings.sftp.transferPoolIdleTtl': 'Mantener activa la conexión de transferencia',
+  'settings.sftp.transferPoolIdleTtl.desc': 'Cuánto tiempo las conexiones SFTP dedicadas de transferencia permanecen activas después de estar inactivas. Los valores más largos reducen la demora de arranque en frío antes de la siguiente subida o descarga. Las transferencias ocupadas nunca se cierran.',
+  'settings.sftp.transferPoolIdleTtl.1m': '1 minuto',
+  'settings.sftp.transferPoolIdleTtl.5m': '5 minutos',
+  'settings.sftp.transferPoolIdleTtl.15m': '15 minutos',
+  'settings.sftp.transferPoolIdleTtl.30m': '30 minutos',
+  'settings.sftp.transferPoolIdleTtl.never': 'Hasta que se cierre la aplicación',
+  'settings.ssh.transportIdleTtl': 'Mantener activa la conexión SSH',
+  'settings.ssh.transportIdleTtl.desc': 'Cuánto tiempo una conexión SSH compartida permanece activa después de liberar el último terminal, la exploración SFTP, la transferencia masiva o el arrendamiento de reenvío de puertos. Mientras esté activa, reconectarse al mismo host puede omitir la reautenticación (incluida la MFA). Las sesiones y transferencias activas nunca se cierran.',
+  'settings.ssh.transportIdleTtl.1m': '1 minuto',
+  'settings.ssh.transportIdleTtl.5m': '5 minutos',
+  'settings.ssh.transportIdleTtl.15m': '15 minutos',
+  'settings.ssh.transportIdleTtl.30m': '30 minutos',
+  'settings.ssh.transportIdleTtl.never': 'Hasta que se cierre la aplicación',
+  'settings.sftp.defaultOpener': 'Aplicación predeterminada para abrir archivos',
+  'settings.sftp.defaultOpener.desc': 'Elige la aplicación predeterminada para abrir archivos sin una asociación de archivos específica',
+  'settings.sftp.defaultOpener.ask': 'Preguntar siempre',
+  'settings.sftp.defaultOpener.askDesc': 'Muestra un diálogo para elegir una aplicación cada vez',
+  'settings.sftp.defaultOpener.builtInDesc': 'Abrir archivos de texto en el editor integrado por defecto',
+  'settings.sftp.defaultOpener.systemApp': 'Elegir aplicación...',
+  'settings.sftp.defaultOpener.systemAppDesc': 'Abrir archivos con una aplicación específica por defecto',
+  'settings.sftpFileAssociations.title': 'Asociaciones de archivos SFTP',
+  'settings.sftpFileAssociations.desc': 'Configura las aplicaciones predeterminadas para abrir archivos por extensión',
+  'settings.sftpFileAssociations.extension': 'Extensión',
+  'settings.sftpFileAssociations.application': 'Aplicación',
+  'settings.sftpFileAssociations.noAssociations': 'No hay asociaciones de archivos configuradas',
+  'settings.sftpFileAssociations.remove': 'Quitar',
+  'settings.sftpFileAssociations.removeConfirm': '¿Quitar la asociación para .{ext}?',
+
+  // Settings > SFTP Behavior
+  'settings.sftp.doubleClickBehavior': 'Comportamiento del doble clic',
+  'settings.sftp.doubleClickBehavior.desc': 'Elige la acción al hacer doble clic en un archivo en la vista SFTP',
+  'settings.sftp.doubleClickBehavior.open': 'Abrir archivo',
+  'settings.sftp.doubleClickBehavior.transfer': 'Transferir al otro panel',
+  'settings.sftp.doubleClickBehavior.openDesc': 'Abrir el archivo en la aplicación predeterminada',
+  'settings.sftp.doubleClickBehavior.transferDesc': 'Transferir el archivo al host activo del otro panel',
+  'settings.sshDeepLink.title': 'Enlaces SSH y Telnet',
+  'settings.sshDeepLink.enable': 'Abrir enlaces ssh:// y telnet:// con Netcatty',
+  'settings.sshDeepLink.enableDesc': 'Permite que Netcatty maneje los enlaces ssh:// y telnet:// de los navegadores y otras aplicaciones.',
+  'settings.explorerContextMenu.title': 'Explorador de Windows',
+  'settings.explorerContextMenu.enable': 'Mostrar "Abrir en Netcatty" en los menús contextuales de carpetas',
+  'settings.explorerContextMenu.enableDesc': 'Agrega un elemento de clic derecho para las carpetas y los fondos de carpeta, para que puedas abrir una terminal local allí. Se aplica de inmediato; no es necesario reinstalar.',
+  'settings.jmsDeepLink.title': 'Enlaces de JumpServer',
+  'settings.jmsDeepLink.enable': 'Manejar enlaces jms://',
+  'settings.jmsDeepLink.enableDesc': 'Registra a Netcatty como el controlador de los enlaces jms:// del cliente de JumpServer. Puede entrar en conflicto con el cliente oficial de JumpServer.',
+
+  // Settings > SFTP Auto Sync
+  'settings.sftp.autoSync': 'Sincronización automática con el remoto',
+  'settings.sftp.autoSync.desc': 'Sincroniza automáticamente los cambios de archivos de vuelta al servidor remoto al abrir archivos con aplicaciones externas',
+  'settings.sftp.autoSync.enable': 'Habilitar la sincronización automática',
+  'settings.sftp.autoSync.enableDesc': 'Cuando guardas un archivo en una aplicación externa, los cambios se subirán automáticamente al servidor remoto',
+
+  // Settings > SFTP Auto Open Sidebar
+  'settings.sftp.autoOpenSidebar': 'Abrir la barra lateral automáticamente al conectar',
+  'settings.sftp.autoOpenSidebar.desc': 'Abre automáticamente la barra lateral del explorador de archivos SFTP al conectar a un host',
+  'settings.sftp.autoOpenSidebar.enable': 'Habilitar la apertura automática de la barra lateral',
+  'settings.sftp.autoOpenSidebar.enableDesc': 'La barra lateral de SFTP se abrirá automáticamente cuando una sesión de terminal se conecte a un host remoto',
+  'settings.sftp.followTerminalCwd': 'Seguir el directorio de la terminal',
+  'settings.sftp.followTerminalCwd.desc': 'Sincroniza automáticamente el explorador SFTP de la barra lateral con el directorio de trabajo de la terminal (alternar en la barra de herramientas)',
+  'settings.sftp.followTerminalCwd.enable': 'Habilitar el seguimiento del directorio de la terminal por defecto',
+  'settings.sftp.followTerminalCwd.enableDesc': 'Cuando la barra lateral de SFTP está abierta, el modo de seguimiento permanece activado por defecto y se actualiza después de los comandos cd de la terminal',
+
+  'settings.sftp.defaultViewMode': 'Modo de vista predeterminado',
+  'settings.sftp.defaultViewMode.desc': 'Elige el modo de vista predeterminado al abrir una pestaña SFTP nueva. Las preferencias por host anulan esta configuración.',
+  'settings.sftp.defaultViewMode.list': 'Vista de lista',
+  'settings.sftp.defaultViewMode.listDesc': 'Muestra los archivos en una lista plana del directorio actual',
+  'settings.sftp.defaultViewMode.tree': 'Vista de árbol',
+  'settings.sftp.defaultViewMode.treeDesc': 'Muestra los archivos en una estructura de árbol jerárquica',
+
+  'sftp.autoSync.success': 'Archivo sincronizado con el remoto: {fileName}',
+  'sftp.autoSync.error': 'No se pudo sincronizar el archivo: {error}',
+
+  // SFTP Folder Upload Progress
+  'sftp.upload.progress': 'Subiendo {current} de {total} archivos...',
+  'sftp.upload.uploading': 'Subiendo...',
+  'sftp.upload.compressing': 'Comprimiendo...',
+  'sftp.upload.extracting': 'Extrayendo...',
+  'sftp.upload.scanning': 'Escaneando archivos...',
+  'sftp.upload.completed': 'Completado',
+  'sftp.upload.compressed': 'Transferencia comprimida',
+  'sftp.upload.currentFile': 'Actual: {fileName}',
+  'sftp.upload.cancelled': 'Subida cancelada',
+  'sftp.upload.noFiles': 'No hay archivos para subir',
+  'sftp.upload.partialSuccess': 'Se subieron {success} archivo(s); {failed} fallaron',
+  'sftp.upload.cancel': 'Cancelar',
+  'sftp.upload.completedToPath': 'Subido a {path}',
+
+  // SFTP Download
+  'sftp.download.completed': 'Descargado',
+  'sftp.download.cancelled': 'Descarga cancelada',
+
+  // SFTP Reconnecting
+  'sftp.reconnecting.title': 'Reconectando...',
+  'sftp.reconnecting.desc': 'Se perdió la conexión, intentando reconectar',
+  'sftp.reconnected': 'Conexión restablecida',
+  'sftp.error.reconnectFailed': 'No se pudo reconectar. Inténtalo de nuevo.',
+  'sftp.error.connectionLostManual': 'Se perdió la conexión. Vuelve a conectar manualmente.',
+  'sftp.error.connectionLostReconnecting': 'Se perdió la conexión. Reconectando...',
+  'sftp.error.sessionLost': 'Se perdió la sesión SFTP. Vuelve a conectar.',
+
+  // Settings > SFTP Show Hidden Files
+  'settings.sftp.showHiddenFiles': 'Mostrar archivos ocultos',
+  'settings.sftp.showHiddenFiles.desc': 'Muestra los archivos ocultos (dotfiles en Unix/macOS y archivos con el atributo oculto en Windows) en el explorador de archivos SFTP.',
+  'settings.sftp.showHiddenFiles.enable': 'Mostrar archivos ocultos',
+  'settings.sftp.showHiddenFiles.enableDesc': 'Muestra los archivos ocultos al explorar sistemas de archivos locales y remotos',
+
+  // Settings > SFTP Compressed Upload
+  'settings.sftp.compressedUpload': 'Transferencia de carpetas comprimidas',
+  'settings.sftp.compressedUpload.desc': 'Comprime las carpetas antes de subirlas para reducir significativamente el tiempo de transferencia.',
+  'settings.sftp.compressedUpload.enable': 'Habilitar la compresión de carpetas',
+  'settings.sftp.compressedUpload.enableDesc': 'Comprime automáticamente las carpetas con tar antes de la transferencia. Requiere soporte de tar en el servidor. Si no está disponible, se recurre a una transferencia normal.',
+
+  'settings.sftp.skipUnchanged.enable': 'Omitir archivos sin cambios',
+  'settings.sftp.skipUnchanged.enableDesc': 'Omite los archivos cuyo tamaño y hora de modificación ya coinciden con el destino (estilo rsync). Deshabilitado al reemplazar una carpeta en una ruta de staging.',
+
+  // Quick Switcher
+  'qs.search.placeholder': 'Buscar hosts o pestañas',
+  'qs.jumpTo': 'Ir a',
+  'qs.localTerminal': 'Terminal local',
+  'qs.localShells': 'Shells locales',
+  'qs.default': 'Predeterminado',
+
+  // Select Host panel
+  'selectHost.title': 'Seleccionar host',
+  'selectHost.noHostsFound': 'No se encontraron hosts',
+  'selectHost.newHost': 'Host nuevo',
+  'selectHost.continue': 'Continuar',
+  'selectHost.continueWithCount': 'Continuar ({count} seleccionados)',
+  'selectHost.toggleGroup': 'Alternar todos los hosts en {name}',
+  'selectHost.toggleHost': 'Alternar {name}',
+
+  // Quick Connect
+  'quickConnect.knownHost.title': '¿Estás seguro de que quieres conectarte?',
+  'quickConnect.knownHost.authenticity': 'No se puede establecer la autenticidad de {hostname}.',
+  'quickConnect.knownHost.fingerprintLabel': 'La huella digital de {keyType} es SHA256:',
+  'quickConnect.knownHost.addQuestion': '¿Quieres agregarlo a la lista de hosts conocidos?',
+  'quickConnect.knownHost.addAndContinue': 'Agregar y continuar',
+  'quickConnect.addKey': 'Agregar clave',
+  'quickConnect.warning.unparsedOptions': 'Se ignoraron algunos argumentos SSH: {options}',
+  'quickConnect.identity.label': 'Preajuste de credenciales',
+  'quickConnect.identity.placeholder': 'Elige una identidad guardada',
+  'quickConnect.identity.empty': 'No se encontraron identidades guardadas',
+  'quickConnect.identity.hint': 'Elige una identidad para completar automáticamente su nombre de usuario y autenticación.',
+  'quickConnect.identity.selectedHint': 'Listo para conectar como {username}.',
+  'quickConnect.identity.method.password': 'Contraseña',
+  'quickConnect.identity.method.key': 'Clave SSH',
+  'quickConnect.identity.method.certificate': 'Certificado',
+  'quickConnect.identity.unavailable': 'A esta identidad le faltan credenciales utilizables en este dispositivo.',
+  'quickConnect.identity.useCustom': 'Usar credenciales personalizadas',
+  'quickConnect.identity.connect': 'Conectar con preajuste',
+  'quickConnect.connectTitle': 'Conectar a {host}',
+
+  // Terminal
+  'terminal.connectionErrorTitle': 'Error de conexión',
+
+  // Protocol select dialog
+  'protocolSelect.chooseProtocol': 'Elegir protocolo',
+  'protocolSelect.port': 'puerto:',
+
+  // Host Details
+  'hostDetails.title.details': 'Detalles del host',
+  'hostDetails.title.new': 'Host nuevo',
+  'vault.panel.resizeWidth': 'Redimensionar el ancho del panel',
+  'hostDetails.saveAria': 'Guardar',
+  'hostDetails.section.address': 'Dirección',
+  'hostDetails.hostname.placeholder': 'IP o nombre de host',
+  'hostDetails.section.general': 'General',
+  'hostDetails.section.sftp': 'Configuración de SFTP',
+  'hostDetails.sftp.fileProtocol': 'Protocolo de archivos',
+  'hostDetails.sftp.fileProtocol.desc': 'Auto intenta SFTP y luego recurre al modo SCP cuando el subsistema SFTP no está disponible (p. ej., algunos NAS). Fuerza SCP para hosts que solo admiten SCP.',
+  'hostDetails.sftp.fileProtocol.auto': 'Auto',
+  'hostDetails.sftp.fileProtocol.sftp': 'Solo SFTP',
+  'hostDetails.sftp.fileProtocol.scp': 'Modo SCP',
+  'hostDetails.sftp.sudo': 'Modo Sudo',
+  'hostDetails.sftp.sudo.desc': 'Adquiere automáticamente privilegios de root usando la contraseña guardada',
+  'hostDetails.sftp.sudo.passwordWarning': 'El modo Sudo requiere una contraseña. Configura una arriba, o asegúrate de que el servidor permita sudo sin contraseña.',
+  'hostDetails.sftp.encoding': 'Codificación de nombres de archivo',
+  'hostDetails.sftp.encoding.desc': 'Selecciona la codificación utilizada para decodificar y enviar los nombres de archivo SFTP.',
+  'hostDetails.label.placeholder': 'Etiqueta (p. ej., servidor de producción)',
+  'hostDetails.notes.label': 'Notas',
+  'hostDetails.notes.placeholder': 'Hardware, proyecto, cliente, región, rol...',
+  'hostDetails.notes.help': 'Admite Markdown. No guardes contraseñas ni claves privadas aquí.',
+  'hostDetails.notes.tab.edit': 'Editar',
+  'hostDetails.notes.tab.preview': 'Vista previa',
+  'hostDetails.notes.preview.empty': 'Aún no hay nada para previsualizar.',
+  'hostDetails.notes.toggle.show': 'Mostrar el editor de notas',
+  'hostDetails.notes.toggle.hide': 'Ocultar el editor de notas',
+  'hostDetails.group.placeholder': 'Grupo padre',
+  'hostDetails.section.credentials': 'Credenciales',
+  'hostDetails.section.portCredentials': 'Puerto y credenciales',
+  'hostDetails.section.appearance': 'Apariencia',
+  'hostDetails.distro.title': 'Distribución de Linux',
+  'hostDetails.distro.desc': 'Detecta automáticamente al conectar, o anula el ícono de la distro manualmente.',
+  'hostDetails.icon.title': 'Ícono del host',
+  'hostDetails.icon.sectionTitle': 'Color e ícono',
+  'hostDetails.icon.desc': 'Elige la fuente y el color del ícono para este host.',
+  'hostDetails.icon.source': 'Fuente',
+  'hostDetails.icon.manualLabel': 'Ícono manual',
+  'hostDetails.icon.tab.brand': 'Marca',
+  'hostDetails.icon.tab.type': 'Tipo',
+  'hostDetails.icon.mode.auto': 'Automático',
+  'hostDetails.icon.mode.custom': 'Personalizado',
+  'hostDetails.icon.reset': 'Restablecer el ícono del host',
+  'hostDetails.icon.colorLabel': 'Color del ícono',
+  'hostDetails.icon.colorDefault': 'Predeterminado',
+  'hostDetails.icon.colorAuto': 'Automático',
+  'hostDetails.icon.colorManual': 'Manual',
+  'hostDetails.icon.colorChoice': 'Color',
+  'hostDetails.icon.autoColorLabel': 'Color actual',
+  'hostDetails.icon.preview': 'Vista previa del ícono',
+  'hostDetails.icon.showLibrary': 'Mostrar la biblioteca de íconos',
+  'hostDetails.icon.hideLibrary': 'Ocultar la biblioteca de íconos',
+  'hostDetails.icon.autoUsesDistro': 'Usa el ícono de la distribución de Linux y el color seleccionado para este host.',
+  'hostDetails.icon.customOverridesDistro': 'El ícono integrado reemplaza la distribución de Linux para este host.',
+  'hostDetails.icon.option.server': 'Servidor',
+  'hostDetails.icon.option.terminal': 'Terminal',
+  'hostDetails.icon.option.database': 'Base de datos',
+  'hostDetails.icon.option.cloud': 'Nube',
+  'hostDetails.icon.option.router': 'Router',
+  'hostDetails.icon.option.shield': 'Escudo',
+  'hostDetails.icon.option.code': 'Código',
+  'hostDetails.icon.option.box': 'Caja',
+  'hostDetails.icon.option.globe': 'Globo',
+  'hostDetails.icon.option.cpu': 'CPU',
+  'hostDetails.icon.option.hard-drive': 'Almacenamiento',
+  'hostDetails.icon.option.network': 'Red',
+  'hostDetails.icon.option.wifi': 'Inalámbrico',
+  'hostDetails.icon.option.lock': 'Bloqueo',
+  'hostDetails.icon.option.key': 'Clave',
+  'hostDetails.icon.option.monitor': 'Monitor',
+  'hostDetails.icon.option.container': 'Contenedor',
+  'hostDetails.icon.option.activity': 'Actividad',
+  'hostDetails.icon.option.zap': 'Rápido',
+  'hostDetails.icon.option.server-cog': 'Configuración del servidor',
+  'hostDetails.icon.color.blue': 'Azul',
+  'hostDetails.icon.color.green': 'Verde',
+  'hostDetails.icon.color.red': 'Rojo',
+  'hostDetails.icon.color.amber': 'Ámbar',
+  'hostDetails.icon.color.purple': 'Púrpura',
+  'hostDetails.icon.color.cyan': 'Cian',
+  'hostDetails.icon.color.orange': 'Naranja',
+  'hostDetails.icon.color.slate': 'Pizarra',
+  'hostDetails.icon.color.violet': 'Violeta',
+  'hostDetails.icon.color.pink': 'Rosa',
+  'hostDetails.icon.color.rose': 'Rosado',
+  'hostDetails.icon.color.lime': 'Lima',
+  'hostDetails.icon.color.teal': 'Verde azulado',
+  'hostDetails.icon.color.sky': 'Celeste',
+  'hostDetails.icon.color.indigo': 'Índigo',
+  'hostDetails.icon.color.zinc': 'Zinc',
+  'hostDetails.icon.color.custom': 'Color personalizado',
+  'hostDetails.distro.mode': 'Fuente',
+  'hostDetails.distro.mode.auto': 'Detección automática',
+  'hostDetails.distro.mode.manual': 'Anulación manual',
+  'hostDetails.distro.detectedLabel': 'Actual',
+  'hostDetails.distro.manualLabel': 'Anulación',
+  'hostDetails.distro.pending': 'Detectar después de la primera conexión',
+  'hostDetails.distro.unknown': 'Desconocido',
+  'hostDetails.distro.option.linux': 'Linux genérico',
+  'hostDetails.distro.option.ubuntu': 'Ubuntu',
+  'hostDetails.distro.option.debian': 'Debian',
+  'hostDetails.distro.option.centos': 'CentOS',
+  'hostDetails.distro.option.rocky': 'Rocky Linux',
+  'hostDetails.distro.option.fedora': 'Fedora',
+  'hostDetails.distro.option.arch': 'Arch Linux',
+  'hostDetails.distro.option.alpine': 'Alpine',
+  'hostDetails.distro.option.amazon': 'Amazon Linux',
+  'hostDetails.distro.option.opensuse': 'openSUSE / SLES',
+  'hostDetails.distro.option.redhat': 'Red Hat / RHEL',
+  'hostDetails.distro.option.almalinux': 'AlmaLinux',
+  'hostDetails.distro.option.alinux': 'Alibaba Cloud Linux',
+  'hostDetails.distro.option.openeuler': 'openEuler',
+  'hostDetails.distro.option.freebsd': 'FreeBSD',
+  'hostDetails.distro.option.oracle': 'Oracle Linux',
+  'hostDetails.distro.option.kali': 'Kali Linux',
+  'hostDetails.distro.option.cisco': 'Cisco',
+  'hostDetails.distro.option.juniper': 'Juniper Networks',
+  'hostDetails.distro.option.huawei': 'Huawei',
+  'hostDetails.distro.option.h3c': 'H3C',
+  'hostDetails.distro.option.hpe': 'HPE',
+  'hostDetails.distro.option.mikrotik': 'MikroTik',
+  'hostDetails.distro.option.fortinet': 'Fortinet',
+  'hostDetails.distro.option.paloalto': 'Palo Alto Networks',
+  'hostDetails.distro.option.zyxel': 'ZyXEL',
+  'hostDetails.distro.option.ruijie': 'Ruijie',
+  'hostDetails.section.mosh': 'Mosh',
+  'hostDetails.section.et': 'EternalTerminal',
+  'hostDetails.et.port': 'Puerto del servidor ET',
+  'hostDetails.et.port.desc': 'Puerto en el que escucha etserver (predeterminado 2022)',
+  'hostDetails.username.placeholder': 'Nombre de usuario',
+  'hostDetails.password.placeholder': 'Contraseña',
+  'hostDetails.password.show': 'Mostrar contraseña',
+  'hostDetails.password.hide': 'Ocultar contraseña',
+  'hostDetails.password.save': 'Guardar contraseña',
+  'hostDetails.auth.method': 'Método de inicio de sesión',
+  'hostDetails.auth.auto': 'Automático',
+  'hostDetails.auth.auto.desc': 'Intenta con el agente SSH y las claves locales, y luego usa la contraseña guardada.',
+  'hostDetails.auth.passwordOnly': 'Solo contraseña',
+  'hostDetails.auth.password.desc': 'Usa solo la contraseña guardada y las solicitudes interactivas de contraseña.',
+  'hostDetails.auth.key': 'Clave',
+  'hostDetails.auth.key.desc': 'Usa la clave seleccionada, con la contraseña guardada como respaldo cuando esté presente.',
+  'hostDetails.auth.certificate': 'Certificado',
+  'hostDetails.auth.certificate.desc': 'Usa el certificado SSH seleccionado, con la contraseña guardada como respaldo cuando esté presente.',
+  'hostDetails.auth.mfaFirst': 'Preferir autenticación interactiva',
+  'hostDetails.auth.mfaFirst.desc': 'Para servidores que requieren contraseña y MFA a través de keyboard-interactive.',
+  'hostDetails.auth.credentialRequired': 'Selecciona una clave o un certificado antes de guardar este método de inicio de sesión.',
+  'hostDetails.identity.suggestions': 'Identidades',
+  'hostDetails.identity.missing': 'Identidad no encontrada',
+  'hostDetails.credential.keyCertificate': 'Clave, certificado, archivo de clave local',
+  'hostDetails.credential.key': 'Clave',
+  'hostDetails.credential.certificate': 'Certificado',
+  'hostDetails.credential.localKeyFile': 'Archivo de clave local',
+  'hostDetails.credential.localKeyFilePlaceholder': '~/.ssh/id_ed25519',
+  'hostDetails.credential.browseKeyFile': 'Explorar...',
+  'hostDetails.credential.missing': 'Credencial no encontrada',
+  'hostDetails.section.systemSshAgent': 'Agente SSH del sistema',
+  'hostDetails.systemSshAgent': 'Usar el agente SSH del sistema para iniciar sesión',
+  'hostDetails.systemSshAgent.desc': 'Usa claves ya desbloqueadas por macOS, Linux, Windows, 1Password u otro agente SSH compatible',
+  'hostDetails.systemSshAgent.socket': 'Socket del agente',
+  'hostDetails.systemSshAgent.socket.desc': 'Déjalo vacío para usar SSH_AUTH_SOCK',
+  'hostDetails.systemSshAgent.identitiesOnly': 'Usar solo las claves configuradas',
+  'hostDetails.systemSshAgent.identitiesOnly.desc': 'No intentar con claves no relacionadas actualmente cargadas en el agente',
+  'hostDetails.systemSshAgent.notRunning': 'El agente SSH del sistema no está disponible',
+  'hostDetails.systemSshAgent.notRunningHint': 'Inicia o desbloquea tu agente SSH, o proporciona la ruta de su socket arriba.',
+  'hostDetails.keys.search': 'Buscar claves...',
+  'hostDetails.keys.empty': 'No hay claves disponibles',
+  'hostDetails.certs.search': 'Buscar certificados...',
+  'hostDetails.certs.empty': 'No hay certificados disponibles',
+  'hostDetails.agentForwarding': 'Reenviar el agente SSH',
+  'hostDetails.agentForwarding.desc': 'Permite que el servidor remoto use tus claves SSH locales (p. ej., para operaciones de git)',
+  'hostDetails.agentForwarding.agentNotRunning': 'El agente SSH no está disponible',
+  'hostDetails.agentForwarding.agentNotRunningHint': 'No se detectó ningún agente SSH. Habilita el agente de autenticación de OpenSSH en los servicios de Windows, o usa un agente compatible como Bitwarden, 1Password o gpg-agent.',
+  'hostDetails.section.agentForwarding': 'Agente SSH',
+  'hostDetails.x11Forwarding': 'Reenviar aplicaciones X11',
+  'hostDetails.x11Forwarding.desc': 'Muestra las aplicaciones gráficas remotas en tu escritorio local cuando se ejecuta un servidor X local.',
+  'hostDetails.section.x11Forwarding': 'Reenvío X11',
+  'hostDetails.section.deviceType': 'Tipo de dispositivo',
+  'hostDetails.deviceType': 'Modo de dispositivo de red',
+  'hostDetails.deviceType.desc': 'Habilítalo para equipos de red (switches, routers, firewalls) conectados mediante SSH. Los comandos se envían tal cual, sin envoltura de shell, compatible con las CLI de proveedores como Huawei VRP y Cisco IOS.',
+  'hostDetails.deviceType.warning': 'Los comandos del agente de IA se enviarán directamente sin seguimiento del código de salida. Habilítalo solo para dispositivos que no ejecutan un shell estándar.',
+  'hostDetails.section.sshAlgorithms': 'Algoritmos SSH',
+  'hostDetails.section.terminalBehavior': 'Comportamiento de la terminal',
+  'hostDetails.lineTimestamps': 'Mostrar marcas de tiempo de salida',
+  'hostDetails.lineTimestamps.desc': 'Muestra la hora local junto a las líneas de salida visibles de este host sin cambiar el texto de la terminal.',
+  'hostDetails.legacyAlgorithms': 'Permitir algoritmos heredados',
+  'hostDetails.legacyAlgorithms.desc': 'Habilita algoritmos SSH obsoletos (diffie-hellman-group1, ssh-dss, 3des-cbc, etc.) para conectar con equipos de red más antiguos.',
+  'hostDetails.legacyAlgorithms.warning': 'Estos algoritmos tienen debilidades de seguridad conocidas. Habilítalos solo para dispositivos heredados que no admiten criptografía moderna.',
+  'hostDetails.skipEcdsaHostKey': 'Omitir la clave de host ECDSA',
+  'hostDetails.skipEcdsaHostKey.desc': 'Algunos switches antiguos de Huawei / Cisco generan firmas de clave de host ECDSA no estándar que provocan "signature verification failed". Al activar esto, se eliminan todos los ecdsa-sha2-* de la oferta del cliente para que la negociación recurra a RSA / Ed25519.',
+  'hostDetails.algorithms.advanced': 'Anulaciones avanzadas de algoritmos',
+  'hostDetails.algorithms.advanced.desc': 'Reemplaza la lista de algoritmos ofrecidos para cualquier categoría por cada host. Dejar una categoría sin cambios usa la predeterminada; seleccionar un subconjunto reemplaza por completo la lista predeterminada. Los valores incorrectos pueden hacer que el host sea inalcanzable.',
+  'hostDetails.algorithms.inheritedNotice': 'El grupo actual tiene anulaciones de algoritmos configuradas para: {categories}. El botón "Restablecer" aquí recurre a las listas del grupo, no a las predeterminadas de Netcatty. Para ignorar la restricción del grupo, borra la anulación en la configuración de algoritmos del grupo.',
+  'hostDetails.algorithms.customized': 'personalizado',
+  'hostDetails.algorithms.reset': 'Restablecer',
+  'hostDetails.algorithms.category.kex': 'Intercambio de claves (KEX)',
+  'hostDetails.algorithms.category.cipher': 'Cifrado',
+  'hostDetails.algorithms.category.hmac': 'MAC (HMAC)',
+  'hostDetails.algorithms.category.serverHostKey': 'Clave de host',
+  'hostDetails.algorithms.category.compress': 'Compresión',
+  'hostDetails.section.keepalive': 'Keepalive',
+  'hostDetails.keepalive.override': 'Anular el keepalive global',
+  'hostDetails.keepalive.desc': 'Usa una política de keepalive personalizada para este host en lugar de la configuración global. Útil para routers o switches antiguos cuyo servidor SSH no responde a las solicitudes keepalive@openssh.com: establece el intervalo en 0 para deshabilitar el keepalive por completo en este host.',
+  'hostDetails.keepalive.interval': 'Intervalo (segundos)',
+  'hostDetails.keepalive.countMax': 'Máximo de keepalives sin respuesta',
+  'hostDetails.keepalive.disabledHint': 'Intervalo = 0 deshabilita el keepalive para este host. La sesión dependerá de los tiempos de espera a nivel de TCP para detectar una conexión caída.',
+  'hostDetails.section.sshTimeouts': 'Tiempos de espera de conexión SSH',
+  'hostDetails.sshTimeouts.tcpConnect': 'Tiempo de espera de TCP',
+  'hostDetails.sshTimeouts.tcpConnect.desc': 'Segundos de espera para la conexión de red a este host.',
+  'hostDetails.sshTimeouts.authReady': 'Tiempo de espera de autenticación SSH',
+  'hostDetails.sshTimeouts.authReady.desc': 'Segundos de espera después de conectar para que terminen la negociación y la autenticación SSH.',
+  'hostDetails.backspaceBehavior': 'Comportamiento de la tecla Retroceso',
+  'hostDetails.backspaceBehavior.default': 'Predeterminado',
+  'hostDetails.jumpHosts': 'Proxy mediante hosts',
+  'hostDetails.jumpHosts.hops': '{count} salto(s)',
+  'hostDetails.jumpHosts.direct': 'Directo',
+  'hostDetails.jumpHosts.configure': 'Configurar hosts proxy',
+  'hostDetails.proxy': 'Proxy mediante HTTP/SOCKS5/Comando',
+  'hostDetails.proxy.none': 'Ninguno',
+  'hostDetails.proxy.edit': 'Editar proxy',
+  'hostDetails.proxy.configure': 'Configurar proxy',
+  'hostDetails.proxyPanel.title': 'Proxy mediante HTTP/SOCKS5/Comando',
+  'hostDetails.proxyPanel.hostPlaceholder': 'Host del proxy',
+  'hostDetails.proxyPanel.command': 'ProxyCommand',
+  'hostDetails.proxyPanel.commandPlaceholder': 'cloudflared access ssh --hostname %h',
+  'hostDetails.proxyPanel.commandHelp': 'Usa %h para el host de destino, %p para el puerto de destino y %% para un porcentaje literal.',
+  'hostDetails.proxyPanel.credentials': 'Credenciales',
+  'hostDetails.proxyPanel.usernamePlaceholder': 'Nombre de usuario',
+  'hostDetails.proxyPanel.passwordPlaceholder': 'Contraseña',
+  'hostDetails.proxyPanel.identities': 'Identidades',
+  'hostDetails.proxyPanel.keychainIdentity': 'Identidad del llavero',
+  'hostDetails.proxyPanel.manualCredentials': 'Credenciales manuales',
+  'hostDetails.proxyPanel.remove': 'Quitar proxy',
+  'hostDetails.proxyPanel.savedProxy': 'Proxy guardado',
+  'hostDetails.proxyPanel.selectSaved': 'Seleccionar proxy guardado',
+  'hostDetails.proxyPanel.customProxy': 'Proxy personalizado',
+  'hostDetails.proxyPanel.missing': 'Faltante',
+  'hostDetails.proxyPanel.missingSaved': 'Falta el proxy guardado',
+  'hostDetails.proxyPanel.missingIdentity': 'Falta la identidad del llavero',
+  'hostDetails.proxyPanel.incompleteIdentity': 'La identidad del proxy necesita un nombre de usuario y una contraseña',
+  'hostDetails.proxyPanel.unreadableIdentity': 'No se puede leer la contraseña de la identidad del proxy en este dispositivo',
+  'hostDetails.proxyPanel.error.required': 'Se requieren el host y el puerto del proxy, o un ProxyCommand.',
+  'hostDetails.envVars': 'Variables de entorno',
+  'hostDetails.envVars.add': 'Agregar variable de entorno',
+  'hostDetails.envVars.title': 'Variables de entorno',
+  'hostDetails.envVars.desc': 'Establece una variable de entorno para {host}.',
+  'hostDetails.envVars.note':
+    'Algunos servidores SSH por defecto solo permiten variables con el prefijo LC_ y LANG_.',
+  'hostDetails.envVars.variable': 'Variable',
+  'hostDetails.envVars.value': 'Valor',
+  'hostDetails.envVars.newVariable': 'Variable nueva',
+  'hostDetails.envVars.variableName': 'Nombre de la variable',
+  'hostDetails.chain.title': 'Editar cadena',
+  'hostDetails.chain.desc': 'Agregar otro host creará una conexión a {host}.',
+  'hostDetails.chain.addHost': 'Agregar un host',
+  'hostDetails.chain.target': 'Destino',
+  'hostDetails.chain.availableHosts': 'Hosts disponibles',
+  'hostDetails.chain.clear': 'Limpiar',
+  'hostDetails.group.title': 'Grupo nuevo',
+  'hostDetails.group.general': 'General',
+  'hostDetails.group.namePlaceholder': 'Nombre del grupo',
+  'hostDetails.group.parentPlaceholder': 'Grupo padre',
+  'hostDetails.group.cloudSync': 'Sincronización en la nube',
+  'hostDetails.group.addProtocol': 'Agregar protocolo',
+  'hostDetails.startupCommand': 'Comando de inicio',
+  'hostDetails.startupCommand.placeholder': 'Comando para ejecutar al conectar (p. ej., cd /app && ls)',
+  'hostDetails.startupCommand.help':
+    'Este comando se ejecutará automáticamente después de que se establezca la conexión SSH.',
+  'hostDetails.startupCommand.runMode': 'Ejecución multilínea',
+  'hostDetails.startupCommand.runMode.help': 'Elige cómo se envían los comandos de inicio multilínea después de la conexión.',
+  'hostDetails.startupCommand.runMode.lineDelay': 'Enviar línea por línea',
+  'hostDetails.startupCommand.runMode.paste': 'Enviar todo de una vez',
+  'hostDetails.otherProtocols': 'Otros protocolos',
+  'hostDetails.telnetOn': 'Telnet activado',
+  'hostDetails.port': 'puerto',
+  'hostDetails.telnet.credentials': 'Credenciales',
+  'hostDetails.telnet.identity.placeholder': 'Identidad manual',
+  'hostDetails.telnet.username': 'Nombre de usuario de Telnet',
+  'hostDetails.telnet.password': 'Contraseña de Telnet',
+  'hostDetails.charset.placeholder': 'Codificación (p. ej., UTF-8)',
+  'hostDetails.telnet.add': 'Agregar protocolo Telnet',
+  'hostDetails.telnet.setDefault': 'Conectar con Telnet por defecto',
+  'hostDetails.tags': 'Etiquetas',
+  'hostDetails.group': 'Grupo',
+  'hostDetails.selectGroup': 'Seleccionar grupo',
+  'hostDetails.addTag': 'Agregar una etiqueta...',
+  'hostDetails.createTag': 'Crear etiqueta',
+  'hostDetails.createGroup': 'Crear grupo',
+  'hostDetails.plugin.title': 'Conexión de plugin',
+  'hostDetails.plugin.provider.placeholder': 'Selecciona un proveedor de conexión',
+  'hostDetails.plugin.provider.empty': 'No hay proveedores de conexión instalados',
+  'hostDetails.plugin.authentication.placeholder': 'Selecciona un proveedor de autenticación',
+  'hostDetails.plugin.authentication.none': 'Administrada por el proveedor o sin autenticación',
+  'hostDetails.plugin.credential.placeholder': 'Selecciona una credencial del host',
+  'hostDetails.plugin.credential.none': 'No hay credencial guardada',
+  'hostDetails.plugin.credential.password': 'Identidad de contraseña',
+  'hostDetails.plugin.credential.privateKey': 'Clave privada',
+  'hostDetails.plugin.credential.unavailable': 'Credencial guardada no disponible',
+  'hostDetails.plugin.configuration.label': 'Configuración del proveedor (JSON)',
+  'hostDetails.plugin.configuration.invalid': 'La configuración debe ser un JSON válido.',
+  'hostDetails.plugin.configuration.schemaInvalid': 'La configuración no coincide con el esquema del proveedor.',
+  'hostDetails.plugin.unavailable': 'El proveedor configurado no está disponible. La configuración se conserva hasta que se restaure el plugin.',
+  'hostDetails.plugin.useSsh': 'Usar SSH en su lugar',
+
+  // Host form (legacy modal)
+  'hostForm.title.edit': 'Editar host',
+  'hostForm.title.new': 'Host nuevo',
+  'hostForm.desc.edit': 'Actualiza los detalles de conexión de este host',
+  'hostForm.desc.new': 'Crea una nueva entrada de host SSH',
+  'hostForm.field.label': 'Etiqueta',
+  'hostForm.placeholder.label': 'Mi servidor de producción',
+  'hostForm.field.hostname': 'Nombre de host / IP',
+  'hostForm.placeholder.hostname': '192.168.1.1',
+  'hostForm.field.port': 'Puerto',
+  'hostForm.field.username': 'Nombre de usuario',
+  'hostForm.field.osType': 'Tipo de SO',
+  'hostForm.placeholder.selectOs': 'Seleccionar SO',
+  'hostForm.field.group': 'Grupo',
+  'hostForm.placeholder.group': 'p. ej., AWS, DigitalOcean',
+  'hostForm.field.tags': 'Etiquetas',
+  'hostForm.placeholder.addTag': 'Agregar una etiqueta...',
+  'hostForm.auth.method': 'Método de autenticación',
+  'hostForm.auth.password': 'Contraseña',
+  'hostForm.auth.sshKey': 'Clave SSH',
+  'hostForm.auth.selectKey': 'Seleccionar una clave SSH',
+  'hostForm.auth.noKeys': 'No hay claves disponibles',
+  'hostForm.auth.noKeysHint': 'No se encontraron claves SSH en el llavero. Crea una primero.',
+  'hostForm.saveHost': 'Guardar host',
+
+  // Connection logs
+  'logs.table.date': 'Fecha',
+  'logs.table.user': 'Usuario',
+  'logs.table.host': 'Host',
+  'logs.table.saved': 'Guardado',
+  'logs.empty.title': 'No hay registros de conexión',
+  'logs.empty.desc':
+    'Tu historial de conexiones aparecerá aquí cuando te conectes a hosts o abras terminales locales.',
+  'logs.loadMore': 'Cargar {count} registros más',
+  'logs.ongoing': 'en curso',
+  'logs.localTerminal': 'Terminal local',
+  'logs.action.save': 'Guardar',
+  'logs.action.unsave': 'Quitar de guardados',
+  'logs.action.delete': 'Eliminar',
+
+  // Log view
+  'logView.customizeAppearance': 'Personalizar la apariencia',
+  'logView.appearance': 'Apariencia',
+  'logView.readOnly': 'Solo lectura',
+  'logView.export': 'Exportar',
+  'vault.import.plugins.title': 'Importadores de plugins',
+  'vault.import.plugins.loading': 'Generando una vista previa de importación segura…',
+  'vault.import.plugins.progress': '{completed} de {total} procesados {message}',
+  'vault.import.plugins.preview': 'Vista previa de importación',
+  'vault.import.plugins.empty': 'No se devolvieron borradores importables.',
+  'vault.import.plugins.summary': '{parsed} borradores · {warnings} advertencias · {errors} errores',
+  'vault.import.plugins.commit': 'Vista previa de importación',
+  'vault.import.plugins.fileUnavailable': 'El archivo seleccionado no está disponible para el bridge del importador de escritorio.',
+  'vault.import.plugins.notRecognized': 'Este importador no reconoció el archivo seleccionado.',
+  'vault.import.plugins.containsErrors': 'La vista previa de importación contiene errores y no se puede confirmar.',
+  'vault.import.plugins.committed': 'Se importaron {count} elementos validados.',
+  'vault.import.plugins.duplicates': '{count} elementos duplicados se omitirán.',
+  'vault.import.plugins.validationErrors': '{count} borradores fallaron la validación de host y deben corregirse mediante el importador.',
+  'vault.import.plugins.kind.host': 'Host',
+  'vault.import.plugins.kind.identity': 'Identidad',
+  'vault.import.plugins.kind.key': 'Clave',
+  'vault.import.plugins.kind.snippet': 'Fragmento',
+  'vault.import.plugins.kind.group': 'Grupo',
+  'vault.import.plugins.moreItems': '{count} elementos más están incluidos en esta importación.',
+  'vault.import.plugins.moreDiagnostics': '{count} diagnósticos más se omitieron de esta vista previa.',
+
+};

application/i18n/locales/ru/terminal.ts

@@ -765,7 +765,7 @@ export const ruTerminalMessages: Messages = {
   'snippets.shortkey.recording': 'Нажмите сочетание клавиш...',
   'snippets.shortkey.hint': 'Нажмите это сочетание в терминале, чтобы быстро отправить команду.',
   'snippets.shortkey.clear': 'Очистить сочетание',
-  'snippets.shortkey.error.systemConflict': 'Это сочетание конфликтует с системным сочетанием',
+  'snippets.shortkey.error.systemConflict': 'Это сочетание конфликтует с «{name}»',
   'snippets.shortkey.error.snippetConflict': 'Это сочетание уже используется сниппетом: {name}',
 
   // Serial Port

application/i18n/locales/serverStatsLatency.test.ts

@@ -5,6 +5,8 @@ import { enSystemManagerMessages } from "./en/systemManager";
 import { enTerminalMessages } from "./en/terminal";
 import { ruSystemManagerMessages } from "./ru/systemManager";
 import { ruTerminalMessages } from "./ru/terminal";
+import { esSystemManagerMessages } from "./es/systemManager";
+import { esTerminalMessages } from "./es/terminal";
 import { zhCnSystemManagerMessages } from "./zh-CN/systemManager";
 import { zhCNVaultMessages } from "./zh-CN/vault";
 import { zhTwSystemManagerMessages } from "./zh-TW/systemManager";
@@ -14,6 +16,7 @@ test("SSH network latency is explicit in every locale and UI surface", () => {
   const labels = [
     [enTerminalMessages, enSystemManagerMessages, "SSH network latency"],
     [ruTerminalMessages, ruSystemManagerMessages, "Сетевая задержка SSH"],
+    [esTerminalMessages, esSystemManagerMessages, "Latencia de red SSH"],
     [zhCNVaultMessages, zhCnSystemManagerMessages, "SSH 网络延迟"],
     [zhTWVaultMessages, zhTwSystemManagerMessages, "SSH 網路延遲"],
   ] as const;

application/i18n/locales/settingsLocales.test.ts

@@ -5,10 +5,12 @@ import { DEFAULT_KEY_BINDINGS } from "../../../domain/models/keyBindings.ts";
 import { HOST_ICON_COLORS, HOST_ICON_IDS } from "../../../domain/hostIcon.ts";
 import zhCN from "./zh-CN.ts";
 import ru from "./ru.ts";
+import es from "./es.ts";
 
 const LOCALIZED_SETTINGS_LOCALES = [
   { name: "zh-CN", messages: zhCN },
   { name: "ru", messages: ru },
+  { name: "es", messages: es },
 ];
 
 test("localized settings include names for every default shortcut", () => {

application/i18n/locales/snippetBulkDeleteLocales.test.ts

@@ -3,6 +3,7 @@ import test from 'node:test';
 
 import en from './en.ts';
 import ru from './ru.ts';
+import es from './es.ts';
 import zhCN from './zh-CN.ts';
 import zhTW from './zh-TW.ts';
 
@@ -14,12 +15,23 @@ const KEYS = [
 ] as const;
 
 test('snippet bulk-delete copy exists in every locale', () => {
-  for (const [locale, messages] of Object.entries({ en, ru, zhCN, zhTW })) {
+  for (const [locale, messages] of Object.entries({ en, ru, es, zhCN, zhTW })) {
     const missing = KEYS.filter((key) => !messages[key]);
     assert.deepEqual(missing, [], `${locale} is missing snippet bulk-delete copy`);
   }
 });
 
+test('snippet shortkey system-conflict copy names the conflicting action', () => {
+  for (const [locale, messages] of Object.entries({ en, ru, es, zhCN, zhTW })) {
+    const text = messages['snippets.shortkey.error.systemConflict'];
+    assert.match(
+      text ?? '',
+      /\{name\}/,
+      `${locale} system-conflict copy should include {name}`,
+    );
+  }
+});
+
 test('English bulk-delete copy is entity-neutral and grammatical for one item', () => {
   assert.equal(
     en['snippets.selection.deleteConfirmTitle'].replace('{count}', '1'),

application/i18n/locales/terminalHostManagementLocales.test.ts

@@ -3,6 +3,7 @@ import test from 'node:test';
 
 import en from './en';
 import ru from './ru';
+import es from './es';
 import zhCN from './zh-CN';
 import zhTW from './zh-TW';
 
@@ -14,7 +15,7 @@ const keys = [
 ] as const;
 
 test('terminal host management strings exist in every shipped locale', () => {
-  for (const [locale, messages] of Object.entries({ en, 'zh-CN': zhCN, 'zh-TW': zhTW, ru })) {
+  for (const [locale, messages] of Object.entries({ en, es, 'zh-CN': zhCN, 'zh-TW': zhTW, ru })) {
     for (const key of keys) {
       assert.equal(typeof messages[key], 'string', `${locale} is missing ${key}`);
       assert.notEqual(messages[key], '', `${locale} has an empty ${key}`);

application/i18n/locales/terminalInlineImageLocales.test.ts

@@ -3,6 +3,7 @@ import test from "node:test";
 
 import en from "./en.ts";
 import ru from "./ru.ts";
+import es from "./es.ts";
 import zhCN from "./zh-CN.ts";
 import zhTW from "./zh-TW.ts";
 
@@ -29,6 +30,7 @@ const INLINE_IMAGE_KEYS = [
 
 const LOCALES = [
   { name: "en", messages: en },
+  { name: "es", messages: es },
   { name: "zh-CN", messages: zhCN },
   { name: "zh-TW", messages: zhTW },
   { name: "ru", messages: ru },

application/i18n/locales/terminalOsc7Locales.test.ts

@@ -3,6 +3,7 @@ import assert from "node:assert/strict";
 
 import en from "./en.ts";
 import ru from "./ru.ts";
+import es from "./es.ts";
 import zhCN from "./zh-CN.ts";
 
 const osc7Keys = [
@@ -19,7 +20,7 @@ const osc7Keys = [
 ] as const;
 
 test("OSC 7 setup copy exists in every bundled locale", () => {
-  for (const [locale, messages] of Object.entries({ en, ru, zhCN })) {
+  for (const [locale, messages] of Object.entries({ en, ru, es, zhCN })) {
     for (const key of osc7Keys) {
       assert.equal(typeof messages[key], "string", `${locale} is missing ${key}`);
       assert.notEqual(messages[key], "", `${locale} has empty ${key}`);

application/i18n/locales/vaultBulkImportLocales.test.ts

@@ -3,6 +3,7 @@ import test from "node:test";
 
 import en from "./en.ts";
 import ru from "./ru.ts";
+import es from "./es.ts";
 import zhCN from "./zh-CN.ts";
 import zhTW from "./zh-TW.ts";
 
@@ -26,7 +27,7 @@ const KEYS = [
 ] as const;
 
 test("bulk vault import and group-selection copy exists in every locale", () => {
-  for (const [locale, messages] of Object.entries({ en, ru, zhCN, zhTW })) {
+  for (const [locale, messages] of Object.entries({ en, ru, es, zhCN, zhTW })) {
     const missing = KEYS.filter((key) => !messages[key]);
     assert.deepEqual(missing, [], `${locale} is missing bulk vault labels`);
   }

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

@@ -170,6 +170,10 @@ export const zhCNCoreMessages: Messages = {
 
   // Settings > Session Restore
   'settings.sessionRestore.title': '会话恢复',
+  'settings.sessionRestore.startupLanding': '启动时打开',
+  'settings.sessionRestore.startupLandingDesc': '当没有可恢复的会话时，选择启动后进入主机主页还是直接打开本地终端。',
+  'settings.sessionRestore.startupLanding.vault': '主页（主机）',
+  'settings.sessionRestore.startupLanding.localTerminal': '本地终端',
   'settings.sessionRestore.restorePreviousSession': '恢复上次的标签页和工作区',
   'settings.sessionRestore.restorePreviousSessionDesc': '启动时重新打开上次的终端标签页和工作区布局。',
   'settings.sessionRestore.restoreTerminalCwd': '恢复终端工作目录',

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

@@ -833,7 +833,7 @@ export const zhCNTerminalMessages: Messages = {
   'snippets.shortkey.recording': '请按下快捷键组合...',
   'snippets.shortkey.hint': '在终端中按下此快捷键可快速发送命令。',
   'snippets.shortkey.clear': '清除快捷键',
-  'snippets.shortkey.error.systemConflict': '此快捷键与系统快捷键冲突',
+  'snippets.shortkey.error.systemConflict': '此快捷键与「{name}」冲突',
   'snippets.shortkey.error.snippetConflict': '此快捷键已被代码片段使用：{name}',
 
   'snippets.variables.dialogTitle': '填写变量',

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

@@ -170,6 +170,10 @@ export const zhTWCoreMessages: Messages = {
 
   // Settings > Session Restore
   'settings.sessionRestore.title': '工作階段恢復',
+  'settings.sessionRestore.startupLanding': '啟動時開啟',
+  'settings.sessionRestore.startupLandingDesc': '當沒有可恢復的工作階段時，選擇啟動後進入主機主頁還是直接開啟本機終端。',
+  'settings.sessionRestore.startupLanding.vault': '主頁（主機）',
+  'settings.sessionRestore.startupLanding.localTerminal': '本機終端',
   'settings.sessionRestore.restorePreviousSession': '恢復上次的標籤頁和工作區',
   'settings.sessionRestore.restorePreviousSessionDesc': '啟動時重新開啟上次的終端標籤頁和工作區佈局。',
   'settings.sessionRestore.restoreTerminalCwd': '恢復終端工作目錄',

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

@@ -833,7 +833,7 @@ export const zhTWTerminalMessages: Messages = {
   'snippets.shortkey.recording': '請按下快捷鍵組合...',
   'snippets.shortkey.hint': '在終端中按下此快捷鍵可快速傳送指令。',
   'snippets.shortkey.clear': '清除快捷鍵',
-  'snippets.shortkey.error.systemConflict': '此快捷鍵與系統快捷鍵衝突',
+  'snippets.shortkey.error.systemConflict': '此快捷鍵與「{name}」衝突',
   'snippets.shortkey.error.snippetConflict': '此快捷鍵已被程式碼片段使用：{name}',
 
   'snippets.variables.dialogTitle': '填寫變數',

application/i18n/messages.ts

@@ -2,6 +2,7 @@ import en, { type Messages } from './locales/en';
 import zhCN from './locales/zh-CN';
 import zhTW from './locales/zh-TW';
 import ru from './locales/ru';
+import es from './locales/es';
 
 // Keep keys stable; add new locales by adding another import and map entry.
 export { type Messages };
@@ -9,6 +10,7 @@ export { type Messages };
 export const MESSAGES_BY_LOCALE: Record<string, Messages> = {
   en,
   ru,
+  es,
   'zh-CN': zhCN,
   'zh-TW': zhTW,
 };

application/state/aiDraftState.test.ts

@@ -18,8 +18,103 @@ import {
   setDraftView,
   setSessionView,
   updateDraftForScope,
+  draftsByScopeEqualIgnoringComposerText,
+  draftsByScopeEqualIgnoringAllComposerText,
 } from "./aiDraftState.ts";
 
+test("draftsByScopeEqualIgnoringComposerText ignores typing in the active scope", () => {
+  const base = createEmptyDraft("catty");
+  const prev = { "terminal:1": { ...base, text: "" } };
+  const next = { "terminal:1": { ...base, text: "你好", updatedAt: base.updatedAt + 1 } };
+  assert.equal(draftsByScopeEqualIgnoringComposerText(prev, next, "terminal:1"), true);
+  assert.equal(
+    draftsByScopeEqualIgnoringComposerText(
+      prev,
+      { "terminal:1": { ...base, text: "你好", attachments: [{ id: "a" } as never] } },
+      "terminal:1",
+    ),
+    false,
+  );
+  assert.equal(
+    draftsByScopeEqualIgnoringComposerText(
+      prev,
+      { "terminal:1": prev["terminal:1"], "workspace:2": base },
+      "terminal:1",
+    ),
+    true,
+  );
+  assert.equal(
+    draftsByScopeEqualIgnoringComposerText(
+      prev,
+      {
+        "terminal:1": prev["terminal:1"],
+        "workspace:2": { ...base, attachments: [{ id: "a" } as never] },
+      },
+      "terminal:1",
+    ),
+    false,
+  );
+});
+
+test("first composer draft is treated as text-only identity churn", () => {
+  const empty = createEmptyDraft("catty");
+  const created = { ...empty, text: "你" };
+  assert.equal(draftsByScopeEqualIgnoringAllComposerText({}, { "terminal:1": empty }), false);
+  assert.equal(draftsByScopeEqualIgnoringAllComposerText({}, { "terminal:1": created }), true);
+  assert.equal(
+    draftsByScopeEqualIgnoringComposerText({}, { "terminal:1": created }, "terminal:1"),
+    true,
+  );
+  assert.equal(
+    draftsByScopeEqualIgnoringAllComposerText(
+      { "terminal:1": empty },
+      { "terminal:1": created },
+    ),
+    true,
+  );
+  assert.equal(
+    draftsByScopeEqualIgnoringAllComposerText(
+      { "terminal:1": created },
+      { "terminal:1": empty },
+    ),
+    false,
+  );
+  assert.equal(
+    draftsByScopeEqualIgnoringAllComposerText(
+      {},
+      { "terminal:1": { ...created, attachments: [{ id: "a" } as never] } },
+    ),
+    false,
+  );
+});
+
+test("draftsByScopeEqualIgnoringAllComposerText ignores typing in every scope", () => {
+  const base = createEmptyDraft("catty");
+  const prev = {
+    "terminal:1": { ...base, text: "a" },
+    "terminal:2": { ...base, text: "b", attachments: [] },
+  };
+  const next = {
+    "terminal:1": { ...prev["terminal:1"], text: "aa", updatedAt: base.updatedAt + 1 },
+    "terminal:2": { ...prev["terminal:2"], text: "bb", updatedAt: base.updatedAt + 2 },
+  };
+  assert.equal(draftsByScopeEqualIgnoringAllComposerText(prev, next), true);
+  assert.equal(
+    draftsByScopeEqualIgnoringAllComposerText(prev, {
+      ...next,
+      "terminal:2": { ...next["terminal:2"], attachments: [{ id: "a" } as never] },
+    }),
+    false,
+  );
+});
+
+test("updateDraftForScope keeps the original map when the updater is a no-op", () => {
+  const draft = createEmptyDraft("catty");
+  const prev = { "terminal:1": draft };
+  const next = updateDraftForScope(prev, "terminal:1", "catty", (current) => current);
+  assert.equal(next, prev);
+});
+
 test("createEmptyDraft seeds selected agent and empty inputs", () => {
   const draft = createEmptyDraft("agent-alpha");
 

application/state/aiDraftState.ts

@@ -11,6 +11,65 @@ type DraftUploadGenerationByScope = Record<string, number>;
 
 const DEFAULT_PANEL_VIEW: AIPanelView = { mode: 'draft' };
 
+function isComposerOnlyDraft(draft: AIDraft | undefined): boolean {
+  return Boolean(
+    draft
+    && draft.attachments.length === 0
+    && draft.selectedUserSkillSlugs.length === 0,
+  );
+}
+
+/**
+ * First keystroke creates a missing → composer-only draft. That is still just
+ * typing. Clearing a draft (`right` missing or emptied) is a real lifecycle
+ * change so New Chat / send can reset the uncontrolled composer.
+ */
+function draftsEquivalentIgnoringComposerText(
+  left: AIDraft | undefined,
+  right: AIDraft | undefined,
+): boolean {
+  if (left === right) return true;
+  if (!left) return Boolean(isComposerOnlyDraft(right) && right.text.trim().length > 0);
+  if (!right) return false;
+  if (left.agentId !== right.agentId) return false;
+  if (left.attachments !== right.attachments) return false;
+  if (left.selectedUserSkillSlugs !== right.selectedUserSkillSlugs) return false;
+  const leftEmpty = left.text.trim().length === 0;
+  const rightEmpty = right.text.trim().length === 0;
+  if (leftEmpty !== rightEmpty) return leftEmpty;
+  return true;
+}
+
+/** True when every scope is unchanged except composer text/updatedAt. */
+export function draftsByScopeEqualIgnoringAllComposerText(
+  prev: DraftsByScope,
+  next: DraftsByScope,
+): boolean {
+  if (prev === next) return true;
+  const keys = new Set([...Object.keys(prev), ...Object.keys(next)]);
+  for (const key of keys) {
+    if (!draftsEquivalentIgnoringComposerText(prev[key], next[key])) return false;
+  }
+  return true;
+}
+
+/** Typing only changes text/updatedAt. Sibling empty-draft creates stay ignored. */
+export function draftsByScopeEqualIgnoringComposerText(
+  prev: DraftsByScope,
+  next: DraftsByScope,
+  scopeKey: string,
+): boolean {
+  if (prev === next) return true;
+  const keys = new Set([...Object.keys(prev), ...Object.keys(next)]);
+  for (const key of keys) {
+    const left = prev[key];
+    const right = next[key];
+    if (key !== scopeKey && !left && isComposerOnlyDraft(right)) continue;
+    if (!draftsEquivalentIgnoringComposerText(left, right)) return false;
+  }
+  return true;
+}
+
 export function createEmptyDraft(agentId: string): AIDraft {
   return {
     text: '',
@@ -142,6 +201,9 @@ export function updateDraftForScope(
 ): DraftsByScope {
   const currentDraft = draftsByScope[scopeKey] ?? createEmptyDraft(fallbackAgentId);
   const nextDraft = updater(currentDraft);
+  if (nextDraft === currentDraft && draftsByScope[scopeKey] === currentDraft) {
+    return draftsByScope;
+  }
 
   return {
     ...draftsByScope,

application/state/aiSessionsStore.test.ts

@@ -0,0 +1,68 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { createEmptyDraft } from './aiDraftState.ts';
+import { aiSessionsStore } from './aiSessionsStore.ts';
+
+test('AI sessions store does not notify listeners when only composer text changes', () => {
+  const previous = aiSessionsStore.getSnapshot();
+  const draft = createEmptyDraft('catty');
+  const base = {
+    sessions: Object.freeze([]),
+    activeSessionIdMap: Object.freeze({}),
+    draftsByScope: { 'terminal:1': draft },
+    panelViewByScope: {},
+  };
+
+  try {
+    aiSessionsStore.setSnapshot(base);
+
+    let notified = 0;
+    const unsubscribe = aiSessionsStore.subscribe(() => {
+      notified += 1;
+    });
+
+    aiSessionsStore.setSnapshot({
+      ...base,
+      draftsByScope: {
+        'terminal:1': { ...draft, text: 'hello', updatedAt: draft.updatedAt + 1 },
+      },
+    });
+    assert.equal(notified, 0);
+    assert.equal(aiSessionsStore.getSnapshot().draftsByScope['terminal:1']?.text, 'hello');
+
+    aiSessionsStore.setSnapshot({
+      ...base,
+      draftsByScope: {},
+    });
+    notified = 0;
+    aiSessionsStore.setSnapshot({
+      ...base,
+      draftsByScope: {
+        'terminal:1': { ...draft, text: '你好' },
+      },
+    });
+    assert.equal(notified, 0);
+
+    notified = 0;
+    aiSessionsStore.setSnapshot({
+      ...base,
+      draftsByScope: {
+        'terminal:1': { ...draft, text: '' },
+      },
+    });
+    assert.equal(notified, 1);
+
+    notified = 0;
+    aiSessionsStore.setSnapshot({
+      ...base,
+      draftsByScope: {
+        'terminal:1': { ...draft, text: 'hello', attachments: [{ id: 'a' } as never] },
+      },
+    });
+    assert.equal(notified, 1);
+    unsubscribe();
+  } finally {
+    aiSessionsStore.setSnapshot(previous);
+  }
+});

application/state/aiSessionsStore.ts

@@ -1,6 +1,7 @@
 import { useSyncExternalStore } from 'react';
 
 import type { AISession } from '../../infrastructure/ai/types';
+import { draftsByScopeEqualIgnoringAllComposerText } from './aiDraftState';
 import type { DraftsByScope, PanelViewByScope } from './aiStateSnapshots';
 
 type Listener = () => void;
@@ -50,7 +51,16 @@ class AISessionsStore {
     ) {
       return;
     }
+    const textOnlyDraftChange =
+      this.snapshot.sessions === next.sessions
+      && this.snapshot.activeSessionIdMap === next.activeSessionIdMap
+      && this.snapshot.panelViewByScope === next.panelViewByScope
+      && draftsByScopeEqualIgnoringAllComposerText(
+        this.snapshot.draftsByScope,
+        next.draftsByScope,
+      );
     this.snapshot = next;
+    if (textOnlyDraftChange) return;
     for (const listener of this.listeners) {
       listener();
     }

application/state/sessionRestoreSettings.test.ts

@@ -175,7 +175,7 @@ test("restore-only settings do not bump the cloud sync settings version", () =>
   const settingsVersionSource = settingsSource.slice(settingsVersionIndex);
 
   assert.notEqual(settingsVersionIndex, -1);
-  assert.doesNotMatch(settingsVersionSource, /restorePreviousSession|restoreTerminalCwd/);
+  assert.doesNotMatch(settingsVersionSource, /restorePreviousSession|restoreTerminalCwd|startupLanding/);
 });
 
 test("restore previous session re-arms after cross-window settings ipc sync", () => {

application/state/settingsIpcSync.ts

@@ -15,6 +15,7 @@ import {
   STORAGE_KEY_DISABLE_TERMINAL_FONT_ZOOM,
   STORAGE_KEY_RESTORE_PREVIOUS_SESSION,
   STORAGE_KEY_RESTORE_TERMINAL_CWD,
+  STORAGE_KEY_STARTUP_LANDING,
   STORAGE_KEY_SESSION_LOGS_DIR,
   STORAGE_KEY_SESSION_LOGS_ENABLED,
   STORAGE_KEY_SESSION_LOGS_FORMAT,
@@ -60,6 +61,7 @@ import {
   migrateIncomingTerminalFontId,
 } from './settingsStateDefaults';
 import { isTerminalSidePanelAutoOpenTab, type TerminalSidePanelAutoOpenTab } from '../../domain/terminalSidePanelAutoOpen';
+import { isStartupLanding, type StartupLanding } from '../../domain/startupLanding';
 import type { AppearanceSyncEvent } from './appearanceSync';
 
 interface UseSettingsIpcSyncParams {
@@ -102,6 +104,7 @@ interface UseSettingsIpcSyncParams {
   setDisableTerminalFontZoomState: Dispatch<SetStateAction<boolean>>;
   setRestorePreviousSessionState: Dispatch<SetStateAction<boolean>>;
   setRestoreTerminalCwdState: Dispatch<SetStateAction<boolean>>;
+  setStartupLandingState: Dispatch<SetStateAction<StartupLanding>>;
   setSftpTransferConcurrencyState: Dispatch<SetStateAction<number>>;
   setSshTransportIdleTtlMsState: Dispatch<SetStateAction<number>>;
 }
@@ -146,6 +149,7 @@ export function useSettingsIpcSync({
   setDisableTerminalFontZoomState,
   setRestorePreviousSessionState,
   setRestoreTerminalCwdState,
+  setStartupLandingState,
   setSftpTransferConcurrencyState,
   setSshTransportIdleTtlMsState,
 }: UseSettingsIpcSyncParams) {
@@ -304,6 +308,9 @@ export function useSettingsIpcSync({
       if (key === STORAGE_KEY_RESTORE_TERMINAL_CWD && typeof value === 'boolean') {
         setRestoreTerminalCwdState((prev) => (prev === value ? prev : value));
       }
+      if (key === STORAGE_KEY_STARTUP_LANDING && isStartupLanding(value)) {
+        setStartupLandingState((prev) => (prev === value ? prev : value));
+      }
       if (key === STORAGE_KEY_SFTP_TRANSFER_CONCURRENCY && typeof value === 'number') {
         setSftpTransferConcurrencyState((prev) => (prev === value ? prev : value));
       }
@@ -348,6 +355,7 @@ export function useSettingsIpcSync({
     setDisableTerminalFontZoomState,
     setRestorePreviousSessionState,
     setRestoreTerminalCwdState,
+    setStartupLandingState,
     setSftpTransferConcurrencyState,
     setSshTransportIdleTtlMsState,
     setTerminalFontFamilyId,

application/state/settingsStateDefaults.ts

@@ -85,6 +85,8 @@ export const DEFAULT_SHELL_ONLY_TAB_NUMBER_SHORTCUTS = false;
 export const DEFAULT_SHOW_TAB_NUMBER_BADGES = true;
 export const DEFAULT_DISABLE_TERMINAL_FONT_ZOOM = false;
 export { DEFAULT_RESTORE_PREVIOUS_SESSION } from './sessionRestoreSettings';
+export { DEFAULT_STARTUP_LANDING } from '../../domain/startupLanding';
+export type { StartupLanding } from '../../domain/startupLanding';
 
 // Editor defaults
 export const DEFAULT_EDITOR_WORD_WRAP = false;

application/state/settingsStorageSync.ts

@@ -19,6 +19,7 @@ import {
   STORAGE_KEY_EXPLORER_CONTEXT_MENU_ENABLED,
   STORAGE_KEY_RESTORE_PREVIOUS_SESSION,
   STORAGE_KEY_RESTORE_TERMINAL_CWD,
+  STORAGE_KEY_STARTUP_LANDING,
   STORAGE_KEY_SFTP_AUTO_OPEN_SIDEBAR,
   STORAGE_KEY_SFTP_FOLLOW_TERMINAL_CWD,
   STORAGE_KEY_SFTP_AUTO_SYNC,
@@ -60,6 +61,7 @@ import {
 } from './settingsStateDefaults';
 import { isTerminalSidePanelAutoOpenTab, type TerminalSidePanelAutoOpenTab } from '../../domain/terminalSidePanelAutoOpen';
 import { isHostClickBehavior, type HostClickBehavior } from '../../domain/hostClickBehavior';
+import { isStartupLanding, type StartupLanding } from '../../domain/startupLanding';
 
 interface UseSettingsStorageSyncParams {
   enabled?: boolean;
@@ -97,6 +99,7 @@ interface UseSettingsStorageSyncParams {
   disableTerminalFontZoom: boolean;
   restorePreviousSession: boolean;
   restoreTerminalCwd: boolean;
+  startupLanding: StartupLanding;
   editorWordWrap: boolean;
   sessionLogsEnabled: boolean;
   sessionLogsDir: string;
@@ -145,6 +148,7 @@ interface UseSettingsStorageSyncParams {
   setDisableTerminalFontZoomState: Dispatch<SetStateAction<boolean>>;
   setRestorePreviousSessionState: Dispatch<SetStateAction<boolean>>;
   setRestoreTerminalCwdState: Dispatch<SetStateAction<boolean>>;
+  setStartupLandingState: Dispatch<SetStateAction<StartupLanding>>;
   setEditorWordWrapState: Dispatch<SetStateAction<boolean>>;
   setSessionLogsEnabled: Dispatch<SetStateAction<boolean>>;
   setSessionLogsDir: Dispatch<SetStateAction<string>>;
@@ -172,7 +176,7 @@ export function useSettingsStorageSync({
   terminalThemeId, followAppTerminalTheme, terminalFontFamilyId, terminalFontSize,
   sftpDoubleClickBehavior, sftpAutoSync, sftpShowHiddenFiles,
   sftpUseCompressedUpload, sftpSkipUnchanged, sftpAutoOpenSidebar, sftpFollowTerminalCwd, sftpDefaultViewMode,
-  showRecentHosts, hostClickBehavior, showOnlyUngroupedHostsInRoot, showSftpTab, showHostTreeSidebar, terminalSidePanelAutoOpen, terminalSidePanelAutoOpenTab, shellOnlyTabNumberShortcuts, showTabNumberBadges, disableTerminalFontZoom, restorePreviousSession, restoreTerminalCwd,
+  showRecentHosts, hostClickBehavior, showOnlyUngroupedHostsInRoot, showSftpTab, showHostTreeSidebar, terminalSidePanelAutoOpen, terminalSidePanelAutoOpenTab, shellOnlyTabNumberShortcuts, showTabNumberBadges, disableTerminalFontZoom, restorePreviousSession, restoreTerminalCwd, startupLanding,
   editorWordWrap, sessionLogsEnabled, sessionLogsDir, sessionLogsFormat, sessionLogsTimestampsEnabled, sshDebugLogsEnabled, sshDeepLinkEnabled, jmsDeepLinkEnabled, explorerContextMenuEnabled,
   globalHotkeyEnabled, autoUpdateEnabled, windowOpacity, appIconVariant,
   setTheme, setLightUiThemeId, setDarkUiThemeId, setAccentMode, applyIncomingCustomAccent,
@@ -181,7 +185,7 @@ export function useSettingsStorageSync({
   setFollowAppTerminalThemeState, setTerminalFontFamilyId, setTerminalFontSize,
   setSftpDoubleClickBehavior, setSftpAutoSync, setSftpShowHiddenFiles,
   setSftpUseCompressedUpload, setSftpSkipUnchanged, setSftpAutoOpenSidebar, setSftpFollowTerminalCwd, setSftpDefaultViewMode,
-  setShowRecentHostsState, setHostClickBehaviorState, setShowOnlyUngroupedHostsInRootState, setShowSftpTabState, setShowHostTreeSidebarState, setTerminalSidePanelAutoOpenState, setTerminalSidePanelAutoOpenTabState, setShellOnlyTabNumberShortcutsState, setShowTabNumberBadgesState, setDisableTerminalFontZoomState, setRestorePreviousSessionState, setRestoreTerminalCwdState,
+  setShowRecentHostsState, setHostClickBehaviorState, setShowOnlyUngroupedHostsInRootState, setShowSftpTabState, setShowHostTreeSidebarState, setTerminalSidePanelAutoOpenState, setTerminalSidePanelAutoOpenTabState, setShellOnlyTabNumberShortcutsState, setShowTabNumberBadgesState, setDisableTerminalFontZoomState, setRestorePreviousSessionState, setRestoreTerminalCwdState, setStartupLandingState,
   setEditorWordWrapState, setSessionLogsEnabled, setSessionLogsDir, setSessionLogsFormat, setSessionLogsTimestampsEnabled, setSshDebugLogsEnabled, setSshDeepLinkEnabledState, setJmsDeepLinkEnabledState, setExplorerContextMenuEnabledState,
   setGlobalHotkeyEnabled, setWindowOpacity, setAppIconVariant, setAutoUpdateEnabled, setWorkspaceFocusStyleState,
   setSftpTransferConcurrencyState, setSshTransportIdleTtlMsState,
@@ -196,7 +200,7 @@ export function useSettingsStorageSync({
     terminalThemeId, followAppTerminalTheme, terminalFontFamilyId, terminalFontSize,
     sftpDoubleClickBehavior, sftpAutoSync, sftpShowHiddenFiles,
     sftpUseCompressedUpload, sftpSkipUnchanged, sftpAutoOpenSidebar, sftpFollowTerminalCwd, sftpDefaultViewMode,
-    showRecentHosts, hostClickBehavior, showOnlyUngroupedHostsInRoot, showSftpTab, showHostTreeSidebar, terminalSidePanelAutoOpen, terminalSidePanelAutoOpenTab, shellOnlyTabNumberShortcuts, showTabNumberBadges, disableTerminalFontZoom, restorePreviousSession, restoreTerminalCwd,
+    showRecentHosts, hostClickBehavior, showOnlyUngroupedHostsInRoot, showSftpTab, showHostTreeSidebar, terminalSidePanelAutoOpen, terminalSidePanelAutoOpenTab, shellOnlyTabNumberShortcuts, showTabNumberBadges, disableTerminalFontZoom, restorePreviousSession, restoreTerminalCwd, startupLanding,
     editorWordWrap, sessionLogsEnabled, sessionLogsDir, sessionLogsFormat, sessionLogsTimestampsEnabled, sshDebugLogsEnabled, sshDeepLinkEnabled, jmsDeepLinkEnabled, explorerContextMenuEnabled,
     globalHotkeyEnabled, autoUpdateEnabled, windowOpacity, appIconVariant,
   });
@@ -206,7 +210,7 @@ export function useSettingsStorageSync({
     terminalThemeId, followAppTerminalTheme, terminalFontFamilyId, terminalFontSize,
     sftpDoubleClickBehavior, sftpAutoSync, sftpShowHiddenFiles,
     sftpUseCompressedUpload, sftpSkipUnchanged, sftpAutoOpenSidebar, sftpFollowTerminalCwd, sftpDefaultViewMode,
-    showRecentHosts, hostClickBehavior, showOnlyUngroupedHostsInRoot, showSftpTab, showHostTreeSidebar, terminalSidePanelAutoOpen, terminalSidePanelAutoOpenTab, shellOnlyTabNumberShortcuts, showTabNumberBadges, disableTerminalFontZoom, restorePreviousSession, restoreTerminalCwd,
+    showRecentHosts, hostClickBehavior, showOnlyUngroupedHostsInRoot, showSftpTab, showHostTreeSidebar, terminalSidePanelAutoOpen, terminalSidePanelAutoOpenTab, shellOnlyTabNumberShortcuts, showTabNumberBadges, disableTerminalFontZoom, restorePreviousSession, restoreTerminalCwd, startupLanding,
     editorWordWrap, sessionLogsEnabled, sessionLogsDir, sessionLogsFormat, sessionLogsTimestampsEnabled, sshDebugLogsEnabled, sshDeepLinkEnabled, jmsDeepLinkEnabled, explorerContextMenuEnabled,
     globalHotkeyEnabled, autoUpdateEnabled, windowOpacity, appIconVariant,
   };
@@ -480,6 +484,11 @@ export function useSettingsStorageSync({
           setRestoreTerminalCwdState(newValue);
         }
       }
+      if (e.key === STORAGE_KEY_STARTUP_LANDING && e.newValue !== null) {
+        if (isStartupLanding(e.newValue) && e.newValue !== s.startupLanding) {
+          setStartupLandingState(e.newValue);
+        }
+      }
       // Sync global hotkey enabled setting from other windows
       if (e.key === STORAGE_KEY_GLOBAL_HOTKEY_ENABLED && e.newValue !== null) {
         const newValue = e.newValue === 'true';
@@ -572,6 +581,7 @@ export function useSettingsStorageSync({
     setDisableTerminalFontZoomState,
     setRestorePreviousSessionState,
     setRestoreTerminalCwdState,
+    setStartupLandingState,
     setTerminalFontFamilyId,
     setTerminalFontSize,
     setTerminalThemeDarkId,

application/state/sftp/errors.test.ts

@@ -11,6 +11,24 @@ test("isMissingStatError accepts only true path absence codes", () => {
   assert.equal(isMissingStatError(new Error("ENOENT")), true);
 });
 
+test("isMissingStatError treats Electron-wrapped SFTP absence as missing", () => {
+  // ipcRenderer.invoke strips custom `code` and wraps the ssh2 message.
+  // New-file uploads lstat the destination first; this is the toast users see.
+  assert.equal(
+    isMissingStatError(
+      new Error("Error invoking remote method 'netcatty:sftp:lstat': Error: No such file"),
+    ),
+    true,
+  );
+  assert.equal(isMissingStatError(new Error("No such file")), true);
+  assert.equal(isMissingStatError(new Error("No such file or directory")), true);
+  assert.equal(isMissingStatError(new Error("No such file: /tmp/tool.sh")), true);
+  assert.equal(
+    isMissingStatError(new Error("ENOENT: no such file or directory, lstat '/tmp/tool.sh'")),
+    true,
+  );
+});
+
 test("isMissingStatError rejects unsupported LSTAT and other failures", () => {
   const enotsup = new Error("Remote server does not support LSTAT") as Error & {
     code: string;
@@ -24,4 +42,25 @@ test("isMissingStatError rejects unsupported LSTAT and other failures", () => {
   eperm.code = "EPERM";
   assert.equal(isMissingStatError(eperm), false);
   assert.equal(isMissingStatError(new Error("channel closed")), false);
+  assert.equal(
+    isMissingStatError(
+      new Error("Error invoking remote method 'netcatty:sftp:lstat': Error: Permission denied"),
+    ),
+    false,
+  );
+  // Path names are user-controlled; do not treat a substring hit as absence.
+  assert.equal(
+    isMissingStatError(
+      new Error("EACCES: permission denied, lstat '/private/enoent/report.txt'"),
+    ),
+    false,
+  );
+  assert.equal(
+    isMissingStatError(
+      new Error(
+        "Error invoking remote method 'netcatty:sftp:lstat': Error: EACCES: permission denied, lstat '/private/enoent/report.txt'",
+      ),
+    ),
+    false,
+  );
 });

application/state/sftp/errors.ts

@@ -18,12 +18,4 @@ export const isSessionError = (err: unknown): boolean => {
   );
 };
 
-/** True absence only — ENOTSUP / unknown inspection must not map to "no conflict". */
-export const isMissingStatError = (error: unknown): boolean => {
-  const code = (error as { code?: string | number } | null)?.code;
-  return code === 2
-    || code === "ENOENT"
-    || code === "NO_SUCH_FILE"
-    || code === "SSH_FX_NO_SUCH_FILE"
-    || String((error as { message?: string } | null)?.message || "").trim() === "ENOENT";
-};
+export { isMissingStatError } from "../../../domain/sftpStatError";

application/state/startupLandingSettings.test.ts

@@ -0,0 +1,58 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+
+test("startup landing setting participates in cross-window settings sync", () => {
+  const storageSyncSource = readFileSync(new URL("./settingsStorageSync.ts", import.meta.url), "utf8");
+  const ipcSyncSource = readFileSync(new URL("./settingsIpcSync.ts", import.meta.url), "utf8");
+
+  assert.match(storageSyncSource, /STORAGE_KEY_STARTUP_LANDING/);
+  assert.match(storageSyncSource, /setStartupLandingState/);
+  assert.match(storageSyncSource, /e\.key === STORAGE_KEY_STARTUP_LANDING/);
+
+  assert.match(ipcSyncSource, /STORAGE_KEY_STARTUP_LANDING/);
+  assert.match(ipcSyncSource, /setStartupLandingState/);
+  assert.match(ipcSyncSource, /key === STORAGE_KEY_STARTUP_LANDING/);
+});
+
+test("startup landing does not bump the cloud sync settings version", () => {
+  const settingsSource = readFileSync(new URL("./useSettingsState.ts", import.meta.url), "utf8");
+  const settingsVersionIndex = settingsSource.indexOf("settingsVersion: useMemo");
+  const settingsVersionSource = settingsSource.slice(settingsVersionIndex);
+
+  assert.notEqual(settingsVersionIndex, -1);
+  assert.doesNotMatch(settingsVersionSource, /startupLanding/);
+});
+
+test("main window opens local terminal on cold start when preferred", () => {
+  const sideEffectsSource = readFileSync(new URL("../app/AppSideEffects.tsx", import.meta.url), "utf8");
+
+  assert.match(sideEffectsSource, /startupLocalTerminalAttemptedRef/);
+  assert.match(sideEffectsSource, /shouldOpenLocalTerminalOnStartup/);
+  assert.match(sideEffectsSource, /STORAGE_KEY_STARTUP_LANDING/);
+  assert.match(sideEffectsSource, /handleCreateLocalTerminal\(/);
+  assert.match(sideEffectsSource, /onColdStartIntentsSettled/);
+  assert.match(sideEffectsSource, /ensureDiscoveredShells/);
+  assert.match(sideEffectsSource, /hasQueuedStartupIntent:\s*startupLaunchIntentReceivedRef\.current/);
+
+  const latchAt = sideEffectsSource.indexOf("if (startupLocalTerminalAttemptedRef.current) return;");
+  const setLatchAt = sideEffectsSource.indexOf(
+    "startupLocalTerminalAttemptedRef.current = true;",
+    latchAt,
+  );
+  const createAt = sideEffectsSource.indexOf("handleCreateLocalTerminal(", setLatchAt);
+  assert.notEqual(latchAt, -1);
+  assert.notEqual(setLatchAt, -1);
+  assert.notEqual(createAt, -1);
+  assert.ok(setLatchAt < createAt, "StrictMode latch must be set before creating the terminal");
+});
+
+test("settings system tab exposes startup landing control", () => {
+  const tabSource = readFileSync(
+    new URL("../../components/settings/tabs/SettingsSystemTab.tsx", import.meta.url),
+    "utf8",
+  );
+  assert.match(tabSource, /system-startup-landing/);
+  assert.match(tabSource, /settings\.sessionRestore\.startupLanding/);
+  assert.match(tabSource, /local-terminal/);
+});

application/state/uploadService.test.ts

@@ -659,6 +659,39 @@ test("ENOENT from lstat still means absent destination for conflict check", asyn
   assert.equal(results[0].success, true);
 });
 
+test("Electron-wrapped lstat absence still means absent destination", async () => {
+  const file = new File(["new-bytes"], "tool.sh", { lastModified: 1234 });
+  Object.defineProperty(file, "path", { value: "/local/tool.sh" });
+  const uploadedPaths: string[] = [];
+
+  const results = await uploadFromFileList(
+    [file],
+    {
+      targetPath: "/usr/local/bin",
+      sftpId: "sftp-1",
+      isLocal: false,
+      bridge: {
+        mkdirSftp: async () => {},
+        lstatSftp: async () => {
+          throw new Error("Error invoking remote method 'netcatty:sftp:lstat': Error: No such file");
+        },
+        startStreamTransfer: async ({ targetPath: path }) => {
+          uploadedPaths.push(path);
+          return { transferId: "upload-1" };
+        },
+      },
+      joinPath: (base, name) => `${base}/${name}`,
+      resolveConflict: async () => {
+        throw new Error("absent destination must not prompt for conflict");
+      },
+    },
+  );
+
+  assert.deepEqual(uploadedPaths, ["/usr/local/bin/tool.sh"]);
+  assert.equal(results.length, 1);
+  assert.equal(results[0].success, true);
+});
+
 test("compressed-upload LSTAT ENOTSUP is not treated as an absent destination", async (t) => {
   let compressedStarts = 0;
   installCompressedUploadBridge(t, {

application/state/useAIState.ts

@@ -42,6 +42,7 @@ import {
 import {
   activateDraftView,
   clearScopeDraftState,
+  draftsByScopeEqualIgnoringAllComposerText,
   ensureDraftForScopeState,
   pruneStaleSessionPanelViews,
   setDraftView,
@@ -786,18 +787,21 @@ export function useAIState() {
 
   const ensureDraftForScope = useCallback((scopeKey: string, agentId: string): void => {
     let nextDraftsByScope: DraftsByScope | null = null;
+    let textOnly = false;
 
     setDraftsByScopeRaw((prev) => {
       const next = ensureDraftForScopeState(prev, scopeKey, agentId);
       if (next === prev) return prev;
       nextDraftsByScope = next;
+      textOnly = draftsByScopeEqualIgnoringAllComposerText(prev, next);
       return next;
     });
 
     if (!nextDraftsByScope) return;
 
-    bumpDraftMutationVersion(scopeKey);
     setLatestAIDraftsByScopeSnapshot(nextDraftsByScope);
+    if (textOnly) return;
+    bumpDraftMutationVersion(scopeKey);
     emitAIStateChanged(AI_STATE_CHANGED_DRAFTS_BY_SCOPE);
   }, []);
 
@@ -806,52 +810,69 @@ export function useAIState() {
     fallbackAgentId: string,
     updater: (draft: AIDraft) => AIDraft,
   ): void => {
+    let nextDraftsByScope: DraftsByScope | null = null;
+    let textOnly = false;
+
     setDraftsByScopeRaw((prev) => {
       const next = updateDraftForScope(
         prev,
         scopeKey,
         fallbackAgentId,
         (draft) => {
+          const updated = updater(draft);
+          if (updated === draft) return draft;
           return {
-            ...updater(draft),
+            ...updated,
             updatedAt: Date.now(),
           };
         },
       );
-      setLatestAIDraftsByScopeSnapshot(next);
-      emitAIStateChanged(AI_STATE_CHANGED_DRAFTS_BY_SCOPE);
+      if (next === prev) return prev;
+      nextDraftsByScope = next;
+      textOnly = draftsByScopeEqualIgnoringAllComposerText(prev, next);
       return next;
     });
+
+    if (!nextDraftsByScope) return;
+    setLatestAIDraftsByScopeSnapshot(nextDraftsByScope);
+    if (textOnly) return;
     bumpDraftMutationVersion(scopeKey);
+    emitAIStateChanged(AI_STATE_CHANGED_DRAFTS_BY_SCOPE);
   }, []);
 
   const updateDraftIfPresent = useCallback((
     scopeKey: string,
     updater: (draft: AIDraft) => AIDraft,
   ): void => {
-    let updated = false;
+    let nextDraftsByScope: DraftsByScope | null = null;
+    let textOnly = false;
 
     setDraftsByScopeRaw((prev) => {
       const currentDraft = prev[scopeKey];
       if (!currentDraft) return prev;
 
-      const nextDraft = {
-        ...updater(currentDraft),
-        updatedAt: Date.now(),
-      };
+      const updated = updater(currentDraft);
+      const nextDraft = updated === currentDraft
+        ? currentDraft
+        : {
+          ...updated,
+          updatedAt: Date.now(),
+        };
+      if (nextDraft === currentDraft) return prev;
       const next = {
         ...prev,
         [scopeKey]: nextDraft,
       };
-      updated = true;
-      setLatestAIDraftsByScopeSnapshot(next);
-      emitAIStateChanged(AI_STATE_CHANGED_DRAFTS_BY_SCOPE);
+      nextDraftsByScope = next;
+      textOnly = draftsByScopeEqualIgnoringAllComposerText(prev, next);
       return next;
     });
 
-    if (updated) {
-      bumpDraftMutationVersion(scopeKey);
-    }
+    if (!nextDraftsByScope) return;
+    setLatestAIDraftsByScopeSnapshot(nextDraftsByScope);
+    if (textOnly) return;
+    bumpDraftMutationVersion(scopeKey);
+    emitAIStateChanged(AI_STATE_CHANGED_DRAFTS_BY_SCOPE);
   }, []);
 
   const showDraftView = useCallback((scopeKey: string) => {

application/state/useAgentDiscovery.ts

@@ -22,10 +22,16 @@ let agentDiscoveryWriteGeneration = 0;
 export function useAgentDiscovery(
   externalAgents: ExternalAgentConfig[],
   setExternalAgents?: (value: ExternalAgentConfig[] | ((prev: ExternalAgentConfig[]) => ExternalAgentConfig[])) => void,
-  options?: { enabled?: boolean },
+  options?: {
+    enabled?: boolean;
+    schedule?: (task: () => void) => () => void;
+  },
 ) {
   const enabled = options?.enabled ?? true;
-  const [discoveredAgents, setDiscoveredAgents] = useState<DiscoveredAgent[]>([]);
+  const schedule = options?.schedule;
+  const [discoveredAgents, setDiscoveredAgents] = useState<DiscoveredAgent[]>(
+    () => agentDiscoveryCache?.agents ?? [],
+  );
   const [isDiscovering, setIsDiscovering] = useState(false);
   const discoverSeqRef = useRef(0);
   const mountedRef = useRef(true);
@@ -116,8 +122,16 @@ export function useAgentDiscovery(
       if (!cancelled) void discover();
     };
 
+    if (schedule) {
+      const cancel = schedule(runDiscover);
+      return () => {
+        cancelled = true;
+        cancel();
+      };
+    }
+
     if (typeof requestIdleCallback === 'function') {
-      const idleId = requestIdleCallback(runDiscover, { timeout: 2000 });
+      const idleId = requestIdleCallback(runDiscover);
       return () => {
         cancelled = true;
         cancelIdleCallback(idleId);
@@ -129,7 +143,7 @@ export function useAgentDiscovery(
       cancelled = true;
       clearTimeout(timeoutId);
     };
-  }, [discover, enabled]);
+  }, [discover, enabled, schedule]);
 
   // Auto-update args for already-configured discovered agents when
   // the canonical args from discovery change (e.g. after an app update).

application/state/useSettingsState.ts

@@ -52,6 +52,7 @@ import {
   STORAGE_KEY_SESSION_LOGS_ENABLED,
   STORAGE_KEY_RESTORE_PREVIOUS_SESSION,
   STORAGE_KEY_RESTORE_TERMINAL_CWD,
+  STORAGE_KEY_STARTUP_LANDING,
   STORAGE_KEY_SESSION_LOGS_DIR,
   STORAGE_KEY_SESSION_LOGS_FORMAT,
   STORAGE_KEY_SESSION_LOGS_TIMESTAMPS_ENABLED,
@@ -146,6 +147,10 @@ import {
   type HostClickBehavior,
 } from './settingsStateDefaults';
 import { isHostClickBehavior } from '../../domain/hostClickBehavior';
+import {
+  resolveStartupLandingSetting,
+  type StartupLanding,
+} from '../../domain/startupLanding';
 import { resolveRestorePreviousSessionSetting, resolveRestoreTerminalCwdSetting } from './sessionRestoreSettings';
 import { sessionRestoreStorage } from './sessionRestoreStorage';
 import { useSettingsStorageSync } from './settingsStorageSync';
@@ -431,6 +436,9 @@ export const useSettingsState = (options: { enableSettingsSync?: boolean; enable
     const stored = localStorageAdapter.readBoolean(STORAGE_KEY_RESTORE_TERMINAL_CWD);
     return resolveRestoreTerminalCwdSetting(stored);
   });
+  const [startupLanding, setStartupLandingState] = useState<StartupLanding>(() => {
+    return resolveStartupLandingSetting(readStoredString(STORAGE_KEY_STARTUP_LANDING));
+  });
   const [sftpTransferConcurrency, setSftpTransferConcurrencyState] = useState<number>(() => {
     return resolveSftpTransferConcurrency(() =>
       localStorageAdapter.readNumber(STORAGE_KEY_SFTP_TRANSFER_CONCURRENCY),
@@ -955,6 +963,7 @@ export const useSettingsState = (options: { enableSettingsSync?: boolean; enable
     setRestorePreviousSessionState(resolveRestorePreviousSessionSetting(storedRestorePreviousSession));
     const storedRestoreTerminalCwd = localStorageAdapter.readBoolean(STORAGE_KEY_RESTORE_TERMINAL_CWD);
     setRestoreTerminalCwdState(resolveRestoreTerminalCwdSetting(storedRestoreTerminalCwd));
+    setStartupLandingState(resolveStartupLandingSetting(readStoredString(STORAGE_KEY_STARTUP_LANDING)));
 
     // Workspace focus style
     const storedFocusStyle = readStoredString(STORAGE_KEY_WORKSPACE_FOCUS_STYLE);
@@ -1123,6 +1132,7 @@ export const useSettingsState = (options: { enableSettingsSync?: boolean; enable
     setDisableTerminalFontZoomState,
     setRestorePreviousSessionState,
     setRestoreTerminalCwdState,
+    setStartupLandingState,
     setSftpTransferConcurrencyState,
     setSshTransportIdleTtlMsState,
   });
@@ -1153,7 +1163,7 @@ export const useSettingsState = (options: { enableSettingsSync?: boolean; enable
     terminalThemeId, followAppTerminalTheme, terminalFontFamilyId, terminalFontSize,
     sftpDoubleClickBehavior, sftpAutoSync, sftpShowHiddenFiles,
     sftpUseCompressedUpload, sftpSkipUnchanged, sftpAutoOpenSidebar, sftpFollowTerminalCwd, sftpDefaultViewMode,
-    showRecentHosts, hostClickBehavior, showOnlyUngroupedHostsInRoot, showSftpTab, showHostTreeSidebar, terminalSidePanelAutoOpen, terminalSidePanelAutoOpenTab, shellOnlyTabNumberShortcuts, showTabNumberBadges, disableTerminalFontZoom, restorePreviousSession, restoreTerminalCwd,
+    showRecentHosts, hostClickBehavior, showOnlyUngroupedHostsInRoot, showSftpTab, showHostTreeSidebar, terminalSidePanelAutoOpen, terminalSidePanelAutoOpenTab, shellOnlyTabNumberShortcuts, showTabNumberBadges, disableTerminalFontZoom, restorePreviousSession, restoreTerminalCwd, startupLanding,
     editorWordWrap, sessionLogsEnabled, sessionLogsDir, sessionLogsFormat, sessionLogsTimestampsEnabled, sshDebugLogsEnabled, sshDeepLinkEnabled, jmsDeepLinkEnabled, explorerContextMenuEnabled,
     globalHotkeyEnabled, autoUpdateEnabled, windowOpacity, appIconVariant,
     setTheme, setLightUiThemeId, setDarkUiThemeId, setAccentMode,
@@ -1163,7 +1173,7 @@ export const useSettingsState = (options: { enableSettingsSync?: boolean; enable
     setFollowAppTerminalThemeState, setTerminalFontFamilyId, setTerminalFontSize: applyIncomingTerminalFontSize,
     setSftpDoubleClickBehavior, setSftpAutoSync, setSftpShowHiddenFiles,
     setSftpUseCompressedUpload, setSftpSkipUnchanged, setSftpAutoOpenSidebar, setSftpFollowTerminalCwd, setSftpDefaultViewMode,
-    setShowRecentHostsState, setHostClickBehaviorState, setShowOnlyUngroupedHostsInRootState, setShowSftpTabState, setShowHostTreeSidebarState, setTerminalSidePanelAutoOpenState, setTerminalSidePanelAutoOpenTabState, setShellOnlyTabNumberShortcutsState, setShowTabNumberBadgesState, setDisableTerminalFontZoomState, setRestorePreviousSessionState, setRestoreTerminalCwdState,
+    setShowRecentHostsState, setHostClickBehaviorState, setShowOnlyUngroupedHostsInRootState, setShowSftpTabState, setShowHostTreeSidebarState, setTerminalSidePanelAutoOpenState, setTerminalSidePanelAutoOpenTabState, setShellOnlyTabNumberShortcutsState, setShowTabNumberBadgesState, setDisableTerminalFontZoomState, setRestorePreviousSessionState, setRestoreTerminalCwdState, setStartupLandingState,
     setEditorWordWrapState, setSessionLogsEnabled, setSessionLogsDir, setSessionLogsFormat, setSessionLogsTimestampsEnabled, setSshDebugLogsEnabled, setSshDeepLinkEnabledState: applyIncomingSshDeepLinkEnabled, setJmsDeepLinkEnabledState: applyIncomingJmsDeepLinkEnabled, setExplorerContextMenuEnabledState: applyIncomingExplorerContextMenuEnabled,
     setGlobalHotkeyEnabled, setWindowOpacity: applyIncomingWindowOpacity, setAppIconVariant, setAutoUpdateEnabled, setWorkspaceFocusStyleState,
     setSftpTransferConcurrencyState, setSshTransportIdleTtlMsState,
@@ -1360,6 +1370,13 @@ export const useSettingsState = (options: { enableSettingsSync?: boolean; enable
     notifySettingsChanged(STORAGE_KEY_RESTORE_TERMINAL_CWD, enabled);
   }, [notifySettingsChanged]);
 
+  const setStartupLanding = useCallback((landing: StartupLanding) => {
+    setStartupLandingState(landing);
+    localStorageAdapter.writeString(STORAGE_KEY_STARTUP_LANDING, landing);
+    if (!persistMountedRef.current) return;
+    notifySettingsChanged(STORAGE_KEY_STARTUP_LANDING, landing);
+  }, [notifySettingsChanged]);
+
   // Apply and persist custom CSS
   useEffect(() => {
     applyCustomCssToDocument(customCSS);
@@ -1964,6 +1981,8 @@ export const useSettingsState = (options: { enableSettingsSync?: boolean; enable
     setRestorePreviousSession,
     restoreTerminalCwd,
     setRestoreTerminalCwd,
+    startupLanding,
+    setStartupLanding,
     sftpTransferConcurrency,
     setSftpTransferConcurrency,
     sshTransportIdleTtlMs,

components/AIChatPanelContent.tsx

@@ -89,6 +89,10 @@ interface AIChatPanelContentProps {
   onOpenVaultNote?: (noteId: string) => void;
   onOpenVaultHost?: (hostId: string) => void;
   onOpenVaultSection?: (section: 'notes' | 'hosts') => void;
+  /** Hidden retained panels keep the composer warm without the message tree. */
+  parked?: boolean;
+  /** Disable header transitions while send preflight is in flight. */
+  sending?: boolean;
 }
 
 export const AIChatPanelContent: React.FC<AIChatPanelContentProps> = ({
@@ -152,7 +156,37 @@ export const AIChatPanelContent: React.FC<AIChatPanelContentProps> = ({
   onOpenVaultNote,
   onOpenVaultHost,
   onOpenVaultSection,
+  parked = false,
+  sending = false,
 }) => {
+  const mentionHosts = React.useMemo(
+    () => terminalSessions.map((session) => ({
+      sessionId: session.sessionId,
+      hostname: session.hostname,
+      label: session.label,
+      connected: session.connected,
+    })),
+    [terminalSessions],
+  );
+  const providerSwitcher = React.useMemo(
+    () => (
+      currentAgentId === 'catty' && cattyConfiguredProviders.length > 0
+        ? {
+            providers: cattyConfiguredProviders,
+            selectedProviderId: effectiveActiveProvider?.id,
+            selectedModelId: effectiveActiveModelId || undefined,
+            onSelect: handleAgentProviderModelSelect,
+          }
+        : undefined
+    ),
+    [
+      cattyConfiguredProviders,
+      currentAgentId,
+      effectiveActiveModelId,
+      effectiveActiveProvider?.id,
+      handleAgentProviderModelSelect,
+    ],
+  );
   const hiddenParts = getAIPanelDiagnosticHiddenParts();
   const hideHeader = isAIPanelDiagnosticPartHidden('header', hiddenParts);
   const hideHistory = isAIPanelDiagnosticPartHidden('history', hiddenParts);
@@ -174,6 +208,8 @@ export const AIChatPanelContent: React.FC<AIChatPanelContentProps> = ({
               externalAgents={externalAgents}
               discoveredAgents={discoveredAgents}
               isDiscovering={isDiscovering}
+              parked={parked}
+              disabled={sending}
               onSelectAgent={handleAgentChange}
               onEnableDiscoveredAgent={handleEnableDiscoveredAgent}
               onRediscover={rediscover}
@@ -191,6 +227,7 @@ export const AIChatPanelContent: React.FC<AIChatPanelContentProps> = ({
                     variant="ghost"
                     size="icon"
                     className="h-6 w-6 rounded-md text-muted-foreground/62 hover:bg-white/[0.05] hover:text-foreground"
+                    disabled={sending}
                     onClick={() => setShowHistory(!showHistory)}
                   >
                     <History size={12} />
@@ -204,6 +241,7 @@ export const AIChatPanelContent: React.FC<AIChatPanelContentProps> = ({
                     variant="ghost"
                     size="icon"
                     className="h-6 w-6 rounded-md text-primary/82 hover:bg-primary/[0.10] hover:text-primary"
+                    disabled={sending}
                     onClick={handleNewChat}
                   >
                     <Plus size={13} />
@@ -217,12 +255,12 @@ export const AIChatPanelContent: React.FC<AIChatPanelContentProps> = ({
       )}
 
       {/* ── Main content ── */}
-      {showHistory && !hideHistory ? (
+      {!parked && showHistory && !hideHistory ? (
         <React.Profiler {...getAIPanelProfilerProps('AIChatPanel.History')}>
           <SessionHistoryDrawer
             sessions={historySessions}
             activeSessionId={activeSessionId}
-            onSelect={handleSelectSession}
+            onSelect={sending ? () => undefined : handleSelectSession}
             onDelete={handleDeleteSession}
             onClose={() => setShowHistory(false)}
           />
@@ -230,7 +268,7 @@ export const AIChatPanelContent: React.FC<AIChatPanelContentProps> = ({
       ) : (
         <>
           {/* Chat messages */}
-          {!hideMessages && (
+          {!parked && !hideMessages && (
             <React.Profiler {...getAIPanelProfilerProps('AIChatPanel.Messages')}>
               <ChatMessageList
                 messages={messages}
@@ -247,7 +285,7 @@ export const AIChatPanelContent: React.FC<AIChatPanelContentProps> = ({
           )}
 
           {/* Recent sessions (Zed-style, shown when no messages) */}
-          {messages.length === 0 && historySessions.length > 0 && !hideRecent && (
+          {!parked && messages.length === 0 && historySessions.length > 0 && !hideRecent && (
             <React.Profiler {...getAIPanelProfilerProps('AIChatPanel.Recent')}>
               <div className="shrink-0 px-4 pb-1">
                 <div className="flex items-baseline justify-between mb-2">
@@ -262,8 +300,9 @@ export const AIChatPanelContent: React.FC<AIChatPanelContentProps> = ({
                 {historySessions.slice(0, 3).map((session) => (
                   <button
                     key={session.id}
+                    disabled={sending}
                     onClick={() => handleSelectSession(session.id)}
-                    className="w-full flex items-baseline justify-between py-1.5 text-left hover:text-foreground transition-colors cursor-pointer"
+                    className="w-full flex items-baseline justify-between py-1.5 text-left hover:text-foreground transition-colors cursor-pointer disabled:pointer-events-none disabled:opacity-50"
                   >
                     <span className="text-[13px] text-foreground/60 truncate pr-4">
                       {session.title || t('ai.chat.untitled')}
@@ -291,6 +330,7 @@ export const AIChatPanelContent: React.FC<AIChatPanelContentProps> = ({
                   </div>
                 ) : null}
                 <ChatInput
+                  parked={parked}
                   value={inputValue}
                   onChange={setInputValue}
                   onSend={handleSend}
@@ -309,20 +349,11 @@ export const AIChatPanelContent: React.FC<AIChatPanelContentProps> = ({
                   modelPresets={agentModelPresets}
                   selectedModelId={selectedAgentModel}
                   onModelSelect={handleAgentModelSelect}
-                  providerSwitcher={
-                    currentAgentId === 'catty' && cattyConfiguredProviders.length > 0
-                      ? {
-                          providers: cattyConfiguredProviders,
-                          selectedProviderId: effectiveActiveProvider?.id,
-                          selectedModelId: effectiveActiveModelId || undefined,
-                          onSelect: handleAgentProviderModelSelect,
-                        }
-                      : undefined
-                  }
+                  providerSwitcher={providerSwitcher}
                   files={files}
                   onAddFiles={addFiles}
                   onRemoveFile={removeFile}
-                  hosts={terminalSessions.map(s => ({ sessionId: s.sessionId, hostname: s.hostname, label: s.label, connected: s.connected }))}
+                  hosts={mentionHosts}
                   selectedUserSkills={selectedUserSkills}
                   userSkills={userSkillOptions}
                   quickMessages={quickMessages}

components/AIChatSidePanel.mountRetention.test.ts

@@ -1,5 +1,6 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
+import { readFileSync } from 'node:fs';
 import React from 'react';
 import { renderToStaticMarkup } from 'react-dom/server';
 
@@ -108,6 +109,51 @@ const baseProps = (overrides: Partial<AIChatSidePanelProps> = {}): AIChatSidePan
   ...overrides,
 });
 
+test('send preflight aborts after the panel unmounts or the scope changes', () => {
+  const source = readFileSync(new URL('./AIChatSidePanel.tsx', import.meta.url), 'utf8');
+  assert.match(source, /sendEpochRef/);
+  assert.match(source, /if \(isSendStale\(\)\) return;/);
+});
+
+test('send preflight locks header agent and new-chat controls', () => {
+  const panel = readFileSync(new URL('./AIChatSidePanel.tsx', import.meta.url), 'utf8');
+  const content = readFileSync(new URL('./AIChatPanelContent.tsx', import.meta.url), 'utf8');
+  assert.match(panel, /sending=\{isSending\}/);
+  assert.match(content, /disabled=\{sending\}/);
+  const selector = readFileSync(new URL('./ai/AgentSelector.tsx', import.meta.url), 'utf8');
+  assert.match(selector, /if \(parked \|\| disabled\) setOpen\(false\)/);
+});
+
+test('first send awaits provider sync instead of idle-deferring it', () => {
+  const source = readFileSync(new URL('./AIChatSidePanel.tsx', import.meta.url), 'utf8');
+  assert.match(source, /await sendBridge\.aiSyncProviders\(providers\)/);
+  assert.match(source, /await sendBridge\.aiSyncWebSearch\(/);
+  assert.doesNotMatch(source, /scheduleWhenAiComposerIdle\(\(\) => \{\s*void bridge\.aiSyncProviders/);
+});
+
+test('send and new chat discard pending composer text', () => {
+  const source = readFileSync(new URL('./AIChatSidePanel.tsx', import.meta.url), 'utf8');
+  assert.match(source, /discardPendingComposerText/);
+  assert.match(source, /if \(!options\?\.keepPendingText\) discardPendingComposerText\(\)/);
+});
+
+test('text-only draft writes do not emit AI state changes', () => {
+  const source = readFileSync(new URL('../application/state/useAIState.ts', import.meta.url), 'utf8');
+  assert.match(source, /draftsByScopeEqualIgnoringAllComposerText/);
+  assert.match(source, /if \(textOnly\) return;/);
+});
+
+test('first composer keystroke does not create a store draft synchronously', () => {
+  const source = readFileSync(new URL('./AIChatSidePanel.tsx', import.meta.url), 'utf8');
+  const setter = source.slice(
+    source.indexOf('const setInputValue = useCallback'),
+    source.indexOf('const addFiles = useCallback'),
+  );
+  assert.match(setter, /pendingComposerTextRef\.current = value/);
+  assert.doesNotMatch(setter, /enterScopeDraftMode/);
+  assert.doesNotMatch(setter, /setTimeout/);
+});
+
 test('hidden empty AI side panel can release its subtree', () => {
   const props = baseProps();
 
@@ -184,7 +230,7 @@ test('AI side panel re-renders when retained content becomes visible again', ()
   ), false);
 });
 
-test('hidden retained AI side panel skips chat input and message content', () => {
+test('hidden retained AI side panel keeps the composer and skips message content', () => {
   const markup = renderToStaticMarkup(
     React.createElement(
       I18nProvider,
@@ -212,10 +258,11 @@ test('hidden retained AI side panel skips chat input and message content', () =>
   );
 
   assert.match(markup, /data-section="ai-chat-panel-retained"/);
-  assert.doesNotMatch(markup, /textarea/);
+  assert.match(markup, /inert/);
+  assert.match(markup, /aria-hidden/);
+  assert.match(markup, /textarea/);
   assert.doesNotMatch(markup, /hidden-user-message/);
   assert.doesNotMatch(markup, /hidden-assistant-message/);
-  assert.doesNotMatch(markup, /draft still retained/);
 });
 
 test('AI side panel re-renders when command timeout changes', () => {
@@ -253,6 +300,25 @@ test('AI side panel skips re-render when only a sibling scope session object cha
   );
 });
 
+test('AI side panel skips re-render when only the composer draft text changes', () => {
+  const empty = draft({ text: '' });
+  const prev = baseProps({
+    isVisible: true,
+    scopeType: 'terminal',
+    scopeTargetId: 'terminal-1',
+    draftsByScope: {
+      'terminal:terminal-1': empty,
+    },
+  });
+  const next = {
+    ...prev,
+    draftsByScope: {
+      'terminal:terminal-1': { ...empty, text: '你好', updatedAt: 2 },
+    },
+  };
+  assert.equal(aiChatSidePanelPropsAreEqual(prev, next), true);
+});
+
 test('workspace AI panel memo follows visible inherited session, not hidden terminal maps', () => {
   const visibleMemberChat = session({
     id: 'chat-visible',

components/AIChatSidePanel.tsx

@@ -38,7 +38,7 @@ import {
   endSendForKey,
   tryBeginSendForKey,
 } from './ai/draftSendGate';
-import { selectDraftForAgentSwitch } from '../application/state/aiDraftState';
+import { draftsByScopeEqualIgnoringComposerText, selectDraftForAgentSwitch } from '../application/state/aiDraftState';
 import {
   buildPromptWithTerminalSelectionAttachments,
   isTerminalSelectionAttachment,
@@ -79,6 +79,7 @@ import {
   getAIPanelProfilerProps,
   profileAIPanelCalculation,
 } from './ai/aiPanelDiagnostics';
+import { scheduleWhenAiComposerIdle, warmAiMarkdownRenderer } from './ai/aiMarkdownWarmup';
 
 type UserSkillsStatusResult = { ok: boolean; skills?: Array<{
   id: string;
@@ -198,15 +199,9 @@ export function shouldKeepAIChatSidePanelMounted(props: AIChatSidePanelProps): b
   return isAIChatSessionStreaming(sessionId);
 }
 
-function shouldDelayAIChatSidePanelActivation(props: AIChatSidePanelProps): boolean {
-  if (!(props.isVisible ?? true)) return false;
-  const scopeKey = `${props.scopeType}:${props.scopeTargetId ?? ''}`;
-  if (props.draftsByScope[scopeKey] || props.panelViewByScope[scopeKey]?.mode === 'draft') {
-    return false;
-  }
-  const sessionId = props.activeSessionIdMap[scopeKey] ?? null;
-  if (isAIChatSessionStreaming(sessionId)) return false;
-  return !hasAIChatSidePanelRetainedContent(props);
+function shouldDelayAIChatSidePanelActivation(_props: AIChatSidePanelProps): boolean {
+  // Empty-panel activation delay used to land in the expand → first-type window.
+  return false;
 }
 
 function schedulePanelActivation(callback: () => void): () => void {
@@ -303,6 +298,7 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
   const scopeKey = `${scopeType}:${scopeTargetId ?? ''}`;
 
   const [showHistory, setShowHistory] = useState(false);
+  const [isSending, setIsSending] = useState(false);
   const [runtimeAgentModelPresets, setRuntimeAgentModelPresets] = useState<Record<string, AgentModelPreset[]>>({});
   const [runtimeModelWarnings, setRuntimeModelWarnings] = useState<Record<string, string>>({});
   const [steerWarnings, setSteerWarnings] = useState<Record<string, SteerWarning>>({});
@@ -377,6 +373,7 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
 
   const explicitPanelView = panelViewByScope[scopeKey];
   const currentDraft = draftsByScope[scopeKey] ?? null;
+  const pendingComposerTextRef = useRef<string | null>(null);
   const visibleHistorySessionIds = useMemo(
     () => new Set(historySessions.map((session) => session.id)),
     [historySessions],
@@ -402,12 +399,41 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
   const isSteering = activeSessionId != null && steeringSessionId === activeSessionId;
   const currentAgentId = activeSession?.agentId ?? currentDraft?.agentId ?? defaultAgentId;
   const observedContextUsage = useAgentContextUsage(activeSessionId);
-  const inputValue = currentDraft?.text ?? '';
+  const inputValue = pendingComposerTextRef.current ?? currentDraft?.text ?? '';
   const files = currentDraft?.attachments ?? [];
   const panelViewRef = useRef(normalizedPanelView);
   panelViewRef.current = normalizedPanelView;
+  const permissionModeRef = useRef(globalPermissionMode);
+  permissionModeRef.current = globalPermissionMode;
+  const sendEpochRef = useRef(0);
+  useEffect(() => () => {
+    sendEpochRef.current += 1;
+  }, [scopeKey]);
   const currentDraftRef = useRef(currentDraft);
-  currentDraftRef.current = currentDraft;
+  if (pendingComposerTextRef.current != null) {
+    const pending = pendingComposerTextRef.current;
+    if (currentDraft && currentDraft.text === pending) {
+      pendingComposerTextRef.current = null;
+      currentDraftRef.current = currentDraft;
+    } else if (currentDraftRef.current?.text === pending) {
+      if (currentDraft && currentDraftRef.current) {
+        currentDraftRef.current.attachments = currentDraft.attachments;
+        currentDraftRef.current.selectedUserSkillSlugs = currentDraft.selectedUserSkillSlugs;
+        currentDraftRef.current.agentId = currentDraft.agentId;
+      }
+    } else {
+      const base = currentDraft ?? currentDraftRef.current ?? {
+        text: '',
+        agentId: currentAgentId,
+        attachments: [],
+        selectedUserSkillSlugs: [],
+        updatedAt: Date.now(),
+      };
+      currentDraftRef.current = { ...base, text: pending };
+    }
+  } else {
+    currentDraftRef.current = currentDraft;
+  }
   const activeSessionRef = useRef(activeSession);
   activeSessionRef.current = activeSession;
 
@@ -439,13 +465,9 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
     const bridge = getNetcattyBridge();
     if (!bridge?.aiMcpUpdateSessions) return;
 
-    const timeoutId = window.setTimeout(() => {
+    return scheduleWhenAiComposerIdle(() => {
       void bridge.aiMcpUpdateSessions(terminalSessions, activeSessionId ?? undefined);
-    }, 250);
-
-    return () => {
-      window.clearTimeout(timeoutId);
-    };
+    }, { initialDelayMs: 250 });
   }, [isVisible, terminalSessions, activeSessionId]);
 
   useEffect(() => {
@@ -517,9 +539,14 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
     showSessionView(scopeKey, sessionId);
   }, [scopeKey, showSessionView]);
 
-  const clearScopeDraft = useCallback(() => {
+  const discardPendingComposerText = useCallback(() => {
+    pendingComposerTextRef.current = null;
+  }, []);
+
+  const clearScopeDraft = useCallback((options?: { keepPendingText?: boolean }) => {
+    if (!options?.keepPendingText) discardPendingComposerText();
     clearDraftForScope(scopeKey);
-  }, [clearDraftForScope, scopeKey]);
+  }, [clearDraftForScope, discardPendingComposerText, scopeKey]);
 
   const enterScopeDraftMode = useCallback((agentId: string, preserveSessionView = false) => {
     applyDraftEntrySelection({
@@ -529,14 +556,29 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
     });
   }, [ensureScopeDraft, showScopeDraftView]);
 
-  const setInputValue = useCallback((value: string) => {
-    enterScopeDraftMode(currentAgentId, panelViewRef.current.mode === 'session');
-    updateScopeDraft(currentAgentId, (draft) => ({
-      ...draft,
-      text: value,
-    }));
+  const flushDraftText = useCallback(() => {
+    const pending = pendingComposerTextRef.current;
+    if (pending == null) return;
+    if (panelViewRef.current.mode !== 'draft') {
+      enterScopeDraftMode(currentAgentId, panelViewRef.current.mode === 'session');
+    }
+    updateScopeDraft(currentAgentId, (current) => (
+      current.text === pending ? current : { ...current, text: pending }
+    ));
   }, [currentAgentId, enterScopeDraftMode, updateScopeDraft]);
 
+  const setInputValue = useCallback((value: string) => {
+    const base = currentDraftRef.current ?? {
+      text: '',
+      agentId: currentAgentId,
+      attachments: [],
+      selectedUserSkillSlugs: [],
+      updatedAt: Date.now(),
+    };
+    pendingComposerTextRef.current = value;
+    currentDraftRef.current = { ...base, text: value, updatedAt: Date.now() };
+  }, [currentAgentId]);
+
   const addFiles = useCallback(async (inputFiles: File[]) => {
     enterScopeDraftMode(currentAgentId, panelViewRef.current.mode === 'session');
     await addDraftFiles(scopeKey, currentAgentId, inputFiles);
@@ -546,6 +588,20 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
     removeDraftFile(scopeKey, currentAgentId, fileId);
   }, [removeDraftFile, scopeKey, currentAgentId]);
 
+  useEffect(() => {
+    if (isVisible) return undefined;
+    flushDraftText();
+    return undefined;
+  }, [flushDraftText, isVisible]);
+
+  useEffect(() => () => {
+    flushDraftText();
+  }, [flushDraftText, scopeKey]);
+
+  useEffect(() => {
+    flushDraftText();
+  }, [activeSessionId, flushDraftText]);
+
   useEffect(() => {
     if (!isVisible) return;
 
@@ -586,16 +642,19 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
     };
 
     const bridge = getNetcattyBridge();
-    void loadUserSkillsStatus(bridge)
-      .then((result) => {
-        if (cancelled) return;
-        if (result === undefined) return;
-        applyUserSkillsStatus(result);
-      })
-      .catch(() => {});
+    const cancelIdle = scheduleWhenAiComposerIdle(() => {
+      void loadUserSkillsStatus(bridge)
+        .then((result) => {
+          if (cancelled) return;
+          if (result === undefined) return;
+          applyUserSkillsStatus(result);
+        })
+        .catch(() => {});
+    });
 
     return () => {
       cancelled = true;
+      cancelIdle();
     };
   }, [isVisible, scopeKey, toolIntegrationMode, updateScopeDraft, userSkillsStatusVersion]);
 
@@ -609,17 +668,15 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
   useEffect(() => {
     if (!isVisible) return;
     const bridge = getNetcattyBridge();
-    if (bridge?.aiSyncProviders && providers.length > 0) {
-      void bridge.aiSyncProviders(providers);
-    }
+    if (!bridge?.aiSyncProviders || providers.length === 0) return;
+    void bridge.aiSyncProviders(providers);
   }, [isVisible, providers]);
 
   useEffect(() => {
     if (!isVisible) return;
     const bridge = getNetcattyBridge();
-    if (bridge?.aiSyncWebSearch) {
-      void bridge.aiSyncWebSearch(webSearchConfig?.apiHost || null, webSearchConfig?.apiKey || null);
-    }
+    if (!bridge?.aiSyncWebSearch) return;
+    void bridge.aiSyncWebSearch(webSearchConfig?.apiHost || null, webSearchConfig?.apiKey || null);
   }, [isVisible, webSearchConfig?.apiHost, webSearchConfig?.apiKey, webSearchConfig?.enabled]);
 
   const {
@@ -627,7 +684,10 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
     isDiscovering,
     rediscover,
     enableAgent,
-  } = useAgentDiscovery(externalAgents, setExternalAgents, { enabled: isVisible });
+  } = useAgentDiscovery(externalAgents, setExternalAgents, {
+    enabled: isVisible,
+    schedule: scheduleWhenAiComposerIdle,
+  });
 
   const handleEnableDiscoveredAgent = useCallback(
     (agent: DiscoveredAgent) => {
@@ -745,7 +805,9 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
         setCodexCustomConfigResolved(false);
       }
     });
-    return () => { cancelled = true; };
+    return () => {
+      cancelled = true;
+    };
   }, [isVisible, isCodexManagedAgent, currentAgentId, currentAgentConfig]);
 
   const agentModelMapRef = useRef(agentModelMap);
@@ -868,15 +930,19 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
     // Respect renderer TTL / in-flight coalescing for all SDK agents including
     // OpenCode. Forced refresh used to re-spawn opencode on every effect re-run
     // even when the user never selected OpenCode (#2184). Manual refresh still
-    // passes force via the model selector path.
+    // passes force via the model selector path. Defer the network refresh so
+    // expand → first type does not wait on CLI model listing.
     let cancelled = false;
-    void loadSdkRuntimeModelCatalog(target).then((catalog) => {
-      if (cancelled || !catalog) return;
-      applySdkRuntimeModelCatalog(target.agentId, catalog, { adoptCurrentModel: true });
+    const cancelIdle = scheduleWhenAiComposerIdle(() => {
+      void loadSdkRuntimeModelCatalog(target).then((catalog) => {
+        if (cancelled || !catalog) return;
+        applySdkRuntimeModelCatalog(target.agentId, catalog, { adoptCurrentModel: true });
+      });
     });
 
     return () => {
       cancelled = true;
+      cancelIdle();
     };
   }, [
     isVisible,
@@ -939,8 +1005,8 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
 
   const inputAgentId = activeSession?.agentId ?? currentDraft?.agentId ?? currentAgentId;
   const canSendCurrentAgent = useMemo(
-    () => canSendWithAgent(inputAgentId, externalAgents),
-    [inputAgentId, externalAgents],
+    () => !isSending && canSendWithAgent(inputAgentId, externalAgents),
+    [inputAgentId, externalAgents, isSending],
   );
 
   const handleAgentModelSelect = useCallback((modelId: string) => {
@@ -1052,13 +1118,65 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
     const modelAttachments = attachments.filter((attachment) => !isTerminalSelectionAttachment(attachment));
     const isDraftMode = currentPanelView.mode === 'draft';
 
+    flushDraftText();
+    const submittedText = draft?.text ?? '';
+    const keepPendingAfterSend = () => {
+      const pending = pendingComposerTextRef.current;
+      return pending != null && pending !== submittedText;
+    };
     const sendGateKey = currentSessionView?.id ?? `draft:${scopeKey}`;
     if (!tryBeginSendForKey(sendGateKey)) {
       return;
     }
     let sessionSendGateKey: string | null = null;
+    const sendEpoch = sendEpochRef.current;
+    const isSendStale = () => sendEpochRef.current !== sendEpoch;
+    setIsSending(true);
 
     try {
+      const sendBridge = getNetcattyBridge();
+      if (sendBridge?.aiSyncProviders && providers.length > 0) {
+        await sendBridge.aiSyncProviders(providers);
+      }
+      if (sendBridge?.aiSyncWebSearch) {
+        await sendBridge.aiSyncWebSearch(webSearchConfig?.apiHost || null, webSearchConfig?.apiKey || null);
+      }
+      let sendSelectedAgentModel = selectedAgentModel;
+      if (currentAgentConfig && shouldLoadSdkRuntimeModels(currentAgentConfig)) {
+        const runtimeTarget = buildExternalAgentRuntimeModelTarget(currentAgentConfig);
+        if (runtimeTarget) {
+          const catalog = await loadSdkRuntimeModelCatalog(runtimeTarget);
+          if (catalog) {
+            applySdkRuntimeModelCatalog(runtimeTarget.agentId, catalog, { adoptCurrentModel: true });
+            const runtimePresets = normalizeSdkRuntimeModelPresets(catalog.models, catalog.currentModelId);
+            const storedModelId = agentModelMapRef.current[sendAgentId];
+            if (
+              catalog.currentModelId
+              && shouldAdoptSdkCurrentModel(catalog.currentModelId, storedModelId, runtimePresets)
+            ) {
+              sendSelectedAgentModel = catalog.currentModelId;
+            } else if (shouldUseStoredAgentModel(storedModelId, runtimePresets)) {
+              sendSelectedAgentModel = storedModelId ?? sendSelectedAgentModel;
+            } else if (runtimePresets[0]) {
+              sendSelectedAgentModel = runtimePresets[0].id;
+            }
+          }
+        }
+      }
+      setIsSending(false);
+      const sendPermissionMode = permissionModeRef.current;
+      if (isSendStale()) return;
+      if (currentAgentId !== sendAgentId) return;
+      const liveView = panelViewRef.current;
+      if (liveView.mode !== currentPanelView.mode) return;
+      if (
+        currentPanelView.mode === 'session'
+        && liveView.mode === 'session'
+        && liveView.sessionId !== currentPanelView.sessionId
+      ) {
+        return;
+      }
+      void warmAiMarkdownRenderer();
       let sessionId = currentSessionView?.id ?? null;
       let currentSession = currentSessionView ?? null;
       if (isDraftMode) {
@@ -1066,7 +1184,7 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
         const createdSession = createSession(scope, sendAgentId);
         sessionId = createdSession.id;
         currentSession = createdSession;
-        clearScopeDraft();
+        clearScopeDraft({ keepPendingText: keepPendingAfterSend() });
         showScopeSessionView(createdSession.id);
         setActiveSessionId(createdSession.id);
         sessionSendGateKey = sessionId;
@@ -1096,7 +1214,7 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
         });
         addMessageToSession(sessionId, { id: generateId(), role: 'assistant', content: t('ai.chat.noProvider'), timestamp: Date.now() });
         if (currentPanelView.mode === 'session') {
-          clearScopeDraft();
+          clearScopeDraft({ keepPendingText: keepPendingAfterSend() });
           showScopeSessionView(sessionId);
         }
         return;
@@ -1110,7 +1228,7 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
         });
         addMessageToSession(sessionId, { id: generateId(), role: 'assistant', content: t('ai.chat.noProviderModel'), timestamp: Date.now() });
         if (currentPanelView.mode === 'session') {
-          clearScopeDraft();
+          clearScopeDraft({ keepPendingText: keepPendingAfterSend() });
           showScopeSessionView(sessionId);
         }
         return;
@@ -1121,7 +1239,7 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
         ...(attachments.length > 0 ? { attachments } : {}),
         timestamp: Date.now(),
       });
-      clearScopeDraft();
+      clearScopeDraft({ keepPendingText: keepPendingAfterSend() });
       showScopeSessionView(sessionId);
       setActiveSessionId(sessionId);
       setStreamingForScope(sessionId, true);
@@ -1130,7 +1248,7 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
       addMessageToSession(sessionId, {
         id: assistantMsgId, role: 'assistant', content: '', timestamp: Date.now(),
         model: isExternalAgent
-          ? (selectedAgentModel || agentConfig?.name || 'external')
+          ? (sendSelectedAgentModel || agentConfig?.name || 'external')
           : (sendActiveModelId || sendActiveProvider?.defaultModel || ''),
         providerId: isExternalAgent ? undefined : sendActiveProvider?.providerId,
       });
@@ -1154,10 +1272,10 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
             terminalSessions,
             defaultTargetSession,
             providers,
-            selectedAgentModel,
+            selectedAgentModel: sendSelectedAgentModel,
             toolIntegrationMode,
             selectedUserSkillSlugs: selectedSkillSlugs,
-            permissionMode: globalPermissionMode,
+            permissionMode: sendPermissionMode,
           });
         } catch (err) {
           reportStreamError(sessionId, abortController.signal, err);
@@ -1178,7 +1296,7 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
           scopeType,
           scopeTargetId,
           scopeLabel,
-          globalPermissionMode,
+          globalPermissionMode: sendPermissionMode,
           commandBlocklist,
           commandTimeout,
           terminalSessions,
@@ -1190,6 +1308,7 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
         }, modelAttachments.length > 0 ? modelAttachments : undefined);
       }
     } finally {
+      setIsSending(false);
       endSendForKey(sendGateKey);
       if (sessionSendGateKey && sessionSendGateKey !== sendGateKey) {
         endSendForKey(sessionSendGateKey);
@@ -1202,9 +1321,11 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
     setStreamingForScope,
     sendToExternalAgent, sendToCattyAgent, reportStreamError, autoTitleSession, t,
     abortControllersRef, terminalSessions, defaultTargetSession, providers, selectedAgentModel, updateSessionExternalSessionId,
-    scopeType, scopeTargetId, scopeHostIds, scopeLabel, globalPermissionMode, commandBlocklist, commandTimeout, webSearchConfig, buildExecutorContextForScope,
+    scopeType, scopeTargetId, scopeHostIds, scopeLabel, commandBlocklist, commandTimeout, webSearchConfig, buildExecutorContextForScope,
     toolIntegrationMode,
     clearScopeDraft, showScopeSessionView, setActiveSessionId,
+    flushDraftText, currentAgentConfig, buildExternalAgentRuntimeModelTarget,
+    loadSdkRuntimeModelCatalog, applySdkRuntimeModelCatalog,
   ]);
 
   const handleCompact = useCallback(async () => {
@@ -1462,45 +1583,19 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
     setShowHistory(false);
   }, [ensureScopeDraft, showScopeDraftView, updateScopeDraft]);
 
-  // Warm the Streamdown/markdown chunk while the panel is visible but idle, so
-  // the first completed assistant reply does not pay the full parse cost mid-interaction.
-  useEffect(() => {
-    if (!isVisible) return;
-    let cancelled = false;
-    const loadMarkdown = () => {
-      if (cancelled) return;
-      void import('./ai-elements/messageResponse');
-    };
-    if (typeof requestIdleCallback === 'function') {
-      const idleId = requestIdleCallback(loadMarkdown, { timeout: 2500 });
-      return () => {
-        cancelled = true;
-        cancelIdleCallback(idleId);
-      };
-    }
-    const timeoutId = window.setTimeout(loadMarkdown, 0);
-    return () => {
-      cancelled = true;
-      window.clearTimeout(timeoutId);
-    };
-  }, [isVisible]);
-
-  // Keep streaming/session hooks alive for retained hidden panels, but do not
-  // mount ChatMessageList / Streamdown / ChatInput while CSS-hidden — those trees
-  // are the main tab-switch and cross-tab re-render cost.
-  if (!isVisible) {
-    return (
-      <div
-        className="h-full min-h-0 bg-background"
-        data-section="ai-chat-panel-retained"
-        aria-hidden="true"
-      />
-    );
-  }
-
+  // Hidden retained panels keep the composer mounted (parent is `hidden` +
+  // inert) so reopen does not remount ChatInput. Skip the message list.
   return (
     <React.Profiler {...getAIPanelProfilerProps('AIChatSidePanel.Active')}>
+      <div
+        className="h-full min-h-0"
+        data-section={isVisible ? undefined : 'ai-chat-panel-retained'}
+        aria-hidden={isVisible ? undefined : true}
+        inert={isVisible ? undefined : true}
+      >
       <AIChatPanelContent
+        parked={!isVisible}
+        sending={isSending}
         t={t}
         currentAgentId={currentAgentId}
         externalAgents={externalAgents}
@@ -1535,7 +1630,7 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
         canSteer={canSteerCurrentTurn}
         isSteering={isSteering}
         steerWarning={steerWarning}
-        lockTurnConfiguration={Boolean(isStreaming && isCodexAppServer)}
+        lockTurnConfiguration={Boolean(isSending || (isStreaming && isCodexAppServer))}
         canSendCurrentAgent={canSendCurrentAgent}
         providerDisplayName={providerDisplayName}
         modelDisplayName={modelDisplayName}
@@ -1566,6 +1661,7 @@ const AIChatSidePanelActive: React.FC<AIChatSidePanelProps> = ({
         onOpenVaultSnippet={onOpenVaultSnippet}
         onOpenVaultSection={onOpenVaultSection}
       />
+      </div>
     </React.Profiler>
   );
 };
@@ -1641,6 +1737,22 @@ export function aiChatSidePanelPropsAreEqual(
   if (prev.onOpenVaultSnippet !== next.onOpenVaultSnippet) return false;
   if (prev.onOpenVaultSection !== next.onOpenVaultSection) return false;
 
+  const scopeKey = `${prev.scopeType}:${prev.scopeTargetId ?? ''}`;
+  if (
+    prev.sessions === next.sessions
+    && draftsByScopeEqualIgnoringComposerText(prev.draftsByScope, next.draftsByScope, scopeKey)
+  ) {
+    let restEqual = true;
+    for (const key of AI_CHAT_SIDE_PANEL_AI_STATE_KEYS) {
+      if (key === 'sessions' || key === 'draftsByScope') continue;
+      if (prev[key] !== next[key]) {
+        restEqual = false;
+        break;
+      }
+    }
+    if (restEqual) return true;
+  }
+
   // Sibling stream thrash: full sessions array identity always changes. Only
   // exact-scope session object refs matter for this panel's active chat —
   // plus the currently selected session, which may be a host-matched history
@@ -1706,6 +1818,12 @@ export function aiChatSidePanelPropsAreEqual(
 
   for (const key of AI_CHAT_SIDE_PANEL_AI_STATE_KEYS) {
     if (key === 'sessions') continue;
+    if (key === 'draftsByScope') {
+      if (!draftsByScopeEqualIgnoringComposerText(prev.draftsByScope, next.draftsByScope, scopeKey)) {
+        return false;
+      }
+      continue;
+    }
     if (prev[key] !== next[key]) return false;
   }
   return true;

components/QuickAddSnippetDialog.test.tsx

@@ -29,6 +29,7 @@ test("quick add snippet form binds shortkeys and uses a centered Dialog modal",
   assert.match(source, /from '\.\/ui\/dialog'/);
   assert.doesNotMatch(source, /AsidePanel/);
   assert.match(source, /snippets\.field\.shortkey/);
+  assert.match(source, /findActiveSystemShortcutConflict/);
   assert.match(source, /keyEventToString/);
   assert.match(source, /shortkey: shortkey \|\| undefined/);
   assert.match(source, /if \(e\.defaultPrevented\) return/);

components/QuickAddSnippetDialog.tsx

@@ -12,12 +12,13 @@ import { Keyboard, Package, RotateCcw } from 'lucide-react';
 import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { useI18n } from '../application/i18n/I18nProvider';
 import type { Snippet } from '../domain/models';
+import { findActiveSystemShortcutConflict } from '../domain/activeKeyBindings';
 import {
   type HotkeyScheme,
   type KeyBinding,
   keyEventToString,
+  keyStringToKeyboardEvent,
   matchesKeyBinding,
-  parseKeyCombo,
 } from '../domain/models';
 import { isScriptSnippet } from '../domain/snippetScript.ts';
 import { cn, isMacPlatform } from '../lib/utils';
@@ -132,78 +133,6 @@ export const QuickAddSnippetDialog: React.FC<QuickAddSnippetDialogProps> = ({
     snippets.filter((s) => Boolean(s.shortkey) && s.id !== editing?.id)
   ), [snippets, editing?.id]);
 
-  const activeSystemBindings = useMemo(() => {
-    return keyBindings.flatMap((binding) => {
-      const entries: { binding: string; isMac: boolean }[] = [];
-      const macBinding = binding.mac;
-      const pcBinding = binding.pc;
-
-      if (hotkeyScheme === 'mac') {
-        if (macBinding && macBinding !== 'Disabled') {
-          entries.push({ binding: macBinding, isMac: true });
-        }
-        return entries;
-      }
-
-      if (hotkeyScheme === 'pc') {
-        if (pcBinding && pcBinding !== 'Disabled') {
-          entries.push({ binding: pcBinding, isMac: false });
-        }
-        return entries;
-      }
-
-      if (macBinding && macBinding !== 'Disabled') {
-        entries.push({ binding: macBinding, isMac: true });
-      }
-      if (pcBinding && pcBinding !== 'Disabled') {
-        entries.push({ binding: pcBinding, isMac: false });
-      }
-      return entries;
-    });
-  }, [hotkeyScheme, keyBindings]);
-
-  const buildKeyEventFromString = useCallback((keyString: string) => {
-    const parsed = parseKeyCombo(keyString);
-    if (!parsed) return null;
-
-    const modifiers = new Set(parsed.modifiers);
-    const key = parsed.key;
-    const normalizedKey = (() => {
-      switch (key) {
-        case 'Space':
-          return ' ';
-        case '↑':
-          return 'ArrowUp';
-        case '↓':
-          return 'ArrowDown';
-        case '←':
-          return 'ArrowLeft';
-        case '→':
-          return 'ArrowRight';
-        case 'Esc':
-          return 'Escape';
-        case '⌫':
-          return 'Backspace';
-        case 'Del':
-          return 'Delete';
-        case '↵':
-          return 'Enter';
-        case '⇥':
-          return 'Tab';
-        default:
-          return key.length === 1 ? key.toLowerCase() : key;
-      }
-    })();
-
-    return new KeyboardEvent('keydown', {
-      key: normalizedKey,
-      metaKey: modifiers.has('⌘') || modifiers.has('Win'),
-      ctrlKey: modifiers.has('⌃') || modifiers.has('Ctrl'),
-      altKey: modifiers.has('⌥') || modifiers.has('Alt'),
-      shiftKey: modifiers.has('Shift'),
-    });
-  }, []);
-
   const normalizeKeyString = useCallback((value: string) => (
     value.toLowerCase().replace(/\s+/g, '')
   ), []);
@@ -211,16 +140,14 @@ export const QuickAddSnippetDialog: React.FC<QuickAddSnippetDialogProps> = ({
   const validateShortkey = useCallback((key: string): string | null => {
     if (!key) return null;
 
-    const syntheticEvent = buildKeyEventFromString(key);
-    if (syntheticEvent) {
-      const conflictsSystem = activeSystemBindings.some(({ binding, isMac: bindingIsMac }) => (
-        matchesKeyBinding(syntheticEvent, binding, bindingIsMac)
-      ));
-      if (conflictsSystem) {
-        return t('snippets.shortkey.error.systemConflict');
-      }
+    const systemConflict = findActiveSystemShortcutConflict(key, hotkeyScheme, keyBindings);
+    if (systemConflict) {
+      const nameKey = `settings.shortcuts.binding.${systemConflict.id}`;
+      const name = t(nameKey) !== nameKey ? t(nameKey) : systemConflict.label;
+      return t('snippets.shortkey.error.systemConflict', { name });
     }
 
+    const syntheticEvent = keyStringToKeyboardEvent(key);
     if (syntheticEvent) {
       for (const snippet of existingShortkeys) {
         if (snippet.shortkey && matchesKeyBinding(syntheticEvent, snippet.shortkey, isMac)) {
@@ -239,10 +166,10 @@ export const QuickAddSnippetDialog: React.FC<QuickAddSnippetDialogProps> = ({
 
     return null;
   }, [
-    activeSystemBindings,
-    buildKeyEventFromString,
     existingShortkeys,
+    hotkeyScheme,
     isMac,
+    keyBindings,
     normalizeKeyString,
     t,
   ]);

components/SettingsPage.tsx

@@ -627,6 +627,8 @@ const SettingsPageContent: React.FC<{ settings: SettingsState }> = ({ settings }
                                 setRestorePreviousSession={settings.setRestorePreviousSession}
                                 restoreTerminalCwd={settings.restoreTerminalCwd}
                                 setRestoreTerminalCwd={settings.setRestoreTerminalCwd}
+                                startupLanding={settings.startupLanding}
+                                setStartupLanding={settings.setStartupLanding}
                                 toggleWindowHotkey={settings.toggleWindowHotkey}
                                 setToggleWindowHotkey={settings.setToggleWindowHotkey}
                                 closeToTray={settings.closeToTray}

components/SnippetsManager.tsx

@@ -9,7 +9,8 @@ import {
   getShellHistorySnapshot,
   subscribeShellHistory,
 } from '../application/state/shellHistoryStore';
-import { HotkeyScheme, KeyBinding, keyEventToString, ManagedSource, matchesKeyBinding, parseKeyCombo } from '../domain/models';
+import { findActiveSystemShortcutConflict } from '../domain/activeKeyBindings';
+import { HotkeyScheme, KeyBinding, keyEventToString, keyStringToKeyboardEvent, ManagedSource, matchesKeyBinding } from '../domain/models';
 import {
   buildSnippetExportPayload,
   combineSnippetImportPayloads,
@@ -576,95 +577,21 @@ const SnippetsManager: React.FC<SnippetsManagerProps> = ({
     hotkeyScheme === 'mac' || (hotkeyScheme === 'disabled' && isMacPlatform())
   ), [hotkeyScheme]);
 
-  const activeSystemBindings = useMemo(() => {
-    return keyBindings.flatMap((binding) => {
-      const entries: { binding: string; isMac: boolean }[] = [];
-      const macBinding = binding.mac;
-      const pcBinding = binding.pc;
-
-      if (hotkeyScheme === 'mac') {
-        if (macBinding && macBinding !== 'Disabled') {
-          entries.push({ binding: macBinding, isMac: true });
-        }
-        return entries;
-      }
-
-      if (hotkeyScheme === 'pc') {
-        if (pcBinding && pcBinding !== 'Disabled') {
-          entries.push({ binding: pcBinding, isMac: false });
-        }
-        return entries;
-      }
-
-      if (macBinding && macBinding !== 'Disabled') {
-        entries.push({ binding: macBinding, isMac: true });
-      }
-      if (pcBinding && pcBinding !== 'Disabled') {
-        entries.push({ binding: pcBinding, isMac: false });
-      }
-      return entries;
-    });
-  }, [hotkeyScheme, keyBindings]);
-
-  const buildKeyEventFromString = useCallback((keyString: string) => {
-    const parsed = parseKeyCombo(keyString);
-    if (!parsed) return null;
-
-    const modifiers = new Set(parsed.modifiers);
-    const key = parsed.key;
-    const normalizedKey = (() => {
-      switch (key) {
-        case 'Space':
-          return ' ';
-        case '↑':
-          return 'ArrowUp';
-        case '↓':
-          return 'ArrowDown';
-        case '←':
-          return 'ArrowLeft';
-        case '→':
-          return 'ArrowRight';
-        case 'Esc':
-          return 'Escape';
-        case '⌫':
-          return 'Backspace';
-        case 'Del':
-          return 'Delete';
-        case '↵':
-          return 'Enter';
-        case '⇥':
-          return 'Tab';
-        default:
-          return key.length === 1 ? key.toLowerCase() : key;
-      }
-    })();
-
-    return new KeyboardEvent('keydown', {
-      key: normalizedKey,
-      metaKey: modifiers.has('⌘') || modifiers.has('Win'),
-      ctrlKey: modifiers.has('⌃') || modifiers.has('Ctrl'),
-      altKey: modifiers.has('⌥') || modifiers.has('Alt'),
-      shiftKey: modifiers.has('Shift'),
-    });
-  }, []);
-
   const normalizeKeyString = useCallback((value: string) => (
     value.toLowerCase().replace(/\s+/g, '')
   ), []);
 
   const validateShortkey = useCallback((key: string): string | null => {
     if (!key) return null;
-    
-    const syntheticEvent = buildKeyEventFromString(key);
-    if (syntheticEvent) {
-      const conflictsSystem = activeSystemBindings.some(({ binding, isMac: bindingIsMac }) => (
-        matchesKeyBinding(syntheticEvent, binding, bindingIsMac)
-      ));
-      if (conflictsSystem) {
-        return t('snippets.shortkey.error.systemConflict');
-      }
+
+    const systemConflict = findActiveSystemShortcutConflict(key, hotkeyScheme, keyBindings);
+    if (systemConflict) {
+      const nameKey = `settings.shortcuts.binding.${systemConflict.id}`;
+      const name = t(nameKey) !== nameKey ? t(nameKey) : systemConflict.label;
+      return t('snippets.shortkey.error.systemConflict', { name });
     }
-    
+
+    const syntheticEvent = keyStringToKeyboardEvent(key);
     if (syntheticEvent) {
       for (const snippet of existingShortkeys) {
         if (snippet.shortkey && matchesKeyBinding(syntheticEvent, snippet.shortkey, isMac)) {
@@ -680,13 +607,13 @@ const SnippetsManager: React.FC<SnippetsManagerProps> = ({
         return t('snippets.shortkey.error.snippetConflict', { name: conflictingSnippet.label });
       }
     }
-    
+
     return null;
   }, [
-    activeSystemBindings,
-    buildKeyEventFromString,
     existingShortkeys,
+    hotkeyScheme,
     isMac,
+    keyBindings,
     normalizeKeyString,
     t,
   ]);

components/Terminal.tsx

@@ -44,6 +44,7 @@ import {
 import { classifyDistroId, shouldProbeSessionCwd } from "../domain/host";
 import { shouldCollectServerStats } from "../domain/systemManager/systemTarget";
 import { resolveHostSshConnectionTimeouts } from "../domain/sshConnectionTimeouts";
+import { CONNECTION_PROGRESS_START } from "./terminal/connectionProgress";
 import { supportsZmodemTerminalDragDrop } from "../lib/zmodemDragDrop";
 import { resolveHostAuth, resolveHostAutofillPassword } from "../domain/sshAuth";
 import { resolveEffectiveTerminalProtocol } from "../domain/terminalProtocol";
@@ -824,7 +825,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
   const [isCancelling, setIsCancelling] = useState(false);
   const [showSFTP, setShowSFTP] = useState(false);
   const [isSessionLogging, setIsSessionLogging] = useState(false);
-  const [progressValue, setProgressValue] = useState(15);
+  const [progressValue, setProgressValue] = useState(CONNECTION_PROGRESS_START);
   const [isDisconnectedDialogDismissed, setIsDisconnectedDialogDismissed] = useState(false);
   const [connectionReuseFellBack, setConnectionReuseFellBack] = useState(false);
   const [connectionReuseAttemptSourceId, setConnectionReuseAttemptSourceId] = useState(

components/ai-elements/LazyMessageResponse.tsx

@@ -1,12 +1,24 @@
-import React, { lazy, Suspense } from 'react';
+import React, { lazy, Suspense, useEffect, useState } from 'react';
 
 import { cn } from '../../lib/utils';
+import {
+  enqueueChatMarkdownHydrate,
+  isAiMarkdownRendererReady,
+  scheduleWhenAiComposerIdle,
+  subscribeAiMarkdownRendererReady,
+  warmAiMarkdownRenderer,
+} from '../ai/aiMarkdownWarmup';
 import { LazyLoadBoundary } from '../ui/lazy-load-boundary';
 
 type LazyMessageResponseProps = {
   children?: React.ReactNode;
   className?: string;
   isAnimating?: boolean;
+  /**
+   * Keep plaintext until Streamdown is already warmed. Chat history uses this
+   * so expanding the panel cannot start the ~350KB parse during first typing.
+   */
+  deferUntilWarm?: boolean;
 };
 
 const MessageResponse = lazy(() =>
@@ -20,11 +32,34 @@ const PlainTextFallback = ({ children, className }: LazyMessageResponseProps) =>
 );
 
 export function LazyMessageResponse(props: LazyMessageResponseProps) {
-  const resetKey = typeof props.children === 'string' ? props.children : undefined;
+  const { deferUntilWarm = false, ...rendererProps } = props;
+  const [ready, setReady] = useState(() => !deferUntilWarm && isAiMarkdownRendererReady());
+  const resetKey = typeof rendererProps.children === 'string' ? rendererProps.children : undefined;
+
+  useEffect(() => {
+    if (ready) return undefined;
+    if (!deferUntilWarm) {
+      const unsubscribe = subscribeAiMarkdownRendererReady(() => setReady(true));
+      if (isAiMarkdownRendererReady()) return unsubscribe;
+      const cancelIdle = scheduleWhenAiComposerIdle(() => {
+        void warmAiMarkdownRenderer();
+      });
+      return () => {
+        unsubscribe();
+        cancelIdle();
+      };
+    }
+    return enqueueChatMarkdownHydrate(() => setReady(true));
+  }, [deferUntilWarm, ready]);
+
+  if (deferUntilWarm && !ready) {
+    return <PlainTextFallback {...rendererProps} />;
+  }
+
   return (
-    <LazyLoadBoundary fallback={<PlainTextFallback {...props} />} resetKey={resetKey}>
-      <Suspense fallback={<PlainTextFallback {...props} />}>
-        <MessageResponse {...props} />
+    <LazyLoadBoundary fallback={<PlainTextFallback {...rendererProps} />} resetKey={resetKey}>
+      <Suspense fallback={<PlainTextFallback {...rendererProps} />}>
+        <MessageResponse {...rendererProps} />
       </Suspense>
     </LazyLoadBoundary>
   );

components/ai-elements/hasMarkdownCodeFence.test.ts

@@ -0,0 +1,13 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { hasMarkdownCodeFence } from './hasMarkdownCodeFence';
+
+test('detects common markdown fences', () => {
+  assert.equal(hasMarkdownCodeFence('hello'), false);
+  assert.equal(hasMarkdownCodeFence('use `code` inline'), false);
+  assert.equal(hasMarkdownCodeFence('```ts\nconst a = 1\n```'), true);
+  assert.equal(hasMarkdownCodeFence('prefix\n```\nplain\n```'), true);
+  assert.equal(hasMarkdownCodeFence('~~~\nbash\n~~~'), true);
+  assert.equal(hasMarkdownCodeFence('   ```json\n{}\n```'), true);
+});

components/ai-elements/hasMarkdownCodeFence.ts

@@ -0,0 +1,6 @@
+const FENCE_RE = /(?:^|\n)\s{0,3}(`{3,}|~{3,})/;
+
+/** True when markdown contains a fenced code block that may want Shiki. */
+export function hasMarkdownCodeFence(text: string): boolean {
+  return FENCE_RE.test(text);
+}

components/ai-elements/messageResponse.test.ts

@@ -0,0 +1,20 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { readFileSync } from 'node:fs';
+
+test('messageResponse does not statically import Shiki', () => {
+  const source = readFileSync(new URL('./messageResponse.tsx', import.meta.url), 'utf8');
+  assert.doesNotMatch(source, /from ['"]@streamdown\/code['"]/);
+  assert.match(source, /from ['"]@streamdown\/cjk['"]/);
+  assert.match(source, /hasMarkdownCodeFence/);
+  assert.match(source, /warmAiCodeHighlighter/);
+  assert.match(source, /scheduleWhenAiComposerIdle/);
+});
+
+test('Shiki lives in an isolated plugin module', () => {
+  const plugin = readFileSync(new URL('./streamdownCodePlugin.ts', import.meta.url), 'utf8');
+  const warmup = readFileSync(new URL('./streamdownCodeWarmup.ts', import.meta.url), 'utf8');
+  assert.match(plugin, /from ['"]@streamdown\/code['"]/);
+  assert.match(warmup, /import\('\.\/streamdownCodePlugin'\)/);
+  assert.doesNotMatch(warmup, /from ['"]@streamdown\/code['"]/);
+});

components/ai-elements/messageResponse.tsx

@@ -1,43 +1,73 @@
-import { cn } from '../../lib/utils';
 import { cjk } from '@streamdown/cjk';
-import { code } from '@streamdown/code';
 import type { ComponentProps } from 'react';
-import { memo } from 'react';
+import { memo, useEffect, useMemo, useState } from 'react';
 import { Streamdown } from 'streamdown';
-import { createSafeCodeHighlighter } from './streamdownCodeHighlighter';
 
-const safeCode = createSafeCodeHighlighter(code);
-const streamdownPlugins = { cjk, code: safeCode };
+import { scheduleWhenAiComposerIdle } from '../ai/aiMarkdownWarmup';
+import { cn } from '../../lib/utils';
+import { hasMarkdownCodeFence } from './hasMarkdownCodeFence';
+import {
+  getCachedStreamdownCodePlugin,
+  warmAiCodeHighlighter,
+} from './streamdownCodeWarmup';
+
+const STREAMDOWN_CLASS = [
+  'size-full [&>*:first-child]:mt-0 [&>*:last-child]:mb-0',
+  '[&_code]:text-[12px] [&_code]:font-mono',
+  '[&_p_code]:px-[0.4em] [&_p_code]:py-[0.15em] [&_p_code]:rounded [&_p_code]:bg-foreground/[0.06] [&_p_code]:text-[85%] [&_p_code]:whitespace-normal [&_p_code]:[overflow-wrap:anywhere]',
+  '[&_p]:my-1.5',
+  '[&_ul]:my-1.5 [&_ul]:pl-4 [&_ul]:list-disc',
+  '[&_ol]:my-1.5 [&_ol]:pl-4 [&_ol]:list-decimal',
+  '[&_li]:my-0.5',
+  '[&_h1]:text-base [&_h1]:font-semibold [&_h1]:mt-4 [&_h1]:mb-2',
+  '[&_h2]:text-sm [&_h2]:font-semibold [&_h2]:mt-3 [&_h2]:mb-1.5',
+  '[&_h3]:text-sm [&_h3]:font-medium [&_h3]:mt-2 [&_h3]:mb-1',
+  '[&_blockquote]:border-l-2 [&_blockquote]:border-border/50 [&_blockquote]:pl-3 [&_blockquote]:text-muted-foreground',
+  '[&_a]:text-primary [&_a]:underline',
+  '[&_hr]:border-border/30 [&_hr]:my-3',
+  '[&_table]:text-[12px] [&_th]:px-2 [&_th]:py-1 [&_th]:border [&_th]:border-border/30 [&_th]:bg-muted/20 [&_td]:px-2 [&_td]:py-1 [&_td]:border [&_td]:border-border/30',
+].join(' ');
 
 export type MessageResponseProps = ComponentProps<typeof Streamdown>;
 
-/** Heavy markdown renderer — load via LazyMessageResponse, not the chat list critical path. */
-export const MessageResponse = memo(
-  ({ className, ...props }: MessageResponseProps) => (
+function MessageResponseView({ className, children, ...props }: MessageResponseProps) {
+  const [codePlugin, setCodePlugin] = useState(getCachedStreamdownCodePlugin);
+  const source = typeof children === 'string' ? children : '';
+  const wantsCode = hasMarkdownCodeFence(source);
+
+  useEffect(() => {
+    if (!wantsCode || codePlugin) return undefined;
+    let cancelled = false;
+    const cancelIdle = scheduleWhenAiComposerIdle(() => {
+      void warmAiCodeHighlighter().then((plugin) => {
+        if (!cancelled) setCodePlugin(plugin);
+      });
+    });
+    return () => {
+      cancelled = true;
+      cancelIdle();
+    };
+  }, [codePlugin, wantsCode]);
+
+  const plugins = useMemo(
+    () => (codePlugin ? { cjk, code: codePlugin } : { cjk }),
+    [codePlugin],
+  );
+
+  return (
     <Streamdown
-      className={cn(
-        'size-full [&>*:first-child]:mt-0 [&>*:last-child]:mb-0',
-        // Style the rendered markdown
-        // Code: base styles (code-block overrides are in index.css)
-        '[&_code]:text-[12px] [&_code]:font-mono',
-        '[&_p_code]:px-[0.4em] [&_p_code]:py-[0.15em] [&_p_code]:rounded [&_p_code]:bg-foreground/[0.06] [&_p_code]:text-[85%] [&_p_code]:whitespace-normal [&_p_code]:[overflow-wrap:anywhere]',
-        '[&_p]:my-1.5',
-        '[&_ul]:my-1.5 [&_ul]:pl-4 [&_ul]:list-disc',
-        '[&_ol]:my-1.5 [&_ol]:pl-4 [&_ol]:list-decimal',
-        '[&_li]:my-0.5',
-        '[&_h1]:text-base [&_h1]:font-semibold [&_h1]:mt-4 [&_h1]:mb-2',
-        '[&_h2]:text-sm [&_h2]:font-semibold [&_h2]:mt-3 [&_h2]:mb-1.5',
-        '[&_h3]:text-sm [&_h3]:font-medium [&_h3]:mt-2 [&_h3]:mb-1',
-        '[&_blockquote]:border-l-2 [&_blockquote]:border-border/50 [&_blockquote]:pl-3 [&_blockquote]:text-muted-foreground',
-        '[&_a]:text-primary [&_a]:underline',
-        '[&_hr]:border-border/30 [&_hr]:my-3',
-        '[&_table]:text-[12px] [&_th]:px-2 [&_th]:py-1 [&_th]:border [&_th]:border-border/30 [&_th]:bg-muted/20 [&_td]:px-2 [&_td]:py-1 [&_td]:border [&_td]:border-border/30',
-        className,
-      )}
-      plugins={streamdownPlugins}
+      className={cn(STREAMDOWN_CLASS, className)}
+      plugins={plugins}
       {...props}
-    />
-  ),
+    >
+      {children}
+    </Streamdown>
+  );
+}
+
+/** Streamdown + CJK only. Shiki loads later when a fence exists and the composer is idle. */
+export const MessageResponse = memo(
+  MessageResponseView,
   (prevProps, nextProps) =>
     prevProps.children === nextProps.children &&
     nextProps.isAnimating === prevProps.isAnimating,

components/ai-elements/streamdownCodePlugin.ts

@@ -0,0 +1,6 @@
+import { code } from '@streamdown/code';
+
+import { createSafeCodeHighlighter } from './streamdownCodeHighlighter';
+
+/** Isolated Shiki entry — import this file only through warmAiCodeHighlighter. */
+export const streamdownCodePlugin = createSafeCodeHighlighter(code);

components/ai-elements/streamdownCodeWarmup.ts

@@ -0,0 +1,24 @@
+import type { CodeHighlighterPlugin } from 'streamdown';
+
+let cachedCodePlugin: CodeHighlighterPlugin | null = null;
+let codePluginPromise: Promise<CodeHighlighterPlugin> | null = null;
+
+export function getCachedStreamdownCodePlugin(): CodeHighlighterPlugin | null {
+  return cachedCodePlugin;
+}
+
+export function isAiCodeHighlighterReady(): boolean {
+  return cachedCodePlugin != null;
+}
+
+/** Prefetch Shiki only when a message actually contains a code fence. */
+export function warmAiCodeHighlighter(): Promise<CodeHighlighterPlugin> {
+  codePluginPromise ??= import('./streamdownCodePlugin').then((module) => {
+    cachedCodePlugin = module.streamdownCodePlugin;
+    return module.streamdownCodePlugin;
+  }, (error) => {
+    codePluginPromise = null;
+    throw error;
+  });
+  return codePluginPromise;
+}

components/ai/AgentSelector.tsx

@@ -6,7 +6,7 @@
  */
 
 import { ChevronDown, RefreshCw, Plus, Settings } from 'lucide-react';
-import React, { useCallback, useMemo, useState } from 'react';
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
 import { cn } from '../../lib/utils';
 import { useI18n } from '../../application/i18n/I18nProvider';
 import {
@@ -32,6 +32,8 @@ interface AgentSelectorProps {
   onEnableDiscoveredAgent?: (agent: DiscoveredAgent) => void;
   onRediscover?: () => void;
   onManageAgents?: () => void;
+  parked?: boolean;
+  disabled?: boolean;
 }
 
 const BUILTIN_AGENTS: AgentInfo[] = [
@@ -125,10 +127,16 @@ const AgentSelector: React.FC<AgentSelectorProps> = ({
   onEnableDiscoveredAgent,
   onRediscover,
   onManageAgents,
+  parked = false,
+  disabled = false,
 }) => {
   const { t } = useI18n();
   const [open, setOpen] = useState(false);
 
+  useEffect(() => {
+    if (parked || disabled) setOpen(false);
+  }, [disabled, parked]);
+
   const enabledExternalAgents = useMemo(
     () =>
       externalAgents
@@ -200,7 +208,8 @@ const AgentSelector: React.FC<AgentSelectorProps> = ({
       <DropdownTrigger asChild>
         <button
           type="button"
-          className="group flex h-6 min-w-0 max-w-[170px] items-center gap-1.5 rounded-md px-1.5 text-left transition-colors hover:bg-muted focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-primary/28"
+          disabled={disabled}
+          className="group flex h-6 min-w-0 max-w-[170px] items-center gap-1.5 rounded-md px-1.5 text-left transition-colors hover:bg-muted focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-primary/28 disabled:pointer-events-none disabled:opacity-50"
         >
           <AgentIconBadge
             agent={currentAgent}

components/ai/ChatInput.test.tsx

@@ -62,6 +62,31 @@ test('expanded composer grows the text area while keeping controls at the bottom
   assert.doesNotMatch(source, /setExpanded/);
 });
 
+test('parked composer closes body-portaled menus', () => {
+  const source = readFileSync(new URL('./ChatInput.tsx', import.meta.url), 'utf8');
+  assert.match(source, /parked = false/);
+  assert.match(source, /if \(parked\) closeAllMenus\(\)/);
+  assert.match(source, /becameParked/);
+});
+
+test('first keystrokes stay local so IME and Chromium spellcheck cannot stall the composer', () => {
+  const source = readFileSync(new URL('./ChatInput.tsx', import.meta.url), 'utf8');
+  assert.match(source, /spellCheck=\{false\}/);
+  assert.match(source, /autoCorrect="off"/);
+  assert.match(source, /autoCapitalize="off"/);
+  assert.match(source, /nativeEvent\.isComposing/);
+  assert.match(source, /onCompositionEnd=/);
+  assert.match(source, /onBlur=\{\(\) => commitComposerText\(readComposerText\(\)\)\}/);
+  assert.match(source, /onChangeRef\.current\(textareaRef\.current\?\.value \?\? composerTextRef\.current\)/);
+  assert.doesNotMatch(source, /onSend\(\);\s*commitComposerText\(''\);/);
+  assert.match(source, /defaultValue=\{value\}/);
+  assert.match(source, /field-sizing-fixed/);
+  assert.doesNotMatch(source, /value=\{composerText\}/);
+  assert.match(source, /createComposerHasTextStore/);
+  assert.match(source, /ComposerSendUi/);
+  assert.match(source, /chatInputPropsAreEqual/);
+});
+
 test('composer resizing also ends when pointer capture is unexpectedly lost', () => {
   const source = readFileSync(new URL('./ChatInput.tsx', import.meta.url), 'utf8');
 
@@ -192,6 +217,11 @@ test('renders the Catty context usage ring after the model chip', () => {
   assert.match(html, /aria-valuenow="50"/);
 });
 
+test('slash picker system commands clear the local composer', () => {
+  const source = readFileSync(new URL('./ChatInput.tsx', import.meta.url), 'utf8');
+  assert.match(source, /if \(command === 'stop'\) onStop\?\.\(\);\s*commitComposerText\(''\);/s);
+});
+
 test('ChatInput wires /compact through getSystemSlashCommand and canCompact', () => {
   const source = readFileSync(new URL('./ChatInput.tsx', import.meta.url), 'utf8');
   assert.match(source, /getSystemSlashCommand/);

components/ai/ChatInput.tsx

@@ -20,7 +20,7 @@ import {
   type UserSkillSlashOption,
 } from '../../infrastructure/ai/quickMessages';
 import { SlashCommandPicker } from './SlashCommandPicker';
-import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import React, { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from 'react';
 import { useI18n } from '../../application/i18n/I18nProvider';
 import { createPortal } from 'react-dom';
 import type { FormEvent } from 'react';
@@ -38,6 +38,7 @@ import { ProviderIconBadge } from '../settings/tabs/ai/ProviderIconBadge';
 import { VariableSizeVirtualList, type VariableSizeVirtualListHandle } from '../ui/VariableSizeVirtualList';
 import { Tooltip, TooltipContent, TooltipTrigger } from '../ui/tooltip';
 import type { AgentContextUsage } from '../../application/state/useAgentCompactionUi';
+import { markAiComposerActivity, setAiComposerComposing } from './aiMarkdownWarmup';
 import {
   CHAT_INPUT_DEFAULT_HEIGHT,
   CHAT_INPUT_MAX_HEIGHT,
@@ -87,6 +88,87 @@ export interface ProviderSwitcherConfig {
   onSelect: (providerId: string, modelId: string) => void;
 }
 
+type ComposerHasTextStore = {
+  subscribe: (listener: () => void) => () => void;
+  get: () => boolean;
+  set: (next: boolean) => void;
+};
+
+function createComposerHasTextStore(initial: boolean): ComposerHasTextStore {
+  let value = initial;
+  const listeners = new Set<() => void>();
+  return {
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    get: () => value,
+    set: (next) => {
+      if (value === next) return;
+      value = next;
+      for (const listener of listeners) listener();
+    },
+  };
+}
+
+const ComposerSendUi = React.memo(function ComposerSendUi({
+  hasTextStore,
+  hasTerminalSelectionAttachment,
+  composerDisabled,
+  disabled,
+  isStreaming,
+  canSteer,
+  isSteering,
+  status,
+  onStop,
+  steerSendingLabel,
+  steerLabel,
+}: {
+  hasTextStore: ComposerHasTextStore;
+  hasTerminalSelectionAttachment: boolean;
+  composerDisabled: boolean;
+  disabled: boolean;
+  isStreaming: boolean;
+  canSteer: boolean;
+  isSteering: boolean;
+  status: PromptInputStatus;
+  onStop?: () => void;
+  steerSendingLabel: string;
+  steerLabel: string;
+}) {
+  const hasComposerText = useSyncExternalStore(hasTextStore.subscribe, hasTextStore.get, hasTextStore.get);
+  const sendDisabled = (!hasComposerText && !hasTerminalSelectionAttachment) || disabled;
+  if (isStreaming && canSteer) {
+    return (
+      <>
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <button
+              type="submit"
+              disabled={(!hasComposerText && !hasTerminalSelectionAttachment) || composerDisabled}
+              aria-label={isSteering ? steerSendingLabel : steerLabel}
+              className="inline-flex h-8 w-8 items-center justify-center rounded-full border border-foreground/20 bg-foreground text-background shadow-sm transition-colors hover:bg-foreground/90 disabled:border-border/80 disabled:bg-muted/52 disabled:text-foreground/72"
+            >
+              {isSteering ? <Loader2 size={14} className="animate-spin" /> : <ArrowUp size={14} />}
+            </button>
+          </TooltipTrigger>
+          <TooltipContent>{isSteering ? steerSendingLabel : steerLabel}</TooltipContent>
+        </Tooltip>
+        <PromptInputSubmit status="streaming" onStop={onStop} />
+      </>
+    );
+  }
+  return (
+    <PromptInputSubmit
+      status={status}
+      onStop={onStop}
+      disabled={sendDisabled}
+    />
+  );
+});
+
 interface ChatInputProps {
   value: string;
   onChange: (value: string) => void;
@@ -141,6 +223,8 @@ interface ChatInputProps {
    * `modelPresets` dropdown because their provider is wired inside the CLI.
    */
   providerSwitcher?: ProviderSwitcherConfig;
+  /** Hidden retained panels must not leave body-portaled menus open. */
+  parked?: boolean;
 }
 
 const ChatInput: React.FC<ChatInputProps> = ({
@@ -176,10 +260,18 @@ const ChatInput: React.FC<ChatInputProps> = ({
   permissionMode,
   onPermissionModeChange,
   providerSwitcher,
+  parked = false,
 }) => {
   const { t } = useI18n();
   const hasTerminalSelectionAttachment = files.some((file) => file.terminalSelection);
   const composerDisabled = disabled || isSteering;
+  const composerTextRef = useRef(value);
+  const hasTextStoreRef = useRef<ComposerHasTextStore | null>(null);
+  if (hasTextStoreRef.current == null) {
+    hasTextStoreRef.current = createComposerHasTextStore(value.trim().length > 0);
+  }
+  const hasTextStore = hasTextStoreRef.current;
+  const pushedParentTextRef = useRef(value);
   const [composerHeight, setComposerHeight] = useState<number | null>(null);
   const [composerMaxHeight, setComposerMaxHeight] = useState(CHAT_INPUT_MAX_HEIGHT);
   const composerDesiredHeightRef = useRef<number | null>(null);
@@ -209,6 +301,10 @@ const ChatInput: React.FC<ChatInputProps> = ({
     setSlashQuery('');
     setSlashRange(null);
   }, []);
+
+  useEffect(() => {
+    if (parked) closeAllMenus();
+  }, [closeAllMenus, parked]);
   const textareaRef = useRef<HTMLTextAreaElement>(null);
   const inputShellRef = useRef<HTMLDivElement>(null);
   const resizeStartRef = useRef<{
@@ -320,11 +416,12 @@ const ChatInput: React.FC<ChatInputProps> = ({
     const observer = new ResizeObserver(() => {
       const maxHeight = resolveVisibleChatInputMaxHeight(panel.clientHeight);
       if (maxHeight == null) return;
-      setComposerMaxHeight(maxHeight);
-      setComposerHeight(resolveVisibleChatInputHeight(
+      const nextHeight = resolveVisibleChatInputHeight(
         composerDesiredHeightRef.current,
         maxHeight,
-      ));
+      );
+      setComposerMaxHeight((current) => (current === maxHeight ? current : maxHeight));
+      setComposerHeight((current) => (current === nextHeight ? current : nextHeight));
     });
     observer.observe(panel);
     return () => observer.disconnect();
@@ -337,6 +434,48 @@ const ChatInput: React.FC<ChatInputProps> = ({
     document.body.style.userSelect = resizeStart.previousUserSelect;
   }, []);
 
+  const syncHasComposerText = useCallback((text: string) => {
+    hasTextStore.set(text.trim().length > 0);
+  }, [hasTextStore]);
+
+  const readComposerText = useCallback(() => (
+    textareaRef.current?.value ?? composerTextRef.current
+  ), []);
+
+  useEffect(() => {
+    if (value === pushedParentTextRef.current) return;
+    pushedParentTextRef.current = value;
+    composerTextRef.current = value;
+    if (textareaRef.current && textareaRef.current.value !== value) {
+      textareaRef.current.value = value;
+    }
+    syncHasComposerText(value);
+  }, [syncHasComposerText, value]);
+
+  const commitComposerText = useCallback((next: string) => {
+    composerTextRef.current = next;
+    pushedParentTextRef.current = next;
+    if (textareaRef.current && textareaRef.current.value !== next) {
+      textareaRef.current.value = next;
+    }
+    syncHasComposerText(next);
+    onChange(next);
+  }, [onChange, syncHasComposerText]);
+
+  const parkedRef = useRef(parked);
+  useEffect(() => {
+    const becameParked = parked && !parkedRef.current;
+    parkedRef.current = parked;
+    if (!becameParked) return;
+    commitComposerText(readComposerText());
+  }, [commitComposerText, parked, readComposerText]);
+
+  const onChangeRef = useRef(onChange);
+  onChangeRef.current = onChange;
+  useEffect(() => () => {
+    onChangeRef.current(textareaRef.current?.value ?? composerTextRef.current);
+  }, []);
+
   const findSlashTrigger = useCallback((text: string, caretPosition: number) => {
     const beforeCaret = text.slice(0, caretPosition);
     const match = /(^|\s)\/([a-z0-9-]*)$/i.exec(beforeCaret);
@@ -362,13 +501,18 @@ const ChatInput: React.FC<ChatInputProps> = ({
     };
   }, []);
 
-  const handleInputChange = useCallback((newValue: string) => {
-    onChange(newValue);
+  const handleInputChange = useCallback((newValue: string, composing = false) => {
+    markAiComposerActivity();
+    const previousText = composerTextRef.current;
+    composerTextRef.current = newValue;
+    syncHasComposerText(newValue);
+    if (composing) return;
+    commitComposerText(newValue);
     const caretPosition = textareaRef.current?.selectionStart ?? newValue.length;
     // Detect if user just typed @
     if (
       hosts.length > 0 &&
-      newValue.length > value.length &&
+      newValue.length > previousText.length &&
       newValue.endsWith('@')
     ) {
       // Position the popover near the textarea
@@ -396,18 +540,19 @@ const ChatInput: React.FC<ChatInputProps> = ({
     } else if (showSlashCommandPicker) {
       closeAllMenus();
     }
-  }, [onChange, value, hosts.length, showAtMention, findSlashTrigger, showSlashCommandPicker, closeAllMenus, getInputPanelMenuPos]);
+  }, [commitComposerText, hosts.length, showAtMention, findSlashTrigger, showSlashCommandPicker, closeAllMenus, getInputPanelMenuPos, syncHasComposerText]);
 
   const handleSelectAtMention = useCallback((host: { label: string; hostname: string }) => {
     // Replace the trailing @ with @hostname
     const name = host.label || host.hostname;
-    const lastAt = value.lastIndexOf('@');
+    const currentText = readComposerText();
+    const lastAt = currentText.lastIndexOf('@');
     const newValue = lastAt >= 0
-      ? value.slice(0, lastAt) + `@${name} `
-      : value + `@${name} `;
-    onChange(newValue);
+      ? currentText.slice(0, lastAt) + `@${name} `
+      : currentText + `@${name} `;
+    commitComposerText(newValue);
     closeAllMenus();
-  }, [value, onChange, closeAllMenus]);
+  }, [readComposerText, commitComposerText, closeAllMenus]);
 
   const openInputPanelMenu = useCallback((menu: 'atMention' | 'slashCommand') => {
     const pos = getInputPanelMenuPos();
@@ -415,8 +560,9 @@ const ChatInput: React.FC<ChatInputProps> = ({
     setMenuPos(null);
     setInputPanelPos(pos);
     if (menu === 'slashCommand') {
-      const caret = textareaRef.current?.selectionStart ?? value.length;
-      const trigger = findSlashTrigger(value, caret);
+      const currentText = readComposerText();
+      const caret = textareaRef.current?.selectionStart ?? currentText.length;
+      const trigger = findSlashTrigger(currentText, caret);
       if (trigger) {
         setSlashQuery(trigger.query);
         setSlashRange({ start: trigger.start, end: trigger.end });
@@ -426,7 +572,7 @@ const ChatInput: React.FC<ChatInputProps> = ({
       }
     }
     setActiveMenu(menu);
-  }, [findSlashTrigger, getInputPanelMenuPos, value]);
+  }, [findSlashTrigger, getInputPanelMenuPos, readComposerText]);
 
   const userSkillOptions = useMemo<UserSkillSlashOption[]>(
     () => (lockTurnConfiguration ? [] : userSkills).map((skill) => ({
@@ -492,37 +638,39 @@ const ChatInput: React.FC<ChatInputProps> = ({
   const showSlashPickerUI = showSlashCommandPicker && (inputPanelPos != null || menuPos != null);
 
   const removeSlashQueryFromInput = useCallback(() => {
-    if (!slashRange) return value;
-    const before = value.slice(0, slashRange.start);
-    const after = value.slice(slashRange.end);
+    const currentText = readComposerText();
+    if (!slashRange) return currentText;
+    const before = currentText.slice(0, slashRange.start);
+    const after = currentText.slice(slashRange.end);
     if (/\s$/.test(before) && /^\s/.test(after)) {
       return `${before}${after.slice(1)}`;
     }
     return `${before}${after}`;
-  }, [slashRange, value]);
+  }, [slashRange, readComposerText]);
 
   const insertUserSkillToken = useCallback((skill: { slug: string }) => {
     if (lockTurnConfiguration) return;
     onAddUserSkill?.(skill.slug);
     if (slashRange) {
-      onChange(removeSlashQueryFromInput());
+      commitComposerText(removeSlashQueryFromInput());
     }
     closeAllMenus();
-  }, [closeAllMenus, lockTurnConfiguration, onAddUserSkill, onChange, removeSlashQueryFromInput, slashRange]);
+  }, [closeAllMenus, lockTurnConfiguration, onAddUserSkill, commitComposerText, removeSlashQueryFromInput, slashRange]);
 
   const insertQuickMessage = useCallback((message: AIQuickMessage) => {
+    const currentText = readComposerText();
     if (slashRange) {
-      const before = value.slice(0, slashRange.start);
-      const after = value.slice(slashRange.end);
+      const before = currentText.slice(0, slashRange.start);
+      const after = currentText.slice(slashRange.end);
       const spacerBefore = before.length > 0 && !/\s$/.test(before) ? ' ' : '';
       const spacerAfter = after.length > 0 && !/^\s/.test(after) ? ' ' : '';
-      onChange(`${before}${spacerBefore}${message.content}${spacerAfter}${after}`);
+      commitComposerText(`${before}${spacerBefore}${message.content}${spacerAfter}${after}`);
     } else {
-      const spacer = value.length > 0 && !/\s$/.test(value) ? ' ' : '';
-      onChange(`${value}${spacer}${message.content}`);
+      const spacer = currentText.length > 0 && !/\s$/.test(currentText) ? ' ' : '';
+      commitComposerText(`${currentText}${spacer}${message.content}`);
     }
     closeAllMenus();
-  }, [closeAllMenus, onChange, slashRange, value]);
+  }, [closeAllMenus, commitComposerText, readComposerText, slashRange]);
 
   const handleSelectSlashCommandItem = useCallback((item: SlashCommandItem) => {
     if (item.kind === 'system') {
@@ -535,7 +683,7 @@ const ChatInput: React.FC<ChatInputProps> = ({
         onCompact?.();
       }
       if (command === 'stop') onStop?.();
-      onChange('');
+      commitComposerText('');
       closeAllMenus();
       return;
     }
@@ -544,7 +692,7 @@ const ChatInput: React.FC<ChatInputProps> = ({
       return;
     }
     insertUserSkillToken(item.skill);
-  }, [canCompact, closeAllMenus, insertQuickMessage, insertUserSkillToken, onChange, onCompact, onStop]);
+  }, [canCompact, closeAllMenus, commitComposerText, insertQuickMessage, insertUserSkillToken, onCompact, onStop]);
 
   // Reset active highlight when a menu opens or when the *identity* of the
   // visible items changes. Watching only `.length` misses cases where the
@@ -677,17 +825,19 @@ const ChatInput: React.FC<ChatInputProps> = ({
 
   const handleSubmit = useCallback(
     (_text: string, _event: FormEvent<HTMLFormElement>) => {
-      const systemCommand = getSystemSlashCommand(value);
+      const submittedText = readComposerText();
+      commitComposerText(submittedText);
+      const systemCommand = getSystemSlashCommand(submittedText);
       if (systemCommand) {
         if (systemCommand === 'compact') {
           if (!canCompact) return;
           onCompact?.();
-          onChange('');
+          commitComposerText('');
           return;
         }
         if (systemCommand === 'stop') {
           onStop?.();
-          onChange('');
+          commitComposerText('');
           return;
         }
         return;
@@ -696,9 +846,11 @@ const ChatInput: React.FC<ChatInputProps> = ({
         onSteer?.();
         return;
       }
+      // Do not empty the box here. handleSend awaits provider sync and may
+      // abort; the parent clears value only after the user message is accepted.
       onSend();
     },
-    [canCompact, canSteer, isStreaming, onCompact, onSend, onSteer, onStop, onChange, value],
+    [canCompact, canSteer, commitComposerText, isStreaming, onCompact, onSend, onSteer, onStop, readComposerText],
   );
 
   const status: PromptInputStatus = isStreaming ? 'streaming' : 'idle';
@@ -912,12 +1064,25 @@ const ChatInput: React.FC<ChatInputProps> = ({
           )}
           <PromptInputTextarea
             ref={textareaRef}
-            value={value}
-            onChange={(e) => handleInputChange(e.target.value)}
+            defaultValue={value}
+            spellCheck={false}
+            autoCorrect="off"
+            autoCapitalize="off"
+            autoComplete="off"
+            onChange={(e) => handleInputChange(e.target.value, e.nativeEvent.isComposing)}
+            onFocus={() => markAiComposerActivity()}
+            onCompositionStart={() => setAiComposerComposing(true)}
+            onCompositionUpdate={() => markAiComposerActivity()}
+            onCompositionEnd={(e) => {
+              setAiComposerComposing(false);
+              handleInputChange(e.currentTarget.value);
+            }}
+            onBlur={() => commitComposerText(readComposerText())}
             onKeyDown={handleTextareaKeyDown}
             placeholder={placeholder || (isStreaming && canSteer ? t('ai.codex.steer.placeholder') : defaultPlaceholder)}
             disabled={composerDisabled}
             className={[
+              'field-sizing-fixed',
               selectedUserSkills.length > 0 ? 'pt-1.5' : undefined,
               composerHeight != null ? 'min-h-0 max-h-none flex-1' : undefined,
             ].filter(Boolean).join(' ')}
@@ -1420,30 +1585,19 @@ const ChatInput: React.FC<ChatInputProps> = ({
           <div className="flex-1 min-w-0" />
 
           <div className="flex items-center gap-1">
-            {isStreaming && canSteer ? (
-              <>
-                <Tooltip>
-                  <TooltipTrigger asChild>
-                    <button
-                      type="submit"
-                      disabled={(!value.trim() && !hasTerminalSelectionAttachment) || composerDisabled}
-                      aria-label={isSteering ? t('ai.codex.steer.sending') : t('ai.codex.steer.addInstruction')}
-                      className="inline-flex h-8 w-8 items-center justify-center rounded-full border border-foreground/20 bg-foreground text-background shadow-sm transition-colors hover:bg-foreground/90 disabled:border-border/80 disabled:bg-muted/52 disabled:text-foreground/72"
-                    >
-                      {isSteering ? <Loader2 size={14} className="animate-spin" /> : <ArrowUp size={14} />}
-                    </button>
-                  </TooltipTrigger>
-                  <TooltipContent>{isSteering ? t('ai.codex.steer.sending') : t('ai.codex.steer.addInstruction')}</TooltipContent>
-                </Tooltip>
-                <PromptInputSubmit status="streaming" onStop={onStop} />
-              </>
-            ) : (
-              <PromptInputSubmit
-                status={status}
-                onStop={onStop}
-                disabled={(!value.trim() && !hasTerminalSelectionAttachment) || disabled}
-              />
-            )}
+            <ComposerSendUi
+              hasTextStore={hasTextStore}
+              hasTerminalSelectionAttachment={hasTerminalSelectionAttachment}
+              composerDisabled={composerDisabled}
+              disabled={disabled}
+              isStreaming={isStreaming}
+              canSteer={canSteer}
+              isSteering={isSteering}
+              status={status}
+              onStop={onStop}
+              steerSendingLabel={t('ai.codex.steer.sending')}
+              steerLabel={t('ai.codex.steer.addInstruction')}
+            />
           </div>
         </PromptInputFooter>
       </PromptInput>
@@ -1452,4 +1606,56 @@ const ChatInput: React.FC<ChatInputProps> = ({
   );
 };
 
-export default React.memo(ChatInput);
+function contextUsageEqual(
+  prev: AgentContextUsage | null | undefined,
+  next: AgentContextUsage | null | undefined,
+): boolean {
+  if (prev === next) return true;
+  if (!prev || !next) return false;
+  return (
+    prev.sessionId === next.sessionId
+    && prev.inputTokens === next.inputTokens
+    && prev.contextWindow === next.contextWindow
+    && prev.estimated === next.estimated
+  );
+}
+
+function chatInputPropsAreEqual(prev: ChatInputProps, next: ChatInputProps): boolean {
+  return (
+    prev.value === next.value
+    && prev.onChange === next.onChange
+    && prev.onSend === next.onSend
+    && prev.onCompact === next.onCompact
+    && prev.canCompact === next.canCompact
+    && contextUsageEqual(prev.contextUsage, next.contextUsage)
+    && prev.onSteer === next.onSteer
+    && prev.onStop === next.onStop
+    && prev.isStreaming === next.isStreaming
+    && prev.canSteer === next.canSteer
+    && prev.isSteering === next.isSteering
+    && prev.lockTurnConfiguration === next.lockTurnConfiguration
+    && prev.disabled === next.disabled
+    && prev.providerName === next.providerName
+    && prev.modelName === next.modelName
+    && prev.agentName === next.agentName
+    && prev.placeholder === next.placeholder
+    && prev.modelPresets === next.modelPresets
+    && prev.selectedModelId === next.selectedModelId
+    && prev.onModelSelect === next.onModelSelect
+    && prev.files === next.files
+    && prev.onAddFiles === next.onAddFiles
+    && prev.onRemoveFile === next.onRemoveFile
+    && prev.hosts === next.hosts
+    && prev.selectedUserSkills === next.selectedUserSkills
+    && prev.userSkills === next.userSkills
+    && prev.quickMessages === next.quickMessages
+    && prev.onAddUserSkill === next.onAddUserSkill
+    && prev.onRemoveUserSkill === next.onRemoveUserSkill
+    && prev.permissionMode === next.permissionMode
+    && prev.onPermissionModeChange === next.onPermissionModeChange
+    && prev.providerSwitcher === next.providerSwitcher
+    && prev.parked === next.parked
+  );
+}
+
+export default React.memo(ChatInput, chatInputPropsAreEqual);

components/ai/ChatMessageList.tsx

@@ -18,6 +18,12 @@ import {
 } from '../ai-elements/conversation';
 import { LazyMessageResponse } from '../ai-elements/LazyMessageResponse';
 import { Message, MessageContent } from '../ai-elements/messageShell';
+import {
+  AI_MARKDOWN_WARMUP_INITIAL_DELAY_MS,
+  AI_MARKDOWN_WARMUP_RESUME_DELAY_MS,
+  isAiComposerTyping,
+  scheduleAiMarkdownWarmup,
+} from './aiMarkdownWarmup';
 import { ToolCall } from '../ai-elements/tool-call';
 import ThinkingBlock from './ThinkingBlock';
 import AgentActivityGroup from './AgentActivityGroup';
@@ -371,6 +377,23 @@ const ChatMessageList: React.FC<ChatMessageListProps> = ({
     setPendingJumpMessageId(null);
   }, [activeSessionId]);
 
+  const hasAssistantMarkdown = useMemo(
+    () => messages.some((message) => message.role === 'assistant' && Boolean(message.content)),
+    [messages],
+  );
+
+  // Do not start Streamdown on expand. Import cannot be cancelled, and idle
+  // right after open collides with the first few keystrokes. History stays
+  // plaintext until send, composer blur, or a long unfocused delay.
+  useEffect(() => {
+    if (!hasAssistantMarkdown) return undefined;
+    return scheduleAiMarkdownWarmup({
+      isBusy: isAiComposerTyping,
+      initialDelayMs: AI_MARKDOWN_WARMUP_INITIAL_DELAY_MS,
+      resumeDelayMs: AI_MARKDOWN_WARMUP_RESUME_DELAY_MS,
+    });
+  }, [hasAssistantMarkdown]);
+
   const visibleMessages = useMemo(
     () => messages.filter((message) => message.role !== 'system'),
     [messages],
@@ -714,7 +737,7 @@ const ChatMessageList: React.FC<ChatMessageListProps> = ({
                       : (
                           <React.Profiler {...getAIPanelProfilerProps('AIChatPanel.Markdown')}>
                             <div data-ai-content="markdown">
-                              <LazyMessageResponse isAnimating={!!isThisStreaming}>
+                              <LazyMessageResponse deferUntilWarm isAnimating={!!isThisStreaming}>
                                 {message.content}
                               </LazyMessageResponse>
                             </div>

components/ai/aiMarkdownWarmup.test.ts

@@ -0,0 +1,87 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { readFileSync } from 'node:fs';
+
+import {
+  AI_COMPOSER_IDLE_MS,
+  AI_MARKDOWN_WARMUP_INITIAL_DELAY_MS,
+  AI_MARKDOWN_WARMUP_RESUME_DELAY_MS,
+  isAiComposerBusy,
+  isAiComposerTarget,
+  markAiComposerActivity,
+  resolveAiMarkdownWarmupDelay,
+  shouldDeferAiMarkdownWarmup,
+} from './aiMarkdownWarmup';
+
+test('defers markdown warmup while the composer is focused, composing, or recently active', () => {
+  assert.equal(shouldDeferAiMarkdownWarmup({}), false);
+  assert.equal(shouldDeferAiMarkdownWarmup({ composerFocused: true }), true);
+  assert.equal(shouldDeferAiMarkdownWarmup({ isComposing: true }), true);
+  assert.equal(shouldDeferAiMarkdownWarmup({ recentlyActive: true }), true);
+});
+
+test('recent composer activity counts as busy', () => {
+  markAiComposerActivity();
+  assert.equal(isAiComposerBusy(), true);
+  assert.ok(AI_COMPOSER_IDLE_MS >= 2000);
+});
+
+test('recognizes the chat composer as a busy warmup target', () => {
+  const body = { closest: (sel: string) => (sel.includes('ai-chat-input-body') ? {} : null) };
+  assert.equal(isAiComposerTarget(body as unknown as EventTarget), true);
+  assert.equal(isAiComposerTarget(null), false);
+});
+
+test('composer-idle IPC waits the same expand grace as history markdown', () => {
+  const warmup = readFileSync(new URL('./aiMarkdownWarmup.ts', import.meta.url), 'utf8');
+  assert.match(warmup, /initialDelayMs:\s*options\?\.initialDelayMs \?\? AI_MARKDOWN_WARMUP_INITIAL_DELAY_MS/);
+  assert.match(warmup, /isBusy: isAiComposerBusy/);
+  assert.match(warmup, /markAiComposerActivity\(\);\n\s*arm\(\);/);
+  assert.match(warmup, /if \(isAiComposerTyping\(\)\) \{\s*hydrateScheduled = true;/s);
+});
+
+test('history markdown waits after expand, then resumes quickly after blur', () => {
+  assert.equal(AI_MARKDOWN_WARMUP_INITIAL_DELAY_MS, 4000);
+  assert.equal(AI_MARKDOWN_WARMUP_RESUME_DELAY_MS, 600);
+  assert.equal(resolveAiMarkdownWarmupDelay({
+    hasArmed: false,
+    initialDelayMs: AI_MARKDOWN_WARMUP_INITIAL_DELAY_MS,
+    resumeDelayMs: AI_MARKDOWN_WARMUP_RESUME_DELAY_MS,
+  }), 4000);
+  assert.equal(resolveAiMarkdownWarmupDelay({
+    hasArmed: true,
+    initialDelayMs: AI_MARKDOWN_WARMUP_INITIAL_DELAY_MS,
+    resumeDelayMs: AI_MARKDOWN_WARMUP_RESUME_DELAY_MS,
+  }), 600);
+});
+
+test('AI panel no longer starts Streamdown just because it became visible', () => {
+  const panel = readFileSync(new URL('../AIChatSidePanel.tsx', import.meta.url), 'utf8');
+  assert.doesNotMatch(panel, /scheduleAiMarkdownWarmup/);
+  assert.match(panel, /warmAiMarkdownRenderer/);
+  assert.doesNotMatch(panel, /timeout:\s*2500/);
+  assert.doesNotMatch(panel, /import\('\.\/ai-elements\/messageResponse'\)/);
+  assert.doesNotMatch(panel, /@streamdown\/code/);
+});
+
+test('chat history defers Streamdown until warmup is already done', () => {
+  const list = readFileSync(new URL('./ChatMessageList.tsx', import.meta.url), 'utf8');
+  assert.match(list, /deferUntilWarm/);
+  assert.match(list, /scheduleAiMarkdownWarmup/);
+  assert.match(list, /isAiComposerTyping/);
+  assert.match(list, /AI_MARKDOWN_WARMUP_INITIAL_DELAY_MS/);
+  assert.match(list, /AI_MARKDOWN_WARMUP_RESUME_DELAY_MS/);
+});
+
+test('composer focus alone does not count as typing', () => {
+  assert.equal(shouldDeferAiMarkdownWarmup({ composerFocused: true }), true);
+  assert.equal(shouldDeferAiMarkdownWarmup({ composerFocused: true, isComposing: false, recentlyActive: false }), true);
+  assert.equal(shouldDeferAiMarkdownWarmup({ isComposing: false, recentlyActive: false }), false);
+});
+
+test('LazyMessageResponse keeps plaintext while chat asks to defer', () => {
+  const source = readFileSync(new URL('../ai-elements/LazyMessageResponse.tsx', import.meta.url), 'utf8');
+  assert.match(source, /deferUntilWarm/);
+  assert.match(source, /enqueueChatMarkdownHydrate/);
+  assert.match(source, /isAiMarkdownRendererReady/);
+});

components/ai/aiMarkdownWarmup.ts

@@ -0,0 +1,274 @@
+const AI_COMPOSER_FOCUS_SELECTOR =
+  '[data-section="ai-chat-input-body"], [data-section="ai-chat-panel"] textarea';
+
+/** Wait after expand before history markdown can start — covers the type-a-few-chars window. */
+export const AI_MARKDOWN_WARMUP_INITIAL_DELAY_MS = 4000;
+/** After the composer blurs, a short pause is enough to know typing stopped. */
+export const AI_MARKDOWN_WARMUP_RESUME_DELAY_MS = 600;
+/** Treat recent keystrokes as busy even if focus already moved. */
+export const AI_COMPOSER_IDLE_MS = 2000;
+let composerComposing = false;
+const CHAT_MARKDOWN_HYDRATE_BATCH = 2;
+
+let markdownWarmupPromise: Promise<unknown> | null = null;
+let markdownWarmupResolved = false;
+let lastComposerActivityAt = 0;
+const readyListeners = new Set<() => void>();
+const hydrateQueue: Array<() => void> = [];
+let hydrateScheduled = false;
+
+function notifyAiMarkdownRendererReady(): void {
+  markdownWarmupResolved = true;
+  for (const listener of readyListeners) listener();
+  readyListeners.clear();
+  pumpChatMarkdownHydrate();
+}
+
+export function isAiComposerTarget(target: EventTarget | null): boolean {
+  if (!target || typeof (target as Element).closest !== 'function') return false;
+  return Boolean((target as Element).closest(AI_COMPOSER_FOCUS_SELECTOR));
+}
+
+export function markAiComposerActivity(): void {
+  lastComposerActivityAt = Date.now();
+}
+
+export function setAiComposerComposing(next: boolean): void {
+  composerComposing = next;
+  if (next) markAiComposerActivity();
+}
+
+export function isAiComposerRecentlyActive(now = Date.now()): boolean {
+  return lastComposerActivityAt > 0 && now - lastComposerActivityAt < AI_COMPOSER_IDLE_MS;
+}
+
+export function shouldDeferAiMarkdownWarmup(input: {
+  composerFocused?: boolean;
+  isComposing?: boolean;
+  recentlyActive?: boolean;
+}): boolean {
+  return Boolean(input.composerFocused || input.isComposing || input.recentlyActive);
+}
+
+export function isAiComposerTyping(): boolean {
+  return shouldDeferAiMarkdownWarmup({
+    isComposing: composerComposing,
+    recentlyActive: isAiComposerRecentlyActive(),
+  });
+}
+
+export function isAiComposerBusy(): boolean {
+  const active = typeof document === 'undefined' ? null : document.activeElement;
+  return shouldDeferAiMarkdownWarmup({
+    composerFocused: isAiComposerTarget(active),
+    isComposing: composerComposing,
+    recentlyActive: isAiComposerRecentlyActive(),
+  });
+}
+
+export function isAiMarkdownRendererReady(): boolean {
+  return markdownWarmupResolved;
+}
+
+export function subscribeAiMarkdownRendererReady(listener: () => void): () => void {
+  if (markdownWarmupResolved) {
+    listener();
+    return () => {};
+  }
+  readyListeners.add(listener);
+  return () => {
+    readyListeners.delete(listener);
+  };
+}
+
+export function resolveAiMarkdownWarmupDelay(input: {
+  hasArmed: boolean;
+  initialDelayMs: number;
+  resumeDelayMs: number;
+}): number {
+  return input.hasArmed ? input.resumeDelayMs : input.initialDelayMs;
+}
+
+/** Prefetch Streamdown off the first-keystroke path. Safe to call repeatedly. */
+export function warmAiMarkdownRenderer(): Promise<unknown> {
+  markdownWarmupPromise ??= import('../ai-elements/messageResponse').then((module) => {
+    notifyAiMarkdownRendererReady();
+    return module;
+  }, (error) => {
+    markdownWarmupPromise = null;
+    throw error;
+  });
+  return markdownWarmupPromise;
+}
+
+function pumpChatMarkdownHydrate(): void {
+  if (hydrateScheduled) return;
+  hydrateScheduled = true;
+  const run = () => {
+    hydrateScheduled = false;
+    if (hydrateQueue.length === 0) return;
+    if (!markdownWarmupResolved) return;
+    // Focused but idle is fine: Streamdown+CJK is light. Only pause while
+    // the user is actually typing so history does not stay raw forever.
+    if (isAiComposerTyping()) {
+      hydrateScheduled = true;
+      window.setTimeout(() => {
+        hydrateScheduled = false;
+        pumpChatMarkdownHydrate();
+      }, AI_COMPOSER_IDLE_MS);
+      return;
+    }
+    const batch = hydrateQueue.splice(0, CHAT_MARKDOWN_HYDRATE_BATCH);
+    for (const task of batch) task();
+    if (hydrateQueue.length > 0) {
+      pumpChatMarkdownHydrate();
+    }
+  };
+  if (typeof requestAnimationFrame === 'function') {
+    requestAnimationFrame(run);
+    return;
+  }
+  queueMicrotask(run);
+}
+
+/** Upgrade deferred chat rows a few at a time, never while the composer is busy. */
+export function enqueueChatMarkdownHydrate(onReady: () => void): () => void {
+  let cancelled = false;
+  const task = () => {
+    if (!cancelled) onReady();
+  };
+  hydrateQueue.push(task);
+  pumpChatMarkdownHydrate();
+  return () => {
+    cancelled = true;
+    const index = hydrateQueue.indexOf(task);
+    if (index >= 0) hydrateQueue.splice(index, 1);
+  };
+}
+
+/**
+ * Run `task` only when the composer is idle. Import/IPC cannot be cancelled
+ * once started, so this must not fire during expand → first type.
+ */
+export function scheduleWhenAiComposerIdle(
+  task: () => void,
+  options?: {
+    initialDelayMs?: number;
+    resumeDelayMs?: number;
+  },
+): () => void {
+  return scheduleAiMarkdownWarmup({
+    load: task,
+    isBusy: isAiComposerBusy,
+    initialDelayMs: options?.initialDelayMs ?? AI_MARKDOWN_WARMUP_INITIAL_DELAY_MS,
+    resumeDelayMs: options?.resumeDelayMs ?? AI_COMPOSER_IDLE_MS,
+  });
+}
+
+/**
+ * Load markdown only when the browser is idle and the composer is not focused.
+ * Import() cannot be cancelled, so this must not start during expand → first type.
+ */
+export function scheduleAiMarkdownWarmup(options?: {
+  isBusy?: () => boolean;
+  load?: () => void;
+  initialDelayMs?: number;
+  resumeDelayMs?: number;
+}): () => void {
+  const isBusy = options?.isBusy ?? isAiComposerBusy;
+  const load = options?.load ?? (() => {
+    void warmAiMarkdownRenderer();
+  });
+  const initialDelayMs = options?.initialDelayMs ?? 0;
+  const resumeDelayMs = options?.resumeDelayMs ?? 0;
+
+  let idleId: number | null = null;
+  let timeoutId: number | null = null;
+  let cancelled = false;
+  let hasArmed = false;
+
+  const clearTimers = () => {
+    if (idleId != null && typeof cancelIdleCallback === 'function') {
+      cancelIdleCallback(idleId);
+    }
+    idleId = null;
+    if (timeoutId != null) {
+      window.clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+
+  const tryLoad = () => {
+    idleId = null;
+    timeoutId = null;
+    if (cancelled) return;
+    if (isBusy()) {
+      timeoutId = window.setTimeout(armIdle, Math.max(resumeDelayMs, AI_COMPOSER_IDLE_MS));
+      return;
+    }
+    load();
+  };
+
+  const armIdle = () => {
+    if (cancelled) return;
+    if (typeof requestIdleCallback === 'function') {
+      idleId = requestIdleCallback(tryLoad);
+      return;
+    }
+    timeoutId = window.setTimeout(tryLoad, 2000);
+  };
+
+  const arm = () => {
+    if (cancelled) return;
+    clearTimers();
+    const delay = resolveAiMarkdownWarmupDelay({
+      hasArmed,
+      initialDelayMs,
+      resumeDelayMs,
+    });
+    hasArmed = true;
+    if (delay > 0) {
+      timeoutId = window.setTimeout(() => {
+        timeoutId = null;
+        armIdle();
+      }, delay);
+      return;
+    }
+    armIdle();
+  };
+
+  const onFocusIn = (event: FocusEvent) => {
+    if (isAiComposerTarget(event.target)) {
+      markAiComposerActivity();
+      arm();
+    }
+  };
+  const onFocusOut = (event: FocusEvent) => {
+    if (isAiComposerTarget(event.target)) arm();
+  };
+  const onComposerEvent = (event: Event) => {
+    if (!isAiComposerTarget(event.target)) return;
+    markAiComposerActivity();
+    arm();
+  };
+
+  if (typeof window !== 'undefined') {
+    window.addEventListener('focusin', onFocusIn);
+    window.addEventListener('focusout', onFocusOut);
+    window.addEventListener('keydown', onComposerEvent, true);
+    window.addEventListener('compositionstart', onComposerEvent, true);
+    window.addEventListener('compositionupdate', onComposerEvent, true);
+  }
+  arm();
+
+  return () => {
+    cancelled = true;
+    clearTimers();
+    if (typeof window === 'undefined') return;
+    window.removeEventListener('focusin', onFocusIn);
+    window.removeEventListener('focusout', onFocusOut);
+    window.removeEventListener('keydown', onComposerEvent, true);
+    window.removeEventListener('compositionstart', onComposerEvent, true);
+    window.removeEventListener('compositionupdate', onComposerEvent, true);
+  };
+}

components/portForwardingUtils.test.ts

@@ -3,6 +3,7 @@ import test from "node:test";
 
 import type { PortForwardingRule } from "../domain/models";
 import en from "../application/i18n/locales/en";
+import es from "../application/i18n/locales/es";
 import zhCN from "../application/i18n/locales/zh-CN";
 import ru from "../application/i18n/locales/ru";
 import { buildRuleSummary, stopRuntimeTunnelBeforeDelete } from "./port-forwarding/utils";
@@ -45,7 +46,7 @@ test("buildRuleSummary describes local, remote, and dynamic forwarding direction
 });
 
 test("bundled locales include port forwarding summary copy for every forwarding type", () => {
-  for (const [locale, messages] of Object.entries({ en, zhCN, ru })) {
+  for (const [locale, messages] of Object.entries({ en, es, zhCN, ru })) {
     for (const key of [
       "pf.rule.summary.local",
       "pf.rule.summary.remote",

components/settings/settings-ui.tsx

@@ -161,6 +161,16 @@ export const SettingsSection: React.FC<{
   </section>
 );
 
+/** Footer note under a SettingCard. Keep a gap so it does not kiss the card. */
+export const settingHintClassName = "mt-3 text-xs text-muted-foreground";
+
+export const SettingHint: React.FC<{
+  children: React.ReactNode;
+  className?: string;
+}> = ({ children, className }) => (
+  <p className={cn(settingHintClassName, className)}>{children}</p>
+);
+
 export const settingCardClassName = "rounded-lg border bg-card";
 
 interface SettingCardProps {

components/settings/settingsFocus.test.ts

@@ -2,6 +2,20 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import test from "node:test";
 
+test("system setting hints sit below their cards with a shared top gap", () => {
+  const uiSource = readFileSync(new URL("./settings-ui.tsx", import.meta.url), "utf8");
+  const systemSource = readFileSync(new URL("./tabs/SettingsSystemTab.tsx", import.meta.url), "utf8");
+
+  assert.match(uiSource, /export const settingHintClassName = "mt-3 text-xs text-muted-foreground"/);
+  assert.match(uiSource, /export const SettingHint/);
+  assert.match(systemSource, /SettingHint/);
+  assert.match(systemSource, /settings\.system\.crashLogs\.hint/);
+  assert.doesNotMatch(
+    systemSource,
+    /<p className="text-xs text-muted-foreground">\s*\{t\("settings\.system\.crashLogs\.hint"\)\}/,
+  );
+});
+
 test("settings search focus scrolls the content pane, not the window viewport", () => {
   const source = readFileSync(new URL("./settingsFocus.ts", import.meta.url), "utf8");
   const uiSource = readFileSync(new URL("./settings-ui.tsx", import.meta.url), "utf8");

components/settings/tabs/SettingsSystemTab.tsx

@@ -11,7 +11,7 @@ import { SessionLogFormat, keyEventToString } from "../../../domain/models";
 import type { HttpNetworkProxyMode, HttpNetworkProxySettings } from "../../../domain/httpNetworkProxy";
 import { Button } from "../../ui/button";
 import { Tooltip, TooltipContent, TooltipTrigger } from "../../ui/tooltip";
-import { Toggle, Select, SettingRow, SectionHeader, SettingCard, SettingsAnchor, SettingsTabContent } from "../settings-ui";
+import { Toggle, Select, SettingRow, SectionHeader, SettingCard, SettingHint, SettingsAnchor, SettingsTabContent } from "../settings-ui";
 import { cn } from "../../../lib/utils";
 
 interface CrashLogFile {
@@ -98,6 +98,8 @@ interface SettingsSystemTabProps {
   setRestorePreviousSession: (enabled: boolean) => void;
   restoreTerminalCwd: boolean;
   setRestoreTerminalCwd: (enabled: boolean) => void;
+  startupLanding: "vault" | "local-terminal";
+  setStartupLanding: (landing: "vault" | "local-terminal") => void;
   toggleWindowHotkey: string;
   setToggleWindowHotkey: (hotkey: string) => void;
   closeToTray: boolean;
@@ -139,6 +141,8 @@ const SettingsSystemTab: React.FC<SettingsSystemTabProps> = ({
   setRestorePreviousSession,
   restoreTerminalCwd,
   setRestoreTerminalCwd,
+  startupLanding,
+  setStartupLanding,
   toggleWindowHotkey,
   setToggleWindowHotkey,
   closeToTray,
@@ -565,7 +569,7 @@ const SettingsSystemTab: React.FC<SettingsSystemTabProps> = ({
                 />
               </SettingRow>
             </SettingCard>
-            <p className="text-xs text-muted-foreground">
+            <SettingHint>
               {updateState.lastCheckedAt && (
                 <span>
                   {t('settings.update.lastCheckedPrefix')}
@@ -574,7 +578,7 @@ const SettingsSystemTab: React.FC<SettingsSystemTabProps> = ({
                 </span>
               )}
               {t('settings.update.hint')}
-            </p>
+            </SettingHint>
 
           <SectionHeader title={t("settings.system.networkProxy.title")} />
             <SettingCard className="space-y-4 py-4">
@@ -635,9 +639,9 @@ const SettingsSystemTab: React.FC<SettingsSystemTabProps> = ({
                 </>
               )}
             </SettingCard>
-            <p className="text-xs text-muted-foreground">
+            <SettingHint>
               {t("settings.system.networkProxy.hint")}
-            </p>
+            </SettingHint>
 
           <SectionHeader title={t("settings.system.credentials.title")} />
             <SettingsAnchor anchorId="system-credentials">
@@ -828,9 +832,9 @@ const SettingsSystemTab: React.FC<SettingsSystemTabProps> = ({
               )}
             </SettingCard>
 
-            <p className="text-xs text-muted-foreground">
+            <SettingHint>
               {t("settings.system.crashLogs.hint")}
-            </p>
+            </SettingHint>
             </SettingsAnchor>
 
           <SectionHeader title={t("settings.system.tempDirectory")} />
@@ -911,13 +915,31 @@ const SettingsSystemTab: React.FC<SettingsSystemTabProps> = ({
               )}
             </SettingCard>
 
-            <p className="text-xs text-muted-foreground">
+            <SettingHint>
               {t("settings.system.tempDirectoryHint")}
-            </p>
+            </SettingHint>
             </SettingsAnchor>
 
           <SectionHeader title={t("settings.sessionRestore.title")} />
             <SettingCard className="space-y-4 py-4">
+              <SettingRow
+                anchorId="system-startup-landing"
+                label={t("settings.sessionRestore.startupLanding")}
+                description={t("settings.sessionRestore.startupLandingDesc")}
+              >
+                <Select
+                  value={startupLanding}
+                  onChange={(value) => {
+                    if (value === "vault" || value === "local-terminal") {
+                      setStartupLanding(value);
+                    }
+                  }}
+                  options={[
+                    { value: "vault", label: t("settings.sessionRestore.startupLanding.vault") },
+                    { value: "local-terminal", label: t("settings.sessionRestore.startupLanding.localTerminal") },
+                  ]}
+                />
+              </SettingRow>
               <SettingRow
                 anchorId="system-session-restore"
                 label={t("settings.sessionRestore.restorePreviousSession")}
@@ -1046,9 +1068,9 @@ const SettingsSystemTab: React.FC<SettingsSystemTabProps> = ({
               </div>
             </SettingCard>
 
-            <p className="text-xs text-muted-foreground">
+            <SettingHint>
               {t("settings.sessionLogs.hint")}
-            </p>
+            </SettingHint>
 
           <SectionHeader title={t('settings.sshDeepLink.title')} />
             <SettingCard>
@@ -1161,9 +1183,9 @@ const SettingsSystemTab: React.FC<SettingsSystemTabProps> = ({
               </div>
             </SettingCard>
 
-            <p className="text-xs text-muted-foreground">
+            <SettingHint>
               {t("settings.sshDebugLogs.hint")}
-            </p>
+            </SettingHint>
 
           <SectionHeader title={t("settings.globalHotkey.title")} />
             <SettingCard className="space-y-4 py-4">
@@ -1236,9 +1258,9 @@ const SettingsSystemTab: React.FC<SettingsSystemTabProps> = ({
               </SettingRow>
             </SettingCard>
 
-            <p className="text-xs text-muted-foreground">
+            <SettingHint>
               {t("settings.globalHotkey.hint")}
-            </p>
+            </SettingHint>
     </SettingsTabContent>
   );
 };

components/systemManager/SystemManagerSidePanel.test.tsx

@@ -64,6 +64,16 @@ test("overview tab reuses the shared server stats source", () => {
   assert.doesNotMatch(source, /backend\.getServerStats/);
 });
 
+test("overview network interfaces show cumulative RX/TX totals alongside rates", () => {
+  const source = readFileSync(new URL("./SystemOverviewTab.tsx", import.meta.url), "utf8");
+
+  assert.match(source, /stats\.netInterfaces\.slice\(0, 5\)\.map/);
+  assert.match(source, /formatBytes\(iface\.rxBytes\)/);
+  assert.match(source, /formatBytes\(iface\.txBytes\)/);
+  assert.match(source, /formatThroughput\(iface\.rxSpeed\)/);
+  assert.match(source, /formatThroughput\(iface\.txSpeed\)/);
+});
+
 test("overview tab stays mounted and only pauses polling while another system tab is active", () => {
   const source = readFileSync(new URL("./SystemManagerSidePanel.tsx", import.meta.url), "utf8");
 

components/systemManager/SystemOverviewTab.tsx

@@ -53,6 +53,7 @@ function formatPercent(value: number | null | undefined, digits = 0): string {
 function formatBytes(bytes: number): string {
   const value = Number(bytes);
   if (!Number.isFinite(value) || value <= 0) return '0 B';
+  if (value >= 1024 ** 4) return `${(value / 1024 ** 4).toFixed(1)} TB`;
   if (value >= 1024 ** 3) return `${(value / 1024 ** 3).toFixed(1)} GB`;
   if (value >= 1024 ** 2) return `${(value / 1024 ** 2).toFixed(1)} MB`;
   if (value >= 1024) return `${(value / 1024).toFixed(1)} KB`;
@@ -396,11 +397,16 @@ export const SystemOverviewTab = memo(function SystemOverviewTab({
             {stats.netInterfaces.length > 0 ? (
               <div className="space-y-2">
                 {stats.netInterfaces.slice(0, 5).map((iface) => (
-                  <div key={iface.name} className="grid grid-cols-[1fr_auto] items-center gap-2 text-[11px]">
-                    <span className="min-w-0 truncate text-foreground">{iface.name}</span>
-                    <span className="shrink-0 tabular-nums text-muted-foreground">
+                  <div key={iface.name} className="space-y-0.5">
+                    <div className="grid grid-cols-[1fr_auto] items-center gap-2 text-[11px]">
+                      <span className="min-w-0 truncate text-foreground">{iface.name}</span>
+                      <span className="shrink-0 tabular-nums text-muted-foreground">
+                        {t('systemManager.overview.rx')} {formatBytes(iface.rxBytes)} · {t('systemManager.overview.tx')} {formatBytes(iface.txBytes)}
+                      </span>
+                    </div>
+                    <div className="text-right text-[10px] tabular-nums text-muted-foreground/80">
                       {t('systemManager.overview.rx')} {formatThroughput(iface.rxSpeed)} · {t('systemManager.overview.tx')} {formatThroughput(iface.txSpeed)}
-                    </span>
+                    </div>
                   </div>
                 ))}
               </div>

components/terminal/TerminalContextMenu.test.ts

@@ -3,6 +3,7 @@ import assert from "node:assert/strict";
 
 import en from "../../application/i18n/locales/en.ts";
 import ru from "../../application/i18n/locales/ru.ts";
+import es from "../../application/i18n/locales/es.ts";
 import zhCN from "../../application/i18n/locales/zh-CN.ts";
 import { markMiddleClickContextMenuEvent } from "./runtime/middleClickBehavior.ts";
 import * as terminalContextMenu from "./TerminalContextMenu.tsx";
@@ -112,7 +113,7 @@ test("shows upload clipboard image context menu action when a handler exists", (
 });
 
 test("localizes the upload clipboard image context menu label", () => {
-  const locales = { en, ru, "zh-CN": zhCN };
+  const locales = { en, ru, es, "zh-CN": zhCN };
   const keys = [
     "terminal.menu.uploadClipboardImage",
     "terminal.clipboardImageUpload.noImage",

components/terminal/connectionProgress.test.ts

@@ -0,0 +1,51 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import test from "node:test";
+
+import {
+  CONNECTION_PROGRESS_CAP,
+  CONNECTION_PROGRESS_START,
+  advanceIndeterminateConnectionProgress,
+  advanceMonotonicConnectionProgress,
+  resolveHopConnectionProgress,
+} from "./connectionProgress";
+
+test("indeterminate connection progress only moves forward toward the cap", () => {
+  assert.equal(advanceIndeterminateConnectionProgress(CONNECTION_PROGRESS_CAP), CONNECTION_PROGRESS_CAP);
+  assert.equal(advanceIndeterminateConnectionProgress(94), CONNECTION_PROGRESS_CAP);
+  const first = advanceIndeterminateConnectionProgress(CONNECTION_PROGRESS_START);
+  assert.ok(first > CONNECTION_PROGRESS_START);
+  assert.ok(first < CONNECTION_PROGRESS_CAP);
+  const second = advanceIndeterminateConnectionProgress(first);
+  assert.ok(second > first);
+});
+
+test("hop connection progress stays within the visual cap", () => {
+  assert.equal(resolveHopConnectionProgress(1, 1), 90);
+  assert.equal(resolveHopConnectionProgress(1, 2), 50);
+  assert.equal(resolveHopConnectionProgress(2, 2), 90);
+  assert.equal(resolveHopConnectionProgress(0, 1), 10);
+});
+
+test("connection progress updates never rewind", () => {
+  assert.equal(advanceMonotonicConnectionProgress(40, 10), 40);
+  assert.equal(advanceMonotonicConnectionProgress(40, 90), 90);
+  assert.equal(advanceMonotonicConnectionProgress(5, 5), 5);
+});
+
+test("connecting seeds progress once and hop/phase changes do not snap it back", () => {
+  const effectsSource = readFileSync(new URL("./useTerminalEffects.ts", import.meta.url), "utf8");
+  assert.match(
+    effectsSource,
+    /if \(status === "connecting"\) \{\s*setIsDisconnectedDialogDismissed\(false\);\s*setProgressValue\(CONNECTION_PROGRESS_START\);/,
+  );
+  assert.match(effectsSource, /setProgressValue\(advanceIndeterminateConnectionProgress\)/);
+  assert.doesNotMatch(effectsSource, /setProgressValue\(5\)/);
+
+  const starterSource = readFileSync(
+    new URL("./runtime/createTerminalSessionStarters.ts", import.meta.url),
+    "utf8",
+  );
+  assert.match(starterSource, /advanceMonotonicConnectionProgress/);
+  assert.match(starterSource, /resolveHopConnectionProgress/);
+});

components/terminal/connectionProgress.ts

@@ -0,0 +1,18 @@
+export const CONNECTION_PROGRESS_START = 5;
+export const CONNECTION_PROGRESS_CAP = 95;
+
+export const advanceIndeterminateConnectionProgress = (prev: number): number => {
+  if (prev >= CONNECTION_PROGRESS_CAP) return prev;
+  const remaining = CONNECTION_PROGRESS_CAP - prev;
+  const increment = Math.max(1, remaining * 0.15);
+  return Math.min(CONNECTION_PROGRESS_CAP, prev + increment);
+};
+
+export const resolveHopConnectionProgress = (hop: number, total: number): number => {
+  const safeTotal = Math.max(1, total);
+  const safeHop = Math.max(0, hop);
+  return Math.min(CONNECTION_PROGRESS_CAP, (safeHop / safeTotal) * 80 + 10);
+};
+
+export const advanceMonotonicConnectionProgress = (prev: number, next: number): number =>
+  Math.max(prev, next);

components/terminal/hooks/useTerminalSearch.ts

@@ -1,12 +1,22 @@
 import type { SearchAddon } from "@xterm/addon-search";
 import type { Terminal as XTerm } from "@xterm/xterm";
-import { useCallback, useRef, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 import type { RefObject } from "react";
 import { useStoredBoolean } from "../../../application/state/useStoredBoolean";
 import { STORAGE_KEY_TERMINAL_SEARCH_OPEN } from "../../../infrastructure/config/storageKeys";
 
 type SearchMatchCount = { current: number; total: number } | null;
 
+type SearchAddonResetTarget = Pick<SearchAddon, "findNext" | "clearDecorations"> | null;
+type TerminalSearchVisualElement = {
+  querySelectorAll: (selector: string) => ArrayLike<{ remove: () => void }>;
+};
+type TerminalSearchResetTarget = Pick<XTerm, "refresh" | "rows" | "clearSelection"> & {
+  element?: TerminalSearchVisualElement | null;
+  clearTextureAtlas?: () => void;
+} | null;
+type TerminalSearchGuardTarget = TerminalSearchResetTarget;
+
 const SEARCH_DECORATIONS = {
   matchBackground: "#FFFF0044",
   matchBorder: "#FFFF00",
@@ -16,6 +26,58 @@ const SEARCH_DECORATIONS = {
   activeMatchColorOverviewRuler: "#FF8800",
 } as const;
 
+const SEARCH_DECORATION_BACKGROUNDS = new Set<string>([
+  SEARCH_DECORATIONS.matchBackground.toLowerCase(),
+  SEARCH_DECORATIONS.activeMatchBackground.toLowerCase(),
+]);
+
+type StaleSearchDecoration = {
+  dispose: () => void;
+  options?: { backgroundColor?: string };
+  element?: {
+    classList?: { contains: (name: string) => boolean };
+    style?: { backgroundColor?: string };
+  };
+};
+
+type CellDecorationService = {
+  decorations?: Iterable<StaleSearchDecoration>;
+  forEachDecorationAtCell?: (
+    x: number,
+    y: number,
+    layer: "bottom" | "top" | undefined,
+    callback: (decoration: StaleSearchDecoration) => void,
+  ) => void;
+};
+
+type SearchAddonInternals = {
+  clearDecorations?: () => void;
+  clearActiveDecoration?: () => void;
+  _highlightTimeout?: { clear?: () => void };
+  _state?: { reset?: () => void };
+};
+
+type TerminalDecorationHost = {
+  _core?: { _decorationService?: CellDecorationService };
+  _decorationService?: CellDecorationService;
+};
+
+export const SEARCH_DECORATION_TRACKER_KEY = "__netcattySearchDecorationTracker";
+
+export type SearchDecorationTracker = {
+  disposeAll: () => number;
+  size: () => number;
+  markSearched: () => void;
+  hasSearched: () => boolean;
+  consumeSearched: () => boolean;
+  noteEmptyQueryReset: () => void;
+  consumeCloseSweep: () => boolean;
+};
+
+type TrackableTerminal = Pick<XTerm, "registerDecoration"> & {
+  [SEARCH_DECORATION_TRACKER_KEY]?: SearchDecorationTracker;
+};
+
 const SEARCH_OPTIONS = {
   regex: false,
   caseSensitive: false,
@@ -23,20 +85,266 @@ const SEARCH_OPTIONS = {
   decorations: SEARCH_DECORATIONS,
 } as const;
 
+/**
+ * SearchAddon schedules `_updateMatches` 200ms after writes/resizes and does
+ * not cancel that timer from `clearDecorations()`. A timeout that already
+ * captured the prior term can revive yellow match decorations after reset —
+ * re-clear once past that window (issue #2980).
+ */
+export const SEARCH_HIGHLIGHT_REVIVAL_GUARD_MS = 250;
+
+/**
+ * SearchAddon paints matches as HTML overlays (`.xterm-find-result-decoration`).
+ * Disposing the addon decoration does not always detach that node — after Esc
+ * closes the search bar and the terminal refits, the first two cells of the
+ * last hit can stay outlined on top of the buffer.
+ */
+export const SEARCH_DECORATION_NODE_SELECTOR =
+  ".xterm-find-result-decoration, .xterm-find-active-result-decoration";
+
+export const stripStaleSearchDecorationNodes = (
+  term?: { element?: TerminalSearchVisualElement | null } | null,
+): void => {
+  const nodes = term?.element?.querySelectorAll(SEARCH_DECORATION_NODE_SELECTOR);
+  if (!nodes) return;
+  for (let i = 0; i < nodes.length; i += 1) {
+    nodes[i]?.remove();
+  }
+};
+
+export const isSearchDecorationBackground = (color?: string): boolean => (
+  Boolean(color) && SEARCH_DECORATION_BACKGROUNDS.has(color.trim().toLowerCase())
+);
+
+export const installSearchDecorationTracker = (
+  term: TrackableTerminal,
+): SearchDecorationTracker => {
+  const existing = term[SEARCH_DECORATION_TRACKER_KEY];
+  if (existing) return existing;
+
+  const tracked = new Set<{ dispose: () => void }>();
+  let searched = false;
+  let pendingCloseSweep = false;
+  const originalRegister = term.registerDecoration.bind(term);
+  term.registerDecoration = (options) => {
+    // Keep search fill on the HTML overlay only. Passing backgroundColor into
+    // xterm lets WebGL bake the yellow into the glyph atlas, and those cells
+    // stay stained after Esc even when the decoration handle is gone.
+    const searchBackground = isSearchDecorationBackground(options.backgroundColor)
+      ? options.backgroundColor
+      : undefined;
+    const decoration = originalRegister(
+      searchBackground ? { ...options, backgroundColor: undefined } : options,
+    );
+    if (!decoration) return decoration;
+    if (!searchBackground) return decoration;
+    tracked.add(decoration);
+    decoration.onRender((element) => {
+      element.style.backgroundColor = searchBackground;
+    });
+    decoration.onDispose(() => {
+      tracked.delete(decoration);
+    });
+    return decoration;
+  };
+
+  const tracker: SearchDecorationTracker = {
+    disposeAll: () => {
+      const leftover = [...tracked];
+      tracked.clear();
+      for (const decoration of leftover) decoration.dispose();
+      return leftover.length;
+    },
+    size: () => tracked.size,
+    markSearched: () => {
+      searched = true;
+      pendingCloseSweep = true;
+    },
+    hasSearched: () => searched,
+    consumeSearched: () => {
+      const value = searched;
+      searched = false;
+      return value;
+    },
+    noteEmptyQueryReset: () => {
+      searched = false;
+    },
+    consumeCloseSweep: () => {
+      const value = pendingCloseSweep;
+      pendingCloseSweep = false;
+      return value;
+    },
+  };
+  term[SEARCH_DECORATION_TRACKER_KEY] = tracker;
+  return tracker;
+};
+
+export const getSearchDecorationTracker = (term?: unknown): SearchDecorationTracker | null => {
+  if (!term || typeof term !== "object") return null;
+  const tracker = (term as TrackableTerminal)[SEARCH_DECORATION_TRACKER_KEY];
+  return tracker && typeof tracker.disposeAll === "function" ? tracker : null;
+};
+
+const isStaleSearchDecoration = (decoration: StaleSearchDecoration): boolean => (
+  isSearchDecorationBackground(decoration.options?.backgroundColor)
+  || isSearchDecorationBackground(decoration.element?.style?.backgroundColor)
+  || decoration.element?.classList?.contains("xterm-find-result-decoration") === true
+  || decoration.element?.classList?.contains("xterm-find-active-result-decoration") === true
+);
+
+const readDecorationService = (term?: unknown): CellDecorationService | null => {
+  const host = term as TerminalDecorationHost & {
+    _core?: Record<string, unknown>;
+  } | null | undefined;
+  const direct = host?._core?._decorationService ?? host?._decorationService;
+  if (direct && (direct.decorations || direct.forEachDecorationAtCell)) {
+    return direct;
+  }
+  const core = host?._core;
+  if (!core || typeof core !== "object") return null;
+  for (const value of Object.values(core)) {
+    const candidate = value as CellDecorationService | undefined;
+    if (candidate && typeof candidate.forEachDecorationAtCell === "function") {
+      return candidate;
+    }
+  }
+  return null;
+};
+
+const readDecorationIterable = (
+  term?: unknown,
+): Iterable<StaleSearchDecoration> | null => (
+  readDecorationService(term)?.decorations ?? null
+);
+
+export const disposeSearchDecorationsInViewport = (term?: unknown): number => {
+  const service = readDecorationService(term);
+  const view = term as {
+    cols?: number;
+    rows?: number;
+    buffer?: { active?: { viewportY?: number } };
+  } | null | undefined;
+  if (!service?.forEachDecorationAtCell || !view?.cols || !view.rows) return 0;
+  const viewportY = view.buffer?.active?.viewportY ?? 0;
+  const stale = new Set<StaleSearchDecoration>();
+  for (let y = viewportY; y < viewportY + view.rows; y += 1) {
+    for (let x = 0; x < view.cols; x += 1) {
+      service.forEachDecorationAtCell(x, y, undefined, (decoration) => {
+        if (isStaleSearchDecoration(decoration)) stale.add(decoration);
+      });
+    }
+  }
+  for (const decoration of stale) decoration.dispose();
+  return stale.size;
+};
+
+/**
+ * WebGL paints decoration backgroundColor into the cell. SearchAddon can lose
+ * a couple of those handles on Esc+refit, so walk the terminal decoration
+ * service and dispose anything still using the search yellow/orange.
+ */
+export const disposeStaleSearchDecorations = (term?: unknown): number => {
+  if (term && typeof term === "object" && "registerDecoration" in term) {
+    installSearchDecorationTracker(term as TrackableTerminal);
+  }
+  const trackedCount = getSearchDecorationTracker(term)?.disposeAll() ?? 0;
+  const viewportCount = disposeSearchDecorationsInViewport(term);
+  const decorations = readDecorationIterable(term);
+  if (!decorations) return trackedCount + viewportCount;
+  const stale: StaleSearchDecoration[] = [];
+  for (const decoration of decorations) {
+    if (isStaleSearchDecoration(decoration)) stale.push(decoration);
+  }
+  for (const decoration of stale) decoration.dispose();
+  return trackedCount + viewportCount + stale.length;
+};
+
+/** Cancel SearchAddon's 200ms _updateMatches timer and drop cached term/options. */
+export const disarmSearchAddonRevival = (searchAddon?: unknown): void => {
+  const addon = searchAddon as SearchAddonInternals | null | undefined;
+  if (!addon) return;
+  addon._highlightTimeout?.clear?.();
+  addon._state?.reset?.();
+  addon.clearActiveDecoration?.();
+  addon.clearDecorations?.();
+};
+
+/**
+ * Delayed re-clear for addon decoration revival only. Do not clearSelection
+ * here: reset already cleared the search selection, and a user may have made
+ * a new manual selection during the guard window.
+ */
+export const clearTerminalSearchHighlights = (
+  searchAddon: Pick<SearchAddon, "clearDecorations"> | null,
+  term?: Pick<XTerm, "refresh" | "rows"> & {
+    element?: TerminalSearchVisualElement | null;
+    clearTextureAtlas?: () => void;
+  } | null,
+): void => {
+  disarmSearchAddonRevival(searchAddon);
+  disposeStaleSearchDecorations(term);
+  stripStaleSearchDecorationNodes(term);
+  if (term && term.rows > 0) {
+    term.refresh(0, term.rows - 1);
+  }
+};
+
+/**
+ * After the search bar unmounts the terminal grows and is force-fitted.
+ * Re-sweep leftover overlays and the addon selection that a resize can revive
+ * as a 2-cell sliver of the last match.
+ */
+export const settleTerminalSearchAfterLayout = (
+  searchAddon: Pick<SearchAddon, "clearDecorations"> | null,
+  term?: TerminalSearchResetTarget,
+  onRepaint?: () => void,
+): void => {
+  // Search-open state is shared across terminals. A sibling that never
+  // searched still sees the bar close and would otherwise lose a manual
+  // selection via clearSelection(). Emptying the query resets highlights
+  // while the bar stays open; keep the close-time repaint, but do not
+  // treat that stale search as a reason to wipe a later manual selection.
+  const tracker = getSearchDecorationTracker(term);
+  const shouldClearSelection = tracker ? tracker.consumeSearched() : true;
+  const shouldSweepLeftovers = tracker ? tracker.consumeCloseSweep() : true;
+  const shouldSweep = !tracker || shouldClearSelection || shouldSweepLeftovers;
+  if (!shouldSweep) return;
+  clearTerminalSearchHighlights(searchAddon, term);
+  if (shouldClearSelection) term?.clearSelection();
+  term?.clearTextureAtlas?.();
+  onRepaint?.();
+};
+
 export const resetTerminalSearch = (
-  searchAddon: Pick<SearchAddon, "findNext" | "clearDecorations"> | null,
+  searchAddon: SearchAddonResetTarget,
   searchTermRef: { current: string },
-  term?: Pick<XTerm, "refresh" | "rows"> | null,
+  term?: TerminalSearchResetTarget,
 ): void => {
   searchTermRef.current = "";
-  // The addon's empty-search path clears both its decorations and the terminal
-  // selection used for the active match. clearDecorations() alone leaves that
-  // selection visible.
-  searchAddon?.findNext("", SEARCH_OPTIONS);
-  // findNext("") assigns cachedSearchTerm back to "". Clear decorations again
-  // so the addon drops that cache to undefined and cannot revive match
-  // highlights via its delayed onResize/onWriteParsed update path.
+  // Drop decorations and cachedSearchTerm first so any not-yet-running addon
+  // `_updateMatches` timeout observes an empty cache and does not revive.
+  disarmSearchAddonRevival(searchAddon);
+  // clearDecorations() leaves the active-match selection; clear it explicitly.
+  term?.clearSelection();
+  // Empty find clears selection via the addon path. Do NOT pass SEARCH_OPTIONS:
+  // findNext always assigns lastSearchOptions, and decoration options would
+  // keep that latch armed for later write/resize updates.
+  try {
+    searchAddon?.findNext("");
+  } catch {
+    // Addon not activated yet.
+  }
+  // findNext("") assigns cachedSearchTerm back to "". Clear again so the cache
+  // is undefined rather than an empty string.
   searchAddon?.clearDecorations();
+  // SearchAddon can drop a couple of decoration handles on Esc+refit. Those
+  // leftover yellow cells are still in xterm's decoration service and WebGL
+  // keeps painting them until we dispose them directly.
+  disposeStaleSearchDecorations(term);
+  // Disposing search decorations does not always detach the overlay nodes
+  // (Esc close leaves the first two cells of the last hit). Sweep them
+  // before refresh so WebGL/DOM cannot keep the yellow outline.
+  stripStaleSearchDecorationNodes(term);
   // Disposing search decorations does not always repaint cells (observed on
   // Windows after clearing or closing search). Keyword highlighting already
   // forces a refresh after dispose; do the same here so yellow match
@@ -46,6 +354,85 @@ export const resetTerminalSearch = (
   }
 };
 
+/**
+ * Pointer listeners used to tell a user-created selection apart from the
+ * addon's delayed findPrevious re-select. Keyboard selections in this 250ms
+ * window are rare enough that treating them as addon revival is acceptable.
+ */
+export const subscribeTerminalUserSelection = (
+  term: Pick<XTerm, "element"> | null | undefined,
+  mark: () => void,
+): (() => void) => {
+  const el = term?.element;
+  if (!el) return () => {};
+  const onPointer = () => mark();
+  el.addEventListener("mousedown", onPointer);
+  el.addEventListener("touchstart", onPointer);
+  return () => {
+    el.removeEventListener("mousedown", onPointer);
+    el.removeEventListener("touchstart", onPointer);
+  };
+};
+
+export const armSearchHighlightRevivalGuard = ({
+  getSearchAddon,
+  getTerm,
+  subscribeUserSelection,
+  delayMs = SEARCH_HIGHLIGHT_REVIVAL_GUARD_MS,
+  setTimeoutFn = setTimeout,
+  clearTimeoutFn = clearTimeout,
+}: {
+  getSearchAddon: () => Pick<SearchAddon, "clearDecorations"> | null;
+  getTerm: () => TerminalSearchGuardTarget;
+  subscribeUserSelection?: (mark: () => void) => () => void;
+  delayMs?: number;
+  setTimeoutFn?: typeof setTimeout;
+  clearTimeoutFn?: typeof clearTimeout;
+}): { arm: () => void; dispose: () => void; markUserSelection: () => void } => {
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  let userTouchedSelection = false;
+  let unsubscribeUserSelection: (() => void) | null = null;
+
+  const markUserSelection = () => {
+    userTouchedSelection = true;
+  };
+
+  const dispose = () => {
+    if (timer !== null) {
+      clearTimeoutFn(timer);
+      timer = null;
+    }
+    unsubscribeUserSelection?.();
+    unsubscribeUserSelection = null;
+  };
+
+  const arm = () => {
+    dispose();
+    userTouchedSelection = false;
+    if (subscribeUserSelection) {
+      unsubscribeUserSelection = subscribeUserSelection(markUserSelection);
+    }
+    timer = setTimeoutFn(() => {
+      timer = null;
+      unsubscribeUserSelection?.();
+      unsubscribeUserSelection = null;
+      const term = getTerm();
+      clearTerminalSearchHighlights(getSearchAddon(), term);
+      // Addon findPrevious re-selects the prior active match. Clear that
+      // revived selection unless the user started a new one in this window.
+      if (!userTouchedSelection) {
+        term?.clearSelection();
+      }
+    }, delayMs);
+  };
+
+  return { arm, dispose, markUserSelection };
+};
+
+/** True when this terminal has a local query that shared search-close must clear. */
+export const shouldResetOnSharedSearchClose = (localSearchTerm: string): boolean =>
+  localSearchTerm !== "";
+
 export const useTerminalSearch = ({
   searchAddonRef,
   termRef,
@@ -64,6 +451,42 @@ export const useTerminalSearch = ({
   // never returns to the input. See issue #1789.
   const [searchFocusToken, setSearchFocusToken] = useState(0);
   const searchTermRef = useRef<string>("");
+  const revivalGuardRef = useRef<ReturnType<typeof armSearchHighlightRevivalGuard> | null>(null);
+
+  // Existing sessions (and Vite HMR) never go back through createXTermRuntime.
+  // Install on the live term so Esc can still find leaked decorations.
+  if (termRef.current) {
+    installSearchDecorationTracker(termRef.current);
+  }
+
+  if (revivalGuardRef.current === null) {
+    revivalGuardRef.current = armSearchHighlightRevivalGuard({
+      getSearchAddon: () => searchAddonRef.current,
+      getTerm: () => termRef.current,
+      subscribeUserSelection: (mark) => subscribeTerminalUserSelection(termRef.current, mark),
+    });
+  }
+
+  useEffect(() => () => {
+    revivalGuardRef.current?.dispose();
+  }, []);
+
+  const runReset = useCallback(() => {
+    resetTerminalSearch(searchAddonRef.current, searchTermRef, termRef.current);
+    revivalGuardRef.current?.arm();
+  }, [searchAddonRef, termRef]);
+
+  // Search open state is shared via localStorage across terminal sessions. When
+  // another session closes search, this session's bar unmounts without going
+  // through handleCloseSearch — clear leftover decorations only when this
+  // terminal actually searched (otherwise shared false would wipe unrelated
+  // manual selections in other splits).
+  useEffect(() => {
+    if (isSearchOpen) return;
+    setSearchMatchCount(null);
+    if (!shouldResetOnSharedSearchClose(searchTermRef.current)) return;
+    runReset();
+  }, [isSearchOpen, runReset]);
 
   // Invoked by the searchTerminal hotkey (Cmd/Ctrl+F). Always opens the bar
   // and bumps the focus token: when closed, setIsSearchOpen(true) mounts the
@@ -83,20 +506,29 @@ export const useTerminalSearch = ({
     setIsSearchOpen(next);
     if (!next) {
       setSearchMatchCount(null);
-      resetTerminalSearch(searchAddonRef.current, searchTermRef, termRef.current);
+      runReset();
     }
-  }, [isSearchOpen, searchAddonRef, setIsSearchOpen, termRef]);
+  }, [isSearchOpen, runReset, setIsSearchOpen]);
 
   const handleSearch = useCallback(
     (term: string): boolean => {
       const searchAddon = searchAddonRef.current;
       if (!searchAddon || !term) {
-        resetTerminalSearch(searchAddon, searchTermRef, termRef.current);
+        runReset();
+        if (termRef.current) installSearchDecorationTracker(termRef.current);
+        getSearchDecorationTracker(termRef.current)?.noteEmptyQueryReset();
         setSearchMatchCount(null);
         return false;
       }
 
       searchTermRef.current = term;
+      revivalGuardRef.current?.dispose();
+      // Incremental typing (ro -> root) can leave the previous term's
+      // decorations in xterm even after clearDecorations(). Drop our tracked
+      // leftovers before painting the new matches.
+      if (termRef.current) installSearchDecorationTracker(termRef.current);
+      getSearchDecorationTracker(termRef.current)?.markSearched();
+      disposeStaleSearchDecorations(termRef.current);
       searchAddon.clearDecorations();
 
       const found = searchAddon.findNext(term, SEARCH_OPTIONS);
@@ -109,7 +541,7 @@ export const useTerminalSearch = ({
 
       return found;
     },
-    [searchAddonRef, termRef],
+    [runReset, searchAddonRef, termRef],
   );
 
   const handleFindNext = useCallback((): boolean => {
@@ -129,9 +561,9 @@ export const useTerminalSearch = ({
   const handleCloseSearch = useCallback(() => {
     setIsSearchOpen(false);
     setSearchMatchCount(null);
-    resetTerminalSearch(searchAddonRef.current, searchTermRef, termRef.current);
+    runReset();
     termRef.current?.focus();
-  }, [searchAddonRef, setIsSearchOpen, termRef]);
+  }, [runReset, setIsSearchOpen, termRef]);
 
   return {
     isSearchOpen,

components/terminal/keywordHighlight.test.ts

@@ -492,6 +492,28 @@ test("wrapped matches stay on the same logical line", async () => {
   term.dispose();
 });
 
+test("quiet catch-up refreshes a tall viewport once", async () => {
+  const term = new XTerm({ allowProposedApi: true, cols: 80, rows: 40, scrollback: 80 });
+  let refreshCount = 0;
+  const originalRefresh = term.refresh.bind(term);
+  term.refresh = (start, end) => {
+    refreshCount += 1;
+    return originalRefresh(start, end);
+  };
+  const highlighter = new KeywordHighlighter(term);
+  highlighter.setRules(rule(), true);
+  const line = "2026-08-13 INFO worker=1 WARN ERROR failed from 10.2.0.1 payload=xxxxxxxx";
+  const flood = Array.from({ length: 60 }, () => line).join("\r\n");
+  noteTerminalOutputPressureData(term, flood);
+  await write(term, flood);
+  await new Promise((resolve) => setTimeout(resolve, 650));
+  await highlighter.whenSettled();
+  assert.equal(refreshCount, 1);
+  assert.deepEqual(uncoloredKeywordLines(term, "ERROR", RED), []);
+  highlighter.dispose();
+  term.dispose();
+});
+
 test("identical flood lines are all colored after quiet catch-up", async () => {
   const term = new XTerm({ allowProposedApi: true, cols: 80, rows: 12, scrollback: 40 });
   const highlighter = new KeywordHighlighter(term);

components/terminal/keywordHighlight.ts

@@ -590,10 +590,7 @@ export class KeywordHighlighter implements IDisposable {
           break;
         }
         const sliceEnd = Math.min(buffer.length - 1, nextY + RECOLOR_SLICE_LINES - 1);
-        const viewportStart = buffer.viewportY;
-        const viewportEnd = viewportStart + this.term.rows - 1;
-        const refresh = sliceEnd >= viewportStart && nextY <= viewportEnd;
-        this.recolorRange(nextY, sliceEnd, refresh, false);
+        this.recolorRange(nextY, sliceEnd, false, false);
         nextY = sliceEnd + 1;
         if (nextY >= buffer.length) {
           this.catchUpFrom = null;
@@ -616,6 +613,7 @@ export class KeywordHighlighter implements IDisposable {
         this.resolveCatchUp = null;
       } else if (this.resolveCatchUpY() === null) {
         this.catchUpCounted = false;
+        this.recolorVisible();
         this.resolveCatchUp?.();
         this.resolveCatchUp = null;
       } else if (pausedOnAlternate) {

components/terminal/runtime/createTerminalSessionStarters.ts

@@ -51,6 +51,10 @@ import {
   hasUsableProxyConfig,
   resolveProxyConfigAuth,
 } from "../../../domain/proxyProfiles";
+import {
+  advanceMonotonicConnectionProgress,
+  resolveHopConnectionProgress,
+} from "../connectionProgress";
 import { hasConnectionPassedTcpDial } from "../connectionTimeouts";
 import { resolveHostSshConnectionTimeouts } from "../../../domain/sshConnectionTimeouts";
 import { isPluginHostProtocol, sanitizePluginConnection } from "../../../domain/pluginConnection";
@@ -540,8 +544,8 @@ export const createTerminalSessionStarters = (ctx: TerminalSessionStartersContex
         }
 
         ctx.setProgressLogs((prev) => [...prev, logLine]);
-        const hopProgress = (hop / total) * 80 + 10;
-        ctx.setProgressValue(Math.min(95, hopProgress));
+        const hopProgress = resolveHopConnectionProgress(hop, total);
+        ctx.setProgressValue((prev) => advanceMonotonicConnectionProgress(prev, hopProgress));
       });
       if (unsub) unsubscribeChainProgress = unsub;
     }

components/terminal/runtime/createXTermRuntime.ts

@@ -14,6 +14,7 @@ import {
 } from "../../../application/state/useGlobalHotkeys";
 import { fontStore } from "../../../application/state/fontStore";
 import { KeywordHighlighter } from "../keywordHighlight";
+import { installSearchDecorationTracker } from "../hooks/useTerminalSearch";
 import { CursorLineHighlighter } from "./cursorLineHighlight";
 import { resolveCursorLineHighlightBackground } from "../../../domain/cursorLineHighlight";
 import {
@@ -91,8 +92,9 @@ import {
 } from "./middleClickBehavior";
 import { handleSerialLineModeInput } from "./serialLineInput";
 import {
+  doesKittyEncodingPreserveShiftEnter,
   getShiftEnterSubmittedInput,
-  resolveShiftEnterText,
+  resolveShiftEnterPayload,
   shouldSendShiftEnterText,
 } from "./shiftEnterText";
 import {
@@ -557,6 +559,7 @@ export const createXTermRuntime = (ctx: CreateXTermRuntimeContext): XTermRuntime
       scrollbarSliderActiveBackground: ctx.terminalTheme.colors.foreground + '80', // 50% opacity
     },
   });
+  installSearchDecorationTracker(term);
 
   type MaybeRenderer = {
     constructor?: { name?: string };
@@ -978,7 +981,11 @@ export const createXTermRuntime = (ctx: CreateXTermRuntimeContext): XTermRuntime
 
   const handleTerminalInputData = (
     data: string,
-    options?: { source?: "terminal" | "shift-enter" | "kitty" },
+    options?: {
+      source?: "terminal" | "shift-enter" | "kitty";
+      /** Skip string broadcast when peers will re-resolve from a key chord. */
+      skipBroadcast?: boolean;
+    },
   ) => {
     // Clipboard paste / typed password while assist is open must dismiss the
     // hint first. Otherwise Enter is still hijacked for confirmFill and can
@@ -1000,7 +1007,9 @@ export const createXTermRuntime = (ctx: CreateXTermRuntimeContext): XTermRuntime
     const broadcastDataBeforeSudo = mapTerminalBackspaceInput(data, ctx.host.backspaceBehavior);
     const suppressTerminalBroadcast = inputSource === "terminal" && suppressNextTerminalDataBroadcast;
     if (suppressTerminalBroadcast) suppressNextTerminalDataBroadcast = false;
-    const willBroadcastInput = !sensitive &&
+    // skipBroadcast only suppresses the raw-string fan-out. Peers still receive
+    // the Shift+Enter chord, so sudo autofill must treat this as a broadcast.
+    const canBroadcastInput = !sensitive &&
       inputSource !== "kitty" &&
       !handlingKittyBroadcast &&
       !suppressTerminalBroadcast &&
@@ -1008,6 +1017,7 @@ export const createXTermRuntime = (ctx: CreateXTermRuntimeContext): XTermRuntime
       isBroadcastEnabled: ctx.isBroadcastEnabledRef.current,
       hasBroadcastInputHandler: !!onBroadcastInput,
     });
+    const willBroadcastInput = canBroadcastInput && options?.skipBroadcast !== true;
     if (ctx.statusRef.current === "connected" && submittedInput) {
       if (submittedInput.text) {
         ctx.commandBufferRef.current += submittedInput.text;
@@ -1026,7 +1036,9 @@ export const createXTermRuntime = (ctx: CreateXTermRuntimeContext): XTermRuntime
         { sensitive, allowHostStyleGreaterThanPrompt: ctx.allowHostStyleGreaterThanPrompt },
       );
       handledSubmittedInput = true;
-      if (!willBroadcastInput) {
+      // Recipients of a key-chord broadcast must not arm password assistance.
+      // handlingKittyBroadcast already blocks re-fan-out via canBroadcastInput.
+      if (!canBroadcastInput && !handlingKittyBroadcast) {
         prepareSudoAutofillInput(
           submittedInput.lineEnding === "\r\n" ? "\n" : submittedInput.lineEnding,
           recordedCommand,
@@ -1035,7 +1047,8 @@ export const createXTermRuntime = (ctx: CreateXTermRuntimeContext): XTermRuntime
       }
     } else if (
       ctx.statusRef.current === "connected" &&
-      !willBroadcastInput &&
+      !canBroadcastInput &&
+      !handlingKittyBroadcast &&
       inputSource !== "shift-enter"
     ) {
       const pastedCommand = getSinglePastedCommand(data);
@@ -1720,6 +1733,54 @@ export const createXTermRuntime = (ctx: CreateXTermRuntimeContext): XTermRuntime
       return false;
     }
 
+    // Before Kitty encoding that collapses Shift+Enter to bare CR/LF (flags=0,
+    // or non-preserving sets like alternate-key / associated-text alone). Remap
+    // first so alternate-screen TUIs still receive CSI-u Shift+Enter.
+    if (
+      shouldSendShiftEnterText(e, ctx.terminalSettingsRef.current) &&
+      !doesKittyEncodingPreserveShiftEnter(kittySequenceForKeyDown)
+    ) {
+      const id = ctx.sessionRef.current;
+      if (id) {
+        e.preventDefault();
+        e.stopPropagation();
+        const kittyEvent = toKittyKeyboardEvent(e);
+        // Local payload uses this session's buffer. Broadcast targets re-resolve
+        // from the key chord via resolveKittyKeyboardBroadcastInput.
+        const shiftEnterPayload = resolveShiftEnterPayload(
+          ctx.terminalSettingsRef.current,
+          { alternateScreen: term.buffer.active.type === "alternate" },
+        );
+        if (shiftEnterPayload.data) {
+          if (shiftEnterPayload.kind === "key") {
+            // Local CSI-u as kitty-sourced input so raw bytes are not broadcast.
+            handleTerminalInputData(shiftEnterPayload.data, { source: "kitty" });
+          } else {
+            // Skip string broadcast: peers resolve Shift+Enter from their own
+            // buffer + keyboard mode via the key chord below.
+            handleTerminalInputData(shiftEnterPayload.data, {
+              source: "shift-enter",
+              skipBroadcast: true,
+            });
+          }
+          const forwarded = broadcastKittyInput({
+            kind: "key",
+            event: kittyEvent,
+            fallbackToLegacy: true,
+          });
+          if (forwarded) {
+            upsertKittyKeyboardForwardedPress(
+              broadcastForwardedKeys,
+              kittyKeyIdentity(e),
+              kittyEvent,
+              forwarded.targetSessionIds,
+            );
+          }
+        }
+        return false;
+      }
+    }
+
     if (kittySequenceForKeyDown) {
       e.preventDefault();
       e.stopPropagation();
@@ -1750,22 +1811,6 @@ export const createXTermRuntime = (ctx: CreateXTermRuntimeContext): XTermRuntime
       return false;
     }
 
-    if (
-      !isKittyKeyboardModeActive(kittyKeyboardMode) &&
-      shouldSendShiftEnterText(e, ctx.terminalSettingsRef.current)
-    ) {
-      const id = ctx.sessionRef.current;
-      if (id) {
-        e.preventDefault();
-        e.stopPropagation();
-        const textToSend = resolveShiftEnterText(ctx.terminalSettingsRef.current);
-        if (textToSend) {
-          handleTerminalInputData(textToSend, { source: "shift-enter" });
-        }
-        return false;
-      }
-    }
-
     // macOS Option+←/→ → Meta-b / Meta-f so the shell jumps by word (discussion
     // #826). After kitty mode so apps using the kitty protocol keep their own
     // arrow encoding; read live so the toggle applies without reconnecting.
@@ -1984,6 +2029,8 @@ export const createXTermRuntime = (ctx: CreateXTermRuntimeContext): XTermRuntime
       applicationCursorMode: term.modes.applicationCursorKeysMode,
       encodedKeys: broadcastEncodedKeys,
       legacySuppressedKeys: broadcastLegacySuppressedKeys,
+      alternateScreen: term.buffer.active.type === "alternate",
+      shiftEnterSettings: ctx.terminalSettingsRef.current,
     }),
     getSessionId: () => ctx.sessionRef.current,
     isSensitiveInput: () => ctx.passwordPromptActiveRef?.current === true,

components/terminal/runtime/kittyKeyboardBroadcast.test.ts

@@ -19,6 +19,7 @@ import {
   encodeKittyKeyEvent,
   setKittyKeyboardModeFlags,
 } from "./kittyKeyboardProtocol";
+import { SHIFT_ENTER_CSI_U_SEQUENCE } from "./shiftEnterText";
 
 test("routes normalized Kitty input to the target session only", () => {
   const received: KittyKeyboardBroadcastInput[] = [];
@@ -520,6 +521,59 @@ test("enhanced sources can fall back to reliable legacy data for plain targets",
   }
 });
 
+test("Shift+Enter broadcast remaps from each target buffer when Kitty collapses the chord", () => {
+  const alternateOnly = createKittyKeyboardModeState();
+  setKittyKeyboardModeFlags(alternateOnly, 0b00100);
+  const shiftEnter = {
+    kind: "key" as const,
+    fallbackToLegacy: true,
+    event: {
+      type: "keydown" as const,
+      key: "Enter",
+      code: "Enter",
+      shiftKey: true,
+    },
+  };
+
+  assert.deepEqual(resolveKittyKeyboardBroadcastInput(shiftEnter, {
+    kittyProtocolEnabled: true,
+    kittyMode: alternateOnly,
+    applicationCursorMode: false,
+    encodedKeys: new Set<string>(),
+    alternateScreen: true,
+  }), {
+    data: SHIFT_ENTER_CSI_U_SEQUENCE,
+    kittyEncoded: true,
+    urgentInterrupt: false,
+  });
+
+  assert.deepEqual(resolveKittyKeyboardBroadcastInput(shiftEnter, {
+    kittyProtocolEnabled: true,
+    kittyMode: createKittyKeyboardModeState(),
+    applicationCursorMode: false,
+    encodedKeys: new Set<string>(),
+    alternateScreen: false,
+  }), {
+    data: "\n",
+    kittyEncoded: false,
+    urgentInterrupt: false,
+  });
+
+  const disambiguate = createKittyKeyboardModeState();
+  setKittyKeyboardModeFlags(disambiguate, 0b00001);
+  assert.deepEqual(resolveKittyKeyboardBroadcastInput(shiftEnter, {
+    kittyProtocolEnabled: true,
+    kittyMode: disambiguate,
+    applicationCursorMode: false,
+    encodedKeys: new Set<string>(),
+    alternateScreen: true,
+  }), {
+    data: SHIFT_ENTER_CSI_U_SEQUENCE,
+    kittyEncoded: true,
+    urgentInterrupt: false,
+  });
+});
+
 test("plain Kitty targets preserve modified non-ASCII keys without a legacy fallback", () => {
   const plain = createKittyKeyboardModeState();
   assert.deepEqual(resolveKittyKeyboardBroadcastInput({

components/terminal/runtime/kittyKeyboardBroadcast.ts

@@ -6,6 +6,12 @@ import {
   type KittyKeyboardEvent,
   type KittyKeyboardModeState,
 } from "./kittyKeyboardProtocol";
+import type { TerminalSettings } from "../../../domain/models";
+import {
+  isBareShiftEnterLineEnding,
+  resolveShiftEnterPayload,
+  shouldSendShiftEnterText,
+} from "./shiftEnterText";
 
 export type KittyKeyboardBroadcastInput =
   | {
@@ -190,15 +196,46 @@ export const flushKittyKeyboardBroadcastReleases = (
   releases.clear();
 };
 
+type ResolveKittyKeyboardBroadcastOptions = {
+  kittyProtocolEnabled: boolean;
+  kittyMode: KittyKeyboardModeState;
+  applicationCursorMode: boolean;
+  encodedKeys: Set<string>;
+  legacySuppressedKeys?: Set<string>;
+  /** Target buffer: remap Shift+Enter per peer, not from the broadcast source. */
+  alternateScreen?: boolean;
+  shiftEnterSettings?: Pick<
+    TerminalSettings,
+    "shiftEnterNewlineEnabled" | "shiftEnterNewlineText"
+  >;
+};
+
+const resolveShiftEnterBroadcastPayload = (
+  input: Extract<KittyKeyboardBroadcastInput, { kind: "key" }>,
+  options: ResolveKittyKeyboardBroadcastOptions,
+  candidate: string | null,
+): ResolvedKittyKeyboardBroadcastInput | null => {
+  if (
+    !shouldSendShiftEnterText(input.event, options.shiftEnterSettings) ||
+    candidate === null ||
+    !isBareShiftEnterLineEnding(candidate)
+  ) {
+    return null;
+  }
+  const payload = resolveShiftEnterPayload(options.shiftEnterSettings, {
+    alternateScreen: options.alternateScreen === true,
+  });
+  if (!payload.data) return null;
+  return {
+    data: payload.data,
+    kittyEncoded: payload.kind === "key",
+    urgentInterrupt: false,
+  };
+};
+
 export const resolveKittyKeyboardBroadcastInput = (
   input: KittyKeyboardBroadcastInput,
-  options: {
-    kittyProtocolEnabled: boolean;
-    kittyMode: KittyKeyboardModeState;
-    applicationCursorMode: boolean;
-    encodedKeys: Set<string>;
-    legacySuppressedKeys?: Set<string>;
-  },
+  options: ResolveKittyKeyboardBroadcastOptions,
 ): ResolvedKittyKeyboardBroadcastInput | null => {
   if (input.kind === "text") {
     if (options.kittyProtocolEnabled && shouldEncodeKittyCompositionText(options.kittyMode)) {
@@ -237,6 +274,8 @@ export const resolveKittyKeyboardBroadcastInput = (
       options.encodedKeys.add(identity);
       legacySuppressedKeys.add(identity);
     }
+    const remapped = resolveShiftEnterBroadcastPayload(input, options, encoded);
+    if (remapped) return remapped;
     return { data: encoded, kittyEncoded: true, urgentInterrupt: false };
   }
   if (!input.fallbackToLegacy || input.event.type === "keyup") return null;
@@ -244,6 +283,8 @@ export const resolveKittyKeyboardBroadcastInput = (
   if (!legacy) return null;
   options.encodedKeys.add(identity);
   legacySuppressedKeys.add(identity);
+  const remapped = resolveShiftEnterBroadcastPayload(input, options, legacy);
+  if (remapped) return remapped;
   return {
     data: legacy,
     kittyEncoded: false,
@@ -252,13 +293,7 @@ export const resolveKittyKeyboardBroadcastInput = (
 };
 
 export const createKittyKeyboardBroadcastHandler = (options: {
-  resolveOptions: () => {
-    kittyProtocolEnabled: boolean;
-    kittyMode: KittyKeyboardModeState;
-    applicationCursorMode: boolean;
-    encodedKeys: Set<string>;
-    legacySuppressedKeys?: Set<string>;
-  };
+  resolveOptions: () => ResolveKittyKeyboardBroadcastOptions;
   getSessionId: () => string | null;
   isSensitiveInput?: () => boolean;
   isConnected: () => boolean;

components/terminal/runtime/shiftEnterText.test.ts

@@ -4,9 +4,13 @@ import { readFileSync } from "node:fs";
 
 import {
   decodeTerminalTextEscapes,
+  doesKittyEncodingPreserveShiftEnter,
   getShiftEnterSubmittedInput,
+  isBareShiftEnterLineEnding,
   isShiftEnterLineContinuationText,
+  resolveShiftEnterPayload,
   resolveShiftEnterText,
+  SHIFT_ENTER_CSI_U_SEQUENCE,
   shouldSendShiftEnterText,
 } from "./shiftEnterText";
 
@@ -79,6 +83,61 @@ test("shift enter handler respects the terminal setting toggle", () => {
   );
 });
 
+test("bare line-ending Shift+Enter text is detected for TUI passthrough", () => {
+  assert.equal(isBareShiftEnterLineEnding("\n"), true);
+  assert.equal(isBareShiftEnterLineEnding("\r"), true);
+  assert.equal(isBareShiftEnterLineEnding("\r\n"), true);
+  assert.equal(isBareShiftEnterLineEnding(" \\\n"), false);
+  assert.equal(isBareShiftEnterLineEnding("sudo whoami\n"), false);
+  assert.equal(isBareShiftEnterLineEnding(""), false);
+});
+
+test("Kitty encodings that collapse Shift+Enter to CR/LF do not preserve the chord", () => {
+  assert.equal(doesKittyEncodingPreserveShiftEnter(null), false);
+  assert.equal(doesKittyEncodingPreserveShiftEnter(""), false);
+  assert.equal(doesKittyEncodingPreserveShiftEnter("\r"), false);
+  assert.equal(doesKittyEncodingPreserveShiftEnter("\n"), false);
+  assert.equal(doesKittyEncodingPreserveShiftEnter(SHIFT_ENTER_CSI_U_SEQUENCE), true);
+});
+
+test("main-buffer Shift+Enter keeps configured send text", () => {
+  assert.deepEqual(resolveShiftEnterPayload(), {
+    kind: "text",
+    data: "\n",
+  });
+  assert.deepEqual(
+    resolveShiftEnterPayload(
+      { shiftEnterNewlineText: " \\\\\\n" },
+      { alternateScreen: false },
+    ),
+    { kind: "text", data: " \\\n" },
+  );
+});
+
+test("alternate-screen Shift+Enter sends CSI-u when configured text is a bare line ending", () => {
+  assert.deepEqual(
+    resolveShiftEnterPayload(undefined, { alternateScreen: true }),
+    { kind: "key", data: SHIFT_ENTER_CSI_U_SEQUENCE },
+  );
+  assert.deepEqual(
+    resolveShiftEnterPayload(
+      { shiftEnterNewlineText: "\\r\\n" },
+      { alternateScreen: true },
+    ),
+    { kind: "key", data: SHIFT_ENTER_CSI_U_SEQUENCE },
+  );
+});
+
+test("alternate-screen Shift+Enter keeps custom non-line-ending send text", () => {
+  assert.deepEqual(
+    resolveShiftEnterPayload(
+      { shiftEnterNewlineText: " \\\\\\n" },
+      { alternateScreen: true },
+    ),
+    { kind: "text", data: " \\\n" },
+  );
+});
+
 test("runtime routes Shift+Enter text through the shared input handler", () => {
   const source = readFileSync(
     new URL("./createXTermRuntime.ts", import.meta.url),
@@ -87,15 +146,24 @@ test("runtime routes Shift+Enter text through the shared input handler", () => {
 
   assert.match(
     source,
-    /const handleTerminalInputData = \(\s+data: string,\s+options\?: \{ source\?: "terminal" \| "shift-enter" \| "kitty" \},\s+\) => \{/s,
+    /const handleTerminalInputData = \(\s+data: string,\s+options\?: \{\s+source\?: "terminal" \| "shift-enter" \| "kitty";\s+[\s\S]*?skipBroadcast\?: boolean;\s+\},\s+\) => \{/s,
+  );
+  // Remap when Kitty encoding does not preserve Shift+Enter (not merely flags===0).
+  assert.match(
+    source,
+    /if \(\s*shouldSendShiftEnterText\([\s\S]*?\) &&\s*!doesKittyEncodingPreserveShiftEnter\(kittySequenceForKeyDown\)\s*\) \{[\s\S]*?const shiftEnterPayload = resolveShiftEnterPayload\([\s\S]*?\)[\s\S]*?\}\s*if \(kittySequenceForKeyDown\)/s,
   );
   assert.match(
     source,
-    /if \(textToSend\) \{\s+handleTerminalInputData\(textToSend, \{ source: "shift-enter" \}\);/s,
+    /if \(shiftEnterPayload\.kind === "key"\) \{[\s\S]*?handleTerminalInputData\(shiftEnterPayload\.data, \{ source: "kitty" \}\);[\s\S]*?\} else \{[\s\S]*?handleTerminalInputData\(shiftEnterPayload\.data, \{\s*source: "shift-enter",\s*skipBroadcast: true,\s*\}\);[\s\S]*?\}\s*const forwarded = broadcastKittyInput\(\{\s*kind: "key",\s*event: kittyEvent,\s*fallbackToLegacy: true,\s*\}\);/s,
   );
   assert.match(
     source,
-    /!isKittyKeyboardModeActive\(kittyKeyboardMode\) &&\s+shouldSendShiftEnterText/,
+    /const canBroadcastInput = !sensitive &&[\s\S]*?const willBroadcastInput = canBroadcastInput && options\?\.skipBroadcast !== true;[\s\S]*?if \(!canBroadcastInput && !handlingKittyBroadcast\) \{\s*prepareSudoAutofillInput/s,
+  );
+  assert.match(
+    source,
+    /alternateScreen: term\.buffer\.active\.type === "alternate",\s*shiftEnterSettings: ctx\.terminalSettingsRef\.current,/s,
   );
   assert.match(source, /getShiftEnterSubmittedInput\(data\)/);
   assert.match(source, /inputSource !== "shift-enter"/);

components/terminal/runtime/shiftEnterText.ts

@@ -2,6 +2,9 @@ import type { TerminalSettings } from "../../../domain/models";
 
 export const DEFAULT_SHIFT_ENTER_TEXT = "\\n";
 
+/** Kitty CSI-u encoding for Shift+Enter (keycode 13, modifier shift → 2). */
+export const SHIFT_ENTER_CSI_U_SEQUENCE = "\u001b[13;2u";
+
 type ShiftEnterEvent = Pick<
   KeyboardEvent,
   "altKey" | "ctrlKey" | "key" | "metaKey" | "shiftKey" | "type"
@@ -71,6 +74,47 @@ export function resolveShiftEnterText(
   );
 }
 
+export function isBareShiftEnterLineEnding(text: string): boolean {
+  return text === "\n" || text === "\r" || text === "\r\n";
+}
+
+/**
+ * True when Kitty encoding already keeps Shift+Enter distinct from plain Enter.
+ * Non-preserving flag sets (e.g. alternate-key or associated-text alone) still
+ * encode Shift+Enter as a bare CR/LF, so the alternate-screen remap must run.
+ */
+export function doesKittyEncodingPreserveShiftEnter(
+  encoded: string | null | undefined,
+): boolean {
+  return typeof encoded === "string"
+    && encoded.length > 0
+    && !isBareShiftEnterLineEnding(encoded);
+}
+
+export type ShiftEnterPayload =
+  | { kind: "text"; data: string }
+  | { kind: "key"; data: string };
+
+/**
+ * Resolve what Shift+Enter should write.
+ *
+ * On the main buffer, keep the configured send-text (default LF) so shell /
+ * Claude-style multiline prompts keep working. On the alternate screen (full-
+ * screen TUIs), bare line-ending remaps collapse Shift+Enter into Ctrl+Enter /
+ * LF for apps like Codex; send CSI-u Shift+Enter instead so the TUI can see
+ * the real chord. Custom send-text (e.g. shell continuation) is unchanged.
+ */
+export function resolveShiftEnterPayload(
+  settings?: Pick<TerminalSettings, "shiftEnterNewlineText">,
+  options?: { alternateScreen?: boolean },
+): ShiftEnterPayload {
+  const text = resolveShiftEnterText(settings);
+  if (options?.alternateScreen && isBareShiftEnterLineEnding(text)) {
+    return { kind: "key", data: SHIFT_ENTER_CSI_U_SEQUENCE };
+  }
+  return { kind: "text", data: text };
+}
+
 export function isShiftEnterLineContinuationText(text: string): boolean {
   return /\\(?:\r\n|\r|\n)$/.test(text);
 }

components/terminal/runtime/terminalInterceptorInputSafety.test.ts

@@ -34,7 +34,7 @@ test("password-prompt input is classified before prompt state reset and cannot b
   );
   assert.match(
     runtimeSource,
-    /const sensitive = ctx\.passwordPromptActiveRef\?\.current === true;[\s\S]*?const willBroadcastInput = !sensitive &&/u,
+    /const sensitive = ctx\.passwordPromptActiveRef\?\.current === true;[\s\S]*?const canBroadcastInput = !sensitive &&[\s\S]*?const willBroadcastInput = canBroadcastInput && options\?\.skipBroadcast !== true;/u,
   );
   assert.match(
     runtimeSource,

components/terminal/terminalSearch.test.ts

@@ -1,8 +1,20 @@
 import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
 import test from "node:test";
 
 import { notifyTerminalSearchTermChange } from "./TerminalSearchBar.tsx";
-import { resetTerminalSearch } from "./hooks/useTerminalSearch.ts";
+import {
+  armSearchHighlightRevivalGuard,
+  disarmSearchAddonRevival,
+  disposeStaleSearchDecorations,
+  installSearchDecorationTracker,
+  resetTerminalSearch,
+  SEARCH_HIGHLIGHT_REVIVAL_GUARD_MS,
+  settleTerminalSearchAfterLayout,
+  shouldResetOnSharedSearchClose,
+  stripStaleSearchDecorationNodes,
+  subscribeTerminalUserSelection,
+} from "./hooks/useTerminalSearch.ts";
 
 test("clearing the search input notifies the terminal search handler", () => {
   const terms: string[] = [];
@@ -43,11 +55,20 @@ test("resetting terminal search clears both match decorations and active selecti
       }
       return false;
     },
-    clearDecorations() {},
+    clearDecorations() {
+      decorationsVisible = false;
+    },
+  };
+  const term = {
+    rows: 24,
+    refresh() {},
+    clearSelection() {
+      activeSelectionVisible = false;
+    },
   };
   const searchTermRef = { current: "needle" };
 
-  resetTerminalSearch(searchAddon, searchTermRef);
+  resetTerminalSearch(searchAddon, searchTermRef, term);
 
   assert.equal(searchTermRef.current, "");
   assert.deepEqual(searchedTerms, [""]);
@@ -55,14 +76,19 @@ test("resetting terminal search clears both match decorations and active selecti
   assert.equal(activeSelectionVisible, false);
 });
 
-test("resetting terminal search clears cached decorations and refreshes the terminal", () => {
-  // Disposing search decorations can leave yellow match backgrounds painted on
-  // the canvas (seen on Windows after clearing/closing search). Keyword
-  // highlighting already forces a refresh after dispose; search reset must too.
+test("resetting terminal search clears cache before empty find and refreshes", () => {
+  // SearchAddon keeps a 200ms onWriteParsed/onResize timer that can revive
+  // highlights after reset if cachedSearchTerm was not cleared first. Also,
+  // findNext("", { decorations }) re-arms lastSearchOptions.decorations — so
+  // the empty find must not pass decoration options. clearDecorations alone
+  // leaves the active-match selection; clear it explicitly and refresh so
+  // Windows/WebGL does not keep yellow match backgrounds.
   const calls: string[] = [];
+  const findNextArgs: unknown[] = [];
   const searchAddon = {
-    findNext(term: string) {
+    findNext(term: string, options?: unknown) {
       calls.push(`findNext:${term}`);
+      findNextArgs.push(options);
       return false;
     },
     clearDecorations() {
@@ -74,11 +100,506 @@ test("resetting terminal search clears cached decorations and refreshes the term
     refresh(start: number, end: number) {
       calls.push(`refresh:${start}:${end}`);
     },
+    clearSelection() {
+      calls.push("clearSelection");
+    },
   };
   const searchTermRef = { current: "needle" };
 
   resetTerminalSearch(searchAddon, searchTermRef, term);
 
   assert.equal(searchTermRef.current, "");
-  assert.deepEqual(calls, ["findNext:", "clearDecorations", "refresh:0:23"]);
+  assert.deepEqual(calls, [
+    "clearDecorations",
+    "clearSelection",
+    "findNext:",
+    "clearDecorations",
+    "refresh:0:23",
+  ]);
+  assert.equal(findNextArgs[0], undefined);
+});
+
+test("search highlight revival guard re-clears decorations and the addon selection", () => {
+  assert.ok(SEARCH_HIGHLIGHT_REVIVAL_GUARD_MS > 200);
+
+  const calls: string[] = [];
+  let scheduled: { cb: () => void; ms: number } | null = null;
+  const searchAddon = {
+    clearDecorations() {
+      calls.push("clearDecorations");
+    },
+  };
+  const term = {
+    rows: 10,
+    refresh(start: number, end: number) {
+      calls.push(`refresh:${start}:${end}`);
+    },
+    clearSelection() {
+      calls.push("clearSelection");
+    },
+  };
+
+  const guard = armSearchHighlightRevivalGuard({
+    getSearchAddon: () => searchAddon,
+    getTerm: () => term,
+    setTimeoutFn: ((cb: () => void, ms: number) => {
+      scheduled = { cb, ms };
+      return 1 as unknown as ReturnType<typeof setTimeout>;
+    }) as typeof setTimeout,
+    clearTimeoutFn: (() => {}) as typeof clearTimeout,
+  });
+
+  guard.arm();
+  assert.ok(scheduled);
+  assert.equal(scheduled?.ms, SEARCH_HIGHLIGHT_REVIVAL_GUARD_MS);
+  assert.deepEqual(calls, []);
+
+  // SearchAddon._updateMatches can revive decorations and re-select the
+  // previous active match. With no user selection in the window, clear both.
+  calls.push("revived");
+  scheduled?.cb();
+
+  assert.deepEqual(calls, [
+    "revived",
+    "clearDecorations",
+    "refresh:0:9",
+    "clearSelection",
+  ]);
+
+  guard.dispose();
+});
+
+test("search highlight revival guard keeps a user selection made during the window", () => {
+  const calls: string[] = [];
+  let scheduled: { cb: () => void; ms: number } | null = null;
+  const searchAddon = {
+    clearDecorations() {
+      calls.push("clearDecorations");
+    },
+  };
+  const term = {
+    rows: 10,
+    refresh(start: number, end: number) {
+      calls.push(`refresh:${start}:${end}`);
+    },
+    clearSelection() {
+      calls.push("clearSelection");
+    },
+  };
+
+  const guard = armSearchHighlightRevivalGuard({
+    getSearchAddon: () => searchAddon,
+    getTerm: () => term,
+    setTimeoutFn: ((cb: () => void, ms: number) => {
+      scheduled = { cb, ms };
+      return 1 as unknown as ReturnType<typeof setTimeout>;
+    }) as typeof setTimeout,
+    clearTimeoutFn: (() => {}) as typeof clearTimeout,
+  });
+
+  guard.arm();
+  guard.markUserSelection();
+  scheduled?.cb();
+
+  assert.deepEqual(calls, [
+    "clearDecorations",
+    "refresh:0:9",
+  ]);
+
+  guard.dispose();
+});
+
+test("subscribeTerminalUserSelection marks on pointer down and unsubscribes", () => {
+  const marks: string[] = [];
+  const listeners = new Map<string, EventListener>();
+  const element = {
+    addEventListener(type: string, listener: EventListener) {
+      listeners.set(type, listener);
+    },
+    removeEventListener(type: string) {
+      listeners.delete(type);
+    },
+  };
+  const unsubscribe = subscribeTerminalUserSelection(
+    { element: element as unknown as HTMLElement },
+    () => marks.push("mark"),
+  );
+
+  listeners.get("mousedown")?.(new Event("mousedown"));
+  listeners.get("touchstart")?.(new Event("touchstart"));
+  assert.deepEqual(marks, ["mark", "mark"]);
+
+  unsubscribe();
+  assert.equal(listeners.size, 0);
+});
+
+test("revival guard subscribes to user selection only while armed", () => {
+  let subscribed = 0;
+  let unsubscribed = 0;
+  let scheduled: { cb: () => void } | null = null;
+  const guard = armSearchHighlightRevivalGuard({
+    getSearchAddon: () => ({
+      clearDecorations() {},
+    }),
+    getTerm: () => ({
+      rows: 1,
+      refresh() {},
+      clearSelection() {},
+    }),
+    subscribeUserSelection: () => {
+      subscribed += 1;
+      return () => {
+        unsubscribed += 1;
+      };
+    },
+    setTimeoutFn: ((cb: () => void) => {
+      scheduled = { cb };
+      return 1 as unknown as ReturnType<typeof setTimeout>;
+    }) as typeof setTimeout,
+    clearTimeoutFn: (() => {}) as typeof clearTimeout,
+  });
+
+  guard.arm();
+  assert.equal(subscribed, 1);
+  assert.equal(unsubscribed, 0);
+
+  scheduled?.cb();
+  assert.equal(unsubscribed, 1);
+
+  guard.dispose();
+});
+
+test("shared search close only resets terminals that have a local query", () => {
+  assert.equal(shouldResetOnSharedSearchClose(""), false);
+  assert.equal(shouldResetOnSharedSearchClose("needle"), true);
+});
+
+const leftoverDecoration = (className: string) => {
+  const node = {
+    className,
+    removed: false,
+    remove() {
+      this.removed = true;
+    },
+  };
+  return node;
+};
+
+test("resetting terminal search strips leftover find-result decoration nodes", () => {
+  // Esc close disposes SearchAddon decorations, but the last match's HTML
+  // overlay can remain — typically the first two cells of the previous hit.
+  const leftover = leftoverDecoration("xterm-find-result-decoration");
+  const searchAddon = {
+    findNext() {
+      return false;
+    },
+    clearDecorations() {},
+  };
+  const term = {
+    rows: 24,
+    refresh() {},
+    clearSelection() {},
+    element: {
+      querySelectorAll(selector: string) {
+        assert.match(selector, /xterm-find-result-decoration/);
+        return [leftover];
+      },
+    },
+  };
+
+  resetTerminalSearch(searchAddon, { current: "pro" }, term);
+
+  assert.equal(leftover.removed, true);
+});
+
+test("stripStaleSearchDecorationNodes removes both result and active overlays", () => {
+  const resultNode = leftoverDecoration("xterm-find-result-decoration");
+  const activeNode = leftoverDecoration("xterm-find-active-result-decoration");
+  stripStaleSearchDecorationNodes({
+    element: {
+      querySelectorAll() {
+        return [resultNode, activeNode];
+      },
+    },
+  });
+  assert.equal(resultNode.removed, true);
+  assert.equal(activeNode.removed, true);
+});
+
+test("settling search after an emptied query keeps a later manual selection", () => {
+  const leftover = leftoverDecoration("xterm-find-result-decoration");
+  const calls: string[] = [];
+  const term = {
+    rows: 12,
+    registerDecoration() {
+      return undefined;
+    },
+    refresh() {
+      calls.push("refresh");
+    },
+    clearSelection() {
+      calls.push("clearSelection");
+    },
+    element: {
+      querySelectorAll() {
+        return [leftover];
+      },
+    },
+  };
+  const tracker = installSearchDecorationTracker(term);
+  tracker.markSearched();
+  tracker.noteEmptyQueryReset();
+  settleTerminalSearchAfterLayout(
+    {
+      clearDecorations() {
+        calls.push("clearDecorations");
+      },
+    },
+    term,
+    () => calls.push("atlas"),
+  );
+  assert.equal(calls.includes("clearSelection"), false);
+  assert.ok(calls.includes("clearDecorations"));
+  assert.ok(calls.includes("atlas"));
+  assert.equal(leftover.removed, true);
+});
+
+test("settling search after layout skips terminals that never searched", () => {
+  const leftover = leftoverDecoration("xterm-find-result-decoration");
+  const calls: string[] = [];
+  const term = {
+    rows: 12,
+    registerDecoration() {
+      return undefined;
+    },
+    refresh() {
+      calls.push("refresh");
+    },
+    clearSelection() {
+      calls.push("clearSelection");
+    },
+    element: {
+      querySelectorAll() {
+        return [leftover];
+      },
+    },
+  };
+  installSearchDecorationTracker(term);
+  settleTerminalSearchAfterLayout(
+    {
+      clearDecorations() {
+        calls.push("clearDecorations");
+      },
+    },
+    term,
+    () => calls.push("atlas"),
+  );
+  assert.deepEqual(calls, []);
+  assert.equal(leftover.removed, false);
+});
+
+test("settling search after layout re-clears decorations, selection, leftover nodes, and repaints", () => {
+  const leftover = leftoverDecoration("xterm-find-result-decoration");
+  const calls: string[] = [];
+  const searchAddon = {
+    clearDecorations() {
+      calls.push("clearDecorations");
+    },
+  };
+  const term = {
+    rows: 12,
+    refresh(start: number, end: number) {
+      calls.push(`refresh:${start}:${end}`);
+    },
+    clearSelection() {
+      calls.push("clearSelection");
+    },
+    element: {
+      querySelectorAll() {
+        calls.push("queryLeftover");
+        return [leftover];
+      },
+    },
+  };
+
+  settleTerminalSearchAfterLayout(searchAddon, term, () => {
+    calls.push("atlas");
+  });
+
+  assert.equal(leftover.removed, true);
+  assert.deepEqual(calls, [
+    "clearDecorations",
+    "queryLeftover",
+    "refresh:0:11",
+    "clearSelection",
+    "atlas",
+  ]);
+});
+
+test("disposeStaleSearchDecorations drops leaked search backgrounds and keeps others", () => {
+  const searchMatch = {
+    disposed: false,
+    options: { backgroundColor: "#FFFF0044" },
+    dispose() {
+      this.disposed = true;
+    },
+  };
+  const activeMatch = {
+    disposed: false,
+    options: { backgroundColor: "#FF880088" },
+    dispose() {
+      this.disposed = true;
+    },
+  };
+  const cursorLine = {
+    disposed: false,
+    options: { backgroundColor: "#1e293b" },
+    dispose() {
+      this.disposed = true;
+    },
+  };
+  const count = disposeStaleSearchDecorations({
+    _core: {
+      _decorationService: {
+        decorations: [searchMatch, activeMatch, cursorLine],
+      },
+    },
+  });
+  assert.equal(count, 2);
+  assert.equal(searchMatch.disposed, true);
+  assert.equal(activeMatch.disposed, true);
+  assert.equal(cursorLine.disposed, false);
+});
+
+test("resetting terminal search disposes leaked WebGL search decorations", () => {
+  const leaked = {
+    disposed: false,
+    options: { backgroundColor: "#ffff0044" },
+    dispose() {
+      this.disposed = true;
+    },
+  };
+  resetTerminalSearch(
+    {
+      findNext() {
+        return false;
+      },
+      clearDecorations() {},
+    },
+    { current: "s" },
+    {
+      rows: 24,
+      refresh() {},
+      clearSelection() {},
+      _core: {
+        _decorationService: {
+          decorations: [leaked],
+        },
+      },
+    } as never,
+  );
+  assert.equal(leaked.disposed, true);
+});
+
+test("search decoration tracker disposes leaked incremental matches", () => {
+  const live: Array<{
+    registeredBackground?: string;
+    overlayBackground?: string;
+    disposed: boolean;
+    dispose: () => void;
+    onDispose: (cb: () => void) => { dispose: () => void };
+    onRender: (cb: (el: { style: { backgroundColor: string } }) => void) => { dispose: () => void };
+  }> = [];
+  const registeredBackgrounds: Array<string | undefined> = [];
+  const term = {
+    registerDecoration(options: { backgroundColor?: string }) {
+      registeredBackgrounds.push(options.backgroundColor);
+      const disposeListeners: Array<() => void> = [];
+      const renderListeners: Array<(el: { style: { backgroundColor: string } }) => void> = [];
+      const decoration = {
+        registeredBackground: options.backgroundColor,
+        overlayBackground: undefined as string | undefined,
+        disposed: false,
+        dispose() {
+          if (this.disposed) return;
+          this.disposed = true;
+          for (const listener of disposeListeners) listener();
+        },
+        onDispose(cb: () => void) {
+          disposeListeners.push(cb);
+          return { dispose() {} };
+        },
+        onRender(cb: (el: { style: { backgroundColor: string } }) => void) {
+          renderListeners.push(cb);
+          return { dispose() {} };
+        },
+        paint() {
+          const el = { style: { backgroundColor: "" } };
+          for (const listener of renderListeners) listener(el);
+          this.overlayBackground = el.style.backgroundColor;
+        },
+      };
+      live.push(decoration);
+      return decoration;
+    },
+  };
+  const tracker = installSearchDecorationTracker(term);
+  const match = term.registerDecoration({ backgroundColor: "#FFFF0044" });
+  term.registerDecoration({ backgroundColor: "#FF880088" });
+  term.registerDecoration({ backgroundColor: "#1e293b" });
+  match?.paint();
+  assert.deepEqual(registeredBackgrounds, [undefined, undefined, "#1e293b"]);
+  assert.equal(match?.overlayBackground, "#FFFF0044");
+  assert.equal(tracker.size(), 2);
+  tracker.markSearched();
+  assert.equal(tracker.hasSearched(), true);
+  assert.equal(tracker.disposeAll(), 2);
+  assert.equal(live.filter((item) => item.disposed).length, 2);
+  assert.equal(live.some((item) => item.registeredBackground === "#1e293b" && !item.disposed), true);
+  assert.equal(tracker.size(), 0);
+});
+
+test("xterm runtime installs the search decoration tracker", () => {
+  const source = readFileSync(new URL("./runtime/createXTermRuntime.ts", import.meta.url), "utf8");
+  assert.match(source, /installSearchDecorationTracker\(term\)/);
+});
+
+test("disarmSearchAddonRevival cancels the addon timer and resets cached state", () => {
+  const calls: string[] = [];
+  disarmSearchAddonRevival({
+    _highlightTimeout: {
+      clear() {
+        calls.push("clearTimeout");
+      },
+    },
+    _state: {
+      reset() {
+        calls.push("resetState");
+      },
+    },
+    clearActiveDecoration() {
+      calls.push("clearActive");
+    },
+    clearDecorations() {
+      calls.push("clearDecorations");
+    },
+  });
+  assert.deepEqual(calls, [
+    "clearTimeout",
+    "resetState",
+    "clearActive",
+    "clearDecorations",
+  ]);
+});
+
+test("search-bar close fit settles leftover highlights after layout", () => {
+  const source = readFileSync(new URL("./useTerminalEffects.ts", import.meta.url), "utf8");
+  assert.match(source, /settleTerminalSearchAfterLayout/);
+  assert.match(source, /closingSearch = wasSearchOpen && !isSearchOpen/);
+  assert.match(source, /if \(!closingSearch \|\| prevIsSearchOpenRef\.current\) return/);
+  assert.match(source, /if \(raf\) cancelAnimationFrame\(raf\)/);
+  assert.match(
+    source,
+    /safeFit\(\{ force: true, requireVisible: true \}\);[\s\S]*settleClosedSearch/,
+  );
 });

components/terminal/useTerminalEffects.ts

@@ -48,12 +48,17 @@ import {
   type XTermFontRemeasureTarget,
 } from './runtime/terminalFontRemeasure';
 import { shouldClaimTerminalKeyboardFocus } from '../../domain/terminalKeyboardFocus';
+import { settleTerminalSearchAfterLayout } from './hooks/useTerminalSearch';
 import {
   isTerminalCloseGenerationCurrent,
   resolveConnectionLogCapturePayload,
   scheduleTerminalCloseTeardown,
   serializeTerminalCloseFallback,
 } from './runtime/terminalCloseCapture';
+import {
+  CONNECTION_PROGRESS_START,
+  advanceIndeterminateConnectionProgress,
+} from './connectionProgress';
 import {
   getConnectionTimeoutMs,
   resolveActiveConnectionTimeoutHost,
@@ -172,6 +177,7 @@ export function useTerminalEffects(ctx: TerminalEffectsContext) {
     effectiveTerminalProtocol,
   ) && !kittyKeyboardProtocolEnabledForSession;
   ctx.pluginDecorationRulesRef.current = pluginDecorationRules;
+  const prevIsSearchOpenRef = useRef(isSearchOpen);
   const pluginAwareOnCommandSubmitted = (...args: Parameters<NonNullable<typeof onCommandSubmitted>>) => {
     markTerminalCommandCompletionPending(promptLineBreakStateRef);
     publishPluginTerminalRuntimeLifecycleEvent(pluginTerminalLifecycle, 'commandSubmitted');
@@ -1002,14 +1008,8 @@ export function useTerminalEffects(ctx: TerminalEffectsContext) {
       setProgressLogs((prev) => [...prev, "Connection timed out."]);
     }, connectionTimeout);
 
-    setProgressValue(5);
     const prog = setInterval(() => {
-      setProgressValue((prev) => {
-        if (prev >= 95) return prev;
-        const remaining = 95 - prev;
-        const increment = Math.max(1, remaining * 0.15);
-        return Math.min(95, prev + increment);
-      });
+      setProgressValue(advanceIndeterminateConnectionProgress);
     }, 200);
 
     return () => {
@@ -1024,6 +1024,7 @@ export function useTerminalEffects(ctx: TerminalEffectsContext) {
   useEffect(() => {
     if (status === "connecting") {
       setIsDisconnectedDialogDismissed(false);
+      setProgressValue(CONNECTION_PROGRESS_START);
     }
   }, [status]);
 
@@ -1583,13 +1584,29 @@ export function useTerminalEffects(ctx: TerminalEffectsContext) {
   // When search bar opens/closes, re-fit terminal and maintain scroll position
   useEffect(() => {
     const term = termRef.current;
+    const wasSearchOpen = prevIsSearchOpenRef.current;
+    prevIsSearchOpenRef.current = isSearchOpen;
     if (!term || !fitAddonRef.current) return;
     const buffer = term.buffer.active;
     const wasAtBottom = buffer.viewportY >= buffer.baseY;
     const prevViewportY = buffer.viewportY;
+    const closingSearch = wasSearchOpen && !isSearchOpen;
+    let raf = 0;
+    const settleClosedSearch = () => {
+      // A later open flips prevIsSearchOpenRef before this stale frame runs.
+      if (!closingSearch || prevIsSearchOpenRef.current) return;
+      settleTerminalSearchAfterLayout(
+        searchAddonRef.current,
+        term,
+        () => xtermRuntimeRef.current?.clearTextureAtlas(),
+      );
+    };
     const timer = setTimeout(() => {
       safeFit({ force: true, requireVisible: true });
-      requestAnimationFrame(() => {
+      settleClosedSearch();
+      raf = requestAnimationFrame(() => {
+        raf = 0;
+        settleClosedSearch();
         if (wasAtBottom) {
           term.scrollToBottom();
         } else {
@@ -1597,7 +1614,10 @@ export function useTerminalEffects(ctx: TerminalEffectsContext) {
         }
       });
     }, 0);
-    return () => clearTimeout(timer);
+    return () => {
+      clearTimeout(timer);
+      if (raf) cancelAnimationFrame(raf);
+    };
   }, [isSearchOpen]);
 
   // When compose bar opens/closes, re-fit terminal and maintain scroll position

components/terminalLayer/TerminalLayerSupport.tsx

@@ -56,6 +56,12 @@ const LazyAIChatSidePanel = lazy(() =>
   import('../AIChatSidePanel').then((module) => ({ default: module.AIChatSidePanel })),
 );
 
+if (typeof requestIdleCallback === 'function') {
+  requestIdleCallback(() => {
+    void import('../AIChatSidePanel');
+  });
+}
+
 const AIChatSidePanelFallback = memo(function AIChatSidePanelFallback() {
   return (
     <div className="netcatty-lazy-fade-in h-full min-h-0 bg-background" aria-hidden="true" />

docs/assets/star-history/star-history-dark.svg

@@ -15,31 +15,33 @@
 <text x="50%" y="30" fill="#e6edf3" font-size="20" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Star History</text>
   <rect width="178" height="32" x="105" y="90" fill="#161b22" fill-opacity="0.9" stroke="#30363d" stroke-width="1.5" rx="4" ry="4" filter="url(#xkcdify)"/><rect width="8" height="8" x="115" y="102" rx="2" ry="2" fill="#dd4528" filter="url(#xkcdify)"/><text x="131" y="110" fill="#e6edf3" font-size="15" font-family="Handlee, cursive" font-weight="bold">binaricat/Netcatty</text>
   <text x="85" y="468.0" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">0</text>
-  <line x1="90" y1="386.4" x2="765" y2="386.4" stroke="#21262d" stroke-width="1" filter="url(#xkcdify)"/>
-  <text x="85" y="391.4" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">1K</text>
-  <line x1="90" y1="309.8" x2="765" y2="309.8" stroke="#21262d" stroke-width="1" filter="url(#xkcdify)"/>
-  <text x="85" y="314.79999999999995" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">2K</text>
-  <line x1="90" y1="233.2" x2="765" y2="233.2" stroke="#21262d" stroke-width="1" filter="url(#xkcdify)"/>
-  <text x="85" y="238.20000000000002" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">3K</text>
-  <line x1="90" y1="156.6" x2="765" y2="156.6" stroke="#21262d" stroke-width="1" filter="url(#xkcdify)"/>
-  <text x="85" y="161.59999999999997" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">4K</text>
+  <line x1="90" y1="399.2" x2="765" y2="399.2" stroke="#21262d" stroke-width="1" filter="url(#xkcdify)"/>
+  <text x="85" y="404.1666666666667" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">1K</text>
+  <line x1="90" y1="335.3" x2="765" y2="335.3" stroke="#21262d" stroke-width="1" filter="url(#xkcdify)"/>
+  <text x="85" y="340.33333333333337" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">2K</text>
+  <line x1="90" y1="271.5" x2="765" y2="271.5" stroke="#21262d" stroke-width="1" filter="url(#xkcdify)"/>
+  <text x="85" y="276.5" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">3K</text>
+  <line x1="90" y1="207.7" x2="765" y2="207.7" stroke="#21262d" stroke-width="1" filter="url(#xkcdify)"/>
+  <text x="85" y="212.66666666666669" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">4K</text>
+  <line x1="90" y1="143.8" x2="765" y2="143.8" stroke="#21262d" stroke-width="1" filter="url(#xkcdify)"/>
+  <text x="85" y="148.83333333333331" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">5K</text>
   <line x1="90" y1="80.0" x2="765" y2="80.0" stroke="#21262d" stroke-width="1" filter="url(#xkcdify)"/>
-  <text x="85" y="85.0" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">5K</text>
+  <text x="85" y="85.0" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">6K</text>
   <text x="43" y="271.5" fill="#e6edf3" font-size="17" font-family="Handlee, cursive" font-weight="bold" transform="rotate(-90, 43, 271.5)">GitHub Stars</text>
   <text x="90.0" y="488" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Jan 2026</text>
-  <text x="182.3" y="488" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Feb 2026</text>
-  <text x="271.5" y="488" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Mar 2026</text>
-  <text x="370.2" y="488" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Apr 2026</text>
-  <text x="465.7" y="488" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">May 2026</text>
-  <text x="564.4" y="488" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Jun 2026</text>
-  <text x="659.9" y="488" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Jul 2026</text>
-  <text x="758.6" y="488" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Aug 2026</text>
+  <text x="177.0" y="488" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Feb 2026</text>
+  <text x="261.0" y="488" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Mar 2026</text>
+  <text x="354.0" y="488" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Apr 2026</text>
+  <text x="444.0" y="488" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">May 2026</text>
+  <text x="537.0" y="488" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Jun 2026</text>
+  <text x="627.0" y="488" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Jul 2026</text>
+  <text x="720.0" y="488" fill="#e6edf3" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Aug 2026</text>
   <text x="50%" y="525" fill="#e6edf3" font-size="17" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Date</text>
   <line x1="90" y1="80" x2="90" y2="463" stroke="#30363d" stroke-width="2.5" filter="url(#xkcdify)"/>
   <line x1="90" y1="463" x2="765" y2="463" stroke="#30363d" stroke-width="2.5" filter="url(#xkcdify)"/>
-  <path d="M 90.0,461.9 C 90.5,461.7 92.7,461.3 93.2,461.2 C 94.2,461.0 95.3,460.8 96.4,460.5 C 97.4,460.3 98.5,460.0 99.6,459.9 C 100.6,459.7 101.7,459.8 102.7,459.8 C 103.8,459.7 104.9,459.7 105.9,459.6 C 107.0,459.6 108.0,459.5 109.1,459.4 C 110.2,459.3 110.7,459.2 112.3,459.2 C 113.9,459.1 117.1,459.0 118.7,458.9 C 120.2,458.9 120.8,458.8 121.8,458.8 C 122.9,458.7 124.0,458.7 125.0,458.7 C 126.1,458.7 127.1,458.7 128.2,458.6 C 129.3,458.6 130.3,458.6 131.4,458.6 C 132.5,458.5 133.5,458.4 134.6,458.3 C 135.6,458.2 136.7,458.3 137.8,458.0 C 138.8,457.8 139.9,457.4 140.9,456.9 C 142.0,456.5 143.1,455.4 144.1,455.0 C 145.2,454.7 146.2,454.9 147.3,454.8 C 148.4,454.7 149.4,454.7 150.5,454.7 C 151.6,454.6 152.1,454.5 153.7,454.5 C 155.3,454.5 157.9,454.5 160.0,454.4 C 162.2,454.4 164.8,454.3 166.4,454.3 C 168.0,454.2 168.5,454.2 169.6,454.1 C 170.7,454.1 171.7,454.0 172.8,454.0 C 173.8,453.9 174.9,453.8 176.0,453.8 C 177.0,453.8 178.1,453.8 179.2,453.7 C 180.2,453.7 180.7,453.7 182.3,453.7 C 183.9,453.6 186.0,453.5 188.7,453.5 C 191.4,453.5 195.6,453.5 198.3,453.4 C 200.9,453.4 201.4,453.4 204.6,453.3 C 207.8,453.3 214.7,453.1 217.4,453.0 C 220.0,453.0 219.0,453.0 220.5,453.0 C 222.1,452.9 224.3,452.9 226.9,452.9 C 229.6,452.9 231.2,452.8 236.5,452.7 C 241.8,452.7 254.5,452.6 258.8,452.5 C 263.0,452.5 260.9,452.5 261.9,452.4 C 263.0,452.4 263.5,453.3 265.1,452.4 C 266.7,451.4 269.9,450.6 271.5,446.5 C 273.1,442.5 273.6,431.6 274.7,428.2 C 275.7,424.8 276.8,426.8 277.9,426.2 C 278.9,425.7 280.0,425.4 281.0,425.0 C 282.1,424.7 283.2,424.4 284.2,424.2 C 285.3,423.9 286.3,423.9 287.4,423.7 C 288.5,423.6 289.5,423.3 290.6,423.2 C 291.7,423.2 292.7,423.3 293.8,423.2 C 294.8,423.1 295.9,422.8 297.0,422.6 C 298.0,422.5 299.1,422.6 300.1,422.4 C 301.2,422.2 302.3,421.7 303.3,421.6 C 304.4,421.4 305.4,421.5 306.5,421.3 C 307.6,421.2 308.6,420.9 309.7,420.8 C 310.8,420.7 311.8,420.8 312.9,420.7 C 313.9,420.7 315.0,420.6 316.1,420.5 C 317.1,420.4 318.2,420.3 319.2,420.3 C 320.3,420.2 321.4,420.2 322.4,420.0 C 323.5,419.9 324.6,419.5 325.6,419.3 C 326.7,419.1 327.7,420.1 328.8,418.8 C 329.9,417.5 330.9,413.1 332.0,411.6 C 333.0,410.1 334.1,410.3 335.2,410.1 C 336.2,409.8 337.3,410.2 338.3,410.0 C 339.4,409.8 340.5,409.3 341.5,408.9 C 342.6,408.5 343.7,408.2 344.7,407.5 C 345.8,406.7 346.8,405.4 347.9,404.6 C 349.0,403.7 350.0,402.9 351.1,402.3 C 352.1,401.6 353.2,401.2 354.3,400.8 C 355.3,400.4 356.4,400.3 357.5,400.1 C 358.5,399.9 359.6,400.0 360.6,399.8 C 361.7,399.7 362.8,399.3 363.8,399.2 C 364.9,399.1 365.9,399.1 367.0,399.0 C 368.1,399.0 369.1,398.9 370.2,398.7 C 371.2,398.6 372.3,398.6 373.4,398.0 C 374.4,397.5 375.5,396.0 376.6,395.3 C 377.6,394.6 378.7,394.4 379.7,393.8 C 380.8,393.3 381.9,394.4 382.9,392.1 C 384.0,389.9 385.0,383.2 386.1,380.6 C 387.2,378.0 388.2,377.6 389.3,376.4 C 390.4,375.3 391.4,374.7 392.5,373.9 C 393.5,373.1 394.6,372.4 395.7,371.8 C 396.7,371.2 397.8,370.7 398.8,370.3 C 399.9,369.9 401.0,369.9 402.0,369.5 C 403.1,369.2 404.2,368.9 405.2,368.5 C 406.3,368.1 407.3,367.4 408.4,367.0 C 409.5,366.7 410.5,366.7 411.6,366.3 C 412.6,366.0 413.7,365.3 414.8,364.9 C 415.8,364.4 416.9,364.1 417.9,363.7 C 419.0,363.4 420.1,363.1 421.1,362.9 C 422.2,362.7 423.3,362.6 424.3,362.4 C 425.4,362.2 426.4,361.9 427.5,361.7 C 428.6,361.4 429.6,361.2 430.7,360.9 C 431.7,360.6 432.8,360.3 433.9,359.9 C 434.9,359.4 436.0,358.6 437.1,358.2 C 438.1,357.8 439.2,357.7 440.2,357.4 C 441.3,357.2 442.4,357.1 443.4,356.9 C 444.5,356.7 445.5,356.6 446.6,356.4 C 447.7,356.3 448.7,356.1 449.8,356.0 C 450.8,355.9 451.9,356.0 453.0,355.8 C 454.0,355.6 455.1,355.2 456.2,354.8 C 457.2,354.4 458.3,353.8 459.3,353.3 C 460.4,352.8 461.5,352.3 462.5,352.0 C 463.6,351.7 464.6,351.7 465.7,351.5 C 466.8,351.3 467.8,351.2 468.9,350.9 C 470.0,350.5 471.0,349.8 472.1,349.5 C 473.1,349.2 474.2,349.3 475.3,349.1 C 476.3,348.9 477.4,348.5 478.4,348.3 C 479.5,348.0 480.6,347.8 481.6,347.5 C 482.7,347.2 483.8,346.9 484.8,346.6 C 485.9,346.4 486.9,346.3 488.0,346.0 C 489.1,345.6 490.1,345.1 491.2,344.8 C 492.2,344.5 493.3,344.3 494.4,344.0 C 495.4,343.6 496.5,343.1 497.5,342.7 C 498.6,342.3 499.7,341.9 500.7,341.6 C 501.8,341.2 502.9,341.2 503.9,340.6 C 505.0,340.0 506.0,338.7 507.1,338.2 C 508.2,337.7 509.2,337.6 510.3,337.5 C 511.3,337.3 512.4,337.3 513.5,337.1 C 514.5,337.0 515.6,336.8 516.7,336.6 C 517.7,336.5 518.8,336.7 519.8,336.2 C 520.9,335.7 522.0,334.1 523.0,333.5 C 524.1,332.9 525.1,333.0 526.2,332.6 C 527.3,332.3 528.3,331.6 529.4,331.3 C 530.4,331.0 531.5,331.2 532.6,330.9 C 533.6,330.6 534.7,329.9 535.8,329.6 C 536.8,329.3 537.9,329.3 538.9,329.2 C 540.0,329.0 541.1,329.0 542.1,328.7 C 543.2,328.4 544.2,328.0 545.3,327.3 C 546.4,326.5 547.4,325.1 548.5,324.4 C 549.6,323.6 550.6,323.3 551.7,322.7 C 552.7,322.2 553.8,322.1 554.9,321.1 C 555.9,320.0 557.0,317.7 558.0,316.5 C 559.1,315.4 560.2,314.9 561.2,314.2 C 562.3,313.5 563.3,313.4 564.4,312.3 C 565.5,311.3 566.5,309.0 567.6,308.0 C 568.7,307.0 569.7,306.9 570.8,306.3 C 571.Line truncated
-  <path d="M 90.0,461.9 C 90.5,461.7 92.7,461.3 93.2,461.2 C 94.2,461.0 95.3,460.8 96.4,460.5 C 97.4,460.3 98.5,460.0 99.6,459.9 C 100.6,459.7 101.7,459.8 102.7,459.8 C 103.8,459.7 104.9,459.7 105.9,459.6 C 107.0,459.6 108.0,459.5 109.1,459.4 C 110.2,459.3 110.7,459.2 112.3,459.2 C 113.9,459.1 117.1,459.0 118.7,458.9 C 120.2,458.9 120.8,458.8 121.8,458.8 C 122.9,458.7 124.0,458.7 125.0,458.7 C 126.1,458.7 127.1,458.7 128.2,458.6 C 129.3,458.6 130.3,458.6 131.4,458.6 C 132.5,458.5 133.5,458.4 134.6,458.3 C 135.6,458.2 136.7,458.3 137.8,458.0 C 138.8,457.8 139.9,457.4 140.9,456.9 C 142.0,456.5 143.1,455.4 144.1,455.0 C 145.2,454.7 146.2,454.9 147.3,454.8 C 148.4,454.7 149.4,454.7 150.5,454.7 C 151.6,454.6 152.1,454.5 153.7,454.5 C 155.3,454.5 157.9,454.5 160.0,454.4 C 162.2,454.4 164.8,454.3 166.4,454.3 C 168.0,454.2 168.5,454.2 169.6,454.1 C 170.7,454.1 171.7,454.0 172.8,454.0 C 173.8,453.9 174.9,453.8 176.0,453.8 C 177.0,453.8 178.1,453.8 179.2,453.7 C 180.2,453.7 180.7,453.7 182.3,453.7 C 183.9,453.6 186.0,453.5 188.7,453.5 C 191.4,453.5 195.6,453.5 198.3,453.4 C 200.9,453.4 201.4,453.4 204.6,453.3 C 207.8,453.3 214.7,453.1 217.4,453.0 C 220.0,453.0 219.0,453.0 220.5,453.0 C 222.1,452.9 224.3,452.9 226.9,452.9 C 229.6,452.9 231.2,452.8 236.5,452.7 C 241.8,452.7 254.5,452.6 258.8,452.5 C 263.0,452.5 260.9,452.5 261.9,452.4 C 263.0,452.4 263.5,453.3 265.1,452.4 C 266.7,451.4 269.9,450.6 271.5,446.5 C 273.1,442.5 273.6,431.6 274.7,428.2 C 275.7,424.8 276.8,426.8 277.9,426.2 C 278.9,425.7 280.0,425.4 281.0,425.0 C 282.1,424.7 283.2,424.4 284.2,424.2 C 285.3,423.9 286.3,423.9 287.4,423.7 C 288.5,423.6 289.5,423.3 290.6,423.2 C 291.7,423.2 292.7,423.3 293.8,423.2 C 294.8,423.1 295.9,422.8 297.0,422.6 C 298.0,422.5 299.1,422.6 300.1,422.4 C 301.2,422.2 302.3,421.7 303.3,421.6 C 304.4,421.4 305.4,421.5 306.5,421.3 C 307.6,421.2 308.6,420.9 309.7,420.8 C 310.8,420.7 311.8,420.8 312.9,420.7 C 313.9,420.7 315.0,420.6 316.1,420.5 C 317.1,420.4 318.2,420.3 319.2,420.3 C 320.3,420.2 321.4,420.2 322.4,420.0 C 323.5,419.9 324.6,419.5 325.6,419.3 C 326.7,419.1 327.7,420.1 328.8,418.8 C 329.9,417.5 330.9,413.1 332.0,411.6 C 333.0,410.1 334.1,410.3 335.2,410.1 C 336.2,409.8 337.3,410.2 338.3,410.0 C 339.4,409.8 340.5,409.3 341.5,408.9 C 342.6,408.5 343.7,408.2 344.7,407.5 C 345.8,406.7 346.8,405.4 347.9,404.6 C 349.0,403.7 350.0,402.9 351.1,402.3 C 352.1,401.6 353.2,401.2 354.3,400.8 C 355.3,400.4 356.4,400.3 357.5,400.1 C 358.5,399.9 359.6,400.0 360.6,399.8 C 361.7,399.7 362.8,399.3 363.8,399.2 C 364.9,399.1 365.9,399.1 367.0,399.0 C 368.1,399.0 369.1,398.9 370.2,398.7 C 371.2,398.6 372.3,398.6 373.4,398.0 C 374.4,397.5 375.5,396.0 376.6,395.3 C 377.6,394.6 378.7,394.4 379.7,393.8 C 380.8,393.3 381.9,394.4 382.9,392.1 C 384.0,389.9 385.0,383.2 386.1,380.6 C 387.2,378.0 388.2,377.6 389.3,376.4 C 390.4,375.3 391.4,374.7 392.5,373.9 C 393.5,373.1 394.6,372.4 395.7,371.8 C 396.7,371.2 397.8,370.7 398.8,370.3 C 399.9,369.9 401.0,369.9 402.0,369.5 C 403.1,369.2 404.2,368.9 405.2,368.5 C 406.3,368.1 407.3,367.4 408.4,367.0 C 409.5,366.7 410.5,366.7 411.6,366.3 C 412.6,366.0 413.7,365.3 414.8,364.9 C 415.8,364.4 416.9,364.1 417.9,363.7 C 419.0,363.4 420.1,363.1 421.1,362.9 C 422.2,362.7 423.3,362.6 424.3,362.4 C 425.4,362.2 426.4,361.9 427.5,361.7 C 428.6,361.4 429.6,361.2 430.7,360.9 C 431.7,360.6 432.8,360.3 433.9,359.9 C 434.9,359.4 436.0,358.6 437.1,358.2 C 438.1,357.8 439.2,357.7 440.2,357.4 C 441.3,357.2 442.4,357.1 443.4,356.9 C 444.5,356.7 445.5,356.6 446.6,356.4 C 447.7,356.3 448.7,356.1 449.8,356.0 C 450.8,355.9 451.9,356.0 453.0,355.8 C 454.0,355.6 455.1,355.2 456.2,354.8 C 457.2,354.4 458.3,353.8 459.3,353.3 C 460.4,352.8 461.5,352.3 462.5,352.0 C 463.6,351.7 464.6,351.7 465.7,351.5 C 466.8,351.3 467.8,351.2 468.9,350.9 C 470.0,350.5 471.0,349.8 472.1,349.5 C 473.1,349.2 474.2,349.3 475.3,349.1 C 476.3,348.9 477.4,348.5 478.4,348.3 C 479.5,348.0 480.6,347.8 481.6,347.5 C 482.7,347.2 483.8,346.9 484.8,346.6 C 485.9,346.4 486.9,346.3 488.0,346.0 C 489.1,345.6 490.1,345.1 491.2,344.8 C 492.2,344.5 493.3,344.3 494.4,344.0 C 495.4,343.6 496.5,343.1 497.5,342.7 C 498.6,342.3 499.7,341.9 500.7,341.6 C 501.8,341.2 502.9,341.2 503.9,340.6 C 505.0,340.0 506.0,338.7 507.1,338.2 C 508.2,337.7 509.2,337.6 510.3,337.5 C 511.3,337.3 512.4,337.3 513.5,337.1 C 514.5,337.0 515.6,336.8 516.7,336.6 C 517.7,336.5 518.8,336.7 519.8,336.2 C 520.9,335.7 522.0,334.1 523.0,333.5 C 524.1,332.9 525.1,333.0 526.2,332.6 C 527.3,332.3 528.3,331.6 529.4,331.3 C 530.4,331.0 531.5,331.2 532.6,330.9 C 533.6,330.6 534.7,329.9 535.8,329.6 C 536.8,329.3 537.9,329.3 538.9,329.2 C 540.0,329.0 541.1,329.0 542.1,328.7 C 543.2,328.4 544.2,328.0 545.3,327.3 C 546.4,326.5 547.4,325.1 548.5,324.4 C 549.6,323.6 550.6,323.3 551.7,322.7 C 552.7,322.2 553.8,322.1 554.9,321.1 C 555.9,320.0 557.0,317.7 558.0,316.5 C 559.1,315.4 560.2,314.9 561.2,314.2 C 562.3,313.5 563.3,313.4 564.4,312.3 C 565.5,311.3 566.5,309.0 567.6,308.0 C 568.7,307.0 569.7,306.9 570.8,306.3 C 571.Line truncated
-  <circle cx="765.0" cy="116.9" r="5" fill="#dd4528" stroke="#0d1117" stroke-width="2" filter="url(#xkcdify)"/>
-<text x="753.0" y="77.0" fill="#dd4528" font-size="18" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">4518</text>
+  <path d="M 90.0,462.0 C 90.5,462.0 92.5,461.6 93.0,461.5 C 94.0,461.4 95.0,461.1 96.0,461.0 C 97.0,460.8 98.0,460.5 99.0,460.4 C 100.0,460.3 101.0,460.4 102.0,460.3 C 103.0,460.3 104.0,460.2 105.0,460.2 C 106.0,460.1 107.0,460.1 108.0,460.0 C 109.0,459.9 109.5,459.9 111.0,459.8 C 112.5,459.7 115.5,459.7 117.0,459.6 C 118.5,459.6 119.0,459.5 120.0,459.5 C 121.0,459.5 122.0,459.4 123.0,459.4 C 124.0,459.4 125.0,459.4 126.0,459.4 C 127.0,459.3 128.0,459.3 129.0,459.3 C 130.0,459.3 131.0,459.2 132.0,459.1 C 133.0,459.0 134.0,459.0 135.0,458.9 C 136.0,458.7 137.0,458.4 138.0,458.0 C 139.0,457.5 140.0,456.7 141.0,456.4 C 142.0,456.1 143.0,456.2 144.0,456.2 C 145.0,456.1 146.0,456.1 147.0,456.0 C 148.0,456.0 148.5,455.9 150.0,455.9 C 151.5,455.9 154.0,455.9 156.0,455.9 C 158.0,455.8 160.5,455.8 162.0,455.7 C 163.5,455.7 164.0,455.6 165.0,455.6 C 166.0,455.6 167.0,455.5 168.0,455.5 C 169.0,455.4 170.0,455.4 171.0,455.3 C 172.0,455.3 173.0,455.3 174.0,455.3 C 175.0,455.3 175.5,455.2 177.0,455.2 C 178.5,455.2 180.5,455.1 183.0,455.1 C 185.5,455.1 189.5,455.0 192.0,455.0 C 194.5,455.0 195.0,455.0 198.0,455.0 C 201.0,454.9 207.5,454.8 210.0,454.7 C 212.5,454.6 211.5,454.7 213.0,454.6 C 214.5,454.6 216.5,454.6 219.0,454.6 C 221.5,454.5 223.0,454.5 228.0,454.4 C 233.0,454.4 245.0,454.3 249.0,454.3 C 253.0,454.2 251.0,454.2 252.0,454.2 C 253.0,454.2 253.5,454.9 255.0,454.1 C 256.5,453.3 259.5,452.6 261.0,449.3 C 262.5,445.9 263.0,436.9 264.0,434.1 C 265.0,431.3 266.0,432.9 267.0,432.4 C 268.0,432.0 269.0,431.7 270.0,431.4 C 271.0,431.1 272.0,430.9 273.0,430.7 C 274.0,430.5 275.0,430.4 276.0,430.3 C 277.0,430.2 278.0,430.0 279.0,429.9 C 280.0,429.9 281.0,430.0 282.0,429.9 C 283.0,429.8 284.0,429.5 285.0,429.4 C 286.0,429.3 287.0,429.4 288.0,429.2 C 289.0,429.1 290.0,428.7 291.0,428.5 C 292.0,428.4 293.0,428.4 294.0,428.3 C 295.0,428.2 296.0,428.0 297.0,427.9 C 298.0,427.8 299.0,427.9 300.0,427.8 C 301.0,427.8 302.0,427.7 303.0,427.6 C 304.0,427.6 305.0,427.5 306.0,427.4 C 307.0,427.4 308.0,427.4 309.0,427.3 C 310.0,427.1 311.0,426.8 312.0,426.7 C 313.0,426.5 314.0,427.3 315.0,426.2 C 316.0,425.2 317.0,421.4 318.0,420.2 C 319.0,419.0 320.0,419.2 321.0,419.0 C 322.0,418.7 323.0,419.1 324.0,418.9 C 325.0,418.7 326.0,418.3 327.0,418.0 C 328.0,417.7 329.0,417.4 330.0,416.8 C 331.0,416.3 332.0,415.1 333.0,414.4 C 334.0,413.7 335.0,413.0 336.0,412.5 C 337.0,412.0 338.0,411.6 339.0,411.3 C 340.0,411.0 341.0,410.9 342.0,410.7 C 343.0,410.6 344.0,410.6 345.0,410.5 C 346.0,410.3 347.0,410.1 348.0,410.0 C 349.0,409.8 350.0,409.9 351.0,409.8 C 352.0,409.8 353.0,409.7 354.0,409.6 C 355.0,409.4 356.0,409.5 357.0,409.0 C 358.0,408.5 359.0,407.3 360.0,406.7 C 361.0,406.1 362.0,405.9 363.0,405.5 C 364.0,405.0 365.0,405.9 366.0,404.1 C 367.0,402.3 368.0,396.7 369.0,394.5 C 370.0,392.3 371.0,392.0 372.0,391.1 C 373.0,390.1 374.0,389.6 375.0,389.0 C 376.0,388.3 377.0,387.7 378.0,387.2 C 379.0,386.7 380.0,386.3 381.0,386.0 C 382.0,385.6 383.0,385.6 384.0,385.3 C 385.0,385.1 386.0,384.8 387.0,384.4 C 388.0,384.1 389.0,383.5 390.0,383.2 C 391.0,382.9 392.0,382.9 393.0,382.6 C 394.0,382.3 395.0,381.8 396.0,381.4 C 397.0,381.1 398.0,380.7 399.0,380.5 C 400.0,380.2 401.0,379.9 402.0,379.8 C 403.0,379.6 404.0,379.5 405.0,379.4 C 406.0,379.2 407.0,379.0 408.0,378.7 C 409.0,378.5 410.0,378.3 411.0,378.1 C 412.0,377.9 413.0,377.6 414.0,377.3 C 415.0,376.9 416.0,376.2 417.0,375.9 C 418.0,375.5 419.0,375.4 420.0,375.2 C 421.0,375.0 422.0,374.9 423.0,374.8 C 424.0,374.6 425.0,374.5 426.0,374.4 C 427.0,374.3 428.0,374.1 429.0,374.0 C 430.0,373.9 431.0,374.0 432.0,373.8 C 433.0,373.7 434.0,373.4 435.0,373.1 C 436.0,372.7 437.0,372.2 438.0,371.8 C 439.0,371.4 440.0,371.0 441.0,370.7 C 442.0,370.4 443.0,370.4 444.0,370.3 C 445.0,370.1 446.0,370.0 447.0,369.7 C 448.0,369.5 449.0,368.8 450.0,368.6 C 451.0,368.3 452.0,368.4 453.0,368.3 C 454.0,368.1 455.0,367.8 456.0,367.6 C 457.0,367.3 458.0,367.2 459.0,366.9 C 460.0,366.7 461.0,366.4 462.0,366.2 C 463.0,366.0 464.0,365.9 465.0,365.7 C 466.0,365.4 467.0,365.0 468.0,364.7 C 469.0,364.4 470.0,364.3 471.0,364.0 C 472.0,363.7 473.0,363.4 474.0,363.0 C 475.0,362.7 476.0,362.4 477.0,362.1 C 478.0,361.8 479.0,361.7 480.0,361.2 C 481.0,360.8 482.0,359.7 483.0,359.3 C 484.0,358.8 485.0,358.8 486.0,358.6 C 487.0,358.5 488.0,358.5 489.0,358.4 C 490.0,358.3 491.0,358.1 492.0,357.9 C 493.0,357.8 494.0,358.0 495.0,357.6 C 496.0,357.2 497.0,355.9 498.0,355.4 C 499.0,354.9 500.0,355.0 501.0,354.7 C 502.0,354.4 503.0,353.8 504.0,353.6 C 505.0,353.4 506.0,353.5 507.0,353.3 C 508.0,353.0 509.0,352.4 510.0,352.2 C 511.0,352.0 512.0,352.0 513.0,351.9 C 514.0,351.7 515.0,351.7 516.0,351.5 C 517.0,351.2 518.0,350.9 519.0,350.3 C 520.0,349.7 521.0,348.5 522.0,347.8 C 523.0,347.2 524.0,347.0 525.0,346.5 C 526.0,346.0 527.0,346.0 528.0,345.1 C 529.0,344.2 530.0,342.3 531.0,341.3 C 532.0,340.4 533.0,340.0 534.0,339.4 C 535.0,338.8 536.0,338.7 537.0,337.9 C 538.0,337.0 539.0,335.2 540.0,334.3 C 541.0,333.5 542.0,333.3 543.0,332.8 C 544.Line truncated
+  <path d="M 90.0,462.0 C 90.5,462.0 92.5,461.6 93.0,461.5 C 94.0,461.4 95.0,461.1 96.0,461.0 C 97.0,460.8 98.0,460.5 99.0,460.4 C 100.0,460.3 101.0,460.4 102.0,460.3 C 103.0,460.3 104.0,460.2 105.0,460.2 C 106.0,460.1 107.0,460.1 108.0,460.0 C 109.0,459.9 109.5,459.9 111.0,459.8 C 112.5,459.7 115.5,459.7 117.0,459.6 C 118.5,459.6 119.0,459.5 120.0,459.5 C 121.0,459.5 122.0,459.4 123.0,459.4 C 124.0,459.4 125.0,459.4 126.0,459.4 C 127.0,459.3 128.0,459.3 129.0,459.3 C 130.0,459.3 131.0,459.2 132.0,459.1 C 133.0,459.0 134.0,459.0 135.0,458.9 C 136.0,458.7 137.0,458.4 138.0,458.0 C 139.0,457.5 140.0,456.7 141.0,456.4 C 142.0,456.1 143.0,456.2 144.0,456.2 C 145.0,456.1 146.0,456.1 147.0,456.0 C 148.0,456.0 148.5,455.9 150.0,455.9 C 151.5,455.9 154.0,455.9 156.0,455.9 C 158.0,455.8 160.5,455.8 162.0,455.7 C 163.5,455.7 164.0,455.6 165.0,455.6 C 166.0,455.6 167.0,455.5 168.0,455.5 C 169.0,455.4 170.0,455.4 171.0,455.3 C 172.0,455.3 173.0,455.3 174.0,455.3 C 175.0,455.3 175.5,455.2 177.0,455.2 C 178.5,455.2 180.5,455.1 183.0,455.1 C 185.5,455.1 189.5,455.0 192.0,455.0 C 194.5,455.0 195.0,455.0 198.0,455.0 C 201.0,454.9 207.5,454.8 210.0,454.7 C 212.5,454.6 211.5,454.7 213.0,454.6 C 214.5,454.6 216.5,454.6 219.0,454.6 C 221.5,454.5 223.0,454.5 228.0,454.4 C 233.0,454.4 245.0,454.3 249.0,454.3 C 253.0,454.2 251.0,454.2 252.0,454.2 C 253.0,454.2 253.5,454.9 255.0,454.1 C 256.5,453.3 259.5,452.6 261.0,449.3 C 262.5,445.9 263.0,436.9 264.0,434.1 C 265.0,431.3 266.0,432.9 267.0,432.4 C 268.0,432.0 269.0,431.7 270.0,431.4 C 271.0,431.1 272.0,430.9 273.0,430.7 C 274.0,430.5 275.0,430.4 276.0,430.3 C 277.0,430.2 278.0,430.0 279.0,429.9 C 280.0,429.9 281.0,430.0 282.0,429.9 C 283.0,429.8 284.0,429.5 285.0,429.4 C 286.0,429.3 287.0,429.4 288.0,429.2 C 289.0,429.1 290.0,428.7 291.0,428.5 C 292.0,428.4 293.0,428.4 294.0,428.3 C 295.0,428.2 296.0,428.0 297.0,427.9 C 298.0,427.8 299.0,427.9 300.0,427.8 C 301.0,427.8 302.0,427.7 303.0,427.6 C 304.0,427.6 305.0,427.5 306.0,427.4 C 307.0,427.4 308.0,427.4 309.0,427.3 C 310.0,427.1 311.0,426.8 312.0,426.7 C 313.0,426.5 314.0,427.3 315.0,426.2 C 316.0,425.2 317.0,421.4 318.0,420.2 C 319.0,419.0 320.0,419.2 321.0,419.0 C 322.0,418.7 323.0,419.1 324.0,418.9 C 325.0,418.7 326.0,418.3 327.0,418.0 C 328.0,417.7 329.0,417.4 330.0,416.8 C 331.0,416.3 332.0,415.1 333.0,414.4 C 334.0,413.7 335.0,413.0 336.0,412.5 C 337.0,412.0 338.0,411.6 339.0,411.3 C 340.0,411.0 341.0,410.9 342.0,410.7 C 343.0,410.6 344.0,410.6 345.0,410.5 C 346.0,410.3 347.0,410.1 348.0,410.0 C 349.0,409.8 350.0,409.9 351.0,409.8 C 352.0,409.8 353.0,409.7 354.0,409.6 C 355.0,409.4 356.0,409.5 357.0,409.0 C 358.0,408.5 359.0,407.3 360.0,406.7 C 361.0,406.1 362.0,405.9 363.0,405.5 C 364.0,405.0 365.0,405.9 366.0,404.1 C 367.0,402.3 368.0,396.7 369.0,394.5 C 370.0,392.3 371.0,392.0 372.0,391.1 C 373.0,390.1 374.0,389.6 375.0,389.0 C 376.0,388.3 377.0,387.7 378.0,387.2 C 379.0,386.7 380.0,386.3 381.0,386.0 C 382.0,385.6 383.0,385.6 384.0,385.3 C 385.0,385.1 386.0,384.8 387.0,384.4 C 388.0,384.1 389.0,383.5 390.0,383.2 C 391.0,382.9 392.0,382.9 393.0,382.6 C 394.0,382.3 395.0,381.8 396.0,381.4 C 397.0,381.1 398.0,380.7 399.0,380.5 C 400.0,380.2 401.0,379.9 402.0,379.8 C 403.0,379.6 404.0,379.5 405.0,379.4 C 406.0,379.2 407.0,379.0 408.0,378.7 C 409.0,378.5 410.0,378.3 411.0,378.1 C 412.0,377.9 413.0,377.6 414.0,377.3 C 415.0,376.9 416.0,376.2 417.0,375.9 C 418.0,375.5 419.0,375.4 420.0,375.2 C 421.0,375.0 422.0,374.9 423.0,374.8 C 424.0,374.6 425.0,374.5 426.0,374.4 C 427.0,374.3 428.0,374.1 429.0,374.0 C 430.0,373.9 431.0,374.0 432.0,373.8 C 433.0,373.7 434.0,373.4 435.0,373.1 C 436.0,372.7 437.0,372.2 438.0,371.8 C 439.0,371.4 440.0,371.0 441.0,370.7 C 442.0,370.4 443.0,370.4 444.0,370.3 C 445.0,370.1 446.0,370.0 447.0,369.7 C 448.0,369.5 449.0,368.8 450.0,368.6 C 451.0,368.3 452.0,368.4 453.0,368.3 C 454.0,368.1 455.0,367.8 456.0,367.6 C 457.0,367.3 458.0,367.2 459.0,366.9 C 460.0,366.7 461.0,366.4 462.0,366.2 C 463.0,366.0 464.0,365.9 465.0,365.7 C 466.0,365.4 467.0,365.0 468.0,364.7 C 469.0,364.4 470.0,364.3 471.0,364.0 C 472.0,363.7 473.0,363.4 474.0,363.0 C 475.0,362.7 476.0,362.4 477.0,362.1 C 478.0,361.8 479.0,361.7 480.0,361.2 C 481.0,360.8 482.0,359.7 483.0,359.3 C 484.0,358.8 485.0,358.8 486.0,358.6 C 487.0,358.5 488.0,358.5 489.0,358.4 C 490.0,358.3 491.0,358.1 492.0,357.9 C 493.0,357.8 494.0,358.0 495.0,357.6 C 496.0,357.2 497.0,355.9 498.0,355.4 C 499.0,354.9 500.0,355.0 501.0,354.7 C 502.0,354.4 503.0,353.8 504.0,353.6 C 505.0,353.4 506.0,353.5 507.0,353.3 C 508.0,353.0 509.0,352.4 510.0,352.2 C 511.0,352.0 512.0,352.0 513.0,351.9 C 514.0,351.7 515.0,351.7 516.0,351.5 C 517.0,351.2 518.0,350.9 519.0,350.3 C 520.0,349.7 521.0,348.5 522.0,347.8 C 523.0,347.2 524.0,347.0 525.0,346.5 C 526.0,346.0 527.0,346.0 528.0,345.1 C 529.0,344.2 530.0,342.3 531.0,341.3 C 532.0,340.4 533.0,340.0 534.0,339.4 C 535.0,338.8 536.0,338.7 537.0,337.9 C 538.0,337.0 539.0,335.2 540.0,334.3 C 541.0,333.5 542.0,333.3 543.0,332.8 C 544.Line truncated
+  <circle cx="765.0" cy="134.6" r="5" fill="#dd4528" stroke="#0d1117" stroke-width="2" filter="url(#xkcdify)"/>
+<text x="753.0" y="77.0" fill="#dd4528" font-size="18" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">5144</text>
   <a href="https://github.com/carsteneu/mystarhistory" target="_blank" rel="noopener"><text x="763" y="527" font-size="13" font-family="Handlee, cursive" fill="#fff" text-anchor="end">Made with carsteneu/mystarhistory</text></a>
 </svg>

docs/assets/star-history/star-history-light.svg

@@ -15,31 +15,33 @@
 <text x="50%" y="30" fill="#000" font-size="20" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Star History</text>
   <rect width="178" height="32" x="105" y="90" fill="#fff" fill-opacity="0.9" stroke="#000" stroke-width="1.5" rx="4" ry="4" filter="url(#xkcdify)"/><rect width="8" height="8" x="115" y="102" rx="2" ry="2" fill="#dd4528" filter="url(#xkcdify)"/><text x="131" y="110" fill="#000" font-size="15" font-family="Handlee, cursive" font-weight="bold">binaricat/Netcatty</text>
   <text x="85" y="468.0" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">0</text>
-  <line x1="90" y1="386.4" x2="765" y2="386.4" stroke="#eee" stroke-width="1" filter="url(#xkcdify)"/>
-  <text x="85" y="391.4" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">1K</text>
-  <line x1="90" y1="309.8" x2="765" y2="309.8" stroke="#eee" stroke-width="1" filter="url(#xkcdify)"/>
-  <text x="85" y="314.79999999999995" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">2K</text>
-  <line x1="90" y1="233.2" x2="765" y2="233.2" stroke="#eee" stroke-width="1" filter="url(#xkcdify)"/>
-  <text x="85" y="238.20000000000002" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">3K</text>
-  <line x1="90" y1="156.6" x2="765" y2="156.6" stroke="#eee" stroke-width="1" filter="url(#xkcdify)"/>
-  <text x="85" y="161.59999999999997" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">4K</text>
+  <line x1="90" y1="399.2" x2="765" y2="399.2" stroke="#eee" stroke-width="1" filter="url(#xkcdify)"/>
+  <text x="85" y="404.1666666666667" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">1K</text>
+  <line x1="90" y1="335.3" x2="765" y2="335.3" stroke="#eee" stroke-width="1" filter="url(#xkcdify)"/>
+  <text x="85" y="340.33333333333337" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">2K</text>
+  <line x1="90" y1="271.5" x2="765" y2="271.5" stroke="#eee" stroke-width="1" filter="url(#xkcdify)"/>
+  <text x="85" y="276.5" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">3K</text>
+  <line x1="90" y1="207.7" x2="765" y2="207.7" stroke="#eee" stroke-width="1" filter="url(#xkcdify)"/>
+  <text x="85" y="212.66666666666669" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">4K</text>
+  <line x1="90" y1="143.8" x2="765" y2="143.8" stroke="#eee" stroke-width="1" filter="url(#xkcdify)"/>
+  <text x="85" y="148.83333333333331" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">5K</text>
   <line x1="90" y1="80.0" x2="765" y2="80.0" stroke="#eee" stroke-width="1" filter="url(#xkcdify)"/>
-  <text x="85" y="85.0" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">5K</text>
+  <text x="85" y="85.0" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">6K</text>
   <text x="43" y="271.5" fill="#000" font-size="17" font-family="Handlee, cursive" font-weight="bold" transform="rotate(-90, 43, 271.5)">GitHub Stars</text>
   <text x="90.0" y="488" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Jan 2026</text>
-  <text x="182.3" y="488" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Feb 2026</text>
-  <text x="271.5" y="488" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Mar 2026</text>
-  <text x="370.2" y="488" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Apr 2026</text>
-  <text x="465.7" y="488" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">May 2026</text>
-  <text x="564.4" y="488" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Jun 2026</text>
-  <text x="659.9" y="488" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Jul 2026</text>
-  <text x="758.6" y="488" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Aug 2026</text>
+  <text x="177.0" y="488" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Feb 2026</text>
+  <text x="261.0" y="488" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Mar 2026</text>
+  <text x="354.0" y="488" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Apr 2026</text>
+  <text x="444.0" y="488" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">May 2026</text>
+  <text x="537.0" y="488" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Jun 2026</text>
+  <text x="627.0" y="488" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Jul 2026</text>
+  <text x="720.0" y="488" fill="#000" font-size="16" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Aug 2026</text>
   <text x="50%" y="525" fill="#000" font-size="17" font-family="Handlee, cursive" font-weight="bold" text-anchor="middle">Date</text>
   <line x1="90" y1="80" x2="90" y2="463" stroke="#222" stroke-width="2.5" filter="url(#xkcdify)"/>
   <line x1="90" y1="463" x2="765" y2="463" stroke="#222" stroke-width="2.5" filter="url(#xkcdify)"/>
-  <path d="M 90.0,461.9 C 90.5,461.7 92.7,461.3 93.2,461.2 C 94.2,461.0 95.3,460.8 96.4,460.5 C 97.4,460.3 98.5,460.0 99.6,459.9 C 100.6,459.7 101.7,459.8 102.7,459.8 C 103.8,459.7 104.9,459.7 105.9,459.6 C 107.0,459.6 108.0,459.5 109.1,459.4 C 110.2,459.3 110.7,459.2 112.3,459.2 C 113.9,459.1 117.1,459.0 118.7,458.9 C 120.2,458.9 120.8,458.8 121.8,458.8 C 122.9,458.7 124.0,458.7 125.0,458.7 C 126.1,458.7 127.1,458.7 128.2,458.6 C 129.3,458.6 130.3,458.6 131.4,458.6 C 132.5,458.5 133.5,458.4 134.6,458.3 C 135.6,458.2 136.7,458.3 137.8,458.0 C 138.8,457.8 139.9,457.4 140.9,456.9 C 142.0,456.5 143.1,455.4 144.1,455.0 C 145.2,454.7 146.2,454.9 147.3,454.8 C 148.4,454.7 149.4,454.7 150.5,454.7 C 151.6,454.6 152.1,454.5 153.7,454.5 C 155.3,454.5 157.9,454.5 160.0,454.4 C 162.2,454.4 164.8,454.3 166.4,454.3 C 168.0,454.2 168.5,454.2 169.6,454.1 C 170.7,454.1 171.7,454.0 172.8,454.0 C 173.8,453.9 174.9,453.8 176.0,453.8 C 177.0,453.8 178.1,453.8 179.2,453.7 C 180.2,453.7 180.7,453.7 182.3,453.7 C 183.9,453.6 186.0,453.5 188.7,453.5 C 191.4,453.5 195.6,453.5 198.3,453.4 C 200.9,453.4 201.4,453.4 204.6,453.3 C 207.8,453.3 214.7,453.1 217.4,453.0 C 220.0,453.0 219.0,453.0 220.5,453.0 C 222.1,452.9 224.3,452.9 226.9,452.9 C 229.6,452.9 231.2,452.8 236.5,452.7 C 241.8,452.7 254.5,452.6 258.8,452.5 C 263.0,452.5 260.9,452.5 261.9,452.4 C 263.0,452.4 263.5,453.3 265.1,452.4 C 266.7,451.4 269.9,450.6 271.5,446.5 C 273.1,442.5 273.6,431.6 274.7,428.2 C 275.7,424.8 276.8,426.8 277.9,426.2 C 278.9,425.7 280.0,425.4 281.0,425.0 C 282.1,424.7 283.2,424.4 284.2,424.2 C 285.3,423.9 286.3,423.9 287.4,423.7 C 288.5,423.6 289.5,423.3 290.6,423.2 C 291.7,423.2 292.7,423.3 293.8,423.2 C 294.8,423.1 295.9,422.8 297.0,422.6 C 298.0,422.5 299.1,422.6 300.1,422.4 C 301.2,422.2 302.3,421.7 303.3,421.6 C 304.4,421.4 305.4,421.5 306.5,421.3 C 307.6,421.2 308.6,420.9 309.7,420.8 C 310.8,420.7 311.8,420.8 312.9,420.7 C 313.9,420.7 315.0,420.6 316.1,420.5 C 317.1,420.4 318.2,420.3 319.2,420.3 C 320.3,420.2 321.4,420.2 322.4,420.0 C 323.5,419.9 324.6,419.5 325.6,419.3 C 326.7,419.1 327.7,420.1 328.8,418.8 C 329.9,417.5 330.9,413.1 332.0,411.6 C 333.0,410.1 334.1,410.3 335.2,410.1 C 336.2,409.8 337.3,410.2 338.3,410.0 C 339.4,409.8 340.5,409.3 341.5,408.9 C 342.6,408.5 343.7,408.2 344.7,407.5 C 345.8,406.7 346.8,405.4 347.9,404.6 C 349.0,403.7 350.0,402.9 351.1,402.3 C 352.1,401.6 353.2,401.2 354.3,400.8 C 355.3,400.4 356.4,400.3 357.5,400.1 C 358.5,399.9 359.6,400.0 360.6,399.8 C 361.7,399.7 362.8,399.3 363.8,399.2 C 364.9,399.1 365.9,399.1 367.0,399.0 C 368.1,399.0 369.1,398.9 370.2,398.7 C 371.2,398.6 372.3,398.6 373.4,398.0 C 374.4,397.5 375.5,396.0 376.6,395.3 C 377.6,394.6 378.7,394.4 379.7,393.8 C 380.8,393.3 381.9,394.4 382.9,392.1 C 384.0,389.9 385.0,383.2 386.1,380.6 C 387.2,378.0 388.2,377.6 389.3,376.4 C 390.4,375.3 391.4,374.7 392.5,373.9 C 393.5,373.1 394.6,372.4 395.7,371.8 C 396.7,371.2 397.8,370.7 398.8,370.3 C 399.9,369.9 401.0,369.9 402.0,369.5 C 403.1,369.2 404.2,368.9 405.2,368.5 C 406.3,368.1 407.3,367.4 408.4,367.0 C 409.5,366.7 410.5,366.7 411.6,366.3 C 412.6,366.0 413.7,365.3 414.8,364.9 C 415.8,364.4 416.9,364.1 417.9,363.7 C 419.0,363.4 420.1,363.1 421.1,362.9 C 422.2,362.7 423.3,362.6 424.3,362.4 C 425.4,362.2 426.4,361.9 427.5,361.7 C 428.6,361.4 429.6,361.2 430.7,360.9 C 431.7,360.6 432.8,360.3 433.9,359.9 C 434.9,359.4 436.0,358.6 437.1,358.2 C 438.1,357.8 439.2,357.7 440.2,357.4 C 441.3,357.2 442.4,357.1 443.4,356.9 C 444.5,356.7 445.5,356.6 446.6,356.4 C 447.7,356.3 448.7,356.1 449.8,356.0 C 450.8,355.9 451.9,356.0 453.0,355.8 C 454.0,355.6 455.1,355.2 456.2,354.8 C 457.2,354.4 458.3,353.8 459.3,353.3 C 460.4,352.8 461.5,352.3 462.5,352.0 C 463.6,351.7 464.6,351.7 465.7,351.5 C 466.8,351.3 467.8,351.2 468.9,350.9 C 470.0,350.5 471.0,349.8 472.1,349.5 C 473.1,349.2 474.2,349.3 475.3,349.1 C 476.3,348.9 477.4,348.5 478.4,348.3 C 479.5,348.0 480.6,347.8 481.6,347.5 C 482.7,347.2 483.8,346.9 484.8,346.6 C 485.9,346.4 486.9,346.3 488.0,346.0 C 489.1,345.6 490.1,345.1 491.2,344.8 C 492.2,344.5 493.3,344.3 494.4,344.0 C 495.4,343.6 496.5,343.1 497.5,342.7 C 498.6,342.3 499.7,341.9 500.7,341.6 C 501.8,341.2 502.9,341.2 503.9,340.6 C 505.0,340.0 506.0,338.7 507.1,338.2 C 508.2,337.7 509.2,337.6 510.3,337.5 C 511.3,337.3 512.4,337.3 513.5,337.1 C 514.5,337.0 515.6,336.8 516.7,336.6 C 517.7,336.5 518.8,336.7 519.8,336.2 C 520.9,335.7 522.0,334.1 523.0,333.5 C 524.1,332.9 525.1,333.0 526.2,332.6 C 527.3,332.3 528.3,331.6 529.4,331.3 C 530.4,331.0 531.5,331.2 532.6,330.9 C 533.6,330.6 534.7,329.9 535.8,329.6 C 536.8,329.3 537.9,329.3 538.9,329.2 C 540.0,329.0 541.1,329.0 542.1,328.7 C 543.2,328.4 544.2,328.0 545.3,327.3 C 546.4,326.5 547.4,325.1 548.5,324.4 C 549.6,323.6 550.6,323.3 551.7,322.7 C 552.7,322.2 553.8,322.1 554.9,321.1 C 555.9,320.0 557.0,317.7 558.0,316.5 C 559.1,315.4 560.2,314.9 561.2,314.2 C 562.3,313.5 563.3,313.4 564.4,312.3 C 565.5,311.3 566.5,309.0 567.6,308.0 C 568.7,307.0 569.7,306.9 570.8,306.3 C 571.Line truncated
-  <path d="M 90.0,461.9 C 90.5,461.7 92.7,461.3 93.2,461.2 C 94.2,461.0 95.3,460.8 96.4,460.5 C 97.4,460.3 98.5,460.0 99.6,459.9 C 100.6,459.7 101.7,459.8 102.7,459.8 C 103.8,459.7 104.9,459.7 105.9,459.6 C 107.0,459.6 108.0,459.5 109.1,459.4 C 110.2,459.3 110.7,459.2 112.3,459.2 C 113.9,459.1 117.1,459.0 118.7,458.9 C 120.2,458.9 120.8,458.8 121.8,458.8 C 122.9,458.7 124.0,458.7 125.0,458.7 C 126.1,458.7 127.1,458.7 128.2,458.6 C 129.3,458.6 130.3,458.6 131.4,458.6 C 132.5,458.5 133.5,458.4 134.6,458.3 C 135.6,458.2 136.7,458.3 137.8,458.0 C 138.8,457.8 139.9,457.4 140.9,456.9 C 142.0,456.5 143.1,455.4 144.1,455.0 C 145.2,454.7 146.2,454.9 147.3,454.8 C 148.4,454.7 149.4,454.7 150.5,454.7 C 151.6,454.6 152.1,454.5 153.7,454.5 C 155.3,454.5 157.9,454.5 160.0,454.4 C 162.2,454.4 164.8,454.3 166.4,454.3 C 168.0,454.2 168.5,454.2 169.6,454.1 C 170.7,454.1 171.7,454.0 172.8,454.0 C 173.8,453.9 174.9,453.8 176.0,453.8 C 177.0,453.8 178.1,453.8 179.2,453.7 C 180.2,453.7 180.7,453.7 182.3,453.7 C 183.9,453.6 186.0,453.5 188.7,453.5 C 191.4,453.5 195.6,453.5 198.3,453.4 C 200.9,453.4 201.4,453.4 204.6,453.3 C 207.8,453.3 214.7,453.1 217.4,453.0 C 220.0,453.0 219.0,453.0 220.5,453.0 C 222.1,452.9 224.3,452.9 226.9,452.9 C 229.6,452.9 231.2,452.8 236.5,452.7 C 241.8,452.7 254.5,452.6 258.8,452.5 C 263.0,452.5 260.9,452.5 261.9,452.4 C 263.0,452.4 263.5,453.3 265.1,452.4 C 266.7,451.4 269.9,450.6 271.5,446.5 C 273.1,442.5 273.6,431.6 274.7,428.2 C 275.7,424.8 276.8,426.8 277.9,426.2 C 278.9,425.7 280.0,425.4 281.0,425.0 C 282.1,424.7 283.2,424.4 284.2,424.2 C 285.3,423.9 286.3,423.9 287.4,423.7 C 288.5,423.6 289.5,423.3 290.6,423.2 C 291.7,423.2 292.7,423.3 293.8,423.2 C 294.8,423.1 295.9,422.8 297.0,422.6 C 298.0,422.5 299.1,422.6 300.1,422.4 C 301.2,422.2 302.3,421.7 303.3,421.6 C 304.4,421.4 305.4,421.5 306.5,421.3 C 307.6,421.2 308.6,420.9 309.7,420.8 C 310.8,420.7 311.8,420.8 312.9,420.7 C 313.9,420.7 315.0,420.6 316.1,420.5 C 317.1,420.4 318.2,420.3 319.2,420.3 C 320.3,420.2 321.4,420.2 322.4,420.0 C 323.5,419.9 324.6,419.5 325.6,419.3 C 326.7,419.1 327.7,420.1 328.8,418.8 C 329.9,417.5 330.9,413.1 332.0,411.6 C 333.0,410.1 334.1,410.3 335.2,410.1 C 336.2,409.8 337.3,410.2 338.3,410.0 C 339.4,409.8 340.5,409.3 341.5,408.9 C 342.6,408.5 343.7,408.2 344.7,407.5 C 345.8,406.7 346.8,405.4 347.9,404.6 C 349.0,403.7 350.0,402.9 351.1,402.3 C 352.1,401.6 353.2,401.2 354.3,400.8 C 355.3,400.4 356.4,400.3 357.5,400.1 C 358.5,399.9 359.6,400.0 360.6,399.8 C 361.7,399.7 362.8,399.3 363.8,399.2 C 364.9,399.1 365.9,399.1 367.0,399.0 C 368.1,399.0 369.1,398.9 370.2,398.7 C 371.2,398.6 372.3,398.6 373.4,398.0 C 374.4,397.5 375.5,396.0 376.6,395.3 C 377.6,394.6 378.7,394.4 379.7,393.8 C 380.8,393.3 381.9,394.4 382.9,392.1 C 384.0,389.9 385.0,383.2 386.1,380.6 C 387.2,378.0 388.2,377.6 389.3,376.4 C 390.4,375.3 391.4,374.7 392.5,373.9 C 393.5,373.1 394.6,372.4 395.7,371.8 C 396.7,371.2 397.8,370.7 398.8,370.3 C 399.9,369.9 401.0,369.9 402.0,369.5 C 403.1,369.2 404.2,368.9 405.2,368.5 C 406.3,368.1 407.3,367.4 408.4,367.0 C 409.5,366.7 410.5,366.7 411.6,366.3 C 412.6,366.0 413.7,365.3 414.8,364.9 C 415.8,364.4 416.9,364.1 417.9,363.7 C 419.0,363.4 420.1,363.1 421.1,362.9 C 422.2,362.7 423.3,362.6 424.3,362.4 C 425.4,362.2 426.4,361.9 427.5,361.7 C 428.6,361.4 429.6,361.2 430.7,360.9 C 431.7,360.6 432.8,360.3 433.9,359.9 C 434.9,359.4 436.0,358.6 437.1,358.2 C 438.1,357.8 439.2,357.7 440.2,357.4 C 441.3,357.2 442.4,357.1 443.4,356.9 C 444.5,356.7 445.5,356.6 446.6,356.4 C 447.7,356.3 448.7,356.1 449.8,356.0 C 450.8,355.9 451.9,356.0 453.0,355.8 C 454.0,355.6 455.1,355.2 456.2,354.8 C 457.2,354.4 458.3,353.8 459.3,353.3 C 460.4,352.8 461.5,352.3 462.5,352.0 C 463.6,351.7 464.6,351.7 465.7,351.5 C 466.8,351.3 467.8,351.2 468.9,350.9 C 470.0,350.5 471.0,349.8 472.1,349.5 C 473.1,349.2 474.2,349.3 475.3,349.1 C 476.3,348.9 477.4,348.5 478.4,348.3 C 479.5,348.0 480.6,347.8 481.6,347.5 C 482.7,347.2 483.8,346.9 484.8,346.6 C 485.9,346.4 486.9,346.3 488.0,346.0 C 489.1,345.6 490.1,345.1 491.2,344.8 C 492.2,344.5 493.3,344.3 494.4,344.0 C 495.4,343.6 496.5,343.1 497.5,342.7 C 498.6,342.3 499.7,341.9 500.7,341.6 C 501.8,341.2 502.9,341.2 503.9,340.6 C 505.0,340.0 506.0,338.7 507.1,338.2 C 508.2,337.7 509.2,337.6 510.3,337.5 C 511.3,337.3 512.4,337.3 513.5,337.1 C 514.5,337.0 515.6,336.8 516.7,336.6 C 517.7,336.5 518.8,336.7 519.8,336.2 C 520.9,335.7 522.0,334.1 523.0,333.5 C 524.1,332.9 525.1,333.0 526.2,332.6 C 527.3,332.3 528.3,331.6 529.4,331.3 C 530.4,331.0 531.5,331.2 532.6,330.9 C 533.6,330.6 534.7,329.9 535.8,329.6 C 536.8,329.3 537.9,329.3 538.9,329.2 C 540.0,329.0 541.1,329.0 542.1,328.7 C 543.2,328.4 544.2,328.0 545.3,327.3 C 546.4,326.5 547.4,325.1 548.5,324.4 C 549.6,323.6 550.6,323.3 551.7,322.7 C 552.7,322.2 553.8,322.1 554.9,321.1 C 555.9,320.0 557.0,317.7 558.0,316.5 C 559.1,315.4 560.2,314.9 561.2,314.2 C 562.3,313.5 563.3,313.4 564.4,312.3 C 565.5,311.3 566.5,309.0 567.6,308.0 C 568.7,307.0 569.7,306.9 570.8,306.3 C 571.Line truncated
-  <circle cx="765.0" cy="116.9" r="5" fill="#dd4528" stroke="#fff" stroke-width="2" filter="url(#xkcdify)"/>
-<text x="753.0" y="77.0" fill="#dd4528" font-size="18" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">4518</text>
+  <path d="M 90.0,462.0 C 90.5,462.0 92.5,461.6 93.0,461.5 C 94.0,461.4 95.0,461.1 96.0,461.0 C 97.0,460.8 98.0,460.5 99.0,460.4 C 100.0,460.3 101.0,460.4 102.0,460.3 C 103.0,460.3 104.0,460.2 105.0,460.2 C 106.0,460.1 107.0,460.1 108.0,460.0 C 109.0,459.9 109.5,459.9 111.0,459.8 C 112.5,459.7 115.5,459.7 117.0,459.6 C 118.5,459.6 119.0,459.5 120.0,459.5 C 121.0,459.5 122.0,459.4 123.0,459.4 C 124.0,459.4 125.0,459.4 126.0,459.4 C 127.0,459.3 128.0,459.3 129.0,459.3 C 130.0,459.3 131.0,459.2 132.0,459.1 C 133.0,459.0 134.0,459.0 135.0,458.9 C 136.0,458.7 137.0,458.4 138.0,458.0 C 139.0,457.5 140.0,456.7 141.0,456.4 C 142.0,456.1 143.0,456.2 144.0,456.2 C 145.0,456.1 146.0,456.1 147.0,456.0 C 148.0,456.0 148.5,455.9 150.0,455.9 C 151.5,455.9 154.0,455.9 156.0,455.9 C 158.0,455.8 160.5,455.8 162.0,455.7 C 163.5,455.7 164.0,455.6 165.0,455.6 C 166.0,455.6 167.0,455.5 168.0,455.5 C 169.0,455.4 170.0,455.4 171.0,455.3 C 172.0,455.3 173.0,455.3 174.0,455.3 C 175.0,455.3 175.5,455.2 177.0,455.2 C 178.5,455.2 180.5,455.1 183.0,455.1 C 185.5,455.1 189.5,455.0 192.0,455.0 C 194.5,455.0 195.0,455.0 198.0,455.0 C 201.0,454.9 207.5,454.8 210.0,454.7 C 212.5,454.6 211.5,454.7 213.0,454.6 C 214.5,454.6 216.5,454.6 219.0,454.6 C 221.5,454.5 223.0,454.5 228.0,454.4 C 233.0,454.4 245.0,454.3 249.0,454.3 C 253.0,454.2 251.0,454.2 252.0,454.2 C 253.0,454.2 253.5,454.9 255.0,454.1 C 256.5,453.3 259.5,452.6 261.0,449.3 C 262.5,445.9 263.0,436.9 264.0,434.1 C 265.0,431.3 266.0,432.9 267.0,432.4 C 268.0,432.0 269.0,431.7 270.0,431.4 C 271.0,431.1 272.0,430.9 273.0,430.7 C 274.0,430.5 275.0,430.4 276.0,430.3 C 277.0,430.2 278.0,430.0 279.0,429.9 C 280.0,429.9 281.0,430.0 282.0,429.9 C 283.0,429.8 284.0,429.5 285.0,429.4 C 286.0,429.3 287.0,429.4 288.0,429.2 C 289.0,429.1 290.0,428.7 291.0,428.5 C 292.0,428.4 293.0,428.4 294.0,428.3 C 295.0,428.2 296.0,428.0 297.0,427.9 C 298.0,427.8 299.0,427.9 300.0,427.8 C 301.0,427.8 302.0,427.7 303.0,427.6 C 304.0,427.6 305.0,427.5 306.0,427.4 C 307.0,427.4 308.0,427.4 309.0,427.3 C 310.0,427.1 311.0,426.8 312.0,426.7 C 313.0,426.5 314.0,427.3 315.0,426.2 C 316.0,425.2 317.0,421.4 318.0,420.2 C 319.0,419.0 320.0,419.2 321.0,419.0 C 322.0,418.7 323.0,419.1 324.0,418.9 C 325.0,418.7 326.0,418.3 327.0,418.0 C 328.0,417.7 329.0,417.4 330.0,416.8 C 331.0,416.3 332.0,415.1 333.0,414.4 C 334.0,413.7 335.0,413.0 336.0,412.5 C 337.0,412.0 338.0,411.6 339.0,411.3 C 340.0,411.0 341.0,410.9 342.0,410.7 C 343.0,410.6 344.0,410.6 345.0,410.5 C 346.0,410.3 347.0,410.1 348.0,410.0 C 349.0,409.8 350.0,409.9 351.0,409.8 C 352.0,409.8 353.0,409.7 354.0,409.6 C 355.0,409.4 356.0,409.5 357.0,409.0 C 358.0,408.5 359.0,407.3 360.0,406.7 C 361.0,406.1 362.0,405.9 363.0,405.5 C 364.0,405.0 365.0,405.9 366.0,404.1 C 367.0,402.3 368.0,396.7 369.0,394.5 C 370.0,392.3 371.0,392.0 372.0,391.1 C 373.0,390.1 374.0,389.6 375.0,389.0 C 376.0,388.3 377.0,387.7 378.0,387.2 C 379.0,386.7 380.0,386.3 381.0,386.0 C 382.0,385.6 383.0,385.6 384.0,385.3 C 385.0,385.1 386.0,384.8 387.0,384.4 C 388.0,384.1 389.0,383.5 390.0,383.2 C 391.0,382.9 392.0,382.9 393.0,382.6 C 394.0,382.3 395.0,381.8 396.0,381.4 C 397.0,381.1 398.0,380.7 399.0,380.5 C 400.0,380.2 401.0,379.9 402.0,379.8 C 403.0,379.6 404.0,379.5 405.0,379.4 C 406.0,379.2 407.0,379.0 408.0,378.7 C 409.0,378.5 410.0,378.3 411.0,378.1 C 412.0,377.9 413.0,377.6 414.0,377.3 C 415.0,376.9 416.0,376.2 417.0,375.9 C 418.0,375.5 419.0,375.4 420.0,375.2 C 421.0,375.0 422.0,374.9 423.0,374.8 C 424.0,374.6 425.0,374.5 426.0,374.4 C 427.0,374.3 428.0,374.1 429.0,374.0 C 430.0,373.9 431.0,374.0 432.0,373.8 C 433.0,373.7 434.0,373.4 435.0,373.1 C 436.0,372.7 437.0,372.2 438.0,371.8 C 439.0,371.4 440.0,371.0 441.0,370.7 C 442.0,370.4 443.0,370.4 444.0,370.3 C 445.0,370.1 446.0,370.0 447.0,369.7 C 448.0,369.5 449.0,368.8 450.0,368.6 C 451.0,368.3 452.0,368.4 453.0,368.3 C 454.0,368.1 455.0,367.8 456.0,367.6 C 457.0,367.3 458.0,367.2 459.0,366.9 C 460.0,366.7 461.0,366.4 462.0,366.2 C 463.0,366.0 464.0,365.9 465.0,365.7 C 466.0,365.4 467.0,365.0 468.0,364.7 C 469.0,364.4 470.0,364.3 471.0,364.0 C 472.0,363.7 473.0,363.4 474.0,363.0 C 475.0,362.7 476.0,362.4 477.0,362.1 C 478.0,361.8 479.0,361.7 480.0,361.2 C 481.0,360.8 482.0,359.7 483.0,359.3 C 484.0,358.8 485.0,358.8 486.0,358.6 C 487.0,358.5 488.0,358.5 489.0,358.4 C 490.0,358.3 491.0,358.1 492.0,357.9 C 493.0,357.8 494.0,358.0 495.0,357.6 C 496.0,357.2 497.0,355.9 498.0,355.4 C 499.0,354.9 500.0,355.0 501.0,354.7 C 502.0,354.4 503.0,353.8 504.0,353.6 C 505.0,353.4 506.0,353.5 507.0,353.3 C 508.0,353.0 509.0,352.4 510.0,352.2 C 511.0,352.0 512.0,352.0 513.0,351.9 C 514.0,351.7 515.0,351.7 516.0,351.5 C 517.0,351.2 518.0,350.9 519.0,350.3 C 520.0,349.7 521.0,348.5 522.0,347.8 C 523.0,347.2 524.0,347.0 525.0,346.5 C 526.0,346.0 527.0,346.0 528.0,345.1 C 529.0,344.2 530.0,342.3 531.0,341.3 C 532.0,340.4 533.0,340.0 534.0,339.4 C 535.0,338.8 536.0,338.7 537.0,337.9 C 538.0,337.0 539.0,335.2 540.0,334.3 C 541.0,333.5 542.0,333.3 543.0,332.8 C 544.Line truncated
+  <path d="M 90.0,462.0 C 90.5,462.0 92.5,461.6 93.0,461.5 C 94.0,461.4 95.0,461.1 96.0,461.0 C 97.0,460.8 98.0,460.5 99.0,460.4 C 100.0,460.3 101.0,460.4 102.0,460.3 C 103.0,460.3 104.0,460.2 105.0,460.2 C 106.0,460.1 107.0,460.1 108.0,460.0 C 109.0,459.9 109.5,459.9 111.0,459.8 C 112.5,459.7 115.5,459.7 117.0,459.6 C 118.5,459.6 119.0,459.5 120.0,459.5 C 121.0,459.5 122.0,459.4 123.0,459.4 C 124.0,459.4 125.0,459.4 126.0,459.4 C 127.0,459.3 128.0,459.3 129.0,459.3 C 130.0,459.3 131.0,459.2 132.0,459.1 C 133.0,459.0 134.0,459.0 135.0,458.9 C 136.0,458.7 137.0,458.4 138.0,458.0 C 139.0,457.5 140.0,456.7 141.0,456.4 C 142.0,456.1 143.0,456.2 144.0,456.2 C 145.0,456.1 146.0,456.1 147.0,456.0 C 148.0,456.0 148.5,455.9 150.0,455.9 C 151.5,455.9 154.0,455.9 156.0,455.9 C 158.0,455.8 160.5,455.8 162.0,455.7 C 163.5,455.7 164.0,455.6 165.0,455.6 C 166.0,455.6 167.0,455.5 168.0,455.5 C 169.0,455.4 170.0,455.4 171.0,455.3 C 172.0,455.3 173.0,455.3 174.0,455.3 C 175.0,455.3 175.5,455.2 177.0,455.2 C 178.5,455.2 180.5,455.1 183.0,455.1 C 185.5,455.1 189.5,455.0 192.0,455.0 C 194.5,455.0 195.0,455.0 198.0,455.0 C 201.0,454.9 207.5,454.8 210.0,454.7 C 212.5,454.6 211.5,454.7 213.0,454.6 C 214.5,454.6 216.5,454.6 219.0,454.6 C 221.5,454.5 223.0,454.5 228.0,454.4 C 233.0,454.4 245.0,454.3 249.0,454.3 C 253.0,454.2 251.0,454.2 252.0,454.2 C 253.0,454.2 253.5,454.9 255.0,454.1 C 256.5,453.3 259.5,452.6 261.0,449.3 C 262.5,445.9 263.0,436.9 264.0,434.1 C 265.0,431.3 266.0,432.9 267.0,432.4 C 268.0,432.0 269.0,431.7 270.0,431.4 C 271.0,431.1 272.0,430.9 273.0,430.7 C 274.0,430.5 275.0,430.4 276.0,430.3 C 277.0,430.2 278.0,430.0 279.0,429.9 C 280.0,429.9 281.0,430.0 282.0,429.9 C 283.0,429.8 284.0,429.5 285.0,429.4 C 286.0,429.3 287.0,429.4 288.0,429.2 C 289.0,429.1 290.0,428.7 291.0,428.5 C 292.0,428.4 293.0,428.4 294.0,428.3 C 295.0,428.2 296.0,428.0 297.0,427.9 C 298.0,427.8 299.0,427.9 300.0,427.8 C 301.0,427.8 302.0,427.7 303.0,427.6 C 304.0,427.6 305.0,427.5 306.0,427.4 C 307.0,427.4 308.0,427.4 309.0,427.3 C 310.0,427.1 311.0,426.8 312.0,426.7 C 313.0,426.5 314.0,427.3 315.0,426.2 C 316.0,425.2 317.0,421.4 318.0,420.2 C 319.0,419.0 320.0,419.2 321.0,419.0 C 322.0,418.7 323.0,419.1 324.0,418.9 C 325.0,418.7 326.0,418.3 327.0,418.0 C 328.0,417.7 329.0,417.4 330.0,416.8 C 331.0,416.3 332.0,415.1 333.0,414.4 C 334.0,413.7 335.0,413.0 336.0,412.5 C 337.0,412.0 338.0,411.6 339.0,411.3 C 340.0,411.0 341.0,410.9 342.0,410.7 C 343.0,410.6 344.0,410.6 345.0,410.5 C 346.0,410.3 347.0,410.1 348.0,410.0 C 349.0,409.8 350.0,409.9 351.0,409.8 C 352.0,409.8 353.0,409.7 354.0,409.6 C 355.0,409.4 356.0,409.5 357.0,409.0 C 358.0,408.5 359.0,407.3 360.0,406.7 C 361.0,406.1 362.0,405.9 363.0,405.5 C 364.0,405.0 365.0,405.9 366.0,404.1 C 367.0,402.3 368.0,396.7 369.0,394.5 C 370.0,392.3 371.0,392.0 372.0,391.1 C 373.0,390.1 374.0,389.6 375.0,389.0 C 376.0,388.3 377.0,387.7 378.0,387.2 C 379.0,386.7 380.0,386.3 381.0,386.0 C 382.0,385.6 383.0,385.6 384.0,385.3 C 385.0,385.1 386.0,384.8 387.0,384.4 C 388.0,384.1 389.0,383.5 390.0,383.2 C 391.0,382.9 392.0,382.9 393.0,382.6 C 394.0,382.3 395.0,381.8 396.0,381.4 C 397.0,381.1 398.0,380.7 399.0,380.5 C 400.0,380.2 401.0,379.9 402.0,379.8 C 403.0,379.6 404.0,379.5 405.0,379.4 C 406.0,379.2 407.0,379.0 408.0,378.7 C 409.0,378.5 410.0,378.3 411.0,378.1 C 412.0,377.9 413.0,377.6 414.0,377.3 C 415.0,376.9 416.0,376.2 417.0,375.9 C 418.0,375.5 419.0,375.4 420.0,375.2 C 421.0,375.0 422.0,374.9 423.0,374.8 C 424.0,374.6 425.0,374.5 426.0,374.4 C 427.0,374.3 428.0,374.1 429.0,374.0 C 430.0,373.9 431.0,374.0 432.0,373.8 C 433.0,373.7 434.0,373.4 435.0,373.1 C 436.0,372.7 437.0,372.2 438.0,371.8 C 439.0,371.4 440.0,371.0 441.0,370.7 C 442.0,370.4 443.0,370.4 444.0,370.3 C 445.0,370.1 446.0,370.0 447.0,369.7 C 448.0,369.5 449.0,368.8 450.0,368.6 C 451.0,368.3 452.0,368.4 453.0,368.3 C 454.0,368.1 455.0,367.8 456.0,367.6 C 457.0,367.3 458.0,367.2 459.0,366.9 C 460.0,366.7 461.0,366.4 462.0,366.2 C 463.0,366.0 464.0,365.9 465.0,365.7 C 466.0,365.4 467.0,365.0 468.0,364.7 C 469.0,364.4 470.0,364.3 471.0,364.0 C 472.0,363.7 473.0,363.4 474.0,363.0 C 475.0,362.7 476.0,362.4 477.0,362.1 C 478.0,361.8 479.0,361.7 480.0,361.2 C 481.0,360.8 482.0,359.7 483.0,359.3 C 484.0,358.8 485.0,358.8 486.0,358.6 C 487.0,358.5 488.0,358.5 489.0,358.4 C 490.0,358.3 491.0,358.1 492.0,357.9 C 493.0,357.8 494.0,358.0 495.0,357.6 C 496.0,357.2 497.0,355.9 498.0,355.4 C 499.0,354.9 500.0,355.0 501.0,354.7 C 502.0,354.4 503.0,353.8 504.0,353.6 C 505.0,353.4 506.0,353.5 507.0,353.3 C 508.0,353.0 509.0,352.4 510.0,352.2 C 511.0,352.0 512.0,352.0 513.0,351.9 C 514.0,351.7 515.0,351.7 516.0,351.5 C 517.0,351.2 518.0,350.9 519.0,350.3 C 520.0,349.7 521.0,348.5 522.0,347.8 C 523.0,347.2 524.0,347.0 525.0,346.5 C 526.0,346.0 527.0,346.0 528.0,345.1 C 529.0,344.2 530.0,342.3 531.0,341.3 C 532.0,340.4 533.0,340.0 534.0,339.4 C 535.0,338.8 536.0,338.7 537.0,337.9 C 538.0,337.0 539.0,335.2 540.0,334.3 C 541.0,333.5 542.0,333.3 543.0,332.8 C 544.Line truncated
+  <circle cx="765.0" cy="134.6" r="5" fill="#dd4528" stroke="#fff" stroke-width="2" filter="url(#xkcdify)"/>
+<text x="753.0" y="77.0" fill="#dd4528" font-size="18" font-family="Handlee, cursive" font-weight="bold" text-anchor="end">5144</text>
   <a href="https://github.com/carsteneu/mystarhistory" target="_blank" rel="noopener"><text x="763" y="527" font-size="13" font-family="Handlee, cursive" fill="#000" text-anchor="end">Made with carsteneu/mystarhistory</text></a>
 </svg>

domain/activeKeyBindings.test.ts

@@ -0,0 +1,68 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  findActiveSystemShortcutConflict,
+  listActiveSystemBindings,
+} from './activeKeyBindings.ts';
+import { DEFAULT_KEY_BINDINGS, type KeyBinding } from './models/keyBindings.ts';
+
+const withBindingOverride = (
+  id: string,
+  override: Partial<Pick<KeyBinding, 'mac' | 'pc'>>,
+): KeyBinding[] => (
+  DEFAULT_KEY_BINDINGS.map((binding) => (
+    binding.id === id ? { ...binding, ...override } : binding
+  ))
+);
+
+test('disabled scheme exposes no active system bindings', () => {
+  assert.deepEqual(listActiveSystemBindings('disabled', DEFAULT_KEY_BINDINGS), []);
+});
+
+test('disabled scheme does not treat default tab or broadcast keys as occupied', () => {
+  assert.equal(
+    findActiveSystemShortcutConflict('Ctrl + 1', 'disabled', DEFAULT_KEY_BINDINGS),
+    null,
+  );
+  assert.equal(
+    findActiveSystemShortcutConflict('Ctrl + B', 'disabled', DEFAULT_KEY_BINDINGS),
+    null,
+  );
+  assert.equal(
+    findActiveSystemShortcutConflict('⌘ + 1', 'disabled', DEFAULT_KEY_BINDINGS),
+    null,
+  );
+});
+
+test('pc scheme reports the tab-switch binding for Ctrl+1', () => {
+  const conflict = findActiveSystemShortcutConflict('Ctrl + 1', 'pc', DEFAULT_KEY_BINDINGS);
+
+  assert.equal(conflict?.id, 'switch-tab-1-9');
+});
+
+test('pc scheme reports the broadcast binding for Ctrl+B', () => {
+  const conflict = findActiveSystemShortcutConflict('Ctrl + B', 'pc', DEFAULT_KEY_BINDINGS);
+
+  assert.equal(conflict?.id, 'broadcast');
+});
+
+test('mac scheme does not treat Ctrl+1 as a tab shortcut', () => {
+  assert.equal(
+    findActiveSystemShortcutConflict('Ctrl + 1', 'mac', DEFAULT_KEY_BINDINGS),
+    null,
+  );
+});
+
+test('mac scheme reports the tab-switch binding for Cmd+1', () => {
+  const conflict = findActiveSystemShortcutConflict('⌘ + 1', 'mac', DEFAULT_KEY_BINDINGS);
+
+  assert.equal(conflict?.id, 'switch-tab-1-9');
+});
+
+test('a Disabled individual binding is not a conflict', () => {
+  const bindings = withBindingOverride('switch-tab-1-9', { pc: 'Disabled' });
+
+  assert.equal(findActiveSystemShortcutConflict('Ctrl + 1', 'pc', bindings), null);
+  assert.equal(findActiveSystemShortcutConflict('Ctrl + B', 'pc', bindings)?.id, 'broadcast');
+});

domain/activeKeyBindings.ts

@@ -0,0 +1,52 @@
+import {
+  type HotkeyScheme,
+  type KeyBinding,
+  keyStringToKeyboardEvent,
+  matchesKeyBinding,
+} from './models/keyBindings.ts';
+
+export type ActiveSystemBinding = {
+  binding: KeyBinding;
+  key: string;
+  isMac: boolean;
+};
+
+/** App shortcuts that can actually fire for the current scheme. */
+export const listActiveSystemBindings = (
+  hotkeyScheme: HotkeyScheme,
+  keyBindings: readonly KeyBinding[],
+): ActiveSystemBinding[] => {
+  if (hotkeyScheme === 'disabled') return [];
+
+  return keyBindings.flatMap((binding) => {
+    if (hotkeyScheme === 'mac') {
+      return binding.mac && binding.mac !== 'Disabled'
+        ? [{ binding, key: binding.mac, isMac: true }]
+        : [];
+    }
+
+    if (hotkeyScheme === 'pc') {
+      return binding.pc && binding.pc !== 'Disabled'
+        ? [{ binding, key: binding.pc, isMac: false }]
+        : [];
+    }
+
+    return [];
+  });
+};
+
+export const findActiveSystemShortcutConflict = (
+  key: string,
+  hotkeyScheme: HotkeyScheme,
+  keyBindings: readonly KeyBinding[],
+): KeyBinding | null => {
+  if (!key) return null;
+
+  const event = keyStringToKeyboardEvent(key);
+  if (!event) return null;
+
+  const conflict = listActiveSystemBindings(hotkeyScheme, keyBindings).find((entry) => (
+    matchesKeyBinding(event, entry.key, entry.isMac)
+  ));
+  return conflict?.binding ?? null;
+};

domain/models.test.ts

@@ -1,7 +1,7 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
 
-import { keyEventToString, matchesKeyBinding, tabShortcutDigitFromEvent } from './models.ts';
+import { keyEventToString, keyStringToKeyboardEvent, matchesKeyBinding, tabShortcutDigitFromEvent } from './models.ts';
 
 const keyboardEvent = (
   key: string,
@@ -74,3 +74,17 @@ test('tab shortcut digit falls back to e.key when code is missing', () => {
   assert.equal(tabShortcutDigitFromEvent({ key: '3', code: '' }), 3);
   assert.equal(tabShortcutDigitFromEvent({ key: '!', code: '' }), null);
 });
+
+test('stored shortcut strings rebuild matching keyboard events', () => {
+  const event = keyStringToKeyboardEvent('Ctrl + 1');
+  assert.ok(event);
+  assert.equal(event.key, '1');
+  assert.equal(event.ctrlKey, true);
+  assert.equal(matchesKeyBinding(event, 'Ctrl + [1...9]', false), true);
+
+  const macEvent = keyStringToKeyboardEvent('⌘ + B');
+  assert.ok(macEvent);
+  assert.equal(macEvent.key, 'b');
+  assert.equal(macEvent.metaKey, true);
+  assert.equal(matchesKeyBinding(macEvent, '⌘ + B', true), true);
+});

domain/models/keyBindings.ts

@@ -21,6 +21,38 @@ export const parseKeyCombo = (keyStr: string): { modifiers: string[]; key: strin
   return { modifiers: parts, key };
 };
 
+const KEY_STRING_TO_EVENT_KEY: Record<string, string> = {
+  Space: ' ',
+  '↑': 'ArrowUp',
+  '↓': 'ArrowDown',
+  '←': 'ArrowLeft',
+  '→': 'ArrowRight',
+  Esc: 'Escape',
+  '⌫': 'Backspace',
+  Del: 'Delete',
+  '↵': 'Enter',
+  '⇥': 'Tab',
+};
+
+/** Rebuild a keydown-like event from a stored shortcut string for matching. */
+export const keyStringToKeyboardEvent = (keyString: string): KeyboardEvent | null => {
+  const parsed = parseKeyCombo(keyString);
+  if (!parsed) return null;
+
+  const modifiers = new Set(parsed.modifiers);
+  const mappedKey = KEY_STRING_TO_EVENT_KEY[parsed.key];
+  const key = mappedKey ?? (parsed.key.length === 1 ? parsed.key.toLowerCase() : parsed.key);
+
+  return {
+    key,
+    code: '',
+    metaKey: modifiers.has('⌘') || modifiers.has('Win'),
+    ctrlKey: modifiers.has('⌃') || modifiers.has('Ctrl'),
+    altKey: modifiers.has('⌥') || modifiers.has('Alt'),
+    shiftKey: modifiers.has('Shift'),
+  } as KeyboardEvent;
+};
+
 const PHYSICAL_SHORTCUT_KEY_NAMES: Record<string, string> = {
   Backquote: '`',
   Minus: '-',

domain/settingsSearchCatalog.ts

@@ -813,6 +813,14 @@ export const SETTINGS_SEARCH_CATALOG: readonly SettingsSearchEntry[] = [
     labelKey: "settings.system.crashLogs.title",
     descriptionKey: "settings.system.crashLogs.description",
   },
+  {
+    id: "system-startup-landing",
+    tab: "system",
+    labelKey: "settings.sessionRestore.startupLanding",
+    descriptionKey: "settings.sessionRestore.startupLandingDesc",
+    sectionKey: "settings.sessionRestore.title",
+    keywords: ["startup", "launch", "local terminal", "home"],
+  },
   {
     id: "system-session-restore",
     tab: "system",

domain/sftpStatError.test.ts

@@ -0,0 +1,22 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { isMissingStatError } from "./sftpStatError";
+
+test("isMissingStatError recognizes ssh2 and Electron-wrapped absence", () => {
+  assert.equal(isMissingStatError(new Error("No such file")), true);
+  assert.equal(
+    isMissingStatError(
+      new Error("Error invoking remote method 'netcatty:sftp:lstat': Error: No such file"),
+    ),
+    true,
+  );
+});
+
+test("isMissingStatError does not treat path substrings as absence", () => {
+  assert.equal(
+    isMissingStatError(
+      new Error("EACCES: permission denied, lstat '/private/enoent/report.txt'"),
+    ),
+    false,
+  );
+});

domain/sftpStatError.ts

@@ -0,0 +1,30 @@
+const ELECTRON_INVOKE_PREFIX = /^error invoking remote method '[^']+': error:\s*/i;
+
+/** ssh2 / Node / SCP absence kinds. Must not search the whole message: paths are user-controlled. */
+const ABSENCE_KIND = /^(?:enoent|no such file(?: or directory)?|no_such_file|ssh_fx_no_such_file)(?:\b|:|$)/;
+
+const unwrapStatErrorMessage = (message: string): string =>
+  message.replace(ELECTRON_INVOKE_PREFIX, "").trim();
+
+/** True absence only — ENOTSUP / unknown inspection must not map to "no conflict". */
+export const isMissingStatError = (error: unknown): boolean => {
+  const code = (error as { code?: string | number } | null)?.code;
+  if (
+    code === 2
+    || code === "ENOENT"
+    || code === "NO_SUCH_FILE"
+    || code === "SSH_FX_NO_SUCH_FILE"
+  ) {
+    return true;
+  }
+
+  const message = String((error as { message?: string } | null)?.message || "")
+    .trim()
+    .toLowerCase();
+  if (!message) return false;
+
+  // ssh2 StatusCodeError is "No such file". ipcRenderer.invoke strips `code`
+  // and wraps it as:
+  // Error invoking remote method 'netcatty:sftp:lstat': Error: No such file
+  return ABSENCE_KIND.test(unwrapStatErrorMessage(message));
+};

domain/startupLanding.test.ts

@@ -0,0 +1,68 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  DEFAULT_STARTUP_LANDING,
+  isStartupLanding,
+  resolveStartupLandingSetting,
+  shouldOpenLocalTerminalOnStartup,
+} from './startupLanding.ts';
+
+test('startup landing defaults to vault', () => {
+  assert.equal(DEFAULT_STARTUP_LANDING, 'vault');
+  assert.equal(resolveStartupLandingSetting(null), 'vault');
+  assert.equal(resolveStartupLandingSetting(undefined), 'vault');
+  assert.equal(resolveStartupLandingSetting('nope'), 'vault');
+});
+
+test('startup landing accepts stored values', () => {
+  assert.equal(isStartupLanding('vault'), true);
+  assert.equal(isStartupLanding('local-terminal'), true);
+  assert.equal(isStartupLanding('sftp'), false);
+  assert.equal(resolveStartupLandingSetting('vault'), 'vault');
+  assert.equal(resolveStartupLandingSetting('local-terminal'), 'local-terminal');
+});
+
+test('should open local terminal only for empty main-window cold start', () => {
+  assert.equal(
+    shouldOpenLocalTerminalOnStartup({
+      startupLanding: 'local-terminal',
+      hasRestoredSessionState: false,
+      isPeerSessionWindow: false,
+    }),
+    true,
+  );
+  assert.equal(
+    shouldOpenLocalTerminalOnStartup({
+      startupLanding: 'vault',
+      hasRestoredSessionState: false,
+      isPeerSessionWindow: false,
+    }),
+    false,
+  );
+  assert.equal(
+    shouldOpenLocalTerminalOnStartup({
+      startupLanding: 'local-terminal',
+      hasRestoredSessionState: true,
+      isPeerSessionWindow: false,
+    }),
+    false,
+  );
+  assert.equal(
+    shouldOpenLocalTerminalOnStartup({
+      startupLanding: 'local-terminal',
+      hasRestoredSessionState: false,
+      isPeerSessionWindow: true,
+    }),
+    false,
+  );
+  assert.equal(
+    shouldOpenLocalTerminalOnStartup({
+      startupLanding: 'local-terminal',
+      hasRestoredSessionState: false,
+      isPeerSessionWindow: false,
+      hasQueuedStartupIntent: true,
+    }),
+    false,
+  );
+});

domain/startupLanding.ts

@@ -0,0 +1,34 @@
+/**
+ * App startup landing preference (Settings → System).
+ *
+ * - `vault` (default): open the home / host picker
+ * - `local-terminal`: open a local terminal when there is nothing to restore
+ */
+export type StartupLanding = 'vault' | 'local-terminal';
+
+export const DEFAULT_STARTUP_LANDING: StartupLanding = 'vault';
+
+export function isStartupLanding(value: unknown): value is StartupLanding {
+  return value === 'vault' || value === 'local-terminal';
+}
+
+export function resolveStartupLandingSetting(stored: string | null | undefined): StartupLanding {
+  return isStartupLanding(stored) ? stored : DEFAULT_STARTUP_LANDING;
+}
+
+/**
+ * Whether the main window should create a local terminal on cold start.
+ * Session restore, peer/new windows, and queued startup launch intents
+ * (ssh/telnet/jms deep links, Explorer "open terminal here") take precedence.
+ */
+export function shouldOpenLocalTerminalOnStartup(input: {
+  startupLanding: StartupLanding;
+  hasRestoredSessionState: boolean;
+  isPeerSessionWindow: boolean;
+  hasQueuedStartupIntent?: boolean;
+}): boolean {
+  if (input.isPeerSessionWindow) return false;
+  if (input.hasRestoredSessionState) return false;
+  if (input.hasQueuedStartupIntent) return false;
+  return input.startupLanding === 'local-terminal';
+}

electron/bridges/ai/ptyExec.cjs

@@ -18,6 +18,7 @@ const {
   subscribeToPtyData,
   hasExpectedPromptSuffix,
   resolveEffectiveShellKind,
+  buildPendingInputClearPrefix,
   buildWrappedCommand,
   findEndMarker,
   normalizePtyOutput,
@@ -581,7 +582,8 @@ function startPtyJob(ptyStream, command, options) {
     }
   }
 
-  ptyStream.write(buildWrappedCommand(command, resolvedShellKind, marker));
+  const wrapped = buildWrappedCommand(command, resolvedShellKind, marker);
+  ptyStream.write(`${buildPendingInputClearPrefix(resolvedShellKind)}${wrapped}`);
 
   return {
     marker,

electron/bridges/ai/ptyExec.test.cjs

@@ -12,15 +12,18 @@ const {
   DEFAULT_FOREGROUND_PTY_CAPTURE_CHARS,
   resolveEffectiveShellKind,
   execViaChannel,
+  execViaRawPty,
 } = require("./ptyExec.cjs");
 const {
+  buildPendingInputClearPrefix,
   buildWrappedCommand,
 } = require("./ptyExecHelpers.cjs");
 
 class ShellBackedPty extends EventEmitter {
   write(data) {
     if (data === "\x03") return;
-    const result = spawnSync("sh", ["-c", String(data)], { encoding: "utf8" });
+    const script = String(data).replace(/^\x15\x0b/, "");
+    const result = spawnSync("sh", ["-c", script], { encoding: "utf8" });
     queueMicrotask(() => {
       this.emit("data", Buffer.from(result.stdout));
     });
@@ -324,6 +327,53 @@ test("loginShellHint selects fish/posix/powershell/cmd without pinning confirmed
   );
 });
 
+test("pending-input clear prefix covers interactive shells and skips raw devices", () => {
+  assert.equal(buildPendingInputClearPrefix("posix"), "\x15\x0b");
+  assert.equal(buildPendingInputClearPrefix("fish"), "\x15\x0b");
+  assert.equal(buildPendingInputClearPrefix("powershell"), "\x1b\x15\x0b");
+  assert.equal(buildPendingInputClearPrefix("cmd"), "\x1b");
+  assert.equal(buildPendingInputClearPrefix("raw"), "");
+});
+
+test("startPtyJob writes the clear prefix before the wrapper", async () => {
+  const writes = [];
+  class CapturePty extends EventEmitter {
+    write(data) {
+      writes.push(String(data));
+    }
+  }
+  const pty = new CapturePty();
+  const job = startPtyJob(pty, "echo hi", {
+    shellKind: "posix",
+    timeoutMs: 50,
+    expectedPrompt: "$ ",
+  });
+  assert.equal(writes.length, 1);
+  assert.ok(writes[0].startsWith("\x15\x0b"));
+  assert.match(writes[0], /__NCMCP_/);
+  job.cancel();
+  pty.emit("data", Buffer.from("$ "));
+  await job.resultPromise;
+});
+
+test("execViaRawPty does not prepend a line-clear before device commands", async () => {
+  const writes = [];
+  const port = new EventEmitter();
+  port.write = (data) => {
+    writes.push(String(data));
+  };
+  const abort = new AbortController();
+  const resultPromise = execViaRawPty(port, "show version", {
+    timeoutMs: 200,
+    idleMs: 20,
+    abortSignal: abort.signal,
+  });
+  assert.deepEqual(writes, ["show version\r"]);
+  abort.abort();
+  const result = await resultPromise;
+  assert.equal(result.ok, false);
+});
+
 test("cmd wrapper uses interactive cmd variable expansion", () => {
   const wrapped = buildWrappedCommand("ipconfig /all", "cmd", "__NCMCP_TEST__");
   assert.match(wrapped, /"%__NCMCP_TEST___CMD%"/);