@episoda/cli 0.2.157 → 0.2.159

package/dist/daemon/daemon-process.js

@@ -1653,10 +1653,6 @@ var require_git_executor = __commonJS({
             };
           } catch {
           }
-          try {
-            await this.runGitCommand(["fetch", "--all", "--prune"], cwd, options);
-          } catch {
-          }
           const args = ["worktree", "add"];
           if (command.detach) {
             args.push("--detach", command.path);
@@ -2913,7 +2909,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@episoda/cli",
-      version: "0.2.157",
+      version: "0.2.159",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -4936,6 +4932,8 @@ var ClaudePersistentRuntime = class {
     this.maxStderrTailBytes = 8192;
     // Stdout JSONL parsing state
     this.stdoutBuffer = "";
+    this.stdoutLineQueue = [];
+    this.drainingStdoutQueue = false;
     this.parsedLineCount = 0;
     this.chunksSent = 0;
     this.hasContent = false;
@@ -4998,21 +4996,9 @@ var ClaudePersistentRuntime = class {
       this.stdoutBuffer += data.toString();
       const lines = this.stdoutBuffer.split("\n");
       this.stdoutBuffer = lines.pop() || "";
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        try {
-          const parsed = JSON.parse(line);
-          this.parsedLineCount++;
-          if (this.parsedLineCount === 1) {
-            const ttftMs = Date.now() - this.spawnTimestamp;
-            console.log(`[ClaudePersistentRuntime] EP1360: TTFT (spawn to first JSON): ${ttftMs}ms, session=${this.sessionId}`);
-          }
-          this.handleParsedEvent(parsed);
-        } catch {
-          if (line.trim() && this.callbacks) {
-            this.callbacks.onChunk(line + "\n");
-          }
-        }
+      if (lines.length > 0) {
+        this.stdoutLineQueue.push(...lines);
+        this.drainStdoutQueue();
       }
     });
     this.process.on("exit", (code, signal) => {
@@ -5118,6 +5104,41 @@ var ClaudePersistentRuntime = class {
   // -------------------------------------------------------------------------
   // Event handling
   // -------------------------------------------------------------------------
+  drainStdoutQueue() {
+    if (this.drainingStdoutQueue) return;
+    this.drainingStdoutQueue = true;
+    const BATCH_SIZE = 5;
+    const processBatch = () => {
+      let processed = 0;
+      while (processed < BATCH_SIZE && this.stdoutLineQueue.length > 0) {
+        const line = this.stdoutLineQueue.shift();
+        processed++;
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line);
+          this.parsedLineCount++;
+          if (this.parsedLineCount === 1) {
+            const ttftMs = Date.now() - this.spawnTimestamp;
+            console.log(`[ClaudePersistentRuntime] EP1360: TTFT (spawn to first JSON): ${ttftMs}ms, session=${this.sessionId}`);
+          }
+          this.handleParsedEvent(parsed);
+        } catch {
+          if (line.trim() && this.callbacks) {
+            this.callbacks.onChunk(line + "\n");
+          }
+        }
+      }
+      if (this.stdoutLineQueue.length > 0) {
+        setImmediate(processBatch);
+        return;
+      }
+      this.drainingStdoutQueue = false;
+      if (this.stdoutLineQueue.length > 0) {
+        this.drainStdoutQueue();
+      }
+    };
+    processBatch();
+  }
   handleParsedEvent(parsed) {
     const type = parsed.type;
     if (this._turnState === "waiting_for_echo") {
@@ -5429,6 +5450,8 @@ var CodexPersistentRuntime = class {
     this.stderrTail = "";
     this.maxStderrTailBytes = 8192;
     this.stdoutBuffer = "";
+    this.stdoutLineQueue = [];
+    this.drainingStdoutQueue = false;
     this.parsedLineCount = 0;
     // Per-turn accounting
     this.turnStartTime = 0;
@@ -5483,21 +5506,9 @@ var CodexPersistentRuntime = class {
       this.stdoutBuffer += data.toString();
       const lines = this.stdoutBuffer.split("\n");
       this.stdoutBuffer = lines.pop() || "";
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        try {
-          const parsed = JSON.parse(line);
-          this.parsedLineCount++;
-          if (this.parsedLineCount === 1) {
-            const ttftMs = Date.now() - this.spawnTimestamp;
-            console.log(`[CodexPersistentRuntime] EP1360: TTFT (spawn to first JSON): ${ttftMs}ms, session=${this.sessionId}`);
-          }
-          this.handleJsonRpcMessage(parsed);
-        } catch {
-          if (line.trim() && this.callbacks) {
-            this.callbacks.onChunk(line + "\n");
-          }
-        }
+      if (lines.length > 0) {
+        this.stdoutLineQueue.push(...lines);
+        this.drainStdoutQueue();
       }
     });
     this.process.on("exit", (code, signal) => {
@@ -5608,6 +5619,41 @@ var CodexPersistentRuntime = class {
   // -------------------------------------------------------------------------
   // JSON-RPC plumbing
   // -------------------------------------------------------------------------
+  drainStdoutQueue() {
+    if (this.drainingStdoutQueue) return;
+    this.drainingStdoutQueue = true;
+    const BATCH_SIZE = 5;
+    const processBatch = () => {
+      let processed = 0;
+      while (processed < BATCH_SIZE && this.stdoutLineQueue.length > 0) {
+        const line = this.stdoutLineQueue.shift();
+        processed++;
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line);
+          this.parsedLineCount++;
+          if (this.parsedLineCount === 1) {
+            const ttftMs = Date.now() - this.spawnTimestamp;
+            console.log(`[CodexPersistentRuntime] EP1360: TTFT (spawn to first JSON): ${ttftMs}ms, session=${this.sessionId}`);
+          }
+          this.handleJsonRpcMessage(parsed);
+        } catch {
+          if (line.trim() && this.callbacks) {
+            this.callbacks.onChunk(line + "\n");
+          }
+        }
+      }
+      if (this.stdoutLineQueue.length > 0) {
+        setImmediate(processBatch);
+        return;
+      }
+      this.drainingStdoutQueue = false;
+      if (this.stdoutLineQueue.length > 0) {
+        this.drainStdoutQueue();
+      }
+    };
+    processBatch();
+  }
   handleJsonRpcMessage(msg) {
     if (RUNTIME_DEBUG2 && this.debugTraceCount < 20) {
       this.debugTraceCount++;
@@ -8109,6 +8155,7 @@ var AgentCommandQueue = class {
 // src/daemon/worktree-manager.ts
 var fs11 = __toESM(require("fs"));
 var path12 = __toESM(require("path"));
+var import_child_process11 = require("child_process");
 var import_core10 = __toESM(require_dist());
 function validateModuleUid(moduleUid) {
   if (!moduleUid || typeof moduleUid !== "string" || !moduleUid.trim()) {
@@ -8125,6 +8172,38 @@ function validateModuleUid(moduleUid) {
   }
   return true;
 }
+function isValidDefaultBranchName(name) {
+  if (!name || typeof name !== "string") return false;
+  const trimmed = name.trim();
+  if (trimmed !== name) return false;
+  if (name.length > 255) return false;
+  if (name.startsWith("-")) return false;
+  if (name.startsWith("/")) return false;
+  if (name.endsWith("/")) return false;
+  if (name.endsWith(".")) return false;
+  if (name.endsWith(".lock")) return false;
+  if (name.includes("..")) return false;
+  if (name.includes("@{")) return false;
+  if (name.includes("//")) return false;
+  if (name.includes("\\")) return false;
+  if (/[ ~^:?*\[\]\s]/.test(name)) return false;
+  if (!/^[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(name)) return false;
+  return true;
+}
+function runGit(args, cwd, timeoutMs) {
+  const res = (0, import_child_process11.spawnSync)("git", args, {
+    cwd,
+    encoding: "utf-8",
+    timeout: timeoutMs,
+    windowsHide: true,
+    shell: false
+  });
+  return {
+    success: res.status === 0,
+    stdout: (res.stdout || "").toString(),
+    stderr: (res.stderr || "").toString()
+  };
+}
 var WorktreeManager = class _WorktreeManager {
   constructor(projectRoot) {
     // ============================================================
@@ -8182,22 +8261,24 @@ var WorktreeManager = class _WorktreeManager {
    */
   async ensureFetchRefspecConfigured() {
     try {
-      const { execSync: execSync10 } = require("child_process");
       let fetchRefspec = null;
       try {
-        fetchRefspec = execSync10("git config --get remote.origin.fetch", {
-          cwd: this.bareRepoPath,
-          encoding: "utf-8",
-          timeout: 5e3
-        }).trim();
+        const res = runGit(["config", "--get", "remote.origin.fetch"], this.bareRepoPath, 5e3);
+        if (res.success) {
+          fetchRefspec = res.stdout.trim();
+        }
       } catch {
       }
       if (!fetchRefspec) {
         console.log("[WorktreeManager] EP1014: Configuring missing fetch refspec for bare repo");
-        execSync10('git config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"', {
-          cwd: this.bareRepoPath,
-          timeout: 5e3
-        });
+        const setRes = runGit(
+          ["config", "remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*"],
+          this.bareRepoPath,
+          5e3
+        );
+        if (!setRes.success) {
+          throw new Error(setRes.stderr || "Failed to configure fetch refspec");
+        }
         console.log("[WorktreeManager] EP1014: Fetch refspec configured successfully");
       }
     } catch (error) {
@@ -8230,11 +8311,44 @@ var WorktreeManager = class _WorktreeManager {
     manager.writeConfig(config);
     return manager;
   }
+  /**
+   * EP1373: Resolve the default branch name using a 3-level fallback:
+   * 1. Explicit defaultBranch parameter (from project GitHub config)
+   * 2. Git-derived: refs/remotes/origin/HEAD symbolic-ref target
+   * 3. Final fallback: 'main' (with warning)
+   */
+  async resolveDefaultBranch(explicitDefault) {
+    if (explicitDefault) {
+      if (isValidDefaultBranchName(explicitDefault)) {
+        return explicitDefault;
+      }
+      console.warn(`[WorktreeManager] EP1373: Invalid defaultBranch provided ("${explicitDefault}"), ignoring`);
+    }
+    try {
+      const res = runGit(["symbolic-ref", "refs/remotes/origin/HEAD"], this.bareRepoPath, 5e3);
+      if (!res.success) {
+        throw new Error(res.stderr || "symbolic-ref failed");
+      }
+      const symref = res.stdout.trim();
+      const match = symref.match(/^refs\/remotes\/origin\/(.+)$/);
+      if (match && match[1]) {
+        const derived = match[1];
+        if (isValidDefaultBranchName(derived)) {
+          return derived;
+        }
+        console.warn(`[WorktreeManager] EP1373: Derived default branch from origin/HEAD is invalid ("${derived}"), ignoring`);
+      }
+    } catch {
+    }
+    console.warn('[WorktreeManager] EP1373: Could not resolve default branch, falling back to "main"');
+    return "main";
+  }
   /**
    * Create a worktree for a module
    * The entire operation is locked to prevent race conditions
+   * EP1373: Added defaultBranch parameter for explicit default branch resolution
    */
-  async createWorktree(moduleUid, branchName, createBranch = false) {
+  async createWorktree(moduleUid, branchName, createBranch = false, defaultBranch, correlationId) {
     if (!validateModuleUid(moduleUid)) {
       return {
         success: false,
@@ -8300,25 +8414,63 @@ var WorktreeManager = class _WorktreeManager {
           console.warn("[WorktreeManager] EP1265: Failed to prune worktrees (continuing):", pruneResult.output);
         }
       }
-      const fetchResult = await this.gitExecutor.execute({
-        action: "fetch",
-        remote: "origin",
-        branch: "+refs/heads/main:refs/remotes/origin/main"
-      }, { cwd: this.bareRepoPath });
-      if (!fetchResult.success && createBranch) {
-        console.error("[worktree-manager] Failed to fetch from origin:", fetchResult.output);
-        return {
-          success: false,
-          error: "Failed to fetch latest refs from origin. Cannot create worktree with stale refs."
-        };
+      const resolvedDefault = await this.resolveDefaultBranch(defaultBranch);
+      let shouldCreateBranch = createBranch;
+      let startPoint;
+      if (createBranch) {
+        const managerFetchStartMs = Date.now();
+        const fetchResult = await this.gitExecutor.execute({
+          action: "fetch",
+          remote: "origin",
+          branch: `+refs/heads/${resolvedDefault}:refs/remotes/origin/${resolvedDefault}`
+        }, { cwd: this.bareRepoPath });
+        console.log(`[WorktreeManager] EP1373: manager_fetch phase=manager_fetch durationMs=${Date.now() - managerFetchStartMs} moduleUid=${moduleUid} correlationId=${correlationId || "none"} defaultBranch=${resolvedDefault} success=${fetchResult.success}`);
+        if (!fetchResult.success) {
+          console.error("[worktree-manager] Failed to fetch from origin:", fetchResult.output);
+          return {
+            success: false,
+            error: "Failed to fetch latest refs from origin. Cannot create worktree with stale refs."
+          };
+        }
+        startPoint = `origin/${resolvedDefault}`;
+      } else {
+        const existingBranchFetchStartMs = Date.now();
+        const branchFetchResult = await this.gitExecutor.execute({
+          action: "fetch",
+          remote: "origin",
+          branch: `+refs/heads/${branchName}:refs/remotes/origin/${branchName}`
+        }, { cwd: this.bareRepoPath });
+        console.log(`[WorktreeManager] EP1373: existing_branch_fetch phase=existing_branch_fetch durationMs=${Date.now() - existingBranchFetchStartMs} moduleUid=${moduleUid} correlationId=${correlationId || "none"} branch=${branchName} success=${branchFetchResult.success}`);
+        const localBranchExists = runGit(
+          ["show-ref", "--verify", `refs/heads/${branchName}`],
+          this.bareRepoPath,
+          5e3
+        ).success;
+        const remoteBranchExists = runGit(
+          ["show-ref", "--verify", `refs/remotes/origin/${branchName}`],
+          this.bareRepoPath,
+          5e3
+        ).success;
+        if (!localBranchExists && remoteBranchExists) {
+          shouldCreateBranch = true;
+          startPoint = `origin/${branchName}`;
+          console.log(`[WorktreeManager] EP1373: remote_only_branch phase=remote_only_branch moduleUid=${moduleUid} correlationId=${correlationId || "none"} branch=${branchName}`);
+        } else if (!localBranchExists && !remoteBranchExists) {
+          return {
+            success: false,
+            error: `Branch "${branchName}" not found locally or on origin`
+          };
+        }
       }
+      const gitWorktreeAddStartMs = Date.now();
       const result = await this.gitExecutor.execute({
         action: "worktree_add",
         path: worktreePath,
         branch: branchName,
-        create: createBranch,
-        startPoint: createBranch ? "origin/main" : void 0
+        create: shouldCreateBranch,
+        startPoint
       }, { cwd: this.bareRepoPath });
+      console.log(`[WorktreeManager] EP1373: git_worktree_add phase=git_worktree_add durationMs=${Date.now() - gitWorktreeAddStartMs} moduleUid=${moduleUid} correlationId=${correlationId || "none"} success=${result.success}`);
       if (!result.success) {
         return {
           success: false,
@@ -9959,7 +10111,7 @@ async function handleFileMkdir(command, projectPath) {
 }
 
 // src/daemon/handlers/exec-handler.ts
-var import_child_process11 = require("child_process");
+var import_child_process12 = require("child_process");
 var DEFAULT_TIMEOUT = 3e4;
 var MAX_TIMEOUT = 3e5;
 async function handleExec(command, projectPath) {
@@ -9981,7 +10133,7 @@ async function handleExec(command, projectPath) {
       resolve4(result);
     };
     try {
-      const proc = (0, import_child_process11.spawn)(cmd, {
+      const proc = (0, import_child_process12.spawn)(cmd, {
         shell: true,
         cwd,
         env: { ...process.env, ...env },
@@ -10045,7 +10197,7 @@ async function handleExec(command, projectPath) {
 var path23 = __toESM(require("path"));
 var fs22 = __toESM(require("fs"));
 var os10 = __toESM(require("os"));
-var import_child_process14 = require("child_process");
+var import_child_process15 = require("child_process");
 var import_util2 = require("util");
 
 // src/preview/types.ts
@@ -10072,7 +10224,7 @@ var import_events3 = require("events");
 var import_fs = require("fs");
 
 // src/preview/dev-server-runner.ts
-var import_child_process13 = require("child_process");
+var import_child_process14 = require("child_process");
 var http = __toESM(require("http"));
 var fs20 = __toESM(require("fs"));
 var path21 = __toESM(require("path"));
@@ -10210,7 +10362,7 @@ No cached values available as fallback.`
 var fs19 = __toESM(require("fs"));
 var path20 = __toESM(require("path"));
 var os9 = __toESM(require("os"));
-var import_child_process12 = require("child_process");
+var import_child_process13 = require("child_process");
 var DEV_SERVER_REGISTRY_DIR = path20.join(os9.homedir(), ".episoda", "dev-servers");
 var DevServerRegistry = class {
   constructor() {
@@ -10365,7 +10517,7 @@ var DevServerRegistry = class {
    */
   getProcessCwd(pid) {
     try {
-      const output = (0, import_child_process12.execSync)(`lsof -p ${pid} -Fn | grep ^n | grep cwd | head -1`, {
+      const output = (0, import_child_process13.execSync)(`lsof -p ${pid} -Fn | grep ^n | grep cwd | head -1`, {
         encoding: "utf8",
         timeout: 5e3
       }).trim();
@@ -10390,7 +10542,7 @@ var DevServerRegistry = class {
   findProcessesInWorktree(worktreePath) {
     const pids = [];
     try {
-      const output = (0, import_child_process12.execSync)(
+      const output = (0, import_child_process13.execSync)(
         `lsof -c node -c next | grep "${worktreePath}" | awk '{print $2}' | sort -u`,
         { encoding: "utf8", timeout: 5e3 }
       ).trim();
@@ -10451,7 +10603,7 @@ var DevServerRegistry = class {
    */
   findProcessesOnPort(port) {
     try {
-      const output = (0, import_child_process12.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
+      const output = (0, import_child_process13.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
       if (!output) {
         return [];
       }
@@ -10705,7 +10857,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
    */
   async killProcessOnPort(port) {
     try {
-      const result = (0, import_child_process13.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
+      const result = (0, import_child_process14.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
       if (!result) {
         return true;
       }
@@ -10713,15 +10865,15 @@ var DevServerRunner = class extends import_events2.EventEmitter {
       console.log(`[DevServerRunner] Found ${pids.length} process(es) on port ${port}`);
       for (const pid of pids) {
         try {
-          (0, import_child_process13.execSync)(`kill -15 ${pid} 2>/dev/null || true`);
+          (0, import_child_process14.execSync)(`kill -15 ${pid} 2>/dev/null || true`);
         } catch {
         }
       }
       await this.wait(1e3);
       for (const pid of pids) {
         try {
-          (0, import_child_process13.execSync)(`kill -0 ${pid} 2>/dev/null`);
-          (0, import_child_process13.execSync)(`kill -9 ${pid} 2>/dev/null || true`);
+          (0, import_child_process14.execSync)(`kill -0 ${pid} 2>/dev/null`);
+          (0, import_child_process14.execSync)(`kill -9 ${pid} 2>/dev/null || true`);
         } catch {
         }
       }
@@ -10770,7 +10922,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
       PORT: String(port),
       NODE_OPTIONS: enhancedNodeOptions
     };
-    const proc = (0, import_child_process13.spawn)(cmd, args, {
+    const proc = (0, import_child_process14.spawn)(cmd, args, {
       cwd: projectPath,
       env: mergedEnv,
       stdio: ["ignore", "pipe", "pipe"],
@@ -11571,7 +11723,7 @@ async function getConfigForApi() {
   }
   return (0, import_core13.loadConfig)();
 }
-var execAsync2 = (0, import_util2.promisify)(import_child_process14.exec);
+var execAsync2 = (0, import_util2.promisify)(import_child_process15.exec);
 function persistWorkspaceProjectContext(workspaceSlug, projectSlug, projectId) {
   if (process.env.EPISODA_MODE !== "cloud") {
     return;
@@ -11644,8 +11796,11 @@ async function handleWorktreeCreate(request2) {
     envVars,
     setupScript,
     // EP1229: detachedHead removed - planning worktrees no longer exist
-    moduleType
+    moduleType,
+    defaultBranch,
+    correlationId
   } = request2;
+  const worktreeStartMs = Date.now();
   console.log(`[Worktree] K1273: Creating worktree for ${moduleUid}`);
   console.log(`[Worktree]   Project: ${projectSlug}`);
   console.log(`[Worktree]   Branch: ${branchName} (create: ${createBranch})`);
@@ -11689,12 +11844,7 @@ async function handleWorktreeCreate(request2) {
         };
       }
     } else {
-      console.log(`[Worktree] K1273: Project exists, fetching latest...`);
-      try {
-        await execAsync2(`git -C "${bareRepoPath}" fetch origin --prune`, { env: gitEnv });
-      } catch (fetchError) {
-        console.warn(`[Worktree] K1273: Fetch failed (continuing anyway): ${fetchError.message}`);
-      }
+      console.log(`[Worktree] EP1373: Project exists, skipping handler-level fetch (manager handles narrow fetch)`);
     }
     const manager = new WorktreeManager(projectPath);
     const initialized2 = await manager.initialize();
@@ -11704,7 +11854,8 @@ async function handleWorktreeCreate(request2) {
         error: `Failed to initialize WorktreeManager at ${projectPath}`
       };
     }
-    const result = await manager.createWorktree(moduleUid, branchName, createBranch);
+    const worktreeAddStartMs = Date.now();
+    const result = await manager.createWorktree(moduleUid, branchName, createBranch, defaultBranch, correlationId);
     if (!result.success) {
       return {
         success: false,
@@ -11712,6 +11863,7 @@ async function handleWorktreeCreate(request2) {
       };
     }
     const worktreePath = result.worktreePath;
+    console.log(`[Worktree] EP1373: worktree_add phase=worktree_add durationMs=${Date.now() - worktreeAddStartMs} moduleUid=${moduleUid} correlationId=${correlationId || "none"}`);
     console.log(`[Worktree] EP1143: Worktree created at ${worktreePath}`);
     const config = await getConfigForApi();
     let finalStatus = "ready";
@@ -11743,6 +11895,7 @@ ${buildCmd}` : buildCmd;
       }
     }
     if (effectiveSetupScript) {
+      const setupStartMs = Date.now();
       await manager.updateWorktreeStatus(moduleUid, "setup");
       if (config?.access_token) {
         await updateWorktree(config, {
@@ -11755,6 +11908,7 @@ ${buildCmd}` : buildCmd;
       }
       console.log(`[Worktree] EP1143: Running setup script...`);
       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}`);
       if (!scriptResult.success) {
         console.error(`[Worktree] EP1143: Setup script failed: ${scriptResult.error}`);
         await manager.updateWorktreeStatus(moduleUid, "error", scriptResult.error);
@@ -11814,6 +11968,7 @@ ${buildCmd}` : buildCmd;
         console.error(`[Worktree] EP1143: Failed to update worktrees table: ${apiError.message}`);
       }
     }
+    console.log(`[Worktree] EP1373: worktree_create_total phase=worktree_create_total durationMs=${Date.now() - worktreeStartMs} moduleUid=${moduleUid} correlationId=${correlationId || "none"} status=${finalStatus}`);
     console.log(`[Worktree] EP1143: Worktree ready for ${moduleUid}`);
     return {
       success: true,
@@ -12116,7 +12271,7 @@ async function handleProjectSetup(params) {
 }
 
 // src/utils/dev-server.ts
-var import_child_process15 = require("child_process");
+var import_child_process16 = require("child_process");
 var import_core14 = __toESM(require_dist());
 var fs24 = __toESM(require("fs"));
 var path25 = __toESM(require("path"));
@@ -12165,7 +12320,7 @@ function writeToLog(logPath, line, isError = false) {
 }
 async function killProcessOnPort(port) {
   try {
-    const result = (0, import_child_process15.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
+    const result = (0, import_child_process16.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
     if (!result) {
       console.log(`[DevServer] EP929: No process found on port ${port}`);
       return true;
@@ -12174,7 +12329,7 @@ async function killProcessOnPort(port) {
     console.log(`[DevServer] EP929: Found ${pids.length} process(es) on port ${port}: ${pids.join(", ")}`);
     for (const pid of pids) {
       try {
-        (0, import_child_process15.execSync)(`kill -15 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
+        (0, import_child_process16.execSync)(`kill -15 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
         console.log(`[DevServer] EP929: Sent SIGTERM to PID ${pid}`);
       } catch {
       }
@@ -12182,8 +12337,8 @@ async function killProcessOnPort(port) {
     await new Promise((resolve4) => setTimeout(resolve4, 1e3));
     for (const pid of pids) {
       try {
-        (0, import_child_process15.execSync)(`kill -0 ${pid} 2>/dev/null`, { encoding: "utf8" });
-        (0, import_child_process15.execSync)(`kill -9 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
+        (0, import_child_process16.execSync)(`kill -0 ${pid} 2>/dev/null`, { encoding: "utf8" });
+        (0, import_child_process16.execSync)(`kill -9 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
         console.log(`[DevServer] EP929: Force killed PID ${pid}`);
       } catch {
       }
@@ -12234,7 +12389,7 @@ function spawnDevServerProcess(projectPath, port, moduleUid, logPath, customComm
   if (injectedCount > 0) {
     console.log(`[DevServer] EP998: Injecting ${injectedCount} env vars from database`);
   }
-  const devProcess = (0, import_child_process15.spawn)(cmd, args, {
+  const devProcess = (0, import_child_process16.spawn)(cmd, args, {
     cwd: projectPath,
     env: mergedEnv,
     stdio: ["ignore", "pipe", "pipe"],
@@ -12682,11 +12837,11 @@ var IPCRouter = class {
 // src/daemon/update-manager.ts
 var fs25 = __toESM(require("fs"));
 var path26 = __toESM(require("path"));
-var import_child_process17 = require("child_process");
+var import_child_process18 = require("child_process");
 var import_core17 = __toESM(require_dist());
 
 // src/utils/update-checker.ts
-var import_child_process16 = require("child_process");
+var import_child_process17 = require("child_process");
 var semver = __toESM(require("semver"));
 
 // src/ipc/ipc-client.ts
@@ -12697,7 +12852,7 @@ var PACKAGE_NAME = "@episoda/cli";
 var NPM_REGISTRY = "https://registry.npmjs.org";
 function isFileLinkedInstall() {
   try {
-    const output = (0, import_child_process16.execSync)(`npm list -g ${PACKAGE_NAME} --json`, {
+    const output = (0, import_child_process17.execSync)(`npm list -g ${PACKAGE_NAME} --json`, {
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 1e4
     }).toString();
@@ -12741,7 +12896,7 @@ async function checkForUpdates(currentVersion) {
 }
 function performSyncUpdate(targetVersion) {
   try {
-    (0, import_child_process16.execSync)(`npm install -g ${PACKAGE_NAME}@${targetVersion}`, {
+    (0, import_child_process17.execSync)(`npm install -g ${PACKAGE_NAME}@${targetVersion}`, {
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 12e4
       // 2 minute timeout
@@ -12756,7 +12911,7 @@ function performSyncUpdate(targetVersion) {
 }
 function getInstalledVersion() {
   try {
-    const output = (0, import_child_process16.execSync)(`npm list -g ${PACKAGE_NAME} --json`, {
+    const output = (0, import_child_process17.execSync)(`npm list -g ${PACKAGE_NAME} --json`, {
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 1e4
     }).toString();
@@ -12891,7 +13046,7 @@ var UpdateManager = class _UpdateManager {
       const configDir = (0, import_core17.getConfigDir)();
       const logPath = path26.join(configDir, "daemon.log");
       const logFd = fs25.openSync(logPath, "a");
-      const child = (0, import_child_process17.spawn)("node", [this.daemonEntryFile], {
+      const child = (0, import_child_process18.spawn)("node", [this.daemonEntryFile], {
         detached: true,
         stdio: ["ignore", logFd, logFd],
         env: { ...process.env, EPISODA_DAEMON_MODE: "1" }