gsd-pi 2.65.0-dev.5c8557b → 2.65.0-dev.d0517ff

package/src/resources/extensions/gsd/tests/integration/state-machine-live-validation.test.ts

@@ -11,6 +11,8 @@
 
 // GSD State Machine Live Validation (#3161)
 
+
+
 import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import {
@@ -721,10 +723,10 @@ describe("state-machine-live-validation", () => {
       const result = await handleCompleteTask(makeTaskParams("T01", "S99", "M099") as any, base);
       assert.ok(!("error" in result), `expected success: ${JSON.stringify(result)}`);
 
-      // Phantom milestone created
+      // Phantom milestone created — H6 fix: now uses ID as title instead of empty string
       const milestone = getMilestone("M099");
       assert.ok(milestone, "phantom milestone M099 should exist");
-      assert.equal(milestone!.title, "", "phantom milestone has empty title");
+      assert.equal(milestone!.title, "M099", "H6 fix: phantom milestone uses ID as title");
 
       // Phantom slice created
       const slice = getSlice("M099", "S99");
@@ -895,13 +897,10 @@ describe("state-machine-live-validation", () => {
   // ─────────────────────────────────────────────────────────────────────────
 
   describe("reopen-then-redo cycle", () => {
-    test("complete → reopen → M12: stale SUMMARY causes immediate auto-reconcile", async () => {
-      // Finding M12: reopen-task does NOT delete the SUMMARY.md from disk.
-      // The reopen handler's own post-mutation hook calls renderAllProjections
-      // which triggers deriveStateFromDb, which sees the stale SUMMARY.md and
-      // auto-reconciles the task BACK to "complete" (#2514) within the same call.
-      //
-      // Result: the reopen is effectively a no-op when filesystem artifacts exist.
+    test("complete → reopen → re-complete task works end-to-end (M12 fixed)", async () => {
+      // M12 fix: reopen-task now deletes SUMMARY.md from disk before the
+      // post-mutation hook runs, preventing the reconciler from auto-correcting
+      // the task back to "complete".
       base = createFullFixture();
       openDatabase(join(base, ".gsd", "gsd.db"));
       insertMilestone({ id: "M001", title: "Active", status: "active" });
@@ -915,23 +914,23 @@ describe("state-machine-live-validation", () => {
       const summaryPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md");
       assert.ok(existsSync(summaryPath), "SUMMARY.md exists after completion");
 
-      // Reopen — handler sets DB to "pending" in transaction, but post-mutation
-      // hook triggers reconciler which immediately sets it back to "complete"
+      // Reopen — now deletes SUMMARY.md from disk (M12 fix)
       const r2 = await handleReopenTask({ milestoneId: "M001", sliceId: "S01", taskId: "T01" }, base);
-      assert.ok(!("error" in r2), `reopen handler succeeded: ${JSON.stringify(r2)}`);
+      assert.ok(!("error" in r2), `reopen: ${JSON.stringify(r2)}`);
 
-      // M12: After reopen completes, DB shows "complete" not "pending" because
-      // the reconciler auto-corrected it from the stale SUMMARY.md
-      const task = getTask("M001", "S01", "T01");
-      assert.equal(task!.status, "complete", "M12: reconciler overrides reopen — task is back to complete");
-      assert.ok(existsSync(summaryPath), "M12: SUMMARY.md was never cleaned up");
+      // Task is now properly pending — SUMMARY.md was cleaned up
+      assert.equal(getTask("M001", "S01", "T01")!.status, "pending");
+      assert.ok(!existsSync(summaryPath), "M12 fix: SUMMARY.md cleaned up by reopen");
+
+      // Re-complete succeeds
+      const r3 = await handleCompleteTask(makeTaskParams("T01", "S01", "M001") as any, base);
+      assert.ok(!("error" in r3), `re-complete: ${JSON.stringify(r3)}`);
+      assert.ok(isClosedStatus(getTask("M001", "S01", "T01")!.status));
     });
 
-    test("complete slice → reopen → M12: reconciler overrides task reset via stale SUMMARY", async () => {
-      // Same M12 pattern at the slice level: reopen-slice resets all tasks to
-      // "pending" in DB, but task SUMMARY.md artifacts remain on disk. The
-      // reopen handler's post-mutation hook triggers reconciler which sees the
-      // stale artifacts and auto-corrects tasks back to "complete".
+    test("complete slice → reopen → re-complete all works end-to-end (M12 fixed)", async () => {
+      // M12 fix: reopen-slice now deletes all SUMMARY.md and UAT.md artifacts
+      // from disk, preventing reconciler interference.
       base = createFullFixture();
       openDatabase(join(base, ".gsd", "gsd.db"));
       insertMilestone({ id: "M001", title: "Active", status: "active" });
@@ -943,17 +942,16 @@ describe("state-machine-live-validation", () => {
       await handleCompleteSlice(makeSliceParams("S01", "M001") as any, base);
       assert.ok(isClosedStatus(getSlice("M001", "S01")!.status));
 
-      // Reopen slice — transaction resets slice to in_progress and task to pending,
-      // but post-mutation hook triggers reconciler which sees stale SUMMARY.md
+      // Reopen slice — now cleans up all artifacts (M12 fix)
       await handleReopenSlice({ milestoneId: "M001", sliceId: "S01" }, base);
-
-      // Slice status is correctly in_progress (no slice SUMMARY reconciliation)
       assert.equal(getSlice("M001", "S01")!.status, "in_progress");
+      assert.equal(getTask("M001", "S01", "T01")!.status, "pending");
 
-      // M12: Task was reset to "pending" in the transaction, but reconciler
-      // already corrected it back to "complete" from the stale SUMMARY.md
-      const task = getTask("M001", "S01", "T01");
-      assert.equal(task!.status, "complete", "M12: reconciler overrides reopen — task back to complete");
+      // Re-complete task + slice succeeds
+      await handleCompleteTask(makeTaskParams("T01", "S01", "M001") as any, base);
+      const r = await handleCompleteSlice(makeSliceParams("S01", "M001") as any, base);
+      assert.ok(!("error" in r), `re-complete slice: ${JSON.stringify(r)}`);
+      assert.ok(isClosedStatus(getSlice("M001", "S01")!.status));
     });
   });
 });

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

@@ -0,0 +1,53 @@
+/**
+ * Test isolation utilities for integration tests.
+ *
+ * Integration tests often call `mergeMilestoneToMain` and other functions that
+ * load preferences. If the user's global ~/.gsd/preferences.md has
+ * `git.main_branch: master`, tests fail because test repos use `main`.
+ *
+ * These utilities isolate tests from the user's global environment.
+ */
+
+import { mkdtempSync, rmSync, realpathSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { _resetServiceCache } from "../../worktree.ts";
+import { _clearGsdRootCache } from "../../paths.ts";
+
+let originalHome: string | undefined;
+let fakeHome: string | null = null;
+
+/**
+ * Isolate the test environment from user's global preferences.
+ * Creates a fake HOME directory so loadEffectiveGSDPreferences() returns
+ * empty global preferences instead of the user's ~/.gsd/preferences.md.
+ *
+ * Call this in a test.before() hook.
+ */
+export function isolateFromGlobalPreferences(): void {
+  originalHome = process.env.HOME;
+  fakeHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-test-home-")));
+  process.env.HOME = fakeHome;
+  _clearGsdRootCache();
+  _resetServiceCache();
+}
+
+/**
+ * Restore the original HOME and clean up the fake home directory.
+ *
+ * Call this in a test.after() hook.
+ */
+export function restoreGlobalPreferences(): void {
+  if (originalHome !== undefined) {
+    process.env.HOME = originalHome;
+  } else {
+    delete process.env.HOME;
+  }
+  _clearGsdRootCache();
+  _resetServiceCache();
+  if (fakeHome) {
+    rmSync(fakeHome, { recursive: true, force: true });
+    fakeHome = null;
+  }
+}

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

@@ -0,0 +1,525 @@
+/**
+ * Integration tests for the prepared discussion system.
+ *
+ * Exercises the full preparation pipeline against the real GSD-2 codebase:
+ * - runPreparation() produces valid briefs
+ * - TypeScript is detected as primary language
+ * - Module structure includes top-level directories
+ * - Completes within R112 timing requirement (<60s)
+ * - prepareAndBuildDiscussPrompt() uses discuss-prepared template when enabled
+ * - Fallback to standard prompt when preparation is disabled
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import {
+  runPreparation,
+  formatCodebaseBrief,
+  formatPriorContextBrief,
+  formatEcosystemBrief,
+  type PreparationUIContext,
+  type PreparationPreferences,
+  type PreparationResult,
+} from "../preparation.ts";
+import { validateEnhancedContext } from "../prompt-validation.ts";
+import { getLastPreparationResult, clearPreparationResult } from "../guided-flow.ts";
+
+// ─── Test Helpers ───────────────────────────────────────────────────────────────
+
+/**
+ * Mock UI context that captures notifications for testing.
+ * Follows the pattern from preparation.test.ts.
+ */
+function createMockUI(): PreparationUIContext & { notifications: Array<{ message: string; type?: string }> } {
+  const notifications: Array<{ message: string; type?: string }> = [];
+  return {
+    notifications,
+    notify(message: string, type?: "info" | "warning" | "error" | "success") {
+      notifications.push({ message, type });
+    },
+  };
+}
+
+/**
+ * Get the GSD extension source directory for integration testing.
+ * This is the real codebase we'll analyze.
+ */
+function getGsdExtensionDir(): string {
+  // Navigate from tests/ up to gsd/ directory
+  return join(import.meta.dirname, "..");
+}
+
+/**
+ * Get the GSD-2 project root for full codebase analysis.
+ */
+function getProjectRoot(): string {
+  // Navigate from tests/ up to the project root
+  // tests/ -> gsd/ -> extensions/ -> resources/ -> src/ -> gsd-2/
+  return join(import.meta.dirname, "..", "..", "..", "..", "..");
+}
+
+// ─── R111 Validation: runPreparation against real codebase ──────────────────────
+
+test("R111: runPreparation() produces valid codebase brief for GSD extension", async (t) => {
+  const dir = getGsdExtensionDir();
+  const ui = createMockUI();
+  const prefs: PreparationPreferences = {
+    discuss_preparation: true,
+    discuss_web_research: false, // Skip web research to avoid API key requirement
+    discuss_depth: "standard",
+  };
+
+  const result = await runPreparation(dir, ui, prefs);
+
+  // Verify preparation completed successfully
+  assert.equal(result.enabled, true, "preparation should be enabled");
+  assert.ok(result.codebase, "should have codebase brief");
+  assert.ok(result.codebaseBrief, "should have formatted codebase brief");
+
+  // Verify TypeScript is detected as primary language
+  assert.equal(
+    result.codebase.techStack.primaryLanguage,
+    "javascript/typescript",
+    "should detect TypeScript as primary language",
+  );
+
+  // Verify module structure includes top-level directories
+  const topLevelDirs = result.codebase.moduleStructure.topLevelDirs;
+  assert.ok(topLevelDirs.length > 0, "should detect top-level directories");
+
+  // Common directories in the GSD extension
+  const expectedDirs = ["tests", "prompts", "templates", "migrate"];
+  const foundExpected = expectedDirs.filter(d => topLevelDirs.includes(d));
+  assert.ok(
+    foundExpected.length >= 2,
+    `should detect common directories, found: ${topLevelDirs.join(", ")}`,
+  );
+
+  // Verify sampled files exist
+  assert.ok(result.codebase.sampledFiles.length > 0, "should sample source files");
+});
+
+test("R111: runPreparation() produces valid prior context brief", async (t) => {
+  const dir = getGsdExtensionDir();
+  const ui = createMockUI();
+  const prefs: PreparationPreferences = {
+    discuss_preparation: true,
+    discuss_web_research: false,
+  };
+
+  const result = await runPreparation(dir, ui, prefs);
+
+  // Verify prior context brief structure
+  assert.ok(result.priorContext, "should have prior context");
+  assert.ok(result.priorContextBrief, "should have formatted prior context brief");
+
+  // Prior context aggregates decisions, requirements, knowledge, summaries
+  assert.ok("decisions" in result.priorContext, "should have decisions");
+  assert.ok("requirements" in result.priorContext, "should have requirements");
+  assert.ok("knowledge" in result.priorContext, "should have knowledge");
+  assert.ok("summaries" in result.priorContext, "should have summaries");
+});
+
+test("R111: runPreparation() produces valid ecosystem brief (skipped without API key)", async (t) => {
+  const dir = getGsdExtensionDir();
+  const ui = createMockUI();
+  const prefs: PreparationPreferences = {
+    discuss_preparation: true,
+    discuss_web_research: false, // Explicitly disable
+  };
+
+  const result = await runPreparation(dir, ui, prefs);
+
+  // Verify ecosystem brief structure
+  assert.ok(result.ecosystem, "should have ecosystem brief");
+  assert.ok(result.ecosystemBrief, "should have formatted ecosystem brief");
+  assert.equal(result.ecosystem.available, false, "ecosystem should be unavailable when web research disabled");
+  assert.ok(result.ecosystem.skippedReason, "should have skip reason");
+});
+
+test("R112: runPreparation() completes within 60s requirement", async (t) => {
+  const dir = getGsdExtensionDir();
+  const prefs: PreparationPreferences = {
+    discuss_preparation: true,
+    discuss_web_research: false,
+    discuss_depth: "standard",
+  };
+
+  const startTime = performance.now();
+  const result = await runPreparation(dir, null, prefs);
+  const elapsed = performance.now() - startTime;
+
+  // R112 requirement: preparation must complete within 60 seconds
+  assert.ok(result.durationMs < 60000, `should complete within 60s, took ${result.durationMs}ms`);
+  assert.ok(elapsed < 60000, `wall-clock time should be under 60s, was ${elapsed}ms`);
+
+  // Should be much faster for a local directory analysis
+  assert.ok(result.durationMs < 10000, `should typically complete within 10s, took ${result.durationMs}ms`);
+});
+
+// ─── Codebase Pattern Detection ─────────────────────────────────────────────────
+
+test("runPreparation() detects code patterns from GSD extension", async (t) => {
+  const dir = getGsdExtensionDir();
+  const prefs: PreparationPreferences = {
+    discuss_preparation: true,
+    discuss_web_research: false,
+  };
+
+  const result = await runPreparation(dir, null, prefs);
+
+  // The GSD extension uses async/await extensively
+  assert.ok(
+    result.codebase.patterns.asyncStyle === "async/await" || result.codebase.patterns.asyncStyle === "mixed",
+    `should detect async/await or mixed, got ${result.codebase.patterns.asyncStyle}`,
+  );
+
+  // The GSD extension uses try/catch for error handling
+  assert.ok(
+    result.codebase.patterns.errorHandling === "try/catch" || result.codebase.patterns.errorHandling === "mixed",
+    `should detect try/catch or mixed, got ${result.codebase.patterns.errorHandling}`,
+  );
+
+  // TypeScript uses camelCase or mixed naming
+  assert.ok(
+    result.codebase.patterns.namingConvention === "camelCase" || result.codebase.patterns.namingConvention === "mixed",
+    `should detect camelCase or mixed, got ${result.codebase.patterns.namingConvention}`,
+  );
+
+  // Evidence should be populated
+  assert.ok(result.codebase.patterns.evidence.asyncStyle.length > 0, "should have async style evidence");
+});
+
+test("runPreparation() samples TypeScript files from src/ or project root", async (t) => {
+  const dir = getGsdExtensionDir();
+  const prefs: PreparationPreferences = {
+    discuss_preparation: true,
+    discuss_web_research: false,
+  };
+
+  const result = await runPreparation(dir, null, prefs);
+
+  // Should sample TypeScript files
+  const tsFiles = result.codebase.sampledFiles.filter(
+    f => f.endsWith(".ts") || f.endsWith(".tsx"),
+  );
+  assert.ok(tsFiles.length > 0, "should sample TypeScript files");
+
+  // Should exclude test files
+  const testFiles = result.codebase.sampledFiles.filter(
+    f => f.includes(".test.") || f.includes(".spec."),
+  );
+  assert.equal(testFiles.length, 0, "should not sample test files");
+});
+
+// ─── Brief Formatting ───────────────────────────────────────────────────────────
+
+test("formatCodebaseBrief() produces LLM-readable markdown", async (t) => {
+  const dir = getGsdExtensionDir();
+  const prefs: PreparationPreferences = {
+    discuss_preparation: true,
+    discuss_web_research: false,
+  };
+
+  const result = await runPreparation(dir, null, prefs);
+  const formatted = formatCodebaseBrief(result.codebase);
+
+  // Should contain expected sections
+  assert.ok(formatted.includes("## Tech Stack"), "should have Tech Stack section");
+  assert.ok(formatted.includes("## Module Structure"), "should have Module Structure section");
+  assert.ok(formatted.includes("## Code Patterns"), "should have Code Patterns section");
+
+  // Should contain detected tech
+  assert.ok(formatted.includes("javascript/typescript"), "should include detected language");
+
+  // Should be within character limit
+  assert.ok(formatted.length <= 3000, `should cap at 3000 chars, got ${formatted.length}`);
+});
+
+test("formatPriorContextBrief() produces structured prior context output", async (t) => {
+  const dir = getGsdExtensionDir();
+  const prefs: PreparationPreferences = {
+    discuss_preparation: true,
+    discuss_web_research: false,
+  };
+
+  const result = await runPreparation(dir, null, prefs);
+  const formatted = formatPriorContextBrief(result.priorContext);
+
+  // Should contain expected sections
+  assert.ok(formatted.includes("## Prior Decisions"), "should have Prior Decisions section");
+  assert.ok(formatted.includes("## Prior Requirements"), "should have Prior Requirements section");
+  assert.ok(formatted.includes("## Prior Knowledge"), "should have Prior Knowledge section");
+  assert.ok(formatted.includes("## Prior Milestone Summaries"), "should have Prior Milestone Summaries section");
+
+  // Should be within character limit
+  assert.ok(formatted.length <= 6000, `should cap at 6000 chars, got ${formatted.length}`);
+});
+
+test("formatEcosystemBrief() returns simplified message (research happens during discussion)", async (t) => {
+  const dir = getGsdExtensionDir();
+  const prefs: PreparationPreferences = {
+    discuss_preparation: true,
+    discuss_web_research: false,
+  };
+
+  const result = await runPreparation(dir, null, prefs);
+  const formatted = formatEcosystemBrief(result.ecosystem);
+
+  // Should contain section header
+  assert.ok(formatted.includes("## Ecosystem Research"), "should have Ecosystem Research section");
+
+  // Should indicate research happens during discussion
+  assert.ok(formatted.includes("during the discussion"), "should mention research happens during discussion");
+  assert.ok(formatted.includes("web search tools"), "should mention web search tools");
+
+  // Should be within character limit
+  assert.ok(formatted.length <= 4000, `should cap at 4000 chars, got ${formatted.length}`);
+});
+
+// ─── Preparation Result Storage ─────────────────────────────────────────────────
+
+test("getLastPreparationResult() returns null initially", async (t) => {
+  // Clear any existing state
+  clearPreparationResult();
+
+  const result = getLastPreparationResult();
+  assert.equal(result, null, "should return null when no preparation has run");
+});
+
+test("clearPreparationResult() clears stored result", async (t) => {
+  // This test verifies the clear function works
+  // We can't easily test the set behavior without running the full guided-flow
+  clearPreparationResult();
+  const result = getLastPreparationResult();
+  assert.equal(result, null, "should be null after clear");
+});
+
+// ─── TUI Progress Notifications ─────────────────────────────────────────────────
+
+test("runPreparation() emits TUI progress notifications", async (t) => {
+  const dir = getGsdExtensionDir();
+  const ui = createMockUI();
+  const prefs: PreparationPreferences = {
+    discuss_preparation: true,
+    discuss_web_research: false,
+  };
+
+  await runPreparation(dir, ui, prefs);
+
+  // Should have notifications for each phase
+  assert.ok(ui.notifications.length > 0, "should have notifications");
+
+  // Verify codebase analysis notifications
+  assert.ok(
+    ui.notifications.some(n => n.message.includes("Analyzing codebase")),
+    "should show codebase analysis start",
+  );
+  assert.ok(
+    ui.notifications.some(n => n.message.includes("✓ Analyzed codebase")),
+    "should show codebase analysis complete",
+  );
+
+  // Verify prior context notifications
+  assert.ok(
+    ui.notifications.some(n => n.message.includes("Reviewing prior context")),
+    "should show prior context start",
+  );
+  assert.ok(
+    ui.notifications.some(n => n.message.includes("✓ Reviewed prior context")),
+    "should show prior context complete",
+  );
+});
+
+test("runPreparation() works in silent mode (no UI)", async (t) => {
+  const dir = getGsdExtensionDir();
+  const prefs: PreparationPreferences = {
+    discuss_preparation: true,
+    discuss_web_research: false,
+  };
+
+  // Pass null for UI
+  const result = await runPreparation(dir, null, prefs);
+
+  // Should complete without error
+  assert.equal(result.enabled, true, "should work without UI");
+  assert.ok(result.codebase, "should have codebase");
+  assert.ok(result.priorContext, "should have priorContext");
+  assert.ok(result.durationMs > 0, "should have duration");
+});
+
+// ─── Preference-Controlled Behavior ─────────────────────────────────────────────
+
+test("runPreparation() returns early when discuss_preparation is false", async (t) => {
+  const dir = getGsdExtensionDir();
+  const ui = createMockUI();
+  const prefs: PreparationPreferences = {
+    discuss_preparation: false,
+  };
+
+  const result = await runPreparation(dir, ui, prefs);
+
+  assert.equal(result.enabled, false, "should indicate preparation disabled");
+  assert.equal(result.codebaseBrief, "", "should have empty codebase brief");
+  assert.equal(result.priorContextBrief, "", "should have empty prior context brief");
+  assert.equal(result.ecosystemBrief, "", "should have empty ecosystem brief");
+  assert.equal(ui.notifications.length, 0, "should not show any notifications");
+});
+
+test("runPreparation() ecosystem research always returns unavailable (happens during discussion)", async (t) => {
+  const dir = getGsdExtensionDir();
+  const ui = createMockUI();
+  const prefs: PreparationPreferences = {
+    discuss_preparation: true,
+    discuss_web_research: true, // Even with this enabled, ecosystem research returns unavailable
+  };
+
+  const result = await runPreparation(dir, ui, prefs);
+
+  assert.equal(result.enabled, true);
+  assert.equal(result.ecosystemResearchPerformed, false, "should not perform ecosystem research from preparation");
+  assert.equal(result.ecosystem.available, false);
+  assert.ok(
+    result.ecosystem.skippedReason?.includes("during the discussion"),
+    "should indicate research happens during discussion",
+  );
+
+  // Should NOT have ecosystem research notifications (no longer part of preparation)
+  assert.ok(
+    !ui.notifications.some(n => n.message.includes("Researching ecosystem")),
+    "should not show ecosystem research notification",
+  );
+});
+
+// ─── validateEnhancedContext Integration ────────────────────────────────────────
+
+test("validateEnhancedContext() validates required sections", async (t) => {
+  // Test with valid enhanced context
+  const validContext = `# M001 — Test Milestone
+
+## Scope
+
+This milestone covers X, Y, Z.
+
+## Architectural Decisions
+
+### Decision 1: Use TypeScript
+
+We will use TypeScript for type safety.
+
+## Acceptance Criteria
+
+- [ ] Feature A works
+- [ ] Feature B works
+`;
+
+  const validResult = validateEnhancedContext(validContext);
+  assert.equal(validResult.valid, true, "should validate complete context");
+  assert.deepEqual(validResult.missing, [], "should have no missing sections");
+
+  // Test with missing sections
+  const invalidContext = `# M001 — Test Milestone
+
+## Scope
+
+This milestone covers X, Y, Z.
+`;
+
+  const invalidResult = validateEnhancedContext(invalidContext);
+  assert.equal(invalidResult.valid, false, "should reject incomplete context");
+  assert.ok(invalidResult.missing.length > 0, "should list missing sections");
+  assert.ok(
+    invalidResult.missing.some(m => m.includes("Architectural Decisions")),
+    "should report missing Architectural Decisions",
+  );
+  assert.ok(
+    invalidResult.missing.some(m => m.includes("Acceptance Criteria")),
+    "should report missing Acceptance Criteria",
+  );
+});
+
+test("validateEnhancedContext() requires decision entries in Architectural Decisions", async (t) => {
+  // Empty architectural decisions section
+  const emptyDecisions = `# M001 — Test Milestone
+
+## Scope
+
+This milestone covers X, Y, Z.
+
+## Architectural Decisions
+
+(No decisions yet)
+
+## Acceptance Criteria
+
+- [ ] Feature A works
+`;
+
+  const result = validateEnhancedContext(emptyDecisions);
+  assert.equal(result.valid, false, "should reject empty decisions section");
+  assert.ok(
+    result.missing.some(m => m.includes("decision entry")),
+    "should report missing decision entry",
+  );
+});
+
+// ─── Full Pipeline Integration ──────────────────────────────────────────────────
+
+test("Full pipeline: preparation produces consistent results across runs", async (t) => {
+  const dir = getGsdExtensionDir();
+  const prefs: PreparationPreferences = {
+    discuss_preparation: true,
+    discuss_web_research: false,
+  };
+
+  // Run preparation twice
+  const result1 = await runPreparation(dir, null, prefs);
+  const result2 = await runPreparation(dir, null, prefs);
+
+  // Results should be consistent (same codebase, same analysis)
+  assert.equal(
+    result1.codebase.techStack.primaryLanguage,
+    result2.codebase.techStack.primaryLanguage,
+    "primary language should be consistent",
+  );
+
+  assert.deepEqual(
+    result1.codebase.moduleStructure.topLevelDirs.sort(),
+    result2.codebase.moduleStructure.topLevelDirs.sort(),
+    "top-level directories should be consistent",
+  );
+
+  assert.equal(
+    result1.codebase.patterns.asyncStyle,
+    result2.codebase.patterns.asyncStyle,
+    "async style should be consistent",
+  );
+});
+
+test("Full pipeline: preparation handles empty .gsd directory gracefully", async (t) => {
+  // The GSD extension directory may or may not have a .gsd subdirectory
+  // Either way, preparation should not crash
+  const dir = getGsdExtensionDir();
+  const prefs: PreparationPreferences = {
+    discuss_preparation: true,
+    discuss_web_research: false,
+  };
+
+  let result: PreparationResult | undefined;
+  let error: unknown;
+
+  try {
+    result = await runPreparation(dir, null, prefs);
+  } catch (e) {
+    error = e;
+  }
+
+  assert.equal(error, undefined, "should not throw");
+  assert.ok(result, "should return result");
+  assert.equal(result!.enabled, true, "should be enabled");
+
+  // Prior context should gracefully handle missing files
+  assert.ok(result!.priorContext, "should have prior context even if files missing");
+});