episoda 0.2.51 → 0.2.53

package/dist/daemon/daemon-process.js

@@ -1563,15 +1563,15 @@ var require_git_executor = __commonJS({
           try {
             const { stdout: gitDir } = await execAsync2("git rev-parse --git-dir", { cwd, timeout: 5e3 });
             const gitDirPath = gitDir.trim();
-            const fs18 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+            const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
             const rebaseMergePath = `${gitDirPath}/rebase-merge`;
             const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
             try {
-              await fs18.access(rebaseMergePath);
+              await fs17.access(rebaseMergePath);
               inRebase = true;
             } catch {
               try {
-                await fs18.access(rebaseApplyPath);
+                await fs17.access(rebaseApplyPath);
                 inRebase = true;
               } catch {
                 inRebase = false;
@@ -1625,9 +1625,9 @@ var require_git_executor = __commonJS({
               error: validation.error || "UNKNOWN_ERROR"
             };
           }
-          const fs18 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs18.access(command.path);
+            await fs17.access(command.path);
             return {
               success: false,
               error: "WORKTREE_EXISTS",
@@ -1681,9 +1681,9 @@ var require_git_executor = __commonJS({
        */
       async executeWorktreeRemove(command, cwd, options) {
         try {
-          const fs18 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs18.access(command.path);
+            await fs17.access(command.path);
           } catch {
             return {
               success: false,
@@ -1718,7 +1718,7 @@ var require_git_executor = __commonJS({
           const result = await this.runGitCommand(args, cwd, options);
           if (result.success) {
             try {
-              await fs18.rm(command.path, { recursive: true, force: true });
+              await fs17.rm(command.path, { recursive: true, force: true });
             } catch {
             }
             return {
@@ -1852,10 +1852,10 @@ var require_git_executor = __commonJS({
        */
       async executeCloneBare(command, options) {
         try {
-          const fs18 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path19 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path18 = await Promise.resolve().then(() => __importStar(require("path")));
           try {
-            await fs18.access(command.path);
+            await fs17.access(command.path);
             return {
               success: false,
               error: "BRANCH_ALREADY_EXISTS",
@@ -1864,9 +1864,9 @@ var require_git_executor = __commonJS({
             };
           } catch {
           }
-          const parentDir = path19.dirname(command.path);
+          const parentDir = path18.dirname(command.path);
           try {
-            await fs18.mkdir(parentDir, { recursive: true });
+            await fs17.mkdir(parentDir, { recursive: true });
           } catch {
           }
           const { stdout, stderr } = await execAsync2(
@@ -1914,22 +1914,22 @@ var require_git_executor = __commonJS({
        */
       async executeProjectInfo(cwd, options) {
         try {
-          const fs18 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path19 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path18 = await Promise.resolve().then(() => __importStar(require("path")));
           let currentPath = cwd;
           let projectPath = cwd;
           let bareRepoPath;
           for (let i = 0; i < 10; i++) {
-            const bareDir = path19.join(currentPath, ".bare");
-            const episodaDir = path19.join(currentPath, ".episoda");
+            const bareDir = path18.join(currentPath, ".bare");
+            const episodaDir = path18.join(currentPath, ".episoda");
             try {
-              await fs18.access(bareDir);
-              await fs18.access(episodaDir);
+              await fs17.access(bareDir);
+              await fs17.access(episodaDir);
               projectPath = currentPath;
               bareRepoPath = bareDir;
               break;
             } catch {
-              const parentPath = path19.dirname(currentPath);
+              const parentPath = path18.dirname(currentPath);
               if (parentPath === currentPath) {
                 break;
               }
@@ -2538,31 +2538,31 @@ var require_auth = __commonJS({
     exports2.loadConfig = loadConfig7;
     exports2.saveConfig = saveConfig2;
     exports2.validateToken = validateToken;
-    var fs18 = __importStar(require("fs"));
-    var path19 = __importStar(require("path"));
+    var fs17 = __importStar(require("fs"));
+    var path18 = __importStar(require("path"));
     var os7 = __importStar(require("os"));
     var child_process_1 = require("child_process");
     var DEFAULT_CONFIG_FILE = "config.json";
     function getConfigDir8() {
-      return process.env.EPISODA_CONFIG_DIR || path19.join(os7.homedir(), ".episoda");
+      return process.env.EPISODA_CONFIG_DIR || path18.join(os7.homedir(), ".episoda");
     }
     function getConfigPath(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path19.join(getConfigDir8(), DEFAULT_CONFIG_FILE);
+      return path18.join(getConfigDir8(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path19.dirname(configPath);
-      const isNew = !fs18.existsSync(dir);
+      const dir = path18.dirname(configPath);
+      const isNew = !fs17.existsSync(dir);
       if (isNew) {
-        fs18.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs17.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path19.join(dir, ".nosync");
-        if (isNew || !fs18.existsSync(nosyncPath)) {
+        const nosyncPath = path18.join(dir, ".nosync");
+        if (isNew || !fs17.existsSync(nosyncPath)) {
           try {
-            fs18.writeFileSync(nosyncPath, "", { mode: 384 });
+            fs17.writeFileSync(nosyncPath, "", { mode: 384 });
             (0, child_process_1.execSync)(`xattr -w com.apple.fileprovider.ignore 1 "${dir}"`, {
               stdio: "ignore",
               timeout: 5e3
@@ -2574,9 +2574,9 @@ var require_auth = __commonJS({
     }
     async function loadConfig7(configPath) {
       const fullPath = getConfigPath(configPath);
-      if (fs18.existsSync(fullPath)) {
+      if (fs17.existsSync(fullPath)) {
         try {
-          const content = fs18.readFileSync(fullPath, "utf8");
+          const content = fs17.readFileSync(fullPath, "utf8");
           const config = JSON.parse(content);
           return config;
         } catch (error) {
@@ -2601,7 +2601,7 @@ var require_auth = __commonJS({
       ensureConfigDir(fullPath);
       try {
         const content = JSON.stringify(config, null, 2);
-        fs18.writeFileSync(fullPath, content, { mode: 384 });
+        fs17.writeFileSync(fullPath, content, { mode: 384 });
       } catch (error) {
         throw new Error(`Failed to save config: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -2718,7 +2718,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.51",
+      version: "0.2.53",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -4020,12 +4020,14 @@ var os2 = __toESM(require("os"));
 // src/tunnel/tunnel-api.ts
 var import_core7 = __toESM(require_dist());
 async function provisionNamedTunnel(moduleId, port = 3e3) {
+  console.log(`[TunnelAPI] EP1038: provisionNamedTunnel called for moduleId ${moduleId} with port ${port}`);
   const config = await (0, import_core7.loadConfig)();
   if (!config?.access_token) {
     return { success: false, error: "Not authenticated" };
   }
   try {
     const apiUrl = config.api_url || "https://episoda.dev";
+    console.log(`[TunnelAPI] EP1038: POSTing to ${apiUrl}/api/tunnels with port=${port}`);
     const response = await fetch(`${apiUrl}/api/tunnels`, {
       method: "POST",
       headers: {
@@ -4055,6 +4057,7 @@ async function provisionNamedTunnel(moduleId, port = 3e3) {
   }
 }
 async function provisionNamedTunnelByUid(moduleUid, port = 3e3) {
+  console.log(`[TunnelAPI] EP1038: provisionNamedTunnelByUid called for ${moduleUid} with port ${port}`);
   const config = await (0, import_core7.loadConfig)();
   if (!config?.access_token) {
     return { success: false, error: "Not authenticated" };
@@ -5857,6 +5860,48 @@ function getDevServerRunner() {
   return instance2;
 }
 
+// src/utils/port-allocator.ts
+var PORT_RANGE_START = 3100;
+var PORT_RANGE_END = 3199;
+var PORT_WARNING_THRESHOLD = 80;
+var portAssignments = /* @__PURE__ */ new Map();
+function allocatePort(moduleUid) {
+  const existing = portAssignments.get(moduleUid);
+  if (existing) {
+    return existing;
+  }
+  const usedPorts = new Set(portAssignments.values());
+  if (usedPorts.size >= PORT_WARNING_THRESHOLD) {
+    console.warn(
+      `[PortAllocator] Warning: ${usedPorts.size}/${PORT_RANGE_END - PORT_RANGE_START + 1} ports allocated`
+    );
+  }
+  for (let port = PORT_RANGE_START; port <= PORT_RANGE_END; port++) {
+    if (!usedPorts.has(port)) {
+      portAssignments.set(moduleUid, port);
+      console.log(`[PortAllocator] Assigned port ${port} to ${moduleUid}`);
+      return port;
+    }
+  }
+  throw new Error(
+    `No available ports in range ${PORT_RANGE_START}-${PORT_RANGE_END}. ${portAssignments.size} modules are using all available ports.`
+  );
+}
+function releasePort(moduleUid) {
+  const port = portAssignments.get(moduleUid);
+  if (port) {
+    portAssignments.delete(moduleUid);
+    console.log(`[PortAllocator] Released port ${port} from ${moduleUid}`);
+  }
+}
+function clearAllPorts() {
+  const count = portAssignments.size;
+  portAssignments.clear();
+  if (count > 0) {
+    console.log(`[PortAllocator] Cleared ${count} port assignments`);
+  }
+}
+
 // src/preview/preview-manager.ts
 var DEFAULT_PORT = 3e3;
 var PreviewManager = class extends import_events3.EventEmitter {
@@ -6069,6 +6114,7 @@ var PreviewManager = class extends import_events3.EventEmitter {
     } catch (error) {
       console.warn(`[PreviewManager] Error clearing tunnel URL for ${moduleUid}:`, error);
     }
+    releasePort(moduleUid);
     if (state) {
       state.state = "stopped";
       state.tunnelUrl = void 0;
@@ -6574,80 +6620,9 @@ function getDevServerStatus() {
   }));
 }
 
-// src/utils/port-detect.ts
+// src/daemon/worktree-manager.ts
 var fs13 = __toESM(require("fs"));
 var path14 = __toESM(require("path"));
-var DEFAULT_PORT2 = 3e3;
-function detectDevPort(projectPath) {
-  const envPort = getPortFromEnv(projectPath);
-  if (envPort) {
-    console.log(`[PortDetect] Found PORT=${envPort} in .env`);
-    return envPort;
-  }
-  const scriptPort = getPortFromPackageJson(projectPath);
-  if (scriptPort) {
-    console.log(`[PortDetect] Found port ${scriptPort} in package.json dev script`);
-    return scriptPort;
-  }
-  console.log(`[PortDetect] Using default port ${DEFAULT_PORT2}`);
-  return DEFAULT_PORT2;
-}
-function getPortFromEnv(projectPath) {
-  const envPaths = [
-    path14.join(projectPath, ".env"),
-    path14.join(projectPath, ".env.local"),
-    path14.join(projectPath, ".env.development"),
-    path14.join(projectPath, ".env.development.local")
-  ];
-  for (const envPath of envPaths) {
-    try {
-      if (!fs13.existsSync(envPath)) continue;
-      const content = fs13.readFileSync(envPath, "utf-8");
-      const lines = content.split("\n");
-      for (const line of lines) {
-        const match = line.match(/^\s*PORT\s*=\s*["']?(\d+)["']?\s*(?:#.*)?$/);
-        if (match) {
-          const port = parseInt(match[1], 10);
-          if (port > 0 && port < 65536) {
-            return port;
-          }
-        }
-      }
-    } catch {
-    }
-  }
-  return null;
-}
-function getPortFromPackageJson(projectPath) {
-  const packageJsonPath = path14.join(projectPath, "package.json");
-  try {
-    if (!fs13.existsSync(packageJsonPath)) return null;
-    const content = fs13.readFileSync(packageJsonPath, "utf-8");
-    const pkg = JSON.parse(content);
-    const devScript = pkg.scripts?.dev;
-    if (!devScript) return null;
-    const portMatch = devScript.match(/(?:--port[=\s]|-p[=\s])(\d+)/);
-    if (portMatch) {
-      const port = parseInt(portMatch[1], 10);
-      if (port > 0 && port < 65536) {
-        return port;
-      }
-    }
-    const envMatch = devScript.match(/PORT[=\s](\d+)/);
-    if (envMatch) {
-      const port = parseInt(envMatch[1], 10);
-      if (port > 0 && port < 65536) {
-        return port;
-      }
-    }
-  } catch {
-  }
-  return null;
-}
-
-// src/daemon/worktree-manager.ts
-var fs14 = __toESM(require("fs"));
-var path15 = __toESM(require("path"));
 var import_core10 = __toESM(require_dist());
 function validateModuleUid(moduleUid) {
   if (!moduleUid || typeof moduleUid !== "string" || !moduleUid.trim()) {
@@ -6671,8 +6646,8 @@ var WorktreeManager = class _WorktreeManager {
     // ============================================================
     this.lockPath = "";
     this.projectRoot = projectRoot;
-    this.bareRepoPath = path15.join(projectRoot, ".bare");
-    this.configPath = path15.join(projectRoot, ".episoda", "config.json");
+    this.bareRepoPath = path14.join(projectRoot, ".bare");
+    this.configPath = path14.join(projectRoot, ".episoda", "config.json");
     this.gitExecutor = new import_core10.GitExecutor();
   }
   /**
@@ -6681,10 +6656,10 @@ var WorktreeManager = class _WorktreeManager {
    * @returns true if valid project, false otherwise
    */
   async initialize() {
-    if (!fs14.existsSync(this.bareRepoPath)) {
+    if (!fs13.existsSync(this.bareRepoPath)) {
       return false;
     }
-    if (!fs14.existsSync(this.configPath)) {
+    if (!fs13.existsSync(this.configPath)) {
       return false;
     }
     try {
@@ -6731,8 +6706,8 @@ var WorktreeManager = class _WorktreeManager {
    */
   static async createProject(projectRoot, repoUrl, projectId, workspaceSlug, projectSlug) {
     const manager = new _WorktreeManager(projectRoot);
-    const episodaDir = path15.join(projectRoot, ".episoda");
-    fs14.mkdirSync(episodaDir, { recursive: true });
+    const episodaDir = path14.join(projectRoot, ".episoda");
+    fs13.mkdirSync(episodaDir, { recursive: true });
     const cloneResult = await manager.gitExecutor.execute({
       action: "clone_bare",
       url: repoUrl,
@@ -6763,7 +6738,7 @@ var WorktreeManager = class _WorktreeManager {
         error: `Invalid module UID: "${moduleUid}" - contains disallowed characters`
       };
     }
-    const worktreePath = path15.join(this.projectRoot, moduleUid);
+    const worktreePath = path14.join(this.projectRoot, moduleUid);
     const lockAcquired = await this.acquireLock();
     if (!lockAcquired) {
       return {
@@ -6863,14 +6838,21 @@ var WorktreeManager = class _WorktreeManager {
           error: result.output || "Failed to remove worktree"
         };
       }
-      const config = this.readConfig();
-      if (config) {
-        config.worktrees = config.worktrees.filter((w) => w.moduleUid !== moduleUid);
-        this.writeConfig(config);
+      let configUpdated = false;
+      try {
+        const config = this.readConfig();
+        if (config) {
+          config.worktrees = config.worktrees.filter((w) => w.moduleUid !== moduleUid);
+          this.writeConfig(config);
+          configUpdated = true;
+        }
+      } catch (configError) {
+        console.warn(`[WorktreeManager] EP1035: Config update failed after removing ${moduleUid} (non-blocking):`, configError.message);
       }
       return {
         success: true,
-        worktreePath: existing.worktreePath
+        worktreePath: existing.worktreePath,
+        configUpdated
       };
     } finally {
       this.releaseLock();
@@ -6945,7 +6927,7 @@ var WorktreeManager = class _WorktreeManager {
     let prunedCount = 0;
     await this.updateConfigSafe((config) => {
       const initialCount = config.worktrees.length;
-      config.worktrees = config.worktrees.filter((w) => fs14.existsSync(w.worktreePath));
+      config.worktrees = config.worktrees.filter((w) => fs13.existsSync(w.worktreePath));
       prunedCount = initialCount - config.worktrees.length;
       return config;
     });
@@ -7026,16 +7008,16 @@ var WorktreeManager = class _WorktreeManager {
     const retryInterval = 50;
     while (Date.now() - startTime < timeoutMs) {
       try {
-        fs14.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+        fs13.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
         return true;
       } catch (err) {
         if (err.code === "EEXIST") {
           try {
-            const stats = fs14.statSync(lockPath);
+            const stats = fs13.statSync(lockPath);
             const lockAge = Date.now() - stats.mtimeMs;
             if (lockAge > 3e4) {
               try {
-                const lockContent = fs14.readFileSync(lockPath, "utf-8").trim();
+                const lockContent = fs13.readFileSync(lockPath, "utf-8").trim();
                 const lockPid = parseInt(lockContent, 10);
                 if (!isNaN(lockPid) && this.isProcessRunning(lockPid)) {
                   await new Promise((resolve3) => setTimeout(resolve3, retryInterval));
@@ -7044,7 +7026,7 @@ var WorktreeManager = class _WorktreeManager {
               } catch {
               }
               try {
-                fs14.unlinkSync(lockPath);
+                fs13.unlinkSync(lockPath);
               } catch {
               }
               continue;
@@ -7065,29 +7047,34 @@ var WorktreeManager = class _WorktreeManager {
    */
   releaseLock() {
     try {
-      fs14.unlinkSync(this.getLockPath());
+      fs13.unlinkSync(this.getLockPath());
     } catch {
     }
   }
   readConfig() {
     try {
-      if (!fs14.existsSync(this.configPath)) {
+      if (!fs13.existsSync(this.configPath)) {
         return null;
       }
-      const content = fs14.readFileSync(this.configPath, "utf-8");
+      const content = fs13.readFileSync(this.configPath, "utf-8");
       return JSON.parse(content);
     } catch (error) {
-      console.error("[WorktreeManager] Failed to read config:", error);
+      if (error instanceof SyntaxError) {
+        console.warn(`[WorktreeManager] EP1035: Config file corrupted at ${this.configPath} - JSON parse error:`, error.message);
+        console.warn("[WorktreeManager] EP1035: Config will be recovered on next pruneStaleWorktrees call");
+      } else {
+        console.error("[WorktreeManager] Failed to read config:", error.message);
+      }
       return null;
     }
   }
   writeConfig(config) {
     try {
-      const dir = path15.dirname(this.configPath);
-      if (!fs14.existsSync(dir)) {
-        fs14.mkdirSync(dir, { recursive: true });
+      const dir = path14.dirname(this.configPath);
+      if (!fs13.existsSync(dir)) {
+        fs13.mkdirSync(dir, { recursive: true });
       }
-      fs14.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf-8");
+      fs13.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf-8");
     } catch (error) {
       console.error("[WorktreeManager] Failed to write config:", error);
       throw error;
@@ -7168,14 +7155,14 @@ var WorktreeManager = class _WorktreeManager {
     }
     try {
       for (const file of files) {
-        const srcPath = path15.join(mainWorktree.worktreePath, file);
-        const destPath = path15.join(worktree.worktreePath, file);
-        if (fs14.existsSync(srcPath)) {
-          const destDir = path15.dirname(destPath);
-          if (!fs14.existsSync(destDir)) {
-            fs14.mkdirSync(destDir, { recursive: true });
-          }
-          fs14.copyFileSync(srcPath, destPath);
+        const srcPath = path14.join(mainWorktree.worktreePath, file);
+        const destPath = path14.join(worktree.worktreePath, file);
+        if (fs13.existsSync(srcPath)) {
+          const destDir = path14.dirname(destPath);
+          if (!fs13.existsSync(destDir)) {
+            fs13.mkdirSync(destDir, { recursive: true });
+          }
+          fs13.copyFileSync(srcPath, destPath);
           console.log(`[WorktreeManager] EP964: Copied ${file} to ${moduleUid} (deprecated)`);
         } else {
           console.log(`[WorktreeManager] EP964: Skipped ${file} (not found in main)`);
@@ -7258,27 +7245,27 @@ var WorktreeManager = class _WorktreeManager {
   }
 };
 function getEpisodaRoot() {
-  return process.env.EPISODA_ROOT || path15.join(require("os").homedir(), "episoda");
+  return process.env.EPISODA_ROOT || path14.join(require("os").homedir(), "episoda");
 }
 async function isWorktreeProject(projectRoot) {
   const manager = new WorktreeManager(projectRoot);
   return manager.initialize();
 }
 async function findProjectRoot(startPath) {
-  let current = path15.resolve(startPath);
+  let current = path14.resolve(startPath);
   const episodaRoot = getEpisodaRoot();
   if (!current.startsWith(episodaRoot)) {
     return null;
   }
   for (let i = 0; i < 10; i++) {
-    const bareDir = path15.join(current, ".bare");
-    const episodaDir = path15.join(current, ".episoda");
-    if (fs14.existsSync(bareDir) && fs14.existsSync(episodaDir)) {
+    const bareDir = path14.join(current, ".bare");
+    const episodaDir = path14.join(current, ".episoda");
+    if (fs13.existsSync(bareDir) && fs13.existsSync(episodaDir)) {
       if (await isWorktreeProject(current)) {
         return current;
       }
     }
-    const parent = path15.dirname(current);
+    const parent = path14.dirname(current);
     if (parent === current) {
       break;
     }
@@ -7288,19 +7275,19 @@ async function findProjectRoot(startPath) {
 }
 
 // src/utils/worktree.ts
-var path16 = __toESM(require("path"));
-var fs15 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
 var os5 = __toESM(require("os"));
 var import_core11 = __toESM(require_dist());
 function getEpisodaRoot2() {
-  return process.env.EPISODA_ROOT || path16.join(os5.homedir(), "episoda");
+  return process.env.EPISODA_ROOT || path15.join(os5.homedir(), "episoda");
 }
 function getWorktreeInfo(moduleUid, workspaceSlug, projectSlug) {
   const root = getEpisodaRoot2();
-  const worktreePath = path16.join(root, workspaceSlug, projectSlug, moduleUid);
+  const worktreePath = path15.join(root, workspaceSlug, projectSlug, moduleUid);
   return {
     path: worktreePath,
-    exists: fs15.existsSync(worktreePath),
+    exists: fs14.existsSync(worktreePath),
     moduleUid
   };
 }
@@ -7313,72 +7300,62 @@ async function getWorktreeInfoForModule(moduleUid) {
   return getWorktreeInfo(moduleUid, config.workspace_slug, config.project_slug);
 }
 
-// src/utils/port-allocator.ts
-var portAssignments = /* @__PURE__ */ new Map();
-function clearAllPorts() {
-  const count = portAssignments.size;
-  portAssignments.clear();
-  if (count > 0) {
-    console.log(`[PortAllocator] Cleared ${count} port assignments`);
-  }
-}
-
 // src/framework-detector.ts
-var fs16 = __toESM(require("fs"));
-var path17 = __toESM(require("path"));
+var fs15 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
 function getInstallCommand(cwd) {
-  if (fs16.existsSync(path17.join(cwd, "bun.lockb"))) {
+  if (fs15.existsSync(path16.join(cwd, "bun.lockb"))) {
     return {
       command: ["bun", "install"],
       description: "Installing dependencies with bun",
       detectedFrom: "bun.lockb"
     };
   }
-  if (fs16.existsSync(path17.join(cwd, "pnpm-lock.yaml"))) {
+  if (fs15.existsSync(path16.join(cwd, "pnpm-lock.yaml"))) {
     return {
       command: ["pnpm", "install"],
       description: "Installing dependencies with pnpm",
       detectedFrom: "pnpm-lock.yaml"
     };
   }
-  if (fs16.existsSync(path17.join(cwd, "yarn.lock"))) {
+  if (fs15.existsSync(path16.join(cwd, "yarn.lock"))) {
     return {
       command: ["yarn", "install"],
       description: "Installing dependencies with yarn",
       detectedFrom: "yarn.lock"
     };
   }
-  if (fs16.existsSync(path17.join(cwd, "package-lock.json"))) {
+  if (fs15.existsSync(path16.join(cwd, "package-lock.json"))) {
     return {
       command: ["npm", "ci"],
       description: "Installing dependencies with npm ci",
       detectedFrom: "package-lock.json"
     };
   }
-  if (fs16.existsSync(path17.join(cwd, "package.json"))) {
+  if (fs15.existsSync(path16.join(cwd, "package.json"))) {
     return {
       command: ["npm", "install"],
       description: "Installing dependencies with npm",
       detectedFrom: "package.json"
     };
   }
-  if (fs16.existsSync(path17.join(cwd, "Pipfile.lock")) || fs16.existsSync(path17.join(cwd, "Pipfile"))) {
+  if (fs15.existsSync(path16.join(cwd, "Pipfile.lock")) || fs15.existsSync(path16.join(cwd, "Pipfile"))) {
     return {
       command: ["pipenv", "install"],
       description: "Installing dependencies with pipenv",
-      detectedFrom: fs16.existsSync(path17.join(cwd, "Pipfile.lock")) ? "Pipfile.lock" : "Pipfile"
+      detectedFrom: fs15.existsSync(path16.join(cwd, "Pipfile.lock")) ? "Pipfile.lock" : "Pipfile"
     };
   }
-  if (fs16.existsSync(path17.join(cwd, "poetry.lock"))) {
+  if (fs15.existsSync(path16.join(cwd, "poetry.lock"))) {
     return {
       command: ["poetry", "install"],
       description: "Installing dependencies with poetry",
       detectedFrom: "poetry.lock"
     };
   }
-  if (fs16.existsSync(path17.join(cwd, "pyproject.toml"))) {
-    const pyprojectPath = path17.join(cwd, "pyproject.toml");
-    const content = fs16.readFileSync(pyprojectPath, "utf-8");
+  if (fs15.existsSync(path16.join(cwd, "pyproject.toml"))) {
+    const pyprojectPath = path16.join(cwd, "pyproject.toml");
+    const content = fs15.readFileSync(pyprojectPath, "utf-8");
     if (content.includes("[tool.poetry]")) {
       return {
         command: ["poetry", "install"],
@@ -7387,41 +7364,41 @@ function getInstallCommand(cwd) {
       };
     }
   }
-  if (fs16.existsSync(path17.join(cwd, "requirements.txt"))) {
+  if (fs15.existsSync(path16.join(cwd, "requirements.txt"))) {
     return {
       command: ["pip", "install", "-r", "requirements.txt"],
       description: "Installing dependencies with pip",
       detectedFrom: "requirements.txt"
     };
   }
-  if (fs16.existsSync(path17.join(cwd, "Gemfile.lock")) || fs16.existsSync(path17.join(cwd, "Gemfile"))) {
+  if (fs15.existsSync(path16.join(cwd, "Gemfile.lock")) || fs15.existsSync(path16.join(cwd, "Gemfile"))) {
     return {
       command: ["bundle", "install"],
       description: "Installing dependencies with bundler",
-      detectedFrom: fs16.existsSync(path17.join(cwd, "Gemfile.lock")) ? "Gemfile.lock" : "Gemfile"
+      detectedFrom: fs15.existsSync(path16.join(cwd, "Gemfile.lock")) ? "Gemfile.lock" : "Gemfile"
     };
   }
-  if (fs16.existsSync(path17.join(cwd, "go.sum")) || fs16.existsSync(path17.join(cwd, "go.mod"))) {
+  if (fs15.existsSync(path16.join(cwd, "go.sum")) || fs15.existsSync(path16.join(cwd, "go.mod"))) {
     return {
       command: ["go", "mod", "download"],
       description: "Downloading Go modules",
-      detectedFrom: fs16.existsSync(path17.join(cwd, "go.sum")) ? "go.sum" : "go.mod"
+      detectedFrom: fs15.existsSync(path16.join(cwd, "go.sum")) ? "go.sum" : "go.mod"
     };
   }
-  if (fs16.existsSync(path17.join(cwd, "Cargo.lock")) || fs16.existsSync(path17.join(cwd, "Cargo.toml"))) {
+  if (fs15.existsSync(path16.join(cwd, "Cargo.lock")) || fs15.existsSync(path16.join(cwd, "Cargo.toml"))) {
     return {
       command: ["cargo", "build"],
       description: "Building Rust project (downloads dependencies)",
-      detectedFrom: fs16.existsSync(path17.join(cwd, "Cargo.lock")) ? "Cargo.lock" : "Cargo.toml"
+      detectedFrom: fs15.existsSync(path16.join(cwd, "Cargo.lock")) ? "Cargo.lock" : "Cargo.toml"
     };
   }
   return null;
 }
 
 // src/daemon/daemon-process.ts
-var fs17 = __toESM(require("fs"));
+var fs16 = __toESM(require("fs"));
 var os6 = __toESM(require("os"));
-var path18 = __toESM(require("path"));
+var path17 = __toESM(require("path"));
 var packageJson = require_package();
 async function ensureValidToken(config, bufferMs = 5 * 60 * 1e3) {
   const now = Date.now();
@@ -7772,6 +7749,7 @@ var Daemon = class _Daemon {
       }
       await tunnelManager.stopTunnel(moduleUid);
       await stopDevServer(moduleUid);
+      releasePort(moduleUid);
       await clearTunnelUrl(moduleUid);
       this.tunnelHealthFailures.delete(moduleUid);
       console.log(`[Daemon] EP823: Tunnel stopped for ${moduleUid}`);
@@ -7922,7 +7900,7 @@ var Daemon = class _Daemon {
         client.updateActivity();
         try {
           const gitCmd = message.command;
-          const bareRepoPath = path18.join(projectPath, ".bare");
+          const bareRepoPath = path17.join(projectPath, ".bare");
           const cwd = gitCmd.worktreePath || bareRepoPath;
           if (gitCmd.worktreePath) {
             console.log(`[Daemon] Routing command to worktree: ${gitCmd.worktreePath}`);
@@ -8076,7 +8054,8 @@ var Daemon = class _Daemon {
               return;
             }
             console.log(`[Daemon] EP1024: Using worktree path ${worktree.path} for ${cmd.moduleUid}`);
-            const port = cmd.port || detectDevPort(worktree.path);
+            const port = cmd.port || allocatePort(cmd.moduleUid);
+            console.log(`[Daemon] EP1038: Allocated port ${port} for ${cmd.moduleUid}`);
             const devConfig = await (0, import_core12.loadConfig)();
             const customCommand = devConfig?.project_settings?.worktree_dev_server_script;
             const startResult = await previewManager.startPreview({
@@ -8250,6 +8229,78 @@ var Daemon = class _Daemon {
         }
       }
     });
+    client.on("worktree_cleanup_command", async (message) => {
+      if (message.type === "worktree_cleanup_command" && message.command) {
+        const cmd = message.command;
+        console.log(`[Daemon] EP1035: Received worktree cleanup command for ${cmd.moduleUid}`);
+        client.updateActivity();
+        let result;
+        try {
+          const projectRootPath = await findProjectRoot(cmd.worktreePath);
+          if (!projectRootPath) {
+            console.warn(`[Daemon] EP1035: Cannot find project root for ${cmd.worktreePath}`);
+            result = {
+              success: false,
+              error: `Cannot find project root for worktree path: ${cmd.worktreePath}`
+            };
+          } else {
+            const manager = new WorktreeManager(projectRootPath);
+            const initialized = await manager.initialize();
+            if (!initialized) {
+              console.warn(`[Daemon] EP1035: Failed to initialize WorktreeManager for ${projectRootPath}`);
+              result = {
+                success: false,
+                error: `Failed to initialize WorktreeManager for project: ${projectRootPath}`
+              };
+            } else {
+              const removeResult = await manager.removeWorktree(cmd.moduleUid, cmd.force || false);
+              if (removeResult.success) {
+                if (removeResult.configUpdated === false) {
+                  console.warn(`[Daemon] EP1035: Worktree ${cmd.moduleUid} removed but config update failed (will sync on next prune)`);
+                } else {
+                  console.log(`[Daemon] EP1035: Successfully cleaned up worktree for ${cmd.moduleUid}`);
+                }
+                result = {
+                  success: true,
+                  worktreePath: removeResult.worktreePath
+                };
+              } else {
+                if (removeResult.error?.includes("not found") || removeResult.error?.includes("No worktree found")) {
+                  console.log(`[Daemon] EP1035: Worktree for ${cmd.moduleUid} already removed, syncing config`);
+                  await manager.pruneStaleWorktrees();
+                  result = {
+                    success: true,
+                    worktreePath: cmd.worktreePath
+                  };
+                } else {
+                  console.error(`[Daemon] EP1035: Failed to remove worktree for ${cmd.moduleUid}: ${removeResult.error}`);
+                  result = {
+                    success: false,
+                    error: removeResult.error
+                  };
+                }
+              }
+            }
+          }
+        } catch (error) {
+          console.error(`[Daemon] EP1035: Worktree cleanup error for ${cmd.moduleUid}:`, error);
+          result = {
+            success: false,
+            error: error instanceof Error ? error.message : String(error)
+          };
+        }
+        try {
+          await client.send({
+            type: "worktree_cleanup_result",
+            commandId: message.id,
+            result
+          });
+        } catch (sendError) {
+          console.error(`[Daemon] EP1035: Failed to send cleanup result (WebSocket may be disconnected):`, sendError);
+        }
+        console.log(`[Daemon] EP1035: Worktree cleanup for ${cmd.moduleUid} completed:`, result.success ? "success" : "failed");
+      }
+    });
     client.on("shutdown", async (message) => {
       const shutdownMessage = message;
       const reason = shutdownMessage.reason || "unknown";
@@ -8337,8 +8388,8 @@ var Daemon = class _Daemon {
       let daemonPid;
       try {
         const pidPath = getPidFilePath();
-        if (fs17.existsSync(pidPath)) {
-          const pidStr = fs17.readFileSync(pidPath, "utf-8").trim();
+        if (fs16.existsSync(pidPath)) {
+          const pidStr = fs16.readFileSync(pidPath, "utf-8").trim();
           daemonPid = parseInt(pidStr, 10);
         }
       } catch (pidError) {
@@ -8459,27 +8510,27 @@ var Daemon = class _Daemon {
    */
   async installGitHooks(projectPath) {
     const hooks = ["post-checkout", "pre-commit", "post-commit"];
-    const hooksDir = path18.join(projectPath, ".git", "hooks");
-    if (!fs17.existsSync(hooksDir)) {
+    const hooksDir = path17.join(projectPath, ".git", "hooks");
+    if (!fs16.existsSync(hooksDir)) {
       console.warn(`[Daemon] Hooks directory not found: ${hooksDir}`);
       return;
     }
     for (const hookName of hooks) {
       try {
-        const hookPath = path18.join(hooksDir, hookName);
-        const bundledHookPath = path18.join(__dirname, "..", "hooks", hookName);
-        if (!fs17.existsSync(bundledHookPath)) {
+        const hookPath = path17.join(hooksDir, hookName);
+        const bundledHookPath = path17.join(__dirname, "..", "hooks", hookName);
+        if (!fs16.existsSync(bundledHookPath)) {
           console.warn(`[Daemon] Bundled hook not found: ${bundledHookPath}`);
           continue;
         }
-        const hookContent = fs17.readFileSync(bundledHookPath, "utf-8");
-        if (fs17.existsSync(hookPath)) {
-          const existingContent = fs17.readFileSync(hookPath, "utf-8");
+        const hookContent = fs16.readFileSync(bundledHookPath, "utf-8");
+        if (fs16.existsSync(hookPath)) {
+          const existingContent = fs16.readFileSync(hookPath, "utf-8");
           if (existingContent === hookContent) {
             continue;
           }
         }
-        fs17.writeFileSync(hookPath, hookContent, { mode: 493 });
+        fs16.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);
@@ -9030,14 +9081,36 @@ var Daemon = class _Daemon {
       }
       const { orphaned } = manager.auditWorktrees(activeModuleUids);
       if (orphaned.length > 0) {
-        console.log(`[Daemon] EP957: Found ${orphaned.length} orphaned worktree(s) in ${config.workspaceSlug}/${config.projectSlug}:`);
+        console.log(`[Daemon] EP1035: Found ${orphaned.length} orphaned worktree(s) in ${config.workspaceSlug}/${config.projectSlug}:`);
         for (const w of orphaned) {
           console.log(`  - ${w.moduleUid} (branch: ${w.branchName})`);
         }
-        console.log('[Daemon] EP957: Run "episoda release <module>" to clean up');
+        console.log("[Daemon] EP1035: Auto-cleaning orphaned worktrees...");
+        for (const w of orphaned) {
+          try {
+            const removeResult = await manager.removeWorktree(w.moduleUid, true);
+            if (removeResult.success) {
+              console.log(`[Daemon] EP1035: Cleaned up orphaned worktree ${w.moduleUid}`);
+            } else {
+              if (removeResult.error?.includes("not found") || removeResult.error?.includes("No worktree found")) {
+                console.log(`[Daemon] EP1035: Worktree ${w.moduleUid} already removed, syncing config`);
+                await manager.pruneStaleWorktrees();
+              } else {
+                console.warn(`[Daemon] EP1035: Failed to clean up ${w.moduleUid}: ${removeResult.error}`);
+              }
+            }
+          } catch (cleanupError) {
+            console.warn(`[Daemon] EP1035: Error cleaning up ${w.moduleUid}:`, cleanupError.message);
+          }
+        }
+        try {
+          await manager.pruneStaleWorktrees();
+        } catch (pruneError) {
+          console.warn("[Daemon] EP1035: Failed to prune stale worktrees:", pruneError.message);
+        }
       }
     } catch (error) {
-      console.warn(`[Daemon] EP957: Failed to audit ${projectPath}:`, error);
+      console.warn(`[Daemon] EP1035: Failed to audit ${projectPath}:`, error);
     }
   }
   /**
@@ -9342,8 +9415,8 @@ var Daemon = class _Daemon {
     await this.shutdown();
     try {
       const pidPath = getPidFilePath();
-      if (fs17.existsSync(pidPath)) {
-        fs17.unlinkSync(pidPath);
+      if (fs16.existsSync(pidPath)) {
+        fs16.unlinkSync(pidPath);
         console.log("[Daemon] PID file cleaned up");
       }
     } catch (error) {