tmex-cli 0.5.1 → 0.6.1

package/dist/runtime/server.js

@@ -20282,7 +20282,7 @@ var require_lib3 = __commonJS((exports, module) => {
 
 // src/runtime/server.ts
 import { existsSync as existsSync4 } from "fs";
-import { extname, join as join5, normalize, resolve as resolve2, sep } from "path";
+import { extname, join as join4, normalize, resolve as resolve2, sep } from "path";
 
 // ../../apps/gateway/src/crypto/errors.ts
 function contextLabel(context) {
@@ -52139,7 +52139,6 @@ class EventNotifier {
 var eventNotifier = new EventNotifier;
 
 // ../../apps/gateway/src/tmux-client/local-external-connection.ts
-import { mkdirSync, rmSync } from "fs";
 import { homedir } from "os";
 
 // ../../apps/gateway/src/ws/error-classify.ts
@@ -52531,156 +52530,297 @@ function buildLocalTmuxEnv(resolvedPath, baseEnv = process.env) {
   return nextEnv;
 }
 
-// ../../apps/gateway/src/tmux-client/command-builder.ts
-function quoteShellArg(value) {
-  return `'${value.replaceAll("'", "'\\''")}'`;
+// ../../apps/gateway/src/tmux-client/capture-history.ts
+var PANE_SCREEN_INFO_FORMAT = "#{alternate_on} #{cursor_x} #{cursor_y} #{pane_height}";
+function parsePaneScreenInfo(stdout) {
+  const parts = stdout.trim().split(/\s+/);
+  const toInt = (value) => {
+    if (value === undefined) {
+      return null;
+    }
+    const parsed = Number.parseInt(value, 10);
+    return Number.isNaN(parsed) || parsed < 0 ? null : parsed;
+  };
+  return {
+    alternateScreen: parts[0] === "1",
+    cursorX: toInt(parts[1]),
+    cursorY: toInt(parts[2]),
+    paneHeight: toInt(parts[3])
+  };
 }
-function joinShellArgs(argv) {
-  return argv.map((arg) => quoteShellArg(arg)).join(" ");
+function appendCursorRestore(history, info) {
+  const { cursorX, cursorY, paneHeight } = info;
+  if (cursorX === null || cursorY === null || paneHeight === null || paneHeight < 1) {
+    return history;
+  }
+  const trimmed = history.endsWith(`
+`) ? history.slice(0, -1) : history;
+  if (info.alternateScreen) {
+    return `${trimmed}\x1B[${cursorY + 1};${cursorX + 1}H`;
+  }
+  const up = Math.min(Math.max(0, paneHeight - 1 - cursorY), paneHeight - 1);
+  const moveUp = up > 0 ? `\x1B[${up}A` : "";
+  return `${trimmed}${moveUp}\x1B[${cursorX + 1}G`;
 }
 
-// ../../apps/gateway/src/tmux-client/fs-paths.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { join as join3 } from "path";
-var DEFAULT_ROOT_DIR = "/tmp/tmex";
-var DEFAULT_GATEWAY_RUNTIME_ID = randomUUID2();
-function toSafePathSegment(value) {
-  return Array.from(value).map((char) => {
-    if (/^[A-Za-z0-9._-]$/.test(char)) {
-      return char;
-    }
-    return `_${char.codePointAt(0)?.toString(16) ?? "00"}_`;
-  }).join("");
-}
-function createRuntimeFsPaths(options) {
-  const baseRootDir = options.rootDir ?? DEFAULT_ROOT_DIR;
-  const safeSessionName = toSafePathSegment(options.sessionName?.trim() || "tmex");
-  const safeGatewayRuntimeId = toSafePathSegment(options.gatewayRuntimeId?.trim() || DEFAULT_GATEWAY_RUNTIME_ID);
-  const runtimeDirName = `${toSafePathSegment(options.deviceId)}-${safeGatewayRuntimeId}-${options.gatewayPid}`;
-  const runtimeRootDir = join3(baseRootDir, runtimeDirName);
-  const panesDir = join3(runtimeRootDir, "panes");
-  const hooksDir = join3(runtimeRootDir, "hooks");
-  return {
-    rootDir: runtimeRootDir,
-    panesDir,
-    hooksDir,
-    hookFifoPath: join3(hooksDir, "events.fifo"),
-    paneFifoPath(paneId) {
-      return join3(panesDir, `${safeSessionName}-${toSafePathSegment(paneId)}.fifo`);
+// ../../apps/gateway/src/tmux-client/control-mode-parser.ts
+var decoder = new TextDecoder;
+var MAX_LINE_BYTES = 4 * 1024 * 1024;
+var MAX_BLOCK_BODY_LINES = 1000;
+var BYTE_LF = 10;
+var BYTE_SPACE = 32;
+var BYTE_PERCENT = 37;
+var BYTE_BACKSLASH = 92;
+var KNOWN_NOTIFICATION_TYPES = new Set([
+  "client-detached",
+  "client-session-changed",
+  "config-error",
+  "continue",
+  "layout-change",
+  "message",
+  "pane-mode-changed",
+  "paste-buffer-changed",
+  "paste-buffer-deleted",
+  "pause",
+  "session-changed",
+  "session-renamed",
+  "session-window-changed",
+  "sessions-changed",
+  "subscription-changed",
+  "unlinked-window-add",
+  "unlinked-window-close",
+  "unlinked-window-renamed",
+  "window-add",
+  "window-close",
+  "window-pane-changed",
+  "window-renamed"
+]);
+function isOctalDigit(byte) {
+  return byte >= 48 && byte <= 55;
+}
+function unescapeControlModeData(line, start, onInvalidEscape) {
+  const result = new Uint8Array(line.length - start);
+  let written = 0;
+  let index = start;
+  while (index < line.length) {
+    const byte = line[index];
+    if (byte !== BYTE_BACKSLASH) {
+      result[written] = byte;
+      written += 1;
+      index += 1;
+      continue;
     }
-  };
+    const d1 = line[index + 1];
+    const d2 = line[index + 2];
+    const d3 = line[index + 3];
+    if (d1 !== undefined && d2 !== undefined && d3 !== undefined && isOctalDigit(d1) && isOctalDigit(d2) && isOctalDigit(d3)) {
+      result[written] = d1 - 48 << 6 | d2 - 48 << 3 | d3 - 48;
+      written += 1;
+      index += 4;
+      continue;
+    }
+    onInvalidEscape?.();
+    result[written] = byte;
+    written += 1;
+    index += 1;
+  }
+  return result.subarray(0, written);
 }
-
-// ../../apps/gateway/src/tmux-client/ghostty-terminfo.ts
-var XTERM_GHOSTTY_TERMINFO_SOURCE = `xterm-ghostty|ghostty|Ghostty,
-	am, bce, ccc, hs, km, mc5i, mir, msgr, npc, xenl, AX, Su, Tc, XT, fullkbd,
-	colors#0x100, cols#80, it#8, lines#24, pairs#0x7fff,
-	acsc=++\\,\\,--..00\`\`aaffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~,
-	bel=^G, blink=\\E[5m, bold=\\E[1m, cbt=\\E[Z, civis=\\E[?25l,
-	clear=\\E[H\\E[2J, cnorm=\\E[?12l\\E[?25h, cr=\\r,
-	csr=\\E[%i%p1%d;%p2%dr, cub=\\E[%p1%dD, cub1=^H,
-	cud=\\E[%p1%dB, cud1=\\n, cuf=\\E[%p1%dC, cuf1=\\E[C,
-	cup=\\E[%i%p1%d;%p2%dH, cuu=\\E[%p1%dA, cuu1=\\E[A,
-	cvvis=\\E[?12;25h, dch=\\E[%p1%dP, dch1=\\E[P, dim=\\E[2m,
-	dl=\\E[%p1%dM, dl1=\\E[M, dsl=\\E]2;\\007, ech=\\E[%p1%dX,
-	ed=\\E[J, el=\\E[K, el1=\\E[1K, flash=\\E[?5h$<100/>\\E[?5l,
-	fsl=^G, home=\\E[H, hpa=\\E[%i%p1%dG, ht=^I, hts=\\EH,
-	ich=\\E[%p1%d@, ich1=\\E[@, il=\\E[%p1%dL, il1=\\E[L, ind=\\n,
-	indn=\\E[%p1%dS,
-	initc=\\E]4;%p1%d;rgb:%p2%{255}%*%{1000}%/%2.2X/%p3%{255}%*%{1000}%/%2.2X/%p4%{255}%*%{1000}%/%2.2X\\E\\\\,
-	invis=\\E[8m, kDC=\\E[3;2~, kEND=\\E[1;2F, kHOM=\\E[1;2H,
-	kIC=\\E[2;2~, kLFT=\\E[1;2D, kNXT=\\E[6;2~, kPRV=\\E[5;2~,
-	kRIT=\\E[1;2C, kbs=^?, kcbt=\\E[Z, kcub1=\\EOD, kcud1=\\EOB,
-	kcuf1=\\EOC, kcuu1=\\EOA, kdch1=\\E[3~, kend=\\EOF, kent=\\EOM,
-	kf1=\\EOP, kf10=\\E[21~, kf11=\\E[23~, kf12=\\E[24~,
-	kf13=\\E[1;2P, kf14=\\E[1;2Q, kf15=\\E[1;2R, kf16=\\E[1;2S,
-	kf17=\\E[15;2~, kf18=\\E[17;2~, kf19=\\E[18;2~, kf2=\\EOQ,
-	kf20=\\E[19;2~, kf21=\\E[20;2~, kf22=\\E[21;2~,
-	kf23=\\E[23;2~, kf24=\\E[24;2~, kf25=\\E[1;5P, kf26=\\E[1;5Q,
-	kf27=\\E[1;5R, kf28=\\E[1;5S, kf29=\\E[15;5~, kf3=\\EOR,
-	kf30=\\E[17;5~, kf31=\\E[18;5~, kf32=\\E[19;5~,
-	kf33=\\E[20;5~, kf34=\\E[21;5~, kf35=\\E[23;5~,
-	kf36=\\E[24;5~, kf37=\\E[1;6P, kf38=\\E[1;6Q, kf39=\\E[1;6R,
-	kf4=\\EOS, kf40=\\E[1;6S, kf41=\\E[15;6~, kf42=\\E[17;6~,
-	kf43=\\E[18;6~, kf44=\\E[19;6~, kf45=\\E[20;6~,
-	kf46=\\E[21;6~, kf47=\\E[23;6~, kf48=\\E[24;6~,
-	kf49=\\E[1;3P, kf5=\\E[15~, kf50=\\E[1;3Q, kf51=\\E[1;3R,
-	kf52=\\E[1;3S, kf53=\\E[15;3~, kf54=\\E[17;3~,
-	kf55=\\E[18;3~, kf56=\\E[19;3~, kf57=\\E[20;3~,
-	kf58=\\E[21;3~, kf59=\\E[23;3~, kf6=\\E[17~, kf60=\\E[24;3~,
-	kf61=\\E[1;4P, kf62=\\E[1;4Q, kf63=\\E[1;4R, kf7=\\E[18~,
-	kf8=\\E[19~, kf9=\\E[20~, khome=\\EOH, kich1=\\E[2~,
-	kind=\\E[1;2B, kmous=\\E[<, knp=\\E[6~, kpp=\\E[5~,
-	kri=\\E[1;2A, oc=\\E]104\\007, op=\\E[39;49m, rc=\\E8,
-	rep=%p1%c\\E[%p2%{1}%-%db, rev=\\E[7m, ri=\\EM,
-	rin=\\E[%p1%dT, ritm=\\E[23m, rmacs=\\E(B, rmam=\\E[?7l,
-	rmcup=\\E[?1049l, rmir=\\E[4l, rmkx=\\E[?1l\\E>, rmso=\\E[27m,
-	rmul=\\E[24m, rs1=\\E]\\E\\\\\\Ec, sc=\\E7,
-	setab=\\E[%?%p1%{8}%<%t4%p1%d%e%p1%{16}%<%t10%p1%{8}%-%d%e48;5;%p1%d%;m,
-	setaf=\\E[%?%p1%{8}%<%t3%p1%d%e%p1%{16}%<%t9%p1%{8}%-%d%e38;5;%p1%d%;m,
-	sgr=%?%p9%t\\E(0%e\\E(B%;\\E[0%?%p6%t;1%;%?%p5%t;2%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;%?%p7%t;8%;m,
-	sgr0=\\E(B\\E[m, sitm=\\E[3m, smacs=\\E(0, smam=\\E[?7h,
-	smcup=\\E[?1049h, smir=\\E[4h, smkx=\\E[?1h\\E=, smso=\\E[7m,
-	smul=\\E[4m, tbc=\\E[3g, tsl=\\E]2;, u6=\\E[%i%d;%dR, u7=\\E[6n,
-	u8=\\E[?%[;0123456789]c, u9=\\E[c, vpa=\\E[%i%p1%dd,
-	BD=\\E[?2004l, BE=\\E[?2004h, Clmg=\\E[s,
-	Cmg=\\E[%i%p1%d;%p2%ds, Dsmg=\\E[?69l, E3=\\E[3J,
-	Enmg=\\E[?69h, Ms=\\E]52;%p1%s;%p2%s\\007, PE=\\E[201~,
-	PS=\\E[200~, RV=\\E[>c, Se=\\E[2 q,
-	Setulc=\\E[58:2::%p1%{65536}%/%d:%p1%{256}%/%{255}%&%d:%p1%{255}%&%d%;m,
-	Smulx=\\E[4:%p1%dm, Ss=\\E[%p1%d q,
-	Sync=\\E[?2026%?%p1%{1}%-%tl%eh%;,
-	XM=\\E[?1006;1000%?%p1%{1}%=%th%el%;, XR=\\E[>0q,
-	fd=\\E[?1004l, fe=\\E[?1004h, kDC3=\\E[3;3~, kDC4=\\E[3;4~,
-	kDC5=\\E[3;5~, kDC6=\\E[3;6~, kDC7=\\E[3;7~, kDN=\\E[1;2B,
-	kDN3=\\E[1;3B, kDN4=\\E[1;4B, kDN5=\\E[1;5B, kDN6=\\E[1;6B,
-	kDN7=\\E[1;7B, kEND3=\\E[1;3F, kEND4=\\E[1;4F,
-	kEND5=\\E[1;5F, kEND6=\\E[1;6F, kEND7=\\E[1;7F,
-	kHOM3=\\E[1;3H, kHOM4=\\E[1;4H, kHOM5=\\E[1;5H,
-	kHOM6=\\E[1;6H, kHOM7=\\E[1;7H, kIC3=\\E[2;3~, kIC4=\\E[2;4~,
-	kIC5=\\E[2;5~, kIC6=\\E[2;6~, kIC7=\\E[2;7~, kLFT3=\\E[1;3D,
-	kLFT4=\\E[1;4D, kLFT5=\\E[1;5D, kLFT6=\\E[1;6D,
-	kLFT7=\\E[1;7D, kNXT3=\\E[6;3~, kNXT4=\\E[6;4~,
-	kNXT5=\\E[6;5~, kNXT6=\\E[6;6~, kNXT7=\\E[6;7~,
-	kPRV3=\\E[5;3~, kPRV4=\\E[5;4~, kPRV5=\\E[5;5~,
-	kPRV6=\\E[5;6~, kPRV7=\\E[5;7~, kRIT3=\\E[1;3C,
-	kRIT4=\\E[1;4C, kRIT5=\\E[1;5C, kRIT6=\\E[1;6C,
-	kRIT7=\\E[1;7C, kUP=\\E[1;2A, kUP3=\\E[1;3A, kUP4=\\E[1;4A,
-	kUP5=\\E[1;5A, kUP6=\\E[1;6A, kUP7=\\E[1;7A, kxIN=\\E[I,
-	kxOUT=\\E[O, rmxx=\\E[29m, rv=\\E\\\\[[0-9]+;[0-9]+;[0-9]+c,
-	setrgbb=\\E[48:2:%p1%d:%p2%d:%p3%dm,
-	setrgbf=\\E[38:2:%p1%d:%p2%d:%p3%dm, smxx=\\E[9m,
-	xm=\\E[<%i%p3%d;%p1%d;%p2%d;%?%p4%tM%em%;,
-	xr=\\EP>\\\\|[ -~]+a\\E\\\\,
-`;
-var HEREDOC_MARKER = "TMEX_TERMINFO_EOF";
-function buildEnsureGhosttyTerminfoScript() {
-  return [
-    "if ! infocmp xterm-ghostty >/dev/null 2>&1; then",
-    `tic -x - <<'${HEREDOC_MARKER}' >/dev/null 2>&1`,
-    XTERM_GHOSTTY_TERMINFO_SOURCE.trimEnd(),
-    HEREDOC_MARKER,
-    "fi",
-    "infocmp xterm-ghostty >/dev/null 2>&1"
-  ].join(`
-`);
+function concatChunks(chunks, totalLength) {
+  if (chunks.length === 1) {
+    return chunks[0];
+  }
+  const merged = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk2 of chunks) {
+    merged.set(chunk2, offset);
+    offset += chunk2.length;
+  }
+  return merged;
 }
-
-// ../../apps/gateway/src/tmux-client/input-encoder.ts
-var encoder = new TextEncoder;
-var SEND_KEYS_HEX_CHUNK_BYTES = 256;
-function encodeInputToHexChunks(input, chunkBytes = SEND_KEYS_HEX_CHUNK_BYTES) {
-  const bytes = encoder.encode(input);
-  const chunks = [];
-  for (let offset = 0;offset < bytes.length; offset += chunkBytes) {
-    const chunk2 = bytes.slice(offset, offset + chunkBytes);
-    chunks.push(Array.from(chunk2, (byte) => byte.toString(16).padStart(2, "0")));
+function createControlModeParser(callbacks) {
+  let pendingChunks = [];
+  let pendingLength = 0;
+  let discardingOversizedLine = false;
+  let warnedOversizedLine = false;
+  let warnedInvalidEscape = false;
+  let warnedUnexpectedLine = false;
+  let currentBlock = null;
+  function warnInvalidEscape() {
+    if (!warnedInvalidEscape) {
+      warnedInvalidEscape = true;
+      console.warn("[tmex] control mode parser met invalid escape sequence, passing through");
+    }
   }
-  return chunks;
+  function findByte(line, byte, from) {
+    for (let index = from;index < line.length; index += 1) {
+      if (line[index] === byte) {
+        return index;
+      }
+    }
+    return -1;
+  }
+  function decodeRange(line, start, end) {
+    return decoder.decode(line.subarray(start, end));
+  }
+  function handleOutputLine(line, payloadStart) {
+    const paneEnd = findByte(line, BYTE_SPACE, payloadStart);
+    if (paneEnd < 0) {
+      return;
+    }
+    const paneId = decodeRange(line, payloadStart, paneEnd);
+    callbacks.onOutput(paneId, unescapeControlModeData(line, paneEnd + 1, warnInvalidEscape));
+  }
+  function handleExtendedOutputLine(line, payloadStart) {
+    const paneEnd = findByte(line, BYTE_SPACE, payloadStart);
+    if (paneEnd < 0) {
+      return;
+    }
+    const paneId = decodeRange(line, payloadStart, paneEnd);
+    for (let index = paneEnd;index + 2 < line.length; index += 1) {
+      if (line[index] === BYTE_SPACE && line[index + 1] === 58 && line[index + 2] === BYTE_SPACE) {
+        callbacks.onOutput(paneId, unescapeControlModeData(line, index + 3, warnInvalidEscape));
+        return;
+      }
+    }
+  }
+  function handleLine(line) {
+    if (line.length === 0) {
+      return;
+    }
+    if (line[0] !== BYTE_PERCENT) {
+      if (currentBlock) {
+        if (currentBlock.lines.length < MAX_BLOCK_BODY_LINES) {
+          currentBlock.lines.push(decoder.decode(line));
+        }
+        return;
+      }
+      if (!warnedUnexpectedLine) {
+        warnedUnexpectedLine = true;
+        console.warn(`[tmex] control mode parser ignored unexpected line: ${decoder.decode(line.subarray(0, 80))}`);
+      }
+      return;
+    }
+    const typeEnd = findByte(line, BYTE_SPACE, 0);
+    const type = typeEnd < 0 ? decodeRange(line, 1, line.length) : decodeRange(line, 1, typeEnd);
+    const argsStart = typeEnd < 0 ? line.length : typeEnd + 1;
+    switch (type) {
+      case "output":
+        handleOutputLine(line, argsStart);
+        return;
+      case "extended-output":
+        handleExtendedOutputLine(line, argsStart);
+        return;
+      case "begin": {
+        if (currentBlock) {
+          callbacks.onBlockEnd?.(currentBlock);
+        }
+        currentBlock = {
+          args: decodeRange(line, argsStart, line.length),
+          isError: false,
+          lines: []
+        };
+        return;
+      }
+      case "end":
+      case "error": {
+        if (!currentBlock) {
+          return;
+        }
+        const args = decodeRange(line, argsStart, line.length);
+        if (args !== currentBlock.args) {
+          console.warn(`[tmex] control mode block guard mismatch: begin "${currentBlock.args}" vs ${type} "${args}"`);
+        }
+        currentBlock.isError = type === "error";
+        callbacks.onBlockEnd?.(currentBlock);
+        currentBlock = null;
+        return;
+      }
+      case "exit": {
+        const reason = argsStart < line.length ? decodeRange(line, argsStart, line.length) : null;
+        callbacks.onExit(reason);
+        return;
+      }
+      default: {
+        if (currentBlock && !KNOWN_NOTIFICATION_TYPES.has(type)) {
+          if (currentBlock.lines.length < MAX_BLOCK_BODY_LINES) {
+            currentBlock.lines.push(decoder.decode(line));
+          }
+          return;
+        }
+        callbacks.onNotification({
+          type,
+          args: decodeRange(line, argsStart, line.length),
+          raw: decoder.decode(line)
+        });
+        return;
+      }
+    }
+  }
+  function takePendingLine(tail) {
+    if (pendingLength === 0) {
+      return tail;
+    }
+    pendingChunks.push(tail);
+    const line = concatChunks(pendingChunks, pendingLength + tail.length);
+    pendingChunks = [];
+    pendingLength = 0;
+    return line;
+  }
+  return {
+    push(chunk2) {
+      let start = 0;
+      while (start <= chunk2.length) {
+        const newlineIndex = findByte(chunk2, BYTE_LF, start);
+        if (newlineIndex < 0) {
+          break;
+        }
+        const tail = chunk2.subarray(start, newlineIndex);
+        if (discardingOversizedLine) {
+          discardingOversizedLine = false;
+          pendingChunks = [];
+          pendingLength = 0;
+        } else {
+          handleLine(takePendingLine(tail));
+        }
+        start = newlineIndex + 1;
+      }
+      if (start < chunk2.length) {
+        const rest = chunk2.subarray(start);
+        if (discardingOversizedLine) {
+          return;
+        }
+        if (pendingLength + rest.length > MAX_LINE_BYTES) {
+          if (!warnedOversizedLine) {
+            warnedOversizedLine = true;
+            console.warn("[tmex] control mode parser dropped oversized line");
+          }
+          discardingOversizedLine = true;
+          pendingChunks = [];
+          pendingLength = 0;
+          return;
+        }
+        pendingChunks.push(rest);
+        pendingLength += rest.length;
+      }
+    },
+    end() {
+      if (discardingOversizedLine || pendingLength === 0) {
+        discardingOversizedLine = false;
+        pendingChunks = [];
+        pendingLength = 0;
+        return;
+      }
+      const line = concatChunks(pendingChunks, pendingLength);
+      pendingChunks = [];
+      pendingLength = 0;
+      handleLine(line);
+    }
+  };
 }
 
 // ../../apps/gateway/src/tmux-client/pane-stream-parser.ts
-var decoder = new TextDecoder;
+var decoder2 = new TextDecoder;
 var MAX_OSC_KIND_BYTES = 16;
 var MAX_OSC_PAYLOAD_BYTES = 8 * 1024;
 var MAX_DCS_PASSTHROUGH_BYTES = 64 * 1024;
@@ -52714,14 +52854,14 @@ function createPaneStreamParser(options) {
     return true;
   }
   function emitTitle(bytes) {
-    const title = decoder.decode(new Uint8Array(bytes)).trim();
+    const title = decoder2.decode(new Uint8Array(bytes)).trim();
     if (!title) {
       return;
     }
     options.onTitle(title);
   }
   function emitOsc() {
-    const payload = decoder.decode(new Uint8Array(oscPayloadBytes));
+    const payload = decoder2.decode(new Uint8Array(oscPayloadBytes));
     switch (oscKind) {
       case "0":
       case "1":
@@ -53020,7 +53160,245 @@ function createPaneStreamParser(options) {
   };
 }
 
+// ../../apps/gateway/src/tmux-client/control-mode-subscription.ts
+var STRUCTURE_DEBOUNCE_MS = 150;
+var STRUCTURE_NOTIFICATION_TYPES = new Set([
+  "layout-change",
+  "session-renamed",
+  "session-window-changed",
+  "sessions-changed",
+  "unlinked-window-add",
+  "unlinked-window-close",
+  "unlinked-window-renamed",
+  "window-add",
+  "window-close",
+  "window-pane-changed",
+  "window-renamed"
+]);
+function createControlModeSubscription(callbacks) {
+  const paneParsers = new Map;
+  let structureTimer = null;
+  let lastStructureEmitAt = 0;
+  let disposed = false;
+  function getPaneParser(paneId) {
+    const existing = paneParsers.get(paneId);
+    if (existing) {
+      return existing;
+    }
+    const parser2 = createPaneStreamParser({
+      onTitle: (title) => callbacks.onTitle(paneId, title),
+      onBell: () => callbacks.onBell(paneId),
+      onNotification: (notification) => callbacks.onNotification(paneId, notification)
+    });
+    paneParsers.set(paneId, parser2);
+    return parser2;
+  }
+  function scheduleStructureChanged() {
+    if (disposed) {
+      return;
+    }
+    const now = Date.now();
+    if (structureTimer) {
+      return;
+    }
+    if (now - lastStructureEmitAt >= STRUCTURE_DEBOUNCE_MS) {
+      lastStructureEmitAt = now;
+      callbacks.onStructureChanged();
+      return;
+    }
+    structureTimer = setTimeout(() => {
+      structureTimer = null;
+      if (disposed) {
+        return;
+      }
+      lastStructureEmitAt = Date.now();
+      callbacks.onStructureChanged();
+    }, STRUCTURE_DEBOUNCE_MS - (now - lastStructureEmitAt));
+  }
+  function handleNotification(notification) {
+    if (STRUCTURE_NOTIFICATION_TYPES.has(notification.type)) {
+      scheduleStructureChanged();
+    }
+  }
+  const parser = createControlModeParser({
+    onOutput: (paneId, data) => {
+      const output = getPaneParser(paneId).push(data);
+      if (output.length > 0) {
+        callbacks.onTerminalOutput(paneId, output);
+      }
+    },
+    onNotification: handleNotification,
+    onExit: (reason) => callbacks.onExit(reason),
+    onBlockEnd: (block) => callbacks.onBlockEnd?.(block)
+  });
+  return {
+    push(chunk2) {
+      if (disposed) {
+        return;
+      }
+      parser.push(chunk2);
+    },
+    end() {
+      if (disposed) {
+        return;
+      }
+      parser.end();
+    },
+    prunePanes(validPaneIds) {
+      for (const paneId of Array.from(paneParsers.keys())) {
+        if (!validPaneIds.has(paneId)) {
+          paneParsers.delete(paneId);
+        }
+      }
+    },
+    dispose() {
+      disposed = true;
+      if (structureTimer) {
+        clearTimeout(structureTimer);
+        structureTimer = null;
+      }
+      paneParsers.clear();
+    }
+  };
+}
+
+// ../../apps/gateway/src/tmux-client/ghostty-terminfo.ts
+var XTERM_GHOSTTY_TERMINFO_SOURCE = `xterm-ghostty|ghostty|Ghostty,
+	am, bce, ccc, hs, km, mc5i, mir, msgr, npc, xenl, AX, Su, Tc, XT, fullkbd,
+	colors#0x100, cols#80, it#8, lines#24, pairs#0x7fff,
+	acsc=++\\,\\,--..00\`\`aaffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~,
+	bel=^G, blink=\\E[5m, bold=\\E[1m, cbt=\\E[Z, civis=\\E[?25l,
+	clear=\\E[H\\E[2J, cnorm=\\E[?12l\\E[?25h, cr=\\r,
+	csr=\\E[%i%p1%d;%p2%dr, cub=\\E[%p1%dD, cub1=^H,
+	cud=\\E[%p1%dB, cud1=\\n, cuf=\\E[%p1%dC, cuf1=\\E[C,
+	cup=\\E[%i%p1%d;%p2%dH, cuu=\\E[%p1%dA, cuu1=\\E[A,
+	cvvis=\\E[?12;25h, dch=\\E[%p1%dP, dch1=\\E[P, dim=\\E[2m,
+	dl=\\E[%p1%dM, dl1=\\E[M, dsl=\\E]2;\\007, ech=\\E[%p1%dX,
+	ed=\\E[J, el=\\E[K, el1=\\E[1K, flash=\\E[?5h$<100/>\\E[?5l,
+	fsl=^G, home=\\E[H, hpa=\\E[%i%p1%dG, ht=^I, hts=\\EH,
+	ich=\\E[%p1%d@, ich1=\\E[@, il=\\E[%p1%dL, il1=\\E[L, ind=\\n,
+	indn=\\E[%p1%dS,
+	initc=\\E]4;%p1%d;rgb:%p2%{255}%*%{1000}%/%2.2X/%p3%{255}%*%{1000}%/%2.2X/%p4%{255}%*%{1000}%/%2.2X\\E\\\\,
+	invis=\\E[8m, kDC=\\E[3;2~, kEND=\\E[1;2F, kHOM=\\E[1;2H,
+	kIC=\\E[2;2~, kLFT=\\E[1;2D, kNXT=\\E[6;2~, kPRV=\\E[5;2~,
+	kRIT=\\E[1;2C, kbs=^?, kcbt=\\E[Z, kcub1=\\EOD, kcud1=\\EOB,
+	kcuf1=\\EOC, kcuu1=\\EOA, kdch1=\\E[3~, kend=\\EOF, kent=\\EOM,
+	kf1=\\EOP, kf10=\\E[21~, kf11=\\E[23~, kf12=\\E[24~,
+	kf13=\\E[1;2P, kf14=\\E[1;2Q, kf15=\\E[1;2R, kf16=\\E[1;2S,
+	kf17=\\E[15;2~, kf18=\\E[17;2~, kf19=\\E[18;2~, kf2=\\EOQ,
+	kf20=\\E[19;2~, kf21=\\E[20;2~, kf22=\\E[21;2~,
+	kf23=\\E[23;2~, kf24=\\E[24;2~, kf25=\\E[1;5P, kf26=\\E[1;5Q,
+	kf27=\\E[1;5R, kf28=\\E[1;5S, kf29=\\E[15;5~, kf3=\\EOR,
+	kf30=\\E[17;5~, kf31=\\E[18;5~, kf32=\\E[19;5~,
+	kf33=\\E[20;5~, kf34=\\E[21;5~, kf35=\\E[23;5~,
+	kf36=\\E[24;5~, kf37=\\E[1;6P, kf38=\\E[1;6Q, kf39=\\E[1;6R,
+	kf4=\\EOS, kf40=\\E[1;6S, kf41=\\E[15;6~, kf42=\\E[17;6~,
+	kf43=\\E[18;6~, kf44=\\E[19;6~, kf45=\\E[20;6~,
+	kf46=\\E[21;6~, kf47=\\E[23;6~, kf48=\\E[24;6~,
+	kf49=\\E[1;3P, kf5=\\E[15~, kf50=\\E[1;3Q, kf51=\\E[1;3R,
+	kf52=\\E[1;3S, kf53=\\E[15;3~, kf54=\\E[17;3~,
+	kf55=\\E[18;3~, kf56=\\E[19;3~, kf57=\\E[20;3~,
+	kf58=\\E[21;3~, kf59=\\E[23;3~, kf6=\\E[17~, kf60=\\E[24;3~,
+	kf61=\\E[1;4P, kf62=\\E[1;4Q, kf63=\\E[1;4R, kf7=\\E[18~,
+	kf8=\\E[19~, kf9=\\E[20~, khome=\\EOH, kich1=\\E[2~,
+	kind=\\E[1;2B, kmous=\\E[<, knp=\\E[6~, kpp=\\E[5~,
+	kri=\\E[1;2A, oc=\\E]104\\007, op=\\E[39;49m, rc=\\E8,
+	rep=%p1%c\\E[%p2%{1}%-%db, rev=\\E[7m, ri=\\EM,
+	rin=\\E[%p1%dT, ritm=\\E[23m, rmacs=\\E(B, rmam=\\E[?7l,
+	rmcup=\\E[?1049l, rmir=\\E[4l, rmkx=\\E[?1l\\E>, rmso=\\E[27m,
+	rmul=\\E[24m, rs1=\\E]\\E\\\\\\Ec, sc=\\E7,
+	setab=\\E[%?%p1%{8}%<%t4%p1%d%e%p1%{16}%<%t10%p1%{8}%-%d%e48;5;%p1%d%;m,
+	setaf=\\E[%?%p1%{8}%<%t3%p1%d%e%p1%{16}%<%t9%p1%{8}%-%d%e38;5;%p1%d%;m,
+	sgr=%?%p9%t\\E(0%e\\E(B%;\\E[0%?%p6%t;1%;%?%p5%t;2%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;%?%p7%t;8%;m,
+	sgr0=\\E(B\\E[m, sitm=\\E[3m, smacs=\\E(0, smam=\\E[?7h,
+	smcup=\\E[?1049h, smir=\\E[4h, smkx=\\E[?1h\\E=, smso=\\E[7m,
+	smul=\\E[4m, tbc=\\E[3g, tsl=\\E]2;, u6=\\E[%i%d;%dR, u7=\\E[6n,
+	u8=\\E[?%[;0123456789]c, u9=\\E[c, vpa=\\E[%i%p1%dd,
+	BD=\\E[?2004l, BE=\\E[?2004h, Clmg=\\E[s,
+	Cmg=\\E[%i%p1%d;%p2%ds, Dsmg=\\E[?69l, E3=\\E[3J,
+	Enmg=\\E[?69h, Ms=\\E]52;%p1%s;%p2%s\\007, PE=\\E[201~,
+	PS=\\E[200~, RV=\\E[>c, Se=\\E[2 q,
+	Setulc=\\E[58:2::%p1%{65536}%/%d:%p1%{256}%/%{255}%&%d:%p1%{255}%&%d%;m,
+	Smulx=\\E[4:%p1%dm, Ss=\\E[%p1%d q,
+	Sync=\\E[?2026%?%p1%{1}%-%tl%eh%;,
+	XM=\\E[?1006;1000%?%p1%{1}%=%th%el%;, XR=\\E[>0q,
+	fd=\\E[?1004l, fe=\\E[?1004h, kDC3=\\E[3;3~, kDC4=\\E[3;4~,
+	kDC5=\\E[3;5~, kDC6=\\E[3;6~, kDC7=\\E[3;7~, kDN=\\E[1;2B,
+	kDN3=\\E[1;3B, kDN4=\\E[1;4B, kDN5=\\E[1;5B, kDN6=\\E[1;6B,
+	kDN7=\\E[1;7B, kEND3=\\E[1;3F, kEND4=\\E[1;4F,
+	kEND5=\\E[1;5F, kEND6=\\E[1;6F, kEND7=\\E[1;7F,
+	kHOM3=\\E[1;3H, kHOM4=\\E[1;4H, kHOM5=\\E[1;5H,
+	kHOM6=\\E[1;6H, kHOM7=\\E[1;7H, kIC3=\\E[2;3~, kIC4=\\E[2;4~,
+	kIC5=\\E[2;5~, kIC6=\\E[2;6~, kIC7=\\E[2;7~, kLFT3=\\E[1;3D,
+	kLFT4=\\E[1;4D, kLFT5=\\E[1;5D, kLFT6=\\E[1;6D,
+	kLFT7=\\E[1;7D, kNXT3=\\E[6;3~, kNXT4=\\E[6;4~,
+	kNXT5=\\E[6;5~, kNXT6=\\E[6;6~, kNXT7=\\E[6;7~,
+	kPRV3=\\E[5;3~, kPRV4=\\E[5;4~, kPRV5=\\E[5;5~,
+	kPRV6=\\E[5;6~, kPRV7=\\E[5;7~, kRIT3=\\E[1;3C,
+	kRIT4=\\E[1;4C, kRIT5=\\E[1;5C, kRIT6=\\E[1;6C,
+	kRIT7=\\E[1;7C, kUP=\\E[1;2A, kUP3=\\E[1;3A, kUP4=\\E[1;4A,
+	kUP5=\\E[1;5A, kUP6=\\E[1;6A, kUP7=\\E[1;7A, kxIN=\\E[I,
+	kxOUT=\\E[O, rmxx=\\E[29m, rv=\\E\\\\[[0-9]+;[0-9]+;[0-9]+c,
+	setrgbb=\\E[48:2:%p1%d:%p2%d:%p3%dm,
+	setrgbf=\\E[38:2:%p1%d:%p2%d:%p3%dm, smxx=\\E[9m,
+	xm=\\E[<%i%p3%d;%p1%d;%p2%d;%?%p4%tM%em%;,
+	xr=\\EP>\\\\|[ -~]+a\\E\\\\,
+`;
+var HEREDOC_MARKER = "TMEX_TERMINFO_EOF";
+function buildEnsureGhosttyTerminfoScript() {
+  return [
+    "if ! infocmp xterm-ghostty >/dev/null 2>&1; then",
+    `tic -x - <<'${HEREDOC_MARKER}' >/dev/null 2>&1`,
+    XTERM_GHOSTTY_TERMINFO_SOURCE.trimEnd(),
+    HEREDOC_MARKER,
+    "fi",
+    "infocmp xterm-ghostty >/dev/null 2>&1"
+  ].join(`
+`);
+}
+
+// ../../apps/gateway/src/tmux-client/input-encoder.ts
+var encoder = new TextEncoder;
+var SEND_KEYS_HEX_CHUNK_BYTES = 256;
+function encodeInputToHexChunks(input, chunkBytes = SEND_KEYS_HEX_CHUNK_BYTES) {
+  const bytes = encoder.encode(input);
+  const chunks = [];
+  for (let offset = 0;offset < bytes.length; offset += chunkBytes) {
+    const chunk2 = bytes.slice(offset, offset + chunkBytes);
+    chunks.push(Array.from(chunk2, (byte) => byte.toString(16).padStart(2, "0")));
+  }
+  return chunks;
+}
+
+// ../../apps/gateway/src/tmux-client/tmux-version.ts
+var MIN_CONTROL_MODE_VERSION = { major: 3, minor: 0 };
+function parseTmuxVersion(versionOutput) {
+  const match = versionOutput.match(/(\d+)\.(\d+)/);
+  if (!match) {
+    return null;
+  }
+  return {
+    major: Number.parseInt(match[1], 10),
+    minor: Number.parseInt(match[2], 10)
+  };
+}
+function isControlModeSupported(version2) {
+  if (!version2) {
+    return true;
+  }
+  if (version2.major !== MIN_CONTROL_MODE_VERSION.major) {
+    return version2.major > MIN_CONTROL_MODE_VERSION.major;
+  }
+  return version2.minor >= MIN_CONTROL_MODE_VERSION.minor;
+}
+
 // ../../apps/gateway/src/tmux-client/local-external-connection.ts
+var CONTROL_MAX_RESTARTS = 3;
+var CONTROL_RESTART_DELAY_MS = 500;
+var CONTROL_STABLE_RESET_MS = 1e4;
+var CONTROL_STDERR_TAIL_LIMIT = 2048;
+var CONTROL_ATTACH_READY_TIMEOUT_MS = 3000;
+var PARKING_WINDOW_NAME = "tmex-park";
 function hasRenderableTerminalContent(value) {
   return value.trim().length > 0;
 }
@@ -53048,6 +53426,26 @@ function defaultRun(argv) {
     }).catch(reject);
   });
 }
+function defaultSpawnControlClient(argv) {
+  const subprocess = Bun.spawn(argv, {
+    env: buildLocalTmuxEnv(getLocalShellPath()),
+    stdin: "pipe",
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const stdin = subprocess.stdin;
+  return {
+    stdout: subprocess.stdout,
+    stderr: subprocess.stderr,
+    exited: subprocess.exited,
+    kill: () => {
+      try {
+        stdin?.end();
+      } catch {}
+      subprocess.kill();
+    }
+  };
+}
 
 class LocalExternalTmuxConnection {
   deviceId;
@@ -53062,30 +53460,27 @@ class LocalExternalTmuxConnection {
   pendingPaneTitles = new Map;
   snapshotSession = null;
   snapshotWindows = new Map;
-  paneReaders = new Map;
-  pipeTransition = Promise.resolve();
   inputTransition = Promise.resolve();
-  hookReadAbort = null;
-  hookBuffer = "";
   bellDedup = new Map;
   closeNotified = false;
   cleanupPromise = null;
-  fsPaths = createRuntimeFsPaths({
-    deviceId: "pending",
-    sessionName: "pending",
-    gatewayPid: process.pid
-  });
+  controlProcess = null;
+  controlSubscription = null;
+  controlStartedAt = 0;
+  controlRestartCount = 0;
+  controlStderrTail = "";
   constructor(options, inputDeps = {}) {
     this.deviceId = options.deviceId;
     this.callbacks = options;
     this.deps = {
-      enableHooks: inputDeps.enableHooks ?? true,
+      enableSubscription: inputDeps.enableSubscription ?? true,
       getDevice: inputDeps.getDevice ?? ((deviceId) => getDeviceById(deviceId)),
       run: inputDeps.run ?? defaultRun,
       ensureGhosttyTerminfo: inputDeps.ensureGhosttyTerminfo ?? (async () => {
         const result = await this.deps.run(["/bin/sh", "-c", buildEnsureGhosttyTerminfoScript()]);
         return result.exitCode === 0;
-      })
+      }),
+      spawnControlClient: inputDeps.spawnControlClient ?? defaultSpawnControlClient
     };
   }
   async connect() {
@@ -53099,16 +53494,13 @@ class LocalExternalTmuxConnection {
       throw new Error(`LocalExternalTmuxConnection only supports local device: ${this.deviceId}`);
     }
     this.sessionName = this.device.session?.trim() || "tmex";
-    this.fsPaths = createRuntimeFsPaths({
-      deviceId: this.deviceId,
-      sessionName: this.sessionName,
-      gatewayPid: process.pid
-    });
-    this.ensureRuntimeDirs();
+    if (this.deps.enableSubscription) {
+      await this.assertControlModeSupport();
+    }
     await this.ensureSession();
     await this.configureSessionOptions();
-    if (this.deps.enableHooks) {
-      await this.startHooks();
+    if (this.deps.enableSubscription) {
+      await this.startControlClient();
     }
     this.connected = true;
     updateDeviceRuntimeStatus(this.deviceId, {
@@ -53125,11 +53517,7 @@ class LocalExternalTmuxConnection {
     }
     this.manualDisconnect = true;
     this.connected = false;
-    this.stopAllPipeReaders();
-    if (this.deps.enableHooks) {
-      this.stopHooks();
-    }
-    rmSync(this.fsPaths.rootDir, { recursive: true, force: true });
+    this.stopControlClient();
   }
   requestSnapshot() {
     this.requestSnapshotInternal();
@@ -53241,7 +53629,14 @@ class LocalExternalTmuxConnection {
       "extended-keys-format",
       "csi-u"
     ]);
-    await this.runTmuxAllowFailure(["set-option", "-t", this.sessionName, "-g", "focus-events", "on"]);
+    await this.runTmuxAllowFailure(["set-option", "-t", this.sessionName, "-g", "focus-events", "off"]);
+    await this.runTmuxAllowFailure([
+      "set-option",
+      "-t",
+      this.sessionName,
+      "destroy-unattached",
+      "off"
+    ]);
     const termProgram = config.tmuxTermProgram.trim();
     if (termProgram && termProgram.toLowerCase() !== "off") {
       await this.runTmuxAllowFailure([
@@ -53262,86 +53657,204 @@ class LocalExternalTmuxConnection {
       }
     }
   }
-  ensureRuntimeDirs() {
-    mkdirSync(this.fsPaths.rootDir, { recursive: true, mode: 448 });
-    mkdirSync(this.fsPaths.panesDir, { recursive: true, mode: 448 });
-    mkdirSync(this.fsPaths.hooksDir, { recursive: true, mode: 448 });
+  async assertControlModeSupport() {
+    const result = await this.runTmuxAllowFailure(["-V"]);
+    if (result.exitCode !== 0) {
+      return;
+    }
+    const version2 = parseTmuxVersion(result.stdout.trim());
+    if (!isControlModeSupported(version2)) {
+      throw new Error(`tmux ${version2?.major}.${version2?.minor} is too old for tmex (control mode requires tmux >= 3.0)`);
+    }
   }
-  async startHooks() {
-    this.ensureRuntimeDirs();
-    const fifoPath = this.fsPaths.hookFifoPath;
-    rmSync(fifoPath, { force: true });
-    await this.runShell(`mkfifo ${quoteShellArg(fifoPath)}`);
-    const readerProcess = Bun.spawn(["/bin/sh", "-lc", `tail -n +1 -f ${quoteShellArg(fifoPath)}`], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const reader = readerProcess.stdout.getReader();
-    (async () => {
-      try {
-        while (true) {
-          const chunk2 = await reader.read();
-          if (chunk2.done) {
-            break;
-          }
-          this.handleHookChunk(new TextDecoder().decode(chunk2.value));
-        }
-      } catch (error) {
-        if (!this.manualDisconnect && !shouldIgnoreReaderAbortError(error)) {
-          this.callbacks.onError(error instanceof Error ? error : new Error(String(error)));
-        }
-      }
-    })();
-    this.hookReadAbort = () => {
-      reader.releaseLock();
-      readerProcess.kill();
-      rmSync(fifoPath, { force: true });
-    };
-    await this.installHook("pane-exited", ["pane-exited", "#{window_id}", "#{pane_id}"]);
-    await this.installHook("pane-died", ["pane-died", "#{window_id}", "#{pane_id}"]);
-    await this.installHook("after-new-window", ["refresh"]);
-    await this.installHook("after-split-window", ["refresh"]);
-  }
-  async stopHooks() {
-    await this.runTmuxAllowFailure(["set-hook", "-u", "-t", this.sessionName, "pane-exited"]);
-    await this.runTmuxAllowFailure(["set-hook", "-u", "-t", this.sessionName, "pane-died"]);
-    await this.runTmuxAllowFailure(["set-hook", "-u", "-t", this.sessionName, "after-new-window"]);
-    await this.runTmuxAllowFailure(["set-hook", "-u", "-t", this.sessionName, "after-split-window"]);
-    this.hookReadAbort?.();
-    this.hookReadAbort = null;
-    this.hookBuffer = "";
-  }
-  async installHook(hookName, fields) {
-    const fifoPath = this.fsPaths.hookFifoPath;
-    const innerScript = `printf '%s\\t%s\\t%s\\n' ${fields.map((field) => quoteShellArg(field)).join(" ")} >> ${quoteShellArg(fifoPath)}`;
-    await this.runTmux([
-      "set-hook",
+  async createParkingWindow() {
+    const result = await this.runTmuxAllowFailure([
+      "new-window",
       "-t",
       this.sessionName,
-      hookName,
-      `run-shell -b ${quoteShellArg(innerScript)}`
+      "-n",
+      PARKING_WINDOW_NAME,
+      "-P",
+      "-F",
+      "#{window_id}",
+      "sleep 30"
     ]);
+    if (result.exitCode !== 0) {
+      console.warn(`[local] failed to create parking window on ${this.deviceId}, attaching without focus shield`);
+      return null;
+    }
+    return result.stdout.trim() || null;
   }
-  handleHookChunk(text2) {
-    this.hookBuffer += text2;
-    while (true) {
-      const newlineIndex = this.hookBuffer.indexOf(`
-`);
-      if (newlineIndex < 0) {
-        return;
+  async removeParkingWindow(windowId) {
+    if (!windowId) {
+      return;
+    }
+    await this.runTmuxAllowFailure(["last-window", "-t", this.sessionName]);
+    await this.runTmuxAllowFailure(["kill-window", "-t", windowId]);
+  }
+  async startControlClient() {
+    let attachReadyResolve = null;
+    const attachReady = new Promise((resolve) => {
+      attachReadyResolve = resolve;
+    });
+    const parkingWindowId = await this.createParkingWindow();
+    let proc;
+    try {
+      proc = this.spawnControlClientProcess(() => {
+        attachReadyResolve?.();
+        attachReadyResolve = null;
+      });
+      await Promise.race([
+        attachReady,
+        new Promise((resolve) => setTimeout(resolve, CONTROL_ATTACH_READY_TIMEOUT_MS))
+      ]);
+    } finally {
+      await this.removeParkingWindow(parkingWindowId);
+    }
+    if (this.controlProcess !== proc) {
+      const message = this.controlStderrTail.trim() || "tmux control client exited during attach";
+      console.warn(`[local] tmux control client died during attach on ${this.deviceId}: ${message}`);
+      throw new Error(message);
+    }
+  }
+  spawnControlClientProcess(onAttachReady) {
+    const subscription = createControlModeSubscription({
+      onTerminalOutput: (paneId, data) => {
+        this.callbacks.onTerminalOutput(paneId, data);
+      },
+      onTitle: (paneId, title) => {
+        this.pendingPaneTitles.set(paneId, title);
+        this.requestSnapshot();
+      },
+      onBell: (paneId) => {
+        this.recordBell(paneId);
+      },
+      onNotification: (paneId, notification) => {
+        this.emitNotification(paneId, notification);
+      },
+      onStructureChanged: () => {
+        this.requestSnapshot();
+      },
+      onExit: () => {},
+      onBlockEnd: () => {
+        onAttachReady();
       }
-      const line = this.hookBuffer.slice(0, newlineIndex).trim();
-      this.hookBuffer = this.hookBuffer.slice(newlineIndex + 1);
-      if (!line) {
-        continue;
+    });
+    const proc = this.deps.spawnControlClient([
+      "tmux",
+      "-C",
+      "attach-session",
+      "-t",
+      this.sessionName
+    ]);
+    this.controlProcess = proc;
+    this.controlSubscription = subscription;
+    this.controlStartedAt = Date.now();
+    this.controlStderrTail = "";
+    this.pumpControlStdout(proc, subscription);
+    this.pumpControlStderr(proc);
+    proc.exited.then((exitCode) => {
+      this.handleControlClientExit(proc, exitCode);
+    }).catch(() => {
+      this.handleControlClientExit(proc, -1);
+    });
+    return proc;
+  }
+  async pumpControlStdout(proc, subscription) {
+    const reader = proc.stdout.getReader();
+    try {
+      while (true) {
+        const chunk2 = await reader.read();
+        if (chunk2.done || this.controlProcess !== proc) {
+          break;
+        }
+        subscription.push(chunk2.value);
       }
-      const [type, windowId, paneId] = line.split("\t");
-      if (type === "bell") {
-        continue;
+    } catch (error) {
+      if (!this.manualDisconnect && !shouldIgnoreReaderAbortError(error)) {
+        this.callbacks.onError(error instanceof Error ? error : new Error(String(error)));
       }
-      if (type === "pane-exited" || type === "pane-died" || type === "refresh") {
-        this.requestSnapshot();
+    }
+    subscription.end();
+  }
+  async pumpControlStderr(proc) {
+    const reader = proc.stderr.getReader();
+    const decoder3 = new TextDecoder;
+    try {
+      while (true) {
+        const chunk2 = await reader.read();
+        if (chunk2.done) {
+          break;
+        }
+        if (this.controlProcess === proc) {
+          this.controlStderrTail = (this.controlStderrTail + decoder3.decode(chunk2.value)).slice(-CONTROL_STDERR_TAIL_LIMIT);
+        }
       }
+    } catch {}
+  }
+  stopControlClient() {
+    const proc = this.controlProcess;
+    this.controlProcess = null;
+    this.controlSubscription?.dispose();
+    this.controlSubscription = null;
+    proc?.kill();
+  }
+  handleControlClientExit(proc, exitCode) {
+    if (this.controlProcess !== proc) {
+      return;
+    }
+    this.controlProcess = null;
+    this.controlSubscription?.dispose();
+    this.controlSubscription = null;
+    if (!this.connected || this.manualDisconnect) {
+      return;
+    }
+    this.reconnectControlClient(exitCode);
+  }
+  async reconnectControlClient(exitCode) {
+    if (Date.now() - this.controlStartedAt > CONTROL_STABLE_RESET_MS) {
+      this.controlRestartCount = 0;
+    }
+    this.controlRestartCount += 1;
+    const stderrMessage = this.controlStderrTail.trim();
+    if (this.controlRestartCount > CONTROL_MAX_RESTARTS) {
+      const message = stderrMessage || `tmux control client exited repeatedly (last code ${exitCode})`;
+      console.warn(`[local] tmux control client gave up on ${this.deviceId}: ${message}`);
+      this.notifyRuntimeError(message);
+      this.shutdownInternal(true);
+      return;
+    }
+    console.warn(`[local] tmux control client exited (code ${exitCode}) on ${this.deviceId}, reconnecting (attempt ${this.controlRestartCount})`);
+    await new Promise((resolve) => setTimeout(resolve, CONTROL_RESTART_DELAY_MS * this.controlRestartCount));
+    if (!this.connected || this.manualDisconnect) {
+      return;
+    }
+    const probe = await this.runTmuxAllowFailure(["has-session", "-t", this.sessionName]);
+    if (probe.exitCode !== 0) {
+      const message = probe.stderr.trim() || probe.stdout.trim() || "tmux session gone";
+      console.warn(`[local] tmux session gone on ${this.deviceId}: ${message}`);
+      updateDeviceRuntimeStatus(this.deviceId, {
+        lastSeenAt: new Date().toISOString(),
+        tmuxAvailable: false,
+        lastError: message
+      });
+      this.shutdownInternal(true);
+      return;
+    }
+    if (!this.connected || this.manualDisconnect) {
+      return;
+    }
+    try {
+      await this.startControlClient();
+    } catch (error) {
+      console.warn(`[local] control client restart failed on ${this.deviceId}:`, error);
+      return;
+    }
+    this.requestSnapshot();
+    if (this.activePaneId) {
+      this.capturePaneHistory(this.activePaneId).catch(() => {
+        return;
+      });
     }
   }
   async runAndRefresh(argv, allowTargetMissing = false) {
@@ -53381,13 +53894,13 @@ class LocalExternalTmuxConnection {
     await this.requestSnapshotInternal();
   }
   async capturePaneHistory(paneId) {
-    const mode = (await this.runTmux(["display-message", "-p", "-t", paneId, "#{alternate_on}"], true)).stdout.trim();
-    const alternateScreen = mode === "1";
-    const normal = (await this.runTmux(["capture-pane", "-t", paneId, "-S", "-", "-E", "-", "-e", "-N", "-p"], true)).stdout;
-    const alternate = (await this.runTmux(["capture-pane", "-t", paneId, "-a", "-S", "-", "-E", "-", "-e", "-N", "-p", "-q"], true)).stdout;
+    const screenInfo = parsePaneScreenInfo((await this.runTmux(["display-message", "-p", "-t", paneId, PANE_SCREEN_INFO_FORMAT], true)).stdout);
+    const alternateScreen = screenInfo.alternateScreen;
+    const normal = (await this.runTmux(["capture-pane", "-t", paneId, "-S", "-", "-E", "-", "-e", "-J", "-N", "-p"], true)).stdout;
+    const alternate = (await this.runTmux(["capture-pane", "-t", paneId, "-a", "-S", "-", "-E", "-", "-e", "-J", "-N", "-p", "-q"], true)).stdout;
     const history = alternateScreen ? hasRenderableTerminalContent(normal) ? normal : alternate : normal || alternate;
     if (history) {
-      this.callbacks.onTerminalHistory(paneId, history, alternateScreen);
+      this.callbacks.onTerminalHistory(paneId, appendCursorRestore(history, screenInfo), alternateScreen);
     }
   }
   async requestSnapshotInternal() {
@@ -53438,7 +53951,7 @@ ${panesRes.stderr}`;
     this.parseSnapshotSession(sessionRes.stdout.split(/\r?\n/));
     this.parseSnapshotWindows(windowsRes.stdout.split(/\r?\n/));
     this.parseSnapshotPanes(panesRes.stdout.split(/\r?\n/));
-    await this.syncPipeReaders();
+    this.controlSubscription?.prunePanes(new Set(this.getExpectedPaneIds()));
     this.emitSnapshot();
   }
   parseSnapshotSession(lines) {
@@ -53564,108 +54077,6 @@ ${panesRes.stderr}`;
   getExpectedPaneIds() {
     return Array.from(this.snapshotWindows.values()).sort((left, right) => left.index - right.index).flatMap((window2) => window2.panes.map((pane) => pane.id));
   }
-  async startPipeForPaneNow(paneId) {
-    if (this.paneReaders.has(paneId)) {
-      return;
-    }
-    const fifoPath = this.fsPaths.paneFifoPath(paneId);
-    this.ensureRuntimeDirs();
-    rmSync(fifoPath, { force: true });
-    await this.runShell(`mkfifo ${quoteShellArg(fifoPath)}`);
-    const parser = createPaneStreamParser({
-      onTitle: (title) => {
-        this.pendingPaneTitles.set(paneId, title);
-        this.requestSnapshot();
-      },
-      onBell: () => {
-        this.recordBell(paneId);
-      },
-      onNotification: (notification) => {
-        this.emitNotification(paneId, notification);
-      }
-    });
-    const readerProcess = Bun.spawn(["/bin/sh", "-lc", `cat ${quoteShellArg(fifoPath)}`], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const reader = readerProcess.stdout.getReader();
-    const stopReader = () => {
-      reader.releaseLock();
-      readerProcess.kill();
-      rmSync(fifoPath, { force: true });
-    };
-    this.paneReaders.set(paneId, { paneId, fifoPath, stopReader });
-    (async () => {
-      try {
-        while (true) {
-          const chunk2 = await reader.read();
-          if (chunk2.done) {
-            break;
-          }
-          const output = parser.push(chunk2.value);
-          if (output.length > 0) {
-            this.callbacks.onTerminalOutput(paneId, output);
-          }
-        }
-      } catch (error) {
-        if (!this.manualDisconnect && !shouldIgnoreReaderAbortError(error)) {
-          this.callbacks.onError(error instanceof Error ? error : new Error(String(error)));
-        }
-      }
-    })();
-    try {
-      await this.runTmux(["pipe-pane", "-O", "-t", paneId, `cat >${fifoPath}`]);
-    } catch (error) {
-      this.paneReaders.delete(paneId);
-      stopReader();
-      throw error;
-    }
-  }
-  async stopPipeForPaneNow(paneId) {
-    const handle = this.paneReaders.get(paneId);
-    if (!handle) {
-      return;
-    }
-    this.paneReaders.delete(paneId);
-    await this.runTmuxAllowFailure(["pipe-pane", "-t", paneId]);
-    handle.stopReader();
-  }
-  async syncPipeReaders() {
-    const expectedPaneIds = this.getExpectedPaneIds();
-    const expectedSet = new Set(expectedPaneIds);
-    await this.queuePipeTransition(async () => {
-      for (const paneId of Array.from(this.paneReaders.keys())) {
-        if (!expectedSet.has(paneId)) {
-          await this.stopPipeForPaneNow(paneId);
-        }
-      }
-      for (const paneId of expectedPaneIds) {
-        if (!this.paneReaders.has(paneId)) {
-          await this.startPipeForPaneNow(paneId);
-        }
-      }
-    });
-  }
-  async stopAllPipeReaders() {
-    await this.queuePipeTransition(async () => {
-      for (const paneId of Array.from(this.paneReaders.keys())) {
-        await this.stopPipeForPaneNow(paneId);
-      }
-    });
-  }
-  queuePipeTransition(task) {
-    const next = this.pipeTransition.catch(() => {
-      return;
-    }).then(task);
-    this.pipeTransition = next;
-    return next;
-  }
-  async runShell(command) {
-    const result = await this.deps.run(["/bin/sh", "-lc", command]);
-    if (result.exitCode !== 0) {
-      throw new Error(result.stderr.trim() || `shell command failed: ${command}`);
-    }
-  }
   async runTmux(argv, allowTargetMissing = false) {
     const result = await this.runTmuxAllowFailure(argv);
     if (result.exitCode === 0) {
@@ -53722,17 +54133,7 @@ ${panesRes.stderr}`;
     }
     this.connected = false;
     this.cleanupPromise = (async () => {
-      await this.stopAllPipeReaders().catch(() => {
-        return;
-      });
-      if (this.deps.enableHooks) {
-        await this.stopHooks().catch(() => {
-          return;
-        });
-      }
-      try {
-        rmSync(this.fsPaths.rootDir, { recursive: true, force: true });
-      } catch {}
+      this.stopControlClient();
     })();
     await this.cleanupPromise;
     this.cleanupPromise = null;
@@ -53756,9 +54157,17 @@ ${panesRes.stderr}`;
 // ../../apps/gateway/src/tmux-client/ssh-external-connection.ts
 var import_ssh2 = __toESM(require_lib3(), 1);
 
+// ../../apps/gateway/src/tmux-client/command-builder.ts
+function quoteShellArg(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function joinShellArgs(argv) {
+  return argv.map((arg) => quoteShellArg(arg)).join(" ");
+}
+
 // ../../apps/gateway/src/tmux-client/ssh-connect-config.ts
 import { existsSync as existsSync2, readFileSync } from "fs";
-import { join as join4 } from "path";
+import { join as join3 } from "path";
 
 // ../../apps/gateway/src/tmux/ssh-auth.ts
 function normalizeEnvValue(value) {
@@ -53811,7 +54220,7 @@ function expandHomePath(value, env) {
     return env.HOME?.trim() || trimmed;
   }
   if (trimmed.startsWith("~/") && env.HOME?.trim()) {
-    return join4(env.HOME.trim(), trimmed.slice(2));
+    return join3(env.HOME.trim(), trimmed.slice(2));
   }
   return trimmed;
 }
@@ -54094,6 +54503,12 @@ function hasRenderableTerminalContent2(value) {
 var BELL_DEDUP_WINDOW_MS2 = 200;
 var COMMAND_SENTINEL = "\x1ETMEX_END ";
 var SNAPSHOT_FIELD_SEPARATOR = "|";
+var CONTROL_MAX_RESTARTS2 = 3;
+var CONTROL_RESTART_DELAY_MS2 = 500;
+var CONTROL_STABLE_RESET_MS2 = 1e4;
+var CONTROL_STDERR_TAIL_LIMIT2 = 2048;
+var CONTROL_ATTACH_READY_TIMEOUT_MS2 = 3000;
+var PARKING_WINDOW_NAME2 = "tmex-park";
 function splitSnapshotFields(line, fieldCount) {
   const parts = line.split(SNAPSHOT_FIELD_SEPARATOR);
   if (parts.length <= fieldCount) {
@@ -54134,16 +54549,12 @@ class SshExternalTmuxConnection {
   pendingPaneTitles = new Map;
   snapshotSession = null;
   snapshotWindows = new Map;
-  paneReaders = new Map;
-  pipeTransition = Promise.resolve();
-  hookReadAbort = null;
-  hookBuffer = "";
   bellDedup = new Map;
-  fsPaths = createRuntimeFsPaths({
-    deviceId: "pending",
-    sessionName: "pending",
-    gatewayPid: process.pid
-  });
+  controlChannel = null;
+  controlSubscription = null;
+  controlStartedAt = 0;
+  controlRestartCount = 0;
+  controlStderrTail = "";
   sshClient = null;
   commandStream = null;
   commandStdoutBuffer = "";
@@ -54171,17 +54582,11 @@ class SshExternalTmuxConnection {
       throw new Error(`SshExternalTmuxConnection only supports ssh device: ${this.deviceId}`);
     }
     this.sessionName = this.device.session?.trim() || "tmex";
-    this.fsPaths = createRuntimeFsPaths({
-      deviceId: this.deviceId,
-      sessionName: this.sessionName,
-      gatewayPid: process.pid
-    });
     await this.connectSshClient();
     await this.openCommandChannel();
-    await this.ensureRemoteRuntimeDirs();
     await this.ensureSession();
     await this.configureSessionOptions();
-    await this.startHooks();
+    await this.startControlClient();
     this.connected = true;
     updateDeviceRuntimeStatus(this.deviceId, {
       lastSeenAt: new Date().toISOString(),
@@ -54371,17 +54776,16 @@ class SshExternalTmuxConnection {
     }
     this.tmuxBin = parsed.tmuxBin;
     this.remoteHomeDir = parsed.homeDir;
-  }
-  async ensureRemoteRuntimeDirs() {
-    await this.runShell([
-      `mkdir -p ${quoteShellArg(this.fsPaths.rootDir)}`,
-      `mkdir -p ${quoteShellArg(this.fsPaths.panesDir)}`,
-      `mkdir -p ${quoteShellArg(this.fsPaths.hooksDir)}`,
-      `chmod 700 ${quoteShellArg(this.fsPaths.rootDir)}`,
-      `chmod 700 ${quoteShellArg(this.fsPaths.panesDir)}`,
-      `chmod 700 ${quoteShellArg(this.fsPaths.hooksDir)}`
-    ].join(`
-`));
+    const version2 = parseTmuxVersion(parsed.tmuxVersion);
+    if (!isControlModeSupported(version2)) {
+      const message = `remote tmux too old for tmex (control mode requires tmux >= 3.0, found ${parsed.tmuxVersion || "unknown"})`;
+      updateDeviceRuntimeStatus(this.deviceId, {
+        lastSeenAt: new Date().toISOString(),
+        tmuxAvailable: false,
+        lastError: message
+      });
+      throw new Error(message);
+    }
   }
   async ensureSession() {
     const exists3 = await this.runTmuxAllowFailure(["has-session", "-t", this.sessionName]);
@@ -54408,7 +54812,14 @@ class SshExternalTmuxConnection {
       "extended-keys-format",
       "csi-u"
     ]);
-    await this.runTmuxAllowFailure(["set-option", "-t", this.sessionName, "-g", "focus-events", "on"]);
+    await this.runTmuxAllowFailure(["set-option", "-t", this.sessionName, "-g", "focus-events", "off"]);
+    await this.runTmuxAllowFailure([
+      "set-option",
+      "-t",
+      this.sessionName,
+      "destroy-unattached",
+      "off"
+    ]);
     const termProgram = config.tmuxTermProgram.trim();
     if (termProgram && termProgram.toLowerCase() !== "off") {
       await this.runTmuxAllowFailure([
@@ -54437,71 +54848,167 @@ class SshExternalTmuxConnection {
       return false;
     }
   }
-  async startHooks() {
-    await this.ensureRemoteRuntimeDirs();
-    const fifoPath = this.fsPaths.hookFifoPath;
-    await this.runShell(`rm -f ${quoteShellArg(fifoPath)} && mkfifo ${quoteShellArg(fifoPath)} && chmod 600 ${quoteShellArg(fifoPath)}`);
-    const stopReader = await this.openReaderChannel(`exec tail -n +1 -f ${quoteShellArg(fifoPath)}`, {
+  async createParkingWindow() {
+    const result = await this.runTmuxAllowFailure([
+      "new-window",
+      "-t",
+      this.sessionName,
+      "-n",
+      PARKING_WINDOW_NAME2,
+      "-P",
+      "-F",
+      "#{window_id}",
+      "sleep 30"
+    ]);
+    if (result.exitCode !== 0) {
+      console.warn(`[ssh] failed to create parking window on ${this.deviceId}, attaching without focus shield`);
+      return null;
+    }
+    return result.stdout.trim() || null;
+  }
+  async removeParkingWindow(windowId) {
+    if (!windowId) {
+      return;
+    }
+    await this.runTmuxAllowFailure(["last-window", "-t", this.sessionName]);
+    await this.runTmuxAllowFailure(["kill-window", "-t", windowId]);
+  }
+  async startControlClient() {
+    let attachReadyResolve = null;
+    const attachReady = new Promise((resolve) => {
+      attachReadyResolve = resolve;
+    });
+    const parkingWindowId = await this.createParkingWindow();
+    let handle;
+    try {
+      handle = await this.openControlChannel(() => {
+        attachReadyResolve?.();
+        attachReadyResolve = null;
+      });
+      await Promise.race([
+        attachReady,
+        new Promise((resolve) => setTimeout(resolve, CONTROL_ATTACH_READY_TIMEOUT_MS2))
+      ]);
+    } finally {
+      await this.removeParkingWindow(parkingWindowId);
+    }
+    if (this.controlChannel !== handle) {
+      throw new Error(this.controlStderrTail.trim() || "tmux control client channel closed during attach");
+    }
+  }
+  async openControlChannel(onAttachReady) {
+    const subscription = createControlModeSubscription({
+      onTerminalOutput: (paneId, data) => {
+        this.callbacks.onTerminalOutput(paneId, data);
+      },
+      onTitle: (paneId, title) => {
+        this.pendingPaneTitles.set(paneId, title);
+        this.requestSnapshot();
+      },
+      onBell: (paneId) => {
+        this.recordBell(paneId);
+      },
+      onNotification: (paneId, notification) => {
+        this.emitNotification(paneId, notification);
+      },
+      onStructureChanged: () => {
+        this.requestSnapshot();
+      },
+      onExit: () => {},
+      onBlockEnd: () => {
+        onAttachReady();
+      }
+    });
+    const handle = { stop: () => {} };
+    this.controlChannel = handle;
+    this.controlSubscription = subscription;
+    this.controlStartedAt = Date.now();
+    this.controlStderrTail = "";
+    const stopReader = await this.openReaderChannel(`exec ${quoteShellArg(this.tmuxBin)} -C attach-session -t ${quoteShellArg(this.sessionName)}`, {
       onData: (data) => {
-        this.handleHookChunk(data.toString());
+        if (this.controlChannel === handle) {
+          subscription.push(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+        }
       },
-      onClose: () => {
-        if (this.manualDisconnect) {
-          return;
+      onStderr: (data) => {
+        if (this.controlChannel === handle) {
+          this.controlStderrTail = (this.controlStderrTail + data.toString()).slice(-CONTROL_STDERR_TAIL_LIMIT2);
         }
-        console.error("[ssh] hook reader channel closed unexpectedly, tearing down");
-        this.shutdownInternal(true);
+      },
+      onClose: () => {
+        this.handleControlChannelClose(handle);
       }
     });
-    this.hookReadAbort = () => {
-      stopReader();
-      this.runShellAllowFailure(`rm -f ${quoteShellArg(fifoPath)}`);
-    };
-    await this.installHook("pane-exited", ["pane-exited", "#{window_id}", "#{pane_id}"]);
-    await this.installHook("pane-died", ["pane-died", "#{window_id}", "#{pane_id}"]);
-    await this.installHook("after-new-window", ["refresh"]);
-    await this.installHook("after-split-window", ["refresh"]);
-  }
-  async stopHooks() {
-    await this.runTmuxAllowFailure(["set-hook", "-u", "-t", this.sessionName, "pane-exited"]);
-    await this.runTmuxAllowFailure(["set-hook", "-u", "-t", this.sessionName, "pane-died"]);
-    await this.runTmuxAllowFailure(["set-hook", "-u", "-t", this.sessionName, "after-new-window"]);
-    await this.runTmuxAllowFailure(["set-hook", "-u", "-t", this.sessionName, "after-split-window"]);
-    this.hookReadAbort?.();
-    this.hookReadAbort = null;
-    this.hookBuffer = "";
-  }
-  async installHook(hookName, fields) {
-    const fifoPath = this.fsPaths.hookFifoPath;
-    const innerScript = `printf '%s\\t%s\\t%s\\n' ${fields.map((field) => quoteShellArg(field)).join(" ")} >> ${quoteShellArg(fifoPath)}`;
-    await this.runTmux([
-      "set-hook",
-      "-t",
-      this.sessionName,
-      hookName,
-      `run-shell -b ${quoteShellArg(innerScript)}`
-    ]);
+    handle.stop = stopReader;
+    return handle;
   }
-  handleHookChunk(text2) {
-    this.hookBuffer += text2;
-    while (true) {
-      const newlineIndex = this.hookBuffer.indexOf(`
-`);
-      if (newlineIndex < 0) {
+  stopControlClient() {
+    const handle = this.controlChannel;
+    this.controlChannel = null;
+    this.controlSubscription?.dispose();
+    this.controlSubscription = null;
+    handle?.stop();
+  }
+  handleControlChannelClose(handle) {
+    if (this.controlChannel !== handle) {
+      return;
+    }
+    this.controlChannel = null;
+    this.controlSubscription?.dispose();
+    this.controlSubscription = null;
+    if (!this.connected || this.manualDisconnect) {
+      return;
+    }
+    this.reconnectControlClient();
+  }
+  async reconnectControlClient() {
+    if (Date.now() - this.controlStartedAt > CONTROL_STABLE_RESET_MS2) {
+      this.controlRestartCount = 0;
+    }
+    this.controlRestartCount += 1;
+    const stderrMessage = this.controlStderrTail.trim();
+    if (this.controlRestartCount > CONTROL_MAX_RESTARTS2) {
+      const message = stderrMessage || "tmux control client channel closed repeatedly";
+      console.warn(`[ssh] tmux control client gave up on ${this.deviceId}: ${message}`);
+      updateDeviceRuntimeStatus(this.deviceId, {
+        lastSeenAt: new Date().toISOString(),
+        tmuxAvailable: false,
+        lastError: message
+      });
+      this.shutdownInternal(true);
+      return;
+    }
+    console.warn(`[ssh] tmux control client channel closed on ${this.deviceId}, reconnecting (attempt ${this.controlRestartCount})`);
+    await new Promise((resolve) => setTimeout(resolve, CONTROL_RESTART_DELAY_MS2 * this.controlRestartCount));
+    if (!this.connected || this.manualDisconnect) {
+      return;
+    }
+    const probe = await this.runTmuxAllowFailure(["has-session", "-t", this.sessionName]);
+    if (probe.exitCode !== 0) {
+      const message = probe.stderr.trim() || probe.stdout.trim() || "tmux session gone";
+      console.warn(`[ssh] tmux session gone on ${this.deviceId}: ${message}`);
+      updateDeviceRuntimeStatus(this.deviceId, {
+        lastSeenAt: new Date().toISOString(),
+        tmuxAvailable: false,
+        lastError: message
+      });
+      this.shutdownInternal(true);
+      return;
+    }
+    if (!this.connected || this.manualDisconnect) {
+      return;
+    }
+    try {
+      await this.startControlClient();
+    } catch (error) {
+      console.warn(`[ssh] control client restart failed on ${this.deviceId}:`, error);
+      return;
+    }
+    this.requestSnapshot();
+    if (this.activePaneId) {
+      this.capturePaneHistory(this.activePaneId).catch(() => {
         return;
-      }
-      const line = this.hookBuffer.slice(0, newlineIndex).trim();
-      this.hookBuffer = this.hookBuffer.slice(newlineIndex + 1);
-      if (!line) {
-        continue;
-      }
-      const [type, windowId, paneId] = line.split("\t");
-      if (type === "bell") {
-        continue;
-      }
-      if (type === "pane-exited" || type === "pane-died" || type === "refresh") {
-        this.requestSnapshot();
-      }
+      });
     }
   }
   async runAndRefresh(argv, allowTargetMissing = false) {
@@ -54541,13 +55048,13 @@ class SshExternalTmuxConnection {
     await this.requestSnapshotInternal();
   }
   async capturePaneHistory(paneId) {
-    const mode = (await this.runTmux(["display-message", "-p", "-t", paneId, "#{alternate_on}"], true)).stdout.trim();
-    const alternateScreen = mode === "1";
-    const normal = (await this.runTmux(["capture-pane", "-t", paneId, "-S", "-", "-E", "-", "-e", "-N", "-p"], true, 30000)).stdout;
-    const alternate = (await this.runTmux(["capture-pane", "-t", paneId, "-a", "-S", "-", "-E", "-", "-e", "-N", "-p", "-q"], true, 30000)).stdout;
+    const screenInfo = parsePaneScreenInfo((await this.runTmux(["display-message", "-p", "-t", paneId, PANE_SCREEN_INFO_FORMAT], true)).stdout);
+    const alternateScreen = screenInfo.alternateScreen;
+    const normal = (await this.runTmux(["capture-pane", "-t", paneId, "-S", "-", "-E", "-", "-e", "-J", "-N", "-p"], true, 30000)).stdout;
+    const alternate = (await this.runTmux(["capture-pane", "-t", paneId, "-a", "-S", "-", "-E", "-", "-e", "-J", "-N", "-p", "-q"], true, 30000)).stdout;
     const history = alternateScreen ? hasRenderableTerminalContent2(normal) ? normal : alternate : normal || alternate;
     if (history) {
-      this.callbacks.onTerminalHistory(paneId, history, alternateScreen);
+      this.callbacks.onTerminalHistory(paneId, appendCursorRestore(history, screenInfo), alternateScreen);
     }
   }
   async requestSnapshotInternal() {
@@ -54598,7 +55105,7 @@ ${panesRes.stderr}`;
     this.parseSnapshotSession(sessionRes.stdout.split(/\r?\n/));
     this.parseSnapshotWindows(windowsRes.stdout.split(/\r?\n/));
     this.parseSnapshotPanes(panesRes.stdout.split(/\r?\n/));
-    await this.syncPipeReaders();
+    this.controlSubscription?.prunePanes(new Set(this.getExpectedPaneIds()));
     this.emitSnapshot();
   }
   parseSnapshotSession(lines) {
@@ -54724,104 +55231,6 @@ ${panesRes.stderr}`;
   getExpectedPaneIds() {
     return Array.from(this.snapshotWindows.values()).sort((left, right) => left.index - right.index).flatMap((window2) => window2.panes.map((pane) => pane.id));
   }
-  async startPipeForPaneNow(paneId) {
-    if (this.paneReaders.has(paneId)) {
-      return;
-    }
-    const fifoPath = this.fsPaths.paneFifoPath(paneId);
-    await this.ensureRemoteRuntimeDirs();
-    await this.runShell(`rm -f ${quoteShellArg(fifoPath)} && mkfifo ${quoteShellArg(fifoPath)} && chmod 600 ${quoteShellArg(fifoPath)}`);
-    const parser = createPaneStreamParser({
-      onTitle: (title) => {
-        this.pendingPaneTitles.set(paneId, title);
-        this.requestSnapshot();
-      },
-      onBell: () => {
-        this.recordBell(paneId);
-      },
-      onNotification: (notification) => {
-        this.emitNotification(paneId, notification);
-      }
-    });
-    const stopReader = await this.openReaderChannel(`exec cat ${quoteShellArg(fifoPath)}`, {
-      onData: (raw) => {
-        const output = parser.push(raw);
-        if (output.length > 0) {
-          this.callbacks.onTerminalOutput(paneId, output);
-        }
-      },
-      onClose: () => {
-        if (this.manualDisconnect) {
-          return;
-        }
-        const existing = this.paneReaders.get(paneId);
-        if (!existing) {
-          return;
-        }
-        console.warn(`[ssh] pane reader channel closed for ${paneId}, resync on next snapshot`);
-        this.paneReaders.delete(paneId);
-        this.runShellAllowFailure(`rm -f ${quoteShellArg(existing.fifoPath)}`);
-        this.requestSnapshot();
-      }
-    });
-    const handle = {
-      paneId,
-      fifoPath,
-      stopReader: () => {
-        stopReader();
-        this.runShellAllowFailure(`rm -f ${quoteShellArg(fifoPath)}`);
-      }
-    };
-    this.paneReaders.set(paneId, handle);
-    try {
-      await this.runTmux(["pipe-pane", "-O", "-t", paneId, `cat >${fifoPath}`]);
-    } catch (error) {
-      this.paneReaders.delete(paneId);
-      handle.stopReader();
-      throw error;
-    }
-  }
-  async stopPipeForPaneNow(paneId) {
-    const handle = this.paneReaders.get(paneId);
-    if (!handle) {
-      return;
-    }
-    this.paneReaders.delete(paneId);
-    await this.runTmuxAllowFailure(["pipe-pane", "-t", paneId]);
-    handle.stopReader();
-  }
-  async syncPipeReaders() {
-    const expectedPaneIds = this.getExpectedPaneIds();
-    const expectedSet = new Set(expectedPaneIds);
-    await this.queuePipeTransition(async () => {
-      for (const paneId of Array.from(this.paneReaders.keys())) {
-        if (!expectedSet.has(paneId)) {
-          await this.stopPipeForPaneNow(paneId);
-        }
-      }
-      for (const paneId of expectedPaneIds) {
-        if (!this.paneReaders.has(paneId)) {
-          await this.startPipeForPaneNow(paneId);
-        }
-      }
-    });
-  }
-  async stopAllPipeReaders() {
-    await this.queuePipeTransition(async () => {
-      for (const paneId of Array.from(this.paneReaders.keys())) {
-        await this.stopPipeForPaneNow(paneId);
-      }
-    });
-  }
-  queuePipeTransition(task) {
-    const next = this.pipeTransition.catch(() => {
-      return;
-    }).then(task);
-    this.pipeTransition = next.catch(() => {
-      return;
-    });
-    return next;
-  }
   async runTmux(argv, allowTargetMissing = false, timeoutMs = 1e4) {
     const result = await this.runTmuxAllowFailure(argv, timeoutMs);
     if (result.exitCode === 0) {
@@ -54949,6 +55358,10 @@ printf '\\036TMEX_END %s %d\\036\\n' ${quoteShellArg(commandId)} $?
       options.onData(data);
     });
     stream.stderr.on("data", (data) => {
+      if (options.onStderr) {
+        options.onStderr(data);
+        return;
+      }
       if (!this.manualDisconnect) {
         this.callbacks.onError(new Error(data.toString().trim() || "SSH reader stderr output"));
       }
@@ -54993,15 +55406,7 @@ printf '\\036TMEX_END %s %d\\036\\n' ${quoteShellArg(commandId)} $?
     }
     this.connected = false;
     this.cleanupPromise = (async () => {
-      await this.stopAllPipeReaders().catch(() => {
-        return;
-      });
-      await this.stopHooks().catch(() => {
-        return;
-      });
-      await this.runShellAllowFailure(`rm -rf ${quoteShellArg(this.fsPaths.rootDir)}`).catch(() => {
-        return;
-      });
+      this.stopControlClient();
       this.rejectPendingCommand(new Error("SSH command channel closed"));
       this.commandStream?.end();
       this.commandStream?.close();
@@ -57816,7 +58221,7 @@ async function serveFrontend(req, staticRoot) {
   if (!requestedPath) {
     return new Response(t3("runtime.forbidden"), { status: 403 });
   }
-  const indexPath = join5(staticRoot, "index.html");
+  const indexPath = join4(staticRoot, "index.html");
   const targetPath = existsSync4(requestedPath) ? requestedPath : indexPath;
   if (!existsSync4(targetPath)) {
     return new Response(t3("runtime.frontendMissing"), { status: 500 });