episoda 0.2.84 → 0.2.86

package/dist/daemon/daemon-process.js

@@ -1563,15 +1563,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 fs19 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+            const fs20 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
             const rebaseMergePath = `${gitDirPath}/rebase-merge`;
             const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
             try {
-              await fs19.access(rebaseMergePath);
+              await fs20.access(rebaseMergePath);
               inRebase = true;
             } catch {
               try {
-                await fs19.access(rebaseApplyPath);
+                await fs20.access(rebaseApplyPath);
                 inRebase = true;
               } catch {
                 inRebase = false;
@@ -1625,9 +1625,9 @@ var require_git_executor = __commonJS({
               error: validation.error || "UNKNOWN_ERROR"
             };
           }
-          const fs19 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs20 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs19.access(command.path);
+            await fs20.access(command.path);
             return {
               success: false,
               error: "WORKTREE_EXISTS",
@@ -1681,9 +1681,9 @@ var require_git_executor = __commonJS({
        */
       async executeWorktreeRemove(command, cwd, options) {
         try {
-          const fs19 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs20 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs19.access(command.path);
+            await fs20.access(command.path);
           } catch {
             return {
               success: false,
@@ -1718,7 +1718,7 @@ var require_git_executor = __commonJS({
           const result = await this.runGitCommand(args, cwd, options);
           if (result.success) {
             try {
-              await fs19.rm(command.path, { recursive: true, force: true });
+              await fs20.rm(command.path, { recursive: true, force: true });
             } catch {
             }
             return {
@@ -1852,10 +1852,10 @@ var require_git_executor = __commonJS({
        */
       async executeCloneBare(command, options) {
         try {
-          const fs19 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path20 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs20 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path21 = await Promise.resolve().then(() => __importStar(require("path")));
           try {
-            await fs19.access(command.path);
+            await fs20.access(command.path);
             return {
               success: false,
               error: "BRANCH_ALREADY_EXISTS",
@@ -1864,9 +1864,9 @@ var require_git_executor = __commonJS({
             };
           } catch {
           }
-          const parentDir = path20.dirname(command.path);
+          const parentDir = path21.dirname(command.path);
           try {
-            await fs19.mkdir(parentDir, { recursive: true });
+            await fs20.mkdir(parentDir, { recursive: true });
           } catch {
           }
           const { stdout, stderr } = await execAsync2(
@@ -1914,22 +1914,22 @@ var require_git_executor = __commonJS({
        */
       async executeProjectInfo(cwd, options) {
         try {
-          const fs19 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path20 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs20 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path21 = await Promise.resolve().then(() => __importStar(require("path")));
           let currentPath = cwd;
           let projectPath = cwd;
           let bareRepoPath;
           for (let i = 0; i < 10; i++) {
-            const bareDir = path20.join(currentPath, ".bare");
-            const episodaDir = path20.join(currentPath, ".episoda");
+            const bareDir = path21.join(currentPath, ".bare");
+            const episodaDir = path21.join(currentPath, ".episoda");
             try {
-              await fs19.access(bareDir);
-              await fs19.access(episodaDir);
+              await fs20.access(bareDir);
+              await fs20.access(episodaDir);
               projectPath = currentPath;
               bareRepoPath = bareDir;
               break;
             } catch {
-              const parentPath = path20.dirname(currentPath);
+              const parentPath = path21.dirname(currentPath);
               if (parentPath === currentPath) {
                 break;
               }
@@ -2564,31 +2564,31 @@ var require_auth = __commonJS({
     exports2.loadConfig = loadConfig7;
     exports2.saveConfig = saveConfig2;
     exports2.validateToken = validateToken;
-    var fs19 = __importStar(require("fs"));
-    var path20 = __importStar(require("path"));
+    var fs20 = __importStar(require("fs"));
+    var path21 = __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 || path20.join(os9.homedir(), ".episoda");
+      return process.env.EPISODA_CONFIG_DIR || path21.join(os9.homedir(), ".episoda");
     }
     function getConfigPath(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path20.join(getConfigDir8(), DEFAULT_CONFIG_FILE);
+      return path21.join(getConfigDir8(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path20.dirname(configPath);
-      const isNew = !fs19.existsSync(dir);
+      const dir = path21.dirname(configPath);
+      const isNew = !fs20.existsSync(dir);
       if (isNew) {
-        fs19.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs20.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path20.join(dir, ".nosync");
-        if (isNew || !fs19.existsSync(nosyncPath)) {
+        const nosyncPath = path21.join(dir, ".nosync");
+        if (isNew || !fs20.existsSync(nosyncPath)) {
           try {
-            fs19.writeFileSync(nosyncPath, "", { mode: 384 });
+            fs20.writeFileSync(nosyncPath, "", { mode: 384 });
             (0, child_process_1.execSync)(`xattr -w com.apple.fileprovider.ignore 1 "${dir}"`, {
               stdio: "ignore",
               timeout: 5e3
@@ -2600,9 +2600,9 @@ var require_auth = __commonJS({
     }
     async function loadConfig7(configPath) {
       const fullPath = getConfigPath(configPath);
-      if (fs19.existsSync(fullPath)) {
+      if (fs20.existsSync(fullPath)) {
         try {
-          const content = fs19.readFileSync(fullPath, "utf8");
+          const content = fs20.readFileSync(fullPath, "utf8");
           const config = JSON.parse(content);
           return config;
         } catch (error) {
@@ -2631,7 +2631,7 @@ var require_auth = __commonJS({
       ensureConfigDir(fullPath);
       try {
         const content = JSON.stringify(config, null, 2);
-        fs19.writeFileSync(fullPath, content, { mode: 384 });
+        fs20.writeFileSync(fullPath, content, { mode: 384 });
       } catch (error) {
         throw new Error(`Failed to save config: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -2748,7 +2748,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.84",
+      version: "0.2.86",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -2782,7 +2782,8 @@ var require_package = __commonJS({
         zod: "^4.0.10"
       },
       optionalDependencies: {
-        "@anthropic-ai/claude-code": "^2.0.0"
+        "@anthropic-ai/claude-code": "^2.0.0",
+        "@openai/codex": "^0.86.0"
       },
       devDependencies: {
         "@episoda/core": "*",
@@ -4947,10 +4948,118 @@ async function ensureClaudeBinary() {
   );
 }
 
-// src/agent/agent-manager.ts
+// src/agent/codex-binary.ts
 var import_child_process8 = require("child_process");
 var path9 = __toESM(require("path"));
 var fs8 = __toESM(require("fs"));
+var cachedBinaryPath2 = null;
+function isValidCodexBinary(binaryPath) {
+  try {
+    fs8.accessSync(binaryPath, fs8.constants.X_OK);
+    const version = (0, import_child_process8.execSync)(`"${binaryPath}" --version`, {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (version && /codex.*\d+\.\d+/i.test(version)) {
+      console.log(`[CodexBinary] Found Codex CLI at ${binaryPath}: ${version}`);
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function ensureCodexBinary() {
+  if (cachedBinaryPath2) {
+    return cachedBinaryPath2;
+  }
+  try {
+    const pathResult = (0, import_child_process8.execSync)("which codex", {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (pathResult && isValidCodexBinary(pathResult)) {
+      cachedBinaryPath2 = pathResult;
+      return cachedBinaryPath2;
+    }
+  } catch {
+  }
+  const bundledPaths = [
+    // In production: node_modules/.bin/codex
+    path9.join(__dirname, "..", "..", "node_modules", ".bin", "codex"),
+    // In monorepo development: packages/episoda/node_modules/.bin/codex
+    path9.join(__dirname, "..", "..", "..", "..", "node_modules", ".bin", "codex"),
+    // Root monorepo node_modules
+    path9.join(__dirname, "..", "..", "..", "..", "..", "node_modules", ".bin", "codex")
+  ];
+  for (const bundledPath of bundledPaths) {
+    if (fs8.existsSync(bundledPath) && isValidCodexBinary(bundledPath)) {
+      cachedBinaryPath2 = bundledPath;
+      return cachedBinaryPath2;
+    }
+  }
+  try {
+    const npxResult = (0, import_child_process8.execSync)("npx --yes @openai/codex --version", {
+      encoding: "utf-8",
+      timeout: 3e4,
+      // npx might need to download
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (npxResult && /codex.*\d+\.\d+/i.test(npxResult)) {
+      cachedBinaryPath2 = "npx:@openai/codex";
+      console.log(`[CodexBinary] Using npx to run Codex CLI: ${npxResult}`);
+      return cachedBinaryPath2;
+    }
+  } catch {
+  }
+  throw new Error(
+    "Codex CLI not found. Please install it globally with: npm install -g @openai/codex"
+  );
+}
+
+// src/agent/codex-config.ts
+function generateCodexAuthJson(credentials) {
+  const tokens = {
+    id_token: credentials.idToken || credentials.accessToken,
+    // Fallback to access_token if no id_token
+    access_token: credentials.accessToken
+  };
+  if (credentials.refreshToken) {
+    tokens.refresh_token = credentials.refreshToken;
+  }
+  if (credentials.accountId) {
+    tokens.account_id = credentials.accountId;
+  }
+  const authData = {
+    OPENAI_API_KEY: null,
+    // This null is expected by Codex CLI
+    tokens,
+    last_refresh: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return JSON.stringify(authData, null, 2);
+}
+function generateCodexConfigToml(projectPath) {
+  const escapedPath = projectPath.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  return `[projects."${escapedPath}"]
+trust_level = "trusted"
+`;
+}
+function generateCodexConfig(credentials, projectPath) {
+  const files = {
+    "auth.json": generateCodexAuthJson(credentials)
+  };
+  if (projectPath) {
+    files["config.toml"] = generateCodexConfigToml(projectPath);
+  }
+  return files;
+}
+
+// src/agent/agent-manager.ts
+var import_child_process9 = require("child_process");
+var path10 = __toESM(require("path"));
+var fs9 = __toESM(require("fs"));
 var os3 = __toESM(require("os"));
 
 // src/agent/claude-config.ts
@@ -5255,11 +5364,30 @@ var AgentManager = class {
     this.sessions = /* @__PURE__ */ new Map();
     this.processes = /* @__PURE__ */ new Map();
     this.initialized = false;
-    this.pidDir = path9.join(os3.homedir(), ".episoda", "agent-pids");
+    // EP1133: Lock for config file writes to prevent race conditions
+    this.configWriteLock = Promise.resolve();
+    this.pidDir = path10.join(os3.homedir(), ".episoda", "agent-pids");
+  }
+  /**
+   * EP1133: Acquire lock for config file writes
+   * Ensures sequential writes to prevent file corruption
+   */
+  async withConfigLock(fn) {
+    const previousLock = this.configWriteLock;
+    let releaseLock;
+    this.configWriteLock = new Promise((resolve3) => {
+      releaseLock = resolve3;
+    });
+    try {
+      await previousLock;
+      return await fn();
+    } finally {
+      releaseLock();
+    }
   }
   /**
    * Initialize the agent manager
-   * - Ensure Claude Code is available
+   * - Ensure agent CLIs are available (Claude Code, Codex)
    * - Clean up any orphaned processes from previous daemon runs
    */
   async initialize() {
@@ -5267,8 +5395,8 @@ var AgentManager = class {
       return;
     }
     console.log("[AgentManager] Initializing...");
-    if (!fs8.existsSync(this.pidDir)) {
-      fs8.mkdirSync(this.pidDir, { recursive: true });
+    if (!fs9.existsSync(this.pidDir)) {
+      fs9.mkdirSync(this.pidDir, { recursive: true });
     }
     await this.cleanupOrphanedProcesses();
     try {
@@ -5277,6 +5405,12 @@ var AgentManager = class {
     } catch (error) {
       console.warn("[AgentManager] Claude Code not available:", error instanceof Error ? error.message : error);
     }
+    try {
+      await ensureCodexBinary();
+      console.log("[AgentManager] Codex CLI binary verified");
+    } catch (error) {
+      console.warn("[AgentManager] Codex CLI not available:", error instanceof Error ? error.message : error);
+    }
     this.initialized = true;
     console.log("[AgentManager] Initialized");
   }
@@ -5285,28 +5419,38 @@ var AgentManager = class {
    *
    * Creates the session record but doesn't spawn the process yet.
    * The process is spawned on the first message.
+   *
+   * EP1133: Added provider parameter for multi-provider support
    */
   async startSession(options) {
-    const { sessionId, moduleId, moduleUid, projectPath, message, credentials, systemPrompt, onChunk, onComplete, onError } = options;
+    const { sessionId, moduleId, moduleUid, projectPath, provider = "claude", message, credentials, systemPrompt, onChunk, onComplete, onError } = options;
     if (this.sessions.has(sessionId)) {
       return { success: false, error: "Session already exists" };
     }
     const oauthToken = credentials?.oauthToken;
     const apiKey = credentials?.apiKey;
     if (!oauthToken && !apiKey) {
+      const providerName = provider === "claude" ? "Claude" : "Codex";
       return {
         success: false,
-        error: "Missing credentials. Please connect your Claude account in Settings or provide an API key."
+        error: `Missing credentials. Please connect your ${providerName} account in Settings.`
       };
     }
     const authMethod = oauthToken ? "OAuth" : "API key";
-    console.log(`[AgentManager] Using ${authMethod} authentication`);
+    console.log(`[AgentManager] Using ${provider} provider with ${authMethod} authentication`);
     try {
-      await ensureClaudeBinary();
+      if (provider === "claude") {
+        await ensureClaudeBinary();
+      } else if (provider === "codex") {
+        await ensureCodexBinary();
+      } else {
+        return { success: false, error: `Unknown provider: ${provider}` };
+      }
     } catch (error) {
+      const cliName = provider === "claude" ? "Claude Code" : "Codex CLI";
       return {
         success: false,
-        error: error instanceof Error ? error.message : "Claude Code not available"
+        error: error instanceof Error ? error.message : `${cliName} not available`
       };
     }
     const session = {
@@ -5314,6 +5458,8 @@ var AgentManager = class {
       moduleId,
       moduleUid,
       projectPath,
+      provider,
+      // EP1133: Store provider in session
       credentials,
       systemPrompt,
       status: "starting",
@@ -5321,7 +5467,7 @@ var AgentManager = class {
       lastActivityAt: /* @__PURE__ */ new Date()
     };
     this.sessions.set(sessionId, session);
-    console.log(`[AgentManager] Started session ${sessionId} for ${moduleUid}`);
+    console.log(`[AgentManager] Started ${provider} session ${sessionId} for ${moduleUid}`);
     return this.sendMessage({
       sessionId,
       message,
@@ -5334,38 +5480,70 @@ var AgentManager = class {
   /**
    * Send a message to an agent session
    *
-   * Spawns a new Claude Code process for each message.
-   * Uses --print for non-interactive mode and --output-format stream-json for structured output.
-   * Subsequent messages use --resume with the claudeSessionId for conversation continuity.
+   * Spawns a new agent CLI process for each message.
+   * EP1133: Supports both Claude Code and Codex CLI with provider-specific handling.
    */
   async sendMessage(options) {
-    const { sessionId, message, isFirstMessage, claudeSessionId, onChunk, onComplete, onError } = options;
+    const { sessionId, message, isFirstMessage, agentSessionId, claudeSessionId, onChunk, onComplete, onError } = options;
     const session = this.sessions.get(sessionId);
     if (!session) {
       return { success: false, error: "Session not found" };
     }
     session.lastActivityAt = /* @__PURE__ */ new Date();
     session.status = "running";
+    const resumeSessionId = agentSessionId || claudeSessionId;
     try {
-      const binaryPath = await ensureClaudeBinary();
-      const args = [
-        "--print",
-        // Non-interactive mode
-        "--output-format",
-        "stream-json",
-        // Structured streaming output
-        "--verbose"
-        // Required for stream-json with --print
-      ];
-      if (isFirstMessage && session.systemPrompt) {
-        args.push("--system-prompt", session.systemPrompt);
-      }
-      if (claudeSessionId) {
-        args.push("--resume", claudeSessionId);
-        session.claudeSessionId = claudeSessionId;
-      }
-      args.push("--", message);
-      console.log(`[AgentManager] Spawning Claude Code for session ${sessionId}`);
+      const provider = session.provider || "claude";
+      let binaryPath;
+      let args;
+      if (provider === "codex") {
+        binaryPath = await ensureCodexBinary();
+        args = [
+          "exec",
+          "--json",
+          // JSONL streaming output
+          "--skip-git-repo-check",
+          // Allow running outside git repos
+          "--full-auto",
+          // Automatic execution with sandbox
+          "--cd",
+          session.projectPath
+          // Working directory
+        ];
+        if (resumeSessionId) {
+          args.push("resume", resumeSessionId);
+        }
+        let fullMessage = message;
+        if (isFirstMessage && session.systemPrompt) {
+          fullMessage = `${session.systemPrompt}
+
+---
+
+${message}`;
+        }
+        args.push(fullMessage);
+      } else {
+        binaryPath = await ensureClaudeBinary();
+        args = [
+          "--print",
+          // Non-interactive mode
+          "--output-format",
+          "stream-json",
+          // Structured streaming output
+          "--verbose"
+          // Required for stream-json with --print
+        ];
+        if (isFirstMessage && session.systemPrompt) {
+          args.push("--system-prompt", session.systemPrompt);
+        }
+        if (resumeSessionId) {
+          args.push("--resume", resumeSessionId);
+          session.agentSessionId = resumeSessionId;
+          session.claudeSessionId = resumeSessionId;
+        }
+        args.push("--", message);
+      }
+      console.log(`[AgentManager] Spawning ${provider} CLI for session ${sessionId}`);
       console.log(`[AgentManager] Command: ${binaryPath} ${args.join(" ").substring(0, 100)}...`);
       let spawnCmd;
       let spawnArgs;
@@ -5378,68 +5556,110 @@ var AgentManager = class {
       }
       const useOAuth = !!session.credentials.oauthToken;
       const useApiKey = !useOAuth && !!session.credentials.apiKey;
-      const claudeDir = path9.join(os3.homedir(), ".claude");
-      const credentialsPath = path9.join(claudeDir, ".credentials.json");
-      const statsigDir = path9.join(claudeDir, "statsig");
-      if (!fs8.existsSync(claudeDir)) {
-        fs8.mkdirSync(claudeDir, { recursive: true });
-      }
-      if (!fs8.existsSync(statsigDir)) {
-        fs8.mkdirSync(statsigDir, { recursive: true });
-      }
-      if (useOAuth) {
-        const oauthCredentials = {
-          accessToken: session.credentials.oauthToken
-        };
-        if (session.credentials.refreshToken) {
-          oauthCredentials.refreshToken = session.credentials.refreshToken;
-        }
-        if (session.credentials.expiresAt) {
-          oauthCredentials.expiresAt = session.credentials.expiresAt;
-        }
-        if (session.credentials.scopes) {
-          oauthCredentials.scopes = session.credentials.scopes;
-        }
-        const credentialsContent = JSON.stringify({
-          claudeAiOauth: oauthCredentials
-        }, null, 2);
-        fs8.writeFileSync(credentialsPath, credentialsContent, { mode: 384 });
-        console.log(
-          "[AgentManager] EP1126: Wrote OAuth credentials to ~/.claude/.credentials.json (with %s fields)",
-          Object.keys(oauthCredentials).join(", ")
-        );
-        try {
-          const claudeConfig = generateClaudeConfig();
-          const statsigFiles = Object.keys(claudeConfig.statsig);
-          const hasEvaluations = statsigFiles.some((f) => f.includes("cached.evaluations"));
-          const hasStableId = statsigFiles.some((f) => f.includes("stable_id"));
-          if (!hasEvaluations || !hasStableId) {
-            throw new Error(`Invalid statsig config: missing required files (evaluations=${hasEvaluations}, stableId=${hasStableId})`);
-          }
-          const settingsPath = path9.join(claudeDir, "settings.json");
-          fs8.writeFileSync(settingsPath, claudeConfig["settings.json"], { mode: 384 });
-          console.log("[AgentManager] EP1126: Wrote settings.json");
-          for (const [filename, content] of Object.entries(claudeConfig.statsig)) {
-            const filePath = path9.join(statsigDir, filename);
-            fs8.writeFileSync(filePath, content, { mode: 420 });
-          }
-          console.log("[AgentManager] EP1126: Wrote statsig cache files (%d files) for eligibility verification", statsigFiles.length);
-        } catch (configError) {
-          console.warn("[AgentManager] EP1126: Failed to write config files:", configError instanceof Error ? configError.message : configError);
-        }
-      } else if (useApiKey) {
-        console.log("[AgentManager] EP1126: Using API key authentication (ANTHROPIC_API_KEY)");
-      }
-      const childProcess = (0, import_child_process8.spawn)(spawnCmd, spawnArgs, {
+      if (provider === "codex") {
+        await this.withConfigLock(async () => {
+          const codexDir = path10.join(os3.homedir(), ".codex");
+          if (!fs9.existsSync(codexDir)) {
+            fs9.mkdirSync(codexDir, { recursive: true });
+          }
+          if (useOAuth) {
+            const codexConfig = generateCodexConfig({
+              accessToken: session.credentials.oauthToken,
+              refreshToken: session.credentials.refreshToken,
+              idToken: session.credentials.idToken,
+              accountId: session.credentials.accountId,
+              expiresAt: session.credentials.expiresAt
+            }, session.projectPath);
+            const authJsonPath = path10.join(codexDir, "auth.json");
+            fs9.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 = path10.join(codexDir, "config.toml");
+              let existingConfig = "";
+              try {
+                existingConfig = fs9.readFileSync(configTomlPath, "utf-8");
+              } catch {
+              }
+              const escapedPathForRegex = session.projectPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+              const projectKeyPattern = new RegExp(`\\[projects\\."${escapedPathForRegex}"\\]`);
+              const projectAlreadyTrusted = projectKeyPattern.test(existingConfig);
+              if (!projectAlreadyTrusted) {
+                fs9.writeFileSync(configTomlPath, existingConfig + "\n" + codexConfig["config.toml"], { mode: 420 });
+                console.log("[AgentManager] EP1133: Updated Codex config.toml with project trust");
+              }
+            }
+          } else if (useApiKey) {
+            console.log("[AgentManager] EP1133: Using Codex with API key (OPENAI_API_KEY)");
+          }
+        });
+      } else {
+        await this.withConfigLock(async () => {
+          const claudeDir = path10.join(os3.homedir(), ".claude");
+          const credentialsPath = path10.join(claudeDir, ".credentials.json");
+          const statsigDir = path10.join(claudeDir, "statsig");
+          if (!fs9.existsSync(claudeDir)) {
+            fs9.mkdirSync(claudeDir, { recursive: true });
+          }
+          if (!fs9.existsSync(statsigDir)) {
+            fs9.mkdirSync(statsigDir, { recursive: true });
+          }
+          if (useOAuth) {
+            const oauthCredentials = {
+              accessToken: session.credentials.oauthToken
+            };
+            if (session.credentials.refreshToken) {
+              oauthCredentials.refreshToken = session.credentials.refreshToken;
+            }
+            if (session.credentials.expiresAt) {
+              oauthCredentials.expiresAt = session.credentials.expiresAt;
+            }
+            if (session.credentials.scopes) {
+              oauthCredentials.scopes = session.credentials.scopes;
+            }
+            const credentialsContent = JSON.stringify({
+              claudeAiOauth: oauthCredentials
+            }, null, 2);
+            fs9.writeFileSync(credentialsPath, credentialsContent, { mode: 384 });
+            console.log("[AgentManager] Wrote OAuth credentials to ~/.claude/.credentials.json");
+            try {
+              const claudeConfig = generateClaudeConfig();
+              const statsigFiles = Object.keys(claudeConfig.statsig);
+              const hasEvaluations = statsigFiles.some((f) => f.includes("cached.evaluations"));
+              const hasStableId = statsigFiles.some((f) => f.includes("stable_id"));
+              if (!hasEvaluations || !hasStableId) {
+                throw new Error(`Invalid statsig config: missing required files`);
+              }
+              const settingsPath = path10.join(claudeDir, "settings.json");
+              fs9.writeFileSync(settingsPath, claudeConfig["settings.json"], { mode: 384 });
+              for (const [filename, content] of Object.entries(claudeConfig.statsig)) {
+                const filePath = path10.join(statsigDir, filename);
+                fs9.writeFileSync(filePath, content, { mode: 420 });
+              }
+              console.log("[AgentManager] Wrote Claude config files");
+            } catch (configError) {
+              console.warn("[AgentManager] Failed to write Claude config files:", configError instanceof Error ? configError.message : configError);
+            }
+          } else if (useApiKey) {
+            console.log("[AgentManager] Using Claude with API key (ANTHROPIC_API_KEY)");
+          }
+        });
+      }
+      const envVars = {
+        ...process.env,
+        // Disable color output for cleaner JSON parsing
+        NO_COLOR: "1",
+        FORCE_COLOR: "0"
+      };
+      if (useApiKey && session.credentials.apiKey) {
+        if (provider === "codex") {
+          envVars.OPENAI_API_KEY = session.credentials.apiKey;
+        } else {
+          envVars.ANTHROPIC_API_KEY = session.credentials.apiKey;
+        }
+      }
+      const childProcess = (0, import_child_process9.spawn)(spawnCmd, spawnArgs, {
         cwd: session.projectPath,
-        env: {
-          ...process.env,
-          // Disable color output for cleaner JSON parsing
-          NO_COLOR: "1",
-          FORCE_COLOR: "0",
-          // Add API key if using API key auth mode
-          ...useApiKey && session.credentials.apiKey ? { ANTHROPIC_API_KEY: session.credentials.apiKey } : {}
-        },
+        env: envVars,
         stdio: ["pipe", "pipe", "pipe"]
       });
       this.processes.set(sessionId, childProcess);
@@ -5464,42 +5684,76 @@ var AgentManager = class {
           if (!line.trim()) continue;
           try {
             const parsed = JSON.parse(line);
-            switch (parsed.type) {
-              case "assistant":
-                if (parsed.message?.content) {
-                  for (const block of parsed.message.content) {
-                    if (block.type === "text" && block.text) {
-                      onChunk(block.text);
+            if (provider === "codex") {
+              switch (parsed.type) {
+                case "thread.started":
+                  if (parsed.thread_id) {
+                    extractedSessionId = parsed.thread_id;
+                    session.agentSessionId = extractedSessionId;
+                  }
+                  break;
+                case "item.completed":
+                  if (parsed.item?.type === "agent_message" && parsed.item.text) {
+                    onChunk(parsed.item.text);
+                  } else if (parsed.item?.type === "reasoning" && parsed.item.summary) {
+                    onChunk(`[Thinking: ${parsed.item.summary}]
+`);
+                  }
+                  break;
+                case "item.failed":
+                case "turn.failed":
+                  onError(parsed.item?.error || parsed.error?.message || "Codex operation failed");
+                  break;
+                case "error":
+                  onError(parsed.message || parsed.error?.message || "Unknown error from Codex");
+                  break;
+                // Ignore: turn.started, turn.completed (usage stats), item.started
+                default:
+                  if (!["turn.started", "turn.completed", "item.started"].includes(parsed.type)) {
+                    console.log(`[AgentManager] Codex event: ${parsed.type}`);
+                  }
+              }
+            } else {
+              switch (parsed.type) {
+                case "assistant":
+                  if (parsed.message?.content) {
+                    for (const block of parsed.message.content) {
+                      if (block.type === "text" && block.text) {
+                        onChunk(block.text);
+                      }
                     }
                   }
-                }
-                break;
-              case "content_block_delta":
-                if (parsed.delta?.text) {
-                  onChunk(parsed.delta.text);
-                }
-                break;
-              case "result":
-                if (parsed.session_id) {
-                  extractedSessionId = parsed.session_id;
-                  session.claudeSessionId = extractedSessionId;
-                }
-                if (parsed.result?.session_id) {
-                  extractedSessionId = parsed.result.session_id;
-                  session.claudeSessionId = extractedSessionId;
-                }
-                break;
-              case "system":
-                if (parsed.session_id) {
-                  extractedSessionId = parsed.session_id;
-                  session.claudeSessionId = extractedSessionId;
-                }
-                break;
-              case "error":
-                onError(parsed.error?.message || parsed.message || "Unknown error from Claude Code");
-                break;
-              default:
-                console.log(`[AgentManager] Unknown stream-json type: ${parsed.type}`);
+                  break;
+                case "content_block_delta":
+                  if (parsed.delta?.text) {
+                    onChunk(parsed.delta.text);
+                  }
+                  break;
+                case "result":
+                  if (parsed.session_id) {
+                    extractedSessionId = parsed.session_id;
+                    session.agentSessionId = extractedSessionId;
+                    session.claudeSessionId = extractedSessionId;
+                  }
+                  if (parsed.result?.session_id) {
+                    extractedSessionId = parsed.result.session_id;
+                    session.agentSessionId = extractedSessionId;
+                    session.claudeSessionId = extractedSessionId;
+                  }
+                  break;
+                case "system":
+                  if (parsed.session_id) {
+                    extractedSessionId = parsed.session_id;
+                    session.agentSessionId = extractedSessionId;
+                    session.claudeSessionId = extractedSessionId;
+                  }
+                  break;
+                case "error":
+                  onError(parsed.error?.message || parsed.message || "Unknown error from Claude Code");
+                  break;
+                default:
+                  console.log(`[AgentManager] Claude event: ${parsed.type}`);
+              }
             }
           } catch (parseError) {
             if (line.trim()) {
@@ -5513,15 +5767,15 @@ var AgentManager = class {
         stderrBuffer += data.toString();
       });
       childProcess.on("exit", (code, signal) => {
-        console.log(`[AgentManager] Claude Code exited for session ${sessionId}: code=${code}, signal=${signal}`);
+        console.log(`[AgentManager] ${provider} CLI exited for session ${sessionId}: code=${code}, signal=${signal}`);
         this.processes.delete(sessionId);
         this.removePidFile(sessionId);
         if (code === 0) {
           session.status = "stopped";
-          onComplete(extractedSessionId || session.claudeSessionId);
+          onComplete(extractedSessionId || session.agentSessionId || session.claudeSessionId);
         } else if (signal === "SIGINT") {
           session.status = "stopped";
-          onComplete(extractedSessionId || session.claudeSessionId);
+          onComplete(extractedSessionId || session.agentSessionId || session.claudeSessionId);
         } else {
           session.status = "error";
           const errorMsg = stderrBuffer.trim() || `Process exited with code ${code}`;
@@ -5546,13 +5800,13 @@ var AgentManager = class {
   /**
    * Abort an agent session (SIGINT)
    *
-   * Sends SIGINT to the Claude Code process to abort the current operation.
+   * Sends SIGINT to the agent CLI process to abort the current operation.
    */
   async abortSession(sessionId) {
-    const process2 = this.processes.get(sessionId);
-    if (process2 && !process2.killed) {
+    const agentProcess = this.processes.get(sessionId);
+    if (agentProcess && !agentProcess.killed) {
       console.log(`[AgentManager] Aborting session ${sessionId} with SIGINT`);
-      process2.kill("SIGINT");
+      agentProcess.kill("SIGINT");
     }
     const session = this.sessions.get(sessionId);
     if (session) {
@@ -5566,23 +5820,23 @@ var AgentManager = class {
    * If it doesn't exit within 5 seconds, sends SIGTERM.
    */
   async stopSession(sessionId) {
-    const process2 = this.processes.get(sessionId);
+    const agentProcess = this.processes.get(sessionId);
     const session = this.sessions.get(sessionId);
     if (session) {
       session.status = "stopping";
     }
-    if (process2 && !process2.killed) {
+    if (agentProcess && !agentProcess.killed) {
       console.log(`[AgentManager] Stopping session ${sessionId}`);
-      process2.kill("SIGINT");
+      agentProcess.kill("SIGINT");
       await new Promise((resolve3) => {
         const timeout = setTimeout(() => {
-          if (!process2.killed) {
+          if (!agentProcess.killed) {
             console.log(`[AgentManager] Force killing session ${sessionId}`);
-            process2.kill("SIGTERM");
+            agentProcess.kill("SIGTERM");
           }
           resolve3();
         }, 5e3);
-        process2.once("exit", () => {
+        agentProcess.once("exit", () => {
           clearTimeout(timeout);
           resolve3();
         });
@@ -5626,14 +5880,14 @@ var AgentManager = class {
    */
   async cleanupOrphanedProcesses() {
     let cleaned = 0;
-    if (!fs8.existsSync(this.pidDir)) {
+    if (!fs9.existsSync(this.pidDir)) {
       return { cleaned };
     }
-    const pidFiles = fs8.readdirSync(this.pidDir).filter((f) => f.endsWith(".pid"));
+    const pidFiles = fs9.readdirSync(this.pidDir).filter((f) => f.endsWith(".pid"));
     for (const pidFile of pidFiles) {
-      const pidPath = path9.join(this.pidDir, pidFile);
+      const pidPath = path10.join(this.pidDir, pidFile);
       try {
-        const pidStr = fs8.readFileSync(pidPath, "utf-8").trim();
+        const pidStr = fs9.readFileSync(pidPath, "utf-8").trim();
         const pid = parseInt(pidStr, 10);
         if (!isNaN(pid)) {
           try {
@@ -5644,7 +5898,7 @@ var AgentManager = class {
           } catch {
           }
         }
-        fs8.unlinkSync(pidPath);
+        fs9.unlinkSync(pidPath);
       } catch (error) {
         console.warn(`[AgentManager] Error cleaning PID file ${pidFile}:`, error);
       }
@@ -5658,17 +5912,17 @@ var AgentManager = class {
    * Write PID file for session tracking
    */
   writePidFile(sessionId, pid) {
-    const pidPath = path9.join(this.pidDir, `${sessionId}.pid`);
-    fs8.writeFileSync(pidPath, pid.toString());
+    const pidPath = path10.join(this.pidDir, `${sessionId}.pid`);
+    fs9.writeFileSync(pidPath, pid.toString());
   }
   /**
    * Remove PID file for session
    */
   removePidFile(sessionId) {
-    const pidPath = path9.join(this.pidDir, `${sessionId}.pid`);
+    const pidPath = path10.join(this.pidDir, `${sessionId}.pid`);
     try {
-      if (fs8.existsSync(pidPath)) {
-        fs8.unlinkSync(pidPath);
+      if (fs9.existsSync(pidPath)) {
+        fs9.unlinkSync(pidPath);
       }
     } catch {
     }
@@ -5699,10 +5953,10 @@ var import_events3 = require("events");
 var import_fs = require("fs");
 
 // src/preview/dev-server-runner.ts
-var import_child_process10 = require("child_process");
+var import_child_process11 = require("child_process");
 var http = __toESM(require("http"));
-var fs12 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
+var fs13 = __toESM(require("fs"));
+var path14 = __toESM(require("path"));
 var import_events2 = require("events");
 var import_core8 = __toESM(require_dist());
 
@@ -5727,13 +5981,13 @@ async function isPortInUse(port) {
 }
 
 // src/utils/env-cache.ts
-var fs10 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
+var fs11 = __toESM(require("fs"));
+var path12 = __toESM(require("path"));
 var os4 = __toESM(require("os"));
 
 // src/utils/env-setup.ts
-var fs9 = __toESM(require("fs"));
-var path10 = __toESM(require("path"));
+var fs10 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
 async function fetchEnvVars(apiUrl, accessToken) {
   try {
     const url = `${apiUrl}/api/cli/env-vars`;
@@ -5768,29 +6022,29 @@ function writeEnvFile(targetPath, envVars) {
     }
     return `${key}=${value}`;
   }).join("\n") + "\n";
-  const envPath = path10.join(targetPath, ".env");
-  fs9.writeFileSync(envPath, envContent, { mode: 384 });
+  const envPath = path11.join(targetPath, ".env");
+  fs10.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");
+var CACHE_DIR = path12.join(os4.homedir(), ".episoda", "cache");
 function getCacheFilePath(projectId) {
-  return path11.join(CACHE_DIR, `env-vars-${projectId}.json`);
+  return path12.join(CACHE_DIR, `env-vars-${projectId}.json`);
 }
 function ensureCacheDir() {
-  if (!fs10.existsSync(CACHE_DIR)) {
-    fs10.mkdirSync(CACHE_DIR, { recursive: true, mode: 448 });
+  if (!fs11.existsSync(CACHE_DIR)) {
+    fs11.mkdirSync(CACHE_DIR, { recursive: true, mode: 448 });
   }
 }
 function readCache(projectId) {
   try {
     const cacheFile = getCacheFilePath(projectId);
-    if (!fs10.existsSync(cacheFile)) {
+    if (!fs11.existsSync(cacheFile)) {
       return null;
     }
-    const content = fs10.readFileSync(cacheFile, "utf-8");
+    const content = fs11.readFileSync(cacheFile, "utf-8");
     const data = JSON.parse(content);
     if (!data.vars || typeof data.vars !== "object" || !data.fetchedAt) {
       return null;
@@ -5809,7 +6063,7 @@ function writeCache(projectId, vars) {
       fetchedAt: Date.now(),
       projectId
     };
-    fs10.writeFileSync(cacheFile, JSON.stringify(data, null, 2), { mode: 384 });
+    fs11.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);
   }
@@ -5878,11 +6132,11 @@ No cached values available as fallback.`
 }
 
 // src/preview/dev-server-registry.ts
-var fs11 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var fs12 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
 var os5 = __toESM(require("os"));
-var import_child_process9 = require("child_process");
-var DEV_SERVER_REGISTRY_DIR = path12.join(os5.homedir(), ".episoda", "dev-servers");
+var import_child_process10 = require("child_process");
+var DEV_SERVER_REGISTRY_DIR = path13.join(os5.homedir(), ".episoda", "dev-servers");
 var DevServerRegistry = class {
   constructor() {
     this.ensureRegistryDir();
@@ -5892,9 +6146,9 @@ var DevServerRegistry = class {
    */
   ensureRegistryDir() {
     try {
-      if (!fs11.existsSync(DEV_SERVER_REGISTRY_DIR)) {
+      if (!fs12.existsSync(DEV_SERVER_REGISTRY_DIR)) {
         console.log(`[DevServerRegistry] EP1042: Creating registry directory: ${DEV_SERVER_REGISTRY_DIR}`);
-        fs11.mkdirSync(DEV_SERVER_REGISTRY_DIR, { recursive: true });
+        fs12.mkdirSync(DEV_SERVER_REGISTRY_DIR, { recursive: true });
       }
     } catch (error) {
       console.error(`[DevServerRegistry] EP1042: Failed to create registry directory:`, error);
@@ -5905,7 +6159,7 @@ var DevServerRegistry = class {
    * Get the registry file path for a module
    */
   getEntryPath(moduleUid) {
-    return path12.join(DEV_SERVER_REGISTRY_DIR, `${moduleUid}.json`);
+    return path13.join(DEV_SERVER_REGISTRY_DIR, `${moduleUid}.json`);
   }
   /**
    * Register a dev server
@@ -5916,7 +6170,7 @@ var DevServerRegistry = class {
     try {
       this.ensureRegistryDir();
       const entryPath = this.getEntryPath(entry.moduleUid);
-      fs11.writeFileSync(entryPath, JSON.stringify(entry, null, 2), "utf8");
+      fs12.writeFileSync(entryPath, JSON.stringify(entry, null, 2), "utf8");
       console.log(`[DevServerRegistry] EP1042: Registered ${entry.moduleUid} (PID ${entry.pid}, port ${entry.port})`);
     } catch (error) {
       console.error(`[DevServerRegistry] EP1042: Failed to register ${entry.moduleUid}:`, error);
@@ -5930,8 +6184,8 @@ var DevServerRegistry = class {
   unregister(moduleUid) {
     try {
       const entryPath = this.getEntryPath(moduleUid);
-      if (fs11.existsSync(entryPath)) {
-        fs11.unlinkSync(entryPath);
+      if (fs12.existsSync(entryPath)) {
+        fs12.unlinkSync(entryPath);
         console.log(`[DevServerRegistry] EP1042: Unregistered ${moduleUid}`);
       }
     } catch (error) {
@@ -5947,10 +6201,10 @@ var DevServerRegistry = class {
   getByModule(moduleUid) {
     try {
       const entryPath = this.getEntryPath(moduleUid);
-      if (!fs11.existsSync(entryPath)) {
+      if (!fs12.existsSync(entryPath)) {
         return null;
       }
-      const content = fs11.readFileSync(entryPath, "utf8");
+      const content = fs12.readFileSync(entryPath, "utf8");
       const entry = JSON.parse(content);
       if (!entry.pid || !entry.port || !entry.worktreePath) {
         console.warn(`[DevServerRegistry] EP1042: Invalid entry for ${moduleUid}, removing`);
@@ -5988,7 +6242,7 @@ var DevServerRegistry = class {
     const entries = [];
     try {
       this.ensureRegistryDir();
-      const files = fs11.readdirSync(DEV_SERVER_REGISTRY_DIR).filter((f) => f.endsWith(".json"));
+      const files = fs12.readdirSync(DEV_SERVER_REGISTRY_DIR).filter((f) => f.endsWith(".json"));
       for (const file of files) {
         const moduleUid = file.replace(".json", "");
         const entry = this.getByModule(moduleUid);
@@ -6036,7 +6290,7 @@ var DevServerRegistry = class {
    */
   getProcessCwd(pid) {
     try {
-      const output = (0, import_child_process9.execSync)(`lsof -p ${pid} -Fn | grep ^n | grep cwd | head -1`, {
+      const output = (0, import_child_process10.execSync)(`lsof -p ${pid} -Fn | grep ^n | grep cwd | head -1`, {
         encoding: "utf8",
         timeout: 5e3
       }).trim();
@@ -6046,7 +6300,7 @@ var DevServerRegistry = class {
       return null;
     } catch {
       try {
-        return fs11.readlinkSync(`/proc/${pid}/cwd`);
+        return fs12.readlinkSync(`/proc/${pid}/cwd`);
       } catch {
         return null;
       }
@@ -6061,7 +6315,7 @@ var DevServerRegistry = class {
   findProcessesInWorktree(worktreePath) {
     const pids = [];
     try {
-      const output = (0, import_child_process9.execSync)(
+      const output = (0, import_child_process10.execSync)(
         `lsof -c node -c next | grep "${worktreePath}" | awk '{print $2}' | sort -u`,
         { encoding: "utf8", timeout: 5e3 }
       ).trim();
@@ -6122,7 +6376,7 @@ var DevServerRegistry = class {
    */
   findProcessesOnPort(port) {
     try {
-      const output = (0, import_child_process9.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
+      const output = (0, import_child_process10.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
       if (!output) {
         return [];
       }
@@ -6376,7 +6630,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
    */
   async killProcessOnPort(port) {
     try {
-      const result = (0, import_child_process10.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
+      const result = (0, import_child_process11.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
       if (!result) {
         return true;
       }
@@ -6384,15 +6638,15 @@ var DevServerRunner = class extends import_events2.EventEmitter {
       console.log(`[DevServerRunner] Found ${pids.length} process(es) on port ${port}`);
       for (const pid of pids) {
         try {
-          (0, import_child_process10.execSync)(`kill -15 ${pid} 2>/dev/null || true`);
+          (0, import_child_process11.execSync)(`kill -15 ${pid} 2>/dev/null || true`);
         } catch {
         }
       }
       await this.wait(1e3);
       for (const pid of pids) {
         try {
-          (0, import_child_process10.execSync)(`kill -0 ${pid} 2>/dev/null`);
-          (0, import_child_process10.execSync)(`kill -9 ${pid} 2>/dev/null || true`);
+          (0, import_child_process11.execSync)(`kill -0 ${pid} 2>/dev/null`);
+          (0, import_child_process11.execSync)(`kill -9 ${pid} 2>/dev/null || true`);
         } catch {
         }
       }
@@ -6416,8 +6670,8 @@ var DevServerRunner = class extends import_events2.EventEmitter {
         cacheTtl: 300
       });
       console.log(`[DevServerRunner] Loaded ${Object.keys(result.envVars).length} env vars`);
-      const envFilePath = path13.join(projectPath, ".env");
-      if (!fs12.existsSync(envFilePath) && Object.keys(result.envVars).length > 0) {
+      const envFilePath = path14.join(projectPath, ".env");
+      if (!fs13.existsSync(envFilePath) && Object.keys(result.envVars).length > 0) {
         console.log(`[DevServerRunner] Writing .env file`);
         writeEnvFile(projectPath, result.envVars);
       }
@@ -6441,7 +6695,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
       PORT: String(port),
       NODE_OPTIONS: enhancedNodeOptions
     };
-    const proc = (0, import_child_process10.spawn)(cmd, args, {
+    const proc = (0, import_child_process11.spawn)(cmd, args, {
       cwd: projectPath,
       env: mergedEnv,
       stdio: ["ignore", "pipe", "pipe"],
@@ -6566,25 +6820,25 @@ var DevServerRunner = class extends import_events2.EventEmitter {
     return new Promise((resolve3) => setTimeout(resolve3, ms));
   }
   getLogsDir() {
-    const logsDir = path13.join((0, import_core8.getConfigDir)(), "logs");
-    if (!fs12.existsSync(logsDir)) {
-      fs12.mkdirSync(logsDir, { recursive: true });
+    const logsDir = path14.join((0, import_core8.getConfigDir)(), "logs");
+    if (!fs13.existsSync(logsDir)) {
+      fs13.mkdirSync(logsDir, { recursive: true });
     }
     return logsDir;
   }
   getLogFilePath(moduleUid) {
-    return path13.join(this.getLogsDir(), `dev-${moduleUid}.log`);
+    return path14.join(this.getLogsDir(), `dev-${moduleUid}.log`);
   }
   rotateLogIfNeeded(logPath) {
     try {
-      if (fs12.existsSync(logPath)) {
-        const stats = fs12.statSync(logPath);
+      if (fs13.existsSync(logPath)) {
+        const stats = fs13.statSync(logPath);
         if (stats.size > DEV_SERVER_CONSTANTS.MAX_LOG_SIZE_BYTES) {
           const backupPath = `${logPath}.1`;
-          if (fs12.existsSync(backupPath)) {
-            fs12.unlinkSync(backupPath);
+          if (fs13.existsSync(backupPath)) {
+            fs13.unlinkSync(backupPath);
           }
-          fs12.renameSync(logPath, backupPath);
+          fs13.renameSync(logPath, backupPath);
         }
       }
     } catch {
@@ -6595,7 +6849,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
     try {
       const timestamp = (/* @__PURE__ */ new Date()).toISOString();
       const prefix = isError ? "ERR" : "OUT";
-      fs12.appendFileSync(logPath, `[${timestamp}] [${prefix}] ${line}
+      fs13.appendFileSync(logPath, `[${timestamp}] [${prefix}] ${line}
 `);
     } catch {
     }
@@ -6623,21 +6877,21 @@ function getDevServerRunner() {
 }
 
 // src/utils/port-allocator.ts
-var fs13 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
 var os6 = __toESM(require("os"));
 var PORT_RANGE_START = 3100;
 var PORT_RANGE_END = 3199;
 var PORT_WARNING_THRESHOLD = 80;
-var PORTS_FILE = path14.join(os6.homedir(), ".episoda", "ports.json");
+var PORTS_FILE = path15.join(os6.homedir(), ".episoda", "ports.json");
 var portAssignments = /* @__PURE__ */ new Map();
 var initialized = false;
 function loadFromDisk() {
   if (initialized) return;
   initialized = true;
   try {
-    if (fs13.existsSync(PORTS_FILE)) {
-      const content = fs13.readFileSync(PORTS_FILE, "utf8");
+    if (fs14.existsSync(PORTS_FILE)) {
+      const content = fs14.readFileSync(PORTS_FILE, "utf8");
       const data = JSON.parse(content);
       for (const [moduleUid, port] of Object.entries(data)) {
         if (typeof port === "number" && port >= PORT_RANGE_START && port <= PORT_RANGE_END) {
@@ -6654,15 +6908,15 @@ function loadFromDisk() {
 }
 function saveToDisk() {
   try {
-    const dir = path14.dirname(PORTS_FILE);
-    if (!fs13.existsSync(dir)) {
-      fs13.mkdirSync(dir, { recursive: true });
+    const dir = path15.dirname(PORTS_FILE);
+    if (!fs14.existsSync(dir)) {
+      fs14.mkdirSync(dir, { recursive: true });
     }
     const data = {};
     for (const [moduleUid, port] of portAssignments) {
       data[moduleUid] = port;
     }
-    fs13.writeFileSync(PORTS_FILE, JSON.stringify(data, null, 2), "utf8");
+    fs14.writeFileSync(PORTS_FILE, JSON.stringify(data, null, 2), "utf8");
   } catch (error) {
     console.warn(`[PortAllocator] EP1042: Failed to save ports.json:`, error);
   }
@@ -7138,10 +7392,10 @@ function getPreviewManager() {
 }
 
 // src/utils/dev-server.ts
-var import_child_process11 = require("child_process");
+var import_child_process12 = require("child_process");
 var import_core9 = __toESM(require_dist());
-var fs14 = __toESM(require("fs"));
-var path15 = __toESM(require("path"));
+var fs15 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
 var MAX_RESTART_ATTEMPTS = 5;
 var INITIAL_RESTART_DELAY_MS = 2e3;
 var MAX_RESTART_DELAY_MS = 3e4;
@@ -7149,26 +7403,26 @@ var MAX_LOG_SIZE_BYTES = 5 * 1024 * 1024;
 var NODE_MEMORY_LIMIT_MB = 2048;
 var activeServers = /* @__PURE__ */ new Map();
 function getLogsDir() {
-  const logsDir = path15.join((0, import_core9.getConfigDir)(), "logs");
-  if (!fs14.existsSync(logsDir)) {
-    fs14.mkdirSync(logsDir, { recursive: true });
+  const logsDir = path16.join((0, import_core9.getConfigDir)(), "logs");
+  if (!fs15.existsSync(logsDir)) {
+    fs15.mkdirSync(logsDir, { recursive: true });
   }
   return logsDir;
 }
 function getLogFilePath(moduleUid) {
-  return path15.join(getLogsDir(), `dev-${moduleUid}.log`);
+  return path16.join(getLogsDir(), `dev-${moduleUid}.log`);
 }
 function rotateLogIfNeeded(logPath) {
   try {
-    if (fs14.existsSync(logPath)) {
-      const stats = fs14.statSync(logPath);
+    if (fs15.existsSync(logPath)) {
+      const stats = fs15.statSync(logPath);
       if (stats.size > MAX_LOG_SIZE_BYTES) {
         const backupPath = `${logPath}.1`;
-        if (fs14.existsSync(backupPath)) {
-          fs14.unlinkSync(backupPath);
+        if (fs15.existsSync(backupPath)) {
+          fs15.unlinkSync(backupPath);
         }
-        fs14.renameSync(logPath, backupPath);
-        console.log(`[DevServer] EP932: Rotated log file for ${path15.basename(logPath)}`);
+        fs15.renameSync(logPath, backupPath);
+        console.log(`[DevServer] EP932: Rotated log file for ${path16.basename(logPath)}`);
       }
     }
   } catch (error) {
@@ -7181,13 +7435,13 @@ function writeToLog(logPath, line, isError = false) {
     const prefix = isError ? "ERR" : "OUT";
     const logLine = `[${timestamp}] [${prefix}] ${line}
 `;
-    fs14.appendFileSync(logPath, logLine);
+    fs15.appendFileSync(logPath, logLine);
   } catch {
   }
 }
 async function killProcessOnPort(port) {
   try {
-    const result = (0, import_child_process11.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
+    const result = (0, import_child_process12.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
     if (!result) {
       console.log(`[DevServer] EP929: No process found on port ${port}`);
       return true;
@@ -7196,7 +7450,7 @@ async function killProcessOnPort(port) {
     console.log(`[DevServer] EP929: Found ${pids.length} process(es) on port ${port}: ${pids.join(", ")}`);
     for (const pid of pids) {
       try {
-        (0, import_child_process11.execSync)(`kill -15 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
+        (0, import_child_process12.execSync)(`kill -15 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
         console.log(`[DevServer] EP929: Sent SIGTERM to PID ${pid}`);
       } catch {
       }
@@ -7204,8 +7458,8 @@ async function killProcessOnPort(port) {
     await new Promise((resolve3) => setTimeout(resolve3, 1e3));
     for (const pid of pids) {
       try {
-        (0, import_child_process11.execSync)(`kill -0 ${pid} 2>/dev/null`, { encoding: "utf8" });
-        (0, import_child_process11.execSync)(`kill -9 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
+        (0, import_child_process12.execSync)(`kill -0 ${pid} 2>/dev/null`, { encoding: "utf8" });
+        (0, import_child_process12.execSync)(`kill -9 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
         console.log(`[DevServer] EP929: Force killed PID ${pid}`);
       } catch {
       }
@@ -7256,7 +7510,7 @@ function spawnDevServerProcess(projectPath, port, moduleUid, logPath, customComm
   if (injectedCount > 0) {
     console.log(`[DevServer] EP998: Injecting ${injectedCount} env vars from database`);
   }
-  const devProcess = (0, import_child_process11.spawn)(cmd, args, {
+  const devProcess = (0, import_child_process12.spawn)(cmd, args, {
     cwd: projectPath,
     env: mergedEnv,
     stdio: ["ignore", "pipe", "pipe"],
@@ -7360,8 +7614,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 = path15.join(projectPath, ".env");
-      if (!fs14.existsSync(envFilePath) && Object.keys(injectedEnvVars).length > 0) {
+      const envFilePath = path16.join(projectPath, ".env");
+      if (!fs15.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);
       }
@@ -7467,8 +7721,8 @@ function getDevServerStatus() {
 }
 
 // src/daemon/worktree-manager.ts
-var fs15 = __toESM(require("fs"));
-var path16 = __toESM(require("path"));
+var fs16 = __toESM(require("fs"));
+var path17 = __toESM(require("path"));
 var import_core10 = __toESM(require_dist());
 function validateModuleUid(moduleUid) {
   if (!moduleUid || typeof moduleUid !== "string" || !moduleUid.trim()) {
@@ -7492,8 +7746,8 @@ var WorktreeManager = class _WorktreeManager {
     // ============================================================
     this.lockPath = "";
     this.projectRoot = projectRoot;
-    this.bareRepoPath = path16.join(projectRoot, ".bare");
-    this.configPath = path16.join(projectRoot, ".episoda", "config.json");
+    this.bareRepoPath = path17.join(projectRoot, ".bare");
+    this.configPath = path17.join(projectRoot, ".episoda", "config.json");
     this.gitExecutor = new import_core10.GitExecutor();
   }
   /**
@@ -7504,13 +7758,13 @@ var WorktreeManager = class _WorktreeManager {
    */
   async initialize() {
     const debug = process.env.EPISODA_DEBUG === "1" || process.env.GIT_CREDENTIAL_EPISODA_DEBUG === "1";
-    if (!fs15.existsSync(this.bareRepoPath)) {
+    if (!fs16.existsSync(this.bareRepoPath)) {
       if (debug) {
         console.log(`[WorktreeManager] initialize: .bare not found at ${this.bareRepoPath}`);
       }
       return false;
     }
-    if (!fs15.existsSync(this.configPath)) {
+    if (!fs16.existsSync(this.configPath)) {
       if (debug) {
         console.log(`[WorktreeManager] initialize: config not found at ${this.configPath}`);
       }
@@ -7542,10 +7796,10 @@ var WorktreeManager = class _WorktreeManager {
    */
   async ensureFetchRefspecConfigured() {
     try {
-      const { execSync: execSync9 } = require("child_process");
+      const { execSync: execSync10 } = require("child_process");
       let fetchRefspec = null;
       try {
-        fetchRefspec = execSync9("git config --get remote.origin.fetch", {
+        fetchRefspec = execSync10("git config --get remote.origin.fetch", {
           cwd: this.bareRepoPath,
           encoding: "utf-8",
           timeout: 5e3
@@ -7554,7 +7808,7 @@ var WorktreeManager = class _WorktreeManager {
       }
       if (!fetchRefspec) {
         console.log("[WorktreeManager] EP1014: Configuring missing fetch refspec for bare repo");
-        execSync9('git config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"', {
+        execSync10('git config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"', {
           cwd: this.bareRepoPath,
           timeout: 5e3
         });
@@ -7569,8 +7823,8 @@ var WorktreeManager = class _WorktreeManager {
    */
   static async createProject(projectRoot, repoUrl, projectId, workspaceSlug, projectSlug) {
     const manager = new _WorktreeManager(projectRoot);
-    const episodaDir = path16.join(projectRoot, ".episoda");
-    fs15.mkdirSync(episodaDir, { recursive: true });
+    const episodaDir = path17.join(projectRoot, ".episoda");
+    fs16.mkdirSync(episodaDir, { recursive: true });
     const cloneResult = await manager.gitExecutor.execute({
       action: "clone_bare",
       url: repoUrl,
@@ -7601,7 +7855,7 @@ var WorktreeManager = class _WorktreeManager {
         error: `Invalid module UID: "${moduleUid}" - contains disallowed characters`
       };
     }
-    const worktreePath = path16.join(this.projectRoot, moduleUid);
+    const worktreePath = path17.join(this.projectRoot, moduleUid);
     const lockAcquired = await this.acquireLock();
     if (!lockAcquired) {
       return {
@@ -7792,7 +8046,7 @@ var WorktreeManager = class _WorktreeManager {
     let prunedCount = 0;
     await this.updateConfigSafe((config) => {
       const initialCount = config.worktrees.length;
-      config.worktrees = config.worktrees.filter((w) => fs15.existsSync(w.worktreePath));
+      config.worktrees = config.worktrees.filter((w) => fs16.existsSync(w.worktreePath));
       prunedCount = initialCount - config.worktrees.length;
       return config;
     });
@@ -7873,16 +8127,16 @@ var WorktreeManager = class _WorktreeManager {
     const retryInterval = 50;
     while (Date.now() - startTime < timeoutMs) {
       try {
-        fs15.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+        fs16.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
         return true;
       } catch (err) {
         if (err.code === "EEXIST") {
           try {
-            const stats = fs15.statSync(lockPath);
+            const stats = fs16.statSync(lockPath);
             const lockAge = Date.now() - stats.mtimeMs;
             if (lockAge > 3e4) {
               try {
-                const lockContent = fs15.readFileSync(lockPath, "utf-8").trim();
+                const lockContent = fs16.readFileSync(lockPath, "utf-8").trim();
                 const lockPid = parseInt(lockContent, 10);
                 if (!isNaN(lockPid) && this.isProcessRunning(lockPid)) {
                   await new Promise((resolve3) => setTimeout(resolve3, retryInterval));
@@ -7891,7 +8145,7 @@ var WorktreeManager = class _WorktreeManager {
               } catch {
               }
               try {
-                fs15.unlinkSync(lockPath);
+                fs16.unlinkSync(lockPath);
               } catch {
               }
               continue;
@@ -7912,7 +8166,7 @@ var WorktreeManager = class _WorktreeManager {
    */
   releaseLock() {
     try {
-      fs15.unlinkSync(this.getLockPath());
+      fs16.unlinkSync(this.getLockPath());
     } catch {
     }
   }
@@ -7936,11 +8190,11 @@ var WorktreeManager = class _WorktreeManager {
       // Turborepo cache
     ];
     for (const cacheDir of cacheDirs) {
-      const cachePath = path16.join(worktreePath, cacheDir);
+      const cachePath = path17.join(worktreePath, cacheDir);
       try {
-        if (fs15.existsSync(cachePath)) {
+        if (fs16.existsSync(cachePath)) {
           console.log(`[WorktreeManager] EP1070: Cleaning build cache: ${cacheDir}`);
-          fs15.rmSync(cachePath, { recursive: true, force: true });
+          fs16.rmSync(cachePath, { recursive: true, force: true });
         }
       } catch (error) {
         console.warn(`[WorktreeManager] EP1070: Failed to clean ${cacheDir} (non-blocking):`, error.message);
@@ -7949,10 +8203,10 @@ var WorktreeManager = class _WorktreeManager {
   }
   readConfig() {
     try {
-      if (!fs15.existsSync(this.configPath)) {
+      if (!fs16.existsSync(this.configPath)) {
         return null;
       }
-      const content = fs15.readFileSync(this.configPath, "utf-8");
+      const content = fs16.readFileSync(this.configPath, "utf-8");
       return JSON.parse(content);
     } catch (error) {
       if (error instanceof SyntaxError) {
@@ -7966,11 +8220,11 @@ var WorktreeManager = class _WorktreeManager {
   }
   writeConfig(config) {
     try {
-      const dir = path16.dirname(this.configPath);
-      if (!fs15.existsSync(dir)) {
-        fs15.mkdirSync(dir, { recursive: true });
+      const dir = path17.dirname(this.configPath);
+      if (!fs16.existsSync(dir)) {
+        fs16.mkdirSync(dir, { recursive: true });
       }
-      fs15.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf-8");
+      fs16.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf-8");
     } catch (error) {
       console.error("[WorktreeManager] Failed to write config:", error);
       throw error;
@@ -8051,14 +8305,14 @@ var WorktreeManager = class _WorktreeManager {
     }
     try {
       for (const file of files) {
-        const srcPath = path16.join(mainWorktree.worktreePath, file);
-        const destPath = path16.join(worktree.worktreePath, file);
-        if (fs15.existsSync(srcPath)) {
-          const destDir = path16.dirname(destPath);
-          if (!fs15.existsSync(destDir)) {
-            fs15.mkdirSync(destDir, { recursive: true });
-          }
-          fs15.copyFileSync(srcPath, destPath);
+        const srcPath = path17.join(mainWorktree.worktreePath, file);
+        const destPath = path17.join(worktree.worktreePath, file);
+        if (fs16.existsSync(srcPath)) {
+          const destDir = path17.dirname(destPath);
+          if (!fs16.existsSync(destDir)) {
+            fs16.mkdirSync(destDir, { recursive: true });
+          }
+          fs16.copyFileSync(srcPath, destPath);
           console.log(`[WorktreeManager] EP964: Copied ${file} to ${moduleUid} (deprecated)`);
         } else {
           console.log(`[WorktreeManager] EP964: Skipped ${file} (not found in main)`);
@@ -8089,8 +8343,8 @@ var WorktreeManager = class _WorktreeManager {
     console.log(`[WorktreeManager] EP959:   Timeout: ${TIMEOUT_MINUTES} minutes`);
     console.log(`[WorktreeManager] EP959:   Script: ${scriptPreview}`);
     try {
-      const { execSync: execSync9 } = require("child_process");
-      execSync9(script, {
+      const { execSync: execSync10 } = require("child_process");
+      execSync10(script, {
         cwd: worktree.worktreePath,
         stdio: "inherit",
         timeout: TIMEOUT_MINUTES * 60 * 1e3,
@@ -8124,8 +8378,8 @@ var WorktreeManager = class _WorktreeManager {
     console.log(`[WorktreeManager] EP959:   Timeout: ${TIMEOUT_MINUTES} minutes`);
     console.log(`[WorktreeManager] EP959:   Script: ${scriptPreview}`);
     try {
-      const { execSync: execSync9 } = require("child_process");
-      execSync9(script, {
+      const { execSync: execSync10 } = require("child_process");
+      execSync10(script, {
         cwd: worktree.worktreePath,
         stdio: "inherit",
         timeout: TIMEOUT_MINUTES * 60 * 1e3,
@@ -8141,7 +8395,7 @@ var WorktreeManager = class _WorktreeManager {
   }
 };
 function getEpisodaRoot() {
-  return process.env.EPISODA_ROOT || path16.join(require("os").homedir(), "episoda");
+  return process.env.EPISODA_ROOT || path17.join(require("os").homedir(), "episoda");
 }
 async function isWorktreeProject(projectRoot) {
   const debug = process.env.EPISODA_DEBUG === "1" || process.env.GIT_CREDENTIAL_EPISODA_DEBUG === "1";
@@ -8156,7 +8410,7 @@ async function isWorktreeProject(projectRoot) {
   return result;
 }
 async function findProjectRoot(startPath) {
-  let current = path16.resolve(startPath);
+  let current = path17.resolve(startPath);
   const episodaRoot = getEpisodaRoot();
   const debug = process.env.EPISODA_DEBUG === "1" || process.env.GIT_CREDENTIAL_EPISODA_DEBUG === "1";
   if (debug) {
@@ -8169,14 +8423,14 @@ async function findProjectRoot(startPath) {
     return null;
   }
   for (let i = 0; i < 10; i++) {
-    const bareDir = path16.join(current, ".bare");
-    const episodaDir = path16.join(current, ".episoda");
+    const bareDir = path17.join(current, ".bare");
+    const episodaDir = path17.join(current, ".episoda");
     if (debug) {
-      const bareExists = fs15.existsSync(bareDir);
-      const episodaExists = fs15.existsSync(episodaDir);
+      const bareExists = fs16.existsSync(bareDir);
+      const episodaExists = fs16.existsSync(episodaDir);
       console.log(`[WorktreeManager] findProjectRoot: checking ${current} (.bare=${bareExists}, .episoda=${episodaExists})`);
     }
-    if (fs15.existsSync(bareDir) && fs15.existsSync(episodaDir)) {
+    if (fs16.existsSync(bareDir) && fs16.existsSync(episodaDir)) {
       if (await isWorktreeProject(current)) {
         if (debug) {
           console.log(`[WorktreeManager] findProjectRoot: found valid project at ${current}`);
@@ -8184,7 +8438,7 @@ async function findProjectRoot(startPath) {
         return current;
       }
     }
-    const parent = path16.dirname(current);
+    const parent = path17.dirname(current);
     if (parent === current) {
       break;
     }
@@ -8197,19 +8451,19 @@ async function findProjectRoot(startPath) {
 }
 
 // src/utils/worktree.ts
-var path17 = __toESM(require("path"));
-var fs16 = __toESM(require("fs"));
+var path18 = __toESM(require("path"));
+var fs17 = __toESM(require("fs"));
 var os7 = __toESM(require("os"));
 var import_core11 = __toESM(require_dist());
 function getEpisodaRoot2() {
-  return process.env.EPISODA_ROOT || path17.join(os7.homedir(), "episoda");
+  return process.env.EPISODA_ROOT || path18.join(os7.homedir(), "episoda");
 }
 function getWorktreeInfo(moduleUid, workspaceSlug, projectSlug) {
   const root = getEpisodaRoot2();
-  const worktreePath = path17.join(root, workspaceSlug, projectSlug, moduleUid);
+  const worktreePath = path18.join(root, workspaceSlug, projectSlug, moduleUid);
   return {
     path: worktreePath,
-    exists: fs16.existsSync(worktreePath),
+    exists: fs17.existsSync(worktreePath),
     moduleUid
   };
 }
@@ -8223,61 +8477,61 @@ async function getWorktreeInfoForModule(moduleUid) {
 }
 
 // src/framework-detector.ts
-var fs17 = __toESM(require("fs"));
-var path18 = __toESM(require("path"));
+var fs18 = __toESM(require("fs"));
+var path19 = __toESM(require("path"));
 function getInstallCommand(cwd) {
-  if (fs17.existsSync(path18.join(cwd, "bun.lockb"))) {
+  if (fs18.existsSync(path19.join(cwd, "bun.lockb"))) {
     return {
       command: ["bun", "install"],
       description: "Installing dependencies with bun",
       detectedFrom: "bun.lockb"
     };
   }
-  if (fs17.existsSync(path18.join(cwd, "pnpm-lock.yaml"))) {
+  if (fs18.existsSync(path19.join(cwd, "pnpm-lock.yaml"))) {
     return {
       command: ["pnpm", "install"],
       description: "Installing dependencies with pnpm",
       detectedFrom: "pnpm-lock.yaml"
     };
   }
-  if (fs17.existsSync(path18.join(cwd, "yarn.lock"))) {
+  if (fs18.existsSync(path19.join(cwd, "yarn.lock"))) {
     return {
       command: ["yarn", "install"],
       description: "Installing dependencies with yarn",
       detectedFrom: "yarn.lock"
     };
   }
-  if (fs17.existsSync(path18.join(cwd, "package-lock.json"))) {
+  if (fs18.existsSync(path19.join(cwd, "package-lock.json"))) {
     return {
       command: ["npm", "ci"],
       description: "Installing dependencies with npm ci",
       detectedFrom: "package-lock.json"
     };
   }
-  if (fs17.existsSync(path18.join(cwd, "package.json"))) {
+  if (fs18.existsSync(path19.join(cwd, "package.json"))) {
     return {
       command: ["npm", "install"],
       description: "Installing dependencies with npm",
       detectedFrom: "package.json"
     };
   }
-  if (fs17.existsSync(path18.join(cwd, "Pipfile.lock")) || fs17.existsSync(path18.join(cwd, "Pipfile"))) {
+  if (fs18.existsSync(path19.join(cwd, "Pipfile.lock")) || fs18.existsSync(path19.join(cwd, "Pipfile"))) {
     return {
       command: ["pipenv", "install"],
       description: "Installing dependencies with pipenv",
-      detectedFrom: fs17.existsSync(path18.join(cwd, "Pipfile.lock")) ? "Pipfile.lock" : "Pipfile"
+      detectedFrom: fs18.existsSync(path19.join(cwd, "Pipfile.lock")) ? "Pipfile.lock" : "Pipfile"
     };
   }
-  if (fs17.existsSync(path18.join(cwd, "poetry.lock"))) {
+  if (fs18.existsSync(path19.join(cwd, "poetry.lock"))) {
     return {
       command: ["poetry", "install"],
       description: "Installing dependencies with poetry",
       detectedFrom: "poetry.lock"
     };
   }
-  if (fs17.existsSync(path18.join(cwd, "pyproject.toml"))) {
-    const pyprojectPath = path18.join(cwd, "pyproject.toml");
-    const content = fs17.readFileSync(pyprojectPath, "utf-8");
+  if (fs18.existsSync(path19.join(cwd, "pyproject.toml"))) {
+    const pyprojectPath = path19.join(cwd, "pyproject.toml");
+    const content = fs18.readFileSync(pyprojectPath, "utf-8");
     if (content.includes("[tool.poetry]")) {
       return {
         command: ["poetry", "install"],
@@ -8286,41 +8540,41 @@ function getInstallCommand(cwd) {
       };
     }
   }
-  if (fs17.existsSync(path18.join(cwd, "requirements.txt"))) {
+  if (fs18.existsSync(path19.join(cwd, "requirements.txt"))) {
     return {
       command: ["pip", "install", "-r", "requirements.txt"],
       description: "Installing dependencies with pip",
       detectedFrom: "requirements.txt"
     };
   }
-  if (fs17.existsSync(path18.join(cwd, "Gemfile.lock")) || fs17.existsSync(path18.join(cwd, "Gemfile"))) {
+  if (fs18.existsSync(path19.join(cwd, "Gemfile.lock")) || fs18.existsSync(path19.join(cwd, "Gemfile"))) {
     return {
       command: ["bundle", "install"],
       description: "Installing dependencies with bundler",
-      detectedFrom: fs17.existsSync(path18.join(cwd, "Gemfile.lock")) ? "Gemfile.lock" : "Gemfile"
+      detectedFrom: fs18.existsSync(path19.join(cwd, "Gemfile.lock")) ? "Gemfile.lock" : "Gemfile"
     };
   }
-  if (fs17.existsSync(path18.join(cwd, "go.sum")) || fs17.existsSync(path18.join(cwd, "go.mod"))) {
+  if (fs18.existsSync(path19.join(cwd, "go.sum")) || fs18.existsSync(path19.join(cwd, "go.mod"))) {
     return {
       command: ["go", "mod", "download"],
       description: "Downloading Go modules",
-      detectedFrom: fs17.existsSync(path18.join(cwd, "go.sum")) ? "go.sum" : "go.mod"
+      detectedFrom: fs18.existsSync(path19.join(cwd, "go.sum")) ? "go.sum" : "go.mod"
     };
   }
-  if (fs17.existsSync(path18.join(cwd, "Cargo.lock")) || fs17.existsSync(path18.join(cwd, "Cargo.toml"))) {
+  if (fs18.existsSync(path19.join(cwd, "Cargo.lock")) || fs18.existsSync(path19.join(cwd, "Cargo.toml"))) {
     return {
       command: ["cargo", "build"],
       description: "Building Rust project (downloads dependencies)",
-      detectedFrom: fs17.existsSync(path18.join(cwd, "Cargo.lock")) ? "Cargo.lock" : "Cargo.toml"
+      detectedFrom: fs18.existsSync(path19.join(cwd, "Cargo.lock")) ? "Cargo.lock" : "Cargo.toml"
     };
   }
   return null;
 }
 
 // src/daemon/daemon-process.ts
-var fs18 = __toESM(require("fs"));
+var fs19 = __toESM(require("fs"));
 var os8 = __toESM(require("os"));
-var path19 = __toESM(require("path"));
+var path20 = __toESM(require("path"));
 var packageJson = require_package();
 async function ensureValidToken(config, bufferMs = 5 * 60 * 1e3) {
   const now = Date.now();
@@ -8834,7 +9088,7 @@ var Daemon = class _Daemon {
         client.updateActivity();
         try {
           const gitCmd = message.command;
-          const bareRepoPath = path19.join(projectPath, ".bare");
+          const bareRepoPath = path20.join(projectPath, ".bare");
           const cwd = gitCmd.worktreePath || bareRepoPath;
           if (gitCmd.worktreePath) {
             console.log(`[Daemon] Routing command to worktree: ${gitCmd.worktreePath}`);
@@ -9108,6 +9362,8 @@ var Daemon = class _Daemon {
               moduleId: cmd.moduleId,
               moduleUid: cmd.moduleUid,
               projectPath: agentWorkingDir,
+              provider: cmd.provider || "claude",
+              // EP1133: Multi-provider support
               message: cmd.message,
               credentials: cmd.credentials,
               systemPrompt: cmd.systemPrompt,
@@ -9125,7 +9381,9 @@ var Daemon = class _Daemon {
               sessionId: cmd.sessionId,
               message: cmd.message,
               isFirstMessage: false,
+              agentSessionId: cmd.agentSessionId || cmd.claudeSessionId,
               claudeSessionId: cmd.claudeSessionId,
+              // Backward compat
               ...callbacks
             });
             result = {
@@ -9359,8 +9617,8 @@ var Daemon = class _Daemon {
       let daemonPid;
       try {
         const pidPath = getPidFilePath();
-        if (fs18.existsSync(pidPath)) {
-          const pidStr = fs18.readFileSync(pidPath, "utf-8").trim();
+        if (fs19.existsSync(pidPath)) {
+          const pidStr = fs19.readFileSync(pidPath, "utf-8").trim();
           daemonPid = parseInt(pidStr, 10);
         }
       } catch (pidError) {
@@ -9441,28 +9699,28 @@ var Daemon = class _Daemon {
    * - workDir: The directory to run git commands in (cwd)
    */
   getGitDirs(projectPath) {
-    const bareDir = path19.join(projectPath, ".bare");
-    const gitPath = path19.join(projectPath, ".git");
-    if (fs18.existsSync(bareDir) && fs18.statSync(bareDir).isDirectory()) {
+    const bareDir = path20.join(projectPath, ".bare");
+    const gitPath = path20.join(projectPath, ".git");
+    if (fs19.existsSync(bareDir) && fs19.statSync(bareDir).isDirectory()) {
       return { gitDir: bareDir, workDir: projectPath };
     }
-    if (fs18.existsSync(gitPath) && fs18.statSync(gitPath).isDirectory()) {
+    if (fs19.existsSync(gitPath) && fs19.statSync(gitPath).isDirectory()) {
       return { gitDir: null, workDir: projectPath };
     }
-    if (fs18.existsSync(gitPath) && fs18.statSync(gitPath).isFile()) {
+    if (fs19.existsSync(gitPath) && fs19.statSync(gitPath).isFile()) {
       return { gitDir: null, workDir: projectPath };
     }
-    const entries = fs18.readdirSync(projectPath, { withFileTypes: true });
+    const entries = fs19.readdirSync(projectPath, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory() && entry.name.startsWith("EP")) {
-        const worktreePath = path19.join(projectPath, entry.name);
-        const worktreeGit = path19.join(worktreePath, ".git");
-        if (fs18.existsSync(worktreeGit)) {
+        const worktreePath = path20.join(projectPath, entry.name);
+        const worktreeGit = path20.join(worktreePath, ".git");
+        if (fs19.existsSync(worktreeGit)) {
           return { gitDir: null, workDir: worktreePath };
         }
       }
     }
-    if (fs18.existsSync(bareDir)) {
+    if (fs19.existsSync(bareDir)) {
       return { gitDir: bareDir, workDir: projectPath };
     }
     return { gitDir: null, workDir: projectPath };
@@ -9480,31 +9738,31 @@ var Daemon = class _Daemon {
    */
   async configureGitUser(projectPath, userId, workspaceId, machineId, projectId, machineUuid) {
     try {
-      const { execSync: execSync9 } = await import("child_process");
+      const { execSync: execSync10 } = await import("child_process");
       const { gitDir, workDir } = this.getGitDirs(projectPath);
       const gitCmd = gitDir ? `git --git-dir="${gitDir}"` : "git";
-      execSync9(`${gitCmd} config episoda.userId ${userId}`, {
+      execSync10(`${gitCmd} config episoda.userId ${userId}`, {
         cwd: workDir,
         encoding: "utf8",
         stdio: "pipe"
       });
-      execSync9(`${gitCmd} config episoda.workspaceId ${workspaceId}`, {
+      execSync10(`${gitCmd} config episoda.workspaceId ${workspaceId}`, {
         cwd: workDir,
         encoding: "utf8",
         stdio: "pipe"
       });
-      execSync9(`${gitCmd} config episoda.machineId ${machineId}`, {
+      execSync10(`${gitCmd} config episoda.machineId ${machineId}`, {
         cwd: workDir,
         encoding: "utf8",
         stdio: "pipe"
       });
-      execSync9(`${gitCmd} config episoda.projectId ${projectId}`, {
+      execSync10(`${gitCmd} config episoda.projectId ${projectId}`, {
         cwd: workDir,
         encoding: "utf8",
         stdio: "pipe"
       });
       if (machineUuid) {
-        execSync9(`${gitCmd} config episoda.deviceId ${machineUuid}`, {
+        execSync10(`${gitCmd} config episoda.deviceId ${machineUuid}`, {
           cwd: workDir,
           encoding: "utf8",
           stdio: "pipe"
@@ -9526,24 +9784,24 @@ var Daemon = class _Daemon {
   async installGitHooks(projectPath) {
     const hooks = ["post-checkout", "pre-commit", "post-commit"];
     let hooksDir;
-    const bareHooksDir = path19.join(projectPath, ".bare", "hooks");
-    const gitHooksDir = path19.join(projectPath, ".git", "hooks");
-    if (fs18.existsSync(bareHooksDir)) {
+    const bareHooksDir = path20.join(projectPath, ".bare", "hooks");
+    const gitHooksDir = path20.join(projectPath, ".git", "hooks");
+    if (fs19.existsSync(bareHooksDir)) {
       hooksDir = bareHooksDir;
-    } else if (fs18.existsSync(gitHooksDir) && fs18.statSync(path19.join(projectPath, ".git")).isDirectory()) {
+    } else if (fs19.existsSync(gitHooksDir) && fs19.statSync(path20.join(projectPath, ".git")).isDirectory()) {
       hooksDir = gitHooksDir;
     } else {
-      const parentBareHooks = path19.join(projectPath, "..", ".bare", "hooks");
-      if (fs18.existsSync(parentBareHooks)) {
+      const parentBareHooks = path20.join(projectPath, "..", ".bare", "hooks");
+      if (fs19.existsSync(parentBareHooks)) {
         hooksDir = parentBareHooks;
       } else {
         console.warn(`[Daemon] Hooks directory not found for: ${projectPath}`);
         return;
       }
     }
-    if (!fs18.existsSync(hooksDir)) {
+    if (!fs19.existsSync(hooksDir)) {
       try {
-        fs18.mkdirSync(hooksDir, { recursive: true });
+        fs19.mkdirSync(hooksDir, { recursive: true });
       } catch (error) {
         console.warn(`[Daemon] Hooks directory not found and could not create: ${hooksDir}`);
         return;
@@ -9551,20 +9809,20 @@ var Daemon = class _Daemon {
     }
     for (const hookName of hooks) {
       try {
-        const hookPath = path19.join(hooksDir, hookName);
-        const bundledHookPath = path19.join(__dirname, "..", "hooks", hookName);
-        if (!fs18.existsSync(bundledHookPath)) {
+        const hookPath = path20.join(hooksDir, hookName);
+        const bundledHookPath = path20.join(__dirname, "..", "hooks", hookName);
+        if (!fs19.existsSync(bundledHookPath)) {
           console.warn(`[Daemon] Bundled hook not found: ${bundledHookPath}`);
           continue;
         }
-        const hookContent = fs18.readFileSync(bundledHookPath, "utf-8");
-        if (fs18.existsSync(hookPath)) {
-          const existingContent = fs18.readFileSync(hookPath, "utf-8");
+        const hookContent = fs19.readFileSync(bundledHookPath, "utf-8");
+        if (fs19.existsSync(hookPath)) {
+          const existingContent = fs19.readFileSync(hookPath, "utf-8");
           if (existingContent === hookContent) {
             continue;
           }
         }
-        fs18.writeFileSync(hookPath, hookContent, { mode: 493 });
+        fs19.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);
@@ -10031,8 +10289,8 @@ var Daemon = class _Daemon {
       console.log(`[Daemon] EP1002: ${installCmd.description} (detected from ${installCmd.detectedFrom})`);
       console.log(`[Daemon] EP1002: Running: ${installCmd.command.join(" ")}`);
       try {
-        const { execSync: execSync9 } = await import("child_process");
-        execSync9(installCmd.command.join(" "), {
+        const { execSync: execSync10 } = await import("child_process");
+        execSync10(installCmd.command.join(" "), {
           cwd: worktreePath,
           stdio: "inherit",
           timeout: 10 * 60 * 1e3,
@@ -10085,8 +10343,8 @@ var Daemon = class _Daemon {
         console.log(`[Daemon] EP986: ${installCmd.description} (detected from ${installCmd.detectedFrom})`);
         console.log(`[Daemon] EP986: Running: ${installCmd.command.join(" ")}`);
         try {
-          const { execSync: execSync9 } = await import("child_process");
-          execSync9(installCmd.command.join(" "), {
+          const { execSync: execSync10 } = await import("child_process");
+          execSync10(installCmd.command.join(" "), {
             cwd: worktreePath,
             stdio: "inherit",
             timeout: 10 * 60 * 1e3,
@@ -10670,8 +10928,8 @@ var Daemon = class _Daemon {
     await this.shutdown();
     try {
       const pidPath = getPidFilePath();
-      if (fs18.existsSync(pidPath)) {
-        fs18.unlinkSync(pidPath);
+      if (fs19.existsSync(pidPath)) {
+        fs19.unlinkSync(pidPath);
         console.log("[Daemon] PID file cleaned up");
       }
     } catch (error) {