@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.c18009cd

package/src/resources/extensions/gsd/tests/migrate-external-worktree.test.ts

@@ -7,12 +7,16 @@ import {
   existsSync,
   mkdirSync,
   realpathSync,
+  readFileSync,
 } from "node:fs";
+import fs from "node:fs";
+import { syncBuiltinESMExports } from "node:module";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
 import { migrateToExternalState, recoverFailedMigration } from "../migrate-external.ts";
+import { externalGsdRoot } from "../repo-identity.ts";
 
 function run(command: string, cwd: string): string {
   return execSync(command, {
@@ -116,6 +120,175 @@ describe("migrate-external worktree guard (#2970)", () => {
   });
 });
 
+describe("migrateToExternalState rename fallback (#1179)", () => {
+  test("falls back to copy/delete when rename fails with EACCES", () => {
+    const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-migrate-eacces-")));
+    const stateDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-state-eacces-")));
+    const previousStateDir = process.env.GSD_STATE_DIR;
+    const previousProjectId = process.env.GSD_PROJECT_ID;
+    const originalRenameSync = fs.renameSync;
+    const localGsd = join(base, ".gsd");
+    const migratingPath = join(base, ".gsd.migrating");
+    let renameAttempts = 0;
+
+    process.env.GSD_STATE_DIR = stateDir;
+    process.env.GSD_PROJECT_ID = "rename-eacces";
+
+    try {
+      run("git init -b main", base);
+      mkdirSync(localGsd, { recursive: true });
+      writeFileSync(join(localGsd, "PREFERENCES.md"), "# prefs\n", "utf-8");
+
+      fs.renameSync = ((src, dst) => {
+        if (String(src) === localGsd && String(dst) === migratingPath) {
+          renameAttempts += 1;
+          const error = new Error("simulated WSL/DrvFs rename lock") as NodeJS.ErrnoException;
+          error.code = "EACCES";
+          throw error;
+        }
+        return originalRenameSync(src, dst);
+      }) as typeof fs.renameSync;
+      syncBuiltinESMExports();
+
+      const result = migrateToExternalState(base);
+
+      assert.equal(result.migrated, true, "EACCES rename failure should use copy/delete fallback");
+      assert.equal(result.error, undefined);
+      assert.equal(renameAttempts, 1, "should exercise the EACCES rename fallback once");
+      assert.equal(readFileSync(join(stateDir, "projects", "rename-eacces", "PREFERENCES.md"), "utf-8"), "# prefs\n");
+      assert.equal(readFileSync(join(base, ".gsd", "PREFERENCES.md"), "utf-8"), "# prefs\n");
+      assert.ok(!existsSync(migratingPath), "backup staging dir must be removed after successful migration");
+    } finally {
+      fs.renameSync = originalRenameSync;
+      syncBuiltinESMExports();
+      if (previousStateDir === undefined) {
+        delete process.env.GSD_STATE_DIR;
+      } else {
+        process.env.GSD_STATE_DIR = previousStateDir;
+      }
+      if (previousProjectId === undefined) {
+        delete process.env.GSD_PROJECT_ID;
+      } else {
+        process.env.GSD_PROJECT_ID = previousProjectId;
+      }
+      rmSync(base, { recursive: true, force: true });
+      rmSync(stateDir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("migrateToExternalState already-migrated external state guard (#1178)", () => {
+  test("skips migration when external state already exists for a real local .gsd directory", () => {
+    const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-migrate-already-external-")));
+    const stateDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-state-already-external-")));
+    const previousStateDir = process.env.GSD_STATE_DIR;
+    const previousProjectId = process.env.GSD_PROJECT_ID;
+    process.env.GSD_STATE_DIR = stateDir;
+
+    try {
+      run("git init -b main", base);
+      run('git config user.name "Test"', base);
+      run('git config user.email "test@example.com"', base);
+      writeFileSync(join(base, "README.md"), "# Test\n", "utf-8");
+      run("git add README.md", base);
+      run('git commit -m "init"', base);
+
+      const externalPath = externalGsdRoot(base);
+      const identity = externalPath.split(/[\\/]/).pop();
+      assert.ok(identity, "external state path must include an identity segment");
+      mkdirSync(externalPath, { recursive: true });
+      writeFileSync(join(base, ".gsd-id"), `${identity}\n`, "utf-8");
+      writeFileSync(join(externalPath, "gsd.db"), "newer external state\n", "utf-8");
+
+      mkdirSync(join(base, ".gsd"), { recursive: true });
+      writeFileSync(join(base, ".gsd", "gsd.db"), "stale local state\n", "utf-8");
+
+      const result = migrateToExternalState(base);
+
+      assert.equal(result.migrated, false, "already-migrated project must not re-run migration");
+      assert.match(result.error ?? "", /external state already exists/i);
+      assert.equal(
+        readFileSync(join(externalPath, "gsd.db"), "utf-8"),
+        "newer external state\n",
+        "newer external gsd.db must not be overwritten by stale local state",
+      );
+      assert.equal(
+        readFileSync(join(base, ".gsd", "gsd.db"), "utf-8"),
+        "stale local state\n",
+        "local real .gsd directory should be left for explicit recovery",
+      );
+      assert.ok(!existsSync(join(base, ".gsd.migrating")), "migration staging dir must not be created");
+    } finally {
+      if (previousStateDir === undefined) {
+        delete process.env.GSD_STATE_DIR;
+      } else {
+        process.env.GSD_STATE_DIR = previousStateDir;
+      }
+      if (previousProjectId === undefined) {
+        delete process.env.GSD_PROJECT_ID;
+      } else {
+        process.env.GSD_PROJECT_ID = previousProjectId;
+      }
+      rmSync(base, { recursive: true, force: true });
+      rmSync(stateDir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("migrateToExternalState copy failure rollback (#1047)", () => {
+  test("restores .gsd when a source entry fails to copy", () => {
+    const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-migrate-copy-fail-")));
+    const stateDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-state-copy-fail-")));
+    const previousStateDir = process.env.GSD_STATE_DIR;
+    const previousProjectId = process.env.GSD_PROJECT_ID;
+    const originalCpSync = fs.cpSync;
+    process.env.GSD_STATE_DIR = stateDir;
+    process.env.GSD_PROJECT_ID = "copy-fail";
+
+    try {
+      run("git init -b main", base);
+      mkdirSync(join(base, ".gsd"), { recursive: true });
+      writeFileSync(join(base, ".gsd", "PREFERENCES.md"), "# prefs\n", "utf-8");
+      writeFileSync(join(base, ".gsd", "gsd.db"), "state", "utf-8");
+      const failingSource = join(base, ".gsd.migrating", "gsd.db");
+      fs.cpSync = ((...args: Parameters<typeof fs.cpSync>) => {
+        const src = args[0];
+        if (String(src) === failingSource) {
+          const error = new Error("simulated copy failure") as NodeJS.ErrnoException;
+          error.code = "EACCES";
+          throw error;
+        }
+        return originalCpSync(...args);
+      }) as typeof fs.cpSync;
+      syncBuiltinESMExports();
+
+      const result = migrateToExternalState(base);
+
+      assert.equal(result.migrated, false, "copy failure must fail the migration");
+      assert.match(result.error ?? "", /Migration copy failed/);
+      assert.ok(existsSync(join(base, ".gsd", "gsd.db")), "source .gsd must be restored");
+      assert.equal(readFileSync(join(base, ".gsd", "PREFERENCES.md"), "utf-8"), "# prefs\n");
+      assert.ok(!existsSync(join(base, ".gsd.migrating")), "backup staging dir must not remain after restore");
+      assert.ok(!existsSync(join(stateDir, "projects", "copy-fail", "gsd.db")), "failed file must not be reported as migrated");
+    } finally {
+      fs.cpSync = originalCpSync;
+      syncBuiltinESMExports();
+      if (previousStateDir === undefined) {
+        delete process.env.GSD_STATE_DIR;
+      } else {
+        process.env.GSD_STATE_DIR = previousStateDir;
+      }
+      if (previousProjectId === undefined) {
+        delete process.env.GSD_PROJECT_ID;
+      } else {
+        process.env.GSD_PROJECT_ID = previousProjectId;
+      }
+      rmSync(base, { recursive: true, force: true });
+      rmSync(stateDir, { recursive: true, force: true });
+    }
+  });
+});
+
 // Regression tests for #5571 — recoverFailedMigration handles orphaned .gsd.migrating
 describe("recoverFailedMigration (#5571)", () => {
   test("returns false when .gsd.migrating does not exist", () => {

package/src/resources/extensions/gsd/tests/migration-auto-check.test.ts

@@ -429,3 +429,73 @@ test("rebuildMarkdownProjectionsFromDb realigns markdown when DB holds extra row
     cleanup(base);
   }
 });
+
+test("rebuildMarkdownProjectionsFromDb realigns markdown for numeric milestone IDs", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory({ projectContent: "# P\n", decisionsContent: "", requirements: [], milestones: [] }, base);
+    assert.equal(await ensureDbOpen(base), true);
+    insertMilestone({ id: "15", title: "Numeric milestone", status: "active" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "15",
+      title: "Numeric slice",
+      status: "pending",
+      risk: "medium",
+      depends: [],
+      demo: "d",
+      sequence: 1,
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "15",
+      title: "Numeric task",
+      status: "pending",
+    });
+
+    const before = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(before.recoveryCommand, "/gsd rebuild markdown");
+
+    const { rebuildMarkdownProjectionsFromDb } = await import("../commands-maintenance.ts");
+    const rebuild = await rebuildMarkdownProjectionsFromDb(base);
+    assert.ok(rebuild.rendered > 0, "expected markdown projections to render");
+
+    const after = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(after.action, "none");
+    assert.equal(after.reason, "in-sync");
+    assert.deepEqual(after.markdown, { milestones: 1, slices: 1, tasks: 1 });
+    assert.deepEqual(after.beforeDb, { milestones: 1, slices: 1, tasks: 1 });
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("rebuildMarkdownProjectionsFromDb realigns markdown for planned zero-slice milestones", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory({ projectContent: "# P\n", decisionsContent: "", requirements: [], milestones: [] }, base);
+    assert.equal(await ensureDbOpen(base), true);
+    insertMilestone({
+      id: "M016",
+      title: "Queued milestone",
+      status: "queued",
+      planning: { vision: "Defined but not sliced yet" },
+    });
+
+    const before = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(before.recoveryCommand, "/gsd rebuild markdown");
+
+    const { rebuildMarkdownProjectionsFromDb } = await import("../commands-maintenance.ts");
+    const rebuild = await rebuildMarkdownProjectionsFromDb(base);
+    assert.ok(rebuild.rendered > 0, "expected markdown projections to render");
+
+    const after = await checkMarkdownHierarchyAgainstDb(base);
+    assert.equal(after.action, "none");
+    assert.equal(after.reason, "in-sync");
+    assert.deepEqual(after.markdown, { milestones: 1, slices: 0, tasks: 0 });
+    assert.deepEqual(after.beforeDb, { milestones: 1, slices: 0, tasks: 0 });
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/milestone-closeout.test.ts

@@ -154,7 +154,12 @@ test("isCompletedMilestoneTerminal accepts validation-pass with all slices close
 test("evaluateCompleteMilestoneDispatch repairs missing SUMMARY when DB is closed", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-dispatch-repair-summary-"));
   tmpDirs.push(base);
-  mkdirSync(join(base, ".gsd", "milestones", "M008"), { recursive: true });
+  const m008Dir = join(base, ".gsd", "milestones", "M008");
+  mkdirSync(m008Dir, { recursive: true });
+  // A content-bearing legacy milestone dir requires at least one non-META file
+  // (dirIsContentBearingLegacyMilestone) so the layout sniffer treats it as a
+  // real legacy milestone rather than a metadata-only placeholder.
+  writeFileSync(join(m008Dir, "M008-CONTEXT.md"), "# M008\n");
   openDatabase(join(base, ".gsd", "gsd.db"));
   insertMilestone({ id: "M008", title: "Live Text Search", status: "complete" });
   insertSlice({ id: "S01", milestoneId: "M008", title: "Slice", status: "complete" });
@@ -191,7 +196,7 @@ test("repairMissingMilestoneSummaryProjection succeeds when milestone dir does n
   const repair = await repairMissingMilestoneSummaryProjection(base, "M042");
   assert.equal(repair.ok, true, "repair should report success when handler creates the SUMMARY");
   assert.ok(
-    existsSync(join(base, ".gsd", "milestones", "M042", "M042-SUMMARY.md")),
+    existsSync(join(base, ".gsd", "phases", "42-m042", "42-SUMMARY.md")),
     "repair should write the SUMMARY artifact to the canonical projection path",
   );
 });

package/src/resources/extensions/gsd/tests/milestone-merge-stash-restore.test.ts

@@ -4,7 +4,10 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 
-import { _runMilestoneMergeWithStashRestore } from "../auto/closeout.js";
+import {
+  _runMilestoneMergeOnceWithStashRestore,
+  _runMilestoneMergeWithStashRestore,
+} from "../auto/closeout.js";
 import type { IterationContext } from "../auto/types.js";
 import { MergeConflictError } from "../git-service.js";
 import type {
@@ -58,6 +61,30 @@ function buildIc(opts: {
     },
   };
 
+  const plainExitMilestone = (exitOpts: { merge: boolean }) => {
+    log.mergeCalls += 1;
+    if (opts.mergeBehavior === "succeed") {
+      return { ok: true, merged: exitOpts.merge, codeFilesChanged: false } as const;
+    }
+    try {
+      opts.mergeBehavior();
+      return { ok: true, merged: exitOpts.merge, codeFilesChanged: false } as const;
+    } catch (err) {
+      // Mirror Lifecycle's typed-result wrapping of MergeConflictError
+      // and other thrown values per worktree-lifecycle.exitMilestone.
+      const isMergeConflict =
+        err !== null &&
+        typeof err === "object" &&
+        err !== undefined &&
+        (err as { name?: string }).name === "MergeConflictError";
+      return {
+        ok: false,
+        reason: isMergeConflict ? "merge-conflict" : "teardown-failed",
+        cause: err,
+      } as const;
+    }
+  };
+
   const deps = {
     preflightCleanRoot: () => {
       log.preflightCalls += 1;
@@ -76,28 +103,72 @@ function buildIc(opts: {
       },
     },
     lifecycle: {
-      exitMilestone: (_mid: string, exitOpts: { merge: boolean }) => {
-        log.mergeCalls += 1;
-        if (opts.mergeBehavior === "succeed") {
-          return { ok: true, merged: exitOpts.merge, codeFilesChanged: false };
-        }
-        try {
-          opts.mergeBehavior();
-          return { ok: true, merged: exitOpts.merge, codeFilesChanged: false };
-        } catch (err) {
-          // Mirror Lifecycle's typed-result wrapping of MergeConflictError
-          // and other thrown values per worktree-lifecycle.exitMilestone.
-          const isMergeConflict =
-            err !== null &&
-            typeof err === "object" &&
-            err !== undefined &&
-            (err as { name?: string }).name === "MergeConflictError";
-          return {
-            ok: false,
-            reason: isMergeConflict ? "merge-conflict" : "teardown-failed",
-            cause: err,
-          } as const;
+      exitMilestone: (
+        _mid: string,
+        exitOpts: {
+          merge: boolean;
+          guardedMerge?: {
+            projectRoot: string;
+            preflightCleanRoot: (
+              basePath: string,
+              milestoneId: string,
+              notify: (message: string, level: "info" | "warning" | "error") => void,
+            ) => PreflightResult;
+            postflightPopStash: (
+              basePath: string,
+              milestoneId: string,
+              stashMarker: string | undefined,
+              notify: (message: string, level: "info" | "warning" | "error") => void,
+            ) => PostflightResult;
+          };
+        },
+        exitCtx?: { notify: (message: string, level: "info" | "warning" | "error") => void },
+      ) => {
+        const notify = exitCtx?.notify ?? (() => {});
+        const guarded = exitOpts.guardedMerge;
+        if (exitOpts.merge && guarded) {
+          const preflight = guarded.preflightCleanRoot(guarded.projectRoot, _mid, notify);
+          if (preflight.blocked) {
+            return {
+              ok: false,
+              reason: preflight.blockedReason?.startsWith("unmerged-conflicts")
+                ? "preflight-unmerged-conflicts"
+                : "preflight-dirty-overlap",
+            } as const;
+          }
+
+          const mergeResult = plainExitMilestone({ merge: true });
+          const postflight = preflight.stashPushed
+            ? guarded.postflightPopStash(
+                guarded.projectRoot,
+                _mid,
+                preflight.stashMarker,
+                notify,
+              )
+            : undefined;
+
+          if (!mergeResult.ok) {
+            if (mergeResult.reason === "merge-conflict") {
+              return { ...mergeResult, postflight } as const;
+            }
+            return {
+              ok: false,
+              reason: "merge-failed",
+              cause: mergeResult.cause,
+              postflight,
+            } as const;
+          }
+          if (postflight?.needsManualRecovery) {
+            return {
+              ok: false,
+              reason: "postflight-stash-restore-failed",
+              postflight,
+            } as const;
+          }
+          return mergeResult;
         }
+
+        return plainExitMilestone(exitOpts);
       },
     },
     stopAuto: async (
@@ -155,6 +226,14 @@ const PREFLIGHT_UNMERGED: PreflightResult = {
   summary: "Working tree has unresolved Git conflicts before milestone M002 merge.",
 };
 
+const PREFLIGHT_UNMERGED_EVAL_FAILED: PreflightResult = {
+  stashPushed: false,
+  blocked: true,
+  blockedReason: "unmerged-conflicts-eval-failed",
+  conflictedPaths: ["todo.js"],
+  summary: "Unable to fully evaluate unresolved Git conflicts before milestone M002 merge.",
+};
+
 const POP_OK: PostflightResult = {
   restored: true,
   needsManualRecovery: false,
@@ -344,6 +423,52 @@ test("unmerged conflicts: preflight stops before merge and postflight restore",
   );
 });
 
+test("unmerged conflict evaluation failure stops as preflight-unmerged-conflicts", async () => {
+  const { ic, log } = buildIc({
+    preflightResult: PREFLIGHT_UNMERGED_EVAL_FAILED,
+    mergeBehavior: "succeed",
+    postflightResult: POP_OK,
+  });
+
+  const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+  assert.deepEqual(result, {
+    action: "break",
+    reason: "preflight-unmerged-conflicts",
+  });
+  assert.equal(
+    log.mergeCalls,
+    0,
+    "failed conflict evaluation must not start milestone merge",
+  );
+  assert.equal(log.postflightCalls, 0, "blocked preflight must not attempt stash restore");
+  assert.equal(log.stopAutoCalls.length, 1);
+  assert.match(
+    log.stopAutoCalls[0] ?? "",
+    /Pre-merge unresolved Git conflicts block milestone M002/,
+  );
+});
+
+test("already-merged milestone skips guarded merge to terminate duplicate closeout loops", async () => {
+  const { ic, log } = buildIc({
+    preflightResult: STASH_PUSHED,
+    mergeBehavior: "succeed",
+    postflightResult: POP_OK,
+  });
+  log.milestoneMergedInPhases = true;
+
+  const result = await _runMilestoneMergeOnceWithStashRestore(ic, "M002");
+
+  assert.equal(result, null);
+  assert.equal(log.preflightCalls, 0, "already-merged guard must not re-trigger preflight");
+  assert.equal(log.mergeCalls, 0, "already-merged guard must not re-trigger merge");
+  assert.equal(
+    log.postflightCalls,
+    0,
+    "already-merged guard must not re-trigger stash restore",
+  );
+});
+
 test("merge succeeds but stash pop needs manual recovery -> postflight-stash-restore-failed break", async () => {
   const { ic, log } = buildIc({
     preflightResult: STASH_PUSHED,
@@ -358,6 +483,11 @@ test("merge succeeds but stash pop needs manual recovery -> postflight-stash-res
     reason: "postflight-stash-restore-failed",
   });
   assert.equal(log.postflightCalls, 1);
+  assert.equal(
+    log.milestoneMergedInPhases,
+    true,
+    "successful merge must set the flag before postflight recovery stops auto-mode",
+  );
   assert.equal(log.stopAutoCalls.length, 1);
   assert.match(
     log.stopAutoCalls[0] ?? "",

package/src/resources/extensions/gsd/tests/milestone-merge-transaction.test.ts

@@ -13,7 +13,7 @@ test("runMilestoneMergeTransaction delegates to the supplied merge runner", () =
   const calls: unknown[][] = [];
   const result = runMilestoneMergeTransaction(
     {
-      mergeMilestoneToMain: (basePath, milestoneId, roadmapContent) => {
+      mergeMilestone: (basePath, milestoneId, roadmapContent) => {
         calls.push([basePath, milestoneId, roadmapContent]);
         return { pushed: true, codeFilesChanged: true, commitMessage: "merge M001" };
       },

package/src/resources/extensions/gsd/tests/milestone-settlement.test.ts

@@ -55,7 +55,12 @@ function seedClosedMilestone(root: string, worktree: string): void {
     fullContent: "verdict: pass\n",
   });
 
-  mkdirSync(join(worktree, ".gsd", "milestones", "M001"), { recursive: true });
+  const worktreeMilestoneDir = join(worktree, ".gsd", "milestones", "M001");
+  mkdirSync(worktreeMilestoneDir, { recursive: true });
+  // A content-bearing legacy milestone dir requires at least one non-META file
+  // (dirIsContentBearingLegacyMilestone) so the layout sniffer treats it as a
+  // real legacy milestone rather than a metadata-only placeholder.
+  writeFileSync(join(worktreeMilestoneDir, "M001-CONTEXT.md"), "# M001\n");
   const summaryPath = resolveExpectedArtifactPath("complete-milestone", "M001", worktree);
   assert.ok(summaryPath, "complete-milestone summary path should resolve");
   mkdirSync(dirname(summaryPath), { recursive: true });