claude-tempo 0.29.0 → 0.29.1

package/dashboard/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-tempo-dashboard",
   "private": true,
-  "version": "0.29.0",
+  "version": "0.29.1",
   "type": "module",
   "description": "Web dashboard for claude-tempo. Bundled into the npm package; served by the daemon at /dashboard/*.",
   "scripts": {

package/dist/tools/worktree.js

@@ -41,7 +41,7 @@ const helpers_1 = require("./helpers");
 const worktree_1 = require("../utils/worktree");
 const validation_1 = require("../utils/validation");
 function registerWorktreeTool(server, client, config, handle, getPlayerId) {
-    (0, helpers_1.defineTool)(server, 'worktree', 'Manage git worktrees for player isolation. Conductor only. Actions: create (provision worktree for a player), remove (clean up), list (show active worktrees). Use when multiple players commit to different branches of the same repo simultaneously; skip for read-only work, sequential work, or tasks under ~5 min. See docs/orchestration.md#when-to-use-worktrees.', {
+    (0, helpers_1.defineTool)(server, 'worktree', 'Manage git worktrees for player isolation. Conductor only. Actions: create (provision worktree for a player), remove (clean up), list (show active worktrees). Use when multiple players commit to different branches of the same repo simultaneously; skip for read-only work, sequential work, or tasks under ~5 min. IMPORTANT: before `remove`, have the player stop any long-running processes inside the worktree (dev servers, file watchers) — on Windows a memory-mapped native module will block directory removal and `remove` will fail. See docs/orchestration.md#when-to-use-worktrees.', {
         action: zod_1.z.enum(['create', 'remove', 'list']).describe('Action to perform'),
         player: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).optional().describe('Player name (required for create/remove)'),
         branch: zod_1.z.string().optional().describe('Git branch for the worktree (defaults to {ensemble}/{player-name})'),
@@ -132,9 +132,22 @@ function registerWorktreeTool(server, client, config, handle, getPlayerId) {
                     if (!entry) {
                         return (0, helpers_1.fail)(`No worktree found for player "${player}".`);
                     }
-                    // Remove from disk
-                    (0, worktree_1.removeWorktree)(entry.path);
-                    // Remove from conductor state
+                    // Remove from disk. #594: removeWorktree throws if the directory
+                    // survives the removal (Windows file-lock half-removal). We must
+                    // NOT signal `removeWorktree` state or cue the player until disk
+                    // removal is confirmed — otherwise Temporal state records "no
+                    // worktree" while a locked orphan directory remains on disk, and
+                    // the next `create` fails with a confusing git fatal.
+                    try {
+                        (0, worktree_1.removeWorktree)(entry.path, entry.gitRoot);
+                    }
+                    catch (err) {
+                        return (0, helpers_1.fail)(`Worktree for **${player}** could not be removed: ${(0, helpers_1.formatError)(err)}\n\n` +
+                            `Conductor state is unchanged — the worktree is still tracked. ` +
+                            `Have the player stop any long-running processes inside the worktree ` +
+                            `(dev servers, file watchers), then retry \`worktree remove\`.`);
+                    }
+                    // Remove from conductor state (only reached on confirmed disk removal)
                     await handle.signal('removeWorktree', player);
                     // Auto-cue the player
                     try {

package/dist/utils/worktree.d.ts

@@ -82,5 +82,22 @@ export declare function createWorktree(opts: CreateWorktreeOpts): CreateWorktree
 export declare function installDependencies(worktreePath: string, timeoutMs?: number): void;
 /**
  * Remove a git worktree.
+ *
+ * Throws if the worktree directory survives the removal (#594). On Windows,
+ * `git worktree remove --force` deletes `.git/worktrees/<name>` metadata
+ * *first*, then `rmdir`s the directory — so when a native `.node` module
+ * inside the worktree is memory-mapped by a live process, the directory
+ * deletion fails while the metadata is already gone. The pre-#594 code
+ * swallowed that failure (log-only, no throw), so the caller reported
+ * success and Temporal state diverged from disk. Now the post-removal
+ * `existsSync` check turns a half-removal into a hard error the caller can
+ * surface.
+ *
+ * `gitRoot` scopes the `git worktree remove` invocation to the owning
+ * repository. Pre-#594 the command ran with no `cwd`, so it only worked when
+ * `process.cwd()` happened to be the right repo — fragile, and wrong outright
+ * when the conductor's cwd is a different checkout than the worktree's repo.
+ * Callers should pass `entry.gitRoot` from the `WorktreeEntry`; it defaults to
+ * `process.cwd()` for backward compatibility.
  */
-export declare function removeWorktree(worktreePath: string): void;
+export declare function removeWorktree(worktreePath: string, gitRoot?: string): void;

package/dist/utils/worktree.js

@@ -165,6 +165,42 @@ function createWorktree(opts) {
         const switched = switchWorktreeToBranch(wtPath, branch);
         return { path: wtPath, branch, created: false, switched };
     }
+    // #594 defect 2: stale-orphan recovery. A half-removed worktree leaves the
+    // directory on disk with its `.git` file already deleted (`git worktree
+    // remove` deletes metadata before the rmdir, which then fails under a
+    // Windows file lock). The reuse guard above keys on `.git` presence, so it
+    // is skipped — and `git worktree add` below refuses a non-empty pre-existing
+    // directory with a confusing `fatal: '...' already exists`. Detect the
+    // orphan and clear it first, with a clear error if the lock is still held.
+    if ((0, fs_1.existsSync)(wtPath)) {
+        log(`Stale worktree directory at "${wtPath}" (no \`.git\`) — attempting cleanup`);
+        try {
+            (0, fs_1.rmSync)(wtPath, { recursive: true, force: true });
+        }
+        catch (err) {
+            // Swallow — the existsSync re-check below is the authoritative gate.
+            log(`Warning: \`rmSync\` on stale worktree "${wtPath}" failed: ${err?.message ?? err}`);
+        }
+        if ((0, fs_1.existsSync)(wtPath)) {
+            throw new Error(`Stale worktree directory at "${wtPath}" could not be removed — kill any ` +
+                `processes running inside it (e.g. a dev server) and retry. On Windows, ` +
+                `memory-mapped native \`.node\` modules hold the lock until the owning ` +
+                `process exits.`);
+        }
+        // Directory cleared — prune any dangling git metadata so `git worktree add`
+        // doesn't trip over a stale registration for the same path/branch.
+        try {
+            (0, child_process_1.execFileSync)('git', ['worktree', 'prune'], {
+                cwd: gitRoot,
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+        }
+        catch {
+            // Best-effort — prune failure is non-fatal; the add below will surface
+            // any real conflict.
+        }
+    }
     // Ensure base directory exists
     (0, fs_1.mkdirSync)(basePath, { recursive: true });
     // Check if the branch already has a worktree (would cause git error)
@@ -246,17 +282,46 @@ function installDependencies(worktreePath, timeoutMs = validation_1.WORKTREE_INS
 }
 /**
  * Remove a git worktree.
+ *
+ * Throws if the worktree directory survives the removal (#594). On Windows,
+ * `git worktree remove --force` deletes `.git/worktrees/<name>` metadata
+ * *first*, then `rmdir`s the directory — so when a native `.node` module
+ * inside the worktree is memory-mapped by a live process, the directory
+ * deletion fails while the metadata is already gone. The pre-#594 code
+ * swallowed that failure (log-only, no throw), so the caller reported
+ * success and Temporal state diverged from disk. Now the post-removal
+ * `existsSync` check turns a half-removal into a hard error the caller can
+ * surface.
+ *
+ * `gitRoot` scopes the `git worktree remove` invocation to the owning
+ * repository. Pre-#594 the command ran with no `cwd`, so it only worked when
+ * `process.cwd()` happened to be the right repo — fragile, and wrong outright
+ * when the conductor's cwd is a different checkout than the worktree's repo.
+ * Callers should pass `entry.gitRoot` from the `WorktreeEntry`; it defaults to
+ * `process.cwd()` for backward compatibility.
  */
-function removeWorktree(worktreePath) {
+function removeWorktree(worktreePath, gitRoot = process.cwd()) {
     try {
         (0, child_process_1.execFileSync)('git', ['worktree', 'remove', '--force', worktreePath], {
+            cwd: gitRoot,
             encoding: 'utf8',
             stdio: ['pipe', 'pipe', 'pipe'],
         });
-        log(`Removed worktree at "${worktreePath}"`);
     }
     catch (err) {
         const msg = err.stderr || err.message || String(err);
-        log(`Warning: failed to remove worktree at "${worktreePath}": ${msg.trim()}`);
+        log(`Warning: \`git worktree remove\` failed at "${worktreePath}": ${msg.trim()}`);
+        // Don't return here — fall through to the post-removal check. git may have
+        // deleted the metadata but failed the rmdir; the existsSync gate below is
+        // the real success criterion.
+    }
+    // #594 defect 1: post-removal verification. If the directory is still on
+    // disk, the removal half-succeeded — surface it instead of returning void.
+    if ((0, fs_1.existsSync)(worktreePath)) {
+        throw new Error(`Worktree directory "${worktreePath}" still exists after \`git worktree remove\`. ` +
+            `On Windows this usually means a process is holding a file lock — e.g. a dev ` +
+            `server with a memory-mapped native \`.node\` module. Stop any processes running ` +
+            `inside the worktree and retry.`);
     }
+    log(`Removed worktree at "${worktreePath}"`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-tempo",
-  "version": "0.29.0",
+  "version": "0.29.1",
   "description": "MCP server for multi-session Claude Code coordination via Temporal",
   "keywords": [
     "mcp",