gsd-pi 2.81.0 → 2.82.0-dev.ed17d078d

package/src/resources/extensions/gsd/tests/integration/git-service.test.ts

@@ -608,6 +608,32 @@ describe('git-service', async () => {
     rmSync(repo, { recursive: true, force: true });
   });
 
+  test('GitServiceImpl: task context keyFiles ignores gitignored build outputs', () => {
+    const repo = initTempRepo();
+    const svc = new GitServiceImpl(repo);
+
+    createFile(repo, ".gitignore", "dist/\n");
+    runGit(repo, ["add", ".gitignore"]);
+    runGit(repo, ["commit", "-F", "-"], { input: "ignore dist" });
+
+    createFile(repo, "src/task.ts", "export const task = true;");
+    createFile(repo, "dist/task.js", "export const task = true;");
+
+    const msg = svc.autoCommit("execute-task", "M001/S01/T01", [], {
+      taskId: "S01/T01",
+      taskTitle: "implement scoped task",
+      oneLiner: "Added scoped task implementation",
+      keyFiles: ["src/task.ts", "dist/task.js"],
+    });
+    assert.ok(msg !== null, "autoCommit should commit non-ignored key files");
+
+    const committed = run("git show --name-only --format= HEAD", repo);
+    assert.ok(committed.includes("src/task.ts"), "non-ignored key file is committed");
+    assert.ok(!committed.includes("dist/task.js"), "ignored build output is not committed");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
   // ─── GitServiceImpl: empty-after-staging guard ─────────────────────────
 
   test('GitServiceImpl: empty-after-staging guard', () => {

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

@@ -17,10 +17,12 @@ import { migrateFromMarkdown, parseDecisionsTable } from '../../md-importer.ts';
 import {
   queryDecisions,
   queryRequirements,
+  getAllDecisionsFromMemories,
   formatDecisionsForPrompt,
   formatRequirementsForPrompt,
 } from '../../context-store.ts';
 import { saveDecisionToDb, generateDecisionsMd } from '../../db-writer.ts';
+import { backfillDecisionsToMemories } from '../../memory-backfill.ts';
 import { describe, test, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert/strict';
 
@@ -233,8 +235,8 @@ test('integration-lifecycle: full pipeline', async () => {
       assert.ok(typeof saved.id === 'string', 'lifecycle: saveDecisionToDb returned an id');
       assert.match(saved.id, /^D\d+$/, 'lifecycle: saved ID matches D### pattern');
 
-      // Query back from DB
-      const allAfterSave = queryDecisions();
+      // Query back from DB (memories — Stage 3 of ADR-013 stopped legacy decisions-table writes)
+      const allAfterSave = getAllDecisionsFromMemories();
       const savedDecision = allAfterSave.find(d => d.id === saved.id);
       assert.ok(savedDecision !== null && savedDecision !== undefined, `lifecycle: saved decision ${saved.id} found in DB`);
       assert.deepStrictEqual(savedDecision?.decision, 'integration test write-back decision', 'lifecycle: saved decision text matches');
@@ -253,9 +255,15 @@ test('integration-lifecycle: full pipeline', async () => {
       assert.deepStrictEqual(reparsedSaved?.rationale, 'proves round-trip fidelity', 'lifecycle: round-trip rationale preserved');
 
       // ── Step 8: DB consistency — total count sanity ─────────────────────
-      const finalCount = queryDecisions().length;
-      // Original 14 + 1 re-import + 1 saveDecisionToDb = 16
-      assert.ok(finalCount === DECISIONS_COUNT + 2, `lifecycle: final DB count = ${DECISIONS_COUNT + 2} (got ${finalCount})`);
+      // ADR-013 Stage 3 split the write paths: migrateFromMarkdown still
+      // populates the legacy decisions table, but saveDecisionToDb now writes
+      // only to memories. The unified projection (and the post-#5756 cutover
+      // end-state) lives in memories, so simulate what bootstrap does and
+      // backfill the table rows into memories before counting.
+      backfillDecisionsToMemories();
+      const finalCount = getAllDecisionsFromMemories().length;
+      // Original 14 + 1 re-import (decisions table → memories via backfill) + 1 saveDecisionToDb = 16
+      assert.ok(finalCount === DECISIONS_COUNT + 2, `lifecycle: final memory-store count = ${DECISIONS_COUNT + 2} (got ${finalCount})`);
 
       closeDatabase();
     } finally {

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

@@ -62,8 +62,8 @@ import {
   renderRoadmapCheckboxes,
   renderAllFromDb,
   detectStaleRenders,
-  repairStaleRenders,
 } from "../../markdown-renderer.ts";
+import { repairStaleRenders } from "../../state-reconciliation/drift/stale-render.ts";
 
 // ── State derivation ──────────────────────────────────────────────────────
 import {

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

@@ -14,7 +14,9 @@ import {
   generatePreview,
   writeGSDDirectory,
 } from '../../migrate/index.ts';
+import { importWrittenMigrationToDb } from '../../migrate/command.ts';
 import { deriveState } from '../../state.ts';
+import { closeDatabase, getDecisionById, getRequirementCounts } from '../../gsd-db.ts';
 import { describe, test, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert/strict';
 
@@ -52,6 +54,16 @@ const SAMPLE_REQUIREMENTS = `# Requirements
 - Description: Output matches GSD format.
 `;
 
+const SAMPLE_REQUIREMENTS_LEGACY_IDS = `# Requirements
+
+## Active
+
+- [ ] **CORE-PIPELINE**: Pipeline must work end-to-end.
+- [ ] **OUTPUT-FORMAT**: Output matches GSD format.
+- [ ] **IMPORT-DB**: Migration imports requirements into the DB.
+- [ ] **STATUS-WIDGET**: Status can query migrated requirements.
+`;
+
 const SAMPLE_STATE = `# State
 
 **Current Phase:** 20-features
@@ -166,14 +178,14 @@ Depends on foundation work.
 </context>
 `;
 
-function createCompleteFixture(): string {
+function createCompleteFixture(requirementsContent: string = SAMPLE_REQUIREMENTS): string {
   const base = mkdtempSync(join(tmpdir(), 'gsd-cmd-test-'));
   const planning = join(base, '.planning');
   mkdirSync(planning, { recursive: true });
 
   writeFileSync(join(planning, 'PROJECT.md'), SAMPLE_PROJECT);
   writeFileSync(join(planning, 'ROADMAP.md'), SAMPLE_ROADMAP);
-  writeFileSync(join(planning, 'REQUIREMENTS.md'), SAMPLE_REQUIREMENTS);
+  writeFileSync(join(planning, 'REQUIREMENTS.md'), requirementsContent);
   writeFileSync(join(planning, 'STATE.md'), SAMPLE_STATE);
   writeFileSync(join(planning, 'config.json'), SAMPLE_CONFIG);
 
@@ -303,6 +315,7 @@ test('Full pipeline: parse → transform → preview → write → deriveState',
       const expectedTaskPct = totalTasks > 0 ? Math.round((doneTasks / totalTasks) * 100) : 0;
       assert.deepStrictEqual(preview.sliceCompletionPct, expectedSlicePct, 'pipeline: preview sliceCompletionPct');
       assert.deepStrictEqual(preview.taskCompletionPct, expectedTaskPct, 'pipeline: preview taskCompletionPct');
+      assert.deepStrictEqual(preview.decisions.total, 1, 'pipeline: preview decisions total');
 
       // Requirements in preview
       assert.deepStrictEqual(preview.requirements.active, 1, 'pipeline: preview requirements active');
@@ -342,6 +355,39 @@ test('Full pipeline: parse → transform → preview → write → deriveState',
     }
 });
 
+test('Full pipeline: legacy requirement IDs import into DB with canonical IDs', async () => {
+    const base = createCompleteFixture(SAMPLE_REQUIREMENTS_LEGACY_IDS);
+    const writeTarget = mkdtempSync(join(tmpdir(), 'gsd-cmd-legacy-reqs-'));
+    try {
+      const parsed = await parsePlanningDirectory(join(base, '.planning'));
+      const project = transformToGSD(parsed);
+      const preview = generatePreview(project);
+
+      assert.deepStrictEqual(
+        project.requirements.map((req) => req.id),
+        ['R001', 'R002', 'R003', 'R004'],
+        'legacy-reqs: transform assigns canonical R IDs',
+      );
+      assert.ok(
+        project.requirements[0]?.description.includes('Legacy ID: CORE-PIPELINE'),
+        'legacy-reqs: original ID survives in migrated requirement content',
+      );
+
+      await writeGSDDirectory(project, writeTarget);
+      const imported = await importWrittenMigrationToDb(writeTarget, preview);
+      const counts = getRequirementCounts();
+
+      assert.deepStrictEqual(imported.decisions, 1, 'legacy-reqs: DB import includes migrated decisions');
+      assert.deepStrictEqual(imported.requirements, 4, 'legacy-reqs: DB import count matches preview');
+      assert.ok(getDecisionById('D001') !== null, 'legacy-reqs: migrated decision is queryable');
+      assert.deepStrictEqual(counts.total, 4, 'legacy-reqs: DB stores all migrated requirements');
+    } finally {
+      closeDatabase();
+      rmSync(base, { recursive: true, force: true });
+      rmSync(writeTarget, { recursive: true, force: true });
+    }
+});
+
   // ─── Test 6: .gsd/ exists detection ────────────────────────────────────
 
 test('.gsd/ exists detection', () => {
@@ -357,4 +403,3 @@ test('.gsd/ exists detection', () => {
       rmSync(base, { recursive: true, force: true });
     }
 });
-

package/src/resources/extensions/gsd/tests/integration/parallel-merge.test.ts

@@ -85,7 +85,49 @@ function cleanup(dir: string): void {
   try { rmSync(dir, { recursive: true, force: true }); } catch { /* */ }
 }
 
-/** Set up a milestone roadmap file in .gsd/milestones/<MID>/ */
+/**
+ * Write `.gsd/preferences.md` with `git.isolation: branch` so the merge
+ * routes through the standalone Lifecycle merge body in branch mode rather
+ * than falling through `getIsolationMode === "none"` to a skipped result.
+ *
+ * Parallel-merge in production runs with `git.isolation: worktree` and a
+ * real auto-worktree on disk; these integration tests use branch mode as a
+ * simpler equivalent that exercises the same merge path without requiring
+ * `git worktree add` setup. ADR-016 phase 2 / A2 routes parallel-merge
+ * through the Module, which performs mode detection — branch mode keeps
+ * the test simple while still going through the Module.
+ */
+function setupBranchIsolation(repo: string): void {
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(repo, ".gsd", "preferences.md"),
+    "## Git\n- isolation: branch\n",
+  );
+  // Commit on main so subsequent `git checkout main` restores the file.
+  // Without this commit, `createMilestoneBranch`'s checkout dance carries
+  // the uncommitted file onto the milestone branch and back-checking-out
+  // main loses the preference file before `mergeMilestoneStandalone`
+  // reads it (ADR-016 phase 2 / A2).
+  try {
+    run("git add .gsd/preferences.md", repo);
+    run('git commit -m "test: add branch-isolation preferences"', repo);
+  } catch { /* file may already be committed */ }
+}
+
+/**
+ * Set up a milestone roadmap file in .gsd/milestones/<MID>/ AND commit it on
+ * the current branch.
+ *
+ * The commit is required after ADR-016 phase 2 / A2 because the standalone
+ * Module-level merge (now used by parallel-merge) reads the roadmap _after_
+ * its branch checkout. Uncommitted roadmaps on `main` survive a checkout
+ * for the first milestone but get committed onto the milestone branch by
+ * `autoCommitDirtyState`, which then doesn't reproduce them on the next
+ * milestone branch's checkout.
+ *
+ * Real production runs commit roadmap files on each milestone branch as
+ * part of the unit's normal output; tests should mirror that.
+ */
 function setupRoadmap(repo: string, mid: string, title: string, slices: string[]): void {
   const dir = join(repo, ".gsd", "milestones", mid);
   mkdirSync(dir, { recursive: true });
@@ -94,6 +136,10 @@ function setupRoadmap(repo: string, mid: string, title: string, slices: string[]
     join(dir, `${mid}-ROADMAP.md`),
     `# ${mid}: ${title}\n\n## Slices\n${sliceLines}\n`,
   );
+  try {
+    run(`git add .gsd/milestones/${mid}/${mid}-ROADMAP.md`, repo);
+    run(`git commit -m "test: add roadmap for ${mid}"`, repo);
+  } catch { /* file may already be committed; not a git repo; etc. */ }
 }
 
 /** Create a milestone branch with file changes, then return to main. */
@@ -234,15 +280,36 @@ test("formatMergeResults — mixed results", () => {
 // ═══════════════════════════════════════════════════════════════════════════════
 
 test("mergeCompletedMilestone — missing roadmap returns error result", async () => {
-  const base = join(tmpdir(), `parallel-merge-noroadmap-${Date.now()}`);
-  mkdirSync(join(base, ".gsd"), { recursive: true });
+  const savedCwd = process.cwd();
+  // Use a real git repo so the standalone's branch-mode merge body can
+  // call `getCurrentBranch` without throwing. The roadmap is intentionally
+  // omitted so the merge ends in the "no-roadmap" branch.
+  const repo = createTempRepo();
   try {
-    const result = await mergeCompletedMilestone(base, "M999");
+    setupBranchIsolation(repo);
+    // Create a milestone branch but no roadmap file — this is the
+    // condition under test.
+    run("git checkout -b milestone/M999", repo);
+    writeFileSync(join(repo, "feature.ts"), "export {};\n");
+    run("git add .", repo);
+    run('git commit -m "M999 feature"', repo);
+    run("git checkout main", repo);
+
+    process.chdir(repo);
+    const result = await mergeCompletedMilestone(repo, "M999");
+
     assert.equal(result.success, false);
-    assert.ok(result.error?.includes("No roadmap found") || result.error?.includes("Could not read"));
+    // A2 widens the error surface vs. the legacy bypass: the standalone
+    // routes through the Module, so the no-roadmap path teardowns the
+    // (non-existent) worktree branch and surfaces a typed failure.
+    // What matters is `success: false`; the exact wording can shift as
+    // the standalone evolves.
+    assert.ok(result.error, "should report a non-empty error");
     assert.equal(result.milestoneId, "M999");
   } finally {
-    cleanup(base);
+    process.chdir(savedCwd);
+    try { run("git reset --hard HEAD", repo); } catch { /* */ }
+    cleanup(repo);
   }
 });
 
@@ -251,14 +318,24 @@ test("mergeCompletedMilestone — clean merge, session status cleaned up", async
   const repo = createTempRepo();
 
   try {
+    // Route the merge through the Module's branch-mode path. With default
+    // `isolation: none`, the standalone returns `{ mode: "skipped" }`
+    // (ADR-016 phase 2 / A2). Branch mode exercises the same Module-level
+    // merge body without requiring an on-disk auto-worktree.
+    setupBranchIsolation(repo);
+
+    // Set up roadmap on main BEFORE the milestone branch is created so the
+    // roadmap is in the milestone branch's history. After A2, the standalone
+    // reads the roadmap _inside_ the merge body (after the branch checkout)
+    // — the file must therefore exist in the milestone branch's tree, not
+    // just as an uncommitted file on main.
+    setupRoadmap(repo, "M010", "Auth System", ["S01: JWT module"]);
+
     // Create milestone branch with a new file
     createMilestoneBranch(repo, "M010", [
       { name: "auth.ts", content: "export const auth = true;\n" },
     ]);
 
-    // Set up roadmap
-    setupRoadmap(repo, "M010", "Auth System", ["S01: JWT module"]);
-
     // Write session status to verify cleanup
     writeSessionStatus(repo, {
       milestoneId: "M010",
@@ -309,6 +386,11 @@ test("mergeCompletedMilestone — conflict returns structured error with file li
   const repo = createTempRepo();
 
   try {
+    setupBranchIsolation(repo);
+
+    // Roadmap committed on main BEFORE branching — see "clean merge" test.
+    setupRoadmap(repo, "M020", "Conflict Test", ["S01: Conflict scenario"]);
+
     // Create milestone branch that modifies README.md
     run("git checkout -b milestone/M020", repo);
     writeFileSync(join(repo, "README.md"), "# M020 version\n");
@@ -321,9 +403,6 @@ test("mergeCompletedMilestone — conflict returns structured error with file li
     run("git add .", repo);
     run('git commit -m "main changes README"', repo);
 
-    // Set up roadmap
-    setupRoadmap(repo, "M020", "Conflict Test", ["S01: Conflict scenario"]);
-
     process.chdir(repo);
     const result = await mergeCompletedMilestone(repo, "M020");
 
@@ -350,6 +429,12 @@ test("mergeAllCompleted — merges in sequential order", async () => {
   const repo = createTempRepo();
 
   try {
+    setupBranchIsolation(repo);
+
+    // Roadmaps committed on main BEFORE branching — see "clean merge" test.
+    setupRoadmap(repo, "M001", "Auth", ["S01: Auth module"]);
+    setupRoadmap(repo, "M002", "Dashboard", ["S01: Dashboard module"]);
+
     // M001: adds auth.ts
     createMilestoneBranch(repo, "M001", [
       { name: "auth.ts", content: "export const auth = true;\n" },
@@ -359,9 +444,6 @@ test("mergeAllCompleted — merges in sequential order", async () => {
       { name: "dashboard.ts", content: "export const dash = true;\n" },
     ]);
 
-    setupRoadmap(repo, "M001", "Auth", ["S01: Auth module"]);
-    setupRoadmap(repo, "M002", "Dashboard", ["S01: Dashboard module"]);
-
     const workers = [
       makeWorker({ milestoneId: "M002", startedAt: 100 }),
       makeWorker({ milestoneId: "M001", startedAt: 200 }),
@@ -373,9 +455,9 @@ test("mergeAllCompleted — merges in sequential order", async () => {
     // Both should succeed
     assert.equal(results.length, 2, "should have two results");
     assert.equal(results[0]!.milestoneId, "M001", "M001 merged first (sequential)");
-    assert.equal(results[0]!.success, true, "M001 should succeed");
+    assert.equal(results[0]!.success, true, `M001 should succeed: ${results[0]!.error}`);
     assert.equal(results[1]!.milestoneId, "M002", "M002 merged second");
-    assert.equal(results[1]!.success, true, "M002 should succeed");
+    assert.equal(results[1]!.success, true, `M002 should succeed: ${results[1]!.error}`);
 
     // Both files on main
     assert.ok(existsSync(join(repo, "auth.ts")), "auth.ts on main");
@@ -391,6 +473,12 @@ test("mergeAllCompleted — stops on first conflict, skips later milestones", as
   const repo = createTempRepo();
 
   try {
+    setupBranchIsolation(repo);
+
+    // Roadmaps committed on main BEFORE branching — see "clean merge" test.
+    setupRoadmap(repo, "M001", "Conflict milestone", ["S01: Conflict test"]);
+    setupRoadmap(repo, "M002", "Clean milestone", ["S01: Clean test"]);
+
     // M001: modifies README.md (will conflict with main)
     run("git checkout -b milestone/M001", repo);
     writeFileSync(join(repo, "README.md"), "# M001 version\n");
@@ -408,9 +496,6 @@ test("mergeAllCompleted — stops on first conflict, skips later milestones", as
     run("git add .", repo);
     run('git commit -m "main diverges README"', repo);
 
-    setupRoadmap(repo, "M001", "Conflict milestone", ["S01: Conflict test"]);
-    setupRoadmap(repo, "M002", "Clean milestone", ["S01: Clean test"]);
-
     const workers = [
       makeWorker({ milestoneId: "M001" }),
       makeWorker({ milestoneId: "M002" }),
@@ -442,6 +527,12 @@ test("mergeAllCompleted — by-completion order respects startedAt", async () =>
   const repo = createTempRepo();
 
   try {
+    setupBranchIsolation(repo);
+
+    // Roadmaps committed on main BEFORE branching — see "clean merge" test.
+    setupRoadmap(repo, "M001", "Auth", ["S01: Auth module"]);
+    setupRoadmap(repo, "M002", "Feature", ["S01: Feature module"]);
+
     // M001: adds auth.ts (started later)
     createMilestoneBranch(repo, "M001", [
       { name: "auth.ts", content: "export const auth = true;\n" },
@@ -451,9 +542,6 @@ test("mergeAllCompleted — by-completion order respects startedAt", async () =>
       { name: "feature.ts", content: "export const feature = true;\n" },
     ]);
 
-    setupRoadmap(repo, "M001", "Auth", ["S01: Auth module"]);
-    setupRoadmap(repo, "M002", "Feature", ["S01: Feature module"]);
-
     const workers = [
       makeWorker({ milestoneId: "M001", startedAt: 2000 }),
       makeWorker({ milestoneId: "M002", startedAt: 1000 }),
@@ -549,11 +637,15 @@ test("mergeAllCompleted — discovers DB-complete milestones when workers show e
   const repo = createTempRepo();
 
   try {
+    setupBranchIsolation(repo);
+
+    // Roadmap committed on main BEFORE branching — see "clean merge" test.
+    setupRoadmap(repo, "M011", "Feature System", ["S01: Feature module"]);
+
     // Create milestone branch with a file
     createMilestoneBranch(repo, "M011", [
       { name: "feature.ts", content: "export const feature = true;\n" },
     ]);
-    setupRoadmap(repo, "M011", "Feature System", ["S01: Feature module"]);
 
     // Set up canonical DB showing M011 is complete
     setupCanonicalDbWithWorktree(repo, "M011");

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

@@ -75,7 +75,6 @@ function makeMockDeps(
     pruneQueueOrder: () => {},
     isInAutoWorktree: () => false,
     shouldUseWorktreeIsolation: () => false,
-    mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: false }),
     teardownAutoWorktree: () => {},
     createAutoWorktree: () => "/tmp/wt",
     captureIntegrationBranch: () => {},