codeam-cli 2.4.39 → 2.5.1

package/dist/index.js

@@ -519,9 +519,9 @@ var require_windowsPtyAgent = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.argsToCommandLine = exports2.WindowsPtyAgent = void 0;
-    var fs11 = require("fs");
-    var os10 = require("os");
-    var path18 = require("path");
+    var fs12 = require("fs");
+    var os11 = require("os");
+    var path19 = require("path");
     var child_process_1 = require("child_process");
     var net_1 = require("net");
     var windowsConoutConnection_1 = require_windowsConoutConnection();
@@ -557,7 +557,7 @@ var require_windowsPtyAgent = __commonJS({
             }
           }
           this._ptyNative = this._useConpty ? conptyNative : winptyNative;
-          cwd = path18.resolve(cwd);
+          cwd = path19.resolve(cwd);
           var commandLine = argsToCommandLine(file, args2);
           var term;
           if (this._useConpty) {
@@ -578,7 +578,7 @@ var require_windowsPtyAgent = __commonJS({
           this._outSocket.on("connect", function() {
             _this._outSocket.emit("ready_datapipe");
           });
-          var inSocketFD = fs11.openSync(term.conin, "w");
+          var inSocketFD = fs12.openSync(term.conin, "w");
           this._inSocket = new net_1.Socket({
             fd: inSocketFD,
             readable: false,
@@ -679,7 +679,7 @@ var require_windowsPtyAgent = __commonJS({
         WindowsPtyAgent2.prototype._getConsoleProcessList = function() {
           var _this = this;
           return new Promise(function(resolve2) {
-            var agent = child_process_1.fork(path18.join(__dirname, "conpty_console_list_agent"), [_this._innerPid.toString()]);
+            var agent = child_process_1.fork(path19.join(__dirname, "conpty_console_list_agent"), [_this._innerPid.toString()]);
             agent.on("message", function(message) {
               clearTimeout(timeout);
               resolve2(message.consoleProcessList);
@@ -702,7 +702,7 @@ var require_windowsPtyAgent = __commonJS({
           configurable: true
         });
         WindowsPtyAgent2.prototype._getWindowsBuildNumber = function() {
-          var osVersion = /(\d+)\.(\d+)\.(\d+)/g.exec(os10.release());
+          var osVersion = /(\d+)\.(\d+)\.(\d+)/g.exec(os11.release());
           var buildNumber = 0;
           if (osVersion && osVersion.length === 4) {
             buildNumber = parseInt(osVersion[3]);
@@ -1012,15 +1012,15 @@ var require_unixTerminal = __commonJS({
     })();
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.UnixTerminal = void 0;
-    var fs11 = require("fs");
-    var path18 = require("path");
+    var fs12 = require("fs");
+    var path19 = require("path");
     var tty = require("tty");
     var terminal_1 = require_terminal();
     var utils_1 = require_utils();
     var native = utils_1.loadNativeModule("pty");
     var pty = native.module;
     var helperPath = native.dir + "/spawn-helper";
-    helperPath = path18.resolve(__dirname, helperPath);
+    helperPath = path19.resolve(__dirname, helperPath);
     helperPath = helperPath.replace("app.asar", "app.asar.unpacked");
     helperPath = helperPath.replace("node_modules.asar", "node_modules.asar.unpacked");
     var DEFAULT_FILE = "sh";
@@ -1275,7 +1275,7 @@ var require_unixTerminal = __commonJS({
             return;
           }
           var task = this._writeQueue[0];
-          fs11.write(this._fd, task.buffer, task.offset, function(err, written) {
+          fs12.write(this._fd, task.buffer, task.offset, function(err, written) {
             if (err) {
               if ("code" in err && err.code === "EAGAIN") {
                 _this._writeImmediate = setImmediate(function() {
@@ -1313,10 +1313,10 @@ var require_lib = __commonJS({
     } else {
       terminalCtor = require_unixTerminal().UnixTerminal;
     }
-    function spawn8(file, args2, opt) {
+    function spawn10(file, args2, opt) {
       return new terminalCtor(file, args2, opt);
     }
-    exports2.spawn = spawn8;
+    exports2.spawn = spawn10;
     function fork(file, args2, opt) {
       return new terminalCtor(file, args2, opt);
     }
@@ -1390,11 +1390,6 @@ var require_src = __commonJS({
 });
 
 // src/commands/start.ts
-var fs8 = __toESM(require("fs"));
-var os7 = __toESM(require("os"));
-var path11 = __toESM(require("path"));
-var import_crypto = require("crypto");
-var import_child_process5 = require("child_process");
 var import_picocolors2 = __toESM(require("picocolors"));
 
 // src/config.ts
@@ -1482,7 +1477,7 @@ var import_qrcode_terminal = __toESM(require("qrcode-terminal"));
 // package.json
 var package_default = {
   name: "codeam-cli",
-  version: "2.4.39",
+  version: "2.5.1",
   description: "Remote control Claude Code (and other AI coding agents) from your mobile phone. Pair your device, send prompts, stream responses in real-time, and approve commands \u2014 from anywhere.",
   type: "commonjs",
   main: "dist/index.js",
@@ -1601,8 +1596,14 @@ function showPairingCode(code, expiresAt) {
   console.log("");
 }
 
-// src/services/websocket.service.ts
-var import_ws = __toESM(require("ws"));
+// src/services/command-relay.service.ts
+var https2 = __toESM(require("https"));
+var http2 = __toESM(require("http"));
+
+// src/services/pairing.service.ts
+var https = __toESM(require("https"));
+var http = __toESM(require("http"));
+var os2 = __toESM(require("os"));
 
 // src/lib/poll-delay.ts
 var MAX_DELAY_MS = 3e4;
@@ -1612,175 +1613,17 @@ function computePollDelay({ baseMs, failures }) {
   return Math.round(jitter);
 }
 
-// src/services/logger.ts
-var fs2 = __toESM(require("fs"));
-var os2 = __toESM(require("os"));
-var path2 = __toESM(require("path"));
-var LEVELS = { silent: 0, error: 1, warn: 2, info: 3, debug: 4, trace: 5 };
-function currentLevel() {
-  if (process.env.CODEAM_DEBUG === "1") return LEVELS.trace;
-  const raw = (process.env.CODEAM_LOG ?? "error").toLowerCase();
-  return LEVELS[raw] ?? LEVELS.error;
-}
-var fileEnabled = process.env.CODEAM_DEBUG === "1" || process.env.CODEAM_LOG === "debug" || process.env.CODEAM_LOG === "trace";
-var debugFilePath = path2.join(os2.homedir(), ".codeam", "debug.log");
-var fileInitialized = false;
-function appendToFile(line) {
-  if (!fileEnabled) return;
-  try {
-    if (!fileInitialized) {
-      fs2.mkdirSync(path2.dirname(debugFilePath), { recursive: true });
-      fs2.writeFileSync(
-        debugFilePath,
-        `=== codeam debug log \u2014 pid ${process.pid} \u2014 ${(/* @__PURE__ */ new Date()).toISOString()} ===
-platform=${process.platform} node=${process.version} cwd=${process.cwd()}
-
-`
-      );
-      fileInitialized = true;
-    }
-    fs2.appendFileSync(debugFilePath, line);
-  } catch {
-  }
-}
-function emit(level, tag, msg, err) {
-  if (LEVELS[level] > currentLevel()) return;
-  const detail = err instanceof Error ? `: ${err.message}` : err !== void 0 ? `: ${String(err)}` : "";
-  const line = `[codeam:${level}] ${tag} \u2014 ${msg}${detail}
-`;
-  process.stderr.write(line);
-  if (LEVELS[level] >= LEVELS.debug) {
-    appendToFile(`${(/* @__PURE__ */ new Date()).toISOString()} ${line}`);
-  }
-}
-var log = {
-  error: (tag, msg, err) => emit("error", tag, msg, err),
-  warn: (tag, msg, err) => emit("warn", tag, msg, err),
-  info: (tag, msg, err) => emit("info", tag, msg, err),
-  debug: (tag, msg, err) => emit("debug", tag, msg, err),
-  /**
-   * Verbose pipeline breadcrumb. Only fires when CODEAM_LOG=trace or
-   * CODEAM_DEBUG=1, so call sites can be liberal — they have zero
-   * cost in normal runs.
-   */
-  trace: (tag, msg, err) => emit("trace", tag, msg, err)
-};
-
-// src/services/websocket.service.ts
-var API_BASE = process.env.CODEAM_API_URL ?? "https://codeagent-mobile-api.vercel.app";
-var WS_URL = API_BASE.replace("https://", "wss://").replace("http://", "ws://") + "/api/ws";
-var HEARTBEAT_MS = 3e4;
-var MAX_RECONNECT = 10;
-var WebSocketService = class {
-  constructor(sessionId, pluginId) {
-    this.sessionId = sessionId;
-    this.pluginId = pluginId;
-  }
-  sessionId;
-  pluginId;
-  client = null;
-  heartbeat = null;
-  reconnectTimer = null;
-  reconnectAttempts = 0;
-  handlers = [];
-  _connected = false;
-  get connected() {
-    return this._connected;
-  }
-  addHandler(h) {
-    this.handlers.push(h);
-  }
-  connect() {
-    this.disconnect();
-    try {
-      this.client = new import_ws.default(WS_URL);
-      this.client.on("open", () => {
-        log.trace("ws", `connected to ${WS_URL}`);
-        this._connected = true;
-        this.reconnectAttempts = 0;
-        this.client.send(JSON.stringify({
-          type: "auth",
-          payload: { sessionId: this.sessionId, pluginId: this.pluginId },
-          timestamp: Date.now()
-        }));
-        this.startHeartbeat();
-        this.handlers.forEach((h) => h.onConnected());
-      });
-      this.client.on("message", (raw) => {
-        try {
-          const msg = JSON.parse(raw.toString());
-          if (msg.type === "pong" || msg.type === "auth_success" || msg.type === "auth_error") {
-            log.trace("ws", `meta msg type=${msg.type}`);
-            return;
-          }
-          log.trace("ws", `dispatch msg type=${msg.type}`);
-          this.handlers.forEach((h) => h.onMessage(msg.type, msg.payload ?? {}));
-        } catch (err) {
-          log.trace("ws", "malformed message", err);
-        }
-      });
-      this.client.on("close", (code, reason) => {
-        log.trace("ws", `closed code=${code} reason=${reason?.toString() || "(empty)"}`);
-        this._connected = false;
-        this.stopHeartbeat();
-        this.handlers.forEach((h) => h.onDisconnected());
-        if (this.reconnectAttempts < MAX_RECONNECT) {
-          this.reconnectAttempts++;
-          const delay = computePollDelay({ baseMs: 1e3, failures: this.reconnectAttempts });
-          this.reconnectTimer = setTimeout(() => this.connect(), delay);
-        }
-      });
-      this.client.on("error", (err) => {
-        log.trace("ws", "error", err);
-      });
-    } catch (err) {
-      log.trace("ws", "sync connect threw", err);
-    }
-  }
-  send(type, payload) {
-    if (!this._connected || !this.client) return;
-    this.client.send(JSON.stringify({ type, payload, timestamp: Date.now() }));
-  }
-  disconnect() {
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    this.reconnectAttempts = 0;
-    this.stopHeartbeat();
-    this.client?.removeAllListeners();
-    this.client?.close();
-    this.client = null;
-    this._connected = false;
-  }
-  startHeartbeat() {
-    this.stopHeartbeat();
-    this.heartbeat = setInterval(() => {
-      if (this._connected) this.client?.send(JSON.stringify({ type: "ping", timestamp: Date.now() }));
-    }, HEARTBEAT_MS);
-  }
-  stopHeartbeat() {
-    if (this.heartbeat) {
-      clearInterval(this.heartbeat);
-      this.heartbeat = null;
-    }
-  }
-};
-
 // src/services/pairing.service.ts
-var https = __toESM(require("https"));
-var http = __toESM(require("http"));
-var os3 = __toESM(require("os"));
-var API_BASE2 = process.env.CODEAM_API_URL ?? "https://codeagent-mobile-api.vercel.app";
+var API_BASE = process.env.CODEAM_API_URL ?? "https://codeagent-mobile-api.vercel.app";
 async function requestCode(pluginId) {
   try {
     const runtime = process.env.CODESPACES === "true" ? "github-codespaces" : "local";
     const codespaceName = process.env.CODESPACE_NAME;
-    const result = await _transport.postJson(`${API_BASE2}/api/pairing/code`, {
+    const result = await _transport.postJson(`${API_BASE}/api/pairing/code`, {
       pluginId,
       ideName: "Terminal (codeam-cli)",
       ideVersion: package_default.version,
-      hostname: os3.hostname(),
+      hostname: os2.hostname(),
       runtime,
       ...codespaceName ? { codespaceName } : {}
     });
@@ -1799,7 +1642,7 @@ function pollStatus(pluginId, onPaired, onTimeout) {
     if (stopped) return;
     try {
       const result = await _transport.getJson(
-        `${API_BASE2}/api/pairing/status?pluginId=${pluginId}`
+        `${API_BASE}/api/pairing/status?pluginId=${pluginId}`
       );
       consecutiveFailures = 0;
       const data = result?.data;
@@ -1932,8 +1775,62 @@ async function _getJson(url) {
   });
 }
 
+// src/services/logger.ts
+var fs2 = __toESM(require("fs"));
+var os3 = __toESM(require("os"));
+var path2 = __toESM(require("path"));
+var LEVELS = { silent: 0, error: 1, warn: 2, info: 3, debug: 4, trace: 5 };
+function currentLevel() {
+  if (process.env.CODEAM_DEBUG === "1") return LEVELS.trace;
+  const raw = (process.env.CODEAM_LOG ?? "error").toLowerCase();
+  return LEVELS[raw] ?? LEVELS.error;
+}
+var fileEnabled = process.env.CODEAM_DEBUG === "1" || process.env.CODEAM_LOG === "debug" || process.env.CODEAM_LOG === "trace";
+var debugFilePath = path2.join(os3.homedir(), ".codeam", "debug.log");
+var fileInitialized = false;
+function appendToFile(line) {
+  if (!fileEnabled) return;
+  try {
+    if (!fileInitialized) {
+      fs2.mkdirSync(path2.dirname(debugFilePath), { recursive: true });
+      fs2.writeFileSync(
+        debugFilePath,
+        `=== codeam debug log \u2014 pid ${process.pid} \u2014 ${(/* @__PURE__ */ new Date()).toISOString()} ===
+platform=${process.platform} node=${process.version} cwd=${process.cwd()}
+
+`
+      );
+      fileInitialized = true;
+    }
+    fs2.appendFileSync(debugFilePath, line);
+  } catch {
+  }
+}
+function emit(level, tag, msg, err) {
+  if (LEVELS[level] > currentLevel()) return;
+  const detail = err instanceof Error ? `: ${err.message}` : err !== void 0 ? `: ${String(err)}` : "";
+  const line = `[codeam:${level}] ${tag} \u2014 ${msg}${detail}
+`;
+  process.stderr.write(line);
+  if (LEVELS[level] >= LEVELS.debug) {
+    appendToFile(`${(/* @__PURE__ */ new Date()).toISOString()} ${line}`);
+  }
+}
+var log = {
+  error: (tag, msg, err) => emit("error", tag, msg, err),
+  warn: (tag, msg, err) => emit("warn", tag, msg, err),
+  info: (tag, msg, err) => emit("info", tag, msg, err),
+  debug: (tag, msg, err) => emit("debug", tag, msg, err),
+  /**
+   * Verbose pipeline breadcrumb. Only fires when CODEAM_LOG=trace or
+   * CODEAM_DEBUG=1, so call sites can be liberal — they have zero
+   * cost in normal runs.
+   */
+  trace: (tag, msg, err) => emit("trace", tag, msg, err)
+};
+
 // src/services/command-relay.service.ts
-var API_BASE3 = process.env.CODEAM_API_URL ?? "https://codeagent-mobile-api.vercel.app";
+var API_BASE2 = process.env.CODEAM_API_URL ?? "https://codeagent-mobile-api.vercel.app";
 var CommandRelayService = class {
   constructor(pluginId, onCommand) {
     this.pluginId = pluginId;
@@ -1942,108 +1839,179 @@ var CommandRelayService = class {
   pluginId;
   onCommand;
   _running = false;
-  pollTimer = null;
   heartbeatTimer = null;
   agentsTimer = null;
-  consecutiveFailures = 0;
   /** True once `/api/plugin/agents` has accepted at least one report. */
   agentsRegistered = false;
+  /** SSE connection (null when on the polling fallback or stopped). */
+  sseRequest = null;
+  /** Polling backoff state (only used on the fallback). */
+  pollTimer = null;
+  pollFailures = 0;
+  /** Reconnect backoff state for the SSE stream. */
+  sseFailures = 0;
+  sseReconnectTimer = null;
   start() {
-    if (this.pollTimer) {
-      clearTimeout(this.pollTimer);
-      this.pollTimer = null;
-    }
-    if (this.heartbeatTimer) {
-      clearInterval(this.heartbeatTimer);
-      this.heartbeatTimer = null;
-    }
-    if (this.agentsTimer) {
-      clearInterval(this.agentsTimer);
-      this.agentsTimer = null;
-    }
+    this.cleanup();
     this._running = true;
     this.agentsRegistered = false;
     this.sendHeartbeat(true);
     this.heartbeatTimer = setInterval(() => this.sendHeartbeat(true), 2e4);
-    void this.pollLoop();
-    this.reportAgents();
     this.agentsTimer = setInterval(() => {
       if (this._running && !this.agentsRegistered) this.reportAgents();
     }, 5e3);
+    this.reportAgents();
+    if (process.env.NODE_ENV === "test" || process.env.CODEAM_DISABLE_SSE_PULL === "1") {
+      this.startPollingFallback();
+    } else {
+      this.connectSSE();
+    }
   }
   stop() {
     if (!this._running) return;
     this._running = false;
-    if (this.pollTimer) {
-      clearTimeout(this.pollTimer);
-      this.pollTimer = null;
-    }
-    if (this.heartbeatTimer) {
-      clearInterval(this.heartbeatTimer);
-      this.heartbeatTimer = null;
-    }
-    if (this.agentsTimer) {
-      clearInterval(this.agentsTimer);
-      this.agentsTimer = null;
-    }
+    this.cleanup();
     this.sendHeartbeat(false).catch(() => {
     });
   }
   async sendResult(commandId, status2, result) {
-    await _postJson(`${API_BASE3}/api/commands/result`, { commandId, status: status2, result });
+    await _postJson(`${API_BASE2}/api/commands/result`, { commandId, status: status2, result });
+  }
+  // ─── SSE pull (primary) ──────────────────────────────────────────
+  connectSSE() {
+    if (!this._running) return;
+    const url = new URL(`${API_BASE2}/api/commands/pending/stream`);
+    url.searchParams.set("pluginId", this.pluginId);
+    const transport = url.protocol === "https:" ? https2 : http2;
+    log.trace("relay", `sse connect ${url.pathname}`);
+    const req = transport.request(
+      {
+        hostname: url.hostname,
+        port: url.port || (url.protocol === "https:" ? 443 : 80),
+        path: `${url.pathname}${url.search}`,
+        method: "GET",
+        headers: { Accept: "text/event-stream", "Cache-Control": "no-cache" },
+        timeout: 35e3
+      },
+      (res) => {
+        if (res.statusCode !== 200) {
+          log.trace("relay", `sse status=${res.statusCode}`);
+          res.resume();
+          this.sseFailures += 1;
+          if (this.sseFailures >= 2) {
+            log.trace("relay", "sse unavailable, falling back to polling");
+            this.startPollingFallback();
+            return;
+          }
+          this.scheduleSseReconnect();
+          return;
+        }
+        this.sseFailures = 0;
+        let buffer = "";
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => {
+          buffer += chunk;
+          let frameEnd;
+          while ((frameEnd = buffer.indexOf("\n\n")) !== -1) {
+            const frame = buffer.slice(0, frameEnd);
+            buffer = buffer.slice(frameEnd + 2);
+            this.handleSseFrame(frame);
+          }
+        });
+        res.on("end", () => {
+          if (this._running) this.scheduleSseReconnect();
+        });
+        res.on("error", () => {
+          if (this._running) this.scheduleSseReconnect();
+        });
+      }
+    );
+    req.on("error", (err) => {
+      log.trace("relay", "sse req error", err);
+      this.sseFailures += 1;
+      if (this.sseFailures >= 2) {
+        this.startPollingFallback();
+        return;
+      }
+      this.scheduleSseReconnect();
+    });
+    req.on("timeout", () => {
+      req.destroy();
+    });
+    req.end();
+    this.sseRequest = req;
+  }
+  handleSseFrame(frame) {
+    let event = "message";
+    let data = "";
+    for (const line of frame.split("\n")) {
+      if (line.startsWith("event: ")) event = line.slice(7).trim();
+      else if (line.startsWith("data: ")) data += line.slice(6);
+    }
+    if (event !== "commands" || !data) return;
+    try {
+      const parsed = JSON.parse(data);
+      const commands = parsed.commands ?? [];
+      if (commands.length === 0) return;
+      log.trace("relay", `sse received ${commands.length} command(s)`);
+      void this.dispatchCommands(commands);
+    } catch (err) {
+      log.trace("relay", "sse parse error", err);
+    }
+  }
+  scheduleSseReconnect() {
+    if (this.sseReconnectTimer) return;
+    const delay = computePollDelay({ baseMs: 1e3, failures: this.sseFailures });
+    this.sseReconnectTimer = setTimeout(() => {
+      this.sseReconnectTimer = null;
+      this.connectSSE();
+    }, delay);
+  }
+  // ─── Polling fallback ────────────────────────────────────────────
+  startPollingFallback() {
+    if (this.pollTimer) return;
+    void this.pollLoop();
   }
   async pollLoop() {
     if (!this._running) return;
-    await this.poll();
+    await this.pollOnce();
     if (this._running) {
-      const delay = computePollDelay({
-        baseMs: 2e3,
-        failures: this.consecutiveFailures
-      });
+      const delay = computePollDelay({ baseMs: 2e3, failures: this.pollFailures });
       this.pollTimer = setTimeout(() => this.pollLoop(), delay);
     }
   }
-  async poll() {
+  async pollOnce() {
     try {
-      const data = await _getJson(
-        `${API_BASE3}/api/commands/pending?pluginId=${this.pluginId}`
-      );
+      const data = await _getJson(`${API_BASE2}/api/commands/pending?pluginId=${this.pluginId}`);
       const commands = data?.data;
-      this.consecutiveFailures = 0;
-      if (!Array.isArray(commands)) return;
-      if (commands.length > 0) {
-        log.trace("relay", `poll received ${commands.length} command(s)`);
-      }
-      for (const obj of commands) {
-        try {
-          log.trace("relay", `dispatch type=${obj.type} id=${obj.id}`);
-          await this.onCommand({
-            id: obj.id,
-            sessionId: obj.sessionId,
-            type: obj.type,
-            payload: obj.payload ?? {}
-          });
-        } catch (err) {
-          log.trace("relay", `command handler threw`, err);
-        }
-      }
+      this.pollFailures = 0;
+      if (!Array.isArray(commands) || commands.length === 0) return;
+      log.trace("relay", `poll received ${commands.length} command(s)`);
+      await this.dispatchCommands(commands);
     } catch (err) {
-      this.consecutiveFailures += 1;
-      log.trace(
-        "relay",
-        `poll failed (failures=${this.consecutiveFailures})`,
-        err
-      );
+      this.pollFailures += 1;
+      log.trace("relay", `poll failed (failures=${this.pollFailures})`, err);
+    }
+  }
+  async dispatchCommands(commands) {
+    for (const cmd of commands) {
+      try {
+        log.trace("relay", `dispatch type=${cmd.type} id=${cmd.id}`);
+        await this.onCommand(cmd);
+      } catch (err) {
+        log.trace("relay", "command handler threw", err);
+      }
     }
   }
+  // ─── Heartbeat + agents ──────────────────────────────────────────
   async sendHeartbeat(online) {
-    await _postJson(`${API_BASE3}/api/plugin/heartbeat`, {
+    await _postJson(`${API_BASE2}/api/plugin/heartbeat`, {
       pluginId: this.pluginId,
       online
     }).then(() => log.trace("relay", `heartbeat ok online=${online}`)).catch((err) => log.trace("relay", `heartbeat failed online=${online}`, err));
   }
   reportAgents() {
-    _postJson(`${API_BASE3}/api/plugin/agents`, {
+    _postJson(`${API_BASE2}/api/plugin/agents`, {
       pluginId: this.pluginId,
       agents: [{ id: "claude-code", name: "Claude Code", icon: "\u{1F916}", installed: true }]
     }).then(() => {
@@ -2051,6 +2019,32 @@ var CommandRelayService = class {
     }).catch(() => {
     });
   }
+  // ─── Lifecycle ───────────────────────────────────────────────────
+  cleanup() {
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.agentsTimer) {
+      clearInterval(this.agentsTimer);
+      this.agentsTimer = null;
+    }
+    if (this.sseReconnectTimer) {
+      clearTimeout(this.sseReconnectTimer);
+      this.sseReconnectTimer = null;
+    }
+    if (this.sseRequest) {
+      try {
+        this.sseRequest.destroy();
+      } catch {
+      }
+      this.sseRequest = null;
+    }
+  }
 };
 
 // src/services/pty/unix.strategy.ts
@@ -4496,8 +4490,14 @@ var ClaudeService = class {
   constructor(opts) {
     this.opts = opts;
     this.strategyOpts = {
-      onData: opts.onData ?? (() => {
-      }),
+      onData: (d3) => {
+        if (!this.claudeReady && d3.length > 0) {
+          this.claudeReady = true;
+          setTimeout(() => this.drainPending(), 250);
+        }
+        (opts.onData ?? (() => {
+        }))(d3);
+      },
       onExit: opts.onExit
     };
   }
@@ -4507,6 +4507,30 @@ var ClaudeService = class {
   // Methods called before spawn() (e.g. early kill/SIGINT) no-op safely.
   strategy = null;
   strategyOpts;
+  /**
+   * Set once the PTY emits its FIRST batch of output — proxy for
+   * "Claude has rendered its input box and is ready to read keystrokes."
+   * Before this, remote `sendCommand`s are buffered (`pendingInputs`)
+   * and replayed in order on first data. Without this guard, the very
+   * first prompt right after `codeam pair` on Windows lands while
+   * Claude's React Ink tree is still mounting — the input bytes are
+   * accepted by the PTY but never make it to the input field, and
+   * the prompt silently vanishes.
+   */
+  claudeReady = false;
+  pendingInputs = [];
+  drainPending() {
+    if (!this.strategy || this.pendingInputs.length === 0) return;
+    const s = this.strategy;
+    log.trace("claude", `drain pending=${this.pendingInputs.length}`);
+    let offset = 0;
+    for (const text of this.pendingInputs) {
+      setTimeout(() => s.write(text), offset);
+      setTimeout(() => s.write("\r"), offset + 50);
+      offset += 200;
+    }
+    this.pendingInputs.length = 0;
+  }
   async spawn() {
     let launch = buildClaudeLaunch();
     if (!launch) {
@@ -4575,6 +4599,11 @@ var ClaudeService = class {
       log.trace("claude", "sendCommand dropped (no strategy)");
       return;
     }
+    if (!this.claudeReady) {
+      log.trace("claude", `sendCommand buffered (not ready) text=${text.length}B`);
+      this.pendingInputs.push(text);
+      return;
+    }
     const s = this.strategy;
     log.trace("claude", `sendCommand text=${text.length}B`);
     s.write(text);
@@ -4645,10 +4674,6 @@ var ClaudeService = class {
   }
 };
 
-// src/services/output.service.ts
-var https2 = __toESM(require("https"));
-var http2 = __toESM(require("http"));
-
 // ../../packages/shared/src/protocol/parseChrome.ts
 var SPINNER_RE = /^(?:[✳✢✶✻✽✴✷✸✹⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏◐◑◒◓▁▂▃▄▅▆▇█]|🔴|🟠|🟡|🟢|🔵|🟣|🟤|⚫|⚪|🌀|💭|✨)\s/u;
 var BULLET_TOOL_RE = /^•\s+(?:Read(?:ing)?|Edit(?:ing)?|Writ(?:e|ing)|Bash|Runn(?:ing)?|Search(?:ing)?|Glob(?:bing)?|Grep(?:ping)?|Creat(?:e|ing)|Execut(?:e|ing)|Task|Agent|NotebookEdit)\b/i;
@@ -5019,158 +5044,358 @@ function getContextWindow(model) {
   return DEFAULT_CONTEXT_WINDOW;
 }
 
+// src/services/output/chrome-tracker.ts
+var ChromeStepTracker = class {
+  history = [];
+  sentCount = 0;
+  reset() {
+    this.history = [];
+    this.sentCount = 0;
+  }
+  /** Parse the rendered lines, append unseen steps to the cumulative history. */
+  ingest(lines) {
+    const visible = lines.filter((l) => isChromeLine(l)).map((l) => parseChromeLine(l)).filter((s) => s !== null);
+    if (visible.length === 0) return;
+    for (const step of visible) {
+      const exists = this.history.some(
+        (s) => s.tool === step.tool && s.label === step.label
+      );
+      if (!exists) this.history.push(step);
+    }
+  }
+  /**
+   * Returns the steps that have NOT yet been shipped on the wire,
+   * marking them as shipped. Empty array means nothing new since
+   * the last call. Caller forwards this as the chunk's
+   * `appendSteps` payload.
+   */
+  consumeDelta() {
+    if (this.history.length === this.sentCount) return [];
+    const delta = this.history.slice(this.sentCount);
+    this.sentCount = this.history.length;
+    return delta;
+  }
+  /** Snapshot of the cumulative unique-step history (debug + tests). */
+  get cumulativeHistory() {
+    return this.history;
+  }
+};
+
+// src/services/output/chunk-emitter.ts
+var https3 = __toESM(require("https"));
+var http3 = __toESM(require("http"));
+var API_BASE3 = process.env.CODEAM_API_URL ?? "https://codeagent-mobile-api.vercel.app";
+var ChunkEmitter = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.headers = {
+      "Content-Type": "application/json",
+      // Tell the backend which wire-format version we speak so
+      // it can route legacy translations / 426 us when we're
+      // too far behind. Bumped to 2.0.0 with the discriminated-
+      // chunk + delta-chrome refactor in this release.
+      "X-Codeam-Protocol-Version": "2.0.0"
+    };
+    if (opts.pluginAuthToken) {
+      this.headers["X-Plugin-Auth-Token"] = opts.pluginAuthToken;
+    }
+  }
+  opts;
+  url = `${API_BASE3}/api/commands/output`;
+  headers;
+  /**
+   * Send a chunk. `body` is the chunk fields minus `sessionId` /
+   * `pluginId` — the emitter splices those in. `critical = true`
+   * triggers up to 3 retries with linear backoff (200/400/600 ms);
+   * non-critical sends are best-effort (a transient miss gets
+   * superseded by the next tick's emission).
+   */
+  async send(body, opts = {}) {
+    const payload = JSON.stringify({
+      sessionId: this.opts.sessionId,
+      pluginId: this.opts.pluginId,
+      ...body
+    });
+    const maxRetries = opts.critical ? 3 : 0;
+    log.trace(
+      "chunkEmitter",
+      `send type=${body.type ?? "(clear)"} bytes=${payload.length}`
+    );
+    return new Promise((resolve2) => {
+      const attempt = (attemptsLeft) => {
+        _transport2.post(this.url, this.headers, payload).then(({ statusCode, body: resBody }) => {
+          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");
+            resolve2({ dead: true });
+            return;
+          }
+          if (statusCode >= 400) {
+            process.stderr.write(`[codeam] output API error ${statusCode}: ${resBody}
+`);
+          }
+          log.trace("chunkEmitter", `status=${statusCode}`);
+          resolve2({ dead: false });
+        }).catch((err) => {
+          log.trace(
+            "chunkEmitter",
+            `error retries-left=${attemptsLeft}`,
+            err
+          );
+          if (attemptsLeft > 0) {
+            const delay = 200 * (maxRetries - attemptsLeft + 1);
+            setTimeout(() => attempt(attemptsLeft - 1), delay);
+          } else {
+            resolve2({ dead: false });
+          }
+        });
+      };
+      attempt(maxRetries);
+    });
+  }
+};
+var _transport2 = {
+  post: _post
+};
+function _post(url, headers, payload) {
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    const u2 = new URL(url);
+    const transport = u2.protocol === "https:" ? https3 : http3;
+    const req = transport.request(
+      {
+        hostname: u2.hostname,
+        port: u2.port || (u2.protocol === "https:" ? 443 : 80),
+        path: u2.pathname,
+        method: "POST",
+        headers: {
+          ...headers,
+          "Content-Length": Buffer.byteLength(payload)
+        },
+        timeout: 8e3
+      },
+      (res) => {
+        let resData = "";
+        res.on("data", (c2) => {
+          resData += c2.toString();
+        });
+        res.on("end", () => {
+          if (settled) return;
+          settled = true;
+          resolve2({ statusCode: res.statusCode ?? 0, body: resData });
+        });
+      }
+    );
+    req.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      reject(err);
+    });
+    req.on("timeout", () => {
+      req.destroy();
+    });
+    req.write(payload);
+    req.end();
+  });
+}
+
+// src/services/output/pty-buffer.ts
+var PtyBuffer = class {
+  raw = "";
+  active = false;
+  lastPushAt = 0;
+  terminalInputPending = false;
+  /** Whether to absorb pushes (`true`) or only watch for terminal input (`false`). */
+  get isActive() {
+    return this.active;
+  }
+  /** Bytes accumulated since the last reset. */
+  get content() {
+    return this.raw;
+  }
+  /** Wall-clock of the most recent printable push (`0` if none yet this turn). */
+  get lastPushTime() {
+    return this.lastPushAt;
+  }
+  /** Length of the accumulated buffer in raw bytes (debug + tests). */
+  get size() {
+    return this.raw.length;
+  }
+  activate() {
+    this.active = true;
+    this.raw = "";
+    this.lastPushAt = 0;
+    this.terminalInputPending = false;
+  }
+  deactivate() {
+    this.active = false;
+  }
+  reset() {
+    this.raw = "";
+    this.lastPushAt = 0;
+  }
+  /**
+   * Ingest a raw PTY frame. Returns whether the buffer was active
+   * at the time (caller cares because rendering only matters for
+   * active frames) and whether this push triggered the
+   * terminal-initiated-turn signal.
+   */
+  push(raw) {
+    if (!this.active) {
+      let terminalInputDetected = false;
+      if (!this.terminalInputPending && hasPrintable(raw)) {
+        this.terminalInputPending = true;
+        terminalInputDetected = true;
+      }
+      return { active: false, terminalInputDetected };
+    }
+    this.raw += raw;
+    if (hasPrintable(raw)) this.lastPushAt = Date.now();
+    return { active: true, terminalInputDetected: false };
+  }
+};
+function hasPrintable(raw) {
+  const stripped = raw.replace(/\x1B\[[^@-~]*[@-~]/g, "").replace(/[\x00-\x1F\x7F]/g, "");
+  return stripped.trim().length > 0;
+}
+
+// src/services/output/turn-renderer.ts
+function renderLines(buffer) {
+  return renderToLines(buffer);
+}
+function detectAnySelector(lines) {
+  return detectSelector(lines) ?? detectListSelector(lines);
+}
+function extractContent(lines) {
+  return filterChrome(lines).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+
 // src/services/output.service.ts
-var API_BASE4 = process.env.CODEAM_API_URL ?? "https://codeagent-mobile-api.vercel.app";
 var OutputService = class _OutputService {
-  constructor(sessionId, pluginId, onSessionIdDetected, onRateLimitDetected, onTurnComplete, onTerminalTurnDetected, pluginAuthToken) {
-    this.sessionId = sessionId;
-    this.pluginId = pluginId;
-    this.pluginAuthToken = pluginAuthToken;
-    this.onSessionIdDetected = onSessionIdDetected;
-    this.onRateLimitDetected = onRateLimitDetected;
-    this.onTurnComplete = onTurnComplete;
-    this.onTerminalTurnDetected = onTerminalTurnDetected;
-  }
-  sessionId;
-  pluginId;
-  pluginAuthToken;
-  rawBuffer = "";
+  pty = new PtyBuffer();
+  steps = new ChromeStepTracker();
+  emitter;
   lastSentContent = "";
-  lastSentChromeStepsJson = "";
-  chromeStepsHistory = [];
   pollTimer = null;
   startTime = 0;
-  active = false;
   terminalTurnPending = false;
-  lastPushTime = 0;
   onSessionIdDetected;
   onRateLimitDetected;
   onTurnComplete;
   onTerminalTurnDetected;
+  /** Tick cadence — every 1 s while a turn is active. */
   static POLL_MS = 1e3;
+  /** Idle threshold for "the agent's text settled, finalize the turn". */
   static IDLE_MS = 3e3;
-  /** Shorter idle threshold for selector detection (UI is ready immediately). */
+  /** Same threshold but tighter for selectors (UI is ready to interact immediately). */
   static SELECTOR_IDLE_MS = 1500;
   /**
-   * Grace period before the first tick processes output.
-   * Prevents the raw PTY input echo from being captured before Claude Code
-   * clears and re-renders its TUI (which happens within ~100-200 ms of
-   * receiving the input, but we give a 1.5 s margin for loaded machines).
+   * Grace period before tick processes anything — Claude needs ~100-
+   * 200 ms after `\r` to clear the input echo and re-render the TUI.
+   * 1.5 s is a comfortable margin on loaded machines.
    */
   static WARMUP_MS = 1500;
-  /** Max idle with no visible content (spinner only) before finalizing. */
+  /** Max idle with chrome-only output before we stop waiting on the agent. */
   static EMPTY_TIMEOUT_MS = 6e4;
+  /** Hard turn cap — pathological no-op turns get cut after 2 minutes. */
   static MAX_MS = 12e4;
+  constructor(sessionId, pluginId, onSessionIdDetected, onRateLimitDetected, onTurnComplete, onTerminalTurnDetected, pluginAuthToken) {
+    this.onSessionIdDetected = onSessionIdDetected;
+    this.onRateLimitDetected = onRateLimitDetected;
+    this.onTurnComplete = onTurnComplete;
+    this.onTerminalTurnDetected = onTerminalTurnDetected;
+    this.emitter = new ChunkEmitter({
+      sessionId,
+      pluginId,
+      pluginAuthToken
+    });
+  }
+  // ─── Turn lifecycle ──────────────────────────────────────────────
+  /**
+   * Begin a turn driven by a mobile-side prompt. Resets the buffer
+   * and emits the boundary chunks (clear → new_turn) that tell
+   * clients to wipe the prior agent reply and show "Agent is
+   * typing…".
+   */
+  newTurn() {
+    log.trace("outputSvc", "newTurn() \u2014 activating output stream");
+    this.beginTurn();
+    this.send({ type: "clear" }, { critical: true }).then(() => this.send({ type: "new_turn", done: false }, { critical: true })).catch(() => {
+    });
+  }
   /**
-   * Called by the terminal-turn callback once the user message is known.
-   * Sequences: clear → user_message (if any) → new_turn → start timer.
-   * This guarantees the user message appears before the typing placeholder
-   * in the apps, with no race against the clear event.
+   * Begin a turn driven by the user typing locally in their
+   * terminal. Same shape as `newTurn` but additionally sends a
+   * `user_message` so collaborators see the prompt attributed
+   * correctly. `userText` is the prompt text scraped from the
+   * Claude JSONL by `historySvc.waitForNewUserMessage`.
    */
   async startTerminalTurn(userText) {
     this.terminalTurnPending = false;
-    this.stopPoll();
-    this.rawBuffer = "";
-    this.lastSentContent = "";
-    this.lastSentChromeStepsJson = "";
-    this.chromeStepsHistory = [];
-    this.lastPushTime = 0;
-    this.active = true;
-    this.startTime = Date.now();
-    await this.postChunk({ clear: true });
+    this.beginTurn();
+    await this.send({ type: "clear" }, { critical: true });
     if (userText) {
-      await this.postChunk({ type: "user_message", content: userText, done: true });
+      await this.send({ type: "user_message", content: userText, done: true }, { critical: true });
     }
-    await this.postChunk({ type: "new_turn", content: "", done: false });
-    this.pollTimer = setInterval(() => this.tick(), _OutputService.POLL_MS);
-  }
-  newTurn() {
-    log.trace("outputSvc", "newTurn() \u2014 activating output stream");
-    this.stopPoll();
-    this.rawBuffer = "";
-    this.lastSentContent = "";
-    this.lastSentChromeStepsJson = "";
-    this.chromeStepsHistory = [];
-    this.lastPushTime = 0;
-    this.active = true;
-    this.terminalTurnPending = false;
-    this.startTime = Date.now();
-    this.postChunk({ clear: true }).then(() => this.postChunk({ type: "new_turn", content: "", done: false })).catch(() => {
-    });
-    this.pollTimer = setInterval(() => this.tick(), _OutputService.POLL_MS);
+    await this.send({ type: "new_turn", done: false }, { critical: true });
   }
   /**
-   * Like newTurn() but signals clients that a session is being resumed.
-   * The resumedSessionId tells clients to fetch the conversation from the API.
-   * Awaits the POST so callers can guarantee the signal is sent before restarting Claude.
+   * Begin a turn after a `resume_session` request. Includes the
+   * `resumedSessionId` so the client wipes its history and
+   * re-fetches from the JSONL via `get_conversation`.
    */
   async newTurnResume(resumedSessionId) {
-    this.stopPoll();
-    this.rawBuffer = "";
-    this.lastSentContent = "";
-    this.lastSentChromeStepsJson = "";
-    this.chromeStepsHistory = [];
-    this.lastPushTime = 0;
-    this.active = true;
-    this.startTime = Date.now();
-    await this.postChunk({ clear: true });
-    await this.postChunk({ type: "new_turn", resumedSessionId, content: "", done: false });
-    this.pollTimer = setInterval(() => this.tick(), _OutputService.POLL_MS);
+    this.beginTurn();
+    await this.send({ type: "clear" }, { critical: true });
+    await this.send(
+      { type: "new_turn", done: false, resumedSessionId },
+      { critical: true }
+    );
   }
+  // ─── Pump ────────────────────────────────────────────────────────
   push(raw) {
-    if (!this.active) {
-      if (!this.terminalTurnPending) {
-        const printable2 = raw.replace(/\x1B\[[^@-~]*[@-~]/g, "").replace(/[\x00-\x1F\x7F]/g, "");
-        if (printable2.trim()) {
-          this.terminalTurnPending = true;
-          log.trace("outputSvc", `terminal-turn detected (idle, ${raw.length}B)`);
-          this.onTerminalTurnDetected?.();
-        }
+    const result = this.pty.push(raw);
+    if (!result.active) {
+      if (result.terminalInputDetected && !this.terminalTurnPending) {
+        this.terminalTurnPending = true;
+        this.onTerminalTurnDetected?.();
       }
       log.trace("outputSvc", `push dropped (inactive, ${raw.length}B)`);
       return;
     }
-    this.rawBuffer += raw;
-    const printable = raw.replace(/\x1B\[[^@-~]*[@-~]/g, "").replace(/[\x00-\x1F\x7F]/g, "");
-    if (printable.trim()) {
-      this.lastPushTime = Date.now();
-      this.tryExtractSessionId(printable);
-      this.tryDetectRateLimit(printable);
-    }
     log.trace(
       "outputSvc",
-      `push +${raw.length}B (buf=${this.rawBuffer.length}B printable=${printable.trim().length})`
+      `push +${raw.length}B (buf=${this.pty.size}B)`
     );
+    this.tryExtractSessionId(raw);
+    this.tryDetectRateLimit(raw);
   }
-  /** Extract Claude conversation ID from output text (e.g., from /cost command or session resume) */
-  tryExtractSessionId(text) {
-    const patterns = [
-      /Resuming session[:\s]+([a-f0-9-]{36})/i,
-      /Session[:\s]+([a-f0-9-]{36})/i,
-      /Conversation[:\s]+([a-f0-9-]{36})/i,
-      /Session\s+ID[:\s]+([a-f0-9-]{36})/i
-    ];
-    for (const pattern of patterns) {
-      const match = text.match(pattern);
-      if (match && this.onSessionIdDetected) {
-        this.onSessionIdDetected(match[1]);
-        return;
-      }
-    }
+  dispose() {
+    this.stopPoll();
+    this.pty.deactivate();
   }
-  /** Detect rate limit messages from Claude Code output (e.g. "You've hit your limit · resets Apr 16 at 1pm") */
-  tryDetectRateLimit(text) {
-    const match = text.match(/hit your limit.*resets\s+(.+?)(?:\s*\(|$)/i) ?? text.match(/rate.?limit.*resets\s+(.+?)(?:\s*\(|$)/i);
-    if (match && this.onRateLimitDetected) {
-      this.onRateLimitDetected(match[1].trim());
+  // ─── Internals ───────────────────────────────────────────────────
+  beginTurn() {
+    this.stopPoll();
+    this.pty.activate();
+    this.steps.reset();
+    this.lastSentContent = "";
+    this.startTime = Date.now();
+    this.pollTimer = setInterval(() => this.tick(), _OutputService.POLL_MS);
+  }
+  async send(body, opts = {}) {
+    const outcome = await this.emitter.send(body, opts);
+    if (outcome.dead && this.pty.isActive) {
+      this.dispose();
     }
   }
-  dispose() {
-    this.stopPoll();
-    this.active = false;
+  stopPoll() {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
   }
   tick() {
-    if (!this.active) return;
+    if (!this.pty.isActive) return;
     const now = Date.now();
     const elapsed = now - this.startTime;
     if (elapsed >= _OutputService.MAX_MS) {
@@ -5178,36 +5403,51 @@ var OutputService = class _OutputService {
       return;
     }
     if (elapsed < _OutputService.WARMUP_MS) return;
-    const lines = renderToLines(this.rawBuffer);
-    this.postChromeSteps(lines);
-    const selector = detectSelector(lines) ?? detectListSelector(lines);
+    const lines = renderLines(this.pty.content);
+    this.steps.ingest(lines);
+    const stepsDelta = this.steps.consumeDelta();
+    if (stepsDelta.length > 0) {
+      this.send({ type: "chrome_steps", appendSteps: stepsDelta }).catch(() => {
+      });
+    }
+    const selector = detectAnySelector(lines);
     if (selector) {
-      const idleMs2 = this.lastPushTime > 0 ? now - this.lastPushTime : elapsed;
+      const idleMs2 = this.pty.lastPushTime > 0 ? now - this.pty.lastPushTime : elapsed;
       log.trace(
         "outputSvc",
         `tick selector found (idleMs=${idleMs2}, options=${selector.options.length})`
       );
       if (idleMs2 >= _OutputService.SELECTOR_IDLE_MS) {
         this.stopPoll();
-        this.active = false;
-        this.postChunk({ type: "select_prompt", content: selector.question, options: selector.options, optionDescriptions: selector.optionDescriptions, currentIndex: selector.currentIndex, done: true }).catch(() => {
+        this.pty.deactivate();
+        this.send(
+          {
+            type: "select_prompt",
+            content: selector.question,
+            options: selector.options,
+            optionDescriptions: selector.optionDescriptions,
+            currentIndex: selector.currentIndex,
+            done: true
+          },
+          { critical: true }
+        ).catch(() => {
         });
       }
       return;
     }
-    const content = filterChrome(lines).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+    const content = extractContent(lines);
     if (!content) {
       log.trace(
         "outputSvc",
-        `tick empty content (raw=${this.rawBuffer.length}B lines=${lines.length} elapsed=${elapsed}ms)`
+        `tick empty content (raw=${this.pty.size}B lines=${lines.length} elapsed=${elapsed}ms)`
       );
       if (elapsed >= _OutputService.EMPTY_TIMEOUT_MS) this.finalize();
       return;
     }
-    const idleMs = this.lastPushTime > 0 ? now - this.lastPushTime : elapsed;
+    const idleMs = this.pty.lastPushTime > 0 ? now - this.pty.lastPushTime : elapsed;
     log.trace(
       "outputSvc",
-      `tick content (raw=${this.rawBuffer.length}B lines=${lines.length} content=${content.length} idleMs=${idleMs})`
+      `tick content (raw=${this.pty.size}B lines=${lines.length} content=${content.length} idleMs=${idleMs})`
     );
     if (idleMs >= _OutputService.IDLE_MS) {
       this.finalize();
@@ -5215,161 +5455,78 @@ var OutputService = class _OutputService {
     }
     if (content !== this.lastSentContent) {
       this.lastSentContent = content;
-      this.postChunk({ type: "text", content, done: false }).catch(() => {
+      this.send({ type: "text", content, done: false }).catch(() => {
       });
     }
   }
   finalize() {
-    const lines = renderToLines(this.rawBuffer);
-    this.postChromeSteps(lines);
-    const selector = detectSelector(lines) ?? detectListSelector(lines);
+    const lines = renderLines(this.pty.content);
+    this.steps.ingest(lines);
+    const stepsDelta = this.steps.consumeDelta();
+    if (stepsDelta.length > 0) {
+      this.send({ type: "chrome_steps", appendSteps: stepsDelta }).catch(() => {
+      });
+    }
+    const selector = detectAnySelector(lines);
     this.stopPoll();
-    this.active = false;
+    this.pty.deactivate();
     if (selector) {
-      this.postChunk({ type: "select_prompt", content: selector.question, options: selector.options, optionDescriptions: selector.optionDescriptions, currentIndex: selector.currentIndex, done: true }).catch(() => {
+      this.send(
+        {
+          type: "select_prompt",
+          content: selector.question,
+          options: selector.options,
+          optionDescriptions: selector.optionDescriptions,
+          currentIndex: selector.currentIndex,
+          done: true
+        },
+        { critical: true }
+      ).catch(() => {
       });
     } else {
-      const content = filterChrome(lines).join("\n").replace(/\n{3,}/g, "\n\n").trim();
-      this.postChunk({ type: "text", content, done: true }).catch(() => {
+      const content = extractContent(lines);
+      this.send(
+        { type: "text", content, done: true },
+        { critical: true }
+      ).catch(() => {
       });
       this.onTurnComplete?.();
     }
   }
-  stopPoll() {
-    if (this.pollTimer) {
-      clearInterval(this.pollTimer);
-      this.pollTimer = null;
-    }
-  }
-  postChromeSteps(lines) {
-    const visible = lines.filter((l) => isChromeLine(l)).map((l) => parseChromeLine(l)).filter((s) => s !== null);
-    if (visible.length === 0) return;
-    let changed = false;
-    for (const step of visible) {
-      const exists = this.chromeStepsHistory.some(
-        (s) => s.tool === step.tool && s.label === step.label
-      );
-      if (!exists) {
-        this.chromeStepsHistory.push(step);
-        changed = true;
+  // ─── Side-channel observation (session id + rate limit) ──────────
+  tryExtractSessionId(text) {
+    if (!this.onSessionIdDetected) return;
+    const printable = text.replace(/\x1B\[[^@-~]*[@-~]/g, "").replace(/[\x00-\x1F\x7F]/g, "");
+    const patterns = [
+      /Resuming session[:\s]+([a-f0-9-]{36})/i,
+      /Session[:\s]+([a-f0-9-]{36})/i,
+      /Conversation[:\s]+([a-f0-9-]{36})/i,
+      /Session\s+ID[:\s]+([a-f0-9-]{36})/i
+    ];
+    for (const pattern of patterns) {
+      const match = printable.match(pattern);
+      if (match) {
+        this.onSessionIdDetected(match[1]);
+        return;
       }
     }
-    if (!changed) return;
-    const json = JSON.stringify(this.chromeStepsHistory);
-    if (json === this.lastSentChromeStepsJson) return;
-    this.lastSentChromeStepsJson = json;
-    this.postChunk({ type: "chrome_steps", content: "", steps: [...this.chromeStepsHistory] }).catch(() => {
-    });
   }
-  postChunk(body) {
-    const isCritical = body.clear === true || body.type === "new_turn" || body.type === "user_message" || body.done === true;
-    const maxRetries = isCritical ? 3 : 0;
-    const payload = JSON.stringify({
-      sessionId: this.sessionId,
-      pluginId: this.pluginId,
-      ...body
-    });
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (this.pluginAuthToken) {
-      headers["X-Plugin-Auth-Token"] = this.pluginAuthToken;
-    }
-    const chunkType = body.type ?? "(clear)";
-    log.trace(
-      "outputSvc",
-      `postChunk type=${chunkType} done=${body.done === true} bytes=${payload.length}`
-    );
-    if (chunkType === "select_prompt" || chunkType === "new_turn" || body.type === "text" && body.done === true) {
-      const preview = payload.length > 2048 ? payload.slice(0, 2048) + "\u2026(truncated)" : payload;
-      log.trace("outputSvc", `payload ${preview}`);
+  tryDetectRateLimit(text) {
+    if (!this.onRateLimitDetected) return;
+    const printable = text.replace(/\x1B\[[^@-~]*[@-~]/g, "").replace(/[\x00-\x1F\x7F]/g, "");
+    const match = printable.match(/hit your limit.*resets\s+(.+?)(?:\s*\(|$)/i) ?? printable.match(/rate.?limit.*resets\s+(.+?)(?:\s*\(|$)/i);
+    if (match) {
+      this.onRateLimitDetected(match[1].trim());
     }
-    return new Promise((resolve2) => {
-      const attempt = (attemptsLeft) => {
-        _transport2.sendOutputChunk(`${API_BASE4}/api/commands/output`, headers, payload).then(({ statusCode, body: resBody }) => {
-          log.trace("outputSvc", `postChunk status=${statusCode}`);
-          if (statusCode === 410 || statusCode === 404 && /SESSION_NOT_FOUND|SESSION_GONE/.test(resBody)) {
-            if (this.active) {
-              process.stderr.write("[codeam] session was deleted/disconnected \u2014 stopping output stream.\n");
-              this.dispose();
-            }
-            resolve2();
-            return;
-          }
-          if (statusCode >= 400) {
-            process.stderr.write(`[codeam] output API error ${statusCode}: ${resBody}
-`);
-          }
-          resolve2();
-        }).catch((err) => {
-          log.trace(
-            "outputSvc",
-            `postChunk error (retries left=${attemptsLeft})`,
-            err
-          );
-          if (attemptsLeft > 0) {
-            const delay = 200 * (maxRetries - attemptsLeft + 1);
-            setTimeout(() => attempt(attemptsLeft - 1), delay);
-          } else {
-            resolve2();
-          }
-        });
-      };
-      attempt(maxRetries);
-    });
   }
 };
-var _transport2 = {
-  sendOutputChunk: _sendOutputChunk
-};
-function _sendOutputChunk(url, headers, payload) {
-  return new Promise((resolve2, reject) => {
-    let settled = false;
-    const u2 = new URL(url);
-    const transport = u2.protocol === "https:" ? https2 : http2;
-    const req = transport.request(
-      {
-        hostname: u2.hostname,
-        port: u2.port || (u2.protocol === "https:" ? 443 : 80),
-        path: u2.pathname,
-        method: "POST",
-        headers: {
-          ...headers,
-          "Content-Length": Buffer.byteLength(payload)
-        },
-        timeout: 8e3
-      },
-      (res) => {
-        let resData = "";
-        res.on("data", (c2) => {
-          resData += c2.toString();
-        });
-        res.on("end", () => {
-          if (settled) return;
-          settled = true;
-          resolve2({ statusCode: res.statusCode ?? 0, body: resData });
-        });
-      }
-    );
-    req.on("error", (err) => {
-      if (settled) return;
-      settled = true;
-      reject(err);
-    });
-    req.on("timeout", () => {
-      req.destroy();
-    });
-    req.write(payload);
-    req.end();
-  });
-}
 
 // src/services/history.service.ts
 var fs5 = __toESM(require("fs"));
 var path8 = __toESM(require("path"));
 var os6 = __toESM(require("os"));
-var https3 = __toESM(require("https"));
-var http3 = __toESM(require("http"));
+var https4 = __toESM(require("https"));
+var http4 = __toESM(require("http"));
 var import_zod = require("zod");
 var historyRecordSchema = import_zod.z.object({
   type: import_zod.z.string().optional(),
@@ -5381,7 +5538,7 @@ var historyRecordSchema = import_zod.z.object({
     content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(import_zod.z.unknown())]).optional()
   }).passthrough().optional()
 }).passthrough();
-var API_BASE5 = process.env.CODEAM_API_URL ?? "https://codeagent-mobile-api.vercel.app";
+var API_BASE4 = process.env.CODEAM_API_URL ?? "https://codeagent-mobile-api.vercel.app";
 function encodeCwd(cwd) {
   return cwd.replace(/[\\/:]/g, "-");
 }
@@ -5454,8 +5611,8 @@ function parseJsonl(filePath) {
 function post(endpoint, body) {
   return new Promise((resolve2) => {
     const payload = JSON.stringify(body);
-    const u2 = new URL(`${API_BASE5}${endpoint}`);
-    const transport = u2.protocol === "https:" ? https3 : http3;
+    const u2 = new URL(`${API_BASE4}${endpoint}`);
+    const transport = u2.protocol === "https:" ? https4 : http4;
     const req = transport.request(
       {
         hostname: u2.hostname,
@@ -5834,6 +5991,161 @@ var HistoryService = class {
   }
 };
 
+// src/commands/start/quota-fetcher.ts
+var fs6 = __toESM(require("fs"));
+var os7 = __toESM(require("os"));
+var path9 = __toESM(require("path"));
+var import_child_process4 = require("child_process");
+var inProgress = false;
+var HELPER_SCRIPT = `import os,pty,sys,select,signal,struct,fcntl,termios,errno
+m,s=pty.openpty()
+try:
+    fcntl.ioctl(s,termios.TIOCSWINSZ,struct.pack('HHHH',30,120,0,0))
+except Exception:pass
+pid=os.fork()
+if pid==0:
+    os.close(m);os.setsid()
+    try:fcntl.ioctl(s,termios.TIOCSCTTY,0)
+    except Exception:pass
+    for fd in[0,1,2]:os.dup2(s,fd)
+    if s>2:os.close(s)
+    os.execvp(sys.argv[1],sys.argv[1:])
+    sys.exit(127)
+os.close(s)
+done=[False]
+def onchld(n,f):
+    try:os.waitpid(pid,os.WNOHANG)
+    except Exception:pass
+    done[0]=True
+signal.signal(signal.SIGCHLD,onchld)
+i=sys.stdin.fileno();o=sys.stdout.fileno()
+while not done[0]:
+    try:r,_,_=select.select([i,m],[],[],0.1)
+    except OSError as e:
+        if e.errno==errno.EINTR:continue
+        break
+    if i in r:
+        try:
+            d=os.read(i,4096)
+            if d:os.write(m,d)
+            else:break
+        except OSError:break
+    if m in r:
+        try:
+            d=os.read(m,4096)
+            if d:os.write(o,d)
+        except OSError:done[0]=True
+try:os.kill(pid,signal.SIGTERM)
+except Exception:pass
+try:
+    _,st=os.waitpid(pid,0)
+    sys.exit((st>>8)&0xFF)
+except Exception:sys.exit(0)
+`;
+function fetchQuotaUsage(historySvc) {
+  if (inProgress) return;
+  inProgress = true;
+  const claudeCmd = findInPath("claude") ? "claude" : "claude-code";
+  if (!claudeCmd) {
+    inProgress = false;
+    return;
+  }
+  const helperPath = path9.join(os7.tmpdir(), "codeam-quota-helper.py");
+  fs6.writeFileSync(helperPath, HELPER_SCRIPT, { mode: 420 });
+  const python = findInPath("python3") ?? findInPath("python");
+  if (!python) {
+    inProgress = false;
+    return;
+  }
+  const proc = (0, import_child_process4.spawn)(python, [helperPath, claudeCmd, "--tools", ""], {
+    stdio: ["pipe", "pipe", "ignore"],
+    cwd: process.cwd(),
+    env: { ...process.env, TERM: "dumb", COLUMNS: "120", LINES: "30" }
+  });
+  let output = "";
+  proc.stdout?.on("data", (chunk) => {
+    output += chunk.toString("utf8");
+  });
+  setTimeout(() => {
+    proc.stdin?.write("/usage\r");
+    setTimeout(() => {
+      const clean = output.replace(/\x1B\[[^@-~]*[@-~]/g, "").replace(/[\x00-\x1F\x7F]/g, " ").replace(/\s+/g, " ");
+      const weekMatch = clean.match(/(\d+)%\s*used/i) || clean.match(/(\d+)\s*%/);
+      if (weekMatch) historySvc.setQuotaPercent(parseInt(weekMatch[1], 10));
+      const resetMatch = clean.match(/resets\s+(.+?)(?:\s*\(|$)/im);
+      if (resetMatch) historySvc.setRateLimitReset(resetMatch[1].trim());
+      try {
+        proc.kill();
+      } catch {
+      }
+      try {
+        fs6.unlinkSync(helperPath);
+      } catch {
+      }
+      inProgress = false;
+    }, 5e3);
+  }, 8e3);
+  proc.on("exit", () => {
+    inProgress = false;
+  });
+  setTimeout(() => {
+    try {
+      proc.kill();
+    } catch {
+    }
+  }, 2e4);
+}
+
+// src/commands/start/keep-alive.ts
+var import_child_process5 = require("child_process");
+function buildKeepAlive(ctx) {
+  let timer = null;
+  async function setIdleTimeout(minutes) {
+    if (!ctx.inCodespace || !ctx.codespaceName) return;
+    await new Promise((resolve2) => {
+      const proc = (0, import_child_process5.spawn)(
+        "gh",
+        [
+          "api",
+          "-X",
+          "PATCH",
+          `/user/codespaces/${ctx.codespaceName}`,
+          "-F",
+          `idle_timeout_minutes=${minutes}`
+        ],
+        { stdio: "ignore", detached: true }
+      );
+      proc.unref();
+      proc.on("exit", () => resolve2());
+      proc.on("error", () => resolve2());
+    });
+  }
+  return {
+    apply(enabled) {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+      if (!ctx.inCodespace || !ctx.codespaceName) return;
+      if (!enabled) {
+        void setIdleTimeout(30);
+        return;
+      }
+      void setIdleTimeout(240);
+      timer = setInterval(() => {
+        void setIdleTimeout(240);
+      }, 30 * 60 * 1e3);
+    }
+  };
+}
+
+// src/commands/start/handlers.ts
+var fs9 = __toESM(require("fs"));
+var os8 = __toESM(require("os"));
+var path12 = __toESM(require("path"));
+var import_crypto = require("crypto");
+var import_child_process7 = require("child_process");
+
 // src/lib/payload.ts
 var import_zod2 = require("zod");
 var fileEntrySchema = import_zod2.z.object({
@@ -5869,8 +6181,8 @@ function parsePayload(schema, raw) {
 }
 
 // src/services/file-ops.service.ts
-var fs6 = __toESM(require("fs/promises"));
-var path9 = __toESM(require("path"));
+var fs7 = __toESM(require("fs/promises"));
+var path10 = __toESM(require("path"));
 var MAX_FILE_BYTES = 5 * 1024 * 1024;
 var MAX_WALK_DEPTH = 6;
 var MAX_VISITED_DIRS = 5e3;
@@ -5905,12 +6217,12 @@ var SUBDIR_IGNORE = /* @__PURE__ */ new Set([
   "__pycache__"
 ]);
 function isUnder(parent, candidate) {
-  const rel = path9.relative(parent, candidate);
-  return rel === "" || !rel.startsWith("..") && !path9.isAbsolute(rel);
+  const rel = path10.relative(parent, candidate);
+  return rel === "" || !rel.startsWith("..") && !path10.isAbsolute(rel);
 }
 async function isExistingFile(absPath) {
   try {
-    const stat3 = await fs6.stat(absPath);
+    const stat3 = await fs7.stat(absPath);
     return stat3.isFile();
   } catch {
     return false;
@@ -5923,13 +6235,13 @@ async function walkForSuffix(dir, needleVariants, depth, ctx) {
   ctx.visited++;
   let entries = [];
   try {
-    entries = await fs6.readdir(dir, { withFileTypes: true });
+    entries = await fs7.readdir(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const e of entries) {
     if (!e.isFile()) continue;
-    const full = path9.join(dir, e.name);
+    const full = path10.join(dir, e.name);
     if (needleVariants.some((needle) => full.endsWith(needle))) {
       ctx.matches.push(full);
       if (ctx.matches.length >= ctx.cap) return;
@@ -5939,21 +6251,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(path9.join(dir, e.name), needleVariants, depth + 1, ctx);
+    await walkForSuffix(path10.join(dir, e.name), needleVariants, depth + 1, ctx);
     if (ctx.matches.length >= ctx.cap) return;
   }
 }
 async function findFile(rawPath) {
   const cwd = process.cwd();
-  if (path9.isAbsolute(rawPath)) {
-    const abs = path9.normalize(rawPath);
+  if (path10.isAbsolute(rawPath)) {
+    const abs = path10.normalize(rawPath);
     if (isUnder(cwd, abs) && await isExistingFile(abs)) return abs;
   }
-  const direct = path9.resolve(cwd, rawPath);
+  const direct = path10.resolve(cwd, rawPath);
   if (isUnder(cwd, direct) && await isExistingFile(direct)) return direct;
-  const normalized = path9.normalize(rawPath).replace(/^[./\\]+/, "");
+  const normalized = path10.normalize(rawPath).replace(/^[./\\]+/, "");
   const needles = [
-    `${path9.sep}${normalized}`,
+    `${path10.sep}${normalized}`,
     `/${normalized}`
   ].filter((v, i, a) => a.indexOf(v) === i);
   const ctx = { visited: 0, matches: [], cap: 16 };
@@ -5967,7 +6279,7 @@ async function findWriteTarget(rawPath) {
   const found = await findFile(rawPath);
   if (found) return found;
   const cwd = process.cwd();
-  const fallback = path9.isAbsolute(rawPath) ? path9.normalize(rawPath) : path9.resolve(cwd, rawPath);
+  const fallback = path10.isAbsolute(rawPath) ? path10.normalize(rawPath) : path10.resolve(cwd, rawPath);
   if (!isUnder(cwd, fallback)) return null;
   return fallback;
 }
@@ -5984,11 +6296,11 @@ async function readProjectFile(rawPath) {
     if (!abs) {
       return { error: `File not found in the project tree: ${rawPath}` };
     }
-    const stat3 = await fs6.stat(abs);
+    const stat3 = await fs7.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 fs6.readFile(abs);
+    const buf = await fs7.readFile(abs);
     if (looksBinary(buf)) {
       return { error: "Binary file \u2014 refusing to open in a code editor." };
     }
@@ -6007,8 +6319,8 @@ async function writeProjectFile(rawPath, content) {
     if (Buffer.byteLength(content, "utf-8") > MAX_FILE_BYTES) {
       return { error: "Content too large." };
     }
-    await fs6.mkdir(path9.dirname(abs), { recursive: true });
-    await fs6.writeFile(abs, content, "utf-8");
+    await fs7.mkdir(path10.dirname(abs), { recursive: true });
+    await fs7.writeFile(abs, content, "utf-8");
     return { ok: true };
   } catch (e) {
     const msg = e instanceof Error ? e.message : "Write failed";
@@ -6017,11 +6329,11 @@ async function writeProjectFile(rawPath, content) {
 }
 
 // src/services/project-ops.service.ts
-var import_child_process4 = require("child_process");
+var import_child_process6 = require("child_process");
 var import_util = require("util");
-var fs7 = __toESM(require("fs/promises"));
-var path10 = __toESM(require("path"));
-var execFileP = (0, import_util.promisify)(import_child_process4.execFile);
+var fs8 = __toESM(require("fs/promises"));
+var path11 = __toESM(require("path"));
+var execFileP = (0, import_util.promisify)(import_child_process6.execFile);
 var PROJECT_IGNORE = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -6068,7 +6380,7 @@ async function listProjectFiles(opts = {}) {
     }
     let entries = [];
     try {
-      entries = await fs7.readdir(dir, { withFileTypes: true });
+      entries = await fs8.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -6078,18 +6390,18 @@ async function listProjectFiles(opts = {}) {
         return;
       }
       if (PROJECT_IGNORE.has(e.name)) continue;
-      const full = path10.join(dir, e.name);
+      const full = path11.join(dir, e.name);
       if (e.isDirectory()) {
         if (depth >= 12) continue;
         await walk(full, depth + 1);
       } else if (e.isFile()) {
-        const rel = path10.relative(root, full);
+        const rel = path11.relative(root, full);
         if (q2 && !rel.toLowerCase().includes(q2) && !e.name.toLowerCase().includes(q2)) {
           continue;
         }
         let size = 0;
         try {
-          const st3 = await fs7.stat(full);
+          const st3 = await fs8.stat(full);
           size = st3.size;
         } catch {
         }
@@ -6191,8 +6503,8 @@ async function gitStatus(cwd) {
   let hasMergeInProgress = false;
   try {
     const gitDir = (await git(["rev-parse", "--git-dir"], root)).stdout.trim();
-    const mergeHead = path10.isAbsolute(gitDir) ? path10.join(gitDir, "MERGE_HEAD") : path10.join(root, gitDir, "MERGE_HEAD");
-    await fs7.access(mergeHead);
+    const mergeHead = path11.isAbsolute(gitDir) ? path11.join(gitDir, "MERGE_HEAD") : path11.join(root, gitDir, "MERGE_HEAD");
+    await fs8.access(mergeHead);
     hasMergeInProgress = true;
   } catch {
   }
@@ -6265,15 +6577,261 @@ async function gitResolve(file, side, cwd) {
   return { ok: true };
 }
 
-// src/commands/start.ts
+// src/commands/start/handlers.ts
 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 = path11.join(os7.tmpdir(), `codeam-${(0, import_crypto.randomUUID)()}-${safeName}`);
-    fs8.writeFileSync(tmpPath, Buffer.from(base64, "base64"));
+    const tmpPath = path12.join(os8.tmpdir(), `codeam-${(0, import_crypto.randomUUID)()}-${safeName}`);
+    fs9.writeFileSync(tmpPath, Buffer.from(base64, "base64"));
     return tmpPath;
   });
 }
+function dispatchPrompt(ctx, prompt) {
+  ctx.outputSvc.newTurn();
+  ctx.claude.sendCommand(prompt);
+}
+var startTask = (ctx, _cmd, parsed) => {
+  const { prompt, files } = parsed;
+  const effectivePrompt = prompt ?? "";
+  if (files && files.length > 0) {
+    const paths = saveFilesTemp(files);
+    const atRefs = paths.map((p2) => `@${p2}`).join(" ");
+    ctx.outputSvc.newTurn();
+    ctx.claude.sendCommand(`${atRefs} ${effectivePrompt}`.trim());
+    setTimeout(() => {
+      for (const p2 of paths) {
+        try {
+          fs9.unlinkSync(p2);
+        } catch {
+        }
+      }
+    }, 12e4);
+  } else if (effectivePrompt) {
+    dispatchPrompt(ctx, effectivePrompt);
+  }
+};
+var provideInput = (ctx, _cmd, parsed) => {
+  if (parsed.input) dispatchPrompt(ctx, parsed.input);
+};
+var selectOption = (ctx, _cmd, parsed) => {
+  const index = parsed.index ?? 0;
+  const from = parsed.from ?? 0;
+  ctx.outputSvc.newTurn();
+  ctx.claude.selectOption(index, from);
+};
+var escapeKey = (ctx) => {
+  ctx.outputSvc.newTurn();
+  ctx.claude.sendEscape();
+};
+var stopTask = (ctx) => {
+  ctx.claude.interrupt();
+};
+var resumeSession = async (ctx, _cmd, parsed) => {
+  const { id, auto } = parsed;
+  if (!id) return;
+  ctx.historySvc.setCurrentConversationId(id);
+  await ctx.historySvc.loadConversation(id);
+  await ctx.outputSvc.newTurnResume(id);
+  ctx.claude.restart(id, auto ?? false);
+};
+var getContext = async (ctx, cmd) => {
+  const usage = ctx.historySvc.getCurrentUsage();
+  const monthlyCost = ctx.historySvc.getMonthlyEstimatedCost();
+  const rateLimitReset = ctx.historySvc.getRateLimitReset();
+  const quotaPercent = ctx.historySvc.getQuotaPercent();
+  const base = usage ? { ...usage, monthlyCost } : { used: 0, total: 2e5, percent: 0, model: null, outputTokens: 0, cacheReadTokens: 0, monthlyCost, error: "No usage data found" };
+  const result = {
+    ...base,
+    ...rateLimitReset ? { rateLimitReset } : {},
+    ...quotaPercent !== null ? { quotaPercent } : {}
+  };
+  await ctx.relay.sendResult(cmd.id, "completed", result);
+};
+var getConversation = async (ctx, cmd) => {
+  const currentId = ctx.historySvc.getCurrentConversationId();
+  if (!currentId) {
+    await ctx.relay.sendResult(cmd.id, "completed", { conversationId: null });
+    return;
+  }
+  try {
+    await ctx.historySvc.loadConversation(currentId);
+    await ctx.relay.sendResult(cmd.id, "completed", { conversationId: currentId });
+  } catch {
+    await ctx.relay.sendResult(cmd.id, "failed", {});
+  }
+};
+var listModels = async (ctx, cmd) => {
+  const models = [
+    { id: "claude-opus-4-7", label: "Claude Opus 4.7", description: "Most capable", family: "claude", vendor: "anthropic", isDefault: false },
+    { id: "claude-opus-4-6", label: "Claude Opus 4.6", description: "Top tier", family: "claude", vendor: "anthropic", isDefault: false },
+    { id: "claude-sonnet-4-6", label: "Claude Sonnet 4.6", description: "Balanced", family: "claude", vendor: "anthropic", isDefault: true },
+    { id: "claude-haiku-4-5-20251001", label: "Claude Haiku 4.5", description: "Fastest", family: "claude", vendor: "anthropic", isDefault: false }
+  ];
+  await ctx.relay.sendResult(cmd.id, "completed", { models });
+};
+var setKeepAlive = async (ctx, cmd) => {
+  const enabled = !!cmd.payload.enabled;
+  ctx.setKeepAlive(enabled);
+  try {
+    await ctx.relay.sendResult(
+      cmd.id,
+      "success",
+      {
+        enabled,
+        applied: enabled && ctx.keepAliveCtx.inCodespace,
+        runtime: ctx.keepAliveCtx.inCodespace ? "github-codespaces" : "local"
+      }
+    );
+  } catch {
+  }
+};
+var sessionTerminated = (ctx) => {
+  showInfo("Session was deleted from the app \u2014 exiting.");
+  try {
+    ctx.claude.kill();
+  } catch {
+  }
+  try {
+    const proc = (0, import_child_process7.spawn)("bash", ["-lc", "pm2 delete codeam-pair >/dev/null 2>&1 || true"], {
+      detached: true,
+      stdio: "ignore"
+    });
+    proc.unref();
+  } catch {
+  }
+  ctx.outputSvc.dispose();
+  ctx.relay.stop();
+  process.exit(0);
+};
+var shutdownSession = async (ctx, cmd) => {
+  try {
+    await ctx.relay.sendResult(cmd.id, "success", { ok: true });
+  } catch {
+  }
+  try {
+    ctx.claude.kill();
+  } catch {
+  }
+  if (ctx.keepAliveCtx.inCodespace && ctx.keepAliveCtx.codespaceName) {
+    try {
+      const stopProc = (0, import_child_process7.spawn)(
+        "bash",
+        ["-lc", `sleep 1; gh codespace stop -c ${JSON.stringify(ctx.keepAliveCtx.codespaceName)} >/dev/null 2>&1 || true`],
+        { detached: true, stdio: "ignore" }
+      );
+      stopProc.unref();
+    } catch {
+    }
+  }
+  try {
+    const proc = (0, import_child_process7.spawn)("bash", ["-lc", "pm2 delete codeam-pair >/dev/null 2>&1 || true"], {
+      detached: true,
+      stdio: "ignore"
+    });
+    proc.unref();
+  } catch {
+  }
+  ctx.outputSvc.dispose();
+  ctx.relay.stop();
+  process.exit(0);
+};
+var readFile2 = async (ctx, cmd, parsed) => {
+  if (!parsed.path) {
+    await ctx.relay.sendResult(cmd.id, "failed", { error: "Missing path" });
+    return;
+  }
+  const result = await readProjectFile(parsed.path);
+  await ctx.relay.sendResult(cmd.id, "completed", result);
+};
+var writeFile2 = async (ctx, cmd, parsed) => {
+  if (!parsed.path || typeof parsed.content !== "string") {
+    await ctx.relay.sendResult(cmd.id, "failed", { error: "Missing path or content" });
+    return;
+  }
+  const result = await writeProjectFile(parsed.path, parsed.content);
+  await ctx.relay.sendResult(cmd.id, "completed", result);
+};
+var listFiles = async (ctx, cmd, parsed) => {
+  const result = await listProjectFiles({ query: parsed.query });
+  await ctx.relay.sendResult(cmd.id, "completed", result);
+};
+var gitStatusH = async (ctx, cmd) => {
+  const result = await gitStatus();
+  await ctx.relay.sendResult(cmd.id, "completed", result);
+};
+var gitDiffH = async (ctx, cmd, parsed) => {
+  const result = await gitDiff(parsed.path ?? null);
+  await ctx.relay.sendResult(cmd.id, "completed", result);
+};
+var gitDiffStagedH = async (ctx, cmd, parsed) => {
+  const result = await gitDiffStaged(parsed.path ?? null);
+  await ctx.relay.sendResult(cmd.id, "completed", result);
+};
+var gitLogH = async (ctx, cmd, parsed) => {
+  const result = await gitLog(parsed.limit ?? 30);
+  await ctx.relay.sendResult(cmd.id, "completed", result);
+};
+var gitCommitH = async (ctx, cmd, parsed) => {
+  if (!parsed.message) {
+    await ctx.relay.sendResult(cmd.id, "failed", { error: "Missing message" });
+    return;
+  }
+  const result = await gitCommit(parsed.message, parsed.paths);
+  await ctx.relay.sendResult(cmd.id, "completed", result);
+};
+var gitPushH = async (ctx, cmd) => {
+  const result = await gitPush();
+  await ctx.relay.sendResult(cmd.id, "completed", result);
+};
+var gitPullH = async (ctx, cmd) => {
+  const result = await gitPull();
+  await ctx.relay.sendResult(cmd.id, "completed", result);
+};
+var gitResolveH = async (ctx, cmd, parsed) => {
+  if (!parsed.path || !parsed.side) {
+    await ctx.relay.sendResult(cmd.id, "failed", { error: "Missing path or side" });
+    return;
+  }
+  const result = await gitResolve(parsed.path, parsed.side);
+  await ctx.relay.sendResult(cmd.id, "completed", result);
+};
+var handlers = {
+  start_task: startTask,
+  provide_input: provideInput,
+  select_option: selectOption,
+  escape_key: escapeKey,
+  stop_task: stopTask,
+  resume_session: resumeSession,
+  get_context: getContext,
+  get_conversation: getConversation,
+  list_models: listModels,
+  set_keep_alive: setKeepAlive,
+  session_terminated: sessionTerminated,
+  shutdown_session: shutdownSession,
+  read_file: readFile2,
+  write_file: writeFile2,
+  list_files: listFiles,
+  git_status: gitStatusH,
+  git_diff: gitDiffH,
+  git_diff_staged: gitDiffStagedH,
+  git_log: gitLogH,
+  git_commit: gitCommitH,
+  git_push: gitPushH,
+  git_pull: gitPullH,
+  git_resolve: gitResolveH
+};
+async function dispatchCommand(ctx, cmd) {
+  const parsed = parsePayload(startCommandSchema, cmd.payload);
+  if (!parsed) {
+    showInfo(`Ignoring malformed ${cmd.type} payload.`);
+    return;
+  }
+  const handler = handlers[cmd.type];
+  if (!handler) return;
+  await handler(ctx, cmd, parsed);
+}
+
+// src/commands/start.ts
 async function start() {
   showIntro();
   const session = getActiveSession();
@@ -6287,434 +6845,32 @@ async function start() {
   showInfo(`${session.userName}  \xB7  ${import_picocolors2.default.cyan(session.plan)}`);
   showInfo("Launching Claude Code...\n");
   const cwd = process.cwd();
-  const ws = new WebSocketService(session.id, pluginId);
   const historySvc = new HistoryService(pluginId, cwd);
-  let quotaFetchInProgress = false;
-  function fetchQuotaUsage() {
-    if (quotaFetchInProgress) return;
-    quotaFetchInProgress = true;
-    const claudeCmd = findInPath("claude") ? "claude" : "claude-code";
-    if (!claudeCmd) {
-      quotaFetchInProgress = false;
-      return;
-    }
-    const helperScript = `import os,pty,sys,select,signal,struct,fcntl,termios,errno
-m,s=pty.openpty()
-try:
-    fcntl.ioctl(s,termios.TIOCSWINSZ,struct.pack('HHHH',30,120,0,0))
-except Exception:pass
-pid=os.fork()
-if pid==0:
-    os.close(m);os.setsid()
-    try:fcntl.ioctl(s,termios.TIOCSCTTY,0)
-    except Exception:pass
-    for fd in[0,1,2]:os.dup2(s,fd)
-    if s>2:os.close(s)
-    os.execvp(sys.argv[1],sys.argv[1:])
-    sys.exit(127)
-os.close(s)
-done=[False]
-def onchld(n,f):
-    try:os.waitpid(pid,os.WNOHANG)
-    except Exception:pass
-    done[0]=True
-signal.signal(signal.SIGCHLD,onchld)
-i=sys.stdin.fileno();o=sys.stdout.fileno()
-while not done[0]:
-    try:r,_,_=select.select([i,m],[],[],0.1)
-    except OSError as e:
-        if e.errno==errno.EINTR:continue
-        break
-    if i in r:
-        try:
-            d=os.read(i,4096)
-            if d:os.write(m,d)
-            else:break
-        except OSError:break
-    if m in r:
-        try:
-            d=os.read(m,4096)
-            if d:os.write(o,d)
-        except OSError:done[0]=True
-try:os.kill(pid,signal.SIGTERM)
-except Exception:pass
-try:
-    _,st=os.waitpid(pid,0)
-    sys.exit((st>>8)&0xFF)
-except Exception:sys.exit(0)
-`;
-    const helperPath = path11.join(os7.tmpdir(), "codeam-quota-helper.py");
-    fs8.writeFileSync(helperPath, helperScript, { mode: 420 });
-    const python = findInPath("python3") ?? findInPath("python");
-    if (!python) {
-      quotaFetchInProgress = false;
-      return;
-    }
-    const proc = (0, import_child_process5.spawn)(python, [helperPath, claudeCmd, "--tools", ""], {
-      stdio: ["pipe", "pipe", "ignore"],
-      cwd: process.cwd(),
-      env: { ...process.env, TERM: "dumb", COLUMNS: "120", LINES: "30" }
-    });
-    let output = "";
-    proc.stdout?.on("data", (chunk) => {
-      output += chunk.toString("utf8");
-    });
-    setTimeout(() => {
-      proc.stdin?.write("/usage\r");
+  const keepAliveCtx = {
+    inCodespace: process.env.CODESPACES === "true",
+    codespaceName: process.env.CODESPACE_NAME
+  };
+  const { apply: setKeepAlive2 } = buildKeepAlive(keepAliveCtx);
+  const outputSvc = new OutputService(
+    session.id,
+    pluginId,
+    (conversationId) => historySvc.setCurrentConversationId(conversationId),
+    (reset) => historySvc.setRateLimitReset(reset),
+    () => {
+      if (historySvc.isQuotaStale()) fetchQuotaUsage(historySvc);
       setTimeout(() => {
-        const clean = output.replace(/\x1B\[[^@-~]*[@-~]/g, "").replace(/[\x00-\x1F\x7F]/g, " ").replace(/\s+/g, " ");
-        const weekMatch = clean.match(/(\d+)%\s*used/i) || clean.match(/(\d+)\s*%/);
-        if (weekMatch) {
-          historySvc.setQuotaPercent(parseInt(weekMatch[1], 10));
-        }
-        const resetMatch = clean.match(/resets\s+(.+?)(?:\s*\(|$)/im);
-        if (resetMatch) {
-          historySvc.setRateLimitReset(resetMatch[1].trim());
-        }
-        try {
-          proc.kill();
-        } catch {
-        }
-        try {
-          fs8.unlinkSync(helperPath);
-        } catch {
-        }
-        quotaFetchInProgress = false;
-      }, 5e3);
-    }, 8e3);
-    proc.on("exit", () => {
-      quotaFetchInProgress = false;
-    });
-    setTimeout(() => {
-      try {
-        proc.kill();
-      } catch {
-      }
-    }, 2e4);
-  }
-  const outputSvc = new OutputService(session.id, pluginId, (conversationId) => {
-    historySvc.setCurrentConversationId(conversationId);
-  }, (reset) => {
-    historySvc.setRateLimitReset(reset);
-  }, () => {
-    if (historySvc.isQuotaStale()) {
-      fetchQuotaUsage();
-    }
-    setTimeout(() => {
-      historySvc.uploadDelta().catch(() => {
-      });
-    }, 400);
-  }, () => {
-    const prevCount = historySvc.getCurrentMessageCount();
-    historySvc.waitForNewUserMessage(prevCount).then((userText) => outputSvc.startTerminalTurn(userText ?? void 0)).catch(() => outputSvc.startTerminalTurn(void 0));
-  }, session.pluginAuthToken);
-  function sendPrompt(prompt) {
-    outputSvc.newTurn();
-    claude.sendCommand(prompt);
-  }
-  const relay = new CommandRelayService(pluginId, async (cmd) => {
-    const parsed = parsePayload(startCommandSchema, cmd.payload);
-    if (!parsed) {
-      showInfo(`Ignoring malformed ${cmd.type} payload.`);
-      return;
-    }
-    switch (cmd.type) {
-      case "start_task": {
-        const { prompt, files } = parsed;
-        const effectivePrompt = prompt ?? "";
-        if (files && files.length > 0) {
-          const paths = saveFilesTemp(files);
-          const atRefs = paths.map((p2) => `@${p2}`).join(" ");
-          outputSvc.newTurn();
-          claude.sendCommand(`${atRefs} ${effectivePrompt}`.trim());
-          setTimeout(() => {
-            for (const p2 of paths) {
-              try {
-                fs8.unlinkSync(p2);
-              } catch {
-              }
-            }
-          }, 12e4);
-        } else if (effectivePrompt) {
-          sendPrompt(effectivePrompt);
-        }
-        break;
-      }
-      case "provide_input": {
-        const { input } = parsed;
-        if (input) sendPrompt(input);
-        break;
-      }
-      case "select_option": {
-        const index = parsed.index ?? 0;
-        const from = parsed.from ?? 0;
-        outputSvc.newTurn();
-        claude.selectOption(index, from);
-        break;
-      }
-      case "escape_key":
-        outputSvc.newTurn();
-        claude.sendEscape();
-        break;
-      case "stop_task":
-        claude.interrupt();
-        break;
-      case "set_keep_alive": {
-        const enabled = !!cmd.payload.enabled;
-        const inCodespaceEnv = process.env.CODESPACES === "true";
-        setKeepAlive(enabled);
-        try {
-          await relay.sendResult(
-            cmd.id,
-            "success",
-            { enabled, applied: enabled && inCodespaceEnv, runtime: inCodespaceEnv ? "github-codespaces" : "local" }
-          );
-        } catch {
-        }
-        break;
-      }
-      case "session_terminated": {
-        showInfo("Session was deleted from the app \u2014 exiting.");
-        try {
-          claude.kill();
-        } catch {
-        }
-        try {
-          const proc = (0, import_child_process5.spawn)("bash", ["-lc", "pm2 delete codeam-pair >/dev/null 2>&1 || true"], {
-            detached: true,
-            stdio: "ignore"
-          });
-          proc.unref();
-        } catch {
-        }
-        outputSvc.dispose();
-        relay.stop();
-        ws.disconnect();
-        process.exit(0);
-      }
-      case "shutdown_session": {
-        try {
-          await relay.sendResult(cmd.id, "success", { ok: true });
-        } catch {
-        }
-        try {
-          claude.kill();
-        } catch {
-        }
-        const codespaceName2 = process.env.CODESPACE_NAME;
-        if (codespaceName2 && process.env.CODESPACES === "true") {
-          try {
-            const stopProc = (0, import_child_process5.spawn)(
-              "bash",
-              ["-lc", `sleep 1; gh codespace stop -c ${JSON.stringify(codespaceName2)} >/dev/null 2>&1 || true`],
-              { detached: true, stdio: "ignore" }
-            );
-            stopProc.unref();
-          } catch {
-          }
-        }
-        try {
-          const proc = (0, import_child_process5.spawn)("bash", ["-lc", "pm2 delete codeam-pair >/dev/null 2>&1 || true"], {
-            detached: true,
-            stdio: "ignore"
-          });
-          proc.unref();
-        } catch {
-        }
-        outputSvc.dispose();
-        relay.stop();
-        ws.disconnect();
-        process.exit(0);
-      }
-      case "get_context": {
-        const usage = historySvc.getCurrentUsage();
-        const monthlyCost = historySvc.getMonthlyEstimatedCost();
-        const rateLimitReset = historySvc.getRateLimitReset();
-        const quotaPercent = historySvc.getQuotaPercent();
-        const base = usage ? { ...usage, monthlyCost } : { used: 0, total: 2e5, percent: 0, model: null, outputTokens: 0, cacheReadTokens: 0, monthlyCost, error: "No usage data found" };
-        const result = { ...base, ...rateLimitReset ? { rateLimitReset } : {}, ...quotaPercent !== null ? { quotaPercent } : {} };
-        await relay.sendResult(cmd.id, "completed", result);
-        break;
-      }
-      case "resume_session": {
-        const { id, auto } = parsed;
-        if (!id) break;
-        historySvc.setCurrentConversationId(id);
-        await historySvc.loadConversation(id);
-        await outputSvc.newTurnResume(id);
-        claude.restart(id, auto ?? false);
-        break;
-      }
-      case "get_conversation": {
-        const currentId = historySvc.getCurrentConversationId();
-        if (currentId) {
-          try {
-            await historySvc.loadConversation(currentId);
-            await relay.sendResult(cmd.id, "completed", { conversationId: currentId });
-          } catch {
-            await relay.sendResult(cmd.id, "failed", {});
-          }
-        } else {
-          await relay.sendResult(cmd.id, "completed", { conversationId: null });
-        }
-        break;
-      }
-      case "list_models": {
-        const models = [
-          { id: "claude-opus-4-7", label: "Claude Opus 4.7", description: "Most capable", family: "claude", vendor: "anthropic", isDefault: false },
-          { id: "claude-opus-4-6", label: "Claude Opus 4.6", description: "Top tier", family: "claude", vendor: "anthropic", isDefault: false },
-          { id: "claude-sonnet-4-6", label: "Claude Sonnet 4.6", description: "Balanced", family: "claude", vendor: "anthropic", isDefault: true },
-          { id: "claude-haiku-4-5-20251001", label: "Claude Haiku 4.5", description: "Fastest", family: "claude", vendor: "anthropic", isDefault: false }
-        ];
-        await relay.sendResult(cmd.id, "completed", { models });
-        break;
-      }
-      case "read_file": {
-        const { path: filePath } = parsed;
-        if (!filePath) {
-          await relay.sendResult(cmd.id, "failed", { error: "Missing path" });
-          break;
-        }
-        const result = await readProjectFile(filePath);
-        await relay.sendResult(cmd.id, "completed", result);
-        break;
-      }
-      case "write_file": {
-        const { path: filePath, content } = parsed;
-        if (!filePath || typeof content !== "string") {
-          await relay.sendResult(cmd.id, "failed", { error: "Missing path or content" });
-          break;
-        }
-        const result = await writeProjectFile(filePath, content);
-        await relay.sendResult(cmd.id, "completed", result);
-        break;
-      }
-      case "list_files": {
-        const result = await listProjectFiles({ query: parsed.query });
-        await relay.sendResult(cmd.id, "completed", result);
-        break;
-      }
-      case "git_status": {
-        const result = await gitStatus();
-        await relay.sendResult(cmd.id, "completed", result);
-        break;
-      }
-      case "git_diff": {
-        const { path: filePath } = parsed;
-        const result = await gitDiff(filePath ?? null);
-        await relay.sendResult(cmd.id, "completed", result);
-        break;
-      }
-      case "git_diff_staged": {
-        const { path: filePath } = parsed;
-        const result = await gitDiffStaged(filePath ?? null);
-        await relay.sendResult(cmd.id, "completed", result);
-        break;
-      }
-      case "git_log": {
-        const result = await gitLog(parsed.limit ?? 30);
-        await relay.sendResult(cmd.id, "completed", result);
-        break;
-      }
-      case "git_commit": {
-        if (!parsed.message) {
-          await relay.sendResult(cmd.id, "failed", { error: "Missing message" });
-          break;
-        }
-        const result = await gitCommit(parsed.message, parsed.paths);
-        await relay.sendResult(cmd.id, "completed", result);
-        break;
-      }
-      case "git_push": {
-        const result = await gitPush();
-        await relay.sendResult(cmd.id, "completed", result);
-        break;
-      }
-      case "git_pull": {
-        const result = await gitPull();
-        await relay.sendResult(cmd.id, "completed", result);
-        break;
-      }
-      case "git_resolve": {
-        const { path: filePath, side } = parsed;
-        if (!filePath || !side) {
-          await relay.sendResult(cmd.id, "failed", { error: "Missing path or side" });
-          break;
-        }
-        const result = await gitResolve(filePath, side);
-        await relay.sendResult(cmd.id, "completed", result);
-        break;
-      }
-    }
-  });
-  ws.addHandler({
-    onConnected() {
+        historySvc.uploadDelta().catch(() => {
+        });
+      }, 400);
     },
-    onDisconnected() {
+    () => {
+      const prevCount = historySvc.getCurrentMessageCount();
+      historySvc.waitForNewUserMessage(prevCount).then((userText) => outputSvc.startTerminalTurn(userText ?? void 0)).catch(() => outputSvc.startTerminalTurn(void 0));
     },
-    onMessage(type, payload) {
-      if (type !== "agent_command") return;
-      const cmdType = typeof payload.type === "string" ? payload.type : null;
-      if (!cmdType) return;
-      const parsed = parsePayload(startCommandSchema, payload.payload ?? {});
-      if (!parsed) {
-        showInfo(`Ignoring malformed ${cmdType} payload (ws).`);
-        return;
-      }
-      if (cmdType === "start_task") {
-        const { prompt, files } = parsed;
-        const effectivePrompt = prompt ?? "";
-        if (files && files.length > 0) {
-          const paths = saveFilesTemp(files);
-          const atRefs = paths.map((p2) => `@${p2}`).join(" ");
-          outputSvc.newTurn();
-          claude.sendCommand(`${atRefs} ${effectivePrompt}`.trim());
-          setTimeout(() => {
-            for (const p2 of paths) {
-              try {
-                fs8.unlinkSync(p2);
-              } catch {
-              }
-            }
-          }, 12e4);
-        } else if (effectivePrompt) {
-          sendPrompt(effectivePrompt);
-        }
-      } else if (cmdType === "provide_input") {
-        const { input } = parsed;
-        if (input) sendPrompt(input);
-      } else if (cmdType === "select_option") {
-        const index = parsed.index ?? 0;
-        const from = parsed.from ?? 0;
-        outputSvc.newTurn();
-        claude.selectOption(index, from);
-      } else if (cmdType === "escape_key") {
-        outputSvc.newTurn();
-        claude.sendEscape();
-      } else if (cmdType === "stop_task") {
-        claude.interrupt();
-      } else if (cmdType === "get_conversation") {
-        const currentId = historySvc.getCurrentConversationId();
-        if (currentId) {
-          historySvc.loadConversation(currentId).catch(() => {
-          });
-        }
-      } else if (cmdType === "resume_session") {
-        const { id, auto } = parsed;
-        if (id) {
-          const autoFlag = auto ?? false;
-          historySvc.loadConversation(id).then(() => outputSvc.newTurnResume(id)).then(() => {
-            claude.restart(id, autoFlag);
-          }).catch(() => {
-          });
-        }
-      }
-    }
-  });
-  ws.connect();
-  relay.start();
+    session.pluginAuthToken
+  );
   const claude = new ClaudeService({
-    cwd: process.cwd(),
+    cwd,
     onData(raw) {
       outputSvc.push(raw);
     },
@@ -6722,19 +6878,30 @@ except Exception:sys.exit(0)
       process.removeListener("SIGINT", sigintHandler);
       outputSvc.dispose();
       relay.stop();
-      ws.disconnect();
       process.exit(code);
     }
   });
+  const ctx = {
+    outputSvc,
+    claude,
+    historySvc,
+    relay: void 0,
+    setKeepAlive: setKeepAlive2,
+    keepAliveCtx
+  };
+  const relay = new CommandRelayService(pluginId, async (cmd) => {
+    await dispatchCommand(ctx, cmd);
+  });
+  ctx.relay = relay;
   function sigintHandler() {
     claude.kill();
     outputSvc.dispose();
     relay.stop();
-    ws.disconnect();
     process.exit(0);
   }
   process.once("SIGINT", sigintHandler);
   await claude.spawn();
+  relay.start();
   setTimeout(() => {
     historySvc.detectCurrentConversation();
     historySvc.load().catch(() => {
@@ -6745,47 +6912,7 @@ except Exception:sys.exit(0)
       });
     }
   }, 2e3);
-  setTimeout(() => {
-    fetchQuotaUsage();
-  }, 5e3);
-  const inCodespace = process.env.CODESPACES === "true";
-  const codespaceName = process.env.CODESPACE_NAME;
-  let keepAliveTimer = null;
-  async function setIdleTimeout(minutes) {
-    if (!inCodespace || !codespaceName) return;
-    await new Promise((resolve2) => {
-      const proc = (0, import_child_process5.spawn)(
-        "gh",
-        [
-          "api",
-          "-X",
-          "PATCH",
-          `/user/codespaces/${codespaceName}`,
-          "-F",
-          `idle_timeout_minutes=${minutes}`
-        ],
-        { stdio: "ignore", detached: true }
-      );
-      proc.unref();
-      proc.on("exit", () => resolve2());
-      proc.on("error", () => resolve2());
-    });
-  }
-  function setKeepAlive(enabled) {
-    if (keepAliveTimer) {
-      clearInterval(keepAliveTimer);
-      keepAliveTimer = null;
-    }
-    if (!inCodespace || !codespaceName) return;
-    if (!enabled) {
-      void setIdleTimeout(30);
-      return;
-    }
-    void setIdleTimeout(240);
-    keepAliveTimer = setInterval(() => {
-      void setIdleTimeout(240);
-    }, 30 * 60 * 1e3);
-  }
+  setTimeout(() => fetchQuotaUsage(historySvc), 5e3);
 }
 
 // src/commands/pair.ts
@@ -6966,19 +7093,19 @@ async function logout() {
 }
 
 // src/commands/deploy.ts
-var import_child_process10 = require("child_process");
-var fs9 = __toESM(require("fs"));
-var os8 = __toESM(require("os"));
-var path16 = __toESM(require("path"));
+var import_child_process12 = require("child_process");
+var fs10 = __toESM(require("fs"));
+var os9 = __toESM(require("os"));
+var path17 = __toESM(require("path"));
 var import_util6 = require("util");
 var import_picocolors9 = __toESM(require("picocolors"));
 
 // src/services/providers/github-codespaces.ts
-var import_child_process6 = require("child_process");
+var import_child_process8 = require("child_process");
 var import_util2 = require("util");
 var import_picocolors7 = __toESM(require("picocolors"));
-var path12 = __toESM(require("path"));
-var execFileP2 = (0, import_util2.promisify)(import_child_process6.execFile);
+var path13 = __toESM(require("path"));
+var execFileP2 = (0, import_util2.promisify)(import_child_process8.execFile);
 var MAX_BUFFER = 8 * 1024 * 1024;
 function resetStdinForChild() {
   if (process.stdin.isTTY) {
@@ -7022,7 +7149,7 @@ var GitHubCodespacesProvider = class {
     if (!isAuthed) {
       resetStdinForChild();
       await new Promise((resolve2, reject) => {
-        const proc = (0, import_child_process6.spawn)("gh", ["auth", "login", "-s", "codespace,repo,read:user"], {
+        const proc = (0, import_child_process8.spawn)("gh", ["auth", "login", "-s", "codespace,repo,read:user"], {
           stdio: "inherit"
         });
         proc.on("exit", (code) => {
@@ -7056,7 +7183,7 @@ var GitHubCodespacesProvider = class {
       wt(noteLines.join("\n"), "One more permission needed");
       resetStdinForChild();
       const refreshCode = await new Promise((resolve2, reject) => {
-        const proc = (0, import_child_process6.spawn)(
+        const proc = (0, import_child_process8.spawn)(
           "gh",
           ["auth", "refresh", "-h", "github.com", "-s", "codespace"],
           { stdio: "inherit" }
@@ -7206,7 +7333,7 @@ var GitHubCodespacesProvider = class {
     O2.step(`Installing gh via ${installCmd.describe}\u2026`);
     resetStdinForChild();
     const ok = await new Promise((resolve2) => {
-      const proc = (0, import_child_process6.spawn)(installCmd.exe, installCmd.args, { stdio: "inherit" });
+      const proc = (0, import_child_process8.spawn)(installCmd.exe, installCmd.args, { stdio: "inherit" });
       proc.on("exit", (code) => resolve2(code === 0));
       proc.on("error", () => resolve2(false));
     });
@@ -7233,7 +7360,7 @@ var GitHubCodespacesProvider = class {
     );
     resetStdinForChild();
     await new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process6.spawn)(
+      const proc = (0, import_child_process8.spawn)(
         "gh",
         ["auth", "refresh", "-h", "github.com", "-s", "repo,read:org"],
         { stdio: "inherit" }
@@ -7411,7 +7538,7 @@ var GitHubCodespacesProvider = class {
   async streamCommand(workspaceId, command2) {
     resetStdinForChild();
     return new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process6.spawn)(
+      const proc = (0, import_child_process8.spawn)(
         "gh",
         ["codespace", "ssh", "-c", workspaceId, "--", "-tt", command2],
         { stdio: "inherit" }
@@ -7438,11 +7565,11 @@ var GitHubCodespacesProvider = class {
       `mkdir -p ${shellQuote(remoteDir)} && tar -xzf - -C ${shellQuote(remoteDir)}`
     ];
     await new Promise((resolve2, reject) => {
-      const tar = (0, import_child_process6.spawn)("tar", tarArgs, {
+      const tar = (0, import_child_process8.spawn)("tar", tarArgs, {
         stdio: ["ignore", "pipe", "pipe"],
         env: tarEnv
       });
-      const ssh = (0, import_child_process6.spawn)("gh", sshArgs, {
+      const ssh = (0, import_child_process8.spawn)("gh", sshArgs, {
         stdio: [tar.stdout, "pipe", "pipe"]
       });
       let tarErr = "";
@@ -7466,7 +7593,7 @@ var GitHubCodespacesProvider = class {
     });
   }
   async uploadFile(workspaceId, remotePath, contents, options = {}) {
-    const remoteDir = path12.posix.dirname(remotePath);
+    const remoteDir = path13.posix.dirname(remotePath);
     const parts = [
       `mkdir -p ${shellQuote(remoteDir)}`,
       `cat > ${shellQuote(remotePath)}`
@@ -7476,7 +7603,7 @@ var GitHubCodespacesProvider = class {
     }
     const cmd = parts.join(" && ");
     await new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process6.spawn)(
+      const proc = (0, import_child_process8.spawn)(
         "gh",
         ["codespace", "ssh", "-c", workspaceId, "--", cmd],
         { stdio: ["pipe", "pipe", "pipe"] }
@@ -7534,11 +7661,11 @@ function shellQuote(s) {
 }
 
 // src/services/providers/gitpod.ts
-var import_child_process7 = require("child_process");
+var import_child_process9 = require("child_process");
 var import_util3 = require("util");
-var path13 = __toESM(require("path"));
+var path14 = __toESM(require("path"));
 var import_picocolors8 = __toESM(require("picocolors"));
-var execFileP3 = (0, import_util3.promisify)(import_child_process7.execFile);
+var execFileP3 = (0, import_util3.promisify)(import_child_process9.execFile);
 var MAX_BUFFER2 = 8 * 1024 * 1024;
 function resetStdinForChild2() {
   if (process.stdin.isTTY) {
@@ -7578,7 +7705,7 @@ var GitpodProvider = class {
     );
     resetStdinForChild2();
     await new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process7.spawn)("gitpod", ["login"], { stdio: "inherit" });
+      const proc = (0, import_child_process9.spawn)("gitpod", ["login"], { stdio: "inherit" });
       proc.on("exit", (code) => {
         if (code === 0) resolve2();
         else reject(new Error("gitpod login failed."));
@@ -7730,7 +7857,7 @@ var GitpodProvider = class {
   async streamCommand(workspaceId, command2) {
     resetStdinForChild2();
     return new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process7.spawn)(
+      const proc = (0, import_child_process9.spawn)(
         "gitpod",
         ["workspace", "ssh", workspaceId, "--", "-tt", command2],
         { stdio: "inherit" }
@@ -7750,11 +7877,11 @@ var GitpodProvider = class {
     const tarEnv = { ...process.env, COPYFILE_DISABLE: "1" };
     const remoteCmd = `mkdir -p ${shellQuote2(remoteDir)} && tar -xzf - -C ${shellQuote2(remoteDir)}`;
     await new Promise((resolve2, reject) => {
-      const tar = (0, import_child_process7.spawn)("tar", tarArgs, {
+      const tar = (0, import_child_process9.spawn)("tar", tarArgs, {
         stdio: ["ignore", "pipe", "pipe"],
         env: tarEnv
       });
-      const ssh = (0, import_child_process7.spawn)(
+      const ssh = (0, import_child_process9.spawn)(
         "gitpod",
         ["workspace", "ssh", workspaceId, "--", remoteCmd],
         { stdio: [tar.stdout, "pipe", "pipe"] }
@@ -7776,7 +7903,7 @@ var GitpodProvider = class {
     });
   }
   async uploadFile(workspaceId, remotePath, contents, options = {}) {
-    const remoteDir = path13.posix.dirname(remotePath);
+    const remoteDir = path14.posix.dirname(remotePath);
     const parts = [
       `mkdir -p ${shellQuote2(remoteDir)}`,
       `cat > ${shellQuote2(remotePath)}`
@@ -7786,7 +7913,7 @@ var GitpodProvider = class {
     }
     const cmd = parts.join(" && ");
     await new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process7.spawn)(
+      const proc = (0, import_child_process9.spawn)(
         "gitpod",
         ["workspace", "ssh", workspaceId, "--", cmd],
         { stdio: ["pipe", "pipe", "pipe"] }
@@ -7810,10 +7937,10 @@ function shellQuote2(s) {
 }
 
 // src/services/providers/gitlab-workspaces.ts
-var import_child_process8 = require("child_process");
+var import_child_process10 = require("child_process");
 var import_util4 = require("util");
-var path14 = __toESM(require("path"));
-var execFileP4 = (0, import_util4.promisify)(import_child_process8.execFile);
+var path15 = __toESM(require("path"));
+var execFileP4 = (0, import_util4.promisify)(import_child_process10.execFile);
 var MAX_BUFFER3 = 8 * 1024 * 1024;
 var GITLAB_API_BASE = process.env.CODEAM_GITLAB_API_URL ?? "https://gitlab.com/api/v4";
 function resetStdinForChild3() {
@@ -7855,7 +7982,7 @@ var GitLabWorkspacesProvider = class {
     );
     resetStdinForChild3();
     await new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process8.spawn)(
+      const proc = (0, import_child_process10.spawn)(
         "glab",
         ["auth", "login", "--scopes", "api,read_user,read_repository"],
         { stdio: "inherit" }
@@ -8027,7 +8154,7 @@ Docs: https://docs.gitlab.com/ee/user/workspace/configuration.html`
     const sshHost = process.env.CODEAM_GITLAB_SSH_HOST ?? "workspaces.gitlab.com";
     resetStdinForChild3();
     return new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process8.spawn)(
+      const proc = (0, import_child_process10.spawn)(
         "ssh",
         ["-tt", "-o", "StrictHostKeyChecking=accept-new", `${workspaceId}@${sshHost}`, command2],
         { stdio: "inherit" }
@@ -8048,8 +8175,8 @@ Docs: https://docs.gitlab.com/ee/user/workspace/configuration.html`
     const tarEnv = { ...process.env, COPYFILE_DISABLE: "1" };
     const remoteCmd = `mkdir -p ${shellQuote3(remoteDir)} && tar -xzf - -C ${shellQuote3(remoteDir)}`;
     await new Promise((resolve2, reject) => {
-      const tar = (0, import_child_process8.spawn)("tar", tarArgs, { stdio: ["ignore", "pipe", "pipe"], env: tarEnv });
-      const ssh = (0, import_child_process8.spawn)(
+      const tar = (0, import_child_process10.spawn)("tar", tarArgs, { stdio: ["ignore", "pipe", "pipe"], env: tarEnv });
+      const ssh = (0, import_child_process10.spawn)(
         "ssh",
         ["-o", "StrictHostKeyChecking=accept-new", `${workspaceId}@${sshHost}`, remoteCmd],
         { stdio: [tar.stdout, "pipe", "pipe"] }
@@ -8072,14 +8199,14 @@ Docs: https://docs.gitlab.com/ee/user/workspace/configuration.html`
   }
   async uploadFile(workspaceId, remotePath, contents, options = {}) {
     const sshHost = process.env.CODEAM_GITLAB_SSH_HOST ?? "workspaces.gitlab.com";
-    const remoteDir = path14.posix.dirname(remotePath);
+    const remoteDir = path15.posix.dirname(remotePath);
     const parts = [`mkdir -p ${shellQuote3(remoteDir)}`, `cat > ${shellQuote3(remotePath)}`];
     if (options.mode != null) {
       parts.push(`chmod ${options.mode.toString(8)} ${shellQuote3(remotePath)}`);
     }
     const cmd = parts.join(" && ");
     await new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process8.spawn)(
+      const proc = (0, import_child_process10.spawn)(
         "ssh",
         ["-o", "StrictHostKeyChecking=accept-new", `${workspaceId}@${sshHost}`, cmd],
         { stdio: ["pipe", "pipe", "pipe"] }
@@ -8138,10 +8265,10 @@ function shellQuote3(s) {
 }
 
 // src/services/providers/railway.ts
-var import_child_process9 = require("child_process");
+var import_child_process11 = require("child_process");
 var import_util5 = require("util");
-var path15 = __toESM(require("path"));
-var execFileP5 = (0, import_util5.promisify)(import_child_process9.execFile);
+var path16 = __toESM(require("path"));
+var execFileP5 = (0, import_util5.promisify)(import_child_process11.execFile);
 var MAX_BUFFER4 = 8 * 1024 * 1024;
 function resetStdinForChild4() {
   if (process.stdin.isTTY) {
@@ -8182,7 +8309,7 @@ var RailwayProvider = class {
     );
     resetStdinForChild4();
     await new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process9.spawn)("railway", ["login"], { stdio: "inherit" });
+      const proc = (0, import_child_process11.spawn)("railway", ["login"], { stdio: "inherit" });
       proc.on("exit", (code) => {
         if (code === 0) resolve2();
         else reject(new Error("railway login failed."));
@@ -8325,7 +8452,7 @@ var RailwayProvider = class {
     }
     resetStdinForChild4();
     return new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process9.spawn)(
+      const proc = (0, import_child_process11.spawn)(
         "railway",
         ["shell", "--project", projectId, "--service", serviceId, "--command", command2],
         { stdio: "inherit" }
@@ -8349,8 +8476,8 @@ var RailwayProvider = class {
     const tarEnv = { ...process.env, COPYFILE_DISABLE: "1" };
     const remoteCmd = `mkdir -p ${shellQuote4(remoteDir)} && tar -xzf - -C ${shellQuote4(remoteDir)}`;
     await new Promise((resolve2, reject) => {
-      const tar = (0, import_child_process9.spawn)("tar", tarArgs, { stdio: ["ignore", "pipe", "pipe"], env: tarEnv });
-      const sh = (0, import_child_process9.spawn)(
+      const tar = (0, import_child_process11.spawn)("tar", tarArgs, { stdio: ["ignore", "pipe", "pipe"], env: tarEnv });
+      const sh = (0, import_child_process11.spawn)(
         "railway",
         ["shell", "--project", projectId, "--service", serviceId, "--command", remoteCmd],
         { stdio: [tar.stdout, "pipe", "pipe"] }
@@ -8376,14 +8503,14 @@ var RailwayProvider = class {
     if (!projectId || !serviceId) {
       throw new Error("Invalid Railway workspace id (expected projectId/serviceId).");
     }
-    const remoteDir = path15.posix.dirname(remotePath);
+    const remoteDir = path16.posix.dirname(remotePath);
     const parts = [`mkdir -p ${shellQuote4(remoteDir)}`, `cat > ${shellQuote4(remotePath)}`];
     if (options.mode != null) {
       parts.push(`chmod ${options.mode.toString(8)} ${shellQuote4(remotePath)}`);
     }
     const cmd = parts.join(" && ");
     await new Promise((resolve2, reject) => {
-      const proc = (0, import_child_process9.spawn)(
+      const proc = (0, import_child_process11.spawn)(
         "railway",
         ["shell", "--project", projectId, "--service", serviceId, "--command", cmd],
         { stdio: ["pipe", "pipe", "pipe"] }
@@ -8415,7 +8542,7 @@ var PROVIDERS = [
 ];
 
 // src/commands/deploy.ts
-var execFileP6 = (0, import_util6.promisify)(import_child_process10.execFile);
+var execFileP6 = (0, import_util6.promisify)(import_child_process12.execFile);
 async function deploy() {
   console.log();
   mt(import_picocolors9.default.bgMagenta(import_picocolors9.default.white(" codeam deploy ")));
@@ -8568,7 +8695,7 @@ async function deploy() {
       process.exit(1);
     }
   }
-  const localClaudeDir = path16.join(os8.homedir(), ".claude");
+  const localClaudeDir = path17.join(os9.homedir(), ".claude");
   const localCredsKind = await detectLocalClaudeCredentials(localClaudeDir);
   let bridged = "none";
   if (localCredsKind !== "none") {
@@ -8612,7 +8739,7 @@ async function deploy() {
     process.exit(1);
   }
   claudeStep.stop("\u2713 Claude CLI installed");
-  const haveLocalClaude = fs9.existsSync(localClaudeDir) && fs9.statSync(localClaudeDir).isDirectory();
+  const haveLocalClaude = fs10.existsSync(localClaudeDir) && fs10.statSync(localClaudeDir).isDirectory();
   if (haveLocalClaude) {
     const copyStep = fe();
     copyStep.start("Copying local Claude config to workspace\u2026");
@@ -8666,10 +8793,10 @@ async function deploy() {
     }
   }
   if (bridged !== "none") {
-    const localClaudeJson = path16.join(os8.homedir(), ".claude.json");
-    if (fs9.existsSync(localClaudeJson)) {
+    const localClaudeJson = path17.join(os9.homedir(), ".claude.json");
+    if (fs10.existsSync(localClaudeJson)) {
       try {
-        const contents = fs9.readFileSync(localClaudeJson);
+        const contents = fs10.readFileSync(localClaudeJson);
         await provider.uploadFile(
           workspace.id,
           "/home/codespace/.claude.json",
@@ -8859,7 +8986,7 @@ async function runRemoteClaudeLogin(provider, workspaceId) {
   }
 }
 async function detectLocalClaudeCredentials(localClaudeDir) {
-  if (fs9.existsSync(path16.join(localClaudeDir, ".credentials.json"))) {
+  if (fs10.existsSync(path17.join(localClaudeDir, ".credentials.json"))) {
     return "flat-file";
   }
   if (process.platform === "darwin") {
@@ -8892,8 +9019,8 @@ async function verifyClaudeAuth(provider, workspaceId) {
   }
 }
 async function bridgeClaudeCredentials(provider, workspaceId, localClaudeDir) {
-  const fileBased = path16.join(localClaudeDir, ".credentials.json");
-  if (fs9.existsSync(fileBased)) return "flat-file";
+  const fileBased = path17.join(localClaudeDir, ".credentials.json");
+  if (fs10.existsSync(fileBased)) return "flat-file";
   if (process.platform === "darwin") {
     try {
       const { stdout } = await execFileP6(
@@ -9101,7 +9228,7 @@ async function stopWorkspaceFromLocal(target) {
 // src/commands/version.ts
 var import_picocolors11 = __toESM(require("picocolors"));
 function version() {
-  const v = true ? "2.4.39" : "unknown";
+  const v = true ? "2.5.1" : "unknown";
   console.log(`${import_picocolors11.default.bold("codeam-cli")} ${import_picocolors11.default.cyan(v)}`);
 }
 
@@ -9138,22 +9265,22 @@ function help() {
 }
 
 // src/lib/updateNotifier.ts
-var fs10 = __toESM(require("fs"));
-var os9 = __toESM(require("os"));
-var path17 = __toESM(require("path"));
-var https4 = __toESM(require("https"));
+var fs11 = __toESM(require("fs"));
+var os10 = __toESM(require("os"));
+var path18 = __toESM(require("path"));
+var https5 = __toESM(require("https"));
 var import_picocolors13 = __toESM(require("picocolors"));
 var PKG_NAME = "codeam-cli";
 var REGISTRY_URL = `https://registry.npmjs.org/${PKG_NAME}/latest`;
 var TTL_MS = 24 * 60 * 60 * 1e3;
 var REQUEST_TIMEOUT_MS = 1500;
 function cachePath() {
-  const dir = path17.join(os9.homedir(), ".codeam");
-  return path17.join(dir, "update-check.json");
+  const dir = path18.join(os10.homedir(), ".codeam");
+  return path18.join(dir, "update-check.json");
 }
 function readCache() {
   try {
-    const raw = fs10.readFileSync(cachePath(), "utf8");
+    const raw = fs11.readFileSync(cachePath(), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.fetchedAt !== "number" || typeof parsed.latest !== "string") return null;
     return parsed;
@@ -9164,8 +9291,8 @@ function readCache() {
 function writeCache(cache) {
   try {
     const file = cachePath();
-    fs10.mkdirSync(path17.dirname(file), { recursive: true });
-    fs10.writeFileSync(file, JSON.stringify(cache));
+    fs11.mkdirSync(path18.dirname(file), { recursive: true });
+    fs11.writeFileSync(file, JSON.stringify(cache));
   } catch {
   }
 }
@@ -9184,7 +9311,7 @@ function compareSemver(a, b) {
 }
 function fetchLatest() {
   return new Promise((resolve2) => {
-    const req = https4.get(
+    const req = https5.get(
       REGISTRY_URL,
       { headers: { Accept: "application/json" }, timeout: REQUEST_TIMEOUT_MS },
       (res) => {
@@ -9236,7 +9363,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.4.39" : null;
+  const current = true ? "2.5.1" : null;
   if (!current) return;
   const cache = readCache();
   const fresh = cache && Date.now() - cache.fetchedAt < TTL_MS;