codeam-cli 2.27.1 → 2.27.2

package/dist/index.js

@@ -300,6 +300,18 @@ var AGENT_REGISTRY = {
     // this via the existing --api-key escape hatch in commands/link.ts.
     supportedAuthKinds: ["api_key"],
     preferredAuthKind: "api_key"
+  },
+  gemini: {
+    id: "gemini",
+    displayName: "Gemini CLI",
+    binaryName: "gemini",
+    enabled: true,
+    // Gemini speaks ACP natively via `gemini --acp` — pairing flows
+    // through the ACP runtime, not a PTY parser. Auth is the user's
+    // existing `gemini auth login` (OAuth) or GEMINI_API_KEY env var,
+    // both managed by the gemini binary itself.
+    supportedAuthKinds: ["api_key"],
+    preferredAuthKind: "api_key"
   }
 };
 function getEnabledAgents() {
@@ -311,7 +323,7 @@ function getAgent(id) {
   return meta;
 }
 function isKnownAgentId(id) {
-  return id === "claude" || id === "codex" || id === "copilot" || id === "coderabbit" || id === "cursor" || id === "aider";
+  return id === "claude" || id === "codex" || id === "copilot" || id === "coderabbit" || id === "cursor" || id === "aider" || id === "gemini";
 }
 
 // ../../packages/shared/src/api-url.ts
@@ -486,7 +498,7 @@ var import_qrcode_terminal = __toESM(require("qrcode-terminal"));
 // package.json
 var package_default = {
   name: "codeam-cli",
-  version: "2.27.1",
+  version: "2.27.2",
   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",
@@ -556,8 +568,12 @@ var package_default = {
     node: ">=18.0.0"
   },
   dependencies: {
+    "@agentclientprotocol/claude-agent-acp": "^0.42.0",
+    "@agentclientprotocol/codex-acp": "^0.0.45",
+    "@agentclientprotocol/sdk": "^0.25.0",
     "@clack/prompts": "^1.2.0",
     chokidar: "^3.6.0",
+    "cursor-agent-acp": "^0.1.1",
     picocolors: "^1.1.0",
     "qrcode-terminal": "^0.12.0",
     which: "^5.0.0",
@@ -853,7 +869,7 @@ async function postPreviewEvent(input) {
   }
 }
 async function _postJsonAuthed(url, body, pluginAuthToken) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const data = JSON.stringify(body);
     const u2 = new URL(url);
     const transport = u2.protocol === "https:" ? https : http;
@@ -874,8 +890,8 @@ async function _postJsonAuthed(url, body, pluginAuthToken) {
       (res) => {
         res.on("error", reject);
         let responseBody = "";
-        res.on("data", (chunk) => {
-          responseBody += chunk.toString();
+        res.on("data", (chunk2) => {
+          responseBody += chunk2.toString();
         });
         res.on("end", () => {
           if (res.statusCode && res.statusCode >= 400) {
@@ -885,9 +901,9 @@ async function _postJsonAuthed(url, body, pluginAuthToken) {
             return;
           }
           try {
-            resolve5(JSON.parse(responseBody));
+            resolve6(JSON.parse(responseBody));
           } catch {
-            resolve5(null);
+            resolve6(null);
           }
         });
       }
@@ -902,7 +918,7 @@ async function _postJsonAuthed(url, body, pluginAuthToken) {
   });
 }
 async function _postJson(url, body) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const data = JSON.stringify(body);
     const u2 = new URL(url);
     const transport = u2.protocol === "https:" ? https : http;
@@ -922,8 +938,8 @@ async function _postJson(url, body) {
       (res) => {
         res.on("error", reject);
         let body2 = "";
-        res.on("data", (chunk) => {
-          body2 += chunk.toString();
+        res.on("data", (chunk2) => {
+          body2 += chunk2.toString();
         });
         res.on("end", () => {
           if (res.statusCode && res.statusCode >= 400) {
@@ -931,9 +947,9 @@ async function _postJson(url, body) {
             return;
           }
           try {
-            resolve5(JSON.parse(body2));
+            resolve6(JSON.parse(body2));
           } catch {
-            resolve5(null);
+            resolve6(null);
           }
         });
       }
@@ -948,7 +964,7 @@ async function _postJson(url, body) {
   });
 }
 async function _getJson(url) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const u2 = new URL(url);
     const transport = u2.protocol === "https:" ? https : http;
     const req = transport.request(
@@ -963,8 +979,8 @@ async function _getJson(url) {
       (res) => {
         res.on("error", reject);
         let body = "";
-        res.on("data", (chunk) => {
-          body += chunk.toString();
+        res.on("data", (chunk2) => {
+          body += chunk2.toString();
         });
         res.on("end", () => {
           if (res.statusCode && res.statusCode >= 400) {
@@ -972,9 +988,9 @@ async function _getJson(url) {
             return;
           }
           try {
-            resolve5(JSON.parse(body));
+            resolve6(JSON.parse(body));
           } catch {
-            resolve5(null);
+            resolve6(null);
           }
         });
       }
@@ -1144,8 +1160,8 @@ function createGetModuleFromFilename(basePath = process.argv[1] ? (0, import_pat
     return decodedFile;
   };
 }
-function normalizeWindowsPath(path43) {
-  return path43.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
+function normalizeWindowsPath(path44) {
+  return path44.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
 }
 
 // ../../node_modules/@posthog/core/dist/featureFlagUtils.mjs
@@ -3625,15 +3641,15 @@ async function addSourceContext(frames) {
   LRU_FILE_CONTENTS_CACHE.reduce();
   return frames;
 }
-function getContextLinesFromFile(path43, ranges, output) {
-  return new Promise((resolve5) => {
-    const stream = (0, import_node_fs.createReadStream)(path43);
+function getContextLinesFromFile(path44, ranges, output) {
+  return new Promise((resolve6) => {
+    const stream = (0, import_node_fs.createReadStream)(path44);
     const lineReaded = (0, import_node_readline.createInterface)({
       input: stream
     });
     function destroyStreamAndResolve() {
       stream.destroy();
-      resolve5();
+      resolve6();
     }
     let lineNumber = 0;
     let currentRangeIndex = 0;
@@ -3642,7 +3658,7 @@ function getContextLinesFromFile(path43, ranges, output) {
     let rangeStart = range[0];
     let rangeEnd = range[1];
     function onStreamError() {
-      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path43, 1);
+      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path44, 1);
       lineReaded.close();
       lineReaded.removeAllListeners();
       destroyStreamAndResolve();
@@ -3703,8 +3719,8 @@ function clearLineContext(frame) {
   delete frame.context_line;
   delete frame.post_context;
 }
-function shouldSkipContextLinesForFile(path43) {
-  return path43.startsWith("node:") || path43.endsWith(".min.js") || path43.endsWith(".min.cjs") || path43.endsWith(".min.mjs") || path43.startsWith("data:");
+function shouldSkipContextLinesForFile(path44) {
+  return path44.startsWith("node:") || path44.endsWith(".min.js") || path44.endsWith(".min.cjs") || path44.endsWith(".min.mjs") || path44.startsWith("data:");
 }
 function shouldSkipContextLinesForFrame(frame) {
   if (void 0 !== frame.lineno && frame.lineno > MAX_CONTEXTLINES_LINENO) return true;
@@ -4920,9 +4936,9 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     if (!waitUntil) return;
     if (this.disabled || this.optedOut) return;
     if (!this._waitUntilCycle) {
-      let resolve5;
+      let resolve6;
       const promise = new Promise((r) => {
-        resolve5 = r;
+        resolve6 = r;
       });
       try {
         waitUntil(promise);
@@ -4930,7 +4946,7 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
         return;
       }
       this._waitUntilCycle = {
-        resolve: resolve5,
+        resolve: resolve6,
         startedAt: Date.now(),
         timer: void 0
       };
@@ -4954,12 +4970,12 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     return cycle?.resolve;
   }
   async resolveWaitUntilFlush() {
-    const resolve5 = this._consumeWaitUntilCycle();
+    const resolve6 = this._consumeWaitUntilCycle();
     try {
       await super.flush();
     } catch {
     } finally {
-      resolve5?.();
+      resolve6?.();
     }
   }
   getPersistedProperty(key) {
@@ -5051,15 +5067,15 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
   async waitForLocalEvaluationReady(timeoutMs = THIRTY_SECONDS) {
     if (this.isLocalEvaluationReady()) return true;
     if (void 0 === this.featureFlagsPoller) return false;
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       const timeout = setTimeout(() => {
         cleanup();
-        resolve5(false);
+        resolve6(false);
       }, timeoutMs);
       const cleanup = this._events.on("localEvaluationFlagsLoaded", (count) => {
         clearTimeout(timeout);
         cleanup();
-        resolve5(count > 0);
+        resolve6(count > 0);
       });
     });
   }
@@ -5496,13 +5512,13 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     this.context?.enter(data, options);
   }
   async _shutdown(shutdownTimeoutMs) {
-    const resolve5 = this._consumeWaitUntilCycle();
+    const resolve6 = this._consumeWaitUntilCycle();
     await this.featureFlagsPoller?.stopPoller(shutdownTimeoutMs);
     this.errorTracking.shutdown();
     try {
       return await super._shutdown(shutdownTimeoutMs);
     } finally {
-      resolve5?.();
+      resolve6?.();
     }
   }
   async _requestRemoteConfigPayload(flagKey) {
@@ -5858,7 +5874,7 @@ function readAnonId() {
 }
 function superProperties() {
   return {
-    cliVersion: true ? "2.27.1" : "0.0.0-dev",
+    cliVersion: true ? "2.27.2" : "0.0.0-dev",
     nodeVersion: process.version,
     platform: process.platform,
     arch: process.arch,
@@ -6065,9 +6081,9 @@ var CommandRelayService = class {
         this.armSseWatchdog();
         let buffer = "";
         res.setEncoding("utf8");
-        res.on("data", (chunk) => {
+        res.on("data", (chunk2) => {
           this.sseLastByteAt = Date.now();
-          buffer += chunk;
+          buffer += chunk2;
           let frameEnd;
           while ((frameEnd = buffer.indexOf("\n\n")) !== -1) {
             const frame = buffer.slice(0, frameEnd);
@@ -6736,9 +6752,9 @@ var UnixPtyStrategy = class {
       );
       process.exit(1);
     });
-    this.proc.stdout?.on("data", (chunk) => {
-      process.stdout.write(chunk);
-      this.opts.onData(chunk.toString("utf8"));
+    this.proc.stdout?.on("data", (chunk2) => {
+      process.stdout.write(chunk2);
+      this.opts.onData(chunk2.toString("utf8"));
     });
     if (process.stdin.isTTY) process.stdin.setRawMode(true);
     process.stdin.resume();
@@ -6830,8 +6846,8 @@ var UnixPtyStrategy = class {
       }
     }
   }
-  stdinHandler = (chunk) => {
-    this.proc?.stdin?.write(chunk);
+  stdinHandler = (chunk2) => {
+    this.proc?.stdin?.write(chunk2);
   };
   handleResize = () => {
     if (this.proc?.pid) {
@@ -7017,8 +7033,8 @@ var WindowsConPtyStrategy = class _WindowsConPtyStrategy {
     }
     this.pty = null;
   }
-  stdinHandler = (chunk) => {
-    this.pty?.write(chunk.toString("utf8"));
+  stdinHandler = (chunk2) => {
+    this.pty?.write(chunk2.toString("utf8"));
   };
 };
 
@@ -7051,9 +7067,9 @@ var WindowsPtyStrategy = class {
       );
       process.exit(1);
     });
-    this.proc.stdout?.on("data", (chunk) => {
-      process.stdout.write(chunk);
-      this.opts.onData(chunk.toString("utf8"));
+    this.proc.stdout?.on("data", (chunk2) => {
+      process.stdout.write(chunk2);
+      this.opts.onData(chunk2.toString("utf8"));
     });
     this.proc.stdin?.write("");
     if (process.stdin.isTTY) process.stdin.setRawMode(true);
@@ -7080,8 +7096,8 @@ var WindowsPtyStrategy = class {
       }
     }
   }
-  stdinHandler = (chunk) => {
-    this.proc?.stdin?.write(chunk);
+  stdinHandler = (chunk2) => {
+    this.proc?.stdin?.write(chunk2);
   };
 };
 
@@ -9159,15 +9175,15 @@ function runInstaller() {
     "-Command",
     "irm https://claude.ai/install.ps1 | iex"
   ] : ["-c", "curl -fsSL https://claude.ai/install.sh | bash"];
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const proc = (0, import_child_process4.spawn)(cmd, args2, { stdio: "inherit" });
     proc.on("error", (err) => {
       console.error(`
   \u2717 Installer failed to launch: ${err.message}`);
-      resolve5(false);
+      resolve6(false);
     });
     proc.on("exit", (code) => {
-      resolve5(code === 0);
+      resolve6(code === 0);
     });
   });
 }
@@ -9344,17 +9360,17 @@ function parseUsageOutput(raw) {
   return { percent, resetAt };
 }
 async function fetchClaudeQuota() {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const claudeCmd = findInPath("claude") ? "claude" : "claude-code";
     if (!claudeCmd) {
-      resolve5(null);
+      resolve6(null);
       return;
     }
     const helperPath = path11.join(os10.tmpdir(), "codeam-quota-helper.py");
     fs8.writeFileSync(helperPath, HELPER_SCRIPT, { mode: 420 });
     const python = findInPath("python3") ?? findInPath("python");
     if (!python) {
-      resolve5(null);
+      resolve6(null);
       return;
     }
     const proc = (0, import_child_process5.spawn)(python, [helperPath, claudeCmd, "--tools", ""], {
@@ -9364,8 +9380,8 @@ async function fetchClaudeQuota() {
     });
     let output = "";
     let resolved = false;
-    proc.stdout?.on("data", (chunk) => {
-      output += chunk.toString("utf8");
+    proc.stdout?.on("data", (chunk2) => {
+      output += chunk2.toString("utf8");
     });
     setTimeout(() => {
       proc.stdin?.write("/usage\r");
@@ -9381,13 +9397,13 @@ async function fetchClaudeQuota() {
           fs8.unlinkSync(helperPath);
         } catch {
         }
-        resolve5(result);
+        resolve6(result);
       }, 5e3);
     }, 8e3);
     setTimeout(() => {
       if (!resolved) {
         resolved = true;
-        resolve5(null);
+        resolve6(null);
       }
       try {
         proc.kill();
@@ -9418,12 +9434,12 @@ function killActiveSpawnAndCaptureChildren() {
 }
 async function spawnAndCapture(cmd, args2, opts = {}) {
   const timeoutMs = opts.timeoutMs ?? 6e4;
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     let settled = false;
     const settle = (value) => {
       if (settled) return;
       settled = true;
-      resolve5(value);
+      resolve6(value);
     };
     let child;
     try {
@@ -9438,11 +9454,11 @@ async function spawnAndCapture(cmd, args2, opts = {}) {
     }
     activeChildren.add(child);
     let stdout = "";
-    child.stdout?.on("data", (chunk) => {
-      stdout += chunk.toString("utf8");
+    child.stdout?.on("data", (chunk2) => {
+      stdout += chunk2.toString("utf8");
     });
-    child.stderr?.on("data", (chunk) => {
-      opts.onStderr?.(chunk.toString("utf8"));
+    child.stderr?.on("data", (chunk2) => {
+      opts.onStderr?.(chunk2.toString("utf8"));
     });
     const timer = setTimeout(() => {
       try {
@@ -9930,13 +9946,13 @@ function detectStartupBanner(lines) {
   while (artStart > 0 && BANNER_ART_RE.test(lines[artStart - 1])) artStart--;
   if (metaIdx - artStart < 2) return null;
   const pathLine = (lines[metaIdx + 1] ?? "").trim();
-  const path43 = pathLine && !BANNER_ART_RE.test(pathLine) ? pathLine : "";
+  const path44 = pathLine && !BANNER_ART_RE.test(pathLine) ? pathLine : "";
   return {
     title: "",
     subtitle: lines[metaIdx].trim(),
-    path: path43,
+    path: path44,
     startIdx: artStart,
-    endIdx: metaIdx + (path43 ? 1 : 0)
+    endIdx: metaIdx + (path44 ? 1 : 0)
   };
 }
 
@@ -11090,12 +11106,12 @@ function resolveNpm(os27) {
   return os27.id === "win32" ? "npm.cmd" : "npm";
 }
 async function installCodexViaNpm(os27) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const proc = (0, import_node_child_process4.spawn)(resolveNpm(os27), ["install", "-g", "@openai/codex"], {
       stdio: "inherit"
     });
     proc.on("close", (code) => {
-      if (code === 0) resolve5();
+      if (code === 0) resolve6();
       else reject(new Error(`npm install -g @openai/codex exited ${code}`));
     });
     proc.on("error", (err) => {
@@ -11210,12 +11226,12 @@ async function ensureCoderabbitInstalled(os27) {
     return false;
   }
   console.log("\n  CodeRabbit CLI not found \u2014 installing via the official script\u2026\n");
-  const ok = await new Promise((resolve5) => {
+  const ok = await new Promise((resolve6) => {
     const proc = (0, import_node_child_process5.spawn)("sh", ["-c", `curl -fsSL ${INSTALL_URL} | sh`], {
       stdio: "inherit"
     });
-    proc.on("close", (code) => resolve5(code === 0));
-    proc.on("error", () => resolve5(false));
+    proc.on("close", (code) => resolve6(code === 0));
+    proc.on("error", () => resolve6(false));
   });
   if (!ok) return false;
   os27.augmentPath([`${os27.homeDir()}/.local/bin`, "/opt/homebrew/bin"]);
@@ -11272,11 +11288,11 @@ function parseReview(stdout) {
   for (const line of lines) {
     const m = line.match(HUNK_LINE_RE);
     if (!m) continue;
-    const [, path43, lineNo, sevToken, message] = m;
-    if (!path43 || !lineNo || !message) continue;
+    const [, path44, lineNo, sevToken, message] = m;
+    if (!path44 || !lineNo || !message) continue;
     const cleanedMessage = message.trim().replace(/^[*-]\s+/, "");
     hunks.push({
-      path: path43.trim(),
+      path: path44.trim(),
       line: Number(lineNo),
       severity: sevToken ? SEVERITY_MAP[sevToken.toLowerCase()] : void 0,
       message: cleanedMessage
@@ -11334,7 +11350,7 @@ var CoderabbitRuntimeStrategy = class {
   }
   async runOneShot(input) {
     const launch = await this.prepareInvocation(input);
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const stdoutBuf = [];
       const stderrBuf = [];
       const proc = (0, import_node_child_process7.spawn)(launch.cmd, launch.args, {
@@ -11345,7 +11361,7 @@ var CoderabbitRuntimeStrategy = class {
       proc.stderr?.on("data", (b) => stderrBuf.push(b));
       proc.on("error", (err) => reject(err));
       proc.on("close", (code) => {
-        resolve5(
+        resolve6(
           this.parseOutput({
             exitCode: code ?? 0,
             stdout: Buffer.concat(stdoutBuf).toString("utf8"),
@@ -11795,6 +11811,681 @@ function createDeployStrategy(agent) {
   return build();
 }
 
+// src/agents/acp/adapters.ts
+var path24 = __toESM(require("path"));
+var require_ = require;
+function resolveBin(pkgName, binName) {
+  try {
+    const manifestPath = require_.resolve(`${pkgName}/package.json`);
+    const manifest = require_(`${pkgName}/package.json`);
+    const pkgDir = path24.dirname(manifestPath);
+    const bin = manifest.bin;
+    if (!bin) return null;
+    if (typeof bin === "string") return path24.resolve(pkgDir, bin);
+    const target = binName ?? Object.keys(bin)[0];
+    if (!target || !bin[target]) return null;
+    return path24.resolve(pkgDir, bin[target]);
+  } catch {
+    return null;
+  }
+}
+var REGISTRY = {
+  claude: () => {
+    const bin = resolveBin("@agentclientprotocol/claude-agent-acp", "claude-agent-acp");
+    if (!bin) return null;
+    return {
+      command: process.execPath,
+      args: [bin],
+      requiresAgentBinary: "claude"
+    };
+  },
+  codex: () => {
+    const bin = resolveBin("@agentclientprotocol/codex-acp", "codex-acp");
+    if (!bin) return null;
+    return {
+      command: process.execPath,
+      args: [bin],
+      requiresAgentBinary: "codex"
+    };
+  },
+  cursor: () => {
+    const bin = resolveBin("cursor-agent-acp", "cursor-agent-acp");
+    if (!bin) return null;
+    return {
+      command: process.execPath,
+      args: [bin],
+      requiresAgentBinary: "cursor-agent"
+    };
+  },
+  // Gemini speaks ACP natively via `gemini --acp` — no npm adapter
+  // package, just the user-installed `gemini` binary on PATH. Same
+  // {@link AdapterSpec} shape; the only difference is `command` is
+  // resolved from PATH at spawn time instead of being absolute.
+  gemini: () => ({
+    command: "gemini",
+    args: ["--acp"],
+    requiresAgentBinary: "gemini"
+  })
+};
+function getAcpAdapter(agent) {
+  const factory = REGISTRY[agent];
+  return factory ? factory() : null;
+}
+
+// src/agents/acp/runner.ts
+var import_node_crypto6 = require("crypto");
+
+// src/agents/acp/client.ts
+var import_node_child_process10 = require("child_process");
+var fs20 = __toESM(require("fs/promises"));
+var import_node_stream = require("stream");
+var import_sdk = require("@agentclientprotocol/sdk");
+var PROTOCOL_VERSION2 = 1;
+var CLIENT_CAPABILITIES = {
+  fs: { readTextFile: true, writeTextFile: true },
+  terminal: false
+};
+var AcpClient = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  child = null;
+  connection = null;
+  stopping = false;
+  sessionId = null;
+  /**
+   * Spawn the adapter + perform the initial handshake (initialize
+   * → newSession). Returns the ACP-assigned sessionId so the
+   * caller can route subsequent prompts.
+   */
+  async start() {
+    if (this.child) throw new Error("AcpClient already started");
+    const { adapter, cwd } = this.opts;
+    const child = (0, import_node_child_process10.spawn)(adapter.command, adapter.args, {
+      cwd,
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.child = child;
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (chunk2) => {
+      for (const line of chunk2.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (trimmed) this.opts.onStderr?.(trimmed);
+      }
+    });
+    child.on("exit", (code, signal) => {
+      if (this.stopping) return;
+      log.warn("acpClient", `adapter exited unexpectedly code=${code} signal=${signal}`);
+      this.opts.onUnexpectedExit?.(code, signal);
+    });
+    if (!child.stdin || !child.stdout) {
+      throw new Error("Spawned ACP adapter is missing stdio handles");
+    }
+    const input = import_node_stream.Readable.toWeb(child.stdout);
+    const output = import_node_stream.Writable.toWeb(child.stdin);
+    const stream = (0, import_sdk.ndJsonStream)(output, input);
+    this.connection = new import_sdk.ClientSideConnection(
+      (_agent) => this.buildClient(),
+      stream
+    );
+    const initialize = await this.connection.initialize({
+      protocolVersion: PROTOCOL_VERSION2,
+      clientCapabilities: CLIENT_CAPABILITIES
+    });
+    const newSession = await this.connection.newSession({
+      cwd,
+      mcpServers: []
+    });
+    this.sessionId = newSession.sessionId;
+    return { sessionId: newSession.sessionId, initialize };
+  }
+  /**
+   * Send a user prompt to the active session. Returns the
+   * {@link PromptResponse} which carries the agent's stop reason
+   * once the turn finishes. Session/update notifications keep
+   * arriving on `onSessionUpdate` while the turn streams.
+   */
+  async prompt(text) {
+    if (!this.connection || !this.sessionId) {
+      throw new Error("AcpClient.prompt called before start()");
+    }
+    return this.connection.prompt({
+      sessionId: this.sessionId,
+      prompt: [{ type: "text", text }]
+    });
+  }
+  /**
+   * Cancel the in-flight prompt turn. Notification — no response.
+   * Safe to call when nothing is in flight (the adapter no-ops).
+   */
+  async cancel() {
+    if (!this.connection || !this.sessionId) return;
+    await this.connection.cancel({ sessionId: this.sessionId });
+  }
+  /**
+   * Kill the adapter process and tear down the connection. Safe
+   * to call multiple times. Suppresses the unexpected-exit
+   * callback for this teardown.
+   */
+  async stop() {
+    this.stopping = true;
+    const child = this.child;
+    if (!child) return;
+    this.child = null;
+    this.connection = null;
+    this.sessionId = null;
+    try {
+      child.kill("SIGTERM");
+      const grace = new Promise((resolve6) => {
+        const t2 = setTimeout(() => {
+          try {
+            child.kill("SIGKILL");
+          } catch {
+          }
+          resolve6();
+        }, 2e3);
+        child.once("exit", () => {
+          clearTimeout(t2);
+          resolve6();
+        });
+      });
+      await grace;
+    } catch (err) {
+      log.trace("acpClient", "stop teardown error", err);
+    }
+  }
+  // ─── Client surface (what the agent calls into) ───────────────────
+  buildClient() {
+    return {
+      sessionUpdate: async (params) => {
+        this.opts.onSessionUpdate(params);
+      },
+      requestPermission: (params) => {
+        return this.opts.onRequestPermission(params);
+      },
+      readTextFile: async (params) => {
+        const content = await fs20.readFile(params.path, "utf8");
+        return applyLineRange(content, params.line ?? null, params.limit ?? null);
+      },
+      writeTextFile: async (params) => {
+        await fs20.writeFile(params.path, params.content, "utf8");
+        return {};
+      },
+      // Terminal capability is declared `false` above so adapters
+      // shouldn't call these; provide explicit "not implemented"
+      // stubs so a misbehaving adapter gets a clean error instead
+      // of a hung promise.
+      createTerminal: async () => {
+        throw new Error("terminal capability not implemented in this client (Phase 1)");
+      },
+      terminalOutput: async () => {
+        throw new Error("terminal capability not implemented in this client (Phase 1)");
+      },
+      releaseTerminal: async () => {
+        throw new Error("terminal capability not implemented in this client (Phase 1)");
+      },
+      waitForTerminalExit: async () => {
+        throw new Error("terminal capability not implemented in this client (Phase 1)");
+      },
+      killTerminal: async () => {
+        throw new Error("terminal capability not implemented in this client (Phase 1)");
+      }
+    };
+  }
+};
+function applyLineRange(content, line, limit) {
+  if (line === null && limit === null) return { content };
+  const lines = content.split("\n");
+  const start2 = Math.max(0, (line ?? 1) - 1);
+  const end = limit !== null ? start2 + limit : lines.length;
+  return { content: lines.slice(start2, end).join("\n") };
+}
+
+// src/services/streaming/transport.ts
+var http3 = __toESM(require("http"));
+var https3 = __toESM(require("https"));
+var _transport2 = {
+  post: _post,
+  get: _get
+};
+function _post(url, headers, payload) {
+  return new Promise((resolve6, reject) => {
+    let settled = false;
+    const u2 = new URL(url);
+    const lib = u2.protocol === "https:" ? https3 : http3;
+    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;
+          resolve6({ 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((resolve6, reject) => {
+    let settled = false;
+    const u2 = new URL(url);
+    const lib = u2.protocol === "https:" ? https3 : http3;
+    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;
+          resolve6({ statusCode: res.statusCode ?? 0, body });
+        });
+      }
+    );
+    req.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      reject(err);
+    });
+    req.on("timeout", () => {
+      req.destroy();
+    });
+    req.end();
+  });
+}
+
+// src/agents/acp/publisher.ts
+var AcpPublisher = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.apiBase = opts.apiBaseUrl ?? resolveApiBaseUrl();
+    this.headers = {
+      "Content-Type": "application/json",
+      "X-Codeam-Protocol-Version": "2.0.0",
+      "X-Plugin-Auth-Token": opts.pluginAuthToken
+    };
+  }
+  opts;
+  apiBase;
+  headers;
+  /**
+   * Fire-and-forget chunk POST. The backend's per-user SSE bus
+   * forwards each chunk to mobile/landing within ~20 ms (PRO) /
+   * ~80 ms (FREE). Errors are logged but never thrown — a missed
+   * chunk shouldn't bring down the whole session.
+   */
+  async publishChunk(event) {
+    const url = `${this.apiBase}/api/sessions/${encodeURIComponent(this.opts.sessionId)}/streaming-chunk`;
+    try {
+      const { statusCode, body } = await _transport2.post(
+        url,
+        this.headers,
+        JSON.stringify(event)
+      );
+      if (statusCode < 200 || statusCode >= 300) {
+        log.warn("acpPublisher", `chunk status=${statusCode} body=${body.slice(0, 200)}`);
+      }
+    } catch (err) {
+      log.trace("acpPublisher", "chunk post failed", err);
+    }
+  }
+  /**
+   * Publish an awaiting-answer event so the mobile renders the
+   * pending-prompt sheet. The CLI follows up with
+   * {@link pollPendingAnswer} until the user replies (or the
+   * 5 min Redis TTL expires upstream).
+   */
+  async publishAwaitingAnswer(event) {
+    const url = `${this.apiBase}/api/sessions/${encodeURIComponent(this.opts.sessionId)}/awaiting-answer`;
+    try {
+      const { statusCode, body } = await _transport2.post(
+        url,
+        this.headers,
+        JSON.stringify(event)
+      );
+      if (statusCode < 200 || statusCode >= 300) {
+        log.warn("acpPublisher", `awaiting-answer status=${statusCode} body=${body.slice(0, 200)}`);
+      }
+    } catch (err) {
+      log.trace("acpPublisher", "awaiting-answer post failed", err);
+    }
+  }
+  /**
+   * Drain the pending-answer endpoint. Returns the resolved answer
+   * when the user has replied, `null` otherwise. The caller polls
+   * this on a 1.5 s cadence (same as the legacy emitter) until a
+   * non-null result lands.
+   */
+  async pollPendingAnswer(questionId) {
+    const url = `${this.apiBase}/api/sessions/${encodeURIComponent(this.opts.sessionId)}/pending-answer?questionId=${encodeURIComponent(questionId)}&pluginId=${encodeURIComponent(this.opts.pluginId)}`;
+    try {
+      const { statusCode, body } = await _transport2.get(url, this.headers);
+      if (statusCode === 204 || statusCode === 404) return null;
+      if (statusCode < 200 || statusCode >= 300) {
+        log.warn("acpPublisher", `pending-answer status=${statusCode} body=${body.slice(0, 200)}`);
+        return null;
+      }
+      return parsePendingAnswerResponse(body, questionId);
+    } catch (err) {
+      log.trace("acpPublisher", "pending-answer poll failed", err);
+      return null;
+    }
+  }
+};
+function parsePendingAnswerResponse(body, questionId) {
+  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 qid = candidate.questionId;
+  const answer = candidate.answer;
+  const optionIndex = candidate.optionIndex;
+  if (typeof qid !== "string" || qid !== questionId) return null;
+  if (typeof answer !== "string") return null;
+  const result = { questionId: qid, answer };
+  if (typeof optionIndex === "number" && Number.isInteger(optionIndex)) {
+    result.optionIndex = optionIndex;
+  }
+  return result;
+}
+
+// src/agents/acp/mappers.ts
+var import_node_crypto5 = require("crypto");
+function mapSessionUpdate(notification) {
+  const update = notification.update;
+  switch (update.sessionUpdate) {
+    case "agent_message_chunk": {
+      const text = extractText2(update.content);
+      if (!text) return [];
+      return [chunk(messageChunkId(update.messageId), "text", text)];
+    }
+    case "agent_thought_chunk": {
+      const text = extractText2(update.content);
+      if (!text) return [];
+      return [chunk(messageChunkId(update.messageId), "thinking", text)];
+    }
+    case "tool_call": {
+      const summary = describeToolCall(update);
+      if (!summary) return [];
+      return [chunk(update.toolCallId, "tool_use", summary)];
+    }
+    case "tool_call_update": {
+      if (update.status !== "completed" && update.status !== "failed") {
+        return [];
+      }
+      const body = describeToolCallUpdate(update);
+      if (!body) return [];
+      const prefix = update.status === "failed" ? "[failed] " : "";
+      return [chunk(update.toolCallId, "tool_result", prefix + body)];
+    }
+    case "user_message_chunk":
+      return [];
+    case "plan":
+    case "plan_update":
+    case "plan_removed":
+    case "available_commands_update":
+    case "current_mode_update":
+    case "config_option_update":
+    case "session_info_update":
+    case "usage_update":
+      return [];
+    default:
+      return [];
+  }
+}
+function mapPermissionRequest(request) {
+  const prompt = describeToolCall(request.toolCall) ?? "The agent requested permission to continue.";
+  const optionIdByLabel = {};
+  const kindByLabel = {};
+  const labels = [];
+  for (const opt of request.options) {
+    const label = opt.name?.trim() || humanizeKind(opt.kind);
+    if (label in optionIdByLabel) continue;
+    optionIdByLabel[label] = opt.optionId;
+    kindByLabel[label] = opt.kind;
+    labels.push(label);
+  }
+  return {
+    event: {
+      questionId: (0, import_node_crypto5.randomUUID)(),
+      prompt,
+      options: labels.length > 0 ? labels : void 0
+    },
+    optionIdByLabel,
+    kindByLabel
+  };
+}
+function chunk(chunkId, kind, content) {
+  return { chunkId, kind, content, isFinal: true };
+}
+function messageChunkId(messageId) {
+  if (typeof messageId === "string" && messageId.length > 0) return messageId;
+  return (0, import_node_crypto5.randomUUID)();
+}
+function extractText2(content) {
+  if (!content || typeof content !== "object") return null;
+  if ("type" in content && content.type === "text") {
+    const t2 = content.text;
+    return typeof t2 === "string" && t2.length > 0 ? t2 : null;
+  }
+  return null;
+}
+function describeToolCall(call) {
+  const title = call.title?.trim();
+  const kind = call.kind?.trim();
+  if (title && title.length > 0) return title;
+  if (kind && kind.length > 0) return kind;
+  if (call.rawInput && typeof call.rawInput === "object") {
+    try {
+      const summary = JSON.stringify(call.rawInput);
+      if (summary.length > 240) return `${summary.slice(0, 240)}\u2026`;
+      return summary;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function describeToolCallUpdate(update) {
+  const parts = [];
+  if (Array.isArray(update.content)) {
+    for (const item of update.content) {
+      if (!item || typeof item !== "object") continue;
+      if (item.type === "content" && item.content) {
+        const text = extractText2(item.content);
+        if (text) parts.push(text);
+      } else if (item.type === "diff") {
+        const p2 = item.path;
+        parts.push(p2 ? `diff: ${p2}` : "diff");
+      } else if (item.type === "terminal") {
+        const id = item.terminalId;
+        parts.push(id ? `terminal: ${id}` : "terminal");
+      }
+    }
+  }
+  if (parts.length > 0) return parts.join("\n");
+  const title = update.title?.trim();
+  return title && title.length > 0 ? title : null;
+}
+function humanizeKind(kind) {
+  switch (kind) {
+    case "allow_once":
+      return "Allow once";
+    case "allow_always":
+      return "Always allow";
+    case "reject_once":
+      return "Reject";
+    case "reject_always":
+      return "Always reject";
+    default:
+      return kind;
+  }
+}
+
+// src/agents/acp/runner.ts
+var ANSWER_POLL_MS = 1500;
+var PERMISSION_TIMEOUT_MS = 5 * 60 * 1e3;
+async function runAcpSession(opts) {
+  const publisher = new AcpPublisher({
+    sessionId: opts.sessionId,
+    pluginId: opts.pluginId,
+    pluginAuthToken: opts.pluginAuthToken
+  });
+  const client2 = new AcpClient({
+    adapter: opts.adapter,
+    cwd: opts.cwd,
+    onSessionUpdate: (notification) => {
+      const chunks = mapSessionUpdate(notification);
+      for (const chunk2 of chunks) {
+        void publisher.publishChunk(chunk2);
+      }
+    },
+    onRequestPermission: async (request) => {
+      const { event, optionIdByLabel } = mapPermissionRequest(request);
+      await publisher.publishAwaitingAnswer(event);
+      const answer = await waitForAnswer(publisher, event.questionId);
+      if (!answer) {
+        return { outcome: { outcome: "cancelled" } };
+      }
+      const optionId = optionIdByLabel[answer.answer];
+      if (!optionId) {
+        log.warn(
+          "acpRunner",
+          `pending-answer label not in option map; reply="${answer.answer.slice(0, 80)}"`
+        );
+        return { outcome: { outcome: "cancelled" } };
+      }
+      return { outcome: { outcome: "selected", optionId } };
+    },
+    onStderr: (line) => {
+      log.trace("acpAdapter", line);
+    },
+    onUnexpectedExit: (code, signal) => {
+      log.warn("acpRunner", `adapter died code=${code} signal=${signal}; shutting down session`);
+      void publisher.publishChunk({
+        chunkId: (0, import_node_crypto6.randomUUID)(),
+        kind: "text",
+        content: `Agent adapter exited unexpectedly (code=${code ?? "null"} signal=${signal ?? "null"}).`,
+        isFinal: true
+      });
+      process.exit(1);
+    }
+  });
+  showInfo(`Starting ${opts.agent} via ACP adapter (${opts.adapter.requiresAgentBinary})\u2026`);
+  const { sessionId: acpSessionId, initialize } = await client2.start();
+  log.trace(
+    "acpRunner",
+    `adapter handshake ok protocolVersion=${initialize.protocolVersion} sessionId=${acpSessionId.slice(0, 8)}`
+  );
+  const relay = new CommandRelayService(
+    opts.pluginId,
+    async (cmd) => {
+      await handleCommand(cmd, client2);
+    },
+    { id: opts.agent, name: opts.agent, displayName: opts.agent }
+  );
+  relay.start();
+  const shutdown = async (signal) => {
+    showInfo(`Shutting down ACP session (${signal})\u2026`);
+    relay.stop();
+    await client2.stop();
+    process.exit(0);
+  };
+  process.once("SIGINT", () => void shutdown("SIGINT"));
+  process.once("SIGTERM", () => void shutdown("SIGTERM"));
+  process.once("SIGHUP", () => void shutdown("SIGHUP"));
+  await new Promise(() => {
+  });
+}
+async function handleCommand(cmd, client2) {
+  switch (cmd.type) {
+    case "start_task": {
+      const payload = cmd.payload;
+      const prompt = payload?.prompt?.trim();
+      if (!prompt) {
+        log.warn("acpRunner", "start_task with empty prompt; ignoring");
+        return;
+      }
+      try {
+        await client2.prompt(prompt);
+      } catch (err) {
+        log.warn("acpRunner", `prompt failed: ${describeError(err)}`);
+      }
+      return;
+    }
+    case "stop_task":
+    case "escape_key": {
+      try {
+        await client2.cancel();
+      } catch (err) {
+        log.warn("acpRunner", `cancel failed: ${describeError(err)}`);
+      }
+      return;
+    }
+    default:
+      log.trace("acpRunner", `command type "${cmd.type}" not supported in Phase 1 ACP mode`);
+      return;
+  }
+}
+async function waitForAnswer(publisher, questionId) {
+  const deadline = Date.now() + PERMISSION_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    const reply = await publisher.pollPendingAnswer(questionId);
+    if (reply) return { answer: reply.answer };
+    await new Promise((r) => setTimeout(r, ANSWER_POLL_MS));
+  }
+  return null;
+}
+function describeError(err) {
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+
 // src/services/output/chrome-tracker.ts
 var ChromeStepTracker = class {
   history = [];
@@ -11841,12 +12532,12 @@ var ChromeStepTracker = class {
 };
 
 // src/services/output/chunk-emitter.ts
-var https3 = __toESM(require("https"));
-var http3 = __toESM(require("http"));
+var https4 = __toESM(require("https"));
+var http4 = __toESM(require("http"));
 var API_BASE3 = resolveApiBaseUrl();
 async function refreshAuthToken(sessionId, pluginId) {
   try {
-    const { statusCode, body } = await _transport2.post(
+    const { statusCode, body } = await _transport3.post(
       `${API_BASE3}/api/pairing/reconnect`,
       {
         "Content-Type": "application/json",
@@ -11909,14 +12600,14 @@ var ChunkEmitter = class {
       "chunkEmitter",
       `send type=${body.type ?? "(clear)"} bytes=${payload.length} done=${body.done === true}`
     );
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       const attempt = (attemptsLeft) => {
-        _transport2.post(this.url, this.headers, payload).then(({ statusCode, body: resBody }) => {
+        _transport3.post(this.url, this.headers, payload).then(({ statusCode, body: resBody }) => {
           const tookMs = Date.now() - t0;
           if (statusCode === 410 || statusCode === 404 && /SESSION_NOT_FOUND|SESSION_GONE/.test(resBody)) {
             process.stderr.write("[codeam] session was deleted/disconnected \u2014 stopping output stream.\n");
             log.info("chunkEmitter", `dead status=${statusCode} took=${tookMs}ms`);
-            resolve5({ dead: true });
+            resolve6({ dead: true });
             return;
           }
           if (statusCode === 401) {
@@ -11932,7 +12623,7 @@ var ChunkEmitter = class {
                   return;
                 }
               }
-              resolve5({ dead: false });
+              resolve6({ dead: false });
             })();
             return;
           }
@@ -11943,7 +12634,7 @@ var ChunkEmitter = class {
           } else {
             log.info("chunkEmitter", `ok status=${statusCode} took=${tookMs}ms`);
           }
-          resolve5({ dead: false });
+          resolve6({ dead: false });
         }).catch((err) => {
           log.warn(
             "chunkEmitter",
@@ -11954,7 +12645,7 @@ var ChunkEmitter = class {
             const delay = 200 * (maxRetries - attemptsLeft + 1);
             setTimeout(() => attempt(attemptsLeft - 1), delay);
           } else {
-            resolve5({ dead: false });
+            resolve6({ dead: false });
           }
         });
       };
@@ -11962,14 +12653,14 @@ var ChunkEmitter = class {
     });
   }
 };
-var _transport2 = {
-  post: _post
+var _transport3 = {
+  post: _post2
 };
-function _post(url, headers, payload) {
-  return new Promise((resolve5, reject) => {
+function _post2(url, headers, payload) {
+  return new Promise((resolve6, reject) => {
     let settled = false;
     const u2 = new URL(url);
-    const transport = u2.protocol === "https:" ? https3 : http3;
+    const transport = u2.protocol === "https:" ? https4 : http4;
     const req = transport.request(
       {
         hostname: u2.hostname,
@@ -11990,7 +12681,7 @@ function _post(url, headers, payload) {
         res.on("end", () => {
           if (settled) return;
           settled = true;
-          resolve5({ statusCode: res.statusCode ?? 0, body: resData });
+          resolve6({ statusCode: res.statusCode ?? 0, body: resData });
         });
       }
     );
@@ -12564,11 +13255,11 @@ var OutputService = class _OutputService {
 };
 
 // src/services/history.service.ts
-var fs20 = __toESM(require("fs"));
-var path24 = __toESM(require("path"));
+var fs21 = __toESM(require("fs"));
+var path25 = __toESM(require("path"));
 var os21 = __toESM(require("os"));
-var https4 = __toESM(require("https"));
-var http4 = __toESM(require("http"));
+var https5 = __toESM(require("https"));
+var http5 = __toESM(require("http"));
 var import_zod = require("zod");
 var historyRecordSchema = import_zod.z.object({
   type: import_zod.z.string().optional(),
@@ -12581,7 +13272,7 @@ var historyRecordSchema = import_zod.z.object({
   }).passthrough().optional()
 }).passthrough();
 var API_BASE4 = resolveApiBaseUrl();
-function extractText2(content) {
+function extractText3(content) {
   if (typeof content === "string") return content;
   if (Array.isArray(content)) {
     return content.filter((b) => b["type"] === "text").map((b) => b["text"]).join("\n");
@@ -12593,7 +13284,7 @@ function parseJsonl(filePath) {
   const messages = [];
   let raw;
   try {
-    raw = fs20.readFileSync(filePath, "utf8");
+    raw = fs21.readFileSync(filePath, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") {
       log.warn("history:parseJsonl", `read failed for ${filePath}`, err);
@@ -12620,20 +13311,20 @@ function parseJsonl(filePath) {
     const uuid = record.uuid ?? `${Date.now()}-${Math.random()}`;
     const msg = record.message;
     if (record.type === "user" && msg) {
-      const text = extractText2(msg.content).trim();
+      const text = extractText3(msg.content).trim();
       if (text) messages.push({ id: uuid, role: "user", text, timestamp });
     } else if (record.type === "assistant" && msg) {
-      const text = extractText2(msg.content).trim();
+      const text = extractText3(msg.content).trim();
       if (text) messages.push({ id: uuid, role: "agent", text, timestamp });
     }
   }
   return messages;
 }
 function post(endpoint, body) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const payload = JSON.stringify(body);
     const u2 = new URL(`${API_BASE4}${endpoint}`);
-    const transport = u2.protocol === "https:" ? https4 : http4;
+    const transport = u2.protocol === "https:" ? https5 : http5;
     const req = transport.request(
       {
         hostname: u2.hostname,
@@ -12651,17 +13342,17 @@ function post(endpoint, body) {
         res.resume();
         const ok = res.statusCode !== void 0 && res.statusCode >= 200 && res.statusCode < 300;
         if (!ok) log.warn("history:post", `${endpoint} \u2192 HTTP ${res.statusCode}`);
-        resolve5(ok);
+        resolve6(ok);
       }
     );
     req.on("error", (err) => {
       log.warn("history:post", `${endpoint} network error`, err);
-      resolve5(false);
+      resolve6(false);
     });
     req.on("timeout", () => {
       log.warn("history:post", `${endpoint} timeout after 15s`);
       req.destroy();
-      resolve5(false);
+      resolve6(false);
     });
     req.write(payload);
     req.end();
@@ -12728,7 +13419,7 @@ var HistoryService = class _HistoryService {
     return this._quotaPercent === null || Date.now() - this._quotaFetchedAt > ttlMs;
   }
   get projectDir() {
-    return this.runtime.resolveHistoryDir(this.cwd) ?? path24.join(os21.homedir(), ".claude", "projects", encodeCwd(this.cwd));
+    return this.runtime.resolveHistoryDir(this.cwd) ?? path25.join(os21.homedir(), ".claude", "projects", encodeCwd(this.cwd));
   }
   /** Set the current Claude conversation ID (extracted from /cost command or session start) */
   setCurrentConversationId(id) {
@@ -12740,7 +13431,7 @@ var HistoryService = class _HistoryService {
   /** Return the current message count in the active conversation. */
   getCurrentMessageCount() {
     if (!this.currentConversationId) return 0;
-    const filePath = path24.join(this.projectDir, `${this.currentConversationId}.jsonl`);
+    const filePath = path25.join(this.projectDir, `${this.currentConversationId}.jsonl`);
     return parseJsonl(filePath).length;
   }
   /**
@@ -12751,7 +13442,7 @@ var HistoryService = class _HistoryService {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
       if (!this.currentConversationId) return null;
-      const filePath = path24.join(this.projectDir, `${this.currentConversationId}.jsonl`);
+      const filePath = path25.join(this.projectDir, `${this.currentConversationId}.jsonl`);
       const messages = parseJsonl(filePath);
       if (messages.length > previousCount) {
         for (let i = messages.length - 1; i >= previousCount; i--) {
@@ -12777,16 +13468,16 @@ var HistoryService = class _HistoryService {
     const dir = this.projectDir;
     const cutoff = this.bootTimeMs - _HistoryService.BIRTHTIME_GRACE_MS;
     try {
-      const files = fs20.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => {
+      const files = fs21.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => {
         try {
-          const stat3 = fs20.statSync(path24.join(dir, e.name));
+          const stat3 = fs21.statSync(path25.join(dir, e.name));
           return { name: e.name, mtime: stat3.mtimeMs, birthtime: stat3.birthtimeMs };
         } catch {
           return { name: e.name, mtime: 0, birthtime: 0 };
         }
       }).filter((f) => f.birthtime >= cutoff).sort((a, b) => b.mtime - a.mtime);
       if (files.length > 0) {
-        this.currentConversationId = path24.basename(files[0].name, ".jsonl");
+        this.currentConversationId = path25.basename(files[0].name, ".jsonl");
       }
     } catch {
     }
@@ -12820,13 +13511,13 @@ var HistoryService = class _HistoryService {
     const cutoff = this.bootTimeMs - _HistoryService.BIRTHTIME_GRACE_MS;
     let entries;
     try {
-      entries = fs20.readdirSync(dir, { withFileTypes: true });
+      entries = fs21.readdirSync(dir, { withFileTypes: true });
     } catch {
       return null;
     }
     const files = entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => {
       try {
-        const stat3 = fs20.statSync(path24.join(dir, e.name));
+        const stat3 = fs21.statSync(path25.join(dir, e.name));
         return { name: e.name, mtime: stat3.mtimeMs, birthtime: stat3.birthtimeMs };
       } catch {
         return { name: e.name, mtime: 0, birthtime: 0 };
@@ -12835,12 +13526,12 @@ var HistoryService = class _HistoryService {
     if (files.length === 0) return null;
     const targetFile = this.currentConversationId ? `${this.currentConversationId}.jsonl` : files[0].name;
     if (!files.some((f) => f.name === targetFile)) return null;
-    return this.extractUsageFromFile(path24.join(dir, targetFile));
+    return this.extractUsageFromFile(path25.join(dir, targetFile));
   }
   extractUsageFromFile(filePath) {
     let raw;
     try {
-      raw = fs20.readFileSync(filePath, "utf8");
+      raw = fs21.readFileSync(filePath, "utf8");
     } catch {
       return null;
     }
@@ -12885,9 +13576,9 @@ var HistoryService = class _HistoryService {
     let totalCost = 0;
     let files;
     try {
-      files = fs20.readdirSync(projectDir).filter((f) => f.endsWith(".jsonl")).filter((f) => {
+      files = fs21.readdirSync(projectDir).filter((f) => f.endsWith(".jsonl")).filter((f) => {
         try {
-          return fs20.statSync(path24.join(projectDir, f)).mtimeMs >= monthStartMs;
+          return fs21.statSync(path25.join(projectDir, f)).mtimeMs >= monthStartMs;
         } catch {
           return false;
         }
@@ -12898,7 +13589,7 @@ var HistoryService = class _HistoryService {
     for (const file of files) {
       let raw;
       try {
-        raw = fs20.readFileSync(path24.join(projectDir, file), "utf8");
+        raw = fs21.readFileSync(path25.join(projectDir, file), "utf8");
       } catch {
         continue;
       }
@@ -12962,7 +13653,7 @@ var HistoryService = class _HistoryService {
    * showing an empty conversation.
    */
   async loadConversation(sessionId) {
-    const filePath = path24.join(this.projectDir, `${sessionId}.jsonl`);
+    const filePath = path25.join(this.projectDir, `${sessionId}.jsonl`);
     const messages = parseJsonl(filePath);
     if (messages.length === 0) return;
     const totalBatches = Math.ceil(messages.length / CONVERSATION_BATCH_SIZE);
@@ -13016,7 +13707,7 @@ var HistoryService = class _HistoryService {
       if (!this.currentConversationId) return 0;
     }
     const sessionId = this.currentConversationId;
-    const filePath = path24.join(this.projectDir, `${sessionId}.jsonl`);
+    const filePath = path25.join(this.projectDir, `${sessionId}.jsonl`);
     const messages = parseJsonl(filePath);
     if (messages.length === 0) return 0;
     const marker = this.lastUploadedUuid.get(sessionId);
@@ -13047,9 +13738,9 @@ var HistoryService = class _HistoryService {
 
 // src/services/file-watcher.service.ts
 var import_child_process8 = require("child_process");
-var fs21 = __toESM(require("fs"));
+var fs22 = __toESM(require("fs"));
 var os22 = __toESM(require("os"));
-var path25 = __toESM(require("path"));
+var path26 = __toESM(require("path"));
 
 // src/services/file-watcher/diff-parser.ts
 var HUNK_HEADER_RE = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/;
@@ -13138,16 +13829,16 @@ function isIgnoredFilePath(filePath) {
 }
 
 // src/services/file-watcher/transport.ts
-var http5 = __toESM(require("http"));
-var https5 = __toESM(require("https"));
-var _transport3 = {
-  post: _post2
+var http6 = __toESM(require("http"));
+var https6 = __toESM(require("https"));
+var _transport4 = {
+  post: _post3
 };
-function _post2(url, headers, payload) {
-  return new Promise((resolve5, reject) => {
+function _post3(url, headers, payload) {
+  return new Promise((resolve6, reject) => {
     let settled = false;
     const u2 = new URL(url);
-    const lib = u2.protocol === "https:" ? https5 : http5;
+    const lib = u2.protocol === "https:" ? https6 : http6;
     const req = lib.request(
       {
         hostname: u2.hostname,
@@ -13169,7 +13860,7 @@ function _post2(url, headers, payload) {
         res.on("end", () => {
           if (settled) return;
           settled = true;
-          resolve5({ statusCode: res.statusCode ?? 0, body });
+          resolve6({ statusCode: res.statusCode ?? 0, body });
         });
       }
     );
@@ -13240,18 +13931,18 @@ var _findGitRootSeam = {
   resolve: _defaultFindGitRoot
 };
 function _defaultFindGitRoot(startDir) {
-  let dir = path25.resolve(startDir);
+  let dir = path26.resolve(startDir);
   const seen = /* @__PURE__ */ new Set();
   for (let i = 0; i < 256; i++) {
     if (seen.has(dir)) return null;
     seen.add(dir);
     try {
-      const gitPath = path25.join(dir, ".git");
-      const stat3 = fs21.statSync(gitPath, { throwIfNoEntry: false });
+      const gitPath = path26.join(dir, ".git");
+      const stat3 = fs22.statSync(gitPath, { throwIfNoEntry: false });
       if (stat3 && (stat3.isDirectory() || stat3.isFile())) return dir;
     } catch {
     }
-    const parent = path25.dirname(dir);
+    const parent = path26.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -13485,7 +14176,7 @@ var FileWatcherService = class {
   }
   async emitForFile(absPath, changeType) {
     if (this.stopped) return;
-    const fileDir = path25.dirname(absPath);
+    const fileDir = path26.dirname(absPath);
     let gitRoot = this.gitRootByDir.get(fileDir);
     if (gitRoot === void 0) {
       gitRoot = findGitRoot(fileDir);
@@ -13499,10 +14190,10 @@ var FileWatcherService = class {
       return;
     }
     this.opts.onRepoDirty?.(gitRoot);
-    const relPathInRepo = path25.relative(gitRoot, absPath);
+    const relPathInRepo = path26.relative(gitRoot, absPath);
     if (!relPathInRepo || relPathInRepo.startsWith("..")) return;
-    const repoPath = path25.relative(this.opts.workingDir, gitRoot);
-    const repoName = path25.basename(gitRoot);
+    const repoPath = path26.relative(this.opts.workingDir, gitRoot);
+    const repoName = path26.basename(gitRoot);
     let diffText = "";
     let fileStatus = "modified";
     if (changeType === "unlink") {
@@ -13646,7 +14337,7 @@ var FileWatcherService = class {
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt += 1) {
       if (this.stopped) return;
       try {
-        const { statusCode, body: resBody } = await _transport3.post(url, headers, payload);
+        const { statusCode, body: resBody } = await _transport4.post(url, headers, payload);
         if (statusCode >= 200 && statusCode < 300) {
           log.trace(
             "fileWatcher",
@@ -13765,12 +14456,12 @@ var _gitSeam = {
   run: _runGitImpl
 };
 async function _runGitImpl(cwd, args2, opts = {}) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     let proc;
     try {
       proc = (0, import_child_process8.spawn)("git", args2, { cwd, env: process.env });
     } catch {
-      resolve5(null);
+      resolve6(null);
       return;
     }
     let stdout = "";
@@ -13781,13 +14472,13 @@ async function _runGitImpl(cwd, args2, opts = {}) {
     proc.stderr?.on("data", (c2) => {
       stderr += c2.toString();
     });
-    proc.on("error", () => resolve5(null));
+    proc.on("error", () => resolve6(null));
     proc.on("close", (code) => {
       if (code === 0 || opts.allowNonZeroExit) {
-        resolve5(stdout);
+        resolve6(stdout);
       } else {
         log.trace("fileWatcher", `git ${args2.join(" ")} exited ${code} stderr=${stderr.slice(0, 200)}`);
-        resolve5(null);
+        resolve6(null);
       }
     });
   });
@@ -13801,7 +14492,7 @@ var import_crypto2 = require("crypto");
 
 // src/services/turn-files/git-changeset.ts
 var import_child_process9 = require("child_process");
-var path26 = __toESM(require("path"));
+var path27 = __toESM(require("path"));
 async function collectRepoChangeset(opts) {
   const status2 = await runGit2(opts.repoRoot, ["status", "--porcelain=v1", "-z"]);
   if (status2 === null) return null;
@@ -13881,12 +14572,12 @@ function runGit2(cwd, args2) {
   return _runGitImpl2.run(cwd, args2);
 }
 function defaultRunGit(cwd, args2) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     let proc;
     try {
       proc = (0, import_child_process9.spawn)("git", args2, { cwd, env: process.env });
     } catch {
-      resolve5(null);
+      resolve6(null);
       return;
     }
     let stdout = "";
@@ -13897,22 +14588,22 @@ function defaultRunGit(cwd, args2) {
     proc.stderr?.on("data", (c2) => {
       stderr += c2.toString();
     });
-    proc.on("error", () => resolve5(null));
+    proc.on("error", () => resolve6(null));
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve5(stdout);
+        resolve6(stdout);
       } else {
         log.trace(
           "turnFiles",
           `git ${args2.join(" ")} exited ${code} stderr=${stderr.slice(0, 200)}`
         );
-        resolve5(null);
+        resolve6(null);
       }
     });
   });
 }
 async function discoverRepos(workingDir, maxDepth = 4) {
-  const fs34 = await import("fs/promises");
+  const fs35 = await import("fs/promises");
   const out2 = [];
   await walk(workingDir, 0);
   return out2;
@@ -13920,7 +14611,7 @@ async function discoverRepos(workingDir, maxDepth = 4) {
     if (depth > maxDepth) return;
     let entries = [];
     try {
-      const dirents = await fs34.readdir(dir, { withFileTypes: true });
+      const dirents = await fs35.readdir(dir, { withFileTypes: true });
       entries = dirents.filter((d3) => !d3.name.startsWith(".") || d3.name === ".git").map((d3) => ({ name: d3.name, isDirectory: d3.isDirectory() }));
     } catch {
       return;
@@ -13931,8 +14622,8 @@ async function discoverRepos(workingDir, maxDepth = 4) {
     if (hasGit) {
       out2.push({
         repoRoot: dir,
-        repoPath: path26.relative(workingDir, dir),
-        repoName: path26.basename(dir)
+        repoPath: path27.relative(workingDir, dir),
+        repoName: path27.basename(dir)
       });
       return;
     }
@@ -13940,14 +14631,14 @@ async function discoverRepos(workingDir, maxDepth = 4) {
       if (!entry.isDirectory) continue;
       if (entry.name === "node_modules") continue;
       if (entry.name === "dist" || entry.name === "build") continue;
-      await walk(path26.join(dir, entry.name), depth + 1);
+      await walk(path27.join(dir, entry.name), depth + 1);
     }
   }
 }
 
 // src/services/turn-files/files-outbox.ts
-var fs22 = __toESM(require("fs/promises"));
-var path27 = __toESM(require("path"));
+var fs23 = __toESM(require("fs/promises"));
+var path28 = __toESM(require("path"));
 var import_os6 = require("os");
 var HOME_OUTBOX_DIR = ".codeam/outbox";
 var MAX_AGE_MS = 24 * 60 * 60 * 1e3;
@@ -13980,16 +14671,16 @@ var FilesOutbox = class {
   backoffIndex = 0;
   stopped = false;
   constructor(opts) {
-    const base = opts.baseDir ?? path27.join(homeDir(), HOME_OUTBOX_DIR);
-    this.filePath = path27.join(base, `${opts.sessionId}.jsonl`);
+    const base = opts.baseDir ?? path28.join(homeDir(), HOME_OUTBOX_DIR);
+    this.filePath = path28.join(base, `${opts.sessionId}.jsonl`);
     this.post = opts.post;
     this.autoSchedule = opts.autoSchedule !== false;
   }
   /** Persist the entry to disk and trigger a flush. Returns once the
    *  line is durable on disk (not once the POST succeeds). */
   async enqueue(entry) {
-    await fs22.mkdir(path27.dirname(this.filePath), { recursive: true });
-    await fs22.appendFile(this.filePath, JSON.stringify(entry) + "\n", "utf8");
+    await fs23.mkdir(path28.dirname(this.filePath), { recursive: true });
+    await fs23.appendFile(this.filePath, JSON.stringify(entry) + "\n", "utf8");
     this.backoffIndex = 0;
     if (this.autoSchedule) this.scheduleFlush(0);
   }
@@ -14078,7 +14769,7 @@ var FilesOutbox = class {
   async readAll() {
     let raw = "";
     try {
-      raw = await fs22.readFile(this.filePath, "utf8");
+      raw = await fs23.readFile(this.filePath, "utf8");
     } catch {
       return [];
     }
@@ -14102,12 +14793,12 @@ var FilesOutbox = class {
   async rewrite(entries) {
     const tmpPath = `${this.filePath}.${process.pid}.tmp`;
     if (entries.length === 0) {
-      await fs22.unlink(this.filePath).catch(() => void 0);
+      await fs23.unlink(this.filePath).catch(() => void 0);
       return;
     }
     const payload = entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
-    await fs22.writeFile(tmpPath, payload, "utf8");
-    await fs22.rename(tmpPath, this.filePath);
+    await fs23.writeFile(tmpPath, payload, "utf8");
+    await fs23.rename(tmpPath, this.filePath);
   }
 };
 function applyJitter(ms) {
@@ -14222,13 +14913,13 @@ var TurnFileAggregator = class {
         return;
       }
       const chunks = chunkArray(novel, MAX_BATCH_SIZE);
-      for (const chunk of chunks) {
+      for (const chunk2 of chunks) {
         const entry = {
           turnId: (0, import_crypto2.randomUUID)(),
           sessionId: this.opts.sessionId,
           pluginId: this.opts.pluginId,
           enqueuedAt: Date.now(),
-          files: chunk
+          files: chunk2
         };
         await this.outbox.enqueue(entry);
       }
@@ -14267,7 +14958,7 @@ var TurnFileAggregator = class {
       files: entry.files
     });
     try {
-      const res = await _transport3.post(url, headers, body);
+      const res = await _transport4.post(url, headers, body);
       return { ok: res.statusCode >= 200 && res.statusCode < 300, statusCode: res.statusCode };
     } catch (err) {
       log.trace(
@@ -14326,101 +15017,9 @@ var RepoDirtyTracker = class {
 
 // src/services/streaming-emitter.service.ts
 var import_crypto3 = 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((resolve5, 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;
-          resolve5({ 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((resolve5, 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;
-          resolve5({ 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_BASE7 = resolveApiBaseUrl();
 var TICK_MS = 50;
-var ANSWER_POLL_MS = 1500;
+var ANSWER_POLL_MS2 = 1500;
 var SELECTOR_STABLE_MS = 800;
 var MAX_RETRIES2 = 1;
 var RETRY_BACKOFF_MS2 = 200;
@@ -14460,7 +15059,7 @@ var StreamingEmitterService = class {
     this.tickTimer = setInterval(() => this.tick(), TICK_MS);
     this.answerPollTimer = setInterval(() => {
       void this.pollPendingAnswer();
-    }, ANSWER_POLL_MS);
+    }, ANSWER_POLL_MS2);
     log.trace("streamingEmitter", `started session=${this.opts.sessionId.slice(0, 8)}`);
   }
   /**
@@ -14481,11 +15080,11 @@ var StreamingEmitterService = class {
     }
     if (this.activeChunk) {
       const finalContent = this.activeChunk.currentContent;
-      const chunk = this.activeChunk;
+      const chunk2 = this.activeChunk;
       this.activeChunk = null;
       await this.postChunk({
-        chunkId: chunk.chunkId,
-        kind: chunk.kind,
+        chunkId: chunk2.chunkId,
+        kind: chunk2.kind,
         content: finalContent,
         isFinal: true
       });
@@ -14557,17 +15156,17 @@ var StreamingEmitterService = class {
     this.maybeFlushActive(false);
   }
   maybeFlushActive(force) {
-    const chunk = this.activeChunk;
-    if (!chunk) return;
+    const chunk2 = this.activeChunk;
+    if (!chunk2) 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;
+    if (!force && now - chunk2.lastEmitAt < TICK_MS) return;
+    if (chunk2.currentContent === chunk2.emittedContent) return;
+    chunk2.emittedContent = chunk2.currentContent;
+    chunk2.lastEmitAt = now;
     void this.postChunk({
-      chunkId: chunk.chunkId,
-      kind: chunk.kind,
-      content: chunk.currentContent,
+      chunkId: chunk2.chunkId,
+      kind: chunk2.kind,
+      content: chunk2.currentContent,
       isFinal: false
     });
   }
@@ -14634,7 +15233,7 @@ var StreamingEmitterService = class {
     if (!this.pendingAnswer) return;
     const questionId = this.pendingAnswer.questionId;
     try {
-      const { statusCode, body } = await _transport4.get(
+      const { statusCode, body } = await _transport2.get(
         `${this.apiBase}/api/sessions/${encodeURIComponent(this.opts.sessionId)}/pending-answer?questionId=${encodeURIComponent(questionId)}&pluginId=${encodeURIComponent(this.opts.pluginId)}`,
         this.headers
       );
@@ -14645,7 +15244,7 @@ var StreamingEmitterService = class {
         log.warn("streamingEmitter", `pending-answer status=${statusCode} body=${body.slice(0, 200)}`);
         return;
       }
-      const parsed = parsePendingAnswerResponse(body);
+      const parsed = parsePendingAnswerResponse2(body);
       if (!parsed || parsed.questionId !== questionId) return;
       const pending = this.pendingAnswer;
       this.pendingAnswer = null;
@@ -14695,7 +15294,7 @@ var StreamingEmitterService = class {
     });
     for (let attempt = 0; attempt <= MAX_RETRIES2; attempt += 1) {
       try {
-        const { statusCode, body: resBody } = await _transport4.post(url, this.headers, payload);
+        const { statusCode, body: resBody } = await _transport2.post(url, this.headers, payload);
         if (statusCode >= 200 && statusCode < 300) {
           log.trace("streamingEmitter", `post ok url=${url} status=${statusCode}`);
           return;
@@ -14742,7 +15341,7 @@ function classifyLine(line, parseChrome, runtime) {
   if (filtered.length === 0) return null;
   return "text";
 }
-function parsePendingAnswerResponse(body) {
+function parsePendingAnswerResponse2(body) {
   if (!body) return null;
   let parsed;
   try {
@@ -14784,7 +15383,7 @@ function buildKeepAlive(ctx) {
   let timer = null;
   async function setIdleTimeout(minutes) {
     if (!ctx.inCodespace || !ctx.codespaceName) return;
-    await new Promise((resolve5) => {
+    await new Promise((resolve6) => {
       const proc = (0, import_child_process10.spawn)(
         "gh",
         [
@@ -14798,8 +15397,8 @@ function buildKeepAlive(ctx) {
         { stdio: "ignore", detached: true }
       );
       proc.unref();
-      proc.on("exit", () => resolve5());
-      proc.on("error", () => resolve5());
+      proc.on("exit", () => resolve6());
+      proc.on("error", () => resolve6());
     });
   }
   return {
@@ -14822,9 +15421,9 @@ function buildKeepAlive(ctx) {
 }
 
 // src/commands/start/handlers.ts
-var fs30 = __toESM(require("fs"));
+var fs31 = __toESM(require("fs"));
 var os24 = __toESM(require("os"));
-var path36 = __toESM(require("path"));
+var path37 = __toESM(require("path"));
 var import_crypto5 = require("crypto");
 var import_child_process15 = require("child_process");
 
@@ -14948,8 +15547,8 @@ function parsePayload2(schema, raw) {
 }
 
 // src/services/file-ops.service.ts
-var fs23 = __toESM(require("fs/promises"));
-var path28 = __toESM(require("path"));
+var fs24 = __toESM(require("fs/promises"));
+var path29 = __toESM(require("path"));
 var MAX_FILE_BYTES = 5 * 1024 * 1024;
 var MAX_WALK_DEPTH = 6;
 var MAX_VISITED_DIRS = 5e3;
@@ -14984,12 +15583,12 @@ var SUBDIR_IGNORE = /* @__PURE__ */ new Set([
   "__pycache__"
 ]);
 function isUnder(parent, candidate) {
-  const rel = path28.relative(parent, candidate);
-  return rel === "" || !rel.startsWith("..") && !path28.isAbsolute(rel);
+  const rel = path29.relative(parent, candidate);
+  return rel === "" || !rel.startsWith("..") && !path29.isAbsolute(rel);
 }
 async function isExistingFile(absPath) {
   try {
-    const stat3 = await fs23.stat(absPath);
+    const stat3 = await fs24.stat(absPath);
     return stat3.isFile();
   } catch {
     return false;
@@ -15002,13 +15601,13 @@ async function walkForSuffix(dir, needleVariants, depth, ctx) {
   ctx.visited++;
   let entries = [];
   try {
-    entries = await fs23.readdir(dir, { withFileTypes: true });
+    entries = await fs24.readdir(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const e of entries) {
     if (!e.isFile()) continue;
-    const full = path28.join(dir, e.name);
+    const full = path29.join(dir, e.name);
     if (needleVariants.some((needle) => full.endsWith(needle))) {
       ctx.matches.push(full);
       if (ctx.matches.length >= ctx.cap) return;
@@ -15018,21 +15617,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(path28.join(dir, e.name), needleVariants, depth + 1, ctx);
+    await walkForSuffix(path29.join(dir, e.name), needleVariants, depth + 1, ctx);
     if (ctx.matches.length >= ctx.cap) return;
   }
 }
 async function findFile(rawPath) {
   const cwd = process.cwd();
-  if (path28.isAbsolute(rawPath)) {
-    const abs = path28.normalize(rawPath);
+  if (path29.isAbsolute(rawPath)) {
+    const abs = path29.normalize(rawPath);
     if (isUnder(cwd, abs) && await isExistingFile(abs)) return abs;
   }
-  const direct = path28.resolve(cwd, rawPath);
+  const direct = path29.resolve(cwd, rawPath);
   if (isUnder(cwd, direct) && await isExistingFile(direct)) return direct;
-  const normalized = path28.normalize(rawPath).replace(/^[./\\]+/, "");
+  const normalized = path29.normalize(rawPath).replace(/^[./\\]+/, "");
   const needles = [
-    `${path28.sep}${normalized}`,
+    `${path29.sep}${normalized}`,
     `/${normalized}`
   ].filter((v, i, a) => a.indexOf(v) === i);
   const ctx = { visited: 0, matches: [], cap: 16 };
@@ -15046,7 +15645,7 @@ async function findWriteTarget(rawPath) {
   const found = await findFile(rawPath);
   if (found) return found;
   const cwd = process.cwd();
-  const fallback = path28.isAbsolute(rawPath) ? path28.normalize(rawPath) : path28.resolve(cwd, rawPath);
+  const fallback = path29.isAbsolute(rawPath) ? path29.normalize(rawPath) : path29.resolve(cwd, rawPath);
   if (!isUnder(cwd, fallback)) return null;
   return fallback;
 }
@@ -15063,11 +15662,11 @@ async function readProjectFile(rawPath) {
     if (!abs) {
       return { error: `File not found in the project tree: ${rawPath}` };
     }
-    const stat3 = await fs23.stat(abs);
+    const stat3 = await fs24.stat(abs);
     if (stat3.size > MAX_FILE_BYTES) {
       return { error: `File too large (${(stat3.size / 1024 / 1024).toFixed(1)} MB > ${MAX_FILE_BYTES / 1024 / 1024} MB).` };
     }
-    const buf = await fs23.readFile(abs);
+    const buf = await fs24.readFile(abs);
     if (looksBinary(buf)) {
       return { error: "Binary file \u2014 refusing to open in a code editor." };
     }
@@ -15086,8 +15685,8 @@ async function writeProjectFile(rawPath, content) {
     if (Buffer.byteLength(content, "utf-8") > MAX_FILE_BYTES) {
       return { error: "Content too large." };
     }
-    await fs23.mkdir(path28.dirname(abs), { recursive: true });
-    await fs23.writeFile(abs, content, "utf-8");
+    await fs24.mkdir(path29.dirname(abs), { recursive: true });
+    await fs24.writeFile(abs, content, "utf-8");
     return { ok: true };
   } catch (e) {
     const msg = e instanceof Error ? e.message : "Write failed";
@@ -15098,8 +15697,8 @@ async function writeProjectFile(rawPath, content) {
 // src/services/project-ops.service.ts
 var import_child_process11 = require("child_process");
 var import_util2 = require("util");
-var fs24 = __toESM(require("fs/promises"));
-var path29 = __toESM(require("path"));
+var fs25 = __toESM(require("fs/promises"));
+var path30 = __toESM(require("path"));
 var execFileP3 = (0, import_util2.promisify)(import_child_process11.execFile);
 var PROJECT_IGNORE = /* @__PURE__ */ new Set([
   "node_modules",
@@ -15147,7 +15746,7 @@ async function listProjectFiles(opts = {}) {
     }
     let entries = [];
     try {
-      entries = await fs24.readdir(dir, { withFileTypes: true });
+      entries = await fs25.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -15157,18 +15756,18 @@ async function listProjectFiles(opts = {}) {
         return;
       }
       if (PROJECT_IGNORE.has(e.name)) continue;
-      const full = path29.join(dir, e.name);
+      const full = path30.join(dir, e.name);
       if (e.isDirectory()) {
         if (depth >= 12) continue;
         await walk(full, depth + 1);
       } else if (e.isFile()) {
-        const rel = path29.relative(root, full);
+        const rel = path30.relative(root, full);
         if (q2 && !rel.toLowerCase().includes(q2) && !e.name.toLowerCase().includes(q2)) {
           continue;
         }
         let size = 0;
         try {
-          const st3 = await fs24.stat(full);
+          const st3 = await fs25.stat(full);
           size = st3.size;
         } catch {
         }
@@ -15270,8 +15869,8 @@ async function gitStatus(cwd) {
   let hasMergeInProgress = false;
   try {
     const gitDir = (await git(["rev-parse", "--git-dir"], root)).stdout.trim();
-    const mergeHead = path29.isAbsolute(gitDir) ? path29.join(gitDir, "MERGE_HEAD") : path29.join(root, gitDir, "MERGE_HEAD");
-    await fs24.access(mergeHead);
+    const mergeHead = path30.isAbsolute(gitDir) ? path30.join(gitDir, "MERGE_HEAD") : path30.join(root, gitDir, "MERGE_HEAD");
+    await fs25.access(mergeHead);
     hasMergeInProgress = true;
   } catch {
   }
@@ -15417,7 +16016,7 @@ async function jsSearchFiles(opts, cwd, cap) {
     }
     let content = "";
     try {
-      content = await fs24.readFile(path29.join(cwd, f.path), "utf8");
+      content = await fs25.readFile(path30.join(cwd, f.path), "utf8");
     } catch {
       continue;
     }
@@ -15698,14 +16297,14 @@ function closeAllTerminals() {
 
 // src/services/apply-file-review.service.ts
 var import_child_process13 = require("child_process");
-var fs25 = __toESM(require("fs"));
-var path31 = __toESM(require("path"));
+var fs26 = __toESM(require("fs"));
+var path32 = __toESM(require("path"));
 async function applyFileReview(workingDir, filePath, action) {
-  if (filePath.includes("..") || path31.isAbsolute(filePath)) {
+  if (filePath.includes("..") || path32.isAbsolute(filePath)) {
     return { ok: false, action, filePath, error: "invalid file path" };
   }
-  const absFile = path31.resolve(workingDir, filePath);
-  const repoRoot = findGitRoot2(path31.dirname(absFile));
+  const absFile = path32.resolve(workingDir, filePath);
+  const repoRoot = findGitRoot2(path32.dirname(absFile));
   if (!repoRoot) {
     return {
       ok: false,
@@ -15714,7 +16313,7 @@ async function applyFileReview(workingDir, filePath, action) {
       error: `no enclosing git repo for ${filePath}`
     };
   }
-  const relInRepo = path31.relative(repoRoot, absFile);
+  const relInRepo = path32.relative(repoRoot, absFile);
   if (!relInRepo || relInRepo.startsWith("..")) {
     return { ok: false, action, filePath, error: "path escapes repo root" };
   }
@@ -15736,12 +16335,12 @@ async function applyFileReview(workingDir, filePath, action) {
   return { ok: true, action, filePath, repoRoot };
 }
 function runGit3(cwd, args2) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     let proc;
     try {
       proc = (0, import_child_process13.spawn)("git", args2, { cwd, env: process.env });
     } catch (err) {
-      resolve5({ ok: false, code: -1, stdout: "", stderr: err.message });
+      resolve6({ ok: false, code: -1, stdout: "", stderr: err.message });
       return;
     }
     let stdout = "";
@@ -15754,26 +16353,26 @@ function runGit3(cwd, args2) {
     });
     proc.on(
       "error",
-      (err) => resolve5({ ok: false, code: -1, stdout, stderr: stderr + err.message })
+      (err) => resolve6({ ok: false, code: -1, stdout, stderr: stderr + err.message })
     );
     proc.on(
       "close",
-      (code) => resolve5({ ok: code === 0, code: code ?? -1, stdout, stderr })
+      (code) => resolve6({ ok: code === 0, code: code ?? -1, stdout, stderr })
     );
   });
 }
 function findGitRoot2(startDir) {
-  let dir = path31.resolve(startDir);
+  let dir = path32.resolve(startDir);
   const seen = /* @__PURE__ */ new Set();
   for (let i = 0; i < 256; i++) {
     if (seen.has(dir)) return null;
     seen.add(dir);
     try {
-      const stat3 = fs25.statSync(path31.join(dir, ".git"), { throwIfNoEntry: false });
+      const stat3 = fs26.statSync(path32.join(dir, ".git"), { throwIfNoEntry: false });
       if (stat3 && (stat3.isDirectory() || stat3.isFile())) return dir;
     } catch {
     }
-    const parent = path31.dirname(dir);
+    const parent = path32.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -15781,9 +16380,9 @@ function findGitRoot2(startDir) {
 }
 
 // src/commands/link.ts
-var import_node_crypto5 = require("crypto");
-var fs26 = __toESM(require("fs"));
-var path32 = __toESM(require("path"));
+var import_node_crypto7 = require("crypto");
+var fs27 = __toESM(require("fs"));
+var path33 = __toESM(require("path"));
 var import_chokidar = __toESM(require("chokidar"));
 var import_picocolors2 = __toESM(require("picocolors"));
 
@@ -15843,7 +16442,7 @@ function parseLinkArgs(args2) {
   if (apiKeyFileArg) {
     const filePath = apiKeyFileArg.slice("--api-key-file=".length);
     try {
-      apiKey = fs26.readFileSync(path32.resolve(filePath), "utf8").trim();
+      apiKey = fs27.readFileSync(path33.resolve(filePath), "utf8").trim();
     } catch (err) {
       throw new Error(`Could not read --api-key-file ${filePath}: ${err.message}`);
     }
@@ -15870,7 +16469,7 @@ async function link(args2 = []) {
     await linkDryRunPreflight(ctx);
     return;
   }
-  const pluginId = (0, import_node_crypto5.randomUUID)();
+  const pluginId = (0, import_node_crypto7.randomUUID)();
   const spin = dist_exports.spinner();
   spin.start("Requesting pairing code...");
   const pairing = await requestCode(pluginId);
@@ -15888,7 +16487,7 @@ async function link(args2 = []) {
   waitSpin.start(waitMsg());
   const countdown = setInterval(() => waitSpin.message(waitMsg()), 1e3);
   countdown.unref?.();
-  const paired = await new Promise((resolve5, reject) => {
+  const paired = await new Promise((resolve6, reject) => {
     let stopPoll = null;
     const sigint = () => {
       clearInterval(countdown);
@@ -15901,7 +16500,7 @@ async function link(args2 = []) {
         process.removeListener("SIGINT", sigint);
         clearInterval(countdown);
         waitSpin.stop("Paired");
-        resolve5(info);
+        resolve6(info);
       },
       () => {
         clearInterval(countdown);
@@ -15937,7 +16536,7 @@ async function link(args2 = []) {
     return;
   }
   if (parsed.tokenFile) {
-    const credential = fs26.readFileSync(path32.resolve(parsed.tokenFile), "utf8").trim();
+    const credential = fs27.readFileSync(path33.resolve(parsed.tokenFile), "utf8").trim();
     if (!credential) {
       showError(`--token-file ${parsed.tokenFile} is empty.`);
       process.exit(1);
@@ -16036,14 +16635,14 @@ async function captureFreshCredentials(ctx) {
     }
   };
   try {
-    const token = await new Promise((resolve5, reject) => {
+    const token = await new Promise((resolve6, reject) => {
       let settled = false;
       const tryExtract = async () => {
         if (settled) return;
         const t2 = await ctx.locator.extract();
         if (t2 && !settled) {
           settled = true;
-          resolve5(t2);
+          resolve6(t2);
         }
       };
       watcher.on("add", () => void tryExtract());
@@ -16447,7 +17046,7 @@ var pendingAttachmentFiles = /* @__PURE__ */ new Set();
 function cleanupAttachmentTempFiles() {
   for (const p2 of pendingAttachmentFiles) {
     try {
-      fs30.unlinkSync(p2);
+      fs31.unlinkSync(p2);
     } catch {
     }
   }
@@ -16456,8 +17055,8 @@ function cleanupAttachmentTempFiles() {
 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 = path36.join(os24.tmpdir(), `codeam-${(0, import_crypto5.randomUUID)()}-${safeName}`);
-    fs30.writeFileSync(tmpPath, Buffer.from(base64, "base64"));
+    const tmpPath = path37.join(os24.tmpdir(), `codeam-${(0, import_crypto5.randomUUID)()}-${safeName}`);
+    fs31.writeFileSync(tmpPath, Buffer.from(base64, "base64"));
     pendingAttachmentFiles.add(tmpPath);
     return tmpPath;
   });
@@ -16477,7 +17076,7 @@ var startTask = (ctx, _cmd, parsed) => {
     setTimeout(() => {
       for (const p2 of paths) {
         try {
-          fs30.unlinkSync(p2);
+          fs31.unlinkSync(p2);
         } catch {
         }
         pendingAttachmentFiles.delete(p2);
@@ -16645,7 +17244,7 @@ var shutdownSession = async (ctx, cmd) => {
   ctx.relay.stop();
   process.exit(0);
 };
-var readFile4 = async (ctx, cmd, parsed) => {
+var readFile5 = async (ctx, cmd, parsed) => {
   if (!parsed.path) {
     await ctx.relay.sendResult(cmd.id, "failed", { error: "Missing path" });
     return;
@@ -16653,7 +17252,7 @@ var readFile4 = async (ctx, cmd, parsed) => {
   const result = await readProjectFile(parsed.path);
   await ctx.relay.sendResult(cmd.id, "completed", result);
 };
-var writeFile3 = async (ctx, cmd, parsed) => {
+var writeFile4 = async (ctx, cmd, parsed) => {
   if (!parsed.path || typeof parsed.content !== "string") {
     await ctx.relay.sendResult(cmd.id, "failed", { error: "Missing path or content" });
     return;
@@ -17104,8 +17703,8 @@ var previewStartH = (ctx, _cmd, parsed) => {
     let readyMatched = false;
     let expoUrl = null;
     const readyRe = new RegExp(detection.ready_pattern);
-    const onChunk = (chunk) => {
-      const s = chunk.toString();
+    const onChunk = (chunk2) => {
+      const s = chunk2.toString();
       if (!readyMatched && readyRe.test(s)) readyMatched = true;
       if (!expoUrl && detection.framework === "Expo") expoUrl = parseExpoUrl(s);
     };
@@ -17228,8 +17827,8 @@ var previewStartH = (ctx, _cmd, parsed) => {
         stdio: ["ignore", "pipe", "pipe"]
       });
       let parsedUrl = null;
-      const onTunnelChunk = (chunk) => {
-        const s = chunk.toString();
+      const onTunnelChunk = (chunk2) => {
+        const s = chunk2.toString();
         if (!parsedUrl) parsedUrl = parseCloudflaredUrl(s);
         const trimmed = s.replace(/\n+$/g, "");
         if (trimmed.length > 0) log.info("preview", `cloudflared: ${trimmed}`);
@@ -17321,22 +17920,22 @@ var previewStopH = (ctx) => {
   })();
 };
 function runOnce(cmd, args2, cwd, env) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const child = (0, import_child_process15.spawn)(cmd, args2, {
       cwd,
       env: { ...process.env, ...env ?? {} },
       stdio: ["ignore", "pipe", "pipe"]
     });
     const tag = `setup:${cmd}`;
-    const onChunk = (chunk) => {
-      const text = chunk.toString().replace(/\n+$/g, "");
+    const onChunk = (chunk2) => {
+      const text = chunk2.toString().replace(/\n+$/g, "");
       if (text.length === 0) return;
       log.info("preview", `${tag}: ${text}`);
     };
     child.stdout?.on("data", onChunk);
     child.stderr?.on("data", onChunk);
-    child.once("exit", (code) => resolve5(code));
-    child.once("error", () => resolve5(-1));
+    child.once("exit", (code) => resolve6(code));
+    child.once("error", () => resolve6(-1));
   });
 }
 var savePreviewConfigH = (_ctx, _cmd, parsed) => {
@@ -17364,8 +17963,8 @@ var handlers = {
   set_keep_alive: setKeepAlive,
   session_terminated: sessionTerminated,
   shutdown_session: shutdownSession,
-  read_file: readFile4,
-  write_file: writeFile3,
+  read_file: readFile5,
+  write_file: writeFile4,
   list_files: listFiles,
   search_files: searchFilesH,
   terminal_open: terminalOpenH,
@@ -17441,6 +18040,23 @@ async function start(requestedAgent) {
     requestedAgent: requestedAgent ?? null
   });
   const cwd = process.cwd();
+  if (process.env.CODEAM_ACP_ENABLED === "1" && session.pluginAuthToken) {
+    const adapter = getAcpAdapter(session.agent);
+    if (adapter) {
+      await runAcpSession({
+        agent: session.agent,
+        sessionId: session.id,
+        pluginId,
+        pluginAuthToken: session.pluginAuthToken,
+        adapter,
+        cwd
+      });
+      return;
+    }
+    showInfo(
+      `CODEAM_ACP_ENABLED is set but no ACP adapter is registered for "${session.agent}" \u2014 falling back to PTY runtime.`
+    );
+  }
   const runtime = createRuntimeStrategy(session.agent);
   const historySvc = new HistoryService(runtime, pluginId, cwd);
   const keepAliveCtx = {
@@ -17688,7 +18304,7 @@ async function pair(args2 = []) {
     waitSpin.message(waitMessage());
   }, 1e3);
   countdownInterval.unref?.();
-  await new Promise((resolve5) => {
+  await new Promise((resolve6) => {
     let stopPolling = null;
     function sigintHandler() {
       clearInterval(countdownInterval);
@@ -17736,7 +18352,7 @@ async function pair(args2 = []) {
             pluginAuthToken: info.pluginAuthToken
           });
         }
-        resolve5();
+        resolve6();
       },
       () => {
         clearInterval(countdownInterval);
@@ -17788,7 +18404,7 @@ async function autoLinkAfterPair(opts) {
 }
 
 // src/commands/pair-auto.ts
-var fs31 = __toESM(require("fs"));
+var fs32 = __toESM(require("fs"));
 var os25 = __toESM(require("os"));
 var import_crypto7 = require("crypto");
 
@@ -17957,12 +18573,12 @@ function readTokenFromArgs(args2) {
   }
   const fileFlag = args2.find((a) => a.startsWith("--token-file="));
   if (fileFlag) {
-    const path43 = fileFlag.slice("--token-file=".length);
+    const path44 = fileFlag.slice("--token-file=".length);
     try {
-      const content = fs31.readFileSync(path43, "utf8").trim();
-      if (content.length === 0) fail(`--token-file ${path43} is empty`);
+      const content = fs32.readFileSync(path44, "utf8").trim();
+      if (content.length === 0) fail(`--token-file ${path44} is empty`);
       try {
-        fs31.unlinkSync(path43);
+        fs32.unlinkSync(path44);
       } catch {
       }
       return content;
@@ -18228,7 +18844,7 @@ var import_picocolors10 = __toESM(require("picocolors"));
 var import_child_process16 = require("child_process");
 var import_util4 = require("util");
 var import_picocolors8 = __toESM(require("picocolors"));
-var path37 = __toESM(require("path"));
+var path38 = __toESM(require("path"));
 var execFileP5 = (0, import_util4.promisify)(import_child_process16.execFile);
 var MAX_BUFFER = 8 * 1024 * 1024;
 function resetStdinForChild() {
@@ -18272,12 +18888,12 @@ var GitHubCodespacesProvider = class {
     }
     if (!isAuthed) {
       resetStdinForChild();
-      await new Promise((resolve5, reject) => {
+      await new Promise((resolve6, reject) => {
         const proc = (0, import_child_process16.spawn)("gh", ["auth", "login", "-s", "codespace,repo,read:user"], {
           stdio: "inherit"
         });
         proc.on("exit", (code) => {
-          if (code === 0) resolve5();
+          if (code === 0) resolve6();
           else reject(new Error("gh auth login failed."));
         });
         proc.on("error", reject);
@@ -18306,13 +18922,13 @@ var GitHubCodespacesProvider = class {
       }
       wt(noteLines.join("\n"), "One more permission needed");
       resetStdinForChild();
-      const refreshCode = await new Promise((resolve5, reject) => {
+      const refreshCode = await new Promise((resolve6, reject) => {
         const proc = (0, import_child_process16.spawn)(
           "gh",
           ["auth", "refresh", "-h", "github.com", "-s", "codespace"],
           { stdio: "inherit" }
         );
-        proc.on("exit", (code) => resolve5(code ?? 1));
+        proc.on("exit", (code) => resolve6(code ?? 1));
         proc.on("error", reject);
       });
       if (refreshCode !== 0) {
@@ -18456,10 +19072,10 @@ var GitHubCodespacesProvider = class {
     if (q(proceed) || !proceed) return;
     O2.step(`Installing gh via ${installCmd.describe}\u2026`);
     resetStdinForChild();
-    const ok = await new Promise((resolve5) => {
+    const ok = await new Promise((resolve6) => {
       const proc = (0, import_child_process16.spawn)(installCmd.exe, installCmd.args, { stdio: "inherit" });
-      proc.on("exit", (code) => resolve5(code === 0));
-      proc.on("error", () => resolve5(false));
+      proc.on("exit", (code) => resolve6(code === 0));
+      proc.on("error", () => resolve6(false));
     });
     if (ok) O2.success("gh installed");
     else O2.error("gh install failed");
@@ -18483,14 +19099,14 @@ var GitHubCodespacesProvider = class {
       "Expanding GitHub scopes"
     );
     resetStdinForChild();
-    await new Promise((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       const proc = (0, import_child_process16.spawn)(
         "gh",
         ["auth", "refresh", "-h", "github.com", "-s", "repo,read:org"],
         { stdio: "inherit" }
       );
       proc.on("exit", (code) => {
-        if (code === 0) resolve5();
+        if (code === 0) resolve6();
         else reject(new Error(
           "gh auth refresh failed. Re-run `gh auth refresh -h github.com -s repo,read:org` manually."
         ));
@@ -18661,13 +19277,13 @@ var GitHubCodespacesProvider = class {
   }
   async streamCommand(workspaceId, command2) {
     resetStdinForChild();
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const proc = (0, import_child_process16.spawn)(
         "gh",
         ["codespace", "ssh", "-c", workspaceId, "--", "-tt", command2],
         { stdio: "inherit" }
       );
-      proc.on("exit", (code) => resolve5({ code: code ?? 0 }));
+      proc.on("exit", (code) => resolve6({ code: code ?? 0 }));
       proc.on("error", reject);
     });
   }
@@ -18688,7 +19304,7 @@ var GitHubCodespacesProvider = class {
       "--",
       `mkdir -p ${shellQuote(remoteDir)} && tar -xzf - -C ${shellQuote(remoteDir)}`
     ];
-    await new Promise((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       const tar = (0, import_child_process16.spawn)("tar", tarArgs, {
         stdio: ["ignore", "pipe", "pipe"],
         env: tarEnv
@@ -18708,7 +19324,7 @@ var GitHubCodespacesProvider = class {
       ssh.on("error", reject);
       ssh.on("exit", (code) => {
         if (code === 0) {
-          resolve5();
+          resolve6();
         } else {
           const reason = (sshErr || tarErr || `exit ${code}`).trim().slice(0, 500);
           reject(new Error(`Remote tar failed: ${reason}`));
@@ -18717,7 +19333,7 @@ var GitHubCodespacesProvider = class {
     });
   }
   async uploadFile(workspaceId, remotePath, contents, options = {}) {
-    const remoteDir = path37.posix.dirname(remotePath);
+    const remoteDir = path38.posix.dirname(remotePath);
     const parts = [
       `mkdir -p ${shellQuote(remoteDir)}`,
       `cat > ${shellQuote(remotePath)}`
@@ -18726,7 +19342,7 @@ var GitHubCodespacesProvider = class {
       parts.push(`chmod ${options.mode.toString(8)} ${shellQuote(remotePath)}`);
     }
     const cmd = parts.join(" && ");
-    await new Promise((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       const proc = (0, import_child_process16.spawn)(
         "gh",
         ["codespace", "ssh", "-c", workspaceId, "--", cmd],
@@ -18738,7 +19354,7 @@ var GitHubCodespacesProvider = class {
       });
       proc.on("error", reject);
       proc.on("exit", (code) => {
-        if (code === 0) resolve5();
+        if (code === 0) resolve6();
         else reject(new Error(`Remote write failed: ${(stderr || `exit ${code}`).trim().slice(0, 500)}`));
       });
       proc.stdin?.write(contents);
@@ -18787,7 +19403,7 @@ function shellQuote(s) {
 // src/services/providers/gitpod.ts
 var import_child_process17 = require("child_process");
 var import_util5 = require("util");
-var path38 = __toESM(require("path"));
+var path39 = __toESM(require("path"));
 var import_picocolors9 = __toESM(require("picocolors"));
 var execFileP6 = (0, import_util5.promisify)(import_child_process17.execFile);
 var MAX_BUFFER2 = 8 * 1024 * 1024;
@@ -18828,10 +19444,10 @@ var GitpodProvider = class {
       "Authenticating Gitpod"
     );
     resetStdinForChild2();
-    await new Promise((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       const proc = (0, import_child_process17.spawn)("gitpod", ["login"], { stdio: "inherit" });
       proc.on("exit", (code) => {
-        if (code === 0) resolve5();
+        if (code === 0) resolve6();
         else reject(new Error("gitpod login failed."));
       });
       proc.on("error", reject);
@@ -18980,13 +19596,13 @@ var GitpodProvider = class {
   }
   async streamCommand(workspaceId, command2) {
     resetStdinForChild2();
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const proc = (0, import_child_process17.spawn)(
         "gitpod",
         ["workspace", "ssh", workspaceId, "--", "-tt", command2],
         { stdio: "inherit" }
       );
-      proc.on("exit", (code) => resolve5({ code: code ?? 0 }));
+      proc.on("exit", (code) => resolve6({ code: code ?? 0 }));
       proc.on("error", reject);
     });
   }
@@ -19000,7 +19616,7 @@ var GitpodProvider = class {
     tarArgs.push(".");
     const tarEnv = { ...process.env, COPYFILE_DISABLE: "1" };
     const remoteCmd = `mkdir -p ${shellQuote2(remoteDir)} && tar -xzf - -C ${shellQuote2(remoteDir)}`;
-    await new Promise((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       const tar = (0, import_child_process17.spawn)("tar", tarArgs, {
         stdio: ["ignore", "pipe", "pipe"],
         env: tarEnv
@@ -19021,13 +19637,13 @@ var GitpodProvider = class {
       tar.on("error", reject);
       ssh.on("error", reject);
       ssh.on("exit", (code) => {
-        if (code === 0) resolve5();
+        if (code === 0) resolve6();
         else reject(new Error(`Remote tar failed: ${(sshErr || tarErr || `exit ${code}`).trim().slice(0, 500)}`));
       });
     });
   }
   async uploadFile(workspaceId, remotePath, contents, options = {}) {
-    const remoteDir = path38.posix.dirname(remotePath);
+    const remoteDir = path39.posix.dirname(remotePath);
     const parts = [
       `mkdir -p ${shellQuote2(remoteDir)}`,
       `cat > ${shellQuote2(remotePath)}`
@@ -19036,7 +19652,7 @@ var GitpodProvider = class {
       parts.push(`chmod ${options.mode.toString(8)} ${shellQuote2(remotePath)}`);
     }
     const cmd = parts.join(" && ");
-    await new Promise((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       const proc = (0, import_child_process17.spawn)(
         "gitpod",
         ["workspace", "ssh", workspaceId, "--", cmd],
@@ -19048,7 +19664,7 @@ var GitpodProvider = class {
       });
       proc.on("error", reject);
       proc.on("exit", (code) => {
-        if (code === 0) resolve5();
+        if (code === 0) resolve6();
         else reject(new Error(`Remote write failed: ${(stderr || `exit ${code}`).trim().slice(0, 500)}`));
       });
       proc.stdin?.write(contents);
@@ -19063,7 +19679,7 @@ function shellQuote2(s) {
 // src/services/providers/gitlab-workspaces.ts
 var import_child_process18 = require("child_process");
 var import_util6 = require("util");
-var path39 = __toESM(require("path"));
+var path40 = __toESM(require("path"));
 var execFileP7 = (0, import_util6.promisify)(import_child_process18.execFile);
 var MAX_BUFFER3 = 8 * 1024 * 1024;
 var GITLAB_API_BASE = process.env.CODEAM_GITLAB_API_URL ?? "https://gitlab.com/api/v4";
@@ -19105,14 +19721,14 @@ var GitLabWorkspacesProvider = class {
       "Authenticating GitLab"
     );
     resetStdinForChild3();
-    await new Promise((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       const proc = (0, import_child_process18.spawn)(
         "glab",
         ["auth", "login", "--scopes", "api,read_user,read_repository"],
         { stdio: "inherit" }
       );
       proc.on("exit", (code) => {
-        if (code === 0) resolve5();
+        if (code === 0) resolve6();
         else reject(new Error("glab auth login failed."));
       });
       proc.on("error", reject);
@@ -19277,13 +19893,13 @@ Docs: https://docs.gitlab.com/ee/user/workspace/configuration.html`
   async streamCommand(workspaceId, command2) {
     const sshHost = process.env.CODEAM_GITLAB_SSH_HOST ?? "workspaces.gitlab.com";
     resetStdinForChild3();
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const proc = (0, import_child_process18.spawn)(
         "ssh",
         ["-tt", "-o", "StrictHostKeyChecking=accept-new", `${workspaceId}@${sshHost}`, command2],
         { stdio: "inherit" }
       );
-      proc.on("exit", (code) => resolve5({ code: code ?? 0 }));
+      proc.on("exit", (code) => resolve6({ code: code ?? 0 }));
       proc.on("error", reject);
     });
   }
@@ -19298,7 +19914,7 @@ Docs: https://docs.gitlab.com/ee/user/workspace/configuration.html`
     tarArgs.push(".");
     const tarEnv = { ...process.env, COPYFILE_DISABLE: "1" };
     const remoteCmd = `mkdir -p ${shellQuote3(remoteDir)} && tar -xzf - -C ${shellQuote3(remoteDir)}`;
-    await new Promise((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       const tar = (0, import_child_process18.spawn)("tar", tarArgs, { stdio: ["ignore", "pipe", "pipe"], env: tarEnv });
       const ssh = (0, import_child_process18.spawn)(
         "ssh",
@@ -19316,20 +19932,20 @@ Docs: https://docs.gitlab.com/ee/user/workspace/configuration.html`
       tar.on("error", reject);
       ssh.on("error", reject);
       ssh.on("exit", (code) => {
-        if (code === 0) resolve5();
+        if (code === 0) resolve6();
         else reject(new Error(`Remote tar failed: ${(sshErr || tarErr || `exit ${code}`).trim().slice(0, 500)}`));
       });
     });
   }
   async uploadFile(workspaceId, remotePath, contents, options = {}) {
     const sshHost = process.env.CODEAM_GITLAB_SSH_HOST ?? "workspaces.gitlab.com";
-    const remoteDir = path39.posix.dirname(remotePath);
+    const remoteDir = path40.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((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       const proc = (0, import_child_process18.spawn)(
         "ssh",
         ["-o", "StrictHostKeyChecking=accept-new", `${workspaceId}@${sshHost}`, cmd],
@@ -19341,7 +19957,7 @@ Docs: https://docs.gitlab.com/ee/user/workspace/configuration.html`
       });
       proc.on("error", reject);
       proc.on("exit", (code) => {
-        if (code === 0) resolve5();
+        if (code === 0) resolve6();
         else reject(new Error(`Remote write failed: ${(stderr || `exit ${code}`).trim().slice(0, 500)}`));
       });
       proc.stdin?.write(contents);
@@ -19391,7 +20007,7 @@ function shellQuote3(s) {
 // src/services/providers/railway.ts
 var import_child_process19 = require("child_process");
 var import_util7 = require("util");
-var path40 = __toESM(require("path"));
+var path41 = __toESM(require("path"));
 var execFileP8 = (0, import_util7.promisify)(import_child_process19.execFile);
 var MAX_BUFFER4 = 8 * 1024 * 1024;
 function resetStdinForChild4() {
@@ -19432,10 +20048,10 @@ var RailwayProvider = class {
       "Authenticating Railway"
     );
     resetStdinForChild4();
-    await new Promise((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       const proc = (0, import_child_process19.spawn)("railway", ["login"], { stdio: "inherit" });
       proc.on("exit", (code) => {
-        if (code === 0) resolve5();
+        if (code === 0) resolve6();
         else reject(new Error("railway login failed."));
       });
       proc.on("error", reject);
@@ -19575,13 +20191,13 @@ var RailwayProvider = class {
       throw new Error("Invalid Railway workspace id (expected projectId/serviceId).");
     }
     resetStdinForChild4();
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const proc = (0, import_child_process19.spawn)(
         "railway",
         ["shell", "--project", projectId, "--service", serviceId, "--command", command2],
         { stdio: "inherit" }
       );
-      proc.on("exit", (code) => resolve5({ code: code ?? 0 }));
+      proc.on("exit", (code) => resolve6({ code: code ?? 0 }));
       proc.on("error", reject);
     });
   }
@@ -19599,7 +20215,7 @@ var RailwayProvider = class {
     tarArgs.push(".");
     const tarEnv = { ...process.env, COPYFILE_DISABLE: "1" };
     const remoteCmd = `mkdir -p ${shellQuote4(remoteDir)} && tar -xzf - -C ${shellQuote4(remoteDir)}`;
-    await new Promise((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       const tar = (0, import_child_process19.spawn)("tar", tarArgs, { stdio: ["ignore", "pipe", "pipe"], env: tarEnv });
       const sh = (0, import_child_process19.spawn)(
         "railway",
@@ -19617,7 +20233,7 @@ var RailwayProvider = class {
       tar.on("error", reject);
       sh.on("error", reject);
       sh.on("exit", (code) => {
-        if (code === 0) resolve5();
+        if (code === 0) resolve6();
         else reject(new Error(`Remote tar failed: ${(shErr || tarErr || `exit ${code}`).trim().slice(0, 500)}`));
       });
     });
@@ -19627,13 +20243,13 @@ var RailwayProvider = class {
     if (!projectId || !serviceId) {
       throw new Error("Invalid Railway workspace id (expected projectId/serviceId).");
     }
-    const remoteDir = path40.posix.dirname(remotePath);
+    const remoteDir = path41.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((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       const proc = (0, import_child_process19.spawn)(
         "railway",
         ["shell", "--project", projectId, "--service", serviceId, "--command", cmd],
@@ -19645,7 +20261,7 @@ var RailwayProvider = class {
       });
       proc.on("error", reject);
       proc.on("exit", (code) => {
-        if (code === 0) resolve5();
+        if (code === 0) resolve6();
         else reject(new Error(`Remote write failed: ${(stderr || `exit ${code}`).trim().slice(0, 500)}`));
       });
       proc.stdin?.write(contents);
@@ -20169,9 +20785,9 @@ async function stopWorkspaceFromLocal(target) {
 // src/commands/doctor.ts
 var import_node_dns = require("dns");
 var import_node_util4 = require("util");
-var import_node_crypto6 = require("crypto");
-var fs32 = __toESM(require("fs"));
-var path41 = __toESM(require("path"));
+var import_node_crypto8 = require("crypto");
+var fs33 = __toESM(require("fs"));
+var path42 = __toESM(require("path"));
 var import_picocolors12 = __toESM(require("picocolors"));
 var dnsResolveP = (0, import_node_util4.promisify)(import_node_dns.resolve);
 async function checkDns(apiBase) {
@@ -20227,13 +20843,13 @@ async function checkHealth(apiBase) {
   }
 }
 function checkConfigDir() {
-  const dir = path41.join(require("os").homedir(), ".codeam");
+  const dir = path42.join(require("os").homedir(), ".codeam");
   try {
-    fs32.mkdirSync(dir, { recursive: true, mode: 448 });
-    const probe = path41.join(dir, ".doctor-probe");
-    fs32.writeFileSync(probe, "ok", { mode: 384 });
-    const read = fs32.readFileSync(probe, "utf8");
-    fs32.unlinkSync(probe);
+    fs33.mkdirSync(dir, { recursive: true, mode: 448 });
+    const probe = path42.join(dir, ".doctor-probe");
+    fs33.writeFileSync(probe, "ok", { mode: 384 });
+    const read = fs33.readFileSync(probe, "utf8");
+    fs33.unlinkSync(probe);
     if (read !== "ok") throw new Error("write/read round-trip mismatch");
     return {
       id: "config-dir",
@@ -20297,7 +20913,7 @@ function checkNodePty() {
       detail: "not required on this platform"
     };
   }
-  const vendoredPath = path41.join(__dirname, "vendor", "node-pty");
+  const vendoredPath = path42.join(__dirname, "vendor", "node-pty");
   for (const target of [vendoredPath, "node-pty"]) {
     try {
       require(target);
@@ -20339,9 +20955,9 @@ function checkChokidar() {
 }
 async function doctor(args2 = []) {
   const json = args2.includes("--json");
-  const cliVersion = true ? "2.27.1" : "0.0.0-dev";
+  const cliVersion = true ? "2.27.2" : "0.0.0-dev";
   const apiBase = resolveApiBaseUrl();
-  const diagnosticId = (0, import_node_crypto6.randomUUID)();
+  const diagnosticId = (0, import_node_crypto8.randomUUID)();
   log.info("doctor", `run id=${diagnosticId} cli=${cliVersion}`);
   const [dns, health] = await Promise.all([
     checkDns(apiBase),
@@ -20538,7 +21154,7 @@ async function completion(args2) {
 // src/commands/version.ts
 var import_picocolors13 = __toESM(require("picocolors"));
 function version2() {
-  const v = true ? "2.27.1" : "unknown";
+  const v = true ? "2.27.2" : "unknown";
   console.log(`${import_picocolors13.default.bold("codeam-cli")} ${import_picocolors13.default.cyan(v)}`);
 }
 
@@ -20666,9 +21282,9 @@ function tryShowSubcommandHelp(cmd, args2) {
 var _subcommandHelpKeys = Object.keys(HELPS);
 
 // src/lib/updateNotifier.ts
-var fs33 = __toESM(require("fs"));
+var fs34 = __toESM(require("fs"));
 var os26 = __toESM(require("os"));
-var path42 = __toESM(require("path"));
+var path43 = __toESM(require("path"));
 var https7 = __toESM(require("https"));
 var import_picocolors16 = __toESM(require("picocolors"));
 var PKG_NAME = "codeam-cli";
@@ -20676,12 +21292,12 @@ 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 = path42.join(os26.homedir(), ".codeam");
-  return path42.join(dir, "update-check.json");
+  const dir = path43.join(os26.homedir(), ".codeam");
+  return path43.join(dir, "update-check.json");
 }
 function readCache() {
   try {
-    const raw = fs33.readFileSync(cachePath(), "utf8");
+    const raw = fs34.readFileSync(cachePath(), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.fetchedAt !== "number" || typeof parsed.latest !== "string") return null;
     return parsed;
@@ -20692,10 +21308,10 @@ function readCache() {
 function writeCache(cache) {
   try {
     const file = cachePath();
-    fs33.mkdirSync(path42.dirname(file), { recursive: true });
+    fs34.mkdirSync(path43.dirname(file), { recursive: true });
     const tmp = `${file}.${process.pid}.tmp`;
-    fs33.writeFileSync(tmp, JSON.stringify(cache));
-    fs33.renameSync(tmp, file);
+    fs34.writeFileSync(tmp, JSON.stringify(cache));
+    fs34.renameSync(tmp, file);
   } catch {
   }
 }
@@ -20713,40 +21329,40 @@ function compareSemver(a, b) {
   return 0;
 }
 function fetchLatest() {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const req = https7.get(
       REGISTRY_URL,
       { headers: { Accept: "application/json" }, timeout: REQUEST_TIMEOUT_MS },
       (res) => {
         if (res.statusCode !== 200) {
           res.resume();
-          resolve5(null);
+          resolve6(null);
           return;
         }
         let buf = "";
         res.setEncoding("utf8");
-        res.on("data", (chunk) => {
-          buf += chunk;
+        res.on("data", (chunk2) => {
+          buf += chunk2;
         });
         res.on("end", () => {
           try {
             const json = JSON.parse(buf);
             if (typeof json.version === "string") {
-              resolve5(json.version);
+              resolve6(json.version);
             } else {
-              resolve5(null);
+              resolve6(null);
             }
           } catch {
-            resolve5(null);
+            resolve6(null);
           }
         });
       }
     );
     req.on("timeout", () => {
       req.destroy();
-      resolve5(null);
+      resolve6(null);
     });
-    req.on("error", () => resolve5(null));
+    req.on("error", () => resolve6(null));
   });
 }
 function notifyIfStale(currentVersion, latest) {
@@ -20766,7 +21382,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.27.1" : null;
+  const current = true ? "2.27.2" : null;
   if (!current) return;
   const cache = readCache();
   const fresh = cache && Date.now() - cache.fetchedAt < TTL_MS;