fix(windows): daemon must NEVER die from uncaught errors

Three independent bugs that combined to crash the daemon on Windows:

1. **Duplicate uncaughtException handlers** — lifecycle.ts registered a
   handler that called shutdown(1), index.ts registered a 'stays alive'
   handler. Node calls ALL listeners, so the shutdown handler always
   ran and the keep-alive log was just decoration. Daemon died on every
   uncaught exception.

   Fix: removed the lifecycle.ts handler. Single global handler in
   index.ts.

2. **Stays-alive handler registered AFTER startup()** — node-pty can
   throw synchronously from socket event callbacks during startup
   (e.g. Cannot resize a pty that has already exited). If that fires
   before line 125 of index.ts, no handler is installed yet and the
   daemon dies on Node's default uncaughtException behavior.

   Fix: moved the global handlers to the very top of index.ts (lines
   3-30), BEFORE any imports. Now the handler is in place before any
   module-load-time side effect can fire.

3. **conptyResize crashed on already-exited PTY** — node-pty's resize()
   throws synchronously if the PTY has exited but the close event
   hasn't propagated yet. This was hitting ConPTY sessions during
   normal teardown.

   Fix: skip resize when session.exited is true; wrap the call in
   try/catch and mark exited if node-pty throws anyway.

Verified end-to-end on Windows: daemon survived multiple terminal
resize events that previously killed it. PID 1404180 still running.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: imcodes-win

src/agent/conpty.ts

@@ -324,7 +324,17 @@ export function conptySubscribe(name: string, callback: (data: string) => void):
 export function conptyResize(name: string, cols: number, rows: number): void {
   const session = sessions.get(name);
   if (!session) return;
-  session.pty.resize(cols, rows);
+  if (session.exited) return;  // pty already exited — resize would throw
+  try {
+    session.pty.resize(cols, rows);
+  } catch (err) {
+    // node-pty throws "Cannot resize a pty that has already exited" if the
+    // exit event hasn't propagated yet.  Swallow it instead of letting it
+    // become an uncaught exception that takes the daemon down.
+    logger.debug({ name, err: err instanceof Error ? err.message : String(err) }, 'conptyResize: ignored error on dead pty');
+    session.exited = true;
+    return;
+  }
   session.cols = cols;
   session.rows = rows;
 }

src/daemon/lifecycle.ts

@@ -767,10 +767,10 @@ function setupSignalHandlers(): void {
   const handler = () => shutdown(0);
   process.on('SIGTERM', handler);
   process.on('SIGINT', handler);
-  process.on('uncaughtException', (err) => {
-    logger.error({ err }, 'Uncaught exception');
-    shutdown(1);
-  });
+  // NOTE: uncaughtException / unhandledRejection are handled in src/index.ts
+  // with a "daemon stays alive" policy.  We must NOT register a shutdown
+  // handler here — that would override the keep-alive behavior and let any
+  // stray error take the daemon down.
 }
 
 export function getDaemonContext(): DaemonContext {

src/index.ts

@@ -1,4 +1,31 @@
 #!/usr/bin/env node
+// ── GLOBAL ERROR HANDLERS — registered FIRST, before anything else ────────
+// The daemon must NEVER die from an unhandled error. node-pty in particular
+// throws synchronously from socket event handlers (e.g. resize on a dead pty)
+// which propagates as uncaughtException.  These handlers MUST be installed
+// before any module imports that might trigger such errors.
+process.on('uncaughtException', (err) => {
+  // Use console.error if logger isn't loaded yet, otherwise use the logger.
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const log = require('./util/logger.js').default;
+    log.error({ err }, 'Uncaught exception — daemon stays alive');
+  } catch {
+    // eslint-disable-next-line no-console
+    console.error('Uncaught exception (logger not loaded):', err);
+  }
+});
+process.on('unhandledRejection', (err) => {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const log = require('./util/logger.js').default;
+    log.error({ err }, 'Unhandled rejection — daemon stays alive');
+  } catch {
+    // eslint-disable-next-line no-console
+    console.error('Unhandled rejection (logger not loaded):', err);
+  }
+});
+
 import { Command } from 'commander';
 // These modules are imported lazily to avoid eager tmux backend detection on Windows.
 // Commands like `bind` don't need tmux/conpty and shouldn't crash when node-pty is missing.
@@ -103,13 +130,7 @@ program
         throw err; // re-throw other startup errors
       }
       // Called by launchd/systemd plist/unit — run inline.
-      // Global error handlers: daemon must NEVER crash from unhandled errors.
-      process.on('uncaughtException', (err) => {
-        logger.error({ err }, 'Uncaught exception — daemon stays alive');
-      });
-      process.on('unhandledRejection', (err) => {
-        logger.error({ err }, 'Unhandled rejection — daemon stays alive');
-      });
+      // Global error handlers are registered at the top of this file.
       logger.info('Daemon running. Press Ctrl+C to stop.');
       await new Promise(() => {});
       return;