@tuan_son.dinh/gsd 2.6.0

package/src/resources/extensions/gsd/tests/run-uat.test.ts

@@ -0,0 +1,348 @@
+// Tests for extractUatType — the core UAT classification primitive — plus
+// prompt template loading and dispatch precondition assertions (via
+// resolveSliceFile / extractUatType on real fixture files).
+//
+// Sections:
+//   (a)–(j)  extractUatType classification (17 assertions from T01)
+//   (k)      run-uat prompt template loading and content integrity (8 assertions)
+//   (l)      dispatch precondition assertions via resolveSliceFile (4 assertions)
+
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+import { extractUatType } from '../files.ts';
+import { resolveSliceFile } from '../paths.ts';
+
+// ─── Worktree-aware prompt loader ──────────────────────────────────────────
+// Resolves prompts relative to this test file so the worktree copy is used
+// instead of the main checkout copy (matches complete-milestone.test.ts pattern).
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const worktreePromptsDir = join(__dirname, '..', 'prompts');
+
+function loadPromptFromWorktree(name: string, vars: Record<string, string> = {}): string {
+  const path = join(worktreePromptsDir, `${name}.md`);
+  let content = readFileSync(path, 'utf-8');
+  for (const [key, value] of Object.entries(vars)) {
+    content = content.replaceAll(`{{${key}}}`, value);
+  }
+  return content.trim();
+}
+
+// ─── Assertion helpers ─────────────────────────────────────────────────────
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition: boolean, message: string): void {
+  if (condition) {
+    passed++;
+  } else {
+    failed++;
+    console.error(`  FAIL: ${message}`);
+  }
+}
+
+function assertEq<T>(actual: T, expected: T, message: string): void {
+  if (JSON.stringify(actual) === JSON.stringify(expected)) {
+    passed++;
+  } else {
+    failed++;
+    console.error(`  FAIL: ${message} — expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+  }
+}
+
+// ─── Fixture helpers ───────────────────────────────────────────────────────
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-run-uat-test-'));
+  mkdirSync(join(base, '.gsd', 'milestones'), { recursive: true });
+  return base;
+}
+
+function writeSliceFile(
+  base: string,
+  mid: string,
+  sid: string,
+  suffix: string,
+  content: string,
+): void {
+  const dir = join(base, '.gsd', 'milestones', mid, 'slices', sid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${sid}-${suffix}.md`), content);
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+function makeUatContent(mode: string): string {
+  return `# UAT File\n\n## UAT Type\n\n- UAT mode: ${mode}\n- Some other bullet: value\n`;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+async function main(): Promise<void> {
+
+  // ─── (a) artifact-driven ──────────────────────────────────────────────────
+  console.log('\n── (a) artifact-driven');
+
+  assertEq(
+    extractUatType(makeUatContent('artifact-driven')),
+    'artifact-driven',
+    'plain artifact-driven → artifact-driven',
+  );
+
+  assertEq(
+    extractUatType('## UAT Type\n\n- UAT mode: artifact-driven\n'),
+    'artifact-driven',
+    'minimal content, artifact-driven',
+  );
+
+  // ─── (b) live-runtime ─────────────────────────────────────────────────────
+  console.log('\n── (b) live-runtime');
+
+  assertEq(
+    extractUatType(makeUatContent('live-runtime')),
+    'live-runtime',
+    'plain live-runtime → live-runtime',
+  );
+
+  // ─── (c) human-experience ─────────────────────────────────────────────────
+  console.log('\n── (c) human-experience');
+
+  assertEq(
+    extractUatType(makeUatContent('human-experience')),
+    'human-experience',
+    'plain human-experience → human-experience',
+  );
+
+  // ─── (d) mixed standalone ─────────────────────────────────────────────────
+  console.log('\n── (d) mixed standalone');
+
+  assertEq(
+    extractUatType(makeUatContent('mixed')),
+    'mixed',
+    'plain mixed → mixed',
+  );
+
+  // ─── (e) mixed with parenthetical ─────────────────────────────────────────
+  console.log('\n── (e) mixed parenthetical');
+
+  assertEq(
+    extractUatType(makeUatContent('mixed (artifact-driven + live-runtime)')),
+    'mixed',
+    'mixed (artifact-driven + live-runtime) → mixed (leading keyword only)',
+  );
+
+  assertEq(
+    extractUatType(makeUatContent('mixed (some other description)')),
+    'mixed',
+    'mixed with arbitrary parenthetical → mixed',
+  );
+
+  // ─── (f) missing ## UAT Type section ──────────────────────────────────────
+  console.log('\n── (f) missing UAT Type section');
+
+  assertEq(
+    extractUatType('# UAT File\n\n## Overview\n\nSome content.\n'),
+    undefined,
+    'no ## UAT Type section → undefined',
+  );
+
+  assertEq(
+    extractUatType(''),
+    undefined,
+    'empty content → undefined',
+  );
+
+  // ─── (g) ## UAT Type present but no UAT mode: bullet ─────────────────────
+  console.log('\n── (g) UAT Type section present, no UAT mode: bullet');
+
+  assertEq(
+    extractUatType('## UAT Type\n\n- Some other bullet: value\n- Another bullet\n'),
+    undefined,
+    'section present but no UAT mode: bullet → undefined',
+  );
+
+  assertEq(
+    extractUatType('## UAT Type\n\n'),
+    undefined,
+    'section present but empty → undefined',
+  );
+
+  // ─── (h) unknown keyword ──────────────────────────────────────────────────
+  console.log('\n── (h) unknown keyword');
+
+  assertEq(
+    extractUatType(makeUatContent('automated')),
+    undefined,
+    'unknown keyword automated → undefined',
+  );
+
+  assertEq(
+    extractUatType(makeUatContent('fully-automated')),
+    undefined,
+    'unknown keyword fully-automated → undefined',
+  );
+
+  // ─── (i) extra whitespace around value ────────────────────────────────────
+  console.log('\n── (i) extra whitespace');
+
+  assertEq(
+    extractUatType('## UAT Type\n\n- UAT mode:   artifact-driven   \n'),
+    'artifact-driven',
+    'leading/trailing whitespace around value → still classified correctly',
+  );
+
+  assertEq(
+    extractUatType('## UAT Type\n\n- UAT mode:  mixed (artifact-driven + live-runtime)  \n'),
+    'mixed',
+    'whitespace around mixed parenthetical → mixed',
+  );
+
+  // ─── (j) case sensitivity ─────────────────────────────────────────────────
+  console.log('\n── (j) case sensitivity');
+
+  assertEq(
+    extractUatType(makeUatContent('Artifact-Driven')),
+    'artifact-driven',
+    'Artifact-Driven (title case) → artifact-driven (function lowercases before matching)',
+  );
+
+  assertEq(
+    extractUatType(makeUatContent('MIXED')),
+    'mixed',
+    'MIXED (upper case) → mixed (function lowercases before matching)',
+  );
+
+  // ─── (k) prompt template loading and content integrity ────────────────────
+  console.log('\n── (k) run-uat prompt template');
+
+  const milestoneId = 'M001';
+  const sliceId = 'S01';
+  const uatPath = '.gsd/milestones/M001/slices/S01/S01-UAT.md';
+  const uatResultAbsPath = '/tmp/gsd-test/S01-UAT-RESULT.md';
+  const uatResultPath = '.gsd/milestones/M001/slices/S01/S01-UAT-RESULT.md';
+  const uatType = 'artifact-driven';
+  const inlinedContext = '<!-- no context -->';
+
+  let promptResult: string | undefined;
+  let promptThrew = false;
+  try {
+    promptResult = loadPromptFromWorktree('run-uat', {
+      milestoneId,
+      sliceId,
+      uatPath,
+      uatResultAbsPath,
+      uatResultPath,
+      uatType,
+      inlinedContext,
+    });
+  } catch {
+    promptThrew = true;
+  }
+
+  assert(!promptThrew, 'loadPromptFromWorktree("run-uat", vars) does not throw');
+  assert(
+    typeof promptResult === 'string' && promptResult.length > 0,
+    'run-uat prompt result is a non-empty string',
+  );
+  assert(
+    promptResult?.includes(milestoneId) ?? false,
+    `prompt contains milestoneId value "${milestoneId}" after substitution`,
+  );
+  assert(
+    promptResult?.includes(sliceId) ?? false,
+    `prompt contains sliceId value "${sliceId}" after substitution`,
+  );
+  assert(
+    promptResult?.includes(uatResultAbsPath) ?? false,
+    `prompt contains uatResultAbsPath value after substitution`,
+  );
+  assert(
+    !/\{\{[^}]+\}\}/.test(promptResult ?? ''),
+    'no unreplaced {{...}} tokens remain after variable substitution',
+  );
+  assert(
+    /artifact|execute|run/i.test(promptResult ?? ''),
+    'prompt contains artifact-driven execution language (artifact/execute/run)',
+  );
+  assert(
+    /surfaced for human review/i.test(promptResult ?? ''),
+    'prompt contains "surfaced for human review" text for non-artifact-driven path',
+  );
+
+  // ─── (l) dispatch precondition assertions via resolveSliceFile ────────────
+  console.log('\n── (l) dispatch preconditions via resolveSliceFile');
+
+  // State A: UAT file exists, UAT-RESULT file does NOT — triggers dispatch
+  {
+    const base = createFixtureBase();
+    const uatContent = makeUatContent('artifact-driven');
+    try {
+      writeSliceFile(base, 'M001', 'S01', 'UAT', uatContent);
+
+      const uatFilePath = resolveSliceFile(base, 'M001', 'S01', 'UAT');
+      assert(
+        uatFilePath !== null,
+        'resolveSliceFile(..., "UAT") returns non-null when UAT file exists (dispatch trigger state)',
+      );
+
+      const uatResultFilePath = resolveSliceFile(base, 'M001', 'S01', 'UAT-RESULT');
+      assertEq(
+        uatResultFilePath,
+        null,
+        'resolveSliceFile(..., "UAT-RESULT") returns null when result file missing (dispatch trigger state)',
+      );
+
+      // End-to-end: file content → parse → classify
+      const rawContent = readFileSync(uatFilePath!, 'utf-8');
+      assertEq(
+        extractUatType(rawContent),
+        'artifact-driven',
+        'extractUatType on fixture UAT file returns expected type (end-to-end data flow)',
+      );
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // State B: UAT-RESULT file exists — dispatch is skipped (idempotent)
+  {
+    const base = createFixtureBase();
+    try {
+      writeSliceFile(base, 'M001', 'S01', 'UAT', makeUatContent('artifact-driven'));
+      writeSliceFile(base, 'M001', 'S01', 'UAT-RESULT', '# UAT Result\n\nverdict: PASS\n');
+
+      const uatResultFilePath = resolveSliceFile(base, 'M001', 'S01', 'UAT-RESULT');
+      assert(
+        uatResultFilePath !== null,
+        'resolveSliceFile(..., "UAT-RESULT") returns non-null when result file exists (idempotent skip state)',
+      );
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Results
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  console.log(`\n${'='.repeat(40)}`);
+  console.log(`Results: ${passed} passed, ${failed} failed`);
+  if (failed > 0) {
+    process.exit(1);
+  } else {
+    console.log('All tests passed ✓');
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

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

@@ -0,0 +1,247 @@
+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";
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition: boolean, message: string): void {
+  if (condition) passed++;
+  else {
+    failed++;
+    console.error(`  FAIL: ${message}`);
+  }
+}
+
+function assertEq<T>(actual: T, expected: T, message: string): void {
+  if (JSON.stringify(actual) === JSON.stringify(expected)) passed++;
+  else {
+    failed++;
+    console.error(`  FAIL: ${message} — expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+  }
+}
+
+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");
+  assert(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");
+  assert(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");
+  assert(/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");
+
+  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");
+  assert(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");
+
+  const status = await inspectExecuteTaskDurability(mhBase, "M200/S02/T01");
+  assert(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!);
+  assert(diag.includes("must-have gap"), "mh-partial: diagnostic includes 'must-have gap'");
+  assert(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");
+
+  const status = await inspectExecuteTaskDurability(mhBase, "M200/S03/T01");
+  assert(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");
+
+  const status = await inspectExecuteTaskDurability(mhBase, "M200/S04/T01");
+  assert(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");
+
+  const status = await inspectExecuteTaskDurability(mhBase, "M200/S05/T01");
+  assert(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!);
+  assert(diag.includes("must-have gap"), "mh-substr: diagnostic includes gap info");
+  assert(diag.includes("2 of 3"), "mh-substr: diagnostic includes '2 of 3'");
+}
+
+rmSync(mhBase, { recursive: true, force: true });
+rmSync(base, { recursive: true, force: true });
+console.log(`\nResults: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);
+console.log("All tests passed ✓");

package/src/resources/extensions/gsd/tests/workflow-config.test.mjs

@@ -0,0 +1,53 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { resolveWorkflowConfig } from '../preferences.ts';
+
+test('resolveWorkflowConfig returns all required keys', () => {
+  const wf = resolveWorkflowConfig();
+  const keys = Object.keys(wf).sort();
+  assert.deepEqual(keys, [
+    'skip_milestone_research',
+    'skip_observability',
+    'skip_plan_self_audit',
+    'skip_reassessment',
+    'skip_slice_research',
+  ]);
+});
+
+test('resolveWorkflowConfig values are all booleans', () => {
+  const wf = resolveWorkflowConfig();
+  for (const [key, value] of Object.entries(wf)) {
+    assert.equal(typeof value, 'boolean', `${key} should be boolean, got ${typeof value}`);
+  }
+});
+
+// With ~/.gsd/preferences.md having planning_depth: standard and
+// workflow overrides, verify the merge logic works:
+// - planning_depth: standard sets skip_slice_research, skip_plan_self_audit to true (NOT milestone research)
+// - explicit workflow.skip_milestone_research: false confirms standard default (false)
+// - explicit workflow.skip_slice_research: true confirms standard default (true)
+// - explicit workflow.skip_plan_self_audit: true confirms standard default (true)
+// - explicit workflow.skip_reassessment: false confirms standard default (false)
+test('resolveWorkflowConfig respects global preferences with overrides', () => {
+  const wf = resolveWorkflowConfig();
+
+  // planning_depth: standard → skip_milestone_research defaults false,
+  // workflow.skip_milestone_research: false confirms it
+  assert.equal(wf.skip_milestone_research, false);
+
+  // planning_depth: standard → skip_slice_research defaults true,
+  // workflow.skip_slice_research: true confirms it
+  assert.equal(wf.skip_slice_research, true);
+
+  // planning_depth: standard → skip_plan_self_audit defaults true,
+  // workflow.skip_plan_self_audit: true confirms it
+  assert.equal(wf.skip_plan_self_audit, true);
+
+  // planning_depth: standard → skip_reassessment defaults false,
+  // workflow.skip_reassessment: false confirms it
+  assert.equal(wf.skip_reassessment, false);
+
+  // planning_depth: standard → skip_observability defaults false,
+  // no explicit override, uses standard default (false)
+  assert.equal(wf.skip_observability, false);
+});