@episoda/cli 0.2.146 → 0.2.148

package/dist/daemon/daemon-process.js

@@ -1880,7 +1880,7 @@ var require_git_executor = __commonJS({
       async executeCloneBare(command, options) {
         try {
           const fs24 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path26 = await Promise.resolve().then(() => __importStar(require("path")));
+          const path25 = await Promise.resolve().then(() => __importStar(require("path")));
           try {
             await fs24.access(command.path);
             return {
@@ -1891,7 +1891,7 @@ var require_git_executor = __commonJS({
             };
           } catch {
           }
-          const parentDir = path26.dirname(command.path);
+          const parentDir = path25.dirname(command.path);
           try {
             await fs24.mkdir(parentDir, { recursive: true });
           } catch {
@@ -1942,13 +1942,13 @@ var require_git_executor = __commonJS({
       async executeProjectInfo(cwd, options) {
         try {
           const fs24 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path26 = await Promise.resolve().then(() => __importStar(require("path")));
+          const path25 = await Promise.resolve().then(() => __importStar(require("path")));
           let currentPath = cwd;
           let projectPath = cwd;
           let bareRepoPath;
           for (let i = 0; i < 10; i++) {
-            const bareDir = path26.join(currentPath, ".bare");
-            const episodaDir = path26.join(currentPath, ".episoda");
+            const bareDir = path25.join(currentPath, ".bare");
+            const episodaDir = path25.join(currentPath, ".episoda");
             try {
               await fs24.access(bareDir);
               await fs24.access(episodaDir);
@@ -1956,7 +1956,7 @@ var require_git_executor = __commonJS({
               bareRepoPath = bareDir;
               break;
             } catch {
-              const parentPath = path26.dirname(currentPath);
+              const parentPath = path25.dirname(currentPath);
               if (parentPath === currentPath) {
                 break;
               }
@@ -2610,29 +2610,29 @@ var require_auth = __commonJS({
     exports2.saveConfig = saveConfig2;
     exports2.validateToken = validateToken;
     var fs24 = __importStar(require("fs"));
-    var path26 = __importStar(require("path"));
+    var path25 = __importStar(require("path"));
     var os10 = __importStar(require("os"));
     var child_process_1 = require("child_process");
     var DEFAULT_CONFIG_FILE = "config.json";
     var hasWarnedMissingProjectId = false;
     var hasWarnedMissingRequiredFields = false;
     function getConfigDir8() {
-      return process.env.EPISODA_CONFIG_DIR || path26.join(os10.homedir(), ".episoda");
+      return process.env.EPISODA_CONFIG_DIR || path25.join(os10.homedir(), ".episoda");
     }
     function getConfigPath(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path26.join(getConfigDir8(), DEFAULT_CONFIG_FILE);
+      return path25.join(getConfigDir8(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path26.dirname(configPath);
+      const dir = path25.dirname(configPath);
       const isNew = !fs24.existsSync(dir);
       if (isNew) {
         fs24.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path26.join(dir, ".nosync");
+        const nosyncPath = path25.join(dir, ".nosync");
         if (isNew || !fs24.existsSync(nosyncPath)) {
           try {
             fs24.writeFileSync(nosyncPath, "", { mode: 384 });
@@ -2913,7 +2913,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@episoda/cli",
-      version: "0.2.145",
+      version: "0.2.148",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -3304,77 +3304,7 @@ var import_child_process2 = require("child_process");
 var semver = __toESM(require("semver"));
 
 // src/ipc/ipc-client.ts
-var net2 = __toESM(require("net"));
-var path5 = __toESM(require("path"));
-var crypto2 = __toESM(require("crypto"));
 var import_core5 = __toESM(require_dist());
-var getSocketPath2 = () => path5.join((0, import_core5.getConfigDir)(), "daemon.sock");
-var DEFAULT_TIMEOUT = 15e3;
-async function sendCommand(command, params, timeout = DEFAULT_TIMEOUT) {
-  return new Promise((resolve4, reject) => {
-    const socket = net2.createConnection(getSocketPath2());
-    const requestId = crypto2.randomUUID();
-    let buffer = "";
-    let timeoutHandle;
-    timeoutHandle = setTimeout(() => {
-      socket.destroy();
-      reject(new Error(`Command timed out after ${timeout}ms`));
-    }, timeout);
-    socket.on("connect", () => {
-      const request2 = {
-        id: requestId,
-        command,
-        params
-      };
-      socket.write(JSON.stringify(request2) + "\n");
-    });
-    socket.on("data", (chunk) => {
-      buffer += chunk.toString();
-      const newlineIndex = buffer.indexOf("\n");
-      if (newlineIndex === -1) return;
-      const message = buffer.slice(0, newlineIndex);
-      try {
-        const response = JSON.parse(message);
-        if (response.id !== requestId) {
-          reject(new Error("Response ID mismatch"));
-          return;
-        }
-        clearTimeout(timeoutHandle);
-        socket.end();
-        if (response.success) {
-          resolve4(response.data);
-        } else {
-          reject(new Error(response.error || "Command failed"));
-        }
-      } catch (error) {
-        clearTimeout(timeoutHandle);
-        socket.end();
-        reject(new Error("Invalid response from daemon"));
-      }
-    });
-    socket.on("error", (error) => {
-      clearTimeout(timeoutHandle);
-      if (error.code === "ENOENT" || error.code === "ECONNREFUSED") {
-        reject(new Error("Daemon is not running. Start it with: episoda dev"));
-      } else {
-        reject(error);
-      }
-    });
-    socket.on("timeout", () => {
-      clearTimeout(timeoutHandle);
-      socket.destroy();
-      reject(new Error("Connection timeout"));
-    });
-  });
-}
-async function isDaemonReachable() {
-  try {
-    await sendCommand("ping", {}, 1e3);
-    return true;
-  } catch (error) {
-    return false;
-  }
-}
 
 // src/utils/update-checker.ts
 var PACKAGE_NAME = "@episoda/cli";
@@ -3438,67 +3368,6 @@ function performSyncUpdate(targetVersion) {
     };
   }
 }
-async function restartDaemon() {
-  try {
-    (0, import_child_process2.execSync)("episoda stop", {
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 1e4
-    });
-    await new Promise((resolve4) => setTimeout(resolve4, 1e3));
-    const child = (0, import_child_process2.spawn)("episoda", ["dev"], {
-      detached: true,
-      stdio: "ignore",
-      shell: true
-    });
-    child.unref();
-    const maxWaitMs = 1e4;
-    const pollIntervalMs = 500;
-    const startTime = Date.now();
-    while (Date.now() - startTime < maxWaitMs) {
-      await new Promise((resolve4) => setTimeout(resolve4, pollIntervalMs));
-      try {
-        const reachable = await isDaemonReachable();
-        if (reachable) {
-          return { success: true };
-        }
-      } catch {
-      }
-    }
-    return {
-      success: false,
-      error: "Daemon did not respond within 10 seconds"
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-async function updateAndRestartDaemon(targetVersion) {
-  const updateResult = performSyncUpdate(targetVersion);
-  if (!updateResult.success) {
-    return {
-      updateSuccess: false,
-      restartSuccess: false,
-      error: `Update failed: ${updateResult.error}`
-    };
-  }
-  const installedVersion = getInstalledVersion();
-  if (installedVersion !== targetVersion) {
-    return {
-      updateSuccess: false,
-      restartSuccess: false,
-      error: `Version mismatch: expected ${targetVersion}, got ${installedVersion || "unknown"}`
-    };
-  }
-  const restartResult = await restartDaemon();
-  return {
-    updateSuccess: true,
-    restartSuccess: restartResult.success,
-    error: restartResult.success ? void 0 : `Restart failed: ${restartResult.error}`
-  };
-}
 function getInstalledVersion() {
   try {
     const output = (0, import_child_process2.execSync)(`npm list -g ${PACKAGE_NAME} --json`, {
@@ -3514,26 +3383,26 @@ function getInstalledVersion() {
 
 // src/daemon/handlers/file-handlers.ts
 var fs5 = __toESM(require("fs"));
-var path7 = __toESM(require("path"));
+var path6 = __toESM(require("path"));
 var readline = __toESM(require("readline"));
 
 // src/daemon/permissions/path-classifier.ts
-var path6 = __toESM(require("path"));
+var path5 = __toESM(require("path"));
 var fs4 = __toESM(require("fs"));
 function classifyPath(targetPath, options) {
   const { workspaceRoot, projectRoot } = options;
-  const normalizedWorkspace = path6.resolve(workspaceRoot);
-  const normalizedProject = path6.resolve(projectRoot);
-  const resolvedPath = path6.isAbsolute(targetPath) ? path6.resolve(targetPath) : path6.resolve(projectRoot, targetPath);
-  const artifactsDir = path6.join(normalizedWorkspace, "artifacts");
-  if (resolvedPath.startsWith(artifactsDir + path6.sep) || resolvedPath === artifactsDir) {
+  const normalizedWorkspace = path5.resolve(workspaceRoot);
+  const normalizedProject = path5.resolve(projectRoot);
+  const resolvedPath = path5.isAbsolute(targetPath) ? path5.resolve(targetPath) : path5.resolve(projectRoot, targetPath);
+  const artifactsDir = path5.join(normalizedWorkspace, "artifacts");
+  if (resolvedPath.startsWith(artifactsDir + path5.sep) || resolvedPath === artifactsDir) {
     return {
       classification: "artifacts",
       resolvedPath
     };
   }
-  if (!resolvedPath.startsWith(normalizedProject + path6.sep) && resolvedPath !== normalizedProject) {
-    if (resolvedPath.startsWith(normalizedWorkspace + path6.sep)) {
+  if (!resolvedPath.startsWith(normalizedProject + path5.sep) && resolvedPath !== normalizedProject) {
+    if (resolvedPath.startsWith(normalizedWorkspace + path5.sep)) {
       return {
         classification: "unknown",
         resolvedPath
@@ -3544,8 +3413,8 @@ function classifyPath(targetPath, options) {
       resolvedPath
     };
   }
-  const relativePath = path6.relative(normalizedProject, resolvedPath);
-  const pathParts = relativePath.split(path6.sep);
+  const relativePath = path5.relative(normalizedProject, resolvedPath);
+  const pathParts = relativePath.split(path5.sep);
   if (pathParts[0] === ".bare") {
     return {
       classification: "bare_repo",
@@ -3560,8 +3429,8 @@ function classifyPath(targetPath, options) {
   }
   const firstPart = pathParts[0];
   if (firstPart && isModuleUidPattern(firstPart)) {
-    const worktreeDir = path6.join(normalizedProject, firstPart);
-    const gitFile = path6.join(worktreeDir, ".git");
+    const worktreeDir = path5.join(normalizedProject, firstPart);
+    const gitFile = path5.join(worktreeDir, ".git");
     const worktreeExists = fs4.existsSync(gitFile) && fs4.statSync(gitFile).isFile();
     return {
       classification: "worktree",
@@ -3579,19 +3448,19 @@ function isModuleUidPattern(str) {
   return /^EP\d+$/.test(str);
 }
 function deriveWorkspaceRoot(projectPath) {
-  return path6.dirname(path6.resolve(projectPath));
+  return path5.dirname(path5.resolve(projectPath));
 }
 function validateWorkspacePath(filePath, projectPath) {
-  const normalizedProjectPath = path6.resolve(projectPath);
+  const normalizedProjectPath = path5.resolve(projectPath);
   const workspaceRoot = deriveWorkspaceRoot(projectPath);
-  const normalizedWorkspace = path6.resolve(workspaceRoot);
-  const artifactsDir = path6.join(normalizedWorkspace, "artifacts");
-  const absolutePath = path6.isAbsolute(filePath) ? path6.resolve(filePath) : path6.resolve(projectPath, filePath);
-  const normalizedPath = path6.normalize(absolutePath);
-  if (normalizedPath.startsWith(normalizedProjectPath + path6.sep) || normalizedPath === normalizedProjectPath) {
+  const normalizedWorkspace = path5.resolve(workspaceRoot);
+  const artifactsDir = path5.join(normalizedWorkspace, "artifacts");
+  const absolutePath = path5.isAbsolute(filePath) ? path5.resolve(filePath) : path5.resolve(projectPath, filePath);
+  const normalizedPath = path5.normalize(absolutePath);
+  if (normalizedPath.startsWith(normalizedProjectPath + path5.sep) || normalizedPath === normalizedProjectPath) {
     return normalizedPath;
   }
-  if (normalizedPath.startsWith(artifactsDir + path6.sep) || normalizedPath === artifactsDir) {
+  if (normalizedPath.startsWith(artifactsDir + path5.sep) || normalizedPath === artifactsDir) {
     return normalizedPath;
   }
   return null;
@@ -3748,7 +3617,7 @@ async function handleFileWrite(command, projectPath) {
   }
   try {
     if (createDirs) {
-      const dirPath = path7.dirname(validPath);
+      const dirPath = path6.dirname(validPath);
       if (!fs5.existsSync(dirPath)) {
         fs5.mkdirSync(dirPath, { recursive: true });
       }
@@ -3806,7 +3675,7 @@ async function handleFileList(command, projectPath) {
       const dirEntries = await fs5.promises.readdir(validPath, { withFileTypes: true });
       for (const entry of dirEntries) {
         if (!includeHidden && entry.name.startsWith(".")) continue;
-        const entryPath = path7.join(validPath, entry.name);
+        const entryPath = path6.join(validPath, entry.name);
         const entryStats = await fs5.promises.stat(entryPath);
         entries.push({
           name: entry.name,
@@ -3832,8 +3701,8 @@ async function listDirectoryRecursive(basePath, currentPath, entries, includeHid
   const dirEntries = await fs5.promises.readdir(currentPath, { withFileTypes: true });
   for (const entry of dirEntries) {
     if (!includeHidden && entry.name.startsWith(".")) continue;
-    const entryPath = path7.join(currentPath, entry.name);
-    const relativePath = path7.relative(basePath, entryPath);
+    const entryPath = path6.join(currentPath, entry.name);
+    const relativePath = path6.relative(basePath, entryPath);
     try {
       const entryStats = await fs5.promises.stat(entryPath);
       entries.push({
@@ -3953,8 +3822,8 @@ async function searchFilesRecursive(basePath, currentPath, pattern, files, maxRe
   for (const entry of entries) {
     if (files.length >= maxResults) return;
     if (entry.name.startsWith(".")) continue;
-    const entryPath = path7.join(currentPath, entry.name);
-    const relativePath = path7.relative(basePath, entryPath);
+    const entryPath = path6.join(currentPath, entry.name);
+    const relativePath = path6.relative(basePath, entryPath);
     try {
       if (entry.isDirectory()) {
         await searchFilesRecursive(basePath, entryPath, pattern, files, maxResults);
@@ -4012,7 +3881,7 @@ async function handleFileGrep(command, projectPath) {
 }
 async function grepFile(basePath, filePath, pattern, matches, maxResults) {
   if (matches.length >= maxResults) return;
-  const relativePath = path7.relative(basePath, filePath);
+  const relativePath = path6.relative(basePath, filePath);
   const fileStream = fs5.createReadStream(filePath, { encoding: "utf8" });
   const rl = readline.createInterface({
     input: fileStream,
@@ -4027,7 +3896,7 @@ async function grepFile(basePath, filePath, pattern, matches, maxResults) {
     }
     if (pattern.test(line)) {
       matches.push({
-        file: relativePath || path7.basename(filePath),
+        file: relativePath || path6.basename(filePath),
         line: lineNumber,
         content: line.slice(0, 500)
         // Truncate long lines
@@ -4041,7 +3910,7 @@ async function grepDirectoryRecursive(basePath, currentPath, searchPattern, file
   for (const entry of entries) {
     if (matches.length >= maxResults) return;
     if (entry.name.startsWith(".")) continue;
-    const entryPath = path7.join(currentPath, entry.name);
+    const entryPath = path6.join(currentPath, entry.name);
     try {
       if (entry.isDirectory()) {
         await grepDirectoryRecursive(basePath, entryPath, searchPattern, filePattern, matches, maxResults);
@@ -4132,7 +4001,7 @@ async function handleFileDelete(command, projectPath) {
       error: "Invalid path: directory traversal not allowed"
     };
   }
-  const normalizedProjectPath = path7.resolve(projectPath);
+  const normalizedProjectPath = path6.resolve(projectPath);
   if (validPath === normalizedProjectPath) {
     return {
       success: false,
@@ -4230,13 +4099,13 @@ async function handleFileMkdir(command, projectPath) {
 
 // src/daemon/handlers/exec-handler.ts
 var import_child_process3 = require("child_process");
-var DEFAULT_TIMEOUT2 = 3e4;
+var DEFAULT_TIMEOUT = 3e4;
 var MAX_TIMEOUT = 3e5;
 async function handleExec(command, projectPath) {
   const {
     command: cmd,
     cwd = projectPath,
-    timeout = DEFAULT_TIMEOUT2,
+    timeout = DEFAULT_TIMEOUT,
     env = {}
   } = command;
   const effectiveTimeout = Math.min(Math.max(timeout, 1e3), MAX_TIMEOUT);
@@ -4312,7 +4181,7 @@ async function handleExec(command, projectPath) {
 }
 
 // src/daemon/handlers/worktree-handlers.ts
-var path17 = __toESM(require("path"));
+var path16 = __toESM(require("path"));
 var fs15 = __toESM(require("fs"));
 var os6 = __toESM(require("os"));
 var import_child_process8 = require("child_process");
@@ -4320,7 +4189,7 @@ var import_util = require("util");
 
 // src/daemon/worktree-manager.ts
 var fs6 = __toESM(require("fs"));
-var path8 = __toESM(require("path"));
+var path7 = __toESM(require("path"));
 var import_core6 = __toESM(require_dist());
 function validateModuleUid(moduleUid) {
   if (!moduleUid || typeof moduleUid !== "string" || !moduleUid.trim()) {
@@ -4344,8 +4213,8 @@ var WorktreeManager = class _WorktreeManager {
     // ============================================================
     this.lockPath = "";
     this.projectRoot = projectRoot;
-    this.bareRepoPath = path8.join(projectRoot, ".bare");
-    this.configPath = path8.join(projectRoot, ".episoda", "config.json");
+    this.bareRepoPath = path7.join(projectRoot, ".bare");
+    this.configPath = path7.join(projectRoot, ".episoda", "config.json");
     this.gitExecutor = new import_core6.GitExecutor();
   }
   /**
@@ -4421,7 +4290,7 @@ var WorktreeManager = class _WorktreeManager {
    */
   static async createProject(projectRoot, repoUrl, projectId, workspaceSlug, projectSlug) {
     const manager = new _WorktreeManager(projectRoot);
-    const episodaDir = path8.join(projectRoot, ".episoda");
+    const episodaDir = path7.join(projectRoot, ".episoda");
     fs6.mkdirSync(episodaDir, { recursive: true });
     const cloneResult = await manager.gitExecutor.execute({
       action: "clone_bare",
@@ -4453,8 +4322,8 @@ var WorktreeManager = class _WorktreeManager {
         error: `Invalid module UID: "${moduleUid}" - contains disallowed characters`
       };
     }
-    const worktreePath = path8.join(this.projectRoot, moduleUid);
-    const normalizedWorktreePath = path8.resolve(worktreePath);
+    const worktreePath = path7.join(this.projectRoot, moduleUid);
+    const normalizedWorktreePath = path7.resolve(worktreePath);
     const lockAcquired = await this.acquireLock();
     if (!lockAcquired) {
       return {
@@ -4476,7 +4345,7 @@ var WorktreeManager = class _WorktreeManager {
           action: "worktree_list"
         }, { cwd: this.bareRepoPath });
         const worktrees = listResult.details?.worktrees || [];
-        const matching = worktrees.find((w) => path8.resolve(w.path) === normalizedWorktreePath);
+        const matching = worktrees.find((w) => path7.resolve(w.path) === normalizedWorktreePath);
         if (matching) {
           const adoptedWorktree = {
             moduleUid,
@@ -4736,7 +4605,7 @@ var WorktreeManager = class _WorktreeManager {
     try {
       const validation = await this.validateWorktrees();
       for (const orphanPath of validation.orphaned) {
-        const dirName = path8.basename(orphanPath);
+        const dirName = path7.basename(orphanPath);
         const isModuleWorktree = /^EP\d+$/.test(dirName);
         if (!isModuleWorktree) {
           console.log(`[WorktreeManager] EP1190: Found non-module worktree: ${dirName}`);
@@ -4872,7 +4741,7 @@ var WorktreeManager = class _WorktreeManager {
       // Turborepo cache
     ];
     for (const cacheDir of cacheDirs) {
-      const cachePath = path8.join(worktreePath, cacheDir);
+      const cachePath = path7.join(worktreePath, cacheDir);
       try {
         if (fs6.existsSync(cachePath)) {
           console.log(`[WorktreeManager] EP1070: Cleaning build cache: ${cacheDir}`);
@@ -4902,7 +4771,7 @@ var WorktreeManager = class _WorktreeManager {
   }
   writeConfig(config) {
     try {
-      const dir = path8.dirname(this.configPath);
+      const dir = path7.dirname(this.configPath);
       if (!fs6.existsSync(dir)) {
         fs6.mkdirSync(dir, { recursive: true });
       }
@@ -4988,10 +4857,10 @@ var WorktreeManager = class _WorktreeManager {
     }
     try {
       for (const file of files) {
-        const srcPath = path8.join(mainWorktree.worktreePath, file);
-        const destPath = path8.join(worktree.worktreePath, file);
+        const srcPath = path7.join(mainWorktree.worktreePath, file);
+        const destPath = path7.join(worktree.worktreePath, file);
         if (fs6.existsSync(srcPath)) {
-          const destDir = path8.dirname(destPath);
+          const destDir = path7.dirname(destPath);
           if (!fs6.existsSync(destDir)) {
             fs6.mkdirSync(destDir, { recursive: true });
           }
@@ -5084,10 +4953,10 @@ function getEpisodaRoot() {
   if (process.env.EPISODA_MODE === "cloud") {
     return process.env.HOME || "/home/episoda";
   }
-  return path8.join(require("os").homedir(), "episoda");
+  return path7.join(require("os").homedir(), "episoda");
 }
 function getProjectPath(workspaceSlug, projectSlug) {
-  return path8.join(getEpisodaRoot(), workspaceSlug, projectSlug);
+  return path7.join(getEpisodaRoot(), workspaceSlug, projectSlug);
 }
 async function isWorktreeProject(projectRoot) {
   const debug = process.env.EPISODA_DEBUG === "1" || process.env.GIT_CREDENTIAL_EPISODA_DEBUG === "1";
@@ -5102,7 +4971,7 @@ async function isWorktreeProject(projectRoot) {
   return result;
 }
 async function findProjectRoot(startPath) {
-  let current = path8.resolve(startPath);
+  let current = path7.resolve(startPath);
   const episodaRoot = getEpisodaRoot();
   const debug = process.env.EPISODA_DEBUG === "1" || process.env.GIT_CREDENTIAL_EPISODA_DEBUG === "1";
   if (debug) {
@@ -5115,8 +4984,8 @@ async function findProjectRoot(startPath) {
     return null;
   }
   for (let i = 0; i < 10; i++) {
-    const bareDir = path8.join(current, ".bare");
-    const episodaDir = path8.join(current, ".episoda");
+    const bareDir = path7.join(current, ".bare");
+    const episodaDir = path7.join(current, ".episoda");
     if (debug) {
       const bareExists = fs6.existsSync(bareDir);
       const episodaExists = fs6.existsSync(episodaDir);
@@ -5130,7 +4999,7 @@ async function findProjectRoot(startPath) {
         return current;
       }
     }
-    const parent = path8.dirname(current);
+    const parent = path7.dirname(current);
     if (parent === current) {
       break;
     }
@@ -5169,15 +5038,15 @@ var import_fs = require("fs");
 var import_child_process5 = require("child_process");
 var http = __toESM(require("http"));
 var fs10 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var path11 = __toESM(require("path"));
 var import_events = require("events");
 var import_core7 = __toESM(require_dist());
 
 // src/utils/port-check.ts
-var net3 = __toESM(require("net"));
+var net2 = __toESM(require("net"));
 async function isPortInUse(port) {
   return new Promise((resolve4) => {
-    const server = net3.createServer();
+    const server = net2.createServer();
     server.once("error", (err) => {
       if (err.code === "EADDRINUSE") {
         resolve4(true);
@@ -5195,12 +5064,12 @@ async function isPortInUse(port) {
 
 // src/utils/env-cache.ts
 var fs8 = __toESM(require("fs"));
-var path10 = __toESM(require("path"));
+var path9 = __toESM(require("path"));
 var os = __toESM(require("os"));
 
 // src/utils/env-setup.ts
 var fs7 = __toESM(require("fs"));
-var path9 = __toESM(require("path"));
+var path8 = __toESM(require("path"));
 async function fetchEnvVars(apiUrl, accessToken) {
   try {
     const url = `${apiUrl}/api/cli/env-vars`;
@@ -5235,16 +5104,16 @@ function writeEnvFile(targetPath, envVars) {
     }
     return `${key}=${value}`;
   }).join("\n") + "\n";
-  const envPath = path9.join(targetPath, ".env");
+  const envPath = path8.join(targetPath, ".env");
   fs7.writeFileSync(envPath, envContent, { mode: 384 });
   console.log(`[env-setup] Wrote ${Object.keys(envVars).length} env vars to ${envPath}`);
 }
 
 // src/utils/env-cache.ts
 var DEFAULT_CACHE_TTL = 60;
-var CACHE_DIR = path10.join(os.homedir(), ".episoda", "cache");
+var CACHE_DIR = path9.join(os.homedir(), ".episoda", "cache");
 function getCacheFilePath(projectId) {
-  return path10.join(CACHE_DIR, `env-vars-${projectId}.json`);
+  return path9.join(CACHE_DIR, `env-vars-${projectId}.json`);
 }
 function ensureCacheDir() {
   if (!fs8.existsSync(CACHE_DIR)) {
@@ -5346,10 +5215,10 @@ No cached values available as fallback.`
 
 // src/preview/dev-server-registry.ts
 var fs9 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
+var path10 = __toESM(require("path"));
 var os2 = __toESM(require("os"));
 var import_child_process4 = require("child_process");
-var DEV_SERVER_REGISTRY_DIR = path11.join(os2.homedir(), ".episoda", "dev-servers");
+var DEV_SERVER_REGISTRY_DIR = path10.join(os2.homedir(), ".episoda", "dev-servers");
 var DevServerRegistry = class {
   constructor() {
     this.ensureRegistryDir();
@@ -5372,7 +5241,7 @@ var DevServerRegistry = class {
    * Get the registry file path for a module
    */
   getEntryPath(moduleUid) {
-    return path11.join(DEV_SERVER_REGISTRY_DIR, `${moduleUid}.json`);
+    return path10.join(DEV_SERVER_REGISTRY_DIR, `${moduleUid}.json`);
   }
   /**
    * Register a dev server
@@ -5883,7 +5752,7 @@ var DevServerRunner = class extends import_events.EventEmitter {
         cacheTtl: 300
       });
       console.log(`[DevServerRunner] Loaded ${Object.keys(result.envVars).length} env vars`);
-      const envFilePath = path12.join(projectPath, ".env");
+      const envFilePath = path11.join(projectPath, ".env");
       if (!fs10.existsSync(envFilePath) && Object.keys(result.envVars).length > 0) {
         console.log(`[DevServerRunner] Writing .env file`);
         writeEnvFile(projectPath, result.envVars);
@@ -6033,14 +5902,14 @@ var DevServerRunner = class extends import_events.EventEmitter {
     return new Promise((resolve4) => setTimeout(resolve4, ms));
   }
   getLogsDir() {
-    const logsDir = path12.join((0, import_core7.getConfigDir)(), "logs");
+    const logsDir = path11.join((0, import_core7.getConfigDir)(), "logs");
     if (!fs10.existsSync(logsDir)) {
       fs10.mkdirSync(logsDir, { recursive: true });
     }
     return logsDir;
   }
   getLogFilePath(moduleUid) {
-    return path12.join(this.getLogsDir(), `dev-${moduleUid}.log`);
+    return path11.join(this.getLogsDir(), `dev-${moduleUid}.log`);
   }
   rotateLogIfNeeded(logPath) {
     try {
@@ -6093,13 +5962,13 @@ function getDevServerRunner() {
 var import_child_process7 = require("child_process");
 var import_events2 = require("events");
 var fs12 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
+var path13 = __toESM(require("path"));
 var os4 = __toESM(require("os"));
 
 // src/tunnel/cloudflared-manager.ts
 var import_child_process6 = require("child_process");
 var fs11 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
+var path12 = __toESM(require("path"));
 var os3 = __toESM(require("os"));
 var https = __toESM(require("https"));
 var tar = __toESM(require("tar"));
@@ -6118,11 +5987,11 @@ var DOWNLOAD_URLS = {
   }
 };
 function getEpisodaBinDir() {
-  return path13.join(os3.homedir(), ".episoda", "bin");
+  return path12.join(os3.homedir(), ".episoda", "bin");
 }
 function getCloudflaredPath() {
   const binaryName = os3.platform() === "win32" ? "cloudflared.exe" : "cloudflared";
-  return path13.join(getEpisodaBinDir(), binaryName);
+  return path12.join(getEpisodaBinDir(), binaryName);
 }
 function isCloudflaredInPath() {
   try {
@@ -6220,7 +6089,7 @@ async function downloadCloudflared() {
   fs11.mkdirSync(binDir, { recursive: true });
   const isTgz = url.endsWith(".tgz");
   if (isTgz) {
-    const tempFile = path13.join(binDir, "cloudflared.tgz");
+    const tempFile = path12.join(binDir, "cloudflared.tgz");
     console.log(`[Tunnel] Downloading cloudflared from ${url}...`);
     await downloadFile(url, tempFile);
     console.log("[Tunnel] Extracting cloudflared...");
@@ -6424,7 +6293,7 @@ function getDaemonModeConfig() {
 }
 
 // src/tunnel/tunnel-manager.ts
-var TUNNEL_PID_DIR = path14.join(os4.homedir(), ".episoda", "tunnels");
+var TUNNEL_PID_DIR = path13.join(os4.homedir(), ".episoda", "tunnels");
 var TUNNEL_TIMEOUTS = {
   /** Time to wait for Named Tunnel connection (includes API token fetch + connect) */
   NAMED_TUNNEL_CONNECT: 6e4,
@@ -6470,7 +6339,7 @@ var TunnelManager = class extends import_events2.EventEmitter {
    * EP877: Get PID file path for a module
    */
   getPidFilePath(moduleUid) {
-    return path14.join(TUNNEL_PID_DIR, `${moduleUid}.pid`);
+    return path13.join(TUNNEL_PID_DIR, `${moduleUid}.pid`);
   }
   /**
    * EP877: Write PID to file for tracking across restarts
@@ -7086,12 +6955,12 @@ function getTunnelManager() {
 
 // src/utils/port-allocator.ts
 var fs13 = __toESM(require("fs"));
-var path15 = __toESM(require("path"));
+var path14 = __toESM(require("path"));
 var os5 = __toESM(require("os"));
 var PORT_RANGE_START = 3100;
 var PORT_RANGE_END = 3199;
 var PORT_WARNING_THRESHOLD = 80;
-var PORTS_FILE = path15.join(os5.homedir(), ".episoda", "ports.json");
+var PORTS_FILE = path14.join(os5.homedir(), ".episoda", "ports.json");
 var portAssignments = /* @__PURE__ */ new Map();
 var initialized = false;
 function loadFromDisk() {
@@ -7116,7 +6985,7 @@ function loadFromDisk() {
 }
 function saveToDisk() {
   try {
-    const dir = path15.dirname(PORTS_FILE);
+    const dir = path14.dirname(PORTS_FILE);
     if (!fs13.existsSync(dir)) {
       fs13.mkdirSync(dir, { recursive: true });
     }
@@ -7660,16 +7529,16 @@ async function deleteWorktree(config, moduleUid) {
 
 // src/daemon/package-manager.ts
 var fs14 = __toESM(require("fs"));
-var path16 = __toESM(require("path"));
+var path15 = __toESM(require("path"));
 var PACKAGE_MANAGERS = {
   javascript: [
     {
       name: "pnpm",
       detector: (p) => {
-        if (fs14.existsSync(path16.join(p, "pnpm-lock.yaml"))) {
+        if (fs14.existsSync(path15.join(p, "pnpm-lock.yaml"))) {
           return "pnpm-lock.yaml";
         }
-        const pkgJsonPath = path16.join(p, "package.json");
+        const pkgJsonPath = path15.join(p, "package.json");
         if (fs14.existsSync(pkgJsonPath)) {
           try {
             const pkg = JSON.parse(fs14.readFileSync(pkgJsonPath, "utf-8"));
@@ -7688,7 +7557,7 @@ var PACKAGE_MANAGERS = {
     },
     {
       name: "yarn",
-      detector: (p) => fs14.existsSync(path16.join(p, "yarn.lock")) ? "yarn.lock" : null,
+      detector: (p) => fs14.existsSync(path15.join(p, "yarn.lock")) ? "yarn.lock" : null,
       config: {
         installCmd: "yarn install --frozen-lockfile",
         cacheEnvVar: "YARN_CACHE_FOLDER"
@@ -7696,14 +7565,14 @@ var PACKAGE_MANAGERS = {
     },
     {
       name: "bun",
-      detector: (p) => fs14.existsSync(path16.join(p, "bun.lockb")) ? "bun.lockb" : null,
+      detector: (p) => fs14.existsSync(path15.join(p, "bun.lockb")) ? "bun.lockb" : null,
       config: {
         installCmd: "bun install --frozen-lockfile"
       }
     },
     {
       name: "npm",
-      detector: (p) => fs14.existsSync(path16.join(p, "package-lock.json")) ? "package-lock.json" : null,
+      detector: (p) => fs14.existsSync(path15.join(p, "package-lock.json")) ? "package-lock.json" : null,
       config: {
         installCmd: "npm ci"
       }
@@ -7712,7 +7581,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) => fs14.existsSync(path16.join(p, "package.json")) ? "package.json (no lockfile - defaulting to pnpm)" : null,
+      detector: (p) => fs14.existsSync(path15.join(p, "package.json")) ? "package.json (no lockfile - defaulting to pnpm)" : null,
       config: {
         installCmd: "pnpm install",
         cacheEnvVar: "PNPM_HOME"
@@ -7723,8 +7592,8 @@ var PACKAGE_MANAGERS = {
     {
       name: "uv",
       detector: (p) => {
-        const pyprojectPath = path16.join(p, "pyproject.toml");
-        if (fs14.existsSync(path16.join(p, "uv.lock"))) {
+        const pyprojectPath = path15.join(p, "pyproject.toml");
+        if (fs14.existsSync(path15.join(p, "uv.lock"))) {
           return "uv.lock";
         }
         if (fs14.existsSync(pyprojectPath)) {
@@ -7745,7 +7614,7 @@ var PACKAGE_MANAGERS = {
     },
     {
       name: "pip",
-      detector: (p) => fs14.existsSync(path16.join(p, "requirements.txt")) ? "requirements.txt" : null,
+      detector: (p) => fs14.existsSync(path15.join(p, "requirements.txt")) ? "requirements.txt" : null,
       config: {
         installCmd: "pip install -r requirements.txt"
       }
@@ -7819,7 +7688,7 @@ function persistWorkspaceProjectContext(workspaceSlug, projectSlug, projectId) {
     return;
   }
   const homeDir = process.env.HOME || os6.homedir();
-  const workspaceConfigPath = path17.join(
+  const workspaceConfigPath = path16.join(
     homeDir,
     "episoda",
     workspaceSlug,
@@ -7899,19 +7768,19 @@ async function handleWorktreeCreate(request2) {
   }
   try {
     const projectPath = getProjectPath(workspaceSlug, projectSlug);
-    const bareRepoPath = path17.join(projectPath, ".bare");
+    const bareRepoPath = path16.join(projectPath, ".bare");
     const gitEnv = projectId ? { ...process.env, EPISODA_PROJECT_ID: projectId } : process.env;
     if (!fs15.existsSync(bareRepoPath)) {
       console.log(`[Worktree] K1273: Project not found, cloning lazily...`);
       console.log(`[Worktree]   Repo URL: ${repoUrl.replace(/\/\/[^@]*@/, "//***@")}`);
-      const episodaDir = path17.join(projectPath, ".episoda");
+      const episodaDir = path16.join(projectPath, ".episoda");
       fs15.mkdirSync(episodaDir, { recursive: true });
       try {
         console.log(`[Worktree] K1273: Starting git clone...`);
         await execAsync(`git clone --bare "${repoUrl}" "${bareRepoPath}"`, { env: gitEnv });
         console.log(`[Worktree] K1273: Clone successful`);
         await execAsync(`git -C "${bareRepoPath}" config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"`, { env: gitEnv });
-        const configPath = path17.join(episodaDir, "config.json");
+        const configPath = path16.join(episodaDir, "config.json");
         const config2 = {
           projectId,
           workspaceSlug,
@@ -7968,7 +7837,7 @@ async function handleWorktreeCreate(request2) {
     }
     if (envVars && Object.keys(envVars).length > 0) {
       const envContent = Object.entries(envVars).map(([key, value]) => `${key}=${value}`).join("\n");
-      const envPath = path17.join(worktreePath, ".env");
+      const envPath = path16.join(worktreePath, ".env");
       fs15.writeFileSync(envPath, envContent + "\n", "utf-8");
       console.log(`[Worktree] EP1143: Wrote ${Object.keys(envVars).length} env vars to .env`);
     }
@@ -8155,7 +8024,7 @@ async function handleProjectEject(request2) {
   console.log(`[Worktree] EP1144: Ejecting project ${projectSlug} from workspace ${workspaceSlug}`);
   try {
     const projectPath = getProjectPath(workspaceSlug, projectSlug);
-    const bareRepoPath = path17.join(projectPath, ".bare");
+    const bareRepoPath = path16.join(projectPath, ".bare");
     if (!fs15.existsSync(projectPath)) {
       console.log(`[Worktree] EP1144: Project path not found, nothing to eject: ${projectPath}`);
       return { success: true };
@@ -8175,7 +8044,7 @@ async function handleProjectEject(request2) {
         };
       }
     }
-    const artifactsPath = path17.join(projectPath, "artifacts");
+    const artifactsPath = path16.join(projectPath, "artifacts");
     if (fs15.existsSync(artifactsPath)) {
       await persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug);
     }
@@ -8208,7 +8077,7 @@ async function persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug
     }
     const artifacts = [];
     for (const fileName of files) {
-      const filePath = path17.join(artifactsPath, fileName);
+      const filePath = path16.join(artifactsPath, fileName);
       const stat = await fs15.promises.stat(filePath);
       if (stat.isDirectory()) {
         continue;
@@ -8220,7 +8089,7 @@ async function persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug
       try {
         const content = await fs15.promises.readFile(filePath);
         const base64Content = content.toString("base64");
-        const ext = path17.extname(fileName).toLowerCase();
+        const ext = path16.extname(fileName).toLowerCase();
         const mimeTypes = {
           ".json": "application/json",
           ".txt": "text/plain",
@@ -8276,7 +8145,7 @@ async function persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug
 }
 
 // src/daemon/handlers/project-handlers.ts
-var path18 = __toESM(require("path"));
+var path17 = __toESM(require("path"));
 var fs16 = __toESM(require("fs"));
 function validateSlug(slug, fieldName) {
   if (!slug || typeof slug !== "string") {
@@ -8317,9 +8186,9 @@ async function handleProjectSetup(params) {
   console.log(`[ProjectSetup] EP1199: Setting up project ${workspaceSlug}/${projectSlug}`);
   try {
     const projectPath = getProjectPath(workspaceSlug, projectSlug);
-    const artifactsPath = path18.join(projectPath, "artifacts");
-    const configDir = path18.join(projectPath, ".episoda");
-    const configPath = path18.join(configDir, "config.json");
+    const artifactsPath = path17.join(projectPath, "artifacts");
+    const configDir = path17.join(projectPath, ".episoda");
+    const configPath = path17.join(configDir, "config.json");
     await fs16.promises.mkdir(artifactsPath, { recursive: true });
     await fs16.promises.mkdir(configDir, { recursive: true });
     let existingConfig = {};
@@ -8451,7 +8320,7 @@ async function cleanupStaleCommits(projectPath) {
 
 // src/agent/claude-binary.ts
 var import_child_process10 = require("child_process");
-var path19 = __toESM(require("path"));
+var path18 = __toESM(require("path"));
 var fs17 = __toESM(require("fs"));
 var cachedBinaryPath = null;
 function isValidClaudeBinary(binaryPath) {
@@ -8489,11 +8358,11 @@ async function ensureClaudeBinary() {
   }
   const bundledPaths = [
     // In production: node_modules/.bin/claude
-    path19.join(__dirname, "..", "..", "node_modules", ".bin", "claude"),
+    path18.join(__dirname, "..", "..", "node_modules", ".bin", "claude"),
     // In monorepo development: packages/episoda/node_modules/.bin/claude
-    path19.join(__dirname, "..", "..", "..", "..", "node_modules", ".bin", "claude"),
+    path18.join(__dirname, "..", "..", "..", "..", "node_modules", ".bin", "claude"),
     // Root monorepo node_modules
-    path19.join(__dirname, "..", "..", "..", "..", "..", "node_modules", ".bin", "claude")
+    path18.join(__dirname, "..", "..", "..", "..", "..", "node_modules", ".bin", "claude")
   ];
   for (const bundledPath of bundledPaths) {
     if (fs17.existsSync(bundledPath) && isValidClaudeBinary(bundledPath)) {
@@ -8522,7 +8391,7 @@ async function ensureClaudeBinary() {
 
 // src/agent/codex-binary.ts
 var import_child_process11 = require("child_process");
-var path20 = __toESM(require("path"));
+var path19 = __toESM(require("path"));
 var fs18 = __toESM(require("fs"));
 var cachedBinaryPath2 = null;
 function isValidCodexBinary(binaryPath) {
@@ -8560,11 +8429,11 @@ async function ensureCodexBinary() {
   }
   const bundledPaths = [
     // In production: node_modules/.bin/codex
-    path20.join(__dirname, "..", "..", "node_modules", ".bin", "codex"),
+    path19.join(__dirname, "..", "..", "node_modules", ".bin", "codex"),
     // In monorepo development: packages/episoda/node_modules/.bin/codex
-    path20.join(__dirname, "..", "..", "..", "..", "node_modules", ".bin", "codex"),
+    path19.join(__dirname, "..", "..", "..", "..", "node_modules", ".bin", "codex"),
     // Root monorepo node_modules
-    path20.join(__dirname, "..", "..", "..", "..", "..", "node_modules", ".bin", "codex")
+    path19.join(__dirname, "..", "..", "..", "..", "..", "node_modules", ".bin", "codex")
   ];
   for (const bundledPath of bundledPaths) {
     if (fs18.existsSync(bundledPath) && isValidCodexBinary(bundledPath)) {
@@ -8663,7 +8532,7 @@ function generateCodexMcpConfigToml(servers, projectPath) {
 
 // src/agent/agent-manager.ts
 var import_child_process12 = require("child_process");
-var path21 = __toESM(require("path"));
+var path20 = __toESM(require("path"));
 var fs19 = __toESM(require("fs"));
 var os7 = __toESM(require("os"));
 
@@ -8983,7 +8852,7 @@ var AgentManager = class {
     this.initialized = false;
     // EP1133: Lock for config file writes to prevent race conditions
     this.configWriteLock = Promise.resolve();
-    this.pidDir = path21.join(os7.homedir(), ".episoda", "agent-pids");
+    this.pidDir = path20.join(os7.homedir(), ".episoda", "agent-pids");
   }
   /**
    * EP1133: Acquire lock for config file writes
@@ -9040,12 +8909,12 @@ var AgentManager = class {
   }
   loadProviderTokens(provider, sessionDir, legacyDir) {
     if (provider === "codex") {
-      const sessionAuthPath = path21.join(sessionDir, "auth.json");
-      const legacyAuthPath = path21.join(legacyDir, "auth.json");
+      const sessionAuthPath = path20.join(sessionDir, "auth.json");
+      const legacyAuthPath = path20.join(legacyDir, "auth.json");
       return this.readCodexTokensFromPath(sessionAuthPath) || this.readCodexTokensFromPath(legacyAuthPath);
     }
-    const sessionCredentialsPath = path21.join(sessionDir, ".credentials.json");
-    const legacyCredentialsPath = path21.join(legacyDir, ".credentials.json");
+    const sessionCredentialsPath = path20.join(sessionDir, ".credentials.json");
+    const legacyCredentialsPath = path20.join(legacyDir, ".credentials.json");
     return this.readClaudeTokensFromPath(sessionCredentialsPath) || this.readClaudeTokensFromPath(legacyCredentialsPath);
   }
   applyTokensToSession(session, tokens) {
@@ -9123,10 +8992,10 @@ var AgentManager = class {
   findCodexRequirementsToml(sessionProjectPath) {
     const candidates = [];
     if (sessionProjectPath) {
-      candidates.push(path21.join(sessionProjectPath, ".codex", "requirements.toml"));
+      candidates.push(path20.join(sessionProjectPath, ".codex", "requirements.toml"));
     }
-    const codexHome = process.env.CODEX_HOME || path21.join(os7.homedir(), ".codex");
-    candidates.push(path21.join(codexHome, "requirements.toml"));
+    const codexHome = process.env.CODEX_HOME || path20.join(os7.homedir(), ".codex");
+    candidates.push(path20.join(codexHome, "requirements.toml"));
     candidates.push("/etc/codex/requirements.toml");
     for (const p of candidates) {
       if (fs19.existsSync(p)) return p;
@@ -9600,10 +9469,10 @@ If changes are needed, explain what needs to be done.`;
       }
       const useOAuth = !!session.credentials.oauthToken;
       const useApiKey = !useOAuth && !!session.credentials.apiKey;
-      const sessionCodexDir = path21.join(os7.homedir(), ".codex", "sessions", sessionId);
-      const sessionClaudeDir = path21.join(os7.homedir(), ".claude", "sessions", sessionId);
-      const legacyCodexDir = path21.join(os7.homedir(), ".codex");
-      const legacyClaudeDir = path21.join(os7.homedir(), ".claude");
+      const sessionCodexDir = path20.join(os7.homedir(), ".codex", "sessions", sessionId);
+      const sessionClaudeDir = path20.join(os7.homedir(), ".claude", "sessions", sessionId);
+      const legacyCodexDir = path20.join(os7.homedir(), ".codex");
+      const legacyClaudeDir = path20.join(os7.homedir(), ".claude");
       const sessionConfigDir = provider === "codex" ? sessionCodexDir : sessionClaudeDir;
       const legacyConfigDir = provider === "codex" ? legacyCodexDir : legacyClaudeDir;
       if (useOAuth) {
@@ -9627,7 +9496,7 @@ If changes are needed, explain what needs to be done.`;
               accountId: session.credentials.accountId,
               expiresAt: session.credentials.expiresAt
             });
-            const authJsonPath = path21.join(sessionCodexDir, "auth.json");
+            const authJsonPath = path20.join(sessionCodexDir, "auth.json");
             fs19.writeFileSync(authJsonPath, codexConfig["auth.json"], { mode: 384 });
             console.log(`[AgentManager] EP1260: Wrote Codex auth.json to ${authJsonPath}`);
           } else if (useApiKey) {
@@ -9719,13 +9588,13 @@ If changes are needed, explain what needs to be done.`;
               };
             });
             const configTomlContent = generateCodexMcpConfigToml(codexMcpServers, session.projectPath);
-            const configTomlPath = path21.join(sessionCodexDir, "config.toml");
+            const configTomlPath = path20.join(sessionCodexDir, "config.toml");
             fs19.writeFileSync(configTomlPath, configTomlContent, { mode: 384 });
             console.log(`[AgentManager] EP1287: Wrote Codex config.toml at ${configTomlPath} with ${codexMcpServers.length} MCP server(s): ${codexMcpServers.map((s) => s.name).join(", ")}`);
           } else {
             const configTomlContent = generateCodexMcpConfigToml([], session.projectPath);
             if (configTomlContent.trim()) {
-              const configTomlPath = path21.join(sessionCodexDir, "config.toml");
+              const configTomlPath = path20.join(sessionCodexDir, "config.toml");
               fs19.writeFileSync(configTomlPath, configTomlContent, { mode: 420 });
               console.log(`[AgentManager] EP1287: Wrote Codex config.toml (project trust only) at ${configTomlPath}`);
             }
@@ -9733,11 +9602,11 @@ If changes are needed, explain what needs to be done.`;
         });
       } else {
         await this.withConfigLock(async () => {
-          const statsigDir = path21.join(sessionClaudeDir, "statsig");
+          const statsigDir = path20.join(sessionClaudeDir, "statsig");
           fs19.mkdirSync(statsigDir, { recursive: true });
           console.log(`[AgentManager] EP1260: Created session-specific Claude dir: ${sessionClaudeDir}`);
           if (useOAuth) {
-            const credentialsPath = path21.join(sessionClaudeDir, ".credentials.json");
+            const credentialsPath = path20.join(sessionClaudeDir, ".credentials.json");
             const oauthCredentials = {
               accessToken: session.credentials.oauthToken
             };
@@ -9765,10 +9634,10 @@ If changes are needed, explain what needs to be done.`;
               if (!hasEvaluations || !hasStableId) {
                 throw new Error(`Invalid statsig config: missing required files`);
               }
-              const settingsPath = path21.join(sessionClaudeDir, "settings.json");
+              const settingsPath = path20.join(sessionClaudeDir, "settings.json");
               fs19.writeFileSync(settingsPath, claudeConfig["settings.json"], { mode: 384 });
               for (const [filename, content] of Object.entries(claudeConfig.statsig)) {
-                const filePath = path21.join(statsigDir, filename);
+                const filePath = path20.join(statsigDir, filename);
                 fs19.writeFileSync(filePath, content, { mode: 420 });
               }
               console.log("[AgentManager] EP1260: Wrote Claude config files to session directory");
@@ -10163,7 +10032,7 @@ If changes are needed, explain what needs to be done.`;
   cleanupSessionCredentials(sessionId, provider) {
     const providers = provider ? [provider] : ["claude", "codex"];
     for (const p of providers) {
-      const sessionDir = p === "codex" ? path21.join(os7.homedir(), ".codex", "sessions", sessionId) : path21.join(os7.homedir(), ".claude", "sessions", sessionId);
+      const sessionDir = p === "codex" ? path20.join(os7.homedir(), ".codex", "sessions", sessionId) : path20.join(os7.homedir(), ".claude", "sessions", sessionId);
       try {
         if (fs19.existsSync(sessionDir)) {
           fs19.rmSync(sessionDir, { recursive: true, force: true });
@@ -10254,7 +10123,7 @@ If changes are needed, explain what needs to be done.`;
     }
     const pidFiles = fs19.readdirSync(this.pidDir).filter((f) => f.endsWith(".pid"));
     for (const pidFile of pidFiles) {
-      const pidPath = path21.join(this.pidDir, pidFile);
+      const pidPath = path20.join(this.pidDir, pidFile);
       try {
         const pidStr = fs19.readFileSync(pidPath, "utf-8").trim();
         const pid = parseInt(pidStr, 10);
@@ -10281,14 +10150,14 @@ If changes are needed, explain what needs to be done.`;
    * Write PID file for session tracking
    */
   writePidFile(sessionId, pid) {
-    const pidPath = path21.join(this.pidDir, `${sessionId}.pid`);
+    const pidPath = path20.join(this.pidDir, `${sessionId}.pid`);
     fs19.writeFileSync(pidPath, pid.toString());
   }
   /**
    * Remove PID file for session
    */
   removePidFile(sessionId) {
-    const pidPath = path21.join(this.pidDir, `${sessionId}.pid`);
+    const pidPath = path20.join(this.pidDir, `${sessionId}.pid`);
     try {
       if (fs19.existsSync(pidPath)) {
         fs19.unlinkSync(pidPath);
@@ -10504,7 +10373,7 @@ var AgentCommandQueue = class {
 var import_child_process13 = require("child_process");
 var import_core12 = __toESM(require_dist());
 var fs20 = __toESM(require("fs"));
-var path22 = __toESM(require("path"));
+var path21 = __toESM(require("path"));
 var MAX_RESTART_ATTEMPTS = 5;
 var INITIAL_RESTART_DELAY_MS = 2e3;
 var MAX_RESTART_DELAY_MS = 3e4;
@@ -10512,14 +10381,14 @@ var MAX_LOG_SIZE_BYTES = 5 * 1024 * 1024;
 var NODE_MEMORY_LIMIT_MB = 2048;
 var activeServers = /* @__PURE__ */ new Map();
 function getLogsDir() {
-  const logsDir = path22.join((0, import_core12.getConfigDir)(), "logs");
+  const logsDir = path21.join((0, import_core12.getConfigDir)(), "logs");
   if (!fs20.existsSync(logsDir)) {
     fs20.mkdirSync(logsDir, { recursive: true });
   }
   return logsDir;
 }
 function getLogFilePath(moduleUid) {
-  return path22.join(getLogsDir(), `dev-${moduleUid}.log`);
+  return path21.join(getLogsDir(), `dev-${moduleUid}.log`);
 }
 function rotateLogIfNeeded(logPath) {
   try {
@@ -10531,7 +10400,7 @@ function rotateLogIfNeeded(logPath) {
           fs20.unlinkSync(backupPath);
         }
         fs20.renameSync(logPath, backupPath);
-        console.log(`[DevServer] EP932: Rotated log file for ${path22.basename(logPath)}`);
+        console.log(`[DevServer] EP932: Rotated log file for ${path21.basename(logPath)}`);
       }
     }
   } catch (error) {
@@ -10723,7 +10592,7 @@ 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 = path22.join(projectPath, ".env");
+      const envFilePath = path21.join(projectPath, ".env");
       if (!fs20.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);
@@ -10830,7 +10699,7 @@ function getDevServerStatus() {
 }
 
 // src/utils/worktree.ts
-var path23 = __toESM(require("path"));
+var path22 = __toESM(require("path"));
 var fs21 = __toESM(require("fs"));
 var os8 = __toESM(require("os"));
 var import_core13 = __toESM(require_dist());
@@ -10841,11 +10710,11 @@ function getEpisodaRoot2() {
   if (process.env.EPISODA_MODE === "cloud") {
     return process.env.HOME || "/home/episoda";
   }
-  return path23.join(os8.homedir(), "episoda");
+  return path22.join(os8.homedir(), "episoda");
 }
 function getWorktreeInfo(moduleUid, workspaceSlug, projectSlug) {
   const root = getEpisodaRoot2();
-  const worktreePath = path23.join(root, workspaceSlug, projectSlug, moduleUid);
+  const worktreePath = path22.join(root, workspaceSlug, projectSlug, moduleUid);
   return {
     path: worktreePath,
     exists: fs21.existsSync(worktreePath),
@@ -10862,14 +10731,14 @@ async function getWorktreeInfoForModule(moduleUid) {
     return null;
   }
   const root = getEpisodaRoot2();
-  const workspaceRoot = path23.join(root, config.workspace_slug);
+  const workspaceRoot = path22.join(root, config.workspace_slug);
   try {
     const entries = fs21.readdirSync(workspaceRoot, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) {
         continue;
       }
-      const worktreePath = path23.join(workspaceRoot, entry.name, moduleUid);
+      const worktreePath = path22.join(workspaceRoot, entry.name, moduleUid);
       if (fs21.existsSync(worktreePath)) {
         return {
           path: worktreePath,
@@ -10888,59 +10757,59 @@ async function getWorktreeInfoForModule(moduleUid) {
 
 // src/framework-detector.ts
 var fs22 = __toESM(require("fs"));
-var path24 = __toESM(require("path"));
+var path23 = __toESM(require("path"));
 function getInstallCommand2(cwd) {
-  if (fs22.existsSync(path24.join(cwd, "bun.lockb"))) {
+  if (fs22.existsSync(path23.join(cwd, "bun.lockb"))) {
     return {
       command: ["bun", "install"],
       description: "Installing dependencies with bun",
       detectedFrom: "bun.lockb"
     };
   }
-  if (fs22.existsSync(path24.join(cwd, "pnpm-lock.yaml"))) {
+  if (fs22.existsSync(path23.join(cwd, "pnpm-lock.yaml"))) {
     return {
       command: ["pnpm", "install"],
       description: "Installing dependencies with pnpm",
       detectedFrom: "pnpm-lock.yaml"
     };
   }
-  if (fs22.existsSync(path24.join(cwd, "yarn.lock"))) {
+  if (fs22.existsSync(path23.join(cwd, "yarn.lock"))) {
     return {
       command: ["yarn", "install"],
       description: "Installing dependencies with yarn",
       detectedFrom: "yarn.lock"
     };
   }
-  if (fs22.existsSync(path24.join(cwd, "package-lock.json"))) {
+  if (fs22.existsSync(path23.join(cwd, "package-lock.json"))) {
     return {
       command: ["npm", "ci"],
       description: "Installing dependencies with npm ci",
       detectedFrom: "package-lock.json"
     };
   }
-  if (fs22.existsSync(path24.join(cwd, "package.json"))) {
+  if (fs22.existsSync(path23.join(cwd, "package.json"))) {
     return {
       command: ["npm", "install"],
       description: "Installing dependencies with npm",
       detectedFrom: "package.json"
     };
   }
-  if (fs22.existsSync(path24.join(cwd, "Pipfile.lock")) || fs22.existsSync(path24.join(cwd, "Pipfile"))) {
+  if (fs22.existsSync(path23.join(cwd, "Pipfile.lock")) || fs22.existsSync(path23.join(cwd, "Pipfile"))) {
     return {
       command: ["pipenv", "install"],
       description: "Installing dependencies with pipenv",
-      detectedFrom: fs22.existsSync(path24.join(cwd, "Pipfile.lock")) ? "Pipfile.lock" : "Pipfile"
+      detectedFrom: fs22.existsSync(path23.join(cwd, "Pipfile.lock")) ? "Pipfile.lock" : "Pipfile"
     };
   }
-  if (fs22.existsSync(path24.join(cwd, "poetry.lock"))) {
+  if (fs22.existsSync(path23.join(cwd, "poetry.lock"))) {
     return {
       command: ["poetry", "install"],
       description: "Installing dependencies with poetry",
       detectedFrom: "poetry.lock"
     };
   }
-  if (fs22.existsSync(path24.join(cwd, "pyproject.toml"))) {
-    const pyprojectPath = path24.join(cwd, "pyproject.toml");
+  if (fs22.existsSync(path23.join(cwd, "pyproject.toml"))) {
+    const pyprojectPath = path23.join(cwd, "pyproject.toml");
     const content = fs22.readFileSync(pyprojectPath, "utf-8");
     if (content.includes("[tool.poetry]")) {
       return {
@@ -10950,42 +10819,43 @@ function getInstallCommand2(cwd) {
       };
     }
   }
-  if (fs22.existsSync(path24.join(cwd, "requirements.txt"))) {
+  if (fs22.existsSync(path23.join(cwd, "requirements.txt"))) {
     return {
       command: ["pip", "install", "-r", "requirements.txt"],
       description: "Installing dependencies with pip",
       detectedFrom: "requirements.txt"
     };
   }
-  if (fs22.existsSync(path24.join(cwd, "Gemfile.lock")) || fs22.existsSync(path24.join(cwd, "Gemfile"))) {
+  if (fs22.existsSync(path23.join(cwd, "Gemfile.lock")) || fs22.existsSync(path23.join(cwd, "Gemfile"))) {
     return {
       command: ["bundle", "install"],
       description: "Installing dependencies with bundler",
-      detectedFrom: fs22.existsSync(path24.join(cwd, "Gemfile.lock")) ? "Gemfile.lock" : "Gemfile"
+      detectedFrom: fs22.existsSync(path23.join(cwd, "Gemfile.lock")) ? "Gemfile.lock" : "Gemfile"
     };
   }
-  if (fs22.existsSync(path24.join(cwd, "go.sum")) || fs22.existsSync(path24.join(cwd, "go.mod"))) {
+  if (fs22.existsSync(path23.join(cwd, "go.sum")) || fs22.existsSync(path23.join(cwd, "go.mod"))) {
     return {
       command: ["go", "mod", "download"],
       description: "Downloading Go modules",
-      detectedFrom: fs22.existsSync(path24.join(cwd, "go.sum")) ? "go.sum" : "go.mod"
+      detectedFrom: fs22.existsSync(path23.join(cwd, "go.sum")) ? "go.sum" : "go.mod"
     };
   }
-  if (fs22.existsSync(path24.join(cwd, "Cargo.lock")) || fs22.existsSync(path24.join(cwd, "Cargo.toml"))) {
+  if (fs22.existsSync(path23.join(cwd, "Cargo.lock")) || fs22.existsSync(path23.join(cwd, "Cargo.toml"))) {
     return {
       command: ["cargo", "build"],
       description: "Building Rust project (downloads dependencies)",
-      detectedFrom: fs22.existsSync(path24.join(cwd, "Cargo.lock")) ? "Cargo.lock" : "Cargo.toml"
+      detectedFrom: fs22.existsSync(path23.join(cwd, "Cargo.lock")) ? "Cargo.lock" : "Cargo.toml"
     };
   }
   return null;
 }
 
 // src/daemon/daemon-process.ts
+var import_child_process14 = require("child_process");
 var fs23 = __toESM(require("fs"));
 var http2 = __toESM(require("http"));
 var os9 = __toESM(require("os"));
-var path25 = __toESM(require("path"));
+var path24 = __toESM(require("path"));
 var packageJson = require_package();
 function getBuildPackagesCommand2(installCmd) {
   const runner = installCmd?.command?.[0];
@@ -11153,6 +11023,9 @@ var Daemon = class _Daemon {
     this.pendingUpdateVersion = null;
     // Deferred update when sessions are active
     this.updateInProgress = false;
+    // EP1324: Retry limiting for failed update attempts
+    this.lastFailedUpdateVersion = null;
+    this.updateFailedAttempts = 0;
     this.ipcServer = new IPCServer();
   }
   static {
@@ -11189,6 +11062,9 @@ var Daemon = class _Daemon {
   static {
     this.UPDATE_CHECK_INTERVAL_MS = 4 * 60 * 60 * 1e3;
   }
+  static {
+    this.MAX_UPDATE_ATTEMPTS = 3;
+  }
   /**
    * Start the daemon
    */
@@ -11264,27 +11140,74 @@ var Daemon = class _Daemon {
   }
   async applyUpdateIfIdle(targetVersion, source) {
     if (this.updateInProgress) return;
+    if (targetVersion === packageJson.version) {
+      console.log(`[Daemon] EP1324: Already running version ${targetVersion}, skipping update`);
+      return;
+    }
+    if (this.lastFailedUpdateVersion === targetVersion && this.updateFailedAttempts >= _Daemon.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 (${packageJson.version} \u2192 ${targetVersion}) but ${activeAgentSessions} active agent session(s) \u2014 deferring`);
       return;
     }
+    const currentInstalled = getInstalledVersion();
+    if (currentInstalled && currentInstalled === targetVersion) {
+      console.log(`[Daemon] EP1343: Already installed version ${targetVersion} (embedded: ${packageJson.version}), skipping update`);
+      return;
+    }
     this.updateInProgress = true;
     console.log(`[Daemon] EP1319: Applying CLI update (${source}) to ${targetVersion} (idle)`);
     try {
-      const result = await updateAndRestartDaemon(targetVersion);
-      if (!result.updateSuccess || !result.restartSuccess) {
-        console.warn(`[Daemon] EP1319: Update to ${targetVersion} failed (${result.error || "unknown error"}), will retry later`);
-        this.pendingUpdateVersion = targetVersion;
+      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.shutdown();
+      const { getConfigDir: getConfigDir8 } = require_dist();
+      const configDir = getConfigDir8();
+      const logPath = path24.join(configDir, "daemon.log");
+      const logFd = fs23.openSync(logPath, "a");
+      const child = (0, import_child_process14.spawn)("node", [__filename], {
+        detached: true,
+        stdio: ["ignore", logFd, logFd],
+        env: { ...process.env, EPISODA_DAEMON_MODE: "1" }
+      });
+      child.unref();
+      const pidPath = getPidFilePath();
+      fs23.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) {
-      console.warn(`[Daemon] EP1319: Update to ${targetVersion} failed, will retry later`);
-      this.pendingUpdateVersion = targetVersion;
+      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}/${_Daemon.MAX_UPDATE_ATTEMPTS}): ${reason}`);
+  }
   /**
    * EP1319: Periodic update check for long-lived containers
    * Checks npm registry for newer version. If found:
@@ -11323,9 +11246,9 @@ var Daemon = class _Daemon {
       this.healthServer = http2.createServer((req, res) => {
         if (req.url === "/health" || req.url === "/") {
           const isConnected = this.liveConnections.size > 0;
-          const projects = Array.from(this.connections.entries()).map(([path26, conn]) => ({
-            path: path26,
-            connected: this.liveConnections.has(path26)
+          const projects = Array.from(this.connections.entries()).map(([path25, conn]) => ({
+            path: path25,
+            connected: this.liveConnections.has(path25)
           }));
           const status = {
             status: isConnected ? "healthy" : "degraded",
@@ -11753,7 +11676,7 @@ var Daemon = class _Daemon {
         client.updateActivity();
         try {
           const gitCmd = message.command;
-          const bareRepoPath = path25.join(projectPath, ".bare");
+          const bareRepoPath = path24.join(projectPath, ".bare");
           const cwd = gitCmd.worktreePath || bareRepoPath;
           if (gitCmd.worktreePath) {
             console.log(`[Daemon] Routing command to worktree: ${gitCmd.worktreePath}`);
@@ -12533,8 +12456,8 @@ var Daemon = class _Daemon {
    * - workDir: The directory to run git commands in (cwd)
    */
   getGitDirs(projectPath) {
-    const bareDir = path25.join(projectPath, ".bare");
-    const gitPath = path25.join(projectPath, ".git");
+    const bareDir = path24.join(projectPath, ".bare");
+    const gitPath = path24.join(projectPath, ".git");
     if (fs23.existsSync(bareDir) && fs23.statSync(bareDir).isDirectory()) {
       return { gitDir: bareDir, workDir: projectPath };
     }
@@ -12547,8 +12470,8 @@ var Daemon = class _Daemon {
     const entries = fs23.readdirSync(projectPath, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory() && entry.name.startsWith("EP")) {
-        const worktreePath = path25.join(projectPath, entry.name);
-        const worktreeGit = path25.join(worktreePath, ".git");
+        const worktreePath = path24.join(projectPath, entry.name);
+        const worktreeGit = path24.join(worktreePath, ".git");
         if (fs23.existsSync(worktreeGit)) {
           return { gitDir: null, workDir: worktreePath };
         }
@@ -12618,14 +12541,14 @@ var Daemon = class _Daemon {
   async installGitHooks(projectPath) {
     const hooks = ["post-checkout", "pre-commit", "post-commit"];
     let hooksDir;
-    const bareHooksDir = path25.join(projectPath, ".bare", "hooks");
-    const gitHooksDir = path25.join(projectPath, ".git", "hooks");
+    const bareHooksDir = path24.join(projectPath, ".bare", "hooks");
+    const gitHooksDir = path24.join(projectPath, ".git", "hooks");
     if (fs23.existsSync(bareHooksDir)) {
       hooksDir = bareHooksDir;
-    } else if (fs23.existsSync(gitHooksDir) && fs23.statSync(path25.join(projectPath, ".git")).isDirectory()) {
+    } else if (fs23.existsSync(gitHooksDir) && fs23.statSync(path24.join(projectPath, ".git")).isDirectory()) {
       hooksDir = gitHooksDir;
     } else {
-      const parentBareHooks = path25.join(projectPath, "..", ".bare", "hooks");
+      const parentBareHooks = path24.join(projectPath, "..", ".bare", "hooks");
       if (fs23.existsSync(parentBareHooks)) {
         hooksDir = parentBareHooks;
       } else {
@@ -12643,8 +12566,8 @@ var Daemon = class _Daemon {
     }
     for (const hookName of hooks) {
       try {
-        const hookPath = path25.join(hooksDir, hookName);
-        const bundledHookPath = path25.join(__dirname, "..", "hooks", hookName);
+        const hookPath = path24.join(hooksDir, hookName);
+        const bundledHookPath = path24.join(__dirname, "..", "hooks", hookName);
         if (!fs23.existsSync(bundledHookPath)) {
           console.warn(`[Daemon] Bundled hook not found: ${bundledHookPath}`);
           continue;