@episoda/cli 0.2.174 → 0.2.176

package/dist/index.js

@@ -1640,15 +1640,15 @@ var require_git_executor = __commonJS({
           try {
             const { stdout: gitDir } = await execAsync("git rev-parse --git-dir", { cwd, timeout: 5e3 });
             const gitDirPath = gitDir.trim();
-            const fs16 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+            const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
             const rebaseMergePath = `${gitDirPath}/rebase-merge`;
             const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
             try {
-              await fs16.access(rebaseMergePath);
+              await fs17.access(rebaseMergePath);
               inRebase = true;
             } catch {
               try {
-                await fs16.access(rebaseApplyPath);
+                await fs17.access(rebaseApplyPath);
                 inRebase = true;
               } catch {
                 inRebase = false;
@@ -1704,9 +1704,9 @@ var require_git_executor = __commonJS({
               };
             }
           }
-          const fs16 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs16.access(command.path);
+            await fs17.access(command.path);
             return {
               success: false,
               error: "WORKTREE_EXISTS",
@@ -1765,9 +1765,9 @@ var require_git_executor = __commonJS({
        */
       async executeWorktreeRemove(command, cwd, options) {
         try {
-          const fs16 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs16.access(command.path);
+            await fs17.access(command.path);
           } catch {
             return {
               success: false,
@@ -1802,7 +1802,7 @@ var require_git_executor = __commonJS({
           const result = await this.runGitCommand(args, cwd, options);
           if (result.success) {
             try {
-              await fs16.rm(command.path, { recursive: true, force: true });
+              await fs17.rm(command.path, { recursive: true, force: true });
             } catch {
             }
             return {
@@ -1936,10 +1936,10 @@ var require_git_executor = __commonJS({
        */
       async executeCloneBare(command, options) {
         try {
-          const fs16 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path19 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path20 = await Promise.resolve().then(() => __importStar(require("path")));
           try {
-            await fs16.access(command.path);
+            await fs17.access(command.path);
             return {
               success: false,
               error: "BRANCH_ALREADY_EXISTS",
@@ -1948,9 +1948,9 @@ var require_git_executor = __commonJS({
             };
           } catch {
           }
-          const parentDir = path19.dirname(command.path);
+          const parentDir = path20.dirname(command.path);
           try {
-            await fs16.mkdir(parentDir, { recursive: true });
+            await fs17.mkdir(parentDir, { recursive: true });
           } catch {
           }
           const { stdout, stderr } = await execAsync(
@@ -1998,22 +1998,22 @@ var require_git_executor = __commonJS({
        */
       async executeProjectInfo(cwd, options) {
         try {
-          const fs16 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path19 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path20 = await Promise.resolve().then(() => __importStar(require("path")));
           let currentPath = cwd;
           let projectPath = cwd;
           let bareRepoPath;
           for (let i = 0; i < 10; i++) {
-            const bareDir = path19.join(currentPath, ".bare");
-            const episodaDir = path19.join(currentPath, ".episoda");
+            const bareDir = path20.join(currentPath, ".bare");
+            const episodaDir = path20.join(currentPath, ".episoda");
             try {
-              await fs16.access(bareDir);
-              await fs16.access(episodaDir);
+              await fs17.access(bareDir);
+              await fs17.access(episodaDir);
               projectPath = currentPath;
               bareRepoPath = bareDir;
               break;
             } catch {
-              const parentPath = path19.dirname(currentPath);
+              const parentPath = path20.dirname(currentPath);
               if (parentPath === currentPath) {
                 break;
               }
@@ -2187,6 +2187,7 @@ var require_websocket_client = __commonJS({
       constructor() {
         this.eventHandlers = /* @__PURE__ */ new Map();
         this.reconnectAttempts = 0;
+        this.autoReconnectEnabled = true;
         this.url = "";
         this.token = "";
         this.isConnected = false;
@@ -2235,7 +2236,7 @@ var require_websocket_client = __commonJS({
           clearTimeout(this.reconnectTimeout);
           this.reconnectTimeout = void 0;
         }
-        return new Promise((resolve5, reject) => {
+        return new Promise((resolve6, reject) => {
           const connectionTimeout = setTimeout(() => {
             if (this.ws) {
               this.ws.terminate();
@@ -2266,7 +2267,7 @@ var require_websocket_client = __commonJS({
                 daemonPid: this.daemonPid
               });
               this.startHeartbeat();
-              resolve5();
+              resolve6();
             });
             this.ws.on("pong", () => {
               if (this.heartbeatTimeoutTimer) {
@@ -2288,7 +2289,7 @@ var require_websocket_client = __commonJS({
             this.ws.on("close", (code, reason) => {
               console.log(`[EpisodaClient] WebSocket closed: ${code} ${reason.toString()}`);
               this.isConnected = false;
-              const willReconnect = !this.isDisconnecting;
+              const willReconnect = !this.isDisconnecting && this.autoReconnectEnabled;
               this.emit({
                 type: "disconnected",
                 code,
@@ -2312,6 +2313,19 @@ var require_websocket_client = __commonJS({
           }
         });
       }
+      /**
+       * Enable/disable automatic reconnect scheduling.
+       *
+       * This lets daemon startup/handshake own retry policy without competing
+       * with client-side reconnect loops.
+       */
+      setAutoReconnect(enabled) {
+        this.autoReconnectEnabled = enabled;
+        if (!enabled && this.reconnectTimeout) {
+          clearTimeout(this.reconnectTimeout);
+          this.reconnectTimeout = void 0;
+        }
+      }
       /**
        * Disconnect from the server
        * @param intentional - If true, prevents automatic reconnection (user-initiated disconnect)
@@ -2397,13 +2411,13 @@ var require_websocket_client = __commonJS({
           console.warn("[EpisodaClient] Cannot send - WebSocket not connected");
           return false;
         }
-        return new Promise((resolve5) => {
+        return new Promise((resolve6) => {
           this.ws.send(JSON.stringify(message), (error) => {
             if (error) {
               console.error("[EpisodaClient] Failed to send message:", error);
-              resolve5(false);
+              resolve6(false);
             } else {
-              resolve5(true);
+              resolve6(true);
             }
           });
         });
@@ -2526,7 +2540,12 @@ var require_websocket_client = __commonJS({
         if (this.rateLimitBackoffUntil && Date.now() < this.rateLimitBackoffUntil) {
           const waitTime = this.rateLimitBackoffUntil - Date.now();
           console.log(`[EpisodaClient] Rate limited, waiting ${Math.round(waitTime / 1e3)}s before retry`);
-          this.reconnectAttempts++;
+          this.emit({
+            type: "reconnect_scheduled",
+            attempt: this.reconnectAttempts + 1,
+            delayMs: waitTime,
+            strategy: "rate_limited"
+          });
           this.reconnectTimeout = setTimeout(() => {
             this.rateLimitBackoffUntil = void 0;
             this.scheduleReconnect();
@@ -2534,6 +2553,7 @@ var require_websocket_client = __commonJS({
           return;
         }
         let delay;
+        let strategy = "connection_lost";
         let shouldRetry = true;
         const isCloudMode = this.environment === "cloud";
         const MAX_CLOUD_AUTH_FAILURES = 3;
@@ -2545,20 +2565,28 @@ var require_websocket_client = __commonJS({
           } else {
             delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), MAX_CLOUD_RECONNECT_DELAY);
             delay = applyJitter(delay);
+            strategy = "cloud";
             const delayStr = delay >= 6e4 ? `${Math.round(delay / 6e4)}m` : `${Math.round(delay / 1e3)}s`;
             console.log(`[EpisodaClient] Cloud mode: reconnecting in ${delayStr}... (attempt ${this.reconnectAttempts + 1}, never giving up)`);
           }
         } else if (this.isGracefulShutdown && this.reconnectAttempts < 7) {
           delay = Math.min(500 * Math.pow(2, this.reconnectAttempts), 5e3);
           delay = applyJitter(delay);
+          strategy = "graceful_shutdown";
           console.log(`[EpisodaClient] Server restarting, reconnecting in ${delay}ms (attempt ${this.reconnectAttempts + 1}/7)`);
         } else {
           delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), MAX_LOCAL_RECONNECT_DELAY);
           delay = applyJitter(delay);
+          strategy = "connection_lost";
           const delayStr = delay >= 6e4 ? `${Math.round(delay / 6e4)}m` : `${Math.round(delay / 1e3)}s`;
           console.log(`[EpisodaClient] Connection lost, retrying in ${delayStr}... (attempt ${this.reconnectAttempts + 1}, retrying until connected)`);
         }
         if (!shouldRetry) {
+          this.emit({
+            type: "reconnect_exhausted",
+            attempts: this.reconnectAttempts,
+            reason: `retry_exhausted_after_${this.consecutiveAuthFailures}_auth_failures`
+          });
           this.emit({
             type: "disconnected",
             code: 1006,
@@ -2567,9 +2595,20 @@ var require_websocket_client = __commonJS({
           });
           return;
         }
-        this.reconnectAttempts++;
+        const reconnectAttempt = this.reconnectAttempts + 1;
+        this.reconnectAttempts = reconnectAttempt;
+        this.emit({
+          type: "reconnect_scheduled",
+          attempt: reconnectAttempt,
+          delayMs: delay,
+          strategy
+        });
         this.reconnectTimeout = setTimeout(() => {
           console.log("[EpisodaClient] Attempting reconnection...");
+          this.emit({
+            type: "reconnect_attempt",
+            attempt: reconnectAttempt
+          });
           this.connect(this.url, this.token, this.machineId, {
             hostname: this.hostname,
             osPlatform: this.osPlatform,
@@ -2582,6 +2621,11 @@ var require_websocket_client = __commonJS({
             containerId: this.containerId
           }).then(() => {
             console.log("[EpisodaClient] Reconnection successful");
+            this.emit({
+              type: "reconnect_result",
+              attempt: reconnectAttempt,
+              success: true
+            });
             this.reconnectAttempts = 0;
             this.isGracefulShutdown = false;
             this.firstDisconnectTime = void 0;
@@ -2589,6 +2633,12 @@ var require_websocket_client = __commonJS({
             this.consecutiveAuthFailures = 0;
           }).catch((error) => {
             console.error("[EpisodaClient] Reconnection failed:", error.message);
+            this.emit({
+              type: "reconnect_result",
+              attempt: reconnectAttempt,
+              success: false,
+              error: error instanceof Error ? error.message : String(error)
+            });
           });
         }, delay);
       }
@@ -2669,38 +2719,38 @@ var require_auth = __commonJS({
       };
     })();
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.getConfigDir = getConfigDir6;
+    exports2.getConfigDir = getConfigDir7;
     exports2.getConfigPath = getConfigPath4;
     exports2.loadConfig = loadConfig9;
     exports2.saveConfig = saveConfig3;
     exports2.validateToken = validateToken;
-    var fs16 = __importStar(require("fs"));
-    var path19 = __importStar(require("path"));
+    var fs17 = __importStar(require("fs"));
+    var path20 = __importStar(require("path"));
     var os5 = __importStar(require("os"));
     var child_process_1 = require("child_process");
     var DEFAULT_CONFIG_FILE = "config.json";
     var hasWarnedMissingProjectId = false;
     var hasWarnedMissingRequiredFields = false;
-    function getConfigDir6() {
-      return process.env.EPISODA_CONFIG_DIR || path19.join(os5.homedir(), ".episoda");
+    function getConfigDir7() {
+      return process.env.EPISODA_CONFIG_DIR || path20.join(os5.homedir(), ".episoda");
     }
     function getConfigPath4(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path19.join(getConfigDir6(), DEFAULT_CONFIG_FILE);
+      return path20.join(getConfigDir7(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path19.dirname(configPath);
-      const isNew = !fs16.existsSync(dir);
+      const dir = path20.dirname(configPath);
+      const isNew = !fs17.existsSync(dir);
       if (isNew) {
-        fs16.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs17.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path19.join(dir, ".nosync");
-        if (isNew || !fs16.existsSync(nosyncPath)) {
+        const nosyncPath = path20.join(dir, ".nosync");
+        if (isNew || !fs17.existsSync(nosyncPath)) {
           try {
-            fs16.writeFileSync(nosyncPath, "", { mode: 384 });
+            fs17.writeFileSync(nosyncPath, "", { mode: 384 });
             (0, child_process_1.execSync)(`xattr -w com.apple.fileprovider.ignore 1 "${dir}"`, {
               stdio: "ignore",
               timeout: 5e3
@@ -2714,11 +2764,11 @@ var require_auth = __commonJS({
       const fullPath = getConfigPath4(configPath);
       const isCloudMode = process.env.EPISODA_MODE === "cloud";
       const readConfigFile = (pathToFile) => {
-        if (!fs16.existsSync(pathToFile)) {
+        if (!fs17.existsSync(pathToFile)) {
           return null;
         }
         try {
-          const content = fs16.readFileSync(pathToFile, "utf8");
+          const content = fs17.readFileSync(pathToFile, "utf8");
           return JSON.parse(content);
         } catch (error) {
           console.error("Error loading config:", error);
@@ -2757,11 +2807,11 @@ var require_auth = __commonJS({
         }
         const homeDir = process.env.HOME || require("os").homedir();
         const workspaceConfigPath = require("path").join(homeDir, "episoda", process.env.EPISODA_WORKSPACE, ".episoda", "config.json");
-        if (!fs16.existsSync(workspaceConfigPath)) {
+        if (!fs17.existsSync(workspaceConfigPath)) {
           return null;
         }
         try {
-          const content = fs16.readFileSync(workspaceConfigPath, "utf8");
+          const content = fs17.readFileSync(workspaceConfigPath, "utf8");
           const workspaceConfig2 = JSON.parse(content);
           const expiresAtEnv = envValue(process.env.EPISODA_ACCESS_TOKEN_EXPIRES_AT);
           return {
@@ -2789,11 +2839,11 @@ var require_auth = __commonJS({
         }
         const homeDir = process.env.HOME || require("os").homedir();
         const projectConfigPath = require("path").join(homeDir, "episoda", workspaceSlug, projectSlug, ".episoda", "config.json");
-        if (!fs16.existsSync(projectConfigPath)) {
+        if (!fs17.existsSync(projectConfigPath)) {
           return null;
         }
         try {
-          const content = fs16.readFileSync(projectConfigPath, "utf8");
+          const content = fs17.readFileSync(projectConfigPath, "utf8");
           const projectConfig2 = JSON.parse(content);
           return {
             project_id: projectConfig2.projectId || projectConfig2.project_id,
@@ -2861,7 +2911,7 @@ var require_auth = __commonJS({
       ensureConfigDir(fullPath);
       try {
         const content = JSON.stringify(config, null, 2);
-        fs16.writeFileSync(fullPath, content, { mode: 384 });
+        fs17.writeFileSync(fullPath, content, { mode: 384 });
       } catch (error) {
         throw new Error(`Failed to save config: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -3020,6 +3070,7 @@ var status = {
 // src/daemon/daemon-manager.ts
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
+var net = __toESM(require("net"));
 var import_child_process = require("child_process");
 var import_crypto = require("crypto");
 var import_core = __toESM(require_dist());
@@ -3032,6 +3083,20 @@ function logSignalDispatch(input) {
   };
   console.log(`[DaemonManager] SignalDispatch ${JSON.stringify(payload)}`);
 }
+function logReliabilityMetric(metric, fields) {
+  const line = `[Daemon][Metric] ${JSON.stringify({
+    metric,
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...fields
+  })}`;
+  console.log(line);
+  try {
+    const daemonLogPath = path.join((0, import_core.getConfigDir)(), "daemon.log");
+    fs.appendFileSync(daemonLogPath, `${line}
+`, "utf-8");
+  } catch {
+  }
+}
 function killAllEpisodaProcesses() {
   const currentPid = process.pid;
   let killedCount = 0;
@@ -3084,6 +3149,111 @@ function killAllEpisodaProcesses() {
 function getPidFilePath() {
   return path.join((0, import_core.getConfigDir)(), "daemon.pid");
 }
+function resolveDaemonEntryScript() {
+  const packagedPath = path.join(__dirname, "daemon", "daemon-process.js");
+  if (fs.existsSync(packagedPath)) {
+    return packagedPath;
+  }
+  const sourceFallbackPath = path.resolve(__dirname, "../../dist/daemon/daemon-process.js");
+  if (fs.existsSync(sourceFallbackPath)) {
+    return sourceFallbackPath;
+  }
+  throw new Error(
+    `Daemon script not found. Checked: ${packagedPath}, ${sourceFallbackPath}. Make sure CLI is built.`
+  );
+}
+async function pingDaemonSocket(socketPath, timeoutMs) {
+  await new Promise((resolve6, reject) => {
+    const socket = net.createConnection(socketPath);
+    const requestId = (0, import_crypto.randomUUID)();
+    let settled = false;
+    let buffer = "";
+    const finish = (fn) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      socket.removeAllListeners();
+      socket.destroy();
+      fn();
+    };
+    const timer = setTimeout(() => {
+      finish(() => reject(new Error("IPC ping timeout")));
+    }, timeoutMs);
+    socket.on("connect", () => {
+      socket.write(JSON.stringify({ id: requestId, command: "ping", params: {} }) + "\n");
+    });
+    socket.on("data", (chunk) => {
+      buffer += chunk.toString("utf8");
+      const parsed = consumeIpcPingBufferForRequest(buffer, requestId);
+      buffer = parsed.remainingBuffer;
+      if (parsed.result === "pending") return;
+      if (parsed.result === "success") {
+        finish(() => resolve6());
+        return;
+      }
+      finish(() => reject(new Error(parsed.error || "IPC ping failed")));
+    });
+    socket.on("error", (error) => {
+      finish(() => reject(error));
+    });
+  });
+}
+function consumeIpcPingBufferForRequest(buffer, requestId) {
+  let remaining = buffer;
+  while (true) {
+    const newlineIndex = remaining.indexOf("\n");
+    if (newlineIndex === -1) {
+      return { result: "pending", remainingBuffer: remaining };
+    }
+    const frame = remaining.slice(0, newlineIndex).trim();
+    remaining = remaining.slice(newlineIndex + 1);
+    if (!frame) continue;
+    let parsed = null;
+    try {
+      parsed = JSON.parse(frame);
+    } catch {
+      continue;
+    }
+    if (!parsed || parsed.id !== requestId) {
+      continue;
+    }
+    if (parsed.success) {
+      return { result: "success", remainingBuffer: remaining };
+    }
+    return {
+      result: "error",
+      remainingBuffer: remaining,
+      error: parsed.error || "IPC ping failed"
+    };
+  }
+}
+async function waitForDaemonIpcReady(timeoutMs = 15e3) {
+  const socketPath = path.join((0, import_core.getConfigDir)(), "daemon.sock");
+  const deadline = Date.now() + timeoutMs;
+  let lastError = "unknown";
+  while (Date.now() < deadline) {
+    try {
+      await pingDaemonSocket(socketPath, 1e3);
+      return;
+    } catch (error) {
+      lastError = error instanceof Error ? error.message : String(error);
+      await new Promise((resolve6) => setTimeout(resolve6, 200));
+    }
+  }
+  throw new Error(`Daemon IPC not ready within ${Math.round(timeoutMs / 1e3)}s (${lastError})`);
+}
+async function waitForProcessStart(pid, timeoutMs = 5e3) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      process.kill(pid, 0);
+      return;
+    } catch {
+      await new Promise((resolve6) => setTimeout(resolve6, 100));
+    }
+  }
+  throw new Error(`Daemon process did not become alive within ${Math.round(timeoutMs / 1e3)}s`);
+}
 function looksLikeEpisodaDaemonProcess(pid) {
   if (process.platform === "win32") {
     return true;
@@ -3128,6 +3298,7 @@ function isDaemonRunning() {
   }
 }
 async function startDaemon() {
+  const startTime = Date.now();
   const existingPid = isDaemonRunning();
   if (existingPid) {
     throw new Error(`Daemon already running (PID: ${existingPid})`);
@@ -3136,10 +3307,7 @@ async function startDaemon() {
   if (!fs.existsSync(configDir)) {
     fs.mkdirSync(configDir, { recursive: true });
   }
-  const daemonScript = path.join(__dirname, "daemon", "daemon-process.js");
-  if (!fs.existsSync(daemonScript)) {
-    throw new Error(`Daemon script not found: ${daemonScript}. Make sure CLI is built.`);
-  }
+  const daemonScript = resolveDaemonEntryScript();
   const logPath = path.join(configDir, "daemon.log");
   rotateDaemonLog(logPath);
   const logFd = fs.openSync(logPath, "a");
@@ -3148,6 +3316,8 @@ async function startDaemon() {
     // Run independently of parent
     stdio: ["ignore", logFd, logFd],
     // EP813: Redirect stdout/stderr to log file
+    cwd: configDir,
+    // Stable daemon context; never inherit transient shell cwd
     env: {
       ...process.env,
       EPISODA_DAEMON_MODE: "1"
@@ -3158,10 +3328,29 @@ async function startDaemon() {
   const pid = child.pid;
   const pidPath = getPidFilePath();
   fs.writeFileSync(pidPath, pid.toString(), "utf-8");
-  await new Promise((resolve5) => setTimeout(resolve5, 500));
-  const runningPid = isDaemonRunning();
-  if (!runningPid) {
-    throw new Error("Daemon failed to start");
+  await waitForProcessStart(pid, 5e3);
+  try {
+    await waitForDaemonIpcReady(15e3);
+    logReliabilityMetric("daemon_startup_ready", {
+      pid,
+      startupReadyLatencyMs: Date.now() - startTime
+    });
+  } catch (error) {
+    try {
+      logSignalDispatch({
+        initiator: "startDaemon",
+        pid,
+        signal: "SIGTERM",
+        reason: "ipc_readiness_failed"
+      });
+      process.kill(pid, "SIGTERM");
+    } catch {
+    }
+    try {
+      if (fs.existsSync(pidPath)) fs.unlinkSync(pidPath);
+    } catch {
+    }
+    throw error;
   }
   return pid;
 }
@@ -3186,7 +3375,7 @@ async function stopDaemon(timeout = 5e3) {
     while (Date.now() - startTime < timeout) {
       try {
         process.kill(pid, 0);
-        await new Promise((resolve5) => setTimeout(resolve5, 100));
+        await new Promise((resolve6) => setTimeout(resolve6, 100));
       } catch (error) {
         const pidPath2 = getPidFilePath();
         if (fs.existsSync(pidPath2)) {
@@ -3240,15 +3429,15 @@ function rotateDaemonLog(logPath) {
 }
 
 // src/ipc/ipc-client.ts
-var net = __toESM(require("net"));
+var net2 = __toESM(require("net"));
 var path2 = __toESM(require("path"));
 var crypto = __toESM(require("crypto"));
 var import_core2 = __toESM(require_dist());
 var getSocketPath = () => path2.join((0, import_core2.getConfigDir)(), "daemon.sock");
 var DEFAULT_TIMEOUT = 15e3;
 async function sendCommand(command, params, timeout = DEFAULT_TIMEOUT) {
-  return new Promise((resolve5, reject) => {
-    const socket = net.createConnection(getSocketPath());
+  return new Promise((resolve6, reject) => {
+    const socket = net2.createConnection(getSocketPath());
     const requestId = crypto.randomUUID();
     let buffer = "";
     let timeoutHandle;
@@ -3278,7 +3467,7 @@ async function sendCommand(command, params, timeout = DEFAULT_TIMEOUT) {
         clearTimeout(timeoutHandle);
         socket.end();
         if (response.success) {
-          resolve5(response.data);
+          resolve6(response.data);
         } else {
           reject(new Error(response.error || "Command failed"));
         }
@@ -3305,7 +3494,7 @@ async function sendCommand(command, params, timeout = DEFAULT_TIMEOUT) {
 }
 async function isDaemonReachable() {
   try {
-    await sendCommand("ping", {}, 1e3);
+    await sendCommand("ping", {}, 3e3);
     return true;
   } catch (error) {
     return false;
@@ -3947,7 +4136,7 @@ var WorktreeManager = class _WorktreeManager {
                 const lockContent = fs2.readFileSync(lockPath, "utf-8").trim();
                 const lockPid = parseInt(lockContent, 10);
                 if (!isNaN(lockPid) && this.isProcessRunning(lockPid)) {
-                  await new Promise((resolve5) => setTimeout(resolve5, retryInterval));
+                  await new Promise((resolve6) => setTimeout(resolve6, retryInterval));
                   continue;
                 }
               } catch {
@@ -3961,7 +4150,7 @@ var WorktreeManager = class _WorktreeManager {
           } catch {
             continue;
           }
-          await new Promise((resolve5) => setTimeout(resolve5, retryInterval));
+          await new Promise((resolve6) => setTimeout(resolve6, retryInterval));
           continue;
         }
         throw err;
@@ -4298,7 +4487,7 @@ async function fetchProjectPath(config, projectId) {
     return null;
   }
 }
-async function syncProjectPath(config, projectId, path19) {
+async function syncProjectPath(config, projectId, path20) {
   const machineUuid = config.machine_uuid || config.device_id;
   if (!machineUuid || !config.access_token) {
     return false;
@@ -4312,7 +4501,7 @@ async function syncProjectPath(config, projectId, path19) {
         "Authorization": `Bearer ${config.access_token}`,
         "Content-Type": "application/json"
       },
-      body: JSON.stringify({ path: path19 })
+      body: JSON.stringify({ path: path20 })
     });
     if (!response.ok) {
       console.debug(`[MachineSettings] syncProjectPath failed: ${response.status} ${response.statusText}`);
@@ -4566,6 +4755,29 @@ async function ensureProtocolHandlerRegistered() {
   }
 }
 
+// src/utils/daemon-readiness.ts
+async function waitForDaemonReachable(isReachable, timeoutMs = 15e3, pollMs = 250, options = {}) {
+  const deadline = Date.now() + timeoutMs;
+  const backoffFactor = options.backoffFactor ?? 1.25;
+  const maxPollMs = options.maxPollMs ?? 1e3;
+  const random = options.random ?? Math.random;
+  let currentPollMs = pollMs;
+  while (Date.now() < deadline) {
+    if (await isReachable()) {
+      return true;
+    }
+    const remainingMs = Math.max(0, deadline - Date.now());
+    const jitterMs = options.jitterMs ?? Math.min(50, Math.floor(currentPollMs * 0.2));
+    const jitter = jitterMs > 0 ? Math.floor(random() * jitterMs) : 0;
+    const sleepMs = Math.min(remainingMs, currentPollMs + jitter);
+    if (sleepMs > 0) {
+      await new Promise((resolve6) => setTimeout(resolve6, sleepMs));
+    }
+    currentPollMs = Math.min(maxPollMs, Math.max(1, Math.round(currentPollMs * backoffFactor)));
+  }
+  return false;
+}
+
 // src/commands/daemon.ts
 var CONNECTION_MAX_RETRIES = 3;
 var FOREGROUND_DAEMON_MONITOR_INTERVAL_MS = 5e3;
@@ -4620,7 +4832,7 @@ async function daemonCommand(options = {}) {
       const killedCount = killAllEpisodaProcesses();
       if (killedCount > 0) {
         status.info(`Cleaned up ${killedCount} stale process${killedCount > 1 ? "es" : ""}`);
-        await new Promise((resolve5) => setTimeout(resolve5, 2e3));
+        await new Promise((resolve6) => setTimeout(resolve6, 2e3));
       }
     }
     let projectPath = null;
@@ -4685,7 +4897,7 @@ async function daemonCommand(options = {}) {
     } else {
       status.debug(`Daemon already running (PID: ${daemonPid})`);
     }
-    const reachable = await isDaemonReachable();
+    const reachable = await waitForDaemonReachable(isDaemonReachable, 15e3, 250);
     if (!reachable) {
       status.error("Daemon is running but not responding. Try: episoda stop && episoda dev");
       process.exit(1);
@@ -4709,7 +4921,7 @@ async function daemonCommand(options = {}) {
     for (let retry = 0; retry < CONNECTION_MAX_RETRIES && !connected; retry++) {
       if (retry > 0) {
         status.info(`Retrying connection (attempt ${retry + 1}/${CONNECTION_MAX_RETRIES})...`);
-        await new Promise((resolve5) => setTimeout(resolve5, 1e3));
+        await new Promise((resolve6) => setTimeout(resolve6, 1e3));
       }
       try {
         const result = await addProject(connectId, connectPath);
@@ -5284,10 +5496,10 @@ async function initiateDeviceFlow(apiUrl, machineId) {
   return await response.json();
 }
 async function monitorAuthorization(apiUrl, deviceCode, expiresIn) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const timeout = setTimeout(() => {
       status.error("Authorization timed out");
-      resolve5(false);
+      resolve6(false);
     }, expiresIn * 1e3);
     const url = `${apiUrl}/api/oauth/authorize-stream?device_code=${deviceCode}`;
     const curlProcess = (0, import_child_process7.spawn)("curl", ["-N", url]);
@@ -5313,26 +5525,26 @@ async function monitorAuthorization(apiUrl, deviceCode, expiresIn) {
           if (eventType === "authorized") {
             clearTimeout(timeout);
             curlProcess.kill();
-            resolve5(true);
+            resolve6(true);
             return;
           } else if (eventType === "denied") {
             clearTimeout(timeout);
             curlProcess.kill();
             status.error("Authorization denied by user");
-            resolve5(false);
+            resolve6(false);
             return;
           } else if (eventType === "expired") {
             clearTimeout(timeout);
             curlProcess.kill();
             status.error("Authorization code expired");
-            resolve5(false);
+            resolve6(false);
             return;
           } else if (eventType === "error") {
             const errorData = JSON.parse(data);
             clearTimeout(timeout);
             curlProcess.kill();
             status.error(`Authorization error: ${errorData.error_description || errorData.error || "Unknown error"}`);
-            resolve5(false);
+            resolve6(false);
             return;
           }
         } catch (error) {
@@ -5342,13 +5554,13 @@ async function monitorAuthorization(apiUrl, deviceCode, expiresIn) {
     curlProcess.on("error", (error) => {
       clearTimeout(timeout);
       status.error(`Failed to monitor authorization: ${error.message}`);
-      resolve5(false);
+      resolve6(false);
     });
     curlProcess.on("close", (code) => {
       clearTimeout(timeout);
       if (code !== 0 && code !== null) {
         status.error(`Authorization monitoring failed with code ${code}`);
-        resolve5(false);
+        resolve6(false);
       }
     });
   });
@@ -5672,7 +5884,7 @@ async function restartDaemon() {
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 1e4
     });
-    await new Promise((resolve5) => setTimeout(resolve5, 1e3));
+    await new Promise((resolve6) => setTimeout(resolve6, 1e3));
     const child = (0, import_child_process9.spawn)("episoda", ["dev"], {
       detached: true,
       stdio: "ignore",
@@ -5683,7 +5895,7 @@ async function restartDaemon() {
     const pollIntervalMs = 500;
     const startTime = Date.now();
     while (Date.now() - startTime < maxWaitMs) {
-      await new Promise((resolve5) => setTimeout(resolve5, pollIntervalMs));
+      await new Promise((resolve6) => setTimeout(resolve6, pollIntervalMs));
       try {
         const reachable = await isDaemonReachable();
         if (reachable) {
@@ -5790,6 +6002,21 @@ function sanitizeGithubToken(token) {
 }
 
 // src/commands/status.ts
+var fs9 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
+function logCliReliabilityMetric(metric, fields) {
+  const line = `[CLI][Metric] ${JSON.stringify({
+    metric,
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...fields
+  })}`;
+  console.warn(line);
+  try {
+    fs9.appendFileSync(path10.join((0, import_core8.getConfigDir)(), "daemon.log"), `${line}
+`, "utf-8");
+  } catch {
+  }
+}
 async function statusCommand(options = {}) {
   status.info("Checking CLI status...");
   status.info("");
@@ -5810,7 +6037,7 @@ async function statusCommand(options = {}) {
   status.info(`  API URL: ${config.api_url}`);
   const effectiveCliVersion = resolveEffectiveCliVersion(import_core8.VERSION);
   const installChannel = detectCliInstallChannel(import_core8.VERSION);
-  if (!options.skipUpdateCheck) {
+  if (options.update) {
     const updateResult = await checkForUpdates(effectiveCliVersion);
     if (updateResult.isLinked) {
       status.info(`  CLI Version: ${effectiveCliVersion} (linked)`);
@@ -5833,6 +6060,7 @@ async function statusCommand(options = {}) {
     }
   } else {
     status.info(`  CLI Version: ${effectiveCliVersion}`);
+    status.info('  Run "episoda update" (or "episoda status --update") to apply updates.');
   }
   if (installChannel.legacyOnly) {
     status.warning(`  \u26A0 Legacy package channel detected (episoda@${installChannel.legacyVersion})`);
@@ -5853,6 +6081,10 @@ async function statusCommand(options = {}) {
   if (!daemonStatus) {
     const daemonPid = isDaemonRunning();
     if (daemonPid) {
+      logCliReliabilityMetric("manual_reconnect_needed", {
+        reason: "daemon_running_ipc_unreachable",
+        daemonPid
+      });
       status.error("\u2717 Daemon process is running but IPC is not reachable");
       status.info(`  PID: ${daemonPid}`);
       status.info('  Run "episoda dev" to re-establish IPC/connection (or "episoda stop && episoda dev").');
@@ -5874,6 +6106,11 @@ async function statusCommand(options = {}) {
           status.info(`  Platform: ${daemonStatus.platform}/${daemonStatus.arch}`);
           status.info(`  Project: ${connectedProject.name}`);
         } else if (serverCheck.localConnected && !serverCheck.serverConnected) {
+          logCliReliabilityMetric("manual_reconnect_needed", {
+            reason: "local_connected_server_disagrees",
+            machineId: serverCheck.machineId,
+            serverMachineId: serverCheck.serverMachineId || null
+          });
           status.error("\u2717 Not connected to server");
           status.info(`  Device: ${deviceDisplayName}`);
           status.info(`  Platform: ${daemonStatus.platform}/${daemonStatus.arch}`);
@@ -6028,24 +6265,24 @@ async function stopCommand(options = {}) {
 }
 
 // src/commands/clone.ts
-var fs10 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
+var fs11 = __toESM(require("fs"));
+var path12 = __toESM(require("path"));
 var import_core10 = __toESM(require_dist());
 
 // src/daemon/project-tracker.ts
-var fs9 = __toESM(require("fs"));
-var path10 = __toESM(require("path"));
+var fs10 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
 var import_core9 = __toESM(require_dist());
 function getProjectsFilePath() {
-  return path10.join((0, import_core9.getConfigDir)(), "projects.json");
+  return path11.join((0, import_core9.getConfigDir)(), "projects.json");
 }
 function readProjects() {
   const projectsPath = getProjectsFilePath();
   try {
-    if (!fs9.existsSync(projectsPath)) {
+    if (!fs10.existsSync(projectsPath)) {
       return { projects: [] };
     }
-    const content = fs9.readFileSync(projectsPath, "utf-8");
+    const content = fs10.readFileSync(projectsPath, "utf-8");
     const data = JSON.parse(content);
     if (!data.projects || !Array.isArray(data.projects)) {
       console.warn("Invalid projects.json structure, resetting");
@@ -6060,11 +6297,11 @@ function readProjects() {
 function writeProjects(data) {
   const projectsPath = getProjectsFilePath();
   try {
-    const dir = path10.dirname(projectsPath);
-    if (!fs9.existsSync(dir)) {
-      fs9.mkdirSync(dir, { recursive: true });
+    const dir = path11.dirname(projectsPath);
+    if (!fs10.existsSync(dir)) {
+      fs10.mkdirSync(dir, { recursive: true });
     }
-    fs9.writeFileSync(projectsPath, JSON.stringify(data, null, 2), "utf-8");
+    fs10.writeFileSync(projectsPath, JSON.stringify(data, null, 2), "utf-8");
   } catch (error) {
     throw new Error(`Failed to write projects.json: ${error}`);
   }
@@ -6088,7 +6325,7 @@ function addProject2(projectId, projectPath, options) {
     console.log(`[ProjectTracker] Replacing project entry: ${existingById.path} -> ${projectPath}`);
     data.projects.splice(existingByIdIndex, 1);
   }
-  const projectName = path10.basename(projectPath);
+  const projectName = path11.basename(projectPath);
   const newProject = {
     id: projectId,
     path: projectPath,
@@ -6122,9 +6359,9 @@ async function cloneCommand(slugArg, options = {}) {
   }
   const apiUrl = options.apiUrl || config.api_url || "https://episoda.dev";
   const projectPath = getProjectPath(workspaceSlug, projectSlug);
-  if (fs10.existsSync(projectPath)) {
-    const bareRepoPath = path11.join(projectPath, ".bare");
-    if (fs10.existsSync(bareRepoPath)) {
+  if (fs11.existsSync(projectPath)) {
+    const bareRepoPath = path12.join(projectPath, ".bare");
+    if (fs11.existsSync(bareRepoPath)) {
       status.warning(`Project already cloned at ${projectPath}`);
       status.info("");
       status.info("Next steps:");
@@ -6156,7 +6393,7 @@ Please configure a repository in the project settings on episoda.dev.`
   status.info("");
   status.info("Creating project directory...");
   const episodaRoot = getEpisodaRoot();
-  fs10.mkdirSync(projectPath, { recursive: true });
+  fs11.mkdirSync(projectPath, { recursive: true });
   status.success(`\u2713 Created ${projectPath}`);
   status.info("Cloning repository (bare)...");
   try {
@@ -6194,9 +6431,9 @@ Please configure a repository in the project settings on episoda.dev.`
     status.info("  3. episoda checkout {moduleUid}  # e.g., episoda checkout EP100");
     status.info("");
   } catch (error) {
-    if (fs10.existsSync(projectPath)) {
+    if (fs11.existsSync(projectPath)) {
       try {
-        fs10.rmSync(projectPath, { recursive: true, force: true });
+        fs11.rmSync(projectPath, { recursive: true, force: true });
       } catch {
       }
     }
@@ -6290,15 +6527,15 @@ async function fetchWithRetry(url, options, maxRetries = 3) {
       lastError = error instanceof Error ? error : new Error("Network error");
     }
     if (attempt < maxRetries - 1) {
-      await new Promise((resolve5) => setTimeout(resolve5, Math.pow(2, attempt) * 1e3));
+      await new Promise((resolve6) => setTimeout(resolve6, Math.pow(2, attempt) * 1e3));
     }
   }
   throw lastError || new Error("Request failed after retries");
 }
 
 // src/utils/env-setup.ts
-var fs11 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var fs12 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
 async function fetchEnvVars(apiUrl, accessToken) {
   try {
     const url = `${apiUrl}/api/cli/env-vars`;
@@ -6333,8 +6570,8 @@ function writeEnvFile(targetPath, envVars) {
     }
     return `${key}=${value}`;
   }).join("\n") + "\n";
-  const envPath = path12.join(targetPath, ".env");
-  fs11.writeFileSync(envPath, envContent, { mode: 384 });
+  const envPath = path13.join(targetPath, ".env");
+  fs12.writeFileSync(envPath, envContent, { mode: 384 });
   console.log(`[env-setup] Wrote ${Object.keys(envVars).length} env vars to ${envPath}`);
 }
 async function setupWorktreeEnv(worktreePath, apiUrl, accessToken) {
@@ -6552,7 +6789,7 @@ async function updateModuleCheckout(apiUrl, moduleId, accessToken, branchName, w
 }
 
 // src/commands/release.ts
-var path13 = __toESM(require("path"));
+var path14 = __toESM(require("path"));
 var import_core12 = __toESM(require_dist());
 async function releaseCommand(moduleUid, options = {}) {
   if (!moduleUid || !moduleUid.match(/^EP\d+$/)) {
@@ -6599,7 +6836,7 @@ Commit or stash your changes first, or use --force to discard them.`
       );
     }
   }
-  const currentPath = path13.resolve(process.cwd());
+  const currentPath = path14.resolve(process.cwd());
   if (currentPath.startsWith(existing.worktreePath)) {
     status.warning("You are inside the worktree being released.");
     status.info(`Please cd to ${projectRoot} first.`);
@@ -6673,8 +6910,8 @@ async function updateModuleRelease(apiUrl, projectId, workspaceSlug, moduleUid,
 }
 
 // src/commands/list.ts
-var fs12 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
+var fs13 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
 var import_chalk2 = __toESM(require("chalk"));
 var import_core13 = __toESM(require_dist());
 async function listCommand(subcommand, options = {}) {
@@ -6686,7 +6923,7 @@ async function listCommand(subcommand, options = {}) {
 }
 async function listProjects(options) {
   const episodaRoot = getEpisodaRoot();
-  if (!fs12.existsSync(episodaRoot)) {
+  if (!fs13.existsSync(episodaRoot)) {
     status.info("No projects cloned yet.");
     status.info("");
     status.info("Clone a project with:");
@@ -6694,12 +6931,12 @@ async function listProjects(options) {
     return;
   }
   const projects = [];
-  const workspaces = fs12.readdirSync(episodaRoot, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("."));
+  const workspaces = fs13.readdirSync(episodaRoot, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("."));
   for (const workspace of workspaces) {
-    const workspacePath = path14.join(episodaRoot, workspace.name);
-    const projectDirs = fs12.readdirSync(workspacePath, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("."));
+    const workspacePath = path15.join(episodaRoot, workspace.name);
+    const projectDirs = fs13.readdirSync(workspacePath, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("."));
     for (const projectDir of projectDirs) {
-      const projectPath = path14.join(workspacePath, projectDir.name);
+      const projectPath = path15.join(workspacePath, projectDir.name);
       if (await isWorktreeProject(projectPath)) {
         const manager = new WorktreeManager(projectPath);
         await manager.initialize();
@@ -6805,7 +7042,7 @@ async function listWorktrees(options) {
     console.log("");
     console.log(import_chalk2.default.red("  Orphaned worktrees (in git but not in config):"));
     for (const wtPath of orphaned) {
-      const moduleUid = path14.basename(wtPath);
+      const moduleUid = path15.basename(wtPath);
       console.log(import_chalk2.default.red(`    \u2717 ${moduleUid} - ${wtPath}`));
     }
     console.log(import_chalk2.default.gray("    These may be from crashed sessions. Run `episoda release <uid>` to clean up"));
@@ -6955,7 +7192,7 @@ async function updateCommand(options = {}) {
   }
   if (options.restart && daemonWasRunning) {
     status.info("Restarting daemon...");
-    await new Promise((resolve5) => setTimeout(resolve5, 1e3));
+    await new Promise((resolve6) => setTimeout(resolve6, 1e3));
     if (startDaemon2()) {
       status.success("\u2713 Daemon restarted");
       status.info("");
@@ -6999,26 +7236,26 @@ var import_child_process12 = require("child_process");
 var import_core15 = __toESM(require_dist());
 
 // src/utils/env-cache.ts
-var fs13 = __toESM(require("fs"));
-var path15 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
 var os4 = __toESM(require("os"));
 var DEFAULT_CACHE_TTL = 60;
-var CACHE_DIR = path15.join(os4.homedir(), ".episoda", "cache");
+var CACHE_DIR = path16.join(os4.homedir(), ".episoda", "cache");
 function getCacheFilePath(projectId) {
-  return path15.join(CACHE_DIR, `env-vars-${projectId}.json`);
+  return path16.join(CACHE_DIR, `env-vars-${projectId}.json`);
 }
 function ensureCacheDir() {
-  if (!fs13.existsSync(CACHE_DIR)) {
-    fs13.mkdirSync(CACHE_DIR, { recursive: true, mode: 448 });
+  if (!fs14.existsSync(CACHE_DIR)) {
+    fs14.mkdirSync(CACHE_DIR, { recursive: true, mode: 448 });
   }
 }
 function readCache(projectId) {
   try {
     const cacheFile = getCacheFilePath(projectId);
-    if (!fs13.existsSync(cacheFile)) {
+    if (!fs14.existsSync(cacheFile)) {
       return null;
     }
-    const content = fs13.readFileSync(cacheFile, "utf-8");
+    const content = fs14.readFileSync(cacheFile, "utf-8");
     const data = JSON.parse(content);
     if (!data.vars || typeof data.vars !== "object" || !data.fetchedAt) {
       return null;
@@ -7037,7 +7274,7 @@ function writeCache(projectId, vars) {
       fetchedAt: Date.now(),
       projectId
     };
-    fs13.writeFileSync(cacheFile, JSON.stringify(data, null, 2), { mode: 384 });
+    fs14.writeFileSync(cacheFile, JSON.stringify(data, null, 2), { mode: 384 });
   } catch (error) {
     console.warn("[env-cache] Failed to write cache:", error instanceof Error ? error.message : error);
   }
@@ -7273,8 +7510,8 @@ function printExports(envVars) {
 }
 
 // src/commands/env.ts
-var fs14 = __toESM(require("fs"));
-var path16 = __toESM(require("path"));
+var fs15 = __toESM(require("fs"));
+var path17 = __toESM(require("path"));
 var readline = __toESM(require("readline"));
 var import_core17 = __toESM(require_dist());
 async function envListCommand(options = {}) {
@@ -7474,27 +7711,27 @@ async function envPullCommand(options = {}) {
     return;
   }
   const filename = options.file || ".env";
-  const filepath = path16.resolve(process.cwd(), filename);
-  fs14.writeFileSync(filepath, fullContent, { mode: 384 });
+  const filepath = path17.resolve(process.cwd(), filename);
+  fs15.writeFileSync(filepath, fullContent, { mode: 384 });
   status.success(`Wrote ${Object.keys(visibleEnvVars).length} env vars to ${filename}`);
 }
 async function promptForValue(key) {
   if (!process.stdin.isTTY) {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const rl = readline.createInterface({
         input: process.stdin,
         output: process.stdout
       });
       rl.question(`Enter value for ${key}: `, (answer) => {
         rl.close();
-        resolve5(answer);
+        resolve6(answer);
       });
       rl.on("close", () => {
         reject(new Error("Input closed"));
       });
     });
   }
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout
@@ -7514,7 +7751,7 @@ async function promptForValue(key) {
         resolved = true;
         cleanup();
         console.log("");
-        resolve5(value);
+        resolve6(value);
       } else if (str === "") {
         cleanup();
         reject(new Error("Cancelled"));
@@ -7743,8 +7980,8 @@ async function migrationsFixCommand(options) {
 }
 
 // src/utils/legacy-channel-notice.ts
-var fs15 = __toESM(require("fs"));
-var path18 = __toESM(require("path"));
+var fs16 = __toESM(require("fs"));
+var path19 = __toESM(require("path"));
 var import_core18 = __toESM(require_dist());
 var LEGACY_NOTICE_FILE = "legacy-channel-notice.json";
 var LEGACY_NOTICE_TTL_MS = 24 * 60 * 60 * 1e3;
@@ -7757,7 +7994,7 @@ var SUPPRESSED_COMMANDS = /* @__PURE__ */ new Set([
   "migrations"
 ]);
 function getNoticeFilePath() {
-  return path18.join((0, import_core18.getConfigDir)(), LEGACY_NOTICE_FILE);
+  return path19.join((0, import_core18.getConfigDir)(), LEGACY_NOTICE_FILE);
 }
 function getPrimaryCommand(argv) {
   const args = argv.slice(2);
@@ -7765,7 +8002,7 @@ function getPrimaryCommand(argv) {
 }
 function readNoticeRecord() {
   try {
-    const raw = fs15.readFileSync(getNoticeFilePath(), "utf-8");
+    const raw = fs16.readFileSync(getNoticeFilePath(), "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed?.legacyVersion || typeof parsed.shownAt !== "number") {
       return null;
@@ -7777,8 +8014,8 @@ function readNoticeRecord() {
 }
 function writeNoticeRecord(record) {
   try {
-    fs15.mkdirSync((0, import_core18.getConfigDir)(), { recursive: true });
-    fs15.writeFileSync(getNoticeFilePath(), JSON.stringify(record), "utf-8");
+    fs16.mkdirSync((0, import_core18.getConfigDir)(), { recursive: true });
+    fs16.writeFileSync(getNoticeFilePath(), JSON.stringify(record), "utf-8");
   } catch {
   }
 }
@@ -7874,12 +8111,12 @@ import_commander.program.command("setup").description("Register episoda:// proto
     process.exit(1);
   }
 });
-import_commander.program.command("status").description("Show connection status").option("--verify", "Verify connection is healthy (not just connected)").option("--local", "Only check local daemon state (faster, but may be stale)").option("--skip-update-check", "Skip CLI version update check (faster)").action(async (options) => {
+import_commander.program.command("status").description("Show connection status").option("--verify", "Verify connection is healthy (not just connected)").option("--local", "Only check local daemon state (faster, but may be stale)").option("--update", "Check and apply CLI update if available (mutating)").action(async (options) => {
   try {
     await statusCommand({
       verify: options.verify,
       local: options.local,
-      skipUpdateCheck: options.skipUpdateCheck
+      update: options.update
     });
   } catch (error) {
     status.error(`Status check failed: ${error instanceof Error ? error.message : String(error)}`);