gsd-pi 2.10.12 → 2.12.0

package/dist/resources/extensions/gsd/tests/unique-milestone-ids.test.ts

@@ -0,0 +1,219 @@
+// Tests for unique milestone ID exports from T01/S01 — covers the S01→S02 boundary contract.
+//
+// Sections:
+//   (a) MILESTONE_ID_RE: regex matching/rejection
+//   (b) extractMilestoneSeq: old/new/invalid → number
+//   (c) parseMilestoneId: old/new/invalid → structured result
+//   (d) milestoneIdSort: ordering of mixed arrays
+//   (e) generateMilestoneSuffix: format, length, uniqueness
+//   (f) nextMilestoneId: uniqueEnabled true/false, mixed arrays
+//   (g) maxMilestoneNum: empty, old, new, mixed, non-matching
+//   (h) Preferences round-trip: validate, merge behavior via renderPreferencesForSystemPrompt
+
+import {
+  MILESTONE_ID_RE,
+  extractMilestoneSeq,
+  parseMilestoneId,
+  milestoneIdSort,
+  generateMilestoneSuffix,
+  nextMilestoneId,
+  maxMilestoneNum,
+} from '../guided-flow.ts';
+
+import { renderPreferencesForSystemPrompt } from '../preferences.ts';
+import type { GSDPreferences } from '../preferences.ts';
+import { createTestContext } from './test-helpers.ts';
+
+
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+// ─── Tests ─────────────────────────────────────────────────────────────────
+
+async function main(): Promise<void> {
+  console.log('unique-milestone-ids tests');
+
+  // (a) MILESTONE_ID_RE
+  {
+    console.log('  (a) MILESTONE_ID_RE');
+    // Should match
+    assertTrue(MILESTONE_ID_RE.test('M001'), 'matches M001');
+    assertTrue(MILESTONE_ID_RE.test('M999'), 'matches M999');
+    assertTrue(MILESTONE_ID_RE.test('M001-abc123'), 'matches M001-abc123');
+    assertTrue(MILESTONE_ID_RE.test('M042-z9a8b7'), 'matches M042-z9a8b7');
+
+    // Should reject
+    assertTrue(!MILESTONE_ID_RE.test('M1'), 'rejects M1 (too few digits)');
+    assertTrue(!MILESTONE_ID_RE.test('M0001'), 'rejects M0001 (too many digits)');
+    assertTrue(!MILESTONE_ID_RE.test('M001-ABCDEF'), 'rejects M001-ABCDEF (uppercase prefix)');
+    assertTrue(!MILESTONE_ID_RE.test('M001-short'), 'rejects M001-short (5-char prefix)');
+    assertTrue(!MILESTONE_ID_RE.test('M001-toolong1'), 'rejects M001-toolong1 (>6-char prefix)');
+    assertTrue(!MILESTONE_ID_RE.test('IM001'), 'rejects IM001 (prefix before M)');
+    assertTrue(!MILESTONE_ID_RE.test(''), 'rejects empty string');
+    assertTrue(!MILESTONE_ID_RE.test('M001extra'), 'rejects M001extra (trailing chars)');
+    assertTrue(!MILESTONE_ID_RE.test('notes'), 'rejects non-milestone string');
+  }
+
+  // (b) extractMilestoneSeq
+  {
+    console.log('  (b) extractMilestoneSeq');
+    // Old format
+    assertEq(extractMilestoneSeq('M001'), 1, 'M001 → 1');
+    assertEq(extractMilestoneSeq('M042'), 42, 'M042 → 42');
+    assertEq(extractMilestoneSeq('M999'), 999, 'M999 → 999');
+
+    // Unique format
+    assertEq(extractMilestoneSeq('M001-abc123'), 1, 'M001-abc123 → 1');
+    assertEq(extractMilestoneSeq('M042-z9a8b7'), 42, 'M042-z9a8b7 → 42');
+
+    // Invalid → 0
+    assertEq(extractMilestoneSeq(''), 0, 'empty → 0');
+    assertEq(extractMilestoneSeq('notes'), 0, 'notes → 0');
+    assertEq(extractMilestoneSeq('M1'), 0, 'M1 → 0');
+    assertEq(extractMilestoneSeq('.DS_Store'), 0, '.DS_Store → 0');
+    assertEq(extractMilestoneSeq('M-ABC-001'), 0, 'M-ABC-001 (old format) → 0');
+  }
+
+  // (c) parseMilestoneId
+  {
+    console.log('  (c) parseMilestoneId');
+    // Old format — no suffix
+    assertEq(parseMilestoneId('M001'), { num: 1 }, 'M001 → { num: 1 }');
+    assertEq(parseMilestoneId('M042'), { num: 42 }, 'M042 → { num: 42 }');
+
+    // Unique format — with suffix
+    assertEq(parseMilestoneId('M001-abc123'), { suffix: 'abc123', num: 1 }, 'M001-abc123 → { suffix, num }');
+    assertEq(parseMilestoneId('M042-z9a8b7'), { suffix: 'z9a8b7', num: 42 }, 'M042-z9a8b7 → { suffix, num }');
+
+    // Invalid → { num: 0 }
+    assertEq(parseMilestoneId(''), { num: 0 }, 'empty → { num: 0 }');
+    assertEq(parseMilestoneId('notes'), { num: 0 }, 'notes → { num: 0 }');
+    assertEq(parseMilestoneId('M001-ABCDEF'), { num: 0 }, 'uppercase suffix → { num: 0 }');
+    assertEq(parseMilestoneId('M1'), { num: 0 }, 'M1 → { num: 0 }');
+  }
+
+  // (d) milestoneIdSort
+  {
+    console.log('  (d) milestoneIdSort');
+    const mixed = ['M003-abc123', 'M001', 'M002-z9a8b7'];
+    const sorted = [...mixed].sort(milestoneIdSort);
+    assertEq(sorted, ['M001', 'M002-z9a8b7', 'M003-abc123'], 'sorts mixed IDs by sequence number');
+
+    // All old format
+    const oldOnly = ['M003', 'M001', 'M002'];
+    assertEq([...oldOnly].sort(milestoneIdSort), ['M001', 'M002', 'M003'], 'sorts old-format IDs');
+
+    // Invalid entries sort to front (seq 0)
+    const withInvalid = ['M002', 'notes', 'M001'];
+    assertEq([...withInvalid].sort(milestoneIdSort), ['notes', 'M001', 'M002'], 'invalid entries (seq 0) sort first');
+  }
+
+  // (e) generateMilestoneSuffix
+  {
+    console.log('  (e) generateMilestoneSuffix');
+    const suffix1 = generateMilestoneSuffix();
+    assertEq(suffix1.length, 6, 'suffix length is 6');
+    assertMatch(suffix1, /^[a-z0-9]{6}$/, 'suffix matches [a-z0-9]{6}');
+
+    const suffix2 = generateMilestoneSuffix();
+    assertEq(suffix2.length, 6, 'second suffix length is 6');
+    assertMatch(suffix2, /^[a-z0-9]{6}$/, 'second suffix matches [a-z0-9]{6}');
+
+    // Two calls should produce different results (36^6 = ~2.2B possibilities)
+    assertTrue(suffix1 !== suffix2, 'two calls produce different suffixes');
+  }
+
+  // (f) nextMilestoneId
+  {
+    console.log('  (f) nextMilestoneId');
+    // uniqueEnabled=false (default) → old format
+    assertEq(nextMilestoneId([]), 'M001', 'empty + uniqueEnabled=false → M001');
+    assertEq(nextMilestoneId(['M001', 'M002']), 'M003', 'sequential + uniqueEnabled=false → M003');
+    assertEq(nextMilestoneId(['M001', 'M002'], false), 'M003', 'explicit false → M003');
+
+    // uniqueEnabled=true → unique format
+    const newId = nextMilestoneId([], true);
+    assertMatch(newId, MILESTONE_ID_RE, 'uniqueEnabled=true produces valid ID');
+    assertTrue(newId.startsWith('M001-'), 'uniqueEnabled=true starts with M001-');
+    assertMatch(newId, /^M001-[a-z0-9]{6}$/, 'empty + uniqueEnabled=true → M001-{rand6}');
+
+    // Mixed array with uniqueEnabled=true
+    const mixedIds = ['M001', 'M003-abc123', 'M002'];
+    const nextNew = nextMilestoneId(mixedIds, true);
+    assertMatch(nextNew, MILESTONE_ID_RE, 'mixed array + uniqueEnabled=true → valid ID');
+    assertMatch(nextNew, /^M004-[a-z0-9]{6}$/, 'mixed array max=3 → M004-{rand6}');
+
+    // Mixed array with uniqueEnabled=false
+    assertEq(nextMilestoneId(mixedIds, false), 'M004', 'mixed array + uniqueEnabled=false → M004');
+
+    // Correct sequential number from mixed arrays
+    const mixedIds2 = ['M005-xyz999', 'M002'];
+    assertEq(nextMilestoneId(mixedIds2, false), 'M006', 'mixed max=5 → M006');
+    const nextNew2 = nextMilestoneId(mixedIds2, true);
+    assertMatch(nextNew2, /^M006-[a-z0-9]{6}$/, 'mixed max=5 + unique → M006-{rand6}');
+  }
+
+  // (g) maxMilestoneNum
+  {
+    console.log('  (g) maxMilestoneNum');
+    // Empty
+    assertEq(maxMilestoneNum([]), 0, 'empty → 0');
+
+    // Old format only
+    assertEq(maxMilestoneNum(['M001', 'M002', 'M003']), 3, 'old format only → 3');
+
+    // Unique format only — must not return NaN
+    assertEq(maxMilestoneNum(['M001-abc123', 'M002-def456']), 2, 'unique format only → 2');
+    assertTrue(!Number.isNaN(maxMilestoneNum(['M001-abc123'])), 'unique format does not return NaN');
+
+    // Mixed formats
+    assertEq(maxMilestoneNum(['M001', 'M003-abc123', 'M002']), 3, 'mixed → 3');
+
+    // Non-matching entries ignored
+    assertEq(maxMilestoneNum(['M001', 'notes', '.DS_Store', 'M003']), 3, 'non-matching ignored → 3');
+    assertEq(maxMilestoneNum(['notes', '.DS_Store']), 0, 'all non-matching → 0');
+  }
+
+  // (h) Preferences round-trip via renderPreferencesForSystemPrompt
+  {
+    console.log('  (h) Preferences round-trip');
+
+    // validate { unique_milestone_ids: true } → field preserved (no validation error)
+    const prefsTrue: GSDPreferences = { unique_milestone_ids: true };
+    const renderedTrue = renderPreferencesForSystemPrompt(prefsTrue);
+    assertTrue(!renderedTrue.includes('some preference values were ignored'), 'unique_milestone_ids: true validates without error');
+
+    // validate { unique_milestone_ids: undefined } → field absent (no error)
+    const prefsUndefined: GSDPreferences = {};
+    const renderedUndefined = renderPreferencesForSystemPrompt(prefsUndefined);
+    assertTrue(!renderedUndefined.includes('some preference values were ignored'), 'undefined unique_milestone_ids validates without error');
+
+    // validate { unique_milestone_ids: false } → also valid
+    const prefsFalse: GSDPreferences = { unique_milestone_ids: false };
+    const renderedFalse = renderPreferencesForSystemPrompt(prefsFalse);
+    assertTrue(!renderedFalse.includes('some preference values were ignored'), 'unique_milestone_ids: false validates without error');
+
+    // validate coercion: truthy non-boolean → coerced to boolean (no crash)
+    const prefsCoerced: GSDPreferences = { unique_milestone_ids: 1 as unknown as boolean };
+    const renderedCoerced = renderPreferencesForSystemPrompt(prefsCoerced);
+    assertTrue(!renderedCoerced.includes('some preference values were ignored'), 'truthy non-boolean coerces without validation error');
+
+    // GSDPreferences interface accepts the field (compile-time check — if this compiles, it works)
+    const prefs: GSDPreferences = { unique_milestone_ids: true, version: 1 };
+    assertTrue(prefs.unique_milestone_ids === true, 'GSDPreferences interface accepts unique_milestone_ids');
+  }
+
+  report();
+}
+
+// When run via vitest, wrap in test(); when run via tsx, call directly.
+const isVitest = typeof globalThis !== 'undefined' && (globalThis as any).__vitest_worker__?.config?.defines != null && 'vitest' in (globalThis as any).__vitest_worker__.config.defines || process.env.VITEST;
+if (isVitest) {
+  const { test } = await import('vitest');
+  test('unique-milestone-ids: all ID primitives handle both formats', async () => {
+    await main();
+  });
+} else {
+  main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+}

package/dist/resources/extensions/gsd/tests/unit-runtime.test.ts

@@ -0,0 +1,234 @@
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  clearUnitRuntimeRecord,
+  formatExecuteTaskRecoveryStatus,
+  inspectExecuteTaskDurability,
+  readUnitRuntimeRecord,
+  writeUnitRuntimeRecord,
+} from "../unit-runtime.ts";
+import { clearPathCache } from '../paths.ts';
+import { createTestContext } from './test-helpers.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+const base = mkdtempSync(join(tmpdir(), "gsd-unit-runtime-test-"));
+const tasksDir = join(base, ".gsd", "milestones", "M100", "slices", "S02", "tasks");
+mkdirSync(tasksDir, { recursive: true });
+writeFileSync(join(base, ".gsd", "STATE.md"), "## Next Action\nExecute T09 for S02: do the thing\n", "utf-8");
+writeFileSync(
+  join(base, ".gsd", "milestones", "M100", "slices", "S02", "S02-PLAN.md"),
+  "# S02: Test Slice\n\n## Tasks\n\n- [ ] **T09: Do the thing** `est:10m`\n  Description.\n",
+  "utf-8",
+);
+
+console.log("\n=== runtime record write/read/update ===");
+{
+  const first = writeUnitRuntimeRecord(base, "execute-task", "M100/S02/T09", 1000, { phase: "dispatched" });
+  assertEq(first.phase, "dispatched", "initial phase");
+  const second = writeUnitRuntimeRecord(base, "execute-task", "M100/S02/T09", 1000, { phase: "wrapup-warning-sent", wrapupWarningSent: true });
+  assertEq(second.wrapupWarningSent, true, "warning persisted");
+  const loaded = readUnitRuntimeRecord(base, "execute-task", "M100/S02/T09");
+  assertTrue(loaded !== null, "record readable");
+  assertEq(loaded!.phase, "wrapup-warning-sent", "updated phase readable");
+}
+
+console.log("\n=== execute-task durability inspection ===");
+{
+  let status = await inspectExecuteTaskDurability(base, "M100/S02/T09");
+  assertTrue(status !== null, "status exists");
+  assertEq(status!.summaryExists, false, "summary initially missing");
+  assertEq(status!.taskChecked, false, "task initially unchecked");
+  assertEq(status!.nextActionAdvanced, false, "next action initially stale");
+  assertTrue(/summary missing/i.test(formatExecuteTaskRecoveryStatus(status!)), "diagnostic mentions summary");
+
+  writeFileSync(join(tasksDir, "T09-SUMMARY.md"), "# done\n", "utf-8");
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M100", "slices", "S02", "S02-PLAN.md"),
+    "# S02: Test Slice\n\n## Tasks\n\n- [x] **T09: Do the thing** `est:10m`\n  Description.\n",
+    "utf-8",
+  );
+  writeFileSync(join(base, ".gsd", "STATE.md"), "## Next Action\nExecute T10 for S02: next thing\n", "utf-8");
+  clearPathCache();
+
+  status = await inspectExecuteTaskDurability(base, "M100/S02/T09");
+  assertEq(status!.summaryExists, true, "summary found after write");
+  assertEq(status!.taskChecked, true, "task checked after update");
+  assertEq(status!.nextActionAdvanced, true, "next action advanced after update");
+  assertEq(formatExecuteTaskRecoveryStatus(status!), "all durable task artifacts present", "clean diagnostic when complete");
+}
+
+console.log("\n=== runtime record cleanup ===");
+{
+  clearUnitRuntimeRecord(base, "execute-task", "M100/S02/T09");
+  const loaded = readUnitRuntimeRecord(base, "execute-task", "M100/S02/T09");
+  assertEq(loaded, null, "record removed");
+}
+
+// ─── Must-have durability integration tests ───────────────────────────────
+
+// Create a separate temp base for must-have tests to avoid interference
+const mhBase = mkdtempSync(join(tmpdir(), "gsd-unit-runtime-mh-test-"));
+
+console.log("\n=== must-haves: all mentioned in summary ===");
+{
+  const tasksDir2 = join(mhBase, ".gsd", "milestones", "M200", "slices", "S01", "tasks");
+  mkdirSync(tasksDir2, { recursive: true });
+
+  // Slice plan with T01 checked
+  writeFileSync(
+    join(mhBase, ".gsd", "milestones", "M200", "slices", "S01", "S01-PLAN.md"),
+    "# S01: Test\n\n## Tasks\n\n- [x] **T01: Build parser** `est:10m`\n  Build the parser.\n",
+    "utf-8",
+  );
+  // Task plan with must-haves containing backtick code tokens
+  writeFileSync(
+    join(tasksDir2, "T01-PLAN.md"),
+    "# T01: Build parser\n\n## Must-Haves\n\n- [ ] `parseWidget` function is exported\n- [ ] `formatWidget` handles edge cases\n- [ ] All existing tests pass\n\n## Steps\n\n1. Do stuff\n",
+    "utf-8",
+  );
+  // Summary that mentions all must-haves
+  writeFileSync(
+    join(tasksDir2, "T01-SUMMARY.md"),
+    "# T01: Build parser\n\nAdded parseWidget function and formatWidget with edge case handling. All existing tests pass without regression.\n",
+    "utf-8",
+  );
+  // STATE.md with next action advanced past T01
+  writeFileSync(join(mhBase, ".gsd", "STATE.md"), "## Next Action\nExecute T02 for S01: next thing\n", "utf-8");
+
+  const status = await inspectExecuteTaskDurability(mhBase, "M200/S01/T01");
+  assertTrue(status !== null, "mh-all: status exists");
+  assertEq(status!.mustHaveCount, 3, "mh-all: mustHaveCount is 3");
+  assertEq(status!.mustHavesMentionedInSummary, 3, "mh-all: all 3 must-haves mentioned");
+  assertEq(status!.summaryExists, true, "mh-all: summary exists");
+  assertEq(status!.taskChecked, true, "mh-all: task checked");
+  const diag = formatExecuteTaskRecoveryStatus(status!);
+  assertEq(diag, "all durable task artifacts present", "mh-all: diagnostic is clean when all must-haves met");
+}
+
+console.log("\n=== must-haves: partially mentioned in summary ===");
+{
+  const tasksDir3 = join(mhBase, ".gsd", "milestones", "M200", "slices", "S02", "tasks");
+  mkdirSync(tasksDir3, { recursive: true });
+
+  writeFileSync(
+    join(mhBase, ".gsd", "milestones", "M200", "slices", "S02", "S02-PLAN.md"),
+    "# S02: Test\n\n## Tasks\n\n- [x] **T01: Build thing** `est:10m`\n  Build.\n",
+    "utf-8",
+  );
+  // Task plan with 3 must-haves, summary will only mention 1
+  writeFileSync(
+    join(tasksDir3, "T01-PLAN.md"),
+    "# T01: Build thing\n\n## Must-Haves\n\n- [ ] `computeScore` function is exported\n- [ ] `validateInput` rejects invalid data\n- [ ] `renderOutput` handles empty arrays\n\n## Steps\n\n1. Do stuff\n",
+    "utf-8",
+  );
+  // Summary only mentions computeScore
+  writeFileSync(
+    join(tasksDir3, "T01-SUMMARY.md"),
+    "# T01: Build thing\n\nAdded computeScore function with full test coverage.\n",
+    "utf-8",
+  );
+  writeFileSync(join(mhBase, ".gsd", "STATE.md"), "## Next Action\nExecute T02 for S02: next thing\n", "utf-8");
+
+  clearPathCache();
+  const status = await inspectExecuteTaskDurability(mhBase, "M200/S02/T01");
+  assertTrue(status !== null, "mh-partial: status exists");
+  assertEq(status!.mustHaveCount, 3, "mh-partial: mustHaveCount is 3");
+  assertEq(status!.mustHavesMentionedInSummary, 1, "mh-partial: only 1 must-have mentioned");
+  const diag = formatExecuteTaskRecoveryStatus(status!);
+  assertTrue(diag.includes("must-have gap"), "mh-partial: diagnostic includes 'must-have gap'");
+  assertTrue(diag.includes("1 of 3"), "mh-partial: diagnostic includes '1 of 3'");
+}
+
+console.log("\n=== must-haves: no task plan file ===");
+{
+  const tasksDir4 = join(mhBase, ".gsd", "milestones", "M200", "slices", "S03", "tasks");
+  mkdirSync(tasksDir4, { recursive: true });
+
+  writeFileSync(
+    join(mhBase, ".gsd", "milestones", "M200", "slices", "S03", "S03-PLAN.md"),
+    "# S03: Test\n\n## Tasks\n\n- [x] **T01: Quick fix** `est:5m`\n  Fix.\n",
+    "utf-8",
+  );
+  // No T01-PLAN.md — only summary
+  writeFileSync(
+    join(tasksDir4, "T01-SUMMARY.md"),
+    "# T01: Quick fix\n\nFixed the thing.\n",
+    "utf-8",
+  );
+  writeFileSync(join(mhBase, ".gsd", "STATE.md"), "## Next Action\nExecute T02 for S03: next thing\n", "utf-8");
+
+  clearPathCache();
+  const status = await inspectExecuteTaskDurability(mhBase, "M200/S03/T01");
+  assertTrue(status !== null, "mh-noplan: status exists");
+  assertEq(status!.mustHaveCount, 0, "mh-noplan: mustHaveCount is 0 when no task plan");
+  assertEq(status!.mustHavesMentionedInSummary, 0, "mh-noplan: mustHavesMentionedInSummary is 0");
+}
+
+console.log("\n=== must-haves: present but no summary file ===");
+{
+  const tasksDir5 = join(mhBase, ".gsd", "milestones", "M200", "slices", "S04", "tasks");
+  mkdirSync(tasksDir5, { recursive: true });
+
+  writeFileSync(
+    join(mhBase, ".gsd", "milestones", "M200", "slices", "S04", "S04-PLAN.md"),
+    "# S04: Test\n\n## Tasks\n\n- [ ] **T01: Build parser** `est:10m`\n  Build.\n",
+    "utf-8",
+  );
+  // Task plan with must-haves but NO summary file
+  writeFileSync(
+    join(tasksDir5, "T01-PLAN.md"),
+    "# T01: Build parser\n\n## Must-Haves\n\n- [ ] `parseData` function exported\n- [ ] Error handling covers edge cases\n\n## Steps\n\n1. Do stuff\n",
+    "utf-8",
+  );
+  writeFileSync(join(mhBase, ".gsd", "STATE.md"), "## Next Action\nExecute T01 for S04: build parser\n", "utf-8");
+
+  clearPathCache();
+  const status = await inspectExecuteTaskDurability(mhBase, "M200/S04/T01");
+  assertTrue(status !== null, "mh-nosummary: status exists");
+  assertEq(status!.mustHaveCount, 2, "mh-nosummary: mustHaveCount is 2");
+  assertEq(status!.mustHavesMentionedInSummary, 0, "mh-nosummary: mustHavesMentionedInSummary is 0 with no summary");
+  assertEq(status!.summaryExists, false, "mh-nosummary: summary doesn't exist");
+}
+
+console.log("\n=== must-haves: substring matching (no backtick tokens) ===");
+{
+  const tasksDir6 = join(mhBase, ".gsd", "milestones", "M200", "slices", "S05", "tasks");
+  mkdirSync(tasksDir6, { recursive: true });
+
+  writeFileSync(
+    join(mhBase, ".gsd", "milestones", "M200", "slices", "S05", "S05-PLAN.md"),
+    "# S05: Test\n\n## Tasks\n\n- [x] **T01: Add diagnostics** `est:10m`\n  Add.\n",
+    "utf-8",
+  );
+  // Must-haves with no backtick tokens — falls back to substring matching
+  writeFileSync(
+    join(tasksDir6, "T01-PLAN.md"),
+    "# T01: Add diagnostics\n\n## Must-Haves\n\n- [ ] Heuristic matching prioritizes backtick-enclosed code tokens\n- [ ] Recovery diagnostic string shows gap count\n- [ ] All assertions pass\n\n## Steps\n\n1. Do stuff\n",
+    "utf-8",
+  );
+  // Summary mentions "heuristic" and "diagnostic" but not "assertions"
+  writeFileSync(
+    join(tasksDir6, "T01-SUMMARY.md"),
+    "# T01: Add diagnostics\n\nImplemented heuristic matching for must-have items. Recovery diagnostic string now includes gap counts.\n",
+    "utf-8",
+  );
+  writeFileSync(join(mhBase, ".gsd", "STATE.md"), "## Next Action\nExecute T02 for S05: next thing\n", "utf-8");
+
+  clearPathCache();
+  const status = await inspectExecuteTaskDurability(mhBase, "M200/S05/T01");
+  assertTrue(status !== null, "mh-substr: status exists");
+  assertEq(status!.mustHaveCount, 3, "mh-substr: mustHaveCount is 3");
+  // "heuristic" appears in summary for item 1, "diagnostic" for item 2, 
+  // "assertions" appears in summary? No — let's check
+  // Item 3: "All assertions pass" — words: "assertions", "pass" (<4 chars excluded)
+  // summary doesn't contain "assertions" → not matched
+  assertEq(status!.mustHavesMentionedInSummary, 2, "mh-substr: 2 of 3 matched via substring");
+  const diag = formatExecuteTaskRecoveryStatus(status!);
+  assertTrue(diag.includes("must-have gap"), "mh-substr: diagnostic includes gap info");
+  assertTrue(diag.includes("2 of 3"), "mh-substr: diagnostic includes '2 of 3'");
+}
+
+rmSync(mhBase, { recursive: true, force: true });
+rmSync(base, { recursive: true, force: true });
+report();

package/dist/resources/extensions/gsd/tests/workspace-index.test.ts

@@ -0,0 +1,75 @@
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { getSuggestedNextCommands, indexWorkspace, listDoctorScopeSuggestions } from "../workspace-index.ts";
+import { createTestContext } from './test-helpers.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+const base = mkdtempSync(join(tmpdir(), "gsd-workspace-index-test-"));
+const gsd = join(base, ".gsd");
+const mDir = join(gsd, "milestones", "M001");
+const sDir = join(mDir, "slices", "S01");
+const tDir = join(sDir, "tasks");
+mkdirSync(tDir, { recursive: true });
+
+writeFileSync(join(mDir, "M001-ROADMAP.md"), `# M001: Demo Milestone
+
+## Slices
+- [ ] **S01: Demo Slice** \`risk:low\` \`depends:[]\`
+  > After this: demo works
+`);
+
+writeFileSync(join(sDir, "S01-PLAN.md"), `# S01: Demo Slice
+
+**Goal:** Demo
+**Demo:** Demo
+
+## Must-Haves
+- done
+
+## Tasks
+- [ ] **T01: Implement thing** \`est:10m\`
+  Task is in progress.
+`);
+
+writeFileSync(join(tDir, "T01-PLAN.md"), `# T01: Implement thing
+
+## Steps
+- do it
+`);
+
+async function main(): Promise<void> {
+  console.log("\n=== workspace index ===");
+  {
+    const index = await indexWorkspace(base);
+    assertEq(index.active.milestoneId, "M001", "active milestone indexed");
+    assertEq(index.active.sliceId, "S01", "active slice indexed");
+    assertEq(index.active.taskId, "T01", "active task indexed");
+    assertTrue(index.scopes.some(scope => scope.scope === "M001/S01"), "slice scope listed");
+    assertTrue(index.scopes.some(scope => scope.scope === "M001/S01/T01"), "task scope listed");
+  }
+
+  console.log("\n=== doctor scope suggestions ===");
+  {
+    const suggestions = await listDoctorScopeSuggestions(base);
+    assertEq(suggestions[0].value, "M001/S01", "active slice suggested first");
+    assertTrue(suggestions.some(item => item.value === "M001/S01/T01"), "task scope suggested");
+  }
+
+  console.log("\n=== next command suggestions ===");
+  {
+    const commands = await getSuggestedNextCommands(base);
+    assertTrue(commands.includes("/gsd auto"), "suggests auto during execution");
+    assertTrue(commands.includes("/gsd doctor M001/S01"), "suggests scoped doctor");
+    assertTrue(commands.includes("/gsd status"), "suggests status");
+  }
+
+  rmSync(base, { recursive: true, force: true });
+  report();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});