episoda 0.2.19 → 0.2.21

package/dist/daemon/daemon-process.js

@@ -301,8 +301,8 @@ var require_git_executor = __commonJS({
     var util_1 = require("util");
     var git_validator_1 = require_git_validator();
     var git_parser_1 = require_git_parser();
-    var execAsync = (0, util_1.promisify)(child_process_1.exec);
-    var GitExecutor2 = class {
+    var execAsync2 = (0, util_1.promisify)(child_process_1.exec);
+    var GitExecutor3 = class {
       /**
        * Execute a git command
        * @param command - The git command to execute
@@ -388,6 +388,19 @@ var require_git_executor = __commonJS({
               return await this.executeRebaseContinue(cwd, options);
             case "rebase_status":
               return await this.executeRebaseStatus(cwd, options);
+            // EP944: Worktree operations
+            case "worktree_add":
+              return await this.executeWorktreeAdd(command, cwd, options);
+            case "worktree_remove":
+              return await this.executeWorktreeRemove(command, cwd, options);
+            case "worktree_list":
+              return await this.executeWorktreeList(cwd, options);
+            case "worktree_prune":
+              return await this.executeWorktreePrune(cwd, options);
+            case "clone_bare":
+              return await this.executeCloneBare(command, options);
+            case "project_info":
+              return await this.executeProjectInfo(cwd, options);
             default:
               return {
                 success: false,
@@ -613,7 +626,7 @@ var require_git_executor = __commonJS({
           let isLocal = false;
           let isRemote = false;
           try {
-            const { stdout: localBranches } = await execAsync("git branch --list", { cwd, timeout: options?.timeout || 1e4 });
+            const { stdout: localBranches } = await execAsync2("git branch --list", { cwd, timeout: options?.timeout || 1e4 });
             isLocal = localBranches.split("\n").some((line) => {
               const branchName = line.replace(/^\*?\s*/, "").trim();
               return branchName === command.branch;
@@ -621,7 +634,7 @@ var require_git_executor = __commonJS({
           } catch {
           }
           try {
-            const { stdout: remoteBranches } = await execAsync(`git ls-remote --heads origin ${command.branch}`, { cwd, timeout: options?.timeout || 1e4 });
+            const { stdout: remoteBranches } = await execAsync2(`git ls-remote --heads origin ${command.branch}`, { cwd, timeout: options?.timeout || 1e4 });
             isRemote = remoteBranches.trim().length > 0;
           } catch {
           }
@@ -658,7 +671,7 @@ var require_git_executor = __commonJS({
         }
         const baseBranch = command.baseBranch || "main";
         try {
-          const { stdout } = await execAsync(`git cherry origin/${baseBranch} ${command.branch}`, { cwd, timeout: options?.timeout || 1e4 });
+          const { stdout } = await execAsync2(`git cherry origin/${baseBranch} ${command.branch}`, { cwd, timeout: options?.timeout || 1e4 });
           const uniqueCommits = stdout.trim().split("\n").filter((line) => line.startsWith("+"));
           const hasCommits = uniqueCommits.length > 0;
           return {
@@ -671,7 +684,7 @@ var require_git_executor = __commonJS({
           };
         } catch (error) {
           try {
-            const { stdout } = await execAsync(`git rev-list --count origin/${baseBranch}..${command.branch}`, { cwd, timeout: options?.timeout || 1e4 });
+            const { stdout } = await execAsync2(`git rev-list --count origin/${baseBranch}..${command.branch}`, { cwd, timeout: options?.timeout || 1e4 });
             const commitCount = parseInt(stdout.trim(), 10);
             const hasCommits = commitCount > 0;
             return {
@@ -700,7 +713,7 @@ var require_git_executor = __commonJS({
        */
       async executeFindBranchByPrefix(command, cwd, options) {
         try {
-          const { stdout } = await execAsync("git branch -a", { cwd, timeout: options?.timeout || 1e4 });
+          const { stdout } = await execAsync2("git branch -a", { cwd, timeout: options?.timeout || 1e4 });
           const prefix = command.prefix;
           const branches = stdout.split("\n").map((line) => line.replace(/^[\s*]*/, "").replace("remotes/origin/", "").trim()).filter((branch) => branch && !branch.includes("->"));
           const matchingBranch = branches.find((branch) => branch.startsWith(prefix));
@@ -724,7 +737,7 @@ var require_git_executor = __commonJS({
         try {
           let currentBranch = "";
           try {
-            const { stdout } = await execAsync("git branch --show-current", { cwd, timeout: options?.timeout || 1e4 });
+            const { stdout } = await execAsync2("git branch --show-current", { cwd, timeout: options?.timeout || 1e4 });
             currentBranch = stdout.trim();
           } catch (error) {
             return {
@@ -735,7 +748,7 @@ var require_git_executor = __commonJS({
           }
           let uncommittedFiles = [];
           try {
-            const { stdout } = await execAsync("git status --porcelain", { cwd, timeout: options?.timeout || 1e4 });
+            const { stdout } = await execAsync2("git status --porcelain", { cwd, timeout: options?.timeout || 1e4 });
             if (stdout) {
               uncommittedFiles = stdout.split("\n").filter((line) => line.trim()).map((line) => {
                 const parts = line.trim().split(/\s+/);
@@ -747,7 +760,7 @@ var require_git_executor = __commonJS({
           let localCommits = [];
           if (currentBranch === "main") {
             try {
-              const { stdout } = await execAsync('git log origin/main..HEAD --format="%H|%s|%an"', { cwd, timeout: options?.timeout || 1e4 });
+              const { stdout } = await execAsync2('git log origin/main..HEAD --format="%H|%s|%an"', { cwd, timeout: options?.timeout || 1e4 });
               if (stdout) {
                 localCommits = stdout.split("\n").filter((line) => line.trim()).map((line) => {
                   const [sha, message, author] = line.split("|");
@@ -795,11 +808,11 @@ var require_git_executor = __commonJS({
         try {
           let stdout;
           try {
-            const result = await execAsync(`git log ${baseBranch}.."${command.branch}" --pretty=format:"%H|%an|%ae|%aI|%s" -n ${limit} --`, { cwd, timeout: options?.timeout || 1e4 });
+            const result = await execAsync2(`git log ${baseBranch}.."${command.branch}" --pretty=format:"%H|%an|%ae|%aI|%s" -n ${limit} --`, { cwd, timeout: options?.timeout || 1e4 });
             stdout = result.stdout;
           } catch (error) {
             try {
-              const result = await execAsync(`git log "${command.branch}" --pretty=format:"%H|%an|%ae|%aI|%s" -n ${limit} --`, { cwd, timeout: options?.timeout || 1e4 });
+              const result = await execAsync2(`git log "${command.branch}" --pretty=format:"%H|%an|%ae|%aI|%s" -n ${limit} --`, { cwd, timeout: options?.timeout || 1e4 });
               stdout = result.stdout;
             } catch (branchError) {
               return {
@@ -821,7 +834,7 @@ var require_git_executor = __commonJS({
           const commitLines = stdout.trim().split("\n");
           let remoteShas = /* @__PURE__ */ new Set();
           try {
-            const { stdout: remoteCommits } = await execAsync(`git log "origin/${command.branch}" --pretty=format:"%H" -n ${limit} --`, { cwd, timeout: options?.timeout || 1e4 });
+            const { stdout: remoteCommits } = await execAsync2(`git log "origin/${command.branch}" --pretty=format:"%H" -n ${limit} --`, { cwd, timeout: options?.timeout || 1e4 });
             remoteShas = new Set(remoteCommits.trim().split("\n").filter(Boolean));
           } catch {
           }
@@ -1056,52 +1069,52 @@ var require_git_executor = __commonJS({
         let hasStash = false;
         const cherryPickedCommits = [];
         try {
-          const { stdout: currentBranchOut } = await execAsync("git rev-parse --abbrev-ref HEAD", { cwd });
+          const { stdout: currentBranchOut } = await execAsync2("git rev-parse --abbrev-ref HEAD", { cwd });
           const currentBranch = currentBranchOut.trim();
-          const { stdout: statusOutput } = await execAsync("git status --porcelain", { cwd });
+          const { stdout: statusOutput } = await execAsync2("git status --porcelain", { cwd });
           if (statusOutput.trim()) {
             try {
-              await execAsync("git add -A", { cwd });
-              const { stdout: stashHash } = await execAsync('git stash create -m "episoda-move-to-module"', { cwd });
+              await execAsync2("git add -A", { cwd });
+              const { stdout: stashHash } = await execAsync2('git stash create -m "episoda-move-to-module"', { cwd });
               if (stashHash && stashHash.trim()) {
-                await execAsync(`git stash store -m "episoda-move-to-module" ${stashHash.trim()}`, { cwd });
-                await execAsync("git reset --hard HEAD", { cwd });
+                await execAsync2(`git stash store -m "episoda-move-to-module" ${stashHash.trim()}`, { cwd });
+                await execAsync2("git reset --hard HEAD", { cwd });
                 hasStash = true;
               }
             } catch (stashError) {
             }
           }
           if (commitShas && commitShas.length > 0 && currentBranch !== "main" && currentBranch !== "master") {
-            await execAsync("git checkout main", { cwd });
+            await execAsync2("git checkout main", { cwd });
           }
           let branchExists = false;
           try {
-            await execAsync(`git rev-parse --verify ${targetBranch}`, { cwd });
+            await execAsync2(`git rev-parse --verify ${targetBranch}`, { cwd });
             branchExists = true;
           } catch {
             branchExists = false;
           }
           if (!branchExists) {
-            await execAsync(`git checkout -b ${targetBranch}`, { cwd });
+            await execAsync2(`git checkout -b ${targetBranch}`, { cwd });
           } else {
-            await execAsync(`git checkout ${targetBranch}`, { cwd });
+            await execAsync2(`git checkout ${targetBranch}`, { cwd });
             if (currentBranch === "main" || currentBranch === "master") {
               try {
                 const mergeStrategy = conflictResolution === "ours" ? "--strategy=ours" : conflictResolution === "theirs" ? "--strategy-option=theirs" : "";
-                await execAsync(`git merge ${currentBranch} ${mergeStrategy} --no-edit`, { cwd });
+                await execAsync2(`git merge ${currentBranch} ${mergeStrategy} --no-edit`, { cwd });
               } catch (mergeError) {
-                const { stdout: conflictStatus } = await execAsync("git status --porcelain", { cwd });
+                const { stdout: conflictStatus } = await execAsync2("git status --porcelain", { cwd });
                 if (conflictStatus.includes("UU ") || conflictStatus.includes("AA ") || conflictStatus.includes("DD ")) {
-                  const { stdout: conflictFiles } = await execAsync("git diff --name-only --diff-filter=U", { cwd });
+                  const { stdout: conflictFiles } = await execAsync2("git diff --name-only --diff-filter=U", { cwd });
                   const conflictedFiles = conflictFiles.trim().split("\n").filter(Boolean);
                   if (conflictResolution) {
                     for (const file of conflictedFiles) {
-                      await execAsync(`git checkout --${conflictResolution} "${file}"`, { cwd });
-                      await execAsync(`git add "${file}"`, { cwd });
+                      await execAsync2(`git checkout --${conflictResolution} "${file}"`, { cwd });
+                      await execAsync2(`git add "${file}"`, { cwd });
                     }
-                    await execAsync("git commit --no-edit", { cwd });
+                    await execAsync2("git commit --no-edit", { cwd });
                   } else {
-                    await execAsync("git merge --abort", { cwd });
+                    await execAsync2("git merge --abort", { cwd });
                     return {
                       success: false,
                       error: "MERGE_CONFLICT",
@@ -1120,32 +1133,32 @@ var require_git_executor = __commonJS({
           if (commitShas && commitShas.length > 0 && (currentBranch === "main" || currentBranch === "master")) {
             for (const sha of commitShas) {
               try {
-                const { stdout: logOutput } = await execAsync(`git log --format=%H ${targetBranch} | grep ${sha}`, { cwd }).catch(() => ({ stdout: "" }));
+                const { stdout: logOutput } = await execAsync2(`git log --format=%H ${targetBranch} | grep ${sha}`, { cwd }).catch(() => ({ stdout: "" }));
                 if (!logOutput.trim()) {
-                  await execAsync(`git cherry-pick ${sha}`, { cwd });
+                  await execAsync2(`git cherry-pick ${sha}`, { cwd });
                   cherryPickedCommits.push(sha);
                 }
               } catch (err) {
-                await execAsync("git cherry-pick --abort", { cwd }).catch(() => {
+                await execAsync2("git cherry-pick --abort", { cwd }).catch(() => {
                 });
               }
             }
-            await execAsync("git checkout main", { cwd });
-            await execAsync("git reset --hard origin/main", { cwd });
-            await execAsync(`git checkout ${targetBranch}`, { cwd });
+            await execAsync2("git checkout main", { cwd });
+            await execAsync2("git reset --hard origin/main", { cwd });
+            await execAsync2(`git checkout ${targetBranch}`, { cwd });
           }
           if (hasStash) {
             try {
-              await execAsync("git stash pop", { cwd });
+              await execAsync2("git stash pop", { cwd });
             } catch (stashError) {
-              const { stdout: conflictStatus } = await execAsync("git status --porcelain", { cwd });
+              const { stdout: conflictStatus } = await execAsync2("git status --porcelain", { cwd });
               if (conflictStatus.includes("UU ") || conflictStatus.includes("AA ")) {
                 if (conflictResolution) {
-                  const { stdout: conflictFiles } = await execAsync("git diff --name-only --diff-filter=U", { cwd });
+                  const { stdout: conflictFiles } = await execAsync2("git diff --name-only --diff-filter=U", { cwd });
                   const conflictedFiles = conflictFiles.trim().split("\n").filter(Boolean);
                   for (const file of conflictedFiles) {
-                    await execAsync(`git checkout --${conflictResolution} "${file}"`, { cwd });
-                    await execAsync(`git add "${file}"`, { cwd });
+                    await execAsync2(`git checkout --${conflictResolution} "${file}"`, { cwd });
+                    await execAsync2(`git add "${file}"`, { cwd });
                   }
                 }
               }
@@ -1163,9 +1176,9 @@ var require_git_executor = __commonJS({
         } catch (error) {
           if (hasStash) {
             try {
-              const { stdout: stashList } = await execAsync("git stash list", { cwd });
+              const { stdout: stashList } = await execAsync2("git stash list", { cwd });
               if (stashList.includes("episoda-move-to-module")) {
-                await execAsync("git stash pop", { cwd });
+                await execAsync2("git stash pop", { cwd });
               }
             } catch (e) {
             }
@@ -1183,7 +1196,7 @@ var require_git_executor = __commonJS({
        */
       async executeDiscardMainChanges(cwd, options) {
         try {
-          const { stdout: currentBranchOut } = await execAsync("git rev-parse --abbrev-ref HEAD", { cwd });
+          const { stdout: currentBranchOut } = await execAsync2("git rev-parse --abbrev-ref HEAD", { cwd });
           const branch = currentBranchOut.trim();
           if (branch !== "main" && branch !== "master") {
             return {
@@ -1193,22 +1206,22 @@ var require_git_executor = __commonJS({
             };
           }
           let discardedFiles = 0;
-          const { stdout: statusOutput } = await execAsync("git status --porcelain", { cwd });
+          const { stdout: statusOutput } = await execAsync2("git status --porcelain", { cwd });
           if (statusOutput.trim()) {
             try {
-              await execAsync("git stash --include-untracked", { cwd });
+              await execAsync2("git stash --include-untracked", { cwd });
               discardedFiles = statusOutput.trim().split("\n").length;
             } catch (stashError) {
             }
           }
-          await execAsync("git fetch origin", { cwd });
-          await execAsync(`git reset --hard origin/${branch}`, { cwd });
+          await execAsync2("git fetch origin", { cwd });
+          await execAsync2(`git reset --hard origin/${branch}`, { cwd });
           try {
-            await execAsync("git clean -fd", { cwd });
+            await execAsync2("git clean -fd", { cwd });
           } catch (cleanError) {
           }
           try {
-            await execAsync("git stash drop", { cwd });
+            await execAsync2("git stash drop", { cwd });
           } catch (dropError) {
           }
           return {
@@ -1244,7 +1257,7 @@ var require_git_executor = __commonJS({
             };
           }
           try {
-            await execAsync("git fetch origin", { cwd, timeout: options?.timeout || 3e4 });
+            await execAsync2("git fetch origin", { cwd, timeout: options?.timeout || 3e4 });
           } catch (fetchError) {
             return {
               success: false,
@@ -1255,13 +1268,13 @@ var require_git_executor = __commonJS({
           let commitsBehind = 0;
           let commitsAhead = 0;
           try {
-            const { stdout: behindOutput } = await execAsync(`git rev-list --count ${command.branch}..origin/main`, { cwd, timeout: options?.timeout || 1e4 });
+            const { stdout: behindOutput } = await execAsync2(`git rev-list --count ${command.branch}..origin/main`, { cwd, timeout: options?.timeout || 1e4 });
             commitsBehind = parseInt(behindOutput.trim(), 10) || 0;
           } catch {
             commitsBehind = 0;
           }
           try {
-            const { stdout: aheadOutput } = await execAsync(`git rev-list --count origin/main..${command.branch}`, { cwd, timeout: options?.timeout || 1e4 });
+            const { stdout: aheadOutput } = await execAsync2(`git rev-list --count origin/main..${command.branch}`, { cwd, timeout: options?.timeout || 1e4 });
             commitsAhead = parseInt(aheadOutput.trim(), 10) || 0;
           } catch {
             commitsAhead = 0;
@@ -1297,12 +1310,12 @@ var require_git_executor = __commonJS({
         try {
           let currentBranch = "";
           try {
-            const { stdout } = await execAsync("git branch --show-current", { cwd, timeout: 5e3 });
+            const { stdout } = await execAsync2("git branch --show-current", { cwd, timeout: 5e3 });
             currentBranch = stdout.trim();
           } catch {
           }
           try {
-            await execAsync("git fetch origin main", { cwd, timeout: options?.timeout || 3e4 });
+            await execAsync2("git fetch origin main", { cwd, timeout: options?.timeout || 3e4 });
           } catch (fetchError) {
             return {
               success: false,
@@ -1312,7 +1325,7 @@ var require_git_executor = __commonJS({
           }
           const needsSwitch = currentBranch !== "main" && currentBranch !== "";
           if (needsSwitch) {
-            const { stdout: statusOutput } = await execAsync("git status --porcelain", { cwd, timeout: 5e3 });
+            const { stdout: statusOutput } = await execAsync2("git status --porcelain", { cwd, timeout: 5e3 });
             if (statusOutput.trim()) {
               return {
                 success: false,
@@ -1323,13 +1336,13 @@ var require_git_executor = __commonJS({
                 }
               };
             }
-            await execAsync("git checkout main", { cwd, timeout: options?.timeout || 1e4 });
+            await execAsync2("git checkout main", { cwd, timeout: options?.timeout || 1e4 });
           }
           try {
-            await execAsync("git pull origin main", { cwd, timeout: options?.timeout || 3e4 });
+            await execAsync2("git pull origin main", { cwd, timeout: options?.timeout || 3e4 });
           } catch (pullError) {
             if (pullError.message?.includes("CONFLICT") || pullError.stderr?.includes("CONFLICT")) {
-              await execAsync("git merge --abort", { cwd, timeout: 5e3 }).catch(() => {
+              await execAsync2("git merge --abort", { cwd, timeout: 5e3 }).catch(() => {
               });
               return {
                 success: false,
@@ -1340,7 +1353,7 @@ var require_git_executor = __commonJS({
             throw pullError;
           }
           if (needsSwitch && currentBranch) {
-            await execAsync(`git checkout "${currentBranch}"`, { cwd, timeout: options?.timeout || 1e4 });
+            await execAsync2(`git checkout "${currentBranch}"`, { cwd, timeout: options?.timeout || 1e4 });
           }
           return {
             success: true,
@@ -1370,7 +1383,7 @@ var require_git_executor = __commonJS({
               error: validation.error || "UNKNOWN_ERROR"
             };
           }
-          const { stdout: statusOutput } = await execAsync("git status --porcelain", { cwd, timeout: 5e3 });
+          const { stdout: statusOutput } = await execAsync2("git status --porcelain", { cwd, timeout: 5e3 });
           if (statusOutput.trim()) {
             return {
               success: false,
@@ -1381,24 +1394,24 @@ var require_git_executor = __commonJS({
               }
             };
           }
-          const { stdout: currentBranchOut } = await execAsync("git branch --show-current", { cwd, timeout: 5e3 });
+          const { stdout: currentBranchOut } = await execAsync2("git branch --show-current", { cwd, timeout: 5e3 });
           const currentBranch = currentBranchOut.trim();
           if (currentBranch !== command.branch) {
-            await execAsync(`git checkout "${command.branch}"`, { cwd, timeout: options?.timeout || 1e4 });
+            await execAsync2(`git checkout "${command.branch}"`, { cwd, timeout: options?.timeout || 1e4 });
           }
-          await execAsync("git fetch origin main", { cwd, timeout: options?.timeout || 3e4 });
+          await execAsync2("git fetch origin main", { cwd, timeout: options?.timeout || 3e4 });
           try {
-            await execAsync("git rebase origin/main", { cwd, timeout: options?.timeout || 6e4 });
+            await execAsync2("git rebase origin/main", { cwd, timeout: options?.timeout || 6e4 });
           } catch (rebaseError) {
             const errorOutput = (rebaseError.stderr || "") + (rebaseError.stdout || "");
             if (errorOutput.includes("CONFLICT") || errorOutput.includes("could not apply")) {
               let conflictFiles = [];
               try {
-                const { stdout: conflictOutput } = await execAsync("git diff --name-only --diff-filter=U", { cwd, timeout: 5e3 });
+                const { stdout: conflictOutput } = await execAsync2("git diff --name-only --diff-filter=U", { cwd, timeout: 5e3 });
                 conflictFiles = conflictOutput.trim().split("\n").filter(Boolean);
               } catch {
                 try {
-                  const { stdout: statusOut } = await execAsync("git status --porcelain", { cwd, timeout: 5e3 });
+                  const { stdout: statusOut } = await execAsync2("git status --porcelain", { cwd, timeout: 5e3 });
                   conflictFiles = statusOut.trim().split("\n").filter((line) => line.startsWith("UU ") || line.startsWith("AA ") || line.startsWith("DD ")).map((line) => line.slice(3));
                 } catch {
                 }
@@ -1439,7 +1452,7 @@ var require_git_executor = __commonJS({
        */
       async executeRebaseAbort(cwd, options) {
         try {
-          await execAsync("git rebase --abort", { cwd, timeout: options?.timeout || 1e4 });
+          await execAsync2("git rebase --abort", { cwd, timeout: options?.timeout || 1e4 });
           return {
             success: true,
             output: "Rebase aborted. Your branch has been restored to its previous state.",
@@ -1469,8 +1482,8 @@ var require_git_executor = __commonJS({
        */
       async executeRebaseContinue(cwd, options) {
         try {
-          await execAsync("git add -A", { cwd, timeout: 5e3 });
-          await execAsync("git rebase --continue", { cwd, timeout: options?.timeout || 6e4 });
+          await execAsync2("git add -A", { cwd, timeout: 5e3 });
+          await execAsync2("git rebase --continue", { cwd, timeout: options?.timeout || 6e4 });
           return {
             success: true,
             output: "Rebase continued successfully.",
@@ -1483,7 +1496,7 @@ var require_git_executor = __commonJS({
           if (errorOutput.includes("CONFLICT") || errorOutput.includes("could not apply")) {
             let conflictFiles = [];
             try {
-              const { stdout: conflictOutput } = await execAsync("git diff --name-only --diff-filter=U", { cwd, timeout: 5e3 });
+              const { stdout: conflictOutput } = await execAsync2("git diff --name-only --diff-filter=U", { cwd, timeout: 5e3 });
               conflictFiles = conflictOutput.trim().split("\n").filter(Boolean);
             } catch {
             }
@@ -1523,17 +1536,17 @@ var require_git_executor = __commonJS({
           let inRebase = false;
           let rebaseConflicts = [];
           try {
-            const { stdout: gitDir } = await execAsync("git rev-parse --git-dir", { cwd, timeout: 5e3 });
+            const { stdout: gitDir } = await execAsync2("git rev-parse --git-dir", { cwd, timeout: 5e3 });
             const gitDirPath = gitDir.trim();
-            const fs12 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+            const fs14 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
             const rebaseMergePath = `${gitDirPath}/rebase-merge`;
             const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
             try {
-              await fs12.access(rebaseMergePath);
+              await fs14.access(rebaseMergePath);
               inRebase = true;
             } catch {
               try {
-                await fs12.access(rebaseApplyPath);
+                await fs14.access(rebaseApplyPath);
                 inRebase = true;
               } catch {
                 inRebase = false;
@@ -1541,7 +1554,7 @@ var require_git_executor = __commonJS({
             }
           } catch {
             try {
-              const { stdout: statusOutput } = await execAsync("git status", { cwd, timeout: 5e3 });
+              const { stdout: statusOutput } = await execAsync2("git status", { cwd, timeout: 5e3 });
               inRebase = statusOutput.includes("rebase in progress") || statusOutput.includes("interactive rebase in progress") || statusOutput.includes("You are currently rebasing");
             } catch {
               inRebase = false;
@@ -1549,7 +1562,7 @@ var require_git_executor = __commonJS({
           }
           if (inRebase) {
             try {
-              const { stdout: conflictOutput } = await execAsync("git diff --name-only --diff-filter=U", { cwd, timeout: 5e3 });
+              const { stdout: conflictOutput } = await execAsync2("git diff --name-only --diff-filter=U", { cwd, timeout: 5e3 });
               rebaseConflicts = conflictOutput.trim().split("\n").filter(Boolean);
             } catch {
             }
@@ -1571,6 +1584,328 @@ var require_git_executor = __commonJS({
           };
         }
       }
+      // ========================================
+      // EP944: Worktree operations
+      // ========================================
+      /**
+       * EP944: Add a new worktree for a branch
+       * Creates a new working tree at the specified path
+       */
+      async executeWorktreeAdd(command, cwd, options) {
+        try {
+          const validation = (0, git_validator_1.validateBranchName)(command.branch);
+          if (!validation.valid) {
+            return {
+              success: false,
+              error: validation.error || "UNKNOWN_ERROR"
+            };
+          }
+          const fs14 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          try {
+            await fs14.access(command.path);
+            return {
+              success: false,
+              error: "WORKTREE_EXISTS",
+              output: `Worktree already exists at path: ${command.path}`
+            };
+          } catch {
+          }
+          try {
+            await this.runGitCommand(["fetch", "--all", "--prune"], cwd, options);
+          } catch {
+          }
+          const args = ["worktree", "add"];
+          if (command.create) {
+            args.push("-b", command.branch, command.path);
+          } else {
+            args.push(command.path, command.branch);
+          }
+          const result = await this.runGitCommand(args, cwd, options);
+          if (result.success) {
+            return {
+              success: true,
+              output: `Created worktree at ${command.path} for branch ${command.branch}`,
+              details: {
+                worktreePath: command.path,
+                branchName: command.branch
+              }
+            };
+          }
+          if (result.output?.includes("already checked out")) {
+            return {
+              success: false,
+              error: "BRANCH_IN_USE",
+              output: `Branch '${command.branch}' is already checked out in another worktree`
+            };
+          }
+          return result;
+        } catch (error) {
+          return {
+            success: false,
+            error: "UNKNOWN_ERROR",
+            output: error.message || "Failed to add worktree"
+          };
+        }
+      }
+      /**
+       * EP944: Remove a worktree
+       * Removes the working tree at the specified path
+       */
+      async executeWorktreeRemove(command, cwd, options) {
+        try {
+          const fs14 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          try {
+            await fs14.access(command.path);
+          } catch {
+            return {
+              success: false,
+              error: "WORKTREE_NOT_FOUND",
+              output: `Worktree not found at path: ${command.path}`
+            };
+          }
+          if (!command.force) {
+            try {
+              const { stdout } = await execAsync2("git status --porcelain", {
+                cwd: command.path,
+                timeout: options?.timeout || 1e4
+              });
+              if (stdout.trim()) {
+                return {
+                  success: false,
+                  error: "UNCOMMITTED_CHANGES",
+                  output: "Worktree has uncommitted changes. Use force to remove anyway.",
+                  details: {
+                    uncommittedFiles: stdout.trim().split("\n").map((line) => line.slice(3))
+                  }
+                };
+              }
+            } catch {
+            }
+          }
+          const args = ["worktree", "remove"];
+          if (command.force) {
+            args.push("--force");
+          }
+          args.push(command.path);
+          const result = await this.runGitCommand(args, cwd, options);
+          if (result.success) {
+            return {
+              success: true,
+              output: `Removed worktree at ${command.path}`,
+              details: {
+                worktreePath: command.path
+              }
+            };
+          }
+          if (result.output?.includes("locked")) {
+            return {
+              success: false,
+              error: "WORKTREE_LOCKED",
+              output: `Worktree at ${command.path} is locked`
+            };
+          }
+          return result;
+        } catch (error) {
+          return {
+            success: false,
+            error: "UNKNOWN_ERROR",
+            output: error.message || "Failed to remove worktree"
+          };
+        }
+      }
+      /**
+       * EP944: List all worktrees
+       * Returns information about all worktrees in the repository
+       */
+      async executeWorktreeList(cwd, options) {
+        try {
+          const { stdout } = await execAsync2("git worktree list --porcelain", {
+            cwd,
+            timeout: options?.timeout || 1e4
+          });
+          const worktrees = [];
+          const lines = stdout.trim().split("\n");
+          let current = {};
+          for (const line of lines) {
+            if (line.startsWith("worktree ")) {
+              current.path = line.slice(9);
+            } else if (line.startsWith("HEAD ")) {
+              current.commit = line.slice(5);
+            } else if (line.startsWith("branch ")) {
+              const refPath = line.slice(7);
+              current.branch = refPath.replace("refs/heads/", "");
+            } else if (line === "locked") {
+              current.locked = true;
+            } else if (line === "prunable") {
+              current.prunable = true;
+            } else if (line.startsWith("detached")) {
+              current.branch = "HEAD (detached)";
+            } else if (line === "" && current.path) {
+              worktrees.push({
+                path: current.path,
+                branch: current.branch || "unknown",
+                commit: current.commit || "",
+                locked: current.locked,
+                prunable: current.prunable
+              });
+              current = {};
+            }
+          }
+          if (current.path) {
+            worktrees.push({
+              path: current.path,
+              branch: current.branch || "unknown",
+              commit: current.commit || "",
+              locked: current.locked,
+              prunable: current.prunable
+            });
+          }
+          return {
+            success: true,
+            output: `Found ${worktrees.length} worktree(s)`,
+            details: {
+              worktrees
+            }
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: "UNKNOWN_ERROR",
+            output: error.message || "Failed to list worktrees"
+          };
+        }
+      }
+      /**
+       * EP944: Prune stale worktrees
+       * Removes worktree administrative files for worktrees whose directories are missing
+       */
+      async executeWorktreePrune(cwd, options) {
+        try {
+          const listResult = await this.executeWorktreeList(cwd, options);
+          const prunableCount = listResult.details?.worktrees?.filter((w) => w.prunable).length || 0;
+          const result = await this.runGitCommand(["worktree", "prune"], cwd, options);
+          if (result.success) {
+            return {
+              success: true,
+              output: prunableCount > 0 ? `Pruned ${prunableCount} stale worktree(s)` : "No stale worktrees to prune",
+              details: {
+                prunedCount: prunableCount
+              }
+            };
+          }
+          return result;
+        } catch (error) {
+          return {
+            success: false,
+            error: "UNKNOWN_ERROR",
+            output: error.message || "Failed to prune worktrees"
+          };
+        }
+      }
+      /**
+       * EP944: Clone a repository as a bare repository
+       * Used for worktree-based development setup
+       */
+      async executeCloneBare(command, options) {
+        try {
+          const fs14 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path15 = await Promise.resolve().then(() => __importStar(require("path")));
+          try {
+            await fs14.access(command.path);
+            return {
+              success: false,
+              error: "BRANCH_ALREADY_EXISTS",
+              // Reusing for path exists
+              output: `Directory already exists at path: ${command.path}`
+            };
+          } catch {
+          }
+          const parentDir = path15.dirname(command.path);
+          try {
+            await fs14.mkdir(parentDir, { recursive: true });
+          } catch {
+          }
+          const { stdout, stderr } = await execAsync2(
+            `git clone --bare "${command.url}" "${command.path}"`,
+            { timeout: options?.timeout || 12e4 }
+            // 2 minutes for clone
+          );
+          return {
+            success: true,
+            output: `Cloned bare repository to ${command.path}`,
+            details: {
+              worktreePath: command.path
+            }
+          };
+        } catch (error) {
+          if (error.message?.includes("Authentication") || error.message?.includes("Permission denied")) {
+            return {
+              success: false,
+              error: "AUTH_FAILURE",
+              output: "Authentication failed. Please check your credentials."
+            };
+          }
+          if (error.message?.includes("Could not resolve") || error.message?.includes("unable to access")) {
+            return {
+              success: false,
+              error: "NETWORK_ERROR",
+              output: "Network error. Please check your connection."
+            };
+          }
+          return {
+            success: false,
+            error: "UNKNOWN_ERROR",
+            output: error.message || "Failed to clone repository"
+          };
+        }
+      }
+      /**
+       * EP944: Get project info including worktree mode
+       * Returns information about the project configuration
+       */
+      async executeProjectInfo(cwd, options) {
+        try {
+          const fs14 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path15 = await Promise.resolve().then(() => __importStar(require("path")));
+          let currentPath = cwd;
+          let worktreeMode = false;
+          let projectPath = cwd;
+          let bareRepoPath;
+          for (let i = 0; i < 10; i++) {
+            const bareDir = path15.join(currentPath, ".bare");
+            const episodaDir = path15.join(currentPath, ".episoda");
+            try {
+              await fs14.access(bareDir);
+              await fs14.access(episodaDir);
+              worktreeMode = true;
+              projectPath = currentPath;
+              bareRepoPath = bareDir;
+              break;
+            } catch {
+              const parentPath = path15.dirname(currentPath);
+              if (parentPath === currentPath) {
+                break;
+              }
+              currentPath = parentPath;
+            }
+          }
+          return {
+            success: true,
+            output: worktreeMode ? "Worktree mode project" : "Standard git project",
+            details: {
+              worktreeMode,
+              projectPath,
+              bareRepoPath
+            }
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: "UNKNOWN_ERROR",
+            output: error.message || "Failed to get project info"
+          };
+        }
+      }
       /**
        * Run a git command and return structured result
        */
@@ -1586,7 +1921,7 @@ var require_git_executor = __commonJS({
             maxBuffer: 1024 * 1024 * 10
             // 10MB buffer
           };
-          const { stdout, stderr } = await execAsync(command, execOptions);
+          const { stdout, stderr } = await execAsync2(command, execOptions);
           const output = (stdout + stderr).trim();
           const details = {};
           const branchName = (0, git_parser_1.extractBranchName)(output);
@@ -1637,7 +1972,7 @@ var require_git_executor = __commonJS({
        */
       async validateGitInstalled() {
         try {
-          await execAsync("git --version", { timeout: 5e3 });
+          await execAsync2("git --version", { timeout: 5e3 });
           return true;
         } catch {
           return false;
@@ -1648,7 +1983,7 @@ var require_git_executor = __commonJS({
        */
       async isGitRepository(cwd) {
         try {
-          await execAsync("git rev-parse --git-dir", { cwd, timeout: 5e3 });
+          await execAsync2("git rev-parse --git-dir", { cwd, timeout: 5e3 });
           return true;
         } catch {
           return false;
@@ -1660,7 +1995,7 @@ var require_git_executor = __commonJS({
        */
       async detectWorkingDirectory(startPath) {
         try {
-          const { stdout } = await execAsync("git rev-parse --show-toplevel", {
+          const { stdout } = await execAsync2("git rev-parse --show-toplevel", {
             cwd: startPath || process.cwd(),
             timeout: 5e3
           });
@@ -1670,7 +2005,7 @@ var require_git_executor = __commonJS({
         }
       }
     };
-    exports2.GitExecutor = GitExecutor2;
+    exports2.GitExecutor = GitExecutor3;
   }
 });
 
@@ -1761,7 +2096,7 @@ var require_websocket_client = __commonJS({
           clearTimeout(this.reconnectTimeout);
           this.reconnectTimeout = void 0;
         }
-        return new Promise((resolve2, reject) => {
+        return new Promise((resolve3, reject) => {
           const connectionTimeout = setTimeout(() => {
             if (this.ws) {
               this.ws.terminate();
@@ -1788,7 +2123,7 @@ var require_websocket_client = __commonJS({
                 daemonPid: this.daemonPid
               });
               this.startHeartbeat();
-              resolve2();
+              resolve3();
             });
             this.ws.on("pong", () => {
               if (this.heartbeatTimeoutTimer) {
@@ -1904,13 +2239,13 @@ var require_websocket_client = __commonJS({
         if (!this.ws || !this.isConnected) {
           throw new Error("WebSocket not connected");
         }
-        return new Promise((resolve2, reject) => {
+        return new Promise((resolve3, reject) => {
           this.ws.send(JSON.stringify(message), (error) => {
             if (error) {
               console.error("[EpisodaClient] Failed to send message:", error);
               reject(error);
             } else {
-              resolve2();
+              resolve3();
             }
           });
         });
@@ -2023,12 +2358,13 @@ var require_websocket_client = __commonJS({
             console.log(`[EpisodaClient] Server restarting, reconnecting in ${delay}ms (attempt ${this.reconnectAttempts + 1}/7)`);
           }
         } else {
-          if (this.reconnectAttempts >= 1) {
-            console.error('[EpisodaClient] Connection lost. Retry failed. Check server status or restart with "episoda dev".');
+          const MAX_NON_GRACEFUL_RETRIES = 5;
+          if (this.reconnectAttempts >= MAX_NON_GRACEFUL_RETRIES) {
+            console.error(`[EpisodaClient] Connection lost. Reconnection failed after ${MAX_NON_GRACEFUL_RETRIES} attempts. Check server status or restart with "episoda dev".`);
             shouldRetry = false;
           } else {
-            delay = 1e3;
-            console.log("[EpisodaClient] Connection lost, retrying in 1 second...");
+            delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 16e3);
+            console.log(`[EpisodaClient] Connection lost, retrying in ${delay / 1e3}s... (attempt ${this.reconnectAttempts + 1}/${MAX_NON_GRACEFUL_RETRIES})`);
           }
         }
         if (!shouldRetry) {
@@ -2138,34 +2474,34 @@ var require_auth = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.getConfigDir = getConfigDir6;
     exports2.getConfigPath = getConfigPath;
-    exports2.loadConfig = loadConfig3;
+    exports2.loadConfig = loadConfig5;
     exports2.saveConfig = saveConfig2;
     exports2.validateToken = validateToken;
-    var fs12 = __importStar(require("fs"));
-    var path13 = __importStar(require("path"));
-    var os5 = __importStar(require("os"));
+    var fs14 = __importStar(require("fs"));
+    var path15 = __importStar(require("path"));
+    var os6 = __importStar(require("os"));
     var child_process_1 = require("child_process");
     var DEFAULT_CONFIG_FILE = "config.json";
     function getConfigDir6() {
-      return process.env.EPISODA_CONFIG_DIR || path13.join(os5.homedir(), ".episoda");
+      return process.env.EPISODA_CONFIG_DIR || path15.join(os6.homedir(), ".episoda");
     }
     function getConfigPath(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path13.join(getConfigDir6(), DEFAULT_CONFIG_FILE);
+      return path15.join(getConfigDir6(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path13.dirname(configPath);
-      const isNew = !fs12.existsSync(dir);
+      const dir = path15.dirname(configPath);
+      const isNew = !fs14.existsSync(dir);
       if (isNew) {
-        fs12.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs14.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path13.join(dir, ".nosync");
-        if (isNew || !fs12.existsSync(nosyncPath)) {
+        const nosyncPath = path15.join(dir, ".nosync");
+        if (isNew || !fs14.existsSync(nosyncPath)) {
           try {
-            fs12.writeFileSync(nosyncPath, "", { mode: 384 });
+            fs14.writeFileSync(nosyncPath, "", { mode: 384 });
             (0, child_process_1.execSync)(`xattr -w com.apple.fileprovider.ignore 1 "${dir}"`, {
               stdio: "ignore",
               timeout: 5e3
@@ -2175,13 +2511,13 @@ var require_auth = __commonJS({
         }
       }
     }
-    async function loadConfig3(configPath) {
+    async function loadConfig5(configPath) {
       const fullPath = getConfigPath(configPath);
-      if (!fs12.existsSync(fullPath)) {
+      if (!fs14.existsSync(fullPath)) {
         return null;
       }
       try {
-        const content = fs12.readFileSync(fullPath, "utf8");
+        const content = fs14.readFileSync(fullPath, "utf8");
         const config = JSON.parse(content);
         return config;
       } catch (error) {
@@ -2194,7 +2530,7 @@ var require_auth = __commonJS({
       ensureConfigDir(fullPath);
       try {
         const content = JSON.stringify(config, null, 2);
-        fs12.writeFileSync(fullPath, content, { mode: 384 });
+        fs14.writeFileSync(fullPath, content, { mode: 384 });
       } catch (error) {
         throw new Error(`Failed to save config: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -2234,6 +2570,11 @@ var require_errors = __commonJS({
         "BRANCH_ALREADY_EXISTS": "Branch already exists",
         "PUSH_REJECTED": "Push rejected by remote",
         "COMMAND_TIMEOUT": "Command timed out",
+        // EP944: Worktree error messages
+        "WORKTREE_EXISTS": "Worktree already exists at this path",
+        "WORKTREE_NOT_FOUND": "Worktree not found at this path",
+        "WORKTREE_LOCKED": "Worktree is locked",
+        "BRANCH_IN_USE": "Branch is already checked out in another worktree",
         "UNKNOWN_ERROR": "Unknown error occurred"
       };
       let message = messages[code] || `Error: ${code}`;
@@ -2305,18 +2646,18 @@ __export(port_check_exports, {
   isPortInUse: () => isPortInUse
 });
 async function isPortInUse(port) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const server = net2.createServer();
     server.once("error", (err) => {
       if (err.code === "EADDRINUSE") {
-        resolve2(true);
+        resolve3(true);
       } else {
-        resolve2(false);
+        resolve3(false);
       }
     });
     server.once("listening", () => {
       server.close();
-      resolve2(false);
+      resolve3(false);
     });
     server.listen(port);
   });
@@ -2340,7 +2681,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.18",
+      version: "0.2.20",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -2535,13 +2876,19 @@ function writeProjects(data) {
     throw new Error(`Failed to write projects.json: ${error}`);
   }
 }
-function addProject(projectId, projectPath) {
+function addProject(projectId, projectPath, options) {
   const data = readProjects();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const existingByPath = data.projects.find((p) => p.path === projectPath);
   if (existingByPath) {
     existingByPath.id = projectId;
     existingByPath.last_active = now;
+    if (options?.worktreeMode !== void 0) {
+      existingByPath.worktreeMode = options.worktreeMode;
+    }
+    if (options?.bareRepoPath) {
+      existingByPath.bareRepoPath = options.bareRepoPath;
+    }
     writeProjects(data);
     return existingByPath;
   }
@@ -2557,7 +2904,10 @@ function addProject(projectId, projectPath) {
     path: projectPath,
     name: projectName,
     added_at: now,
-    last_active: now
+    last_active: now,
+    // EP944: Worktree mode fields
+    worktreeMode: options?.worktreeMode,
+    bareRepoPath: options?.bareRepoPath
   };
   data.projects.push(newProject);
   writeProjects(data);
@@ -2630,10 +2980,10 @@ var IPCServer = class {
     this.server = net.createServer((socket) => {
       this.handleConnection(socket);
     });
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       this.server.listen(socketPath, () => {
         fs3.chmodSync(socketPath, 384);
-        resolve2();
+        resolve3();
       });
       this.server.on("error", reject);
     });
@@ -2644,12 +2994,12 @@ var IPCServer = class {
   async stop() {
     if (!this.server) return;
     const socketPath = getSocketPath();
-    return new Promise((resolve2) => {
+    return new Promise((resolve3) => {
       this.server.close(() => {
         if (fs3.existsSync(socketPath)) {
           fs3.unlinkSync(socketPath);
         }
-        resolve2();
+        resolve3();
       });
     });
   }
@@ -2711,7 +3061,7 @@ var IPCServer = class {
 };
 
 // src/daemon/daemon-process.ts
-var import_core7 = __toESM(require_dist());
+var import_core10 = __toESM(require_dist());
 
 // src/utils/update-checker.ts
 var import_child_process2 = require("child_process");
@@ -3300,7 +3650,7 @@ async function handleExec(command, projectPath) {
     env = {}
   } = command;
   const effectiveTimeout = Math.min(Math.max(timeout, 1e3), MAX_TIMEOUT);
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     let stdout = "";
     let stderr = "";
     let timedOut = false;
@@ -3308,7 +3658,7 @@ async function handleExec(command, projectPath) {
     const done = (result) => {
       if (resolved) return;
       resolved = true;
-      resolve2(result);
+      resolve3(result);
     };
     try {
       const proc = (0, import_child_process3.spawn)(cmd, {
@@ -3371,8 +3721,103 @@ async function handleExec(command, projectPath) {
   });
 }
 
-// src/tunnel/cloudflared-manager.ts
+// src/daemon/handlers/stale-commit-cleanup.ts
 var import_child_process4 = require("child_process");
+var import_util = require("util");
+var import_core5 = __toESM(require_dist());
+var execAsync = (0, import_util.promisify)(import_child_process4.exec);
+async function cleanupStaleCommits(projectPath) {
+  try {
+    const machineId = await getMachineId();
+    const config = await (0, import_core5.loadConfig)();
+    if (!config?.access_token) {
+      return {
+        success: false,
+        deleted_count: 0,
+        kept_count: 0,
+        message: "No access token available"
+      };
+    }
+    try {
+      await execAsync("git fetch origin", { cwd: projectPath, timeout: 3e4 });
+    } catch (fetchError) {
+      console.warn("[EP950] Could not fetch origin:", fetchError);
+    }
+    let currentBranch = "";
+    try {
+      const { stdout } = await execAsync("git branch --show-current", { cwd: projectPath, timeout: 5e3 });
+      currentBranch = stdout.trim();
+    } catch {
+      return {
+        success: false,
+        deleted_count: 0,
+        kept_count: 0,
+        message: "Could not determine current branch"
+      };
+    }
+    if (currentBranch !== "main" && currentBranch !== "master") {
+      return {
+        success: true,
+        deleted_count: 0,
+        kept_count: 0,
+        message: `Not on main branch (on ${currentBranch}), skipping cleanup`
+      };
+    }
+    let validShas = [];
+    try {
+      const { stdout } = await execAsync(
+        "git log origin/main..HEAD --format=%H",
+        { cwd: projectPath, timeout: 1e4 }
+      );
+      validShas = stdout.trim().split("\n").filter(Boolean);
+    } catch {
+      validShas = [];
+    }
+    const apiUrl = config.api_url || "https://episoda.dev";
+    const response = await fetch(`${apiUrl}/api/commits/local/batch`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${config.access_token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        machine_id: machineId,
+        valid_shas: validShas,
+        branch: "main"
+      })
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      return {
+        success: false,
+        deleted_count: 0,
+        kept_count: 0,
+        message: `API error: ${errorData.error?.message || response.statusText}`
+      };
+    }
+    const result = await response.json();
+    if (result.deleted_count && result.deleted_count > 0) {
+      console.log(`[EP950] Cleaned up ${result.deleted_count} stale commit record(s)`);
+    }
+    return {
+      success: true,
+      deleted_count: result.deleted_count || 0,
+      kept_count: result.kept_count || 0,
+      message: result.message || "Cleanup completed"
+    };
+  } catch (error) {
+    console.error("[EP950] Error during stale commit cleanup:", error);
+    return {
+      success: false,
+      deleted_count: 0,
+      kept_count: 0,
+      message: error.message || "Cleanup failed"
+    };
+  }
+}
+
+// src/tunnel/cloudflared-manager.ts
+var import_child_process5 = require("child_process");
 var fs5 = __toESM(require("fs"));
 var path6 = __toESM(require("path"));
 var os = __toESM(require("os"));
@@ -3403,7 +3848,7 @@ function isCloudflaredInPath() {
   try {
     const command = os.platform() === "win32" ? "where" : "which";
     const binaryName = os.platform() === "win32" ? "cloudflared.exe" : "cloudflared";
-    const result = (0, import_child_process4.spawnSync)(command, [binaryName], { encoding: "utf-8" });
+    const result = (0, import_child_process5.spawnSync)(command, [binaryName], { encoding: "utf-8" });
     if (result.status === 0 && result.stdout.trim()) {
       return result.stdout.trim().split("\n")[0].trim();
     }
@@ -3422,7 +3867,7 @@ function isCloudflaredInstalled() {
 }
 function verifyCloudflared(binaryPath) {
   try {
-    const result = (0, import_child_process4.spawnSync)(binaryPath, ["version"], { encoding: "utf-8", timeout: 5e3 });
+    const result = (0, import_child_process5.spawnSync)(binaryPath, ["version"], { encoding: "utf-8", timeout: 5e3 });
     return result.status === 0 && result.stdout.includes("cloudflared");
   } catch {
     return false;
@@ -3438,7 +3883,7 @@ function getDownloadUrl() {
   return platformUrls[arch3] || null;
 }
 async function downloadFile(url, destPath) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const followRedirect = (currentUrl, redirectCount = 0) => {
       if (redirectCount > 5) {
         reject(new Error("Too many redirects"));
@@ -3468,7 +3913,7 @@ async function downloadFile(url, destPath) {
         response.pipe(file);
         file.on("finish", () => {
           file.close();
-          resolve2();
+          resolve3();
         });
         file.on("error", (err) => {
           fs5.unlinkSync(destPath);
@@ -3527,7 +3972,7 @@ async function ensureCloudflared() {
 }
 
 // src/tunnel/tunnel-manager.ts
-var import_child_process5 = require("child_process");
+var import_child_process6 = require("child_process");
 var import_events = require("events");
 var fs6 = __toESM(require("fs"));
 var path7 = __toESM(require("path"));
@@ -3644,7 +4089,7 @@ var TunnelManager = class extends import_events.EventEmitter {
    */
   findCloudflaredProcesses() {
     try {
-      const output = (0, import_child_process5.execSync)("pgrep -f cloudflared", { encoding: "utf8" });
+      const output = (0, import_child_process6.execSync)("pgrep -f cloudflared", { encoding: "utf8" });
       return output.trim().split("\n").map((pid) => parseInt(pid, 10)).filter((pid) => !isNaN(pid));
     } catch {
       return [];
@@ -3656,7 +4101,7 @@ var TunnelManager = class extends import_events.EventEmitter {
    */
   getProcessPort(pid) {
     try {
-      const output = (0, import_child_process5.execSync)(`ps -p ${pid} -o args=`, { encoding: "utf8" }).trim();
+      const output = (0, import_child_process6.execSync)(`ps -p ${pid} -o args=`, { encoding: "utf8" }).trim();
       const portMatch = output.match(/--url\s+https?:\/\/localhost:(\d+)/);
       if (portMatch) {
         return parseInt(portMatch[1], 10);
@@ -3684,10 +4129,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((resolve2) => setTimeout(resolve2, 500));
+      await new Promise((resolve3) => setTimeout(resolve3, 500));
       if (this.isProcessRunning(pid)) {
         this.killByPid(pid, "SIGKILL");
-        await new Promise((resolve2) => setTimeout(resolve2, 200));
+        await new Promise((resolve3) => setTimeout(resolve3, 200));
       }
       killed.push(pid);
     }
@@ -3713,7 +4158,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((resolve2) => setTimeout(resolve2, 1e3));
+            await new Promise((resolve3) => setTimeout(resolve3, 1e3));
             if (this.isProcessRunning(pid)) {
               this.killByPid(pid, "SIGKILL");
             }
@@ -3728,7 +4173,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((resolve2) => setTimeout(resolve2, 500));
+          await new Promise((resolve3) => setTimeout(resolve3, 500));
           if (this.isProcessRunning(pid)) {
             this.killByPid(pid, "SIGKILL");
           }
@@ -3815,7 +4260,7 @@ var TunnelManager = class extends import_events.EventEmitter {
         return { success: false, error: `Failed to get cloudflared: ${errorMessage}` };
       }
     }
-    return new Promise((resolve2) => {
+    return new Promise((resolve3) => {
       const tunnelInfo = {
         moduleUid,
         url: "",
@@ -3825,7 +4270,7 @@ var TunnelManager = class extends import_events.EventEmitter {
         process: null
         // Will be set below
       };
-      const process2 = (0, import_child_process5.spawn)(this.cloudflaredPath, [
+      const process2 = (0, import_child_process6.spawn)(this.cloudflaredPath, [
         "tunnel",
         "--url",
         `http://localhost:${port}`
@@ -3863,7 +4308,7 @@ var TunnelManager = class extends import_events.EventEmitter {
             moduleUid,
             url: tunnelInfo.url
           });
-          resolve2({ success: true, url: tunnelInfo.url });
+          resolve3({ success: true, url: tunnelInfo.url });
         }
       };
       process2.stdout?.on("data", (data) => {
@@ -3889,7 +4334,7 @@ var TunnelManager = class extends import_events.EventEmitter {
             onStatusChange?.("error", errorMsg);
             this.emitEvent({ type: "error", moduleUid, error: errorMsg });
           }
-          resolve2({ success: false, error: errorMsg });
+          resolve3({ success: false, error: errorMsg });
         } else if (wasConnected) {
           if (currentState && !currentState.intentionallyStopped) {
             console.log(`[Tunnel] ${moduleUid} crashed unexpectedly, attempting reconnect...`);
@@ -3914,7 +4359,7 @@ var TunnelManager = class extends import_events.EventEmitter {
           this.emitEvent({ type: "error", moduleUid, error: error.message });
         }
         if (!urlFound) {
-          resolve2({ success: false, error: error.message });
+          resolve3({ success: false, error: error.message });
         }
       });
       setTimeout(() => {
@@ -3931,7 +4376,7 @@ var TunnelManager = class extends import_events.EventEmitter {
             onStatusChange?.("error", errorMsg);
             this.emitEvent({ type: "error", moduleUid, error: errorMsg });
           }
-          resolve2({ success: false, error: errorMsg });
+          resolve3({ success: false, error: errorMsg });
         }
       }, 3e4);
     });
@@ -3974,7 +4419,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((resolve2) => setTimeout(resolve2, 500));
+      await new Promise((resolve3) => setTimeout(resolve3, 500));
       if (this.isProcessRunning(orphanPid)) {
         this.killByPid(orphanPid, "SIGKILL");
       }
@@ -3983,7 +4428,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((resolve2) => setTimeout(resolve2, 300));
+      await new Promise((resolve3) => setTimeout(resolve3, 1e3));
     }
     const cleanup = await this.cleanupOrphanedProcesses();
     if (cleanup.cleaned > 0) {
@@ -4003,7 +4448,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((resolve2) => setTimeout(resolve2, 1e3));
+        await new Promise((resolve3) => setTimeout(resolve3, 1e3));
         if (this.isProcessRunning(orphanPid)) {
           this.killByPid(orphanPid, "SIGKILL");
         }
@@ -4019,16 +4464,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((resolve2) => {
+      await new Promise((resolve3) => {
         const timeout = setTimeout(() => {
           if (tunnel.process && !tunnel.process.killed) {
             tunnel.process.kill("SIGKILL");
           }
-          resolve2();
+          resolve3();
         }, 3e3);
         tunnel.process.once("exit", () => {
           clearTimeout(timeout);
-          resolve2();
+          resolve3();
         });
       });
     }
@@ -4067,6 +4512,12 @@ var TunnelManager = class extends import_events.EventEmitter {
   hasTunnel(moduleUid) {
     return this.tunnelStates.has(moduleUid);
   }
+  /**
+   * EP956: Get all module UIDs with active tunnels
+   */
+  getActiveModuleUids() {
+    return Array.from(this.tunnelStates.keys());
+  }
   /**
    * Get the URL for an active tunnel
    */
@@ -4083,12 +4534,12 @@ function getTunnelManager() {
 }
 
 // src/tunnel/tunnel-api.ts
-var import_core5 = __toESM(require_dist());
+var import_core6 = __toESM(require_dist());
 async function clearTunnelUrl(moduleUid) {
   if (!moduleUid || moduleUid === "LOCAL") {
     return;
   }
-  const config = await (0, import_core5.loadConfig)();
+  const config = await (0, import_core6.loadConfig)();
   if (!config?.access_token) {
     return;
   }
@@ -4105,14 +4556,14 @@ async function clearTunnelUrl(moduleUid) {
 }
 
 // src/agent/claude-binary.ts
-var import_child_process6 = require("child_process");
+var import_child_process7 = require("child_process");
 var path8 = __toESM(require("path"));
 var fs7 = __toESM(require("fs"));
 var cachedBinaryPath = null;
 function isValidClaudeBinary(binaryPath) {
   try {
     fs7.accessSync(binaryPath, fs7.constants.X_OK);
-    const version = (0, import_child_process6.execSync)(`"${binaryPath}" --version`, {
+    const version = (0, import_child_process7.execSync)(`"${binaryPath}" --version`, {
       encoding: "utf-8",
       timeout: 5e3,
       stdio: ["pipe", "pipe", "pipe"]
@@ -4131,7 +4582,7 @@ async function ensureClaudeBinary() {
     return cachedBinaryPath;
   }
   try {
-    const pathResult = (0, import_child_process6.execSync)("which claude", {
+    const pathResult = (0, import_child_process7.execSync)("which claude", {
       encoding: "utf-8",
       timeout: 5e3,
       stdio: ["pipe", "pipe", "pipe"]
@@ -4157,7 +4608,7 @@ async function ensureClaudeBinary() {
     }
   }
   try {
-    const npxResult = (0, import_child_process6.execSync)("npx --yes @anthropic-ai/claude-code --version", {
+    const npxResult = (0, import_child_process7.execSync)("npx --yes @anthropic-ai/claude-code --version", {
       encoding: "utf-8",
       timeout: 3e4,
       // npx might need to download
@@ -4176,7 +4627,7 @@ async function ensureClaudeBinary() {
 }
 
 // src/agent/agent-manager.ts
-var import_child_process7 = require("child_process");
+var import_child_process8 = require("child_process");
 var path9 = __toESM(require("path"));
 var fs8 = __toESM(require("fs"));
 var os3 = __toESM(require("os"));
@@ -4320,7 +4771,7 @@ var AgentManager = class {
       }, null, 2);
       fs8.writeFileSync(credentialsPath, credentialsContent, { mode: 384 });
       console.log("[AgentManager] EP936: Wrote OAuth credentials to ~/.claude/.credentials.json");
-      const childProcess = (0, import_child_process7.spawn)(spawnCmd, spawnArgs, {
+      const childProcess = (0, import_child_process8.spawn)(spawnCmd, spawnArgs, {
         cwd: session.projectPath,
         env: {
           ...process.env,
@@ -4462,17 +4913,17 @@ var AgentManager = class {
     if (process2 && !process2.killed) {
       console.log(`[AgentManager] Stopping session ${sessionId}`);
       process2.kill("SIGINT");
-      await new Promise((resolve2) => {
+      await new Promise((resolve3) => {
         const timeout = setTimeout(() => {
           if (!process2.killed) {
             console.log(`[AgentManager] Force killing session ${sessionId}`);
             process2.kill("SIGTERM");
           }
-          resolve2();
+          resolve3();
         }, 5e3);
         process2.once("exit", () => {
           clearTimeout(timeout);
-          resolve2();
+          resolve3();
         });
       });
     }
@@ -4564,9 +5015,9 @@ var AgentManager = class {
 };
 
 // src/utils/dev-server.ts
-var import_child_process8 = require("child_process");
+var import_child_process9 = require("child_process");
 init_port_check();
-var import_core6 = __toESM(require_dist());
+var import_core7 = __toESM(require_dist());
 var import_http = __toESM(require("http"));
 var fs9 = __toESM(require("fs"));
 var path10 = __toESM(require("path"));
@@ -4577,7 +5028,7 @@ var MAX_LOG_SIZE_BYTES = 5 * 1024 * 1024;
 var NODE_MEMORY_LIMIT_MB = 2048;
 var activeServers = /* @__PURE__ */ new Map();
 function getLogsDir() {
-  const logsDir = path10.join((0, import_core6.getConfigDir)(), "logs");
+  const logsDir = path10.join((0, import_core7.getConfigDir)(), "logs");
   if (!fs9.existsSync(logsDir)) {
     fs9.mkdirSync(logsDir, { recursive: true });
   }
@@ -4614,7 +5065,7 @@ function writeToLog(logPath, line, isError = false) {
   }
 }
 async function isDevServerHealthy(port, timeoutMs = 5e3) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const req = import_http.default.request(
       {
         hostname: "localhost",
@@ -4624,22 +5075,22 @@ async function isDevServerHealthy(port, timeoutMs = 5e3) {
         timeout: timeoutMs
       },
       (res) => {
-        resolve2(true);
+        resolve3(true);
       }
     );
     req.on("error", () => {
-      resolve2(false);
+      resolve3(false);
     });
     req.on("timeout", () => {
       req.destroy();
-      resolve2(false);
+      resolve3(false);
     });
     req.end();
   });
 }
 async function killProcessOnPort(port) {
   try {
-    const result = (0, import_child_process8.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
+    const result = (0, import_child_process9.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;
@@ -4648,21 +5099,21 @@ 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_process8.execSync)(`kill -15 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
+        (0, import_child_process9.execSync)(`kill -15 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
         console.log(`[DevServer] EP929: Sent SIGTERM to PID ${pid}`);
       } catch {
       }
     }
-    await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+    await new Promise((resolve3) => setTimeout(resolve3, 1e3));
     for (const pid of pids) {
       try {
-        (0, import_child_process8.execSync)(`kill -0 ${pid} 2>/dev/null`, { encoding: "utf8" });
-        (0, import_child_process8.execSync)(`kill -9 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
+        (0, import_child_process9.execSync)(`kill -0 ${pid} 2>/dev/null`, { encoding: "utf8" });
+        (0, import_child_process9.execSync)(`kill -9 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
         console.log(`[DevServer] EP929: Force killed PID ${pid}`);
       } catch {
       }
     }
-    await new Promise((resolve2) => setTimeout(resolve2, 500));
+    await new Promise((resolve3) => setTimeout(resolve3, 500));
     const stillInUse = await isPortInUse(port);
     if (stillInUse) {
       console.error(`[DevServer] EP929: Port ${port} still in use after kill attempts`);
@@ -4682,7 +5133,7 @@ async function waitForPort(port, timeoutMs = 3e4) {
     if (await isPortInUse(port)) {
       return true;
     }
-    await new Promise((resolve2) => setTimeout(resolve2, checkInterval));
+    await new Promise((resolve3) => setTimeout(resolve3, checkInterval));
   }
   return false;
 }
@@ -4695,7 +5146,7 @@ function spawnDevServerProcess(projectPath, port, moduleUid, logPath) {
   const nodeOptions = process.env.NODE_OPTIONS || "";
   const memoryFlag = `--max-old-space-size=${NODE_MEMORY_LIMIT_MB}`;
   const enhancedNodeOptions = nodeOptions.includes("max-old-space-size") ? nodeOptions : `${nodeOptions} ${memoryFlag}`.trim();
-  const devProcess = (0, import_child_process8.spawn)("npm", ["run", "dev"], {
+  const devProcess = (0, import_child_process9.spawn)("npm", ["run", "dev"], {
     cwd: projectPath,
     env: {
       ...process.env,
@@ -4743,7 +5194,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((resolve2) => setTimeout(resolve2, delay));
+  await new Promise((resolve3) => setTimeout(resolve3, delay));
   if (!activeServers.has(moduleUid)) {
     console.log(`[DevServer] EP932: Server ${moduleUid} was removed during restart delay, aborting restart`);
     return;
@@ -4840,7 +5291,7 @@ async function stopDevServer(moduleUid) {
       writeToLog(serverInfo.logFile, `Stopping server (manual stop)`, false);
     }
     serverInfo.process.kill("SIGTERM");
-    await new Promise((resolve2) => setTimeout(resolve2, 2e3));
+    await new Promise((resolve3) => setTimeout(resolve3, 2e3));
     if (!serverInfo.process.killed) {
       serverInfo.process.kill("SIGKILL");
     }
@@ -4858,7 +5309,7 @@ async function restartDevServer(moduleUid) {
     writeToLog(logFile, `Manual restart requested`, false);
   }
   await stopDevServer(moduleUid);
-  await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+  await new Promise((resolve3) => setTimeout(resolve3, 1e3));
   if (await isPortInUse(port)) {
     await killProcessOnPort(port);
   }
@@ -4956,23 +5407,546 @@ function getPortFromPackageJson(projectPath) {
   return null;
 }
 
-// src/daemon/daemon-process.ts
+// src/daemon/worktree-manager.ts
 var fs11 = __toESM(require("fs"));
-var os4 = __toESM(require("os"));
 var path12 = __toESM(require("path"));
-var packageJson = require_package();
-async function ensureValidToken(config, bufferMs = 5 * 60 * 1e3) {
-  const now = Date.now();
-  const expiresAt = config.expires_at || 0;
-  if (expiresAt > now + bufferMs) {
-    return config;
+var import_core8 = __toESM(require_dist());
+function validateModuleUid(moduleUid) {
+  if (!moduleUid || typeof moduleUid !== "string" || !moduleUid.trim()) {
+    return false;
   }
-  if (!config.refresh_token) {
-    console.warn("[Daemon] EP904: Token expired but no refresh_token available");
-    return config;
+  if (moduleUid.includes("/") || moduleUid.includes("\\") || moduleUid.includes("..")) {
+    return false;
   }
-  console.log("[Daemon] EP904: Access token expired or expiring soon, refreshing...");
-  try {
+  if (moduleUid.includes("\0")) {
+    return false;
+  }
+  if (moduleUid.startsWith(".")) {
+    return false;
+  }
+  return true;
+}
+var WorktreeManager = class _WorktreeManager {
+  constructor(projectRoot) {
+    // ============================================================
+    // Private methods
+    // ============================================================
+    this.lockPath = "";
+    this.projectRoot = projectRoot;
+    this.bareRepoPath = path12.join(projectRoot, ".bare");
+    this.configPath = path12.join(projectRoot, ".episoda", "config.json");
+    this.gitExecutor = new import_core8.GitExecutor();
+  }
+  /**
+   * Initialize worktree manager from existing project root
+   * @returns true if valid worktree project, false otherwise
+   */
+  async initialize() {
+    if (!fs11.existsSync(this.bareRepoPath)) {
+      return false;
+    }
+    if (!fs11.existsSync(this.configPath)) {
+      return false;
+    }
+    try {
+      const config = this.readConfig();
+      return config?.worktreeMode === true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Create a new worktree project from scratch
+   */
+  static async createProject(projectRoot, repoUrl, projectId, workspaceSlug, projectSlug) {
+    const manager = new _WorktreeManager(projectRoot);
+    const episodaDir = path12.join(projectRoot, ".episoda");
+    fs11.mkdirSync(episodaDir, { recursive: true });
+    const cloneResult = await manager.gitExecutor.execute({
+      action: "clone_bare",
+      url: repoUrl,
+      path: manager.bareRepoPath
+    });
+    if (!cloneResult.success) {
+      throw new Error(`Failed to clone repository: ${cloneResult.output}`);
+    }
+    const config = {
+      projectId,
+      workspaceSlug,
+      projectSlug,
+      bareRepoPath: manager.bareRepoPath,
+      worktreeMode: true,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      worktrees: []
+    };
+    manager.writeConfig(config);
+    return manager;
+  }
+  /**
+   * Create a worktree for a module
+   * The entire operation is locked to prevent race conditions
+   */
+  async createWorktree(moduleUid, branchName, createBranch = false) {
+    if (!validateModuleUid(moduleUid)) {
+      return {
+        success: false,
+        error: `Invalid module UID: "${moduleUid}" - contains disallowed characters`
+      };
+    }
+    const worktreePath = path12.join(this.projectRoot, moduleUid);
+    const lockAcquired = await this.acquireLock();
+    if (!lockAcquired) {
+      return {
+        success: false,
+        error: "Could not acquire lock for worktree creation"
+      };
+    }
+    try {
+      const existing = this.getWorktreeByModuleUid(moduleUid);
+      if (existing) {
+        return {
+          success: true,
+          worktreePath: existing.worktreePath,
+          worktreeInfo: existing
+        };
+      }
+      const result = await this.gitExecutor.execute({
+        action: "worktree_add",
+        path: worktreePath,
+        branch: branchName,
+        create: createBranch
+      }, { cwd: this.bareRepoPath });
+      if (!result.success) {
+        return {
+          success: false,
+          error: result.output || "Failed to create worktree"
+        };
+      }
+      const worktreeInfo = {
+        moduleUid,
+        branchName,
+        worktreePath,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        lastAccessed: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const config = this.readConfig();
+      if (config) {
+        config.worktrees.push(worktreeInfo);
+        this.writeConfig(config);
+      }
+      return {
+        success: true,
+        worktreePath,
+        worktreeInfo
+      };
+    } finally {
+      this.releaseLock();
+    }
+  }
+  /**
+   * Remove a worktree for a module
+   * P1-2: Wrapped entire operation in lock to prevent race with createWorktree
+   */
+  async removeWorktree(moduleUid, force = false) {
+    if (!validateModuleUid(moduleUid)) {
+      return {
+        success: false,
+        error: `Invalid module UID: "${moduleUid}" - contains disallowed characters`
+      };
+    }
+    const lockAcquired = await this.acquireLock();
+    if (!lockAcquired) {
+      return {
+        success: false,
+        error: "Could not acquire lock for worktree removal"
+      };
+    }
+    try {
+      const existing = this.getWorktreeByModuleUid(moduleUid);
+      if (!existing) {
+        return {
+          success: false,
+          error: `No worktree found for module ${moduleUid}`
+        };
+      }
+      const result = await this.gitExecutor.execute({
+        action: "worktree_remove",
+        path: existing.worktreePath,
+        force
+      }, { cwd: this.bareRepoPath });
+      if (!result.success) {
+        return {
+          success: false,
+          error: result.output || "Failed to remove worktree"
+        };
+      }
+      const config = this.readConfig();
+      if (config) {
+        config.worktrees = config.worktrees.filter((w) => w.moduleUid !== moduleUid);
+        this.writeConfig(config);
+      }
+      return {
+        success: true,
+        worktreePath: existing.worktreePath
+      };
+    } finally {
+      this.releaseLock();
+    }
+  }
+  /**
+   * Get worktree path for a module
+   */
+  getWorktreePath(moduleUid) {
+    if (!validateModuleUid(moduleUid)) {
+      return null;
+    }
+    const worktree = this.getWorktreeByModuleUid(moduleUid);
+    return worktree?.worktreePath || null;
+  }
+  /**
+   * Get worktree info by module UID
+   */
+  getWorktreeByModuleUid(moduleUid) {
+    const config = this.readConfig();
+    return config?.worktrees.find((w) => w.moduleUid === moduleUid) || null;
+  }
+  /**
+   * Get worktree info by branch name
+   */
+  getWorktreeByBranch(branchName) {
+    const config = this.readConfig();
+    return config?.worktrees.find((w) => w.branchName === branchName) || null;
+  }
+  /**
+   * List all active worktrees
+   */
+  listWorktrees() {
+    const config = this.readConfig();
+    return config?.worktrees || [];
+  }
+  /**
+   * EP957: Audit worktrees against known active module UIDs
+   *
+   * Compares local worktrees against a list of module UIDs that should be active.
+   * Used by daemon startup to detect orphaned worktrees from crashed sessions.
+   *
+   * @param activeModuleUids - UIDs of modules currently in doing/review state
+   * @returns Object with orphaned and valid worktree lists
+   */
+  auditWorktrees(activeModuleUids) {
+    const allWorktrees = this.listWorktrees();
+    const activeSet = new Set(activeModuleUids);
+    const orphaned = allWorktrees.filter((w) => !activeSet.has(w.moduleUid));
+    const valid = allWorktrees.filter((w) => activeSet.has(w.moduleUid));
+    return { orphaned, valid };
+  }
+  /**
+   * Update last accessed timestamp for a worktree
+   */
+  async touchWorktree(moduleUid) {
+    await this.updateConfigSafe((config) => {
+      const worktree = config.worktrees.find((w) => w.moduleUid === moduleUid);
+      if (worktree) {
+        worktree.lastAccessed = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      return config;
+    });
+  }
+  /**
+   * Prune stale worktrees (directories that no longer exist)
+   */
+  async pruneStaleWorktrees() {
+    await this.gitExecutor.execute({
+      action: "worktree_prune"
+    }, { cwd: this.bareRepoPath });
+    let prunedCount = 0;
+    await this.updateConfigSafe((config) => {
+      const initialCount = config.worktrees.length;
+      config.worktrees = config.worktrees.filter((w) => fs11.existsSync(w.worktreePath));
+      prunedCount = initialCount - config.worktrees.length;
+      return config;
+    });
+    return prunedCount;
+  }
+  /**
+   * Validate all worktrees and sync with git
+   */
+  async validateWorktrees() {
+    const config = this.readConfig();
+    const valid = [];
+    const stale = [];
+    const orphaned = [];
+    const listResult = await this.gitExecutor.execute({
+      action: "worktree_list"
+    }, { cwd: this.bareRepoPath });
+    const actualWorktrees = new Set(
+      listResult.details?.worktrees?.map((w) => w.path) || []
+    );
+    for (const worktree of config?.worktrees || []) {
+      if (actualWorktrees.has(worktree.worktreePath)) {
+        valid.push(worktree);
+        actualWorktrees.delete(worktree.worktreePath);
+      } else {
+        stale.push(worktree);
+      }
+    }
+    for (const wpath of actualWorktrees) {
+      if (wpath !== this.bareRepoPath) {
+        orphaned.push(wpath);
+      }
+    }
+    return { valid, stale, orphaned };
+  }
+  /**
+   * Get project configuration
+   */
+  getConfig() {
+    return this.readConfig();
+  }
+  /**
+   * Get the bare repo path
+   */
+  getBareRepoPath() {
+    return this.bareRepoPath;
+  }
+  /**
+   * Get the project root path
+   */
+  getProjectRoot() {
+    return this.projectRoot;
+  }
+  getLockPath() {
+    if (!this.lockPath) {
+      this.lockPath = this.configPath + ".lock";
+    }
+    return this.lockPath;
+  }
+  /**
+   * Check if a process is still running
+   */
+  isProcessRunning(pid) {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Acquire a file lock with timeout
+   * Uses atomic file creation to ensure only one process holds the lock
+   * P1-1: Added PID verification before removing stale locks to prevent race conditions
+   */
+  async acquireLock(timeoutMs = 5e3) {
+    const lockPath = this.getLockPath();
+    const startTime = Date.now();
+    const retryInterval = 50;
+    while (Date.now() - startTime < timeoutMs) {
+      try {
+        fs11.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+        return true;
+      } catch (err) {
+        if (err.code === "EEXIST") {
+          try {
+            const stats = fs11.statSync(lockPath);
+            const lockAge = Date.now() - stats.mtimeMs;
+            if (lockAge > 3e4) {
+              try {
+                const lockContent = fs11.readFileSync(lockPath, "utf-8").trim();
+                const lockPid = parseInt(lockContent, 10);
+                if (!isNaN(lockPid) && this.isProcessRunning(lockPid)) {
+                  await new Promise((resolve3) => setTimeout(resolve3, retryInterval));
+                  continue;
+                }
+              } catch {
+              }
+              try {
+                fs11.unlinkSync(lockPath);
+              } catch {
+              }
+              continue;
+            }
+          } catch {
+            continue;
+          }
+          await new Promise((resolve3) => setTimeout(resolve3, retryInterval));
+          continue;
+        }
+        throw err;
+      }
+    }
+    return false;
+  }
+  /**
+   * Release the file lock
+   */
+  releaseLock() {
+    try {
+      fs11.unlinkSync(this.getLockPath());
+    } catch {
+    }
+  }
+  readConfig() {
+    try {
+      if (!fs11.existsSync(this.configPath)) {
+        return null;
+      }
+      const content = fs11.readFileSync(this.configPath, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      console.error("[WorktreeManager] Failed to read config:", error);
+      return null;
+    }
+  }
+  writeConfig(config) {
+    try {
+      const dir = path12.dirname(this.configPath);
+      if (!fs11.existsSync(dir)) {
+        fs11.mkdirSync(dir, { recursive: true });
+      }
+      fs11.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf-8");
+    } catch (error) {
+      console.error("[WorktreeManager] Failed to write config:", error);
+      throw error;
+    }
+  }
+  /**
+   * Read-modify-write with file locking for safe concurrent access
+   */
+  async updateConfigSafe(updater) {
+    const lockAcquired = await this.acquireLock();
+    if (!lockAcquired) {
+      console.error("[WorktreeManager] Failed to acquire lock for config update");
+      return false;
+    }
+    try {
+      const config = this.readConfig();
+      if (!config) {
+        return false;
+      }
+      const updated = updater(config);
+      this.writeConfig(updated);
+      return true;
+    } finally {
+      this.releaseLock();
+    }
+  }
+};
+function getEpisodaRoot() {
+  return process.env.EPISODA_ROOT || path12.join(require("os").homedir(), "episoda");
+}
+async function isWorktreeProject(projectRoot) {
+  const manager = new WorktreeManager(projectRoot);
+  return manager.initialize();
+}
+async function findProjectRoot(startPath) {
+  let current = path12.resolve(startPath);
+  const episodaRoot = getEpisodaRoot();
+  if (!current.startsWith(episodaRoot)) {
+    return null;
+  }
+  for (let i = 0; i < 10; i++) {
+    const bareDir = path12.join(current, ".bare");
+    const episodaDir = path12.join(current, ".episoda");
+    if (fs11.existsSync(bareDir) && fs11.existsSync(episodaDir)) {
+      if (await isWorktreeProject(current)) {
+        return current;
+      }
+    }
+    const parent = path12.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return null;
+}
+
+// src/utils/worktree.ts
+var path13 = __toESM(require("path"));
+var fs12 = __toESM(require("fs"));
+var os4 = __toESM(require("os"));
+var import_core9 = __toESM(require_dist());
+function getEpisodaRoot2() {
+  return process.env.EPISODA_ROOT || path13.join(os4.homedir(), "episoda");
+}
+function getWorktreeInfo(moduleUid, workspaceSlug, projectSlug) {
+  const root = getEpisodaRoot2();
+  const worktreePath = path13.join(root, workspaceSlug, projectSlug, moduleUid);
+  return {
+    path: worktreePath,
+    exists: fs12.existsSync(worktreePath),
+    moduleUid
+  };
+}
+async function getWorktreeInfoForModule(moduleUid) {
+  const config = await (0, import_core9.loadConfig)();
+  if (!config?.workspace_slug || !config?.project_slug) {
+    console.warn("[Worktree] Missing workspace_slug or project_slug in config");
+    return null;
+  }
+  return getWorktreeInfo(moduleUid, config.workspace_slug, config.project_slug);
+}
+
+// src/utils/port-allocator.ts
+var PORT_RANGE_START = 3100;
+var PORT_RANGE_END = 3199;
+var PORT_WARNING_THRESHOLD = 80;
+var portAssignments = /* @__PURE__ */ new Map();
+function allocatePort(moduleUid) {
+  const existing = portAssignments.get(moduleUid);
+  if (existing) {
+    return existing;
+  }
+  const usedPorts = new Set(portAssignments.values());
+  if (usedPorts.size >= PORT_WARNING_THRESHOLD) {
+    console.warn(
+      `[PortAllocator] Warning: ${usedPorts.size}/${PORT_RANGE_END - PORT_RANGE_START + 1} ports allocated`
+    );
+  }
+  for (let port = PORT_RANGE_START; port <= PORT_RANGE_END; port++) {
+    if (!usedPorts.has(port)) {
+      portAssignments.set(moduleUid, port);
+      console.log(`[PortAllocator] Assigned port ${port} to ${moduleUid}`);
+      return port;
+    }
+  }
+  throw new Error(
+    `No available ports in range ${PORT_RANGE_START}-${PORT_RANGE_END}. ${portAssignments.size} modules are using all available ports.`
+  );
+}
+function releasePort(moduleUid) {
+  const port = portAssignments.get(moduleUid);
+  if (port) {
+    portAssignments.delete(moduleUid);
+    console.log(`[PortAllocator] Released port ${port} from ${moduleUid}`);
+  }
+}
+function clearAllPorts() {
+  const count = portAssignments.size;
+  portAssignments.clear();
+  if (count > 0) {
+    console.log(`[PortAllocator] Cleared ${count} port assignments`);
+  }
+}
+
+// src/daemon/daemon-process.ts
+var fs13 = __toESM(require("fs"));
+var os5 = __toESM(require("os"));
+var path14 = __toESM(require("path"));
+var packageJson = require_package();
+async function ensureValidToken(config, bufferMs = 5 * 60 * 1e3) {
+  const now = Date.now();
+  const expiresAt = config.expires_at || 0;
+  if (expiresAt > now + bufferMs) {
+    return config;
+  }
+  if (!config.refresh_token) {
+    console.warn("[Daemon] EP904: Token expired but no refresh_token available");
+    return config;
+  }
+  console.log("[Daemon] EP904: Access token expired or expiring soon, refreshing...");
+  try {
     const apiUrl = config.api_url || "https://episoda.dev";
     const response = await fetch(`${apiUrl}/api/oauth/token`, {
       method: "POST",
@@ -4994,7 +5968,7 @@ async function ensureValidToken(config, bufferMs = 5 * 60 * 1e3) {
       refresh_token: tokenResponse.refresh_token || config.refresh_token,
       expires_at: now + tokenResponse.expires_in * 1e3
     };
-    await (0, import_core7.saveConfig)(updatedConfig);
+    await (0, import_core10.saveConfig)(updatedConfig);
     console.log("[Daemon] EP904: Access token refreshed successfully");
     return updatedConfig;
   } catch (error) {
@@ -5003,7 +5977,7 @@ async function ensureValidToken(config, bufferMs = 5 * 60 * 1e3) {
   }
 }
 async function fetchWithAuth(url, options = {}, retryOnUnauthorized = true) {
-  let config = await (0, import_core7.loadConfig)();
+  let config = await (0, import_core10.loadConfig)();
   if (!config?.access_token) {
     throw new Error("No access token configured");
   }
@@ -5093,7 +6067,7 @@ var Daemon = class _Daemon {
     console.log("[Daemon] Starting Episoda daemon...");
     this.machineId = await getMachineId();
     console.log(`[Daemon] Machine ID: ${this.machineId}`);
-    const config = await (0, import_core7.loadConfig)();
+    const config = await (0, import_core10.loadConfig)();
     if (config?.device_id) {
       this.deviceId = config.device_id;
       console.log(`[Daemon] Loaded cached Device ID (UUID): ${this.deviceId}`);
@@ -5103,6 +6077,7 @@ var Daemon = class _Daemon {
     this.registerIPCHandlers();
     await this.restoreConnections();
     await this.cleanupOrphanedTunnels();
+    await this.auditWorktreesOnStartup();
     this.startHealthCheckPolling();
     this.setupShutdownHandlers();
     console.log("[Daemon] Daemon started successfully");
@@ -5148,9 +6123,9 @@ var Daemon = class _Daemon {
         machineId: this.machineId,
         deviceId: this.deviceId,
         // EP726: UUID for unified device identification
-        hostname: os4.hostname(),
-        platform: os4.platform(),
-        arch: os4.arch(),
+        hostname: os5.hostname(),
+        platform: os5.platform(),
+        arch: os5.arch(),
         projects
       };
     });
@@ -5176,7 +6151,7 @@ var Daemon = class _Daemon {
           if (attempt < MAX_RETRIES) {
             const delay = INITIAL_DELAY * Math.pow(2, attempt - 1);
             console.log(`[Daemon] Retrying in ${delay / 1e3}s...`);
-            await new Promise((resolve2) => setTimeout(resolve2, delay));
+            await new Promise((resolve3) => setTimeout(resolve3, delay));
             await this.disconnectProject(projectPath);
           }
         }
@@ -5229,7 +6204,7 @@ var Daemon = class _Daemon {
       };
     });
     this.ipcServer.on("verify-server-connection", async () => {
-      const config = await (0, import_core7.loadConfig)();
+      const config = await (0, import_core10.loadConfig)();
       if (!config?.access_token || !config?.api_url) {
         return {
           verified: false,
@@ -5365,8 +6340,8 @@ var Daemon = class _Daemon {
       }
     }
     let releaseLock;
-    const lockPromise = new Promise((resolve2) => {
-      releaseLock = resolve2;
+    const lockPromise = new Promise((resolve3) => {
+      releaseLock = resolve3;
     });
     this.tunnelOperationLocks.set(moduleUid, lockPromise);
     try {
@@ -5392,7 +6367,7 @@ var Daemon = class _Daemon {
         const maxWait = 35e3;
         const startTime = Date.now();
         while (this.pendingConnections.has(projectPath) && Date.now() - startTime < maxWait) {
-          await new Promise((resolve2) => setTimeout(resolve2, 500));
+          await new Promise((resolve3) => setTimeout(resolve3, 500));
         }
         if (this.liveConnections.has(projectPath)) {
           console.log(`[Daemon] Pending connection succeeded for ${projectPath}`);
@@ -5403,7 +6378,7 @@ var Daemon = class _Daemon {
       console.warn(`[Daemon] Stale connection detected for ${projectPath}, forcing reconnection`);
       await this.disconnectProject(projectPath);
     }
-    const config = await (0, import_core7.loadConfig)();
+    const config = await (0, import_core10.loadConfig)();
     if (!config || !config.access_token) {
       throw new Error("No access token found. Please run: episoda auth");
     }
@@ -5417,8 +6392,8 @@ var Daemon = class _Daemon {
     const wsPort = process.env.EPISODA_WS_PORT || "3001";
     const wsUrl = `${wsProtocol}//${serverUrlObj.hostname}:${wsPort}`;
     console.log(`[Daemon] Connecting to ${wsUrl} for project ${projectId}...`);
-    const client = new import_core7.EpisodaClient();
-    const gitExecutor = new import_core7.GitExecutor();
+    const client = new import_core10.EpisodaClient();
+    const gitExecutor = new import_core10.GitExecutor();
     const connection = {
       projectId,
       projectPath,
@@ -5432,8 +6407,13 @@ var Daemon = class _Daemon {
         console.log(`[Daemon] Received command for ${projectId}:`, message.command);
         client.updateActivity();
         try {
-          const result = await gitExecutor.execute(message.command, {
-            cwd: projectPath
+          const gitCmd = message.command;
+          const cwd = gitCmd.worktreePath || projectPath;
+          if (gitCmd.worktreePath) {
+            console.log(`[Daemon] EP944: Routing command to worktree: ${gitCmd.worktreePath}`);
+          }
+          const result = await gitExecutor.execute(gitCmd, {
+            cwd
           });
           await client.send({
             type: "result",
@@ -5441,6 +6421,15 @@ var Daemon = class _Daemon {
             result
           });
           console.log(`[Daemon] Command completed for ${projectId}:`, result.success ? "success" : "failed");
+          if (result.success && gitCmd.action === "push" && gitCmd.branch === "main") {
+            cleanupStaleCommits(projectPath).then((cleanupResult) => {
+              if (cleanupResult.deleted_count > 0) {
+                console.log(`[Daemon] EP950: Cleaned up ${cleanupResult.deleted_count} stale commit(s) after push to main`);
+              }
+            }).catch((err) => {
+              console.warn("[Daemon] EP950: Cleanup after push failed:", err.message);
+            });
+          }
         } catch (error) {
           await client.send({
             type: "result",
@@ -5527,7 +6516,7 @@ var Daemon = class _Daemon {
             const port = cmd.port || detectDevPort(projectPath);
             const previewUrl = `https://${cmd.moduleUid.toLowerCase()}-${cmd.projectUid.toLowerCase()}.episoda.site`;
             const reportTunnelStatus = async (data) => {
-              const config2 = await (0, import_core7.loadConfig)();
+              const config2 = await (0, import_core10.loadConfig)();
               if (config2?.access_token) {
                 try {
                   const apiUrl = config2.api_url || "https://episoda.dev";
@@ -5551,7 +6540,7 @@ var Daemon = class _Daemon {
             };
             (async () => {
               const MAX_RETRIES = 3;
-              const RETRY_DELAY_MS = 2e3;
+              const RETRY_DELAY_MS = 3e3;
               await reportTunnelStatus({
                 tunnel_started_at: (/* @__PURE__ */ new Date()).toISOString(),
                 tunnel_error: null
@@ -5599,7 +6588,7 @@ var Daemon = class _Daemon {
                   console.warn(`[Daemon] Tunnel start attempt ${attempt} failed: ${lastError}`);
                   if (attempt < MAX_RETRIES) {
                     console.log(`[Daemon] Retrying in ${RETRY_DELAY_MS}ms...`);
-                    await new Promise((resolve2) => setTimeout(resolve2, RETRY_DELAY_MS));
+                    await new Promise((resolve3) => setTimeout(resolve3, RETRY_DELAY_MS));
                   }
                 }
                 const errorMsg = `Tunnel failed after ${MAX_RETRIES} attempts: ${lastError}`;
@@ -5619,7 +6608,7 @@ var Daemon = class _Daemon {
           } else if (cmd.action === "stop") {
             await tunnelManager.stopTunnel(cmd.moduleUid);
             await stopDevServer(cmd.moduleUid);
-            const config2 = await (0, import_core7.loadConfig)();
+            const config2 = await (0, import_core10.loadConfig)();
             if (config2?.access_token) {
               try {
                 const apiUrl = config2.api_url || "https://episoda.dev";
@@ -5813,15 +6802,26 @@ var Daemon = class _Daemon {
       this.autoStartTunnelsForProject(projectPath, projectId).catch((error) => {
         console.error(`[Daemon] EP819: Failed to auto-start tunnels:`, error);
       });
+      cleanupStaleCommits(projectPath).then((cleanupResult) => {
+        if (cleanupResult.deleted_count > 0) {
+          console.log(`[Daemon] EP950: Cleaned up ${cleanupResult.deleted_count} stale commit(s) on connect`);
+        }
+      }).catch((err) => {
+        console.warn("[Daemon] EP950: Cleanup on connect failed:", err.message);
+      });
     });
     client.on("module_state_changed", async (message) => {
       if (message.type === "module_state_changed") {
-        const { moduleUid, state, previousState, branchName, devMode } = message;
+        const { moduleUid, state, previousState, branchName, devMode, checkoutMachineId } = message;
         console.log(`[Daemon] EP843: Module ${moduleUid} state changed: ${previousState} \u2192 ${state}`);
         if (devMode !== "local") {
           console.log(`[Daemon] EP843: Skipping tunnel action for ${moduleUid} (mode: ${devMode || "unknown"})`);
           return;
         }
+        if (checkoutMachineId && checkoutMachineId !== this.deviceId) {
+          console.log(`[Daemon] EP956: Skipping ${moduleUid} (checked out on different machine: ${checkoutMachineId})`);
+          return;
+        }
         const tunnelManager = getTunnelManager();
         await tunnelManager.initialize();
         await this.withTunnelLock(moduleUid, async () => {
@@ -5835,51 +6835,65 @@ var Daemon = class _Daemon {
               console.log(`[Daemon] EP843: Tunnel already running for ${moduleUid}, skipping start`);
               return;
             }
-            console.log(`[Daemon] EP843: Starting tunnel for ${moduleUid} (${previousState} \u2192 ${state})`);
+            console.log(`[Daemon] EP956: Starting tunnel for ${moduleUid} (${previousState} \u2192 ${state})`);
             try {
-              const port = detectDevPort(projectPath);
-              const devServerResult = await ensureDevServer(projectPath, port, moduleUid);
+              const worktree = await getWorktreeInfoForModule(moduleUid);
+              if (!worktree) {
+                console.error(`[Daemon] EP956: Cannot resolve worktree path for ${moduleUid} (missing config slugs)`);
+                return;
+              }
+              if (!worktree.exists) {
+                console.log(`[Daemon] EP956: No worktree for ${moduleUid} at ${worktree.path}, skipping tunnel`);
+                return;
+              }
+              const port = allocatePort(moduleUid);
+              console.log(`[Daemon] EP956: Using worktree ${worktree.path} on port ${port}`);
+              const devServerResult = await ensureDevServer(worktree.path, port, moduleUid);
               if (!devServerResult.success) {
-                console.error(`[Daemon] EP843: Dev server failed for ${moduleUid}: ${devServerResult.error}`);
+                console.error(`[Daemon] EP956: Dev server failed for ${moduleUid}: ${devServerResult.error}`);
+                releasePort(moduleUid);
                 return;
               }
-              const config2 = await (0, import_core7.loadConfig)();
+              const config2 = await (0, import_core10.loadConfig)();
               const apiUrl = config2?.api_url || "https://episoda.dev";
               const startResult = await tunnelManager.startTunnel({
                 moduleUid,
                 port,
                 onUrl: async (url) => {
-                  console.log(`[Daemon] EP843: Tunnel URL for ${moduleUid}: ${url}`);
+                  console.log(`[Daemon] EP956: Tunnel URL for ${moduleUid}: ${url}`);
                   try {
                     await fetchWithAuth(`${apiUrl}/api/modules/${moduleUid}/tunnel`, {
                       method: "POST",
                       body: JSON.stringify({ tunnel_url: url })
                     });
                   } catch (err) {
-                    console.warn(`[Daemon] EP843: Failed to report tunnel URL:`, err instanceof Error ? err.message : err);
+                    console.warn(`[Daemon] EP956: Failed to report tunnel URL:`, err instanceof Error ? err.message : err);
                   }
                 },
                 onStatusChange: (status, error) => {
                   if (status === "error") {
-                    console.error(`[Daemon] EP843: Tunnel error for ${moduleUid}: ${error}`);
+                    console.error(`[Daemon] EP956: Tunnel error for ${moduleUid}: ${error}`);
                   }
                 }
               });
               if (startResult.success) {
-                console.log(`[Daemon] EP843: Tunnel started for ${moduleUid}`);
+                console.log(`[Daemon] EP956: Tunnel started for ${moduleUid}`);
               } else {
-                console.error(`[Daemon] EP843: Tunnel failed for ${moduleUid}: ${startResult.error}`);
+                console.error(`[Daemon] EP956: Tunnel failed for ${moduleUid}: ${startResult.error}`);
+                releasePort(moduleUid);
               }
             } catch (error) {
-              console.error(`[Daemon] EP843: Error starting tunnel for ${moduleUid}:`, error);
+              console.error(`[Daemon] EP956: Error starting tunnel for ${moduleUid}:`, error);
+              releasePort(moduleUid);
             }
           }
           if (state === "done" && wasInActiveZone) {
-            console.log(`[Daemon] EP933: Stopping tunnel for ${moduleUid} (${previousState} \u2192 done)`);
+            console.log(`[Daemon] EP956: Stopping tunnel for ${moduleUid} (${previousState} \u2192 done)`);
             try {
               await tunnelManager.stopTunnel(moduleUid);
-              console.log(`[Daemon] EP843: Tunnel stopped for ${moduleUid}`);
-              const config2 = await (0, import_core7.loadConfig)();
+              releasePort(moduleUid);
+              console.log(`[Daemon] EP956: Tunnel stopped and port released for ${moduleUid}`);
+              const config2 = await (0, import_core10.loadConfig)();
               const apiUrl = config2?.api_url || "https://episoda.dev";
               try {
                 await fetchWithAuth(`${apiUrl}/api/modules/${moduleUid}/tunnel`, {
@@ -5887,10 +6901,14 @@ var Daemon = class _Daemon {
                   body: JSON.stringify({ tunnel_url: null })
                 });
               } catch (err) {
-                console.warn(`[Daemon] EP843: Failed to clear tunnel URL:`, err instanceof Error ? err.message : err);
+                console.warn(`[Daemon] EP956: Failed to clear tunnel URL:`, err instanceof Error ? err.message : err);
               }
+              this.cleanupModuleWorktree(moduleUid).catch((err) => {
+                console.warn(`[Daemon] EP956: Async cleanup failed for ${moduleUid}:`, err instanceof Error ? err.message : err);
+              });
             } catch (error) {
-              console.error(`[Daemon] EP843: Error stopping tunnel for ${moduleUid}:`, error);
+              console.error(`[Daemon] EP956: Error stopping tunnel for ${moduleUid}:`, error);
+              releasePort(moduleUid);
             }
           }
         });
@@ -5912,21 +6930,21 @@ var Daemon = class _Daemon {
       let daemonPid;
       try {
         const pidPath = getPidFilePath();
-        if (fs11.existsSync(pidPath)) {
-          const pidStr = fs11.readFileSync(pidPath, "utf-8").trim();
+        if (fs13.existsSync(pidPath)) {
+          const pidStr = fs13.readFileSync(pidPath, "utf-8").trim();
           daemonPid = parseInt(pidStr, 10);
         }
       } catch (pidError) {
         console.warn(`[Daemon] Could not read daemon PID:`, pidError instanceof Error ? pidError.message : pidError);
       }
-      const authSuccessPromise = new Promise((resolve2, reject) => {
+      const authSuccessPromise = new Promise((resolve3, reject) => {
         const AUTH_TIMEOUT = 3e4;
         const timeout = setTimeout(() => {
           reject(new Error("Authentication timeout after 30s - server may be under heavy load. Try again in a few seconds."));
         }, AUTH_TIMEOUT);
         const authHandler = () => {
           clearTimeout(timeout);
-          resolve2();
+          resolve3();
         };
         client.once("auth_success", authHandler);
         const errorHandler = (message) => {
@@ -5937,9 +6955,9 @@ var Daemon = class _Daemon {
         client.once("auth_error", errorHandler);
       });
       await client.connect(wsUrl, config.access_token, this.machineId, {
-        hostname: os4.hostname(),
-        osPlatform: os4.platform(),
-        osArch: os4.arch(),
+        hostname: os5.hostname(),
+        osPlatform: os5.platform(),
+        osArch: os5.arch(),
         daemonPid
       });
       console.log(`[Daemon] Successfully connected to project ${projectId}`);
@@ -6034,27 +7052,27 @@ var Daemon = class _Daemon {
    */
   async installGitHooks(projectPath) {
     const hooks = ["post-checkout", "pre-commit", "post-commit"];
-    const hooksDir = path12.join(projectPath, ".git", "hooks");
-    if (!fs11.existsSync(hooksDir)) {
+    const hooksDir = path14.join(projectPath, ".git", "hooks");
+    if (!fs13.existsSync(hooksDir)) {
       console.warn(`[Daemon] Hooks directory not found: ${hooksDir}`);
       return;
     }
     for (const hookName of hooks) {
       try {
-        const hookPath = path12.join(hooksDir, hookName);
-        const bundledHookPath = path12.join(__dirname, "..", "hooks", hookName);
-        if (!fs11.existsSync(bundledHookPath)) {
+        const hookPath = path14.join(hooksDir, hookName);
+        const bundledHookPath = path14.join(__dirname, "..", "hooks", hookName);
+        if (!fs13.existsSync(bundledHookPath)) {
           console.warn(`[Daemon] Bundled hook not found: ${bundledHookPath}`);
           continue;
         }
-        const hookContent = fs11.readFileSync(bundledHookPath, "utf-8");
-        if (fs11.existsSync(hookPath)) {
-          const existingContent = fs11.readFileSync(hookPath, "utf-8");
+        const hookContent = fs13.readFileSync(bundledHookPath, "utf-8");
+        if (fs13.existsSync(hookPath)) {
+          const existingContent = fs13.readFileSync(hookPath, "utf-8");
           if (existingContent === hookContent) {
             continue;
           }
         }
-        fs11.writeFileSync(hookPath, hookContent, { mode: 493 });
+        fs13.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);
@@ -6069,7 +7087,7 @@ var Daemon = class _Daemon {
    */
   async cacheDeviceId(deviceId) {
     try {
-      const config = await (0, import_core7.loadConfig)();
+      const config = await (0, import_core10.loadConfig)();
       if (!config) {
         console.warn("[Daemon] Cannot cache device ID - no config found");
         return;
@@ -6082,12 +7100,39 @@ var Daemon = class _Daemon {
         device_id: deviceId,
         machine_id: this.machineId
       };
-      await (0, import_core7.saveConfig)(updatedConfig);
+      await (0, import_core10.saveConfig)(updatedConfig);
       console.log(`[Daemon] Cached device ID to config: ${deviceId}`);
     } catch (error) {
       console.warn("[Daemon] Failed to cache device ID:", error instanceof Error ? error.message : error);
     }
   }
+  /**
+   * EP956: Cleanup module worktree when module moves to done
+   *
+   * Runs asynchronously to reduce burden on the state change handler.
+   * Steps:
+   * 1. Stop dev server for the module
+   * 2. Log worktree path for potential removal (actual removal TBD)
+   *
+   * Note: Worktree removal requires git worktree remove command, which
+   * needs careful handling to avoid data loss. For now, just stop the
+   * dev server and log the path.
+   */
+  async cleanupModuleWorktree(moduleUid) {
+    console.log(`[Daemon] EP956: Starting async cleanup for ${moduleUid}`);
+    try {
+      await stopDevServer(moduleUid);
+      console.log(`[Daemon] EP956: Dev server stopped for ${moduleUid}`);
+      const worktree = await getWorktreeInfoForModule(moduleUid);
+      if (worktree?.exists) {
+        console.log(`[Daemon] EP956: Worktree for ${moduleUid} at ${worktree.path} is ready for cleanup`);
+      }
+      console.log(`[Daemon] EP956: Async cleanup complete for ${moduleUid}`);
+    } catch (error) {
+      console.error(`[Daemon] EP956: Cleanup error for ${moduleUid}:`, error instanceof Error ? error.message : error);
+      throw error;
+    }
+  }
   /**
    * EP819: Auto-start tunnels for active local modules on daemon connect/reconnect
    *
@@ -6097,7 +7142,7 @@ var Daemon = class _Daemon {
   async autoStartTunnelsForProject(projectPath, projectUid) {
     console.log(`[Daemon] EP819: Checking for active local modules to auto-start tunnels...`);
     try {
-      const config = await (0, import_core7.loadConfig)();
+      const config = await (0, import_core10.loadConfig)();
       if (!config?.access_token) {
         console.warn(`[Daemon] EP819: No access token, skipping tunnel auto-start`);
         return;
@@ -6114,6 +7159,33 @@ var Daemon = class _Daemon {
       const modules = data.modules || [];
       const tunnelManager = getTunnelManager();
       await tunnelManager.initialize();
+      const activeTunnelUids = tunnelManager.getActiveModuleUids();
+      const validModuleUids = new Set(
+        modules.filter(
+          (m) => m.dev_mode === "local" && (!m.checkout_machine_id || m.checkout_machine_id === this.deviceId)
+        ).map((m) => m.uid)
+      );
+      const orphanedTunnels = activeTunnelUids.filter((uid) => !validModuleUids.has(uid));
+      if (orphanedTunnels.length > 0) {
+        console.log(`[Daemon] EP956: Found ${orphanedTunnels.length} orphaned tunnels to stop: ${orphanedTunnels.join(", ")}`);
+        for (const orphanUid of orphanedTunnels) {
+          try {
+            await tunnelManager.stopTunnel(orphanUid);
+            releasePort(orphanUid);
+            console.log(`[Daemon] EP956: Stopped orphaned tunnel and released port for ${orphanUid}`);
+            try {
+              await fetchWithAuth(`${apiUrl}/api/modules/${orphanUid}/tunnel`, {
+                method: "POST",
+                body: JSON.stringify({ tunnel_url: null })
+              });
+            } catch (err) {
+              console.warn(`[Daemon] EP956: Failed to clear tunnel URL for ${orphanUid}:`, err instanceof Error ? err.message : err);
+            }
+          } catch (err) {
+            console.error(`[Daemon] EP956: Failed to stop orphaned tunnel ${orphanUid}:`, err instanceof Error ? err.message : err);
+          }
+        }
+      }
       const localModulesNeedingTunnel = modules.filter(
         (m) => m.dev_mode === "local" && (!m.checkout_machine_id || m.checkout_machine_id === this.deviceId) && !tunnelManager.hasTunnel(m.uid)
       );
@@ -6121,11 +7193,20 @@ var Daemon = class _Daemon {
         console.log(`[Daemon] EP819: No local modules need tunnel auto-start`);
         return;
       }
-      console.log(`[Daemon] EP819: Found ${localModulesNeedingTunnel.length} local modules needing tunnels`);
+      console.log(`[Daemon] EP956: Found ${localModulesNeedingTunnel.length} local modules needing tunnels`);
       for (const module2 of localModulesNeedingTunnel) {
         const moduleUid = module2.uid;
-        const port = detectDevPort(projectPath);
-        console.log(`[Daemon] EP819: Auto-starting tunnel for ${moduleUid} on port ${port}`);
+        const worktree = await getWorktreeInfoForModule(moduleUid);
+        if (!worktree) {
+          console.warn(`[Daemon] EP956: Cannot resolve worktree for ${moduleUid} (missing config slugs)`);
+          continue;
+        }
+        if (!worktree.exists) {
+          console.log(`[Daemon] EP956: No worktree for ${moduleUid} at ${worktree.path}, skipping`);
+          continue;
+        }
+        const port = allocatePort(moduleUid);
+        console.log(`[Daemon] EP956: Auto-starting tunnel for ${moduleUid} at ${worktree.path} on port ${port}`);
         const reportTunnelStatus = async (statusData) => {
           try {
             const statusResponse = await fetchWithAuth(`${apiUrl}/api/modules/${moduleUid}/tunnel`, {
@@ -6144,25 +7225,26 @@ var Daemon = class _Daemon {
         (async () => {
           await this.withTunnelLock(moduleUid, async () => {
             if (tunnelManager.hasTunnel(moduleUid)) {
-              console.log(`[Daemon] EP819: Tunnel already running for ${moduleUid}, skipping auto-start`);
+              console.log(`[Daemon] EP956: Tunnel already running for ${moduleUid}, skipping auto-start`);
               return;
             }
             const MAX_RETRIES = 3;
-            const RETRY_DELAY_MS = 2e3;
+            const RETRY_DELAY_MS = 3e3;
             await reportTunnelStatus({
               tunnel_started_at: (/* @__PURE__ */ new Date()).toISOString(),
               tunnel_error: null
             });
             try {
-              console.log(`[Daemon] EP819: Ensuring dev server is running for ${moduleUid}...`);
-              const devServerResult = await ensureDevServer(projectPath, port, moduleUid);
+              console.log(`[Daemon] EP956: Ensuring dev server is running for ${moduleUid} at ${worktree.path}...`);
+              const devServerResult = await ensureDevServer(worktree.path, port, moduleUid);
               if (!devServerResult.success) {
                 const errorMsg2 = `Dev server failed to start: ${devServerResult.error}`;
-                console.error(`[Daemon] EP819: ${errorMsg2}`);
+                console.error(`[Daemon] EP956: ${errorMsg2}`);
                 await reportTunnelStatus({ tunnel_error: errorMsg2 });
+                releasePort(moduleUid);
                 return;
               }
-              console.log(`[Daemon] EP819: Dev server ready on port ${port}`);
+              console.log(`[Daemon] EP956: Dev server ready on port ${port}`);
               let lastError;
               for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
                 console.log(`[Daemon] EP819: Starting tunnel for ${moduleUid} (attempt ${attempt}/${MAX_RETRIES})...`);
@@ -6193,16 +7275,18 @@ var Daemon = class _Daemon {
                 console.warn(`[Daemon] EP819: Tunnel start attempt ${attempt} failed: ${lastError}`);
                 if (attempt < MAX_RETRIES) {
                   console.log(`[Daemon] EP819: Retrying in ${RETRY_DELAY_MS}ms...`);
-                  await new Promise((resolve2) => setTimeout(resolve2, RETRY_DELAY_MS));
+                  await new Promise((resolve3) => setTimeout(resolve3, RETRY_DELAY_MS));
                 }
               }
               const errorMsg = `Tunnel failed after ${MAX_RETRIES} attempts: ${lastError}`;
-              console.error(`[Daemon] EP819: ${errorMsg}`);
+              console.error(`[Daemon] EP956: ${errorMsg}`);
               await reportTunnelStatus({ tunnel_error: errorMsg });
+              releasePort(moduleUid);
             } catch (error) {
               const errorMsg = error instanceof Error ? error.message : String(error);
-              console.error(`[Daemon] EP819: Async tunnel startup error:`, error);
+              console.error(`[Daemon] EP956: Async tunnel startup error:`, error);
               await reportTunnelStatus({ tunnel_error: errorMsg });
+              releasePort(moduleUid);
             }
           });
         })();
@@ -6249,7 +7333,7 @@ var Daemon = class _Daemon {
       }
       this.healthCheckInProgress = true;
       try {
-        const config = await (0, import_core7.loadConfig)();
+        const config = await (0, import_core10.loadConfig)();
         if (config?.access_token) {
           await this.performHealthChecks(config);
         }
@@ -6306,6 +7390,91 @@ var Daemon = class _Daemon {
       console.error("[Daemon] EP904: Failed to clean up orphaned tunnels:", error);
     }
   }
+  /**
+   * EP957: Audit worktrees on daemon startup to detect orphaned worktrees
+   *
+   * Compares local worktrees against active modules (doing/review state).
+   * Logs orphaned worktrees for visibility but does NOT auto-cleanup - that's
+   * the user's decision via `episoda release` or manual cleanup.
+   *
+   * This is a non-blocking diagnostic - failures are logged but don't affect startup.
+   */
+  async auditWorktreesOnStartup() {
+    try {
+      const projects = getAllProjects();
+      for (const project of projects) {
+        await this.auditProjectWorktrees(project.path);
+      }
+    } catch (error) {
+      console.warn("[Daemon] EP957: Worktree audit failed (non-blocking):", error);
+    }
+  }
+  /**
+   * EP957: Audit worktrees for a single project
+   */
+  async auditProjectWorktrees(projectPath) {
+    try {
+      const projectRoot = await findProjectRoot(projectPath);
+      if (!projectRoot) {
+        return;
+      }
+      const manager = new WorktreeManager(projectRoot);
+      if (!await manager.initialize()) {
+        return;
+      }
+      const config = manager.getConfig();
+      if (!config) {
+        return;
+      }
+      const worktrees = manager.listWorktrees();
+      if (worktrees.length === 0) {
+        return;
+      }
+      const activeModuleUids = await this.fetchActiveModuleUids(config.projectId);
+      if (activeModuleUids === null) {
+        return;
+      }
+      const { orphaned } = manager.auditWorktrees(activeModuleUids);
+      if (orphaned.length > 0) {
+        console.log(`[Daemon] EP957: Found ${orphaned.length} orphaned worktree(s) in ${config.workspaceSlug}/${config.projectSlug}:`);
+        for (const w of orphaned) {
+          console.log(`  - ${w.moduleUid} (branch: ${w.branchName})`);
+        }
+        console.log('[Daemon] EP957: Run "episoda release <module>" to clean up');
+      }
+    } catch (error) {
+      console.warn(`[Daemon] EP957: Failed to audit ${projectPath}:`, error);
+    }
+  }
+  /**
+   * EP957: Fetch UIDs of active modules (doing/review state) for a project
+   * Returns null if fetch fails (non-blocking)
+   */
+  async fetchActiveModuleUids(projectId) {
+    try {
+      const config = await (0, import_core10.loadConfig)();
+      if (!config?.access_token || !config?.api_url) {
+        return null;
+      }
+      const url = `${config.api_url}/api/modules?project_id=${projectId}&state=doing,review`;
+      const response = await fetch(url, {
+        headers: {
+          "Authorization": `Bearer ${config.access_token}`,
+          "Content-Type": "application/json"
+        }
+      });
+      if (!response.ok) {
+        return null;
+      }
+      const data = await response.json();
+      if (!data.success || !data.modules) {
+        return null;
+      }
+      return data.modules.map((m) => m.uid).filter((uid) => !!uid);
+    } catch {
+      return null;
+    }
+  }
   // EP843: syncTunnelsWithActiveModules() removed - replaced by push-based state sync
   // See module_state_changed handler for the new implementation
   /**
@@ -6389,7 +7558,7 @@ var Daemon = class _Daemon {
     const tunnelManager = getTunnelManager();
     try {
       await tunnelManager.stopTunnel(moduleUid);
-      const config = await (0, import_core7.loadConfig)();
+      const config = await (0, import_core10.loadConfig)();
       if (!config?.access_token) {
         console.error(`[Daemon] EP833: No access token for tunnel restart`);
         return;
@@ -6493,11 +7662,11 @@ var Daemon = class _Daemon {
    * Used to clean up orphaned cloudflared processes
    */
   async killProcessesByPattern(pattern) {
-    const { exec } = await import("child_process");
-    const { promisify } = await import("util");
-    const execAsync = promisify(exec);
+    const { exec: exec2 } = await import("child_process");
+    const { promisify: promisify2 } = await import("util");
+    const execAsync2 = promisify2(exec2);
     try {
-      const { stdout } = await execAsync(`pgrep -f "${pattern}"`);
+      const { stdout } = await execAsync2(`pgrep -f "${pattern}"`);
       const pids = stdout.trim().split("\n").filter(Boolean);
       if (pids.length === 0) {
         return 0;
@@ -6505,7 +7674,7 @@ var Daemon = class _Daemon {
       let killed = 0;
       for (const pid of pids) {
         try {
-          await execAsync(`kill ${pid}`);
+          await execAsync2(`kill ${pid}`);
           killed++;
         } catch {
         }
@@ -6523,11 +7692,11 @@ var Daemon = class _Daemon {
    * Used to clean up dev servers when stopping tunnels
    */
   async killProcessOnPort(port) {
-    const { exec } = await import("child_process");
-    const { promisify } = await import("util");
-    const execAsync = promisify(exec);
+    const { exec: exec2 } = await import("child_process");
+    const { promisify: promisify2 } = await import("util");
+    const execAsync2 = promisify2(exec2);
     try {
-      const { stdout } = await execAsync(`lsof -ti :${port}`);
+      const { stdout } = await execAsync2(`lsof -ti :${port}`);
       const pids = stdout.trim().split("\n").filter(Boolean);
       if (pids.length === 0) {
         return false;
@@ -6535,7 +7704,7 @@ var Daemon = class _Daemon {
       let killed = false;
       for (const pid of pids) {
         try {
-          await execAsync(`kill ${pid}`);
+          await execAsync2(`kill ${pid}`);
           killed = true;
         } catch {
         }
@@ -6553,11 +7722,11 @@ var Daemon = class _Daemon {
    * Returns process info for cloudflared processes not tracked by TunnelManager
    */
   async findOrphanedCloudflaredProcesses() {
-    const { exec } = await import("child_process");
-    const { promisify } = await import("util");
-    const execAsync = promisify(exec);
+    const { exec: exec2 } = await import("child_process");
+    const { promisify: promisify2 } = await import("util");
+    const execAsync2 = promisify2(exec2);
     try {
-      const { stdout } = await execAsync("ps aux | grep cloudflared | grep -v grep");
+      const { stdout } = await execAsync2("ps aux | grep cloudflared | grep -v grep");
       const lines = stdout.trim().split("\n").filter(Boolean);
       const tunnelManager = getTunnelManager();
       const trackedModules = new Set(tunnelManager.getAllTunnels().map((t) => t.moduleUid));
@@ -6617,6 +7786,7 @@ var Daemon = class _Daemon {
     } catch (error) {
       console.error("[Daemon] Failed to stop tunnels:", error);
     }
+    clearAllPorts();
     try {
       const agentManager = getAgentManager();
       await agentManager.stopAllSessions();
@@ -6635,8 +7805,8 @@ var Daemon = class _Daemon {
     await this.shutdown();
     try {
       const pidPath = getPidFilePath();
-      if (fs11.existsSync(pidPath)) {
-        fs11.unlinkSync(pidPath);
+      if (fs13.existsSync(pidPath)) {
+        fs13.unlinkSync(pidPath);
         console.log("[Daemon] PID file cleaned up");
       }
     } catch (error) {