farming-code 2.2.29 → 2.2.32

package/backend/{native-pty-host.js → native-pty-host.cjs}

@@ -1,172 +1,246 @@
 #!/usr/bin/env node
-
-const crypto = require('crypto');
-const fs = require('fs');
-const net = require('net');
-const os = require('os');
-const path = require('path');
-
-const TerminalScreenWorkerPool = require('./terminal-screen-worker-pool');
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var native_pty_host_exports = {};
+__export(native_pty_host_exports, {
+  NativePtyHost: () => NativePtyHost,
+  startNativePtyHostProcess: () => startNativePtyHostProcess
+});
+module.exports = __toCommonJS(native_pty_host_exports);
+var crypto = __toESM(require("crypto"));
+var fs = __toESM(require("fs"));
+var net = __toESM(require("net"));
+var os = __toESM(require("os"));
+var path = __toESM(require("path"));
+var import_terminal_screen_worker_pool = require("./terminal-screen-worker-pool.cjs");
+var nativePtyHostPathModule = __toESM(require("./native-pty-host-path.cjs"));
+var inputPartsModule = __toESM(require("./input-parts.cjs"));
+var agentEnvModule = __toESM(require("./agent-env.cjs"));
+var shellBusyIntegrationModule = __toESM(require("./shell-busy-integration.cjs"));
+var localSessionEngineModule = __toESM(require("./local-session-engine.cjs"));
+var terminalStatusModule = __toESM(require("./terminal-status.cjs"));
+var terminalRuntimeCleanupModule = __toESM(require("./terminal-runtime-cleanup.cjs"));
+var nativePtyHostIdentityModule = __toESM(require("./native-pty-host-identity.cjs"));
+var runtimeGenerationModule = __toESM(require("./native-pty-controller-generation.cjs"));
+var reducerFlowControlModule = __toESM(require("./terminal-reducer-flow-control.cjs"));
+var terminalStateSerializationModule = __toESM(require("./terminal-state-serialization.cjs"));
+var terminalAttachCheckpointModule = __toESM(require("./terminal-attach-checkpoint.cjs"));
+var terminalExitQuiescenceModule = __toESM(require("./terminal-exit-quiescence.cjs"));
 const {
   nativePtyHostPrivateSocketPath,
-  nativePtyHostSocketPath,
-} = require('./native-pty-host-path');
-const { terminalInputToPtyString } = require('./input-parts');
-const { normalizeInteractiveTerminalEnv } = require('./agent-env');
+  nativePtyHostSocketPath
+} = nativePtyHostPathModule;
+const { terminalInputToPtyString } = inputPartsModule;
+const { normalizeInteractiveTerminalEnv } = agentEnvModule;
 const {
   cleanupShellBusyIntegration,
-  parseShellBusyMarkers,
-} = require('./shell-busy-integration');
+  parseShellBusyMarkers
+} = shellBusyIntegrationModule;
 const {
   extractLatestTerminalTitle,
   normalizeShellSessionOptions,
-  createPtyProcess,
-} = require('./local-session-engine');
-const { deriveTerminalStatus } = require('./terminal-status');
-const { probeUnixSocket } = require('./terminal-runtime-cleanup');
-const { nativePtyHostRuntimeIdentity } = require('./native-pty-host-identity');
+  createPtyProcess
+} = localSessionEngineModule;
+const { deriveTerminalStatus } = terminalStatusModule;
+const { probeUnixSocket } = terminalRuntimeCleanupModule;
+const { nativePtyHostRuntimeIdentity } = nativePtyHostIdentityModule;
 const {
   allocateNativePtyRuntimeGeneration,
-  formatNativePtyRuntimeEpoch,
-} = require('./native-pty-controller-generation');
+  formatNativePtyRuntimeEpoch
+} = runtimeGenerationModule;
 const {
   acknowledgeTerminalReducerData,
   createTerminalReducerFlowControl,
   ensureTerminalReducerFlowControl,
   enqueueTerminalReducerData,
   resetTerminalReducerFlowControl,
-  setTerminalExternalFlowControlBlocked,
-} = require('./terminal-reducer-flow-control');
+  setTerminalExternalFlowControlBlocked
+} = reducerFlowControlModule;
 const {
   normalizeTerminalStateEntry,
-  serializeTerminalState,
-} = require('./terminal-state-serialization');
-const {
-  captureTerminalAttachCheckpoint,
-} = require('./terminal-attach-checkpoint');
+  serializeTerminalState
+} = terminalStateSerializationModule;
+const { captureTerminalAttachCheckpoint } = terminalAttachCheckpointModule;
 const {
   acceptTerminalExitData,
-  waitForTerminalExitDataQuiescence,
-} = require('./terminal-exit-quiescence');
-
-const OUTPUT_LIMIT = 10000;
+  waitForTerminalExitDataQuiescence
+} = terminalExitQuiescenceModule;
+const OUTPUT_LIMIT = 1e4;
 const DEFAULT_COLS = 80;
 const DEFAULT_ROWS = 30;
-const OWNER_CHECK_INTERVAL_MS = 1000;
+const OWNER_CHECK_INTERVAL_MS = 1e3;
 const DISPOSE_PTY_GRACE_MS = 800;
-const DEFAULT_IDLE_EXIT_MS = 60000;
+const DEFAULT_IDLE_EXIT_MS = 6e4;
 const DEFAULT_CLIENT_MAX_BUFFERED_BYTES = 16 * 1024 * 1024;
 const DEFAULT_CLIENT_MAX_REQUEST_BYTES = 16 * 1024 * 1024;
 const HOST_RUNTIME_IDENTITY = nativePtyHostRuntimeIdentity();
-const CONTROLLER_MUTATION_ADMISSION = Symbol('controllerMutationAdmission');
-const TERMINAL_HISTORY_RESTORED_MESSAGE = '\r\n\x1b[7m History restored \x1b[0m\r\n';
-
+const CONTROLLER_MUTATION_ADMISSION = /* @__PURE__ */ Symbol("controllerMutationAdmission");
+const TERMINAL_HISTORY_RESTORED_MESSAGE = "\r\n\x1B[7m History restored \x1B[0m\r\n";
+function errorMessage(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "object" && error !== null && "message" in error) {
+    return String(error.message || "");
+  }
+  return "";
+}
+function errorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code || "") : "";
+}
+function isControllerAdmission(value) {
+  return CONTROLLER_MUTATION_ADMISSION in value && value[CONTROLLER_MUTATION_ADMISSION] === true;
+}
 function trimOutput(output) {
-  const text = typeof output === 'string' ? output : '';
+  const text = typeof output === "string" ? output : "";
   return text.length > OUTPUT_LIMIT ? text.slice(-OUTPUT_LIMIT) : text;
 }
-
 function normalizePositiveInteger(value, fallback, min, max) {
   const parsed = Math.floor(Number(value));
   if (!Number.isFinite(parsed)) return fallback;
   return Math.max(min, Math.min(max, parsed));
 }
-
 function sanitizeAgentEnv(env) {
-  const next = { ...(env || process.env) };
+  const next = { ...env || process.env };
   return normalizeInteractiveTerminalEnv(next, {
     stripRuntimeShims: false,
-    stripNodeOptions: false,
+    stripNodeOptions: false
   });
 }
-
 function socketIdentity(socketPath) {
   const stat = fs.statSync(socketPath, { bigint: true });
   return { dev: stat.dev, ino: stat.ino };
 }
-
 function sameSocketIdentity(left, right) {
   return Boolean(left && right && left.dev === right.dev && left.ino === right.ino);
 }
-
 class NativePtyHost {
+  configDir;
+  socketPath;
+  ownerPid;
+  runtimeIdentity;
+  exitOnShutdown;
+  boundSocketPath;
+  boundSocketIdentity;
+  sessions;
+  clients;
+  ownerCheckTimer;
+  idleExitTimer;
+  hasAcceptedClient;
+  activeControllerClient;
+  activeControllerIdentity;
+  sessionMutationQueues;
+  activeControllerMutations;
+  controllerRegistrationQueue;
+  controllerHandoff;
+  rotationPreparation;
+  terminalExitDataFlushMs;
+  clientMaxBufferedBytes;
+  clientMaxRequestBytes;
+  idleExitMs;
+  disposed;
+  screenWorkerPool;
+  server;
   constructor(options = {}) {
-    this.configDir = options.configDir || process.env.FARMING_CONFIG_DIR || path.join(os.homedir(), '.farming');
+    this.configDir = options.configDir || process.env.FARMING_CONFIG_DIR || path.join(os.homedir(), ".farming");
     this.socketPath = options.socketPath || process.env.FARMING_NATIVE_PTY_HOST_SOCKET || nativePtyHostSocketPath(this.configDir);
     this.ownerPid = Number(options.ownerPid || process.env.FARMING_NATIVE_PTY_HOST_OWNER_PID || 0);
     this.runtimeIdentity = options.runtimeIdentity || HOST_RUNTIME_IDENTITY;
     this.exitOnShutdown = options.exitOnShutdown !== false;
-    this.boundSocketPath = process.platform === 'win32'
-      ? this.socketPath
-      : nativePtyHostPrivateSocketPath(this.socketPath);
+    this.boundSocketPath = process.platform === "win32" ? this.socketPath : nativePtyHostPrivateSocketPath(this.socketPath);
     this.boundSocketIdentity = null;
-    this.sessions = new Map();
-    this.clients = new Set();
+    this.sessions = /* @__PURE__ */ new Map();
+    this.clients = /* @__PURE__ */ new Set();
     this.ownerCheckTimer = null;
     this.idleExitTimer = null;
     this.hasAcceptedClient = false;
     this.activeControllerClient = null;
     this.activeControllerIdentity = null;
-    this.sessionMutationQueues = new Map();
-    this.activeControllerMutations = new Set();
+    this.sessionMutationQueues = /* @__PURE__ */ new Map();
+    this.activeControllerMutations = /* @__PURE__ */ new Set();
     this.controllerRegistrationQueue = Promise.resolve();
     this.controllerHandoff = null;
     this.rotationPreparation = null;
+    this.terminalExitDataFlushMs = options.terminalExitDataFlushMs;
     this.clientMaxBufferedBytes = normalizePositiveInteger(
       options.clientMaxBufferedBytes,
       DEFAULT_CLIENT_MAX_BUFFERED_BYTES,
       1024,
-      256 * 1024 * 1024,
+      256 * 1024 * 1024
     );
     this.clientMaxRequestBytes = normalizePositiveInteger(
       options.clientMaxRequestBytes,
       DEFAULT_CLIENT_MAX_REQUEST_BYTES,
       1024,
-      256 * 1024 * 1024,
+      256 * 1024 * 1024
     );
     this.idleExitMs = normalizePositiveInteger(
       options.idleExitMs ?? process.env.FARMING_NATIVE_PTY_HOST_IDLE_EXIT_MS,
       DEFAULT_IDLE_EXIT_MS,
       0,
-      3600000
+      36e5
     );
     this.disposed = false;
-    this.screenWorkerPool = new TerminalScreenWorkerPool({
+    this.screenWorkerPool = new import_terminal_screen_worker_pool.TerminalScreenWorkerPool({
       size: normalizePositiveInteger(process.env.FARMING_NATIVE_PTY_SCREEN_WORKERS, 3, 0, 12),
       workerOptions: {
         cols: DEFAULT_COLS,
         rows: DEFAULT_ROWS,
-        previewSnapshot: true,
-      },
+        previewSnapshot: true
+      }
     });
   }
-
   async start() {
     await this.prepareSocket();
-    this.server = net.createServer(socket => this.handleConnection(socket));
+    const server = net.createServer((socket) => this.handleConnection(socket));
+    this.server = server;
     await new Promise((resolve, reject) => {
-      this.server.once('error', reject);
-      this.server.listen(this.boundSocketPath, () => {
-        this.server.off('error', reject);
+      server.once("error", reject);
+      server.listen(this.boundSocketPath, () => {
+        server.off("error", reject);
         resolve();
       });
     });
-    if (process.platform !== 'win32') {
+    if (process.platform !== "win32") {
       this.boundSocketIdentity = socketIdentity(this.boundSocketPath);
-      fs.chmodSync(this.boundSocketPath, 0o600);
+      fs.chmodSync(this.boundSocketPath, 384);
       try {
         fs.linkSync(this.boundSocketPath, this.socketPath);
       } catch (error) {
-        await new Promise(resolve => this.server.close(() => resolve()));
+        await new Promise((resolve) => this.server?.close(() => resolve()));
         this.server = null;
         this.boundSocketIdentity = null;
         throw error;
       }
     }
-    console.error(`[${new Date().toISOString()}] Native PTY host listening on ${this.socketPath} ownerPid=${this.ownerPid || ''}`);
+    console.error(`[${(/* @__PURE__ */ new Date()).toISOString()}] Native PTY host listening on ${this.socketPath} ownerPid=${this.ownerPid || ""}`);
     this.startOwnerWatch();
   }
-
   startOwnerWatch() {
     if (!this.ownerPid || this.ownerPid === process.pid || this.ownerCheckTimer) return;
     this.ownerCheckTimer = setInterval(() => {
@@ -176,19 +250,18 @@ class NativePtyHost {
         this.dispose().finally(() => process.exit(0));
       }
     }, OWNER_CHECK_INTERVAL_MS);
-    if (typeof this.ownerCheckTimer.unref === 'function') {
+    if (typeof this.ownerCheckTimer.unref === "function") {
       this.ownerCheckTimer.unref();
     }
   }
-
   async prepareSocket() {
-    if (process.platform === 'win32') return;
+    if (process.platform === "win32") return;
     fs.mkdirSync(path.dirname(this.socketPath), { recursive: true });
     if (fs.existsSync(this.socketPath)) {
       const probe = await probeUnixSocket(this.socketPath);
       if (probe.active) {
         const error = new Error(`Native PTY host socket is already active: ${this.socketPath}`);
-        error.code = 'EADDRINUSE';
+        error.code = "EADDRINUSE";
         error.socketPath = this.socketPath;
         throw error;
       }
@@ -196,57 +269,46 @@ class NativePtyHost {
     try {
       fs.unlinkSync(this.socketPath);
     } catch (error) {
-      if (!error || error.code !== 'ENOENT') throw error;
+      if (errorCode(error) !== "ENOENT") throw error;
     }
     try {
       fs.unlinkSync(this.boundSocketPath);
     } catch (error) {
-      if (!error || error.code !== 'ENOENT') throw error;
+      if (errorCode(error) !== "ENOENT") throw error;
     }
   }
-
   handleConnection(socket) {
-    const client = { socket, buffer: '', disconnected: false };
+    const client = { socket, buffer: "", disconnected: false };
     this.hasAcceptedClient = true;
     this.cancelIdleExit();
     this.clients.add(client);
-    socket.on('data', chunk => this.handleClientData(client, chunk));
-    socket.on('close', () => this.removeClient(client));
-    socket.on('error', () => this.removeClient(client));
+    socket.on("data", (chunk) => this.handleClientData(client, chunk));
+    socket.on("close", () => this.removeClient(client));
+    socket.on("error", () => this.removeClient(client));
   }
-
   removeClient(client) {
     if (!client || client.disconnected === true) return Promise.resolve();
     client.disconnected = true;
     this.clients.delete(client);
     let retirement = Promise.resolve();
-    if (
-      this.activeControllerClient === client
-      || this.controllerHandoff?.fromClient === client
-      || this.controllerHandoff?.toClient === client
-    ) {
-      retirement = this.controllerRegistrationQueue
-        .catch(() => {})
-        .then(() => this.retireControllerClient(client));
+    if (this.activeControllerClient === client || this.controllerHandoff?.fromClient === client || this.controllerHandoff?.toClient === client) {
+      retirement = this.controllerRegistrationQueue.catch(() => {
+      }).then(() => this.retireControllerClient(client));
       this.controllerRegistrationQueue = retirement;
     }
     this.scheduleIdleExitIfUnused();
     return retirement;
   }
-
   async retireControllerClient(client) {
     if (this.activeControllerClient !== client) return;
     const handoff = {
       fromClient: client,
       fromIdentity: this.activeControllerIdentity,
       toClient: null,
-      toIdentity: null,
+      toIdentity: null
     };
     this.controllerHandoff = handoff;
     try {
-      // A disconnect closes admission immediately, but an operation that was
-      // already admitted owns its linearization point until it completes.
-      // Retire the server client only after that exact set has drained.
       await Promise.allSettled([...this.activeControllerMutations]);
       if (this.activeControllerClient !== client) return;
       this.activeControllerClient = null;
@@ -254,56 +316,38 @@ class NativePtyHost {
       if (this.controllerHandoff === handoff) this.controllerHandoff = null;
     }
   }
-
   hasLiveSessions() {
     for (const session of this.sessions.values()) {
-      if (session && session.status !== 'exited') return true;
+      if (session && session.status !== "exited") return true;
     }
     return false;
   }
-
   cancelIdleExit() {
     if (!this.idleExitTimer) return;
     clearTimeout(this.idleExitTimer);
     this.idleExitTimer = null;
   }
-
   scheduleIdleExitIfUnused() {
-    if (
-      this.disposed ||
-      this.ownerPid ||
-      this.idleExitMs <= 0 ||
-      !this.hasAcceptedClient ||
-      this.clients.size > 0 ||
-      this.hasLiveSessions() ||
-      this.idleExitTimer
-    ) {
+    if (this.disposed || this.ownerPid || this.idleExitMs <= 0 || !this.hasAcceptedClient || this.clients.size > 0 || this.hasLiveSessions() || this.idleExitTimer) {
       return;
     }
-
     this.idleExitTimer = setTimeout(() => {
       this.idleExitTimer = null;
-      if (
-        this.disposed ||
-        this.ownerPid ||
-        this.clients.size > 0 ||
-        this.hasLiveSessions()
-      ) {
+      if (this.disposed || this.ownerPid || this.clients.size > 0 || this.hasLiveSessions()) {
         return;
       }
       this.dispose().finally(() => process.exit(0));
     }, this.idleExitMs);
-    if (typeof this.idleExitTimer.unref === 'function') {
+    if (typeof this.idleExitTimer.unref === "function") {
       this.idleExitTimer.unref();
     }
   }
-
   handleClientData(client, chunk) {
-    client.buffer += chunk.toString('utf8');
-    let newline = client.buffer.indexOf('\n');
+    client.buffer += chunk.toString("utf8");
+    let newline = client.buffer.indexOf("\n");
     while (newline >= 0) {
       if (newline > this.clientMaxRequestBytes) {
-        this.disconnectSlowClient(client, 'native pty request exceeded limit');
+        this.disconnectSlowClient(client, "native pty request exceeded limit");
         return;
       }
       const line = client.buffer.slice(0, newline);
@@ -311,13 +355,12 @@ class NativePtyHost {
       if (line.trim()) {
         this.handleClientMessage(client, line);
       }
-      newline = client.buffer.indexOf('\n');
+      newline = client.buffer.indexOf("\n");
     }
     if (client.buffer.length > this.clientMaxRequestBytes) {
-      this.disconnectSlowClient(client, 'native pty request exceeded limit');
+      this.disconnectSlowClient(client, "native pty request exceeded limit");
     }
   }
-
   async handleClientMessage(client, line) {
     let message;
     try {
@@ -325,10 +368,8 @@ class NativePtyHost {
     } catch {
       return;
     }
-
     const id = message && message.id;
     if (!id) return;
-
     try {
       const result = await this.dispatch(message.method, message.params || {}, client);
       this.send(client, { id, ok: true, result });
@@ -336,92 +377,88 @@ class NativePtyHost {
       this.send(client, {
         id,
         ok: false,
-        error: error && error.message ? error.message : 'Native pty host request failed',
+        error: errorMessage(error) || "Native pty host request failed"
       });
     }
   }
-
   dispatch(method, params, client) {
+    const sessionId = typeof params.sessionId === "string" ? params.sessionId : "";
     switch (method) {
-      case 'ping':
+      case "ping":
         return {
           ok: true,
           pid: process.pid,
-          privateSocketPath: process.platform === 'win32' ? '' : this.boundSocketPath,
-          runtimeIdentity: this.runtimeIdentity,
+          privateSocketPath: process.platform === "win32" ? "" : this.boundSocketPath,
+          runtimeIdentity: this.runtimeIdentity
         };
-      case 'registerController':
+      case "registerController":
         return this.registerController(client, params.identity || {});
-      case 'createSession':
+      case "createSession":
         return this.enqueueControllerMutation(
           params.options?.agentId,
           client,
-          () => this.createSession(params.options || {}),
+          () => this.createSession(params.options || { agentId: "", command: "" })
         );
-      case 'sendInput':
+      case "sendInput":
         return this.enqueueControllerMutation(
-          params.sessionId,
+          sessionId,
           client,
-          () => this.sendInput(params.sessionId, params.input, params.expectedRuntimeEpoch || ''),
+          () => this.sendInput(sessionId, params.input, params.expectedRuntimeEpoch || "")
         );
-      case 'resizeSession':
+      case "resizeSession":
         return this.enqueueControllerMutation(
-          params.sessionId,
+          sessionId,
           client,
-          () => this.resizeSession(params.sessionId, params.cols, params.rows),
+          () => this.resizeSession(sessionId, params.cols, params.rows)
         );
-      case 'clearBuffer':
+      case "clearBuffer":
         return this.enqueueControllerMutation(
-          params.sessionId,
+          sessionId,
           client,
-          () => this.clearBuffer(params.sessionId, params.expectedRuntimeEpoch || ''),
+          () => this.clearBuffer(sessionId, params.expectedRuntimeEpoch || "")
         );
-      case 'killSession':
+      case "killSession":
         return this.enqueueControllerMutation(
-          params.sessionId,
+          sessionId,
           client,
-          () => this.killSession(params.sessionId),
+          () => this.killSession(sessionId)
         );
-      case 'getSessionState':
-        return this.getSessionState(params.sessionId);
-      case 'getSessionAttachCheckpoint':
-        return this.getSessionAttachCheckpoint(params.sessionId, client);
-      case 'getSessionPreview':
-        return this.getSessionPreview(params.sessionId);
-      case 'recoverSessions':
+      case "getSessionState":
+        return this.getSessionState(sessionId);
+      case "getSessionAttachCheckpoint":
+        return this.getSessionAttachCheckpoint(sessionId, client);
+      case "getSessionPreview":
+        return this.getSessionPreview(sessionId);
+      case "recoverSessions":
         return this.recoverSessions();
-      case 'serializeTerminalState':
+      case "serializeTerminalState":
         return this.serializeTerminalState(client);
-      case 'resumeTerminalState':
-        return this.resumeTerminalState(client, params.preparationToken || '');
-      case 'updateSessionMetadata':
+      case "resumeTerminalState":
+        return this.resumeTerminalState(client, params.preparationToken || "");
+      case "updateSessionMetadata":
         return this.enqueueControllerMutation(
-          params.sessionId,
+          sessionId,
           client,
-          () => this.updateSessionMetadata(params.sessionId, params.patch || {}),
+          () => this.updateSessionMetadata(sessionId, params.patch || {})
         );
-      case 'shutdownHost':
+      case "shutdownHost":
         return this.shutdownHost(
           client,
           params.controller || {},
-          params.preparationToken || '',
+          params.preparationToken || ""
         );
       default:
         throw new Error(`Unknown native pty host method: ${method}`);
     }
   }
-
   enqueueControllerMutation(sessionId, client, operation) {
-    // Admission is fenced before queueing. Once a newer controller starts its
-    // handoff, no additional work from the retiring controller may enter the
-    // mutation set; work admitted before that cut is allowed to finish.
     try {
       this.assertActiveController(client);
       if (this.controllerHandoff) {
-        throw new Error('Native pty controller handoff is in progress');
+        throw new Error("Native pty controller handoff is in progress");
       }
       if (this.rotationPreparation) {
-        throw new Error('Native pty host is frozen for runtime rotation');
+        throw new Error("Native pty host is frozen for runtime rotation");
       }
     } catch (error) {
       return Promise.reject(error);
@@ -430,18 +467,17 @@ class NativePtyHost {
       [CONTROLLER_MUTATION_ADMISSION]: true,
       client,
       controllerId: client.controllerId,
-      controllerGeneration: client.controllerGeneration,
+      controllerGeneration: client.controllerGeneration
     });
-    const key = typeof sessionId === 'string' && sessionId ? sessionId : '__host__';
+    const key = typeof sessionId === "string" && sessionId ? sessionId : "__host__";
     const previous = this.sessionMutationQueues.get(key) || Promise.resolve();
-    const next = previous
-      .catch(() => {})
-      .then(() => {
-        if (this.rotationPreparation) {
-          throw new Error('Native pty host is frozen for runtime rotation');
-        }
-        return operation(admission);
-      });
+    const next = previous.catch(() => {
+    }).then(() => {
+      if (this.rotationPreparation) {
+        throw new Error("Native pty host is frozen for runtime rotation");
+      }
+      return operation(admission);
+    });
     this.activeControllerMutations.add(next);
     this.sessionMutationQueues.set(key, next);
     const cleanup = () => {
@@ -453,195 +489,161 @@ class NativePtyHost {
     next.then(cleanup, cleanup);
     return next;
   }
-
   send(client, message) {
-    this.writeClientMessage(client, `${JSON.stringify(message)}\n`);
+    this.writeClientMessage(client, `${JSON.stringify(message)}
+`);
   }
-
   disconnectSlowClient(client, reason) {
     if (!client || !client.socket || client.socket.destroyed) return false;
     client.socket.destroy(new Error(reason));
     return true;
   }
-
   writeClientMessage(client, message) {
     if (!client || !client.socket || client.socket.destroyed) return false;
     if (client.socket.writableLength > this.clientMaxBufferedBytes) {
-      this.disconnectSlowClient(client, 'native pty client backpressure');
+      this.disconnectSlowClient(client, "native pty client backpressure");
       return false;
     }
     const accepted = client.socket.write(message);
     if (!accepted && client.socket.writableLength > this.clientMaxBufferedBytes) {
-      this.disconnectSlowClient(client, 'native pty client backpressure');
+      this.disconnectSlowClient(client, "native pty client backpressure");
       return false;
     }
     return true;
   }
-
   broadcast(event, payload) {
-    const message = `${JSON.stringify({ event, payload })}\n`;
+    const message = `${JSON.stringify({ event, payload })}
+`;
     for (const client of this.clients) {
       this.writeClientMessage(client, message);
     }
   }
-
   emitSessionEvent(event, payload) {
     this.broadcast(event, payload);
   }
-
   registerController(client, rawIdentity) {
     if (!client || client.disconnected === true) {
-      throw new Error('Native pty controller client is disconnected');
+      throw new Error("Native pty controller client is disconnected");
     }
     const identity = {
-      id: typeof rawIdentity.id === 'string' ? rawIdentity.id : '',
-      generation: Math.floor(Number(rawIdentity.generation)),
+      id: typeof rawIdentity.id === "string" ? rawIdentity.id : "",
+      generation: Math.floor(Number(rawIdentity.generation))
     };
     if (!identity.id || !Number.isFinite(identity.generation) || identity.generation <= 0) {
-      throw new Error('Invalid native pty controller identity');
-    }
-
-    const registration = this.controllerRegistrationQueue
-      .catch(() => {})
-      .then(async () => {
-        const current = this.activeControllerIdentity;
-        if (
-          current &&
-          (identity.generation < current.generation ||
-            (identity.generation === current.generation && current.id !== identity.id))
-        ) {
-          throw new Error('Stale native pty controller');
-        }
-
-        const replacesController = !current
-          || current.id !== identity.id
-          || current.generation !== identity.generation
-          || this.activeControllerClient !== client;
-        if (replacesController && current) {
-          const handoff = {
-            fromClient: this.activeControllerClient,
-            fromIdentity: current,
-            toClient: client,
-            toIdentity: identity,
-          };
-          this.controllerHandoff = handoff;
-          try {
-            // New admissions from the retiring controller are now closed.
-            // Drain the exact set admitted before that cut before publishing
-            // the new generation as active.
-            await Promise.allSettled([...this.activeControllerMutations]);
-          } finally {
-            if (this.controllerHandoff === handoff) this.controllerHandoff = null;
-          }
-        }
-
-        if (client.disconnected === true) {
-          throw new Error('Native pty controller client is disconnected');
-        }
-
-        this.activeControllerIdentity = identity;
-        this.activeControllerClient = client;
-        client.controllerId = identity.id;
-        client.controllerGeneration = identity.generation;
-        return {
-          registered: true,
-          controllerId: identity.id,
-          controllerGeneration: identity.generation,
+      throw new Error("Invalid native pty controller identity");
+    }
+    const registration = this.controllerRegistrationQueue.catch(() => {
+    }).then(async () => {
+      const current = this.activeControllerIdentity;
+      if (current && (identity.generation < current.generation || identity.generation === current.generation && current.id !== identity.id)) {
+        throw new Error("Stale native pty controller");
+      }
+      const replacesController = !current || current.id !== identity.id || current.generation !== identity.generation || this.activeControllerClient !== client;
+      if (replacesController && current) {
+        const handoff = {
+          fromClient: this.activeControllerClient,
+          fromIdentity: current,
+          toClient: client,
+          toIdentity: identity
         };
-      });
+        this.controllerHandoff = handoff;
+        try {
+          await Promise.allSettled([...this.activeControllerMutations]);
+        } finally {
+          if (this.controllerHandoff === handoff) this.controllerHandoff = null;
+        }
+      }
+      if (client.disconnected === true) {
+        throw new Error("Native pty controller client is disconnected");
+      }
+      this.activeControllerIdentity = identity;
+      this.activeControllerClient = client;
+      client.controllerId = identity.id;
+      client.controllerGeneration = identity.generation;
+      return {
+        registered: true,
+        controllerId: identity.id,
+        controllerGeneration: identity.generation
+      };
+    });
     this.controllerRegistrationQueue = registration;
     return registration;
   }
-
   assertActiveController(client) {
-    if (client?.[CONTROLLER_MUTATION_ADMISSION] === true) return;
-    if (
-      !client ||
-      client.disconnected === true ||
-      client !== this.activeControllerClient ||
-      !this.activeControllerIdentity ||
-      client.controllerId !== this.activeControllerIdentity.id ||
-      client.controllerGeneration !== this.activeControllerIdentity.generation
-    ) {
-      throw new Error('Native pty mutation requires the active controller');
+    if (client && isControllerAdmission(client)) return;
+    if (!client || client.disconnected === true || client !== this.activeControllerClient || !this.activeControllerIdentity || client.controllerId !== this.activeControllerIdentity.id || client.controllerGeneration !== this.activeControllerIdentity.generation) {
+      throw new Error("Native pty mutation requires the active controller");
     }
   }
-
   async createSession(options) {
     if (this.rotationPreparation) {
-      throw new Error('Native pty host is frozen for runtime rotation');
+      throw new Error("Native pty host is frozen for runtime rotation");
     }
     this.cancelIdleExit();
-    const normalized = options.shellIntegrationPrepared === true
-      ? {
-        ...options,
-        args: [...(options.args || [])],
-        env: sanitizeAgentEnv(options.env),
-      }
-      : normalizeShellSessionOptions({
-        ...options,
-        env: sanitizeAgentEnv(options.env),
-      });
+    const normalized = options.shellIntegrationPrepared === true ? {
+      ...options,
+      args: [...options.args || []],
+      env: sanitizeAgentEnv(options.env)
+    } : normalizeShellSessionOptions({
+      ...options,
+      env: sanitizeAgentEnv(options.env)
+    });
     const agentId = normalized.agentId;
     if (!agentId) {
-      throw new Error('Missing native pty session id');
+      throw new Error("Missing native pty session id");
     }
-
     const existing = this.sessions.get(agentId);
-    if (existing && existing.status !== 'exited') {
+    if (existing && existing.status !== "exited") {
       return { sessionId: agentId, status: existing.status };
     }
-
-    const reviveState = options.reviveState
-      ? normalizeTerminalStateEntry(options.reviveState)
-      : null;
+    const reviveState = options.reviveState ? normalizeTerminalStateEntry(options.reviveState) : null;
     const reviveEvent = reviveState?.replayEvent?.events?.[0] || null;
     const cols = reviveEvent?.cols || normalized.cols || DEFAULT_COLS;
     const rows = reviveEvent?.rows || normalized.rows || DEFAULT_ROWS;
     const runtimeGeneration = await allocateNativePtyRuntimeGeneration(this.configDir);
     const runtimeEpoch = formatNativePtyRuntimeEpoch(runtimeGeneration);
     const screenWorker = await this.screenWorkerPool.acquire({ cols, rows, runtimeEpoch });
-    const replayText = reviveEvent?.data || '';
-    const restoredOutput = reviveState
-      ? `${replayText}${TERMINAL_HISTORY_RESTORED_MESSAGE}`
-      : '';
+    const replayText = reviveEvent?.data || "";
+    const restoredOutput = reviveState ? `${replayText}${TERMINAL_HISTORY_RESTORED_MESSAGE}` : "";
     let restoredScreenState = null;
     if (restoredOutput) {
       try {
         await screenWorker.append(restoredOutput, 1, 1);
         restoredScreenState = await screenWorker.getState();
       } catch (error) {
-        await screenWorker.dispose().catch(() => {});
-        throw new Error(`Failed to restore serialized terminal history: ${error.message}`, {
-          cause: error,
+        await screenWorker.dispose().catch(() => {
+        });
+        throw new Error(`Failed to restore serialized terminal history: ${errorMessage(error)}`, {
+          cause: error
         });
       }
     }
+    const persistedCommand = normalized.metadata?.command;
+    const persistedStartedAt = normalized.metadata?.startedAt;
     const metadata = {
-      ...(normalized.metadata || {}),
+      ...normalized.metadata || {},
       protocolVersion: 1,
-      engineName: 'native',
+      engineName: "native",
       agentId,
-      command: normalized.metadata?.command || normalized.command,
+      command: typeof persistedCommand === "string" && persistedCommand ? persistedCommand : normalized.command,
       cwd: normalized.cwd || process.cwd(),
-      startedAt: normalized.metadata?.startedAt || Date.now(),
+      startedAt: typeof persistedStartedAt === "number" && Number.isFinite(persistedStartedAt) ? persistedStartedAt : Date.now()
     };
-
     let ptyProcess;
     try {
       ptyProcess = createPtyProcess(normalized.command, normalized.args || [], {
-        name: 'xterm-256color',
+        name: "xterm-256color",
         cols,
         rows,
         cwd: normalized.cwd,
-        env: normalized.env || process.env,
+        env: normalized.env || process.env
       });
     } catch (error) {
       cleanupShellBusyIntegration(normalized.shellBusyIntegration);
-      await screenWorker.dispose().catch(() => {});
+      await screenWorker.dispose().catch(() => {
+      });
       throw error;
     }
-
     const session = {
       id: agentId,
       command: normalized.command,
@@ -662,39 +664,38 @@ class NativePtyHost {
       previewSnapshot: restoredScreenState?.previewSnapshot || null,
       previewCols: restoredScreenState?.cols || cols,
       previewRows: restoredScreenState?.rows || rows,
-      title: restoredScreenState?.title || '',
-      status: 'running',
+      title: restoredScreenState?.title || "",
+      status: "running",
       terminalBusy: null,
-      shellCwd: '',
+      shellCwd: "",
       shellLastExitCode: null,
-      shellLastEvent: '',
-      shellCommand: '',
-      shellLastCommand: '',
+      shellLastEvent: "",
+      shellCommand: "",
+      shellLastCommand: "",
       shellCommandStartedAt: null,
       shellLastCommandStartedAt: null,
       shellLastCommandFinishedAt: null,
       shellLastCommandDurationMs: null,
-      shellBusyMarkerPending: '',
+      shellBusyMarkerPending: "",
       shellBusyIntegration: normalized.shellBusyIntegration || null,
       startedAt: metadata.startedAt || Date.now(),
       lastActivityAt: Date.now(),
       exitedAt: null,
-      screenWorker,
+      screenWorker
     };
-
     this.sessions.set(agentId, session);
     this.bindScreenWorker(session);
     this.bindPty(session);
-    this.emitSessionEvent('session-started', {
+    this.emitSessionEvent("session-started", {
       sessionId: agentId,
       status: session.status,
       startedAt: session.startedAt,
       runtimeEpoch: session.runtimeEpoch,
       outputSeq: session.outputSeq,
-      stateRevision: session.stateRevision,
+      stateRevision: session.stateRevision
     });
     if (restoredOutput) {
-      this.emitSessionEvent('session-sync', {
+      this.emitSessionEvent("session-sync", {
         sessionId: agentId,
         output: session.renderOutput,
         textOutput: session.output,
@@ -704,93 +705,80 @@ class NativePtyHost {
         stateRevision: session.stateRevision,
         cols: session.previewCols,
         rows: session.previewRows,
-        revived: true,
+        revived: true
       });
     }
-
     return { sessionId: agentId, status: session.status };
   }
-
   bindScreenWorker(session) {
-    session.screenWorker.on('preview', ({ previewText, title, cols, rows, previewSnapshot }) => {
+    const screenWorker = session.screenWorker;
+    if (!screenWorker) throw new TypeError("Terminal screen worker is unavailable");
+    screenWorker.on("preview", ({ previewText, title, cols, rows, previewSnapshot }) => {
       const current = this.sessions.get(session.id);
       if (current !== session) return;
-
-      current.previewText = previewText || '';
+      current.previewText = previewText || "";
       current.previewSnapshot = previewSnapshot || null;
       current.previewCols = cols || current.previewCols;
       current.previewRows = rows || current.previewRows;
-
       if (title && title !== current.title) {
         current.title = title;
-        this.emitSessionEvent('session-title', {
+        this.emitSessionEvent("session-title", {
           sessionId: current.id,
           title: current.title,
-          runtimeEpoch: current.runtimeEpoch,
+          runtimeEpoch: current.runtimeEpoch
         });
       }
-
-      this.emitSessionEvent('session-preview', {
+      this.emitSessionEvent("session-preview", {
         sessionId: current.id,
         previewText: current.previewText,
         cols: current.previewCols,
         rows: current.previewRows,
         previewSnapshot: current.previewSnapshot,
-        runtimeEpoch: current.runtimeEpoch,
+        runtimeEpoch: current.runtimeEpoch
       });
     });
-
-    session.screenWorker.on('error', error => {
+    screenWorker.on("error", (error) => {
       this.failSessionScreenState(session, error);
     });
   }
-
   failSessionScreenState(session, error) {
     const current = this.sessions.get(session.id);
     if (current !== session || current.stateProofAvailable === false) return;
     current.stateProofAvailable = false;
-    const message = error instanceof Error ? error.message : String(error || 'unknown reducer failure');
-    this.emitSessionEvent('session-error', {
+    const message = error instanceof Error ? error.message : String(error || "unknown reducer failure");
+    this.emitSessionEvent("session-error", {
       sessionId: current.id,
       error: `Terminal state reducer failed: ${message}`,
       fatal: true,
-      runtimeEpoch: current.runtimeEpoch,
+      runtimeEpoch: current.runtimeEpoch
     });
     try {
       current.process?.kill();
     } catch {
-      // The session is already unusable because its authoritative reducer failed.
     }
   }
-
   bindPty(session) {
-    session.process.onData(data => this.handleSessionData(session.id, data, session));
+    session.process.onData((data) => this.handleSessionData(session.id, data, session));
     session.process.onExit(({ code }) => {
-      this.handleSessionExit(session.id, code, session).catch(error => {
+      this.handleSessionExit(session.id, code, session).catch((error) => {
         if (this.sessions.get(session.id) !== session) return;
-        this.emitSessionEvent('session-error', {
+        this.emitSessionEvent("session-error", {
           sessionId: session.id,
           error: error.message,
           fatal: false,
-          runtimeEpoch: session.runtimeEpoch,
+          runtimeEpoch: session.runtimeEpoch
         });
       });
     });
   }
-
   handleSessionData(sessionId, rawData, expectedSession = null) {
     const current = this.sessions.get(sessionId);
-    if (
-      !current ||
-      (expectedSession && current !== expectedSession) ||
-      current.stateProofAvailable === false
-    ) return;
+    if (!current || expectedSession && current !== expectedSession || current.stateProofAvailable === false) return;
     if (!acceptTerminalExitData(current)) {
       current.finalCheckpoint = null;
-      this.failSessionScreenState(current, new Error('PTY emitted data after its final checkpoint cut'));
+      this.failSessionScreenState(current, new Error("PTY emitted data after its final checkpoint cut"));
       return;
     }
-
     const busyState = parseShellBusyMarkers(rawData, current.terminalBusy, current.shellBusyMarkerPending);
     current.shellBusyMarkerPending = busyState.pending;
     if (busyState.markerSeen) {
@@ -805,26 +793,26 @@ class NativePtyHost {
       if (busyState.shellEvent) {
         current.shellLastEvent = busyState.shellEvent;
       }
-      if (busyState.shellEvent === 'start') {
+      if (busyState.shellEvent === "start") {
         current.shellCommandStartedAt = markerAt;
       }
       if (busyState.commandTextSeen) {
-        current.shellCommand = busyState.shellCommand || '';
+        current.shellCommand = busyState.shellCommand || "";
       }
-      if (busyState.shellEvent === 'finish') {
+      if (busyState.shellEvent === "finish") {
         const commandStartedAt = current.shellCommandStartedAt;
         if (current.shellCommand) {
           current.shellLastCommand = current.shellCommand;
         }
-        if (typeof commandStartedAt === 'number') {
+        if (typeof commandStartedAt === "number") {
           current.shellLastCommandStartedAt = commandStartedAt;
           current.shellLastCommandFinishedAt = markerAt;
           current.shellLastCommandDurationMs = Math.max(0, markerAt - commandStartedAt);
         }
-        current.shellCommand = '';
+        current.shellCommand = "";
         current.shellCommandStartedAt = null;
       }
-      this.emitSessionEvent('session-busy-state', {
+      this.emitSessionEvent("session-busy-state", {
         sessionId,
         terminalBusy: current.terminalBusy,
         cwd: current.shellCwd || current.cwd,
@@ -838,17 +826,15 @@ class NativePtyHost {
         shellLastCommandDurationMs: current.shellLastCommandDurationMs,
         statusMarkerSeen: busyState.statusMarkerSeen,
         busyMarkerSeen: busyState.busyMarkerSeen,
-        runtimeEpoch: current.runtimeEpoch,
+        runtimeEpoch: current.runtimeEpoch
       });
     }
-
     const data = busyState.data;
     if (!data) return;
-
     const reducerDelivery = enqueueTerminalReducerData(
       ensureTerminalReducerFlowControl(current),
       current.process,
-      data,
+      data
     );
     if (reducerDelivery.error) {
       this.failSessionScreenState(current, reducerDelivery.error);
@@ -860,17 +846,15 @@ class NativePtyHost {
     const stateRevision = current.stateRevision;
     current.output = trimOutput(current.output + data);
     current.lastActivityAt = Date.now();
-
     const fallbackTitle = extractLatestTerminalTitle(data);
     if (fallbackTitle && fallbackTitle !== current.title) {
       current.title = fallbackTitle;
-      this.emitSessionEvent('session-title', {
+      this.emitSessionEvent("session-title", {
         sessionId,
         title: current.title,
-        runtimeEpoch: current.runtimeEpoch,
+        runtimeEpoch: current.runtimeEpoch
       });
     }
-
     if (current.screenWorker) {
       const commit = current.screenWorker.append(data, stateRevision, outputSeq);
       current.reducerCommitQueue = current.reducerCommitQueue.then(() => commit).then(() => {
@@ -879,49 +863,43 @@ class NativePtyHost {
         const flowError = acknowledgeTerminalReducerData(
           ensureTerminalReducerFlowControl(latest),
           latest.process,
-          reducerDelivery.bytes,
+          reducerDelivery.bytes
         );
         if (flowError) {
           this.failSessionScreenState(latest, flowError);
           return;
         }
-        this.emitSessionEvent('session-output', {
+        this.emitSessionEvent("session-output", {
           sessionId,
           data,
           runtimeEpoch: latest.runtimeEpoch,
           outputSeq,
-          stateRevision,
+          stateRevision
         });
-        this.emitSessionEvent('session-activity', {
+        this.emitSessionEvent("session-activity", {
           sessionId,
           lastActivityAt: latest.lastActivityAt,
-          runtimeEpoch: latest.runtimeEpoch,
+          runtimeEpoch: latest.runtimeEpoch
         });
-      }).catch(error => this.failSessionScreenState(current, error));
+      }).catch((error) => this.failSessionScreenState(current, error));
     }
   }
-
   handleSessionExit(sessionId, code, expectedSession = null) {
     const session = this.sessions.get(sessionId);
-    if (
-      !session ||
-      (expectedSession && session !== expectedSession) ||
-      session.status === 'exited'
-    ) return Promise.resolve();
+    if (!session || expectedSession && session !== expectedSession || session.status === "exited") return Promise.resolve();
     if (session.exitFinalizationPromise) return session.exitFinalizationPromise;
     const finalization = this.finalizeSessionExit(sessionId, code, session);
     session.exitFinalizationPromise = finalization;
     return finalization;
   }
-
   async finalizeSessionExit(sessionId, code, session) {
     const quiesced = await waitForTerminalExitDataQuiescence(session, {
       flushMs: this.terminalExitDataFlushMs,
-      isCurrent: () => this.sessions.get(sessionId) === session,
+      isCurrent: () => this.sessions.get(sessionId) === session
     });
     if (!quiesced) return;
-
-    await Promise.resolve(session.reducerCommitQueue).catch(() => {});
+    await Promise.resolve(session.reducerCommitQueue).catch(() => {
+    });
     if (this.sessions.get(sessionId) !== session) return;
     const finalCheckpoint = await captureTerminalAttachCheckpoint(session, { requireCurrentCut: true });
     if (this.sessions.get(sessionId) !== session) return;
@@ -934,64 +912,61 @@ class NativePtyHost {
       session.previewRows = finalCheckpoint.rows;
       session.title = finalCheckpoint.title || session.title;
     } else {
-      this.failSessionScreenState(session, new Error('Unable to capture the exact final Terminal checkpoint'));
+      this.failSessionScreenState(session, new Error("Unable to capture the exact final Terminal checkpoint"));
     }
-
-    session.status = 'exited';
+    session.status = "exited";
     session.exitedAt = Date.now();
     resetTerminalReducerFlowControl(
       ensureTerminalReducerFlowControl(session),
-      session.process,
+      session.process
     );
     cleanupShellBusyIntegration(session.shellBusyIntegration);
     if (session.screenWorker) {
-      await session.screenWorker.dispose().catch(() => {});
+      await session.screenWorker.dispose().catch(() => {
+      });
       session.screenWorker = null;
     }
-
-    this.emitSessionEvent('session-exited', {
+    this.emitSessionEvent("session-exited", {
       sessionId,
-      code: code == null ? 'unknown' : code,
+      code: code == null ? "unknown" : code,
       exitedAt: session.exitedAt,
       runtimeEpoch: session.runtimeEpoch,
       outputSeq: session.outputSeq,
       stateRevision: session.stateRevision,
-      stateProofAvailable: session.stateProofAvailable !== false,
+      stateProofAvailable: session.stateProofAvailable !== false
     });
     if (finalCheckpoint) {
-      this.emitSessionEvent('session-preview', {
+      this.emitSessionEvent("session-preview", {
         sessionId,
         previewText: session.previewText,
         cols: session.previewCols,
         rows: session.previewRows,
         previewSnapshot: session.previewSnapshot,
-        runtimeEpoch: session.runtimeEpoch,
+        runtimeEpoch: session.runtimeEpoch
       });
     }
     this.scheduleIdleExitIfUnused();
   }
-
-  async sendInput(sessionId, input, expectedRuntimeEpoch = '') {
+  async sendInput(sessionId, input, expectedRuntimeEpoch = "") {
     const session = this.sessions.get(sessionId);
-    if (!session || !session.process || session.status === 'exited' || session.exitFinalizing === true) {
-      throw new Error('Session not available');
+    if (!session || !session.process || session.status === "exited" || session.exitFinalizing === true) {
+      throw new Error("Session not available");
     }
     if (session.rotationFrozen === true) {
-      throw new Error('Terminal session is frozen for native PTY host rotation');
+      throw new Error("Terminal session is frozen for native PTY host rotation");
     }
     if (expectedRuntimeEpoch && expectedRuntimeEpoch !== session.runtimeEpoch) {
-      return { status: 'input-rejected', reason: 'runtime-epoch-mismatch' };
+      return { status: "input-rejected", reason: "runtime-epoch-mismatch" };
     }
     session.process.write(terminalInputToPtyString(input));
     session.lastActivityAt = Date.now();
-    this.emitSessionEvent('session-activity', {
+    this.emitSessionEvent("session-activity", {
       sessionId,
       lastActivityAt: session.lastActivityAt,
-      runtimeEpoch: session.runtimeEpoch,
+      runtimeEpoch: session.runtimeEpoch
     });
     return { sent: true };
   }
-
   async getSessionAttachCheckpoint(sessionId, client) {
     this.assertActiveController(client);
     const session = this.sessions.get(sessionId);
@@ -999,34 +974,35 @@ class NativePtyHost {
     const checkpoint = await captureTerminalAttachCheckpoint(session);
     return this.sessions.get(sessionId) === session ? checkpoint : null;
   }
-
   async resizeSession(sessionId, cols, rows) {
     const session = this.sessions.get(sessionId);
-    if (!session || !session.process || session.status === 'exited' || session.exitFinalizing === true) {
-      return { status: 'resize-rejected', reason: 'session-unavailable', resized: false };
+    if (!session || !session.process || session.status === "exited" || session.exitFinalizing === true) {
+      return { status: "resize-rejected", reason: "session-unavailable", resized: false };
     }
     if (session.rotationFrozen === true) {
-      return { status: 'resize-rejected', reason: 'runtime-rotation', resized: false };
+      return { status: "resize-rejected", reason: "runtime-rotation", resized: false };
     }
-
-    const nextCols = normalizePositiveInteger(cols, session.previewCols || DEFAULT_COLS, 1, 1000);
-    const nextRows = normalizePositiveInteger(rows, session.previewRows || DEFAULT_ROWS, 1, 1000);
+    const nextCols = normalizePositiveInteger(cols, session.previewCols || DEFAULT_COLS, 1, 1e3);
+    const nextRows = normalizePositiveInteger(rows, session.previewRows || DEFAULT_ROWS, 1, 1e3);
     if (nextCols === session.previewCols && nextRows === session.previewRows) {
       return {
-        status: 'resize-committed',
+        status: "resize-committed",
         resized: true,
-        unchanged: true,
+        unchanged: true
       };
     }
-
+    const resize = session.process.resize;
+    if (!resize) {
+      return { status: "resize-rejected", reason: "session-unavailable", resized: false };
+    }
     try {
-      session.process.resize(nextCols, nextRows);
+      resize.call(session.process, nextCols, nextRows);
     } catch (error) {
       return {
-        status: 'resize-rejected',
-        reason: 'pty-resize-failed',
+        status: "resize-rejected",
+        reason: "pty-resize-failed",
         resized: false,
-        error: error instanceof Error ? error.message : String(error || 'unknown PTY resize failure'),
+        error: error instanceof Error ? error.message : String(error || "unknown PTY resize failure")
       };
     }
     session.stateRevision += 1;
@@ -1035,135 +1011,120 @@ class NativePtyHost {
     const runtimeEpoch = session.runtimeEpoch;
     session.previewCols = nextCols;
     session.previewRows = nextRows;
-
     if (session.screenWorker) {
       const reducerCommit = session.screenWorker.resize(nextCols, nextRows, stateRevision);
       const publishedCommit = session.reducerCommitQueue.then(() => reducerCommit).then((screenState) => {
         if (this.sessions.get(sessionId) !== session) {
-          throw new Error('Terminal session was replaced during resize');
+          throw new Error("Terminal session was replaced during resize");
         }
-        if (
-          screenState.runtimeEpoch !== runtimeEpoch ||
-          screenState.outputSeq !== outputSeq ||
-          screenState.stateRevision !== stateRevision
-        ) {
-          throw new Error('Terminal screen resize returned a non-authoritative state cut');
+        if (screenState.runtimeEpoch !== runtimeEpoch || screenState.outputSeq !== outputSeq || screenState.stateRevision !== stateRevision) {
+          throw new Error("Terminal screen resize returned a non-authoritative state cut");
         }
-        session.previewText = screenState.previewText || '';
+        session.previewText = screenState.previewText || "";
         session.previewSnapshot = screenState.previewSnapshot || session.previewSnapshot;
-        session.renderOutput = typeof screenState.renderOutput === 'string'
-          ? screenState.renderOutput
-          : session.renderOutput;
+        session.renderOutput = typeof screenState.renderOutput === "string" ? screenState.renderOutput : session.renderOutput;
         session.previewCols = screenState.cols || nextCols;
         session.previewRows = screenState.rows || nextRows;
         session.title = screenState.title || session.title;
-        this.emitSessionEvent('session-transition', {
+        this.emitSessionEvent("session-transition", {
           sessionId,
-          kind: 'resize',
-          data: '',
+          kind: "resize",
+          data: "",
           runtimeEpoch: screenState.runtimeEpoch,
           outputSeq: screenState.outputSeq,
           stateRevision: screenState.stateRevision,
           cols: screenState.cols,
-          rows: screenState.rows,
+          rows: screenState.rows
         });
         return screenState;
       });
-      session.reducerCommitQueue = publishedCommit.catch(error => {
+      session.reducerCommitQueue = publishedCommit.catch((error) => {
         this.failSessionScreenState(session, error);
       });
       try {
         await publishedCommit;
       } catch {
-        return { status: 'resize-rejected', reason: 'screen-reducer-failed', resized: false };
+        return { status: "resize-rejected", reason: "screen-reducer-failed", resized: false };
       }
     }
     if (this.sessions.get(sessionId) !== session) {
-      return { status: 'resize-rejected', reason: 'session-replaced', resized: false };
+      return { status: "resize-rejected", reason: "session-replaced", resized: false };
     }
-
     return {
-      status: 'resize-committed',
+      status: "resize-committed",
       resized: true,
       unchanged: false,
       runtimeEpoch,
       outputSeq,
       stateRevision,
       cols: nextCols,
-      rows: nextRows,
+      rows: nextRows
     };
   }
-
-  async clearBuffer(sessionId, expectedRuntimeEpoch = '') {
+  async clearBuffer(sessionId, expectedRuntimeEpoch = "") {
     const session = this.sessions.get(sessionId);
-    if (!session || session.status === 'exited' || session.exitFinalizing === true) {
+    if (!session || session.status === "exited" || session.exitFinalizing === true) {
       return { cleared: false };
     }
     if (session.rotationFrozen === true) {
-      return { cleared: false, reason: 'runtime-rotation' };
+      return { cleared: false, reason: "runtime-rotation" };
     }
     if (expectedRuntimeEpoch && expectedRuntimeEpoch !== session.runtimeEpoch) {
-      return { cleared: false, reason: 'runtime-epoch-mismatch' };
+      return { cleared: false, reason: "runtime-epoch-mismatch" };
     }
-
-    session.output = '';
+    session.output = "";
     session.stateRevision += 1;
     const stateRevision = session.stateRevision;
     const outputSeq = session.outputSeq;
     const runtimeEpoch = session.runtimeEpoch;
-    session.renderOutput = '';
-    session.previewText = '';
+    session.renderOutput = "";
+    session.previewText = "";
     session.previewSnapshot = null;
     session.lastActivityAt = Date.now();
-
     let exactState = {
-      renderOutput: '',
+      renderOutput: "",
       runtimeEpoch,
       outputSeq,
       stateRevision,
       cols: session.previewCols,
-      rows: session.previewRows,
+      rows: session.previewRows
     };
     if (session.screenWorker) {
       const reducerCommit = session.screenWorker.clear(stateRevision, outputSeq);
       const publishedCommit = session.reducerCommitQueue.then(() => reducerCommit).then((screenState) => {
         if (this.sessions.get(sessionId) !== session) {
-          throw new Error('Terminal session was replaced during clear');
+          throw new Error("Terminal session was replaced during clear");
         }
-        if (
-          screenState.runtimeEpoch !== runtimeEpoch ||
-          screenState.outputSeq !== outputSeq ||
-          screenState.stateRevision !== stateRevision
-        ) {
-          throw new Error('Terminal screen clear returned a non-authoritative state cut');
+        if (screenState.runtimeEpoch !== runtimeEpoch || screenState.outputSeq !== outputSeq || screenState.stateRevision !== stateRevision) {
+          throw new Error("Terminal screen clear returned a non-authoritative state cut");
         }
-        session.renderOutput = typeof screenState.renderOutput === 'string' ? screenState.renderOutput : '';
-        session.previewText = screenState.previewText || '';
+        session.renderOutput = typeof screenState.renderOutput === "string" ? screenState.renderOutput : "";
+        session.previewText = screenState.previewText || "";
         session.previewSnapshot = screenState.previewSnapshot || null;
         session.previewCols = screenState.cols || session.previewCols;
         session.previewRows = screenState.rows || session.previewRows;
         exactState = screenState;
         if (screenState.title && screenState.title !== session.title) {
           session.title = screenState.title;
-          this.emitSessionEvent('session-title', {
+          this.emitSessionEvent("session-title", {
             sessionId,
             title: session.title,
-            runtimeEpoch: session.runtimeEpoch,
+            runtimeEpoch: session.runtimeEpoch
           });
         }
-        this.emitSessionEvent('session-transition', {
+        this.emitSessionEvent("session-transition", {
           sessionId,
-          kind: 'clear',
-          data: '\x1b[2J\x1b[3J\x1b[H',
+          kind: "clear",
+          data: "\x1B[2J\x1B[3J\x1B[H",
           runtimeEpoch: screenState.runtimeEpoch,
           outputSeq: screenState.outputSeq,
           stateRevision: screenState.stateRevision,
           cols: screenState.cols,
-          rows: screenState.rows,
+          rows: screenState.rows
         });
         return screenState;
       });
-      session.reducerCommitQueue = publishedCommit.catch(error => {
+      session.reducerCommitQueue = publishedCommit.catch((error) => {
         this.failSessionScreenState(session, error);
       });
       try {
@@ -1172,20 +1133,20 @@ class NativePtyHost {
         return { cleared: false };
       }
     }
-    if (this.sessions.get(sessionId) !== session) return { cleared: false, reason: 'session-replaced' };
-    this.emitSessionEvent('session-preview', {
+    if (this.sessions.get(sessionId) !== session) return { cleared: false, reason: "session-replaced" };
+    this.emitSessionEvent("session-preview", {
       sessionId,
       previewText: session.previewText,
       cols: session.previewCols,
       rows: session.previewRows,
       previewSnapshot: session.previewSnapshot,
       title: session.title,
-      runtimeEpoch: session.runtimeEpoch,
+      runtimeEpoch: session.runtimeEpoch
     });
-    this.emitSessionEvent('session-activity', {
+    this.emitSessionEvent("session-activity", {
       sessionId,
       lastActivityAt: session.lastActivityAt,
-      runtimeEpoch: session.runtimeEpoch,
+      runtimeEpoch: session.runtimeEpoch
     });
     return {
       cleared: true,
@@ -1193,34 +1154,29 @@ class NativePtyHost {
       outputSeq: exactState.outputSeq,
       stateRevision: exactState.stateRevision,
       cols: exactState.cols,
-      rows: exactState.rows,
+      rows: exactState.rows
     };
   }
-
   async killSession(sessionId) {
     const session = this.sessions.get(sessionId);
     if (!session || !session.process) return { killed: false };
-    if (session.status === 'exited') return { killed: false };
-    session.status = 'stopping';
+    if (session.status === "exited") return { killed: false };
+    session.status = "stopping";
     session.killRequestedAt = Date.now();
-    session.process.kill('SIGTERM');
+    session.process.kill("SIGTERM");
     const timer = setTimeout(() => {
       const latest = this.sessions.get(sessionId);
-      if (latest !== session || latest.status === 'exited' || !latest.process) return;
-      latest.process.kill('SIGKILL');
+      if (latest !== session || latest.status === "exited" || !latest.process) return;
+      latest.process.kill("SIGKILL");
     }, 1500);
-    if (typeof timer.unref === 'function') timer.unref();
+    if (typeof timer.unref === "function") timer.unref();
     return { killed: true };
   }
-
   async getSessionState(sessionId) {
     const session = this.sessions.get(sessionId);
     if (!session) return null;
-    // Cut the raw output before the async worker request. The screen worker
-    // receives every append with its output sequence and reports the exact
-    // sequence represented by its serialized terminal state.
     const snapshotOutput = session.output;
-    const fallbackPreviewText = session.previewText || snapshotOutput.slice(-2000);
+    const fallbackPreviewText = session.previewText || snapshotOutput.slice(-2e3);
     const fallbackPreviewSnapshot = session.previewSnapshot;
     const fallbackPreviewCols = session.previewCols;
     const fallbackPreviewRows = session.previewRows;
@@ -1229,8 +1185,7 @@ class NativePtyHost {
     const checkpoint = stateProofAvailable ? await captureTerminalAttachCheckpoint(session) : null;
     if (this.sessions.get(sessionId) !== session) return null;
     const title = checkpoint ? checkpoint.title : fallbackTitle;
-    const previewText = checkpoint ? checkpoint.previewText : (stateProofAvailable ? fallbackPreviewText : '');
-
+    const previewText = checkpoint ? checkpoint.previewText : stateProofAvailable ? fallbackPreviewText : "";
     return {
       sessionId: session.id,
       status: session.status,
@@ -1239,9 +1194,9 @@ class NativePtyHost {
       outputSeq: checkpoint?.outputSeq ?? null,
       stateRevision: checkpoint?.stateRevision ?? null,
       stateProofAvailable,
-      renderOutput: checkpoint ? checkpoint.renderOutput : (stateProofAvailable ? snapshotOutput : ''),
+      renderOutput: checkpoint ? checkpoint.renderOutput : stateProofAvailable ? snapshotOutput : "",
       previewText,
-      previewSnapshot: checkpoint ? checkpoint.previewSnapshot : (stateProofAvailable ? fallbackPreviewSnapshot : null),
+      previewSnapshot: checkpoint ? checkpoint.previewSnapshot : stateProofAvailable ? fallbackPreviewSnapshot : null,
       previewCols: checkpoint ? checkpoint.cols : fallbackPreviewCols,
       previewRows: checkpoint ? checkpoint.rows : fallbackPreviewRows,
       title,
@@ -1249,8 +1204,8 @@ class NativePtyHost {
       startedAt: session.startedAt,
       exitedAt: session.exitedAt || null,
       terminalBusy: session.terminalBusy,
-      shellCommand: session.shellCommand || '',
-      shellLastCommand: session.shellLastCommand || '',
+      shellCommand: session.shellCommand || "",
+      shellLastCommand: session.shellLastCommand || "",
       shellCommandStartedAt: session.shellCommandStartedAt ?? null,
       shellLastCommandStartedAt: session.shellLastCommandStartedAt ?? null,
       shellLastCommandFinishedAt: session.shellLastCommandFinishedAt ?? null,
@@ -1269,138 +1224,115 @@ class NativePtyHost {
         shellCommandStartedAt: session.shellCommandStartedAt,
         shellLastCommandStartedAt: session.shellLastCommandStartedAt,
         shellLastCommandFinishedAt: session.shellLastCommandFinishedAt,
-        shellLastCommandDurationMs: session.shellLastCommandDurationMs,
-      }),
+        shellLastCommandDurationMs: session.shellLastCommandDurationMs
+      })
     };
   }
-
   async getSessionPreview(sessionId) {
     const state = await this.getSessionState(sessionId);
-    return state ? state.previewText || '' : '';
+    return state && typeof state.previewText === "string" ? state.previewText : "";
   }
-
   async recoverSessions() {
     const recovered = [];
     for (const session of this.sessions.values()) {
-      if (session.status === 'exited') continue;
+      if (session.status === "exited") continue;
       recovered.push({
         agentId: session.id,
         metadata: session.metadata || {},
-        state: await this.getSessionState(session.id),
+        state: await this.getSessionState(session.id)
       });
     }
     return recovered;
   }
-
   serializeTerminalState(client = null) {
     if (client) this.assertActiveController(client);
     if (this.rotationPreparation) {
-      if (
-        client &&
-        this.rotationPreparation.controllerClient &&
-        this.rotationPreparation.controllerClient !== client
-      ) {
-        throw new Error('Native pty host rotation is owned by another controller');
+      if (client && this.rotationPreparation.controllerClient && this.rotationPreparation.controllerClient !== client) {
+        throw new Error("Native pty host rotation is owned by another controller");
       }
       return this.rotationPreparation.promise;
     }
-
     const preparation = {
       token: crypto.randomUUID(),
       controllerClient: client,
-      phase: 'preparing',
+      phase: "preparing",
       promise: null,
-      serializedTerminalState: '',
+      serializedTerminalState: ""
     };
     this.rotationPreparation = preparation;
     preparation.promise = this.prepareSerializedTerminalState(preparation);
     return preparation.promise;
   }
-
   async prepareSerializedTerminalState(preparation) {
     const entries = [];
     try {
       await Promise.allSettled([...this.activeControllerMutations]);
       if (this.rotationPreparation !== preparation) {
-        throw new Error('Native pty host rotation preparation was cancelled');
+        throw new Error("Native pty host rotation preparation was cancelled");
       }
-
-      const liveSessions = [...this.sessions.values()]
-        .filter(session => session.status === 'running' && session.stateProofAvailable !== false);
+      const liveSessions = [...this.sessions.values()].filter((session) => session.status === "running" && session.stateProofAvailable !== false);
       for (const session of liveSessions) {
         session.rotationFrozen = true;
         const flowError = setTerminalExternalFlowControlBlocked(
           session.reducerFlowControl,
           session.process,
-          true,
+          true
         );
         if (flowError) throw flowError;
       }
-
       for (const session of liveSessions) {
         await session.reducerCommitQueue;
         const state = await this.getSessionState(session.id);
         const current = this.sessions.get(session.id);
-        if (
-          current !== session ||
-          session.status !== 'running' ||
-          state?.status !== 'running'
-        ) {
+        if (current !== session || session.status !== "running" || state?.status !== "running") {
           continue;
         }
-        if (
-          !state ||
-          typeof state.renderOutput !== 'string' ||
-          !Number.isFinite(state.outputSeq) ||
-          !Number.isFinite(state.stateRevision)
-        ) {
+        if (!state || typeof state.renderOutput !== "string" || !Number.isFinite(state.outputSeq) || !Number.isFinite(state.stateRevision)) {
           throw new Error(`Cannot serialize terminal ${session.id} without an exact reducer checkpoint`);
         }
         entries.push({
           id: session.id,
           metadata: session.metadata || {},
           processDetails: {
-            cwd: session.shellCwd || session.cwd || '',
-            title: state.title || session.title || '',
+            cwd: session.shellCwd || session.cwd || "",
+            title: state.title || session.title || ""
           },
           processLaunchConfig: {
-            command: session.command || '',
+            command: session.command || "",
             args: session.args || [],
-            category: session.metadata?.category || '',
+            category: session.metadata?.category || ""
           },
           replayEvent: {
             events: [{
               data: state.renderOutput,
               cols: state.previewCols || session.previewCols || DEFAULT_COLS,
-              rows: state.previewRows || session.previewRows || DEFAULT_ROWS,
-            }],
+              rows: state.previewRows || session.previewRows || DEFAULT_ROWS
+            }]
           },
-          timestamp: Date.now(),
+          timestamp: Date.now()
         });
       }
       const serializedTerminalState = serializeTerminalState(entries);
-      preparation.phase = 'prepared';
+      preparation.phase = "prepared";
       preparation.serializedTerminalState = serializedTerminalState;
       return {
         preparationToken: preparation.token,
-        serializedTerminalState,
+        serializedTerminalState
       };
     } catch (error) {
       this.resumePreparedTerminalState(preparation.token);
       throw error;
     }
   }
-
-  resumeTerminalState(client = null, preparationToken = '') {
+  resumeTerminalState(client = null, preparationToken = "") {
     if (client) this.assertActiveController(client);
     return this.resumePreparedTerminalState(preparationToken);
   }
-
-  resumePreparedTerminalState(preparationToken = '') {
+  resumePreparedTerminalState(preparationToken = "") {
     const preparation = this.rotationPreparation;
     if (!preparation) return { resumed: 0 };
     if (preparationToken && preparation.token !== preparationToken) {
-      throw new Error('Native pty rotation preparation token does not match');
+      throw new Error("Native pty rotation preparation token does not match");
     }
     let resumed = 0;
     for (const session of this.sessions.values()) {
@@ -1409,7 +1341,7 @@ class NativePtyHost {
       const flowError = setTerminalExternalFlowControlBlocked(
         session.reducerFlowControl,
         session.process,
-        false,
+        false
       );
       if (flowError) {
         this.failSessionScreenState(session, flowError);
@@ -1422,47 +1354,34 @@ class NativePtyHost {
     }
     return { resumed };
   }
-
   async updateSessionMetadata(sessionId, patch) {
     const session = this.sessions.get(sessionId);
     if (!session) return null;
     session.metadata = {
-      ...(session.metadata || {}),
-      ...(patch || {}),
+      ...session.metadata || {},
+      ...patch || {},
       agentId: sessionId,
-      engineName: 'native',
+      engineName: "native"
     };
     return session.metadata;
   }
-
-  shutdownHost(client, rawIdentity = {}, preparationToken = '') {
+  shutdownHost(client, rawIdentity = {}, preparationToken = "") {
     const requestedGeneration = Math.floor(Number(rawIdentity.generation));
-    const requestedId = typeof rawIdentity.id === 'string' ? rawIdentity.id : '';
+    const requestedId = typeof rawIdentity.id === "string" ? rawIdentity.id : "";
     const active = this.activeControllerIdentity;
-    const activeClient = client
-      && client === this.activeControllerClient
-      && active
-      && client.controllerId === active.id
-      && client.controllerGeneration === active.generation;
-    const newerController = requestedId
-      && Number.isFinite(requestedGeneration)
-      && requestedGeneration > 0
-      && (!active || requestedGeneration > active.generation);
+    const activeClient = client && client === this.activeControllerClient && active && client.controllerId === active.id && client.controllerGeneration === active.generation;
+    const newerController = requestedId && Number.isFinite(requestedGeneration) && requestedGeneration > 0 && (!active || requestedGeneration > active.generation);
     if (!activeClient && !newerController) {
-      throw new Error('Native pty shutdown requires the active or a newer controller');
+      throw new Error("Native pty shutdown requires the active or a newer controller");
     }
     const preparation = this.rotationPreparation;
     if (preparation) {
-      if (
-        preparation.phase !== 'prepared' ||
-        !preparationToken ||
-        preparationToken !== preparation.token
-      ) {
-        throw new Error('Native pty shutdown requires the prepared rotation token');
+      if (preparation.phase !== "prepared" || !preparationToken || preparationToken !== preparation.token) {
+        throw new Error("Native pty shutdown requires the prepared rotation token");
       }
-      preparation.phase = 'committing';
+      preparation.phase = "committing";
     } else if (this.hasLiveSessions()) {
-      throw new Error('Native pty shutdown requires a prepared terminal checkpoint');
+      throw new Error("Native pty shutdown requires a prepared terminal checkpoint");
     }
     setImmediate(() => {
       this.dispose().finally(() => {
@@ -1471,26 +1390,21 @@ class NativePtyHost {
     });
     return { shuttingDown: true };
   }
-
   async disposeSessionProcess(session) {
-    if (!session || !session.process || session.status === 'exited') return;
-    session.status = 'stopping';
+    if (!session || !session.process || session.status === "exited") return;
+    session.status = "stopping";
     try {
-      session.process.kill('SIGTERM');
+      session.process.kill("SIGTERM");
     } catch {
       return;
     }
-
-    await new Promise(resolve => setTimeout(resolve, DISPOSE_PTY_GRACE_MS));
-    if (session.status === 'exited') return;
-
+    await new Promise((resolve) => setTimeout(resolve, DISPOSE_PTY_GRACE_MS));
+    if (session.status === "exited") return;
     try {
-      session.process.kill('SIGKILL');
+      session.process.kill("SIGKILL");
     } catch {
-      // ignore dispose races
     }
   }
-
   async dispose() {
     if (this.disposed) return;
     this.disposed = true;
@@ -1499,54 +1413,51 @@ class NativePtyHost {
       this.ownerCheckTimer = null;
     }
     this.cancelIdleExit();
-    await Promise.allSettled([...this.sessions.values()].map(session => this.disposeSessionProcess(session)));
+    await Promise.allSettled([...this.sessions.values()].map((session) => this.disposeSessionProcess(session)));
     for (const session of this.sessions.values()) {
       cleanupShellBusyIntegration(session.shellBusyIntegration);
       if (session.screenWorker) {
-        await session.screenWorker.dispose().catch(() => {});
+        await session.screenWorker.dispose().catch(() => {
+        });
       }
     }
     await this.screenWorkerPool.dispose();
-    if (this.server && process.platform !== 'win32') {
+    if (this.server && process.platform !== "win32") {
       try {
         const currentSocketIdentity = socketIdentity(this.socketPath);
         if (sameSocketIdentity(currentSocketIdentity, this.boundSocketIdentity)) {
-          // Unlink while this listener is still active. A competing host cannot
-          // replace an active socket between the ownership check and unlink.
           fs.unlinkSync(this.socketPath);
         }
       } catch (error) {
-        if (!error || error.code !== 'ENOENT') throw error;
+        if (errorCode(error) !== "ENOENT") throw error;
       }
       this.boundSocketIdentity = null;
     }
     if (this.server) {
-      await new Promise(resolve => this.server.close(() => resolve()));
+      await new Promise((resolve) => this.server?.close(() => resolve()));
       this.server = null;
     }
   }
 }
-
 function startNativePtyHostProcess() {
   const host = new NativePtyHost();
-  host.start().catch(error => {
+  host.start().catch((error) => {
     console.error(error && error.stack ? error.stack : error);
     process.exit(1);
   });
-
-  process.on('SIGTERM', () => {
+  process.on("SIGTERM", () => {
     host.dispose().finally(() => process.exit(0));
   });
-  process.on('SIGINT', () => {
+  process.on("SIGINT", () => {
     host.dispose().finally(() => process.exit(0));
   });
-
   return host;
 }
-
 if (require.main === module) {
   startNativePtyHostProcess();
 }
-
-module.exports = NativePtyHost;
-module.exports.startNativePtyHostProcess = startNativePtyHostProcess;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NativePtyHost,
+  startNativePtyHostProcess
+});