@episoda/cli 0.2.163 → 0.2.165

package/dist/index.js

@@ -343,6 +343,8 @@ var require_git_executor = __commonJS({
             case "delete_branch":
               return await this.executeDeleteBranch(command, cwd, options);
             // EP597: Read operations for production local dev mode
+            case "list_branches":
+              return await this.executeListBranches(cwd, options);
             case "branch_exists":
               return await this.executeBranchExists(command, cwd, options);
             case "branch_has_commits":
@@ -632,6 +634,65 @@ var require_git_executor = __commonJS({
         args.push(command.branch);
         return await this.runGitCommand(args, cwd, options);
       }
+      /**
+       * List local branches with remote-tracking signal and current branch marker.
+       */
+      async executeListBranches(cwd, options) {
+        try {
+          const timeout = options?.timeout || 1e4;
+          const branchMap = /* @__PURE__ */ new Map();
+          const addBranch = (name, attrs) => {
+            const normalized = name.trim();
+            if (!normalized)
+              return;
+            const existing = branchMap.get(normalized);
+            if (existing) {
+              existing.current = existing.current || !!attrs?.current;
+              existing.remote = existing.remote || !!attrs?.remote;
+              return;
+            }
+            branchMap.set(normalized, {
+              name: normalized,
+              current: !!attrs?.current,
+              remote: !!attrs?.remote
+            });
+          };
+          const statusResult = await this.executeStatus(cwd, options);
+          const currentBranch = statusResult.success ? statusResult.details?.branchName : void 0;
+          try {
+            const { stdout } = await execAsync(`git for-each-ref --format='%(refname:short)' refs/heads`, { cwd, timeout });
+            stdout.split("\n").map((line) => line.trim()).filter(Boolean).forEach((name) => addBranch(name, { current: name === currentBranch }));
+          } catch {
+          }
+          try {
+            const { stdout } = await execAsync(`git for-each-ref --format='%(refname:short)' refs/remotes/origin`, { cwd, timeout });
+            stdout.split("\n").map((line) => line.trim()).filter(Boolean).forEach((refName) => {
+              if (refName === "origin/HEAD")
+                return;
+              const normalized = refName.startsWith("origin/") ? refName.slice("origin/".length) : refName;
+              addBranch(normalized, { remote: true, current: normalized === currentBranch });
+            });
+          } catch {
+          }
+          if (currentBranch && currentBranch !== "HEAD") {
+            addBranch(currentBranch, { current: true });
+          }
+          const branches = Array.from(branchMap.values()).sort((a, b) => a.name.localeCompare(b.name));
+          return {
+            success: true,
+            details: {
+              branchName: currentBranch,
+              branches
+            }
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: "UNKNOWN_ERROR",
+            output: error.message || "Failed to list branches"
+          };
+        }
+      }
       /**
        * EP597: Execute branch_exists command
        * Checks if a branch exists locally and/or remotely
@@ -1579,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 fs15 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+            const fs16 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
             const rebaseMergePath = `${gitDirPath}/rebase-merge`;
             const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
             try {
-              await fs15.access(rebaseMergePath);
+              await fs16.access(rebaseMergePath);
               inRebase = true;
             } catch {
               try {
-                await fs15.access(rebaseApplyPath);
+                await fs16.access(rebaseApplyPath);
                 inRebase = true;
               } catch {
                 inRebase = false;
@@ -1643,9 +1704,9 @@ var require_git_executor = __commonJS({
               };
             }
           }
-          const fs15 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs16 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs15.access(command.path);
+            await fs16.access(command.path);
             return {
               success: false,
               error: "WORKTREE_EXISTS",
@@ -1704,9 +1765,9 @@ var require_git_executor = __commonJS({
        */
       async executeWorktreeRemove(command, cwd, options) {
         try {
-          const fs15 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs16 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs15.access(command.path);
+            await fs16.access(command.path);
           } catch {
             return {
               success: false,
@@ -1741,7 +1802,7 @@ var require_git_executor = __commonJS({
           const result = await this.runGitCommand(args, cwd, options);
           if (result.success) {
             try {
-              await fs15.rm(command.path, { recursive: true, force: true });
+              await fs16.rm(command.path, { recursive: true, force: true });
             } catch {
             }
             return {
@@ -1875,10 +1936,10 @@ var require_git_executor = __commonJS({
        */
       async executeCloneBare(command, options) {
         try {
-          const fs15 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path18 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs16 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path19 = await Promise.resolve().then(() => __importStar(require("path")));
           try {
-            await fs15.access(command.path);
+            await fs16.access(command.path);
             return {
               success: false,
               error: "BRANCH_ALREADY_EXISTS",
@@ -1887,9 +1948,9 @@ var require_git_executor = __commonJS({
             };
           } catch {
           }
-          const parentDir = path18.dirname(command.path);
+          const parentDir = path19.dirname(command.path);
           try {
-            await fs15.mkdir(parentDir, { recursive: true });
+            await fs16.mkdir(parentDir, { recursive: true });
           } catch {
           }
           const { stdout, stderr } = await execAsync(
@@ -1937,22 +1998,22 @@ var require_git_executor = __commonJS({
        */
       async executeProjectInfo(cwd, options) {
         try {
-          const fs15 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path18 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs16 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path19 = await Promise.resolve().then(() => __importStar(require("path")));
           let currentPath = cwd;
           let projectPath = cwd;
           let bareRepoPath;
           for (let i = 0; i < 10; i++) {
-            const bareDir = path18.join(currentPath, ".bare");
-            const episodaDir = path18.join(currentPath, ".episoda");
+            const bareDir = path19.join(currentPath, ".bare");
+            const episodaDir = path19.join(currentPath, ".episoda");
             try {
-              await fs15.access(bareDir);
-              await fs15.access(episodaDir);
+              await fs16.access(bareDir);
+              await fs16.access(episodaDir);
               projectPath = currentPath;
               bareRepoPath = bareDir;
               break;
             } catch {
-              const parentPath = path18.dirname(currentPath);
+              const parentPath = path19.dirname(currentPath);
               if (parentPath === currentPath) {
                 break;
               }
@@ -2153,6 +2214,8 @@ var require_websocket_client = __commonJS({
         this.osArch = deviceInfo?.osArch;
         this.daemonPid = deviceInfo?.daemonPid;
         this.cliVersion = deviceInfo?.cliVersion;
+        this.cliPackageName = deviceInfo?.cliPackageName;
+        this.capabilities = deviceInfo?.capabilities;
         this.environment = deviceInfo?.environment;
         this.containerId = deviceInfo?.containerId;
         this.isDisconnecting = false;
@@ -2192,6 +2255,8 @@ var require_websocket_client = __commonJS({
                 type: "auth",
                 token,
                 version: this.cliVersion || version_1.VERSION,
+                cliPackageName: this.cliPackageName,
+                capabilities: this.capabilities,
                 environment: this.environment,
                 machineId,
                 containerId: this.containerId,
@@ -2511,6 +2576,8 @@ var require_websocket_client = __commonJS({
             osArch: this.osArch,
             daemonPid: this.daemonPid,
             cliVersion: this.cliVersion,
+            cliPackageName: this.cliPackageName,
+            capabilities: this.capabilities,
             environment: this.environment,
             containerId: this.containerId
           }).then(() => {
@@ -2602,38 +2669,38 @@ var require_auth = __commonJS({
       };
     })();
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.getConfigDir = getConfigDir5;
+    exports2.getConfigDir = getConfigDir6;
     exports2.getConfigPath = getConfigPath4;
     exports2.loadConfig = loadConfig9;
     exports2.saveConfig = saveConfig3;
     exports2.validateToken = validateToken;
-    var fs15 = __importStar(require("fs"));
-    var path18 = __importStar(require("path"));
+    var fs16 = __importStar(require("fs"));
+    var path19 = __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 getConfigDir5() {
-      return process.env.EPISODA_CONFIG_DIR || path18.join(os5.homedir(), ".episoda");
+    function getConfigDir6() {
+      return process.env.EPISODA_CONFIG_DIR || path19.join(os5.homedir(), ".episoda");
     }
     function getConfigPath4(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path18.join(getConfigDir5(), DEFAULT_CONFIG_FILE);
+      return path19.join(getConfigDir6(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path18.dirname(configPath);
-      const isNew = !fs15.existsSync(dir);
+      const dir = path19.dirname(configPath);
+      const isNew = !fs16.existsSync(dir);
       if (isNew) {
-        fs15.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs16.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path18.join(dir, ".nosync");
-        if (isNew || !fs15.existsSync(nosyncPath)) {
+        const nosyncPath = path19.join(dir, ".nosync");
+        if (isNew || !fs16.existsSync(nosyncPath)) {
           try {
-            fs15.writeFileSync(nosyncPath, "", { mode: 384 });
+            fs16.writeFileSync(nosyncPath, "", { mode: 384 });
             (0, child_process_1.execSync)(`xattr -w com.apple.fileprovider.ignore 1 "${dir}"`, {
               stdio: "ignore",
               timeout: 5e3
@@ -2647,11 +2714,11 @@ var require_auth = __commonJS({
       const fullPath = getConfigPath4(configPath);
       const isCloudMode = process.env.EPISODA_MODE === "cloud";
       const readConfigFile = (pathToFile) => {
-        if (!fs15.existsSync(pathToFile)) {
+        if (!fs16.existsSync(pathToFile)) {
           return null;
         }
         try {
-          const content = fs15.readFileSync(pathToFile, "utf8");
+          const content = fs16.readFileSync(pathToFile, "utf8");
           return JSON.parse(content);
         } catch (error) {
           console.error("Error loading config:", error);
@@ -2690,11 +2757,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 (!fs15.existsSync(workspaceConfigPath)) {
+        if (!fs16.existsSync(workspaceConfigPath)) {
           return null;
         }
         try {
-          const content = fs15.readFileSync(workspaceConfigPath, "utf8");
+          const content = fs16.readFileSync(workspaceConfigPath, "utf8");
           const workspaceConfig2 = JSON.parse(content);
           const expiresAtEnv = envValue(process.env.EPISODA_ACCESS_TOKEN_EXPIRES_AT);
           return {
@@ -2722,11 +2789,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 (!fs15.existsSync(projectConfigPath)) {
+        if (!fs16.existsSync(projectConfigPath)) {
           return null;
         }
         try {
-          const content = fs15.readFileSync(projectConfigPath, "utf8");
+          const content = fs16.readFileSync(projectConfigPath, "utf8");
           const projectConfig2 = JSON.parse(content);
           return {
             project_id: projectConfig2.projectId || projectConfig2.project_id,
@@ -2794,7 +2861,7 @@ var require_auth = __commonJS({
       ensureConfigDir(fullPath);
       try {
         const content = JSON.stringify(config, null, 2);
-        fs15.writeFileSync(fullPath, content, { mode: 384 });
+        fs16.writeFileSync(fullPath, content, { mode: 384 });
       } catch (error) {
         throw new Error(`Failed to save config: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -2908,7 +2975,7 @@ var require_dist = __commonJS({
 
 // src/index.ts
 var import_commander = require("commander");
-var import_core18 = __toESM(require_dist());
+var import_core19 = __toESM(require_dist());
 
 // src/commands/daemon.ts
 var import_core4 = __toESM(require_dist());
@@ -2982,6 +3049,21 @@ function killAllEpisodaProcesses() {
 function getPidFilePath() {
   return path.join((0, import_core.getConfigDir)(), "daemon.pid");
 }
+function looksLikeEpisodaDaemonProcess(pid) {
+  if (process.platform === "win32") {
+    return true;
+  }
+  try {
+    const command = (0, import_child_process.execSync)(`ps -p ${pid} -o command=`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 3e3
+    }).trim();
+    return command.includes("daemon-process");
+  } catch {
+    return true;
+  }
+}
 function isDaemonRunning() {
   const pidPath = getPidFilePath();
   try {
@@ -2996,6 +3078,10 @@ function isDaemonRunning() {
     }
     try {
       process.kill(pid, 0);
+      if (!looksLikeEpisodaDaemonProcess(pid)) {
+        fs.unlinkSync(pidPath);
+        return null;
+      }
       return pid;
     } catch (error) {
       fs.unlinkSync(pidPath);
@@ -3654,8 +3740,8 @@ var WorktreeManager = class _WorktreeManager {
     const allWorktrees = this.listWorktrees();
     const activeSet = new Set(activeModuleUids);
     const orphaned = allWorktrees.filter((w) => !activeSet.has(w.moduleUid));
-    const valid = allWorktrees.filter((w) => activeSet.has(w.moduleUid));
-    return { orphaned, valid };
+    const valid2 = allWorktrees.filter((w) => activeSet.has(w.moduleUid));
+    return { orphaned, valid: valid2 };
   }
   /**
    * Update last accessed timestamp for a worktree
@@ -3690,7 +3776,7 @@ var WorktreeManager = class _WorktreeManager {
    */
   async validateWorktrees() {
     const config = this.readConfig();
-    const valid = [];
+    const valid2 = [];
     const stale = [];
     const orphaned = [];
     const listResult = await this.gitExecutor.execute({
@@ -3701,7 +3787,7 @@ var WorktreeManager = class _WorktreeManager {
     );
     for (const worktree of config?.worktrees || []) {
       if (actualWorktrees.has(worktree.worktreePath)) {
-        valid.push(worktree);
+        valid2.push(worktree);
         actualWorktrees.delete(worktree.worktreePath);
       } else {
         stale.push(worktree);
@@ -3712,7 +3798,7 @@ var WorktreeManager = class _WorktreeManager {
         orphaned.push(wpath);
       }
     }
-    return { valid, stale, orphaned };
+    return { valid: valid2, stale, orphaned };
   }
   /**
    * EP1190: Clean up non-module worktrees (like 'main')
@@ -4165,7 +4251,7 @@ async function fetchProjectPath(config, projectId) {
     return null;
   }
 }
-async function syncProjectPath(config, projectId, path18) {
+async function syncProjectPath(config, projectId, path19) {
   const machineUuid = config.machine_uuid || config.device_id;
   if (!machineUuid || !config.access_token) {
     return false;
@@ -4179,7 +4265,7 @@ async function syncProjectPath(config, projectId, path18) {
         "Authorization": `Bearer ${config.access_token}`,
         "Content-Type": "application/json"
       },
-      body: JSON.stringify({ path: path18 })
+      body: JSON.stringify({ path: path19 })
     });
     if (!response.ok) {
       console.debug(`[MachineSettings] syncProjectPath failed: ${response.status} ${response.statusText}`);
@@ -4492,14 +4578,12 @@ async function daemonCommand(options = {}) {
           if (health.healthyConnections > 0) {
             status.debug(`Daemon already running and healthy (PID: ${existingPid})`);
           } else if (health.staleConnections > 0) {
-            status.info("Daemon has stale connections, restarting...");
-            needsRestart = true;
+            status.warning("Daemon has stale connections; continuing without restart and reconnecting...");
           } else {
             status.debug(`Daemon running but no connections (PID: ${existingPid})`);
           }
         } catch {
-          status.debug("Health check failed, restarting daemon...");
-          needsRestart = true;
+          status.warning("Health check failed; continuing with reconnect flow...");
         }
       } else {
         status.debug("Daemon not reachable via IPC, restarting...");
@@ -5488,6 +5572,7 @@ var import_core8 = __toESM(require_dist());
 var import_child_process9 = require("child_process");
 var semver = __toESM(require("semver"));
 var PACKAGE_NAME = "@episoda/cli";
+var LEGACY_PACKAGE_NAME = "episoda";
 var NPM_REGISTRY = "https://registry.npmjs.org";
 function isFileLinkedInstall() {
   try {
@@ -5621,6 +5706,39 @@ function getInstalledVersion() {
     return null;
   }
 }
+function getLegacyInstalledVersion() {
+  try {
+    const output = (0, import_child_process9.execSync)(`npm list -g ${LEGACY_PACKAGE_NAME} --json`, {
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 1e4
+    }).toString();
+    const data = JSON.parse(output);
+    return data?.dependencies?.[LEGACY_PACKAGE_NAME]?.version || null;
+  } catch {
+    return null;
+  }
+}
+function detectCliInstallChannel(embeddedVersion) {
+  const scopedVersion = getInstalledVersion();
+  const legacyVersion = getLegacyInstalledVersion();
+  const effectiveVersion = scopedVersion || legacyVersion || embeddedVersion || null;
+  return {
+    scopedVersion,
+    legacyVersion,
+    legacyOnly: !scopedVersion && !!legacyVersion,
+    effectiveVersion
+  };
+}
+function resolveEffectiveCliVersion(embeddedVersion) {
+  const installedVersion = detectCliInstallChannel(embeddedVersion).effectiveVersion;
+  if (!installedVersion) {
+    return embeddedVersion;
+  }
+  if (semver.valid(installedVersion) && semver.valid(embeddedVersion)) {
+    return semver.gt(installedVersion, embeddedVersion) ? installedVersion : embeddedVersion;
+  }
+  return installedVersion === embeddedVersion ? embeddedVersion : installedVersion;
+}
 
 // src/utils/github-token.ts
 var INVALID_GITHUB_TOKEN_LITERALS = /* @__PURE__ */ new Set([
@@ -5657,12 +5775,14 @@ async function statusCommand(options = {}) {
   status.info("Configuration:");
   status.info(`  Project ID: ${config.project_id}`);
   status.info(`  API URL: ${config.api_url}`);
+  const effectiveCliVersion = resolveEffectiveCliVersion(import_core8.VERSION);
+  const installChannel = detectCliInstallChannel(import_core8.VERSION);
   if (!options.skipUpdateCheck) {
-    const updateResult = await checkForUpdates(import_core8.VERSION);
+    const updateResult = await checkForUpdates(effectiveCliVersion);
     if (updateResult.isLinked) {
-      status.info(`  CLI Version: ${import_core8.VERSION} (linked)`);
+      status.info(`  CLI Version: ${effectiveCliVersion} (linked)`);
     } else if (updateResult.updateAvailable) {
-      status.info(`  CLI Version: ${import_core8.VERSION} \u2192 ${updateResult.latestVersion} (updating...)`);
+      status.info(`  CLI Version: ${effectiveCliVersion} \u2192 ${updateResult.latestVersion} (updating...)`);
       const result = await updateAndRestartDaemon(updateResult.latestVersion);
       if (result.updateSuccess && result.restartSuccess) {
         status.success(`  CLI Version: ${updateResult.latestVersion} \u2713 (updated & daemon restarted)`);
@@ -5673,13 +5793,17 @@ async function statusCommand(options = {}) {
       } else if (result.updateSuccess) {
         status.warning(`  CLI Version: ${updateResult.latestVersion} (updated, restart manually with 'episoda dev')`);
       } else {
-        status.warning(`  CLI Version: ${import_core8.VERSION} (update failed: ${result.error})`);
+        status.warning(`  CLI Version: ${effectiveCliVersion} (update failed: ${result.error})`);
       }
     } else {
-      status.info(`  CLI Version: ${import_core8.VERSION} \u2713`);
+      status.info(`  CLI Version: ${effectiveCliVersion} \u2713`);
     }
   } else {
-    status.info(`  CLI Version: ${import_core8.VERSION}`);
+    status.info(`  CLI Version: ${effectiveCliVersion}`);
+  }
+  if (installChannel.legacyOnly) {
+    status.warning(`  \u26A0 Legacy package channel detected (episoda@${installChannel.legacyVersion})`);
+    status.info("    Migrate with: npm install -g @episoda/cli@latest");
   }
   status.info(`  Config file: ${(0, import_core8.getConfigPath)()}`);
   status.info("");
@@ -5694,8 +5818,15 @@ async function statusCommand(options = {}) {
   } catch {
   }
   if (!daemonStatus) {
-    status.warning("\u26A0 Daemon not running");
-    status.info('  Run "episoda dev" to start the daemon.');
+    const daemonPid = isDaemonRunning();
+    if (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").');
+    } else {
+      status.warning("\u26A0 Daemon not running");
+      status.info('  Run "episoda dev" to start the daemon.');
+    }
     return;
   }
   const deviceDisplayName = daemonStatus.machineName || daemonStatus.hostname;
@@ -6588,11 +6719,11 @@ async function listWorktrees(options) {
     throw new Error(`Invalid worktree project at ${projectRoot}`);
   }
   const config = manager.getConfig();
-  const { valid, stale, orphaned } = await manager.validateWorktrees();
+  const { valid: valid2, stale, orphaned } = await manager.validateWorktrees();
   console.log("");
   console.log(import_chalk2.default.bold(`Worktrees for ${config?.workspaceSlug}/${config?.projectSlug}`));
   console.log("\u2500".repeat(60));
-  const hasAnyWorktrees = valid.length > 0 || stale.length > 0 || orphaned.length > 0;
+  const hasAnyWorktrees = valid2.length > 0 || stale.length > 0 || orphaned.length > 0;
   if (!hasAnyWorktrees) {
     console.log("");
     console.log(import_chalk2.default.gray("  No worktrees checked out"));
@@ -6602,7 +6733,7 @@ async function listWorktrees(options) {
     return;
   }
   const gitExecutor = new import_core13.GitExecutor();
-  for (const wt of valid) {
+  for (const wt of valid2) {
     console.log("");
     let statusIndicator = import_chalk2.default.green("\u25CF");
     let statusNote = "";
@@ -6649,8 +6780,8 @@ async function listWorktrees(options) {
   console.log("");
   console.log(import_chalk2.default.gray("\u2500".repeat(60)));
   const parts = [];
-  if (valid.length > 0) {
-    parts.push(`${valid.length} active`);
+  if (valid2.length > 0) {
+    parts.push(`${valid2.length} active`);
   }
   if (stale.length > 0) {
     parts.push(import_chalk2.default.yellow(`${stale.length} stale`));
@@ -6717,7 +6848,8 @@ function performUpdate(targetVersion) {
   }
 }
 async function updateCommand(options = {}) {
-  const currentVersion = import_core14.VERSION;
+  const currentVersion = resolveEffectiveCliVersion(import_core14.VERSION);
+  const installChannel = detectCliInstallChannel(import_core14.VERSION);
   if (isFileLinkedInstall()) {
     status.info(`Current version: ${currentVersion} (linked)`);
     status.info("");
@@ -6727,6 +6859,10 @@ async function updateCommand(options = {}) {
     return;
   }
   status.info(`Current version: ${currentVersion}`);
+  if (installChannel.legacyOnly) {
+    status.warning(`Legacy package channel detected: episoda@${installChannel.legacyVersion}`);
+    status.info("Migrating to @episoda/cli will be handled by this update.");
+  }
   status.info("Checking for updates...");
   const result = await checkForUpdates(currentVersion);
   if (result.offline) {
@@ -7563,6 +7699,83 @@ async function migrationsFixCommand(options) {
   status.success("Migration conflicts fixed.");
 }
 
+// src/utils/legacy-channel-notice.ts
+var fs15 = __toESM(require("fs"));
+var path18 = __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;
+var SUPPRESSED_COMMANDS = /* @__PURE__ */ new Set([
+  "auth",
+  "connect",
+  "status",
+  "update",
+  "help",
+  "migrations"
+]);
+function getNoticeFilePath() {
+  return path18.join((0, import_core18.getConfigDir)(), LEGACY_NOTICE_FILE);
+}
+function getPrimaryCommand(argv) {
+  const args = argv.slice(2);
+  return args.find((arg) => arg.length > 0 && !arg.startsWith("-"));
+}
+function readNoticeRecord() {
+  try {
+    const raw = fs15.readFileSync(getNoticeFilePath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed?.legacyVersion || typeof parsed.shownAt !== "number") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeNoticeRecord(record) {
+  try {
+    fs15.mkdirSync((0, import_core18.getConfigDir)(), { recursive: true });
+    fs15.writeFileSync(getNoticeFilePath(), JSON.stringify(record), "utf-8");
+  } catch {
+  }
+}
+function shouldShowLegacyNotice(input) {
+  if (input.suppressEnv) return false;
+  if (!input.command) return false;
+  if (SUPPRESSED_COMMANDS.has(input.command)) return false;
+  if (!input.legacyOnly || !input.legacyVersion) return false;
+  if (!input.lastNotice) return true;
+  if (input.lastNotice.legacyVersion !== input.legacyVersion) return true;
+  if (input.now - input.lastNotice.shownAt > LEGACY_NOTICE_TTL_MS) return true;
+  return false;
+}
+function maybeWarnLegacyInstallChannel(argv, embeddedVersion) {
+  const command = getPrimaryCommand(argv);
+  const channel = detectCliInstallChannel(embeddedVersion);
+  const lastNotice = readNoticeRecord();
+  const now = Date.now();
+  const shouldShow = shouldShowLegacyNotice({
+    command,
+    legacyOnly: channel.legacyOnly,
+    legacyVersion: channel.legacyVersion,
+    lastNotice,
+    now,
+    suppressEnv: process.env.CI === "true" || process.env.EPISODA_SUPPRESS_LEGACY_NOTICE === "1"
+  });
+  if (!shouldShow || !channel.legacyVersion) {
+    return;
+  }
+  status.warning(`Legacy CLI install channel detected: episoda@${channel.legacyVersion}`);
+  status.info("Migrate to the supported package channel:");
+  status.info("  npm install -g @episoda/cli@latest");
+  status.info("Then restart daemon sessions with:");
+  status.info("  episoda stop && episoda dev");
+  writeNoticeRecord({
+    legacyVersion: channel.legacyVersion,
+    shownAt: now
+  });
+}
+
 // src/index.ts
 async function handleProtocolInvocation(rawUrl) {
   const parsed = parseProtocolUrl(rawUrl);
@@ -7583,7 +7796,7 @@ if (protocolArg) {
     process.exit(1);
   });
 }
-import_commander.program.name("episoda").description("Episoda CLI - local development with git worktree isolation").version(import_core18.VERSION);
+import_commander.program.name("episoda").description("Episoda CLI - local development with git worktree isolation").version(import_core19.VERSION);
 import_commander.program.command("auth").description("Authenticate to Episoda via OAuth and configure CLI").option("--api-url <url>", "API URL (default: https://episoda.dev)").action(async (options) => {
   try {
     await authCommand(options);
@@ -7841,6 +8054,7 @@ envCmd.command("pull").description("Generate .env file from database (explicit f
   }
 });
 if (!protocolArg) {
+  maybeWarnLegacyInstallChannel(process.argv, import_core19.VERSION);
   import_commander.program.parse();
 }
 //# sourceMappingURL=index.js.map