@episoda/cli 0.2.205 → 0.2.207

package/dist/daemon/daemon-process.js

@@ -2241,7 +2241,7 @@ var require_websocket_client = __commonJS({
           clearTimeout(this.reconnectTimeout);
           this.reconnectTimeout = void 0;
         }
-        return new Promise((resolve8, reject) => {
+        return new Promise((resolve9, reject) => {
           const connectionTimeout = setTimeout(() => {
             if (this.ws) {
               this.ws.terminate();
@@ -2272,7 +2272,7 @@ var require_websocket_client = __commonJS({
                 daemonPid: this.daemonPid
               });
               this.startHeartbeat();
-              resolve8();
+              resolve9();
             });
             this.ws.on("pong", () => {
               if (this.heartbeatTimeoutTimer) {
@@ -2416,13 +2416,13 @@ var require_websocket_client = __commonJS({
           console.warn("[EpisodaClient] Cannot send - WebSocket not connected");
           return false;
         }
-        return new Promise((resolve8) => {
+        return new Promise((resolve9) => {
           this.ws.send(JSON.stringify(message), (error) => {
             if (error) {
               console.error("[EpisodaClient] Failed to send message:", error);
-              resolve8(false);
+              resolve9(false);
             } else {
-              resolve8(true);
+              resolve9(true);
             }
           });
         });
@@ -3051,7 +3051,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@episoda/cli",
-      version: "0.2.205",
+      version: "0.2.207",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -3088,8 +3088,8 @@ var require_package = __commonJS({
       },
       optionalDependencies: {
         "@anthropic-ai/claude-code": "^2.0.0",
-        "@modelcontextprotocol/server-github": "^0.6.0",
-        "@openai/codex": "^0.86.0"
+        "@openai/codex": "^0.86.0",
+        "@modelcontextprotocol/server-github": "^0.6.0"
       },
       devDependencies: {
         "@episoda/core": "workspace:*",
@@ -3330,19 +3330,106 @@ function pruneMissingProjectPaths() {
 }
 
 // src/daemon/daemon-manager.ts
+var path4 = __toESM(require("path"));
+var import_core5 = __toESM(require_dist());
+
+// src/daemon/lifecycle-metadata.ts
+var fs3 = __toESM(require("fs"));
 var path3 = __toESM(require("path"));
 var import_core3 = __toESM(require_dist());
+var DEFAULT_METADATA = {
+  serviceMode: "detached",
+  lastRestartReason: null,
+  lastStartedAt: null
+};
+function getMetadataPath() {
+  return path3.join((0, import_core3.getConfigDir)(), "daemon-metadata.json");
+}
+function readDaemonLifecycleMetadata() {
+  try {
+    const metadataPath = getMetadataPath();
+    if (!fs3.existsSync(metadataPath)) {
+      return { ...DEFAULT_METADATA };
+    }
+    const parsed = JSON.parse(fs3.readFileSync(metadataPath, "utf8"));
+    return {
+      serviceMode: parsed.serviceMode === "detached" ? parsed.serviceMode : DEFAULT_METADATA.serviceMode,
+      lastRestartReason: typeof parsed.lastRestartReason === "string" ? parsed.lastRestartReason : DEFAULT_METADATA.lastRestartReason,
+      lastStartedAt: typeof parsed.lastStartedAt === "string" ? parsed.lastStartedAt : DEFAULT_METADATA.lastStartedAt
+    };
+  } catch {
+    return { ...DEFAULT_METADATA };
+  }
+}
+
+// src/utils/update-checker.ts
+var import_child_process2 = require("child_process");
+var semver = __toESM(require("semver"));
+
+// src/ipc/ipc-client.ts
+var import_core4 = __toESM(require_dist());
+
+// src/utils/update-checker.ts
+var PACKAGE_NAME = "@episoda/cli";
+var LEGACY_PACKAGE_NAME = "episoda";
+function getInstalledVersion() {
+  try {
+    const output = (0, import_child_process2.execSync)(`npm list -g ${PACKAGE_NAME} --json`, {
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 1e4
+    }).toString();
+    const data = JSON.parse(output);
+    return data?.dependencies?.[PACKAGE_NAME]?.version || null;
+  } catch {
+    return null;
+  }
+}
+function getLegacyInstalledVersion() {
+  try {
+    const output = (0, import_child_process2.execSync)(`npm list -g ${LEGACY_PACKAGE_NAME} --json`, {
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 1e4
+    }).toString();
+    const data = JSON.parse(output);
+    return data?.dependencies?.[LEGACY_PACKAGE_NAME]?.version || null;
+  } catch {
+    return null;
+  }
+}
+function detectCliInstallChannel(embeddedVersion) {
+  const scopedVersion = getInstalledVersion();
+  const legacyVersion = getLegacyInstalledVersion();
+  const effectiveVersion = scopedVersion || legacyVersion || embeddedVersion || null;
+  return {
+    scopedVersion,
+    legacyVersion,
+    legacyOnly: !scopedVersion && !!legacyVersion,
+    effectiveVersion
+  };
+}
+function resolveEffectiveCliVersion(embeddedVersion) {
+  const installedVersion = detectCliInstallChannel(embeddedVersion).effectiveVersion;
+  if (!installedVersion) {
+    return embeddedVersion;
+  }
+  if (semver.valid(installedVersion) && semver.valid(embeddedVersion)) {
+    return semver.gt(installedVersion, embeddedVersion) ? installedVersion : embeddedVersion;
+  }
+  return installedVersion === embeddedVersion ? embeddedVersion : installedVersion;
+}
+
+// src/daemon/daemon-manager.ts
 function getPidFilePath() {
-  return path3.join((0, import_core3.getConfigDir)(), "daemon.pid");
+  return path4.join((0, import_core5.getConfigDir)(), "daemon.pid");
 }
 var MAX_LOG_SIZE_BYTES = 10 * 1024 * 1024;
 
 // src/ipc/ipc-server.ts
 var net = __toESM(require("net"));
-var fs3 = __toESM(require("fs"));
-var path4 = __toESM(require("path"));
-var import_core4 = __toESM(require_dist());
-var getSocketPath = () => path4.join((0, import_core4.getConfigDir)(), "daemon.sock");
+var fs4 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+var import_core6 = __toESM(require_dist());
+var getSocketPath = () => path5.join((0, import_core6.getConfigDir)(), "daemon.sock");
 var IPCServer = class {
   constructor() {
     this.server = null;
@@ -3364,20 +3451,20 @@ var IPCServer = class {
    */
   async start() {
     const socketPath = getSocketPath();
-    if (fs3.existsSync(socketPath)) {
-      fs3.unlinkSync(socketPath);
+    if (fs4.existsSync(socketPath)) {
+      fs4.unlinkSync(socketPath);
     }
-    const dir = path4.dirname(socketPath);
-    if (!fs3.existsSync(dir)) {
-      fs3.mkdirSync(dir, { recursive: true });
+    const dir = path5.dirname(socketPath);
+    if (!fs4.existsSync(dir)) {
+      fs4.mkdirSync(dir, { recursive: true });
     }
     this.server = net.createServer((socket) => {
       this.handleConnection(socket);
     });
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       this.server.listen(socketPath, () => {
-        fs3.chmodSync(socketPath, 384);
-        resolve8();
+        fs4.chmodSync(socketPath, 384);
+        resolve9();
       });
       this.server.on("error", reject);
     });
@@ -3388,12 +3475,12 @@ var IPCServer = class {
   async stop() {
     if (!this.server) return;
     const socketPath = getSocketPath();
-    return new Promise((resolve8) => {
+    return new Promise((resolve9) => {
       this.server.close(() => {
-        if (fs3.existsSync(socketPath)) {
-          fs3.unlinkSync(socketPath);
+        if (fs4.existsSync(socketPath)) {
+          fs4.unlinkSync(socketPath);
         }
-        resolve8();
+        resolve9();
       });
     });
   }
@@ -3458,10 +3545,10 @@ var IPCServer = class {
 var import_core22 = __toESM(require_dist());
 
 // src/daemon/handlers/stale-commit-cleanup.ts
-var import_child_process2 = require("child_process");
+var import_child_process3 = require("child_process");
 var import_util = require("util");
-var import_core5 = __toESM(require_dist());
-var execAsync = (0, import_util.promisify)(import_child_process2.exec);
+var import_core7 = __toESM(require_dist());
+var execAsync = (0, import_util.promisify)(import_child_process3.exec);
 async function isGitRepository(projectPath) {
   try {
     await execAsync("git rev-parse --git-dir", { cwd: projectPath, timeout: 5e3 });
@@ -3481,7 +3568,7 @@ async function cleanupStaleCommits(projectPath) {
       };
     }
     const machineId = await getMachineId();
-    const config = await (0, import_core5.loadConfig)();
+    const config = await (0, import_core7.loadConfig)();
     if (!config?.access_token) {
       return {
         success: false,
@@ -3572,9 +3659,9 @@ async function cleanupStaleCommits(projectPath) {
 }
 
 // src/tunnel/cloudflared-manager.ts
-var import_child_process3 = require("child_process");
-var fs4 = __toESM(require("fs"));
-var path5 = __toESM(require("path"));
+var import_child_process4 = require("child_process");
+var fs5 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
 var os = __toESM(require("os"));
 var https = __toESM(require("https"));
 var tar = __toESM(require("tar"));
@@ -3593,17 +3680,17 @@ var DOWNLOAD_URLS = {
   }
 };
 function getEpisodaBinDir() {
-  return path5.join(os.homedir(), ".episoda", "bin");
+  return path6.join(os.homedir(), ".episoda", "bin");
 }
 function getCloudflaredPath() {
   const binaryName = os.platform() === "win32" ? "cloudflared.exe" : "cloudflared";
-  return path5.join(getEpisodaBinDir(), binaryName);
+  return path6.join(getEpisodaBinDir(), binaryName);
 }
 function isCloudflaredInPath() {
   try {
     const command = os.platform() === "win32" ? "where" : "which";
     const binaryName = os.platform() === "win32" ? "cloudflared.exe" : "cloudflared";
-    const result = (0, import_child_process3.spawnSync)(command, [binaryName], { encoding: "utf-8" });
+    const result = (0, import_child_process4.spawnSync)(command, [binaryName], { encoding: "utf-8" });
     if (result.status === 0 && result.stdout.trim()) {
       return result.stdout.trim().split("\n")[0].trim();
     }
@@ -3614,7 +3701,7 @@ function isCloudflaredInPath() {
 function isCloudflaredInstalled() {
   const cloudflaredPath = getCloudflaredPath();
   try {
-    fs4.accessSync(cloudflaredPath, fs4.constants.X_OK);
+    fs5.accessSync(cloudflaredPath, fs5.constants.X_OK);
     return true;
   } catch {
     return false;
@@ -3622,7 +3709,7 @@ function isCloudflaredInstalled() {
 }
 function verifyCloudflared(binaryPath) {
   try {
-    const result = (0, import_child_process3.spawnSync)(binaryPath, ["version"], { encoding: "utf-8", timeout: 5e3 });
+    const result = (0, import_child_process4.spawnSync)(binaryPath, ["version"], { encoding: "utf-8", timeout: 5e3 });
     return result.status === 0 && result.stdout.includes("cloudflared");
   } catch {
     return false;
@@ -3638,7 +3725,7 @@ function getDownloadUrl() {
   return platformUrls[arch4] || null;
 }
 async function downloadFile(url, destPath) {
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const followRedirect = (currentUrl, redirectCount = 0) => {
       if (redirectCount > 5) {
         reject(new Error("Too many redirects"));
@@ -3664,14 +3751,14 @@ async function downloadFile(url, destPath) {
           reject(new Error(`Failed to download: HTTP ${response.statusCode}`));
           return;
         }
-        const file = fs4.createWriteStream(destPath);
+        const file = fs5.createWriteStream(destPath);
         response.pipe(file);
         file.on("finish", () => {
           file.close();
-          resolve8();
+          resolve9();
         });
         file.on("error", (err) => {
-          fs4.unlinkSync(destPath);
+          fs5.unlinkSync(destPath);
           reject(err);
         });
       }).on("error", reject);
@@ -3692,21 +3779,21 @@ async function downloadCloudflared() {
   }
   const binDir = getEpisodaBinDir();
   const cloudflaredPath = getCloudflaredPath();
-  fs4.mkdirSync(binDir, { recursive: true });
+  fs5.mkdirSync(binDir, { recursive: true });
   const isTgz = url.endsWith(".tgz");
   if (isTgz) {
-    const tempFile = path5.join(binDir, "cloudflared.tgz");
+    const tempFile = path6.join(binDir, "cloudflared.tgz");
     console.log(`[Tunnel] Downloading cloudflared from ${url}...`);
     await downloadFile(url, tempFile);
     console.log("[Tunnel] Extracting cloudflared...");
     await extractTgz(tempFile, binDir);
-    fs4.unlinkSync(tempFile);
+    fs5.unlinkSync(tempFile);
   } else {
     console.log(`[Tunnel] Downloading cloudflared from ${url}...`);
     await downloadFile(url, cloudflaredPath);
   }
   if (os.platform() !== "win32") {
-    fs4.chmodSync(cloudflaredPath, 493);
+    fs5.chmodSync(cloudflaredPath, 493);
   }
   if (!verifyCloudflared(cloudflaredPath)) {
     throw new Error("Downloaded cloudflared binary failed verification");
@@ -3727,14 +3814,14 @@ async function ensureCloudflared() {
 }
 
 // src/tunnel/tunnel-manager.ts
-var import_child_process4 = require("child_process");
+var import_child_process5 = require("child_process");
 var import_events = require("events");
-var fs5 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
+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());
+var import_core8 = __toESM(require_dist());
 async function readJsonBody(response) {
   const text = await response.text();
   if (!text) {
@@ -3752,7 +3839,7 @@ function formatNonJsonError(status, text) {
 }
 async function provisionNamedTunnel(moduleId, port = 3e3) {
   console.log(`[TunnelAPI] EP1038: provisionNamedTunnel called for moduleId ${moduleId} with port ${port}`);
-  const config = await (0, import_core6.loadConfig)();
+  const config = await (0, import_core8.loadConfig)();
   if (!config?.access_token) {
     return { success: false, error: "Not authenticated" };
   }
@@ -3796,7 +3883,7 @@ async function provisionNamedTunnel(moduleId, port = 3e3) {
 }
 async function provisionNamedTunnelByUid(moduleUid, port = 3e3) {
   console.log(`[TunnelAPI] EP1038: provisionNamedTunnelByUid called for ${moduleUid} with port ${port}`);
-  const config = await (0, import_core6.loadConfig)();
+  const config = await (0, import_core8.loadConfig)();
   if (!config?.access_token) {
     return { success: false, error: "Not authenticated" };
   }
@@ -3840,7 +3927,7 @@ async function updateTunnelStatus(moduleUid, status, error) {
   if (!moduleUid || moduleUid === "LOCAL") {
     return;
   }
-  const config = await (0, import_core6.loadConfig)();
+  const config = await (0, import_core8.loadConfig)();
   if (!config?.access_token) {
     return;
   }
@@ -3865,7 +3952,7 @@ async function clearTunnelUrl(moduleUid) {
   if (!moduleUid || moduleUid === "LOCAL") {
     return;
   }
-  const config = await (0, import_core6.loadConfig)();
+  const config = await (0, import_core8.loadConfig)();
   if (!config?.access_token) {
     return;
   }
@@ -3906,7 +3993,7 @@ function getDaemonModeConfig() {
 }
 
 // src/tunnel/tunnel-manager.ts
-var TUNNEL_PID_DIR = path6.join(os2.homedir(), ".episoda", "tunnels");
+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,
@@ -3938,9 +4025,9 @@ var TunnelManager = class extends import_events.EventEmitter {
    */
   ensurePidDir() {
     try {
-      if (!fs5.existsSync(TUNNEL_PID_DIR)) {
+      if (!fs6.existsSync(TUNNEL_PID_DIR)) {
         console.log(`[Tunnel] EP904: Creating PID directory: ${TUNNEL_PID_DIR}`);
-        fs5.mkdirSync(TUNNEL_PID_DIR, { recursive: true });
+        fs6.mkdirSync(TUNNEL_PID_DIR, { recursive: true });
         console.log(`[Tunnel] EP904: PID directory created successfully`);
       }
     } catch (error) {
@@ -3952,7 +4039,7 @@ var TunnelManager = class extends import_events.EventEmitter {
    * EP877: Get PID file path for a module
    */
   getPidFilePath(moduleUid) {
-    return path6.join(TUNNEL_PID_DIR, `${moduleUid}.pid`);
+    return path7.join(TUNNEL_PID_DIR, `${moduleUid}.pid`);
   }
   /**
    * EP877: Write PID to file for tracking across restarts
@@ -3962,7 +4049,7 @@ var TunnelManager = class extends import_events.EventEmitter {
     try {
       this.ensurePidDir();
       const pidPath = this.getPidFilePath(moduleUid);
-      fs5.writeFileSync(pidPath, pid.toString(), "utf8");
+      fs6.writeFileSync(pidPath, pid.toString(), "utf8");
       console.log(`[Tunnel] EP904: Wrote PID ${pid} for ${moduleUid} to ${pidPath}`);
     } catch (error) {
       console.error(`[Tunnel] EP904: Failed to write PID file for ${moduleUid}:`, error);
@@ -3975,10 +4062,10 @@ var TunnelManager = class extends import_events.EventEmitter {
   readPidFile(moduleUid) {
     try {
       const pidPath = this.getPidFilePath(moduleUid);
-      if (!fs5.existsSync(pidPath)) {
+      if (!fs6.existsSync(pidPath)) {
         return null;
       }
-      const content = fs5.readFileSync(pidPath, "utf8").trim();
+      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`);
@@ -4006,8 +4093,8 @@ var TunnelManager = class extends import_events.EventEmitter {
   removePidFile(moduleUid) {
     try {
       const pidPath = this.getPidFilePath(moduleUid);
-      if (fs5.existsSync(pidPath)) {
-        fs5.unlinkSync(pidPath);
+      if (fs6.existsSync(pidPath)) {
+        fs6.unlinkSync(pidPath);
         console.log(`[Tunnel] EP877: Removed PID file for ${moduleUid}`);
       }
     } catch (error) {
@@ -4042,7 +4129,7 @@ var TunnelManager = class extends import_events.EventEmitter {
    */
   findCloudflaredProcesses() {
     try {
-      const output = (0, import_child_process4.execSync)("pgrep -f cloudflared", { encoding: "utf8" });
+      const output = (0, import_child_process5.execSync)("pgrep -f cloudflared", { encoding: "utf8" });
       return output.trim().split("\n").map((pid) => parseInt(pid, 10)).filter((pid) => !isNaN(pid));
     } catch {
       return [];
@@ -4054,7 +4141,7 @@ var TunnelManager = class extends import_events.EventEmitter {
    */
   getProcessPort(pid) {
     try {
-      const output = (0, import_child_process4.execSync)(`ps -p ${pid} -o args=`, { encoding: "utf8" }).trim();
+      const output = (0, import_child_process5.execSync)(`ps -p ${pid} -o args=`, { encoding: "utf8" }).trim();
       const portMatch = output.match(/--url\s+https?:\/\/localhost:(\d+)/);
       if (portMatch) {
         return parseInt(portMatch[1], 10);
@@ -4082,10 +4169,10 @@ var TunnelManager = class extends import_events.EventEmitter {
       const isTracked = Array.from(this.tunnelStates.values()).some((s) => s.info.pid === pid);
       console.log(`[Tunnel] EP904: Found cloudflared PID ${pid} on port ${port} (tracked: ${isTracked})`);
       this.killByPid(pid, "SIGTERM");
-      await new Promise((resolve8) => setTimeout(resolve8, 500));
+      await new Promise((resolve9) => setTimeout(resolve9, 500));
       if (this.isProcessRunning(pid)) {
         this.killByPid(pid, "SIGKILL");
-        await new Promise((resolve8) => setTimeout(resolve8, 200));
+        await new Promise((resolve9) => setTimeout(resolve9, 200));
       }
       killed.push(pid);
     }
@@ -4111,7 +4198,7 @@ var TunnelManager = class extends import_events.EventEmitter {
     }
     try {
       this.ensurePidDir();
-      const pidFiles = fs5.readdirSync(TUNNEL_PID_DIR).filter((f) => f.endsWith(".pid"));
+      const pidFiles = fs6.readdirSync(TUNNEL_PID_DIR).filter((f) => f.endsWith(".pid"));
       for (const pidFile of pidFiles) {
         const moduleUid = pidFile.replace(".pid", "");
         const pid = this.readPidFile(moduleUid);
@@ -4119,7 +4206,7 @@ var TunnelManager = class extends import_events.EventEmitter {
           if (!this.tunnelStates.has(moduleUid)) {
             console.log(`[Tunnel] EP877: Found orphaned process PID ${pid} for ${moduleUid}, killing...`);
             this.killByPid(pid, "SIGTERM");
-            await new Promise((resolve8) => setTimeout(resolve8, 1e3));
+            await new Promise((resolve9) => setTimeout(resolve9, 1e3));
             if (this.isProcessRunning(pid)) {
               this.killByPid(pid, "SIGKILL");
             }
@@ -4134,7 +4221,7 @@ var TunnelManager = class extends import_events.EventEmitter {
         if (!trackedPids.includes(pid) && !cleaned.includes(pid)) {
           console.log(`[Tunnel] EP877: Found untracked cloudflared process PID ${pid}, killing...`);
           this.killByPid(pid, "SIGTERM");
-          await new Promise((resolve8) => setTimeout(resolve8, 500));
+          await new Promise((resolve9) => setTimeout(resolve9, 500));
           if (this.isProcessRunning(pid)) {
             this.killByPid(pid, "SIGKILL");
           }
@@ -4224,7 +4311,7 @@ var TunnelManager = class extends import_events.EventEmitter {
         return { success: false, error: `Failed to get cloudflared: ${errorMessage}` };
       }
     }
-    return new Promise((resolve8) => {
+    return new Promise((resolve9) => {
       const tunnelInfo = {
         moduleUid,
         url: previewUrl || "",
@@ -4235,7 +4322,7 @@ var TunnelManager = class extends import_events.EventEmitter {
         process: null
       };
       console.log(`[Tunnel] EP948: Starting Named Tunnel for ${moduleUid} with preview URL ${previewUrl}`);
-      const process2 = (0, import_child_process4.spawn)(this.cloudflaredPath, [
+      const process2 = (0, import_child_process5.spawn)(this.cloudflaredPath, [
         "tunnel",
         "run",
         "--token",
@@ -4290,7 +4377,7 @@ var TunnelManager = class extends import_events.EventEmitter {
             moduleUid,
             url: tunnelInfo.url
           });
-          resolve8({ success: true, url: tunnelInfo.url });
+          resolve9({ success: true, url: tunnelInfo.url });
         }
       };
       process2.stderr?.on("data", (data) => {
@@ -4317,7 +4404,7 @@ var TunnelManager = class extends import_events.EventEmitter {
             onStatusChange?.("error", errorMsg);
             this.emitEvent({ type: "error", moduleUid, error: errorMsg });
           }
-          resolve8({ success: false, error: errorMsg });
+          resolve9({ success: false, error: errorMsg });
         } else if (wasConnected) {
           if (currentState && !currentState.intentionallyStopped) {
             console.log(`[Tunnel] EP948: Named tunnel ${moduleUid} crashed unexpectedly, attempting reconnect...`);
@@ -4348,7 +4435,7 @@ var TunnelManager = class extends import_events.EventEmitter {
           this.emitEvent({ type: "error", moduleUid, error: error.message });
         }
         if (!connected) {
-          resolve8({ success: false, error: error.message });
+          resolve9({ success: false, error: error.message });
         }
       });
       setTimeout(() => {
@@ -4371,7 +4458,7 @@ var TunnelManager = class extends import_events.EventEmitter {
             onStatusChange?.("error", errorMsg);
             this.emitEvent({ type: "error", moduleUid, error: errorMsg });
           }
-          resolve8({ success: false, error: errorMsg });
+          resolve9({ success: false, error: errorMsg });
         }
       }, TUNNEL_TIMEOUTS.NAMED_TUNNEL_CONNECT);
     });
@@ -4432,7 +4519,7 @@ var TunnelManager = class extends import_events.EventEmitter {
     if (orphanPid && this.isProcessRunning(orphanPid)) {
       console.log(`[Tunnel] EP877: Killing orphaned process ${orphanPid} for ${moduleUid} before starting new tunnel`);
       this.killByPid(orphanPid, "SIGTERM");
-      await new Promise((resolve8) => setTimeout(resolve8, 500));
+      await new Promise((resolve9) => setTimeout(resolve9, 500));
       if (this.isProcessRunning(orphanPid)) {
         this.killByPid(orphanPid, "SIGKILL");
       }
@@ -4441,7 +4528,7 @@ var TunnelManager = class extends import_events.EventEmitter {
     const killedOnPort = await this.killCloudflaredOnPort(port);
     if (killedOnPort.length > 0) {
       console.log(`[Tunnel] EP904: Pre-start port cleanup killed ${killedOnPort.length} process(es) on port ${port}`);
-      await new Promise((resolve8) => setTimeout(resolve8, 1e3));
+      await new Promise((resolve9) => setTimeout(resolve9, 1e3));
     }
     const cleanup = await this.cleanupOrphanedProcesses();
     if (cleanup.cleaned > 0) {
@@ -4481,7 +4568,7 @@ var TunnelManager = class extends import_events.EventEmitter {
       if (orphanPid && this.isProcessRunning(orphanPid)) {
         console.log(`[Tunnel] EP877: Stopping orphaned process ${orphanPid} for ${moduleUid} via PID file`);
         this.killByPid(orphanPid, "SIGTERM");
-        await new Promise((resolve8) => setTimeout(resolve8, 1e3));
+        await new Promise((resolve9) => setTimeout(resolve9, 1e3));
         if (this.isProcessRunning(orphanPid)) {
           this.killByPid(orphanPid, "SIGKILL");
         }
@@ -4497,16 +4584,16 @@ var TunnelManager = class extends import_events.EventEmitter {
     const tunnel = state.info;
     if (tunnel.process && !tunnel.process.killed) {
       tunnel.process.kill("SIGTERM");
-      await new Promise((resolve8) => {
+      await new Promise((resolve9) => {
         const timeout = setTimeout(() => {
           if (tunnel.process && !tunnel.process.killed) {
             tunnel.process.kill("SIGKILL");
           }
-          resolve8();
+          resolve9();
         }, 3e3);
         tunnel.process.once("exit", () => {
           clearTimeout(timeout);
-          resolve8();
+          resolve9();
         });
       });
     }
@@ -4567,14 +4654,14 @@ function getTunnelManager() {
 }
 
 // src/agent/providers/claude-binary.ts
-var import_child_process5 = require("child_process");
-var path7 = __toESM(require("path"));
-var fs6 = __toESM(require("fs"));
+var import_child_process6 = require("child_process");
+var path8 = __toESM(require("path"));
+var fs7 = __toESM(require("fs"));
 var cachedBinaryPath = null;
 function isValidClaudeBinary(binaryPath) {
   try {
-    fs6.accessSync(binaryPath, fs6.constants.X_OK);
-    const version = (0, import_child_process5.execSync)(`"${binaryPath}" --version`, {
+    fs7.accessSync(binaryPath, fs7.constants.X_OK);
+    const version = (0, import_child_process6.execSync)(`"${binaryPath}" --version`, {
       encoding: "utf-8",
       timeout: 5e3,
       stdio: ["pipe", "pipe", "pipe"]
@@ -4593,7 +4680,7 @@ async function ensureClaudeBinary() {
     return cachedBinaryPath;
   }
   try {
-    const pathResult = (0, import_child_process5.execSync)("which claude", {
+    const pathResult = (0, import_child_process6.execSync)("which claude", {
       encoding: "utf-8",
       timeout: 5e3,
       stdio: ["pipe", "pipe", "pipe"]
@@ -4606,20 +4693,20 @@ async function ensureClaudeBinary() {
   }
   const bundledPaths = [
     // In production: node_modules/.bin/claude
-    path7.join(__dirname, "..", "..", "node_modules", ".bin", "claude"),
+    path8.join(__dirname, "..", "..", "node_modules", ".bin", "claude"),
     // In monorepo development: packages/episoda/node_modules/.bin/claude
-    path7.join(__dirname, "..", "..", "..", "..", "node_modules", ".bin", "claude"),
+    path8.join(__dirname, "..", "..", "..", "..", "node_modules", ".bin", "claude"),
     // Root monorepo node_modules
-    path7.join(__dirname, "..", "..", "..", "..", "..", "node_modules", ".bin", "claude")
+    path8.join(__dirname, "..", "..", "..", "..", "..", "node_modules", ".bin", "claude")
   ];
   for (const bundledPath of bundledPaths) {
-    if (fs6.existsSync(bundledPath) && isValidClaudeBinary(bundledPath)) {
+    if (fs7.existsSync(bundledPath) && isValidClaudeBinary(bundledPath)) {
       cachedBinaryPath = bundledPath;
       return cachedBinaryPath;
     }
   }
   try {
-    const npxResult = (0, import_child_process5.execSync)("npx --yes @anthropic-ai/claude-code --version", {
+    const npxResult = (0, import_child_process6.execSync)("npx --yes @anthropic-ai/claude-code --version", {
       encoding: "utf-8",
       timeout: 3e4,
       // npx might need to download
@@ -4638,14 +4725,14 @@ async function ensureClaudeBinary() {
 }
 
 // src/agent/providers/codex-binary.ts
-var import_child_process6 = require("child_process");
-var path8 = __toESM(require("path"));
-var fs7 = __toESM(require("fs"));
+var import_child_process7 = require("child_process");
+var path9 = __toESM(require("path"));
+var fs8 = __toESM(require("fs"));
 var cachedBinaryPath2 = null;
 function isValidCodexBinary(binaryPath) {
   try {
-    fs7.accessSync(binaryPath, fs7.constants.X_OK);
-    const version = (0, import_child_process6.execSync)(`"${binaryPath}" --version`, {
+    fs8.accessSync(binaryPath, fs8.constants.X_OK);
+    const version = (0, import_child_process7.execSync)(`"${binaryPath}" --version`, {
       encoding: "utf-8",
       timeout: 5e3,
       stdio: ["pipe", "pipe", "pipe"]
@@ -4664,7 +4751,7 @@ async function ensureCodexBinary() {
     return cachedBinaryPath2;
   }
   try {
-    const pathResult = (0, import_child_process6.execSync)("which codex", {
+    const pathResult = (0, import_child_process7.execSync)("which codex", {
       encoding: "utf-8",
       timeout: 5e3,
       stdio: ["pipe", "pipe", "pipe"]
@@ -4677,20 +4764,20 @@ async function ensureCodexBinary() {
   }
   const bundledPaths = [
     // In production: node_modules/.bin/codex
-    path8.join(__dirname, "..", "..", "node_modules", ".bin", "codex"),
+    path9.join(__dirname, "..", "..", "node_modules", ".bin", "codex"),
     // In monorepo development: packages/episoda/node_modules/.bin/codex
-    path8.join(__dirname, "..", "..", "..", "..", "node_modules", ".bin", "codex"),
+    path9.join(__dirname, "..", "..", "..", "..", "node_modules", ".bin", "codex"),
     // Root monorepo node_modules
-    path8.join(__dirname, "..", "..", "..", "..", "..", "node_modules", ".bin", "codex")
+    path9.join(__dirname, "..", "..", "..", "..", "..", "node_modules", ".bin", "codex")
   ];
   for (const bundledPath of bundledPaths) {
-    if (fs7.existsSync(bundledPath) && isValidCodexBinary(bundledPath)) {
+    if (fs8.existsSync(bundledPath) && isValidCodexBinary(bundledPath)) {
       cachedBinaryPath2 = bundledPath;
       return cachedBinaryPath2;
     }
   }
   try {
-    const npxResult = (0, import_child_process6.execSync)("npx --yes @openai/codex --version", {
+    const npxResult = (0, import_child_process7.execSync)("npx --yes @openai/codex --version", {
       encoding: "utf-8",
       timeout: 3e4,
       // npx might need to download
@@ -4782,13 +4869,13 @@ function generateCodexMcpConfigToml(servers, projectPath) {
 }
 
 // src/agent/agent-control-plane.ts
-var path14 = __toESM(require("path"));
-var fs13 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
 var os7 = __toESM(require("os"));
-var import_core9 = __toESM(require_dist());
+var import_core11 = __toESM(require_dist());
 
 // src/agent/runtime/claude-runtime.ts
-var import_child_process7 = require("child_process");
+var import_child_process8 = require("child_process");
 
 // src/agent/runtime/runtime-process-utils.ts
 async function writeToStdinWithBackpressure(process2, data, drainTimeoutMs, label, sessionId) {
@@ -4796,15 +4883,15 @@ async function writeToStdinWithBackpressure(process2, data, drainTimeoutMs, labe
   if (!stdin || stdin.destroyed) {
     throw new Error(`[${label}] stdin not available. session=${sessionId}`);
   }
-  await new Promise((resolve8, reject) => {
+  await new Promise((resolve9, reject) => {
     const ok = stdin.write(data);
     if (ok) {
-      resolve8();
+      resolve9();
       return;
     }
     const onDrain = () => {
       cleanup();
-      resolve8();
+      resolve9();
     };
     const onError = (err) => {
       cleanup();
@@ -4825,18 +4912,18 @@ async function writeToStdinWithBackpressure(process2, data, drainTimeoutMs, labe
   });
 }
 function waitForProcessExit(process2, alive, timeoutMs) {
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     if (!process2 || !alive) {
-      resolve8(true);
+      resolve9(true);
       return;
     }
     const onExit = () => {
       clearTimeout(timer);
-      resolve8(true);
+      resolve9(true);
     };
     const timer = setTimeout(() => {
       process2.removeListener("exit", onExit);
-      resolve8(false);
+      resolve9(false);
     }, timeoutMs);
     process2.once("exit", onExit);
   });
@@ -5024,7 +5111,7 @@ var ClaudePersistentRuntime = class {
     this.spawnTimestamp = Date.now();
     const spawnRssMb = Math.round(process.memoryUsage().rss / 1024 / 1024);
     console.log(`[ClaudePersistentRuntime] Spawning persistent Claude process for session ${this.sessionId}, RSS=${spawnRssMb}MB`);
-    this.process = (0, import_child_process7.spawn)(binaryPath, args, {
+    this.process = (0, import_child_process8.spawn)(binaryPath, args, {
       cwd,
       env,
       // CLAUDE_CODE_DISABLE_PLUGIN_CACHE=1 is set by agent-manager in envVars
@@ -5429,7 +5516,7 @@ var ClaudePersistentRuntime = class {
 };
 
 // src/agent/runtime/codex-runtime.ts
-var import_child_process8 = require("child_process");
+var import_child_process9 = require("child_process");
 var INIT_TIMEOUT_MS = 3e4;
 var INACTIVITY_TIMEOUT_MS2 = parseInt(process.env.AGENT_STREAM_INACTIVITY_TIMEOUT_MS || "180000", 10);
 var SHUTDOWN_SIGTERM_WAIT_MS2 = 2e3;
@@ -5486,7 +5573,7 @@ var CodexPersistentRuntime = class {
     this.spawnTimestamp = Date.now();
     const spawnRssMb = Math.round(process.memoryUsage().rss / 1024 / 1024);
     console.log(`[CodexPersistentRuntime] Spawning persistent Codex app-server for session ${this.sessionId}, RSS=${spawnRssMb}MB`);
-    this.process = (0, import_child_process8.spawn)(binaryPath, args, {
+    this.process = (0, import_child_process9.spawn)(binaryPath, args, {
       cwd,
       env,
       stdio: ["pipe", "pipe", "pipe"]
@@ -5832,10 +5919,10 @@ var CodexPersistentRuntime = class {
   }
   waitForThreadId(timeoutMs) {
     if (this._agentSessionId) return Promise.resolve(this._agentSessionId);
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       const onId = (id) => {
         clearTimeout(timer);
-        resolve8(id);
+        resolve9(id);
       };
       const timer = setTimeout(() => {
         this.threadIdWaiters = this.threadIdWaiters.filter((w) => w !== onId);
@@ -5866,12 +5953,12 @@ var CodexPersistentRuntime = class {
   sendRequest(method, params, timeoutMs = INIT_TIMEOUT_MS) {
     const id = this.nextId++;
     const msg = { jsonrpc: "2.0", id, method, params };
-    return new Promise(async (resolve8, reject) => {
+    return new Promise(async (resolve9, reject) => {
       const timeout = setTimeout(() => {
         this.pending.delete(id);
         reject(new Error(`JSON-RPC timeout: ${method}`));
       }, timeoutMs);
-      this.pending.set(id, { resolve: resolve8, reject, timeout });
+      this.pending.set(id, { resolve: resolve9, reject, timeout });
       try {
         await this.writeToStdin(JSON.stringify(msg) + "\n");
       } catch (err) {
@@ -6021,11 +6108,11 @@ var UnifiedAgentRuntime = class {
     if (!this.currentTurn && this.impl.turnState === "idle") {
       return this.dispatchTurn(message, callbacks);
     }
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       this.queuedTurns.push({
         message,
         callbacks,
-        resolve: resolve8,
+        resolve: resolve9,
         reject
       });
     });
@@ -6220,18 +6307,18 @@ var AgentSessionManager = class {
 };
 
 // src/agent/credential-manager.ts
-var path9 = __toESM(require("path"));
-var fs8 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
+var fs9 = __toESM(require("fs"));
 var os3 = __toESM(require("os"));
-var import_core7 = __toESM(require_dist());
+var import_core9 = __toESM(require_dist());
 var CredentialManager = class {
   // ---------------------------------------------------------------------------
   // Token file reading
   // ---------------------------------------------------------------------------
   readJsonFileIfExists(filePath) {
-    if (!fs8.existsSync(filePath)) return null;
+    if (!fs9.existsSync(filePath)) return null;
     try {
-      const content = fs8.readFileSync(filePath, "utf8");
+      const content = fs9.readFileSync(filePath, "utf8");
       return JSON.parse(content);
     } catch (error) {
       console.warn(`[CredentialManager] Failed to parse JSON at ${filePath}:`, error instanceof Error ? error.message : error);
@@ -6270,12 +6357,12 @@ var CredentialManager = class {
    */
   loadProviderTokens(provider, sessionDir, legacyDir) {
     if (provider === "codex") {
-      const sessionAuthPath = path9.join(sessionDir, "auth.json");
-      const legacyAuthPath = path9.join(legacyDir, "auth.json");
+      const sessionAuthPath = path10.join(sessionDir, "auth.json");
+      const legacyAuthPath = path10.join(legacyDir, "auth.json");
       return this.readCodexTokensFromPath(sessionAuthPath) || this.readCodexTokensFromPath(legacyAuthPath);
     }
-    const sessionCredentialsPath = path9.join(sessionDir, ".credentials.json");
-    const legacyCredentialsPath = path9.join(legacyDir, ".credentials.json");
+    const sessionCredentialsPath = path10.join(sessionDir, ".credentials.json");
+    const legacyCredentialsPath = path10.join(legacyDir, ".credentials.json");
     return this.readClaudeTokensFromPath(sessionCredentialsPath) || this.readClaudeTokensFromPath(legacyCredentialsPath);
   }
   // ---------------------------------------------------------------------------
@@ -6329,7 +6416,7 @@ var CredentialManager = class {
       return { apiUrl: envApiUrl || "https://episoda.dev", token: envToken };
     }
     try {
-      const config = await (0, import_core7.loadConfig)();
+      const config = await (0, import_core9.loadConfig)();
       if (!config?.access_token) {
         return null;
       }
@@ -6390,10 +6477,10 @@ var CredentialManager = class {
   cleanupSessionCredentials(sessionId, provider) {
     const providers = provider ? [provider] : ["claude", "codex"];
     for (const p of providers) {
-      const sessionDir = p === "codex" ? path9.join(os3.homedir(), ".codex", "sessions", sessionId) : path9.join(os3.homedir(), ".claude", "sessions", sessionId);
+      const sessionDir = p === "codex" ? path10.join(os3.homedir(), ".codex", "sessions", sessionId) : path10.join(os3.homedir(), ".claude", "sessions", sessionId);
       try {
-        if (fs8.existsSync(sessionDir)) {
-          fs8.rmSync(sessionDir, { recursive: true, force: true });
+        if (fs9.existsSync(sessionDir)) {
+          fs9.rmSync(sessionDir, { recursive: true, force: true });
           console.log(`[CredentialManager] EP1260: Cleaned up ${p} session credentials: ${sessionDir}`);
         }
       } catch (error) {
@@ -6404,10 +6491,10 @@ var CredentialManager = class {
 };
 
 // src/agent/mcp-server-configurator.ts
-var path10 = __toESM(require("path"));
-var fs9 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
+var fs10 = __toESM(require("fs"));
 var os4 = __toESM(require("os"));
-var import_core8 = __toESM(require_dist());
+var import_core10 = __toESM(require_dist());
 
 // src/utils/github-token.ts
 var INVALID_GITHUB_TOKEN_LITERALS = /* @__PURE__ */ new Set([
@@ -6440,7 +6527,7 @@ var McpServerConfigurator = class {
       return { apiUrl: envApiUrl || "https://episoda.dev", token: envToken, source: "env" };
     }
     try {
-      const config = await (0, import_core8.loadConfig)();
+      const config = await (0, import_core10.loadConfig)();
       if (config?.access_token) {
         return {
           apiUrl: config.api_url || envApiUrl || "https://episoda.dev",
@@ -6514,13 +6601,13 @@ var McpServerConfigurator = class {
   findCodexRequirementsToml(sessionProjectPath) {
     const candidates = [];
     if (sessionProjectPath) {
-      candidates.push(path10.join(sessionProjectPath, ".codex", "requirements.toml"));
+      candidates.push(path11.join(sessionProjectPath, ".codex", "requirements.toml"));
     }
-    const codexHome = process.env.CODEX_HOME || path10.join(os4.homedir(), ".codex");
-    candidates.push(path10.join(codexHome, "requirements.toml"));
+    const codexHome = process.env.CODEX_HOME || path11.join(os4.homedir(), ".codex");
+    candidates.push(path11.join(codexHome, "requirements.toml"));
     candidates.push("/etc/codex/requirements.toml");
     for (const p of candidates) {
-      if (fs9.existsSync(p)) return p;
+      if (fs10.existsSync(p)) return p;
     }
     return null;
   }
@@ -6558,9 +6645,9 @@ var McpServerConfigurator = class {
 };
 
 // src/agent/providers/claude-provider.ts
-var fs10 = __toESM(require("fs"));
+var fs11 = __toESM(require("fs"));
 var os5 = __toESM(require("os"));
-var path11 = __toESM(require("path"));
+var path12 = __toESM(require("path"));
 
 // src/agent/providers/claude-config.ts
 var import_crypto = require("crypto");
@@ -6880,8 +6967,8 @@ var ClaudeProvider = class _ClaudeProvider {
   }
   getSessionDirs(sessionId) {
     return {
-      sessionConfigDir: path11.join(os5.homedir(), ".claude", "sessions", sessionId),
-      legacyConfigDir: path11.join(os5.homedir(), ".claude")
+      sessionConfigDir: path12.join(os5.homedir(), ".claude", "sessions", sessionId),
+      legacyConfigDir: path12.join(os5.homedir(), ".claude")
     };
   }
   async buildSpawnArgs(options) {
@@ -6986,11 +7073,11 @@ ${message}`;
   }
   async writeSessionConfig(options) {
     const { session, dirs, useOAuth, useApiKey } = options;
-    const statsigDir = path11.join(dirs.sessionConfigDir, "statsig");
-    fs10.mkdirSync(statsigDir, { recursive: true });
+    const statsigDir = path12.join(dirs.sessionConfigDir, "statsig");
+    fs11.mkdirSync(statsigDir, { recursive: true });
     console.log(`[ClaudeProvider] EP1260: Created session-specific Claude dir: ${dirs.sessionConfigDir}`);
     if (useOAuth) {
-      const credentialsPath = path11.join(dirs.sessionConfigDir, ".credentials.json");
+      const credentialsPath = path12.join(dirs.sessionConfigDir, ".credentials.json");
       const oauthCredentials = {
         accessToken: session.credentials.oauthToken
       };
@@ -7004,7 +7091,7 @@ ${message}`;
         oauthCredentials.scopes = session.credentials.scopes;
       }
       const credentialsContent = JSON.stringify({ claudeAiOauth: oauthCredentials }, null, 2);
-      fs10.writeFileSync(credentialsPath, credentialsContent, { mode: 384 });
+      fs11.writeFileSync(credentialsPath, credentialsContent, { mode: 384 });
       console.log(`[ClaudeProvider] EP1260: Wrote OAuth credentials to ${credentialsPath}`);
       try {
         const claudeConfig = generateClaudeConfig({
@@ -7016,11 +7103,11 @@ ${message}`;
         if (!hasEvaluations || !hasStableId) {
           throw new Error("Invalid statsig config: missing required files");
         }
-        const settingsPath = path11.join(dirs.sessionConfigDir, "settings.json");
-        fs10.writeFileSync(settingsPath, claudeConfig["settings.json"], { mode: 384 });
+        const settingsPath = path12.join(dirs.sessionConfigDir, "settings.json");
+        fs11.writeFileSync(settingsPath, claudeConfig["settings.json"], { mode: 384 });
         for (const [filename, content] of Object.entries(claudeConfig.statsig)) {
-          const filePath = path11.join(statsigDir, filename);
-          fs10.writeFileSync(filePath, content, { mode: 420 });
+          const filePath = path12.join(statsigDir, filename);
+          fs11.writeFileSync(filePath, content, { mode: 420 });
         }
         console.log("[ClaudeProvider] EP1260: Wrote Claude config files to session directory");
       } catch (configError) {
@@ -7053,9 +7140,9 @@ If changes are needed, explain what needs to be done.`;
 };
 
 // src/agent/providers/codex-provider.ts
-var fs11 = __toESM(require("fs"));
+var fs12 = __toESM(require("fs"));
 var os6 = __toESM(require("os"));
-var path12 = __toESM(require("path"));
+var path13 = __toESM(require("path"));
 var CodexProvider = class {
   constructor(mcpConfigurator) {
     this.mcpConfigurator = mcpConfigurator;
@@ -7070,8 +7157,8 @@ var CodexProvider = class {
   }
   getSessionDirs(sessionId) {
     return {
-      sessionConfigDir: path12.join(os6.homedir(), ".codex", "sessions", sessionId),
-      legacyConfigDir: path12.join(os6.homedir(), ".codex")
+      sessionConfigDir: path13.join(os6.homedir(), ".codex", "sessions", sessionId),
+      legacyConfigDir: path13.join(os6.homedir(), ".codex")
     };
   }
   async buildSpawnArgs(options) {
@@ -7126,7 +7213,7 @@ ${message}`;
   }
   async writeSessionConfig(options) {
     const { session, dirs, useOAuth, useApiKey, mcpAuth, mcpServers } = options;
-    fs11.mkdirSync(dirs.sessionConfigDir, { recursive: true });
+    fs12.mkdirSync(dirs.sessionConfigDir, { recursive: true });
     console.log(`[CodexProvider] EP1260: Created session-specific Codex dir: ${dirs.sessionConfigDir}`);
     if (useOAuth) {
       const codexConfig = generateCodexConfig({
@@ -7136,8 +7223,8 @@ ${message}`;
         accountId: session.credentials.accountId,
         expiresAt: session.credentials.expiresAt
       });
-      const authJsonPath = path12.join(dirs.sessionConfigDir, "auth.json");
-      fs11.writeFileSync(authJsonPath, codexConfig["auth.json"], { mode: 384 });
+      const authJsonPath = path13.join(dirs.sessionConfigDir, "auth.json");
+      fs12.writeFileSync(authJsonPath, codexConfig["auth.json"], { mode: 384 });
       console.log(`[CodexProvider] EP1260: Wrote Codex auth.json to ${authJsonPath}`);
     } else if (useApiKey) {
       console.log("[CodexProvider] EP1133: Using Codex with API key (OPENAI_API_KEY)");
@@ -7145,7 +7232,7 @@ ${message}`;
     if (mcpServers.length > 0) {
       const requirementsPath = this.mcpConfigurator.findCodexRequirementsToml(session.projectPath);
       if (requirementsPath) {
-        const requirementsContent = fs11.readFileSync(requirementsPath, "utf8");
+        const requirementsContent = fs12.readFileSync(requirementsPath, "utf8");
         const allowlist = this.mcpConfigurator.parseRequirementsMcpAllowlist(requirementsContent);
         const allowedIds = Array.from(allowlist.keys());
         if (allowedIds.length > 0) {
@@ -7226,16 +7313,16 @@ ${message}`;
           env
         };
       });
-      const configTomlPath = path12.join(dirs.sessionConfigDir, "config.toml");
+      const configTomlPath = path13.join(dirs.sessionConfigDir, "config.toml");
       const configTomlContent2 = generateCodexMcpConfigToml(codexMcpServers, session.projectPath);
-      fs11.writeFileSync(configTomlPath, configTomlContent2, { mode: 384 });
+      fs12.writeFileSync(configTomlPath, configTomlContent2, { mode: 384 });
       console.log(`[CodexProvider] EP1287: Wrote Codex config.toml at ${configTomlPath} with ${codexMcpServers.length} MCP server(s): ${codexMcpServers.map((s) => s.name).join(", ")}`);
       return;
     }
     const configTomlContent = generateCodexMcpConfigToml([], session.projectPath);
     if (configTomlContent.trim()) {
-      const configTomlPath = path12.join(dirs.sessionConfigDir, "config.toml");
-      fs11.writeFileSync(configTomlPath, configTomlContent, { mode: 420 });
+      const configTomlPath = path13.join(dirs.sessionConfigDir, "config.toml");
+      fs12.writeFileSync(configTomlPath, configTomlContent, { mode: 420 });
       console.log(`[CodexProvider] EP1287: Wrote Codex config.toml (project trust only) at ${configTomlPath}`);
     }
   }
@@ -7534,18 +7621,18 @@ async function startPersistentRuntimeMessage(params) {
 }
 
 // src/agent/agent-process-metrics.ts
-var import_child_process9 = require("child_process");
+var import_child_process10 = require("child_process");
 async function getChildProcessRssMb(pid) {
   if (!pid || pid <= 0) return null;
   try {
-    if (typeof import_child_process9.execFile !== "function") return null;
-    const stdout = await new Promise((resolve8, reject) => {
-      (0, import_child_process9.execFile)("ps", ["-o", "rss=", "-p", String(pid)], { timeout: 1e3 }, (err, out) => {
+    if (typeof import_child_process10.execFile !== "function") return null;
+    const stdout = await new Promise((resolve9, reject) => {
+      (0, import_child_process10.execFile)("ps", ["-o", "rss=", "-p", String(pid)], { timeout: 1e3 }, (err, out) => {
         if (err) {
           reject(err);
           return;
         }
-        resolve8(String(out));
+        resolve9(String(out));
       });
     });
     const kb = Number(String(stdout).trim());
@@ -7557,18 +7644,18 @@ async function getChildProcessRssMb(pid) {
 }
 
 // src/agent/agent-pid-utils.ts
-var fs12 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
+var fs13 = __toESM(require("fs"));
+var path14 = __toESM(require("path"));
 async function cleanupOrphanedAgentProcesses(pidDir) {
   let cleaned = 0;
-  if (!fs12.existsSync(pidDir)) {
+  if (!fs13.existsSync(pidDir)) {
     return { cleaned };
   }
-  const pidFiles = fs12.readdirSync(pidDir).filter((f) => f.endsWith(".pid"));
+  const pidFiles = fs13.readdirSync(pidDir).filter((f) => f.endsWith(".pid"));
   for (const pidFile of pidFiles) {
-    const pidPath = path13.join(pidDir, pidFile);
+    const pidPath = path14.join(pidDir, pidFile);
     try {
-      const pidStr = fs12.readFileSync(pidPath, "utf-8").trim();
+      const pidStr = fs13.readFileSync(pidPath, "utf-8").trim();
       const pid = parseInt(pidStr, 10);
       if (!isNaN(pid)) {
         try {
@@ -7579,7 +7666,7 @@ async function cleanupOrphanedAgentProcesses(pidDir) {
         } catch {
         }
       }
-      fs12.unlinkSync(pidPath);
+      fs13.unlinkSync(pidPath);
     } catch (error) {
       console.warn(`[AgentManager] Error cleaning PID file ${pidFile}:`, error);
     }
@@ -7590,14 +7677,14 @@ async function cleanupOrphanedAgentProcesses(pidDir) {
   return { cleaned };
 }
 function writeAgentPidFile(pidDir, sessionId, pid) {
-  const pidPath = path13.join(pidDir, `${sessionId}.pid`);
-  fs12.writeFileSync(pidPath, pid.toString());
+  const pidPath = path14.join(pidDir, `${sessionId}.pid`);
+  fs13.writeFileSync(pidPath, pid.toString());
 }
 function removeAgentPidFile(pidDir, sessionId) {
-  const pidPath = path13.join(pidDir, `${sessionId}.pid`);
+  const pidPath = path14.join(pidDir, `${sessionId}.pid`);
   try {
-    if (fs12.existsSync(pidPath)) {
-      fs12.unlinkSync(pidPath);
+    if (fs13.existsSync(pidPath)) {
+      fs13.unlinkSync(pidPath);
     }
   } catch {
   }
@@ -7617,7 +7704,7 @@ var AgentControlPlane = class {
     this.initialized = false;
     // EP1133: Lock for config file writes to prevent race conditions
     this.configWriteLock = Promise.resolve();
-    this.pidDir = path14.join(os7.homedir(), ".episoda", "agent-pids");
+    this.pidDir = path15.join(os7.homedir(), ".episoda", "agent-pids");
     this.runtimeManager = new AgentSessionManager(this);
     this.credentialManager = new CredentialManager();
     this.mcpConfigurator = new McpServerConfigurator();
@@ -7648,8 +7735,8 @@ var AgentControlPlane = class {
   async withConfigLock(fn) {
     const previousLock = this.configWriteLock;
     let releaseLock;
-    this.configWriteLock = new Promise((resolve8) => {
-      releaseLock = resolve8;
+    this.configWriteLock = new Promise((resolve9) => {
+      releaseLock = resolve9;
     });
     try {
       await previousLock;
@@ -7685,8 +7772,8 @@ var AgentControlPlane = class {
       return;
     }
     console.log("[AgentManager] Initializing...");
-    if (!fs13.existsSync(this.pidDir)) {
-      fs13.mkdirSync(this.pidDir, { recursive: true });
+    if (!fs14.existsSync(this.pidDir)) {
+      fs14.mkdirSync(this.pidDir, { recursive: true });
     }
     await this.cleanupOrphanedProcesses();
     for (const providerImpl of Object.values(this.providers)) {
@@ -7761,7 +7848,7 @@ var AgentControlPlane = class {
     let effectiveWorkspaceId = requestedWorkspaceId;
     if (!effectiveWorkspaceId) {
       try {
-        const config = await (0, import_core9.loadConfig)();
+        const config = await (0, import_core11.loadConfig)();
         effectiveWorkspaceId = normalizeWorkspaceId(config?.workspace_id);
       } catch (error) {
         console.warn("[AgentManager] EP1357: Unable to resolve workspaceId from local config:", error instanceof Error ? error.message : error);
@@ -8203,12 +8290,12 @@ var AgentCommandQueue = class {
     const now = Date.now();
     let cleaned = 0;
     for (const [sessionId, queue] of this.pendingCommands) {
-      const valid3 = queue.filter((pending) => now - pending.receivedAt <= this.commandTimeout);
-      cleaned += queue.length - valid3.length;
-      if (valid3.length === 0) {
+      const valid2 = queue.filter((pending) => now - pending.receivedAt <= this.commandTimeout);
+      cleaned += queue.length - valid2.length;
+      if (valid2.length === 0) {
         this.pendingCommands.delete(sessionId);
       } else {
-        this.pendingCommands.set(sessionId, valid3);
+        this.pendingCommands.set(sessionId, valid2);
       }
     }
     if (cleaned > 0) {
@@ -8270,10 +8357,10 @@ var AgentCommandQueue = class {
 };
 
 // src/daemon/worktree-manager.ts
-var fs14 = __toESM(require("fs"));
-var path15 = __toESM(require("path"));
-var import_child_process10 = require("child_process");
-var import_core10 = __toESM(require_dist());
+var fs15 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
+var import_child_process11 = require("child_process");
+var import_core12 = __toESM(require_dist());
 function validateModuleUid(moduleUid) {
   if (!moduleUid || typeof moduleUid !== "string" || !moduleUid.trim()) {
     return false;
@@ -8308,7 +8395,7 @@ function isValidDefaultBranchName(name) {
   return true;
 }
 function runGit(args, cwd, timeoutMs) {
-  const res = (0, import_child_process10.spawnSync)("git", args, {
+  const res = (0, import_child_process11.spawnSync)("git", args, {
     cwd,
     encoding: "utf-8",
     timeout: timeoutMs,
@@ -8328,9 +8415,9 @@ var WorktreeManager = class _WorktreeManager {
     // ============================================================
     this.lockPath = "";
     this.projectRoot = projectRoot;
-    this.bareRepoPath = path15.join(projectRoot, ".bare");
-    this.configPath = path15.join(projectRoot, ".episoda", "config.json");
-    this.gitExecutor = new import_core10.GitExecutor();
+    this.bareRepoPath = path16.join(projectRoot, ".bare");
+    this.configPath = path16.join(projectRoot, ".episoda", "config.json");
+    this.gitExecutor = new import_core12.GitExecutor();
   }
   /**
    * Initialize worktree manager from existing project root
@@ -8340,13 +8427,13 @@ var WorktreeManager = class _WorktreeManager {
    */
   async initialize() {
     const debug = process.env.EPISODA_DEBUG === "1" || process.env.GIT_CREDENTIAL_EPISODA_DEBUG === "1";
-    if (!fs14.existsSync(this.bareRepoPath)) {
+    if (!fs15.existsSync(this.bareRepoPath)) {
       if (debug) {
         console.log(`[WorktreeManager] initialize: .bare not found at ${this.bareRepoPath}`);
       }
       return false;
     }
-    if (!fs14.existsSync(this.configPath)) {
+    if (!fs15.existsSync(this.configPath)) {
       if (debug) {
         console.log(`[WorktreeManager] initialize: config not found at ${this.configPath}`);
       }
@@ -8407,8 +8494,8 @@ var WorktreeManager = class _WorktreeManager {
    */
   static async createProject(projectRoot, repoUrl, projectId, workspaceSlug, projectSlug) {
     const manager = new _WorktreeManager(projectRoot);
-    const episodaDir = path15.join(projectRoot, ".episoda");
-    fs14.mkdirSync(episodaDir, { recursive: true });
+    const episodaDir = path16.join(projectRoot, ".episoda");
+    fs15.mkdirSync(episodaDir, { recursive: true });
     const cloneResult = await manager.gitExecutor.execute({
       action: "clone_bare",
       url: repoUrl,
@@ -8472,8 +8559,8 @@ var WorktreeManager = class _WorktreeManager {
         error: `Invalid module UID: "${moduleUid}" - contains disallowed characters`
       };
     }
-    const worktreePath = path15.join(this.projectRoot, moduleUid);
-    const normalizedWorktreePath = path15.resolve(worktreePath);
+    const worktreePath = path16.join(this.projectRoot, moduleUid);
+    const normalizedWorktreePath = path16.resolve(worktreePath);
     const lockAcquired = await this.acquireLock();
     if (!lockAcquired) {
       return {
@@ -8490,12 +8577,12 @@ var WorktreeManager = class _WorktreeManager {
           worktreeInfo: existing
         };
       }
-      if (fs14.existsSync(worktreePath)) {
+      if (fs15.existsSync(worktreePath)) {
         const listResult = await this.gitExecutor.execute({
           action: "worktree_list"
         }, { cwd: this.bareRepoPath });
         const worktrees = listResult.details?.worktrees || [];
-        const matching = worktrees.find((w) => path15.resolve(w.path) === normalizedWorktreePath);
+        const matching = worktrees.find((w) => path16.resolve(w.path) === normalizedWorktreePath);
         if (matching) {
           const adoptedWorktree = {
             moduleUid,
@@ -8523,7 +8610,7 @@ var WorktreeManager = class _WorktreeManager {
           };
         }
         console.warn(`[WorktreeManager] EP1265: Removing stale worktree path at ${worktreePath}`);
-        fs14.rmSync(worktreePath, { recursive: true, force: true });
+        fs15.rmSync(worktreePath, { recursive: true, force: true });
         const pruneResult = await this.gitExecutor.execute({
           action: "worktree_prune"
         }, { cwd: this.bareRepoPath });
@@ -8718,8 +8805,8 @@ var WorktreeManager = class _WorktreeManager {
     const allWorktrees = this.listWorktrees();
     const activeSet = new Set(activeModuleUids);
     const orphaned = allWorktrees.filter((w) => !activeSet.has(w.moduleUid));
-    const valid3 = allWorktrees.filter((w) => activeSet.has(w.moduleUid));
-    return { orphaned, valid: valid3 };
+    const valid2 = allWorktrees.filter((w) => activeSet.has(w.moduleUid));
+    return { orphaned, valid: valid2 };
   }
   /**
    * Update last accessed timestamp for a worktree
@@ -8743,7 +8830,7 @@ var WorktreeManager = class _WorktreeManager {
     let prunedCount = 0;
     await this.updateConfigSafe((config) => {
       const initialCount = config.worktrees.length;
-      config.worktrees = config.worktrees.filter((w) => fs14.existsSync(w.worktreePath));
+      config.worktrees = config.worktrees.filter((w) => fs15.existsSync(w.worktreePath));
       prunedCount = initialCount - config.worktrees.length;
       return config;
     });
@@ -8754,7 +8841,7 @@ var WorktreeManager = class _WorktreeManager {
    */
   async validateWorktrees() {
     const config = this.readConfig();
-    const valid3 = [];
+    const valid2 = [];
     const stale = [];
     const orphaned = [];
     const listResult = await this.gitExecutor.execute({
@@ -8765,7 +8852,7 @@ var WorktreeManager = class _WorktreeManager {
     );
     for (const worktree of config?.worktrees || []) {
       if (actualWorktrees.has(worktree.worktreePath)) {
-        valid3.push(worktree);
+        valid2.push(worktree);
         actualWorktrees.delete(worktree.worktreePath);
       } else {
         stale.push(worktree);
@@ -8776,7 +8863,7 @@ var WorktreeManager = class _WorktreeManager {
         orphaned.push(wpath);
       }
     }
-    return { valid: valid3, stale, orphaned };
+    return { valid: valid2, stale, orphaned };
   }
   /**
    * EP1190: Clean up non-module worktrees (like 'main')
@@ -8793,7 +8880,7 @@ var WorktreeManager = class _WorktreeManager {
     try {
       const validation = await this.validateWorktrees();
       for (const orphanPath of validation.orphaned) {
-        const dirName = path15.basename(orphanPath);
+        const dirName = path16.basename(orphanPath);
         const isModuleWorktree = /^EP\d+$/.test(dirName);
         if (!isModuleWorktree) {
           console.log(`[WorktreeManager] EP1190: Found non-module worktree: ${dirName}`);
@@ -8866,25 +8953,25 @@ var WorktreeManager = class _WorktreeManager {
     const retryInterval = 50;
     while (Date.now() - startTime < timeoutMs) {
       try {
-        fs14.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+        fs15.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
         return true;
       } catch (err) {
         if (err.code === "EEXIST") {
           try {
-            const stats = fs14.statSync(lockPath);
+            const stats = fs15.statSync(lockPath);
             const lockAge = Date.now() - stats.mtimeMs;
             if (lockAge > 3e4) {
               try {
-                const lockContent = fs14.readFileSync(lockPath, "utf-8").trim();
+                const lockContent = fs15.readFileSync(lockPath, "utf-8").trim();
                 const lockPid = parseInt(lockContent, 10);
                 if (!isNaN(lockPid) && this.isProcessRunning(lockPid)) {
-                  await new Promise((resolve8) => setTimeout(resolve8, retryInterval));
+                  await new Promise((resolve9) => setTimeout(resolve9, retryInterval));
                   continue;
                 }
               } catch {
               }
               try {
-                fs14.unlinkSync(lockPath);
+                fs15.unlinkSync(lockPath);
               } catch {
               }
               continue;
@@ -8892,7 +8979,7 @@ var WorktreeManager = class _WorktreeManager {
           } catch {
             continue;
           }
-          await new Promise((resolve8) => setTimeout(resolve8, retryInterval));
+          await new Promise((resolve9) => setTimeout(resolve9, retryInterval));
           continue;
         }
         throw err;
@@ -8905,7 +8992,7 @@ var WorktreeManager = class _WorktreeManager {
    */
   releaseLock() {
     try {
-      fs14.unlinkSync(this.getLockPath());
+      fs15.unlinkSync(this.getLockPath());
     } catch {
     }
   }
@@ -8929,11 +9016,11 @@ var WorktreeManager = class _WorktreeManager {
       // Turborepo cache
     ];
     for (const cacheDir of cacheDirs) {
-      const cachePath = path15.join(worktreePath, cacheDir);
+      const cachePath = path16.join(worktreePath, cacheDir);
       try {
-        if (fs14.existsSync(cachePath)) {
+        if (fs15.existsSync(cachePath)) {
           console.log(`[WorktreeManager] EP1070: Cleaning build cache: ${cacheDir}`);
-          fs14.rmSync(cachePath, { recursive: true, force: true });
+          fs15.rmSync(cachePath, { recursive: true, force: true });
         }
       } catch (error) {
         console.warn(`[WorktreeManager] EP1070: Failed to clean ${cacheDir} (non-blocking):`, error.message);
@@ -8942,10 +9029,10 @@ var WorktreeManager = class _WorktreeManager {
   }
   readConfig() {
     try {
-      if (!fs14.existsSync(this.configPath)) {
+      if (!fs15.existsSync(this.configPath)) {
         return null;
       }
-      const content = fs14.readFileSync(this.configPath, "utf-8");
+      const content = fs15.readFileSync(this.configPath, "utf-8");
       return JSON.parse(content);
     } catch (error) {
       if (error instanceof SyntaxError) {
@@ -8959,11 +9046,11 @@ var WorktreeManager = class _WorktreeManager {
   }
   writeConfig(config) {
     try {
-      const dir = path15.dirname(this.configPath);
-      if (!fs14.existsSync(dir)) {
-        fs14.mkdirSync(dir, { recursive: true });
+      const dir = path16.dirname(this.configPath);
+      if (!fs15.existsSync(dir)) {
+        fs15.mkdirSync(dir, { recursive: true });
       }
-      fs14.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf-8");
+      fs15.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf-8");
     } catch (error) {
       console.error("[WorktreeManager] Failed to write config:", error);
       throw error;
@@ -9045,14 +9132,14 @@ var WorktreeManager = class _WorktreeManager {
     }
     try {
       for (const file of files) {
-        const srcPath = path15.join(mainWorktree.worktreePath, file);
-        const destPath = path15.join(worktree.worktreePath, file);
-        if (fs14.existsSync(srcPath)) {
-          const destDir = path15.dirname(destPath);
-          if (!fs14.existsSync(destDir)) {
-            fs14.mkdirSync(destDir, { recursive: true });
+        const srcPath = path16.join(mainWorktree.worktreePath, file);
+        const destPath = path16.join(worktree.worktreePath, file);
+        if (fs15.existsSync(srcPath)) {
+          const destDir = path16.dirname(destPath);
+          if (!fs15.existsSync(destDir)) {
+            fs15.mkdirSync(destDir, { recursive: true });
           }
-          fs14.copyFileSync(srcPath, destPath);
+          fs15.copyFileSync(srcPath, destPath);
           console.log(`[WorktreeManager] EP964: Copied ${file} to ${moduleUid} (deprecated)`);
         } else {
           console.log(`[WorktreeManager] EP964: Skipped ${file} (not found in main)`);
@@ -9141,10 +9228,10 @@ function getEpisodaRoot() {
   if (process.env.EPISODA_MODE === "cloud") {
     return process.env.HOME || "/home/episoda";
   }
-  return path15.join(require("os").homedir(), "episoda");
+  return path16.join(require("os").homedir(), "episoda");
 }
 function getProjectPath(workspaceSlug, projectSlug) {
-  return path15.join(getEpisodaRoot(), workspaceSlug, projectSlug);
+  return path16.join(getEpisodaRoot(), workspaceSlug, projectSlug);
 }
 async function isWorktreeProject(projectRoot) {
   const debug = process.env.EPISODA_DEBUG === "1" || process.env.GIT_CREDENTIAL_EPISODA_DEBUG === "1";
@@ -9159,7 +9246,7 @@ async function isWorktreeProject(projectRoot) {
   return result;
 }
 async function findProjectRoot(startPath) {
-  let current = path15.resolve(startPath);
+  let current = path16.resolve(startPath);
   const episodaRoot = getEpisodaRoot();
   const debug = process.env.EPISODA_DEBUG === "1" || process.env.GIT_CREDENTIAL_EPISODA_DEBUG === "1";
   if (debug) {
@@ -9172,14 +9259,14 @@ async function findProjectRoot(startPath) {
     return null;
   }
   for (let i = 0; i < 10; i++) {
-    const bareDir = path15.join(current, ".bare");
-    const episodaDir = path15.join(current, ".episoda");
+    const bareDir = path16.join(current, ".bare");
+    const episodaDir = path16.join(current, ".episoda");
     if (debug) {
-      const bareExists = fs14.existsSync(bareDir);
-      const episodaExists = fs14.existsSync(episodaDir);
+      const bareExists = fs15.existsSync(bareDir);
+      const episodaExists = fs15.existsSync(episodaDir);
       console.log(`[WorktreeManager] findProjectRoot: checking ${current} (.bare=${bareExists}, .episoda=${episodaExists})`);
     }
-    if (fs14.existsSync(bareDir) && fs14.existsSync(episodaDir)) {
+    if (fs15.existsSync(bareDir) && fs15.existsSync(episodaDir)) {
       if (await isWorktreeProject(current)) {
         if (debug) {
           console.log(`[WorktreeManager] findProjectRoot: found valid project at ${current}`);
@@ -9187,7 +9274,7 @@ async function findProjectRoot(startPath) {
         return current;
       }
     }
-    const parent = path15.dirname(current);
+    const parent = path16.dirname(current);
     if (parent === current) {
       break;
     }
@@ -9200,7 +9287,7 @@ async function findProjectRoot(startPath) {
 }
 
 // src/daemon/agent-command-routing.ts
-var fs15 = __toESM(require("fs"));
+var fs16 = __toESM(require("fs"));
 function shouldQueueAgentCommandForRetry(action) {
   return action === "start" || action === "message";
 }
@@ -9214,7 +9301,7 @@ async function resolveAgentWorkingDirectory(options) {
     getWorktreeInfoForModule: getWorktreeInfoForModule2,
     pathExists = async (candidatePath) => {
       try {
-        await fs15.promises.access(candidatePath);
+        await fs16.promises.access(candidatePath);
         return true;
       } catch {
         return false;
@@ -9248,8 +9335,8 @@ async function resolveAgentWorkingDirectory(options) {
 }
 
 // src/utils/env-setup.ts
-var fs16 = __toESM(require("fs"));
-var path16 = __toESM(require("path"));
+var fs17 = __toESM(require("fs"));
+var path17 = __toESM(require("path"));
 async function fetchEnvVars(apiUrl, accessToken) {
   try {
     const url = `${apiUrl}/api/cli/env-vars`;
@@ -9284,16 +9371,16 @@ function writeEnvFile(targetPath, envVars) {
     }
     return `${key}=${value}`;
   }).join("\n") + "\n";
-  const envPath = path16.join(targetPath, ".env");
-  fs16.writeFileSync(envPath, envContent, { mode: 384 });
+  const envPath = path17.join(targetPath, ".env");
+  fs17.writeFileSync(envPath, envContent, { mode: 384 });
   console.log(`[env-setup] Wrote ${Object.keys(envVars).length} env vars to ${envPath}`);
 }
 
 // src/utils/worktree.ts
-var path17 = __toESM(require("path"));
-var fs17 = __toESM(require("fs"));
+var path18 = __toESM(require("path"));
+var fs18 = __toESM(require("fs"));
 var os8 = __toESM(require("os"));
-var import_core11 = __toESM(require_dist());
+var import_core13 = __toESM(require_dist());
 function getEpisodaRoot2() {
   if (process.env.EPISODA_ROOT) {
     return process.env.EPISODA_ROOT;
@@ -9301,19 +9388,19 @@ function getEpisodaRoot2() {
   if (process.env.EPISODA_MODE === "cloud") {
     return process.env.HOME || "/home/episoda";
   }
-  return path17.join(os8.homedir(), "episoda");
+  return path18.join(os8.homedir(), "episoda");
 }
 function getWorktreeInfo(moduleUid, workspaceSlug, projectSlug) {
   const root = getEpisodaRoot2();
-  const worktreePath = path17.join(root, workspaceSlug, projectSlug, moduleUid);
+  const worktreePath = path18.join(root, workspaceSlug, projectSlug, moduleUid);
   return {
     path: worktreePath,
-    exists: fs17.existsSync(worktreePath),
+    exists: fs18.existsSync(worktreePath),
     moduleUid
   };
 }
 async function getWorktreeInfoForModule(moduleUid) {
-  const config = await (0, import_core11.loadConfig)();
+  const config = await (0, import_core13.loadConfig)();
   if (config?.workspace_slug && config?.project_slug) {
     return getWorktreeInfo(moduleUid, config.workspace_slug, config.project_slug);
   }
@@ -9322,15 +9409,15 @@ async function getWorktreeInfoForModule(moduleUid) {
     return null;
   }
   const root = getEpisodaRoot2();
-  const workspaceRoot = path17.join(root, config.workspace_slug);
+  const workspaceRoot = path18.join(root, config.workspace_slug);
   try {
-    const entries = fs17.readdirSync(workspaceRoot, { withFileTypes: true });
+    const entries = fs18.readdirSync(workspaceRoot, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) {
         continue;
       }
-      const worktreePath = path17.join(workspaceRoot, entry.name, moduleUid);
-      if (fs17.existsSync(worktreePath)) {
+      const worktreePath = path18.join(workspaceRoot, entry.name, moduleUid);
+      if (fs18.existsSync(worktreePath)) {
         return {
           path: worktreePath,
           exists: true,
@@ -9347,21 +9434,21 @@ async function getWorktreeInfoForModule(moduleUid) {
 }
 
 // src/utils/port-allocator.ts
-var fs18 = __toESM(require("fs"));
-var path18 = __toESM(require("path"));
+var fs19 = __toESM(require("fs"));
+var path19 = __toESM(require("path"));
 var os9 = __toESM(require("os"));
 var PORT_RANGE_START = 3100;
 var PORT_RANGE_END = 3199;
 var PORT_WARNING_THRESHOLD = 80;
-var PORTS_FILE = path18.join(os9.homedir(), ".episoda", "ports.json");
+var PORTS_FILE = path19.join(os9.homedir(), ".episoda", "ports.json");
 var portAssignments = /* @__PURE__ */ new Map();
 var initialized = false;
 function loadFromDisk() {
   if (initialized) return;
   initialized = true;
   try {
-    if (fs18.existsSync(PORTS_FILE)) {
-      const content = fs18.readFileSync(PORTS_FILE, "utf8");
+    if (fs19.existsSync(PORTS_FILE)) {
+      const content = fs19.readFileSync(PORTS_FILE, "utf8");
       const data = JSON.parse(content);
       for (const [moduleUid, port] of Object.entries(data)) {
         if (typeof port === "number" && port >= PORT_RANGE_START && port <= PORT_RANGE_END) {
@@ -9378,15 +9465,15 @@ function loadFromDisk() {
 }
 function saveToDisk() {
   try {
-    const dir = path18.dirname(PORTS_FILE);
-    if (!fs18.existsSync(dir)) {
-      fs18.mkdirSync(dir, { recursive: true });
+    const dir = path19.dirname(PORTS_FILE);
+    if (!fs19.existsSync(dir)) {
+      fs19.mkdirSync(dir, { recursive: true });
     }
     const data = {};
     for (const [moduleUid, port] of portAssignments) {
       data[moduleUid] = port;
     }
-    fs18.writeFileSync(PORTS_FILE, JSON.stringify(data, null, 2), "utf8");
+    fs19.writeFileSync(PORTS_FILE, JSON.stringify(data, null, 2), "utf8");
   } catch (error) {
     console.warn(`[PortAllocator] EP1042: Failed to save ports.json:`, error);
   }
@@ -9456,21 +9543,21 @@ function reconcileWithRegistry(activeModules) {
 }
 
 // src/utils/ws-port-allocator.ts
-var fs19 = __toESM(require("fs"));
-var path19 = __toESM(require("path"));
+var fs20 = __toESM(require("fs"));
+var path20 = __toESM(require("path"));
 var os10 = __toESM(require("os"));
 var WS_PORT_RANGE_START = 3200;
 var WS_PORT_RANGE_END = 3299;
 var WS_PORT_WARNING_THRESHOLD = 80;
-var WS_PORTS_FILE = path19.join(os10.homedir(), ".episoda", "ws-ports.json");
+var WS_PORTS_FILE = path20.join(os10.homedir(), ".episoda", "ws-ports.json");
 var wsPortAssignments = /* @__PURE__ */ new Map();
 var initialized2 = false;
 function loadFromDisk2() {
   if (initialized2) return;
   initialized2 = true;
   try {
-    if (!fs19.existsSync(WS_PORTS_FILE)) return;
-    const content = fs19.readFileSync(WS_PORTS_FILE, "utf8");
+    if (!fs20.existsSync(WS_PORTS_FILE)) return;
+    const content = fs20.readFileSync(WS_PORTS_FILE, "utf8");
     const data = JSON.parse(content);
     for (const [moduleUid, port] of Object.entries(data)) {
       if (typeof port === "number" && port >= WS_PORT_RANGE_START && port <= WS_PORT_RANGE_END) {
@@ -9486,15 +9573,15 @@ function loadFromDisk2() {
 }
 function saveToDisk2() {
   try {
-    const dir = path19.dirname(WS_PORTS_FILE);
-    if (!fs19.existsSync(dir)) {
-      fs19.mkdirSync(dir, { recursive: true });
+    const dir = path20.dirname(WS_PORTS_FILE);
+    if (!fs20.existsSync(dir)) {
+      fs20.mkdirSync(dir, { recursive: true });
     }
     const data = {};
     for (const [moduleUid, port] of wsPortAssignments) {
       data[moduleUid] = port;
     }
-    fs19.writeFileSync(WS_PORTS_FILE, JSON.stringify(data, null, 2), "utf8");
+    fs20.writeFileSync(WS_PORTS_FILE, JSON.stringify(data, null, 2), "utf8");
   } catch (error) {
     console.warn("[WsPortAllocator] EP1406: Failed to save ws-ports.json:", error);
   }
@@ -9584,61 +9671,61 @@ function clearAllWsPorts() {
 }
 
 // src/framework-detector.ts
-var fs20 = __toESM(require("fs"));
-var path20 = __toESM(require("path"));
+var fs21 = __toESM(require("fs"));
+var path21 = __toESM(require("path"));
 function getInstallCommand(cwd) {
-  if (fs20.existsSync(path20.join(cwd, "bun.lockb"))) {
+  if (fs21.existsSync(path21.join(cwd, "bun.lockb"))) {
     return {
       command: ["bun", "install"],
       description: "Installing dependencies with bun",
       detectedFrom: "bun.lockb"
     };
   }
-  if (fs20.existsSync(path20.join(cwd, "pnpm-lock.yaml"))) {
+  if (fs21.existsSync(path21.join(cwd, "pnpm-lock.yaml"))) {
     return {
       command: ["pnpm", "install"],
       description: "Installing dependencies with pnpm",
       detectedFrom: "pnpm-lock.yaml"
     };
   }
-  if (fs20.existsSync(path20.join(cwd, "yarn.lock"))) {
+  if (fs21.existsSync(path21.join(cwd, "yarn.lock"))) {
     return {
       command: ["yarn", "install"],
       description: "Installing dependencies with yarn",
       detectedFrom: "yarn.lock"
     };
   }
-  if (fs20.existsSync(path20.join(cwd, "package-lock.json"))) {
+  if (fs21.existsSync(path21.join(cwd, "package-lock.json"))) {
     return {
       command: ["npm", "ci"],
       description: "Installing dependencies with npm ci",
       detectedFrom: "package-lock.json"
     };
   }
-  if (fs20.existsSync(path20.join(cwd, "package.json"))) {
+  if (fs21.existsSync(path21.join(cwd, "package.json"))) {
     return {
       command: ["npm", "install"],
       description: "Installing dependencies with npm",
       detectedFrom: "package.json"
     };
   }
-  if (fs20.existsSync(path20.join(cwd, "Pipfile.lock")) || fs20.existsSync(path20.join(cwd, "Pipfile"))) {
+  if (fs21.existsSync(path21.join(cwd, "Pipfile.lock")) || fs21.existsSync(path21.join(cwd, "Pipfile"))) {
     return {
       command: ["pipenv", "install"],
       description: "Installing dependencies with pipenv",
-      detectedFrom: fs20.existsSync(path20.join(cwd, "Pipfile.lock")) ? "Pipfile.lock" : "Pipfile"
+      detectedFrom: fs21.existsSync(path21.join(cwd, "Pipfile.lock")) ? "Pipfile.lock" : "Pipfile"
     };
   }
-  if (fs20.existsSync(path20.join(cwd, "poetry.lock"))) {
+  if (fs21.existsSync(path21.join(cwd, "poetry.lock"))) {
     return {
       command: ["poetry", "install"],
       description: "Installing dependencies with poetry",
       detectedFrom: "poetry.lock"
     };
   }
-  if (fs20.existsSync(path20.join(cwd, "pyproject.toml"))) {
-    const pyprojectPath = path20.join(cwd, "pyproject.toml");
-    const content = fs20.readFileSync(pyprojectPath, "utf-8");
+  if (fs21.existsSync(path21.join(cwd, "pyproject.toml"))) {
+    const pyprojectPath = path21.join(cwd, "pyproject.toml");
+    const content = fs21.readFileSync(pyprojectPath, "utf-8");
     if (content.includes("[tool.poetry]")) {
       return {
         command: ["poetry", "install"],
@@ -9647,32 +9734,32 @@ function getInstallCommand(cwd) {
       };
     }
   }
-  if (fs20.existsSync(path20.join(cwd, "requirements.txt"))) {
+  if (fs21.existsSync(path21.join(cwd, "requirements.txt"))) {
     return {
       command: ["pip", "install", "-r", "requirements.txt"],
       description: "Installing dependencies with pip",
       detectedFrom: "requirements.txt"
     };
   }
-  if (fs20.existsSync(path20.join(cwd, "Gemfile.lock")) || fs20.existsSync(path20.join(cwd, "Gemfile"))) {
+  if (fs21.existsSync(path21.join(cwd, "Gemfile.lock")) || fs21.existsSync(path21.join(cwd, "Gemfile"))) {
     return {
       command: ["bundle", "install"],
       description: "Installing dependencies with bundler",
-      detectedFrom: fs20.existsSync(path20.join(cwd, "Gemfile.lock")) ? "Gemfile.lock" : "Gemfile"
+      detectedFrom: fs21.existsSync(path21.join(cwd, "Gemfile.lock")) ? "Gemfile.lock" : "Gemfile"
     };
   }
-  if (fs20.existsSync(path20.join(cwd, "go.sum")) || fs20.existsSync(path20.join(cwd, "go.mod"))) {
+  if (fs21.existsSync(path21.join(cwd, "go.sum")) || fs21.existsSync(path21.join(cwd, "go.mod"))) {
     return {
       command: ["go", "mod", "download"],
       description: "Downloading Go modules",
-      detectedFrom: fs20.existsSync(path20.join(cwd, "go.sum")) ? "go.sum" : "go.mod"
+      detectedFrom: fs21.existsSync(path21.join(cwd, "go.sum")) ? "go.sum" : "go.mod"
     };
   }
-  if (fs20.existsSync(path20.join(cwd, "Cargo.lock")) || fs20.existsSync(path20.join(cwd, "Cargo.toml"))) {
+  if (fs21.existsSync(path21.join(cwd, "Cargo.lock")) || fs21.existsSync(path21.join(cwd, "Cargo.toml"))) {
     return {
       command: ["cargo", "build"],
       description: "Building Rust project (downloads dependencies)",
-      detectedFrom: fs20.existsSync(path20.join(cwd, "Cargo.lock")) ? "Cargo.lock" : "Cargo.toml"
+      detectedFrom: fs21.existsSync(path21.join(cwd, "Cargo.lock")) ? "Cargo.lock" : "Cargo.toml"
     };
   }
   return null;
@@ -9683,34 +9770,34 @@ var fs35 = __toESM(require("fs"));
 var http2 = __toESM(require("http"));
 var os16 = __toESM(require("os"));
 var path37 = __toESM(require("path"));
-var import_child_process19 = require("child_process");
+var import_child_process18 = require("child_process");
 
 // src/daemon/ipc-router.ts
 var os15 = __toESM(require("os"));
-var import_core15 = __toESM(require_dist());
+var import_core17 = __toESM(require_dist());
 
 // src/daemon/handlers/file-handlers.ts
-var fs22 = __toESM(require("fs"));
-var path22 = __toESM(require("path"));
+var fs23 = __toESM(require("fs"));
+var path23 = __toESM(require("path"));
 var readline = __toESM(require("readline"));
 
 // src/daemon/permissions/path-classifier.ts
-var path21 = __toESM(require("path"));
-var fs21 = __toESM(require("fs"));
+var path22 = __toESM(require("path"));
+var fs22 = __toESM(require("fs"));
 function classifyPath(targetPath, options) {
   const { workspaceRoot, projectRoot } = options;
-  const normalizedWorkspace = path21.resolve(workspaceRoot);
-  const normalizedProject = path21.resolve(projectRoot);
-  const resolvedPath = path21.isAbsolute(targetPath) ? path21.resolve(targetPath) : path21.resolve(projectRoot, targetPath);
-  const artifactsDir = path21.join(normalizedWorkspace, "artifacts");
-  if (resolvedPath.startsWith(artifactsDir + path21.sep) || resolvedPath === artifactsDir) {
+  const normalizedWorkspace = path22.resolve(workspaceRoot);
+  const normalizedProject = path22.resolve(projectRoot);
+  const resolvedPath = path22.isAbsolute(targetPath) ? path22.resolve(targetPath) : path22.resolve(projectRoot, targetPath);
+  const artifactsDir = path22.join(normalizedWorkspace, "artifacts");
+  if (resolvedPath.startsWith(artifactsDir + path22.sep) || resolvedPath === artifactsDir) {
     return {
       classification: "artifacts",
       resolvedPath
     };
   }
-  if (!resolvedPath.startsWith(normalizedProject + path21.sep) && resolvedPath !== normalizedProject) {
-    if (resolvedPath.startsWith(normalizedWorkspace + path21.sep)) {
+  if (!resolvedPath.startsWith(normalizedProject + path22.sep) && resolvedPath !== normalizedProject) {
+    if (resolvedPath.startsWith(normalizedWorkspace + path22.sep)) {
       return {
         classification: "unknown",
         resolvedPath
@@ -9721,8 +9808,8 @@ function classifyPath(targetPath, options) {
       resolvedPath
     };
   }
-  const relativePath = path21.relative(normalizedProject, resolvedPath);
-  const pathParts = relativePath.split(path21.sep);
+  const relativePath = path22.relative(normalizedProject, resolvedPath);
+  const pathParts = relativePath.split(path22.sep);
   if (pathParts[0] === ".bare") {
     return {
       classification: "bare_repo",
@@ -9737,9 +9824,9 @@ function classifyPath(targetPath, options) {
   }
   const firstPart = pathParts[0];
   if (firstPart && isModuleUidPattern(firstPart)) {
-    const worktreeDir = path21.join(normalizedProject, firstPart);
-    const gitFile = path21.join(worktreeDir, ".git");
-    const worktreeExists = fs21.existsSync(gitFile) && fs21.statSync(gitFile).isFile();
+    const worktreeDir = path22.join(normalizedProject, firstPart);
+    const gitFile = path22.join(worktreeDir, ".git");
+    const worktreeExists = fs22.existsSync(gitFile) && fs22.statSync(gitFile).isFile();
     return {
       classification: "worktree",
       moduleUid: firstPart,
@@ -9756,19 +9843,19 @@ function isModuleUidPattern(str) {
   return /^EP\d+$/.test(str);
 }
 function deriveWorkspaceRoot(projectPath) {
-  return path21.dirname(path21.resolve(projectPath));
+  return path22.dirname(path22.resolve(projectPath));
 }
 function validateWorkspacePath(filePath, projectPath) {
-  const normalizedProjectPath = path21.resolve(projectPath);
+  const normalizedProjectPath = path22.resolve(projectPath);
   const workspaceRoot = deriveWorkspaceRoot(projectPath);
-  const normalizedWorkspace = path21.resolve(workspaceRoot);
-  const artifactsDir = path21.join(normalizedWorkspace, "artifacts");
-  const absolutePath = path21.isAbsolute(filePath) ? path21.resolve(filePath) : path21.resolve(projectPath, filePath);
-  const normalizedPath = path21.normalize(absolutePath);
-  if (normalizedPath.startsWith(normalizedProjectPath + path21.sep) || normalizedPath === normalizedProjectPath) {
+  const normalizedWorkspace = path22.resolve(workspaceRoot);
+  const artifactsDir = path22.join(normalizedWorkspace, "artifacts");
+  const absolutePath = path22.isAbsolute(filePath) ? path22.resolve(filePath) : path22.resolve(projectPath, filePath);
+  const normalizedPath = path22.normalize(absolutePath);
+  if (normalizedPath.startsWith(normalizedProjectPath + path22.sep) || normalizedPath === normalizedProjectPath) {
     return normalizedPath;
   }
-  if (normalizedPath.startsWith(artifactsDir + path21.sep) || normalizedPath === artifactsDir) {
+  if (normalizedPath.startsWith(artifactsDir + path22.sep) || normalizedPath === artifactsDir) {
     return normalizedPath;
   }
   return null;
@@ -9866,13 +9953,13 @@ async function handleFileRead(command, projectPath) {
     };
   }
   try {
-    if (!fs22.existsSync(validPath)) {
+    if (!fs23.existsSync(validPath)) {
       return {
         success: false,
         error: "File not found"
       };
     }
-    const stats = fs22.statSync(validPath);
+    const stats = fs23.statSync(validPath);
     if (stats.isDirectory()) {
       return {
         success: false,
@@ -9885,7 +9972,7 @@ async function handleFileRead(command, projectPath) {
         error: `File too large: ${stats.size} bytes exceeds limit of ${maxSize} bytes`
       };
     }
-    const buffer = fs22.readFileSync(validPath);
+    const buffer = fs23.readFileSync(validPath);
     let content;
     if (encoding === "base64") {
       content = buffer.toString("base64");
@@ -9925,9 +10012,9 @@ async function handleFileWrite(command, projectPath) {
   }
   try {
     if (createDirs) {
-      const dirPath = path22.dirname(validPath);
-      if (!fs22.existsSync(dirPath)) {
-        fs22.mkdirSync(dirPath, { recursive: true });
+      const dirPath = path23.dirname(validPath);
+      if (!fs23.existsSync(dirPath)) {
+        fs23.mkdirSync(dirPath, { recursive: true });
       }
     }
     let buffer;
@@ -9937,8 +10024,8 @@ async function handleFileWrite(command, projectPath) {
       buffer = Buffer.from(content, "utf8");
     }
     const tempPath = `${validPath}.tmp.${Date.now()}`;
-    fs22.writeFileSync(tempPath, buffer);
-    fs22.renameSync(tempPath, validPath);
+    fs23.writeFileSync(tempPath, buffer);
+    fs23.renameSync(tempPath, validPath);
     return {
       success: true,
       bytesWritten: buffer.length
@@ -9963,13 +10050,13 @@ async function handleFileList(command, projectPath) {
     };
   }
   try {
-    if (!fs22.existsSync(validPath)) {
+    if (!fs23.existsSync(validPath)) {
       return {
         success: false,
         error: "Directory not found"
       };
     }
-    const stats = fs22.statSync(validPath);
+    const stats = fs23.statSync(validPath);
     if (!stats.isDirectory()) {
       return {
         success: false,
@@ -9980,11 +10067,11 @@ async function handleFileList(command, projectPath) {
     if (recursive) {
       await listDirectoryRecursive(validPath, validPath, entries, includeHidden);
     } else {
-      const dirEntries = await fs22.promises.readdir(validPath, { withFileTypes: true });
+      const dirEntries = await fs23.promises.readdir(validPath, { withFileTypes: true });
       for (const entry of dirEntries) {
         if (!includeHidden && entry.name.startsWith(".")) continue;
-        const entryPath = path22.join(validPath, entry.name);
-        const entryStats = await fs22.promises.stat(entryPath);
+        const entryPath = path23.join(validPath, entry.name);
+        const entryStats = await fs23.promises.stat(entryPath);
         entries.push({
           name: entry.name,
           type: entry.isDirectory() ? "directory" : "file",
@@ -10006,13 +10093,13 @@ async function handleFileList(command, projectPath) {
   }
 }
 async function listDirectoryRecursive(basePath, currentPath, entries, includeHidden) {
-  const dirEntries = await fs22.promises.readdir(currentPath, { withFileTypes: true });
+  const dirEntries = await fs23.promises.readdir(currentPath, { withFileTypes: true });
   for (const entry of dirEntries) {
     if (!includeHidden && entry.name.startsWith(".")) continue;
-    const entryPath = path22.join(currentPath, entry.name);
-    const relativePath = path22.relative(basePath, entryPath);
+    const entryPath = path23.join(currentPath, entry.name);
+    const relativePath = path23.relative(basePath, entryPath);
     try {
-      const entryStats = await fs22.promises.stat(entryPath);
+      const entryStats = await fs23.promises.stat(entryPath);
       entries.push({
         name: relativePath,
         type: entry.isDirectory() ? "directory" : "file",
@@ -10036,7 +10123,7 @@ async function handleFileSearch(command, projectPath) {
     };
   }
   try {
-    if (!fs22.existsSync(validPath)) {
+    if (!fs23.existsSync(validPath)) {
       return {
         success: false,
         error: "Directory not found"
@@ -10126,12 +10213,12 @@ function findClosingBracket(pattern, start) {
 }
 async function searchFilesRecursive(basePath, currentPath, pattern, files, maxResults) {
   if (files.length >= maxResults) return;
-  const entries = await fs22.promises.readdir(currentPath, { withFileTypes: true });
+  const entries = await fs23.promises.readdir(currentPath, { withFileTypes: true });
   for (const entry of entries) {
     if (files.length >= maxResults) return;
     if (entry.name.startsWith(".")) continue;
-    const entryPath = path22.join(currentPath, entry.name);
-    const relativePath = path22.relative(basePath, entryPath);
+    const entryPath = path23.join(currentPath, entry.name);
+    const relativePath = path23.relative(basePath, entryPath);
     try {
       if (entry.isDirectory()) {
         await searchFilesRecursive(basePath, entryPath, pattern, files, maxResults);
@@ -10159,7 +10246,7 @@ async function handleFileGrep(command, projectPath) {
     };
   }
   try {
-    if (!fs22.existsSync(validPath)) {
+    if (!fs23.existsSync(validPath)) {
       return {
         success: false,
         error: "Path not found"
@@ -10168,7 +10255,7 @@ async function handleFileGrep(command, projectPath) {
     const matches = [];
     const searchRegex = new RegExp(pattern, caseSensitive ? "" : "i");
     const fileGlobRegex = globToRegex(filePattern);
-    const stats = fs22.statSync(validPath);
+    const stats = fs23.statSync(validPath);
     if (stats.isFile()) {
       await grepFile(validPath, validPath, searchRegex, matches, effectiveMaxResults);
     } else {
@@ -10189,8 +10276,8 @@ async function handleFileGrep(command, projectPath) {
 }
 async function grepFile(basePath, filePath, pattern, matches, maxResults) {
   if (matches.length >= maxResults) return;
-  const relativePath = path22.relative(basePath, filePath);
-  const fileStream = fs22.createReadStream(filePath, { encoding: "utf8" });
+  const relativePath = path23.relative(basePath, filePath);
+  const fileStream = fs23.createReadStream(filePath, { encoding: "utf8" });
   const rl = readline.createInterface({
     input: fileStream,
     crlfDelay: Infinity
@@ -10204,7 +10291,7 @@ async function grepFile(basePath, filePath, pattern, matches, maxResults) {
     }
     if (pattern.test(line)) {
       matches.push({
-        file: relativePath || path22.basename(filePath),
+        file: relativePath || path23.basename(filePath),
         line: lineNumber,
         content: line.slice(0, 500)
         // Truncate long lines
@@ -10214,11 +10301,11 @@ async function grepFile(basePath, filePath, pattern, matches, maxResults) {
 }
 async function grepDirectoryRecursive(basePath, currentPath, searchPattern, filePattern, matches, maxResults) {
   if (matches.length >= maxResults) return;
-  const entries = await fs22.promises.readdir(currentPath, { withFileTypes: true });
+  const entries = await fs23.promises.readdir(currentPath, { withFileTypes: true });
   for (const entry of entries) {
     if (matches.length >= maxResults) return;
     if (entry.name.startsWith(".")) continue;
-    const entryPath = path22.join(currentPath, entry.name);
+    const entryPath = path23.join(currentPath, entry.name);
     try {
       if (entry.isDirectory()) {
         await grepDirectoryRecursive(basePath, entryPath, searchPattern, filePattern, matches, maxResults);
@@ -10246,13 +10333,13 @@ async function handleFileEdit(command, projectPath) {
     };
   }
   try {
-    if (!fs22.existsSync(validPath)) {
+    if (!fs23.existsSync(validPath)) {
       return {
         success: false,
         error: "File not found"
       };
     }
-    const stats = fs22.statSync(validPath);
+    const stats = fs23.statSync(validPath);
     if (stats.isDirectory()) {
       return {
         success: false,
@@ -10266,7 +10353,7 @@ async function handleFileEdit(command, projectPath) {
         error: `File too large for edit operation: ${stats.size} bytes exceeds limit of ${MAX_EDIT_SIZE} bytes (10MB). Use write-file for large files.`
       };
     }
-    const content = fs22.readFileSync(validPath, "utf8");
+    const content = fs23.readFileSync(validPath, "utf8");
     const occurrences = content.split(oldString).length - 1;
     if (occurrences === 0) {
       return {
@@ -10283,8 +10370,8 @@ async function handleFileEdit(command, projectPath) {
     const newContent = replaceAll ? content.split(oldString).join(newString) : content.replace(oldString, newString);
     const replacements = replaceAll ? occurrences : 1;
     const tempPath = `${validPath}.tmp.${Date.now()}`;
-    fs22.writeFileSync(tempPath, newContent, "utf8");
-    fs22.renameSync(tempPath, validPath);
+    fs23.writeFileSync(tempPath, newContent, "utf8");
+    fs23.renameSync(tempPath, validPath);
     const newSize = Buffer.byteLength(newContent, "utf8");
     return {
       success: true,
@@ -10309,7 +10396,7 @@ async function handleFileDelete(command, projectPath) {
       error: "Invalid path: directory traversal not allowed"
     };
   }
-  const normalizedProjectPath = path22.resolve(projectPath);
+  const normalizedProjectPath = path23.resolve(projectPath);
   if (validPath === normalizedProjectPath) {
     return {
       success: false,
@@ -10324,13 +10411,13 @@ async function handleFileDelete(command, projectPath) {
     };
   }
   try {
-    if (!fs22.existsSync(validPath)) {
+    if (!fs23.existsSync(validPath)) {
       return {
         success: false,
         error: "Path not found"
       };
     }
-    const stats = fs22.statSync(validPath);
+    const stats = fs23.statSync(validPath);
     const isDirectory = stats.isDirectory();
     if (isDirectory && !recursive) {
       return {
@@ -10339,9 +10426,9 @@ async function handleFileDelete(command, projectPath) {
       };
     }
     if (isDirectory) {
-      fs22.rmSync(validPath, { recursive: true, force: true });
+      fs23.rmSync(validPath, { recursive: true, force: true });
     } else {
-      fs22.unlinkSync(validPath);
+      fs23.unlinkSync(validPath);
     }
     return {
       success: true,
@@ -10374,8 +10461,8 @@ async function handleFileMkdir(command, projectPath) {
     };
   }
   try {
-    if (fs22.existsSync(validPath)) {
-      const stats = fs22.statSync(validPath);
+    if (fs23.existsSync(validPath)) {
+      const stats = fs23.statSync(validPath);
       if (stats.isDirectory()) {
         return {
           success: true,
@@ -10390,7 +10477,7 @@ async function handleFileMkdir(command, projectPath) {
       }
     }
     const modeNum = parseInt(mode, 8);
-    fs22.mkdirSync(validPath, { recursive: true, mode: modeNum });
+    fs23.mkdirSync(validPath, { recursive: true, mode: modeNum });
     return {
       success: true,
       created: true
@@ -10406,7 +10493,7 @@ async function handleFileMkdir(command, projectPath) {
 }
 
 // src/daemon/handlers/exec-handler.ts
-var import_child_process11 = require("child_process");
+var import_child_process12 = require("child_process");
 var DEFAULT_TIMEOUT = 3e4;
 var MAX_TIMEOUT = 3e5;
 async function handleExec(command, projectPath) {
@@ -10417,7 +10504,7 @@ async function handleExec(command, projectPath) {
     env = {}
   } = command;
   const effectiveTimeout = Math.min(Math.max(timeout, 1e3), MAX_TIMEOUT);
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     let stdout = "";
     let stderr = "";
     let timedOut = false;
@@ -10425,10 +10512,10 @@ async function handleExec(command, projectPath) {
     const done = (result) => {
       if (resolved) return;
       resolved = true;
-      resolve8(result);
+      resolve9(result);
     };
     try {
-      const proc = (0, import_child_process11.spawn)(cmd, {
+      const proc = (0, import_child_process12.spawn)(cmd, {
         shell: true,
         cwd,
         env: { ...process.env, ...env },
@@ -10489,10 +10576,10 @@ async function handleExec(command, projectPath) {
 }
 
 // src/daemon/handlers/worktree-handlers.ts
-var path28 = __toESM(require("path"));
-var fs28 = __toESM(require("fs"));
+var path29 = __toESM(require("path"));
+var fs29 = __toESM(require("fs"));
 var os13 = __toESM(require("os"));
-var import_child_process14 = require("child_process");
+var import_child_process15 = require("child_process");
 var import_util2 = require("util");
 
 // src/preview/types.ts
@@ -10519,54 +10606,54 @@ var import_events3 = require("events");
 var import_fs = require("fs");
 
 // src/preview/dev-server-runner.ts
-var import_child_process13 = require("child_process");
+var import_child_process14 = require("child_process");
 var http = __toESM(require("http"));
-var fs25 = __toESM(require("fs"));
-var path25 = __toESM(require("path"));
+var fs26 = __toESM(require("fs"));
+var path26 = __toESM(require("path"));
 var import_events2 = require("events");
-var import_core12 = __toESM(require_dist());
+var import_core14 = __toESM(require_dist());
 
 // src/utils/port-check.ts
 var net2 = __toESM(require("net"));
 async function isPortInUse(port) {
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     const server = net2.createServer();
     server.once("error", (err) => {
       if (err.code === "EADDRINUSE") {
-        resolve8(true);
+        resolve9(true);
       } else {
-        resolve8(false);
+        resolve9(false);
       }
     });
     server.once("listening", () => {
       server.close();
-      resolve8(false);
+      resolve9(false);
     });
     server.listen(port);
   });
 }
 
 // src/utils/env-cache.ts
-var fs23 = __toESM(require("fs"));
-var path23 = __toESM(require("path"));
+var fs24 = __toESM(require("fs"));
+var path24 = __toESM(require("path"));
 var os11 = __toESM(require("os"));
 var DEFAULT_CACHE_TTL = 60;
-var CACHE_DIR = path23.join(os11.homedir(), ".episoda", "cache");
+var CACHE_DIR = path24.join(os11.homedir(), ".episoda", "cache");
 function getCacheFilePath(projectId) {
-  return path23.join(CACHE_DIR, `env-vars-${projectId}.json`);
+  return path24.join(CACHE_DIR, `env-vars-${projectId}.json`);
 }
 function ensureCacheDir() {
-  if (!fs23.existsSync(CACHE_DIR)) {
-    fs23.mkdirSync(CACHE_DIR, { recursive: true, mode: 448 });
+  if (!fs24.existsSync(CACHE_DIR)) {
+    fs24.mkdirSync(CACHE_DIR, { recursive: true, mode: 448 });
   }
 }
 function readCache(projectId) {
   try {
     const cacheFile = getCacheFilePath(projectId);
-    if (!fs23.existsSync(cacheFile)) {
+    if (!fs24.existsSync(cacheFile)) {
       return null;
     }
-    const content = fs23.readFileSync(cacheFile, "utf-8");
+    const content = fs24.readFileSync(cacheFile, "utf-8");
     const data = JSON.parse(content);
     if (!data.vars || typeof data.vars !== "object" || !data.fetchedAt) {
       return null;
@@ -10585,7 +10672,7 @@ function writeCache(projectId, vars) {
       fetchedAt: Date.now(),
       projectId
     };
-    fs23.writeFileSync(cacheFile, JSON.stringify(data, null, 2), { mode: 384 });
+    fs24.writeFileSync(cacheFile, JSON.stringify(data, null, 2), { mode: 384 });
   } catch (error) {
     console.warn("[env-cache] Failed to write cache:", error instanceof Error ? error.message : error);
   }
@@ -10654,11 +10741,11 @@ No cached values available as fallback.`
 }
 
 // src/preview/dev-server-registry.ts
-var fs24 = __toESM(require("fs"));
-var path24 = __toESM(require("path"));
+var fs25 = __toESM(require("fs"));
+var path25 = __toESM(require("path"));
 var os12 = __toESM(require("os"));
-var import_child_process12 = require("child_process");
-var DEV_SERVER_REGISTRY_DIR = path24.join(os12.homedir(), ".episoda", "dev-servers");
+var import_child_process13 = require("child_process");
+var DEV_SERVER_REGISTRY_DIR = path25.join(os12.homedir(), ".episoda", "dev-servers");
 var DevServerRegistry = class {
   constructor() {
     this.ensureRegistryDir();
@@ -10668,9 +10755,9 @@ var DevServerRegistry = class {
    */
   ensureRegistryDir() {
     try {
-      if (!fs24.existsSync(DEV_SERVER_REGISTRY_DIR)) {
+      if (!fs25.existsSync(DEV_SERVER_REGISTRY_DIR)) {
         console.log(`[DevServerRegistry] EP1042: Creating registry directory: ${DEV_SERVER_REGISTRY_DIR}`);
-        fs24.mkdirSync(DEV_SERVER_REGISTRY_DIR, { recursive: true });
+        fs25.mkdirSync(DEV_SERVER_REGISTRY_DIR, { recursive: true });
       }
     } catch (error) {
       console.error(`[DevServerRegistry] EP1042: Failed to create registry directory:`, error);
@@ -10681,7 +10768,7 @@ var DevServerRegistry = class {
    * Get the registry file path for a module
    */
   getEntryPath(moduleUid) {
-    return path24.join(DEV_SERVER_REGISTRY_DIR, `${moduleUid}.json`);
+    return path25.join(DEV_SERVER_REGISTRY_DIR, `${moduleUid}.json`);
   }
   /**
    * Register a dev server
@@ -10692,7 +10779,7 @@ var DevServerRegistry = class {
     try {
       this.ensureRegistryDir();
       const entryPath = this.getEntryPath(entry.moduleUid);
-      fs24.writeFileSync(entryPath, JSON.stringify(entry, null, 2), "utf8");
+      fs25.writeFileSync(entryPath, JSON.stringify(entry, null, 2), "utf8");
       console.log(
         `[DevServerRegistry] EP1042: Registered ${entry.moduleUid} (PID ${entry.pid}, port ${entry.port}${entry.wsPort ? `, wsPort ${entry.wsPort}` : ""})`
       );
@@ -10708,8 +10795,8 @@ var DevServerRegistry = class {
   unregister(moduleUid) {
     try {
       const entryPath = this.getEntryPath(moduleUid);
-      if (fs24.existsSync(entryPath)) {
-        fs24.unlinkSync(entryPath);
+      if (fs25.existsSync(entryPath)) {
+        fs25.unlinkSync(entryPath);
         console.log(`[DevServerRegistry] EP1042: Unregistered ${moduleUid}`);
       }
     } catch (error) {
@@ -10725,10 +10812,10 @@ var DevServerRegistry = class {
   getByModule(moduleUid) {
     try {
       const entryPath = this.getEntryPath(moduleUid);
-      if (!fs24.existsSync(entryPath)) {
+      if (!fs25.existsSync(entryPath)) {
         return null;
       }
-      const content = fs24.readFileSync(entryPath, "utf8");
+      const content = fs25.readFileSync(entryPath, "utf8");
       const entry = JSON.parse(content);
       if (!entry.pid || !entry.port || !entry.worktreePath) {
         console.warn(`[DevServerRegistry] EP1042: Invalid entry for ${moduleUid}, removing`);
@@ -10771,7 +10858,7 @@ var DevServerRegistry = class {
     const entries = [];
     try {
       this.ensureRegistryDir();
-      const files = fs24.readdirSync(DEV_SERVER_REGISTRY_DIR).filter((f) => f.endsWith(".json"));
+      const files = fs25.readdirSync(DEV_SERVER_REGISTRY_DIR).filter((f) => f.endsWith(".json"));
       for (const file of files) {
         const moduleUid = file.replace(".json", "");
         const entry = this.getByModule(moduleUid);
@@ -10819,7 +10906,7 @@ var DevServerRegistry = class {
    */
   getProcessCwd(pid) {
     try {
-      const output = (0, import_child_process12.execSync)(`lsof -p ${pid} -Fn | grep ^n | grep cwd | head -1`, {
+      const output = (0, import_child_process13.execSync)(`lsof -p ${pid} -Fn | grep ^n | grep cwd | head -1`, {
         encoding: "utf8",
         timeout: 5e3
       }).trim();
@@ -10829,7 +10916,7 @@ var DevServerRegistry = class {
       return null;
     } catch {
       try {
-        return fs24.readlinkSync(`/proc/${pid}/cwd`);
+        return fs25.readlinkSync(`/proc/${pid}/cwd`);
       } catch {
         return null;
       }
@@ -10844,7 +10931,7 @@ var DevServerRegistry = class {
   findProcessesInWorktree(worktreePath) {
     const pids = [];
     try {
-      const output = (0, import_child_process12.execSync)(
+      const output = (0, import_child_process13.execSync)(
         `lsof -c node -c next | grep "${worktreePath}" | awk '{print $2}' | sort -u`,
         { encoding: "utf8", timeout: 5e3 }
       ).trim();
@@ -10909,7 +10996,7 @@ var DevServerRegistry = class {
    */
   findProcessesOnPort(port) {
     try {
-      const output = (0, import_child_process12.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
+      const output = (0, import_child_process13.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
       if (!output) {
         return [];
       }
@@ -10943,24 +11030,24 @@ var DevServerRegistry = class {
     return killed;
   }
   wait(ms) {
-    return new Promise((resolve8) => setTimeout(resolve8, ms));
+    return new Promise((resolve9) => setTimeout(resolve9, ms));
   }
   killWsServerOnPort(wsPort, worktreePath) {
     const killed = [];
     try {
-      const output = (0, import_child_process12.execSync)(`lsof -ti:${wsPort} 2>/dev/null || true`, {
+      const output = (0, import_child_process13.execSync)(`lsof -ti:${wsPort} 2>/dev/null || true`, {
         encoding: "utf8",
         timeout: 5e3
       }).trim();
       if (!output) {
         return killed;
       }
-      const expectedPath = path24.resolve(worktreePath);
+      const expectedPath = path25.resolve(worktreePath);
       const pids = output.split("\n").map((line) => parseInt(line, 10)).filter((pid) => !isNaN(pid) && pid > 0);
       for (const pid of pids) {
-        const command = (0, import_child_process12.execSync)(`ps -p ${pid} -o command=`, { encoding: "utf8", timeout: 5e3 }).trim();
+        const command = (0, import_child_process13.execSync)(`ps -p ${pid} -o command=`, { encoding: "utf8", timeout: 5e3 }).trim();
         const cwd = this.getProcessCwd(pid);
-        const cwdMatches = cwd ? path24.resolve(cwd) === expectedPath : false;
+        const cwdMatches = cwd ? path25.resolve(cwd) === expectedPath : false;
         const isWsServer = command.includes("ws-server.js") || command.includes("build:ws-server");
         if (!isWsServer || !cwdMatches) {
           continue;
@@ -11240,7 +11327,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
    */
   async killProcessOnPort(port) {
     try {
-      const result = (0, import_child_process13.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
+      const result = (0, import_child_process14.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
       if (!result) {
         return true;
       }
@@ -11248,15 +11335,15 @@ var DevServerRunner = class extends import_events2.EventEmitter {
       console.log(`[DevServerRunner] Found ${pids.length} process(es) on port ${port}`);
       for (const pid of pids) {
         try {
-          (0, import_child_process13.execSync)(`kill -15 ${pid} 2>/dev/null || true`);
+          (0, import_child_process14.execSync)(`kill -15 ${pid} 2>/dev/null || true`);
         } catch {
         }
       }
       await this.wait(1e3);
       for (const pid of pids) {
         try {
-          (0, import_child_process13.execSync)(`kill -0 ${pid} 2>/dev/null`);
-          (0, import_child_process13.execSync)(`kill -9 ${pid} 2>/dev/null || true`);
+          (0, import_child_process14.execSync)(`kill -0 ${pid} 2>/dev/null`);
+          (0, import_child_process14.execSync)(`kill -9 ${pid} 2>/dev/null || true`);
         } catch {
         }
       }
@@ -11276,13 +11363,13 @@ var DevServerRunner = class extends import_events2.EventEmitter {
       return { success: false, error: `WS_BIND_CONFLICT: WS port ${wsPort} is already in use.` };
     }
     const registry = getDevServerRegistry();
-    const expectedPath = path25.resolve(projectPath);
+    const expectedPath = path26.resolve(projectPath);
     const unsafe = [];
     const killable = [];
     for (const pid of pids) {
       const command = this.getProcessCommand(pid);
       const cwd = registry.getProcessCwd(pid);
-      const cwdMatches = cwd ? path25.resolve(cwd) === expectedPath : false;
+      const cwdMatches = cwd ? path26.resolve(cwd) === expectedPath : false;
       if (this.isLikelyWsServerProcess(command) && cwdMatches) {
         killable.push(pid);
       } else {
@@ -11322,12 +11409,12 @@ var DevServerRunner = class extends import_events2.EventEmitter {
   async cleanupWsServerOnPort(wsPort, worktreePath) {
     if (!wsPort || !await isPortInUse(wsPort)) return;
     const registry = getDevServerRegistry();
-    const expectedPath = path25.resolve(worktreePath);
+    const expectedPath = path26.resolve(worktreePath);
     const pids = this.getPidsOnPort(wsPort);
     for (const pid of pids) {
       const command = this.getProcessCommand(pid);
       const cwd = registry.getProcessCwd(pid);
-      const cwdMatches = cwd ? path25.resolve(cwd) === expectedPath : false;
+      const cwdMatches = cwd ? path26.resolve(cwd) === expectedPath : false;
       if (!this.isLikelyWsServerProcess(command) || !cwdMatches) {
         continue;
       }
@@ -11340,7 +11427,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
     for (const pid of pids) {
       const command = this.getProcessCommand(pid);
       const cwd = registry.getProcessCwd(pid);
-      const cwdMatches = cwd ? path25.resolve(cwd) === expectedPath : false;
+      const cwdMatches = cwd ? path26.resolve(cwd) === expectedPath : false;
       if (!this.isLikelyWsServerProcess(command) || !cwdMatches) {
         continue;
       }
@@ -11353,7 +11440,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
   }
   getPidsOnPort(port) {
     try {
-      const output = (0, import_child_process13.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
+      const output = (0, import_child_process14.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
       if (!output) return [];
       return output.split("\n").map((value) => parseInt(value, 10)).filter((value) => !isNaN(value) && value > 0);
     } catch {
@@ -11362,7 +11449,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
   }
   getProcessCommand(pid) {
     try {
-      return (0, import_child_process13.execSync)(`ps -p ${pid} -o command=`, { encoding: "utf8" }).trim() || "unknown";
+      return (0, import_child_process14.execSync)(`ps -p ${pid} -o command=`, { encoding: "utf8" }).trim() || "unknown";
     } catch {
       return "unknown";
     }
@@ -11374,8 +11461,8 @@ var DevServerRunner = class extends import_events2.EventEmitter {
     const fallback = `WS_BIND_CONFLICT: ws-server failed to become healthy on WS port ${wsPort}`;
     if (!logPath) return fallback;
     try {
-      if (!fs25.existsSync(logPath)) return fallback;
-      const content = fs25.readFileSync(logPath, "utf8");
+      if (!fs26.existsSync(logPath)) return fallback;
+      const content = fs26.readFileSync(logPath, "utf8");
       if (content.includes("EADDRINUSE") && content.includes(`${wsPort}`)) {
         return `WS_BIND_CONFLICT: ws-server could not bind to WS port ${wsPort} (EADDRINUSE)`;
       }
@@ -11389,7 +11476,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
   // ============ Private Methods ============
   async fetchEnvVars(projectPath) {
     try {
-      const config = await (0, import_core12.loadConfig)();
+      const config = await (0, import_core14.loadConfig)();
       if (!config?.access_token || !config?.project_id) {
         return {};
       }
@@ -11399,8 +11486,8 @@ var DevServerRunner = class extends import_events2.EventEmitter {
         cacheTtl: 300
       });
       console.log(`[DevServerRunner] Loaded ${Object.keys(result.envVars).length} env vars`);
-      const envFilePath = path25.join(projectPath, ".env");
-      if (!fs25.existsSync(envFilePath) && Object.keys(result.envVars).length > 0) {
+      const envFilePath = path26.join(projectPath, ".env");
+      if (!fs26.existsSync(envFilePath) && Object.keys(result.envVars).length > 0) {
         console.log(`[DevServerRunner] Writing .env file`);
         writeEnvFile(projectPath, result.envVars);
       }
@@ -11425,7 +11512,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
       WS_PORT: String(wsPort),
       NODE_OPTIONS: enhancedNodeOptions
     };
-    const proc = (0, import_child_process13.spawn)(cmd, args, {
+    const proc = (0, import_child_process14.spawn)(cmd, args, {
       cwd: projectPath,
       env: mergedEnv,
       stdio: ["ignore", "pipe", "pipe"],
@@ -11517,7 +11604,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
     return Math.min(delay, DEV_SERVER_CONSTANTS.MAX_RESTART_DELAY_MS);
   }
   async checkHealth(port) {
-    return new Promise((resolve8) => {
+    return new Promise((resolve9) => {
       const req = http.request(
         {
           hostname: "localhost",
@@ -11526,18 +11613,18 @@ var DevServerRunner = class extends import_events2.EventEmitter {
           method: "HEAD",
           timeout: DEV_SERVER_CONSTANTS.HEALTH_CHECK_TIMEOUT_MS
         },
-        () => resolve8(true)
+        () => resolve9(true)
       );
-      req.on("error", () => resolve8(false));
+      req.on("error", () => resolve9(false));
       req.on("timeout", () => {
         req.destroy();
-        resolve8(false);
+        resolve9(false);
       });
       req.end();
     });
   }
   async checkWsHealth(wsPort) {
-    return new Promise((resolve8) => {
+    return new Promise((resolve9) => {
       const req = http.request(
         {
           hostname: "127.0.0.1",
@@ -11547,14 +11634,14 @@ var DevServerRunner = class extends import_events2.EventEmitter {
           timeout: DEV_SERVER_CONSTANTS.HEALTH_CHECK_TIMEOUT_MS
         },
         (res) => {
-          resolve8(res.statusCode === 200);
+          resolve9(res.statusCode === 200);
           res.resume();
         }
       );
-      req.on("error", () => resolve8(false));
+      req.on("error", () => resolve9(false));
       req.on("timeout", () => {
         req.destroy();
-        resolve8(false);
+        resolve9(false);
       });
       req.end();
     });
@@ -11582,28 +11669,28 @@ var DevServerRunner = class extends import_events2.EventEmitter {
     return false;
   }
   wait(ms) {
-    return new Promise((resolve8) => setTimeout(resolve8, ms));
+    return new Promise((resolve9) => setTimeout(resolve9, ms));
   }
   getLogsDir() {
-    const logsDir = path25.join((0, import_core12.getConfigDir)(), "logs");
-    if (!fs25.existsSync(logsDir)) {
-      fs25.mkdirSync(logsDir, { recursive: true });
+    const logsDir = path26.join((0, import_core14.getConfigDir)(), "logs");
+    if (!fs26.existsSync(logsDir)) {
+      fs26.mkdirSync(logsDir, { recursive: true });
     }
     return logsDir;
   }
   getLogFilePath(moduleUid) {
-    return path25.join(this.getLogsDir(), `dev-${moduleUid}.log`);
+    return path26.join(this.getLogsDir(), `dev-${moduleUid}.log`);
   }
   rotateLogIfNeeded(logPath) {
     try {
-      if (fs25.existsSync(logPath)) {
-        const stats = fs25.statSync(logPath);
+      if (fs26.existsSync(logPath)) {
+        const stats = fs26.statSync(logPath);
         if (stats.size > DEV_SERVER_CONSTANTS.MAX_LOG_SIZE_BYTES) {
           const backupPath = `${logPath}.1`;
-          if (fs25.existsSync(backupPath)) {
-            fs25.unlinkSync(backupPath);
+          if (fs26.existsSync(backupPath)) {
+            fs26.unlinkSync(backupPath);
           }
-          fs25.renameSync(logPath, backupPath);
+          fs26.renameSync(logPath, backupPath);
         }
       }
     } catch {
@@ -11614,7 +11701,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
     try {
       const timestamp = (/* @__PURE__ */ new Date()).toISOString();
       const prefix = isError ? "ERR" : "OUT";
-      fs25.appendFileSync(logPath, `[${timestamp}] [${prefix}] ${line}
+      fs26.appendFileSync(logPath, `[${timestamp}] [${prefix}] ${line}
 `);
     } catch {
     }
@@ -11781,7 +11868,7 @@ var PreviewManager = class extends import_events3.EventEmitter {
       for (let attempt = 1; attempt <= MAX_TUNNEL_RETRIES; attempt++) {
         if (attempt > 1) {
           console.log(`[PreviewManager] Retrying tunnel for ${moduleUid} (attempt ${attempt}/${MAX_TUNNEL_RETRIES})...`);
-          await new Promise((resolve8) => setTimeout(resolve8, 2e3));
+          await new Promise((resolve9) => setTimeout(resolve9, 2e3));
         }
         tunnelResult = await this.tunnel.startTunnel({
           moduleUid,
@@ -11913,7 +12000,7 @@ var PreviewManager = class extends import_events3.EventEmitter {
     }
     console.log(`[PreviewManager] Restarting preview for ${moduleUid}`);
     await this.stopPreview(moduleUid);
-    await new Promise((resolve8) => setTimeout(resolve8, 1e3));
+    await new Promise((resolve9) => setTimeout(resolve9, 1e3));
     return this.startPreview({
       moduleUid,
       worktreePath: state.worktreePath,
@@ -12070,7 +12157,7 @@ function getPreviewManager() {
 }
 
 // src/daemon/handlers/worktree-handlers.ts
-var import_core13 = __toESM(require_dist());
+var import_core15 = __toESM(require_dist());
 
 // src/api/worktree-api.ts
 async function deleteWorktree(config, moduleUid) {
@@ -12106,8 +12193,8 @@ async function deleteWorktree(config, moduleUid) {
 }
 
 // src/daemon/package-manager.ts
-var fs26 = __toESM(require("fs"));
-var path26 = __toESM(require("path"));
+var fs27 = __toESM(require("fs"));
+var path27 = __toESM(require("path"));
 function pnpmCommand(args) {
   return [
     "if command -v pnpm >/dev/null 2>&1; then",
@@ -12125,13 +12212,13 @@ var PACKAGE_MANAGERS = {
     {
       name: "pnpm",
       detector: (p) => {
-        if (fs26.existsSync(path26.join(p, "pnpm-lock.yaml"))) {
+        if (fs27.existsSync(path27.join(p, "pnpm-lock.yaml"))) {
           return "pnpm-lock.yaml";
         }
-        const pkgJsonPath = path26.join(p, "package.json");
-        if (fs26.existsSync(pkgJsonPath)) {
+        const pkgJsonPath = path27.join(p, "package.json");
+        if (fs27.existsSync(pkgJsonPath)) {
           try {
-            const pkg = JSON.parse(fs26.readFileSync(pkgJsonPath, "utf-8"));
+            const pkg = JSON.parse(fs27.readFileSync(pkgJsonPath, "utf-8"));
             if (pkg.packageManager?.startsWith("pnpm")) {
               return "package.json (packageManager field)";
             }
@@ -12147,7 +12234,7 @@ var PACKAGE_MANAGERS = {
     },
     {
       name: "yarn",
-      detector: (p) => fs26.existsSync(path26.join(p, "yarn.lock")) ? "yarn.lock" : null,
+      detector: (p) => fs27.existsSync(path27.join(p, "yarn.lock")) ? "yarn.lock" : null,
       config: {
         installCmd: "yarn install --frozen-lockfile",
         cacheEnvVar: "YARN_CACHE_FOLDER"
@@ -12155,14 +12242,14 @@ var PACKAGE_MANAGERS = {
     },
     {
       name: "bun",
-      detector: (p) => fs26.existsSync(path26.join(p, "bun.lockb")) ? "bun.lockb" : null,
+      detector: (p) => fs27.existsSync(path27.join(p, "bun.lockb")) ? "bun.lockb" : null,
       config: {
         installCmd: "bun install --frozen-lockfile"
       }
     },
     {
       name: "npm",
-      detector: (p) => fs26.existsSync(path26.join(p, "package-lock.json")) ? "package-lock.json" : null,
+      detector: (p) => fs27.existsSync(path27.join(p, "package-lock.json")) ? "package-lock.json" : null,
       config: {
         installCmd: "npm ci"
       }
@@ -12171,7 +12258,7 @@ var PACKAGE_MANAGERS = {
       // EP1222: Default to pnpm for new projects without lockfile
       // This encourages standardization on pnpm across Episoda projects
       name: "pnpm",
-      detector: (p) => fs26.existsSync(path26.join(p, "package.json")) ? "package.json (no lockfile - defaulting to pnpm)" : null,
+      detector: (p) => fs27.existsSync(path27.join(p, "package.json")) ? "package.json (no lockfile - defaulting to pnpm)" : null,
       config: {
         installCmd: pnpmCommand("install"),
         cacheEnvVar: "PNPM_HOME"
@@ -12182,13 +12269,13 @@ var PACKAGE_MANAGERS = {
     {
       name: "uv",
       detector: (p) => {
-        const pyprojectPath = path26.join(p, "pyproject.toml");
-        if (fs26.existsSync(path26.join(p, "uv.lock"))) {
+        const pyprojectPath = path27.join(p, "pyproject.toml");
+        if (fs27.existsSync(path27.join(p, "uv.lock"))) {
           return "uv.lock";
         }
-        if (fs26.existsSync(pyprojectPath)) {
+        if (fs27.existsSync(pyprojectPath)) {
           try {
-            const content = fs26.readFileSync(pyprojectPath, "utf-8");
+            const content = fs27.readFileSync(pyprojectPath, "utf-8");
             if (content.includes("[tool.uv]") || content.includes("[project]")) {
               return "pyproject.toml";
             }
@@ -12204,7 +12291,7 @@ var PACKAGE_MANAGERS = {
     },
     {
       name: "pip",
-      detector: (p) => fs26.existsSync(path26.join(p, "requirements.txt")) ? "requirements.txt" : null,
+      detector: (p) => fs27.existsSync(path27.join(p, "requirements.txt")) ? "requirements.txt" : null,
       config: {
         installCmd: "pip install -r requirements.txt"
       }
@@ -12256,15 +12343,15 @@ function detectPackageManager(worktreePath, preferredLanguages) {
 }
 
 // src/daemon/build-packages.ts
-var fs27 = __toESM(require("fs"));
-var path27 = __toESM(require("path"));
+var fs28 = __toESM(require("fs"));
+var path28 = __toESM(require("path"));
 function hasPackageScript(worktreePath, scriptName) {
   try {
-    const packageJsonPath = path27.join(worktreePath, "package.json");
-    if (!fs27.existsSync(packageJsonPath)) {
+    const packageJsonPath = path28.join(worktreePath, "package.json");
+    if (!fs28.existsSync(packageJsonPath)) {
       return false;
     }
-    const packageJson2 = JSON.parse(fs27.readFileSync(packageJsonPath, "utf-8"));
+    const packageJson2 = JSON.parse(fs28.readFileSync(packageJsonPath, "utf-8"));
     return typeof packageJson2.scripts?.[scriptName] === "string";
   } catch {
     return false;
@@ -12315,7 +12402,7 @@ async function getConfigForApi() {
       machine_uuid: process.env.EPISODA_CONTAINER_ID
     };
   }
-  return (0, import_core13.loadConfig)();
+  return (0, import_core15.loadConfig)();
 }
 function stripGitCredentials(repoUrl) {
   try {
@@ -12402,24 +12489,24 @@ async function readOriginUrl(bareRepoPath) {
     return null;
   }
 }
-var execAsync2 = (0, import_util2.promisify)(import_child_process14.exec);
+var execAsync2 = (0, import_util2.promisify)(import_child_process15.exec);
 function persistWorkspaceProjectContext(workspaceSlug, projectSlug, projectId) {
   if (process.env.EPISODA_MODE !== "cloud") {
     return;
   }
   const homeDir = process.env.HOME || os13.homedir();
-  const workspaceConfigPath = path28.join(
+  const workspaceConfigPath = path29.join(
     homeDir,
     "episoda",
     workspaceSlug,
     ".episoda",
     "config.json"
   );
-  if (!fs28.existsSync(workspaceConfigPath)) {
+  if (!fs29.existsSync(workspaceConfigPath)) {
     return;
   }
   try {
-    const content = fs28.readFileSync(workspaceConfigPath, "utf8");
+    const content = fs29.readFileSync(workspaceConfigPath, "utf8");
     const workspaceConfig = JSON.parse(content);
     let changed = false;
     if (projectId && workspaceConfig.projectId !== projectId && workspaceConfig.project_id !== projectId) {
@@ -12431,7 +12518,7 @@ function persistWorkspaceProjectContext(workspaceSlug, projectSlug, projectId) {
       changed = true;
     }
     if (changed) {
-      fs28.writeFileSync(workspaceConfigPath, JSON.stringify(workspaceConfig, null, 2), "utf8");
+      fs29.writeFileSync(workspaceConfigPath, JSON.stringify(workspaceConfig, null, 2), "utf8");
       console.log("[Worktree] Updated workspace config with project context");
     }
   } catch (error) {
@@ -12478,20 +12565,20 @@ async function handleWorktreeCreate(request2) {
   }
   try {
     const projectPath = getProjectPath(workspaceSlug, projectSlug);
-    const bareRepoPath = path28.join(projectPath, ".bare");
+    const bareRepoPath = path29.join(projectPath, ".bare");
     const gitEnv = projectId ? { ...process.env, EPISODA_PROJECT_ID: projectId } : process.env;
     const refreshedRepoUrl = await getFreshGithubRepoUrl(repoUrl, projectId);
-    if (!fs28.existsSync(bareRepoPath)) {
+    if (!fs29.existsSync(bareRepoPath)) {
       console.log(`[Worktree] K1273: Project not found, cloning lazily...`);
       console.log(`[Worktree]   Repo URL: ${stripGitCredentials(refreshedRepoUrl)}`);
-      const episodaDir = path28.join(projectPath, ".episoda");
-      fs28.mkdirSync(episodaDir, { recursive: true });
+      const episodaDir = path29.join(projectPath, ".episoda");
+      fs29.mkdirSync(episodaDir, { recursive: true });
       try {
         console.log(`[Worktree] K1273: Starting git clone...`);
         await execAsync2(`git clone --bare "${refreshedRepoUrl}" "${bareRepoPath}"`, { env: gitEnv });
         console.log(`[Worktree] K1273: Clone successful`);
         await execAsync2(`git -C "${bareRepoPath}" config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"`, { env: gitEnv });
-        const configPath = path28.join(episodaDir, "config.json");
+        const configPath = path29.join(episodaDir, "config.json");
         const config = {
           projectId,
           workspaceSlug,
@@ -12500,7 +12587,7 @@ async function handleWorktreeCreate(request2) {
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),
           worktrees: []
         };
-        fs28.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+        fs29.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
         console.log(`[Worktree] K1273: Project initialized at ${projectPath}`);
       } catch (cloneError) {
         console.error(`[Worktree] K1273: Git clone failed: ${cloneError.message}`);
@@ -12544,8 +12631,8 @@ async function handleWorktreeCreate(request2) {
     console.log(`[Worktree] EP1143: Worktree created at ${worktreePath}`);
     if (envVars && Object.keys(envVars).length > 0) {
       const envContent = Object.entries(envVars).map(([key, value]) => `${key}=${value}`).join("\n");
-      const envPath = path28.join(worktreePath, ".env");
-      fs28.writeFileSync(envPath, envContent + "\n", "utf-8");
+      const envPath = path29.join(worktreePath, ".env");
+      fs29.writeFileSync(envPath, envContent + "\n", "utf-8");
       console.log(`[Worktree] EP1143: Wrote ${Object.keys(envVars).length} env vars to .env`);
     }
     const isCloud = process.env.EPISODA_MODE === "cloud";
@@ -12697,12 +12784,12 @@ async function handleProjectEject(request2) {
   console.log(`[Worktree] EP1144: Ejecting project ${projectSlug} from workspace ${workspaceSlug}`);
   try {
     const projectPath = getProjectPath(workspaceSlug, projectSlug);
-    const bareRepoPath = path28.join(projectPath, ".bare");
-    if (!fs28.existsSync(projectPath)) {
+    const bareRepoPath = path29.join(projectPath, ".bare");
+    if (!fs29.existsSync(projectPath)) {
       console.log(`[Worktree] EP1144: Project path not found, nothing to eject: ${projectPath}`);
       return { success: true };
     }
-    if (!fs28.existsSync(bareRepoPath)) {
+    if (!fs29.existsSync(bareRepoPath)) {
       console.log(`[Worktree] EP1144: Bare repo not found, nothing to eject: ${bareRepoPath}`);
       return { success: true };
     }
@@ -12717,12 +12804,12 @@ async function handleProjectEject(request2) {
         };
       }
     }
-    const artifactsPath = path28.join(projectPath, "artifacts");
-    if (fs28.existsSync(artifactsPath)) {
+    const artifactsPath = path29.join(projectPath, "artifacts");
+    if (fs29.existsSync(artifactsPath)) {
       await persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug);
     }
     console.log(`[Worktree] EP1144: Removing project directory: ${projectPath}`);
-    await fs28.promises.rm(projectPath, { recursive: true, force: true });
+    await fs29.promises.rm(projectPath, { recursive: true, force: true });
     console.log(`[Worktree] EP1144: Successfully ejected project ${projectSlug}`);
     return { success: true };
   } catch (error) {
@@ -12736,7 +12823,7 @@ async function handleProjectEject(request2) {
 async function persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug) {
   const MAX_ARTIFACT_SIZE = 10 * 1024 * 1024;
   try {
-    const files = await fs28.promises.readdir(artifactsPath);
+    const files = await fs29.promises.readdir(artifactsPath);
     if (files.length === 0) {
       return;
     }
@@ -12750,8 +12837,8 @@ async function persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug
     }
     const artifacts = [];
     for (const fileName of files) {
-      const filePath = path28.join(artifactsPath, fileName);
-      const stat = await fs28.promises.stat(filePath);
+      const filePath = path29.join(artifactsPath, fileName);
+      const stat = await fs29.promises.stat(filePath);
       if (stat.isDirectory()) {
         continue;
       }
@@ -12760,9 +12847,9 @@ async function persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug
         continue;
       }
       try {
-        const content = await fs28.promises.readFile(filePath);
+        const content = await fs29.promises.readFile(filePath);
         const base64Content = content.toString("base64");
-        const ext = path28.extname(fileName).toLowerCase();
+        const ext = path29.extname(fileName).toLowerCase();
         const mimeTypes = {
           ".json": "application/json",
           ".txt": "text/plain",
@@ -12818,8 +12905,8 @@ async function persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug
 }
 
 // src/daemon/handlers/project-handlers.ts
-var path29 = __toESM(require("path"));
-var fs29 = __toESM(require("fs"));
+var path30 = __toESM(require("path"));
+var fs30 = __toESM(require("fs"));
 function validateSlug(slug, fieldName) {
   if (!slug || typeof slug !== "string") {
     return `${fieldName} is required`;
@@ -12859,14 +12946,14 @@ async function handleProjectSetup(params) {
   console.log(`[ProjectSetup] EP1199: Setting up project ${workspaceSlug}/${projectSlug}`);
   try {
     const projectPath = getProjectPath(workspaceSlug, projectSlug);
-    const artifactsPath = path29.join(projectPath, "artifacts");
-    const configDir = path29.join(projectPath, ".episoda");
-    const configPath = path29.join(configDir, "config.json");
-    await fs29.promises.mkdir(artifactsPath, { recursive: true });
-    await fs29.promises.mkdir(configDir, { recursive: true });
+    const artifactsPath = path30.join(projectPath, "artifacts");
+    const configDir = path30.join(projectPath, ".episoda");
+    const configPath = path30.join(configDir, "config.json");
+    await fs30.promises.mkdir(artifactsPath, { recursive: true });
+    await fs30.promises.mkdir(configDir, { recursive: true });
     let existingConfig = {};
     try {
-      const existing = await fs29.promises.readFile(configPath, "utf-8");
+      const existing = await fs30.promises.readFile(configPath, "utf-8");
       existingConfig = JSON.parse(existing);
     } catch {
     }
@@ -12879,7 +12966,7 @@ async function handleProjectSetup(params) {
       // Only set created_at if not already present
       created_at: existingConfig.created_at || (/* @__PURE__ */ new Date()).toISOString()
     };
-    await fs29.promises.writeFile(configPath, JSON.stringify(config, null, 2));
+    await fs30.promises.writeFile(configPath, JSON.stringify(config, null, 2));
     console.log(`[ProjectSetup] EP1199: Project setup complete at ${projectPath}`);
     return {
       success: true,
@@ -12898,9 +12985,9 @@ async function handleProjectSetup(params) {
 
 // src/daemon/handlers/pty-handler.ts
 var pty = __toESM(require("@lydell/node-pty"));
-var fs30 = __toESM(require("fs"));
+var fs31 = __toESM(require("fs"));
 var os14 = __toESM(require("os"));
-var path30 = __toESM(require("path"));
+var path31 = __toESM(require("path"));
 var INACTIVITY_TIMEOUT_MS3 = 30 * 60 * 1e3;
 var sessions = /* @__PURE__ */ new Map();
 async function handlePtySpawn(payload, client) {
@@ -13070,27 +13157,27 @@ function createCredentialBootstrap(payload, agentRunId) {
   if (bootstrap.provider === "codex" && !bootstrap.oauth.refresh_token) {
     throw new Error("Codex PTY spawn aborted: refresh_token is missing from credential bundle. Please reconnect Codex in Settings.");
   }
-  const baseDir = fs30.mkdtempSync(path30.join(os14.tmpdir(), `episoda-pty-${agentRunId}-`));
+  const baseDir = fs31.mkdtempSync(path31.join(os14.tmpdir(), `episoda-pty-${agentRunId}-`));
   const cleanupDirs = [baseDir];
   if (bootstrap.provider === "claude") {
-    const claudeConfigDir = path30.join(baseDir, ".claude");
-    fs30.mkdirSync(claudeConfigDir, { recursive: true });
-    const credentialsPath = path30.join(claudeConfigDir, ".credentials.json");
+    const claudeConfigDir = path31.join(baseDir, ".claude");
+    fs31.mkdirSync(claudeConfigDir, { recursive: true });
+    const credentialsPath = path31.join(claudeConfigDir, ".credentials.json");
     const claudeAiOauth = {
       accessToken: bootstrap.oauth.access_token
     };
     if (bootstrap.oauth.refresh_token) claudeAiOauth.refreshToken = bootstrap.oauth.refresh_token;
     if (bootstrap.oauth.expires_at) claudeAiOauth.expiresAt = new Date(bootstrap.oauth.expires_at).getTime();
     if (bootstrap.oauth.scopes) claudeAiOauth.scopes = bootstrap.oauth.scopes;
-    fs30.writeFileSync(credentialsPath, JSON.stringify({ claudeAiOauth }, null, 2), { mode: 384 });
+    fs31.writeFileSync(credentialsPath, JSON.stringify({ claudeAiOauth }, null, 2), { mode: 384 });
     return {
       env: { CLAUDE_CONFIG_DIR: claudeConfigDir },
       cleanupDirs
     };
   }
-  const codexHome = path30.join(baseDir, ".codex");
-  fs30.mkdirSync(codexHome, { recursive: true });
-  const authPath = path30.join(codexHome, "auth.json");
+  const codexHome = path31.join(baseDir, ".codex");
+  fs31.mkdirSync(codexHome, { recursive: true });
+  const authPath = path31.join(codexHome, "auth.json");
   const authPayload = {
     auth_mode: "chatgpt",
     OPENAI_API_KEY: null,
@@ -13104,7 +13191,7 @@ function createCredentialBootstrap(payload, agentRunId) {
       account_id: bootstrap.oauth.account_id
     }
   };
-  fs30.writeFileSync(authPath, JSON.stringify(authPayload, null, 2), { mode: 384 });
+  fs31.writeFileSync(authPath, JSON.stringify(authPayload, null, 2), { mode: 384 });
   return {
     env: { CODEX_HOME: codexHome },
     cleanupDirs,
@@ -13117,7 +13204,7 @@ function syncCredentialUpdateAfterExit(session, agent_run_id, client) {
     cleanupCredentialDirs(session.credentialDirs);
     return;
   }
-  void fs30.promises.readFile(authPath, "utf8").then((raw) => {
+  void fs31.promises.readFile(authPath, "utf8").then((raw) => {
     const tokens = extractCredentialTokens(raw);
     if (!tokens.access_token) {
       console.warn(`[PTY] EP1472: No access_token in auth.json for ${agent_run_id}, skipping credential update`);
@@ -13169,8 +13256,8 @@ function getErrorMessage(error) {
 function cleanupCredentialDirs(dirs) {
   for (const dirPath of dirs) {
     try {
-      if (fs30.existsSync(dirPath)) {
-        fs30.rmSync(dirPath, { recursive: true, force: true });
+      if (fs31.existsSync(dirPath)) {
+        fs31.rmSync(dirPath, { recursive: true, force: true });
       }
     } catch (error) {
       console.warn(`[PTY] Failed to cleanup credential dir ${dirPath}:`, error);
@@ -13179,10 +13266,10 @@ function cleanupCredentialDirs(dirs) {
 }
 
 // src/utils/dev-server.ts
-var import_child_process15 = require("child_process");
-var import_core14 = __toESM(require_dist());
-var fs31 = __toESM(require("fs"));
-var path31 = __toESM(require("path"));
+var import_child_process16 = require("child_process");
+var import_core16 = __toESM(require_dist());
+var fs32 = __toESM(require("fs"));
+var path32 = __toESM(require("path"));
 var MAX_RESTART_ATTEMPTS = 5;
 var INITIAL_RESTART_DELAY_MS = 2e3;
 var MAX_RESTART_DELAY_MS = 3e4;
@@ -13190,26 +13277,26 @@ var MAX_LOG_SIZE_BYTES2 = 5 * 1024 * 1024;
 var NODE_MEMORY_LIMIT_MB = 2048;
 var activeServers = /* @__PURE__ */ new Map();
 function getLogsDir() {
-  const logsDir = path31.join((0, import_core14.getConfigDir)(), "logs");
-  if (!fs31.existsSync(logsDir)) {
-    fs31.mkdirSync(logsDir, { recursive: true });
+  const logsDir = path32.join((0, import_core16.getConfigDir)(), "logs");
+  if (!fs32.existsSync(logsDir)) {
+    fs32.mkdirSync(logsDir, { recursive: true });
   }
   return logsDir;
 }
 function getLogFilePath(moduleUid) {
-  return path31.join(getLogsDir(), `dev-${moduleUid}.log`);
+  return path32.join(getLogsDir(), `dev-${moduleUid}.log`);
 }
 function rotateLogIfNeeded(logPath) {
   try {
-    if (fs31.existsSync(logPath)) {
-      const stats = fs31.statSync(logPath);
+    if (fs32.existsSync(logPath)) {
+      const stats = fs32.statSync(logPath);
       if (stats.size > MAX_LOG_SIZE_BYTES2) {
         const backupPath = `${logPath}.1`;
-        if (fs31.existsSync(backupPath)) {
-          fs31.unlinkSync(backupPath);
+        if (fs32.existsSync(backupPath)) {
+          fs32.unlinkSync(backupPath);
         }
-        fs31.renameSync(logPath, backupPath);
-        console.log(`[DevServer] EP932: Rotated log file for ${path31.basename(logPath)}`);
+        fs32.renameSync(logPath, backupPath);
+        console.log(`[DevServer] EP932: Rotated log file for ${path32.basename(logPath)}`);
       }
     }
   } catch (error) {
@@ -13222,13 +13309,13 @@ function writeToLog(logPath, line, isError = false) {
     const prefix = isError ? "ERR" : "OUT";
     const logLine = `[${timestamp}] [${prefix}] ${line}
 `;
-    fs31.appendFileSync(logPath, logLine);
+    fs32.appendFileSync(logPath, logLine);
   } catch {
   }
 }
 async function killProcessOnPort(port) {
   try {
-    const result = (0, import_child_process15.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
+    const result = (0, import_child_process16.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;
@@ -13237,21 +13324,21 @@ 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_process15.execSync)(`kill -15 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
+        (0, import_child_process16.execSync)(`kill -15 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
         console.log(`[DevServer] EP929: Sent SIGTERM to PID ${pid}`);
       } catch {
       }
     }
-    await new Promise((resolve8) => setTimeout(resolve8, 1e3));
+    await new Promise((resolve9) => setTimeout(resolve9, 1e3));
     for (const pid of pids) {
       try {
-        (0, import_child_process15.execSync)(`kill -0 ${pid} 2>/dev/null`, { encoding: "utf8" });
-        (0, import_child_process15.execSync)(`kill -9 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
+        (0, import_child_process16.execSync)(`kill -0 ${pid} 2>/dev/null`, { encoding: "utf8" });
+        (0, import_child_process16.execSync)(`kill -9 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
         console.log(`[DevServer] EP929: Force killed PID ${pid}`);
       } catch {
       }
     }
-    await new Promise((resolve8) => setTimeout(resolve8, 500));
+    await new Promise((resolve9) => setTimeout(resolve9, 500));
     const stillInUse = await isPortInUse(port);
     if (stillInUse) {
       console.error(`[DevServer] EP929: Port ${port} still in use after kill attempts`);
@@ -13271,7 +13358,7 @@ async function waitForPort(port, timeoutMs = 3e4) {
     if (await isPortInUse(port)) {
       return true;
     }
-    await new Promise((resolve8) => setTimeout(resolve8, checkInterval));
+    await new Promise((resolve9) => setTimeout(resolve9, checkInterval));
   }
   return false;
 }
@@ -13297,7 +13384,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_process15.spawn)(cmd, args, {
+  const devProcess = (0, import_child_process16.spawn)(cmd, args, {
     cwd: projectPath,
     env: mergedEnv,
     stdio: ["ignore", "pipe", "pipe"],
@@ -13343,7 +13430,7 @@ async function handleProcessExit(moduleUid, code, signal) {
   const delay = calculateRestartDelay(serverInfo.restartCount);
   console.log(`[DevServer] EP932: Restarting ${moduleUid} in ${delay}ms (attempt ${serverInfo.restartCount + 1}/${MAX_RESTART_ATTEMPTS})`);
   writeToLog(serverInfo.logFile || "", `Scheduling restart in ${delay}ms (attempt ${serverInfo.restartCount + 1})`, false);
-  await new Promise((resolve8) => setTimeout(resolve8, delay));
+  await new Promise((resolve9) => setTimeout(resolve9, delay));
   if (!activeServers.has(moduleUid)) {
     console.log(`[DevServer] EP932: Server ${moduleUid} was removed during restart delay, aborting restart`);
     return;
@@ -13391,7 +13478,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_core14.loadConfig)();
+    const config = await (0, import_core16.loadConfig)();
     if (config?.access_token && config?.project_id) {
       const apiUrl = config.api_url || "https://episoda.dev";
       const result = await fetchEnvVarsWithCache(apiUrl, config.access_token, {
@@ -13401,8 +13488,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 = path31.join(projectPath, ".env");
-      if (!fs31.existsSync(envFilePath) && Object.keys(injectedEnvVars).length > 0) {
+      const envFilePath = path32.join(projectPath, ".env");
+      if (!fs32.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);
       }
@@ -13468,7 +13555,7 @@ async function stopDevServer(moduleUid) {
       writeToLog(serverInfo.logFile, `Stopping server (manual stop)`, false);
     }
     serverInfo.process.kill("SIGTERM");
-    await new Promise((resolve8) => setTimeout(resolve8, 2e3));
+    await new Promise((resolve9) => setTimeout(resolve9, 2e3));
     if (!serverInfo.process.killed) {
       serverInfo.process.kill("SIGKILL");
     }
@@ -13486,7 +13573,7 @@ async function restartDevServer(moduleUid) {
     writeToLog(logFile, `Manual restart requested`, false);
   }
   await stopDevServer(moduleUid);
-  await new Promise((resolve8) => setTimeout(resolve8, 1e3));
+  await new Promise((resolve9) => setTimeout(resolve9, 1e3));
   if (await isPortInUse(port)) {
     await killProcessOnPort(port);
   }
@@ -13507,6 +13594,32 @@ function getDevServerStatus() {
   }));
 }
 
+// src/ipc/protocol-version.ts
+var PROTOCOL_VERSION = "1";
+
+// src/cli-version.ts
+var import_fs2 = require("fs");
+var import_path = require("path");
+var FALLBACK_CLI_VERSION = "0.2.206";
+function getCliVersion() {
+  const candidatePaths = [
+    (0, import_path.resolve)(__dirname, "..", "package.json"),
+    (0, import_path.resolve)(__dirname, "../../package.json")
+  ];
+  for (const candidatePath of candidatePaths) {
+    try {
+      if (!(0, import_fs2.existsSync)(candidatePath)) continue;
+      const parsed = JSON.parse((0, import_fs2.readFileSync)(candidatePath, "utf8"));
+      if (typeof parsed.version === "string" && parsed.version.length > 0) {
+        return parsed.version;
+      }
+    } catch {
+    }
+  }
+  return FALLBACK_CLI_VERSION;
+}
+var CLI_VERSION = getCliVersion();
+
 // src/daemon/ipc-router.ts
 var IPCRouter = class {
   constructor(host, ipcServer) {
@@ -13521,6 +13634,9 @@ var IPCRouter = class {
       return { status: "ok" };
     });
     this.ipcServer.on("status", async () => {
+      const lifecycleMetadata = readDaemonLifecycleMetadata();
+      const pinnedVersion = process.env.EPISODA_CLI_PIN_VERSION || null;
+      const installChannel = process.env.EPISODA_CLI_INSTALL_CHANNEL || "embedded";
       const projects = getAllProjects().map((p) => ({
         id: p.id,
         path: p.path,
@@ -13543,6 +13659,16 @@ var IPCRouter = class {
         hostname: os15.hostname(),
         platform: os15.platform(),
         arch: os15.arch(),
+        daemonVersion: CLI_VERSION,
+        protocolVersion: PROTOCOL_VERSION,
+        installChannel,
+        serviceMode: lifecycleMetadata.serviceMode,
+        updatePolicy: "manual",
+        updateState: pinnedVersion ? "pinned" : installChannel === "linked" ? "linked" : "manual",
+        pinnedVersion,
+        lastRestartReason: lifecycleMetadata.lastRestartReason,
+        lastStartedAt: lifecycleMetadata.lastStartedAt,
+        attachedProjects: projects,
         projects
       };
     });
@@ -13568,7 +13694,7 @@ var IPCRouter = class {
           if (attempt < MAX_RETRIES) {
             const delay = INITIAL_DELAY * Math.pow(2, attempt - 1);
             console.log(`[Daemon] Retrying in ${delay / 1e3}s...`);
-            await new Promise((resolve8) => setTimeout(resolve8, delay));
+            await new Promise((resolve9) => setTimeout(resolve9, delay));
             await this.host.disconnectProject(projectPath);
           }
         }
@@ -13621,7 +13747,7 @@ var IPCRouter = class {
       };
     });
     this.ipcServer.on("verify-server-connection", async () => {
-      const config = await (0, import_core15.loadConfig)();
+      const config = await (0, import_core17.loadConfig)();
       if (!config?.access_token || !config?.api_url) {
         return {
           verified: false,
@@ -13744,331 +13870,19 @@ var IPCRouter = class {
 };
 
 // src/daemon/update-manager.ts
-var fs32 = __toESM(require("fs"));
-var path32 = __toESM(require("path"));
-var import_child_process17 = require("child_process");
-var import_core17 = __toESM(require_dist());
-var semver2 = __toESM(require("semver"));
-
-// src/utils/update-checker.ts
-var import_child_process16 = require("child_process");
-var semver = __toESM(require("semver"));
-
-// src/ipc/ipc-client.ts
-var import_core16 = __toESM(require_dist());
-
-// src/utils/update-checker.ts
-var PACKAGE_NAME = "@episoda/cli";
-var LEGACY_PACKAGE_NAME = "episoda";
-var NPM_REGISTRY = "https://registry.npmjs.org";
-function isFileLinkedInstall() {
-  try {
-    const output = (0, import_child_process16.execSync)(`npm list -g ${PACKAGE_NAME} --json`, {
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 1e4
-    }).toString();
-    const data = JSON.parse(output);
-    const resolved = data?.dependencies?.[PACKAGE_NAME]?.resolved;
-    return typeof resolved === "string" && resolved.startsWith("file:");
-  } catch {
-    return false;
-  }
-}
-async function checkForUpdates(currentVersion) {
-  const isLinked = isFileLinkedInstall();
-  if (isLinked) {
-    return {
-      currentVersion,
-      latestVersion: currentVersion,
-      updateAvailable: false,
-      isLinked: true
-    };
-  }
-  try {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 5e3);
-    const response = await fetch(`${NPM_REGISTRY}/${PACKAGE_NAME}/latest`, {
-      signal: controller.signal
-    });
-    clearTimeout(timeoutId);
-    if (!response.ok) {
-      return { currentVersion, latestVersion: currentVersion, updateAvailable: false };
-    }
-    const data = await response.json();
-    const latestVersion = data.version;
-    return {
-      currentVersion,
-      latestVersion,
-      updateAvailable: semver.gt(latestVersion, currentVersion)
-    };
-  } catch (error) {
-    return { currentVersion, latestVersion: currentVersion, updateAvailable: false, offline: true };
-  }
-}
-function performSyncUpdate(targetVersion) {
-  try {
-    (0, import_child_process16.execSync)(`npm install -g ${PACKAGE_NAME}@${targetVersion}`, {
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 12e4
-      // 2 minute timeout
-    });
-    return { success: true };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error)
-    };
+var UpdateManager = class {
+  constructor(_host, _currentVersion, _daemonEntryFile) {
+    this._host = _host;
+    this._currentVersion = _currentVersion;
+    this._daemonEntryFile = _daemonEntryFile;
   }
-}
-function getInstalledVersion() {
-  try {
-    const output = (0, import_child_process16.execSync)(`npm list -g ${PACKAGE_NAME} --json`, {
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 1e4
-    }).toString();
-    const data = JSON.parse(output);
-    return data?.dependencies?.[PACKAGE_NAME]?.version || null;
-  } catch {
-    return null;
-  }
-}
-function getLegacyInstalledVersion() {
-  try {
-    const output = (0, import_child_process16.execSync)(`npm list -g ${LEGACY_PACKAGE_NAME} --json`, {
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 1e4
-    }).toString();
-    const data = JSON.parse(output);
-    return data?.dependencies?.[LEGACY_PACKAGE_NAME]?.version || null;
-  } catch {
-    return null;
-  }
-}
-function detectCliInstallChannel(embeddedVersion) {
-  const scopedVersion = getInstalledVersion();
-  const legacyVersion = getLegacyInstalledVersion();
-  const effectiveVersion = scopedVersion || legacyVersion || embeddedVersion || null;
-  return {
-    scopedVersion,
-    legacyVersion,
-    legacyOnly: !scopedVersion && !!legacyVersion,
-    effectiveVersion
-  };
-}
-function resolveEffectiveCliVersion(embeddedVersion) {
-  const installedVersion = detectCliInstallChannel(embeddedVersion).effectiveVersion;
-  if (!installedVersion) {
-    return embeddedVersion;
-  }
-  if (semver.valid(installedVersion) && semver.valid(embeddedVersion)) {
-    return semver.gt(installedVersion, embeddedVersion) ? installedVersion : embeddedVersion;
-  }
-  return installedVersion === embeddedVersion ? embeddedVersion : installedVersion;
-}
-
-// src/daemon/update-manager.ts
-var UpdateManager = class _UpdateManager {
-  constructor(host, currentVersion, daemonEntryFile) {
-    this.host = host;
-    this.currentVersion = currentVersion;
-    this.daemonEntryFile = daemonEntryFile;
-    this.pendingUpdateVersion = null;
-    this.updateInProgress = false;
-    // EP1324: Retry limiting for failed update attempts
-    this.lastFailedUpdateVersion = null;
-    this.updateFailedAttempts = 0;
-    // EP1319: Periodic CLI auto-update for long-lived containers
-    this.updateCheckInterval = null;
-  }
-  static {
-    this.UPDATE_CHECK_INTERVAL_MS = 4 * 60 * 60 * 1e3;
-  }
-  static {
-    // 4 hours
-    this.MAX_UPDATE_ATTEMPTS = 3;
-  }
-  /**
-   * Prefer installed CLI version when it's newer than embedded bundle metadata.
-   * This avoids update churn when daemon bundle version lags package install version.
-   */
-  getEffectiveCurrentVersion() {
-    return resolveEffectiveCliVersion(this.currentVersion);
-  }
-  isTargetVersionNewer(targetVersion, currentVersion) {
-    if (semver2.valid(targetVersion) && semver2.valid(currentVersion)) {
-      return semver2.gt(targetVersion, currentVersion);
-    }
-    return targetVersion !== currentVersion;
-  }
-  /**
-   * Start periodic update checks (every 4 hours).
-   * Does nothing if EPISODA_CLI_PIN_VERSION is set.
-   */
   startPeriodicChecks() {
-    if (process.env.EPISODA_CLI_PIN_VERSION) {
-      console.log(`[Daemon] EP1319: CLI version pinned to ${process.env.EPISODA_CLI_PIN_VERSION}, periodic updates disabled`);
-      return;
-    }
-    this.updateCheckInterval = setInterval(() => {
-      this.periodicUpdateCheck();
-    }, _UpdateManager.UPDATE_CHECK_INTERVAL_MS);
-    this.updateCheckInterval.unref();
-    console.log("[Daemon] EP1319: Periodic update check started (every 4 hours)");
   }
-  /**
-   * Stop periodic update checks. Call during shutdown.
-   */
   stopPeriodicChecks() {
-    if (this.updateCheckInterval) {
-      clearInterval(this.updateCheckInterval);
-      this.updateCheckInterval = null;
-    }
   }
-  /**
-   * EP1319: Apply deferred update when agent sessions become idle.
-   * Called from WS disconnect handler when pending update exists.
-   */
   applyPendingUpdateIfIdle() {
-    if (this.pendingUpdateVersion && this.getActiveAgentSessionCount() === 0) {
-      const pending = this.pendingUpdateVersion;
-      this.pendingUpdateVersion = null;
-      void this.applyUpdateIfIdle(pending, "idle");
-    }
   }
-  /**
-   * EP783: Check for CLI updates on startup (non-blocking).
-   * Fails silently on errors.
-   */
   async checkOnStartup() {
-    if (process.env.EPISODA_CLI_PIN_VERSION) {
-      return;
-    }
-    try {
-      const effectiveCurrentVersion = this.getEffectiveCurrentVersion();
-      const result = await checkForUpdates(effectiveCurrentVersion);
-      if (result.updateAvailable) {
-        await this.applyUpdateIfIdle(result.latestVersion, "startup");
-      }
-    } catch (error) {
-    }
-  }
-  /**
-   * EP1319: Determine if any agent sessions are actively running.
-   * More accurate than liveConnections.size, which only reflects WebSocket connectivity.
-   */
-  getActiveAgentSessionCount() {
-    try {
-      const agentManager = getAgentControlPlane();
-      const sessions2 = agentManager.getAllSessions();
-      return sessions2.filter((session) => ["starting", "running", "stopping"].includes(session.status)).length;
-    } catch {
-      return 0;
-    }
-  }
-  async applyUpdateIfIdle(targetVersion, source) {
-    if (this.updateInProgress) return;
-    const effectiveCurrentVersion = this.getEffectiveCurrentVersion();
-    if (!this.isTargetVersionNewer(targetVersion, effectiveCurrentVersion)) {
-      console.log(`[Daemon] EP1390: Skipping update target=${targetVersion}, current=${effectiveCurrentVersion} (source=${source})`);
-      return;
-    }
-    if (this.lastFailedUpdateVersion === targetVersion && this.updateFailedAttempts >= _UpdateManager.MAX_UPDATE_ATTEMPTS) {
-      console.log(`[Daemon] EP1324: Skipping update to ${targetVersion} after ${this.updateFailedAttempts} failed attempts`);
-      return;
-    }
-    const activeAgentSessions = this.getActiveAgentSessionCount();
-    if (activeAgentSessions > 0) {
-      this.pendingUpdateVersion = targetVersion;
-      console.log(`[Daemon] EP1319: Update available (${effectiveCurrentVersion} \u2192 ${targetVersion}) but ${activeAgentSessions} active agent session(s) \u2014 deferring`);
-      return;
-    }
-    const latestEffectiveCurrent = this.getEffectiveCurrentVersion();
-    if (!this.isTargetVersionNewer(targetVersion, latestEffectiveCurrent)) {
-      console.log(`[Daemon] EP1390: Update no longer needed target=${targetVersion}, current=${latestEffectiveCurrent}`);
-      return;
-    }
-    this.updateInProgress = true;
-    console.log(`[Daemon] EP1319: Applying CLI update (${source}) to ${targetVersion} (idle)`);
-    try {
-      const installResult = performSyncUpdate(targetVersion);
-      if (!installResult.success) {
-        this.recordUpdateFailure(targetVersion, `Install failed: ${installResult.error}`);
-        return;
-      }
-      const installedVersion = getInstalledVersion();
-      if (installedVersion !== targetVersion) {
-        this.recordUpdateFailure(targetVersion, `Version mismatch: expected ${targetVersion}, got ${installedVersion || "unknown"}`);
-        return;
-      }
-      console.log(`[Daemon] EP1324: Update to ${targetVersion} installed, restarting daemon...`);
-      await this.host.shutdown();
-      const configDir = (0, import_core17.getConfigDir)();
-      const logPath = path32.join(configDir, "daemon.log");
-      const logFd = fs32.openSync(logPath, "a");
-      const child = (0, import_child_process17.spawn)("node", [this.daemonEntryFile], {
-        detached: true,
-        stdio: ["ignore", logFd, logFd],
-        cwd: configDir,
-        // Keep daemon process context stable across restarts.
-        env: { ...process.env, EPISODA_DAEMON_MODE: "1" }
-      });
-      if (!child.pid) {
-        try {
-          fs32.closeSync(logFd);
-        } catch {
-        }
-        this.recordUpdateFailure(targetVersion, "Failed to spawn replacement daemon (missing pid)");
-        return;
-      }
-      child.unref();
-      const pidPath = getPidFilePath();
-      fs32.writeFileSync(pidPath, child.pid.toString(), "utf-8");
-      console.log(`[Daemon] EP1324: New daemon spawned (PID: ${child.pid}), exiting old process`);
-      process.exit(0);
-    } catch (error) {
-      this.recordUpdateFailure(targetVersion, error instanceof Error ? error.message : String(error));
-    } finally {
-      this.updateInProgress = false;
-    }
-  }
-  /**
-   * EP1324: Record a failed update attempt and defer for retry.
-   * After MAX_UPDATE_ATTEMPTS for the same version, further attempts are blocked.
-   */
-  recordUpdateFailure(version, reason) {
-    if (this.lastFailedUpdateVersion === version) {
-      this.updateFailedAttempts++;
-    } else {
-      this.lastFailedUpdateVersion = version;
-      this.updateFailedAttempts = 1;
-    }
-    this.pendingUpdateVersion = version;
-    console.warn(`[Daemon] EP1324: Update to ${version} failed (attempt ${this.updateFailedAttempts}/${_UpdateManager.MAX_UPDATE_ATTEMPTS}): ${reason}`);
-  }
-  /**
-   * EP1319: Periodic update check for long-lived containers
-   * Checks npm registry for newer version. If found:
-   *   - No active connections → install immediately via background update
-   *   - Active connections → defer update, store version, retry next interval
-   */
-  async periodicUpdateCheck() {
-    if (process.env.EPISODA_CLI_PIN_VERSION) {
-      return;
-    }
-    try {
-      const effectiveCurrentVersion = this.getEffectiveCurrentVersion();
-      const result = await checkForUpdates(effectiveCurrentVersion);
-      if (!result.updateAvailable) {
-        if (this.pendingUpdateVersion) {
-          console.log(`[Daemon] EP1319: Pending update to ${this.pendingUpdateVersion} is no longer needed (already current)`);
-          this.pendingUpdateVersion = null;
-        }
-        return;
-      }
-      const targetVersion = result.latestVersion;
-      await this.applyUpdateIfIdle(targetVersion, "periodic");
-    } catch (error) {
-    }
   }
 };
 
@@ -14679,7 +14493,7 @@ var HealthOrchestrator = class _HealthOrchestrator {
 };
 
 // src/daemon/daemon-core.ts
-var import_child_process18 = require("child_process");
+var import_child_process17 = require("child_process");
 var DaemonCore = class {
   constructor(host) {
     this.host = host;
@@ -14688,7 +14502,7 @@ var DaemonCore = class {
     const ppid = process.ppid;
     if (!ppid || ppid <= 0) return void 0;
     try {
-      return (0, import_child_process18.execSync)(`ps -p ${ppid} -o command=`, {
+      return (0, import_child_process17.execSync)(`ps -p ${ppid} -o command=`, {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"],
         timeout: 3e3
@@ -14844,7 +14658,7 @@ var ConnectionManager = class {
    * handlers are removed deterministically on every exit path.
    */
   async waitForAuthentication(client, timeoutMs = 3e4) {
-    await new Promise((resolve8, reject) => {
+    await new Promise((resolve9, reject) => {
       let settled = false;
       const cleanup = () => {
         clearTimeout(timeout);
@@ -14863,7 +14677,7 @@ var ConnectionManager = class {
         if (settled) return;
         settled = true;
         cleanup();
-        resolve8();
+        resolve9();
       };
       const authErrorHandler = (message) => {
         if (settled) return;
@@ -15895,8 +15709,8 @@ var Daemon = class _Daemon {
       }
     }
     let releaseLock;
-    const lockPromise = new Promise((resolve8) => {
-      releaseLock = resolve8;
+    const lockPromise = new Promise((resolve9) => {
+      releaseLock = resolve9;
     });
     this.tunnelOperationLocks.set(moduleUid, lockPromise);
     try {
@@ -15942,7 +15756,7 @@ var Daemon = class _Daemon {
         const maxWait = 35e3;
         const startTime = Date.now();
         while (this.connectionManager.hasPendingConnection(projectPath) && Date.now() - startTime < maxWait) {
-          await new Promise((resolve8) => setTimeout(resolve8, 500));
+          await new Promise((resolve9) => setTimeout(resolve9, 500));
         }
         if (this.connectionManager.hasLiveConnection(projectPath)) {
           console.log(`[Daemon] Pending connection succeeded for ${projectPath}`);
@@ -17068,9 +16882,9 @@ var Daemon = class _Daemon {
     console.log(`[Daemon] EP1002: Worktree setup complete for ${moduleUid}`);
   }
   async runForegroundCommand(command, args, cwd, env, timeoutMs) {
-    await new Promise((resolve8, reject) => {
+    await new Promise((resolve9, reject) => {
       const commandLabel = `${command} ${args.join(" ")}`.trim();
-      const child = (0, import_child_process19.spawn)(command, args, {
+      const child = (0, import_child_process18.spawn)(command, args, {
         cwd,
         env,
         stdio: "inherit",
@@ -17091,7 +16905,7 @@ var Daemon = class _Daemon {
           reject(error);
           return;
         }
-        resolve8();
+        resolve9();
       };
       termTimer = setTimeout(() => {
         timedOut = true;