gsd-pi 2.80.0-dev.4ea7d80e7 → 2.80.0-dev.7582bf37a

package/dist/resources/extensions/gsd/worktree-manager.js

@@ -22,6 +22,16 @@ import { logWarning } from "./workflow-logger.js";
 import { nativeBranchDelete, nativeBranchExists, nativeBranchForceReset, nativeCommit, nativeDetectMainBranch, nativeDiffContent, nativeDiffNameStatus, nativeDiffNumstat, nativeGetCurrentBranch, nativeIsAncestor, nativeLogOneline, nativeMergeSquash, nativeWorktreeAdd, nativeWorktreeList, nativeWorktreePrune, nativeWorktreeRemove, } from "./native-git-bridge.js";
 import { emitCanonicalRootRedirect } from "./worktree-telemetry.js";
 import { isGsdWorktreePath, normalizeWorktreePathForCompare, resolveWorktreeProjectRoot, } from "./worktree-root.js";
+function deleteBranchIfPresent(basePath, branch, warningPrefix) {
+    try {
+        if (!nativeBranchExists(basePath, branch))
+            return;
+        nativeBranchDelete(basePath, branch, true);
+    }
+    catch (e) {
+        logWarning("worktree", `${warningPrefix}: ${e.message}`);
+    }
+}
 // ─── Path Helpers ──────────────────────────────────────────────────────────
 function normalizePathForComparison(path) {
     const normalized = path
@@ -311,7 +321,7 @@ export function listWorktrees(basePath) {
 // of their object database, causing permanent silent data loss.
 /** Directories to skip when scanning for nested .git dirs. */
 const NESTED_GIT_SKIP_DIRS = new Set([
-    ".git", ".gsd", "node_modules", ".next", ".nuxt", "dist", "build",
+    ".git", ".gsd", ".bg-shell", "node_modules", ".next", ".nuxt", "dist", "build",
     "__pycache__", ".tox", ".venv", "venv", "target", "vendor",
 ]);
 /**
@@ -364,7 +374,9 @@ export function findNestedGitDirs(rootPath) {
                 }
             }
             catch (e) {
-                logWarning("worktree", `existsSync/.git check failed for ${fullPath}: ${e.message}`);
+                if (e.code !== "ENOENT") {
+                    logWarning("worktree", `existsSync/.git check failed for ${fullPath}: ${e.message}`);
+                }
             }
             walk(fullPath, depth + 1);
         }
@@ -430,12 +442,7 @@ export function removeWorktree(basePath, name, opts = {}) {
     if (!existsSync(wtPath)) {
         nativeWorktreePrune(basePath);
         if (deleteBranch) {
-            try {
-                nativeBranchDelete(basePath, branch, true);
-            }
-            catch (e) {
-                logWarning("worktree", `nativeBranchDelete failed: ${e.message}`);
-            }
+            deleteBranchIfPresent(basePath, branch, "nativeBranchDelete failed");
         }
         return;
     }
@@ -549,12 +556,7 @@ export function removeWorktree(basePath, name, opts = {}) {
     // Prune stale entries so git knows the worktree is gone
     nativeWorktreePrune(basePath);
     if (deleteBranch) {
-        try {
-            nativeBranchDelete(basePath, branch, true);
-        }
-        catch (e) {
-            logWarning("worktree", `final branch delete failed: ${e.message}`);
-        }
+        deleteBranchIfPresent(basePath, branch, "final branch delete failed");
     }
 }
 /**

package/dist/resources/extensions/gsd/worktree-resolver.js

@@ -22,7 +22,7 @@ import { emitWorktreeCreated, emitWorktreeMerged } from "./worktree-telemetry.js
 import { getCollapseCadence, getMilestoneResquash, resquashMilestoneOnMain } from "./slice-cadence.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { resolveWorktreeProjectRoot, normalizeWorktreePathForCompare } from "./worktree-root.js";
-import { claimMilestoneLease, releaseMilestoneLease } from "./db/milestone-leases.js";
+import { claimMilestoneLease, refreshMilestoneLease, releaseMilestoneLease } from "./db/milestone-leases.js";
 // ─── Path Comparison Helper ────────────────────────────────────────────────
 /**
  * Compare two paths for physical identity, tolerating trailing slashes,
@@ -35,6 +35,14 @@ import { claimMilestoneLease, releaseMilestoneLease } from "./db/milestone-lease
 function isSamePath(a, b) {
     return normalizeWorktreePathForCompare(a) === normalizeWorktreePathForCompare(b);
 }
+class UserNotifiedError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.name = "UserNotifiedError";
+        this.cause = cause;
+    }
+}
 // ─── Path Helpers ──────────────────────────────────────────────────────────
 /**
  * Resolve the project root from session path state.
@@ -119,24 +127,40 @@ export class WorktreeResolver {
         // milestone (re-entry within the same session).
         if (this.s.workerId) {
             if (this.s.currentMilestoneId === milestoneId && this.s.milestoneLeaseToken !== null) {
-                // Already held — no-op, the heartbeat in loop.ts refreshes TTL.
-            }
-            else {
-                // If we held a different milestone, release it first so other
-                // workers don't have to wait for TTL.
-                if (this.s.currentMilestoneId && this.s.currentMilestoneId !== milestoneId && this.s.milestoneLeaseToken !== null) {
-                    try {
-                        releaseMilestoneLease(this.s.workerId, this.s.currentMilestoneId, this.s.milestoneLeaseToken);
-                    }
-                    catch (err) {
-                        debugLog("WorktreeResolver", {
-                            action: "enterMilestone",
-                            milestoneId,
-                            releasePriorLeaseError: err instanceof Error ? err.message : String(err),
-                        });
-                    }
+                const refreshed = refreshMilestoneLease(this.s.workerId, milestoneId, this.s.milestoneLeaseToken);
+                if (refreshed) {
+                    debugLog("WorktreeResolver", {
+                        action: "enterMilestone",
+                        milestoneId,
+                        leaseRefreshed: true,
+                        fencingToken: this.s.milestoneLeaseToken,
+                    });
+                }
+                else {
+                    debugLog("WorktreeResolver", {
+                        action: "enterMilestone",
+                        milestoneId,
+                        staleLeaseToken: this.s.milestoneLeaseToken,
+                    });
                     this.s.milestoneLeaseToken = null;
                 }
+            }
+            // If we held a different milestone, release it first so other
+            // workers don't have to wait for TTL.
+            if (this.s.currentMilestoneId && this.s.currentMilestoneId !== milestoneId && this.s.milestoneLeaseToken !== null) {
+                try {
+                    releaseMilestoneLease(this.s.workerId, this.s.currentMilestoneId, this.s.milestoneLeaseToken);
+                }
+                catch (err) {
+                    debugLog("WorktreeResolver", {
+                        action: "enterMilestone",
+                        milestoneId,
+                        releasePriorLeaseError: err instanceof Error ? err.message : String(err),
+                    });
+                }
+                this.s.milestoneLeaseToken = null;
+            }
+            if (this.s.milestoneLeaseToken === null) {
                 try {
                     const claim = claimMilestoneLease(this.s.workerId, milestoneId);
                     if (claim.ok) {
@@ -336,19 +360,38 @@ export class WorktreeResolver {
                 phase: "auto-commit-failed",
                 error: err instanceof Error ? err.message : String(err),
             });
+            ctx.notify(`Auto-commit before exiting ${milestoneId} failed: ${err instanceof Error ? err.message : String(err)}. Branch ${this.deps.autoWorktreeBranch(milestoneId)} is preserved for recovery.`, "warning");
         }
+        if (this.s.originalBasePath) {
+            try {
+                process.chdir(this.s.originalBasePath);
+            }
+            catch (err) {
+                debugLog("WorktreeResolver", {
+                    action: "exitMilestone",
+                    milestoneId,
+                    phase: "pre-teardown-chdir-failed",
+                    originalBasePath: this.s.originalBasePath,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                ctx.notify(`Could not leave milestone worktree before cleanup: ${err instanceof Error ? err.message : String(err)}. Branch ${this.deps.autoWorktreeBranch(milestoneId)} is preserved for recovery.`, "warning");
+            }
+        }
+        let teardownFailed = false;
         try {
             this.deps.teardownAutoWorktree(this.s.originalBasePath, milestoneId, {
                 preserveBranch: opts?.preserveBranch ?? false,
             });
         }
         catch (err) {
+            teardownFailed = true;
             debugLog("WorktreeResolver", {
                 action: "exitMilestone",
                 milestoneId,
                 phase: "teardown-failed",
                 error: err instanceof Error ? err.message : String(err),
             });
+            ctx.notify(`Worktree cleanup failed for ${milestoneId}: ${err instanceof Error ? err.message : String(err)}. Branch ${this.deps.autoWorktreeBranch(milestoneId)} is preserved for recovery.`, "warning");
         }
         this.restoreToProjectRoot();
         debugLog("WorktreeResolver", {
@@ -357,7 +400,9 @@ export class WorktreeResolver {
             result: "done",
             basePath: this.s.basePath,
         });
-        ctx.notify(`Exited worktree for ${milestoneId}`, "info");
+        ctx.notify(teardownFailed
+            ? `Worktree exit for ${milestoneId} needs manual cleanup.`
+            : `Exited worktree for ${milestoneId}`, teardownFailed ? "warning" : "info");
     }
     // ── Merge and Exit ─────────────────────────────────────────────────────
     /**
@@ -647,16 +692,35 @@ export class WorktreeResolver {
             const currentBranch = this.deps.getCurrentBranch(this.s.basePath);
             const milestoneBranch = this.deps.autoWorktreeBranch(milestoneId);
             if (currentBranch !== milestoneBranch) {
+                // #5538-followup: previous behavior was to silently `return false`
+                // when HEAD wasn't on the milestone branch — that let the loop
+                // advance with the milestone's commits stranded on the branch (the
+                // exact failure mode reported in the test12345 repro). Attempt
+                // recovery by force-checking-out the milestone branch; if the
+                // checkout fails, throw so the caller pauses auto-mode and the user
+                // sees the failure instead of a silent merge skip.
                 debugLog("WorktreeResolver", {
                     action: "mergeAndExit",
                     milestoneId,
                     mode: "branch",
-                    skipped: true,
-                    reason: "not-on-milestone-branch",
+                    recovery: "checkout-milestone-branch",
                     currentBranch,
                     milestoneBranch,
                 });
-                return false;
+                try {
+                    this.deps.checkoutBranch(this.s.basePath, milestoneBranch);
+                }
+                catch (checkoutErr) {
+                    const checkoutMsg = checkoutErr instanceof Error ? checkoutErr.message : String(checkoutErr);
+                    ctx.notify(`Cannot merge milestone ${milestoneId}: working tree is on ${currentBranch} and checkout to ${milestoneBranch} failed (${checkoutMsg}). Resolve manually and run /gsd auto to resume.`, "error");
+                    throw new UserNotifiedError(checkoutMsg, checkoutErr);
+                }
+                const reverify = this.deps.getCurrentBranch(this.s.basePath);
+                if (reverify !== milestoneBranch) {
+                    const reverifyMsg = `branch checkout to ${milestoneBranch} reported success but current branch is ${reverify}`;
+                    ctx.notify(`Cannot merge milestone ${milestoneId}: ${reverifyMsg}. Resolve manually and run /gsd auto to resume.`, "error");
+                    throw new UserNotifiedError(reverifyMsg);
+                }
             }
             const roadmapPath = this.deps.resolveMilestoneFile(this.s.basePath, milestoneId, "ROADMAP");
             if (!roadmapPath) {
@@ -697,7 +761,9 @@ export class WorktreeResolver {
                 result: "error",
                 error: msg,
             });
-            ctx.notify(`Milestone merge failed (branch mode): ${msg}`, "warning");
+            if (!(err instanceof UserNotifiedError)) {
+                ctx.notify(`Milestone merge failed (branch mode): ${msg}`, "warning");
+            }
             // Re-throw all errors so callers can apply their own recovery logic (#4380).
             throw err;
         }
@@ -720,6 +786,8 @@ export class WorktreeResolver {
             this.mergeAndExit(currentMilestoneId, ctx);
         }
         catch (err) {
+            if (err instanceof UserNotifiedError)
+                throw err;
             // mergeAndExit emits a warning and restores state when it fails during
             // merge/cleanup. But if it throws before recovery runs (e.g., in
             // validateMilestoneId or emitJournalEvent), basePath won't be restored