@threadbase-sh/streamer 1.23.0 → 1.24.0

package/dist/index.js

@@ -480,10 +480,50 @@ async function createPool(config) {
   return new Pool(poolConfig);
 }
 
-// src/process-discovery.ts
-import { execFile } from "child_process";
-import { platform as platform2 } from "os";
-import { basename, dirname as dirname3 } from "path";
+// src/live-session-manager.ts
+import { basename as basename3 } from "path";
+
+// src/codex-pty-runner.ts
+import { Terminal } from "@xterm/headless";
+import { randomUUID } from "crypto";
+import { existsSync as existsSync2 } from "fs";
+import { basename } from "path";
+
+// src/logger.ts
+import pino from "pino";
+var baseLogger = pino({
+  level: process.env.LOG_LEVEL ?? "info",
+  base: { service: "tb-streamer" },
+  timestamp: pino.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
 import { execFileSync } from "child_process";
@@ -549,188 +589,534 @@ function resolveClaudeExe() {
   _claudeExe = "claude";
   return _claudeExe;
 }
+var _codexExe;
+function resolveCodexExe() {
+  if (_codexExe !== void 0) return _codexExe;
+  if (isWindows) {
+    try {
+      const found = execFileSync("where.exe", ["codex"], {
+        encoding: "utf-8",
+        windowsHide: true,
+        timeout: 3e3
+      }).trim().split("\n")[0].trim();
+      if (found) {
+        _codexExe = found;
+        return _codexExe;
+      }
+    } catch {
+    }
+    const candidates = [
+      join4(homedir2(), ".local", "bin", "codex.exe"),
+      join4(
+        process.env.LOCALAPPDATA ?? join4(homedir2(), "AppData", "Local"),
+        "Microsoft",
+        "WindowsApps",
+        "codex.exe"
+      )
+    ];
+    for (const p of candidates) {
+      if (existsSync(p)) {
+        _codexExe = p;
+        return _codexExe;
+      }
+    }
+  } else {
+    try {
+      const found = execFileSync("/usr/bin/which", ["codex"], {
+        encoding: "utf-8",
+        timeout: 3e3
+      }).trim().split("\n")[0].trim();
+      if (found && existsSync(found)) {
+        _codexExe = found;
+        return _codexExe;
+      }
+    } catch {
+    }
+    const candidates = [
+      "/opt/homebrew/bin/codex",
+      "/usr/local/bin/codex",
+      join4(homedir2(), ".local", "bin", "codex")
+    ];
+    for (const p of candidates) {
+      if (existsSync(p)) {
+        _codexExe = p;
+        return _codexExe;
+      }
+    }
+  }
+  _codexExe = "codex";
+  return _codexExe;
+}
 
-// src/process-discovery.ts
-async function discoverClaudeProcesses() {
-  if (platform2() === "win32") return discoverWindows();
-  return discoverUnix();
+// 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 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: basename(cwd),
-          branch: await readGitBranch(cwd),
-          conversationId,
-          startedAt
-        };
-      } catch {
-        return null;
-      }
-    })
-  );
-  return results.filter((r) => r !== null);
+function isProviderResumable(_provider, availabilityResumable) {
+  return availabilityResumable;
 }
-async function discoverWindows() {
-  const pids = await getPidsWindows();
-  const results = await Promise.all(
-    pids.map(async (pid) => {
+
+// 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)}`;
+}
+var pty = null;
+async function loadPty() {
+  if (pty) return pty;
+  try {
+    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 createScreen() {
+  return new Terminal({
+    cols: PTY_COLS,
+    rows: PTY_ROWS,
+    scrollback: SCREEN_SCROLLBACK,
+    allowProposedApi: true
+  });
+}
+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 promise = this.doStart(sessionId, options).finally(() => {
+      this.startPromises.delete(sessionId);
+    });
+    this.startPromises.set(sessionId, promise);
+    return promise;
+  }
+  async doStart(sessionId, options) {
+    const nodePty = await loadPty();
+    const projectName = options.projectName ?? 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 = randomUUID();
+    const projectName = options.projectName ?? 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 {
-        const info = await getProcessInfoWindows(pid);
-        if (!info) return null;
-        return {
-          pid,
-          projectPath: info.cwd,
-          projectName: basename(info.cwd),
-          branch: await readGitBranch(info.cwd),
-          conversationId: extractResumeId(info.args),
-          startedAt: info.startedAt
-        };
+        session.process.kill();
       } catch {
-        return null;
-      }
-    })
-  );
-  return results.filter((r) => r !== null);
-}
-function run(cmd, args, opts = {}) {
-  return new Promise((resolve2, reject) => {
-    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 [];
-  }
-}
-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 [];
-  }
-}
-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 ? dirname3(exePath) : "";
-    return { cwd, args, startedAt };
-  } catch {
-    return null;
+      session.screen.dispose();
+    }
+    this.sessions.clear();
+    this.pendingReady.clear();
+    this.queuedInputs.clear();
+    this.trustGateAnswered.clear();
   }
-}
-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 "";
+  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
+      });
+    });
   }
-}
-
-// src/pty-manager.ts
-import { Terminal } from "@xterm/headless";
-import { randomUUID } from "crypto";
-import { existsSync as existsSync2 } from "fs";
-import { basename as basename2 } from "path";
-
-// src/logger.ts
-import pino from "pino";
-var baseLogger = pino({
-  level: process.env.LOG_LEVEL ?? "info",
-  base: { service: "tb-streamer" },
-  timestamp: pino.stdTimeFunctions.isoTime,
-  redact: {
-    paths: ["req.headers.authorization", "req.headers.cookie", 'req.headers["x-api-key"]'],
-    censor: "[redacted]"
+  // 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);
   }
-});
-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);
+  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 (!existsSync2(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
+import { Terminal as Terminal2 } from "@xterm/headless";
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync3 } from "fs";
+import { basename as basename2 } from "path";
 
 // src/services/questions/detectPermissionGate.ts
 var OSC_777_RE = /\x1b\]777;notify;Claude Code;[^\x07\x1b]*/;
@@ -889,28 +1275,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
@@ -918,11 +1304,11 @@ Original error: ${err}`
     );
   }
 }
-function createScreen() {
-  return new Terminal({
-    cols: PTY_COLS,
-    rows: PTY_ROWS,
-    scrollback: SCREEN_SCROLLBACK,
+function createScreen2() {
+  return new Terminal2({
+    cols: PTY_COLS2,
+    rows: PTY_ROWS2,
+    scrollback: SCREEN_SCROLLBACK2,
     allowProposedApi: true
   });
 }
@@ -971,6 +1357,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;
@@ -993,7 +1383,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 ?? basename2(options.projectPath);
     const proc = nodePty.spawn(
       resolveClaudeExe(),
@@ -1015,6 +1416,7 @@ var PTYManager = class {
     );
     const session = {
       id: sessionId,
+      provider: CLAUDE_CODE_PROVIDER,
       projectPath: options.projectPath,
       projectName,
       branch: options.branch ?? "",
@@ -1025,7 +1427,7 @@ var PTYManager = class {
       lastOutput: "",
       process: proc,
       outputBuffer: Buffer.alloc(0),
-      screen: createScreen()
+      screen: createScreen2()
     };
     this.sessions.set(sessionId, session);
     this.pendingReady.add(sessionId);
@@ -1036,14 +1438,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 = randomUUID();
+    const nodePty = await loadPty2();
+    const sessionId = randomUUID2();
     const projectName = options.projectName ?? basename2(options.projectPath);
     const args = [
       "--permission-mode",
@@ -1065,6 +1467,7 @@ var PTYManager = class {
     });
     const session = {
       id: sessionId,
+      provider: CLAUDE_CODE_PROVIDER,
       projectPath: options.projectPath,
       projectName,
       branch: "",
@@ -1075,7 +1478,7 @@ var PTYManager = class {
       lastOutput: "",
       process: proc,
       outputBuffer: Buffer.alloc(0),
-      screen: createScreen()
+      screen: createScreen2()
     };
     this.sessions.set(sessionId, session);
     this.pendingReady.add(sessionId);
@@ -1086,7 +1489,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.
@@ -1098,10 +1501,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);
@@ -1133,7 +1536,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();
@@ -1146,13 +1549,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"
       }
@@ -1167,13 +1570,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,
@@ -1231,7 +1634,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);
@@ -1262,13 +1665,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()) {
@@ -1300,7 +1703,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,
@@ -1309,17 +1712,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) {
@@ -1422,11 +1825,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) {
@@ -1436,13 +1839,13 @@ var PTYManager = class {
     session.status = "idle";
     const elapsedMs = session.completedAt.getTime() - session.startedAt.getTime();
     if (exitCode !== 0 && elapsedMs < 2e3 && session.lastOutput === "") {
-      if (!existsSync2(session.projectPath)) {
+      if (!existsSync3(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);
@@ -1452,9 +1855,10 @@ var PTYManager = class {
     this.shellPromptOpen.delete(sessionId);
   }
 };
-function toPublicSession(s) {
+function toPublicSession2(s) {
   return {
     id: s.id,
+    provider: s.provider ?? CLAUDE_CODE_PROVIDER,
     projectPath: s.projectPath,
     projectName: s.projectName,
     branch: s.branch,
@@ -1468,10 +1872,249 @@ function toPublicSession(s) {
     ...s.filePath != null && { filePath: s.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_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 ${basename3(projectPath)}`
+    );
+    err.statusCode = 501;
+    throw err;
+  }
+};
+
+// src/process-discovery.ts
+import { execFile } from "child_process";
+import { platform as platform2 } from "os";
+import { basename as basename4, dirname as dirname3 } from "path";
+async function discoverClaudeProcesses() {
+  if (platform2() === "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: basename4(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: basename4(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) => {
+    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 [];
+  }
+}
+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 [];
+  }
+}
+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 ? dirname3(exePath) : "";
+    return { cwd, args, startedAt };
+  } catch {
+    return null;
+  }
+}
+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
 import { createNodeWebSocket } from "@hono/node-ws";
 import { Connection, Client as TemporalClient } from "@temporalio/client";
@@ -1486,7 +2129,7 @@ import {
 import { EventEmitter } from "events";
 import {
   createReadStream,
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   watch as fsWatch,
   readdirSync as readdirSync4,
   readFileSync as readFileSync6,
@@ -1678,7 +2321,7 @@ async function handleSendAgentInput(sessionId, body, deps) {
 }
 
 // src/agent/handle-start-agent-session.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { join as join5 } from "path";
 function validateBody(body) {
   if (body === null || body === void 0 || typeof body !== "object") {
@@ -1710,7 +2353,7 @@ async function handleStartAgentSession(body, deps) {
   let conversationId = parsed.conversationId;
   if (conversationId) {
     const jsonlPath = join5(deps.conversationsDir, `${conversationId}.jsonl`);
-    if (!existsSync3(jsonlPath)) {
+    if (!existsSync4(jsonlPath)) {
       return {
         status: 404,
         body: agentErrorResponse(
@@ -2300,7 +2943,7 @@ async function createDirectory(parentAbsolutePath, name) {
 
 // src/conversation-cache.ts
 import Database from "better-sqlite3";
-import { closeSync as closeSync2, existsSync as existsSync4, mkdirSync as mkdirSync2, openSync as openSync2, readSync as readSync2, statSync as statSync2 } from "fs";
+import { closeSync as closeSync2, existsSync as existsSync5, mkdirSync as mkdirSync2, openSync as openSync2, readSync as readSync2, statSync as statSync2 } from "fs";
 import { dirname as dirname6 } from "path";
 
 // src/db/sqlite-migrate.ts
@@ -2344,14 +2987,6 @@ 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
 import { closeSync, openSync, readSync, statSync } from "fs";
 var DEFAULT_AGENT_ENTRYPOINTS = /* @__PURE__ */ new Set(["sdk-cli", "claude-vscode"]);
@@ -2532,7 +3167,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,
@@ -2809,6 +3447,7 @@ var ConversationCache = class _ConversationCache {
           fileSize = s.size;
         } catch {
         }
+        const seq = ++this.tailSeq;
         this.stmts.upsertFull.run({
           id,
           file_path: m.filePath,
@@ -2823,7 +3462,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
@@ -3040,9 +3679,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;
   }
@@ -3052,7 +3707,7 @@ var ConversationCache = class _ConversationCache {
    * `handleGetConversation` can still serve the cached tail even when the
    * JSONL has been deleted.
    */
-  pruneGhostFiles(exists = existsSync4) {
+  pruneGhostFiles(exists = existsSync5) {
     const rows = this.stmts.allFilePaths.all();
     const ghosts = [];
     const prune = this.db.transaction((ids) => {
@@ -3132,7 +3787,7 @@ var ConversationsRepository = class {
 };
 
 // src/db/repositories/projects.repository.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 
 // src/utils/canonicalizeProjectPath.ts
 function canonicalizeProjectPath(projectPath) {
@@ -3225,7 +3880,7 @@ var ProjectsRepository = class {
       });
       return rowToProject(this.getById.get(existing.id));
     }
-    const id = randomUUID2();
+    const id = randomUUID3();
     this.insert.run({
       id,
       path,
@@ -3522,14 +4177,14 @@ var ConversationWatcher = class {
 };
 
 // src/services/conversations/pruneAgentConversations.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "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 (!existsSync5(row.file_path)) {
+    if (!existsSync6(row.file_path)) {
       missing += 1;
       continue;
     }
@@ -3812,6 +4467,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,
@@ -3837,13 +4493,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,
@@ -4268,7 +4926,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,
@@ -4285,7 +4943,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 });
@@ -4622,10 +5280,11 @@ var StreamerServer = class {
           }
         } 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);
@@ -5113,16 +5772,16 @@ var StreamerServer = class {
   }
   findJsonlPath(uuid) {
     const projectsDir = join12(homedir5(), ".claude", "projects");
-    if (!existsSync6(projectsDir)) return null;
+    if (!existsSync7(projectsDir)) return null;
     const filename = `${uuid}.jsonl`;
     for (const dir of readdirSync4(projectsDir)) {
       const fp = join12(projectsDir, dir, filename);
-      if (existsSync6(fp)) return fp;
+      if (existsSync7(fp)) return fp;
       const projectDir = join12(projectsDir, dir);
       try {
         for (const sub of readdirSync4(projectDir)) {
           const subagentPath = join12(projectDir, sub, "subagents", filename);
-          if (existsSync6(subagentPath)) return subagentPath;
+          if (existsSync7(subagentPath)) return subagentPath;
         }
       } catch {
       }
@@ -5431,7 +6090,7 @@ var StreamerServer = class {
   handleGetSession(sessionId, res) {
     const session = this.sessionStore.get(sessionId, this.ptyAttachedIds());
     if (session) {
-      if (!existsSync6(session.projectPath)) {
+      if (!existsSync7(session.projectPath)) {
         session.failureReason = `Project directory not found: ${session.projectPath}`;
       }
       json(res, 200, session);
@@ -5471,7 +6130,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
@@ -5830,6 +6492,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.",
@@ -5837,8 +6506,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;
@@ -5859,21 +6526,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 ─────────────────────────────────────────────
@@ -5946,8 +6619,8 @@ var StreamerServer = class {
         cleanup();
         return;
       }
-      let resolvedFilePath = existsSync6(filePath) ? filePath : null;
-      if (!resolvedFilePath && existsSync6(projectsDir)) {
+      let resolvedFilePath = existsSync7(filePath) ? filePath : null;
+      if (!resolvedFilePath && existsSync7(projectsDir)) {
         try {
           const now = Date.now();
           const recent = readdirSync4(projectsDir).filter((f) => f.endsWith(".jsonl")).map((f) => ({ f, mtime: statSync5(join12(projectsDir, f)).mtimeMs })).filter(({ mtime }) => now - mtime < 5e3).sort((a, b) => b.mtime - a.mtime)[0];
@@ -5991,6 +6664,121 @@ var StreamerServer = class {
     } 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 = join12(
+      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 = readFileSync6(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 = join12(root, dateDir);
+        if (!existsSync7(sessionsDir)) continue;
+        let candidateFiles;
+        try {
+          candidateFiles = readdirSync4(sessionsDir).filter((f) => f.endsWith(".jsonl"));
+        } catch {
+          continue;
+        }
+        const nowMs = Date.now();
+        const recentCandidates = candidateFiles.map((f) => ({ f, mtime: statSync5(join12(sessionsDir, f)).mtimeMs })).filter(({ mtime }) => nowMs - mtime < 1e4).sort((a, b) => b.mtime - a.mtime);
+        for (const { f } of recentCandidates) {
+          const candidatePath = join12(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 = readFileSync6(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, {
@@ -6074,7 +6862,7 @@ var StreamerServer = class {
 };
 function classifyResumability(cwd) {
   if (!cwd) return { resumable: true };
-  if (existsSync6(cwd)) return { resumable: true };
+  if (existsSync7(cwd)) return { resumable: true };
   const ranInWorktree = /\/\.worktrees\//.test(cwd) || /\/\.claude\/worktrees\//.test(cwd);
   return {
     resumable: false,
@@ -6205,7 +6993,10 @@ function readBody(req) {
   });
 }
 export {
+  CLAUDE_CODE_PROVIDER,
+  CODEX_CLI_PROVIDER,
   ConversationWatcher,
+  LiveSessionManager,
   PTYManager,
   SessionStore,
   StreamerServer,
@@ -6219,6 +7010,8 @@ export {
   generateApiKey,
   getDbConfig,
   isDbEnabled,
+  isProviderName,
+  isProviderResumable,
   loadOrCreateApiKey,
   maskConnectionString,
   readAgentConfig,