episoda 0.2.40 → 0.2.42

package/dist/daemon/daemon-process.js

@@ -6,16 +6,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -1559,15 +1552,15 @@ var require_git_executor = __commonJS({
           try {
             const { stdout: gitDir } = await execAsync2("git rev-parse --git-dir", { cwd, timeout: 5e3 });
             const gitDirPath = gitDir.trim();
-            const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+            const fs18 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
             const rebaseMergePath = `${gitDirPath}/rebase-merge`;
             const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
             try {
-              await fs17.access(rebaseMergePath);
+              await fs18.access(rebaseMergePath);
               inRebase = true;
             } catch {
               try {
-                await fs17.access(rebaseApplyPath);
+                await fs18.access(rebaseApplyPath);
                 inRebase = true;
               } catch {
                 inRebase = false;
@@ -1621,9 +1614,9 @@ var require_git_executor = __commonJS({
               error: validation.error || "UNKNOWN_ERROR"
             };
           }
-          const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs18 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs17.access(command.path);
+            await fs18.access(command.path);
             return {
               success: false,
               error: "WORKTREE_EXISTS",
@@ -1677,9 +1670,9 @@ var require_git_executor = __commonJS({
        */
       async executeWorktreeRemove(command, cwd, options) {
         try {
-          const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs18 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs17.access(command.path);
+            await fs18.access(command.path);
           } catch {
             return {
               success: false,
@@ -1714,7 +1707,7 @@ var require_git_executor = __commonJS({
           const result = await this.runGitCommand(args, cwd, options);
           if (result.success) {
             try {
-              await fs17.rm(command.path, { recursive: true, force: true });
+              await fs18.rm(command.path, { recursive: true, force: true });
             } catch {
             }
             return {
@@ -1848,10 +1841,10 @@ var require_git_executor = __commonJS({
        */
       async executeCloneBare(command, options) {
         try {
-          const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path18 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs18 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path19 = await Promise.resolve().then(() => __importStar(require("path")));
           try {
-            await fs17.access(command.path);
+            await fs18.access(command.path);
             return {
               success: false,
               error: "BRANCH_ALREADY_EXISTS",
@@ -1860,9 +1853,9 @@ var require_git_executor = __commonJS({
             };
           } catch {
           }
-          const parentDir = path18.dirname(command.path);
+          const parentDir = path19.dirname(command.path);
           try {
-            await fs17.mkdir(parentDir, { recursive: true });
+            await fs18.mkdir(parentDir, { recursive: true });
           } catch {
           }
           const { stdout, stderr } = await execAsync2(
@@ -1910,22 +1903,22 @@ var require_git_executor = __commonJS({
        */
       async executeProjectInfo(cwd, options) {
         try {
-          const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path18 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs18 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path19 = await Promise.resolve().then(() => __importStar(require("path")));
           let currentPath = cwd;
           let projectPath = cwd;
           let bareRepoPath;
           for (let i = 0; i < 10; i++) {
-            const bareDir = path18.join(currentPath, ".bare");
-            const episodaDir = path18.join(currentPath, ".episoda");
+            const bareDir = path19.join(currentPath, ".bare");
+            const episodaDir = path19.join(currentPath, ".episoda");
             try {
-              await fs17.access(bareDir);
-              await fs17.access(episodaDir);
+              await fs18.access(bareDir);
+              await fs18.access(episodaDir);
               projectPath = currentPath;
               bareRepoPath = bareDir;
               break;
             } catch {
-              const parentPath = path18.dirname(currentPath);
+              const parentPath = path19.dirname(currentPath);
               if (parentPath === currentPath) {
                 break;
               }
@@ -2514,36 +2507,36 @@ var require_auth = __commonJS({
       };
     })();
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.getConfigDir = getConfigDir6;
+    exports2.getConfigDir = getConfigDir7;
     exports2.getConfigPath = getConfigPath;
-    exports2.loadConfig = loadConfig6;
+    exports2.loadConfig = loadConfig7;
     exports2.saveConfig = saveConfig2;
     exports2.validateToken = validateToken;
-    var fs17 = __importStar(require("fs"));
-    var path18 = __importStar(require("path"));
+    var fs18 = __importStar(require("fs"));
+    var path19 = __importStar(require("path"));
     var os7 = __importStar(require("os"));
     var child_process_1 = require("child_process");
     var DEFAULT_CONFIG_FILE = "config.json";
-    function getConfigDir6() {
-      return process.env.EPISODA_CONFIG_DIR || path18.join(os7.homedir(), ".episoda");
+    function getConfigDir7() {
+      return process.env.EPISODA_CONFIG_DIR || path19.join(os7.homedir(), ".episoda");
     }
     function getConfigPath(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path18.join(getConfigDir6(), DEFAULT_CONFIG_FILE);
+      return path19.join(getConfigDir7(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path18.dirname(configPath);
-      const isNew = !fs17.existsSync(dir);
+      const dir = path19.dirname(configPath);
+      const isNew = !fs18.existsSync(dir);
       if (isNew) {
-        fs17.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs18.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path18.join(dir, ".nosync");
-        if (isNew || !fs17.existsSync(nosyncPath)) {
+        const nosyncPath = path19.join(dir, ".nosync");
+        if (isNew || !fs18.existsSync(nosyncPath)) {
           try {
-            fs17.writeFileSync(nosyncPath, "", { mode: 384 });
+            fs18.writeFileSync(nosyncPath, "", { mode: 384 });
             (0, child_process_1.execSync)(`xattr -w com.apple.fileprovider.ignore 1 "${dir}"`, {
               stdio: "ignore",
               timeout: 5e3
@@ -2553,13 +2546,13 @@ var require_auth = __commonJS({
         }
       }
     }
-    async function loadConfig6(configPath) {
+    async function loadConfig7(configPath) {
       const fullPath = getConfigPath(configPath);
-      if (!fs17.existsSync(fullPath)) {
+      if (!fs18.existsSync(fullPath)) {
         return null;
       }
       try {
-        const content = fs17.readFileSync(fullPath, "utf8");
+        const content = fs18.readFileSync(fullPath, "utf8");
         const config = JSON.parse(content);
         return config;
       } catch (error) {
@@ -2572,7 +2565,7 @@ var require_auth = __commonJS({
       ensureConfigDir(fullPath);
       try {
         const content = JSON.stringify(config, null, 2);
-        fs17.writeFileSync(fullPath, content, { mode: 384 });
+        fs18.writeFileSync(fullPath, content, { mode: 384 });
       } catch (error) {
         throw new Error(`Failed to save config: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -2684,49 +2677,12 @@ var require_dist = __commonJS({
   }
 });
 
-// src/utils/port-check.ts
-var port_check_exports = {};
-__export(port_check_exports, {
-  getServerPort: () => getServerPort,
-  isPortInUse: () => isPortInUse
-});
-async function isPortInUse(port) {
-  return new Promise((resolve3) => {
-    const server = net2.createServer();
-    server.once("error", (err) => {
-      if (err.code === "EADDRINUSE") {
-        resolve3(true);
-      } else {
-        resolve3(false);
-      }
-    });
-    server.once("listening", () => {
-      server.close();
-      resolve3(false);
-    });
-    server.listen(port);
-  });
-}
-function getServerPort() {
-  if (process.env.PORT) {
-    return parseInt(process.env.PORT, 10);
-  }
-  return 3e3;
-}
-var net2;
-var init_port_check = __esm({
-  "src/utils/port-check.ts"() {
-    "use strict";
-    net2 = __toESM(require("net"));
-  }
-});
-
 // package.json
 var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.40",
+      version: "0.2.42",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -3056,8 +3012,8 @@ var IPCServer = class {
       const message = buffer.slice(0, newlineIndex);
       buffer = buffer.slice(newlineIndex + 1);
       try {
-        const request = JSON.parse(message);
-        const response = await this.handleRequest(request);
+        const request2 = JSON.parse(message);
+        const response = await this.handleRequest(request2);
         socket.write(JSON.stringify(response) + "\n");
       } catch (error) {
         const errorResponse = {
@@ -3075,25 +3031,25 @@ var IPCServer = class {
   /**
    * Handle IPC request
    */
-  async handleRequest(request) {
-    const handler = this.handlers.get(request.command);
+  async handleRequest(request2) {
+    const handler = this.handlers.get(request2.command);
     if (!handler) {
       return {
-        id: request.id,
+        id: request2.id,
         success: false,
-        error: `Unknown command: ${request.command}`
+        error: `Unknown command: ${request2.command}`
       };
     }
     try {
-      const data = await handler(request.params);
+      const data = await handler(request2.params);
       return {
-        id: request.id,
+        id: request2.id,
         success: true,
         data
       };
     } catch (error) {
       return {
-        id: request.id,
+        id: request2.id,
         success: false,
         error: error instanceof Error ? error.message : "Unknown error"
       };
@@ -3102,7 +3058,7 @@ var IPCServer = class {
 };
 
 // src/daemon/daemon-process.ts
-var import_core10 = __toESM(require_dist());
+var import_core11 = __toESM(require_dist());
 
 // src/utils/update-checker.ts
 var import_child_process2 = require("child_process");
@@ -4018,7 +3974,134 @@ var import_events = require("events");
 var fs6 = __toESM(require("fs"));
 var path7 = __toESM(require("path"));
 var os2 = __toESM(require("os"));
+
+// src/tunnel/tunnel-api.ts
+var import_core6 = __toESM(require_dist());
+async function provisionNamedTunnel(moduleId) {
+  const config = await (0, import_core6.loadConfig)();
+  if (!config?.access_token) {
+    return { success: false, error: "Not authenticated" };
+  }
+  try {
+    const apiUrl = config.api_url || "https://episoda.dev";
+    const response = await fetch(`${apiUrl}/api/tunnels`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${config.access_token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ module_id: moduleId })
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      return {
+        success: false,
+        error: data.error?.message || data.message || `HTTP ${response.status}`
+      };
+    }
+    return {
+      success: true,
+      tunnel: data.tunnel,
+      message: data.message
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to provision tunnel"
+    };
+  }
+}
+async function provisionNamedTunnelByUid(moduleUid) {
+  const config = await (0, import_core6.loadConfig)();
+  if (!config?.access_token) {
+    return { success: false, error: "Not authenticated" };
+  }
+  try {
+    const apiUrl = config.api_url || "https://episoda.dev";
+    const moduleResponse = await fetch(`${apiUrl}/api/modules/${moduleUid}`, {
+      headers: {
+        "Authorization": `Bearer ${config.access_token}`
+      }
+    });
+    if (!moduleResponse.ok) {
+      return {
+        success: false,
+        error: `Failed to find module ${moduleUid}`
+      };
+    }
+    const moduleData = await moduleResponse.json();
+    const moduleId = moduleData.moduleRecord?.id;
+    if (!moduleId) {
+      return {
+        success: false,
+        error: `Module ${moduleUid} has no ID (response keys: ${JSON.stringify(Object.keys(moduleData))})`
+      };
+    }
+    return provisionNamedTunnel(moduleId);
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to provision tunnel"
+    };
+  }
+}
+async function updateTunnelStatus(moduleUid, status, error) {
+  if (!moduleUid || moduleUid === "LOCAL") {
+    return;
+  }
+  const config = await (0, import_core6.loadConfig)();
+  if (!config?.access_token) {
+    return;
+  }
+  try {
+    const apiUrl = config.api_url || "https://episoda.dev";
+    await fetch(`${apiUrl}/api/modules/${moduleUid}/tunnel`, {
+      method: "PATCH",
+      headers: {
+        "Authorization": `Bearer ${config.access_token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        tunnel_health_status: status,
+        tunnel_last_health_check: (/* @__PURE__ */ new Date()).toISOString(),
+        ...error && { tunnel_error: error }
+      })
+    });
+  } catch {
+  }
+}
+async function clearTunnelUrl(moduleUid) {
+  if (!moduleUid || moduleUid === "LOCAL") {
+    return;
+  }
+  const config = await (0, import_core6.loadConfig)();
+  if (!config?.access_token) {
+    return;
+  }
+  try {
+    const apiUrl = config.api_url || "https://episoda.dev";
+    await fetch(`${apiUrl}/api/modules/${moduleUid}/tunnel`, {
+      method: "DELETE",
+      headers: {
+        "Authorization": `Bearer ${config.access_token}`
+      }
+    });
+  } catch {
+  }
+}
+
+// src/tunnel/tunnel-manager.ts
 var TUNNEL_PID_DIR = path7.join(os2.homedir(), ".episoda", "tunnels");
+var TUNNEL_TIMEOUTS = {
+  /** Time to wait for Named Tunnel connection (includes API token fetch + connect) */
+  NAMED_TUNNEL_CONNECT: 6e4,
+  /** Time to wait for Quick Tunnel connection (simpler, faster connection) */
+  QUICK_TUNNEL_CONNECT: 3e4,
+  /** Time to wait for cloudflared process to start before giving up */
+  PROCESS_START: 1e4,
+  /** Grace period after starting cloudflared before checking status */
+  STARTUP_GRACE: 2e3
+};
 var TUNNEL_URL_REGEX = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/i;
 var DEFAULT_RECONNECT_CONFIG = {
   maxRetries: 5,
@@ -4075,6 +4158,7 @@ var TunnelManager = class extends import_events.EventEmitter {
   }
   /**
    * EP877: Read PID from file
+   * EP948: Enhanced with validation and stale file cleanup
    */
   readPidFile(moduleUid) {
     try {
@@ -4082,9 +4166,25 @@ var TunnelManager = class extends import_events.EventEmitter {
       if (!fs6.existsSync(pidPath)) {
         return null;
       }
-      const pid = parseInt(fs6.readFileSync(pidPath, "utf8").trim(), 10);
-      return isNaN(pid) ? null : pid;
+      const content = fs6.readFileSync(pidPath, "utf8").trim();
+      const pid = parseInt(content, 10);
+      if (isNaN(pid) || pid <= 0) {
+        console.warn(`[Tunnel] EP948: Invalid PID file content for ${moduleUid}: "${content}", removing stale file`);
+        this.removePidFile(moduleUid);
+        return null;
+      }
+      if (!this.isProcessRunning(pid)) {
+        console.log(`[Tunnel] EP948: PID ${pid} for ${moduleUid} is not running, removing stale file`);
+        this.removePidFile(moduleUid);
+        return null;
+      }
+      return pid;
     } catch (error) {
+      console.warn(`[Tunnel] EP948: Failed to read PID file for ${moduleUid}: ${error.message}`);
+      try {
+        this.removePidFile(moduleUid);
+      } catch {
+      }
       return null;
     }
   }
@@ -4288,10 +4388,190 @@ var TunnelManager = class extends import_events.EventEmitter {
     }, delay);
   }
   /**
-   * EP672-9: Internal method to start the tunnel process
-   * Separated from startTunnel to support reconnection
+   * EP948: Start a Named Tunnel using a pre-provisioned token
+   * Named Tunnels connect to a persistent tunnel created via Cloudflare API
+   */
+  async startNamedTunnelProcess(options, existingState) {
+    const { moduleUid, port = 3e3, onUrl, onStatusChange, tunnelToken, previewUrl } = options;
+    if (!tunnelToken) {
+      return { success: false, error: "Named tunnel requires a token" };
+    }
+    if (!this.cloudflaredPath) {
+      try {
+        this.cloudflaredPath = await ensureCloudflared();
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return { success: false, error: `Failed to get cloudflared: ${errorMessage}` };
+      }
+    }
+    return new Promise((resolve3) => {
+      const tunnelInfo = {
+        moduleUid,
+        url: previewUrl || "",
+        // Named tunnels have a known URL
+        port,
+        status: "starting",
+        startedAt: /* @__PURE__ */ new Date(),
+        process: null
+      };
+      console.log(`[Tunnel] EP948: Starting Named Tunnel for ${moduleUid} with preview URL ${previewUrl}`);
+      const process2 = (0, import_child_process6.spawn)(this.cloudflaredPath, [
+        "tunnel",
+        "run",
+        "--token",
+        tunnelToken
+      ], {
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      tunnelInfo.process = process2;
+      tunnelInfo.pid = process2.pid;
+      if (process2.pid) {
+        this.writePidFile(moduleUid, process2.pid);
+      }
+      const state = existingState || {
+        info: tunnelInfo,
+        options,
+        intentionallyStopped: false,
+        retryCount: 0,
+        retryTimeoutId: null
+      };
+      state.info = tunnelInfo;
+      this.tunnelStates.set(moduleUid, state);
+      let connected = false;
+      let stderrBuffer = "";
+      const connectionPatterns = [
+        /Connection.*registered/i,
+        // "Connection [id] registered"
+        /Registered tunnel connection/i,
+        // Alternative format
+        /connected to.*connector/i,
+        // "connected to [colo] connector ID"
+        /Tunnel is ready/i,
+        // Some versions use this
+        /ingress.*rules.*applied/i,
+        // Indicates ingress rules are active
+        /Initial.*connection.*established/i
+        // Initial connection message
+      ];
+      const checkConnection = (data) => {
+        if (connected) return;
+        const isConnected = connectionPatterns.some((pattern) => pattern.test(data));
+        if (isConnected) {
+          connected = true;
+          tunnelInfo.status = "connected";
+          tunnelInfo.url = previewUrl || "";
+          console.log(`[Tunnel] EP948: Named Tunnel connected for ${moduleUid}: ${previewUrl}`);
+          updateTunnelStatus(moduleUid, "healthy").catch(() => {
+          });
+          onStatusChange?.("connected");
+          onUrl?.(tunnelInfo.url);
+          this.emitEvent({
+            type: "started",
+            moduleUid,
+            url: tunnelInfo.url
+          });
+          resolve3({ success: true, url: tunnelInfo.url });
+        }
+      };
+      process2.stderr?.on("data", (data) => {
+        stderrBuffer += data.toString();
+        checkConnection(stderrBuffer);
+      });
+      process2.stdout?.on("data", (data) => {
+        checkConnection(data.toString());
+      });
+      process2.on("exit", (code, signal) => {
+        const wasConnected = tunnelInfo.status === "connected";
+        tunnelInfo.status = "disconnected";
+        const currentState = this.tunnelStates.get(moduleUid);
+        if (!connected) {
+          const errorMsg = `Named tunnel process exited with code ${code}`;
+          tunnelInfo.status = "error";
+          tunnelInfo.error = errorMsg;
+          updateTunnelStatus(moduleUid, "error", errorMsg).catch(() => {
+          });
+          if (currentState && !currentState.intentionallyStopped) {
+            this.attemptReconnect(moduleUid);
+          } else {
+            this.tunnelStates.delete(moduleUid);
+            onStatusChange?.("error", errorMsg);
+            this.emitEvent({ type: "error", moduleUid, error: errorMsg });
+          }
+          resolve3({ success: false, error: errorMsg });
+        } else if (wasConnected) {
+          if (currentState && !currentState.intentionallyStopped) {
+            console.log(`[Tunnel] EP948: Named tunnel ${moduleUid} crashed unexpectedly, attempting reconnect...`);
+            updateTunnelStatus(moduleUid, "disconnected").catch(() => {
+            });
+            onStatusChange?.("reconnecting");
+            this.attemptReconnect(moduleUid);
+          } else {
+            updateTunnelStatus(moduleUid, "disconnected").catch(() => {
+            });
+            this.tunnelStates.delete(moduleUid);
+            onStatusChange?.("disconnected");
+            this.emitEvent({ type: "stopped", moduleUid });
+          }
+        }
+      });
+      process2.on("error", (error) => {
+        tunnelInfo.status = "error";
+        tunnelInfo.error = error.message;
+        updateTunnelStatus(moduleUid, "error", error.message).catch(() => {
+        });
+        const currentState = this.tunnelStates.get(moduleUid);
+        if (currentState && !currentState.intentionallyStopped) {
+          this.attemptReconnect(moduleUid);
+        } else {
+          this.tunnelStates.delete(moduleUid);
+          onStatusChange?.("error", error.message);
+          this.emitEvent({ type: "error", moduleUid, error: error.message });
+        }
+        if (!connected) {
+          resolve3({ success: false, error: error.message });
+        }
+      });
+      setTimeout(() => {
+        if (!connected) {
+          process2.kill();
+          if (stderrBuffer) {
+            console.error(`[Tunnel] EP948: Named tunnel ${moduleUid} stderr before timeout:`);
+            console.error(stderrBuffer.slice(-2e3));
+          }
+          const errorMsg = "Named tunnel connection timed out after 60 seconds. Check logs for cloudflared output.";
+          tunnelInfo.status = "error";
+          tunnelInfo.error = errorMsg;
+          updateTunnelStatus(moduleUid, "error", errorMsg).catch(() => {
+          });
+          const currentState = this.tunnelStates.get(moduleUid);
+          if (currentState && !currentState.intentionallyStopped) {
+            this.attemptReconnect(moduleUid);
+          } else {
+            this.tunnelStates.delete(moduleUid);
+            onStatusChange?.("error", errorMsg);
+            this.emitEvent({ type: "error", moduleUid, error: errorMsg });
+          }
+          resolve3({ success: false, error: errorMsg });
+        }
+      }, TUNNEL_TIMEOUTS.NAMED_TUNNEL_CONNECT);
+    });
+  }
+  /**
+   * EP948: Route to the appropriate tunnel process method based on mode
    */
   async startTunnelProcess(options, existingState) {
+    const mode = options.mode || "named";
+    if (mode === "named" && options.tunnelToken) {
+      return this.startNamedTunnelProcess(options, existingState);
+    }
+    console.log(`[Tunnel] EP948: Using Quick Tunnel mode for ${options.moduleUid}`);
+    return this.startQuickTunnelProcess(options, existingState);
+  }
+  /**
+   * EP672-9: Internal method to start the tunnel process (Quick Tunnel mode)
+   * Separated from startTunnel to support reconnection
+   */
+  async startQuickTunnelProcess(options, existingState) {
     const { moduleUid, port = 3e3, onUrl, onStatusChange } = options;
     if (!this.cloudflaredPath) {
       try {
@@ -4419,7 +4699,7 @@ var TunnelManager = class extends import_events.EventEmitter {
           }
           resolve3({ success: false, error: errorMsg });
         }
-      }, 3e4);
+      }, TUNNEL_TIMEOUTS.QUICK_TUNNEL_CONNECT);
     });
   }
   /**
@@ -4446,9 +4726,11 @@ var TunnelManager = class extends import_events.EventEmitter {
    * EP877: Internal start implementation with lock already held
    * EP901: Enhanced to clean up ALL orphaned cloudflared processes before starting
    * EP904: Added port-based deduplication to prevent multiple tunnels on same port
+   * EP948: Added Named Tunnel provisioning via platform API
    */
   async startTunnelWithLock(options) {
     const { moduleUid, port = 3e3 } = options;
+    let resolvedOptions = { ...options };
     const existingState = this.tunnelStates.get(moduleUid);
     if (existingState) {
       if (existingState.info.status === "connected") {
@@ -4475,7 +4757,23 @@ var TunnelManager = class extends import_events.EventEmitter {
     if (cleanup.cleaned > 0) {
       console.log(`[Tunnel] EP901: Pre-start cleanup removed ${cleanup.cleaned} orphaned processes`);
     }
-    return this.startTunnelProcess(options);
+    const mode = resolvedOptions.mode || "named";
+    if (mode === "named" && !resolvedOptions.tunnelToken && moduleUid !== "LOCAL") {
+      console.log(`[Tunnel] EP948: Provisioning Named Tunnel for ${moduleUid}...`);
+      const provisionResult = await provisionNamedTunnelByUid(moduleUid);
+      if (provisionResult.success && provisionResult.tunnel) {
+        console.log(`[Tunnel] EP948: Named Tunnel provisioned: ${provisionResult.tunnel.preview_url}`);
+        resolvedOptions = {
+          ...resolvedOptions,
+          tunnelToken: provisionResult.tunnel.token,
+          previewUrl: provisionResult.tunnel.preview_url
+        };
+      } else {
+        console.warn(`[Tunnel] EP948: Named Tunnel provisioning failed: ${provisionResult.error}. Falling back to Quick Tunnel.`);
+        resolvedOptions = { ...resolvedOptions, mode: "quick" };
+      }
+    }
+    return this.startTunnelProcess(resolvedOptions);
   }
   /**
    * Stop a tunnel for a module
@@ -4574,28 +4872,6 @@ function getTunnelManager() {
   return tunnelManagerInstance;
 }
 
-// src/tunnel/tunnel-api.ts
-var import_core6 = __toESM(require_dist());
-async function clearTunnelUrl(moduleUid) {
-  if (!moduleUid || moduleUid === "LOCAL") {
-    return;
-  }
-  const config = await (0, import_core6.loadConfig)();
-  if (!config?.access_token) {
-    return;
-  }
-  try {
-    const apiUrl = config.api_url || "https://episoda.dev";
-    await fetch(`${apiUrl}/api/modules/${moduleUid}/tunnel`, {
-      method: "DELETE",
-      headers: {
-        "Authorization": `Bearer ${config.access_token}`
-      }
-    });
-  } catch {
-  }
-}
-
 // src/agent/claude-binary.ts
 var import_child_process7 = require("child_process");
 var path8 = __toESM(require("path"));
@@ -5055,11 +5331,57 @@ var AgentManager = class {
   }
 };
 
-// src/utils/dev-server.ts
+// src/preview/types.ts
+var DEV_SERVER_CONSTANTS = {
+  /** Maximum restart attempts before giving up */
+  MAX_RESTART_ATTEMPTS: 5,
+  /** Initial delay before first restart (ms) */
+  INITIAL_RESTART_DELAY_MS: 2e3,
+  /** Maximum delay between restarts (ms) */
+  MAX_RESTART_DELAY_MS: 3e4,
+  /** Maximum log file size before rotation (bytes) */
+  MAX_LOG_SIZE_BYTES: 5 * 1024 * 1024,
+  // 5MB
+  /** Node.js memory limit (MB) */
+  NODE_MEMORY_LIMIT_MB: 2048,
+  /** Timeout waiting for server to start (ms) */
+  STARTUP_TIMEOUT_MS: 6e4,
+  /** Timeout for health check requests (ms) */
+  HEALTH_CHECK_TIMEOUT_MS: 5e3
+};
+
+// src/preview/preview-manager.ts
+var import_events3 = require("events");
+var import_fs = require("fs");
+
+// src/preview/dev-server-runner.ts
 var import_child_process9 = require("child_process");
-init_port_check();
+var http = __toESM(require("http"));
+var fs11 = __toESM(require("fs"));
+var path12 = __toESM(require("path"));
+var import_events2 = require("events");
 var import_core7 = __toESM(require_dist());
 
+// src/utils/port-check.ts
+var net2 = __toESM(require("net"));
+async function isPortInUse(port) {
+  return new Promise((resolve3) => {
+    const server = net2.createServer();
+    server.once("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        resolve3(true);
+      } else {
+        resolve3(false);
+      }
+    });
+    server.once("listening", () => {
+      server.close();
+      resolve3(false);
+    });
+    server.listen(port);
+  });
+}
+
 // src/utils/env-cache.ts
 var fs10 = __toESM(require("fs"));
 var path11 = __toESM(require("path"));
@@ -5211,10 +5533,809 @@ No cached values available as fallback.`
   }
 }
 
+// src/preview/dev-server-runner.ts
+var DevServerRunner = class extends import_events2.EventEmitter {
+  constructor() {
+    super();
+    this.servers = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Start a dev server for a module
+   */
+  async start(config) {
+    const {
+      projectPath,
+      port,
+      moduleUid,
+      customCommand,
+      autoRestart = true
+    } = config;
+    if (await isPortInUse(port)) {
+      console.log(`[DevServerRunner] Server already running on port ${port}`);
+      return { success: true, alreadyRunning: true };
+    }
+    const existing = this.servers.get(moduleUid);
+    if (existing && !existing.process.killed) {
+      console.log(`[DevServerRunner] Process already exists for ${moduleUid}`);
+      return { success: true, alreadyRunning: true };
+    }
+    console.log(`[DevServerRunner] Starting dev server for ${moduleUid} on port ${port}...`);
+    const injectedEnvVars = await this.fetchEnvVars(projectPath);
+    try {
+      const logPath = this.getLogFilePath(moduleUid);
+      const process2 = this.spawnProcess(projectPath, port, moduleUid, logPath, customCommand, injectedEnvVars);
+      const state = {
+        process: process2,
+        moduleUid,
+        projectPath,
+        port,
+        startedAt: /* @__PURE__ */ new Date(),
+        restartCount: 0,
+        lastRestartAt: null,
+        autoRestartEnabled: autoRestart,
+        logFile: logPath,
+        customCommand,
+        injectedEnvVars
+      };
+      this.servers.set(moduleUid, state);
+      this.writeToLog(logPath, `Starting dev server on port ${port}`);
+      this.setupProcessHandlers(moduleUid, process2, logPath);
+      console.log(`[DevServerRunner] Waiting for server on port ${port}...`);
+      const ready = await this.waitForPort(port, DEV_SERVER_CONSTANTS.STARTUP_TIMEOUT_MS);
+      if (!ready) {
+        process2.kill();
+        this.servers.delete(moduleUid);
+        this.writeToLog(logPath, "Failed to start within timeout", true);
+        return { success: false, error: "Dev server failed to start within timeout" };
+      }
+      console.log(`[DevServerRunner] Server started successfully on port ${port}`);
+      this.writeToLog(logPath, "Server started successfully");
+      this.emit("started", moduleUid, port);
+      return { success: true };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      console.error(`[DevServerRunner] Failed to start:`, error);
+      return { success: false, error: errorMsg };
+    }
+  }
+  /**
+   * Stop a dev server
+   */
+  async stop(moduleUid) {
+    const state = this.servers.get(moduleUid);
+    if (!state) {
+      return;
+    }
+    state.autoRestartEnabled = false;
+    if (!state.process.killed) {
+      console.log(`[DevServerRunner] Stopping server for ${moduleUid}`);
+      this.writeToLog(state.logFile, "Stopping server (manual stop)");
+      state.process.kill("SIGTERM");
+      await this.wait(2e3);
+      if (!state.process.killed) {
+        state.process.kill("SIGKILL");
+      }
+    }
+    this.servers.delete(moduleUid);
+    this.emit("stopped", moduleUid);
+  }
+  /**
+   * Restart a dev server
+   */
+  async restart(moduleUid) {
+    const state = this.servers.get(moduleUid);
+    if (!state) {
+      return { success: false, error: `No dev server found for ${moduleUid}` };
+    }
+    const { projectPath, port, autoRestartEnabled, customCommand, logFile } = state;
+    console.log(`[DevServerRunner] Restarting server for ${moduleUid}...`);
+    this.writeToLog(logFile, "Manual restart requested");
+    await this.stop(moduleUid);
+    await this.wait(1e3);
+    if (await isPortInUse(port)) {
+      await this.killProcessOnPort(port);
+    }
+    return this.start({
+      projectPath,
+      port,
+      moduleUid,
+      customCommand,
+      autoRestart: autoRestartEnabled
+    });
+  }
+  /**
+   * Check if a dev server is healthy (responding to HTTP requests)
+   */
+  async isHealthy(moduleUid) {
+    const state = this.servers.get(moduleUid);
+    if (!state) {
+      return false;
+    }
+    return this.checkHealth(state.port);
+  }
+  /**
+   * Check if a dev server is running
+   */
+  isRunning(moduleUid) {
+    const state = this.servers.get(moduleUid);
+    return !!state && !state.process.killed;
+  }
+  /**
+   * Get status of a specific dev server
+   */
+  getStatus(moduleUid) {
+    const state = this.servers.get(moduleUid);
+    if (!state) {
+      return void 0;
+    }
+    return this.stateToStatus(state);
+  }
+  /**
+   * Get status of all dev servers
+   */
+  getAllStatus() {
+    return Array.from(this.servers.values()).map((s) => this.stateToStatus(s));
+  }
+  /**
+   * Stop all dev servers
+   */
+  async stopAll() {
+    const uids = Array.from(this.servers.keys());
+    await Promise.all(uids.map((uid) => this.stop(uid)));
+  }
+  /**
+   * Ensure a dev server is running, starting if needed
+   *
+   * Note: start() already handles the case where the port is in use,
+   * returning { success: true, alreadyRunning: true }.
+   */
+  async ensure(config) {
+    return this.start({ ...config, autoRestart: true });
+  }
+  /**
+   * Kill any process on a specific port
+   */
+  async killProcessOnPort(port) {
+    try {
+      const result = (0, import_child_process9.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
+      if (!result) {
+        return true;
+      }
+      const pids = result.split("\n").filter(Boolean);
+      console.log(`[DevServerRunner] Found ${pids.length} process(es) on port ${port}`);
+      for (const pid of pids) {
+        try {
+          (0, import_child_process9.execSync)(`kill -15 ${pid} 2>/dev/null || true`);
+        } catch {
+        }
+      }
+      await this.wait(1e3);
+      for (const pid of pids) {
+        try {
+          (0, import_child_process9.execSync)(`kill -0 ${pid} 2>/dev/null`);
+          (0, import_child_process9.execSync)(`kill -9 ${pid} 2>/dev/null || true`);
+        } catch {
+        }
+      }
+      await this.wait(500);
+      return !await isPortInUse(port);
+    } catch (error) {
+      console.error(`[DevServerRunner] Error killing process on port ${port}:`, error);
+      return false;
+    }
+  }
+  // ============ Private Methods ============
+  async fetchEnvVars(projectPath) {
+    try {
+      const config = await (0, import_core7.loadConfig)();
+      if (!config?.access_token || !config?.project_id) {
+        return {};
+      }
+      const apiUrl = config.api_url || "https://episoda.dev";
+      const result = await fetchEnvVarsWithCache(apiUrl, config.access_token, {
+        projectId: config.project_id,
+        cacheTtl: 300
+      });
+      console.log(`[DevServerRunner] Loaded ${Object.keys(result.envVars).length} env vars`);
+      const envFilePath = path12.join(projectPath, ".env");
+      if (!fs11.existsSync(envFilePath) && Object.keys(result.envVars).length > 0) {
+        console.log(`[DevServerRunner] Writing .env file`);
+        writeEnvFile(projectPath, result.envVars);
+      }
+      return result.envVars;
+    } catch (error) {
+      console.warn(`[DevServerRunner] Failed to fetch env vars:`, error);
+      return {};
+    }
+  }
+  spawnProcess(projectPath, port, 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}`;
+    const enhancedNodeOptions = nodeOptions.includes("max-old-space-size") ? nodeOptions : `${nodeOptions} ${memoryFlag}`.trim();
+    const command = customCommand || "npm run dev";
+    const [cmd, ...args] = command.split(" ");
+    console.log(`[DevServerRunner] Running: ${command}`);
+    const mergedEnv = {
+      ...process.env,
+      ...envVars,
+      PORT: String(port),
+      NODE_OPTIONS: enhancedNodeOptions
+    };
+    const proc = (0, import_child_process9.spawn)(cmd, args, {
+      cwd: projectPath,
+      env: mergedEnv,
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: false,
+      shell: true
+    });
+    proc.stdout?.on("data", (data) => {
+      const line = data.toString().trim();
+      if (line) {
+        console.log(`[DevServer:${moduleUid}] ${line}`);
+        this.writeToLog(logPath, line);
+      }
+    });
+    proc.stderr?.on("data", (data) => {
+      const line = data.toString().trim();
+      if (line) {
+        console.error(`[DevServer:${moduleUid}] ${line}`);
+        this.writeToLog(logPath, line, true);
+      }
+    });
+    return proc;
+  }
+  setupProcessHandlers(moduleUid, proc, logPath) {
+    proc.on("exit", (code, signal) => {
+      this.handleProcessExit(moduleUid, code, signal);
+    });
+    proc.on("error", (error) => {
+      console.error(`[DevServerRunner] Process error for ${moduleUid}:`, error);
+      this.writeToLog(logPath, `Process error: ${error.message}`, true);
+      this.emit("error", moduleUid, error);
+    });
+  }
+  async handleProcessExit(moduleUid, code, signal) {
+    const state = this.servers.get(moduleUid);
+    if (!state) {
+      return;
+    }
+    const exitReason = signal ? `signal ${signal}` : `code ${code}`;
+    console.log(`[DevServerRunner] Process for ${moduleUid} exited with ${exitReason}`);
+    this.writeToLog(state.logFile, `Process exited with ${exitReason}`, true);
+    if (!state.autoRestartEnabled) {
+      this.servers.delete(moduleUid);
+      return;
+    }
+    if (state.restartCount >= DEV_SERVER_CONSTANTS.MAX_RESTART_ATTEMPTS) {
+      console.error(`[DevServerRunner] Max restart attempts reached for ${moduleUid}`);
+      this.writeToLog(state.logFile, "Max restart attempts reached", true);
+      this.servers.delete(moduleUid);
+      return;
+    }
+    const delay = this.calculateRestartDelay(state.restartCount);
+    console.log(`[DevServerRunner] Restarting ${moduleUid} in ${delay}ms (attempt ${state.restartCount + 1})`);
+    await this.wait(delay);
+    if (!this.servers.has(moduleUid)) {
+      return;
+    }
+    const logPath = state.logFile || this.getLogFilePath(moduleUid);
+    const newProcess = this.spawnProcess(
+      state.projectPath,
+      state.port,
+      moduleUid,
+      logPath,
+      state.customCommand,
+      state.injectedEnvVars
+    );
+    state.process = newProcess;
+    state.restartCount++;
+    state.lastRestartAt = /* @__PURE__ */ new Date();
+    this.setupProcessHandlers(moduleUid, newProcess, logPath);
+    const ready = await this.waitForPort(state.port, DEV_SERVER_CONSTANTS.STARTUP_TIMEOUT_MS);
+    if (ready) {
+      console.log(`[DevServerRunner] Server ${moduleUid} restarted successfully`);
+      state.restartCount = 0;
+      this.emit("restarted", moduleUid, state.restartCount);
+    } else {
+      console.error(`[DevServerRunner] Server ${moduleUid} failed to restart after attempt ${state.restartCount}`);
+      this.writeToLog(logPath, `Failed to restart (attempt ${state.restartCount})`, true);
+      if (state.restartCount >= DEV_SERVER_CONSTANTS.MAX_RESTART_ATTEMPTS) {
+        console.error(`[DevServerRunner] Max restart attempts reached for ${moduleUid}, cleaning up`);
+        this.writeToLog(logPath, "Max restart attempts reached, giving up", true);
+        this.servers.delete(moduleUid);
+        this.emit("permanent_failure", moduleUid, new Error("Max restart attempts reached"));
+      }
+    }
+  }
+  calculateRestartDelay(restartCount) {
+    const delay = DEV_SERVER_CONSTANTS.INITIAL_RESTART_DELAY_MS * Math.pow(2, restartCount);
+    return Math.min(delay, DEV_SERVER_CONSTANTS.MAX_RESTART_DELAY_MS);
+  }
+  async checkHealth(port) {
+    return new Promise((resolve3) => {
+      const req = http.request(
+        {
+          hostname: "localhost",
+          port,
+          path: "/",
+          method: "HEAD",
+          timeout: DEV_SERVER_CONSTANTS.HEALTH_CHECK_TIMEOUT_MS
+        },
+        () => resolve3(true)
+      );
+      req.on("error", () => resolve3(false));
+      req.on("timeout", () => {
+        req.destroy();
+        resolve3(false);
+      });
+      req.end();
+    });
+  }
+  async waitForPort(port, timeoutMs) {
+    const startTime = Date.now();
+    const checkInterval = 500;
+    while (Date.now() - startTime < timeoutMs) {
+      if (await isPortInUse(port)) {
+        return true;
+      }
+      await this.wait(checkInterval);
+    }
+    return false;
+  }
+  wait(ms) {
+    return new Promise((resolve3) => setTimeout(resolve3, ms));
+  }
+  getLogsDir() {
+    const logsDir = path12.join((0, import_core7.getConfigDir)(), "logs");
+    if (!fs11.existsSync(logsDir)) {
+      fs11.mkdirSync(logsDir, { recursive: true });
+    }
+    return logsDir;
+  }
+  getLogFilePath(moduleUid) {
+    return path12.join(this.getLogsDir(), `dev-${moduleUid}.log`);
+  }
+  rotateLogIfNeeded(logPath) {
+    try {
+      if (fs11.existsSync(logPath)) {
+        const stats = fs11.statSync(logPath);
+        if (stats.size > DEV_SERVER_CONSTANTS.MAX_LOG_SIZE_BYTES) {
+          const backupPath = `${logPath}.1`;
+          if (fs11.existsSync(backupPath)) {
+            fs11.unlinkSync(backupPath);
+          }
+          fs11.renameSync(logPath, backupPath);
+        }
+      }
+    } catch {
+    }
+  }
+  writeToLog(logPath, line, isError = false) {
+    if (!logPath) return;
+    try {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const prefix = isError ? "ERR" : "OUT";
+      fs11.appendFileSync(logPath, `[${timestamp}] [${prefix}] ${line}
+`);
+    } catch {
+    }
+  }
+  stateToStatus(state) {
+    return {
+      moduleUid: state.moduleUid,
+      port: state.port,
+      pid: state.process.pid,
+      startedAt: state.startedAt,
+      uptime: Math.floor((Date.now() - state.startedAt.getTime()) / 1e3),
+      restartCount: state.restartCount,
+      lastRestartAt: state.lastRestartAt,
+      autoRestartEnabled: state.autoRestartEnabled,
+      logFile: state.logFile
+    };
+  }
+};
+var instance2 = null;
+function getDevServerRunner() {
+  if (!instance2) {
+    instance2 = new DevServerRunner();
+  }
+  return instance2;
+}
+
+// src/preview/preview-manager.ts
+var DEFAULT_PORT = 3e3;
+var PreviewManager = class extends import_events3.EventEmitter {
+  constructor() {
+    super();
+    this.previews = /* @__PURE__ */ new Map();
+    this.startingModules = /* @__PURE__ */ new Set();
+    // Prevents concurrent startPreview() race conditions
+    this.initialized = false;
+    this.devServer = getDevServerRunner();
+    this.tunnel = getTunnelManager();
+    this.setupEventForwarding();
+  }
+  /**
+   * Initialize the preview manager
+   *
+   * Must be called before starting any previews.
+   * Initializes the tunnel manager (ensures cloudflared, cleans orphans).
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    console.log("[PreviewManager] Initializing...");
+    await this.tunnel.initialize();
+    this.initialized = true;
+    console.log("[PreviewManager] Initialized");
+  }
+  /**
+   * Start a preview for a module
+   *
+   * This will:
+   * 1. Start the dev server in the worktree
+   * 2. Provision a Named Tunnel via the platform API
+   * 3. Connect the tunnel to the dev server
+   * 4. Return the preview URL
+   *
+   * @param config - Preview configuration
+   * @returns Result with success status and preview URL
+   */
+  async startPreview(config) {
+    const { moduleUid, worktreePath, port = DEFAULT_PORT, customCommand } = config;
+    if (!worktreePath) {
+      return { success: false, error: "Worktree path is required" };
+    }
+    if (!(0, import_fs.existsSync)(worktreePath)) {
+      console.error(`[PreviewManager] Worktree path does not exist: ${worktreePath}`);
+      return { success: false, error: `Worktree path does not exist: ${worktreePath}` };
+    }
+    try {
+      const stats = (0, import_fs.statSync)(worktreePath);
+      if (!stats.isDirectory()) {
+        console.error(`[PreviewManager] Worktree path is not a directory: ${worktreePath}`);
+        return { success: false, error: `Worktree path is not a directory: ${worktreePath}` };
+      }
+    } catch (error) {
+      console.error(`[PreviewManager] Cannot access worktree path: ${worktreePath}`, error);
+      return { success: false, error: `Cannot access worktree path: ${worktreePath}` };
+    }
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    if (this.startingModules.has(moduleUid)) {
+      console.log(`[PreviewManager] Preview startup already in progress for ${moduleUid}`);
+      return { success: false, error: "Preview startup already in progress" };
+    }
+    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
+      };
+    }
+    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");
+    try {
+      console.log(`[PreviewManager] Starting dev server for ${moduleUid}...`);
+      const devResult = await this.devServer.start({
+        projectPath: worktreePath,
+        port,
+        moduleUid,
+        customCommand,
+        autoRestart: true
+      });
+      if (!devResult.success) {
+        state.state = "error";
+        state.error = devResult.error || "Failed to start dev server";
+        this.emitStateChange(moduleUid, "error");
+        this.emit("error", moduleUid, new Error(state.error));
+        return { success: false, error: state.error };
+      }
+      state.state = "running";
+      this.emitStateChange(moduleUid, "running");
+      console.log(`[PreviewManager] Dev server running on port ${port}`);
+      console.log(`[PreviewManager] Starting Named Tunnel for ${moduleUid}...`);
+      state.state = "tunneling";
+      this.emitStateChange(moduleUid, "tunneling");
+      const MAX_TUNNEL_RETRIES = 2;
+      let tunnelResult = { success: false };
+      let lastError = "";
+      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((resolve3) => setTimeout(resolve3, 2e3));
+        }
+        tunnelResult = await this.tunnel.startTunnel({
+          moduleUid,
+          port,
+          mode: "named",
+          // Named Tunnels only
+          onStatusChange: (status, error) => {
+            console.log(`[PreviewManager] Tunnel status for ${moduleUid}: ${status}${error ? ` - ${error}` : ""}`);
+            if (status === "error") {
+              state.state = "error";
+              state.error = error || "Tunnel error";
+              this.emitStateChange(moduleUid, "error");
+            } else if (status === "disconnected") {
+              state.state = "running";
+              state.tunnelUrl = void 0;
+              this.emitStateChange(moduleUid, "running");
+            } else if (status === "reconnecting") {
+              state.state = "tunneling";
+              this.emitStateChange(moduleUid, "tunneling");
+            }
+          },
+          onUrl: (url) => {
+            state.tunnelUrl = url;
+          }
+        });
+        if (tunnelResult.success) {
+          break;
+        }
+        lastError = tunnelResult.error || "Unknown tunnel error";
+        console.warn(`[PreviewManager] Tunnel attempt ${attempt} failed for ${moduleUid}: ${lastError}`);
+      }
+      if (!tunnelResult.success) {
+        console.error(`[PreviewManager] Tunnel failed after ${MAX_TUNNEL_RETRIES} attempts for ${moduleUid}, stopping dev server`);
+        try {
+          await this.devServer.stop(moduleUid);
+        } catch (cleanupError) {
+          console.warn(`[PreviewManager] Error cleaning up dev server after tunnel failure:`, cleanupError);
+        }
+        state.state = "error";
+        state.error = lastError;
+        this.previews.delete(moduleUid);
+        this.emitStateChange(moduleUid, "error");
+        return {
+          success: false,
+          error: `Tunnel failed after ${MAX_TUNNEL_RETRIES} attempts: ${lastError}`
+        };
+      }
+      state.state = "live";
+      state.tunnelUrl = tunnelResult.url;
+      state.error = void 0;
+      this.emitStateChange(moduleUid, "live");
+      this.emit("live", moduleUid, tunnelResult.url);
+      console.log(`[PreviewManager] Preview live for ${moduleUid}: ${tunnelResult.url}`);
+      return {
+        success: true,
+        previewUrl: tunnelResult.url
+      };
+    } 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");
+      this.emit("error", moduleUid, error instanceof Error ? error : new Error(errorMsg));
+      return { success: false, error: errorMsg };
+    } finally {
+      this.startingModules.delete(moduleUid);
+    }
+  }
+  /**
+   * Stop a preview for a module
+   *
+   * This will:
+   * 1. Stop the tunnel
+   * 2. Stop the dev server
+   * 3. Clear the tunnel URL from the platform API
+   *
+   * @param moduleUid - Module identifier
+   */
+  async stopPreview(moduleUid) {
+    console.log(`[PreviewManager] Stopping preview for ${moduleUid}`);
+    const state = this.previews.get(moduleUid);
+    try {
+      await this.tunnel.stopTunnel(moduleUid);
+    } catch (error) {
+      console.warn(`[PreviewManager] Error stopping tunnel for ${moduleUid}:`, error);
+    }
+    try {
+      await this.devServer.stop(moduleUid);
+    } catch (error) {
+      console.warn(`[PreviewManager] Error stopping dev server for ${moduleUid}:`, error);
+    }
+    try {
+      await clearTunnelUrl(moduleUid);
+    } catch (error) {
+      console.warn(`[PreviewManager] Error clearing tunnel URL for ${moduleUid}:`, error);
+    }
+    if (state) {
+      state.state = "stopped";
+      state.tunnelUrl = void 0;
+    }
+    this.previews.delete(moduleUid);
+    this.emitStateChange(moduleUid, "stopped");
+    this.emit("stopped", moduleUid);
+    console.log(`[PreviewManager] Preview stopped for ${moduleUid}`);
+  }
+  /**
+   * Restart a preview for a module
+   *
+   * @param moduleUid - Module identifier
+   * @returns Result with success status and new preview URL
+   */
+  async restartPreview(moduleUid) {
+    const state = this.previews.get(moduleUid);
+    if (!state) {
+      return { success: false, error: `No preview found for ${moduleUid}` };
+    }
+    console.log(`[PreviewManager] Restarting preview for ${moduleUid}`);
+    await this.stopPreview(moduleUid);
+    await new Promise((resolve3) => setTimeout(resolve3, 1e3));
+    return this.startPreview({
+      moduleUid,
+      worktreePath: state.worktreePath,
+      port: state.port
+    });
+  }
+  /**
+   * Get the status of a preview
+   *
+   * @param moduleUid - Module identifier
+   * @returns Preview status or undefined if not found
+   */
+  getStatus(moduleUid) {
+    const state = this.previews.get(moduleUid);
+    if (!state) {
+      return void 0;
+    }
+    const devServerStatus = this.devServer.getStatus(moduleUid);
+    const tunnelInfo = this.tunnel.getTunnel(moduleUid);
+    return {
+      moduleUid: state.moduleUid,
+      state: state.state,
+      devServer: devServerStatus,
+      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,
+      error: state.error,
+      startedAt: state.startedAt
+    };
+  }
+  /**
+   * Get the status of all previews
+   *
+   * @returns Array of preview statuses
+   */
+  getAllStatus() {
+    return Array.from(this.previews.keys()).map((uid) => this.getStatus(uid));
+  }
+  /**
+   * Check if a preview is running
+   *
+   * @param moduleUid - Module identifier
+   * @returns True if preview is running (dev server active)
+   */
+  isRunning(moduleUid) {
+    const state = this.previews.get(moduleUid);
+    return !!state && (state.state === "running" || state.state === "live" || state.state === "tunneling");
+  }
+  /**
+   * Check if a preview is fully live (dev server + tunnel)
+   *
+   * @param moduleUid - Module identifier
+   * @returns True if preview is fully live with tunnel connected
+   */
+  isLive(moduleUid) {
+    const state = this.previews.get(moduleUid);
+    return !!state && state.state === "live";
+  }
+  /**
+   * Get the preview URL for a module
+   *
+   * @param moduleUid - Module identifier
+   * @returns Preview URL or undefined if not available
+   */
+  getPreviewUrl(moduleUid) {
+    return this.previews.get(moduleUid)?.tunnelUrl;
+  }
+  /**
+   * Stop all previews
+   */
+  async stopAll() {
+    console.log("[PreviewManager] Stopping all previews...");
+    const moduleUids = Array.from(this.previews.keys());
+    await Promise.all(moduleUids.map((uid) => this.stopPreview(uid)));
+    console.log("[PreviewManager] All previews stopped");
+  }
+  /**
+   * Get all module UIDs with active previews
+   */
+  getActiveModuleUids() {
+    return Array.from(this.previews.keys()).filter((uid) => this.isRunning(uid));
+  }
+  // ============ Private Methods ============
+  setupEventForwarding() {
+    this.devServer.on("started", (moduleUid, port) => {
+      console.log(`[PreviewManager] Dev server started: ${moduleUid} on port ${port}`);
+    });
+    this.devServer.on("stopped", (moduleUid) => {
+      console.log(`[PreviewManager] Dev server stopped: ${moduleUid}`);
+      const state = this.previews.get(moduleUid);
+      if (state && state.state !== "stopped") {
+        state.state = "error";
+        state.error = "Dev server stopped unexpectedly";
+        this.emitStateChange(moduleUid, "error");
+      }
+    });
+    this.devServer.on("error", (moduleUid, error) => {
+      console.error(`[PreviewManager] Dev server error: ${moduleUid}`, error);
+      const state = this.previews.get(moduleUid);
+      if (state) {
+        state.state = "error";
+        state.error = error.message;
+        this.emitStateChange(moduleUid, "error");
+      }
+    });
+    this.devServer.on("permanent_failure", (moduleUid, error) => {
+      console.error(`[PreviewManager] Dev server permanent failure: ${moduleUid}`, error);
+      const state = this.previews.get(moduleUid);
+      if (state) {
+        state.state = "error";
+        state.error = `Dev server failed permanently: ${error.message}`;
+        this.emitStateChange(moduleUid, "error");
+        this.emit("error", moduleUid, error);
+        this.tunnel.stopTunnel(moduleUid).catch(() => {
+        });
+        this.previews.delete(moduleUid);
+      }
+    });
+    this.tunnel.on("tunnel", (event) => {
+      const moduleUid = event.moduleUid;
+      const state = this.previews.get(moduleUid);
+      if (!state) return;
+      if (event.type === "started") {
+        state.tunnelUrl = event.url;
+        state.state = "live";
+        this.emitStateChange(moduleUid, "live");
+        this.emit("live", moduleUid, event.url);
+      } else if (event.type === "stopped") {
+        state.tunnelUrl = void 0;
+        if (state.state === "live") {
+          state.state = "running";
+          this.emitStateChange(moduleUid, "running");
+        }
+      } else if (event.type === "error") {
+        console.error(`[PreviewManager] Tunnel error for ${moduleUid}:`, event.error);
+      } else if (event.type === "reconnecting") {
+        state.state = "tunneling";
+        this.emitStateChange(moduleUid, "tunneling");
+      }
+    });
+  }
+  emitStateChange(moduleUid, state) {
+    this.emit("stateChange", moduleUid, state);
+  }
+};
+var instance3 = null;
+function getPreviewManager() {
+  if (!instance3) {
+    instance3 = new PreviewManager();
+  }
+  return instance3;
+}
+
 // src/utils/dev-server.ts
-var import_http = __toESM(require("http"));
-var fs11 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var import_child_process10 = require("child_process");
+var import_core8 = __toESM(require_dist());
+var fs12 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
 var MAX_RESTART_ATTEMPTS = 5;
 var INITIAL_RESTART_DELAY_MS = 2e3;
 var MAX_RESTART_DELAY_MS = 3e4;
@@ -5222,26 +6343,26 @@ var MAX_LOG_SIZE_BYTES = 5 * 1024 * 1024;
 var NODE_MEMORY_LIMIT_MB = 2048;
 var activeServers = /* @__PURE__ */ new Map();
 function getLogsDir() {
-  const logsDir = path12.join((0, import_core7.getConfigDir)(), "logs");
-  if (!fs11.existsSync(logsDir)) {
-    fs11.mkdirSync(logsDir, { recursive: true });
+  const logsDir = path13.join((0, import_core8.getConfigDir)(), "logs");
+  if (!fs12.existsSync(logsDir)) {
+    fs12.mkdirSync(logsDir, { recursive: true });
   }
   return logsDir;
 }
 function getLogFilePath(moduleUid) {
-  return path12.join(getLogsDir(), `dev-${moduleUid}.log`);
+  return path13.join(getLogsDir(), `dev-${moduleUid}.log`);
 }
 function rotateLogIfNeeded(logPath) {
   try {
-    if (fs11.existsSync(logPath)) {
-      const stats = fs11.statSync(logPath);
+    if (fs12.existsSync(logPath)) {
+      const stats = fs12.statSync(logPath);
       if (stats.size > MAX_LOG_SIZE_BYTES) {
         const backupPath = `${logPath}.1`;
-        if (fs11.existsSync(backupPath)) {
-          fs11.unlinkSync(backupPath);
+        if (fs12.existsSync(backupPath)) {
+          fs12.unlinkSync(backupPath);
         }
-        fs11.renameSync(logPath, backupPath);
-        console.log(`[DevServer] EP932: Rotated log file for ${path12.basename(logPath)}`);
+        fs12.renameSync(logPath, backupPath);
+        console.log(`[DevServer] EP932: Rotated log file for ${path13.basename(logPath)}`);
       }
     }
   } catch (error) {
@@ -5254,37 +6375,13 @@ function writeToLog(logPath, line, isError = false) {
     const prefix = isError ? "ERR" : "OUT";
     const logLine = `[${timestamp}] [${prefix}] ${line}
 `;
-    fs11.appendFileSync(logPath, logLine);
+    fs12.appendFileSync(logPath, logLine);
   } catch {
   }
 }
-async function isDevServerHealthy(port, timeoutMs = 5e3) {
-  return new Promise((resolve3) => {
-    const req = import_http.default.request(
-      {
-        hostname: "localhost",
-        port,
-        path: "/",
-        method: "HEAD",
-        timeout: timeoutMs
-      },
-      (res) => {
-        resolve3(true);
-      }
-    );
-    req.on("error", () => {
-      resolve3(false);
-    });
-    req.on("timeout", () => {
-      req.destroy();
-      resolve3(false);
-    });
-    req.end();
-  });
-}
 async function killProcessOnPort(port) {
   try {
-    const result = (0, import_child_process9.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
+    const result = (0, import_child_process10.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
     if (!result) {
       console.log(`[DevServer] EP929: No process found on port ${port}`);
       return true;
@@ -5293,7 +6390,7 @@ async function killProcessOnPort(port) {
     console.log(`[DevServer] EP929: Found ${pids.length} process(es) on port ${port}: ${pids.join(", ")}`);
     for (const pid of pids) {
       try {
-        (0, import_child_process9.execSync)(`kill -15 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
+        (0, import_child_process10.execSync)(`kill -15 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
         console.log(`[DevServer] EP929: Sent SIGTERM to PID ${pid}`);
       } catch {
       }
@@ -5301,8 +6398,8 @@ async function killProcessOnPort(port) {
     await new Promise((resolve3) => setTimeout(resolve3, 1e3));
     for (const pid of pids) {
       try {
-        (0, import_child_process9.execSync)(`kill -0 ${pid} 2>/dev/null`, { encoding: "utf8" });
-        (0, import_child_process9.execSync)(`kill -9 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
+        (0, import_child_process10.execSync)(`kill -0 ${pid} 2>/dev/null`, { encoding: "utf8" });
+        (0, import_child_process10.execSync)(`kill -9 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
         console.log(`[DevServer] EP929: Force killed PID ${pid}`);
       } catch {
       }
@@ -5353,7 +6450,7 @@ function spawnDevServerProcess(projectPath, port, moduleUid, logPath, customComm
   if (injectedCount > 0) {
     console.log(`[DevServer] EP998: Injecting ${injectedCount} env vars from database`);
   }
-  const devProcess = (0, import_child_process9.spawn)(cmd, args, {
+  const devProcess = (0, import_child_process10.spawn)(cmd, args, {
     cwd: projectPath,
     env: mergedEnv,
     stdio: ["ignore", "pipe", "pipe"],
@@ -5447,7 +6544,7 @@ async function startDevServer(projectPath, port = 3e3, moduleUid = "default", op
   console.log(`[DevServer] EP932: Starting dev server for ${moduleUid} on port ${port} (auto-restart: ${autoRestart})...`);
   let injectedEnvVars = {};
   try {
-    const config = await (0, import_core7.loadConfig)();
+    const config = await (0, import_core8.loadConfig)();
     if (config?.access_token && config?.project_id) {
       const apiUrl = config.api_url || "https://episoda.dev";
       const result = await fetchEnvVarsWithCache(apiUrl, config.access_token, {
@@ -5457,8 +6554,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 = path12.join(projectPath, ".env");
-      if (!fs11.existsSync(envFilePath) && Object.keys(injectedEnvVars).length > 0) {
+      const envFilePath = path13.join(projectPath, ".env");
+      if (!fs12.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);
       }
@@ -5562,17 +6659,11 @@ function getDevServerStatus() {
     logFile: info.logFile
   }));
 }
-async function ensureDevServer(projectPath, port = 3e3, moduleUid = "default", customCommand) {
-  if (await isPortInUse(port)) {
-    return { success: true };
-  }
-  return startDevServer(projectPath, port, moduleUid, { autoRestart: true, customCommand });
-}
 
 // src/utils/port-detect.ts
-var fs12 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
-var DEFAULT_PORT = 3e3;
+var fs13 = __toESM(require("fs"));
+var path14 = __toESM(require("path"));
+var DEFAULT_PORT2 = 3e3;
 function detectDevPort(projectPath) {
   const envPort = getPortFromEnv(projectPath);
   if (envPort) {
@@ -5584,20 +6675,20 @@ function detectDevPort(projectPath) {
     console.log(`[PortDetect] Found port ${scriptPort} in package.json dev script`);
     return scriptPort;
   }
-  console.log(`[PortDetect] Using default port ${DEFAULT_PORT}`);
-  return DEFAULT_PORT;
+  console.log(`[PortDetect] Using default port ${DEFAULT_PORT2}`);
+  return DEFAULT_PORT2;
 }
 function getPortFromEnv(projectPath) {
   const envPaths = [
-    path13.join(projectPath, ".env"),
-    path13.join(projectPath, ".env.local"),
-    path13.join(projectPath, ".env.development"),
-    path13.join(projectPath, ".env.development.local")
+    path14.join(projectPath, ".env"),
+    path14.join(projectPath, ".env.local"),
+    path14.join(projectPath, ".env.development"),
+    path14.join(projectPath, ".env.development.local")
   ];
   for (const envPath of envPaths) {
     try {
-      if (!fs12.existsSync(envPath)) continue;
-      const content = fs12.readFileSync(envPath, "utf-8");
+      if (!fs13.existsSync(envPath)) continue;
+      const content = fs13.readFileSync(envPath, "utf-8");
       const lines = content.split("\n");
       for (const line of lines) {
         const match = line.match(/^\s*PORT\s*=\s*["']?(\d+)["']?\s*(?:#.*)?$/);
@@ -5614,10 +6705,10 @@ function getPortFromEnv(projectPath) {
   return null;
 }
 function getPortFromPackageJson(projectPath) {
-  const packageJsonPath = path13.join(projectPath, "package.json");
+  const packageJsonPath = path14.join(projectPath, "package.json");
   try {
-    if (!fs12.existsSync(packageJsonPath)) return null;
-    const content = fs12.readFileSync(packageJsonPath, "utf-8");
+    if (!fs13.existsSync(packageJsonPath)) return null;
+    const content = fs13.readFileSync(packageJsonPath, "utf-8");
     const pkg = JSON.parse(content);
     const devScript = pkg.scripts?.dev;
     if (!devScript) return null;
@@ -5641,9 +6732,9 @@ function getPortFromPackageJson(projectPath) {
 }
 
 // src/daemon/worktree-manager.ts
-var fs13 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
-var import_core8 = __toESM(require_dist());
+var fs14 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
+var import_core9 = __toESM(require_dist());
 function validateModuleUid(moduleUid) {
   if (!moduleUid || typeof moduleUid !== "string" || !moduleUid.trim()) {
     return false;
@@ -5666,9 +6757,9 @@ var WorktreeManager = class _WorktreeManager {
     // ============================================================
     this.lockPath = "";
     this.projectRoot = projectRoot;
-    this.bareRepoPath = path14.join(projectRoot, ".bare");
-    this.configPath = path14.join(projectRoot, ".episoda", "config.json");
-    this.gitExecutor = new import_core8.GitExecutor();
+    this.bareRepoPath = path15.join(projectRoot, ".bare");
+    this.configPath = path15.join(projectRoot, ".episoda", "config.json");
+    this.gitExecutor = new import_core9.GitExecutor();
   }
   /**
    * Initialize worktree manager from existing project root
@@ -5676,10 +6767,10 @@ var WorktreeManager = class _WorktreeManager {
    * @returns true if valid project, false otherwise
    */
   async initialize() {
-    if (!fs13.existsSync(this.bareRepoPath)) {
+    if (!fs14.existsSync(this.bareRepoPath)) {
       return false;
     }
-    if (!fs13.existsSync(this.configPath)) {
+    if (!fs14.existsSync(this.configPath)) {
       return false;
     }
     try {
@@ -5699,10 +6790,10 @@ var WorktreeManager = class _WorktreeManager {
    */
   async ensureFetchRefspecConfigured() {
     try {
-      const { execSync: execSync7 } = require("child_process");
+      const { execSync: execSync8 } = require("child_process");
       let fetchRefspec = null;
       try {
-        fetchRefspec = execSync7("git config --get remote.origin.fetch", {
+        fetchRefspec = execSync8("git config --get remote.origin.fetch", {
           cwd: this.bareRepoPath,
           encoding: "utf-8",
           timeout: 5e3
@@ -5711,7 +6802,7 @@ var WorktreeManager = class _WorktreeManager {
       }
       if (!fetchRefspec) {
         console.log("[WorktreeManager] EP1014: Configuring missing fetch refspec for bare repo");
-        execSync7('git config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"', {
+        execSync8('git config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"', {
           cwd: this.bareRepoPath,
           timeout: 5e3
         });
@@ -5726,8 +6817,8 @@ var WorktreeManager = class _WorktreeManager {
    */
   static async createProject(projectRoot, repoUrl, projectId, workspaceSlug, projectSlug) {
     const manager = new _WorktreeManager(projectRoot);
-    const episodaDir = path14.join(projectRoot, ".episoda");
-    fs13.mkdirSync(episodaDir, { recursive: true });
+    const episodaDir = path15.join(projectRoot, ".episoda");
+    fs14.mkdirSync(episodaDir, { recursive: true });
     const cloneResult = await manager.gitExecutor.execute({
       action: "clone_bare",
       url: repoUrl,
@@ -5758,7 +6849,7 @@ var WorktreeManager = class _WorktreeManager {
         error: `Invalid module UID: "${moduleUid}" - contains disallowed characters`
       };
     }
-    const worktreePath = path14.join(this.projectRoot, moduleUid);
+    const worktreePath = path15.join(this.projectRoot, moduleUid);
     const lockAcquired = await this.acquireLock();
     if (!lockAcquired) {
       return {
@@ -5940,7 +7031,7 @@ var WorktreeManager = class _WorktreeManager {
     let prunedCount = 0;
     await this.updateConfigSafe((config) => {
       const initialCount = config.worktrees.length;
-      config.worktrees = config.worktrees.filter((w) => fs13.existsSync(w.worktreePath));
+      config.worktrees = config.worktrees.filter((w) => fs14.existsSync(w.worktreePath));
       prunedCount = initialCount - config.worktrees.length;
       return config;
     });
@@ -6021,16 +7112,16 @@ var WorktreeManager = class _WorktreeManager {
     const retryInterval = 50;
     while (Date.now() - startTime < timeoutMs) {
       try {
-        fs13.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+        fs14.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
         return true;
       } catch (err) {
         if (err.code === "EEXIST") {
           try {
-            const stats = fs13.statSync(lockPath);
+            const stats = fs14.statSync(lockPath);
             const lockAge = Date.now() - stats.mtimeMs;
             if (lockAge > 3e4) {
               try {
-                const lockContent = fs13.readFileSync(lockPath, "utf-8").trim();
+                const lockContent = fs14.readFileSync(lockPath, "utf-8").trim();
                 const lockPid = parseInt(lockContent, 10);
                 if (!isNaN(lockPid) && this.isProcessRunning(lockPid)) {
                   await new Promise((resolve3) => setTimeout(resolve3, retryInterval));
@@ -6039,7 +7130,7 @@ var WorktreeManager = class _WorktreeManager {
               } catch {
               }
               try {
-                fs13.unlinkSync(lockPath);
+                fs14.unlinkSync(lockPath);
               } catch {
               }
               continue;
@@ -6060,16 +7151,16 @@ var WorktreeManager = class _WorktreeManager {
    */
   releaseLock() {
     try {
-      fs13.unlinkSync(this.getLockPath());
+      fs14.unlinkSync(this.getLockPath());
     } catch {
     }
   }
   readConfig() {
     try {
-      if (!fs13.existsSync(this.configPath)) {
+      if (!fs14.existsSync(this.configPath)) {
         return null;
       }
-      const content = fs13.readFileSync(this.configPath, "utf-8");
+      const content = fs14.readFileSync(this.configPath, "utf-8");
       return JSON.parse(content);
     } catch (error) {
       console.error("[WorktreeManager] Failed to read config:", error);
@@ -6078,11 +7169,11 @@ var WorktreeManager = class _WorktreeManager {
   }
   writeConfig(config) {
     try {
-      const dir = path14.dirname(this.configPath);
-      if (!fs13.existsSync(dir)) {
-        fs13.mkdirSync(dir, { recursive: true });
+      const dir = path15.dirname(this.configPath);
+      if (!fs14.existsSync(dir)) {
+        fs14.mkdirSync(dir, { recursive: true });
       }
-      fs13.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf-8");
+      fs14.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf-8");
     } catch (error) {
       console.error("[WorktreeManager] Failed to write config:", error);
       throw error;
@@ -6163,14 +7254,14 @@ var WorktreeManager = class _WorktreeManager {
     }
     try {
       for (const file of files) {
-        const srcPath = path14.join(mainWorktree.worktreePath, file);
-        const destPath = path14.join(worktree.worktreePath, file);
-        if (fs13.existsSync(srcPath)) {
-          const destDir = path14.dirname(destPath);
-          if (!fs13.existsSync(destDir)) {
-            fs13.mkdirSync(destDir, { recursive: true });
-          }
-          fs13.copyFileSync(srcPath, destPath);
+        const srcPath = path15.join(mainWorktree.worktreePath, file);
+        const destPath = path15.join(worktree.worktreePath, file);
+        if (fs14.existsSync(srcPath)) {
+          const destDir = path15.dirname(destPath);
+          if (!fs14.existsSync(destDir)) {
+            fs14.mkdirSync(destDir, { recursive: true });
+          }
+          fs14.copyFileSync(srcPath, destPath);
           console.log(`[WorktreeManager] EP964: Copied ${file} to ${moduleUid} (deprecated)`);
         } else {
           console.log(`[WorktreeManager] EP964: Skipped ${file} (not found in main)`);
@@ -6201,8 +7292,8 @@ var WorktreeManager = class _WorktreeManager {
     console.log(`[WorktreeManager] EP959:   Timeout: ${TIMEOUT_MINUTES} minutes`);
     console.log(`[WorktreeManager] EP959:   Script: ${scriptPreview}`);
     try {
-      const { execSync: execSync7 } = require("child_process");
-      execSync7(script, {
+      const { execSync: execSync8 } = require("child_process");
+      execSync8(script, {
         cwd: worktree.worktreePath,
         stdio: "inherit",
         timeout: TIMEOUT_MINUTES * 60 * 1e3,
@@ -6236,8 +7327,8 @@ var WorktreeManager = class _WorktreeManager {
     console.log(`[WorktreeManager] EP959:   Timeout: ${TIMEOUT_MINUTES} minutes`);
     console.log(`[WorktreeManager] EP959:   Script: ${scriptPreview}`);
     try {
-      const { execSync: execSync7 } = require("child_process");
-      execSync7(script, {
+      const { execSync: execSync8 } = require("child_process");
+      execSync8(script, {
         cwd: worktree.worktreePath,
         stdio: "inherit",
         timeout: TIMEOUT_MINUTES * 60 * 1e3,
@@ -6253,27 +7344,27 @@ var WorktreeManager = class _WorktreeManager {
   }
 };
 function getEpisodaRoot() {
-  return process.env.EPISODA_ROOT || path14.join(require("os").homedir(), "episoda");
+  return process.env.EPISODA_ROOT || path15.join(require("os").homedir(), "episoda");
 }
 async function isWorktreeProject(projectRoot) {
   const manager = new WorktreeManager(projectRoot);
   return manager.initialize();
 }
 async function findProjectRoot(startPath) {
-  let current = path14.resolve(startPath);
+  let current = path15.resolve(startPath);
   const episodaRoot = getEpisodaRoot();
   if (!current.startsWith(episodaRoot)) {
     return null;
   }
   for (let i = 0; i < 10; i++) {
-    const bareDir = path14.join(current, ".bare");
-    const episodaDir = path14.join(current, ".episoda");
-    if (fs13.existsSync(bareDir) && fs13.existsSync(episodaDir)) {
+    const bareDir = path15.join(current, ".bare");
+    const episodaDir = path15.join(current, ".episoda");
+    if (fs14.existsSync(bareDir) && fs14.existsSync(episodaDir)) {
       if (await isWorktreeProject(current)) {
         return current;
       }
     }
-    const parent = path14.dirname(current);
+    const parent = path15.dirname(current);
     if (parent === current) {
       break;
     }
@@ -6283,24 +7374,24 @@ async function findProjectRoot(startPath) {
 }
 
 // src/utils/worktree.ts
-var path15 = __toESM(require("path"));
-var fs14 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
+var fs15 = __toESM(require("fs"));
 var os5 = __toESM(require("os"));
-var import_core9 = __toESM(require_dist());
+var import_core10 = __toESM(require_dist());
 function getEpisodaRoot2() {
-  return process.env.EPISODA_ROOT || path15.join(os5.homedir(), "episoda");
+  return process.env.EPISODA_ROOT || path16.join(os5.homedir(), "episoda");
 }
 function getWorktreeInfo(moduleUid, workspaceSlug, projectSlug) {
   const root = getEpisodaRoot2();
-  const worktreePath = path15.join(root, workspaceSlug, projectSlug, moduleUid);
+  const worktreePath = path16.join(root, workspaceSlug, projectSlug, moduleUid);
   return {
     path: worktreePath,
-    exists: fs14.existsSync(worktreePath),
+    exists: fs15.existsSync(worktreePath),
     moduleUid
   };
 }
 async function getWorktreeInfoForModule(moduleUid) {
-  const config = await (0, import_core9.loadConfig)();
+  const config = await (0, import_core10.loadConfig)();
   if (!config?.workspace_slug || !config?.project_slug) {
     console.warn("[Worktree] Missing workspace_slug or project_slug in config");
     return null;
@@ -6319,61 +7410,61 @@ function clearAllPorts() {
 }
 
 // src/framework-detector.ts
-var fs15 = __toESM(require("fs"));
-var path16 = __toESM(require("path"));
+var fs16 = __toESM(require("fs"));
+var path17 = __toESM(require("path"));
 function getInstallCommand(cwd) {
-  if (fs15.existsSync(path16.join(cwd, "bun.lockb"))) {
+  if (fs16.existsSync(path17.join(cwd, "bun.lockb"))) {
     return {
       command: ["bun", "install"],
       description: "Installing dependencies with bun",
       detectedFrom: "bun.lockb"
     };
   }
-  if (fs15.existsSync(path16.join(cwd, "pnpm-lock.yaml"))) {
+  if (fs16.existsSync(path17.join(cwd, "pnpm-lock.yaml"))) {
     return {
       command: ["pnpm", "install"],
       description: "Installing dependencies with pnpm",
       detectedFrom: "pnpm-lock.yaml"
     };
   }
-  if (fs15.existsSync(path16.join(cwd, "yarn.lock"))) {
+  if (fs16.existsSync(path17.join(cwd, "yarn.lock"))) {
     return {
       command: ["yarn", "install"],
       description: "Installing dependencies with yarn",
       detectedFrom: "yarn.lock"
     };
   }
-  if (fs15.existsSync(path16.join(cwd, "package-lock.json"))) {
+  if (fs16.existsSync(path17.join(cwd, "package-lock.json"))) {
     return {
       command: ["npm", "ci"],
       description: "Installing dependencies with npm ci",
       detectedFrom: "package-lock.json"
     };
   }
-  if (fs15.existsSync(path16.join(cwd, "package.json"))) {
+  if (fs16.existsSync(path17.join(cwd, "package.json"))) {
     return {
       command: ["npm", "install"],
       description: "Installing dependencies with npm",
       detectedFrom: "package.json"
     };
   }
-  if (fs15.existsSync(path16.join(cwd, "Pipfile.lock")) || fs15.existsSync(path16.join(cwd, "Pipfile"))) {
+  if (fs16.existsSync(path17.join(cwd, "Pipfile.lock")) || fs16.existsSync(path17.join(cwd, "Pipfile"))) {
     return {
       command: ["pipenv", "install"],
       description: "Installing dependencies with pipenv",
-      detectedFrom: fs15.existsSync(path16.join(cwd, "Pipfile.lock")) ? "Pipfile.lock" : "Pipfile"
+      detectedFrom: fs16.existsSync(path17.join(cwd, "Pipfile.lock")) ? "Pipfile.lock" : "Pipfile"
     };
   }
-  if (fs15.existsSync(path16.join(cwd, "poetry.lock"))) {
+  if (fs16.existsSync(path17.join(cwd, "poetry.lock"))) {
     return {
       command: ["poetry", "install"],
       description: "Installing dependencies with poetry",
       detectedFrom: "poetry.lock"
     };
   }
-  if (fs15.existsSync(path16.join(cwd, "pyproject.toml"))) {
-    const pyprojectPath = path16.join(cwd, "pyproject.toml");
-    const content = fs15.readFileSync(pyprojectPath, "utf-8");
+  if (fs16.existsSync(path17.join(cwd, "pyproject.toml"))) {
+    const pyprojectPath = path17.join(cwd, "pyproject.toml");
+    const content = fs16.readFileSync(pyprojectPath, "utf-8");
     if (content.includes("[tool.poetry]")) {
       return {
         command: ["poetry", "install"],
@@ -6382,41 +7473,41 @@ function getInstallCommand(cwd) {
       };
     }
   }
-  if (fs15.existsSync(path16.join(cwd, "requirements.txt"))) {
+  if (fs16.existsSync(path17.join(cwd, "requirements.txt"))) {
     return {
       command: ["pip", "install", "-r", "requirements.txt"],
       description: "Installing dependencies with pip",
       detectedFrom: "requirements.txt"
     };
   }
-  if (fs15.existsSync(path16.join(cwd, "Gemfile.lock")) || fs15.existsSync(path16.join(cwd, "Gemfile"))) {
+  if (fs16.existsSync(path17.join(cwd, "Gemfile.lock")) || fs16.existsSync(path17.join(cwd, "Gemfile"))) {
     return {
       command: ["bundle", "install"],
       description: "Installing dependencies with bundler",
-      detectedFrom: fs15.existsSync(path16.join(cwd, "Gemfile.lock")) ? "Gemfile.lock" : "Gemfile"
+      detectedFrom: fs16.existsSync(path17.join(cwd, "Gemfile.lock")) ? "Gemfile.lock" : "Gemfile"
     };
   }
-  if (fs15.existsSync(path16.join(cwd, "go.sum")) || fs15.existsSync(path16.join(cwd, "go.mod"))) {
+  if (fs16.existsSync(path17.join(cwd, "go.sum")) || fs16.existsSync(path17.join(cwd, "go.mod"))) {
     return {
       command: ["go", "mod", "download"],
       description: "Downloading Go modules",
-      detectedFrom: fs15.existsSync(path16.join(cwd, "go.sum")) ? "go.sum" : "go.mod"
+      detectedFrom: fs16.existsSync(path17.join(cwd, "go.sum")) ? "go.sum" : "go.mod"
     };
   }
-  if (fs15.existsSync(path16.join(cwd, "Cargo.lock")) || fs15.existsSync(path16.join(cwd, "Cargo.toml"))) {
+  if (fs16.existsSync(path17.join(cwd, "Cargo.lock")) || fs16.existsSync(path17.join(cwd, "Cargo.toml"))) {
     return {
       command: ["cargo", "build"],
       description: "Building Rust project (downloads dependencies)",
-      detectedFrom: fs15.existsSync(path16.join(cwd, "Cargo.lock")) ? "Cargo.lock" : "Cargo.toml"
+      detectedFrom: fs16.existsSync(path17.join(cwd, "Cargo.lock")) ? "Cargo.lock" : "Cargo.toml"
     };
   }
   return null;
 }
 
 // src/daemon/daemon-process.ts
-var fs16 = __toESM(require("fs"));
+var fs17 = __toESM(require("fs"));
 var os6 = __toESM(require("os"));
-var path17 = __toESM(require("path"));
+var path18 = __toESM(require("path"));
 var packageJson = require_package();
 async function ensureValidToken(config, bufferMs = 5 * 60 * 1e3) {
   const now = Date.now();
@@ -6451,7 +7542,7 @@ async function ensureValidToken(config, bufferMs = 5 * 60 * 1e3) {
       refresh_token: tokenResponse.refresh_token || config.refresh_token,
       expires_at: now + tokenResponse.expires_in * 1e3
     };
-    await (0, import_core10.saveConfig)(updatedConfig);
+    await (0, import_core11.saveConfig)(updatedConfig);
     console.log("[Daemon] EP904: Access token refreshed successfully");
     return updatedConfig;
   } catch (error) {
@@ -6460,7 +7551,7 @@ async function ensureValidToken(config, bufferMs = 5 * 60 * 1e3) {
   }
 }
 async function fetchWithAuth(url, options = {}, retryOnUnauthorized = true) {
-  let config = await (0, import_core10.loadConfig)();
+  let config = await (0, import_core11.loadConfig)();
   if (!config?.access_token) {
     throw new Error("No access token configured");
   }
@@ -6487,7 +7578,7 @@ async function fetchWithAuth(url, options = {}, retryOnUnauthorized = true) {
 }
 async function fetchEnvVars2() {
   try {
-    const config = await (0, import_core10.loadConfig)();
+    const config = await (0, import_core11.loadConfig)();
     if (!config?.project_id) {
       console.warn("[Daemon] EP973: No project_id in config, cannot fetch env vars");
       return {};
@@ -6572,7 +7663,7 @@ var Daemon = class _Daemon {
     console.log("[Daemon] Starting Episoda daemon...");
     this.machineId = await getMachineId();
     console.log(`[Daemon] Machine ID: ${this.machineId}`);
-    const config = await (0, import_core10.loadConfig)();
+    const config = await (0, import_core11.loadConfig)();
     if (config?.device_id) {
       this.deviceId = config.device_id;
       console.log(`[Daemon] Loaded cached Device ID (UUID): ${this.deviceId}`);
@@ -6709,7 +7800,7 @@ var Daemon = class _Daemon {
       };
     });
     this.ipcServer.on("verify-server-connection", async () => {
-      const config = await (0, import_core10.loadConfig)();
+      const config = await (0, import_core11.loadConfig)();
       if (!config?.access_token || !config?.api_url) {
         return {
           verified: false,
@@ -6883,7 +7974,7 @@ var Daemon = class _Daemon {
       console.warn(`[Daemon] Stale connection detected for ${projectPath}, forcing reconnection`);
       await this.disconnectProject(projectPath);
     }
-    const config = await (0, import_core10.loadConfig)();
+    const config = await (0, import_core11.loadConfig)();
     if (!config || !config.access_token) {
       throw new Error("No access token found. Please run: episoda auth");
     }
@@ -6904,8 +7995,8 @@ var Daemon = class _Daemon {
       wsUrl = `${wsProtocol}//${wsHostname}:${wsPort}`;
     }
     console.log(`[Daemon] Connecting to ${wsUrl} for project ${projectId}...`);
-    const client = new import_core10.EpisodaClient();
-    const gitExecutor = new import_core10.GitExecutor();
+    const client = new import_core11.EpisodaClient();
+    const gitExecutor = new import_core11.GitExecutor();
     const connection = {
       projectId,
       projectPath,
@@ -6920,7 +8011,7 @@ var Daemon = class _Daemon {
         client.updateActivity();
         try {
           const gitCmd = message.command;
-          const bareRepoPath = path17.join(projectPath, ".bare");
+          const bareRepoPath = path18.join(projectPath, ".bare");
           const cwd = gitCmd.worktreePath || bareRepoPath;
           if (gitCmd.worktreePath) {
             console.log(`[Daemon] Routing command to worktree: ${gitCmd.worktreePath}`);
@@ -7048,15 +8139,15 @@ var Daemon = class _Daemon {
     client.on("tunnel_command", async (message) => {
       if (message.type === "tunnel_command" && message.command) {
         const cmd = message.command;
-        console.log(`[Daemon] Received tunnel command for ${projectId}:`, cmd.action);
+        console.log(`[Daemon] EP1024: Received tunnel command for ${projectId}:`, cmd.action);
         client.updateActivity();
         try {
-          const tunnelManager = getTunnelManager();
+          const previewManager = getPreviewManager();
           let result;
           if (cmd.action === "start") {
             const worktree = await getWorktreeInfoForModule(cmd.moduleUid);
             if (!worktree) {
-              console.error(`[Daemon] EP973: Cannot resolve worktree path for ${cmd.moduleUid}`);
+              console.error(`[Daemon] EP1024: Cannot resolve worktree path for ${cmd.moduleUid}`);
               await client.send({
                 type: "tunnel_result",
                 commandId: message.id,
@@ -7065,7 +8156,7 @@ var Daemon = class _Daemon {
               return;
             }
             if (!worktree.exists) {
-              console.error(`[Daemon] EP973: Worktree not found at ${worktree.path}`);
+              console.error(`[Daemon] EP1024: Worktree not found at ${worktree.path}`);
               await client.send({
                 type: "tunnel_result",
                 commandId: message.id,
@@ -7073,118 +8164,31 @@ var Daemon = class _Daemon {
               });
               return;
             }
-            console.log(`[Daemon] EP973: Using worktree path ${worktree.path} for ${cmd.moduleUid}`);
+            console.log(`[Daemon] EP1024: Using worktree path ${worktree.path} for ${cmd.moduleUid}`);
             const port = cmd.port || detectDevPort(worktree.path);
-            const previewUrl = `https://${cmd.moduleUid.toLowerCase()}-${cmd.projectUid.toLowerCase()}.episoda.site`;
-            const reportTunnelStatus = async (data) => {
-              const config2 = await (0, import_core10.loadConfig)();
-              if (config2?.access_token) {
-                try {
-                  const apiUrl = config2.api_url || "https://episoda.dev";
-                  const response = await fetch(`${apiUrl}/api/modules/${cmd.moduleUid}/tunnel`, {
-                    method: "POST",
-                    headers: {
-                      "Authorization": `Bearer ${config2.access_token}`,
-                      "Content-Type": "application/json"
-                    },
-                    body: JSON.stringify(data)
-                  });
-                  if (response.ok) {
-                    console.log(`[Daemon] Tunnel status reported for ${cmd.moduleUid}`);
-                  } else {
-                    console.warn(`[Daemon] Failed to report tunnel status: ${response.statusText}`);
-                  }
-                } catch (reportError) {
-                  console.warn(`[Daemon] Error reporting tunnel status:`, reportError);
-                }
-              }
-            };
-            (async () => {
-              const MAX_RETRIES = 3;
-              const RETRY_DELAY_MS = 3e3;
-              await reportTunnelStatus({
-                tunnel_started_at: (/* @__PURE__ */ new Date()).toISOString(),
-                tunnel_error: null
-                // Clear any previous error
-              });
-              try {
-                await tunnelManager.initialize();
-                const devConfig = await (0, import_core10.loadConfig)();
-                const devServerScript = devConfig?.project_settings?.worktree_dev_server_script;
-                console.log(`[Daemon] EP973: Ensuring dev server is running in ${worktree.path} on port ${port}...`);
-                const devServerResult = await ensureDevServer(worktree.path, port, cmd.moduleUid, devServerScript);
-                if (!devServerResult.success) {
-                  const errorMsg2 = `Dev server failed to start: ${devServerResult.error}`;
-                  console.error(`[Daemon] ${errorMsg2}`);
-                  await reportTunnelStatus({ tunnel_error: errorMsg2 });
-                  return;
-                }
-                console.log(`[Daemon] Dev server ready on port ${port}`);
-                let lastError;
-                for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-                  console.log(`[Daemon] Starting tunnel (attempt ${attempt}/${MAX_RETRIES})...`);
-                  const startResult = await tunnelManager.startTunnel({
-                    moduleUid: cmd.moduleUid,
-                    port,
-                    onUrl: async (url) => {
-                      console.log(`[Daemon] Tunnel URL for ${cmd.moduleUid}: ${url}`);
-                      await reportTunnelStatus({
-                        tunnel_url: url,
-                        tunnel_error: null
-                        // Clear error on success
-                      });
-                    },
-                    onStatusChange: (status, error) => {
-                      if (status === "error") {
-                        console.error(`[Daemon] Tunnel error for ${cmd.moduleUid}: ${error}`);
-                        reportTunnelStatus({ tunnel_error: error || "Tunnel connection error" });
-                      } else if (status === "reconnecting") {
-                        console.log(`[Daemon] Tunnel reconnecting for ${cmd.moduleUid}...`);
-                      }
-                    }
-                  });
-                  if (startResult.success) {
-                    console.log(`[Daemon] Tunnel started successfully for ${cmd.moduleUid}`);
-                    return;
-                  }
-                  lastError = startResult.error;
-                  console.warn(`[Daemon] Tunnel start attempt ${attempt} failed: ${lastError}`);
-                  if (attempt < MAX_RETRIES) {
-                    console.log(`[Daemon] Retrying in ${RETRY_DELAY_MS}ms...`);
-                    await new Promise((resolve3) => setTimeout(resolve3, RETRY_DELAY_MS));
-                  }
-                }
-                const errorMsg = `Tunnel failed after ${MAX_RETRIES} attempts: ${lastError}`;
-                console.error(`[Daemon] ${errorMsg}`);
-                await reportTunnelStatus({ tunnel_error: errorMsg });
-              } catch (error) {
-                const errorMsg = error instanceof Error ? error.message : String(error);
-                console.error(`[Daemon] Async tunnel startup error:`, error);
-                await reportTunnelStatus({ tunnel_error: `Unexpected error: ${errorMsg}` });
-              }
-            })();
-            result = {
-              success: true,
-              previewUrl
-              // Note: actual tunnel URL will be reported via API when ready
-            };
-          } else if (cmd.action === "stop") {
-            await tunnelManager.stopTunnel(cmd.moduleUid);
-            await stopDevServer(cmd.moduleUid);
-            const config2 = await (0, import_core10.loadConfig)();
-            if (config2?.access_token) {
-              try {
-                const apiUrl = config2.api_url || "https://episoda.dev";
-                await fetch(`${apiUrl}/api/modules/${cmd.moduleUid}/tunnel`, {
-                  method: "DELETE",
-                  headers: {
-                    "Authorization": `Bearer ${config2.access_token}`
-                  }
-                });
-                console.log(`[Daemon] Tunnel URL cleared for ${cmd.moduleUid}`);
-              } catch {
-              }
+            const devConfig = await (0, import_core11.loadConfig)();
+            const customCommand = devConfig?.project_settings?.worktree_dev_server_script;
+            const startResult = await previewManager.startPreview({
+              moduleUid: cmd.moduleUid,
+              worktreePath: worktree.path,
+              port,
+              customCommand
+            });
+            if (startResult.success) {
+              console.log(`[Daemon] EP1024: Preview started for ${cmd.moduleUid}: ${startResult.previewUrl}`);
+              result = {
+                success: true,
+                previewUrl: startResult.previewUrl
+              };
+            } else {
+              console.error(`[Daemon] EP1024: Preview failed for ${cmd.moduleUid}: ${startResult.error}`);
+              result = {
+                success: false,
+                error: startResult.error || "Failed to start preview"
+              };
             }
+          } else if (cmd.action === "stop") {
+            await previewManager.stopPreview(cmd.moduleUid);
             result = { success: true };
           } else {
             result = {
@@ -7197,7 +8201,7 @@ var Daemon = class _Daemon {
             commandId: message.id,
             result
           });
-          console.log(`[Daemon] Tunnel command ${cmd.action} completed for ${cmd.moduleUid}:`, result.success ? "success" : "failed");
+          console.log(`[Daemon] EP1024: Tunnel command ${cmd.action} completed for ${cmd.moduleUid}:`, result.success ? "success" : "failed");
         } catch (error) {
           await client.send({
             type: "tunnel_result",
@@ -7207,7 +8211,7 @@ var Daemon = class _Daemon {
               error: error instanceof Error ? error.message : String(error)
             }
           });
-          console.error(`[Daemon] Tunnel command execution error:`, error);
+          console.error(`[Daemon] EP1024: Tunnel command execution error:`, error);
         }
       }
     });
@@ -7422,8 +8426,8 @@ var Daemon = class _Daemon {
       let daemonPid;
       try {
         const pidPath = getPidFilePath();
-        if (fs16.existsSync(pidPath)) {
-          const pidStr = fs16.readFileSync(pidPath, "utf-8").trim();
+        if (fs17.existsSync(pidPath)) {
+          const pidStr = fs17.readFileSync(pidPath, "utf-8").trim();
           daemonPid = parseInt(pidStr, 10);
         }
       } catch (pidError) {
@@ -7502,29 +8506,29 @@ var Daemon = class _Daemon {
    */
   async configureGitUser(projectPath, userId, workspaceId, machineId, projectId, deviceId) {
     try {
-      const { execSync: execSync7 } = await import("child_process");
-      execSync7(`git config episoda.userId ${userId}`, {
+      const { execSync: execSync8 } = await import("child_process");
+      execSync8(`git config episoda.userId ${userId}`, {
         cwd: projectPath,
         encoding: "utf8",
         stdio: "pipe"
       });
-      execSync7(`git config episoda.workspaceId ${workspaceId}`, {
+      execSync8(`git config episoda.workspaceId ${workspaceId}`, {
         cwd: projectPath,
         encoding: "utf8",
         stdio: "pipe"
       });
-      execSync7(`git config episoda.machineId ${machineId}`, {
+      execSync8(`git config episoda.machineId ${machineId}`, {
         cwd: projectPath,
         encoding: "utf8",
         stdio: "pipe"
       });
-      execSync7(`git config episoda.projectId ${projectId}`, {
+      execSync8(`git config episoda.projectId ${projectId}`, {
         cwd: projectPath,
         encoding: "utf8",
         stdio: "pipe"
       });
       if (deviceId) {
-        execSync7(`git config episoda.deviceId ${deviceId}`, {
+        execSync8(`git config episoda.deviceId ${deviceId}`, {
           cwd: projectPath,
           encoding: "utf8",
           stdio: "pipe"
@@ -7544,27 +8548,27 @@ var Daemon = class _Daemon {
    */
   async installGitHooks(projectPath) {
     const hooks = ["post-checkout", "pre-commit", "post-commit"];
-    const hooksDir = path17.join(projectPath, ".git", "hooks");
-    if (!fs16.existsSync(hooksDir)) {
+    const hooksDir = path18.join(projectPath, ".git", "hooks");
+    if (!fs17.existsSync(hooksDir)) {
       console.warn(`[Daemon] Hooks directory not found: ${hooksDir}`);
       return;
     }
     for (const hookName of hooks) {
       try {
-        const hookPath = path17.join(hooksDir, hookName);
-        const bundledHookPath = path17.join(__dirname, "..", "hooks", hookName);
-        if (!fs16.existsSync(bundledHookPath)) {
+        const hookPath = path18.join(hooksDir, hookName);
+        const bundledHookPath = path18.join(__dirname, "..", "hooks", hookName);
+        if (!fs17.existsSync(bundledHookPath)) {
           console.warn(`[Daemon] Bundled hook not found: ${bundledHookPath}`);
           continue;
         }
-        const hookContent = fs16.readFileSync(bundledHookPath, "utf-8");
-        if (fs16.existsSync(hookPath)) {
-          const existingContent = fs16.readFileSync(hookPath, "utf-8");
+        const hookContent = fs17.readFileSync(bundledHookPath, "utf-8");
+        if (fs17.existsSync(hookPath)) {
+          const existingContent = fs17.readFileSync(hookPath, "utf-8");
           if (existingContent === hookContent) {
             continue;
           }
         }
-        fs16.writeFileSync(hookPath, hookContent, { mode: 493 });
+        fs17.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);
@@ -7579,7 +8583,7 @@ var Daemon = class _Daemon {
    */
   async cacheDeviceId(deviceId) {
     try {
-      const config = await (0, import_core10.loadConfig)();
+      const config = await (0, import_core11.loadConfig)();
       if (!config) {
         console.warn("[Daemon] Cannot cache device ID - no config found");
         return;
@@ -7592,7 +8596,7 @@ var Daemon = class _Daemon {
         device_id: deviceId,
         machine_id: this.machineId
       };
-      await (0, import_core10.saveConfig)(updatedConfig);
+      await (0, import_core11.saveConfig)(updatedConfig);
       console.log(`[Daemon] Cached device ID to config: ${deviceId}`);
     } catch (error) {
       console.warn("[Daemon] Failed to cache device ID:", error instanceof Error ? error.message : error);
@@ -7606,7 +8610,7 @@ var Daemon = class _Daemon {
    */
   async syncProjectSettings(projectId) {
     try {
-      const config = await (0, import_core10.loadConfig)();
+      const config = await (0, import_core11.loadConfig)();
       if (!config) return;
       const apiUrl = config.api_url || "https://episoda.dev";
       const response = await fetchWithAuth(`${apiUrl}/api/projects/${projectId}/settings`);
@@ -7640,7 +8644,7 @@ var Daemon = class _Daemon {
             cached_at: Date.now()
           }
         };
-        await (0, import_core10.saveConfig)(updatedConfig);
+        await (0, import_core11.saveConfig)(updatedConfig);
         console.log(`[Daemon] EP973: Project settings synced (slugs: ${projectSlug}/${workspaceSlug})`);
       }
     } catch (error) {
@@ -7660,7 +8664,7 @@ var Daemon = class _Daemon {
         console.warn("[Daemon] EP995: Cannot sync project path - deviceId not available");
         return;
       }
-      const config = await (0, import_core10.loadConfig)();
+      const config = await (0, import_core11.loadConfig)();
       if (!config) return;
       const apiUrl = config.api_url || "https://episoda.dev";
       const response = await fetchWithAuth(`${apiUrl}/api/account/machines/${this.deviceId}`, {
@@ -7693,7 +8697,7 @@ var Daemon = class _Daemon {
    */
   async updateModuleWorktreeStatus(moduleUid, status, worktreePath, errorMessage) {
     try {
-      const config = await (0, import_core10.loadConfig)();
+      const config = await (0, import_core11.loadConfig)();
       if (!config) return;
       const apiUrl = config.api_url || "https://episoda.dev";
       const body = {
@@ -7748,7 +8752,7 @@ var Daemon = class _Daemon {
         console.log("[Daemon] EP1003: Cannot reconcile - deviceId not available yet");
         return;
       }
-      const config = await (0, import_core10.loadConfig)();
+      const config = await (0, import_core11.loadConfig)();
       if (!config) return;
       const apiUrl = config.api_url || "https://episoda.dev";
       const controller = new AbortController();
@@ -7860,7 +8864,7 @@ var Daemon = class _Daemon {
         console.log(`[Daemon] EP994: No worktree to remove for ${moduleUid}`);
       }
       try {
-        const cleanupConfig = await (0, import_core10.loadConfig)();
+        const cleanupConfig = await (0, import_core11.loadConfig)();
         const cleanupApiUrl = cleanupConfig?.api_url || "https://episoda.dev";
         await fetchWithAuth(`${cleanupApiUrl}/api/modules/${moduleUid}`, {
           method: "PATCH",
@@ -7892,7 +8896,7 @@ var Daemon = class _Daemon {
     try {
       const envVars = await fetchEnvVars2();
       console.log(`[Daemon] EP1002: Fetched ${Object.keys(envVars).length} env vars for ${moduleUid}`);
-      const config = await (0, import_core10.loadConfig)();
+      const config = await (0, import_core11.loadConfig)();
       const setupConfig = config?.project_settings;
       await this.runWorktreeSetupSync(
         moduleUid,
@@ -7938,8 +8942,8 @@ var Daemon = class _Daemon {
       console.log(`[Daemon] EP1002: ${installCmd.description} (detected from ${installCmd.detectedFrom})`);
       console.log(`[Daemon] EP1002: Running: ${installCmd.command.join(" ")}`);
       try {
-        const { execSync: execSync7 } = await import("child_process");
-        execSync7(installCmd.command.join(" "), {
+        const { execSync: execSync8 } = await import("child_process");
+        execSync8(installCmd.command.join(" "), {
           cwd: worktreePath,
           stdio: "inherit",
           timeout: 10 * 60 * 1e3,
@@ -7992,8 +8996,8 @@ var Daemon = class _Daemon {
         console.log(`[Daemon] EP986: ${installCmd.description} (detected from ${installCmd.detectedFrom})`);
         console.log(`[Daemon] EP986: Running: ${installCmd.command.join(" ")}`);
         try {
-          const { execSync: execSync7 } = await import("child_process");
-          execSync7(installCmd.command.join(" "), {
+          const { execSync: execSync8 } = await import("child_process");
+          execSync8(installCmd.command.join(" "), {
             cwd: worktreePath,
             stdio: "inherit",
             timeout: 10 * 60 * 1e3,
@@ -8070,7 +9074,7 @@ var Daemon = class _Daemon {
       }
       this.healthCheckInProgress = true;
       try {
-        const config = await (0, import_core10.loadConfig)();
+        const config = await (0, import_core11.loadConfig)();
         if (config?.access_token) {
           await this.performHealthChecks(config);
         }
@@ -8189,7 +9193,7 @@ var Daemon = class _Daemon {
    */
   async fetchActiveModuleUids(projectId) {
     try {
-      const config = await (0, import_core10.loadConfig)();
+      const config = await (0, import_core11.loadConfig)();
       if (!config?.access_token || !config?.api_url) {
         return null;
       }
@@ -8289,84 +9293,76 @@ var Daemon = class _Daemon {
   }
   /**
    * EP833: Restart a failed tunnel
-   * EP932: Now uses restartDevServer() for robust dev server restart with auto-restart
+   * EP1024: Refactored to use PreviewManager for unified preview lifecycle
    */
   async restartTunnel(moduleUid, port) {
-    const tunnelManager = getTunnelManager();
+    const previewManager = getPreviewManager();
     try {
-      await tunnelManager.stopTunnel(moduleUid);
-      const config = await (0, import_core10.loadConfig)();
+      const config = await (0, import_core11.loadConfig)();
       if (!config?.access_token) {
         console.error(`[Daemon] EP833: No access token for tunnel restart`);
         return;
       }
       const apiUrl = config.api_url || "https://episoda.dev";
-      const devServerResult = await restartDevServer(moduleUid);
-      if (!devServerResult.success) {
-        console.log(`[Daemon] EP932: No tracked server for ${moduleUid}, looking up project...`);
-        let projectId = null;
-        try {
-          const moduleResponse = await fetchWithAuth(`${apiUrl}/api/modules/${moduleUid}`);
-          if (moduleResponse.ok) {
-            const moduleData = await moduleResponse.json();
-            projectId = moduleData.moduleRecord?.project_id ?? null;
-          }
-        } catch (e) {
-          console.warn(`[Daemon] EP833: Failed to fetch module details for project lookup`);
-        }
-        const worktree = await getWorktreeInfoForModule(moduleUid);
-        if (!worktree) {
-          console.error(`[Daemon] EP973: Cannot resolve worktree path for ${moduleUid} - missing config slugs`);
-          return;
-        }
-        if (!worktree.exists) {
-          console.error(`[Daemon] EP973: Worktree not found at ${worktree.path}`);
-          return;
-        }
-        const { isPortInUse: isPortInUse2 } = await Promise.resolve().then(() => (init_port_check(), port_check_exports));
-        if (await isPortInUse2(port)) {
-          console.log(`[Daemon] EP932: Port ${port} in use, checking health...`);
-          const healthy = await isDevServerHealthy(port);
-          if (!healthy) {
-            console.log(`[Daemon] EP932: Dev server on port ${port} is not responding, killing process...`);
-            await killProcessOnPort(port);
-          }
-        }
-        const devServerScript = config.project_settings?.worktree_dev_server_script;
-        const startResult2 = await ensureDevServer(worktree.path, port, moduleUid, devServerScript);
-        if (!startResult2.success) {
-          console.error(`[Daemon] EP932: Failed to start dev server: ${startResult2.error}`);
-          return;
-        }
-      }
-      console.log(`[Daemon] EP932: Dev server ready, restarting tunnel for ${moduleUid}...`);
-      const startResult = await tunnelManager.startTunnel({
-        moduleUid,
-        port,
-        onUrl: async (url) => {
-          console.log(`[Daemon] EP833: Tunnel restarted for ${moduleUid}: ${url}`);
+      const status = previewManager.getStatus(moduleUid);
+      if (status) {
+        console.log(`[Daemon] EP1024: Restarting tracked preview for ${moduleUid}...`);
+        const result2 = await previewManager.restartPreview(moduleUid);
+        if (result2.success && result2.previewUrl) {
+          console.log(`[Daemon] EP833: Preview restarted for ${moduleUid}: ${result2.previewUrl}`);
           try {
             await fetchWithAuth(`${apiUrl}/api/modules/${moduleUid}/tunnel`, {
               method: "POST",
               body: JSON.stringify({
-                tunnel_url: url,
+                tunnel_url: result2.previewUrl,
                 tunnel_error: null,
                 restart_reason: "health_check_failure"
-                // EP1003: Server can track restart causes
               })
             });
           } catch (e) {
             console.warn(`[Daemon] EP833: Failed to report restarted tunnel URL`);
           }
+        } else {
+          console.error(`[Daemon] EP833: Preview restart failed for ${moduleUid}: ${result2.error}`);
         }
+        return;
+      }
+      console.log(`[Daemon] EP1024: No tracked preview for ${moduleUid}, starting fresh...`);
+      const worktree = await getWorktreeInfoForModule(moduleUid);
+      if (!worktree) {
+        console.error(`[Daemon] EP1024: Cannot resolve worktree path for ${moduleUid} - missing config slugs`);
+        return;
+      }
+      if (!worktree.exists) {
+        console.error(`[Daemon] EP1024: Worktree not found at ${worktree.path}`);
+        return;
+      }
+      const devServerScript = config.project_settings?.worktree_dev_server_script;
+      const result = await previewManager.startPreview({
+        moduleUid,
+        worktreePath: worktree.path,
+        port,
+        customCommand: devServerScript
       });
-      if (startResult.success) {
-        console.log(`[Daemon] EP833: Tunnel restart successful for ${moduleUid}`);
+      if (result.success && result.previewUrl) {
+        console.log(`[Daemon] EP833: Preview started for ${moduleUid}: ${result.previewUrl}`);
+        try {
+          await fetchWithAuth(`${apiUrl}/api/modules/${moduleUid}/tunnel`, {
+            method: "POST",
+            body: JSON.stringify({
+              tunnel_url: result.previewUrl,
+              tunnel_error: null,
+              restart_reason: "health_check_failure"
+            })
+          });
+        } catch (e) {
+          console.warn(`[Daemon] EP833: Failed to report restarted tunnel URL`);
+        }
       } else {
-        console.error(`[Daemon] EP833: Tunnel restart failed for ${moduleUid}: ${startResult.error}`);
+        console.error(`[Daemon] EP833: Preview start failed for ${moduleUid}: ${result.error}`);
       }
     } catch (error) {
-      console.error(`[Daemon] EP833: Error restarting tunnel for ${moduleUid}:`, error);
+      console.error(`[Daemon] EP833: Error restarting preview for ${moduleUid}:`, error);
     }
   }
   /**
@@ -8544,8 +9540,8 @@ var Daemon = class _Daemon {
     await this.shutdown();
     try {
       const pidPath = getPidFilePath();
-      if (fs16.existsSync(pidPath)) {
-        fs16.unlinkSync(pidPath);
+      if (fs17.existsSync(pidPath)) {
+        fs17.unlinkSync(pidPath);
         console.log("[Daemon] PID file cleaned up");
       }
     } catch (error) {