@episoda/cli 0.2.189 → 0.2.190

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 fs35 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+            const fs36 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
             const rebaseMergePath = `${gitDirPath}/rebase-merge`;
             const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
             try {
-              await fs35.access(rebaseMergePath);
+              await fs36.access(rebaseMergePath);
               inRebase = true;
             } catch {
               try {
-                await fs35.access(rebaseApplyPath);
+                await fs36.access(rebaseApplyPath);
                 inRebase = true;
               } catch {
                 inRebase = false;
@@ -1704,9 +1704,9 @@ var require_git_executor = __commonJS({
               };
             }
           }
-          const fs35 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs36 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs35.access(command.path);
+            await fs36.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 fs35 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs36 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs35.access(command.path);
+            await fs36.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 fs35.rm(command.path, { recursive: true, force: true });
+              await fs36.rm(command.path, { recursive: true, force: true });
             } catch {
             }
             return {
@@ -1936,10 +1936,10 @@ var require_git_executor = __commonJS({
        */
       async executeCloneBare(command, options) {
         try {
-          const fs35 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path37 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs36 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path38 = await Promise.resolve().then(() => __importStar(require("path")));
           try {
-            await fs35.access(command.path);
+            await fs36.access(command.path);
             return {
               success: false,
               error: "BRANCH_ALREADY_EXISTS",
@@ -1948,9 +1948,9 @@ var require_git_executor = __commonJS({
             };
           } catch {
           }
-          const parentDir = path37.dirname(command.path);
+          const parentDir = path38.dirname(command.path);
           try {
-            await fs35.mkdir(parentDir, { recursive: true });
+            await fs36.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 fs35 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path37 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs36 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path38 = await Promise.resolve().then(() => __importStar(require("path")));
           let currentPath = cwd;
           let projectPath = cwd;
           let bareRepoPath;
           for (let i = 0; i < 10; i++) {
-            const bareDir = path37.join(currentPath, ".bare");
-            const episodaDir = path37.join(currentPath, ".episoda");
+            const bareDir = path38.join(currentPath, ".bare");
+            const episodaDir = path38.join(currentPath, ".episoda");
             try {
-              await fs35.access(bareDir);
-              await fs35.access(episodaDir);
+              await fs36.access(bareDir);
+              await fs36.access(episodaDir);
               projectPath = currentPath;
               bareRepoPath = bareDir;
               break;
             } catch {
-              const parentPath = path37.dirname(currentPath);
+              const parentPath = path38.dirname(currentPath);
               if (parentPath === currentPath) {
                 break;
               }
@@ -2724,33 +2724,33 @@ var require_auth = __commonJS({
     exports2.loadConfig = loadConfig16;
     exports2.saveConfig = saveConfig4;
     exports2.validateToken = validateToken;
-    var fs35 = __importStar(require("fs"));
-    var path37 = __importStar(require("path"));
-    var os16 = __importStar(require("os"));
+    var fs36 = __importStar(require("fs"));
+    var path38 = __importStar(require("path"));
+    var os17 = __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 || path37.join(os16.homedir(), ".episoda");
+      return process.env.EPISODA_CONFIG_DIR || path38.join(os17.homedir(), ".episoda");
     }
     function getConfigPath(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path37.join(getConfigDir10(), DEFAULT_CONFIG_FILE);
+      return path38.join(getConfigDir10(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path37.dirname(configPath);
-      const isNew = !fs35.existsSync(dir);
+      const dir = path38.dirname(configPath);
+      const isNew = !fs36.existsSync(dir);
       if (isNew) {
-        fs35.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs36.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path37.join(dir, ".nosync");
-        if (isNew || !fs35.existsSync(nosyncPath)) {
+        const nosyncPath = path38.join(dir, ".nosync");
+        if (isNew || !fs36.existsSync(nosyncPath)) {
           try {
-            fs35.writeFileSync(nosyncPath, "", { mode: 384 });
+            fs36.writeFileSync(nosyncPath, "", { mode: 384 });
             (0, child_process_1.execSync)(`xattr -w com.apple.fileprovider.ignore 1 "${dir}"`, {
               stdio: "ignore",
               timeout: 5e3
@@ -2764,11 +2764,11 @@ var require_auth = __commonJS({
       const fullPath = getConfigPath(configPath);
       const isCloudMode = process.env.EPISODA_MODE === "cloud";
       const readConfigFile = (pathToFile) => {
-        if (!fs35.existsSync(pathToFile)) {
+        if (!fs36.existsSync(pathToFile)) {
           return null;
         }
         try {
-          const content = fs35.readFileSync(pathToFile, "utf8");
+          const content = fs36.readFileSync(pathToFile, "utf8");
           return JSON.parse(content);
         } catch (error) {
           console.error("Error loading config:", error);
@@ -2807,11 +2807,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 (!fs35.existsSync(workspaceConfigPath)) {
+        if (!fs36.existsSync(workspaceConfigPath)) {
           return null;
         }
         try {
-          const content = fs35.readFileSync(workspaceConfigPath, "utf8");
+          const content = fs36.readFileSync(workspaceConfigPath, "utf8");
           const workspaceConfig2 = JSON.parse(content);
           const expiresAtEnv = envValue(process.env.EPISODA_ACCESS_TOKEN_EXPIRES_AT);
           return {
@@ -2839,11 +2839,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 (!fs35.existsSync(projectConfigPath)) {
+        if (!fs36.existsSync(projectConfigPath)) {
           return null;
         }
         try {
-          const content = fs35.readFileSync(projectConfigPath, "utf8");
+          const content = fs36.readFileSync(projectConfigPath, "utf8");
           const projectConfig2 = JSON.parse(content);
           return {
             project_id: projectConfig2.projectId || projectConfig2.project_id,
@@ -2911,7 +2911,7 @@ var require_auth = __commonJS({
       ensureConfigDir(fullPath);
       try {
         const content = JSON.stringify(config, null, 2);
-        fs35.writeFileSync(fullPath, content, { mode: 384 });
+        fs36.writeFileSync(fullPath, content, { mode: 384 });
       } catch (error) {
         throw new Error(`Failed to save config: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -3046,7 +3046,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@episoda/cli",
-      version: "0.2.189",
+      version: "0.2.190",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -9663,14 +9663,14 @@ function getInstallCommand(cwd) {
 }
 
 // src/daemon/daemon-process.ts
-var fs34 = __toESM(require("fs"));
+var fs35 = __toESM(require("fs"));
 var http2 = __toESM(require("http"));
-var os15 = __toESM(require("os"));
-var path36 = __toESM(require("path"));
+var os16 = __toESM(require("os"));
+var path37 = __toESM(require("path"));
 var import_child_process19 = require("child_process");
 
 // src/daemon/ipc-router.ts
-var os14 = __toESM(require("os"));
+var os15 = __toESM(require("os"));
 var import_core15 = __toESM(require_dist());
 
 // src/daemon/handlers/file-handlers.ts
@@ -12873,6 +12873,9 @@ async function handleProjectSetup(params) {
 
 // src/daemon/handlers/pty-handler.ts
 var pty = __toESM(require("@lydell/node-pty"));
+var fs30 = __toESM(require("fs"));
+var os14 = __toESM(require("os"));
+var path30 = __toESM(require("path"));
 var INACTIVITY_TIMEOUT_MS3 = 30 * 60 * 1e3;
 var sessions = /* @__PURE__ */ new Map();
 async function handlePtySpawn(payload, client) {
@@ -12882,6 +12885,7 @@ async function handlePtySpawn(payload, client) {
     return;
   }
   console.log(`[PTY] Spawning PTY for ${moduleUid} / ${agent_run_id}: ${command} ${args.join(" ")}`);
+  const bootstrap = createCredentialBootstrap(payload, agent_run_id);
   let proc;
   try {
     proc = pty.spawn(command, args, {
@@ -12889,9 +12893,14 @@ async function handlePtySpawn(payload, client) {
       cols,
       rows,
       cwd: cwd || process.cwd(),
-      env: { ...process.env, ...env || {} }
+      env: {
+        ...process.env,
+        ...env || {},
+        ...bootstrap.env
+      }
     });
   } catch (err) {
+    cleanupCredentialDirs(bootstrap.cleanupDirs);
     console.error(`[PTY] Failed to spawn PTY for ${agent_run_id}:`, err);
     await client.send({
       type: "pty_exit",
@@ -12908,7 +12917,8 @@ async function handlePtySpawn(payload, client) {
     agent_run_id,
     startedAt: Date.now(),
     lastOutputAt: Date.now(),
-    watchdogTimer: null
+    watchdogTimer: null,
+    credentialDirs: bootstrap.cleanupDirs
   };
   sessions.set(agent_run_id, session);
   const resetWatchdog = () => {
@@ -12942,6 +12952,7 @@ async function handlePtySpawn(payload, client) {
     if (session.watchdogTimer) clearTimeout(session.watchdogTimer);
     console.log(`[PTY] Process exited for ${agent_run_id} with code ${exitCode} after ${durationMs}ms`);
     sessions.delete(agent_run_id);
+    cleanupCredentialDirs(session.credentialDirs);
     client.send({
       type: "pty_exit",
       moduleUid,
@@ -12977,15 +12988,67 @@ function handlePtyKill(payload) {
     session.pty.kill();
   } catch {
   }
+  cleanupCredentialDirs(session.credentialDirs);
   sessions.delete(agent_run_id);
   console.log(`[PTY] Killed session ${agent_run_id}`);
 }
+function createCredentialBootstrap(payload, agentRunId) {
+  const bootstrap = payload.credential_bootstrap;
+  if (!bootstrap?.oauth?.access_token) {
+    return { env: {}, cleanupDirs: [] };
+  }
+  const baseDir = fs30.mkdtempSync(path30.join(os14.tmpdir(), `episoda-pty-${agentRunId}-`));
+  const cleanupDirs = [baseDir];
+  if (bootstrap.provider === "claude") {
+    const claudeConfigDir = path30.join(baseDir, ".claude");
+    fs30.mkdirSync(claudeConfigDir, { recursive: true });
+    const credentialsPath = path30.join(claudeConfigDir, ".credentials.json");
+    const claudeAiOauth = {
+      accessToken: bootstrap.oauth.access_token
+    };
+    if (bootstrap.oauth.refresh_token) claudeAiOauth.refreshToken = bootstrap.oauth.refresh_token;
+    if (bootstrap.oauth.expires_at) claudeAiOauth.expiresAt = new Date(bootstrap.oauth.expires_at).getTime();
+    if (bootstrap.oauth.scopes) claudeAiOauth.scopes = bootstrap.oauth.scopes;
+    fs30.writeFileSync(credentialsPath, JSON.stringify({ claudeAiOauth }, null, 2), { mode: 384 });
+    return {
+      env: { CLAUDE_CONFIG_DIR: claudeConfigDir },
+      cleanupDirs
+    };
+  }
+  const codexHome = path30.join(baseDir, ".codex");
+  fs30.mkdirSync(codexHome, { recursive: true });
+  const authPath = path30.join(codexHome, "auth.json");
+  const authPayload = {
+    tokens: {
+      access_token: bootstrap.oauth.access_token,
+      refresh_token: bootstrap.oauth.refresh_token,
+      id_token: bootstrap.oauth.id_token,
+      account_id: bootstrap.oauth.account_id
+    }
+  };
+  fs30.writeFileSync(authPath, JSON.stringify(authPayload, null, 2), { mode: 384 });
+  return {
+    env: { CODEX_HOME: codexHome },
+    cleanupDirs
+  };
+}
+function cleanupCredentialDirs(dirs) {
+  for (const dirPath of dirs) {
+    try {
+      if (fs30.existsSync(dirPath)) {
+        fs30.rmSync(dirPath, { recursive: true, force: true });
+      }
+    } catch (error) {
+      console.warn(`[PTY] Failed to cleanup credential dir ${dirPath}:`, error);
+    }
+  }
+}
 
 // src/utils/dev-server.ts
 var import_child_process15 = require("child_process");
 var import_core14 = __toESM(require_dist());
-var fs30 = __toESM(require("fs"));
-var path30 = __toESM(require("path"));
+var fs31 = __toESM(require("fs"));
+var path31 = __toESM(require("path"));
 var MAX_RESTART_ATTEMPTS = 5;
 var INITIAL_RESTART_DELAY_MS = 2e3;
 var MAX_RESTART_DELAY_MS = 3e4;
@@ -12993,26 +13056,26 @@ var MAX_LOG_SIZE_BYTES2 = 5 * 1024 * 1024;
 var NODE_MEMORY_LIMIT_MB = 2048;
 var activeServers = /* @__PURE__ */ new Map();
 function getLogsDir() {
-  const logsDir = path30.join((0, import_core14.getConfigDir)(), "logs");
-  if (!fs30.existsSync(logsDir)) {
-    fs30.mkdirSync(logsDir, { recursive: true });
+  const logsDir = path31.join((0, import_core14.getConfigDir)(), "logs");
+  if (!fs31.existsSync(logsDir)) {
+    fs31.mkdirSync(logsDir, { recursive: true });
   }
   return logsDir;
 }
 function getLogFilePath(moduleUid) {
-  return path30.join(getLogsDir(), `dev-${moduleUid}.log`);
+  return path31.join(getLogsDir(), `dev-${moduleUid}.log`);
 }
 function rotateLogIfNeeded(logPath) {
   try {
-    if (fs30.existsSync(logPath)) {
-      const stats = fs30.statSync(logPath);
+    if (fs31.existsSync(logPath)) {
+      const stats = fs31.statSync(logPath);
       if (stats.size > MAX_LOG_SIZE_BYTES2) {
         const backupPath = `${logPath}.1`;
-        if (fs30.existsSync(backupPath)) {
-          fs30.unlinkSync(backupPath);
+        if (fs31.existsSync(backupPath)) {
+          fs31.unlinkSync(backupPath);
         }
-        fs30.renameSync(logPath, backupPath);
-        console.log(`[DevServer] EP932: Rotated log file for ${path30.basename(logPath)}`);
+        fs31.renameSync(logPath, backupPath);
+        console.log(`[DevServer] EP932: Rotated log file for ${path31.basename(logPath)}`);
       }
     }
   } catch (error) {
@@ -13025,7 +13088,7 @@ function writeToLog(logPath, line, isError = false) {
     const prefix = isError ? "ERR" : "OUT";
     const logLine = `[${timestamp}] [${prefix}] ${line}
 `;
-    fs30.appendFileSync(logPath, logLine);
+    fs31.appendFileSync(logPath, logLine);
   } catch {
   }
 }
@@ -13204,8 +13267,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 = path30.join(projectPath, ".env");
-      if (!fs30.existsSync(envFilePath) && Object.keys(injectedEnvVars).length > 0) {
+      const envFilePath = path31.join(projectPath, ".env");
+      if (!fs31.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);
       }
@@ -13343,9 +13406,9 @@ var IPCRouter = class {
         // EP726: Kept for backward compatibility
         machineName: this.host.deviceName,
         // EP1186: User-friendly machine name from server
-        hostname: os14.hostname(),
-        platform: os14.platform(),
-        arch: os14.arch(),
+        hostname: os15.hostname(),
+        platform: os15.platform(),
+        arch: os15.arch(),
         projects
       };
     });
@@ -13547,8 +13610,8 @@ var IPCRouter = class {
 };
 
 // src/daemon/update-manager.ts
-var fs31 = __toESM(require("fs"));
-var path31 = __toESM(require("path"));
+var fs32 = __toESM(require("fs"));
+var path32 = __toESM(require("path"));
 var import_child_process17 = require("child_process");
 var import_core17 = __toESM(require_dist());
 var semver2 = __toESM(require("semver"));
@@ -13806,8 +13869,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 = path31.join(configDir, "daemon.log");
-      const logFd = fs31.openSync(logPath, "a");
+      const logPath = path32.join(configDir, "daemon.log");
+      const logFd = fs32.openSync(logPath, "a");
       const child = (0, import_child_process17.spawn)("node", [this.daemonEntryFile], {
         detached: true,
         stdio: ["ignore", logFd, logFd],
@@ -13817,7 +13880,7 @@ var UpdateManager = class _UpdateManager {
       });
       if (!child.pid) {
         try {
-          fs31.closeSync(logFd);
+          fs32.closeSync(logFd);
         } catch {
         }
         this.recordUpdateFailure(targetVersion, "Failed to spawn replacement daemon (missing pid)");
@@ -13825,7 +13888,7 @@ var UpdateManager = class _UpdateManager {
       }
       child.unref();
       const pidPath = getPidFilePath();
-      fs31.writeFileSync(pidPath, child.pid.toString(), "utf-8");
+      fs32.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) {
@@ -13876,8 +13939,8 @@ var UpdateManager = class _UpdateManager {
 };
 
 // src/daemon/health-orchestrator.ts
-var fs32 = __toESM(require("fs"));
-var path32 = __toESM(require("path"));
+var fs33 = __toESM(require("fs"));
+var path33 = __toESM(require("path"));
 var import_core18 = __toESM(require_dist());
 var HealthOrchestrator = class _HealthOrchestrator {
   constructor(host) {
@@ -14137,26 +14200,26 @@ var HealthOrchestrator = class _HealthOrchestrator {
   checkAndRotateLog() {
     try {
       const configDir = (0, import_core18.getConfigDir)();
-      const logPath = path32.join(configDir, "daemon.log");
-      if (!fs32.existsSync(logPath)) return;
-      const stats = fs32.statSync(logPath);
+      const logPath = path33.join(configDir, "daemon.log");
+      if (!fs33.existsSync(logPath)) return;
+      const stats = fs33.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 (fs32.existsSync(src)) {
+        if (fs33.existsSync(src)) {
           try {
-            fs32.renameSync(src, dst);
+            fs33.renameSync(src, dst);
           } catch {
           }
         }
       }
       try {
-        fs32.copyFileSync(logPath, `${logPath}.1`);
+        fs33.copyFileSync(logPath, `${logPath}.1`);
       } catch {
       }
-      fs32.truncateSync(logPath, 0);
+      fs33.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);
@@ -14205,9 +14268,9 @@ var HealthOrchestrator = class _HealthOrchestrator {
           if (Number.isFinite(lastAccessedMs)) {
             referenceTimestampMs = lastAccessedMs;
             fallbackAgeSource.push(`${w.moduleUid}(lastAccessed)`);
-          } else if (w.worktreePath && fs32.existsSync(w.worktreePath)) {
+          } else if (w.worktreePath && fs33.existsSync(w.worktreePath)) {
             try {
-              const stats = fs32.statSync(w.worktreePath);
+              const stats = fs33.statSync(w.worktreePath);
               referenceTimestampMs = stats.mtimeMs;
               fallbackAgeSource.push(`${w.moduleUid}(fs.mtime)`);
             } catch {
@@ -14753,7 +14816,7 @@ function resolveDaemonWsEndpoint(config, env = process.env) {
 
 // src/daemon/project-message-router.ts
 var import_core19 = __toESM(require_dist());
-var path33 = __toESM(require("path"));
+var path34 = __toESM(require("path"));
 var ProjectMessageRouter = class {
   constructor(host) {
     this.host = host;
@@ -14771,7 +14834,7 @@ var ProjectMessageRouter = class {
         client.updateActivity();
         try {
           const gitCmd = message.command;
-          const bareRepoPath = path33.join(projectPath, ".bare");
+          const bareRepoPath = path34.join(projectPath, ".bare");
           const cwd = gitCmd.worktreePath || bareRepoPath;
           if (gitCmd.worktreePath) {
             console.log(`[Daemon] Routing command to worktree: ${gitCmd.worktreePath}`);
@@ -15145,32 +15208,32 @@ async function fetchEnvVars2(projectId) {
 }
 
 // src/daemon/project-git-config.ts
-var fs33 = __toESM(require("fs"));
-var path34 = __toESM(require("path"));
+var fs34 = __toESM(require("fs"));
+var path35 = __toESM(require("path"));
 var import_core21 = __toESM(require_dist());
 function getGitDirs(projectPath) {
-  const bareDir = path34.join(projectPath, ".bare");
-  const gitPath = path34.join(projectPath, ".git");
-  if (fs33.existsSync(bareDir) && fs33.statSync(bareDir).isDirectory()) {
+  const bareDir = path35.join(projectPath, ".bare");
+  const gitPath = path35.join(projectPath, ".git");
+  if (fs34.existsSync(bareDir) && fs34.statSync(bareDir).isDirectory()) {
     return { gitDir: bareDir, workDir: projectPath };
   }
-  if (fs33.existsSync(gitPath) && fs33.statSync(gitPath).isDirectory()) {
+  if (fs34.existsSync(gitPath) && fs34.statSync(gitPath).isDirectory()) {
     return { gitDir: null, workDir: projectPath };
   }
-  if (fs33.existsSync(gitPath) && fs33.statSync(gitPath).isFile()) {
+  if (fs34.existsSync(gitPath) && fs34.statSync(gitPath).isFile()) {
     return { gitDir: null, workDir: projectPath };
   }
-  const entries = fs33.readdirSync(projectPath, { withFileTypes: true });
+  const entries = fs34.readdirSync(projectPath, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory() && entry.name.startsWith("EP")) {
-      const worktreePath = path34.join(projectPath, entry.name);
-      const worktreeGit = path34.join(worktreePath, ".git");
-      if (fs33.existsSync(worktreeGit)) {
+      const worktreePath = path35.join(projectPath, entry.name);
+      const worktreeGit = path35.join(worktreePath, ".git");
+      if (fs34.existsSync(worktreeGit)) {
         return { gitDir: null, workDir: worktreePath };
       }
     }
   }
-  if (fs33.existsSync(bareDir)) {
+  if (fs34.existsSync(bareDir)) {
     return { gitDir: bareDir, workDir: projectPath };
   }
   return { gitDir: null, workDir: projectPath };
@@ -15215,24 +15278,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 = path34.join(projectPath, ".bare", "hooks");
-  const gitHooksDir = path34.join(projectPath, ".git", "hooks");
-  if (fs33.existsSync(bareHooksDir)) {
+  const bareHooksDir = path35.join(projectPath, ".bare", "hooks");
+  const gitHooksDir = path35.join(projectPath, ".git", "hooks");
+  if (fs34.existsSync(bareHooksDir)) {
     hooksDir = bareHooksDir;
-  } else if (fs33.existsSync(gitHooksDir) && fs33.statSync(path34.join(projectPath, ".git")).isDirectory()) {
+  } else if (fs34.existsSync(gitHooksDir) && fs34.statSync(path35.join(projectPath, ".git")).isDirectory()) {
     hooksDir = gitHooksDir;
   } else {
-    const parentBareHooks = path34.join(projectPath, "..", ".bare", "hooks");
-    if (fs33.existsSync(parentBareHooks)) {
+    const parentBareHooks = path35.join(projectPath, "..", ".bare", "hooks");
+    if (fs34.existsSync(parentBareHooks)) {
       hooksDir = parentBareHooks;
     } else {
       console.warn(`[Daemon] Hooks directory not found for: ${projectPath}`);
       return;
     }
   }
-  if (!fs33.existsSync(hooksDir)) {
+  if (!fs34.existsSync(hooksDir)) {
     try {
-      fs33.mkdirSync(hooksDir, { recursive: true });
+      fs34.mkdirSync(hooksDir, { recursive: true });
     } catch {
       console.warn(`[Daemon] Hooks directory not found and could not create: ${hooksDir}`);
       return;
@@ -15240,20 +15303,20 @@ async function installGitHooks(projectPath) {
   }
   for (const hookName of hooks) {
     try {
-      const hookPath = path34.join(hooksDir, hookName);
-      const bundledHookPath = path34.join(__dirname, "..", "hooks", hookName);
-      if (!fs33.existsSync(bundledHookPath)) {
+      const hookPath = path35.join(hooksDir, hookName);
+      const bundledHookPath = path35.join(__dirname, "..", "hooks", hookName);
+      if (!fs34.existsSync(bundledHookPath)) {
         console.warn(`[Daemon] Bundled hook not found: ${bundledHookPath}`);
         continue;
       }
-      const hookContent = fs33.readFileSync(bundledHookPath, "utf-8");
-      if (fs33.existsSync(hookPath)) {
-        const existingContent = fs33.readFileSync(hookPath, "utf-8");
+      const hookContent = fs34.readFileSync(bundledHookPath, "utf-8");
+      if (fs34.existsSync(hookPath)) {
+        const existingContent = fs34.readFileSync(hookPath, "utf-8");
         if (existingContent === hookContent) {
           continue;
         }
       }
-      fs33.writeFileSync(hookPath, hookContent, { mode: 493 });
+      fs34.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);
@@ -15284,21 +15347,21 @@ async function cacheMachineUuid(machineUuid, machineId) {
 }
 
 // src/daemon/reconciliation-utils.ts
-var path35 = __toESM(require("path"));
+var path36 = __toESM(require("path"));
 function isPathUnderRoot(candidatePath, projectRoot) {
-  const relative4 = path35.relative(projectRoot, candidatePath);
-  return relative4 !== "" && !relative4.startsWith("..") && !path35.isAbsolute(relative4);
+  const relative4 = path36.relative(projectRoot, candidatePath);
+  return relative4 !== "" && !relative4.startsWith("..") && !path36.isAbsolute(relative4);
 }
 function collectUnexpectedWorktrees(params) {
-  const projectRootResolved = path35.resolve(params.projectRoot);
-  const bareRepoPathResolved = path35.resolve(params.bareRepoPath);
+  const projectRootResolved = path36.resolve(params.projectRoot);
+  const bareRepoPathResolved = path36.resolve(params.bareRepoPath);
   const unexpectedWorktrees = [];
   for (const worktree of params.worktrees) {
-    const worktreePathResolved = path35.resolve(worktree.path);
+    const worktreePathResolved = path36.resolve(worktree.path);
     if (worktreePathResolved === bareRepoPathResolved) continue;
     if (worktree.prunable || worktree.locked) continue;
     if (!isPathUnderRoot(worktreePathResolved, projectRootResolved)) continue;
-    const moduleUid = path35.basename(worktreePathResolved);
+    const moduleUid = path36.basename(worktreePathResolved);
     if (!validateModuleUid(moduleUid)) continue;
     if (!/^EP\d+$/.test(moduleUid)) continue;
     if (params.expectedModuleUids.has(moduleUid)) continue;
@@ -15515,9 +15578,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(([path37, conn]) => ({
-            path: path37,
-            connected: this.connectionManager.hasLiveConnection(path37)
+          const projects = Array.from(this.connectionManager.entries()).map(([path38, conn]) => ({
+            path: path38,
+            connected: this.connectionManager.hasLiveConnection(path38)
           }));
           const status = {
             status: isConnected ? "healthy" : "degraded",
@@ -15590,8 +15653,8 @@ var Daemon = class _Daemon {
     await this.shutdown();
     try {
       const pidPath = getPidFilePath();
-      if (fs34.existsSync(pidPath)) {
-        fs34.unlinkSync(pidPath);
+      if (fs35.existsSync(pidPath)) {
+        fs35.unlinkSync(pidPath);
         console.log("[Daemon] PID file cleaned up (watchdog)");
       }
     } catch (error) {
@@ -16269,8 +16332,8 @@ var Daemon = class _Daemon {
       let daemonPid;
       try {
         const pidPath = getPidFilePath();
-        if (fs34.existsSync(pidPath)) {
-          const pidStr = fs34.readFileSync(pidPath, "utf-8").trim();
+        if (fs35.existsSync(pidPath)) {
+          const pidStr = fs35.readFileSync(pidPath, "utf-8").trim();
           daemonPid = parseInt(pidStr, 10);
         }
       } catch (pidError) {
@@ -16281,9 +16344,9 @@ var Daemon = class _Daemon {
       const containerId = process.env.EPISODA_CONTAINER_ID;
       const capabilities = ["worktree_create_v1"];
       await client.connect(wsEndpoint.wsUrl, config.access_token, this.machineId, {
-        hostname: os15.hostname(),
-        osPlatform: os15.platform(),
-        osArch: os15.arch(),
+        hostname: os16.hostname(),
+        osPlatform: os16.platform(),
+        osArch: os16.arch(),
         daemonPid,
         cliVersion: this.cliRuntimeVersion,
         cliPackageName: packageJson.name,
@@ -16520,7 +16583,7 @@ var Daemon = class _Daemon {
       await tunnelManager.initialize();
       const moduleStatuses = [];
       const expectedModuleUids = new Set(modules.map((m) => m.uid));
-      const bareRepoPath = path36.join(projectPath, ".bare");
+      const bareRepoPath = path37.join(projectPath, ".bare");
       for (const mod of modules) {
         const moduleUid = mod.uid;
         const worktree = await getWorktreeInfoForModule(moduleUid);
@@ -16963,8 +17026,8 @@ var Daemon = class _Daemon {
     await this.shutdown();
     try {
       const pidPath = getPidFilePath();
-      if (fs34.existsSync(pidPath)) {
-        fs34.unlinkSync(pidPath);
+      if (fs35.existsSync(pidPath)) {
+        fs35.unlinkSync(pidPath);
         console.log("[Daemon] PID file cleaned up");
       }
     } catch (error) {