gsd-pi 2.43.0 → 2.44.0-dev.848dd4c

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

@@ -0,0 +1,643 @@
+/**
+ * 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.match(roadmapAfter, /\[x\]\s+\*\*S01:/, "S01 should be checked in roadmap");
+
+    // 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);
+
+    // Both paths should agree on key fields
+    assert.equal(
+      dbState.activeMilestone?.id ?? null,
+      fileState.activeMilestone?.id ?? null,
+      "activeMilestone.id should match between DB and filesystem paths",
+    );
+    assert.equal(
+      dbState.activeSlice?.id ?? null,
+      fileState.activeSlice?.id ?? null,
+      "activeSlice.id should match between DB and filesystem paths",
+    );
+    assert.equal(dbState.phase, fileState.phase, "phase should match between DB and filesystem paths");
+    assert.equal(
+      dbState.registry.length,
+      fileState.registry.length,
+      "registry length should match",
+    );
+
+    // ── (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.match(planAfterReset, /\[ \]\s+\*\*T01:/, "T01 should be unchecked after reset");
+    assert.match(planAfterReset, /\[ \]\s+\*\*T02:/, "T02 should be unchecked after reset");
+
+    // Roadmap checkbox should be unchecked
+    const roadmapPath = join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
+    const roadmapAfterReset = readFileSync(roadmapPath, "utf-8");
+    assert.match(roadmapAfterReset, /\[ \]\s+\*\*S01:/, "S01 should be unchecked in roadmap after reset");
+
+    // Reset notification should be success
+    assert.ok(
+      resetNotifs.some(n => n.level === "success"),
+      "Reset should produce success notification",
+    );
+});

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

@@ -91,8 +91,6 @@ function makeMockDeps(
     runPreDispatchHooks: () => ({ firedHooks: [], action: "proceed" }),
     getPriorSliceCompletionBlocker: () => null,
     getMainBranch: () => "main",
-    collectObservabilityWarnings: async () => [],
-    buildObservabilityRepairBlock: () => null,
     closeoutUnit: async () => {},
     verifyExpectedArtifact: () => true,
     clearUnitRuntimeRecord: () => {},
@@ -287,7 +285,6 @@ test("runUnitPhase emits unit-start and unit-end with causedBy reference", async
     prompt: "do stuff",
     finalPrompt: "do stuff",
     pauseAfterUatDispatch: false,
-    observabilityIssues: [],
     state: { phase: "executing", activeMilestone: { id: "M001" }, activeSlice: { id: "S01" }, registry: [], blockers: [] } as any,
     mid: "M001",
     midTitle: "Test",