codeam-cli 2.65.13 → 2.65.15

package/CHANGELOG.md

@@ -4,6 +4,22 @@ All notable changes to `codeam-cli` are documented here.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.65.14] — 2026-08-20
+
+### CI
+
+- **workflow:** All workflows report to Discord (catch-all) (#643)
+
+### Fixed
+
+- **cli:** Permission guards never scan plan text and never auto-reject silently
+
+## [2.65.13] — 2026-08-20
+
+### Fixed
+
+- **cli:** Filter non-chat models out of the native ACP model catalog
+
 ## [2.65.12] — 2026-08-19
 
 ### CI

package/dist/index.js

@@ -8079,7 +8079,7 @@ function readAnonId() {
 }
 function superProperties() {
   return {
-    cliVersion: true ? "2.65.13" : "0.0.0-dev",
+    cliVersion: true ? "2.65.15" : "0.0.0-dev",
     nodeVersion: process.version,
     platform: process.platform,
     arch: process.arch,
@@ -8321,7 +8321,7 @@ var http = __toESM(require("http"));
 // package.json
 var package_default = {
   name: "codeam-cli",
-  version: "2.65.13",
+  version: "2.65.15",
   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",
@@ -9842,7 +9842,7 @@ var CommandRelayService = class _CommandRelayService {
       // 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.65.13" ? { ideVersion: "2.65.13" } : {}
+      ..."2.65.15" ? { ideVersion: "2.65.15" } : {}
     }).then(() => log.trace("relay", `heartbeat ok online=${online}`)).catch((err) => log.trace("relay", `heartbeat failed online=${online}`, err));
   }
   /**
@@ -18315,22 +18315,31 @@ async function waitForCommandOnPath(cmd, opts = {}) {
   }
   return check();
 }
-function augmentUserLocalBinPaths(deps = {}) {
+function agentInstallBinDirs(deps = {}) {
   const env = deps.env ?? process.env;
   const home = deps.homedir ?? import_os4.default.homedir();
   const p2 = deps.pathApi ?? import_path4.default;
-  const candidates = [
+  return [
     // XDG-style per-user bin — npm's default global-prefix bin dir on most
     // Linux setups (`npm config set prefix ~/.local` or an nvm-less
-    // per-user npm), and where curl-based agent installers commonly land.
+    // per-user npm), and where curl-based agent installers commonly land
+    // (cursor-agent, coderabbit, pip --user's aider).
     p2.join(home, ".local", "bin"),
     // Common explicit npm global-prefix conventions seen in the wild
     // (`npm config set prefix ~/.npm-global`, and Debian/Fedora's
     // `~/.local/share/npm` layout for `npm config set prefix
     // ~/.local/share/npm`).
     p2.join(home, ".npm-global", "bin"),
-    p2.join(home, ".local", "share", "npm", "bin")
+    p2.join(home, ".local", "share", "npm", "bin"),
+    // Vendor curl-installer targets that are NOT on any default PATH.
+    p2.join(env.KIMI_CODE_HOME || p2.join(home, ".kimi-code"), "bin"),
+    p2.join(env.OPENCODE_HOME || p2.join(home, ".opencode"), "bin")
   ];
+}
+function augmentUserLocalBinPaths(deps = {}) {
+  const env = deps.env ?? process.env;
+  const p2 = deps.pathApi ?? import_path4.default;
+  const candidates = agentInstallBinDirs(deps);
   const parts = (env.PATH ?? "").split(p2.delimiter).filter((s) => s.length > 0);
   const existing = new Set(parts);
   const additions = candidates.filter((dir) => !existing.has(dir));
@@ -20784,6 +20793,38 @@ async function reportDeployProgress(auth, deployId, step, message, sessionId) {
   } catch {
   }
 }
+async function postSessionErrorBubble(auth, message) {
+  const chunks = [
+    { type: "new_turn", done: false },
+    { type: "text", content: message, done: true }
+  ];
+  for (const chunk of chunks) {
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), PROGRESS_TIMEOUT_MS);
+      timer.unref?.();
+      try {
+        await fetch(`${apiBase()}/api/commands/output`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "X-Plugin-Auth-Token": auth.pluginAuthToken,
+            ...vercelBypassHeader()
+          },
+          body: JSON.stringify({
+            sessionId: auth.sessionId,
+            pluginId: auth.pluginId,
+            ...chunk
+          }),
+          signal: controller.signal
+        });
+      } finally {
+        clearTimeout(timer);
+      }
+    } catch {
+    }
+  }
+}
 
 // src/commands/host/workspace.ts
 var fs39 = __toESM(require("fs"));
@@ -21966,7 +22007,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 current2 = true ? "2.65.13" : null;
+  const current2 = true ? "2.65.15" : null;
   if (!current2) return;
   const cache = readCache();
   const fresh = cache && Date.now() - cache.fetchedAt < TTL_MS;
@@ -21983,7 +22024,7 @@ function checkForUpdates() {
   if (process.env.CODEAM_DISABLE_UPDATE_CHECK === "1") return;
   if (process.env.CI) return;
   if (!process.stdout.isTTY) return;
-  const current2 = true ? "2.65.13" : null;
+  const current2 = true ? "2.65.15" : null;
   if (!current2) return;
   const cache = readCache();
   const fresh = cache && Date.now() - cache.fetchedAt < TTL_MS;
@@ -22003,7 +22044,7 @@ var SELF_UPDATE_INTERVAL_MS = 60 * 60 * 1e3;
 var SELF_UPDATE_VIEW_TIMEOUT_MS = 3e4;
 var SELF_UPDATE_INSTALL_TIMEOUT_MS = 18e4;
 function currentCliVersion() {
-  return true ? "2.65.13" : null;
+  return true ? "2.65.15" : null;
 }
 function runCmd(cmd, args2, timeoutMs) {
   return new Promise((resolve10) => {
@@ -22096,6 +22137,9 @@ function resolveInputPricePerMillion(agentId) {
   return getPricing(model).input;
 }
 var HEARTBEAT_INTERVAL_MS = 2e4;
+var RESUME_RETRY_BACKOFF_MS = [15e3, 3e4, 6e4, 12e4];
+var RESUME_REPROBE_INTERVAL_MS = 5 * 6e4;
+var RESUME_HEALTHY_AFTER_MS = 10 * 6e4;
 function maybeStartHeadroomReporter(ctx) {
   if (process.env["HEADROOM_ENABLED"] !== "1") return null;
   try {
@@ -22431,6 +22475,7 @@ var HostAgentSupervisor = class {
     this.selfUpdate = deps.selfUpdate ?? runSelfUpdate;
     this.onUpdated = deps.onUpdated ?? defaultOnUpdated;
     this.docker = deps.docker ?? defaultDockerRunner;
+    this.postResumeFailure = deps.postResumeFailure ?? postSessionErrorBubble;
   }
   identity;
   deps;
@@ -22472,6 +22517,20 @@ var HostAgentSupervisor = class {
   docker;
   /** Guards against firing the self-heal more than once. */
   healing = false;
+  /** Visible-error poster for the exhausted-resume path (injectable). */
+  postResumeFailure;
+  /** How many resume re-spawns have failed since the last healthy child. */
+  resumeRetryAttempts = 0;
+  /** Pending bounded-backoff resume retry (cleared on stop()). */
+  resumeRetryTimer = null;
+  /** Set once the bounded retries exhaust → heartbeat-ridden slow re-probe. */
+  resumeExhausted = false;
+  /** Guards the one-shot visible error bubble per failure episode. */
+  resumeFailurePosted = false;
+  /** Last slow re-probe attempt (epoch ms) — throttles the heartbeat rider. */
+  lastResumeReprobeAt = 0;
+  /** True after stop() — no resume retries may be scheduled past teardown. */
+  stopped = false;
   /**
    * Resolve the self-update interval, honoring `CODEAM_HOST_SELF_UPDATE_MS`.
    * A finite value > 0 overrides the default; 0 or negative DISABLES the
@@ -22515,6 +22574,11 @@ var HostAgentSupervisor = class {
   }
   /** Stop the control channel + heartbeats + kill every child. */
   stop() {
+    this.stopped = true;
+    if (this.resumeRetryTimer) {
+      clearTimeout(this.resumeRetryTimer);
+      this.resumeRetryTimer = null;
+    }
     if (this.heartbeatTimer) {
       clearInterval(this.heartbeatTimer);
       this.heartbeatTimer = null;
@@ -22530,6 +22594,7 @@ var HostAgentSupervisor = class {
     this.children.clear();
   }
   async beat() {
+    this.resumeRecoveryTick();
     try {
       let metrics;
       try {
@@ -23222,15 +23287,12 @@ var HostAgentSupervisor = class {
       proc.once("exit", (code) => {
         if (this.children.get(session.id)?.proc === proc) this.children.delete(session.id);
         if (typeof code === "number" && code !== 0) {
-          log.warn(
-            "host-agent",
-            `resumed session ${session.id.slice(0, 8)} exited (${code}): ${tail.trim().slice(-300)}`
-          );
+          this.onResumeChildExit(session, code, tail.trim().slice(-300));
         }
       });
       log.info(
         "host-agent",
-        `resumed session ${session.id.slice(0, 8)} pluginId=${session.pluginId.slice(0, 12)} (ACP)`
+        `resumed session ${session.id.slice(0, 8)} pluginId=${session.pluginId.slice(0, 12)} (ACP)` + (this.resumeRetryAttempts > 0 ? ` [retry ${this.resumeRetryAttempts}]` : "")
       );
     } catch (err) {
       log.warn(
@@ -23239,6 +23301,92 @@ var HostAgentSupervisor = class {
       );
     }
   }
+  /**
+   * A resumed session child died with a non-zero exit. Before 2026-08-20 this
+   * was ONE warn log and permanent, silent surrender: the v2.65.13 self-update
+   * restarted the fleet-1 unit, the resumed kimi child died `ENOENT — 'kimi'
+   * was not found on PATH`, and the session sat dead for 3+ hours while the
+   * HOST heartbeat stayed green (nothing retried, nothing surfaced anywhere).
+   * Now: bounded backoff retries ({@link RESUME_RETRY_BACKOFF_MS}); when they
+   * exhaust, post an HONEST error bubble into the session's chat (the relay/
+   * backend are up — only the agent child is dead) and hand off to the
+   * heartbeat-ridden slow re-probe ({@link resumeRecoveryTick}) so an
+   * externally-fixed cause heals without a manual restart.
+   */
+  onResumeChildExit(session, code, detail) {
+    if (this.stopped) return;
+    const reason = detail ? `exit ${code}: ${detail}` : `exit ${code}`;
+    if (this.resumeRetryAttempts < RESUME_RETRY_BACKOFF_MS.length) {
+      const delay = RESUME_RETRY_BACKOFF_MS[this.resumeRetryAttempts];
+      this.resumeRetryAttempts += 1;
+      log.warn(
+        "host-agent",
+        `resumed session ${session.id.slice(0, 8)} died (${reason}) \u2014 retry ${this.resumeRetryAttempts}/${RESUME_RETRY_BACKOFF_MS.length} in ${Math.round(delay / 1e3)}s`
+      );
+      this.resumeRetryTimer = setTimeout(() => {
+        this.resumeRetryTimer = null;
+        this.resumePersistedSession();
+      }, delay);
+      this.resumeRetryTimer.unref?.();
+      return;
+    }
+    this.resumeExhausted = true;
+    this.lastResumeReprobeAt = Date.now();
+    log.error(
+      "host-agent",
+      `resumed session ${session.id.slice(0, 8)} FAILED permanently after ${RESUME_RETRY_BACKOFF_MS.length + 1} attempts (${reason}) \u2014 posting visible error, re-probing every ${Math.round(RESUME_REPROBE_INTERVAL_MS / 6e4)} min`
+    );
+    if (!this.resumeFailurePosted) {
+      this.resumeFailurePosted = true;
+      if (session.pluginId && session.pluginAuthToken) {
+        void this.postResumeFailure(
+          {
+            sessionId: session.id,
+            pluginId: session.pluginId,
+            pluginAuthToken: session.pluginAuthToken
+          },
+          `The agent failed to restart after a CLI update/restart (${reason}). I tried ${RESUME_RETRY_BACKOFF_MS.length + 1} times without success. The host stays online and keeps retrying about every ${Math.round(RESUME_REPROBE_INTERVAL_MS / 6e4)} minutes \u2014 once the cause is fixed (for example the agent binary is reinstalled), the session reconnects automatically. You can also redeploy this server from My Servers.`
+        ).catch(() => void 0);
+      } else {
+        log.warn(
+          "host-agent",
+          "resume failure bubble skipped \u2014 persisted session has no pluginAuthToken"
+        );
+      }
+    }
+  }
+  /**
+   * Heartbeat rider for resume recovery (synchronous scheduling only — the
+   * beat must stay punctual, and this adds NO new timers):
+   *   - a live session child ⇒ the failure episode (if any) is over: reset
+   *     the retry counter + flags so a FUTURE restart gets fresh retries and
+   *     a fresh (single) error bubble.
+   *   - retries exhausted + no child ⇒ re-probe the resume, throttled to
+   *     {@link RESUME_REPROBE_INTERVAL_MS}, so a fixed PATH / reinstalled
+   *     binary heals the session WITHOUT another manual restart. A re-probe
+   *     that fails again stays in this state (the bubble is not re-posted).
+   */
+  resumeRecoveryTick() {
+    if (this.children.size > 0) {
+      const now2 = Date.now();
+      const hasHealthyChild = [...this.children.values()].some(
+        (c2) => now2 - c2.startedAt >= RESUME_HEALTHY_AFTER_MS
+      );
+      if (hasHealthyChild && (this.resumeRetryAttempts > 0 || this.resumeExhausted)) {
+        log.info("host-agent", "resume recovered \u2014 session child healthy, retry state reset");
+        this.resumeRetryAttempts = 0;
+        this.resumeExhausted = false;
+        this.resumeFailurePosted = false;
+      }
+      return;
+    }
+    if (!this.resumeExhausted || this.resumeRetryTimer) return;
+    const now = Date.now();
+    if (now - this.lastResumeReprobeAt < RESUME_REPROBE_INTERVAL_MS) return;
+    this.lastResumeReprobeAt = now;
+    log.info("host-agent", "resume re-probe (post-exhaustion heartbeat rider)");
+    this.resumePersistedSession();
+  }
   /**
    * Run the backend-supplied per-agent CLI install script (e.g.
    * `claude.ai/install.sh`, `npm i -g @openai/codex`). Best-effort + bounded:
@@ -33942,6 +34090,10 @@ function createIdleTimeout(idleMs, makeError, activeIdleMs = idleMs) {
 var path74 = __toESM(require("path"));
 var os57 = __toESM(require("os"));
 var INTERNAL_TOKENS = [".codeam", "house-claude"];
+var PROSE_ONLY_TOOL_KINDS = /* @__PURE__ */ new Set(["think", "switch_mode"]);
+function isProseOnlyToolKind(kind) {
+  return kind != null && PROSE_ONLY_TOOL_KINDS.has(kind);
+}
 var SELF_HOSTED_WORKSPACE_RE = /\.codeam[/\\]self-hosted/gi;
 function textReferencesInternal(text) {
   if (!text) return false;
@@ -33956,7 +34108,9 @@ function pathIsInternal(p2, homeDir2 = os57.homedir()) {
   if (within(path74.join(home, ".codeam", "self-hosted"))) return false;
   return within(path74.join(home, ".codeam")) || within(path74.join(home, ".beads")) || abs === path74.join(home, ".codeam-host.log") || abs.includes(`${path74.sep}house-claude${path74.sep}`) || abs.endsWith(`${path74.sep}house-claude`);
 }
-function toolCallReferencesInternal(call) {
+function toolCallReferencesInternal(call, homeDir2) {
+  if (call.locations?.some((l) => pathIsInternal(l.path, homeDir2))) return true;
+  if (isProseOnlyToolKind(call.kind)) return false;
   if (textReferencesInternal(call.title)) return true;
   if (call.rawInput != null) {
     try {
@@ -33967,9 +34121,9 @@ function toolCallReferencesInternal(call) {
   }
   return false;
 }
-function internalPathPermissionOutcome(request) {
-  if (!toolCallReferencesInternal(request.toolCall)) return null;
-  const reject = request.options.find((o) => o.kind === "reject_always") ?? request.options.find((o) => o.kind === "reject_once");
+function internalPathPermissionOutcome(request, homeDir2) {
+  if (!toolCallReferencesInternal(request.toolCall, homeDir2)) return null;
+  const reject = request.options.find((o) => o.kind === "reject_once") ?? request.options.find((o) => o.kind === "reject_always");
   if (reject) return { outcome: { outcome: "selected", optionId: reject.optionId } };
   return { outcome: { outcome: "cancelled" } };
 }
@@ -34029,6 +34183,7 @@ function toolPathIsSecret(p2) {
 }
 var GUARDRAIL_SECRET_READ_BLOCK_REASON = "Reading this secret file is blocked by this session's guardrails (Reading secrets = Deny). Adjust it in the session Guardrails settings if intended.";
 function guardrailDecision(request, policy) {
+  if (isProseOnlyToolKind(request.toolCall.kind)) return null;
   const hay = haystack(request.toolCall);
   if (!hay) return null;
   const matched = matchedCategories(hay);
@@ -35054,6 +35209,7 @@ function knownAgentBinaryDirs() {
   out2.push("/usr/bin");
   out2.push(path75.join(home, ".local/bin"));
   out2.push(path75.join(home, "bin"));
+  out2.push(...agentInstallBinDirs());
   if (process.platform === "win32") {
     const { LOCALAPPDATA, APPDATA } = process.env;
     if (LOCALAPPDATA) out2.push(path75.join(LOCALAPPDATA, "cursor-agent"));
@@ -36226,6 +36382,73 @@ function humanizeKind(kind) {
   }
 }
 
+// src/agents/acp/permission-gate.ts
+function pickAllowOption(options) {
+  return options.find((o) => o.kind === "allow_always") ?? options.find((o) => o.kind === "allow_once") ?? null;
+}
+function describeToolCallForNotice(toolCall) {
+  const title = toolCall.title?.trim();
+  return title ? `"${title}"` : "a tool call";
+}
+function internalBlockNotice(toolCall) {
+  return `\u26D4 CodeAgent auto-blocked ${describeToolCallForNotice(toolCall)} \u2014 it targets CodeAgent's own runtime files (~/.codeam), which are off-limits to the agent. This was an automatic block by CodeAgent, not a rejection by you.`;
+}
+function guardrailBlockNotice(decision, toolCall) {
+  return `\u26D4 Guardrail auto-blocked ${describeToolCallForNotice(toolCall)} \u2014 ${decision.reason} This session's "${decision.category}" guardrail is set to Deny (adjust it in the session's Guardrails settings if intended). This was an automatic block, not a rejection by you.`;
+}
+function createOnRequestPermission(deps) {
+  return async (request) => {
+    let guardrailConfirm = false;
+    if (!deps.isLocal()) {
+      const denied = internalPathPermissionOutcome(request);
+      if (denied) {
+        log.warn(
+          "acpRunner",
+          "internal-path guard \u2014 denying tool call referencing a CodeAgent platform internal"
+        );
+        void deps.publisher.publishOutput({
+          type: "text",
+          content: internalBlockNotice(request.toolCall),
+          done: true
+        });
+        return denied;
+      }
+      const g = guardrailDecision(request, deps.getPolicy());
+      if (g?.kind === "deny") {
+        log.warn("acpRunner", `guardrail [${g.category}] \u2014 denying tool call`);
+        void deps.publisher.publishOutput({
+          type: "text",
+          content: guardrailBlockNotice(g, request.toolCall),
+          done: true
+        });
+        return g.outcome;
+      }
+      if (g?.kind === "confirm") {
+        guardrailConfirm = true;
+        log.info("acpRunner", `guardrail [${g.category}] \u2014 requiring confirmation`);
+      }
+    }
+    if (deps.autoApprovePermissions && !guardrailConfirm) {
+      const allow = pickAllowOption(request.options);
+      if (allow) {
+        log.info(
+          "acpRunner",
+          `AUTO mode \u2014 auto-approving permission (${allow.kind}) optionId=${allow.optionId}`
+        );
+        return { outcome: { outcome: "selected", optionId: allow.optionId } };
+      }
+      log.warn("acpRunner", "AUTO mode \u2014 no allow option offered; falling back to interactive");
+    }
+    const { event, optionIdByLabel } = mapPermissionRequest(request);
+    await deps.publisher.publishAwaitingAnswer(event);
+    return deps.registerPermission({
+      questionId: event.questionId,
+      labels: event.options ?? [],
+      optionIdByLabel
+    });
+  };
+}
+
 // src/agents/acp/selectPromptExtractor.ts
 var MAX_OPTIONS = 6;
 var MAX_OPTION_BODY_CHARS = 200;
@@ -39555,9 +39778,6 @@ var StreamingState = class {
   }
 };
 var PERMISSION_TIMEOUT_MS = 5 * 60 * 1e3;
-function pickAllowOption(options) {
-  return options.find((o) => o.kind === "allow_always") ?? options.find((o) => o.kind === "allow_once") ?? null;
-}
 var AcpHistory = class {
   constructor(publisher, opts) {
     this.publisher = publisher;
@@ -39798,46 +40018,19 @@ async function runAcpSession(opts) {
     // Same guard the baton uses; the happy path never calls loadSession.
     beginLoadReplay: () => streaming.beginLoadReplay(),
     endLoadReplay: () => streaming.endLoadReplay(),
-    onRequestPermission: async (request) => {
-      let guardrailConfirm = false;
-      if (!isLocalSession()) {
-        const denied = internalPathPermissionOutcome(request);
-        if (denied) {
-          log.warn(
-            "acpRunner",
-            "internal-path guard \u2014 denying tool call referencing a CodeAgent platform internal"
-          );
-          return denied;
-        }
-        const g = guardrailDecision(request, getGuardrailPolicy());
-        if (g?.kind === "deny") {
-          log.warn("acpRunner", `guardrail [${g.category}] \u2014 denying tool call`);
-          return g.outcome;
-        }
-        if (g?.kind === "confirm") {
-          guardrailConfirm = true;
-          log.info("acpRunner", `guardrail [${g.category}] \u2014 requiring confirmation`);
-        }
-      }
-      if (opts.autoApprovePermissions && !guardrailConfirm) {
-        const allow = pickAllowOption(request.options);
-        if (allow) {
-          log.info(
-            "acpRunner",
-            `AUTO mode \u2014 auto-approving permission (${allow.kind}) optionId=${allow.optionId}`
-          );
-          return { outcome: { outcome: "selected", optionId: allow.optionId } };
-        }
-        log.warn("acpRunner", "AUTO mode \u2014 no allow option offered; falling back to interactive");
-      }
-      const { event, optionIdByLabel } = mapPermissionRequest(request);
-      await publisher.publishAwaitingAnswer(event);
-      return streaming.registerPermission({
-        questionId: event.questionId,
-        labels: event.options ?? [],
-        optionIdByLabel
-      });
-    },
+    // The full `session/request_permission` decision path (internal-path guard
+    // → guardrails → AUTO auto-approve → interactive prompt) lives in
+    // ./permission-gate.ts so it is unit-tested exactly as it runs here.
+    // HARD RULE enforced there: every auto-REJECT publishes a visible chat
+    // line — a guard must never silently answer for the user (the 2026-08-19
+    // ExitPlanMode silent-rejection P0).
+    onRequestPermission: createOnRequestPermission({
+      autoApprovePermissions: opts.autoApprovePermissions === true,
+      isLocal: isLocalSession,
+      getPolicy: getGuardrailPolicy,
+      publisher,
+      registerPermission: (args2) => streaming.registerPermission(args2)
+    }),
     onStderr: (line) => {
       recentStderr.push(line);
       if (recentStderr.length > 40) recentStderr.shift();
@@ -45272,7 +45465,7 @@ function checkChokidar() {
 }
 async function doctor(args2 = []) {
   const json = args2.includes("--json");
-  const cliVersion = true ? "2.65.13" : "0.0.0-dev";
+  const cliVersion = true ? "2.65.15" : "0.0.0-dev";
   const apiBase2 = resolveApiBaseUrl();
   const diagnosticId = (0, import_node_crypto13.randomUUID)();
   log.info("doctor", `run id=${diagnosticId} cli=${cliVersion}`);
@@ -45663,7 +45856,7 @@ async function mcpRun(args2) {
 // src/commands/version.ts
 var import_picocolors15 = __toESM(require("picocolors"));
 function version2() {
-  const v = true ? "2.65.13" : "unknown";
+  const v = true ? "2.65.15" : "unknown";
   console.log(`${import_picocolors15.default.bold("codeam-cli")} ${import_picocolors15.default.cyan(v)}`);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeam-cli",
-  "version": "2.65.13",
+  "version": "2.65.15",
   "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 — async. The terminal companion for CodeAgent Mobile.",
   "type": "commonjs",
   "main": "dist/index.js",