episoda 0.2.40 → 0.2.42

package/dist/index.js

@@ -1552,15 +1552,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 fs14 = 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 fs14.access(rebaseMergePath);
               inRebase = true;
             } catch {
               try {
-                await fs15.access(rebaseApplyPath);
+                await fs14.access(rebaseApplyPath);
                 inRebase = true;
               } catch {
                 inRebase = false;
@@ -1614,9 +1614,9 @@ var require_git_executor = __commonJS({
               error: validation.error || "UNKNOWN_ERROR"
             };
           }
-          const fs15 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs14 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs15.access(command.path);
+            await fs14.access(command.path);
             return {
               success: false,
               error: "WORKTREE_EXISTS",
@@ -1670,9 +1670,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 fs14 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs15.access(command.path);
+            await fs14.access(command.path);
           } catch {
             return {
               success: false,
@@ -1707,7 +1707,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 fs14.rm(command.path, { recursive: true, force: true });
             } catch {
             }
             return {
@@ -1841,10 +1841,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 path17 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs14 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path16 = await Promise.resolve().then(() => __importStar(require("path")));
           try {
-            await fs15.access(command.path);
+            await fs14.access(command.path);
             return {
               success: false,
               error: "BRANCH_ALREADY_EXISTS",
@@ -1853,9 +1853,9 @@ var require_git_executor = __commonJS({
             };
           } catch {
           }
-          const parentDir = path17.dirname(command.path);
+          const parentDir = path16.dirname(command.path);
           try {
-            await fs15.mkdir(parentDir, { recursive: true });
+            await fs14.mkdir(parentDir, { recursive: true });
           } catch {
           }
           const { stdout, stderr } = await execAsync(
@@ -1903,22 +1903,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 path17 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs14 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path16 = await Promise.resolve().then(() => __importStar(require("path")));
           let currentPath = cwd;
           let projectPath = cwd;
           let bareRepoPath;
           for (let i = 0; i < 10; i++) {
-            const bareDir = path17.join(currentPath, ".bare");
-            const episodaDir = path17.join(currentPath, ".episoda");
+            const bareDir = path16.join(currentPath, ".bare");
+            const episodaDir = path16.join(currentPath, ".episoda");
             try {
-              await fs15.access(bareDir);
-              await fs15.access(episodaDir);
+              await fs14.access(bareDir);
+              await fs14.access(episodaDir);
               projectPath = currentPath;
               bareRepoPath = bareDir;
               break;
             } catch {
-              const parentPath = path17.dirname(currentPath);
+              const parentPath = path16.dirname(currentPath);
               if (parentPath === currentPath) {
                 break;
               }
@@ -2512,31 +2512,31 @@ var require_auth = __commonJS({
     exports2.loadConfig = loadConfig9;
     exports2.saveConfig = saveConfig3;
     exports2.validateToken = validateToken;
-    var fs15 = __importStar(require("fs"));
-    var path17 = __importStar(require("path"));
+    var fs14 = __importStar(require("fs"));
+    var path16 = __importStar(require("path"));
     var os4 = __importStar(require("os"));
     var child_process_1 = require("child_process");
     var DEFAULT_CONFIG_FILE = "config.json";
     function getConfigDir5() {
-      return process.env.EPISODA_CONFIG_DIR || path17.join(os4.homedir(), ".episoda");
+      return process.env.EPISODA_CONFIG_DIR || path16.join(os4.homedir(), ".episoda");
     }
     function getConfigPath4(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path17.join(getConfigDir5(), DEFAULT_CONFIG_FILE);
+      return path16.join(getConfigDir5(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path17.dirname(configPath);
-      const isNew = !fs15.existsSync(dir);
+      const dir = path16.dirname(configPath);
+      const isNew = !fs14.existsSync(dir);
       if (isNew) {
-        fs15.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs14.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path17.join(dir, ".nosync");
-        if (isNew || !fs15.existsSync(nosyncPath)) {
+        const nosyncPath = path16.join(dir, ".nosync");
+        if (isNew || !fs14.existsSync(nosyncPath)) {
           try {
-            fs15.writeFileSync(nosyncPath, "", { mode: 384 });
+            fs14.writeFileSync(nosyncPath, "", { mode: 384 });
             (0, child_process_1.execSync)(`xattr -w com.apple.fileprovider.ignore 1 "${dir}"`, {
               stdio: "ignore",
               timeout: 5e3
@@ -2548,11 +2548,11 @@ var require_auth = __commonJS({
     }
     async function loadConfig9(configPath) {
       const fullPath = getConfigPath4(configPath);
-      if (!fs15.existsSync(fullPath)) {
+      if (!fs14.existsSync(fullPath)) {
         return null;
       }
       try {
-        const content = fs15.readFileSync(fullPath, "utf8");
+        const content = fs14.readFileSync(fullPath, "utf8");
         const config = JSON.parse(content);
         return config;
       } catch (error) {
@@ -2565,7 +2565,7 @@ var require_auth = __commonJS({
       ensureConfigDir(fullPath);
       try {
         const content = JSON.stringify(config, null, 2);
-        fs15.writeFileSync(fullPath, content, { mode: 384 });
+        fs14.writeFileSync(fullPath, content, { mode: 384 });
       } catch (error) {
         throw new Error(`Failed to save config: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -2681,211 +2681,9 @@ var require_dist = __commonJS({
 var import_commander = require("commander");
 var import_core18 = __toESM(require_dist());
 
-// src/commands/dev.ts
+// src/commands/daemon.ts
 var import_core4 = __toESM(require_dist());
 
-// src/framework-detector.ts
-var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
-async function detectFramework(cwd = process.cwd()) {
-  const packageJsonPath = path.join(cwd, "package.json");
-  if (fs.existsSync(packageJsonPath)) {
-    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
-    const scripts = packageJson.scripts || {};
-    if (packageJson.dependencies?.next || packageJson.devDependencies?.next) {
-      if (scripts.dev) {
-        return {
-          framework: "Next.js",
-          command: ["npm", "run", "dev"],
-          confidence: "high",
-          detectedFrom: "package.json (next dependency + dev script)"
-        };
-      }
-      return {
-        framework: "Next.js",
-        command: ["npx", "next", "dev"],
-        confidence: "medium",
-        detectedFrom: "package.json (next dependency)"
-      };
-    }
-    if (packageJson.dependencies?.react || packageJson.devDependencies?.react) {
-      if (scripts.dev) {
-        return {
-          framework: "React",
-          command: ["npm", "run", "dev"],
-          confidence: "high",
-          detectedFrom: "package.json (react + dev script)"
-        };
-      }
-      if (scripts.start) {
-        return {
-          framework: "React",
-          command: ["npm", "start"],
-          confidence: "high",
-          detectedFrom: "package.json (react + start script)"
-        };
-      }
-    }
-    if (packageJson.dependencies?.express) {
-      if (scripts.dev) {
-        return {
-          framework: "Express",
-          command: ["npm", "run", "dev"],
-          confidence: "high",
-          detectedFrom: "package.json (express + dev script)"
-        };
-      }
-      if (scripts.start) {
-        return {
-          framework: "Express",
-          command: ["npm", "start"],
-          confidence: "medium",
-          detectedFrom: "package.json (express + start script)"
-        };
-      }
-    }
-    if (packageJson.dependencies?.vue || packageJson.devDependencies?.vue) {
-      if (scripts.dev) {
-        return {
-          framework: "Vue",
-          command: ["npm", "run", "dev"],
-          confidence: "high",
-          detectedFrom: "package.json (vue + dev script)"
-        };
-      }
-      if (scripts.serve) {
-        return {
-          framework: "Vue",
-          command: ["npm", "run", "serve"],
-          confidence: "high",
-          detectedFrom: "package.json (vue + serve script)"
-        };
-      }
-    }
-    if (scripts.dev) {
-      return {
-        framework: "Node.js",
-        command: ["npm", "run", "dev"],
-        confidence: "medium",
-        detectedFrom: "package.json (dev script)"
-      };
-    }
-    if (scripts.start) {
-      return {
-        framework: "Node.js",
-        command: ["npm", "start"],
-        confidence: "low",
-        detectedFrom: "package.json (start script)"
-      };
-    }
-  }
-  const requirementsPath = path.join(cwd, "requirements.txt");
-  if (fs.existsSync(requirementsPath)) {
-    const requirements = fs.readFileSync(requirementsPath, "utf-8");
-    if (requirements.includes("Django") || requirements.includes("django")) {
-      const managePy = path.join(cwd, "manage.py");
-      if (fs.existsSync(managePy)) {
-        return {
-          framework: "Django",
-          command: ["python", "manage.py", "runserver"],
-          confidence: "high",
-          detectedFrom: "requirements.txt (Django) + manage.py"
-        };
-      }
-      return {
-        framework: "Django",
-        command: ["python", "manage.py", "runserver"],
-        confidence: "medium",
-        detectedFrom: "requirements.txt (Django)"
-      };
-    }
-    if (requirements.includes("Flask") || requirements.includes("flask")) {
-      const appFiles = ["app.py", "application.py", "wsgi.py"];
-      for (const file of appFiles) {
-        if (fs.existsSync(path.join(cwd, file))) {
-          return {
-            framework: "Flask",
-            command: ["flask", "run"],
-            confidence: "high",
-            detectedFrom: `requirements.txt (Flask) + ${file}`
-          };
-        }
-      }
-      return {
-        framework: "Flask",
-        command: ["flask", "run"],
-        confidence: "medium",
-        detectedFrom: "requirements.txt (Flask)"
-      };
-    }
-    if (requirements.includes("fastapi") || requirements.includes("uvicorn")) {
-      return {
-        framework: "FastAPI",
-        command: ["uvicorn", "main:app", "--reload"],
-        confidence: "medium",
-        detectedFrom: "requirements.txt (fastapi/uvicorn)"
-      };
-    }
-  }
-  const gemfilePath = path.join(cwd, "Gemfile");
-  if (fs.existsSync(gemfilePath)) {
-    const gemfile = fs.readFileSync(gemfilePath, "utf-8");
-    if (gemfile.includes("rails")) {
-      return {
-        framework: "Rails",
-        command: ["rails", "server"],
-        confidence: "high",
-        detectedFrom: "Gemfile (rails)"
-      };
-    }
-    if (gemfile.includes("sinatra")) {
-      return {
-        framework: "Sinatra",
-        command: ["ruby", "app.rb"],
-        confidence: "medium",
-        detectedFrom: "Gemfile (sinatra)"
-      };
-    }
-  }
-  const goModPath = path.join(cwd, "go.mod");
-  if (fs.existsSync(goModPath)) {
-    return {
-      framework: "Go",
-      command: ["go", "run", "."],
-      confidence: "medium",
-      detectedFrom: "go.mod"
-    };
-  }
-  const cargoTomlPath = path.join(cwd, "Cargo.toml");
-  if (fs.existsSync(cargoTomlPath)) {
-    return {
-      framework: "Rust",
-      command: ["cargo", "run"],
-      confidence: "medium",
-      detectedFrom: "Cargo.toml"
-    };
-  }
-  return null;
-}
-async function resolveDevCommand(providedCommand, cwd = process.cwd()) {
-  if (providedCommand && providedCommand.length > 0) {
-    return { command: providedCommand, detection: null };
-  }
-  const detection = await detectFramework(cwd);
-  if (detection) {
-    return { command: detection.command, detection };
-  }
-  return {
-    command: ["npm", "run", "dev"],
-    detection: {
-      framework: "Unknown",
-      command: ["npm", "run", "dev"],
-      confidence: "low",
-      detectedFrom: "default fallback"
-    }
-  };
-}
-
 // src/output.ts
 var import_chalk = __toESM(require("chalk"));
 var import_ora = __toESM(require("ora"));
@@ -2904,17 +2702,10 @@ var status = {
     process.stdout.write(`\r${import_chalk.default.blue("\u23F3")} ${message}`);
   }
 };
-function printFrameworkDetection(framework, command, confidence) {
-  console.log(import_chalk.default.bold("\n\u{1F50D} Framework Detection"));
-  console.log(import_chalk.default.cyan("  Framework:"), framework);
-  console.log(import_chalk.default.cyan("  Command:"), command.join(" "));
-  console.log(import_chalk.default.cyan("  Confidence:"), confidence);
-  console.log();
-}
 
 // src/daemon/daemon-manager.ts
-var fs2 = __toESM(require("fs"));
-var path2 = __toESM(require("path"));
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
 var import_child_process = require("child_process");
 var import_core = __toESM(require_dist());
 function killAllEpisodaProcesses() {
@@ -2946,13 +2737,13 @@ function killAllEpisodaProcesses() {
       (0, import_child_process.execSync)("sleep 0.5", { timeout: 2e3 });
     }
     const configDir = (0, import_core.getConfigDir)();
-    const pidPath = path2.join(configDir, "daemon.pid");
-    const sockPath = path2.join(configDir, "daemon.sock");
-    if (fs2.existsSync(pidPath)) {
-      fs2.unlinkSync(pidPath);
+    const pidPath = path.join(configDir, "daemon.pid");
+    const sockPath = path.join(configDir, "daemon.sock");
+    if (fs.existsSync(pidPath)) {
+      fs.unlinkSync(pidPath);
     }
-    if (fs2.existsSync(sockPath)) {
-      fs2.unlinkSync(sockPath);
+    if (fs.existsSync(sockPath)) {
+      fs.unlinkSync(sockPath);
     }
   } catch (error) {
     console.warn("[Cleanup] Error during process cleanup:", error instanceof Error ? error.message : error);
@@ -2960,25 +2751,25 @@ function killAllEpisodaProcesses() {
   return killedCount;
 }
 function getPidFilePath() {
-  return path2.join((0, import_core.getConfigDir)(), "daemon.pid");
+  return path.join((0, import_core.getConfigDir)(), "daemon.pid");
 }
 function isDaemonRunning() {
   const pidPath = getPidFilePath();
   try {
-    if (!fs2.existsSync(pidPath)) {
+    if (!fs.existsSync(pidPath)) {
       return null;
     }
-    const pidStr = fs2.readFileSync(pidPath, "utf-8").trim();
+    const pidStr = fs.readFileSync(pidPath, "utf-8").trim();
     const pid = parseInt(pidStr, 10);
     if (isNaN(pid)) {
-      fs2.unlinkSync(pidPath);
+      fs.unlinkSync(pidPath);
       return null;
     }
     try {
       process.kill(pid, 0);
       return pid;
     } catch (error) {
-      fs2.unlinkSync(pidPath);
+      fs.unlinkSync(pidPath);
       return null;
     }
   } catch (error) {
@@ -2992,15 +2783,15 @@ async function startDaemon() {
     throw new Error(`Daemon already running (PID: ${existingPid})`);
   }
   const configDir = (0, import_core.getConfigDir)();
-  if (!fs2.existsSync(configDir)) {
-    fs2.mkdirSync(configDir, { recursive: true });
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
   }
-  const daemonScript = path2.join(__dirname, "daemon", "daemon-process.js");
-  if (!fs2.existsSync(daemonScript)) {
+  const daemonScript = path.join(__dirname, "daemon", "daemon-process.js");
+  if (!fs.existsSync(daemonScript)) {
     throw new Error(`Daemon script not found: ${daemonScript}. Make sure CLI is built.`);
   }
-  const logPath = path2.join(configDir, "daemon.log");
-  const logFd = fs2.openSync(logPath, "a");
+  const logPath = path.join(configDir, "daemon.log");
+  const logFd = fs.openSync(logPath, "a");
   const child = (0, import_child_process.spawn)("node", [daemonScript], {
     detached: true,
     // Run independently of parent
@@ -3015,7 +2806,7 @@ async function startDaemon() {
   child.unref();
   const pid = child.pid;
   const pidPath = getPidFilePath();
-  fs2.writeFileSync(pidPath, pid.toString(), "utf-8");
+  fs.writeFileSync(pidPath, pid.toString(), "utf-8");
   await new Promise((resolve5) => setTimeout(resolve5, 500));
   const runningPid = isDaemonRunning();
   if (!runningPid) {
@@ -3027,8 +2818,8 @@ async function stopDaemon(timeout = 5e3) {
   const pid = isDaemonRunning();
   if (!pid) {
     const pidPath = getPidFilePath();
-    if (fs2.existsSync(pidPath)) {
-      fs2.unlinkSync(pidPath);
+    if (fs.existsSync(pidPath)) {
+      fs.unlinkSync(pidPath);
     }
     return false;
   }
@@ -3041,8 +2832,8 @@ async function stopDaemon(timeout = 5e3) {
         await new Promise((resolve5) => setTimeout(resolve5, 100));
       } catch (error) {
         const pidPath2 = getPidFilePath();
-        if (fs2.existsSync(pidPath2)) {
-          fs2.unlinkSync(pidPath2);
+        if (fs.existsSync(pidPath2)) {
+          fs.unlinkSync(pidPath2);
         }
         return true;
       }
@@ -3050,8 +2841,8 @@ async function stopDaemon(timeout = 5e3) {
     console.warn(`Daemon didn't stop gracefully, forcing shutdown (PID: ${pid})`);
     process.kill(pid, "SIGKILL");
     const pidPath = getPidFilePath();
-    if (fs2.existsSync(pidPath)) {
-      fs2.unlinkSync(pidPath);
+    if (fs.existsSync(pidPath)) {
+      fs.unlinkSync(pidPath);
     }
     return true;
   } catch (error) {
@@ -3062,10 +2853,10 @@ async function stopDaemon(timeout = 5e3) {
 
 // src/ipc/ipc-client.ts
 var net = __toESM(require("net"));
-var path3 = __toESM(require("path"));
+var path2 = __toESM(require("path"));
 var crypto = __toESM(require("crypto"));
 var import_core2 = __toESM(require_dist());
-var getSocketPath = () => path3.join((0, import_core2.getConfigDir)(), "daemon.sock");
+var getSocketPath = () => path2.join((0, import_core2.getConfigDir)(), "daemon.sock");
 var DEFAULT_TIMEOUT = 15e3;
 async function sendCommand(command, params, timeout = DEFAULT_TIMEOUT) {
   return new Promise((resolve5, reject) => {
@@ -3154,40 +2945,14 @@ async function getDevServerStatus() {
   return await sendCommand("dev-server-status");
 }
 
-// src/commands/dev.ts
+// src/commands/daemon.ts
 var import_child_process3 = require("child_process");
-var path6 = __toESM(require("path"));
-var fs5 = __toESM(require("fs"));
-
-// src/utils/port-check.ts
-var net2 = __toESM(require("net"));
-async function isPortInUse(port) {
-  return new Promise((resolve5) => {
-    const server = net2.createServer();
-    server.once("error", (err) => {
-      if (err.code === "EADDRINUSE") {
-        resolve5(true);
-      } else {
-        resolve5(false);
-      }
-    });
-    server.once("listening", () => {
-      server.close();
-      resolve5(false);
-    });
-    server.listen(port);
-  });
-}
-function getServerPort() {
-  if (process.env.PORT) {
-    return parseInt(process.env.PORT, 10);
-  }
-  return 3e3;
-}
+var path5 = __toESM(require("path"));
+var fs4 = __toESM(require("fs"));
 
 // src/daemon/worktree-manager.ts
-var fs3 = __toESM(require("fs"));
-var path4 = __toESM(require("path"));
+var fs2 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
 var import_core3 = __toESM(require_dist());
 function validateModuleUid(moduleUid) {
   if (!moduleUid || typeof moduleUid !== "string" || !moduleUid.trim()) {
@@ -3211,8 +2976,8 @@ var WorktreeManager = class _WorktreeManager {
     // ============================================================
     this.lockPath = "";
     this.projectRoot = projectRoot;
-    this.bareRepoPath = path4.join(projectRoot, ".bare");
-    this.configPath = path4.join(projectRoot, ".episoda", "config.json");
+    this.bareRepoPath = path3.join(projectRoot, ".bare");
+    this.configPath = path3.join(projectRoot, ".episoda", "config.json");
     this.gitExecutor = new import_core3.GitExecutor();
   }
   /**
@@ -3221,10 +2986,10 @@ var WorktreeManager = class _WorktreeManager {
    * @returns true if valid project, false otherwise
    */
   async initialize() {
-    if (!fs3.existsSync(this.bareRepoPath)) {
+    if (!fs2.existsSync(this.bareRepoPath)) {
       return false;
     }
-    if (!fs3.existsSync(this.configPath)) {
+    if (!fs2.existsSync(this.configPath)) {
       return false;
     }
     try {
@@ -3271,8 +3036,8 @@ var WorktreeManager = class _WorktreeManager {
    */
   static async createProject(projectRoot, repoUrl, projectId, workspaceSlug, projectSlug) {
     const manager = new _WorktreeManager(projectRoot);
-    const episodaDir = path4.join(projectRoot, ".episoda");
-    fs3.mkdirSync(episodaDir, { recursive: true });
+    const episodaDir = path3.join(projectRoot, ".episoda");
+    fs2.mkdirSync(episodaDir, { recursive: true });
     const cloneResult = await manager.gitExecutor.execute({
       action: "clone_bare",
       url: repoUrl,
@@ -3303,7 +3068,7 @@ var WorktreeManager = class _WorktreeManager {
         error: `Invalid module UID: "${moduleUid}" - contains disallowed characters`
       };
     }
-    const worktreePath = path4.join(this.projectRoot, moduleUid);
+    const worktreePath = path3.join(this.projectRoot, moduleUid);
     const lockAcquired = await this.acquireLock();
     if (!lockAcquired) {
       return {
@@ -3485,7 +3250,7 @@ var WorktreeManager = class _WorktreeManager {
     let prunedCount = 0;
     await this.updateConfigSafe((config) => {
       const initialCount = config.worktrees.length;
-      config.worktrees = config.worktrees.filter((w) => fs3.existsSync(w.worktreePath));
+      config.worktrees = config.worktrees.filter((w) => fs2.existsSync(w.worktreePath));
       prunedCount = initialCount - config.worktrees.length;
       return config;
     });
@@ -3566,16 +3331,16 @@ var WorktreeManager = class _WorktreeManager {
     const retryInterval = 50;
     while (Date.now() - startTime < timeoutMs) {
       try {
-        fs3.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+        fs2.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
         return true;
       } catch (err) {
         if (err.code === "EEXIST") {
           try {
-            const stats = fs3.statSync(lockPath);
+            const stats = fs2.statSync(lockPath);
             const lockAge = Date.now() - stats.mtimeMs;
             if (lockAge > 3e4) {
               try {
-                const lockContent = fs3.readFileSync(lockPath, "utf-8").trim();
+                const lockContent = fs2.readFileSync(lockPath, "utf-8").trim();
                 const lockPid = parseInt(lockContent, 10);
                 if (!isNaN(lockPid) && this.isProcessRunning(lockPid)) {
                   await new Promise((resolve5) => setTimeout(resolve5, retryInterval));
@@ -3584,7 +3349,7 @@ var WorktreeManager = class _WorktreeManager {
               } catch {
               }
               try {
-                fs3.unlinkSync(lockPath);
+                fs2.unlinkSync(lockPath);
               } catch {
               }
               continue;
@@ -3605,16 +3370,16 @@ var WorktreeManager = class _WorktreeManager {
    */
   releaseLock() {
     try {
-      fs3.unlinkSync(this.getLockPath());
+      fs2.unlinkSync(this.getLockPath());
     } catch {
     }
   }
   readConfig() {
     try {
-      if (!fs3.existsSync(this.configPath)) {
+      if (!fs2.existsSync(this.configPath)) {
         return null;
       }
-      const content = fs3.readFileSync(this.configPath, "utf-8");
+      const content = fs2.readFileSync(this.configPath, "utf-8");
       return JSON.parse(content);
     } catch (error) {
       console.error("[WorktreeManager] Failed to read config:", error);
@@ -3623,11 +3388,11 @@ var WorktreeManager = class _WorktreeManager {
   }
   writeConfig(config) {
     try {
-      const dir = path4.dirname(this.configPath);
-      if (!fs3.existsSync(dir)) {
-        fs3.mkdirSync(dir, { recursive: true });
+      const dir = path3.dirname(this.configPath);
+      if (!fs2.existsSync(dir)) {
+        fs2.mkdirSync(dir, { recursive: true });
       }
-      fs3.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf-8");
+      fs2.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf-8");
     } catch (error) {
       console.error("[WorktreeManager] Failed to write config:", error);
       throw error;
@@ -3708,14 +3473,14 @@ var WorktreeManager = class _WorktreeManager {
     }
     try {
       for (const file of files) {
-        const srcPath = path4.join(mainWorktree.worktreePath, file);
-        const destPath = path4.join(worktree.worktreePath, file);
-        if (fs3.existsSync(srcPath)) {
-          const destDir = path4.dirname(destPath);
-          if (!fs3.existsSync(destDir)) {
-            fs3.mkdirSync(destDir, { recursive: true });
+        const srcPath = path3.join(mainWorktree.worktreePath, file);
+        const destPath = path3.join(worktree.worktreePath, file);
+        if (fs2.existsSync(srcPath)) {
+          const destDir = path3.dirname(destPath);
+          if (!fs2.existsSync(destDir)) {
+            fs2.mkdirSync(destDir, { recursive: true });
           }
-          fs3.copyFileSync(srcPath, destPath);
+          fs2.copyFileSync(srcPath, destPath);
           console.log(`[WorktreeManager] EP964: Copied ${file} to ${moduleUid} (deprecated)`);
         } else {
           console.log(`[WorktreeManager] EP964: Skipped ${file} (not found in main)`);
@@ -3798,30 +3563,30 @@ var WorktreeManager = class _WorktreeManager {
   }
 };
 function getEpisodaRoot() {
-  return process.env.EPISODA_ROOT || path4.join(require("os").homedir(), "episoda");
+  return process.env.EPISODA_ROOT || path3.join(require("os").homedir(), "episoda");
 }
 function getProjectPath(workspaceSlug, projectSlug) {
-  return path4.join(getEpisodaRoot(), workspaceSlug, projectSlug);
+  return path3.join(getEpisodaRoot(), workspaceSlug, projectSlug);
 }
 async function isWorktreeProject(projectRoot) {
   const manager = new WorktreeManager(projectRoot);
   return manager.initialize();
 }
 async function findProjectRoot(startPath) {
-  let current = path4.resolve(startPath);
+  let current = path3.resolve(startPath);
   const episodaRoot = getEpisodaRoot();
   if (!current.startsWith(episodaRoot)) {
     return null;
   }
   for (let i = 0; i < 10; i++) {
-    const bareDir = path4.join(current, ".bare");
-    const episodaDir = path4.join(current, ".episoda");
-    if (fs3.existsSync(bareDir) && fs3.existsSync(episodaDir)) {
+    const bareDir = path3.join(current, ".bare");
+    const episodaDir = path3.join(current, ".episoda");
+    if (fs2.existsSync(bareDir) && fs2.existsSync(episodaDir)) {
       if (await isWorktreeProject(current)) {
         return current;
       }
     }
-    const parent = path4.dirname(current);
+    const parent = path3.dirname(current);
     if (parent === current) {
       break;
     }
@@ -3859,7 +3624,7 @@ async function fetchProjectPath(config, projectId) {
     return null;
   }
 }
-async function syncProjectPath(config, projectId, path17) {
+async function syncProjectPath(config, projectId, path16) {
   if (!config.device_id || !config.access_token) {
     return false;
   }
@@ -3872,7 +3637,7 @@ async function syncProjectPath(config, projectId, path17) {
         "Authorization": `Bearer ${config.access_token}`,
         "Content-Type": "application/json"
       },
-      body: JSON.stringify({ path: path17 })
+      body: JSON.stringify({ path: path16 })
     });
     if (!response.ok) {
       console.debug(`[MachineSettings] syncProjectPath failed: ${response.status} ${response.statusText}`);
@@ -3885,22 +3650,22 @@ async function syncProjectPath(config, projectId, path17) {
 }
 
 // src/utils/bootstrap.ts
-var fs4 = __toESM(require("fs"));
-var path5 = __toESM(require("path"));
+var fs3 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
 var import_child_process2 = require("child_process");
 async function extractBootstrapScripts(bareRepoPath, projectPath) {
-  const scriptsDir = path5.join(projectPath, ".episoda", "scripts");
-  const scriptPath = path5.join(scriptsDir, "api-helper.sh");
-  if (fs4.existsSync(scriptPath)) {
+  const scriptsDir = path4.join(projectPath, ".episoda", "scripts");
+  const scriptPath = path4.join(scriptsDir, "api-helper.sh");
+  if (fs3.existsSync(scriptPath)) {
     return false;
   }
-  fs4.mkdirSync(scriptsDir, { recursive: true });
+  fs3.mkdirSync(scriptsDir, { recursive: true });
   try {
     const scriptContent = (0, import_child_process2.execSync)(
       `git --git-dir="${bareRepoPath}" show main:scripts/api-helper.sh`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     );
-    fs4.writeFileSync(scriptPath, scriptContent, { mode: 493 });
+    fs3.writeFileSync(scriptPath, scriptContent, { mode: 493 });
     return true;
   } catch (error) {
     console.log("[bootstrap] Could not extract api-helper.sh:", error);
@@ -3908,7 +3673,7 @@ async function extractBootstrapScripts(bareRepoPath, projectPath) {
   }
 }
 
-// src/commands/dev.ts
+// src/commands/daemon.ts
 var CONNECTION_MAX_RETRIES = 3;
 function findGitRoot(startDir) {
   try {
@@ -3922,7 +3687,7 @@ function findGitRoot(startDir) {
     return null;
   }
 }
-async function devCommand(options = {}) {
+async function daemonCommand(options = {}) {
   try {
     const config = await (0, import_core4.loadConfig)();
     if (!config || !config.access_token || !config.project_id) {
@@ -3956,8 +3721,6 @@ async function devCommand(options = {}) {
         status.debug("Daemon not reachable via IPC, restarting...");
         needsRestart = true;
       }
-    } else {
-      needsRestart = false;
     }
     if (needsRestart) {
       const killedCount = killAllEpisodaProcesses();
@@ -3968,22 +3731,18 @@ async function devCommand(options = {}) {
     }
     let projectPath;
     const serverPath = await fetchProjectPath(config, config.project_id);
-    if (serverPath && fs5.existsSync(serverPath)) {
+    if (serverPath && fs4.existsSync(serverPath)) {
       projectPath = serverPath;
       status.debug(`Using server-synced project path: ${projectPath}`);
     } else {
       const detectedRoot = findGitRoot(options.cwd || process.cwd());
-      projectPath = detectedRoot || path6.resolve(options.cwd || process.cwd());
+      projectPath = detectedRoot || path5.resolve(options.cwd || process.cwd());
       if (detectedRoot) {
         status.debug(`Detected project root: ${projectPath}`);
       } else {
         status.warning(`Could not detect git root, using: ${projectPath}`);
       }
-      syncProjectPath(config, config.project_id, projectPath).then((synced) => {
-        if (synced) {
-          status.debug("Project path synced to server");
-        }
-      }).catch(() => {
+      syncProjectPath(config, config.project_id, projectPath).catch(() => {
       });
     }
     const isWorktree = await isWorktreeProject(projectPath);
@@ -3994,10 +3753,10 @@ async function devCommand(options = {}) {
       status.info("");
       process.exit(1);
     }
-    const bareRepoPath = path6.join(projectPath, ".bare");
+    const bareRepoPath = path5.join(projectPath, ".bare");
     const scriptsExtracted = await extractBootstrapScripts(bareRepoPath, projectPath);
     if (scriptsExtracted) {
-      status.success("\u2713 Bootstrap scripts extracted");
+      status.success("Bootstrap scripts extracted");
     }
     let daemonPid = isDaemonRunning();
     if (!daemonPid) {
@@ -4014,10 +3773,10 @@ async function devCommand(options = {}) {
     }
     const reachable = await isDaemonReachable();
     if (!reachable) {
-      status.error("Daemon is running but not responding. Try: episoda stop && episoda dev");
+      status.error("Daemon is running but not responding. Try: episoda stop && episoda daemon");
       process.exit(1);
     }
-    status.info(`Connecting project to Episoda...`);
+    status.info("Connecting project to Episoda...");
     let connected = false;
     let lastError;
     for (let retry = 0; retry < CONNECTION_MAX_RETRIES && !connected; retry++) {
@@ -4042,41 +3801,25 @@ async function devCommand(options = {}) {
       process.exit(1);
     }
     status.success("Connected to Episoda");
-    let command;
-    let detection;
-    let connectionOnlyMode = false;
-    if (options.command && options.command.length === 0) {
-      connectionOnlyMode = true;
-      status.debug("Connection-only mode (explicit)");
-    } else if (!options.command) {
-      const serverPort = getServerPort();
-      const portInUse = await isPortInUse(serverPort);
-      if (portInUse) {
-        connectionOnlyMode = true;
-        status.info(`Server already running on port ${serverPort}`);
-        status.info("Connecting to existing server...");
-      }
-    }
-    if (!connectionOnlyMode) {
-      try {
-        const result = await resolveDevCommand(options.command || null, projectPath);
-        command = result.command;
-        detection = result.detection;
-        if (detection && !options.command) {
-          printFrameworkDetection(detection.framework, detection.command, detection.confidence);
-        }
-      } catch (error) {
-        status.debug("No dev command detected");
-        command = void 0;
-      }
-    }
-    if (command && command.length > 0) {
-      await runDevServer(command, projectPath, options.autoRestart ?? false);
+    if (options.background) {
+      status.info("");
+      status.info("Daemon running in background.");
+      status.info("Use `episoda status` to check connection.");
+      status.info("Use `episoda stop` to stop the daemon.");
+      process.exit(0);
     } else {
       status.info("");
-      status.info("Connected! Git operations will be executed by Episoda.");
-      status.info("Press Ctrl+C to disconnect.");
+      status.info("Daemon connected! Dev servers start automatically when you begin work on a module.");
+      status.info("Press Ctrl+C to disconnect (daemon continues in background).");
       status.info("");
+      const shutdownHandler = (signal) => {
+        status.info(`
+Received ${signal}. Daemon continues running in background.`);
+        status.info("Use `episoda stop` to fully stop the daemon.");
+        process.exit(0);
+      };
+      process.on("SIGTERM", () => shutdownHandler("SIGTERM"));
+      process.on("SIGINT", () => shutdownHandler("SIGINT"));
       await new Promise(() => {
       });
     }
@@ -4085,73 +3828,17 @@ async function devCommand(options = {}) {
     process.exit(1);
   }
 }
-async function runDevServer(command, cwd, autoRestart) {
-  let devProcess;
-  let restartCount = 0;
-  let shuttingDown = false;
-  const startServer = () => {
-    status.info(`Starting dev server: ${command.join(" ")}`);
-    devProcess = (0, import_child_process3.spawn)(command[0], command.slice(1), {
-      cwd,
-      stdio: ["inherit", "inherit", "inherit"],
-      shell: true
-    });
-    devProcess.on("exit", (code, signal) => {
-      if (shuttingDown) {
-        status.info("Dev server stopped");
-        return;
-      }
-      if (code === 0) {
-        status.success("Dev server exited successfully");
-      } else {
-        status.error(`Dev server exited with code ${code}${signal ? ` (signal: ${signal})` : ""}`);
-      }
-      if (autoRestart && !shuttingDown) {
-        restartCount++;
-        status.info(`Auto-restarting dev server (attempt ${restartCount})...`);
-        setTimeout(() => {
-          startServer();
-        }, 2e3);
-      } else if (!shuttingDown) {
-        status.info("");
-        status.info("Dev server stopped, but daemon remains connected.");
-        status.info("Git operations will still be executed by Episoda.");
-        status.info("Press Ctrl+C to disconnect.");
-        status.info("");
-      }
-    });
-    devProcess.on("error", (error) => {
-      status.error(`Dev server error: ${error.message}`);
-    });
-  };
-  const shutdownHandler = async (signal) => {
-    if (shuttingDown) return;
-    shuttingDown = true;
-    status.info(`
-Received ${signal}, shutting down...`);
-    if (devProcess) {
-      devProcess.kill("SIGTERM");
-    }
-    status.info("Dev server stopped. Daemon continues running in background.");
-    process.exit(0);
-  };
-  process.on("SIGTERM", () => shutdownHandler("SIGTERM"));
-  process.on("SIGINT", () => shutdownHandler("SIGINT"));
-  startServer();
-  await new Promise(() => {
-  });
-}
 
 // src/commands/auth.ts
 var os = __toESM(require("os"));
-var fs7 = __toESM(require("fs"));
-var path8 = __toESM(require("path"));
+var fs6 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
 var import_child_process5 = require("child_process");
 var import_core6 = __toESM(require_dist());
 
 // src/daemon/machine-id.ts
-var fs6 = __toESM(require("fs"));
-var path7 = __toESM(require("path"));
+var fs5 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
 var crypto2 = __toESM(require("crypto"));
 var import_child_process4 = require("child_process");
 var import_core5 = __toESM(require_dist());
@@ -4160,17 +3847,17 @@ function isValidUUID(str) {
   return uuidRegex.test(str);
 }
 async function getMachineId() {
-  const machineIdPath = path7.join((0, import_core5.getConfigDir)(), "machine-id");
+  const machineIdPath = path6.join((0, import_core5.getConfigDir)(), "machine-id");
   try {
-    if (fs6.existsSync(machineIdPath)) {
-      const existingId = fs6.readFileSync(machineIdPath, "utf-8").trim();
+    if (fs5.existsSync(machineIdPath)) {
+      const existingId = fs5.readFileSync(machineIdPath, "utf-8").trim();
       if (existingId) {
         if (isValidUUID(existingId)) {
           return existingId;
         }
         console.log("[MachineId] Migrating legacy machine ID to UUID format...");
         const newUUID = generateMachineId();
-        fs6.writeFileSync(machineIdPath, newUUID, "utf-8");
+        fs5.writeFileSync(machineIdPath, newUUID, "utf-8");
         console.log(`[MachineId] Migrated: ${existingId} \u2192 ${newUUID}`);
         return newUUID;
       }
@@ -4179,11 +3866,11 @@ async function getMachineId() {
   }
   const machineId = generateMachineId();
   try {
-    const dir = path7.dirname(machineIdPath);
-    if (!fs6.existsSync(dir)) {
-      fs6.mkdirSync(dir, { recursive: true });
+    const dir = path6.dirname(machineIdPath);
+    if (!fs5.existsSync(dir)) {
+      fs5.mkdirSync(dir, { recursive: true });
     }
-    fs6.writeFileSync(machineIdPath, machineId, "utf-8");
+    fs5.writeFileSync(machineIdPath, machineId, "utf-8");
   } catch (error) {
     console.error("Warning: Could not save machine ID to disk:", error);
   }
@@ -4200,14 +3887,14 @@ function getHardwareUUID() {
         return output;
       }
     } else if (process.platform === "linux") {
-      if (fs6.existsSync("/etc/machine-id")) {
-        const machineId = fs6.readFileSync("/etc/machine-id", "utf-8").trim();
+      if (fs5.existsSync("/etc/machine-id")) {
+        const machineId = fs5.readFileSync("/etc/machine-id", "utf-8").trim();
         if (machineId && machineId.length > 0) {
           return machineId;
         }
       }
-      if (fs6.existsSync("/var/lib/dbus/machine-id")) {
-        const dbusId = fs6.readFileSync("/var/lib/dbus/machine-id", "utf-8").trim();
+      if (fs5.existsSync("/var/lib/dbus/machine-id")) {
+        const dbusId = fs5.readFileSync("/var/lib/dbus/machine-id", "utf-8").trim();
         if (dbusId && dbusId.length > 0) {
           return dbusId;
         }
@@ -4767,13 +4454,13 @@ function openBrowser(url) {
 async function installGitCredentialHelper(apiUrl) {
   try {
     const homeDir = os.homedir();
-    const episodaBinDir = path8.join(homeDir, ".episoda", "bin");
-    const helperPath = path8.join(episodaBinDir, "git-credential-episoda");
-    fs7.mkdirSync(episodaBinDir, { recursive: true });
+    const episodaBinDir = path7.join(homeDir, ".episoda", "bin");
+    const helperPath = path7.join(episodaBinDir, "git-credential-episoda");
+    fs6.mkdirSync(episodaBinDir, { recursive: true });
     const scriptContent = generateCredentialHelperScript(apiUrl);
-    fs7.writeFileSync(helperPath, scriptContent, { mode: 493 });
+    fs6.writeFileSync(helperPath, scriptContent, { mode: 493 });
     try {
-      fs7.accessSync(helperPath, fs7.constants.X_OK);
+      fs6.accessSync(helperPath, fs6.constants.X_OK);
     } catch {
     }
     try {
@@ -4804,19 +4491,19 @@ function updateShellProfile(binDir) {
   }
   const homeDir = os.homedir();
   const profiles = [
-    path8.join(homeDir, ".bashrc"),
-    path8.join(homeDir, ".zshrc"),
-    path8.join(homeDir, ".profile")
+    path7.join(homeDir, ".bashrc"),
+    path7.join(homeDir, ".zshrc"),
+    path7.join(homeDir, ".profile")
   ];
   const exportLine = `export PATH="${binDir}:$PATH"  # Added by episoda auth`;
   for (const profile of profiles) {
     try {
-      if (fs7.existsSync(profile)) {
-        const content = fs7.readFileSync(profile, "utf8");
+      if (fs6.existsSync(profile)) {
+        const content = fs6.readFileSync(profile, "utf8");
         if (content.includes(".episoda/bin")) {
           continue;
         }
-        fs7.appendFileSync(profile, `
+        fs6.appendFileSync(profile, `
 # Episoda CLI
 ${exportLine}
 `);
@@ -4828,8 +4515,8 @@ ${exportLine}
 
 // src/commands/connect.ts
 var os2 = __toESM(require("os"));
-var fs8 = __toESM(require("fs"));
-var path9 = __toESM(require("path"));
+var fs7 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
 var import_child_process6 = require("child_process");
 var import_core7 = __toESM(require_dist());
 async function connectCommand(options) {
@@ -4904,11 +4591,11 @@ async function exchangeUserCode(apiUrl, userCode, machineId) {
 async function installGitCredentialHelper2(apiUrl) {
   try {
     const homeDir = os2.homedir();
-    const episodaBinDir = path9.join(homeDir, ".episoda", "bin");
-    const helperPath = path9.join(episodaBinDir, "git-credential-episoda");
-    fs8.mkdirSync(episodaBinDir, { recursive: true });
+    const episodaBinDir = path8.join(homeDir, ".episoda", "bin");
+    const helperPath = path8.join(episodaBinDir, "git-credential-episoda");
+    fs7.mkdirSync(episodaBinDir, { recursive: true });
     const scriptContent = generateCredentialHelperScript(apiUrl);
-    fs8.writeFileSync(helperPath, scriptContent, { mode: 493 });
+    fs7.writeFileSync(helperPath, scriptContent, { mode: 493 });
     try {
       const allHelpers = (0, import_child_process6.execSync)("git config --global --get-all credential.helper", {
         encoding: "utf8",
@@ -4937,19 +4624,19 @@ function updateShellProfile2(binDir) {
   }
   const homeDir = os2.homedir();
   const profiles = [
-    path9.join(homeDir, ".bashrc"),
-    path9.join(homeDir, ".zshrc"),
-    path9.join(homeDir, ".profile")
+    path8.join(homeDir, ".bashrc"),
+    path8.join(homeDir, ".zshrc"),
+    path8.join(homeDir, ".profile")
   ];
   const exportLine = `export PATH="${binDir}:$PATH"  # Added by episoda`;
   for (const profile of profiles) {
     try {
-      if (fs8.existsSync(profile)) {
-        const content = fs8.readFileSync(profile, "utf8");
+      if (fs7.existsSync(profile)) {
+        const content = fs7.readFileSync(profile, "utf8");
         if (content.includes(".episoda/bin")) {
           continue;
         }
-        fs8.appendFileSync(profile, `
+        fs7.appendFileSync(profile, `
 # Episoda CLI
 ${exportLine}
 `);
@@ -5251,24 +4938,24 @@ async function stopCommand(options = {}) {
 }
 
 // src/commands/clone.ts
-var fs10 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
+var fs9 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
 var import_core10 = __toESM(require_dist());
 
 // src/daemon/project-tracker.ts
-var fs9 = __toESM(require("fs"));
-var path10 = __toESM(require("path"));
+var fs8 = __toESM(require("fs"));
+var path9 = __toESM(require("path"));
 var import_core9 = __toESM(require_dist());
 function getProjectsFilePath() {
-  return path10.join((0, import_core9.getConfigDir)(), "projects.json");
+  return path9.join((0, import_core9.getConfigDir)(), "projects.json");
 }
 function readProjects() {
   const projectsPath = getProjectsFilePath();
   try {
-    if (!fs9.existsSync(projectsPath)) {
+    if (!fs8.existsSync(projectsPath)) {
       return { projects: [] };
     }
-    const content = fs9.readFileSync(projectsPath, "utf-8");
+    const content = fs8.readFileSync(projectsPath, "utf-8");
     const data = JSON.parse(content);
     if (!data.projects || !Array.isArray(data.projects)) {
       console.warn("Invalid projects.json structure, resetting");
@@ -5283,11 +4970,11 @@ function readProjects() {
 function writeProjects(data) {
   const projectsPath = getProjectsFilePath();
   try {
-    const dir = path10.dirname(projectsPath);
-    if (!fs9.existsSync(dir)) {
-      fs9.mkdirSync(dir, { recursive: true });
+    const dir = path9.dirname(projectsPath);
+    if (!fs8.existsSync(dir)) {
+      fs8.mkdirSync(dir, { recursive: true });
     }
-    fs9.writeFileSync(projectsPath, JSON.stringify(data, null, 2), "utf-8");
+    fs8.writeFileSync(projectsPath, JSON.stringify(data, null, 2), "utf-8");
   } catch (error) {
     throw new Error(`Failed to write projects.json: ${error}`);
   }
@@ -5311,7 +4998,7 @@ function addProject2(projectId, projectPath, options) {
     console.log(`[ProjectTracker] Replacing project entry: ${existingById.path} -> ${projectPath}`);
     data.projects.splice(existingByIdIndex, 1);
   }
-  const projectName = path10.basename(projectPath);
+  const projectName = path9.basename(projectPath);
   const newProject = {
     id: projectId,
     path: projectPath,
@@ -5345,9 +5032,9 @@ async function cloneCommand(slugArg, options = {}) {
   }
   const apiUrl = options.apiUrl || config.api_url || "https://episoda.dev";
   const projectPath = getProjectPath(workspaceSlug, projectSlug);
-  if (fs10.existsSync(projectPath)) {
-    const bareRepoPath = path11.join(projectPath, ".bare");
-    if (fs10.existsSync(bareRepoPath)) {
+  if (fs9.existsSync(projectPath)) {
+    const bareRepoPath = path10.join(projectPath, ".bare");
+    if (fs9.existsSync(bareRepoPath)) {
       status.warning(`Project already cloned at ${projectPath}`);
       status.info("");
       status.info("Next steps:");
@@ -5379,7 +5066,7 @@ Please configure a repository in the project settings on episoda.dev.`
   status.info("");
   status.info("Creating project directory...");
   const episodaRoot = getEpisodaRoot();
-  fs10.mkdirSync(projectPath, { recursive: true });
+  fs9.mkdirSync(projectPath, { recursive: true });
   status.success(`\u2713 Created ${projectPath}`);
   status.info("Cloning repository (bare)...");
   try {
@@ -5417,9 +5104,9 @@ Please configure a repository in the project settings on episoda.dev.`
     status.info("  3. episoda checkout {moduleUid}  # e.g., episoda checkout EP100");
     status.info("");
   } catch (error) {
-    if (fs10.existsSync(projectPath)) {
+    if (fs9.existsSync(projectPath)) {
       try {
-        fs10.rmSync(projectPath, { recursive: true, force: true });
+        fs9.rmSync(projectPath, { recursive: true, force: true });
       } catch {
       }
     }
@@ -5520,8 +5207,8 @@ async function fetchWithRetry(url, options, maxRetries = 3) {
 }
 
 // src/utils/env-setup.ts
-var fs11 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var fs10 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
 async function fetchEnvVars(apiUrl, accessToken) {
   try {
     const url = `${apiUrl}/api/cli/env-vars`;
@@ -5556,8 +5243,8 @@ function writeEnvFile(targetPath, envVars) {
     }
     return `${key}=${value}`;
   }).join("\n") + "\n";
-  const envPath = path12.join(targetPath, ".env");
-  fs11.writeFileSync(envPath, envContent, { mode: 384 });
+  const envPath = path11.join(targetPath, ".env");
+  fs10.writeFileSync(envPath, envContent, { mode: 384 });
   console.log(`[env-setup] Wrote ${Object.keys(envVars).length} env vars to ${envPath}`);
 }
 async function setupWorktreeEnv(worktreePath, apiUrl, accessToken) {
@@ -5735,7 +5422,7 @@ async function updateModuleCheckout(apiUrl, moduleId, accessToken, branchName) {
 }
 
 // src/commands/release.ts
-var path13 = __toESM(require("path"));
+var path12 = __toESM(require("path"));
 var import_core12 = __toESM(require_dist());
 async function releaseCommand(moduleUid, options = {}) {
   if (!moduleUid || !moduleUid.match(/^EP\d+$/)) {
@@ -5782,7 +5469,7 @@ Commit or stash your changes first, or use --force to discard them.`
       );
     }
   }
-  const currentPath = path13.resolve(process.cwd());
+  const currentPath = path12.resolve(process.cwd());
   if (currentPath.startsWith(existing.worktreePath)) {
     status.warning("You are inside the worktree being released.");
     status.info(`Please cd to ${projectRoot} first.`);
@@ -5856,8 +5543,8 @@ async function updateModuleRelease(apiUrl, projectId, workspaceSlug, moduleUid,
 }
 
 // src/commands/list.ts
-var fs12 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
+var fs11 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
 var import_chalk2 = __toESM(require("chalk"));
 var import_core13 = __toESM(require_dist());
 async function listCommand(subcommand, options = {}) {
@@ -5869,7 +5556,7 @@ async function listCommand(subcommand, options = {}) {
 }
 async function listProjects(options) {
   const episodaRoot = getEpisodaRoot();
-  if (!fs12.existsSync(episodaRoot)) {
+  if (!fs11.existsSync(episodaRoot)) {
     status.info("No projects cloned yet.");
     status.info("");
     status.info("Clone a project with:");
@@ -5877,12 +5564,12 @@ async function listProjects(options) {
     return;
   }
   const projects = [];
-  const workspaces = fs12.readdirSync(episodaRoot, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("."));
+  const workspaces = fs11.readdirSync(episodaRoot, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("."));
   for (const workspace of workspaces) {
-    const workspacePath = path14.join(episodaRoot, workspace.name);
-    const projectDirs = fs12.readdirSync(workspacePath, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("."));
+    const workspacePath = path13.join(episodaRoot, workspace.name);
+    const projectDirs = fs11.readdirSync(workspacePath, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("."));
     for (const projectDir of projectDirs) {
-      const projectPath = path14.join(workspacePath, projectDir.name);
+      const projectPath = path13.join(workspacePath, projectDir.name);
       if (await isWorktreeProject(projectPath)) {
         const manager = new WorktreeManager(projectPath);
         await manager.initialize();
@@ -6122,26 +5809,26 @@ var import_child_process9 = require("child_process");
 var import_core15 = __toESM(require_dist());
 
 // src/utils/env-cache.ts
-var fs13 = __toESM(require("fs"));
-var path15 = __toESM(require("path"));
+var fs12 = __toESM(require("fs"));
+var path14 = __toESM(require("path"));
 var os3 = __toESM(require("os"));
 var DEFAULT_CACHE_TTL = 60;
-var CACHE_DIR = path15.join(os3.homedir(), ".episoda", "cache");
+var CACHE_DIR = path14.join(os3.homedir(), ".episoda", "cache");
 function getCacheFilePath(projectId) {
-  return path15.join(CACHE_DIR, `env-vars-${projectId}.json`);
+  return path14.join(CACHE_DIR, `env-vars-${projectId}.json`);
 }
 function ensureCacheDir() {
-  if (!fs13.existsSync(CACHE_DIR)) {
-    fs13.mkdirSync(CACHE_DIR, { recursive: true, mode: 448 });
+  if (!fs12.existsSync(CACHE_DIR)) {
+    fs12.mkdirSync(CACHE_DIR, { recursive: true, mode: 448 });
   }
 }
 function readCache(projectId) {
   try {
     const cacheFile = getCacheFilePath(projectId);
-    if (!fs13.existsSync(cacheFile)) {
+    if (!fs12.existsSync(cacheFile)) {
       return null;
     }
-    const content = fs13.readFileSync(cacheFile, "utf-8");
+    const content = fs12.readFileSync(cacheFile, "utf-8");
     const data = JSON.parse(content);
     if (!data.vars || typeof data.vars !== "object" || !data.fetchedAt) {
       return null;
@@ -6160,7 +5847,7 @@ function writeCache(projectId, vars) {
       fetchedAt: Date.now(),
       projectId
     };
-    fs13.writeFileSync(cacheFile, JSON.stringify(data, null, 2), { mode: 384 });
+    fs12.writeFileSync(cacheFile, JSON.stringify(data, null, 2), { mode: 384 });
   } catch (error) {
     console.warn("[env-cache] Failed to write cache:", error instanceof Error ? error.message : error);
   }
@@ -6396,8 +6083,8 @@ function printExports(envVars) {
 }
 
 // src/commands/env.ts
-var fs14 = __toESM(require("fs"));
-var path16 = __toESM(require("path"));
+var fs13 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
 var readline = __toESM(require("readline"));
 var import_core17 = __toESM(require_dist());
 async function envListCommand(options = {}) {
@@ -6587,8 +6274,8 @@ async function envPullCommand(options = {}) {
     return;
   }
   const filename = options.file || ".env";
-  const filepath = path16.resolve(process.cwd(), filename);
-  fs14.writeFileSync(filepath, fullContent, { mode: 384 });
+  const filepath = path15.resolve(process.cwd(), filename);
+  fs13.writeFileSync(filepath, fullContent, { mode: 384 });
   status.success(`Wrote ${Object.keys(envVars).length} env vars to ${filename}`);
 }
 async function promptForValue(key) {
@@ -6661,18 +6348,24 @@ import_commander.program.command("connect").description("Connect using a pre-aut
     process.exit(1);
   }
 });
-import_commander.program.command("dev").description("Connect to Episoda and start dev server").option("--auto-restart", "Auto-restart dev server if it crashes").option("--connection-only", "Connection-only mode (don't start dev server)").allowUnknownOption().action(async (options, cmd) => {
+import_commander.program.command("daemon").description("Connect project to Episoda daemon (dev servers start automatically)").option("--background", "Run in background and exit immediately").action(async (options) => {
   try {
-    const args = process.argv.slice(process.argv.indexOf("dev") + 1);
-    const separatorIndex = args.indexOf("--");
-    const command = separatorIndex >= 0 ? args.slice(separatorIndex + 1) : [];
-    const filteredCommand = command.filter((arg) => arg !== "--auto-restart" && arg !== "--connection-only");
-    await devCommand({
-      command: options.connectionOnly ? [] : filteredCommand.length > 0 ? filteredCommand : void 0,
-      autoRestart: options.autoRestart
+    await daemonCommand({
+      background: options.background
+    });
+  } catch (error) {
+    status.error(`Daemon command failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+});
+import_commander.program.command("dev").description('Alias for "daemon" (deprecated)').option("--background", "Run in background and exit immediately").action(async (options) => {
+  status.warning('Note: "episoda dev" is deprecated. Use "episoda daemon" instead.');
+  try {
+    await daemonCommand({
+      background: options.background
     });
   } catch (error) {
-    status.error(`Dev command failed: ${error instanceof Error ? error.message : String(error)}`);
+    status.error(`Command failed: ${error instanceof Error ? error.message : String(error)}`);
     process.exit(1);
   }
 });