codeam-cli 2.53.2 → 2.53.4

package/dist/index.js

@@ -199,9 +199,35 @@ function renderToLines(raw) {
   return screen;
 }
 
+// ../../packages/shared/src/protocol/remote-command.ts
+var import_zod = require("zod");
+var remoteCommandSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  sessionId: import_zod.z.string(),
+  pluginId: import_zod.z.string(),
+  type: import_zod.z.string(),
+  // The backend may omit `payload` (or send null) for payload-less commands;
+  // clients have always normalized that to `{}` — keep that behavior here.
+  payload: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).nullish(),
+  status: import_zod.z.string(),
+  createdAt: import_zod.z.number()
+});
+
 // ../../packages/shared/src/models/pricing.ts
 var MODEL_PRICING = {
   // ── Anthropic / Claude ────────────────────────────────────
+  // The 4.x rows below cover the model ids actually emitted by the CLI
+  // (apps/cli/src/agents/claude/runtime.ts listModels) and the JetBrains
+  // fallback catalog (RemoteCommandRouter.kt). Prices are copied from the
+  // same-family base rows (claude-opus-4 / claude-sonnet-4 /
+  // claude-3-5-haiku) until distinct published rates land.
+  "claude-opus-4-7": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+  "claude-opus-4-6": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+  "claude-sonnet-4-6": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  // Haiku-tier prices copied from claude-3-5-haiku (closest same-tier
+  // sibling in this table) — previously this id matched NO row and was
+  // silently billed at sonnet rates via the unknown-model fallback.
+  "claude-haiku-4-5": { input: 0.8, output: 4, cacheRead: 0.08, cacheWrite: 1 },
   "claude-sonnet-4": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
   "claude-opus-4": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
   "claude-3-5-sonnet": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
@@ -220,6 +246,10 @@ var MODEL_PRICING = {
 };
 var MODEL_CONTEXT_WINDOW = {
   // ── Anthropic / Claude ────────────────────────────────────
+  "claude-opus-4-7": 1e6,
+  "claude-opus-4-6": 1e6,
+  "claude-sonnet-4-6": 1e6,
+  "claude-haiku-4-5": 2e5,
   "claude-opus-4": 1e6,
   "claude-sonnet-4": 1e6,
   "claude-3-5-sonnet": 2e5,
@@ -234,18 +264,23 @@ var MODEL_CONTEXT_WINDOW = {
   "codex-auto-review": 272e3
 };
 var DEFAULT_CONTEXT_WINDOW = 2e5;
-function getPricing(model) {
-  for (const [prefix, pricing] of Object.entries(MODEL_PRICING)) {
-    if (model.startsWith(prefix)) return pricing;
+function longestPrefixMatch(table, model) {
+  let best;
+  let bestLen = -1;
+  for (const [prefix, value] of Object.entries(table)) {
+    if (prefix.length > bestLen && model.startsWith(prefix)) {
+      best = value;
+      bestLen = prefix.length;
+    }
   }
-  return MODEL_PRICING["claude-sonnet-4"];
+  return best;
+}
+function getPricing(model) {
+  return longestPrefixMatch(MODEL_PRICING, model) ?? MODEL_PRICING["claude-sonnet-4"];
 }
 function getContextWindow(model) {
   if (!model) return DEFAULT_CONTEXT_WINDOW;
-  for (const [prefix, size] of Object.entries(MODEL_CONTEXT_WINDOW)) {
-    if (model.startsWith(prefix)) return size;
-  }
-  return DEFAULT_CONTEXT_WINDOW;
+  return longestPrefixMatch(MODEL_CONTEXT_WINDOW, model) ?? DEFAULT_CONTEXT_WINDOW;
 }
 
 // ../../packages/shared/src/agents/registry.ts
@@ -255,8 +290,12 @@ var AGENT_REGISTRY = {
     displayName: "Claude Code",
     binaryName: "claude",
     enabled: true,
-    supportedAuthKinds: ["oauth_token", "api_key"],
-    preferredAuthKind: "oauth_token"
+    // Mirrors the backend registry (codeagent-mobile
+    // apps/api-v2/src/codespaces/agent.ts — authoritative for auth
+    // capabilities). `setup_token` is the bare `sk-ant-oat01-…` from
+    // `claude setup-token` → delivered via CLAUDE_CODE_OAUTH_TOKEN.
+    supportedAuthKinds: ["setup_token", "oauth_token", "api_key"],
+    preferredAuthKind: "setup_token"
   },
   codex: {
     id: "codex",
@@ -279,15 +318,22 @@ var AGENT_REGISTRY = {
     displayName: "CodeRabbit",
     binaryName: "coderabbit",
     enabled: true,
-    supportedAuthKinds: ["oauth_token", "api_key"],
-    preferredAuthKind: "oauth_token"
+    // Backend registry is authoritative: CodeRabbit links via a real
+    // API key only (no OAuth flow exists in api-v2).
+    supportedAuthKinds: ["api_key"],
+    preferredAuthKind: "api_key"
   },
   cursor: {
     id: "cursor",
     displayName: "Cursor Agent",
     binaryName: "cursor-agent",
     enabled: true,
-    supportedAuthKinds: ["oauth_token", "api_key"],
+    // Backend registry is authoritative: since the Cursor OAuth
+    // device-flow shipped, new links are oauth_token only (the login
+    // blob written to ~/.config/cursor/auth.json). Legacy vaulted
+    // api_key rows may still exist server-side, but the link surface
+    // no longer offers api_key.
+    supportedAuthKinds: ["oauth_token"],
     preferredAuthKind: "oauth_token"
   },
   aider: {
@@ -323,7 +369,7 @@ function getAgent(id) {
   return meta;
 }
 function isKnownAgentId(id) {
-  return id === "claude" || id === "codex" || id === "copilot" || id === "coderabbit" || id === "cursor" || id === "aider" || id === "gemini";
+  return id in AGENT_REGISTRY;
 }
 
 // ../../packages/shared/src/api-url.ts
@@ -338,6 +384,74 @@ function resolveApiBaseUrl() {
   return DEFAULT_API_BASE_URL;
 }
 
+// ../../packages/shared/src/types/events.ts
+var USER_EVENTS = {
+  PAIRED_SESSION_STATUS: "paired_session_status",
+  PAIRED_SESSION_ADDED: "paired_session_added",
+  PAIRED_SESSION_REMOVED: "paired_session_removed",
+  PAIRED_SESSION_BRANCH_CHANGED: "paired_session_branch_changed",
+  SHARED_WITH_ME_ADDED: "shared_with_me_added",
+  SHARED_WITH_ME_REVOKED: "shared_with_me_revoked",
+  USAGE_CHANGED: "usage_changed",
+  TASK_DONE: "task_done",
+  HUNK_PENDING_REVIEW_ADDED: "hunk_pending_review_added",
+  HUNK_REVIEW_RESOLVED: "hunk_review_resolved",
+  FILE_CHANGED: "file_changed",
+  FILES_BATCH_CHANGED: "files_batch_changed",
+  AGENT_STREAMING_CHUNK: "agent_streaming_chunk",
+  AGENT_AWAITING_ANSWER: "agent_awaiting_answer",
+  AWAITING_INPUT_ADDED: "awaiting_input_added",
+  AGENT_ANSWER_RESOLVED: "agent_answer_resolved",
+  TEMPLATE_ADDED: "template_added",
+  TEMPLATE_REMOVED: "template_removed",
+  TEMPLATE_UPDATED: "template_updated",
+  AGENT_TASK_DISPATCHED: "agent_task_dispatched",
+  AGENT_TASK_COMPLETED: "agent_task_completed",
+  LINKED_AGENT_ADDED: "linked_agent_added",
+  QUOTA_REACHED: "quota_reached",
+  LINKED_AGENT_LINK_FAILED: "linked_agent_link_failed",
+  CODESPACE_AGENT_INSTALLED: "codespace_agent_installed",
+  AGENT_CREDENTIALS_REFRESHED: "agent_credentials_refreshed",
+  CREDENTIAL_INVALID: "credential_invalid",
+  CODESPACE_WAKING: "codespace_waking",
+  CODESPACE_BILLING_BLOCKED: "codespace_billing_blocked",
+  COST_SAVING_UPDATED: "cost_saving_updated",
+  COMMAND_COMPLETED: "command_completed",
+  AI_SUMMARY_PENDING: "ai_summary_pending",
+  AI_SUMMARY_READY: "ai_summary_ready",
+  AI_INSIGHT_PENDING: "ai_insight_pending",
+  AI_INSIGHT_READY: "ai_insight_ready",
+  PUSH_TOKEN_INVALIDATED: "push_token_invalidated",
+  PREVIEW_DETECTION_PENDING: "preview_detection_pending",
+  PREVIEW_DETECTION_READY: "preview_detection_ready",
+  PREVIEW_STARTING: "preview_starting",
+  PREVIEW_READY: "preview_ready",
+  PREVIEW_STOPPED: "preview_stopped",
+  PREVIEW_ERROR: "preview_error",
+  PREVIEW_PROGRESS: "preview_progress",
+  BEADS_STATE_CHANGED: "beads_state_changed",
+  BEADS_PROVISIONING: "beads_provisioning",
+  BEADS_TEAM_MEMORY_CHANGED: "beads_team_memory_changed",
+  AUDIT_EVENT_ADDED: "audit_event_added",
+  SELF_HOSTED_HOST_ADDED: "self_hosted_host_added",
+  SELF_HOSTED_HOST_STATUS: "self_hosted_host_status",
+  SELF_HOSTED_HOST_REMOVED: "self_hosted_host_removed",
+  SELF_HOSTED_HOST_TELEMETRY: "self_hosted_host_telemetry",
+  SELF_HOSTED_HOST_METRICS: "self_hosted_host_metrics",
+  SELF_HOSTED_HOST_SESSIONS: "self_hosted_host_sessions",
+  SELF_HOSTED_DEPLOY_PROGRESS: "self_hosted_deploy_progress",
+  REFERRAL_REWARD_EARNED: "referral_reward_earned",
+  HEADROOM_PROGRESS: "headroom_progress",
+  HEADROOM_STATUS: "headroom_status",
+  BEADS_STATUS: "beads_status",
+  LINKED_AGENT_HEADROOM_BUDGET_UPDATED: "linked_agent_headroom_budget_updated",
+  CLI_UPDATE_AVAILABLE: "cli_update_available",
+  AGENT_INSTALL_PROGRESS: "agent_install_progress",
+  AGENT_INSTALL_FAILED: "agent_install_failed",
+  CLI_UPDATE_PROGRESS: "cli_update_progress",
+  CLI_UPDATE_FAILED: "cli_update_failed"
+};
+
 // ../../packages/shared/src/preview-prompts.ts
 var PREVIEW_DETECT_PROMPT = `
 Analyze the project in the current working directory and return how to start
@@ -522,9 +636,9 @@ var _default = makeConfig();
 var { getConfig, ensurePluginId, addSession, removeSession, setActiveSession, getActiveSession, getActiveSessionForAgent, setDisable1mContext, clearAll, saveCliConfig, loadCliConfig } = _default;
 
 // src/commands/pair-auto.ts
-var fs45 = __toESM(require("fs"));
-var os38 = __toESM(require("os"));
-var path50 = __toESM(require("path"));
+var fs46 = __toESM(require("fs"));
+var os39 = __toESM(require("os"));
+var path51 = __toESM(require("path"));
 var import_crypto4 = require("crypto");
 
 // src/services/telemetry.service.ts
@@ -560,8 +674,8 @@ function createGetModuleFromFilename(basePath = process.argv[1] ? (0, import_pat
     return decodedFile;
   };
 }
-function normalizeWindowsPath(path64) {
-  return path64.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
+function normalizeWindowsPath(path65) {
+  return path65.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
 }
 
 // ../../node_modules/@posthog/core/dist/featureFlagUtils.mjs
@@ -3041,9 +3155,9 @@ async function addSourceContext(frames) {
   LRU_FILE_CONTENTS_CACHE.reduce();
   return frames;
 }
-function getContextLinesFromFile(path64, ranges, output) {
+function getContextLinesFromFile(path65, ranges, output) {
   return new Promise((resolve7) => {
-    const stream = (0, import_node_fs.createReadStream)(path64);
+    const stream = (0, import_node_fs.createReadStream)(path65);
     const lineReaded = (0, import_node_readline.createInterface)({
       input: stream
     });
@@ -3058,7 +3172,7 @@ function getContextLinesFromFile(path64, ranges, output) {
     let rangeStart = range[0];
     let rangeEnd = range[1];
     function onStreamError() {
-      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path64, 1);
+      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path65, 1);
       lineReaded.close();
       lineReaded.removeAllListeners();
       destroyStreamAndResolve();
@@ -3119,8 +3233,8 @@ function clearLineContext(frame) {
   delete frame.context_line;
   delete frame.post_context;
 }
-function shouldSkipContextLinesForFile(path64) {
-  return path64.startsWith("node:") || path64.endsWith(".min.js") || path64.endsWith(".min.cjs") || path64.endsWith(".min.mjs") || path64.startsWith("data:");
+function shouldSkipContextLinesForFile(path65) {
+  return path65.startsWith("node:") || path65.endsWith(".min.js") || path65.endsWith(".min.cjs") || path65.endsWith(".min.mjs") || path65.startsWith("data:");
 }
 function shouldSkipContextLinesForFrame(frame) {
   if (void 0 !== frame.lineno && frame.lineno > MAX_CONTEXTLINES_LINENO) return true;
@@ -5397,7 +5511,7 @@ function readAnonId() {
 }
 function superProperties() {
   return {
-    cliVersion: true ? "2.53.2" : "0.0.0-dev",
+    cliVersion: true ? "2.53.4" : "0.0.0-dev",
     nodeVersion: process.version,
     platform: process.platform,
     arch: process.arch,
@@ -5578,7 +5692,7 @@ var os4 = __toESM(require("os"));
 // package.json
 var package_default = {
   name: "codeam-cli",
-  version: "2.53.2",
+  version: "2.53.4",
   description: "Workflow-continuity bridge for AI coding agents. Wrap Claude Code or Codex in a PTY and supervise, approve, and redirect the session from any device \u2014 async. The terminal companion for CodeAgent Mobile.",
   type: "commonjs",
   main: "dist/index.js",
@@ -6106,9 +6220,9 @@ function computePollDelay({ baseMs, failures }) {
 
 // src/services/headroom/proxy-supervisor.ts
 var import_child_process2 = require("child_process");
-var fs4 = __toESM(require("fs"));
-var os5 = __toESM(require("os"));
-var path4 = __toESM(require("path"));
+var fs5 = __toESM(require("fs"));
+var os6 = __toESM(require("os"));
+var path5 = __toESM(require("path"));
 
 // src/services/headroom/budget-args.ts
 function buildBudgetProxyArgs(env) {
@@ -6118,6 +6232,74 @@ function buildBudgetProxyArgs(env) {
   return ["--budget", budget, "--budget-period", period];
 }
 
+// src/services/headroom/proxy-pid.ts
+var import_node_child_process = require("child_process");
+var fs4 = __toESM(require("fs"));
+var os5 = __toESM(require("os"));
+var path4 = __toESM(require("path"));
+function headroomProxyPidfilePath() {
+  return path4.join(os5.homedir(), ".codeam", "headroom-proxy.pid");
+}
+function writeHeadroomProxyPidfile(pid) {
+  if (!pid) return;
+  try {
+    const file = headroomProxyPidfilePath();
+    fs4.mkdirSync(path4.dirname(file), { recursive: true, mode: 448 });
+    fs4.writeFileSync(file, `${pid}
+`, { encoding: "utf8", mode: 384 });
+  } catch {
+  }
+}
+function readHeadroomProxyPidfile() {
+  try {
+    const pid = Number(fs4.readFileSync(headroomProxyPidfilePath(), "utf8").trim());
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function pkillFallback() {
+  try {
+    const killer = (0, import_node_child_process.spawn)("pkill", ["-TERM", "-f", "headroom.*proxy"], {
+      detached: true,
+      stdio: "ignore"
+    });
+    killer.once("error", () => {
+    });
+    killer.unref();
+  } catch {
+  }
+}
+function killHeadroomProxy() {
+  const pid = readHeadroomProxyPidfile();
+  if (pid !== null && isPidAlive(pid)) {
+    try {
+      process.kill(pid, "SIGTERM");
+      try {
+        fs4.rmSync(headroomProxyPidfilePath(), { force: true });
+      } catch {
+      }
+      return;
+    } catch {
+    }
+  }
+  if (pid !== null) {
+    try {
+      fs4.rmSync(headroomProxyPidfilePath(), { force: true });
+    } catch {
+    }
+  }
+  pkillFallback();
+}
+
 // src/services/headroom/proxy-supervisor.ts
 async function ensureHeadroomProxy(deps) {
   if (!deps.isConfigured()) return "skip";
@@ -6132,17 +6314,17 @@ async function ensureHeadroomProxy(deps) {
   deps.spawnProxy();
   return "respawned";
 }
-function isHeadroomConfiguredReal(homeDir2 = os5.homedir()) {
+function isHeadroomConfiguredReal(homeDir2 = os6.homedir()) {
   if (process.env.HEADROOM_ENABLED === "1") return true;
-  const csEnv = path4.join(homeDir2, ".codeam", "codespace-env.json");
+  const csEnv = path5.join(homeDir2, ".codeam", "codespace-env.json");
   try {
-    const j2 = JSON.parse(fs4.readFileSync(csEnv, "utf8"));
+    const j2 = JSON.parse(fs5.readFileSync(csEnv, "utf8"));
     if (j2.HEADROOM_ENABLED === "1" || j2.HEADROOM_ENABLED === 1) return true;
   } catch {
   }
-  const settings = path4.join(homeDir2, ".claude", "settings.json");
+  const settings = path5.join(homeDir2, ".claude", "settings.json");
   try {
-    if (fs4.readFileSync(settings, "utf8").includes("127.0.0.1:8787")) return true;
+    if (fs5.readFileSync(settings, "utf8").includes("127.0.0.1:8787")) return true;
   } catch {
   }
   return false;
@@ -6176,6 +6358,7 @@ function spawnProxyReal() {
       log.warn("headroom-supervisor", `respawn error (best-effort): ${e.message}`);
     });
     proxy.unref();
+    writeHeadroomProxyPidfile(proxy.pid);
   } catch (e) {
     log.warn(
       "headroom-supervisor",
@@ -6543,7 +6726,7 @@ var CommandRelayService = class {
       // fresh + clear the "CLI update available" banner after a self-update
       // (a codespace that reinstalls @latest reconnects via heartbeat, not
       // pair/reconnect). Older backends ignore the extra field.
-      ..."2.53.2" ? { ideVersion: "2.53.2" } : {}
+      ..."2.53.4" ? { ideVersion: "2.53.4" } : {}
     }).then(() => log.trace("relay", `heartbeat ok online=${online}`)).catch((err) => log.trace("relay", `heartbeat failed online=${online}`, err));
   }
   /**
@@ -6609,9 +6792,9 @@ var CommandRelayService = class {
 
 // src/services/file-watcher.service.ts
 var import_child_process3 = require("child_process");
-var fs5 = __toESM(require("fs"));
-var os6 = __toESM(require("os"));
-var path5 = __toESM(require("path"));
+var fs6 = __toESM(require("fs"));
+var os7 = __toESM(require("os"));
+var path6 = __toESM(require("path"));
 var import_ignore = __toESM(require("ignore"));
 
 // src/services/file-watcher/diff-parser.ts
@@ -6770,10 +6953,10 @@ var WINDOWS_LEGACY_JUNCTIONS = [
   /[\\/]Start Menu([\\/]|$)/i,
   /[\\/]Templates([\\/]|$)/i
 ];
-function isUnsafeWindowsWatchRoot(dir, homedir35) {
+function isUnsafeWindowsWatchRoot(dir, homedir36) {
   const norm = (p2) => p2.replace(/\//g, "\\").replace(/\\+$/, "").toLowerCase();
   const cwd = norm(dir);
-  const home = norm(homedir35);
+  const home = norm(homedir36);
   if (cwd === home) return true;
   if (/^[a-z]:$/.test(cwd)) return true;
   const sysRoots = [
@@ -6803,18 +6986,18 @@ var _findGitRootSeam = {
   resolve: _defaultFindGitRoot
 };
 function _defaultFindGitRoot(startDir) {
-  let dir = path5.resolve(startDir);
+  let dir = path6.resolve(startDir);
   const seen = /* @__PURE__ */ new Set();
   for (let i = 0; i < 256; i++) {
     if (seen.has(dir)) return null;
     seen.add(dir);
     try {
-      const gitPath = path5.join(dir, ".git");
-      const stat3 = fs5.statSync(gitPath, { throwIfNoEntry: false });
+      const gitPath = path6.join(dir, ".git");
+      const stat3 = fs6.statSync(gitPath, { throwIfNoEntry: false });
       if (stat3 && (stat3.isDirectory() || stat3.isFile())) return dir;
     } catch {
     }
-    const parent = path5.dirname(dir);
+    const parent = path6.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -6872,7 +7055,7 @@ var FileWatcherService = class {
       throw new Error("FileWatcherService has already been stopped \u2014 re-instantiate to restart.");
     }
     const isWin = process.platform === "win32";
-    if (isWin && isUnsafeWindowsWatchRoot(this.opts.workingDir, os6.homedir())) {
+    if (isWin && isUnsafeWindowsWatchRoot(this.opts.workingDir, os7.homedir())) {
       log.warn(
         "fileWatcher",
         `refusing to watch ${this.opts.workingDir} \u2014 looks like a Windows user-profile or system path. Run codeam from your project folder to enable file change emission.`
@@ -7059,7 +7242,7 @@ var FileWatcherService = class {
   }
   async emitForFile(absPath, changeType) {
     if (this.stopped) return;
-    const fileDir = path5.dirname(absPath);
+    const fileDir = path6.dirname(absPath);
     let gitRoot = this.gitRootByDir.get(fileDir);
     if (gitRoot === void 0) {
       gitRoot = findGitRoot(fileDir);
@@ -7072,19 +7255,19 @@ var FileWatcherService = class {
       );
       return;
     }
-    const relPathInRepo = path5.relative(gitRoot, absPath);
+    const relPathInRepo = path6.relative(gitRoot, absPath);
     if (!relPathInRepo || relPathInRepo.startsWith("..")) return;
     const matcher = this.getGitIgnoreMatcher(gitRoot);
     if (matcher && matcher.ignores(relPathInRepo)) {
       log.trace(
         "fileWatcher",
-        `${relPathInRepo} ignored by ${path5.basename(gitRoot)}/.gitignore \u2014 suppressing emit`
+        `${relPathInRepo} ignored by ${path6.basename(gitRoot)}/.gitignore \u2014 suppressing emit`
       );
       return;
     }
     this.opts.onRepoDirty?.(gitRoot);
-    const repoPath = path5.relative(this.opts.workingDir, gitRoot);
-    const repoName = path5.basename(gitRoot);
+    const repoPath = path6.relative(this.opts.workingDir, gitRoot);
+    const repoName = path6.basename(gitRoot);
     let diffText = "";
     let fileStatus = "modified";
     if (changeType === "unlink") {
@@ -7259,7 +7442,7 @@ var FileWatcherService = class {
   collectGitignoreFiles(repoRoot, dir, matcher) {
     let entries;
     try {
-      entries = fs5.readdirSync(dir, { withFileTypes: true });
+      entries = fs6.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -7268,16 +7451,16 @@ var FileWatcherService = class {
     );
     if (gitignoreEntry) {
       try {
-        const body = fs5.readFileSync(path5.join(dir, ".gitignore"), "utf8");
-        const rel = path5.relative(repoRoot, dir).replace(/\\/g, "/");
+        const body = fs6.readFileSync(path6.join(dir, ".gitignore"), "utf8");
+        const rel = path6.relative(repoRoot, dir).replace(/\\/g, "/");
         const prefixed = body.split(/\r?\n/).map((line) => {
           const trimmed = line.trim();
           if (!trimmed || trimmed.startsWith("#")) return line;
           if (!rel) return line;
           if (trimmed.startsWith("!")) {
-            return "!" + path5.posix.join(rel, trimmed.slice(1));
+            return "!" + path6.posix.join(rel, trimmed.slice(1));
           }
-          return path5.posix.join(rel, trimmed);
+          return path6.posix.join(rel, trimmed);
         }).join("\n");
         matcher.add(prefixed);
       } catch {
@@ -7286,7 +7469,7 @@ var FileWatcherService = class {
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (entry.name === ".git") continue;
-      const childAbs = path5.join(dir, entry.name);
+      const childAbs = path6.join(dir, entry.name);
       if (isIgnoredFilePath(childAbs)) continue;
       this.collectGitignoreFiles(repoRoot, childAbs, matcher);
     }
@@ -7917,76 +8100,76 @@ function closeAllTerminals() {
 }
 
 // src/commands/start/handlers.ts
-var fs44 = __toESM(require("fs"));
-var os37 = __toESM(require("os"));
-var path49 = __toESM(require("path"));
+var fs45 = __toESM(require("fs"));
+var os38 = __toESM(require("os"));
+var path50 = __toESM(require("path"));
 var import_crypto3 = require("crypto");
 var import_child_process22 = require("child_process");
 var import_which2 = __toESM(require("which"));
 
 // src/lib/payload.ts
-var import_zod = require("zod");
-var fileEntrySchema = import_zod.z.object({
-  filename: import_zod.z.string().min(1).max(256),
-  mimeType: import_zod.z.string(),
-  base64: import_zod.z.string()
+var import_zod2 = require("zod");
+var fileEntrySchema = import_zod2.z.object({
+  filename: import_zod2.z.string().min(1).max(256),
+  mimeType: import_zod2.z.string(),
+  base64: import_zod2.z.string()
 });
-var startCommandSchema = import_zod.z.object({
-  prompt: import_zod.z.string().optional(),
-  files: import_zod.z.array(fileEntrySchema).optional(),
-  input: import_zod.z.string().optional(),
-  index: import_zod.z.number().optional(),
-  from: import_zod.z.number().optional(),
-  id: import_zod.z.string().optional(),
-  auto: import_zod.z.boolean().optional(),
+var startCommandSchema = import_zod2.z.object({
+  prompt: import_zod2.z.string().optional(),
+  files: import_zod2.z.array(fileEntrySchema).optional(),
+  input: import_zod2.z.string().optional(),
+  index: import_zod2.z.number().optional(),
+  from: import_zod2.z.number().optional(),
+  id: import_zod2.z.string().optional(),
+  auto: import_zod2.z.boolean().optional(),
   // `read_file` / `write_file` for the mobile + landing mini-IDE modal.
   // `path` is bounded to 4096 chars (a comfortable POSIX path max) so a
   // malformed payload can't blow up the disk-side validator.
-  path: import_zod.z.string().min(1).max(4096).optional(),
-  content: import_zod.z.string().optional(),
+  path: import_zod2.z.string().min(1).max(4096).optional(),
+  content: import_zod2.z.string().optional(),
   // Mini-IDE / project ops. `paths` (plural, strings) is used for
   // git_commit's optional file selection — distinct from `files`
   // (FileEntry[]) used by `start_task` for attachments.
-  query: import_zod.z.string().max(256).optional(),
-  message: import_zod.z.string().max(8e3).optional(),
-  paths: import_zod.z.array(import_zod.z.string().max(4096)).optional(),
+  query: import_zod2.z.string().max(256).optional(),
+  message: import_zod2.z.string().max(8e3).optional(),
+  paths: import_zod2.z.array(import_zod2.z.string().max(4096)).optional(),
   // `show_install_command` — backend pushes the self-hosted install
   // one-liner the user copies onto their own box. DISPLAY-ONLY: the
   // CLI prints it to the terminal and never executes it. Bounded to
   // 8192 chars so a malformed payload can't flood the terminal.
-  command: import_zod.z.string().min(1).max(8192).optional(),
-  side: import_zod.z.enum(["ours", "theirs"]).optional(),
-  limit: import_zod.z.number().int().min(1).max(500).optional(),
+  command: import_zod2.z.string().min(1).max(8192).optional(),
+  side: import_zod2.z.enum(["ours", "theirs"]).optional(),
+  limit: import_zod2.z.number().int().min(1).max(500).optional(),
   // search_files options. `query` is the haystack/needle string,
   // declared above for list_files. The rest mirror VS Code's
   // search panel toggles + the @codeam/ide-core SearchOptions
   // contract.
-  caseSensitive: import_zod.z.boolean().optional(),
-  wholeWord: import_zod.z.boolean().optional(),
-  regex: import_zod.z.boolean().optional(),
-  include: import_zod.z.array(import_zod.z.string().max(512)).max(64).optional(),
-  exclude: import_zod.z.array(import_zod.z.string().max(512)).max(64).optional(),
-  maxResults: import_zod.z.number().int().min(1).max(500).optional(),
+  caseSensitive: import_zod2.z.boolean().optional(),
+  wholeWord: import_zod2.z.boolean().optional(),
+  regex: import_zod2.z.boolean().optional(),
+  include: import_zod2.z.array(import_zod2.z.string().max(512)).max(64).optional(),
+  exclude: import_zod2.z.array(import_zod2.z.string().max(512)).max(64).optional(),
+  maxResults: import_zod2.z.number().int().min(1).max(500).optional(),
   // terminal_open / _write / _resize / _close. `sessionId` is the
   // opaque uuid returned by `terminal_open` and required by every
   // subsequent op. `data` carries keystrokes (any UTF-8 string).
   // `cwd` lets the host pin the spawn directory.
-  sessionId: import_zod.z.string().min(1).max(128).optional(),
-  data: import_zod.z.string().max(64 * 1024).optional(),
-  cwd: import_zod.z.string().max(4096).optional(),
-  cols: import_zod.z.number().int().min(1).max(500).optional(),
-  rows: import_zod.z.number().int().min(1).max(200).optional(),
+  sessionId: import_zod2.z.string().min(1).max(128).optional(),
+  data: import_zod2.z.string().max(64 * 1024).optional(),
+  cwd: import_zod2.z.string().max(4096).optional(),
+  cols: import_zod2.z.number().int().min(1).max(500).optional(),
+  rows: import_zod2.z.number().int().min(1).max(200).optional(),
   // `apply_file_review` (Epic B follow-up — backend pushes this when
   // the user clicks APPROVE_CHANGES / REJECT_CHANGES in the diff
   // drawer). `filePath` is relative to the enclosing git repo; the
   // handler walks up from it to find `.git/` and runs `git add` or
   // `git restore` from there. `action='approved'` stages the edit,
   // `action='rejected'` discards every worktree change on the file.
-  filePath: import_zod.z.string().min(1).max(4096).optional(),
-  action: import_zod.z.enum(["approved", "rejected", "enable", "disable", "status"]).optional(),
+  filePath: import_zod2.z.string().min(1).max(4096).optional(),
+  action: import_zod2.z.enum(["approved", "rejected", "enable", "disable", "status"]).optional(),
   // `headroom_configure` — savings ingest URL delivered from the session
   // when enabling Headroom on-demand. Bounded to 2048 chars.
-  savingsIngestUrl: import_zod.z.string().url().max(2048).optional(),
+  savingsIngestUrl: import_zod2.z.string().url().max(2048).optional(),
   // `request_link_credentials` — backend fires this from the
   // heartbeat handler when it notices the user is running an agent
   // they haven't vaulted yet. Also reused by `get_context` /
@@ -8002,7 +8185,7 @@ var startCommandSchema = import_zod.z.object({
   // Without nullable() zod rejects the whole payload, the dispatcher
   // logs "Ignoring malformed list_models payload" and the model
   // picker / context never load.
-  agentId: import_zod.z.string().max(64).nullable().optional(),
+  agentId: import_zod2.z.string().max(64).nullable().optional(),
   // `request_ai_summary` / `request_ai_insight` — backend fires
   // these on turn-end (+ file selection) when LinkedAgent.
   // aiInsightsEnabled is true. The CLI spawns the agent in
@@ -8016,12 +8199,12 @@ var startCommandSchema = import_zod.z.object({
   // unchanged on the result POST so the backend doesn't have to
   // recompute (numbers came from file_changes; the agent only
   // writes the narrative).
-  turnId: import_zod.z.string().max(128).optional(),
-  fileChangeId: import_zod.z.string().max(128).optional(),
-  stats: import_zod.z.object({
-    added: import_zod.z.number().int(),
-    removed: import_zod.z.number().int(),
-    complexityShift: import_zod.z.number().int()
+  turnId: import_zod2.z.string().max(128).optional(),
+  fileChangeId: import_zod2.z.string().max(128).optional(),
+  stats: import_zod2.z.object({
+    added: import_zod2.z.number().int(),
+    removed: import_zod2.z.number().int(),
+    complexityShift: import_zod2.z.number().int()
   }).optional(),
   // `preview_start` carries the agent-detected `PreviewDetection`
   // shape from the mobile / web confirmation sheet. Mirrors
@@ -8030,23 +8213,23 @@ var startCommandSchema = import_zod.z.object({
   // running against a newer backend that adds optional fields still
   // accepts the payload; the handler validates the shape it needs
   // before spawning.
-  detection: import_zod.z.object({
-    framework: import_zod.z.string().max(64),
-    command: import_zod.z.string().min(1).max(256),
-    args: import_zod.z.array(import_zod.z.string().max(1024)).max(64),
-    port: import_zod.z.number().int().min(1).max(65535),
-    ready_pattern: import_zod.z.string().min(1).max(4096),
-    env: import_zod.z.record(import_zod.z.string(), import_zod.z.string().max(8192)).optional(),
+  detection: import_zod2.z.object({
+    framework: import_zod2.z.string().max(64),
+    command: import_zod2.z.string().min(1).max(256),
+    args: import_zod2.z.array(import_zod2.z.string().max(1024)).max(64),
+    port: import_zod2.z.number().int().min(1).max(65535),
+    ready_pattern: import_zod2.z.string().min(1).max(4096),
+    env: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string().max(8192)).optional(),
     // The agent emits entries as either {cmd,args} objects OR bare command
     // strings ("npx prisma generate"). Accept both and normalize strings to
     // {cmd,args} so a string entry doesn't reject the whole detection (which
     // would silently drop the preview) and downstream always gets objects.
-    setup_commands: import_zod.z.array(
-      import_zod.z.union([
-        import_zod.z.string().min(1).max(1024),
-        import_zod.z.object({
-          cmd: import_zod.z.string().min(1).max(256),
-          args: import_zod.z.array(import_zod.z.string().max(1024)).max(64)
+    setup_commands: import_zod2.z.array(
+      import_zod2.z.union([
+        import_zod2.z.string().min(1).max(1024),
+        import_zod2.z.object({
+          cmd: import_zod2.z.string().min(1).max(256),
+          args: import_zod2.z.array(import_zod2.z.string().max(1024)).max(64)
         })
       ]).transform((entry) => {
         if (typeof entry !== "string") return entry;
@@ -8054,15 +8237,15 @@ var startCommandSchema = import_zod.z.object({
         return { cmd: parts[0] ?? "", args: parts.slice(1) };
       })
     ).max(32).optional(),
-    notes: import_zod.z.string().max(4096).nullable().optional()
+    notes: import_zod2.z.string().max(4096).nullable().optional()
   }).optional(),
   // `env_write` carries the full desired set of environment variables
   // for the project `.env`. Bounded so a malformed payload can't flood
   // the disk-side serializer. `env_read` / `preview_restart` send no payload.
-  vars: import_zod.z.array(
-    import_zod.z.object({
-      key: import_zod.z.string().min(1).max(256),
-      value: import_zod.z.string().max(32768)
+  vars: import_zod2.z.array(
+    import_zod2.z.object({
+      key: import_zod2.z.string().min(1).max(256),
+      value: import_zod2.z.string().max(32768)
     })
   ).max(512).optional()
 });
@@ -8072,8 +8255,8 @@ function parsePayload2(schema, raw) {
 }
 
 // src/services/file-ops.service.ts
-var fs6 = __toESM(require("fs/promises"));
-var path7 = __toESM(require("path"));
+var fs7 = __toESM(require("fs/promises"));
+var path8 = __toESM(require("path"));
 var MAX_FILE_BYTES = 5 * 1024 * 1024;
 var MAX_WALK_DEPTH = 6;
 var MAX_VISITED_DIRS = 5e3;
@@ -8108,12 +8291,12 @@ var SUBDIR_IGNORE = /* @__PURE__ */ new Set([
   "__pycache__"
 ]);
 function isUnder(parent, candidate) {
-  const rel = path7.relative(parent, candidate);
-  return rel === "" || !rel.startsWith("..") && !path7.isAbsolute(rel);
+  const rel = path8.relative(parent, candidate);
+  return rel === "" || !rel.startsWith("..") && !path8.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;
@@ -8126,13 +8309,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 = path7.join(dir, e.name);
+    const full = path8.join(dir, e.name);
     if (needleVariants.some((needle) => full.endsWith(needle))) {
       ctx.matches.push(full);
       if (ctx.matches.length >= ctx.cap) return;
@@ -8142,21 +8325,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(path7.join(dir, e.name), needleVariants, depth + 1, ctx);
+    await walkForSuffix(path8.join(dir, e.name), needleVariants, depth + 1, ctx);
     if (ctx.matches.length >= ctx.cap) return;
   }
 }
 async function findFile(rawPath) {
   const cwd = process.cwd();
-  if (path7.isAbsolute(rawPath)) {
-    const abs = path7.normalize(rawPath);
+  if (path8.isAbsolute(rawPath)) {
+    const abs = path8.normalize(rawPath);
     if (isUnder(cwd, abs) && await isExistingFile(abs)) return abs;
   }
-  const direct = path7.resolve(cwd, rawPath);
+  const direct = path8.resolve(cwd, rawPath);
   if (isUnder(cwd, direct) && await isExistingFile(direct)) return direct;
-  const normalized = path7.normalize(rawPath).replace(/^[./\\]+/, "");
+  const normalized = path8.normalize(rawPath).replace(/^[./\\]+/, "");
   const needles = [
-    `${path7.sep}${normalized}`,
+    `${path8.sep}${normalized}`,
     `/${normalized}`
   ].filter((v, i, a) => a.indexOf(v) === i);
   const ctx = { visited: 0, matches: [], cap: 16 };
@@ -8170,7 +8353,7 @@ async function findWriteTarget(rawPath) {
   const found = await findFile(rawPath);
   if (found) return found;
   const cwd = process.cwd();
-  const fallback = path7.isAbsolute(rawPath) ? path7.normalize(rawPath) : path7.resolve(cwd, rawPath);
+  const fallback = path8.isAbsolute(rawPath) ? path8.normalize(rawPath) : path8.resolve(cwd, rawPath);
   if (!isUnder(cwd, fallback)) return null;
   return fallback;
 }
@@ -8187,11 +8370,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." };
     }
@@ -8210,8 +8393,8 @@ async function writeProjectFile(rawPath, content) {
     if (Buffer.byteLength(content, "utf-8") > MAX_FILE_BYTES) {
       return { error: "Content too large." };
     }
-    await fs6.mkdir(path7.dirname(abs), { recursive: true });
-    await fs6.writeFile(abs, content, "utf-8");
+    await fs7.mkdir(path8.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";
@@ -8222,8 +8405,8 @@ async function writeProjectFile(rawPath, content) {
 // src/services/project-ops.service.ts
 var import_child_process5 = require("child_process");
 var import_util = require("util");
-var fs7 = __toESM(require("fs/promises"));
-var path8 = __toESM(require("path"));
+var fs8 = __toESM(require("fs/promises"));
+var path9 = __toESM(require("path"));
 var execFileP = (0, import_util.promisify)(import_child_process5.execFile);
 var PROJECT_IGNORE = /* @__PURE__ */ new Set([
   "node_modules",
@@ -8271,7 +8454,7 @@ async function listProjectFiles(opts = {}) {
     }
     let entries = [];
     try {
-      entries = await fs7.readdir(dir, { withFileTypes: true });
+      entries = await fs8.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -8281,18 +8464,18 @@ async function listProjectFiles(opts = {}) {
         return;
       }
       if (PROJECT_IGNORE.has(e.name)) continue;
-      const full = path8.join(dir, e.name);
+      const full = path9.join(dir, e.name);
       if (e.isDirectory()) {
         if (depth >= 12) continue;
         await walk(full, depth + 1);
       } else if (e.isFile()) {
-        const rel = path8.relative(root, full);
+        const rel = path9.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 {
         }
@@ -8394,8 +8577,8 @@ async function gitStatus(cwd) {
   let hasMergeInProgress = false;
   try {
     const gitDir = (await git(["rev-parse", "--git-dir"], root)).stdout.trim();
-    const mergeHead = path8.isAbsolute(gitDir) ? path8.join(gitDir, "MERGE_HEAD") : path8.join(root, gitDir, "MERGE_HEAD");
-    await fs7.access(mergeHead);
+    const mergeHead = path9.isAbsolute(gitDir) ? path9.join(gitDir, "MERGE_HEAD") : path9.join(root, gitDir, "MERGE_HEAD");
+    await fs8.access(mergeHead);
     hasMergeInProgress = true;
   } catch {
   }
@@ -8541,7 +8724,7 @@ async function jsSearchFiles(opts, cwd, cap) {
     }
     let content = "";
     try {
-      content = await fs7.readFile(path8.join(cwd, f.path), "utf8");
+      content = await fs8.readFile(path9.join(cwd, f.path), "utf8");
     } catch {
       continue;
     }
@@ -8618,14 +8801,14 @@ function formatRemaining(expiresAt) {
 
 // src/services/apply-file-review.service.ts
 var import_child_process6 = require("child_process");
-var fs8 = __toESM(require("fs"));
-var path9 = __toESM(require("path"));
+var fs9 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
 async function applyFileReview(workingDir, filePath, action) {
-  if (filePath.includes("..") || path9.isAbsolute(filePath)) {
+  if (filePath.includes("..") || path10.isAbsolute(filePath)) {
     return { ok: false, action, filePath, error: "invalid file path" };
   }
-  const absFile = path9.resolve(workingDir, filePath);
-  const repoRoot = findGitRoot2(path9.dirname(absFile));
+  const absFile = path10.resolve(workingDir, filePath);
+  const repoRoot = findGitRoot2(path10.dirname(absFile));
   if (!repoRoot) {
     return {
       ok: false,
@@ -8634,7 +8817,7 @@ async function applyFileReview(workingDir, filePath, action) {
       error: `no enclosing git repo for ${filePath}`
     };
   }
-  const relInRepo = path9.relative(repoRoot, absFile);
+  const relInRepo = path10.relative(repoRoot, absFile);
   if (!relInRepo || relInRepo.startsWith("..")) {
     return { ok: false, action, filePath, error: "path escapes repo root" };
   }
@@ -8683,17 +8866,17 @@ function runGit2(cwd, args2) {
   });
 }
 function findGitRoot2(startDir) {
-  let dir = path9.resolve(startDir);
+  let dir = path10.resolve(startDir);
   const seen = /* @__PURE__ */ new Set();
   for (let i = 0; i < 256; i++) {
     if (seen.has(dir)) return null;
     seen.add(dir);
     try {
-      const stat3 = fs8.statSync(path9.join(dir, ".git"), { throwIfNoEntry: false });
+      const stat3 = fs9.statSync(path10.join(dir, ".git"), { throwIfNoEntry: false });
       if (stat3 && (stat3.isDirectory() || stat3.isFile())) return dir;
     } catch {
     }
-    const parent = path9.dirname(dir);
+    const parent = path10.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -8702,8 +8885,8 @@ function findGitRoot2(startDir) {
 
 // src/commands/link.ts
 var import_node_crypto5 = require("crypto");
-var fs26 = __toESM(require("fs"));
-var path31 = __toESM(require("path"));
+var fs27 = __toESM(require("fs"));
+var path32 = __toESM(require("path"));
 var import_chokidar = __toESM(require("chokidar"));
 var import_picocolors2 = __toESM(require("picocolors"));
 
@@ -8727,7 +8910,7 @@ __export(dist_exports, {
   S_ERROR: () => ge,
   S_INFO: () => he,
   S_PASSWORD_MASK: () => xe,
-  S_RADIO_ACTIVE: () => z3,
+  S_RADIO_ACTIVE: () => z4,
   S_RADIO_INACTIVE: () => H2,
   S_STEP_ACTIVE: () => _e,
   S_STEP_CANCEL: () => oe,
@@ -9206,7 +9389,7 @@ function w(r, t2) {
   const e = r;
   e.isTTY && e.setRawMode(t2);
 }
-function z2({ input: r = import_node_process.stdin, output: t2 = import_node_process.stdout, overwrite: e = true, hideCursor: s = true } = {}) {
+function z3({ input: r = import_node_process.stdin, output: t2 = import_node_process.stdout, overwrite: e = true, hideCursor: s = true } = {}) {
   const i = _.createInterface({ input: r, output: t2, prompt: "", tabSize: 1 });
   _.emitKeypressEvents(r, i), r instanceof import_node_tty.ReadStream && r.isTTY && r.setRawMode(true);
   const n = (o, { name: a, sequence: h }) => {
@@ -9818,7 +10001,7 @@ var d2 = w2("\u2502", "|");
 var E2 = w2("\u2514", "\u2014");
 var Ie = w2("\u2510", "T");
 var Ee = w2("\u2518", "\u2014");
-var z3 = w2("\u25CF", ">");
+var z4 = w2("\u25CF", ">");
 var H2 = w2("\u25CB", " ");
 var te = w2("\u25FB", "[\u2022]");
 var U = w2("\u25FC", "[+]");
@@ -9910,7 +10093,7 @@ var Ae = (e) => new H({ options: e.options, initialValue: e.initialValue ? [e.in
     const $2 = Me(a), y2 = a.hint && a.value === this.focusedValue ? (0, import_node_util2.styleText)("dim", ` (${a.hint})`) : "";
     switch (l) {
       case "active":
-        return `${(0, import_node_util2.styleText)("green", z3)} ${$2}${y2}`;
+        return `${(0, import_node_util2.styleText)("green", z4)} ${$2}${y2}`;
       case "inactive":
         return `${(0, import_node_util2.styleText)("dim", H2)} ${(0, import_node_util2.styleText)("dim", $2)}`;
       case "disabled":
@@ -10023,9 +10206,9 @@ ${(0, import_node_util2.styleText)("gray", d2)}` : ""}`;
       }
       default: {
         const l = r ? `${(0, import_node_util2.styleText)("cyan", d2)}  ` : "", $2 = r ? (0, import_node_util2.styleText)("cyan", E2) : "";
-        return `${c2}${l}${this.value ? `${(0, import_node_util2.styleText)("green", z3)} ${i}` : `${(0, import_node_util2.styleText)("dim", H2)} ${(0, import_node_util2.styleText)("dim", i)}`}${e.vertical ? r ? `
+        return `${c2}${l}${this.value ? `${(0, import_node_util2.styleText)("green", z4)} ${i}` : `${(0, import_node_util2.styleText)("dim", H2)} ${(0, import_node_util2.styleText)("dim", i)}`}${e.vertical ? r ? `
 ${(0, import_node_util2.styleText)("cyan", d2)}  ` : `
-` : ` ${(0, import_node_util2.styleText)("dim", "/")} `}${this.value ? `${(0, import_node_util2.styleText)("dim", H2)} ${(0, import_node_util2.styleText)("dim", s)}` : `${(0, import_node_util2.styleText)("green", z3)} ${s}`}
+` : ` ${(0, import_node_util2.styleText)("dim", "/")} `}${this.value ? `${(0, import_node_util2.styleText)("dim", H2)} ${(0, import_node_util2.styleText)("dim", s)}` : `${(0, import_node_util2.styleText)("green", z4)} ${s}`}
 ${$2}
 `;
       }
@@ -10356,7 +10539,7 @@ var fe = ({ indicator: e = "dots", onCancel: i, output: s = process.stdout, canc
     const A2 = (performance.now() - _2) / 1e3, k2 = Math.floor(A2 / 60), L2 = Math.floor(A2 % 60);
     return k2 > 0 ? `[${k2}m ${L2}s]` : `[${L2}s]`;
   }, D2 = a.withGuide ?? u.withGuide, ie = (_2 = "") => {
-    p2 = true, $2 = z2({ output: s }), g = R2(_2), h = performance.now(), D2 && s.write(`${(0, import_node_util2.styleText)("gray", d2)}
+    p2 = true, $2 = z3({ output: s }), g = R2(_2), h = performance.now(), D2 && s.write(`${(0, import_node_util2.styleText)("gray", d2)}
 `);
     let A2 = 0, k2 = 0;
     x(), y2 = setInterval(() => {
@@ -10427,7 +10610,7 @@ var _t = (e) => {
       case "selected":
         return `${re(u2, (n) => (0, import_node_util2.styleText)("dim", n))}`;
       case "active":
-        return `${(0, import_node_util2.styleText)("green", z3)} ${u2}${s.hint ? ` ${(0, import_node_util2.styleText)("dim", `(${s.hint})`)}` : ""}`;
+        return `${(0, import_node_util2.styleText)("green", z4)} ${u2}${s.hint ? ` ${(0, import_node_util2.styleText)("dim", `(${s.hint})`)}` : ""}`;
       case "cancelled":
         return `${re(u2, (n) => (0, import_node_util2.styleText)(["strikethrough", "dim"], n))}`;
       default:
@@ -10758,19 +10941,19 @@ function parseFrame(frame, dispatch) {
 }
 
 // src/os/posix.ts
-var fs10 = __toESM(require("fs"));
-var os8 = __toESM(require("os"));
-var path12 = __toESM(require("path"));
+var fs11 = __toESM(require("fs"));
+var os9 = __toESM(require("os"));
+var path13 = __toESM(require("path"));
 var import_node_crypto2 = require("crypto");
 
 // src/os/strategy.ts
-var path10 = __toESM(require("path"));
+var path11 = __toESM(require("path"));
 function findInPathFor(name, opts) {
-  const dirs = (process.env.PATH ?? "").split(path10.delimiter).filter(Boolean);
+  const dirs = (process.env.PATH ?? "").split(path11.delimiter).filter(Boolean);
   const candidates = opts.candidates(name);
   for (const dir of dirs) {
     for (const candidate of candidates) {
-      const full = path10.join(dir, candidate);
+      const full = path11.join(dir, candidate);
       try {
         opts.accessSync(full, opts.accessFlag);
         return full;
@@ -10783,9 +10966,9 @@ function findInPathFor(name, opts) {
 
 // src/services/pty/unix.strategy.ts
 var import_child_process7 = require("child_process");
-var fs9 = __toESM(require("fs"));
-var os7 = __toESM(require("os"));
-var path11 = __toESM(require("path"));
+var fs10 = __toESM(require("fs"));
+var os8 = __toESM(require("os"));
+var path12 = __toESM(require("path"));
 
 // src/services/pty/types.ts
 function findInPath(name) {
@@ -10867,8 +11050,8 @@ var UnixPtyStrategy = class {
     }
     const cols = process.stdout.columns || 220;
     const rows = process.stdout.rows || 50;
-    this.helperPath = path11.join(os7.tmpdir(), "codeam-pty-helper.py");
-    fs9.writeFileSync(this.helperPath, PYTHON_PTY_HELPER, { mode: 420 });
+    this.helperPath = path12.join(os8.tmpdir(), "codeam-pty-helper.py");
+    fs10.writeFileSync(this.helperPath, PYTHON_PTY_HELPER, { mode: 420 });
     this.proc = (0, import_child_process7.spawn)(python, [this.helperPath, cmd, ...args2], {
       stdio: ["pipe", "pipe", "inherit"],
       cwd,
@@ -10997,7 +11180,7 @@ var UnixPtyStrategy = class {
   removeTempFile() {
     if (this.helperPath) {
       try {
-        fs9.unlinkSync(this.helperPath);
+        fs10.unlinkSync(this.helperPath);
       } catch {
       }
       this.helperPath = null;
@@ -11008,11 +11191,11 @@ var UnixPtyStrategy = class {
 // src/os/posix.ts
 var PosixOsStrategy = class {
   homeDir() {
-    return os8.homedir();
+    return os9.homedir();
   }
   scratchPath(prefix) {
     const tag = `${process.pid}-${(0, import_node_crypto2.randomBytes)(4).toString("hex")}`;
-    return path12.join(os8.tmpdir(), `${prefix}-${tag}`);
+    return path13.join(os9.tmpdir(), `${prefix}-${tag}`);
   }
   devNull() {
     return "/dev/null";
@@ -11020,8 +11203,8 @@ var PosixOsStrategy = class {
   findInPath(name) {
     return findInPathFor(name, {
       candidates: () => [name],
-      accessFlag: fs10.constants.X_OK,
-      accessSync: fs10.accessSync
+      accessFlag: fs11.constants.X_OK,
+      accessSync: fs11.accessSync
     });
   }
   augmentPath(dirs) {
@@ -11049,15 +11232,15 @@ var LinuxOsStrategy = class extends PosixOsStrategy {
 };
 
 // src/os/win32.ts
-var fs11 = __toESM(require("fs"));
-var os9 = __toESM(require("os"));
-var path14 = __toESM(require("path"));
+var fs12 = __toESM(require("fs"));
+var os10 = __toESM(require("os"));
+var path15 = __toESM(require("path"));
 var import_node_crypto3 = require("crypto");
 
 // src/services/pty/windows-conpty.strategy.ts
-var path13 = __toESM(require("path"));
+var path14 = __toESM(require("path"));
 function loadNodePty2() {
-  const vendoredPath = path13.join(__dirname, "vendor", "node-pty");
+  const vendoredPath = path14.join(__dirname, "vendor", "node-pty");
   try {
     return require(vendoredPath);
   } catch (vendorErr) {
@@ -11243,25 +11426,25 @@ var WINDOWS_EXEC_EXTS = [".exe", ".cmd", ".bat", ".ps1"];
 var Win32OsStrategy = class {
   id = "win32";
   homeDir() {
-    return os9.homedir();
+    return os10.homedir();
   }
   scratchPath(prefix) {
     const tag = `${process.pid}-${(0, import_node_crypto3.randomBytes)(4).toString("hex")}`;
-    return path14.join(os9.tmpdir(), `${prefix}-${tag}`);
+    return path15.join(os10.tmpdir(), `${prefix}-${tag}`);
   }
   devNull() {
     return "NUL";
   }
   findInPath(name) {
-    const hasExt = path14.extname(name).length > 0;
+    const hasExt = path15.extname(name).length > 0;
     return findInPathFor(name, {
       candidates: (n) => hasExt ? [n] : [...WINDOWS_EXEC_EXTS.map((ext) => `${n}${ext}`), n],
       // Windows has no Unix execute bit; presence + matching extension
       // IS the executability check. X_OK on Windows is a no-op alias
       // for F_OK at the libuv layer anyway, but F_OK makes intent
       // explicit.
-      accessFlag: fs11.constants.F_OK,
-      accessSync: fs11.accessSync
+      accessFlag: fs12.constants.F_OK,
+      accessSync: fs12.accessSync
     });
   }
   augmentPath(dirs) {
@@ -11298,7 +11481,7 @@ var Win32OsStrategy = class {
     return `"${escaped.replace(/[&|^<>()%!]/g, "^$&")}"`;
   }
   buildLaunch(binaryPath, extraArgs = []) {
-    const ext = path14.extname(binaryPath).toLowerCase();
+    const ext = path15.extname(binaryPath).toLowerCase();
     if (ext === ".cmd" || ext === ".bat") {
       return { cmd: "cmd.exe", args: ["/c", binaryPath, ...extraArgs] };
     }
@@ -11353,28 +11536,28 @@ function buildForPlatform(platform3) {
 var import_node_crypto4 = require("crypto");
 
 // src/agents/claude/resolver.ts
-function buildClaudeLaunch(extraArgs = [], os44 = createOsStrategy()) {
-  const found = os44.findInPath("claude") ?? os44.findInPath("claude-code");
+function buildClaudeLaunch(extraArgs = [], os45 = createOsStrategy()) {
+  const found = os45.findInPath("claude") ?? os45.findInPath("claude-code");
   if (!found) return null;
-  return os44.buildLaunch(found, extraArgs);
+  return os45.buildLaunch(found, extraArgs);
 }
 
 // src/agents/claude/installer.ts
 var import_child_process9 = require("child_process");
-var path15 = __toESM(require("path"));
-var os10 = __toESM(require("os"));
+var path16 = __toESM(require("path"));
+var os11 = __toESM(require("os"));
 function probeInstallDirs() {
-  const home = os10.homedir();
+  const home = os11.homedir();
   if (process.platform === "win32") {
     return [
-      path15.join(home, ".claude", "local"),
-      path15.join(home, "AppData", "Local", "AnthropicClaude"),
-      path15.join(home, "AppData", "Local", "Programs", "AnthropicClaude")
+      path16.join(home, ".claude", "local"),
+      path16.join(home, "AppData", "Local", "AnthropicClaude"),
+      path16.join(home, "AppData", "Local", "Programs", "AnthropicClaude")
     ];
   }
   return [
-    path15.join(home, ".local", "bin"),
-    path15.join(home, ".claude", "local"),
+    path16.join(home, ".local", "bin"),
+    path16.join(home, ".claude", "local"),
     "/usr/local/bin"
   ];
 }
@@ -11383,7 +11566,7 @@ function isAvailable() {
 }
 function augmentPath() {
   const dirs = probeInstallDirs();
-  const sep7 = path15.delimiter;
+  const sep7 = path16.delimiter;
   const current = process.env.PATH ?? "";
   const existing = new Set(current.split(sep7).filter(Boolean));
   const additions = dirs.filter((d3) => !existing.has(d3));
@@ -11441,15 +11624,15 @@ async function ensureClaudeInstalled() {
 }
 
 // src/agents/claude/link.ts
-var import_node_child_process2 = require("child_process");
+var import_node_child_process3 = require("child_process");
 
 // src/agents/claude/local-token.ts
-var import_node_child_process = require("child_process");
-var fs12 = __toESM(require("fs"));
-var os11 = __toESM(require("os"));
-var path16 = __toESM(require("path"));
+var import_node_child_process2 = require("child_process");
+var fs13 = __toESM(require("fs"));
+var os12 = __toESM(require("os"));
+var path17 = __toESM(require("path"));
 var import_node_util3 = require("util");
-var execFileP2 = (0, import_node_util3.promisify)(import_node_child_process.execFile);
+var execFileP2 = (0, import_node_util3.promisify)(import_node_child_process2.execFile);
 var KEYCHAIN_SERVICE_NAMES = [
   "Claude Code-credentials",
   "claude-code-credentials",
@@ -11457,17 +11640,17 @@ var KEYCHAIN_SERVICE_NAMES = [
   "Anthropic Claude"
 ];
 function claudeCredentialsPaths() {
-  const home = os11.homedir();
+  const home = os12.homedir();
   return [
-    path16.join(home, ".claude", ".credentials.json"),
-    path16.join(home, ".config", "claude", ".credentials.json")
+    path17.join(home, ".claude", ".credentials.json"),
+    path17.join(home, ".config", "claude", ".credentials.json")
   ];
 }
 async function extractLocalClaudeToken() {
   const agentState = readClaudeAgentState();
   for (const flat of claudeCredentialsPaths()) {
-    if (!fs12.existsSync(flat)) continue;
-    const credential = fs12.readFileSync(flat, "utf8").trim();
+    if (!fs13.existsSync(flat)) continue;
+    const credential = fs13.readFileSync(flat, "utf8").trim();
     if (credential.length > 0) {
       return { method: "oauth", credential, source: "flat-file", agentState };
     }
@@ -11492,10 +11675,10 @@ async function extractLocalClaudeToken() {
 }
 function readClaudeAgentState() {
   const STATE_MAX_BYTES = 256 * 1024;
-  const candidate = path16.join(os11.homedir(), ".claude.json");
+  const candidate = path17.join(os12.homedir(), ".claude.json");
   try {
-    if (!fs12.existsSync(candidate)) return void 0;
-    const buf = fs12.readFileSync(candidate);
+    if (!fs13.existsSync(candidate)) return void 0;
+    const buf = fs13.readFileSync(candidate);
     if (buf.length === 0 || buf.length > STATE_MAX_BYTES) return void 0;
     const text = buf.toString("utf8").trim();
     return text.length > 0 ? text : void 0;
@@ -11542,7 +11725,7 @@ function extractSetupTokenFromOutput(output) {
 }
 function captureClaudeSetupToken() {
   return new Promise((resolve7, reject) => {
-    const child = (0, import_node_child_process2.spawn)("claude", ["setup-token"], {
+    const child = (0, import_node_child_process3.spawn)("claude", ["setup-token"], {
       stdio: ["inherit", "pipe", "inherit"]
     });
     let out2 = "";
@@ -11570,7 +11753,7 @@ function claudeLoginLauncher() {
   return {
     ensureInstalled: ensureClaudeInstalled,
     launch() {
-      const child = (0, import_node_child_process2.spawn)("claude", [], { stdio: ["pipe", "inherit", "inherit"] });
+      const child = (0, import_node_child_process3.spawn)("claude", [], { stdio: ["pipe", "inherit", "inherit"] });
       child.stdin?.write("/login\n");
       return child;
     },
@@ -11582,9 +11765,9 @@ function claudeLoginLauncher() {
 }
 
 // src/agents/claude/quota.ts
-var fs13 = __toESM(require("fs"));
-var os12 = __toESM(require("os"));
-var path17 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
+var os13 = __toESM(require("os"));
+var path18 = __toESM(require("path"));
 var import_child_process10 = require("child_process");
 var HELPER_SCRIPT = `import os,pty,sys,select,signal,struct,fcntl,termios,errno
 m,s=pty.openpty()
@@ -11647,8 +11830,8 @@ async function fetchClaudeQuota() {
       resolve7(null);
       return;
     }
-    const helperPath = path17.join(os12.tmpdir(), "codeam-quota-helper.py");
-    fs13.writeFileSync(helperPath, HELPER_SCRIPT, { mode: 420 });
+    const helperPath = path18.join(os13.tmpdir(), "codeam-quota-helper.py");
+    fs14.writeFileSync(helperPath, HELPER_SCRIPT, { mode: 420 });
     const python = findInPath("python3") ?? findInPath("python");
     if (!python) {
       resolve7(null);
@@ -11675,7 +11858,7 @@ async function fetchClaudeQuota() {
         } catch {
         }
         try {
-          fs13.unlinkSync(helperPath);
+          fs14.unlinkSync(helperPath);
         } catch {
         }
         resolve7(result);
@@ -11768,24 +11951,24 @@ async function spawnAndCapture(cmd, args2, opts = {}) {
 }
 
 // src/agents/claude/history.ts
-var fs14 = __toESM(require("fs"));
-var path18 = __toESM(require("path"));
-var os13 = __toESM(require("os"));
+var fs15 = __toESM(require("fs"));
+var path19 = __toESM(require("path"));
+var os14 = __toESM(require("os"));
 function encodeCwd(cwd) {
   return cwd.replace(/[\\/:]/g, "-");
 }
 function resolveHistoryDir(cwd, projectsRoot) {
-  const root = projectsRoot ?? path18.join(os13.homedir(), ".claude", "projects");
-  const primary = path18.join(root, encodeCwd(cwd));
-  if (fs14.existsSync(primary)) return primary;
+  const root = projectsRoot ?? path19.join(os14.homedir(), ".claude", "projects");
+  const primary = path19.join(root, encodeCwd(cwd));
+  if (fs15.existsSync(primary)) return primary;
   try {
-    const entries = fs14.readdirSync(root, { withFileTypes: true });
+    const entries = fs15.readdirSync(root, { withFileTypes: true });
     const wanted = encodeCwd(cwd);
     for (const e of entries) {
       if (!e.isDirectory()) continue;
       const candidate = e.name.replace(/-+/g, "-");
       if (candidate === wanted.replace(/-+/g, "-")) {
-        return path18.join(root, e.name);
+        return path19.join(root, e.name);
       }
     }
   } catch {
@@ -11797,23 +11980,23 @@ function getCurrentUsage(historyDir, bootTimeMs = 0) {
   const cutoff = bootTimeMs > 0 ? bootTimeMs - GRACE_MS : 0;
   let entries;
   try {
-    entries = fs14.readdirSync(historyDir, { withFileTypes: true });
+    entries = fs15.readdirSync(historyDir, { withFileTypes: true });
   } catch {
     return null;
   }
   const files = entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => {
     try {
-      const stat3 = fs14.statSync(path18.join(historyDir, e.name));
+      const stat3 = fs15.statSync(path19.join(historyDir, e.name));
       return { name: e.name, mtime: stat3.mtimeMs, birthtime: stat3.birthtimeMs };
     } catch {
       return { name: e.name, mtime: 0, birthtime: 0 };
     }
   }).filter((f) => f.birthtime >= cutoff).sort((a, b) => b.mtime - a.mtime);
   if (files.length === 0) return null;
-  const filePath = path18.join(historyDir, files[0].name);
+  const filePath = path19.join(historyDir, files[0].name);
   let raw;
   try {
-    raw = fs14.readFileSync(filePath, "utf8");
+    raw = fs15.readFileSync(filePath, "utf8");
   } catch {
     return null;
   }
@@ -11858,7 +12041,7 @@ function parseHistoryFile(filePath) {
   const out2 = [];
   let raw;
   try {
-    raw = fs14.readFileSync(filePath, "utf8");
+    raw = fs15.readFileSync(filePath, "utf8");
   } catch {
     return out2;
   }
@@ -11903,7 +12086,7 @@ function listResumableSessions(cwd) {
   if (!dir) return [];
   let entries;
   try {
-    entries = fs14.readdirSync(dir, { withFileTypes: true });
+    entries = fs15.readdirSync(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -11911,15 +12094,15 @@ function listResumableSessions(cwd) {
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
     const id = entry.name.slice(0, -".jsonl".length);
-    const filePath = path18.join(dir, entry.name);
+    const filePath = path19.join(dir, entry.name);
     let timestamp = Date.now();
     try {
-      timestamp = fs14.statSync(filePath).mtimeMs;
+      timestamp = fs15.statSync(filePath).mtimeMs;
     } catch {
     }
     let summary = "";
     try {
-      const raw = fs14.readFileSync(filePath, "utf8");
+      const raw = fs15.readFileSync(filePath, "utf8");
       for (const line of raw.split("\n")) {
         if (!line.trim()) continue;
         try {
@@ -11949,8 +12132,8 @@ var ClaudeRuntimeStrategy = class {
   meta = getAgent("claude");
   mode = "interactive";
   os;
-  constructor(os44) {
-    this.os = os44;
+  constructor(os45) {
+    this.os = os45;
   }
   /**
    * Claude Code's react-ink TUI enables bracketed-paste mode at
@@ -12082,24 +12265,24 @@ var ClaudeRuntimeStrategy = class {
 };
 
 // src/agents/claude/deploy.ts
-var fs16 = __toESM(require("fs"));
-var os15 = __toESM(require("os"));
-var path20 = __toESM(require("path"));
+var fs17 = __toESM(require("fs"));
+var os16 = __toESM(require("os"));
+var path21 = __toESM(require("path"));
 
 // src/agents/claude/credentials.ts
 var import_child_process12 = require("child_process");
-var fs15 = __toESM(require("fs"));
-var os14 = __toESM(require("os"));
-var path19 = __toESM(require("path"));
+var fs16 = __toESM(require("fs"));
+var os15 = __toESM(require("os"));
+var path20 = __toESM(require("path"));
 var import_util2 = require("util");
 var execFileP3 = (0, import_util2.promisify)(import_child_process12.execFile);
 async function detectLocalClaudeCredentials() {
-  const localClaudeDir = path19.join(os14.homedir(), ".claude");
-  const flat = path19.join(localClaudeDir, ".credentials.json");
-  if (fs15.existsSync(flat)) {
+  const localClaudeDir = path20.join(os15.homedir(), ".claude");
+  const flat = path20.join(localClaudeDir, ".credentials.json");
+  if (fs16.existsSync(flat)) {
     return { source: "flat-file", description: "~/.claude/.credentials.json" };
   }
-  if (os14.platform() === "darwin") {
+  if (os15.platform() === "darwin") {
     try {
       await execFileP3(
         "security",
@@ -12114,9 +12297,9 @@ async function detectLocalClaudeCredentials() {
   return { source: "none", description: "" };
 }
 async function bridgeClaudeCredentials(provider, workspaceId) {
-  const localClaudeDir = path19.join(os14.homedir(), ".claude");
-  const fileBased = path19.join(localClaudeDir, ".credentials.json");
-  if (fs15.existsSync(fileBased)) {
+  const localClaudeDir = path20.join(os15.homedir(), ".claude");
+  const fileBased = path20.join(localClaudeDir, ".credentials.json");
+  if (fs16.existsSync(fileBased)) {
     return { source: "flat-file", description: "~/.claude/.credentials.json" };
   }
   if (process.platform === "darwin") {
@@ -12208,8 +12391,8 @@ var ClaudeDeployStrategy = class {
       process.exit(1);
     }
     claudeStep.stop("\u2713 Claude CLI installed");
-    const localClaudeDir = path20.join(os15.homedir(), ".claude");
-    const haveLocalClaude = fs16.existsSync(localClaudeDir) && fs16.statSync(localClaudeDir).isDirectory();
+    const localClaudeDir = path21.join(os16.homedir(), ".claude");
+    const haveLocalClaude = fs17.existsSync(localClaudeDir) && fs17.statSync(localClaudeDir).isDirectory();
     if (haveLocalClaude) {
       const copyStep = fe();
       copyStep.start("Copying local Claude config to workspace\u2026");
@@ -12263,10 +12446,10 @@ var ClaudeDeployStrategy = class {
       }
     }
     if (opts.bridged !== "none") {
-      const localClaudeJson = path20.join(os15.homedir(), ".claude.json");
-      if (fs16.existsSync(localClaudeJson)) {
+      const localClaudeJson = path21.join(os16.homedir(), ".claude.json");
+      if (fs17.existsSync(localClaudeJson)) {
         try {
-          const contents = fs16.readFileSync(localClaudeJson);
+          const contents = fs17.readFileSync(localClaudeJson);
           await provider.uploadFile(
             workspaceId,
             "/home/codespace/.claude.json",
@@ -12298,8 +12481,8 @@ var ClaudeDeployStrategy = class {
 };
 
 // src/agents/codex/runtime.ts
-var import_node_child_process4 = require("child_process");
-var path23 = __toESM(require("path"));
+var import_node_child_process5 = require("child_process");
+var path24 = __toESM(require("path"));
 
 // src/agents/codex/history.ts
 var import_node_fs3 = __toESM(require("fs"));
@@ -12556,19 +12739,19 @@ function getCurrentUsage2(historyDir) {
 }
 
 // src/agents/codex/link.ts
-var import_node_child_process3 = require("child_process");
+var import_node_child_process4 = require("child_process");
 
 // src/agents/codex/local-token.ts
-var fs18 = __toESM(require("fs"));
-var os17 = __toESM(require("os"));
-var path22 = __toESM(require("path"));
+var fs19 = __toESM(require("fs"));
+var os18 = __toESM(require("os"));
+var path23 = __toESM(require("path"));
 function codexCredentialsPath() {
-  return path22.join(os17.homedir(), ".codex", "auth.json");
+  return path23.join(os18.homedir(), ".codex", "auth.json");
 }
 async function extractLocalCodexToken() {
   const file = codexCredentialsPath();
-  if (!fs18.existsSync(file)) return null;
-  const credential = fs18.readFileSync(file, "utf8").trim();
+  if (!fs19.existsSync(file)) return null;
+  const credential = fs19.readFileSync(file, "utf8").trim();
   if (credential.length === 0) return null;
   return { method: "oauth", credential, source: "flat-file" };
 }
@@ -12627,11 +12810,11 @@ function codexCredentialLocator() {
 function codexLoginLauncher() {
   return {
     async ensureInstalled() {
-      const os44 = createOsStrategy();
-      return os44.findInPath("codex") !== null;
+      const os45 = createOsStrategy();
+      return os45.findInPath("codex") !== null;
     },
     launch() {
-      return (0, import_node_child_process3.spawn)("codex", ["login"], { stdio: "inherit" });
+      return (0, import_node_child_process4.spawn)("codex", ["login"], { stdio: "inherit" });
     }
   };
 }
@@ -12651,8 +12834,8 @@ var CodexRuntimeStrategy = class {
   meta = getAgent("codex");
   mode = "interactive";
   os;
-  constructor(os44) {
-    this.os = os44;
+  constructor(os45) {
+    this.os = os45;
   }
   async prepareLaunch() {
     let binary = this.os.findInPath("codex");
@@ -12751,12 +12934,12 @@ var CodexRuntimeStrategy = class {
     });
   }
 };
-function resolveNpm(os44) {
-  return os44.id === "win32" ? "npm.cmd" : "npm";
+function resolveNpm(os45) {
+  return os45.id === "win32" ? "npm.cmd" : "npm";
 }
-async function installCodexViaNpm(os44) {
+async function installCodexViaNpm(os45) {
   return new Promise((resolve7, reject) => {
-    const proc = (0, import_node_child_process4.spawn)(resolveNpm(os44), ["install", "-g", "@openai/codex"], {
+    const proc = (0, import_node_child_process5.spawn)(resolveNpm(os45), ["install", "-g", "@openai/codex"], {
       stdio: "inherit"
     });
     proc.on("close", (code) => {
@@ -12773,16 +12956,16 @@ async function installCodexViaNpm(os44) {
     });
   });
 }
-function augmentNpmGlobalBin(os44) {
+function augmentNpmGlobalBin(os45) {
   try {
-    const result = (0, import_node_child_process4.spawnSync)(resolveNpm(os44), ["prefix", "-g"], {
+    const result = (0, import_node_child_process5.spawnSync)(resolveNpm(os45), ["prefix", "-g"], {
       stdio: ["ignore", "pipe", "ignore"]
     });
     if (result.status !== 0) return;
     const prefix = result.stdout.toString().trim();
     if (!prefix) return;
-    const binDir = os44.id === "win32" ? prefix : path23.join(prefix, "bin");
-    os44.augmentPath([binDir]);
+    const binDir = os45.id === "win32" ? prefix : path24.join(prefix, "bin");
+    os45.augmentPath([binDir]);
   } catch {
   }
 }
@@ -12861,14 +13044,14 @@ var CodexDeployStrategy = class {
 };
 
 // src/agents/coderabbit/runtime.ts
-var import_node_child_process7 = require("child_process");
+var import_node_child_process8 = require("child_process");
 
 // src/agents/coderabbit/installer.ts
-var import_node_child_process5 = require("child_process");
+var import_node_child_process6 = require("child_process");
 var INSTALL_URL = "https://cli.coderabbit.ai/install.sh";
-async function ensureCoderabbitInstalled(os44) {
-  if (os44.findInPath("coderabbit")) return true;
-  if (os44.id === "win32") {
+async function ensureCoderabbitInstalled(os45) {
+  if (os45.findInPath("coderabbit")) return true;
+  if (os45.id === "win32") {
     console.error(
       "\n  \u2717 CodeRabbit on Windows requires WSL.\n    Install the CLI inside your WSL distribution\n    (curl -fsSL https://cli.coderabbit.ai/install.sh | sh)\n    then re-run `codeam link coderabbit` from WSL.\n"
     );
@@ -12876,22 +13059,22 @@ async function ensureCoderabbitInstalled(os44) {
   }
   console.log("\n  CodeRabbit CLI not found \u2014 installing via the official script\u2026\n");
   const ok = await new Promise((resolve7) => {
-    const proc = (0, import_node_child_process5.spawn)("sh", ["-c", `curl -fsSL ${INSTALL_URL} | sh`], {
+    const proc = (0, import_node_child_process6.spawn)("sh", ["-c", `curl -fsSL ${INSTALL_URL} | sh`], {
       stdio: "inherit"
     });
     proc.on("close", (code) => resolve7(code === 0));
     proc.on("error", () => resolve7(false));
   });
   if (!ok) return false;
-  os44.augmentPath([`${os44.homeDir()}/.local/bin`, "/opt/homebrew/bin"]);
-  return os44.findInPath("coderabbit") !== null;
+  os45.augmentPath([`${os45.homeDir()}/.local/bin`, "/opt/homebrew/bin"]);
+  return os45.findInPath("coderabbit") !== null;
 }
 
 // src/agents/coderabbit/link.ts
-var import_node_child_process6 = require("child_process");
-var fs20 = __toESM(require("fs"));
-var os19 = __toESM(require("os"));
-var path25 = __toESM(require("path"));
+var import_node_child_process7 = require("child_process");
+var fs21 = __toESM(require("fs"));
+var os20 = __toESM(require("os"));
+var path26 = __toESM(require("path"));
 
 // src/agents/strategy.ts
 function validateNonEmptyCredential(token) {
@@ -12900,12 +13083,12 @@ function validateNonEmptyCredential(token) {
 
 // src/agents/coderabbit/link.ts
 function authPath() {
-  return path25.join(os19.homedir(), ".coderabbit", "auth.json");
+  return path26.join(os20.homedir(), ".coderabbit", "auth.json");
 }
 async function extractLocalCoderabbitToken() {
   const file = authPath();
-  if (!fs20.existsSync(file)) return null;
-  const credential = fs20.readFileSync(file, "utf8").trim();
+  if (!fs21.existsSync(file)) return null;
+  const credential = fs21.readFileSync(file, "utf8").trim();
   if (credential.length === 0) return null;
   return { method: "oauth", credential, source: "flat-file" };
 }
@@ -12919,13 +13102,13 @@ function coderabbitCredentialLocator() {
     validate: validateNonEmptyCredential
   };
 }
-function coderabbitLoginLauncher(os44) {
+function coderabbitLoginLauncher(os45) {
   return {
     async ensureInstalled() {
-      return ensureCoderabbitInstalled(os44);
+      return ensureCoderabbitInstalled(os45);
     },
     launch() {
-      return (0, import_node_child_process6.spawn)("coderabbit", ["login"], { stdio: "inherit" });
+      return (0, import_node_child_process7.spawn)("coderabbit", ["login"], { stdio: "inherit" });
     }
   };
 }
@@ -12945,11 +13128,11 @@ function parseReview(stdout) {
   for (const line of lines) {
     const m = line.match(HUNK_LINE_RE);
     if (!m) continue;
-    const [, path64, lineNo, sevToken, message] = m;
-    if (!path64 || !lineNo || !message) continue;
+    const [, path65, lineNo, sevToken, message] = m;
+    if (!path65 || !lineNo || !message) continue;
     const cleanedMessage = message.trim().replace(/^[*-]\s+/, "");
     hunks.push({
-      path: path64.trim(),
+      path: path65.trim(),
       line: Number(lineNo),
       severity: sevToken ? SEVERITY_MAP[sevToken.toLowerCase()] : void 0,
       message: cleanedMessage
@@ -12968,8 +13151,8 @@ var CoderabbitRuntimeStrategy = class {
   meta = getAgent("coderabbit");
   mode = "batch";
   os;
-  constructor(os44) {
-    this.os = os44;
+  constructor(os45) {
+    this.os = os45;
   }
   getDefaultArgs() {
     return ["review"];
@@ -13010,7 +13193,7 @@ var CoderabbitRuntimeStrategy = class {
     return new Promise((resolve7, reject) => {
       const stdoutBuf = [];
       const stderrBuf = [];
-      const proc = (0, import_node_child_process7.spawn)(launch.cmd, launch.args, {
+      const proc = (0, import_node_child_process8.spawn)(launch.cmd, launch.args, {
         env: { ...process.env, ...launch.env ?? {} },
         stdio: ["ignore", "pipe", "pipe"]
       });
@@ -13037,12 +13220,12 @@ var CoderabbitRuntimeStrategy = class {
 };
 
 // src/agents/cursor/history.ts
-var fs21 = __toESM(require("fs"));
-var os20 = __toESM(require("os"));
-var path26 = __toESM(require("path"));
-var HISTORY_ROOT = path26.join(os20.homedir(), ".cursor", "projects");
+var fs22 = __toESM(require("fs"));
+var os21 = __toESM(require("os"));
+var path27 = __toESM(require("path"));
+var HISTORY_ROOT = path27.join(os21.homedir(), ".cursor", "projects");
 function resolveHistoryDir3(cwd) {
-  if (!fs21.existsSync(HISTORY_ROOT)) return null;
+  if (!fs22.existsSync(HISTORY_ROOT)) return null;
   void cwd;
   return HISTORY_ROOT;
 }
@@ -13054,19 +13237,19 @@ function getCurrentUsage3(_historyDir) {
 }
 
 // src/agents/cursor/link.ts
-var import_node_child_process8 = require("child_process");
+var import_node_child_process9 = require("child_process");
 
 // src/agents/cursor/local-token.ts
-var fs22 = __toESM(require("fs"));
-var os21 = __toESM(require("os"));
-var path27 = __toESM(require("path"));
+var fs23 = __toESM(require("fs"));
+var os22 = __toESM(require("os"));
+var path28 = __toESM(require("path"));
 function cursorCredentialsPath() {
-  return path27.join(os21.homedir(), ".cursor", "auth.json");
+  return path28.join(os22.homedir(), ".cursor", "auth.json");
 }
 async function extractLocalCursorToken() {
   const file = cursorCredentialsPath();
-  if (!fs22.existsSync(file)) return null;
-  const credential = fs22.readFileSync(file, "utf8").trim();
+  if (!fs23.existsSync(file)) return null;
+  const credential = fs23.readFileSync(file, "utf8").trim();
   if (credential.length === 0) return null;
   return { method: "oauth", credential, source: "flat-file" };
 }
@@ -13085,17 +13268,17 @@ function cursorCredentialLocator() {
     validate: validateNonEmptyCredential
   };
 }
-function cursorLoginLauncher(os44) {
+function cursorLoginLauncher(os45) {
   return {
     async ensureInstalled() {
-      if (os44.findInPath("cursor-agent")) return true;
+      if (os45.findInPath("cursor-agent")) return true;
       console.error(
         "\n  \u2717 cursor-agent binary not on PATH.\n    Install Cursor (https://cursor.com/) and ensure the CLI\n    plugin is enabled, then re-run `codeam link cursor`.\n"
       );
       return false;
     },
     launch() {
-      return (0, import_node_child_process8.spawn)("cursor-agent", ["login"], { stdio: "inherit" });
+      return (0, import_node_child_process9.spawn)("cursor-agent", ["login"], { stdio: "inherit" });
     }
   };
 }
@@ -13150,8 +13333,8 @@ var CursorRuntimeStrategy = class {
   meta = getAgent("cursor");
   mode = "interactive";
   os;
-  constructor(os44) {
-    this.os = os44;
+  constructor(os45) {
+    this.os = os45;
   }
   async prepareLaunch() {
     const binary = this.os.findInPath("cursor-agent");
@@ -13230,12 +13413,12 @@ var CursorRuntimeStrategy = class {
 };
 
 // src/agents/aider/history.ts
-var fs23 = __toESM(require("fs"));
-var path28 = __toESM(require("path"));
+var fs24 = __toESM(require("fs"));
+var path29 = __toESM(require("path"));
 var AIDER_HISTORY_FILE = ".aider.chat.history.md";
 function resolveHistoryDir4(cwd) {
-  const candidate = path28.join(cwd, AIDER_HISTORY_FILE);
-  return fs23.existsSync(candidate) ? cwd : null;
+  const candidate = path29.join(cwd, AIDER_HISTORY_FILE);
+  return fs24.existsSync(candidate) ? cwd : null;
 }
 function parseHistoryFile4(_filePath) {
   return [];
@@ -13245,13 +13428,13 @@ function getCurrentUsage4(_historyDir) {
 }
 
 // src/agents/aider/link.ts
-var import_node_child_process9 = require("child_process");
+var import_node_child_process10 = require("child_process");
 
 // src/agents/aider/local-token.ts
-var fs24 = __toESM(require("fs"));
-var os22 = __toESM(require("os"));
-var path29 = __toESM(require("path"));
-var AIDER_CONF_FILE = path29.join(os22.homedir(), ".aider.conf.yml");
+var fs25 = __toESM(require("fs"));
+var os23 = __toESM(require("os"));
+var path30 = __toESM(require("path"));
+var AIDER_CONF_FILE = path30.join(os23.homedir(), ".aider.conf.yml");
 var API_KEY_ENV_VARS = [
   "ANTHROPIC_API_KEY",
   "OPENAI_API_KEY",
@@ -13266,8 +13449,8 @@ async function extractLocalAiderToken() {
       return { method: "api_key", credential: value.trim(), source: "flat-file" };
     }
   }
-  if (fs24.existsSync(AIDER_CONF_FILE)) {
-    const conf = fs24.readFileSync(AIDER_CONF_FILE, "utf8");
+  if (fs25.existsSync(AIDER_CONF_FILE)) {
+    const conf = fs25.readFileSync(AIDER_CONF_FILE, "utf8");
     const match = conf.match(/^api-key:\s*['"]?([^'"\n]+)['"]?\s*$/m);
     if (match) {
       return { method: "api_key", credential: match[1].trim(), source: "flat-file" };
@@ -13290,10 +13473,10 @@ function aiderCredentialLocator() {
     validate: validateNonEmptyCredential
   };
 }
-function aiderLoginLauncher(os44) {
+function aiderLoginLauncher(os45) {
   return {
     async ensureInstalled() {
-      if (os44.findInPath("aider")) return true;
+      if (os45.findInPath("aider")) return true;
       console.error(
         "\n  \u2717 aider binary not on PATH.\n    Install Aider:\n      pip install aider-chat\n    then re-run `codeam link aider`.\n"
       );
@@ -13303,7 +13486,7 @@ function aiderLoginLauncher(os44) {
       console.error(
         "\n  Aider has no interactive login flow.\n    Set ANTHROPIC_API_KEY or OPENAI_API_KEY in your shell,\n    or re-run `codeam link aider --api-key=<your-key>`.\n"
       );
-      return (0, import_node_child_process9.spawn)(os44.id === "win32" ? "cmd.exe" : "sh", os44.id === "win32" ? ["/c", "exit", "0"] : ["-c", "exit 0"], {
+      return (0, import_node_child_process10.spawn)(os45.id === "win32" ? "cmd.exe" : "sh", os45.id === "win32" ? ["/c", "exit", "0"] : ["-c", "exit 0"], {
         stdio: "ignore"
       });
     }
@@ -13375,8 +13558,8 @@ var AiderRuntimeStrategy = class {
   meta = getAgent("aider");
   mode = "interactive";
   os;
-  constructor(os44) {
-    this.os = os44;
+  constructor(os45) {
+    this.os = os45;
   }
   async prepareLaunch() {
     const binary = this.os.findInPath("aider");
@@ -13444,22 +13627,22 @@ var AiderRuntimeStrategy = class {
 };
 
 // src/agents/gemini/link.ts
-var import_node_child_process10 = require("child_process");
+var import_node_child_process11 = require("child_process");
 
 // src/agents/gemini/local-token.ts
-var fs25 = __toESM(require("fs"));
-var os23 = __toESM(require("os"));
-var path30 = __toESM(require("path"));
+var fs26 = __toESM(require("fs"));
+var os24 = __toESM(require("os"));
+var path31 = __toESM(require("path"));
 function geminiCredentialsPath() {
-  return path30.join(os23.homedir(), ".gemini", "oauth_creds.json");
+  return path31.join(os24.homedir(), ".gemini", "oauth_creds.json");
 }
 function geminiCredentialsPaths() {
   return [geminiCredentialsPath()];
 }
 async function extractLocalGeminiToken() {
   const file = geminiCredentialsPath();
-  if (!fs25.existsSync(file)) return null;
-  const credential = fs25.readFileSync(file, "utf8").trim();
+  if (!fs26.existsSync(file)) return null;
+  const credential = fs26.readFileSync(file, "utf8").trim();
   if (credential.length === 0) return null;
   return { method: "oauth", credential, source: "flat-file" };
 }
@@ -13505,11 +13688,11 @@ function geminiCredentialLocator() {
 function geminiLoginLauncher() {
   return {
     async ensureInstalled() {
-      const os44 = createOsStrategy();
-      return os44.findInPath("gemini") !== null;
+      const os45 = createOsStrategy();
+      return os45.findInPath("gemini") !== null;
     },
     launch() {
-      return (0, import_node_child_process10.spawn)("gemini", ["auth", "login"], { stdio: "inherit" });
+      return (0, import_node_child_process11.spawn)("gemini", ["auth", "login"], { stdio: "inherit" });
     }
   };
 }
@@ -13539,8 +13722,8 @@ var GeminiRuntimeStrategy = class {
   meta = getAgent("gemini");
   mode = "interactive";
   os;
-  constructor(os44) {
-    this.os = os44;
+  constructor(os45) {
+    this.os = os45;
   }
   async prepareLaunch() {
     const binary = this.os.findInPath("gemini");
@@ -13639,18 +13822,18 @@ var GeminiRuntimeStrategy = class {
 
 // src/agents/registry.ts
 var runtimeBuilders = {
-  claude: (os44) => new ClaudeRuntimeStrategy(os44),
-  codex: (os44) => new CodexRuntimeStrategy(os44),
-  coderabbit: (os44) => new CoderabbitRuntimeStrategy(os44),
-  cursor: (os44) => new CursorRuntimeStrategy(os44),
-  aider: (os44) => new AiderRuntimeStrategy(os44),
-  gemini: (os44) => new GeminiRuntimeStrategy(os44)
+  claude: (os45) => new ClaudeRuntimeStrategy(os45),
+  codex: (os45) => new CodexRuntimeStrategy(os45),
+  coderabbit: (os45) => new CoderabbitRuntimeStrategy(os45),
+  cursor: (os45) => new CursorRuntimeStrategy(os45),
+  aider: (os45) => new AiderRuntimeStrategy(os45),
+  gemini: (os45) => new GeminiRuntimeStrategy(os45)
 };
 var deployBuilders = {
   claude: () => new ClaudeDeployStrategy(),
   codex: () => new CodexDeployStrategy()
 };
-function createAgentStrategy(agent, os44 = createOsStrategy()) {
+function createAgentStrategy(agent, os45 = createOsStrategy()) {
   if (!AGENT_REGISTRY[agent]?.enabled) {
     throw new Error(
       `Agent "${agent}" is not supported in this codeam-cli version. Upgrade with 'npm i -g codeam-cli@latest'.`
@@ -13660,10 +13843,10 @@ function createAgentStrategy(agent, os44 = createOsStrategy()) {
   if (!build) {
     throw new Error(`No runtime strategy registered for agent "${agent}"`);
   }
-  return build(os44);
+  return build(os45);
 }
-function createInteractiveAgentStrategy(agent, os44 = createOsStrategy()) {
-  const s = createAgentStrategy(agent, os44);
+function createInteractiveAgentStrategy(agent, os45 = createOsStrategy()) {
+  const s = createAgentStrategy(agent, os45);
   if (s.mode !== "interactive") {
     throw new Error(
       `Agent "${agent}" is a batch agent; use createAgentStrategy + .runOneShot for one-shot reviews.`
@@ -13719,7 +13902,7 @@ function parseLinkArgs(args2) {
   if (apiKeyFileArg) {
     const filePath = apiKeyFileArg.slice("--api-key-file=".length);
     try {
-      apiKey = fs26.readFileSync(path31.resolve(filePath), "utf8").trim();
+      apiKey = fs27.readFileSync(path32.resolve(filePath), "utf8").trim();
     } catch (err) {
       throw new Error(`Could not read --api-key-file ${filePath}: ${err.message}`);
     }
@@ -13846,7 +14029,7 @@ async function link(args2 = []) {
     return;
   }
   if (parsed.tokenFile) {
-    const credential = fs26.readFileSync(path31.resolve(parsed.tokenFile), "utf8").trim();
+    const credential = fs27.readFileSync(path32.resolve(parsed.tokenFile), "utf8").trim();
     if (!credential) {
       showError(`--token-file ${parsed.tokenFile} is empty.`);
       process.exit(1);
@@ -14066,15 +14249,15 @@ async function linkDryRunPreflight(ctx) {
 }
 
 // src/commands/host-agent.ts
-var import_node_child_process15 = require("child_process");
-var os30 = __toESM(require("os"));
-var fs33 = __toESM(require("fs"));
-var path37 = __toESM(require("path"));
+var import_node_child_process16 = require("child_process");
+var os31 = __toESM(require("os"));
+var fs34 = __toESM(require("fs"));
+var path38 = __toESM(require("path"));
 
 // src/util/restrict-to-owner.ts
 var import_node_fs5 = __toESM(require("fs"));
 var import_node_os3 = __toESM(require("os"));
-var import_node_child_process11 = require("child_process");
+var import_node_child_process12 = require("child_process");
 var BROAD_WINDOWS_SIDS = [
   "*S-1-1-0",
   "*S-1-5-11",
@@ -14086,7 +14269,7 @@ function restrictToOwner(filePath) {
   try {
     if (process.platform === "win32") {
       const username = import_node_os3.default.userInfo().username;
-      (0, import_node_child_process11.execFileSync)(
+      (0, import_node_child_process12.execFileSync)(
         "icacls",
         [
           filePath,
@@ -14105,13 +14288,13 @@ function restrictToOwner(filePath) {
 }
 
 // src/commands/host/host-client.ts
-var fs28 = __toESM(require("fs"));
-var os25 = __toESM(require("os"));
-var path32 = __toESM(require("path"));
+var fs29 = __toESM(require("fs"));
+var os26 = __toESM(require("os"));
+var path33 = __toESM(require("path"));
 function sampleCpuTimes() {
   let idle = 0;
   let total = 0;
-  for (const cpu of os25.cpus()) {
+  for (const cpu of os26.cpus()) {
     const t2 = cpu.times;
     idle += t2.idle;
     total += t2.user + t2.nice + t2.sys + t2.idle + t2.irq;
@@ -14130,8 +14313,8 @@ var MetricsCollector = class {
     const prev = this.prevCpu;
     this.prevCpu = current;
     if (!prev) {
-      const cores = os25.cpus().length || 1;
-      const proxy = os25.loadavg()[0] / cores * 100;
+      const cores = os26.cpus().length || 1;
+      const proxy = os26.loadavg()[0] / cores * 100;
       return Math.min(100, Math.max(0, Math.round(proxy)));
     }
     const idleDelta = current.idle - prev.idle;
@@ -14144,8 +14327,8 @@ var MetricsCollector = class {
   collect() {
     return {
       cpuPct: this.cpuPct(),
-      ramUsedMb: Math.round((os25.totalmem() - os25.freemem()) / 1048576),
-      ramTotalMb: Math.round(os25.totalmem() / 1048576),
+      ramUsedMb: Math.round((os26.totalmem() - os26.freemem()) / 1048576),
+      ramTotalMb: Math.round(os26.totalmem() / 1048576),
       latencyMs: this.lastLatencyMs
     };
   }
@@ -14154,19 +14337,19 @@ function apiBase() {
   return process.env.CODEAM_API_URL ?? resolveApiBaseUrl();
 }
 function hostIdentityPath() {
-  return path32.join(os25.homedir(), ".codeam", "host-agent.json");
+  return path33.join(os26.homedir(), ".codeam", "host-agent.json");
 }
 function collectOsInfo() {
   return {
-    distro: os25.platform(),
-    arch: os25.arch(),
-    kernel: os25.release(),
+    distro: os26.platform(),
+    arch: os26.arch(),
+    kernel: os26.release(),
     nodeVersion: process.versions.node
   };
 }
 function loadHostIdentity() {
   try {
-    const raw = fs28.readFileSync(hostIdentityPath(), "utf8");
+    const raw = fs29.readFileSync(hostIdentityPath(), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && typeof parsed.hostId === "string" && typeof parsed.hostToken === "string" && typeof parsed.controlPluginId === "string") {
       const p2 = parsed;
@@ -14179,8 +14362,8 @@ function loadHostIdentity() {
 }
 function saveHostIdentity(identity) {
   const file = hostIdentityPath();
-  fs28.mkdirSync(path32.dirname(file), { recursive: true, mode: 448 });
-  fs28.writeFileSync(file, JSON.stringify(identity, null, 2), {
+  fs29.mkdirSync(path33.dirname(file), { recursive: true, mode: 448 });
+  fs29.writeFileSync(file, JSON.stringify(identity, null, 2), {
     encoding: "utf8",
     mode: 384
   });
@@ -14225,7 +14408,7 @@ function isTerminalEnrollError(err) {
 }
 function deleteHostIdentity() {
   try {
-    fs28.rmSync(hostIdentityPath(), { force: true });
+    fs29.rmSync(hostIdentityPath(), { force: true });
   } catch {
   }
 }
@@ -14348,17 +14531,17 @@ async function reportDeployProgress(auth, deployId, step, message, sessionId) {
 }
 
 // src/commands/host/workspace.ts
-var fs29 = __toESM(require("fs"));
-var os26 = __toESM(require("os"));
-var path33 = __toESM(require("path"));
-var import_node_child_process12 = require("child_process");
+var fs30 = __toESM(require("fs"));
+var os27 = __toESM(require("os"));
+var path34 = __toESM(require("path"));
+var import_node_child_process13 = require("child_process");
 var import_node_util4 = require("util");
-var execFileP4 = (0, import_node_util4.promisify)(import_node_child_process12.execFile);
+var execFileP4 = (0, import_node_util4.promisify)(import_node_child_process13.execFile);
 function isAbsolutePathTarget(target) {
-  return path33.isAbsolute(target);
+  return path34.isAbsolute(target);
 }
 function selfHostedWorkspaceRoot() {
-  return path33.join(os26.homedir(), ".codeam", "self-hosted");
+  return path34.join(os27.homedir(), ".codeam", "self-hosted");
 }
 function nonInteractiveGitEnv() {
   return {
@@ -14411,13 +14594,13 @@ async function fetchGithubIdentity(token) {
 async function configureGitCredentials(dest, repoRef, cloneToken) {
   const gh = githubOwnerRepo(repoRef.trim());
   if (!gh || !cloneToken) return;
-  const credFile = path33.join(dest, ".git", "codeam-credentials");
-  fs29.writeFileSync(credFile, `https://x-access-token:${cloneToken}@github.com
+  const credFile = path34.join(dest, ".git", "codeam-credentials");
+  fs30.writeFileSync(credFile, `https://x-access-token:${cloneToken}@github.com
 `, { mode: 384 });
   restrictToOwner(credFile);
   const env = nonInteractiveGitEnv();
   const git2 = (args2) => execFileP4("git", ["-C", dest, ...args2], { timeout: 3e4, env });
-  const credFilePosix = credFile.split(path33.sep).join("/");
+  const credFilePosix = credFile.split(path34.sep).join("/");
   await git2(["config", "--local", "--replace-all", "credential.helper", ""]).catch(() => {
   });
   await git2([
@@ -14453,17 +14636,17 @@ function maskToken(text, cloneToken) {
 }
 async function prepareWorkspace(repoOrPath, deployId, cloneToken) {
   if (isAbsolutePathTarget(repoOrPath)) {
-    if (!fs29.existsSync(repoOrPath)) {
+    if (!fs30.existsSync(repoOrPath)) {
       throw new Error(`deploy target path does not exist: ${repoOrPath}`);
     }
     return repoOrPath;
   }
-  const dest = path33.join(selfHostedWorkspaceRoot(), deployId);
-  if (fs29.existsSync(path33.join(dest, ".git"))) {
+  const dest = path34.join(selfHostedWorkspaceRoot(), deployId);
+  if (fs30.existsSync(path34.join(dest, ".git"))) {
     if (cloneToken) await configureGitCredentials(dest, repoOrPath, cloneToken);
     return dest;
   }
-  fs29.mkdirSync(selfHostedWorkspaceRoot(), { recursive: true, mode: 448 });
+  fs30.mkdirSync(selfHostedWorkspaceRoot(), { recursive: true, mode: 448 });
   const cloneUrl = repoCloneUrl(repoOrPath, cloneToken);
   try {
     await execFileP4("git", ["clone", "--depth", "1", cloneUrl, dest], {
@@ -14480,9 +14663,9 @@ async function prepareWorkspace(repoOrPath, deployId, cloneToken) {
 }
 
 // src/commands/host/agent-provisioning.ts
-var fs30 = __toESM(require("fs"));
-var os27 = __toESM(require("os"));
-var path34 = __toESM(require("path"));
+var fs31 = __toESM(require("fs"));
+var os28 = __toESM(require("os"));
+var path35 = __toESM(require("path"));
 var PUBLIC_TO_INTERNAL_AGENT = {
   claude_code: "claude",
   claude: "claude",
@@ -14497,22 +14680,22 @@ function toInternalAgentId(publicAgentId) {
   return PUBLIC_TO_INTERNAL_AGENT[publicAgentId] ?? null;
 }
 function ensureDir(dir) {
-  fs30.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs31.mkdirSync(dir, { recursive: true, mode: 448 });
 }
 function writeFile0600(filePath, contents) {
-  ensureDir(path34.dirname(filePath));
-  fs30.writeFileSync(filePath, contents, { encoding: "utf8", mode: 384 });
+  ensureDir(path35.dirname(filePath));
+  fs31.writeFileSync(filePath, contents, { encoding: "utf8", mode: 384 });
   restrictToOwner(filePath);
 }
 function rmIfExists(filePath) {
   try {
-    fs30.rmSync(filePath, { force: true });
+    fs31.rmSync(filePath, { force: true });
   } catch {
   }
 }
 var claudeProvisioner = {
   write(auth, home) {
-    const credentialsJson = path34.join(home, ".claude", ".credentials.json");
+    const credentialsJson = path35.join(home, ".claude", ".credentials.json");
     if (auth.kind === "api_key") {
       rmIfExists(credentialsJson);
       return { ANTHROPIC_API_KEY: auth.value };
@@ -14524,8 +14707,8 @@ var claudeProvisioner = {
     } else {
       rmIfExists(credentialsJson);
     }
-    const claudeJson = path34.join(home, ".claude.json");
-    if (!fs30.existsSync(claudeJson)) {
+    const claudeJson = path35.join(home, ".claude.json");
+    if (!fs31.existsSync(claudeJson)) {
       writeFile0600(
         claudeJson,
         JSON.stringify({ hasCompletedOnboarding: true, customApiKeyResponses: { approved: [] } })
@@ -14536,7 +14719,7 @@ var claudeProvisioner = {
 };
 var codexProvisioner = {
   write(auth, home) {
-    const authJson = path34.join(home, ".codex", "auth.json");
+    const authJson = path35.join(home, ".codex", "auth.json");
     if (auth.kind === "api_key") {
       rmIfExists(authJson);
       return { OPENAI_API_KEY: auth.value };
@@ -14547,8 +14730,8 @@ var codexProvisioner = {
 };
 var geminiProvisioner = {
   write(auth, home) {
-    const settingsJson = path34.join(home, ".gemini", "settings.json");
-    const oauthCreds = path34.join(home, ".gemini", "oauth_creds.json");
+    const settingsJson = path35.join(home, ".gemini", "settings.json");
+    const oauthCreds = path35.join(home, ".gemini", "oauth_creds.json");
     if (auth.kind === "api_key") {
       rmIfExists(oauthCreds);
       writeFile0600(settingsJson, '{"security":{"auth":{"selectedType":"gemini-api-key"}}}');
@@ -14561,7 +14744,7 @@ var geminiProvisioner = {
 };
 var cursorProvisioner = {
   write(auth, home) {
-    const authJson = path34.join(home, ".config", "cursor", "auth.json");
+    const authJson = path35.join(home, ".config", "cursor", "auth.json");
     if (auth.kind === "api_key") {
       rmIfExists(authJson);
       return { CURSOR_API_KEY: auth.value };
@@ -14598,7 +14781,7 @@ var UnsupportedAgentError = class extends Error {
     this.agentId = agentId;
   }
 };
-function provisionAgentCredentials(publicAgentId, auth, homeDir2 = os27.homedir()) {
+function provisionAgentCredentials(publicAgentId, auth, homeDir2 = os28.homedir()) {
   const internal = toInternalAgentId(publicAgentId);
   if (!internal) throw new UnsupportedAgentError(publicAgentId);
   const provisioner = PROVISIONERS[internal];
@@ -14607,12 +14790,12 @@ function provisionAgentCredentials(publicAgentId, auth, homeDir2 = os27.homedir(
 }
 
 // src/commands/host/git-tooling.ts
-var import_node_child_process13 = require("child_process");
-var fs31 = __toESM(require("fs"));
-var os28 = __toESM(require("os"));
-var path35 = __toESM(require("path"));
+var import_node_child_process14 = require("child_process");
+var fs32 = __toESM(require("fs"));
+var os29 = __toESM(require("os"));
+var path36 = __toESM(require("path"));
 function codeamBinDir() {
-  return process.env.CODEAM_BIN_DIR ?? path35.join(os28.homedir(), ".codeam", "bin");
+  return process.env.CODEAM_BIN_DIR ?? path36.join(os29.homedir(), ".codeam", "bin");
 }
 var FALLBACK_GH_VERSION = "2.62.0";
 var RELEASE_API = "https://api.github.com/repos/cli/cli/releases/latest";
@@ -14644,7 +14827,7 @@ async function download(url, dest) {
     const res = await fetch(url, { headers: { "User-Agent": "codeam-cli" } });
     if (!res.ok || !res.body) return false;
     const buf = Buffer.from(await res.arrayBuffer());
-    fs31.writeFileSync(dest, buf);
+    fs32.writeFileSync(dest, buf);
     return true;
   } catch {
     return false;
@@ -14667,8 +14850,8 @@ async function ensureGhCli(runner, token, deps = {}) {
     const version3 = await resolveVersionFn(token);
     const asset = `gh_${version3}_${osToken}_${arch2}`;
     const url = `https://github.com/cli/cli/releases/download/v${version3}/${asset}.${ext}`;
-    const tmpRoot = fs31.mkdtempSync(path35.join(os28.tmpdir(), "codeam-gh-"));
-    const archive = path35.join(tmpRoot, `${asset}.${ext}`);
+    const tmpRoot = fs32.mkdtempSync(path36.join(os29.tmpdir(), "codeam-gh-"));
+    const archive = path36.join(tmpRoot, `${asset}.${ext}`);
     if (!await downloadFn(url, archive)) {
       log.warn("host-agent", "gh download failed \u2014 skipping (git pull/push still work via the credential helper)");
       return null;
@@ -14678,16 +14861,16 @@ async function ensureGhCli(runner, token, deps = {}) {
       log.warn("host-agent", `gh archive extraction failed (code=${String(extract.code)}) \u2014 skipping`);
       return null;
     }
-    const extractedBin = path35.join(tmpRoot, asset, "bin", binaryName);
-    if (!fs31.existsSync(extractedBin)) {
+    const extractedBin = path36.join(tmpRoot, asset, "bin", binaryName);
+    if (!fs32.existsSync(extractedBin)) {
       log.warn("host-agent", "gh binary not found in the extracted archive \u2014 skipping");
       return null;
     }
     const binDir = codeamBinDir();
-    fs31.mkdirSync(binDir, { recursive: true });
-    const target = path35.join(binDir, binaryName);
-    fs31.copyFileSync(extractedBin, target);
-    fs31.chmodSync(target, 493);
+    fs32.mkdirSync(binDir, { recursive: true });
+    const target = path36.join(binDir, binaryName);
+    fs32.copyFileSync(extractedBin, target);
+    fs32.chmodSync(target, 493);
     log.info("host-agent", `gh installed to ${target} (v${version3})`);
     return target;
   } catch (e) {
@@ -14721,7 +14904,7 @@ var defaultGitToolingRunner = {
   which(cmd) {
     try {
       const probe = process.platform === "win32" ? "where" : "which";
-      (0, import_node_child_process13.execFileSync)(probe, [cmd], { stdio: "ignore" });
+      (0, import_node_child_process14.execFileSync)(probe, [cmd], { stdio: "ignore" });
       return true;
     } catch {
       return false;
@@ -14729,7 +14912,7 @@ var defaultGitToolingRunner = {
   },
   run(cmd, args2, opts = {}) {
     return new Promise((resolve7) => {
-      const child = (0, import_node_child_process13.spawn)(cmd, args2, {
+      const child = (0, import_node_child_process14.spawn)(cmd, args2, {
         stdio: [opts.input !== void 0 ? "pipe" : "ignore", "ignore", "pipe"]
       });
       let stderr = "";
@@ -14769,6 +14952,16 @@ var defaultGitToolingRunner = {
 
 // src/services/headroom/stats-reporter.ts
 var DEFAULT_INPUT_PRICE_PER_MILLION = 3;
+var HEADROOM_FETCH_TIMEOUT_MS = 1e4;
+async function fetchWithTimeout(url, init, timeoutMs = HEADROOM_FETCH_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
 var ZERO = {
   rawTokensEst: 0,
   sentTokensEst: 0,
@@ -14831,6 +15024,9 @@ var HeadroomStatsReporter = class {
   deps;
   timer = null;
   prev = ZERO;
+  /** Period spend observed on the previous budgeted post — lets `budgetReached`
+   *  fire once per crossing instead of on every post while over the cap. */
+  prevPeriodSpendUsd = null;
   start() {
     const ms = this.deps.intervalMs ?? (Number(process.env.HEADROOM_STATS_POLL_INTERVAL_MS ?? "30000") || 3e4);
     this.timer = setInterval(() => void this.tick(), ms);
@@ -14847,11 +15043,18 @@ var HeadroomStatsReporter = class {
       if (delta.compressionTokens > 0 || delta.compressionSavingsUsd > 0 || delta.rawTokensEst > 0 || delta.cacheReadTokens > 0 || delta.cacheSavingsUsd > 0) {
         const getBudgetEnv = this.deps.getBudgetEnv ?? defaultGetBudgetEnv;
         const budgetEnv = getBudgetEnv();
-        const budget = budgetEnv ? {
-          periodSpendUsd: stats.cost?.cost_with_headroom_usd ?? 0,
-          budgetUsd: budgetEnv.budgetUsd,
-          budgetPeriod: budgetEnv.budgetPeriod
-        } : void 0;
+        let budget;
+        if (budgetEnv) {
+          const periodSpendUsd = stats.cost?.cost_with_headroom_usd ?? 0;
+          const crossed = periodSpendUsd >= budgetEnv.budgetUsd && (this.prevPeriodSpendUsd === null || this.prevPeriodSpendUsd < budgetEnv.budgetUsd);
+          this.prevPeriodSpendUsd = periodSpendUsd;
+          budget = {
+            periodSpendUsd,
+            budgetUsd: budgetEnv.budgetUsd,
+            budgetPeriod: budgetEnv.budgetPeriod,
+            ...crossed ? { budgetReached: true } : {}
+          };
+        }
         await this.deps.postSavings(delta, budget);
       }
     } catch {
@@ -14866,23 +15069,23 @@ var HeadroomStatsReporter = class {
 };
 
 // src/lib/updateNotifier.ts
-var fs32 = __toESM(require("fs"));
-var os29 = __toESM(require("os"));
-var path36 = __toESM(require("path"));
+var fs33 = __toESM(require("fs"));
+var os30 = __toESM(require("os"));
+var path37 = __toESM(require("path"));
 var https6 = __toESM(require("https"));
-var import_node_child_process14 = require("child_process");
+var import_node_child_process15 = require("child_process");
 var import_picocolors3 = __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 = path36.join(os29.homedir(), ".codeam");
-  return path36.join(dir, "update-check.json");
+  const dir = path37.join(os30.homedir(), ".codeam");
+  return path37.join(dir, "update-check.json");
 }
 function readCache() {
   try {
-    const raw = fs32.readFileSync(cachePath(), "utf8");
+    const raw = fs33.readFileSync(cachePath(), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.fetchedAt !== "number" || typeof parsed.latest !== "string") return null;
     return parsed;
@@ -14893,10 +15096,10 @@ function readCache() {
 function writeCache(cache) {
   try {
     const file = cachePath();
-    fs32.mkdirSync(path36.dirname(file), { recursive: true });
+    fs33.mkdirSync(path37.dirname(file), { recursive: true });
     const tmp = `${file}.${process.pid}.tmp`;
-    fs32.writeFileSync(tmp, JSON.stringify(cache));
-    fs32.renameSync(tmp, file);
+    fs33.writeFileSync(tmp, JSON.stringify(cache));
+    fs33.renameSync(tmp, file);
   } catch {
   }
 }
@@ -14964,14 +15167,14 @@ function notifyIfStale(currentVersion, latest) {
 }
 function isLinkedInstall() {
   try {
-    const root = (0, import_node_child_process14.execSync)("npm root -g", {
+    const root = (0, import_node_child_process15.execSync)("npm root -g", {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
       timeout: 2e3
     }).trim();
     if (!root) return false;
-    const pkgPath = path36.join(root, PKG_NAME);
-    return fs32.lstatSync(pkgPath).isSymbolicLink();
+    const pkgPath = path37.join(root, PKG_NAME);
+    return fs33.lstatSync(pkgPath).isSymbolicLink();
   } catch {
     return false;
   }
@@ -14992,7 +15195,7 @@ function maybeAutoUpdate(currentVersion, latest) {
 
 `
   );
-  const install = (0, import_node_child_process14.spawnSync)("npm", ["install", "-g", `${PKG_NAME}@latest`], {
+  const install = (0, import_node_child_process15.spawnSync)("npm", ["install", "-g", `${PKG_NAME}@latest`], {
     stdio: "inherit",
     env: process.env
   });
@@ -15007,13 +15210,13 @@ function maybeAutoUpdate(currentVersion, latest) {
     return;
   }
   try {
-    fs32.unlinkSync(cachePath());
+    fs33.unlinkSync(cachePath());
   } catch {
   }
   process.stderr.write(`  ${import_picocolors3.default.green("\u2713")} Updated. Resuming session...
 
 `);
-  const child = (0, import_node_child_process14.spawnSync)("codeam", process.argv.slice(2), {
+  const child = (0, import_node_child_process15.spawnSync)("codeam", process.argv.slice(2), {
     stdio: "inherit",
     env: process.env
   });
@@ -15023,7 +15226,7 @@ async function autoUpgradeBeforeCriticalCommand() {
   if (process.env.NODE_ENV === "test") return;
   if (process.env.CODEAM_DISABLE_UPDATE_CHECK === "1") return;
   if (process.env.CI) return;
-  const current = true ? "2.53.2" : null;
+  const current = true ? "2.53.4" : null;
   if (!current) return;
   const cache = readCache();
   const fresh = cache && Date.now() - cache.fetchedAt < TTL_MS;
@@ -15040,7 +15243,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.53.2" : null;
+  const current = true ? "2.53.4" : null;
   if (!current) return;
   const cache = readCache();
   const fresh = cache && Date.now() - cache.fetchedAt < TTL_MS;
@@ -15074,11 +15277,11 @@ function maybeStartHeadroomReporter(ctx) {
         process.env["HEADROOM_AGENT"] ?? "claude"
       ),
       fetchStats: async () => {
-        const res = await fetch("http://localhost:8787/stats");
+        const res = await fetchWithTimeout("http://localhost:8787/stats");
         return res.json();
       },
       postSavings: async (delta, budget) => {
-        await fetch(ingestUrl, {
+        const res = await fetchWithTimeout(ingestUrl, {
           method: "POST",
           headers: {
             "Content-Type": "application/json",
@@ -15092,10 +15295,14 @@ function maybeStartHeadroomReporter(ctx) {
             ...budget ? {
               periodSpendUsd: budget.periodSpendUsd,
               budgetUsd: budget.budgetUsd,
-              budgetPeriod: budget.budgetPeriod
+              budgetPeriod: budget.budgetPeriod,
+              budgetReached: budget.budgetReached
             } : {}
           })
         });
+        if (!res.ok) {
+          log.warn("headroom", `savings POST rejected ${res.status} \u2014 delta not credited`);
+        }
       }
     });
     reporter.start();
@@ -15112,22 +15319,22 @@ function maybeResumeLocalHeadroomReporter(ctx) {
   if (process.env["HEADROOM_ENABLED"] === "1") return null;
   try {
     const file = headroomConfigPath();
-    if (!fs33.existsSync(file)) return null;
-    const cfg = JSON.parse(fs33.readFileSync(file, "utf8"));
+    if (!fs34.existsSync(file)) return null;
+    const cfg = JSON.parse(fs34.readFileSync(file, "utf8"));
     if (!cfg?.enabled) return null;
     const agent = cfg.agent ?? "claude";
     const ingestUrl = `${resolveApiBaseUrl()}/api/sessions/${ctx.sessionId}/headroom-savings`;
     const reporter = new HeadroomStatsReporter({
       inputPricePerMillionUsd: resolveInputPricePerMillion(agent),
       fetchStats: async () => {
-        const res = await fetch("http://localhost:8787/stats");
+        const res = await fetchWithTimeout("http://localhost:8787/stats");
         return res.json();
       },
       // Body MUST match HeadroomSavingsDto + PluginAuthGuard (sessionId +
       // pluginId in the body) — same shape as the codespace reporter above and
       // the on-demand `startReporter` in handlers.ts.
       postSavings: async (delta, budget) => {
-        await fetch(ingestUrl, {
+        const res = await fetchWithTimeout(ingestUrl, {
           method: "POST",
           headers: {
             "Content-Type": "application/json",
@@ -15141,10 +15348,14 @@ function maybeResumeLocalHeadroomReporter(ctx) {
             ...budget ? {
               periodSpendUsd: budget.periodSpendUsd,
               budgetUsd: budget.budgetUsd,
-              budgetPeriod: budget.budgetPeriod
+              budgetPeriod: budget.budgetPeriod,
+              budgetReached: budget.budgetReached
             } : {}
           })
         });
+        if (!res.ok) {
+          log.warn("headroom", `savings POST rejected ${res.status} \u2014 delta not credited`);
+        }
       }
     });
     reporter.start();
@@ -15204,7 +15415,7 @@ var HEADROOM_MIN_FREE_DISK_BYTES = 2 * 1024 * 1024 * 1024;
 var defaultHeadroomRunner = {
   which(cmd) {
     try {
-      (0, import_node_child_process15.execFileSync)("which", [cmd], { stdio: "ignore" });
+      (0, import_node_child_process16.execFileSync)("which", [cmd], { stdio: "ignore" });
       return true;
     } catch {
       return false;
@@ -15213,7 +15424,7 @@ var defaultHeadroomRunner = {
   run(cmd, args2, opts = {}) {
     return new Promise((resolve7) => {
       const spawnEnv = opts.env ?? process.env;
-      const child = (0, import_node_child_process15.spawn)(cmd, args2, { stdio: ["ignore", "pipe", "pipe"], env: spawnEnv });
+      const child = (0, import_node_child_process16.spawn)(cmd, args2, { stdio: ["ignore", "pipe", "pipe"], env: spawnEnv });
       let stderrBuf = "";
       let stdoutBuf = "";
       let settled = false;
@@ -15377,15 +15588,15 @@ function isHeadroomSupportedAgent(agentId) {
   return n.startsWith("claude") || n.startsWith("codex") || n.startsWith("copilot");
 }
 function headroomConfigPath() {
-  return path37.join(os30.homedir(), ".codeam", "headroom-config.json");
+  return path38.join(os31.homedir(), ".codeam", "headroom-config.json");
 }
 function persistHeadroomConfig(config) {
   try {
     const file = headroomConfigPath();
-    fs33.mkdirSync(path37.dirname(file), { recursive: true, mode: 448 });
+    fs34.mkdirSync(path38.dirname(file), { recursive: true, mode: 448 });
     const tmp = `${file}.tmp-${process.pid}`;
-    fs33.writeFileSync(tmp, JSON.stringify(config, null, 2), { encoding: "utf8", mode: 384 });
-    fs33.renameSync(tmp, file);
+    fs34.writeFileSync(tmp, JSON.stringify(config, null, 2), { encoding: "utf8", mode: 384 });
+    fs34.renameSync(tmp, file);
     restrictToOwner(file);
   } catch (err) {
     log.warn(
@@ -15395,21 +15606,21 @@ function persistHeadroomConfig(config) {
   }
 }
 function agentSettingsPath(kind) {
-  const home = os30.homedir();
-  if (kind === "claude") return path37.join(home, ".claude", "settings.json");
-  if (kind === "codex") return path37.join(home, ".codex", "auth.json");
-  if (kind === "copilot") return path37.join(home, ".config", "github-copilot", "hosts.json");
+  const home = os31.homedir();
+  if (kind === "claude") return path38.join(home, ".claude", "settings.json");
+  if (kind === "codex") return path38.join(home, ".codex", "auth.json");
+  if (kind === "copilot") return path38.join(home, ".config", "github-copilot", "hosts.json");
   return null;
 }
 function backupAgentHeadroomConfig(kind) {
   const src = agentSettingsPath(kind);
   if (!src) return;
   try {
-    if (!fs33.existsSync(src)) return;
-    const dest = path37.join(os30.homedir(), ".codeam", `headroom-backup-${kind}.json`);
-    fs33.mkdirSync(path37.dirname(dest), { recursive: true, mode: 448 });
-    fs33.copyFileSync(src, dest);
-    fs33.chmodSync(dest, 384);
+    if (!fs34.existsSync(src)) return;
+    const dest = path38.join(os31.homedir(), ".codeam", `headroom-backup-${kind}.json`);
+    fs34.mkdirSync(path38.dirname(dest), { recursive: true, mode: 448 });
+    fs34.copyFileSync(src, dest);
+    fs34.chmodSync(dest, 384);
     log.info("host-agent", `headroom config backup: ${src} \u2192 ${dest}`);
   } catch (err) {
     log.warn(
@@ -15421,12 +15632,12 @@ function backupAgentHeadroomConfig(kind) {
 function restoreAgentHeadroomConfig(kind) {
   const dest = agentSettingsPath(kind);
   if (!dest) return false;
-  const src = path37.join(os30.homedir(), ".codeam", `headroom-backup-${kind}.json`);
-  if (!fs33.existsSync(src)) return false;
+  const src = path38.join(os31.homedir(), ".codeam", `headroom-backup-${kind}.json`);
+  if (!fs34.existsSync(src)) return false;
   try {
-    fs33.mkdirSync(path37.dirname(dest), { recursive: true, mode: 448 });
-    fs33.copyFileSync(src, dest);
-    fs33.chmodSync(dest, 384);
+    fs34.mkdirSync(path38.dirname(dest), { recursive: true, mode: 448 });
+    fs34.copyFileSync(src, dest);
+    fs34.chmodSync(dest, 384);
     log.info("host-agent", `headroom config restored: ${src} \u2192 ${dest}`);
     return true;
   } catch (err) {
@@ -15439,7 +15650,7 @@ function restoreAgentHeadroomConfig(kind) {
 }
 function readHeadroomChildEnv() {
   try {
-    const raw = fs33.readFileSync(headroomConfigPath(), "utf8");
+    const raw = fs34.readFileSync(headroomConfigPath(), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null) return {};
     const o = parsed;
@@ -15464,37 +15675,37 @@ function bundledClaudeBinDir() {
   const roots = /* @__PURE__ */ new Set();
   let dir = __dirname;
   for (let i = 0; i < 6; i++) {
-    roots.add(path37.join(dir, "node_modules"));
-    const parent = path37.dirname(dir);
+    roots.add(path38.join(dir, "node_modules"));
+    const parent = path38.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   try {
     const main2 = require.resolve("@anthropic-ai/claude-agent-sdk");
-    const marker = `${path37.sep}@anthropic-ai${path37.sep}`;
+    const marker = `${path38.sep}@anthropic-ai${path38.sep}`;
     const idx = main2.lastIndexOf(marker);
     if (idx !== -1) roots.add(main2.slice(0, idx));
   } catch {
   }
   for (const nm of roots) {
-    const atAnthropic = path37.join(nm, "@anthropic-ai");
+    const atAnthropic = path38.join(nm, "@anthropic-ai");
     let entries;
     try {
-      entries = fs33.readdirSync(atAnthropic);
+      entries = fs34.readdirSync(atAnthropic);
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (!entry.startsWith("claude-agent-sdk-")) continue;
-      const bin = path37.join(atAnthropic, entry, "claude");
-      if (fs33.existsSync(bin)) return path37.dirname(bin);
+      const bin = path38.join(atAnthropic, entry, "claude");
+      if (fs34.existsSync(bin)) return path38.dirname(bin);
     }
   }
   return null;
 }
 async function getFreeDiskBytes(dir) {
   try {
-    const s = await fs33.promises.statfs(dir);
+    const s = await fs34.promises.statfs(dir);
     return s.bsize * s.bavail;
   } catch {
     return null;
@@ -15686,7 +15897,7 @@ async function setupHeadroomForSelfHosted(agent, runner = defaultHeadroomRunner,
   if (initKind === "claude") {
     const claudeDir = bundledClaudeBinDir();
     if (claudeDir) {
-      initEnv.PATH = `${claudeDir}${path37.delimiter}${process.env["PATH"] ?? ""}`;
+      initEnv.PATH = `${claudeDir}${path38.delimiter}${process.env["PATH"] ?? ""}`;
       log.info("host-agent", `headroom init: bundled claude on PATH (${claudeDir})`);
     } else {
       log.warn("host-agent", "headroom init: bundled claude binary not found \u2014 init may fail");
@@ -15710,7 +15921,7 @@ async function setupHeadroomForSelfHosted(agent, runner = defaultHeadroomRunner,
   onProgress("proxy");
   try {
     const proxyEnv = { ...process.env, HEADROOM_KOMPRESS_BACKEND: "onnx_cpu" };
-    const proxy = (0, import_node_child_process15.spawn)(
+    const proxy = (0, import_node_child_process16.spawn)(
       "headroom",
       ["proxy", "--port", "8787", ...buildBudgetProxyArgs(proxyEnv)],
       {
@@ -15726,6 +15937,7 @@ async function setupHeadroomForSelfHosted(agent, runner = defaultHeadroomRunner,
       );
     });
     proxy.unref();
+    writeHeadroomProxyPidfile(proxy.pid);
   } catch (e) {
     log.warn(
       "host-agent",
@@ -15735,18 +15947,18 @@ async function setupHeadroomForSelfHosted(agent, runner = defaultHeadroomRunner,
   onProgress("ready");
   return true;
 }
-var defaultSpawner = (env, cwd, args2 = []) => (0, import_node_child_process15.spawn)(process.execPath, [process.argv[1], "pair-auto", ...args2], {
+var defaultSpawner = (env, cwd, args2 = []) => (0, import_node_child_process16.spawn)(process.execPath, [process.argv[1], "pair-auto", ...args2], {
   cwd,
   env: { ...process.env, ...env },
   stdio: ["ignore", "pipe", "pipe"],
   detached: false
 });
 function currentCliVersion() {
-  return true ? "2.53.2" : null;
+  return true ? "2.53.4" : null;
 }
 function runCmd(cmd, args2, timeoutMs) {
   return new Promise((resolve7) => {
-    (0, import_node_child_process15.execFile)(cmd, args2, { timeout: timeoutMs }, (err, stdout, stderr) => {
+    (0, import_node_child_process16.execFile)(cmd, args2, { timeout: timeoutMs }, (err, stdout, stderr) => {
       const code = err && typeof err.code === "number" ? err.code : err ? null : 0;
       resolve7({ code, stdout: stdout ?? "", stderr: stderr ?? "" });
     });
@@ -15817,22 +16029,19 @@ var defaultOnUpdated = (version3) => {
 };
 var defaultDisableService = () => {
   try {
-    (0, import_node_child_process15.execFileSync)("systemctl", ["disable", "--now", "codeam-host-agent"], { stdio: "ignore" });
+    (0, import_node_child_process16.execFileSync)("systemctl", ["disable", "--now", "codeam-host-agent"], { stdio: "ignore" });
   } catch {
   }
 };
 var defaultTeardownHeadroom = () => {
   try {
-    const kind = JSON.parse(fs33.readFileSync(headroomConfigPath(), "utf8")).agent;
+    const kind = JSON.parse(fs34.readFileSync(headroomConfigPath(), "utf8")).agent;
     if (kind) {
-      (0, import_node_child_process15.execFileSync)("headroom", ["unwrap", kind], { stdio: "ignore", timeout: 15e3 });
+      (0, import_node_child_process16.execFileSync)("headroom", ["unwrap", kind], { stdio: "ignore", timeout: 15e3 });
     }
   } catch {
   }
-  try {
-    (0, import_node_child_process15.execFileSync)("pkill", ["-TERM", "-f", "headroom.*proxy"], { stdio: "ignore" });
-  } catch {
-  }
+  killHeadroomProxy();
   persistHeadroomConfig({ enabled: false });
 };
 var HostAgentSupervisor = class {
@@ -16137,9 +16346,9 @@ var HostAgentSupervisor = class {
           API_TIMEOUT_MS: "3000000",
           CODEAM_AUTO_TOKEN: payload.autoPairToken
         };
-        const houseConfigDir = path37.join(os30.homedir(), ".codeam", "house-claude");
+        const houseConfigDir = path38.join(os31.homedir(), ".codeam", "house-claude");
         try {
-          fs33.mkdirSync(houseConfigDir, { recursive: true, mode: 448 });
+          fs34.mkdirSync(houseConfigDir, { recursive: true, mode: 448 });
         } catch {
         }
         childEnv.CLAUDE_CONFIG_DIR = houseConfigDir;
@@ -16157,14 +16366,14 @@ var HostAgentSupervisor = class {
         report("installing", "installing agent CLI");
         await this.runAgentInstall(payload.agentInstallScript);
       }
-      const home = process.env.HOME || os30.homedir();
+      const home = process.env.HOME || os31.homedir();
       childEnv.PATH = `${home}/.local/bin:${process.env.PATH ?? ""}`;
       if (payload.cloneToken) {
         try {
           report("preparing", "configuring git tooling");
           const ghCmd = await ensureGhCli(defaultGitToolingRunner, payload.cloneToken);
           if (ghCmd) {
-            childEnv.PATH = `${codeamBinDir()}${path37.delimiter}${childEnv.PATH}`;
+            childEnv.PATH = `${codeamBinDir()}${path38.delimiter}${childEnv.PATH}`;
             await ensureGhAuth(defaultGitToolingRunner, ghCmd, payload.cloneToken);
           }
         } catch (e) {
@@ -16180,7 +16389,7 @@ var HostAgentSupervisor = class {
       }
       if (payload.headroomEnabled && payload.headroomAgent && payload.headroomSavingsIngestUrl && isHeadroomSupportedAgent(payload.headroomAgent)) {
         report("headroom", "setting up Headroom proxy");
-        const freeBytes = await this.getFreeDisk(os30.homedir());
+        const freeBytes = await this.getFreeDisk(os31.homedir());
         const alreadyInstalled = this.isHeadroomInstalled();
         if (!alreadyInstalled && freeBytes !== null && freeBytes < HEADROOM_MIN_FREE_DISK_BYTES) {
           const freeGb = (freeBytes / 1e9).toFixed(1);
@@ -16302,8 +16511,8 @@ var HostAgentSupervisor = class {
    */
   runAgentInstall(script) {
     return new Promise((resolve7) => {
-      const home = process.env.HOME || os30.homedir();
-      const child = (0, import_node_child_process15.spawn)("sh", ["-c", script], {
+      const home = process.env.HOME || os31.homedir();
+      const child = (0, import_node_child_process16.spawn)("sh", ["-c", script], {
         env: { ...process.env, HOME: home },
         stdio: ["ignore", "pipe", "pipe"]
       });
@@ -16458,10 +16667,10 @@ async function configureHeadroom(action, ctx, deps) {
     if (!isHeadroomSupportedAgent(ctx.agent)) return { supported: false };
     const ok = await deps.setup(ctx.agent, void 0, {
       extras: ["proxy", "code", "image"],
-      onProgress: (step) => deps.emit({ type: "headroom_progress", step })
+      onProgress: (step) => deps.emit({ type: USER_EVENTS.HEADROOM_PROGRESS, step })
     });
     if (!ok) {
-      deps.emit({ type: "headroom_status", state: "error" });
+      deps.emit({ type: USER_EVENTS.HEADROOM_STATUS, state: "error" });
       return { enabled: false };
     }
     deps.persist({ enabled: true, agent: kind, ingestUrl: ctx.savingsIngestUrl });
@@ -16472,21 +16681,21 @@ async function configureHeadroom(action, ctx, deps) {
         pluginAuthToken: ctx.pluginAuthToken
       });
     }
-    deps.emit({ type: "headroom_status", state: "enabled" });
+    deps.emit({ type: USER_EVENTS.HEADROOM_STATUS, state: "enabled" });
     return { enabled: true };
   }
   deps.restoreAgentHeadroomConfig(kind);
   deps.stopProxy();
   deps.persist({ enabled: false });
   deps.stopReporter();
-  deps.emit({ type: "headroom_status", state: "disabled" });
+  deps.emit({ type: USER_EVENTS.HEADROOM_STATUS, state: "disabled" });
   return { enabled: false };
 }
 
 // src/services/headroom/budget-relaunch.ts
-var fs34 = __toESM(require("fs"));
-var os31 = __toESM(require("os"));
-var path38 = __toESM(require("path"));
+var fs35 = __toESM(require("fs"));
+var os32 = __toESM(require("os"));
+var path39 = __toESM(require("path"));
 var import_child_process13 = require("child_process");
 function amendDeploymentManifestBudget(manifest, budget) {
   const rawArgs = manifest.proxy_args ?? [];
@@ -16520,7 +16729,7 @@ function amendDeploymentManifestBudget(manifest, budget) {
   return { ...manifest, proxy_args: newArgs, base_env: newEnv };
 }
 function findHeadroomDeployments(homeDir2, deps) {
-  const deployDir = path38.join(homeDir2, ".headroom", "deploy");
+  const deployDir = path39.join(homeDir2, ".headroom", "deploy");
   let profiles;
   try {
     profiles = deps.readDir(deployDir);
@@ -16529,7 +16738,7 @@ function findHeadroomDeployments(homeDir2, deps) {
   }
   const results = [];
   for (const profile of profiles) {
-    const manifestPath = path38.join(deployDir, profile, "manifest.json");
+    const manifestPath = path39.join(deployDir, profile, "manifest.json");
     let raw;
     try {
       raw = deps.readJson(manifestPath);
@@ -16561,8 +16770,8 @@ async function applyBudgetToHeadroom(budget, deps) {
 }
 function writeManifestReal(manifestPath, manifest) {
   const tmp = manifestPath + ".codeam.tmp";
-  fs34.writeFileSync(tmp, JSON.stringify(manifest, null, 2) + "\n", { mode: 384 });
-  fs34.renameSync(tmp, manifestPath);
+  fs35.writeFileSync(tmp, JSON.stringify(manifest, null, 2) + "\n", { mode: 384 });
+  fs35.renameSync(tmp, manifestPath);
 }
 function restartDeploymentReal(profile) {
   try {
@@ -16582,16 +16791,7 @@ function restartDeploymentReal(profile) {
   }
 }
 function killProxyReal() {
-  try {
-    const killer = (0, import_child_process13.spawn)("pkill", ["-TERM", "-f", "headroom.*proxy"], {
-      detached: true,
-      stdio: "ignore"
-    });
-    killer.once("error", () => {
-    });
-    killer.unref();
-  } catch {
-  }
+  killHeadroomProxy();
 }
 function spawnProxyReal2(budget) {
   try {
@@ -16612,6 +16812,7 @@ function spawnProxyReal2(budget) {
       log.warn("headroom-budget", `proxy relaunch error (best-effort): ${e.message}`);
     });
     proxy.unref();
+    writeHeadroomProxyPidfile(proxy.pid);
   } catch (e) {
     log.warn(
       "headroom-budget",
@@ -16620,11 +16821,11 @@ function spawnProxyReal2(budget) {
   }
 }
 function makeRealApplyBudgetDeps() {
-  const homeDir2 = os31.homedir();
+  const homeDir2 = os32.homedir();
   return {
     findDeployments: () => findHeadroomDeployments(homeDir2, {
-      readDir: (dir) => fs34.readdirSync(dir),
-      readJson: (filePath) => JSON.parse(fs34.readFileSync(filePath, "utf8"))
+      readDir: (dir) => fs35.readdirSync(dir),
+      readJson: (filePath) => JSON.parse(fs35.readFileSync(filePath, "utf8"))
     }),
     writeManifest: writeManifestReal,
     restartDeployment: restartDeploymentReal,
@@ -17268,9 +17469,9 @@ function activePreviewSessionIds() {
 
 // src/beads/bd-adapter.ts
 var import_child_process17 = require("child_process");
-var fs39 = __toESM(require("fs"));
-var os33 = __toESM(require("os"));
-var path43 = __toESM(require("path"));
+var fs40 = __toESM(require("fs"));
+var os34 = __toESM(require("os"));
+var path44 = __toESM(require("path"));
 var BD_PACKAGE = "@beads/bd";
 function resolveBundledBdBinary() {
   return _resolveSeam.resolveBundled();
@@ -17282,11 +17483,11 @@ function _defaultResolveBundled() {
   } catch {
     return null;
   }
-  const binDir = path43.join(path43.dirname(pkgJsonPath), "bin");
+  const binDir = path44.join(path44.dirname(pkgJsonPath), "bin");
   const binaryName = process.platform === "win32" ? "bd.exe" : "bd";
-  const binaryPath = path43.join(binDir, binaryName);
+  const binaryPath = path44.join(binDir, binaryName);
   try {
-    fs39.accessSync(binaryPath, fs39.constants.F_OK);
+    fs40.accessSync(binaryPath, fs40.constants.F_OK);
     return binaryPath;
   } catch {
     return null;
@@ -17296,13 +17497,13 @@ function resolveBdOnPath() {
   return _resolveSeam.resolveOnPath();
 }
 function _defaultResolveOnPath() {
-  const dirs = (process.env.PATH ?? "").split(path43.delimiter).filter(Boolean);
+  const dirs = (process.env.PATH ?? "").split(path44.delimiter).filter(Boolean);
   const candidates = process.platform === "win32" ? ["bd.exe", "bd.cmd", "bd"] : ["bd"];
   for (const dir of dirs) {
     for (const candidate of candidates) {
-      const full = path43.join(dir, candidate);
+      const full = path44.join(dir, candidate);
       try {
-        fs39.accessSync(full, fs39.constants.F_OK);
+        fs40.accessSync(full, fs40.constants.F_OK);
         return full;
       } catch {
       }
@@ -17387,7 +17588,7 @@ var BdAdapter = class {
     const env = { ...process.env };
     if (!env.HOME) {
       try {
-        const home = os33.homedir();
+        const home = os34.homedir();
         if (home) env.HOME = home;
       } catch {
       }
@@ -17467,18 +17668,21 @@ function coerceIssue(row, projectKey) {
     owner: typeof r.owner === "string" && r.owner.length > 0 ? r.owner : null,
     created_at: typeof r.created_at === "string" ? r.created_at : "",
     updated_at: typeof r.updated_at === "string" ? r.updated_at : "",
-    dependency_count: typeof r.dependency_count === "number" ? r.dependency_count : void 0,
-    dependent_count: typeof r.dependent_count === "number" ? r.dependent_count : void 0,
-    comment_count: typeof r.comment_count === "number" ? r.comment_count : void 0,
+    // The backend ingest DTO validates the counts as REQUIRED ints — an
+    // omitted count would 400 the whole snapshot. Default to 0 when a bd
+    // version omits one instead of dropping the field.
+    dependency_count: typeof r.dependency_count === "number" ? r.dependency_count : 0,
+    dependent_count: typeof r.dependent_count === "number" ? r.dependent_count : 0,
+    comment_count: typeof r.comment_count === "number" ? r.comment_count : 0,
     projectKey
   };
 }
 
 // src/beads/provisioner.ts
 var import_child_process21 = require("child_process");
-var fs42 = __toESM(require("fs"));
-var os35 = __toESM(require("os"));
-var path46 = __toESM(require("path"));
+var fs43 = __toESM(require("fs"));
+var os36 = __toESM(require("os"));
+var path47 = __toESM(require("path"));
 
 // src/beads/install-bd.ts
 var import_child_process18 = require("child_process");
@@ -17543,9 +17747,9 @@ async function installBd(platform3 = process.platform) {
 
 // src/beads/install-dolt.ts
 var import_child_process19 = require("child_process");
-var fs40 = __toESM(require("fs"));
-var os34 = __toESM(require("os"));
-var path44 = __toESM(require("path"));
+var fs41 = __toESM(require("fs"));
+var os35 = __toESM(require("os"));
+var path45 = __toESM(require("path"));
 var DOLT_INSTALL_SH_URL = "https://github.com/dolthub/dolt/releases/latest/download/install.sh";
 var DOLT_MSI_URL = "https://github.com/dolthub/dolt/releases/latest/download/dolt-windows-amd64.msi";
 function resolveDoltInstallStrategy(platform3) {
@@ -17585,11 +17789,11 @@ function resolveDoltInstallStrategy(platform3) {
 }
 var DOLT_RELEASE_BASE = "https://github.com/dolthub/dolt/releases/latest/download";
 function doltPlatformTuple(platform3, arch2) {
-  const os44 = platform3 === "win32" ? "windows" : platform3 === "darwin" ? "darwin" : "linux";
+  const os45 = platform3 === "win32" ? "windows" : platform3 === "darwin" ? "darwin" : "linux";
   const a = arch2 === "x64" ? "amd64" : arch2 === "arm64" ? "arm64" : null;
   if (!a) return null;
-  if (os44 === "windows" && a !== "amd64") return null;
-  return `${os44}-${a}`;
+  if (os45 === "windows" && a !== "amd64") return null;
+  return `${os45}-${a}`;
 }
 function resolveDoltTarballStrategy(targetDir, platform3, arch2) {
   const tuple = doltPlatformTuple(platform3, arch2);
@@ -17634,14 +17838,14 @@ async function installDoltToDir(targetDir, platform3 = process.platform, arch2 =
   return result;
 }
 var _doltPathSeam = {
-  homedir: () => os34.homedir(),
+  homedir: () => os35.homedir(),
   getPath: () => process.env.PATH ?? "",
   setPath: (p2) => {
     process.env.PATH = p2;
   },
   exists: (p2) => {
     try {
-      fs40.accessSync(p2, fs40.constants.F_OK);
+      fs41.accessSync(p2, fs41.constants.F_OK);
       return true;
     } catch {
       return false;
@@ -17652,7 +17856,7 @@ function doltBinaryNames(platform3) {
   return platform3 === "win32" ? ["dolt.exe", "dolt.cmd", "dolt"] : ["dolt"];
 }
 function knownDoltDirs(platform3) {
-  const P3 = platform3 === "win32" ? path44.win32 : path44.posix;
+  const P3 = platform3 === "win32" ? path45.win32 : path45.posix;
   const home = _doltPathSeam.homedir();
   if (platform3 === "win32") {
     return [
@@ -17668,7 +17872,7 @@ function knownDoltDirs(platform3) {
   ].filter(Boolean);
 }
 function ensureDoltResolvable(platform3 = process.platform) {
-  const P3 = platform3 === "win32" ? path44.win32 : path44.posix;
+  const P3 = platform3 === "win32" ? path45.win32 : path45.posix;
   const delim = platform3 === "win32" ? ";" : ":";
   const names = doltBinaryNames(platform3);
   const pathDirs = _doltPathSeam.getPath().split(delim).filter(Boolean);
@@ -17804,8 +18008,8 @@ async function ensureSharedServer(adapter, options = {}) {
 // src/beads/project-key.ts
 var import_child_process20 = require("child_process");
 var crypto2 = __toESM(require("crypto"));
-var fs41 = __toESM(require("fs"));
-var path45 = __toESM(require("path"));
+var fs42 = __toESM(require("fs"));
+var path46 = __toESM(require("path"));
 function normalizeOrigin(raw) {
   const trimmed = raw.trim();
   if (!trimmed) return null;
@@ -17831,17 +18035,17 @@ function normalizeOrigin(raw) {
   return `${host2}/${pathPart}`;
 }
 function findRepoRoot(cwd) {
-  let dir = path45.resolve(cwd);
+  let dir = path46.resolve(cwd);
   const seen = /* @__PURE__ */ new Set();
   for (let i = 0; i < 256; i++) {
     if (seen.has(dir)) return null;
     seen.add(dir);
     try {
-      const stat3 = fs41.statSync(path45.join(dir, ".git"), { throwIfNoEntry: false });
+      const stat3 = fs42.statSync(path46.join(dir, ".git"), { throwIfNoEntry: false });
       if (stat3 && (stat3.isDirectory() || stat3.isFile())) return dir;
     } catch {
     }
-    const parent = path45.dirname(dir);
+    const parent = path46.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -17852,7 +18056,7 @@ var _execSeam2 = {
     const out2 = (0, import_child_process20.execFileSync)(file, args2, opts);
     return typeof out2 === "string" ? out2 : out2.toString("utf8");
   },
-  realpath: (p2) => fs41.realpathSync(p2)
+  realpath: (p2) => fs42.realpathSync(p2)
 };
 function readOrigin(cwd) {
   try {
@@ -17881,7 +18085,7 @@ function deriveProjectIdentity(cwd = process.cwd()) {
   } catch {
   }
   const hash = crypto2.createHash("sha256").update(real).digest("hex");
-  return { projectKey: `path:${hash}`, projectLabel: path45.basename(real) || "project" };
+  return { projectKey: `path:${hash}`, projectLabel: path46.basename(real) || "project" };
 }
 
 // src/beads/project-prefix.ts
@@ -17923,17 +18127,17 @@ var _provisionSeam = {
 };
 var _linkSeam = {
   platform: () => process.platform,
-  homedir: () => os35.homedir(),
+  homedir: () => os36.homedir(),
   isWritableDir: (dir) => {
     try {
-      fs42.accessSync(dir, fs42.constants.W_OK);
+      fs43.accessSync(dir, fs43.constants.W_OK);
       return true;
     } catch {
       return false;
     }
   },
   ensureDir: (dir) => {
-    fs42.mkdirSync(dir, { recursive: true });
+    fs43.mkdirSync(dir, { recursive: true });
   },
   /**
    * A directory to symlink `bd` into so the AGENT's shell + Claude Code's
@@ -17954,9 +18158,9 @@ var _linkSeam = {
    * which `linkBdOntoPath` creates if missing.
    */
   cliBinDir: () => {
-    const pathDirs = (process.env.PATH ?? "").split(path46.delimiter).filter(Boolean);
+    const pathDirs = (process.env.PATH ?? "").split(path47.delimiter).filter(Boolean);
     const home = _linkSeam.homedir();
-    const localBin = home ? path46.join(home, ".local", "bin") : null;
+    const localBin = home ? path47.join(home, ".local", "bin") : null;
     if (localBin) {
       try {
         _linkSeam.ensureDir(localBin);
@@ -17966,16 +18170,16 @@ var _linkSeam = {
     const candidates = [];
     if (localBin) candidates.push(localBin);
     try {
-      candidates.push(path46.dirname(process.execPath));
+      candidates.push(path47.dirname(process.execPath));
     } catch {
     }
     candidates.push("/usr/local/bin");
     const entry = process.argv[1];
     if (entry) {
       try {
-        candidates.push(path46.dirname(fs42.realpathSync(entry)));
+        candidates.push(path47.dirname(fs43.realpathSync(entry)));
       } catch {
-        candidates.push(path46.dirname(entry));
+        candidates.push(path47.dirname(entry));
       }
     }
     const onPathWritable = candidates.find(
@@ -17987,20 +18191,20 @@ var _linkSeam = {
   /** Current symlink target at `linkPath`, or null when absent / not a link. */
   readlink: (linkPath) => {
     try {
-      return fs42.readlinkSync(linkPath);
+      return fs43.readlinkSync(linkPath);
     } catch {
       return null;
     }
   },
-  unlink: (linkPath) => fs42.unlinkSync(linkPath),
-  symlink: (target, linkPath) => fs42.symlinkSync(target, linkPath)
+  unlink: (linkPath) => fs43.unlinkSync(linkPath),
+  symlink: (target, linkPath) => fs43.symlinkSync(target, linkPath)
 };
 function linkBdOntoPath(binaryPath) {
   if (_linkSeam.platform() === "win32") return;
   const binDir = _linkSeam.cliBinDir();
   if (!binDir) return;
   _linkSeam.ensureDir(binDir);
-  const linkPath = path46.join(binDir, "bd");
+  const linkPath = path47.join(binDir, "bd");
   if (linkPath === binaryPath) return;
   const current = _linkSeam.readlink(linkPath);
   if (current === binaryPath) return;
@@ -18195,7 +18399,7 @@ function dedupeRecipes(agents) {
 
 // src/beads/watcher.ts
 var crypto4 = __toESM(require("crypto"));
-var path47 = __toESM(require("path"));
+var path48 = __toESM(require("path"));
 var API_BASE6 = resolveApiBaseUrl();
 var DEBOUNCE_MS2 = 400;
 var ZERO_SUMMARY = {
@@ -18219,7 +18423,7 @@ var BeadsWatcher = class {
   constructor(opts) {
     this.opts = opts;
     this.bd = opts.adapter ?? new BdAdapter({ cwd: opts.cwd, beadsDir: opts.beadsDir });
-    this.feedPath = opts.feedPath ?? path47.join(opts.cwd ?? process.cwd(), ".beads", "last-touched");
+    this.feedPath = opts.feedPath ?? path48.join(opts.cwd ?? process.cwd(), ".beads", "last-touched");
     this.apiBase = opts.apiBaseUrl ?? API_BASE6;
   }
   opts;
@@ -18306,9 +18510,10 @@ var BeadsWatcher = class {
       projectLabel,
       fullSnapshot: true,
       issues,
-      // The backend DTO requires `dependencies` (not `deps`). We don't track
-      // edges in the P0 snapshot yet, so always send an empty array rather than
-      // omitting the field (an omitted/conditional field 400s the ingest).
+      // We don't track edges in the P0 snapshot yet, so send an empty array.
+      // (The backend DTO marks `dependencies` optional and tolerates absence,
+      // but the wire contract in @codeagent/shared says "always sent" — keep
+      // the payload deterministic.)
       dependencies: [],
       memories: [],
       // Always send a summary — a null `bd status` yields a zeroed block rather
@@ -18629,7 +18834,7 @@ var pendingAttachmentFiles = /* @__PURE__ */ new Set();
 function cleanupAttachmentTempFiles() {
   for (const p2 of pendingAttachmentFiles) {
     try {
-      fs44.unlinkSync(p2);
+      fs45.unlinkSync(p2);
     } catch {
     }
   }
@@ -18638,8 +18843,8 @@ function cleanupAttachmentTempFiles() {
 function saveFilesTemp(files) {
   return files.filter(({ base64 }) => base64 && base64.length > 0).map(({ filename, base64 }) => {
     const safeName = filename.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 80);
-    const tmpPath = path49.join(os37.tmpdir(), `codeam-${(0, import_crypto3.randomUUID)()}-${safeName}`);
-    fs44.writeFileSync(tmpPath, Buffer.from(base64, "base64"));
+    const tmpPath = path50.join(os38.tmpdir(), `codeam-${(0, import_crypto3.randomUUID)()}-${safeName}`);
+    fs45.writeFileSync(tmpPath, Buffer.from(base64, "base64"));
     pendingAttachmentFiles.add(tmpPath);
     return tmpPath;
   });
@@ -18659,7 +18864,7 @@ var startTask = (ctx, _cmd, parsed) => {
     setTimeout(() => {
       for (const p2 of paths) {
         try {
-          fs44.unlinkSync(p2);
+          fs45.unlinkSync(p2);
         } catch {
         }
         pendingAttachmentFiles.delete(p2);
@@ -18860,9 +19065,9 @@ var listFiles = async (ctx, cmd, parsed) => {
   await ctx.relay.sendResult(cmd.id, "completed", result);
 };
 var envReadH = async (ctx, cmd) => {
-  const envPath = path49.join(process.cwd(), ".env");
+  const envPath = path50.join(process.cwd(), ".env");
   try {
-    const raw = await fs44.promises.readFile(envPath, "utf8");
+    const raw = await fs45.promises.readFile(envPath, "utf8");
     await ctx.relay.sendResult(cmd.id, "completed", {
       exists: true,
       vars: parseDotenv(raw)
@@ -18893,14 +19098,14 @@ var envWriteH = async (ctx, cmd, parsed) => {
     }
     seen.add(v.key);
   }
-  const envPath = path49.join(process.cwd(), ".env");
-  const tmpPath = path49.join(process.cwd(), ".env.codeam.tmp");
+  const envPath = path50.join(process.cwd(), ".env");
+  const tmpPath = path50.join(process.cwd(), ".env.codeam.tmp");
   try {
-    await fs44.promises.writeFile(tmpPath, serializeDotenv(vars), "utf8");
-    await fs44.promises.rename(tmpPath, envPath);
+    await fs45.promises.writeFile(tmpPath, serializeDotenv(vars), "utf8");
+    await fs45.promises.rename(tmpPath, envPath);
     await ctx.relay.sendResult(cmd.id, "completed", { ok: true, count: vars.length });
   } catch (err) {
-    await fs44.promises.rm(tmpPath, { force: true }).catch(() => void 0);
+    await fs45.promises.rm(tmpPath, { force: true }).catch(() => void 0);
     await ctx.relay.sendResult(cmd.id, "failed", { error: err.message });
   }
 };
@@ -18918,7 +19123,7 @@ var headroomConfigureH = async (ctx, cmd, parsed) => {
   let configuredAgent = rawAgentId;
   if (!configuredAgent) {
     try {
-      const raw = JSON.parse(fs44.readFileSync(headroomConfigPath(), "utf8"));
+      const raw = JSON.parse(fs45.readFileSync(headroomConfigPath(), "utf8"));
       configuredAgent = raw.agent ?? "";
     } catch {
     }
@@ -18931,7 +19136,7 @@ var headroomConfigureH = async (ctx, cmd, parsed) => {
     setup: setupHeadroomForSelfHosted,
     probeStats: async () => {
       try {
-        const res = await fetch("http://localhost:8787/stats");
+        const res = await fetchWithTimeout("http://localhost:8787/stats");
         if (!res.ok) return null;
         const raw = await res.json();
         return mapStatsToSavings(raw, {
@@ -18952,7 +19157,7 @@ var headroomConfigureH = async (ctx, cmd, parsed) => {
     persist: persistHeadroomConfig,
     readEnabled: () => {
       try {
-        const raw = JSON.parse(fs44.readFileSync(headroomConfigPath(), "utf8"));
+        const raw = JSON.parse(fs45.readFileSync(headroomConfigPath(), "utf8"));
         return raw.enabled === true;
       } catch {
         return false;
@@ -18962,12 +19167,12 @@ var headroomConfigureH = async (ctx, cmd, parsed) => {
       _activeReporter?.stop();
       const reporter = new HeadroomStatsReporter({
         fetchStats: async () => {
-          const res = await fetch("http://localhost:8787/stats");
+          const res = await fetchWithTimeout("http://localhost:8787/stats");
           return res.json();
         },
         postSavings: async (delta, budget) => {
           if (!opts.ingestUrl) return;
-          await fetch(opts.ingestUrl, {
+          const res = await fetchWithTimeout(opts.ingestUrl, {
             method: "POST",
             headers: {
               "Content-Type": "application/json",
@@ -18988,10 +19193,14 @@ var headroomConfigureH = async (ctx, cmd, parsed) => {
               ...budget ? {
                 periodSpendUsd: budget.periodSpendUsd,
                 budgetUsd: budget.budgetUsd,
-                budgetPeriod: budget.budgetPeriod
+                budgetPeriod: budget.budgetPeriod,
+                budgetReached: budget.budgetReached
               } : {}
             })
           });
+          if (!res.ok) {
+            log.warn("headroom", `savings POST rejected ${res.status} \u2014 delta not credited`);
+          }
         }
       });
       reporter.start();
@@ -19002,18 +19211,9 @@ var headroomConfigureH = async (ctx, cmd, parsed) => {
       _activeReporter = null;
     },
     restoreAgentHeadroomConfig: (kind) => restoreAgentHeadroomConfig(kind),
-    stopProxy: () => {
-      try {
-        const p2 = (0, import_child_process22.spawn)("pkill", ["-TERM", "-f", "headroom.*proxy"], {
-          detached: true,
-          stdio: "ignore"
-        });
-        p2.on("error", () => {
-        });
-        p2.unref();
-      } catch {
-      }
-    },
+    // Targeted pidfile kill; falls back to the legacy pkill pattern only when
+    // no live recorded pid exists. Best-effort — never throws.
+    stopProxy: () => killHeadroomProxy(),
     emit: (event) => {
       const token = ctx.pluginAuthToken;
       if (!token) return;
@@ -19046,7 +19246,7 @@ var headroomBudgetH = async (ctx, cmd) => {
   }
   let headroomActive = false;
   try {
-    const raw = JSON.parse(fs44.readFileSync(headroomConfigPath(), "utf8"));
+    const raw = JSON.parse(fs45.readFileSync(headroomConfigPath(), "utf8"));
     headroomActive = raw.enabled === true;
   } catch {
   }
@@ -19056,7 +19256,7 @@ var headroomBudgetH = async (ctx, cmd) => {
   }
   let existingConfig = { enabled: true };
   try {
-    existingConfig = JSON.parse(fs44.readFileSync(headroomConfigPath(), "utf8"));
+    existingConfig = JSON.parse(fs45.readFileSync(headroomConfigPath(), "utf8"));
   } catch {
   }
   if (payload.budgetEnabled && payload.budgetUsd != null) {
@@ -19135,7 +19335,7 @@ var beadsConfigureH = async (ctx, cmd, parsed) => {
           sessionId: ctx.sessionId,
           pluginId: ctx.pluginId,
           pluginAuthToken: token,
-          type: "beads_status",
+          type: USER_EVENTS.BEADS_STATUS,
           payload: Object.fromEntries(
             Object.entries(event).filter(([k2]) => k2 !== "type")
           )
@@ -19174,13 +19374,13 @@ var CLI_UPDATE_MAX_ATTEMPTS = 3;
 function buildNpmInstallInvocation(opts) {
   const entryScript = opts?.entryScript ?? process.argv[1] ?? "";
   const execPath = opts?.execPath ?? process.execPath;
-  const exists2 = opts?.existsSync ?? fs44.existsSync;
-  const normalized = entryScript.split(path49.sep).join("/");
+  const exists2 = opts?.existsSync ?? fs45.existsSync;
+  const normalized = entryScript.split(path50.sep).join("/");
   const marker = "/lib/node_modules/codeam-cli/";
   const markerIdx = normalized.indexOf(marker);
   const prefix = markerIdx > 0 ? entryScript.slice(0, markerIdx) : null;
-  const siblingNpm = path49.join(
-    path49.dirname(execPath),
+  const siblingNpm = path50.join(
+    path50.dirname(execPath),
     process.platform === "win32" ? "npm.cmd" : "npm"
   );
   const command2 = exists2(siblingNpm) ? siblingNpm : "npm";
@@ -19526,7 +19726,7 @@ var requestPreviewDetectH = (ctx) => {
       sessionId: ctx.sessionId,
       pluginId: ctx.pluginId,
       pluginAuthToken: ctx.pluginAuthToken,
-      type: "preview_error",
+      type: USER_EVENTS.PREVIEW_ERROR,
       payload: {
         stage: "detection",
         message: `Preview detection isn't available on ${ctx.runtime.id} sessions yet \u2014 link a Claude or Codex agent.`
@@ -19543,7 +19743,7 @@ var requestPreviewDetectH = (ctx) => {
         sessionId: ctx.sessionId,
         pluginId: ctx.pluginId,
         pluginAuthToken,
-        type: "preview_detection_ready",
+        type: USER_EVENTS.PREVIEW_DETECTION_READY,
         payload: { detection: fromFile }
       });
       return;
@@ -19552,7 +19752,7 @@ var requestPreviewDetectH = (ctx) => {
       sessionId: ctx.sessionId,
       pluginId: ctx.pluginId,
       pluginAuthToken,
-      type: "preview_detection_pending"
+      type: USER_EVENTS.PREVIEW_DETECTION_PENDING
     });
     log.info("preview", "detect: invoking generateOneShot");
     const startedAt = Date.now();
@@ -19568,7 +19768,7 @@ var requestPreviewDetectH = (ctx) => {
         sessionId: ctx.sessionId,
         pluginId: ctx.pluginId,
         pluginAuthToken,
-        type: "preview_error",
+        type: USER_EVENTS.PREVIEW_ERROR,
         payload: {
           stage: "detection",
           message: "Agent returned invalid JSON. Try again, or add a .codeam/preview.json override."
@@ -19582,7 +19782,7 @@ var requestPreviewDetectH = (ctx) => {
         sessionId: ctx.sessionId,
         pluginId: ctx.pluginId,
         pluginAuthToken,
-        type: "preview_error",
+        type: USER_EVENTS.PREVIEW_ERROR,
         payload: {
           stage: "unsupported",
           message: detection.notes ?? "No dev server applies to this project."
@@ -19598,7 +19798,7 @@ var requestPreviewDetectH = (ctx) => {
       sessionId: ctx.sessionId,
       pluginId: ctx.pluginId,
       pluginAuthToken,
-      type: "preview_detection_ready",
+      type: USER_EVENTS.PREVIEW_DETECTION_READY,
       payload: { detection }
     });
   })();
@@ -19687,8 +19887,8 @@ function normalizeDetectionForSpawn(detection, cwd) {
   if (args2.length === 0) return detection;
   const binName = args2[0];
   if (binName.startsWith("-")) return detection;
-  const binPath = path49.join(cwd, "node_modules", ".bin", binName);
-  if (!fs44.existsSync(binPath)) return detection;
+  const binPath = path50.join(cwd, "node_modules", ".bin", binName);
+  if (!fs45.existsSync(binPath)) return detection;
   return {
     ...detection,
     command: binPath,
@@ -19715,7 +19915,7 @@ function startPreviewFromDetection(ctx, detection, pluginAuthToken) {
       sessionId: ctx.sessionId,
       pluginId: ctx.pluginId,
       pluginAuthToken,
-      type: "preview_progress",
+      type: USER_EVENTS.PREVIEW_PROGRESS,
       payload: { step, message, timestamp: Date.now() }
     });
   };
@@ -19731,7 +19931,7 @@ function startPreviewFromDetection(ctx, detection, pluginAuthToken) {
         sessionId: ctx.sessionId,
         pluginId: ctx.pluginId,
         pluginAuthToken,
-        type: "preview_ready",
+        type: USER_EVENTS.PREVIEW_READY,
         payload: { url: existing.url, framework: existing.framework, port: detection.port }
       });
       return;
@@ -19740,7 +19940,7 @@ function startPreviewFromDetection(ctx, detection, pluginAuthToken) {
       sessionId: ctx.sessionId,
       pluginId: ctx.pluginId,
       pluginAuthToken,
-      type: "preview_starting",
+      type: USER_EVENTS.PREVIEW_STARTING,
       payload: { framework: detection.framework, port: detection.port }
     });
     emitProgress("ENV_DETECTED", `${detection.framework}`);
@@ -19767,7 +19967,7 @@ function startPreviewFromDetection(ctx, detection, pluginAuthToken) {
             sessionId: ctx.sessionId,
             pluginId: ctx.pluginId,
             pluginAuthToken,
-            type: "preview_error",
+            type: USER_EVENTS.PREVIEW_ERROR,
             payload: {
               stage: "spawn",
               message: `This project uses yarn but yarn isn't installed, and installing it automatically failed (npm install -g yarn, exit ${ensured.code}). Install yarn in this environment and try the preview again.`
@@ -19792,7 +19992,7 @@ function startPreviewFromDetection(ctx, detection, pluginAuthToken) {
           sessionId: ctx.sessionId,
           pluginId: ctx.pluginId,
           pluginAuthToken,
-          type: "preview_error",
+          type: USER_EVENTS.PREVIEW_ERROR,
           payload: {
             stage: "ready_timeout",
             message: `Dependency install (${missingDeps.cmd} ${missingDeps.args.join(" ")}) didn't finish within ${Math.round(INSTALL_TIMEOUT_MS / 1e3)}s and was stopped. Run it manually in this project, then try the preview again.`
@@ -19805,7 +20005,7 @@ function startPreviewFromDetection(ctx, detection, pluginAuthToken) {
           sessionId: ctx.sessionId,
           pluginId: ctx.pluginId,
           pluginAuthToken,
-          type: "preview_error",
+          type: USER_EVENTS.PREVIEW_ERROR,
           payload: {
             stage: "spawn",
             message: `Dependency install failed (${missingDeps.cmd} ${missingDeps.args.join(" ")}, exit ${result.code}). Run it manually in this project and try again.`
@@ -19842,7 +20042,7 @@ function startPreviewFromDetection(ctx, detection, pluginAuthToken) {
           sessionId: ctx.sessionId,
           pluginId: ctx.pluginId,
           pluginAuthToken,
-          type: "preview_error",
+          type: USER_EVENTS.PREVIEW_ERROR,
           payload: {
             stage: "ready_timeout",
             message: `Setup step (${setup.cmd} ${setup.args.join(" ")}) didn't finish within ${Math.round(timeoutMs / 1e3)}s and was stopped.`
@@ -19855,7 +20055,7 @@ function startPreviewFromDetection(ctx, detection, pluginAuthToken) {
           sessionId: ctx.sessionId,
           pluginId: ctx.pluginId,
           pluginAuthToken,
-          type: "preview_error",
+          type: USER_EVENTS.PREVIEW_ERROR,
           payload: {
             stage: "spawn",
             message: `Setup failed (${setup.cmd} ${setup.args.join(" ")}, exit ${result.code}).`
@@ -19876,7 +20076,7 @@ function startPreviewFromDetection(ctx, detection, pluginAuthToken) {
           sessionId: ctx.sessionId,
           pluginId: ctx.pluginId,
           pluginAuthToken,
-          type: "preview_ready",
+          type: USER_EVENTS.PREVIEW_READY,
           payload: { url: raceExisting.url, framework: raceExisting.framework, port: detection.port }
         });
         return;
@@ -19896,7 +20096,7 @@ function startPreviewFromDetection(ctx, detection, pluginAuthToken) {
             sessionId: ctx.sessionId,
             pluginId: ctx.pluginId,
             pluginAuthToken,
-            type: "preview_error",
+            type: USER_EVENTS.PREVIEW_ERROR,
             payload: {
               stage: "spawn",
               message: `Port ${detection.port} is still in use after stopping the previous preview. Wait a moment and try again.`
@@ -19909,7 +20109,7 @@ function startPreviewFromDetection(ctx, detection, pluginAuthToken) {
           sessionId: ctx.sessionId,
           pluginId: ctx.pluginId,
           pluginAuthToken,
-          type: "preview_error",
+          type: USER_EVENTS.PREVIEW_ERROR,
           payload: {
             stage: "spawn",
             message: `Port ${detection.port} is already in use by another process, so the dev server can't start there. Stop whatever is listening on port ${detection.port} and try the preview again.`
@@ -19957,7 +20157,7 @@ function startPreviewFromDetection(ctx, detection, pluginAuthToken) {
         sessionId: ctx.sessionId,
         pluginId: ctx.pluginId,
         pluginAuthToken,
-        type: "preview_error",
+        type: USER_EVENTS.PREVIEW_ERROR,
         payload: {
           stage: "spawn",
           message: `The dev server exited (code ${outcome.code}) before it was ready. It may need a database or other services.`,
@@ -19972,7 +20172,7 @@ function startPreviewFromDetection(ctx, detection, pluginAuthToken) {
         sessionId: ctx.sessionId,
         pluginId: ctx.pluginId,
         pluginAuthToken,
-        type: "preview_error",
+        type: USER_EVENTS.PREVIEW_ERROR,
         payload: {
           stage: "ready_timeout",
           message: "The dev server didn't become ready in time. It may be stuck waiting on a database or other service.",
@@ -20001,7 +20201,7 @@ function startPreviewFromDetection(ctx, detection, pluginAuthToken) {
           sessionId: ctx.sessionId,
           pluginId: ctx.pluginId,
           pluginAuthToken,
-          type: "preview_error",
+          type: USER_EVENTS.PREVIEW_ERROR,
           payload: { stage: "tunnel", message: "Expo did not report a tunnel URL." }
         });
         return;
@@ -20017,7 +20217,7 @@ function startPreviewFromDetection(ctx, detection, pluginAuthToken) {
           sessionId: ctx.sessionId,
           pluginId: ctx.pluginId,
           pluginAuthToken,
-          type: "preview_error",
+          type: USER_EVENTS.PREVIEW_ERROR,
           payload: { stage: "tunnel", message: e.message }
         });
         return;
@@ -20111,7 +20311,7 @@ function startPreviewFromDetection(ctx, detection, pluginAuthToken) {
           sessionId: ctx.sessionId,
           pluginId: ctx.pluginId,
           pluginAuthToken,
-          type: "preview_error",
+          type: USER_EVENTS.PREVIEW_ERROR,
           payload: {
             stage: "tunnel",
             message: `Tunnel did not become reachable after ${MAX_TUNNEL_ATTEMPTS} attempts (${lastTunnelErr}). Cloudflare Quick Tunnels occasionally fail to register \u2014 please retry.`
@@ -20135,7 +20335,7 @@ function startPreviewFromDetection(ctx, detection, pluginAuthToken) {
       sessionId: ctx.sessionId,
       pluginId: ctx.pluginId,
       pluginAuthToken,
-      type: "preview_ready",
+      type: USER_EVENTS.PREVIEW_READY,
       payload: { url, framework: detection.framework, port: detection.port }
     });
   })().catch((err) => {
@@ -20145,7 +20345,7 @@ function startPreviewFromDetection(ctx, detection, pluginAuthToken) {
       sessionId: ctx.sessionId,
       pluginId: ctx.pluginId,
       pluginAuthToken,
-      type: "preview_error",
+      type: USER_EVENTS.PREVIEW_ERROR,
       payload: { stage: "spawn", message: `Preview failed to start: ${message}` }
     });
   });
@@ -20163,7 +20363,7 @@ var previewStopH = (ctx) => {
       sessionId: ctx.sessionId,
       pluginId: ctx.pluginId,
       pluginAuthToken,
-      type: "preview_stopped",
+      type: USER_EVENTS.PREVIEW_STOPPED,
       payload: { reason: "user" }
     });
   })();
@@ -20507,12 +20707,12 @@ function readTokenFromArgs(args2) {
   }
   const fileFlag = args2.find((a) => a.startsWith("--token-file="));
   if (fileFlag) {
-    const path64 = fileFlag.slice("--token-file=".length);
+    const path65 = fileFlag.slice("--token-file=".length);
     try {
-      const content = fs45.readFileSync(path64, "utf8").trim();
-      if (content.length === 0) fail(`--token-file ${path64} is empty`);
+      const content = fs46.readFileSync(path65, "utf8").trim();
+      if (content.length === 0) fail(`--token-file ${path65} is empty`);
       try {
-        fs45.unlinkSync(path64);
+        fs46.unlinkSync(path65);
       } catch {
       }
       return content;
@@ -20538,7 +20738,7 @@ async function claimOnce(token, pluginId, pluginSecretHash) {
     pluginId,
     ideName: "codeam-cli (codespace)",
     ideVersion: process.env.npm_package_version ?? "unknown",
-    hostname: os38.hostname(),
+    hostname: os39.hostname(),
     codespaceName: process.env.CODESPACE_NAME ?? "",
     // Current git branch of the codespace's working directory, so the
     // backend can populate `PairedSession.branch` for the codespace pair.
@@ -20599,7 +20799,7 @@ async function claim(token, pluginId, pluginSecretHash) {
   }
 }
 function pairAutoLockPath() {
-  return path50.join(os38.homedir(), ".codeam", "pair-auto.lock");
+  return path51.join(os39.homedir(), ".codeam", "pair-auto.lock");
 }
 function isLivePairAuto(pid) {
   if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid) return false;
@@ -20609,7 +20809,7 @@ function isLivePairAuto(pid) {
     if (e.code !== "EPERM") return false;
   }
   try {
-    return fs45.readFileSync(`/proc/${pid}/cmdline`, "utf8").includes("codeam");
+    return fs46.readFileSync(`/proc/${pid}/cmdline`, "utf8").includes("codeam");
   } catch {
     return true;
   }
@@ -20619,24 +20819,24 @@ function isLiveCodeam(pid) {
 }
 function daemonLockPath(sessionId) {
   const safe = sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return path50.join(os38.homedir(), ".codeam", `daemon-${safe}.lock`);
+  return path51.join(os39.homedir(), ".codeam", `daemon-${safe}.lock`);
 }
 function acquireDaemonLock(sessionId) {
   const lockPath = daemonLockPath(sessionId);
   try {
-    fs45.mkdirSync(path50.dirname(lockPath), { recursive: true });
+    fs46.mkdirSync(path51.dirname(lockPath), { recursive: true });
     try {
-      fs45.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+      fs46.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
     } catch (e) {
       if (e.code !== "EEXIST") throw e;
-      const holder = Number(fs45.readFileSync(lockPath, "utf8").trim());
+      const holder = Number(fs46.readFileSync(lockPath, "utf8").trim());
       if (holder && holder !== process.pid && isLiveCodeam(holder)) return false;
-      fs45.writeFileSync(lockPath, String(process.pid));
+      fs46.writeFileSync(lockPath, String(process.pid));
     }
     const release3 = () => {
       try {
-        if (fs45.existsSync(lockPath) && Number(fs45.readFileSync(lockPath, "utf8").trim()) === process.pid) {
-          fs45.unlinkSync(lockPath);
+        if (fs46.existsSync(lockPath) && Number(fs46.readFileSync(lockPath, "utf8").trim()) === process.pid) {
+          fs46.unlinkSync(lockPath);
         }
       } catch {
       }
@@ -20658,19 +20858,19 @@ function acquireDaemonLock(sessionId) {
 function acquireSingletonLock() {
   const lockPath = pairAutoLockPath();
   try {
-    fs45.mkdirSync(path50.dirname(lockPath), { recursive: true });
+    fs46.mkdirSync(path51.dirname(lockPath), { recursive: true });
     try {
-      fs45.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+      fs46.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
     } catch (e) {
       if (e.code !== "EEXIST") throw e;
-      const holder = Number(fs45.readFileSync(lockPath, "utf8").trim());
+      const holder = Number(fs46.readFileSync(lockPath, "utf8").trim());
       if (isLivePairAuto(holder)) return false;
-      fs45.writeFileSync(lockPath, String(process.pid));
+      fs46.writeFileSync(lockPath, String(process.pid));
     }
     process.once("exit", () => {
       try {
-        if (fs45.existsSync(lockPath) && Number(fs45.readFileSync(lockPath, "utf8").trim()) === process.pid) {
-          fs45.unlinkSync(lockPath);
+        if (fs46.existsSync(lockPath) && Number(fs46.readFileSync(lockPath, "utf8").trim()) === process.pid) {
+          fs46.unlinkSync(lockPath);
         }
       } catch {
       }
@@ -20752,7 +20952,7 @@ async function pairAuto(args2) {
 }
 
 // src/services/headroom/wrap-launch.ts
-var import_node_child_process16 = require("child_process");
+var import_node_child_process17 = require("child_process");
 function wrapWithHeadroom(launch, opts) {
   if (!opts.enabled || !opts.headroomPresent) return launch;
   return {
@@ -20765,7 +20965,7 @@ var _present;
 function headroomPresent() {
   if (_present !== void 0) return Promise.resolve(_present);
   return new Promise((resolve7) => {
-    (0, import_node_child_process16.execFile)("headroom", ["--version"], (err) => {
+    (0, import_node_child_process17.execFile)("headroom", ["--version"], (err) => {
       _present = !err;
       resolve7(_present);
     });
@@ -21115,7 +21315,7 @@ var AgentService = class _AgentService {
 };
 
 // src/agents/acp/adapters.ts
-var path52 = __toESM(require("path"));
+var path53 = __toESM(require("path"));
 
 // src/agents/acp/agent-binary.ts
 var import_fs4 = __toESM(require("fs"));
@@ -21268,13 +21468,13 @@ function resolveBin(pkgName, binName) {
   try {
     const manifestPath = require_.resolve(`${pkgName}/package.json`);
     const manifest = require_(`${pkgName}/package.json`);
-    const pkgDir = path52.dirname(manifestPath);
+    const pkgDir = path53.dirname(manifestPath);
     const bin = manifest.bin;
     if (!bin) return null;
-    if (typeof bin === "string") return path52.resolve(pkgDir, bin);
+    if (typeof bin === "string") return path53.resolve(pkgDir, bin);
     const target = binName ?? Object.keys(bin)[0];
     if (!target || !bin[target]) return null;
-    return path52.resolve(pkgDir, bin[target]);
+    return path53.resolve(pkgDir, bin[target]);
   } catch {
     return null;
   }
@@ -21349,20 +21549,20 @@ function requiresAcp(agent) {
 var import_node_crypto7 = require("crypto");
 
 // src/services/history.service.ts
-var fs47 = __toESM(require("fs"));
-var path53 = __toESM(require("path"));
-var os39 = __toESM(require("os"));
+var fs48 = __toESM(require("fs"));
+var path54 = __toESM(require("path"));
+var os40 = __toESM(require("os"));
 var https7 = __toESM(require("https"));
 var http6 = __toESM(require("http"));
-var import_zod2 = require("zod");
-var historyRecordSchema = import_zod2.z.object({
-  type: import_zod2.z.string().optional(),
-  timestamp: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number()]).optional(),
-  uuid: import_zod2.z.string().optional(),
-  isMeta: import_zod2.z.boolean().optional(),
-  message: import_zod2.z.object({
+var import_zod3 = require("zod");
+var historyRecordSchema = import_zod3.z.object({
+  type: import_zod3.z.string().optional(),
+  timestamp: import_zod3.z.union([import_zod3.z.string(), import_zod3.z.number()]).optional(),
+  uuid: import_zod3.z.string().optional(),
+  isMeta: import_zod3.z.boolean().optional(),
+  message: import_zod3.z.object({
     // Claude content is either a string or an array of typed blocks.
-    content: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.array(import_zod2.z.unknown())]).optional()
+    content: import_zod3.z.union([import_zod3.z.string(), import_zod3.z.array(import_zod3.z.unknown())]).optional()
   }).passthrough().optional()
 }).passthrough();
 var API_BASE8 = resolveApiBaseUrl();
@@ -21378,7 +21578,7 @@ function parseJsonl(filePath) {
   const messages = [];
   let raw;
   try {
-    raw = fs47.readFileSync(filePath, "utf8");
+    raw = fs48.readFileSync(filePath, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") {
       log.warn("history:parseJsonl", `read failed for ${filePath}`, err);
@@ -21519,7 +21719,7 @@ var HistoryService = class _HistoryService {
     return this._quotaPercent === null || Date.now() - this._quotaFetchedAt > ttlMs;
   }
   get projectDir() {
-    return this.runtime.resolveHistoryDir(this.cwd) ?? path53.join(os39.homedir(), ".claude", "projects", encodeCwd(this.cwd));
+    return this.runtime.resolveHistoryDir(this.cwd) ?? path54.join(os40.homedir(), ".claude", "projects", encodeCwd(this.cwd));
   }
   /** Set the current Claude conversation ID (extracted from /cost command or session start) */
   setCurrentConversationId(id) {
@@ -21531,7 +21731,7 @@ var HistoryService = class _HistoryService {
   /** Return the current message count in the active conversation. */
   getCurrentMessageCount() {
     if (!this.currentConversationId) return 0;
-    const filePath = path53.join(this.projectDir, `${this.currentConversationId}.jsonl`);
+    const filePath = path54.join(this.projectDir, `${this.currentConversationId}.jsonl`);
     return parseJsonl(filePath).length;
   }
   /**
@@ -21542,7 +21742,7 @@ var HistoryService = class _HistoryService {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
       if (!this.currentConversationId) return null;
-      const filePath = path53.join(this.projectDir, `${this.currentConversationId}.jsonl`);
+      const filePath = path54.join(this.projectDir, `${this.currentConversationId}.jsonl`);
       const messages = parseJsonl(filePath);
       if (messages.length > previousCount) {
         for (let i = messages.length - 1; i >= previousCount; i--) {
@@ -21568,16 +21768,16 @@ var HistoryService = class _HistoryService {
     const dir = this.projectDir;
     const cutoff = this.bootTimeMs - _HistoryService.BIRTHTIME_GRACE_MS;
     try {
-      const files = fs47.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => {
+      const files = fs48.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => {
         try {
-          const stat3 = fs47.statSync(path53.join(dir, e.name));
+          const stat3 = fs48.statSync(path54.join(dir, e.name));
           return { name: e.name, mtime: stat3.mtimeMs, birthtime: stat3.birthtimeMs };
         } catch {
           return { name: e.name, mtime: 0, birthtime: 0 };
         }
       }).filter((f) => f.birthtime >= cutoff).sort((a, b) => b.mtime - a.mtime);
       if (files.length > 0) {
-        this.currentConversationId = path53.basename(files[0].name, ".jsonl");
+        this.currentConversationId = path54.basename(files[0].name, ".jsonl");
       }
     } catch {
     }
@@ -21611,13 +21811,13 @@ var HistoryService = class _HistoryService {
     const cutoff = this.bootTimeMs - _HistoryService.BIRTHTIME_GRACE_MS;
     let entries;
     try {
-      entries = fs47.readdirSync(dir, { withFileTypes: true });
+      entries = fs48.readdirSync(dir, { withFileTypes: true });
     } catch {
       return null;
     }
     const files = entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => {
       try {
-        const stat3 = fs47.statSync(path53.join(dir, e.name));
+        const stat3 = fs48.statSync(path54.join(dir, e.name));
         return { name: e.name, mtime: stat3.mtimeMs, birthtime: stat3.birthtimeMs };
       } catch {
         return { name: e.name, mtime: 0, birthtime: 0 };
@@ -21626,12 +21826,12 @@ var HistoryService = class _HistoryService {
     if (files.length === 0) return null;
     const targetFile = this.currentConversationId ? `${this.currentConversationId}.jsonl` : files[0].name;
     if (!files.some((f) => f.name === targetFile)) return null;
-    return this.extractUsageFromFile(path53.join(dir, targetFile));
+    return this.extractUsageFromFile(path54.join(dir, targetFile));
   }
   extractUsageFromFile(filePath) {
     let raw;
     try {
-      raw = fs47.readFileSync(filePath, "utf8");
+      raw = fs48.readFileSync(filePath, "utf8");
     } catch {
       return null;
     }
@@ -21676,9 +21876,9 @@ var HistoryService = class _HistoryService {
     let totalCost = 0;
     let files;
     try {
-      files = fs47.readdirSync(projectDir).filter((f) => f.endsWith(".jsonl")).filter((f) => {
+      files = fs48.readdirSync(projectDir).filter((f) => f.endsWith(".jsonl")).filter((f) => {
         try {
-          return fs47.statSync(path53.join(projectDir, f)).mtimeMs >= monthStartMs;
+          return fs48.statSync(path54.join(projectDir, f)).mtimeMs >= monthStartMs;
         } catch {
           return false;
         }
@@ -21689,7 +21889,7 @@ var HistoryService = class _HistoryService {
     for (const file of files) {
       let raw;
       try {
-        raw = fs47.readFileSync(path53.join(projectDir, file), "utf8");
+        raw = fs48.readFileSync(path54.join(projectDir, file), "utf8");
       } catch {
         continue;
       }
@@ -21768,7 +21968,7 @@ var HistoryService = class _HistoryService {
     if (this.runtime.resolveHistoryFile) {
       return this.runtime.resolveHistoryFile(this.cwd, sessionId);
     }
-    return path53.join(this.projectDir, `${sessionId}.jsonl`);
+    return path54.join(this.projectDir, `${sessionId}.jsonl`);
   }
   /**
    * Parse a conversation's messages from disk, agent-aware. Claude uses the
@@ -21802,7 +22002,7 @@ var HistoryService = class _HistoryService {
         };
       });
     }
-    return parseJsonl(path53.join(this.projectDir, `${sessionId}.jsonl`));
+    return parseJsonl(path54.join(this.projectDir, `${sessionId}.jsonl`));
   }
   async loadConversation(sessionId) {
     const messages = this.readConversation(sessionId);
@@ -21858,7 +22058,7 @@ var HistoryService = class _HistoryService {
     if (!filePath) return false;
     let mtimeMs;
     try {
-      mtimeMs = fs47.statSync(filePath).mtimeMs;
+      mtimeMs = fs48.statSync(filePath).mtimeMs;
     } catch {
       return false;
     }
@@ -21926,11 +22126,11 @@ var HistoryService = class _HistoryService {
 };
 
 // src/agents/acp/client.ts
-var import_node_child_process17 = require("child_process");
-var fs48 = __toESM(require("fs/promises"));
+var import_node_child_process18 = require("child_process");
+var fs49 = __toESM(require("fs/promises"));
 var fsSync = __toESM(require("fs"));
-var os40 = __toESM(require("os"));
-var path54 = __toESM(require("path"));
+var os41 = __toESM(require("os"));
+var path55 = __toESM(require("path"));
 var import_node_stream = require("stream");
 
 // ../../node_modules/@agentclientprotocol/sdk/dist/acp.js
@@ -24477,7 +24677,7 @@ var AcpClient = class {
       "acpClient",
       `spawn cmd=${adapter.command} args=[${adapter.args.join(",")}] cwd=${cwd}`
     );
-    const child = (0, import_node_child_process17.spawn)(adapter.command, adapter.args, {
+    const child = (0, import_node_child_process18.spawn)(adapter.command, adapter.args, {
       cwd,
       // extraEnv (e.g. CLAUDE_CODE_DISABLE_1M_CONTEXT=1 on an on-demand
       // re-spawn) layers over process.env; PATH stays last so the augmented
@@ -24763,7 +24963,7 @@ var AcpClient = class {
       },
       readTextFile: async (params) => {
         try {
-          const content = await fs48.readFile(params.path, "utf8");
+          const content = await fs49.readFile(params.path, "utf8");
           return applyLineRange(content, params.line ?? null, params.limit ?? null);
         } catch (err) {
           const code = err.code;
@@ -24783,7 +24983,7 @@ var AcpClient = class {
       },
       writeTextFile: async (params) => {
         try {
-          await fs48.writeFile(params.path, params.content, "utf8");
+          await fs49.writeFile(params.path, params.content, "utf8");
           return {};
         } catch (err) {
           const code = err.code;
@@ -24832,25 +25032,25 @@ function applyLineRange(content, line, limit) {
   return { content: lines.slice(start2, end).join("\n") };
 }
 function knownAgentBinaryDirs() {
-  const home = os40.homedir();
+  const home = os41.homedir();
   const out2 = [];
   out2.push("/tmp/codeam-node20/bin");
   for (const root of [
     "/usr/local/share/nvm/versions/node",
-    path54.join(home, ".nvm/versions/node")
+    path55.join(home, ".nvm/versions/node")
   ]) {
     try {
       for (const child of fsSync.readdirSync(root)) {
-        out2.push(path54.join(root, child, "bin"));
+        out2.push(path55.join(root, child, "bin"));
       }
     } catch {
     }
   }
-  out2.push(path54.join(home, ".volta/bin"));
+  out2.push(path55.join(home, ".volta/bin"));
   out2.push("/usr/local/bin");
   out2.push("/usr/bin");
-  out2.push(path54.join(home, ".local/bin"));
-  out2.push(path54.join(home, "bin"));
+  out2.push(path55.join(home, ".local/bin"));
+  out2.push(path55.join(home, "bin"));
   return out2.filter((p2) => {
     try {
       return fsSync.statSync(p2).isDirectory();
@@ -24861,7 +25061,7 @@ function knownAgentBinaryDirs() {
 }
 function expandPathForAgentBinaries(existingPath) {
   const existing = new Set(
-    existingPath.split(path54.delimiter).filter((p2) => p2.length > 0)
+    existingPath.split(path55.delimiter).filter((p2) => p2.length > 0)
   );
   const additions = [];
   for (const dir of knownAgentBinaryDirs()) {
@@ -24871,7 +25071,7 @@ function expandPathForAgentBinaries(existingPath) {
     }
   }
   if (additions.length === 0) return existingPath;
-  return [...additions, existingPath].filter((p2) => p2.length > 0).join(path54.delimiter);
+  return [...additions, existingPath].filter((p2) => p2.length > 0).join(path55.delimiter);
 }
 
 // src/services/streaming/transport.ts
@@ -25416,15 +25616,15 @@ function commonPrefixLength(a, b) {
 
 // src/agents/acp/onboarding.ts
 var import_child_process25 = require("child_process");
-var fs49 = __toESM(require("fs"));
-var os41 = __toESM(require("os"));
-var path55 = __toESM(require("path"));
+var fs50 = __toESM(require("fs"));
+var os42 = __toESM(require("os"));
+var path56 = __toESM(require("path"));
 var _onboardingSeam = {
-  markerPath: (sessionId) => path55.join(os41.homedir(), ".codeam", "welcomed", `${sessionId}.done`),
-  exists: (p2) => fs49.existsSync(p2),
+  markerPath: (sessionId) => path56.join(os42.homedir(), ".codeam", "welcomed", `${sessionId}.done`),
+  exists: (p2) => fs50.existsSync(p2),
   write: (p2) => {
-    fs49.mkdirSync(path55.dirname(p2), { recursive: true });
-    fs49.writeFileSync(p2, "");
+    fs50.mkdirSync(path56.dirname(p2), { recursive: true });
+    fs50.writeFileSync(p2, "");
   },
   disabled: () => {
     const v = process.env.CODEAM_ONBOARDING_DISABLED;
@@ -25461,7 +25661,7 @@ function resolveRepoName(cwd) {
       if (name) return name;
     }
   }
-  const base = path55.basename(cwd || "");
+  const base = path56.basename(cwd || "");
   if (base && !isUuid(base)) return base;
   return "this project";
 }
@@ -25739,8 +25939,8 @@ var import_crypto5 = require("crypto");
 
 // src/services/turn-files/git-changeset.ts
 var import_child_process26 = require("child_process");
-var fs50 = __toESM(require("fs/promises"));
-var path56 = __toESM(require("path"));
+var fs51 = __toESM(require("fs/promises"));
+var path57 = __toESM(require("path"));
 async function collectRepoChangeset(opts) {
   const status2 = await runGit3(opts.repoRoot, ["status", "--porcelain=v1", "-z"]);
   if (status2 === null) return null;
@@ -25758,7 +25958,7 @@ async function collectRepoChangeset(opts) {
     let stats;
     if (row.fileStatus === "added" && numstatEntry === void 0) {
       const lineCount = await readUntrackedLineCount(
-        path56.join(opts.repoRoot, row.filePath)
+        path57.join(opts.repoRoot, row.filePath)
       );
       stats = { added: lineCount, removed: 0 };
     } else {
@@ -25789,7 +25989,7 @@ function readUntrackedLineCount(absPath) {
 }
 async function defaultReadUntrackedLineCount(absPath) {
   try {
-    const content = await fs50.readFile(absPath, "utf8");
+    const content = await fs51.readFile(absPath, "utf8");
     let count = 0;
     let pos = -1;
     while ((pos = content.indexOf("\n", pos + 1)) !== -1) {
@@ -25881,7 +26081,7 @@ function defaultRunGit(cwd, args2) {
   });
 }
 async function discoverRepos(workingDir, maxDepth = 4) {
-  const fs54 = await import("fs/promises");
+  const fs55 = await import("fs/promises");
   const out2 = [];
   await walk(workingDir, 0);
   return out2;
@@ -25889,7 +26089,7 @@ async function discoverRepos(workingDir, maxDepth = 4) {
     if (depth > maxDepth) return;
     let entries = [];
     try {
-      const dirents = await fs54.readdir(dir, { withFileTypes: true });
+      const dirents = await fs55.readdir(dir, { withFileTypes: true });
       entries = dirents.filter((d3) => !d3.name.startsWith(".") || d3.name === ".git").map((d3) => ({ name: d3.name, isDirectory: d3.isDirectory() }));
     } catch {
       return;
@@ -25900,8 +26100,8 @@ async function discoverRepos(workingDir, maxDepth = 4) {
     if (hasGit) {
       out2.push({
         repoRoot: dir,
-        repoPath: path56.relative(workingDir, dir),
-        repoName: path56.basename(dir)
+        repoPath: path57.relative(workingDir, dir),
+        repoName: path57.basename(dir)
       });
       return;
     }
@@ -25909,14 +26109,14 @@ async function discoverRepos(workingDir, maxDepth = 4) {
       if (!entry.isDirectory) continue;
       if (entry.name === "node_modules") continue;
       if (entry.name === "dist" || entry.name === "build") continue;
-      await walk(path56.join(dir, entry.name), depth + 1);
+      await walk(path57.join(dir, entry.name), depth + 1);
     }
   }
 }
 
 // src/services/turn-files/files-outbox.ts
-var fs51 = __toESM(require("fs/promises"));
-var path57 = __toESM(require("path"));
+var fs52 = __toESM(require("fs/promises"));
+var path58 = __toESM(require("path"));
 var import_os7 = require("os");
 var HOME_OUTBOX_DIR = ".codeam/outbox";
 var MAX_AGE_MS = 24 * 60 * 60 * 1e3;
@@ -25949,16 +26149,16 @@ var FilesOutbox = class {
   backoffIndex = 0;
   stopped = false;
   constructor(opts) {
-    const base = opts.baseDir ?? path57.join(homeDir(), HOME_OUTBOX_DIR);
-    this.filePath = path57.join(base, `${opts.sessionId}.jsonl`);
+    const base = opts.baseDir ?? path58.join(homeDir(), HOME_OUTBOX_DIR);
+    this.filePath = path58.join(base, `${opts.sessionId}.jsonl`);
     this.post = opts.post;
     this.autoSchedule = opts.autoSchedule !== false;
   }
   /** Persist the entry to disk and trigger a flush. Returns once the
    *  line is durable on disk (not once the POST succeeds). */
   async enqueue(entry) {
-    await fs51.mkdir(path57.dirname(this.filePath), { recursive: true });
-    await fs51.appendFile(this.filePath, JSON.stringify(entry) + "\n", "utf8");
+    await fs52.mkdir(path58.dirname(this.filePath), { recursive: true });
+    await fs52.appendFile(this.filePath, JSON.stringify(entry) + "\n", "utf8");
     this.backoffIndex = 0;
     if (this.autoSchedule) this.scheduleFlush(0);
   }
@@ -26047,7 +26247,7 @@ var FilesOutbox = class {
   async readAll() {
     let raw = "";
     try {
-      raw = await fs51.readFile(this.filePath, "utf8");
+      raw = await fs52.readFile(this.filePath, "utf8");
     } catch {
       return [];
     }
@@ -26071,12 +26271,12 @@ var FilesOutbox = class {
   async rewrite(entries) {
     const tmpPath = `${this.filePath}.${process.pid}.tmp`;
     if (entries.length === 0) {
-      await fs51.unlink(this.filePath).catch(() => void 0);
+      await fs52.unlink(this.filePath).catch(() => void 0);
       return;
     }
     const payload = entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
-    await fs51.writeFile(tmpPath, payload, "utf8");
-    await fs51.rename(tmpPath, this.filePath);
+    await fs52.writeFile(tmpPath, payload, "utf8");
+    await fs52.rename(tmpPath, this.filePath);
   }
 };
 function applyJitter(ms) {
@@ -27066,21 +27266,12 @@ async function runAcpSession(opts) {
   });
   let _budgetReachedPosted = false;
   const relaunchProxyWithoutBudget = async () => {
-    const { spawn: spawn35 } = await import("child_process");
-    try {
-      const killer = spawn35("pkill", ["-TERM", "-f", "headroom.*proxy"], {
-        detached: true,
-        stdio: "ignore"
-      });
-      killer.once("error", () => {
-      });
-      killer.unref();
-    } catch {
-    }
+    const { spawn: spawn36 } = await import("child_process");
+    killHeadroomProxy();
     await new Promise((r) => setTimeout(r, 500));
     const proxyEnv = buildRelaunchProxyEnv(process.env);
     try {
-      const proxy = spawn35(
+      const proxy = spawn36(
         "headroom",
         ["proxy", "--port", "8787"],
         { stdio: "ignore", detached: true, env: proxyEnv }
@@ -27089,6 +27280,7 @@ async function runAcpSession(opts) {
         log.warn("acpRunner", `budget recovery proxy relaunch error (best-effort): ${e.message}`);
       });
       proxy.unref();
+      writeHeadroomProxyPidfile(proxy.pid);
     } catch (e) {
       log.warn(
         "acpRunner",
@@ -28733,15 +28925,15 @@ function fetchQuotaUsage(runtime, historySvc) {
 }
 
 // src/agents/claude/onboarding.ts
-var fs52 = __toESM(require("fs"));
-var os42 = __toESM(require("os"));
-var path58 = __toESM(require("path"));
+var fs53 = __toESM(require("fs"));
+var os43 = __toESM(require("os"));
+var path59 = __toESM(require("path"));
 function ensureClaudeOnboarded() {
   try {
-    const file = path58.join(os42.homedir(), ".claude.json");
+    const file = path59.join(os43.homedir(), ".claude.json");
     let config = {};
     try {
-      config = JSON.parse(fs52.readFileSync(file, "utf8"));
+      config = JSON.parse(fs53.readFileSync(file, "utf8"));
     } catch {
     }
     if (config.hasCompletedOnboarding === true && typeof config.theme === "string") {
@@ -28752,8 +28944,8 @@ function ensureClaudeOnboarded() {
     if (typeof config.lastOnboardingVersion !== "string") {
       config.lastOnboardingVersion = "2.1.177";
     }
-    fs52.mkdirSync(path58.dirname(file), { recursive: true });
-    fs52.writeFileSync(file, JSON.stringify(config, null, 2));
+    fs53.mkdirSync(path59.dirname(file), { recursive: true });
+    fs53.writeFileSync(file, JSON.stringify(config, null, 2));
     log.info("claude", "pre-completed Claude onboarding (skip first-run theme picker)");
   } catch (err) {
     log.warn("claude", `ensureClaudeOnboarded failed (non-fatal): ${err.message}`);
@@ -29410,7 +29602,7 @@ var import_picocolors11 = __toESM(require("picocolors"));
 var import_child_process27 = require("child_process");
 var import_util4 = require("util");
 var import_picocolors9 = __toESM(require("picocolors"));
-var path59 = __toESM(require("path"));
+var path60 = __toESM(require("path"));
 var execFileP6 = (0, import_util4.promisify)(import_child_process27.execFile);
 var MAX_BUFFER = 8 * 1024 * 1024;
 function resetStdinForChild() {
@@ -29899,7 +30091,7 @@ var GitHubCodespacesProvider = class {
     });
   }
   async uploadFile(workspaceId, remotePath, contents, options = {}) {
-    const remoteDir = path59.posix.dirname(remotePath);
+    const remoteDir = path60.posix.dirname(remotePath);
     const parts = [
       `mkdir -p ${shellQuote(remoteDir)}`,
       `cat > ${shellQuote(remotePath)}`
@@ -29969,7 +30161,7 @@ function shellQuote(s) {
 // src/services/providers/gitpod.ts
 var import_child_process28 = require("child_process");
 var import_util5 = require("util");
-var path60 = __toESM(require("path"));
+var path61 = __toESM(require("path"));
 var import_picocolors10 = __toESM(require("picocolors"));
 var execFileP7 = (0, import_util5.promisify)(import_child_process28.execFile);
 var MAX_BUFFER2 = 8 * 1024 * 1024;
@@ -30209,7 +30401,7 @@ var GitpodProvider = class {
     });
   }
   async uploadFile(workspaceId, remotePath, contents, options = {}) {
-    const remoteDir = path60.posix.dirname(remotePath);
+    const remoteDir = path61.posix.dirname(remotePath);
     const parts = [
       `mkdir -p ${shellQuote2(remoteDir)}`,
       `cat > ${shellQuote2(remotePath)}`
@@ -30245,7 +30437,7 @@ function shellQuote2(s) {
 // src/services/providers/gitlab-workspaces.ts
 var import_child_process29 = require("child_process");
 var import_util6 = require("util");
-var path61 = __toESM(require("path"));
+var path62 = __toESM(require("path"));
 var execFileP8 = (0, import_util6.promisify)(import_child_process29.execFile);
 var MAX_BUFFER3 = 8 * 1024 * 1024;
 var GITLAB_API_BASE = process.env.CODEAM_GITLAB_API_URL ?? "https://gitlab.com/api/v4";
@@ -30505,7 +30697,7 @@ 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 = path61.posix.dirname(remotePath);
+    const remoteDir = path62.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)}`);
@@ -30573,7 +30765,7 @@ function shellQuote3(s) {
 // src/services/providers/railway.ts
 var import_child_process30 = require("child_process");
 var import_util7 = require("util");
-var path62 = __toESM(require("path"));
+var path63 = __toESM(require("path"));
 var execFileP9 = (0, import_util7.promisify)(import_child_process30.execFile);
 var MAX_BUFFER4 = 8 * 1024 * 1024;
 function resetStdinForChild4() {
@@ -30809,7 +31001,7 @@ var RailwayProvider = class {
     if (!projectId || !serviceId) {
       throw new Error("Invalid Railway workspace id (expected projectId/serviceId).");
     }
-    const remoteDir = path62.posix.dirname(remotePath);
+    const remoteDir = path63.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)}`);
@@ -31455,8 +31647,8 @@ async function invite() {
 var import_node_dns = require("dns");
 var import_node_util5 = require("util");
 var import_node_crypto8 = require("crypto");
-var fs53 = __toESM(require("fs"));
-var path63 = __toESM(require("path"));
+var fs54 = __toESM(require("fs"));
+var path64 = __toESM(require("path"));
 var import_picocolors14 = __toESM(require("picocolors"));
 var dnsResolveP = (0, import_node_util5.promisify)(import_node_dns.resolve);
 async function checkDns(apiBase2) {
@@ -31512,13 +31704,13 @@ async function checkHealth(apiBase2) {
   }
 }
 function checkConfigDir() {
-  const dir = path63.join(require("os").homedir(), ".codeam");
+  const dir = path64.join(require("os").homedir(), ".codeam");
   try {
-    fs53.mkdirSync(dir, { recursive: true, mode: 448 });
-    const probe = path63.join(dir, ".doctor-probe");
-    fs53.writeFileSync(probe, "ok", { mode: 384 });
-    const read2 = fs53.readFileSync(probe, "utf8");
-    fs53.unlinkSync(probe);
+    fs54.mkdirSync(dir, { recursive: true, mode: 448 });
+    const probe = path64.join(dir, ".doctor-probe");
+    fs54.writeFileSync(probe, "ok", { mode: 384 });
+    const read2 = fs54.readFileSync(probe, "utf8");
+    fs54.unlinkSync(probe);
     if (read2 !== "ok") throw new Error("write/read round-trip mismatch");
     return {
       id: "config-dir",
@@ -31558,9 +31750,9 @@ function checkSessions() {
   }
 }
 function checkAgentBinaries() {
-  const os44 = createOsStrategy();
+  const os45 = createOsStrategy();
   return getEnabledAgents().map((meta) => {
-    const found = os44.findInPath(meta.binaryName);
+    const found = os45.findInPath(meta.binaryName);
     return {
       id: `agent-${meta.id}`,
       label: `Agent binary: ${meta.displayName} (${meta.binaryName})`,
@@ -31582,7 +31774,7 @@ function checkNodePty() {
       detail: "not required on this platform"
     };
   }
-  const vendoredPath = path63.join(__dirname, "vendor", "node-pty");
+  const vendoredPath = path64.join(__dirname, "vendor", "node-pty");
   for (const target of [vendoredPath, "node-pty"]) {
     try {
       require(target);
@@ -31624,7 +31816,7 @@ function checkChokidar() {
 }
 async function doctor(args2 = []) {
   const json = args2.includes("--json");
-  const cliVersion = true ? "2.53.2" : "0.0.0-dev";
+  const cliVersion = true ? "2.53.4" : "0.0.0-dev";
   const apiBase2 = resolveApiBaseUrl();
   const diagnosticId = (0, import_node_crypto8.randomUUID)();
   log.info("doctor", `run id=${diagnosticId} cli=${cliVersion}`);
@@ -31823,7 +32015,7 @@ async function completion(args2) {
 // src/commands/version.ts
 var import_picocolors15 = __toESM(require("picocolors"));
 function version2() {
-  const v = true ? "2.53.2" : "unknown";
+  const v = true ? "2.53.4" : "unknown";
   console.log(`${import_picocolors15.default.bold("codeam-cli")} ${import_picocolors15.default.cyan(v)}`);
 }
 
@@ -31972,10 +32164,10 @@ var EXIT_CODE_NAMES = {
 };
 
 // src/index.ts
-var os43 = __toESM(require("os"));
+var os44 = __toESM(require("os"));
 if (!process.env.HOME) {
   try {
-    const home = os43.homedir();
+    const home = os44.homedir();
     if (home) process.env.HOME = home;
   } catch {
   }