episoda 0.2.109 → 0.2.111

package/dist/daemon/daemon-process.js

@@ -2815,7 +2815,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.108",
+      version: "0.2.110",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -4202,7 +4202,7 @@ var WorktreeManager = class _WorktreeManager {
    * Create a worktree for a module
    * The entire operation is locked to prevent race conditions
    */
-  async createWorktree(moduleUid, branchName, createBranch = false, detachedHead = false) {
+  async createWorktree(moduleUid, branchName, createBranch = false) {
     if (!validateModuleUid(moduleUid)) {
       return {
         success: false,
@@ -4241,13 +4241,9 @@ var WorktreeManager = class _WorktreeManager {
       const result = await this.gitExecutor.execute({
         action: "worktree_add",
         path: worktreePath,
-        branch: detachedHead ? void 0 : branchName,
-        // No branch for detached HEAD
-        create: detachedHead ? false : createBranch,
-        // Don't create branch for detached
-        detach: detachedHead,
-        // EP1223: Detach flag
-        startPoint: detachedHead ? "origin/main" : createBranch ? "origin/main" : void 0
+        branch: branchName,
+        create: createBranch,
+        startPoint: createBranch ? "origin/main" : void 0
       }, { cwd: this.bareRepoPath });
       if (!result.success) {
         return {
@@ -7524,13 +7520,12 @@ async function handleWorktreeCreate(request2) {
     createBranch,
     repoUrl,
     envVars,
-    setupScript,
-    detachedHead = false
-    // EP1223: Default to false for backward compatibility
+    setupScript
+    // EP1229: detachedHead removed - planning worktrees no longer exist
   } = request2;
   console.log(`[Worktree] K1273: Creating worktree for ${moduleUid}`);
   console.log(`[Worktree]   Project: ${projectSlug}`);
-  console.log(`[Worktree]   Branch: ${branchName} (create: ${createBranch}, detached: ${detachedHead})`);
+  console.log(`[Worktree]   Branch: ${branchName} (create: ${createBranch})`);
   if (!validateModuleUid(moduleUid)) {
     return {
       success: false,
@@ -7584,7 +7579,7 @@ async function handleWorktreeCreate(request2) {
         error: `Failed to initialize WorktreeManager at ${projectPath}`
       };
     }
-    const result = await manager.createWorktree(moduleUid, branchName, createBranch, detachedHead);
+    const result = await manager.createWorktree(moduleUid, branchName, createBranch);
     if (!result.success) {
       return {
         success: false,
@@ -7980,35 +7975,6 @@ async function handleProjectSetup(params) {
     };
   }
 }
-async function handleFolderCleanup(projectPath, moduleUid) {
-  if (!moduleUid || !UUID_REGEX.test(moduleUid)) {
-    console.error(`[FolderCleanup] EP1226: Invalid moduleUid format: ${moduleUid}`);
-    return { success: false, error: "Invalid moduleUid format" };
-  }
-  const folderPath = path17.join(projectPath, moduleUid);
-  console.log(`[FolderCleanup] EP1226: Cleaning up module folder: ${folderPath}`);
-  try {
-    try {
-      await fs16.promises.access(folderPath);
-    } catch {
-      console.log(`[FolderCleanup] EP1226: Module folder does not exist, nothing to clean: ${folderPath}`);
-      return { success: true, folderPath };
-    }
-    await fs16.promises.rm(folderPath, { recursive: true, force: true });
-    console.log(`[FolderCleanup] EP1226: Module folder removed: ${folderPath}`);
-    return {
-      success: true,
-      folderPath
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    console.error(`[FolderCleanup] EP1226: Cleanup failed:`, errorMessage);
-    return {
-      success: false,
-      error: errorMessage
-    };
-  }
-}
 
 // src/daemon/handlers/stale-commit-cleanup.ts
 var import_child_process9 = require("child_process");
@@ -10479,10 +10445,7 @@ var Daemon = class _Daemon {
             case "project:setup":
               result = await handleProjectSetup(cmd);
               break;
-            // EP1226: Module folder cleanup
-            case "folder:cleanup":
-              result = await handleFolderCleanup(projectPath, cmd.moduleUid);
-              break;
+            // EP1229: folder:cleanup removed (module folders no longer used)
             default:
               result = {
                 success: false,
@@ -10661,17 +10624,26 @@ var Daemon = class _Daemon {
               } else {
                 console.log(`[Daemon] EP1205: Worktree requested but not found for ${cmd.moduleUid}, using project root`);
               }
-            } else if (cmd.sessionContext === "module_folder" && cmd.moduleUid) {
-              const moduleFolderPath = path24.join(projectPath, cmd.moduleUid);
-              try {
-                await fs23.promises.mkdir(moduleFolderPath, { recursive: true });
-                agentWorkingDir = moduleFolderPath;
-                console.log(`[Daemon] EP1226: Agent for ${cmd.moduleUid} in module folder: ${agentWorkingDir}`);
-              } catch (err) {
-                console.error(`[Daemon] EP1226: Failed to create module folder ${moduleFolderPath}, using project root:`, err);
-              }
             } else if (cmd.sessionContext === "project_root") {
-              console.log(`[Daemon] EP1205: Agent for ${cmd.moduleUid || "project"} in project root (sessionContext=project_root)`);
+              if (cmd.workspaceSlug && cmd.projectSlug) {
+                const resolvedProjectPath = path24.join(
+                  process.env.HOME || projectPath,
+                  "episoda",
+                  cmd.workspaceSlug,
+                  cmd.projectSlug
+                );
+                if (resolvedProjectPath !== projectPath) {
+                  try {
+                    await fs23.promises.access(resolvedProjectPath);
+                    agentWorkingDir = resolvedProjectPath;
+                    console.log(`[Daemon] EP1227: Agent for ${cmd.moduleUid || "project"} in resolved project path: ${agentWorkingDir}`);
+                  } catch {
+                    console.log(`[Daemon] EP1227: Resolved project path not found, using projectPath: ${projectPath}`);
+                  }
+                }
+              } else {
+                console.log(`[Daemon] EP1205: Agent for ${cmd.moduleUid || "project"} in project root (sessionContext=project_root)`);
+              }
             } else {
               if (cmd.moduleUid) {
                 const worktreeInfo = await getWorktreeInfoForModule(cmd.moduleUid);