lsd-pi 1.0.0 → 1.1.0

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

@@ -1,634 +0,0 @@
-/**
- * integration-proof.test.ts — End-to-end integration proof for M001.
- *
- * Proves all S01–S06 subsystems compose correctly:
- *   auto-migration → complete_task → complete_slice → deriveState crossval →
- *   doctor zero-fix → rogue detection → DB recovery → undo/reset
- *
- * Requirement coverage:
- *   R001 (task completion)      — step 3c
- *   R002 (slice completion)     — step 3e
- *   R003 (auto-migration)       — step 3b
- *   R004 (markdown rendering)   — steps 3d, 3f
- *   R005 (deriveState crossval) — step 3g
- *   R006 (prompt migration)     — deferred to T02 grep
- *   R007 (hierarchy migration)  — step 3b
- *   R008 (rogue detection)      — step 3i
- *   R009 (doctor zero-fix)      — step 3h
- *   R010 (DB recovery)          — step 4
- *   R011 (undo/reset)           — step 5
- *   R012 (shared WAL)           — implicit (file-backed DB uses WAL throughout)
- *   R013 (stale render)         — step 4 stale detection
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import {
-  mkdtempSync,
-  mkdirSync,
-  writeFileSync,
-  readFileSync,
-  rmSync,
-  existsSync,
-  unlinkSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-// ── DB layer ──────────────────────────────────────────────────────────────
-import {
-  openDatabase,
-  closeDatabase,
-  insertMilestone,
-  insertSlice,
-  insertTask,
-  getTask,
-  getSliceTasks,
-  getSlice,
-  updateTaskStatus,
-  updateSliceStatus,
-  transaction,
-  isDbAvailable,
-  _getAdapter,
-} from "../../gsd-db.ts";
-
-// ── Tool handlers ─────────────────────────────────────────────────────────
-import { handleCompleteTask } from "../../tools/complete-task.ts";
-import { handleCompleteSlice } from "../../tools/complete-slice.ts";
-
-// ── Markdown renderer ─────────────────────────────────────────────────────
-import {
-  renderPlanCheckboxes,
-  renderRoadmapCheckboxes,
-  renderAllFromDb,
-  detectStaleRenders,
-  repairStaleRenders,
-} from "../../markdown-renderer.ts";
-
-// ── State derivation ──────────────────────────────────────────────────────
-import {
-  deriveStateFromDb,
-  _deriveStateImpl,
-  invalidateStateCache,
-} from "../../state.ts";
-
-// ── Auto-migration ───────────────────────────────────────────────────────
-import {
-  migrateHierarchyToDb,
-  migrateFromMarkdown,
-} from "../../md-importer.ts";
-
-// ── Post-unit diagnostics ─────────────────────────────────────────────────
-import { detectRogueFileWrites } from "../../auto-post-unit.ts";
-
-// ── Doctor ────────────────────────────────────────────────────────────────
-import { runGSDDoctor } from "../../doctor.ts";
-
-// ── Undo/reset ────────────────────────────────────────────────────────────
-import { handleUndoTask, handleResetSlice } from "../../undo.ts";
-
-// ── Cache invalidation ───────────────────────────────────────────────────
-import { invalidateAllCaches } from "../../cache.ts";
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Helpers
-// ═══════════════════════════════════════════════════════════════════════════
-
-function makeTempDir(): string {
-  return mkdtempSync(join(tmpdir(), "gsd-integration-proof-"));
-}
-
-function makeCtx(): { notifications: Array<{ message: string; level: string }>; ctx: any } {
-  const notifications: Array<{ message: string; level: string }> = [];
-  const ctx = {
-    ui: {
-      notify(message: string, level: string) {
-        notifications.push({ message, level });
-      },
-    },
-  };
-  return { notifications, ctx };
-}
-
-/**
- * Create a temp directory with a realistic .gsd/ structure:
- * - M001-ROADMAP.md with one slice (S01, two tasks T01/T02)
- * - S01-PLAN.md with two task checkboxes
- * - REQUIREMENTS.md and DECISIONS.md stubs to keep doctor happy
- */
-function createRealisticFixture(): string {
-  const base = makeTempDir();
-  const gsdDir = join(base, ".gsd");
-  const mDir = join(gsdDir, "milestones", "M001");
-  const sliceDir = join(mDir, "slices", "S01");
-  const tasksDir = join(sliceDir, "tasks");
-
-  mkdirSync(tasksDir, { recursive: true });
-  mkdirSync(join(gsdDir, "activity"), { recursive: true });
-
-  // Roadmap with exact format
-  writeFileSync(
-    join(mDir, "M001-ROADMAP.md"),
-    `# M001: Integration Proof Milestone
-
-## Vision
-
-Prove all subsystems compose.
-
-## Success Criteria
-
-- All tests pass
-
-## Slices
-
-- [ ] **S01: Core Feature** \`risk:low\` \`depends:[]\`
-  - After this: Core feature is proven end-to-end.
-
-## Boundary Map
-
-| From | To | Produces | Consumes |
-|------|----|----------|----------|
-| S01 | terminal | Working feature | nothing |
-`,
-    "utf-8",
-  );
-
-  // Plan with exact format
-  writeFileSync(
-    join(sliceDir, "S01-PLAN.md"),
-    `# S01: Core Feature
-
-**Goal:** Implement and prove the core feature.
-**Demo:** Feature works end-to-end.
-
-## Must-Haves
-
-- Feature works correctly
-
-## Tasks
-
-- [ ] **T01: First implementation** \`est:30m\`
-  - Do: Implement the first part
-  - Verify: Run tests
-
-- [ ] **T02: Second implementation** \`est:30m\`
-  - Do: Implement the second part
-  - Verify: Run tests
-
-## Files Likely Touched
-
-- src/feature.ts
-`,
-    "utf-8",
-  );
-
-  // Minimal REQUIREMENTS.md
-  writeFileSync(
-    join(gsdDir, "REQUIREMENTS.md"),
-    `# Requirements
-
-## Active
-
-| ID | Description | Owner |
-|----|-------------|-------|
-| R001 | Task completion | S01 |
-`,
-    "utf-8",
-  );
-
-  // Minimal DECISIONS.md
-  writeFileSync(
-    join(gsdDir, "DECISIONS.md"),
-    `# Decisions
-
-| ID | Decision | Choice | Rationale |
-|----|----------|--------|-----------|
-`,
-    "utf-8",
-  );
-
-  // PROJECT.md stub
-  writeFileSync(
-    join(gsdDir, "PROJECT.md"),
-    "# Integration Proof Project\n\nTest project for integration proof.\n",
-    "utf-8",
-  );
-
-  return base;
-}
-
-function makeCompleteTaskParams(taskId: string): any {
-  return {
-    taskId,
-    sliceId: "S01",
-    milestoneId: "M001",
-    oneLiner: `Completed ${taskId} successfully`,
-    narrative: `Implemented ${taskId} with full coverage.`,
-    verification: "All tests pass.",
-    keyFiles: ["src/feature.ts"],
-    keyDecisions: [],
-    deviations: "None.",
-    knownIssues: "None.",
-    blockerDiscovered: false,
-    verificationEvidence: [
-      {
-        command: "npm run test:unit",
-        exitCode: 0,
-        verdict: "✅ pass",
-        durationMs: 3000,
-      },
-    ],
-  };
-}
-
-function makeCompleteSliceParams(): any {
-  return {
-    sliceId: "S01",
-    milestoneId: "M001",
-    sliceTitle: "Core Feature",
-    oneLiner: "Core feature proven end-to-end",
-    narrative: "All tasks completed and verified.",
-    verification: "Full test suite passes.",
-    keyFiles: ["src/feature.ts"],
-    keyDecisions: [],
-    patternsEstablished: [],
-    observabilitySurfaces: [],
-    deviations: "None.",
-    knownLimitations: "None.",
-    followUps: "None.",
-    requirementsAdvanced: [],
-    requirementsValidated: [],
-    requirementsSurfaced: [],
-    requirementsInvalidated: [],
-    filesModified: [{ path: "src/feature.ts", description: "Core feature" }],
-    uatContent: "All acceptance criteria met.",
-    provides: ["core-feature"],
-    requires: [],
-    affects: [],
-    drillDownPaths: [],
-  };
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Core lifecycle: migrate → complete_task × 2 → complete_slice →
-//   deriveState crossval → doctor → rogue detection
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("full lifecycle: migration through completion through doctor", async (t) => {
-  const base = createRealisticFixture();
-  const dbPath = join(base, ".gsd", "gsd.db");
-
-  t.after(() => {
-    closeDatabase();
-    rmSync(base, { recursive: true, force: true });
-  });
-
-  // ── (a) Open file-backed DB ──────────────────────────────────────
-    const opened = openDatabase(dbPath);
-    assert.equal(opened, true, "DB should open successfully");
-    assert.equal(isDbAvailable(), true, "DB should be available");
-
-    // Verify WAL mode (R012 — implicit proof via file-backed DB)
-    const adapter = _getAdapter()!;
-    const journalMode = adapter.prepare("PRAGMA journal_mode").get();
-    assert.equal(
-      (journalMode as any)?.journal_mode,
-      "wal",
-      "file-backed DB should use WAL mode",
-    );
-
-    // ── (b) Auto-migrate markdown → DB (R003, R007) ─────────────────
-    const counts = migrateHierarchyToDb(base);
-    assert.equal(counts.milestones, 1, "should migrate 1 milestone");
-    assert.equal(counts.slices, 1, "should migrate 1 slice");
-    assert.equal(counts.tasks, 2, "should migrate 2 tasks");
-
-    // Verify DB rows after migration
-    const t1Before = getTask("M001", "S01", "T01");
-    assert.ok(t1Before, "T01 should exist in DB after migration");
-    assert.equal(t1Before!.status, "pending", "T01 should be pending after migration");
-
-    const t2Before = getTask("M001", "S01", "T02");
-    assert.ok(t2Before, "T02 should exist in DB after migration");
-    assert.equal(t2Before!.status, "pending", "T02 should be pending after migration");
-
-    // ── (c) Complete T01 and T02 via handleCompleteTask (R001) ───────
-    const r1 = await handleCompleteTask(makeCompleteTaskParams("T01"), base);
-    assert.ok(!("error" in r1), `T01 completion should succeed: ${JSON.stringify(r1)}`);
-
-    const r2 = await handleCompleteTask(makeCompleteTaskParams("T02"), base);
-    assert.ok(!("error" in r2), `T02 completion should succeed: ${JSON.stringify(r2)}`);
-
-    // ── (d) Verify DB rows and markdown summaries on disk (R004) ─────
-    const t1After = getTask("M001", "S01", "T01");
-    assert.equal(t1After!.status, "complete", "T01 should be complete in DB");
-    assert.ok(t1After!.one_liner, "T01 should have one_liner in DB");
-
-    const t2After = getTask("M001", "S01", "T02");
-    assert.equal(t2After!.status, "complete", "T02 should be complete in DB");
-
-    // Verify T01-SUMMARY.md on disk
-    if (!("error" in r1)) {
-      assert.ok(existsSync(r1.summaryPath), "T01 summary file should exist on disk");
-      const t1Summary = readFileSync(r1.summaryPath, "utf-8");
-      assert.match(t1Summary, /id: T01/, "T01 summary should contain frontmatter");
-      assert.match(t1Summary, /Completed T01 successfully/, "T01 summary should contain one-liner");
-    }
-
-    // Verify plan checkboxes toggled
-    const planPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
-    const planAfterTasks = readFileSync(planPath, "utf-8");
-    assert.match(planAfterTasks, /\[x\]\s+\*\*T01:/, "T01 should be checked in plan");
-    assert.match(planAfterTasks, /\[x\]\s+\*\*T02:/, "T02 should be checked in plan");
-
-    // ── (e) Complete slice via handleCompleteSlice (R002) ─────────────
-    invalidateAllCaches();
-    const sliceResult = await handleCompleteSlice(makeCompleteSliceParams(), base);
-    assert.ok(!("error" in sliceResult), `Slice completion should succeed: ${JSON.stringify(sliceResult)}`);
-
-    // ── (f) Verify slice artifacts on disk (R004) ────────────────────
-    if (!("error" in sliceResult)) {
-      assert.ok(existsSync(sliceResult.summaryPath), "Slice summary should exist on disk");
-      assert.ok(existsSync(sliceResult.uatPath), "Slice UAT should exist on disk");
-
-      const sliceSummary = readFileSync(sliceResult.summaryPath, "utf-8");
-      assert.match(sliceSummary, /id: S01/, "Slice summary should contain frontmatter");
-      assert.match(sliceSummary, /Core feature proven/, "Slice summary should contain one-liner");
-    }
-
-    // Verify roadmap checkbox toggled
-    const roadmapPath = join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
-    const roadmapAfter = readFileSync(roadmapPath, "utf-8");
-    assert.ok(roadmapAfter.includes("\u2705"), "S01 should be checked in roadmap (✅ emoji in table format)");
-
-    // Verify slice status in DB
-    const sliceRow = getSlice("M001", "S01");
-    assert.equal(sliceRow?.status, "complete", "S01 should be complete in DB");
-
-    // ── (g) deriveState cross-validation (R005) ──────────────────────
-    invalidateStateCache();
-    invalidateAllCaches();
-    const dbState = await deriveStateFromDb(base);
-    const fileState = await _deriveStateImpl(base);
-
-    // DB state is authoritative (single-writer engine). Filesystem parser may not
-    // parse the new table-format roadmap projections, so cross-validation is relaxed
-    // to only check DB state correctness.
-    assert.ok(dbState.activeMilestone?.id, "DB should have an active milestone");
-    assert.ok(dbState.registry.length > 0, "DB registry should have entries");
-
-    // ── (h) Doctor zero-fix (R009) ───────────────────────────────────
-    const doctorReport = await runGSDDoctor(base, {
-      fix: false,
-      isolationMode: "none",
-    });
-    // Filter to only errors (warnings/info about env, git, etc. are expected in a temp dir)
-    const errors = doctorReport.issues.filter(i => i.severity === "error");
-    // Doctor should produce zero fixable reconciliation issues on a healthy state
-    const reconciliationErrors = errors.filter(i =>
-      i.code.includes("checkbox") || i.code.includes("reconcil") || i.code.includes("cascade"),
-    );
-    assert.equal(
-      reconciliationErrors.length,
-      0,
-      `Doctor should find zero reconciliation errors, got: ${JSON.stringify(reconciliationErrors)}`,
-    );
-
-    // ── (i) Rogue file detection (R008) ──────────────────────────────
-    // Write a fake summary for a non-DB-tracked task T99
-    const rogueDir = join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks");
-    writeFileSync(join(rogueDir, "T99-SUMMARY.md"), "# Rogue Summary\n", "utf-8");
-
-    // Clear path cache so resolveTaskFile sees the newly written file
-    const { clearPathCache } = await import("../../paths.ts");
-    clearPathCache();
-
-    const rogues = detectRogueFileWrites("execute-task", "M001/S01/T99", base);
-    assert.ok(rogues.length > 0, "Should detect rogue file write for T99");
-    assert.equal(rogues[0].unitId, "M001/S01/T99", "Rogue detection should identify the correct unit");
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Recovery: DB deletion → migrateFromMarkdown → state reconstruction (R010)
-// Stale render detection (R013)
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("recovery: DB loss → migrateFromMarkdown restores state, stale render detection", async (t) => {
-  const base = createRealisticFixture();
-  const dbPath = join(base, ".gsd", "gsd.db");
-
-  t.after(() => {
-    closeDatabase();
-    rmSync(base, { recursive: true, force: true });
-  });
-
-  // Set up a completed state first
-    openDatabase(dbPath);
-    migrateHierarchyToDb(base);
-    await handleCompleteTask(makeCompleteTaskParams("T01"), base);
-    await handleCompleteTask(makeCompleteTaskParams("T02"), base);
-    invalidateAllCaches();
-    await handleCompleteSlice(makeCompleteSliceParams(), base);
-
-    // Verify we have a healthy DB with completed state
-    const sliceBefore = getSlice("M001", "S01");
-    assert.equal(sliceBefore?.status, "complete", "Slice should be complete before recovery test");
-
-    // ── Stale render detection (R013) ────────────────────────────────
-    // Mutate a task status in DB to create a stale condition
-    // (DB says pending but plan checkbox says [x])
-    updateTaskStatus("M001", "S01", "T01", "pending", new Date().toISOString());
-    invalidateAllCaches();
-
-    const staleEntries = detectStaleRenders(base);
-    assert.ok(staleEntries.length > 0, "Should detect stale renders after DB mutation");
-
-    // Restore the task status for the recovery test
-    updateTaskStatus("M001", "S01", "T01", "complete", new Date().toISOString());
-
-    // ── DB deletion + recovery (R010) ────────────────────────────────
-    closeDatabase();
-
-    // Delete the DB file and any WAL/SHM files
-    for (const suffix of ["", "-wal", "-shm"]) {
-      const f = dbPath + suffix;
-      if (existsSync(f)) unlinkSync(f);
-    }
-
-    assert.equal(existsSync(dbPath), false, "DB file should be deleted");
-
-    // Clear path caches so gsdRoot re-probes after DB deletion
-    const { clearPathCache: clearPaths } = await import("../../paths.ts");
-    clearPaths();
-    invalidateAllCaches();
-
-    // Recover from markdown — migrateFromMarkdown takes basePath (project root)
-    const recoveryResult = migrateFromMarkdown(base);
-
-    assert.ok(
-      recoveryResult.hierarchy.milestones >= 1,
-      "Recovery should import at least 1 milestone",
-    );
-    assert.ok(
-      recoveryResult.hierarchy.slices >= 1,
-      "Recovery should import at least 1 slice",
-    );
-    assert.ok(
-      recoveryResult.hierarchy.tasks >= 2,
-      "Recovery should import at least 2 tasks",
-    );
-
-    // Verify state is reconstructed — slice should be complete (roadmap says [x])
-    const sliceAfter = getSlice("M001", "S01");
-    assert.ok(sliceAfter, "S01 should exist in DB after recovery");
-    assert.equal(
-      sliceAfter!.status,
-      "complete",
-      "S01 should be complete after recovery (roadmap checkbox was [x])",
-    );
-
-    // Tasks should be complete too (plan checkboxes were [x])
-    const t1Recovered = getTask("M001", "S01", "T01");
-    assert.ok(t1Recovered, "T01 should exist after recovery");
-    assert.equal(t1Recovered!.status, "complete", "T01 should be complete after recovery");
-
-    const t2Recovered = getTask("M001", "S01", "T02");
-    assert.ok(t2Recovered, "T02 should exist after recovery");
-    assert.equal(t2Recovered!.status, "complete", "T02 should be complete after recovery");
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Undo/reset: handleUndoTask + handleResetSlice (R011)
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("undo/reset: undo task and reset slice revert DB + markdown", async (t) => {
-  const base = createRealisticFixture();
-  const dbPath = join(base, ".gsd", "gsd.db");
-
-  t.after(() => {
-    closeDatabase();
-    rmSync(base, { recursive: true, force: true });
-  });
-
-  // Build up completed state
-    openDatabase(dbPath);
-    migrateHierarchyToDb(base);
-    await handleCompleteTask(makeCompleteTaskParams("T01"), base);
-    await handleCompleteTask(makeCompleteTaskParams("T02"), base);
-    invalidateAllCaches();
-    await handleCompleteSlice(makeCompleteSliceParams(), base);
-
-    // Verify completed state
-    assert.equal(getTask("M001", "S01", "T01")?.status, "complete");
-    assert.equal(getTask("M001", "S01", "T02")?.status, "complete");
-    assert.equal(getSlice("M001", "S01")?.status, "complete");
-
-    // ── Undo T01 ─────────────────────────────────────────────────────
-    const { notifications: undoNotifs, ctx: undoCtx } = makeCtx();
-    await handleUndoTask("M001/S01/T01 --force", undoCtx, {} as any, base);
-
-    // DB status should revert
-    const t1Undone = getTask("M001", "S01", "T01");
-    assert.equal(t1Undone?.status, "pending", "T01 should be pending after undo");
-
-    // T01 summary file should be deleted
-    const t1SummaryPath = join(
-      base,
-      ".gsd",
-      "milestones",
-      "M001",
-      "slices",
-      "S01",
-      "tasks",
-      "T01-SUMMARY.md",
-    );
-    assert.equal(existsSync(t1SummaryPath), false, "T01 summary should be deleted after undo");
-
-    // Plan checkbox should be unchecked
-    const planPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
-    const planAfterUndo = readFileSync(planPath, "utf-8");
-    assert.match(planAfterUndo, /\[ \]\s+\*\*T01:/, "T01 should be unchecked in plan after undo");
-
-    // T02 should still be complete
-    assert.equal(getTask("M001", "S01", "T02")?.status, "complete", "T02 should still be complete");
-
-    // Undo notification should be success
-    assert.ok(
-      undoNotifs.some(n => n.level === "success"),
-      "Undo should produce success notification",
-    );
-
-    // ── Reset S01 ────────────────────────────────────────────────────
-    // Re-complete T01 first so we can reset the whole slice
-    await handleCompleteTask(makeCompleteTaskParams("T01"), base);
-    invalidateAllCaches();
-
-    // Re-complete slice
-    await handleCompleteSlice(makeCompleteSliceParams(), base);
-
-    const { notifications: resetNotifs, ctx: resetCtx } = makeCtx();
-    await handleResetSlice("M001/S01 --force", resetCtx, {} as any, base);
-
-    // All tasks should be pending
-    assert.equal(getTask("M001", "S01", "T01")?.status, "pending", "T01 should be pending after reset");
-    assert.equal(getTask("M001", "S01", "T02")?.status, "pending", "T02 should be pending after reset");
-
-    // Slice should be active (not complete)
-    const sliceAfterReset = getSlice("M001", "S01");
-    assert.equal(sliceAfterReset?.status, "active", "S01 should be active after reset");
-
-    // Task summaries should be deleted
-    assert.equal(existsSync(t1SummaryPath), false, "T01 summary should be deleted after reset");
-    const t2SummaryPath = join(
-      base,
-      ".gsd",
-      "milestones",
-      "M001",
-      "slices",
-      "S01",
-      "tasks",
-      "T02-SUMMARY.md",
-    );
-    assert.equal(existsSync(t2SummaryPath), false, "T02 summary should be deleted after reset");
-
-    // Slice summary and UAT should be deleted
-    const sliceSummaryPath = join(
-      base,
-      ".gsd",
-      "milestones",
-      "M001",
-      "slices",
-      "S01",
-      "S01-SUMMARY.md",
-    );
-    const sliceUatPath = join(
-      base,
-      ".gsd",
-      "milestones",
-      "M001",
-      "slices",
-      "S01",
-      "S01-UAT.md",
-    );
-    assert.equal(existsSync(sliceSummaryPath), false, "Slice summary should be deleted after reset");
-    assert.equal(existsSync(sliceUatPath), false, "Slice UAT should be deleted after reset");
-
-    // Plan checkboxes should be unchecked
-    const planAfterReset = readFileSync(planPath, "utf-8");
-    assert.ok(planAfterReset.includes("[ ] **T01:"), "T01 should be unchecked after reset");
-    assert.ok(planAfterReset.includes("[ ] **T02:"), "T02 should be unchecked after reset");
-
-    // DB state is authoritative — verify slice status in DB rather than roadmap file
-    // (roadmap projection format changed and undo module may not re-render it)
-    const sliceAfterResetDb = getSlice("M001", "S01");
-    assert.ok(
-      sliceAfterResetDb?.status !== "complete" && sliceAfterResetDb?.status !== "done",
-      "S01 should not be complete in DB after reset",
-    );
-
-    // Reset notification should be success
-    assert.ok(
-      resetNotifs.some(n => n.level === "success"),
-      "Reset should produce success notification",
-    );
-});