@episoda/cli 0.2.164 → 0.2.166

package/dist/daemon/daemon-process.js

@@ -1640,15 +1640,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 fs29 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+            const fs30 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
             const rebaseMergePath = `${gitDirPath}/rebase-merge`;
             const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
             try {
-              await fs29.access(rebaseMergePath);
+              await fs30.access(rebaseMergePath);
               inRebase = true;
             } catch {
               try {
-                await fs29.access(rebaseApplyPath);
+                await fs30.access(rebaseApplyPath);
                 inRebase = true;
               } catch {
                 inRebase = false;
@@ -1704,9 +1704,9 @@ var require_git_executor = __commonJS({
               };
             }
           }
-          const fs29 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs30 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs29.access(command.path);
+            await fs30.access(command.path);
             return {
               success: false,
               error: "WORKTREE_EXISTS",
@@ -1765,9 +1765,9 @@ var require_git_executor = __commonJS({
        */
       async executeWorktreeRemove(command, cwd, options) {
         try {
-          const fs29 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs30 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs29.access(command.path);
+            await fs30.access(command.path);
           } catch {
             return {
               success: false,
@@ -1802,7 +1802,7 @@ var require_git_executor = __commonJS({
           const result = await this.runGitCommand(args, cwd, options);
           if (result.success) {
             try {
-              await fs29.rm(command.path, { recursive: true, force: true });
+              await fs30.rm(command.path, { recursive: true, force: true });
             } catch {
             }
             return {
@@ -1936,10 +1936,10 @@ var require_git_executor = __commonJS({
        */
       async executeCloneBare(command, options) {
         try {
-          const fs29 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path30 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs30 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path31 = await Promise.resolve().then(() => __importStar(require("path")));
           try {
-            await fs29.access(command.path);
+            await fs30.access(command.path);
             return {
               success: false,
               error: "BRANCH_ALREADY_EXISTS",
@@ -1948,9 +1948,9 @@ var require_git_executor = __commonJS({
             };
           } catch {
           }
-          const parentDir = path30.dirname(command.path);
+          const parentDir = path31.dirname(command.path);
           try {
-            await fs29.mkdir(parentDir, { recursive: true });
+            await fs30.mkdir(parentDir, { recursive: true });
           } catch {
           }
           const { stdout, stderr } = await execAsync3(
@@ -1998,22 +1998,22 @@ var require_git_executor = __commonJS({
        */
       async executeProjectInfo(cwd, options) {
         try {
-          const fs29 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path30 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs30 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path31 = await Promise.resolve().then(() => __importStar(require("path")));
           let currentPath = cwd;
           let projectPath = cwd;
           let bareRepoPath;
           for (let i = 0; i < 10; i++) {
-            const bareDir = path30.join(currentPath, ".bare");
-            const episodaDir = path30.join(currentPath, ".episoda");
+            const bareDir = path31.join(currentPath, ".bare");
+            const episodaDir = path31.join(currentPath, ".episoda");
             try {
-              await fs29.access(bareDir);
-              await fs29.access(episodaDir);
+              await fs30.access(bareDir);
+              await fs30.access(episodaDir);
               projectPath = currentPath;
               bareRepoPath = bareDir;
               break;
             } catch {
-              const parentPath = path30.dirname(currentPath);
+              const parentPath = path31.dirname(currentPath);
               if (parentPath === currentPath) {
                 break;
               }
@@ -2674,33 +2674,33 @@ var require_auth = __commonJS({
     exports2.loadConfig = loadConfig16;
     exports2.saveConfig = saveConfig4;
     exports2.validateToken = validateToken;
-    var fs29 = __importStar(require("fs"));
-    var path30 = __importStar(require("path"));
+    var fs30 = __importStar(require("fs"));
+    var path31 = __importStar(require("path"));
     var os13 = __importStar(require("os"));
     var child_process_1 = require("child_process");
     var DEFAULT_CONFIG_FILE = "config.json";
     var hasWarnedMissingProjectId = false;
     var hasWarnedMissingRequiredFields = false;
     function getConfigDir10() {
-      return process.env.EPISODA_CONFIG_DIR || path30.join(os13.homedir(), ".episoda");
+      return process.env.EPISODA_CONFIG_DIR || path31.join(os13.homedir(), ".episoda");
     }
     function getConfigPath(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path30.join(getConfigDir10(), DEFAULT_CONFIG_FILE);
+      return path31.join(getConfigDir10(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path30.dirname(configPath);
-      const isNew = !fs29.existsSync(dir);
+      const dir = path31.dirname(configPath);
+      const isNew = !fs30.existsSync(dir);
       if (isNew) {
-        fs29.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs30.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path30.join(dir, ".nosync");
-        if (isNew || !fs29.existsSync(nosyncPath)) {
+        const nosyncPath = path31.join(dir, ".nosync");
+        if (isNew || !fs30.existsSync(nosyncPath)) {
           try {
-            fs29.writeFileSync(nosyncPath, "", { mode: 384 });
+            fs30.writeFileSync(nosyncPath, "", { mode: 384 });
             (0, child_process_1.execSync)(`xattr -w com.apple.fileprovider.ignore 1 "${dir}"`, {
               stdio: "ignore",
               timeout: 5e3
@@ -2714,11 +2714,11 @@ var require_auth = __commonJS({
       const fullPath = getConfigPath(configPath);
       const isCloudMode = process.env.EPISODA_MODE === "cloud";
       const readConfigFile = (pathToFile) => {
-        if (!fs29.existsSync(pathToFile)) {
+        if (!fs30.existsSync(pathToFile)) {
           return null;
         }
         try {
-          const content = fs29.readFileSync(pathToFile, "utf8");
+          const content = fs30.readFileSync(pathToFile, "utf8");
           return JSON.parse(content);
         } catch (error) {
           console.error("Error loading config:", error);
@@ -2757,11 +2757,11 @@ var require_auth = __commonJS({
         }
         const homeDir = process.env.HOME || require("os").homedir();
         const workspaceConfigPath = require("path").join(homeDir, "episoda", process.env.EPISODA_WORKSPACE, ".episoda", "config.json");
-        if (!fs29.existsSync(workspaceConfigPath)) {
+        if (!fs30.existsSync(workspaceConfigPath)) {
           return null;
         }
         try {
-          const content = fs29.readFileSync(workspaceConfigPath, "utf8");
+          const content = fs30.readFileSync(workspaceConfigPath, "utf8");
           const workspaceConfig2 = JSON.parse(content);
           const expiresAtEnv = envValue(process.env.EPISODA_ACCESS_TOKEN_EXPIRES_AT);
           return {
@@ -2789,11 +2789,11 @@ var require_auth = __commonJS({
         }
         const homeDir = process.env.HOME || require("os").homedir();
         const projectConfigPath = require("path").join(homeDir, "episoda", workspaceSlug, projectSlug, ".episoda", "config.json");
-        if (!fs29.existsSync(projectConfigPath)) {
+        if (!fs30.existsSync(projectConfigPath)) {
           return null;
         }
         try {
-          const content = fs29.readFileSync(projectConfigPath, "utf8");
+          const content = fs30.readFileSync(projectConfigPath, "utf8");
           const projectConfig2 = JSON.parse(content);
           return {
             project_id: projectConfig2.projectId || projectConfig2.project_id,
@@ -2861,7 +2861,7 @@ var require_auth = __commonJS({
       ensureConfigDir(fullPath);
       try {
         const content = JSON.stringify(config, null, 2);
-        fs29.writeFileSync(fullPath, content, { mode: 384 });
+        fs30.writeFileSync(fullPath, content, { mode: 384 });
       } catch (error) {
         throw new Error(`Failed to save config: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -2978,7 +2978,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@episoda/cli",
-      version: "0.2.164",
+      version: "0.2.166",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -4979,7 +4979,9 @@ var import_core9 = __toESM(require_dist());
 
 // src/agent/claude-persistent-runtime.ts
 var import_child_process7 = require("child_process");
-var ECHO_TIMEOUT_MS = parseInt(process.env.AGENT_ECHO_TIMEOUT_MS || "10000", 10);
+var DEFAULT_STARTUP_GRACE_MS = 3e4;
+var HEARTBEAT_ACK_MARKER = "__EPISODA_HEARTBEAT_ACK__";
+var ECHO_TIMEOUT_MS = parseInt(process.env.AGENT_ECHO_TIMEOUT_MS || `${DEFAULT_STARTUP_GRACE_MS}`, 10);
 var INACTIVITY_TIMEOUT_MS = parseInt(process.env.AGENT_STREAM_INACTIVITY_TIMEOUT_MS || "180000", 10);
 var SHUTDOWN_SIGTERM_WAIT_MS = 2e3;
 var SHUTDOWN_SIGKILL_WAIT_MS = 2e3;
@@ -5015,7 +5017,6 @@ var ClaudePersistentRuntime = class {
     this.echoTimer = null;
     this.inactivityTimer = null;
     this.turnStartTime = 0;
-    this.sawAnyStdoutThisTurn = false;
     // EP1360: Instrumentation
     this.spawnTimestamp = 0;
     this.sessionId = options.sessionId;
@@ -5055,6 +5056,11 @@ var ClaudePersistentRuntime = class {
     this.alive = true;
     this.process.stderr?.on("data", (data) => {
       const chunk = data.toString();
+      this.resetInactivityTimer();
+      if (this._turnState === "waiting_for_echo") {
+        const source = chunk.includes(HEARTBEAT_ACK_MARKER) ? "stderr-marker" : "stderr";
+        this.recordStartupHeartbeatAck(source);
+      }
       this.stderrTail = (this.stderrTail + chunk).slice(-this.maxStderrTailBytes);
       if (RUNTIME_DEBUG) {
         console.error(`[ClaudePersistentRuntime] stderr (session=${this.sessionId}): ${chunk.trimEnd()}`);
@@ -5062,6 +5068,7 @@ var ClaudePersistentRuntime = class {
     });
     this.process.stdout?.on("data", (data) => {
       this.resetInactivityTimer();
+      this.recordStartupHeartbeatAck("stdout");
       this.stdoutBuffer += data.toString();
       const lines = this.stdoutBuffer.split("\n");
       this.stdoutBuffer = lines.pop() || "";
@@ -5112,7 +5119,6 @@ var ClaudePersistentRuntime = class {
     this.turnStartTime = Date.now();
     this.turnTtftLogged = false;
     this.seenToolUseIds.clear();
-    this.sawAnyStdoutThisTurn = false;
     this._turnState = "waiting_for_echo";
     const payload = JSON.stringify({ type: "user", message: { role: "user", content: message } }) + "\n";
     try {
@@ -5125,9 +5131,9 @@ var ClaudePersistentRuntime = class {
     }
     this.echoTimer = setTimeout(() => {
       if (this._turnState === "waiting_for_echo") {
-        console.warn(`[ClaudePersistentRuntime] Echo timeout after ${ECHO_TIMEOUT_MS}ms \u2014 auto-degrading. session=${this.sessionId}`);
+        console.warn(`[ClaudePersistentRuntime] Startup heartbeat timeout after ${ECHO_TIMEOUT_MS}ms \u2014 auto-degrading. session=${this.sessionId}`);
         if (this.callbacks) {
-          this.callbacks.onError(`ECHO_TIMEOUT: No stdout event within ${ECHO_TIMEOUT_MS}ms after send`);
+          this.callbacks.onError(`ECHO_TIMEOUT: No startup heartbeat within ${ECHO_TIMEOUT_MS}ms after send`);
           this.endTurn();
         }
       }
@@ -5210,14 +5216,7 @@ var ClaudePersistentRuntime = class {
   }
   handleParsedEvent(parsed) {
     const type = parsed.type;
-    if (this._turnState === "waiting_for_echo") {
-      this.sawAnyStdoutThisTurn = true;
-      this.clearEchoTimer();
-      this._turnState = "streaming";
-      if (RUNTIME_DEBUG) {
-        console.log(`[ClaudePersistentRuntime] First stdout for turn \u2014 streaming started. session=${this.sessionId}`);
-      }
-    }
+    this.recordStartupHeartbeatAck("stdout");
     if (type === "user") {
       return;
     }
@@ -5403,6 +5402,14 @@ var ClaudePersistentRuntime = class {
     this.endTurn();
     cb.onComplete(this._agentSessionId, resultMeta);
   }
+  recordStartupHeartbeatAck(source) {
+    if (this._turnState !== "waiting_for_echo") return;
+    this.clearEchoTimer();
+    this._turnState = "streaming";
+    if (RUNTIME_DEBUG) {
+      console.log(`[ClaudePersistentRuntime] Startup heartbeat ack via ${source}; streaming started. session=${this.sessionId}`);
+    }
+  }
   endTurn() {
     this.clearTimers();
     this.callbacks = null;
@@ -9472,7 +9479,7 @@ function getInstallCommand(cwd) {
 }
 
 // src/daemon/daemon-process.ts
-var fs28 = __toESM(require("fs"));
+var fs29 = __toESM(require("fs"));
 var http2 = __toESM(require("http"));
 var os12 = __toESM(require("os"));
 
@@ -10280,8 +10287,8 @@ async function handleExec(command, projectPath) {
 }
 
 // src/daemon/handlers/worktree-handlers.ts
-var path23 = __toESM(require("path"));
-var fs22 = __toESM(require("fs"));
+var path24 = __toESM(require("path"));
+var fs23 = __toESM(require("fs"));
 var os10 = __toESM(require("os"));
 var import_child_process15 = require("child_process");
 var import_util2 = require("util");
@@ -11628,7 +11635,7 @@ function pnpmCommand(args) {
     '  echo "[setup] ERROR: pnpm is not installed and corepack is unavailable" >&2',
     "  exit 127",
     "fi"
-  ].join(" ");
+  ].join("\n");
 }
 var PACKAGE_MANAGERS = {
   javascript: [
@@ -11765,6 +11772,51 @@ function detectPackageManager(worktreePath, preferredLanguages) {
   };
 }
 
+// src/daemon/build-packages.ts
+var fs22 = __toESM(require("fs"));
+var path23 = __toESM(require("path"));
+function hasPackageScript(worktreePath, scriptName) {
+  try {
+    const packageJsonPath = path23.join(worktreePath, "package.json");
+    if (!fs22.existsSync(packageJsonPath)) {
+      return false;
+    }
+    const packageJson2 = JSON.parse(fs22.readFileSync(packageJsonPath, "utf-8"));
+    return typeof packageJson2.scripts?.[scriptName] === "string";
+  } catch {
+    return false;
+  }
+}
+function getBuildPackagesCommand(packageManagerName, hasBuildPackagesScript) {
+  if (!hasBuildPackagesScript) {
+    return null;
+  }
+  switch (packageManagerName) {
+    case "pnpm":
+      return [
+        "if command -v pnpm >/dev/null 2>&1; then",
+        "  pnpm run build:packages",
+        "elif command -v corepack >/dev/null 2>&1; then",
+        "  corepack pnpm run build:packages",
+        "else",
+        '  echo "[setup] ERROR: pnpm is not installed and corepack is unavailable" >&2',
+        "  exit 127",
+        "fi"
+      ].join("\n");
+    case "yarn":
+      return "yarn build:packages";
+    case "npm":
+      return "npm run build:packages";
+    case "bun":
+      return "bun run build:packages";
+    default:
+      return null;
+  }
+}
+function shouldRunBuildPackagesBootstrap(installSucceeded, buildPackagesCommand) {
+  return installSucceeded && !!buildPackagesCommand;
+}
+
 // src/daemon/handlers/worktree-handlers.ts
 async function getConfigForApi() {
   if (process.env.EPISODA_MODE === "cloud" && process.env.EPISODA_ACCESS_TOKEN) {
@@ -11788,18 +11840,18 @@ function persistWorkspaceProjectContext(workspaceSlug, projectSlug, projectId) {
     return;
   }
   const homeDir = process.env.HOME || os10.homedir();
-  const workspaceConfigPath = path23.join(
+  const workspaceConfigPath = path24.join(
     homeDir,
     "episoda",
     workspaceSlug,
     ".episoda",
     "config.json"
   );
-  if (!fs22.existsSync(workspaceConfigPath)) {
+  if (!fs23.existsSync(workspaceConfigPath)) {
     return;
   }
   try {
-    const content = fs22.readFileSync(workspaceConfigPath, "utf8");
+    const content = fs23.readFileSync(workspaceConfigPath, "utf8");
     const workspaceConfig = JSON.parse(content);
     let changed = false;
     if (projectId && workspaceConfig.projectId !== projectId && workspaceConfig.project_id !== projectId) {
@@ -11811,7 +11863,7 @@ function persistWorkspaceProjectContext(workspaceSlug, projectSlug, projectId) {
       changed = true;
     }
     if (changed) {
-      fs22.writeFileSync(workspaceConfigPath, JSON.stringify(workspaceConfig, null, 2), "utf8");
+      fs23.writeFileSync(workspaceConfigPath, JSON.stringify(workspaceConfig, null, 2), "utf8");
       console.log("[Worktree] Updated workspace config with project context");
     }
   } catch (error) {
@@ -11828,32 +11880,6 @@ async function autoDetectSetupScript(worktreePath) {
   console.log(`[Worktree] EP1222: Detected ${name} (${language}) via ${detection.matchedFile}`);
   return installCmd;
 }
-function getBuildPackagesCommand(packageManagerName) {
-  switch (packageManagerName) {
-    case "pnpm":
-      return 'if command -v pnpm >/dev/null 2>&1; then pnpm run build:packages; elif command -v corepack >/dev/null 2>&1; then corepack pnpm run build:packages; else echo "[setup] ERROR: pnpm is not installed and corepack is unavailable" >&2; exit 127; fi';
-    case "yarn":
-      return "yarn build:packages";
-    case "npm":
-      return "npm run build:packages";
-    case "bun":
-      return "bun run build:packages";
-    default:
-      return null;
-  }
-}
-function hasPackageScript(worktreePath, scriptName) {
-  try {
-    const packageJsonPath = path23.join(worktreePath, "package.json");
-    if (!fs22.existsSync(packageJsonPath)) {
-      return false;
-    }
-    const packageJson2 = JSON.parse(fs22.readFileSync(packageJsonPath, "utf-8"));
-    return typeof packageJson2.scripts?.[scriptName] === "string";
-  } catch {
-    return false;
-  }
-}
 async function handleWorktreeCreate(request2) {
   const {
     workspaceSlug,
@@ -11884,19 +11910,19 @@ async function handleWorktreeCreate(request2) {
   }
   try {
     const projectPath = getProjectPath(workspaceSlug, projectSlug);
-    const bareRepoPath = path23.join(projectPath, ".bare");
+    const bareRepoPath = path24.join(projectPath, ".bare");
     const gitEnv = projectId ? { ...process.env, EPISODA_PROJECT_ID: projectId } : process.env;
-    if (!fs22.existsSync(bareRepoPath)) {
+    if (!fs23.existsSync(bareRepoPath)) {
       console.log(`[Worktree] K1273: Project not found, cloning lazily...`);
       console.log(`[Worktree]   Repo URL: ${repoUrl.replace(/\/\/[^@]*@/, "//***@")}`);
-      const episodaDir = path23.join(projectPath, ".episoda");
-      fs22.mkdirSync(episodaDir, { recursive: true });
+      const episodaDir = path24.join(projectPath, ".episoda");
+      fs23.mkdirSync(episodaDir, { recursive: true });
       try {
         console.log(`[Worktree] K1273: Starting git clone...`);
         await execAsync2(`git clone --bare "${repoUrl}" "${bareRepoPath}"`, { env: gitEnv });
         console.log(`[Worktree] K1273: Clone successful`);
         await execAsync2(`git -C "${bareRepoPath}" config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"`, { env: gitEnv });
-        const configPath = path23.join(episodaDir, "config.json");
+        const configPath = path24.join(episodaDir, "config.json");
         const config = {
           projectId,
           workspaceSlug,
@@ -11905,7 +11931,7 @@ async function handleWorktreeCreate(request2) {
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),
           worktrees: []
         };
-        fs22.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+        fs23.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
         console.log(`[Worktree] K1273: Project initialized at ${projectPath}`);
       } catch (cloneError) {
         console.error(`[Worktree] K1273: Git clone failed: ${cloneError.message}`);
@@ -11940,16 +11966,16 @@ async function handleWorktreeCreate(request2) {
     let finalError;
     if (envVars && Object.keys(envVars).length > 0) {
       const envContent = Object.entries(envVars).map(([key, value]) => `${key}=${value}`).join("\n");
-      const envPath = path23.join(worktreePath, ".env");
-      fs22.writeFileSync(envPath, envContent + "\n", "utf-8");
+      const envPath = path24.join(worktreePath, ".env");
+      fs23.writeFileSync(envPath, envContent + "\n", "utf-8");
       console.log(`[Worktree] EP1143: Wrote ${Object.keys(envVars).length} env vars to .env`);
     }
     const isCloud = process.env.EPISODA_MODE === "cloud";
     let effectiveSetupScript = setupScript || await autoDetectSetupScript(worktreePath);
     const detection = detectPackageManager(worktreePath);
-    const buildCmd = getBuildPackagesCommand(detection.packageManager?.name);
     const hasBuildPackages = hasPackageScript(worktreePath, "build:packages");
-    if (buildCmd && hasBuildPackages && !effectiveSetupScript?.includes("build:packages")) {
+    const buildCmd = getBuildPackagesCommand(detection.packageManager?.name, hasBuildPackages);
+    if (buildCmd && !effectiveSetupScript?.includes("build:packages")) {
       effectiveSetupScript = effectiveSetupScript ? `${effectiveSetupScript}
 ${buildCmd}` : buildCmd;
       console.log(`[Worktree] EP1386: Added build:packages bootstrap for ${isCloud ? "cloud" : "local"} setup`);
@@ -12082,12 +12108,12 @@ async function handleProjectEject(request2) {
   console.log(`[Worktree] EP1144: Ejecting project ${projectSlug} from workspace ${workspaceSlug}`);
   try {
     const projectPath = getProjectPath(workspaceSlug, projectSlug);
-    const bareRepoPath = path23.join(projectPath, ".bare");
-    if (!fs22.existsSync(projectPath)) {
+    const bareRepoPath = path24.join(projectPath, ".bare");
+    if (!fs23.existsSync(projectPath)) {
       console.log(`[Worktree] EP1144: Project path not found, nothing to eject: ${projectPath}`);
       return { success: true };
     }
-    if (!fs22.existsSync(bareRepoPath)) {
+    if (!fs23.existsSync(bareRepoPath)) {
       console.log(`[Worktree] EP1144: Bare repo not found, nothing to eject: ${bareRepoPath}`);
       return { success: true };
     }
@@ -12102,12 +12128,12 @@ async function handleProjectEject(request2) {
         };
       }
     }
-    const artifactsPath = path23.join(projectPath, "artifacts");
-    if (fs22.existsSync(artifactsPath)) {
+    const artifactsPath = path24.join(projectPath, "artifacts");
+    if (fs23.existsSync(artifactsPath)) {
       await persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug);
     }
     console.log(`[Worktree] EP1144: Removing project directory: ${projectPath}`);
-    await fs22.promises.rm(projectPath, { recursive: true, force: true });
+    await fs23.promises.rm(projectPath, { recursive: true, force: true });
     console.log(`[Worktree] EP1144: Successfully ejected project ${projectSlug}`);
     return { success: true };
   } catch (error) {
@@ -12121,7 +12147,7 @@ async function handleProjectEject(request2) {
 async function persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug) {
   const MAX_ARTIFACT_SIZE = 10 * 1024 * 1024;
   try {
-    const files = await fs22.promises.readdir(artifactsPath);
+    const files = await fs23.promises.readdir(artifactsPath);
     if (files.length === 0) {
       return;
     }
@@ -12135,8 +12161,8 @@ async function persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug
     }
     const artifacts = [];
     for (const fileName of files) {
-      const filePath = path23.join(artifactsPath, fileName);
-      const stat = await fs22.promises.stat(filePath);
+      const filePath = path24.join(artifactsPath, fileName);
+      const stat = await fs23.promises.stat(filePath);
       if (stat.isDirectory()) {
         continue;
       }
@@ -12145,9 +12171,9 @@ async function persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug
         continue;
       }
       try {
-        const content = await fs22.promises.readFile(filePath);
+        const content = await fs23.promises.readFile(filePath);
         const base64Content = content.toString("base64");
-        const ext = path23.extname(fileName).toLowerCase();
+        const ext = path24.extname(fileName).toLowerCase();
         const mimeTypes = {
           ".json": "application/json",
           ".txt": "text/plain",
@@ -12203,8 +12229,8 @@ async function persistArtifactsBeforeEject(artifactsPath, projectId, projectSlug
 }
 
 // src/daemon/handlers/project-handlers.ts
-var path24 = __toESM(require("path"));
-var fs23 = __toESM(require("fs"));
+var path25 = __toESM(require("path"));
+var fs24 = __toESM(require("fs"));
 function validateSlug(slug, fieldName) {
   if (!slug || typeof slug !== "string") {
     return `${fieldName} is required`;
@@ -12244,14 +12270,14 @@ async function handleProjectSetup(params) {
   console.log(`[ProjectSetup] EP1199: Setting up project ${workspaceSlug}/${projectSlug}`);
   try {
     const projectPath = getProjectPath(workspaceSlug, projectSlug);
-    const artifactsPath = path24.join(projectPath, "artifacts");
-    const configDir = path24.join(projectPath, ".episoda");
-    const configPath = path24.join(configDir, "config.json");
-    await fs23.promises.mkdir(artifactsPath, { recursive: true });
-    await fs23.promises.mkdir(configDir, { recursive: true });
+    const artifactsPath = path25.join(projectPath, "artifacts");
+    const configDir = path25.join(projectPath, ".episoda");
+    const configPath = path25.join(configDir, "config.json");
+    await fs24.promises.mkdir(artifactsPath, { recursive: true });
+    await fs24.promises.mkdir(configDir, { recursive: true });
     let existingConfig = {};
     try {
-      const existing = await fs23.promises.readFile(configPath, "utf-8");
+      const existing = await fs24.promises.readFile(configPath, "utf-8");
       existingConfig = JSON.parse(existing);
     } catch {
     }
@@ -12264,7 +12290,7 @@ async function handleProjectSetup(params) {
       // Only set created_at if not already present
       created_at: existingConfig.created_at || (/* @__PURE__ */ new Date()).toISOString()
     };
-    await fs23.promises.writeFile(configPath, JSON.stringify(config, null, 2));
+    await fs24.promises.writeFile(configPath, JSON.stringify(config, null, 2));
     console.log(`[ProjectSetup] EP1199: Project setup complete at ${projectPath}`);
     return {
       success: true,
@@ -12284,8 +12310,8 @@ async function handleProjectSetup(params) {
 // src/utils/dev-server.ts
 var import_child_process16 = require("child_process");
 var import_core14 = __toESM(require_dist());
-var fs24 = __toESM(require("fs"));
-var path25 = __toESM(require("path"));
+var fs25 = __toESM(require("fs"));
+var path26 = __toESM(require("path"));
 var MAX_RESTART_ATTEMPTS = 5;
 var INITIAL_RESTART_DELAY_MS = 2e3;
 var MAX_RESTART_DELAY_MS = 3e4;
@@ -12293,26 +12319,26 @@ var MAX_LOG_SIZE_BYTES2 = 5 * 1024 * 1024;
 var NODE_MEMORY_LIMIT_MB = 2048;
 var activeServers = /* @__PURE__ */ new Map();
 function getLogsDir() {
-  const logsDir = path25.join((0, import_core14.getConfigDir)(), "logs");
-  if (!fs24.existsSync(logsDir)) {
-    fs24.mkdirSync(logsDir, { recursive: true });
+  const logsDir = path26.join((0, import_core14.getConfigDir)(), "logs");
+  if (!fs25.existsSync(logsDir)) {
+    fs25.mkdirSync(logsDir, { recursive: true });
   }
   return logsDir;
 }
 function getLogFilePath(moduleUid) {
-  return path25.join(getLogsDir(), `dev-${moduleUid}.log`);
+  return path26.join(getLogsDir(), `dev-${moduleUid}.log`);
 }
 function rotateLogIfNeeded(logPath) {
   try {
-    if (fs24.existsSync(logPath)) {
-      const stats = fs24.statSync(logPath);
+    if (fs25.existsSync(logPath)) {
+      const stats = fs25.statSync(logPath);
       if (stats.size > MAX_LOG_SIZE_BYTES2) {
         const backupPath = `${logPath}.1`;
-        if (fs24.existsSync(backupPath)) {
-          fs24.unlinkSync(backupPath);
+        if (fs25.existsSync(backupPath)) {
+          fs25.unlinkSync(backupPath);
         }
-        fs24.renameSync(logPath, backupPath);
-        console.log(`[DevServer] EP932: Rotated log file for ${path25.basename(logPath)}`);
+        fs25.renameSync(logPath, backupPath);
+        console.log(`[DevServer] EP932: Rotated log file for ${path26.basename(logPath)}`);
       }
     }
   } catch (error) {
@@ -12325,7 +12351,7 @@ function writeToLog(logPath, line, isError = false) {
     const prefix = isError ? "ERR" : "OUT";
     const logLine = `[${timestamp}] [${prefix}] ${line}
 `;
-    fs24.appendFileSync(logPath, logLine);
+    fs25.appendFileSync(logPath, logLine);
   } catch {
   }
 }
@@ -12504,8 +12530,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 = path25.join(projectPath, ".env");
-      if (!fs24.existsSync(envFilePath) && Object.keys(injectedEnvVars).length > 0) {
+      const envFilePath = path26.join(projectPath, ".env");
+      if (!fs25.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);
       }
@@ -12846,8 +12872,8 @@ var IPCRouter = class {
 };
 
 // src/daemon/update-manager.ts
-var fs25 = __toESM(require("fs"));
-var path26 = __toESM(require("path"));
+var fs26 = __toESM(require("fs"));
+var path27 = __toESM(require("path"));
 var import_child_process18 = require("child_process");
 var import_core17 = __toESM(require_dist());
 var semver2 = __toESM(require("semver"));
@@ -13105,8 +13131,8 @@ var UpdateManager = class _UpdateManager {
       console.log(`[Daemon] EP1324: Update to ${targetVersion} installed, restarting daemon...`);
       await this.host.shutdown();
       const configDir = (0, import_core17.getConfigDir)();
-      const logPath = path26.join(configDir, "daemon.log");
-      const logFd = fs25.openSync(logPath, "a");
+      const logPath = path27.join(configDir, "daemon.log");
+      const logFd = fs26.openSync(logPath, "a");
       const child = (0, import_child_process18.spawn)("node", [this.daemonEntryFile], {
         detached: true,
         stdio: ["ignore", logFd, logFd],
@@ -13114,7 +13140,7 @@ var UpdateManager = class _UpdateManager {
       });
       if (!child.pid) {
         try {
-          fs25.closeSync(logFd);
+          fs26.closeSync(logFd);
         } catch {
         }
         this.recordUpdateFailure(targetVersion, "Failed to spawn replacement daemon (missing pid)");
@@ -13122,7 +13148,7 @@ var UpdateManager = class _UpdateManager {
       }
       child.unref();
       const pidPath = getPidFilePath();
-      fs25.writeFileSync(pidPath, child.pid.toString(), "utf-8");
+      fs26.writeFileSync(pidPath, child.pid.toString(), "utf-8");
       console.log(`[Daemon] EP1324: New daemon spawned (PID: ${child.pid}), exiting old process`);
       process.exit(0);
     } catch (error) {
@@ -13173,8 +13199,8 @@ var UpdateManager = class _UpdateManager {
 };
 
 // src/daemon/health-orchestrator.ts
-var fs26 = __toESM(require("fs"));
-var path27 = __toESM(require("path"));
+var fs27 = __toESM(require("fs"));
+var path28 = __toESM(require("path"));
 var import_core18 = __toESM(require_dist());
 var HealthOrchestrator = class _HealthOrchestrator {
   constructor(host) {
@@ -13416,26 +13442,26 @@ var HealthOrchestrator = class _HealthOrchestrator {
   checkAndRotateLog() {
     try {
       const configDir = (0, import_core18.getConfigDir)();
-      const logPath = path27.join(configDir, "daemon.log");
-      if (!fs26.existsSync(logPath)) return;
-      const stats = fs26.statSync(logPath);
+      const logPath = path28.join(configDir, "daemon.log");
+      if (!fs27.existsSync(logPath)) return;
+      const stats = fs27.statSync(logPath);
       if (stats.size < _HealthOrchestrator.MAX_LOG_SIZE_BYTES) return;
       console.log(`[Daemon] EP1351: daemon.log is ${Math.round(stats.size / 1024 / 1024)}MB, rotating...`);
       for (let i = _HealthOrchestrator.MAX_LOG_FILES - 1; i >= 1; i--) {
         const src = `${logPath}.${i}`;
         const dst = `${logPath}.${i + 1}`;
-        if (fs26.existsSync(src)) {
+        if (fs27.existsSync(src)) {
           try {
-            fs26.renameSync(src, dst);
+            fs27.renameSync(src, dst);
           } catch {
           }
         }
       }
       try {
-        fs26.copyFileSync(logPath, `${logPath}.1`);
+        fs27.copyFileSync(logPath, `${logPath}.1`);
       } catch {
       }
-      fs26.truncateSync(logPath, 0);
+      fs27.truncateSync(logPath, 0);
       console.log("[Daemon] EP1351: Log rotated successfully");
     } catch (error) {
       console.warn("[Daemon] EP1351: Log rotation failed:", error instanceof Error ? error.message : error);
@@ -13865,7 +13891,7 @@ function resolveDaemonWsEndpoint(config, env = process.env) {
 
 // src/daemon/project-message-router.ts
 var import_core19 = __toESM(require_dist());
-var path28 = __toESM(require("path"));
+var path29 = __toESM(require("path"));
 var ProjectMessageRouter = class {
   constructor(host) {
     this.host = host;
@@ -13882,7 +13908,7 @@ var ProjectMessageRouter = class {
         client.updateActivity();
         try {
           const gitCmd = message.command;
-          const bareRepoPath = path28.join(projectPath, ".bare");
+          const bareRepoPath = path29.join(projectPath, ".bare");
           const cwd = gitCmd.worktreePath || bareRepoPath;
           if (gitCmd.worktreePath) {
             console.log(`[Daemon] Routing command to worktree: ${gitCmd.worktreePath}`);
@@ -14222,32 +14248,32 @@ async function fetchEnvVars2(projectId) {
 }
 
 // src/daemon/project-git-config.ts
-var fs27 = __toESM(require("fs"));
-var path29 = __toESM(require("path"));
+var fs28 = __toESM(require("fs"));
+var path30 = __toESM(require("path"));
 var import_core21 = __toESM(require_dist());
 function getGitDirs(projectPath) {
-  const bareDir = path29.join(projectPath, ".bare");
-  const gitPath = path29.join(projectPath, ".git");
-  if (fs27.existsSync(bareDir) && fs27.statSync(bareDir).isDirectory()) {
+  const bareDir = path30.join(projectPath, ".bare");
+  const gitPath = path30.join(projectPath, ".git");
+  if (fs28.existsSync(bareDir) && fs28.statSync(bareDir).isDirectory()) {
     return { gitDir: bareDir, workDir: projectPath };
   }
-  if (fs27.existsSync(gitPath) && fs27.statSync(gitPath).isDirectory()) {
+  if (fs28.existsSync(gitPath) && fs28.statSync(gitPath).isDirectory()) {
     return { gitDir: null, workDir: projectPath };
   }
-  if (fs27.existsSync(gitPath) && fs27.statSync(gitPath).isFile()) {
+  if (fs28.existsSync(gitPath) && fs28.statSync(gitPath).isFile()) {
     return { gitDir: null, workDir: projectPath };
   }
-  const entries = fs27.readdirSync(projectPath, { withFileTypes: true });
+  const entries = fs28.readdirSync(projectPath, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory() && entry.name.startsWith("EP")) {
-      const worktreePath = path29.join(projectPath, entry.name);
-      const worktreeGit = path29.join(worktreePath, ".git");
-      if (fs27.existsSync(worktreeGit)) {
+      const worktreePath = path30.join(projectPath, entry.name);
+      const worktreeGit = path30.join(worktreePath, ".git");
+      if (fs28.existsSync(worktreeGit)) {
         return { gitDir: null, workDir: worktreePath };
       }
     }
   }
-  if (fs27.existsSync(bareDir)) {
+  if (fs28.existsSync(bareDir)) {
     return { gitDir: bareDir, workDir: projectPath };
   }
   return { gitDir: null, workDir: projectPath };
@@ -14292,24 +14318,24 @@ async function configureGitUser(projectPath, userId, workspaceId, machineId, pro
 async function installGitHooks(projectPath) {
   const hooks = ["post-checkout", "pre-commit", "post-commit"];
   let hooksDir;
-  const bareHooksDir = path29.join(projectPath, ".bare", "hooks");
-  const gitHooksDir = path29.join(projectPath, ".git", "hooks");
-  if (fs27.existsSync(bareHooksDir)) {
+  const bareHooksDir = path30.join(projectPath, ".bare", "hooks");
+  const gitHooksDir = path30.join(projectPath, ".git", "hooks");
+  if (fs28.existsSync(bareHooksDir)) {
     hooksDir = bareHooksDir;
-  } else if (fs27.existsSync(gitHooksDir) && fs27.statSync(path29.join(projectPath, ".git")).isDirectory()) {
+  } else if (fs28.existsSync(gitHooksDir) && fs28.statSync(path30.join(projectPath, ".git")).isDirectory()) {
     hooksDir = gitHooksDir;
   } else {
-    const parentBareHooks = path29.join(projectPath, "..", ".bare", "hooks");
-    if (fs27.existsSync(parentBareHooks)) {
+    const parentBareHooks = path30.join(projectPath, "..", ".bare", "hooks");
+    if (fs28.existsSync(parentBareHooks)) {
       hooksDir = parentBareHooks;
     } else {
       console.warn(`[Daemon] Hooks directory not found for: ${projectPath}`);
       return;
     }
   }
-  if (!fs27.existsSync(hooksDir)) {
+  if (!fs28.existsSync(hooksDir)) {
     try {
-      fs27.mkdirSync(hooksDir, { recursive: true });
+      fs28.mkdirSync(hooksDir, { recursive: true });
     } catch {
       console.warn(`[Daemon] Hooks directory not found and could not create: ${hooksDir}`);
       return;
@@ -14317,20 +14343,20 @@ async function installGitHooks(projectPath) {
   }
   for (const hookName of hooks) {
     try {
-      const hookPath = path29.join(hooksDir, hookName);
-      const bundledHookPath = path29.join(__dirname, "..", "hooks", hookName);
-      if (!fs27.existsSync(bundledHookPath)) {
+      const hookPath = path30.join(hooksDir, hookName);
+      const bundledHookPath = path30.join(__dirname, "..", "hooks", hookName);
+      if (!fs28.existsSync(bundledHookPath)) {
         console.warn(`[Daemon] Bundled hook not found: ${bundledHookPath}`);
         continue;
       }
-      const hookContent = fs27.readFileSync(bundledHookPath, "utf-8");
-      if (fs27.existsSync(hookPath)) {
-        const existingContent = fs27.readFileSync(hookPath, "utf-8");
+      const hookContent = fs28.readFileSync(bundledHookPath, "utf-8");
+      if (fs28.existsSync(hookPath)) {
+        const existingContent = fs28.readFileSync(hookPath, "utf-8");
         if (existingContent === hookContent) {
           continue;
         }
       }
-      fs27.writeFileSync(hookPath, hookContent, { mode: 493 });
+      fs28.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);
@@ -14362,21 +14388,6 @@ async function cacheMachineUuid(machineUuid, machineId) {
 
 // src/daemon/daemon-process.ts
 var packageJson = require_package();
-function getBuildPackagesCommand2(installCmd) {
-  const runner = installCmd?.command?.[0];
-  switch (runner) {
-    case "pnpm":
-      return 'if command -v pnpm >/dev/null 2>&1; then pnpm run build:packages; elif command -v corepack >/dev/null 2>&1; then corepack pnpm run build:packages; else echo "[setup] ERROR: pnpm is not installed and corepack is unavailable" >&2; exit 127; fi';
-    case "yarn":
-      return "yarn build:packages";
-    case "npm":
-      return "npm run build:packages";
-    case "bun":
-      return "bun run build:packages";
-    default:
-      return null;
-  }
-}
 var Daemon = class _Daemon {
   constructor() {
     this.machineId = "";
@@ -14488,9 +14499,9 @@ var Daemon = class _Daemon {
       this.healthServer = http2.createServer((req, res) => {
         if (req.url === "/health" || req.url === "/") {
           const isConnected = this.connectionManager.liveConnectionCount() > 0;
-          const projects = Array.from(this.connectionManager.entries()).map(([path30, conn]) => ({
-            path: path30,
-            connected: this.connectionManager.hasLiveConnection(path30)
+          const projects = Array.from(this.connectionManager.entries()).map(([path31, conn]) => ({
+            path: path31,
+            connected: this.connectionManager.hasLiveConnection(path31)
           }));
           const status = {
             status: isConnected ? "healthy" : "degraded",
@@ -14563,8 +14574,8 @@ var Daemon = class _Daemon {
     await this.shutdown();
     try {
       const pidPath = getPidFilePath();
-      if (fs28.existsSync(pidPath)) {
-        fs28.unlinkSync(pidPath);
+      if (fs29.existsSync(pidPath)) {
+        fs29.unlinkSync(pidPath);
         console.log("[Daemon] PID file cleaned up (watchdog)");
       }
     } catch (error) {
@@ -14830,7 +14841,7 @@ var Daemon = class _Daemon {
                 const resolvedProjectPath = getProjectPath(cmd.workspaceSlug, cmd.projectSlug);
                 if (resolvedProjectPath !== projectPath) {
                   try {
-                    await fs28.promises.access(resolvedProjectPath);
+                    await fs29.promises.access(resolvedProjectPath);
                     agentWorkingDir = resolvedProjectPath;
                     console.log(`[Daemon] EP1230: Agent for ${cmd.moduleUid || "project"} in resolved project path: ${agentWorkingDir}`);
                   } catch {
@@ -15162,8 +15173,8 @@ var Daemon = class _Daemon {
       let daemonPid;
       try {
         const pidPath = getPidFilePath();
-        if (fs28.existsSync(pidPath)) {
-          const pidStr = fs28.readFileSync(pidPath, "utf-8").trim();
+        if (fs29.existsSync(pidPath)) {
+          const pidStr = fs29.readFileSync(pidPath, "utf-8").trim();
           daemonPid = parseInt(pidStr, 10);
         }
       } catch (pidError) {
@@ -15633,23 +15644,25 @@ var Daemon = class _Daemon {
     } else {
       console.log(`[Daemon] EP1002: No package manager detected, skipping dependency installation`);
     }
-    if (process.env.EPISODA_MODE === "cloud" && installSucceeded) {
-      const buildCmd = getBuildPackagesCommand2(installCmd);
-      if (buildCmd) {
-        console.log(`[Daemon] EP1262: Bootstrapping packages for cloud dev (${buildCmd})`);
-        try {
-          const { execSync: execSync10 } = await import("child_process");
-          execSync10(buildCmd, {
-            cwd: worktreePath,
-            stdio: "inherit",
-            timeout: 10 * 60 * 1e3,
-            env: { ...process.env, CI: "true" }
-          });
-          console.log("[Daemon] EP1262: Package bootstrap completed");
-        } catch (buildError) {
-          const errorMsg = buildError instanceof Error ? buildError.message : String(buildError);
-          console.warn(`[Daemon] EP1262: Package bootstrap failed (non-fatal): ${errorMsg}`);
-        }
+    const hasBuildPackages = hasPackageScript(worktreePath, "build:packages");
+    const buildCmd = getBuildPackagesCommand(installCmd?.command?.[0], hasBuildPackages);
+    if (buildCmd && shouldRunBuildPackagesBootstrap(installSucceeded, buildCmd)) {
+      const bootstrapCmd = buildCmd;
+      console.log(`[Daemon] EP1386: Bootstrapping packages after dependency install (${bootstrapCmd})`);
+      try {
+        const { execSync: execSync10 } = await import("child_process");
+        execSync10(bootstrapCmd, {
+          cwd: worktreePath,
+          stdio: "inherit",
+          timeout: 10 * 60 * 1e3,
+          env: { ...process.env, CI: "true" }
+        });
+        console.log("[Daemon] EP1386: Package bootstrap completed");
+      } catch (buildError) {
+        const errorMsg = buildError instanceof Error ? buildError.message : String(buildError);
+        await worktreeManager.updateWorktreeStatus(moduleUid, "error", errorMsg);
+        await this.updateModuleWorktreeStatus(moduleUid, "error", worktreePath, errorMsg);
+        throw new Error(`Package bootstrap failed: ${errorMsg}`);
       }
     }
     if (setupScript) {
@@ -15731,8 +15744,8 @@ var Daemon = class _Daemon {
     await this.shutdown();
     try {
       const pidPath = getPidFilePath();
-      if (fs28.existsSync(pidPath)) {
-        fs28.unlinkSync(pidPath);
+      if (fs29.existsSync(pidPath)) {
+        fs29.unlinkSync(pidPath);
         console.log("[Daemon] PID file cleaned up");
       }
     } catch (error) {