gsd-pi 2.81.0 → 2.82.0-dev.20138ae42

package/src/resources/extensions/gsd/tests/load-knowledge-block-rules-only.test.ts

@@ -0,0 +1,209 @@
+// ADR-013 follow-up — loadKnowledgeBlock injects only Rules from project
+// KNOWLEDGE.md to avoid duplicating Patterns + Lessons content already
+// injected via loadMemoryBlock (Stage 2b cutover).
+//
+// Global KNOWLEDGE.md (~/.gsd/agent/KNOWLEDGE.md) is NOT memory-projected
+// and still passes through with all three sections intact.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { loadKnowledgeBlock } from "../bootstrap/system-context.ts";
+import { extractIntroAndRules } from "../knowledge-parser.ts";
+
+function makeTmpProject(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-knowledge-rules-only-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function makeTmpHome(): string {
+  const home = mkdtempSync(join(tmpdir(), "gsd-knowledge-home-"));
+  mkdirSync(join(home, "agent"), { recursive: true });
+  return home;
+}
+
+function cleanup(...dirs: string[]): void {
+  for (const dir of dirs) {
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {
+      /* noop */
+    }
+  }
+}
+
+const FULL_KNOWLEDGE = `# Project Knowledge
+
+Append-only register of project-specific rules, patterns, and lessons learned.
+
+## Rules
+
+| # | Scope | Rule | Why | Added |
+|---|-------|------|-----|-------|
+| K001 | project | All timestamps in UTC | clarity | 2026-01-01 |
+| K002 | M001 | Never trust user input | safety | 2026-01-02 |
+
+## Patterns
+
+| # | Pattern | Where | Notes |
+|---|---------|-------|-------|
+| P001 | Repository pattern | services/ | guards |
+
+## Lessons Learned
+
+| # | What Happened | Root Cause | Fix | Scope |
+|---|--------------|------------|-----|-------|
+| L001 | Cache poisoning | reused key | versioned key | project |
+`;
+
+// ─── extractIntroAndRules unit tests ───────────────────────────────────────
+
+test("extractIntroAndRules keeps intro + Rules, drops Patterns + Lessons", () => {
+  const out = extractIntroAndRules(FULL_KNOWLEDGE);
+  assert.match(out, /# Project Knowledge/);
+  assert.match(out, /## Rules/);
+  assert.match(out, /\| K001 \| project \| All timestamps in UTC/);
+  assert.match(out, /\| K002 \| M001 \| Never trust user input/);
+
+  assert.equal(out.includes("## Patterns"), false, "Patterns heading must be dropped");
+  assert.equal(out.includes("P001"), false, "Pattern rows must be dropped");
+  assert.equal(out.includes("## Lessons Learned"), false, "Lessons heading must be dropped");
+  assert.equal(out.includes("L001"), false, "Lesson rows must be dropped");
+});
+
+test("extractIntroAndRules returns content unchanged when no `## Rules` heading", () => {
+  const content = "# Notes\n\nfreeform content without standard sections\n";
+  assert.equal(extractIntroAndRules(content), content);
+});
+
+test("extractIntroAndRules returns empty for empty input", () => {
+  assert.equal(extractIntroAndRules(""), "");
+  assert.equal(extractIntroAndRules("   \n\n"), "");
+});
+
+test("extractIntroAndRules handles Rules as the only section (no Patterns/Lessons to drop)", () => {
+  const content = `# Project Knowledge
+
+## Rules
+
+| # | Scope | Rule | Why | Added |
+|---|-------|------|-----|-------|
+| K001 | project | only rule | reason | 2026-01-01 |
+`;
+  const out = extractIntroAndRules(content);
+  assert.match(out, /K001/);
+  assert.match(out, /## Rules/);
+});
+
+// ─── loadKnowledgeBlock integration ────────────────────────────────────────
+
+test("loadKnowledgeBlock trims project KNOWLEDGE.md to intro + Rules", () => {
+  const base = makeTmpProject();
+  const home = makeTmpHome();
+  try {
+    writeFileSync(join(base, ".gsd", "KNOWLEDGE.md"), FULL_KNOWLEDGE, "utf-8");
+    const { block } = loadKnowledgeBlock(home, base);
+
+    assert.match(block, /## Project Knowledge/);
+    assert.match(block, /K001/);
+    assert.match(block, /K002/);
+    assert.equal(block.includes("P001"), false, "project Patterns must not appear in the block");
+    assert.equal(block.includes("L001"), false, "project Lessons must not appear in the block");
+    assert.equal(block.includes("## Patterns"), false);
+    assert.equal(block.includes("## Lessons Learned"), false);
+  } finally {
+    cleanup(base, home);
+  }
+});
+
+test("loadKnowledgeBlock leaves global KNOWLEDGE.md intact (no memory projection there)", () => {
+  const base = makeTmpProject();
+  const home = makeTmpHome();
+  try {
+    writeFileSync(join(home, "agent", "KNOWLEDGE.md"), FULL_KNOWLEDGE, "utf-8");
+    const { block, globalSizeKb } = loadKnowledgeBlock(home, base);
+
+    assert.match(block, /## Global Knowledge/);
+    // Global is full-fidelity: all three sections intact.
+    assert.match(block, /K001/);
+    assert.match(block, /P001/);
+    assert.match(block, /L001/);
+    assert.match(block, /## Patterns/);
+    assert.match(block, /## Lessons Learned/);
+    assert.ok(globalSizeKb > 0, "globalSizeKb should report the global file size");
+  } finally {
+    cleanup(base, home);
+  }
+});
+
+test("loadKnowledgeBlock with both global and project: global keeps full content, project trimmed", () => {
+  const base = makeTmpProject();
+  const home = makeTmpHome();
+  try {
+    writeFileSync(join(home, "agent", "KNOWLEDGE.md"), FULL_KNOWLEDGE, "utf-8");
+    writeFileSync(join(base, ".gsd", "KNOWLEDGE.md"), FULL_KNOWLEDGE, "utf-8");
+    const { block } = loadKnowledgeBlock(home, base);
+
+    // Both sections present.
+    assert.match(block, /## Global Knowledge/);
+    assert.match(block, /## Project Knowledge/);
+
+    // Project's Patterns/Lessons headings must be gone. But global keeps
+    // them, so a substring count of e.g. "## Patterns" should equal 1.
+    const patternsCount = (block.match(/## Patterns/g) ?? []).length;
+    const lessonsCount = (block.match(/## Lessons Learned/g) ?? []).length;
+    assert.equal(patternsCount, 1, "Patterns heading appears exactly once (in global)");
+    assert.equal(lessonsCount, 1, "Lessons heading appears exactly once (in global)");
+
+    // K/P/L rows: K appears twice (global + project), P/L appear once (global).
+    const k001Count = (block.match(/K001/g) ?? []).length;
+    const p001Count = (block.match(/P001/g) ?? []).length;
+    const l001Count = (block.match(/L001/g) ?? []).length;
+    assert.equal(k001Count, 2, "K001 in both global and project");
+    assert.equal(p001Count, 1, "P001 only in global");
+    assert.equal(l001Count, 1, "L001 only in global");
+  } finally {
+    cleanup(base, home);
+  }
+});
+
+test("loadKnowledgeBlock returns empty block when neither file exists", () => {
+  const base = makeTmpProject();
+  const home = makeTmpHome();
+  try {
+    const result = loadKnowledgeBlock(home, base);
+    assert.equal(result.block, "");
+    assert.equal(result.globalSizeKb, 0);
+  } finally {
+    cleanup(base, home);
+  }
+});
+
+test("loadKnowledgeBlock injects only Rules when project KNOWLEDGE.md has no Patterns/Lessons", () => {
+  const base = makeTmpProject();
+  const home = makeTmpHome();
+  try {
+    writeFileSync(
+      join(base, ".gsd", "KNOWLEDGE.md"),
+      `# Project Knowledge
+
+## Rules
+
+| # | Scope | Rule | Why | Added |
+|---|-------|------|-----|-------|
+| K001 | project | rule one | reason | 2026-01-01 |
+`,
+      "utf-8",
+    );
+    const { block } = loadKnowledgeBlock(home, base);
+    assert.match(block, /K001/);
+    // Block heading reflects the new contract.
+    assert.match(block, /Rules from KNOWLEDGE\.md/);
+  } finally {
+    cleanup(base, home);
+  }
+});

package/src/resources/extensions/gsd/tests/markdown-renderer.test.ts

@@ -24,8 +24,8 @@ import {
   renderPlanFromDb,
   renderTaskPlanFromDb,
   detectStaleRenders,
-  repairStaleRenders,
 } from '../markdown-renderer.ts';
+import { repairStaleRenders } from '../state-reconciliation/drift/stale-render.ts';
 import {
   parseRoadmap,
   parsePlan,

package/src/resources/extensions/gsd/tests/memory-consolidation-scanner.test.ts

@@ -0,0 +1,316 @@
+// GSD-2 — ADR-013 Phase 6 preflight scanner tests.
+//
+// Locks in the four states the scanner must distinguish:
+//   1. Clean — no gaps, no warning emitted.
+//   2. Decisions gap — active decisions without a migrated memory.
+//   3. KNOWLEDGE.md gap — rows in the legacy markdown without migration.
+//   4. Both gaps — combined summary message.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertDecision,
+} from "../gsd-db.ts";
+import { createMemory } from "../memory-store.ts";
+import {
+  _resetNotificationStore,
+  initNotificationStore,
+  readNotifications,
+} from "../notification-store.ts";
+import {
+  parseKnowledgeRows,
+  reportConsolidationGaps,
+  scanConsolidationGaps,
+} from "../memory-consolidation-scanner.ts";
+
+function makeTmpBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-consolidation-scan-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  initNotificationStore(base);
+  return base;
+}
+
+function cleanup(base: string): void {
+  try {
+    closeDatabase();
+  } catch {
+    /* noop */
+  }
+  _resetNotificationStore();
+  try {
+    rmSync(base, { recursive: true, force: true });
+  } catch {
+    /* noop */
+  }
+}
+
+function writeKnowledgeMd(base: string, body: string): void {
+  writeFileSync(join(base, ".gsd", "KNOWLEDGE.md"), body, "utf-8");
+}
+
+// ─── parseKnowledgeRows ─────────────────────────────────────────────────────
+
+test("parseKnowledgeRows extracts entries from the three legacy tables", () => {
+  const content = `# Project Knowledge
+
+Append-only register.
+
+## Rules
+
+| # | Scope | Rule | Why | Added |
+|---|-------|------|-----|-------|
+| K001 | project | Always pin SQLite version | corruption | 2026-01-01 |
+| K002 | M001 | Use UTC | clarity | 2026-01-02 |
+
+## Patterns
+
+| # | Pattern | Where | Notes |
+|---|---------|-------|-------|
+| P001 | Repository pattern | services/ | guards |
+
+## Lessons Learned
+
+| # | What Happened | Root Cause | Fix | Scope |
+|---|--------------|------------|-----|-------|
+| L001 | Cache poisoning | reused key | versioned key | project |
+`;
+
+  const rows = parseKnowledgeRows(content);
+  assert.equal(rows.length, 4, "should extract 2 rules + 1 pattern + 1 lesson");
+  assert.deepEqual(
+    rows.map((r) => ({ table: r.table, id: r.id })),
+    [
+      { table: "rules", id: "K001" },
+      { table: "rules", id: "K002" },
+      { table: "patterns", id: "P001" },
+      { table: "lessons", id: "L001" },
+    ],
+  );
+});
+
+test("parseKnowledgeRows skips header/separator rows and unrecognized sections", () => {
+  const content = `## Rules
+
+| # | Scope | Rule | Why | Added |
+|---|-------|------|-----|-------|
+
+## Other Section
+
+| # | Foo |
+|---|-----|
+| X999 | bar |
+`;
+
+  // Empty Rules table → 0 rows. Unrecognized "Other Section" is ignored.
+  assert.equal(parseKnowledgeRows(content).length, 0);
+});
+
+test("parseKnowledgeRows returns empty for empty input", () => {
+  assert.deepEqual(parseKnowledgeRows(""), []);
+  assert.deepEqual(parseKnowledgeRows("   \n\n"), []);
+});
+
+// ─── scanConsolidationGaps ─────────────────────────────────────────────────
+
+test("scanConsolidationGaps reports zero gaps when both surfaces are empty", () => {
+  const base = makeTmpBase();
+  try {
+    const report = scanConsolidationGaps(base);
+    assert.equal(report.decisions.total, 0);
+    assert.equal(report.knowledge.total, 0);
+    assert.equal(report.totalGaps, 0);
+    assert.match(report.summary, /all decisions and KNOWLEDGE\.md rows are in memories/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("scanConsolidationGaps detects unmigrated decisions and ignores migrated ones", () => {
+  const base = makeTmpBase();
+  try {
+    insertDecision({
+      id: "D001",
+      when_context: "2026-01-01",
+      scope: "M001",
+      decision: "Decision needing migration",
+      choice: "A",
+      rationale: "because",
+      revisable: "yes",
+      made_by: "agent",
+      superseded_by: null,
+    });
+    insertDecision({
+      id: "D002",
+      when_context: "2026-01-02",
+      scope: "M001",
+      decision: "Already migrated decision",
+      choice: "B",
+      rationale: "covered",
+      revisable: "yes",
+      made_by: "agent",
+      superseded_by: null,
+    });
+    // D002 has a corresponding migrated memory; D001 doesn't.
+    createMemory({
+      category: "architecture",
+      content: "Already migrated decision Chose: B. Rationale: covered.",
+      scope: "M001",
+      structuredFields: { sourceDecisionId: "D002" },
+    });
+
+    const report = scanConsolidationGaps(base);
+    assert.equal(report.decisions.total, 2);
+    assert.equal(report.decisions.migrated, 1);
+    assert.equal(report.decisions.unmigrated, 1);
+    assert.equal(report.decisions.samples.length, 1);
+    assert.equal(report.decisions.samples[0]?.id, "D001");
+    assert.equal(report.totalGaps, 1);
+    assert.match(report.summary, /1 of 2 active decisions/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("scanConsolidationGaps skips superseded decisions (historical record only)", () => {
+  const base = makeTmpBase();
+  try {
+    insertDecision({
+      id: "D001",
+      when_context: "2026-01-01",
+      scope: "M001",
+      decision: "Superseded — does not need migration",
+      choice: "A",
+      rationale: "old",
+      revisable: "yes",
+      made_by: "agent",
+      superseded_by: "D002",
+    });
+
+    const report = scanConsolidationGaps(base);
+    assert.equal(report.decisions.total, 0, "superseded decisions excluded from active count");
+    assert.equal(report.totalGaps, 0);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("scanConsolidationGaps detects unmigrated KNOWLEDGE.md rows by table", () => {
+  const base = makeTmpBase();
+  try {
+    writeKnowledgeMd(
+      base,
+      `## Rules
+
+| # | Scope | Rule | Why | Added |
+|---|-------|------|-----|-------|
+| K001 | project | Pin SQLite | corruption | 2026-01-01 |
+| K002 | M001 | UTC only | clarity | 2026-01-02 |
+
+## Patterns
+
+| # | Pattern | Where | Notes |
+|---|---------|-------|-------|
+| P001 | Repository | services/ | guards |
+
+## Lessons Learned
+
+| # | What Happened | Root Cause | Fix | Scope |
+|---|--------------|------------|-----|-------|
+`,
+    );
+
+    const report = scanConsolidationGaps(base);
+    assert.equal(report.knowledge.total, 3);
+    assert.equal(report.knowledge.unmigrated, 3, "no sourceKnowledgeId markers exist yet");
+    assert.deepEqual(report.knowledge.byTable, { rules: 2, patterns: 1, lessons: 0 });
+    assert.equal(report.knowledge.samples.length, 3);
+    assert.equal(report.totalGaps, 3);
+    assert.match(report.summary, /3 of 3 KNOWLEDGE\.md rows/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("scanConsolidationGaps combines decisions and KNOWLEDGE.md gaps in summary", () => {
+  const base = makeTmpBase();
+  try {
+    insertDecision({
+      id: "D001",
+      when_context: "2026-01-01",
+      scope: "M001",
+      decision: "Unmigrated decision",
+      choice: "A",
+      rationale: "x",
+      revisable: "yes",
+      made_by: "agent",
+      superseded_by: null,
+    });
+    writeKnowledgeMd(
+      base,
+      `## Rules
+
+| # | Scope | Rule | Why | Added |
+|---|-------|------|-----|-------|
+| K001 | project | Some rule | reason | 2026-01-01 |
+`,
+    );
+
+    const report = scanConsolidationGaps(base);
+    assert.equal(report.totalGaps, 2);
+    assert.match(report.summary, /1 of 1 active decisions/);
+    assert.match(report.summary, /1 of 1 KNOWLEDGE\.md rows/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── reportConsolidationGaps ───────────────────────────────────────────────
+
+test("reportConsolidationGaps emits a notification + warning when gaps exist", () => {
+  const base = makeTmpBase();
+  try {
+    insertDecision({
+      id: "D001",
+      when_context: "2026-01-01",
+      scope: "M001",
+      decision: "Unmigrated",
+      choice: "A",
+      rationale: "x",
+      revisable: "yes",
+      made_by: "agent",
+      superseded_by: null,
+    });
+
+    const report = reportConsolidationGaps(base);
+    assert.ok(report);
+    assert.equal(report.totalGaps, 1);
+
+    const notifications = readNotifications(base);
+    const gapNotifs = notifications.filter((n) => n.message.includes("Memory consolidation"));
+    assert.ok(gapNotifs.length >= 1, "a consolidation notification should be persisted");
+    assert.equal(gapNotifs[0]?.severity, "warning");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("reportConsolidationGaps stays silent when there are no gaps", () => {
+  const base = makeTmpBase();
+  try {
+    const report = reportConsolidationGaps(base);
+    assert.ok(report);
+    assert.equal(report.totalGaps, 0);
+    const notifications = readNotifications(base);
+    const gapNotifs = notifications.filter((n) => n.message.includes("not yet in memories"));
+    assert.equal(gapNotifs.length, 0, "no warning notification when clean");
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/merge-conflict-stops-loop.test.ts

@@ -29,20 +29,25 @@
 
 import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, mkdirSync } from "node:fs";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { WorktreeLifecycle, type WorktreeLifecycleDeps } from "../worktree-lifecycle.ts";
+import {
+  WorktreeLifecycle,
+  type WorktreeLifecycleDeps,
+  type WorktreeLifecycleTestOverrides,
+} from "../worktree-lifecycle.ts";
 import { WorktreeStateProjection } from "../worktree-state-projection.ts";
 import { MergeConflictError } from "../git-service.ts";
 import type { AutoSession } from "../auto/session.ts";
 
-// Test-local: LegacyTestDeps had three fields Lifecycle does not need
-// (shouldUseWorktreeIsolation, syncWorktreeStateBack, captureIntegrationBranch).
-// Permit them in test fixtures so existing override patterns keep working —
-// Lifecycle ignores the extras via structural typing.
-type LegacyTestDeps = WorktreeLifecycleDeps & {
+// Test-local: extras the WorktreeResolver-era fixture passed but Lifecycle
+// does not need (shouldUseWorktreeIsolation, syncWorktreeStateBack,
+// captureIntegrationBranch). Lifecycle ignores them via structural typing.
+// The C1-C4-inlined primitive overrides come from
+// `WorktreeLifecycleTestOverrides`, the test seam exported by the Module.
+type LegacyTestDeps = WorktreeLifecycleDeps & WorktreeLifecycleTestOverrides & {
   shouldUseWorktreeIsolation?: () => boolean;
   syncWorktreeStateBack?: (
     mainBasePath: string,
@@ -50,6 +55,7 @@ type LegacyTestDeps = WorktreeLifecycleDeps & {
     milestoneId: string,
   ) => { synced: string[] };
   captureIntegrationBranch?: (basePath: string, mid: string | undefined) => void;
+  GitServiceImpl?: new (basePath: string, gitConfig: unknown) => unknown;
 };
 
 /**
@@ -96,7 +102,12 @@ function makeDeps(
     enterAutoWorktree: () => "",
     enterBranchModeForMilestone: () => undefined,
     getAutoWorktreePath: () => null,
-    autoCommitCurrentBranch: () => undefined,
+    autoCommitCurrentBranch: (
+      _basePath: string,
+      _unitType: string,
+      _unitId: string,
+      _taskContext?: unknown,
+    ) => null,
     getCurrentBranch: () => "worktree/M001",
     checkoutBranch: () => undefined,
     autoWorktreeBranch: (mid: string) => `worktree/${mid}`,
@@ -109,6 +120,8 @@ function makeDeps(
     invalidateAllCaches: () => undefined,
     captureIntegrationBranch: () => undefined,
     worktreeProjection: new WorktreeStateProjection(),
+    // ADR-016 phase 2 / C4 (#5627): GitServiceImpl constructor → factory.
+    gitServiceFactory: () => ({}) as never,
     ...overrides,
   };
 }
@@ -128,14 +141,36 @@ function makeNotifyCtx(): {
 
 describe("WorktreeResolver.mergeAndExit re-throws MergeConflictError (#2330)", () => {
   let baseDir: string;
+  const savedCwd = process.cwd();
 
   beforeEach(() => {
     baseDir = mkdtempSync(join(tmpdir(), "merge-conflict-stops-loop-"));
     // Fake out a milestone directory so mergeAndExit reaches mergeMilestoneToMain.
     mkdirSync(join(baseDir, ".gsd", "milestones", "M001"), { recursive: true });
+    // ADR-016 phase 2 / C1 (#5624): worktree-lifecycle.ts now calls
+    // node:fs.readFileSync directly (the dep was retired), so the roadmap
+    // file must exist on disk for the test to reach mergeMilestoneToMain.
+    writeFileSync(
+      join(baseDir, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+      "# M001\n",
+    );
+    // ADR-016 phase 2 / C3 (#5626): `getIsolationMode` is also inlined.
+    // Without explicit isolation preferences the mode defaults to "none"
+    // and the merge short-circuits before the test's mocked
+    // `mergeMilestoneToMain` is reached. Write a preferences file so the
+    // standalone routes through worktree-mode merge.
+    writeFileSync(
+      join(baseDir, ".gsd", "preferences.md"),
+      "## Git\n- isolation: worktree\n",
+    );
   });
 
   afterEach(() => {
+    // ADR-016 phase 2 / C2 (#5625): the inlined `mergeMilestoneStandalone`
+    // chdirs into the project root before the merge body runs. Restore
+    // cwd before deleting `baseDir` so the next test's `process.cwd()`
+    // doesn't fail with ENOENT.
+    try { process.chdir(savedCwd); } catch { /* best-effort */ }
     try {
       rmSync(baseDir, { recursive: true, force: true });
     } catch {
@@ -147,7 +182,7 @@ describe("WorktreeResolver.mergeAndExit re-throws MergeConflictError (#2330)", (
     const conflicted = ["src/feature.ts", "README.md"];
     const roadmapPath = join(baseDir, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
     const deps = makeDeps({
-      resolveMilestoneFile: (_base, _mid, type) =>
+      resolveMilestoneFile: (_base: string, _mid: string, type: string) =>
         type === "ROADMAP" ? roadmapPath : null,
       readFileSync: () => "# M001\n",
       mergeMilestoneToMain: () => {
@@ -178,7 +213,7 @@ describe("WorktreeResolver.mergeAndExit re-throws MergeConflictError (#2330)", (
     const roadmapPath = join(baseDir, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
     class FakePermError extends Error {}
     const deps = makeDeps({
-      resolveMilestoneFile: (_base, _mid, type) =>
+      resolveMilestoneFile: (_base: string, _mid: string, type: string) =>
         type === "ROADMAP" ? roadmapPath : null,
       readFileSync: () => "# M001\n",
       mergeMilestoneToMain: () => {
@@ -204,7 +239,7 @@ describe("WorktreeResolver.mergeAndExit re-throws MergeConflictError (#2330)", (
   test("successful merge does not throw", () => {
     const roadmapPath = join(baseDir, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
     const deps = makeDeps({
-      resolveMilestoneFile: (_base, _mid, type) =>
+      resolveMilestoneFile: (_base: string, _mid: string, type: string) =>
         type === "ROADMAP" ? roadmapPath : null,
       readFileSync: () => "# M001\n",
       mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),

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

@@ -497,6 +497,7 @@ test('Scenario 11: Requirements edge cases', () => {
       makeRequirement('', 'Another No ID', 'validated'),
       makeRequirement('R005', 'Has ID', 'something-weird'),
       makeRequirement('R006', 'Deferred One', 'DEFERRED'),
+      makeRequirement('AUTH-7', 'Legacy ID', 'active'),
     ],
     phases: {
       '1-req-edge': makePhase('1-req-edge', 1, 'req-edge'),
@@ -510,6 +511,8 @@ test('Scenario 11: Requirements edge cases', () => {
   assert.deepStrictEqual(result.requirements[2]?.id, 'R005', 'req-edge: existing id preserved');
   assert.deepStrictEqual(result.requirements[2]?.status, 'active', 'req-edge: unknown status normalized to active');
   assert.deepStrictEqual(result.requirements[3]?.status, 'deferred', 'req-edge: uppercase DEFERRED normalized');
+  assert.deepStrictEqual(result.requirements[4]?.id, 'R003', 'req-edge: non-R legacy id gets next canonical id');
+  assert.ok(result.requirements[4]?.description.includes('Legacy ID: AUTH-7'), 'req-edge: original legacy id is preserved in description');
 });
 
 // ─── Scenario 12: Vision derivation ────────────────────────────────────────
@@ -553,6 +556,8 @@ test('Scenario 13: Decisions content', () => {
   const result = transformToGSD(project);
 
   assert.ok(result.decisionsContent.includes('decision-01'), 'decisions: extracts key-decisions from summaries');
+  assert.ok(result.decisionsContent.includes('| D001 |'), 'decisions: writes DB-importable decision ID');
+  assert.ok(result.decisionsContent.includes('| # | When | Scope | Decision | Choice | Rationale | Revisable? | Made By |'), 'decisions: writes canonical table header');
 });
 
 // ─── Scenario 14: No undefined values in output ───────────────────────────
@@ -616,4 +621,3 @@ test('Scenario 15: Empty research', () => {
 });
 
 // ─── Results ───────────────────────────────────────────────────────────────
-