@opengsd/gsd-pi 1.4.0 → 1.5.0-dev.4fb2d460

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

@@ -0,0 +1,166 @@
+// gsd-pi — Auto-worktree cleanup helpers.
+//
+// Owns shared cleanup primitives used by teardown and merge cleanup paths:
+// same-file DB reconciliation checks, transient project-root state removal,
+// git pathspec conversion for externally-rooted .gsd paths, and expected
+// unlink error classification.
+
+import { execFileSync } from "node:child_process";
+import { existsSync, realpathSync, unlinkSync } from "node:fs";
+import { isAbsolute, join, relative } from "node:path";
+
+import { gsdRoot } from "./paths.js";
+import { logWarning } from "./workflow-logger.js";
+
+function isSamePath(a: string, b: string): boolean {
+  try {
+    return realpathSync(a) === realpathSync(b);
+  } catch (e) {
+    if ((e as NodeJS.ErrnoException).code === "ENOENT") return false;
+    logWarning("worktree", `isSamePath failed: ${(e as Error).message}`);
+    return false;
+  }
+}
+
+export function _isSamePath(a: string, b: string): boolean {
+  return isSamePath(a, b);
+}
+
+export function _shouldReconcileWorktreeDb(
+  worktreeDbPath: string,
+  mainDbPath: string,
+  pathExists: (path: string) => boolean = existsSync,
+  samePath: (a: string, b: string) => boolean = isSamePath,
+): boolean {
+  return pathExists(worktreeDbPath) && !samePath(worktreeDbPath, mainDbPath);
+}
+
+export function _isExpectedWorktreeUnlinkError(
+  code: string | undefined,
+): boolean {
+  return code === "ENOENT" || code === "EISDIR";
+}
+
+function gitPathspecForWorktreePath(
+  basePath: string,
+  targetPath: string,
+): string | null {
+  let base = basePath;
+  let target = targetPath;
+  try {
+    base = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+      cwd: basePath,
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf-8",
+    }).trim() || basePath;
+  } catch {
+    /* keep original */
+    void base;
+  }
+  try {
+    base = realpathSync.native(base);
+  } catch {
+    /* keep original */
+    void base;
+  }
+  try {
+    target = realpathSync.native(targetPath);
+  } catch {
+    /* keep original */
+    void target;
+  }
+
+  const rel = relative(base, target);
+  if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) return null;
+  return rel.replaceAll("\\", "/");
+}
+
+export function _gitPathspecForWorktreePath(
+  basePath: string,
+  targetPath: string,
+): string | null {
+  return gitPathspecForWorktreePath(basePath, targetPath);
+}
+
+export function clearProjectRootStateFiles(
+  basePath: string,
+  milestoneId: string,
+): void {
+  const gsdDir = gsdRoot(basePath);
+  // Phase C pt 2: auto.lock removed from this list — the file is gone
+  // (migrated to the workers + unit_dispatches + runtime_kv tables). The
+  // remaining transient files (STATE.md, {MID}-META.json) are still
+  // worth removing on teardown.
+  const transientFiles = [
+    join(gsdDir, "STATE.md"),
+    join(gsdDir, "milestones", milestoneId, `${milestoneId}-META.json`),
+  ];
+
+  for (const file of transientFiles) {
+    try {
+      unlinkSync(file);
+    } catch (err) {
+      // ENOENT is expected — file may not exist (#3597)
+      if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
+        logWarning(
+          "worktree",
+          `file unlink failed: ${err instanceof Error ? err.message : String(err)}`,
+        );
+      }
+    }
+  }
+
+  // Clean up legacy synced milestone directories and runtime/units.
+  // Older versions copied these into the project root during execution.
+  // If they remain as untracked files when we attempt
+  // `git merge --squash`, git rejects the merge with "local changes would
+  // be overwritten", causing silent data loss (#1738).
+  const syncedDirs = [
+    join(gsdDir, "milestones", milestoneId),
+    join(gsdDir, "runtime", "units"),
+  ];
+
+  for (const dir of syncedDirs) {
+    try {
+      if (!existsSync(dir)) continue;
+
+      const pathspec = gitPathspecForWorktreePath(basePath, dir);
+      if (!pathspec) continue;
+
+      // Only remove files that are untracked by git — tracked files are
+      // managed by the branch checkout and should not be deleted.
+      const untrackedOutput = execFileSync(
+        "git",
+        ["ls-files", "--others", "--exclude-standard", pathspec],
+        {
+          cwd: basePath,
+          stdio: ["ignore", "pipe", "pipe"],
+          encoding: "utf-8",
+        },
+      ).trim();
+      if (!untrackedOutput) continue;
+
+      for (const f of untrackedOutput.split("\n").filter(Boolean)) {
+        try {
+          unlinkSync(join(basePath, f));
+        } catch (err) {
+          // ENOENT/EISDIR are expected for already-removed or
+          // directory entries (#3597).
+          const code = (err as NodeJS.ErrnoException).code;
+          if (!_isExpectedWorktreeUnlinkError(code)) {
+            logWarning(
+              "worktree",
+              `untracked file unlink failed: ${err instanceof Error ? err.message : String(err)}`,
+            );
+          }
+        }
+      }
+    } catch (err) {
+      /* non-fatal — git command may fail if not in repo */
+      logWarning(
+        "worktree",
+        `untracked file cleanup failed: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+  }
+}

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

@@ -0,0 +1,37 @@
+// gsd-pi — Conflict auto-resolve policy for auto-worktree merges.
+//
+// Owns the pure path policy for conflict paths that are safe to resolve
+// mechanically. Git mutation stays in git-conflict-resolve.ts.
+
+/** Patterns for machine-generated build artifacts that can be safely
+ * auto-resolved by accepting --theirs during merge. These files are
+ * regenerable and never contain meaningful manual edits. */
+export const SAFE_AUTO_RESOLVE_PATTERNS: RegExp[] = [
+  /\.tsbuildinfo$/,
+  /\.pyc$/,
+  /\/__pycache__\//,
+  /\.DS_Store$/,
+  /\.map$/,
+  // Regenerable dependency lockfiles. These are fully derivable from their
+  // manifests by the package manager, so accepting the merge side during
+  // auto-resolve clears the conflict markers without losing meaningful edits —
+  // and stops auto-mode from hard-pausing on a lockfile conflict (issue #828).
+  /(?:^|\/)pnpm-lock\.yaml$/,
+  /(?:^|\/)package-lock\.json$/,
+  /(?:^|\/)npm-shrinkwrap\.json$/,
+  /(?:^|\/)yarn\.lock$/,
+  /(?:^|\/)bun\.lockb?$/,
+  /(?:^|\/)Cargo\.lock$/,
+  /(?:^|\/)composer\.lock$/,
+  /(?:^|\/)Gemfile\.lock$/,
+  /(?:^|\/)Pipfile\.lock$/,
+  /(?:^|\/)poetry\.lock$/,
+];
+
+/** Returns true if the file path is safe to auto-resolve during merge.
+ * Covers `.gsd/` state files, common build artifacts, and regenerable
+ * dependency lockfiles. */
+export function isSafeToAutoResolve(filePath: string): boolean {
+  return filePath.startsWith(".gsd/")
+    || SAFE_AUTO_RESOLVE_PATTERNS.some((re) => re.test(filePath));
+}

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

@@ -0,0 +1,171 @@
+// gsd-pi — Auto-worktree creation module.
+//
+// Owns the creation path for milestone worktrees: repository readiness,
+// branch reuse/start-point selection, initial untracked-content import,
+// post-create hook, cwd transition, and session registry update.
+
+import { execFileSync } from "node:child_process";
+import { cpSync, existsSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+import { classifyProject } from "./detection.js";
+import { GSDError, GSD_GIT_ERROR, GSD_IO_ERROR } from "./errors.js";
+import { readIntegrationBranch } from "./git-service.js";
+import { nativeBranchExists } from "./native-git-bridge.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
+import {
+  autoWorktreeBranch,
+  fastForwardReusedMilestoneBranchIfSafe,
+  _resolveAutoWorktreeStartPoint,
+} from "./auto-worktree-branch-lifecycle.js";
+import { setActiveWorkspace } from "./auto-worktree-session-registry.js";
+import { runWorktreePostCreateHook } from "./worktree-post-create-hook.js";
+import { createWorktree } from "./worktree-manager.js";
+import { nudgeGitBranchCache } from "./worktree.js";
+import { resolveWorktreeProjectRoot } from "./worktree-root.js";
+import { createWorkspace } from "./workspace.js";
+import { debugLog } from "./debug-logger.js";
+import { logWarning } from "./workflow-logger.js";
+
+function importUntrackedProjectRootContentIntoEmptyWorktree(
+  projectRoot: string,
+  worktreeRoot: string,
+  milestoneId: string,
+): number {
+  const worktreeClassification = classifyProject(worktreeRoot);
+  if (worktreeClassification.kind !== "greenfield") return 0;
+
+  const projectRootClassification = classifyProject(projectRoot);
+  if (
+    projectRootClassification.kind === "greenfield" ||
+    projectRootClassification.kind === "invalid-repo" ||
+    projectRootClassification.untrackedFiles.length === 0
+  ) {
+    return 0;
+  }
+
+  let copied = 0;
+  for (const relPath of projectRootClassification.untrackedFiles) {
+    const src = join(projectRoot, relPath);
+    if (!existsSync(src)) continue;
+
+    const dst = join(worktreeRoot, relPath);
+    if (existsSync(dst)) continue;
+
+    mkdirSync(dirname(dst), { recursive: true });
+    cpSync(src, dst, { recursive: true, force: false });
+    copied++;
+  }
+
+  if (copied > 0) {
+    debugLog("createAutoWorktree", {
+      phase: "import-untracked-project-content",
+      milestoneId,
+      copied,
+    });
+  }
+
+  return copied;
+}
+
+export function createAutoWorktree(
+  basePath: string,
+  milestoneId: string,
+): string {
+  basePath = resolveWorktreeProjectRoot(basePath);
+
+  // Check if repo has commits — git worktree requires a valid HEAD.
+  try {
+    execFileSync("git", ["rev-parse", "--verify", "HEAD"], {
+      cwd: basePath,
+      stdio: "pipe",
+    });
+  } catch {
+    throw new GSDError(
+      GSD_GIT_ERROR,
+      "Cannot create worktree: repository has no commits yet. Worktree isolation requires at least one commit.",
+    );
+  }
+
+  const branch = autoWorktreeBranch(milestoneId);
+
+  // Check if the milestone branch already exists — it survives auto-mode
+  // stop/pause and contains committed work from prior sessions. If it exists,
+  // re-attach the worktree to it WITHOUT resetting. Only create a fresh branch
+  // from the integration branch when no prior work exists.
+  const branchExists = nativeBranchExists(basePath, branch);
+
+  let info: { name: string; path: string; branch: string; exists: boolean };
+  if (branchExists) {
+    // #5538-followup: fast-forward the reused branch onto the integration
+    // branch when safe so the next milestone forks from up-to-date code.
+    // Without this, a milestone that was created before another milestone
+    // merged into main would carry a stale base into its worktree.
+    fastForwardReusedMilestoneBranchIfSafe(basePath, milestoneId, branch);
+
+    // Re-attach worktree to the existing milestone branch (preserving commits).
+    info = createWorktree(basePath, milestoneId, {
+      branch,
+      reuseExistingBranch: true,
+    });
+  } else {
+    // Fresh start — create branch from integration branch.
+    // Use the same 3-tier fallback as mergeMilestoneToMain (#3461):
+    //   1. META.json integration branch (explicit per-milestone override)
+    //   2. git.main_branch preference (user's configured working branch)
+    //   3. nativeDetectMainBranch (origin/HEAD auto-detection)
+    // Without tier 2, projects with main_branch=dev but origin/HEAD→master
+    // would fork worktrees from the wrong (stale) branch.
+    const integrationBranch = readIntegrationBranch(basePath, milestoneId)
+      ?? undefined;
+    const gitPrefs = loadEffectiveGSDPreferences()?.preferences?.git;
+    const startPoint = _resolveAutoWorktreeStartPoint(
+      integrationBranch,
+      gitPrefs?.main_branch,
+      (branchName) => nativeBranchExists(basePath, branchName),
+    );
+    info = createWorktree(basePath, milestoneId, {
+      branch,
+      startPoint,
+    });
+  }
+
+  // Phase C: copyPlanningArtifacts and reconcilePlanCheckboxes were
+  // deleted. Both addressed the same problem (worktree-local .gsd/
+  // projection lagging behind project-root state) by maintaining a stale
+  // copy. Now that auto-mode writers in workflow-projections.ts,
+  // triage-resolution.ts, rule-registry.ts, and auto-post-unit.ts route
+  // through s.canonicalProjectRoot, the worktree never needs a local
+  // .gsd/ — both reads and writes converge on the project-root .gsd/.
+  // The original concerns (#759, #778) no longer apply because there is
+  // no second copy to drift.
+  importUntrackedProjectRootContentIntoEmptyWorktree(
+    basePath,
+    info.path,
+    milestoneId,
+  );
+
+  // Run user-configured post-create hook (#597) — e.g. copy .env, symlink assets.
+  const hookError = runWorktreePostCreateHook(basePath, info.path);
+  if (hookError) {
+    // Non-fatal — log but don't prevent worktree usage.
+    logWarning("reconcile", hookError, { worktree: info.name });
+  }
+
+  const previousCwd = process.cwd();
+
+  try {
+    process.chdir(info.path);
+    setActiveWorkspace(createWorkspace(basePath));
+  } catch (err) {
+    // If chdir fails, the worktree was created but we couldn't enter it.
+    // Don't set activeWorkspace -- caller can retry or clean up.
+    throw new GSDError(
+      GSD_IO_ERROR,
+      `Auto-worktree created at ${info.path} but chdir failed: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+
+  nudgeGitBranchCache(previousCwd);
+  return info.path;
+}

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

@@ -0,0 +1,154 @@
+// gsd-pi — Auto-worktree entry and presence detection module.
+//
+// Owns the small interface for finding, entering, and identifying milestone
+// worktrees. The legacy auto-worktree barrel re-exports these functions for
+// compatibility while lifecycle callers can depend on this focused module.
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { GSDError, GSD_GIT_ERROR, GSD_IO_ERROR } from "./errors.js";
+import { nativeGetCurrentBranch } from "./native-git-bridge.js";
+import { worktreePath } from "./worktree-manager.js";
+import { worktreePathFor } from "./worktree-placement.js";
+import { nudgeGitBranchCache } from "./worktree.js";
+import {
+  isGsdWorktreePath,
+  normalizeWorktreePathForCompare,
+  resolveWorktreeProjectRoot,
+} from "./worktree-root.js";
+import {
+  getAutoWorktreeOriginalBase,
+  setActiveWorkspace,
+} from "./auto-worktree-session-registry.js";
+import { createWorkspace } from "./workspace.js";
+import { logWarning } from "./workflow-logger.js";
+
+function safeCwd(fallback: string): string {
+  try {
+    return process.cwd();
+  } catch {
+    return fallback;
+  }
+}
+
+/**
+ * Detect if the process is currently inside an auto-worktree.
+ * Uses the current directory structure plus git branch prefix so detection
+ * still works after process restart when module state has been reset.
+ */
+export function isInAutoWorktree(basePath: string): boolean {
+  const targetPath = isGsdWorktreePath(basePath) ? basePath : safeCwd("");
+  if (!isGsdWorktreePath(targetPath)) return false;
+
+  const storedBase = getAutoWorktreeOriginalBase();
+  const projectRoot = resolveWorktreeProjectRoot(basePath, storedBase);
+  const targetProjectRoot = resolveWorktreeProjectRoot(targetPath, storedBase);
+  if (
+    normalizeWorktreePathForCompare(projectRoot) !==
+    normalizeWorktreePathForCompare(targetProjectRoot)
+  ) {
+    return false;
+  }
+
+  try {
+    const branch = nativeGetCurrentBranch(targetPath);
+    return branch.startsWith("milestone/");
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get the filesystem path for an auto-worktree, or null if it doesn't exist
+ * or is not a valid git worktree.
+ *
+ * Validates that the path is a real git worktree (has a .git file with a
+ * gitdir: pointer) rather than just a stray directory. This prevents
+ * mis-detection of leftover directories as active worktrees (#695).
+ */
+export function getAutoWorktreePath(
+  basePath: string,
+  milestoneId: string,
+): string | null {
+  basePath = resolveWorktreeProjectRoot(basePath);
+
+  // basePath is already the resolved project root — go straight to placement
+  // instead of worktreePath(), which would re-resolve the root.
+  const p = worktreePathFor(basePath, milestoneId);
+  if (!existsSync(p)) return null;
+
+  // Validate this is a real git worktree, not a stray directory.
+  // A git worktree has a .git *file* (not directory) containing "gitdir: <path>".
+  const gitPath = join(p, ".git");
+  if (!existsSync(gitPath)) return null;
+  try {
+    const content = readFileSync(gitPath, "utf8").trim();
+    if (!content.startsWith("gitdir: ")) return null;
+  } catch (e) {
+    logWarning("worktree", `getAutoWorktreePath .git read failed: ${(e as Error).message}`);
+    return null;
+  }
+
+  return p;
+}
+
+/**
+ * Enter an existing auto-worktree (chdir into it, store originalBase).
+ * Use for resume -- the worktree already exists from a prior create.
+ *
+ * Atomic: chdir + originalBase update in same try block.
+ */
+export function enterAutoWorktree(
+  basePath: string,
+  milestoneId: string,
+): string {
+  basePath = resolveWorktreeProjectRoot(basePath);
+
+  const p = worktreePath(basePath, milestoneId);
+  if (!existsSync(p)) {
+    throw new GSDError(
+      GSD_IO_ERROR,
+      `Auto-worktree for ${milestoneId} does not exist at ${p}`,
+    );
+  }
+
+  // Validate this is a real git worktree, not a stray directory (#695)
+  const gitPath = join(p, ".git");
+  if (!existsSync(gitPath)) {
+    throw new GSDError(
+      GSD_GIT_ERROR,
+      `Auto-worktree path ${p} exists but is not a git worktree (no .git)`,
+    );
+  }
+  try {
+    const content = readFileSync(gitPath, "utf8").trim();
+    if (!content.startsWith("gitdir: ")) {
+      throw new GSDError(
+        GSD_GIT_ERROR,
+        `Auto-worktree path ${p} has a .git but it is not a worktree gitdir pointer`,
+      );
+    }
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("worktree")) throw err;
+    throw new GSDError(
+      GSD_IO_ERROR,
+      `Auto-worktree path ${p} exists but .git is unreadable`,
+    );
+  }
+
+  const previousCwd = process.cwd();
+
+  try {
+    process.chdir(p);
+    setActiveWorkspace(createWorkspace(basePath));
+  } catch (err) {
+    throw new GSDError(
+      GSD_IO_ERROR,
+      `Failed to enter auto-worktree at ${p}: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+
+  nudgeGitBranchCache(previousCwd);
+  return p;
+}

package/src/resources/extensions/gsd/auto-worktree-merge-already-merged.ts

@@ -0,0 +1,161 @@
+// gsd-pi — Already-merged milestone merge fast path.
+//
+// Owns the safety invariant for milestone branches already reachable from the
+// integration branch: skip the squash merge only when milestone-touched code is
+// still anchored on the current integration branch, then run normal cleanup.
+
+import { execFileSync } from "node:child_process";
+
+import { debugLog } from "./debug-logger.js";
+import { GSDError, GSD_GIT_ERROR } from "./errors.js";
+import {
+  nativeDiffNumstat,
+  nativeIsAncestor,
+} from "./native-git-bridge.js";
+import { cleanupMergedMilestoneWorktree } from "./auto-worktree-merge-cleanup.js";
+import { logWarning } from "./workflow-logger.js";
+
+export interface AlreadyMergedMilestoneRequest {
+  projectRoot: string;
+  milestoneId: string;
+  milestoneBranch: string;
+  mainBranch: string;
+  previousCwd: string;
+  commitMessage: string;
+}
+
+export interface AlreadyMergedMilestoneResult {
+  commitMessage: string;
+  pushed: false;
+  prCreated: false;
+  codeFilesChanged: true;
+}
+
+export function finalizeAlreadyMergedMilestoneIfReachable(
+  request: AlreadyMergedMilestoneRequest,
+): AlreadyMergedMilestoneResult | null {
+  const {
+    projectRoot,
+    milestoneId,
+    milestoneBranch,
+    mainBranch,
+    previousCwd,
+    commitMessage,
+  } = request;
+
+  if (!nativeIsAncestor(projectRoot, milestoneBranch, mainBranch)) {
+    return null;
+  }
+
+  assertNoUnanchoredRegularMergeCodeChanges({
+    projectRoot,
+    milestoneBranch,
+    mainBranch,
+    previousCwd,
+  });
+
+  debugLog("mergeMilestoneToMain", {
+    action: "skip-squash-already-merged",
+    milestoneId,
+    milestoneBranch,
+    mainBranch,
+  });
+  cleanupMergedMilestoneWorktree({
+    projectRoot,
+    milestoneId,
+    milestoneBranch,
+    previousCwd,
+    clearProjectRootState: true,
+    chdirWarningContext: "after already-merged cleanup",
+  });
+  return { commitMessage, pushed: false, prCreated: false, codeFilesChanged: true };
+}
+
+function assertNoUnanchoredRegularMergeCodeChanges(request: {
+  projectRoot: string;
+  milestoneBranch: string;
+  mainBranch: string;
+  previousCwd: string;
+}): void {
+  const { projectRoot, milestoneBranch, mainBranch, previousCwd } = request;
+  const codeChanges = nativeDiffNumstat(
+    projectRoot,
+    mainBranch,
+    milestoneBranch,
+  ).filter((entry) => !entry.path.startsWith(".gsd/"));
+  if (codeChanges.length === 0) return;
+
+  const regularMergeChangedPaths = findRegularMergeChangedPaths(
+    projectRoot,
+    milestoneBranch,
+    mainBranch,
+  );
+  const unanchoredCodeChanges = codeChanges.filter((entry) =>
+    regularMergeChangedPaths.has(entry.path)
+  );
+  if (unanchoredCodeChanges.length === 0) return;
+
+  process.chdir(previousCwd);
+  throw new GSDError(
+    GSD_GIT_ERROR,
+    `Milestone branch "${milestoneBranch}" is reachable from "${mainBranch}" ` +
+      `but has ${unanchoredCodeChanges.length} milestone-touched code file(s) not on current "${mainBranch}". ` +
+      `Aborting worktree teardown to prevent data loss.`,
+  );
+}
+
+function findRegularMergeChangedPaths(
+  basePath: string,
+  milestoneBranch: string,
+  mainBranch: string,
+): Set<string> {
+  const changedPaths = new Set<string>();
+  let mergeLog = "";
+  try {
+    mergeLog = execFileSync(
+      "git",
+      ["rev-list", "--merges", "--parents", mainBranch],
+      {
+        cwd: basePath,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+      },
+    ).trim();
+  } catch (err) {
+    logWarning("worktree", `regular merge lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+    return changedPaths;
+  }
+
+  for (const line of mergeLog.split("\n").filter(Boolean)) {
+    const [mergeCommit, firstParent, ...otherParents] = line.split(" ");
+    if (!mergeCommit || !firstParent || otherParents.length === 0) continue;
+    const mergedMilestone = otherParents.some((parent) => {
+      try {
+        return nativeIsAncestor(basePath, milestoneBranch, parent);
+      } catch {
+        return false;
+      }
+    });
+    if (!mergedMilestone) continue;
+
+    try {
+      const output = execFileSync(
+        "git",
+        ["diff", "--name-only", firstParent, mergeCommit],
+        {
+          cwd: basePath,
+          stdio: ["ignore", "pipe", "pipe"],
+          encoding: "utf-8",
+        },
+      ).trim();
+      for (const path of output.split("\n").filter(Boolean)) {
+        if (!path.startsWith(".gsd/")) changedPaths.add(path);
+      }
+    } catch (err) {
+      logWarning("worktree", `regular merge diff lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return changedPaths;
+  }
+
+  return changedPaths;
+}