@opengsd/gsd-pi 1.8.1 → 1.9.0-dev.5c1a3ff2

package/src/resources/extensions/gsd/tests/skill-activation.test.ts

@@ -56,6 +56,10 @@ function buildBlock(
   });
 }
 
+function expectedSkillRead(base: string, name: string): string {
+  return `Read the skill file at \`${join(base, "skills", name, "SKILL.md")}\``;
+}
+
 test("buildSkillActivationBlock does not auto-activate skills via broad context heuristic", () => {
   const base = makeTempBase();
   try {
@@ -92,7 +96,7 @@ test("buildSkillActivationBlock activates skills via prefer_skills when context
       prefer_skills: ["react"],
     });
 
-    assert.match(result, /Read the installed 'react' skill file from <available_skills>/);
+    assert.ok(result.includes(expectedSkillRead(base, "react")));
     assert.doesNotMatch(result, /swiftui/);
   } finally {
     cleanup(base);
@@ -111,7 +115,7 @@ test("buildSkillActivationBlock includes always_use_skills using read-based skil
 
     assert.equal(
       result,
-      "<skill_activation>Read the installed 'swift-testing' skill file from <available_skills>.</skill_activation>",
+      `<skill_activation>Read the skill file at \`${join(base, "skills", "swift-testing", "SKILL.md")}\`.</skill_activation>`,
     );
   } finally {
     cleanup(base);
@@ -140,8 +144,8 @@ test("buildSkillActivationBlock includes skill_rules matches and task-plan skill
       skill_rules: [{ when: "prisma database schema", use: ["prisma"] }],
     });
 
-    assert.match(result, /Read the installed 'accessibility' skill file from <available_skills>/);
-    assert.match(result, /Read the installed 'prisma' skill file from <available_skills>/);
+    assert.ok(result.includes(expectedSkillRead(base, "accessibility")));
+    assert.ok(result.includes(expectedSkillRead(base, "prisma")));
   } finally {
     cleanup(base);
   }
@@ -163,7 +167,7 @@ test("buildSkillActivationBlock matches skill_rules against exact unit type cont
       ],
     });
 
-    assert.match(result, /Read the installed 'complete-slice-policies' skill file from <available_skills>/);
+    assert.ok(result.includes(expectedSkillRead(base, "complete-slice-policies")));
     assert.doesNotMatch(result, /slice-broad/);
   } finally {
     cleanup(base);
@@ -267,8 +271,8 @@ test("buildSkillActivationBlock allows valid skill names and rejects invalid one
     });
 
     assert.match(result, /skill_activation/);
-    assert.match(result, /Read the installed 'react' skill file from <available_skills>/);
-    assert.match(result, /Read the installed 'good-skill-2' skill file from <available_skills>/);
+    assert.ok(result.includes(expectedSkillRead(base, "react")));
+    assert.ok(result.includes(expectedSkillRead(base, "good-skill-2")));
     assert.doesNotMatch(result, /bad'name/);
   } finally {
     cleanup(base);
@@ -292,8 +296,8 @@ test("buildSkillActivationBlock: explicit always_use_skills bypass the unit-type
       always_use_skills: ["write-docs", "swiftui"],
     });
 
-    assert.match(result, /Read the installed 'write-docs' skill file from <available_skills>/);
-    assert.match(result, /Read the installed 'swiftui' skill file from <available_skills>/);
+    assert.ok(result.includes(expectedSkillRead(base, "write-docs")));
+    assert.ok(result.includes(expectedSkillRead(base, "swiftui")));
   } finally {
     cleanup(base);
   }
@@ -310,7 +314,7 @@ test("buildSkillActivationBlock falls through to all skills for unknown unit typ
     });
 
     // Unknown unit type = wildcard fallback (pre-manifest behavior).
-    assert.match(result, /Read the installed 'swiftui' skill file from <available_skills>/);
+    assert.ok(result.includes(expectedSkillRead(base, "swiftui")));
   } finally {
     cleanup(base);
   }
@@ -327,7 +331,7 @@ test("buildSkillActivationBlock without unitType preserves pre-manifest behavior
       always_use_skills: ["swiftui"],
     });
 
-    assert.match(result, /Read the installed 'swiftui' skill file from <available_skills>/);
+    assert.ok(result.includes(expectedSkillRead(base, "swiftui")));
   } finally {
     cleanup(base);
   }
@@ -344,12 +348,12 @@ test("milestone prompt builders propagate always_use_skills through buildSkillAc
     loadOnlyTestSkills(base);
 
     const researchPrompt = await buildResearchMilestonePrompt("M001", "Test", base);
-    assert.match(researchPrompt, /Read the installed 'write-docs' skill file from <available_skills>/);
-    assert.match(researchPrompt, /Read the installed 'swiftui' skill file from <available_skills>/);
+    assert.ok(researchPrompt.includes(expectedSkillRead(base, "write-docs")));
+    assert.ok(researchPrompt.includes(expectedSkillRead(base, "swiftui")));
 
     const planPrompt = await buildPlanMilestonePrompt("M001", "Test", base);
-    assert.match(planPrompt, /Read the installed 'write-docs' skill file from <available_skills>/);
-    assert.match(planPrompt, /Read the installed 'swiftui' skill file from <available_skills>/);
+    assert.ok(planPrompt.includes(expectedSkillRead(base, "write-docs")));
+    assert.ok(planPrompt.includes(expectedSkillRead(base, "swiftui")));
   } finally {
     cleanup(base);
   }
@@ -380,7 +384,7 @@ test("complete-slice prompt propagates always_use_skills through buildSkillActiv
 
     const prompt = await buildCompleteSlicePrompt("M001", "Test", "S01", "Slice", base);
 
-    assert.match(prompt, /Read the installed 'write-docs' skill file from <available_skills>/);
+    assert.ok(prompt.includes(expectedSkillRead(base, "write-docs")));
   } finally {
     cleanup(base);
   }

package/src/resources/extensions/gsd/tests/skip-slice-cascades-tasks.test.ts

@@ -25,6 +25,7 @@ import {
   updateTaskStatus,
 } from "../gsd-db.ts";
 import { handleSkipSlice } from "../tools/skip-slice.ts";
+import { skipSliceCascade } from "../db/writers/cascades.ts";
 
 describe("handleSkipSlice cascades skip to tasks (#4375)", () => {
   let dir: string;
@@ -122,4 +123,24 @@ describe("handleSkipSlice cascades skip to tasks (#4375)", () => {
     assert.match(result.error!, /not found/i);
     assert.equal(result.errorCode, "slice_not_found");
   });
+
+  test("skipSliceCascade rejects a slice in the legacy 'closed' status without nulling completed_at", () => {
+    const completedAt = "2026-01-01T00:00:00.000Z";
+    updateSliceStatus("M001", "S03", "closed", completedAt);
+
+    const outcome = skipSliceCascade("M001", "S03");
+    assert.deepEqual(outcome, { ok: false, reason: "slice-already-complete" });
+
+    const slice = getSlice("M001", "S03");
+    assert.equal(slice?.status, "closed", "closed slice must not be downgraded to skipped");
+    assert.equal(slice?.completed_at, completedAt, "completed_at must be preserved");
+  });
+
+  test("skipSliceCascade still re-skips an already-skipped slice (ok, wasAlreadySkipped)", () => {
+    updateSliceStatus("M001", "S03", "skipped");
+
+    const outcome = skipSliceCascade("M001", "S03");
+    assert.equal(outcome.ok, true);
+    if (outcome.ok) assert.equal(outcome.wasAlreadySkipped, true);
+  });
 });

package/src/resources/extensions/gsd/tests/stop-notice.test.ts

@@ -14,6 +14,7 @@ import {
   isPauseNotice,
   isBlockedNoticeMessage,
   isManualResolutionNotice,
+  isInteractiveMenuUnavailableNotice,
   PAUSED_NOTICE_PREFIXES,
   TERMINAL_NOTICE_PREFIXES,
 } from "../stop-notice.js";
@@ -62,6 +63,22 @@ describe("emitter↔detector round-trip", () => {
     assert.ok(isBlockedNoticeMessage(message));
   });
 
+  test("un-showable menu notices classify as blocked (#1294)", () => {
+    // Emitted verbatim by notifyCommandMenuUnavailable (next-action-ui.ts / command-feedback.ts).
+    const menuUnavailable =
+      "gsd — m002: editorial hn menu could not be shown in this session.\nrun /gsd when ready.";
+    assert.ok(isInteractiveMenuUnavailableNotice(menuUnavailable));
+    assert.ok(isBlockedNoticeMessage(menuUnavailable));
+
+    // Emitted by notifyPickerCommandNeedsInteractiveMenu (command-feedback.ts).
+    const pickerGuidance = "/gsd did not start: milestone menu needs an interactive session";
+    assert.ok(isInteractiveMenuUnavailableNotice(pickerGuidance));
+    assert.ok(isBlockedNoticeMessage(pickerGuidance));
+
+    // Unrelated notices are not swept up.
+    assert.equal(isInteractiveMenuUnavailableNotice("auto-mode complete"), false);
+  });
+
   test("terminal prefixes cover the known stop vocabulary", () => {
     for (const message of ["auto-mode stopped.", "auto-mode complete", "auto-mode idle", "no active milestone"]) {
       assert.ok(TERMINAL_NOTICE_PREFIXES.some((prefix) => message.startsWith(prefix)), message);

package/src/resources/extensions/gsd/tests/sync-lock.test.ts

@@ -174,3 +174,22 @@ test('sync-lock: contended fresh lock fails fast without honoring long sync time
     cleanupDir(base);
   }
 });
+
+test('sync-lock: uncreatable lock path fails open instead of spinning forever', () => {
+  const base = tempDir();
+  try {
+    // `.gsd` is a dangling symlink to a missing target: the O_EXCL open lands
+    // on a missing parent and throws non-EEXIST on every attempt. Without the
+    // fail-open guard the retry loop spins forever, blocking the event loop.
+    fs.symlinkSync(path.join(base, 'missing-external-state'), path.join(base, '.gsd'), 'junction');
+
+    const startedAt = performance.now();
+    const result = acquireSyncLock(base, 0, 'write-gate.lock');
+    const elapsedMs = performance.now() - startedAt;
+
+    assert.strictEqual(result.acquired, false, 'uncreatable lock path must fail open, not acquire');
+    assert.ok(elapsedMs < 250, `must return promptly, not spin; elapsed=${elapsedMs.toFixed(1)}ms`);
+  } finally {
+    cleanupDir(base);
+  }
+});

package/src/resources/extensions/gsd/tests/system-context-message-routing.test.ts

@@ -4,7 +4,13 @@
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
 
-import { buildContextMessage, stripVolatileCodebaseMetadata } from "../bootstrap/system-context.ts";
+import {
+  buildContextMessage,
+  GSD_CONTEXT_MESSAGE_SENTINEL,
+  stripVolatileCodebaseMetadata,
+} from "../bootstrap/system-context.ts";
+
+const SENTINEL = `${GSD_CONTEXT_MESSAGE_SENTINEL}\n`;
 
 describe("stripVolatileCodebaseMetadata (#847 — KV cache stability)", () => {
   const map = [
@@ -63,7 +69,7 @@ describe("buildContextMessage (#5019 — memory routing)", () => {
     });
     assert.ok(result, "expected a context message");
     assert.equal(result.customType, "gsd-memory");
-    assert.equal(result.content, "[GSD Context Metadata]\n- Memory supplied: yes\n\n[MEMORY]\nrule one\nrule two");
+    assert.equal(result.content, `${SENTINEL}[GSD Context Metadata]\n- Memory supplied: yes\n\n[MEMORY]\nrule one\nrule two`);
     assert.equal(result.display, false);
   });
 
@@ -75,7 +81,7 @@ describe("buildContextMessage (#5019 — memory routing)", () => {
     });
     assert.ok(result);
     assert.equal(result.customType, "gsd-guided-context");
-    assert.equal(result.content, "[GUIDED]\nexecute T01");
+    assert.equal(result.content, `${SENTINEL}[GUIDED]\nexecute T01`);
   });
 
   test("forensics injection alone emits gsd-forensics", () => {
@@ -86,7 +92,7 @@ describe("buildContextMessage (#5019 — memory routing)", () => {
     });
     assert.ok(result);
     assert.equal(result.customType, "gsd-forensics");
-    assert.equal(result.content, "[FORENSICS]\ninvestigation context");
+    assert.equal(result.content, `${SENTINEL}[FORENSICS]\ninvestigation context`);
   });
 
   test("memory + guided injection: memory prepended, customType is gsd-guided-context", () => {
@@ -97,7 +103,7 @@ describe("buildContextMessage (#5019 — memory routing)", () => {
     });
     assert.ok(result);
     assert.equal(result.customType, "gsd-guided-context");
-    assert.equal(result.content, `${markedMemory}\n\n[GUIDED]\nexecute T01`);
+    assert.equal(result.content, `${SENTINEL}${markedMemory}\n\n[GUIDED]\nexecute T01`);
   });
 
   test("memory + forensics: memory prepended, customType is gsd-forensics", () => {
@@ -108,7 +114,7 @@ describe("buildContextMessage (#5019 — memory routing)", () => {
     });
     assert.ok(result);
     assert.equal(result.customType, "gsd-forensics");
-    assert.equal(result.content, `${markedMemory}\n\n[FORENSICS]\ninvestigation context`);
+    assert.equal(result.content, `${SENTINEL}${markedMemory}\n\n[FORENSICS]\ninvestigation context`);
   });
 
   test("guided takes precedence over forensics when both are somehow present", () => {
@@ -122,6 +128,6 @@ describe("buildContextMessage (#5019 — memory routing)", () => {
     });
     assert.ok(result);
     assert.equal(result.customType, "gsd-guided-context");
-    assert.equal(result.content, "[GUIDED]");
+    assert.equal(result.content, `${SENTINEL}[GUIDED]`);
   });
 });

package/src/resources/extensions/gsd/tests/tool-naming.test.ts

@@ -25,8 +25,16 @@ function makeMockPi() {
 
 console.log('\n── Tool naming: registration count ──');
 
+// Aliases are hidden from the model-facing surface by default (plan 035);
+// opt in here so this file can keep exercising alias-registration behavior.
+const previousAdvertiseAliases = process.env.GSD_ADVERTISE_TOOL_ALIASES;
+process.env.GSD_ADVERTISE_TOOL_ALIASES = "1";
+
 const pi = makeMockPi();
 registerDbTools(pi);
+
+if (previousAdvertiseAliases === undefined) delete process.env.GSD_ADVERTISE_TOOL_ALIASES;
+else process.env.GSD_ADVERTISE_TOOL_ALIASES = previousAdvertiseAliases;
 const toolByName = new Map<string, any>(pi.tools.map((tool: any) => [tool.name, tool]));
 const registeredCanonicalNames = new Set<string>(
   WORKFLOW_TOOL_CONTRACTS

package/src/resources/extensions/gsd/tests/unit-context-composer.test.ts

@@ -43,7 +43,10 @@ import {
   insertMilestone,
   upsertMilestonePlanning,
   insertSlice,
+  insertTask,
+  saveReworkBrief,
 } from "../gsd-db.ts";
+import { clearGSDPreferencesCache, getProjectGSDPreferencesPath } from "../preferences.ts";
 
 // ─── Pure composer tests ──────────────────────────────────────────────────
 
@@ -416,6 +419,44 @@ test("Tool Surface composer: planning-dispatch lists allowed subagents", () => {
   assert.match(out, /\*\*planner\*\*/);
 });
 
+test("Tool Surface composer: planning_subagents updates plan-milestone dispatch guidance", (t) => {
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = mkdtempSync(join(tmpdir(), "gsd-tool-surface-planning-subagents-"));
+  const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-tool-surface-planning-subagents-home-"));
+
+  t.after(() => {
+    clearGSDPreferencesCache();
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  });
+
+  process.env.GSD_HOME = tempGsdHome;
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  clearGSDPreferencesCache();
+  writeFileSync(
+    getProjectGSDPreferencesPath(tempProject),
+    [
+      "---",
+      "version: 1",
+      "planning_subagents:",
+      "  plan-milestone:",
+      "    allowed: [security]",
+      "---",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  const out = composeToolSurfaceInstructions("plan-milestone", {
+    renderMode: "standalone",
+    basePath: tempProject,
+  });
+  assert.match(out, /Dispatch subagents only to \*\*security\*\*/);
+  assert.doesNotMatch(out, /Do not dispatch subagents/);
+});
+
 test("Tool Surface composer: execute-task warns against slice/milestone closeout tools", () => {
   const out = composeToolSurfaceInstructions("execute-task", { renderMode: "nested" });
   assert.match(out, /^Tool surface: /);
@@ -518,6 +559,38 @@ test("#4782 phase 2: buildReassessRoadmapPrompt emits composer-shaped context wi
   assert.ok(!prompt.includes("Slice Context (from discussion)"));
 });
 
+
+test("execute-task prompt injects unresolved blocking rework findings", async (t) => {
+  const base = makeFixtureBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seed(base, "M001");
+  writeArtifacts(base);
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Task", status: "pending" });
+  saveReworkBrief({
+    briefId: "RB-001",
+    milestoneId: "M001",
+    sliceId: "S01",
+    taskId: "T01",
+    findings: [{
+      findingId: "F1",
+      severity: "blocking",
+      description: "Compile regression",
+      requiredFix: "Restore typecheck",
+      verificationCommands: ["pnpm run typecheck:extensions"],
+    }],
+  });
+
+  const prompt = await buildExecuteTaskPrompt("M001", "S01", "First", "T01", "Task", base);
+
+  assert.match(prompt, /Blocking Rework Findings \(non-optional\)/);
+  assert.match(prompt, /F1/);
+  assert.match(prompt, /Compile regression/);
+  assert.match(prompt, /pnpm run typecheck:extensions/);
+  assert.match(prompt, /reworkResolution/);
+});
+
 test("execute-task prompt omits on-demand slice research when the artifact is absent", async (t) => {
   const base = makeFixtureBase();
   t.after(() => cleanup(base));

package/src/resources/extensions/gsd/tests/uok-plan-v2-wiring.test.ts

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -239,6 +239,98 @@ test("plan-v2 ensure rejects empty executable graph", () => {
   assert.equal(isEmptyPlanV2GraphResult(compiled), true);
 });
 
+function seedMultiSliceRows(): void {
+  insertMilestone({ id: MILESTONE_ID, title: "Milestone", status: "active" });
+  const slices: Array<[string, number, Array<[string, number]>]> = [
+    ["S01", 1, [["T01", 1], ["T02", 2]]],
+    ["S02", 2, [["T03", 1], ["T04", 2]]],
+  ];
+  for (const [sid, sseq, tasks] of slices) {
+    insertSlice({ id: sid, milestoneId: MILESTONE_ID, title: `Slice ${sid}`, status: "in_progress", sequence: sseq });
+    for (const [tid, tseq] of tasks) {
+      insertTask({
+        id: tid,
+        milestoneId: MILESTONE_ID,
+        sliceId: sid,
+        title: `Task ${tid}`,
+        status: "pending",
+        keyFiles: [`src/${tid}.ts`],
+        sequence: tseq,
+      });
+    }
+  }
+}
+
+test("plan-v2 batched compile preserves node ids, order, and count", () => {
+  const basePath = createBasePath();
+  seedMultiSliceRows();
+  writeMilestoneFile(basePath, "CONTEXT", "Finalized context.");
+
+  const compiled = ensurePlanV2Graph(basePath, buildState("executing"));
+  assert.equal(compiled.ok, true);
+
+  const graph = JSON.parse(readFileSync(compiled.graphPath ?? "", "utf-8")) as {
+    nodes: Array<{ id: string }>;
+  };
+  assert.deepEqual(
+    graph.nodes.map((n) => n.id),
+    [
+      "execute-task:M001:S01:T01",
+      "execute-task:M001:S01:T02",
+      "complete-slice:M001:S01",
+      "execute-task:M001:S02:T03",
+      "execute-task:M001:S02:T04",
+      "complete-slice:M001:S02",
+    ],
+  );
+});
+
+test("plan-v2 skips the disk write when the graph is unchanged", () => {
+  const basePath = createBasePath();
+  seedMultiSliceRows();
+  writeMilestoneFile(basePath, "CONTEXT", "Finalized context.");
+
+  const first = ensurePlanV2Graph(basePath, buildState("executing"));
+  assert.equal(first.ok, true);
+  const graphPath = first.graphPath ?? "";
+  const before = readFileSync(graphPath, "utf-8");
+
+  // Backdate mtime so a rewrite is detectable even within the same millisecond.
+  utimesSync(graphPath, 1000, 1000);
+  const backdatedMtime = statSync(graphPath).mtimeMs;
+
+  const second = ensurePlanV2Graph(basePath, buildState("executing"));
+  assert.equal(second.ok, true);
+  assert.equal(statSync(graphPath).mtimeMs, backdatedMtime, "identical state must not rewrite the graph");
+  assert.equal(readFileSync(graphPath, "utf-8"), before);
+});
+
+test("plan-v2 rewrites the graph when it changes", () => {
+  const basePath = createBasePath();
+  seedMultiSliceRows();
+  writeMilestoneFile(basePath, "CONTEXT", "Finalized context.");
+
+  const first = ensurePlanV2Graph(basePath, buildState("executing"));
+  const graphPath = first.graphPath ?? "";
+  const before = readFileSync(graphPath, "utf-8");
+  utimesSync(graphPath, 1000, 1000);
+
+  insertTask({
+    id: "T05",
+    milestoneId: MILESTONE_ID,
+    sliceId: "S02",
+    title: "Added task",
+    status: "pending",
+    keyFiles: ["src/T05.ts"],
+    sequence: 3,
+  });
+
+  const second = ensurePlanV2Graph(basePath, buildState("executing"));
+  assert.equal(second.ok, true);
+  assert.notEqual(statSync(graphPath).mtimeMs, 1000000, "changed graph must rewrite");
+  assert.notEqual(readFileSync(graphPath, "utf-8"), before);
+});
+
 test("plan-v2 allows empty graph for milestone terminal phases", () => {
   const basePath = createBasePath();
   writeMilestoneFile(basePath, "CONTEXT", "Finalized context.");

package/src/resources/extensions/gsd/tests/workflow-mcp.test.ts

@@ -94,6 +94,8 @@ test("complete-slice requires status, closeout, and execution handoff tools", ()
     "gsd_slice_complete",
     "gsd_task_reopen",
     "gsd_replan_slice",
+    "gsd_replan_task",
+    "gsd_rework_brief_save",
     "gsd_requirement_update",
     "gsd_summary_save",
   ];

package/src/resources/extensions/gsd/tests/workflow-migration-gates.test.ts

@@ -0,0 +1,139 @@
+// GSD Extension - Auto-migration gate tests (plan 026).
+// Covers needsAutoMigration's trigger (empty milestones table + .gsd/milestones
+// present) and validateMigration's engine-vs-markdown count comparison.
+
+import { describe, 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, insertMilestone, insertSlice } from '../gsd-db.ts';
+import { needsAutoMigration, validateMigration } from '../workflow-migration.ts';
+
+function makeProject(): string {
+  return mkdtempSync(join(tmpdir(), 'gsd-migration-gates-'));
+}
+
+function openProjectDb(base: string): string {
+  const gsdDir = join(base, '.gsd');
+  mkdirSync(gsdDir, { recursive: true });
+  const dbPath = join(gsdDir, 'gsd.db');
+  assert.ok(openDatabase(dbPath), 'openDatabase should succeed');
+  return dbPath;
+}
+
+function cleanup(base: string): void {
+  closeDatabase();
+  rmSync(base, { recursive: true, force: true });
+}
+
+function writeRoadmap(base: string, mId: string, sliceLines: string[]): void {
+  const mDir = join(base, '.gsd', 'milestones', mId);
+  mkdirSync(mDir, { recursive: true });
+  writeFileSync(join(mDir, 'ROADMAP.md'), [
+    `# ${mId}: Test`,
+    '',
+    '## Slices',
+    '',
+    ...sliceLines,
+    '',
+  ].join('\n'));
+}
+
+describe('needsAutoMigration', () => {
+  test('false for a fresh project with no legacy markdown', () => {
+    const base = makeProject();
+    try {
+      openProjectDb(base);
+      assert.equal(needsAutoMigration(base), false, 'no .gsd/milestones dir → no migration');
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test('true when engine tables are empty and .gsd/milestones exists', () => {
+    const base = makeProject();
+    try {
+      openProjectDb(base);
+      mkdirSync(join(base, '.gsd', 'milestones', 'M001'), { recursive: true });
+      assert.equal(needsAutoMigration(base), true, 'legacy markdown + empty engine → migrate');
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test('false once the milestones table has rows (migration already done)', () => {
+    const base = makeProject();
+    try {
+      openProjectDb(base);
+      mkdirSync(join(base, '.gsd', 'milestones', 'M001'), { recursive: true });
+      insertMilestone({ id: 'M001', title: 'Migrated' });
+      assert.equal(needsAutoMigration(base), false, 'engine rows present → migration already done');
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test('false when no database connection is open', () => {
+    const base = makeProject();
+    try {
+      mkdirSync(join(base, '.gsd', 'milestones', 'M001'), { recursive: true });
+      closeDatabase();
+      assert.equal(needsAutoMigration(base), false, 'no DB → cannot migrate');
+    } finally {
+      cleanup(base);
+    }
+  });
+});
+
+describe('validateMigration', () => {
+  test('reports no discrepancies when engine counts match markdown', () => {
+    const base = makeProject();
+    try {
+      openProjectDb(base);
+      writeRoadmap(base, 'M001', ['- [ ] **S01: Test Slice** `risk:low` `depends:[]`']);
+      insertMilestone({ id: 'M001', title: 'Test' });
+      insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice' });
+
+      const result = validateMigration(base);
+      assert.deepEqual(result.discrepancies, [], 'matching engine/markdown counts → clean');
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test('reports discrepancies when engine counts diverge from markdown', () => {
+    const base = makeProject();
+    try {
+      openProjectDb(base);
+      writeRoadmap(base, 'M001', [
+        '- [ ] **S01: Test Slice** `risk:low` `depends:[]`',
+        '- [ ] **S02: Second Slice** `risk:low` `depends:[]`',
+      ]);
+      // Engine has no rows at all → milestone and slice counts both diverge.
+      const result = validateMigration(base);
+      assert.ok(
+        result.discrepancies.some((d) => d.includes('Milestone count mismatch')),
+        `expected milestone mismatch, got: ${result.discrepancies.join('; ')}`,
+      );
+      assert.ok(
+        result.discrepancies.some((d) => d.includes('Slice count mismatch')),
+        `expected slice mismatch, got: ${result.discrepancies.join('; ')}`,
+      );
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test('reports a validation failure when no database connection is open', () => {
+    const base = makeProject();
+    try {
+      closeDatabase();
+      const result = validateMigration(base);
+      assert.deepEqual(result.discrepancies, ['No database connection for validation']);
+    } finally {
+      cleanup(base);
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/workflow-projections.test.ts

@@ -352,7 +352,7 @@ test('workflow-projections: regenerateIfMissing SUMMARY is idempotent for flat-p
       keyDecisions: ['Use centralized task summary paths.'],
     });
 
-    const summaryPath = join(phaseDir, 'T01-SUMMARY.md');
+    const summaryPath = join(phaseDir, 'S01-T01-SUMMARY.md');
     assert.ok(!existsSync(summaryPath), 'precondition: flat-phase task summary absent');
 
     const first = await regenerateIfMissing(base, 'M001', 'S01', 'SUMMARY');
@@ -399,7 +399,7 @@ test('workflow-projections: flat-phase SUMMARY regeneration ignores stale nested
       status: 'complete',
     });
 
-    const rootSummaryPath = join(phaseDir, 'T01-SUMMARY.md');
+    const rootSummaryPath = join(phaseDir, 'S01-T01-SUMMARY.md');
     assert.ok(!existsSync(rootSummaryPath), 'precondition: canonical flat-phase task summary absent');
 
     const regenerated = await regenerateIfMissing(base, 'M001', 'S01', 'SUMMARY');
@@ -440,8 +440,8 @@ test('workflow-projections: renderSummaryProjection uses milestone title when cr
       status: 'complete',
     });
 
-    const titleSummaryPath = join(base, '.gsd', 'phases', '01-milestone', 'T01-SUMMARY.md');
-    const idSummaryPath = join(base, '.gsd', 'phases', '01-m001', 'T01-SUMMARY.md');
+    const titleSummaryPath = join(base, '.gsd', 'phases', '01-milestone', 'S01-T01-SUMMARY.md');
+    const idSummaryPath = join(base, '.gsd', 'phases', '01-m001', 'S01-T01-SUMMARY.md');
 
     renderSummaryProjection(base, 'M001', 'S01', 'T01');