@threadbase-sh/streamer 1.23.0 → 1.24.0

package/dist/index.cjs

@@ -30,7 +30,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  CLAUDE_CODE_PROVIDER: () => CLAUDE_CODE_PROVIDER,
+  CODEX_CLI_PROVIDER: () => CODEX_CLI_PROVIDER,
   ConversationWatcher: () => ConversationWatcher,
+  LiveSessionManager: () => LiveSessionManager,
   PTYManager: () => PTYManager,
   SessionStore: () => SessionStore,
   StreamerServer: () => StreamerServer,
@@ -44,6 +47,8 @@ __export(index_exports, {
   generateApiKey: () => generateApiKey,
   getDbConfig: () => getDbConfig,
   isDbEnabled: () => isDbEnabled,
+  isProviderName: () => isProviderName,
+  isProviderResumable: () => isProviderResumable,
   loadOrCreateApiKey: () => loadOrCreateApiKey,
   maskConnectionString: () => maskConnectionString,
   readAgentConfig: () => readAgentConfig,
@@ -527,11 +532,51 @@ async function createPool(config) {
   return new Pool(poolConfig);
 }
 
-// src/process-discovery.ts
-var import_child_process2 = require("child_process");
-var import_os3 = require("os");
+// src/live-session-manager.ts
+var import_path6 = require("path");
+
+// src/codex-pty-runner.ts
+var import_headless = require("@xterm/headless");
+var import_crypto2 = require("crypto");
+var import_fs4 = require("fs");
 var import_path4 = require("path");
 
+// src/logger.ts
+var import_pino = __toESM(require("pino"), 1);
+var baseLogger = (0, import_pino.default)({
+  level: process.env.LOG_LEVEL ?? "info",
+  base: { service: "tb-streamer" },
+  timestamp: import_pino.default.stdTimeFunctions.isoTime,
+  redact: {
+    paths: ["req.headers.authorization", "req.headers.cookie", 'req.headers["x-api-key"]'],
+    censor: "[redacted]"
+  }
+});
+function emit(pinoChild, level, msg, fields, dest) {
+  if (dest === "pino" || dest === "both") {
+    if (fields && Object.keys(fields).length > 0) pinoChild[level](fields, msg);
+    else pinoChild[level](msg);
+  }
+  if (dest === "console" || dest === "both") {
+    const consoleMethod = level === "error" ? "error" : level === "warn" ? "warn" : "log";
+    console[consoleMethod](msg);
+  }
+}
+function build(pinoChild) {
+  return {
+    debug: (m, f, d = "both") => emit(pinoChild, "debug", m, f, d),
+    info: (m, f, d = "both") => emit(pinoChild, "info", m, f, d),
+    warn: (m, f, d = "both") => emit(pinoChild, "warn", m, f, d),
+    error: (m, f, d = "both") => emit(pinoChild, "error", m, f, d),
+    log: (lvl, m, f, d = "both") => emit(pinoChild, lvl, m, f, d),
+    pino: pinoChild
+  };
+}
+function getLogger(component) {
+  return build(component ? baseLogger.child({ component }) : baseLogger);
+}
+var logger = build(baseLogger);
+
 // src/platform.ts
 var import_child_process = require("child_process");
 var import_fs3 = require("fs");
@@ -596,188 +641,534 @@ function resolveClaudeExe() {
   _claudeExe = "claude";
   return _claudeExe;
 }
-
-// src/process-discovery.ts
-async function discoverClaudeProcesses() {
-  if ((0, import_os3.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_path4.basename)(cwd),
-          branch: await readGitBranch(cwd),
-          conversationId,
-          startedAt
-        };
-      } catch {
-        return null;
+var _codexExe;
+function resolveCodexExe() {
+  if (_codexExe !== void 0) return _codexExe;
+  if (isWindows) {
+    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_path4.basename)(info.cwd),
-          branch: await readGitBranch(info.cwd),
-          conversationId: extractResumeId(info.args),
-          startedAt: info.startedAt
-        };
-      } catch {
-        return null;
+    } catch {
+    }
+    const candidates = [
+      (0, import_path3.join)((0, import_os2.homedir)(), ".local", "bin", "codex.exe"),
+      (0, import_path3.join)(
+        process.env.LOCALAPPDATA ?? (0, import_path3.join)((0, import_os2.homedir)(), "AppData", "Local"),
+        "Microsoft",
+        "WindowsApps",
+        "codex.exe"
+      )
+    ];
+    for (const p of candidates) {
+      if ((0, import_fs3.existsSync)(p)) {
+        _codexExe = p;
+        return _codexExe;
       }
-    })
-  );
-  return results.filter((r) => r !== null);
-}
-function run(cmd, args, opts = {}) {
-  return new Promise((resolve2, reject) => {
-    (0, import_child_process2.execFile)(
-      cmd,
-      args,
-      { windowsHide: isWindows, encoding: "utf-8", timeout: opts.timeout ?? 5e3, cwd: opts.cwd },
-      (err, stdout) => {
-        if (err) reject(err);
-        else resolve2(stdout);
+    }
+  } 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_fs3.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((s) => Number.parseInt(s, 10));
-  } catch {
-    return [];
+    } catch {
+    }
+    const candidates = [
+      "/opt/homebrew/bin/codex",
+      "/usr/local/bin/codex",
+      (0, import_path3.join)((0, import_os2.homedir)(), ".local", "bin", "codex")
+    ];
+    for (const p of candidates) {
+      if ((0, import_fs3.existsSync)(p)) {
+        _codexExe = p;
+        return _codexExe;
+      }
+    }
   }
+  _codexExe = "codex";
+  return _codexExe;
 }
-async function getProcessCwdUnix(pid) {
-  const output = await run("lsof", ["-p", String(pid), "-a", "-d", "cwd", "-Fn"]);
-  const match = output.match(/n(.+)/);
-  return match?.[1] ?? "";
-}
-async function getProcessArgsUnix(pid) {
-  return (await run("ps", ["-p", String(pid), "-o", "args="])).trim();
+
+// src/providers.ts
+var CLAUDE_CODE_PROVIDER = "claude-code";
+var CODEX_CLI_PROVIDER = "codex-cli";
+function isProviderName(value) {
+  return value === CLAUDE_CODE_PROVIDER || value === CODEX_CLI_PROVIDER;
 }
-async function getProcessStartTimeUnix(pid) {
-  const raw = (await run("ps", ["-p", String(pid), "-o", "lstart="])).trim();
-  const d = new Date(raw);
-  return Number.isNaN(d.getTime()) ? /* @__PURE__ */ new Date() : d;
+function isProviderResumable(_provider, availabilityResumable) {
+  return availabilityResumable;
 }
-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(s) {
+  const escaped = s.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_path4.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 match = args.match(/--resume\s+(\S+)/);
-  return match?.[1] ?? null;
+function createScreen() {
+  return new import_headless.Terminal({
+    cols: PTY_COLS,
+    rows: PTY_ROWS,
+    scrollback: SCREEN_SCROLLBACK,
+    allowProposedApi: true
+  });
 }
-async function readGitBranch(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");
   }
-}
-
-// src/pty-manager.ts
-var import_headless = require("@xterm/headless");
-var import_crypto2 = require("crypto");
-var import_fs4 = require("fs");
-var import_path5 = require("path");
-
-// src/logger.ts
-var import_pino = __toESM(require("pino"), 1);
-var baseLogger = (0, import_pino.default)({
-  level: process.env.LOG_LEVEL ?? "info",
-  base: { service: "tb-streamer" },
-  timestamp: import_pino.default.stdTimeFunctions.isoTime,
-  redact: {
-    paths: ["req.headers.authorization", "req.headers.cookie", 'req.headers["x-api-key"]'],
-    censor: "[redacted]"
+  // 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 promise = this.doStart(sessionId, options).finally(() => {
+      this.startPromises.delete(sessionId);
+    });
+    this.startPromises.set(sessionId, promise);
+    return promise;
   }
-});
-function emit(pinoChild, level, msg, fields, dest) {
-  if (dest === "pino" || dest === "both") {
-    if (fields && Object.keys(fields).length > 0) pinoChild[level](fields, msg);
-    else pinoChild[level](msg);
+  async doStart(sessionId, options) {
+    const nodePty = await loadPty();
+    const projectName = options.projectName ?? (0, import_path4.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_PROVIDER,
+      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_crypto2.randomUUID)();
+    const projectName = options.projectName ?? (0, import_path4.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_PROVIDER,
+      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, path, 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,
+        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,
+          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((resolve2) => session.screen.write("", () => resolve2()));
+    const buf = session.screen.buffer.active;
+    const lines = [];
+    for (let y = 0; y < buf.length; y++) {
+      lines.push(buf.getLine(y)?.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));
+    }
   }
-  if (dest === "console" || dest === "both") {
-    const consoleMethod = level === "error" ? "error" : level === "warn" ? "warn" : "log";
-    console[consoleMethod](msg);
+  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_fs4.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 build(pinoChild) {
+};
+function toPublicSession(s) {
   return {
-    debug: (m, f, d = "both") => emit(pinoChild, "debug", m, f, d),
-    info: (m, f, d = "both") => emit(pinoChild, "info", m, f, d),
-    warn: (m, f, d = "both") => emit(pinoChild, "warn", m, f, d),
-    error: (m, f, d = "both") => emit(pinoChild, "error", m, f, d),
-    log: (lvl, m, f, d = "both") => emit(pinoChild, lvl, m, f, d),
-    pino: pinoChild
+    id: s.id,
+    provider: s.provider ?? CODEX_CLI_PROVIDER,
+    projectPath: s.projectPath,
+    projectName: s.projectName,
+    branch: s.branch,
+    status: s.status,
+    startedAt: s.startedAt,
+    completedAt: s.completedAt,
+    promptCount: s.promptCount,
+    lastOutput: s.lastOutput,
+    ...s.failureReason != null && { failureReason: s.failureReason },
+    ...s.lastActivityAt != null && { lastActivityAt: s.lastActivityAt },
+    ...s.filePath != null && { filePath: s.filePath }
   };
 }
-function getLogger(component) {
-  return build(component ? baseLogger.child({ component }) : baseLogger);
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").replace(/\x1b\][^\x07]*\x07/g, "");
 }
-var logger = build(baseLogger);
+
+// src/pty-manager.ts
+var import_headless2 = require("@xterm/headless");
+var import_crypto3 = require("crypto");
+var import_fs5 = require("fs");
+var import_path5 = require("path");
 
 // src/services/questions/detectPermissionGate.ts
 var OSC_777_RE = /\x1b\]777;notify;Claude Code;[^\x07\x1b]*/;
@@ -936,28 +1327,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(s) {
+function digestBytes2(s) {
   const escaped = s.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
@@ -965,11 +1356,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
   });
 }
@@ -1018,6 +1409,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;
@@ -1040,7 +1435,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 promise = this.doStart(sessionId, options).finally(() => {
+      this.startPromises.delete(sessionId);
+    });
+    this.startPromises.set(sessionId, promise);
+    return promise;
+  }
+  async doStart(sessionId, options) {
+    const nodePty = await loadPty2();
     const projectName = options.projectName ?? (0, import_path5.basename)(options.projectPath);
     const proc = nodePty.spawn(
       resolveClaudeExe(),
@@ -1062,6 +1468,7 @@ var PTYManager = class {
     );
     const session = {
       id: sessionId,
+      provider: CLAUDE_CODE_PROVIDER,
       projectPath: options.projectPath,
       projectName,
       branch: options.branch ?? "",
@@ -1072,7 +1479,7 @@ var PTYManager = class {
       lastOutput: "",
       process: proc,
       outputBuffer: Buffer.alloc(0),
-      screen: createScreen()
+      screen: createScreen2()
     };
     this.sessions.set(sessionId, session);
     this.pendingReady.add(sessionId);
@@ -1083,14 +1490,14 @@ 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 sessionId = (0, import_crypto2.randomUUID)();
+    const nodePty = await loadPty2();
+    const sessionId = (0, import_crypto3.randomUUID)();
     const projectName = options.projectName ?? (0, import_path5.basename)(options.projectPath);
     const args = [
       "--permission-mode",
@@ -1112,6 +1519,7 @@ var PTYManager = class {
     });
     const session = {
       id: sessionId,
+      provider: CLAUDE_CODE_PROVIDER,
       projectPath: options.projectPath,
       projectName,
       branch: "",
@@ -1122,7 +1530,7 @@ var PTYManager = class {
       lastOutput: "",
       process: proc,
       outputBuffer: Buffer.alloc(0),
-      screen: createScreen()
+      screen: createScreen2()
     };
     this.sessions.set(sessionId, session);
     this.pendingReady.add(sessionId);
@@ -1133,7 +1541,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.
@@ -1145,10 +1553,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);
@@ -1180,7 +1588,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();
@@ -1193,13 +1601,13 @@ var PTYManager = class {
   writeSubmit(sessionId, session, input, path, 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,
         phase: "paste"
       }
@@ -1214,13 +1622,13 @@ var PTYManager = class {
           event: "pty.input_write",
           sessionId,
           promptCount,
-          byteLen: SUBMIT_BYTES.length,
+          byteLen: SUBMIT_BYTES2.length,
           digest: "\\r",
           path,
           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,
@@ -1278,7 +1686,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);
@@ -1309,13 +1717,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()) {
@@ -1347,7 +1755,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,
@@ -1356,17 +1764,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((m) => stripped.includes(m));
     if (session.status === "running" && matchedMarker) {
@@ -1436,87 +1844,327 @@ var PTYManager = class {
           this.onLiveQuestion?.(sessionId, detected.questions);
         }
       }
-    } else if (this.lastScreenQuestionKey.has(sessionId) && hasPromptMarker) {
-      this.lastScreenQuestionKey.delete(sessionId);
-      this.onLiveQuestionGone?.(sessionId);
-    }
-    if (!oscPermission && !askFooterOnScreen && !this.permissionOpen.has(sessionId)) {
-      const shell = detectShellPrompt(lines);
-      if (shell) {
-        const key = `${shell.prompt}\0${shell.options.map((o) => o.label).join("\0")}`;
-        if (this.shellPromptOpen.get(sessionId) !== key) {
-          this.shellPromptOpen.set(sessionId, key);
-          this.onPermissionChange?.(sessionId, {
-            prompt: shell.prompt,
-            options: shell.options
-          });
-        }
-      } else if (this.shellPromptOpen.has(sessionId) && hasPromptMarker) {
-        this.shellPromptOpen.delete(sessionId);
-        this.onPermissionChange?.(sessionId, null);
+    } else if (this.lastScreenQuestionKey.has(sessionId) && hasPromptMarker) {
+      this.lastScreenQuestionKey.delete(sessionId);
+      this.onLiveQuestionGone?.(sessionId);
+    }
+    if (!oscPermission && !askFooterOnScreen && !this.permissionOpen.has(sessionId)) {
+      const shell = detectShellPrompt(lines);
+      if (shell) {
+        const key = `${shell.prompt}\0${shell.options.map((o) => o.label).join("\0")}`;
+        if (this.shellPromptOpen.get(sessionId) !== key) {
+          this.shellPromptOpen.set(sessionId, key);
+          this.onPermissionChange?.(sessionId, {
+            prompt: shell.prompt,
+            options: shell.options
+          });
+        }
+      } else if (this.shellPromptOpen.has(sessionId) && hasPromptMarker) {
+        this.shellPromptOpen.delete(sessionId);
+        this.onPermissionChange?.(sessionId, null);
+      }
+    }
+  }
+  // Transition a session from "running" to "waiting_input", clear pendingReady,
+  // and flush any queued input. Idempotent: callers can invoke at any chunk.
+  markReady(sessionId, session, reason) {
+    session.lastActivityAt = /* @__PURE__ */ new Date();
+    session.status = "waiting_input";
+    const elapsedMs = Date.now() - (this.firstChunkAt.get(sessionId) ?? Date.now());
+    this.log.info(`[pty.ready] ${sessionId.slice(0, 8)} ${reason} (elapsed=${elapsedMs}ms)`, {
+      event: "pty.ready",
+      sessionId,
+      reason,
+      elapsedMs
+    });
+    this.onStatusChange?.(toPublicSession2(session));
+    if (this.pendingReady.has(sessionId)) {
+      this.pendingReady.delete(sessionId);
+      this.flushQueuedInputs(sessionId);
+      this.onReady?.(toPublicSession2(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_fs5.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?.(toPublicSession2(session));
+    session.screen.dispose();
+    this.sessions.delete(sessionId);
+    this.queuedInputs.delete(sessionId);
+    this.firstChunkAt.delete(sessionId);
+    this.permissionOpen.delete(sessionId);
+    this.lastScreenQuestionKey.delete(sessionId);
+    this.shellPromptOpen.delete(sessionId);
+  }
+};
+function toPublicSession2(s) {
+  return {
+    id: s.id,
+    provider: s.provider ?? CLAUDE_CODE_PROVIDER,
+    projectPath: s.projectPath,
+    projectName: s.projectName,
+    branch: s.branch,
+    status: s.status,
+    startedAt: s.startedAt,
+    completedAt: s.completedAt,
+    promptCount: s.promptCount,
+    lastOutput: s.lastOutput,
+    ...s.failureReason != null && { failureReason: s.failureReason },
+    ...s.lastActivityAt != null && { lastActivityAt: s.lastActivityAt },
+    ...s.filePath != null && { filePath: s.filePath }
+  };
+}
+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_PROVIDER, new PTYManager(options)],
+      [CODEX_CLI_PROVIDER, new CodexPtyRunner(options)]
+    ]);
+  }
+  async start(sessionId, options) {
+    const provider = options.provider ?? CLAUDE_CODE_PROVIDER;
+    const runner = this.assertSupportedProvider(provider, options.projectPath);
+    return runner.start(sessionId, options);
+  }
+  async startFresh(options) {
+    const provider = options.provider ?? CLAUDE_CODE_PROVIDER;
+    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_path6.basename)(projectPath)}`
+    );
+    err.statusCode = 501;
+    throw err;
+  }
+};
+
+// src/process-discovery.ts
+var import_child_process2 = require("child_process");
+var import_os3 = require("os");
+var import_path7 = require("path");
+async function discoverClaudeProcesses() {
+  if ((0, import_os3.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_path7.basename)(cwd),
+          branch: await readGitBranch(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_path7.basename)(info.cwd),
+          branch: await readGitBranch(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((resolve2, reject) => {
+    (0, import_child_process2.execFile)(
+      cmd,
+      args,
+      { windowsHide: isWindows, encoding: "utf-8", timeout: opts.timeout ?? 5e3, cwd: opts.cwd },
+      (err, stdout) => {
+        if (err) reject(err);
+        else resolve2(stdout);
       }
-    }
+    );
+  });
+}
+async function getPidsUnix() {
+  try {
+    const output = await run("pgrep", ["-x", "claude"]);
+    return output.trim().split("\n").filter(Boolean).map((s) => Number.parseInt(s, 10));
+  } catch {
+    return [];
   }
-  // Transition a session from "running" to "waiting_input", clear pendingReady,
-  // and flush any queued input. Idempotent: callers can invoke at any chunk.
-  markReady(sessionId, session, reason) {
-    session.lastActivityAt = /* @__PURE__ */ new Date();
-    session.status = "waiting_input";
-    const elapsedMs = Date.now() - (this.firstChunkAt.get(sessionId) ?? Date.now());
-    this.log.info(`[pty.ready] ${sessionId.slice(0, 8)} ${reason} (elapsed=${elapsedMs}ms)`, {
-      event: "pty.ready",
-      sessionId,
-      reason,
-      elapsedMs
-    });
-    this.onStatusChange?.(toPublicSession(session));
-    if (this.pendingReady.has(sessionId)) {
-      this.pendingReady.delete(sessionId);
-      this.flushQueuedInputs(sessionId);
-      this.onReady?.(toPublicSession(session));
-    }
+}
+async function getProcessCwdUnix(pid) {
+  const output = await run("lsof", ["-p", String(pid), "-a", "-d", "cwd", "-Fn"]);
+  const match = output.match(/n(.+)/);
+  return match?.[1] ?? "";
+}
+async function getProcessArgsUnix(pid) {
+  return (await run("ps", ["-p", String(pid), "-o", "args="])).trim();
+}
+async function getProcessStartTimeUnix(pid) {
+  const raw = (await run("ps", ["-p", String(pid), "-o", "lstart="])).trim();
+  const d = new Date(raw);
+  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 [];
   }
-  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_fs4.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));
-    session.screen.dispose();
-    this.sessions.delete(sessionId);
-    this.queuedInputs.delete(sessionId);
-    this.firstChunkAt.delete(sessionId);
-    this.permissionOpen.delete(sessionId);
-    this.lastScreenQuestionKey.delete(sessionId);
-    this.shellPromptOpen.delete(sessionId);
+}
+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_path7.dirname)(exePath) : "";
+    return { cwd, args, startedAt };
+  } catch {
+    return null;
   }
-};
-function toPublicSession(s) {
-  return {
-    id: s.id,
-    projectPath: s.projectPath,
-    projectName: s.projectName,
-    branch: s.branch,
-    status: s.status,
-    startedAt: s.startedAt,
-    completedAt: s.completedAt,
-    promptCount: s.promptCount,
-    lastOutput: s.lastOutput,
-    ...s.failureReason != null && { failureReason: s.failureReason },
-    ...s.lastActivityAt != null && { lastActivityAt: s.lastActivityAt },
-    ...s.filePath != null && { filePath: s.filePath }
-  };
 }
-function stripAnsi(str) {
-  return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").replace(/\x1b\][^\x07]*\x07/g, "");
+function extractResumeId(args) {
+  const match = args.match(/--resume\s+(\S+)/);
+  return match?.[1] ?? null;
+}
+async function readGitBranch(dir) {
+  try {
+    return (await run("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: dir, timeout: 3e3 })).trim();
+  } catch {
+    return "";
+  }
 }
 
 // src/server.ts
@@ -1524,15 +2172,15 @@ var import_node_ws = require("@hono/node-ws");
 var import_client = require("@temporalio/client");
 var import_scanner2 = require("@threadbase-sh/scanner");
 var import_events = require("events");
-var import_fs11 = require("fs");
+var import_fs12 = require("fs");
 var import_promises5 = require("fs/promises");
 var import_http = require("http");
 var import_os6 = require("os");
-var import_path11 = require("path");
+var import_path13 = require("path");
 var import_readline = require("readline");
 
 // node_modules/nanoid/index.js
-var import_crypto3 = __toESM(require("crypto"), 1);
+var import_crypto4 = __toESM(require("crypto"), 1);
 
 // node_modules/nanoid/url-alphabet/index.js
 var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
@@ -1546,10 +2194,10 @@ var fillPool = (bytes) => {
   try {
     if (!pool || pool.length < bytes) {
       pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
-      import_crypto3.default.randomFillSync(pool);
+      import_crypto4.default.randomFillSync(pool);
       poolOffset = 0;
     } else if (poolOffset + bytes > pool.length) {
-      import_crypto3.default.randomFillSync(pool);
+      import_crypto4.default.randomFillSync(pool);
       poolOffset = 0;
     }
   } catch (e) {
@@ -2282,7 +2930,7 @@ var createHonoApp = (deps, upgradeWebSocket) => {
 
 // src/browse.ts
 var import_promises2 = require("fs/promises");
-var import_path6 = require("path");
+var import_path8 = require("path");
 var BrowsePathNotFoundError = class extends Error {
   constructor(message) {
     super(message);
@@ -2290,15 +2938,15 @@ var BrowsePathNotFoundError = class extends Error {
   }
 };
 async function resolveBrowsePath(browseRoot, relativePath) {
-  const normalizedRoot = (0, import_path6.resolve)(browseRoot);
+  const normalizedRoot = (0, import_path8.resolve)(browseRoot);
   let sanitized;
   if (process.platform !== "win32" && relativePath.startsWith("/") && relativePath.length > 1 && relativePath.includes("/", 1)) {
     sanitized = relativePath;
   } else {
     sanitized = relativePath.replace(/^[/\\]+/, "");
   }
-  const target = sanitized ? (0, import_path6.resolve)(normalizedRoot, sanitized) : normalizedRoot;
-  const rootPrefix = normalizedRoot.endsWith(import_path6.sep) ? normalizedRoot : `${normalizedRoot}${import_path6.sep}`;
+  const target = sanitized ? (0, import_path8.resolve)(normalizedRoot, sanitized) : normalizedRoot;
+  const rootPrefix = normalizedRoot.endsWith(import_path8.sep) ? normalizedRoot : `${normalizedRoot}${import_path8.sep}`;
   if (!target.startsWith(rootPrefix) && target !== normalizedRoot) {
     throw new Error("Path outside browse root");
   }
@@ -2320,7 +2968,7 @@ async function createDirectory(parentAbsolutePath, name) {
   if (name.includes("/") || name.includes("\\") || name === ".." || name === ".") {
     throw new Error("Invalid directory name");
   }
-  const target = (0, import_path6.join)(parentAbsolutePath, name);
+  const target = (0, import_path8.join)(parentAbsolutePath, name);
   try {
     const s = await (0, import_promises2.stat)(target);
     if (s.isDirectory()) throw new Error("Directory already exists");
@@ -2333,17 +2981,17 @@ async function createDirectory(parentAbsolutePath, name) {
 
 // src/conversation-cache.ts
 var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
-var import_fs7 = require("fs");
-var import_path8 = require("path");
+var import_fs8 = require("fs");
+var import_path10 = require("path");
 
 // src/db/sqlite-migrate.ts
-var import_fs5 = require("fs");
-var import_path7 = require("path");
+var import_fs6 = require("fs");
+var import_path9 = require("path");
 var import_url2 = require("url");
 var import_meta2 = {};
 function getMigrationsDir2() {
   if (typeof import_meta2 !== "undefined" && import_meta2.url) {
-    return (0, import_path7.dirname)((0, import_url2.fileURLToPath)(import_meta2.url));
+    return (0, import_path9.dirname)((0, import_url2.fileURLToPath)(import_meta2.url));
   }
   return __dirname;
 }
@@ -2355,8 +3003,8 @@ CREATE TABLE IF NOT EXISTS schema_migrations (
 `;
 function runSqliteMigrations(db, migrationsDir) {
   db.exec(SCHEMA_MIGRATIONS_SQL);
-  const dir = migrationsDir ?? (0, import_path7.join)(getMigrationsDir2(), "migrations");
-  const files = (0, import_fs5.readdirSync)(dir).filter((f) => f.endsWith(".sql")).sort();
+  const dir = migrationsDir ?? (0, import_path9.join)(getMigrationsDir2(), "migrations");
+  const files = (0, import_fs6.readdirSync)(dir).filter((f) => f.endsWith(".sql")).sort();
   const appliedRows = db.prepare("SELECT id FROM schema_migrations").all();
   const appliedSet = new Set(appliedRows.map((r) => r.id));
   const recordApplied = db.prepare("INSERT INTO schema_migrations (id, applied_at) VALUES (?, ?)");
@@ -2367,7 +3015,7 @@ function runSqliteMigrations(db, migrationsDir) {
       skipped.push(file);
       continue;
     }
-    const sql = (0, import_fs5.readFileSync)((0, import_path7.join)(dir, file), "utf-8");
+    const sql = (0, import_fs6.readFileSync)((0, import_path9.join)(dir, file), "utf-8");
     const tx = db.transaction(() => {
       db.exec(sql);
       recordApplied.run(file, (/* @__PURE__ */ new Date()).toISOString());
@@ -2378,16 +3026,8 @@ function runSqliteMigrations(db, migrationsDir) {
   return { applied, skipped };
 }
 
-// src/providers.ts
-var CLAUDE_CODE_PROVIDER = "claude-code";
-var CODEX_CLI_PROVIDER = "codex-cli";
-function isProviderResumable(provider, availabilityResumable) {
-  if (provider === CODEX_CLI_PROVIDER) return false;
-  return availabilityResumable;
-}
-
 // src/services/conversations/isAgentConversation.ts
-var import_fs6 = require("fs");
+var import_fs7 = require("fs");
 var DEFAULT_AGENT_ENTRYPOINTS = /* @__PURE__ */ new Set(["sdk-cli", "claude-vscode"]);
 var CHUNK_BYTES = 64 * 1024;
 var ENTRYPOINT_PROBE = `"entrypoint":`;
@@ -2409,12 +3049,12 @@ function isAgentFile(filePath, entrypoints = DEFAULT_AGENT_ENTRYPOINTS) {
   if (cached2 !== void 0) return cached2;
   let fd;
   try {
-    fd = (0, import_fs6.openSync)(filePath, "r");
+    fd = (0, import_fs7.openSync)(filePath, "r");
   } catch {
     return false;
   }
   try {
-    const fileSize = (0, import_fs6.statSync)(filePath).size;
+    const fileSize = (0, import_fs7.statSync)(filePath).size;
     if (fileSize === 0) {
       fileDecisionCache.set(key, false);
       return false;
@@ -2425,7 +3065,7 @@ function isAgentFile(filePath, entrypoints = DEFAULT_AGENT_ENTRYPOINTS) {
     let carry = "";
     while (offset < fileSize) {
       const toRead = Math.min(CHUNK_BYTES, fileSize - offset);
-      const got = (0, import_fs6.readSync)(fd, buf, 0, toRead, offset);
+      const got = (0, import_fs7.readSync)(fd, buf, 0, toRead, offset);
       if (got <= 0) break;
       const chunk = carry + buf.toString("utf8", 0, got);
       for (const marker of markers) {
@@ -2446,7 +3086,7 @@ function isAgentFile(filePath, entrypoints = DEFAULT_AGENT_ENTRYPOINTS) {
   } catch {
     return false;
   } finally {
-    (0, import_fs6.closeSync)(fd);
+    (0, import_fs7.closeSync)(fd);
   }
 }
 function parseAgentEntrypointsEnv(raw) {
@@ -2566,7 +3206,10 @@ var ConversationCache = class _ConversationCache {
           model         = excluded.model,
           account       = excluded.account,
           branch        = excluded.branch,
-          message_count = excluded.message_count,
+          -- message_count is incremented by live tailing but recounted from
+          -- scratch by a scanner rescan; a stale rescan must not carry a live
+          -- session's count backwards, so take the max instead of overwriting.
+          message_count = MAX(conversation_meta.message_count, excluded.message_count),
           last_activity = excluded.last_activity,
           first_message = excluded.first_message,
           last_message  = excluded.last_message,
@@ -2655,7 +3298,7 @@ var ConversationCache = class _ConversationCache {
     return this.agentEntrypoints;
   }
   static open(dbPath, tailSize = 10, migrationsDir, options) {
-    (0, import_fs7.mkdirSync)((0, import_path8.dirname)(dbPath), { recursive: true });
+    (0, import_fs8.mkdirSync)((0, import_path10.dirname)(dbPath), { recursive: true });
     const db = new import_better_sqlite3.default(dbPath);
     db.pragma("journal_mode = WAL");
     db.pragma("foreign_keys = ON");
@@ -2838,11 +3481,12 @@ var ConversationCache = class _ConversationCache {
         let mtimeMs = null;
         let fileSize = null;
         try {
-          const s = (0, import_fs7.statSync)(m.filePath);
+          const s = (0, import_fs8.statSync)(m.filePath);
           mtimeMs = s.mtimeMs;
           fileSize = s.size;
         } catch {
         }
+        const seq = ++this.tailSeq;
         this.stmts.upsertFull.run({
           id,
           file_path: m.filePath,
@@ -2857,7 +3501,7 @@ var ConversationCache = class _ConversationCache {
           first_message: m.firstMessage ? JSON.stringify(m.firstMessage) : null,
           last_message: m.lastMessage ? JSON.stringify(m.lastMessage) : null,
           preview: m.preview ?? null,
-          updated_at: 0,
+          updated_at: seq,
           mtime_ms: mtimeMs,
           file_size: fileSize,
           provider: m.provider ?? CLAUDE_CODE_PROVIDER
@@ -2890,8 +3534,8 @@ var ConversationCache = class _ConversationCache {
     let fileSize;
     let fd;
     try {
-      fileSize = (0, import_fs7.statSync)(filePath).size;
-      fd = (0, import_fs7.openSync)(filePath, "r");
+      fileSize = (0, import_fs8.statSync)(filePath).size;
+      fd = (0, import_fs8.openSync)(filePath, "r");
     } catch {
       return false;
     }
@@ -2904,7 +3548,7 @@ var ConversationCache = class _ConversationCache {
       while (pos > 0 && lines.length < this.tailSize * 4) {
         const toRead = Math.min(CHUNK, pos);
         pos -= toRead;
-        (0, import_fs7.readSync)(fd, buf, 0, toRead, pos);
+        (0, import_fs8.readSync)(fd, buf, 0, toRead, pos);
         const chunk = buf.subarray(0, toRead).toString("utf8");
         const combined = chunk + partial;
         const parts = combined.split("\n");
@@ -2915,7 +3559,7 @@ var ConversationCache = class _ConversationCache {
       }
       if (partial) lines.push(partial);
     } finally {
-      (0, import_fs7.closeSync)(fd);
+      (0, import_fs8.closeSync)(fd);
     }
     const msgs = [];
     for (let i = 0; i < lines.length && msgs.length < this.tailSize; i++) {
@@ -3074,9 +3718,25 @@ var ConversationCache = class _ConversationCache {
       this.fileIndex.clear();
     }
   }
-  invalidateByFilePath(filePath) {
+  /**
+   * Drop the cached row for a file. Two callers with opposite intent:
+   *  - a directory-watch "change" event (the file was appended to) — pass
+   *    `skipIfTailed: true`. A cached tail means the row is being actively
+   *    maintained from the file's real content by the live-tail
+   *    (updateFromLines) or warm-up path, fresher than any scanner-derived
+   *    view. Both watchers fire on the same append with no ordering guarantee;
+   *    without this guard the invalidate can land after the tail write and wipe
+   *    the just-cached row, flickering the conversation out of
+   *    /api/conversations on nearly every message (CRITICAL #2). The debounced
+   *    rescan still re-derives metadata, so skipping the eager drop loses
+   *    nothing.
+   *  - a genuine unlink (the file is gone) — leave `skipIfTailed` false so the
+   *    row is always removed, otherwise a deleted session ghosts in the cache.
+   */
+  invalidateByFilePath(filePath, opts) {
     const row = this.stmts.getIdByFilePath.get(filePath);
     if (!row) return null;
+    if (opts?.skipIfTailed && this.stmts.hasTail.get(row.id)) return null;
     this.invalidate(row.id);
     return row.id;
   }
@@ -3086,7 +3746,7 @@ var ConversationCache = class _ConversationCache {
    * `handleGetConversation` can still serve the cached tail even when the
    * JSONL has been deleted.
    */
-  pruneGhostFiles(exists = import_fs7.existsSync) {
+  pruneGhostFiles(exists = import_fs8.existsSync) {
     const rows = this.stmts.allFilePaths.all();
     const ghosts = [];
     const prune = this.db.transaction((ids) => {
@@ -3166,7 +3826,7 @@ var ConversationsRepository = class {
 };
 
 // src/db/repositories/projects.repository.ts
-var import_crypto4 = require("crypto");
+var import_crypto5 = require("crypto");
 
 // src/utils/canonicalizeProjectPath.ts
 function canonicalizeProjectPath(projectPath) {
@@ -3259,7 +3919,7 @@ var ProjectsRepository = class {
       });
       return rowToProject(this.getById.get(existing.id));
     }
-    const id = (0, import_crypto4.randomUUID)();
+    const id = (0, import_crypto5.randomUUID)();
     this.insert.run({
       id,
       path,
@@ -3315,23 +3975,23 @@ async function recordUpload(pool2, instanceId, row) {
 }
 
 // src/handlers/handleListProjects.ts
-var import_fs8 = require("fs");
+var import_fs9 = require("fs");
 var import_os5 = require("os");
-var import_path9 = require("path");
+var import_path11 = require("path");
 function decodeProjectPath(dirName) {
   return dirName.replace(/-/g, "/");
 }
 function handleListProjects(url, res) {
   const limit = Math.max(1, parseInt(url.searchParams.get("limit") ?? "50", 10) || 50);
   const offset = Math.max(0, parseInt(url.searchParams.get("offset") ?? "0", 10) || 0);
-  const projectsDir = (0, import_path9.join)((0, import_os5.homedir)(), ".claude", "projects");
+  const projectsDir = (0, import_path11.join)((0, import_os5.homedir)(), ".claude", "projects");
   let entries;
   try {
-    entries = (0, import_fs8.readdirSync)(projectsDir).map((dirName) => {
-      const fullPath = (0, import_path9.join)(projectsDir, dirName);
+    entries = (0, import_fs9.readdirSync)(projectsDir).map((dirName) => {
+      const fullPath = (0, import_path11.join)(projectsDir, dirName);
       let mtime = 0;
       try {
-        mtime = (0, import_fs8.statSync)(fullPath).mtimeMs;
+        mtime = (0, import_fs9.statSync)(fullPath).mtimeMs;
       } catch {
       }
       const path = decodeProjectPath(dirName);
@@ -3350,7 +4010,7 @@ function handleListProjects(url, res) {
 }
 
 // src/pair-store.ts
-var import_crypto5 = require("crypto");
+var import_crypto6 = require("crypto");
 var DEFAULT_TTL_SECONDS = 180;
 var SWEEP_INTERVAL_MS = 6e4;
 var PairTokenStore = class {
@@ -3365,7 +4025,7 @@ var PairTokenStore = class {
     }
   }
   mint() {
-    const token = `pt_${(0, import_crypto5.randomBytes)(16).toString("hex")}`;
+    const token = `pt_${(0, import_crypto6.randomBytes)(16).toString("hex")}`;
     const expiresAt = Date.now() + this.ttlMs;
     this.current = { token, expiresAt, used: false };
     return {
@@ -3426,7 +4086,7 @@ function seal(plaintext, recipientPublicKeyBase64) {
 
 // src/services/conversations/conversationWatcher.ts
 var import_chokidar = __toESM(require("chokidar"), 1);
-var import_fs9 = require("fs");
+var import_fs10 = require("fs");
 var import_promises3 = require("fs/promises");
 var ConversationWatcher = class {
   files = /* @__PURE__ */ new Map();
@@ -3447,7 +4107,7 @@ var ConversationWatcher = class {
     if (this.files.has(filePath)) return;
     let offset;
     try {
-      offset = (0, import_fs9.statSync)(filePath).size;
+      offset = (0, import_fs10.statSync)(filePath).size;
     } catch {
       offset = 0;
     }
@@ -3556,14 +4216,14 @@ var ConversationWatcher = class {
 };
 
 // src/services/conversations/pruneAgentConversations.ts
-var import_fs10 = require("fs");
+var import_fs11 = 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_fs10.existsSync)(row.file_path)) {
+    if (!(0, import_fs11.existsSync)(row.file_path)) {
       missing += 1;
       continue;
     }
@@ -3846,6 +4506,7 @@ function managedToResponse(s, ptyAttached) {
   return {
     id: s.id,
     conversationId: s.id,
+    provider: s.provider ?? CLAUDE_CODE_PROVIDER,
     status: s.status,
     projectPath: s.projectPath,
     projectName: s.projectName,
@@ -3871,13 +4532,15 @@ function managedToResponse(s, ptyAttached) {
     ...s.failureReason != null && { failureReason: s.failureReason },
     ...s.resumedFromConversationId != null && {
       resumedFromConversationId: s.resumedFromConversationId
-    }
+    },
+    ...s.boundConversationId != null && { boundConversationId: s.boundConversationId }
   };
 }
 function discoveredToResponse(d, conversationId) {
   return {
     id: conversationId,
     conversationId,
+    provider: CLAUDE_CODE_PROVIDER,
     status: "idle",
     projectPath: d.projectPath,
     projectName: d.projectName,
@@ -3893,10 +4556,10 @@ function discoveredToResponse(d, conversationId) {
 }
 
 // src/uploads.ts
-var import_crypto6 = require("crypto");
+var import_crypto7 = require("crypto");
 var import_promises4 = require("fs/promises");
 var import_heic_convert = __toESM(require("heic-convert"), 1);
-var import_path10 = require("path");
+var import_path12 = require("path");
 var UPLOAD_DIR_NAME = ".threadbase-uploads";
 var MAX_BYTES = 25 * 1024 * 1024;
 var HEIC_MIMES = /* @__PURE__ */ new Set(["image/heic", "image/heif"]);
@@ -3927,11 +4590,11 @@ async function saveUploadFile(input) {
     mimeType = "image/jpeg";
     originalName = originalName.replace(/\.(heic|heif)$/i, ".jpg");
   }
-  const id = `up_${(0, import_crypto6.randomBytes)(8).toString("hex")}`;
+  const id = `up_${(0, import_crypto7.randomBytes)(8).toString("hex")}`;
   const safeName = sanitizeFilename(originalName) || `file${MIME_TO_EXT[mimeType] ?? ""}`;
-  const dir = (0, import_path10.join)(input.projectPath, UPLOAD_DIR_NAME, input.sessionId);
+  const dir = (0, import_path12.join)(input.projectPath, UPLOAD_DIR_NAME, input.sessionId);
   await (0, import_promises4.mkdir)(dir, { recursive: true });
-  const filePath = (0, import_path10.join)(dir, `${Date.now()}-${id}-${safeName}`);
+  const filePath = (0, import_path12.join)(dir, `${Date.now()}-${id}-${safeName}`);
   await (0, import_promises4.writeFile)(filePath, buffer);
   return {
     id,
@@ -4232,10 +4895,10 @@ var StreamerServer = class {
     this.verbose = config.verbose ?? false;
     this.disableDb = config.disableDb ?? false;
     this.scanProfiles = config.scanProfiles;
-    this.codexRoots = config.codexRoots ?? [(0, import_path11.join)((0, import_os6.homedir)(), ".codex", "sessions")];
+    this.codexRoots = config.codexRoots ?? [(0, import_path13.join)((0, import_os6.homedir)(), ".codex", "sessions")];
     this.ptyGracePeriodMs = config.ptyGracePeriodMs ?? DEFAULT_PTY_GRACE_PERIOD_MS;
     this.defaultSystemPrompt = config.defaultSystemPrompt ?? DEFAULT_SYSTEM_PROMPT;
-    this.cacheDir = config.cacheDir ?? loadCacheDir() ?? (0, import_path11.join)((0, import_os6.homedir)(), ".threadbase", "cache");
+    this.cacheDir = config.cacheDir ?? loadCacheDir() ?? (0, import_path13.join)((0, import_os6.homedir)(), ".threadbase", "cache");
     this.tailSize = config.tailSize ?? loadTailSize() ?? 10;
     this.directoryDebounceMs = parseDirScanDebounceEnv(process.env.THREADBASE_DIR_SCAN_DEBOUNCE_MS) ?? config.directoryScanDebounceMs ?? 1e3;
     this.markScannerStaleDebounced = debounce(() => {
@@ -4302,7 +4965,7 @@ var StreamerServer = class {
         }
       },
       onConversationChanged: (filePath) => {
-        this.cache?.invalidateByFilePath(filePath);
+        this.cache?.invalidateByFilePath(filePath, { skipIfTailed: true });
         this.markScannerStaleDebounced();
         this.log.debug?.(`Scanner invalidated by directory event: ${filePath}`, {
           filePath,
@@ -4319,7 +4982,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 });
@@ -4400,7 +5063,7 @@ var StreamerServer = class {
         temporalClient,
         taskQueue: agentConfig.temporal.taskQueue
       });
-      const conversationsBaseDir = agentConfig.conversationsDir || (0, import_path11.join)((0, import_path11.dirname)(this.cacheDir), "conversations");
+      const conversationsBaseDir = agentConfig.conversationsDir || (0, import_path13.join)((0, import_path13.dirname)(this.cacheDir), "conversations");
       conversationWriter = createConversationWriter({
         baseDir: conversationsBaseDir
       });
@@ -4622,7 +5285,7 @@ var StreamerServer = class {
         });
         try {
           this.cache = ConversationCache.open(
-            (0, import_path11.join)(this.cacheDir, "cache.db"),
+            (0, import_path13.join)(this.cacheDir, "cache.db"),
             this.tailSize,
             void 0,
             {
@@ -4648,18 +5311,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_path11.join)(profile.configDir, "projects"));
+                this.fileWatcher.watchDirectory((0, import_path13.join)(profile.configDir, "projects"));
               }
             }
           } else {
-            this.fileWatcher.watchDirectory((0, import_path11.join)((0, import_os6.homedir)(), ".claude", "projects"));
+            this.fileWatcher.watchDirectory((0, import_path13.join)((0, import_os6.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 import_scanner2.ConversationScanner();
         this.allScanners.add(warmupScanner);
@@ -5146,17 +5810,17 @@ var StreamerServer = class {
     return this.getScanner();
   }
   findJsonlPath(uuid) {
-    const projectsDir = (0, import_path11.join)((0, import_os6.homedir)(), ".claude", "projects");
-    if (!(0, import_fs11.existsSync)(projectsDir)) return null;
+    const projectsDir = (0, import_path13.join)((0, import_os6.homedir)(), ".claude", "projects");
+    if (!(0, import_fs12.existsSync)(projectsDir)) return null;
     const filename = `${uuid}.jsonl`;
-    for (const dir of (0, import_fs11.readdirSync)(projectsDir)) {
-      const fp = (0, import_path11.join)(projectsDir, dir, filename);
-      if ((0, import_fs11.existsSync)(fp)) return fp;
-      const projectDir = (0, import_path11.join)(projectsDir, dir);
+    for (const dir of (0, import_fs12.readdirSync)(projectsDir)) {
+      const fp = (0, import_path13.join)(projectsDir, dir, filename);
+      if ((0, import_fs12.existsSync)(fp)) return fp;
+      const projectDir = (0, import_path13.join)(projectsDir, dir);
       try {
-        for (const sub of (0, import_fs11.readdirSync)(projectDir)) {
-          const subagentPath = (0, import_path11.join)(projectDir, sub, "subagents", filename);
-          if ((0, import_fs11.existsSync)(subagentPath)) return subagentPath;
+        for (const sub of (0, import_fs12.readdirSync)(projectDir)) {
+          const subagentPath = (0, import_path13.join)(projectDir, sub, "subagents", filename);
+          if ((0, import_fs12.existsSync)(subagentPath)) return subagentPath;
         }
       } catch {
       }
@@ -5165,7 +5829,7 @@ var StreamerServer = class {
   }
   async readCwdFromJsonl(filePath) {
     return new Promise((resolve2) => {
-      const rl = (0, import_readline.createInterface)({ input: (0, import_fs11.createReadStream)(filePath), crlfDelay: Infinity });
+      const rl = (0, import_readline.createInterface)({ input: (0, import_fs12.createReadStream)(filePath), crlfDelay: Infinity });
       let found = false;
       rl.on("line", (line) => {
         if (found) return;
@@ -5222,7 +5886,7 @@ var StreamerServer = class {
     if (!conv.filePath) return false;
     let mtimeMs = null;
     try {
-      mtimeMs = (0, import_fs11.statSync)(conv.filePath).mtimeMs;
+      mtimeMs = (0, import_fs12.statSync)(conv.filePath).mtimeMs;
     } catch {
       return false;
     }
@@ -5465,7 +6129,7 @@ var StreamerServer = class {
   handleGetSession(sessionId, res) {
     const session = this.sessionStore.get(sessionId, this.ptyAttachedIds());
     if (session) {
-      if (!(0, import_fs11.existsSync)(session.projectPath)) {
+      if (!(0, import_fs12.existsSync)(session.projectPath)) {
         session.failureReason = `Project directory not found: ${session.projectPath}`;
       }
       json(res, 200, session);
@@ -5505,7 +6169,10 @@ var StreamerServer = class {
       json(res, 400, { error: "Could not determine project path" });
       return;
     }
+    const cachedConvMeta = this.cache?.getMetaById(sessionId);
+    const provider = conv?.provider ?? cachedConvMeta?.provider ?? CLAUDE_CODE_PROVIDER;
     const session = await this.ptyManager.start(sessionId, {
+      provider,
       projectPath,
       projectName: body.projectName,
       branch: body.branch
@@ -5855,7 +6522,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_path11.join)((0, import_path11.dirname)(this.cacheDir), "conversations") : "",
+        conversationsDir: this.cacheDir ? (0, import_path13.join)((0, import_path13.dirname)(this.cacheDir), "conversations") : "",
         agentConfig: this.agentConfig
       });
       json(res, result.status, result.body);
@@ -5864,6 +6531,13 @@ var StreamerServer = class {
       }
       return;
     }
+    const body = await readBody(req);
+    const { path: relativePath, provider: requestedProvider, systemPrompt: clientPrompt } = body;
+    if (requestedProvider !== void 0 && !isProviderName(requestedProvider)) {
+      json(res, 400, { error: "Invalid provider" });
+      return;
+    }
+    const provider = requestedProvider ?? CLAUDE_CODE_PROVIDER;
     if (!this.browseRoot) {
       json(res, 403, {
         error: "File browsing not configured. Set browseRoot on the server.",
@@ -5871,8 +6545,6 @@ var StreamerServer = class {
       });
       return;
     }
-    const body = await readBody(req);
-    const { path: relativePath, systemPrompt: clientPrompt } = body;
     if (typeof relativePath !== "string") {
       json(res, 400, { error: "Missing path field" });
       return;
@@ -5893,21 +6565,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);
       json(res, 202, { id: session.id, status: "pending" });
-      this.watchForJsonl(session.id, resolvedPath);
+      if (provider === CODEX_CLI_PROVIDER) {
+        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
       });
-      json(res, 500, { error: message });
+      json(res, statusCode, { error: message });
     }
   }
   // ─── Project linking ─────────────────────────────────────────────
@@ -5960,9 +6638,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_path11.join)((0, import_os6.homedir)(), ".claude", "projects", encoded);
+    const projectsDir = (0, import_path13.join)((0, import_os6.homedir)(), ".claude", "projects", encoded);
     const expectedFile = `${sessionId}.jsonl`;
-    const filePath = (0, import_path11.join)(projectsDir, expectedFile);
+    const filePath = (0, import_path13.join)(projectsDir, expectedFile);
     const deadline = Date.now() + 12e4;
     let watcher = null;
     const cleanup = () => {
@@ -5980,12 +6658,12 @@ var StreamerServer = class {
         cleanup();
         return;
       }
-      let resolvedFilePath = (0, import_fs11.existsSync)(filePath) ? filePath : null;
-      if (!resolvedFilePath && (0, import_fs11.existsSync)(projectsDir)) {
+      let resolvedFilePath = (0, import_fs12.existsSync)(filePath) ? filePath : null;
+      if (!resolvedFilePath && (0, import_fs12.existsSync)(projectsDir)) {
         try {
           const now = Date.now();
-          const recent = (0, import_fs11.readdirSync)(projectsDir).filter((f) => f.endsWith(".jsonl")).map((f) => ({ f, mtime: (0, import_fs11.statSync)((0, import_path11.join)(projectsDir, f)).mtimeMs })).filter(({ mtime }) => now - mtime < 5e3).sort((a, b) => b.mtime - a.mtime)[0];
-          if (recent) resolvedFilePath = (0, import_path11.join)(projectsDir, recent.f);
+          const recent = (0, import_fs12.readdirSync)(projectsDir).filter((f) => f.endsWith(".jsonl")).map((f) => ({ f, mtime: (0, import_fs12.statSync)((0, import_path13.join)(projectsDir, f)).mtimeMs })).filter(({ mtime }) => now - mtime < 5e3).sort((a, b) => b.mtime - a.mtime)[0];
+          if (recent) resolvedFilePath = (0, import_path13.join)(projectsDir, recent.f);
         } catch {
         }
       }
@@ -5994,7 +6672,7 @@ var StreamerServer = class {
       this.sessionFileMap.set(sessionId, resolvedFilePath);
       this.fileWatcher.watch(resolvedFilePath);
       try {
-        const existing = (0, import_fs11.readFileSync)(resolvedFilePath, "utf8").split("\n").filter(Boolean);
+        const existing = (0, import_fs12.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) {
@@ -6020,11 +6698,126 @@ var StreamerServer = class {
     if (this.sessionFileMap.has(sessionId)) return;
     try {
       require("fs").mkdirSync(projectsDir, { recursive: true });
-      watcher = (0, import_fs11.watch)(projectsDir, tryWire);
+      watcher = (0, import_fs12.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_path13.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_fs12.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((s) => s.id !== sessionId && s.boundConversationId != null).map((s) => s.boundConversationId)
+      );
+      for (const root of this.codexRoots) {
+        const sessionsDir = (0, import_path13.join)(root, dateDir);
+        if (!(0, import_fs12.existsSync)(sessionsDir)) continue;
+        let candidateFiles;
+        try {
+          candidateFiles = (0, import_fs12.readdirSync)(sessionsDir).filter((f) => f.endsWith(".jsonl"));
+        } catch {
+          continue;
+        }
+        const nowMs = Date.now();
+        const recentCandidates = candidateFiles.map((f) => ({ f, mtime: (0, import_fs12.statSync)((0, import_path13.join)(sessionsDir, f)).mtimeMs })).filter(({ mtime }) => nowMs - mtime < 1e4).sort((a, b) => b.mtime - a.mtime);
+        for (const { f } of recentCandidates) {
+          const candidatePath = (0, import_path13.join)(sessionsDir, f);
+          const match = matchesProjectPath(candidatePath);
+          if (!match) continue;
+          if (boundElsewhere.has(match.id)) continue;
+          const codexSessionId = match.id;
+          cleanup();
+          this.sessionStore.updateManaged(sessionId, { boundConversationId: codexSessionId });
+          this.sessionFileMap.set(sessionId, candidatePath);
+          this.fileWatcher.watch(candidatePath);
+          try {
+            const existing = (0, import_fs12.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(url, res) {
     if (!this.browseRoot) {
       json(res, 403, {
@@ -6108,7 +6901,7 @@ var StreamerServer = class {
 };
 function classifyResumability(cwd) {
   if (!cwd) return { resumable: true };
-  if ((0, import_fs11.existsSync)(cwd)) return { resumable: true };
+  if ((0, import_fs12.existsSync)(cwd)) return { resumable: true };
   const ranInWorktree = /\/\.worktrees\//.test(cwd) || /\/\.claude\/worktrees\//.test(cwd);
   return {
     resumable: false,
@@ -6240,7 +7033,10 @@ function readBody(req) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CLAUDE_CODE_PROVIDER,
+  CODEX_CLI_PROVIDER,
   ConversationWatcher,
+  LiveSessionManager,
   PTYManager,
   SessionStore,
   StreamerServer,
@@ -6254,6 +7050,8 @@ function readBody(req) {
   generateApiKey,
   getDbConfig,
   isDbEnabled,
+  isProviderName,
+  isProviderResumable,
   loadOrCreateApiKey,
   maskConnectionString,
   readAgentConfig,