codeam-cli 2.15.2 → 2.15.6

package/dist/index.js

@@ -386,8 +386,8 @@ var import_qrcode_terminal = __toESM(require("qrcode-terminal"));
 // package.json
 var package_default = {
   name: "codeam-cli",
-  version: "2.15.2",
-  description: "Remote control Claude Code (and other AI coding agents) from your mobile phone. Pair your device, send prompts, stream responses in real-time, and approve commands \u2014 from anywhere.",
+  version: "2.15.6",
+  description: "Workflow-continuity bridge for AI coding agents. Wrap Claude Code or Codex in a PTY and supervise, approve, and redirect the session from any device \u2014 async. The terminal companion for CodeAgent Mobile.",
   type: "commonjs",
   main: "dist/index.js",
   bin: {
@@ -410,29 +410,29 @@ var package_default = {
   keywords: [
     "claude",
     "claude-code",
-    "claude-code-mobile",
     "ai",
     "ai-agent",
     "ai-coding",
-    "ai-pair-programming",
+    "ai-workflow",
+    "ai-workflow-continuity",
+    "async-ai-productivity",
+    "remote-ai-supervision",
     "cli",
-    "remote-control",
-    "remote-development",
-    "mobile-ide",
-    "mobile-coding",
-    "pair-programming",
+    "developer-tools",
+    "devtools",
     "codeagent",
     "codeam",
     "anthropic",
+    "openai-codex",
     "cursor",
     "copilot",
     "jetbrains",
     "vscode",
+    "windsurf",
     "mcp",
-    "code-from-phone",
-    "afk-coding",
-    "remote-pair-programming",
-    "agent-control"
+    "remote-development",
+    "agent-control",
+    "agent-operations"
   ],
   homepage: "https://codeagent-mobile.com",
   bugs: {
@@ -456,6 +456,7 @@ var package_default = {
   },
   dependencies: {
     "@clack/prompts": "^1.2.0",
+    chokidar: "^3.6.0",
     picocolors: "^1.1.0",
     "qrcode-terminal": "^0.12.0",
     ws: "^8.18.0",
@@ -520,6 +521,34 @@ function vercelBypassHeader() {
   return token ? { "x-vercel-protection-bypass": token } : {};
 }
 
+// src/lib/git-branch.ts
+var import_child_process = require("child_process");
+function detectCurrentBranch(cwd = process.cwd()) {
+  try {
+    const raw = _execSeam.exec("git branch --show-current", {
+      cwd,
+      // 1 s ceiling is comfortably above normal git latency (<50 ms
+      // on a healthy repo) and well below the pair POST's 10 s budget.
+      timeout: 1e3,
+      // Swallow stderr — non-git directories print "fatal: not a git
+      // repository" to stderr and we don't want that on the CLI's
+      // own stderr while pairing.
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf8"
+    });
+    const trimmed = raw.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  } catch {
+    return null;
+  }
+}
+var _execSeam = {
+  exec: (cmd, opts) => {
+    const out = (0, import_child_process.execSync)(cmd, opts);
+    return typeof out === "string" ? out : out.toString("utf8");
+  }
+};
+
 // src/lib/poll-delay.ts
 var MAX_DELAY_MS = 3e4;
 function computePollDelay({ baseMs, failures }) {
@@ -534,12 +563,14 @@ async function requestCode(pluginId) {
   try {
     const runtime = process.env.CODESPACES === "true" ? "github-codespaces" : "local";
     const codespaceName = process.env.CODESPACE_NAME;
+    const branch = detectCurrentBranch();
     const result = await _transport.postJson(`${API_BASE}/api/pairing/code`, {
       pluginId,
       ideName: "Terminal (codeam-cli)",
       ideVersion: package_default.version,
       hostname: os2.hostname(),
       runtime,
+      branch,
       ...codespaceName ? { codespaceName } : {}
     });
     const data = result?.data;
@@ -982,7 +1013,7 @@ var CommandRelayService = class {
 };
 
 // src/services/pty/unix.strategy.ts
-var import_child_process = require("child_process");
+var import_child_process2 = require("child_process");
 var fs4 = __toESM(require("fs"));
 var os4 = __toESM(require("os"));
 var path4 = __toESM(require("path"));
@@ -1086,7 +1117,7 @@ var UnixPtyStrategy = class {
     const rows = process.stdout.rows || 50;
     this.helperPath = path4.join(os4.tmpdir(), "codeam-pty-helper.py");
     fs4.writeFileSync(this.helperPath, PYTHON_PTY_HELPER, { mode: 420 });
-    this.proc = (0, import_child_process.spawn)(python, [this.helperPath, cmd, ...args2], {
+    this.proc = (0, import_child_process2.spawn)(python, [this.helperPath, cmd, ...args2], {
       stdio: ["pipe", "pipe", "inherit"],
       cwd,
       env: {
@@ -1151,7 +1182,7 @@ var UnixPtyStrategy = class {
    * are NOT interpreted by /bin/sh.
    */
   spawnDirect(cmd, cwd, args2 = []) {
-    this.proc = (0, import_child_process.spawn)(cmd, args2, {
+    this.proc = (0, import_child_process2.spawn)(cmd, args2, {
       stdio: ["pipe", "inherit", "inherit"],
       cwd,
       env: process.env,
@@ -1223,7 +1254,7 @@ var UnixPtyStrategy = class {
 };
 
 // src/services/pty/windows.strategy.ts
-var import_child_process2 = require("child_process");
+var import_child_process3 = require("child_process");
 var WindowsPtyStrategy = class {
   constructor(opts) {
     this.opts = opts;
@@ -1231,7 +1262,7 @@ var WindowsPtyStrategy = class {
   opts;
   proc = null;
   spawn(cmd, cwd, args2 = []) {
-    this.proc = (0, import_child_process2.spawn)(cmd, args2, {
+    this.proc = (0, import_child_process3.spawn)(cmd, args2, {
       stdio: ["pipe", "pipe", "inherit"],
       cwd,
       env: {
@@ -1407,7 +1438,7 @@ var WindowsConPtyStrategy = class _WindowsConPtyStrategy {
 };
 
 // src/services/claude-installer.ts
-var import_child_process3 = require("child_process");
+var import_child_process4 = require("child_process");
 var path6 = __toESM(require("path"));
 var os5 = __toESM(require("os"));
 
@@ -3360,7 +3391,7 @@ function runInstaller() {
     "irm https://claude.ai/install.ps1 | iex"
   ] : ["-c", "curl -fsSL https://claude.ai/install.sh | bash"];
   return new Promise((resolve2) => {
-    const proc = (0, import_child_process3.spawn)(cmd, args2, { stdio: "inherit" });
+    const proc = (0, import_child_process4.spawn)(cmd, args2, { stdio: "inherit" });
     proc.on("error", (err) => {
       console.error(`
   \u2717 Installer failed to launch: ${err.message}`);
@@ -3659,7 +3690,7 @@ var AgentService = class {
 var fs5 = __toESM(require("fs"));
 var os6 = __toESM(require("os"));
 var path8 = __toESM(require("path"));
-var import_child_process4 = require("child_process");
+var import_child_process5 = require("child_process");
 var HELPER_SCRIPT = `import os,pty,sys,select,signal,struct,fcntl,termios,errno
 m,s=pty.openpty()
 try:
@@ -3728,7 +3759,7 @@ async function fetchClaudeQuota() {
       resolve2(null);
       return;
     }
-    const proc = (0, import_child_process4.spawn)(python, [helperPath, claudeCmd, "--tools", ""], {
+    const proc = (0, import_child_process5.spawn)(python, [helperPath, claudeCmd, "--tools", ""], {
       stdio: ["pipe", "pipe", "ignore"],
       cwd: process.cwd(),
       env: { ...process.env, TERM: "dumb", COLUMNS: "120", LINES: "30" }
@@ -4191,12 +4222,12 @@ var os9 = __toESM(require("os"));
 var path11 = __toESM(require("path"));
 
 // src/agents/claude/credentials.ts
-var import_child_process5 = require("child_process");
+var import_child_process6 = require("child_process");
 var fs7 = __toESM(require("fs"));
 var os8 = __toESM(require("os"));
 var path10 = __toESM(require("path"));
 var import_util = require("util");
-var execFileP = (0, import_util.promisify)(import_child_process5.execFile);
+var execFileP = (0, import_util.promisify)(import_child_process6.execFile);
 async function detectLocalClaudeCredentials() {
   const localClaudeDir = path10.join(os8.homedir(), ".claude");
   const flat = path10.join(localClaudeDir, ".credentials.json");
@@ -6125,6 +6156,886 @@ var HistoryService = class _HistoryService {
   }
 };
 
+// src/services/file-watcher.service.ts
+var import_child_process7 = require("child_process");
+var path15 = __toESM(require("path"));
+
+// src/services/file-watcher/diff-parser.ts
+var HUNK_HEADER_RE = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/;
+function parseUnifiedDiff(diff) {
+  if (!diff || diff.trim().length === 0) {
+    return {
+      fileStatus: "modified",
+      hunks: [],
+      totalLinesAdded: 0,
+      totalLinesRemoved: 0
+    };
+  }
+  const rawLines = diff.split(/\r?\n/);
+  const fileStatus = detectFileStatus(rawLines);
+  const hunks = [];
+  let current = null;
+  let oldLine = 0;
+  let newLine = 0;
+  let totalAdded = 0;
+  let totalRemoved = 0;
+  for (const raw of rawLines) {
+    if (raw.startsWith("@@")) {
+      const match = raw.match(HUNK_HEADER_RE);
+      if (!match) continue;
+      if (current) hunks.push(current);
+      oldLine = parseInt(match[1], 10);
+      newLine = parseInt(match[2], 10);
+      current = {
+        header: raw,
+        lines: [],
+        linesAdded: 0,
+        linesRemoved: 0
+      };
+      continue;
+    }
+    if (current === null) continue;
+    if (raw.startsWith("\\ No newline")) continue;
+    if (raw.startsWith("+")) {
+      current.lines.push({ type: "add", lineNumber: newLine, text: raw.slice(1) });
+      current.linesAdded += 1;
+      totalAdded += 1;
+      newLine += 1;
+      continue;
+    }
+    if (raw.startsWith("-")) {
+      current.lines.push({ type: "remove", lineNumber: oldLine, text: raw.slice(1) });
+      current.linesRemoved += 1;
+      totalRemoved += 1;
+      oldLine += 1;
+      continue;
+    }
+    if (raw.startsWith(" ")) {
+      current.lines.push({ type: "context", lineNumber: newLine, text: raw.slice(1) });
+      newLine += 1;
+      oldLine += 1;
+      continue;
+    }
+  }
+  if (current) hunks.push(current);
+  return {
+    fileStatus,
+    hunks,
+    totalLinesAdded: totalAdded,
+    totalLinesRemoved: totalRemoved
+  };
+}
+function detectFileStatus(rawLines) {
+  for (const line of rawLines) {
+    if (line.startsWith("@@")) break;
+    if (line.startsWith("new file mode")) return "added";
+    if (line.startsWith("deleted file mode")) return "deleted";
+    if (line.startsWith("rename from ") || line.startsWith("rename to ")) {
+      return "renamed";
+    }
+    if (line.startsWith("--- /dev/null")) return "added";
+    if (line.startsWith("+++ /dev/null")) return "deleted";
+  }
+  return "modified";
+}
+
+// src/services/file-watcher/transport.ts
+var http5 = __toESM(require("http"));
+var https5 = __toESM(require("https"));
+var _transport3 = {
+  post: _post2
+};
+function _post2(url, headers, payload) {
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    const u2 = new URL(url);
+    const lib = u2.protocol === "https:" ? https5 : http5;
+    const req = lib.request(
+      {
+        hostname: u2.hostname,
+        port: u2.port || (u2.protocol === "https:" ? 443 : 80),
+        path: u2.pathname + u2.search,
+        method: "POST",
+        headers: {
+          ...headers,
+          ...vercelBypassHeader(),
+          "Content-Length": Buffer.byteLength(payload)
+        },
+        timeout: 8e3
+      },
+      (res) => {
+        let body = "";
+        res.on("data", (c2) => {
+          body += c2.toString();
+        });
+        res.on("end", () => {
+          if (settled) return;
+          settled = true;
+          resolve2({ statusCode: res.statusCode ?? 0, body });
+        });
+      }
+    );
+    req.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      reject(err);
+    });
+    req.on("timeout", () => {
+      req.destroy();
+    });
+    req.write(payload);
+    req.end();
+  });
+}
+
+// src/services/file-watcher.service.ts
+var API_BASE5 = process.env.CODEAM_API_URL ?? "https://codeagent-mobile-api.vercel.app";
+var DEBOUNCE_MS = 250;
+var MAX_RETRIES = 2;
+var RETRY_BACKOFF_MS = 300;
+var FileWatcherService = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.apiBase = opts.apiBaseUrl ?? API_BASE5;
+  }
+  opts;
+  watcher = null;
+  pending = /* @__PURE__ */ new Map();
+  apiBase;
+  stopped = false;
+  /**
+   * Start watching `opts.workingDir`. Idempotent (second call is a
+   * no-op). Resolves once chokidar's initial scan completes; that
+   * way the `start.ts` orchestrator can sequence "agent up → watcher
+   * ready" deterministically if it wants to, though today it
+   * doesn't await this.
+   */
+  async start() {
+    if (this.watcher) return;
+    if (this.stopped) {
+      throw new Error("FileWatcherService has already been stopped \u2014 re-instantiate to restart.");
+    }
+    let chokidar;
+    try {
+      chokidar = require("chokidar");
+    } catch (err) {
+      log.warn(
+        "fileWatcher",
+        `chokidar unavailable \u2014 file change emission disabled`,
+        err
+      );
+      return;
+    }
+    const watcher = chokidar.watch(this.opts.workingDir, {
+      ignored: [
+        /(^|[\\/])\../,
+        // dot-files & dot-dirs (.git, .next, .expo, .DS_Store, …)
+        /node_modules/,
+        /dist/,
+        /build/,
+        /out/,
+        /coverage/,
+        /\.turbo/,
+        /\.cache/,
+        /\.parcel-cache/,
+        // Build outputs that aren't a typical "dist" target
+        /target\//,
+        /__pycache__/
+      ],
+      ignoreInitial: true,
+      // we only care about post-start changes
+      persistent: true,
+      awaitWriteFinish: {
+        // Coalesces rapid sequential writes (npm install spam, build
+        // tools emitting bursts). Lower than chokidar's default so
+        // the user sees their Files screen update within 0.5 s of
+        // saving.
+        stabilityThreshold: 150,
+        pollInterval: 50
+      }
+    });
+    watcher.on("add", (filePath) => this.schedule(filePath, "add"));
+    watcher.on("change", (filePath) => this.schedule(filePath, "change"));
+    watcher.on("unlink", (filePath) => this.schedule(filePath, "unlink"));
+    this.watcher = watcher;
+    log.info(
+      "fileWatcher",
+      `watching ${this.opts.workingDir} for session=${this.opts.sessionId.slice(0, 8)}`
+    );
+  }
+  /**
+   * Stop watching. Idempotent — safe to call multiple times. After
+   * stop, the instance is dead; create a new one to resume. (This
+   * matches the `OutputService` / `CommandRelayService` style.)
+   */
+  async stop() {
+    if (this.stopped) return;
+    this.stopped = true;
+    for (const entry of this.pending.values()) {
+      clearTimeout(entry.timer);
+    }
+    this.pending.clear();
+    if (this.watcher) {
+      try {
+        await this.watcher.close();
+      } catch (err) {
+        log.warn("fileWatcher", "error closing chokidar", err);
+      }
+      this.watcher = null;
+    }
+    log.info("fileWatcher", `stopped (session=${this.opts.sessionId.slice(0, 8)})`);
+  }
+  /**
+   * Coalesce rapid writes per-file. Each fresh event resets the
+   * 250 ms debounce timer. When the timer fires, we compute the
+   * diff once and emit.
+   *
+   * `unlink` events bypass the diff path — we emit a synthetic
+   * deletion directly because `git diff <path>` for a removed file
+   * produces a diff that's already encoded as a deletion in
+   * `parseUnifiedDiff`, but in practice the file is gone and the
+   * synthetic path is simpler and avoids a race with git's index.
+   */
+  schedule(absPath, changeType) {
+    if (this.stopped) return;
+    const existing = this.pending.get(absPath);
+    if (existing) clearTimeout(existing.timer);
+    const timer = setTimeout(() => {
+      this.pending.delete(absPath);
+      void this.emitForFile(absPath, changeType);
+    }, DEBOUNCE_MS);
+    this.pending.set(absPath, {
+      lastEventAt: Date.now(),
+      timer,
+      changeType
+    });
+  }
+  /**
+   * Visible for tests — lets vitest pump a synthetic file event
+   * through the debounce + diff + emit pipeline without spinning up
+   * a real chokidar watcher.
+   */
+  /* @internal */
+  _scheduleForTest(absPath, changeType) {
+    this.schedule(absPath, changeType);
+  }
+  async emitForFile(absPath, changeType) {
+    if (this.stopped) return;
+    const relPath = path15.relative(this.opts.workingDir, absPath);
+    if (!relPath || relPath.startsWith("..")) {
+      return;
+    }
+    let diffText = "";
+    let fileStatus = "modified";
+    if (changeType === "unlink") {
+      const diff = await this.gitDiff(relPath);
+      if (diff !== null && diff.trim().length > 0) {
+        diffText = diff;
+      } else {
+        await this.postFileChanged({
+          sessionId: this.opts.sessionId,
+          pluginId: this.opts.pluginId,
+          filePath: relPath,
+          fileStatus: "deleted",
+          linesAdded: 0,
+          linesRemoved: 0,
+          hunkCount: 0
+        });
+        return;
+      }
+      fileStatus = "deleted";
+    } else {
+      const diff = await this.gitDiff(relPath);
+      if (diff === null) {
+        log.warn(
+          "fileWatcher",
+          `git diff failed for ${relPath} \u2014 emitting file-changed only`
+        );
+        await this.postFileChanged({
+          sessionId: this.opts.sessionId,
+          pluginId: this.opts.pluginId,
+          filePath: relPath,
+          fileStatus: changeType === "add" ? "added" : "modified",
+          linesAdded: 0,
+          linesRemoved: 0,
+          hunkCount: 0
+        });
+        return;
+      }
+      diffText = diff;
+    }
+    const parsed = parseUnifiedDiff(diffText);
+    const finalStatus = parsed.fileStatus !== "modified" ? parsed.fileStatus : changeType === "add" ? "added" : changeType === "unlink" ? "deleted" : fileStatus;
+    const reviewStatus = parsed.hunks.length > 0 ? "awaiting_review" : void 0;
+    await this.postFileChanged({
+      sessionId: this.opts.sessionId,
+      pluginId: this.opts.pluginId,
+      filePath: relPath,
+      fileStatus: finalStatus,
+      linesAdded: parsed.totalLinesAdded,
+      linesRemoved: parsed.totalLinesRemoved,
+      hunkCount: parsed.hunks.length,
+      reviewStatus
+    });
+    for (const hunk of parsed.hunks) {
+      await this.postReviewHunk({
+        sessionId: this.opts.sessionId,
+        pluginId: this.opts.pluginId,
+        filePath: relPath,
+        fileStatus: finalStatus,
+        hunkHeader: hunk.header,
+        lines: hunk.lines,
+        linesAdded: hunk.linesAdded,
+        linesRemoved: hunk.linesRemoved
+      });
+    }
+  }
+  /**
+   * Compute the unified diff for a single path relative to the
+   * working dir. Returns `null` when git is unavailable or the cwd
+   * is not a repo. Returns `''` when there's no diff (a touch that
+   * didn't change content).
+   *
+   * For tracked files we use `git diff --no-color -- <path>` which
+   * compares the worktree against HEAD's blob.
+   * For untracked files (`git ls-files --error-unmatch` exits non-
+   * zero) we use `git diff --no-color --no-index /dev/null <path>`,
+   * which produces an "added"-shaped diff against an empty source.
+   */
+  async gitDiff(relPath) {
+    const tracked = await runGit(
+      this.opts.workingDir,
+      ["diff", "--no-color", "--", relPath]
+    );
+    if (tracked === null) return null;
+    if (tracked.trim().length > 0) return tracked;
+    const devNull = process.platform === "win32" ? "NUL" : "/dev/null";
+    const untracked = await runGit(
+      this.opts.workingDir,
+      ["diff", "--no-color", "--no-index", "--", devNull, relPath],
+      { allowNonZeroExit: true }
+    );
+    return untracked ?? "";
+  }
+  async postFileChanged(body) {
+    await this.postWithRetries(`${this.apiBase}/api/files/changed`, body);
+  }
+  async postReviewHunk(body) {
+    await this.postWithRetries(`${this.apiBase}/api/review/hunks`, body);
+  }
+  async postWithRetries(url, body) {
+    const payload = JSON.stringify(body);
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Codeam-Protocol-Version": "2.0.0",
+      "X-Plugin-Auth-Token": this.opts.pluginAuthToken
+    };
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt += 1) {
+      try {
+        const { statusCode, body: resBody } = await _transport3.post(url, headers, payload);
+        if (statusCode >= 200 && statusCode < 300) {
+          log.trace(
+            "fileWatcher",
+            `post ok url=${url} status=${statusCode} path=${body.filePath}`
+          );
+          return;
+        }
+        if (statusCode === 410 || statusCode === 404) {
+          log.warn(
+            "fileWatcher",
+            `session dead (status=${statusCode}) \u2014 dropping ${body.filePath}`
+          );
+          this.stopped = true;
+          return;
+        }
+        log.warn(
+          "fileWatcher",
+          `post failed url=${url} status=${statusCode} attempt=${attempt + 1} body=${resBody.slice(0, 200)}`
+        );
+      } catch (err) {
+        log.warn(
+          "fileWatcher",
+          `post error url=${url} attempt=${attempt + 1}`,
+          err
+        );
+      }
+      if (attempt < MAX_RETRIES) {
+        await sleep(RETRY_BACKOFF_MS * (attempt + 1));
+      }
+    }
+    log.warn(
+      "fileWatcher",
+      `giving up after ${MAX_RETRIES + 1} attempts \u2014 path=${body.filePath}`
+    );
+  }
+};
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+async function runGit(cwd, args2, opts = {}) {
+  return _runGit(cwd, args2, opts);
+}
+var _gitSeam = {
+  run: _runGitImpl
+};
+async function _runGitImpl(cwd, args2, opts = {}) {
+  return new Promise((resolve2) => {
+    let proc;
+    try {
+      proc = (0, import_child_process7.spawn)("git", args2, { cwd, env: process.env });
+    } catch {
+      resolve2(null);
+      return;
+    }
+    let stdout = "";
+    let stderr = "";
+    proc.stdout?.on("data", (c2) => {
+      stdout += c2.toString();
+    });
+    proc.stderr?.on("data", (c2) => {
+      stderr += c2.toString();
+    });
+    proc.on("error", () => resolve2(null));
+    proc.on("close", (code) => {
+      if (code === 0 || opts.allowNonZeroExit) {
+        resolve2(stdout);
+      } else {
+        log.trace("fileWatcher", `git ${args2.join(" ")} exited ${code} stderr=${stderr.slice(0, 200)}`);
+        resolve2(null);
+      }
+    });
+  });
+}
+function _runGit(cwd, args2, opts = {}) {
+  return _gitSeam.run(cwd, args2, opts);
+}
+
+// src/services/streaming-emitter.service.ts
+var import_crypto = require("crypto");
+
+// src/services/streaming/transport.ts
+var http6 = __toESM(require("http"));
+var https6 = __toESM(require("https"));
+var _transport4 = {
+  post: _post3,
+  get: _get
+};
+function _post3(url, headers, payload) {
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    const u2 = new URL(url);
+    const lib = u2.protocol === "https:" ? https6 : http6;
+    const req = lib.request(
+      {
+        hostname: u2.hostname,
+        port: u2.port || (u2.protocol === "https:" ? 443 : 80),
+        path: u2.pathname + u2.search,
+        method: "POST",
+        headers: {
+          ...headers,
+          ...vercelBypassHeader(),
+          "Content-Length": Buffer.byteLength(payload)
+        },
+        timeout: 8e3
+      },
+      (res) => {
+        let body = "";
+        res.on("data", (c2) => {
+          body += c2.toString();
+        });
+        res.on("end", () => {
+          if (settled) return;
+          settled = true;
+          resolve2({ statusCode: res.statusCode ?? 0, body });
+        });
+      }
+    );
+    req.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      reject(err);
+    });
+    req.on("timeout", () => {
+      req.destroy();
+    });
+    req.write(payload);
+    req.end();
+  });
+}
+function _get(url, headers) {
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    const u2 = new URL(url);
+    const lib = u2.protocol === "https:" ? https6 : http6;
+    const req = lib.request(
+      {
+        hostname: u2.hostname,
+        port: u2.port || (u2.protocol === "https:" ? 443 : 80),
+        path: u2.pathname + u2.search,
+        method: "GET",
+        headers: {
+          ...headers,
+          ...vercelBypassHeader()
+        },
+        timeout: 8e3
+      },
+      (res) => {
+        let body = "";
+        res.on("data", (c2) => {
+          body += c2.toString();
+        });
+        res.on("end", () => {
+          if (settled) return;
+          settled = true;
+          resolve2({ statusCode: res.statusCode ?? 0, body });
+        });
+      }
+    );
+    req.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      reject(err);
+    });
+    req.on("timeout", () => {
+      req.destroy();
+    });
+    req.end();
+  });
+}
+
+// src/services/streaming-emitter.service.ts
+var API_BASE6 = process.env.CODEAM_API_URL ?? "https://codeagent-mobile-api.vercel.app";
+var TICK_MS = 50;
+var ANSWER_POLL_MS = 1500;
+var SELECTOR_STABLE_MS = 800;
+var MAX_RETRIES2 = 1;
+var RETRY_BACKOFF_MS2 = 200;
+var StreamingEmitterService = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.apiBase = opts.apiBaseUrl ?? API_BASE6;
+    this.headers = {
+      "Content-Type": "application/json",
+      "X-Codeam-Protocol-Version": "2.0.0",
+      "X-Plugin-Auth-Token": opts.pluginAuthToken
+    };
+  }
+  opts;
+  apiBase;
+  headers;
+  rawBuffer = "";
+  active = false;
+  tickTimer = null;
+  answerPollTimer = null;
+  /** Open chunk we're appending bytes to; cleared on kind change or stop. */
+  activeChunk = null;
+  /** Outstanding answer we're polling the backend for. Null when idle. */
+  pendingAnswer = null;
+  /**
+   * Memoised selector signature so we don't fire `awaiting-answer` on
+   * every tick while the user thinks. Cleared once an answer resolves.
+   */
+  lastSelectorSignature = null;
+  selectorFirstSeenAt = 0;
+  // ─── Lifecycle ─────────────────────────────────────────────────────
+  start() {
+    if (this.active) return;
+    this.active = true;
+    this.tickTimer = setInterval(() => this.tick(), TICK_MS);
+    this.answerPollTimer = setInterval(() => {
+      void this.pollPendingAnswer();
+    }, ANSWER_POLL_MS);
+    log.trace("streamingEmitter", `started session=${this.opts.sessionId.slice(0, 8)}`);
+  }
+  /**
+   * Stop the emitter. Finalises the open chunk (if any) so the
+   * backend doesn't leave a half-streamed message in the SSE
+   * buffer. Idempotent.
+   */
+  async stop() {
+    if (!this.active) return;
+    this.active = false;
+    if (this.tickTimer) {
+      clearInterval(this.tickTimer);
+      this.tickTimer = null;
+    }
+    if (this.answerPollTimer) {
+      clearInterval(this.answerPollTimer);
+      this.answerPollTimer = null;
+    }
+    if (this.activeChunk) {
+      const finalContent = this.activeChunk.currentContent;
+      const chunk = this.activeChunk;
+      this.activeChunk = null;
+      await this.postChunk({
+        chunkId: chunk.chunkId,
+        kind: chunk.kind,
+        content: finalContent,
+        isFinal: true
+      });
+    }
+    log.trace("streamingEmitter", `stopped session=${this.opts.sessionId.slice(0, 8)}`);
+  }
+  // ─── Input pump ────────────────────────────────────────────────────
+  /**
+   * Forward a chunk of raw PTY bytes into the emitter. Safe to call
+   * before `start()` — bytes accumulate in the internal buffer and the
+   * first tick processes the backlog.
+   */
+  push(raw) {
+    if (raw.length === 0) return;
+    this.rawBuffer += raw;
+  }
+  // ─── Tick ──────────────────────────────────────────────────────────
+  /**
+   * Visible for tests. Runs one classify-and-emit pass against the
+   * current PTY buffer.
+   */
+  /* @internal */
+  _tickForTest() {
+    this.tick();
+  }
+  tick() {
+    if (!this.active) return;
+    const lines = (this.opts.runtime.renderToLines ?? renderToLines)(this.rawBuffer);
+    const selector = this.opts.runtime.detectInteractivePrompt(lines);
+    if (selector) {
+      this.maybeEmitAwaitingAnswer(selector);
+      return;
+    }
+    this.lastSelectorSignature = null;
+    this.selectorFirstSeenAt = 0;
+    const groups = this.classifyLines(lines, this.opts.runtime);
+    if (groups.length === 0) return;
+    const last = groups[groups.length - 1];
+    if (this.activeChunk && this.activeChunk.kind === last.kind) {
+      this.activeChunk.currentContent = last.content;
+      this.maybeFlushActive(false);
+      return;
+    }
+    if (this.activeChunk) {
+      const closing = this.activeChunk;
+      this.activeChunk = null;
+      void this.postChunk({
+        chunkId: closing.chunkId,
+        kind: closing.kind,
+        content: closing.currentContent,
+        isFinal: true
+      });
+    }
+    this.activeChunk = {
+      chunkId: (0, import_crypto.randomUUID)(),
+      kind: last.kind,
+      emittedContent: "",
+      currentContent: last.content,
+      lastEmitAt: 0
+    };
+    this.maybeFlushActive(false);
+  }
+  maybeFlushActive(force) {
+    const chunk = this.activeChunk;
+    if (!chunk) return;
+    const now = Date.now();
+    if (!force && now - chunk.lastEmitAt < TICK_MS) return;
+    if (chunk.currentContent === chunk.emittedContent) return;
+    chunk.emittedContent = chunk.currentContent;
+    chunk.lastEmitAt = now;
+    void this.postChunk({
+      chunkId: chunk.chunkId,
+      kind: chunk.kind,
+      content: chunk.currentContent,
+      isFinal: false
+    });
+  }
+  // ─── Line classification ───────────────────────────────────────────
+  /**
+   * Walk the rendered screen lines and bucket them into kind-groups.
+   *
+   * Visible for tests so we can assert discrimination against fixture
+   * inputs without standing up the full POST loop.
+   */
+  /* @internal */
+  _classifyForTest(lines) {
+    return this.classifyLines(lines, this.opts.runtime);
+  }
+  classifyLines(lines, runtime) {
+    const parseLine2 = runtime.parseTuiChrome?.bind(runtime);
+    const groups = [];
+    let current = null;
+    const flush = () => {
+      if (!current) return;
+      const text = current.lines.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+      if (text.length > 0) groups.push({ kind: current.kind, content: text });
+      current = null;
+    };
+    for (const rawLine of lines) {
+      const kind = classifyLine(rawLine, parseLine2, runtime);
+      if (kind === null) continue;
+      if (!current || current.kind !== kind) {
+        flush();
+        current = { kind, lines: [rawLine] };
+      } else {
+        current.lines.push(rawLine);
+      }
+    }
+    flush();
+    return groups;
+  }
+  // ─── Awaiting-answer + answer subscription ─────────────────────────
+  maybeEmitAwaitingAnswer(selector) {
+    const signature = `${selector.question}::${selector.options.join("|")}`;
+    const now = Date.now();
+    if (this.lastSelectorSignature !== signature) {
+      this.lastSelectorSignature = signature;
+      this.selectorFirstSeenAt = now;
+      return;
+    }
+    if (this.pendingAnswer) return;
+    if (now - this.selectorFirstSeenAt < SELECTOR_STABLE_MS) return;
+    const questionId = (0, import_crypto.randomUUID)();
+    this.pendingAnswer = {
+      questionId,
+      options: selector.options.length > 0 ? selector.options : void 0,
+      fromIndex: selector.currentIndex
+    };
+    const event = {
+      questionId,
+      prompt: selector.question,
+      ...selector.options.length > 0 ? { options: selector.options } : {}
+    };
+    void this.postAwaitingAnswer(event);
+  }
+  async pollPendingAnswer() {
+    if (!this.active) return;
+    if (!this.pendingAnswer) return;
+    const questionId = this.pendingAnswer.questionId;
+    try {
+      const { statusCode, body } = await _transport4.get(
+        `${this.apiBase}/api/sessions/${encodeURIComponent(this.opts.sessionId)}/pending-answer?questionId=${encodeURIComponent(questionId)}`,
+        this.headers
+      );
+      if (statusCode === 204 || statusCode === 404) {
+        return;
+      }
+      if (statusCode < 200 || statusCode >= 300) {
+        log.warn("streamingEmitter", `pending-answer status=${statusCode} body=${body.slice(0, 200)}`);
+        return;
+      }
+      const parsed = parsePendingAnswerResponse(body);
+      if (!parsed || parsed.questionId !== questionId) return;
+      const pending = this.pendingAnswer;
+      this.pendingAnswer = null;
+      this.lastSelectorSignature = null;
+      this.selectorFirstSeenAt = 0;
+      this.deliverAnswer(parsed, pending);
+    } catch (err) {
+      log.trace("streamingEmitter", "pending-answer poll failed", err);
+    }
+  }
+  deliverAnswer(answer, pending) {
+    if (pending.options && pending.options.length > 0) {
+      let targetIndex = answer.optionIndex ?? -1;
+      if (targetIndex < 0) {
+        targetIndex = pending.options.findIndex((o) => o === answer.answer);
+      }
+      if (targetIndex < 0 || targetIndex >= pending.options.length) {
+        log.warn(
+          "streamingEmitter",
+          `answer label "${answer.answer}" not found in selector options \u2014 defaulting to 0`
+        );
+        targetIndex = 0;
+      }
+      this.opts.ptyInput.selectOption(targetIndex, pending.fromIndex ?? 0);
+      return;
+    }
+    this.opts.ptyInput.sendCommand(answer.answer);
+  }
+  // ─── POSTs ─────────────────────────────────────────────────────────
+  async postChunk(event) {
+    await this.postWithRetries(
+      `${this.apiBase}/api/sessions/${encodeURIComponent(this.opts.sessionId)}/streaming-chunk`,
+      event
+    );
+  }
+  async postAwaitingAnswer(event) {
+    await this.postWithRetries(
+      `${this.apiBase}/api/sessions/${encodeURIComponent(this.opts.sessionId)}/awaiting-answer`,
+      event
+    );
+  }
+  async postWithRetries(url, body) {
+    const payload = JSON.stringify(body);
+    for (let attempt = 0; attempt <= MAX_RETRIES2; attempt += 1) {
+      try {
+        const { statusCode, body: resBody } = await _transport4.post(url, this.headers, payload);
+        if (statusCode >= 200 && statusCode < 300) {
+          log.trace("streamingEmitter", `post ok url=${url} status=${statusCode}`);
+          return;
+        }
+        if (statusCode === 410 || statusCode === 404) {
+          log.warn("streamingEmitter", `session dead (status=${statusCode}) \u2014 disabling emitter`);
+          this.active = false;
+          if (this.tickTimer) {
+            clearInterval(this.tickTimer);
+            this.tickTimer = null;
+          }
+          if (this.answerPollTimer) {
+            clearInterval(this.answerPollTimer);
+            this.answerPollTimer = null;
+          }
+          return;
+        }
+        log.warn(
+          "streamingEmitter",
+          `post failed url=${url} status=${statusCode} attempt=${attempt + 1} body=${resBody.slice(0, 200)}`
+        );
+      } catch (err) {
+        log.warn("streamingEmitter", `post error url=${url} attempt=${attempt + 1}`, err);
+      }
+      if (attempt < MAX_RETRIES2) {
+        await sleep2(RETRY_BACKOFF_MS2 * (attempt + 1));
+      }
+    }
+  }
+};
+function sleep2(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+var TREE_CONTINUATION_RE = /^\s*└/;
+function classifyLine(line, parseChrome, runtime) {
+  if (line.trim().length === 0) return null;
+  if (TREE_CONTINUATION_RE.test(line)) return "tool_result";
+  const step = parseChrome?.(line) ?? null;
+  if (step) {
+    if (step.tool === "thinking") return "thinking";
+    return "tool_use";
+  }
+  const filtered = runtime.filterTuiOutput([line]);
+  if (filtered.length === 0) return null;
+  return "text";
+}
+function parsePendingAnswerResponse(body) {
+  if (!body) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const root = parsed;
+  const candidate = root.data && typeof root.data === "object" ? root.data : root;
+  const questionId = candidate.questionId;
+  const answer = candidate.answer;
+  const optionIndex = candidate.optionIndex;
+  if (typeof questionId !== "string" || typeof answer !== "string") return null;
+  const result = { questionId, answer };
+  if (typeof optionIndex === "number" && Number.isInteger(optionIndex)) {
+    result.optionIndex = optionIndex;
+  }
+  return result;
+}
+
 // src/commands/start/quota-fetcher.ts
 var inProgress = false;
 function fetchQuotaUsage(runtime, historySvc) {
@@ -6140,13 +7051,13 @@ function fetchQuotaUsage(runtime, historySvc) {
 }
 
 // src/commands/start/keep-alive.ts
-var import_child_process6 = require("child_process");
+var import_child_process8 = require("child_process");
 function buildKeepAlive(ctx) {
   let timer = null;
   async function setIdleTimeout(minutes) {
     if (!ctx.inCodespace || !ctx.codespaceName) return;
     await new Promise((resolve2) => {
-      const proc = (0, import_child_process6.spawn)(
+      const proc = (0, import_child_process8.spawn)(
         "gh",
         [
           "api",
@@ -6185,9 +7096,9 @@ function buildKeepAlive(ctx) {
 // src/commands/start/handlers.ts
 var fs14 = __toESM(require("fs"));
 var os13 = __toESM(require("os"));
-var path18 = __toESM(require("path"));
-var import_crypto2 = require("crypto");
-var import_child_process9 = require("child_process");
+var path19 = __toESM(require("path"));
+var import_crypto3 = require("crypto");
+var import_child_process11 = require("child_process");
 
 // src/lib/payload.ts
 var import_zod2 = require("zod");
@@ -6244,7 +7155,7 @@ function parsePayload(schema, raw) {
 
 // src/services/file-ops.service.ts
 var fs12 = __toESM(require("fs/promises"));
-var path15 = __toESM(require("path"));
+var path16 = __toESM(require("path"));
 var MAX_FILE_BYTES = 5 * 1024 * 1024;
 var MAX_WALK_DEPTH = 6;
 var MAX_VISITED_DIRS = 5e3;
@@ -6279,8 +7190,8 @@ var SUBDIR_IGNORE = /* @__PURE__ */ new Set([
   "__pycache__"
 ]);
 function isUnder(parent, candidate) {
-  const rel = path15.relative(parent, candidate);
-  return rel === "" || !rel.startsWith("..") && !path15.isAbsolute(rel);
+  const rel = path16.relative(parent, candidate);
+  return rel === "" || !rel.startsWith("..") && !path16.isAbsolute(rel);
 }
 async function isExistingFile(absPath) {
   try {
@@ -6303,7 +7214,7 @@ async function walkForSuffix(dir, needleVariants, depth, ctx) {
   }
   for (const e of entries) {
     if (!e.isFile()) continue;
-    const full = path15.join(dir, e.name);
+    const full = path16.join(dir, e.name);
     if (needleVariants.some((needle) => full.endsWith(needle))) {
       ctx.matches.push(full);
       if (ctx.matches.length >= ctx.cap) return;
@@ -6313,21 +7224,21 @@ async function walkForSuffix(dir, needleVariants, depth, ctx) {
     if (!e.isDirectory()) continue;
     if (SUBDIR_IGNORE.has(e.name)) continue;
     if (e.name.startsWith(".") && SUBDIR_IGNORE.has(e.name)) continue;
-    await walkForSuffix(path15.join(dir, e.name), needleVariants, depth + 1, ctx);
+    await walkForSuffix(path16.join(dir, e.name), needleVariants, depth + 1, ctx);
     if (ctx.matches.length >= ctx.cap) return;
   }
 }
 async function findFile(rawPath) {
   const cwd = process.cwd();
-  if (path15.isAbsolute(rawPath)) {
-    const abs = path15.normalize(rawPath);
+  if (path16.isAbsolute(rawPath)) {
+    const abs = path16.normalize(rawPath);
     if (isUnder(cwd, abs) && await isExistingFile(abs)) return abs;
   }
-  const direct = path15.resolve(cwd, rawPath);
+  const direct = path16.resolve(cwd, rawPath);
   if (isUnder(cwd, direct) && await isExistingFile(direct)) return direct;
-  const normalized = path15.normalize(rawPath).replace(/^[./\\]+/, "");
+  const normalized = path16.normalize(rawPath).replace(/^[./\\]+/, "");
   const needles = [
-    `${path15.sep}${normalized}`,
+    `${path16.sep}${normalized}`,
     `/${normalized}`
   ].filter((v, i, a) => a.indexOf(v) === i);
   const ctx = { visited: 0, matches: [], cap: 16 };
@@ -6341,7 +7252,7 @@ async function findWriteTarget(rawPath) {
   const found = await findFile(rawPath);
   if (found) return found;
   const cwd = process.cwd();
-  const fallback = path15.isAbsolute(rawPath) ? path15.normalize(rawPath) : path15.resolve(cwd, rawPath);
+  const fallback = path16.isAbsolute(rawPath) ? path16.normalize(rawPath) : path16.resolve(cwd, rawPath);
   if (!isUnder(cwd, fallback)) return null;
   return fallback;
 }
@@ -6381,7 +7292,7 @@ async function writeProjectFile(rawPath, content) {
     if (Buffer.byteLength(content, "utf-8") > MAX_FILE_BYTES) {
       return { error: "Content too large." };
     }
-    await fs12.mkdir(path15.dirname(abs), { recursive: true });
+    await fs12.mkdir(path16.dirname(abs), { recursive: true });
     await fs12.writeFile(abs, content, "utf-8");
     return { ok: true };
   } catch (e) {
@@ -6391,11 +7302,11 @@ async function writeProjectFile(rawPath, content) {
 }
 
 // src/services/project-ops.service.ts
-var import_child_process7 = require("child_process");
+var import_child_process9 = require("child_process");
 var import_util2 = require("util");
 var fs13 = __toESM(require("fs/promises"));
-var path16 = __toESM(require("path"));
-var execFileP2 = (0, import_util2.promisify)(import_child_process7.execFile);
+var path17 = __toESM(require("path"));
+var execFileP2 = (0, import_util2.promisify)(import_child_process9.execFile);
 var PROJECT_IGNORE = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -6452,12 +7363,12 @@ async function listProjectFiles(opts = {}) {
         return;
       }
       if (PROJECT_IGNORE.has(e.name)) continue;
-      const full = path16.join(dir, e.name);
+      const full = path17.join(dir, e.name);
       if (e.isDirectory()) {
         if (depth >= 12) continue;
         await walk(full, depth + 1);
       } else if (e.isFile()) {
-        const rel = path16.relative(root, full);
+        const rel = path17.relative(root, full);
         if (q2 && !rel.toLowerCase().includes(q2) && !e.name.toLowerCase().includes(q2)) {
           continue;
         }
@@ -6565,7 +7476,7 @@ async function gitStatus(cwd) {
   let hasMergeInProgress = false;
   try {
     const gitDir = (await git(["rev-parse", "--git-dir"], root)).stdout.trim();
-    const mergeHead = path16.isAbsolute(gitDir) ? path16.join(gitDir, "MERGE_HEAD") : path16.join(root, gitDir, "MERGE_HEAD");
+    const mergeHead = path17.isAbsolute(gitDir) ? path17.join(gitDir, "MERGE_HEAD") : path17.join(root, gitDir, "MERGE_HEAD");
     await fs13.access(mergeHead);
     hasMergeInProgress = true;
   } catch {
@@ -6712,7 +7623,7 @@ async function jsSearchFiles(opts, cwd, cap) {
     }
     let content = "";
     try {
-      content = await fs13.readFile(path16.join(cwd, f.path), "utf8");
+      content = await fs13.readFile(path17.join(cwd, f.path), "utf8");
     } catch {
       continue;
     }
@@ -6735,8 +7646,8 @@ async function jsSearchFiles(opts, cwd, cap) {
 }
 
 // src/services/terminal-ops.service.ts
-var import_child_process8 = require("child_process");
-var import_crypto = require("crypto");
+var import_child_process10 = require("child_process");
+var import_crypto2 = require("crypto");
 var import_path = __toESM(require("path"));
 var MAX_CONCURRENT_SESSIONS = 4;
 var nodePtyModule;
@@ -6857,7 +7768,7 @@ function createPythonSession(id, shell, cwd, env, cols, rows) {
   }
   let child;
   try {
-    child = (0, import_child_process8.spawn)(python, ["-c", PYTHON_TERMINAL_HELPER, shell], {
+    child = (0, import_child_process10.spawn)(python, ["-c", PYTHON_TERMINAL_HELPER, shell], {
       cwd,
       env: { ...env, COLUMNS: String(cols), LINES: String(rows) },
       stdio: ["pipe", "pipe", "pipe"]
@@ -6912,7 +7823,7 @@ function openTerminal(opts) {
   };
   const cols = Math.max(1, Math.min(opts.cols ?? 80, 500));
   const rows = Math.max(1, Math.min(opts.rows ?? 24, 200));
-  const id = (0, import_crypto.randomUUID)();
+  const id = (0, import_crypto2.randomUUID)();
   const ptyMod = loadNodePty2();
   if (ptyMod) {
     try {
@@ -6992,7 +7903,7 @@ function closeTerminal(sessionId) {
 function saveFilesTemp(files) {
   return files.filter(({ base64 }) => base64 && base64.length > 0).map(({ filename, base64 }) => {
     const safeName = filename.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 80);
-    const tmpPath = path18.join(os13.tmpdir(), `codeam-${(0, import_crypto2.randomUUID)()}-${safeName}`);
+    const tmpPath = path19.join(os13.tmpdir(), `codeam-${(0, import_crypto3.randomUUID)()}-${safeName}`);
     fs14.writeFileSync(tmpPath, Buffer.from(base64, "base64"));
     return tmpPath;
   });
@@ -7124,7 +8035,7 @@ var sessionTerminated = (ctx) => {
   } catch {
   }
   try {
-    const proc = (0, import_child_process9.spawn)("bash", ["-lc", "pm2 delete codeam-pair >/dev/null 2>&1 || true"], {
+    const proc = (0, import_child_process11.spawn)("bash", ["-lc", "pm2 delete codeam-pair >/dev/null 2>&1 || true"], {
       detached: true,
       stdio: "ignore"
     });
@@ -7146,7 +8057,7 @@ var shutdownSession = async (ctx, cmd) => {
   }
   if (ctx.keepAliveCtx.inCodespace && ctx.keepAliveCtx.codespaceName) {
     try {
-      const stopProc = (0, import_child_process9.spawn)(
+      const stopProc = (0, import_child_process11.spawn)(
         "bash",
         ["-lc", `sleep 1; gh codespace stop -c ${JSON.stringify(ctx.keepAliveCtx.codespaceName)} >/dev/null 2>&1 || true`],
         { detached: true, stdio: "ignore" }
@@ -7156,7 +8067,7 @@ var shutdownSession = async (ctx, cmd) => {
     }
   }
   try {
-    const proc = (0, import_child_process9.spawn)("bash", ["-lc", "pm2 delete codeam-pair >/dev/null 2>&1 || true"], {
+    const proc = (0, import_child_process11.spawn)("bash", ["-lc", "pm2 delete codeam-pair >/dev/null 2>&1 || true"], {
       detached: true,
       stdio: "ignore"
     });
@@ -7375,21 +8286,40 @@ async function start(requestedAgent) {
     session.pluginAuthToken,
     runtime
   );
+  const fileWatcher = session.pluginAuthToken ? new FileWatcherService({
+    workingDir: cwd,
+    sessionId: session.id,
+    pluginId,
+    pluginAuthToken: session.pluginAuthToken
+  }) : null;
+  let streamingEmitter = null;
   const claude = new AgentService(
     runtime,
     {
       cwd,
       onData(raw) {
         outputSvc.push(raw);
+        streamingEmitter?.push(raw);
       },
       onExit(code) {
         process.removeListener("SIGINT", sigintHandler);
         outputSvc.dispose();
         relay.stop();
+        void fileWatcher?.stop();
+        void streamingEmitter?.stop();
         process.exit(code);
       }
     }
   );
+  if (session.pluginAuthToken) {
+    streamingEmitter = new StreamingEmitterService({
+      sessionId: session.id,
+      pluginId,
+      pluginAuthToken: session.pluginAuthToken,
+      runtime,
+      ptyInput: claude
+    });
+  }
   const ctx = {
     outputSvc,
     claude,
@@ -7415,12 +8345,19 @@ async function start(requestedAgent) {
     claude.kill();
     outputSvc.dispose();
     relay.stop();
+    void fileWatcher?.stop();
+    void streamingEmitter?.stop();
     process.exit(0);
   }
   process.once("SIGINT", sigintHandler);
   await claude.spawn();
   await outputSvc.startTerminalTurn();
   relay.start();
+  if (fileWatcher) {
+    fileWatcher.start().catch(() => {
+    });
+  }
+  streamingEmitter?.start();
   setTimeout(() => {
     historySvc.load().catch(() => {
     });
@@ -7429,7 +8366,7 @@ async function start(requestedAgent) {
 }
 
 // src/commands/pair.ts
-var import_crypto3 = require("crypto");
+var import_crypto4 = require("crypto");
 var import_picocolors3 = __toESM(require("picocolors"));
 
 // src/ui/prompts.ts
@@ -7492,7 +8429,7 @@ async function pair(args2 = []) {
   const flagAgent = parseAgentFlag(args2);
   const agentId = flagAgent ?? await promptForAgent(config.preferredAgent ?? "claude");
   showIntro();
-  const pluginId = (0, import_crypto3.randomUUID)();
+  const pluginId = (0, import_crypto4.randomUUID)();
   const spin = dist_exports.spinner();
   spin.start("Requesting pairing code...");
   const result = await requestCode(pluginId);
@@ -7548,8 +8485,8 @@ async function pair(args2 = []) {
 // src/commands/pair-auto.ts
 var fs15 = __toESM(require("fs"));
 var os14 = __toESM(require("os"));
-var import_crypto4 = require("crypto");
-var API_BASE5 = process.env.CODEAM_API_URL ?? "https://codeagent-mobile-api.vercel.app";
+var import_crypto5 = require("crypto");
+var API_BASE7 = process.env.CODEAM_API_URL ?? "https://codeagent-mobile-api.vercel.app";
 function fail(msg) {
   console.error(`
   ${msg}
@@ -7564,12 +8501,12 @@ function readTokenFromArgs(args2) {
   }
   const fileFlag = args2.find((a) => a.startsWith("--token-file="));
   if (fileFlag) {
-    const path24 = fileFlag.slice("--token-file=".length);
+    const path25 = fileFlag.slice("--token-file=".length);
     try {
-      const content = fs15.readFileSync(path24, "utf8").trim();
-      if (content.length === 0) fail(`--token-file ${path24} is empty`);
+      const content = fs15.readFileSync(path25, "utf8").trim();
+      if (content.length === 0) fail(`--token-file ${path25} is empty`);
       try {
-        fs15.unlinkSync(path24);
+        fs15.unlinkSync(path25);
       } catch {
       }
       return content;
@@ -7581,14 +8518,18 @@ function readTokenFromArgs(args2) {
   fail("codeam pair-auto requires --token-file=<path>, --token=<value>, or CODEAM_AUTO_TOKEN env");
 }
 async function claim(token, pluginId) {
-  const url = `${API_BASE5}/api/pairing/claim-auto-token`;
+  const url = `${API_BASE7}/api/pairing/claim-auto-token`;
   const body = {
     token,
     pluginId,
     ideName: "codeam-cli (codespace)",
     ideVersion: process.env.npm_package_version ?? "unknown",
     hostname: os14.hostname(),
-    codespaceName: process.env.CODESPACE_NAME ?? ""
+    codespaceName: process.env.CODESPACE_NAME ?? "",
+    // Current git branch of the codespace's working directory, so the
+    // backend can populate `PairedSession.branch` for the codespace pair.
+    // `null` when detached HEAD / not a git repo.
+    branch: detectCurrentBranch()
   };
   const res = await fetch(url, {
     method: "POST",
@@ -7610,7 +8551,7 @@ async function claim(token, pluginId) {
 }
 async function pairAuto(args2) {
   const token = readTokenFromArgs(args2);
-  const pluginId = (0, import_crypto4.randomUUID)();
+  const pluginId = (0, import_crypto5.randomUUID)();
   console.log("  Claiming pairing token\u2026");
   const claimed = await claim(token, pluginId);
   if (!isKnownAgentId(claimed.agent)) {
@@ -7736,11 +8677,11 @@ async function logout() {
 var import_picocolors9 = __toESM(require("picocolors"));
 
 // src/services/providers/github-codespaces.ts
-var import_child_process10 = require("child_process");
+var import_child_process12 = require("child_process");
 var import_util3 = require("util");
 var import_picocolors7 = __toESM(require("picocolors"));
-var path19 = __toESM(require("path"));
-var execFileP3 = (0, import_util3.promisify)(import_child_process10.execFile);
+var path20 = __toESM(require("path"));
+var execFileP3 = (0, import_util3.promisify)(import_child_process12.execFile);
 var MAX_BUFFER = 8 * 1024 * 1024;
 function resetStdinForChild() {
   if (process.stdin.isTTY) {
@@ -7784,7 +8725,7 @@ var GitHubCodespacesProvider = class {
     if (!isAuthed) {
       resetStdinForChild();
       await new Promise((resolve2, reject) => {
-        const proc = (0, import_child_process10.spawn)("gh", ["auth", "login", "-s", "codespace,repo,read:user"], {
+        const proc = (0, import_child_process12.spawn)("gh", ["auth", "login", "-s", "codespace,repo,read:user"], {
           stdio: "inherit"
         });
         proc.on("exit", (code) => {
@@ -7818,7 +8759,7 @@ var GitHubCodespacesProvider = class {
       wt(noteLines.join("\n"), "One more permission needed");
       resetStdinForChild();
       const refreshCode = await new Promise((resolve2, reject) => {
-        const proc = (0, import_child_process10.spawn)(
+        const proc = (0, import_child_process12.spawn)(
           "gh",
           ["auth", "refresh", "-h", "github.com", "-s", "codespace"],
           { stdio: "inherit" }
@@ -7968,7 +8909,7 @@ var GitHubCodespacesProvider = class {
     O2.step(`Installing gh via ${installCmd.describe}\u2026`);
     resetStdinForChild();
     const ok = await new Promise((resolve2) => {
-      const proc = (0, import_child_process10.spawn)(installCmd.exe, installCmd.args, { stdio: "inherit" });
+      const proc = (0, import_child_process12.spawn)(installCmd.exe, installCmd.args, { stdio: "inherit" });
       proc.on("exit", (code) => resolve2(code === 0));
       proc.on("error", () => resolve2(false));
     });
@@ -7995,7 +8936,7 @@ var GitHubCodespacesProvider = class {
     );
     resetStdinForChild();
     await new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process10.spawn)(
+      const proc = (0, import_child_process12.spawn)(
         "gh",
         ["auth", "refresh", "-h", "github.com", "-s", "repo,read:org"],
         { stdio: "inherit" }
@@ -8173,7 +9114,7 @@ var GitHubCodespacesProvider = class {
   async streamCommand(workspaceId, command2) {
     resetStdinForChild();
     return new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process10.spawn)(
+      const proc = (0, import_child_process12.spawn)(
         "gh",
         ["codespace", "ssh", "-c", workspaceId, "--", "-tt", command2],
         { stdio: "inherit" }
@@ -8200,11 +9141,11 @@ var GitHubCodespacesProvider = class {
       `mkdir -p ${shellQuote(remoteDir)} && tar -xzf - -C ${shellQuote(remoteDir)}`
     ];
     await new Promise((resolve2, reject) => {
-      const tar = (0, import_child_process10.spawn)("tar", tarArgs, {
+      const tar = (0, import_child_process12.spawn)("tar", tarArgs, {
         stdio: ["ignore", "pipe", "pipe"],
         env: tarEnv
       });
-      const ssh = (0, import_child_process10.spawn)("gh", sshArgs, {
+      const ssh = (0, import_child_process12.spawn)("gh", sshArgs, {
         stdio: [tar.stdout, "pipe", "pipe"]
       });
       let tarErr = "";
@@ -8228,7 +9169,7 @@ var GitHubCodespacesProvider = class {
     });
   }
   async uploadFile(workspaceId, remotePath, contents, options = {}) {
-    const remoteDir = path19.posix.dirname(remotePath);
+    const remoteDir = path20.posix.dirname(remotePath);
     const parts = [
       `mkdir -p ${shellQuote(remoteDir)}`,
       `cat > ${shellQuote(remotePath)}`
@@ -8238,7 +9179,7 @@ var GitHubCodespacesProvider = class {
     }
     const cmd = parts.join(" && ");
     await new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process10.spawn)(
+      const proc = (0, import_child_process12.spawn)(
         "gh",
         ["codespace", "ssh", "-c", workspaceId, "--", cmd],
         { stdio: ["pipe", "pipe", "pipe"] }
@@ -8296,11 +9237,11 @@ function shellQuote(s) {
 }
 
 // src/services/providers/gitpod.ts
-var import_child_process11 = require("child_process");
+var import_child_process13 = require("child_process");
 var import_util4 = require("util");
-var path20 = __toESM(require("path"));
+var path21 = __toESM(require("path"));
 var import_picocolors8 = __toESM(require("picocolors"));
-var execFileP4 = (0, import_util4.promisify)(import_child_process11.execFile);
+var execFileP4 = (0, import_util4.promisify)(import_child_process13.execFile);
 var MAX_BUFFER2 = 8 * 1024 * 1024;
 function resetStdinForChild2() {
   if (process.stdin.isTTY) {
@@ -8340,7 +9281,7 @@ var GitpodProvider = class {
     );
     resetStdinForChild2();
     await new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process11.spawn)("gitpod", ["login"], { stdio: "inherit" });
+      const proc = (0, import_child_process13.spawn)("gitpod", ["login"], { stdio: "inherit" });
       proc.on("exit", (code) => {
         if (code === 0) resolve2();
         else reject(new Error("gitpod login failed."));
@@ -8492,7 +9433,7 @@ var GitpodProvider = class {
   async streamCommand(workspaceId, command2) {
     resetStdinForChild2();
     return new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process11.spawn)(
+      const proc = (0, import_child_process13.spawn)(
         "gitpod",
         ["workspace", "ssh", workspaceId, "--", "-tt", command2],
         { stdio: "inherit" }
@@ -8512,11 +9453,11 @@ var GitpodProvider = class {
     const tarEnv = { ...process.env, COPYFILE_DISABLE: "1" };
     const remoteCmd = `mkdir -p ${shellQuote2(remoteDir)} && tar -xzf - -C ${shellQuote2(remoteDir)}`;
     await new Promise((resolve2, reject) => {
-      const tar = (0, import_child_process11.spawn)("tar", tarArgs, {
+      const tar = (0, import_child_process13.spawn)("tar", tarArgs, {
         stdio: ["ignore", "pipe", "pipe"],
         env: tarEnv
       });
-      const ssh = (0, import_child_process11.spawn)(
+      const ssh = (0, import_child_process13.spawn)(
         "gitpod",
         ["workspace", "ssh", workspaceId, "--", remoteCmd],
         { stdio: [tar.stdout, "pipe", "pipe"] }
@@ -8538,7 +9479,7 @@ var GitpodProvider = class {
     });
   }
   async uploadFile(workspaceId, remotePath, contents, options = {}) {
-    const remoteDir = path20.posix.dirname(remotePath);
+    const remoteDir = path21.posix.dirname(remotePath);
     const parts = [
       `mkdir -p ${shellQuote2(remoteDir)}`,
       `cat > ${shellQuote2(remotePath)}`
@@ -8548,7 +9489,7 @@ var GitpodProvider = class {
     }
     const cmd = parts.join(" && ");
     await new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process11.spawn)(
+      const proc = (0, import_child_process13.spawn)(
         "gitpod",
         ["workspace", "ssh", workspaceId, "--", cmd],
         { stdio: ["pipe", "pipe", "pipe"] }
@@ -8572,10 +9513,10 @@ function shellQuote2(s) {
 }
 
 // src/services/providers/gitlab-workspaces.ts
-var import_child_process12 = require("child_process");
+var import_child_process14 = require("child_process");
 var import_util5 = require("util");
-var path21 = __toESM(require("path"));
-var execFileP5 = (0, import_util5.promisify)(import_child_process12.execFile);
+var path22 = __toESM(require("path"));
+var execFileP5 = (0, import_util5.promisify)(import_child_process14.execFile);
 var MAX_BUFFER3 = 8 * 1024 * 1024;
 var GITLAB_API_BASE = process.env.CODEAM_GITLAB_API_URL ?? "https://gitlab.com/api/v4";
 function resetStdinForChild3() {
@@ -8617,7 +9558,7 @@ var GitLabWorkspacesProvider = class {
     );
     resetStdinForChild3();
     await new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process12.spawn)(
+      const proc = (0, import_child_process14.spawn)(
         "glab",
         ["auth", "login", "--scopes", "api,read_user,read_repository"],
         { stdio: "inherit" }
@@ -8789,7 +9730,7 @@ Docs: https://docs.gitlab.com/ee/user/workspace/configuration.html`
     const sshHost = process.env.CODEAM_GITLAB_SSH_HOST ?? "workspaces.gitlab.com";
     resetStdinForChild3();
     return new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process12.spawn)(
+      const proc = (0, import_child_process14.spawn)(
         "ssh",
         ["-tt", "-o", "StrictHostKeyChecking=accept-new", `${workspaceId}@${sshHost}`, command2],
         { stdio: "inherit" }
@@ -8810,8 +9751,8 @@ Docs: https://docs.gitlab.com/ee/user/workspace/configuration.html`
     const tarEnv = { ...process.env, COPYFILE_DISABLE: "1" };
     const remoteCmd = `mkdir -p ${shellQuote3(remoteDir)} && tar -xzf - -C ${shellQuote3(remoteDir)}`;
     await new Promise((resolve2, reject) => {
-      const tar = (0, import_child_process12.spawn)("tar", tarArgs, { stdio: ["ignore", "pipe", "pipe"], env: tarEnv });
-      const ssh = (0, import_child_process12.spawn)(
+      const tar = (0, import_child_process14.spawn)("tar", tarArgs, { stdio: ["ignore", "pipe", "pipe"], env: tarEnv });
+      const ssh = (0, import_child_process14.spawn)(
         "ssh",
         ["-o", "StrictHostKeyChecking=accept-new", `${workspaceId}@${sshHost}`, remoteCmd],
         { stdio: [tar.stdout, "pipe", "pipe"] }
@@ -8834,14 +9775,14 @@ Docs: https://docs.gitlab.com/ee/user/workspace/configuration.html`
   }
   async uploadFile(workspaceId, remotePath, contents, options = {}) {
     const sshHost = process.env.CODEAM_GITLAB_SSH_HOST ?? "workspaces.gitlab.com";
-    const remoteDir = path21.posix.dirname(remotePath);
+    const remoteDir = path22.posix.dirname(remotePath);
     const parts = [`mkdir -p ${shellQuote3(remoteDir)}`, `cat > ${shellQuote3(remotePath)}`];
     if (options.mode != null) {
       parts.push(`chmod ${options.mode.toString(8)} ${shellQuote3(remotePath)}`);
     }
     const cmd = parts.join(" && ");
     await new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process12.spawn)(
+      const proc = (0, import_child_process14.spawn)(
         "ssh",
         ["-o", "StrictHostKeyChecking=accept-new", `${workspaceId}@${sshHost}`, cmd],
         { stdio: ["pipe", "pipe", "pipe"] }
@@ -8900,10 +9841,10 @@ function shellQuote3(s) {
 }
 
 // src/services/providers/railway.ts
-var import_child_process13 = require("child_process");
+var import_child_process15 = require("child_process");
 var import_util6 = require("util");
-var path22 = __toESM(require("path"));
-var execFileP6 = (0, import_util6.promisify)(import_child_process13.execFile);
+var path23 = __toESM(require("path"));
+var execFileP6 = (0, import_util6.promisify)(import_child_process15.execFile);
 var MAX_BUFFER4 = 8 * 1024 * 1024;
 function resetStdinForChild4() {
   if (process.stdin.isTTY) {
@@ -8944,7 +9885,7 @@ var RailwayProvider = class {
     );
     resetStdinForChild4();
     await new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process13.spawn)("railway", ["login"], { stdio: "inherit" });
+      const proc = (0, import_child_process15.spawn)("railway", ["login"], { stdio: "inherit" });
       proc.on("exit", (code) => {
         if (code === 0) resolve2();
         else reject(new Error("railway login failed."));
@@ -9087,7 +10028,7 @@ var RailwayProvider = class {
     }
     resetStdinForChild4();
     return new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process13.spawn)(
+      const proc = (0, import_child_process15.spawn)(
         "railway",
         ["shell", "--project", projectId, "--service", serviceId, "--command", command2],
         { stdio: "inherit" }
@@ -9111,8 +10052,8 @@ var RailwayProvider = class {
     const tarEnv = { ...process.env, COPYFILE_DISABLE: "1" };
     const remoteCmd = `mkdir -p ${shellQuote4(remoteDir)} && tar -xzf - -C ${shellQuote4(remoteDir)}`;
     await new Promise((resolve2, reject) => {
-      const tar = (0, import_child_process13.spawn)("tar", tarArgs, { stdio: ["ignore", "pipe", "pipe"], env: tarEnv });
-      const sh = (0, import_child_process13.spawn)(
+      const tar = (0, import_child_process15.spawn)("tar", tarArgs, { stdio: ["ignore", "pipe", "pipe"], env: tarEnv });
+      const sh = (0, import_child_process15.spawn)(
         "railway",
         ["shell", "--project", projectId, "--service", serviceId, "--command", remoteCmd],
         { stdio: [tar.stdout, "pipe", "pipe"] }
@@ -9138,14 +10079,14 @@ var RailwayProvider = class {
     if (!projectId || !serviceId) {
       throw new Error("Invalid Railway workspace id (expected projectId/serviceId).");
     }
-    const remoteDir = path22.posix.dirname(remotePath);
+    const remoteDir = path23.posix.dirname(remotePath);
     const parts = [`mkdir -p ${shellQuote4(remoteDir)}`, `cat > ${shellQuote4(remotePath)}`];
     if (options.mode != null) {
       parts.push(`chmod ${options.mode.toString(8)} ${shellQuote4(remotePath)}`);
     }
     const cmd = parts.join(" && ");
     await new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process13.spawn)(
+      const proc = (0, import_child_process15.spawn)(
         "railway",
         ["shell", "--project", projectId, "--service", serviceId, "--command", cmd],
         { stdio: ["pipe", "pipe", "pipe"] }
@@ -9680,7 +10621,7 @@ async function stopWorkspaceFromLocal(target) {
 // src/commands/version.ts
 var import_picocolors11 = __toESM(require("picocolors"));
 function version() {
-  const v = true ? "2.15.2" : "unknown";
+  const v = true ? "2.15.6" : "unknown";
   console.log(`${import_picocolors11.default.bold("codeam-cli")} ${import_picocolors11.default.cyan(v)}`);
 }
 
@@ -9723,16 +10664,16 @@ function help() {
 // src/lib/updateNotifier.ts
 var fs16 = __toESM(require("fs"));
 var os15 = __toESM(require("os"));
-var path23 = __toESM(require("path"));
-var https5 = __toESM(require("https"));
+var path24 = __toESM(require("path"));
+var https7 = __toESM(require("https"));
 var import_picocolors13 = __toESM(require("picocolors"));
 var PKG_NAME = "codeam-cli";
 var REGISTRY_URL = `https://registry.npmjs.org/${PKG_NAME}/latest`;
 var TTL_MS = 24 * 60 * 60 * 1e3;
 var REQUEST_TIMEOUT_MS = 1500;
 function cachePath() {
-  const dir = path23.join(os15.homedir(), ".codeam");
-  return path23.join(dir, "update-check.json");
+  const dir = path24.join(os15.homedir(), ".codeam");
+  return path24.join(dir, "update-check.json");
 }
 function readCache() {
   try {
@@ -9747,7 +10688,7 @@ function readCache() {
 function writeCache(cache) {
   try {
     const file = cachePath();
-    fs16.mkdirSync(path23.dirname(file), { recursive: true });
+    fs16.mkdirSync(path24.dirname(file), { recursive: true });
     fs16.writeFileSync(file, JSON.stringify(cache));
   } catch {
   }
@@ -9767,7 +10708,7 @@ function compareSemver(a, b) {
 }
 function fetchLatest() {
   return new Promise((resolve2) => {
-    const req = https5.get(
+    const req = https7.get(
       REGISTRY_URL,
       { headers: { Accept: "application/json" }, timeout: REQUEST_TIMEOUT_MS },
       (res) => {
@@ -9819,7 +10760,7 @@ function checkForUpdates() {
   if (process.env.CODEAM_DISABLE_UPDATE_CHECK === "1") return;
   if (process.env.CI) return;
   if (!process.stdout.isTTY) return;
-  const current = true ? "2.15.2" : null;
+  const current = true ? "2.15.6" : null;
   if (!current) return;
   const cache = readCache();
   const fresh = cache && Date.now() - cache.fetchedAt < TTL_MS;