@episoda/cli 0.2.187 → 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 path35 = 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 = path35.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 path35 = 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 = path35.join(currentPath, ".bare");
-            const episodaDir = path35.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 = path35.dirname(currentPath);
+              const parentPath = path38.dirname(currentPath);
               if (parentPath === currentPath) {
                 break;
               }
@@ -2236,7 +2236,7 @@ var require_websocket_client = __commonJS({
           clearTimeout(this.reconnectTimeout);
           this.reconnectTimeout = void 0;
         }
-        return new Promise((resolve7, reject) => {
+        return new Promise((resolve8, reject) => {
           const connectionTimeout = setTimeout(() => {
             if (this.ws) {
               this.ws.terminate();
@@ -2267,7 +2267,7 @@ var require_websocket_client = __commonJS({
                 daemonPid: this.daemonPid
               });
               this.startHeartbeat();
-              resolve7();
+              resolve8();
             });
             this.ws.on("pong", () => {
               if (this.heartbeatTimeoutTimer) {
@@ -2411,13 +2411,13 @@ var require_websocket_client = __commonJS({
           console.warn("[EpisodaClient] Cannot send - WebSocket not connected");
           return false;
         }
-        return new Promise((resolve7) => {
+        return new Promise((resolve8) => {
           this.ws.send(JSON.stringify(message), (error) => {
             if (error) {
               console.error("[EpisodaClient] Failed to send message:", error);
-              resolve7(false);
+              resolve8(false);
             } else {
-              resolve7(true);
+              resolve8(true);
             }
           });
         });
@@ -2724,33 +2724,33 @@ var require_auth = __commonJS({
     exports2.loadConfig = loadConfig16;
     exports2.saveConfig = saveConfig4;
     exports2.validateToken = validateToken;
-    var fs35 = __importStar(require("fs"));
-    var path35 = __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 || path35.join(os16.homedir(), ".episoda");
+      return process.env.EPISODA_CONFIG_DIR || path38.join(os17.homedir(), ".episoda");
     }
     function getConfigPath(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path35.join(getConfigDir10(), DEFAULT_CONFIG_FILE);
+      return path38.join(getConfigDir10(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path35.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 = path35.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.187",
+      version: "0.2.190",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -3362,10 +3362,10 @@ var IPCServer = class {
     this.server = net.createServer((socket) => {
       this.handleConnection(socket);
     });
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve8, reject) => {
       this.server.listen(socketPath, () => {
         fs3.chmodSync(socketPath, 384);
-        resolve7();
+        resolve8();
       });
       this.server.on("error", reject);
     });
@@ -3376,12 +3376,12 @@ var IPCServer = class {
   async stop() {
     if (!this.server) return;
     const socketPath = getSocketPath();
-    return new Promise((resolve7) => {
+    return new Promise((resolve8) => {
       this.server.close(() => {
         if (fs3.existsSync(socketPath)) {
           fs3.unlinkSync(socketPath);
         }
-        resolve7();
+        resolve8();
       });
     });
   }
@@ -3626,7 +3626,7 @@ function getDownloadUrl() {
   return platformUrls[arch4] || null;
 }
 async function downloadFile(url, destPath) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const followRedirect = (currentUrl, redirectCount = 0) => {
       if (redirectCount > 5) {
         reject(new Error("Too many redirects"));
@@ -3656,7 +3656,7 @@ async function downloadFile(url, destPath) {
         response.pipe(file);
         file.on("finish", () => {
           file.close();
-          resolve7();
+          resolve8();
         });
         file.on("error", (err) => {
           fs4.unlinkSync(destPath);
@@ -4070,10 +4070,10 @@ var TunnelManager = class extends import_events.EventEmitter {
       const isTracked = Array.from(this.tunnelStates.values()).some((s) => s.info.pid === pid);
       console.log(`[Tunnel] EP904: Found cloudflared PID ${pid} on port ${port} (tracked: ${isTracked})`);
       this.killByPid(pid, "SIGTERM");
-      await new Promise((resolve7) => setTimeout(resolve7, 500));
+      await new Promise((resolve8) => setTimeout(resolve8, 500));
       if (this.isProcessRunning(pid)) {
         this.killByPid(pid, "SIGKILL");
-        await new Promise((resolve7) => setTimeout(resolve7, 200));
+        await new Promise((resolve8) => setTimeout(resolve8, 200));
       }
       killed.push(pid);
     }
@@ -4107,7 +4107,7 @@ var TunnelManager = class extends import_events.EventEmitter {
           if (!this.tunnelStates.has(moduleUid)) {
             console.log(`[Tunnel] EP877: Found orphaned process PID ${pid} for ${moduleUid}, killing...`);
             this.killByPid(pid, "SIGTERM");
-            await new Promise((resolve7) => setTimeout(resolve7, 1e3));
+            await new Promise((resolve8) => setTimeout(resolve8, 1e3));
             if (this.isProcessRunning(pid)) {
               this.killByPid(pid, "SIGKILL");
             }
@@ -4122,7 +4122,7 @@ var TunnelManager = class extends import_events.EventEmitter {
         if (!trackedPids.includes(pid) && !cleaned.includes(pid)) {
           console.log(`[Tunnel] EP877: Found untracked cloudflared process PID ${pid}, killing...`);
           this.killByPid(pid, "SIGTERM");
-          await new Promise((resolve7) => setTimeout(resolve7, 500));
+          await new Promise((resolve8) => setTimeout(resolve8, 500));
           if (this.isProcessRunning(pid)) {
             this.killByPid(pid, "SIGKILL");
           }
@@ -4212,7 +4212,7 @@ var TunnelManager = class extends import_events.EventEmitter {
         return { success: false, error: `Failed to get cloudflared: ${errorMessage}` };
       }
     }
-    return new Promise((resolve7) => {
+    return new Promise((resolve8) => {
       const tunnelInfo = {
         moduleUid,
         url: previewUrl || "",
@@ -4278,7 +4278,7 @@ var TunnelManager = class extends import_events.EventEmitter {
             moduleUid,
             url: tunnelInfo.url
           });
-          resolve7({ success: true, url: tunnelInfo.url });
+          resolve8({ success: true, url: tunnelInfo.url });
         }
       };
       process2.stderr?.on("data", (data) => {
@@ -4305,7 +4305,7 @@ var TunnelManager = class extends import_events.EventEmitter {
             onStatusChange?.("error", errorMsg);
             this.emitEvent({ type: "error", moduleUid, error: errorMsg });
           }
-          resolve7({ success: false, error: errorMsg });
+          resolve8({ success: false, error: errorMsg });
         } else if (wasConnected) {
           if (currentState && !currentState.intentionallyStopped) {
             console.log(`[Tunnel] EP948: Named tunnel ${moduleUid} crashed unexpectedly, attempting reconnect...`);
@@ -4336,7 +4336,7 @@ var TunnelManager = class extends import_events.EventEmitter {
           this.emitEvent({ type: "error", moduleUid, error: error.message });
         }
         if (!connected) {
-          resolve7({ success: false, error: error.message });
+          resolve8({ success: false, error: error.message });
         }
       });
       setTimeout(() => {
@@ -4359,7 +4359,7 @@ var TunnelManager = class extends import_events.EventEmitter {
             onStatusChange?.("error", errorMsg);
             this.emitEvent({ type: "error", moduleUid, error: errorMsg });
           }
-          resolve7({ success: false, error: errorMsg });
+          resolve8({ success: false, error: errorMsg });
         }
       }, TUNNEL_TIMEOUTS.NAMED_TUNNEL_CONNECT);
     });
@@ -4420,7 +4420,7 @@ var TunnelManager = class extends import_events.EventEmitter {
     if (orphanPid && this.isProcessRunning(orphanPid)) {
       console.log(`[Tunnel] EP877: Killing orphaned process ${orphanPid} for ${moduleUid} before starting new tunnel`);
       this.killByPid(orphanPid, "SIGTERM");
-      await new Promise((resolve7) => setTimeout(resolve7, 500));
+      await new Promise((resolve8) => setTimeout(resolve8, 500));
       if (this.isProcessRunning(orphanPid)) {
         this.killByPid(orphanPid, "SIGKILL");
       }
@@ -4429,7 +4429,7 @@ var TunnelManager = class extends import_events.EventEmitter {
     const killedOnPort = await this.killCloudflaredOnPort(port);
     if (killedOnPort.length > 0) {
       console.log(`[Tunnel] EP904: Pre-start port cleanup killed ${killedOnPort.length} process(es) on port ${port}`);
-      await new Promise((resolve7) => setTimeout(resolve7, 1e3));
+      await new Promise((resolve8) => setTimeout(resolve8, 1e3));
     }
     const cleanup = await this.cleanupOrphanedProcesses();
     if (cleanup.cleaned > 0) {
@@ -4469,7 +4469,7 @@ var TunnelManager = class extends import_events.EventEmitter {
       if (orphanPid && this.isProcessRunning(orphanPid)) {
         console.log(`[Tunnel] EP877: Stopping orphaned process ${orphanPid} for ${moduleUid} via PID file`);
         this.killByPid(orphanPid, "SIGTERM");
-        await new Promise((resolve7) => setTimeout(resolve7, 1e3));
+        await new Promise((resolve8) => setTimeout(resolve8, 1e3));
         if (this.isProcessRunning(orphanPid)) {
           this.killByPid(orphanPid, "SIGKILL");
         }
@@ -4485,16 +4485,16 @@ var TunnelManager = class extends import_events.EventEmitter {
     const tunnel = state.info;
     if (tunnel.process && !tunnel.process.killed) {
       tunnel.process.kill("SIGTERM");
-      await new Promise((resolve7) => {
+      await new Promise((resolve8) => {
         const timeout = setTimeout(() => {
           if (tunnel.process && !tunnel.process.killed) {
             tunnel.process.kill("SIGKILL");
           }
-          resolve7();
+          resolve8();
         }, 3e3);
         tunnel.process.once("exit", () => {
           clearTimeout(timeout);
-          resolve7();
+          resolve8();
         });
       });
     }
@@ -4781,15 +4781,15 @@ async function writeToStdinWithBackpressure(process2, data, drainTimeoutMs, labe
   if (!stdin || stdin.destroyed) {
     throw new Error(`[${label}] stdin not available. session=${sessionId}`);
   }
-  await new Promise((resolve7, reject) => {
+  await new Promise((resolve8, reject) => {
     const ok = stdin.write(data);
     if (ok) {
-      resolve7();
+      resolve8();
       return;
     }
     const onDrain = () => {
       cleanup();
-      resolve7();
+      resolve8();
     };
     const onError = (err) => {
       cleanup();
@@ -4810,18 +4810,18 @@ async function writeToStdinWithBackpressure(process2, data, drainTimeoutMs, labe
   });
 }
 function waitForProcessExit(process2, alive, timeoutMs) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     if (!process2 || !alive) {
-      resolve7(true);
+      resolve8(true);
       return;
     }
     const onExit = () => {
       clearTimeout(timer);
-      resolve7(true);
+      resolve8(true);
     };
     const timer = setTimeout(() => {
       process2.removeListener("exit", onExit);
-      resolve7(false);
+      resolve8(false);
     }, timeoutMs);
     process2.once("exit", onExit);
   });
@@ -5817,10 +5817,10 @@ var CodexPersistentRuntime = class {
   }
   waitForThreadId(timeoutMs) {
     if (this._agentSessionId) return Promise.resolve(this._agentSessionId);
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve8, reject) => {
       const onId = (id) => {
         clearTimeout(timer);
-        resolve7(id);
+        resolve8(id);
       };
       const timer = setTimeout(() => {
         this.threadIdWaiters = this.threadIdWaiters.filter((w) => w !== onId);
@@ -5851,12 +5851,12 @@ var CodexPersistentRuntime = class {
   sendRequest(method, params, timeoutMs = INIT_TIMEOUT_MS) {
     const id = this.nextId++;
     const msg = { jsonrpc: "2.0", id, method, params };
-    return new Promise(async (resolve7, reject) => {
+    return new Promise(async (resolve8, reject) => {
       const timeout = setTimeout(() => {
         this.pending.delete(id);
         reject(new Error(`JSON-RPC timeout: ${method}`));
       }, timeoutMs);
-      this.pending.set(id, { resolve: resolve7, reject, timeout });
+      this.pending.set(id, { resolve: resolve8, reject, timeout });
       try {
         await this.writeToStdin(JSON.stringify(msg) + "\n");
       } catch (err) {
@@ -6006,11 +6006,11 @@ var UnifiedAgentRuntime = class {
     if (!this.currentTurn && this.impl.turnState === "idle") {
       return this.dispatchTurn(message, callbacks);
     }
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve8, reject) => {
       this.queuedTurns.push({
         message,
         callbacks,
-        resolve: resolve7,
+        resolve: resolve8,
         reject
       });
     });
@@ -7523,13 +7523,13 @@ async function getChildProcessRssMb(pid) {
   if (!pid || pid <= 0) return null;
   try {
     if (typeof import_child_process9.execFile !== "function") return null;
-    const stdout = await new Promise((resolve7, reject) => {
+    const stdout = await new Promise((resolve8, reject) => {
       (0, import_child_process9.execFile)("ps", ["-o", "rss=", "-p", String(pid)], { timeout: 1e3 }, (err, out) => {
         if (err) {
           reject(err);
           return;
         }
-        resolve7(String(out));
+        resolve8(String(out));
       });
     });
     const kb = Number(String(stdout).trim());
@@ -7632,8 +7632,8 @@ var AgentControlPlane = class {
   async withConfigLock(fn) {
     const previousLock = this.configWriteLock;
     let releaseLock;
-    this.configWriteLock = new Promise((resolve7) => {
-      releaseLock = resolve7;
+    this.configWriteLock = new Promise((resolve8) => {
+      releaseLock = resolve8;
     });
     try {
       await previousLock;
@@ -8862,7 +8862,7 @@ var WorktreeManager = class _WorktreeManager {
                 const lockContent = fs14.readFileSync(lockPath, "utf-8").trim();
                 const lockPid = parseInt(lockContent, 10);
                 if (!isNaN(lockPid) && this.isProcessRunning(lockPid)) {
-                  await new Promise((resolve7) => setTimeout(resolve7, retryInterval));
+                  await new Promise((resolve8) => setTimeout(resolve8, retryInterval));
                   continue;
                 }
               } catch {
@@ -8876,7 +8876,7 @@ var WorktreeManager = class _WorktreeManager {
           } catch {
             continue;
           }
-          await new Promise((resolve7) => setTimeout(resolve7, retryInterval));
+          await new Promise((resolve8) => setTimeout(resolve8, retryInterval));
           continue;
         }
         throw err;
@@ -9663,13 +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 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
@@ -10400,7 +10401,7 @@ async function handleExec(command, projectPath) {
     env = {}
   } = command;
   const effectiveTimeout = Math.min(Math.max(timeout, 1e3), MAX_TIMEOUT);
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     let stdout = "";
     let stderr = "";
     let timedOut = false;
@@ -10408,7 +10409,7 @@ async function handleExec(command, projectPath) {
     const done = (result) => {
       if (resolved) return;
       resolved = true;
-      resolve7(result);
+      resolve8(result);
     };
     try {
       const proc = (0, import_child_process11.spawn)(cmd, {
@@ -10512,18 +10513,18 @@ var import_core12 = __toESM(require_dist());
 // src/utils/port-check.ts
 var net2 = __toESM(require("net"));
 async function isPortInUse(port) {
-  return new Promise((resolve7) => {
+  return new Promise((resolve8) => {
     const server = net2.createServer();
     server.once("error", (err) => {
       if (err.code === "EADDRINUSE") {
-        resolve7(true);
+        resolve8(true);
       } else {
-        resolve7(false);
+        resolve8(false);
       }
     });
     server.once("listening", () => {
       server.close();
-      resolve7(false);
+      resolve8(false);
     });
     server.listen(port);
   });
@@ -10926,7 +10927,7 @@ var DevServerRegistry = class {
     return killed;
   }
   wait(ms) {
-    return new Promise((resolve7) => setTimeout(resolve7, ms));
+    return new Promise((resolve8) => setTimeout(resolve8, ms));
   }
   killWsServerOnPort(wsPort, worktreePath) {
     const killed = [];
@@ -11500,7 +11501,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
     return Math.min(delay, DEV_SERVER_CONSTANTS.MAX_RESTART_DELAY_MS);
   }
   async checkHealth(port) {
-    return new Promise((resolve7) => {
+    return new Promise((resolve8) => {
       const req = http.request(
         {
           hostname: "localhost",
@@ -11509,18 +11510,18 @@ var DevServerRunner = class extends import_events2.EventEmitter {
           method: "HEAD",
           timeout: DEV_SERVER_CONSTANTS.HEALTH_CHECK_TIMEOUT_MS
         },
-        () => resolve7(true)
+        () => resolve8(true)
       );
-      req.on("error", () => resolve7(false));
+      req.on("error", () => resolve8(false));
       req.on("timeout", () => {
         req.destroy();
-        resolve7(false);
+        resolve8(false);
       });
       req.end();
     });
   }
   async checkWsHealth(wsPort) {
-    return new Promise((resolve7) => {
+    return new Promise((resolve8) => {
       const req = http.request(
         {
           hostname: "127.0.0.1",
@@ -11530,14 +11531,14 @@ var DevServerRunner = class extends import_events2.EventEmitter {
           timeout: DEV_SERVER_CONSTANTS.HEALTH_CHECK_TIMEOUT_MS
         },
         (res) => {
-          resolve7(res.statusCode === 200);
+          resolve8(res.statusCode === 200);
           res.resume();
         }
       );
-      req.on("error", () => resolve7(false));
+      req.on("error", () => resolve8(false));
       req.on("timeout", () => {
         req.destroy();
-        resolve7(false);
+        resolve8(false);
       });
       req.end();
     });
@@ -11565,7 +11566,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
     return false;
   }
   wait(ms) {
-    return new Promise((resolve7) => setTimeout(resolve7, ms));
+    return new Promise((resolve8) => setTimeout(resolve8, ms));
   }
   getLogsDir() {
     const logsDir = path25.join((0, import_core12.getConfigDir)(), "logs");
@@ -11764,7 +11765,7 @@ var PreviewManager = class extends import_events3.EventEmitter {
       for (let attempt = 1; attempt <= MAX_TUNNEL_RETRIES; attempt++) {
         if (attempt > 1) {
           console.log(`[PreviewManager] Retrying tunnel for ${moduleUid} (attempt ${attempt}/${MAX_TUNNEL_RETRIES})...`);
-          await new Promise((resolve7) => setTimeout(resolve7, 2e3));
+          await new Promise((resolve8) => setTimeout(resolve8, 2e3));
         }
         tunnelResult = await this.tunnel.startTunnel({
           moduleUid,
@@ -11896,7 +11897,7 @@ var PreviewManager = class extends import_events3.EventEmitter {
     }
     console.log(`[PreviewManager] Restarting preview for ${moduleUid}`);
     await this.stopPreview(moduleUid);
-    await new Promise((resolve7) => setTimeout(resolve7, 1e3));
+    await new Promise((resolve8) => setTimeout(resolve8, 1e3));
     return this.startPreview({
       moduleUid,
       worktreePath: state.worktreePath,
@@ -12872,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) {
@@ -12881,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, {
@@ -12888,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",
@@ -12907,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 = () => {
@@ -12941,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,
@@ -12976,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;
@@ -12992,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) {
@@ -13024,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 {
   }
 }
@@ -13044,7 +13108,7 @@ async function killProcessOnPort(port) {
       } catch {
       }
     }
-    await new Promise((resolve7) => setTimeout(resolve7, 1e3));
+    await new Promise((resolve8) => setTimeout(resolve8, 1e3));
     for (const pid of pids) {
       try {
         (0, import_child_process15.execSync)(`kill -0 ${pid} 2>/dev/null`, { encoding: "utf8" });
@@ -13053,7 +13117,7 @@ async function killProcessOnPort(port) {
       } catch {
       }
     }
-    await new Promise((resolve7) => setTimeout(resolve7, 500));
+    await new Promise((resolve8) => setTimeout(resolve8, 500));
     const stillInUse = await isPortInUse(port);
     if (stillInUse) {
       console.error(`[DevServer] EP929: Port ${port} still in use after kill attempts`);
@@ -13073,7 +13137,7 @@ async function waitForPort(port, timeoutMs = 3e4) {
     if (await isPortInUse(port)) {
       return true;
     }
-    await new Promise((resolve7) => setTimeout(resolve7, checkInterval));
+    await new Promise((resolve8) => setTimeout(resolve8, checkInterval));
   }
   return false;
 }
@@ -13145,7 +13209,7 @@ async function handleProcessExit(moduleUid, code, signal) {
   const delay = calculateRestartDelay(serverInfo.restartCount);
   console.log(`[DevServer] EP932: Restarting ${moduleUid} in ${delay}ms (attempt ${serverInfo.restartCount + 1}/${MAX_RESTART_ATTEMPTS})`);
   writeToLog(serverInfo.logFile || "", `Scheduling restart in ${delay}ms (attempt ${serverInfo.restartCount + 1})`, false);
-  await new Promise((resolve7) => setTimeout(resolve7, delay));
+  await new Promise((resolve8) => setTimeout(resolve8, delay));
   if (!activeServers.has(moduleUid)) {
     console.log(`[DevServer] EP932: Server ${moduleUid} was removed during restart delay, aborting restart`);
     return;
@@ -13203,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);
       }
@@ -13270,7 +13334,7 @@ async function stopDevServer(moduleUid) {
       writeToLog(serverInfo.logFile, `Stopping server (manual stop)`, false);
     }
     serverInfo.process.kill("SIGTERM");
-    await new Promise((resolve7) => setTimeout(resolve7, 2e3));
+    await new Promise((resolve8) => setTimeout(resolve8, 2e3));
     if (!serverInfo.process.killed) {
       serverInfo.process.kill("SIGKILL");
     }
@@ -13288,7 +13352,7 @@ async function restartDevServer(moduleUid) {
     writeToLog(logFile, `Manual restart requested`, false);
   }
   await stopDevServer(moduleUid);
-  await new Promise((resolve7) => setTimeout(resolve7, 1e3));
+  await new Promise((resolve8) => setTimeout(resolve8, 1e3));
   if (await isPortInUse(port)) {
     await killProcessOnPort(port);
   }
@@ -13342,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
       };
     });
@@ -13370,7 +13434,7 @@ var IPCRouter = class {
           if (attempt < MAX_RETRIES) {
             const delay = INITIAL_DELAY * Math.pow(2, attempt - 1);
             console.log(`[Daemon] Retrying in ${delay / 1e3}s...`);
-            await new Promise((resolve7) => setTimeout(resolve7, delay));
+            await new Promise((resolve8) => setTimeout(resolve8, delay));
             await this.host.disconnectProject(projectPath);
           }
         }
@@ -13546,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"));
@@ -13805,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],
@@ -13816,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)");
@@ -13824,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) {
@@ -13875,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) {
@@ -14136,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);
@@ -14204,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 {
@@ -14646,7 +14710,7 @@ var ConnectionManager = class {
    * handlers are removed deterministically on every exit path.
    */
   async waitForAuthentication(client, timeoutMs = 3e4) {
-    await new Promise((resolve7, reject) => {
+    await new Promise((resolve8, reject) => {
       let settled = false;
       const cleanup = () => {
         clearTimeout(timeout);
@@ -14665,7 +14729,7 @@ var ConnectionManager = class {
         if (settled) return;
         settled = true;
         cleanup();
-        resolve7();
+        resolve8();
       };
       const authErrorHandler = (message) => {
         if (settled) return;
@@ -14752,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;
@@ -14770,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}`);
@@ -15144,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 };
@@ -15214,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;
@@ -15239,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);
@@ -15282,6 +15346,36 @@ async function cacheMachineUuid(machineUuid, machineId) {
   }
 }
 
+// src/daemon/reconciliation-utils.ts
+var path36 = __toESM(require("path"));
+function isPathUnderRoot(candidatePath, projectRoot) {
+  const relative4 = path36.relative(projectRoot, candidatePath);
+  return relative4 !== "" && !relative4.startsWith("..") && !path36.isAbsolute(relative4);
+}
+function collectUnexpectedWorktrees(params) {
+  const projectRootResolved = path36.resolve(params.projectRoot);
+  const bareRepoPathResolved = path36.resolve(params.bareRepoPath);
+  const unexpectedWorktrees = [];
+  for (const worktree of params.worktrees) {
+    const worktreePathResolved = path36.resolve(worktree.path);
+    if (worktreePathResolved === bareRepoPathResolved) continue;
+    if (worktree.prunable || worktree.locked) continue;
+    if (!isPathUnderRoot(worktreePathResolved, projectRootResolved)) continue;
+    const moduleUid = path36.basename(worktreePathResolved);
+    if (!validateModuleUid(moduleUid)) continue;
+    if (!/^EP\d+$/.test(moduleUid)) continue;
+    if (params.expectedModuleUids.has(moduleUid)) continue;
+    const branch = worktree.branch || "unknown";
+    if (branch === "HEAD (detached)") continue;
+    unexpectedWorktrees.push({
+      moduleUid,
+      path: worktreePathResolved,
+      branch
+    });
+  }
+  return unexpectedWorktrees;
+}
+
 // src/daemon/daemon-process.ts
 var packageJson = require_package();
 var Daemon = class _Daemon {
@@ -15484,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(([path35, conn]) => ({
-            path: path35,
-            connected: this.connectionManager.hasLiveConnection(path35)
+          const projects = Array.from(this.connectionManager.entries()).map(([path38, conn]) => ({
+            path: path38,
+            connected: this.connectionManager.hasLiveConnection(path38)
           }));
           const status = {
             status: isConnected ? "healthy" : "degraded",
@@ -15559,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) {
@@ -15623,8 +15717,8 @@ var Daemon = class _Daemon {
       }
     }
     let releaseLock;
-    const lockPromise = new Promise((resolve7) => {
-      releaseLock = resolve7;
+    const lockPromise = new Promise((resolve8) => {
+      releaseLock = resolve8;
     });
     this.tunnelOperationLocks.set(moduleUid, lockPromise);
     try {
@@ -15670,7 +15764,7 @@ var Daemon = class _Daemon {
         const maxWait = 35e3;
         const startTime = Date.now();
         while (this.connectionManager.hasPendingConnection(projectPath) && Date.now() - startTime < maxWait) {
-          await new Promise((resolve7) => setTimeout(resolve7, 500));
+          await new Promise((resolve8) => setTimeout(resolve8, 500));
         }
         if (this.connectionManager.hasLiveConnection(projectPath)) {
           console.log(`[Daemon] Pending connection succeeded for ${projectPath}`);
@@ -16238,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) {
@@ -16250,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,
@@ -16489,6 +16583,7 @@ var Daemon = class _Daemon {
       await tunnelManager.initialize();
       const moduleStatuses = [];
       const expectedModuleUids = new Set(modules.map((m) => m.uid));
+      const bareRepoPath = path37.join(projectPath, ".bare");
       for (const mod of modules) {
         const moduleUid = mod.uid;
         const worktree = await getWorktreeInfoForModule(moduleUid);
@@ -16519,11 +16614,36 @@ var Daemon = class _Daemon {
       if (orphanTunnels.length > 0) {
         console.log(`[Daemon] EP1003: Reporting ${orphanTunnels.length} orphan tunnel(s) for server cleanup`);
       }
+      let unexpectedWorktrees;
+      try {
+        const listResult = await new import_core22.GitExecutor().execute(
+          { action: "worktree_list" },
+          { cwd: bareRepoPath }
+        );
+        if (listResult.success) {
+          const localWorktrees = listResult.details?.worktrees || [];
+          const discoveredUnexpectedWorktrees = collectUnexpectedWorktrees({
+            worktrees: localWorktrees,
+            expectedModuleUids,
+            projectRoot: projectPath,
+            bareRepoPath
+          });
+          if (discoveredUnexpectedWorktrees.length > 0) {
+            unexpectedWorktrees = discoveredUnexpectedWorktrees;
+            console.log(`[Daemon] EP1446: Reporting ${discoveredUnexpectedWorktrees.length} unexpected worktree(s) for recovery`);
+          }
+        } else {
+          console.warn("[Daemon] EP1446: Failed to list local worktrees for reconciliation");
+        }
+      } catch (error) {
+        console.warn("[Daemon] EP1446: Error while scanning local worktrees:", error instanceof Error ? error.message : error);
+      }
       const report = {
         projectId,
         machineId: this.machineUuid,
         modules: moduleStatuses,
-        orphanTunnels: orphanTunnels.length > 0 ? orphanTunnels : void 0
+        orphanTunnels: orphanTunnels.length > 0 ? orphanTunnels : void 0,
+        unexpectedWorktrees
       };
       console.log(`[Daemon] EP1003: Sending reconciliation report with ${moduleStatuses.length} module(s)`);
       await client.send({
@@ -16770,7 +16890,7 @@ var Daemon = class _Daemon {
     console.log(`[Daemon] EP1002: Worktree setup complete for ${moduleUid}`);
   }
   async runForegroundCommand(command, args, cwd, env, timeoutMs) {
-    await new Promise((resolve7, reject) => {
+    await new Promise((resolve8, reject) => {
       const commandLabel = `${command} ${args.join(" ")}`.trim();
       const child = (0, import_child_process19.spawn)(command, args, {
         cwd,
@@ -16793,7 +16913,7 @@ var Daemon = class _Daemon {
           reject(error);
           return;
         }
-        resolve7();
+        resolve8();
       };
       termTimer = setTimeout(() => {
         timedOut = true;
@@ -16906,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) {