@threadbase-sh/streamer 1.42.0 → 1.44.0

package/dist/cli.cjs

@@ -4637,11 +4637,11 @@ var require_tools = __commonJS({
         }
       }
     }
-    function buildFormatters(level, bindings, log12) {
+    function buildFormatters(level, bindings, log13) {
       return {
         level,
         bindings,
-        log: log12
+        log: log13
       };
     }
     function normalizeDestFileDescriptor(destination) {
@@ -5023,11 +5023,11 @@ var require_proto = __commonJS({
         }
       } else instance[serializersSym] = serializers;
       if (options.hasOwnProperty("formatters")) {
-        const { level, bindings: chindings, log: log12 } = options.formatters;
+        const { level, bindings: chindings, log: log13 } = options.formatters;
         instance[formattersSym] = buildFormatters(
           level || formatters.level,
           chindings || resetChildingsFormatter,
-          log12 || formatters.log
+          log13 || formatters.log
         );
       } else {
         instance[formattersSym] = buildFormatters(
@@ -6097,6 +6097,9 @@ var require_pino = __commonJS({
 });
 
 // src/logger.ts
+function defaultDest() {
+  return process.stdout.isTTY ? "console" : "pino";
+}
 function emit(pinoChild, level, msg, fields, dest) {
   if (dest === "pino" || dest === "both") {
     if (fields && Object.keys(fields).length > 0) pinoChild[level](fields, msg);
@@ -6109,11 +6112,11 @@ function emit(pinoChild, level, msg, fields, dest) {
 }
 function build(pinoChild) {
   return {
-    debug: (m2, f2, d = "both") => emit(pinoChild, "debug", m2, f2, d),
-    info: (m2, f2, d = "both") => emit(pinoChild, "info", m2, f2, d),
-    warn: (m2, f2, d = "both") => emit(pinoChild, "warn", m2, f2, d),
-    error: (m2, f2, d = "both") => emit(pinoChild, "error", m2, f2, d),
-    log: (lvl, m2, f2, d = "both") => emit(pinoChild, lvl, m2, f2, d),
+    debug: (m2, f2, d = defaultDest()) => emit(pinoChild, "debug", m2, f2, d),
+    info: (m2, f2, d = defaultDest()) => emit(pinoChild, "info", m2, f2, d),
+    warn: (m2, f2, d = defaultDest()) => emit(pinoChild, "warn", m2, f2, d),
+    error: (m2, f2, d = defaultDest()) => emit(pinoChild, "error", m2, f2, d),
+    log: (lvl, m2, f2, d = defaultDest()) => emit(pinoChild, lvl, m2, f2, d),
     pino: pinoChild
   };
 }
@@ -6219,6 +6222,12 @@ var init_feature_flags = __esm({
         description: "Seed the session list at boot with sessions a previous streamer run left behind, so a restart leaves them one tap from resuming instead of silently gone. On by default, with a kill switch: it changes what GET /api/sessions contains.",
         default: true,
         env: "THREADBASE_FEATURE_SESSION_REHYDRATION"
+      },
+      {
+        id: "ptyHost",
+        description: "Keep live PTYs in a separate host process so a streamer restart can reconnect without restarting the agents. Off by default until cross-platform behavior is qualified.",
+        default: false,
+        env: "THREADBASE_FEATURE_PTY_HOST"
       }
     ];
   }
@@ -8197,7 +8206,7 @@ var require_merge = __commonJS({
 var require_addPairToJSMap = __commonJS({
   "node_modules/yaml/dist/nodes/addPairToJSMap.js"(exports2) {
     "use strict";
-    var log12 = require_log();
+    var log13 = require_log();
     var merge2 = require_merge();
     var stringify = require_stringify();
     var identity = require_identity();
@@ -8246,7 +8255,7 @@ var require_addPairToJSMap = __commonJS({
           let jsonStr = JSON.stringify(strKey);
           if (jsonStr.length > 40)
             jsonStr = jsonStr.substring(0, 36) + '..."';
-          log12.warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`);
+          log13.warn(ctx.doc.options.logLevel, `Keys with collection values will be stringified due to JS Object restrictions: ${jsonStr}. Set mapAsMap: true to use object keys.`);
           ctx.mapKeyWarned = true;
         }
         return strKey;
@@ -13662,7 +13671,7 @@ var require_public_api = __commonJS({
     var composer = require_composer();
     var Document = require_Document();
     var errors = require_errors();
-    var log12 = require_log();
+    var log13 = require_log();
     var identity = require_identity();
     var lineCounter = require_line_counter();
     var parser = require_parser();
@@ -13714,7 +13723,7 @@ var require_public_api = __commonJS({
       const doc = parseDocument(src, options);
       if (!doc)
         return null;
-      doc.warnings.forEach((warning) => log12.warn(doc.options.logLevel, warning));
+      doc.warnings.forEach((warning) => log13.warn(doc.options.logLevel, warning));
       if (doc.errors.length > 0) {
         if (doc.options.logLevel !== "silent")
           throw doc.errors[0];
@@ -32964,11 +32973,11 @@ var require_type_helpers = __commonJS({
     function isRecord(value) {
       return typeof value === "object" && value !== null;
     }
-    function hasOwnProperty(record2, prop) {
-      return prop in record2;
+    function hasOwnProperty(record3, prop) {
+      return prop in record3;
     }
-    function hasOwnProperties(record2, props) {
-      return props.every((prop) => prop in record2);
+    function hasOwnProperties(record3, props) {
+      return props.every((prop) => prop in record3);
     }
     function isError(error51) {
       return isRecord(error51) && typeof error51.name === "string" && typeof error51.message === "string" && (error51.stack == null || typeof error51.stack === "string");
@@ -37230,7 +37239,7 @@ var require_logging = __commonJS({
       _logVerbosity = verbosity;
     };
     exports2.setLoggerVerbosity = setLoggerVerbosity;
-    var log12 = (severity, ...args) => {
+    var log13 = (severity, ...args) => {
       let logFunction;
       if (severity >= _logVerbosity) {
         switch (severity) {
@@ -37252,7 +37261,7 @@ var require_logging = __commonJS({
         }
       }
     };
-    exports2.log = log12;
+    exports2.log = log13;
     var tracersString = (_d = (_c = process.env.GRPC_NODE_TRACE) !== null && _c !== void 0 ? _c : process.env.GRPC_TRACE) !== null && _d !== void 0 ? _d : "";
     var enabledTracers = /* @__PURE__ */ new Set();
     var disabledTracers = /* @__PURE__ */ new Set();
@@ -38663,9 +38672,9 @@ var require_service_config = __commonJS({
       throw new Error("No matching service config found");
     }
     function extractAndSelectServiceConfig(txtRecord, percentage) {
-      for (const record2 of txtRecord) {
-        if (record2.length > 0 && record2[0].startsWith("grpc_config=")) {
-          const recordString = record2.join("").substring("grpc_config=".length);
+      for (const record3 of txtRecord) {
+        if (record3.length > 0 && record3[0].startsWith("grpc_config=")) {
+          const recordString = record3.join("").substring("grpc_config=".length);
           const recordJson = JSON.parse(recordString);
           return validateAndSelectCanaryConfig(recordJson, percentage);
         }
@@ -100690,11 +100699,11 @@ var require_out = __commonJS({
       async.read(path2, getSettings(optionsOrSettingsOrCallback), callback);
     }
     exports2.stat = stat7;
-    function statSync14(path2, optionsOrSettings) {
+    function statSync15(path2, optionsOrSettings) {
       const settings = getSettings(optionsOrSettings);
       return sync.read(path2, settings);
     }
-    exports2.statSync = statSync14;
+    exports2.statSync = statSync15;
     function getSettings(settingsOrOptions = {}) {
       if (settingsOrOptions instanceof settings_1.default) {
         return settingsOrOptions;
@@ -102581,6 +102590,14 @@ var require_out4 = __commonJS({
 });
 
 // src/platform.ts
+function isWindowsExecutablePath(path2) {
+  const dot = path2.lastIndexOf(".");
+  if (dot < 0) return false;
+  return WINDOWS_EXECUTABLE_EXTENSIONS.has(path2.slice(dot).toLowerCase());
+}
+function clearClaudeExeCache() {
+  _claudeExe = void 0;
+}
 function resolveClaudeExe() {
   if (_claudeExe !== void 0) return _claudeExe;
   if (isWindows2) {
@@ -102589,7 +102606,7 @@ function resolveClaudeExe() {
         encoding: "utf-8",
         windowsHide: true,
         timeout: 3e3
-      }).trim().split("\n")[0].trim();
+      }).trim().split("\n").map((line) => line.trim()).find(isWindowsExecutablePath);
       if (found) {
         _claudeExe = found;
         return _claudeExe;
@@ -102638,6 +102655,9 @@ function resolveClaudeExe() {
   _claudeExe = "claude";
   return _claudeExe;
 }
+function clearCodexExeCache() {
+  _codexExe = void 0;
+}
 function resolveCodexExe() {
   if (_codexExe !== void 0) return _codexExe;
   if (isWindows2) {
@@ -102646,7 +102666,7 @@ function resolveCodexExe() {
         encoding: "utf-8",
         windowsHide: true,
         timeout: 3e3
-      }).trim().split("\n")[0].trim();
+      }).trim().split("\n").map((line) => line.trim()).find(isWindowsExecutablePath);
       if (found) {
         _codexExe = found;
         return _codexExe;
@@ -102695,7 +102715,7 @@ function resolveCodexExe() {
   _codexExe = "codex";
   return _codexExe;
 }
-var import_child_process, import_fs13, import_os6, import_path13, isWindows2, _claudeExe, _codexExe;
+var import_child_process, import_fs13, import_os6, import_path13, isWindows2, WINDOWS_EXECUTABLE_EXTENSIONS, _claudeExe, _codexExe;
 var init_platform = __esm({
   "src/platform.ts"() {
     "use strict";
@@ -102704,6 +102724,7 @@ var init_platform = __esm({
     import_os6 = require("os");
     import_path13 = require("path");
     isWindows2 = (0, import_os6.platform)() === "win32";
+    WINDOWS_EXECUTABLE_EXTENSIONS = /* @__PURE__ */ new Set([".exe", ".cmd", ".bat"]);
   }
 });
 
@@ -113213,20 +113234,26 @@ var init_codex_pty_runner = __esm({
       async doStart(sessionId, options) {
         const nodePty = await loadPty();
         const projectName = options.projectName ?? (0, import_path21.basename)(options.projectPath);
-        const proc = nodePty.spawn(
-          resolveCodexExe(),
-          // `sessionId` stays the runner's map key — only argv carries the
-          // provider-side id, so a resumed Codex session keeps the placeholder id
-          // its client already navigated to.
-          ["resume", options.resumeId ?? sessionId, "--cd", options.projectPath, "--no-alt-screen"],
-          {
-            name: "xterm-256color",
-            cols: PTY_COLS,
-            rows: PTY_ROWS,
-            cwd: options.projectPath,
-            env: process.env
-          }
-        );
+        let proc;
+        try {
+          proc = nodePty.spawn(
+            resolveCodexExe(),
+            // `sessionId` stays the runner's map key — only argv carries the
+            // provider-side id, so a resumed Codex session keeps the placeholder id
+            // its client already navigated to.
+            ["resume", options.resumeId ?? sessionId, "--cd", options.projectPath, "--no-alt-screen"],
+            {
+              name: "xterm-256color",
+              cols: PTY_COLS,
+              rows: PTY_ROWS,
+              cwd: options.projectPath,
+              env: process.env
+            }
+          );
+        } catch (err) {
+          clearCodexExeCache();
+          throw err;
+        }
         const session = {
           id: sessionId,
           provider: CODEX_CLI_PROVIDER2,
@@ -113269,13 +113296,19 @@ var init_codex_pty_runner = __esm({
         if (options.systemPrompt) {
           args.push(options.systemPrompt);
         }
-        const proc = nodePty.spawn(resolveCodexExe(), args, {
-          name: "xterm-256color",
-          cols: PTY_COLS,
-          rows: PTY_ROWS,
-          cwd: options.projectPath,
-          env: process.env
-        });
+        let proc;
+        try {
+          proc = nodePty.spawn(resolveCodexExe(), args, {
+            name: "xterm-256color",
+            cols: PTY_COLS,
+            rows: PTY_ROWS,
+            cwd: options.projectPath,
+            env: process.env
+          });
+        } catch (err) {
+          clearCodexExeCache();
+          throw err;
+        }
         const session = {
           id: sessionId,
           provider: CODEX_CLI_PROVIDER2,
@@ -113730,6 +113763,394 @@ var init_codex_pty_runner = __esm({
   }
 });
 
+// src/pty-host/protocol.ts
+function isHostEvent(message) {
+  return "type" in message && message.type === "event";
+}
+function reviveSession(raw2) {
+  const s3 = { ...raw2 };
+  for (const field of SESSION_DATE_FIELDS) {
+    const value = s3[field];
+    if (typeof value === "string") s3[field] = new Date(value);
+  }
+  return s3;
+}
+function encodeMessage(message) {
+  return `${JSON.stringify(message)}
+`;
+}
+var PTY_HOST_PROTOCOL_VERSION, SESSION_DATE_FIELDS, LineDecoder;
+var init_protocol = __esm({
+  "src/pty-host/protocol.ts"() {
+    "use strict";
+    PTY_HOST_PROTOCOL_VERSION = 2;
+    SESSION_DATE_FIELDS = [
+      "startedAt",
+      "completedAt",
+      "statusUpdatedAt",
+      "lastActivityAt",
+      "firstMessageAt",
+      "lastMessageAt"
+    ];
+    LineDecoder = class {
+      buffer = "";
+      push(chunk) {
+        this.buffer += chunk;
+        const lines = this.buffer.split("\n");
+        this.buffer = lines.pop() ?? "";
+        return lines.filter((line) => line.length > 0);
+      }
+    };
+  }
+});
+
+// src/pty-host/remote-session-runner.ts
+var PtyHostProtocolMismatchError, HOST_HEARTBEAT_INTERVAL_MS, HOST_HEARTBEAT_REQUEST_TIMEOUT_MS, HOST_SHUTDOWN_REQUEST_TIMEOUT_MS, RemoteSessionRunner;
+var init_remote_session_runner = __esm({
+  "src/pty-host/remote-session-runner.ts"() {
+    "use strict";
+    init_protocol();
+    PtyHostProtocolMismatchError = class extends Error {
+      constructor(hostVersion, streamerVersion) {
+        super(
+          `pty-host protocol ${hostVersion} is incompatible with streamer protocol ${streamerVersion}`
+        );
+        this.hostVersion = hostVersion;
+        this.streamerVersion = streamerVersion;
+        this.name = "PtyHostProtocolMismatchError";
+      }
+      hostVersion;
+      streamerVersion;
+    };
+    HOST_HEARTBEAT_INTERVAL_MS = 1e4;
+    HOST_HEARTBEAT_REQUEST_TIMEOUT_MS = 5e3;
+    HOST_SHUTDOWN_REQUEST_TIMEOUT_MS = 1e3;
+    RemoteSessionRunner = class _RemoteSessionRunner {
+      transport;
+      options;
+      decoder = new LineDecoder();
+      nextRequestId = 1;
+      pending = /* @__PURE__ */ new Map();
+      /** The mirror. Rebuilt wholesale by `status`, patched by events. */
+      sessions = /* @__PURE__ */ new Map();
+      /** Ring buffers, fed by `output` events so `getOutput` stays synchronous. */
+      output = /* @__PURE__ */ new Map();
+      inputHistory = /* @__PURE__ */ new Map();
+      /** Fixed for a session's lifetime, so only spawn and status carry it. */
+      pids = /* @__PURE__ */ new Map();
+      closed = false;
+      heartbeatTimer = null;
+      heartbeatInFlight = false;
+      /**
+       * The only supported way to build one: a runner whose mirror has not been
+       * seeded yet would answer `hasSession` with a confident, wrong `false` for
+       * every session the host is holding — which reads as "the agent is gone" and
+       * routes the user to start a new one.
+       */
+      static async connect(transport, options = {}) {
+        const runner = new _RemoteSessionRunner(transport, options);
+        const status = await runner.readStatus();
+        if (status.protocolVersion !== PTY_HOST_PROTOCOL_VERSION) {
+          try {
+            await runner.request({ type: "shutdown-host" }, HOST_SHUTDOWN_REQUEST_TIMEOUT_MS);
+          } catch (err) {
+            options.logger?.warn("[pty-host] incompatible host did not acknowledge shutdown", {
+              event: "pty_host.shutdown_failed",
+              err
+            });
+          } finally {
+            runner.dispose();
+          }
+          throw new PtyHostProtocolMismatchError(status.protocolVersion, PTY_HOST_PROTOCOL_VERSION);
+        }
+        await runner.request({ type: "subscribe" });
+        runner.refreshMirror(status);
+        return runner;
+      }
+      constructor(transport, options) {
+        this.transport = transport;
+        this.options = options;
+        transport.onLine((line) => this.handleLine(line));
+        transport.onClose(() => this.handleClose());
+      }
+      // ─── Transport plumbing ──────────────────────────────────────────
+      handleLine(line) {
+        for (const complete of this.decoder.push(line)) {
+          let message;
+          try {
+            message = JSON.parse(complete);
+          } catch {
+            this.options.logger?.warn("[pty-host] dropped unparseable message", {
+              event: "pty_host.bad_message"
+            });
+            continue;
+          }
+          if (isHostEvent(message)) {
+            this.handleEvent(message);
+            continue;
+          }
+          const waiter = this.pending.get(message.id);
+          if (!waiter) continue;
+          this.pending.delete(message.id);
+          if (waiter.timeout) clearTimeout(waiter.timeout);
+          if (message.ok) waiter.resolve(message.result);
+          else waiter.reject(new Error(message.error));
+        }
+      }
+      /**
+       * Fail every in-flight request when the socket drops.
+       *
+       * Without this each one stays pending forever and the caller — a session
+       * start, an input write — hangs rather than erroring. PR 9 adds reconnection;
+       * until then a dropped host is a hard failure that says so.
+       */
+      handleClose() {
+        if (this.closed) return;
+        this.closed = true;
+        this.stopHeartbeat();
+        const err = new Error("pty-host connection closed");
+        for (const waiter of this.pending.values()) {
+          if (waiter.timeout) clearTimeout(waiter.timeout);
+          waiter.reject(err);
+        }
+        this.pending.clear();
+      }
+      request(body, timeoutMs) {
+        if (this.closed) return Promise.reject(new Error("pty-host connection closed"));
+        const id = this.nextRequestId++;
+        return new Promise((resolve4, reject) => {
+          const timeout = timeoutMs === void 0 ? null : setTimeout(() => {
+            if (!this.pending.delete(id)) return;
+            reject(new Error(`${body.type} timed out after ${timeoutMs}ms`));
+          }, timeoutMs);
+          timeout?.unref?.();
+          this.pending.set(id, { resolve: resolve4, reject, timeout });
+          this.transport.send(encodeMessage({ ...body, id }));
+        });
+      }
+      /**
+       * Fire-and-forget for the synchronous parts of `SessionRunner`.
+       *
+       * `sendKeys`, `cancel`, `killPid` and `putOnHold` all return void, so there is
+       * no channel to report a failure through even if we waited for one. The
+       * response is still consumed — an unhandled rejection would take the process
+       * down over a keystroke that failed to land.
+       */
+      fireAndForget(body) {
+        this.request(body).catch((err) => {
+          this.options.logger?.warn("[pty-host] request failed", {
+            event: "pty_host.request_failed",
+            type: body.type,
+            err
+          });
+        });
+      }
+      async readStatus() {
+        return await this.request({ type: "status" });
+      }
+      refreshMirror(status) {
+        this.sessions = /* @__PURE__ */ new Map();
+        this.pids = /* @__PURE__ */ new Map();
+        for (const entry of status.sessions) {
+          const session = reviveSession(entry.session);
+          this.sessions.set(session.id, session);
+          this.pids.set(session.id, entry.pid);
+        }
+      }
+      async heartbeat(state, timeoutMs = HOST_HEARTBEAT_REQUEST_TIMEOUT_MS) {
+        await this.request({ type: "heartbeat", ...state }, timeoutMs);
+      }
+      startHeartbeat(getState, intervalMs = HOST_HEARTBEAT_INTERVAL_MS) {
+        this.stopHeartbeat();
+        const send = () => {
+          if (this.closed || this.heartbeatInFlight) return;
+          this.heartbeatInFlight = true;
+          void Promise.resolve().then(() => this.heartbeat(getState())).catch((err) => {
+            if (this.closed) return;
+            this.options.logger?.warn("[pty-host] heartbeat failed", {
+              event: "pty_host.heartbeat_failed",
+              err
+            });
+          }).finally(() => {
+            this.heartbeatInFlight = false;
+          });
+        };
+        send();
+        this.heartbeatTimer = setInterval(send, intervalMs);
+        this.heartbeatTimer.unref?.();
+      }
+      stopHeartbeat() {
+        if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = null;
+      }
+      // ─── Events ──────────────────────────────────────────────────────
+      handleEvent(event) {
+        switch (event.event) {
+          case "output": {
+            this.output.set(event.sessionId, (this.output.get(event.sessionId) ?? "") + event.data);
+            this.options.onOutput?.(event.sessionId, event.data);
+            break;
+          }
+          case "status-change": {
+            const session = reviveSession(event.session);
+            if (session.status === "idle" && session.completedAt != null) {
+              this.sessions.delete(session.id);
+              this.pids.delete(session.id);
+              this.output.delete(session.id);
+              this.inputHistory.delete(session.id);
+            } else {
+              this.sessions.set(session.id, session);
+            }
+            this.options.onStatusChange?.(session);
+            break;
+          }
+          case "ready": {
+            const session = reviveSession(event.session);
+            this.sessions.set(session.id, session);
+            this.options.onReady?.(session);
+            break;
+          }
+          case "permission-change":
+            this.options.onPermissionChange?.(event.sessionId, event.gate);
+            break;
+          case "live-question":
+            this.options.onLiveQuestion?.(event.sessionId, event.questions);
+            break;
+          case "live-question-gone":
+            this.options.onLiveQuestionGone?.(event.sessionId);
+            break;
+          case "user-message": {
+            const history = this.inputHistory.get(event.sessionId) ?? [];
+            history.push({ text: event.text, ts: event.ts });
+            this.inputHistory.set(event.sessionId, history);
+            this.options.onUserMessage?.(event.sessionId, event.text, event.ts);
+            break;
+          }
+          case "exit": {
+            this.sessions.delete(event.sessionId);
+            this.pids.delete(event.sessionId);
+            this.output.delete(event.sessionId);
+            this.inputHistory.delete(event.sessionId);
+            break;
+          }
+        }
+      }
+      // ─── SessionRunner ───────────────────────────────────────────────
+      async start(sessionId, options) {
+        const provider = options.provider ?? "claude-code";
+        return this.adopt(await this.request({ type: "spawn", provider, sessionId, options }));
+      }
+      async startFresh(options) {
+        const provider = options.provider ?? "claude-code";
+        return this.adopt(await this.request({ type: "spawn", provider, sessionId: null, options }));
+      }
+      /**
+       * Take a spawn answer into the mirror.
+       *
+       * The pid lands here and nowhere else in the live path: `recordSessionSpawn`
+       * reads it immediately after start to write the durable registry row, and a
+       * null there costs the next boot its ability to probe whether the agent
+       * outlived us.
+       */
+      adopt(raw2) {
+        const entry = raw2;
+        const session = reviveSession(entry.session);
+        this.sessions.set(session.id, session);
+        this.pids.set(session.id, entry.pid);
+        return session;
+      }
+      /**
+       * Returns the mirror's promptCount, optimistically incremented.
+       *
+       * The interface is synchronous, so there is no way to return the host's
+       * authoritative count. The increment matches what an in-process runner does
+       * for the same call, and the next `status-change` event overwrites it — so a
+       * mirror that guessed wrong is corrected within one round trip rather than
+       * drifting.
+       */
+      sendInput(sessionId, input) {
+        const session = this.requireSession(sessionId);
+        this.fireAndForget({ type: "write", sessionId, input });
+        session.promptCount += 1;
+        return session.promptCount;
+      }
+      sendKeys(sessionId, keys) {
+        this.requireSession(sessionId);
+        this.fireAndForget({ type: "keys", sessionId, keys });
+      }
+      cancel(sessionId) {
+        this.fireAndForget({ type: "cancel", sessionId });
+      }
+      killPid(pid) {
+        this.fireAndForget({ type: "kill", pid });
+      }
+      putOnHold(sessionId) {
+        this.fireAndForget({ type: "kill", sessionId, hold: true });
+        this.sessions.delete(sessionId);
+        this.pids.delete(sessionId);
+      }
+      getOutput(sessionId) {
+        this.requireSession(sessionId);
+        return this.output.get(sessionId) ?? "";
+      }
+      async getOutputLines(sessionId, maxLines) {
+        const result = await this.request({ type: "replay", sessionId, maxLines });
+        if (typeof result.output === "string") this.output.set(sessionId, result.output);
+        return result.lines;
+      }
+      /**
+       * Synchronous, so it answers from the mirror rather than the host.
+       *
+       * Seeded lazily: `user-message` events append as they arrive, and a session
+       * this streamer did not start has none until `hydrateInputHistory` fetches
+       * them. Empty is the same answer an in-process runner gives for an unknown
+       * session, so a caller cannot tell "none yet" from "not fetched" — which is
+       * why the fetch is explicit rather than hidden behind this getter.
+       */
+      getInputHistory(sessionId) {
+        return this.inputHistory.get(sessionId) ?? [];
+      }
+      /** Pull a session's recorded messages from the host into the mirror. */
+      async hydrateInputHistory(sessionId) {
+        const result = await this.request({
+          type: "input-history",
+          sessionId
+        });
+        this.inputHistory.set(sessionId, result.history);
+        return result.history;
+      }
+      getPid(sessionId) {
+        return this.pids.get(sessionId) ?? null;
+      }
+      getSession(sessionId) {
+        return this.sessions.get(sessionId) ?? null;
+      }
+      hasSession(sessionId) {
+        return this.sessions.has(sessionId);
+      }
+      listSessions() {
+        return [...this.sessions.values()];
+      }
+      /**
+       * Drops this streamer's connection and nothing else.
+       *
+       * Emphatically NOT the in-process `dispose()`, which signals every child. The
+       * entire point of the host is that its PTYs outlive the streamer, so tearing
+       * them down here would spend the feature to implement a method name.
+       */
+      dispose() {
+        this.handleClose();
+        this.transport.close();
+      }
+      requireSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) throw new Error(`Session not found: ${sessionId}`);
+        return session;
+      }
+    };
+  }
+});
+
 // src/services/questions/detectPermissionGate.ts
 function permissionContentKey(gate) {
   return `${gate.prompt ?? ""}::${gate.detail ?? ""}::${gate.options.map((o) => `${o.index}.${o.label}`).join(",")}::${gate.cursor ?? ""}`;
@@ -114159,13 +114580,19 @@ var init_pty_manager = __esm({
           sessionId
         ];
         args.push(...buildFlagArgs(options.claudeFlags, options.claudeExtraArgs));
-        const proc = nodePty.spawn(resolveClaudeExe(), args, {
-          name: "xterm-256color",
-          cols: 120,
-          rows: 40,
-          cwd: options.projectPath,
-          env: buildSpawnEnv()
-        });
+        let proc;
+        try {
+          proc = nodePty.spawn(resolveClaudeExe(), args, {
+            name: "xterm-256color",
+            cols: 120,
+            rows: 40,
+            cwd: options.projectPath,
+            env: buildSpawnEnv()
+          });
+        } catch (err) {
+          clearClaudeExeCache();
+          throw err;
+        }
         const session = {
           id: sessionId,
           provider: CLAUDE_CODE_PROVIDER2,
@@ -114220,13 +114647,19 @@ var init_pty_manager = __esm({
           args.push("--system-prompt", options.systemPrompt);
         }
         args.push(...buildFlagArgs(options.claudeFlags, options.claudeExtraArgs));
-        const proc = nodePty.spawn(resolveClaudeExe(), args, {
-          name: "xterm-256color",
-          cols: 120,
-          rows: 40,
-          cwd: options.projectPath,
-          env: buildSpawnEnv()
-        });
+        let proc;
+        try {
+          proc = nodePty.spawn(resolveClaudeExe(), args, {
+            name: "xterm-256color",
+            cols: 120,
+            rows: 40,
+            cwd: options.projectPath,
+            env: buildSpawnEnv()
+          });
+        } catch (err) {
+          clearClaudeExeCache();
+          throw err;
+        }
         const session = {
           id: sessionId,
           provider: CLAUDE_CODE_PROVIDER2,
@@ -114775,15 +115208,34 @@ var init_live_session_manager = __esm({
     import_path23 = require("path");
     init_codex_pty_runner();
     init_providers();
+    init_remote_session_runner();
     init_pty_manager();
     LiveSessionManager = class {
       runners;
+      remoteRunner = null;
+      options;
       constructor(options = {}) {
+        this.options = options;
         this.runners = /* @__PURE__ */ new Map([
           [CLAUDE_CODE_PROVIDER2, new PTYManager(options)],
           [CODEX_CLI_PROVIDER2, new CodexPtyRunner(options)]
         ]);
       }
+      async useRemoteRunner(transport) {
+        const remote = await RemoteSessionRunner.connect(transport, this.options);
+        await Promise.all(
+          remote.listSessions().map((session) => remote.hydrateInputHistory(session.id))
+        );
+        for (const runner of this.runners.values()) runner.dispose();
+        this.remoteRunner = remote;
+        return remote.listSessions();
+      }
+      isRemote() {
+        return this.remoteRunner !== null;
+      }
+      startRemoteHeartbeat(getState) {
+        this.remoteRunner?.startHeartbeat(getState);
+      }
       async start(sessionId, options) {
         const provider = options.provider ?? CLAUDE_CODE_PROVIDER2;
         const runner = this.assertSupportedProvider(provider, options.projectPath);
@@ -114804,7 +115256,7 @@ var init_live_session_manager = __esm({
         this.runnerFor(sessionId).cancel(sessionId);
       }
       killPid(pid) {
-        for (const runner of this.runners.values()) {
+        for (const runner of this.activeRunners()) {
           runner.killPid(pid);
         }
       }
@@ -114814,13 +115266,13 @@ var init_live_session_manager = __esm({
       // every runner rather than throwing; this matches the pre-extraction
       // behavior of delegating straight through with no existence check.
       putOnHold(sessionId) {
-        for (const runner of this.runners.values()) {
+        for (const runner of this.activeRunners()) {
           if (runner.hasSession(sessionId) || runner.getSession(sessionId)) {
             runner.putOnHold(sessionId);
             return;
           }
         }
-        for (const runner of this.runners.values()) {
+        for (const runner of this.activeRunners()) {
           runner.putOnHold(sessionId);
         }
       }
@@ -114834,7 +115286,7 @@ var init_live_session_manager = __esm({
         return this.runnerFor(sessionId).getInputHistory(sessionId);
       }
       getSession(sessionId) {
-        for (const runner of this.runners.values()) {
+        for (const runner of this.activeRunners()) {
           const session = runner.getSession(sessionId);
           if (session) return session;
         }
@@ -114844,23 +115296,23 @@ var init_live_session_manager = __esm({
       // best-effort basis, so an unknown session must return null rather than
       // throw the way the input-routing methods do.
       getPid(sessionId) {
-        for (const runner of this.runners.values()) {
+        for (const runner of this.activeRunners()) {
           const pid = runner.getPid(sessionId);
           if (pid != null) return pid;
         }
         return null;
       }
       hasSession(sessionId) {
-        for (const runner of this.runners.values()) {
+        for (const runner of this.activeRunners()) {
           if (runner.hasSession(sessionId)) return true;
         }
         return false;
       }
       listSessions() {
-        return Array.from(this.runners.values()).flatMap((runner) => runner.listSessions());
+        return this.activeRunners().flatMap((runner) => runner.listSessions());
       }
       dispose() {
-        for (const runner of this.runners.values()) {
+        for (const runner of this.activeRunners()) {
           runner.dispose();
         }
       }
@@ -114868,12 +115320,13 @@ var init_live_session_manager = __esm({
       // this is a linear scan across hasSession()/getSession() rather than a
       // separate session→provider index — see task-1-brief.md.
       runnerFor(sessionId) {
-        for (const runner of this.runners.values()) {
+        for (const runner of this.activeRunners()) {
           if (runner.hasSession(sessionId) || runner.getSession(sessionId)) return runner;
         }
         throw new Error(`Session not found: ${sessionId}`);
       }
       assertSupportedProvider(provider, projectPath) {
+        if (this.remoteRunner) return this.remoteRunner;
         const runner = this.runners.get(provider);
         if (runner) return runner;
         const err = new Error(
@@ -114882,10 +115335,187 @@ var init_live_session_manager = __esm({
         err.statusCode = 501;
         throw err;
       }
+      activeRunners() {
+        return this.remoteRunner ? [this.remoteRunner] : [...this.runners.values()];
+      }
     };
   }
 });
 
+// src/pty-host/socket.ts
+var socket_exports = {};
+__export(socket_exports, {
+  broadcast: () => broadcast,
+  connectToHost: () => connectToHost,
+  hostSocketPath: () => hostSocketPath,
+  listenForStreamers: () => listenForStreamers,
+  probePtyHostStatus: () => probePtyHostStatus,
+  socketTransport: () => socketTransport
+});
+function hostSocketPath(instanceId) {
+  if (process.platform === "win32") {
+    return `\\\\.\\pipe\\threadbase-pty-host-${instanceId}`;
+  }
+  const dir = process.env.THREADBASE_CONFIG_DIR ?? (0, import_node_path10.join)((0, import_node_os5.homedir)(), ".threadbase");
+  return (0, import_node_path10.join)(dir, "run", `pty-host-${instanceId}.sock`);
+}
+function socketTransport(socket) {
+  socket.setEncoding("utf8");
+  return {
+    send(line) {
+      socket.write(line);
+    },
+    onLine(handler) {
+      socket.on("data", (chunk) => handler(chunk));
+    },
+    onClose(handler) {
+      let handled = false;
+      const handleClose = () => {
+        if (handled) return;
+        handled = true;
+        handler();
+      };
+      socket.once("close", handleClose);
+      socket.once("error", handleClose);
+    },
+    close() {
+      socket.destroy();
+    }
+  };
+}
+function connectToHost(socketPath) {
+  return new Promise((resolve4, reject) => {
+    const socket = (0, import_node_net.createConnection)(socketPath);
+    socket.once("error", reject);
+    socket.once("connect", () => {
+      socket.removeListener("error", reject);
+      resolve4(socketTransport(socket));
+    });
+  });
+}
+async function probePtyHostStatus(socketPath, timeoutMs = 1e3) {
+  let transport;
+  let connectTimedOut = false;
+  let connectTimer;
+  const connecting = connectToHost(socketPath);
+  try {
+    transport = await Promise.race([
+      connecting,
+      new Promise((_2, reject) => {
+        connectTimer = setTimeout(() => {
+          connectTimedOut = true;
+          reject(new Error(`status timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        connectTimer.unref?.();
+      })
+    ]);
+  } catch (err) {
+    if (connectTimer) clearTimeout(connectTimer);
+    if (connectTimedOut)
+      void connecting.then(
+        (late) => late.close(),
+        () => {
+        }
+      );
+    return { reachable: false, error: err instanceof Error ? err.message : String(err) };
+  }
+  if (connectTimer) clearTimeout(connectTimer);
+  return await new Promise((resolve4) => {
+    const decoder = new LineDecoder();
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      transport.close();
+      resolve4(result);
+    };
+    const timer = setTimeout(
+      () => finish({ reachable: false, error: `status timed out after ${timeoutMs}ms` }),
+      timeoutMs
+    );
+    timer.unref?.();
+    transport.onClose(() => finish({ reachable: false, error: "pty-host connection closed" }));
+    transport.onLine((chunk) => {
+      for (const line of decoder.push(chunk)) {
+        let message;
+        try {
+          message = JSON.parse(line);
+        } catch {
+          finish({ reachable: false, error: "pty-host returned an invalid status response" });
+          return;
+        }
+        if (isHostEvent(message) || message.id !== 1) continue;
+        if (!message.ok) {
+          finish({ reachable: false, error: message.error });
+          return;
+        }
+        const status = message.result;
+        if (typeof status?.protocolVersion !== "number" || !Array.isArray(status.sessions)) {
+          finish({ reachable: false, error: "pty-host returned an invalid status response" });
+          return;
+        }
+        finish({
+          reachable: true,
+          protocolVersion: status.protocolVersion,
+          sessionCount: status.sessions.length
+        });
+      }
+    });
+    try {
+      transport.send(encodeMessage({ id: 1, type: "status" }));
+    } catch (err) {
+      finish({ reachable: false, error: err instanceof Error ? err.message : String(err) });
+    }
+  });
+}
+async function listenForStreamers(socketPath, handlers) {
+  if (process.platform !== "win32") {
+    const { mkdirSync: mkdirSync16, rmSync: rmSync6 } = await import("fs");
+    const { dirname: dirname18 } = await import("path");
+    mkdirSync16(dirname18(socketPath), { recursive: true });
+    try {
+      const probe = await connectToHost(socketPath);
+      probe.close();
+      throw new Error(`a pty-host is already listening on ${socketPath}`);
+    } catch (err) {
+      if (err.message?.startsWith("a pty-host is already listening")) throw err;
+      rmSync6(socketPath, { force: true });
+    }
+  }
+  const server = (0, import_node_net.createServer)((socket) => {
+    const transport = socketTransport(socket);
+    const dispose = handlers.onConnection(transport);
+    transport.onClose(dispose);
+  });
+  return new Promise((resolve4, reject) => {
+    server.once("error", reject);
+    server.listen(socketPath, () => {
+      server.removeListener("error", reject);
+      resolve4(server);
+    });
+  });
+}
+function broadcast(transports, message) {
+  const line = encodeMessage(message);
+  for (const t of transports) {
+    try {
+      t.send(line);
+    } catch {
+    }
+  }
+}
+var import_node_net, import_node_os5, import_node_path10;
+var init_socket = __esm({
+  "src/pty-host/socket.ts"() {
+    "use strict";
+    import_node_net = require("net");
+    import_node_os5 = require("os");
+    import_node_path10 = require("path");
+    init_protocol();
+  }
+});
+
 // node_modules/tweetnacl/nacl-fast.js
 var require_nacl_fast = __commonJS({
   "node_modules/tweetnacl/nacl-fast.js"(exports2, module2) {
@@ -125828,7 +126458,7 @@ function uidScope() {
 function resolveOwnLabel() {
   if (process.env.LAUNCHD_LABEL) return process.env.LAUNCHD_LABEL;
   try {
-    (0, import_node_child_process4.execFileSync)("launchctl", ["print", `${uidScope()}/homebrew.mxcl.tb-streamer`], {
+    (0, import_node_child_process5.execFileSync)("launchctl", ["print", `${uidScope()}/homebrew.mxcl.tb-streamer`], {
       stdio: "ignore"
     });
     return "homebrew.mxcl.tb-streamer";
@@ -125838,7 +126468,7 @@ function resolveOwnLabel() {
 }
 function isLabelLoaded(label) {
   try {
-    (0, import_node_child_process4.execFileSync)("launchctl", ["list", label], { stdio: "ignore" });
+    (0, import_node_child_process5.execFileSync)("launchctl", ["list", label], { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -125858,7 +126488,7 @@ function detectConflictingAgents() {
     }
   }
   try {
-    const out = (0, import_node_child_process4.execFileSync)("launchctl", ["list"], {
+    const out = (0, import_node_child_process5.execFileSync)("launchctl", ["list"], {
       stdio: ["ignore", "pipe", "ignore"]
     }).toString();
     for (const line of out.split("\n")) {
@@ -125891,11 +126521,11 @@ function formatConflictMessage(conflicts) {
   );
   return lines.join("\n");
 }
-var import_node_child_process4, KNOWN_STREAMER_LABELS, LEGACY_PATTERN;
+var import_node_child_process5, KNOWN_STREAMER_LABELS, LEGACY_PATTERN;
 var init_conflict_check = __esm({
   "src/lifecycle/conflict-check.ts"() {
     "use strict";
-    import_node_child_process4 = require("child_process");
+    import_node_child_process5 = require("child_process");
     init_constants();
     KNOWN_STREAMER_LABELS = [
       "com.ronen.threadbase",
@@ -125923,7 +126553,7 @@ function uidScope2() {
 function resolveLoadedLabel() {
   if (process.env.LAUNCHD_LABEL) return process.env.LAUNCHD_LABEL;
   try {
-    (0, import_node_child_process5.execFileSync)("launchctl", ["print", `${uidScope2()}/${BREW_LAUNCHD_LABEL2}`], {
+    (0, import_node_child_process6.execFileSync)("launchctl", ["print", `${uidScope2()}/${BREW_LAUNCHD_LABEL2}`], {
       stdio: "ignore"
     });
     return BREW_LAUNCHD_LABEL2;
@@ -125936,7 +126566,7 @@ function fullTarget() {
 }
 function isAgentLoaded() {
   try {
-    (0, import_node_child_process5.execFileSync)("launchctl", ["list", resolveLoadedLabel()], { stdio: "ignore" });
+    (0, import_node_child_process6.execFileSync)("launchctl", ["list", resolveLoadedLabel()], { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -125944,7 +126574,7 @@ function isAgentLoaded() {
 }
 function bootoutAgent(timeoutMs = 2e3) {
   try {
-    (0, import_node_child_process5.execFileSync)("launchctl", ["bootout", fullTarget()], { stdio: "ignore" });
+    (0, import_node_child_process6.execFileSync)("launchctl", ["bootout", fullTarget()], { stdio: "ignore" });
   } catch {
   }
   const deadline = Date.now() + timeoutMs;
@@ -125955,7 +126585,7 @@ function bootoutAgent(timeoutMs = 2e3) {
 }
 function bootstrapAgent(plistPath, opts) {
   try {
-    (0, import_node_child_process5.execFileSync)("launchctl", ["bootstrap", uidScope2(), plistPath], {
+    (0, import_node_child_process6.execFileSync)("launchctl", ["bootstrap", uidScope2(), plistPath], {
       stdio: ["ignore", "ignore", "pipe"]
     });
   } catch (err) {
@@ -125968,18 +126598,18 @@ function bootstrapAgent(plistPath, opts) {
   }
 }
 function kickstartAgent() {
-  (0, import_node_child_process5.execFileSync)("launchctl", ["kickstart", "-k", fullTarget()], { stdio: "ignore" });
+  (0, import_node_child_process6.execFileSync)("launchctl", ["kickstart", "-k", fullTarget()], { stdio: "ignore" });
 }
 function darwinPlistPath() {
   return `${process.env.HOME}/Library/LaunchAgents/${resolveLoadedLabel()}.plist`;
 }
 function getLogPaths() {
-  const dir = (0, import_node_path24.join)(installDir(), "logs");
-  return { stdout: (0, import_node_path24.join)(dir, "stdout.log"), stderr: (0, import_node_path24.join)(dir, "stderr.log") };
+  const dir = (0, import_node_path25.join)(installDir(), "logs");
+  return { stdout: (0, import_node_path25.join)(dir, "stdout.log"), stderr: (0, import_node_path25.join)(dir, "stderr.log") };
 }
 function getAgentPid() {
   try {
-    const out = (0, import_node_child_process5.execFileSync)("launchctl", ["list"], {
+    const out = (0, import_node_child_process6.execFileSync)("launchctl", ["list"], {
       stdio: ["ignore", "pipe", "ignore"]
     }).toString();
     const label = resolveLoadedLabel();
@@ -125995,12 +126625,12 @@ function getAgentPid() {
     return null;
   }
 }
-var import_node_child_process5, import_node_path24, BREW_LAUNCHD_LABEL2;
+var import_node_child_process6, import_node_path25, BREW_LAUNCHD_LABEL2;
 var init_launchd = __esm({
   "src/lifecycle/launchd.ts"() {
     "use strict";
-    import_node_child_process5 = require("child_process");
-    import_node_path24 = require("path");
+    import_node_child_process6 = require("child_process");
+    import_node_path25 = require("path");
     init_constants();
     BREW_LAUNCHD_LABEL2 = "homebrew.mxcl.tb-streamer";
   }
@@ -126031,7 +126661,7 @@ function readMarker() {
     const parsed = JSON.parse(raw2);
     return MarkerSchema.parse(parsed);
   } catch (err) {
-    log7.warn(`marker at ${markerPath()} is malformed; treating as absent`, {
+    log8.warn(`marker at ${markerPath()} is malformed; treating as absent`, {
       error: err instanceof Error ? err.message : String(err)
     });
     return null;
@@ -126039,7 +126669,7 @@ function readMarker() {
 }
 function writeMarker(marker) {
   MarkerSchema.parse(marker);
-  (0, import_node_fs22.mkdirSync)((0, import_node_path25.dirname)(markerPath()), { recursive: true });
+  (0, import_node_fs22.mkdirSync)((0, import_node_path26.dirname)(markerPath()), { recursive: true });
   const tmp = `${markerPath()}.tmp`;
   (0, import_node_fs22.writeFileSync)(tmp, `${JSON.stringify(marker, null, 2)}
 `, { mode: 384 });
@@ -126048,16 +126678,16 @@ function writeMarker(marker) {
 function clearMarker() {
   if ((0, import_node_fs22.existsSync)(markerPath())) (0, import_node_fs22.rmSync)(markerPath());
 }
-var import_node_fs22, import_node_path25, log7;
+var import_node_fs22, import_node_path26, log8;
 var init_marker = __esm({
   "src/lifecycle/marker.ts"() {
     "use strict";
     import_node_fs22 = require("fs");
-    import_node_path25 = require("path");
+    import_node_path26 = require("path");
     init_logger();
     init_constants();
     init_marker_schema();
-    log7 = getLogger("lifecycle.marker");
+    log8 = getLogger("lifecycle.marker");
   }
 });
 
@@ -126072,7 +126702,7 @@ __export(task_scheduler_exports, {
   kickstartAgent: () => kickstartAgent2
 });
 function ps2(command) {
-  return (0, import_node_child_process6.execFileSync)("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", command], {
+  return (0, import_node_child_process7.execFileSync)("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", command], {
     stdio: ["ignore", "pipe", "ignore"]
   }).toString();
 }
@@ -126118,11 +126748,11 @@ function getAgentPid2() {
     return null;
   }
 }
-var import_node_child_process6;
+var import_node_child_process7;
 var init_task_scheduler = __esm({
   "src/lifecycle/task-scheduler.ts"() {
     "use strict";
-    import_node_child_process6 = require("child_process");
+    import_node_child_process7 = require("child_process");
     init_constants();
   }
 });
@@ -126189,6 +126819,34 @@ var init_check_sqlite_abi = __esm({
   }
 });
 
+// src/lifecycle/log-cap.ts
+var log_cap_exports = {};
+__export(log_cap_exports, {
+  LOG_CAP_BYTES: () => LOG_CAP_BYTES,
+  truncateOversizedLogs: () => truncateOversizedLogs
+});
+function truncateOversizedLogs(maxBytes = LOG_CAP_BYTES, paths = Object.values(getLogPaths())) {
+  const truncated = [];
+  for (const file2 of paths) {
+    try {
+      if ((0, import_node_fs24.statSync)(file2).size <= maxBytes) continue;
+      (0, import_node_fs24.truncateSync)(file2, 0);
+      truncated.push(file2);
+    } catch {
+    }
+  }
+  return truncated;
+}
+var import_node_fs24, LOG_CAP_BYTES;
+var init_log_cap = __esm({
+  "src/lifecycle/log-cap.ts"() {
+    "use strict";
+    import_node_fs24 = require("fs");
+    init_launchd();
+    LOG_CAP_BYTES = 32 * 1024 * 1024;
+  }
+});
+
 // src/lifecycle/prompt.ts
 var prompt_exports = {};
 __export(prompt_exports, {
@@ -126267,11 +126925,11 @@ The supervised prod streamer is already holding port ${prodPort}.
 // src/lifecycle/prefs.ts
 function readPrefs() {
   const path2 = prefsPath();
-  if (!(0, import_node_fs24.existsSync)(path2)) return { repos: {} };
+  if (!(0, import_node_fs25.existsSync)(path2)) return { repos: {} };
   try {
-    return PrefsSchema.parse(JSON.parse((0, import_node_fs24.readFileSync)(path2, "utf8")));
+    return PrefsSchema.parse(JSON.parse((0, import_node_fs25.readFileSync)(path2, "utf8")));
   } catch (err) {
-    log9.warn(`prefs at ${path2} are malformed; treating as empty`, {
+    log10.warn(`prefs at ${path2} are malformed; treating as empty`, {
       error: err instanceof Error ? err.message : String(err)
     });
     return { repos: {} };
@@ -126279,11 +126937,11 @@ function readPrefs() {
 }
 function savePrefs(p2) {
   const path2 = prefsPath();
-  (0, import_node_fs24.mkdirSync)((0, import_node_path26.dirname)(path2), { recursive: true });
+  (0, import_node_fs25.mkdirSync)((0, import_node_path27.dirname)(path2), { recursive: true });
   const tmp = `${path2}.tmp`;
-  (0, import_node_fs24.writeFileSync)(tmp, `${JSON.stringify(p2, null, 2)}
+  (0, import_node_fs25.writeFileSync)(tmp, `${JSON.stringify(p2, null, 2)}
 `, { mode: 384 });
-  (0, import_node_fs24.renameSync)(tmp, path2);
+  (0, import_node_fs25.renameSync)(tmp, path2);
 }
 function writePrefForRepo(repoToplevel, choice) {
   const p2 = readPrefs();
@@ -126304,18 +126962,18 @@ function forgetRepo(repoToplevel) {
 }
 function forgetAll() {
   const path2 = prefsPath();
-  if ((0, import_node_fs24.existsSync)(path2)) (0, import_node_fs24.rmSync)(path2);
+  if ((0, import_node_fs25.existsSync)(path2)) (0, import_node_fs25.rmSync)(path2);
 }
-var import_node_fs24, import_node_path26, log9, PrefsSchema;
+var import_node_fs25, import_node_path27, log10, PrefsSchema;
 var init_prefs = __esm({
   "src/lifecycle/prefs.ts"() {
     "use strict";
-    import_node_fs24 = require("fs");
-    import_node_path26 = require("path");
+    import_node_fs25 = require("fs");
+    import_node_path27 = require("path");
     init_zod();
     init_logger();
     init_constants();
-    log9 = getLogger("lifecycle.prefs");
+    log10 = getLogger("lifecycle.prefs");
     PrefsSchema = external_exports.object({
       repos: external_exports.record(
         external_exports.string(),
@@ -126381,7 +127039,7 @@ function detectProdActive() {
 }
 function isPortInUse(port) {
   return new Promise((resolve4) => {
-    const srv = (0, import_node_net.createServer)();
+    const srv = (0, import_node_net2.createServer)();
     srv.once("error", () => resolve4(true));
     srv.once("listening", () => srv.close(() => resolve4(false)));
     srv.listen(port, "127.0.0.1");
@@ -126394,7 +127052,7 @@ async function tryBind(start, offset) {
   if (offset >= 50) return start;
   const port = start + offset;
   const free = await new Promise((resolve4) => {
-    const srv = (0, import_node_net.createServer)();
+    const srv = (0, import_node_net2.createServer)();
     srv.once("error", () => resolve4(false));
     srv.once("listening", () => srv.close(() => resolve4(true)));
     srv.listen(port, "127.0.0.1");
@@ -126418,7 +127076,7 @@ function takeoverProd(opts) {
         `prod is already suspended by dev pid ${existing.devPid} (since ${existing.suspendedAt}). Stop that dev session first, or run 'tb-streamer prod doctor'.`
       );
     }
-    log10.info(`stale marker found (pid ${existing.devPid} is gone) \u2014 clearing and proceeding`);
+    log11.info(`stale marker found (pid ${existing.devPid} is gone) \u2014 clearing and proceeding`);
   }
   getSupervisor().bootoutAgent();
   writeMarker({
@@ -126433,7 +127091,7 @@ function takeoverProd(opts) {
     const m2 = readMarker();
     if (m2 && m2.devPid === process.pid) {
       writeMarker({ ...m2, userHeld: true });
-      log10.info(
+      log11.info(
         `prod is suspended (userHeld). Run 'tb-streamer prod start' to restore the supervised instance.`
       );
     }
@@ -126452,23 +127110,23 @@ function takeoverProd(opts) {
   });
   process.on("uncaughtException", (err) => {
     flipUserHeld();
-    log10.error(`uncaught: ${err.message}`);
+    log11.error(`uncaught: ${err.message}`);
     process.exit(1);
   });
   process.on("exit", () => {
     flipUserHeld();
   });
 }
-var import_node_net, log10;
+var import_node_net2, log11;
 var init_dev_takeover = __esm({
   "src/lifecycle/dev-takeover.ts"() {
     "use strict";
-    import_node_net = require("net");
+    import_node_net2 = require("net");
     init_logger();
     init_marker();
     init_platform2();
     init_prefs();
-    log10 = getLogger("lifecycle.dev-takeover");
+    log11 = getLogger("lifecycle.dev-takeover");
   }
 });
 
@@ -126479,7 +127137,7 @@ __export(repo_exports, {
 });
 function getGitToplevel(cwd) {
   try {
-    return (0, import_node_child_process8.execFileSync)("git", ["rev-parse", "--show-toplevel"], {
+    return (0, import_node_child_process9.execFileSync)("git", ["rev-parse", "--show-toplevel"], {
       cwd,
       stdio: ["ignore", "pipe", "ignore"]
     }).toString().trim();
@@ -126487,11 +127145,11 @@ function getGitToplevel(cwd) {
     return null;
   }
 }
-var import_node_child_process8;
+var import_node_child_process9;
 var init_repo = __esm({
   "src/lifecycle/repo.ts"() {
     "use strict";
-    import_node_child_process8 = require("child_process");
+    import_node_child_process9 = require("child_process");
   }
 });
 
@@ -126541,39 +127199,16 @@ var init_setKey = __esm({
   }
 });
 
-// src/pty-host/protocol.ts
-function isHostEvent(message) {
-  return "type" in message && message.type === "event";
-}
-function encodeMessage(message) {
-  return `${JSON.stringify(message)}
-`;
-}
-var PTY_HOST_PROTOCOL_VERSION, LineDecoder;
-var init_protocol = __esm({
-  "src/pty-host/protocol.ts"() {
-    "use strict";
-    PTY_HOST_PROTOCOL_VERSION = 1;
-    LineDecoder = class {
-      buffer = "";
-      push(chunk) {
-        this.buffer += chunk;
-        const lines = this.buffer.split("\n");
-        this.buffer = lines.pop() ?? "";
-        return lines.filter((line) => line.length > 0);
-      }
-    };
-  }
-});
-
 // src/pty-host/host.ts
 var host_exports = {};
 __export(host_exports, {
+  HOST_HEARTBEAT_TIMEOUT_MS: () => HOST_HEARTBEAT_TIMEOUT_MS,
   HOST_IDLE_AFTER_MS: () => HOST_IDLE_AFTER_MS,
   HOST_IDLE_SWEEP_MS: () => HOST_IDLE_SWEEP_MS,
+  HOST_ORPHAN_SWEEP_MS: () => HOST_ORPHAN_SWEEP_MS,
   SessionHost: () => SessionHost
 });
-var HOST_IDLE_SWEEP_MS, HOST_IDLE_AFTER_MS, SessionHost;
+var HOST_IDLE_SWEEP_MS, HOST_IDLE_AFTER_MS, HOST_HEARTBEAT_TIMEOUT_MS, HOST_ORPHAN_SWEEP_MS, SessionHost;
 var init_host = __esm({
   "src/pty-host/host.ts"() {
     "use strict";
@@ -126582,6 +127217,8 @@ var init_host = __esm({
     init_protocol();
     HOST_IDLE_SWEEP_MS = 5 * 60 * 1e3;
     HOST_IDLE_AFTER_MS = 6 * 60 * 60 * 1e3;
+    HOST_HEARTBEAT_TIMEOUT_MS = 3e4;
+    HOST_ORPHAN_SWEEP_MS = 1e4;
     SessionHost = class {
       runner;
       log;
@@ -126591,9 +127228,19 @@ var init_host = __esm({
       lastAgentChunkAt = /* @__PURE__ */ new Map();
       idleTimer = null;
       idleAfterMs;
+      onShutdown;
+      heartbeatTimeoutMs;
+      heartbeatLeases = /* @__PURE__ */ new Map();
+      lastRegistryHeartbeat = null;
+      orphanTimer = null;
+      onOrphaned;
+      orphaned = false;
       constructor(options = {}) {
         this.log = options.logger ?? getLogger("pty-host");
         this.idleAfterMs = options.idleAfterMs ?? HOST_IDLE_AFTER_MS;
+        this.onShutdown = options.onShutdown;
+        this.heartbeatTimeoutMs = options.heartbeatTimeoutMs ?? HOST_HEARTBEAT_TIMEOUT_MS;
+        this.onOrphaned = options.onOrphaned;
         this.runner = new LiveSessionManager({
           logger: this.log,
           onOutput: (sessionId, data) => {
@@ -126609,6 +127256,11 @@ var init_host = __esm({
         });
         this.idleTimer = setInterval(() => this.reapIdle(), options.idleSweepMs ?? HOST_IDLE_SWEEP_MS);
         this.idleTimer.unref?.();
+        this.orphanTimer = setInterval(
+          () => this.reapOrphan(),
+          options.orphanSweepMs ?? HOST_ORPHAN_SWEEP_MS
+        );
+        this.orphanTimer.unref?.();
       }
       /**
        * Attach a connected streamer. Returns the disposer for its disconnect.
@@ -126621,6 +127273,7 @@ var init_host = __esm({
         transport.onLine((chunk) => this.handleChunk(transport, chunk));
         return () => {
           this.subscribers.delete(transport);
+          this.heartbeatLeases.delete(transport);
           this.log.info("[pty-host] streamer disconnected; sessions kept", {
             event: "pty_host.streamer_disconnected",
             subscribers: this.subscribers.size
@@ -126648,6 +127301,7 @@ var init_host = __esm({
         try {
           const result = await this.handle(transport, request);
           transport.send(encodeMessage({ id: request.id, ok: true, result }));
+          if (request.type === "shutdown-host") this.onShutdown?.();
         } catch (err) {
           transport.send(
             encodeMessage({
@@ -126672,6 +127326,14 @@ var init_host = __esm({
               protocolVersion: PTY_HOST_PROTOCOL_VERSION,
               sessions: this.runner.listSessions().map((session) => this.toHostSession(session))
             };
+          case "heartbeat":
+            this.heartbeatLeases.set(transport, Date.now());
+            this.lastRegistryHeartbeat = {
+              registryState: request.registryState,
+              referencedSessionIds: [...request.referencedSessionIds],
+              at: Date.now()
+            };
+            return {};
           case "spawn": {
             const session = request.sessionId === null ? await this.runner.startFresh(request.options) : await this.runner.start(request.sessionId, {
               ...request.options,
@@ -126696,6 +127358,8 @@ var init_host = __esm({
             }
             return {};
           }
+          case "shutdown-host":
+            return {};
           case "replay": {
             const lines = await this.runner.getOutputLines(request.sessionId, request.maxLines);
             return { lines, output: this.runner.getOutput(request.sessionId) };
@@ -126751,6 +127415,23 @@ var init_host = __esm({
       sessionCount() {
         return this.runner.listSessions().length;
       }
+      reapOrphan(now = Date.now()) {
+        if (this.orphaned) return false;
+        for (const lastSeen of this.heartbeatLeases.values()) {
+          if (now - lastSeen <= this.heartbeatTimeoutMs) return false;
+        }
+        const registry2 = this.lastRegistryHeartbeat;
+        if (registry2?.registryState !== "known") return false;
+        if (now - registry2.at <= this.heartbeatTimeoutMs) return false;
+        if (registry2.referencedSessionIds.length > 0) return false;
+        if (this.sessionCount() > 0) return false;
+        this.orphaned = true;
+        this.log.info("[pty-host] releasing unreferenced idle host", {
+          event: "pty_host.orphan_reap"
+        });
+        this.onOrphaned?.();
+        return true;
+      }
       /**
        * Shut the host down, signalling its children.
        *
@@ -126761,104 +127442,16 @@ var init_host = __esm({
       dispose() {
         if (this.idleTimer) clearInterval(this.idleTimer);
         this.idleTimer = null;
+        if (this.orphanTimer) clearInterval(this.orphanTimer);
+        this.orphanTimer = null;
         this.subscribers.clear();
+        this.heartbeatLeases.clear();
         this.runner.dispose();
       }
     };
   }
 });
 
-// src/pty-host/socket.ts
-var socket_exports = {};
-__export(socket_exports, {
-  broadcast: () => broadcast,
-  connectToHost: () => connectToHost,
-  hostSocketPath: () => hostSocketPath,
-  listenForStreamers: () => listenForStreamers,
-  socketTransport: () => socketTransport
-});
-function hostSocketPath(instanceId) {
-  if (process.platform === "win32") {
-    return `\\\\.\\pipe\\threadbase-pty-host-${instanceId}`;
-  }
-  const dir = process.env.THREADBASE_CONFIG_DIR ?? (0, import_node_path27.join)((0, import_node_os6.homedir)(), ".threadbase");
-  return (0, import_node_path27.join)(dir, "run", `pty-host-${instanceId}.sock`);
-}
-function socketTransport(socket) {
-  socket.setEncoding("utf8");
-  return {
-    send(line) {
-      socket.write(line);
-    },
-    onLine(handler) {
-      socket.on("data", (chunk) => handler(chunk));
-    },
-    onClose(handler) {
-      socket.once("close", handler);
-      socket.once("error", handler);
-    },
-    close() {
-      socket.destroy();
-    }
-  };
-}
-function connectToHost(socketPath) {
-  return new Promise((resolve4, reject) => {
-    const socket = (0, import_node_net2.createConnection)(socketPath);
-    socket.once("error", reject);
-    socket.once("connect", () => {
-      socket.removeListener("error", reject);
-      resolve4(socketTransport(socket));
-    });
-  });
-}
-async function listenForStreamers(socketPath, handlers) {
-  if (process.platform !== "win32") {
-    const { mkdirSync: mkdirSync16, rmSync: rmSync6 } = await import("fs");
-    const { dirname: dirname18 } = await import("path");
-    mkdirSync16(dirname18(socketPath), { recursive: true });
-    try {
-      const probe = await connectToHost(socketPath);
-      probe.close();
-      throw new Error(`a pty-host is already listening on ${socketPath}`);
-    } catch (err) {
-      if (err.message?.startsWith("a pty-host is already listening")) throw err;
-      rmSync6(socketPath, { force: true });
-    }
-  }
-  const server = (0, import_node_net2.createServer)((socket) => {
-    const transport = socketTransport(socket);
-    const dispose = handlers.onConnection(transport);
-    socket.once("close", dispose);
-  });
-  return new Promise((resolve4, reject) => {
-    server.once("error", reject);
-    server.listen(socketPath, () => {
-      server.removeListener("error", reject);
-      resolve4(server);
-    });
-  });
-}
-function broadcast(transports, message) {
-  const line = encodeMessage(message);
-  for (const t of transports) {
-    try {
-      t.send(line);
-    } catch {
-    }
-  }
-}
-var import_node_net2, import_node_os6, import_node_path27;
-var init_socket = __esm({
-  "src/pty-host/socket.ts"() {
-    "use strict";
-    import_node_net2 = require("net");
-    import_node_os6 = require("os");
-    import_node_path27 = require("path");
-    init_protocol();
-  }
-});
-
 // node_modules/dotenv/config.js
 (function() {
   require_main().config(
@@ -134628,7 +135221,7 @@ var REF_PREFIX = "ref: refs/heads/";
 var MAX_DEPTH = 6;
 function readGitBranch(projectPath) {
   if (!projectPath) return null;
-  const log12 = getLogger2();
+  const log13 = getLogger2();
   let dir = projectPath;
   let depth = 0;
   while (depth < MAX_DEPTH) {
@@ -134637,11 +135230,11 @@ function readGitBranch(projectPath) {
       const content = (0, import_fs2.readFileSync)(headPath, "utf-8").trim();
       if (content.startsWith(REF_PREFIX)) {
         const branch = content.slice(REF_PREFIX.length);
-        log12.trace({ projectPath, dir, branch }, "git: branch resolved");
+        log13.trace({ projectPath, dir, branch }, "git: branch resolved");
         return branch;
       }
       if (content.length >= 7) {
-        log12.trace({ projectPath, dir }, "git: detached HEAD");
+        log13.trace({ projectPath, dir }, "git: detached HEAD");
         return "(detached)";
       }
       return null;
@@ -134652,7 +135245,7 @@ function readGitBranch(projectPath) {
     dir = parent;
     depth++;
   }
-  log12.trace({ projectPath }, "git: no .git found within depth");
+  log13.trace({ projectPath }, "git: no .git found within depth");
   return null;
 }
 function generateMatches(meta3, query) {
@@ -134945,8 +135538,8 @@ function cleanSystemTags(text) {
   return text.replace(SYSTEM_TAG_RE, "").replace(/[^\S\n]+/g, " ").replace(/\n{3,}/g, "\n\n").trim();
 }
 async function parseMeta(filePath, account, tier) {
-  const log12 = getLogger2();
-  log12.trace({ filePath, account, tier: tier.name }, "parseMeta: start");
+  const log13 = getLogger2();
+  log13.trace({ filePath, account, tier: tier.name }, "parseMeta: start");
   const state = initialReducerState();
   const fileStream = (0, import_fs3.createReadStream)(filePath);
   const rl = (0, import_readline.createInterface)({ input: fileStream, crlfDelay: Infinity });
@@ -134963,22 +135556,22 @@ async function parseMeta(filePath, account, tier) {
       reduceLine(state, entry, tier);
     }
   } catch (err) {
-    log12.warn({ filePath, err }, "parseMeta: read failed");
+    log13.warn({ filePath, err }, "parseMeta: read failed");
     return null;
   }
   if (state.badJsonLines > 0) {
-    log12.warn(
+    log13.warn(
       { filePath, badJsonLines: state.badJsonLines },
       "parseMeta: skipped malformed JSON lines"
     );
   }
   const meta3 = finalizeMeta(state, filePath, account, tier);
-  if (!meta3) log12.trace({ filePath }, "parseMeta: no messages");
+  if (!meta3) log13.trace({ filePath }, "parseMeta: no messages");
   return meta3;
 }
 async function parseConversation(filePath, account) {
-  const log12 = getLogger2();
-  log12.trace({ filePath, account }, "parseConversation: start");
+  const log13 = getLogger2();
+  log13.trace({ filePath, account }, "parseConversation: start");
   const messages = [];
   let badJsonLines = 0;
   const textParts = [];
@@ -135011,17 +135604,17 @@ async function parseConversation(filePath, account) {
       }
     }
   } catch (err) {
-    log12.warn({ filePath, err }, "parseConversation: read failed");
+    log13.warn({ filePath, err }, "parseConversation: read failed");
     return null;
   }
   if (badJsonLines > 0) {
-    log12.warn({ filePath, badJsonLines }, "parseConversation: skipped malformed JSON lines");
+    log13.warn({ filePath, badJsonLines }, "parseConversation: skipped malformed JSON lines");
   }
   if (messages.length === 0) {
-    log12.trace({ filePath }, "parseConversation: no messages");
+    log13.trace({ filePath }, "parseConversation: no messages");
     return null;
   }
-  log12.debug({ filePath, messageCount: messages.length }, "parseConversation: complete");
+  log13.debug({ filePath, messageCount: messages.length }, "parseConversation: complete");
   applyTeamInfo(messages, state);
   return {
     id: filePath,
@@ -135286,15 +135879,15 @@ async function detectDefaultProfile() {
   };
 }
 async function loadProfiles(configPath) {
-  const log12 = getLogger2();
+  const log13 = getLogger2();
   try {
     const resolved = resolveConfigDir(configPath);
     const data = await (0, import_promises4.readFile)((0, import_path5.join)(resolved, PROFILES_FILE), "utf-8");
     const profiles = JSON.parse(data);
-    log12.debug({ configPath, count: profiles.length }, "profiles: loaded");
+    log13.debug({ configPath, count: profiles.length }, "profiles: loaded");
     return profiles;
   } catch (err) {
-    log12.debug({ configPath, err }, "profiles: load failed, using default");
+    log13.debug({ configPath, err }, "profiles: load failed, using default");
     const defaultProfile = await detectDefaultProfile();
     return [defaultProfile];
   }
@@ -135305,7 +135898,7 @@ function canonicalPath(p2) {
 var CodexCliProvider = class {
   name = CODEX_CLI_PROVIDER;
   async discover(roots) {
-    const log12 = getLogger2();
+    const log13 = getLogger2();
     const results = [];
     for (const root of roots) {
       let paths;
@@ -135317,7 +135910,7 @@ var CodexCliProvider = class {
           unique: true
         });
       } catch (err) {
-        log12.warn({ root, err }, "codex discovery: glob failed");
+        log13.warn({ root, err }, "codex discovery: glob failed");
         continue;
       }
       for (const filePath of paths) {
@@ -135325,7 +135918,7 @@ var CodexCliProvider = class {
           const s3 = await (0, import_promises5.stat)(filePath);
           if (s3.size > 0) results.push({ filePath: canonicalPath(filePath), account: "codex" });
         } catch (err) {
-          log12.warn({ filePath, err }, "codex discovery: stat failed");
+          log13.warn({ filePath, err }, "codex discovery: stat failed");
         }
       }
     }
@@ -135469,7 +136062,7 @@ function getShortProjectName3(fullPath) {
   return fullPath.split("/").filter(Boolean).slice(-3).join("/");
 }
 async function parseCodexConversation(filePath, account) {
-  const log12 = getLogger2();
+  const log13 = getLogger2();
   const messages = [];
   const textParts = [];
   let sessionId = "";
@@ -135505,7 +136098,7 @@ async function parseCodexConversation(filePath, account) {
       if (role === "user") lastUserText = text;
     }
   } catch (err) {
-    log12.warn({ filePath, err }, "parseCodexConversation: read failed");
+    log13.warn({ filePath, err }, "parseCodexConversation: read failed");
     return null;
   }
   if (messages.length === 0) return null;
@@ -135527,7 +136120,7 @@ async function parseCodexConversation(filePath, account) {
 var EXCLUDED_SEGMENTS = ["/memory/", "/tool-results/"];
 var STAT_CONCURRENCY = 32;
 async function discoverJsonlFiles(dirs, onProgress) {
-  const log12 = getLogger2();
+  const log13 = getLogger2();
   const results = [];
   for (const { projectsDir, account } of dirs) {
     let filePaths;
@@ -135538,7 +136131,7 @@ async function discoverJsonlFiles(dirs, onProgress) {
         dot: false
       });
     } catch (err) {
-      log12.warn({ projectsDir, account, err }, "discovery: glob failed");
+      log13.warn({ projectsDir, account, err }, "discovery: glob failed");
       continue;
     }
     const filtered = filePaths.filter((fp) => !EXCLUDED_SEGMENTS.some((seg) => fp.includes(seg)));
@@ -135553,7 +136146,7 @@ async function discoverJsonlFiles(dirs, onProgress) {
             const s3 = await (0, import_promises6.stat)(filePath);
             return { filePath, size: s3.size };
           } catch (err) {
-            log12.warn({ filePath, err }, "discovery: stat failed");
+            log13.warn({ filePath, err }, "discovery: stat failed");
             return { filePath, size: -1 };
           }
         })
@@ -135569,7 +136162,7 @@ async function discoverJsonlFiles(dirs, onProgress) {
         }
       }
     }
-    log12.debug(
+    log13.debug(
       {
         projectsDir,
         account,
@@ -135583,7 +136176,7 @@ async function discoverJsonlFiles(dirs, onProgress) {
     );
     onProgress?.(results.length);
   }
-  log12.debug({ totalFiles: results.length, dirs: dirs.length }, "discovery: complete");
+  log13.debug({ totalFiles: results.length, dirs: dirs.length }, "discovery: complete");
   return results;
 }
 var ThreadbaseProvider = class {
@@ -135893,7 +136486,7 @@ function classify(filePath, existing) {
   return { change: "reindex", stat: stat42 };
 }
 async function parseMetaWithProvider(provider, filePath, account, tier) {
-  const log12 = getLogger2();
+  const log13 = getLogger2();
   const acc = provider.createEmptyAccumulator();
   const rl = (0, import_readline3.createInterface)({
     input: (0, import_fs11.createReadStream)(filePath),
@@ -135911,11 +136504,11 @@ async function parseMetaWithProvider(provider, filePath, account, tier) {
       try {
         provider.reduceEntry(acc, entry, tier);
       } catch (err) {
-        log12.warn({ filePath, provider: provider.name, err }, "provider reduce threw; line skipped");
+        log13.warn({ filePath, provider: provider.name, err }, "provider reduce threw; line skipped");
       }
     }
   } catch (err) {
-    log12.warn({ filePath, provider: provider.name, err }, "provider parse: read failed");
+    log13.warn({ filePath, provider: provider.name, err }, "provider parse: read failed");
     return null;
   }
   return provider.finalize(acc, filePath, account, tier);
@@ -136089,8 +136682,8 @@ CREATE INDEX IF NOT EXISTS idx_scanned_dirs_parent_root ON scanned_dirs(parent_r
 function runMigrations(db) {
   const current = db.pragma("user_version", { simple: true });
   if (current >= SCHEMA_VERSION) return;
-  const log12 = getLogger2();
-  log12.info({ from: current, to: SCHEMA_VERSION }, "migrations: applying");
+  const log13 = getLogger2();
+  log13.info({ from: current, to: SCHEMA_VERSION }, "migrations: applying");
   if (current >= 1 && current < 2 && tableExists(db, "conversations")) {
     for (const [col, ddl] of [
       [
@@ -136132,7 +136725,7 @@ function openDatabase(dbPath) {
 }
 var FULL_RECONCILE_EVERY_N_SCANS = 20;
 async function discoverJsonlFilesGated(dirs, files, scannedDirs, options = {}) {
-  const log12 = getLogger2();
+  const log13 = getLogger2();
   if (options.fullRescan) {
     return discoverJsonlFiles(dirs);
   }
@@ -136174,7 +136767,7 @@ async function discoverJsonlFilesGated(dirs, files, scannedDirs, options = {}) {
       }
     }
   }
-  log12.debug(
+  log13.debug(
     { totalFiles: results.length, dirs: dirs.length },
     "dir-watermark: gated discovery complete"
   );
@@ -136680,7 +137273,7 @@ var PersistentEngine = class {
   // changed since the last index, and upsert their metadata. Returns the number
   // of files seen on disk this pass (the scan "scanned" count).
   async indexAll(activeProfiles, options) {
-    const log12 = getLogger2();
+    const log13 = getLogger2();
     const tier = resolveTier(options.tier ?? "standard", options.tiers);
     const enabled = options.providers ?? [CLAUDE_CODE_PROVIDER];
     const discovered = [];
@@ -136744,7 +137337,7 @@ var PersistentEngine = class {
     for (const path2 of this.files.activePathsByAccounts([...coveredAccounts])) {
       if (!seen.has(path2)) this.markDeleted(path2);
     }
-    log12.info({ scanned, indexed: this.conversations.count() }, "persistent: indexAll complete");
+    log13.info({ scanned, indexed: this.conversations.count() }, "persistent: indexAll complete");
     return { scanned };
   }
   // (Re)index a single file. Classifies the change vs. the persisted cursor:
@@ -136755,7 +137348,7 @@ var PersistentEngine = class {
   // alongside the meta so callers (refreshFile) can keep, extend, or evict
   // their own per-file caches without re-stat'ing the file (racy) themselves.
   async indexFile(rawFilePath, account, tierName, customTiers, resolveGitBranch, force = false, provider) {
-    const log12 = getLogger2();
+    const log13 = getLogger2();
     const tier = resolveTier(tierName, customTiers);
     const filePath = canonicalPath(rawFilePath);
     const existing = this.files.getByPath(filePath);
@@ -136786,7 +137379,7 @@ var PersistentEngine = class {
     try {
       result = await tailReduce(filePath, startOffset, startLine, state, tier);
     } catch (err) {
-      log12.warn({ filePath, err }, "persistent: tail read failed");
+      log13.warn({ filePath, err }, "persistent: tail read failed");
       return { meta: null, change };
     }
     const meta3 = finalizeMeta(state, filePath, account, tier);
@@ -136829,7 +137422,7 @@ var PersistentEngine = class {
         )
       );
     }
-    log12.debug(
+    log13.debug(
       { filePath, change, bytesRead: result.newOffset - startOffset, msgs: meta3.messageCount },
       "persistent: indexed file"
     );
@@ -136841,7 +137434,7 @@ var PersistentEngine = class {
   // so the next pass classifies an unchanged file as "unchanged" and skips it;
   // any change reparses from 0 again. No reducer_state is persisted.
   async indexFileWithProvider(provider, filePath, account, tier, stat42, resolveGitBranch) {
-    const log12 = getLogger2();
+    const log13 = getLogger2();
     const meta3 = await parseMetaWithProvider(provider, filePath, account, tier);
     if (!meta3) {
       this.markDeleted(filePath);
@@ -136869,7 +137462,7 @@ var PersistentEngine = class {
       });
     });
     upsert();
-    log12.debug(
+    log13.debug(
       { filePath, provider: provider.name, msgs: meta3.messageCount },
       "persistent: indexed provider file"
     );
@@ -136983,7 +137576,7 @@ var FileWatcher = class {
   // Resolves once every underlying chokidar watcher has finished its initial
   // scan, so the caller knows subsequent FS changes will be observed.
   async start() {
-    const log12 = getLogger2();
+    const log13 = getLogger2();
     const ready = [];
     for (const profile of this.profiles) {
       const dir = getProjectsDir(profile);
@@ -136995,7 +137588,7 @@ var FileWatcher = class {
       watcher.on("add", (p2) => this.dispatch(p2, profile.id, "add")).on("change", (p2) => this.dispatch(p2, profile.id, "change")).on("unlink", (p2) => this.dispatch(p2, profile.id, "unlink"));
       ready.push(new Promise((resolve4) => watcher.once("ready", () => resolve4())));
       this.watchers.push(watcher);
-      log12.debug({ dir, account: profile.id }, "watcher: watching");
+      log13.debug({ dir, account: profile.id }, "watcher: watching");
     }
     await Promise.all(ready);
   }
@@ -137042,14 +137635,14 @@ var IndexQueue = class {
   async drain() {
     if (this.running) return;
     this.running = true;
-    const log12 = getLogger2();
+    const log13 = getLogger2();
     while (this.pending.size > 0) {
       const [path2, job] = this.pending.entries().next().value;
       this.pending.delete(path2);
       try {
         await this.process(job);
       } catch (err) {
-        log12.warn({ filePath: job.filePath, err }, "index-queue: job failed");
+        log13.warn({ filePath: job.filePath, err }, "index-queue: job failed");
       }
     }
     this.running = false;
@@ -137158,13 +137751,13 @@ var ConversationScanner = class {
   // active metas and run the identical filter/sort/view/paginate pipeline as
   // the in-memory path — guaranteeing an identical ScanResult shape.
   async scanPersistent(activeProfiles, options) {
-    const log12 = getLogger2();
+    const log13 = getLogger2();
     const startedAt = Date.now();
     const engine = this.engine();
     const { scanned } = await engine.indexAll(activeProfiles, options);
     const allMetas = engine.allActive();
     const { conversations, total } = this.finalize(allMetas, options);
-    log12.info(
+    log13.info(
       { scanned, kept: allMetas.length, filteredTotal: total, elapsedMs: Date.now() - startedAt },
       "scan: complete (persistent)"
     );
@@ -137191,10 +137784,10 @@ var ConversationScanner = class {
     return { conversations, total };
   }
   async scanInMemory(activeProfiles, options) {
-    const log12 = getLogger2();
+    const log13 = getLogger2();
     const startedAt = Date.now();
     const tier = this.lastTier;
-    log12.info(
+    log13.info(
       {
         activeProfiles: activeProfiles.length,
         tier: tier.name,
@@ -137248,7 +137841,7 @@ var ConversationScanner = class {
             return meta3;
           } catch (err) {
             parseFailures++;
-            log12.warn({ filePath, account, provider: provider.name, err }, "scan: parse threw");
+            log13.warn({ filePath, account, provider: provider.name, err }, "scan: parse threw");
             return null;
           }
         })
@@ -137268,12 +137861,12 @@ var ConversationScanner = class {
         options.onBatch?.(batchMetas);
       }
       scanned += batch.length;
-      log12.debug({ scanned, totalFiles, batchKept: batchMetas.length }, "scan: batch complete");
+      log13.debug({ scanned, totalFiles, batchKept: batchMetas.length }, "scan: batch complete");
       options.onProgress?.(scanned, totalFiles);
     }
     const { conversations, total } = this.finalize(allMetas, options);
     const elapsedMs = Date.now() - startedAt;
-    log12.info(
+    log13.info(
       {
         totalFiles,
         scanned,
@@ -137287,13 +137880,13 @@ var ConversationScanner = class {
     return { conversations, total, scanned };
   }
   async search(query, options = {}) {
-    const log12 = getLogger2();
-    log12.debug({ query, indexSize: this.indexer.getDocumentCount() }, "search: start");
+    const log13 = getLogger2();
+    log13.debug({ query, indexSize: this.indexer.getDocumentCount() }, "search: start");
     let results;
     if (this.persistent) {
       const engine = this.engine();
       if (engine.conversations.count() === 0) {
-        log12.debug("search: persistent index empty, triggering scan");
+        log13.debug("search: persistent index empty, triggering scan");
         const profiles = await this.resolveProfiles(options.profiles);
         const activeProfiles = profiles.filter((p2) => p2.enabled && p2.scanHistory !== false);
         await engine.indexAll(activeProfiles, { ...options, limit: void 0, offset: void 0 });
@@ -137306,7 +137899,7 @@ var ConversationScanner = class {
       }));
     } else {
       if (this.indexer.getDocumentCount() === 0) {
-        log12.debug("search: index empty, triggering scan");
+        log13.debug("search: index empty, triggering scan");
         await this.scan({ ...options, limit: void 0, offset: void 0 });
       }
       results = this.indexer.search(query, {
@@ -137349,23 +137942,23 @@ var ConversationScanner = class {
     const limit = options.limit ?? 50;
     const offset = options.offset ?? 0;
     const sliced = results.slice(offset, offset + limit);
-    log12.debug({ query, matched: results.length, returned: sliced.length }, "search: complete");
+    log13.debug({ query, matched: results.length, returned: sliced.length }, "search: complete");
     return sliced;
   }
   async getConversation(id, _options) {
-    const log12 = getLogger2();
+    const log13 = getLogger2();
     const cid = canonicalPath(id);
     const cached4 = this.conversationLRU.get(cid);
     if (cached4) {
-      log12.debug({ id }, "getConversation: cache hit");
+      log13.debug({ id }, "getConversation: cache hit");
       return cached4.conversation;
     }
     const meta3 = this.persistent ? this.engine().getByIdOrSession(cid) : this.metadataCache.get(cid) ?? this.resolveSessionId(cid);
     if (!meta3) {
-      log12.debug({ id }, "getConversation: not found in metadata");
+      log13.debug({ id }, "getConversation: not found in metadata");
       return null;
     }
-    log12.debug({ id, filePath: meta3.filePath }, "getConversation: cache miss, parsing");
+    log13.debug({ id, filePath: meta3.filePath }, "getConversation: cache miss, parsing");
     try {
       if (this.persistent && meta3.provider !== CODEX_CLI_PROVIDER) {
         const parsed = await parseConversationResumable(meta3.filePath, meta3.account);
@@ -137378,7 +137971,7 @@ var ConversationScanner = class {
       }
       return conversation;
     } catch (err) {
-      log12.warn({ id, filePath: meta3.filePath, err }, "getConversation: parse failed");
+      log13.warn({ id, filePath: meta3.filePath, err }, "getConversation: parse failed");
       return null;
     }
   }
@@ -137464,7 +138057,7 @@ var ConversationScanner = class {
     return refresh;
   }
   async doRefreshFile(filePath, account) {
-    const log12 = getLogger2();
+    const log13 = getLogger2();
     if (this.persistent) {
       const engine = this.engine();
       const previous2 = engine.getByIdOrSession(filePath);
@@ -137491,7 +138084,7 @@ var ConversationScanner = class {
       } else if (change === "appended") {
         await this.extendCachedConversations(cacheKeys, filePath, meta22.account);
       }
-      log12.debug({ filePath, change, kept: !!meta22 }, "refreshFile: updated persistent index");
+      log13.debug({ filePath, change, kept: !!meta22 }, "refreshFile: updated persistent index");
       return meta22;
     }
     const previous = this.metadataCache.get(filePath);
@@ -137500,7 +138093,7 @@ var ConversationScanner = class {
     try {
       meta3 = await parseMeta(filePath, resolvedAccount, this.lastTier);
     } catch (err) {
-      log12.warn({ filePath, err }, "refreshFile: parseMeta threw");
+      log13.warn({ filePath, err }, "refreshFile: parseMeta threw");
       meta3 = null;
     }
     const evict = (m2) => {
@@ -137516,7 +138109,7 @@ var ConversationScanner = class {
         this.removeFromSessionIndex(previous);
         this.indexer.removeDocument(previous.id);
       }
-      log12.debug({ filePath }, "refreshFile: dropped (no parseable messages)");
+      log13.debug({ filePath }, "refreshFile: dropped (no parseable messages)");
       return null;
     }
     meta3.gitBranch = readGitBranch(meta3.projectPath);
@@ -137529,7 +138122,7 @@ var ConversationScanner = class {
     } else {
       this.indexer.addDocument(meta3);
     }
-    log12.debug(
+    log13.debug(
       { filePath, messageCount: meta3.messageCount },
       "refreshFile: updated in-memory indexes"
     );
@@ -137938,14 +138531,14 @@ function createConversationWriter(opts) {
       }
       const file2 = (0, import_node_path6.join)(baseDir, `${args.sessionId}.jsonl`);
       await (0, import_promises10.mkdir)((0, import_node_path6.dirname)(file2), { recursive: true });
-      const record2 = {
+      const record3 = {
         role: "assistant",
         turnId: args.turnId,
         content: args.content,
         timestamp: Date.now(),
         ...args.reviewerOverruled ? { reviewerOverruled: true } : {}
       };
-      const line = `${JSON.stringify(record2)}
+      const line = `${JSON.stringify(record3)}
 `;
       await (0, import_promises10.appendFile)(file2, line, { encoding: "utf8" });
     }
@@ -142259,21 +142852,53 @@ var createWsRoutes = (deps, upgradeWebSocket) => {
 };
 
 // src/api/app.ts
+var ALREADY_HANDLED7 = 597;
+function summarizeQuery(query) {
+  const keys = Object.keys(query).sort();
+  if (keys.length === 0) return void 0;
+  return keys.map((k2) => `${k2}=${/^-?\d+$/.test(query[k2]) ? query[k2] : "_"}`).join("&");
+}
+function countResponseBytes(res) {
+  let bytes = 0;
+  const add = (chunk) => {
+    if (typeof chunk === "string") bytes += Buffer.byteLength(chunk);
+    else if (chunk instanceof Uint8Array) bytes += chunk.byteLength;
+  };
+  const write = res.write;
+  const end = res.end;
+  res.write = function(...args) {
+    add(args[0]);
+    return write.apply(this, args);
+  };
+  res.end = function(...args) {
+    add(args[0]);
+    return end.apply(this, args);
+  };
+  return () => bytes;
+}
 var createHonoApp = (deps, upgradeWebSocket) => {
   const app = new Hono2();
   const httpLog = getLogger("http");
   app.use("*", async (c, next) => {
     const start = Date.now();
     const ua2 = c.req.header("user-agent") ?? "";
+    const outgoing = c.env?.outgoing;
+    const bytesWritten = outgoing && countResponseBytes(outgoing);
     await next();
     if (!deps.logMenubarRequests && c.req.header("x-client") === "menubar") return;
     const ms2 = Date.now() - start;
-    httpLog.info(`[req] ${c.req.method} ${c.req.path} \u2192 ${c.res.status} ${ms2}ms`, {
+    const handled = c.res.status === ALREADY_HANDLED7 && outgoing !== void 0;
+    const status = handled ? outgoing.statusCode : c.res.status;
+    const qs2 = summarizeQuery(c.req.query());
+    const bytes = handled && bytesWritten ? bytesWritten() : void 0;
+    httpLog.info(`[req] ${c.req.method} ${c.req.path} \u2192 ${status} ${ms2}ms`, {
       method: c.req.method,
       path: c.req.path,
-      status: c.res.status,
+      status,
       ms: ms2,
       ua: ua2,
+      ...qs2 ? { qs: qs2 } : {},
+      ...bytes === void 0 ? {} : { bytes },
       event: "http.request"
     });
   });
@@ -142366,6 +142991,75 @@ var import_promises12 = require("fs/promises");
 var import_path17 = require("path");
 var import_promises13 = require("timers/promises");
 
+// src/db/query-timing.ts
+init_logger();
+var log3 = getLogger("db");
+var DEFAULT_SLOW_QUERY_MS = 35;
+var LABEL = /* @__PURE__ */ Symbol("tbQueryLabel");
+function deriveLabel(sql) {
+  const verb = /^\s*(\w+)/.exec(sql)?.[1]?.toLowerCase() ?? "sql";
+  const table = /(?:from|into|update)\s+([A-Za-z_]\w*)/i.exec(sql)?.[1] ?? "?";
+  return `${verb}:${table}`;
+}
+function resolveSlowMs() {
+  const raw2 = process.env.THREADBASE_DB_SLOW_QUERY_MS;
+  if (raw2 === void 0 || raw2 === "") return DEFAULT_SLOW_QUERY_MS;
+  const parsed = Number(raw2);
+  return Number.isFinite(parsed) ? parsed : DEFAULT_SLOW_QUERY_MS;
+}
+function record2(label, ms2, rows, slowMs) {
+  if (slowMs > 0 && ms2 >= slowMs) {
+    log3.warn(
+      `[db] slow query ${label} ${ms2.toFixed(1)}ms rows=${rows}`,
+      { event: "db.slow_query", stmt: label, ms: Math.round(ms2 * 100) / 100, rows },
+      "pino"
+    );
+    return;
+  }
+  if (log3.pino.isLevelEnabled("debug")) {
+    log3.debug(
+      `[db] ${label} ${ms2.toFixed(2)}ms rows=${rows}`,
+      { event: "db.query", stmt: label, ms: Math.round(ms2 * 100) / 100, rows },
+      "pino"
+    );
+  }
+}
+function rowsOf(method, result) {
+  if (method === "all") return Array.isArray(result) ? result.length : 0;
+  if (method === "run") return result?.changes ?? 0;
+  return result === void 0 ? 0 : 1;
+}
+function instrumentDatabase(db, options = {}) {
+  const slowMs = options.slowMs ?? resolveSlowMs();
+  const prepare = db.prepare.bind(db);
+  db.prepare = ((sql) => {
+    const stmt = prepare(sql);
+    const box = { label: deriveLabel(sql) };
+    Object.defineProperty(stmt, LABEL, { value: box, configurable: true });
+    for (const method of ["get", "all", "run"]) {
+      const original = stmt[method].bind(stmt);
+      Object.defineProperty(stmt, method, {
+        configurable: true,
+        writable: true,
+        value: (...args) => {
+          const started = performance.now();
+          const result = original(...args);
+          record2(box.label, performance.now() - started, rowsOf(method, result), slowMs);
+          return result;
+        }
+      });
+    }
+    return stmt;
+  });
+  return db;
+}
+function labelStatements(statements) {
+  for (const [name, stmt] of Object.entries(statements)) {
+    const box = stmt?.[LABEL];
+    if (box) box.label = name;
+  }
+}
+
 // src/db/sqlite-migrate.ts
 var import_fs15 = require("fs");
 var import_path15 = require("path");
@@ -142412,6 +143106,7 @@ function runSqliteMigrations(db, migrationsDir) {
 }
 
 // src/conversation-cache.ts
+init_logger();
 init_providers();
 
 // src/services/conversations/isAgentConversation.ts
@@ -142579,6 +143274,7 @@ CREATE TABLE IF NOT EXISTS session_names (
   updated_at  INTEGER NOT NULL
 );
 `;
+var cacheLog = getLogger("cache");
 var ConversationCache = class _ConversationCache {
   db;
   tailSize;
@@ -142808,6 +143504,7 @@ var ConversationCache = class _ConversationCache {
         "SELECT COUNT(*) as cnt FROM conversation_message_index WHERE conversation_id = ?"
       )
     };
+    labelStatements(this.stmts);
   }
   /**
    * Expose the underlying handle so projects/cache_metadata repositories can
@@ -142971,6 +143668,7 @@ var ConversationCache = class _ConversationCache {
     return walk;
   }
   async runBackfill(filePath) {
+    const startedAt = performance.now();
     const convId = _ConversationCache.conversationIdForFile(filePath);
     this.deleteFileIndex(filePath, convId);
     this.indexParseState.delete(filePath);
@@ -143031,6 +143729,18 @@ var ConversationCache = class _ConversationCache {
       last_message_index: nextIndex - 1
     });
     this.indexParseState.set(filePath, state);
+    const ms2 = Math.round(performance.now() - startedAt);
+    cacheLog.info(
+      `[cache] offset-index backfilled ${convId} ${ms2}ms`,
+      {
+        event: "offset_index.backfill_ok",
+        conversationId: convId,
+        ms: ms2,
+        rows: nextIndex,
+        bytes: stat7.size
+      },
+      "pino"
+    );
   }
   /**
    * Windowed detail read straight from the offset index — the hot path.
@@ -143116,7 +143826,7 @@ var ConversationCache = class _ConversationCache {
   }
   static open(dbPath, tailSize = 10, migrationsDir, options) {
     (0, import_fs17.mkdirSync)((0, import_path17.dirname)(dbPath), { recursive: true });
-    const db = new import_better_sqlite32.default(dbPath);
+    const db = instrumentDatabase(new import_better_sqlite32.default(dbPath));
     db.pragma("journal_mode = WAL");
     db.pragma("foreign_keys = ON");
     return new _ConversationCache(db, tailSize, migrationsDir, options);
@@ -144218,7 +144928,7 @@ var RuntimeStore = class _RuntimeStore {
   }
   db;
   static open(dbPath, migrationsDir) {
-    const db = new import_better_sqlite33.default(dbPath);
+    const db = instrumentDatabase(new import_better_sqlite33.default(dbPath));
     db.pragma("journal_mode = WAL");
     runSqliteMigrations(db, migrationsDir ?? resolveMigrationsDir("runtime-migrations"));
     return new _RuntimeStore(db);
@@ -144357,14 +145067,14 @@ var PairTokenStore = class {
     };
   }
   consume(token) {
-    const record2 = this.current;
-    if (!record2 || record2.token !== token) return { ok: false, reason: "unknown" };
-    if (Date.now() > record2.expiresAt) {
+    const record3 = this.current;
+    if (!record3 || record3.token !== token) return { ok: false, reason: "unknown" };
+    if (Date.now() > record3.expiresAt) {
       this.current = null;
       return { ok: false, reason: "expired" };
     }
-    if (record2.used) return { ok: false, reason: "used" };
-    record2.used = true;
+    if (record3.used) return { ok: false, reason: "used" };
+    record3.used = true;
     return { ok: true };
   }
   peek() {
@@ -144653,6 +145363,42 @@ async function readGitBranch2(dir) {
 
 // src/server.ts
 init_providers();
+init_remote_session_runner();
+
+// src/pty-host/spawn-host.ts
+var import_node_child_process3 = require("child_process");
+init_socket();
+var HOST_READY_TIMEOUT_MS = 5e3;
+var HOST_POLL_INTERVAL_MS = 50;
+async function connectOrSpawnHost(options) {
+  const socketPath = hostSocketPath(options.instanceId);
+  try {
+    return await connectToHost(socketPath);
+  } catch {
+  }
+  spawnDetachedHost(socketPath, options.entryPoint);
+  const deadline = Date.now() + (options.timeoutMs ?? HOST_READY_TIMEOUT_MS);
+  let lastError;
+  while (Date.now() < deadline) {
+    try {
+      return await connectToHost(socketPath);
+    } catch (err) {
+      lastError = err;
+      await new Promise((r) => setTimeout(r, HOST_POLL_INTERVAL_MS));
+    }
+  }
+  throw new Error(
+    `pty-host did not accept a connection on ${socketPath} within ${options.timeoutMs ?? HOST_READY_TIMEOUT_MS}ms` + (lastError instanceof Error ? `: ${lastError.message}` : "")
+  );
+}
+function spawnDetachedHost(socketPath, entryPoint) {
+  const child = (0, import_node_child_process3.spawn)(
+    process.execPath,
+    [entryPoint ?? process.argv[1], "pty-host", "--socket", socketPath],
+    { detached: true, stdio: "ignore" }
+  );
+  child.unref();
+}
 
 // src/seal.ts
 var import_tweetnacl = __toESM(require_nacl_fast(), 1);
@@ -144752,10 +145498,10 @@ function fingerprintOf(ids) {
   return `sha256:${(0, import_crypto11.createHash)("sha256").update(sorted.join("\n")).digest("hex")}`;
 }
 var CacheIntegrityMonitor = class {
-  constructor(cache, wsHub, log12, cacheDir, rescan, runDuringReset) {
+  constructor(cache, wsHub, log13, cacheDir, rescan, runDuringReset) {
     this.cache = cache;
     this.wsHub = wsHub;
-    this.log = log12;
+    this.log = log13;
     this.cacheDir = cacheDir;
     this.rescan = rescan;
     this.runDuringReset = runDuringReset;
@@ -145591,7 +146337,7 @@ function deriveProjectChatTitle(input) {
 var import_node_crypto3 = require("crypto");
 var import_node_http2 = require("http2");
 init_logger();
-var log3 = getLogger("apns");
+var log4 = getLogger("apns");
 var APNS_HOST_SANDBOX = "api.sandbox.push.apple.com";
 var APNS_MAX_PAYLOAD_BYTES = 4096;
 var JWT_TTL_SECONDS = 3e3;
@@ -145675,7 +146421,7 @@ var ApnsClient = class {
     }
     const session = (0, import_node_http2.connect)(`https://${this.creds.host}`);
     session.on("error", (err) => {
-      log3.warn("apns.session_error", { event: "apns.session_error", err: String(err) });
+      log4.warn("apns.session_error", { event: "apns.session_error", err: String(err) });
     });
     this.session = session;
     return session;
@@ -145763,7 +146509,7 @@ function truncateLastOutput(raw2) {
 }
 
 // src/services/push/liveActivityNotifier.ts
-var log4 = getLogger("live-activity");
+var log5 = getLogger("live-activity");
 function contentStateForSession(args) {
   const status = toLiveActivityStatus(args.session.status);
   if (!status) return null;
@@ -145823,7 +146569,7 @@ var LiveActivityNotifier = class {
       }
       await this.maybeSendName(session);
     } catch (err) {
-      log4.error("live_activity.notify_failed", {
+      log5.error("live_activity.notify_failed", {
         event: "live_activity.notify_failed",
         sessionId: session.id,
         status: session.status,
@@ -145845,7 +146591,7 @@ var LiveActivityNotifier = class {
     });
     this.openActivity.set(session.id, { sessionNameSent: session.sessionName != null });
     if (outcome.attempted > 0) {
-      log4.info("live_activity.updated", {
+      log5.info("live_activity.updated", {
         event: "live_activity.updated",
         sessionId: session.id,
         status: contentState.status,
@@ -145869,7 +146615,7 @@ var LiveActivityNotifier = class {
     });
     open3.sessionNameSent = true;
     if (outcome.attempted > 0) {
-      log4.info("live_activity.updated", {
+      log5.info("live_activity.updated", {
         event: "live_activity.updated",
         sessionId: session.id,
         status: contentState.status,
@@ -145888,7 +146634,7 @@ var LiveActivityNotifier = class {
     if (!contentState) return;
     const outcome = await this.sender.end({ sessionId: session.id, contentState });
     if (outcome.attempted > 0) {
-      log4.info("live_activity.ended", {
+      log5.info("live_activity.ended", {
         event: "live_activity.ended",
         sessionId: session.id,
         ...outcome
@@ -145906,7 +146652,7 @@ init_logger();
 
 // src/services/push/liveActivitySender.ts
 init_logger();
-var log5 = getLogger("live-activity");
+var log6 = getLogger("live-activity");
 var ACTIVITY_MAX_LIFETIME_MS = 8 * 60 * 60 * 1e3;
 function buildActivityKitPayload(args) {
   return {
@@ -145970,7 +146716,7 @@ var LiveActivitySender = class {
     );
     for (const { row, result, error: error51 } of results) {
       if (error51) {
-        log5.error("live_activity.send_failed", {
+        log6.error("live_activity.send_failed", {
           event: "live_activity.send_failed",
           sessionId: args.sessionId,
           activityId: row.activity_id,
@@ -145991,7 +146737,7 @@ var LiveActivitySender = class {
         this.repo.expire(row.token, now);
         outcome.retired += 1;
       }
-      log5.warn("live_activity.send_rejected", {
+      log6.warn("live_activity.send_rejected", {
         event: "live_activity.send_rejected",
         sessionId: args.sessionId,
         activityId: row.activity_id,
@@ -146036,7 +146782,7 @@ var LiveActivitySender = class {
 };
 
 // src/services/push/liveActivityRenewal.ts
-var log6 = getLogger("live-activity");
+var log7 = getLogger("live-activity");
 var RENEWAL_LEAD_MS = 30 * 60 * 1e3;
 var MAX_TIMER_MS = 60 * 60 * 1e3;
 function renewalDueAt(row) {
@@ -146084,7 +146830,7 @@ var LiveActivityRenewalScheduler = class {
         await this.renew(row, now);
       }
     } catch (err) {
-      log6.error("live_activity.renewal_sweep_failed", {
+      log7.error("live_activity.renewal_sweep_failed", {
         event: "live_activity.renewal_sweep_failed",
         err: String(err)
       });
@@ -146113,7 +146859,7 @@ var LiveActivityRenewalScheduler = class {
     if (!session || !status) {
       this.deps.repo.claimRenewal(row.token, now);
       this.deps.repo.expire(row.token, now);
-      log6.info("live_activity.renewal_skipped", {
+      log7.info("live_activity.renewal_skipped", {
         event: "live_activity.renewal_skipped",
         sessionId: row.session_id,
         activityId: row.activity_id,
@@ -146148,7 +146894,7 @@ var LiveActivityRenewalScheduler = class {
         startedAt,
         now
       });
-      log6.info("live_activity.renewed", {
+      log7.info("live_activity.renewed", {
         event: "live_activity.renewed",
         sessionId: session.id,
         activityId: row.activity_id,
@@ -146158,7 +146904,7 @@ var LiveActivityRenewalScheduler = class {
         replacementRequested: started
       });
     } catch (err) {
-      log6.error("live_activity.renewal_failed", {
+      log7.error("live_activity.renewal_failed", {
         event: "live_activity.renewal_failed",
         sessionId: session.id,
         activityId: row.activity_id,
@@ -146439,6 +147185,34 @@ function paginate(results, offset, limit) {
   };
 }
 
+// src/services/sessions/autoResumeOnBoot.ts
+var AUTO_RESUME_WINDOW_MS = 15 * 60 * 1e3;
+var AUTO_RESUME_MAX = 5;
+var AUTO_RESUME_CONCURRENCY = 2;
+var AUTO_RESUME_STAGGER_MS = 500;
+function autoResumeSkipReason(row, opts) {
+  if (row.status_source !== "shutdown") return "not_shutdown";
+  if (row.status !== "running" && row.status !== "waiting_input") return "not_interrupted";
+  if (opts.now - row.status_updated_at > AUTO_RESUME_WINDOW_MS) return "too_old";
+  if (!opts.projectExists(row.project_path)) return "project_missing";
+  if (resumeIdForRow(row) == null) return "resume_identity_missing";
+  return null;
+}
+function planAutoResume(rows, opts) {
+  const eligible = [];
+  const skipped = [];
+  for (const row of rows) {
+    const reason = autoResumeSkipReason(row, opts);
+    if (reason) skipped.push({ row, reason });
+    else eligible.push(row);
+  }
+  return {
+    attempts: eligible.slice(0, AUTO_RESUME_MAX),
+    skipped,
+    overflow: eligible.slice(AUTO_RESUME_MAX)
+  };
+}
+
 // src/services/sessions/conversationBusy.ts
 var import_fs29 = require("fs");
 var RESUME_BUSY_WINDOW_MS = 12e4;
@@ -146655,6 +147429,12 @@ var SessionStore = class {
   removeManaged(sessionId) {
     return this.managed.delete(sessionId);
   }
+  /**
+   * The **live** stored record — mutating it mutates the store. Paired with
+   * `get()`, which hands back a throwaway response copy. Prefer
+   * `updateManaged()` for writes; this is for readers that need the internal
+   * shape (Date fields, `rehydrated`, …) rather than the wire shape.
+   */
   getManaged(sessionId) {
     return this.managed.get(sessionId) ?? null;
   }
@@ -146664,12 +147444,21 @@ var SessionStore = class {
       this.discovered.set(proc.pid, proc);
     }
   }
+  /**
+   * The **live** stored records — mutating an element mutates the store. Paired
+   * with `list()`, which hands back throwaway response copies.
+   */
   listManaged() {
     return Array.from(this.managed.values());
   }
   // Build the session list: live PTY sessions (managed) merged with externally
   // discovered Claude processes. Managed sessions keyed by JSONL UUID take
   // priority — discovered processes with the same UUID are skipped.
+  //
+  // Returns freshly constructed response objects, NOT references into the
+  // store — hence `Readonly`: writing to one changes nothing, so the compiler
+  // refuses it. Persist state with `updateManaged()`; to decorate a response,
+  // build a new object (`{ ...s, … }`) as `withReconciledLifecycle` does.
   list(ptyAttachedIds) {
     const results = [];
     const seenIds = /* @__PURE__ */ new Set();
@@ -146685,6 +147474,9 @@ var SessionStore = class {
     }
     return results;
   }
+  // A freshly constructed response object, NOT a reference into the store —
+  // hence `Readonly`, for the same reason as `list()` above. Use `getManaged()`
+  // when you want the live record.
   get(sessionId, ptyAttachedIds) {
     const managed = this.managed.get(sessionId);
     if (managed) return managedToResponse(managed, ptyAttachedIds.has(sessionId));
@@ -146776,8 +147568,8 @@ function managedToResponse(s3, ptyAttached) {
     // behind it — `resumable`, and `historical` rather than `managed`
     // (docs/plans/live-sessions-persistence-plan.md §4, Phase 1).
     lifecycle: ptyAttached ? "attached" : s3.rehydrated ? "resumable" : s3.failureReason != null ? "failed" : "completed",
-    lifecycleSource: ptyAttached ? "spawn" : s3.rehydrated ? "reconcile" : "exit",
-    // We spawned it, so `status` is the authoritative signal — no inferred
+    lifecycleSource: ptyAttached ? s3.reconciled ? "reconcile" : "spawn" : s3.rehydrated ? "reconcile" : "exit",
+    // We own its PTY, so `status` is the authoritative signal — no inferred
     // `activity` is attached for managed sessions.
     ownership: s3.rehydrated ? "historical" : "managed",
     projectPath: s3.projectPath,
@@ -147312,6 +148104,7 @@ var StreamerServer = class {
   disableDb = false;
   // Skip the startup warm-up scan (test hook; see ServerConfig.skipStartupWarmup).
   skipStartupWarmup;
+  autoResumeOnBoot;
   browseRoot = null;
   publicUrl = null;
   browserCors;
@@ -147428,6 +148221,7 @@ var StreamerServer = class {
     this.verbose = config2.verbose ?? false;
     this.disableDb = config2.disableDb ?? false;
     this.skipStartupWarmup = config2.skipStartupWarmup ?? false;
+    this.autoResumeOnBoot = config2.autoResumeOnBoot ?? false;
     this.scannerPersistenceDisabled = config2.scannerPersistent === false;
     this.scanProfiles = config2.scanProfiles;
     this.codexRoots = config2.codexRoots ?? [(0, import_path29.join)((0, import_os13.homedir)(), ".codex", "sessions")];
@@ -147908,16 +148702,19 @@ var StreamerServer = class {
   broadcastOrUnicastSessionList(req) {
     const clientId = req.headers["x-client-id"];
     const ws2 = typeof clientId === "string" ? this.clientIdToWs.get(clientId) : void 0;
-    const payload = {
-      type: "session_list",
-      sessions: this.withReconciledLifecycle(this.sessionStore.list(this.ptyAttachedIds()))
-    };
+    const payload = this.sessionListPayload();
     if (ws2) {
       this.wsHub.unicast(ws2, payload);
     } else {
       this.wsHub.broadcast(payload);
     }
   }
+  sessionListPayload() {
+    return {
+      type: "session_list",
+      sessions: this.withReconciledLifecycle(this.sessionStore.list(this.ptyAttachedIds()))
+    };
+  }
   /**
    * Overlay boot-reconciliation verdicts onto session responses.
    *
@@ -148005,7 +148802,7 @@ var StreamerServer = class {
     if (!this.managedSessionsRepo) return [];
     let verdicts = [];
     try {
-      const rows = this.managedSessionsRepo.listNonTerminal();
+      const rows = this.managedSessionsRepo.listNonTerminal().filter((row) => !this.ptyManager.hasSession(row.session_id));
       if (rows.length === PROBE_SET_MAX) {
         this.log.warn(
           `[reconcile] probe set hit its cap of ${PROBE_SET_MAX} \u2014 older rows skipped`,
@@ -148091,7 +148888,7 @@ var StreamerServer = class {
    * by id rather than duplicating it.
    */
   rehydratePreviousSessions(verdicts) {
-    if (!this.featureFlags.sessionRehydration || !this.managedSessionsRepo) return;
+    if (!this.managedSessionsRepo) return [];
     try {
       const now = Date.now();
       const rows = this.managedSessionsRepo.listRecoverable({
@@ -148100,7 +148897,7 @@ var StreamerServer = class {
       });
       const truncated = rows.length > REHYDRATE_MAX;
       const candidates = truncated ? rows.slice(0, REHYDRATE_MAX) : rows;
-      if (candidates.length === 0) return;
+      if (!this.featureFlags.sessionRehydration || candidates.length === 0) return candidates;
       const verdictById = new Map(verdicts.map((v2) => [v2.sessionId, v2]));
       let rehydrated = 0;
       const skippedBy = {};
@@ -148135,12 +148932,107 @@ var StreamerServer = class {
         skippedBy,
         truncated
       });
+      return candidates;
     } catch (err) {
       this.log.warn("[rehydrate] failed to rehydrate previous sessions", {
         event: "sessions.rehydrate_failed",
         err
       });
+      return [];
+    }
+  }
+  /** Resume only the recent sessions the user explicitly allowed us to start at boot. */
+  async autoResumePreviousSessions(rows) {
+    if (!this.autoResumeOnBoot) return;
+    const plan = planAutoResume(rows, { now: Date.now(), projectExists: import_fs30.existsSync });
+    const skippedBy = {};
+    for (const { row, reason } of plan.skipped) {
+      skippedBy[reason] = (skippedBy[reason] ?? 0) + 1;
+      this.log.debug(`[auto-resume] skipped ${row.session_id}: ${reason}`, {
+        event: "sessions.auto_resume_skipped",
+        sessionId: row.session_id,
+        reason
+      });
     }
+    if (plan.skipped.length > 0) {
+      this.log.info(
+        `[auto-resume] left ${plan.skipped.length} ineligible session(s) for manual resume`,
+        {
+          event: "sessions.auto_resume_skipped",
+          skipped: plan.skipped.length,
+          skippedBy
+        }
+      );
+    }
+    for (const row of plan.overflow) {
+      this.log.info(`[auto-resume] left ${row.session_id} for manual resume: ceiling reached`, {
+        event: "sessions.auto_resume_skipped",
+        sessionId: row.session_id,
+        reason: "ceiling_reached"
+      });
+    }
+    let resumed = 0;
+    let failed = 0;
+    const inFlight = /* @__PURE__ */ new Set();
+    let started = 0;
+    const resume = async (row) => {
+      try {
+        const outcome = await this.resumeSession({
+          sessionId: row.session_id,
+          projectName: row.project_name,
+          branch: row.branch
+        });
+        if (!outcome.ok) {
+          failed++;
+          this.log.info(`[auto-resume] skipped ${row.session_id}: ${outcome.reason}`, {
+            event: "sessions.auto_resume_skipped",
+            sessionId: row.session_id,
+            reason: outcome.reason,
+            ...outcome.reason === "conversation_busy" && {
+              detectedBy: outcome.detectedBy,
+              lastActivityMs: outcome.lastActivityMs,
+              likelyOwner: outcome.likelyOwner
+            }
+          });
+          return;
+        }
+        resumed++;
+        this.log.info(`[auto-resume] resumed ${row.session_id}`, {
+          event: "sessions.auto_resume_succeeded",
+          sessionId: row.session_id,
+          alreadyRunning: outcome.alreadyRunning
+        });
+      } catch (err) {
+        failed++;
+        this.log.warn(`[auto-resume] failed to resume ${row.session_id}`, {
+          event: "sessions.auto_resume_failed",
+          sessionId: row.session_id,
+          err
+        });
+      }
+    };
+    for (const row of plan.attempts) {
+      while (inFlight.size >= AUTO_RESUME_CONCURRENCY) {
+        await Promise.race(inFlight);
+      }
+      if (started > 0) {
+        await new Promise((resolve4) => setTimeout(resolve4, AUTO_RESUME_STAGGER_MS));
+      }
+      const task = resume(row);
+      inFlight.add(task);
+      void task.then(() => inFlight.delete(task));
+      started++;
+    }
+    await Promise.all(inFlight);
+    if (resumed > 0) this.wsHub.broadcast(this.sessionListPayload());
+    this.log.info(`[auto-resume] completed boot recovery: ${resumed} resumed`, {
+      event: "sessions.auto_resume_completed",
+      attempted: plan.attempts.length,
+      resumed,
+      failed,
+      ineligible: plan.skipped.length,
+      overflow: plan.overflow.length
+    });
   }
   /**
    * Pick a token guaranteed to appear in the spawned process's argv, for the
@@ -148157,6 +149049,26 @@ var StreamerServer = class {
     if (session.provider !== CODEX_CLI_PROVIDER2) return session.id;
     return session.boundConversationId ?? session.projectPath;
   }
+  /** Restore registry-only metadata after the host mirror has been adopted. */
+  refreshHostedSessionsFromRegistry() {
+    for (const session of this.ptyManager.listSessions()) {
+      const row = this.managedSessionsRepo?.get(session.id);
+      const merged = {
+        ...session,
+        reconciled: true,
+        ...row?.project_id != null && { projectId: row.project_id },
+        ...row?.session_name != null && { sessionName: row.session_name },
+        ...row?.bound_conversation_id != null && {
+          boundConversationId: row.bound_conversation_id
+        },
+        ...row?.resumed_from_conversation_id != null && {
+          resumedFromConversationId: row.resumed_from_conversation_id
+        }
+      };
+      this.sessionStore.addManaged(merged);
+      void this.watchConversationFile(session.id, merged.boundConversationId ?? session.id);
+    }
+  }
   /**
    * Mirror a freshly-spawned session into the durable registry (C1 Phase 2).
    *
@@ -148252,6 +149164,7 @@ var StreamerServer = class {
    * of waiting on the interval.
    */
   reapIdleSessions(now = Date.now()) {
+    if (this.ptyManager.isRemote()) return [];
     const reaped = [];
     for (const session of this.ptyManager.listSessions()) {
       if (session.status === "running") continue;
@@ -148353,6 +149266,40 @@ var StreamerServer = class {
     return true;
   }
   async listen(port, opts) {
+    if (this.featureFlags.ptyHost) {
+      try {
+        let sessions = null;
+        for (let attempt = 0; attempt < 2; attempt += 1) {
+          const transport = await connectOrSpawnHost({
+            instanceId: process.env.THREADBASE_INSTANCE_ID ?? (0, import_os13.hostname)()
+          });
+          try {
+            sessions = await this.ptyManager.useRemoteRunner(transport);
+            break;
+          } catch (err) {
+            if (!(err instanceof PtyHostProtocolMismatchError) || attempt > 0) throw err;
+            this.log.info(`[pty-host] replaced incompatible protocol ${err.hostVersion}`, {
+              event: "pty_host.protocol_replaced",
+              hostVersion: err.hostVersion,
+              streamerVersion: err.streamerVersion
+            });
+          }
+        }
+        if (!sessions) throw new Error("pty-host replacement did not produce a compatible host");
+        for (const session of sessions) {
+          this.sessionStore.addManaged({ ...session, reconciled: true });
+        }
+        this.log.info(`[pty-host] re-adopted ${sessions.length} live session(s)`, {
+          event: "pty_host.sessions_adopted",
+          sessions: sessions.length
+        });
+      } catch (err) {
+        this.log.error(
+          "[pty-host] could not attach; falling back to in-process PTYs for this run",
+          { event: "pty_host.attach_failed", err }
+        );
+      }
+    }
     const dbConfig = this.disableDb ? null : getDbConfig();
     if (dbConfig) {
       this.dbPool = await createPool(dbConfig);
@@ -148367,8 +149314,10 @@ var StreamerServer = class {
       this.log.info("Database migrations applied", { event: "db.migrations_applied" });
     }
     await this.bindWithRetry(port);
-    this.idleReaperTimer = setInterval(() => this.reapIdleSessions(), IDLE_REAP_SWEEP_MS);
-    this.idleReaperTimer.unref?.();
+    if (!this.ptyManager.isRemote()) {
+      this.idleReaperTimer = setInterval(() => this.reapIdleSessions(), IDLE_REAP_SWEEP_MS);
+      this.idleReaperTimer.unref?.();
+    }
     const warmUp = new Promise((resolveWarm) => {
       {
         this.log.info(`Streamer server listening on port ${port}`, {
@@ -148386,6 +149335,15 @@ var StreamerServer = class {
             { error: message, abiMismatch, path: this.runtimeDbPath, event: "runtime.open_failed" }
           );
         }
+        if (this.ptyManager.isRemote()) {
+          this.ptyManager.startRemoteHeartbeat(() => {
+            if (!this.managedSessionsRepo) {
+              return { registryState: "unknown", referencedSessionIds: [] };
+            }
+            const referencedSessionIds = this.ptyManager.listSessions().filter((session) => this.managedSessionsRepo?.get(session.id)?.completed_at == null).map((session) => session.id);
+            return { registryState: "known", referencedSessionIds };
+          });
+        }
         try {
           this.cache = ConversationCache.open(
             (0, import_path29.join)(this.cacheDir, "cache.db"),
@@ -148462,8 +149420,10 @@ var StreamerServer = class {
           );
           this.scannerPersistenceDisabled = true;
         }
-        void this.reconcilePreviousSessions().then((v2) => {
-          this.rehydratePreviousSessions(v2);
+        if (this.ptyManager.isRemote()) this.refreshHostedSessionsFromRegistry();
+        void this.reconcilePreviousSessions().then(async (v2) => {
+          const recoverableRows = this.rehydratePreviousSessions(v2);
+          await this.autoResumePreviousSessions(recoverableRows);
           this.pruneTerminalSessions();
         });
         if (this.skipStartupWarmup) {
@@ -148666,7 +149626,8 @@ var StreamerServer = class {
     }
     this.lastAgentChunkAt.clear();
     this.terminalSeq.clear();
-    this.recordShutdownState();
+    if (this.ptyManager.isRemote()) this.ptyManager.dispose();
+    else this.recordShutdownState();
     this.markScannerStaleDebounced.cancel();
     await Promise.all([...this.inFlightCacheWrites]);
     await Promise.all([...this.allScanners].map((s3) => s3.close()));
@@ -148674,7 +149635,7 @@ var StreamerServer = class {
     this.scanner = null;
     this.cache?.close();
     this.runtimeStore?.close();
-    this.ptyManager.dispose();
+    if (!this.ptyManager.isRemote()) this.ptyManager.dispose();
     this.fileWatcher.dispose();
     this.externalTails.clear();
     this.wsHub.dispose();
@@ -149724,6 +150685,16 @@ var StreamerServer = class {
       const windowStart = Math.max(0, beforeIndex - scanLimit);
       const indexWindow = scanLimit > 0 && !hasAnchor && indexFilePath && this.cache ? this.cache.readMessageWindow(indexFilePath, windowStart, beforeIndex) : null;
       if (!indexWindow && indexFilePath && this.cache && !hasAnchor) {
+        this.log.info(
+          `[server] offset-index miss ${id} \u2192 scanner fallback`,
+          {
+            event: "offset_index.miss",
+            conversationId: id,
+            fromIndex: windowStart,
+            toIndex: beforeIndex
+          },
+          "pino"
+        );
         this.trackCacheWrite(
           this.cache.backfillIndex(indexFilePath).catch((err) => {
             this.log.warn("offset-index.backfill_failed", {
@@ -149998,14 +150969,15 @@ var StreamerServer = class {
   }
   async handleGetSession(sessionId, res) {
     if (this.rejectIfWarmingUp(res)) return;
-    const session = this.sessionStore.get(sessionId, this.ptyAttachedIds());
-    if (session) {
-      if (!(0, import_fs30.existsSync)(session.projectPath)) {
-        session.failureReason = `Project directory not found: ${session.projectPath}`;
-      }
-      const reconciled = this.withReconciledLifecycle([session])[0];
-      session.lifecycle = reconciled.lifecycle;
-      session.lifecycleSource = reconciled.lifecycleSource;
+    const base = this.sessionStore.get(sessionId, this.ptyAttachedIds());
+    if (base) {
+      const reconciled = this.withReconciledLifecycle([base])[0];
+      const session = {
+        ...base,
+        ...(0, import_fs30.existsSync)(base.projectPath) ? {} : { failureReason: `Project directory not found: ${base.projectPath}` },
+        lifecycle: reconciled.lifecycle,
+        lifecycleSource: reconciled.lifecycleSource
+      };
       if (this.ptyManager.hasSession(sessionId)) {
         try {
           const lines = await this.ptyManager.getOutputLines(sessionId, 10);
@@ -150168,31 +151140,37 @@ var StreamerServer = class {
     this.sessionStore.addManaged(session);
     this.recordSessionSpawn(session);
     void this.watchConversationFile(sessionId, historyId);
-    const response = this.sessionStore.get(session.id, this.ptyAttachedIds());
     this.enrichResumedSessionAsync(sessionId, projectPath, conv);
+    const response = this.sessionStore.get(session.id, this.ptyAttachedIds());
     return { ok: true, alreadyRunning: false, session, response };
   }
   enrichResumedSessionAsync(sessionId, projectPath, conv) {
     try {
-      const session = this.sessionStore.get(sessionId, this.ptyAttachedIds());
-      if (!session) return;
+      if (!this.sessionStore.getManaged(sessionId)) return;
       if (conv) {
-        session.sessionName = conv.sessionName ?? void 0;
-        session.messageCount = conv.messageCount ?? 0;
-        session.account = conv.account ?? void 0;
-        session.filePath = conv.filePath ?? void 0;
+        this.sessionStore.updateManaged(sessionId, {
+          sessionName: conv.sessionName ?? void 0,
+          messageCount: conv.messageCount ?? 0,
+          account: conv.account ?? void 0,
+          filePath: conv.filePath ?? void 0
+        });
       }
       if (!this.cache || !this.projectsRepo || !this.conversationsRepo) return;
       const cached4 = this.cache.getMetaById(sessionId);
       if (cached4) {
-        session.model = cached4.model ?? void 0;
-        session.preview = cached4.preview ?? void 0;
         const first = cached4.firstMessage ? JSON.parse(cached4.firstMessage) : null;
         const last = cached4.lastMessage ? JSON.parse(cached4.lastMessage) : null;
-        session.firstMessageText = first?.text ?? void 0;
-        session.firstMessageAt = first?.timestamp ? new Date(first.timestamp).toISOString() : void 0;
-        session.lastMessageText = last?.text ?? void 0;
-        session.lastMessageAt = last?.timestamp ? new Date(last.timestamp).toISOString() : void 0;
+        this.sessionStore.updateManaged(sessionId, {
+          model: cached4.model ?? void 0,
+          preview: cached4.preview ?? void 0,
+          firstMessageText: first?.text ?? void 0,
+          // parseIsoDateOrNull, not `new Date()`: an unparseable cached
+          // timestamp must land as absent, not as an Invalid Date that
+          // managedToResponse would throw on when it calls .toISOString().
+          firstMessageAt: parseIsoDateOrNull(first?.timestamp) ?? void 0,
+          lastMessageText: last?.text ?? void 0,
+          lastMessageAt: parseIsoDateOrNull(last?.timestamp) ?? void 0
+        });
       }
       let resolvedProjectId = cached4?.projectId ?? null;
       if (!resolvedProjectId) {
@@ -150204,8 +151182,10 @@ var StreamerServer = class {
         });
       }
       if (resolvedProjectId) {
-        session.projectId = resolvedProjectId;
-        session.resumedFromConversationId = sessionId;
+        this.sessionStore.updateManaged(sessionId, {
+          projectId: resolvedProjectId,
+          resumedFromConversationId: sessionId
+        });
       }
     } catch (err) {
       console.error(`[enrichResumedSessionAsync] ${sessionId}:`, err);
@@ -151482,7 +152462,7 @@ function isBrewInstall(scriptPath = process.argv[1] ?? "") {
 // src/updater/download.ts
 var import_node_crypto5 = require("crypto");
 var import_node_fs10 = require("fs");
-var import_node_path10 = require("path");
+var import_node_path11 = require("path");
 var import_promises17 = require("stream/promises");
 
 // src/updater/manifest.ts
@@ -151542,7 +152522,7 @@ async function downloadAndVerify(opts) {
       `Manifest references ${artifact.filename} but it is not attached to the release`
     );
   }
-  (0, import_node_fs10.mkdirSync)((0, import_node_path10.dirname)(targetPath), { recursive: true });
+  (0, import_node_fs10.mkdirSync)((0, import_node_path11.dirname)(targetPath), { recursive: true });
   const res = await fetch(asset.browserDownloadUrl);
   if (!res.ok || !res.body) {
     throw new Error(`Failed to download ${artifact.filename}: ${res.status} ${res.statusText}`);
@@ -151581,23 +152561,23 @@ async function downloadAndVerify(opts) {
 }
 
 // src/updater/paths.ts
-var import_node_os5 = require("os");
-var import_node_path11 = require("path");
-var THREADBASE_ROOT = (0, import_node_path11.join)((0, import_node_os5.homedir)(), ".threadbase");
-var RELEASES_DIR = (0, import_node_path11.join)(THREADBASE_ROOT, "releases");
-var CURRENT_SYMLINK = (0, import_node_path11.join)(THREADBASE_ROOT, "current");
-var DOWNLOAD_DIR = (0, import_node_path11.join)(THREADBASE_ROOT, "releases", ".tmp");
+var import_node_os6 = require("os");
+var import_node_path12 = require("path");
+var THREADBASE_ROOT = (0, import_node_path12.join)((0, import_node_os6.homedir)(), ".threadbase");
+var RELEASES_DIR = (0, import_node_path12.join)(THREADBASE_ROOT, "releases");
+var CURRENT_SYMLINK = (0, import_node_path12.join)(THREADBASE_ROOT, "current");
+var DOWNLOAD_DIR = (0, import_node_path12.join)(THREADBASE_ROOT, "releases", ".tmp");
 function releaseDir(version2) {
-  return (0, import_node_path11.join)(RELEASES_DIR, version2);
+  return (0, import_node_path12.join)(RELEASES_DIR, version2);
 }
 function downloadPath(version2, filename) {
-  return (0, import_node_path11.join)(DOWNLOAD_DIR, `${version2}-${filename}`);
+  return (0, import_node_path12.join)(DOWNLOAD_DIR, `${version2}-${filename}`);
 }
 
 // src/updater/restart.ts
-var import_node_child_process3 = require("child_process");
+var import_node_child_process4 = require("child_process");
 var import_node_util3 = require("util");
-var execFileP = (0, import_node_util3.promisify)(import_node_child_process3.execFile);
+var execFileP = (0, import_node_util3.promisify)(import_node_child_process4.execFile);
 var BREW_LAUNCHD_LABEL = "homebrew.mxcl.tb-streamer";
 var DEPLOY_LAUNCHD_LABEL = "com.ronen.threadbase";
 function resolveDefaultLabel() {
@@ -151747,11 +152727,11 @@ async function waitForRestartHealth(opts) {
 
 // src/updater/stamp-version.ts
 var import_node_fs11 = require("fs");
-var import_node_path12 = require("path");
+var import_node_path13 = require("path");
 function stampVersionTxt(destDir, version2) {
-  const distDir = (0, import_node_path12.join)(destDir, "dist");
+  const distDir = (0, import_node_path13.join)(destDir, "dist");
   (0, import_node_fs11.mkdirSync)(distDir, { recursive: true });
-  (0, import_node_fs11.writeFileSync)((0, import_node_path12.join)(distDir, "version.txt"), versionStamp(version2));
+  (0, import_node_fs11.writeFileSync)((0, import_node_path13.join)(distDir, "version.txt"), versionStamp(version2));
 }
 function versionStamp(version2) {
   return `${version2}+update
@@ -151760,7 +152740,7 @@ function versionStamp(version2) {
 
 // src/updater/swap.ts
 var import_node_fs12 = require("fs");
-var import_node_path13 = require("path");
+var import_node_path14 = require("path");
 var import_semver2 = __toESM(require_semver2(), 1);
 var KEEP_LAST_N = 2;
 function swapCurrent(version2) {
@@ -151776,7 +152756,7 @@ function swapCurrent(version2) {
       (0, import_node_fs12.rmSync)(CURRENT_SYMLINK, { recursive: true, force: true });
     }
     (0, import_node_fs12.renameSync)(tmp, CURRENT_SYMLINK);
-    (0, import_node_fs12.copyFileSync)((0, import_node_path13.join)(CURRENT_SYMLINK, "dist", "cli.cjs"), (0, import_node_path13.join)(THREADBASE_ROOT, "cli.js"));
+    (0, import_node_fs12.copyFileSync)((0, import_node_path14.join)(CURRENT_SYMLINK, "dist", "cli.cjs"), (0, import_node_path14.join)(THREADBASE_ROOT, "cli.js"));
     publishVersionTxt(target, version2);
     return;
   }
@@ -151786,17 +152766,17 @@ function swapCurrent(version2) {
   }
   (0, import_node_fs12.symlinkSync)(target, tmpLink);
   (0, import_node_fs12.renameSync)(tmpLink, CURRENT_SYMLINK);
-  const cliJs = (0, import_node_path13.join)(THREADBASE_ROOT, "cli.js");
+  const cliJs = (0, import_node_path14.join)(THREADBASE_ROOT, "cli.js");
   const tmpCliJs = `${cliJs}.new`;
   if ((0, import_node_fs12.existsSync)(tmpCliJs) || lstatSafeIsSymlink(tmpCliJs)) (0, import_node_fs12.unlinkSync)(tmpCliJs);
-  (0, import_node_fs12.symlinkSync)((0, import_node_path13.join)(target, "dist", "cli.cjs"), tmpCliJs);
+  (0, import_node_fs12.symlinkSync)((0, import_node_path14.join)(target, "dist", "cli.cjs"), tmpCliJs);
   (0, import_node_fs12.renameSync)(tmpCliJs, cliJs);
   publishVersionTxt(target, version2);
 }
 function publishVersionTxt(target, version2) {
-  const dest = (0, import_node_path13.join)(THREADBASE_ROOT, "version.txt");
+  const dest = (0, import_node_path14.join)(THREADBASE_ROOT, "version.txt");
   try {
-    (0, import_node_fs12.copyFileSync)((0, import_node_path13.join)(target, "dist", "version.txt"), dest);
+    (0, import_node_fs12.copyFileSync)((0, import_node_path14.join)(target, "dist", "version.txt"), dest);
   } catch {
     (0, import_node_fs12.writeFileSync)(dest, versionStamp(version2));
   }
@@ -151835,7 +152815,7 @@ var import_fs31 = __toESM(require("fs"), 1);
 var import_node_events3 = require("events");
 var import_node_stream2 = __toESM(require("stream"), 1);
 var import_node_string_decoder = require("string_decoder");
-var import_node_path14 = __toESM(require("path"), 1);
+var import_node_path15 = __toESM(require("path"), 1);
 var import_node_fs13 = __toESM(require("fs"), 1);
 var import_path30 = require("path");
 var import_events4 = require("events");
@@ -151843,27 +152823,27 @@ var import_assert = __toESM(require("assert"), 1);
 var import_buffer2 = require("buffer");
 var Ps = __toESM(require("zlib"), 1);
 var import_zlib = __toESM(require("zlib"), 1);
-var import_node_path15 = require("path");
 var import_node_path16 = require("path");
+var import_node_path17 = require("path");
 var import_fs32 = __toESM(require("fs"), 1);
 var import_fs33 = __toESM(require("fs"), 1);
 var import_path31 = __toESM(require("path"), 1);
-var import_node_path17 = require("path");
+var import_node_path18 = require("path");
 var import_path32 = __toESM(require("path"), 1);
 var import_node_fs14 = __toESM(require("fs"), 1);
 var import_node_assert = __toESM(require("assert"), 1);
 var import_node_crypto6 = require("crypto");
 var import_node_fs15 = __toESM(require("fs"), 1);
-var import_node_path18 = __toESM(require("path"), 1);
+var import_node_path19 = __toESM(require("path"), 1);
 var import_fs34 = __toESM(require("fs"), 1);
 var import_node_fs16 = __toESM(require("fs"), 1);
-var import_node_path19 = __toESM(require("path"), 1);
+var import_node_path20 = __toESM(require("path"), 1);
 var import_node_fs17 = __toESM(require("fs"), 1);
 var import_promises18 = __toESM(require("fs/promises"), 1);
-var import_node_path20 = __toESM(require("path"), 1);
-var import_node_path21 = require("path");
+var import_node_path21 = __toESM(require("path"), 1);
+var import_node_path22 = require("path");
 var import_node_fs18 = __toESM(require("fs"), 1);
-var import_node_path22 = __toESM(require("path"), 1);
+var import_node_path23 = __toESM(require("path"), 1);
 var zr = Object.defineProperty;
 var Ur = (s3, t) => {
   for (var e in t) zr(s3, e, { get: t[e], enumerable: true });
@@ -152757,12 +153737,12 @@ var F = class {
   }
 };
 var un = (s3, t) => {
-  let i = s3, r = "", n, o = import_node_path15.posix.parse(s3).root || ".";
+  let i = s3, r = "", n, o = import_node_path16.posix.parse(s3).root || ".";
   if (Buffer.byteLength(i) < 100) n = [i, r, false];
   else {
-    r = import_node_path15.posix.dirname(i), i = import_node_path15.posix.basename(i);
+    r = import_node_path16.posix.dirname(i), i = import_node_path16.posix.basename(i);
     do
-      Buffer.byteLength(i) <= 100 && Buffer.byteLength(r) <= t ? n = [i, r, false] : Buffer.byteLength(i) > 100 && Buffer.byteLength(r) <= t ? n = [i.slice(0, 99), r, true] : (i = import_node_path15.posix.join(import_node_path15.posix.basename(r), i), r = import_node_path15.posix.dirname(r));
+      Buffer.byteLength(i) <= 100 && Buffer.byteLength(r) <= t ? n = [i, r, false] : Buffer.byteLength(i) > 100 && Buffer.byteLength(r) <= t ? n = [i.slice(0, 99), r, true] : (i = import_node_path16.posix.join(import_node_path16.posix.basename(r), i), r = import_node_path16.posix.dirname(r));
     while (r !== o && n === void 0);
     n || (n = [s3.slice(0, 99), "", true]);
   }
@@ -152808,7 +153788,7 @@ var ft = class s {
     if (t === "") return Buffer.allocUnsafe(0);
     let e = Buffer.byteLength(t), i = 512 * Math.ceil(1 + e / 512), r = Buffer.allocUnsafe(i);
     for (let n = 0; n < 512; n++) r[n] = 0;
-    new F({ path: ("PaxHeader/" + (0, import_node_path16.basename)(this.path ?? "")).slice(0, 99), mode: this.mode || 420, uid: this.uid, gid: this.gid, size: e, mtime: this.mtime, type: this.global ? "GlobalExtendedHeader" : "ExtendedHeader", linkpath: "", uname: this.uname || "", gname: this.gname || "", devmaj: 0, devmin: 0, atime: this.atime, ctime: this.ctime }).encode(r), r.write(t, 512, e, "utf8");
+    new F({ path: ("PaxHeader/" + (0, import_node_path17.basename)(this.path ?? "")).slice(0, 99), mode: this.mode || 420, uid: this.uid, gid: this.gid, size: e, mtime: this.mtime, type: this.global ? "GlobalExtendedHeader" : "ExtendedHeader", linkpath: "", uname: this.uname || "", gname: this.gname || "", devmaj: 0, devmin: 0, atime: this.atime, ctime: this.ctime }).encode(r), r.write(t, 512, e, "utf8");
     for (let n = e + 512; n < r.length; n++) r[n] = 0;
     return r;
   }
@@ -153264,7 +154244,7 @@ var Ct = K(Mn, Bn, (s3) => new rt(s3), (s3) => new rt(s3), (s3, t) => {
   t?.length && Qi(s3, t), s3.noResume || vn(s3);
 });
 var Ji = (s3, t, e) => (s3 &= 4095, e && (s3 = (s3 | 384) & -19), t && (s3 & 256 && (s3 |= 64), s3 & 32 && (s3 |= 8), s3 & 4 && (s3 |= 1)), s3);
-var { isAbsolute: zn, parse: qs } = import_node_path17.win32;
+var { isAbsolute: zn, parse: qs } = import_node_path18.win32;
 var ce = (s3) => {
   let t = "", e = qs(s3);
   for (; zn(s3) || e.root; ) {
@@ -153973,11 +154953,11 @@ var $n = (s3, t) => {
 };
 var fr = (s3, t) => {
   t.forEach((e) => {
-    e.charAt(0) === "@" ? Ct({ file: import_node_path14.default.resolve(s3.cwd, e.slice(1)), sync: true, noResume: true, onReadEntry: (i) => s3.add(i) }) : s3.add(e);
+    e.charAt(0) === "@" ? Ct({ file: import_node_path15.default.resolve(s3.cwd, e.slice(1)), sync: true, noResume: true, onReadEntry: (i) => s3.add(i) }) : s3.add(e);
   }), s3.end();
 };
 var dr = async (s3, t) => {
-  for (let e of t) e.charAt(0) === "@" ? await Ct({ file: import_node_path14.default.resolve(String(s3.cwd), e.slice(1)), noResume: true, onReadEntry: (i) => {
+  for (let e of t) e.charAt(0) === "@" ? await Ct({ file: import_node_path15.default.resolve(String(s3.cwd), e.slice(1)), noResume: true, onReadEntry: (i) => {
     s3.add(i);
   } }) : s3.add(e);
   s3.end();
@@ -154015,13 +154995,13 @@ var Ei = (s3, t, e, i) => {
   });
 };
 var io = (s3, t, e, i, r) => {
-  if (t.isDirectory()) Es(import_node_path19.default.resolve(s3, t.name), e, i, (n) => {
+  if (t.isDirectory()) Es(import_node_path20.default.resolve(s3, t.name), e, i, (n) => {
     if (n) return r(n);
-    let o = import_node_path19.default.resolve(s3, t.name);
+    let o = import_node_path20.default.resolve(s3, t.name);
     Ei(o, e, i, r);
   });
   else {
-    let n = import_node_path19.default.resolve(s3, t.name);
+    let n = import_node_path20.default.resolve(s3, t.name);
     Ei(n, e, i, r);
   }
 };
@@ -154042,7 +155022,7 @@ var Es = (s3, t, e, i) => {
   });
 };
 var so = (s3, t, e, i) => {
-  t.isDirectory() && ws(import_node_path19.default.resolve(s3, t.name), e, i), ps(import_node_path19.default.resolve(s3, t.name), e, i);
+  t.isDirectory() && ws(import_node_path20.default.resolve(s3, t.name), e, i), ps(import_node_path20.default.resolve(s3, t.name), e, i);
 };
 var ws = (s3, t, e) => {
   let i;
@@ -154092,12 +155072,12 @@ var gr = (s3, t, e) => {
   };
   if (s3 === d) return no(s3, S2);
   if (l) return import_promises18.default.mkdir(s3, { mode: r, recursive: true }).then((E) => S2(null, E ?? void 0), S2);
-  let D = f(import_node_path20.default.relative(d, s3)).split("/");
+  let D = f(import_node_path21.default.relative(d, s3)).split("/");
   Ss(d, D, r, c, d, void 0, S2);
 };
 var Ss = (s3, t, e, i, r, n, o) => {
   if (t.length === 0) return o(null, n);
-  let h = t.shift(), a = f(import_node_path20.default.resolve(s3 + "/" + h));
+  let h = t.shift(), a = f(import_node_path21.default.resolve(s3 + "/" + h));
   import_node_fs17.default.mkdir(a, e, br(a, t, e, i, r, n, o));
 };
 var br = (s3, t, e, i, r, n, o) => (h) => {
@@ -154131,9 +155111,9 @@ var _r = (s3, t) => {
   };
   if (s3 === c) return oo(c), d();
   if (a) return d(import_node_fs17.default.mkdirSync(s3, { mode: i, recursive: true }) ?? void 0);
-  let T2 = f(import_node_path20.default.relative(c, s3)).split("/"), D;
+  let T2 = f(import_node_path21.default.relative(c, s3)).split("/"), D;
   for (let E = T2.shift(), x = c; E && (x += "/" + E); E = T2.shift()) {
-    x = f(import_node_path20.default.resolve(x));
+    x = f(import_node_path21.default.resolve(x));
     try {
       import_node_fs17.default.mkdirSync(x, i), D = D || x;
     } catch {
@@ -154162,14 +155142,14 @@ var ho = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
 var ao = ho === "win32";
 var lo = (s3) => s3.split("/").slice(0, -1).reduce((e, i) => {
   let r = e.at(-1);
-  return r !== void 0 && (i = (0, import_node_path21.join)(r, i)), e.push(i || "/"), e;
+  return r !== void 0 && (i = (0, import_node_path22.join)(r, i)), e.push(i || "/"), e;
 }, []);
 var yi = class {
   #t = /* @__PURE__ */ new Map();
   #i = /* @__PURE__ */ new Map();
   #s = /* @__PURE__ */ new Set();
   reserve(t, e) {
-    t = ao ? ["win32 parallelization disabled"] : t.map((r) => ut((0, import_node_path21.join)(Tr(r))));
+    t = ao ? ["win32 parallelization disabled"] : t.map((r) => ut((0, import_node_path22.join)(Tr(r))));
     let i = new Set(t.map((r) => lo(r)).reduce((r, n) => r.concat(n)));
     this.#i.set(e, { dirs: i, paths: t });
     for (let r of t) {
@@ -154309,7 +155289,7 @@ var Xt = class extends rt {
       if (t.preserveOwner) throw new TypeError("cannot preserve owner in archive and also set owner explicitly");
       this.uid = t.uid, this.gid = t.gid, this.setOwner = true;
     } else this.uid = void 0, this.gid = void 0, this.setOwner = false;
-    this.preserveOwner = t.preserveOwner === void 0 && typeof t.uid != "number" ? process.getuid?.() === 0 : !!t.preserveOwner, this.processUid = (this.preserveOwner || this.setOwner) && process.getuid ? process.getuid() : void 0, this.processGid = (this.preserveOwner || this.setOwner) && process.getgid ? process.getgid() : void 0, this.maxDepth = typeof t.maxDepth == "number" ? t.maxDepth : mo, this.forceChown = t.forceChown === true, this.win32 = !!t.win32 || Te, this.newer = !!t.newer, this.keep = !!t.keep, this.noMtime = !!t.noMtime, this.preservePaths = !!t.preservePaths, this.unlink = !!t.unlink, this.cwd = f(import_node_path18.default.resolve(t.cwd || process.cwd())), this.strip = Number(t.strip) || 0, this.processUmask = this.chmod ? typeof t.processUmask == "number" ? t.processUmask : Lr() : 0, this.umask = typeof t.umask == "number" ? t.umask : this.processUmask, this.dmode = t.dmode || 511 & ~this.umask, this.fmode = t.fmode || 438 & ~this.umask, this.on("entry", (e) => this[Dr](e));
+    this.preserveOwner = t.preserveOwner === void 0 && typeof t.uid != "number" ? process.getuid?.() === 0 : !!t.preserveOwner, this.processUid = (this.preserveOwner || this.setOwner) && process.getuid ? process.getuid() : void 0, this.processGid = (this.preserveOwner || this.setOwner) && process.getgid ? process.getgid() : void 0, this.maxDepth = typeof t.maxDepth == "number" ? t.maxDepth : mo, this.forceChown = t.forceChown === true, this.win32 = !!t.win32 || Te, this.newer = !!t.newer, this.keep = !!t.keep, this.noMtime = !!t.noMtime, this.preservePaths = !!t.preservePaths, this.unlink = !!t.unlink, this.cwd = f(import_node_path19.default.resolve(t.cwd || process.cwd())), this.strip = Number(t.strip) || 0, this.processUmask = this.chmod ? typeof t.processUmask == "number" ? t.processUmask : Lr() : 0, this.umask = typeof t.umask == "number" ? t.umask : this.processUmask, this.dmode = t.dmode || 511 & ~this.umask, this.fmode = t.fmode || 438 & ~this.umask, this.on("entry", (e) => this[Dr](e));
   }
   warn(t, e, i = {}) {
     return (t === "TAR_BAD_ARCHIVE" || t === "TAR_ABORT") && (i.recoverable = false), super.warn(t, e, i);
@@ -154323,7 +155303,7 @@ var Xt = class extends rt {
     let [n, o] = ce(i), h = o.replaceAll(/\\/g, "/").split("/");
     if (h.includes("..") || Te && /^[a-z]:\.\.$/i.test(h[0] ?? "")) {
       if (e === "path" || r === "Link") return this.warn("TAR_ENTRY_ERROR", `${e} contains '..'`, { entry: t, [e]: i }), false;
-      let a = import_node_path18.default.posix.dirname(t.path), l = import_node_path18.default.posix.normalize(import_node_path18.default.posix.join(a, h.join("/")));
+      let a = import_node_path19.default.posix.dirname(t.path), l = import_node_path19.default.posix.normalize(import_node_path19.default.posix.join(a, h.join("/")));
       if (l.startsWith("../") || l === "..") return this.warn("TAR_ENTRY_ERROR", `${e} escapes extraction directory`, { entry: t, [e]: i }), false;
     }
     return n && (t[e] = String(o), this.warn("TAR_ENTRY_INFO", `stripping ${n} from absolute ${e}`, { entry: t, [e]: i })), true;
@@ -154341,12 +155321,12 @@ var Xt = class extends rt {
     }
     if (isFinite(this.maxDepth) && i.length > this.maxDepth) return this.warn("TAR_ENTRY_ERROR", "path excessively deep", { entry: t, path: e, depth: i.length, maxDepth: this.maxDepth }), false;
     if (!this[Rs](t, "path") || !this[Rs](t, "linkpath")) return false;
-    if (t.absolute = import_node_path18.default.isAbsolute(t.path) ? f(import_node_path18.default.resolve(t.path)) : f(import_node_path18.default.resolve(this.cwd, t.path)), !this.preservePaths && typeof t.absolute == "string" && t.absolute.indexOf(this.cwd + "/") !== 0 && t.absolute !== this.cwd) return this.warn("TAR_ENTRY_ERROR", "path escaped extraction target", { entry: t, path: f(t.path), resolvedPath: t.absolute, cwd: this.cwd }), false;
+    if (t.absolute = import_node_path19.default.isAbsolute(t.path) ? f(import_node_path19.default.resolve(t.path)) : f(import_node_path19.default.resolve(this.cwd, t.path)), !this.preservePaths && typeof t.absolute == "string" && t.absolute.indexOf(this.cwd + "/") !== 0 && t.absolute !== this.cwd) return this.warn("TAR_ENTRY_ERROR", "path escaped extraction target", { entry: t, path: f(t.path), resolvedPath: t.absolute, cwd: this.cwd }), false;
     if (t.absolute === this.cwd && t.type !== "Directory" && t.type !== "GNUDumpDir") return false;
     if (this.win32) {
-      let { root: r } = import_node_path18.default.win32.parse(String(t.absolute));
+      let { root: r } = import_node_path19.default.win32.parse(String(t.absolute));
       t.absolute = r + ts(String(t.absolute).slice(r.length));
-      let { root: n } = import_node_path18.default.win32.parse(t.path);
+      let { root: n } = import_node_path19.default.win32.parse(t.path);
       t.path = n + ts(t.path.slice(n.length));
     }
     return true;
@@ -154434,13 +155414,13 @@ var Xt = class extends rt {
     t.unsupported = true, this.warn("TAR_ENTRY_UNSUPPORTED", `unsupported entry type: ${t.type}`, { entry: t }), t.resume();
   }
   [Ar](t, e) {
-    let i = f(import_node_path18.default.relative(this.cwd, import_node_path18.default.resolve(import_node_path18.default.dirname(String(t.absolute)), String(t.linkpath)))).split("/");
+    let i = f(import_node_path19.default.relative(this.cwd, import_node_path19.default.resolve(import_node_path19.default.dirname(String(t.absolute)), String(t.linkpath)))).split("/");
     this[Re](t, this.cwd, i, () => this[gi](t, String(t.linkpath), "symlink", e), (r) => {
       this[O](r, t), e();
     });
   }
   [Ir](t, e) {
-    let i = f(import_node_path18.default.resolve(this.cwd, String(t.linkpath))), r = f(String(t.linkpath)).split("/");
+    let i = f(import_node_path19.default.resolve(this.cwd, String(t.linkpath))), r = f(String(t.linkpath)).split("/");
     this[Re](t, this.cwd, r, () => this[gi](t, i, "link", e), (n) => {
       this[O](n, t), e();
     });
@@ -154448,10 +155428,10 @@ var Xt = class extends rt {
   [Re](t, e, i, r, n) {
     let o = i.shift();
     if (this.preservePaths || o === void 0) return r();
-    let h = import_node_path18.default.resolve(e, o);
+    let h = import_node_path19.default.resolve(e, o);
     import_node_fs15.default.lstat(h, (a, l) => {
       if (a) return r();
-      if (l?.isSymbolicLink()) return n(new St(h, import_node_path18.default.resolve(h, i.join("/"))));
+      if (l?.isSymbolicLink()) return n(new St(h, import_node_path19.default.resolve(h, i.join("/"))));
       this[Re](t, h, i, r, n);
     });
   }
@@ -154485,7 +155465,7 @@ var Xt = class extends rt {
       });
     }, n = () => {
       if (t.absolute !== this.cwd) {
-        let h = f(import_node_path18.default.dirname(String(t.absolute)));
+        let h = f(import_node_path19.default.dirname(String(t.absolute)));
         if (h !== this.cwd) return this[yt](h, this.dmode, (a) => {
           if (a) {
             this[O](a, t), i();
@@ -154560,7 +155540,7 @@ var xe = class extends Xt {
       this[Oe] = true;
     }
     if (t.absolute !== this.cwd) {
-      let n = f(import_node_path18.default.dirname(String(t.absolute)));
+      let n = f(import_node_path19.default.dirname(String(t.absolute)));
       if (n !== this.cwd) {
         let o = this[yt](n, this.dmode);
         if (o) return this[O](o, t);
@@ -154660,10 +155640,10 @@ var xe = class extends Xt {
     if (this.preservePaths || i.length === 0) return r();
     let o = e;
     for (let h of i) {
-      o = import_node_path18.default.resolve(o, h);
+      o = import_node_path19.default.resolve(o, h);
       let [a, l] = ye(() => import_node_fs15.default.lstatSync(o));
       if (a) return r();
-      if (l.isSymbolicLink()) return n(new St(o, import_node_path18.default.resolve(e, i.join("/"))));
+      if (l.isSymbolicLink()) return n(new St(o, import_node_path19.default.resolve(e, i.join("/"))));
     }
     r();
   }
@@ -154767,11 +155747,11 @@ var go = (s3, t) => {
 };
 var bo = (s3, t) => {
   t.forEach((e) => {
-    e.charAt(0) === "@" ? Ct({ file: import_node_path22.default.resolve(s3.cwd, e.slice(1)), sync: true, noResume: true, onReadEntry: (i) => s3.add(i) }) : s3.add(e);
+    e.charAt(0) === "@" ? Ct({ file: import_node_path23.default.resolve(s3.cwd, e.slice(1)), sync: true, noResume: true, onReadEntry: (i) => s3.add(i) }) : s3.add(e);
   }), s3.end();
 };
 var _o = async (s3, t) => {
-  for (let e of t) e.charAt(0) === "@" ? await Ct({ file: import_node_path22.default.resolve(String(s3.cwd), e.slice(1)), noResume: true, onReadEntry: (i) => s3.add(i) }) : s3.add(e);
+  for (let e of t) e.charAt(0) === "@" ? await Ct({ file: import_node_path23.default.resolve(String(s3.cwd), e.slice(1)), noResume: true, onReadEntry: (i) => s3.add(i) }) : s3.add(e);
   s3.end();
 };
 var vt = K(yo, go, () => {
@@ -154801,8 +155781,8 @@ async function unpackTarball(opts) {
 
 // src/updater/update-log.ts
 var import_node_fs20 = require("fs");
-var import_node_path23 = require("path");
-var LOG_PATH = (0, import_node_path23.join)(THREADBASE_ROOT, "update.log");
+var import_node_path24 = require("path");
+var LOG_PATH = (0, import_node_path24.join)(THREADBASE_ROOT, "update.log");
 function appendUpdateLog(line) {
   try {
     (0, import_node_fs20.mkdirSync)(THREADBASE_ROOT, { recursive: true });
@@ -154917,15 +155897,19 @@ async function runInstall(opts) {
 }
 
 // cli/prod.ts
-var import_node_child_process7 = require("child_process");
+var import_node_child_process8 = require("child_process");
 var import_node_fs23 = require("fs");
+init_auth();
+init_feature_flags();
 init_conflict_check();
 init_constants();
 init_launchd();
 init_marker();
 init_platform2();
 init_logger();
-var log8 = getLogger("prod");
+init_protocol();
+init_socket();
+var log9 = getLogger("prod");
 function clearSupervisorLogs() {
   let paths;
   try {
@@ -154974,9 +155958,10 @@ async function runProdStatus() {
     marker: readMarker()
   };
 }
-async function runProdDoctor(opts) {
+async function runProdDoctor(opts, deps = {}) {
   const findings = [];
   const repairs = [];
+  let ptyHost;
   const marker = readMarker();
   if (marker && !marker.userHeld && !isPidAlive(marker.devPid)) {
     findings.push(`stale marker (dev pid ${marker.devPid} dead)`);
@@ -155000,7 +155985,23 @@ async function runProdDoctor(opts) {
       );
     }
   }
-  return { findings, repairs };
+  const featureFlags = deps.featureFlags ?? resolveFeatureFlags({ yaml: loadFeatureFlags() });
+  if (featureFlags.ptyHost) {
+    const probe = deps.probePtyHost ?? (() => probePtyHostStatus(hostSocketPath(getInstanceId())));
+    try {
+      ptyHost = await probe();
+    } catch (err) {
+      ptyHost = { reachable: false, error: err instanceof Error ? err.message : String(err) };
+    }
+    if (!ptyHost.reachable) {
+      findings.push(`pty-host is not reachable: ${ptyHost.error}`);
+    } else if (ptyHost.protocolVersion !== PTY_HOST_PROTOCOL_VERSION) {
+      findings.push(
+        `pty-host protocol ${ptyHost.protocolVersion} does not match streamer protocol ${PTY_HOST_PROTOCOL_VERSION}`
+      );
+    }
+  }
+  return { findings, repairs, ...ptyHost ? { ptyHost } : {} };
 }
 var defaultSpawnTail = ({ files, lines, follow }) => {
   const existing = files.filter((f2) => (0, import_node_fs23.existsSync)(f2));
@@ -155014,7 +156015,7 @@ var defaultSpawnTail = ({ files, lines, follow }) => {
   if (follow) args.push("-F");
   args.push(...existing);
   return new Promise((resolve4) => {
-    const child = (0, import_node_child_process7.spawn)("tail", args, { stdio: ["ignore", "inherit", "inherit"] });
+    const child = (0, import_node_child_process8.spawn)("tail", args, { stdio: ["ignore", "inherit", "inherit"] });
     child.on("error", (err) => resolve4({ ok: false, message: `tail failed: ${err.message}` }));
     child.on("exit", (code) => resolve4({ ok: code === 0 }));
   });
@@ -155082,12 +156083,12 @@ function registerProdCommands(program3) {
   prod.command("start").description("Restore prod after a user-held suspension").option("--clear-logs", "Clear existing stdout + stderr logs", false).action(async (opts) => {
     if (opts.clearLogs === true) clearSupervisorLogs();
     const r = await runProdStart();
-    log8.info(r.message, void 0, "console");
+    log9.info(r.message, void 0, "console");
     if (!r.ok) process.exitCode = 1;
   });
   prod.command("stop").description("Unload the launchd agent (prod will not auto-restart)").action(async () => {
     const r = await runProdStop();
-    log8.info(r.message, void 0, "console");
+    log9.info(r.message, void 0, "console");
   });
   prod.command("status").description("Report whether prod is supervised, suspended, or down").action(async () => {
     const s3 = await runProdStatus();
@@ -155096,7 +156097,7 @@ function registerProdCommands(program3) {
       `pid: ${s3.agentPid ?? "(none)"}`,
       s3.marker ? `marker: ${s3.marker.userHeld ? "userHeld (intentional stop)" : "dev-suspended"}, devPid=${s3.marker.devPid}, port=${s3.marker.port}, repo=${s3.marker.repoToplevel}` : "marker: none"
     ];
-    log8.info(parts.join("\n  "), void 0, "console");
+    log9.info(parts.join("\n  "), void 0, "console");
   });
   prod.command("restart").description("Stop + restart the supervised streamer (re-reads service definition)").option("--clear-logs", "Clear existing stdout + stderr logs", false).action(async (opts) => {
     const sup = getSupervisor();
@@ -155105,17 +156106,24 @@ function registerProdCommands(program3) {
     sup.bootoutAgent();
     sup.bootstrapAgent(specPath, { afterBootout: true });
     const what = process.platform === "darwin" ? `agent restarted from ${specPath}` : `task '${TASK_NAME}' restarted`;
-    log8.info(what, void 0, "console");
+    log9.info(what, void 0, "console");
   });
-  prod.command("doctor").description("Detect & repair stale markers, missing agent, plist drift").option("--fix", "Apply repairs (default is dry-run)", false).action(async (opts) => {
+  prod.command("doctor").description("Detect stale markers, missing agents, and pty-host health").option("--fix", "Apply repairs (default is dry-run)", false).action(async (opts) => {
     const r = await runProdDoctor({ fix: opts.fix === true });
-    log8.info(`findings: ${r.findings.length === 0 ? "(none)" : ""}`, void 0, "console");
-    for (const f2 of r.findings) log8.info(`  - ${f2}`, void 0, "console");
+    if (r.ptyHost) {
+      log9.info(
+        r.ptyHost.reachable ? `pty-host: reachable, protocol=${r.ptyHost.protocolVersion}, sessions=${r.ptyHost.sessionCount}` : `pty-host: unreachable (${r.ptyHost.error})`,
+        void 0,
+        "console"
+      );
+    }
+    log9.info(`findings: ${r.findings.length === 0 ? "(none)" : ""}`, void 0, "console");
+    for (const f2 of r.findings) log9.info(`  - ${f2}`, void 0, "console");
     if (r.repairs.length) {
-      log8.info(`repairs:`, void 0, "console");
-      for (const fix of r.repairs) log8.info(`  - ${fix}`, void 0, "console");
+      log9.info(`repairs:`, void 0, "console");
+      for (const fix of r.repairs) log9.info(`  - ${fix}`, void 0, "console");
     } else if (!opts.fix && r.findings.length > 0) {
-      log8.info(`(re-run with --fix to apply repairs)`, void 0, "console");
+      log9.info(`(re-run with --fix to apply repairs)`, void 0, "console");
     }
   });
   prod.command("logs").description("Tail the supervised streamer's stdout + stderr log files").option("-n, --lines <count>", "Seed with the last N lines (default 50)", "50").option("--no-follow", "Print last N lines and exit (do not follow)").option("--errors-only", "Tail only stderr", false).option("--clear", "Truncate stdout + stderr logs in place, then exit", false).action(async (opts) => {
@@ -155126,14 +156134,14 @@ function registerProdCommands(program3) {
       errorsOnly: opts.errorsOnly === true,
       clear: opts.clear === true
     });
-    if (r.message) log8.info(r.message, void 0, "console");
+    if (r.message) log9.info(r.message, void 0, "console");
     if (!r.ok) process.exitCode = 1;
   });
   program3.addCommand(prod);
 }
 
 // cli/index.ts
-var log11 = getLogger("cli");
+var log12 = getLogger("cli");
 var program2 = new Command();
 program2.name("threadbase-streamer").description("PTY session management, WebSocket streaming, and REST API server for Claude Code").version(getVersion());
 program2.command("serve").description("Start the streamer server").option("-p, --port <number>", "Port to listen on", "8766").option("--api-key <key>", "API key for authentication").option("--local-no-auth", "Skip auth for localhost requests", false).option("-v, --verbose", "Verbose output", false).option("--log-menubar-requests", "Log /healthz requests from the menubar app", false).option("--browse-root <path>", "Root directory for file browsing").option(
@@ -155175,14 +156183,14 @@ program2.command("serve").description("Start the streamer server").option("-p, -
     const { checkSqliteAbi: checkSqliteAbi2 } = await Promise.resolve().then(() => (init_check_sqlite_abi(), check_sqlite_abi_exports));
     checkSqliteAbi2();
   } catch (err) {
-    log11.error(err instanceof Error ? err.message : String(err), void 0, "console");
+    log12.error(err instanceof Error ? err.message : String(err), void 0, "console");
     process.exit(1);
   }
   if (opts.multiAgentFlow) {
     process.env.MULTI_AGENT_FLOW = "true";
   }
   if (opts.defaultPermissionMode !== void 0 && !isPermissionMode(opts.defaultPermissionMode)) {
-    log11.error(
+    log12.error(
       `Invalid --default-permission-mode: ${opts.defaultPermissionMode} (expected one of ${PERMISSION_MODES.join(", ")})`,
       void 0,
       "console"
@@ -155198,7 +156206,7 @@ program2.command("serve").description("Start the streamer server").option("-p, -
       const value = eq === -1 ? true : entry.slice(eq + 1);
       const def = findFlag(id);
       if (!def) {
-        log11.error(
+        log12.error(
           `Invalid --claude-flag id: ${id} (expected one of ${CLAUDE_FLAGS.map((f2) => f2.id).join(", ")})`,
           void 0,
           "console"
@@ -155215,7 +156223,7 @@ program2.command("serve").description("Start the streamer server").option("-p, -
     claudeFlags = validateFlagValues(raw2);
     for (const id of Object.keys(raw2)) {
       if (!(id in claudeFlags)) {
-        log11.error(`Invalid value for --claude-flag ${id}`, void 0, "console");
+        log12.error(`Invalid value for --claude-flag ${id}`, void 0, "console");
         process.exit(1);
       }
     }
@@ -155224,13 +156232,13 @@ program2.command("serve").description("Start the streamer server").option("-p, -
   if (Array.isArray(opts.feature) && opts.feature.length > 0) {
     const parsed = parseFeatureFlagArgs(opts.feature);
     if (parsed.errors.length > 0) {
-      for (const error51 of parsed.errors) log11.error(`--feature: ${error51}`, void 0, "console");
+      for (const error51 of parsed.errors) log12.error(`--feature: ${error51}`, void 0, "console");
       process.exit(1);
     }
     featureFlags = parsed.values;
   }
   if (opts.defaultEffort !== void 0 && !isEffortLevel(opts.defaultEffort)) {
-    log11.error(
+    log12.error(
       `Invalid --default-effort: ${opts.defaultEffort} (expected one of ${EFFORT_LEVELS.join(", ")})`,
       void 0,
       "console"
@@ -155241,7 +156249,7 @@ program2.command("serve").description("Start the streamer server").option("-p, -
   if (opts.ptyGracePeriodMs !== void 0) {
     const parsed = Number(opts.ptyGracePeriodMs);
     if (!Number.isInteger(parsed) || parsed < 0) {
-      log11.error(
+      log12.error(
         `Invalid --pty-grace-period-ms: ${opts.ptyGracePeriodMs} (expected a non-negative integer; 0 disables auto-hold)`,
         void 0,
         "console"
@@ -155257,11 +156265,17 @@ program2.command("serve").description("Start the streamer server").option("-p, -
   const publicUrl = opts.publicUrl ?? loadPublicUrl() ?? null;
   const isProdInvocation = opts.prod === true || process.ppid === 1;
   if (!isProdInvocation) appendDevSessionMarker();
+  if (isProdInvocation) {
+    const { truncateOversizedLogs: truncateOversizedLogs2 } = await Promise.resolve().then(() => (init_log_cap(), log_cap_exports));
+    for (const f2 of truncateOversizedLogs2()) {
+      log12.info(`truncated oversized log at boot: ${f2}`, { path: f2, event: "log.truncated" });
+    }
+  }
   if (process.platform === "darwin") {
     const { detectConflictingAgents: detectConflictingAgents2, formatConflictMessage: formatConflictMessage2 } = await Promise.resolve().then(() => (init_conflict_check(), conflict_check_exports));
     const conflicts = detectConflictingAgents2();
     if (conflicts.length > 0) {
-      log11.warn(formatConflictMessage2(conflicts), void 0, "console");
+      log12.warn(formatConflictMessage2(conflicts), void 0, "console");
     }
   }
   let resolvedDefaultPermissionMode = opts.defaultPermissionMode;
@@ -155276,7 +156290,7 @@ program2.command("serve").description("Start the streamer server").option("-p, -
     resolvedAutoResumeOnBoot = await interactiveAutoResumePrompt2();
     setAutoResumeOnBoot(resolvedAutoResumeOnBoot);
   } else if (resolvedAutoResumeOnBoot === void 0) {
-    log11.info(
+    log12.info(
       "auto_resume_on_boot is not set; interrupted sessions will wait for you to resume them.\nSet `auto_resume_on_boot: true` in ~/.threadbase/server.yaml to resume them automatically.",
       void 0,
       "console"
@@ -155326,15 +156340,15 @@ program2.command("serve").description("Start the streamer server").option("-p, -
   await server.listen(resolvedPort);
   {
     const v2 = getVersion();
-    log11.info(`Threadbase Streamer v${v2}`, { version: v2, port: resolvedPort });
+    log12.info(`Threadbase Streamer v${v2}`, { version: v2, port: resolvedPort });
   }
-  log11.info(`Listening on http://localhost:${resolvedPort}`, {
+  log12.info(`Listening on http://localhost:${resolvedPort}`, {
     url: `http://localhost:${resolvedPort}`
   });
-  log11.info(`WebSocket at ws://localhost:${resolvedPort}/ws`, {
+  log12.info(`WebSocket at ws://localhost:${resolvedPort}/ws`, {
     wsUrl: `ws://localhost:${resolvedPort}/ws`
   });
-  log11.info(`API key: ${apiKey}`, { apiKeyMasked: `${apiKey.slice(0, 6)}\u2026` });
+  log12.info(`API key: ${apiKey}`, { apiKeyMasked: `${apiKey.slice(0, 6)}\u2026` });
   try {
     await printServerBanner({
       port: resolvedPort,
@@ -155344,15 +156358,15 @@ program2.command("serve").description("Start the streamer server").option("-p, -
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    log11.warn(`(skipped pairing QR: ${message})`, { reason: message });
-    log11.info(
+    log12.warn(`(skipped pairing QR: ${message})`, { reason: message });
+    log12.info(
       printUrlBanner({ url: resolveServerUrl({ publicUrl, port: resolvedPort }) }),
       void 0,
       "console"
     );
   }
   const shutdown = async () => {
-    log11.info("Shutting down...");
+    log12.info("Shutting down...");
     await server.close();
     process.exit(0);
   };
@@ -155360,7 +156374,7 @@ program2.command("serve").description("Start the streamer server").option("-p, -
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);
     process.on("uncaughtException", (err) => {
-      log11.error(`uncaught: ${err.message}`, {
+      log12.error(`uncaught: ${err.message}`, {
         error: err.message,
         stack: err.stack,
         event: "process.uncaught"
@@ -155369,7 +156383,7 @@ program2.command("serve").description("Start the streamer server").option("-p, -
     });
     process.on("unhandledRejection", (reason) => {
       const msg = reason instanceof Error ? reason.message : String(reason);
-      log11.error(`unhandled rejection: ${msg}`, {
+      log12.error(`unhandled rejection: ${msg}`, {
         error: msg,
         event: "process.unhandled_rejection"
       });
@@ -155394,10 +156408,10 @@ program2.command("cache").description("Manage the local SQLite conversation cach
       const f2 = dbPath + suffix;
       if (existsSync16(f2)) {
         rmSync6(f2);
-        log11.info(`Deleted ${f2}`, { path: f2 }, "console");
+        log12.info(`Deleted ${f2}`, { path: f2 }, "console");
       }
     }
-    log11.info("Cache cleared. Restart the server to rebuild.", void 0, "console");
+    log12.info("Cache cleared. Restart the server to rebuild.", void 0, "console");
   })
 );
 program2.command("pair").description("Print a pairing QR code (server must already be running)").option("-p, --port <number>", "Port the server is listening on", "8766").action(async (opts) => {
@@ -155422,7 +156436,7 @@ program2.command("set-key [key]").description("Set the streamer API key in ~/.th
 program2.command("update").description("Check for streamer updates from GitHub Releases and install them").option("--check", "Check only; do not install", false).option("--version <version>", "Pin to a specific release tag").option("--allow-major", "Allow a major-version bump", false).option("--force", "Skip the active-session defer check", false).option("--dry-run", "Print what would be installed without writing to disk", false).option("-p, --port <number>", "Port of the running streamer for active-session check", "8766").action(async (opts) => {
   const cfg = loadUpdateConfig();
   if (!cfg) {
-    log11.warn(
+    log12.warn(
       `No update config found at ${DEFAULT_CONFIG_PATH}. Create one with at least 'github_repo: owner/name' to enable updates.`,
       void 0,
       "console"
@@ -155441,11 +156455,11 @@ program2.command("update").description("Check for streamer updates from GitHub R
       appendUpdateLog(
         `[check] current=${result2.current} latest=${result2.latest ?? "none"} status=${result2.reason}`
       );
-      log11.info(`Current : ${result2.current}`, void 0, "console");
-      log11.info(`Latest  : ${result2.latest ?? "(none)"}`, void 0, "console");
-      log11.info(`Channel : ${cfg.channel}`, void 0, "console");
-      log11.info(`Diff    : ${result2.diff ?? "(none)"}`, void 0, "console");
-      log11.info(`Status  : ${result2.reason}`, void 0, "console");
+      log12.info(`Current : ${result2.current}`, void 0, "console");
+      log12.info(`Latest  : ${result2.latest ?? "(none)"}`, void 0, "console");
+      log12.info(`Channel : ${cfg.channel}`, void 0, "console");
+      log12.info(`Diff    : ${result2.diff ?? "(none)"}`, void 0, "console");
+      log12.info(`Status  : ${result2.reason}`, void 0, "console");
       return;
     }
     const port = Number.parseInt(opts.port, 10);
@@ -155461,20 +156475,20 @@ program2.command("update").description("Check for streamer updates from GitHub R
     });
     switch (result.kind) {
       case "no-op":
-        log11.info(`Current : ${result.current}`, void 0, "console");
-        log11.info(`Latest  : ${result.latest ?? "(none)"}`, void 0, "console");
-        log11.info(`Status  : ${result.reason}`, void 0, "console");
+        log12.info(`Current : ${result.current}`, void 0, "console");
+        log12.info(`Latest  : ${result.latest ?? "(none)"}`, void 0, "console");
+        log12.info(`Status  : ${result.reason}`, void 0, "console");
         break;
       case "unsupported-install":
-        log11.warn(result.reason, void 0, "console");
+        log12.warn(result.reason, void 0, "console");
         process.exitCode = 2;
         break;
       case "deferred":
-        log11.warn(`Deferred: ${result.reason}`, void 0, "console");
+        log12.warn(`Deferred: ${result.reason}`, void 0, "console");
         process.exitCode = 2;
         break;
       case "dry-run":
-        log11.info(
+        log12.info(
           `Would install ${result.latest} from ${result.tarballUrl}`,
           void 0,
           "console"
@@ -155482,28 +156496,28 @@ program2.command("update").description("Check for streamer updates from GitHub R
         break;
       case "installed":
         if (result.restart.method.startsWith("failed:")) {
-          log11.error(
+          log12.error(
             `Installed ${result.installed} on disk, but the running service was not updated. Restart: ${result.restart.method}.`,
             void 0,
             "console"
           );
           process.exitCode = 1;
         } else {
-          log11.info(
+          log12.info(
             `Installed ${result.installed} (was ${result.previous}). Restart: ${result.restart.method}.`,
             void 0,
             "console"
           );
         }
         if (result.pruned.length > 0) {
-          log11.info(`Pruned old releases: ${result.pruned.join(", ")}`, void 0, "console");
+          log12.info(`Pruned old releases: ${result.pruned.join(", ")}`, void 0, "console");
         }
         break;
     }
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     appendUpdateLog(`[error] ${message}`);
-    log11.error(`Update failed: ${message}`, { error: message }, "console");
+    log12.error(`Update failed: ${message}`, { error: message }, "console");
     process.exitCode = 1;
   }
 });
@@ -155515,21 +156529,32 @@ program2.command("pty-host").description(
 ).action(async (opts) => {
   const { SessionHost: SessionHost2 } = await Promise.resolve().then(() => (init_host(), host_exports));
   const { listenForStreamers: listenForStreamers2 } = await Promise.resolve().then(() => (init_socket(), socket_exports));
-  const host = new SessionHost2({ logger: getLogger("pty-host") });
   let server;
+  let host;
+  host = new SessionHost2({
+    logger: getLogger("pty-host"),
+    onShutdown: () => {
+      host.dispose();
+      server.close(() => process.exit(0));
+    },
+    onOrphaned: () => {
+      host.dispose();
+      server.close(() => process.exit(0));
+    }
+  });
   try {
     server = await listenForStreamers2(opts.socket, {
       onConnection: (transport) => host.accept(transport)
     });
   } catch (err) {
-    log11.error(
+    log12.error(
       `pty-host could not listen on ${opts.socket}: ${err instanceof Error ? err.message : String(err)}`,
       void 0,
       "console"
     );
     process.exit(1);
   }
-  log11.info(`pty-host listening on ${opts.socket}`, {
+  log12.info(`pty-host listening on ${opts.socket}`, {
     event: "pty_host.listening",
     socket: opts.socket
   });
@@ -155583,7 +156608,7 @@ async function printServerBanner({
 }) {
   const url2 = resolveServerUrl({ publicUrl, port });
   if (!includeQr) {
-    log11.info(printUrlBanner({ url: url2 }), void 0, "console");
+    log12.info(printUrlBanner({ url: url2 }), void 0, "console");
     return;
   }
   const res = await fetch(`http://localhost:${port}/api/pair/start`, {
@@ -155598,9 +156623,9 @@ async function printServerBanner({
   const expSeconds = Math.floor(expiresAt / 1e3);
   const payload = `threadbase://pair?url=${encodeURIComponent(url2)}&token=${token}&exp=${expSeconds}`;
   const qr2 = await generateQr(payload);
-  log11.info(printUrlBanner({ url: url2, qr: qr2, expiresAt }), void 0, "console");
-  log11.info(`Pair URL: ${payload}`, void 0, "console");
-  log11.info(`Expires in ${expiresInSeconds}s`, void 0, "console");
+  log12.info(printUrlBanner({ url: url2, qr: qr2, expiresAt }), void 0, "console");
+  log12.info(`Pair URL: ${payload}`, void 0, "console");
+  log12.info(`Expires in ${expiresInSeconds}s`, void 0, "console");
 }
 /*! Bundled license information: