gsd-pi 2.29.0-dev.49d972f → 2.29.0-dev.4c155ee

package/src/resources/extensions/gsd/tests/extension-selector-separator.test.ts

@@ -1,4 +1,6 @@
-// Tests for the SEPARATOR_PREFIX convention used by ExtensionSelectorComponent.
+// Tests for the SEPARATOR_PREFIX convention used by ExtensionSelectorComponent
+// and the two-step provider→model picker in configureModels.
+//
 // We cannot import the component directly in node:test because its transitive
 // dependency (countdown-timer.ts) uses TypeScript parameter properties which
 // are unsupported under --experimental-strip-types. Instead we duplicate the
@@ -69,16 +71,17 @@ describe("separator detection", () => {
 	});
 });
 
-describe("model grouping", () => {
-	test("groups models by provider with separator headers", () => {
-		// Simulate the grouping logic from configureModels
-		const availableModels = [
-			{ id: "claude-opus-4-6", provider: "anthropic" },
-			{ id: "gpt-4o", provider: "openai" },
-			{ id: "claude-sonnet-4-5", provider: "anthropic" },
-			{ id: "o3-mini", provider: "openai" },
-		];
+describe("two-step provider→model picker", () => {
+	// Simulate the grouping logic from configureModels
+	const availableModels = [
+		{ id: "claude-opus-4-6", provider: "anthropic" },
+		{ id: "gpt-4o", provider: "openai" },
+		{ id: "claude-sonnet-4-5", provider: "anthropic" },
+		{ id: "o3-mini", provider: "openai" },
+		{ id: "claude-haiku-4-5", provider: "anthropic" },
+	];
 
+	function buildProviderGroups() {
 		const byProvider = new Map<string, typeof availableModels>();
 		for (const m of availableModels) {
 			let group = byProvider.get(m.provider);
@@ -89,34 +92,53 @@ describe("model grouping", () => {
 			group.push(m);
 		}
 		const providers = Array.from(byProvider.keys()).sort((a, b) => a.localeCompare(b));
-
-		const modelOptions: string[] = [];
-		for (const provider of providers) {
-			const group = byProvider.get(provider)!;
-			modelOptions.push(`${SEPARATOR_PREFIX} ${provider} (${group.length}) ${SEPARATOR_PREFIX}`);
-			for (const m of group) {
-				modelOptions.push(`${m.id} · ${m.provider}`);
-			}
+		for (const group of byProvider.values()) {
+			group.sort((a, b) => a.id.localeCompare(b.id));
 		}
-		modelOptions.push("(keep current)", "(clear)");
-
-		// Verify structure
-		assert.strictEqual(modelOptions[0], `${SEPARATOR_PREFIX} anthropic (2) ${SEPARATOR_PREFIX}`);
-		assert.strictEqual(modelOptions[1], "claude-opus-4-6 · anthropic");
-		assert.strictEqual(modelOptions[2], "claude-sonnet-4-5 · anthropic");
-		assert.strictEqual(modelOptions[3], `${SEPARATOR_PREFIX} openai (2) ${SEPARATOR_PREFIX}`);
-		assert.strictEqual(modelOptions[4], "gpt-4o · openai");
-		assert.strictEqual(modelOptions[5], "o3-mini · openai");
-		assert.strictEqual(modelOptions[6], "(keep current)");
-		assert.strictEqual(modelOptions[7], "(clear)");
-
-		// Verify separators are correctly detected
-		assert.ok(isSeparator(modelOptions, 0));
-		assert.ok(!isSeparator(modelOptions, 1));
-		assert.ok(isSeparator(modelOptions, 3));
-		assert.ok(!isSeparator(modelOptions, 6));
-
-		// Verify first selectable is index 1, not the separator at 0
-		assert.strictEqual(nextSelectable(modelOptions, 0, 1), 1);
+		return { byProvider, providers };
+	}
+
+	test("provider menu lists providers with model counts", () => {
+		const { providers, byProvider } = buildProviderGroups();
+		const providerOptions = providers.map(p => {
+			const count = byProvider.get(p)!.length;
+			return `${p} (${count} models)`;
+		});
+		providerOptions.push("(keep current)", "(clear)", "(type manually)");
+
+		assert.strictEqual(providerOptions[0], "anthropic (3 models)");
+		assert.strictEqual(providerOptions[1], "openai (2 models)");
+		assert.strictEqual(providerOptions[2], "(keep current)");
+		assert.strictEqual(providerOptions[3], "(clear)");
+		assert.strictEqual(providerOptions[4], "(type manually)");
+	});
+
+	test("model menu for a provider is sorted alphabetically", () => {
+		const { byProvider } = buildProviderGroups();
+		const anthropicModels = byProvider.get("anthropic")!;
+		const modelOptions = anthropicModels.map(m => m.id);
+
+		assert.strictEqual(modelOptions[0], "claude-haiku-4-5");
+		assert.strictEqual(modelOptions[1], "claude-opus-4-6");
+		assert.strictEqual(modelOptions[2], "claude-sonnet-4-5");
+	});
+
+	test("provider name is extracted correctly from choice string", () => {
+		const choice = "anthropic (3 models)";
+		const providerName = choice.replace(/ \(\d+ models?\)$/, "");
+		assert.strictEqual(providerName, "anthropic");
+
+		const singleChoice = "ollama (1 model)";
+		const singleProvider = singleChoice.replace(/ \(\d+ models?\)$/, "");
+		assert.strictEqual(singleProvider, "ollama");
+	});
+
+	test("openai models are sorted within their group", () => {
+		const { byProvider } = buildProviderGroups();
+		const openaiModels = byProvider.get("openai")!;
+		const modelOptions = openaiModels.map(m => m.id);
+
+		assert.strictEqual(modelOptions[0], "gpt-4o");
+		assert.strictEqual(modelOptions[1], "o3-mini");
 	});
 });

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

@@ -311,7 +311,7 @@ async function main(): Promise<void> {
     // Test 2: Uncommitted .gsd/ planning files are available in worktree
     //
     // When auto-mode starts, .gsd/ files may be untracked/uncommitted.
-    // copyPlanningArtifacts should carry them into the worktree even if
+    // Planning artifacts should be carried into the worktree even if
     // they weren't committed on the feature branch.
     // ================================================================
     console.log("\n=== Untracked planning files copied to worktree ===");
@@ -341,23 +341,10 @@ async function main(): Promise<void> {
       const wtPath = createAutoWorktree(repo, milestoneId);
       tempDirs.push(wtPath);
 
-      // Planning files should exist in the worktree (via copyPlanningArtifacts)
-      assertTrue(
-        existsSync(join(wtPath, ".gsd", "milestones", milestoneId, `${milestoneId}-ROADMAP.md`)),
-        "ROADMAP.md copied to worktree",
-      );
-      assertTrue(
-        existsSync(join(wtPath, ".gsd", "milestones", milestoneId, "slices", "S01", "S01-PLAN.md")),
-        "S01-PLAN.md copied to worktree",
-      );
-      assertTrue(
-        existsSync(join(wtPath, ".gsd", "PROJECT.md")),
-        "PROJECT.md copied to worktree",
-      );
-      assertTrue(
-        existsSync(join(wtPath, ".gsd", "DECISIONS.md")),
-        "DECISIONS.md copied to worktree",
-      );
+      // With external state, worktree .gsd is a symlink to shared state.
+      // Verify symlink was created (planning files are shared, not copied).
+      const wtGsd = join(wtPath, ".gsd");
+      assertTrue(existsSync(wtGsd), "worktree .gsd exists (symlink or dir)");
 
       // Clean up: chdir back before teardown
       process.chdir(savedCwd);

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

@@ -1167,53 +1167,26 @@ async function main(): Promise<void> {
     rmSync(repo, { recursive: true, force: true });
   }
 
-  // ─── ensureGitignore: commit_docs false adds blanket .gsd/ ──────────
+  // ─── ensureGitignore: always adds .gsd to gitignore ──────────────────
 
-  console.log("\n=== ensureGitignore: commit_docs false ===");
+  console.log("\n=== ensureGitignore: adds .gsd entry ===");
 
   {
     const { ensureGitignore } = await import("../gitignore.ts");
-    const repo = mkdtempSync(join(tmpdir(), "gsd-gitignore-commit-docs-"));
+    const repo = mkdtempSync(join(tmpdir(), "gsd-gitignore-external-state-"));
 
-    // When commit_docs is false, should add blanket .gsd/ to gitignore
-    const modified = ensureGitignore(repo, { commitDocs: false });
-    assertTrue(modified, "commit_docs=false: gitignore was modified");
+    // Should add .gsd to gitignore (external state dir is a symlink)
+    const modified = ensureGitignore(repo);
+    assertTrue(modified, "ensureGitignore: gitignore was modified");
 
     const { readFileSync } = await import("node:fs");
     const content = readFileSync(join(repo, ".gitignore"), "utf-8");
-    assertTrue(content.includes(".gsd/"), "commit_docs=false: .gitignore contains blanket .gsd/");
-    assertTrue(content.includes("commit_docs: false"), "commit_docs=false: .gitignore contains explanatory comment");
-
-    // Should NOT contain individual runtime patterns (those are subsumed by blanket .gsd/)
-    // But it's OK if it does — the blanket .gsd/ covers everything
+    const lines = content.split("\n").map(l => l.trim()).filter(l => l && !l.startsWith("#"));
+    assertTrue(lines.includes(".gsd"), "ensureGitignore: .gitignore contains .gsd");
 
     // Idempotent — calling again doesn't add duplicates
-    const modified2 = ensureGitignore(repo, { commitDocs: false });
-    assertTrue(!modified2, "commit_docs=false: second call is idempotent");
-
-    rmSync(repo, { recursive: true, force: true });
-  }
-
-  // ─── ensureGitignore: commit_docs true removes blanket .gsd/ ────────
-
-  console.log("\n=== ensureGitignore: commit_docs true self-heals ===");
-
-  {
-    const { ensureGitignore } = await import("../gitignore.ts");
-    const repo = mkdtempSync(join(tmpdir(), "gsd-gitignore-selfheal-"));
-
-    // Start with a gitignore that has a blanket .gsd/ (e.g., user switched setting)
-    writeFileSync(join(repo, ".gitignore"), ".gsd/\n");
-
-    const modified = ensureGitignore(repo, { commitDocs: true });
-    assertTrue(modified, "commit_docs=true: gitignore was modified");
-
-    const { readFileSync } = await import("node:fs");
-    const content = readFileSync(join(repo, ".gitignore"), "utf-8");
-    // Blanket .gsd/ should be removed
-    const lines = content.split("\n").map(l => l.trim()).filter(l => l && !l.startsWith("#"));
-    assertTrue(!lines.includes(".gsd/"), "commit_docs=true: blanket .gsd/ was removed");
-    assertTrue(!lines.includes(".gsd"), "commit_docs=true: blanket .gsd was removed");
+    const modified2 = ensureGitignore(repo);
+    assertTrue(!modified2, "ensureGitignore: second call is idempotent");
 
     rmSync(repo, { recursive: true, force: true });
   }

package/src/resources/extensions/gsd/tests/knowledge.test.ts

@@ -10,7 +10,7 @@
 
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync } from 'node:fs';
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync, realpathSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { GSD_ROOT_FILES, resolveGsdRootFile } from '../paths.ts';
@@ -27,7 +27,7 @@ test('knowledge: KNOWLEDGE key exists in GSD_ROOT_FILES', () => {
 // ─── resolveGsdRootFile resolves KNOWLEDGE.md ───────────────────────────────
 
 test('knowledge: resolveGsdRootFile returns canonical path when KNOWLEDGE.md exists', () => {
-  const tmp = mkdtempSync(join(tmpdir(), 'gsd-knowledge-'));
+  const tmp = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-knowledge-')));
   const gsdDir = join(tmp, '.gsd');
   mkdirSync(gsdDir, { recursive: true });
   writeFileSync(join(gsdDir, 'KNOWLEDGE.md'), '# Project Knowledge\n');
@@ -39,7 +39,7 @@ test('knowledge: resolveGsdRootFile returns canonical path when KNOWLEDGE.md exi
 });
 
 test('knowledge: resolveGsdRootFile resolves when legacy knowledge.md exists', () => {
-  const tmp = mkdtempSync(join(tmpdir(), 'gsd-knowledge-'));
+  const tmp = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-knowledge-')));
   const gsdDir = join(tmp, '.gsd');
   mkdirSync(gsdDir, { recursive: true });
   writeFileSync(join(gsdDir, 'knowledge.md'), '# Project Knowledge\n');
@@ -58,7 +58,7 @@ test('knowledge: resolveGsdRootFile resolves when legacy knowledge.md exists', (
 });
 
 test('knowledge: resolveGsdRootFile returns canonical path when file does not exist', () => {
-  const tmp = mkdtempSync(join(tmpdir(), 'gsd-knowledge-'));
+  const tmp = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-knowledge-')));
   const gsdDir = join(tmp, '.gsd');
   mkdirSync(gsdDir, { recursive: true });
 

package/src/resources/extensions/gsd/tests/mechanical-completion.test.ts

@@ -0,0 +1,356 @@
+/**
+ * Mechanical Completion — unit tests (ADR-003).
+ *
+ * Tests deterministic slice/milestone completion using fixture data.
+ * Uses node:test + node:assert for consistency with token-profile.test.ts.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync, readFileSync, rmSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomBytes } from "node:crypto";
+
+// ─── Fixture Helpers ──────────────────────────────────────────────────────────
+
+function createTmpBase(): string {
+  const base = join(tmpdir(), `gsd-mech-test-${randomBytes(4).toString("hex")}`);
+  mkdirSync(base, { recursive: true });
+  return base;
+}
+
+function scaffold(base: string, mid: string, sid: string, taskSummaries: Array<{ tid: string; content: string }>) {
+  const gsdRoot = join(base, ".gsd");
+  const mDir = join(gsdRoot, "milestones", mid);
+  const sDir = join(mDir, "slices", sid);
+  const tDir = join(sDir, "tasks");
+  mkdirSync(tDir, { recursive: true });
+
+  for (const { tid, content } of taskSummaries) {
+    writeFileSync(join(tDir, `${tid}-SUMMARY.md`), content, "utf-8");
+  }
+
+  return { gsdRoot, mDir, sDir, tDir };
+}
+
+function makeTaskSummary(tid: string, opts: {
+  oneLiner?: string;
+  provides?: string[];
+  key_files?: string[];
+  key_decisions?: string[];
+  verification_result?: string;
+}): string {
+  const lines: string[] = [
+    "---",
+    `id: ${tid}`,
+    `parent: S01`,
+    `milestone: M001`,
+  ];
+  if (opts.provides?.length) lines.push(`provides:\n${opts.provides.map(p => `  - ${p}`).join("\n")}`);
+  if (opts.key_files?.length) lines.push(`key_files:\n${opts.key_files.map(f => `  - ${f}`).join("\n")}`);
+  if (opts.key_decisions?.length) lines.push(`key_decisions:\n${opts.key_decisions.map(d => `  - ${d}`).join("\n")}`);
+  lines.push(`verification_result: ${opts.verification_result ?? "passed"}`);
+  lines.push("---");
+  lines.push("");
+  lines.push(`# ${tid}: Test Task`);
+  lines.push("");
+  if (opts.oneLiner) lines.push(`**${opts.oneLiner}**`);
+  lines.push("");
+  lines.push("## What Happened");
+  lines.push("");
+  lines.push(`Implemented the feature described in ${tid}. This was a significant change that modified multiple files across the codebase to support the new functionality.`);
+  lines.push("");
+  return lines.join("\n");
+}
+
+// ─── Source-level structural tests ────────────────────────────────────────────
+
+const mechanicalSrc = readFileSync(
+  join(import.meta.dirname!, "..", "mechanical-completion.ts"),
+  "utf-8",
+);
+
+test("mechanical-completion: exports mechanicalSliceCompletion", () => {
+  assert.ok(
+    mechanicalSrc.includes("export async function mechanicalSliceCompletion"),
+    "should export mechanicalSliceCompletion",
+  );
+});
+
+test("mechanical-completion: exports aggregateMilestoneVerification", () => {
+  assert.ok(
+    mechanicalSrc.includes("export async function aggregateMilestoneVerification"),
+    "should export aggregateMilestoneVerification",
+  );
+});
+
+test("mechanical-completion: exports generateMilestoneSummary", () => {
+  assert.ok(
+    mechanicalSrc.includes("export async function generateMilestoneSummary"),
+    "should export generateMilestoneSummary",
+  );
+});
+
+test("mechanical-completion: exports appendNewDecisions", () => {
+  assert.ok(
+    mechanicalSrc.includes("export async function appendNewDecisions"),
+    "should export appendNewDecisions",
+  );
+});
+
+test("mechanical-completion: uses atomicWriteSync for file writes", () => {
+  assert.ok(
+    mechanicalSrc.includes("atomicWriteSync"),
+    "should use atomicWriteSync for safe file writes",
+  );
+});
+
+test("mechanical-completion: quality gate checks summary length for multi-task slices", () => {
+  assert.ok(
+    mechanicalSrc.includes("totalContent.length < 200"),
+    "should have quality gate for summary content length",
+  );
+});
+
+test("mechanical-completion: marks slice [x] in roadmap", () => {
+  assert.ok(
+    mechanicalSrc.includes("markSliceInRoadmap"),
+    "should mark slice done in roadmap",
+  );
+});
+
+test("mechanical-completion: aggregates VERIFY.json files for milestone validation", () => {
+  assert.ok(
+    mechanicalSrc.includes("resolveTaskJsonFiles") && mechanicalSrc.includes("VERIFY"),
+    "should read VERIFY.json files for milestone validation",
+  );
+});
+
+test("mechanical-completion: deduplicates decisions against existing DECISIONS.md", () => {
+  assert.ok(
+    mechanicalSrc.includes("existing.includes(d.trim())"),
+    "should deduplicate decisions against existing content",
+  );
+});
+
+test("mechanical-completion: produces VALIDATION.md with verdict frontmatter", () => {
+  assert.ok(
+    mechanicalSrc.includes("verdict:") && mechanicalSrc.includes("remediation_round: 0"),
+    "VALIDATION.md should have verdict and remediation_round frontmatter",
+  );
+});
+
+// ─── Integration tests with fixture data ──────────────────────────────────────
+
+test("mechanical: slice completion with 2 task summaries produces SUMMARY.md", async () => {
+  const base = createTmpBase();
+  try {
+    const mid = "M001";
+    const sid = "S01";
+
+    // Scaffold task summaries
+    scaffold(base, mid, sid, [
+      {
+        tid: "T01",
+        content: makeTaskSummary("T01", {
+          oneLiner: "Set up project structure",
+          provides: ["project-scaffold"],
+          key_files: ["src/index.ts", "package.json"],
+          verification_result: "passed",
+        }),
+      },
+      {
+        tid: "T02",
+        content: makeTaskSummary("T02", {
+          oneLiner: "Add core API endpoints",
+          provides: ["api-endpoints"],
+          key_files: ["src/api.ts"],
+          key_decisions: ["Used Express over Fastify"],
+          verification_result: "passed",
+        }),
+      },
+    ]);
+
+    // Write a roadmap with the slice unchecked
+    const roadmapPath = join(base, ".gsd", "milestones", mid, `${mid}-ROADMAP.md`);
+    writeFileSync(roadmapPath, `# Roadmap\n\n- [ ] **${sid}: First Slice**\n`, "utf-8");
+
+    // Write a slice plan with Verification section
+    const planPath = join(base, ".gsd", "milestones", mid, "slices", sid, `${sid}-PLAN.md`);
+    writeFileSync(planPath, `# Plan\n\n## Verification\n\n- Run \`npm test\`\n- Check output\n`, "utf-8");
+
+    // Dynamic import to get the actual module
+    const { mechanicalSliceCompletion } = await import("../mechanical-completion.js");
+    const ok = await mechanicalSliceCompletion(base, mid, sid);
+
+    assert.ok(ok, "should return true for valid slice completion");
+
+    // Check SUMMARY.md was written
+    const summaryPath = join(base, ".gsd", "milestones", mid, "slices", sid, `${sid}-SUMMARY.md`);
+    assert.ok(existsSync(summaryPath), "SUMMARY.md should exist");
+
+    const summaryContent = readFileSync(summaryPath, "utf-8");
+    assert.ok(summaryContent.includes("T01"), "summary should reference T01");
+    assert.ok(summaryContent.includes("T02"), "summary should reference T02");
+    assert.ok(summaryContent.includes("verification_result: passed"), "should have passed verification");
+
+    // Check roadmap was updated
+    const updatedRoadmap = readFileSync(roadmapPath, "utf-8");
+    assert.ok(updatedRoadmap.includes("[x]"), "roadmap should have [x] checkbox");
+
+    // Check UAT was written
+    const uatPath = join(base, ".gsd", "milestones", mid, "slices", sid, `${sid}-UAT.md`);
+    assert.ok(existsSync(uatPath), "UAT.md should exist");
+    const uatContent = readFileSync(uatPath, "utf-8");
+    assert.ok(uatContent.includes("npm test"), "UAT should contain verification content");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("mechanical: returns false for empty task summaries", async () => {
+  const base = createTmpBase();
+  try {
+    const mid = "M001";
+    const sid = "S01";
+    scaffold(base, mid, sid, []);
+
+    const { mechanicalSliceCompletion } = await import("../mechanical-completion.js");
+    const ok = await mechanicalSliceCompletion(base, mid, sid);
+    assert.ok(!ok, "should return false when no summaries exist");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("mechanical: returns false for insufficient summary content in multi-task slice", async () => {
+  const base = createTmpBase();
+  try {
+    const mid = "M001";
+    const sid = "S01";
+
+    // Two tasks but with very short content (under 200 chars)
+    scaffold(base, mid, sid, [
+      { tid: "T01", content: "---\nid: T01\nparent: S01\nmilestone: M001\n---\n\n# T01: A\n\n**Short**\n" },
+      { tid: "T02", content: "---\nid: T02\nparent: S01\nmilestone: M001\n---\n\n# T02: B\n\n**Brief**\n" },
+    ]);
+
+    const { mechanicalSliceCompletion } = await import("../mechanical-completion.js");
+    const ok = await mechanicalSliceCompletion(base, mid, sid);
+    assert.ok(!ok, "should return false when summaries are too short");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("mechanical: milestone verification aggregates VERIFY.json files", async () => {
+  const base = createTmpBase();
+  try {
+    const mid = "M001";
+    const sid = "S01";
+    const { tDir } = scaffold(base, mid, sid, []);
+
+    // Write VERIFY.json files
+    const evidence = {
+      schemaVersion: 1,
+      taskId: "T01",
+      unitId: "M001/S01/T01",
+      timestamp: Date.now(),
+      passed: true,
+      discoverySource: "plan",
+      checks: [
+        { command: "npm test", exitCode: 0, durationMs: 1500, verdict: "pass", blocking: true },
+      ],
+    };
+    writeFileSync(join(tDir, "T01-VERIFY.json"), JSON.stringify(evidence), "utf-8");
+
+    const evidence2 = { ...evidence, taskId: "T02", passed: false, checks: [
+      { command: "npm test", exitCode: 1, durationMs: 500, verdict: "fail", blocking: true },
+    ]};
+    writeFileSync(join(tDir, "T02-VERIFY.json"), JSON.stringify(evidence2), "utf-8");
+
+    const { aggregateMilestoneVerification } = await import("../mechanical-completion.js");
+    const result = await aggregateMilestoneVerification(base, mid);
+
+    assert.equal(result.verdict, "mixed", "should be mixed when some pass and some fail");
+    assert.equal(result.checks.length, 2, "should have 2 checks");
+
+    // Check VALIDATION.md was written
+    const validationPath = join(base, ".gsd", "milestones", mid, `${mid}-VALIDATION.md`);
+    assert.ok(existsSync(validationPath), "VALIDATION.md should exist");
+    const validationContent = readFileSync(validationPath, "utf-8");
+    assert.ok(validationContent.includes("verdict: mixed"), "should have mixed verdict in frontmatter");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("mechanical: milestone summary aggregates slice summaries", async () => {
+  const base = createTmpBase();
+  try {
+    const mid = "M001";
+
+    // Create two slices with summaries
+    for (const sid of ["S01", "S02"]) {
+      const sDir = join(base, ".gsd", "milestones", mid, "slices", sid);
+      mkdirSync(sDir, { recursive: true });
+      writeFileSync(
+        join(sDir, `${sid}-SUMMARY.md`),
+        `---\nid: ${sid}\nprovides:\n  - feature-${sid.toLowerCase()}\nkey_files:\n  - src/${sid.toLowerCase()}.ts\n---\n\n# ${sid}: Slice\n\n**${sid} implemented**\n`,
+        "utf-8",
+      );
+    }
+
+    const { generateMilestoneSummary } = await import("../mechanical-completion.js");
+    const content = await generateMilestoneSummary(base, mid);
+
+    assert.ok(content.includes("S01"), "should reference S01");
+    assert.ok(content.includes("S02"), "should reference S02");
+    assert.ok(content.includes("feature-s01"), "should aggregate provides");
+    assert.ok(content.includes("feature-s02"), "should aggregate provides");
+
+    const summaryPath = join(base, ".gsd", "milestones", mid, `${mid}-SUMMARY.md`);
+    assert.ok(existsSync(summaryPath), "M##-SUMMARY.md should exist");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("mechanical: decision deduplication skips existing decisions", async () => {
+  const base = createTmpBase();
+  try {
+    const gsdRoot = join(base, ".gsd");
+    mkdirSync(gsdRoot, { recursive: true });
+
+    // Write existing decisions
+    const decisionsPath = join(gsdRoot, "DECISIONS.md");
+    writeFileSync(decisionsPath, "# Decisions\n\n- Used TypeScript for type safety\n", "utf-8");
+
+    const { appendNewDecisions } = await import("../mechanical-completion.js");
+
+    // Call with one existing and one new decision
+    const mockSummaries = [
+      {
+        frontmatter: {
+          id: "T01", parent: "S01", milestone: "M001",
+          provides: [], requires: [], affects: [],
+          key_files: [], key_decisions: ["Used TypeScript for type safety", "Chose Express over Koa"],
+          patterns_established: [], drill_down_paths: [], observability_surfaces: [],
+          duration: "", verification_result: "passed", completed_at: "", blocker_discovered: false,
+        },
+        title: "T01", oneLiner: "", whatHappened: "", deviations: "", filesModified: [],
+      },
+    ];
+
+    await appendNewDecisions(base, mockSummaries as any);
+
+    const updated = readFileSync(decisionsPath, "utf-8");
+    assert.ok(updated.includes("Chose Express over Koa"), "should append new decision");
+    // The existing decision should not be duplicated
+    const matches = updated.match(/Used TypeScript for type safety/g);
+    assert.equal(matches?.length, 1, "should not duplicate existing decision");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/plan-slice-prompt.test.ts

@@ -25,6 +25,7 @@ const BASE_VARS = {
   outputPath: "/tmp/test-project/.gsd/milestones/M001/slices/S01/S01-PLAN.md",
   inlinedContext: "--- test inlined context ---",
   dependencySummaries: "", executorContextConstraints: "",
+  sourceFilePaths: "- **Requirements**: `.gsd/REQUIREMENTS.md`",
 };
 
 test("plan-slice prompt: commit step present when commit_docs=true", () => {