episoda 0.2.106 → 0.2.107

package/dist/daemon/daemon-process.js

@@ -1571,15 +1571,15 @@ var require_git_executor = __commonJS({
           try {
             const { stdout: gitDir } = await execAsync3("git rev-parse --git-dir", { cwd, timeout: 5e3 });
             const gitDirPath = gitDir.trim();
-            const fs23 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+            const fs24 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
             const rebaseMergePath = `${gitDirPath}/rebase-merge`;
             const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
             try {
-              await fs23.access(rebaseMergePath);
+              await fs24.access(rebaseMergePath);
               inRebase = true;
             } catch {
               try {
-                await fs23.access(rebaseApplyPath);
+                await fs24.access(rebaseApplyPath);
                 inRebase = true;
               } catch {
                 inRebase = false;
@@ -1633,9 +1633,9 @@ var require_git_executor = __commonJS({
               error: validation.error || "UNKNOWN_ERROR"
             };
           }
-          const fs23 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs24 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs23.access(command.path);
+            await fs24.access(command.path);
             return {
               success: false,
               error: "WORKTREE_EXISTS",
@@ -1689,9 +1689,9 @@ var require_git_executor = __commonJS({
        */
       async executeWorktreeRemove(command, cwd, options) {
         try {
-          const fs23 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs24 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs23.access(command.path);
+            await fs24.access(command.path);
           } catch {
             return {
               success: false,
@@ -1726,7 +1726,7 @@ var require_git_executor = __commonJS({
           const result = await this.runGitCommand(args, cwd, options);
           if (result.success) {
             try {
-              await fs23.rm(command.path, { recursive: true, force: true });
+              await fs24.rm(command.path, { recursive: true, force: true });
             } catch {
             }
             return {
@@ -1860,10 +1860,10 @@ var require_git_executor = __commonJS({
        */
       async executeCloneBare(command, options) {
         try {
-          const fs23 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path24 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs24 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path25 = await Promise.resolve().then(() => __importStar(require("path")));
           try {
-            await fs23.access(command.path);
+            await fs24.access(command.path);
             return {
               success: false,
               error: "BRANCH_ALREADY_EXISTS",
@@ -1872,9 +1872,9 @@ var require_git_executor = __commonJS({
             };
           } catch {
           }
-          const parentDir = path24.dirname(command.path);
+          const parentDir = path25.dirname(command.path);
           try {
-            await fs23.mkdir(parentDir, { recursive: true });
+            await fs24.mkdir(parentDir, { recursive: true });
           } catch {
           }
           const { stdout, stderr } = await execAsync3(
@@ -1922,22 +1922,22 @@ var require_git_executor = __commonJS({
        */
       async executeProjectInfo(cwd, options) {
         try {
-          const fs23 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path24 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs24 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          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 = path24.join(currentPath, ".bare");
-            const episodaDir = path24.join(currentPath, ".episoda");
+            const bareDir = path25.join(currentPath, ".bare");
+            const episodaDir = path25.join(currentPath, ".episoda");
             try {
-              await fs23.access(bareDir);
-              await fs23.access(episodaDir);
+              await fs24.access(bareDir);
+              await fs24.access(episodaDir);
               projectPath = currentPath;
               bareRepoPath = bareDir;
               break;
             } catch {
-              const parentPath = path24.dirname(currentPath);
+              const parentPath = path25.dirname(currentPath);
               if (parentPath === currentPath) {
                 break;
               }
@@ -2590,31 +2590,31 @@ var require_auth = __commonJS({
     exports2.loadConfig = loadConfig8;
     exports2.saveConfig = saveConfig2;
     exports2.validateToken = validateToken;
-    var fs23 = __importStar(require("fs"));
-    var path24 = __importStar(require("path"));
+    var fs24 = __importStar(require("fs"));
+    var path25 = __importStar(require("path"));
     var os9 = __importStar(require("os"));
     var child_process_1 = require("child_process");
     var DEFAULT_CONFIG_FILE = "config.json";
     function getConfigDir8() {
-      return process.env.EPISODA_CONFIG_DIR || path24.join(os9.homedir(), ".episoda");
+      return process.env.EPISODA_CONFIG_DIR || path25.join(os9.homedir(), ".episoda");
     }
     function getConfigPath(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path24.join(getConfigDir8(), DEFAULT_CONFIG_FILE);
+      return path25.join(getConfigDir8(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path24.dirname(configPath);
-      const isNew = !fs23.existsSync(dir);
+      const dir = path25.dirname(configPath);
+      const isNew = !fs24.existsSync(dir);
       if (isNew) {
-        fs23.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs24.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path24.join(dir, ".nosync");
-        if (isNew || !fs23.existsSync(nosyncPath)) {
+        const nosyncPath = path25.join(dir, ".nosync");
+        if (isNew || !fs24.existsSync(nosyncPath)) {
           try {
-            fs23.writeFileSync(nosyncPath, "", { mode: 384 });
+            fs24.writeFileSync(nosyncPath, "", { mode: 384 });
             (0, child_process_1.execSync)(`xattr -w com.apple.fileprovider.ignore 1 "${dir}"`, {
               stdio: "ignore",
               timeout: 5e3
@@ -2626,9 +2626,9 @@ var require_auth = __commonJS({
     }
     async function loadConfig8(configPath) {
       const fullPath = getConfigPath(configPath);
-      if (fs23.existsSync(fullPath)) {
+      if (fs24.existsSync(fullPath)) {
         try {
-          const content = fs23.readFileSync(fullPath, "utf8");
+          const content = fs24.readFileSync(fullPath, "utf8");
           const config = JSON.parse(content);
           return config;
         } catch (error) {
@@ -2638,9 +2638,9 @@ var require_auth = __commonJS({
       if (process.env.EPISODA_MODE === "cloud" && process.env.EPISODA_WORKSPACE) {
         const homeDir = process.env.HOME || require("os").homedir();
         const workspaceConfigPath = require("path").join(homeDir, "episoda", process.env.EPISODA_WORKSPACE, ".episoda", "config.json");
-        if (fs23.existsSync(workspaceConfigPath)) {
+        if (fs24.existsSync(workspaceConfigPath)) {
           try {
-            const content = fs23.readFileSync(workspaceConfigPath, "utf8");
+            const content = fs24.readFileSync(workspaceConfigPath, "utf8");
             const workspaceConfig = JSON.parse(content);
             return {
               access_token: process.env.EPISODA_ACCESS_TOKEN || workspaceConfig.accessToken,
@@ -2687,7 +2687,7 @@ var require_auth = __commonJS({
       ensureConfigDir(fullPath);
       try {
         const content = JSON.stringify(config, null, 2);
-        fs23.writeFileSync(fullPath, content, { mode: 384 });
+        fs24.writeFileSync(fullPath, content, { mode: 384 });
       } catch (error) {
         throw new Error(`Failed to save config: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -2843,7 +2843,7 @@ var require_package = __commonJS({
         "@modelcontextprotocol/server-github": "^0.6.0"
       },
       devDependencies: {
-        "@episoda/core": "*",
+        "@episoda/core": "workspace:*",
         "@types/node": "^20.11.24",
         "@types/semver": "7.7.1",
         "@types/tar": "6.1.13",
@@ -4058,8 +4058,8 @@ async function handleExec(command, projectPath) {
 }
 
 // src/daemon/handlers/worktree-handlers.ts
-var path15 = __toESM(require("path"));
-var fs14 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
+var fs15 = __toESM(require("fs"));
 var import_child_process8 = require("child_process");
 var import_util = require("util");
 
@@ -7332,6 +7332,144 @@ async function deleteWorktree(config, moduleUid) {
   }
 }
 
+// src/daemon/package-manager.ts
+var fs14 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
+var PACKAGE_MANAGERS = {
+  javascript: [
+    {
+      name: "pnpm",
+      detector: (p) => {
+        if (fs14.existsSync(path15.join(p, "pnpm-lock.yaml"))) {
+          return "pnpm-lock.yaml";
+        }
+        const pkgJsonPath = path15.join(p, "package.json");
+        if (fs14.existsSync(pkgJsonPath)) {
+          try {
+            const pkg = JSON.parse(fs14.readFileSync(pkgJsonPath, "utf-8"));
+            if (pkg.packageManager?.startsWith("pnpm")) {
+              return "package.json (packageManager field)";
+            }
+          } catch {
+          }
+        }
+        return null;
+      },
+      config: {
+        installCmd: "pnpm install --frozen-lockfile",
+        cacheEnvVar: "PNPM_HOME"
+      }
+    },
+    {
+      name: "yarn",
+      detector: (p) => fs14.existsSync(path15.join(p, "yarn.lock")) ? "yarn.lock" : null,
+      config: {
+        installCmd: "yarn install --frozen-lockfile",
+        cacheEnvVar: "YARN_CACHE_FOLDER"
+      }
+    },
+    {
+      name: "bun",
+      detector: (p) => fs14.existsSync(path15.join(p, "bun.lockb")) ? "bun.lockb" : null,
+      config: {
+        installCmd: "bun install --frozen-lockfile"
+      }
+    },
+    {
+      name: "npm",
+      detector: (p) => fs14.existsSync(path15.join(p, "package-lock.json")) ? "package-lock.json" : null,
+      config: {
+        installCmd: "npm ci"
+      }
+    },
+    {
+      // EP1222: Default to pnpm for new projects without lockfile
+      // This encourages standardization on pnpm across Episoda projects
+      name: "pnpm",
+      detector: (p) => fs14.existsSync(path15.join(p, "package.json")) ? "package.json (no lockfile - defaulting to pnpm)" : null,
+      config: {
+        installCmd: "pnpm install",
+        cacheEnvVar: "PNPM_HOME"
+      }
+    }
+  ],
+  python: [
+    {
+      name: "uv",
+      detector: (p) => {
+        const pyprojectPath = path15.join(p, "pyproject.toml");
+        if (fs14.existsSync(path15.join(p, "uv.lock"))) {
+          return "uv.lock";
+        }
+        if (fs14.existsSync(pyprojectPath)) {
+          try {
+            const content = fs14.readFileSync(pyprojectPath, "utf-8");
+            if (content.includes("[tool.uv]") || content.includes("[project]")) {
+              return "pyproject.toml";
+            }
+          } catch {
+          }
+        }
+        return null;
+      },
+      config: {
+        installCmd: "uv sync",
+        cacheEnvVar: "UV_CACHE_DIR"
+      }
+    },
+    {
+      name: "pip",
+      detector: (p) => fs14.existsSync(path15.join(p, "requirements.txt")) ? "requirements.txt" : null,
+      config: {
+        installCmd: "pip install -r requirements.txt"
+      }
+    }
+  ]
+  // Future: Add more languages here
+  // rust: [
+  //   {
+  //     name: 'cargo',
+  //     detector: (p) => fs.existsSync(path.join(p, 'Cargo.toml')) ? 'Cargo.toml' : null,
+  //     config: { installCmd: 'cargo build' }
+  //   }
+  // ],
+  // go: [
+  //   {
+  //     name: 'go',
+  //     detector: (p) => fs.existsSync(path.join(p, 'go.mod')) ? 'go.mod' : null,
+  //     config: { installCmd: 'go mod download' }
+  //   }
+  // ],
+};
+function detectPackageManager(worktreePath, preferredLanguages) {
+  const checkedFiles = [];
+  const languages = preferredLanguages || Object.keys(PACKAGE_MANAGERS);
+  for (const language of languages) {
+    const managers = PACKAGE_MANAGERS[language];
+    if (!managers) continue;
+    for (const { name, detector, config } of managers) {
+      const matchedFile = detector(worktreePath);
+      if (matchedFile) {
+        checkedFiles.push(matchedFile);
+        return {
+          detected: true,
+          packageManager: {
+            name,
+            language,
+            ...config
+          },
+          checkedFiles,
+          matchedFile
+        };
+      }
+    }
+  }
+  return {
+    detected: false,
+    checkedFiles
+  };
+}
+
 // src/daemon/handlers/worktree-handlers.ts
 async function getConfigForApi() {
   if (process.env.EPISODA_MODE === "cloud" && process.env.EPISODA_ACCESS_TOKEN) {
@@ -7350,6 +7488,16 @@ async function getConfigForApi() {
   return (0, import_core9.loadConfig)();
 }
 var execAsync = (0, import_util.promisify)(import_child_process8.exec);
+async function autoDetectSetupScript(worktreePath) {
+  const detection = detectPackageManager(worktreePath);
+  if (!detection.detected || !detection.packageManager) {
+    console.log(`[Worktree] EP1222: No package manager detected in ${worktreePath}`);
+    return null;
+  }
+  const { name, language, installCmd } = detection.packageManager;
+  console.log(`[Worktree] EP1222: Detected ${name} (${language}) via ${detection.matchedFile}`);
+  return installCmd;
+}
 async function handleWorktreeCreate(request2) {
   const {
     workspaceSlug,
@@ -7374,18 +7522,18 @@ async function handleWorktreeCreate(request2) {
   }
   try {
     const projectPath = getProjectPath(workspaceSlug, projectSlug);
-    const bareRepoPath = path15.join(projectPath, ".bare");
-    if (!fs14.existsSync(bareRepoPath)) {
+    const bareRepoPath = path16.join(projectPath, ".bare");
+    if (!fs15.existsSync(bareRepoPath)) {
       console.log(`[Worktree] K1273: Project not found, cloning lazily...`);
       console.log(`[Worktree]   Repo URL: ${repoUrl.replace(/\/\/[^@]*@/, "//***@")}`);
-      const episodaDir = path15.join(projectPath, ".episoda");
-      fs14.mkdirSync(episodaDir, { recursive: true });
+      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}"`);
         console.log(`[Worktree] K1273: Clone successful`);
         await execAsync(`git -C "${bareRepoPath}" config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"`);
-        const configPath = path15.join(episodaDir, "config.json");
+        const configPath = path16.join(episodaDir, "config.json");
         const config2 = {
           projectId,
           workspaceSlug,
@@ -7394,7 +7542,7 @@ async function handleWorktreeCreate(request2) {
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),
           worktrees: []
         };
-        fs14.writeFileSync(configPath, JSON.stringify(config2, null, 2), "utf-8");
+        fs15.writeFileSync(configPath, JSON.stringify(config2, null, 2), "utf-8");
         console.log(`[Worktree] K1273: Project initialized at ${projectPath}`);
       } catch (cloneError) {
         console.error(`[Worktree] K1273: Git clone failed: ${cloneError.message}`);
@@ -7442,11 +7590,12 @@ 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 = path15.join(worktreePath, ".env");
-      fs14.writeFileSync(envPath, envContent + "\n", "utf-8");
+      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`);
     }
-    if (setupScript) {
+    const effectiveSetupScript = setupScript || await autoDetectSetupScript(worktreePath);
+    if (effectiveSetupScript) {
       await manager.updateWorktreeStatus(moduleUid, "setup");
       if (config?.access_token) {
         await updateWorktree(config, {
@@ -7458,7 +7607,7 @@ async function handleWorktreeCreate(request2) {
         });
       }
       console.log(`[Worktree] EP1143: Running setup script...`);
-      const scriptResult = await manager.runSetupScript(moduleUid, setupScript);
+      const scriptResult = await manager.runSetupScript(moduleUid, effectiveSetupScript);
       if (!scriptResult.success) {
         console.error(`[Worktree] EP1143: Setup script failed: ${scriptResult.error}`);
         await manager.updateWorktreeStatus(moduleUid, "error", scriptResult.error);
@@ -7616,12 +7765,12 @@ async function handleProjectEject(request2) {
   console.log(`[Worktree] EP1144: Ejecting project ${projectSlug} from workspace ${workspaceSlug}`);
   try {
     const projectPath = getProjectPath(workspaceSlug, projectSlug);
-    const bareRepoPath = path15.join(projectPath, ".bare");
-    if (!fs14.existsSync(projectPath)) {
+    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 };
     }
-    if (!fs14.existsSync(bareRepoPath)) {
+    if (!fs15.existsSync(bareRepoPath)) {
       console.log(`[Worktree] EP1144: Bare repo not found, nothing to eject: ${bareRepoPath}`);
       return { success: true };
     }
@@ -7636,12 +7785,12 @@ async function handleProjectEject(request2) {
         };
       }
     }
-    const artifactsPath = path15.join(projectPath, "artifacts");
-    if (fs14.existsSync(artifactsPath)) {
+    const artifactsPath = path16.join(projectPath, "artifacts");
+    if (fs15.existsSync(artifactsPath)) {
       await persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug);
     }
     console.log(`[Worktree] EP1144: Removing project directory: ${projectPath}`);
-    await fs14.promises.rm(projectPath, { recursive: true, force: true });
+    await fs15.promises.rm(projectPath, { recursive: true, force: true });
     console.log(`[Worktree] EP1144: Successfully ejected project ${projectSlug}`);
     return { success: true };
   } catch (error) {
@@ -7655,7 +7804,7 @@ async function handleProjectEject(request2) {
 async function persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug) {
   const MAX_ARTIFACT_SIZE = 10 * 1024 * 1024;
   try {
-    const files = await fs14.promises.readdir(artifactsPath);
+    const files = await fs15.promises.readdir(artifactsPath);
     if (files.length === 0) {
       return;
     }
@@ -7669,8 +7818,8 @@ async function persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug
     }
     const artifacts = [];
     for (const fileName of files) {
-      const filePath = path15.join(artifactsPath, fileName);
-      const stat = await fs14.promises.stat(filePath);
+      const filePath = path16.join(artifactsPath, fileName);
+      const stat = await fs15.promises.stat(filePath);
       if (stat.isDirectory()) {
         continue;
       }
@@ -7679,9 +7828,9 @@ async function persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug
         continue;
       }
       try {
-        const content = await fs14.promises.readFile(filePath);
+        const content = await fs15.promises.readFile(filePath);
         const base64Content = content.toString("base64");
-        const ext = path15.extname(fileName).toLowerCase();
+        const ext = path16.extname(fileName).toLowerCase();
         const mimeTypes = {
           ".json": "application/json",
           ".txt": "text/plain",
@@ -7737,8 +7886,8 @@ async function persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug
 }
 
 // src/daemon/handlers/project-handlers.ts
-var path16 = __toESM(require("path"));
-var fs15 = __toESM(require("fs"));
+var path17 = __toESM(require("path"));
+var fs16 = __toESM(require("fs"));
 function validateSlug(slug, fieldName) {
   if (!slug || typeof slug !== "string") {
     return `${fieldName} is required`;
@@ -7778,14 +7927,14 @@ async function handleProjectSetup(params) {
   console.log(`[ProjectSetup] EP1199: Setting up project ${workspaceSlug}/${projectSlug}`);
   try {
     const projectPath = getProjectPath(workspaceSlug, projectSlug);
-    const artifactsPath = path16.join(projectPath, "artifacts");
-    const configDir = path16.join(projectPath, ".episoda");
-    const configPath = path16.join(configDir, "config.json");
-    await fs15.promises.mkdir(artifactsPath, { recursive: true });
-    await fs15.promises.mkdir(configDir, { recursive: true });
+    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 = {};
     try {
-      const existing = await fs15.promises.readFile(configPath, "utf-8");
+      const existing = await fs16.promises.readFile(configPath, "utf-8");
       existingConfig = JSON.parse(existing);
     } catch {
     }
@@ -7798,7 +7947,7 @@ async function handleProjectSetup(params) {
       // Only set created_at if not already present
       created_at: existingConfig.created_at || (/* @__PURE__ */ new Date()).toISOString()
     };
-    await fs15.promises.writeFile(configPath, JSON.stringify(config, null, 2));
+    await fs16.promises.writeFile(configPath, JSON.stringify(config, null, 2));
     console.log(`[ProjectSetup] EP1199: Project setup complete at ${projectPath}`);
     return {
       success: true,
@@ -7912,12 +8061,12 @@ async function cleanupStaleCommits(projectPath) {
 
 // src/agent/claude-binary.ts
 var import_child_process10 = require("child_process");
-var path17 = __toESM(require("path"));
-var fs16 = __toESM(require("fs"));
+var path18 = __toESM(require("path"));
+var fs17 = __toESM(require("fs"));
 var cachedBinaryPath = null;
 function isValidClaudeBinary(binaryPath) {
   try {
-    fs16.accessSync(binaryPath, fs16.constants.X_OK);
+    fs17.accessSync(binaryPath, fs17.constants.X_OK);
     const version = (0, import_child_process10.execSync)(`"${binaryPath}" --version`, {
       encoding: "utf-8",
       timeout: 5e3,
@@ -7950,14 +8099,14 @@ async function ensureClaudeBinary() {
   }
   const bundledPaths = [
     // In production: node_modules/.bin/claude
-    path17.join(__dirname, "..", "..", "node_modules", ".bin", "claude"),
+    path18.join(__dirname, "..", "..", "node_modules", ".bin", "claude"),
     // In monorepo development: packages/episoda/node_modules/.bin/claude
-    path17.join(__dirname, "..", "..", "..", "..", "node_modules", ".bin", "claude"),
+    path18.join(__dirname, "..", "..", "..", "..", "node_modules", ".bin", "claude"),
     // Root monorepo node_modules
-    path17.join(__dirname, "..", "..", "..", "..", "..", "node_modules", ".bin", "claude")
+    path18.join(__dirname, "..", "..", "..", "..", "..", "node_modules", ".bin", "claude")
   ];
   for (const bundledPath of bundledPaths) {
-    if (fs16.existsSync(bundledPath) && isValidClaudeBinary(bundledPath)) {
+    if (fs17.existsSync(bundledPath) && isValidClaudeBinary(bundledPath)) {
       cachedBinaryPath = bundledPath;
       return cachedBinaryPath;
     }
@@ -7983,12 +8132,12 @@ async function ensureClaudeBinary() {
 
 // src/agent/codex-binary.ts
 var import_child_process11 = require("child_process");
-var path18 = __toESM(require("path"));
-var fs17 = __toESM(require("fs"));
+var path19 = __toESM(require("path"));
+var fs18 = __toESM(require("fs"));
 var cachedBinaryPath2 = null;
 function isValidCodexBinary(binaryPath) {
   try {
-    fs17.accessSync(binaryPath, fs17.constants.X_OK);
+    fs18.accessSync(binaryPath, fs18.constants.X_OK);
     const version = (0, import_child_process11.execSync)(`"${binaryPath}" --version`, {
       encoding: "utf-8",
       timeout: 5e3,
@@ -8021,14 +8170,14 @@ async function ensureCodexBinary() {
   }
   const bundledPaths = [
     // In production: node_modules/.bin/codex
-    path18.join(__dirname, "..", "..", "node_modules", ".bin", "codex"),
+    path19.join(__dirname, "..", "..", "node_modules", ".bin", "codex"),
     // In monorepo development: packages/episoda/node_modules/.bin/codex
-    path18.join(__dirname, "..", "..", "..", "..", "node_modules", ".bin", "codex"),
+    path19.join(__dirname, "..", "..", "..", "..", "node_modules", ".bin", "codex"),
     // Root monorepo node_modules
-    path18.join(__dirname, "..", "..", "..", "..", "..", "node_modules", ".bin", "codex")
+    path19.join(__dirname, "..", "..", "..", "..", "..", "node_modules", ".bin", "codex")
   ];
   for (const bundledPath of bundledPaths) {
-    if (fs17.existsSync(bundledPath) && isValidCodexBinary(bundledPath)) {
+    if (fs18.existsSync(bundledPath) && isValidCodexBinary(bundledPath)) {
       cachedBinaryPath2 = bundledPath;
       return cachedBinaryPath2;
     }
@@ -8095,8 +8244,8 @@ function generateCodexConfig(credentials, projectPath) {
 
 // src/agent/agent-manager.ts
 var import_child_process12 = require("child_process");
-var path19 = __toESM(require("path"));
-var fs18 = __toESM(require("fs"));
+var path20 = __toESM(require("path"));
+var fs19 = __toESM(require("fs"));
 var os6 = __toESM(require("os"));
 
 // src/agent/claude-config.ts
@@ -8419,7 +8568,7 @@ var AgentManager = class {
     this.initialized = false;
     // EP1133: Lock for config file writes to prevent race conditions
     this.configWriteLock = Promise.resolve();
-    this.pidDir = path19.join(os6.homedir(), ".episoda", "agent-pids");
+    this.pidDir = path20.join(os6.homedir(), ".episoda", "agent-pids");
   }
   /**
    * EP1133: Acquire lock for config file writes
@@ -8448,8 +8597,8 @@ var AgentManager = class {
       return;
     }
     console.log("[AgentManager] Initializing...");
-    if (!fs18.existsSync(this.pidDir)) {
-      fs18.mkdirSync(this.pidDir, { recursive: true });
+    if (!fs19.existsSync(this.pidDir)) {
+      fs19.mkdirSync(this.pidDir, { recursive: true });
     }
     await this.cleanupOrphanedProcesses();
     try {
@@ -8696,9 +8845,9 @@ If changes are needed, explain what needs to be done.`;
       const useApiKey = !useOAuth && !!session.credentials.apiKey;
       if (provider === "codex") {
         await this.withConfigLock(async () => {
-          const codexDir = path19.join(os6.homedir(), ".codex");
-          if (!fs18.existsSync(codexDir)) {
-            fs18.mkdirSync(codexDir, { recursive: true });
+          const codexDir = path20.join(os6.homedir(), ".codex");
+          if (!fs19.existsSync(codexDir)) {
+            fs19.mkdirSync(codexDir, { recursive: true });
           }
           if (useOAuth) {
             const codexConfig = generateCodexConfig({
@@ -8708,21 +8857,21 @@ If changes are needed, explain what needs to be done.`;
               accountId: session.credentials.accountId,
               expiresAt: session.credentials.expiresAt
             }, session.projectPath);
-            const authJsonPath = path19.join(codexDir, "auth.json");
-            fs18.writeFileSync(authJsonPath, codexConfig["auth.json"], { mode: 384 });
+            const authJsonPath = path20.join(codexDir, "auth.json");
+            fs19.writeFileSync(authJsonPath, codexConfig["auth.json"], { mode: 384 });
             console.log("[AgentManager] EP1133: Wrote Codex auth.json to ~/.codex/auth.json");
             if (codexConfig["config.toml"]) {
-              const configTomlPath = path19.join(codexDir, "config.toml");
+              const configTomlPath = path20.join(codexDir, "config.toml");
               let existingConfig = "";
               try {
-                existingConfig = fs18.readFileSync(configTomlPath, "utf-8");
+                existingConfig = fs19.readFileSync(configTomlPath, "utf-8");
               } catch {
               }
               const escapedPathForRegex = session.projectPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
               const projectKeyPattern = new RegExp(`\\[projects\\."${escapedPathForRegex}"\\]`);
               const projectAlreadyTrusted = projectKeyPattern.test(existingConfig);
               if (!projectAlreadyTrusted) {
-                fs18.writeFileSync(configTomlPath, existingConfig + "\n" + codexConfig["config.toml"], { mode: 420 });
+                fs19.writeFileSync(configTomlPath, existingConfig + "\n" + codexConfig["config.toml"], { mode: 420 });
                 console.log("[AgentManager] EP1133: Updated Codex config.toml with project trust");
               }
             }
@@ -8732,14 +8881,14 @@ If changes are needed, explain what needs to be done.`;
         });
       } else {
         await this.withConfigLock(async () => {
-          const claudeDir = path19.join(os6.homedir(), ".claude");
-          const credentialsPath = path19.join(claudeDir, ".credentials.json");
-          const statsigDir = path19.join(claudeDir, "statsig");
-          if (!fs18.existsSync(claudeDir)) {
-            fs18.mkdirSync(claudeDir, { recursive: true });
+          const claudeDir = path20.join(os6.homedir(), ".claude");
+          const credentialsPath = path20.join(claudeDir, ".credentials.json");
+          const statsigDir = path20.join(claudeDir, "statsig");
+          if (!fs19.existsSync(claudeDir)) {
+            fs19.mkdirSync(claudeDir, { recursive: true });
           }
-          if (!fs18.existsSync(statsigDir)) {
-            fs18.mkdirSync(statsigDir, { recursive: true });
+          if (!fs19.existsSync(statsigDir)) {
+            fs19.mkdirSync(statsigDir, { recursive: true });
           }
           if (useOAuth) {
             const oauthCredentials = {
@@ -8757,7 +8906,7 @@ If changes are needed, explain what needs to be done.`;
             const credentialsContent = JSON.stringify({
               claudeAiOauth: oauthCredentials
             }, null, 2);
-            fs18.writeFileSync(credentialsPath, credentialsContent, { mode: 384 });
+            fs19.writeFileSync(credentialsPath, credentialsContent, { mode: 384 });
             console.log("[AgentManager] Wrote OAuth credentials to ~/.claude/.credentials.json");
             try {
               const claudeConfig = generateClaudeConfig({
@@ -8769,11 +8918,11 @@ If changes are needed, explain what needs to be done.`;
               if (!hasEvaluations || !hasStableId) {
                 throw new Error(`Invalid statsig config: missing required files`);
               }
-              const settingsPath = path19.join(claudeDir, "settings.json");
-              fs18.writeFileSync(settingsPath, claudeConfig["settings.json"], { mode: 384 });
+              const settingsPath = path20.join(claudeDir, "settings.json");
+              fs19.writeFileSync(settingsPath, claudeConfig["settings.json"], { mode: 384 });
               for (const [filename, content] of Object.entries(claudeConfig.statsig)) {
-                const filePath = path19.join(statsigDir, filename);
-                fs18.writeFileSync(filePath, content, { mode: 420 });
+                const filePath = path20.join(statsigDir, filename);
+                fs19.writeFileSync(filePath, content, { mode: 420 });
               }
               if (session.credentials.githubToken) {
                 console.log("[AgentManager] EP1146: GitHub MCP server enabled with installation token");
@@ -9043,14 +9192,14 @@ If changes are needed, explain what needs to be done.`;
    */
   async cleanupOrphanedProcesses() {
     let cleaned = 0;
-    if (!fs18.existsSync(this.pidDir)) {
+    if (!fs19.existsSync(this.pidDir)) {
       return { cleaned };
     }
-    const pidFiles = fs18.readdirSync(this.pidDir).filter((f) => f.endsWith(".pid"));
+    const pidFiles = fs19.readdirSync(this.pidDir).filter((f) => f.endsWith(".pid"));
     for (const pidFile of pidFiles) {
-      const pidPath = path19.join(this.pidDir, pidFile);
+      const pidPath = path20.join(this.pidDir, pidFile);
       try {
-        const pidStr = fs18.readFileSync(pidPath, "utf-8").trim();
+        const pidStr = fs19.readFileSync(pidPath, "utf-8").trim();
         const pid = parseInt(pidStr, 10);
         if (!isNaN(pid)) {
           try {
@@ -9061,7 +9210,7 @@ If changes are needed, explain what needs to be done.`;
           } catch {
           }
         }
-        fs18.unlinkSync(pidPath);
+        fs19.unlinkSync(pidPath);
       } catch (error) {
         console.warn(`[AgentManager] Error cleaning PID file ${pidFile}:`, error);
       }
@@ -9075,17 +9224,17 @@ If changes are needed, explain what needs to be done.`;
    * Write PID file for session tracking
    */
   writePidFile(sessionId, pid) {
-    const pidPath = path19.join(this.pidDir, `${sessionId}.pid`);
-    fs18.writeFileSync(pidPath, pid.toString());
+    const pidPath = path20.join(this.pidDir, `${sessionId}.pid`);
+    fs19.writeFileSync(pidPath, pid.toString());
   }
   /**
    * Remove PID file for session
    */
   removePidFile(sessionId) {
-    const pidPath = path19.join(this.pidDir, `${sessionId}.pid`);
+    const pidPath = path20.join(this.pidDir, `${sessionId}.pid`);
     try {
-      if (fs18.existsSync(pidPath)) {
-        fs18.unlinkSync(pidPath);
+      if (fs19.existsSync(pidPath)) {
+        fs19.unlinkSync(pidPath);
       }
     } catch {
     }
@@ -9095,8 +9244,8 @@ If changes are needed, explain what needs to be done.`;
 // src/utils/dev-server.ts
 var import_child_process13 = require("child_process");
 var import_core11 = __toESM(require_dist());
-var fs19 = __toESM(require("fs"));
-var path20 = __toESM(require("path"));
+var fs20 = __toESM(require("fs"));
+var path21 = __toESM(require("path"));
 var MAX_RESTART_ATTEMPTS = 5;
 var INITIAL_RESTART_DELAY_MS = 2e3;
 var MAX_RESTART_DELAY_MS = 3e4;
@@ -9104,26 +9253,26 @@ var MAX_LOG_SIZE_BYTES = 5 * 1024 * 1024;
 var NODE_MEMORY_LIMIT_MB = 2048;
 var activeServers = /* @__PURE__ */ new Map();
 function getLogsDir() {
-  const logsDir = path20.join((0, import_core11.getConfigDir)(), "logs");
-  if (!fs19.existsSync(logsDir)) {
-    fs19.mkdirSync(logsDir, { recursive: true });
+  const logsDir = path21.join((0, import_core11.getConfigDir)(), "logs");
+  if (!fs20.existsSync(logsDir)) {
+    fs20.mkdirSync(logsDir, { recursive: true });
   }
   return logsDir;
 }
 function getLogFilePath(moduleUid) {
-  return path20.join(getLogsDir(), `dev-${moduleUid}.log`);
+  return path21.join(getLogsDir(), `dev-${moduleUid}.log`);
 }
 function rotateLogIfNeeded(logPath) {
   try {
-    if (fs19.existsSync(logPath)) {
-      const stats = fs19.statSync(logPath);
+    if (fs20.existsSync(logPath)) {
+      const stats = fs20.statSync(logPath);
       if (stats.size > MAX_LOG_SIZE_BYTES) {
         const backupPath = `${logPath}.1`;
-        if (fs19.existsSync(backupPath)) {
-          fs19.unlinkSync(backupPath);
+        if (fs20.existsSync(backupPath)) {
+          fs20.unlinkSync(backupPath);
         }
-        fs19.renameSync(logPath, backupPath);
-        console.log(`[DevServer] EP932: Rotated log file for ${path20.basename(logPath)}`);
+        fs20.renameSync(logPath, backupPath);
+        console.log(`[DevServer] EP932: Rotated log file for ${path21.basename(logPath)}`);
       }
     }
   } catch (error) {
@@ -9136,7 +9285,7 @@ function writeToLog(logPath, line, isError = false) {
     const prefix = isError ? "ERR" : "OUT";
     const logLine = `[${timestamp}] [${prefix}] ${line}
 `;
-    fs19.appendFileSync(logPath, logLine);
+    fs20.appendFileSync(logPath, logLine);
   } catch {
   }
 }
@@ -9315,8 +9464,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 = path20.join(projectPath, ".env");
-      if (!fs19.existsSync(envFilePath) && Object.keys(injectedEnvVars).length > 0) {
+      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);
       }
@@ -9422,19 +9571,19 @@ function getDevServerStatus() {
 }
 
 // src/utils/worktree.ts
-var path21 = __toESM(require("path"));
-var fs20 = __toESM(require("fs"));
+var path22 = __toESM(require("path"));
+var fs21 = __toESM(require("fs"));
 var os7 = __toESM(require("os"));
 var import_core12 = __toESM(require_dist());
 function getEpisodaRoot2() {
-  return process.env.EPISODA_ROOT || path21.join(os7.homedir(), "episoda");
+  return process.env.EPISODA_ROOT || path22.join(os7.homedir(), "episoda");
 }
 function getWorktreeInfo(moduleUid, workspaceSlug, projectSlug) {
   const root = getEpisodaRoot2();
-  const worktreePath = path21.join(root, workspaceSlug, projectSlug, moduleUid);
+  const worktreePath = path22.join(root, workspaceSlug, projectSlug, moduleUid);
   return {
     path: worktreePath,
-    exists: fs20.existsSync(worktreePath),
+    exists: fs21.existsSync(worktreePath),
     moduleUid
   };
 }
@@ -9448,15 +9597,15 @@ async function getWorktreeInfoForModule(moduleUid) {
     return null;
   }
   const root = getEpisodaRoot2();
-  const workspaceRoot = path21.join(root, config.workspace_slug);
+  const workspaceRoot = path22.join(root, config.workspace_slug);
   try {
-    const entries = fs20.readdirSync(workspaceRoot, { withFileTypes: true });
+    const entries = fs21.readdirSync(workspaceRoot, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) {
         continue;
       }
-      const worktreePath = path21.join(workspaceRoot, entry.name, moduleUid);
-      if (fs20.existsSync(worktreePath)) {
+      const worktreePath = path22.join(workspaceRoot, entry.name, moduleUid);
+      if (fs21.existsSync(worktreePath)) {
         return {
           path: worktreePath,
           exists: true,
@@ -9473,61 +9622,61 @@ async function getWorktreeInfoForModule(moduleUid) {
 }
 
 // src/framework-detector.ts
-var fs21 = __toESM(require("fs"));
-var path22 = __toESM(require("path"));
-function getInstallCommand(cwd) {
-  if (fs21.existsSync(path22.join(cwd, "bun.lockb"))) {
+var fs22 = __toESM(require("fs"));
+var path23 = __toESM(require("path"));
+function getInstallCommand2(cwd) {
+  if (fs22.existsSync(path23.join(cwd, "bun.lockb"))) {
     return {
       command: ["bun", "install"],
       description: "Installing dependencies with bun",
       detectedFrom: "bun.lockb"
     };
   }
-  if (fs21.existsSync(path22.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 (fs21.existsSync(path22.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 (fs21.existsSync(path22.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 (fs21.existsSync(path22.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 (fs21.existsSync(path22.join(cwd, "Pipfile.lock")) || fs21.existsSync(path22.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: fs21.existsSync(path22.join(cwd, "Pipfile.lock")) ? "Pipfile.lock" : "Pipfile"
+      detectedFrom: fs22.existsSync(path23.join(cwd, "Pipfile.lock")) ? "Pipfile.lock" : "Pipfile"
     };
   }
-  if (fs21.existsSync(path22.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 (fs21.existsSync(path22.join(cwd, "pyproject.toml"))) {
-    const pyprojectPath = path22.join(cwd, "pyproject.toml");
-    const content = fs21.readFileSync(pyprojectPath, "utf-8");
+  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 {
         command: ["poetry", "install"],
@@ -9536,42 +9685,42 @@ function getInstallCommand(cwd) {
       };
     }
   }
-  if (fs21.existsSync(path22.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 (fs21.existsSync(path22.join(cwd, "Gemfile.lock")) || fs21.existsSync(path22.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: fs21.existsSync(path22.join(cwd, "Gemfile.lock")) ? "Gemfile.lock" : "Gemfile"
+      detectedFrom: fs22.existsSync(path23.join(cwd, "Gemfile.lock")) ? "Gemfile.lock" : "Gemfile"
     };
   }
-  if (fs21.existsSync(path22.join(cwd, "go.sum")) || fs21.existsSync(path22.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: fs21.existsSync(path22.join(cwd, "go.sum")) ? "go.sum" : "go.mod"
+      detectedFrom: fs22.existsSync(path23.join(cwd, "go.sum")) ? "go.sum" : "go.mod"
     };
   }
-  if (fs21.existsSync(path22.join(cwd, "Cargo.lock")) || fs21.existsSync(path22.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: fs21.existsSync(path22.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 fs22 = __toESM(require("fs"));
+var fs23 = __toESM(require("fs"));
 var http2 = __toESM(require("http"));
 var os8 = __toESM(require("os"));
-var path23 = __toESM(require("path"));
+var path24 = __toESM(require("path"));
 var packageJson = require_package();
 async function ensureValidToken(config, bufferMs = 5 * 60 * 1e3) {
   const now = Date.now();
@@ -9792,9 +9941,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(([path24, conn]) => ({
-            path: path24,
-            connected: this.liveConnections.has(path24)
+          const projects = Array.from(this.connections.entries()).map(([path25, conn]) => ({
+            path: path25,
+            connected: this.liveConnections.has(path25)
           }));
           const status = {
             status: isConnected ? "healthy" : "degraded",
@@ -10162,7 +10311,7 @@ var Daemon = class _Daemon {
         client.updateActivity();
         try {
           const gitCmd = message.command;
-          const bareRepoPath = path23.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}`);
@@ -10747,8 +10896,8 @@ var Daemon = class _Daemon {
       let daemonPid;
       try {
         const pidPath = getPidFilePath();
-        if (fs22.existsSync(pidPath)) {
-          const pidStr = fs22.readFileSync(pidPath, "utf-8").trim();
+        if (fs23.existsSync(pidPath)) {
+          const pidStr = fs23.readFileSync(pidPath, "utf-8").trim();
           daemonPid = parseInt(pidStr, 10);
         }
       } catch (pidError) {
@@ -10829,28 +10978,28 @@ var Daemon = class _Daemon {
    * - workDir: The directory to run git commands in (cwd)
    */
   getGitDirs(projectPath) {
-    const bareDir = path23.join(projectPath, ".bare");
-    const gitPath = path23.join(projectPath, ".git");
-    if (fs22.existsSync(bareDir) && fs22.statSync(bareDir).isDirectory()) {
+    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 };
     }
-    if (fs22.existsSync(gitPath) && fs22.statSync(gitPath).isDirectory()) {
+    if (fs23.existsSync(gitPath) && fs23.statSync(gitPath).isDirectory()) {
       return { gitDir: null, workDir: projectPath };
     }
-    if (fs22.existsSync(gitPath) && fs22.statSync(gitPath).isFile()) {
+    if (fs23.existsSync(gitPath) && fs23.statSync(gitPath).isFile()) {
       return { gitDir: null, workDir: projectPath };
     }
-    const entries = fs22.readdirSync(projectPath, { withFileTypes: true });
+    const entries = fs23.readdirSync(projectPath, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory() && entry.name.startsWith("EP")) {
-        const worktreePath = path23.join(projectPath, entry.name);
-        const worktreeGit = path23.join(worktreePath, ".git");
-        if (fs22.existsSync(worktreeGit)) {
+        const worktreePath = path24.join(projectPath, entry.name);
+        const worktreeGit = path24.join(worktreePath, ".git");
+        if (fs23.existsSync(worktreeGit)) {
           return { gitDir: null, workDir: worktreePath };
         }
       }
     }
-    if (fs22.existsSync(bareDir)) {
+    if (fs23.existsSync(bareDir)) {
       return { gitDir: bareDir, workDir: projectPath };
     }
     return { gitDir: null, workDir: projectPath };
@@ -10914,24 +11063,24 @@ var Daemon = class _Daemon {
   async installGitHooks(projectPath) {
     const hooks = ["post-checkout", "pre-commit", "post-commit"];
     let hooksDir;
-    const bareHooksDir = path23.join(projectPath, ".bare", "hooks");
-    const gitHooksDir = path23.join(projectPath, ".git", "hooks");
-    if (fs22.existsSync(bareHooksDir)) {
+    const bareHooksDir = path24.join(projectPath, ".bare", "hooks");
+    const gitHooksDir = path24.join(projectPath, ".git", "hooks");
+    if (fs23.existsSync(bareHooksDir)) {
       hooksDir = bareHooksDir;
-    } else if (fs22.existsSync(gitHooksDir) && fs22.statSync(path23.join(projectPath, ".git")).isDirectory()) {
+    } else if (fs23.existsSync(gitHooksDir) && fs23.statSync(path24.join(projectPath, ".git")).isDirectory()) {
       hooksDir = gitHooksDir;
     } else {
-      const parentBareHooks = path23.join(projectPath, "..", ".bare", "hooks");
-      if (fs22.existsSync(parentBareHooks)) {
+      const parentBareHooks = path24.join(projectPath, "..", ".bare", "hooks");
+      if (fs23.existsSync(parentBareHooks)) {
         hooksDir = parentBareHooks;
       } else {
         console.warn(`[Daemon] Hooks directory not found for: ${projectPath}`);
         return;
       }
     }
-    if (!fs22.existsSync(hooksDir)) {
+    if (!fs23.existsSync(hooksDir)) {
       try {
-        fs22.mkdirSync(hooksDir, { recursive: true });
+        fs23.mkdirSync(hooksDir, { recursive: true });
       } catch (error) {
         console.warn(`[Daemon] Hooks directory not found and could not create: ${hooksDir}`);
         return;
@@ -10939,20 +11088,20 @@ var Daemon = class _Daemon {
     }
     for (const hookName of hooks) {
       try {
-        const hookPath = path23.join(hooksDir, hookName);
-        const bundledHookPath = path23.join(__dirname, "..", "hooks", hookName);
-        if (!fs22.existsSync(bundledHookPath)) {
+        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;
         }
-        const hookContent = fs22.readFileSync(bundledHookPath, "utf-8");
-        if (fs22.existsSync(hookPath)) {
-          const existingContent = fs22.readFileSync(hookPath, "utf-8");
+        const hookContent = fs23.readFileSync(bundledHookPath, "utf-8");
+        if (fs23.existsSync(hookPath)) {
+          const existingContent = fs23.readFileSync(hookPath, "utf-8");
           if (existingContent === hookContent) {
             continue;
           }
         }
-        fs22.writeFileSync(hookPath, hookContent, { mode: 493 });
+        fs23.writeFileSync(hookPath, hookContent, { mode: 493 });
         console.log(`[Daemon] Installed git hook: ${hookName}`);
       } catch (error) {
         console.warn(`[Daemon] Failed to install ${hookName} hook:`, error instanceof Error ? error.message : error);
@@ -11290,7 +11439,7 @@ var Daemon = class _Daemon {
       console.log(`[Daemon] EP1002: Writing .env with ${Object.keys(envVars).length} variables`);
       writeEnvFile(worktreePath, envVars);
     }
-    const installCmd = getInstallCommand(worktreePath);
+    const installCmd = getInstallCommand2(worktreePath);
     if (installCmd) {
       console.log(`[Daemon] EP1002: ${installCmd.description} (detected from ${installCmd.detectedFrom})`);
       console.log(`[Daemon] EP1002: Running: ${installCmd.command.join(" ")}`);
@@ -11344,7 +11493,7 @@ var Daemon = class _Daemon {
           console.warn(`[Daemon] EP964: File copy failed (non-fatal): ${copyResult.error}`);
         }
       }
-      const installCmd = getInstallCommand(worktreePath);
+      const installCmd = getInstallCommand2(worktreePath);
       if (installCmd) {
         console.log(`[Daemon] EP986: ${installCmd.description} (detected from ${installCmd.detectedFrom})`);
         console.log(`[Daemon] EP986: Running: ${installCmd.command.join(" ")}`);
@@ -11956,8 +12105,8 @@ var Daemon = class _Daemon {
     await this.shutdown();
     try {
       const pidPath = getPidFilePath();
-      if (fs22.existsSync(pidPath)) {
-        fs22.unlinkSync(pidPath);
+      if (fs23.existsSync(pidPath)) {
+        fs23.unlinkSync(pidPath);
         console.log("[Daemon] PID file cleaned up");
       }
     } catch (error) {