episoda 0.2.105 → 0.2.106

package/dist/daemon/daemon-process.js

@@ -1571,15 +1571,15 @@ var require_git_executor = __commonJS({
           try {
             const { stdout: gitDir } = await execAsync3("git rev-parse --git-dir", { cwd, timeout: 5e3 });
             const gitDirPath = gitDir.trim();
-            const fs22 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+            const fs23 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
             const rebaseMergePath = `${gitDirPath}/rebase-merge`;
             const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
             try {
-              await fs22.access(rebaseMergePath);
+              await fs23.access(rebaseMergePath);
               inRebase = true;
             } catch {
               try {
-                await fs22.access(rebaseApplyPath);
+                await fs23.access(rebaseApplyPath);
                 inRebase = true;
               } catch {
                 inRebase = false;
@@ -1633,9 +1633,9 @@ var require_git_executor = __commonJS({
               error: validation.error || "UNKNOWN_ERROR"
             };
           }
-          const fs22 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs23 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs22.access(command.path);
+            await fs23.access(command.path);
             return {
               success: false,
               error: "WORKTREE_EXISTS",
@@ -1689,9 +1689,9 @@ var require_git_executor = __commonJS({
        */
       async executeWorktreeRemove(command, cwd, options) {
         try {
-          const fs22 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs23 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs22.access(command.path);
+            await fs23.access(command.path);
           } catch {
             return {
               success: false,
@@ -1726,7 +1726,7 @@ var require_git_executor = __commonJS({
           const result = await this.runGitCommand(args, cwd, options);
           if (result.success) {
             try {
-              await fs22.rm(command.path, { recursive: true, force: true });
+              await fs23.rm(command.path, { recursive: true, force: true });
             } catch {
             }
             return {
@@ -1860,10 +1860,10 @@ var require_git_executor = __commonJS({
        */
       async executeCloneBare(command, options) {
         try {
-          const fs22 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path23 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs23 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path24 = await Promise.resolve().then(() => __importStar(require("path")));
           try {
-            await fs22.access(command.path);
+            await fs23.access(command.path);
             return {
               success: false,
               error: "BRANCH_ALREADY_EXISTS",
@@ -1872,9 +1872,9 @@ var require_git_executor = __commonJS({
             };
           } catch {
           }
-          const parentDir = path23.dirname(command.path);
+          const parentDir = path24.dirname(command.path);
           try {
-            await fs22.mkdir(parentDir, { recursive: true });
+            await fs23.mkdir(parentDir, { recursive: true });
           } catch {
           }
           const { stdout, stderr } = await execAsync3(
@@ -1922,22 +1922,22 @@ var require_git_executor = __commonJS({
        */
       async executeProjectInfo(cwd, options) {
         try {
-          const fs22 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path23 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs23 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path24 = await Promise.resolve().then(() => __importStar(require("path")));
           let currentPath = cwd;
           let projectPath = cwd;
           let bareRepoPath;
           for (let i = 0; i < 10; i++) {
-            const bareDir = path23.join(currentPath, ".bare");
-            const episodaDir = path23.join(currentPath, ".episoda");
+            const bareDir = path24.join(currentPath, ".bare");
+            const episodaDir = path24.join(currentPath, ".episoda");
             try {
-              await fs22.access(bareDir);
-              await fs22.access(episodaDir);
+              await fs23.access(bareDir);
+              await fs23.access(episodaDir);
               projectPath = currentPath;
               bareRepoPath = bareDir;
               break;
             } catch {
-              const parentPath = path23.dirname(currentPath);
+              const parentPath = path24.dirname(currentPath);
               if (parentPath === currentPath) {
                 break;
               }
@@ -2590,31 +2590,31 @@ var require_auth = __commonJS({
     exports2.loadConfig = loadConfig8;
     exports2.saveConfig = saveConfig2;
     exports2.validateToken = validateToken;
-    var fs22 = __importStar(require("fs"));
-    var path23 = __importStar(require("path"));
+    var fs23 = __importStar(require("fs"));
+    var path24 = __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 || path23.join(os9.homedir(), ".episoda");
+      return process.env.EPISODA_CONFIG_DIR || path24.join(os9.homedir(), ".episoda");
     }
     function getConfigPath(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path23.join(getConfigDir8(), DEFAULT_CONFIG_FILE);
+      return path24.join(getConfigDir8(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path23.dirname(configPath);
-      const isNew = !fs22.existsSync(dir);
+      const dir = path24.dirname(configPath);
+      const isNew = !fs23.existsSync(dir);
       if (isNew) {
-        fs22.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs23.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path23.join(dir, ".nosync");
-        if (isNew || !fs22.existsSync(nosyncPath)) {
+        const nosyncPath = path24.join(dir, ".nosync");
+        if (isNew || !fs23.existsSync(nosyncPath)) {
           try {
-            fs22.writeFileSync(nosyncPath, "", { mode: 384 });
+            fs23.writeFileSync(nosyncPath, "", { mode: 384 });
             (0, child_process_1.execSync)(`xattr -w com.apple.fileprovider.ignore 1 "${dir}"`, {
               stdio: "ignore",
               timeout: 5e3
@@ -2626,9 +2626,9 @@ var require_auth = __commonJS({
     }
     async function loadConfig8(configPath) {
       const fullPath = getConfigPath(configPath);
-      if (fs22.existsSync(fullPath)) {
+      if (fs23.existsSync(fullPath)) {
         try {
-          const content = fs22.readFileSync(fullPath, "utf8");
+          const content = fs23.readFileSync(fullPath, "utf8");
           const config = JSON.parse(content);
           return config;
         } catch (error) {
@@ -2638,9 +2638,9 @@ var require_auth = __commonJS({
       if (process.env.EPISODA_MODE === "cloud" && process.env.EPISODA_WORKSPACE) {
         const homeDir = process.env.HOME || require("os").homedir();
         const workspaceConfigPath = require("path").join(homeDir, "episoda", process.env.EPISODA_WORKSPACE, ".episoda", "config.json");
-        if (fs22.existsSync(workspaceConfigPath)) {
+        if (fs23.existsSync(workspaceConfigPath)) {
           try {
-            const content = fs22.readFileSync(workspaceConfigPath, "utf8");
+            const content = fs23.readFileSync(workspaceConfigPath, "utf8");
             const workspaceConfig = JSON.parse(content);
             return {
               access_token: process.env.EPISODA_ACCESS_TOKEN || workspaceConfig.accessToken,
@@ -2687,7 +2687,7 @@ var require_auth = __commonJS({
       ensureConfigDir(fullPath);
       try {
         const content = JSON.stringify(config, null, 2);
-        fs22.writeFileSync(fullPath, content, { mode: 384 });
+        fs23.writeFileSync(fullPath, content, { mode: 384 });
       } catch (error) {
         throw new Error(`Failed to save config: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -2804,7 +2804,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.105",
+      version: "0.2.106",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -4781,7 +4781,13 @@ var WorktreeManager = class _WorktreeManager {
   }
 };
 function getEpisodaRoot() {
-  return process.env.EPISODA_ROOT || path7.join(require("os").homedir(), "episoda");
+  if (process.env.EPISODA_ROOT) {
+    return process.env.EPISODA_ROOT;
+  }
+  if (process.env.EPISODA_MODE === "cloud") {
+    return process.env.HOME || "/home/episoda";
+  }
+  return path7.join(require("os").homedir(), "episoda");
 }
 function getProjectPath(workspaceSlug, projectSlug) {
   return path7.join(getEpisodaRoot(), workspaceSlug, projectSlug);
@@ -7730,6 +7736,85 @@ async function persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug
   }
 }
 
+// src/daemon/handlers/project-handlers.ts
+var path16 = __toESM(require("path"));
+var fs15 = __toESM(require("fs"));
+function validateSlug(slug, fieldName) {
+  if (!slug || typeof slug !== "string") {
+    return `${fieldName} is required`;
+  }
+  const trimmed = slug.trim();
+  if (!trimmed) {
+    return `${fieldName} cannot be empty`;
+  }
+  if (trimmed.includes("..") || trimmed.includes("/") || trimmed.includes("\\")) {
+    return `${fieldName} contains invalid characters`;
+  }
+  if (trimmed.includes("\0")) {
+    return `${fieldName} contains invalid characters`;
+  }
+  if (trimmed.startsWith(".")) {
+    return `${fieldName} cannot start with a dot`;
+  }
+  return null;
+}
+var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+async function handleProjectSetup(params) {
+  const { workspaceSlug, projectSlug, projectId } = params;
+  const workspaceError = validateSlug(workspaceSlug, "workspaceSlug");
+  if (workspaceError) {
+    console.error(`[ProjectSetup] EP1199: Validation failed: ${workspaceError}`);
+    return { success: false, error: workspaceError };
+  }
+  const projectError = validateSlug(projectSlug, "projectSlug");
+  if (projectError) {
+    console.error(`[ProjectSetup] EP1199: Validation failed: ${projectError}`);
+    return { success: false, error: projectError };
+  }
+  if (!UUID_REGEX.test(projectId)) {
+    console.error(`[ProjectSetup] EP1199: Invalid projectId format: ${projectId}`);
+    return { success: false, error: "Invalid projectId format" };
+  }
+  console.log(`[ProjectSetup] EP1199: Setting up project ${workspaceSlug}/${projectSlug}`);
+  try {
+    const projectPath = getProjectPath(workspaceSlug, projectSlug);
+    const artifactsPath = path16.join(projectPath, "artifacts");
+    const configDir = path16.join(projectPath, ".episoda");
+    const configPath = path16.join(configDir, "config.json");
+    await fs15.promises.mkdir(artifactsPath, { recursive: true });
+    await fs15.promises.mkdir(configDir, { recursive: true });
+    let existingConfig = {};
+    try {
+      const existing = await fs15.promises.readFile(configPath, "utf-8");
+      existingConfig = JSON.parse(existing);
+    } catch {
+    }
+    const config = {
+      ...existingConfig,
+      project_id: projectId,
+      workspace_slug: workspaceSlug,
+      project_slug: projectSlug,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      // Only set created_at if not already present
+      created_at: existingConfig.created_at || (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await fs15.promises.writeFile(configPath, JSON.stringify(config, null, 2));
+    console.log(`[ProjectSetup] EP1199: Project setup complete at ${projectPath}`);
+    return {
+      success: true,
+      projectPath,
+      artifactsPath
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`[ProjectSetup] EP1199: Setup failed:`, errorMessage);
+    return {
+      success: false,
+      error: errorMessage
+    };
+  }
+}
+
 // src/daemon/handlers/stale-commit-cleanup.ts
 var import_child_process9 = require("child_process");
 var import_util2 = require("util");
@@ -7827,12 +7912,12 @@ async function cleanupStaleCommits(projectPath) {
 
 // src/agent/claude-binary.ts
 var import_child_process10 = require("child_process");
-var path16 = __toESM(require("path"));
-var fs15 = __toESM(require("fs"));
+var path17 = __toESM(require("path"));
+var fs16 = __toESM(require("fs"));
 var cachedBinaryPath = null;
 function isValidClaudeBinary(binaryPath) {
   try {
-    fs15.accessSync(binaryPath, fs15.constants.X_OK);
+    fs16.accessSync(binaryPath, fs16.constants.X_OK);
     const version = (0, import_child_process10.execSync)(`"${binaryPath}" --version`, {
       encoding: "utf-8",
       timeout: 5e3,
@@ -7865,14 +7950,14 @@ async function ensureClaudeBinary() {
   }
   const bundledPaths = [
     // In production: node_modules/.bin/claude
-    path16.join(__dirname, "..", "..", "node_modules", ".bin", "claude"),
+    path17.join(__dirname, "..", "..", "node_modules", ".bin", "claude"),
     // In monorepo development: packages/episoda/node_modules/.bin/claude
-    path16.join(__dirname, "..", "..", "..", "..", "node_modules", ".bin", "claude"),
+    path17.join(__dirname, "..", "..", "..", "..", "node_modules", ".bin", "claude"),
     // Root monorepo node_modules
-    path16.join(__dirname, "..", "..", "..", "..", "..", "node_modules", ".bin", "claude")
+    path17.join(__dirname, "..", "..", "..", "..", "..", "node_modules", ".bin", "claude")
   ];
   for (const bundledPath of bundledPaths) {
-    if (fs15.existsSync(bundledPath) && isValidClaudeBinary(bundledPath)) {
+    if (fs16.existsSync(bundledPath) && isValidClaudeBinary(bundledPath)) {
       cachedBinaryPath = bundledPath;
       return cachedBinaryPath;
     }
@@ -7898,12 +7983,12 @@ async function ensureClaudeBinary() {
 
 // src/agent/codex-binary.ts
 var import_child_process11 = require("child_process");
-var path17 = __toESM(require("path"));
-var fs16 = __toESM(require("fs"));
+var path18 = __toESM(require("path"));
+var fs17 = __toESM(require("fs"));
 var cachedBinaryPath2 = null;
 function isValidCodexBinary(binaryPath) {
   try {
-    fs16.accessSync(binaryPath, fs16.constants.X_OK);
+    fs17.accessSync(binaryPath, fs17.constants.X_OK);
     const version = (0, import_child_process11.execSync)(`"${binaryPath}" --version`, {
       encoding: "utf-8",
       timeout: 5e3,
@@ -7936,14 +8021,14 @@ async function ensureCodexBinary() {
   }
   const bundledPaths = [
     // In production: node_modules/.bin/codex
-    path17.join(__dirname, "..", "..", "node_modules", ".bin", "codex"),
+    path18.join(__dirname, "..", "..", "node_modules", ".bin", "codex"),
     // In monorepo development: packages/episoda/node_modules/.bin/codex
-    path17.join(__dirname, "..", "..", "..", "..", "node_modules", ".bin", "codex"),
+    path18.join(__dirname, "..", "..", "..", "..", "node_modules", ".bin", "codex"),
     // Root monorepo node_modules
-    path17.join(__dirname, "..", "..", "..", "..", "..", "node_modules", ".bin", "codex")
+    path18.join(__dirname, "..", "..", "..", "..", "..", "node_modules", ".bin", "codex")
   ];
   for (const bundledPath of bundledPaths) {
-    if (fs16.existsSync(bundledPath) && isValidCodexBinary(bundledPath)) {
+    if (fs17.existsSync(bundledPath) && isValidCodexBinary(bundledPath)) {
       cachedBinaryPath2 = bundledPath;
       return cachedBinaryPath2;
     }
@@ -8010,8 +8095,8 @@ function generateCodexConfig(credentials, projectPath) {
 
 // src/agent/agent-manager.ts
 var import_child_process12 = require("child_process");
-var path18 = __toESM(require("path"));
-var fs17 = __toESM(require("fs"));
+var path19 = __toESM(require("path"));
+var fs18 = __toESM(require("fs"));
 var os6 = __toESM(require("os"));
 
 // src/agent/claude-config.ts
@@ -8334,7 +8419,7 @@ var AgentManager = class {
     this.initialized = false;
     // EP1133: Lock for config file writes to prevent race conditions
     this.configWriteLock = Promise.resolve();
-    this.pidDir = path18.join(os6.homedir(), ".episoda", "agent-pids");
+    this.pidDir = path19.join(os6.homedir(), ".episoda", "agent-pids");
   }
   /**
    * EP1133: Acquire lock for config file writes
@@ -8363,8 +8448,8 @@ var AgentManager = class {
       return;
     }
     console.log("[AgentManager] Initializing...");
-    if (!fs17.existsSync(this.pidDir)) {
-      fs17.mkdirSync(this.pidDir, { recursive: true });
+    if (!fs18.existsSync(this.pidDir)) {
+      fs18.mkdirSync(this.pidDir, { recursive: true });
     }
     await this.cleanupOrphanedProcesses();
     try {
@@ -8611,9 +8696,9 @@ If changes are needed, explain what needs to be done.`;
       const useApiKey = !useOAuth && !!session.credentials.apiKey;
       if (provider === "codex") {
         await this.withConfigLock(async () => {
-          const codexDir = path18.join(os6.homedir(), ".codex");
-          if (!fs17.existsSync(codexDir)) {
-            fs17.mkdirSync(codexDir, { recursive: true });
+          const codexDir = path19.join(os6.homedir(), ".codex");
+          if (!fs18.existsSync(codexDir)) {
+            fs18.mkdirSync(codexDir, { recursive: true });
           }
           if (useOAuth) {
             const codexConfig = generateCodexConfig({
@@ -8623,21 +8708,21 @@ If changes are needed, explain what needs to be done.`;
               accountId: session.credentials.accountId,
               expiresAt: session.credentials.expiresAt
             }, session.projectPath);
-            const authJsonPath = path18.join(codexDir, "auth.json");
-            fs17.writeFileSync(authJsonPath, codexConfig["auth.json"], { mode: 384 });
+            const authJsonPath = path19.join(codexDir, "auth.json");
+            fs18.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 = path18.join(codexDir, "config.toml");
+              const configTomlPath = path19.join(codexDir, "config.toml");
               let existingConfig = "";
               try {
-                existingConfig = fs17.readFileSync(configTomlPath, "utf-8");
+                existingConfig = fs18.readFileSync(configTomlPath, "utf-8");
               } catch {
               }
               const escapedPathForRegex = session.projectPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
               const projectKeyPattern = new RegExp(`\\[projects\\."${escapedPathForRegex}"\\]`);
               const projectAlreadyTrusted = projectKeyPattern.test(existingConfig);
               if (!projectAlreadyTrusted) {
-                fs17.writeFileSync(configTomlPath, existingConfig + "\n" + codexConfig["config.toml"], { mode: 420 });
+                fs18.writeFileSync(configTomlPath, existingConfig + "\n" + codexConfig["config.toml"], { mode: 420 });
                 console.log("[AgentManager] EP1133: Updated Codex config.toml with project trust");
               }
             }
@@ -8647,14 +8732,14 @@ If changes are needed, explain what needs to be done.`;
         });
       } else {
         await this.withConfigLock(async () => {
-          const claudeDir = path18.join(os6.homedir(), ".claude");
-          const credentialsPath = path18.join(claudeDir, ".credentials.json");
-          const statsigDir = path18.join(claudeDir, "statsig");
-          if (!fs17.existsSync(claudeDir)) {
-            fs17.mkdirSync(claudeDir, { recursive: true });
+          const claudeDir = path19.join(os6.homedir(), ".claude");
+          const credentialsPath = path19.join(claudeDir, ".credentials.json");
+          const statsigDir = path19.join(claudeDir, "statsig");
+          if (!fs18.existsSync(claudeDir)) {
+            fs18.mkdirSync(claudeDir, { recursive: true });
           }
-          if (!fs17.existsSync(statsigDir)) {
-            fs17.mkdirSync(statsigDir, { recursive: true });
+          if (!fs18.existsSync(statsigDir)) {
+            fs18.mkdirSync(statsigDir, { recursive: true });
           }
           if (useOAuth) {
             const oauthCredentials = {
@@ -8672,7 +8757,7 @@ If changes are needed, explain what needs to be done.`;
             const credentialsContent = JSON.stringify({
               claudeAiOauth: oauthCredentials
             }, null, 2);
-            fs17.writeFileSync(credentialsPath, credentialsContent, { mode: 384 });
+            fs18.writeFileSync(credentialsPath, credentialsContent, { mode: 384 });
             console.log("[AgentManager] Wrote OAuth credentials to ~/.claude/.credentials.json");
             try {
               const claudeConfig = generateClaudeConfig({
@@ -8684,11 +8769,11 @@ If changes are needed, explain what needs to be done.`;
               if (!hasEvaluations || !hasStableId) {
                 throw new Error(`Invalid statsig config: missing required files`);
               }
-              const settingsPath = path18.join(claudeDir, "settings.json");
-              fs17.writeFileSync(settingsPath, claudeConfig["settings.json"], { mode: 384 });
+              const settingsPath = path19.join(claudeDir, "settings.json");
+              fs18.writeFileSync(settingsPath, claudeConfig["settings.json"], { mode: 384 });
               for (const [filename, content] of Object.entries(claudeConfig.statsig)) {
-                const filePath = path18.join(statsigDir, filename);
-                fs17.writeFileSync(filePath, content, { mode: 420 });
+                const filePath = path19.join(statsigDir, filename);
+                fs18.writeFileSync(filePath, content, { mode: 420 });
               }
               if (session.credentials.githubToken) {
                 console.log("[AgentManager] EP1146: GitHub MCP server enabled with installation token");
@@ -8958,14 +9043,14 @@ If changes are needed, explain what needs to be done.`;
    */
   async cleanupOrphanedProcesses() {
     let cleaned = 0;
-    if (!fs17.existsSync(this.pidDir)) {
+    if (!fs18.existsSync(this.pidDir)) {
       return { cleaned };
     }
-    const pidFiles = fs17.readdirSync(this.pidDir).filter((f) => f.endsWith(".pid"));
+    const pidFiles = fs18.readdirSync(this.pidDir).filter((f) => f.endsWith(".pid"));
     for (const pidFile of pidFiles) {
-      const pidPath = path18.join(this.pidDir, pidFile);
+      const pidPath = path19.join(this.pidDir, pidFile);
       try {
-        const pidStr = fs17.readFileSync(pidPath, "utf-8").trim();
+        const pidStr = fs18.readFileSync(pidPath, "utf-8").trim();
         const pid = parseInt(pidStr, 10);
         if (!isNaN(pid)) {
           try {
@@ -8976,7 +9061,7 @@ If changes are needed, explain what needs to be done.`;
           } catch {
           }
         }
-        fs17.unlinkSync(pidPath);
+        fs18.unlinkSync(pidPath);
       } catch (error) {
         console.warn(`[AgentManager] Error cleaning PID file ${pidFile}:`, error);
       }
@@ -8990,17 +9075,17 @@ If changes are needed, explain what needs to be done.`;
    * Write PID file for session tracking
    */
   writePidFile(sessionId, pid) {
-    const pidPath = path18.join(this.pidDir, `${sessionId}.pid`);
-    fs17.writeFileSync(pidPath, pid.toString());
+    const pidPath = path19.join(this.pidDir, `${sessionId}.pid`);
+    fs18.writeFileSync(pidPath, pid.toString());
   }
   /**
    * Remove PID file for session
    */
   removePidFile(sessionId) {
-    const pidPath = path18.join(this.pidDir, `${sessionId}.pid`);
+    const pidPath = path19.join(this.pidDir, `${sessionId}.pid`);
     try {
-      if (fs17.existsSync(pidPath)) {
-        fs17.unlinkSync(pidPath);
+      if (fs18.existsSync(pidPath)) {
+        fs18.unlinkSync(pidPath);
       }
     } catch {
     }
@@ -9010,8 +9095,8 @@ If changes are needed, explain what needs to be done.`;
 // src/utils/dev-server.ts
 var import_child_process13 = require("child_process");
 var import_core11 = __toESM(require_dist());
-var fs18 = __toESM(require("fs"));
-var path19 = __toESM(require("path"));
+var fs19 = __toESM(require("fs"));
+var path20 = __toESM(require("path"));
 var MAX_RESTART_ATTEMPTS = 5;
 var INITIAL_RESTART_DELAY_MS = 2e3;
 var MAX_RESTART_DELAY_MS = 3e4;
@@ -9019,26 +9104,26 @@ var MAX_LOG_SIZE_BYTES = 5 * 1024 * 1024;
 var NODE_MEMORY_LIMIT_MB = 2048;
 var activeServers = /* @__PURE__ */ new Map();
 function getLogsDir() {
-  const logsDir = path19.join((0, import_core11.getConfigDir)(), "logs");
-  if (!fs18.existsSync(logsDir)) {
-    fs18.mkdirSync(logsDir, { recursive: true });
+  const logsDir = path20.join((0, import_core11.getConfigDir)(), "logs");
+  if (!fs19.existsSync(logsDir)) {
+    fs19.mkdirSync(logsDir, { recursive: true });
   }
   return logsDir;
 }
 function getLogFilePath(moduleUid) {
-  return path19.join(getLogsDir(), `dev-${moduleUid}.log`);
+  return path20.join(getLogsDir(), `dev-${moduleUid}.log`);
 }
 function rotateLogIfNeeded(logPath) {
   try {
-    if (fs18.existsSync(logPath)) {
-      const stats = fs18.statSync(logPath);
+    if (fs19.existsSync(logPath)) {
+      const stats = fs19.statSync(logPath);
       if (stats.size > MAX_LOG_SIZE_BYTES) {
         const backupPath = `${logPath}.1`;
-        if (fs18.existsSync(backupPath)) {
-          fs18.unlinkSync(backupPath);
+        if (fs19.existsSync(backupPath)) {
+          fs19.unlinkSync(backupPath);
         }
-        fs18.renameSync(logPath, backupPath);
-        console.log(`[DevServer] EP932: Rotated log file for ${path19.basename(logPath)}`);
+        fs19.renameSync(logPath, backupPath);
+        console.log(`[DevServer] EP932: Rotated log file for ${path20.basename(logPath)}`);
       }
     }
   } catch (error) {
@@ -9051,7 +9136,7 @@ function writeToLog(logPath, line, isError = false) {
     const prefix = isError ? "ERR" : "OUT";
     const logLine = `[${timestamp}] [${prefix}] ${line}
 `;
-    fs18.appendFileSync(logPath, logLine);
+    fs19.appendFileSync(logPath, logLine);
   } catch {
   }
 }
@@ -9230,8 +9315,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 = path19.join(projectPath, ".env");
-      if (!fs18.existsSync(envFilePath) && Object.keys(injectedEnvVars).length > 0) {
+      const envFilePath = path20.join(projectPath, ".env");
+      if (!fs19.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);
       }
@@ -9337,19 +9422,19 @@ function getDevServerStatus() {
 }
 
 // src/utils/worktree.ts
-var path20 = __toESM(require("path"));
-var fs19 = __toESM(require("fs"));
+var path21 = __toESM(require("path"));
+var fs20 = __toESM(require("fs"));
 var os7 = __toESM(require("os"));
 var import_core12 = __toESM(require_dist());
 function getEpisodaRoot2() {
-  return process.env.EPISODA_ROOT || path20.join(os7.homedir(), "episoda");
+  return process.env.EPISODA_ROOT || path21.join(os7.homedir(), "episoda");
 }
 function getWorktreeInfo(moduleUid, workspaceSlug, projectSlug) {
   const root = getEpisodaRoot2();
-  const worktreePath = path20.join(root, workspaceSlug, projectSlug, moduleUid);
+  const worktreePath = path21.join(root, workspaceSlug, projectSlug, moduleUid);
   return {
     path: worktreePath,
-    exists: fs19.existsSync(worktreePath),
+    exists: fs20.existsSync(worktreePath),
     moduleUid
   };
 }
@@ -9363,15 +9448,15 @@ async function getWorktreeInfoForModule(moduleUid) {
     return null;
   }
   const root = getEpisodaRoot2();
-  const workspaceRoot = path20.join(root, config.workspace_slug);
+  const workspaceRoot = path21.join(root, config.workspace_slug);
   try {
-    const entries = fs19.readdirSync(workspaceRoot, { withFileTypes: true });
+    const entries = fs20.readdirSync(workspaceRoot, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) {
         continue;
       }
-      const worktreePath = path20.join(workspaceRoot, entry.name, moduleUid);
-      if (fs19.existsSync(worktreePath)) {
+      const worktreePath = path21.join(workspaceRoot, entry.name, moduleUid);
+      if (fs20.existsSync(worktreePath)) {
         return {
           path: worktreePath,
           exists: true,
@@ -9388,61 +9473,61 @@ async function getWorktreeInfoForModule(moduleUid) {
 }
 
 // src/framework-detector.ts
-var fs20 = __toESM(require("fs"));
-var path21 = __toESM(require("path"));
+var fs21 = __toESM(require("fs"));
+var path22 = __toESM(require("path"));
 function getInstallCommand(cwd) {
-  if (fs20.existsSync(path21.join(cwd, "bun.lockb"))) {
+  if (fs21.existsSync(path22.join(cwd, "bun.lockb"))) {
     return {
       command: ["bun", "install"],
       description: "Installing dependencies with bun",
       detectedFrom: "bun.lockb"
     };
   }
-  if (fs20.existsSync(path21.join(cwd, "pnpm-lock.yaml"))) {
+  if (fs21.existsSync(path22.join(cwd, "pnpm-lock.yaml"))) {
     return {
       command: ["pnpm", "install"],
       description: "Installing dependencies with pnpm",
       detectedFrom: "pnpm-lock.yaml"
     };
   }
-  if (fs20.existsSync(path21.join(cwd, "yarn.lock"))) {
+  if (fs21.existsSync(path22.join(cwd, "yarn.lock"))) {
     return {
       command: ["yarn", "install"],
       description: "Installing dependencies with yarn",
       detectedFrom: "yarn.lock"
     };
   }
-  if (fs20.existsSync(path21.join(cwd, "package-lock.json"))) {
+  if (fs21.existsSync(path22.join(cwd, "package-lock.json"))) {
     return {
       command: ["npm", "ci"],
       description: "Installing dependencies with npm ci",
       detectedFrom: "package-lock.json"
     };
   }
-  if (fs20.existsSync(path21.join(cwd, "package.json"))) {
+  if (fs21.existsSync(path22.join(cwd, "package.json"))) {
     return {
       command: ["npm", "install"],
       description: "Installing dependencies with npm",
       detectedFrom: "package.json"
     };
   }
-  if (fs20.existsSync(path21.join(cwd, "Pipfile.lock")) || fs20.existsSync(path21.join(cwd, "Pipfile"))) {
+  if (fs21.existsSync(path22.join(cwd, "Pipfile.lock")) || fs21.existsSync(path22.join(cwd, "Pipfile"))) {
     return {
       command: ["pipenv", "install"],
       description: "Installing dependencies with pipenv",
-      detectedFrom: fs20.existsSync(path21.join(cwd, "Pipfile.lock")) ? "Pipfile.lock" : "Pipfile"
+      detectedFrom: fs21.existsSync(path22.join(cwd, "Pipfile.lock")) ? "Pipfile.lock" : "Pipfile"
     };
   }
-  if (fs20.existsSync(path21.join(cwd, "poetry.lock"))) {
+  if (fs21.existsSync(path22.join(cwd, "poetry.lock"))) {
     return {
       command: ["poetry", "install"],
       description: "Installing dependencies with poetry",
       detectedFrom: "poetry.lock"
     };
   }
-  if (fs20.existsSync(path21.join(cwd, "pyproject.toml"))) {
-    const pyprojectPath = path21.join(cwd, "pyproject.toml");
-    const content = fs20.readFileSync(pyprojectPath, "utf-8");
+  if (fs21.existsSync(path22.join(cwd, "pyproject.toml"))) {
+    const pyprojectPath = path22.join(cwd, "pyproject.toml");
+    const content = fs21.readFileSync(pyprojectPath, "utf-8");
     if (content.includes("[tool.poetry]")) {
       return {
         command: ["poetry", "install"],
@@ -9451,42 +9536,42 @@ function getInstallCommand(cwd) {
       };
     }
   }
-  if (fs20.existsSync(path21.join(cwd, "requirements.txt"))) {
+  if (fs21.existsSync(path22.join(cwd, "requirements.txt"))) {
     return {
       command: ["pip", "install", "-r", "requirements.txt"],
       description: "Installing dependencies with pip",
       detectedFrom: "requirements.txt"
     };
   }
-  if (fs20.existsSync(path21.join(cwd, "Gemfile.lock")) || fs20.existsSync(path21.join(cwd, "Gemfile"))) {
+  if (fs21.existsSync(path22.join(cwd, "Gemfile.lock")) || fs21.existsSync(path22.join(cwd, "Gemfile"))) {
     return {
       command: ["bundle", "install"],
       description: "Installing dependencies with bundler",
-      detectedFrom: fs20.existsSync(path21.join(cwd, "Gemfile.lock")) ? "Gemfile.lock" : "Gemfile"
+      detectedFrom: fs21.existsSync(path22.join(cwd, "Gemfile.lock")) ? "Gemfile.lock" : "Gemfile"
     };
   }
-  if (fs20.existsSync(path21.join(cwd, "go.sum")) || fs20.existsSync(path21.join(cwd, "go.mod"))) {
+  if (fs21.existsSync(path22.join(cwd, "go.sum")) || fs21.existsSync(path22.join(cwd, "go.mod"))) {
     return {
       command: ["go", "mod", "download"],
       description: "Downloading Go modules",
-      detectedFrom: fs20.existsSync(path21.join(cwd, "go.sum")) ? "go.sum" : "go.mod"
+      detectedFrom: fs21.existsSync(path22.join(cwd, "go.sum")) ? "go.sum" : "go.mod"
     };
   }
-  if (fs20.existsSync(path21.join(cwd, "Cargo.lock")) || fs20.existsSync(path21.join(cwd, "Cargo.toml"))) {
+  if (fs21.existsSync(path22.join(cwd, "Cargo.lock")) || fs21.existsSync(path22.join(cwd, "Cargo.toml"))) {
     return {
       command: ["cargo", "build"],
       description: "Building Rust project (downloads dependencies)",
-      detectedFrom: fs20.existsSync(path21.join(cwd, "Cargo.lock")) ? "Cargo.lock" : "Cargo.toml"
+      detectedFrom: fs21.existsSync(path22.join(cwd, "Cargo.lock")) ? "Cargo.lock" : "Cargo.toml"
     };
   }
   return null;
 }
 
 // src/daemon/daemon-process.ts
-var fs21 = __toESM(require("fs"));
+var fs22 = __toESM(require("fs"));
 var http2 = __toESM(require("http"));
 var os8 = __toESM(require("os"));
-var path22 = __toESM(require("path"));
+var path23 = __toESM(require("path"));
 var packageJson = require_package();
 async function ensureValidToken(config, bufferMs = 5 * 60 * 1e3) {
   const now = Date.now();
@@ -9707,9 +9792,9 @@ var Daemon = class _Daemon {
       this.healthServer = http2.createServer((req, res) => {
         if (req.url === "/health" || req.url === "/") {
           const isConnected = this.liveConnections.size > 0;
-          const projects = Array.from(this.connections.entries()).map(([path23, conn]) => ({
-            path: path23,
-            connected: this.liveConnections.has(path23)
+          const projects = Array.from(this.connections.entries()).map(([path24, conn]) => ({
+            path: path24,
+            connected: this.liveConnections.has(path24)
           }));
           const status = {
             status: isConnected ? "healthy" : "degraded",
@@ -9939,9 +10024,12 @@ var Daemon = class _Daemon {
     this.ipcServer.on("worktree-list", async (params) => {
       return handleWorktreeList(params.workspaceSlug, params.projectSlug);
     });
-    this.ipcServer.on("project-eject", async (params) => {
+    this.ipcServer.on("project:eject", async (params) => {
       return handleProjectEject(params);
     });
+    this.ipcServer.on("project:setup", async (params) => {
+      return handleProjectSetup(params);
+    });
   }
   /**
    * Restore WebSocket connections for tracked projects
@@ -10074,7 +10162,7 @@ var Daemon = class _Daemon {
         client.updateActivity();
         try {
           const gitCmd = message.command;
-          const bareRepoPath = path22.join(projectPath, ".bare");
+          const bareRepoPath = path23.join(projectPath, ".bare");
           const cwd = gitCmd.worktreePath || bareRepoPath;
           if (gitCmd.worktreePath) {
             console.log(`[Daemon] Routing command to worktree: ${gitCmd.worktreePath}`);
@@ -10188,9 +10276,14 @@ var Daemon = class _Daemon {
               );
               break;
             // EP1144: Project ejection for Tier 1 cleanup
-            case "eject_project":
+            // EP1199: Renamed from eject_project to project:eject for naming consistency
+            case "project:eject":
               result = await handleProjectEject(cmd);
               break;
+            // EP1199: Project setup for cloud containers
+            case "project:setup":
+              result = await handleProjectSetup(cmd);
+              break;
             default:
               result = {
                 success: false,
@@ -10654,8 +10747,8 @@ var Daemon = class _Daemon {
       let daemonPid;
       try {
         const pidPath = getPidFilePath();
-        if (fs21.existsSync(pidPath)) {
-          const pidStr = fs21.readFileSync(pidPath, "utf-8").trim();
+        if (fs22.existsSync(pidPath)) {
+          const pidStr = fs22.readFileSync(pidPath, "utf-8").trim();
           daemonPid = parseInt(pidStr, 10);
         }
       } catch (pidError) {
@@ -10736,28 +10829,28 @@ var Daemon = class _Daemon {
    * - workDir: The directory to run git commands in (cwd)
    */
   getGitDirs(projectPath) {
-    const bareDir = path22.join(projectPath, ".bare");
-    const gitPath = path22.join(projectPath, ".git");
-    if (fs21.existsSync(bareDir) && fs21.statSync(bareDir).isDirectory()) {
+    const bareDir = path23.join(projectPath, ".bare");
+    const gitPath = path23.join(projectPath, ".git");
+    if (fs22.existsSync(bareDir) && fs22.statSync(bareDir).isDirectory()) {
       return { gitDir: bareDir, workDir: projectPath };
     }
-    if (fs21.existsSync(gitPath) && fs21.statSync(gitPath).isDirectory()) {
+    if (fs22.existsSync(gitPath) && fs22.statSync(gitPath).isDirectory()) {
       return { gitDir: null, workDir: projectPath };
     }
-    if (fs21.existsSync(gitPath) && fs21.statSync(gitPath).isFile()) {
+    if (fs22.existsSync(gitPath) && fs22.statSync(gitPath).isFile()) {
       return { gitDir: null, workDir: projectPath };
     }
-    const entries = fs21.readdirSync(projectPath, { withFileTypes: true });
+    const entries = fs22.readdirSync(projectPath, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory() && entry.name.startsWith("EP")) {
-        const worktreePath = path22.join(projectPath, entry.name);
-        const worktreeGit = path22.join(worktreePath, ".git");
-        if (fs21.existsSync(worktreeGit)) {
+        const worktreePath = path23.join(projectPath, entry.name);
+        const worktreeGit = path23.join(worktreePath, ".git");
+        if (fs22.existsSync(worktreeGit)) {
           return { gitDir: null, workDir: worktreePath };
         }
       }
     }
-    if (fs21.existsSync(bareDir)) {
+    if (fs22.existsSync(bareDir)) {
       return { gitDir: bareDir, workDir: projectPath };
     }
     return { gitDir: null, workDir: projectPath };
@@ -10821,24 +10914,24 @@ var Daemon = class _Daemon {
   async installGitHooks(projectPath) {
     const hooks = ["post-checkout", "pre-commit", "post-commit"];
     let hooksDir;
-    const bareHooksDir = path22.join(projectPath, ".bare", "hooks");
-    const gitHooksDir = path22.join(projectPath, ".git", "hooks");
-    if (fs21.existsSync(bareHooksDir)) {
+    const bareHooksDir = path23.join(projectPath, ".bare", "hooks");
+    const gitHooksDir = path23.join(projectPath, ".git", "hooks");
+    if (fs22.existsSync(bareHooksDir)) {
       hooksDir = bareHooksDir;
-    } else if (fs21.existsSync(gitHooksDir) && fs21.statSync(path22.join(projectPath, ".git")).isDirectory()) {
+    } else if (fs22.existsSync(gitHooksDir) && fs22.statSync(path23.join(projectPath, ".git")).isDirectory()) {
       hooksDir = gitHooksDir;
     } else {
-      const parentBareHooks = path22.join(projectPath, "..", ".bare", "hooks");
-      if (fs21.existsSync(parentBareHooks)) {
+      const parentBareHooks = path23.join(projectPath, "..", ".bare", "hooks");
+      if (fs22.existsSync(parentBareHooks)) {
         hooksDir = parentBareHooks;
       } else {
         console.warn(`[Daemon] Hooks directory not found for: ${projectPath}`);
         return;
       }
     }
-    if (!fs21.existsSync(hooksDir)) {
+    if (!fs22.existsSync(hooksDir)) {
       try {
-        fs21.mkdirSync(hooksDir, { recursive: true });
+        fs22.mkdirSync(hooksDir, { recursive: true });
       } catch (error) {
         console.warn(`[Daemon] Hooks directory not found and could not create: ${hooksDir}`);
         return;
@@ -10846,20 +10939,20 @@ var Daemon = class _Daemon {
     }
     for (const hookName of hooks) {
       try {
-        const hookPath = path22.join(hooksDir, hookName);
-        const bundledHookPath = path22.join(__dirname, "..", "hooks", hookName);
-        if (!fs21.existsSync(bundledHookPath)) {
+        const hookPath = path23.join(hooksDir, hookName);
+        const bundledHookPath = path23.join(__dirname, "..", "hooks", hookName);
+        if (!fs22.existsSync(bundledHookPath)) {
           console.warn(`[Daemon] Bundled hook not found: ${bundledHookPath}`);
           continue;
         }
-        const hookContent = fs21.readFileSync(bundledHookPath, "utf-8");
-        if (fs21.existsSync(hookPath)) {
-          const existingContent = fs21.readFileSync(hookPath, "utf-8");
+        const hookContent = fs22.readFileSync(bundledHookPath, "utf-8");
+        if (fs22.existsSync(hookPath)) {
+          const existingContent = fs22.readFileSync(hookPath, "utf-8");
           if (existingContent === hookContent) {
             continue;
           }
         }
-        fs21.writeFileSync(hookPath, hookContent, { mode: 493 });
+        fs22.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);
@@ -11863,8 +11956,8 @@ var Daemon = class _Daemon {
     await this.shutdown();
     try {
       const pidPath = getPidFilePath();
-      if (fs21.existsSync(pidPath)) {
-        fs21.unlinkSync(pidPath);
+      if (fs22.existsSync(pidPath)) {
+        fs22.unlinkSync(pidPath);
         console.log("[Daemon] PID file cleaned up");
       }
     } catch (error) {