episoda 0.2.33 → 0.2.34

package/dist/daemon/daemon-process.js

@@ -1556,15 +1556,15 @@ var require_git_executor = __commonJS({
           try {
             const { stdout: gitDir } = await execAsync2("git rev-parse --git-dir", { cwd, timeout: 5e3 });
             const gitDirPath = gitDir.trim();
-            const fs16 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+            const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
             const rebaseMergePath = `${gitDirPath}/rebase-merge`;
             const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
             try {
-              await fs16.access(rebaseMergePath);
+              await fs17.access(rebaseMergePath);
               inRebase = true;
             } catch {
               try {
-                await fs16.access(rebaseApplyPath);
+                await fs17.access(rebaseApplyPath);
                 inRebase = true;
               } catch {
                 inRebase = false;
@@ -1618,9 +1618,9 @@ var require_git_executor = __commonJS({
               error: validation.error || "UNKNOWN_ERROR"
             };
           }
-          const fs16 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs16.access(command.path);
+            await fs17.access(command.path);
             return {
               success: false,
               error: "WORKTREE_EXISTS",
@@ -1674,9 +1674,9 @@ var require_git_executor = __commonJS({
        */
       async executeWorktreeRemove(command, cwd, options) {
         try {
-          const fs16 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs16.access(command.path);
+            await fs17.access(command.path);
           } catch {
             return {
               success: false,
@@ -1829,10 +1829,10 @@ var require_git_executor = __commonJS({
        */
       async executeCloneBare(command, options) {
         try {
-          const fs16 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path17 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path18 = await Promise.resolve().then(() => __importStar(require("path")));
           try {
-            await fs16.access(command.path);
+            await fs17.access(command.path);
             return {
               success: false,
               error: "BRANCH_ALREADY_EXISTS",
@@ -1841,9 +1841,9 @@ var require_git_executor = __commonJS({
             };
           } catch {
           }
-          const parentDir = path17.dirname(command.path);
+          const parentDir = path18.dirname(command.path);
           try {
-            await fs16.mkdir(parentDir, { recursive: true });
+            await fs17.mkdir(parentDir, { recursive: true });
           } catch {
           }
           const { stdout, stderr } = await execAsync2(
@@ -1886,22 +1886,22 @@ var require_git_executor = __commonJS({
        */
       async executeProjectInfo(cwd, options) {
         try {
-          const fs16 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path17 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path18 = await Promise.resolve().then(() => __importStar(require("path")));
           let currentPath = cwd;
           let projectPath = cwd;
           let bareRepoPath;
           for (let i = 0; i < 10; i++) {
-            const bareDir = path17.join(currentPath, ".bare");
-            const episodaDir = path17.join(currentPath, ".episoda");
+            const bareDir = path18.join(currentPath, ".bare");
+            const episodaDir = path18.join(currentPath, ".episoda");
             try {
-              await fs16.access(bareDir);
-              await fs16.access(episodaDir);
+              await fs17.access(bareDir);
+              await fs17.access(episodaDir);
               projectPath = currentPath;
               bareRepoPath = bareDir;
               break;
             } catch {
-              const parentPath = path17.dirname(currentPath);
+              const parentPath = path18.dirname(currentPath);
               if (parentPath === currentPath) {
                 break;
               }
@@ -2492,34 +2492,34 @@ var require_auth = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.getConfigDir = getConfigDir6;
     exports2.getConfigPath = getConfigPath;
-    exports2.loadConfig = loadConfig5;
+    exports2.loadConfig = loadConfig6;
     exports2.saveConfig = saveConfig2;
     exports2.validateToken = validateToken;
-    var fs16 = __importStar(require("fs"));
-    var path17 = __importStar(require("path"));
-    var os6 = __importStar(require("os"));
+    var fs17 = __importStar(require("fs"));
+    var path18 = __importStar(require("path"));
+    var os7 = __importStar(require("os"));
     var child_process_1 = require("child_process");
     var DEFAULT_CONFIG_FILE = "config.json";
     function getConfigDir6() {
-      return process.env.EPISODA_CONFIG_DIR || path17.join(os6.homedir(), ".episoda");
+      return process.env.EPISODA_CONFIG_DIR || path18.join(os7.homedir(), ".episoda");
     }
     function getConfigPath(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path17.join(getConfigDir6(), DEFAULT_CONFIG_FILE);
+      return path18.join(getConfigDir6(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path17.dirname(configPath);
-      const isNew = !fs16.existsSync(dir);
+      const dir = path18.dirname(configPath);
+      const isNew = !fs17.existsSync(dir);
       if (isNew) {
-        fs16.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs17.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path17.join(dir, ".nosync");
-        if (isNew || !fs16.existsSync(nosyncPath)) {
+        const nosyncPath = path18.join(dir, ".nosync");
+        if (isNew || !fs17.existsSync(nosyncPath)) {
           try {
-            fs16.writeFileSync(nosyncPath, "", { mode: 384 });
+            fs17.writeFileSync(nosyncPath, "", { mode: 384 });
             (0, child_process_1.execSync)(`xattr -w com.apple.fileprovider.ignore 1 "${dir}"`, {
               stdio: "ignore",
               timeout: 5e3
@@ -2529,13 +2529,13 @@ var require_auth = __commonJS({
         }
       }
     }
-    async function loadConfig5(configPath) {
+    async function loadConfig6(configPath) {
       const fullPath = getConfigPath(configPath);
-      if (!fs16.existsSync(fullPath)) {
+      if (!fs17.existsSync(fullPath)) {
         return null;
       }
       try {
-        const content = fs16.readFileSync(fullPath, "utf8");
+        const content = fs17.readFileSync(fullPath, "utf8");
         const config = JSON.parse(content);
         return config;
       } catch (error) {
@@ -2548,7 +2548,7 @@ var require_auth = __commonJS({
       ensureConfigDir(fullPath);
       try {
         const content = JSON.stringify(config, null, 2);
-        fs16.writeFileSync(fullPath, content, { mode: 384 });
+        fs17.writeFileSync(fullPath, content, { mode: 384 });
       } catch (error) {
         throw new Error(`Failed to save config: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -2699,7 +2699,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.32",
+      version: "0.2.33",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -5032,9 +5032,162 @@ var AgentManager = class {
 var import_child_process9 = require("child_process");
 init_port_check();
 var import_core7 = __toESM(require_dist());
-var import_http = __toESM(require("http"));
+
+// src/utils/env-cache.ts
+var fs10 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
+var os4 = __toESM(require("os"));
+
+// src/utils/env-setup.ts
 var fs9 = __toESM(require("fs"));
 var path10 = __toESM(require("path"));
+async function fetchEnvVars(apiUrl, accessToken) {
+  try {
+    const url = `${apiUrl}/api/cli/env-vars`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${accessToken}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      console.warn(`[env-setup] Failed to fetch env vars: ${response.status}`);
+      return {};
+    }
+    const data = await response.json();
+    const envVars = data.env_vars || {};
+    console.log(`[env-setup] Fetched ${Object.keys(envVars).length} env vars from server`);
+    return envVars;
+  } catch (error) {
+    console.warn("[env-setup] Error fetching env vars:", error instanceof Error ? error.message : error);
+    return {};
+  }
+}
+function writeEnvFile(targetPath, envVars) {
+  if (Object.keys(envVars).length === 0) {
+    return;
+  }
+  const envContent = Object.entries(envVars).map(([key, value]) => {
+    if (/[\s'"#$`\\]/.test(value) || value.includes("\n")) {
+      const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+      return `${key}="${escaped}"`;
+    }
+    return `${key}=${value}`;
+  }).join("\n") + "\n";
+  const envPath = path10.join(targetPath, ".env");
+  fs9.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 = path11.join(os4.homedir(), ".episoda", "cache");
+function getCacheFilePath(projectId) {
+  return path11.join(CACHE_DIR, `env-vars-${projectId}.json`);
+}
+function ensureCacheDir() {
+  if (!fs10.existsSync(CACHE_DIR)) {
+    fs10.mkdirSync(CACHE_DIR, { recursive: true, mode: 448 });
+  }
+}
+function readCache(projectId) {
+  try {
+    const cacheFile = getCacheFilePath(projectId);
+    if (!fs10.existsSync(cacheFile)) {
+      return null;
+    }
+    const content = fs10.readFileSync(cacheFile, "utf-8");
+    const data = JSON.parse(content);
+    if (!data.vars || typeof data.vars !== "object" || !data.fetchedAt) {
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+function writeCache(projectId, vars) {
+  try {
+    ensureCacheDir();
+    const cacheFile = getCacheFilePath(projectId);
+    const data = {
+      vars,
+      fetchedAt: Date.now(),
+      projectId
+    };
+    fs10.writeFileSync(cacheFile, JSON.stringify(data, null, 2), { mode: 384 });
+  } catch (error) {
+    console.warn("[env-cache] Failed to write cache:", error instanceof Error ? error.message : error);
+  }
+}
+function isCacheValid(cache, ttlSeconds) {
+  const ageMs = Date.now() - cache.fetchedAt;
+  return ageMs < ttlSeconds * 1e3;
+}
+async function fetchEnvVarsWithCache(apiUrl, accessToken, options = {}) {
+  const {
+    noCache = false,
+    cacheTtl = DEFAULT_CACHE_TTL,
+    offline = false,
+    projectId = "default"
+  } = options;
+  if (offline) {
+    const cache = readCache(projectId);
+    if (cache && Object.keys(cache.vars).length > 0) {
+      return {
+        envVars: cache.vars,
+        fromCache: true,
+        cacheAge: Date.now() - cache.fetchedAt
+      };
+    }
+    throw new Error(
+      "Offline mode requires cached env vars, but no cache found.\nRun without --offline first to populate the cache."
+    );
+  }
+  if (!noCache) {
+    const cache = readCache(projectId);
+    if (cache && isCacheValid(cache, cacheTtl)) {
+      return {
+        envVars: cache.vars,
+        fromCache: true,
+        cacheAge: Date.now() - cache.fetchedAt
+      };
+    }
+  }
+  try {
+    const envVars = await fetchEnvVars(apiUrl, accessToken);
+    if (Object.keys(envVars).length > 0) {
+      writeCache(projectId, envVars);
+    }
+    return {
+      envVars,
+      fromCache: false
+    };
+  } catch (error) {
+    const cache = readCache(projectId);
+    if (cache && Object.keys(cache.vars).length > 0) {
+      const cacheAge = Date.now() - cache.fetchedAt;
+      console.warn(
+        `[env-cache] Failed to fetch env vars, using stale cache (${Math.round(cacheAge / 1e3)}s old)`
+      );
+      return {
+        envVars: cache.vars,
+        fromCache: true,
+        cacheAge
+      };
+    }
+    throw new Error(
+      `Failed to fetch environment variables: ${error instanceof Error ? error.message : error}
+No cached values available as fallback.`
+    );
+  }
+}
+
+// src/utils/dev-server.ts
+var import_http = __toESM(require("http"));
+var fs11 = __toESM(require("fs"));
+var path12 = __toESM(require("path"));
 var MAX_RESTART_ATTEMPTS = 5;
 var INITIAL_RESTART_DELAY_MS = 2e3;
 var MAX_RESTART_DELAY_MS = 3e4;
@@ -5042,26 +5195,26 @@ var MAX_LOG_SIZE_BYTES = 5 * 1024 * 1024;
 var NODE_MEMORY_LIMIT_MB = 2048;
 var activeServers = /* @__PURE__ */ new Map();
 function getLogsDir() {
-  const logsDir = path10.join((0, import_core7.getConfigDir)(), "logs");
-  if (!fs9.existsSync(logsDir)) {
-    fs9.mkdirSync(logsDir, { recursive: true });
+  const logsDir = path12.join((0, import_core7.getConfigDir)(), "logs");
+  if (!fs11.existsSync(logsDir)) {
+    fs11.mkdirSync(logsDir, { recursive: true });
   }
   return logsDir;
 }
 function getLogFilePath(moduleUid) {
-  return path10.join(getLogsDir(), `dev-${moduleUid}.log`);
+  return path12.join(getLogsDir(), `dev-${moduleUid}.log`);
 }
 function rotateLogIfNeeded(logPath) {
   try {
-    if (fs9.existsSync(logPath)) {
-      const stats = fs9.statSync(logPath);
+    if (fs11.existsSync(logPath)) {
+      const stats = fs11.statSync(logPath);
       if (stats.size > MAX_LOG_SIZE_BYTES) {
         const backupPath = `${logPath}.1`;
-        if (fs9.existsSync(backupPath)) {
-          fs9.unlinkSync(backupPath);
+        if (fs11.existsSync(backupPath)) {
+          fs11.unlinkSync(backupPath);
         }
-        fs9.renameSync(logPath, backupPath);
-        console.log(`[DevServer] EP932: Rotated log file for ${path10.basename(logPath)}`);
+        fs11.renameSync(logPath, backupPath);
+        console.log(`[DevServer] EP932: Rotated log file for ${path12.basename(logPath)}`);
       }
     }
   } catch (error) {
@@ -5074,7 +5227,7 @@ function writeToLog(logPath, line, isError = false) {
     const prefix = isError ? "ERR" : "OUT";
     const logLine = `[${timestamp}] [${prefix}] ${line}
 `;
-    fs9.appendFileSync(logPath, logLine);
+    fs11.appendFileSync(logPath, logLine);
   } catch {
   }
 }
@@ -5155,7 +5308,7 @@ function calculateRestartDelay(restartCount) {
   const delay = INITIAL_RESTART_DELAY_MS * Math.pow(2, restartCount);
   return Math.min(delay, MAX_RESTART_DELAY_MS);
 }
-function spawnDevServerProcess(projectPath, port, moduleUid, logPath, customCommand) {
+function spawnDevServerProcess(projectPath, port, moduleUid, logPath, customCommand, injectedEnvVars) {
   rotateLogIfNeeded(logPath);
   const nodeOptions = process.env.NODE_OPTIONS || "";
   const memoryFlag = `--max-old-space-size=${NODE_MEMORY_LIMIT_MB}`;
@@ -5163,13 +5316,19 @@ function spawnDevServerProcess(projectPath, port, moduleUid, logPath, customComm
   const command = customCommand || "npm run dev";
   const [cmd, ...args] = command.split(" ");
   console.log(`[DevServer] EP959: Starting with command: ${command}`);
+  const mergedEnv = {
+    ...process.env,
+    ...injectedEnvVars,
+    PORT: String(port),
+    NODE_OPTIONS: enhancedNodeOptions
+  };
+  const injectedCount = injectedEnvVars ? Object.keys(injectedEnvVars).length : 0;
+  if (injectedCount > 0) {
+    console.log(`[DevServer] EP998: Injecting ${injectedCount} env vars from database`);
+  }
   const devProcess = (0, import_child_process9.spawn)(cmd, args, {
     cwd: projectPath,
-    env: {
-      ...process.env,
-      PORT: String(port),
-      NODE_OPTIONS: enhancedNodeOptions
-    },
+    env: mergedEnv,
     stdio: ["ignore", "pipe", "pipe"],
     detached: false,
     shell: true
@@ -5219,7 +5378,7 @@ async function handleProcessExit(moduleUid, code, signal) {
     return;
   }
   const logPath = serverInfo.logFile || getLogFilePath(moduleUid);
-  const newProcess = spawnDevServerProcess(serverInfo.projectPath, serverInfo.port, moduleUid, logPath, serverInfo.customCommand);
+  const newProcess = spawnDevServerProcess(serverInfo.projectPath, serverInfo.port, moduleUid, logPath, serverInfo.customCommand, serverInfo.injectedEnvVars);
   const updatedInfo = {
     ...serverInfo,
     process: newProcess,
@@ -5259,9 +5418,27 @@ async function startDevServer(projectPath, port = 3e3, moduleUid = "default", op
     }
   }
   console.log(`[DevServer] EP932: Starting dev server for ${moduleUid} on port ${port} (auto-restart: ${autoRestart})...`);
+  let injectedEnvVars = {};
+  try {
+    const config = await (0, import_core7.loadConfig)();
+    if (config?.access_token && config?.project_id) {
+      const apiUrl = config.api_url || "https://episoda.dev";
+      const result = await fetchEnvVarsWithCache(apiUrl, config.access_token, {
+        projectId: config.project_id,
+        cacheTtl: 300
+        // 5 minute cache for daemon
+      });
+      injectedEnvVars = result.envVars;
+      console.log(`[DevServer] EP998: Loaded ${Object.keys(injectedEnvVars).length} env vars (from ${result.fromCache ? "cache" : "server"})`);
+    } else {
+      console.log(`[DevServer] EP998: No auth config, skipping env var injection`);
+    }
+  } catch (error) {
+    console.warn(`[DevServer] EP998: Failed to fetch env vars:`, error instanceof Error ? error.message : error);
+  }
   try {
     const logPath = getLogFilePath(moduleUid);
-    const devProcess = spawnDevServerProcess(projectPath, port, moduleUid, logPath, customCommand);
+    const devProcess = spawnDevServerProcess(projectPath, port, moduleUid, logPath, customCommand, injectedEnvVars);
     const serverInfo = {
       process: devProcess,
       moduleUid,
@@ -5272,8 +5449,10 @@ async function startDevServer(projectPath, port = 3e3, moduleUid = "default", op
       lastRestartAt: null,
       autoRestartEnabled: autoRestart,
       logFile: logPath,
-      customCommand
+      customCommand,
       // EP959-m2: Store for restarts
+      injectedEnvVars
+      // EP998: Store for restarts
     };
     activeServers.set(moduleUid, serverInfo);
     writeToLog(logPath, `Starting dev server on port ${port}`, false);
@@ -5359,8 +5538,8 @@ async function ensureDevServer(projectPath, port = 3e3, moduleUid = "default", c
 }
 
 // src/utils/port-detect.ts
-var fs10 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
+var fs12 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
 var DEFAULT_PORT = 3e3;
 function detectDevPort(projectPath) {
   const envPort = getPortFromEnv(projectPath);
@@ -5378,15 +5557,15 @@ function detectDevPort(projectPath) {
 }
 function getPortFromEnv(projectPath) {
   const envPaths = [
-    path11.join(projectPath, ".env"),
-    path11.join(projectPath, ".env.local"),
-    path11.join(projectPath, ".env.development"),
-    path11.join(projectPath, ".env.development.local")
+    path13.join(projectPath, ".env"),
+    path13.join(projectPath, ".env.local"),
+    path13.join(projectPath, ".env.development"),
+    path13.join(projectPath, ".env.development.local")
   ];
   for (const envPath of envPaths) {
     try {
-      if (!fs10.existsSync(envPath)) continue;
-      const content = fs10.readFileSync(envPath, "utf-8");
+      if (!fs12.existsSync(envPath)) continue;
+      const content = fs12.readFileSync(envPath, "utf-8");
       const lines = content.split("\n");
       for (const line of lines) {
         const match = line.match(/^\s*PORT\s*=\s*["']?(\d+)["']?\s*(?:#.*)?$/);
@@ -5403,10 +5582,10 @@ function getPortFromEnv(projectPath) {
   return null;
 }
 function getPortFromPackageJson(projectPath) {
-  const packageJsonPath = path11.join(projectPath, "package.json");
+  const packageJsonPath = path13.join(projectPath, "package.json");
   try {
-    if (!fs10.existsSync(packageJsonPath)) return null;
-    const content = fs10.readFileSync(packageJsonPath, "utf-8");
+    if (!fs12.existsSync(packageJsonPath)) return null;
+    const content = fs12.readFileSync(packageJsonPath, "utf-8");
     const pkg = JSON.parse(content);
     const devScript = pkg.scripts?.dev;
     if (!devScript) return null;
@@ -5430,8 +5609,8 @@ function getPortFromPackageJson(projectPath) {
 }
 
 // src/daemon/worktree-manager.ts
-var fs11 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var fs13 = __toESM(require("fs"));
+var path14 = __toESM(require("path"));
 var import_core8 = __toESM(require_dist());
 function validateModuleUid(moduleUid) {
   if (!moduleUid || typeof moduleUid !== "string" || !moduleUid.trim()) {
@@ -5455,8 +5634,8 @@ var WorktreeManager = class _WorktreeManager {
     // ============================================================
     this.lockPath = "";
     this.projectRoot = projectRoot;
-    this.bareRepoPath = path12.join(projectRoot, ".bare");
-    this.configPath = path12.join(projectRoot, ".episoda", "config.json");
+    this.bareRepoPath = path14.join(projectRoot, ".bare");
+    this.configPath = path14.join(projectRoot, ".episoda", "config.json");
     this.gitExecutor = new import_core8.GitExecutor();
   }
   /**
@@ -5465,10 +5644,10 @@ var WorktreeManager = class _WorktreeManager {
    * @returns true if valid project, false otherwise
    */
   async initialize() {
-    if (!fs11.existsSync(this.bareRepoPath)) {
+    if (!fs13.existsSync(this.bareRepoPath)) {
       return false;
     }
-    if (!fs11.existsSync(this.configPath)) {
+    if (!fs13.existsSync(this.configPath)) {
       return false;
     }
     try {
@@ -5483,8 +5662,8 @@ var WorktreeManager = class _WorktreeManager {
    */
   static async createProject(projectRoot, repoUrl, projectId, workspaceSlug, projectSlug) {
     const manager = new _WorktreeManager(projectRoot);
-    const episodaDir = path12.join(projectRoot, ".episoda");
-    fs11.mkdirSync(episodaDir, { recursive: true });
+    const episodaDir = path14.join(projectRoot, ".episoda");
+    fs13.mkdirSync(episodaDir, { recursive: true });
     const cloneResult = await manager.gitExecutor.execute({
       action: "clone_bare",
       url: repoUrl,
@@ -5515,7 +5694,7 @@ var WorktreeManager = class _WorktreeManager {
         error: `Invalid module UID: "${moduleUid}" - contains disallowed characters`
       };
     }
-    const worktreePath = path12.join(this.projectRoot, moduleUid);
+    const worktreePath = path14.join(this.projectRoot, moduleUid);
     const lockAcquired = await this.acquireLock();
     if (!lockAcquired) {
       return {
@@ -5696,7 +5875,7 @@ var WorktreeManager = class _WorktreeManager {
     let prunedCount = 0;
     await this.updateConfigSafe((config) => {
       const initialCount = config.worktrees.length;
-      config.worktrees = config.worktrees.filter((w) => fs11.existsSync(w.worktreePath));
+      config.worktrees = config.worktrees.filter((w) => fs13.existsSync(w.worktreePath));
       prunedCount = initialCount - config.worktrees.length;
       return config;
     });
@@ -5777,16 +5956,16 @@ var WorktreeManager = class _WorktreeManager {
     const retryInterval = 50;
     while (Date.now() - startTime < timeoutMs) {
       try {
-        fs11.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+        fs13.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
         return true;
       } catch (err) {
         if (err.code === "EEXIST") {
           try {
-            const stats = fs11.statSync(lockPath);
+            const stats = fs13.statSync(lockPath);
             const lockAge = Date.now() - stats.mtimeMs;
             if (lockAge > 3e4) {
               try {
-                const lockContent = fs11.readFileSync(lockPath, "utf-8").trim();
+                const lockContent = fs13.readFileSync(lockPath, "utf-8").trim();
                 const lockPid = parseInt(lockContent, 10);
                 if (!isNaN(lockPid) && this.isProcessRunning(lockPid)) {
                   await new Promise((resolve3) => setTimeout(resolve3, retryInterval));
@@ -5795,7 +5974,7 @@ var WorktreeManager = class _WorktreeManager {
               } catch {
               }
               try {
-                fs11.unlinkSync(lockPath);
+                fs13.unlinkSync(lockPath);
               } catch {
               }
               continue;
@@ -5816,16 +5995,16 @@ var WorktreeManager = class _WorktreeManager {
    */
   releaseLock() {
     try {
-      fs11.unlinkSync(this.getLockPath());
+      fs13.unlinkSync(this.getLockPath());
     } catch {
     }
   }
   readConfig() {
     try {
-      if (!fs11.existsSync(this.configPath)) {
+      if (!fs13.existsSync(this.configPath)) {
         return null;
       }
-      const content = fs11.readFileSync(this.configPath, "utf-8");
+      const content = fs13.readFileSync(this.configPath, "utf-8");
       return JSON.parse(content);
     } catch (error) {
       console.error("[WorktreeManager] Failed to read config:", error);
@@ -5834,11 +6013,11 @@ var WorktreeManager = class _WorktreeManager {
   }
   writeConfig(config) {
     try {
-      const dir = path12.dirname(this.configPath);
-      if (!fs11.existsSync(dir)) {
-        fs11.mkdirSync(dir, { recursive: true });
+      const dir = path14.dirname(this.configPath);
+      if (!fs13.existsSync(dir)) {
+        fs13.mkdirSync(dir, { recursive: true });
       }
-      fs11.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf-8");
+      fs13.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf-8");
     } catch (error) {
       console.error("[WorktreeManager] Failed to write config:", error);
       throw error;
@@ -5919,14 +6098,14 @@ var WorktreeManager = class _WorktreeManager {
     }
     try {
       for (const file of files) {
-        const srcPath = path12.join(mainWorktree.worktreePath, file);
-        const destPath = path12.join(worktree.worktreePath, file);
-        if (fs11.existsSync(srcPath)) {
-          const destDir = path12.dirname(destPath);
-          if (!fs11.existsSync(destDir)) {
-            fs11.mkdirSync(destDir, { recursive: true });
-          }
-          fs11.copyFileSync(srcPath, destPath);
+        const srcPath = path14.join(mainWorktree.worktreePath, file);
+        const destPath = path14.join(worktree.worktreePath, file);
+        if (fs13.existsSync(srcPath)) {
+          const destDir = path14.dirname(destPath);
+          if (!fs13.existsSync(destDir)) {
+            fs13.mkdirSync(destDir, { recursive: true });
+          }
+          fs13.copyFileSync(srcPath, destPath);
           console.log(`[WorktreeManager] EP964: Copied ${file} to ${moduleUid} (deprecated)`);
         } else {
           console.log(`[WorktreeManager] EP964: Skipped ${file} (not found in main)`);
@@ -6009,27 +6188,27 @@ var WorktreeManager = class _WorktreeManager {
   }
 };
 function getEpisodaRoot() {
-  return process.env.EPISODA_ROOT || path12.join(require("os").homedir(), "episoda");
+  return process.env.EPISODA_ROOT || path14.join(require("os").homedir(), "episoda");
 }
 async function isWorktreeProject(projectRoot) {
   const manager = new WorktreeManager(projectRoot);
   return manager.initialize();
 }
 async function findProjectRoot(startPath) {
-  let current = path12.resolve(startPath);
+  let current = path14.resolve(startPath);
   const episodaRoot = getEpisodaRoot();
   if (!current.startsWith(episodaRoot)) {
     return null;
   }
   for (let i = 0; i < 10; i++) {
-    const bareDir = path12.join(current, ".bare");
-    const episodaDir = path12.join(current, ".episoda");
-    if (fs11.existsSync(bareDir) && fs11.existsSync(episodaDir)) {
+    const bareDir = path14.join(current, ".bare");
+    const episodaDir = path14.join(current, ".episoda");
+    if (fs13.existsSync(bareDir) && fs13.existsSync(episodaDir)) {
       if (await isWorktreeProject(current)) {
         return current;
       }
     }
-    const parent = path12.dirname(current);
+    const parent = path14.dirname(current);
     if (parent === current) {
       break;
     }
@@ -6038,39 +6217,20 @@ async function findProjectRoot(startPath) {
   return null;
 }
 
-// src/utils/env-setup.ts
-var fs12 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
-function writeEnvFile(targetPath, envVars) {
-  if (Object.keys(envVars).length === 0) {
-    return;
-  }
-  const envContent = Object.entries(envVars).map(([key, value]) => {
-    if (/[\s'"#$`\\]/.test(value) || value.includes("\n")) {
-      const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
-      return `${key}="${escaped}"`;
-    }
-    return `${key}=${value}`;
-  }).join("\n") + "\n";
-  const envPath = path13.join(targetPath, ".env");
-  fs12.writeFileSync(envPath, envContent, { mode: 384 });
-  console.log(`[env-setup] Wrote ${Object.keys(envVars).length} env vars to ${envPath}`);
-}
-
 // src/utils/worktree.ts
-var path14 = __toESM(require("path"));
-var fs13 = __toESM(require("fs"));
-var os4 = __toESM(require("os"));
+var path15 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
+var os5 = __toESM(require("os"));
 var import_core9 = __toESM(require_dist());
 function getEpisodaRoot2() {
-  return process.env.EPISODA_ROOT || path14.join(os4.homedir(), "episoda");
+  return process.env.EPISODA_ROOT || path15.join(os5.homedir(), "episoda");
 }
 function getWorktreeInfo(moduleUid, workspaceSlug, projectSlug) {
   const root = getEpisodaRoot2();
-  const worktreePath = path14.join(root, workspaceSlug, projectSlug, moduleUid);
+  const worktreePath = path15.join(root, workspaceSlug, projectSlug, moduleUid);
   return {
     path: worktreePath,
-    exists: fs13.existsSync(worktreePath),
+    exists: fs14.existsSync(worktreePath),
     moduleUid
   };
 }
@@ -6087,7 +6247,7 @@ async function getProjectRootPath() {
   if (!config?.workspace_slug || !config?.project_slug) {
     return null;
   }
-  return path14.join(
+  return path15.join(
     getEpisodaRoot2(),
     config.workspace_slug,
     config.project_slug
@@ -6137,61 +6297,61 @@ function clearAllPorts() {
 }
 
 // src/framework-detector.ts
-var fs14 = __toESM(require("fs"));
-var path15 = __toESM(require("path"));
+var fs15 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
 function getInstallCommand(cwd) {
-  if (fs14.existsSync(path15.join(cwd, "bun.lockb"))) {
+  if (fs15.existsSync(path16.join(cwd, "bun.lockb"))) {
     return {
       command: ["bun", "install"],
       description: "Installing dependencies with bun",
       detectedFrom: "bun.lockb"
     };
   }
-  if (fs14.existsSync(path15.join(cwd, "pnpm-lock.yaml"))) {
+  if (fs15.existsSync(path16.join(cwd, "pnpm-lock.yaml"))) {
     return {
       command: ["pnpm", "install"],
       description: "Installing dependencies with pnpm",
       detectedFrom: "pnpm-lock.yaml"
     };
   }
-  if (fs14.existsSync(path15.join(cwd, "yarn.lock"))) {
+  if (fs15.existsSync(path16.join(cwd, "yarn.lock"))) {
     return {
       command: ["yarn", "install"],
       description: "Installing dependencies with yarn",
       detectedFrom: "yarn.lock"
     };
   }
-  if (fs14.existsSync(path15.join(cwd, "package-lock.json"))) {
+  if (fs15.existsSync(path16.join(cwd, "package-lock.json"))) {
     return {
       command: ["npm", "ci"],
       description: "Installing dependencies with npm ci",
       detectedFrom: "package-lock.json"
     };
   }
-  if (fs14.existsSync(path15.join(cwd, "package.json"))) {
+  if (fs15.existsSync(path16.join(cwd, "package.json"))) {
     return {
       command: ["npm", "install"],
       description: "Installing dependencies with npm",
       detectedFrom: "package.json"
     };
   }
-  if (fs14.existsSync(path15.join(cwd, "Pipfile.lock")) || fs14.existsSync(path15.join(cwd, "Pipfile"))) {
+  if (fs15.existsSync(path16.join(cwd, "Pipfile.lock")) || fs15.existsSync(path16.join(cwd, "Pipfile"))) {
     return {
       command: ["pipenv", "install"],
       description: "Installing dependencies with pipenv",
-      detectedFrom: fs14.existsSync(path15.join(cwd, "Pipfile.lock")) ? "Pipfile.lock" : "Pipfile"
+      detectedFrom: fs15.existsSync(path16.join(cwd, "Pipfile.lock")) ? "Pipfile.lock" : "Pipfile"
     };
   }
-  if (fs14.existsSync(path15.join(cwd, "poetry.lock"))) {
+  if (fs15.existsSync(path16.join(cwd, "poetry.lock"))) {
     return {
       command: ["poetry", "install"],
       description: "Installing dependencies with poetry",
       detectedFrom: "poetry.lock"
     };
   }
-  if (fs14.existsSync(path15.join(cwd, "pyproject.toml"))) {
-    const pyprojectPath = path15.join(cwd, "pyproject.toml");
-    const content = fs14.readFileSync(pyprojectPath, "utf-8");
+  if (fs15.existsSync(path16.join(cwd, "pyproject.toml"))) {
+    const pyprojectPath = path16.join(cwd, "pyproject.toml");
+    const content = fs15.readFileSync(pyprojectPath, "utf-8");
     if (content.includes("[tool.poetry]")) {
       return {
         command: ["poetry", "install"],
@@ -6200,41 +6360,41 @@ function getInstallCommand(cwd) {
       };
     }
   }
-  if (fs14.existsSync(path15.join(cwd, "requirements.txt"))) {
+  if (fs15.existsSync(path16.join(cwd, "requirements.txt"))) {
     return {
       command: ["pip", "install", "-r", "requirements.txt"],
       description: "Installing dependencies with pip",
       detectedFrom: "requirements.txt"
     };
   }
-  if (fs14.existsSync(path15.join(cwd, "Gemfile.lock")) || fs14.existsSync(path15.join(cwd, "Gemfile"))) {
+  if (fs15.existsSync(path16.join(cwd, "Gemfile.lock")) || fs15.existsSync(path16.join(cwd, "Gemfile"))) {
     return {
       command: ["bundle", "install"],
       description: "Installing dependencies with bundler",
-      detectedFrom: fs14.existsSync(path15.join(cwd, "Gemfile.lock")) ? "Gemfile.lock" : "Gemfile"
+      detectedFrom: fs15.existsSync(path16.join(cwd, "Gemfile.lock")) ? "Gemfile.lock" : "Gemfile"
     };
   }
-  if (fs14.existsSync(path15.join(cwd, "go.sum")) || fs14.existsSync(path15.join(cwd, "go.mod"))) {
+  if (fs15.existsSync(path16.join(cwd, "go.sum")) || fs15.existsSync(path16.join(cwd, "go.mod"))) {
     return {
       command: ["go", "mod", "download"],
       description: "Downloading Go modules",
-      detectedFrom: fs14.existsSync(path15.join(cwd, "go.sum")) ? "go.sum" : "go.mod"
+      detectedFrom: fs15.existsSync(path16.join(cwd, "go.sum")) ? "go.sum" : "go.mod"
     };
   }
-  if (fs14.existsSync(path15.join(cwd, "Cargo.lock")) || fs14.existsSync(path15.join(cwd, "Cargo.toml"))) {
+  if (fs15.existsSync(path16.join(cwd, "Cargo.lock")) || fs15.existsSync(path16.join(cwd, "Cargo.toml"))) {
     return {
       command: ["cargo", "build"],
       description: "Building Rust project (downloads dependencies)",
-      detectedFrom: fs14.existsSync(path15.join(cwd, "Cargo.lock")) ? "Cargo.lock" : "Cargo.toml"
+      detectedFrom: fs15.existsSync(path16.join(cwd, "Cargo.lock")) ? "Cargo.lock" : "Cargo.toml"
     };
   }
   return null;
 }
 
 // src/daemon/daemon-process.ts
-var fs15 = __toESM(require("fs"));
-var os5 = __toESM(require("os"));
-var path16 = __toESM(require("path"));
+var fs16 = __toESM(require("fs"));
+var os6 = __toESM(require("os"));
+var path17 = __toESM(require("path"));
 var packageJson = require_package();
 async function ensureValidToken(config, bufferMs = 5 * 60 * 1e3) {
   const now = Date.now();
@@ -6303,7 +6463,7 @@ async function fetchWithAuth(url, options = {}, retryOnUnauthorized = true) {
   }
   return response;
 }
-async function fetchEnvVars() {
+async function fetchEnvVars2() {
   try {
     const config = await (0, import_core10.loadConfig)();
     if (!config?.project_id) {
@@ -6446,9 +6606,9 @@ var Daemon = class _Daemon {
         machineId: this.machineId,
         deviceId: this.deviceId,
         // EP726: UUID for unified device identification
-        hostname: os5.hostname(),
-        platform: os5.platform(),
-        arch: os5.arch(),
+        hostname: os6.hostname(),
+        platform: os6.platform(),
+        arch: os6.arch(),
         projects
       };
     });
@@ -6731,7 +6891,7 @@ var Daemon = class _Daemon {
         client.updateActivity();
         try {
           const gitCmd = message.command;
-          const bareRepoPath = path16.join(projectPath, ".bare");
+          const bareRepoPath = path17.join(projectPath, ".bare");
           const cwd = gitCmd.worktreePath || bareRepoPath;
           if (gitCmd.worktreePath) {
             console.log(`[Daemon] Routing command to worktree: ${gitCmd.worktreePath}`);
@@ -7251,7 +7411,7 @@ var Daemon = class _Daemon {
                 }
                 const worktreeConfig = await (0, import_core10.loadConfig)();
                 const setupConfig = worktreeConfig?.project_settings;
-                const envVars = await fetchEnvVars();
+                const envVars = await fetchEnvVars2();
                 const hasEnvVars = Object.keys(envVars).length > 0;
                 const hasSetupConfig = setupConfig?.worktree_copy_files?.length || setupConfig?.worktree_setup_script || hasEnvVars;
                 {
@@ -7365,8 +7525,8 @@ var Daemon = class _Daemon {
       let daemonPid;
       try {
         const pidPath = getPidFilePath();
-        if (fs15.existsSync(pidPath)) {
-          const pidStr = fs15.readFileSync(pidPath, "utf-8").trim();
+        if (fs16.existsSync(pidPath)) {
+          const pidStr = fs16.readFileSync(pidPath, "utf-8").trim();
           daemonPid = parseInt(pidStr, 10);
         }
       } catch (pidError) {
@@ -7390,9 +7550,9 @@ var Daemon = class _Daemon {
         client.once("auth_error", errorHandler);
       });
       await client.connect(wsUrl, config.access_token, this.machineId, {
-        hostname: os5.hostname(),
-        osPlatform: os5.platform(),
-        osArch: os5.arch(),
+        hostname: os6.hostname(),
+        osPlatform: os6.platform(),
+        osArch: os6.arch(),
         daemonPid
       });
       console.log(`[Daemon] Successfully connected to project ${projectId}`);
@@ -7487,27 +7647,27 @@ var Daemon = class _Daemon {
    */
   async installGitHooks(projectPath) {
     const hooks = ["post-checkout", "pre-commit", "post-commit"];
-    const hooksDir = path16.join(projectPath, ".git", "hooks");
-    if (!fs15.existsSync(hooksDir)) {
+    const hooksDir = path17.join(projectPath, ".git", "hooks");
+    if (!fs16.existsSync(hooksDir)) {
       console.warn(`[Daemon] Hooks directory not found: ${hooksDir}`);
       return;
     }
     for (const hookName of hooks) {
       try {
-        const hookPath = path16.join(hooksDir, hookName);
-        const bundledHookPath = path16.join(__dirname, "..", "hooks", hookName);
-        if (!fs15.existsSync(bundledHookPath)) {
+        const hookPath = path17.join(hooksDir, hookName);
+        const bundledHookPath = path17.join(__dirname, "..", "hooks", hookName);
+        if (!fs16.existsSync(bundledHookPath)) {
           console.warn(`[Daemon] Bundled hook not found: ${bundledHookPath}`);
           continue;
         }
-        const hookContent = fs15.readFileSync(bundledHookPath, "utf-8");
-        if (fs15.existsSync(hookPath)) {
-          const existingContent = fs15.readFileSync(hookPath, "utf-8");
+        const hookContent = fs16.readFileSync(bundledHookPath, "utf-8");
+        if (fs16.existsSync(hookPath)) {
+          const existingContent = fs16.readFileSync(hookPath, "utf-8");
           if (existingContent === hookContent) {
             continue;
           }
         }
-        fs15.writeFileSync(hookPath, hookContent, { mode: 493 });
+        fs16.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);
@@ -7739,7 +7899,7 @@ var Daemon = class _Daemon {
             continue;
           }
           const setupConfig = config.project_settings;
-          const envVars = await fetchEnvVars();
+          const envVars = await fetchEnvVars2();
           console.log(`[Daemon] EP995: Starting setup for reconciled module ${moduleUid}`);
           await worktreeManager.updateWorktreeStatus(moduleUid, "pending");
           await this.updateModuleWorktreeStatus(moduleUid, "pending", newWorktree.path);
@@ -8623,8 +8783,8 @@ var Daemon = class _Daemon {
     await this.shutdown();
     try {
       const pidPath = getPidFilePath();
-      if (fs15.existsSync(pidPath)) {
-        fs15.unlinkSync(pidPath);
+      if (fs16.existsSync(pidPath)) {
+        fs16.unlinkSync(pidPath);
         console.log("[Daemon] PID file cleaned up");
       }
     } catch (error) {