episoda 0.2.19 → 0.2.21

package/dist/index.js

@@ -295,7 +295,7 @@ var require_git_executor = __commonJS({
     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 GitExecutor = class {
+    var GitExecutor6 = class {
       /**
        * Execute a git command
        * @param command - The git command to execute
@@ -381,6 +381,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,
@@ -1518,15 +1531,15 @@ var require_git_executor = __commonJS({
           try {
             const { stdout: gitDir } = await execAsync("git rev-parse --git-dir", { cwd, timeout: 5e3 });
             const gitDirPath = gitDir.trim();
-            const fs6 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+            const fs12 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
             const rebaseMergePath = `${gitDirPath}/rebase-merge`;
             const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
             try {
-              await fs6.access(rebaseMergePath);
+              await fs12.access(rebaseMergePath);
               inRebase = true;
             } catch {
               try {
-                await fs6.access(rebaseApplyPath);
+                await fs12.access(rebaseApplyPath);
                 inRebase = true;
               } catch {
                 inRebase = false;
@@ -1564,6 +1577,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 fs12 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          try {
+            await fs12.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 fs12 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          try {
+            await fs12.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 execAsync("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 execAsync("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 fs12 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path14 = await Promise.resolve().then(() => __importStar(require("path")));
+          try {
+            await fs12.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 = path14.dirname(command.path);
+          try {
+            await fs12.mkdir(parentDir, { recursive: true });
+          } catch {
+          }
+          const { stdout, stderr } = await execAsync(
+            `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 fs12 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path14 = 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 = path14.join(currentPath, ".bare");
+            const episodaDir = path14.join(currentPath, ".episoda");
+            try {
+              await fs12.access(bareDir);
+              await fs12.access(episodaDir);
+              worktreeMode = true;
+              projectPath = currentPath;
+              bareRepoPath = bareDir;
+              break;
+            } catch {
+              const parentPath = path14.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
        */
@@ -1663,7 +1998,7 @@ var require_git_executor = __commonJS({
         }
       }
     };
-    exports2.GitExecutor = GitExecutor;
+    exports2.GitExecutor = GitExecutor6;
   }
 });
 
@@ -1754,7 +2089,7 @@ var require_websocket_client = __commonJS({
           clearTimeout(this.reconnectTimeout);
           this.reconnectTimeout = void 0;
         }
-        return new Promise((resolve2, reject) => {
+        return new Promise((resolve4, reject) => {
           const connectionTimeout = setTimeout(() => {
             if (this.ws) {
               this.ws.terminate();
@@ -1781,7 +2116,7 @@ var require_websocket_client = __commonJS({
                 daemonPid: this.daemonPid
               });
               this.startHeartbeat();
-              resolve2();
+              resolve4();
             });
             this.ws.on("pong", () => {
               if (this.heartbeatTimeoutTimer) {
@@ -1897,13 +2232,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((resolve4, reject) => {
           this.ws.send(JSON.stringify(message), (error) => {
             if (error) {
               console.error("[EpisodaClient] Failed to send message:", error);
               reject(error);
             } else {
-              resolve2();
+              resolve4();
             }
           });
         });
@@ -2016,12 +2351,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) {
@@ -2129,36 +2465,36 @@ var require_auth = __commonJS({
       };
     })();
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.getConfigDir = getConfigDir4;
+    exports2.getConfigDir = getConfigDir5;
     exports2.getConfigPath = getConfigPath4;
-    exports2.loadConfig = loadConfig3;
-    exports2.saveConfig = saveConfig4;
+    exports2.loadConfig = loadConfig7;
+    exports2.saveConfig = saveConfig5;
     exports2.validateToken = validateToken;
-    var fs6 = __importStar(require("fs"));
-    var path8 = __importStar(require("path"));
+    var fs12 = __importStar(require("fs"));
+    var path14 = __importStar(require("path"));
     var os3 = __importStar(require("os"));
     var child_process_1 = require("child_process");
     var DEFAULT_CONFIG_FILE = "config.json";
-    function getConfigDir4() {
-      return process.env.EPISODA_CONFIG_DIR || path8.join(os3.homedir(), ".episoda");
+    function getConfigDir5() {
+      return process.env.EPISODA_CONFIG_DIR || path14.join(os3.homedir(), ".episoda");
     }
     function getConfigPath4(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path8.join(getConfigDir4(), DEFAULT_CONFIG_FILE);
+      return path14.join(getConfigDir5(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path8.dirname(configPath);
-      const isNew = !fs6.existsSync(dir);
+      const dir = path14.dirname(configPath);
+      const isNew = !fs12.existsSync(dir);
       if (isNew) {
-        fs6.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs12.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path8.join(dir, ".nosync");
-        if (isNew || !fs6.existsSync(nosyncPath)) {
+        const nosyncPath = path14.join(dir, ".nosync");
+        if (isNew || !fs12.existsSync(nosyncPath)) {
           try {
-            fs6.writeFileSync(nosyncPath, "", { mode: 384 });
+            fs12.writeFileSync(nosyncPath, "", { mode: 384 });
             (0, child_process_1.execSync)(`xattr -w com.apple.fileprovider.ignore 1 "${dir}"`, {
               stdio: "ignore",
               timeout: 5e3
@@ -2168,13 +2504,13 @@ var require_auth = __commonJS({
         }
       }
     }
-    async function loadConfig3(configPath) {
+    async function loadConfig7(configPath) {
       const fullPath = getConfigPath4(configPath);
-      if (!fs6.existsSync(fullPath)) {
+      if (!fs12.existsSync(fullPath)) {
         return null;
       }
       try {
-        const content = fs6.readFileSync(fullPath, "utf8");
+        const content = fs12.readFileSync(fullPath, "utf8");
         const config = JSON.parse(content);
         return config;
       } catch (error) {
@@ -2182,12 +2518,12 @@ var require_auth = __commonJS({
         return null;
       }
     }
-    async function saveConfig4(config, configPath) {
+    async function saveConfig5(config, configPath) {
       const fullPath = getConfigPath4(configPath);
       ensureConfigDir(fullPath);
       try {
         const content = JSON.stringify(config, null, 2);
-        fs6.writeFileSync(fullPath, content, { mode: 384 });
+        fs12.writeFileSync(fullPath, content, { mode: 384 });
       } catch (error) {
         throw new Error(`Failed to save config: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -2227,6 +2563,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}`;
@@ -2293,10 +2634,10 @@ var require_dist = __commonJS({
 
 // src/index.ts
 var import_commander = require("commander");
-var import_core8 = __toESM(require_dist());
+var import_core15 = __toESM(require_dist());
 
 // src/commands/dev.ts
-var import_core3 = __toESM(require_dist());
+var import_core6 = __toESM(require_dist());
 
 // src/framework-detector.ts
 var fs = __toESM(require("fs"));
@@ -2630,7 +2971,7 @@ async function startDaemon() {
   const pid = child.pid;
   const pidPath = getPidFilePath();
   fs2.writeFileSync(pidPath, pid.toString(), "utf-8");
-  await new Promise((resolve2) => setTimeout(resolve2, 500));
+  await new Promise((resolve4) => setTimeout(resolve4, 500));
   const runningPid = isDaemonRunning();
   if (!runningPid) {
     throw new Error("Daemon failed to start");
@@ -2652,7 +2993,7 @@ async function stopDaemon(timeout = 5e3) {
     while (Date.now() - startTime < timeout) {
       try {
         process.kill(pid, 0);
-        await new Promise((resolve2) => setTimeout(resolve2, 100));
+        await new Promise((resolve4) => setTimeout(resolve4, 100));
       } catch (error) {
         const pidPath2 = getPidFilePath();
         if (fs2.existsSync(pidPath2)) {
@@ -2682,7 +3023,7 @@ var import_core2 = __toESM(require_dist());
 var getSocketPath = () => path3.join((0, import_core2.getConfigDir)(), "daemon.sock");
 var DEFAULT_TIMEOUT = 15e3;
 async function sendCommand(command, params, timeout = DEFAULT_TIMEOUT) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     const socket = net.createConnection(getSocketPath());
     const requestId = crypto.randomUUID();
     let buffer = "";
@@ -2713,7 +3054,7 @@ async function sendCommand(command, params, timeout = DEFAULT_TIMEOUT) {
         clearTimeout(timeoutHandle);
         socket.end();
         if (response.success) {
-          resolve2(response.data);
+          resolve4(response.data);
         } else {
           reject(new Error(response.error || "Command failed"));
         }
@@ -2769,40 +3110,889 @@ async function getDevServerStatus() {
 }
 
 // src/commands/dev.ts
-var import_child_process2 = require("child_process");
-var path4 = __toESM(require("path"));
+var import_child_process3 = require("child_process");
+var path7 = __toESM(require("path"));
+var fs6 = __toESM(require("fs"));
 
 // src/utils/port-check.ts
 var net2 = __toESM(require("net"));
 async function isPortInUse(port) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve4) => {
     const server = net2.createServer();
     server.once("error", (err) => {
       if (err.code === "EADDRINUSE") {
-        resolve2(true);
+        resolve4(true);
       } else {
-        resolve2(false);
+        resolve4(false);
+      }
+    });
+    server.once("listening", () => {
+      server.close();
+      resolve4(false);
+    });
+    server.listen(port);
+  });
+}
+function getServerPort() {
+  if (process.env.PORT) {
+    return parseInt(process.env.PORT, 10);
+  }
+  return 3e3;
+}
+
+// src/daemon/worktree-manager.ts
+var fs3 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+var import_core3 = __toESM(require_dist());
+function validateModuleUid(moduleUid) {
+  if (!moduleUid || typeof moduleUid !== "string" || !moduleUid.trim()) {
+    return false;
+  }
+  if (moduleUid.includes("/") || moduleUid.includes("\\") || moduleUid.includes("..")) {
+    return false;
+  }
+  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 = path4.join(projectRoot, ".bare");
+    this.configPath = path4.join(projectRoot, ".episoda", "config.json");
+    this.gitExecutor = new import_core3.GitExecutor();
+  }
+  /**
+   * Initialize worktree manager from existing project root
+   * @returns true if valid worktree project, false otherwise
+   */
+  async initialize() {
+    if (!fs3.existsSync(this.bareRepoPath)) {
+      return false;
+    }
+    if (!fs3.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 = path4.join(projectRoot, ".episoda");
+    fs3.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 = path4.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) => fs3.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 {
+        fs3.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+        return true;
+      } catch (err) {
+        if (err.code === "EEXIST") {
+          try {
+            const stats = fs3.statSync(lockPath);
+            const lockAge = Date.now() - stats.mtimeMs;
+            if (lockAge > 3e4) {
+              try {
+                const lockContent = fs3.readFileSync(lockPath, "utf-8").trim();
+                const lockPid = parseInt(lockContent, 10);
+                if (!isNaN(lockPid) && this.isProcessRunning(lockPid)) {
+                  await new Promise((resolve4) => setTimeout(resolve4, retryInterval));
+                  continue;
+                }
+              } catch {
+              }
+              try {
+                fs3.unlinkSync(lockPath);
+              } catch {
+              }
+              continue;
+            }
+          } catch {
+            continue;
+          }
+          await new Promise((resolve4) => setTimeout(resolve4, retryInterval));
+          continue;
+        }
+        throw err;
+      }
+    }
+    return false;
+  }
+  /**
+   * Release the file lock
+   */
+  releaseLock() {
+    try {
+      fs3.unlinkSync(this.getLockPath());
+    } catch {
+    }
+  }
+  readConfig() {
+    try {
+      if (!fs3.existsSync(this.configPath)) {
+        return null;
+      }
+      const content = fs3.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 = path4.dirname(this.configPath);
+      if (!fs3.existsSync(dir)) {
+        fs3.mkdirSync(dir, { recursive: true });
+      }
+      fs3.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 || path4.join(require("os").homedir(), "episoda");
+}
+function getProjectPath(workspaceSlug, projectSlug) {
+  return path4.join(getEpisodaRoot(), workspaceSlug, projectSlug);
+}
+async function isWorktreeProject(projectRoot) {
+  const manager = new WorktreeManager(projectRoot);
+  return manager.initialize();
+}
+async function findProjectRoot(startPath) {
+  let current = path4.resolve(startPath);
+  const episodaRoot = getEpisodaRoot();
+  if (!current.startsWith(episodaRoot)) {
+    return null;
+  }
+  for (let i = 0; i < 10; i++) {
+    const bareDir = path4.join(current, ".bare");
+    const episodaDir = path4.join(current, ".episoda");
+    if (fs3.existsSync(bareDir) && fs3.existsSync(episodaDir)) {
+      if (await isWorktreeProject(current)) {
+        return current;
+      }
+    }
+    const parent = path4.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return null;
+}
+
+// src/commands/migrate.ts
+var fs5 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
+var import_child_process2 = require("child_process");
+var import_core5 = __toESM(require_dist());
+
+// src/daemon/project-tracker.ts
+var fs4 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+var import_core4 = __toESM(require_dist());
+function getProjectsFilePath() {
+  return path5.join((0, import_core4.getConfigDir)(), "projects.json");
+}
+function readProjects() {
+  const projectsPath = getProjectsFilePath();
+  try {
+    if (!fs4.existsSync(projectsPath)) {
+      return { projects: [] };
+    }
+    const content = fs4.readFileSync(projectsPath, "utf-8");
+    const data = JSON.parse(content);
+    if (!data.projects || !Array.isArray(data.projects)) {
+      console.warn("Invalid projects.json structure, resetting");
+      return { projects: [] };
+    }
+    return data;
+  } catch (error) {
+    console.error("Error reading projects.json:", error);
+    return { projects: [] };
+  }
+}
+function writeProjects(data) {
+  const projectsPath = getProjectsFilePath();
+  try {
+    const dir = path5.dirname(projectsPath);
+    if (!fs4.existsSync(dir)) {
+      fs4.mkdirSync(dir, { recursive: true });
+    }
+    fs4.writeFileSync(projectsPath, JSON.stringify(data, null, 2), "utf-8");
+  } catch (error) {
+    throw new Error(`Failed to write projects.json: ${error}`);
+  }
+}
+function addProject2(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;
+  }
+  const existingByIdIndex = data.projects.findIndex((p) => p.id === projectId);
+  if (existingByIdIndex !== -1) {
+    const existingById = data.projects[existingByIdIndex];
+    console.log(`[ProjectTracker] Replacing project entry: ${existingById.path} -> ${projectPath}`);
+    data.projects.splice(existingByIdIndex, 1);
+  }
+  const projectName = path5.basename(projectPath);
+  const newProject = {
+    id: projectId,
+    path: projectPath,
+    name: projectName,
+    added_at: now,
+    last_active: now,
+    // EP944: Worktree mode fields
+    worktreeMode: options?.worktreeMode,
+    bareRepoPath: options?.bareRepoPath
+  };
+  data.projects.push(newProject);
+  writeProjects(data);
+  return newProject;
+}
+function getProject(projectPath) {
+  const data = readProjects();
+  return data.projects.find((p) => p.path === projectPath) || null;
+}
+
+// src/commands/migrate.ts
+async function migrateCommand(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  status.info("Checking current project...");
+  status.info("");
+  if (!fs5.existsSync(path6.join(cwd, ".git"))) {
+    throw new Error(
+      "Not a git repository.\nRun this command from the root of an existing git project."
+    );
+  }
+  const bareDir = path6.join(cwd, ".bare");
+  if (fs5.existsSync(bareDir)) {
+    throw new Error(
+      "This project is already in worktree mode.\nUse `episoda checkout {module}` to create worktrees."
+    );
+  }
+  const config = await (0, import_core5.loadConfig)();
+  if (!config || !config.access_token) {
+    throw new Error(
+      "Not authenticated. Please run `episoda auth` first."
+    );
+  }
+  const episodaConfigPath = path6.join(cwd, ".episoda", "config.json");
+  if (!fs5.existsSync(episodaConfigPath)) {
+    throw new Error(
+      "No .episoda/config.json found.\nThis project is not connected to episoda.dev.\nUse `episoda clone {workspace}/{project}` to clone a fresh copy."
+    );
+  }
+  let existingConfig;
+  try {
+    existingConfig = JSON.parse(fs5.readFileSync(episodaConfigPath, "utf-8"));
+  } catch (error) {
+    throw new Error("Failed to read .episoda/config.json");
+  }
+  const trackedProject = getProject(cwd);
+  const projectId = trackedProject?.id || existingConfig.project_id;
+  if (!projectId) {
+    throw new Error(
+      "Cannot determine project ID.\nUse `episoda clone {workspace}/{project}` for a fresh clone."
+    );
+  }
+  const gitExecutor = new import_core5.GitExecutor();
+  let currentBranch;
+  try {
+    currentBranch = (0, import_child_process2.execSync)("git branch --show-current", {
+      cwd,
+      encoding: "utf-8"
+    }).trim();
+  } catch {
+    throw new Error("Failed to determine current branch");
+  }
+  const statusResult = await gitExecutor.execute({ action: "status" }, { cwd });
+  const hasUncommitted = (statusResult.details?.uncommittedFiles?.length || 0) > 0;
+  if (hasUncommitted && !options.force) {
+    status.warning("You have uncommitted changes:");
+    for (const file of statusResult.details?.uncommittedFiles || []) {
+      status.info(`  - ${file}`);
+    }
+    status.info("");
+    throw new Error(
+      "Please commit or stash your changes first.\nOr use --force to stash changes automatically."
+    );
+  }
+  let remoteUrl;
+  try {
+    remoteUrl = (0, import_child_process2.execSync)("git remote get-url origin", {
+      cwd,
+      encoding: "utf-8"
+    }).trim();
+  } catch {
+    throw new Error(
+      'No git remote "origin" found.\nPlease configure a remote before migrating.'
+    );
+  }
+  let workspaceSlug = existingConfig.workspace_slug || "default";
+  let projectSlug = existingConfig.project_slug || path6.basename(cwd);
+  try {
+    const apiUrl = config.api_url || "https://episoda.dev";
+    const response = await fetch(`${apiUrl}/api/projects/${projectId}`, {
+      headers: {
+        "Authorization": `Bearer ${config.access_token}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (response.ok) {
+      const responseData = await response.json();
+      const projectData = responseData.data?.project;
+      if (projectData) {
+        workspaceSlug = projectData.workspace_slug || workspaceSlug;
+        projectSlug = projectData.slug || projectSlug;
+      }
+    }
+  } catch {
+  }
+  const targetPath = getProjectPath(workspaceSlug, projectSlug);
+  status.info("Migration Plan:");
+  status.info(`  Current path: ${cwd}`);
+  status.info(`  Target path:  ${targetPath}`);
+  status.info(`  Remote URL:   ${remoteUrl}`);
+  status.info(`  Current branch: ${currentBranch}`);
+  if (hasUncommitted) {
+    status.warning(`  Uncommitted changes will be stashed`);
+  }
+  status.info("");
+  if (options.dryRun) {
+    status.info("Dry run complete. No changes made.");
+    status.info("Remove --dry-run to perform the migration.");
+    return;
+  }
+  const uncommittedFiles = statusResult.details?.uncommittedFiles || [];
+  if (hasUncommitted) {
+    status.info(`Found ${uncommittedFiles.length} uncommitted file(s) to preserve...`);
+  }
+  const targetExistedBefore = fs5.existsSync(targetPath);
+  try {
+    status.info("Creating target directory...");
+    const episodaRoot = getEpisodaRoot();
+    fs5.mkdirSync(targetPath, { recursive: true });
+    status.info("Cloning as bare repository...");
+    const bareRepoPath = path6.join(targetPath, ".bare");
+    const cloneResult = await gitExecutor.execute({
+      action: "clone_bare",
+      url: remoteUrl,
+      path: bareRepoPath
+    });
+    if (!cloneResult.success) {
+      throw new Error(`Failed to clone: ${cloneResult.output}`);
+    }
+    status.success("\u2713 Bare repository cloned");
+    status.info("Creating worktree configuration...");
+    const episodaDir = path6.join(targetPath, ".episoda");
+    fs5.mkdirSync(episodaDir, { recursive: true });
+    const worktreeConfig = {
+      projectId,
+      workspaceSlug,
+      projectSlug,
+      bareRepoPath,
+      worktreeMode: true,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      worktrees: []
+    };
+    fs5.writeFileSync(
+      path6.join(episodaDir, "config.json"),
+      JSON.stringify(worktreeConfig, null, 2),
+      "utf-8"
+    );
+    status.info(`Creating worktree for branch "${currentBranch}"...`);
+    const moduleUid = extractModuleUid(currentBranch) || "main";
+    const worktreePath = path6.join(targetPath, moduleUid);
+    const worktreeResult = await gitExecutor.execute({
+      action: "worktree_add",
+      path: worktreePath,
+      branch: currentBranch,
+      create: false
+    }, { cwd: bareRepoPath });
+    if (!worktreeResult.success) {
+      throw new Error(`Failed to create worktree: ${worktreeResult.output}`);
+    }
+    status.success(`\u2713 Worktree created at ${worktreePath}`);
+    worktreeConfig.worktrees.push({
+      moduleUid,
+      branchName: currentBranch,
+      worktreePath,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastAccessed: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    fs5.writeFileSync(
+      path6.join(episodaDir, "config.json"),
+      JSON.stringify(worktreeConfig, null, 2),
+      "utf-8"
+    );
+    if (hasUncommitted && uncommittedFiles.length > 0) {
+      status.info("Copying uncommitted changes to new worktree...");
+      let copiedCount = 0;
+      let failedCount = 0;
+      for (const file of uncommittedFiles) {
+        const sourcePath = path6.join(cwd, file);
+        const destPath = path6.join(worktreePath, file);
+        try {
+          if (fs5.existsSync(sourcePath)) {
+            const destDir = path6.dirname(destPath);
+            if (!fs5.existsSync(destDir)) {
+              fs5.mkdirSync(destDir, { recursive: true });
+            }
+            fs5.copyFileSync(sourcePath, destPath);
+            copiedCount++;
+          }
+        } catch (copyError) {
+          failedCount++;
+          status.warning(`Could not copy: ${file}`);
+        }
+      }
+      if (copiedCount > 0) {
+        status.success(`\u2713 Copied ${copiedCount} uncommitted file(s)`);
+      }
+      if (failedCount > 0) {
+        status.warning(`${failedCount} file(s) could not be copied`);
+        status.info("You may need to copy some files manually from the original directory");
+      }
+    }
+    addProject2(projectId, targetPath, {
+      worktreeMode: true,
+      bareRepoPath
+    });
+    status.success("\u2713 Project registered with daemon");
+    try {
+      const apiUrl = config.api_url || "https://episoda.dev";
+      const settingsResponse = await fetch(`${apiUrl}/api/projects/${projectId}/settings`, {
+        method: "PATCH",
+        headers: {
+          "Authorization": `Bearer ${config.access_token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          local_project_path: worktreePath
+        })
+      });
+      if (settingsResponse.ok) {
+        status.success("\u2713 Project settings updated");
+      } else {
+        status.warning("Could not update project settings in database");
+      }
+    } catch {
+      status.warning("Could not update project settings in database");
+    }
+    try {
+      const updatedConfig = {
+        ...config,
+        project_settings: {
+          ...config.project_settings,
+          local_project_path: worktreePath,
+          cached_at: Date.now()
+        }
+      };
+      await (0, import_core5.saveConfig)(updatedConfig);
+      status.success("\u2713 Local config updated");
+    } catch {
+      status.warning("Could not update local config cache");
+    }
+    status.info("");
+    status.success("Migration complete!");
+    status.info("");
+    status.info("New project structure:");
+    status.info(`  ${targetPath}/`);
+    status.info("    \u251C\u2500\u2500 .bare/           # Git repository");
+    status.info("    \u251C\u2500\u2500 .episoda/");
+    status.info("    \u2502   \u2514\u2500\u2500 config.json");
+    status.info(`    \u2514\u2500\u2500 ${moduleUid}/          # Your current worktree`);
+    status.info("");
+    status.info("Next steps:");
+    status.info(`  1. cd ${worktreePath}`);
+    status.info("  2. Continue working on your current branch");
+    status.info("  3. Use `episoda checkout EP###` for other modules");
+    status.info("");
+    status.info("Your original repository at:");
+    status.info(`  ${cwd}`);
+    status.info("can be safely removed after verifying the migration.");
+    status.info("");
+  } catch (error) {
+    status.error("Migration failed, cleaning up...");
+    if (!targetExistedBefore && fs5.existsSync(targetPath)) {
+      try {
+        fs5.rmSync(targetPath, { recursive: true, force: true });
+        status.info(`Removed ${targetPath}`);
+      } catch {
+        status.warning(`Could not remove ${targetPath}`);
+      }
+    } else if (targetExistedBefore) {
+      status.info("Target directory existed before migration, only removing migration artifacts...");
+      const bareRepoPath = path6.join(targetPath, ".bare");
+      const episodaDir = path6.join(targetPath, ".episoda");
+      if (fs5.existsSync(bareRepoPath)) {
+        try {
+          fs5.rmSync(bareRepoPath, { recursive: true, force: true });
+          status.info("Removed .bare directory");
+        } catch {
+          status.warning("Could not remove .bare directory");
+        }
       }
-    });
-    server.once("listening", () => {
-      server.close();
-      resolve2(false);
-    });
-    server.listen(port);
-  });
+      if (fs5.existsSync(episodaDir)) {
+        try {
+          const configPath = path6.join(episodaDir, "config.json");
+          if (fs5.existsSync(configPath)) {
+            const config2 = JSON.parse(fs5.readFileSync(configPath, "utf-8"));
+            if (config2.worktreeMode) {
+              fs5.rmSync(episodaDir, { recursive: true, force: true });
+              status.info("Removed .episoda directory");
+            }
+          }
+        } catch {
+          status.warning("Could not remove .episoda directory");
+        }
+      }
+    }
+    throw error;
+  }
 }
-function getServerPort() {
-  if (process.env.PORT) {
-    return parseInt(process.env.PORT, 10);
+function extractModuleUid(branchName) {
+  const match = branchName.match(/ep(\d+)/i);
+  if (match) {
+    return `EP${match[1]}`;
   }
-  return 3e3;
+  return null;
 }
 
 // src/commands/dev.ts
 var CONNECTION_MAX_RETRIES = 3;
 function findGitRoot(startDir) {
   try {
-    const result = (0, import_child_process2.execSync)("git rev-parse --show-toplevel", {
+    const result = (0, import_child_process3.execSync)("git rev-parse --show-toplevel", {
       cwd: startDir,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -2814,7 +4004,7 @@ function findGitRoot(startDir) {
 }
 async function devCommand(options = {}) {
   try {
-    const config = await (0, import_core3.loadConfig)();
+    const config = await (0, import_core6.loadConfig)();
     if (!config || !config.access_token || !config.project_id) {
       status.error("No authentication found. Please run:");
       status.info("");
@@ -2853,7 +4043,7 @@ async function devCommand(options = {}) {
       const killedCount = killAllEpisodaProcesses();
       if (killedCount > 0) {
         status.info(`Cleaned up ${killedCount} stale process${killedCount > 1 ? "es" : ""}`);
-        await new Promise((resolve2) => setTimeout(resolve2, 2e3));
+        await new Promise((resolve4) => setTimeout(resolve4, 2e3));
       }
     }
     const serverUrl = config.api_url || process.env.EPISODA_API_URL || "https://episoda.dev";
@@ -2866,7 +4056,7 @@ async function devCommand(options = {}) {
       status.debug(`Using cached project path: ${projectPath}`);
     } else {
       const detectedRoot = findGitRoot(options.cwd || process.cwd());
-      projectPath = detectedRoot || path4.resolve(options.cwd || process.cwd());
+      projectPath = detectedRoot || path7.resolve(options.cwd || process.cwd());
       if (detectedRoot) {
         status.debug(`Detected project root: ${projectPath}`);
       } else {
@@ -2880,7 +4070,7 @@ async function devCommand(options = {}) {
           cached_at: Date.now()
         }
       };
-      await (0, import_core3.saveConfig)(updatedConfig);
+      await (0, import_core6.saveConfig)(updatedConfig);
       status.debug("Cached project settings locally");
       const settingsUrl = `${serverUrl}/api/projects/${config.project_id}/settings`;
       fetch(settingsUrl, {
@@ -2893,6 +4083,23 @@ async function devCommand(options = {}) {
       }).catch(() => {
       });
     }
+    const hasGitDir = fs6.existsSync(path7.join(projectPath, ".git"));
+    const isWorktree = await isWorktreeProject(projectPath);
+    if (hasGitDir && !isWorktree) {
+      status.info("");
+      status.info("EP944: Migrating project to worktree mode...");
+      status.info("This is a one-time operation that enables multi-module development.");
+      status.info("");
+      try {
+        await migrateCommand({ cwd: projectPath, silent: false });
+        status.success("Project migrated to worktree mode!");
+        status.info("");
+      } catch (error) {
+        status.warning(`Migration skipped: ${error.message}`);
+        status.info("You can run `episoda migrate` manually later.");
+        status.info("");
+      }
+    }
     let daemonPid = isDaemonRunning();
     if (!daemonPid) {
       status.info("Starting Episoda daemon...");
@@ -2917,7 +4124,7 @@ async function devCommand(options = {}) {
     for (let retry = 0; retry < CONNECTION_MAX_RETRIES && !connected; retry++) {
       if (retry > 0) {
         status.info(`Retrying connection (attempt ${retry + 1}/${CONNECTION_MAX_RETRIES})...`);
-        await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+        await new Promise((resolve4) => setTimeout(resolve4, 1e3));
       }
       try {
         const result = await addProject(config.project_id, projectPath);
@@ -2985,7 +4192,7 @@ async function runDevServer(command, cwd, autoRestart) {
   let shuttingDown = false;
   const startServer = () => {
     status.info(`Starting dev server: ${command.join(" ")}`);
-    devProcess = (0, import_child_process2.spawn)(command[0], command.slice(1), {
+    devProcess = (0, import_child_process3.spawn)(command[0], command.slice(1), {
       cwd,
       stdio: ["inherit", "inherit", "inherit"],
       shell: true
@@ -3038,33 +4245,33 @@ Received ${signal}, shutting down...`);
 
 // src/commands/auth.ts
 var os = __toESM(require("os"));
-var fs4 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
-var import_child_process4 = require("child_process");
-var import_core5 = __toESM(require_dist());
+var fs8 = __toESM(require("fs"));
+var path9 = __toESM(require("path"));
+var import_child_process5 = require("child_process");
+var import_core8 = __toESM(require_dist());
 
 // src/daemon/machine-id.ts
-var fs3 = __toESM(require("fs"));
-var path5 = __toESM(require("path"));
+var fs7 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
 var crypto2 = __toESM(require("crypto"));
-var import_child_process3 = require("child_process");
-var import_core4 = __toESM(require_dist());
+var import_child_process4 = require("child_process");
+var import_core7 = __toESM(require_dist());
 function isValidUUID(str) {
   const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
   return uuidRegex.test(str);
 }
 async function getMachineId() {
-  const machineIdPath = path5.join((0, import_core4.getConfigDir)(), "machine-id");
+  const machineIdPath = path8.join((0, import_core7.getConfigDir)(), "machine-id");
   try {
-    if (fs3.existsSync(machineIdPath)) {
-      const existingId = fs3.readFileSync(machineIdPath, "utf-8").trim();
+    if (fs7.existsSync(machineIdPath)) {
+      const existingId = fs7.readFileSync(machineIdPath, "utf-8").trim();
       if (existingId) {
         if (isValidUUID(existingId)) {
           return existingId;
         }
         console.log("[MachineId] Migrating legacy machine ID to UUID format...");
         const newUUID = generateMachineId();
-        fs3.writeFileSync(machineIdPath, newUUID, "utf-8");
+        fs7.writeFileSync(machineIdPath, newUUID, "utf-8");
         console.log(`[MachineId] Migrated: ${existingId} \u2192 ${newUUID}`);
         return newUUID;
       }
@@ -3073,11 +4280,11 @@ async function getMachineId() {
   }
   const machineId = generateMachineId();
   try {
-    const dir = path5.dirname(machineIdPath);
-    if (!fs3.existsSync(dir)) {
-      fs3.mkdirSync(dir, { recursive: true });
+    const dir = path8.dirname(machineIdPath);
+    if (!fs7.existsSync(dir)) {
+      fs7.mkdirSync(dir, { recursive: true });
     }
-    fs3.writeFileSync(machineIdPath, machineId, "utf-8");
+    fs7.writeFileSync(machineIdPath, machineId, "utf-8");
   } catch (error) {
     console.error("Warning: Could not save machine ID to disk:", error);
   }
@@ -3086,7 +4293,7 @@ async function getMachineId() {
 function getHardwareUUID() {
   try {
     if (process.platform === "darwin") {
-      const output = (0, import_child_process3.execSync)(
+      const output = (0, import_child_process4.execSync)(
         `ioreg -d2 -c IOPlatformExpertDevice | awk -F\\" '/IOPlatformUUID/{print $(NF-1)}'`,
         { encoding: "utf-8", timeout: 5e3 }
       ).trim();
@@ -3094,20 +4301,20 @@ function getHardwareUUID() {
         return output;
       }
     } else if (process.platform === "linux") {
-      if (fs3.existsSync("/etc/machine-id")) {
-        const machineId = fs3.readFileSync("/etc/machine-id", "utf-8").trim();
+      if (fs7.existsSync("/etc/machine-id")) {
+        const machineId = fs7.readFileSync("/etc/machine-id", "utf-8").trim();
         if (machineId && machineId.length > 0) {
           return machineId;
         }
       }
-      if (fs3.existsSync("/var/lib/dbus/machine-id")) {
-        const dbusId = fs3.readFileSync("/var/lib/dbus/machine-id", "utf-8").trim();
+      if (fs7.existsSync("/var/lib/dbus/machine-id")) {
+        const dbusId = fs7.readFileSync("/var/lib/dbus/machine-id", "utf-8").trim();
         if (dbusId && dbusId.length > 0) {
           return dbusId;
         }
       }
     } else if (process.platform === "win32") {
-      const output = (0, import_child_process3.execSync)("wmic csproduct get uuid", {
+      const output = (0, import_child_process4.execSync)("wmic csproduct get uuid", {
         encoding: "utf-8",
         timeout: 5e3
       });
@@ -3488,18 +4695,21 @@ async function authCommand(options = {}) {
   status.info(`  Project: ${tokenResponse.project_uid}`);
   status.info(`  Workspace: ${tokenResponse.workspace_uid}`);
   status.info("");
-  await (0, import_core5.saveConfig)({
+  await (0, import_core8.saveConfig)({
     project_id: tokenResponse.project_id,
     user_id: tokenResponse.user_id,
     workspace_id: tokenResponse.workspace_id,
+    workspace_slug: tokenResponse.workspace_uid,
+    // EP956: For worktree paths
+    project_slug: tokenResponse.project_uid,
+    // EP956: For worktree paths
     access_token: tokenResponse.access_token,
     refresh_token: tokenResponse.refresh_token,
     expires_at: Date.now() + tokenResponse.expires_in * 1e3,
     // Convert to Unix timestamp
-    api_url: apiUrl,
-    cli_version: import_core5.VERSION
+    api_url: apiUrl
   });
-  status.success(`\u2713 Configuration saved to ${(0, import_core5.getConfigPath)()}`);
+  status.success(`\u2713 Configuration saved to ${(0, import_core8.getConfigPath)()}`);
   status.info("");
   status.info("Installing git credential helper...");
   const credentialHelperInstalled = await installGitCredentialHelper(apiUrl);
@@ -3537,13 +4747,13 @@ async function initiateDeviceFlow(apiUrl, machineId) {
   return await response.json();
 }
 async function monitorAuthorization(apiUrl, deviceCode, expiresIn) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve4) => {
     const timeout = setTimeout(() => {
       status.error("Authorization timed out");
-      resolve2(false);
+      resolve4(false);
     }, expiresIn * 1e3);
     const url = `${apiUrl}/api/oauth/authorize-stream?device_code=${deviceCode}`;
-    const curlProcess = (0, import_child_process4.spawn)("curl", ["-N", url]);
+    const curlProcess = (0, import_child_process5.spawn)("curl", ["-N", url]);
     let buffer = "";
     curlProcess.stdout.on("data", (chunk) => {
       buffer += chunk.toString();
@@ -3566,26 +4776,26 @@ async function monitorAuthorization(apiUrl, deviceCode, expiresIn) {
           if (eventType === "authorized") {
             clearTimeout(timeout);
             curlProcess.kill();
-            resolve2(true);
+            resolve4(true);
             return;
           } else if (eventType === "denied") {
             clearTimeout(timeout);
             curlProcess.kill();
             status.error("Authorization denied by user");
-            resolve2(false);
+            resolve4(false);
             return;
           } else if (eventType === "expired") {
             clearTimeout(timeout);
             curlProcess.kill();
             status.error("Authorization code expired");
-            resolve2(false);
+            resolve4(false);
             return;
           } else if (eventType === "error") {
             const errorData = JSON.parse(data);
             clearTimeout(timeout);
             curlProcess.kill();
             status.error(`Authorization error: ${errorData.error_description || errorData.error || "Unknown error"}`);
-            resolve2(false);
+            resolve4(false);
             return;
           }
         } catch (error) {
@@ -3595,13 +4805,13 @@ async function monitorAuthorization(apiUrl, deviceCode, expiresIn) {
     curlProcess.on("error", (error) => {
       clearTimeout(timeout);
       status.error(`Failed to monitor authorization: ${error.message}`);
-      resolve2(false);
+      resolve4(false);
     });
     curlProcess.on("close", (code) => {
       clearTimeout(timeout);
       if (code !== 0 && code !== null) {
         status.error(`Authorization monitoring failed with code ${code}`);
-        resolve2(false);
+        resolve4(false);
       }
     });
   });
@@ -3647,7 +4857,7 @@ function openBrowser(url) {
       break;
   }
   try {
-    (0, import_child_process4.spawn)(command, args, {
+    (0, import_child_process5.spawn)(command, args, {
       detached: true,
       stdio: "ignore"
     }).unref();
@@ -3658,17 +4868,17 @@ function openBrowser(url) {
 async function installGitCredentialHelper(apiUrl) {
   try {
     const homeDir = os.homedir();
-    const episodaBinDir = path6.join(homeDir, ".episoda", "bin");
-    const helperPath = path6.join(episodaBinDir, "git-credential-episoda");
-    fs4.mkdirSync(episodaBinDir, { recursive: true });
+    const episodaBinDir = path9.join(homeDir, ".episoda", "bin");
+    const helperPath = path9.join(episodaBinDir, "git-credential-episoda");
+    fs8.mkdirSync(episodaBinDir, { recursive: true });
     const scriptContent = generateCredentialHelperScript(apiUrl);
-    fs4.writeFileSync(helperPath, scriptContent, { mode: 493 });
+    fs8.writeFileSync(helperPath, scriptContent, { mode: 493 });
     try {
-      fs4.accessSync(helperPath, fs4.constants.X_OK);
+      fs8.accessSync(helperPath, fs8.constants.X_OK);
     } catch {
     }
     try {
-      const allHelpers = (0, import_child_process4.execSync)("git config --global --get-all credential.helper", {
+      const allHelpers = (0, import_child_process5.execSync)("git config --global --get-all credential.helper", {
         encoding: "utf8",
         stdio: ["pipe", "pipe", "pipe"]
       }).trim().split("\n");
@@ -3677,7 +4887,7 @@ async function installGitCredentialHelper(apiUrl) {
       }
     } catch {
     }
-    (0, import_child_process4.execSync)(`git config --global --add credential.helper "${helperPath}"`, {
+    (0, import_child_process5.execSync)(`git config --global --add credential.helper "${helperPath}"`, {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -3695,19 +4905,19 @@ function updateShellProfile(binDir) {
   }
   const homeDir = os.homedir();
   const profiles = [
-    path6.join(homeDir, ".bashrc"),
-    path6.join(homeDir, ".zshrc"),
-    path6.join(homeDir, ".profile")
+    path9.join(homeDir, ".bashrc"),
+    path9.join(homeDir, ".zshrc"),
+    path9.join(homeDir, ".profile")
   ];
   const exportLine = `export PATH="${binDir}:$PATH"  # Added by episoda auth`;
   for (const profile of profiles) {
     try {
-      if (fs4.existsSync(profile)) {
-        const content = fs4.readFileSync(profile, "utf8");
+      if (fs8.existsSync(profile)) {
+        const content = fs8.readFileSync(profile, "utf8");
         if (content.includes(".episoda/bin")) {
           continue;
         }
-        fs4.appendFileSync(profile, `
+        fs8.appendFileSync(profile, `
 # Episoda CLI
 ${exportLine}
 `);
@@ -3719,10 +4929,10 @@ ${exportLine}
 
 // src/commands/connect.ts
 var os2 = __toESM(require("os"));
-var fs5 = __toESM(require("fs"));
-var path7 = __toESM(require("path"));
-var import_child_process5 = require("child_process");
-var import_core6 = __toESM(require_dist());
+var fs9 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
+var import_child_process6 = require("child_process");
+var import_core9 = __toESM(require_dist());
 async function connectCommand(options) {
   const { code } = options;
   const apiUrl = options.apiUrl || process.env.EPISODA_API_URL || "https://episoda.dev";
@@ -3738,15 +4948,14 @@ async function connectCommand(options) {
   status.info(`  Project: ${tokenResponse.project_uid}`);
   status.info(`  Workspace: ${tokenResponse.workspace_uid}`);
   status.info("");
-  await (0, import_core6.saveConfig)({
+  await (0, import_core9.saveConfig)({
     project_id: tokenResponse.project_id,
     user_id: tokenResponse.user_id,
     workspace_id: tokenResponse.workspace_id,
     access_token: tokenResponse.access_token,
-    api_url: apiUrl,
-    cli_version: import_core6.VERSION
+    api_url: apiUrl
   });
-  status.success(`\u2713 Configuration saved to ${(0, import_core6.getConfigPath)()}`);
+  status.success(`\u2713 Configuration saved to ${(0, import_core9.getConfigPath)()}`);
   status.info("");
   status.info("Installing git credential helper...");
   const credentialHelperInstalled = await installGitCredentialHelper2(apiUrl);
@@ -3796,13 +5005,13 @@ async function exchangeUserCode(apiUrl, userCode, machineId) {
 async function installGitCredentialHelper2(apiUrl) {
   try {
     const homeDir = os2.homedir();
-    const episodaBinDir = path7.join(homeDir, ".episoda", "bin");
-    const helperPath = path7.join(episodaBinDir, "git-credential-episoda");
-    fs5.mkdirSync(episodaBinDir, { recursive: true });
+    const episodaBinDir = path10.join(homeDir, ".episoda", "bin");
+    const helperPath = path10.join(episodaBinDir, "git-credential-episoda");
+    fs9.mkdirSync(episodaBinDir, { recursive: true });
     const scriptContent = generateCredentialHelperScript(apiUrl);
-    fs5.writeFileSync(helperPath, scriptContent, { mode: 493 });
+    fs9.writeFileSync(helperPath, scriptContent, { mode: 493 });
     try {
-      const allHelpers = (0, import_child_process5.execSync)("git config --global --get-all credential.helper", {
+      const allHelpers = (0, import_child_process6.execSync)("git config --global --get-all credential.helper", {
         encoding: "utf8",
         stdio: ["pipe", "pipe", "pipe"]
       }).trim().split("\n");
@@ -3811,7 +5020,7 @@ async function installGitCredentialHelper2(apiUrl) {
       }
     } catch {
     }
-    (0, import_child_process5.execSync)(`git config --global --add credential.helper "${helperPath}"`, {
+    (0, import_child_process6.execSync)(`git config --global --add credential.helper "${helperPath}"`, {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -3829,19 +5038,19 @@ function updateShellProfile2(binDir) {
   }
   const homeDir = os2.homedir();
   const profiles = [
-    path7.join(homeDir, ".bashrc"),
-    path7.join(homeDir, ".zshrc"),
-    path7.join(homeDir, ".profile")
+    path10.join(homeDir, ".bashrc"),
+    path10.join(homeDir, ".zshrc"),
+    path10.join(homeDir, ".profile")
   ];
   const exportLine = `export PATH="${binDir}:$PATH"  # Added by episoda`;
   for (const profile of profiles) {
     try {
-      if (fs5.existsSync(profile)) {
-        const content = fs5.readFileSync(profile, "utf8");
+      if (fs9.existsSync(profile)) {
+        const content = fs9.readFileSync(profile, "utf8");
         if (content.includes(".episoda/bin")) {
           continue;
         }
-        fs5.appendFileSync(profile, `
+        fs9.appendFileSync(profile, `
 # Episoda CLI
 ${exportLine}
 `);
@@ -3852,11 +5061,11 @@ ${exportLine}
 }
 
 // src/commands/status.ts
-var import_core7 = __toESM(require_dist());
+var import_core10 = __toESM(require_dist());
 async function statusCommand(options = {}) {
   status.info("Checking CLI status...");
   status.info("");
-  const config = await (0, import_core7.loadConfig)();
+  const config = await (0, import_core10.loadConfig)();
   if (!config) {
     status.error("\u2717 CLI not initialized");
     status.info("");
@@ -3871,8 +5080,8 @@ async function statusCommand(options = {}) {
   status.info("Configuration:");
   status.info(`  Project ID: ${config.project_id}`);
   status.info(`  API URL: ${config.api_url}`);
-  status.info(`  CLI Version: ${config.cli_version}`);
-  status.info(`  Config file: ${(0, import_core7.getConfigPath)()}`);
+  status.info(`  CLI Version: ${import_core10.VERSION}`);
+  status.info(`  Config file: ${(0, import_core10.getConfigPath)()}`);
   status.info("");
   if (!config.access_token || config.access_token === "") {
     status.warning("\u26A0 Not authenticated");
@@ -4031,8 +5240,588 @@ async function stopCommand(options = {}) {
   }
 }
 
+// src/commands/clone.ts
+var fs10 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
+var import_core11 = __toESM(require_dist());
+async function cloneCommand(slugArg, options = {}) {
+  const slugParts = slugArg.split("/");
+  if (slugParts.length !== 2 || !slugParts[0] || !slugParts[1]) {
+    throw new Error(
+      "Invalid format. Usage: episoda clone {workspace}/{project}\nExample: episoda clone my-team/my-project"
+    );
+  }
+  const [workspaceSlug, projectSlug] = slugParts;
+  status.info(`Cloning ${workspaceSlug}/${projectSlug}...`);
+  status.info("");
+  const config = await (0, import_core11.loadConfig)();
+  if (!config || !config.access_token) {
+    throw new Error(
+      "Not authenticated. Please run `episoda auth` first."
+    );
+  }
+  const apiUrl = options.apiUrl || config.api_url || "https://episoda.dev";
+  const projectPath = getProjectPath(workspaceSlug, projectSlug);
+  if (fs10.existsSync(projectPath)) {
+    const bareRepoPath = path11.join(projectPath, ".bare");
+    if (fs10.existsSync(bareRepoPath)) {
+      status.warning(`Project already cloned at ${projectPath}`);
+      status.info("");
+      status.info("Next steps:");
+      status.info(`  \u2022 cd ${projectPath}`);
+      status.info("  \u2022 episoda checkout {module}");
+      return;
+    }
+    throw new Error(
+      `Directory exists but is not a worktree project: ${projectPath}
+Please remove it manually or use a different location.`
+    );
+  }
+  status.info("Fetching project details...");
+  const projectDetails = await fetchProjectDetails(
+    apiUrl,
+    workspaceSlug,
+    projectSlug,
+    config.access_token
+  );
+  if (!projectDetails.repo_url) {
+    throw new Error(
+      `Project "${projectSlug}" has no repository configured.
+Please configure a repository in the project settings on episoda.dev.`
+    );
+  }
+  validateRepoUrl(projectDetails.repo_url);
+  status.success(`\u2713 Found project: ${projectDetails.name}`);
+  status.info(`  Repository: ${projectDetails.repo_url}`);
+  status.info("");
+  status.info("Creating project directory...");
+  const episodaRoot = getEpisodaRoot();
+  fs10.mkdirSync(projectPath, { recursive: true });
+  status.success(`\u2713 Created ${projectPath}`);
+  status.info("Cloning repository (bare)...");
+  try {
+    const worktreeManager = await WorktreeManager.createProject(
+      projectPath,
+      projectDetails.repo_url,
+      projectDetails.id,
+      workspaceSlug,
+      projectSlug
+    );
+    status.success("\u2713 Repository cloned");
+    status.info("");
+    const bareRepoPath = worktreeManager.getBareRepoPath();
+    addProject2(projectDetails.id, projectPath, {
+      worktreeMode: true,
+      bareRepoPath
+    });
+    status.success("\u2713 Project registered with daemon");
+    status.info("");
+    status.success("Project cloned successfully!");
+    status.info("");
+    status.info("Project structure:");
+    status.info(`  ${projectPath}/`);
+    status.info("    \u251C\u2500\u2500 .bare/           # Git repository");
+    status.info("    \u2514\u2500\u2500 .episoda/");
+    status.info("        \u2514\u2500\u2500 config.json  # Project config");
+    status.info("");
+    status.info("Next steps:");
+    status.info(`  1. cd ${projectPath}`);
+    status.info("  2. episoda checkout {moduleUid}  # e.g., episoda checkout EP100");
+    status.info("");
+  } catch (error) {
+    if (fs10.existsSync(projectPath)) {
+      try {
+        fs10.rmSync(projectPath, { recursive: true, force: true });
+      } catch {
+      }
+    }
+    throw error;
+  }
+}
+function validateRepoUrl(url) {
+  const dangerousChars = /[;|&$`\\<>(){}[\]!#*?~'"]/;
+  if (dangerousChars.test(url)) {
+    throw new Error(
+      "Repository URL contains invalid characters.\nPlease check the repository configuration on episoda.dev."
+    );
+  }
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    if (/^[\w.-]+@[\w.-]+:[\w./-]+$/.test(url)) {
+      return;
+    }
+    throw new Error(
+      `Repository URL is not a valid URL format.
+Received: ${url}`
+    );
+  }
+  const allowedProtocols = ["https:", "http:", "git:", "ssh:"];
+  if (!allowedProtocols.includes(parsed.protocol)) {
+    throw new Error(
+      `Repository URL uses unsupported protocol: ${parsed.protocol}
+Allowed protocols: https, http, git, ssh`
+    );
+  }
+  if (!parsed.hostname || parsed.hostname.length < 3) {
+    throw new Error(
+      `Repository URL has invalid hostname.
+Received: ${url}`
+    );
+  }
+}
+async function fetchProjectDetails(apiUrl, workspaceSlug, projectSlug, accessToken) {
+  const url = `${apiUrl}/api/projects/by-slug/${workspaceSlug}/${projectSlug}`;
+  const response = await fetch(url, {
+    method: "GET",
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "Content-Type": "application/json"
+    }
+  });
+  if (response.status === 404) {
+    throw new Error(
+      `Project "${workspaceSlug}/${projectSlug}" not found.
+Check the workspace and project slugs are correct.`
+    );
+  }
+  if (response.status === 401) {
+    throw new Error(
+      "Authentication expired. Please run `episoda auth` again."
+    );
+  }
+  if (!response.ok) {
+    const errorBody = await response.text();
+    throw new Error(
+      `Failed to fetch project details: ${response.status}
+${errorBody}`
+    );
+  }
+  const data = await response.json();
+  if (!data.id || !data.slug) {
+    throw new Error("Invalid project response from server");
+  }
+  return data;
+}
+
+// src/commands/checkout.ts
+var import_core12 = __toESM(require_dist());
+
+// src/utils/http.ts
+async function fetchWithRetry(url, options, maxRetries = 3) {
+  let lastError = null;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      const response = await fetch(url, options);
+      if (response.status === 401 || response.status === 404) {
+        return response;
+      }
+      if (response.ok || response.status >= 400 && response.status < 500) {
+        return response;
+      }
+      lastError = new Error(`Server error: ${response.status}`);
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error("Network error");
+    }
+    if (attempt < maxRetries - 1) {
+      await new Promise((resolve4) => setTimeout(resolve4, Math.pow(2, attempt) * 1e3));
+    }
+  }
+  throw lastError || new Error("Request failed after retries");
+}
+
+// src/commands/checkout.ts
+async function checkoutCommand(moduleUid, options = {}) {
+  if (!moduleUid || !moduleUid.match(/^EP\d+$/)) {
+    throw new Error(
+      "Invalid module UID format. Expected format: EP###\nExample: episoda checkout EP100"
+    );
+  }
+  status.info(`Checking out ${moduleUid}...`);
+  status.info("");
+  const projectRoot = await findProjectRoot(process.cwd());
+  if (!projectRoot) {
+    throw new Error(
+      "Not in a worktree project.\nRun this command from within a project cloned with `episoda clone`.\nOr cd to ~/episoda/{workspace}/{project}/"
+    );
+  }
+  const config = await (0, import_core12.loadConfig)();
+  if (!config || !config.access_token) {
+    throw new Error(
+      "Not authenticated. Please run `episoda auth` first."
+    );
+  }
+  const apiUrl = options.apiUrl || config.api_url || "https://episoda.dev";
+  const worktreeManager = new WorktreeManager(projectRoot);
+  const initialized = await worktreeManager.initialize();
+  if (!initialized) {
+    throw new Error(
+      `Invalid worktree project at ${projectRoot}.
+The .bare directory or .episoda/config.json may be missing.`
+    );
+  }
+  const existing = worktreeManager.getWorktreeByModuleUid(moduleUid);
+  if (existing) {
+    status.success(`Module ${moduleUid} is already checked out.`);
+    status.info("");
+    status.info(`Path: ${existing.worktreePath}`);
+    status.info(`Branch: ${existing.branchName}`);
+    status.info("");
+    status.info(`cd ${existing.worktreePath}`);
+    return;
+  }
+  status.info("Fetching module details...");
+  const worktreeConfig = worktreeManager.getConfig();
+  if (!worktreeConfig) {
+    throw new Error("Could not read worktree project config");
+  }
+  const moduleDetails = await fetchModuleDetails(
+    apiUrl,
+    worktreeConfig.projectId,
+    moduleUid,
+    config.access_token
+  );
+  const branchName = moduleDetails.branch_name || `feature/${moduleUid.toLowerCase()}`;
+  let createBranch = !moduleDetails.branch_name || options.create;
+  if (createBranch && !moduleDetails.branch_name) {
+    const { GitExecutor: GitExecutor6 } = await Promise.resolve().then(() => __toESM(require_dist()));
+    const gitExecutor = new GitExecutor6();
+    const branchCheck = await gitExecutor.execute(
+      { action: "branch_exists", branch: branchName },
+      { cwd: worktreeManager.getBareRepoPath() }
+    );
+    if (branchCheck.success && branchCheck.details?.branchExists) {
+      status.info(`Branch ${branchName} already exists, will use existing`);
+      createBranch = false;
+    }
+  }
+  status.success(`\u2713 Found module: ${moduleDetails.name || moduleUid}`);
+  status.info(`  Branch: ${branchName}${createBranch ? " (will be created)" : ""}`);
+  status.info("");
+  status.info("Creating worktree...");
+  const result = await worktreeManager.createWorktree(
+    moduleUid,
+    branchName,
+    createBranch
+  );
+  if (!result.success) {
+    throw new Error(`Failed to create worktree: ${result.error}`);
+  }
+  status.success("\u2713 Worktree created");
+  status.info("");
+  const branchWasGenerated = !moduleDetails.branch_name;
+  try {
+    await updateModuleCheckout(
+      apiUrl,
+      moduleDetails.id,
+      config.access_token,
+      branchWasGenerated ? branchName : void 0
+    );
+  } catch (error) {
+    status.warning("Could not update server with checkout status");
+  }
+  status.success(`Module ${moduleUid} checked out successfully!`);
+  status.info("");
+  status.info(`Path: ${result.worktreePath}`);
+  status.info(`Branch: ${branchName}`);
+  status.info("");
+  status.info("Next step:");
+  status.info(`  cd ${result.worktreePath}`);
+  status.info("");
+}
+async function fetchModuleDetails(apiUrl, projectId, moduleUid, accessToken) {
+  const url = `${apiUrl}/api/modules/by-uid/${moduleUid}?project_id=${projectId}`;
+  const response = await fetchWithRetry(url, {
+    method: "GET",
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "Content-Type": "application/json"
+    }
+  });
+  if (response.status === 404) {
+    throw new Error(
+      `Module "${moduleUid}" not found in this project.
+Check the module UID is correct.`
+    );
+  }
+  if (response.status === 401) {
+    throw new Error(
+      "Authentication expired. Please run `episoda auth` again."
+    );
+  }
+  if (!response.ok) {
+    const errorBody = await response.text();
+    throw new Error(
+      `Failed to fetch module details: ${response.status}
+${errorBody}`
+    );
+  }
+  const data = await response.json();
+  if (!data.id || !data.uid) {
+    throw new Error("Invalid module response from server");
+  }
+  return data;
+}
+async function updateModuleCheckout(apiUrl, moduleId, accessToken, branchName) {
+  const url = `${apiUrl}/api/modules/${moduleId}/checkout`;
+  const body = {
+    checked_out: true,
+    checkout_type: "worktree"
+  };
+  if (branchName) {
+    body.branch_name = branchName;
+  }
+  await fetchWithRetry(url, {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+}
+
+// src/commands/release.ts
+var path12 = __toESM(require("path"));
+var import_core13 = __toESM(require_dist());
+async function releaseCommand(moduleUid, options = {}) {
+  if (!moduleUid || !moduleUid.match(/^EP\d+$/)) {
+    throw new Error(
+      "Invalid module UID format. Expected format: EP###\nExample: episoda release EP100"
+    );
+  }
+  status.info(`Releasing ${moduleUid}...`);
+  status.info("");
+  const projectRoot = await findProjectRoot(process.cwd());
+  if (!projectRoot) {
+    throw new Error(
+      "Not in a worktree project.\nRun this command from within a project cloned with `episoda clone`."
+    );
+  }
+  const worktreeManager = new WorktreeManager(projectRoot);
+  const initialized = await worktreeManager.initialize();
+  if (!initialized) {
+    throw new Error(
+      `Invalid worktree project at ${projectRoot}.`
+    );
+  }
+  const existing = worktreeManager.getWorktreeByModuleUid(moduleUid);
+  if (!existing) {
+    status.warning(`Module ${moduleUid} is not checked out.`);
+    status.info("");
+    status.info("Available worktrees:");
+    const worktrees = worktreeManager.listWorktrees();
+    if (worktrees.length === 0) {
+      status.info("  (none)");
+    } else {
+      for (const wt of worktrees) {
+        status.info(`  ${wt.moduleUid} \u2192 ${wt.branchName}`);
+      }
+    }
+    return;
+  }
+  if (!options.force) {
+    const hasChanges = await checkUncommittedChanges(existing.worktreePath);
+    if (hasChanges) {
+      throw new Error(
+        `Module ${moduleUid} has uncommitted changes.
+Commit or stash your changes first, or use --force to discard them.`
+      );
+    }
+  }
+  const currentPath = path12.resolve(process.cwd());
+  if (currentPath.startsWith(existing.worktreePath)) {
+    status.warning("You are inside the worktree being released.");
+    status.info(`Please cd to ${projectRoot} first.`);
+    throw new Error("Cannot release worktree while inside it");
+  }
+  status.info("Removing worktree...");
+  const result = await worktreeManager.removeWorktree(moduleUid, options.force);
+  if (!result.success) {
+    throw new Error(`Failed to remove worktree: ${result.error}`);
+  }
+  status.success("\u2713 Worktree removed");
+  status.info("");
+  try {
+    const config = await (0, import_core13.loadConfig)();
+    if (config?.access_token) {
+      const worktreeConfig = worktreeManager.getConfig();
+      if (worktreeConfig) {
+        await updateModuleRelease(
+          config.api_url || "https://episoda.dev",
+          worktreeConfig.projectId,
+          worktreeConfig.workspaceSlug,
+          moduleUid,
+          config.access_token
+        );
+      }
+    }
+  } catch (error) {
+  }
+  status.success(`Module ${moduleUid} released successfully!`);
+  status.info("");
+  status.info(`Branch "${existing.branchName}" is preserved in the repository.`);
+  status.info("");
+  status.info("To check out again:");
+  status.info(`  episoda checkout ${moduleUid}`);
+  status.info("");
+}
+async function checkUncommittedChanges(worktreePath) {
+  const gitExecutor = new import_core13.GitExecutor();
+  const result = await gitExecutor.execute(
+    { action: "status" },
+    { cwd: worktreePath }
+  );
+  if (!result.success) {
+    return true;
+  }
+  const uncommitted = result.details?.uncommittedFiles || [];
+  return uncommitted.length > 0;
+}
+async function updateModuleRelease(apiUrl, projectId, workspaceSlug, moduleUid, accessToken) {
+  const url = `${apiUrl}/api/modules/${moduleUid}/checkout/release`;
+  await fetchWithRetry(url, {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "Content-Type": "application/json",
+      "X-Project-Id": projectId,
+      "X-Workspace-Slug": workspaceSlug
+    }
+  });
+}
+
+// src/commands/list.ts
+var fs11 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
+var import_chalk2 = __toESM(require("chalk"));
+var import_core14 = __toESM(require_dist());
+async function listCommand(subcommand, options = {}) {
+  if (subcommand === "worktrees" || subcommand === "wt") {
+    await listWorktrees(options);
+  } else {
+    await listProjects(options);
+  }
+}
+async function listProjects(options) {
+  const episodaRoot = getEpisodaRoot();
+  if (!fs11.existsSync(episodaRoot)) {
+    status.info("No projects cloned yet.");
+    status.info("");
+    status.info("Clone a project with:");
+    status.info("  episoda clone {workspace}/{project}");
+    return;
+  }
+  const projects = [];
+  const workspaces = fs11.readdirSync(episodaRoot, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("."));
+  for (const workspace of workspaces) {
+    const workspacePath = path13.join(episodaRoot, workspace.name);
+    const projectDirs = fs11.readdirSync(workspacePath, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("."));
+    for (const projectDir of projectDirs) {
+      const projectPath = path13.join(workspacePath, projectDir.name);
+      if (await isWorktreeProject(projectPath)) {
+        const manager = new WorktreeManager(projectPath);
+        await manager.initialize();
+        const worktrees = manager.listWorktrees();
+        projects.push({
+          workspaceSlug: workspace.name,
+          projectSlug: projectDir.name,
+          projectPath,
+          worktreeCount: worktrees.length
+        });
+      }
+    }
+  }
+  if (projects.length === 0) {
+    status.info("No worktree projects found.");
+    status.info("");
+    status.info("Clone a project with:");
+    status.info("  episoda clone {workspace}/{project}");
+    return;
+  }
+  console.log("");
+  console.log(import_chalk2.default.bold("Cloned Projects"));
+  console.log("\u2500".repeat(60));
+  for (const project of projects) {
+    const worktreeLabel = project.worktreeCount === 0 ? import_chalk2.default.gray("(no worktrees)") : project.worktreeCount === 1 ? import_chalk2.default.cyan("1 worktree") : import_chalk2.default.cyan(`${project.worktreeCount} worktrees`);
+    console.log("");
+    console.log(`  ${import_chalk2.default.bold(project.workspaceSlug)}/${import_chalk2.default.bold(project.projectSlug)}  ${worktreeLabel}`);
+    console.log(import_chalk2.default.gray(`  ${project.projectPath}`));
+  }
+  console.log("");
+  console.log(import_chalk2.default.gray("\u2500".repeat(60)));
+  console.log(`${projects.length} project${projects.length === 1 ? "" : "s"}`);
+  console.log("");
+  if (options.verbose) {
+    status.info("Commands:");
+    status.info("  episoda list worktrees  # Show worktrees for current project");
+    status.info("  episoda checkout EP###  # Create a new worktree");
+  }
+}
+async function listWorktrees(options) {
+  const projectRoot = await findProjectRoot(process.cwd());
+  if (!projectRoot) {
+    throw new Error(
+      "Not in a worktree project.\nRun this from within a project cloned with `episoda clone`."
+    );
+  }
+  const manager = new WorktreeManager(projectRoot);
+  const initialized = await manager.initialize();
+  if (!initialized) {
+    throw new Error(`Invalid worktree project at ${projectRoot}`);
+  }
+  const config = manager.getConfig();
+  const worktrees = manager.listWorktrees();
+  console.log("");
+  console.log(import_chalk2.default.bold(`Worktrees for ${config?.workspaceSlug}/${config?.projectSlug}`));
+  console.log("\u2500".repeat(60));
+  if (worktrees.length === 0) {
+    console.log("");
+    console.log(import_chalk2.default.gray("  No worktrees checked out"));
+    console.log("");
+    status.info("Create a worktree with:");
+    status.info("  episoda checkout {moduleUid}");
+    return;
+  }
+  const gitExecutor = new import_core14.GitExecutor();
+  for (const wt of worktrees) {
+    console.log("");
+    let statusIndicator = import_chalk2.default.green("\u25CF");
+    let statusNote = "";
+    try {
+      const result = await gitExecutor.execute(
+        { action: "status" },
+        { cwd: wt.worktreePath }
+      );
+      if (result.success) {
+        const uncommitted = result.details?.uncommittedFiles || [];
+        if (uncommitted.length > 0) {
+          statusIndicator = import_chalk2.default.yellow("\u25CF");
+          statusNote = import_chalk2.default.yellow(` (${uncommitted.length} uncommitted)`);
+        }
+      }
+    } catch {
+      statusIndicator = import_chalk2.default.gray("\u25CB");
+    }
+    console.log(`  ${statusIndicator} ${import_chalk2.default.bold(wt.moduleUid)}${statusNote}`);
+    console.log(import_chalk2.default.gray(`    Branch: ${wt.branchName}`));
+    console.log(import_chalk2.default.gray(`    Path: ${wt.worktreePath}`));
+    if (options.verbose) {
+      console.log(import_chalk2.default.gray(`    Created: ${new Date(wt.createdAt).toLocaleDateString()}`));
+      console.log(import_chalk2.default.gray(`    Last accessed: ${new Date(wt.lastAccessed).toLocaleDateString()}`));
+    }
+  }
+  console.log("");
+  console.log(import_chalk2.default.gray("\u2500".repeat(60)));
+  console.log(`${worktrees.length} worktree${worktrees.length === 1 ? "" : "s"}`);
+  console.log("");
+  console.log(import_chalk2.default.gray("\u25CF clean  ") + import_chalk2.default.yellow("\u25CF uncommitted changes"));
+  console.log("");
+}
+
 // src/index.ts
-import_commander.program.name("episoda").description("Episoda local development workflow orchestration").version(import_core8.VERSION);
+import_commander.program.name("episoda").description("Episoda local development workflow orchestration").version(import_core15.VERSION);
 import_commander.program.command("auth").description("Authenticate to Episoda via OAuth and configure CLI").option("--api-url <url>", "API URL (default: https://episoda.dev)").action(async (options) => {
   try {
     await authCommand(options);
@@ -4088,6 +5877,46 @@ import_commander.program.command("disconnect").description("Disconnect from epis
     process.exit(1);
   }
 });
+import_commander.program.command("clone").description("Clone a project in worktree mode for multi-module development").argument("<workspace/project>", "Workspace and project slug (e.g., my-team/my-project)").option("--api-url <url>", "API URL (default: https://episoda.dev)").action(async (slug, options) => {
+  try {
+    await cloneCommand(slug, options);
+  } catch (error) {
+    status.error(`Clone failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+});
+import_commander.program.command("checkout").description("Create a worktree for a module").argument("<moduleUid>", "Module UID (e.g., EP100)").option("--api-url <url>", "API URL (default: https://episoda.dev)").option("--create", "Create branch if it doesn't exist").action(async (moduleUid, options) => {
+  try {
+    await checkoutCommand(moduleUid, options);
+  } catch (error) {
+    status.error(`Checkout failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+});
+import_commander.program.command("release").description("Remove a worktree for a module (preserves branch)").argument("<moduleUid>", "Module UID (e.g., EP100)").option("--force", "Force release even with uncommitted changes").option("--api-url <url>", "API URL (default: https://episoda.dev)").action(async (moduleUid, options) => {
+  try {
+    await releaseCommand(moduleUid, options);
+  } catch (error) {
+    status.error(`Release failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+});
+import_commander.program.command("list").description("List cloned projects and worktrees").argument("[subcommand]", 'Subcommand: "worktrees" or "wt" to list worktrees').option("--verbose", "Show detailed information").action(async (subcommand, options) => {
+  try {
+    await listCommand(subcommand, options);
+  } catch (error) {
+    status.error(`List failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+});
+import_commander.program.command("migrate").description("Convert existing project to worktree mode").option("--force", "Force migration even with uncommitted changes (auto-stash)").option("--dry-run", "Show what would be done without making changes").action(async (options) => {
+  try {
+    await migrateCommand(options);
+  } catch (error) {
+    status.error(`Migration failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+});
 import_commander.program.command("dev:restart").description("Restart the dev server for a module").argument("[moduleUid]", "Module UID (required)").action(async (moduleUid) => {
   try {
     if (!moduleUid) {