@episoda/cli 0.2.171 → 0.2.173

package/dist/daemon/daemon-process.js

@@ -1640,15 +1640,15 @@ var require_git_executor = __commonJS({
           try {
             const { stdout: gitDir } = await execAsync3("git rev-parse --git-dir", { cwd, timeout: 5e3 });
             const gitDirPath = gitDir.trim();
-            const fs34 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+            const fs35 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
             const rebaseMergePath = `${gitDirPath}/rebase-merge`;
             const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
             try {
-              await fs34.access(rebaseMergePath);
+              await fs35.access(rebaseMergePath);
               inRebase = true;
             } catch {
               try {
-                await fs34.access(rebaseApplyPath);
+                await fs35.access(rebaseApplyPath);
                 inRebase = true;
               } catch {
                 inRebase = false;
@@ -1704,9 +1704,9 @@ var require_git_executor = __commonJS({
               };
             }
           }
-          const fs34 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs35 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs34.access(command.path);
+            await fs35.access(command.path);
             return {
               success: false,
               error: "WORKTREE_EXISTS",
@@ -1765,9 +1765,9 @@ var require_git_executor = __commonJS({
        */
       async executeWorktreeRemove(command, cwd, options) {
         try {
-          const fs34 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs35 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs34.access(command.path);
+            await fs35.access(command.path);
           } catch {
             return {
               success: false,
@@ -1802,7 +1802,7 @@ var require_git_executor = __commonJS({
           const result = await this.runGitCommand(args, cwd, options);
           if (result.success) {
             try {
-              await fs34.rm(command.path, { recursive: true, force: true });
+              await fs35.rm(command.path, { recursive: true, force: true });
             } catch {
             }
             return {
@@ -1936,10 +1936,10 @@ var require_git_executor = __commonJS({
        */
       async executeCloneBare(command, options) {
         try {
-          const fs34 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path34 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs35 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path35 = await Promise.resolve().then(() => __importStar(require("path")));
           try {
-            await fs34.access(command.path);
+            await fs35.access(command.path);
             return {
               success: false,
               error: "BRANCH_ALREADY_EXISTS",
@@ -1948,9 +1948,9 @@ var require_git_executor = __commonJS({
             };
           } catch {
           }
-          const parentDir = path34.dirname(command.path);
+          const parentDir = path35.dirname(command.path);
           try {
-            await fs34.mkdir(parentDir, { recursive: true });
+            await fs35.mkdir(parentDir, { recursive: true });
           } catch {
           }
           const { stdout, stderr } = await execAsync3(
@@ -1998,22 +1998,22 @@ var require_git_executor = __commonJS({
        */
       async executeProjectInfo(cwd, options) {
         try {
-          const fs34 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path34 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs35 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path35 = await Promise.resolve().then(() => __importStar(require("path")));
           let currentPath = cwd;
           let projectPath = cwd;
           let bareRepoPath;
           for (let i = 0; i < 10; i++) {
-            const bareDir = path34.join(currentPath, ".bare");
-            const episodaDir = path34.join(currentPath, ".episoda");
+            const bareDir = path35.join(currentPath, ".bare");
+            const episodaDir = path35.join(currentPath, ".episoda");
             try {
-              await fs34.access(bareDir);
-              await fs34.access(episodaDir);
+              await fs35.access(bareDir);
+              await fs35.access(episodaDir);
               projectPath = currentPath;
               bareRepoPath = bareDir;
               break;
             } catch {
-              const parentPath = path34.dirname(currentPath);
+              const parentPath = path35.dirname(currentPath);
               if (parentPath === currentPath) {
                 break;
               }
@@ -2235,7 +2235,7 @@ var require_websocket_client = __commonJS({
           clearTimeout(this.reconnectTimeout);
           this.reconnectTimeout = void 0;
         }
-        return new Promise((resolve4, reject) => {
+        return new Promise((resolve6, reject) => {
           const connectionTimeout = setTimeout(() => {
             if (this.ws) {
               this.ws.terminate();
@@ -2266,7 +2266,7 @@ var require_websocket_client = __commonJS({
                 daemonPid: this.daemonPid
               });
               this.startHeartbeat();
-              resolve4();
+              resolve6();
             });
             this.ws.on("pong", () => {
               if (this.heartbeatTimeoutTimer) {
@@ -2397,13 +2397,13 @@ var require_websocket_client = __commonJS({
           console.warn("[EpisodaClient] Cannot send - WebSocket not connected");
           return false;
         }
-        return new Promise((resolve4) => {
+        return new Promise((resolve6) => {
           this.ws.send(JSON.stringify(message), (error) => {
             if (error) {
               console.error("[EpisodaClient] Failed to send message:", error);
-              resolve4(false);
+              resolve6(false);
             } else {
-              resolve4(true);
+              resolve6(true);
             }
           });
         });
@@ -2674,33 +2674,33 @@ var require_auth = __commonJS({
     exports2.loadConfig = loadConfig16;
     exports2.saveConfig = saveConfig4;
     exports2.validateToken = validateToken;
-    var fs34 = __importStar(require("fs"));
-    var path34 = __importStar(require("path"));
-    var os15 = __importStar(require("os"));
+    var fs35 = __importStar(require("fs"));
+    var path35 = __importStar(require("path"));
+    var os16 = __importStar(require("os"));
     var child_process_1 = require("child_process");
     var DEFAULT_CONFIG_FILE = "config.json";
     var hasWarnedMissingProjectId = false;
     var hasWarnedMissingRequiredFields = false;
     function getConfigDir10() {
-      return process.env.EPISODA_CONFIG_DIR || path34.join(os15.homedir(), ".episoda");
+      return process.env.EPISODA_CONFIG_DIR || path35.join(os16.homedir(), ".episoda");
     }
     function getConfigPath(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path34.join(getConfigDir10(), DEFAULT_CONFIG_FILE);
+      return path35.join(getConfigDir10(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path34.dirname(configPath);
-      const isNew = !fs34.existsSync(dir);
+      const dir = path35.dirname(configPath);
+      const isNew = !fs35.existsSync(dir);
       if (isNew) {
-        fs34.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs35.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path34.join(dir, ".nosync");
-        if (isNew || !fs34.existsSync(nosyncPath)) {
+        const nosyncPath = path35.join(dir, ".nosync");
+        if (isNew || !fs35.existsSync(nosyncPath)) {
           try {
-            fs34.writeFileSync(nosyncPath, "", { mode: 384 });
+            fs35.writeFileSync(nosyncPath, "", { mode: 384 });
             (0, child_process_1.execSync)(`xattr -w com.apple.fileprovider.ignore 1 "${dir}"`, {
               stdio: "ignore",
               timeout: 5e3
@@ -2714,11 +2714,11 @@ var require_auth = __commonJS({
       const fullPath = getConfigPath(configPath);
       const isCloudMode = process.env.EPISODA_MODE === "cloud";
       const readConfigFile = (pathToFile) => {
-        if (!fs34.existsSync(pathToFile)) {
+        if (!fs35.existsSync(pathToFile)) {
           return null;
         }
         try {
-          const content = fs34.readFileSync(pathToFile, "utf8");
+          const content = fs35.readFileSync(pathToFile, "utf8");
           return JSON.parse(content);
         } catch (error) {
           console.error("Error loading config:", error);
@@ -2757,11 +2757,11 @@ var require_auth = __commonJS({
         }
         const homeDir = process.env.HOME || require("os").homedir();
         const workspaceConfigPath = require("path").join(homeDir, "episoda", process.env.EPISODA_WORKSPACE, ".episoda", "config.json");
-        if (!fs34.existsSync(workspaceConfigPath)) {
+        if (!fs35.existsSync(workspaceConfigPath)) {
           return null;
         }
         try {
-          const content = fs34.readFileSync(workspaceConfigPath, "utf8");
+          const content = fs35.readFileSync(workspaceConfigPath, "utf8");
           const workspaceConfig2 = JSON.parse(content);
           const expiresAtEnv = envValue(process.env.EPISODA_ACCESS_TOKEN_EXPIRES_AT);
           return {
@@ -2789,11 +2789,11 @@ var require_auth = __commonJS({
         }
         const homeDir = process.env.HOME || require("os").homedir();
         const projectConfigPath = require("path").join(homeDir, "episoda", workspaceSlug, projectSlug, ".episoda", "config.json");
-        if (!fs34.existsSync(projectConfigPath)) {
+        if (!fs35.existsSync(projectConfigPath)) {
           return null;
         }
         try {
-          const content = fs34.readFileSync(projectConfigPath, "utf8");
+          const content = fs35.readFileSync(projectConfigPath, "utf8");
           const projectConfig2 = JSON.parse(content);
           return {
             project_id: projectConfig2.projectId || projectConfig2.project_id,
@@ -2861,7 +2861,7 @@ var require_auth = __commonJS({
       ensureConfigDir(fullPath);
       try {
         const content = JSON.stringify(config, null, 2);
-        fs34.writeFileSync(fullPath, content, { mode: 384 });
+        fs35.writeFileSync(fullPath, content, { mode: 384 });
       } catch (error) {
         throw new Error(`Failed to save config: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -2931,6 +2931,23 @@ Branch: ${details.branchName}`;
   }
 });
 
+// ../core/dist/internal-env-keys.js
+var require_internal_env_keys = __commonJS({
+  "../core/dist/internal-env-keys.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.INTERNAL_ONLY_ENV_KEYS = void 0;
+    exports2.isInternalOnlyEnvKey = isInternalOnlyEnvKey;
+    exports2.INTERNAL_ONLY_ENV_KEYS = [
+      "AI_CREDENTIALS_ENCRYPTION_KEY"
+    ];
+    var INTERNAL_ONLY_ENV_KEY_SET = new Set(exports2.INTERNAL_ONLY_ENV_KEYS);
+    function isInternalOnlyEnvKey(key) {
+      return INTERNAL_ONLY_ENV_KEY_SET.has(key.toUpperCase());
+    }
+  }
+});
+
 // ../core/dist/index.js
 var require_dist = __commonJS({
   "../core/dist/index.js"(exports2) {
@@ -2966,6 +2983,7 @@ var require_dist = __commonJS({
     __exportStar(require_errors(), exports2);
     __exportStar(require_git_validator(), exports2);
     __exportStar(require_git_parser(), exports2);
+    __exportStar(require_internal_env_keys(), exports2);
     var version_1 = require_version();
     Object.defineProperty(exports2, "VERSION", { enumerable: true, get: function() {
       return version_1.VERSION;
@@ -2978,7 +2996,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@episoda/cli",
-      version: "0.2.171",
+      version: "0.2.173",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -3283,10 +3301,10 @@ var IPCServer = class {
     this.server = net.createServer((socket) => {
       this.handleConnection(socket);
     });
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve6, reject) => {
       this.server.listen(socketPath, () => {
         fs3.chmodSync(socketPath, 384);
-        resolve4();
+        resolve6();
       });
       this.server.on("error", reject);
     });
@@ -3297,12 +3315,12 @@ var IPCServer = class {
   async stop() {
     if (!this.server) return;
     const socketPath = getSocketPath();
-    return new Promise((resolve4) => {
+    return new Promise((resolve6) => {
       this.server.close(() => {
         if (fs3.existsSync(socketPath)) {
           fs3.unlinkSync(socketPath);
         }
-        resolve4();
+        resolve6();
       });
     });
   }
@@ -3528,7 +3546,7 @@ function getDownloadUrl() {
   return platformUrls[arch4] || null;
 }
 async function downloadFile(url, destPath) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve6, reject) => {
     const followRedirect = (currentUrl, redirectCount = 0) => {
       if (redirectCount > 5) {
         reject(new Error("Too many redirects"));
@@ -3558,7 +3576,7 @@ async function downloadFile(url, destPath) {
         response.pipe(file);
         file.on("finish", () => {
           file.close();
-          resolve4();
+          resolve6();
         });
         file.on("error", (err) => {
           fs4.unlinkSync(destPath);
@@ -3972,10 +3990,10 @@ var TunnelManager = class extends import_events.EventEmitter {
       const isTracked = Array.from(this.tunnelStates.values()).some((s) => s.info.pid === pid);
       console.log(`[Tunnel] EP904: Found cloudflared PID ${pid} on port ${port} (tracked: ${isTracked})`);
       this.killByPid(pid, "SIGTERM");
-      await new Promise((resolve4) => setTimeout(resolve4, 500));
+      await new Promise((resolve6) => setTimeout(resolve6, 500));
       if (this.isProcessRunning(pid)) {
         this.killByPid(pid, "SIGKILL");
-        await new Promise((resolve4) => setTimeout(resolve4, 200));
+        await new Promise((resolve6) => setTimeout(resolve6, 200));
       }
       killed.push(pid);
     }
@@ -4009,7 +4027,7 @@ var TunnelManager = class extends import_events.EventEmitter {
           if (!this.tunnelStates.has(moduleUid)) {
             console.log(`[Tunnel] EP877: Found orphaned process PID ${pid} for ${moduleUid}, killing...`);
             this.killByPid(pid, "SIGTERM");
-            await new Promise((resolve4) => setTimeout(resolve4, 1e3));
+            await new Promise((resolve6) => setTimeout(resolve6, 1e3));
             if (this.isProcessRunning(pid)) {
               this.killByPid(pid, "SIGKILL");
             }
@@ -4024,7 +4042,7 @@ var TunnelManager = class extends import_events.EventEmitter {
         if (!trackedPids.includes(pid) && !cleaned.includes(pid)) {
           console.log(`[Tunnel] EP877: Found untracked cloudflared process PID ${pid}, killing...`);
           this.killByPid(pid, "SIGTERM");
-          await new Promise((resolve4) => setTimeout(resolve4, 500));
+          await new Promise((resolve6) => setTimeout(resolve6, 500));
           if (this.isProcessRunning(pid)) {
             this.killByPid(pid, "SIGKILL");
           }
@@ -4114,7 +4132,7 @@ var TunnelManager = class extends import_events.EventEmitter {
         return { success: false, error: `Failed to get cloudflared: ${errorMessage}` };
       }
     }
-    return new Promise((resolve4) => {
+    return new Promise((resolve6) => {
       const tunnelInfo = {
         moduleUid,
         url: previewUrl || "",
@@ -4180,7 +4198,7 @@ var TunnelManager = class extends import_events.EventEmitter {
             moduleUid,
             url: tunnelInfo.url
           });
-          resolve4({ success: true, url: tunnelInfo.url });
+          resolve6({ success: true, url: tunnelInfo.url });
         }
       };
       process2.stderr?.on("data", (data) => {
@@ -4207,7 +4225,7 @@ var TunnelManager = class extends import_events.EventEmitter {
             onStatusChange?.("error", errorMsg);
             this.emitEvent({ type: "error", moduleUid, error: errorMsg });
           }
-          resolve4({ success: false, error: errorMsg });
+          resolve6({ success: false, error: errorMsg });
         } else if (wasConnected) {
           if (currentState && !currentState.intentionallyStopped) {
             console.log(`[Tunnel] EP948: Named tunnel ${moduleUid} crashed unexpectedly, attempting reconnect...`);
@@ -4238,7 +4256,7 @@ var TunnelManager = class extends import_events.EventEmitter {
           this.emitEvent({ type: "error", moduleUid, error: error.message });
         }
         if (!connected) {
-          resolve4({ success: false, error: error.message });
+          resolve6({ success: false, error: error.message });
         }
       });
       setTimeout(() => {
@@ -4261,7 +4279,7 @@ var TunnelManager = class extends import_events.EventEmitter {
             onStatusChange?.("error", errorMsg);
             this.emitEvent({ type: "error", moduleUid, error: errorMsg });
           }
-          resolve4({ success: false, error: errorMsg });
+          resolve6({ success: false, error: errorMsg });
         }
       }, TUNNEL_TIMEOUTS.NAMED_TUNNEL_CONNECT);
     });
@@ -4322,7 +4340,7 @@ var TunnelManager = class extends import_events.EventEmitter {
     if (orphanPid && this.isProcessRunning(orphanPid)) {
       console.log(`[Tunnel] EP877: Killing orphaned process ${orphanPid} for ${moduleUid} before starting new tunnel`);
       this.killByPid(orphanPid, "SIGTERM");
-      await new Promise((resolve4) => setTimeout(resolve4, 500));
+      await new Promise((resolve6) => setTimeout(resolve6, 500));
       if (this.isProcessRunning(orphanPid)) {
         this.killByPid(orphanPid, "SIGKILL");
       }
@@ -4331,7 +4349,7 @@ var TunnelManager = class extends import_events.EventEmitter {
     const killedOnPort = await this.killCloudflaredOnPort(port);
     if (killedOnPort.length > 0) {
       console.log(`[Tunnel] EP904: Pre-start port cleanup killed ${killedOnPort.length} process(es) on port ${port}`);
-      await new Promise((resolve4) => setTimeout(resolve4, 1e3));
+      await new Promise((resolve6) => setTimeout(resolve6, 1e3));
     }
     const cleanup = await this.cleanupOrphanedProcesses();
     if (cleanup.cleaned > 0) {
@@ -4371,7 +4389,7 @@ var TunnelManager = class extends import_events.EventEmitter {
       if (orphanPid && this.isProcessRunning(orphanPid)) {
         console.log(`[Tunnel] EP877: Stopping orphaned process ${orphanPid} for ${moduleUid} via PID file`);
         this.killByPid(orphanPid, "SIGTERM");
-        await new Promise((resolve4) => setTimeout(resolve4, 1e3));
+        await new Promise((resolve6) => setTimeout(resolve6, 1e3));
         if (this.isProcessRunning(orphanPid)) {
           this.killByPid(orphanPid, "SIGKILL");
         }
@@ -4387,16 +4405,16 @@ var TunnelManager = class extends import_events.EventEmitter {
     const tunnel = state.info;
     if (tunnel.process && !tunnel.process.killed) {
       tunnel.process.kill("SIGTERM");
-      await new Promise((resolve4) => {
+      await new Promise((resolve6) => {
         const timeout = setTimeout(() => {
           if (tunnel.process && !tunnel.process.killed) {
             tunnel.process.kill("SIGKILL");
           }
-          resolve4();
+          resolve6();
         }, 3e3);
         tunnel.process.once("exit", () => {
           clearTimeout(timeout);
-          resolve4();
+          resolve6();
         });
       });
     }
@@ -4683,15 +4701,15 @@ async function writeToStdinWithBackpressure(process2, data, drainTimeoutMs, labe
   if (!stdin || stdin.destroyed) {
     throw new Error(`[${label}] stdin not available. session=${sessionId}`);
   }
-  await new Promise((resolve4, reject) => {
+  await new Promise((resolve6, reject) => {
     const ok = stdin.write(data);
     if (ok) {
-      resolve4();
+      resolve6();
       return;
     }
     const onDrain = () => {
       cleanup();
-      resolve4();
+      resolve6();
     };
     const onError = (err) => {
       cleanup();
@@ -4712,18 +4730,18 @@ async function writeToStdinWithBackpressure(process2, data, drainTimeoutMs, labe
   });
 }
 function waitForProcessExit(process2, alive, timeoutMs) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve6) => {
     if (!process2 || !alive) {
-      resolve4(true);
+      resolve6(true);
       return;
     }
     const onExit = () => {
       clearTimeout(timer);
-      resolve4(true);
+      resolve6(true);
     };
     const timer = setTimeout(() => {
       process2.removeListener("exit", onExit);
-      resolve4(false);
+      resolve6(false);
     }, timeoutMs);
     process2.once("exit", onExit);
   });
@@ -5719,10 +5737,10 @@ var CodexPersistentRuntime = class {
   }
   waitForThreadId(timeoutMs) {
     if (this._agentSessionId) return Promise.resolve(this._agentSessionId);
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve6, reject) => {
       const onId = (id) => {
         clearTimeout(timer);
-        resolve4(id);
+        resolve6(id);
       };
       const timer = setTimeout(() => {
         this.threadIdWaiters = this.threadIdWaiters.filter((w) => w !== onId);
@@ -5753,12 +5771,12 @@ var CodexPersistentRuntime = class {
   sendRequest(method, params, timeoutMs = INIT_TIMEOUT_MS) {
     const id = this.nextId++;
     const msg = { jsonrpc: "2.0", id, method, params };
-    return new Promise(async (resolve4, reject) => {
+    return new Promise(async (resolve6, reject) => {
       const timeout = setTimeout(() => {
         this.pending.delete(id);
         reject(new Error(`JSON-RPC timeout: ${method}`));
       }, timeoutMs);
-      this.pending.set(id, { resolve: resolve4, reject, timeout });
+      this.pending.set(id, { resolve: resolve6, reject, timeout });
       try {
         await this.writeToStdin(JSON.stringify(msg) + "\n");
       } catch (err) {
@@ -5908,11 +5926,11 @@ var UnifiedAgentRuntime = class {
     if (!this.currentTurn && this.impl.turnState === "idle") {
       return this.dispatchTurn(message, callbacks);
     }
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve6, reject) => {
       this.queuedTurns.push({
         message,
         callbacks,
-        resolve: resolve4,
+        resolve: resolve6,
         reject
       });
     });
@@ -7425,13 +7443,13 @@ async function getChildProcessRssMb(pid) {
   if (!pid || pid <= 0) return null;
   try {
     if (typeof import_child_process9.execFile !== "function") return null;
-    const stdout = await new Promise((resolve4, reject) => {
+    const stdout = await new Promise((resolve6, reject) => {
       (0, import_child_process9.execFile)("ps", ["-o", "rss=", "-p", String(pid)], { timeout: 1e3 }, (err, out) => {
         if (err) {
           reject(err);
           return;
         }
-        resolve4(String(out));
+        resolve6(String(out));
       });
     });
     const kb = Number(String(stdout).trim());
@@ -7534,8 +7552,8 @@ var AgentControlPlane = class {
   async withConfigLock(fn) {
     const previousLock = this.configWriteLock;
     let releaseLock;
-    this.configWriteLock = new Promise((resolve4) => {
-      releaseLock = resolve4;
+    this.configWriteLock = new Promise((resolve6) => {
+      releaseLock = resolve6;
     });
     try {
       await previousLock;
@@ -8778,7 +8796,7 @@ var WorktreeManager = class _WorktreeManager {
                 const lockContent = fs14.readFileSync(lockPath, "utf-8").trim();
                 const lockPid = parseInt(lockContent, 10);
                 if (!isNaN(lockPid) && this.isProcessRunning(lockPid)) {
-                  await new Promise((resolve4) => setTimeout(resolve4, retryInterval));
+                  await new Promise((resolve6) => setTimeout(resolve6, retryInterval));
                   continue;
                 }
               } catch {
@@ -8792,7 +8810,7 @@ var WorktreeManager = class _WorktreeManager {
           } catch {
             continue;
           }
-          await new Promise((resolve4) => setTimeout(resolve4, retryInterval));
+          await new Promise((resolve6) => setTimeout(resolve6, retryInterval));
           continue;
         }
         throw err;
@@ -9355,62 +9373,190 @@ function reconcileWithRegistry(activeModules) {
   }
 }
 
-// src/framework-detector.ts
+// src/utils/ws-port-allocator.ts
 var fs19 = __toESM(require("fs"));
 var path19 = __toESM(require("path"));
+var os10 = __toESM(require("os"));
+var WS_PORT_RANGE_START = 3200;
+var WS_PORT_RANGE_END = 3299;
+var WS_PORT_WARNING_THRESHOLD = 80;
+var WS_PORTS_FILE = path19.join(os10.homedir(), ".episoda", "ws-ports.json");
+var wsPortAssignments = /* @__PURE__ */ new Map();
+var initialized2 = false;
+function loadFromDisk2() {
+  if (initialized2) return;
+  initialized2 = true;
+  try {
+    if (!fs19.existsSync(WS_PORTS_FILE)) return;
+    const content = fs19.readFileSync(WS_PORTS_FILE, "utf8");
+    const data = JSON.parse(content);
+    for (const [moduleUid, port] of Object.entries(data)) {
+      if (typeof port === "number" && port >= WS_PORT_RANGE_START && port <= WS_PORT_RANGE_END) {
+        wsPortAssignments.set(moduleUid, port);
+      }
+    }
+    if (wsPortAssignments.size > 0) {
+      console.log(`[WsPortAllocator] EP1406: Loaded ${wsPortAssignments.size} WS port assignments from disk`);
+    }
+  } catch (error) {
+    console.warn("[WsPortAllocator] EP1406: Failed to load ws-ports.json:", error);
+  }
+}
+function saveToDisk2() {
+  try {
+    const dir = path19.dirname(WS_PORTS_FILE);
+    if (!fs19.existsSync(dir)) {
+      fs19.mkdirSync(dir, { recursive: true });
+    }
+    const data = {};
+    for (const [moduleUid, port] of wsPortAssignments) {
+      data[moduleUid] = port;
+    }
+    fs19.writeFileSync(WS_PORTS_FILE, JSON.stringify(data, null, 2), "utf8");
+  } catch (error) {
+    console.warn("[WsPortAllocator] EP1406: Failed to save ws-ports.json:", error);
+  }
+}
+function allocateWsPort(moduleUid) {
+  loadFromDisk2();
+  const existing = wsPortAssignments.get(moduleUid);
+  if (existing) {
+    console.log(`[WsPortAllocator] EP1406: Returning existing WS port ${existing} for ${moduleUid}`);
+    return existing;
+  }
+  const usedPorts = new Set(wsPortAssignments.values());
+  if (usedPorts.size >= WS_PORT_WARNING_THRESHOLD) {
+    console.warn(
+      `[WsPortAllocator] EP1406: Warning ${usedPorts.size}/${WS_PORT_RANGE_END - WS_PORT_RANGE_START + 1} WS ports allocated`
+    );
+  }
+  for (let port = WS_PORT_RANGE_START; port <= WS_PORT_RANGE_END; port++) {
+    if (!usedPorts.has(port)) {
+      wsPortAssignments.set(moduleUid, port);
+      saveToDisk2();
+      console.log(`[WsPortAllocator] EP1406: Allocated WS port ${port} to ${moduleUid}`);
+      return port;
+    }
+  }
+  throw new Error(
+    `No available WS ports in range ${WS_PORT_RANGE_START}-${WS_PORT_RANGE_END}. ${wsPortAssignments.size} modules are using all available WS ports.`
+  );
+}
+function assignWsPort(moduleUid, wsPort) {
+  loadFromDisk2();
+  if (!Number.isInteger(wsPort) || wsPort < WS_PORT_RANGE_START || wsPort > WS_PORT_RANGE_END) {
+    throw new Error(
+      `WS port ${wsPort} is outside allowed range ${WS_PORT_RANGE_START}-${WS_PORT_RANGE_END}`
+    );
+  }
+  for (const [ownerModuleUid, ownerPort] of wsPortAssignments.entries()) {
+    if (ownerPort === wsPort && ownerModuleUid !== moduleUid) {
+      throw new Error(`WS port ${wsPort} is already assigned to ${ownerModuleUid}`);
+    }
+  }
+  const existing = wsPortAssignments.get(moduleUid);
+  if (existing === wsPort) {
+    return wsPort;
+  }
+  wsPortAssignments.set(moduleUid, wsPort);
+  saveToDisk2();
+  console.log(`[WsPortAllocator] EP1406: Assigned WS port ${wsPort} to ${moduleUid}`);
+  return wsPort;
+}
+function releaseWsPort(moduleUid) {
+  loadFromDisk2();
+  const port = wsPortAssignments.get(moduleUid);
+  if (!port) return;
+  wsPortAssignments.delete(moduleUid);
+  saveToDisk2();
+  console.log(`[WsPortAllocator] EP1406: Released WS port ${port} from ${moduleUid}`);
+}
+function reconcileWsPortsWithRegistry(activeModules) {
+  loadFromDisk2();
+  let changed = false;
+  for (const [moduleUid, port] of wsPortAssignments) {
+    if (!activeModules.has(moduleUid)) {
+      console.log(`[WsPortAllocator] EP1406: Removing stale WS allocation ${moduleUid} -> ${port}`);
+      wsPortAssignments.delete(moduleUid);
+      changed = true;
+    }
+  }
+  for (const [moduleUid, port] of activeModules) {
+    if (!wsPortAssignments.has(moduleUid)) {
+      console.log(`[WsPortAllocator] EP1406: Adding WS allocation from registry ${moduleUid} -> ${port}`);
+      wsPortAssignments.set(moduleUid, port);
+      changed = true;
+    }
+  }
+  if (changed) {
+    saveToDisk2();
+  }
+}
+function clearAllWsPorts() {
+  const count = wsPortAssignments.size;
+  wsPortAssignments.clear();
+  saveToDisk2();
+  if (count > 0) {
+    console.log(`[WsPortAllocator] EP1406: Cleared ${count} WS port assignments`);
+  }
+}
+
+// src/framework-detector.ts
+var fs20 = __toESM(require("fs"));
+var path20 = __toESM(require("path"));
 function getInstallCommand(cwd) {
-  if (fs19.existsSync(path19.join(cwd, "bun.lockb"))) {
+  if (fs20.existsSync(path20.join(cwd, "bun.lockb"))) {
     return {
       command: ["bun", "install"],
       description: "Installing dependencies with bun",
       detectedFrom: "bun.lockb"
     };
   }
-  if (fs19.existsSync(path19.join(cwd, "pnpm-lock.yaml"))) {
+  if (fs20.existsSync(path20.join(cwd, "pnpm-lock.yaml"))) {
     return {
       command: ["pnpm", "install"],
       description: "Installing dependencies with pnpm",
       detectedFrom: "pnpm-lock.yaml"
     };
   }
-  if (fs19.existsSync(path19.join(cwd, "yarn.lock"))) {
+  if (fs20.existsSync(path20.join(cwd, "yarn.lock"))) {
     return {
       command: ["yarn", "install"],
       description: "Installing dependencies with yarn",
       detectedFrom: "yarn.lock"
     };
   }
-  if (fs19.existsSync(path19.join(cwd, "package-lock.json"))) {
+  if (fs20.existsSync(path20.join(cwd, "package-lock.json"))) {
     return {
       command: ["npm", "ci"],
       description: "Installing dependencies with npm ci",
       detectedFrom: "package-lock.json"
     };
   }
-  if (fs19.existsSync(path19.join(cwd, "package.json"))) {
+  if (fs20.existsSync(path20.join(cwd, "package.json"))) {
     return {
       command: ["npm", "install"],
       description: "Installing dependencies with npm",
       detectedFrom: "package.json"
     };
   }
-  if (fs19.existsSync(path19.join(cwd, "Pipfile.lock")) || fs19.existsSync(path19.join(cwd, "Pipfile"))) {
+  if (fs20.existsSync(path20.join(cwd, "Pipfile.lock")) || fs20.existsSync(path20.join(cwd, "Pipfile"))) {
     return {
       command: ["pipenv", "install"],
       description: "Installing dependencies with pipenv",
-      detectedFrom: fs19.existsSync(path19.join(cwd, "Pipfile.lock")) ? "Pipfile.lock" : "Pipfile"
+      detectedFrom: fs20.existsSync(path20.join(cwd, "Pipfile.lock")) ? "Pipfile.lock" : "Pipfile"
     };
   }
-  if (fs19.existsSync(path19.join(cwd, "poetry.lock"))) {
+  if (fs20.existsSync(path20.join(cwd, "poetry.lock"))) {
     return {
       command: ["poetry", "install"],
       description: "Installing dependencies with poetry",
       detectedFrom: "poetry.lock"
     };
   }
-  if (fs19.existsSync(path19.join(cwd, "pyproject.toml"))) {
-    const pyprojectPath = path19.join(cwd, "pyproject.toml");
-    const content = fs19.readFileSync(pyprojectPath, "utf-8");
+  if (fs20.existsSync(path20.join(cwd, "pyproject.toml"))) {
+    const pyprojectPath = path20.join(cwd, "pyproject.toml");
+    const content = fs20.readFileSync(pyprojectPath, "utf-8");
     if (content.includes("[tool.poetry]")) {
       return {
         command: ["poetry", "install"],
@@ -9419,68 +9565,68 @@ function getInstallCommand(cwd) {
       };
     }
   }
-  if (fs19.existsSync(path19.join(cwd, "requirements.txt"))) {
+  if (fs20.existsSync(path20.join(cwd, "requirements.txt"))) {
     return {
       command: ["pip", "install", "-r", "requirements.txt"],
       description: "Installing dependencies with pip",
       detectedFrom: "requirements.txt"
     };
   }
-  if (fs19.existsSync(path19.join(cwd, "Gemfile.lock")) || fs19.existsSync(path19.join(cwd, "Gemfile"))) {
+  if (fs20.existsSync(path20.join(cwd, "Gemfile.lock")) || fs20.existsSync(path20.join(cwd, "Gemfile"))) {
     return {
       command: ["bundle", "install"],
       description: "Installing dependencies with bundler",
-      detectedFrom: fs19.existsSync(path19.join(cwd, "Gemfile.lock")) ? "Gemfile.lock" : "Gemfile"
+      detectedFrom: fs20.existsSync(path20.join(cwd, "Gemfile.lock")) ? "Gemfile.lock" : "Gemfile"
     };
   }
-  if (fs19.existsSync(path19.join(cwd, "go.sum")) || fs19.existsSync(path19.join(cwd, "go.mod"))) {
+  if (fs20.existsSync(path20.join(cwd, "go.sum")) || fs20.existsSync(path20.join(cwd, "go.mod"))) {
     return {
       command: ["go", "mod", "download"],
       description: "Downloading Go modules",
-      detectedFrom: fs19.existsSync(path19.join(cwd, "go.sum")) ? "go.sum" : "go.mod"
+      detectedFrom: fs20.existsSync(path20.join(cwd, "go.sum")) ? "go.sum" : "go.mod"
     };
   }
-  if (fs19.existsSync(path19.join(cwd, "Cargo.lock")) || fs19.existsSync(path19.join(cwd, "Cargo.toml"))) {
+  if (fs20.existsSync(path20.join(cwd, "Cargo.lock")) || fs20.existsSync(path20.join(cwd, "Cargo.toml"))) {
     return {
       command: ["cargo", "build"],
       description: "Building Rust project (downloads dependencies)",
-      detectedFrom: fs19.existsSync(path19.join(cwd, "Cargo.lock")) ? "Cargo.lock" : "Cargo.toml"
+      detectedFrom: fs20.existsSync(path20.join(cwd, "Cargo.lock")) ? "Cargo.lock" : "Cargo.toml"
     };
   }
   return null;
 }
 
 // src/daemon/daemon-process.ts
-var fs33 = __toESM(require("fs"));
+var fs34 = __toESM(require("fs"));
 var http2 = __toESM(require("http"));
-var os14 = __toESM(require("os"));
+var os15 = __toESM(require("os"));
 
 // src/daemon/ipc-router.ts
-var os13 = __toESM(require("os"));
+var os14 = __toESM(require("os"));
 var import_core15 = __toESM(require_dist());
 
 // src/daemon/handlers/file-handlers.ts
-var fs21 = __toESM(require("fs"));
-var path21 = __toESM(require("path"));
+var fs22 = __toESM(require("fs"));
+var path22 = __toESM(require("path"));
 var readline = __toESM(require("readline"));
 
 // src/daemon/permissions/path-classifier.ts
-var path20 = __toESM(require("path"));
-var fs20 = __toESM(require("fs"));
+var path21 = __toESM(require("path"));
+var fs21 = __toESM(require("fs"));
 function classifyPath(targetPath, options) {
   const { workspaceRoot, projectRoot } = options;
-  const normalizedWorkspace = path20.resolve(workspaceRoot);
-  const normalizedProject = path20.resolve(projectRoot);
-  const resolvedPath = path20.isAbsolute(targetPath) ? path20.resolve(targetPath) : path20.resolve(projectRoot, targetPath);
-  const artifactsDir = path20.join(normalizedWorkspace, "artifacts");
-  if (resolvedPath.startsWith(artifactsDir + path20.sep) || resolvedPath === artifactsDir) {
+  const normalizedWorkspace = path21.resolve(workspaceRoot);
+  const normalizedProject = path21.resolve(projectRoot);
+  const resolvedPath = path21.isAbsolute(targetPath) ? path21.resolve(targetPath) : path21.resolve(projectRoot, targetPath);
+  const artifactsDir = path21.join(normalizedWorkspace, "artifacts");
+  if (resolvedPath.startsWith(artifactsDir + path21.sep) || resolvedPath === artifactsDir) {
     return {
       classification: "artifacts",
       resolvedPath
     };
   }
-  if (!resolvedPath.startsWith(normalizedProject + path20.sep) && resolvedPath !== normalizedProject) {
-    if (resolvedPath.startsWith(normalizedWorkspace + path20.sep)) {
+  if (!resolvedPath.startsWith(normalizedProject + path21.sep) && resolvedPath !== normalizedProject) {
+    if (resolvedPath.startsWith(normalizedWorkspace + path21.sep)) {
       return {
         classification: "unknown",
         resolvedPath
@@ -9491,8 +9637,8 @@ function classifyPath(targetPath, options) {
       resolvedPath
     };
   }
-  const relativePath = path20.relative(normalizedProject, resolvedPath);
-  const pathParts = relativePath.split(path20.sep);
+  const relativePath = path21.relative(normalizedProject, resolvedPath);
+  const pathParts = relativePath.split(path21.sep);
   if (pathParts[0] === ".bare") {
     return {
       classification: "bare_repo",
@@ -9507,9 +9653,9 @@ function classifyPath(targetPath, options) {
   }
   const firstPart = pathParts[0];
   if (firstPart && isModuleUidPattern(firstPart)) {
-    const worktreeDir = path20.join(normalizedProject, firstPart);
-    const gitFile = path20.join(worktreeDir, ".git");
-    const worktreeExists = fs20.existsSync(gitFile) && fs20.statSync(gitFile).isFile();
+    const worktreeDir = path21.join(normalizedProject, firstPart);
+    const gitFile = path21.join(worktreeDir, ".git");
+    const worktreeExists = fs21.existsSync(gitFile) && fs21.statSync(gitFile).isFile();
     return {
       classification: "worktree",
       moduleUid: firstPart,
@@ -9526,19 +9672,19 @@ function isModuleUidPattern(str) {
   return /^EP\d+$/.test(str);
 }
 function deriveWorkspaceRoot(projectPath) {
-  return path20.dirname(path20.resolve(projectPath));
+  return path21.dirname(path21.resolve(projectPath));
 }
 function validateWorkspacePath(filePath, projectPath) {
-  const normalizedProjectPath = path20.resolve(projectPath);
+  const normalizedProjectPath = path21.resolve(projectPath);
   const workspaceRoot = deriveWorkspaceRoot(projectPath);
-  const normalizedWorkspace = path20.resolve(workspaceRoot);
-  const artifactsDir = path20.join(normalizedWorkspace, "artifacts");
-  const absolutePath = path20.isAbsolute(filePath) ? path20.resolve(filePath) : path20.resolve(projectPath, filePath);
-  const normalizedPath = path20.normalize(absolutePath);
-  if (normalizedPath.startsWith(normalizedProjectPath + path20.sep) || normalizedPath === normalizedProjectPath) {
+  const normalizedWorkspace = path21.resolve(workspaceRoot);
+  const artifactsDir = path21.join(normalizedWorkspace, "artifacts");
+  const absolutePath = path21.isAbsolute(filePath) ? path21.resolve(filePath) : path21.resolve(projectPath, filePath);
+  const normalizedPath = path21.normalize(absolutePath);
+  if (normalizedPath.startsWith(normalizedProjectPath + path21.sep) || normalizedPath === normalizedProjectPath) {
     return normalizedPath;
   }
-  if (normalizedPath.startsWith(artifactsDir + path20.sep) || normalizedPath === artifactsDir) {
+  if (normalizedPath.startsWith(artifactsDir + path21.sep) || normalizedPath === artifactsDir) {
     return normalizedPath;
   }
   return null;
@@ -9636,13 +9782,13 @@ async function handleFileRead(command, projectPath) {
     };
   }
   try {
-    if (!fs21.existsSync(validPath)) {
+    if (!fs22.existsSync(validPath)) {
       return {
         success: false,
         error: "File not found"
       };
     }
-    const stats = fs21.statSync(validPath);
+    const stats = fs22.statSync(validPath);
     if (stats.isDirectory()) {
       return {
         success: false,
@@ -9655,7 +9801,7 @@ async function handleFileRead(command, projectPath) {
         error: `File too large: ${stats.size} bytes exceeds limit of ${maxSize} bytes`
       };
     }
-    const buffer = fs21.readFileSync(validPath);
+    const buffer = fs22.readFileSync(validPath);
     let content;
     if (encoding === "base64") {
       content = buffer.toString("base64");
@@ -9695,9 +9841,9 @@ async function handleFileWrite(command, projectPath) {
   }
   try {
     if (createDirs) {
-      const dirPath = path21.dirname(validPath);
-      if (!fs21.existsSync(dirPath)) {
-        fs21.mkdirSync(dirPath, { recursive: true });
+      const dirPath = path22.dirname(validPath);
+      if (!fs22.existsSync(dirPath)) {
+        fs22.mkdirSync(dirPath, { recursive: true });
       }
     }
     let buffer;
@@ -9707,8 +9853,8 @@ async function handleFileWrite(command, projectPath) {
       buffer = Buffer.from(content, "utf8");
     }
     const tempPath = `${validPath}.tmp.${Date.now()}`;
-    fs21.writeFileSync(tempPath, buffer);
-    fs21.renameSync(tempPath, validPath);
+    fs22.writeFileSync(tempPath, buffer);
+    fs22.renameSync(tempPath, validPath);
     return {
       success: true,
       bytesWritten: buffer.length
@@ -9733,13 +9879,13 @@ async function handleFileList(command, projectPath) {
     };
   }
   try {
-    if (!fs21.existsSync(validPath)) {
+    if (!fs22.existsSync(validPath)) {
       return {
         success: false,
         error: "Directory not found"
       };
     }
-    const stats = fs21.statSync(validPath);
+    const stats = fs22.statSync(validPath);
     if (!stats.isDirectory()) {
       return {
         success: false,
@@ -9750,11 +9896,11 @@ async function handleFileList(command, projectPath) {
     if (recursive) {
       await listDirectoryRecursive(validPath, validPath, entries, includeHidden);
     } else {
-      const dirEntries = await fs21.promises.readdir(validPath, { withFileTypes: true });
+      const dirEntries = await fs22.promises.readdir(validPath, { withFileTypes: true });
       for (const entry of dirEntries) {
         if (!includeHidden && entry.name.startsWith(".")) continue;
-        const entryPath = path21.join(validPath, entry.name);
-        const entryStats = await fs21.promises.stat(entryPath);
+        const entryPath = path22.join(validPath, entry.name);
+        const entryStats = await fs22.promises.stat(entryPath);
         entries.push({
           name: entry.name,
           type: entry.isDirectory() ? "directory" : "file",
@@ -9776,13 +9922,13 @@ async function handleFileList(command, projectPath) {
   }
 }
 async function listDirectoryRecursive(basePath, currentPath, entries, includeHidden) {
-  const dirEntries = await fs21.promises.readdir(currentPath, { withFileTypes: true });
+  const dirEntries = await fs22.promises.readdir(currentPath, { withFileTypes: true });
   for (const entry of dirEntries) {
     if (!includeHidden && entry.name.startsWith(".")) continue;
-    const entryPath = path21.join(currentPath, entry.name);
-    const relativePath = path21.relative(basePath, entryPath);
+    const entryPath = path22.join(currentPath, entry.name);
+    const relativePath = path22.relative(basePath, entryPath);
     try {
-      const entryStats = await fs21.promises.stat(entryPath);
+      const entryStats = await fs22.promises.stat(entryPath);
       entries.push({
         name: relativePath,
         type: entry.isDirectory() ? "directory" : "file",
@@ -9806,7 +9952,7 @@ async function handleFileSearch(command, projectPath) {
     };
   }
   try {
-    if (!fs21.existsSync(validPath)) {
+    if (!fs22.existsSync(validPath)) {
       return {
         success: false,
         error: "Directory not found"
@@ -9896,12 +10042,12 @@ function findClosingBracket(pattern, start) {
 }
 async function searchFilesRecursive(basePath, currentPath, pattern, files, maxResults) {
   if (files.length >= maxResults) return;
-  const entries = await fs21.promises.readdir(currentPath, { withFileTypes: true });
+  const entries = await fs22.promises.readdir(currentPath, { withFileTypes: true });
   for (const entry of entries) {
     if (files.length >= maxResults) return;
     if (entry.name.startsWith(".")) continue;
-    const entryPath = path21.join(currentPath, entry.name);
-    const relativePath = path21.relative(basePath, entryPath);
+    const entryPath = path22.join(currentPath, entry.name);
+    const relativePath = path22.relative(basePath, entryPath);
     try {
       if (entry.isDirectory()) {
         await searchFilesRecursive(basePath, entryPath, pattern, files, maxResults);
@@ -9929,7 +10075,7 @@ async function handleFileGrep(command, projectPath) {
     };
   }
   try {
-    if (!fs21.existsSync(validPath)) {
+    if (!fs22.existsSync(validPath)) {
       return {
         success: false,
         error: "Path not found"
@@ -9938,7 +10084,7 @@ async function handleFileGrep(command, projectPath) {
     const matches = [];
     const searchRegex = new RegExp(pattern, caseSensitive ? "" : "i");
     const fileGlobRegex = globToRegex(filePattern);
-    const stats = fs21.statSync(validPath);
+    const stats = fs22.statSync(validPath);
     if (stats.isFile()) {
       await grepFile(validPath, validPath, searchRegex, matches, effectiveMaxResults);
     } else {
@@ -9959,8 +10105,8 @@ async function handleFileGrep(command, projectPath) {
 }
 async function grepFile(basePath, filePath, pattern, matches, maxResults) {
   if (matches.length >= maxResults) return;
-  const relativePath = path21.relative(basePath, filePath);
-  const fileStream = fs21.createReadStream(filePath, { encoding: "utf8" });
+  const relativePath = path22.relative(basePath, filePath);
+  const fileStream = fs22.createReadStream(filePath, { encoding: "utf8" });
   const rl = readline.createInterface({
     input: fileStream,
     crlfDelay: Infinity
@@ -9974,7 +10120,7 @@ async function grepFile(basePath, filePath, pattern, matches, maxResults) {
     }
     if (pattern.test(line)) {
       matches.push({
-        file: relativePath || path21.basename(filePath),
+        file: relativePath || path22.basename(filePath),
         line: lineNumber,
         content: line.slice(0, 500)
         // Truncate long lines
@@ -9984,11 +10130,11 @@ async function grepFile(basePath, filePath, pattern, matches, maxResults) {
 }
 async function grepDirectoryRecursive(basePath, currentPath, searchPattern, filePattern, matches, maxResults) {
   if (matches.length >= maxResults) return;
-  const entries = await fs21.promises.readdir(currentPath, { withFileTypes: true });
+  const entries = await fs22.promises.readdir(currentPath, { withFileTypes: true });
   for (const entry of entries) {
     if (matches.length >= maxResults) return;
     if (entry.name.startsWith(".")) continue;
-    const entryPath = path21.join(currentPath, entry.name);
+    const entryPath = path22.join(currentPath, entry.name);
     try {
       if (entry.isDirectory()) {
         await grepDirectoryRecursive(basePath, entryPath, searchPattern, filePattern, matches, maxResults);
@@ -10016,13 +10162,13 @@ async function handleFileEdit(command, projectPath) {
     };
   }
   try {
-    if (!fs21.existsSync(validPath)) {
+    if (!fs22.existsSync(validPath)) {
       return {
         success: false,
         error: "File not found"
       };
     }
-    const stats = fs21.statSync(validPath);
+    const stats = fs22.statSync(validPath);
     if (stats.isDirectory()) {
       return {
         success: false,
@@ -10036,7 +10182,7 @@ async function handleFileEdit(command, projectPath) {
         error: `File too large for edit operation: ${stats.size} bytes exceeds limit of ${MAX_EDIT_SIZE} bytes (10MB). Use write-file for large files.`
       };
     }
-    const content = fs21.readFileSync(validPath, "utf8");
+    const content = fs22.readFileSync(validPath, "utf8");
     const occurrences = content.split(oldString).length - 1;
     if (occurrences === 0) {
       return {
@@ -10053,8 +10199,8 @@ async function handleFileEdit(command, projectPath) {
     const newContent = replaceAll ? content.split(oldString).join(newString) : content.replace(oldString, newString);
     const replacements = replaceAll ? occurrences : 1;
     const tempPath = `${validPath}.tmp.${Date.now()}`;
-    fs21.writeFileSync(tempPath, newContent, "utf8");
-    fs21.renameSync(tempPath, validPath);
+    fs22.writeFileSync(tempPath, newContent, "utf8");
+    fs22.renameSync(tempPath, validPath);
     const newSize = Buffer.byteLength(newContent, "utf8");
     return {
       success: true,
@@ -10079,7 +10225,7 @@ async function handleFileDelete(command, projectPath) {
       error: "Invalid path: directory traversal not allowed"
     };
   }
-  const normalizedProjectPath = path21.resolve(projectPath);
+  const normalizedProjectPath = path22.resolve(projectPath);
   if (validPath === normalizedProjectPath) {
     return {
       success: false,
@@ -10094,13 +10240,13 @@ async function handleFileDelete(command, projectPath) {
     };
   }
   try {
-    if (!fs21.existsSync(validPath)) {
+    if (!fs22.existsSync(validPath)) {
       return {
         success: false,
         error: "Path not found"
       };
     }
-    const stats = fs21.statSync(validPath);
+    const stats = fs22.statSync(validPath);
     const isDirectory = stats.isDirectory();
     if (isDirectory && !recursive) {
       return {
@@ -10109,9 +10255,9 @@ async function handleFileDelete(command, projectPath) {
       };
     }
     if (isDirectory) {
-      fs21.rmSync(validPath, { recursive: true, force: true });
+      fs22.rmSync(validPath, { recursive: true, force: true });
     } else {
-      fs21.unlinkSync(validPath);
+      fs22.unlinkSync(validPath);
     }
     return {
       success: true,
@@ -10144,8 +10290,8 @@ async function handleFileMkdir(command, projectPath) {
     };
   }
   try {
-    if (fs21.existsSync(validPath)) {
-      const stats = fs21.statSync(validPath);
+    if (fs22.existsSync(validPath)) {
+      const stats = fs22.statSync(validPath);
       if (stats.isDirectory()) {
         return {
           success: true,
@@ -10160,7 +10306,7 @@ async function handleFileMkdir(command, projectPath) {
       }
     }
     const modeNum = parseInt(mode, 8);
-    fs21.mkdirSync(validPath, { recursive: true, mode: modeNum });
+    fs22.mkdirSync(validPath, { recursive: true, mode: modeNum });
     return {
       success: true,
       created: true
@@ -10187,7 +10333,7 @@ async function handleExec(command, projectPath) {
     env = {}
   } = command;
   const effectiveTimeout = Math.min(Math.max(timeout, 1e3), MAX_TIMEOUT);
-  return new Promise((resolve4) => {
+  return new Promise((resolve6) => {
     let stdout = "";
     let stderr = "";
     let timedOut = false;
@@ -10195,7 +10341,7 @@ async function handleExec(command, projectPath) {
     const done = (result) => {
       if (resolved) return;
       resolved = true;
-      resolve4(result);
+      resolve6(result);
     };
     try {
       const proc = (0, import_child_process11.spawn)(cmd, {
@@ -10259,9 +10405,9 @@ async function handleExec(command, projectPath) {
 }
 
 // src/daemon/handlers/worktree-handlers.ts
-var path27 = __toESM(require("path"));
-var fs27 = __toESM(require("fs"));
-var os12 = __toESM(require("os"));
+var path28 = __toESM(require("path"));
+var fs28 = __toESM(require("fs"));
+var os13 = __toESM(require("os"));
 var import_child_process14 = require("child_process");
 var import_util2 = require("util");
 
@@ -10291,52 +10437,52 @@ var import_fs = require("fs");
 // src/preview/dev-server-runner.ts
 var import_child_process13 = require("child_process");
 var http = __toESM(require("http"));
-var fs24 = __toESM(require("fs"));
-var path24 = __toESM(require("path"));
+var fs25 = __toESM(require("fs"));
+var path25 = __toESM(require("path"));
 var import_events2 = require("events");
 var import_core12 = __toESM(require_dist());
 
 // src/utils/port-check.ts
 var net2 = __toESM(require("net"));
 async function isPortInUse(port) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve6) => {
     const server = net2.createServer();
     server.once("error", (err) => {
       if (err.code === "EADDRINUSE") {
-        resolve4(true);
+        resolve6(true);
       } else {
-        resolve4(false);
+        resolve6(false);
       }
     });
     server.once("listening", () => {
       server.close();
-      resolve4(false);
+      resolve6(false);
     });
     server.listen(port);
   });
 }
 
 // src/utils/env-cache.ts
-var fs22 = __toESM(require("fs"));
-var path22 = __toESM(require("path"));
-var os10 = __toESM(require("os"));
+var fs23 = __toESM(require("fs"));
+var path23 = __toESM(require("path"));
+var os11 = __toESM(require("os"));
 var DEFAULT_CACHE_TTL = 60;
-var CACHE_DIR = path22.join(os10.homedir(), ".episoda", "cache");
+var CACHE_DIR = path23.join(os11.homedir(), ".episoda", "cache");
 function getCacheFilePath(projectId) {
-  return path22.join(CACHE_DIR, `env-vars-${projectId}.json`);
+  return path23.join(CACHE_DIR, `env-vars-${projectId}.json`);
 }
 function ensureCacheDir() {
-  if (!fs22.existsSync(CACHE_DIR)) {
-    fs22.mkdirSync(CACHE_DIR, { recursive: true, mode: 448 });
+  if (!fs23.existsSync(CACHE_DIR)) {
+    fs23.mkdirSync(CACHE_DIR, { recursive: true, mode: 448 });
   }
 }
 function readCache(projectId) {
   try {
     const cacheFile = getCacheFilePath(projectId);
-    if (!fs22.existsSync(cacheFile)) {
+    if (!fs23.existsSync(cacheFile)) {
       return null;
     }
-    const content = fs22.readFileSync(cacheFile, "utf-8");
+    const content = fs23.readFileSync(cacheFile, "utf-8");
     const data = JSON.parse(content);
     if (!data.vars || typeof data.vars !== "object" || !data.fetchedAt) {
       return null;
@@ -10355,7 +10501,7 @@ function writeCache(projectId, vars) {
       fetchedAt: Date.now(),
       projectId
     };
-    fs22.writeFileSync(cacheFile, JSON.stringify(data, null, 2), { mode: 384 });
+    fs23.writeFileSync(cacheFile, JSON.stringify(data, null, 2), { mode: 384 });
   } catch (error) {
     console.warn("[env-cache] Failed to write cache:", error instanceof Error ? error.message : error);
   }
@@ -10424,11 +10570,11 @@ No cached values available as fallback.`
 }
 
 // src/preview/dev-server-registry.ts
-var fs23 = __toESM(require("fs"));
-var path23 = __toESM(require("path"));
-var os11 = __toESM(require("os"));
+var fs24 = __toESM(require("fs"));
+var path24 = __toESM(require("path"));
+var os12 = __toESM(require("os"));
 var import_child_process12 = require("child_process");
-var DEV_SERVER_REGISTRY_DIR = path23.join(os11.homedir(), ".episoda", "dev-servers");
+var DEV_SERVER_REGISTRY_DIR = path24.join(os12.homedir(), ".episoda", "dev-servers");
 var DevServerRegistry = class {
   constructor() {
     this.ensureRegistryDir();
@@ -10438,9 +10584,9 @@ var DevServerRegistry = class {
    */
   ensureRegistryDir() {
     try {
-      if (!fs23.existsSync(DEV_SERVER_REGISTRY_DIR)) {
+      if (!fs24.existsSync(DEV_SERVER_REGISTRY_DIR)) {
         console.log(`[DevServerRegistry] EP1042: Creating registry directory: ${DEV_SERVER_REGISTRY_DIR}`);
-        fs23.mkdirSync(DEV_SERVER_REGISTRY_DIR, { recursive: true });
+        fs24.mkdirSync(DEV_SERVER_REGISTRY_DIR, { recursive: true });
       }
     } catch (error) {
       console.error(`[DevServerRegistry] EP1042: Failed to create registry directory:`, error);
@@ -10451,7 +10597,7 @@ var DevServerRegistry = class {
    * Get the registry file path for a module
    */
   getEntryPath(moduleUid) {
-    return path23.join(DEV_SERVER_REGISTRY_DIR, `${moduleUid}.json`);
+    return path24.join(DEV_SERVER_REGISTRY_DIR, `${moduleUid}.json`);
   }
   /**
    * Register a dev server
@@ -10462,8 +10608,10 @@ var DevServerRegistry = class {
     try {
       this.ensureRegistryDir();
       const entryPath = this.getEntryPath(entry.moduleUid);
-      fs23.writeFileSync(entryPath, JSON.stringify(entry, null, 2), "utf8");
-      console.log(`[DevServerRegistry] EP1042: Registered ${entry.moduleUid} (PID ${entry.pid}, port ${entry.port})`);
+      fs24.writeFileSync(entryPath, JSON.stringify(entry, null, 2), "utf8");
+      console.log(
+        `[DevServerRegistry] EP1042: Registered ${entry.moduleUid} (PID ${entry.pid}, port ${entry.port}${entry.wsPort ? `, wsPort ${entry.wsPort}` : ""})`
+      );
     } catch (error) {
       console.error(`[DevServerRegistry] EP1042: Failed to register ${entry.moduleUid}:`, error);
     }
@@ -10476,8 +10624,8 @@ var DevServerRegistry = class {
   unregister(moduleUid) {
     try {
       const entryPath = this.getEntryPath(moduleUid);
-      if (fs23.existsSync(entryPath)) {
-        fs23.unlinkSync(entryPath);
+      if (fs24.existsSync(entryPath)) {
+        fs24.unlinkSync(entryPath);
         console.log(`[DevServerRegistry] EP1042: Unregistered ${moduleUid}`);
       }
     } catch (error) {
@@ -10493,16 +10641,21 @@ var DevServerRegistry = class {
   getByModule(moduleUid) {
     try {
       const entryPath = this.getEntryPath(moduleUid);
-      if (!fs23.existsSync(entryPath)) {
+      if (!fs24.existsSync(entryPath)) {
         return null;
       }
-      const content = fs23.readFileSync(entryPath, "utf8");
+      const content = fs24.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 (entry.wsPort !== void 0 && (typeof entry.wsPort !== "number" || entry.wsPort <= 0)) {
+        console.warn(`[DevServerRegistry] EP1042: Invalid wsPort 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);
@@ -10534,7 +10687,7 @@ var DevServerRegistry = class {
     const entries = [];
     try {
       this.ensureRegistryDir();
-      const files = fs23.readdirSync(DEV_SERVER_REGISTRY_DIR).filter((f) => f.endsWith(".json"));
+      const files = fs24.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);
@@ -10592,7 +10745,7 @@ var DevServerRegistry = class {
       return null;
     } catch {
       try {
-        return fs23.readlinkSync(`/proc/${pid}/cwd`);
+        return fs24.readlinkSync(`/proc/${pid}/cwd`);
       } catch {
         return null;
       }
@@ -10649,6 +10802,10 @@ var DevServerRegistry = class {
             }
             cleaned.push(entry.pid);
           }
+          if (entry.wsPort) {
+            const wsPids = this.killWsServerOnPort(entry.wsPort, entry.worktreePath);
+            cleaned.push(...wsPids);
+          }
           this.unregister(entry.moduleUid);
         }
       }
@@ -10702,7 +10859,39 @@ var DevServerRegistry = class {
     return killed;
   }
   wait(ms) {
-    return new Promise((resolve4) => setTimeout(resolve4, ms));
+    return new Promise((resolve6) => setTimeout(resolve6, ms));
+  }
+  killWsServerOnPort(wsPort, worktreePath) {
+    const killed = [];
+    try {
+      const output = (0, import_child_process12.execSync)(`lsof -ti:${wsPort} 2>/dev/null || true`, {
+        encoding: "utf8",
+        timeout: 5e3
+      }).trim();
+      if (!output) {
+        return killed;
+      }
+      const expectedPath = path24.resolve(worktreePath);
+      const pids = output.split("\n").map((line) => parseInt(line, 10)).filter((pid) => !isNaN(pid) && pid > 0);
+      for (const pid of pids) {
+        const command = (0, import_child_process12.execSync)(`ps -p ${pid} -o command=`, { encoding: "utf8", timeout: 5e3 }).trim();
+        const cwd = this.getProcessCwd(pid);
+        const cwdMatches = cwd ? path24.resolve(cwd) === expectedPath : false;
+        const isWsServer = command.includes("ws-server.js") || command.includes("build:ws-server");
+        if (!isWsServer || !cwdMatches) {
+          continue;
+        }
+        this.killProcess(pid, "SIGTERM");
+        killed.push(pid);
+      }
+      for (const pid of killed) {
+        if (this.isProcessRunning(pid)) {
+          this.killProcess(pid, "SIGKILL");
+        }
+      }
+    } catch {
+    }
+    return killed;
   }
 };
 var registryInstance = null;
@@ -10729,6 +10918,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
     const {
       projectPath,
       port,
+      wsPort,
       moduleUid,
       customCommand,
       autoRestart = true
@@ -10738,13 +10928,21 @@ var DevServerRunner = class extends import_events2.EventEmitter {
       const existingEntry = registry.getByPort(port);
       if (existingEntry) {
         if (existingEntry.worktreePath === projectPath && existingEntry.moduleUid === moduleUid) {
+          const wsHealthy = await this.checkWsHealth(wsPort);
+          if (!wsHealthy) {
+            console.warn(
+              `[DevServerRunner] EP1412: Existing server for ${moduleUid} has unhealthy ws-server on ${wsPort}; preserving preview because app port ${port} is healthy`
+            );
+          }
           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);
+        if (existingEntry.worktreePath !== projectPath || existingEntry.moduleUid !== moduleUid) {
+          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);
@@ -10754,21 +10952,32 @@ var DevServerRunner = class extends import_events2.EventEmitter {
         return { success: false, error: `Port ${port} still in use after cleanup` };
       }
     }
+    const wsPortAvailability = await this.ensureWsPortAvailable(projectPath, wsPort);
+    if (wsPortAvailability) {
+      return wsPortAvailability;
+    }
     const existing = this.servers.get(moduleUid);
     if (existing && !existing.process.killed) {
+      const wsHealthy = await this.checkWsHealth(existing.wsPort);
+      if (!wsHealthy) {
+        console.warn(
+          `[DevServerRunner] EP1412: In-memory server exists for ${moduleUid} with unhealthy ws-server (${existing.wsPort}); preserving running app process`
+        );
+      }
       console.log(`[DevServerRunner] Process already exists for ${moduleUid}`);
       return { success: true, alreadyRunning: true };
     }
-    console.log(`[DevServerRunner] Starting dev server for ${moduleUid} on port ${port}...`);
+    console.log(`[DevServerRunner] Starting dev server for ${moduleUid} on port ${port} (ws:${wsPort})...`);
     const injectedEnvVars = await this.fetchEnvVars(projectPath);
     try {
       const logPath = this.getLogFilePath(moduleUid);
-      const process2 = this.spawnProcess(projectPath, port, moduleUid, logPath, customCommand, injectedEnvVars);
+      const process2 = this.spawnProcess(projectPath, port, wsPort, moduleUid, logPath, customCommand, injectedEnvVars);
       const state = {
         process: process2,
         moduleUid,
         projectPath,
         port,
+        wsPort,
         startedAt: /* @__PURE__ */ new Date(),
         restartCount: 0,
         lastRestartAt: null,
@@ -10788,16 +10997,26 @@ 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" };
       }
+      console.log(`[DevServerRunner] Waiting for ws-server on port ${wsPort}...`);
+      const wsReady = await this.waitForWsPort(wsPort, DEV_SERVER_CONSTANTS.STARTUP_TIMEOUT_MS);
+      if (!wsReady) {
+        const wsStartError = this.detectWsStartupError(logPath, wsPort);
+        this.writeToLog(logPath, `WARN: ${wsStartError}`, true);
+        console.warn(
+          `[DevServerRunner] EP1412: ws-server did not become healthy on ${wsPort}; continuing because preview liveness is app/tunnel based`
+        );
+      }
       if (process2.pid) {
         registry.register({
           pid: process2.pid,
           port,
+          wsPort,
           worktreePath: projectPath,
           startedAt: (/* @__PURE__ */ new Date()).toISOString(),
           moduleUid
         });
       }
-      console.log(`[DevServerRunner] Server started successfully on port ${port}`);
+      console.log(`[DevServerRunner] Server started successfully on ports app:${port} ws:${wsPort}`);
       this.writeToLog(logPath, "Server started successfully");
       this.emit("started", moduleUid, port);
       return { success: true };
@@ -10830,6 +11049,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
           state.process.kill("SIGKILL");
         }
       }
+      await this.cleanupWsServerOnPort(state.wsPort, state.projectPath);
     } else if (registryEntry) {
       console.log(`[DevServerRunner] EP1042: Stopping orphaned server for ${moduleUid} (PID ${registryEntry.pid})`);
       if (registry.isProcessRunning(registryEntry.pid)) {
@@ -10839,6 +11059,9 @@ var DevServerRunner = class extends import_events2.EventEmitter {
           registry.killProcess(registryEntry.pid, "SIGKILL");
         }
       }
+      if (registryEntry.wsPort) {
+        await this.cleanupWsServerOnPort(registryEntry.wsPort, registryEntry.worktreePath);
+      }
     }
     this.servers.delete(moduleUid);
     registry.unregister(moduleUid);
@@ -10852,7 +11075,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
     if (!state) {
       return { success: false, error: `No dev server found for ${moduleUid}` };
     }
-    const { projectPath, port, autoRestartEnabled, customCommand, logFile } = state;
+    const { projectPath, port, wsPort, autoRestartEnabled, customCommand, logFile } = state;
     console.log(`[DevServerRunner] Restarting server for ${moduleUid}...`);
     this.writeToLog(logFile, "Manual restart requested");
     await this.stop(moduleUid);
@@ -10863,6 +11086,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
     return this.start({
       projectPath,
       port,
+      wsPort,
       moduleUid,
       customCommand,
       autoRestart: autoRestartEnabled
@@ -10878,6 +11102,16 @@ var DevServerRunner = class extends import_events2.EventEmitter {
     }
     return this.checkHealth(state.port);
   }
+  /**
+   * Check if ws-server for a module is healthy
+   */
+  async isWsHealthy(moduleUid) {
+    const state = this.servers.get(moduleUid);
+    if (!state) {
+      return false;
+    }
+    return this.checkWsHealth(state.wsPort);
+  }
   /**
    * Check if a dev server is running
    */
@@ -10949,6 +11183,125 @@ var DevServerRunner = class extends import_events2.EventEmitter {
       return false;
     }
   }
+  async ensureWsPortAvailable(projectPath, wsPort) {
+    if (!await isPortInUse(wsPort)) {
+      return null;
+    }
+    const pids = this.getPidsOnPort(wsPort);
+    if (pids.length === 0) {
+      return { success: false, error: `WS_BIND_CONFLICT: WS port ${wsPort} is already in use.` };
+    }
+    const registry = getDevServerRegistry();
+    const expectedPath = path25.resolve(projectPath);
+    const unsafe = [];
+    const killable = [];
+    for (const pid of pids) {
+      const command = this.getProcessCommand(pid);
+      const cwd = registry.getProcessCwd(pid);
+      const cwdMatches = cwd ? path25.resolve(cwd) === expectedPath : false;
+      if (this.isLikelyWsServerProcess(command) && cwdMatches) {
+        killable.push(pid);
+      } else {
+        unsafe.push({ pid, command });
+      }
+    }
+    if (unsafe.length > 0) {
+      const details = unsafe.map((item) => `PID ${item.pid} (${item.command})`).join(", ");
+      return {
+        success: false,
+        error: `WS_BIND_CONFLICT: WS port ${wsPort} is in use by another process: ${details}`
+      };
+    }
+    for (const pid of killable) {
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch {
+      }
+    }
+    await this.wait(800);
+    for (const pid of killable) {
+      try {
+        process.kill(pid, 0);
+        process.kill(pid, "SIGKILL");
+      } catch {
+      }
+    }
+    await this.wait(400);
+    if (await isPortInUse(wsPort)) {
+      return {
+        success: false,
+        error: `WS_BIND_CONFLICT: WS port ${wsPort} remained in use after stale ws-server cleanup`
+      };
+    }
+    return null;
+  }
+  async cleanupWsServerOnPort(wsPort, worktreePath) {
+    if (!wsPort || !await isPortInUse(wsPort)) return;
+    const registry = getDevServerRegistry();
+    const expectedPath = path25.resolve(worktreePath);
+    const pids = this.getPidsOnPort(wsPort);
+    for (const pid of pids) {
+      const command = this.getProcessCommand(pid);
+      const cwd = registry.getProcessCwd(pid);
+      const cwdMatches = cwd ? path25.resolve(cwd) === expectedPath : false;
+      if (!this.isLikelyWsServerProcess(command) || !cwdMatches) {
+        continue;
+      }
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch {
+      }
+    }
+    await this.wait(500);
+    for (const pid of pids) {
+      const command = this.getProcessCommand(pid);
+      const cwd = registry.getProcessCwd(pid);
+      const cwdMatches = cwd ? path25.resolve(cwd) === expectedPath : false;
+      if (!this.isLikelyWsServerProcess(command) || !cwdMatches) {
+        continue;
+      }
+      try {
+        process.kill(pid, 0);
+        process.kill(pid, "SIGKILL");
+      } catch {
+      }
+    }
+  }
+  getPidsOnPort(port) {
+    try {
+      const output = (0, import_child_process13.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
+      if (!output) return [];
+      return output.split("\n").map((value) => parseInt(value, 10)).filter((value) => !isNaN(value) && value > 0);
+    } catch {
+      return [];
+    }
+  }
+  getProcessCommand(pid) {
+    try {
+      return (0, import_child_process13.execSync)(`ps -p ${pid} -o command=`, { encoding: "utf8" }).trim() || "unknown";
+    } catch {
+      return "unknown";
+    }
+  }
+  isLikelyWsServerProcess(command) {
+    return command.includes("ws-server.js") || command.includes("build:ws-server");
+  }
+  detectWsStartupError(logPath, wsPort) {
+    const fallback = `WS_BIND_CONFLICT: ws-server failed to become healthy on WS port ${wsPort}`;
+    if (!logPath) return fallback;
+    try {
+      if (!fs25.existsSync(logPath)) return fallback;
+      const content = fs25.readFileSync(logPath, "utf8");
+      if (content.includes("EADDRINUSE") && content.includes(`${wsPort}`)) {
+        return `WS_BIND_CONFLICT: ws-server could not bind to WS port ${wsPort} (EADDRINUSE)`;
+      }
+      if (content.includes("Failed to initialize")) {
+        return `WS_SERVER_START_FAILED: ws-server failed during startup on WS port ${wsPort}`;
+      }
+    } catch {
+    }
+    return fallback;
+  }
   // ============ Private Methods ============
   async fetchEnvVars(projectPath) {
     try {
@@ -10962,8 +11315,8 @@ var DevServerRunner = class extends import_events2.EventEmitter {
         cacheTtl: 300
       });
       console.log(`[DevServerRunner] Loaded ${Object.keys(result.envVars).length} env vars`);
-      const envFilePath = path24.join(projectPath, ".env");
-      if (!fs24.existsSync(envFilePath) && Object.keys(result.envVars).length > 0) {
+      const envFilePath = path25.join(projectPath, ".env");
+      if (!fs25.existsSync(envFilePath) && Object.keys(result.envVars).length > 0) {
         console.log(`[DevServerRunner] Writing .env file`);
         writeEnvFile(projectPath, result.envVars);
       }
@@ -10973,7 +11326,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
       return {};
     }
   }
-  spawnProcess(projectPath, port, moduleUid, logPath, customCommand, envVars) {
+  spawnProcess(projectPath, port, wsPort, moduleUid, logPath, customCommand, envVars) {
     this.rotateLogIfNeeded(logPath);
     const nodeOptions = process.env.NODE_OPTIONS || "";
     const memoryFlag = `--max-old-space-size=${DEV_SERVER_CONSTANTS.NODE_MEMORY_LIMIT_MB}`;
@@ -10985,6 +11338,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
       ...process.env,
       ...envVars,
       PORT: String(port),
+      WS_PORT: String(wsPort),
       NODE_OPTIONS: enhancedNodeOptions
     };
     const proc = (0, import_child_process13.spawn)(cmd, args, {
@@ -11048,6 +11402,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
     const newProcess = this.spawnProcess(
       state.projectPath,
       state.port,
+      state.wsPort,
       moduleUid,
       logPath,
       state.customCommand,
@@ -11078,7 +11433,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
     return Math.min(delay, DEV_SERVER_CONSTANTS.MAX_RESTART_DELAY_MS);
   }
   async checkHealth(port) {
-    return new Promise((resolve4) => {
+    return new Promise((resolve6) => {
       const req = http.request(
         {
           hostname: "localhost",
@@ -11087,12 +11442,35 @@ var DevServerRunner = class extends import_events2.EventEmitter {
           method: "HEAD",
           timeout: DEV_SERVER_CONSTANTS.HEALTH_CHECK_TIMEOUT_MS
         },
-        () => resolve4(true)
+        () => resolve6(true)
+      );
+      req.on("error", () => resolve6(false));
+      req.on("timeout", () => {
+        req.destroy();
+        resolve6(false);
+      });
+      req.end();
+    });
+  }
+  async checkWsHealth(wsPort) {
+    return new Promise((resolve6) => {
+      const req = http.request(
+        {
+          hostname: "127.0.0.1",
+          port: wsPort,
+          path: "/health",
+          method: "GET",
+          timeout: DEV_SERVER_CONSTANTS.HEALTH_CHECK_TIMEOUT_MS
+        },
+        (res) => {
+          resolve6(res.statusCode === 200);
+          res.resume();
+        }
       );
-      req.on("error", () => resolve4(false));
+      req.on("error", () => resolve6(false));
       req.on("timeout", () => {
         req.destroy();
-        resolve4(false);
+        resolve6(false);
       });
       req.end();
     });
@@ -11108,29 +11486,40 @@ var DevServerRunner = class extends import_events2.EventEmitter {
     }
     return false;
   }
+  async waitForWsPort(wsPort, timeoutMs) {
+    const startTime = Date.now();
+    const checkInterval = 500;
+    while (Date.now() - startTime < timeoutMs) {
+      if (await this.checkWsHealth(wsPort)) {
+        return true;
+      }
+      await this.wait(checkInterval);
+    }
+    return false;
+  }
   wait(ms) {
-    return new Promise((resolve4) => setTimeout(resolve4, ms));
+    return new Promise((resolve6) => setTimeout(resolve6, ms));
   }
   getLogsDir() {
-    const logsDir = path24.join((0, import_core12.getConfigDir)(), "logs");
-    if (!fs24.existsSync(logsDir)) {
-      fs24.mkdirSync(logsDir, { recursive: true });
+    const logsDir = path25.join((0, import_core12.getConfigDir)(), "logs");
+    if (!fs25.existsSync(logsDir)) {
+      fs25.mkdirSync(logsDir, { recursive: true });
     }
     return logsDir;
   }
   getLogFilePath(moduleUid) {
-    return path24.join(this.getLogsDir(), `dev-${moduleUid}.log`);
+    return path25.join(this.getLogsDir(), `dev-${moduleUid}.log`);
   }
   rotateLogIfNeeded(logPath) {
     try {
-      if (fs24.existsSync(logPath)) {
-        const stats = fs24.statSync(logPath);
+      if (fs25.existsSync(logPath)) {
+        const stats = fs25.statSync(logPath);
         if (stats.size > DEV_SERVER_CONSTANTS.MAX_LOG_SIZE_BYTES) {
           const backupPath = `${logPath}.1`;
-          if (fs24.existsSync(backupPath)) {
-            fs24.unlinkSync(backupPath);
+          if (fs25.existsSync(backupPath)) {
+            fs25.unlinkSync(backupPath);
           }
-          fs24.renameSync(logPath, backupPath);
+          fs25.renameSync(logPath, backupPath);
         }
       }
     } catch {
@@ -11141,7 +11530,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
     try {
       const timestamp = (/* @__PURE__ */ new Date()).toISOString();
       const prefix = isError ? "ERR" : "OUT";
-      fs24.appendFileSync(logPath, `[${timestamp}] [${prefix}] ${line}
+      fs25.appendFileSync(logPath, `[${timestamp}] [${prefix}] ${line}
 `);
     } catch {
     }
@@ -11150,6 +11539,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
     return {
       moduleUid: state.moduleUid,
       port: state.port,
+      wsPort: state.wsPort,
       pid: state.process.pid,
       startedAt: state.startedAt,
       uptime: Math.floor((Date.now() - state.startedAt.getTime()) / 1e3),
@@ -11210,7 +11600,8 @@ var PreviewManager = class extends import_events3.EventEmitter {
    * @returns Result with success status and preview URL
    */
   async startPreview(config) {
-    const { moduleUid, worktreePath, port = DEFAULT_PORT, customCommand } = config;
+    const { moduleUid, worktreePath, port = DEFAULT_PORT, wsPort: requestedWsPort, customCommand } = config;
+    let wsPort = requestedWsPort;
     if (!worktreePath) {
       return { success: false, error: "Worktree path is required" };
     }
@@ -11237,29 +11628,50 @@ var PreviewManager = class extends import_events3.EventEmitter {
     }
     const existing = this.previews.get(moduleUid);
     if (existing && (existing.state === "live" || existing.state === "running")) {
-      console.log(`[PreviewManager] Preview already running for ${moduleUid}`);
-      return {
-        success: true,
-        previewUrl: existing.tunnelUrl,
-        alreadyRunning: true
-      };
+      const appHealthy = await this.devServer.isHealthy(moduleUid);
+      const wsHealthy = await this.devServer.isWsHealthy(moduleUid);
+      if (appHealthy) {
+        if (!wsHealthy) {
+          console.warn(
+            `[PreviewManager] EP1412: Preview app is healthy for ${moduleUid}; ws-server unhealthy (${existing.wsPort}) is diagnostics-only for preview liveness`
+          );
+        }
+        console.log(`[PreviewManager] Preview already running for ${moduleUid}`);
+        return {
+          success: true,
+          previewUrl: existing.tunnelUrl,
+          alreadyRunning: true
+        };
+      }
+      console.warn(
+        `[PreviewManager] EP1412: Existing preview for ${moduleUid} is unhealthy (app=${appHealthy}, ws=${wsHealthy}); restarting due to app health failure`
+      );
+      await this.stopPreview(moduleUid);
     }
     this.startingModules.add(moduleUid);
-    console.log(`[PreviewManager] Starting preview for ${moduleUid} at ${worktreePath}:${port}`);
-    const state = {
-      moduleUid,
-      worktreePath,
-      port,
-      state: "starting",
-      startedAt: /* @__PURE__ */ new Date()
-    };
-    this.previews.set(moduleUid, state);
-    this.emitStateChange(moduleUid, "starting");
+    let state = null;
     try {
+      if (!wsPort) {
+        wsPort = allocateWsPort(moduleUid);
+      }
+      wsPort = assignWsPort(moduleUid, wsPort);
+      console.log(`[PreviewManager] Starting preview for ${moduleUid} at ${worktreePath}:${port} (ws:${wsPort})`);
+      state = {
+        moduleUid,
+        worktreePath,
+        port,
+        wsPort,
+        state: "starting",
+        startedAt: /* @__PURE__ */ new Date()
+      };
+      const activeState = state;
+      this.previews.set(moduleUid, state);
+      this.emitStateChange(moduleUid, "starting");
       console.log(`[PreviewManager] Starting dev server for ${moduleUid}...`);
       const devResult = await this.devServer.start({
         projectPath: worktreePath,
         port,
+        wsPort,
         moduleUid,
         customCommand,
         autoRestart: true
@@ -11267,6 +11679,8 @@ var PreviewManager = class extends import_events3.EventEmitter {
       if (!devResult.success) {
         state.state = "error";
         state.error = devResult.error || "Failed to start dev server";
+        releasePort(moduleUid);
+        releaseWsPort(moduleUid);
         this.emitStateChange(moduleUid, "error");
         this.emit("error", moduleUid, new Error(state.error));
         return { success: false, error: state.error };
@@ -11275,7 +11689,7 @@ var PreviewManager = class extends import_events3.EventEmitter {
       this.emitStateChange(moduleUid, "running");
       console.log(`[PreviewManager] Dev server running on port ${port}`);
       console.log(`[PreviewManager] Starting Named Tunnel for ${moduleUid}...`);
-      state.state = "tunneling";
+      activeState.state = "tunneling";
       this.emitStateChange(moduleUid, "tunneling");
       const MAX_TUNNEL_RETRIES = 2;
       let tunnelResult = { success: false };
@@ -11283,7 +11697,7 @@ var PreviewManager = class extends import_events3.EventEmitter {
       for (let attempt = 1; attempt <= MAX_TUNNEL_RETRIES; attempt++) {
         if (attempt > 1) {
           console.log(`[PreviewManager] Retrying tunnel for ${moduleUid} (attempt ${attempt}/${MAX_TUNNEL_RETRIES})...`);
-          await new Promise((resolve4) => setTimeout(resolve4, 2e3));
+          await new Promise((resolve6) => setTimeout(resolve6, 2e3));
         }
         tunnelResult = await this.tunnel.startTunnel({
           moduleUid,
@@ -11293,20 +11707,20 @@ var PreviewManager = class extends import_events3.EventEmitter {
           onStatusChange: (status, error) => {
             console.log(`[PreviewManager] Tunnel status for ${moduleUid}: ${status}${error ? ` - ${error}` : ""}`);
             if (status === "error") {
-              state.state = "error";
-              state.error = error || "Tunnel error";
+              activeState.state = "error";
+              activeState.error = error || "Tunnel error";
               this.emitStateChange(moduleUid, "error");
             } else if (status === "disconnected") {
-              state.state = "running";
-              state.tunnelUrl = void 0;
+              activeState.state = "running";
+              activeState.tunnelUrl = void 0;
               this.emitStateChange(moduleUid, "running");
             } else if (status === "reconnecting") {
-              state.state = "tunneling";
+              activeState.state = "tunneling";
               this.emitStateChange(moduleUid, "tunneling");
             }
           },
           onUrl: (url) => {
-            state.tunnelUrl = url;
+            activeState.tunnelUrl = url;
           }
         });
         if (tunnelResult.success) {
@@ -11322,8 +11736,10 @@ var PreviewManager = class extends import_events3.EventEmitter {
         } catch (cleanupError) {
           console.warn(`[PreviewManager] Error cleaning up dev server after tunnel failure:`, cleanupError);
         }
-        state.state = "error";
-        state.error = lastError;
+        releasePort(moduleUid);
+        releaseWsPort(moduleUid);
+        activeState.state = "error";
+        activeState.error = lastError;
         this.previews.delete(moduleUid);
         this.emitStateChange(moduleUid, "error");
         return {
@@ -11331,9 +11747,9 @@ var PreviewManager = class extends import_events3.EventEmitter {
           error: `Tunnel failed after ${MAX_TUNNEL_RETRIES} attempts: ${lastError}`
         };
       }
-      state.state = "live";
-      state.tunnelUrl = tunnelResult.url;
-      state.error = void 0;
+      activeState.state = "live";
+      activeState.tunnelUrl = tunnelResult.url;
+      activeState.error = void 0;
       this.emitStateChange(moduleUid, "live");
       this.emit("live", moduleUid, tunnelResult.url);
       console.log(`[PreviewManager] Preview live for ${moduleUid}: ${tunnelResult.url}`);
@@ -11344,9 +11760,17 @@ var PreviewManager = class extends import_events3.EventEmitter {
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
       console.error(`[PreviewManager] Error starting preview for ${moduleUid}:`, error);
-      state.state = "error";
-      state.error = errorMsg;
-      this.emitStateChange(moduleUid, "error");
+      if (state) {
+        state.state = "error";
+        state.error = errorMsg;
+      } else {
+        this.previews.delete(moduleUid);
+      }
+      releasePort(moduleUid);
+      releaseWsPort(moduleUid);
+      if (state) {
+        this.emitStateChange(moduleUid, "error");
+      }
       this.emit("error", moduleUid, error instanceof Error ? error : new Error(errorMsg));
       return { success: false, error: errorMsg };
     } finally {
@@ -11382,6 +11806,7 @@ var PreviewManager = class extends import_events3.EventEmitter {
       console.warn(`[PreviewManager] Error clearing tunnel URL for ${moduleUid}:`, error);
     }
     releasePort(moduleUid);
+    releaseWsPort(moduleUid);
     if (state) {
       state.state = "stopped";
       state.tunnelUrl = void 0;
@@ -11404,11 +11829,12 @@ var PreviewManager = class extends import_events3.EventEmitter {
     }
     console.log(`[PreviewManager] Restarting preview for ${moduleUid}`);
     await this.stopPreview(moduleUid);
-    await new Promise((resolve4) => setTimeout(resolve4, 1e3));
+    await new Promise((resolve6) => setTimeout(resolve6, 1e3));
     return this.startPreview({
       moduleUid,
       worktreePath: state.worktreePath,
-      port: state.port
+      port: state.port,
+      wsPort: state.wsPort
     });
   }
   /**
@@ -11431,6 +11857,7 @@ var PreviewManager = class extends import_events3.EventEmitter {
       tunnelUrl: state.tunnelUrl,
       tunnelState: tunnelInfo?.status === "connected" ? "connected" : tunnelInfo?.status === "starting" ? "starting" : tunnelInfo?.status === "error" ? "error" : tunnelInfo?.status === "disconnected" ? "disconnected" : void 0,
       port: state.port,
+      wsPort: state.wsPort,
       error: state.error,
       startedAt: state.startedAt
     };
@@ -11595,8 +12022,8 @@ async function deleteWorktree(config, moduleUid) {
 }
 
 // src/daemon/package-manager.ts
-var fs25 = __toESM(require("fs"));
-var path25 = __toESM(require("path"));
+var fs26 = __toESM(require("fs"));
+var path26 = __toESM(require("path"));
 function pnpmCommand(args) {
   return [
     "if command -v pnpm >/dev/null 2>&1; then",
@@ -11614,13 +12041,13 @@ var PACKAGE_MANAGERS = {
     {
       name: "pnpm",
       detector: (p) => {
-        if (fs25.existsSync(path25.join(p, "pnpm-lock.yaml"))) {
+        if (fs26.existsSync(path26.join(p, "pnpm-lock.yaml"))) {
           return "pnpm-lock.yaml";
         }
-        const pkgJsonPath = path25.join(p, "package.json");
-        if (fs25.existsSync(pkgJsonPath)) {
+        const pkgJsonPath = path26.join(p, "package.json");
+        if (fs26.existsSync(pkgJsonPath)) {
           try {
-            const pkg = JSON.parse(fs25.readFileSync(pkgJsonPath, "utf-8"));
+            const pkg = JSON.parse(fs26.readFileSync(pkgJsonPath, "utf-8"));
             if (pkg.packageManager?.startsWith("pnpm")) {
               return "package.json (packageManager field)";
             }
@@ -11636,7 +12063,7 @@ var PACKAGE_MANAGERS = {
     },
     {
       name: "yarn",
-      detector: (p) => fs25.existsSync(path25.join(p, "yarn.lock")) ? "yarn.lock" : null,
+      detector: (p) => fs26.existsSync(path26.join(p, "yarn.lock")) ? "yarn.lock" : null,
       config: {
         installCmd: "yarn install --frozen-lockfile",
         cacheEnvVar: "YARN_CACHE_FOLDER"
@@ -11644,14 +12071,14 @@ var PACKAGE_MANAGERS = {
     },
     {
       name: "bun",
-      detector: (p) => fs25.existsSync(path25.join(p, "bun.lockb")) ? "bun.lockb" : null,
+      detector: (p) => fs26.existsSync(path26.join(p, "bun.lockb")) ? "bun.lockb" : null,
       config: {
         installCmd: "bun install --frozen-lockfile"
       }
     },
     {
       name: "npm",
-      detector: (p) => fs25.existsSync(path25.join(p, "package-lock.json")) ? "package-lock.json" : null,
+      detector: (p) => fs26.existsSync(path26.join(p, "package-lock.json")) ? "package-lock.json" : null,
       config: {
         installCmd: "npm ci"
       }
@@ -11660,7 +12087,7 @@ var PACKAGE_MANAGERS = {
       // EP1222: Default to pnpm for new projects without lockfile
       // This encourages standardization on pnpm across Episoda projects
       name: "pnpm",
-      detector: (p) => fs25.existsSync(path25.join(p, "package.json")) ? "package.json (no lockfile - defaulting to pnpm)" : null,
+      detector: (p) => fs26.existsSync(path26.join(p, "package.json")) ? "package.json (no lockfile - defaulting to pnpm)" : null,
       config: {
         installCmd: pnpmCommand("install"),
         cacheEnvVar: "PNPM_HOME"
@@ -11671,13 +12098,13 @@ var PACKAGE_MANAGERS = {
     {
       name: "uv",
       detector: (p) => {
-        const pyprojectPath = path25.join(p, "pyproject.toml");
-        if (fs25.existsSync(path25.join(p, "uv.lock"))) {
+        const pyprojectPath = path26.join(p, "pyproject.toml");
+        if (fs26.existsSync(path26.join(p, "uv.lock"))) {
           return "uv.lock";
         }
-        if (fs25.existsSync(pyprojectPath)) {
+        if (fs26.existsSync(pyprojectPath)) {
           try {
-            const content = fs25.readFileSync(pyprojectPath, "utf-8");
+            const content = fs26.readFileSync(pyprojectPath, "utf-8");
             if (content.includes("[tool.uv]") || content.includes("[project]")) {
               return "pyproject.toml";
             }
@@ -11693,7 +12120,7 @@ var PACKAGE_MANAGERS = {
     },
     {
       name: "pip",
-      detector: (p) => fs25.existsSync(path25.join(p, "requirements.txt")) ? "requirements.txt" : null,
+      detector: (p) => fs26.existsSync(path26.join(p, "requirements.txt")) ? "requirements.txt" : null,
       config: {
         installCmd: "pip install -r requirements.txt"
       }
@@ -11745,15 +12172,15 @@ function detectPackageManager(worktreePath, preferredLanguages) {
 }
 
 // src/daemon/build-packages.ts
-var fs26 = __toESM(require("fs"));
-var path26 = __toESM(require("path"));
+var fs27 = __toESM(require("fs"));
+var path27 = __toESM(require("path"));
 function hasPackageScript(worktreePath, scriptName) {
   try {
-    const packageJsonPath = path26.join(worktreePath, "package.json");
-    if (!fs26.existsSync(packageJsonPath)) {
+    const packageJsonPath = path27.join(worktreePath, "package.json");
+    if (!fs27.existsSync(packageJsonPath)) {
       return false;
     }
-    const packageJson2 = JSON.parse(fs26.readFileSync(packageJsonPath, "utf-8"));
+    const packageJson2 = JSON.parse(fs27.readFileSync(packageJsonPath, "utf-8"));
     return typeof packageJson2.scripts?.[scriptName] === "string";
   } catch {
     return false;
@@ -11811,19 +12238,19 @@ function persistWorkspaceProjectContext(workspaceSlug, projectSlug, projectId) {
   if (process.env.EPISODA_MODE !== "cloud") {
     return;
   }
-  const homeDir = process.env.HOME || os12.homedir();
-  const workspaceConfigPath = path27.join(
+  const homeDir = process.env.HOME || os13.homedir();
+  const workspaceConfigPath = path28.join(
     homeDir,
     "episoda",
     workspaceSlug,
     ".episoda",
     "config.json"
   );
-  if (!fs27.existsSync(workspaceConfigPath)) {
+  if (!fs28.existsSync(workspaceConfigPath)) {
     return;
   }
   try {
-    const content = fs27.readFileSync(workspaceConfigPath, "utf8");
+    const content = fs28.readFileSync(workspaceConfigPath, "utf8");
     const workspaceConfig = JSON.parse(content);
     let changed = false;
     if (projectId && workspaceConfig.projectId !== projectId && workspaceConfig.project_id !== projectId) {
@@ -11835,7 +12262,7 @@ function persistWorkspaceProjectContext(workspaceSlug, projectSlug, projectId) {
       changed = true;
     }
     if (changed) {
-      fs27.writeFileSync(workspaceConfigPath, JSON.stringify(workspaceConfig, null, 2), "utf8");
+      fs28.writeFileSync(workspaceConfigPath, JSON.stringify(workspaceConfig, null, 2), "utf8");
       console.log("[Worktree] Updated workspace config with project context");
     }
   } catch (error) {
@@ -11882,19 +12309,19 @@ async function handleWorktreeCreate(request2) {
   }
   try {
     const projectPath = getProjectPath(workspaceSlug, projectSlug);
-    const bareRepoPath = path27.join(projectPath, ".bare");
+    const bareRepoPath = path28.join(projectPath, ".bare");
     const gitEnv = projectId ? { ...process.env, EPISODA_PROJECT_ID: projectId } : process.env;
-    if (!fs27.existsSync(bareRepoPath)) {
+    if (!fs28.existsSync(bareRepoPath)) {
       console.log(`[Worktree] K1273: Project not found, cloning lazily...`);
       console.log(`[Worktree]   Repo URL: ${repoUrl.replace(/\/\/[^@]*@/, "//***@")}`);
-      const episodaDir = path27.join(projectPath, ".episoda");
-      fs27.mkdirSync(episodaDir, { recursive: true });
+      const episodaDir = path28.join(projectPath, ".episoda");
+      fs28.mkdirSync(episodaDir, { recursive: true });
       try {
         console.log(`[Worktree] K1273: Starting git clone...`);
         await execAsync2(`git clone --bare "${repoUrl}" "${bareRepoPath}"`, { env: gitEnv });
         console.log(`[Worktree] K1273: Clone successful`);
         await execAsync2(`git -C "${bareRepoPath}" config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"`, { env: gitEnv });
-        const configPath = path27.join(episodaDir, "config.json");
+        const configPath = path28.join(episodaDir, "config.json");
         const config = {
           projectId,
           workspaceSlug,
@@ -11903,7 +12330,7 @@ async function handleWorktreeCreate(request2) {
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),
           worktrees: []
         };
-        fs27.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+        fs28.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
         console.log(`[Worktree] K1273: Project initialized at ${projectPath}`);
       } catch (cloneError) {
         console.error(`[Worktree] K1273: Git clone failed: ${cloneError.message}`);
@@ -11916,8 +12343,8 @@ async function handleWorktreeCreate(request2) {
       console.log(`[Worktree] EP1373: Project exists, skipping handler-level fetch (manager handles narrow fetch)`);
     }
     const manager = new WorktreeManager(projectPath);
-    const initialized2 = await manager.initialize();
-    if (!initialized2) {
+    const initialized3 = await manager.initialize();
+    if (!initialized3) {
       return {
         success: false,
         error: `Failed to initialize WorktreeManager at ${projectPath}`
@@ -11938,8 +12365,8 @@ async function handleWorktreeCreate(request2) {
     let finalError;
     if (envVars && Object.keys(envVars).length > 0) {
       const envContent = Object.entries(envVars).map(([key, value]) => `${key}=${value}`).join("\n");
-      const envPath = path27.join(worktreePath, ".env");
-      fs27.writeFileSync(envPath, envContent + "\n", "utf-8");
+      const envPath = path28.join(worktreePath, ".env");
+      fs28.writeFileSync(envPath, envContent + "\n", "utf-8");
       console.log(`[Worktree] EP1143: Wrote ${Object.keys(envVars).length} env vars to .env`);
     }
     const isCloud = process.env.EPISODA_MODE === "cloud";
@@ -12011,8 +12438,8 @@ async function handleWorktreeRelease(request2) {
   try {
     const projectPath = getProjectPath(workspaceSlug, projectSlug);
     const manager = new WorktreeManager(projectPath);
-    const initialized2 = await manager.initialize();
-    if (!initialized2) {
+    const initialized3 = await manager.initialize();
+    if (!initialized3) {
       console.log(`[Worktree] EP1143: Project not initialized, nothing to release`);
       return { success: true };
     }
@@ -12065,8 +12492,8 @@ async function handleWorktreeList(workspaceSlug, projectSlug) {
   try {
     const projectPath = getProjectPath(workspaceSlug, projectSlug);
     const manager = new WorktreeManager(projectPath);
-    const initialized2 = await manager.initialize();
-    if (!initialized2) {
+    const initialized3 = await manager.initialize();
+    if (!initialized3) {
       return { success: true, worktrees: [] };
     }
     const worktrees = manager.listWorktrees();
@@ -12080,18 +12507,18 @@ async function handleProjectEject(request2) {
   console.log(`[Worktree] EP1144: Ejecting project ${projectSlug} from workspace ${workspaceSlug}`);
   try {
     const projectPath = getProjectPath(workspaceSlug, projectSlug);
-    const bareRepoPath = path27.join(projectPath, ".bare");
-    if (!fs27.existsSync(projectPath)) {
+    const bareRepoPath = path28.join(projectPath, ".bare");
+    if (!fs28.existsSync(projectPath)) {
       console.log(`[Worktree] EP1144: Project path not found, nothing to eject: ${projectPath}`);
       return { success: true };
     }
-    if (!fs27.existsSync(bareRepoPath)) {
+    if (!fs28.existsSync(bareRepoPath)) {
       console.log(`[Worktree] EP1144: Bare repo not found, nothing to eject: ${bareRepoPath}`);
       return { success: true };
     }
     const manager = new WorktreeManager(projectPath);
-    const initialized2 = await manager.initialize();
-    if (initialized2) {
+    const initialized3 = await manager.initialize();
+    if (initialized3) {
       const worktrees = manager.listWorktrees();
       if (worktrees.length > 0) {
         return {
@@ -12100,12 +12527,12 @@ async function handleProjectEject(request2) {
         };
       }
     }
-    const artifactsPath = path27.join(projectPath, "artifacts");
-    if (fs27.existsSync(artifactsPath)) {
+    const artifactsPath = path28.join(projectPath, "artifacts");
+    if (fs28.existsSync(artifactsPath)) {
       await persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug);
     }
     console.log(`[Worktree] EP1144: Removing project directory: ${projectPath}`);
-    await fs27.promises.rm(projectPath, { recursive: true, force: true });
+    await fs28.promises.rm(projectPath, { recursive: true, force: true });
     console.log(`[Worktree] EP1144: Successfully ejected project ${projectSlug}`);
     return { success: true };
   } catch (error) {
@@ -12119,7 +12546,7 @@ async function handleProjectEject(request2) {
 async function persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug) {
   const MAX_ARTIFACT_SIZE = 10 * 1024 * 1024;
   try {
-    const files = await fs27.promises.readdir(artifactsPath);
+    const files = await fs28.promises.readdir(artifactsPath);
     if (files.length === 0) {
       return;
     }
@@ -12133,8 +12560,8 @@ async function persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug
     }
     const artifacts = [];
     for (const fileName of files) {
-      const filePath = path27.join(artifactsPath, fileName);
-      const stat = await fs27.promises.stat(filePath);
+      const filePath = path28.join(artifactsPath, fileName);
+      const stat = await fs28.promises.stat(filePath);
       if (stat.isDirectory()) {
         continue;
       }
@@ -12143,9 +12570,9 @@ async function persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug
         continue;
       }
       try {
-        const content = await fs27.promises.readFile(filePath);
+        const content = await fs28.promises.readFile(filePath);
         const base64Content = content.toString("base64");
-        const ext = path27.extname(fileName).toLowerCase();
+        const ext = path28.extname(fileName).toLowerCase();
         const mimeTypes = {
           ".json": "application/json",
           ".txt": "text/plain",
@@ -12201,8 +12628,8 @@ async function persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug
 }
 
 // src/daemon/handlers/project-handlers.ts
-var path28 = __toESM(require("path"));
-var fs28 = __toESM(require("fs"));
+var path29 = __toESM(require("path"));
+var fs29 = __toESM(require("fs"));
 function validateSlug(slug, fieldName) {
   if (!slug || typeof slug !== "string") {
     return `${fieldName} is required`;
@@ -12242,14 +12669,14 @@ async function handleProjectSetup(params) {
   console.log(`[ProjectSetup] EP1199: Setting up project ${workspaceSlug}/${projectSlug}`);
   try {
     const projectPath = getProjectPath(workspaceSlug, projectSlug);
-    const artifactsPath = path28.join(projectPath, "artifacts");
-    const configDir = path28.join(projectPath, ".episoda");
-    const configPath = path28.join(configDir, "config.json");
-    await fs28.promises.mkdir(artifactsPath, { recursive: true });
-    await fs28.promises.mkdir(configDir, { recursive: true });
+    const artifactsPath = path29.join(projectPath, "artifacts");
+    const configDir = path29.join(projectPath, ".episoda");
+    const configPath = path29.join(configDir, "config.json");
+    await fs29.promises.mkdir(artifactsPath, { recursive: true });
+    await fs29.promises.mkdir(configDir, { recursive: true });
     let existingConfig = {};
     try {
-      const existing = await fs28.promises.readFile(configPath, "utf-8");
+      const existing = await fs29.promises.readFile(configPath, "utf-8");
       existingConfig = JSON.parse(existing);
     } catch {
     }
@@ -12262,7 +12689,7 @@ async function handleProjectSetup(params) {
       // Only set created_at if not already present
       created_at: existingConfig.created_at || (/* @__PURE__ */ new Date()).toISOString()
     };
-    await fs28.promises.writeFile(configPath, JSON.stringify(config, null, 2));
+    await fs29.promises.writeFile(configPath, JSON.stringify(config, null, 2));
     console.log(`[ProjectSetup] EP1199: Project setup complete at ${projectPath}`);
     return {
       success: true,
@@ -12282,8 +12709,8 @@ async function handleProjectSetup(params) {
 // src/utils/dev-server.ts
 var import_child_process15 = require("child_process");
 var import_core14 = __toESM(require_dist());
-var fs29 = __toESM(require("fs"));
-var path29 = __toESM(require("path"));
+var fs30 = __toESM(require("fs"));
+var path30 = __toESM(require("path"));
 var MAX_RESTART_ATTEMPTS = 5;
 var INITIAL_RESTART_DELAY_MS = 2e3;
 var MAX_RESTART_DELAY_MS = 3e4;
@@ -12291,26 +12718,26 @@ var MAX_LOG_SIZE_BYTES2 = 5 * 1024 * 1024;
 var NODE_MEMORY_LIMIT_MB = 2048;
 var activeServers = /* @__PURE__ */ new Map();
 function getLogsDir() {
-  const logsDir = path29.join((0, import_core14.getConfigDir)(), "logs");
-  if (!fs29.existsSync(logsDir)) {
-    fs29.mkdirSync(logsDir, { recursive: true });
+  const logsDir = path30.join((0, import_core14.getConfigDir)(), "logs");
+  if (!fs30.existsSync(logsDir)) {
+    fs30.mkdirSync(logsDir, { recursive: true });
   }
   return logsDir;
 }
 function getLogFilePath(moduleUid) {
-  return path29.join(getLogsDir(), `dev-${moduleUid}.log`);
+  return path30.join(getLogsDir(), `dev-${moduleUid}.log`);
 }
 function rotateLogIfNeeded(logPath) {
   try {
-    if (fs29.existsSync(logPath)) {
-      const stats = fs29.statSync(logPath);
+    if (fs30.existsSync(logPath)) {
+      const stats = fs30.statSync(logPath);
       if (stats.size > MAX_LOG_SIZE_BYTES2) {
         const backupPath = `${logPath}.1`;
-        if (fs29.existsSync(backupPath)) {
-          fs29.unlinkSync(backupPath);
+        if (fs30.existsSync(backupPath)) {
+          fs30.unlinkSync(backupPath);
         }
-        fs29.renameSync(logPath, backupPath);
-        console.log(`[DevServer] EP932: Rotated log file for ${path29.basename(logPath)}`);
+        fs30.renameSync(logPath, backupPath);
+        console.log(`[DevServer] EP932: Rotated log file for ${path30.basename(logPath)}`);
       }
     }
   } catch (error) {
@@ -12323,7 +12750,7 @@ function writeToLog(logPath, line, isError = false) {
     const prefix = isError ? "ERR" : "OUT";
     const logLine = `[${timestamp}] [${prefix}] ${line}
 `;
-    fs29.appendFileSync(logPath, logLine);
+    fs30.appendFileSync(logPath, logLine);
   } catch {
   }
 }
@@ -12343,7 +12770,7 @@ async function killProcessOnPort(port) {
       } catch {
       }
     }
-    await new Promise((resolve4) => setTimeout(resolve4, 1e3));
+    await new Promise((resolve6) => setTimeout(resolve6, 1e3));
     for (const pid of pids) {
       try {
         (0, import_child_process15.execSync)(`kill -0 ${pid} 2>/dev/null`, { encoding: "utf8" });
@@ -12352,7 +12779,7 @@ async function killProcessOnPort(port) {
       } catch {
       }
     }
-    await new Promise((resolve4) => setTimeout(resolve4, 500));
+    await new Promise((resolve6) => setTimeout(resolve6, 500));
     const stillInUse = await isPortInUse(port);
     if (stillInUse) {
       console.error(`[DevServer] EP929: Port ${port} still in use after kill attempts`);
@@ -12372,7 +12799,7 @@ async function waitForPort(port, timeoutMs = 3e4) {
     if (await isPortInUse(port)) {
       return true;
     }
-    await new Promise((resolve4) => setTimeout(resolve4, checkInterval));
+    await new Promise((resolve6) => setTimeout(resolve6, checkInterval));
   }
   return false;
 }
@@ -12444,7 +12871,7 @@ async function handleProcessExit(moduleUid, code, signal) {
   const delay = calculateRestartDelay(serverInfo.restartCount);
   console.log(`[DevServer] EP932: Restarting ${moduleUid} in ${delay}ms (attempt ${serverInfo.restartCount + 1}/${MAX_RESTART_ATTEMPTS})`);
   writeToLog(serverInfo.logFile || "", `Scheduling restart in ${delay}ms (attempt ${serverInfo.restartCount + 1})`, false);
-  await new Promise((resolve4) => setTimeout(resolve4, delay));
+  await new Promise((resolve6) => setTimeout(resolve6, delay));
   if (!activeServers.has(moduleUid)) {
     console.log(`[DevServer] EP932: Server ${moduleUid} was removed during restart delay, aborting restart`);
     return;
@@ -12502,8 +12929,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 = path29.join(projectPath, ".env");
-      if (!fs29.existsSync(envFilePath) && Object.keys(injectedEnvVars).length > 0) {
+      const envFilePath = path30.join(projectPath, ".env");
+      if (!fs30.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);
       }
@@ -12569,7 +12996,7 @@ async function stopDevServer(moduleUid) {
       writeToLog(serverInfo.logFile, `Stopping server (manual stop)`, false);
     }
     serverInfo.process.kill("SIGTERM");
-    await new Promise((resolve4) => setTimeout(resolve4, 2e3));
+    await new Promise((resolve6) => setTimeout(resolve6, 2e3));
     if (!serverInfo.process.killed) {
       serverInfo.process.kill("SIGKILL");
     }
@@ -12587,7 +13014,7 @@ async function restartDevServer(moduleUid) {
     writeToLog(logFile, `Manual restart requested`, false);
   }
   await stopDevServer(moduleUid);
-  await new Promise((resolve4) => setTimeout(resolve4, 1e3));
+  await new Promise((resolve6) => setTimeout(resolve6, 1e3));
   if (await isPortInUse(port)) {
     await killProcessOnPort(port);
   }
@@ -12641,9 +13068,9 @@ var IPCRouter = class {
         // EP726: Kept for backward compatibility
         machineName: this.host.deviceName,
         // EP1186: User-friendly machine name from server
-        hostname: os13.hostname(),
-        platform: os13.platform(),
-        arch: os13.arch(),
+        hostname: os14.hostname(),
+        platform: os14.platform(),
+        arch: os14.arch(),
         projects
       };
     });
@@ -12669,7 +13096,7 @@ var IPCRouter = class {
           if (attempt < MAX_RETRIES) {
             const delay = INITIAL_DELAY * Math.pow(2, attempt - 1);
             console.log(`[Daemon] Retrying in ${delay / 1e3}s...`);
-            await new Promise((resolve4) => setTimeout(resolve4, delay));
+            await new Promise((resolve6) => setTimeout(resolve6, delay));
             await this.host.disconnectProject(projectPath);
           }
         }
@@ -12807,6 +13234,7 @@ var IPCRouter = class {
       await tunnelManager.stopTunnel(moduleUid);
       await stopDevServer(moduleUid);
       releasePort(moduleUid);
+      releaseWsPort(moduleUid);
       await clearTunnelUrl(moduleUid);
       this.host.deleteTunnelHealthFailure(moduleUid);
       console.log(`[Daemon] EP823: Tunnel stopped for ${moduleUid}`);
@@ -12844,8 +13272,8 @@ var IPCRouter = class {
 };
 
 // src/daemon/update-manager.ts
-var fs30 = __toESM(require("fs"));
-var path30 = __toESM(require("path"));
+var fs31 = __toESM(require("fs"));
+var path31 = __toESM(require("path"));
 var import_child_process17 = require("child_process");
 var import_core17 = __toESM(require_dist());
 var semver2 = __toESM(require("semver"));
@@ -13103,8 +13531,8 @@ var UpdateManager = class _UpdateManager {
       console.log(`[Daemon] EP1324: Update to ${targetVersion} installed, restarting daemon...`);
       await this.host.shutdown();
       const configDir = (0, import_core17.getConfigDir)();
-      const logPath = path30.join(configDir, "daemon.log");
-      const logFd = fs30.openSync(logPath, "a");
+      const logPath = path31.join(configDir, "daemon.log");
+      const logFd = fs31.openSync(logPath, "a");
       const child = (0, import_child_process17.spawn)("node", [this.daemonEntryFile], {
         detached: true,
         stdio: ["ignore", logFd, logFd],
@@ -13112,7 +13540,7 @@ var UpdateManager = class _UpdateManager {
       });
       if (!child.pid) {
         try {
-          fs30.closeSync(logFd);
+          fs31.closeSync(logFd);
         } catch {
         }
         this.recordUpdateFailure(targetVersion, "Failed to spawn replacement daemon (missing pid)");
@@ -13120,7 +13548,7 @@ var UpdateManager = class _UpdateManager {
       }
       child.unref();
       const pidPath = getPidFilePath();
-      fs30.writeFileSync(pidPath, child.pid.toString(), "utf-8");
+      fs31.writeFileSync(pidPath, child.pid.toString(), "utf-8");
       console.log(`[Daemon] EP1324: New daemon spawned (PID: ${child.pid}), exiting old process`);
       process.exit(0);
     } catch (error) {
@@ -13171,8 +13599,8 @@ var UpdateManager = class _UpdateManager {
 };
 
 // src/daemon/health-orchestrator.ts
-var fs31 = __toESM(require("fs"));
-var path31 = __toESM(require("path"));
+var fs32 = __toESM(require("fs"));
+var path32 = __toESM(require("path"));
 var import_core18 = __toESM(require_dist());
 var HealthOrchestrator = class _HealthOrchestrator {
   constructor(host) {
@@ -13376,10 +13804,15 @@ var HealthOrchestrator = class _HealthOrchestrator {
         console.log(`[Daemon] EP1042: Killed ${cleanup.cleaned} orphaned dev server(s)`);
       }
       const registryPorts = /* @__PURE__ */ new Map();
+      const registryWsPorts = /* @__PURE__ */ new Map();
       for (const entry of registry.getAll()) {
         registryPorts.set(entry.moduleUid, entry.port);
+        if (entry.wsPort) {
+          registryWsPorts.set(entry.moduleUid, entry.wsPort);
+        }
       }
       reconcileWithRegistry(registryPorts);
+      reconcileWsPortsWithRegistry(registryWsPorts);
       console.log("[Daemon] EP1042: Orphaned dev server cleanup complete");
     } catch (error) {
       console.error("[Daemon] EP1042: Failed to clean up orphaned dev servers:", error);
@@ -13421,26 +13854,26 @@ var HealthOrchestrator = class _HealthOrchestrator {
   checkAndRotateLog() {
     try {
       const configDir = (0, import_core18.getConfigDir)();
-      const logPath = path31.join(configDir, "daemon.log");
-      if (!fs31.existsSync(logPath)) return;
-      const stats = fs31.statSync(logPath);
+      const logPath = path32.join(configDir, "daemon.log");
+      if (!fs32.existsSync(logPath)) return;
+      const stats = fs32.statSync(logPath);
       if (stats.size < _HealthOrchestrator.MAX_LOG_SIZE_BYTES) return;
       console.log(`[Daemon] EP1351: daemon.log is ${Math.round(stats.size / 1024 / 1024)}MB, rotating...`);
       for (let i = _HealthOrchestrator.MAX_LOG_FILES - 1; i >= 1; i--) {
         const src = `${logPath}.${i}`;
         const dst = `${logPath}.${i + 1}`;
-        if (fs31.existsSync(src)) {
+        if (fs32.existsSync(src)) {
           try {
-            fs31.renameSync(src, dst);
+            fs32.renameSync(src, dst);
           } catch {
           }
         }
       }
       try {
-        fs31.copyFileSync(logPath, `${logPath}.1`);
+        fs32.copyFileSync(logPath, `${logPath}.1`);
       } catch {
       }
-      fs31.truncateSync(logPath, 0);
+      fs32.truncateSync(logPath, 0);
       console.log("[Daemon] EP1351: Log rotated successfully");
     } catch (error) {
       console.warn("[Daemon] EP1351: Log rotation failed:", error instanceof Error ? error.message : error);
@@ -13489,9 +13922,9 @@ var HealthOrchestrator = class _HealthOrchestrator {
           if (Number.isFinite(lastAccessedMs)) {
             referenceTimestampMs = lastAccessedMs;
             fallbackAgeSource.push(`${w.moduleUid}(lastAccessed)`);
-          } else if (w.worktreePath && fs31.existsSync(w.worktreePath)) {
+          } else if (w.worktreePath && fs32.existsSync(w.worktreePath)) {
             try {
-              const stats = fs31.statSync(w.worktreePath);
+              const stats = fs32.statSync(w.worktreePath);
               referenceTimestampMs = stats.mtimeMs;
               fallbackAgeSource.push(`${w.moduleUid}(fs.mtime)`);
             } catch {
@@ -13857,7 +14290,7 @@ var ConnectionManager = class {
    * handlers are removed deterministically on every exit path.
    */
   async waitForAuthentication(client, timeoutMs = 3e4) {
-    await new Promise((resolve4, reject) => {
+    await new Promise((resolve6, reject) => {
       let settled = false;
       const cleanup = () => {
         clearTimeout(timeout);
@@ -13874,7 +14307,7 @@ var ConnectionManager = class {
         if (settled) return;
         settled = true;
         cleanup();
-        resolve4();
+        resolve6();
       };
       const errorHandler = (message) => {
         if (settled) return;
@@ -13937,7 +14370,7 @@ function resolveDaemonWsEndpoint(config, env = process.env) {
 
 // src/daemon/project-message-router.ts
 var import_core19 = __toESM(require_dist());
-var path32 = __toESM(require("path"));
+var path33 = __toESM(require("path"));
 var ProjectMessageRouter = class {
   constructor(host) {
     this.host = host;
@@ -13954,7 +14387,7 @@ var ProjectMessageRouter = class {
         client.updateActivity();
         try {
           const gitCmd = message.command;
-          const bareRepoPath = path32.join(projectPath, ".bare");
+          const bareRepoPath = path33.join(projectPath, ".bare");
           const cwd = gitCmd.worktreePath || bareRepoPath;
           if (gitCmd.worktreePath) {
             console.log(`[Daemon] Routing command to worktree: ${gitCmd.worktreePath}`);
@@ -14294,32 +14727,32 @@ async function fetchEnvVars2(projectId) {
 }
 
 // src/daemon/project-git-config.ts
-var fs32 = __toESM(require("fs"));
-var path33 = __toESM(require("path"));
+var fs33 = __toESM(require("fs"));
+var path34 = __toESM(require("path"));
 var import_core21 = __toESM(require_dist());
 function getGitDirs(projectPath) {
-  const bareDir = path33.join(projectPath, ".bare");
-  const gitPath = path33.join(projectPath, ".git");
-  if (fs32.existsSync(bareDir) && fs32.statSync(bareDir).isDirectory()) {
+  const bareDir = path34.join(projectPath, ".bare");
+  const gitPath = path34.join(projectPath, ".git");
+  if (fs33.existsSync(bareDir) && fs33.statSync(bareDir).isDirectory()) {
     return { gitDir: bareDir, workDir: projectPath };
   }
-  if (fs32.existsSync(gitPath) && fs32.statSync(gitPath).isDirectory()) {
+  if (fs33.existsSync(gitPath) && fs33.statSync(gitPath).isDirectory()) {
     return { gitDir: null, workDir: projectPath };
   }
-  if (fs32.existsSync(gitPath) && fs32.statSync(gitPath).isFile()) {
+  if (fs33.existsSync(gitPath) && fs33.statSync(gitPath).isFile()) {
     return { gitDir: null, workDir: projectPath };
   }
-  const entries = fs32.readdirSync(projectPath, { withFileTypes: true });
+  const entries = fs33.readdirSync(projectPath, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory() && entry.name.startsWith("EP")) {
-      const worktreePath = path33.join(projectPath, entry.name);
-      const worktreeGit = path33.join(worktreePath, ".git");
-      if (fs32.existsSync(worktreeGit)) {
+      const worktreePath = path34.join(projectPath, entry.name);
+      const worktreeGit = path34.join(worktreePath, ".git");
+      if (fs33.existsSync(worktreeGit)) {
         return { gitDir: null, workDir: worktreePath };
       }
     }
   }
-  if (fs32.existsSync(bareDir)) {
+  if (fs33.existsSync(bareDir)) {
     return { gitDir: bareDir, workDir: projectPath };
   }
   return { gitDir: null, workDir: projectPath };
@@ -14364,24 +14797,24 @@ async function configureGitUser(projectPath, userId, workspaceId, machineId, pro
 async function installGitHooks(projectPath) {
   const hooks = ["post-checkout", "pre-commit", "post-commit"];
   let hooksDir;
-  const bareHooksDir = path33.join(projectPath, ".bare", "hooks");
-  const gitHooksDir = path33.join(projectPath, ".git", "hooks");
-  if (fs32.existsSync(bareHooksDir)) {
+  const bareHooksDir = path34.join(projectPath, ".bare", "hooks");
+  const gitHooksDir = path34.join(projectPath, ".git", "hooks");
+  if (fs33.existsSync(bareHooksDir)) {
     hooksDir = bareHooksDir;
-  } else if (fs32.existsSync(gitHooksDir) && fs32.statSync(path33.join(projectPath, ".git")).isDirectory()) {
+  } else if (fs33.existsSync(gitHooksDir) && fs33.statSync(path34.join(projectPath, ".git")).isDirectory()) {
     hooksDir = gitHooksDir;
   } else {
-    const parentBareHooks = path33.join(projectPath, "..", ".bare", "hooks");
-    if (fs32.existsSync(parentBareHooks)) {
+    const parentBareHooks = path34.join(projectPath, "..", ".bare", "hooks");
+    if (fs33.existsSync(parentBareHooks)) {
       hooksDir = parentBareHooks;
     } else {
       console.warn(`[Daemon] Hooks directory not found for: ${projectPath}`);
       return;
     }
   }
-  if (!fs32.existsSync(hooksDir)) {
+  if (!fs33.existsSync(hooksDir)) {
     try {
-      fs32.mkdirSync(hooksDir, { recursive: true });
+      fs33.mkdirSync(hooksDir, { recursive: true });
     } catch {
       console.warn(`[Daemon] Hooks directory not found and could not create: ${hooksDir}`);
       return;
@@ -14389,20 +14822,20 @@ async function installGitHooks(projectPath) {
   }
   for (const hookName of hooks) {
     try {
-      const hookPath = path33.join(hooksDir, hookName);
-      const bundledHookPath = path33.join(__dirname, "..", "hooks", hookName);
-      if (!fs32.existsSync(bundledHookPath)) {
+      const hookPath = path34.join(hooksDir, hookName);
+      const bundledHookPath = path34.join(__dirname, "..", "hooks", hookName);
+      if (!fs33.existsSync(bundledHookPath)) {
         console.warn(`[Daemon] Bundled hook not found: ${bundledHookPath}`);
         continue;
       }
-      const hookContent = fs32.readFileSync(bundledHookPath, "utf-8");
-      if (fs32.existsSync(hookPath)) {
-        const existingContent = fs32.readFileSync(hookPath, "utf-8");
+      const hookContent = fs33.readFileSync(bundledHookPath, "utf-8");
+      if (fs33.existsSync(hookPath)) {
+        const existingContent = fs33.readFileSync(hookPath, "utf-8");
         if (existingContent === hookContent) {
           continue;
         }
       }
-      fs32.writeFileSync(hookPath, hookContent, { mode: 493 });
+      fs33.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);
@@ -14545,9 +14978,9 @@ var Daemon = class _Daemon {
       this.healthServer = http2.createServer((req, res) => {
         if (req.url === "/health" || req.url === "/") {
           const isConnected = this.connectionManager.liveConnectionCount() > 0;
-          const projects = Array.from(this.connectionManager.entries()).map(([path34, conn]) => ({
-            path: path34,
-            connected: this.connectionManager.hasLiveConnection(path34)
+          const projects = Array.from(this.connectionManager.entries()).map(([path35, conn]) => ({
+            path: path35,
+            connected: this.connectionManager.hasLiveConnection(path35)
           }));
           const status = {
             status: isConnected ? "healthy" : "degraded",
@@ -14620,8 +15053,8 @@ var Daemon = class _Daemon {
     await this.shutdown();
     try {
       const pidPath = getPidFilePath();
-      if (fs33.existsSync(pidPath)) {
-        fs33.unlinkSync(pidPath);
+      if (fs34.existsSync(pidPath)) {
+        fs34.unlinkSync(pidPath);
         console.log("[Daemon] PID file cleaned up (watchdog)");
       }
     } catch (error) {
@@ -14684,8 +15117,8 @@ var Daemon = class _Daemon {
       }
     }
     let releaseLock;
-    const lockPromise = new Promise((resolve4) => {
-      releaseLock = resolve4;
+    const lockPromise = new Promise((resolve6) => {
+      releaseLock = resolve6;
     });
     this.tunnelOperationLocks.set(moduleUid, lockPromise);
     try {
@@ -14712,7 +15145,7 @@ var Daemon = class _Daemon {
         const maxWait = 35e3;
         const startTime = Date.now();
         while (this.connectionManager.hasPendingConnection(projectPath) && Date.now() - startTime < maxWait) {
-          await new Promise((resolve4) => setTimeout(resolve4, 500));
+          await new Promise((resolve6) => setTimeout(resolve6, 500));
         }
         if (this.connectionManager.hasLiveConnection(projectPath)) {
           console.log(`[Daemon] Pending connection succeeded for ${projectPath}`);
@@ -15011,8 +15444,8 @@ var Daemon = class _Daemon {
             };
           } else {
             const manager = new WorktreeManager(projectRootPath);
-            const initialized2 = await manager.initialize();
-            if (!initialized2) {
+            const initialized3 = await manager.initialize();
+            if (!initialized3) {
               console.warn(`[Daemon] EP1035: Failed to initialize WorktreeManager for ${projectRootPath}`);
               result = {
                 success: false,
@@ -15210,8 +15643,8 @@ var Daemon = class _Daemon {
       let daemonPid;
       try {
         const pidPath = getPidFilePath();
-        if (fs33.existsSync(pidPath)) {
-          const pidStr = fs33.readFileSync(pidPath, "utf-8").trim();
+        if (fs34.existsSync(pidPath)) {
+          const pidStr = fs34.readFileSync(pidPath, "utf-8").trim();
           daemonPid = parseInt(pidStr, 10);
         }
       } catch (pidError) {
@@ -15222,9 +15655,9 @@ var Daemon = class _Daemon {
       const containerId = process.env.EPISODA_CONTAINER_ID;
       const capabilities = ["worktree_create_v1"];
       await client.connect(wsEndpoint.wsUrl, config.access_token, this.machineId, {
-        hostname: os14.hostname(),
-        osPlatform: os14.platform(),
-        osArch: os14.arch(),
+        hostname: os15.hostname(),
+        osPlatform: os15.platform(),
+        osArch: os15.arch(),
         daemonPid,
         cliVersion: this.cliRuntimeVersion,
         cliPackageName: packageJson.name,
@@ -15763,6 +16196,7 @@ var Daemon = class _Daemon {
       console.error("[Daemon] Failed to stop tunnels:", error);
     }
     clearAllPorts();
+    clearAllWsPorts();
     if (this.disconnectWatchdogTimer) {
       clearInterval(this.disconnectWatchdogTimer);
       this.disconnectWatchdogTimer = null;
@@ -15785,8 +16219,8 @@ var Daemon = class _Daemon {
     await this.shutdown();
     try {
       const pidPath = getPidFilePath();
-      if (fs33.existsSync(pidPath)) {
-        fs33.unlinkSync(pidPath);
+      if (fs34.existsSync(pidPath)) {
+        fs34.unlinkSync(pidPath);
         console.log("[Daemon] PID file cleaned up");
       }
     } catch (error) {