codeam-cli 2.65.10 → 2.65.12

package/CHANGELOG.md

@@ -4,6 +4,42 @@ 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.11] — 2026-08-19
+
+### Documentation
+
+- **cli:** Record the 2026-08-18 baton hand-off + goodbye-heartbeat invariants
+
+### Fixed
+
+- **cli:** Take-control never wedges on "Switching…" again
+- **cli:** Say goodbye before exiting so mobile stops showing ONLINE
+- **cli:** LOCAL_DRIVE mirrors the transcript only — no raw TUI bytes to mobile
+
+### Tests
+
+- **cli:** Real baton local integration test (take-control before first turn, handback, goodbye heartbeat)
+
+## [2.65.10] — 2026-08-19
+
+### Fixed
+
+- **cli:** Codespace sessions report the user's repo, not the shared wrapper hostname
+- **cli:** Dedupe the native ACP model list and validate model/tier at the wire boundary
+- **cli:** Welcome card greets first-time users correctly and never shows a raw internal path
+
+## [2.65.9] — 2026-08-19
+
+### Fixed
+
+- **cli:** Report an ineligible-tier credential to the backend on startup failure
+
+## [2.65.8] — 2026-08-18
+
+### Fixed
+
+- **cli:** Baton re-affirms its state on the relay heartbeat so the 1h backend snapshot never expires under a live session
+
 ## [2.65.7] — 2026-08-15
 
 ### Fixed

package/dist/index.js

@@ -8079,7 +8079,7 @@ function readAnonId() {
 }
 function superProperties() {
   return {
-    cliVersion: true ? "2.65.10" : "0.0.0-dev",
+    cliVersion: true ? "2.65.12" : "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.10",
+  version: "2.65.12",
   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",
@@ -9542,12 +9542,30 @@ var CommandRelayService = class _CommandRelayService {
       this.connectSSE();
     }
   }
+  /**
+   * Stop the relay. Kept SYNCHRONOUS for the many callers that just tear down
+   * — the goodbye heartbeat is fired but NOT awaited here.
+   *
+   * ⚠️ On a shutdown path that calls `process.exit()` right after, use
+   * {@link stopAndFlush} (or {@link stopRelayWithGoodbye}) instead: the process
+   * dies before the fire-and-forget POST hits the wire, so the backend never
+   * learns the CLI went away and mobile keeps showing the session ONLINE until
+   * the 30 s Redis heartbeat key expires — silently, since nothing publishes on
+   * expiry (the 2026-08-18 "closing Claude Code leaves mobile online" report).
+   */
   stop() {
+    void this.stopAndFlush();
+  }
+  /**
+   * Same teardown as {@link stop}, but resolves only once the `online:false`
+   * heartbeat POST has settled — so a caller can `await` it before exiting.
+   * Never rejects (`sendHeartbeat` swallows its own transport errors).
+   */
+  async stopAndFlush() {
     if (!this._running) return;
     this._running = false;
     this.cleanup();
-    this.sendHeartbeat(false).catch(() => {
-    });
+    await this.sendHeartbeat(false);
   }
   async sendResult(commandId, status2, result) {
     if (this.pairingInvalid) return;
@@ -9824,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.10" ? { ideVersion: "2.65.10" } : {}
+      ..."2.65.12" ? { ideVersion: "2.65.12" } : {}
     }).then(() => log.trace("relay", `heartbeat ok online=${online}`)).catch((err) => log.trace("relay", `heartbeat failed online=${online}`, err));
   }
   /**
@@ -9905,6 +9923,21 @@ var CommandRelayService = class _CommandRelayService {
     }
   }
 };
+var RELAY_GOODBYE_TIMEOUT_MS = 1500;
+async function stopRelayWithGoodbye(relay, timeoutMs = RELAY_GOODBYE_TIMEOUT_MS) {
+  let timer;
+  try {
+    await Promise.race([
+      relay.stopAndFlush(),
+      new Promise((resolve10) => {
+        timer = setTimeout(resolve10, timeoutMs);
+      })
+    ]);
+  } catch {
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
 
 // src/services/file-watcher.service.ts
 var import_child_process4 = require("child_process");
@@ -15250,6 +15283,7 @@ function parseHistoryFile(filePath) {
     if (!msg) continue;
     const text = extractText(msg["content"]).trim();
     if (!text) continue;
+    if (type === "user" && isLocalCommandEcho(text)) continue;
     const ts = r["timestamp"];
     const timestamp = typeof ts === "string" ? ts : typeof ts === "number" ? new Date(ts).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
     const uuid = typeof r["uuid"] === "string" ? r["uuid"] : `${Date.now()}-${Math.random()}`;
@@ -15314,6 +15348,175 @@ function listResumableSessions(cwd) {
   out2.sort((a, b) => b.timestamp - a.timestamp);
   return out2;
 }
+function isLocalCommandEcho(text) {
+  return /^\s*<(command-name|local-command-[a-z]+)>/.test(text);
+}
+var CLEAR_COMMAND_ECHO = "<command-name>/clear</command-name>";
+var SWITCH_PROBE_BYTES = 256 * 1024;
+function isClearedConversationFile(filePath) {
+  let fd;
+  try {
+    fd = fs17.openSync(filePath, "r");
+  } catch {
+    return false;
+  }
+  let raw;
+  try {
+    const buf = Buffer.alloc(SWITCH_PROBE_BYTES);
+    const n = fs17.readSync(fd, buf, 0, SWITCH_PROBE_BYTES, 0);
+    raw = buf.toString("utf8", 0, n);
+  } catch {
+    return false;
+  } finally {
+    fs17.closeSync(fd);
+  }
+  if (!raw.includes(CLEAR_COMMAND_ECHO) && !raw.includes("SessionStart:clear")) return false;
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    let r;
+    try {
+      r = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (r["type"] === "user" && !r["isMeta"]) {
+      const msg = r["message"];
+      if (extractText(msg?.["content"]).trimStart().startsWith(CLEAR_COMMAND_ECHO)) return true;
+    }
+    if (r["type"] === "attachment") {
+      const att = r["attachment"];
+      if (typeof att?.["hookName"] === "string" && att["hookName"].startsWith("SessionStart:clear")) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function appendedTailHasResumeMarker(filePath, fromOffset) {
+  let fd;
+  try {
+    fd = fs17.openSync(filePath, "r");
+  } catch {
+    return false;
+  }
+  try {
+    const size = fs17.fstatSync(fd).size;
+    const len = Math.min(Math.max(size - fromOffset, 0), SWITCH_PROBE_BYTES);
+    if (len <= 0) return false;
+    const buf = Buffer.alloc(len);
+    const n = fs17.readSync(fd, buf, 0, len, fromOffset);
+    const raw = buf.toString("utf8", 0, n);
+    if (!raw.includes('"last-prompt"')) return false;
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        if (JSON.parse(line)["type"] === "last-prompt") return true;
+      } catch {
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  } finally {
+    fs17.closeSync(fd);
+  }
+}
+function watchConversationSwitch(cwd, opts, onSwitch, projectsRoot) {
+  const root = projectsRoot ?? path21.join(os15.homedir(), ".claude", "projects");
+  let currentId = opts.currentId;
+  const baseline = /* @__PURE__ */ new Map();
+  const unclassified = /* @__PURE__ */ new Map();
+  let dirWatcher = null;
+  let rootWatcher = null;
+  let closed = false;
+  const fileSize = (file) => {
+    try {
+      return fs17.statSync(file).size;
+    } catch {
+      return null;
+    }
+  };
+  const switchTo = (dir, id, kind) => {
+    const leaving = fileSize(path21.join(dir, `${currentId}.jsonl`));
+    if (leaving !== null) baseline.set(currentId, leaving);
+    baseline.delete(id);
+    unclassified.delete(id);
+    currentId = id;
+    onSwitch(id, { kind });
+  };
+  const scan = (dir) => {
+    if (closed) return;
+    let entries;
+    try {
+      entries = fs17.readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const name of entries) {
+      if (!name.endsWith(".jsonl")) continue;
+      const id = name.slice(0, -".jsonl".length);
+      if (id === currentId) continue;
+      const file = path21.join(dir, name);
+      const size = fileSize(file);
+      if (size === null) continue;
+      const known = baseline.get(id);
+      if (known !== void 0) {
+        if (size > known && appendedTailHasResumeMarker(file, known)) {
+          switchTo(dir, id, "resumed");
+          return;
+        }
+        continue;
+      }
+      if (unclassified.get(id) === size) continue;
+      unclassified.set(id, size);
+      if (isClearedConversationFile(file)) {
+        switchTo(dir, id, "new");
+        return;
+      }
+    }
+  };
+  const attachDir = (initial) => {
+    const dir = resolveHistoryDir(cwd, root);
+    if (!dir) return false;
+    rootWatcher?.close();
+    rootWatcher = null;
+    if (initial) {
+      try {
+        for (const name of fs17.readdirSync(dir)) {
+          if (!name.endsWith(".jsonl")) continue;
+          const id = name.slice(0, -".jsonl".length);
+          if (id === currentId) continue;
+          const size = fileSize(path21.join(dir, name));
+          if (size !== null) baseline.set(id, size);
+        }
+      } catch {
+      }
+    }
+    try {
+      dirWatcher = fs17.watch(dir, { persistent: false }, () => scan(dir));
+    } catch {
+      return false;
+    }
+    scan(dir);
+    return true;
+  };
+  if (!attachDir(true)) {
+    try {
+      fs17.mkdirSync(root, { recursive: true });
+      rootWatcher = fs17.watch(root, { persistent: false }, () => {
+        if (!closed && !dirWatcher) attachDir(false);
+      });
+    } catch {
+    }
+  }
+  return () => {
+    closed = true;
+    dirWatcher?.close();
+    rootWatcher?.close();
+    dirWatcher = null;
+    rootWatcher = null;
+  };
+}
 
 // src/agents/claude/runtime.ts
 var ClaudeRuntimeStrategy = class {
@@ -15403,6 +15606,14 @@ var ClaudeRuntimeStrategy = class {
   parseHistoryFile(filePath) {
     return parseHistoryFile(filePath);
   }
+  /**
+   * Baton: follow the native TUI through `/clear` (new conversation id, new
+   * JSONL) and `/resume` (an existing one) — see
+   * {@link history.watchConversationSwitch}.
+   */
+  watchConversationSwitch(cwd, opts, onSwitch) {
+    return watchConversationSwitch(cwd, opts, onSwitch);
+  }
   getCurrentUsage(historyDir) {
     return getCurrentUsage(historyDir);
   }
@@ -18104,25 +18315,27 @@ async function waitForCommandOnPath(cmd, opts = {}) {
   }
   return check();
 }
-function augmentUserLocalBinPaths() {
-  const home = import_os4.default.homedir();
+function augmentUserLocalBinPaths(deps = {}) {
+  const env = deps.env ?? process.env;
+  const home = deps.homedir ?? import_os4.default.homedir();
+  const p2 = deps.pathApi ?? import_path4.default;
   const candidates = [
     // 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.
-    import_path4.default.join(home, ".local", "bin"),
+    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`).
-    import_path4.default.join(home, ".npm-global", "bin"),
-    import_path4.default.join(home, ".local", "share", "npm", "bin")
+    p2.join(home, ".npm-global", "bin"),
+    p2.join(home, ".local", "share", "npm", "bin")
   ];
-  const parts = (process.env.PATH ?? "").split(import_path4.default.delimiter).filter((p2) => p2.length > 0);
+  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));
   if (additions.length === 0) return;
-  process.env.PATH = [...additions, ...parts].join(import_path4.default.delimiter);
+  env.PATH = [...additions, ...parts].join(p2.delimiter);
 }
 function resolveCursorAgentBinary(deps = {}) {
   const existsSync29 = deps.existsSync ?? import_fs.default.existsSync;
@@ -21753,7 +21966,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.10" : null;
+  const current2 = true ? "2.65.12" : null;
   if (!current2) return;
   const cache = readCache();
   const fresh = cache && Date.now() - cache.fetchedAt < TTL_MS;
@@ -21770,7 +21983,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.10" : null;
+  const current2 = true ? "2.65.12" : null;
   if (!current2) return;
   const cache = readCache();
   const fresh = cache && Date.now() - cache.fetchedAt < TTL_MS;
@@ -21790,7 +22003,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.10" : null;
+  return true ? "2.65.12" : null;
 }
 function runCmd(cmd, args2, timeoutMs) {
   return new Promise((resolve10) => {
@@ -26585,7 +26798,7 @@ var sessionTerminated = async (ctx, cmd) => {
   } catch {
   }
   ctx.outputSvc.dispose();
-  ctx.relay.stop();
+  await stopRelayWithGoodbye(ctx.relay);
   process.exit(0);
 };
 var shutdownSession = async (ctx, cmd) => {
@@ -26614,7 +26827,7 @@ var shutdownSession = async (ctx, cmd) => {
   } catch {
   }
   ctx.outputSvc.dispose();
-  ctx.relay.stop();
+  await stopRelayWithGoodbye(ctx.relay);
   process.exit(0);
 };
 var showInstallCommand = async (ctx, cmd, parsed) => {
@@ -33869,6 +34082,7 @@ var _acpStartSeam = {
 var PROTOCOL_VERSION3 = 1;
 var FATAL_STARTUP_RE = /IneligibleTierError|UNSUPPORTED_CLIENT|no longer supported for Gemini Code Assist|not eligible for Gemini Code Assist|Error authenticating|ProjectIdRequiredError/i;
 var NEWSESSION_TIMEOUT_MS = 12e4;
+var LOADSESSION_TIMEOUT_MS = 6e4;
 var PROMPT_IDLE_TIMEOUT_MS = 9e4;
 var PROMPT_ACTIVE_IDLE_TIMEOUT_MS = 6e5;
 var CLIENT_CAPABILITIES = {
@@ -34383,13 +34597,30 @@ var AcpClient = class {
     log.info("acpClient", `loadSession \u2192 sessionId=${sessionId.slice(0, 8)}`);
     this.opts.beginLoadReplay?.();
     let loaded;
+    let loadTimer;
     try {
-      loaded = await this.connection.loadSession({
-        sessionId,
-        cwd: this.opts.cwd,
-        mcpServers: this.opts.mcpServers ?? []
-      });
+      loaded = await Promise.race([
+        this.connection.loadSession({
+          sessionId,
+          cwd: this.opts.cwd,
+          mcpServers: this.opts.mcpServers ?? []
+        }),
+        new Promise((_2, reject) => {
+          loadTimer = setTimeout(() => {
+            const tail = this.recentStderr.slice(-4).join(" | ");
+            reject(
+              new Error(
+                `ACP_LOAD_SESSION_TIMEOUT: ${this.opts.adapter.requiresAgentBinary} did not answer session/load for ${sessionId.slice(
+                  0,
+                  8
+                )} within ${Math.round(LOADSESSION_TIMEOUT_MS / 1e3)}s${tail ? ` \u2014 last output: ${tail}` : ""}`
+              )
+            );
+          }, LOADSESSION_TIMEOUT_MS);
+        })
+      ]);
     } finally {
+      if (loadTimer) clearTimeout(loadTimer);
       this.opts.endLoadReplay?.();
     }
     this.sessionId = sessionId;
@@ -38676,7 +38907,7 @@ async function sessionShutdownH(ctx) {
     } catch {
     }
   }
-  relay.stop();
+  await stopRelayWithGoodbye(relay);
   closeAllTerminals();
   await client3.stop();
   process.exit(0);
@@ -39975,7 +40206,7 @@ async function runAcpSession(opts) {
   const shutdown = async (signal) => {
     showInfo(`Shutting down ACP session (${signal})\u2026`);
     clearTimeout(prewarmTimer);
-    relay.stop();
+    await stopRelayWithGoodbye(relay);
     void fileWatcher.stop();
     turnFiles.stop();
     closeAllTerminals();
@@ -40444,7 +40675,27 @@ var OutputService = class _OutputService {
       ...lines.slice(banner.endIdx + 1)
     ];
   }
+  /**
+   * Mute/unmute the CHAT-output publish path. Every frame this service would
+   * emit (clear / user_message / new_turn / text / chrome_steps / selectors /
+   * banner / input_suggestion) is dropped while muted; `push()` and the tick
+   * still run, so the detection side-effects (session id, rate limit,
+   * terminal-turn gate) are untouched.
+   *
+   * ⚠️ The one caller is the baton's {@link NativeTuiDriver}: while LOCAL_DRIVE
+   * holds the baton, the mobile view is the read-only TRANSCRIPT mirror, never
+   * a screen-scrape — piping the native TUI's PTY bytes through here published
+   * raw Claude Code chrome (box-drawing rules, `❯`, "auto mode on (shift+tab to
+   * cycle) · esc to interrupt") into the chat as if it were agent output.
+   * Terminal-panel frames (`sendTerminalChunk`/`sendTerminalExit`) go straight
+   * to the emitter and are deliberately NOT affected.
+   */
+  setPublishSuppressed(suppressed) {
+    this.publishSuppressed = suppressed;
+  }
+  publishSuppressed = false;
   async send(body, opts = {}) {
+    if (this.publishSuppressed) return;
     const outcome = await this.emitter.send(body, opts);
     if (outcome.dead && this.pty.isActive) {
       this.dispose();
@@ -41135,11 +41386,18 @@ function provisionSkillsForStart(home = import_node_os13.default.homedir()) {
 }
 
 // src/baton/baton-controller.ts
-var BatonController = class {
+var BatonController = class _BatonController {
   constructor(deps) {
     this.deps = deps;
   }
   deps;
+  /**
+   * Default upper bound on a whole hand-off. A cold `newSession` on claude is
+   * ~20 s, so 45 s leaves generous headroom for a healthy switch while still
+   * failing FAST enough that the user gets an honest error instead of a
+   * permanent "Switching…".
+   */
+  static DEFAULT_SWITCH_TIMEOUT_MS = 45e3;
   _state = "LOCAL_DRIVE";
   _active = "local_tui";
   _conversationId = null;
@@ -41190,6 +41448,21 @@ var BatonController = class {
     this._conversationId = conversationId;
     this.setState("LOCAL_DRIVE");
   }
+  /**
+   * The native TUI SWITCHED conversation while driving (Claude `/clear` →
+   * a new id, `/resume` → an existing one): the process and the pairing are
+   * unchanged, but the conversation the user is in has another id. Re-point
+   * the baton at it so the read-only mirror follows that transcript and a
+   * later Take Control resumes THAT conversation instead of the abandoned one. Guarded to LOCAL_DRIVE — only
+   * the terminal can switch its own conversation, and during a hand-off /
+   * MOBILE_DRIVE the native watcher is torn down anyway (`stop()`). Same id →
+   * no-op. Re-publishes LOCAL_DRIVE so the mirror re-arms + mobile learns the id.
+   */
+  switchConversation(conversationId) {
+    if (this._state !== "LOCAL_DRIVE" || this._conversationId === conversationId) return;
+    this._conversationId = conversationId;
+    this.setState("LOCAL_DRIVE");
+  }
   async takeControl() {
     await this.switchDriver(
       "LOCAL_DRIVE",
@@ -41216,24 +41489,79 @@ var BatonController = class {
     this.setState("SWITCHING");
     const priorActive = this._active;
     const priorConversationId = this._conversationId;
-    try {
+    const timeoutMs = this.deps.switchTimeoutMs ?? _BatonController.DEFAULT_SWITCH_TIMEOUT_MS;
+    let stoppedCurrent = false;
+    const handoff = (async () => {
       await current2.whenSafeToYield();
       await current2.stop();
-      this._conversationId = await next.start(this._conversationId ?? void 0);
+      stoppedCurrent = true;
+      return next.start(priorConversationId ?? void 0);
+    })();
+    handoff.catch(() => void 0);
+    try {
+      const conversationId = await withDeadline(
+        handoff,
+        timeoutMs,
+        `BATON_SWITCH_TIMEOUT: ${from} \u2192 ${to} hand-off did not complete within ${Math.round(
+          timeoutMs / 1e3
+        )}s`
+      );
+      this._conversationId = conversationId;
       this._active = nextKind;
       this.setState(to);
     } catch (err) {
+      await this.recoverFromFailedSwitch(
+        current2,
+        next,
+        stoppedCurrent,
+        priorConversationId,
+        timeoutMs
+      );
       this._active = priorActive;
-      this._conversationId = priorConversationId;
       this.setState(from);
       throw err;
     }
   }
+  /**
+   * Undo a half-done hand-off. The `next` driver may still be starting behind
+   * the deadline — stop it so a second adapter/PTY can't race the revived one.
+   * And when `current` was ALREADY stopped before the failure, reverting only
+   * the STATE would leave the user staring at a dead terminal (or mobile at a
+   * dead adapter), so bring it back on the same conversation. Both best-effort
+   * and bounded: recovery must never itself hang the controller.
+   */
+  async recoverFromFailedSwitch(current2, next, stoppedCurrent, priorConversationId, timeoutMs) {
+    this._conversationId = priorConversationId;
+    await withDeadline(next.stop(), timeoutMs, "BATON_RECOVERY_STOP_TIMEOUT").catch(
+      () => void 0
+    );
+    if (!stoppedCurrent) return;
+    try {
+      const revived = await withDeadline(
+        current2.start(priorConversationId ?? void 0),
+        timeoutMs,
+        "BATON_RECOVERY_START_TIMEOUT"
+      );
+      if (revived) this._conversationId = revived;
+    } catch {
+    }
+  }
   setState(state) {
     this._state = state;
     this.deps.publishState(state, this._active, this._conversationId);
   }
 };
+function withDeadline(promise, ms, message) {
+  let timer;
+  return Promise.race([
+    promise,
+    new Promise((_2, reject) => {
+      timer = setTimeout(() => reject(new Error(message)), ms);
+    })
+  ]).finally(() => {
+    if (timer) clearTimeout(timer);
+  });
+}
 
 // src/baton/terminal.ts
 var TUI_MODE_RESET = "\x1B[?1004l\x1B[?2004l\x1B[?1000l\x1B[?1002l\x1B[?1003l\x1B[?1006l\x1B[?25h";
@@ -41271,6 +41599,7 @@ var NativeTuiDriver = class _NativeTuiDriver {
       deps.opts.pluginAuthToken,
       deps.runtime
     );
+    this.outputSvc.setPublishSuppressed(true);
     this.keepAliveCtx = { inCodespace: false, codespaceName: void 0 };
     this.setKeepAlive = buildKeepAlive(this.keepAliveCtx).apply;
   }
@@ -41285,18 +41614,25 @@ var NativeTuiDriver = class _NativeTuiDriver {
   static QUICK_DISCOVER_MS = 8e3;
   outputSvc;
   historySvc;
+  /** Unsubscribe for the runtime's conversation-switch watcher (armed per
+   *  `start()`, torn down in `stop()`), or null when not armed. */
+  unwatchSwitch = null;
   setKeepAlive;
   keepAliveCtx;
   async start(resumeId) {
     if (resumeId !== void 0) {
       await this.deps.runtime.syncTranscriptForNativeResume?.(this.deps.opts.cwd, resumeId);
       await this.agent.restart(resumeId, false);
+      this.armSwitchWatch(resumeId);
       return resumeId;
     }
     const spawnedAt = this.now();
     await this.agent.spawn();
     const preMinted = this.agent.spawnedSessionId;
-    if (preMinted) return preMinted;
+    if (preMinted) {
+      this.armSwitchWatch(preMinted);
+      return preMinted;
+    }
     const discover = this.deps.runtime.discoverSessionId;
     if (!discover) {
       throw new Error("NativeTuiDriver: agent did not expose a session id after spawn");
@@ -41312,7 +41648,26 @@ var NativeTuiDriver = class _NativeTuiDriver {
     });
     return null;
   }
+  /**
+   * Follow the native TUI if it switches conversation mid-session (Claude
+   * `/clear` / `/resume`): the runtime's event-driven watcher reports the id
+   * now being driven, we point the PTY-side history at it and tell the
+   * controller to rebind. Armed once per `start()` (fresh or resume) on the
+   * id the TUI is driving; inert for agents without the hook.
+   */
+  armSwitchWatch(currentId) {
+    this.unwatchSwitch?.();
+    this.unwatchSwitch = null;
+    const watch3 = this.deps.runtime.watchConversationSwitch;
+    if (!watch3) return;
+    this.unwatchSwitch = watch3(this.deps.opts.cwd, { currentId }, (id) => {
+      this.historySvc.setCurrentConversationId(id);
+      this.deps.onConversationSwitch?.(id);
+    });
+  }
   async stop() {
+    this.unwatchSwitch?.();
+    this.unwatchSwitch = null;
     this.agent.kill();
     parkTerminalForReadonly();
   }
@@ -41375,10 +41730,17 @@ var AcpDriver = class {
   session = null;
   budgetReachedPosted = false;
   async start(resumeId) {
+    const resumable = resumeId !== void 0 && this.hasTranscript(resumeId);
+    if (resumeId !== void 0 && !resumable) {
+      log.info(
+        "batonAcp",
+        `resume id ${resumeId.slice(0, 8)} has no transcript on disk (zero turns yet) \u2014 starting a fresh ACP session instead of session/load`
+      );
+    }
     let started;
     try {
       started = await this.deps.client.start();
-      if (resumeId !== void 0) {
+      if (resumable && resumeId !== void 0) {
         await this.deps.runtime.syncTranscriptForAcpResume?.(this.deps.opts.cwd, resumeId);
         this.deps.streaming.beginLoadReplay();
         try {
@@ -41391,13 +41753,30 @@ var AcpDriver = class {
       await this.deps.client.stop().catch(() => void 0);
       throw err;
     }
-    const conversationId = resumeId !== void 0 ? resumeId : started.sessionId;
+    const conversationId = resumable && resumeId !== void 0 ? resumeId : started.sessionId;
     this.acpSessionId = conversationId;
     this.agentCaps = started.initialize.agentCapabilities;
     this.session = null;
     this.budgetReachedPosted = false;
     return conversationId;
   }
+  /**
+   * Does the agent's own on-disk transcript for `conversationId` exist yet?
+   * `resolveHistoryFile` returns null when the file isn't there (every baton
+   * runtime `existsSync`-checks), which is exactly "the native TUI has run zero
+   * turns on this id" — the only case where `session/load` has nothing to load.
+   * A runtime without the hook can't be a baton runtime (see `gate.ts`), but if
+   * one ever is, assume resumable so behaviour is unchanged.
+   */
+  hasTranscript(conversationId) {
+    const resolve10 = this.deps.runtime.resolveHistoryFile;
+    if (typeof resolve10 !== "function") return true;
+    try {
+      return resolve10.call(this.deps.runtime, this.deps.opts.cwd, conversationId) !== null;
+    } catch {
+      return true;
+    }
+  }
   async stop() {
     await this.deps.client.stop();
     this.acpSessionId = null;
@@ -41535,8 +41914,8 @@ var TranscriptMirror = class {
     if (!file) return false;
     this.attached = true;
     this.emit(file);
-    const watch2 = this.deps.watch ?? defaultWatch;
-    this.unwatch = watch2(file, () => this.emit(file));
+    const watch3 = this.deps.watch ?? defaultWatch;
+    this.unwatch = watch3(file, () => this.emit(file));
     return true;
   }
   clearPoll() {
@@ -41732,8 +42111,7 @@ async function runBatonSession(opts) {
       nativeDriver.handlePtyData(raw);
     },
     onExit(code) {
-      teardown();
-      process.exit(code);
+      void teardown().finally(() => process.exit(code));
     }
   });
   nativeDriver = new NativeTuiDriver({
@@ -41752,10 +42130,17 @@ async function runBatonSession(opts) {
     // calls this once the user's first terminal turn creates the transcript.
     // Safe forward-ref — `controller` is initialised long before `begin()` runs,
     // and onLateBind only fires from inside `begin()`'s spawn.
-    onLateBind: (id) => controller.rebindConversation(id)
+    onLateBind: (id) => controller.rebindConversation(id),
+    // The native TUI switched conversation mid-drive (Claude `/clear` mints a
+    // new id + JSONL; `/resume` re-opens an existing one): rebind so the mirror
+    // follows that transcript and a later Take Control resumes THAT
+    // conversation. Owner report 2026-08-18: after `/clear` (+`/rename`) the
+    // mobile went silent — the mirror kept tailing the abandoned file.
+    onConversationSwitch: (id) => controller.switchConversation(id)
   });
   let mirror = null;
   let firstLocalDrive = true;
+  let lastPublished = null;
   const startMirror = (conversationId, fresh) => {
     mirror?.stop();
     mirror = new TranscriptMirror({
@@ -41788,11 +42173,13 @@ async function runBatonSession(opts) {
     publishState: (state, driver, conversationId) => {
       publishBatonState(state, driver, conversationId);
       if (state === "LOCAL_DRIVE" && conversationId) {
-        startMirror(conversationId, firstLocalDrive);
+        const switched = lastPublished === "LOCAL_DRIVE";
+        startMirror(conversationId, firstLocalDrive || switched);
         firstLocalDrive = false;
       } else if (state !== "LOCAL_DRIVE") {
         mirror?.stop();
       }
+      lastPublished = state;
     }
   });
   const dispatchActive = (cmd) => controller.activeSessionDriver.dispatch(cmd);
@@ -41813,19 +42200,18 @@ async function runBatonSession(opts) {
       publish: publishBatonState
     })
   );
-  function teardown() {
+  async function teardown() {
     if (torn) return;
     torn = true;
     process.removeListener("SIGINT", onSignal);
     process.removeListener("SIGTERM", onSignal);
     process.removeListener("SIGHUP", onSignal);
     mirror?.stop();
-    relay.stop();
     void controller.shutdown();
+    await stopRelayWithGoodbye(relay);
   }
   const onSignal = () => {
-    teardown();
-    process.exit(0);
+    void teardown().finally(() => process.exit(0));
   };
   process.once("SIGINT", onSignal);
   process.once("SIGTERM", onSignal);
@@ -42212,12 +42598,12 @@ async function start(requestedAgent, presetSession) {
         outputSvc.push(raw);
         streamingEmitter?.push(raw);
       },
-      onExit(code) {
+      async onExit(code) {
         process.removeListener("SIGINT", sigintHandler);
         process.removeListener("SIGTERM", sigintHandler);
         process.removeListener("SIGHUP", sigintHandler);
         outputSvc.dispose();
-        relay.stop();
+        await stopRelayWithGoodbye(relay);
         void fileWatcher?.stop();
         turnFiles?.stop();
         void beads?.watcher.stop();
@@ -42272,7 +42658,7 @@ async function start(requestedAgent, presetSession) {
     shuttingDown = true;
     agent.kill();
     outputSvc.dispose();
-    relay.stop();
+    await stopRelayWithGoodbye(relay);
     void fileWatcher?.stop();
     void beads?.watcher.stop();
     void streamingEmitter?.stop();
@@ -44868,7 +45254,7 @@ function checkChokidar() {
 }
 async function doctor(args2 = []) {
   const json = args2.includes("--json");
-  const cliVersion = true ? "2.65.10" : "0.0.0-dev";
+  const cliVersion = true ? "2.65.12" : "0.0.0-dev";
   const apiBase2 = resolveApiBaseUrl();
   const diagnosticId = (0, import_node_crypto13.randomUUID)();
   log.info("doctor", `run id=${diagnosticId} cli=${cliVersion}`);
@@ -45259,7 +45645,7 @@ async function mcpRun(args2) {
 // src/commands/version.ts
 var import_picocolors15 = __toESM(require("picocolors"));
 function version2() {
-  const v = true ? "2.65.10" : "unknown";
+  const v = true ? "2.65.12" : "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.10",
+  "version": "2.65.12",
   "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",