@opengsd/gsd-pi 1.5.0 → 1.6.0

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

@@ -3,6 +3,10 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
 import {
   _runMilestoneMergeOnceWithStashRestore,
@@ -10,6 +14,9 @@ import {
 } from "../auto/closeout.js";
 import type { IterationContext } from "../auto/types.js";
 import { MergeConflictError } from "../git-service.js";
+import { closeDatabase, insertDecision, insertMilestone, insertSlice, insertTask, openDatabase } from "../gsd-db.js";
+import { renderAllFromDb } from "../markdown-renderer.js";
+import { resolveMilestoneFile } from "../paths.js";
 import type {
   PostflightResult,
   PreflightResult,
@@ -234,6 +241,70 @@ const PREFLIGHT_UNMERGED_EVAL_FAILED: PreflightResult = {
   summary: "Unable to fully evaluate unresolved Git conflicts before milestone M002 merge.",
 };
 
+function git(basePath: string, args: string[], stdio: "ignore" | "pipe" = "pipe"): void {
+  execFileSync("git", args, { cwd: basePath, stdio });
+}
+
+async function withProjectionBackedProject<T>(
+  fn: (basePath: string, roadmapPath: string) => Promise<T>,
+  options: { gitInit?: boolean } = {},
+): Promise<T> {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-postflight-projection-"));
+  try {
+    mkdirSync(join(basePath, ".gsd"), { recursive: true });
+    openDatabase(join(basePath, ".gsd", "gsd.db"));
+    insertMilestone({
+      id: "M002",
+      title: "Postflight Guard",
+      status: "active",
+    });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M002",
+      title: "Slice",
+      status: "pending",
+      risk: "medium",
+      depends: [],
+      demo: "demo",
+      sequence: 1,
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M002",
+      title: "Task",
+      status: "pending",
+    });
+    await renderAllFromDb(basePath);
+    if (options.gitInit !== false) {
+      git(basePath, ["init"], "ignore");
+      git(basePath, ["config", "user.email", "test@example.invalid"]);
+      git(basePath, ["config", "user.name", "Test"]);
+      git(basePath, ["add", ".gsd"]);
+      git(basePath, ["commit", "-m", "initial projections"], "ignore");
+    }
+    const roadmapPath = resolveMilestoneFile(basePath, "M002", "ROADMAP");
+    assert.ok(roadmapPath, "expected rendered M002 roadmap path");
+    return await fn(basePath, roadmapPath);
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+}
+
+function insertFreshDbSlice(): void {
+  insertSlice({
+    id: "S02",
+    milestoneId: "M002",
+    title: "Fresh DB Slice",
+    status: "pending",
+    risk: "medium",
+    depends: [],
+    demo: "demo",
+    sequence: 2,
+  });
+}
+
 const POP_OK: PostflightResult = {
   restored: true,
   needsManualRecovery: false,
@@ -469,6 +540,374 @@ test("already-merged milestone skips guarded merge to terminate duplicate closeo
   );
 });
 
+
+test("postflight-restored projection edits survive successful merge rebuild", async () => {
+  await withProjectionBackedProject(async (basePath, roadmapPath) => {
+    const { ic } = buildIc({
+      preflightResult: STASH_PUSHED,
+      mergeBehavior: "succeed",
+      postflightResult: POP_OK,
+    });
+    (ic.s as { basePath: string; originalBasePath: string }).basePath = basePath;
+    (ic.s as { basePath: string; originalBasePath: string }).originalBasePath = basePath;
+    (ic.deps as unknown as { postflightPopStash: () => PostflightResult }).postflightPopStash = () => {
+      writeFileSync(roadmapPath, "# local projection edit restored from stash\n", "utf8");
+      return POP_OK;
+    };
+
+    const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+    assert.equal(result, null);
+    assert.equal(
+      readFileSync(roadmapPath, "utf8"),
+      "# local projection edit restored from stash\n",
+      "projection rebuild must not overwrite user edits restored by postflight stash pop",
+    );
+  });
+});
+
+test("untracked markdown under a new generated .gsd projection directory suppresses successful merge rebuild", async () => {
+  await withProjectionBackedProject(async (basePath, roadmapPath) => {
+    insertFreshDbSlice();
+
+    const { ic } = buildIc({
+      preflightResult: STASH_PUSHED,
+      mergeBehavior: "succeed",
+      postflightResult: POP_OK,
+    });
+    (ic.s as { basePath: string; originalBasePath: string }).basePath = basePath;
+    (ic.s as { basePath: string; originalBasePath: string }).originalBasePath = basePath;
+    (ic.deps as unknown as { postflightPopStash: () => PostflightResult }).postflightPopStash = () => {
+      const restoredDir = join(basePath, ".gsd", "milestones", "M002", "slices", "S99");
+      mkdirSync(restoredDir, { recursive: true });
+      writeFileSync(join(restoredDir, "S99-SUMMARY.md"), "# restored local markdown\n", "utf8");
+      return POP_OK;
+    };
+
+    const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+    assert.equal(result, null);
+    assert.doesNotMatch(
+      readFileSync(roadmapPath, "utf8"),
+      /Fresh DB Slice/,
+      "untracked markdown projections inside generated .gsd directories must suppress rebuild",
+    );
+  });
+});
+
+test("ignored untracked markdown under .gsd suppresses successful merge rebuild", async () => {
+  await withProjectionBackedProject(async (basePath, roadmapPath) => {
+    writeFileSync(join(basePath, ".gitignore"), ".gsd\n", "utf8");
+    git(basePath, ["add", ".gitignore"]);
+    git(basePath, ["commit", "-m", "ignore gsd projections"], "ignore");
+    insertFreshDbSlice();
+
+    const { ic } = buildIc({
+      preflightResult: STASH_PUSHED,
+      mergeBehavior: "succeed",
+      postflightResult: POP_OK,
+    });
+    (ic.s as { basePath: string; originalBasePath: string }).basePath = basePath;
+    (ic.s as { basePath: string; originalBasePath: string }).originalBasePath = basePath;
+    (ic.deps as unknown as { postflightPopStash: () => PostflightResult }).postflightPopStash = () => {
+      const restoredDir = join(basePath, ".gsd", "milestones", "M002", "ignored-restored-projections");
+      mkdirSync(restoredDir, { recursive: true });
+      writeFileSync(join(restoredDir, "S99-SUMMARY.md"), "# ignored restored local markdown\n", "utf8");
+      return POP_OK;
+    };
+
+    const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+    assert.equal(result, null);
+    assert.doesNotMatch(
+      readFileSync(roadmapPath, "utf8"),
+      /Fresh DB Slice/,
+      "ignored .gsd markdown projections restored by postflight must suppress rebuild",
+    );
+  });
+});
+
+test("preexisting ignored markdown under .gsd does not suppress successful merge rebuild", async () => {
+  await withProjectionBackedProject(async (basePath, roadmapPath) => {
+    writeFileSync(join(basePath, ".gitignore"), ".gsd\n", "utf8");
+    git(basePath, ["add", ".gitignore"]);
+    git(basePath, ["commit", "-m", "ignore gsd projections"], "ignore");
+    mkdirSync(join(basePath, ".gsd", "milestones", "M002", "ignored-existing-projections"), { recursive: true });
+    writeFileSync(
+      join(basePath, ".gsd", "milestones", "M002", "ignored-existing-projections", "S99-SUMMARY.md"),
+      "# already ignored local markdown\n",
+      "utf8",
+    );
+    insertFreshDbSlice();
+
+    const { ic } = buildIc({
+      preflightResult: STASH_PUSHED,
+      mergeBehavior: "succeed",
+      postflightResult: POP_OK,
+    });
+    (ic.s as { basePath: string; originalBasePath: string }).basePath = basePath;
+    (ic.s as { basePath: string; originalBasePath: string }).originalBasePath = basePath;
+
+    const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+    assert.equal(result, null);
+    assert.match(
+      readFileSync(roadmapPath, "utf8"),
+      /Fresh DB Slice/,
+      "stable preexisting ignored .gsd markdown must not block the required projection rebuild",
+    );
+  });
+});
+
+test("failed pre-merge ignored snapshot still suppresses rebuild over restored ignored markdown", async () => {
+  await withProjectionBackedProject(async (basePath, roadmapPath) => {
+    insertFreshDbSlice();
+
+    const { ic } = buildIc({
+      preflightResult: STASH_PUSHED,
+      mergeBehavior: "succeed",
+      postflightResult: POP_OK,
+    });
+    (ic.s as { basePath: string; originalBasePath: string }).basePath = basePath;
+    (ic.s as { basePath: string; originalBasePath: string }).originalBasePath = basePath;
+    (ic.deps as unknown as { postflightPopStash: () => PostflightResult }).postflightPopStash = () => {
+      // Git only becomes available AFTER the pre-merge ignored-markdown
+      // snapshot was attempted, so `before` is null. Postflight then restores
+      // ignored `.gsd` markdown that plain `git status` cannot see. With no
+      // baseline to diff against, the guard must fail closed and refuse to
+      // rebuild over the restored edit.
+      git(basePath, ["init"], "ignore");
+      git(basePath, ["config", "user.email", "test@example.invalid"]);
+      git(basePath, ["config", "user.name", "Test"]);
+      writeFileSync(join(basePath, ".gitignore"), ".gsd\n", "utf8");
+      git(basePath, ["add", ".gitignore"]);
+      git(basePath, ["commit", "-m", "ignore gsd projections"], "ignore");
+      writeFileSync(roadmapPath, "# ignored projection edit restored from stash\n", "utf8");
+      return POP_OK;
+    };
+
+    const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+    assert.equal(result, null);
+    assert.equal(
+      readFileSync(roadmapPath, "utf8"),
+      "# ignored projection edit restored from stash\n",
+      "a null pre-merge ignored snapshot must fail closed and preserve restored ignored .gsd markdown",
+    );
+  }, { gitInit: false });
+});
+
+test("non-projection .gsd markdown does not suppress successful merge rebuild", async () => {
+  await withProjectionBackedProject(async (basePath, roadmapPath) => {
+    insertFreshDbSlice();
+
+    const { ic } = buildIc({
+      preflightResult: STASH_PUSHED,
+      mergeBehavior: "succeed",
+      postflightResult: POP_OK,
+    });
+    (ic.s as { basePath: string; originalBasePath: string }).basePath = basePath;
+    (ic.s as { basePath: string; originalBasePath: string }).originalBasePath = basePath;
+    (ic.deps as unknown as { postflightPopStash: () => PostflightResult }).postflightPopStash = () => {
+      writeFileSync(join(basePath, ".gsd", "PREFERENCES.md"), "# local preferences note\n", "utf8");
+      mkdirSync(join(basePath, ".gsd", "milestones", "M002"), { recursive: true });
+      writeFileSync(join(basePath, ".gsd", "milestones", "M002", "NOTES.md"), "# local milestone note\n", "utf8");
+      return POP_OK;
+    };
+
+    const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+    assert.equal(result, null);
+    assert.match(
+      readFileSync(roadmapPath, "utf8"),
+      /Fresh DB Slice/,
+      "non-generated .gsd markdown must not block the required projection rebuild",
+    );
+  });
+});
+
+test("three-digit flat-phase projection restored by postflight suppresses successful merge rebuild", async () => {
+  await withProjectionBackedProject(async (basePath, roadmapPath) => {
+    insertFreshDbSlice();
+
+    const { ic } = buildIc({
+      preflightResult: STASH_PUSHED,
+      mergeBehavior: "succeed",
+      postflightResult: POP_OK,
+    });
+    (ic.s as { basePath: string; originalBasePath: string }).basePath = basePath;
+    (ic.s as { basePath: string; originalBasePath: string }).originalBasePath = basePath;
+    (ic.deps as unknown as { postflightPopStash: () => PostflightResult }).postflightPopStash = () => {
+      const restoredDir = join(basePath, ".gsd", "phases", "999-db-backed-planning");
+      mkdirSync(restoredDir, { recursive: true });
+      writeFileSync(join(restoredDir, "999-ROADMAP.md"), "# restored 3-digit projection\n", "utf8");
+      return POP_OK;
+    };
+
+    const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+    assert.equal(result, null);
+    assert.doesNotMatch(
+      readFileSync(roadmapPath, "utf8"),
+      /Fresh DB Slice/,
+      "three-digit flat-phase projections restored by postflight must suppress rebuild",
+    );
+  });
+});
+
+test("root DECISIONS projection restored by postflight suppresses successful merge rebuild", async () => {
+  await withProjectionBackedProject(async (basePath, roadmapPath) => {
+    insertFreshDbSlice();
+    insertDecision({
+      id: "D001",
+      when_context: "closeout",
+      scope: "global",
+      decision: "Regenerate decisions from DB",
+      choice: "Use database projection",
+      rationale: "Exercise root decision projection rebuild",
+      revisable: "Yes",
+      made_by: "agent",
+      superseded_by: null,
+    });
+
+    const { ic } = buildIc({
+      preflightResult: STASH_PUSHED,
+      mergeBehavior: "succeed",
+      postflightResult: POP_OK,
+    });
+    (ic.s as { basePath: string; originalBasePath: string }).basePath = basePath;
+    (ic.s as { basePath: string; originalBasePath: string }).originalBasePath = basePath;
+    (ic.deps as unknown as { postflightPopStash: () => PostflightResult }).postflightPopStash = () => {
+      writeFileSync(
+        join(basePath, ".gsd", "DECISIONS.md"),
+        "# local decisions edit restored from stash\n",
+        "utf8",
+      );
+      return POP_OK;
+    };
+
+    const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+    assert.equal(result, null);
+    assert.doesNotMatch(
+      readFileSync(roadmapPath, "utf8"),
+      /Fresh DB Slice/,
+      "root generated DECISIONS.md restored by postflight must suppress rebuild",
+    );
+    assert.equal(
+      readFileSync(join(basePath, ".gsd", "DECISIONS.md"), "utf8"),
+      "# local decisions edit restored from stash\n",
+      "rebuild must not overwrite restored root DECISIONS.md edits",
+    );
+  });
+});
+
+test("non-projection .gsd dirt does not suppress successful merge rebuild", async () => {
+  await withProjectionBackedProject(async (basePath, roadmapPath) => {
+    insertFreshDbSlice();
+    mkdirSync(join(basePath, ".gsd", "runtime"), { recursive: true });
+
+    const { ic } = buildIc({
+      preflightResult: STASH_PUSHED,
+      mergeBehavior: "succeed",
+      postflightResult: POP_OK,
+    });
+    (ic.s as { basePath: string; originalBasePath: string }).basePath = basePath;
+    (ic.s as { basePath: string; originalBasePath: string }).originalBasePath = basePath;
+    (ic.deps as unknown as { postflightPopStash: () => PostflightResult }).postflightPopStash = () => {
+      writeFileSync(join(basePath, ".gsd", "runtime", "restored.json"), "{}\n", "utf8");
+      return POP_OK;
+    };
+
+    const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+    assert.equal(result, null);
+    assert.match(
+      readFileSync(roadmapPath, "utf8"),
+      /Fresh DB Slice/,
+      "non-projection .gsd dirt must not block the required projection rebuild",
+    );
+  });
+});
+
+test("guarded merge stash restore and rebuild target the same canonical project root", async () => {
+  await withProjectionBackedProject(async (realRoot, roadmapPath) => {
+    insertFreshDbSlice();
+    let postflightProjectRoot: string | undefined;
+
+    const { ic } = buildIc({
+      preflightResult: STASH_PUSHED,
+      mergeBehavior: "succeed",
+      postflightResult: POP_OK,
+    });
+    // originalBasePath empty + basePath diverging from canonicalProjectRoot is
+    // the exact condition where the guard (snapshot / dirty check / rebuild)
+    // could run against a different tree than the postflight stash restore.
+    // The postflight restore must land on the same canonical root the guard
+    // inspects and the rebuild writes, otherwise restored edits are missed.
+    (ic.s as unknown as {
+      basePath: string;
+      originalBasePath: string;
+      canonicalProjectRoot: string;
+    }).basePath = "/tmp/gsd-decoy-basepath-not-the-project-root";
+    (ic.s as unknown as { originalBasePath: string }).originalBasePath = "";
+    (ic.s as unknown as { canonicalProjectRoot: string }).canonicalProjectRoot = realRoot;
+    (ic.deps as unknown as { postflightPopStash: (projectRoot: string) => PostflightResult }).postflightPopStash =
+      (projectRoot: string) => {
+        postflightProjectRoot = projectRoot;
+        writeFileSync(roadmapPath, "# projection edit restored from stash\n", "utf8");
+        return POP_OK;
+      };
+
+    const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+    assert.equal(result, null);
+    assert.equal(
+      postflightProjectRoot,
+      realRoot,
+      "postflight stash restore must run at the canonical project root the guard and rebuild use",
+    );
+    assert.equal(
+      readFileSync(roadmapPath, "utf8"),
+      "# projection edit restored from stash\n",
+      "restored projection edits on the canonical root must suppress the rebuild",
+    );
+  });
+});
+
+test("git-quoted special-character .gsd markdown paths still suppress rebuild", async () => {
+  await withProjectionBackedProject(async (basePath, roadmapPath) => {
+    insertFreshDbSlice();
+
+    const { ic } = buildIc({
+      preflightResult: STASH_PUSHED,
+      mergeBehavior: "succeed",
+      postflightResult: POP_OK,
+    });
+    (ic.s as { basePath: string; originalBasePath: string }).basePath = basePath;
+    (ic.s as { basePath: string; originalBasePath: string }).originalBasePath = basePath;
+    (ic.deps as unknown as { postflightPopStash: () => PostflightResult }).postflightPopStash = () => {
+      const restoredDir = join(basePath, ".gsd", "milestones", "M002", "restoréd");
+      mkdirSync(restoredDir, { recursive: true });
+      // A non-ASCII generated projection path that `git status --porcelain`
+      // C-quotes without -z; a naive line.endsWith(".md") check would miss the
+      // quoted path. NUL-delimited (-z) parsing sees the raw path and still
+      // detects it as generated projection dirt.
+      writeFileSync(join(restoredDir, "S99-SUMMARY.md"), "# restored local markdown\n", "utf8");
+      return POP_OK;
+    };
+
+    const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+    assert.equal(result, null);
+    assert.doesNotMatch(
+      readFileSync(roadmapPath, "utf8"),
+      /Fresh DB Slice/,
+      "special-character generated .gsd markdown restored by postflight must suppress the rebuild",
+    );
+  });
+});
+
 test("merge succeeds but stash pop needs manual recovery -> postflight-stash-restore-failed break", async () => {
   const { ic, log } = buildIc({
     preflightResult: STASH_PUSHED,

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

@@ -5,6 +5,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 
 import {
+  createDefaultMilestoneMergeTransaction,
   createMilestoneMergeTransaction,
   runMilestoneMergeTransaction,
 } from "../milestone-merge-transaction.js";
@@ -44,3 +45,26 @@ test("createMilestoneMergeTransaction returns a lifecycle-compatible runner", ()
     codeFilesChanged: false,
   });
 });
+
+test("createDefaultMilestoneMergeTransaction hides the legacy merge adapter behind the transaction seam", () => {
+  const calls: unknown[][] = [];
+  const runner = createDefaultMilestoneMergeTransaction(
+    (basePath, milestoneId, roadmapContent) => {
+      calls.push([basePath, milestoneId, roadmapContent]);
+      return {
+        pushed: false,
+        codeFilesChanged: true,
+        commitMessage: "merge M003",
+        prCreated: false,
+      };
+    },
+  );
+
+  assert.deepEqual(runner("/repo", "M003", "# M003"), {
+    pushed: false,
+    codeFilesChanged: true,
+    commitMessage: "merge M003",
+    prCreated: false,
+  });
+  assert.deepEqual(calls, [["/repo", "M003", "# M003"]]);
+});

package/src/resources/extensions/gsd/tests/none-mode-gates.test.ts

@@ -18,7 +18,7 @@ import { execFileSync } from "node:child_process";
 
 import { shouldUseWorktreeIsolation } from "../auto.ts";
 import { getIsolationMode } from "../preferences.ts";
-import { getActiveAutoWorktreeContext } from "../auto-worktree.ts";
+import { getActiveAutoWorktreeContext } from "../auto-worktree-session-registry.ts";
 import { invalidateAllCaches } from "../cache.ts";
 import { describe, test, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert/strict';

package/src/resources/extensions/gsd/tests/originalbase-path-comparison.test.ts

@@ -26,12 +26,12 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
+import { createAutoWorktree } from "../auto-worktree-creation.ts";
 import {
   getAutoWorktreeOriginalBase,
   _resetAutoWorktreeOriginalBaseForTests,
-  createAutoWorktree,
-  teardownAutoWorktree,
-} from "../auto-worktree.ts";
+} from "../auto-worktree-session-registry.ts";
+import { teardownAutoWorktree } from "../auto-worktree-teardown.ts";
 import { normalizeWorktreePathForCompare } from "../worktree-root.ts";
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────

package/src/resources/extensions/gsd/tests/parallel-worker-lock-contention.test.ts

@@ -32,7 +32,7 @@ import { gsdRoot } from "../paths.ts";
 import {
   syncProjectRootToWorktree,
   syncStateToProjectRoot,
-} from "../auto-worktree.ts";
+} from "../auto-worktree-sync.ts";
 import { writeLock, readCrashLock, clearLock } from "../crash-recovery.ts";
 import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";

package/src/resources/extensions/gsd/tests/parsers-legacy-importers.test.ts

@@ -65,7 +65,6 @@ const ALLOWED_IMPORTERS = new Set([
   "gsd/visualizer-data.ts",
   // prompt context text (display strings injected into unit prompts)
   "gsd/auto-prompts.ts",
-  // cold-path maintenance command (branch cleanup messaging)
   "gsd/commands-maintenance.ts",
   // display-only GitHub issue/PR body sync
   "github-sync/sync.ts",