gsd-pi 2.78.1-dev.84a383f51 → 2.78.1

package/src/resources/extensions/gsd/tests/completed-at-reconcile.test.ts

@@ -1,99 +1,42 @@
 /**
- * Behavioural regression test for #4129.
+ * Regression test for #4129: tasks.completed_at stays NULL when status is
+ * reconciled to 'complete' via the file-existence path in state.ts.
  *
- * When deriveStateFromDb's reconcileSliceTasks finds a SUMMARY.md on disk
- * for a task whose DB row is still pending, it flips the row to "complete".
- * Before #4129, the call to updateTaskStatus omitted the completedAt
- * timestamp, leaving completed_at NULL forever.
+ * Root cause: reconcileSliceTasks called
+ *   updateTaskStatus(milestoneId, sliceId, t.id, "complete")
+ * without a completedAt timestamp, so the column stays NULL.
  *
- * The fix passes new Date().toISOString() as the 5th argument; this test
- * exercises that path end-to-end and asserts the column is populated.
- *
- * Refs #4829 (rewrite from positional source-grep).
+ * Fix: pass new Date().toISOString() as the 5th argument.
  */
 
-import { describe, test, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-import { deriveStateFromDb, invalidateStateCache } from '../state.ts';
-import {
-  openDatabase,
-  closeDatabase,
-  insertMilestone,
-  insertSlice,
-  insertTask,
-  getTask,
-} from '../gsd-db.ts';
-
-let basePath: string;
-
-function setupProject(): void {
-  basePath = mkdtempSync(join(tmpdir(), 'gsd-completed-at-'));
-  // Project structure with active milestone, one slice, one task whose
-  // SUMMARY.md is already on disk — but the DB row is still "pending".
-  mkdirSync(join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks'), { recursive: true });
-
-  // CONTEXT + ROADMAP so deriveState identifies M001 as active and S01 as the active slice.
-  writeFileSync(
-    join(basePath, '.gsd', 'milestones', 'M001', 'M001-CONTEXT.md'),
-    '# M001\nActive milestone.\n',
-  );
-  writeFileSync(
-    join(basePath, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md'),
-    `# M001\n\n## Slices\n\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  - After this: works\n`,
-  );
-
-  // Plan file for the slice so reconcile can populate task list if DB is empty.
-  writeFileSync(
-    join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'S01-PLAN.md'),
-    `# S01: Slice\n\n## Tasks\n\n- [ ] **T01: Test task** \`est:30m\`\n  - Do: x\n  - Verify: y\n`,
-  );
-
-  // The summary file: this is the on-disk evidence that flips the task
-  // status to "complete" inside reconcileSliceTasks.
-  writeFileSync(
-    join(basePath, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks', 'T01-SUMMARY.md'),
-    '---\nid: T01\nparent: S01\nmilestone: M001\nblocker_discovered: false\n---\n# T01\n',
-  );
-}
-
-describe('completed_at reconcile (#4129)', () => {
-  beforeEach(() => {
-    setupProject();
-    openDatabase(join(basePath, '.gsd', 'gsd.db'));
-    insertMilestone({ id: 'M001', title: 'M001', status: 'active' });
-    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Slice', status: 'active' });
-    // Task is "pending" in DB, but SUMMARY.md exists on disk → reconcile flips it.
-    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Test task', status: 'pending' });
-    invalidateStateCache();
-  });
-
-  afterEach(() => {
-    closeDatabase();
-    try { rmSync(basePath, { recursive: true, force: true }); } catch { /* */ }
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const stateSource = readFileSync(join(__dirname, "..", "state.ts"), "utf-8");
+
+describe("completed-at reconcile (#4129)", () => {
+  test("reconcileSliceTasks passes a completedAt timestamp when setting status to complete", () => {
+    // Before the fix, state.ts had:
+    //   updateTaskStatus(milestoneId, sliceId, t.id, "complete")
+    // which leaves completed_at NULL in the DB.
+    // After the fix, a timestamp must be passed as the 5th argument.
+    assert.doesNotMatch(
+      stateSource,
+      /updateTaskStatus\(\s*milestoneId\s*,\s*sliceId\s*,\s*t\.id\s*,\s*["']complete["']\s*\)/,
+      "updateTaskStatus must not be called without a completedAt timestamp when reconciling tasks to 'complete' (#4129)",
+    );
   });
 
-  test('reconcileSliceTasks sets completed_at when flipping a pending task to complete via SUMMARY.md', async () => {
-    const before = getTask('M001', 'S01', 'T01');
-    assert.strictEqual(before?.status, 'pending', 'task starts pending');
-    assert.strictEqual(before?.completed_at, null, 'task starts with completed_at NULL');
-
-    // Trigger the reconcile path (state.ts → reconcileSliceTasks).
-    await deriveStateFromDb(basePath);
-
-    const after = getTask('M001', 'S01', 'T01');
-    assert.strictEqual(after?.status, 'complete', 'task should be flipped to complete');
-    assert.ok(
-      typeof after?.completed_at === 'string' && after.completed_at.length > 0,
-      `completed_at must be populated by reconcileSliceTasks (#4129); got ${JSON.stringify(after?.completed_at)}`,
-    );
-    // Sanity: timestamp parses as a valid ISO date.
-    assert.ok(
-      !Number.isNaN(Date.parse(after!.completed_at!)),
-      `completed_at should be a valid ISO timestamp, got ${after!.completed_at}`,
+  test("reconcileSliceTasks passes new Date().toISOString() as the completedAt argument", () => {
+    // Positive assertion: the fixed call must include a timestamp.
+    assert.match(
+      stateSource,
+      /updateTaskStatus\(\s*milestoneId\s*,\s*sliceId\s*,\s*t\.id\s*,\s*["']complete["']\s*,\s*new Date\(\)\.toISOString\(\)\s*\)/,
+      "reconcileSliceTasks must pass new Date().toISOString() as completedAt when setting task status to 'complete' (#4129)",
     );
   });
 });

package/src/resources/extensions/gsd/tests/copy-planning-artifacts-samepath.test.ts

@@ -0,0 +1,22 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { extractSourceRegion } from "./test-helpers.ts";
+
+test("copyPlanningArtifacts skips when source and destination .gsd resolve to the same path", () => {
+  const srcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
+  const src = readFileSync(srcPath, "utf-8");
+
+  const fnIdx = src.indexOf("function copyPlanningArtifacts");
+  assert.ok(fnIdx !== -1, "copyPlanningArtifacts function exists");
+
+  const fnBody = extractSourceRegion(src, "function copyPlanningArtifacts");
+
+  const guardIdx = fnBody.indexOf("if (isSamePath(srcGsd, dstGsd)) return;");
+  const copyIdx = fnBody.indexOf("safeCopyRecursive(join(srcGsd, \"milestones\")");
+
+  assert.ok(guardIdx !== -1, "copyPlanningArtifacts should guard same-path .gsd copies");
+  assert.ok(copyIdx !== -1, "copyPlanningArtifacts should still copy milestones when paths differ");
+  assert.ok(guardIdx < copyIdx, "same-path guard should run before any copy attempt");
+});

package/src/resources/extensions/gsd/tests/custom-engine-loop-integration.test.ts

@@ -12,7 +12,7 @@ import { mkdtempSync, rmSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { autoLoop, resolveAgentEnd, _hasPendingResolveForTest, _resetPendingResolve } from "../auto-loop.js";
+import { autoLoop, resolveAgentEnd, _resetPendingResolve } from "../auto-loop.js";
 import type { LoopDeps } from "../auto/loop-deps.js";
 import type { SessionLockStatus } from "../session-lock.js";
 import { writeGraph, readGraph, type WorkflowGraph, type GraphStep } from "../graph.ts";
@@ -29,17 +29,6 @@ function makeTmpDir(): string {
   return dir;
 }
 
-async function resolveNextAgentEnd(timeoutMs = 3_000): Promise<void> {
-  const deadline = Date.now() + timeoutMs;
-  while (!_hasPendingResolveForTest()) {
-    if (Date.now() > deadline) {
-      throw new Error("Timed out waiting for pending agent_end resolver");
-    }
-    await new Promise((r) => setTimeout(r, 5));
-  }
-  resolveAgentEnd({ messages: [{ role: "assistant" }] });
-}
-
 afterEach(() => {
   _resetPendingResolve();
   for (const d of tmpDirs) {
@@ -287,16 +276,19 @@ describe("Custom engine loop integration", () => {
     // We need to resolve resolveAgentEnd for each step.
 
     // Step 1: step-a
+    await new Promise((r) => setTimeout(r, 80));
     unitCount++;
-    await resolveNextAgentEnd();
+    resolveAgentEnd({ messages: [{ role: "assistant" }] });
 
     // Step 2: step-b
+    await new Promise((r) => setTimeout(r, 80));
     unitCount++;
-    await resolveNextAgentEnd();
+    resolveAgentEnd({ messages: [{ role: "assistant" }] });
 
     // Step 3: step-c
+    await new Promise((r) => setTimeout(r, 80));
     unitCount++;
-    await resolveNextAgentEnd();
+    resolveAgentEnd({ messages: [{ role: "assistant" }] });
 
     // After step-c completes, engine.reconcile marks it complete, then
     // next deriveState sees isComplete=true → stopAuto → loop exits
@@ -406,7 +398,8 @@ describe("Custom engine loop integration", () => {
 
     const loopPromise = autoLoop(ctx, pi, s, deps);
 
-    await resolveNextAgentEnd();
+    await new Promise((r) => setTimeout(r, 80));
+    resolveAgentEnd({ messages: [{ role: "assistant" }] });
 
     await loopPromise;
 
@@ -467,10 +460,12 @@ describe("Custom engine loop integration", () => {
     const loopPromise = autoLoop(ctx, pi, s, deps);
 
     // Resolve step-a
-    await resolveNextAgentEnd();
+    await new Promise((r) => setTimeout(r, 80));
+    resolveAgentEnd({ messages: [{ role: "assistant" }] });
 
     // Resolve step-b
-    await resolveNextAgentEnd();
+    await new Promise((r) => setTimeout(r, 80));
+    resolveAgentEnd({ messages: [{ role: "assistant" }] });
 
     await loopPromise;
 
@@ -519,9 +514,7 @@ describe("Custom engine loop integration", () => {
     });
 
     const resolver = setInterval(() => {
-      if (_hasPendingResolveForTest()) {
-        resolveAgentEnd({ messages: [{ role: "assistant" }] });
-      }
+      resolveAgentEnd({ messages: [{ role: "assistant" }] });
     }, 25);
     let timeout: NodeJS.Timeout | undefined;
     try {
@@ -576,9 +569,7 @@ describe("Custom engine loop integration", () => {
     });
     const deps1 = makeMockDeps();
     const resolver1 = setInterval(() => {
-      if (_hasPendingResolveForTest()) {
-        resolveAgentEnd({ messages: [{ role: "assistant" }] });
-      }
+      resolveAgentEnd({ messages: [{ role: "assistant" }] });
       if (pi1.calls.length >= 2) {
         s1.active = false;
       }
@@ -623,9 +614,7 @@ describe("Custom engine loop integration", () => {
       },
     });
     const resolver2 = setInterval(() => {
-      if (_hasPendingResolveForTest()) {
-        resolveAgentEnd({ messages: [{ role: "assistant" }] });
-      }
+      resolveAgentEnd({ messages: [{ role: "assistant" }] });
     }, 25);
     let timeout2: NodeJS.Timeout | undefined;
     try {
@@ -651,12 +640,7 @@ describe("Custom engine loop integration", () => {
     assert.match(stopEntry ?? "", /requested retry 4 times without passing/);
   });
 
-  it("two-step workflow drives both steps to complete and stops when isComplete fires", async () => {
-    // Note (#4831): renamed from "GRAPH.yaml step stays pending when session
-    // deactivates before reconcile" — the assertion body never proved the
-    // pending-on-deactivate claim and even comments that "the reconcile
-    // will still run for step-b". The behaviour this test actually pins is:
-    // both steps reconcile complete and stopAuto fires once isComplete.
+  it("GRAPH.yaml step stays pending when session deactivates before reconcile", async () => {
     _resetPendingResolve();
 
     // Two-step workflow: a → b. We will complete step-a, then force a break
@@ -688,30 +672,28 @@ describe("Custom engine loop integration", () => {
     const loopPromise = autoLoop(ctx, pi, s, deps);
 
     // Resolve step-a successfully
-    await resolveNextAgentEnd();
+    await new Promise((r) => setTimeout(r, 80));
+    resolveAgentEnd({ messages: [{ role: "assistant" }] });
 
     // Step-b enters runUnit — deactivate the session before resolving.
     // runUnit checks s.active after newSession and returns cancelled if false.
     // But since newSession resolves synchronously in our mock (before the
     // active check), the unit still runs. Instead, let's just cancel it.
+    await new Promise((r) => setTimeout(r, 80));
     // Resolve as cancelled to simulate a failed session
-    await resolveNextAgentEnd();
+    resolveAgentEnd({ messages: [{ role: "assistant" }] });
 
     // The reconcile will still run for step-b in this flow since
     // runUnitPhase returns "next" (not "break") for completed units.
     // After both steps complete, the engine detects isComplete and stops.
     await loopPromise;
 
-    // Both steps reconcile complete; the renamed expectation pins that the
-    // engine drives the workflow through isComplete rather than leaving any
-    // step pending.
+    // Verify step-a is complete
     const finalGraph = readGraph(runDir);
     const stepA = finalGraph.steps.find(s => s.id === "step-a");
-    const stepB = finalGraph.steps.find(s => s.id === "step-b");
     assert.equal(stepA?.status, "complete", "Step-a should be complete");
-    assert.equal(stepB?.status, "complete", "Step-b should be complete");
 
-    // The loop must stop once isComplete fires.
+    // Verify the loop stopped appropriately
     assert.ok(
       deps.callLog.some((e: string) => e.startsWith("stopAuto:")),
       "stopAuto should have been called",

package/src/resources/extensions/gsd/tests/db-path-worktree-symlink.test.ts

@@ -16,6 +16,7 @@
  * retrying can never succeed and causes cost spikes.
  */
 
+import { readFileSync } from "node:fs";
 import { join, sep } from "node:path";
 import { createTestContext } from "./test-helpers.ts";
 
@@ -88,8 +89,47 @@ assertEq(
   "Non-worktree path is unchanged",
 );
 
-// Source-grep checks for ensureDbOpen diagnostics + post-unit retry guard
-// were removed (#4826) — the behavioural retry-loop tests live in
-// auto-post-unit.test.ts and exercise isDbAvailable() directly.
+// ── Part 2: ensureDbOpen returns structured failure context ──────────────
+
+console.log("\n=== #2517 Part 2: ensureDbOpen structured diagnostics ===");
+
+const dynamicToolsSrc = readFileSync(
+  join(import.meta.dirname, "..", "bootstrap", "dynamic-tools.ts"),
+  "utf-8",
+);
+
+// ensureDbOpen should surface diagnostic context, not just boolean false
+// Check that the catch block logs error details via workflow-logger
+assertTrue(
+  dynamicToolsSrc.includes("ensureDbOpen failed") && dynamicToolsSrc.includes("logWarning"),
+  "ensureDbOpen catch block surfaces diagnostic information via logWarning instead of bare false (#2517)",
+);
+
+// ── Part 3: post-unit does NOT artifact-retry on db_unavailable ──────────
+
+console.log("\n=== #2517 Part 3: post-unit db_unavailable is infra-fatal ===");
+
+const postUnitSrc = readFileSync(
+  join(import.meta.dirname, "..", "auto-post-unit.ts"),
+  "utf-8",
+);
+
+// The artifact retry block should check DB availability and skip retry
+// when the DB is unavailable (infra failure, not a missing artifact).
+assertTrue(
+  postUnitSrc.includes("db_unavailable") || postUnitSrc.includes("isDbAvailable"),
+  "post-unit artifact retry path checks DB availability to avoid retry loop (#2517)",
+);
+
+// Verify the retry block is guarded: when !isDbAvailable(), the code must
+// NOT return "retry". The pattern should be: if (!verified && !isDbAvailable()) { skip }
+// followed by else if (!verified) { ... return "retry" }
+const dbUnavailableGuard = postUnitSrc.match(
+  /!triggerArtifactVerified\s*&&\s*!isDbAvailable\(\)/,
+);
+assertTrue(
+  !!dbUnavailableGuard,
+  "The retry block explicitly guards against !isDbAvailable() before returning 'retry' (#2517)",
+);
 
 report();

package/src/resources/extensions/gsd/tests/debug-logger.test.ts

@@ -167,11 +167,9 @@ test('auto-prunes old debug logs', () => {
   enableDebug(tmp);
 
   const files = readdirSync(debugDir).filter(f => f.startsWith('debug-') && f.endsWith('.log'));
-  // MAX_DEBUG_LOGS is 5 — enableDebug prunes to < 5 old and then creates 1 new,
-  // so the directory must hold at most 5 files in total. The previous
-  // assertion (<= 6) would have passed even with one stale log left behind
-  // (Refs #4831).
-  assert.ok(files.length <= 5, `should have pruned old logs to <= 5, got ${files.length}`);
+  // Should have at most MAX_DEBUG_LOGS (5) = 5 old + 1 new, but pruned to 5 total
+  // Actually: prunes to < 5 old, then creates 1 new = at most 5
+  assert.ok(files.length <= 6, `should have pruned old logs, got ${files.length}`);
 
   disableDebug();
 });

package/src/resources/extensions/gsd/tests/discuss-empty-db-fallback.test.ts

@@ -1,22 +1,28 @@
 /**
- * Behavioural regression tests for #2892.
+ * discuss-empty-db-fallback.test.ts — Tests for #2892.
  *
- * When the DB is open but empty (e.g. after crash/truncation),
- * getMilestoneSlices() returns []. The fix in showDiscuss() falls back to
- * parsing slices from the on-disk ROADMAP file instead of declaring "all
- * slices are complete." These tests pin the parser contract that the
- * fallback depends on: incomplete checkboxes (`[ ]`) yield `done=false`
- * slices and completed checkboxes (`[x]`) yield `done=true`.
- *
- * The earlier source-grep / regex-on-showDiscuss-body tests (audit verdicts
- * SOURCE_GREP / POSITIONAL — see #4826/#4829) were dropped; they pinned a
- * specific surface form rather than behaviour.
+ * When the DB is open but empty (e.g., after crash/truncation),
+ * getMilestoneSlices() returns [] and showDiscuss() incorrectly declares
+ * "All slices are complete." The fix adds a roadmap fallback: when the DB
+ * returns zero slices but a ROADMAP file exists, parse slices from the
+ * roadmap instead of treating zero slices as "all complete."
  */
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
 import { parseRoadmapSlices } from "../roadmap-slices.ts";
 
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function readGuidedFlowSource(): string {
+  const thisFile = fileURLToPath(import.meta.url);
+  const thisDir = dirname(thisFile);
+  return readFileSync(join(thisDir, "..", "guided-flow.ts"), "utf-8");
+}
+
 const SAMPLE_ROADMAP = `# M012 Roadmap
 
 ## Slices
@@ -28,23 +34,80 @@ const SAMPLE_ROADMAP = `# M012 Roadmap
   > After this: dashboard renders
 `;
 
-describe("discuss-empty-db-fallback parser contract (#2892)", () => {
-  test("parseRoadmapSlices extracts slices from a valid ROADMAP", () => {
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe("discuss-empty-db-fallback (#2892)", () => {
+
+  test("1. parseRoadmapSlices extracts slices from a valid ROADMAP", () => {
     const slices = parseRoadmapSlices(SAMPLE_ROADMAP);
     assert.strictEqual(slices.length, 3, "should parse 3 slices from sample roadmap");
-    const ids = slices.map(s => s.id).sort();
-    assert.deepStrictEqual(ids, ["S01", "S02", "S03"]);
+    assert.strictEqual(slices[0]!.id, "S01");
+    assert.strictEqual(slices[1]!.id, "S02");
+    assert.strictEqual(slices[2]!.id, "S03");
+    // All slices are incomplete ([ ] not [x])
+    assert.ok(slices.every(s => !s.done), "all slices should be incomplete");
   });
 
-  test("incomplete checkboxes yield done=false (so fallback shows them as pending)", () => {
-    const slices = parseRoadmapSlices(SAMPLE_ROADMAP);
+  test("2. guided-flow imports parseRoadmapSlices for roadmap fallback", () => {
+    const source = readGuidedFlowSource();
+    assert.ok(
+      source.includes("parseRoadmapSlices"),
+      "guided-flow must import parseRoadmapSlices to support roadmap fallback when DB is empty",
+    );
+  });
+
+  test("3. guided-flow has roadmap fallback when normSlices is empty but roadmapContent exists", () => {
+    const source = readGuidedFlowSource();
+    // The fix must add a fallback that checks normSlices.length === 0 && roadmapContent
+    // and repopulates normSlices from the roadmap before the pendingSlices guard.
+    //
+    // Pattern: after DB query produces normSlices, if empty + roadmap exists,
+    // fall back to parseRoadmapSlices(roadmapContent).
+    const fallbackPattern = /normSlices\.length\s*===\s*0\s*&&\s*roadmapContent/;
     assert.ok(
-      slices.every(s => s.done === false),
-      "all 3 incomplete roadmap slices must be done=false — otherwise the empty-DB fallback would falsely report them complete (#2892)",
+      fallbackPattern.test(source),
+      "guided-flow must check normSlices.length === 0 && roadmapContent to trigger roadmap fallback",
     );
   });
 
-  test("completed checkboxes yield done=true; mixed roadmap surfaces only the open slices as pending", () => {
+  test("4. guided-flow no longer has unguarded pendingSlices === 0 exit after DB-only query", () => {
+    const source = readGuidedFlowSource();
+    // Extract the showDiscuss function body
+    const fnMatch = source.match(
+      /async function showDiscuss\s*\([^)]*\)[^{]*\{([\s\S]*?)\nfunction\s/,
+    );
+    assert.ok(!!fnMatch, "showDiscuss function body must be found");
+
+    if (fnMatch) {
+      const body = fnMatch[1]!;
+      // After the DB query block (isDbAvailable/getMilestoneSlices), there should
+      // be a roadmap fallback BEFORE the pendingSlices.length === 0 check.
+      // Find the getMilestoneSlices call and the pendingSlices === 0 check
+      const dbQueryIdx = body.indexOf("getMilestoneSlices");
+      const fallbackIdx = body.indexOf("parseRoadmapSlices");
+      const pendingGuardIdx = body.indexOf('pendingSlices.length === 0');
+
+      assert.ok(dbQueryIdx > 0, "getMilestoneSlices call must exist");
+      assert.ok(fallbackIdx > 0, "parseRoadmapSlices fallback must exist");
+      assert.ok(pendingGuardIdx > 0, "pendingSlices.length === 0 guard must exist");
+      assert.ok(
+        fallbackIdx > dbQueryIdx && fallbackIdx < pendingGuardIdx,
+        "parseRoadmapSlices fallback must appear BETWEEN DB query and pendingSlices === 0 guard",
+      );
+    }
+  });
+
+  test("5. roadmap-parsed slices map to NormSlice format with done=false by default", () => {
+    // When falling back to roadmap, incomplete slices ([ ]) should map to done:false,
+    // ensuring they appear as pending and are NOT falsely reported as complete.
+    const slices = parseRoadmapSlices(SAMPLE_ROADMAP);
+    const normSlices = slices.map(s => ({ id: s.id, done: s.done, title: s.title }));
+    const pendingSlices = normSlices.filter(s => !s.done);
+    assert.strictEqual(pendingSlices.length, 3,
+      "all 3 incomplete roadmap slices should be pending — not falsely treated as complete");
+  });
+
+  test("6. roadmap with completed slices correctly reports them as done", () => {
     const completedRoadmap = `# M012 Roadmap
 
 ## Slices
@@ -56,7 +119,9 @@ describe("discuss-empty-db-fallback parser contract (#2892)", () => {
   > After this: dashboard renders
 `;
     const slices = parseRoadmapSlices(completedRoadmap);
-    const pendingIds = slices.filter(s => !s.done).map(s => s.id);
-    assert.deepStrictEqual(pendingIds, ["S02"], "only S02 should be reported as pending");
+    const normSlices = slices.map(s => ({ id: s.id, done: s.done, title: s.title }));
+    const pendingSlices = normSlices.filter(s => !s.done);
+    assert.strictEqual(pendingSlices.length, 1, "only S02 should be pending");
+    assert.strictEqual(pendingSlices[0]!.id, "S02");
   });
 });