gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

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

@@ -20,9 +20,10 @@ import {
 import { isAbsolute, join } from "node:path";
 import { GSDError, GSD_IO_ERROR, GSD_GIT_ERROR } from "./errors.js";
 import {
-  copyWorktreeDb,
   reconcileWorktreeDb,
   isDbAvailable,
+  getMilestone,
+  getMilestoneSlices,
 } from "./gsd-db.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { execFileSync } from "node:child_process";
@@ -41,7 +42,6 @@ import {
 } from "./worktree.js";
 import { MergeConflictError, readIntegrationBranch, RUNTIME_EXCLUSION_PATHS } from "./git-service.js";
 import { debugLog } from "./debug-logger.js";
-import { parseRoadmap } from "./files.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import {
   nativeGetCurrentBranch,
@@ -306,6 +306,22 @@ export function syncWorktreeStateBack(
 
   if (!existsSync(wtGsd) || !existsSync(mainGsd)) return { synced };
 
+  // ── 0. Pre-upgrade worktree DB reconciliation ────────────────────────
+  // If the worktree has its own gsd.db (copied before the WAL transition),
+  // reconcile its hierarchy data into the project root DB before syncing
+  // files. This handles in-flight worktrees that were created before the
+  // upgrade to shared WAL mode.
+  const wtLocalDb = join(wtGsd, "gsd.db");
+  const mainDb = join(mainGsd, "gsd.db");
+  if (existsSync(wtLocalDb) && existsSync(mainDb)) {
+    try {
+      reconcileWorktreeDb(mainDb, wtLocalDb);
+      synced.push("gsd.db (pre-upgrade reconcile)");
+    } catch {
+      // Non-fatal — file sync below is the fallback
+    }
+  }
+
   // ── 1. Sync root-level .gsd/ files back ──────────────────────────────
   // The worktree is authoritative — complete-milestone updates REQUIREMENTS,
   // PROJECT, etc. These must overwrite main's copies so they survive teardown.
@@ -733,16 +749,11 @@ function copyPlanningArtifacts(srcBase: string, wtPath: string): void {
     safeCopy(join(srcGsd, file), join(dstGsd, file), { force: true });
   }
 
-  // Copy gsd.db if present in source
-  const srcDb = join(srcGsd, "gsd.db");
-  const destDb = join(dstGsd, "gsd.db");
-  if (existsSync(srcDb)) {
-    try {
-      copyWorktreeDb(srcDb, destDb);
-    } catch {
-      /* non-fatal */
-    }
-  }
+  // Shared WAL (R012): worktrees use the project root's DB directly.
+  // No longer copy gsd.db into the worktree — the DB path resolver in
+  // ensureDbOpen() detects the worktree location and opens the root DB.
+  // Compat note: reconcileWorktreeDb() in mergeMilestoneToMain handles
+  // worktrees that already have a local gsd.db from before this change.
 }
 
 /**
@@ -988,9 +999,21 @@ export function mergeMilestoneToMain(
     }
   }
 
-  // 2. Parse roadmap for slice listing
-  const roadmap = parseRoadmap(roadmapContent);
-  const completedSlices = roadmap.slices.filter((s) => s.done);
+  // 2. Get completed slices for commit message
+  let completedSlices: { id: string; title: string }[] = [];
+  if (isDbAvailable()) {
+    completedSlices = getMilestoneSlices(milestoneId)
+      .filter(s => s.status === "complete")
+      .map(s => ({ id: s.id, title: s.title }));
+  }
+  // Fallback: parse roadmap content when DB is unavailable
+  if (completedSlices.length === 0 && roadmapContent) {
+    const sliceRe = /- \[x\] \*\*(\w+):\s*(.+?)\*\*/gi;
+    let m: RegExpExecArray | null;
+    while ((m = sliceRe.exec(roadmapContent)) !== null) {
+      completedSlices.push({ id: m[1], title: m[2] });
+    }
+  }
 
   // 3. chdir to original base
   const previousCwd = process.cwd();
@@ -1020,8 +1043,15 @@ export function mergeMilestoneToMain(
   }
 
   // 6. Build rich commit message
-  const milestoneTitle =
-    roadmap.title.replace(/^M\d+:\s*/, "").trim() || milestoneId;
+  const dbMilestone = getMilestone(milestoneId);
+  let milestoneTitle =
+    (dbMilestone?.title ?? "").replace(/^M\d+:\s*/, "").trim();
+  // Fallback: parse title from roadmap content header (e.g. "# M020: Backend foundation")
+  if (!milestoneTitle && roadmapContent) {
+    const titleMatch = roadmapContent.match(new RegExp(`^#\\s+${milestoneId}:\\s*(.+)`, "m"));
+    if (titleMatch) milestoneTitle = titleMatch[1].trim();
+  }
+  milestoneTitle = milestoneTitle || milestoneId;
   const subject = `feat(${milestoneId}): ${milestoneTitle}`;
   let body = "";
   if (completedSlices.length > 0) {
@@ -1088,7 +1118,32 @@ export function mergeMilestoneToMain(
     }
   }
 
-  // 7. Squash merge — auto-resolve .gsd/ state file conflicts (#530)
+  // 7. Stash any pre-existing dirty files so the squash merge is not
+  //    blocked by unrelated local changes (#2151).  clearProjectRootStateFiles
+  //    only removes untracked .gsd/ files; tracked dirty files elsewhere (e.g.
+  //    .planning/work-state.json with stash conflict markers) are invisible to
+  //    that cleanup but will cause `git merge --squash` to reject.
+  let stashed = false;
+  try {
+    const status = execFileSync("git", ["status", "--porcelain"], {
+      cwd: originalBasePath_,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+    }).trim();
+    if (status) {
+      execFileSync(
+        "git",
+        ["stash", "push", "--include-untracked", "-m", `gsd: pre-merge stash for ${milestoneId}`],
+        { cwd: originalBasePath_, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" },
+      );
+      stashed = true;
+    }
+  } catch {
+    // Stash failure is non-fatal — proceed without stash and let the merge
+    // report the dirty tree if it fails.
+  }
+
+  // 8. Squash merge — auto-resolve .gsd/ state file conflicts (#530)
   const mergeResult = nativeMergeSquash(originalBasePath_, milestoneBranch);
 
   if (!mergeResult.success) {
@@ -1096,12 +1151,27 @@ export function mergeMilestoneToMain(
     // untracked .gsd/ files left by syncStateToProjectRoot).  Preserve the
     // milestone branch so commits are not lost.
     if (mergeResult.conflicts.includes("__dirty_working_tree__")) {
+      // Pop stash before throwing so local work is not lost.
+      if (stashed) {
+        try {
+          execFileSync("git", ["stash", "pop"], {
+            cwd: originalBasePath_,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+          });
+        } catch { /* stash pop conflict is non-fatal */ }
+      }
       // Restore cwd so the caller is not stranded on the integration branch
       process.chdir(previousCwd);
+      // Surface the actual dirty filenames from git stderr instead of
+      // generically blaming .gsd/ (#2151).
+      const fileList = mergeResult.dirtyFiles?.length
+        ? `Dirty files:\n${mergeResult.dirtyFiles.map((f) => `  ${f}`).join("\n")}`
+        : `Check \`git status\` in the project root for details.`;
       throw new GSDError(
         GSD_GIT_ERROR,
-        `Squash merge of ${milestoneBranch} rejected: working tree has dirty or untracked files that conflict with the merge. ` +
-          `Clean the project root .gsd/ directory and retry.`,
+        `Squash merge of ${milestoneBranch} rejected: working tree has dirty or untracked files ` +
+          `that conflict with the merge. ${fileList}`,
       );
     }
 
@@ -1137,6 +1207,16 @@ export function mergeMilestoneToMain(
 
       // If there are still non-.gsd conflicts, escalate
       if (codeConflicts.length > 0) {
+        // Pop stash before throwing so local work is not lost (#2151).
+        if (stashed) {
+          try {
+            execFileSync("git", ["stash", "pop"], {
+              cwd: originalBasePath_,
+              stdio: ["ignore", "pipe", "pipe"],
+              encoding: "utf-8",
+            });
+          } catch { /* stash pop conflict is non-fatal */ }
+        }
         throw new MergeConflictError(
           codeConflicts,
           "squash",
@@ -1148,11 +1228,11 @@ export function mergeMilestoneToMain(
     // No conflicts detected — possibly "already up to date", fall through to commit
   }
 
-  // 8. Commit (handle nothing-to-commit gracefully)
+  // 9. Commit (handle nothing-to-commit gracefully)
   const commitResult = nativeCommit(originalBasePath_, commitMessage);
   const nothingToCommit = commitResult === null;
 
-  // 8a. Clean up SQUASH_MSG left by git merge --squash (#1853).
+  // 9a. 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
@@ -1162,7 +1242,23 @@ export function mergeMilestoneToMain(
     if (existsSync(squashMsgPath)) unlinkSync(squashMsgPath);
   } catch { /* best-effort */ }
 
-  // 8b. Safety check (#1792): if nothing was committed, verify the milestone
+  // 9a-ii. Restore stashed files now that the merge+commit is complete (#2151).
+  // Pop after commit so stashed changes do not interfere with the squash merge
+  // or the commit content.  Conflict on pop is non-fatal — the stash entry is
+  // preserved and the user can resolve manually with `git stash pop`.
+  if (stashed) {
+    try {
+      execFileSync("git", ["stash", "pop"], {
+        cwd: originalBasePath_,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+      });
+    } catch {
+      // Stash pop conflict is non-fatal — stash entry persists for manual resolution.
+    }
+  }
+
+  // 9b. 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
   // are auto-resolved during the squash merge.
@@ -1187,7 +1283,7 @@ export function mergeMilestoneToMain(
     }
   }
 
-  // 8c. Detect whether any non-.gsd/ code files were actually merged (#1906).
+  // 9c. 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.
@@ -1208,7 +1304,7 @@ export function mergeMilestoneToMain(
     }
   }
 
-  // 9. Auto-push if enabled
+  // 10. Auto-push if enabled
   let pushed = false;
   if (prefs.auto_push === true && !nothingToCommit) {
     const remote = prefs.remote ?? "origin";
@@ -1254,11 +1350,11 @@ export function mergeMilestoneToMain(
     }
   }
 
-  // 10. Guard removed — step 8b (#1792) now handles this with a smarter check:
+  // 11. Guard removed — step 9b (#1792) now handles this with a smarter check:
   //     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
+  // 11a. 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`.
@@ -1282,7 +1378,7 @@ export function mergeMilestoneToMain(
     }
   }
 
-  // 11. Remove worktree directory first (must happen before branch deletion)
+  // 12. Remove worktree directory first (must happen before branch deletion)
   try {
     removeWorktree(originalBasePath_, milestoneId, {
       branch: null as unknown as string,
@@ -1292,14 +1388,14 @@ export function mergeMilestoneToMain(
     // Best-effort -- worktree dir may already be gone
   }
 
-  // 12. Delete milestone branch (after worktree removal so ref is unlocked)
+  // 13. Delete milestone branch (after worktree removal so ref is unlocked)
   try {
     nativeBranchDelete(originalBasePath_, milestoneBranch);
   } catch {
     // Best-effort
   }
 
-  // 13. Clear module state
+  // 14. Clear module state
   originalBase = null;
   nudgeGitBranchCache(previousCwd);
 

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

@@ -79,10 +79,6 @@ import {
   getOldestInFlightToolStart,
   clearInFlightTools,
 } from "./auto-tool-tracking.js";
-import {
-  collectObservabilityWarnings as _collectObservabilityWarnings,
-  buildObservabilityRepairBlock,
-} from "./auto-observability.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { recoverTimedOutUnit } from "./auto-timeout-recovery.js";
 import { selfHealRuntimeRecords } from "./auto-recovery.js";
@@ -163,7 +159,6 @@ import {
   verifyExpectedArtifact,
   writeBlockerPlaceholder,
   diagnoseExpectedArtifact,
-  skipExecuteTask,
   buildLoopRemediationSteps,
   reconcileMergeState,
 } from "./auto-recovery.js";
@@ -962,9 +957,6 @@ function buildLoopDeps(): LoopDeps {
     runPreDispatchHooks,
     getPriorSliceCompletionBlocker,
     getMainBranch,
-    collectObservabilityWarnings: _collectObservabilityWarnings,
-    buildObservabilityRepairBlock,
-
     // Unit closeout + runtime records
     closeoutUnit,
     verifyExpectedArtifact,
@@ -1480,6 +1472,5 @@ export {
   resolveExpectedArtifactPath,
   verifyExpectedArtifact,
   writeBlockerPlaceholder,
-  skipExecuteTask,
   buildLoopRemediationSteps,
 } from "./auto-recovery.js";