gsd-pi 2.63.0-dev.026d309 → 2.63.0-dev.786f0ff

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

@@ -6,7 +6,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import {
@@ -382,3 +382,118 @@ test("snapshotUnitMetrics counts toolCall blocks correctly (#1713)", () => {
     rmSync(tmpBase, { recursive: true, force: true });
   }
 });
+
+// ── #1943 — Duplicate metrics entries from idle watchdog ──────────────────────
+
+test("#1943 initMetrics deduplicates entries loaded from a corrupted disk ledger", () => {
+  const tmpBase = mkdtempSync(join(tmpdir(), "gsd-metrics-dedup-load-"));
+  mkdirSync(join(tmpBase, ".gsd"), { recursive: true });
+
+  try {
+    resetMetrics();
+
+    // Simulate a corrupted metrics.json with duplicate entries on disk
+    // (same type+id+startedAt but different finishedAt — idle watchdog pattern)
+    const corruptedLedger: MetricsLedger = {
+      version: 1,
+      projectStartedAt: 1700000000000,
+      units: [
+        makeUnit({ type: "research-slice", id: "M009/S02", startedAt: 1774011016218, finishedAt: 1774011031218, cost: 1.50, tokens: { input: 6600000, output: 100000, cacheRead: 0, cacheWrite: 0, total: 6700000 } }),
+        makeUnit({ type: "research-slice", id: "M009/S02", startedAt: 1774011016218, finishedAt: 1774011046218, cost: 1.55, tokens: { input: 6800000, output: 110000, cacheRead: 0, cacheWrite: 0, total: 6910000 } }),
+        makeUnit({ type: "research-slice", id: "M009/S02", startedAt: 1774011016218, finishedAt: 1774011061218, cost: 1.60, tokens: { input: 7000000, output: 120000, cacheRead: 0, cacheWrite: 0, total: 7120000 } }),
+        makeUnit({ type: "research-slice", id: "M009/S02", startedAt: 1774011016218, finishedAt: 1774011076218, cost: 1.65, tokens: { input: 7200000, output: 130000, cacheRead: 0, cacheWrite: 0, total: 7330000 } }),
+        // A different unit — should be preserved
+        makeUnit({ type: "execute-task", id: "M001/S01/T01", startedAt: 1774012000000, finishedAt: 1774012060000, cost: 0.50 }),
+      ],
+    };
+    writeFileSync(
+      join(tmpBase, ".gsd", "metrics.json"),
+      JSON.stringify(corruptedLedger, null, 2),
+    );
+
+    // Load the corrupted ledger — duplicates should be collapsed on load
+    initMetrics(tmpBase);
+    const ledger = getLedger();
+    assert.ok(ledger);
+
+    // The 4 entries with identical (type, id, startedAt) should collapse to 1,
+    // keeping the latest (highest finishedAt). Plus the 1 different unit = 2 total.
+    assert.equal(
+      ledger!.units.length, 2,
+      `expected 2 entries after dedup (1 collapsed group + 1 unique), got ${ledger!.units.length}`,
+    );
+
+    // The surviving duplicate should be the one with the latest finishedAt
+    const researchEntry = ledger!.units.find(u => u.type === "research-slice");
+    assert.ok(researchEntry);
+    assert.equal(researchEntry!.finishedAt, 1774011076218, "should keep the latest finishedAt");
+    assert.equal(researchEntry!.cost, 1.65, "should keep the latest cost");
+
+    // The on-disk file should also be deduplicated
+    const diskRaw = readFileSync(join(tmpBase, ".gsd", "metrics.json"), "utf-8");
+    const diskLedger: MetricsLedger = JSON.parse(diskRaw);
+    assert.equal(diskLedger.units.length, 2, "disk should also have deduplicated entries");
+  } finally {
+    resetMetrics();
+    rmSync(tmpBase, { recursive: true, force: true });
+  }
+});
+
+test("#1943 getProjectTotals reports correct cost after dedup (no 35% inflation)", () => {
+  // Simulate the exact scenario from the issue: 20 entries for a single dispatch
+  // with monotonically increasing token counts and 15s-apart finishedAt values
+  const startedAt = 1774011016218;
+  const baseCost = 1.50;
+  const duplicateUnits: UnitMetrics[] = [];
+
+  for (let i = 0; i < 20; i++) {
+    duplicateUnits.push(makeUnit({
+      type: "research-slice",
+      id: "M009/S02",
+      startedAt,
+      finishedAt: startedAt + (i + 1) * 15000,
+      cost: baseCost + i * 0.05,
+      toolCalls: 0,
+      tokens: {
+        input: 6600000 + i * 200000,
+        output: 100000 + i * 10000,
+        cacheRead: 0,
+        cacheWrite: 0,
+        total: 6700000 + i * 210000,
+      },
+    }));
+  }
+
+  // Without dedup, getProjectTotals would sum all 20 entries' costs
+  const rawTotals = getProjectTotals(duplicateUnits);
+  // With dedup (only last entry should count), cost should be the last entry's cost
+  const lastEntryCost = duplicateUnits[duplicateUnits.length - 1].cost;
+
+  // This test documents the bug: raw totals inflate cost by summing duplicates
+  assert.ok(
+    rawTotals.cost > lastEntryCost * 2,
+    "raw totals with duplicates inflate cost (bug demonstration)",
+  );
+
+  // After loading through initMetrics (which should dedup), totals should be correct
+  const tmpBase = mkdtempSync(join(tmpdir(), "gsd-metrics-cost-inflation-"));
+  mkdirSync(join(tmpBase, ".gsd"), { recursive: true });
+  try {
+    resetMetrics();
+    writeFileSync(
+      join(tmpBase, ".gsd", "metrics.json"),
+      JSON.stringify({ version: 1, projectStartedAt: 1700000000000, units: duplicateUnits }, null, 2),
+    );
+    initMetrics(tmpBase);
+    const ledger = getLedger()!;
+    const dedupedTotals = getProjectTotals(ledger.units);
+    assert.equal(ledger.units.length, 1, "20 duplicates should collapse to 1 entry");
+    assert.equal(
+      dedupedTotals.cost, lastEntryCost,
+      `deduped cost should be ${lastEntryCost}, not ${dedupedTotals.cost}`,
+    );
+  } finally {
+    resetMetrics();
+    rmSync(tmpBase, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/milestone-status-tool.test.ts

@@ -0,0 +1,201 @@
+// GSD2 — Tests for gsd_milestone_status read-only query tool
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import { registerQueryTools } from "../bootstrap/query-tools.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  _getAdapter,
+} from "../gsd-db.ts";
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function makeMockPi() {
+  const tools: any[] = [];
+  return {
+    registerTool: (tool: any) => tools.push(tool),
+    tools,
+  } as any;
+}
+
+function makeTmpBase(): string {
+  const base = join(tmpdir(), `gsd-query-tool-test-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* swallow */ }
+}
+
+function openTestDb(base: string): void {
+  openDatabase(join(base, ".gsd", "gsd.db"));
+}
+
+async function executeToolInDir(tool: any, params: Record<string, unknown>, dir: string) {
+  const originalCwd = process.cwd();
+  try {
+    process.chdir(dir);
+    return await tool.execute("test-call-id", params, undefined, undefined, undefined);
+  } finally {
+    process.chdir(originalCwd);
+  }
+}
+
+// ─── Seed helpers ─────────────────────────────────────────────────────────────
+
+function seedMilestone(milestoneId: string, title: string, status = "active"): void {
+  const db = _getAdapter();
+  if (!db) throw new Error("DB not open");
+  db.prepare(
+    "INSERT OR REPLACE INTO milestones (id, title, status, created_at) VALUES (?, ?, ?, ?)",
+  ).run(milestoneId, title, status, new Date().toISOString());
+}
+
+function seedSlice(milestoneId: string, sliceId: string, status: string): void {
+  const db = _getAdapter();
+  if (!db) throw new Error("DB not open");
+  db.prepare(
+    "INSERT OR REPLACE INTO slices (milestone_id, id, title, status, created_at) VALUES (?, ?, ?, ?, ?)",
+  ).run(milestoneId, sliceId, `Slice ${sliceId}`, status, new Date().toISOString());
+}
+
+function seedTask(milestoneId: string, sliceId: string, taskId: string, status: string): void {
+  const db = _getAdapter();
+  if (!db) throw new Error("DB not open");
+  db.prepare(
+    "INSERT OR REPLACE INTO tasks (milestone_id, slice_id, id, title, status) VALUES (?, ?, ?, ?, ?)",
+  ).run(milestoneId, sliceId, taskId, `Task ${taskId}`, status);
+}
+
+// ─── Registration ─────────────────────────────────────────────────────────────
+
+test("registerQueryTools registers gsd_milestone_status tool", () => {
+  const pi = makeMockPi();
+  registerQueryTools(pi);
+  assert.equal(pi.tools.length, 1, "Should register exactly one tool");
+  assert.equal(pi.tools[0].name, "gsd_milestone_status");
+});
+
+test("gsd_milestone_status has promptGuidelines mentioning prohibited alternatives", () => {
+  const pi = makeMockPi();
+  registerQueryTools(pi);
+  const tool = pi.tools[0];
+  assert.ok(Array.isArray(tool.promptGuidelines), "promptGuidelines must be an array");
+  assert.ok(tool.promptGuidelines.length >= 1, "Must have at least one guideline");
+  const joined = tool.promptGuidelines.join(" ");
+  assert.match(joined, /sqlite3|better-sqlite3/, "Guidelines must mention prohibited alternatives");
+});
+
+// ─── Happy path: milestone with slices and tasks ──────────────────────────────
+
+test("gsd_milestone_status returns milestone metadata and slice statuses", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    seedMilestone("M001", "Test Milestone");
+    seedSlice("M001", "S01", "complete");
+    seedSlice("M001", "S02", "active");
+    seedTask("M001", "S01", "T01", "done");
+    seedTask("M001", "S01", "T02", "done");
+    seedTask("M001", "S02", "T01", "pending");
+
+    const pi = makeMockPi();
+    registerQueryTools(pi);
+    const tool = pi.tools[0];
+
+    const result = await executeToolInDir(tool, { milestoneId: "M001" }, base);
+    const parsed = JSON.parse(result.content[0].text);
+
+    assert.equal(parsed.milestoneId, "M001");
+    assert.equal(parsed.title, "Test Milestone");
+    assert.equal(parsed.status, "active");
+    assert.equal(parsed.sliceCount, 2);
+    assert.equal(parsed.slices.length, 2);
+
+    const s01 = parsed.slices.find((s: any) => s.id === "S01");
+    assert.ok(s01, "S01 should be in slices");
+    assert.equal(s01.status, "complete");
+    assert.equal(s01.taskCounts.total, 2);
+    assert.equal(s01.taskCounts.done, 2);
+
+    const s02 = parsed.slices.find((s: any) => s.id === "S02");
+    assert.ok(s02, "S02 should be in slices");
+    assert.equal(s02.status, "active");
+    assert.equal(s02.taskCounts.pending, 1);
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
+// ─── Milestone with no slices ─────────────────────────────────────────────────
+
+test("gsd_milestone_status returns empty slices array for milestone with no slices", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    seedMilestone("M002", "Empty Milestone");
+
+    const pi = makeMockPi();
+    registerQueryTools(pi);
+    const tool = pi.tools[0];
+
+    const result = await executeToolInDir(tool, { milestoneId: "M002" }, base);
+    const parsed = JSON.parse(result.content[0].text);
+
+    assert.equal(parsed.milestoneId, "M002");
+    assert.equal(parsed.sliceCount, 0);
+    assert.deepEqual(parsed.slices, []);
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
+// ─── Missing milestone ────────────────────────────────────────────────────────
+
+test("gsd_milestone_status returns not-found for missing milestone", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+
+    const pi = makeMockPi();
+    registerQueryTools(pi);
+    const tool = pi.tools[0];
+
+    const result = await executeToolInDir(tool, { milestoneId: "M999" }, base);
+    assert.match(result.content[0].text, /M999.*not found/i);
+    assert.equal(result.details.found, false);
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
+// ─── DB unavailable ───────────────────────────────────────────────────────────
+
+test("gsd_milestone_status handles missing DB gracefully", async () => {
+  // Create a directory without .gsd/ to ensure ensureDbOpen has nothing to open
+  const base = join(tmpdir(), `gsd-no-db-${randomUUID()}`);
+  mkdirSync(base, { recursive: true });
+  closeDatabase(); // ensure no prior DB is open
+  try {
+    const pi = makeMockPi();
+    registerQueryTools(pi);
+    const tool = pi.tools[0];
+
+    const result = await executeToolInDir(tool, { milestoneId: "M001" }, base);
+    assert.match(result.content[0].text, /GSD database is not available/);
+    assert.equal(result.details.error, "db_unavailable");
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/plan-milestone-title.test.ts

@@ -38,8 +38,9 @@ test("upsertMilestonePlanning updates title when DB row pre-exists with empty ti
 
     // Step 3: upsertMilestonePlanning should update the title
     upsertMilestonePlanning("M099", {
+      title: "My Important Milestone",
       vision: "Test vision",
-    }, "My Important Milestone");
+    });
     const afterUpsert = getMilestone("M099");
     assert.ok(afterUpsert);
     assert.equal(

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

@@ -4,7 +4,7 @@ import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync, writeFileSync
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
-import { openDatabase, closeDatabase, getMilestone, getMilestoneSlices, updateSliceStatus } from '../gsd-db.ts';
+import { openDatabase, closeDatabase, getMilestone, getMilestoneSlices, getSlice, updateSliceStatus, deleteSlice, insertMilestone } from '../gsd-db.ts';
 import { handlePlanMilestone } from '../tools/plan-milestone.ts';
 import { parseRoadmap } from '../parsers-legacy.ts';
 
@@ -198,33 +198,97 @@ test('handlePlanMilestone reruns idempotently and updates existing planning stat
   }
 });
 
-// Regression: #2960 — plan-milestone must refuse to overwrite completed slices
-test('handlePlanMilestone refuses to re-plan a milestone with completed slices (#2960)', async () => {
+test('handlePlanMilestone preserves completed slice status on re-plan (#2558)', async () => {
   const base = makeTmpBase();
   const dbPath = join(base, '.gsd', 'gsd.db');
   openDatabase(dbPath);
 
   try {
-    // First plan succeeds
+    // Initial plan — both slices start as "pending"
     const first = await handlePlanMilestone(validParams(), base);
-    assert.ok(!('error' in first), `initial plan should succeed: ${'error' in first ? first.error : ''}`);
+    assert.ok(!('error' in first), `unexpected error: ${'error' in first ? first.error : ''}`);
 
-    // Mark S01 as complete
-    updateSliceStatus('M001', 'S01', 'complete');
+    // Mark S01 as complete (simulates work done in a worktree)
+    updateSliceStatus('M001', 'S01', 'complete', new Date().toISOString());
 
-    // Second plan should fail — S01 is already complete
-    const second = await handlePlanMilestone({
+    const s01Before = getSlice('M001', 'S01');
+    assert.equal(s01Before?.status, 'complete', 'S01 should be complete before re-plan');
+
+    // Re-plan the same milestone — S01 must stay "complete", S02 stays "pending"
+    const second = await handlePlanMilestone(validParams(), base);
+    assert.ok(!('error' in second), `unexpected error: ${'error' in second ? second.error : ''}`);
+
+    const s01After = getSlice('M001', 'S01');
+    assert.equal(s01After?.status, 'complete', 'S01 status must be preserved as complete after re-plan');
+
+    const s02After = getSlice('M001', 'S02');
+    assert.equal(s02After?.status, 'pending', 'S02 should remain pending');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('plan-milestone re-plan preserves completed status and updates slice fields (#2558)', async () => {
+  const base = makeTmpBase();
+  const dbPath = join(base, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+
+  try {
+    // Initial plan — both slices start as "pending"
+    const first = await handlePlanMilestone(validParams(), base);
+    assert.ok(!('error' in first), `unexpected error: ${'error' in first ? first.error : ''}`);
+
+    // Mark S01 as complete (simulates work done in worktree, then reconciled)
+    updateSliceStatus('M001', 'S01', 'complete', new Date().toISOString());
+    assert.equal(getSlice('M001', 'S01')?.status, 'complete');
+
+    // Re-plan with updated title for S01.
+    // The handler must:
+    //   1. NOT downgrade S01 from "complete" to "pending"
+    //   2. Update S01's non-status fields (title, risk, depends, demo)
+    //   3. Keep S02 as "pending"
+    const updatedParams = {
       ...validParams(),
-      vision: 'Should not overwrite',
-    }, base);
-    assert.ok('error' in second, 'should refuse to re-plan when slices are completed');
-    assert.match(second.error, /cannot re-plan/i);
-    assert.match(second.error, /S01/);
+      slices: [
+        { ...validParams().slices[0], title: 'Updated S01 title', risk: 'high' },
+        validParams().slices[1],
+      ],
+    };
+    const second = await handlePlanMilestone(updatedParams, base);
+    assert.ok(!('error' in second), `unexpected error: ${'error' in second ? second.error : ''}`);
 
-    // Verify the completed slice was not overwritten
-    const slices = getMilestoneSlices('M001');
-    const s01 = slices.find(s => s.id === 'S01');
-    assert.equal(s01?.status, 'complete', 'S01 should still be complete');
+    const s01After = getSlice('M001', 'S01');
+    assert.equal(s01After?.status, 'complete', 'completed slice status must survive re-plan');
+    assert.equal(s01After?.title, 'Updated S01 title', 'title should update on re-plan');
+    assert.equal(s01After?.risk, 'high', 'risk should update on re-plan');
+
+    const s02After = getSlice('M001', 'S02');
+    assert.equal(s02After?.status, 'pending', 'pending slice stays pending');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanMilestone promotes pre-existing queued milestone to active (#3022)', async () => {
+  const base = makeTmpBase();
+  const dbPath = join(base, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+
+  try {
+    // Simulate ensureMilestoneDbRow: pre-create row with status "queued"
+    // (this is what gsd_milestone_generate_id does)
+    insertMilestone({ id: 'M001', status: 'queued' });
+
+    const before = getMilestone('M001');
+    assert.equal(before?.status, 'queued', 'pre-condition: milestone should start as queued');
+
+    // Now plan the milestone — status should be promoted to "active"
+    const result = await handlePlanMilestone(validParams(), base);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+    const after = getMilestone('M001');
+    assert.equal(after?.status, 'active', 'milestone status should be promoted from queued to active');
+    assert.equal(after?.title, 'DB-backed planning', 'milestone title should be set');
   } finally {
     cleanup(base);
   }

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

@@ -412,6 +412,16 @@ test("unrecognized format warning is emitted at most once (#2373)", () => {
   }
 });
 
+test("parsePreferencesMarkdown parses heading+list format without frontmatter (#2036)", () => {
+  // A GSD agent recovery session wrote preferences in markdown heading+list
+  // format instead of YAML frontmatter. Since the heading+list fallback parser
+  // was added, this format is now handled gracefully.
+  const content = "## Git\n\n- isolation: none\n";
+  const result = parsePreferencesMarkdown(content);
+  assert.notEqual(result, null, "heading+list content should be parsed");
+  assert.deepStrictEqual(result!.git, { isolation: "none" });
+});
+
 // ── Experimental preferences ─────────────────────────────────────────────────
 
 test("experimental.rtk: true is accepted and stored", () => {

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

@@ -231,6 +231,31 @@ test("complete-slice prompt uses camelCase parameter names matching TypeBox sche
   assert.match(toolCallLine!, /sliceId/);
 });
 
+// ─── File system safety: complete-slice parity with complete-milestone (#2935) ──
+
+test("complete-slice prompt includes filesystem safety guard against EISDIR", () => {
+  const prompt = readPrompt("complete-slice");
+  assert.match(
+    prompt,
+    /File system safety/i,
+    "complete-slice.md must include a 'File system safety' instruction to prevent EISDIR errors when the LLM passes a directory path to the read tool"
+  );
+  assert.match(
+    prompt,
+    /never pass.*directory path.*directly to the.*read.*tool/i,
+    "complete-slice.md must warn against passing directory paths to the read tool"
+  );
+});
+
+test("complete-milestone prompt still has its filesystem safety guard (regression)", () => {
+  const prompt = readPrompt("complete-milestone");
+  assert.match(
+    prompt,
+    /File system safety/i,
+    "complete-milestone.md must keep its filesystem safety guard"
+  );
+});
+
 test("reactive-execute prompt references tool calls instead of checkbox updates", () => {
   const prompt = readPrompt("reactive-execute");
   assert.doesNotMatch(prompt, /checkbox updates/);

package/src/resources/extensions/gsd/tests/roadmap-slices.test.ts

@@ -133,6 +133,19 @@ test("parseRoadmapSlices: table with glyph completion markers (#2841)", () => {
   assert.equal(slices[3]?.done, true);
 });
 
+test("parseRoadmapSlices: table with heavy check mark U+2714 (#2940)", () => {
+  const tableContent = [
+    "# M003: Heavy Check", "", "## Slices", "",
+    "| Slice | Title | Risk | Status |", "|---|---|---|---|",
+    "| S01 | First | Low | \u2714 |",
+    "| S02 | Second | High | Pending |", "",
+  ].join("\n");
+  const slices = parseRoadmapSlices(tableContent);
+  assert.equal(slices.length, 2);
+  assert.equal(slices[0]?.done, true, "U+2714 heavy check mark should mark slice as done");
+  assert.equal(slices[1]?.done, false);
+});
+
 test("parseRoadmapSlices: table with dependencies column (#1736)", () => {
   const tableContent = [
     "# M004: Deps", "", "## Slices", "",
@@ -393,3 +406,59 @@ test("parseRoadmapSlices: indented H3 headers under ## Slices (#2567)", () => {
   assert.equal(slices[1]?.id, "S02");
   assert.equal(slices[1]?.title, "Build");
 });
+
+// ── Regression tests for #1884: ✅ (U+2705) completion marker ──────────────
+
+test("parseRoadmapSlices: prose headers with ✅ suffix detected as done (#1884)", () => {
+  const proseContent = `# M013: Prose Roadmap
+
+### S01: Plan Limits & Billing Foundation ✅
+All tasks done.
+
+### S02: Usage Tracking
+Not done yet.
+
+### S03: Notification System ✅
+Also done.
+`;
+  const slices = parseRoadmapSlices(proseContent);
+  assert.equal(slices.length, 3);
+  assert.equal(slices[0]?.id, "S01");
+  assert.equal(slices[0]?.done, true, "S01 with trailing ✅ should be done");
+  assert.equal(slices[0]?.title, "Plan Limits & Billing Foundation");
+  assert.equal(slices[1]?.done, false);
+  assert.equal(slices[2]?.done, true, "S03 with trailing ✅ should be done");
+  assert.equal(slices[2]?.title, "Notification System");
+});
+
+test("parseRoadmapSlices: prose headers with ✅ prefix before title detected as done (#1884)", () => {
+  const proseContent = `# M014: Prose
+
+## ✅ S01: Done Slice
+Complete.
+
+## S02: Pending Slice
+Not done.
+`;
+  const slices = parseRoadmapSlices(proseContent);
+  assert.equal(slices.length, 2);
+  assert.equal(slices[0]?.done, true, "prefix ✅ should mark as done");
+  assert.equal(slices[0]?.title, "Done Slice");
+  assert.equal(slices[1]?.done, false);
+});
+
+test("parseRoadmapSlices: prose headers with ✅ after separator detected as done (#1884)", () => {
+  const proseContent = `# M015: Prose
+
+## S01: ✅ First Feature
+Done.
+
+## S02: Second Feature
+Not done.
+`;
+  const slices = parseRoadmapSlices(proseContent);
+  assert.equal(slices.length, 2);
+  assert.equal(slices[0]?.done, true, "✅ after colon should mark as done");
+  assert.equal(slices[0]?.title, "First Feature");
+  assert.equal(slices[1]?.done, false);
+});

package/src/resources/extensions/gsd/tests/shared-wal.test.ts

@@ -68,6 +68,36 @@ describe('shared-wal', async () => {
       'forward-slash worktree path resolves correctly');
   }
 
+  // ─── Test (e1): external-state worktree resolves to project state DB (#2952) ───
+  console.log('\n=== shared-wal: resolve external-state worktree path (#2952) ===');
+  {
+    // External-state layout: ~/.gsd/projects/<hash>/worktrees/<MID>
+    // Should resolve to:     ~/.gsd/projects/<hash>/gsd.db
+    const stateRoot = '/home/user/.gsd/projects/a1b2c3d4';
+    const worktreePath = join(stateRoot, 'worktrees', 'M002');
+    const result = resolveProjectRootDbPath(worktreePath);
+    assert.deepStrictEqual(result, join(stateRoot, 'gsd.db'),
+      'external-state worktree path resolves to project state DB (#2952)');
+  }
+
+  // ─── Test (e2): external-state worktree nested subdir (#2952) ─────────
+  console.log('\n=== shared-wal: resolve external-state worktree nested subdir (#2952) ===');
+  {
+    const stateRoot = '/home/user/.gsd/projects/deadbeef42';
+    const nestedPath = join(stateRoot, 'worktrees', 'M003', 'src', 'lib');
+    const result = resolveProjectRootDbPath(nestedPath);
+    assert.deepStrictEqual(result, join(stateRoot, 'gsd.db'),
+      'external-state nested worktree subdir resolves to project state DB (#2952)');
+  }
+
+  // ─── Test (e3): external-state worktree with forward slashes (#2952) ──
+  console.log('\n=== shared-wal: resolve external-state worktree forward-slash (#2952) ===');
+  {
+    const result = resolveProjectRootDbPath('/Users/dev/.gsd/projects/cafe0123/worktrees/M001');
+    assert.deepStrictEqual(result, join('/Users/dev/.gsd/projects/cafe0123', 'gsd.db'),
+      'external-state forward-slash worktree path resolves correctly (#2952)');
+  }
+
   // ─── Test (e): Concurrent writes — 3 connections to same WAL DB ───────
   console.log('\n=== shared-wal: concurrent writes via WAL ===');
   {