episoda 0.2.52 → 0.2.54

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 fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+            const fs19 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
             const rebaseMergePath = `${gitDirPath}/rebase-merge`;
             const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
             try {
-              await fs17.access(rebaseMergePath);
+              await fs19.access(rebaseMergePath);
               inRebase = true;
             } catch {
               try {
-                await fs17.access(rebaseApplyPath);
+                await fs19.access(rebaseApplyPath);
                 inRebase = true;
               } catch {
                 inRebase = false;
@@ -1625,9 +1625,9 @@ var require_git_executor = __commonJS({
               error: validation.error || "UNKNOWN_ERROR"
             };
           }
-          const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs19 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs17.access(command.path);
+            await fs19.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 fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs19 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs17.access(command.path);
+            await fs19.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 fs17.rm(command.path, { recursive: true, force: true });
+              await fs19.rm(command.path, { recursive: true, force: true });
             } catch {
             }
             return {
@@ -1852,10 +1852,10 @@ var require_git_executor = __commonJS({
        */
       async executeCloneBare(command, options) {
         try {
-          const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path18 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs19 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path20 = await Promise.resolve().then(() => __importStar(require("path")));
           try {
-            await fs17.access(command.path);
+            await fs19.access(command.path);
             return {
               success: false,
               error: "BRANCH_ALREADY_EXISTS",
@@ -1864,9 +1864,9 @@ var require_git_executor = __commonJS({
             };
           } catch {
           }
-          const parentDir = path18.dirname(command.path);
+          const parentDir = path20.dirname(command.path);
           try {
-            await fs17.mkdir(parentDir, { recursive: true });
+            await fs19.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 fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path18 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs19 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path20 = await Promise.resolve().then(() => __importStar(require("path")));
           let currentPath = cwd;
           let projectPath = cwd;
           let bareRepoPath;
           for (let i = 0; i < 10; i++) {
-            const bareDir = path18.join(currentPath, ".bare");
-            const episodaDir = path18.join(currentPath, ".episoda");
+            const bareDir = path20.join(currentPath, ".bare");
+            const episodaDir = path20.join(currentPath, ".episoda");
             try {
-              await fs17.access(bareDir);
-              await fs17.access(episodaDir);
+              await fs19.access(bareDir);
+              await fs19.access(episodaDir);
               projectPath = currentPath;
               bareRepoPath = bareDir;
               break;
             } catch {
-              const parentPath = path18.dirname(currentPath);
+              const parentPath = path20.dirname(currentPath);
               if (parentPath === currentPath) {
                 break;
               }
@@ -2538,31 +2538,31 @@ var require_auth = __commonJS({
     exports2.loadConfig = loadConfig7;
     exports2.saveConfig = saveConfig2;
     exports2.validateToken = validateToken;
-    var fs17 = __importStar(require("fs"));
-    var path18 = __importStar(require("path"));
-    var os7 = __importStar(require("os"));
+    var fs19 = __importStar(require("fs"));
+    var path20 = __importStar(require("path"));
+    var os9 = __importStar(require("os"));
     var child_process_1 = require("child_process");
     var DEFAULT_CONFIG_FILE = "config.json";
     function getConfigDir8() {
-      return process.env.EPISODA_CONFIG_DIR || path18.join(os7.homedir(), ".episoda");
+      return process.env.EPISODA_CONFIG_DIR || path20.join(os9.homedir(), ".episoda");
     }
     function getConfigPath(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path18.join(getConfigDir8(), DEFAULT_CONFIG_FILE);
+      return path20.join(getConfigDir8(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path18.dirname(configPath);
-      const isNew = !fs17.existsSync(dir);
+      const dir = path20.dirname(configPath);
+      const isNew = !fs19.existsSync(dir);
       if (isNew) {
-        fs17.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs19.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path18.join(dir, ".nosync");
-        if (isNew || !fs17.existsSync(nosyncPath)) {
+        const nosyncPath = path20.join(dir, ".nosync");
+        if (isNew || !fs19.existsSync(nosyncPath)) {
           try {
-            fs17.writeFileSync(nosyncPath, "", { mode: 384 });
+            fs19.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 (fs17.existsSync(fullPath)) {
+      if (fs19.existsSync(fullPath)) {
         try {
-          const content = fs17.readFileSync(fullPath, "utf8");
+          const content = fs19.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);
-        fs17.writeFileSync(fullPath, content, { mode: 384 });
+        fs19.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.52",
+      version: "0.2.54",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -5272,10 +5272,10 @@ var import_events3 = require("events");
 var import_fs = require("fs");
 
 // src/preview/dev-server-runner.ts
-var import_child_process9 = require("child_process");
+var import_child_process10 = require("child_process");
 var http = __toESM(require("http"));
-var fs11 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var fs12 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
 var import_events2 = require("events");
 var import_core8 = __toESM(require_dist());
 
@@ -5450,6 +5450,296 @@ No cached values available as fallback.`
   }
 }
 
+// src/preview/dev-server-registry.ts
+var fs11 = __toESM(require("fs"));
+var path12 = __toESM(require("path"));
+var os5 = __toESM(require("os"));
+var import_child_process9 = require("child_process");
+var DEV_SERVER_REGISTRY_DIR = path12.join(os5.homedir(), ".episoda", "dev-servers");
+var DevServerRegistry = class {
+  constructor() {
+    this.ensureRegistryDir();
+  }
+  /**
+   * Ensure the registry directory exists
+   */
+  ensureRegistryDir() {
+    try {
+      if (!fs11.existsSync(DEV_SERVER_REGISTRY_DIR)) {
+        console.log(`[DevServerRegistry] EP1042: Creating registry directory: ${DEV_SERVER_REGISTRY_DIR}`);
+        fs11.mkdirSync(DEV_SERVER_REGISTRY_DIR, { recursive: true });
+      }
+    } catch (error) {
+      console.error(`[DevServerRegistry] EP1042: Failed to create registry directory:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Get the registry file path for a module
+   */
+  getEntryPath(moduleUid) {
+    return path12.join(DEV_SERVER_REGISTRY_DIR, `${moduleUid}.json`);
+  }
+  /**
+   * Register a dev server
+   *
+   * @param entry - Dev server entry to register
+   */
+  register(entry) {
+    try {
+      this.ensureRegistryDir();
+      const entryPath = this.getEntryPath(entry.moduleUid);
+      fs11.writeFileSync(entryPath, JSON.stringify(entry, null, 2), "utf8");
+      console.log(`[DevServerRegistry] EP1042: Registered ${entry.moduleUid} (PID ${entry.pid}, port ${entry.port})`);
+    } catch (error) {
+      console.error(`[DevServerRegistry] EP1042: Failed to register ${entry.moduleUid}:`, error);
+    }
+  }
+  /**
+   * Unregister a dev server
+   *
+   * @param moduleUid - Module UID to unregister
+   */
+  unregister(moduleUid) {
+    try {
+      const entryPath = this.getEntryPath(moduleUid);
+      if (fs11.existsSync(entryPath)) {
+        fs11.unlinkSync(entryPath);
+        console.log(`[DevServerRegistry] EP1042: Unregistered ${moduleUid}`);
+      }
+    } catch (error) {
+      console.error(`[DevServerRegistry] EP1042: Failed to unregister ${moduleUid}:`, error);
+    }
+  }
+  /**
+   * Get a dev server entry by module UID
+   *
+   * @param moduleUid - Module UID to look up
+   * @returns Entry if found and valid, null otherwise
+   */
+  getByModule(moduleUid) {
+    try {
+      const entryPath = this.getEntryPath(moduleUid);
+      if (!fs11.existsSync(entryPath)) {
+        return null;
+      }
+      const content = fs11.readFileSync(entryPath, "utf8");
+      const entry = JSON.parse(content);
+      if (!entry.pid || !entry.port || !entry.worktreePath) {
+        console.warn(`[DevServerRegistry] EP1042: Invalid entry for ${moduleUid}, removing`);
+        this.unregister(moduleUid);
+        return null;
+      }
+      if (!this.isProcessRunning(entry.pid)) {
+        console.log(`[DevServerRegistry] EP1042: PID ${entry.pid} for ${moduleUid} is not running, removing stale entry`);
+        this.unregister(moduleUid);
+        return null;
+      }
+      return entry;
+    } catch (error) {
+      console.warn(`[DevServerRegistry] EP1042: Failed to read entry for ${moduleUid}:`, error);
+      this.unregister(moduleUid);
+      return null;
+    }
+  }
+  /**
+   * Get a dev server entry by port
+   *
+   * @param port - Port to look up
+   * @returns Entry if found, null otherwise
+   */
+  getByPort(port) {
+    const entries = this.getAll();
+    return entries.find((e) => e.port === port) || null;
+  }
+  /**
+   * Get all registered dev server entries
+   *
+   * @returns Array of valid entries
+   */
+  getAll() {
+    const entries = [];
+    try {
+      this.ensureRegistryDir();
+      const files = fs11.readdirSync(DEV_SERVER_REGISTRY_DIR).filter((f) => f.endsWith(".json"));
+      for (const file of files) {
+        const moduleUid = file.replace(".json", "");
+        const entry = this.getByModule(moduleUid);
+        if (entry) {
+          entries.push(entry);
+        }
+      }
+    } catch (error) {
+      console.error(`[DevServerRegistry] EP1042: Failed to read registry:`, error);
+    }
+    return entries;
+  }
+  /**
+   * Check if a process is running by PID
+   */
+  isProcessRunning(pid) {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Kill a process by PID
+   *
+   * @param pid - Process ID to kill
+   * @param signal - Signal to send (default: SIGTERM)
+   * @returns True if signal was sent
+   */
+  killProcess(pid, signal = "SIGTERM") {
+    try {
+      process.kill(pid, signal);
+      console.log(`[DevServerRegistry] EP1042: Sent ${signal} to PID ${pid}`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get the working directory of a process by PID
+   *
+   * @param pid - Process ID
+   * @returns Working directory or null
+   */
+  getProcessCwd(pid) {
+    try {
+      const output = (0, import_child_process9.execSync)(`lsof -p ${pid} -Fn | grep ^n | grep cwd | head -1`, {
+        encoding: "utf8",
+        timeout: 5e3
+      }).trim();
+      if (output.startsWith("n")) {
+        return output.slice(1);
+      }
+      return null;
+    } catch {
+      try {
+        return fs11.readlinkSync(`/proc/${pid}/cwd`);
+      } catch {
+        return null;
+      }
+    }
+  }
+  /**
+   * Find node processes running in a specific directory
+   *
+   * @param worktreePath - Path to search for
+   * @returns Array of PIDs
+   */
+  findProcessesInWorktree(worktreePath) {
+    const pids = [];
+    try {
+      const output = (0, import_child_process9.execSync)(
+        `lsof -c node -c next | grep "${worktreePath}" | awk '{print $2}' | sort -u`,
+        { encoding: "utf8", timeout: 5e3 }
+      ).trim();
+      if (output) {
+        for (const line of output.split("\n")) {
+          const pid = parseInt(line, 10);
+          if (!isNaN(pid) && pid > 0) {
+            pids.push(pid);
+          }
+        }
+      }
+    } catch {
+    }
+    return [...new Set(pids)];
+  }
+  /**
+   * Clean up orphaned dev servers
+   *
+   * An orphan is a dev server whose:
+   * - PID is no longer running
+   * - Module is not in doing/review state
+   * - Worktree no longer exists
+   *
+   * @param activeModuleUids - UIDs of modules in doing/review state
+   * @returns Cleanup stats
+   */
+  async cleanupOrphans(activeModuleUids) {
+    const cleaned = [];
+    try {
+      const entries = this.getAll();
+      for (const entry of entries) {
+        if (!activeModuleUids.includes(entry.moduleUid)) {
+          console.log(`[DevServerRegistry] EP1042: Module ${entry.moduleUid} not active, cleaning up PID ${entry.pid}`);
+          if (this.isProcessRunning(entry.pid)) {
+            this.killProcess(entry.pid, "SIGTERM");
+            await this.wait(1e3);
+            if (this.isProcessRunning(entry.pid)) {
+              this.killProcess(entry.pid, "SIGKILL");
+            }
+            cleaned.push(entry.pid);
+          }
+          this.unregister(entry.moduleUid);
+        }
+      }
+      if (cleaned.length > 0) {
+        console.log(`[DevServerRegistry] EP1042: Cleaned up ${cleaned.length} orphaned dev server(s): ${cleaned.join(", ")}`);
+      }
+    } catch (error) {
+      console.error(`[DevServerRegistry] EP1042: Error during orphan cleanup:`, error);
+    }
+    return { cleaned: cleaned.length, pids: cleaned };
+  }
+  /**
+   * Find processes on a specific port
+   *
+   * @param port - Port to check
+   * @returns Array of PIDs
+   */
+  findProcessesOnPort(port) {
+    try {
+      const output = (0, import_child_process9.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
+      if (!output) {
+        return [];
+      }
+      return output.split("\n").map((pid) => parseInt(pid, 10)).filter((pid) => !isNaN(pid));
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Kill all processes on a specific port
+   *
+   * @param port - Port to clear
+   * @returns PIDs that were killed
+   */
+  async killProcessesOnPort(port) {
+    const pids = this.findProcessesOnPort(port);
+    const killed = [];
+    for (const pid of pids) {
+      this.killProcess(pid, "SIGTERM");
+      killed.push(pid);
+    }
+    if (killed.length > 0) {
+      await this.wait(1e3);
+      for (const pid of killed) {
+        if (this.isProcessRunning(pid)) {
+          this.killProcess(pid, "SIGKILL");
+        }
+      }
+      console.log(`[DevServerRegistry] EP1042: Killed ${killed.length} process(es) on port ${port}`);
+    }
+    return killed;
+  }
+  wait(ms) {
+    return new Promise((resolve3) => setTimeout(resolve3, ms));
+  }
+};
+var registryInstance = null;
+function getDevServerRegistry() {
+  if (!registryInstance) {
+    registryInstance = new DevServerRegistry();
+  }
+  return registryInstance;
+}
+
 // src/preview/dev-server-runner.ts
 var DevServerRunner = class extends import_events2.EventEmitter {
   constructor() {
@@ -5458,6 +5748,9 @@ var DevServerRunner = class extends import_events2.EventEmitter {
   }
   /**
    * Start a dev server for a module
+   *
+   * EP1042: Now validates worktree ownership when port is already in use.
+   * If a different worktree's server is on the port, it kills and restarts.
    */
   async start(config) {
     const {
@@ -5467,9 +5760,26 @@ var DevServerRunner = class extends import_events2.EventEmitter {
       customCommand,
       autoRestart = true
     } = config;
+    const registry = getDevServerRegistry();
     if (await isPortInUse(port)) {
-      console.log(`[DevServerRunner] Server already running on port ${port}`);
-      return { success: true, alreadyRunning: true };
+      const existingEntry = registry.getByPort(port);
+      if (existingEntry) {
+        if (existingEntry.worktreePath === projectPath && existingEntry.moduleUid === moduleUid) {
+          console.log(`[DevServerRunner] EP1042: Correct server already running on port ${port} for ${moduleUid}`);
+          return { success: true, alreadyRunning: true };
+        }
+        console.log(`[DevServerRunner] EP1042: Port ${port} owned by ${existingEntry.moduleUid} (${existingEntry.worktreePath}), killing...`);
+        await this.killProcessOnPort(port);
+        registry.unregister(existingEntry.moduleUid);
+        this.servers.delete(existingEntry.moduleUid);
+      } else {
+        console.log(`[DevServerRunner] EP1042: Unknown process on port ${port}, killing...`);
+        await this.killProcessOnPort(port);
+      }
+      await this.wait(1e3);
+      if (await isPortInUse(port)) {
+        return { success: false, error: `Port ${port} still in use after cleanup` };
+      }
     }
     const existing = this.servers.get(moduleUid);
     if (existing && !existing.process.killed) {
@@ -5505,6 +5815,15 @@ var DevServerRunner = class extends import_events2.EventEmitter {
         this.writeToLog(logPath, "Failed to start within timeout", true);
         return { success: false, error: "Dev server failed to start within timeout" };
       }
+      if (process2.pid) {
+        registry.register({
+          pid: process2.pid,
+          port,
+          worktreePath: projectPath,
+          startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          moduleUid
+        });
+      }
       console.log(`[DevServerRunner] Server started successfully on port ${port}`);
       this.writeToLog(logPath, "Server started successfully");
       this.emit("started", moduleUid, port);
@@ -5517,23 +5836,39 @@ var DevServerRunner = class extends import_events2.EventEmitter {
   }
   /**
    * Stop a dev server
+   *
+   * EP1042: Now also unregisters from persistent registry.
    */
   async stop(moduleUid) {
     const state = this.servers.get(moduleUid);
-    if (!state) {
+    const registry = getDevServerRegistry();
+    const registryEntry = registry.getByModule(moduleUid);
+    if (!state && !registryEntry) {
       return;
     }
-    state.autoRestartEnabled = false;
-    if (!state.process.killed) {
-      console.log(`[DevServerRunner] Stopping server for ${moduleUid}`);
-      this.writeToLog(state.logFile, "Stopping server (manual stop)");
-      state.process.kill("SIGTERM");
-      await this.wait(2e3);
+    if (state) {
+      state.autoRestartEnabled = false;
       if (!state.process.killed) {
-        state.process.kill("SIGKILL");
+        console.log(`[DevServerRunner] Stopping server for ${moduleUid}`);
+        this.writeToLog(state.logFile, "Stopping server (manual stop)");
+        state.process.kill("SIGTERM");
+        await this.wait(2e3);
+        if (!state.process.killed) {
+          state.process.kill("SIGKILL");
+        }
+      }
+    } else if (registryEntry) {
+      console.log(`[DevServerRunner] EP1042: Stopping orphaned server for ${moduleUid} (PID ${registryEntry.pid})`);
+      if (registry.isProcessRunning(registryEntry.pid)) {
+        registry.killProcess(registryEntry.pid, "SIGTERM");
+        await this.wait(2e3);
+        if (registry.isProcessRunning(registryEntry.pid)) {
+          registry.killProcess(registryEntry.pid, "SIGKILL");
+        }
       }
     }
     this.servers.delete(moduleUid);
+    registry.unregister(moduleUid);
     this.emit("stopped", moduleUid);
   }
   /**
@@ -5614,7 +5949,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
    */
   async killProcessOnPort(port) {
     try {
-      const result = (0, import_child_process9.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
+      const result = (0, import_child_process10.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
       if (!result) {
         return true;
       }
@@ -5622,15 +5957,15 @@ var DevServerRunner = class extends import_events2.EventEmitter {
       console.log(`[DevServerRunner] Found ${pids.length} process(es) on port ${port}`);
       for (const pid of pids) {
         try {
-          (0, import_child_process9.execSync)(`kill -15 ${pid} 2>/dev/null || true`);
+          (0, import_child_process10.execSync)(`kill -15 ${pid} 2>/dev/null || true`);
         } catch {
         }
       }
       await this.wait(1e3);
       for (const pid of pids) {
         try {
-          (0, import_child_process9.execSync)(`kill -0 ${pid} 2>/dev/null`);
-          (0, import_child_process9.execSync)(`kill -9 ${pid} 2>/dev/null || true`);
+          (0, import_child_process10.execSync)(`kill -0 ${pid} 2>/dev/null`);
+          (0, import_child_process10.execSync)(`kill -9 ${pid} 2>/dev/null || true`);
         } catch {
         }
       }
@@ -5654,8 +5989,8 @@ var DevServerRunner = class extends import_events2.EventEmitter {
         cacheTtl: 300
       });
       console.log(`[DevServerRunner] Loaded ${Object.keys(result.envVars).length} env vars`);
-      const envFilePath = path12.join(projectPath, ".env");
-      if (!fs11.existsSync(envFilePath) && Object.keys(result.envVars).length > 0) {
+      const envFilePath = path13.join(projectPath, ".env");
+      if (!fs12.existsSync(envFilePath) && Object.keys(result.envVars).length > 0) {
         console.log(`[DevServerRunner] Writing .env file`);
         writeEnvFile(projectPath, result.envVars);
       }
@@ -5679,7 +6014,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
       PORT: String(port),
       NODE_OPTIONS: enhancedNodeOptions
     };
-    const proc = (0, import_child_process9.spawn)(cmd, args, {
+    const proc = (0, import_child_process10.spawn)(cmd, args, {
       cwd: projectPath,
       env: mergedEnv,
       stdio: ["ignore", "pipe", "pipe"],
@@ -5804,25 +6139,25 @@ var DevServerRunner = class extends import_events2.EventEmitter {
     return new Promise((resolve3) => setTimeout(resolve3, ms));
   }
   getLogsDir() {
-    const logsDir = path12.join((0, import_core8.getConfigDir)(), "logs");
-    if (!fs11.existsSync(logsDir)) {
-      fs11.mkdirSync(logsDir, { recursive: true });
+    const logsDir = path13.join((0, import_core8.getConfigDir)(), "logs");
+    if (!fs12.existsSync(logsDir)) {
+      fs12.mkdirSync(logsDir, { recursive: true });
     }
     return logsDir;
   }
   getLogFilePath(moduleUid) {
-    return path12.join(this.getLogsDir(), `dev-${moduleUid}.log`);
+    return path13.join(this.getLogsDir(), `dev-${moduleUid}.log`);
   }
   rotateLogIfNeeded(logPath) {
     try {
-      if (fs11.existsSync(logPath)) {
-        const stats = fs11.statSync(logPath);
+      if (fs12.existsSync(logPath)) {
+        const stats = fs12.statSync(logPath);
         if (stats.size > DEV_SERVER_CONSTANTS.MAX_LOG_SIZE_BYTES) {
           const backupPath = `${logPath}.1`;
-          if (fs11.existsSync(backupPath)) {
-            fs11.unlinkSync(backupPath);
+          if (fs12.existsSync(backupPath)) {
+            fs12.unlinkSync(backupPath);
           }
-          fs11.renameSync(logPath, backupPath);
+          fs12.renameSync(logPath, backupPath);
         }
       }
     } catch {
@@ -5833,7 +6168,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
     try {
       const timestamp = (/* @__PURE__ */ new Date()).toISOString();
       const prefix = isError ? "ERR" : "OUT";
-      fs11.appendFileSync(logPath, `[${timestamp}] [${prefix}] ${line}
+      fs12.appendFileSync(logPath, `[${timestamp}] [${prefix}] ${line}
 `);
     } catch {
     }
@@ -5861,13 +6196,55 @@ function getDevServerRunner() {
 }
 
 // src/utils/port-allocator.ts
+var fs13 = __toESM(require("fs"));
+var path14 = __toESM(require("path"));
+var os6 = __toESM(require("os"));
 var PORT_RANGE_START = 3100;
 var PORT_RANGE_END = 3199;
 var PORT_WARNING_THRESHOLD = 80;
+var PORTS_FILE = path14.join(os6.homedir(), ".episoda", "ports.json");
 var portAssignments = /* @__PURE__ */ new Map();
+var initialized = false;
+function loadFromDisk() {
+  if (initialized) return;
+  initialized = true;
+  try {
+    if (fs13.existsSync(PORTS_FILE)) {
+      const content = fs13.readFileSync(PORTS_FILE, "utf8");
+      const data = JSON.parse(content);
+      for (const [moduleUid, port] of Object.entries(data)) {
+        if (typeof port === "number" && port >= PORT_RANGE_START && port <= PORT_RANGE_END) {
+          portAssignments.set(moduleUid, port);
+        }
+      }
+      if (portAssignments.size > 0) {
+        console.log(`[PortAllocator] EP1042: Loaded ${portAssignments.size} port assignments from disk`);
+      }
+    }
+  } catch (error) {
+    console.warn(`[PortAllocator] EP1042: Failed to load ports.json:`, error);
+  }
+}
+function saveToDisk() {
+  try {
+    const dir = path14.dirname(PORTS_FILE);
+    if (!fs13.existsSync(dir)) {
+      fs13.mkdirSync(dir, { recursive: true });
+    }
+    const data = {};
+    for (const [moduleUid, port] of portAssignments) {
+      data[moduleUid] = port;
+    }
+    fs13.writeFileSync(PORTS_FILE, JSON.stringify(data, null, 2), "utf8");
+  } catch (error) {
+    console.warn(`[PortAllocator] EP1042: Failed to save ports.json:`, error);
+  }
+}
 function allocatePort(moduleUid) {
+  loadFromDisk();
   const existing = portAssignments.get(moduleUid);
   if (existing) {
+    console.log(`[PortAllocator] EP1042: Returning existing port ${existing} for ${moduleUid}`);
     return existing;
   }
   const usedPorts = new Set(portAssignments.values());
@@ -5879,7 +6256,8 @@ function allocatePort(moduleUid) {
   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}`);
+      saveToDisk();
+      console.log(`[PortAllocator] EP1042: Allocated port ${port} to ${moduleUid}`);
       return port;
     }
   }
@@ -5888,17 +6266,41 @@ function allocatePort(moduleUid) {
   );
 }
 function releasePort(moduleUid) {
+  loadFromDisk();
   const port = portAssignments.get(moduleUid);
   if (port) {
     portAssignments.delete(moduleUid);
-    console.log(`[PortAllocator] Released port ${port} from ${moduleUid}`);
+    saveToDisk();
+    console.log(`[PortAllocator] EP1042: Released port ${port} from ${moduleUid}`);
   }
 }
 function clearAllPorts() {
   const count = portAssignments.size;
   portAssignments.clear();
+  saveToDisk();
   if (count > 0) {
-    console.log(`[PortAllocator] Cleared ${count} port assignments`);
+    console.log(`[PortAllocator] EP1042: Cleared ${count} port assignments`);
+  }
+}
+function reconcileWithRegistry(activeModules) {
+  loadFromDisk();
+  let changed = false;
+  for (const [moduleUid, port] of portAssignments) {
+    if (!activeModules.has(moduleUid)) {
+      console.log(`[PortAllocator] EP1042: Removing stale allocation ${moduleUid} -> ${port}`);
+      portAssignments.delete(moduleUid);
+      changed = true;
+    }
+  }
+  for (const [moduleUid, port] of activeModules) {
+    if (!portAssignments.has(moduleUid)) {
+      console.log(`[PortAllocator] EP1042: Adding allocation from registry ${moduleUid} -> ${port}`);
+      portAssignments.set(moduleUid, port);
+      changed = true;
+    }
+  }
+  if (changed) {
+    saveToDisk();
   }
 }
 
@@ -6292,10 +6694,10 @@ function getPreviewManager() {
 }
 
 // src/utils/dev-server.ts
-var import_child_process10 = require("child_process");
+var import_child_process11 = require("child_process");
 var import_core9 = __toESM(require_dist());
-var fs12 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
 var MAX_RESTART_ATTEMPTS = 5;
 var INITIAL_RESTART_DELAY_MS = 2e3;
 var MAX_RESTART_DELAY_MS = 3e4;
@@ -6303,26 +6705,26 @@ var MAX_LOG_SIZE_BYTES = 5 * 1024 * 1024;
 var NODE_MEMORY_LIMIT_MB = 2048;
 var activeServers = /* @__PURE__ */ new Map();
 function getLogsDir() {
-  const logsDir = path13.join((0, import_core9.getConfigDir)(), "logs");
-  if (!fs12.existsSync(logsDir)) {
-    fs12.mkdirSync(logsDir, { recursive: true });
+  const logsDir = path15.join((0, import_core9.getConfigDir)(), "logs");
+  if (!fs14.existsSync(logsDir)) {
+    fs14.mkdirSync(logsDir, { recursive: true });
   }
   return logsDir;
 }
 function getLogFilePath(moduleUid) {
-  return path13.join(getLogsDir(), `dev-${moduleUid}.log`);
+  return path15.join(getLogsDir(), `dev-${moduleUid}.log`);
 }
 function rotateLogIfNeeded(logPath) {
   try {
-    if (fs12.existsSync(logPath)) {
-      const stats = fs12.statSync(logPath);
+    if (fs14.existsSync(logPath)) {
+      const stats = fs14.statSync(logPath);
       if (stats.size > MAX_LOG_SIZE_BYTES) {
         const backupPath = `${logPath}.1`;
-        if (fs12.existsSync(backupPath)) {
-          fs12.unlinkSync(backupPath);
+        if (fs14.existsSync(backupPath)) {
+          fs14.unlinkSync(backupPath);
         }
-        fs12.renameSync(logPath, backupPath);
-        console.log(`[DevServer] EP932: Rotated log file for ${path13.basename(logPath)}`);
+        fs14.renameSync(logPath, backupPath);
+        console.log(`[DevServer] EP932: Rotated log file for ${path15.basename(logPath)}`);
       }
     }
   } catch (error) {
@@ -6335,13 +6737,13 @@ function writeToLog(logPath, line, isError = false) {
     const prefix = isError ? "ERR" : "OUT";
     const logLine = `[${timestamp}] [${prefix}] ${line}
 `;
-    fs12.appendFileSync(logPath, logLine);
+    fs14.appendFileSync(logPath, logLine);
   } catch {
   }
 }
 async function killProcessOnPort(port) {
   try {
-    const result = (0, import_child_process10.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
+    const result = (0, import_child_process11.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
     if (!result) {
       console.log(`[DevServer] EP929: No process found on port ${port}`);
       return true;
@@ -6350,7 +6752,7 @@ async function killProcessOnPort(port) {
     console.log(`[DevServer] EP929: Found ${pids.length} process(es) on port ${port}: ${pids.join(", ")}`);
     for (const pid of pids) {
       try {
-        (0, import_child_process10.execSync)(`kill -15 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
+        (0, import_child_process11.execSync)(`kill -15 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
         console.log(`[DevServer] EP929: Sent SIGTERM to PID ${pid}`);
       } catch {
       }
@@ -6358,8 +6760,8 @@ async function killProcessOnPort(port) {
     await new Promise((resolve3) => setTimeout(resolve3, 1e3));
     for (const pid of pids) {
       try {
-        (0, import_child_process10.execSync)(`kill -0 ${pid} 2>/dev/null`, { encoding: "utf8" });
-        (0, import_child_process10.execSync)(`kill -9 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
+        (0, import_child_process11.execSync)(`kill -0 ${pid} 2>/dev/null`, { encoding: "utf8" });
+        (0, import_child_process11.execSync)(`kill -9 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
         console.log(`[DevServer] EP929: Force killed PID ${pid}`);
       } catch {
       }
@@ -6410,7 +6812,7 @@ function spawnDevServerProcess(projectPath, port, moduleUid, logPath, customComm
   if (injectedCount > 0) {
     console.log(`[DevServer] EP998: Injecting ${injectedCount} env vars from database`);
   }
-  const devProcess = (0, import_child_process10.spawn)(cmd, args, {
+  const devProcess = (0, import_child_process11.spawn)(cmd, args, {
     cwd: projectPath,
     env: mergedEnv,
     stdio: ["ignore", "pipe", "pipe"],
@@ -6514,8 +6916,8 @@ async function startDevServer(projectPath, port = 3e3, moduleUid = "default", op
       });
       injectedEnvVars = result.envVars;
       console.log(`[DevServer] EP998: Loaded ${Object.keys(injectedEnvVars).length} env vars (from ${result.fromCache ? "cache" : "server"})`);
-      const envFilePath = path13.join(projectPath, ".env");
-      if (!fs12.existsSync(envFilePath) && Object.keys(injectedEnvVars).length > 0) {
+      const envFilePath = path15.join(projectPath, ".env");
+      if (!fs14.existsSync(envFilePath) && Object.keys(injectedEnvVars).length > 0) {
         console.log(`[DevServer] EP1004: .env file missing, writing ${Object.keys(injectedEnvVars).length} vars to ${envFilePath}`);
         writeEnvFile(projectPath, injectedEnvVars);
       }
@@ -6621,8 +7023,8 @@ function getDevServerStatus() {
 }
 
 // src/daemon/worktree-manager.ts
-var fs13 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
+var fs15 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
 var import_core10 = __toESM(require_dist());
 function validateModuleUid(moduleUid) {
   if (!moduleUid || typeof moduleUid !== "string" || !moduleUid.trim()) {
@@ -6646,8 +7048,8 @@ var WorktreeManager = class _WorktreeManager {
     // ============================================================
     this.lockPath = "";
     this.projectRoot = projectRoot;
-    this.bareRepoPath = path14.join(projectRoot, ".bare");
-    this.configPath = path14.join(projectRoot, ".episoda", "config.json");
+    this.bareRepoPath = path16.join(projectRoot, ".bare");
+    this.configPath = path16.join(projectRoot, ".episoda", "config.json");
     this.gitExecutor = new import_core10.GitExecutor();
   }
   /**
@@ -6656,10 +7058,10 @@ var WorktreeManager = class _WorktreeManager {
    * @returns true if valid project, false otherwise
    */
   async initialize() {
-    if (!fs13.existsSync(this.bareRepoPath)) {
+    if (!fs15.existsSync(this.bareRepoPath)) {
       return false;
     }
-    if (!fs13.existsSync(this.configPath)) {
+    if (!fs15.existsSync(this.configPath)) {
       return false;
     }
     try {
@@ -6679,10 +7081,10 @@ var WorktreeManager = class _WorktreeManager {
    */
   async ensureFetchRefspecConfigured() {
     try {
-      const { execSync: execSync8 } = require("child_process");
+      const { execSync: execSync9 } = require("child_process");
       let fetchRefspec = null;
       try {
-        fetchRefspec = execSync8("git config --get remote.origin.fetch", {
+        fetchRefspec = execSync9("git config --get remote.origin.fetch", {
           cwd: this.bareRepoPath,
           encoding: "utf-8",
           timeout: 5e3
@@ -6691,7 +7093,7 @@ var WorktreeManager = class _WorktreeManager {
       }
       if (!fetchRefspec) {
         console.log("[WorktreeManager] EP1014: Configuring missing fetch refspec for bare repo");
-        execSync8('git config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"', {
+        execSync9('git config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"', {
           cwd: this.bareRepoPath,
           timeout: 5e3
         });
@@ -6706,8 +7108,8 @@ var WorktreeManager = class _WorktreeManager {
    */
   static async createProject(projectRoot, repoUrl, projectId, workspaceSlug, projectSlug) {
     const manager = new _WorktreeManager(projectRoot);
-    const episodaDir = path14.join(projectRoot, ".episoda");
-    fs13.mkdirSync(episodaDir, { recursive: true });
+    const episodaDir = path16.join(projectRoot, ".episoda");
+    fs15.mkdirSync(episodaDir, { recursive: true });
     const cloneResult = await manager.gitExecutor.execute({
       action: "clone_bare",
       url: repoUrl,
@@ -6738,7 +7140,7 @@ var WorktreeManager = class _WorktreeManager {
         error: `Invalid module UID: "${moduleUid}" - contains disallowed characters`
       };
     }
-    const worktreePath = path14.join(this.projectRoot, moduleUid);
+    const worktreePath = path16.join(this.projectRoot, moduleUid);
     const lockAcquired = await this.acquireLock();
     if (!lockAcquired) {
       return {
@@ -6838,14 +7240,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();
@@ -6920,7 +7329,7 @@ var WorktreeManager = class _WorktreeManager {
     let prunedCount = 0;
     await this.updateConfigSafe((config) => {
       const initialCount = config.worktrees.length;
-      config.worktrees = config.worktrees.filter((w) => fs13.existsSync(w.worktreePath));
+      config.worktrees = config.worktrees.filter((w) => fs15.existsSync(w.worktreePath));
       prunedCount = initialCount - config.worktrees.length;
       return config;
     });
@@ -7001,16 +7410,16 @@ var WorktreeManager = class _WorktreeManager {
     const retryInterval = 50;
     while (Date.now() - startTime < timeoutMs) {
       try {
-        fs13.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+        fs15.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
         return true;
       } catch (err) {
         if (err.code === "EEXIST") {
           try {
-            const stats = fs13.statSync(lockPath);
+            const stats = fs15.statSync(lockPath);
             const lockAge = Date.now() - stats.mtimeMs;
             if (lockAge > 3e4) {
               try {
-                const lockContent = fs13.readFileSync(lockPath, "utf-8").trim();
+                const lockContent = fs15.readFileSync(lockPath, "utf-8").trim();
                 const lockPid = parseInt(lockContent, 10);
                 if (!isNaN(lockPid) && this.isProcessRunning(lockPid)) {
                   await new Promise((resolve3) => setTimeout(resolve3, retryInterval));
@@ -7019,7 +7428,7 @@ var WorktreeManager = class _WorktreeManager {
               } catch {
               }
               try {
-                fs13.unlinkSync(lockPath);
+                fs15.unlinkSync(lockPath);
               } catch {
               }
               continue;
@@ -7040,29 +7449,34 @@ var WorktreeManager = class _WorktreeManager {
    */
   releaseLock() {
     try {
-      fs13.unlinkSync(this.getLockPath());
+      fs15.unlinkSync(this.getLockPath());
     } catch {
     }
   }
   readConfig() {
     try {
-      if (!fs13.existsSync(this.configPath)) {
+      if (!fs15.existsSync(this.configPath)) {
         return null;
       }
-      const content = fs13.readFileSync(this.configPath, "utf-8");
+      const content = fs15.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 = path14.dirname(this.configPath);
-      if (!fs13.existsSync(dir)) {
-        fs13.mkdirSync(dir, { recursive: true });
+      const dir = path16.dirname(this.configPath);
+      if (!fs15.existsSync(dir)) {
+        fs15.mkdirSync(dir, { recursive: true });
       }
-      fs13.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf-8");
+      fs15.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf-8");
     } catch (error) {
       console.error("[WorktreeManager] Failed to write config:", error);
       throw error;
@@ -7143,14 +7557,14 @@ var WorktreeManager = class _WorktreeManager {
     }
     try {
       for (const file of files) {
-        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);
+        const srcPath = path16.join(mainWorktree.worktreePath, file);
+        const destPath = path16.join(worktree.worktreePath, file);
+        if (fs15.existsSync(srcPath)) {
+          const destDir = path16.dirname(destPath);
+          if (!fs15.existsSync(destDir)) {
+            fs15.mkdirSync(destDir, { recursive: true });
+          }
+          fs15.copyFileSync(srcPath, destPath);
           console.log(`[WorktreeManager] EP964: Copied ${file} to ${moduleUid} (deprecated)`);
         } else {
           console.log(`[WorktreeManager] EP964: Skipped ${file} (not found in main)`);
@@ -7181,8 +7595,8 @@ var WorktreeManager = class _WorktreeManager {
     console.log(`[WorktreeManager] EP959:   Timeout: ${TIMEOUT_MINUTES} minutes`);
     console.log(`[WorktreeManager] EP959:   Script: ${scriptPreview}`);
     try {
-      const { execSync: execSync8 } = require("child_process");
-      execSync8(script, {
+      const { execSync: execSync9 } = require("child_process");
+      execSync9(script, {
         cwd: worktree.worktreePath,
         stdio: "inherit",
         timeout: TIMEOUT_MINUTES * 60 * 1e3,
@@ -7216,8 +7630,8 @@ var WorktreeManager = class _WorktreeManager {
     console.log(`[WorktreeManager] EP959:   Timeout: ${TIMEOUT_MINUTES} minutes`);
     console.log(`[WorktreeManager] EP959:   Script: ${scriptPreview}`);
     try {
-      const { execSync: execSync8 } = require("child_process");
-      execSync8(script, {
+      const { execSync: execSync9 } = require("child_process");
+      execSync9(script, {
         cwd: worktree.worktreePath,
         stdio: "inherit",
         timeout: TIMEOUT_MINUTES * 60 * 1e3,
@@ -7233,27 +7647,27 @@ var WorktreeManager = class _WorktreeManager {
   }
 };
 function getEpisodaRoot() {
-  return process.env.EPISODA_ROOT || path14.join(require("os").homedir(), "episoda");
+  return process.env.EPISODA_ROOT || path16.join(require("os").homedir(), "episoda");
 }
 async function isWorktreeProject(projectRoot) {
   const manager = new WorktreeManager(projectRoot);
   return manager.initialize();
 }
 async function findProjectRoot(startPath) {
-  let current = path14.resolve(startPath);
+  let current = path16.resolve(startPath);
   const episodaRoot = getEpisodaRoot();
   if (!current.startsWith(episodaRoot)) {
     return null;
   }
   for (let i = 0; i < 10; i++) {
-    const bareDir = path14.join(current, ".bare");
-    const episodaDir = path14.join(current, ".episoda");
-    if (fs13.existsSync(bareDir) && fs13.existsSync(episodaDir)) {
+    const bareDir = path16.join(current, ".bare");
+    const episodaDir = path16.join(current, ".episoda");
+    if (fs15.existsSync(bareDir) && fs15.existsSync(episodaDir)) {
       if (await isWorktreeProject(current)) {
         return current;
       }
     }
-    const parent = path14.dirname(current);
+    const parent = path16.dirname(current);
     if (parent === current) {
       break;
     }
@@ -7263,19 +7677,19 @@ async function findProjectRoot(startPath) {
 }
 
 // src/utils/worktree.ts
-var path15 = __toESM(require("path"));
-var fs14 = __toESM(require("fs"));
-var os5 = __toESM(require("os"));
+var path17 = __toESM(require("path"));
+var fs16 = __toESM(require("fs"));
+var os7 = __toESM(require("os"));
 var import_core11 = __toESM(require_dist());
 function getEpisodaRoot2() {
-  return process.env.EPISODA_ROOT || path15.join(os5.homedir(), "episoda");
+  return process.env.EPISODA_ROOT || path17.join(os7.homedir(), "episoda");
 }
 function getWorktreeInfo(moduleUid, workspaceSlug, projectSlug) {
   const root = getEpisodaRoot2();
-  const worktreePath = path15.join(root, workspaceSlug, projectSlug, moduleUid);
+  const worktreePath = path17.join(root, workspaceSlug, projectSlug, moduleUid);
   return {
     path: worktreePath,
-    exists: fs14.existsSync(worktreePath),
+    exists: fs16.existsSync(worktreePath),
     moduleUid
   };
 }
@@ -7289,61 +7703,61 @@ async function getWorktreeInfoForModule(moduleUid) {
 }
 
 // src/framework-detector.ts
-var fs15 = __toESM(require("fs"));
-var path16 = __toESM(require("path"));
+var fs17 = __toESM(require("fs"));
+var path18 = __toESM(require("path"));
 function getInstallCommand(cwd) {
-  if (fs15.existsSync(path16.join(cwd, "bun.lockb"))) {
+  if (fs17.existsSync(path18.join(cwd, "bun.lockb"))) {
     return {
       command: ["bun", "install"],
       description: "Installing dependencies with bun",
       detectedFrom: "bun.lockb"
     };
   }
-  if (fs15.existsSync(path16.join(cwd, "pnpm-lock.yaml"))) {
+  if (fs17.existsSync(path18.join(cwd, "pnpm-lock.yaml"))) {
     return {
       command: ["pnpm", "install"],
       description: "Installing dependencies with pnpm",
       detectedFrom: "pnpm-lock.yaml"
     };
   }
-  if (fs15.existsSync(path16.join(cwd, "yarn.lock"))) {
+  if (fs17.existsSync(path18.join(cwd, "yarn.lock"))) {
     return {
       command: ["yarn", "install"],
       description: "Installing dependencies with yarn",
       detectedFrom: "yarn.lock"
     };
   }
-  if (fs15.existsSync(path16.join(cwd, "package-lock.json"))) {
+  if (fs17.existsSync(path18.join(cwd, "package-lock.json"))) {
     return {
       command: ["npm", "ci"],
       description: "Installing dependencies with npm ci",
       detectedFrom: "package-lock.json"
     };
   }
-  if (fs15.existsSync(path16.join(cwd, "package.json"))) {
+  if (fs17.existsSync(path18.join(cwd, "package.json"))) {
     return {
       command: ["npm", "install"],
       description: "Installing dependencies with npm",
       detectedFrom: "package.json"
     };
   }
-  if (fs15.existsSync(path16.join(cwd, "Pipfile.lock")) || fs15.existsSync(path16.join(cwd, "Pipfile"))) {
+  if (fs17.existsSync(path18.join(cwd, "Pipfile.lock")) || fs17.existsSync(path18.join(cwd, "Pipfile"))) {
     return {
       command: ["pipenv", "install"],
       description: "Installing dependencies with pipenv",
-      detectedFrom: fs15.existsSync(path16.join(cwd, "Pipfile.lock")) ? "Pipfile.lock" : "Pipfile"
+      detectedFrom: fs17.existsSync(path18.join(cwd, "Pipfile.lock")) ? "Pipfile.lock" : "Pipfile"
     };
   }
-  if (fs15.existsSync(path16.join(cwd, "poetry.lock"))) {
+  if (fs17.existsSync(path18.join(cwd, "poetry.lock"))) {
     return {
       command: ["poetry", "install"],
       description: "Installing dependencies with poetry",
       detectedFrom: "poetry.lock"
     };
   }
-  if (fs15.existsSync(path16.join(cwd, "pyproject.toml"))) {
-    const pyprojectPath = path16.join(cwd, "pyproject.toml");
-    const content = fs15.readFileSync(pyprojectPath, "utf-8");
+  if (fs17.existsSync(path18.join(cwd, "pyproject.toml"))) {
+    const pyprojectPath = path18.join(cwd, "pyproject.toml");
+    const content = fs17.readFileSync(pyprojectPath, "utf-8");
     if (content.includes("[tool.poetry]")) {
       return {
         command: ["poetry", "install"],
@@ -7352,41 +7766,41 @@ function getInstallCommand(cwd) {
       };
     }
   }
-  if (fs15.existsSync(path16.join(cwd, "requirements.txt"))) {
+  if (fs17.existsSync(path18.join(cwd, "requirements.txt"))) {
     return {
       command: ["pip", "install", "-r", "requirements.txt"],
       description: "Installing dependencies with pip",
       detectedFrom: "requirements.txt"
     };
   }
-  if (fs15.existsSync(path16.join(cwd, "Gemfile.lock")) || fs15.existsSync(path16.join(cwd, "Gemfile"))) {
+  if (fs17.existsSync(path18.join(cwd, "Gemfile.lock")) || fs17.existsSync(path18.join(cwd, "Gemfile"))) {
     return {
       command: ["bundle", "install"],
       description: "Installing dependencies with bundler",
-      detectedFrom: fs15.existsSync(path16.join(cwd, "Gemfile.lock")) ? "Gemfile.lock" : "Gemfile"
+      detectedFrom: fs17.existsSync(path18.join(cwd, "Gemfile.lock")) ? "Gemfile.lock" : "Gemfile"
     };
   }
-  if (fs15.existsSync(path16.join(cwd, "go.sum")) || fs15.existsSync(path16.join(cwd, "go.mod"))) {
+  if (fs17.existsSync(path18.join(cwd, "go.sum")) || fs17.existsSync(path18.join(cwd, "go.mod"))) {
     return {
       command: ["go", "mod", "download"],
       description: "Downloading Go modules",
-      detectedFrom: fs15.existsSync(path16.join(cwd, "go.sum")) ? "go.sum" : "go.mod"
+      detectedFrom: fs17.existsSync(path18.join(cwd, "go.sum")) ? "go.sum" : "go.mod"
     };
   }
-  if (fs15.existsSync(path16.join(cwd, "Cargo.lock")) || fs15.existsSync(path16.join(cwd, "Cargo.toml"))) {
+  if (fs17.existsSync(path18.join(cwd, "Cargo.lock")) || fs17.existsSync(path18.join(cwd, "Cargo.toml"))) {
     return {
       command: ["cargo", "build"],
       description: "Building Rust project (downloads dependencies)",
-      detectedFrom: fs15.existsSync(path16.join(cwd, "Cargo.lock")) ? "Cargo.lock" : "Cargo.toml"
+      detectedFrom: fs17.existsSync(path18.join(cwd, "Cargo.lock")) ? "Cargo.lock" : "Cargo.toml"
     };
   }
   return null;
 }
 
 // src/daemon/daemon-process.ts
-var fs16 = __toESM(require("fs"));
-var os6 = __toESM(require("os"));
-var path17 = __toESM(require("path"));
+var fs18 = __toESM(require("fs"));
+var os8 = __toESM(require("os"));
+var path19 = __toESM(require("path"));
 var packageJson = require_package();
 async function ensureValidToken(config, bufferMs = 5 * 60 * 1e3) {
   const now = Date.now();
@@ -7550,6 +7964,7 @@ var Daemon = class _Daemon {
     this.registerIPCHandlers();
     await this.restoreConnections();
     await this.cleanupOrphanedTunnels();
+    await this.cleanupOrphanedDevServers();
     await this.auditWorktreesOnStartup();
     this.startHealthCheckPolling();
     this.setupShutdownHandlers();
@@ -7596,9 +8011,9 @@ var Daemon = class _Daemon {
         machineId: this.machineId,
         deviceId: this.deviceId,
         // EP726: UUID for unified device identification
-        hostname: os6.hostname(),
-        platform: os6.platform(),
-        arch: os6.arch(),
+        hostname: os8.hostname(),
+        platform: os8.platform(),
+        arch: os8.arch(),
         projects
       };
     });
@@ -7888,7 +8303,7 @@ var Daemon = class _Daemon {
         client.updateActivity();
         try {
           const gitCmd = message.command;
-          const bareRepoPath = path17.join(projectPath, ".bare");
+          const bareRepoPath = path19.join(projectPath, ".bare");
           const cwd = gitCmd.worktreePath || bareRepoPath;
           if (gitCmd.worktreePath) {
             console.log(`[Daemon] Routing command to worktree: ${gitCmd.worktreePath}`);
@@ -8217,6 +8632,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 initialized2 = await manager.initialize();
+            if (!initialized2) {
+              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";
@@ -8304,8 +8791,8 @@ var Daemon = class _Daemon {
       let daemonPid;
       try {
         const pidPath = getPidFilePath();
-        if (fs16.existsSync(pidPath)) {
-          const pidStr = fs16.readFileSync(pidPath, "utf-8").trim();
+        if (fs18.existsSync(pidPath)) {
+          const pidStr = fs18.readFileSync(pidPath, "utf-8").trim();
           daemonPid = parseInt(pidStr, 10);
         }
       } catch (pidError) {
@@ -8329,9 +8816,9 @@ var Daemon = class _Daemon {
         client.once("auth_error", errorHandler);
       });
       await client.connect(wsUrl, config.access_token, this.machineId, {
-        hostname: os6.hostname(),
-        osPlatform: os6.platform(),
-        osArch: os6.arch(),
+        hostname: os8.hostname(),
+        osPlatform: os8.platform(),
+        osArch: os8.arch(),
         daemonPid
       });
       console.log(`[Daemon] Successfully connected to project ${projectId}`);
@@ -8384,29 +8871,29 @@ var Daemon = class _Daemon {
    */
   async configureGitUser(projectPath, userId, workspaceId, machineId, projectId, deviceId) {
     try {
-      const { execSync: execSync8 } = await import("child_process");
-      execSync8(`git config episoda.userId ${userId}`, {
+      const { execSync: execSync9 } = await import("child_process");
+      execSync9(`git config episoda.userId ${userId}`, {
         cwd: projectPath,
         encoding: "utf8",
         stdio: "pipe"
       });
-      execSync8(`git config episoda.workspaceId ${workspaceId}`, {
+      execSync9(`git config episoda.workspaceId ${workspaceId}`, {
         cwd: projectPath,
         encoding: "utf8",
         stdio: "pipe"
       });
-      execSync8(`git config episoda.machineId ${machineId}`, {
+      execSync9(`git config episoda.machineId ${machineId}`, {
         cwd: projectPath,
         encoding: "utf8",
         stdio: "pipe"
       });
-      execSync8(`git config episoda.projectId ${projectId}`, {
+      execSync9(`git config episoda.projectId ${projectId}`, {
         cwd: projectPath,
         encoding: "utf8",
         stdio: "pipe"
       });
       if (deviceId) {
-        execSync8(`git config episoda.deviceId ${deviceId}`, {
+        execSync9(`git config episoda.deviceId ${deviceId}`, {
           cwd: projectPath,
           encoding: "utf8",
           stdio: "pipe"
@@ -8426,27 +8913,27 @@ var Daemon = class _Daemon {
    */
   async installGitHooks(projectPath) {
     const hooks = ["post-checkout", "pre-commit", "post-commit"];
-    const hooksDir = path17.join(projectPath, ".git", "hooks");
-    if (!fs16.existsSync(hooksDir)) {
+    const hooksDir = path19.join(projectPath, ".git", "hooks");
+    if (!fs18.existsSync(hooksDir)) {
       console.warn(`[Daemon] Hooks directory not found: ${hooksDir}`);
       return;
     }
     for (const hookName of hooks) {
       try {
-        const hookPath = path17.join(hooksDir, hookName);
-        const bundledHookPath = path17.join(__dirname, "..", "hooks", hookName);
-        if (!fs16.existsSync(bundledHookPath)) {
+        const hookPath = path19.join(hooksDir, hookName);
+        const bundledHookPath = path19.join(__dirname, "..", "hooks", hookName);
+        if (!fs18.existsSync(bundledHookPath)) {
           console.warn(`[Daemon] Bundled hook not found: ${bundledHookPath}`);
           continue;
         }
-        const hookContent = fs16.readFileSync(bundledHookPath, "utf-8");
-        if (fs16.existsSync(hookPath)) {
-          const existingContent = fs16.readFileSync(hookPath, "utf-8");
+        const hookContent = fs18.readFileSync(bundledHookPath, "utf-8");
+        if (fs18.existsSync(hookPath)) {
+          const existingContent = fs18.readFileSync(hookPath, "utf-8");
           if (existingContent === hookContent) {
             continue;
           }
         }
-        fs16.writeFileSync(hookPath, hookContent, { mode: 493 });
+        fs18.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);
@@ -8762,8 +9249,8 @@ var Daemon = class _Daemon {
       console.log(`[Daemon] EP1002: ${installCmd.description} (detected from ${installCmd.detectedFrom})`);
       console.log(`[Daemon] EP1002: Running: ${installCmd.command.join(" ")}`);
       try {
-        const { execSync: execSync8 } = await import("child_process");
-        execSync8(installCmd.command.join(" "), {
+        const { execSync: execSync9 } = await import("child_process");
+        execSync9(installCmd.command.join(" "), {
           cwd: worktreePath,
           stdio: "inherit",
           timeout: 10 * 60 * 1e3,
@@ -8816,8 +9303,8 @@ var Daemon = class _Daemon {
         console.log(`[Daemon] EP986: ${installCmd.description} (detected from ${installCmd.detectedFrom})`);
         console.log(`[Daemon] EP986: Running: ${installCmd.command.join(" ")}`);
         try {
-          const { execSync: execSync8 } = await import("child_process");
-          execSync8(installCmd.command.join(" "), {
+          const { execSync: execSync9 } = await import("child_process");
+          execSync9(installCmd.command.join(" "), {
             cwd: worktreePath,
             stdio: "inherit",
             timeout: 10 * 60 * 1e3,
@@ -8951,6 +9438,65 @@ var Daemon = class _Daemon {
       console.error("[Daemon] EP904: Failed to clean up orphaned tunnels:", error);
     }
   }
+  /**
+   * EP1042: Clean up orphaned dev servers from previous daemon runs
+   *
+   * When the daemon crashes or is killed, dev servers may continue running.
+   * This method:
+   * 1. Queries the DevServerRegistry for tracked dev servers
+   * 2. Queries API for modules in doing/review state
+   * 3. Kills dev servers for modules NOT in doing/review
+   * 4. Reconciles port allocator with registry
+   */
+  async cleanupOrphanedDevServers() {
+    try {
+      const registry = getDevServerRegistry();
+      const entries = registry.getAll();
+      if (entries.length === 0) {
+        console.log("[Daemon] EP1042: No registered dev servers to check");
+        return;
+      }
+      console.log(`[Daemon] EP1042: Checking ${entries.length} registered dev server(s)...`);
+      const activeModuleUids = [];
+      const config = await (0, import_core12.loadConfig)();
+      if (config?.access_token) {
+        const apiUrl = config.api_url || "https://episoda.dev";
+        try {
+          const response = await fetch(`${apiUrl}/api/modules?state=doing,review&dev_mode=local`, {
+            headers: {
+              "Authorization": `Bearer ${config.access_token}`,
+              "Content-Type": "application/json"
+            }
+          });
+          if (response.ok) {
+            const data = await response.json();
+            if (data.modules && Array.isArray(data.modules)) {
+              for (const module2 of data.modules) {
+                if (module2.uid) {
+                  activeModuleUids.push(module2.uid);
+                }
+              }
+            }
+          }
+        } catch (fetchError) {
+          console.warn("[Daemon] EP1042: Failed to fetch active modules:", fetchError);
+        }
+      }
+      console.log(`[Daemon] EP1042: Found ${activeModuleUids.length} active module(s) in doing/review state`);
+      const cleanup = await registry.cleanupOrphans(activeModuleUids);
+      if (cleanup.cleaned > 0) {
+        console.log(`[Daemon] EP1042: Killed ${cleanup.cleaned} orphaned dev server(s)`);
+      }
+      const registryPorts = /* @__PURE__ */ new Map();
+      for (const entry of registry.getAll()) {
+        registryPorts.set(entry.moduleUid, entry.port);
+      }
+      reconcileWithRegistry(registryPorts);
+      console.log("[Daemon] EP1042: Orphaned dev server cleanup complete");
+    } catch (error) {
+      console.error("[Daemon] EP1042: Failed to clean up orphaned dev servers:", error);
+    }
+  }
   /**
    * EP957: Audit worktrees on daemon startup to detect orphaned worktrees
    *
@@ -8997,14 +9543,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);
     }
   }
   /**
@@ -9072,9 +9640,20 @@ var Daemon = class _Daemon {
   }
   /**
    * EP833: Check if a tunnel is healthy
+   * EP1042: Now also verifies dev server ownership (correct worktree)
    * Verifies both the tunnel URL and local dev server respond
    */
   async checkTunnelHealth(tunnel) {
+    const registry = getDevServerRegistry();
+    const entry = registry.getByPort(tunnel.port);
+    if (entry && entry.moduleUid !== tunnel.moduleUid) {
+      console.log(`[Daemon] EP1042: Port ${tunnel.port} owned by ${entry.moduleUid}, not ${tunnel.moduleUid} - marking unhealthy`);
+      return false;
+    }
+    if (!entry) {
+      console.log(`[Daemon] EP1042: No registry entry for port ${tunnel.port} (module ${tunnel.moduleUid}) - marking unhealthy`);
+      return false;
+    }
     try {
       const controller = new AbortController();
       const timeout = setTimeout(() => controller.abort(), _Daemon.HEALTH_CHECK_TIMEOUT_MS);
@@ -9309,8 +9888,8 @@ var Daemon = class _Daemon {
     await this.shutdown();
     try {
       const pidPath = getPidFilePath();
-      if (fs16.existsSync(pidPath)) {
-        fs16.unlinkSync(pidPath);
+      if (fs18.existsSync(pidPath)) {
+        fs18.unlinkSync(pidPath);
         console.log("[Daemon] PID file cleaned up");
       }
     } catch (error) {