episoda 0.2.21 → 0.2.23

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 GitExecutor6 = class {
+    var GitExecutor4 = class {
       /**
        * Execute a git command
        * @param command - The git command to execute
@@ -530,6 +530,24 @@ var require_git_executor = __commonJS({
        * Execute status command
        */
       async executeStatus(cwd, options) {
+        try {
+          const isBareResult = await execAsync("git rev-parse --is-bare-repository", { cwd, timeout: 5e3 });
+          if (isBareResult.stdout.trim() === "true") {
+            const headResult = await execAsync("git symbolic-ref --short HEAD", { cwd, timeout: 5e3 });
+            const branchName = headResult.stdout.trim();
+            return {
+              success: true,
+              output: `## ${branchName}`,
+              details: {
+                uncommittedFiles: [],
+                // No working tree in bare repo
+                branchName,
+                currentBranch: branchName
+              }
+            };
+          }
+        } catch {
+        }
         const result = await this.runGitCommand(["status", "--porcelain", "-b"], cwd, options);
         if (result.success && result.output) {
           const statusInfo = (0, git_parser_1.parseGitStatus)(result.output);
@@ -1531,15 +1549,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 fs12 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+            const fs11 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
             const rebaseMergePath = `${gitDirPath}/rebase-merge`;
             const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
             try {
-              await fs12.access(rebaseMergePath);
+              await fs11.access(rebaseMergePath);
               inRebase = true;
             } catch {
               try {
-                await fs12.access(rebaseApplyPath);
+                await fs11.access(rebaseApplyPath);
                 inRebase = true;
               } catch {
                 inRebase = false;
@@ -1593,9 +1611,9 @@ var require_git_executor = __commonJS({
               error: validation.error || "UNKNOWN_ERROR"
             };
           }
-          const fs12 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs11 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs12.access(command.path);
+            await fs11.access(command.path);
             return {
               success: false,
               error: "WORKTREE_EXISTS",
@@ -1646,9 +1664,9 @@ var require_git_executor = __commonJS({
        */
       async executeWorktreeRemove(command, cwd, options) {
         try {
-          const fs12 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs11 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs12.access(command.path);
+            await fs11.access(command.path);
           } catch {
             return {
               success: false,
@@ -1801,10 +1819,10 @@ var require_git_executor = __commonJS({
        */
       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")));
+          const fs11 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path13 = await Promise.resolve().then(() => __importStar(require("path")));
           try {
-            await fs12.access(command.path);
+            await fs11.access(command.path);
             return {
               success: false,
               error: "BRANCH_ALREADY_EXISTS",
@@ -1813,9 +1831,9 @@ var require_git_executor = __commonJS({
             };
           } catch {
           }
-          const parentDir = path14.dirname(command.path);
+          const parentDir = path13.dirname(command.path);
           try {
-            await fs12.mkdir(parentDir, { recursive: true });
+            await fs11.mkdir(parentDir, { recursive: true });
           } catch {
           }
           const { stdout, stderr } = await execAsync(
@@ -1858,24 +1876,22 @@ var require_git_executor = __commonJS({
        */
       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")));
+          const fs11 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path13 = 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");
+            const bareDir = path13.join(currentPath, ".bare");
+            const episodaDir = path13.join(currentPath, ".episoda");
             try {
-              await fs12.access(bareDir);
-              await fs12.access(episodaDir);
-              worktreeMode = true;
+              await fs11.access(bareDir);
+              await fs11.access(episodaDir);
               projectPath = currentPath;
               bareRepoPath = bareDir;
               break;
             } catch {
-              const parentPath = path14.dirname(currentPath);
+              const parentPath = path13.dirname(currentPath);
               if (parentPath === currentPath) {
                 break;
               }
@@ -1884,9 +1900,8 @@ var require_git_executor = __commonJS({
           }
           return {
             success: true,
-            output: worktreeMode ? "Worktree mode project" : "Standard git project",
+            output: bareRepoPath ? "Episoda project" : "Git repository",
             details: {
-              worktreeMode,
               projectPath,
               bareRepoPath
             }
@@ -1998,7 +2013,7 @@ var require_git_executor = __commonJS({
         }
       }
     };
-    exports2.GitExecutor = GitExecutor6;
+    exports2.GitExecutor = GitExecutor4;
   }
 });
 
@@ -2467,34 +2482,34 @@ var require_auth = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.getConfigDir = getConfigDir5;
     exports2.getConfigPath = getConfigPath4;
-    exports2.loadConfig = loadConfig7;
-    exports2.saveConfig = saveConfig5;
+    exports2.loadConfig = loadConfig6;
+    exports2.saveConfig = saveConfig3;
     exports2.validateToken = validateToken;
-    var fs12 = __importStar(require("fs"));
-    var path14 = __importStar(require("path"));
+    var fs11 = __importStar(require("fs"));
+    var path13 = __importStar(require("path"));
     var os3 = __importStar(require("os"));
     var child_process_1 = require("child_process");
     var DEFAULT_CONFIG_FILE = "config.json";
     function getConfigDir5() {
-      return process.env.EPISODA_CONFIG_DIR || path14.join(os3.homedir(), ".episoda");
+      return process.env.EPISODA_CONFIG_DIR || path13.join(os3.homedir(), ".episoda");
     }
     function getConfigPath4(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path14.join(getConfigDir5(), DEFAULT_CONFIG_FILE);
+      return path13.join(getConfigDir5(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path14.dirname(configPath);
-      const isNew = !fs12.existsSync(dir);
+      const dir = path13.dirname(configPath);
+      const isNew = !fs11.existsSync(dir);
       if (isNew) {
-        fs12.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs11.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path14.join(dir, ".nosync");
-        if (isNew || !fs12.existsSync(nosyncPath)) {
+        const nosyncPath = path13.join(dir, ".nosync");
+        if (isNew || !fs11.existsSync(nosyncPath)) {
           try {
-            fs12.writeFileSync(nosyncPath, "", { mode: 384 });
+            fs11.writeFileSync(nosyncPath, "", { mode: 384 });
             (0, child_process_1.execSync)(`xattr -w com.apple.fileprovider.ignore 1 "${dir}"`, {
               stdio: "ignore",
               timeout: 5e3
@@ -2504,13 +2519,13 @@ var require_auth = __commonJS({
         }
       }
     }
-    async function loadConfig7(configPath) {
+    async function loadConfig6(configPath) {
       const fullPath = getConfigPath4(configPath);
-      if (!fs12.existsSync(fullPath)) {
+      if (!fs11.existsSync(fullPath)) {
         return null;
       }
       try {
-        const content = fs12.readFileSync(fullPath, "utf8");
+        const content = fs11.readFileSync(fullPath, "utf8");
         const config = JSON.parse(content);
         return config;
       } catch (error) {
@@ -2518,12 +2533,12 @@ var require_auth = __commonJS({
         return null;
       }
     }
-    async function saveConfig5(config, configPath) {
+    async function saveConfig3(config, configPath) {
       const fullPath = getConfigPath4(configPath);
       ensureConfigDir(fullPath);
       try {
         const content = JSON.stringify(config, null, 2);
-        fs12.writeFileSync(fullPath, content, { mode: 384 });
+        fs11.writeFileSync(fullPath, content, { mode: 384 });
       } catch (error) {
         throw new Error(`Failed to save config: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -2634,10 +2649,10 @@ var require_dist = __commonJS({
 
 // src/index.ts
 var import_commander = require("commander");
-var import_core15 = __toESM(require_dist());
+var import_core14 = __toESM(require_dist());
 
 // src/commands/dev.ts
-var import_core6 = __toESM(require_dist());
+var import_core4 = __toESM(require_dist());
 
 // src/framework-detector.ts
 var fs = __toESM(require("fs"));
@@ -3110,9 +3125,9 @@ async function getDevServerStatus() {
 }
 
 // src/commands/dev.ts
-var import_child_process3 = require("child_process");
-var path7 = __toESM(require("path"));
-var fs6 = __toESM(require("fs"));
+var import_child_process2 = require("child_process");
+var path5 = __toESM(require("path"));
+var fs4 = __toESM(require("fs"));
 
 // src/utils/port-check.ts
 var net2 = __toESM(require("net"));
@@ -3172,7 +3187,8 @@ var WorktreeManager = class _WorktreeManager {
   }
   /**
    * Initialize worktree manager from existing project root
-   * @returns true if valid worktree project, false otherwise
+   * EP971: All projects use worktree architecture
+   * @returns true if valid project, false otherwise
    */
   async initialize() {
     if (!fs3.existsSync(this.bareRepoPath)) {
@@ -3183,7 +3199,7 @@ var WorktreeManager = class _WorktreeManager {
     }
     try {
       const config = this.readConfig();
-      return config?.worktreeMode === true;
+      return config !== null;
     } catch {
       return false;
     }
@@ -3208,7 +3224,6 @@ var WorktreeManager = class _WorktreeManager {
       workspaceSlug,
       projectSlug,
       bareRepoPath: manager.bareRepoPath,
-      worktreeMode: true,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       worktrees: []
     };
@@ -3564,6 +3579,148 @@ var WorktreeManager = class _WorktreeManager {
       this.releaseLock();
     }
   }
+  // EP959-11: Worktree setup methods
+  /**
+   * Update the setup status of a worktree
+   */
+  async updateWorktreeStatus(moduleUid, status2, error) {
+    return this.updateConfigSafe((config) => {
+      const worktree = config.worktrees.find((w) => w.moduleUid === moduleUid);
+      if (worktree) {
+        worktree.setupStatus = status2;
+        if (status2 === "running") {
+          worktree.setupStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+        } else if (status2 === "ready" || status2 === "error") {
+          worktree.setupCompletedAt = (/* @__PURE__ */ new Date()).toISOString();
+        }
+        if (error) {
+          worktree.setupError = error;
+        }
+      }
+      return config;
+    });
+  }
+  /**
+   * Get worktree info including setup status
+   */
+  getWorktreeStatus(moduleUid) {
+    const config = this.readConfig();
+    if (!config) return null;
+    return config.worktrees.find((w) => w.moduleUid === moduleUid) || null;
+  }
+  /**
+   * Copy files from main worktree to module worktree
+   *
+   * @deprecated EP964: This function is deprecated. Use worktree_env_vars for
+   * environment variables or worktree_setup_script for other file operations.
+   * This function now returns success (no-op) when main/ worktree doesn't exist.
+   */
+  async copyFilesFromMain(moduleUid, files) {
+    console.warn(`[WorktreeManager] EP964: copyFilesFromMain is DEPRECATED.`);
+    console.warn(`[WorktreeManager] EP964: Use worktree_env_vars for .env or worktree_setup_script for other files.`);
+    const config = this.readConfig();
+    if (!config) {
+      return { success: false, error: "Config not found" };
+    }
+    const worktree = config.worktrees.find((w) => w.moduleUid === moduleUid);
+    if (!worktree) {
+      return { success: false, error: `Worktree not found for ${moduleUid}` };
+    }
+    const mainWorktree = config.worktrees.find((w) => w.moduleUid === "main");
+    if (!mainWorktree) {
+      console.warn(`[WorktreeManager] EP964: No 'main' worktree - skipping file copy (this is expected).`);
+      return { success: true };
+    }
+    try {
+      for (const file of files) {
+        const srcPath = path4.join(mainWorktree.worktreePath, file);
+        const destPath = path4.join(worktree.worktreePath, file);
+        if (fs3.existsSync(srcPath)) {
+          const destDir = path4.dirname(destPath);
+          if (!fs3.existsSync(destDir)) {
+            fs3.mkdirSync(destDir, { recursive: true });
+          }
+          fs3.copyFileSync(srcPath, destPath);
+          console.log(`[WorktreeManager] EP964: Copied ${file} to ${moduleUid} (deprecated)`);
+        } else {
+          console.log(`[WorktreeManager] EP964: Skipped ${file} (not found in main)`);
+        }
+      }
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  /**
+   * Run worktree setup script
+   * EP959-M1: Enhanced logging with working directory, timeout info, and script preview
+   */
+  async runSetupScript(moduleUid, script) {
+    const config = this.readConfig();
+    if (!config) {
+      return { success: false, error: "Config not found" };
+    }
+    const worktree = config.worktrees.find((w) => w.moduleUid === moduleUid);
+    if (!worktree) {
+      return { success: false, error: `Worktree not found for ${moduleUid}` };
+    }
+    const TIMEOUT_MINUTES = 10;
+    const scriptPreview = script.length > 200 ? script.slice(0, 200) + "..." : script;
+    console.log(`[WorktreeManager] EP959: Running setup script for ${moduleUid}`);
+    console.log(`[WorktreeManager] EP959:   Working directory: ${worktree.worktreePath}`);
+    console.log(`[WorktreeManager] EP959:   Timeout: ${TIMEOUT_MINUTES} minutes`);
+    console.log(`[WorktreeManager] EP959:   Script: ${scriptPreview}`);
+    try {
+      const { execSync: execSync7 } = require("child_process");
+      execSync7(script, {
+        cwd: worktree.worktreePath,
+        stdio: "inherit",
+        timeout: TIMEOUT_MINUTES * 60 * 1e3,
+        env: { ...process.env, NODE_ENV: "development" }
+      });
+      console.log(`[WorktreeManager] EP959: Setup script completed successfully for ${moduleUid}`);
+      return { success: true };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error(`[WorktreeManager] EP959: Setup script failed for ${moduleUid}:`, errorMessage);
+      return { success: false, error: errorMessage };
+    }
+  }
+  /**
+   * Run worktree cleanup script before removal
+   * EP959-m3: Execute cleanup script when worktree is being released
+   */
+  async runCleanupScript(moduleUid, script) {
+    const config = this.readConfig();
+    if (!config) {
+      return { success: false, error: "Config not found" };
+    }
+    const worktree = config.worktrees.find((w) => w.moduleUid === moduleUid);
+    if (!worktree) {
+      return { success: false, error: `Worktree not found for ${moduleUid}` };
+    }
+    const TIMEOUT_MINUTES = 5;
+    const scriptPreview = script.length > 200 ? script.slice(0, 200) + "..." : script;
+    console.log(`[WorktreeManager] EP959: Running cleanup script for ${moduleUid}`);
+    console.log(`[WorktreeManager] EP959:   Working directory: ${worktree.worktreePath}`);
+    console.log(`[WorktreeManager] EP959:   Timeout: ${TIMEOUT_MINUTES} minutes`);
+    console.log(`[WorktreeManager] EP959:   Script: ${scriptPreview}`);
+    try {
+      const { execSync: execSync7 } = require("child_process");
+      execSync7(script, {
+        cwd: worktree.worktreePath,
+        stdio: "inherit",
+        timeout: TIMEOUT_MINUTES * 60 * 1e3,
+        env: { ...process.env, NODE_ENV: "development" }
+      });
+      console.log(`[WorktreeManager] EP959: Cleanup script completed successfully for ${moduleUid}`);
+      return { success: true };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.warn(`[WorktreeManager] EP959: Cleanup script failed for ${moduleUid} (non-blocking):`, errorMessage);
+      return { success: false, error: errorMessage };
+    }
+  }
 };
 function getEpisodaRoot() {
   return process.env.EPISODA_ROOT || path4.join(require("os").homedir(), "episoda");
@@ -3598,401 +3755,65 @@ async function findProjectRoot(startPath) {
   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.'
-    );
+// src/api/machine-settings.ts
+async function fetchProjectPath(config, projectId) {
+  if (!config.device_id || !config.access_token) {
+    return null;
   }
-  let workspaceSlug = existingConfig.workspace_slug || "default";
-  let projectSlug = existingConfig.project_slug || path6.basename(cwd);
+  const serverUrl = config.api_url || "https://episoda.dev";
+  const url = `${serverUrl}/api/dev/machines/${config.device_id}/project-path/${projectId}`;
   try {
-    const apiUrl = config.api_url || "https://episoda.dev";
-    const response = await fetch(`${apiUrl}/api/projects/${projectId}`, {
+    const response = await fetch(url, {
+      method: "GET",
       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;
+    if (!response.ok) {
+      if (response.status === 404) {
+        return null;
       }
+      console.debug(`[MachineSettings] fetchProjectPath failed: ${response.status} ${response.statusText}`);
+      return null;
     }
-  } 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 data = await response.json();
+    return data.data?.path || null;
+  } catch (error) {
+    console.debug(`[MachineSettings] fetchProjectPath network error:`, error);
+    return null;
   }
-  const uncommittedFiles = statusResult.details?.uncommittedFiles || [];
-  if (hasUncommitted) {
-    status.info(`Found ${uncommittedFiles.length} uncommitted file(s) to preserve...`);
+}
+async function syncProjectPath(config, projectId, path13) {
+  if (!config.device_id || !config.access_token) {
+    return false;
   }
-  const targetExistedBefore = fs5.existsSync(targetPath);
+  const serverUrl = config.api_url || "https://episoda.dev";
+  const url = `${serverUrl}/api/dev/machines/${config.device_id}/project-path/${projectId}`;
   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
+    const response = await fetch(url, {
+      method: "PUT",
+      headers: {
+        "Authorization": `Bearer ${config.access_token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ path: path13 })
     });
-    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");
+    if (!response.ok) {
+      console.debug(`[MachineSettings] syncProjectPath failed: ${response.status} ${response.statusText}`);
     }
-    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("");
+    return response.ok;
   } 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");
-        }
-      }
-      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 extractModuleUid(branchName) {
-  const match = branchName.match(/ep(\d+)/i);
-  if (match) {
-    return `EP${match[1]}`;
+    console.debug(`[MachineSettings] syncProjectPath network error:`, error);
+    return false;
   }
-  return null;
 }
 
 // src/commands/dev.ts
 var CONNECTION_MAX_RETRIES = 3;
 function findGitRoot(startDir) {
   try {
-    const result = (0, import_child_process3.execSync)("git rev-parse --show-toplevel", {
+    const result = (0, import_child_process2.execSync)("git rev-parse --show-toplevel", {
       cwd: startDir,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -4004,7 +3825,7 @@ function findGitRoot(startDir) {
 }
 async function devCommand(options = {}) {
   try {
-    const config = await (0, import_core6.loadConfig)();
+    const config = await (0, import_core4.loadConfig)();
     if (!config || !config.access_token || !config.project_id) {
       status.error("No authentication found. Please run:");
       status.info("");
@@ -4046,59 +3867,33 @@ async function devCommand(options = {}) {
         await new Promise((resolve4) => setTimeout(resolve4, 2e3));
       }
     }
-    const serverUrl = config.api_url || process.env.EPISODA_API_URL || "https://episoda.dev";
     let projectPath;
-    const SETTINGS_CACHE_TTL = 24 * 60 * 60 * 1e3;
-    const cachedSettings = config.project_settings;
-    const isCacheFresh = cachedSettings?.cached_at && Date.now() - cachedSettings.cached_at < SETTINGS_CACHE_TTL;
-    if (isCacheFresh && cachedSettings?.local_project_path) {
-      projectPath = cachedSettings.local_project_path;
-      status.debug(`Using cached project path: ${projectPath}`);
+    const serverPath = await fetchProjectPath(config, config.project_id);
+    if (serverPath && fs4.existsSync(serverPath)) {
+      projectPath = serverPath;
+      status.debug(`Using server-synced project path: ${projectPath}`);
     } else {
       const detectedRoot = findGitRoot(options.cwd || process.cwd());
-      projectPath = detectedRoot || path7.resolve(options.cwd || process.cwd());
+      projectPath = detectedRoot || path5.resolve(options.cwd || process.cwd());
       if (detectedRoot) {
         status.debug(`Detected project root: ${projectPath}`);
       } else {
         status.warning(`Could not detect git root, using: ${projectPath}`);
       }
-      const updatedConfig = {
-        ...config,
-        project_settings: {
-          ...cachedSettings,
-          local_project_path: projectPath,
-          cached_at: Date.now()
+      syncProjectPath(config, config.project_id, projectPath).then((synced) => {
+        if (synced) {
+          status.debug("Project path synced to server");
         }
-      };
-      await (0, import_core6.saveConfig)(updatedConfig);
-      status.debug("Cached project settings locally");
-      const settingsUrl = `${serverUrl}/api/projects/${config.project_id}/settings`;
-      fetch(settingsUrl, {
-        method: "PATCH",
-        headers: {
-          "Authorization": `Bearer ${config.access_token}`,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({ local_project_path: projectPath })
       }).catch(() => {
       });
     }
-    const hasGitDir = fs6.existsSync(path7.join(projectPath, ".git"));
     const isWorktree = await isWorktreeProject(projectPath);
-    if (hasGitDir && !isWorktree) {
+    if (!isWorktree) {
+      status.error("Not an Episoda project.");
       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("Use `episoda clone {workspace}/{project}` to set up a project.");
       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("");
-      }
+      process.exit(1);
     }
     let daemonPid = isDaemonRunning();
     if (!daemonPid) {
@@ -4192,7 +3987,7 @@ async function runDevServer(command, cwd, autoRestart) {
   let shuttingDown = false;
   const startServer = () => {
     status.info(`Starting dev server: ${command.join(" ")}`);
-    devProcess = (0, import_child_process3.spawn)(command[0], command.slice(1), {
+    devProcess = (0, import_child_process2.spawn)(command[0], command.slice(1), {
       cwd,
       stdio: ["inherit", "inherit", "inherit"],
       shell: true
@@ -4245,33 +4040,33 @@ Received ${signal}, shutting down...`);
 
 // src/commands/auth.ts
 var os = __toESM(require("os"));
-var fs8 = __toESM(require("fs"));
-var path9 = __toESM(require("path"));
-var import_child_process5 = require("child_process");
-var import_core8 = __toESM(require_dist());
+var fs6 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
+var import_child_process4 = require("child_process");
+var import_core6 = __toESM(require_dist());
 
 // src/daemon/machine-id.ts
-var fs7 = __toESM(require("fs"));
-var path8 = __toESM(require("path"));
+var fs5 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
 var crypto2 = __toESM(require("crypto"));
-var import_child_process4 = require("child_process");
-var import_core7 = __toESM(require_dist());
+var import_child_process3 = require("child_process");
+var import_core5 = __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 = path8.join((0, import_core7.getConfigDir)(), "machine-id");
+  const machineIdPath = path6.join((0, import_core5.getConfigDir)(), "machine-id");
   try {
-    if (fs7.existsSync(machineIdPath)) {
-      const existingId = fs7.readFileSync(machineIdPath, "utf-8").trim();
+    if (fs5.existsSync(machineIdPath)) {
+      const existingId = fs5.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();
-        fs7.writeFileSync(machineIdPath, newUUID, "utf-8");
+        fs5.writeFileSync(machineIdPath, newUUID, "utf-8");
         console.log(`[MachineId] Migrated: ${existingId} \u2192 ${newUUID}`);
         return newUUID;
       }
@@ -4280,11 +4075,11 @@ async function getMachineId() {
   }
   const machineId = generateMachineId();
   try {
-    const dir = path8.dirname(machineIdPath);
-    if (!fs7.existsSync(dir)) {
-      fs7.mkdirSync(dir, { recursive: true });
+    const dir = path6.dirname(machineIdPath);
+    if (!fs5.existsSync(dir)) {
+      fs5.mkdirSync(dir, { recursive: true });
     }
-    fs7.writeFileSync(machineIdPath, machineId, "utf-8");
+    fs5.writeFileSync(machineIdPath, machineId, "utf-8");
   } catch (error) {
     console.error("Warning: Could not save machine ID to disk:", error);
   }
@@ -4293,7 +4088,7 @@ async function getMachineId() {
 function getHardwareUUID() {
   try {
     if (process.platform === "darwin") {
-      const output = (0, import_child_process4.execSync)(
+      const output = (0, import_child_process3.execSync)(
         `ioreg -d2 -c IOPlatformExpertDevice | awk -F\\" '/IOPlatformUUID/{print $(NF-1)}'`,
         { encoding: "utf-8", timeout: 5e3 }
       ).trim();
@@ -4301,20 +4096,20 @@ function getHardwareUUID() {
         return output;
       }
     } else if (process.platform === "linux") {
-      if (fs7.existsSync("/etc/machine-id")) {
-        const machineId = fs7.readFileSync("/etc/machine-id", "utf-8").trim();
+      if (fs5.existsSync("/etc/machine-id")) {
+        const machineId = fs5.readFileSync("/etc/machine-id", "utf-8").trim();
         if (machineId && machineId.length > 0) {
           return machineId;
         }
       }
-      if (fs7.existsSync("/var/lib/dbus/machine-id")) {
-        const dbusId = fs7.readFileSync("/var/lib/dbus/machine-id", "utf-8").trim();
+      if (fs5.existsSync("/var/lib/dbus/machine-id")) {
+        const dbusId = fs5.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_process4.execSync)("wmic csproduct get uuid", {
+      const output = (0, import_child_process3.execSync)("wmic csproduct get uuid", {
         encoding: "utf-8",
         timeout: 5e3
       });
@@ -4695,7 +4490,7 @@ async function authCommand(options = {}) {
   status.info(`  Project: ${tokenResponse.project_uid}`);
   status.info(`  Workspace: ${tokenResponse.workspace_uid}`);
   status.info("");
-  await (0, import_core8.saveConfig)({
+  await (0, import_core6.saveConfig)({
     project_id: tokenResponse.project_id,
     user_id: tokenResponse.user_id,
     workspace_id: tokenResponse.workspace_id,
@@ -4709,7 +4504,7 @@ async function authCommand(options = {}) {
     // Convert to Unix timestamp
     api_url: apiUrl
   });
-  status.success(`\u2713 Configuration saved to ${(0, import_core8.getConfigPath)()}`);
+  status.success(`\u2713 Configuration saved to ${(0, import_core6.getConfigPath)()}`);
   status.info("");
   status.info("Installing git credential helper...");
   const credentialHelperInstalled = await installGitCredentialHelper(apiUrl);
@@ -4753,7 +4548,7 @@ async function monitorAuthorization(apiUrl, deviceCode, expiresIn) {
       resolve4(false);
     }, expiresIn * 1e3);
     const url = `${apiUrl}/api/oauth/authorize-stream?device_code=${deviceCode}`;
-    const curlProcess = (0, import_child_process5.spawn)("curl", ["-N", url]);
+    const curlProcess = (0, import_child_process4.spawn)("curl", ["-N", url]);
     let buffer = "";
     curlProcess.stdout.on("data", (chunk) => {
       buffer += chunk.toString();
@@ -4857,7 +4652,7 @@ function openBrowser(url) {
       break;
   }
   try {
-    (0, import_child_process5.spawn)(command, args, {
+    (0, import_child_process4.spawn)(command, args, {
       detached: true,
       stdio: "ignore"
     }).unref();
@@ -4868,17 +4663,17 @@ function openBrowser(url) {
 async function installGitCredentialHelper(apiUrl) {
   try {
     const homeDir = os.homedir();
-    const episodaBinDir = path9.join(homeDir, ".episoda", "bin");
-    const helperPath = path9.join(episodaBinDir, "git-credential-episoda");
-    fs8.mkdirSync(episodaBinDir, { recursive: true });
+    const episodaBinDir = path7.join(homeDir, ".episoda", "bin");
+    const helperPath = path7.join(episodaBinDir, "git-credential-episoda");
+    fs6.mkdirSync(episodaBinDir, { recursive: true });
     const scriptContent = generateCredentialHelperScript(apiUrl);
-    fs8.writeFileSync(helperPath, scriptContent, { mode: 493 });
+    fs6.writeFileSync(helperPath, scriptContent, { mode: 493 });
     try {
-      fs8.accessSync(helperPath, fs8.constants.X_OK);
+      fs6.accessSync(helperPath, fs6.constants.X_OK);
     } catch {
     }
     try {
-      const allHelpers = (0, import_child_process5.execSync)("git config --global --get-all credential.helper", {
+      const allHelpers = (0, import_child_process4.execSync)("git config --global --get-all credential.helper", {
         encoding: "utf8",
         stdio: ["pipe", "pipe", "pipe"]
       }).trim().split("\n");
@@ -4887,7 +4682,7 @@ async function installGitCredentialHelper(apiUrl) {
       }
     } catch {
     }
-    (0, import_child_process5.execSync)(`git config --global --add credential.helper "${helperPath}"`, {
+    (0, import_child_process4.execSync)(`git config --global --add credential.helper "${helperPath}"`, {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -4905,19 +4700,19 @@ function updateShellProfile(binDir) {
   }
   const homeDir = os.homedir();
   const profiles = [
-    path9.join(homeDir, ".bashrc"),
-    path9.join(homeDir, ".zshrc"),
-    path9.join(homeDir, ".profile")
+    path7.join(homeDir, ".bashrc"),
+    path7.join(homeDir, ".zshrc"),
+    path7.join(homeDir, ".profile")
   ];
   const exportLine = `export PATH="${binDir}:$PATH"  # Added by episoda auth`;
   for (const profile of profiles) {
     try {
-      if (fs8.existsSync(profile)) {
-        const content = fs8.readFileSync(profile, "utf8");
+      if (fs6.existsSync(profile)) {
+        const content = fs6.readFileSync(profile, "utf8");
         if (content.includes(".episoda/bin")) {
           continue;
         }
-        fs8.appendFileSync(profile, `
+        fs6.appendFileSync(profile, `
 # Episoda CLI
 ${exportLine}
 `);
@@ -4929,10 +4724,10 @@ ${exportLine}
 
 // src/commands/connect.ts
 var os2 = __toESM(require("os"));
-var fs9 = __toESM(require("fs"));
-var path10 = __toESM(require("path"));
-var import_child_process6 = require("child_process");
-var import_core9 = __toESM(require_dist());
+var fs7 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
+var import_child_process5 = require("child_process");
+var import_core7 = __toESM(require_dist());
 async function connectCommand(options) {
   const { code } = options;
   const apiUrl = options.apiUrl || process.env.EPISODA_API_URL || "https://episoda.dev";
@@ -4948,14 +4743,14 @@ async function connectCommand(options) {
   status.info(`  Project: ${tokenResponse.project_uid}`);
   status.info(`  Workspace: ${tokenResponse.workspace_uid}`);
   status.info("");
-  await (0, import_core9.saveConfig)({
+  await (0, import_core7.saveConfig)({
     project_id: tokenResponse.project_id,
     user_id: tokenResponse.user_id,
     workspace_id: tokenResponse.workspace_id,
     access_token: tokenResponse.access_token,
     api_url: apiUrl
   });
-  status.success(`\u2713 Configuration saved to ${(0, import_core9.getConfigPath)()}`);
+  status.success(`\u2713 Configuration saved to ${(0, import_core7.getConfigPath)()}`);
   status.info("");
   status.info("Installing git credential helper...");
   const credentialHelperInstalled = await installGitCredentialHelper2(apiUrl);
@@ -5005,13 +4800,13 @@ async function exchangeUserCode(apiUrl, userCode, machineId) {
 async function installGitCredentialHelper2(apiUrl) {
   try {
     const homeDir = os2.homedir();
-    const episodaBinDir = path10.join(homeDir, ".episoda", "bin");
-    const helperPath = path10.join(episodaBinDir, "git-credential-episoda");
-    fs9.mkdirSync(episodaBinDir, { recursive: true });
+    const episodaBinDir = path8.join(homeDir, ".episoda", "bin");
+    const helperPath = path8.join(episodaBinDir, "git-credential-episoda");
+    fs7.mkdirSync(episodaBinDir, { recursive: true });
     const scriptContent = generateCredentialHelperScript(apiUrl);
-    fs9.writeFileSync(helperPath, scriptContent, { mode: 493 });
+    fs7.writeFileSync(helperPath, scriptContent, { mode: 493 });
     try {
-      const allHelpers = (0, import_child_process6.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");
@@ -5020,7 +4815,7 @@ async function installGitCredentialHelper2(apiUrl) {
       }
     } catch {
     }
-    (0, import_child_process6.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"]
     });
@@ -5038,19 +4833,19 @@ function updateShellProfile2(binDir) {
   }
   const homeDir = os2.homedir();
   const profiles = [
-    path10.join(homeDir, ".bashrc"),
-    path10.join(homeDir, ".zshrc"),
-    path10.join(homeDir, ".profile")
+    path8.join(homeDir, ".bashrc"),
+    path8.join(homeDir, ".zshrc"),
+    path8.join(homeDir, ".profile")
   ];
   const exportLine = `export PATH="${binDir}:$PATH"  # Added by episoda`;
   for (const profile of profiles) {
     try {
-      if (fs9.existsSync(profile)) {
-        const content = fs9.readFileSync(profile, "utf8");
+      if (fs7.existsSync(profile)) {
+        const content = fs7.readFileSync(profile, "utf8");
         if (content.includes(".episoda/bin")) {
           continue;
         }
-        fs9.appendFileSync(profile, `
+        fs7.appendFileSync(profile, `
 # Episoda CLI
 ${exportLine}
 `);
@@ -5061,11 +4856,11 @@ ${exportLine}
 }
 
 // src/commands/status.ts
-var import_core10 = __toESM(require_dist());
+var import_core8 = __toESM(require_dist());
 async function statusCommand(options = {}) {
   status.info("Checking CLI status...");
   status.info("");
-  const config = await (0, import_core10.loadConfig)();
+  const config = await (0, import_core8.loadConfig)();
   if (!config) {
     status.error("\u2717 CLI not initialized");
     status.info("");
@@ -5080,8 +4875,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: ${import_core10.VERSION}`);
-  status.info(`  Config file: ${(0, import_core10.getConfigPath)()}`);
+  status.info(`  CLI Version: ${import_core8.VERSION}`);
+  status.info(`  Config file: ${(0, import_core8.getConfigPath)()}`);
   status.info("");
   if (!config.access_token || config.access_token === "") {
     status.warning("\u26A0 Not authenticated");
@@ -5241,9 +5036,83 @@ async function stopCommand(options = {}) {
 }
 
 // src/commands/clone.ts
-var fs10 = __toESM(require("fs"));
-var path11 = __toESM(require("path"));
-var import_core11 = __toESM(require_dist());
+var fs9 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
+var import_child_process6 = require("child_process");
+var import_core10 = __toESM(require_dist());
+
+// src/daemon/project-tracker.ts
+var fs8 = __toESM(require("fs"));
+var path9 = __toESM(require("path"));
+var import_core9 = __toESM(require_dist());
+function getProjectsFilePath() {
+  return path9.join((0, import_core9.getConfigDir)(), "projects.json");
+}
+function readProjects() {
+  const projectsPath = getProjectsFilePath();
+  try {
+    if (!fs8.existsSync(projectsPath)) {
+      return { projects: [] };
+    }
+    const content = fs8.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 = path9.dirname(projectsPath);
+    if (!fs8.existsSync(dir)) {
+      fs8.mkdirSync(dir, { recursive: true });
+    }
+    fs8.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?.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 = path9.basename(projectPath);
+  const newProject = {
+    id: projectId,
+    path: projectPath,
+    name: projectName,
+    added_at: now,
+    last_active: now,
+    // EP971: Bare repo path for worktree architecture
+    bareRepoPath: options?.bareRepoPath
+  };
+  data.projects.push(newProject);
+  writeProjects(data);
+  return newProject;
+}
+
+// src/commands/clone.ts
 async function cloneCommand(slugArg, options = {}) {
   const slugParts = slugArg.split("/");
   if (slugParts.length !== 2 || !slugParts[0] || !slugParts[1]) {
@@ -5254,7 +5123,7 @@ async function cloneCommand(slugArg, options = {}) {
   const [workspaceSlug, projectSlug] = slugParts;
   status.info(`Cloning ${workspaceSlug}/${projectSlug}...`);
   status.info("");
-  const config = await (0, import_core11.loadConfig)();
+  const config = await (0, import_core10.loadConfig)();
   if (!config || !config.access_token) {
     throw new Error(
       "Not authenticated. Please run `episoda auth` first."
@@ -5262,9 +5131,9 @@ async function cloneCommand(slugArg, options = {}) {
   }
   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)) {
+  if (fs9.existsSync(projectPath)) {
+    const bareRepoPath = path10.join(projectPath, ".bare");
+    if (fs9.existsSync(bareRepoPath)) {
       status.warning(`Project already cloned at ${projectPath}`);
       status.info("");
       status.info("Next steps:");
@@ -5273,7 +5142,7 @@ async function cloneCommand(slugArg, options = {}) {
       return;
     }
     throw new Error(
-      `Directory exists but is not a worktree project: ${projectPath}
+      `Directory exists but is not an Episoda project: ${projectPath}
 Please remove it manually or use a different location.`
     );
   }
@@ -5296,7 +5165,7 @@ Please configure a repository in the project settings on episoda.dev.`
   status.info("");
   status.info("Creating project directory...");
   const episodaRoot = getEpisodaRoot();
-  fs10.mkdirSync(projectPath, { recursive: true });
+  fs9.mkdirSync(projectPath, { recursive: true });
   status.success(`\u2713 Created ${projectPath}`);
   status.info("Cloning repository (bare)...");
   try {
@@ -5310,8 +5179,10 @@ Please configure a repository in the project settings on episoda.dev.`
     status.success("\u2713 Repository cloned");
     status.info("");
     const bareRepoPath = worktreeManager.getBareRepoPath();
+    await extractBootstrapScripts(bareRepoPath, projectPath);
+    status.success("\u2713 Bootstrap scripts extracted");
+    status.info("");
     addProject2(projectDetails.id, projectPath, {
-      worktreeMode: true,
       bareRepoPath
     });
     status.success("\u2713 Project registered with daemon");
@@ -5320,18 +5191,21 @@ Please configure a repository in the project settings on episoda.dev.`
     status.info("");
     status.info("Project structure:");
     status.info(`  ${projectPath}/`);
-    status.info("    \u251C\u2500\u2500 .bare/           # Git repository");
+    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("        \u251C\u2500\u2500 config.json     # Project config");
+    status.info("        \u2514\u2500\u2500 scripts/");
+    status.info("            \u2514\u2500\u2500 api-helper.sh  # API authentication");
     status.info("");
     status.info("Next steps:");
     status.info(`  1. cd ${projectPath}`);
-    status.info("  2. episoda checkout {moduleUid}  # e.g., episoda checkout EP100");
+    status.info("  2. source .episoda/scripts/api-helper.sh  # Load API helpers");
+    status.info("  3. episoda checkout {moduleUid}  # e.g., episoda checkout EP100");
     status.info("");
   } catch (error) {
-    if (fs10.existsSync(projectPath)) {
+    if (fs9.existsSync(projectPath)) {
       try {
-        fs10.rmSync(projectPath, { recursive: true, force: true });
+        fs9.rmSync(projectPath, { recursive: true, force: true });
       } catch {
       }
     }
@@ -5404,9 +5278,23 @@ ${errorBody}`
   }
   return data;
 }
+async function extractBootstrapScripts(bareRepoPath, projectPath) {
+  const scriptsDir = path10.join(projectPath, ".episoda", "scripts");
+  fs9.mkdirSync(scriptsDir, { recursive: true });
+  try {
+    const scriptContent = (0, import_child_process6.execSync)(
+      `git --git-dir="${bareRepoPath}" show main:scripts/api-helper.sh`,
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    );
+    const scriptPath = path10.join(scriptsDir, "api-helper.sh");
+    fs9.writeFileSync(scriptPath, scriptContent, { mode: 493 });
+  } catch (error) {
+    console.log("[clone] Could not extract api-helper.sh:", error);
+  }
+}
 
 // src/commands/checkout.ts
-var import_core12 = __toESM(require_dist());
+var import_core11 = __toESM(require_dist());
 
 // src/utils/http.ts
 async function fetchWithRetry(url, options, maxRetries = 3) {
@@ -5446,7 +5334,7 @@ async function checkoutCommand(moduleUid, options = {}) {
       "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)();
+  const config = await (0, import_core11.loadConfig)();
   if (!config || !config.access_token) {
     throw new Error(
       "Not authenticated. Please run `episoda auth` first."
@@ -5485,8 +5373,8 @@ The .bare directory or .episoda/config.json may be missing.`
   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 { GitExecutor: GitExecutor4 } = await Promise.resolve().then(() => __toESM(require_dist()));
+    const gitExecutor = new GitExecutor4();
     const branchCheck = await gitExecutor.execute(
       { action: "branch_exists", branch: branchName },
       { cwd: worktreeManager.getBareRepoPath() }
@@ -5583,8 +5471,8 @@ async function updateModuleCheckout(apiUrl, moduleId, accessToken, branchName) {
 }
 
 // src/commands/release.ts
-var path12 = __toESM(require("path"));
-var import_core13 = __toESM(require_dist());
+var path11 = __toESM(require("path"));
+var import_core12 = __toESM(require_dist());
 async function releaseCommand(moduleUid, options = {}) {
   if (!moduleUid || !moduleUid.match(/^EP\d+$/)) {
     throw new Error(
@@ -5630,12 +5518,24 @@ Commit or stash your changes first, or use --force to discard them.`
       );
     }
   }
-  const currentPath = path12.resolve(process.cwd());
+  const currentPath = path11.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");
   }
+  const config = await (0, import_core12.loadConfig)();
+  const cleanupScript = config?.project_settings?.worktree_cleanup_script;
+  if (cleanupScript) {
+    status.info("Running cleanup script...");
+    const cleanupResult = await worktreeManager.runCleanupScript(moduleUid, cleanupScript);
+    if (!cleanupResult.success) {
+      status.warning(`Cleanup script failed: ${cleanupResult.error}`);
+      status.info("Continuing with worktree removal...");
+    } else {
+      status.success("\u2713 Cleanup script completed");
+    }
+  }
   status.info("Removing worktree...");
   const result = await worktreeManager.removeWorktree(moduleUid, options.force);
   if (!result.success) {
@@ -5644,7 +5544,6 @@ Commit or stash your changes first, or use --force to discard them.`
   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) {
@@ -5668,7 +5567,7 @@ Commit or stash your changes first, or use --force to discard them.`
   status.info("");
 }
 async function checkUncommittedChanges(worktreePath) {
-  const gitExecutor = new import_core13.GitExecutor();
+  const gitExecutor = new import_core12.GitExecutor();
   const result = await gitExecutor.execute(
     { action: "status" },
     { cwd: worktreePath }
@@ -5693,10 +5592,10 @@ async function updateModuleRelease(apiUrl, projectId, workspaceSlug, moduleUid,
 }
 
 // src/commands/list.ts
-var fs11 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
+var fs10 = __toESM(require("fs"));
+var path12 = __toESM(require("path"));
 var import_chalk2 = __toESM(require("chalk"));
-var import_core14 = __toESM(require_dist());
+var import_core13 = __toESM(require_dist());
 async function listCommand(subcommand, options = {}) {
   if (subcommand === "worktrees" || subcommand === "wt") {
     await listWorktrees(options);
@@ -5706,7 +5605,7 @@ async function listCommand(subcommand, options = {}) {
 }
 async function listProjects(options) {
   const episodaRoot = getEpisodaRoot();
-  if (!fs11.existsSync(episodaRoot)) {
+  if (!fs10.existsSync(episodaRoot)) {
     status.info("No projects cloned yet.");
     status.info("");
     status.info("Clone a project with:");
@@ -5714,12 +5613,12 @@ async function listProjects(options) {
     return;
   }
   const projects = [];
-  const workspaces = fs11.readdirSync(episodaRoot, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("."));
+  const workspaces = fs10.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("."));
+    const workspacePath = path12.join(episodaRoot, workspace.name);
+    const projectDirs = fs10.readdirSync(workspacePath, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("."));
     for (const projectDir of projectDirs) {
-      const projectPath = path13.join(workspacePath, projectDir.name);
+      const projectPath = path12.join(workspacePath, projectDir.name);
       if (await isWorktreeProject(projectPath)) {
         const manager = new WorktreeManager(projectPath);
         await manager.initialize();
@@ -5784,7 +5683,7 @@ async function listWorktrees(options) {
     status.info("  episoda checkout {moduleUid}");
     return;
   }
-  const gitExecutor = new import_core14.GitExecutor();
+  const gitExecutor = new import_core13.GitExecutor();
   for (const wt of worktrees) {
     console.log("");
     let statusIndicator = import_chalk2.default.green("\u25CF");
@@ -5821,7 +5720,7 @@ async function listWorktrees(options) {
 }
 
 // src/index.ts
-import_commander.program.name("episoda").description("Episoda local development workflow orchestration").version(import_core15.VERSION);
+import_commander.program.name("episoda").description("Episoda CLI - local development with git worktree isolation").version(import_core14.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);
@@ -5838,7 +5737,7 @@ import_commander.program.command("connect").description("Connect using a pre-aut
     process.exit(1);
   }
 });
-import_commander.program.command("dev").description("Start dev server with Episoda orchestration").option("--auto-restart", "Auto-restart dev server if it crashes").option("--connection-only", "Connection-only mode (don't start dev server)").allowUnknownOption().action(async (options, cmd) => {
+import_commander.program.command("dev").description("Connect to Episoda and start dev server").option("--auto-restart", "Auto-restart dev server if it crashes").option("--connection-only", "Connection-only mode (don't start dev server)").allowUnknownOption().action(async (options, cmd) => {
   try {
     const args = process.argv.slice(process.argv.indexOf("dev") + 1);
     const separatorIndex = args.indexOf("--");
@@ -5877,7 +5776,7 @@ 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) => {
+import_commander.program.command("clone").description("Clone a project 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) {
@@ -5909,14 +5808,6 @@ import_commander.program.command("list").description("List cloned projects and w
     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) {