docs: record final native input compatibility acceptance

application/i18n/locales/en/vault.ts

@@ -975,6 +975,9 @@ export const enVaultMessages: Messages = {
   'hostDetails.sshTimeouts.tcpConnect.desc': 'Seconds to wait for the network connection to this host.',
   'hostDetails.sshTimeouts.authReady': 'SSH auth timeout',
   'hostDetails.sshTimeouts.authReady.desc': 'Seconds to wait after connecting for SSH negotiation and authentication to finish.',
+  'hostDetails.sshInputCompatibility': 'Input compatibility: send character by character',
+  'hostDetails.sshInputCompatibility.desc': 'Try enabling this if Chinese input or short pastes lose characters.',
+  'hostDetails.sshInputCompatibility.reconnect': 'Saved changes take effect after reconnecting.',
   'hostDetails.backspaceBehavior': 'Backspace Behavior',
   'hostDetails.backspaceBehavior.default': 'Default',
   'hostDetails.jumpHosts': 'Proxy via Hosts',

application/i18n/locales/es/vault.ts

@@ -965,6 +965,9 @@ export const esVaultMessages: Messages = {
   '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.sshInputCompatibility': 'Compatibilidad de entrada: enviar carácter por carácter',
+  'hostDetails.sshInputCompatibility.desc': 'Actívalo si se pierden caracteres al escribir chino o pegar textos cortos.',
+  'hostDetails.sshInputCompatibility.reconnect': 'Los cambios guardados se aplican al volver a conectar.',
   'hostDetails.backspaceBehavior': 'Comportamiento de la tecla Retroceso',
   'hostDetails.backspaceBehavior.default': 'Predeterminado',
   'hostDetails.jumpHosts': 'Proxy mediante hosts',

application/i18n/locales/ru/vault.ts

@@ -1014,6 +1014,9 @@ export const ruVaultMessages: Messages = {
   'hostDetails.sshTimeouts.tcpConnect.desc': 'Сколько секунд ждать сетевого подключения к этому хосту.',
   'hostDetails.sshTimeouts.authReady': 'Тайм-аут SSH-входа',
   'hostDetails.sshTimeouts.authReady.desc': 'Сколько секунд ждать согласования SSH и завершения аутентификации после подключения.',
+  'hostDetails.sshInputCompatibility': 'Совместимость ввода: отправка по символам',
+  'hostDetails.sshInputCompatibility.desc': 'Включите, если при вводе китайского текста или короткой вставке теряются символы.',
+  'hostDetails.sshInputCompatibility.reconnect': 'Сохранённые изменения применяются после повторного подключения.',
   'hostDetails.backspaceBehavior': 'Поведение Backspace',
   'hostDetails.backspaceBehavior.default': 'По умолчанию',
   'hostDetails.jumpHosts': 'Прокси через хосты',

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

@@ -384,6 +384,9 @@ export const zhCNVaultMessages: Messages = {
   'hostDetails.sshTimeouts.tcpConnect.desc': '等待与该主机建立网络连接的最长时间。',
   'hostDetails.sshTimeouts.authReady': '认证超时（秒）',
   'hostDetails.sshTimeouts.authReady.desc': '网络连接建立后，等待 SSH 协商和认证完成的最长时间。',
+  'hostDetails.sshInputCompatibility': '输入兼容模式：逐字发送',
+  'hostDetails.sshInputCompatibility.desc': '中文输入或短粘贴出现丢字时尝试开启。',
+  'hostDetails.sshInputCompatibility.reconnect': '保存后重新连接生效。',
   'hostDetails.backspaceBehavior': 'Backspace 行为',
   'hostDetails.backspaceBehavior.default': '默认',
   'hostDetails.jumpHosts': '通过主机代理',

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

@@ -384,6 +384,9 @@ export const zhTWVaultMessages: Messages = {
   'hostDetails.sshTimeouts.tcpConnect.desc': '等待與該主機建立網路連線的最長時間。',
   'hostDetails.sshTimeouts.authReady': '驗證逾時（秒）',
   'hostDetails.sshTimeouts.authReady.desc': '網路連線建立後，等待 SSH 交握和驗證完成的最長時間。',
+  'hostDetails.sshInputCompatibility': '輸入相容模式：逐字傳送',
+  'hostDetails.sshInputCompatibility.desc': '中文輸入或短貼上出現漏字時嘗試開啟。',
+  'hostDetails.sshInputCompatibility.reconnect': '儲存後重新連線生效。',
   'hostDetails.backspaceBehavior': 'Backspace 行為',
   'hostDetails.backspaceBehavior.default': '預設',
   'hostDetails.jumpHosts': '透過主機代理',

application/state/useVaultState.inputCompatibility.test.ts

@@ -0,0 +1,108 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import React from "react";
+import { act, create, type ReactTestRenderer } from "react-test-renderer";
+import { JSDOM } from "jsdom";
+import { installBrowserLockFixture } from "../testSupport/browserLockFixture";
+import type { Host } from "../../domain/models";
+import { STORAGE_KEY_HOSTS } from "../../infrastructure/config/storageKeys";
+
+// Exercise actual vault save/load/JSON import and sync boundaries, including
+// the asynchronous encrypted-field adapter (without a native safeStorage key).
+test("host input choices survive save, restart, duplicate, backup and cloud sync", async () => {
+  const dom = new JSDOM("", { url: "http://localhost" });
+  const globals = ["window", "localStorage", "CustomEvent", "IS_REACT_ACT_ENVIRONMENT", "navigator"];
+  const previous = new Map(globals.map(key => [key, Object.getOwnPropertyDescriptor(globalThis, key)]));
+  Object.defineProperties(globalThis, {
+    window: { value: dom.window, configurable: true },
+    localStorage: { value: dom.window.localStorage, configurable: true },
+    CustomEvent: { value: dom.window.CustomEvent, configurable: true },
+    IS_REACT_ACT_ENVIRONMENT: { value: true, configurable: true },
+  });
+  installBrowserLockFixture();
+  const { useVaultState } = await import("./useVaultState");
+  const { buildSyncPayload, applySyncPayload, buildLocalVaultPayload, applyLocalVaultPayload } = await import("../syncPayload");
+  const { buildVaultHostFromDraft } = await import("../../domain/vaultHostCreate");
+  const legacy: Host = { id: "legacy", label: "Legacy", hostname: "localhost", username: "agent", protocol: "ssh", tags: [], os: "linux" };
+  dom.window.localStorage.setItem(STORAGE_KEY_HOSTS, JSON.stringify([legacy]));
+  let state: ReturnType<typeof useVaultState>;
+  let renderer: ReactTestRenderer | undefined;
+  const Probe = () => { state = useVaultState({ syncConnectionLogTerminalData: false }); return null; };
+  const mount = async () => {
+    await act(async () => { renderer = create(React.createElement(Probe)); });
+    for (let attempt = 0; !state!.isInitialized && attempt < 50; attempt++) {
+      await act(async () => { await new Promise(resolve => setTimeout(resolve, 10)); });
+    }
+    assert.equal(state!.isInitialized, true);
+    await act(async () => { await state!.readPersistedHosts(); });
+  };
+  const choices = () => state!.hosts.map(host => [host.id, host.sshInputCompatibility]);
+  try {
+    await mount();
+    assert.deepEqual(choices(), [["legacy", true]]);
+    const created = buildVaultHostFromDraft({ hostname: "new.example.test", username: "agent" });
+    if (created.ok === false) throw Error(created.error);
+    assert.equal(created.ok, true);
+    const standard = { ...created.host, id: "standard" };
+    await act(async () => { await state!.updateHosts([...state!.hosts, standard]); });
+    assert.deepEqual(choices(), [["legacy", true], ["standard", false]]);
+    const duplicate = { ...state!.hosts[0], id: "copy", label: "Legacy copy" };
+    await act(async () => { await state!.updateHosts([...state!.hosts, duplicate]); });
+    await act(async () => { renderer!.unmount(); });
+    await mount();
+    assert.deepEqual(choices(), [["legacy", true], ["standard", false], ["copy", true]]);
+    // A later deliberate false must survive migration, including another boot.
+    await act(async () => { await state!.updateHosts(state!.hosts.map(host => host.id === "legacy" ? { ...host, sshInputCompatibility: false } : host)); });
+    const expected = [["legacy", false], ["standard", false], ["copy", true]];
+    const exported = JSON.stringify(state!.exportData());
+    await act(async () => { await state!.updateHosts([]); await state!.importDataFromString(exported); });
+    assert.deepEqual(choices(), expected);
+    // Use the real sync payload builder and apply importer, not JSON alone.
+    const cloud = JSON.parse(JSON.stringify(buildSyncPayload({ ...state!.exportData(), identities: state!.identities, knownHosts: state!.knownHosts })));
+    await act(async () => { await state!.updateHosts([]); await applySyncPayload(cloud, { importVaultData: state!.importDataFromString }); });
+    assert.deepEqual(choices(), expected);
+    const backup = JSON.parse(JSON.stringify(buildLocalVaultPayload({ ...state!.exportData(), identities: state!.identities, knownHosts: state!.knownHosts })));
+    await act(async () => { await state!.updateHosts([]); await applyLocalVaultPayload(backup, { importVaultData: state!.importDataFromString }); });
+    assert.deepEqual(choices(), expected);
+    await act(async () => { renderer!.unmount(); });
+    await mount();
+    assert.deepEqual(choices(), expected);
+    assert.deepEqual((await state!.readPersistedHosts()).map(host => [host.id, host.sshInputCompatibility]), expected);
+    // Older cloud snapshots enter through the same per-record migration.
+    cloud.hosts = [{ ...legacy, id: "cloud-legacy" }];
+    await act(async () => { await applySyncPayload(cloud, { importVaultData: state!.importDataFromString }); });
+    assert.deepEqual(choices(), [["cloud-legacy", true]]);
+    await act(async () => { await state!.updateHosts(state!.hosts.map(host => ({ ...host, sshInputCompatibility: false }))); });
+    await act(async () => { renderer!.unmount(); });
+    await mount();
+    assert.deepEqual(choices(), [["cloud-legacy", false]]);
+    // These drafts enter HostDetailsPanel as initialData, then the real vault
+    // save/normalization path. They must not be mistaken for legacy records.
+    const { buildSshDeepLinkHostDraft, parseSshDeepLink } = await import("../../domain/sshDeepLink");
+    const { normalizePluginImporterRecords } = await import("../../domain/pluginImporter");
+    const linkDraft = buildSshDeepLinkHostDraft(parseSshDeepLink("ssh://agent@new.test")!, { id: "new-link", now: 1 });
+    const imported = normalizePluginImporterRecords([undefined, false, true].map(choice => ({
+      type: "draft" as const, draft: { kind: "host" as const, value: {
+        hostname: `import-${choice}.test`, protocol: "ssh",
+        ...(choice === undefined ? {} : { sshInputCompatibility: choice }),
+      } },
+    })));
+    assert.deepEqual(imported.errors, []);
+    const explicitCopy = { ...imported.hosts[2], id: "copy-explicit-input" };
+    const drafts = [linkDraft, ...imported.hosts, explicitCopy];
+    const draftChoices = drafts.map(host => [host.id, host.sshInputCompatibility]);
+    assert.deepEqual(drafts.map(host => host.sshInputCompatibility), [false, false, false, true, true]);
+    await act(async () => { await state!.updateHosts([...state!.hosts, ...drafts]); });
+    await act(async () => { renderer!.unmount(); });
+    await mount();
+    assert.deepEqual(choices(), [["cloud-legacy", false], ...draftChoices]);
+  } finally {
+    await act(async () => { renderer?.unmount(); });
+    dom.window.close();
+    for (const key of globals) {
+      const descriptor = previous.get(key);
+      if (descriptor) Object.defineProperty(globalThis, key, descriptor);
+      else Reflect.deleteProperty(globalThis, key);
+    }
+  }
+});

application/state/useVaultState.ts

@@ -1570,6 +1570,7 @@ export const useVaultState = (options?: UseVaultStateOptions) => {
       group: "",
       tags: [],
       protocol: "ssh",
+      sshInputCompatibility: false,
       order: getNextVaultOrder(hosts),
     };
 

components/HostDetailsAdvancedSections.tsx

@@ -503,6 +503,19 @@ export const HostDetailsAdvancedSections: React.FC<HostDetailsAdvancedSectionsPr
             enabled={!!form.showLineTimestamps}
             onToggle={() => update("showLineTimestamps", !form.showLineTimestamps)}
           />
+          {(form.protocol === undefined || form.protocol === "ssh") && !form.moshEnabled && !form.etEnabled && (
+            <>
+              <ToggleRow
+                label={t("hostDetails.sshInputCompatibility")}
+                hint={t("hostDetails.sshInputCompatibility.desc")}
+                enabled={form.sshInputCompatibility ?? true}
+                onToggle={() => update("sshInputCompatibility", !(form.sshInputCompatibility ?? true))}
+              />
+              <p className="text-xs text-muted-foreground">
+                {t("hostDetails.sshInputCompatibility.reconnect")}
+              </p>
+            </>
+          )}
           <HostDetailsSettingRow label={t("hostDetails.backspaceBehavior")}>
             <Select
               value={form.backspaceBehavior ?? "default"}

components/HostDetailsPanel.tsx

@@ -182,6 +182,7 @@ const HostDetailsPanel: React.FC<HostDetailsPanelPropsWithResize> = ({
         os: "linux",
         authMethod: undefined,
         authPolicyVersion: 1,
+        sshInputCompatibility: false,
         charset: groupDefaults?.charset ? undefined : "UTF-8",
         distroMode: "auto",
         createdAt: Date.now(),

components/Terminal.tsx

@@ -4063,7 +4063,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
         return;
       }
       finishReconnectPreparation();
-      xtermRuntimeRef.current?.resetKittyConnectionInputState();
+      xtermRuntimeRef.current?.resetConnectionInputState(host);
       resetKittyKeyboardModeStateForSession(terminalSettingsRef);
       if (effectiveTerminalProtocol.startsWith("plugin:")) {
         sessionStarters.startPluginConnection(term);

components/terminal/localTerminalHibernate.test.ts

@@ -34,7 +34,7 @@ test("local terminals stay out of hibernate and hidden-renderer paths", () => {
 test("reconnect clears keyboard pairing before resetting protocol state", () => {
   assert.match(
     terminalSource,
-    /startNewSession = \(\) => \{[\s\S]*resetKittyConnectionInputState\(\);[\s\S]*resetKittyKeyboardModeStateForSession/,
+    /startNewSession = \(\) => \{[\s\S]*resetConnectionInputState\(host\);[\s\S]*resetKittyKeyboardModeStateForSession/,
   );
   assert.match(
     runtimeSource,
@@ -42,7 +42,7 @@ test("reconnect clears keyboard pairing before resetting protocol state", () =>
   );
   assert.match(
     runtimeSource,
-    /resetKittyConnectionInputState: clearKittyConnectionInputState/,
+    /resetConnectionInputState: \(host\) => \{[\s\S]*clearKittyConnectionInputState\(\)/,
   );
   assert.match(
     runtimeSource,

components/terminal/runtime/createXTermRuntime.test.ts

@@ -985,13 +985,12 @@ test("multi-character plain text goes out as per-character writes (#3077)", asyn
   const { readFileSync } = await import("node:fs");
   const source = readFileSync(new URL("./createXTermRuntime.ts", import.meta.url), "utf8");
 
-  // Strict bastion prompts (QAX) treat one channel write as one keystroke and
-  // drop multi-character chunks, so IME commits and short raw pastes must be
-  // sent one character per write instead of one write per commit.
+  // The legacy workaround selected IME commits and short raw pastes (#3077).
+  // Host settings now gate that selection at the shared send boundary.
   assert.match(source, /perCharacterWrites\?: boolean/);
   assert.match(
     source,
-    /getTextInputWireChunks\(outData, options\?\.perCharacterWrites === true\)/,
+    /getTextInputWireChunks\(outData, usePerCharacterInput && options\?\.perCharacterWrites === true, \(ctx\.host\.protocol === undefined \|\| ctx\.host\.protocol === "ssh"\) && !ctx\.host\.moshEnabled && !ctx\.host\.etEnabled\)/,
   );
   // Every chunk carries the same write options as the original single write.
   const writeLoopIdx = source.indexOf("for (const chunk of getTextInputWireChunks(outData");

components/terminal/runtime/createXTermRuntime.ts

@@ -252,6 +252,9 @@ type TerminalBackendApi = {
 // renderer hibernation. Weak ownership keeps negotiated keyboard state alive
 // for that session without introducing a process-wide session registry.
 const kittyKeyboardStates = createKittyKeyboardSessionStateStore();
+// The same session-owned ref also keeps the connection's input choice alive
+// when hibernation destroys xterm. Only a real reconnect refreshes this choice.
+const inputCompatibilityStates = new WeakMap<object, boolean>();
 
 const resolveKittyKeyboardModeState = (
   ctx: Pick<
@@ -307,8 +310,8 @@ export type XTermRuntime = {
    * terminal reset or FIFO eviction.
    */
   hasInlineImages: () => boolean;
-  /** Clear local/per-target keyboard state before reusing this runtime. */
-  resetKittyConnectionInputState: () => void;
+  /** Reset keyboard state and snapshot endpoint settings for a fresh connection. */
+  resetConnectionInputState: (host: Host) => void;
   /** Emit any owed releases before detaching or closing this renderer. */
   flushKittyKeyboardReleases: () => void;
   /** Transfer negotiated keyboard state across renderer attach handoffs. */
@@ -515,6 +518,13 @@ export const createXTermRuntime = (ctx: CreateXTermRuntimeContext): XTermRuntime
   const rendererType = settings?.rendererType ?? "auto";
   const bridge = netcattyBridge.get();
   const isLocalTerminalHost = ctx.host.protocol === "local";
+  // Capture the terminal endpoint's choice for this connection, never a chain hop.
+  const usesPerCharacterInput = (host: Host) =>
+    (host.protocol !== undefined && host.protocol !== "ssh") || host.moshEnabled === true
+    || host.etEnabled === true || host.sshInputCompatibility === true;
+  let usePerCharacterInput = inputCompatibilityStates.get(ctx.terminalSettingsRef)
+    ?? usesPerCharacterInput(ctx.host);
+  inputCompatibilityStates.set(ctx.terminalSettingsRef, usePerCharacterInput);
   const windowsPty =
     platform === "win32" && isLocalTerminalHost
       ? bridge?.getWindowsPtyInfo?.() ?? { backend: "conpty" as const }
@@ -1325,10 +1335,9 @@ export const createXTermRuntime = (ctx: CreateXTermRuntimeContext): XTermRuntime
       lineDelayMs?: number;
       pasteRequestId?: string;
       /**
-       * Send plain text as one write per character. Strict bastion prompts
-       * (QAX) treat one channel write as a keystroke and drop multi-character
-       * chunks, so IME commits and short raw pastes must go out per
-       * character (#3077). Bookkeeping still sees the whole payload once.
+       * Request the legacy IME/short-paste workaround reported in #3077.
+       * The SSH host's compatibility choice gates the final writes below.
+       * Bookkeeping still sees the whole payload once.
        */
       perCharacterWrites?: boolean;
     },
@@ -1550,7 +1559,7 @@ export const createXTermRuntime = (ctx: CreateXTermRuntimeContext): XTermRuntime
         }
 
         ctx.onOutputTriggerUserInputRef?.current?.(outData);
-        for (const chunk of getTextInputWireChunks(outData, options?.perCharacterWrites === true)) {
+        for (const chunk of getTextInputWireChunks(outData, usePerCharacterInput && options?.perCharacterWrites === true, (ctx.host.protocol === undefined || ctx.host.protocol === "ssh") && !ctx.host.moshEnabled && !ctx.host.etEnabled)) {
           ctx.terminalBackend.writeToSession(id, chunk, {
             sensitive,
             serialEraseChar,
@@ -3140,7 +3149,7 @@ export const createXTermRuntime = (ctx: CreateXTermRuntimeContext): XTermRuntime
       broadcastLegacyDataPending = null;
     }
     // Raw multi-character onData is an unbracketed paste (or a committed
-    // composition): short plain text must reach strict bastions per character.
+    // composition): selected short plain text can use compatibility writes.
     // Decide on the sanitized payload so removed zero-width characters cannot
     // keep a qualifying paste above the split cap (#3138).
     const sanitizedRawData = sanitizeTerminalInput(data);
@@ -3479,7 +3488,11 @@ export const createXTermRuntime = (ctx: CreateXTermRuntimeContext): XTermRuntime
       ligatures.apply(enabled);
     },
     hasInlineImages,
-    resetKittyConnectionInputState: clearKittyConnectionInputState,
+    resetConnectionInputState: (host) => {
+      usePerCharacterInput = usesPerCharacterInput(host);
+      inputCompatibilityStates.set(ctx.terminalSettingsRef, usePerCharacterInput);
+      clearKittyConnectionInputState();
+    },
     flushKittyKeyboardReleases: clearKittyTransientInputState,
     getKittyKeyboardModeState: () => snapshotKittyKeyboardModeState(kittyKeyboardMode),
     restoreKittyKeyboardModeState: (state) => restoreKittyKeyboardModeState(

components/terminal/runtime/serialInputSequences.test.ts

@@ -27,7 +27,7 @@ for (const prefix of ['fresh','empty-arrow','submit','paste-submit','interrupt',
  const session={encoding, serialPort:{write(data: string | Buffer){for(const byte of Buffer.from(data)) { if(byte===127||byte===8) wire=wire.subarray(0,Math.max(0,wire.length-1)); else wire=Buffer.concat([wire,Buffer.from([byte])]);}}}};
  bridge.init({sessions:new Map([['s',session]]),electronModule:{}});
  const ctx={host:{protocol:'serial',id:'h',label:'h'},sessionId:'s',sessionRef:{current:'s'},statusRef:{current:'connected'},commandBufferRef:{current:''},onBroadcastInputRef:{current:null},isBroadcastEnabledRef:{current:false},terminalBackend:{writeToSession(id:string,data:string,opts: {serialEraseChar?: string; sensitive?: boolean}){bridge.writeToSession({}, {sessionId:id,data,...opts})}},serialByteOrientedBackspace:true,serialLocalEcho:false};
- const env={...Object.assign({},...modules),api: undefined as unknown as {handleTerminalInputData: (data: string) => void; recordSerialSnippetInput: (data: string) => void},ctx,term:{buffer:{active:{cursorX:0,cursorY:0,baseY:0,getLine:()=>undefined}},cols:80},suppressNextTerminalDataBroadcast:false,handlingKittyBroadcast:false,shouldBroadcastTerminalUserInput:()=>false,prioritizeTerminalInput:()=>{},getFlowControllerForTerm:()=>null,shouldSuppressTerminalInputScrollForUserPaste:()=>true,shouldOverrideTerminalUserPasteSensitivity:()=>false,scrollToBottomAfterInput:()=>{},writeLocalTerminalData:()=>{}};
+ const env={usePerCharacterInput:true,...Object.assign({},...modules),api: undefined as unknown as {handleTerminalInputData: (data: string) => void; recordSerialSnippetInput: (data: string) => void},ctx,term:{buffer:{active:{cursorX:0,cursorY:0,baseY:0,getLine:()=>undefined}},cols:80},suppressNextTerminalDataBroadcast:false,handlingKittyBroadcast:false,shouldBroadcastTerminalUserInput:()=>false,prioritizeTerminalInput:()=>{},getFlowControllerForTerm:()=>null,shouldSuppressTerminalInputScrollForUserPaste:()=>true,shouldOverrideTerminalUserPasteSensitivity:()=>false,scrollToBottomAfterInput:()=>{},writeLocalTerminalData:()=>{}};
  vm.runInNewContext(code,env); const {handleTerminalInputData:input,recordSerialSnippetInput:snippet}=env.api;
  if(prefix==='empty-arrow') input('\x1b[D');
  if(prefix==='submit') {input('旧');input('\x1b[D');input('\r');}

components/terminal/runtime/sshInputCompatibility.integration.test.ts

@@ -0,0 +1,171 @@
+import assert from "node:assert/strict";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { buildSync } from "esbuild";
+import { JSDOM } from "jsdom";
+
+// Real xterm + runtime input callbacks; canvas measurement is stubbed because
+// these assertions concern writes, not rendering or a native OS input method.
+test("SSH host mode gates every interactive text entry and stays fixed until reconnect", async () => {
+  const root = fileURLToPath(new URL("../../..", import.meta.url));
+  const bundle = buildSync({
+    stdin: {
+      contents: 'export {createXTermRuntime} from "./components/terminal/runtime/createXTermRuntime"; export {DEFAULT_TERMINAL_SETTINGS} from "./domain/models/terminal"; export {dispatchTerminalLinePaste} from "./components/terminal/runtime/terminalUserPaste"; export {wakeTerminalFromHibernate} from "./components/terminal/terminalRuntimeMount";',
+      loader: "ts", resolveDir: root,
+    },
+    bundle: true, format: "iife", globalName: "runtimeTest", platform: "browser", write: false,
+    alias: {
+      "node:diagnostics_channel": path.join(root, "infrastructure/shims/nodeDiagnosticsChannel.ts"),
+      "diagnostics_channel": path.join(root, "infrastructure/shims/nodeDiagnosticsChannel.ts"),
+    },
+    define: { "import.meta.env.DEV": "false", "import.meta.env.PROD": "true", "import.meta": "{}" },
+  }).outputFiles[0].text;
+  const dom = new JSDOM("<body/>", { url: "http://localhost", runScripts: "outside-only", pretendToBeVisual: true });
+  Object.assign(dom.window, { structuredClone });
+  try {
+    dom.window.eval(`
+      window.matchMedia = () => ({matches:false,addListener(){},removeListener(){},addEventListener(){},removeEventListener(){}});
+      window.ResizeObserver = window.IntersectionObserver = class {observe(){} unobserve(){} disconnect(){}};
+      HTMLCanvasElement.prototype.getContext = function(type) {
+        if (type !== '2d') return null;
+        return new Proxy({canvas:this,measureText:()=>({width:8,fontBoundingBoxAscent:12,fontBoundingBoxDescent:3}),
+          getImageData:()=>({data:new Uint8ClampedArray(4)}),createLinearGradient:()=>({addColorStop(){}})},
+          {get:(target,key)=>key in target ? target[key] : ()=>{}});
+      };
+    `);
+    dom.window.eval(bundle);
+    const result = await dom.window.eval(`(async () => {
+      const {createXTermRuntime, DEFAULT_TERMINAL_SETTINGS, dispatchTerminalLinePaste, wakeTerminalFromHibernate} = runtimeTest;
+      const ref = current => ({current});
+      const panes = [];
+      const make = host => {
+        const el = document.createElement('div'); document.body.appendChild(el);
+        const writes = [], logical = [], broadcasts = [];
+        const context = {
+          container:el, host, getHost:()=>host,
+          fontFamilyId:'jetbrains-mono', resolvedFontFamily:'monospace', fontSize:14,
+          terminalTheme:{colors:{background:'#111111',foreground:'#eeeeee',cursor:'#ffffff',selection:'#444444'}},
+          terminalSettingsRef:ref({...DEFAULT_TERMINAL_SETTINGS,rendererType:'dom',fontLigatures:false,cursorBlink:false}),
+          terminalBackend:{writeToSession:(_,data)=>writes.push(data),resizeSession(){},openExternalAvailable:false},
+          sessionRef:ref(host.id),hotkeySchemeRef:ref('disabled'),disableTerminalFontZoomRef:ref(false),
+          keyBindingsRef:ref([]),onHotkeyActionRef:ref(undefined),isBroadcastEnabledRef:ref(true),
+          onBroadcastInputRef:ref(data=>{broadcasts.push(data);return [];}),
+          onOutputTriggerUserInputRef:ref(data=>logical.push(data)),
+          sessionId:host.id,statusRef:ref('connected'),commandBufferRef:ref(''),requestSearchFocus(){},
+          kittyKeyboardProtocolEnabled:true,
+        };
+        const runtime = createXTermRuntime(context);
+        const pane={...runtime,writes,logical,broadcasts,context,el}; panes.push(pane); return pane;
+      };
+      const equal = (actual, expected, label) => {
+        if (JSON.stringify(actual) !== JSON.stringify(expected)) throw Error(label+': '+JSON.stringify({actual,expected}));
+      };
+      const wait = () => new Promise(resolve=>setTimeout(resolve,20));
+      const check = (pane, text, split, label) => {
+        equal(pane.writes.splice(0),split ? Array.from(text) : [text],label);
+        equal(pane.logical.splice(0),[text],label+' logical payload once');
+        pane.broadcasts.length=0;
+      };
+      const hosts=[false,true].map((mode,index)=>({id:'mode-'+index,label:'Mode',hostname:'localhost',protocol:'ssh',sshInputCompatibility:mode}));
+      const metrics=[];
+      for (const host of hosts) {
+        const pane=make(host), term=pane.term, ta=term.textarea, mode=host.sshInputCompatibility;
+        for (const text of ['中文','👩🏽‍💻é','x'.repeat(32),'x'.repeat(33)]) {
+          term.paste(text); check(pane,text,mode && Array.from(text).length<=32,'raw paste '+mode);
+        }
+        ta.dispatchEvent(new InputEvent('input',{bubbles:true,inputType:'insertText',data:'中国'}));
+        check(pane,'中国',mode,'insertText');
+        const longIme='中'.repeat(40);
+        ta.dispatchEvent(new InputEvent('input',{bubbles:true,inputType:'insertText',data:longIme}));
+        check(pane,longIme,mode,'IME keeps its uncapped scope');
+        ta.dispatchEvent(new KeyboardEvent('keydown',{bubbles:true,keyCode:229,key:'Process'}));
+        ta.dispatchEvent(new InputEvent('input',{bubbles:true,inputType:'insertText',data:'中文'}));
+        check(pane,'中文',mode,'IME 229 insertText');
+        ta.dispatchEvent(new CompositionEvent('compositionstart',{bubbles:true,data:''}));
+        ta.value='中文';
+        ta.dispatchEvent(new CompositionEvent('compositionupdate',{bubbles:true,data:'中文'}));
+        ta.dispatchEvent(new CompositionEvent('compositionend',{bubbles:true,data:'中文'}));
+        await wait(); check(pane,'中文',mode,'compositionend');
+        // xterm's composition fallback reaches onData independently of insertText.
+        ta.dispatchEvent(new CompositionEvent('compositionstart',{bubbles:true,data:''}));
+        term.input('中国',true); check(pane,'中国',mode,'composition onData fallback');
+        ta.dispatchEvent(new CompositionEvent('compositionend',{bubbles:true,data:''})); await wait();
+        pane.writes.length=0; pane.logical.length=0;
+        for (const data of ['\\x1b[A','\\x03','\\x03\\x04','\\x1b[0;;200u']) {
+          term.input(data,true); check(pane,data,false,'terminal control');
+        }
+        await new Promise(resolve=>term.write('\\x1b[?2004h',resolve));
+        term.paste('中文'); check(pane,'\\x1b[200~中文\\x1b[201~',false,'bracketed paste');
+        await new Promise(resolve=>term.write('\\x1b[?2004l',resolve));
+        dispatchTerminalLinePaste(term,'中文\\r',{lineDelayMs:1,sensitive:false});
+        equal(pane.writes.splice(0),['中文\\r'],'existing line-paste path stays intact');
+        pane.logical.length=0;
+        await new Promise(resolve=>term.write('\\x1b[>25u',resolve));
+        ta.dispatchEvent(new InputEvent('input',{bubbles:true,inputType:'insertText',data:'中文'}));
+        const kittyWrites=pane.writes.splice(0);
+        equal(kittyWrites,['\\x1b[0;;20013:25991u'],'Kitty associated text stays in one transport write');
+        pane.logical.length=0;
+        await new Promise(resolve=>term.write('\\x1b[<u',resolve));
+        host.sshInputCompatibility=!mode;
+        term.paste('中文'); check(pane,'中文',mode,'save does not change active runtime');
+        // The app reconnects with the existing runtime, so exercise that reset too.
+        pane.resetConnectionInputState(host);
+        term.paste('中文'); check(pane,'中文',!mode,'existing runtime reconnect');
+        pane.dispose();
+        const reconnected=make(host);
+        reconnected.term.paste('中文'); check(reconnected,'中文',!mode,'reconnect reads saved mode');
+        metrics.push({mode,entryPoints:5,reconnectedMode:!mode});
+      }
+      // Exercise the actual wake entry that recreates xterm but only reattaches
+      // the existing backend. Its context contains the newly saved host record.
+      for (const mode of [false,true]) {
+        const connectedHost={id:'hibernate-'+mode,label:'Hibernate',hostname:'127.0.0.1',protocol:'ssh',sshInputCompatibility:mode};
+        const savedHost={...connectedHost,sshInputCompatibility:!mode};
+        let pane=make(connectedHost), reattached=0;
+        const wake = async old => {
+          old.dispose();
+          const refs={xtermRuntimeRef:ref(null),termRef:ref(null),fitAddonRef:ref(null),
+            serializeAddonRef:ref(null),searchAddonRef:ref(null),hasRuntimeRef:ref(false)};
+          const context={...old.context,host:savedHost};
+          const success=await wakeTerminalFromHibernate({
+            refs,runtimeContext:context,container:old.el,
+            getPayload:()=>({snapshot:'',alternateScreen:false,pendingBuffer:''}),
+            prepareWakeFlow:async()=>true,takePendingBuffer:()=>'',
+            stopHibernateDataListener(){},stopHibernateListeners(){},
+            reattachSession(){reattached++;},safeFit(){},resizeSession(){},forceSyncRenderAfterResize(){},
+            lastFittedSizeRef:ref(null),isBootActiveRef:ref(false),sessionId:connectedHost.id,updateStatus(){},
+          });
+          equal(success,true,'hibernate wake succeeds');
+          equal(context.sessionRef.current,connectedHost.id,'hibernate retains backend session');
+          const next={...refs.xtermRuntimeRef.current,context,el:old.el,
+            writes:old.writes,logical:old.logical,broadcasts:old.broadcasts};
+          panes.push(next); next.writes.length=0; next.logical.length=0; return next;
+        };
+        pane=await wake(pane);
+        pane.term.paste('中文');check(pane,'中文',mode,'wake retains connection-time mode');
+        pane.resetConnectionInputState(savedHost);
+        pane.term.paste('中文');check(pane,'中文',!mode,'real reconnect refreshes mode after wake');
+        pane=await wake(pane);
+        pane.term.paste('中文');check(pane,'中文',!mode,'next wake retains refreshed connection mode');
+        equal(reattached,2,'both wakes reattach the existing backend');
+      }
+      // The SSH-only field cannot change other transports' existing policy.
+      for (const protocol of ['local','telnet','serial','mosh','et','ssh-mosh','ssh-et']) {
+        const pane=make({id:'other-'+protocol,label:protocol,hostname:'127.0.0.1',
+          protocol:protocol.startsWith('ssh-')?'ssh':protocol,
+          moshEnabled:protocol==='ssh-mosh',etEnabled:protocol==='ssh-et',sshInputCompatibility:false});
+        pane.term.paste('中文'); check(pane,'中文',true,protocol+' retains legacy short paste');
+        pane.term.input('a\\rb',true); check(pane,'a\\rb',true,protocol+' retains legacy control-containing text');
+      }
+      for (const pane of panes) { try {pane.dispose();} catch {} }
+      return JSON.stringify(metrics);
+    })()`);
+    assert.deepEqual(JSON.parse(result), [
+      { mode: false, entryPoints: 5, reconnectedMode: true },
+      { mode: true, entryPoints: 5, reconnectedMode: false },
+    ]);
+  } finally {
+    dom.window.close();
+  }
+});

components/terminal/runtime/terminalInterceptorInputSafety.test.ts

@@ -42,7 +42,7 @@ test("password-prompt input is classified before prompt state reset and cannot b
   );
   assert.match(
     runtimeSource,
-    /for \(const chunk of getTextInputWireChunks\(outData, options\?\.perCharacterWrites === true\)\) \{\s*ctx\.terminalBackend\.writeToSession\(id, chunk, \{\s*sensitive,\s*serialEraseChar,[\s\S]*?\}\);\s*\}/u,
+    /for \(const chunk of getTextInputWireChunks\(outData, usePerCharacterInput && options\?\.perCharacterWrites === true, \(ctx\.host\.protocol === undefined \|\| ctx\.host\.protocol === "ssh"\) && !ctx\.host\.moshEnabled && !ctx\.host\.etEnabled\)\) \{\s*ctx\.terminalBackend\.writeToSession\(id, chunk, \{\s*sensitive,\s*serialEraseChar,[\s\S]*?\}\);\s*\}/u,
   );
   assert.match(
     runtimeSource,

components/terminal/runtime/terminalLinePaste.test.ts

@@ -127,6 +127,7 @@ for (const [protocol, lineMode, sensitive] of [
         ? { isWrapped: false, translateToString: () => liveLine } : undefined } },
     };
     const env = {
+    usePerCharacterInput: true,
       ...Object.assign({}, ...helpers), ...userPaste, ctx, term, crypto, isPluginHostProtocol: () => false, logger: { warn() {} },
       netcattyBridge: { get: () => ({ onTerminalPasteWrite: (listener: typeof receiptListener) => { receiptListener = listener; return () => { receiptListener = undefined; }; } }) },
       suppressNextTerminalDataBroadcast: false, handlingKittyBroadcast: false,
@@ -341,6 +342,7 @@ test("bypassed sensitive line paste keeps the paced fan-out with sourceSensitive
     buffer: { active: { cursorX: 0, cursorY: 0, baseY: 0, getLine: () => undefined } },
   };
   const env = {
+    usePerCharacterInput: true,
     ...Object.assign({}, ...helpers), ...userPaste, ctx, term, crypto, isPluginHostProtocol: () => false, logger: { warn() {} },
     netcattyBridge: { get: () => ({ onTerminalPasteWrite: (listener: typeof receiptListener) => { receiptListener = listener; return () => { receiptListener = undefined; }; } }) },
     suppressNextTerminalDataBroadcast: false, handlingKittyBroadcast: false,

components/terminal/runtime/terminalPerCharacterInput.test.ts

@@ -66,4 +66,20 @@ test("wire chunking honors the per-character request only for plain text", () =>
   assert.deepEqual(getTextInputWireChunks("\x1b[200~ab\x1b[201~", true), [
     "\x1b[200~ab\x1b[201~",
   ]);
-});
+});
+
+test("compatibility preserves exact Unicode byte order and keeps terminal controls intact", () => {
+  for (const text of ["中文", "👩🏽‍💻", "e\u0301", "क्‍ष"]) {
+    assert.deepEqual(Buffer.from(getTextInputWireChunks(text, true).join("")), Buffer.from(text));
+  }
+  for (const data of ["\x03", "\x1b[A", "\x1b[200~中文\x1b[201~", "\x1b[0;;200u", "\x03\x04", "a\r\nb"]) {
+    assert.deepEqual(getTextInputWireChunks(data, true, true), [data]);
+  }
+});
+
+
+test("non-SSH callers retain legacy control-containing text chunking", () => {
+  assert.equal(shouldSplitRawPasteInputForWire("a\rb"), true);
+  assert.deepEqual(getTextInputWireChunks("a\rb", true), ["a", "\r", "b"]);
+  assert.deepEqual(getTextInputWireChunks("a\rb", true, true), ["a\rb"]);
+});

components/terminal/runtime/terminalPerCharacterInput.ts

@@ -1,13 +1,16 @@
 /**
- * Strict bastion prompts (e.g. QAX/奇安信) treat one SSH channel write as a
- * single keystroke and silently drop every multi-character chunk (#3077). IME
- * commits and short raw pastes therefore have to leave the renderer as
- * per-character writes, which is what typing produces and what Xshell does.
+ * Legacy workaround introduced by #3168 after #3077 reported that individual
+ * hanzi worked where multi-character input did not. The remote parser and
+ * other terminals' default send behavior were not verified. SSH sessions now
+ * select this workaround in their host settings.
  */
 
 /** Raw pastes longer than this keep the single-write behavior. */
 export const MAX_RAW_PASTE_PER_CHARACTER_LENGTH = 32;
 
+// Terminal control bytes are intentional: never fragment shortcuts or reports.
+// eslint-disable-next-line no-control-regex
+const TERMINAL_CONTROL = /[\x00-\x1f\x7f-\x9f]/;
 const ESC = "\x1b";
 
 /** True while the payload only carries plain text and no escape sequence. */
@@ -16,7 +19,7 @@ export const isPlainTerminalInputText = (data: string): boolean => !data.include
 /** One chunk per Unicode code point so surrogate pairs stay intact. */
 export const splitTextIntoCodePointWrites = (data: string): string[] => Array.from(data);
 
-/** IME commits: any plain text with more than one character splits per glyph. */
+/** IME commits: any plain text with more than one character splits per code point. */
 export const shouldSplitImeTextInputForWire = (text: string): boolean =>
   Array.from(text).length > 1 && isPlainTerminalInputText(text);
 
@@ -35,11 +38,13 @@ export const shouldSplitRawPasteInputForWire = (data: string): boolean => {
   return true;
 };
 
-/** Chunks to write for one input payload; escape sequences are never split. */
+/** Escape sequences never split. SSH callers also preserve terminal controls. */
 export const getTextInputWireChunks = (
   data: string,
   perCharacterWrites: boolean,
+  preserveTerminalControls = false,
 ): string[] =>
   perCharacterWrites && isPlainTerminalInputText(data)
+    && !(preserveTerminalControls && TERMINAL_CONTROL.test(data))
     ? splitTextIntoCodePointWrites(data)
     : [data];

docs/ssh-input-compatibility.md

@@ -0,0 +1,79 @@
+# SSH input compatibility
+
+The host advanced settings include **输入兼容模式：逐字发送** (input compatibility: send character by character). The help text is **中文输入或短粘贴出现丢字时尝试开启。** Saved changes take effect after reconnecting.
+
+New SSH hosts use standard mode. Compatibility mode retains the interactive text workaround introduced by [PR #3168](https://github.com/binaricat/Netcatty/pull/3168):
+
+- Literal IME commits with multiple Unicode code points use separate writes.
+- Plain, unbracketed pastes of at most 32 Unicode code points use separate writes.
+- Longer raw pastes, bracketed pastes, Kitty associated text, and the existing confirmed line-paste path retain their current transport behavior.
+- Terminal controls stay together. Unicode code points retain their byte order, including combining marks and emoji sequences.
+
+The setting belongs to the terminal endpoint host. A host used only as an SSH network jump does not supply the target's input setting. Other transports retain their existing input behavior. Automated commands, connect scripts, and SFTP do not use this setting.
+
+## Stored records
+
+`Host.sshInputCompatibility` stores the choice as a boolean. `sanitizeHost` migrates an SSH record with a missing field to `true`, including records whose omitted protocol means SSH. It preserves explicit `false` and `true` values on every subsequent load, import, and save. The existing vault normalization and persistence paths save the migrated value. No global migration marker or new storage key is required.
+
+New host creation paths save `false`. Duplicates copy the source value. JSON vault backups and cloud sync retain the field. CSV exports include `SshInputCompatibility`; imports accept `true` and `false`. External imports without that column create standard-mode hosts.
+
+The connection captures the host's setting under its session-owned terminal settings ref. This snapshot survives xterm disposal and the actual hibernate wake/reattach path. Reconnect refreshes the setting through `resetConnectionInputState(host)`, including reconnects that reuse the existing runtime.
+
+## Historical evidence
+
+[Issue #3077](https://github.com/binaricat/Netcatty/issues/3077#issuecomment-5433744875) reports that individual hanzi worked in a Qianxin search prompt where multi-character input failed. The report also says Windows with Xshell worked. Those observations do not establish the remote parser's SSH-write semantics or Xshell's default implementation.
+
+The [Xshell 7 manual](https://cdn.netsarang.net/docs/Xshell7_manual.pdf), section 5.2.21, printed page 27, describes session paste character delay, line delay, and prompt waiting. [SecureCRT's echo flow control tip](https://www.vandyke.com/support/tips/echoflowctrl.html) describes a session line delay and an optional script that waits for each line's echo. These references support configurable send compatibility. They do not establish default per-character IME sends or equivalence to a Qianxin-specific fix. This feature adds no delays or echo waiting.
+
+## Verification boundaries
+
+`sshInputCompatibility.integration.test.ts` runs real xterm and `createXTermRuntime` callbacks under JSDOM. It covers raw paste, literal `insertText`, key code 229, composition events, composition fallback, long IME text, terminal controls, bracketed paste, Kitty text, reconnect with a reused runtime, and the actual `wakeTerminalFromHibernate` entry after a saved setting changes. Local, Telnet, serial, Mosh, and Eternal Terminal cases verify that the SSH field leaves their legacy text and control-containing payload behavior unchanged. Canvas measurement is stubbed. These tests do not exercise native input methods or application windows.
+
+`useVaultState.inputCompatibility.test.ts` exercises the actual vault hook's asynchronous save, reload, duplicate, JSON backup, local backup payload, and cloud payload apply paths. It uses test localStorage and no native safeStorage key. CSV and endpoint selection have separate round-trip and jump-host tests.
+
+## Isolated OpenSSH timing fixture
+
+The implementation-side fixture connected to an owned OpenSSH server on `127.0.0.1:22379` using public-key authentication. It executed `cat` without a PTY because the unprivileged daemon could not allocate one. Production IME/raw-paste selectors and the code-point chunker supplied an `ssh2` client's `channel.write` calls. This fixture did not include native GUI events, renderer IPC, clipboard handling, or an OS input method.
+
+Each sample used 15 consecutive repetitions per mode on the same ready SSH channel. Standard mode ran before compatibility mode for each sample; the modes were not randomized or interleaved. Authentication, command startup, selector evaluation, and chunk-array construction finished before timing. Each repetition started immediately before its first `channel.write` call and ended after the awaited receive-length condition resolved: the client's echo buffer contained at least the expected UTF-8 byte length. The complete received buffer was then compared byte-for-byte with the input, outside the timer. No artificial send delay was added.
+
+The table reports milliseconds. Median is the eighth sorted observation. P95 uses nearest rank, which is the largest of 15 observations here. Every repetition in all six tested sample pairs preserved the exact input bytes.
+
+| Sample | UTF-8 bytes | Client writes, standard / compatibility | Echo median, standard / compatibility | Echo P95, standard / compatibility |
+|---|---:|---:|---:|---:|
+| `中文输入` (IME selector) | 12 | 1 / 4 | 47.439 / 44.572 | 57.971 / 48.418 |
+| `中文👩🏽‍💻é-hostname-123` (raw paste) | 37 | 1 / 21 | 46.628 / 47.957 | 51.753 / 55.012 |
+| `中` repeated 32 times (raw paste) | 96 | 1 / 32 | 44.122 / 47.536 | 49.040 / 54.734 |
+| `中文abc👩🏽‍💻é` repeated 4,096 times (raw paste) | 110,592 | 1 / 1 | 5.433 / 6.240 | 26.105 / 54.073 |
+| Arrow sequence `ESC [ A` | 3 | 1 / 1 | 44.320 / 47.657 | 55.726 / 52.414 |
+| Bracketed paste containing `中文` | 18 | 1 / 1 | 44.151 / 44.995 | 48.959 / 55.769 |
+
+These are local end-to-end SSH echo completion times for this fixture. They are not native app paste latency, remote processing time, a throughput benchmark, or evidence that the previous behavior caused lag. Client write-call counts do not establish SSH packet boundaries, server read boundaries, or SSH channel-data block counts.
+
+## Native desktop results
+
+The final native report tested production code commit `bd5f27ff42d29b18c0e9cb3513415da3243dd636` against two owned loopback SSH endpoints in an isolated profile. The following checks passed:
+
+- New hosts defaulted to standard mode. Duplicate, save, and application restart preserved each host's choice.
+- Saving during a connection did not change its input mode. A real reconnect adopted the saved mode in both directions.
+- Full hibernation used a 5-second hidden-tab delay and zero retained renderers, with xterm absence confirmed. Wake/reattach retained the old connection choice in both directions; a subsequent reconnect adopted the saved choice.
+- A missing-field legacy record was seeded into the isolated host store. Real application startup migrated it to `true`. After the user disabled compatibility, saved, and restarted, the value remained `false`.
+- The Chinese setting label, help text, and reconnect notice matched the required text and were captured in screenshots. Arrow and Ctrl+C bytes remained intact.
+
+| Native sample | Received-content result | Observed SSH channel-data blocks, standard / compatibility |
+|---|---|---|
+| `中文测试🙂é输入兼容模式` — 37 UTF-8 bytes, 13 code points | Hashes matched between modes | 1 / 13 |
+| Long sample — 131,072 bytes | Hashes matched between modes | Four 32,768-byte frames / four 32,768-byte frames |
+| Negotiated bracketed paste — 49 bytes | Preserved | 1 / 1 |
+
+The native short sample differs from the implementation fixture's 37-byte sample above. Its 1 / 13 SSH channel-data block observation is not the implementation fixture's 1 / 21 client write-call count. The native 131,072-byte long sample is also distinct from the 110,592-byte timing sample.
+
+The native timing observation was one PTY first-to-last receive span per mode: standard **3.408724 ms**, compatibility **1.600044 ms**. It starts at the first received PTY payload and ends at the last received payload. It excludes the input-to-first-receive interval and is not total GUI paste latency. One observation per mode does not provide a median, P95, or causal performance comparison. These spans cannot be substituted for the 15-repetition client echo timings above. Neither run establishes throughput superiority or that the previous workaround caused lag.
+
+Actual OS IME input and Qianxin hardware were not tested. Native networked cloud sync, import, and jump-chain behavior were also not tested; those data flows have automated coverage rather than claimed native validation. Synthetic DOM composition events, native GUI/paste coverage, client write calls, SSH data blocks, and receive timing remain separate evidence categories.
+
+Independent review confirmed the three reported P2 findings resolved, with no new blocking findings. The native application, SSH and clipboard fixture processes, isolated profile, and test keys were cleaned up; the source tree was clean after that run.
+
+## CI result
+
+The `test` workflow completed successfully for documentation commit `38c5f4744cb5fc3ecdd4e624b323587a471e4333`: [run 40319492139](https://github.com/binaricat/Netcatty/actions/runs/40319492139). That workflow includes `npm run lint`, `npm test`, generated-spec checks, and `npm run build`. The production code is unchanged from the native-tested `bd5f27ff` commit. Subsequent acceptance-text edits change documentation only. The PR remains draft and unmerged.

domain/host.test.ts

@@ -793,3 +793,15 @@ test("sanitizeHost preserves named-pipe spaces and restores the authoritative se
   assert.equal(sanitizeHost(host).serialConfig?.path, path);
   assert.equal(sanitizeHost(makeHost({ hostname: 'example.com extra' })).hostname, 'example.com');
 });
+
+
+test("SSH input compatibility migrates legacy hosts once and preserves later choices", () => {
+  const legacy = { id: "legacy", label: "Legacy", hostname: "localhost", username: "user", tags: [], os: "linux" } as Host;
+  for (const protocol of [undefined, "ssh"] as const) {
+    const migrated = sanitizeHost({ ...legacy, protocol });
+    assert.equal(migrated.sshInputCompatibility, true);
+    assert.equal(sanitizeHost(migrated).sshInputCompatibility, true);
+    assert.equal(sanitizeHost({ ...migrated, sshInputCompatibility: false }).sshInputCompatibility, false);
+  }
+  assert.equal(sanitizeHost({ ...legacy, protocol: "telnet" }).sshInputCompatibility, undefined);
+});

domain/host.ts

@@ -466,6 +466,11 @@ export const sanitizeHost = (host: Host, snippets: Snippet[] = []): Host => {
       ? undefined
       : migrated.authMethod ?? inferredLegacyAuthMethod,
     authPolicyVersion: 1,
+    // Legacy SSH records used per-character IME/short-paste writes globally.
+    // Persist the choice on normalization; explicit false survives every reload.
+    sshInputCompatibility: host.protocol === undefined || host.protocol === 'ssh'
+      ? host.sshInputCompatibility ?? true
+      : host.sshInputCompatibility,
     hostname: cleanHostname,
     osOverride: osSelection,
     os: osSelection === 'linux' || osSelection === 'windows' || osSelection === 'macos' ? osSelection : host.os,

domain/models/connection.ts

@@ -189,6 +189,9 @@ export interface Host {
   identityFileId?: string; // Reference to SSHKey
   protocol?: HostProtocol; // Default/primary protocol, including namespaced plugin protocols
   pluginConnection?: PluginConnectionConfig;
+  // SSH interactive IME/short-paste compatibility; applied on reconnect.
+  // Missing on legacy records; sanitizeHost preserves their previous behavior.
+  sshInputCompatibility?: boolean;
   // Runtime marker for in-memory-only hosts (e.g. password deep links).
   // Ephemeral hosts are never persisted to the vault or session restore.
   ephemeral?: boolean;

domain/pluginImporter.test.ts

@@ -820,3 +820,29 @@ test('plugin importer preview is bounded and never exposes secret or command pay
   assert.equal(JSON.stringify(preview).includes('private-key-material'), false);
   assert.equal(JSON.stringify(preview).includes('contains-sensitive-command'), false);
 });
+
+
+test('new imported SSH drafts default to standard input and preserve explicit boolean choices', () => {
+  for (const protocol of [undefined, 'ssh'] as const) {
+    for (const choice of [undefined, false, true]) {
+      const result = normalizePluginImporterRecords([{ type: 'draft', draft: {
+        kind: 'host', value: {
+          hostname: 'new.test', ...(protocol ? { protocol } : {}),
+          ...(choice === undefined ? {} : { sshInputCompatibility: choice }),
+        },
+      } }]);
+      assert.deepEqual(result.errors, []);
+      assert.equal(result.hosts[0].sshInputCompatibility, choice ?? false);
+    }
+  }
+});
+
+test('imported host drafts reject non-boolean input compatibility choices', () => {
+  for (const choice of ['false', 'true', 0, null]) {
+    const result = normalizePluginImporterRecords([{ type: 'draft', draft: {
+      kind: 'host', value: { hostname: 'new.test', protocol: 'ssh', sshInputCompatibility: choice },
+    } }]);
+    assert.deepEqual(result.hosts, []);
+    assert.deepEqual(result.errors, ['Importer returned an invalid host draft.']);
+  }
+});

domain/pluginImporter.ts

@@ -204,6 +204,7 @@ const normalizeHost = (value: JsonValue): Host | null => {
   };
   if (Object.values(optionalStrings).some((item) => item === INVALID_FIELD)) return null;
   const optionalBooleans = {
+    sshInputCompatibility: optionalBooleanValue(object, 'sshInputCompatibility'),
     moshEnabled: optionalBooleanValue(object, 'moshEnabled'),
     etEnabled: optionalBooleanValue(object, 'etEnabled'),
     telnetEnabled: optionalBooleanValue(object, 'telnetEnabled'),
@@ -242,6 +243,7 @@ const normalizeHost = (value: JsonValue): Host | null => {
     createdAt: Date.now(),
     ephemeral: false,
     managedSourceId: undefined,
+    sshInputCompatibility: false,
     ...(protocol ? { protocol } : {}),
     ...(pluginConnection ? { pluginConnection: structuredClone(pluginConnection) } : {}),
     ...(deviceType ? { deviceType } : {}),

domain/quickConnectHost.ts

@@ -68,6 +68,7 @@ export const buildQuickConnectHost = ({
     os: "linux",
     protocol: protocol === "mosh" || protocol === "et" ? "ssh" : protocol,
     authMethod,
+    sshInputCompatibility: false,
     identityId: applicableIdentityId,
     password: !applicableIdentityId && authMethod === "password" ? password : undefined,
     identityFileId:

domain/sshDeepLink.test.ts

@@ -2,6 +2,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import type { Host } from "./models";
 import { resolveHostAutofillPassword } from "./sshAuth";
+import { sanitizeHost } from "./host";
 import {
   buildSshDeepLinkConnectionHost,
   buildSshDeepLinkEphemeralHost,
@@ -242,8 +243,10 @@ test("buildSshDeepLinkHostDraft prepares an editable new ssh host", () => {
     tags: [],
     os: "linux",
     protocol: "ssh",
+    sshInputCompatibility: false,
     createdAt: 123,
   });
+  assert.equal(sanitizeHost(draft).sshInputCompatibility, false);
 });
 
 test("buildSshDeepLinkOpenHost falls back to a draft host when no saved host matches", () => {
@@ -331,3 +334,13 @@ test("buildSshNoteLinkOpenHost ignores unrelated external links", () => {
 
   assert.equal(openHost, null);
 });
+
+
+test("deep links derived from saved hosts preserve explicit input choices", () => {
+  const target = parseSshDeepLink("ssh://alice:secret@example.com")!;
+  for (const sshInputCompatibility of [false, true]) {
+    const saved = host({ sshInputCompatibility });
+    assert.equal(buildSshDeepLinkConnectionHost(saved).sshInputCompatibility, sshInputCompatibility);
+    assert.equal(buildSshDeepLinkEphemeralHostFromSaved(saved, target, { id: "copy", now: 1 }).sshInputCompatibility, sshInputCompatibility);
+  }
+});

domain/sshDeepLink.ts

@@ -165,6 +165,7 @@ export const buildSshDeepLinkHostDraft = (
   tags: [],
   os: "linux",
   protocol: "ssh",
+  sshInputCompatibility: false,
   createdAt: options.now,
 });
 

domain/terminalHostResolution.test.ts

@@ -675,3 +675,16 @@ test("resolveTerminalChainHosts skips non-SSH jump candidates", () => {
 
   assert.deepEqual(resolved.map((host) => host.id), ["jump-ssh", "jump-mosh"]);
 });
+
+
+test("input compatibility belongs to the terminal endpoint, independently of SSH jump hops", () => {
+  const target: Host = { id: "target", label: "Target", hostname: "target.example.test", username: "alice",
+    protocol: "ssh", tags: [], os: "linux", sshInputCompatibility: false, hostChain: { hostIds: ["bastion"] } };
+  const bastion: Host = { ...target, id: "bastion", hostChain: undefined, sshInputCompatibility: true };
+  const resolve = (hostId: string) => resolveTerminalSessionHost({
+    session: { ...baseSession, hostId }, hosts: [target, bastion], groupConfigs: [], proxyProfiles: [], localOs: "linux",
+  });
+  assert.equal(resolve("target").sshInputCompatibility, false);
+  assert.equal(resolve("bastion").sshInputCompatibility, true);
+  assert.equal(resolveTerminalChainHosts({ host: target, hosts: [target, bastion], groupConfigs: [], proxyProfiles: [] })[0].sshInputCompatibility, true);
+});

domain/vaultHostCreate.test.ts

@@ -1956,3 +1956,10 @@ test('applyVaultHostDelete keeps jump hosts referenced by empty group defaults',
   assert.equal(result.ok, false);
   if (!result.ok) assert.match(result.error, /still used as a group jump host/i);
 });
+
+
+test('new SSH hosts explicitly use standard interactive input', () => {
+  const created = buildVaultHostFromDraft({ hostname: 'localhost', username: 'user' });
+  assert.equal(created.ok, true);
+  if (created.ok) assert.equal(created.host.sshInputCompatibility, false);
+});

domain/vaultHostCreate.ts

@@ -329,6 +329,7 @@ export function buildVaultHostFromDraft(
       os,
       osOverride: parsedOs ?? 'auto',
       protocol,
+      sshInputCompatibility: false,
       createdAt: now,
       ...(keyPath
         ? {

domain/vaultImport.ts

@@ -665,6 +665,7 @@ const importFromCsv = (
   const proxyIdx = findExactHeaderIndex(header, ["proxy", "proxyserver", "proxy server"]);
   const proxyJumpIdx = findExactHeaderIndex(header, ["proxyjump"]);
   const localShellIdx = findExactHeaderIndex(header, ["localshell"]);
+  const inputCompatibilityIdx = findExactHeaderIndex(header, ["sshinputcompatibility"]);
   const passphraseIdx = keyPathIdx >= 0 ? explicitPassphraseIdx : -1;
   const exactPasswordIdx = findExactHeaderIndex(header, ["password", "pass", "passwd"]);
   const fuzzyNamedPasswordIdx = findHeaderIndex(header, ["password", "passwd"]);
@@ -795,6 +796,10 @@ const importFromCsv = (
       tags,
       notes,
     });
+    if (inputCompatibilityIdx >= 0 && (protocol === undefined || protocol === "ssh")) {
+      const choice = row[inputCompatibilityIdx]?.trim().toLowerCase();
+      if (choice === "true" || choice === "false") host.sshInputCompatibility = choice === "true";
+    }
     if (proxyConfig) host.proxyConfig = proxyConfig;
     if (directProxy) host.directProxy = true;
     if (localShellSpec && protocol === "local") {

domain/vaultImport/csvExport.test.ts

@@ -842,3 +842,16 @@ test("CSV import warns and ignores a malformed LocalShell value", () => {
   assert.equal(imported.hosts[0]?.localShell, undefined);
   assert.ok(imported.issues.some((issue) => issue.message.includes("row 2") && issue.message.includes("LocalShell")));
 });
+
+
+test("CSV export/import preserves independent SSH input compatibility choices", () => {
+  const hosts: Host[] = [false, true].map((choice, index) => ({
+    ...hostDefaults, id: `mode-${index}`, label: `Mode ${index}`,
+    hostname: `mode-${index}.example.test`, protocol: "ssh", sshInputCompatibility: choice,
+  }));
+  const { csv } = exportHostsToCsvWithStats(hosts);
+  const imported = importVaultHostsFromText("csv", csv);
+  assert.deepEqual(imported.hosts.map(host => host.sshInputCompatibility), [false, true]);
+  const second = importVaultHostsFromText("csv", exportHostsToCsvWithStats(imported.hosts).csv);
+  assert.deepEqual(second.hosts.map(host => host.sshInputCompatibility), [false, true]);
+});

domain/vaultImport/csvExport.ts

@@ -37,7 +37,7 @@ export const getVaultCsvTemplate = (
   opts: VaultCsvTemplateOptions = {},
 ): string => {
   const includeExampleRows = opts.includeExampleRows !== false;
-  const header = ["Groups", "Label", "Tags", "Notes", "Hostname/IP", "Protocol", "Port", "Username", "Password", "KeyPath", "Passphrase", "Proxy", "ProxyJump", "LocalShell"];
+  const header = ["Groups", "Label", "Tags", "Notes", "Hostname/IP", "Protocol", "Port", "Username", "Password", "KeyPath", "Passphrase", "Proxy", "ProxyJump", "LocalShell", "SshInputCompatibility"];
   const rows: string[][] = [header];
   if (includeExampleRows) {
     rows.push(["Project/Dev", "Web Server (dev)", "dev,web", "Dev web tier", "192.168.1.10", "ssh", "22", "root", "", "~/.ssh/id_ed25519", "", "socks5://127.0.0.1:1080"]);
@@ -115,7 +115,7 @@ const formatCsvProxyJump = (host: Host, allHosts: readonly Host[]): string => {
 };
 
 const exportHostsToCsv = (hosts: Host[], options: VaultCsvExportOptions) => {
-  const header = ["Groups", "Label", "Tags", "Notes", "Hostname/IP", "Protocol", "Port", "Username", "Password", "KeyPath", "Passphrase", "Proxy", "ProxyJump", "LocalShell"];
+  const header = ["Groups", "Label", "Tags", "Notes", "Hostname/IP", "Protocol", "Port", "Username", "Password", "KeyPath", "Passphrase", "Proxy", "ProxyJump", "LocalShell", "SshInputCompatibility"];
   const rows: string[][] = [header];
   let unreadableProxyCredentialCount = 0;
 
@@ -217,6 +217,7 @@ const exportHostsToCsv = (hosts: Host[], options: VaultCsvExportOptions) => {
       encodeCsvProxy(proxyValue),
       encodeCsvProxyJump(proxyJumpValue),
       localShellSpec ? encodeCsvLocalShell(localShellSpec) : "",
+      host.protocol === undefined || host.protocol === "ssh" ? String(host.sshInputCompatibility ?? true) : "",
     ]);
   }