gsd-pi 2.80.0-dev.2848d9009 → 2.80.0-dev.3065f7bfa

package/src/resources/extensions/gsd/tests/migrate-writer-integration.test.ts

@@ -13,6 +13,9 @@ import { parseRoadmap, parsePlan } from '../parsers-legacy.ts';
 import { parseSummary } from '../files.ts';
 import { deriveState } from '../state.ts';
 import { invalidateAllCaches } from '../cache.ts';
+import { ensureDbOpen } from '../bootstrap/dynamic-tools.ts';
+import { closeDatabase, getAllMilestones } from '../gsd-db.ts';
+import { importWrittenMigrationToDb } from '../migrate/command.ts';
 import type {
   GSDProject,
   GSDMilestone,
@@ -250,6 +253,51 @@ test('Scenario 1: Incomplete project — write, parse, deriveState', async () =>
     }
 });
 
+test('Scenario 1b: written migration imports into authoritative DB state', async () => {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-writer-db-import-'));
+    try {
+      const project = buildIncompleteProject();
+      await writeGSDDirectory(project, base);
+
+      assert.equal(await ensureDbOpen(base), true, 'db import: ensureDbOpen creates authoritative DB');
+
+      invalidateAllCaches();
+      const before = await deriveState(base);
+      assert.equal(before.activeMilestone, null, 'db import: markdown-only migration is invisible before DB import');
+
+      const imported = await importWrittenMigrationToDb(base);
+      assert.deepStrictEqual(imported.hierarchy, { milestones: 1, slices: 2, tasks: 3 }, 'db import: hierarchy counts');
+
+      invalidateAllCaches();
+      const after = await deriveState(base);
+      assert.deepStrictEqual(after.phase, 'executing', 'db import: deriveState sees imported DB hierarchy');
+      assert.deepStrictEqual(after.activeMilestone?.id, 'M001', 'db import: active milestone');
+      assert.deepStrictEqual(after.activeSlice?.id, 'S02', 'db import: active slice');
+      assert.deepStrictEqual(after.activeTask?.id, 'T03', 'db import: active task');
+    } finally {
+      closeDatabase();
+      rmSync(base, { recursive: true, force: true });
+    }
+});
+
+test('Scenario 1c: DB import verification fails when preview counts do not match', async () => {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-writer-db-check-'));
+    try {
+      const project = buildIncompleteProject();
+      await writeGSDDirectory(project, base);
+
+      const preview = generatePreview(project);
+      await assert.rejects(
+        () => importWrittenMigrationToDb(base, { ...preview, totalTasks: preview.totalTasks + 1 }),
+        /migration DB import verification failed: tasks 3\/4/,
+      );
+      assert.deepStrictEqual(getAllMilestones(), [], 'db import: failed verification rolls back hierarchy rewrite');
+    } finally {
+      closeDatabase();
+      rmSync(base, { recursive: true, force: true });
+    }
+});
+
   // ─── Scenario 2: Fully complete project ────────────────────────────────
 
 test('Scenario 2: Fully complete project — deriveState phase', async () => {

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

@@ -0,0 +1,127 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import test from "node:test";
+
+import { ensureDbOpen } from "../bootstrap/dynamic-tools.ts";
+import {
+  _getAdapter,
+  closeDatabase,
+  getAllMilestones,
+  getSliceTasks,
+} from "../gsd-db.ts";
+import {
+  autoImportMarkdownHierarchyIfDbMismatch,
+  countMarkdownHierarchy,
+} from "../migration-auto-check.ts";
+import { writeGSDDirectory } from "../migrate/writer.ts";
+import type { GSDProject } from "../migrate/types.ts";
+
+function makeBase(): string {
+  return mkdtempSync(join(tmpdir(), "gsd-migration-auto-check-"));
+}
+
+function cleanup(base: string): void {
+  closeDatabase();
+  rmSync(base, { recursive: true, force: true });
+}
+
+function projectFixture(): GSDProject {
+  return {
+    projectContent: "# Legacy Project\n",
+    decisionsContent: "",
+    requirements: [],
+    milestones: [
+      {
+        id: "M001",
+        title: "Legacy Milestone",
+        vision: "Carry forward previous work",
+        successCriteria: ["Existing task is visible"],
+        research: null,
+        boundaryMap: [],
+        slices: [
+          {
+            id: "S01",
+            title: "Legacy Slice",
+            risk: "medium",
+            depends: [],
+            done: false,
+            demo: "Legacy slice demo",
+            goal: "Legacy slice demo",
+            research: null,
+            summary: null,
+            tasks: [
+              {
+                id: "T01",
+                title: "Legacy Task",
+                description: "Task carried from markdown",
+                done: false,
+                estimate: "",
+                files: ["src/index.ts"],
+                mustHaves: [],
+                summary: null,
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  };
+}
+
+test("migration auto-check imports markdown hierarchy when DB is empty", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory(projectFixture(), base);
+    assert.deepEqual(countMarkdownHierarchy(base), { milestones: 1, slices: 1, tasks: 1 });
+
+    assert.equal(await ensureDbOpen(base), true);
+    assert.equal(getAllMilestones().length, 0, "fresh authoritative DB starts empty");
+
+    const result = await autoImportMarkdownHierarchyIfDbMismatch(base);
+    assert.equal(result.action, "imported");
+    assert.equal(result.reason, "db-empty");
+    assert.deepEqual(result.afterDb, { milestones: 1, slices: 1, tasks: 1 });
+    assert.equal(getAllMilestones().length, 1);
+    assert.equal(getSliceTasks("M001", "S01").length, 1);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("migration auto-check repairs DB hierarchy count mismatch", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory(projectFixture(), base);
+    await autoImportMarkdownHierarchyIfDbMismatch(base);
+
+    _getAdapter()!.prepare("DELETE FROM tasks WHERE milestone_id = ? AND slice_id = ? AND id = ?").run("M001", "S01", "T01");
+    assert.equal(getSliceTasks("M001", "S01").length, 0, "test fixture simulates stale DB task count");
+
+    const result = await autoImportMarkdownHierarchyIfDbMismatch(base);
+    assert.equal(result.action, "imported");
+    assert.equal(result.reason, "count-mismatch");
+    assert.deepEqual(result.beforeDb, { milestones: 1, slices: 1, tasks: 0 });
+    assert.deepEqual(result.afterDb, { milestones: 1, slices: 1, tasks: 1 });
+    assert.equal(getSliceTasks("M001", "S01").length, 1);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("migration auto-check leaves matching DB hierarchy alone", async () => {
+  const base = makeBase();
+  try {
+    await writeGSDDirectory(projectFixture(), base);
+    await autoImportMarkdownHierarchyIfDbMismatch(base);
+
+    const result = await autoImportMarkdownHierarchyIfDbMismatch(base);
+    assert.equal(result.action, "none");
+    assert.equal(result.reason, "in-sync");
+    assert.deepEqual(result.markdown, { milestones: 1, slices: 1, tasks: 1 });
+    assert.deepEqual(result.afterDb, { milestones: 1, slices: 1, tasks: 1 });
+  } finally {
+    cleanup(base);
+  }
+});

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

@@ -0,0 +1,242 @@
+// GSD-2 + src/resources/extensions/gsd/tests/milestone-merge-stash-restore.test.ts
+// Regression: postflight stash pop must run even when mergeAndExit throws.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { _runMilestoneMergeWithStashRestore } from "../auto/phases.js";
+import type { IterationContext } from "../auto/types.js";
+import { MergeConflictError } from "../git-service.js";
+import type {
+  PostflightResult,
+  PreflightResult,
+} from "../clean-root-preflight.js";
+
+interface CallLog {
+  preflightCalls: number;
+  mergeCalls: number;
+  postflightCalls: number;
+  stopAutoCalls: Array<string | undefined>;
+  notifyCalls: Array<{ message: string; level: string }>;
+  milestoneMergedInPhases: boolean;
+}
+
+function buildIc(opts: {
+  preflightResult: PreflightResult;
+  mergeBehavior: "succeed" | (() => never);
+  postflightResult: PostflightResult;
+}): { ic: IterationContext; log: CallLog } {
+  const log: CallLog = {
+    preflightCalls: 0,
+    mergeCalls: 0,
+    postflightCalls: 0,
+    stopAutoCalls: [],
+    notifyCalls: [],
+    milestoneMergedInPhases: false,
+  };
+
+  const session = {
+    basePath: "/tmp/proj",
+    originalBasePath: "/tmp/proj",
+    get milestoneMergedInPhases() {
+      return log.milestoneMergedInPhases;
+    },
+    set milestoneMergedInPhases(v: boolean) {
+      log.milestoneMergedInPhases = v;
+    },
+  };
+
+  const ctx = {
+    ui: {
+      notify: (message: string, level: string) => {
+        log.notifyCalls.push({ message, level });
+      },
+    },
+  };
+
+  const deps = {
+    preflightCleanRoot: () => {
+      log.preflightCalls += 1;
+      return opts.preflightResult;
+    },
+    postflightPopStash: () => {
+      log.postflightCalls += 1;
+      return opts.postflightResult;
+    },
+    resolver: {
+      mergeAndExit: () => {
+        log.mergeCalls += 1;
+        if (opts.mergeBehavior !== "succeed") {
+          opts.mergeBehavior();
+        }
+      },
+    },
+    stopAuto: async (_c?: unknown, _p?: unknown, reason?: string) => {
+      log.stopAutoCalls.push(reason);
+    },
+  };
+
+  const ic = {
+    ctx,
+    pi: {},
+    s: session,
+    deps,
+  } as unknown as IterationContext;
+
+  return { ic, log };
+}
+
+const STASH_PUSHED: PreflightResult = {
+  stashPushed: true,
+  stashMarker: "gsd-preflight-stash:M002:42:1700000000000:abc",
+  summary: "Stashed uncommitted changes before merge (milestone M002).",
+};
+
+const STASH_NOT_PUSHED: PreflightResult = {
+  stashPushed: false,
+  summary: "",
+};
+
+const POP_OK: PostflightResult = {
+  restored: true,
+  needsManualRecovery: false,
+  message: "Restored stashed changes after milestone M002 merge.",
+  stashRef: "stash@{0}",
+};
+
+const POP_NEEDS_RECOVERY: PostflightResult = {
+  restored: false,
+  needsManualRecovery: true,
+  message: "git stash pop stash@{0} failed: conflict in lib/models.ts",
+};
+
+test("happy path: merge succeeds and stash is popped", async () => {
+  const { ic, log } = buildIc({
+    preflightResult: STASH_PUSHED,
+    mergeBehavior: "succeed",
+    postflightResult: POP_OK,
+  });
+
+  const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+  assert.equal(result, null, "happy path returns null (loop continues)");
+  assert.equal(log.preflightCalls, 1);
+  assert.equal(log.mergeCalls, 1);
+  assert.equal(log.postflightCalls, 1, "postflight pop must run on success");
+  assert.equal(log.stopAutoCalls.length, 0, "no stopAuto on happy path");
+  assert.equal(log.milestoneMergedInPhases, true, "merge flag set");
+});
+
+test("regression #5538-followup: postflight pop runs even when mergeAndExit throws non-conflict error", async () => {
+  // The original bug: when mergeAndExit threw, the catch block called
+  // stopAuto + return break BEFORE postflight pop ran. The user's
+  // gsd-preflight-stash:M00x stash was orphaned. This test exercises that
+  // exact scenario and asserts the pop is now invoked.
+  const { ic, log } = buildIc({
+    preflightResult: STASH_PUSHED,
+    mergeBehavior: () => {
+      throw new Error("native git merge failed: index lock present");
+    },
+    postflightResult: POP_OK,
+  });
+
+  const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+  assert.deepEqual(result, { action: "break", reason: "merge-failed" });
+  assert.equal(log.mergeCalls, 1);
+  assert.equal(
+    log.postflightCalls,
+    1,
+    "postflight pop must run even on merge failure (was the bug)",
+  );
+  assert.equal(log.stopAutoCalls.length, 1);
+  assert.match(log.stopAutoCalls[0] ?? "", /Merge error on milestone M002/);
+  assert.equal(
+    log.milestoneMergedInPhases,
+    false,
+    "merge flag must NOT be set when merge throws",
+  );
+});
+
+test("regression #5538-followup: postflight pop runs even when mergeAndExit throws MergeConflictError", async () => {
+  const { ic, log } = buildIc({
+    preflightResult: STASH_PUSHED,
+    mergeBehavior: () => {
+      throw new MergeConflictError(
+        ["lib/models.ts", "app/page.tsx"],
+        "squash",
+        "milestone/M002",
+        "main",
+      );
+    },
+    postflightResult: POP_OK,
+  });
+
+  const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+  assert.deepEqual(result, { action: "break", reason: "merge-conflict" });
+  assert.equal(log.mergeCalls, 1);
+  assert.equal(
+    log.postflightCalls,
+    1,
+    "postflight pop must run on merge conflict (was the bug)",
+  );
+  assert.equal(log.stopAutoCalls.length, 1);
+  assert.match(log.stopAutoCalls[0] ?? "", /Merge conflict on milestone M002/);
+});
+
+test("clean tree: no stash to pop, merge succeeds, no pop attempted", async () => {
+  const { ic, log } = buildIc({
+    preflightResult: STASH_NOT_PUSHED,
+    mergeBehavior: "succeed",
+    postflightResult: POP_OK,
+  });
+
+  const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+  assert.equal(result, null);
+  assert.equal(log.postflightCalls, 0, "no pop when nothing was stashed");
+  assert.equal(log.milestoneMergedInPhases, true);
+});
+
+test("merge succeeds but stash pop needs manual recovery -> postflight-stash-restore-failed break", async () => {
+  const { ic, log } = buildIc({
+    preflightResult: STASH_PUSHED,
+    mergeBehavior: "succeed",
+    postflightResult: POP_NEEDS_RECOVERY,
+  });
+
+  const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+  assert.deepEqual(result, {
+    action: "break",
+    reason: "postflight-stash-restore-failed",
+  });
+  assert.equal(log.postflightCalls, 1);
+  assert.equal(log.stopAutoCalls.length, 1);
+  assert.match(
+    log.stopAutoCalls[0] ?? "",
+    /Post-merge stash restore failed for milestone M002/,
+  );
+});
+
+test("merge error is reported even when stash pop also failed (merge-error takes priority)", async () => {
+  const { ic, log } = buildIc({
+    preflightResult: STASH_PUSHED,
+    mergeBehavior: () => {
+      throw new Error("network unreachable during push");
+    },
+    postflightResult: POP_NEEDS_RECOVERY,
+  });
+
+  const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+  assert.deepEqual(result, { action: "break", reason: "merge-failed" });
+  assert.equal(log.postflightCalls, 1, "postflight pop still attempted");
+  assert.equal(log.stopAutoCalls.length, 1, "stopAuto called once, not twice");
+  assert.match(
+    log.stopAutoCalls[0] ?? "",
+    /Merge error/,
+    "stopAuto message reflects merge error, not stash failure",
+  );
+});

package/src/resources/extensions/gsd/tests/native-git-bridge-exec-fallback.test.ts

@@ -12,11 +12,18 @@
 
 import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { chmodSync, mkdtempSync, writeFileSync, readFileSync, rmSync } from "node:fs";
+import { chmodSync, existsSync, mkdtempSync, writeFileSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
-import { nativeIsRepo, nativeCommit, nativeResetHard, nativeBranchDelete } from "../native-git-bridge.js";
+import {
+  assertWorktreeMaterialized,
+  nativeBranchDelete,
+  nativeCommit,
+  nativeIsRepo,
+  nativeResetHard,
+  nativeWorktreeAdd,
+} from "../native-git-bridge.js";
 
 // Note: prior static-analysis tests that scanned native-git-bridge.ts for
 // the raw shell-spawn pattern were removed under #4827 — the integration
@@ -115,4 +122,29 @@ describe("native-git-bridge #4180: fallback runtime behaviour", () => {
       /GSD_GIT_ERROR|git branch -D does-not-exist failed/,
     );
   });
+
+  test("assertWorktreeMaterialized rejects directories without a .git file", (t) => {
+    const dir = mkdtempSync(join(tmpdir(), "ngb-worktree-missing-git-"));
+    t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+    assert.throws(
+      () => assertWorktreeMaterialized(dir),
+      /missing \.git file/,
+    );
+  });
+
+  test("nativeWorktreeAdd materializes a valid .git marker", (t) => {
+    const wtPath = join(repo, ".gsd", "worktrees", "M001");
+    t.after(() => {
+      try { git(["worktree", "remove", "--force", wtPath], repo); } catch { /* noop */ }
+    });
+
+    nativeWorktreeAdd(repo, wtPath, "milestone/M001", true, "HEAD");
+
+    assert.equal(
+      existsSync(join(wtPath, ".git")),
+      true,
+      "created worktree must have the .git file required by later health checks",
+    );
+  });
 });

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

@@ -110,6 +110,9 @@ function makeDeps(overrides?: Partial<WorktreeResolverDeps>): WorktreeResolverDe
       calls.push({ fn: "getCurrentBranch", args: [basePath] });
       return "main";
     },
+    checkoutBranch: (basePath: string, branch: string) => {
+      calls.push({ fn: "checkoutBranch", args: [basePath, branch] });
+    },
     autoWorktreeBranch: (milestoneId: string) => `milestone/${milestoneId}`,
     resolveMilestoneFile: (basePath: string, milestoneId: string, fileType: string) => {
       calls.push({ fn: "resolveMilestoneFile", args: [basePath, milestoneId, fileType] });

package/src/resources/extensions/gsd/tests/orphan-merge-bootstrap.test.ts

@@ -0,0 +1,133 @@
+// GSD-2 + src/resources/extensions/gsd/tests/orphan-merge-bootstrap.test.ts
+// Regression: bootstrap must actively merge orphan completed-but-unmerged
+// milestones, not just seed `s.currentMilestoneId` (the seed approach was
+// silently overwritten at auto-start.ts:948 — caught in audit of PR #5549).
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { _mergeOrphanCompletedMilestone } from "../auto-start.js";
+import type { WorktreeResolver } from "../worktree-resolver.js";
+
+interface FakeResolverState {
+  mergeCalls: Array<{ milestoneId: string }>;
+  shouldThrow?: unknown;
+}
+
+function fakeResolver(state: FakeResolverState): WorktreeResolver {
+  return {
+    mergeAndExit: (milestoneId: string) => {
+      state.mergeCalls.push({ milestoneId });
+      if (state.shouldThrow) throw state.shouldThrow;
+    },
+  } as unknown as WorktreeResolver;
+}
+
+interface FakeUiState {
+  notifications: Array<{ message: string; level: string }>;
+}
+
+function fakeUi(state: FakeUiState): {
+  notify: (msg: string, level?: "info" | "warning" | "error" | "success") => void;
+} {
+  return {
+    notify: (message: string, level?: "info" | "warning" | "error" | "success") => {
+      state.notifications.push({ message, level: level ?? "info" });
+    },
+  };
+}
+
+test("happy path: orphan merge runs, returns merged:true, emits info notify", () => {
+  const resolverState: FakeResolverState = { mergeCalls: [] };
+  const uiState: FakeUiState = { notifications: [] };
+  const result = _mergeOrphanCompletedMilestone(
+    fakeResolver(resolverState),
+    "M002",
+    fakeUi(uiState),
+  );
+
+  assert.deepEqual(result, { merged: true });
+  assert.deepEqual(resolverState.mergeCalls, [{ milestoneId: "M002" }]);
+  assert.equal(uiState.notifications.length, 1);
+  assert.deepEqual(uiState.notifications[0], {
+    message: "Detected unmerged completed milestone M002. Merging now.",
+    level: "info",
+  });
+});
+
+test("regression: mergeAndExit throwing (e.g. wrong-branch from PR #5549 commit 5) does not bubble out", () => {
+  // Commit 5 (68ef58a3c) made `_mergeBranchMode` throw on wrong branch
+  // instead of silently returning false. If `_mergeOrphanCompletedMilestone`
+  // didn't catch the throw, bootstrap would surface an unhandled exception
+  // to the slash-command caller — the exact regression risk that motivated
+  // wrapping in try/catch.
+  const boom = new Error("dirty working tree blocks checkout");
+  const resolverState: FakeResolverState = { mergeCalls: [], shouldThrow: boom };
+  const uiState: FakeUiState = { notifications: [] };
+
+  const result = _mergeOrphanCompletedMilestone(
+    fakeResolver(resolverState),
+    "M002",
+    fakeUi(uiState),
+  );
+
+  assert.equal(result.merged, false);
+  assert.equal(result.error, boom);
+
+  // First notify announces the merge attempt; second notify reports the failure.
+  assert.equal(uiState.notifications.length, 2);
+  assert.equal(uiState.notifications[0].level, "info");
+  assert.equal(uiState.notifications[1].level, "warning");
+  assert.match(
+    uiState.notifications[1].message,
+    /Could not merge orphan milestone M002/,
+  );
+  assert.match(uiState.notifications[1].message, /dirty working tree blocks checkout/);
+  assert.match(uiState.notifications[1].message, /Resolve manually/);
+});
+
+test("non-Error thrown values are still captured and notified", () => {
+  // Defensive: thrown strings, numbers, etc. must not crash the formatter.
+  const resolverState: FakeResolverState = {
+    mergeCalls: [],
+    // mimic a thrown non-Error value
+    shouldThrow: "git lock held",
+  };
+  const uiState: FakeUiState = { notifications: [] };
+
+  const result = _mergeOrphanCompletedMilestone(
+    fakeResolver(resolverState),
+    "M002",
+    fakeUi(uiState),
+  );
+
+  assert.equal(result.merged, false);
+  assert.equal(result.error, resolverState.shouldThrow);
+  assert.equal(uiState.notifications[1].level, "warning");
+  assert.match(uiState.notifications[1].message, /git lock held/);
+});
+
+test("the mergeAndExit call receives a notify-bound NotifyCtx the resolver can invoke", () => {
+  // The resolver's NotifyCtx must be wired to ui.notify so user-facing
+  // messages from inside mergeAndExit (e.g. "Milestone Mxxx merged") still
+  // reach the UI. Verify by having the fake resolver invoke the ctx.notify.
+  const uiState: FakeUiState = { notifications: [] };
+  const ui = fakeUi(uiState);
+
+  const resolver = {
+    mergeAndExit: (_milestoneId: string, ctx: { notify: (msg: string, level?: "info" | "warning" | "error" | "success") => void }) => {
+      ctx.notify("inner success message", "success");
+    },
+  } as unknown as WorktreeResolver;
+
+  const result = _mergeOrphanCompletedMilestone(resolver, "M002", ui);
+
+  assert.equal(result.merged, true);
+  // 1: outer "Detected unmerged completed milestone..."
+  // 2: inner "inner success message" emitted via the bound ctx.notify
+  assert.equal(uiState.notifications.length, 2);
+  assert.deepEqual(uiState.notifications[1], {
+    message: "inner success message",
+    level: "success",
+  });
+});