@threadbase-sh/streamer 1.23.1 → 1.24.1

package/dist/cli.cjs

@@ -26621,7 +26621,7 @@ var require_transport = __commonJS({
   "node_modules/pino/lib/transport.js"(exports2, module2) {
     "use strict";
     var { createRequire } = require("module");
-    var { existsSync: existsSync11 } = require("fs");
+    var { existsSync: existsSync12 } = require("fs");
     var getCallers = require_caller();
     var { join: join26, isAbsolute: isAbsolute3, sep: sep2 } = require("path");
     var { fileURLToPath: fileURLToPath3 } = require("url");
@@ -26695,7 +26695,7 @@ var require_transport = __commonJS({
           return false;
         }
       }
-      return isAbsolute3(path2) && !existsSync11(path2);
+      return isAbsolute3(path2) && !existsSync12(path2);
     }
     function stripQuotes(value) {
       const first = value[0];
@@ -100885,8 +100885,8 @@ var require_pattern = __commonJS({
     }
     exports2.endsWithSlashGlobStar = endsWithSlashGlobStar;
     function isAffectDepthOfReadingPattern(pattern) {
-      const basename9 = path2.basename(pattern);
-      return endsWithSlashGlobStar(pattern) || isStaticPattern(basename9);
+      const basename11 = path2.basename(pattern);
+      return endsWithSlashGlobStar(pattern) || isStaticPattern(basename11);
     }
     exports2.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
     function expandPatternsWithBraceExpansion(patterns2) {
@@ -124663,6 +124663,50 @@ var init_platform = __esm({
   }
 });
 
+// src/db/check-sqlite-abi.ts
+var check_sqlite_abi_exports = {};
+__export(check_sqlite_abi_exports, {
+  SqliteAbiError: () => SqliteAbiError,
+  checkSqliteAbi: () => checkSqliteAbi,
+  isAbiMismatch: () => isAbiMismatch
+});
+function isAbiMismatch(message) {
+  return ABI_MARKERS.some((m2) => message.includes(m2));
+}
+function checkSqliteAbi() {
+  try {
+    const Database3 = require("better-sqlite3");
+    const db = new Database3(":memory:");
+    db.close();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (isAbiMismatch(message)) {
+      throw new SqliteAbiError(message);
+    }
+    throw err;
+  }
+}
+var REBUILD_HINT, SqliteAbiError, ABI_MARKERS;
+var init_check_sqlite_abi = __esm({
+  "src/db/check-sqlite-abi.ts"() {
+    "use strict";
+    REBUILD_HINT = "npm rebuild better-sqlite3";
+    SqliteAbiError = class extends Error {
+      constructor(cause) {
+        super(
+          `better-sqlite3 native module failed to load \u2014 likely a Node ABI mismatch (node_modules was built against a different Node version).
+  Running Node: ${process.version} (NODE_MODULE_VERSION ${process.versions.modules})
+  Fix: ${REBUILD_HINT}
+  (or 'npm ci' after any dependency-affecting pull)
+  Underlying error: ${cause}`
+        );
+        this.name = "SqliteAbiError";
+      }
+    };
+    ABI_MARKERS = ["NODE_MODULE_VERSION", "was compiled against a different Node.js version"];
+  }
+});
+
 // src/lifecycle/prefs.ts
 function readPrefs() {
   const path2 = prefsPath();
@@ -129594,10 +129638,10 @@ var ReaddirpStream = class extends import_node_stream.Readable {
   }
   async _formatEntry(dirent, path2) {
     let entry;
-    const basename9 = this._isDirent ? dirent.name : dirent;
+    const basename11 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = (0, import_node_path5.resolve)((0, import_node_path5.join)(path2, basename9));
-      entry = { path: (0, import_node_path5.relative)(this._root, fullPath), fullPath, basename: basename9 };
+      const fullPath = (0, import_node_path5.resolve)((0, import_node_path5.join)(path2, basename11));
+      entry = { path: (0, import_node_path5.relative)(this._root, fullPath), fullPath, basename: basename11 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -130136,9 +130180,9 @@ var NodeFsHandler = class {
   _watchWithNodeFs(path2, listener) {
     const opts = this.fsw.options;
     const directory = sysPath.dirname(path2);
-    const basename9 = sysPath.basename(path2);
+    const basename11 = sysPath.basename(path2);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename9);
+    parent.add(basename11);
     const absolutePath = sysPath.resolve(path2);
     const options = {
       persistent: opts.persistent
@@ -130148,7 +130192,7 @@ var NodeFsHandler = class {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options.interval = enableBin && isBinaryPath(basename9) ? opts.binaryInterval : opts.interval;
+      options.interval = enableBin && isBinaryPath(basename11) ? opts.binaryInterval : opts.interval;
       closer = setFsWatchFileListener(path2, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
@@ -130171,10 +130215,10 @@ var NodeFsHandler = class {
       return;
     }
     const dirname17 = sysPath.dirname(file2);
-    const basename9 = sysPath.basename(file2);
+    const basename11 = sysPath.basename(file2);
     const parent = this.fsw._getWatchedDir(dirname17);
     let prevStats = stats;
-    if (parent.has(basename9))
+    if (parent.has(basename11))
       return;
     const listener = async (path2, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
@@ -130199,9 +130243,9 @@ var NodeFsHandler = class {
             prevStats = newStats2;
           }
         } catch (error51) {
-          this.fsw._remove(dirname17, basename9);
+          this.fsw._remove(dirname17, basename11);
         }
-      } else if (parent.has(basename9)) {
+      } else if (parent.has(basename11)) {
         const at2 = newStats.atimeMs;
         const mt2 = newStats.mtimeMs;
         if (!at2 || at2 <= mt2 || mt2 !== prevStats.mtimeMs) {
@@ -133973,11 +134017,11 @@ async function search(query, options, scanner) {
 
 // src/server.ts
 var import_events3 = require("events");
-var import_fs23 = require("fs");
+var import_fs24 = require("fs");
 var import_promises14 = require("fs/promises");
 var import_http = require("http");
 var import_os10 = require("os");
-var import_path19 = require("path");
+var import_path21 = require("path");
 var import_readline4 = require("readline");
 
 // src/agent/agent-client.ts
@@ -137104,8 +137148,10 @@ function runSqliteMigrations(db, migrationsDir) {
 // src/providers.ts
 var CLAUDE_CODE_PROVIDER2 = "claude-code";
 var CODEX_CLI_PROVIDER2 = "codex-cli";
-function isProviderResumable(provider, availabilityResumable) {
-  if (provider === CODEX_CLI_PROVIDER2) return false;
+function isProviderName(value) {
+  return value === CLAUDE_CODE_PROVIDER2 || value === CODEX_CLI_PROVIDER2;
+}
+function isProviderResumable(_provider, availabilityResumable) {
   return availabilityResumable;
 }
 
@@ -138182,67 +138228,15 @@ function handleListProjects(url2, res) {
   res.end(JSON.stringify({ projects: page, total }));
 }
 
-// src/server.ts
-init_logger();
+// src/live-session-manager.ts
+var import_path18 = require("path");
 
-// src/pair-store.ts
+// src/codex-pty-runner.ts
+var import_headless = __toESM(require_xterm_headless(), 1);
 var import_crypto5 = require("crypto");
-var DEFAULT_TTL_SECONDS = 180;
-var SWEEP_INTERVAL_MS = 6e4;
-var PairTokenStore = class {
-  current = null;
-  ttlMs;
-  sweepTimer = null;
-  constructor(opts = {}) {
-    this.ttlMs = (opts.ttlSeconds ?? DEFAULT_TTL_SECONDS) * 1e3;
-    if (opts.autoSweep !== false) {
-      this.sweepTimer = setInterval(() => this.sweep(), SWEEP_INTERVAL_MS);
-      this.sweepTimer.unref?.();
-    }
-  }
-  mint() {
-    const token = `pt_${(0, import_crypto5.randomBytes)(16).toString("hex")}`;
-    const expiresAt = Date.now() + this.ttlMs;
-    this.current = { token, expiresAt, used: false };
-    return {
-      token,
-      expiresAt,
-      expiresInSeconds: Math.floor(this.ttlMs / 1e3)
-    };
-  }
-  consume(token) {
-    const record2 = this.current;
-    if (!record2 || record2.token !== token) return { ok: false, reason: "unknown" };
-    if (Date.now() > record2.expiresAt) {
-      this.current = null;
-      return { ok: false, reason: "expired" };
-    }
-    if (record2.used) return { ok: false, reason: "used" };
-    record2.used = true;
-    return { ok: true };
-  }
-  peek() {
-    return this.current;
-  }
-  clear() {
-    this.current = null;
-  }
-  sweep() {
-    if (this.current && Date.now() > this.current.expiresAt) {
-      this.current = null;
-    }
-  }
-  dispose() {
-    if (this.sweepTimer) clearInterval(this.sweepTimer);
-    this.sweepTimer = null;
-    this.current = null;
-  }
-};
-
-// src/process-discovery.ts
-var import_child_process2 = require("child_process");
-var import_os9 = require("os");
+var import_fs20 = require("fs");
 var import_path16 = require("path");
+init_logger();
 
 // src/platform.ts
 var import_child_process = require("child_process");
@@ -138308,151 +138302,523 @@ function resolveClaudeExe() {
   _claudeExe = "claude";
   return _claudeExe;
 }
-
-// src/process-discovery.ts
-async function discoverClaudeProcesses() {
-  if ((0, import_os9.platform)() === "win32") return discoverWindows();
-  return discoverUnix();
-}
-async function discoverUnix() {
-  const pids = await getPidsUnix();
-  const results = await Promise.all(
-    pids.map(async (pid) => {
-      try {
-        const [cwd, args, startedAt] = await Promise.all([
-          getProcessCwdUnix(pid),
-          getProcessArgsUnix(pid),
-          getProcessStartTimeUnix(pid)
-        ]);
-        const conversationId = extractResumeId(args);
-        return {
-          pid,
-          projectPath: cwd,
-          projectName: (0, import_path16.basename)(cwd),
-          branch: await readGitBranch2(cwd),
-          conversationId,
-          startedAt
-        };
-      } catch {
-        return null;
+var _codexExe;
+function resolveCodexExe() {
+  if (_codexExe !== void 0) return _codexExe;
+  if (isWindows2) {
+    try {
+      const found = (0, import_child_process.execFileSync)("where.exe", ["codex"], {
+        encoding: "utf-8",
+        windowsHide: true,
+        timeout: 3e3
+      }).trim().split("\n")[0].trim();
+      if (found) {
+        _codexExe = found;
+        return _codexExe;
       }
-    })
-  );
-  return results.filter((r) => r !== null);
-}
-async function discoverWindows() {
-  const pids = await getPidsWindows();
-  const results = await Promise.all(
-    pids.map(async (pid) => {
-      try {
-        const info = await getProcessInfoWindows(pid);
-        if (!info) return null;
-        return {
-          pid,
-          projectPath: info.cwd,
-          projectName: (0, import_path16.basename)(info.cwd),
-          branch: await readGitBranch2(info.cwd),
-          conversationId: extractResumeId(info.args),
-          startedAt: info.startedAt
-        };
-      } catch {
-        return null;
+    } catch {
+    }
+    const candidates = [
+      (0, import_path15.join)((0, import_os8.homedir)(), ".local", "bin", "codex.exe"),
+      (0, import_path15.join)(
+        process.env.LOCALAPPDATA ?? (0, import_path15.join)((0, import_os8.homedir)(), "AppData", "Local"),
+        "Microsoft",
+        "WindowsApps",
+        "codex.exe"
+      )
+    ];
+    for (const p2 of candidates) {
+      if ((0, import_fs19.existsSync)(p2)) {
+        _codexExe = p2;
+        return _codexExe;
       }
-    })
-  );
-  return results.filter((r) => r !== null);
-}
-function run(cmd, args, opts = {}) {
-  return new Promise((resolve6, reject) => {
-    (0, import_child_process2.execFile)(
-      cmd,
-      args,
-      { windowsHide: isWindows2, encoding: "utf-8", timeout: opts.timeout ?? 5e3, cwd: opts.cwd },
-      (err, stdout2) => {
-        if (err) reject(err);
-        else resolve6(stdout2);
+    }
+  } else {
+    try {
+      const found = (0, import_child_process.execFileSync)("/usr/bin/which", ["codex"], {
+        encoding: "utf-8",
+        timeout: 3e3
+      }).trim().split("\n")[0].trim();
+      if (found && (0, import_fs19.existsSync)(found)) {
+        _codexExe = found;
+        return _codexExe;
       }
-    );
-  });
-}
-async function getPidsUnix() {
-  try {
-    const output = await run("pgrep", ["-x", "claude"]);
-    return output.trim().split("\n").filter(Boolean).map((s3) => Number.parseInt(s3, 10));
-  } catch {
-    return [];
+    } catch {
+    }
+    const candidates = [
+      "/opt/homebrew/bin/codex",
+      "/usr/local/bin/codex",
+      (0, import_path15.join)((0, import_os8.homedir)(), ".local", "bin", "codex")
+    ];
+    for (const p2 of candidates) {
+      if ((0, import_fs19.existsSync)(p2)) {
+        _codexExe = p2;
+        return _codexExe;
+      }
+    }
   }
+  _codexExe = "codex";
+  return _codexExe;
 }
-async function getProcessCwdUnix(pid) {
-  const output = await run("lsof", ["-p", String(pid), "-a", "-d", "cwd", "-Fn"]);
-  const match2 = output.match(/n(.+)/);
-  return match2?.[1] ?? "";
-}
-async function getProcessArgsUnix(pid) {
-  return (await run("ps", ["-p", String(pid), "-o", "args="])).trim();
-}
-async function getProcessStartTimeUnix(pid) {
-  const raw2 = (await run("ps", ["-p", String(pid), "-o", "lstart="])).trim();
-  const d = new Date(raw2);
-  return Number.isNaN(d.getTime()) ? /* @__PURE__ */ new Date() : d;
-}
-async function getPidsWindows() {
-  try {
-    const output = await run("tasklist", ["/FI", "IMAGENAME eq claude.exe", "/FO", "CSV", "/NH"]);
-    return output.trim().split("\n").filter(Boolean).map((line) => {
-      const parts = line.split(",");
-      return Number.parseInt(parts[1]?.replace(/"/g, "") ?? "0", 10);
-    }).filter((pid) => pid > 0);
-  } catch {
-    return [];
-  }
+
+// src/codex-pty-runner.ts
+var OUTPUT_BUFFER_MAX = 65536;
+var PTY_COLS = 120;
+var PTY_ROWS = 40;
+var SCREEN_SCROLLBACK = 1e3;
+var CODEX_PROMPT_READY_TEXT = "Ready";
+var CODEX_TRUST_GATE_REGEX = /trust the contents/i;
+var SUBMIT_BYTES = "\r";
+var CODEX_SUBMIT_DELAY_MS = 16;
+function digestBytes(s3) {
+  const escaped = s3.replace(new RegExp(String.fromCharCode(27), "g"), "\\x1b").replace(/\r/g, "\\r").replace(/\n/g, "\\n").replace(/\t/g, "\\t");
+  if (escaped.length <= 200) return escaped;
+  return `${escaped.slice(0, 100)}\u2026[${escaped.length - 200}B omitted]\u2026${escaped.slice(-100)}`;
 }
-async function getProcessInfoWindows(pid) {
+var pty = null;
+async function loadPty() {
+  if (pty) return pty;
   try {
-    const output = await run("wmic", [
-      "process",
-      "where",
-      `ProcessId=${pid}`,
-      "get",
-      "CommandLine,CreationDate,ExecutablePath",
-      "/FORMAT:CSV"
-    ]);
-    const lines = output.trim().split(/\r?\n/).filter((l) => l.trim().length > 0);
-    if (lines.length < 2) return null;
-    const parts = lines[1].split(",");
-    const args = parts[1] ?? "";
-    const creationDate = parts[2] ?? "";
-    const year = creationDate.slice(0, 4);
-    const month = creationDate.slice(4, 6);
-    const day = creationDate.slice(6, 8);
-    const hour = creationDate.slice(8, 10);
-    const min = creationDate.slice(10, 12);
-    const sec = creationDate.slice(12, 14);
-    const startedAt = /* @__PURE__ */ new Date(`${year}-${month}-${day}T${hour}:${min}:${sec}`);
-    if (Number.isNaN(startedAt.getTime())) return null;
-    const exePath = parts[3] ?? "";
-    const cwd = exePath ? (0, import_path16.dirname)(exePath) : "";
-    return { cwd, args, startedAt };
-  } catch {
-    return null;
+    pty = await import("node-pty");
+    return pty;
+  } catch (err) {
+    throw new Error(
+      `node-pty is required for PTY management but failed to load. Ensure it is installed: npm install node-pty
+Original error: ${err}`
+    );
   }
 }
-function extractResumeId(args) {
-  const match2 = args.match(/--resume\s+(\S+)/);
-  return match2?.[1] ?? null;
+function createScreen() {
+  return new import_headless.Terminal({
+    cols: PTY_COLS,
+    rows: PTY_ROWS,
+    scrollback: SCREEN_SCROLLBACK,
+    allowProposedApi: true
+  });
 }
-async function readGitBranch2(dir) {
-  try {
-    return (await run("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: dir, timeout: 3e3 })).trim();
-  } catch {
-    return "";
+var CodexPtyRunner = class {
+  sessions = /* @__PURE__ */ new Map();
+  onOutput;
+  onStatusChange;
+  onReady;
+  // Accepted for shape-compatibility with PTYManagerOptions; Codex has no
+  // detected equivalent yet (Phase 0) — never invoked.
+  onPermissionChange;
+  onLiveQuestion;
+  onLiveQuestionGone;
+  log;
+  // Tracks sessions whose PTY has spawned but Codex hasn't yet reached its
+  // "Ready" status bar — i.e. onReady hasn't fired.
+  pendingReady = /* @__PURE__ */ new Set();
+  // Inputs received via sendInput() while the session was still pendingReady.
+  // Flushed in arrival order once Codex reaches Ready.
+  queuedInputs = /* @__PURE__ */ new Map();
+  // Per-session debounce so the directory-trust gate's \r is only written once.
+  trustGateAnswered = /* @__PURE__ */ new Set();
+  // In-flight start()/startFresh() calls keyed by sessionId. A second
+  // concurrent resume for the same session (double-tap, client retry) awaits
+  // the first call's promise instead of spawning a duplicate PTY (CRITICAL #3).
+  startPromises = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.onOutput = options.onOutput;
+    this.onStatusChange = options.onStatusChange;
+    this.onReady = options.onReady;
+    this.onPermissionChange = options.onPermissionChange;
+    this.onLiveQuestion = options.onLiveQuestion;
+    this.onLiveQuestionGone = options.onLiveQuestionGone;
+    this.log = options.logger ?? getLogger("codex-pty");
+  }
+  // Resume an existing Codex session. sessionId is the Codex-persisted
+  // session_meta.payload.id (Phase 0, Section 8) — Codex has no fresh-session
+  // equivalent of --session-id, so start() always means "resume".
+  async start(sessionId, options) {
+    const existing = this.sessions.get(sessionId);
+    if (existing) return toPublicSession(existing);
+    const inFlight = this.startPromises.get(sessionId);
+    if (inFlight) return inFlight;
+    const promise2 = this.doStart(sessionId, options).finally(() => {
+      this.startPromises.delete(sessionId);
+    });
+    this.startPromises.set(sessionId, promise2);
+    return promise2;
+  }
+  async doStart(sessionId, options) {
+    const nodePty = await loadPty();
+    const projectName = options.projectName ?? (0, import_path16.basename)(options.projectPath);
+    const proc = nodePty.spawn(
+      resolveCodexExe(),
+      ["resume", sessionId, "--cd", options.projectPath, "--no-alt-screen"],
+      {
+        name: "xterm-256color",
+        cols: PTY_COLS,
+        rows: PTY_ROWS,
+        cwd: options.projectPath,
+        env: process.env
+      }
+    );
+    const session = {
+      id: sessionId,
+      provider: CODEX_CLI_PROVIDER2,
+      projectPath: options.projectPath,
+      projectName,
+      branch: options.branch ?? "",
+      status: "running",
+      startedAt: /* @__PURE__ */ new Date(),
+      completedAt: null,
+      promptCount: 0,
+      lastOutput: "",
+      process: proc,
+      outputBuffer: Buffer.alloc(0),
+      screen: createScreen()
+    };
+    this.sessions.set(sessionId, session);
+    this.pendingReady.add(sessionId);
+    proc.onData((data) => {
+      this.handleOutput(sessionId, data);
+    });
+    proc.onExit(({ exitCode }) => {
+      this.pendingReady.delete(sessionId);
+      this.handleExit(sessionId, exitCode);
+    });
+    return toPublicSession(session);
+  }
+  // Start a brand-new Codex session. Codex has no --session-id equivalent for
+  // a fresh launch — it assigns its own id, discovered later (Task 3's
+  // binding logic). This runner generates a local placeholder id for the
+  // ManagedSession handle only.
+  async startFresh(options) {
+    const nodePty = await loadPty();
+    const sessionId = (0, import_crypto5.randomUUID)();
+    const projectName = options.projectName ?? (0, import_path16.basename)(options.projectPath);
+    const args = ["--cd", options.projectPath, "--no-alt-screen"];
+    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
+    });
+    const session = {
+      id: sessionId,
+      provider: CODEX_CLI_PROVIDER2,
+      projectPath: options.projectPath,
+      projectName,
+      branch: "",
+      status: "running",
+      startedAt: /* @__PURE__ */ new Date(),
+      completedAt: null,
+      promptCount: 0,
+      lastOutput: "",
+      process: proc,
+      outputBuffer: Buffer.alloc(0),
+      screen: createScreen()
+    };
+    this.sessions.set(sessionId, session);
+    this.pendingReady.add(sessionId);
+    proc.onData((data) => {
+      this.handleOutput(sessionId, data);
+    });
+    proc.onExit(({ exitCode }) => {
+      this.pendingReady.delete(sessionId);
+      this.handleExit(sessionId, exitCode);
+    });
+    return toPublicSession(session);
+  }
+  // Write raw key bytes directly to the PTY, same as PTYManager.sendKeys.
+  sendKeys(sessionId, keys) {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Session not found: ${sessionId}`);
+    if (session.status === "idle") {
+      throw new Error(`Session is idle (no active PTY): ${sessionId}`);
+    }
+    if (session.status === "waiting_input") {
+      session.status = "running";
+      this.onStatusChange?.(toPublicSession(session));
+    }
+    this.log.info(
+      `[codex.keys.write] ${sessionId.slice(0, 8)} bytes=${keys.length} digest=${digestBytes(keys)}`,
+      { event: "codex.keys_write", sessionId, byteLen: keys.length }
+    );
+    session.process.write(keys);
+    session.lastActivityAt = /* @__PURE__ */ new Date();
+  }
+  sendInput(sessionId, input) {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Session not found: ${sessionId}`);
+    if (session.status === "idle") {
+      throw new Error(`Session is idle (no active PTY): ${sessionId}`);
+    }
+    if (this.pendingReady.has(sessionId)) {
+      const queue = this.queuedInputs.get(sessionId) ?? [];
+      queue.push(input);
+      this.queuedInputs.set(sessionId, queue);
+      session.lastActivityAt = /* @__PURE__ */ new Date();
+      session.promptCount++;
+      this.log.warn(
+        `[codex.input.queued] ${sessionId.slice(0, 8)} promptCount=${session.promptCount} queueLen=${queue.length}`,
+        {
+          event: "codex.input_queued",
+          sessionId,
+          promptCount: session.promptCount,
+          queueLen: queue.length,
+          inputLen: input.length
+        }
+      );
+      return session.promptCount;
+    }
+    if (session.status === "waiting_input") {
+      session.status = "running";
+      this.onStatusChange?.(toPublicSession(session));
+    }
+    this.writeSubmit(sessionId, session, input, "direct", session.promptCount + 1);
+    session.lastActivityAt = /* @__PURE__ */ new Date();
+    session.promptCount++;
+    return session.promptCount;
   }
+  // Write the input as plain bytes (no bracketed-paste wrap — Phase 0
+  // confirmed Codex accepts plain keystrokes), then submit \r after a short
+  // delay so Codex's TUI gets an event-loop tick to process the input first.
+  writeSubmit(sessionId, session, input, path2, promptCount) {
+    this.log.info(
+      `[codex.input.write] ${sessionId.slice(0, 8)} promptCount=${promptCount} bytes=${input.length} digest=${digestBytes(input)}`,
+      {
+        event: "codex.input_write",
+        sessionId,
+        promptCount,
+        byteLen: input.length,
+        digest: digestBytes(input),
+        path: path2,
+        phase: "input"
+      }
+    );
+    session.process.write(input);
+    setTimeout(() => {
+      const current = this.sessions.get(sessionId);
+      if (!current || current !== session) return;
+      this.log.info(
+        `[codex.input.submit] ${sessionId.slice(0, 8)} promptCount=${promptCount} digest=\\r`,
+        {
+          event: "codex.input_write",
+          sessionId,
+          promptCount,
+          byteLen: SUBMIT_BYTES.length,
+          digest: "\\r",
+          path: path2,
+          phase: "submit"
+        }
+      );
+      current.process.write(SUBMIT_BYTES);
+    }, CODEX_SUBMIT_DELAY_MS);
+  }
+  // Drain any inputs sent while the session was still pendingReady, writing
+  // them in arrival order now that Codex is Ready.
+  flushQueuedInputs(sessionId) {
+    const queue = this.queuedInputs.get(sessionId);
+    if (!queue || queue.length === 0) return;
+    this.queuedInputs.delete(sessionId);
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    this.log.info(
+      `[codex.flush] ${sessionId.slice(0, 8)} flushing ${queue.length} queued input(s)`,
+      {
+        event: "codex.flush_queued",
+        sessionId,
+        queueLen: queue.length
+      }
+    );
+    queue.forEach((input, i) => {
+      const writeAt = i * CODEX_SUBMIT_DELAY_MS * 2;
+      if (writeAt === 0) {
+        this.writeSubmit(sessionId, session, input, "flush", session.promptCount);
+      } else {
+        setTimeout(() => {
+          const current = this.sessions.get(sessionId);
+          if (!current || current !== session) return;
+          this.writeSubmit(sessionId, session, input, "flush", session.promptCount);
+        }, writeAt);
+      }
+    });
+  }
+  // SIGINT produces a clean exitCode=0 exit (Phase 0 — confirmed).
+  cancel(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Session not found: ${sessionId}`);
+    session.process.kill("SIGINT");
+  }
+  killPid(pid) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+    }
+  }
+  // Kill the PTY and mark the session idle. Mirrors PTYManager.putOnHold.
+  putOnHold(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    this.pendingReady.delete(sessionId);
+    this.queuedInputs.delete(sessionId);
+    this.trustGateAnswered.delete(sessionId);
+    try {
+      session.process.kill("SIGINT");
+    } catch {
+    }
+    session.status = "idle";
+    session.completedAt = /* @__PURE__ */ new Date();
+    session.screen.dispose();
+    this.sessions.delete(sessionId);
+    this.onStatusChange?.(toPublicSession(session));
+  }
+  getOutput(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Session not found: ${sessionId}`);
+    return session.outputBuffer.toString("utf-8");
+  }
+  // Render the last `maxLines` rows of the session's screen in true on-screen
+  // order — same flush-then-read technique as PTYManager.getOutputLines.
+  async getOutputLines(sessionId, maxLines) {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Session not found: ${sessionId}`);
+    await new Promise((resolve6) => session.screen.write("", () => resolve6()));
+    const buf = session.screen.buffer.active;
+    const lines = [];
+    for (let y2 = 0; y2 < buf.length; y2++) {
+      lines.push(buf.getLine(y2)?.translateToString(true) ?? "");
+    }
+    while (lines.length > 0 && lines[lines.length - 1] === "") {
+      lines.pop();
+    }
+    return lines.slice(-maxLines);
+  }
+  getSession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    return session ? toPublicSession(session) : null;
+  }
+  hasSession(sessionId) {
+    return this.sessions.has(sessionId);
+  }
+  listSessions() {
+    return Array.from(this.sessions.values()).map(toPublicSession);
+  }
+  dispose() {
+    for (const session of this.sessions.values()) {
+      try {
+        session.process.kill();
+      } catch {
+      }
+      session.screen.dispose();
+    }
+    this.sessions.clear();
+    this.pendingReady.clear();
+    this.queuedInputs.clear();
+    this.trustGateAnswered.clear();
+  }
+  handleOutput(sessionId, data) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    const chunk = Buffer.from(data, "utf-8");
+    session.outputBuffer = Buffer.concat([session.outputBuffer, chunk]);
+    if (session.outputBuffer.length > OUTPUT_BUFFER_MAX) {
+      session.outputBuffer = session.outputBuffer.subarray(
+        session.outputBuffer.length - OUTPUT_BUFFER_MAX
+      );
+    }
+    session.screen.write(data);
+    session.lastOutput = stripAnsi(data);
+    this.onOutput?.(sessionId, data);
+    this.detectReady(sessionId, session).catch((err) => {
+      this.log.warn("[codex.ready_detect] failed", {
+        event: "codex.ready_detect_failed",
+        sessionId,
+        err
+      });
+    });
+  }
+  // Renders the session's headless screen and checks for the directory-trust
+  // gate (answered once, debounced) and the "Ready" status-bar text. Only
+  // transitions to waiting_input / fires onReady when the rendered status
+  // line literally contains "Ready" — `›` alone (visible during "Starting")
+  // is NOT a valid readiness signal (Phase 0).
+  async detectReady(sessionId, session) {
+    if (session.status !== "running" || !this.pendingReady.has(sessionId)) return;
+    const lines = await this.getOutputLines(sessionId, PTY_ROWS);
+    const screenText = lines.join("\n");
+    if (CODEX_TRUST_GATE_REGEX.test(screenText)) {
+      if (!this.trustGateAnswered.has(sessionId)) {
+        this.trustGateAnswered.add(sessionId);
+        this.log.info(`[codex.trust_gate] ${sessionId.slice(0, 8)} auto-answering`, {
+          event: "codex.trust_gate",
+          sessionId
+        });
+        session.process.write("\r");
+      }
+      return;
+    }
+    const lastNonBlank2 = [...lines].reverse().find((l) => l.trim() !== "") ?? "";
+    if (!lastNonBlank2.includes(CODEX_PROMPT_READY_TEXT)) return;
+    this.markReady(sessionId, session);
+  }
+  markReady(sessionId, session) {
+    session.lastActivityAt = /* @__PURE__ */ new Date();
+    session.status = "waiting_input";
+    this.log.info(`[codex.ready] ${sessionId.slice(0, 8)}`, {
+      event: "codex.ready",
+      sessionId
+    });
+    this.onStatusChange?.(toPublicSession(session));
+    if (this.pendingReady.has(sessionId)) {
+      this.pendingReady.delete(sessionId);
+      this.flushQueuedInputs(sessionId);
+      this.onReady?.(toPublicSession(session));
+    }
+  }
+  handleExit(sessionId, exitCode) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    session.completedAt = /* @__PURE__ */ new Date();
+    session.status = "idle";
+    const elapsedMs = session.completedAt.getTime() - session.startedAt.getTime();
+    if (exitCode !== 0 && elapsedMs < 2e3 && session.lastOutput === "") {
+      if (!(0, import_fs20.existsSync)(session.projectPath)) {
+        session.failureReason = `Project directory not found: ${session.projectPath}`;
+      } else {
+        session.failureReason = `Codex process exited immediately (code ${exitCode}).`;
+      }
+    }
+    this.onStatusChange?.(toPublicSession(session));
+    session.screen.dispose();
+    this.sessions.delete(sessionId);
+    this.queuedInputs.delete(sessionId);
+    this.trustGateAnswered.delete(sessionId);
+  }
+};
+function toPublicSession(s3) {
+  return {
+    id: s3.id,
+    provider: s3.provider ?? CODEX_CLI_PROVIDER2,
+    projectPath: s3.projectPath,
+    projectName: s3.projectName,
+    branch: s3.branch,
+    status: s3.status,
+    startedAt: s3.startedAt,
+    completedAt: s3.completedAt,
+    promptCount: s3.promptCount,
+    lastOutput: s3.lastOutput,
+    ...s3.failureReason != null && { failureReason: s3.failureReason },
+    ...s3.lastActivityAt != null && { lastActivityAt: s3.lastActivityAt },
+    ...s3.filePath != null && { filePath: s3.filePath }
+  };
+}
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").replace(/\x1b\][^\x07]*\x07/g, "");
 }
 
 // src/pty-manager.ts
-var import_headless = __toESM(require_xterm_headless(), 1);
+var import_headless2 = __toESM(require_xterm_headless(), 1);
 var import_crypto6 = require("crypto");
-var import_fs20 = require("fs");
+var import_fs21 = require("fs");
 var import_path17 = require("path");
 init_logger();
 
@@ -138613,28 +138979,28 @@ function detectShellPrompt(lines) {
 }
 
 // src/pty-manager.ts
-var OUTPUT_BUFFER_MAX = 65536;
-var PTY_COLS = 120;
-var PTY_ROWS = 40;
-var SCREEN_SCROLLBACK = 1e3;
+var OUTPUT_BUFFER_MAX2 = 65536;
+var PTY_COLS2 = 120;
+var PTY_ROWS2 = 40;
+var SCREEN_SCROLLBACK2 = 1e3;
 var CLAUDE_PROMPT_MARKERS = ["\u256D", "\u276F"];
 var PROMPT_MARKER_FALLBACK_MS = 1e4;
 function buildPasteBytes(input) {
   return `\x1B[200~${input}\x1B[201~`;
 }
-var SUBMIT_BYTES = "\r";
+var SUBMIT_BYTES2 = "\r";
 var SUBMIT_DELAY_MS = 16;
-function digestBytes(s3) {
+function digestBytes2(s3) {
   const escaped = s3.replace(new RegExp(String.fromCharCode(27), "g"), "\\x1b").replace(/\r/g, "\\r").replace(/\n/g, "\\n").replace(/\t/g, "\\t");
   if (escaped.length <= 200) return escaped;
   return `${escaped.slice(0, 100)}\u2026[${escaped.length - 200}B omitted]\u2026${escaped.slice(-100)}`;
 }
-var pty = null;
-async function loadPty() {
-  if (pty) return pty;
+var pty2 = null;
+async function loadPty2() {
+  if (pty2) return pty2;
   try {
-    pty = await import("node-pty");
-    return pty;
+    pty2 = await import("node-pty");
+    return pty2;
   } catch (err) {
     throw new Error(
       `node-pty is required for PTY management but failed to load. Ensure it is installed: npm install node-pty
@@ -138642,11 +139008,11 @@ Original error: ${err}`
     );
   }
 }
-function createScreen() {
-  return new import_headless.Terminal({
-    cols: PTY_COLS,
-    rows: PTY_ROWS,
-    scrollback: SCREEN_SCROLLBACK,
+function createScreen2() {
+  return new import_headless2.Terminal({
+    cols: PTY_COLS2,
+    rows: PTY_ROWS2,
+    scrollback: SCREEN_SCROLLBACK2,
     allowProposedApi: true
   });
 }
@@ -138655,6 +139021,11 @@ function buildSpawnEnv() {
   if (env.CLAUDE_API_KEY) {
     env.ANTHROPIC_API_KEY = env.CLAUDE_API_KEY;
   }
+  for (const key of Object.keys(env)) {
+    if (key === "CLAUDECODE" || key.startsWith("CLAUDE_CODE_")) {
+      delete env[key];
+    }
+  }
   return env;
 }
 var PTYManager = class {
@@ -138695,6 +139066,10 @@ var PTYManager = class {
   // to a given input or fell silent. Reset on dispose().
   chunkIndex = /* @__PURE__ */ new Map();
   lastChunkAt = /* @__PURE__ */ new Map();
+  // In-flight start()/startFresh() calls keyed by sessionId. A second
+  // concurrent resume for the same session (double-tap, client retry) awaits
+  // the first call's promise instead of spawning a duplicate PTY (CRITICAL #3).
+  startPromises = /* @__PURE__ */ new Map();
   constructor(options = {}) {
     this.onOutput = options.onOutput;
     this.onStatusChange = options.onStatusChange;
@@ -138717,7 +139092,18 @@ var PTYManager = class {
   // custom-API-key — are cleared by the seeded ~/.claude.json in
   // docker/entrypoint.sh.) startFresh() uses the same flag for the same reason.
   async start(sessionId, options) {
-    const nodePty = await loadPty();
+    const existing = this.sessions.get(sessionId);
+    if (existing) return toPublicSession2(existing);
+    const inFlight = this.startPromises.get(sessionId);
+    if (inFlight) return inFlight;
+    const promise2 = this.doStart(sessionId, options).finally(() => {
+      this.startPromises.delete(sessionId);
+    });
+    this.startPromises.set(sessionId, promise2);
+    return promise2;
+  }
+  async doStart(sessionId, options) {
+    const nodePty = await loadPty2();
     const projectName = options.projectName ?? (0, import_path17.basename)(options.projectPath);
     const proc = nodePty.spawn(
       resolveClaudeExe(),
@@ -138739,6 +139125,7 @@ var PTYManager = class {
     );
     const session = {
       id: sessionId,
+      provider: CLAUDE_CODE_PROVIDER2,
       projectPath: options.projectPath,
       projectName,
       branch: options.branch ?? "",
@@ -138749,7 +139136,7 @@ var PTYManager = class {
       lastOutput: "",
       process: proc,
       outputBuffer: Buffer.alloc(0),
-      screen: createScreen()
+      screen: createScreen2()
     };
     this.sessions.set(sessionId, session);
     this.pendingReady.add(sessionId);
@@ -138760,13 +139147,13 @@ var PTYManager = class {
       this.pendingReady.delete(sessionId);
       this.handleExit(sessionId, exitCode);
     });
-    return toPublicSession(session);
+    return toPublicSession2(session);
   }
   // Start a brand-new Claude session. A stable UUID is generated here and passed
   // to Claude via --session-id so the JSONL filename matches from the start.
   // onReady fires once Claude reaches its first prompt (waiting_input).
   async startFresh(options) {
-    const nodePty = await loadPty();
+    const nodePty = await loadPty2();
     const sessionId = (0, import_crypto6.randomUUID)();
     const projectName = options.projectName ?? (0, import_path17.basename)(options.projectPath);
     const args = [
@@ -138789,6 +139176,7 @@ var PTYManager = class {
     });
     const session = {
       id: sessionId,
+      provider: CLAUDE_CODE_PROVIDER2,
       projectPath: options.projectPath,
       projectName,
       branch: "",
@@ -138799,7 +139187,7 @@ var PTYManager = class {
       lastOutput: "",
       process: proc,
       outputBuffer: Buffer.alloc(0),
-      screen: createScreen()
+      screen: createScreen2()
     };
     this.sessions.set(sessionId, session);
     this.pendingReady.add(sessionId);
@@ -138810,7 +139198,7 @@ var PTYManager = class {
       this.pendingReady.delete(sessionId);
       this.handleExit(sessionId, exitCode);
     });
-    return toPublicSession(session);
+    return toPublicSession2(session);
   }
   // Write raw key bytes directly to the PTY without bracketed-paste wrapping.
   // Use for control sequences (arrow keys, Enter) that must not be quoted.
@@ -138822,10 +139210,10 @@ var PTYManager = class {
     }
     if (session.status === "waiting_input") {
       session.status = "running";
-      this.onStatusChange?.(toPublicSession(session));
+      this.onStatusChange?.(toPublicSession2(session));
     }
     this.log.info(
-      `[pty.keys.write] ${sessionId.slice(0, 8)} bytes=${keys.length} digest=${digestBytes(keys)}`,
+      `[pty.keys.write] ${sessionId.slice(0, 8)} bytes=${keys.length} digest=${digestBytes2(keys)}`,
       { event: "pty.keys_write", sessionId, byteLen: keys.length }
     );
     session.process.write(keys);
@@ -138857,7 +139245,7 @@ var PTYManager = class {
     }
     if (session.status === "waiting_input") {
       session.status = "running";
-      this.onStatusChange?.(toPublicSession(session));
+      this.onStatusChange?.(toPublicSession2(session));
     }
     this.writeSubmit(sessionId, session, input, "direct", session.promptCount + 1);
     session.lastActivityAt = /* @__PURE__ */ new Date();
@@ -138870,13 +139258,13 @@ var PTYManager = class {
   writeSubmit(sessionId, session, input, path2, promptCount) {
     const pasteBytes = buildPasteBytes(input);
     this.log.info(
-      `[pty.input.write] ${sessionId.slice(0, 8)} promptCount=${promptCount} bytes=${pasteBytes.length} digest=${digestBytes(pasteBytes)}`,
+      `[pty.input.write] ${sessionId.slice(0, 8)} promptCount=${promptCount} bytes=${pasteBytes.length} digest=${digestBytes2(pasteBytes)}`,
       {
         event: "pty.input_write",
         sessionId,
         promptCount,
         byteLen: pasteBytes.length,
-        digest: digestBytes(pasteBytes),
+        digest: digestBytes2(pasteBytes),
         path: path2,
         phase: "paste"
       }
@@ -138891,13 +139279,13 @@ var PTYManager = class {
           event: "pty.input_write",
           sessionId,
           promptCount,
-          byteLen: SUBMIT_BYTES.length,
+          byteLen: SUBMIT_BYTES2.length,
           digest: "\\r",
           path: path2,
           phase: "submit"
         }
       );
-      current.process.write(SUBMIT_BYTES);
+      current.process.write(SUBMIT_BYTES2);
     }, SUBMIT_DELAY_MS);
   }
   // Drain any inputs that were sent while the session was still pendingReady,
@@ -138955,7 +139343,7 @@ var PTYManager = class {
     session.completedAt = /* @__PURE__ */ new Date();
     session.screen.dispose();
     this.sessions.delete(sessionId);
-    this.onStatusChange?.(toPublicSession(session));
+    this.onStatusChange?.(toPublicSession2(session));
   }
   getOutput(sessionId) {
     const session = this.sessions.get(sessionId);
@@ -138986,13 +139374,13 @@ var PTYManager = class {
   }
   getSession(sessionId) {
     const session = this.sessions.get(sessionId);
-    return session ? toPublicSession(session) : null;
+    return session ? toPublicSession2(session) : null;
   }
   hasSession(sessionId) {
     return this.sessions.has(sessionId);
   }
   listSessions() {
-    return Array.from(this.sessions.values()).map(toPublicSession);
+    return Array.from(this.sessions.values()).map(toPublicSession2);
   }
   dispose() {
     for (const session of this.sessions.values()) {
@@ -139024,7 +139412,7 @@ var PTYManager = class {
     this.lastChunkAt.set(sessionId, now);
     const gapMs = last == null ? 0 : now - last;
     this.log.info(
-      `[pty.chunk] ${sessionId.slice(0, 8)} #${idx} +${chunk.length}B gap=${gapMs}ms status=${session.status} digest=${digestBytes(data)}`,
+      `[pty.chunk] ${sessionId.slice(0, 8)} #${idx} +${chunk.length}B gap=${gapMs}ms status=${session.status} digest=${digestBytes2(data)}`,
       {
         event: "pty.chunk",
         sessionId,
@@ -139033,17 +139421,17 @@ var PTYManager = class {
         gapMs,
         status: session.status,
         pendingReady: this.pendingReady.has(sessionId),
-        digest: digestBytes(data)
+        digest: digestBytes2(data)
       }
     );
     session.outputBuffer = Buffer.concat([session.outputBuffer, chunk]);
-    if (session.outputBuffer.length > OUTPUT_BUFFER_MAX) {
+    if (session.outputBuffer.length > OUTPUT_BUFFER_MAX2) {
       session.outputBuffer = session.outputBuffer.subarray(
-        session.outputBuffer.length - OUTPUT_BUFFER_MAX
+        session.outputBuffer.length - OUTPUT_BUFFER_MAX2
       );
     }
     session.screen.write(data);
-    const stripped = stripAnsi(data);
+    const stripped = stripAnsi2(data);
     session.lastOutput = stripped;
     const matchedMarker = CLAUDE_PROMPT_MARKERS.find((m2) => stripped.includes(m2));
     if (session.status === "running" && matchedMarker) {
@@ -139146,11 +139534,11 @@ var PTYManager = class {
       reason,
       elapsedMs
     });
-    this.onStatusChange?.(toPublicSession(session));
+    this.onStatusChange?.(toPublicSession2(session));
     if (this.pendingReady.has(sessionId)) {
       this.pendingReady.delete(sessionId);
       this.flushQueuedInputs(sessionId);
-      this.onReady?.(toPublicSession(session));
+      this.onReady?.(toPublicSession2(session));
     }
   }
   handleExit(sessionId, exitCode) {
@@ -139160,13 +139548,13 @@ var PTYManager = class {
     session.status = "idle";
     const elapsedMs = session.completedAt.getTime() - session.startedAt.getTime();
     if (exitCode !== 0 && elapsedMs < 2e3 && session.lastOutput === "") {
-      if (!(0, import_fs20.existsSync)(session.projectPath)) {
+      if (!(0, import_fs21.existsSync)(session.projectPath)) {
         session.failureReason = `Project directory not found: ${session.projectPath}`;
       } else {
         session.failureReason = `Process exited immediately (code ${exitCode}). Check that the Claude binary is installed and accessible.`;
       }
     }
-    this.onStatusChange?.(toPublicSession(session));
+    this.onStatusChange?.(toPublicSession2(session));
     session.screen.dispose();
     this.sessions.delete(sessionId);
     this.queuedInputs.delete(sessionId);
@@ -139176,9 +139564,10 @@ var PTYManager = class {
     this.shellPromptOpen.delete(sessionId);
   }
 };
-function toPublicSession(s3) {
+function toPublicSession2(s3) {
   return {
     id: s3.id,
+    provider: s3.provider ?? CLAUDE_CODE_PROVIDER2,
     projectPath: s3.projectPath,
     projectName: s3.projectName,
     branch: s3.branch,
@@ -139192,10 +139581,306 @@ function toPublicSession(s3) {
     ...s3.filePath != null && { filePath: s3.filePath }
   };
 }
-function stripAnsi(str) {
+function stripAnsi2(str) {
   return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").replace(/\x1b\][^\x07]*\x07/g, "");
 }
 
+// src/live-session-manager.ts
+var LiveSessionManager = class {
+  runners;
+  constructor(options = {}) {
+    this.runners = /* @__PURE__ */ new Map([
+      [CLAUDE_CODE_PROVIDER2, new PTYManager(options)],
+      [CODEX_CLI_PROVIDER2, new CodexPtyRunner(options)]
+    ]);
+  }
+  async start(sessionId, options) {
+    const provider = options.provider ?? CLAUDE_CODE_PROVIDER2;
+    const runner = this.assertSupportedProvider(provider, options.projectPath);
+    return runner.start(sessionId, options);
+  }
+  async startFresh(options) {
+    const provider = options.provider ?? CLAUDE_CODE_PROVIDER2;
+    const runner = this.assertSupportedProvider(provider, options.projectPath);
+    return runner.startFresh(options);
+  }
+  sendInput(sessionId, input) {
+    return this.runnerFor(sessionId).sendInput(sessionId, input);
+  }
+  sendKeys(sessionId, keys) {
+    this.runnerFor(sessionId).sendKeys(sessionId, keys);
+  }
+  cancel(sessionId) {
+    this.runnerFor(sessionId).cancel(sessionId);
+  }
+  killPid(pid) {
+    for (const runner of this.runners.values()) {
+      runner.killPid(pid);
+    }
+  }
+  // putOnHold tolerates an unknown sessionId (PTYManager.putOnHold is a no-op
+  // when the session isn't in its map), so — unlike the other session-keyed
+  // methods — route to the owning runner when found, otherwise broadcast to
+  // 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()) {
+      if (runner.hasSession(sessionId) || runner.getSession(sessionId)) {
+        runner.putOnHold(sessionId);
+        return;
+      }
+    }
+    for (const runner of this.runners.values()) {
+      runner.putOnHold(sessionId);
+    }
+  }
+  getOutput(sessionId) {
+    return this.runnerFor(sessionId).getOutput(sessionId);
+  }
+  getOutputLines(sessionId, maxLines) {
+    return this.runnerFor(sessionId).getOutputLines(sessionId, maxLines);
+  }
+  getSession(sessionId) {
+    for (const runner of this.runners.values()) {
+      const session = runner.getSession(sessionId);
+      if (session) return session;
+    }
+    return null;
+  }
+  hasSession(sessionId) {
+    for (const runner of this.runners.values()) {
+      if (runner.hasSession(sessionId)) return true;
+    }
+    return false;
+  }
+  listSessions() {
+    return Array.from(this.runners.values()).flatMap((runner) => runner.listSessions());
+  }
+  dispose() {
+    for (const runner of this.runners.values()) {
+      runner.dispose();
+    }
+  }
+  // Look up which runner owns a session. Only one runner exists today, so
+  // 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()) {
+      if (runner.hasSession(sessionId) || runner.getSession(sessionId)) return runner;
+    }
+    throw new Error(`Session not found: ${sessionId}`);
+  }
+  assertSupportedProvider(provider, projectPath) {
+    const runner = this.runners.get(provider);
+    if (runner) return runner;
+    const err = new Error(
+      `Live ${provider} sessions are not implemented yet for ${(0, import_path18.basename)(projectPath)}`
+    );
+    err.statusCode = 501;
+    throw err;
+  }
+};
+
+// src/server.ts
+init_logger();
+
+// src/pair-store.ts
+var import_crypto7 = require("crypto");
+var DEFAULT_TTL_SECONDS = 180;
+var SWEEP_INTERVAL_MS = 6e4;
+var PairTokenStore = class {
+  current = null;
+  ttlMs;
+  sweepTimer = null;
+  constructor(opts = {}) {
+    this.ttlMs = (opts.ttlSeconds ?? DEFAULT_TTL_SECONDS) * 1e3;
+    if (opts.autoSweep !== false) {
+      this.sweepTimer = setInterval(() => this.sweep(), SWEEP_INTERVAL_MS);
+      this.sweepTimer.unref?.();
+    }
+  }
+  mint() {
+    const token = `pt_${(0, import_crypto7.randomBytes)(16).toString("hex")}`;
+    const expiresAt = Date.now() + this.ttlMs;
+    this.current = { token, expiresAt, used: false };
+    return {
+      token,
+      expiresAt,
+      expiresInSeconds: Math.floor(this.ttlMs / 1e3)
+    };
+  }
+  consume(token) {
+    const record2 = this.current;
+    if (!record2 || record2.token !== token) return { ok: false, reason: "unknown" };
+    if (Date.now() > record2.expiresAt) {
+      this.current = null;
+      return { ok: false, reason: "expired" };
+    }
+    if (record2.used) return { ok: false, reason: "used" };
+    record2.used = true;
+    return { ok: true };
+  }
+  peek() {
+    return this.current;
+  }
+  clear() {
+    this.current = null;
+  }
+  sweep() {
+    if (this.current && Date.now() > this.current.expiresAt) {
+      this.current = null;
+    }
+  }
+  dispose() {
+    if (this.sweepTimer) clearInterval(this.sweepTimer);
+    this.sweepTimer = null;
+    this.current = null;
+  }
+};
+
+// src/process-discovery.ts
+var import_child_process2 = require("child_process");
+var import_os9 = require("os");
+var import_path19 = require("path");
+async function discoverClaudeProcesses() {
+  if ((0, import_os9.platform)() === "win32") return discoverWindows();
+  return discoverUnix();
+}
+async function discoverUnix() {
+  const pids = await getPidsUnix();
+  const results = await Promise.all(
+    pids.map(async (pid) => {
+      try {
+        const [cwd, args, startedAt] = await Promise.all([
+          getProcessCwdUnix(pid),
+          getProcessArgsUnix(pid),
+          getProcessStartTimeUnix(pid)
+        ]);
+        const conversationId = extractResumeId(args);
+        return {
+          pid,
+          projectPath: cwd,
+          projectName: (0, import_path19.basename)(cwd),
+          branch: await readGitBranch2(cwd),
+          conversationId,
+          startedAt
+        };
+      } catch {
+        return null;
+      }
+    })
+  );
+  return results.filter((r) => r !== null);
+}
+async function discoverWindows() {
+  const pids = await getPidsWindows();
+  const results = await Promise.all(
+    pids.map(async (pid) => {
+      try {
+        const info = await getProcessInfoWindows(pid);
+        if (!info) return null;
+        return {
+          pid,
+          projectPath: info.cwd,
+          projectName: (0, import_path19.basename)(info.cwd),
+          branch: await readGitBranch2(info.cwd),
+          conversationId: extractResumeId(info.args),
+          startedAt: info.startedAt
+        };
+      } catch {
+        return null;
+      }
+    })
+  );
+  return results.filter((r) => r !== null);
+}
+function run(cmd, args, opts = {}) {
+  return new Promise((resolve6, reject) => {
+    (0, import_child_process2.execFile)(
+      cmd,
+      args,
+      { windowsHide: isWindows2, encoding: "utf-8", timeout: opts.timeout ?? 5e3, cwd: opts.cwd },
+      (err, stdout2) => {
+        if (err) reject(err);
+        else resolve6(stdout2);
+      }
+    );
+  });
+}
+async function getPidsUnix() {
+  try {
+    const output = await run("pgrep", ["-x", "claude"]);
+    return output.trim().split("\n").filter(Boolean).map((s3) => Number.parseInt(s3, 10));
+  } catch {
+    return [];
+  }
+}
+async function getProcessCwdUnix(pid) {
+  const output = await run("lsof", ["-p", String(pid), "-a", "-d", "cwd", "-Fn"]);
+  const match2 = output.match(/n(.+)/);
+  return match2?.[1] ?? "";
+}
+async function getProcessArgsUnix(pid) {
+  return (await run("ps", ["-p", String(pid), "-o", "args="])).trim();
+}
+async function getProcessStartTimeUnix(pid) {
+  const raw2 = (await run("ps", ["-p", String(pid), "-o", "lstart="])).trim();
+  const d = new Date(raw2);
+  return Number.isNaN(d.getTime()) ? /* @__PURE__ */ new Date() : d;
+}
+async function getPidsWindows() {
+  try {
+    const output = await run("tasklist", ["/FI", "IMAGENAME eq claude.exe", "/FO", "CSV", "/NH"]);
+    return output.trim().split("\n").filter(Boolean).map((line) => {
+      const parts = line.split(",");
+      return Number.parseInt(parts[1]?.replace(/"/g, "") ?? "0", 10);
+    }).filter((pid) => pid > 0);
+  } catch {
+    return [];
+  }
+}
+async function getProcessInfoWindows(pid) {
+  try {
+    const output = await run("wmic", [
+      "process",
+      "where",
+      `ProcessId=${pid}`,
+      "get",
+      "CommandLine,CreationDate,ExecutablePath",
+      "/FORMAT:CSV"
+    ]);
+    const lines = output.trim().split(/\r?\n/).filter((l) => l.trim().length > 0);
+    if (lines.length < 2) return null;
+    const parts = lines[1].split(",");
+    const args = parts[1] ?? "";
+    const creationDate = parts[2] ?? "";
+    const year = creationDate.slice(0, 4);
+    const month = creationDate.slice(4, 6);
+    const day = creationDate.slice(6, 8);
+    const hour = creationDate.slice(8, 10);
+    const min = creationDate.slice(10, 12);
+    const sec = creationDate.slice(12, 14);
+    const startedAt = /* @__PURE__ */ new Date(`${year}-${month}-${day}T${hour}:${min}:${sec}`);
+    if (Number.isNaN(startedAt.getTime())) return null;
+    const exePath = parts[3] ?? "";
+    const cwd = exePath ? (0, import_path19.dirname)(exePath) : "";
+    return { cwd, args, startedAt };
+  } catch {
+    return null;
+  }
+}
+function extractResumeId(args) {
+  const match2 = args.match(/--resume\s+(\S+)/);
+  return match2?.[1] ?? null;
+}
+async function readGitBranch2(dir) {
+  try {
+    return (await run("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: dir, timeout: 3e3 })).trim();
+  } catch {
+    return "";
+  }
+}
+
 // src/seal.ts
 var import_tweetnacl = __toESM(require_nacl_fast(), 1);
 var import_tweetnacl_util = __toESM(require_nacl_util(), 1);
@@ -139384,10 +140069,10 @@ var ReaddirpStream2 = class extends import_node_stream2.Readable {
   }
   async _formatEntry(dirent, path2) {
     let entry;
-    const basename9 = this._isDirent ? dirent.name : dirent;
+    const basename11 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = (0, import_node_path9.resolve)((0, import_node_path9.join)(path2, basename9));
-      entry = { path: (0, import_node_path9.relative)(this._root, fullPath), fullPath, basename: basename9 };
+      const fullPath = (0, import_node_path9.resolve)((0, import_node_path9.join)(path2, basename11));
+      entry = { path: (0, import_node_path9.relative)(this._root, fullPath), fullPath, basename: basename11 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -139928,9 +140613,9 @@ var NodeFsHandler2 = class {
   _watchWithNodeFs(path2, listener) {
     const opts = this.fsw.options;
     const directory = sp.dirname(path2);
-    const basename9 = sp.basename(path2);
+    const basename11 = sp.basename(path2);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename9);
+    parent.add(basename11);
     const absolutePath = sp.resolve(path2);
     const options = {
       persistent: opts.persistent
@@ -139940,7 +140625,7 @@ var NodeFsHandler2 = class {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options.interval = enableBin && isBinaryPath2(basename9) ? opts.binaryInterval : opts.interval;
+      options.interval = enableBin && isBinaryPath2(basename11) ? opts.binaryInterval : opts.interval;
       closer = setFsWatchFileListener2(path2, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
@@ -139963,10 +140648,10 @@ var NodeFsHandler2 = class {
       return;
     }
     const dirname17 = sp.dirname(file2);
-    const basename9 = sp.basename(file2);
+    const basename11 = sp.basename(file2);
     const parent = this.fsw._getWatchedDir(dirname17);
     let prevStats = stats;
-    if (parent.has(basename9))
+    if (parent.has(basename11))
       return;
     const listener = async (path2, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH2, file2, 5))
@@ -139991,9 +140676,9 @@ var NodeFsHandler2 = class {
             prevStats = newStats2;
           }
         } catch (error51) {
-          this.fsw._remove(dirname17, basename9);
+          this.fsw._remove(dirname17, basename11);
         }
-      } else if (parent.has(basename9)) {
+      } else if (parent.has(basename11)) {
         const at2 = newStats.atimeMs;
         const mt2 = newStats.mtimeMs;
         if (!at2 || at2 <= mt2 || mt2 !== prevStats.mtimeMs) {
@@ -140950,7 +141635,7 @@ function watch2(paths, options = {}) {
 var chokidar_default = { watch: watch2, FSWatcher: FSWatcher2 };
 
 // src/services/conversations/conversationWatcher.ts
-var import_fs21 = require("fs");
+var import_fs22 = require("fs");
 var import_promises12 = require("fs/promises");
 var ConversationWatcher = class {
   files = /* @__PURE__ */ new Map();
@@ -140971,7 +141656,7 @@ var ConversationWatcher = class {
     if (this.files.has(filePath)) return;
     let offset;
     try {
-      offset = (0, import_fs21.statSync)(filePath).size;
+      offset = (0, import_fs22.statSync)(filePath).size;
     } catch {
       offset = 0;
     }
@@ -141080,14 +141765,14 @@ var ConversationWatcher = class {
 };
 
 // src/services/conversations/pruneAgentConversations.ts
-var import_fs22 = require("fs");
+var import_fs23 = require("fs");
 function pruneAgentConversations(cache) {
   const db = cache.getDatabase();
   const rows = db.prepare("SELECT id, file_path FROM conversation_meta").all();
   let pruned = 0;
   let missing = 0;
   for (const row of rows) {
-    if (!(0, import_fs22.existsSync)(row.file_path)) {
+    if (!(0, import_fs23.existsSync)(row.file_path)) {
       missing += 1;
       continue;
     }
@@ -141396,6 +142081,7 @@ function managedToResponse(s3, ptyAttached) {
   return {
     id: s3.id,
     conversationId: s3.id,
+    provider: s3.provider ?? CLAUDE_CODE_PROVIDER2,
     status: s3.status,
     projectPath: s3.projectPath,
     projectName: s3.projectName,
@@ -141421,13 +142107,15 @@ function managedToResponse(s3, ptyAttached) {
     ...s3.failureReason != null && { failureReason: s3.failureReason },
     ...s3.resumedFromConversationId != null && {
       resumedFromConversationId: s3.resumedFromConversationId
-    }
+    },
+    ...s3.boundConversationId != null && { boundConversationId: s3.boundConversationId }
   };
 }
 function discoveredToResponse(d, conversationId) {
   return {
     id: conversationId,
     conversationId,
+    provider: CLAUDE_CODE_PROVIDER2,
     status: "idle",
     projectPath: d.projectPath,
     projectName: d.projectName,
@@ -141443,10 +142131,10 @@ function discoveredToResponse(d, conversationId) {
 }
 
 // src/uploads.ts
-var import_crypto7 = require("crypto");
+var import_crypto8 = require("crypto");
 var import_promises13 = require("fs/promises");
 var import_heic_convert = __toESM(require_heic_convert(), 1);
-var import_path18 = require("path");
+var import_path20 = require("path");
 var UPLOAD_DIR_NAME = ".threadbase-uploads";
 var MAX_BYTES = 25 * 1024 * 1024;
 var HEIC_MIMES = /* @__PURE__ */ new Set(["image/heic", "image/heif"]);
@@ -141477,11 +142165,11 @@ async function saveUploadFile(input) {
     mimeType = "image/jpeg";
     originalName = originalName.replace(/\.(heic|heif)$/i, ".jpg");
   }
-  const id = `up_${(0, import_crypto7.randomBytes)(8).toString("hex")}`;
+  const id = `up_${(0, import_crypto8.randomBytes)(8).toString("hex")}`;
   const safeName = sanitizeFilename(originalName) || `file${MIME_TO_EXT[mimeType] ?? ""}`;
-  const dir = (0, import_path18.join)(input.projectPath, UPLOAD_DIR_NAME, input.sessionId);
+  const dir = (0, import_path20.join)(input.projectPath, UPLOAD_DIR_NAME, input.sessionId);
   await (0, import_promises13.mkdir)(dir, { recursive: true });
-  const filePath = (0, import_path18.join)(dir, `${Date.now()}-${id}-${safeName}`);
+  const filePath = (0, import_path20.join)(dir, `${Date.now()}-${id}-${safeName}`);
   await (0, import_promises13.writeFile)(filePath, buffer);
   return {
     id,
@@ -141994,10 +142682,10 @@ var StreamerServer = class {
     this.verbose = config2.verbose ?? false;
     this.disableDb = config2.disableDb ?? false;
     this.scanProfiles = config2.scanProfiles;
-    this.codexRoots = config2.codexRoots ?? [(0, import_path19.join)((0, import_os10.homedir)(), ".codex", "sessions")];
+    this.codexRoots = config2.codexRoots ?? [(0, import_path21.join)((0, import_os10.homedir)(), ".codex", "sessions")];
     this.ptyGracePeriodMs = config2.ptyGracePeriodMs ?? DEFAULT_PTY_GRACE_PERIOD_MS;
     this.defaultSystemPrompt = config2.defaultSystemPrompt ?? DEFAULT_SYSTEM_PROMPT;
-    this.cacheDir = config2.cacheDir ?? loadCacheDir() ?? (0, import_path19.join)((0, import_os10.homedir)(), ".threadbase", "cache");
+    this.cacheDir = config2.cacheDir ?? loadCacheDir() ?? (0, import_path21.join)((0, import_os10.homedir)(), ".threadbase", "cache");
     this.tailSize = config2.tailSize ?? loadTailSize() ?? 10;
     this.directoryDebounceMs = parseDirScanDebounceEnv(process.env.THREADBASE_DIR_SCAN_DEBOUNCE_MS) ?? config2.directoryScanDebounceMs ?? 1e3;
     this.markScannerStaleDebounced = debounce(() => {
@@ -142081,7 +142769,7 @@ var StreamerServer = class {
           });
       }
     });
-    this.ptyManager = new PTYManager({
+    this.ptyManager = new LiveSessionManager({
       logger: getLogger("pty"),
       onOutput: (sessionId, data) => {
         this.wsHub.broadcast({ type: "terminal_output", sessionId, data });
@@ -142162,7 +142850,7 @@ var StreamerServer = class {
         temporalClient,
         taskQueue: agentConfig.temporal.taskQueue
       });
-      const conversationsBaseDir = agentConfig.conversationsDir || (0, import_path19.join)((0, import_path19.dirname)(this.cacheDir), "conversations");
+      const conversationsBaseDir = agentConfig.conversationsDir || (0, import_path21.join)((0, import_path21.dirname)(this.cacheDir), "conversations");
       conversationWriter = createConversationWriter({
         baseDir: conversationsBaseDir
       });
@@ -142384,7 +143072,7 @@ var StreamerServer = class {
         });
         try {
           this.cache = ConversationCache.open(
-            (0, import_path19.join)(this.cacheDir, "cache.db"),
+            (0, import_path21.join)(this.cacheDir, "cache.db"),
             this.tailSize,
             void 0,
             {
@@ -142410,18 +143098,19 @@ var StreamerServer = class {
           if (this.scanProfiles && this.scanProfiles.length > 0) {
             for (const profile of this.scanProfiles) {
               if (profile.enabled) {
-                this.fileWatcher.watchDirectory((0, import_path19.join)(profile.configDir, "projects"));
+                this.fileWatcher.watchDirectory((0, import_path21.join)(profile.configDir, "projects"));
               }
             }
           } else {
-            this.fileWatcher.watchDirectory((0, import_path19.join)((0, import_os10.homedir)(), ".claude", "projects"));
+            this.fileWatcher.watchDirectory((0, import_path21.join)((0, import_os10.homedir)(), ".claude", "projects"));
           }
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
-          this.log.warn(`ConversationCache failed to open (running without cache): ${message}`, {
-            error: message,
-            event: "cache.open_failed"
-          });
+          const abiMismatch = message.includes("NODE_MODULE_VERSION") || message.includes("was compiled against a different Node.js version");
+          this.log.error(
+            `ConversationCache failed to open \u2014 running WITHOUT cache; /api/conversations, /api/conversations/count and /project-chats will 500.` + (abiMismatch ? ` Fix: npm rebuild better-sqlite3` : "") + ` (${message})`,
+            { error: message, abiMismatch, event: "cache.open_failed" }
+          );
         }
         const warmupScanner = new ConversationScanner();
         this.allScanners.add(warmupScanner);
@@ -142908,17 +143597,17 @@ var StreamerServer = class {
     return this.getScanner();
   }
   findJsonlPath(uuid3) {
-    const projectsDir = (0, import_path19.join)((0, import_os10.homedir)(), ".claude", "projects");
-    if (!(0, import_fs23.existsSync)(projectsDir)) return null;
+    const projectsDir = (0, import_path21.join)((0, import_os10.homedir)(), ".claude", "projects");
+    if (!(0, import_fs24.existsSync)(projectsDir)) return null;
     const filename = `${uuid3}.jsonl`;
-    for (const dir of (0, import_fs23.readdirSync)(projectsDir)) {
-      const fp = (0, import_path19.join)(projectsDir, dir, filename);
-      if ((0, import_fs23.existsSync)(fp)) return fp;
-      const projectDir = (0, import_path19.join)(projectsDir, dir);
+    for (const dir of (0, import_fs24.readdirSync)(projectsDir)) {
+      const fp = (0, import_path21.join)(projectsDir, dir, filename);
+      if ((0, import_fs24.existsSync)(fp)) return fp;
+      const projectDir = (0, import_path21.join)(projectsDir, dir);
       try {
-        for (const sub of (0, import_fs23.readdirSync)(projectDir)) {
-          const subagentPath = (0, import_path19.join)(projectDir, sub, "subagents", filename);
-          if ((0, import_fs23.existsSync)(subagentPath)) return subagentPath;
+        for (const sub of (0, import_fs24.readdirSync)(projectDir)) {
+          const subagentPath = (0, import_path21.join)(projectDir, sub, "subagents", filename);
+          if ((0, import_fs24.existsSync)(subagentPath)) return subagentPath;
         }
       } catch {
       }
@@ -142927,7 +143616,7 @@ var StreamerServer = class {
   }
   async readCwdFromJsonl(filePath) {
     return new Promise((resolve6) => {
-      const rl = (0, import_readline4.createInterface)({ input: (0, import_fs23.createReadStream)(filePath), crlfDelay: Infinity });
+      const rl = (0, import_readline4.createInterface)({ input: (0, import_fs24.createReadStream)(filePath), crlfDelay: Infinity });
       let found = false;
       rl.on("line", (line) => {
         if (found) return;
@@ -142984,7 +143673,7 @@ var StreamerServer = class {
     if (!conv.filePath) return false;
     let mtimeMs = null;
     try {
-      mtimeMs = (0, import_fs23.statSync)(conv.filePath).mtimeMs;
+      mtimeMs = (0, import_fs24.statSync)(conv.filePath).mtimeMs;
     } catch {
       return false;
     }
@@ -143227,7 +143916,7 @@ var StreamerServer = class {
   handleGetSession(sessionId, res) {
     const session = this.sessionStore.get(sessionId, this.ptyAttachedIds());
     if (session) {
-      if (!(0, import_fs23.existsSync)(session.projectPath)) {
+      if (!(0, import_fs24.existsSync)(session.projectPath)) {
         session.failureReason = `Project directory not found: ${session.projectPath}`;
       }
       json2(res, 200, session);
@@ -143267,7 +143956,10 @@ var StreamerServer = class {
       json2(res, 400, { error: "Could not determine project path" });
       return;
     }
+    const cachedConvMeta = this.cache?.getMetaById(sessionId);
+    const provider = conv?.provider ?? cachedConvMeta?.provider ?? CLAUDE_CODE_PROVIDER2;
     const session = await this.ptyManager.start(sessionId, {
+      provider,
       projectPath,
       projectName: body.projectName,
       branch: body.branch
@@ -143617,7 +144309,7 @@ var StreamerServer = class {
         sessionStore: this.sessionStore,
         // biome-ignore lint/style/noNonNullAssertion: agentClient is set when agentConfig.enabled is true
         agentClient: this.agentClient,
-        conversationsDir: this.cacheDir ? (0, import_path19.join)((0, import_path19.dirname)(this.cacheDir), "conversations") : "",
+        conversationsDir: this.cacheDir ? (0, import_path21.join)((0, import_path21.dirname)(this.cacheDir), "conversations") : "",
         agentConfig: this.agentConfig
       });
       json2(res, result.status, result.body);
@@ -143626,6 +144318,13 @@ var StreamerServer = class {
       }
       return;
     }
+    const body = await readBody(req);
+    const { path: relativePath, provider: requestedProvider, systemPrompt: clientPrompt } = body;
+    if (requestedProvider !== void 0 && !isProviderName(requestedProvider)) {
+      json2(res, 400, { error: "Invalid provider" });
+      return;
+    }
+    const provider = requestedProvider ?? CLAUDE_CODE_PROVIDER2;
     if (!this.browseRoot) {
       json2(res, 403, {
         error: "File browsing not configured. Set browseRoot on the server.",
@@ -143633,8 +144332,6 @@ var StreamerServer = class {
       });
       return;
     }
-    const body = await readBody(req);
-    const { path: relativePath, systemPrompt: clientPrompt } = body;
     if (typeof relativePath !== "string") {
       json2(res, 400, { error: "Missing path field" });
       return;
@@ -143655,21 +144352,27 @@ var StreamerServer = class {
     ].filter(Boolean);
     try {
       const session = await this.ptyManager.startFresh({
+        provider,
         projectPath: resolvedPath,
         projectName: body.projectName,
         systemPrompt: systemPromptParts.join("\n")
       });
       this.sessionStore.addManaged(session);
       json2(res, 202, { id: session.id, status: "pending" });
-      this.watchForJsonl(session.id, resolvedPath);
+      if (provider === CODEX_CLI_PROVIDER2) {
+        this.watchForCodexRollout(session.id, resolvedPath);
+      } else {
+        this.watchForJsonl(session.id, resolvedPath);
+      }
       this.broadcastOrUnicastSessionList(req);
     } catch (err) {
       const message = err instanceof Error ? err.message : "Failed to start session";
+      const statusCode = typeof err.statusCode === "number" ? err.statusCode : 500;
       this.log.error(`[start] failed to start session: ${message}`, {
         event: "session.start_failed",
         error: message
       });
-      json2(res, 500, { error: message });
+      json2(res, statusCode, { error: message });
     }
   }
   // ─── Project linking ─────────────────────────────────────────────
@@ -143722,9 +144425,9 @@ var StreamerServer = class {
   // was passed to Claude via --session-id so the filename matches from the start.
   watchForJsonl(sessionId, projectPath) {
     const encoded = projectPath.replace(/[/\\:.]/g, "-");
-    const projectsDir = (0, import_path19.join)((0, import_os10.homedir)(), ".claude", "projects", encoded);
+    const projectsDir = (0, import_path21.join)((0, import_os10.homedir)(), ".claude", "projects", encoded);
     const expectedFile = `${sessionId}.jsonl`;
-    const filePath = (0, import_path19.join)(projectsDir, expectedFile);
+    const filePath = (0, import_path21.join)(projectsDir, expectedFile);
     const deadline = Date.now() + 12e4;
     let watcher = null;
     const cleanup = () => {
@@ -143742,12 +144445,12 @@ var StreamerServer = class {
         cleanup();
         return;
       }
-      let resolvedFilePath = (0, import_fs23.existsSync)(filePath) ? filePath : null;
-      if (!resolvedFilePath && (0, import_fs23.existsSync)(projectsDir)) {
+      let resolvedFilePath = (0, import_fs24.existsSync)(filePath) ? filePath : null;
+      if (!resolvedFilePath && (0, import_fs24.existsSync)(projectsDir)) {
         try {
           const now = Date.now();
-          const recent = (0, import_fs23.readdirSync)(projectsDir).filter((f2) => f2.endsWith(".jsonl")).map((f2) => ({ f: f2, mtime: (0, import_fs23.statSync)((0, import_path19.join)(projectsDir, f2)).mtimeMs })).filter(({ mtime }) => now - mtime < 5e3).sort((a, b2) => b2.mtime - a.mtime)[0];
-          if (recent) resolvedFilePath = (0, import_path19.join)(projectsDir, recent.f);
+          const recent = (0, import_fs24.readdirSync)(projectsDir).filter((f2) => f2.endsWith(".jsonl")).map((f2) => ({ f: f2, mtime: (0, import_fs24.statSync)((0, import_path21.join)(projectsDir, f2)).mtimeMs })).filter(({ mtime }) => now - mtime < 5e3).sort((a, b2) => b2.mtime - a.mtime)[0];
+          if (recent) resolvedFilePath = (0, import_path21.join)(projectsDir, recent.f);
         } catch {
         }
       }
@@ -143756,7 +144459,7 @@ var StreamerServer = class {
       this.sessionFileMap.set(sessionId, resolvedFilePath);
       this.fileWatcher.watch(resolvedFilePath);
       try {
-        const existing = (0, import_fs23.readFileSync)(resolvedFilePath, "utf8").split("\n").filter(Boolean);
+        const existing = (0, import_fs24.readFileSync)(resolvedFilePath, "utf8").split("\n").filter(Boolean);
         if (existing.length > 0) {
           this.wsHub.broadcast({ type: "conversation_events", sessionId, lines: existing });
           for (const line of existing) {
@@ -143782,11 +144485,126 @@ var StreamerServer = class {
     if (this.sessionFileMap.has(sessionId)) return;
     try {
       require("fs").mkdirSync(projectsDir, { recursive: true });
-      watcher = (0, import_fs23.watch)(projectsDir, tryWire);
+      watcher = (0, import_fs24.watch)(projectsDir, tryWire);
       watcher.on("error", cleanup);
     } catch {
     }
   }
+  // Codex-equivalent of watchForJsonl(). Differs because Codex has no
+  // filename-encoded session id (it assigns its own persisted id) and its
+  // rollout files live under a date-nested directory
+  // (~/.codex/sessions/<YYYY>/<MM>/<DD>/rollout-*.jsonl) that Codex creates
+  // itself — it may not exist yet when this function is first called, so we
+  // poll rather than fs.watch a not-yet-existent directory. Per Phase 0
+  // findings, the rollout file appears within ~1s of process spawn (after
+  // any directory-trust gate is cleared), well before any user input.
+  watchForCodexRollout(sessionId, projectPath) {
+    const deadline = Date.now() + 12e4;
+    const now = /* @__PURE__ */ new Date();
+    const dateDir = (0, import_path21.join)(
+      String(now.getFullYear()),
+      String(now.getMonth() + 1).padStart(2, "0"),
+      String(now.getDate()).padStart(2, "0")
+    );
+    const sessionStartedAtMs = (this.sessionStore.getManaged(sessionId)?.startedAt?.getTime() ?? Date.now()) - 5e3;
+    let intervalHandle = null;
+    const cleanup = () => {
+      if (intervalHandle) clearInterval(intervalHandle);
+      intervalHandle = null;
+    };
+    const matchesProjectPath = (candidatePath) => {
+      try {
+        const firstLine = (0, import_fs24.readFileSync)(candidatePath, "utf8").split("\n", 1)[0];
+        if (!firstLine) return null;
+        const parsed = JSON.parse(firstLine);
+        if (parsed?.type !== "session_meta") return null;
+        const payload = parsed.payload ?? {};
+        if (payload.cwd !== projectPath) return null;
+        if (typeof payload.id !== "string") return null;
+        const createdIso = payload.timestamp ?? parsed.timestamp;
+        const createdAtMs = typeof createdIso === "string" ? Date.parse(createdIso) : Number.NaN;
+        if (Number.isNaN(createdAtMs) || createdAtMs < sessionStartedAtMs) return null;
+        return { id: payload.id, createdAtMs };
+      } catch {
+        return null;
+      }
+    };
+    const tryWire = () => {
+      if (!this.ptyManager.hasSession(sessionId)) {
+        cleanup();
+        return;
+      }
+      if (Date.now() > deadline) {
+        cleanup();
+        return;
+      }
+      const boundElsewhere = new Set(
+        this.sessionStore.listManaged().filter((s3) => s3.id !== sessionId && s3.boundConversationId != null).map((s3) => s3.boundConversationId)
+      );
+      for (const root of this.codexRoots) {
+        const sessionsDir = (0, import_path21.join)(root, dateDir);
+        if (!(0, import_fs24.existsSync)(sessionsDir)) continue;
+        let candidateFiles;
+        try {
+          candidateFiles = (0, import_fs24.readdirSync)(sessionsDir).filter((f2) => f2.endsWith(".jsonl"));
+        } catch {
+          continue;
+        }
+        const nowMs = Date.now();
+        const recentCandidates = candidateFiles.map((f2) => ({ f: f2, mtime: (0, import_fs24.statSync)((0, import_path21.join)(sessionsDir, f2)).mtimeMs })).filter(({ mtime }) => nowMs - mtime < 1e4).sort((a, b2) => b2.mtime - a.mtime);
+        for (const { f: f2 } of recentCandidates) {
+          const candidatePath = (0, import_path21.join)(sessionsDir, f2);
+          const match2 = matchesProjectPath(candidatePath);
+          if (!match2) continue;
+          if (boundElsewhere.has(match2.id)) continue;
+          const codexSessionId = match2.id;
+          cleanup();
+          this.sessionStore.updateManaged(sessionId, { boundConversationId: codexSessionId });
+          this.sessionFileMap.set(sessionId, candidatePath);
+          this.fileWatcher.watch(candidatePath);
+          try {
+            const existing = (0, import_fs24.readFileSync)(candidatePath, "utf8").split("\n").filter(Boolean);
+            if (existing.length > 0) {
+              this.wsHub.broadcast({ type: "conversation_events", sessionId, lines: existing });
+              for (const line of existing) {
+                this.wsHub.broadcast({ type: "conversation_event", sessionId, line });
+              }
+            }
+          } catch {
+          }
+          if (this.scannerReady) {
+            this.scannerStale = true;
+          } else {
+            this.scanner = null;
+          }
+          this.linkSessionToProject(sessionId, projectPath, candidatePath);
+          this.cache?.markAsStreamer(sessionId);
+          const resp = this.sessionStore.get(sessionId, this.ptyAttachedIds());
+          if (resp) {
+            this.wsHub.broadcast({ type: "session_update", session: resp });
+          }
+          this.log.info(
+            `[startFresh] bound Codex rollout for ${sessionId}`,
+            {
+              event: "session.codex_rollout_bound",
+              sessionId,
+              boundConversationId: codexSessionId,
+              filePath: candidatePath
+            },
+            "pino"
+          );
+          return;
+        }
+      }
+    };
+    tryWire();
+    if (!intervalHandle && Date.now() <= deadline) {
+      const alreadyBound = this.sessionStore.getManaged(sessionId)?.boundConversationId != null;
+      if (!alreadyBound) {
+        intervalHandle = setInterval(tryWire, 250);
+      }
+    }
+  }
   async handleBrowse(url2, res) {
     if (!this.browseRoot) {
       json2(res, 403, {
@@ -143870,7 +144688,7 @@ var StreamerServer = class {
 };
 function classifyResumability(cwd) {
   if (!cwd) return { resumable: true };
-  if ((0, import_fs23.existsSync)(cwd)) return { resumable: true };
+  if ((0, import_fs24.existsSync)(cwd)) return { resumable: true };
   const ranInWorktree = /\/\.worktrees\//.test(cwd) || /\/\.claude\/worktrees\//.test(cwd);
   return {
     resumable: false,
@@ -144450,13 +145268,13 @@ var import_node_fs17 = require("fs");
 
 // node_modules/tar/dist/esm/index.min.js
 var import_events4 = __toESM(require("events"), 1);
-var import_fs24 = __toESM(require("fs"), 1);
+var import_fs25 = __toESM(require("fs"), 1);
 var import_node_events3 = require("events");
 var import_node_stream3 = __toESM(require("stream"), 1);
 var import_node_string_decoder = require("string_decoder");
 var import_node_path14 = __toESM(require("path"), 1);
 var import_node_fs11 = __toESM(require("fs"), 1);
-var import_path20 = require("path");
+var import_path22 = require("path");
 var import_events5 = require("events");
 var import_assert = __toESM(require("assert"), 1);
 var import_buffer = require("buffer");
@@ -144464,17 +145282,17 @@ 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_fs25 = __toESM(require("fs"), 1);
 var import_fs26 = __toESM(require("fs"), 1);
-var import_path21 = __toESM(require("path"), 1);
+var import_fs27 = __toESM(require("fs"), 1);
+var import_path23 = __toESM(require("path"), 1);
 var import_node_path17 = require("path");
-var import_path22 = __toESM(require("path"), 1);
+var import_path24 = __toESM(require("path"), 1);
 var import_node_fs12 = __toESM(require("fs"), 1);
 var import_node_assert = __toESM(require("assert"), 1);
 var import_node_crypto5 = require("crypto");
 var import_node_fs13 = __toESM(require("fs"), 1);
 var import_node_path18 = __toESM(require("path"), 1);
-var import_fs27 = __toESM(require("fs"), 1);
+var import_fs28 = __toESM(require("fs"), 1);
 var import_node_fs14 = __toESM(require("fs"), 1);
 var import_node_path19 = __toESM(require("path"), 1);
 var import_node_fs15 = __toESM(require("fs"), 1);
@@ -144826,7 +145644,7 @@ var A = class extends import_node_events3.EventEmitter {
     return Wr;
   }
 };
-var Jr = import_fs24.default.writev;
+var Jr = import_fs25.default.writev;
 var ht = /* @__PURE__ */ Symbol("_autoClose");
 var H = /* @__PURE__ */ Symbol("_close");
 var te = /* @__PURE__ */ Symbol("_ended");
@@ -144881,7 +145699,7 @@ var _t = class extends A {
     throw new TypeError("this is a readable stream");
   }
   [at]() {
-    import_fs24.default.open(this[U2], "r", (t2, e) => this[Ht](t2, e));
+    import_fs25.default.open(this[U2], "r", (t2, e) => this[Ht](t2, e));
   }
   [Ht](t2, e) {
     t2 ? this[Ut](t2) : (this[u2] = e, this.emit("open", e), this[zt]());
@@ -144894,7 +145712,7 @@ var _t = class extends A {
       this[j] = true;
       let t2 = this[vi]();
       if (t2.length === 0) return process.nextTick(() => this[Ii](null, 0, t2));
-      import_fs24.default.read(this[u2], t2, 0, t2.length, null, (e, i, r) => this[Ii](e, i, r));
+      import_fs25.default.read(this[u2], t2, 0, t2.length, null, (e, i, r) => this[Ii](e, i, r));
     }
   }
   [Ii](t2, e, i) {
@@ -144903,7 +145721,7 @@ var _t = class extends A {
   [H]() {
     if (this[ht] && typeof this[u2] == "number") {
       let t2 = this[u2];
-      this[u2] = void 0, import_fs24.default.close(t2, (e) => e ? this.emit("error", e) : this.emit("close"));
+      this[u2] = void 0, import_fs25.default.close(t2, (e) => e ? this.emit("error", e) : this.emit("close"));
     }
   }
   [Ut](t2) {
@@ -144931,7 +145749,7 @@ var Be = class extends _t {
   [at]() {
     let t2 = true;
     try {
-      this[Ht](null, import_fs24.default.openSync(this[U2], "r")), t2 = false;
+      this[Ht](null, import_fs25.default.openSync(this[U2], "r")), t2 = false;
     } finally {
       t2 && this[H]();
     }
@@ -144942,7 +145760,7 @@ var Be = class extends _t {
       if (!this[j]) {
         this[j] = true;
         do {
-          let e = this[vi](), i = e.length === 0 ? 0 : import_fs24.default.readSync(this[u2], e, 0, e.length, null);
+          let e = this[vi](), i = e.length === 0 ? 0 : import_fs25.default.readSync(this[u2], e, 0, e.length, null);
           if (!this[ki](i, e)) break;
         } while (true);
         this[j] = false;
@@ -144955,7 +145773,7 @@ var Be = class extends _t {
   [H]() {
     if (this[ht] && typeof this[u2] == "number") {
       let t2 = this[u2];
-      this[u2] = void 0, import_fs24.default.closeSync(t2), this.emit("close");
+      this[u2] = void 0, import_fs25.default.closeSync(t2), this.emit("close");
     }
   }
 };
@@ -144997,7 +145815,7 @@ var et = class extends import_events4.default {
     this[H](), this[gt] = true, this.emit("error", t2);
   }
   [at]() {
-    import_fs24.default.open(this[U2], this[tt], this[ie], (t2, e) => this[Ht](t2, e));
+    import_fs25.default.open(this[U2], this[tt], this[ie], (t2, e) => this[Ht](t2, e));
   }
   [Ht](t2, e) {
     this[Me] && this[tt] === "r+" && t2 && t2.code === "ENOENT" ? (this[tt] = "w", this[at]()) : t2 ? this[Ut](t2) : (this[u2] = e, this.emit("open", e), this[gt] || this[Ai]());
@@ -145009,7 +145827,7 @@ var et = class extends import_events4.default {
     return typeof t2 == "string" && (t2 = Buffer.from(t2, e)), this[te] ? (this.emit("error", new Error("write() after end()")), false) : this[u2] === void 0 || this[gt] || this[Y2].length ? (this[Y2].push(t2), this[ke] = true, false) : (this[gt] = true, this[ve](t2), true);
   }
   [ve](t2) {
-    import_fs24.default.write(this[u2], t2, 0, t2.length, this[ot], (e, i) => this[Pt](e, i));
+    import_fs25.default.write(this[u2], t2, 0, t2.length, this[ot], (e, i) => this[Pt](e, i));
   }
   [Pt](t2, e) {
     t2 ? this[Ut](t2) : (this[ot] !== void 0 && typeof e == "number" && (this[ot] += e), this[Y2].length ? this[Ai]() : (this[gt] = false, this[te] && !this[Ni] ? (this[Ni] = true, this[H](), this.emit("finish")) : this[ke] && (this[ke] = false, this.emit("drain"))));
@@ -145025,7 +145843,7 @@ var et = class extends import_events4.default {
   [H]() {
     if (this[ht] && typeof this[u2] == "number") {
       let t2 = this[u2];
-      this[u2] = void 0, import_fs24.default.close(t2, (e) => e ? this.emit("error", e) : this.emit("close"));
+      this[u2] = void 0, import_fs25.default.close(t2, (e) => e ? this.emit("error", e) : this.emit("close"));
     }
   }
 };
@@ -145033,24 +145851,24 @@ var Wt = class extends et {
   [at]() {
     let t2;
     if (this[Me] && this[tt] === "r+") try {
-      t2 = import_fs24.default.openSync(this[U2], this[tt], this[ie]);
+      t2 = import_fs25.default.openSync(this[U2], this[tt], this[ie]);
     } catch (e) {
       if (e?.code === "ENOENT") return this[tt] = "w", this[at]();
       throw e;
     }
-    else t2 = import_fs24.default.openSync(this[U2], this[tt], this[ie]);
+    else t2 = import_fs25.default.openSync(this[U2], this[tt], this[ie]);
     this[Ht](null, t2);
   }
   [H]() {
     if (this[ht] && typeof this[u2] == "number") {
       let t2 = this[u2];
-      this[u2] = void 0, import_fs24.default.closeSync(t2), this.emit("close");
+      this[u2] = void 0, import_fs25.default.closeSync(t2), this.emit("close");
     }
   }
   [ve](t2) {
     let e = true;
     try {
-      this[Pt](null, import_fs24.default.writeSync(this[u2], t2, 0, t2.length, this[ot])), e = false;
+      this[Pt](null, import_fs25.default.writeSync(this[u2], t2, 0, t2.length, this[ot])), e = false;
     } finally {
       if (e) try {
         this[H]();
@@ -145833,11 +146651,11 @@ var vn = (s3) => {
 };
 var Qi = (s3, t2) => {
   let e = new Map(t2.map((n) => [ut(n), true])), i = s3.filter, r = (n, o = "") => {
-    let h = o || (0, import_path20.parse)(n).root || ".", a;
+    let h = o || (0, import_path22.parse)(n).root || ".", a;
     if (n === h) a = false;
     else {
       let l = e.get(n);
-      a = l !== void 0 ? l : r((0, import_path20.dirname)(n), h);
+      a = l !== void 0 ? l : r((0, import_path22.dirname)(n), h);
     }
     return e.set(n, a), a;
   };
@@ -145957,7 +146775,7 @@ var de = class extends A {
       let [o, h] = ce(this.path);
       o && typeof h == "string" && (this.path = h, r = o);
     }
-    this.win32 = !!i.win32 || process.platform === "win32", this.win32 && (this.path = Qs(this.path.replaceAll(/\\/g, "/")), t2 = t2.replaceAll(/\\/g, "/")), this.absolute = f(i.absolute || import_path21.default.resolve(this.cwd, t2)), this.path === "" && (this.path = "./"), r && this.warn("TAR_ENTRY_INFO", `stripping ${r} from absolute path`, { entry: this, path: r + this.path });
+    this.win32 = !!i.win32 || process.platform === "win32", this.win32 && (this.path = Qs(this.path.replaceAll(/\\/g, "/")), t2 = t2.replaceAll(/\\/g, "/")), this.absolute = f(i.absolute || import_path23.default.resolve(this.cwd, t2)), this.path === "" && (this.path = "./"), r && this.warn("TAR_ENTRY_INFO", `stripping ${r} from absolute path`, { entry: this, path: r + this.path });
     let n = this.statCache.get(this.absolute);
     n ? this[si](n) : this[ss]();
   }
@@ -145968,7 +146786,7 @@ var de = class extends A {
     return t2 === "error" && (this.#t = true), super.emit(t2, ...e);
   }
   [ss]() {
-    import_fs26.default.lstat(this.absolute, (t2, e) => {
+    import_fs27.default.lstat(this.absolute, (t2, e) => {
       if (t2) return this.emit("error", t2);
       this[si](e);
     });
@@ -146006,7 +146824,7 @@ var de = class extends A {
     this.path.slice(-1) !== "/" && (this.path += "/"), this.stat.size = 0, this[fe](), this.end();
   }
   [is]() {
-    import_fs26.default.readlink(this.absolute, (t2, e) => {
+    import_fs27.default.readlink(this.absolute, (t2, e) => {
       if (t2) return this.emit("error", t2);
       this[ns](e);
     });
@@ -146016,7 +146834,7 @@ var de = class extends A {
   }
   [sr](t2) {
     if (!this.stat) throw new Error("cannot create link entry without stat");
-    this.type = "Link", this.linkpath = f(import_path21.default.relative(this.cwd, t2)), this.stat.size = 0, this[fe](), this.end();
+    this.type = "Link", this.linkpath = f(import_path23.default.relative(this.cwd, t2)), this.stat.size = 0, this[fe](), this.end();
   }
   [er]() {
     if (!this.stat) throw new Error("cannot create file entry without stat");
@@ -146029,7 +146847,7 @@ var de = class extends A {
     this[os]();
   }
   [os]() {
-    import_fs26.default.open(this.absolute, "r", (t2, e) => {
+    import_fs27.default.open(this.absolute, "r", (t2, e) => {
       if (t2) return this.emit("error", t2);
       this[hs](e);
     });
@@ -146044,14 +146862,14 @@ var de = class extends A {
   [ii]() {
     let { fd: t2, buf: e, offset: i, length: r, pos: n } = this;
     if (t2 === void 0 || e === void 0) throw new Error("cannot read file without first opening");
-    import_fs26.default.read(t2, e, i, r, n, (o, h) => {
+    import_fs27.default.read(t2, e, i, r, n, (o, h) => {
       if (o) return this[pt](() => this.emit("error", o));
       this[rs](h);
     });
   }
   [pt](t2 = () => {
   }) {
-    this.fd !== void 0 && import_fs26.default.close(this.fd, t2);
+    this.fd !== void 0 && import_fs27.default.close(this.fd, t2);
   }
   [rs](t2) {
     if (t2 <= 0 && this.remain > 0) {
@@ -146086,20 +146904,20 @@ var de = class extends A {
 var ni = class extends de {
   sync = true;
   [ss]() {
-    this[si](import_fs26.default.lstatSync(this.absolute));
+    this[si](import_fs27.default.lstatSync(this.absolute));
   }
   [is]() {
-    this[ns](import_fs26.default.readlinkSync(this.absolute));
+    this[ns](import_fs27.default.readlinkSync(this.absolute));
   }
   [os]() {
-    this[hs](import_fs26.default.openSync(this.absolute, "r"));
+    this[hs](import_fs27.default.openSync(this.absolute, "r"));
   }
   [ii]() {
     let t2 = true;
     try {
       let { fd: e, buf: i, offset: r, length: n, pos: o } = this;
       if (e === void 0 || i === void 0) throw new Error("fd and buf must be set in READ method");
-      let h = import_fs26.default.readSync(e, i, r, n, o);
+      let h = import_fs27.default.readSync(e, i, r, n, o);
       this[rs](h), t2 = false;
     } finally {
       if (t2) try {
@@ -146114,7 +146932,7 @@ var ni = class extends de {
   }
   [pt](t2 = () => {
   }) {
-    this.fd !== void 0 && import_fs26.default.closeSync(this.fd), t2();
+    this.fd !== void 0 && import_fs27.default.closeSync(this.fd), t2();
   }
 };
 var oi = class extends A {
@@ -146430,7 +147248,7 @@ var wt = class extends A {
     return typeof t2 == "string" ? this[ci](t2) : this[or](t2), this.flowing;
   }
   [or](t2) {
-    let e = f(import_path22.default.resolve(this.cwd, t2.path));
+    let e = f(import_path24.default.resolve(this.cwd, t2.path));
     if (!this.filter(t2.path, t2)) t2.resume();
     else {
       let i = new pi(t2.path, e);
@@ -146439,13 +147257,13 @@ var wt = class extends A {
     this[Ft]();
   }
   [ci](t2) {
-    let e = f(import_path22.default.resolve(this.cwd, t2));
+    let e = f(import_path24.default.resolve(this.cwd, t2));
     this[W].push(new pi(t2, e)), this[Ft]();
   }
   [ds](t2) {
     t2.pending = true, this[G2] += 1;
     let e = this.follow ? "stat" : "lstat";
-    import_fs25.default[e](t2.absolute, (i, r) => {
+    import_fs26.default[e](t2.absolute, (i, r) => {
       t2.pending = false, this[G2] -= 1, i ? this.emit("error", i) : this[li](t2, r);
     });
   }
@@ -146459,7 +147277,7 @@ var wt = class extends A {
     this[Ft]();
   }
   [ms](t2) {
-    t2.pending = true, this[G2] += 1, import_fs25.default.readdir(t2.absolute, (e, i) => {
+    t2.pending = true, this[G2] += 1, import_fs26.default.readdir(t2.absolute, (e, i) => {
       if (t2.pending = false, this[G2] -= 1, e) return this.emit("error", e);
       this[fi](t2, i);
     });
@@ -146560,10 +147378,10 @@ var kt = class extends wt {
   }
   [ds](t2) {
     let e = this.follow ? "statSync" : "lstatSync";
-    this[li](t2, import_fs25.default[e](t2.absolute));
+    this[li](t2, import_fs26.default[e](t2.absolute));
   }
   [ms](t2) {
-    this[fi](t2, import_fs25.default.readdirSync(t2.absolute));
+    this[fi](t2, import_fs26.default.readdirSync(t2.absolute));
   }
   [di](t2) {
     let e = t2.entry, i = this.zip;
@@ -146614,8 +147432,8 @@ var Qn = K2(Vn, $n, Xn, qn, (s3, t2) => {
 });
 var Jn = process.env.__FAKE_PLATFORM__ || process.platform;
 var Er = Jn === "win32";
-var { O_CREAT: wr, O_NOFOLLOW: mr, O_TRUNC: Sr, O_WRONLY: yr } = import_fs27.default.constants;
-var Rr = Number(process.env.__FAKE_FS_O_FILENAME__) || import_fs27.default.constants.UV_FS_O_FILEMAP || 0;
+var { O_CREAT: wr, O_NOFOLLOW: mr, O_TRUNC: Sr, O_WRONLY: yr } = import_fs28.default.constants;
+var Rr = Number(process.env.__FAKE_FS_O_FILENAME__) || import_fs28.default.constants.UV_FS_O_FILEMAP || 0;
 var jn = Er && !!Rr;
 var to = 512 * 1024;
 var eo = Rr | Sr | wr | yr;
@@ -147739,6 +148557,13 @@ program2.command("serve").description("Start the streamer server").option("-p, -
   "Run in multi-agent mode (PTY mode unreachable in this process)",
   false
 ).action(async (opts) => {
+  try {
+    const { checkSqliteAbi: checkSqliteAbi2 } = await Promise.resolve().then(() => (init_check_sqlite_abi(), check_sqlite_abi_exports));
+    checkSqliteAbi2();
+  } catch (err) {
+    log7.error(err instanceof Error ? err.message : String(err), void 0, "console");
+    process.exit(1);
+  }
   if (opts.multiAgentFlow) {
     process.env.MULTI_AGENT_FLOW = "true";
   }
@@ -147836,12 +148661,12 @@ program2.command("cache").description("Manage the local SQLite conversation cach
     "Cache directory (default: ~/.threadbase/cache)",
     `${process.env.HOME}/.threadbase/cache`
   ).action((opts) => {
-    const { rmSync: rmSync6, existsSync: existsSync11 } = require("fs");
+    const { rmSync: rmSync6, existsSync: existsSync12 } = require("fs");
     const { join: join26 } = require("path");
     const dbPath = join26(opts.cacheDir, "cache.db");
     for (const suffix of ["", "-shm", "-wal"]) {
       const f2 = dbPath + suffix;
-      if (existsSync11(f2)) {
+      if (existsSync12(f2)) {
         rmSync6(f2);
         log7.info(`Deleted ${f2}`, { path: f2 }, "console");
       }