gsd-pi 2.41.0 → 2.42.0-dev.1df898f

package/src/resources/extensions/gsd/auto-worktree.ts

@@ -25,12 +25,13 @@ import {
   isDbAvailable,
 } from "./gsd-db.js";
 import { atomicWriteSync } from "./atomic-write.js";
-import { execSync, execFileSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import { safeCopy, safeCopyRecursive } from "./safe-fs.js";
 import { gsdRoot } from "./paths.js";
 import {
   createWorktree,
   removeWorktree,
+  resolveGitDir,
   worktreePath,
 } from "./worktree-manager.js";
 import {
@@ -57,6 +58,8 @@ import {
   nativeBranchDelete,
   nativeBranchExists,
   nativeDiffNumstat,
+  nativeUpdateRef,
+  nativeIsAncestor,
 } from "./native-git-bridge.js";
 
 // ─── Module State ──────────────────────────────────────────────────────────
@@ -182,7 +185,7 @@ export function syncGsdStateToWorktree(
       const mainMilestones = readdirSync(mainMilestonesDir, {
         withFileTypes: true,
       })
-        .filter((d) => d.isDirectory() && /^M\d{3}/.test(d.name))
+        .filter((d) => d.isDirectory())
         .map((d) => d.name);
 
       for (const mid of mainMilestones) {
@@ -339,7 +342,7 @@ export function syncWorktreeStateBack(
 
   try {
     const wtMilestones = readdirSync(wtMilestonesDir, { withFileTypes: true })
-      .filter((d) => d.isDirectory() && /^M\d{3}/.test(d.name))
+      .filter((d) => d.isDirectory())
       .map((d) => d.name);
 
     for (const mid of wtMilestones) {
@@ -468,14 +471,22 @@ export function runWorktreePostCreateHook(
   }
   if (!hookPath) return null;
 
-  // Resolve relative paths against the source project root
-  const resolved = isAbsolute(hookPath) ? hookPath : join(sourceDir, hookPath);
+  // Resolve relative paths against the source project root.
+  // On Windows, convert 8.3 short paths (e.g. RUNNER~1) to long paths
+  // so execFileSync can locate the file correctly.
+  let resolved = isAbsolute(hookPath) ? hookPath : join(sourceDir, hookPath);
   if (!existsSync(resolved)) {
     return `Worktree post-create hook not found: ${resolved}`;
   }
+  if (process.platform === "win32") {
+    try { resolved = realpathSync.native(resolved); } catch { /* keep original */ }
+  }
 
   try {
-    execSync(resolved, {
+    // .bat/.cmd files on Windows require shell mode — execFileSync cannot
+    // spawn them directly (EINVAL).
+    const needsShell = process.platform === "win32" && /\.(bat|cmd)$/i.test(resolved);
+    execFileSync(resolved, [], {
       cwd: worktreeDir,
       env: {
         ...process.env,
@@ -485,6 +496,7 @@ export function runWorktreePostCreateHook(
       stdio: ["ignore", "pipe", "pipe"],
       encoding: "utf-8",
       timeout: 30_000, // 30 second timeout
+      shell: needsShell,
     });
     return null;
   } catch (err) {
@@ -761,6 +773,24 @@ export function teardownAutoWorktree(
     branch,
     deleteBranch: !preserveBranch,
   });
+
+  // Verify cleanup succeeded — warn if the worktree directory is still on disk.
+  // On Windows, bash-based cleanup can silently fail when paths contain
+  // backslashes (#1436), leaving ~1 GB+ orphaned directories.
+  const wtDir = worktreePath(originalBasePath, milestoneId);
+  if (existsSync(wtDir)) {
+    console.error(
+      `[GSD] WARNING: Worktree directory still exists after teardown: ${wtDir}\n` +
+        `  This is likely an orphaned directory consuming disk space.\n` +
+        `  Remove it manually with: rm -rf "${wtDir.replaceAll("\\", "/")}"`,
+    );
+    // Attempt a direct filesystem removal as a fallback
+    try {
+      rmSync(wtDir, { recursive: true, force: true });
+    } catch {
+      // Non-fatal — the warning above tells the user how to clean up
+    }
+  }
 }
 
 /**
@@ -940,7 +970,7 @@ export function mergeMilestoneToMain(
   originalBasePath_: string,
   milestoneId: string,
   roadmapContent: string,
-): { commitMessage: string; pushed: boolean; prCreated: boolean } {
+): { commitMessage: string; pushed: boolean; prCreated: boolean; codeFilesChanged: boolean } {
   const worktreeCwd = process.cwd();
   const milestoneBranch = autoWorktreeBranch(milestoneId);
 
@@ -1002,6 +1032,62 @@ export function mergeMilestoneToMain(
   }
   const commitMessage = subject + body;
 
+  // 6b. Reconcile worktree HEAD with milestone branch ref (#1846).
+  //     When the worktree HEAD detaches and advances past the named branch,
+  //     the branch ref becomes stale. Squash-merging the stale ref silently
+  //     orphans all commits between the branch ref and the actual worktree HEAD.
+  //     Fix: fast-forward the branch ref to the worktree HEAD before merging.
+  //     Only applies when merging from an actual worktree (worktreeCwd differs
+  //     from originalBasePath_).
+  if (worktreeCwd !== originalBasePath_) {
+    try {
+      const worktreeHead = execFileSync("git", ["rev-parse", "HEAD"], {
+        cwd: worktreeCwd,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+      }).trim();
+      const branchHead = execFileSync("git", ["rev-parse", milestoneBranch], {
+        cwd: originalBasePath_,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+      }).trim();
+
+      if (worktreeHead && branchHead && worktreeHead !== branchHead) {
+        if (nativeIsAncestor(originalBasePath_, branchHead, worktreeHead)) {
+          // Worktree HEAD is strictly ahead — fast-forward the branch ref
+          nativeUpdateRef(
+            originalBasePath_,
+            `refs/heads/${milestoneBranch}`,
+            worktreeHead,
+          );
+          debugLog("mergeMilestoneToMain", {
+            action: "fast-forward-branch-ref",
+            milestoneBranch,
+            oldRef: branchHead.slice(0, 8),
+            newRef: worktreeHead.slice(0, 8),
+          });
+        } else {
+          // Diverged — fail loudly rather than silently losing commits
+          process.chdir(previousCwd);
+          throw new GSDError(
+            GSD_GIT_ERROR,
+            `Worktree HEAD (${worktreeHead.slice(0, 8)}) diverged from ` +
+              `${milestoneBranch} (${branchHead.slice(0, 8)}). ` +
+              `Manual reconciliation required before merge.`,
+          );
+        }
+      }
+    } catch (err) {
+      // Re-throw GSDError (divergence); swallow rev-parse failures
+      // (e.g. worktree dir already removed by external cleanup)
+      if (err instanceof GSDError) throw err;
+      debugLog("mergeMilestoneToMain", {
+        action: "reconcile-skipped",
+        reason: String(err),
+      });
+    }
+  }
+
   // 7. Squash merge — auto-resolve .gsd/ state file conflicts (#530)
   const mergeResult = nativeMergeSquash(originalBasePath_, milestoneBranch);
 
@@ -1066,6 +1152,16 @@ export function mergeMilestoneToMain(
   const commitResult = nativeCommit(originalBasePath_, commitMessage);
   const nothingToCommit = commitResult === null;
 
+  // 8a. Clean up SQUASH_MSG left by git merge --squash (#1853).
+  // git only removes SQUASH_MSG when the commit reads it directly (plain
+  // `git commit`).  nativeCommit uses `-F -` (stdin) or libgit2, neither
+  // of which trigger git's SQUASH_MSG cleanup.  If left on disk, doctor
+  // reports `corrupt_merge_state` on every subsequent run.
+  try {
+    const squashMsgPath = join(resolveGitDir(originalBasePath_), "SQUASH_MSG");
+    if (existsSync(squashMsgPath)) unlinkSync(squashMsgPath);
+  } catch { /* best-effort */ }
+
   // 8b. Safety check (#1792): if nothing was committed, verify the milestone
   // work is already on the integration branch before allowing teardown.
   // Compare only non-.gsd/ paths — .gsd/ state files diverge normally and
@@ -1091,12 +1187,33 @@ export function mergeMilestoneToMain(
     }
   }
 
+  // 8c. Detect whether any non-.gsd/ code files were actually merged (#1906).
+  // When a milestone only produced .gsd/ metadata (summaries, roadmaps) but no
+  // real code, the user sees "milestone complete" but nothing changed in their
+  // codebase. Surface this so the caller can warn the user.
+  let codeFilesChanged = false;
+  if (!nothingToCommit) {
+    try {
+      const mergedFiles = nativeDiffNumstat(
+        originalBasePath_,
+        "HEAD~1",
+        "HEAD",
+      );
+      codeFilesChanged = mergedFiles.some(
+        (entry) => !entry.path.startsWith(".gsd/"),
+      );
+    } catch {
+      // If HEAD~1 doesn't exist (first commit), assume code was changed
+      codeFilesChanged = true;
+    }
+  }
+
   // 9. Auto-push if enabled
   let pushed = false;
   if (prefs.auto_push === true && !nothingToCommit) {
     const remote = prefs.remote ?? "origin";
     try {
-      execSync(`git push ${remote} ${mainBranch}`, {
+      execFileSync("git", ["push", remote, mainBranch], {
         cwd: originalBasePath_,
         stdio: ["ignore", "pipe", "pipe"],
         encoding: "utf-8",
@@ -1114,20 +1231,23 @@ export function mergeMilestoneToMain(
     const prTarget = prefs.pr_target_branch ?? mainBranch;
     try {
       // Push the milestone branch to remote first
-      execSync(`git push ${remote} ${milestoneBranch}`, {
+      execFileSync("git", ["push", remote, milestoneBranch], {
         cwd: originalBasePath_,
         stdio: ["ignore", "pipe", "pipe"],
         encoding: "utf-8",
       });
       // Create PR via gh CLI
-      execSync(
-        `gh pr create --base "${prTarget}" --head "${milestoneBranch}" --title "Milestone ${milestoneId} complete" --body "Auto-created by GSD on milestone completion."`,
-        {
-          cwd: originalBasePath_,
-          stdio: ["ignore", "pipe", "pipe"],
-          encoding: "utf-8",
-        },
-      );
+      execFileSync("gh", [
+        "pr", "create",
+        "--base", prTarget,
+        "--head", milestoneBranch,
+        "--title", `Milestone ${milestoneId} complete`,
+        "--body", "Auto-created by GSD on milestone completion.",
+      ], {
+        cwd: originalBasePath_,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+      });
       prCreated = true;
     } catch {
       // PR creation failure is non-fatal — gh may not be installed or authenticated
@@ -1138,6 +1258,30 @@ export function mergeMilestoneToMain(
   //     throws only when the milestone has unanchored code changes, passes
   //     through when the code is genuinely already on the integration branch.
 
+  // 10a. Pre-teardown safety net (#1853): if the worktree still has uncommitted
+  // changes (e.g. nativeHasChanges cache returned stale false, or auto-commit
+  // silently failed), force one final commit so code is not destroyed by
+  // `git worktree remove --force`.
+  if (existsSync(worktreeCwd)) {
+    try {
+      const dirtyCheck = nativeWorkingTreeStatus(worktreeCwd);
+      if (dirtyCheck) {
+        debugLog("mergeMilestoneToMain", {
+          phase: "pre-teardown-dirty",
+          worktreeCwd,
+          status: dirtyCheck.slice(0, 200),
+        });
+        nativeAddAllWithExclusions(worktreeCwd, RUNTIME_EXCLUSION_PATHS);
+        nativeCommit(worktreeCwd, "chore: pre-teardown auto-commit of uncommitted worktree changes");
+      }
+    } catch (e) {
+      debugLog("mergeMilestoneToMain", {
+        phase: "pre-teardown-commit-error",
+        error: String(e),
+      });
+    }
+  }
+
   // 11. Remove worktree directory first (must happen before branch deletion)
   try {
     removeWorktree(originalBasePath_, milestoneId, {
@@ -1159,5 +1303,5 @@ export function mergeMilestoneToMain(
   originalBase = null;
   nudgeGitBranchCache(previousCwd);
 
-  return { commitMessage, pushed, prCreated };
+  return { commitMessage, pushed, prCreated, codeFilesChanged };
 }

package/src/resources/extensions/gsd/auto.ts

@@ -167,7 +167,9 @@ import {
   buildLoopRemediationSteps,
   reconcileMergeState,
 } from "./auto-recovery.js";
-import { resolveDispatch } from "./auto-dispatch.js";
+import { resolveDispatch, DISPATCH_RULES } from "./auto-dispatch.js";
+import { initRegistry, convertDispatchRules } from "./rule-registry.js";
+import { emitJournalEvent as _emitJournalEvent, type JournalEntry } from "./journal.js";
 import {
   type AutoDashboardData,
   updateProgressWidget as _updateProgressWidget,
@@ -356,6 +358,22 @@ export function isAutoPaused(): boolean {
   return s.paused;
 }
 
+export function setActiveEngineId(id: string | null): void {
+  s.activeEngineId = id;
+}
+
+export function getActiveEngineId(): string | null {
+  return s.activeEngineId;
+}
+
+export function setActiveRunDir(runDir: string | null): void {
+  s.activeRunDir = runDir;
+}
+
+export function getActiveRunDir(): string | null {
+  return s.activeRunDir;
+}
+
 /**
  * Return the model captured at auto-mode start for this session.
  * Used by error-recovery to fall back to the session's own model
@@ -535,6 +553,33 @@ function handleLostSessionLock(
   ctx?.ui.setFooter(undefined);
 }
 
+/**
+ * Lightweight cleanup after autoLoop exits via step-wizard break.
+ *
+ * Unlike stopAuto (which tears down the entire session), this only clears
+ * the stale unit state, progress widget, status badge, and restores CWD so
+ * the dashboard does not show an orphaned timer and the shell is usable.
+ */
+function cleanupAfterLoopExit(ctx: ExtensionContext): void {
+  s.currentUnit = null;
+  s.active = false;
+  clearUnitTimeout();
+
+  ctx.ui.setStatus("gsd-auto", undefined);
+  ctx.ui.setWidget("gsd-progress", undefined);
+  ctx.ui.setFooter(undefined);
+
+  // Restore CWD out of worktree back to original project root
+  if (s.originalBasePath) {
+    s.basePath = s.originalBasePath;
+    try {
+      process.chdir(s.basePath);
+    } catch {
+      /* best-effort */
+    }
+  }
+}
+
 export async function stopAuto(
   ctx?: ExtensionContext,
   pi?: ExtensionAPI,
@@ -753,6 +798,8 @@ export async function pauseAuto(
       stepMode: s.stepMode,
       pausedAt: new Date().toISOString(),
       sessionFile: s.pausedSessionFile,
+      activeEngineId: s.activeEngineId,
+      activeRunDir: s.activeRunDir,
     };
     const runtimeDir = join(gsdRoot(s.originalBasePath || s.basePath), "runtime");
     mkdirSync(runtimeDir, { recursive: true });
@@ -849,6 +896,11 @@ function buildResolver(): WorktreeResolver {
  * This bundles all private functions that autoLoop needs without exporting them.
  */
 function buildLoopDeps(): LoopDeps {
+  // Initialize the unified rule registry with converted dispatch rules.
+  // Must happen before LoopDeps is assembled so facade functions
+  // (resolveDispatch, runPreDispatchHooks, etc.) delegate to the registry.
+  initRegistry(convertDispatchRules(DISPATCH_RULES));
+
   return {
     lockBase,
     buildSnapshotOpts,
@@ -959,6 +1011,9 @@ function buildLoopDeps(): LoopDeps {
         return "";
       }
     },
+
+    // Journal
+    emitJournalEvent: (entry: JournalEntry) => _emitJournalEvent(s.basePath, entry),
   } as unknown as LoopDeps;
 }
 
@@ -981,7 +1036,19 @@ export async function startAuto(
       const pausedPath = join(gsdRoot(base), "runtime", "paused-session.json");
       if (existsSync(pausedPath)) {
         const meta = JSON.parse(readFileSync(pausedPath, "utf-8"));
-        if (meta.milestoneId) {
+        if (meta.activeEngineId && meta.activeEngineId !== "dev") {
+          // Custom workflow resume — restore engine state
+          s.activeEngineId = meta.activeEngineId;
+          s.activeRunDir = meta.activeRunDir ?? null;
+          s.originalBasePath = meta.originalBasePath || base;
+          s.stepMode = meta.stepMode ?? requestedStepMode;
+          s.paused = true;
+          try { unlinkSync(pausedPath); } catch { /* non-fatal */ }
+          ctx.ui.notify(
+            `Resuming paused custom workflow${meta.activeRunDir ? ` (${meta.activeRunDir})` : ""}.`,
+            "info",
+          );
+        } else if (meta.milestoneId) {
           // Validate the milestone still exists and isn't already complete (#1664).
           const mDir = resolveMilestonePath(base, meta.milestoneId);
           const summaryFile = resolveMilestoneFile(base, meta.milestoneId, "SUMMARY");
@@ -1121,6 +1188,7 @@ export async function startAuto(
     await selfHealRuntimeRecords(s.basePath, ctx);
 
     await autoLoop(ctx, pi, s, buildLoopDeps());
+    cleanupAfterLoopExit(ctx);
     return;
   }
 
@@ -1155,6 +1223,7 @@ export async function startAuto(
 
   // Dispatch the first unit
   await autoLoop(ctx, pi, s, buildLoopDeps());
+  cleanupAfterLoopExit(ctx);
 }
 
 // ─── Agent End Handler ────────────────────────────────────────────────────────