@episoda/cli 0.2.163 → 0.2.165

package/dist/daemon/daemon-process.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 execAsync3(`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 execAsync3(`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 execAsync3("git rev-parse --git-dir", { cwd, timeout: 5e3 });
             const gitDirPath = gitDir.trim();
-            const fs29 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+            const fs30 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
             const rebaseMergePath = `${gitDirPath}/rebase-merge`;
             const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
             try {
-              await fs29.access(rebaseMergePath);
+              await fs30.access(rebaseMergePath);
               inRebase = true;
             } catch {
               try {
-                await fs29.access(rebaseApplyPath);
+                await fs30.access(rebaseApplyPath);
                 inRebase = true;
               } catch {
                 inRebase = false;
@@ -1643,9 +1704,9 @@ var require_git_executor = __commonJS({
               };
             }
           }
-          const fs29 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs30 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs29.access(command.path);
+            await fs30.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 fs29 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs30 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs29.access(command.path);
+            await fs30.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 fs29.rm(command.path, { recursive: true, force: true });
+              await fs30.rm(command.path, { recursive: true, force: true });
             } catch {
             }
             return {
@@ -1875,10 +1936,10 @@ var require_git_executor = __commonJS({
        */
       async executeCloneBare(command, options) {
         try {
-          const fs29 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path30 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs30 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path31 = await Promise.resolve().then(() => __importStar(require("path")));
           try {
-            await fs29.access(command.path);
+            await fs30.access(command.path);
             return {
               success: false,
               error: "BRANCH_ALREADY_EXISTS",
@@ -1887,9 +1948,9 @@ var require_git_executor = __commonJS({
             };
           } catch {
           }
-          const parentDir = path30.dirname(command.path);
+          const parentDir = path31.dirname(command.path);
           try {
-            await fs29.mkdir(parentDir, { recursive: true });
+            await fs30.mkdir(parentDir, { recursive: true });
           } catch {
           }
           const { stdout, stderr } = await execAsync3(
@@ -1937,22 +1998,22 @@ var require_git_executor = __commonJS({
        */
       async executeProjectInfo(cwd, options) {
         try {
-          const fs29 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path30 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs30 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path31 = await Promise.resolve().then(() => __importStar(require("path")));
           let currentPath = cwd;
           let projectPath = cwd;
           let bareRepoPath;
           for (let i = 0; i < 10; i++) {
-            const bareDir = path30.join(currentPath, ".bare");
-            const episodaDir = path30.join(currentPath, ".episoda");
+            const bareDir = path31.join(currentPath, ".bare");
+            const episodaDir = path31.join(currentPath, ".episoda");
             try {
-              await fs29.access(bareDir);
-              await fs29.access(episodaDir);
+              await fs30.access(bareDir);
+              await fs30.access(episodaDir);
               projectPath = currentPath;
               bareRepoPath = bareDir;
               break;
             } catch {
-              const parentPath = path30.dirname(currentPath);
+              const parentPath = path31.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(() => {
@@ -2607,33 +2674,33 @@ var require_auth = __commonJS({
     exports2.loadConfig = loadConfig16;
     exports2.saveConfig = saveConfig4;
     exports2.validateToken = validateToken;
-    var fs29 = __importStar(require("fs"));
-    var path30 = __importStar(require("path"));
+    var fs30 = __importStar(require("fs"));
+    var path31 = __importStar(require("path"));
     var os13 = __importStar(require("os"));
     var child_process_1 = require("child_process");
     var DEFAULT_CONFIG_FILE = "config.json";
     var hasWarnedMissingProjectId = false;
     var hasWarnedMissingRequiredFields = false;
     function getConfigDir10() {
-      return process.env.EPISODA_CONFIG_DIR || path30.join(os13.homedir(), ".episoda");
+      return process.env.EPISODA_CONFIG_DIR || path31.join(os13.homedir(), ".episoda");
     }
     function getConfigPath(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path30.join(getConfigDir10(), DEFAULT_CONFIG_FILE);
+      return path31.join(getConfigDir10(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path30.dirname(configPath);
-      const isNew = !fs29.existsSync(dir);
+      const dir = path31.dirname(configPath);
+      const isNew = !fs30.existsSync(dir);
       if (isNew) {
-        fs29.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs30.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path30.join(dir, ".nosync");
-        if (isNew || !fs29.existsSync(nosyncPath)) {
+        const nosyncPath = path31.join(dir, ".nosync");
+        if (isNew || !fs30.existsSync(nosyncPath)) {
           try {
-            fs29.writeFileSync(nosyncPath, "", { mode: 384 });
+            fs30.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 = getConfigPath(configPath);
       const isCloudMode = process.env.EPISODA_MODE === "cloud";
       const readConfigFile = (pathToFile) => {
-        if (!fs29.existsSync(pathToFile)) {
+        if (!fs30.existsSync(pathToFile)) {
           return null;
         }
         try {
-          const content = fs29.readFileSync(pathToFile, "utf8");
+          const content = fs30.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 (!fs29.existsSync(workspaceConfigPath)) {
+        if (!fs30.existsSync(workspaceConfigPath)) {
           return null;
         }
         try {
-          const content = fs29.readFileSync(workspaceConfigPath, "utf8");
+          const content = fs30.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 (!fs29.existsSync(projectConfigPath)) {
+        if (!fs30.existsSync(projectConfigPath)) {
           return null;
         }
         try {
-          const content = fs29.readFileSync(projectConfigPath, "utf8");
+          const content = fs30.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);
-        fs29.writeFileSync(fullPath, content, { mode: 384 });
+        fs30.writeFileSync(fullPath, content, { mode: 384 });
       } catch (error) {
         throw new Error(`Failed to save config: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -2911,7 +2978,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@episoda/cli",
-      version: "0.2.163",
+      version: "0.2.165",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -4912,7 +4979,9 @@ var import_core9 = __toESM(require_dist());
 
 // src/agent/claude-persistent-runtime.ts
 var import_child_process7 = require("child_process");
-var ECHO_TIMEOUT_MS = parseInt(process.env.AGENT_ECHO_TIMEOUT_MS || "10000", 10);
+var DEFAULT_STARTUP_GRACE_MS = 3e4;
+var HEARTBEAT_ACK_MARKER = "__EPISODA_HEARTBEAT_ACK__";
+var ECHO_TIMEOUT_MS = parseInt(process.env.AGENT_ECHO_TIMEOUT_MS || `${DEFAULT_STARTUP_GRACE_MS}`, 10);
 var INACTIVITY_TIMEOUT_MS = parseInt(process.env.AGENT_STREAM_INACTIVITY_TIMEOUT_MS || "180000", 10);
 var SHUTDOWN_SIGTERM_WAIT_MS = 2e3;
 var SHUTDOWN_SIGKILL_WAIT_MS = 2e3;
@@ -4948,7 +5017,6 @@ var ClaudePersistentRuntime = class {
     this.echoTimer = null;
     this.inactivityTimer = null;
     this.turnStartTime = 0;
-    this.sawAnyStdoutThisTurn = false;
     // EP1360: Instrumentation
     this.spawnTimestamp = 0;
     this.sessionId = options.sessionId;
@@ -4988,6 +5056,11 @@ var ClaudePersistentRuntime = class {
     this.alive = true;
     this.process.stderr?.on("data", (data) => {
       const chunk = data.toString();
+      this.resetInactivityTimer();
+      if (this._turnState === "waiting_for_echo") {
+        const source = chunk.includes(HEARTBEAT_ACK_MARKER) ? "stderr-marker" : "stderr";
+        this.recordStartupHeartbeatAck(source);
+      }
       this.stderrTail = (this.stderrTail + chunk).slice(-this.maxStderrTailBytes);
       if (RUNTIME_DEBUG) {
         console.error(`[ClaudePersistentRuntime] stderr (session=${this.sessionId}): ${chunk.trimEnd()}`);
@@ -4995,6 +5068,7 @@ var ClaudePersistentRuntime = class {
     });
     this.process.stdout?.on("data", (data) => {
       this.resetInactivityTimer();
+      this.recordStartupHeartbeatAck("stdout");
       this.stdoutBuffer += data.toString();
       const lines = this.stdoutBuffer.split("\n");
       this.stdoutBuffer = lines.pop() || "";
@@ -5045,7 +5119,6 @@ var ClaudePersistentRuntime = class {
     this.turnStartTime = Date.now();
     this.turnTtftLogged = false;
     this.seenToolUseIds.clear();
-    this.sawAnyStdoutThisTurn = false;
     this._turnState = "waiting_for_echo";
     const payload = JSON.stringify({ type: "user", message: { role: "user", content: message } }) + "\n";
     try {
@@ -5058,9 +5131,9 @@ var ClaudePersistentRuntime = class {
     }
     this.echoTimer = setTimeout(() => {
       if (this._turnState === "waiting_for_echo") {
-        console.warn(`[ClaudePersistentRuntime] Echo timeout after ${ECHO_TIMEOUT_MS}ms \u2014 auto-degrading. session=${this.sessionId}`);
+        console.warn(`[ClaudePersistentRuntime] Startup heartbeat timeout after ${ECHO_TIMEOUT_MS}ms \u2014 auto-degrading. session=${this.sessionId}`);
         if (this.callbacks) {
-          this.callbacks.onError(`ECHO_TIMEOUT: No stdout event within ${ECHO_TIMEOUT_MS}ms after send`);
+          this.callbacks.onError(`ECHO_TIMEOUT: No startup heartbeat within ${ECHO_TIMEOUT_MS}ms after send`);
           this.endTurn();
         }
       }
@@ -5143,14 +5216,7 @@ var ClaudePersistentRuntime = class {
   }
   handleParsedEvent(parsed) {
     const type = parsed.type;
-    if (this._turnState === "waiting_for_echo") {
-      this.sawAnyStdoutThisTurn = true;
-      this.clearEchoTimer();
-      this._turnState = "streaming";
-      if (RUNTIME_DEBUG) {
-        console.log(`[ClaudePersistentRuntime] First stdout for turn \u2014 streaming started. session=${this.sessionId}`);
-      }
-    }
+    this.recordStartupHeartbeatAck("stdout");
     if (type === "user") {
       return;
     }
@@ -5336,6 +5402,14 @@ var ClaudePersistentRuntime = class {
     this.endTurn();
     cb.onComplete(this._agentSessionId, resultMeta);
   }
+  recordStartupHeartbeatAck(source) {
+    if (this._turnState !== "waiting_for_echo") return;
+    this.clearEchoTimer();
+    this._turnState = "streaming";
+    if (RUNTIME_DEBUG) {
+      console.log(`[ClaudePersistentRuntime] Startup heartbeat ack via ${source}; streaming started. session=${this.sessionId}`);
+    }
+  }
   endTurn() {
     this.clearTimers();
     this.callbacks = null;
@@ -7527,7 +7601,7 @@ ${message}`;
               const args2 = parts.slice(1);
               let env;
               if (server.name === "github") {
-                env = { ...baseEnv };
+                env = void 0;
               } else {
                 env = {
                   ...baseEnv,
@@ -8620,8 +8694,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 valid3 = allWorktrees.filter((w) => activeSet.has(w.moduleUid));
+    return { orphaned, valid: valid3 };
   }
   /**
    * Update last accessed timestamp for a worktree
@@ -8656,7 +8730,7 @@ var WorktreeManager = class _WorktreeManager {
    */
   async validateWorktrees() {
     const config = this.readConfig();
-    const valid = [];
+    const valid3 = [];
     const stale = [];
     const orphaned = [];
     const listResult = await this.gitExecutor.execute({
@@ -8667,7 +8741,7 @@ var WorktreeManager = class _WorktreeManager {
     );
     for (const worktree of config?.worktrees || []) {
       if (actualWorktrees.has(worktree.worktreePath)) {
-        valid.push(worktree);
+        valid3.push(worktree);
         actualWorktrees.delete(worktree.worktreePath);
       } else {
         stale.push(worktree);
@@ -8678,7 +8752,7 @@ var WorktreeManager = class _WorktreeManager {
         orphaned.push(wpath);
       }
     }
-    return { valid, stale, orphaned };
+    return { valid: valid3, stale, orphaned };
   }
   /**
    * EP1190: Clean up non-module worktrees (like 'main')
@@ -9405,7 +9479,7 @@ function getInstallCommand(cwd) {
 }
 
 // src/daemon/daemon-process.ts
-var fs28 = __toESM(require("fs"));
+var fs29 = __toESM(require("fs"));
 var http2 = __toESM(require("http"));
 var os12 = __toESM(require("os"));
 
@@ -10213,8 +10287,8 @@ async function handleExec(command, projectPath) {
 }
 
 // src/daemon/handlers/worktree-handlers.ts
-var path23 = __toESM(require("path"));
-var fs22 = __toESM(require("fs"));
+var path24 = __toESM(require("path"));
+var fs23 = __toESM(require("fs"));
 var os10 = __toESM(require("os"));
 var import_child_process15 = require("child_process");
 var import_util2 = require("util");
@@ -11551,6 +11625,18 @@ async function deleteWorktree(config, moduleUid) {
 // src/daemon/package-manager.ts
 var fs21 = __toESM(require("fs"));
 var path22 = __toESM(require("path"));
+function pnpmCommand(args) {
+  return [
+    "if command -v pnpm >/dev/null 2>&1; then",
+    `  pnpm ${args}`,
+    "elif command -v corepack >/dev/null 2>&1; then",
+    `  corepack pnpm ${args}`,
+    "else",
+    '  echo "[setup] ERROR: pnpm is not installed and corepack is unavailable" >&2',
+    "  exit 127",
+    "fi"
+  ].join(" ");
+}
 var PACKAGE_MANAGERS = {
   javascript: [
     {
@@ -11572,7 +11658,7 @@ var PACKAGE_MANAGERS = {
         return null;
       },
       config: {
-        installCmd: "pnpm install --frozen-lockfile",
+        installCmd: pnpmCommand("install --frozen-lockfile"),
         cacheEnvVar: "PNPM_HOME"
       }
     },
@@ -11604,7 +11690,7 @@ var PACKAGE_MANAGERS = {
       name: "pnpm",
       detector: (p) => fs21.existsSync(path22.join(p, "package.json")) ? "package.json (no lockfile - defaulting to pnpm)" : null,
       config: {
-        installCmd: "pnpm install",
+        installCmd: pnpmCommand("install"),
         cacheEnvVar: "PNPM_HOME"
       }
     }
@@ -11686,6 +11772,42 @@ function detectPackageManager(worktreePath, preferredLanguages) {
   };
 }
 
+// src/daemon/build-packages.ts
+var fs22 = __toESM(require("fs"));
+var path23 = __toESM(require("path"));
+function hasPackageScript(worktreePath, scriptName) {
+  try {
+    const packageJsonPath = path23.join(worktreePath, "package.json");
+    if (!fs22.existsSync(packageJsonPath)) {
+      return false;
+    }
+    const packageJson2 = JSON.parse(fs22.readFileSync(packageJsonPath, "utf-8"));
+    return typeof packageJson2.scripts?.[scriptName] === "string";
+  } catch {
+    return false;
+  }
+}
+function getBuildPackagesCommand(packageManagerName, hasBuildPackagesScript) {
+  if (!hasBuildPackagesScript) {
+    return null;
+  }
+  switch (packageManagerName) {
+    case "pnpm":
+      return 'if command -v pnpm >/dev/null 2>&1; then pnpm run build:packages; elif command -v corepack >/dev/null 2>&1; then corepack pnpm run build:packages; else echo "[setup] ERROR: pnpm is not installed and corepack is unavailable" >&2; exit 127; fi';
+    case "yarn":
+      return "yarn build:packages";
+    case "npm":
+      return "npm run build:packages";
+    case "bun":
+      return "bun run build:packages";
+    default:
+      return null;
+  }
+}
+function shouldRunBuildPackagesBootstrap(installSucceeded, buildPackagesCommand) {
+  return installSucceeded && !!buildPackagesCommand;
+}
+
 // src/daemon/handlers/worktree-handlers.ts
 async function getConfigForApi() {
   if (process.env.EPISODA_MODE === "cloud" && process.env.EPISODA_ACCESS_TOKEN) {
@@ -11709,18 +11831,18 @@ function persistWorkspaceProjectContext(workspaceSlug, projectSlug, projectId) {
     return;
   }
   const homeDir = process.env.HOME || os10.homedir();
-  const workspaceConfigPath = path23.join(
+  const workspaceConfigPath = path24.join(
     homeDir,
     "episoda",
     workspaceSlug,
     ".episoda",
     "config.json"
   );
-  if (!fs22.existsSync(workspaceConfigPath)) {
+  if (!fs23.existsSync(workspaceConfigPath)) {
     return;
   }
   try {
-    const content = fs22.readFileSync(workspaceConfigPath, "utf8");
+    const content = fs23.readFileSync(workspaceConfigPath, "utf8");
     const workspaceConfig = JSON.parse(content);
     let changed = false;
     if (projectId && workspaceConfig.projectId !== projectId && workspaceConfig.project_id !== projectId) {
@@ -11732,7 +11854,7 @@ function persistWorkspaceProjectContext(workspaceSlug, projectSlug, projectId) {
       changed = true;
     }
     if (changed) {
-      fs22.writeFileSync(workspaceConfigPath, JSON.stringify(workspaceConfig, null, 2), "utf8");
+      fs23.writeFileSync(workspaceConfigPath, JSON.stringify(workspaceConfig, null, 2), "utf8");
       console.log("[Worktree] Updated workspace config with project context");
     }
   } catch (error) {
@@ -11749,32 +11871,6 @@ async function autoDetectSetupScript(worktreePath) {
   console.log(`[Worktree] EP1222: Detected ${name} (${language}) via ${detection.matchedFile}`);
   return installCmd;
 }
-function getBuildPackagesCommand(packageManagerName) {
-  switch (packageManagerName) {
-    case "pnpm":
-      return "pnpm run build:packages";
-    case "yarn":
-      return "yarn build:packages";
-    case "npm":
-      return "npm run build:packages";
-    case "bun":
-      return "bun run build:packages";
-    default:
-      return null;
-  }
-}
-function hasPackageScript(worktreePath, scriptName) {
-  try {
-    const packageJsonPath = path23.join(worktreePath, "package.json");
-    if (!fs22.existsSync(packageJsonPath)) {
-      return false;
-    }
-    const packageJson2 = JSON.parse(fs22.readFileSync(packageJsonPath, "utf-8"));
-    return typeof packageJson2.scripts?.[scriptName] === "string";
-  } catch {
-    return false;
-  }
-}
 async function handleWorktreeCreate(request2) {
   const {
     workspaceSlug,
@@ -11805,19 +11901,19 @@ async function handleWorktreeCreate(request2) {
   }
   try {
     const projectPath = getProjectPath(workspaceSlug, projectSlug);
-    const bareRepoPath = path23.join(projectPath, ".bare");
+    const bareRepoPath = path24.join(projectPath, ".bare");
     const gitEnv = projectId ? { ...process.env, EPISODA_PROJECT_ID: projectId } : process.env;
-    if (!fs22.existsSync(bareRepoPath)) {
+    if (!fs23.existsSync(bareRepoPath)) {
       console.log(`[Worktree] K1273: Project not found, cloning lazily...`);
       console.log(`[Worktree]   Repo URL: ${repoUrl.replace(/\/\/[^@]*@/, "//***@")}`);
-      const episodaDir = path23.join(projectPath, ".episoda");
-      fs22.mkdirSync(episodaDir, { recursive: true });
+      const episodaDir = path24.join(projectPath, ".episoda");
+      fs23.mkdirSync(episodaDir, { recursive: true });
       try {
         console.log(`[Worktree] K1273: Starting git clone...`);
         await execAsync2(`git clone --bare "${repoUrl}" "${bareRepoPath}"`, { env: gitEnv });
         console.log(`[Worktree] K1273: Clone successful`);
         await execAsync2(`git -C "${bareRepoPath}" config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"`, { env: gitEnv });
-        const configPath = path23.join(episodaDir, "config.json");
+        const configPath = path24.join(episodaDir, "config.json");
         const config = {
           projectId,
           workspaceSlug,
@@ -11826,7 +11922,7 @@ async function handleWorktreeCreate(request2) {
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),
           worktrees: []
         };
-        fs22.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+        fs23.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
         console.log(`[Worktree] K1273: Project initialized at ${projectPath}`);
       } catch (cloneError) {
         console.error(`[Worktree] K1273: Git clone failed: ${cloneError.message}`);
@@ -11861,16 +11957,16 @@ async function handleWorktreeCreate(request2) {
     let finalError;
     if (envVars && Object.keys(envVars).length > 0) {
       const envContent = Object.entries(envVars).map(([key, value]) => `${key}=${value}`).join("\n");
-      const envPath = path23.join(worktreePath, ".env");
-      fs22.writeFileSync(envPath, envContent + "\n", "utf-8");
+      const envPath = path24.join(worktreePath, ".env");
+      fs23.writeFileSync(envPath, envContent + "\n", "utf-8");
       console.log(`[Worktree] EP1143: Wrote ${Object.keys(envVars).length} env vars to .env`);
     }
     const isCloud = process.env.EPISODA_MODE === "cloud";
     let effectiveSetupScript = setupScript || await autoDetectSetupScript(worktreePath);
     const detection = detectPackageManager(worktreePath);
-    const buildCmd = getBuildPackagesCommand(detection.packageManager?.name);
     const hasBuildPackages = hasPackageScript(worktreePath, "build:packages");
-    if (buildCmd && hasBuildPackages && !effectiveSetupScript?.includes("build:packages")) {
+    const buildCmd = getBuildPackagesCommand(detection.packageManager?.name, hasBuildPackages);
+    if (buildCmd && !effectiveSetupScript?.includes("build:packages")) {
       effectiveSetupScript = effectiveSetupScript ? `${effectiveSetupScript}
 ${buildCmd}` : buildCmd;
       console.log(`[Worktree] EP1386: Added build:packages bootstrap for ${isCloud ? "cloud" : "local"} setup`);
@@ -12003,12 +12099,12 @@ async function handleProjectEject(request2) {
   console.log(`[Worktree] EP1144: Ejecting project ${projectSlug} from workspace ${workspaceSlug}`);
   try {
     const projectPath = getProjectPath(workspaceSlug, projectSlug);
-    const bareRepoPath = path23.join(projectPath, ".bare");
-    if (!fs22.existsSync(projectPath)) {
+    const bareRepoPath = path24.join(projectPath, ".bare");
+    if (!fs23.existsSync(projectPath)) {
       console.log(`[Worktree] EP1144: Project path not found, nothing to eject: ${projectPath}`);
       return { success: true };
     }
-    if (!fs22.existsSync(bareRepoPath)) {
+    if (!fs23.existsSync(bareRepoPath)) {
       console.log(`[Worktree] EP1144: Bare repo not found, nothing to eject: ${bareRepoPath}`);
       return { success: true };
     }
@@ -12023,12 +12119,12 @@ async function handleProjectEject(request2) {
         };
       }
     }
-    const artifactsPath = path23.join(projectPath, "artifacts");
-    if (fs22.existsSync(artifactsPath)) {
+    const artifactsPath = path24.join(projectPath, "artifacts");
+    if (fs23.existsSync(artifactsPath)) {
       await persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug);
     }
     console.log(`[Worktree] EP1144: Removing project directory: ${projectPath}`);
-    await fs22.promises.rm(projectPath, { recursive: true, force: true });
+    await fs23.promises.rm(projectPath, { recursive: true, force: true });
     console.log(`[Worktree] EP1144: Successfully ejected project ${projectSlug}`);
     return { success: true };
   } catch (error) {
@@ -12042,7 +12138,7 @@ async function handleProjectEject(request2) {
 async function persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug) {
   const MAX_ARTIFACT_SIZE = 10 * 1024 * 1024;
   try {
-    const files = await fs22.promises.readdir(artifactsPath);
+    const files = await fs23.promises.readdir(artifactsPath);
     if (files.length === 0) {
       return;
     }
@@ -12056,8 +12152,8 @@ async function persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug
     }
     const artifacts = [];
     for (const fileName of files) {
-      const filePath = path23.join(artifactsPath, fileName);
-      const stat = await fs22.promises.stat(filePath);
+      const filePath = path24.join(artifactsPath, fileName);
+      const stat = await fs23.promises.stat(filePath);
       if (stat.isDirectory()) {
         continue;
       }
@@ -12066,9 +12162,9 @@ async function persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug
         continue;
       }
       try {
-        const content = await fs22.promises.readFile(filePath);
+        const content = await fs23.promises.readFile(filePath);
         const base64Content = content.toString("base64");
-        const ext = path23.extname(fileName).toLowerCase();
+        const ext = path24.extname(fileName).toLowerCase();
         const mimeTypes = {
           ".json": "application/json",
           ".txt": "text/plain",
@@ -12124,8 +12220,8 @@ async function persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug
 }
 
 // src/daemon/handlers/project-handlers.ts
-var path24 = __toESM(require("path"));
-var fs23 = __toESM(require("fs"));
+var path25 = __toESM(require("path"));
+var fs24 = __toESM(require("fs"));
 function validateSlug(slug, fieldName) {
   if (!slug || typeof slug !== "string") {
     return `${fieldName} is required`;
@@ -12165,14 +12261,14 @@ async function handleProjectSetup(params) {
   console.log(`[ProjectSetup] EP1199: Setting up project ${workspaceSlug}/${projectSlug}`);
   try {
     const projectPath = getProjectPath(workspaceSlug, projectSlug);
-    const artifactsPath = path24.join(projectPath, "artifacts");
-    const configDir = path24.join(projectPath, ".episoda");
-    const configPath = path24.join(configDir, "config.json");
-    await fs23.promises.mkdir(artifactsPath, { recursive: true });
-    await fs23.promises.mkdir(configDir, { recursive: true });
+    const artifactsPath = path25.join(projectPath, "artifacts");
+    const configDir = path25.join(projectPath, ".episoda");
+    const configPath = path25.join(configDir, "config.json");
+    await fs24.promises.mkdir(artifactsPath, { recursive: true });
+    await fs24.promises.mkdir(configDir, { recursive: true });
     let existingConfig = {};
     try {
-      const existing = await fs23.promises.readFile(configPath, "utf-8");
+      const existing = await fs24.promises.readFile(configPath, "utf-8");
       existingConfig = JSON.parse(existing);
     } catch {
     }
@@ -12185,7 +12281,7 @@ async function handleProjectSetup(params) {
       // Only set created_at if not already present
       created_at: existingConfig.created_at || (/* @__PURE__ */ new Date()).toISOString()
     };
-    await fs23.promises.writeFile(configPath, JSON.stringify(config, null, 2));
+    await fs24.promises.writeFile(configPath, JSON.stringify(config, null, 2));
     console.log(`[ProjectSetup] EP1199: Project setup complete at ${projectPath}`);
     return {
       success: true,
@@ -12205,8 +12301,8 @@ async function handleProjectSetup(params) {
 // src/utils/dev-server.ts
 var import_child_process16 = require("child_process");
 var import_core14 = __toESM(require_dist());
-var fs24 = __toESM(require("fs"));
-var path25 = __toESM(require("path"));
+var fs25 = __toESM(require("fs"));
+var path26 = __toESM(require("path"));
 var MAX_RESTART_ATTEMPTS = 5;
 var INITIAL_RESTART_DELAY_MS = 2e3;
 var MAX_RESTART_DELAY_MS = 3e4;
@@ -12214,26 +12310,26 @@ var MAX_LOG_SIZE_BYTES2 = 5 * 1024 * 1024;
 var NODE_MEMORY_LIMIT_MB = 2048;
 var activeServers = /* @__PURE__ */ new Map();
 function getLogsDir() {
-  const logsDir = path25.join((0, import_core14.getConfigDir)(), "logs");
-  if (!fs24.existsSync(logsDir)) {
-    fs24.mkdirSync(logsDir, { recursive: true });
+  const logsDir = path26.join((0, import_core14.getConfigDir)(), "logs");
+  if (!fs25.existsSync(logsDir)) {
+    fs25.mkdirSync(logsDir, { recursive: true });
   }
   return logsDir;
 }
 function getLogFilePath(moduleUid) {
-  return path25.join(getLogsDir(), `dev-${moduleUid}.log`);
+  return path26.join(getLogsDir(), `dev-${moduleUid}.log`);
 }
 function rotateLogIfNeeded(logPath) {
   try {
-    if (fs24.existsSync(logPath)) {
-      const stats = fs24.statSync(logPath);
+    if (fs25.existsSync(logPath)) {
+      const stats = fs25.statSync(logPath);
       if (stats.size > MAX_LOG_SIZE_BYTES2) {
         const backupPath = `${logPath}.1`;
-        if (fs24.existsSync(backupPath)) {
-          fs24.unlinkSync(backupPath);
+        if (fs25.existsSync(backupPath)) {
+          fs25.unlinkSync(backupPath);
         }
-        fs24.renameSync(logPath, backupPath);
-        console.log(`[DevServer] EP932: Rotated log file for ${path25.basename(logPath)}`);
+        fs25.renameSync(logPath, backupPath);
+        console.log(`[DevServer] EP932: Rotated log file for ${path26.basename(logPath)}`);
       }
     }
   } catch (error) {
@@ -12246,7 +12342,7 @@ function writeToLog(logPath, line, isError = false) {
     const prefix = isError ? "ERR" : "OUT";
     const logLine = `[${timestamp}] [${prefix}] ${line}
 `;
-    fs24.appendFileSync(logPath, logLine);
+    fs25.appendFileSync(logPath, logLine);
   } catch {
   }
 }
@@ -12425,8 +12521,8 @@ async function startDevServer(projectPath, port = 3e3, moduleUid = "default", op
       });
       injectedEnvVars = result.envVars;
       console.log(`[DevServer] EP998: Loaded ${Object.keys(injectedEnvVars).length} env vars (from ${result.fromCache ? "cache" : "server"})`);
-      const envFilePath = path25.join(projectPath, ".env");
-      if (!fs24.existsSync(envFilePath) && Object.keys(injectedEnvVars).length > 0) {
+      const envFilePath = path26.join(projectPath, ".env");
+      if (!fs25.existsSync(envFilePath) && Object.keys(injectedEnvVars).length > 0) {
         console.log(`[DevServer] EP1004: .env file missing, writing ${Object.keys(injectedEnvVars).length} vars to ${envFilePath}`);
         writeEnvFile(projectPath, injectedEnvVars);
       }
@@ -12767,10 +12863,11 @@ var IPCRouter = class {
 };
 
 // src/daemon/update-manager.ts
-var fs25 = __toESM(require("fs"));
-var path26 = __toESM(require("path"));
+var fs26 = __toESM(require("fs"));
+var path27 = __toESM(require("path"));
 var import_child_process18 = require("child_process");
 var import_core17 = __toESM(require_dist());
+var semver2 = __toESM(require("semver"));
 
 // src/utils/update-checker.ts
 var import_child_process17 = require("child_process");
@@ -12781,6 +12878,7 @@ var import_core16 = __toESM(require_dist());
 
 // src/utils/update-checker.ts
 var PACKAGE_NAME = "@episoda/cli";
+var LEGACY_PACKAGE_NAME = "episoda";
 var NPM_REGISTRY = "https://registry.npmjs.org";
 function isFileLinkedInstall() {
   try {
@@ -12853,6 +12951,39 @@ function getInstalledVersion() {
     return null;
   }
 }
+function getLegacyInstalledVersion() {
+  try {
+    const output = (0, import_child_process17.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/daemon/update-manager.ts
 var UpdateManager = class _UpdateManager {
@@ -12875,6 +13006,19 @@ var UpdateManager = class _UpdateManager {
     // 4 hours
     this.MAX_UPDATE_ATTEMPTS = 3;
   }
+  /**
+   * Prefer installed CLI version when it's newer than embedded bundle metadata.
+   * This avoids update churn when daemon bundle version lags package install version.
+   */
+  getEffectiveCurrentVersion() {
+    return resolveEffectiveCliVersion(this.currentVersion);
+  }
+  isTargetVersionNewer(targetVersion, currentVersion) {
+    if (semver2.valid(targetVersion) && semver2.valid(currentVersion)) {
+      return semver2.gt(targetVersion, currentVersion);
+    }
+    return targetVersion !== currentVersion;
+  }
   /**
    * Start periodic update checks (every 4 hours).
    * Does nothing if EPISODA_CLI_PIN_VERSION is set.
@@ -12919,7 +13063,8 @@ var UpdateManager = class _UpdateManager {
       return;
     }
     try {
-      const result = await checkForUpdates(this.currentVersion);
+      const effectiveCurrentVersion = this.getEffectiveCurrentVersion();
+      const result = await checkForUpdates(effectiveCurrentVersion);
       if (result.updateAvailable) {
         await this.applyUpdateIfIdle(result.latestVersion, "startup");
       }
@@ -12941,8 +13086,9 @@ var UpdateManager = class _UpdateManager {
   }
   async applyUpdateIfIdle(targetVersion, source) {
     if (this.updateInProgress) return;
-    if (targetVersion === this.currentVersion) {
-      console.log(`[Daemon] EP1324: Already running version ${targetVersion}, skipping update`);
+    const effectiveCurrentVersion = this.getEffectiveCurrentVersion();
+    if (!this.isTargetVersionNewer(targetVersion, effectiveCurrentVersion)) {
+      console.log(`[Daemon] EP1390: Skipping update target=${targetVersion}, current=${effectiveCurrentVersion} (source=${source})`);
       return;
     }
     if (this.lastFailedUpdateVersion === targetVersion && this.updateFailedAttempts >= _UpdateManager.MAX_UPDATE_ATTEMPTS) {
@@ -12952,12 +13098,12 @@ var UpdateManager = class _UpdateManager {
     const activeAgentSessions = this.getActiveAgentSessionCount();
     if (activeAgentSessions > 0) {
       this.pendingUpdateVersion = targetVersion;
-      console.log(`[Daemon] EP1319: Update available (${this.currentVersion} \u2192 ${targetVersion}) but ${activeAgentSessions} active agent session(s) \u2014 deferring`);
+      console.log(`[Daemon] EP1319: Update available (${effectiveCurrentVersion} \u2192 ${targetVersion}) but ${activeAgentSessions} active agent session(s) \u2014 deferring`);
       return;
     }
-    const currentInstalled = getInstalledVersion();
-    if (currentInstalled && currentInstalled === targetVersion) {
-      console.log(`[Daemon] EP1343: Already installed version ${targetVersion} (embedded: ${this.currentVersion}), skipping update`);
+    const latestEffectiveCurrent = this.getEffectiveCurrentVersion();
+    if (!this.isTargetVersionNewer(targetVersion, latestEffectiveCurrent)) {
+      console.log(`[Daemon] EP1390: Update no longer needed target=${targetVersion}, current=${latestEffectiveCurrent}`);
       return;
     }
     this.updateInProgress = true;
@@ -12976,16 +13122,24 @@ var UpdateManager = class _UpdateManager {
       console.log(`[Daemon] EP1324: Update to ${targetVersion} installed, restarting daemon...`);
       await this.host.shutdown();
       const configDir = (0, import_core17.getConfigDir)();
-      const logPath = path26.join(configDir, "daemon.log");
-      const logFd = fs25.openSync(logPath, "a");
+      const logPath = path27.join(configDir, "daemon.log");
+      const logFd = fs26.openSync(logPath, "a");
       const child = (0, import_child_process18.spawn)("node", [this.daemonEntryFile], {
         detached: true,
         stdio: ["ignore", logFd, logFd],
         env: { ...process.env, EPISODA_DAEMON_MODE: "1" }
       });
+      if (!child.pid) {
+        try {
+          fs26.closeSync(logFd);
+        } catch {
+        }
+        this.recordUpdateFailure(targetVersion, "Failed to spawn replacement daemon (missing pid)");
+        return;
+      }
       child.unref();
       const pidPath = getPidFilePath();
-      fs25.writeFileSync(pidPath, child.pid.toString(), "utf-8");
+      fs26.writeFileSync(pidPath, child.pid.toString(), "utf-8");
       console.log(`[Daemon] EP1324: New daemon spawned (PID: ${child.pid}), exiting old process`);
       process.exit(0);
     } catch (error) {
@@ -13019,7 +13173,8 @@ var UpdateManager = class _UpdateManager {
       return;
     }
     try {
-      const result = await checkForUpdates(this.currentVersion);
+      const effectiveCurrentVersion = this.getEffectiveCurrentVersion();
+      const result = await checkForUpdates(effectiveCurrentVersion);
       if (!result.updateAvailable) {
         if (this.pendingUpdateVersion) {
           console.log(`[Daemon] EP1319: Pending update to ${this.pendingUpdateVersion} is no longer needed (already current)`);
@@ -13035,8 +13190,8 @@ var UpdateManager = class _UpdateManager {
 };
 
 // src/daemon/health-orchestrator.ts
-var fs26 = __toESM(require("fs"));
-var path27 = __toESM(require("path"));
+var fs27 = __toESM(require("fs"));
+var path28 = __toESM(require("path"));
 var import_core18 = __toESM(require_dist());
 var HealthOrchestrator = class _HealthOrchestrator {
   constructor(host) {
@@ -13278,26 +13433,26 @@ var HealthOrchestrator = class _HealthOrchestrator {
   checkAndRotateLog() {
     try {
       const configDir = (0, import_core18.getConfigDir)();
-      const logPath = path27.join(configDir, "daemon.log");
-      if (!fs26.existsSync(logPath)) return;
-      const stats = fs26.statSync(logPath);
+      const logPath = path28.join(configDir, "daemon.log");
+      if (!fs27.existsSync(logPath)) return;
+      const stats = fs27.statSync(logPath);
       if (stats.size < _HealthOrchestrator.MAX_LOG_SIZE_BYTES) return;
       console.log(`[Daemon] EP1351: daemon.log is ${Math.round(stats.size / 1024 / 1024)}MB, rotating...`);
       for (let i = _HealthOrchestrator.MAX_LOG_FILES - 1; i >= 1; i--) {
         const src = `${logPath}.${i}`;
         const dst = `${logPath}.${i + 1}`;
-        if (fs26.existsSync(src)) {
+        if (fs27.existsSync(src)) {
           try {
-            fs26.renameSync(src, dst);
+            fs27.renameSync(src, dst);
           } catch {
           }
         }
       }
       try {
-        fs26.copyFileSync(logPath, `${logPath}.1`);
+        fs27.copyFileSync(logPath, `${logPath}.1`);
       } catch {
       }
-      fs26.truncateSync(logPath, 0);
+      fs27.truncateSync(logPath, 0);
       console.log("[Daemon] EP1351: Log rotated successfully");
     } catch (error) {
       console.warn("[Daemon] EP1351: Log rotation failed:", error instanceof Error ? error.message : error);
@@ -13679,9 +13834,55 @@ var ConnectionManager = class {
   }
 };
 
+// src/daemon/ws-endpoint.ts
+var DEFAULT_API_URL = "https://episoda.dev";
+var CANONICAL_PROD_WS_HOST = "ws.episoda.dev";
+var PRODUCTION_API_HOSTS = /* @__PURE__ */ new Set([
+  "episoda.dev",
+  "www.episoda.dev",
+  "api.episoda.dev"
+]);
+function parseApiUrl(rawUrl) {
+  try {
+    return new URL(rawUrl);
+  } catch {
+    return new URL(DEFAULT_API_URL);
+  }
+}
+function resolveDaemonWsEndpoint(config, env = process.env) {
+  if (config.ws_url) {
+    return {
+      wsUrl: config.ws_url,
+      source: "config.ws_url",
+      serverUrl: config.project_settings?.local_server_url || config.api_url || env.EPISODA_API_URL || DEFAULT_API_URL
+    };
+  }
+  if (env.EPISODA_WS_URL) {
+    return {
+      wsUrl: env.EPISODA_WS_URL,
+      source: "env.EPISODA_WS_URL",
+      serverUrl: config.project_settings?.local_server_url || config.api_url || env.EPISODA_API_URL || DEFAULT_API_URL
+    };
+  }
+  const rawServerUrl = config.project_settings?.local_server_url || config.api_url || env.EPISODA_API_URL || DEFAULT_API_URL;
+  const serverUrl = parseApiUrl(rawServerUrl);
+  const wsProtocol = serverUrl.protocol === "https:" ? "wss:" : "ws:";
+  const useCanonicalProdHost = PRODUCTION_API_HOSTS.has(serverUrl.hostname);
+  const wsHostname = useCanonicalProdHost ? CANONICAL_PROD_WS_HOST : serverUrl.hostname;
+  const explicitPort = env.EPISODA_WS_PORT?.trim();
+  const inheritedServerPort = !useCanonicalProdHost ? serverUrl.port : "";
+  const wsPort = explicitPort || inheritedServerPort;
+  const wsUrl = wsPort ? `${wsProtocol}//${wsHostname}:${wsPort}` : `${wsProtocol}//${wsHostname}`;
+  return {
+    wsUrl,
+    source: "derived",
+    serverUrl: serverUrl.toString()
+  };
+}
+
 // src/daemon/project-message-router.ts
 var import_core19 = __toESM(require_dist());
-var path28 = __toESM(require("path"));
+var path29 = __toESM(require("path"));
 var ProjectMessageRouter = class {
   constructor(host) {
     this.host = host;
@@ -13698,7 +13899,7 @@ var ProjectMessageRouter = class {
         client.updateActivity();
         try {
           const gitCmd = message.command;
-          const bareRepoPath = path28.join(projectPath, ".bare");
+          const bareRepoPath = path29.join(projectPath, ".bare");
           const cwd = gitCmd.worktreePath || bareRepoPath;
           if (gitCmd.worktreePath) {
             console.log(`[Daemon] Routing command to worktree: ${gitCmd.worktreePath}`);
@@ -14038,32 +14239,32 @@ async function fetchEnvVars2(projectId) {
 }
 
 // src/daemon/project-git-config.ts
-var fs27 = __toESM(require("fs"));
-var path29 = __toESM(require("path"));
+var fs28 = __toESM(require("fs"));
+var path30 = __toESM(require("path"));
 var import_core21 = __toESM(require_dist());
 function getGitDirs(projectPath) {
-  const bareDir = path29.join(projectPath, ".bare");
-  const gitPath = path29.join(projectPath, ".git");
-  if (fs27.existsSync(bareDir) && fs27.statSync(bareDir).isDirectory()) {
+  const bareDir = path30.join(projectPath, ".bare");
+  const gitPath = path30.join(projectPath, ".git");
+  if (fs28.existsSync(bareDir) && fs28.statSync(bareDir).isDirectory()) {
     return { gitDir: bareDir, workDir: projectPath };
   }
-  if (fs27.existsSync(gitPath) && fs27.statSync(gitPath).isDirectory()) {
+  if (fs28.existsSync(gitPath) && fs28.statSync(gitPath).isDirectory()) {
     return { gitDir: null, workDir: projectPath };
   }
-  if (fs27.existsSync(gitPath) && fs27.statSync(gitPath).isFile()) {
+  if (fs28.existsSync(gitPath) && fs28.statSync(gitPath).isFile()) {
     return { gitDir: null, workDir: projectPath };
   }
-  const entries = fs27.readdirSync(projectPath, { withFileTypes: true });
+  const entries = fs28.readdirSync(projectPath, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory() && entry.name.startsWith("EP")) {
-      const worktreePath = path29.join(projectPath, entry.name);
-      const worktreeGit = path29.join(worktreePath, ".git");
-      if (fs27.existsSync(worktreeGit)) {
+      const worktreePath = path30.join(projectPath, entry.name);
+      const worktreeGit = path30.join(worktreePath, ".git");
+      if (fs28.existsSync(worktreeGit)) {
         return { gitDir: null, workDir: worktreePath };
       }
     }
   }
-  if (fs27.existsSync(bareDir)) {
+  if (fs28.existsSync(bareDir)) {
     return { gitDir: bareDir, workDir: projectPath };
   }
   return { gitDir: null, workDir: projectPath };
@@ -14108,24 +14309,24 @@ async function configureGitUser(projectPath, userId, workspaceId, machineId, pro
 async function installGitHooks(projectPath) {
   const hooks = ["post-checkout", "pre-commit", "post-commit"];
   let hooksDir;
-  const bareHooksDir = path29.join(projectPath, ".bare", "hooks");
-  const gitHooksDir = path29.join(projectPath, ".git", "hooks");
-  if (fs27.existsSync(bareHooksDir)) {
+  const bareHooksDir = path30.join(projectPath, ".bare", "hooks");
+  const gitHooksDir = path30.join(projectPath, ".git", "hooks");
+  if (fs28.existsSync(bareHooksDir)) {
     hooksDir = bareHooksDir;
-  } else if (fs27.existsSync(gitHooksDir) && fs27.statSync(path29.join(projectPath, ".git")).isDirectory()) {
+  } else if (fs28.existsSync(gitHooksDir) && fs28.statSync(path30.join(projectPath, ".git")).isDirectory()) {
     hooksDir = gitHooksDir;
   } else {
-    const parentBareHooks = path29.join(projectPath, "..", ".bare", "hooks");
-    if (fs27.existsSync(parentBareHooks)) {
+    const parentBareHooks = path30.join(projectPath, "..", ".bare", "hooks");
+    if (fs28.existsSync(parentBareHooks)) {
       hooksDir = parentBareHooks;
     } else {
       console.warn(`[Daemon] Hooks directory not found for: ${projectPath}`);
       return;
     }
   }
-  if (!fs27.existsSync(hooksDir)) {
+  if (!fs28.existsSync(hooksDir)) {
     try {
-      fs27.mkdirSync(hooksDir, { recursive: true });
+      fs28.mkdirSync(hooksDir, { recursive: true });
     } catch {
       console.warn(`[Daemon] Hooks directory not found and could not create: ${hooksDir}`);
       return;
@@ -14133,20 +14334,20 @@ async function installGitHooks(projectPath) {
   }
   for (const hookName of hooks) {
     try {
-      const hookPath = path29.join(hooksDir, hookName);
-      const bundledHookPath = path29.join(__dirname, "..", "hooks", hookName);
-      if (!fs27.existsSync(bundledHookPath)) {
+      const hookPath = path30.join(hooksDir, hookName);
+      const bundledHookPath = path30.join(__dirname, "..", "hooks", hookName);
+      if (!fs28.existsSync(bundledHookPath)) {
         console.warn(`[Daemon] Bundled hook not found: ${bundledHookPath}`);
         continue;
       }
-      const hookContent = fs27.readFileSync(bundledHookPath, "utf-8");
-      if (fs27.existsSync(hookPath)) {
-        const existingContent = fs27.readFileSync(hookPath, "utf-8");
+      const hookContent = fs28.readFileSync(bundledHookPath, "utf-8");
+      if (fs28.existsSync(hookPath)) {
+        const existingContent = fs28.readFileSync(hookPath, "utf-8");
         if (existingContent === hookContent) {
           continue;
         }
       }
-      fs27.writeFileSync(hookPath, hookContent, { mode: 493 });
+      fs28.writeFileSync(hookPath, hookContent, { mode: 493 });
       console.log(`[Daemon] Installed git hook: ${hookName}`);
     } catch (error) {
       console.warn(`[Daemon] Failed to install ${hookName} hook:`, error instanceof Error ? error.message : error);
@@ -14178,21 +14379,6 @@ async function cacheMachineUuid(machineUuid, machineId) {
 
 // src/daemon/daemon-process.ts
 var packageJson = require_package();
-function getBuildPackagesCommand2(installCmd) {
-  const runner = installCmd?.command?.[0];
-  switch (runner) {
-    case "pnpm":
-      return "pnpm run build:packages";
-    case "yarn":
-      return "yarn build:packages";
-    case "npm":
-      return "npm run build:packages";
-    case "bun":
-      return "bun run build:packages";
-    default:
-      return null;
-  }
-}
 var Daemon = class _Daemon {
   constructor() {
     this.machineId = "";
@@ -14217,10 +14403,11 @@ var Daemon = class _Daemon {
     // 2 minutes
     // EP1360: Per-session monotonic event seq for daemon→platform stream gap detection.
     this.agentEventSeq = /* @__PURE__ */ new Map();
+    this.cliRuntimeVersion = resolveEffectiveCliVersion(packageJson.version);
     this.ipcServer = new IPCServer();
     this.connectionManager = new ConnectionManager();
     this.ipcRouter = new IPCRouter(this, this.ipcServer);
-    this.updateManager = new UpdateManager(this, packageJson.version, __filename);
+    this.updateManager = new UpdateManager(this, this.cliRuntimeVersion, __filename);
     this.healthOrchestrator = new HealthOrchestrator(this);
     this.daemonCore = new DaemonCore(this);
     this.projectMessageRouter = new ProjectMessageRouter({
@@ -14303,9 +14490,9 @@ var Daemon = class _Daemon {
       this.healthServer = http2.createServer((req, res) => {
         if (req.url === "/health" || req.url === "/") {
           const isConnected = this.connectionManager.liveConnectionCount() > 0;
-          const projects = Array.from(this.connectionManager.entries()).map(([path30, conn]) => ({
-            path: path30,
-            connected: this.connectionManager.hasLiveConnection(path30)
+          const projects = Array.from(this.connectionManager.entries()).map(([path31, conn]) => ({
+            path: path31,
+            connected: this.connectionManager.hasLiveConnection(path31)
           }));
           const status = {
             status: isConnected ? "healthy" : "degraded",
@@ -14378,8 +14565,8 @@ var Daemon = class _Daemon {
     await this.shutdown();
     try {
       const pidPath = getPidFilePath();
-      if (fs28.existsSync(pidPath)) {
-        fs28.unlinkSync(pidPath);
+      if (fs29.existsSync(pidPath)) {
+        fs29.unlinkSync(pidPath);
         console.log("[Daemon] PID file cleaned up (watchdog)");
       }
     } catch (error) {
@@ -14485,23 +14672,15 @@ var Daemon = class _Daemon {
     if (!config || !config.access_token) {
       throw new Error("No access token found. Please run: episoda auth");
     }
-    let serverUrl = config.api_url || process.env.EPISODA_API_URL || "https://episoda.dev";
-    if (config.project_settings?.local_server_url) {
-      serverUrl = config.project_settings.local_server_url;
-      console.log(`[Daemon] Using cached server URL: ${serverUrl}`);
-    }
-    let wsUrl;
-    if (config.ws_url) {
-      wsUrl = config.ws_url;
-      console.log(`[Daemon] Using configured ws_url: ${wsUrl}`);
-    } else {
-      const serverUrlObj = new URL(serverUrl);
-      const wsProtocol = serverUrlObj.protocol === "https:" ? "wss:" : "ws:";
-      const wsHostname = serverUrlObj.hostname === "episoda.dev" ? "ws.episoda.dev" : serverUrlObj.hostname;
-      const wsPort = process.env.EPISODA_WS_PORT;
-      wsUrl = wsPort ? `${wsProtocol}//${wsHostname}:${wsPort}` : `${wsProtocol}//${wsHostname}`;
+    const wsEndpoint = resolveDaemonWsEndpoint(config);
+    if (wsEndpoint.source === "config.ws_url") {
+      console.log(`[Daemon] Using configured ws_url: ${wsEndpoint.wsUrl}`);
+    } else if (wsEndpoint.source === "env.EPISODA_WS_URL") {
+      console.log(`[Daemon] Using EPISODA_WS_URL override: ${wsEndpoint.wsUrl}`);
+    } else if (config.project_settings?.local_server_url) {
+      console.log(`[Daemon] Using cached server URL: ${wsEndpoint.serverUrl}`);
     }
-    console.log(`[Daemon] Connecting to ${wsUrl} for project ${projectId}...`);
+    console.log(`[Daemon] Connecting to ${wsEndpoint.wsUrl} for project ${projectId} (source: ${wsEndpoint.source})...`);
     const client = new import_core22.EpisodaClient();
     const gitExecutor = new import_core22.GitExecutor();
     const connection = {
@@ -14653,7 +14832,7 @@ var Daemon = class _Daemon {
                 const resolvedProjectPath = getProjectPath(cmd.workspaceSlug, cmd.projectSlug);
                 if (resolvedProjectPath !== projectPath) {
                   try {
-                    await fs28.promises.access(resolvedProjectPath);
+                    await fs29.promises.access(resolvedProjectPath);
                     agentWorkingDir = resolvedProjectPath;
                     console.log(`[Daemon] EP1230: Agent for ${cmd.moduleUid || "project"} in resolved project path: ${agentWorkingDir}`);
                   } catch {
@@ -14985,8 +15164,8 @@ var Daemon = class _Daemon {
       let daemonPid;
       try {
         const pidPath = getPidFilePath();
-        if (fs28.existsSync(pidPath)) {
-          const pidStr = fs28.readFileSync(pidPath, "utf-8").trim();
+        if (fs29.existsSync(pidPath)) {
+          const pidStr = fs29.readFileSync(pidPath, "utf-8").trim();
           daemonPid = parseInt(pidStr, 10);
         }
       } catch (pidError) {
@@ -14995,12 +15174,15 @@ var Daemon = class _Daemon {
       const modeConfig = getDaemonModeConfig();
       const environment = modeConfig.mode;
       const containerId = process.env.EPISODA_CONTAINER_ID;
-      await client.connect(wsUrl, config.access_token, this.machineId, {
+      const capabilities = ["worktree_create_v1"];
+      await client.connect(wsEndpoint.wsUrl, config.access_token, this.machineId, {
         hostname: os12.hostname(),
         osPlatform: os12.platform(),
         osArch: os12.arch(),
         daemonPid,
-        cliVersion: packageJson.version,
+        cliVersion: this.cliRuntimeVersion,
+        cliPackageName: packageJson.name,
+        capabilities,
         environment,
         containerId
       });
@@ -15453,23 +15635,25 @@ var Daemon = class _Daemon {
     } else {
       console.log(`[Daemon] EP1002: No package manager detected, skipping dependency installation`);
     }
-    if (process.env.EPISODA_MODE === "cloud" && installSucceeded) {
-      const buildCmd = getBuildPackagesCommand2(installCmd);
-      if (buildCmd) {
-        console.log(`[Daemon] EP1262: Bootstrapping packages for cloud dev (${buildCmd})`);
-        try {
-          const { execSync: execSync10 } = await import("child_process");
-          execSync10(buildCmd, {
-            cwd: worktreePath,
-            stdio: "inherit",
-            timeout: 10 * 60 * 1e3,
-            env: { ...process.env, CI: "true" }
-          });
-          console.log("[Daemon] EP1262: Package bootstrap completed");
-        } catch (buildError) {
-          const errorMsg = buildError instanceof Error ? buildError.message : String(buildError);
-          console.warn(`[Daemon] EP1262: Package bootstrap failed (non-fatal): ${errorMsg}`);
-        }
+    const hasBuildPackages = hasPackageScript(worktreePath, "build:packages");
+    const buildCmd = getBuildPackagesCommand(installCmd?.command?.[0], hasBuildPackages);
+    if (buildCmd && shouldRunBuildPackagesBootstrap(installSucceeded, buildCmd)) {
+      const bootstrapCmd = buildCmd;
+      console.log(`[Daemon] EP1386: Bootstrapping packages after dependency install (${bootstrapCmd})`);
+      try {
+        const { execSync: execSync10 } = await import("child_process");
+        execSync10(bootstrapCmd, {
+          cwd: worktreePath,
+          stdio: "inherit",
+          timeout: 10 * 60 * 1e3,
+          env: { ...process.env, CI: "true" }
+        });
+        console.log("[Daemon] EP1386: Package bootstrap completed");
+      } catch (buildError) {
+        const errorMsg = buildError instanceof Error ? buildError.message : String(buildError);
+        await worktreeManager.updateWorktreeStatus(moduleUid, "error", errorMsg);
+        await this.updateModuleWorktreeStatus(moduleUid, "error", worktreePath, errorMsg);
+        throw new Error(`Package bootstrap failed: ${errorMsg}`);
       }
     }
     if (setupScript) {
@@ -15551,8 +15735,8 @@ var Daemon = class _Daemon {
     await this.shutdown();
     try {
       const pidPath = getPidFilePath();
-      if (fs28.existsSync(pidPath)) {
-        fs28.unlinkSync(pidPath);
+      if (fs29.existsSync(pidPath)) {
+        fs29.unlinkSync(pidPath);
         console.log("[Daemon] PID file cleaned up");
       }
     } catch (error) {