@episoda/cli 0.2.218 → 0.2.220

package/dist/daemon/daemon-process.js

@@ -39,8 +39,9 @@ var require_command_protocol = __commonJS({
     exports2.WORKTREE_STATUS_VALUES = void 0;
     exports2.WORKTREE_STATUS_VALUES = [
       "pending",
-      "setup",
-      "ready",
+      "provisioning",
+      "verified",
+      "missing",
       "error",
       "removing"
     ];
@@ -2241,7 +2242,7 @@ var require_websocket_client = __commonJS({
           clearTimeout(this.reconnectTimeout);
           this.reconnectTimeout = void 0;
         }
-        return new Promise((resolve9, reject) => {
+        return new Promise((resolve10, reject) => {
           const connectionTimeout = setTimeout(() => {
             if (this.ws) {
               this.ws.terminate();
@@ -2272,7 +2273,7 @@ var require_websocket_client = __commonJS({
                 daemonPid: this.daemonPid
               });
               this.startHeartbeat();
-              resolve9();
+              resolve10();
             });
             this.ws.on("pong", () => {
               if (this.heartbeatTimeoutTimer) {
@@ -2416,13 +2417,13 @@ var require_websocket_client = __commonJS({
           console.warn("[EpisodaClient] Cannot send - WebSocket not connected");
           return false;
         }
-        return new Promise((resolve9) => {
+        return new Promise((resolve10) => {
           this.ws.send(JSON.stringify(message), (error) => {
             if (error) {
               console.error("[EpisodaClient] Failed to send message:", error);
-              resolve9(false);
+              resolve10(false);
             } else {
-              resolve9(true);
+              resolve10(true);
             }
           });
         });
@@ -3051,7 +3052,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@episoda/cli",
-      version: "0.2.218",
+      version: "0.2.220",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -3468,10 +3469,10 @@ var IPCServer = class {
     this.server = net.createServer((socket) => {
       this.handleConnection(socket);
     });
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       this.server.listen(socketPath, () => {
         fs4.chmodSync(socketPath, 384);
-        resolve9();
+        resolve10();
       });
       this.server.on("error", reject);
     });
@@ -3482,12 +3483,12 @@ var IPCServer = class {
   async stop() {
     if (!this.server) return;
     const socketPath = getSocketPath();
-    return new Promise((resolve9) => {
+    return new Promise((resolve10) => {
       this.server.close(() => {
         if (fs4.existsSync(socketPath)) {
           fs4.unlinkSync(socketPath);
         }
-        resolve9();
+        resolve10();
       });
     });
   }
@@ -3732,7 +3733,7 @@ function getDownloadUrl() {
   return platformUrls[arch4] || null;
 }
 async function downloadFile(url, destPath) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     const followRedirect = (currentUrl, redirectCount = 0) => {
       if (redirectCount > 5) {
         reject(new Error("Too many redirects"));
@@ -3762,7 +3763,7 @@ async function downloadFile(url, destPath) {
         response.pipe(file);
         file.on("finish", () => {
           file.close();
-          resolve9();
+          resolve10();
         });
         file.on("error", (err) => {
           fs5.unlinkSync(destPath);
@@ -4176,10 +4177,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((resolve9) => setTimeout(resolve9, 500));
+      await new Promise((resolve10) => setTimeout(resolve10, 500));
       if (this.isProcessRunning(pid)) {
         this.killByPid(pid, "SIGKILL");
-        await new Promise((resolve9) => setTimeout(resolve9, 200));
+        await new Promise((resolve10) => setTimeout(resolve10, 200));
       }
       killed.push(pid);
     }
@@ -4213,7 +4214,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((resolve9) => setTimeout(resolve9, 1e3));
+            await new Promise((resolve10) => setTimeout(resolve10, 1e3));
             if (this.isProcessRunning(pid)) {
               this.killByPid(pid, "SIGKILL");
             }
@@ -4228,7 +4229,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((resolve9) => setTimeout(resolve9, 500));
+          await new Promise((resolve10) => setTimeout(resolve10, 500));
           if (this.isProcessRunning(pid)) {
             this.killByPid(pid, "SIGKILL");
           }
@@ -4318,7 +4319,7 @@ var TunnelManager = class extends import_events.EventEmitter {
         return { success: false, error: `Failed to get cloudflared: ${errorMessage}` };
       }
     }
-    return new Promise((resolve9) => {
+    return new Promise((resolve10) => {
       const tunnelInfo = {
         moduleUid,
         url: previewUrl || "",
@@ -4384,7 +4385,7 @@ var TunnelManager = class extends import_events.EventEmitter {
             moduleUid,
             url: tunnelInfo.url
           });
-          resolve9({ success: true, url: tunnelInfo.url });
+          resolve10({ success: true, url: tunnelInfo.url });
         }
       };
       process2.stderr?.on("data", (data) => {
@@ -4411,7 +4412,7 @@ var TunnelManager = class extends import_events.EventEmitter {
             onStatusChange?.("error", errorMsg);
             this.emitEvent({ type: "error", moduleUid, error: errorMsg });
           }
-          resolve9({ success: false, error: errorMsg });
+          resolve10({ success: false, error: errorMsg });
         } else if (wasConnected) {
           if (currentState && !currentState.intentionallyStopped) {
             console.log(`[Tunnel] EP948: Named tunnel ${moduleUid} crashed unexpectedly, attempting reconnect...`);
@@ -4442,7 +4443,7 @@ var TunnelManager = class extends import_events.EventEmitter {
           this.emitEvent({ type: "error", moduleUid, error: error.message });
         }
         if (!connected) {
-          resolve9({ success: false, error: error.message });
+          resolve10({ success: false, error: error.message });
         }
       });
       setTimeout(() => {
@@ -4465,7 +4466,7 @@ var TunnelManager = class extends import_events.EventEmitter {
             onStatusChange?.("error", errorMsg);
             this.emitEvent({ type: "error", moduleUid, error: errorMsg });
           }
-          resolve9({ success: false, error: errorMsg });
+          resolve10({ success: false, error: errorMsg });
         }
       }, TUNNEL_TIMEOUTS.NAMED_TUNNEL_CONNECT);
     });
@@ -4526,7 +4527,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((resolve9) => setTimeout(resolve9, 500));
+      await new Promise((resolve10) => setTimeout(resolve10, 500));
       if (this.isProcessRunning(orphanPid)) {
         this.killByPid(orphanPid, "SIGKILL");
       }
@@ -4535,7 +4536,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((resolve9) => setTimeout(resolve9, 1e3));
+      await new Promise((resolve10) => setTimeout(resolve10, 1e3));
     }
     const cleanup = await this.cleanupOrphanedProcesses();
     if (cleanup.cleaned > 0) {
@@ -4575,7 +4576,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((resolve9) => setTimeout(resolve9, 1e3));
+        await new Promise((resolve10) => setTimeout(resolve10, 1e3));
         if (this.isProcessRunning(orphanPid)) {
           this.killByPid(orphanPid, "SIGKILL");
         }
@@ -4591,16 +4592,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((resolve9) => {
+      await new Promise((resolve10) => {
         const timeout = setTimeout(() => {
           if (tunnel.process && !tunnel.process.killed) {
             tunnel.process.kill("SIGKILL");
           }
-          resolve9();
+          resolve10();
         }, 3e3);
         tunnel.process.once("exit", () => {
           clearTimeout(timeout);
-          resolve9();
+          resolve10();
         });
       });
     }
@@ -4972,15 +4973,15 @@ async function writeToStdinWithBackpressure(process2, data, drainTimeoutMs, labe
   if (!stdin || stdin.destroyed) {
     throw new Error(`[${label}] stdin not available. session=${sessionId}`);
   }
-  await new Promise((resolve9, reject) => {
+  await new Promise((resolve10, reject) => {
     const ok = stdin.write(data);
     if (ok) {
-      resolve9();
+      resolve10();
       return;
     }
     const onDrain = () => {
       cleanup();
-      resolve9();
+      resolve10();
     };
     const onError = (err) => {
       cleanup();
@@ -5001,18 +5002,18 @@ async function writeToStdinWithBackpressure(process2, data, drainTimeoutMs, labe
   });
 }
 function waitForProcessExit(process2, alive, timeoutMs) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     if (!process2 || !alive) {
-      resolve9(true);
+      resolve10(true);
       return;
     }
     const onExit = () => {
       clearTimeout(timer);
-      resolve9(true);
+      resolve10(true);
     };
     const timer = setTimeout(() => {
       process2.removeListener("exit", onExit);
-      resolve9(false);
+      resolve10(false);
     }, timeoutMs);
     process2.once("exit", onExit);
   });
@@ -6008,10 +6009,10 @@ var CodexPersistentRuntime = class {
   }
   waitForThreadId(timeoutMs) {
     if (this._agentSessionId) return Promise.resolve(this._agentSessionId);
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       const onId = (id) => {
         clearTimeout(timer);
-        resolve9(id);
+        resolve10(id);
       };
       const timer = setTimeout(() => {
         this.threadIdWaiters = this.threadIdWaiters.filter((w) => w !== onId);
@@ -6042,12 +6043,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 (resolve9, reject) => {
+    return new Promise(async (resolve10, reject) => {
       const timeout = setTimeout(() => {
         this.pending.delete(id);
         reject(new Error(`JSON-RPC timeout: ${method}`));
       }, timeoutMs);
-      this.pending.set(id, { resolve: resolve9, reject, timeout });
+      this.pending.set(id, { resolve: resolve10, reject, timeout });
       try {
         await this.writeToStdin(JSON.stringify(msg) + "\n");
       } catch (err) {
@@ -6197,11 +6198,11 @@ var UnifiedAgentRuntime = class {
     if (!this.currentTurn && this.impl.turnState === "idle") {
       return this.dispatchTurn(message, callbacks);
     }
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       this.queuedTurns.push({
         message,
         callbacks,
-        resolve: resolve9,
+        resolve: resolve10,
         reject
       });
     });
@@ -7719,13 +7720,13 @@ async function getChildProcessRssMb(pid) {
   if (!pid || pid <= 0) return null;
   try {
     if (typeof import_child_process10.execFile !== "function") return null;
-    const stdout = await new Promise((resolve9, reject) => {
+    const stdout = await new Promise((resolve10, reject) => {
       (0, import_child_process10.execFile)("ps", ["-o", "rss=", "-p", String(pid)], { timeout: 1e3 }, (err, out) => {
         if (err) {
           reject(err);
           return;
         }
-        resolve9(String(out));
+        resolve10(String(out));
       });
     });
     const kb = Number(String(stdout).trim());
@@ -7828,8 +7829,8 @@ var AgentControlPlane = class {
   async withConfigLock(fn) {
     const previousLock = this.configWriteLock;
     let releaseLock;
-    this.configWriteLock = new Promise((resolve9) => {
-      releaseLock = resolve9;
+    this.configWriteLock = new Promise((resolve10) => {
+      releaseLock = resolve10;
     });
     try {
       await previousLock;
@@ -9058,7 +9059,7 @@ var WorktreeManager = class _WorktreeManager {
                 const lockContent = fs15.readFileSync(lockPath, "utf-8").trim();
                 const lockPid = parseInt(lockContent, 10);
                 if (!isNaN(lockPid) && this.isProcessRunning(lockPid)) {
-                  await new Promise((resolve9) => setTimeout(resolve9, retryInterval));
+                  await new Promise((resolve10) => setTimeout(resolve10, retryInterval));
                   continue;
                 }
               } catch {
@@ -9072,7 +9073,7 @@ var WorktreeManager = class _WorktreeManager {
           } catch {
             continue;
           }
-          await new Promise((resolve9) => setTimeout(resolve9, retryInterval));
+          await new Promise((resolve10) => setTimeout(resolve10, retryInterval));
           continue;
         }
         throw err;
@@ -9180,9 +9181,9 @@ var WorktreeManager = class _WorktreeManager {
       const worktree = config.worktrees.find((w) => w.moduleUid === moduleUid);
       if (worktree) {
         worktree.setupStatus = status;
-        if (status === "setup") {
+        if (status === "provisioning") {
           worktree.setupStartedAt = (/* @__PURE__ */ new Date()).toISOString();
-        } else if (status === "ready" || status === "error") {
+        } else if (status === "verified" || status === "error") {
           worktree.setupCompletedAt = (/* @__PURE__ */ new Date()).toISOString();
         }
         if (error) {
@@ -9392,7 +9393,7 @@ async function resolveAgentWorkingDirectory(options) {
     command,
     projectPath,
     getWorktreeInfoForModule: getWorktreeInfoForModule2,
-    pathExists = async (candidatePath) => {
+    pathExists: pathExists2 = async (candidatePath) => {
       try {
         await fs16.promises.access(candidatePath);
         return true;
@@ -9412,7 +9413,7 @@ async function resolveAgentWorkingDirectory(options) {
   if (command.sessionContext === "project_root") {
     if (command.workspaceSlug && command.projectSlug) {
       const resolvedProjectPath = getProjectPath(command.workspaceSlug, command.projectSlug);
-      if (resolvedProjectPath !== projectPath && await pathExists(resolvedProjectPath)) {
+      if (resolvedProjectPath !== projectPath && await pathExists2(resolvedProjectPath)) {
         return resolvedProjectPath;
       }
     }
@@ -10597,7 +10598,7 @@ async function handleExec(command, projectPath) {
     env = {}
   } = command;
   const effectiveTimeout = Math.min(Math.max(timeout, 1e3), MAX_TIMEOUT);
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     let stdout = "";
     let stderr = "";
     let timedOut = false;
@@ -10605,7 +10606,7 @@ async function handleExec(command, projectPath) {
     const done = (result) => {
       if (resolved) return;
       resolved = true;
-      resolve9(result);
+      resolve10(result);
     };
     try {
       const proc = (0, import_child_process12.spawn)(cmd, {
@@ -10709,18 +10710,18 @@ var import_core14 = __toESM(require_dist());
 // src/utils/port-check.ts
 var net2 = __toESM(require("net"));
 async function isPortInUse(port) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     const server = net2.createServer();
     server.once("error", (err) => {
       if (err.code === "EADDRINUSE") {
-        resolve9(true);
+        resolve10(true);
       } else {
-        resolve9(false);
+        resolve10(false);
       }
     });
     server.once("listening", () => {
       server.close();
-      resolve9(false);
+      resolve10(false);
     });
     server.listen(port);
   });
@@ -11123,7 +11124,7 @@ var DevServerRegistry = class {
     return killed;
   }
   wait(ms) {
-    return new Promise((resolve9) => setTimeout(resolve9, ms));
+    return new Promise((resolve10) => setTimeout(resolve10, ms));
   }
   killWsServerOnPort(wsPort, worktreePath) {
     const killed = [];
@@ -11697,7 +11698,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((resolve9) => {
+    return new Promise((resolve10) => {
       const req = http.request(
         {
           hostname: "localhost",
@@ -11706,18 +11707,18 @@ var DevServerRunner = class extends import_events2.EventEmitter {
           method: "HEAD",
           timeout: DEV_SERVER_CONSTANTS.HEALTH_CHECK_TIMEOUT_MS
         },
-        () => resolve9(true)
+        () => resolve10(true)
       );
-      req.on("error", () => resolve9(false));
+      req.on("error", () => resolve10(false));
       req.on("timeout", () => {
         req.destroy();
-        resolve9(false);
+        resolve10(false);
       });
       req.end();
     });
   }
   async checkWsHealth(wsPort) {
-    return new Promise((resolve9) => {
+    return new Promise((resolve10) => {
       const req = http.request(
         {
           hostname: "127.0.0.1",
@@ -11727,14 +11728,14 @@ var DevServerRunner = class extends import_events2.EventEmitter {
           timeout: DEV_SERVER_CONSTANTS.HEALTH_CHECK_TIMEOUT_MS
         },
         (res) => {
-          resolve9(res.statusCode === 200);
+          resolve10(res.statusCode === 200);
           res.resume();
         }
       );
-      req.on("error", () => resolve9(false));
+      req.on("error", () => resolve10(false));
       req.on("timeout", () => {
         req.destroy();
-        resolve9(false);
+        resolve10(false);
       });
       req.end();
     });
@@ -11762,7 +11763,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
     return false;
   }
   wait(ms) {
-    return new Promise((resolve9) => setTimeout(resolve9, ms));
+    return new Promise((resolve10) => setTimeout(resolve10, ms));
   }
   getLogsDir() {
     const logsDir = path26.join((0, import_core14.getConfigDir)(), "logs");
@@ -11961,7 +11962,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((resolve9) => setTimeout(resolve9, 2e3));
+          await new Promise((resolve10) => setTimeout(resolve10, 2e3));
         }
         tunnelResult = await this.tunnel.startTunnel({
           moduleUid,
@@ -12093,7 +12094,7 @@ var PreviewManager = class extends import_events3.EventEmitter {
     }
     console.log(`[PreviewManager] Restarting preview for ${moduleUid}`);
     await this.stopPreview(moduleUid);
-    await new Promise((resolve9) => setTimeout(resolve9, 1e3));
+    await new Promise((resolve10) => setTimeout(resolve10, 1e3));
     return this.startPreview({
       moduleUid,
       worktreePath: state.worktreePath,
@@ -12628,6 +12629,92 @@ async function autoDetectSetupScript(worktreePath) {
   console.log(`[Worktree] EP1222: Detected ${name} (${language}) via ${detection.matchedFile}`);
   return installCmd;
 }
+function isPathWithinRoot(candidatePath, rootPath) {
+  const relative5 = path29.relative(rootPath, candidatePath);
+  return relative5 === "" || !relative5.startsWith("..") && !path29.isAbsolute(relative5);
+}
+async function pathExists(candidatePath) {
+  try {
+    await fs29.promises.access(candidatePath, fs29.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveGitPath(worktreePath, gitPathName) {
+  try {
+    const { stdout } = await execAsync2(`git -C "${worktreePath}" rev-parse --git-path ${gitPathName}`);
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function handleWorktreeVerify(command, projectPath) {
+  const projectRoot = path29.resolve(projectPath);
+  const candidatePath = path29.resolve(command.worktreePath);
+  const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const issues = [];
+  const exists = await pathExists(candidatePath);
+  const withinProjectRoot = exists && isPathWithinRoot(candidatePath, projectRoot);
+  let gitWorktreeValid = false;
+  let observedBranch = null;
+  let structurallySound = true;
+  if (!exists) {
+    issues.push("PATH_MISSING");
+  }
+  if (exists && !withinProjectRoot) {
+    issues.push("OUTSIDE_PROJECT_ROOT");
+  }
+  if (exists && withinProjectRoot) {
+    try {
+      await execAsync2(`git -C "${candidatePath}" rev-parse --is-inside-work-tree`);
+      gitWorktreeValid = true;
+    } catch {
+      issues.push("INVALID_GIT_WORKTREE");
+    }
+  }
+  if (gitWorktreeValid) {
+    try {
+      const { stdout } = await execAsync2(`git -C "${candidatePath}" rev-parse --abbrev-ref HEAD`);
+      observedBranch = stdout.trim() || null;
+    } catch {
+      observedBranch = null;
+    }
+    const brokenMarkers = await Promise.all([
+      resolveGitPath(candidatePath, "MERGE_HEAD"),
+      resolveGitPath(candidatePath, "REBASE_HEAD"),
+      resolveGitPath(candidatePath, "rebase-merge"),
+      resolveGitPath(candidatePath, "rebase-apply")
+    ]);
+    const markerExists = await Promise.all(
+      brokenMarkers.filter((value) => Boolean(value)).map((value) => pathExists(value))
+    );
+    if (markerExists.some(Boolean)) {
+      structurallySound = false;
+      issues.push("BROKEN_STATE");
+    }
+  }
+  const branchMatches = command.expectedBranch ? observedBranch === command.expectedBranch : true;
+  if (command.expectedBranch && !branchMatches) {
+    issues.push("BRANCH_MISMATCH");
+  }
+  const verification = {
+    checkedAt,
+    path: candidatePath,
+    projectRoot,
+    exists,
+    withinProjectRoot,
+    gitWorktreeValid,
+    branchMatches,
+    structurallySound,
+    observedBranch,
+    issues
+  };
+  return {
+    success: true,
+    verification
+  };
+}
 async function handleWorktreeCreate(request2) {
   const {
     workspaceSlug,
@@ -12741,11 +12828,11 @@ ${buildCmd}` : buildCmd;
     setTimeout(() => {
       void (async () => {
         if (!effectiveSetupScript) {
-          await manager.updateWorktreeStatus(moduleUid, "ready");
+          await manager.updateWorktreeStatus(moduleUid, "provisioning");
           return;
         }
         const setupStartMs = Date.now();
-        await manager.updateWorktreeStatus(moduleUid, "setup");
+        await manager.updateWorktreeStatus(moduleUid, "provisioning");
         console.log(`[Worktree] EP1143: Running setup script asynchronously...`);
         const scriptResult = await manager.runSetupScript(moduleUid, effectiveSetupScript);
         console.log(`[Worktree] EP1373: setup_script phase=worktree_setup durationMs=${Date.now() - setupStartMs} moduleUid=${moduleUid} correlationId=${correlationId || "none"} success=${scriptResult.success}`);
@@ -12754,7 +12841,7 @@ ${buildCmd}` : buildCmd;
           await manager.updateWorktreeStatus(moduleUid, "error", scriptResult.error);
           return;
         }
-        await manager.updateWorktreeStatus(moduleUid, "ready");
+        await manager.updateWorktreeStatus(moduleUid, "provisioning");
       })().catch(async (setupError) => {
         const errorMessage = setupError instanceof Error ? setupError.message : String(setupError);
         console.error(`[Worktree] EP1458: Async setup failed for ${moduleUid}: ${errorMessage}`);
@@ -12767,7 +12854,7 @@ ${buildCmd}` : buildCmd;
     }, 0);
     let previewUrl;
     let port;
-    const finalStatus = effectiveSetupScript ? "setup" : "ready";
+    const finalStatus = "provisioning";
     if (moduleType === "ops") {
       console.log(`[Worktree] EP1363: Skipping preview for ops module ${moduleUid}`);
     } else {
@@ -13087,6 +13174,19 @@ var CODEX_BANNER_SIGNAL = /(openai codex|\bmodel:)/i;
 var CODEX_PROMPT_SIGNAL = /(?:^|\n)\s*(?:>|❯)\s*$/m;
 var MAX_CODEX_STARTUP_READY_TIMEOUT_MS = 3e4;
 var sessions = /* @__PURE__ */ new Map();
+function bestEffortTerminateProcessGroup(session) {
+  if (process.platform === "win32") {
+    return;
+  }
+  const pid = session.pty.pid;
+  if (!pid || pid <= 0) {
+    return;
+  }
+  try {
+    process.kill(-pid, "SIGTERM");
+  } catch {
+  }
+}
 function killPtySessionsForModule(moduleUid) {
   const killedRunIds = [];
   for (const [id, session] of sessions.entries()) {
@@ -13095,6 +13195,7 @@ function killPtySessionsForModule(moduleUid) {
     }
     if (session.watchdogTimer) clearTimeout(session.watchdogTimer);
     try {
+      bestEffortTerminateProcessGroup(session);
       session.pty.kill();
       killedRunIds.push(id);
     } catch {
@@ -13221,6 +13322,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);
+    bestEffortTerminateProcessGroup(session);
     client.send({
       type: "pty_exit",
       moduleUid,
@@ -13277,6 +13379,7 @@ function handlePtyKill(payload) {
     return;
   }
   try {
+    bestEffortTerminateProcessGroup(session);
     session.pty.kill();
     console.log(`[PTY] Kill signal sent for session ${agent_run_id}`);
   } catch {
@@ -13366,8 +13469,8 @@ function createStartupState(payload, resolvedArgs) {
   const mode = payload.run_type === "persistent" ? trimmedStdin.length > 0 ? "seed_after_prompt" : "prompt_ready" : "first_output";
   let resolveReady;
   let rejectReady;
-  const waitForReady = new Promise((resolve9, reject) => {
-    resolveReady = resolve9;
+  const waitForReady = new Promise((resolve10, reject) => {
+    resolveReady = resolve10;
     rejectReady = reject;
   });
   const startup = {
@@ -13659,7 +13762,7 @@ async function killProcessOnPort(port) {
       } catch {
       }
     }
-    await new Promise((resolve9) => setTimeout(resolve9, 1e3));
+    await new Promise((resolve10) => setTimeout(resolve10, 1e3));
     for (const pid of pids) {
       try {
         (0, import_child_process16.execSync)(`kill -0 ${pid} 2>/dev/null`, { encoding: "utf8" });
@@ -13668,7 +13771,7 @@ async function killProcessOnPort(port) {
       } catch {
       }
     }
-    await new Promise((resolve9) => setTimeout(resolve9, 500));
+    await new Promise((resolve10) => setTimeout(resolve10, 500));
     const stillInUse = await isPortInUse(port);
     if (stillInUse) {
       console.error(`[DevServer] EP929: Port ${port} still in use after kill attempts`);
@@ -13688,7 +13791,7 @@ async function waitForPort(port, timeoutMs = 3e4) {
     if (await isPortInUse(port)) {
       return true;
     }
-    await new Promise((resolve9) => setTimeout(resolve9, checkInterval));
+    await new Promise((resolve10) => setTimeout(resolve10, checkInterval));
   }
   return false;
 }
@@ -13760,7 +13863,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((resolve9) => setTimeout(resolve9, delay));
+  await new Promise((resolve10) => setTimeout(resolve10, delay));
   if (!activeServers.has(moduleUid)) {
     console.log(`[DevServer] EP932: Server ${moduleUid} was removed during restart delay, aborting restart`);
     return;
@@ -13885,7 +13988,7 @@ async function stopDevServer(moduleUid) {
       writeToLog(serverInfo.logFile, `Stopping server (manual stop)`, false);
     }
     serverInfo.process.kill("SIGTERM");
-    await new Promise((resolve9) => setTimeout(resolve9, 2e3));
+    await new Promise((resolve10) => setTimeout(resolve10, 2e3));
     if (!serverInfo.process.killed) {
       serverInfo.process.kill("SIGKILL");
     }
@@ -13903,7 +14006,7 @@ async function restartDevServer(moduleUid) {
     writeToLog(logFile, `Manual restart requested`, false);
   }
   await stopDevServer(moduleUid);
-  await new Promise((resolve9) => setTimeout(resolve9, 1e3));
+  await new Promise((resolve10) => setTimeout(resolve10, 1e3));
   if (await isPortInUse(port)) {
     await killProcessOnPort(port);
   }
@@ -14024,7 +14127,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((resolve9) => setTimeout(resolve9, delay));
+            await new Promise((resolve10) => setTimeout(resolve10, delay));
             await this.host.disconnectProject(projectPath);
           }
         }
@@ -14988,7 +15091,7 @@ var ConnectionManager = class {
    * handlers are removed deterministically on every exit path.
    */
   async waitForAuthentication(client, timeoutMs = 3e4) {
-    await new Promise((resolve9, reject) => {
+    await new Promise((resolve10, reject) => {
       let settled = false;
       const cleanup = () => {
         clearTimeout(timeout);
@@ -15007,7 +15110,7 @@ var ConnectionManager = class {
         if (settled) return;
         settled = true;
         cleanup();
-        resolve9();
+        resolve10();
       };
       const authErrorHandler = (message) => {
         if (settled) return;
@@ -15222,6 +15325,9 @@ var ProjectMessageRouter = class {
             case "worktree:release":
               result = await handleWorktreeRelease(cmd);
               break;
+            case "worktree:verify":
+              result = await handleWorktreeVerify(cmd, projectPath);
+              break;
             case "worktree:list":
               result = await handleWorktreeList(
                 cmd.workspaceSlug,
@@ -15680,8 +15786,8 @@ 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);
+  const relative5 = path36.relative(projectRoot, candidatePath);
+  return relative5 !== "" && !relative5.startsWith("..") && !path36.isAbsolute(relative5);
 }
 function collectUnexpectedWorktrees(params) {
   const projectRootResolved = path36.resolve(params.projectRoot);
@@ -16051,8 +16157,8 @@ var Daemon = class _Daemon {
       }
     }
     let releaseLock;
-    const lockPromise = new Promise((resolve9) => {
-      releaseLock = resolve9;
+    const lockPromise = new Promise((resolve10) => {
+      releaseLock = resolve10;
     });
     this.tunnelOperationLocks.set(moduleUid, lockPromise);
     try {
@@ -16098,7 +16204,7 @@ var Daemon = class _Daemon {
         const maxWait = 35e3;
         const startTime = Date.now();
         while (this.connectionManager.hasPendingConnection(projectPath) && Date.now() - startTime < maxWait) {
-          await new Promise((resolve9) => setTimeout(resolve9, 500));
+          await new Promise((resolve10) => setTimeout(resolve10, 500));
         }
         if (this.connectionManager.hasLiveConnection(projectPath)) {
           console.log(`[Daemon] Pending connection succeeded for ${projectPath}`);
@@ -17168,8 +17274,8 @@ var Daemon = class _Daemon {
    */
   async runWorktreeSetupSync(moduleUid, worktreeManager, copyFiles, setupScript, worktreePath, envVars = {}) {
     console.log(`[Daemon] EP1002: Running worktree setup for ${moduleUid}`);
-    await worktreeManager.updateWorktreeStatus(moduleUid, "setup");
-    await this.updateModuleWorktreeStatus(moduleUid, "setup", worktreePath);
+    await worktreeManager.updateWorktreeStatus(moduleUid, "provisioning");
+    await this.updateModuleWorktreeStatus(moduleUid, "provisioning", worktreePath);
     if (Object.keys(envVars).length > 0) {
       console.log(`[Daemon] EP1002: Writing .env with ${Object.keys(envVars).length} variables`);
       writeEnvFile(worktreePath, envVars);
@@ -17223,12 +17329,12 @@ var Daemon = class _Daemon {
         throw new Error(`Setup script failed: ${scriptResult.error}`);
       }
     }
-    await worktreeManager.updateWorktreeStatus(moduleUid, "ready");
-    await this.updateModuleWorktreeStatus(moduleUid, "ready", worktreePath);
+    await worktreeManager.updateWorktreeStatus(moduleUid, "provisioning");
+    await this.updateModuleWorktreeStatus(moduleUid, "provisioning", worktreePath);
     console.log(`[Daemon] EP1002: Worktree setup complete for ${moduleUid}`);
   }
   async runForegroundCommand(command, args, cwd, env, timeoutMs) {
-    await new Promise((resolve9, reject) => {
+    await new Promise((resolve10, reject) => {
       const commandLabel = `${command} ${args.join(" ")}`.trim();
       const child = (0, import_child_process18.spawn)(command, args, {
         cwd,
@@ -17251,7 +17357,7 @@ var Daemon = class _Daemon {
           reject(error);
           return;
         }
-        resolve9();
+        resolve10();
       };
       termTimer = setTimeout(() => {
         timedOut = true;