gsd-pi 2.10.12 → 2.12.0

package/src/resources/extensions/gsd/prompts/research-slice.md

@@ -18,7 +18,7 @@ Then research what this slice needs. Narrate key findings and surprises as you g
 2. **Skill Discovery ({{skillDiscoveryMode}}):**{{skillDiscoveryInstructions}}
 3. Explore relevant code for this slice's scope. For targeted exploration, use `rg`, `find`, and reads. For broad or unfamiliar subsystems, use `scout` to map the relevant area first.
 4. Use `resolve_library` / `get_library_docs` for unfamiliar libraries
-5. Read the template at `~/.gsd/agent/extensions/gsd/templates/research.md`
+5. Use the **Research** output template from the inlined context above
 6. Write `{{outputPath}}`
 
 The slice directory already exists at `{{slicePath}}/`. Do NOT mkdir — just write the file.

package/src/resources/extensions/gsd/state.ts

@@ -27,11 +27,13 @@ import {
   resolveSliceFile,
   resolveTaskFile,
   resolveGsdRootFile,
+  gsdRoot,
 } from './paths.js';
 import { getActiveSliceBranch } from './worktree.js';
 import { milestoneIdSort, findMilestoneIds } from './guided-flow.js';
+import { nativeBatchParseGsdFiles, type BatchParsedFile } from './native-parser-bridge.js';
 
-import { join } from 'path';
+import { join, resolve } from 'path';
 
 // ─── Query Functions ───────────────────────────────────────────────────────
 
@@ -51,6 +53,27 @@ export function isMilestoneComplete(roadmap: Roadmap): boolean {
 
 // ─── State Derivation ──────────────────────────────────────────────────────
 
+// ── deriveState memoization ─────────────────────────────────────────────────
+// Cache the most recent deriveState() result keyed by basePath. Within a single
+// dispatch cycle (~100ms window), repeated calls return the cached value instead
+// of re-reading the entire .gsd/ tree from disk.
+
+interface StateCache {
+  basePath: string;
+  result: GSDState;
+  timestamp: number;
+}
+
+const CACHE_TTL_MS = 100;
+let _stateCache: StateCache | null = null;
+
+/**
+ * Invalidate the deriveState() cache. Call this whenever planning files on disk
+ * may have changed (unit completion, merges, file writes).
+ */
+export function invalidateStateCache(): void {
+  _stateCache = null;
+}
 
 /**
  * Returns the ID of the first incomplete milestone, or null if all are complete.
@@ -77,10 +100,94 @@ export async function getActiveMilestoneId(basePath: string): Promise<string | n
 /**
  * Reconstruct GSD state from files on disk.
  * This is the source of truth — STATE.md is just a cache of this output.
+ *
+ * Uses native batch parsing when available: a single Rust call reads and parses
+ * every .md file under .gsd/, populating an in-memory cache that replaces all
+ * individual loadFile() calls during milestone/slice/task traversal.
+ * Falls back to sequential JS file reads when the native module is absent.
  */
 export async function deriveState(basePath: string): Promise<GSDState> {
+  // Return cached result if within the TTL window for the same basePath
+  if (
+    _stateCache &&
+    _stateCache.basePath === basePath &&
+    Date.now() - _stateCache.timestamp < CACHE_TTL_MS
+  ) {
+    return _stateCache.result;
+  }
+
+  const result = await _deriveStateImpl(basePath);
+  _stateCache = { basePath, result, timestamp: Date.now() };
+  return result;
+}
+
+async function _deriveStateImpl(basePath: string): Promise<GSDState> {
   const milestoneIds = findMilestoneIds(basePath);
-  const requirements = parseRequirementCounts(await loadFile(resolveGsdRootFile(basePath, "REQUIREMENTS")));
+
+  // ── Batch-parse file cache ──────────────────────────────────────────────
+  // When the native Rust parser is available, read every .md file under .gsd/
+  // in one call and build an in-memory content map keyed by absolute path.
+  // This eliminates O(N) individual fs.readFile calls during traversal.
+  const fileContentCache = new Map<string, string>();
+  const gsdDir = gsdRoot(basePath);
+
+  const batchFiles = nativeBatchParseGsdFiles(gsdDir);
+  if (batchFiles) {
+    for (const f of batchFiles) {
+      // Reconstruct the full file content from parsed components so downstream
+      // parsers (parseRoadmap, parseSummary, etc.) receive the same input they
+      // expect from loadFile(). Files with frontmatter get it re-serialized;
+      // files without get just the body.
+      const absPath = resolve(gsdDir, f.path);
+      const hasMetadata = Object.keys(f.metadata).length > 0;
+      if (hasMetadata) {
+        // Re-serialize frontmatter as simple YAML key: value lines
+        const fmLines: string[] = ['---'];
+        for (const [key, value] of Object.entries(f.metadata)) {
+          if (Array.isArray(value)) {
+            if (value.length === 0) {
+              fmLines.push(`${key}: []`);
+            } else if (typeof value[0] === 'object' && value[0] !== null) {
+              fmLines.push(`${key}:`);
+              for (const obj of value) {
+                const entries = Object.entries(obj as Record<string, unknown>);
+                if (entries.length > 0) {
+                  fmLines.push(`  - ${entries[0][0]}: ${entries[0][1]}`);
+                  for (let i = 1; i < entries.length; i++) {
+                    fmLines.push(`    ${entries[i][0]}: ${entries[i][1]}`);
+                  }
+                }
+              }
+            } else {
+              fmLines.push(`${key}:`);
+              for (const item of value) {
+                fmLines.push(`  - ${item}`);
+              }
+            }
+          } else {
+            fmLines.push(`${key}: ${value}`);
+          }
+        }
+        fmLines.push('---');
+        fileContentCache.set(absPath, fmLines.join('\n') + '\n\n' + f.body);
+      } else {
+        fileContentCache.set(absPath, f.body);
+      }
+    }
+  }
+
+  /**
+   * Load file content from batch cache first, falling back to disk read.
+   * Resolves the path to absolute before cache lookup.
+   */
+  async function cachedLoadFile(path: string): Promise<string | null> {
+    const abs = resolve(path);
+    const cached = fileContentCache.get(abs);
+    if (cached !== undefined) return cached;
+    return loadFile(path);
+  }
+
+  const requirements = parseRequirementCounts(await cachedLoadFile(resolveGsdRootFile(basePath, "REQUIREMENTS")));
 
   if (milestoneIds.length === 0) {
     return {
@@ -99,25 +206,31 @@ export async function deriveState(basePath: string): Promise<GSDState> {
     };
   }
 
-  // Pre-compute the set of complete milestone IDs for dependency checking.
-  // This allows forward references (M002 depending on M003) to resolve correctly.
+  // ── Single-pass milestone scan ──────────────────────────────────────────
+  // Parse each milestone's roadmap once, caching results. First pass determines
+  // completeness for dependency resolution; second pass builds the registry.
+  // With the batch cache, all file reads hit memory instead of disk.
+
+  // Phase 1: Build roadmap cache and completeness set
+  const roadmapCache = new Map<string, Roadmap>();
   const completeMilestoneIds = new Set<string>();
+
   for (const mid of milestoneIds) {
     const rf = resolveMilestoneFile(basePath, mid, "ROADMAP");
-    const rc = rf ? await loadFile(rf) : null;
+    const rc = rf ? await cachedLoadFile(rf) : null;
     if (!rc) {
-      // No roadmap — milestone is complete if it has a summary
       const sf = resolveMilestoneFile(basePath, mid, "SUMMARY");
       if (sf) completeMilestoneIds.add(mid);
       continue;
     }
     const rmap = parseRoadmap(rc);
+    roadmapCache.set(mid, rmap);
     if (!isMilestoneComplete(rmap)) continue;
     const sf = resolveMilestoneFile(basePath, mid, "SUMMARY");
     if (sf) completeMilestoneIds.add(mid);
   }
 
-  // Build the registry and locate the active milestone in a single pass.
+  // Phase 2: Build registry using cached roadmaps (no re-parsing or re-reading)
   const registry: MilestoneRegistryEntry[] = [];
   let activeMilestone: ActiveRef | null = null;
   let activeRoadmap: Roadmap | null = null;
@@ -125,13 +238,13 @@ export async function deriveState(basePath: string): Promise<GSDState> {
   let activeMilestoneHasDraft = false;
 
   for (const mid of milestoneIds) {
-    const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
-    const content = roadmapFile ? await loadFile(roadmapFile) : null;
-    if (!content) {
+    const roadmap = roadmapCache.get(mid) ?? null;
+
+    if (!roadmap) {
       // No roadmap — check if a summary exists (completed milestone without roadmap)
       const summaryFile = resolveMilestoneFile(basePath, mid, "SUMMARY");
       if (summaryFile) {
-        const summaryContent = await loadFile(summaryFile);
+        const summaryContent = await cachedLoadFile(summaryFile);
         const summaryTitle = summaryContent
           ? (parseSummary(summaryContent).title || mid)
           : mid;
@@ -157,7 +270,6 @@ export async function deriveState(basePath: string): Promise<GSDState> {
       continue;
     }
 
-    const roadmap = parseRoadmap(content);
     const title = roadmap.title.replace(/^M\d+(?:-[a-z0-9]{6})?[^:]*:\s*/, '');
     const complete = isMilestoneComplete(roadmap);
 
@@ -176,7 +288,7 @@ export async function deriveState(basePath: string): Promise<GSDState> {
     } else if (!activeMilestoneFound) {
       // Check milestone-level dependencies before promoting to active
       const contextFile = resolveMilestoneFile(basePath, mid, "CONTEXT");
-      const contextContent = contextFile ? await loadFile(contextFile) : null;
+      const contextContent = contextFile ? await cachedLoadFile(contextFile) : null;
       const deps = parseContextDependsOn(contextContent);
       const depsUnmet = deps.some(dep => !completeMilestoneIds.has(dep));
       if (depsUnmet) {
@@ -190,7 +302,7 @@ export async function deriveState(basePath: string): Promise<GSDState> {
       }
     } else {
       const contextFile2 = resolveMilestoneFile(basePath, mid, "CONTEXT");
-      const contextContent2 = contextFile2 ? await loadFile(contextFile2) : null;
+      const contextContent2 = contextFile2 ? await cachedLoadFile(contextFile2) : null;
       const deps2 = parseContextDependsOn(contextContent2);
       registry.push({ id: mid, title, status: 'pending', ...(deps2.length > 0 ? { dependsOn: deps2 } : {}) });
     }
@@ -330,7 +442,7 @@ export async function deriveState(basePath: string): Promise<GSDState> {
 
   // Check if the slice has a plan
   const planFile = resolveSliceFile(basePath, activeMilestone.id, activeSlice.id, "PLAN");
-  const slicePlanContent = planFile ? await loadFile(planFile) : null;
+  const slicePlanContent = planFile ? await cachedLoadFile(planFile) : null;
 
   if (!slicePlanContent) {
     return {
@@ -392,7 +504,7 @@ export async function deriveState(basePath: string): Promise<GSDState> {
   for (const ct of completedTasks) {
     const summaryFile = resolveTaskFile(basePath, activeMilestone.id, activeSlice.id, ct.id, "SUMMARY");
     if (!summaryFile) continue;
-    const summaryContent = await loadFile(summaryFile);
+    const summaryContent = await cachedLoadFile(summaryFile);
     if (!summaryContent) continue;
     const summary = parseSummary(summaryContent);
     if (summary.frontmatter.blocker_discovered) {
@@ -432,8 +544,8 @@ export async function deriveState(basePath: string): Promise<GSDState> {
   const sDir = resolveSlicePath(basePath, activeMilestone.id, activeSlice.id);
   const continueFile = sDir ? resolveSliceFile(basePath, activeMilestone.id, activeSlice.id, "CONTINUE") : null;
   // Also check legacy continue.md
-  const hasInterrupted = !!(continueFile && await loadFile(continueFile)) ||
-    !!(sDir && await loadFile(join(sDir, "continue.md")));
+  const hasInterrupted = !!(continueFile && await cachedLoadFile(continueFile)) ||
+    !!(sDir && await cachedLoadFile(join(sDir, "continue.md")));
 
   return {
     activeMilestone,

package/src/resources/extensions/gsd/templates/context.md

@@ -1,4 +1,4 @@
-# {{milestoneId}}: {{milestoneTitle}} — Context
+# {{milestoneId}}: {{milestoneTitle}}
 
 **Gathered:** {{date}}
 **Status:** Ready for planning

package/src/resources/extensions/gsd/templates/state.md

@@ -1,8 +1,8 @@
 # GSD State
 
-**Active Milestone:** {{milestoneId}} — {{milestoneTitle}}
-**Active Slice:** {{sliceId}} — {{sliceTitle}}
-**Active Task:** {{taskId}} — {{taskTitle}}
+**Active Milestone:** {{milestoneId}}: {{milestoneTitle}}
+**Active Slice:** {{sliceId}}: {{sliceTitle}}
+**Active Task:** {{taskId}}: {{taskTitle}}
 **Phase:** {{phase}}
 **Slice Branch:** {{activeBranch}}
 **Active Workspace:** {{activeWorkspace}}

package/src/resources/extensions/gsd/tests/activity-log-save.test.ts

@@ -0,0 +1,127 @@
+// Tests for saveActivityLog performance behavior:
+// - cache next sequence per activity directory instead of rescanning every save
+// - skip rewriting identical snapshots for the same unit
+// - recover safely if another writer creates the cached next sequence
+
+import { existsSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { saveActivityLog } from "../activity-log.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+let tmpDirs: string[] = [];
+
+function createBaseDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-activity-save-test-"));
+  tmpDirs.push(dir);
+  return dir;
+}
+
+function activityDir(baseDir: string): string {
+  return join(baseDir, ".gsd", "activity");
+}
+
+function listActivityFiles(baseDir: string): string[] {
+  const dir = activityDir(baseDir);
+  return existsSync(dir) ? readdirSync(dir).sort() : [];
+}
+
+function createCtx(entries: unknown[]) {
+  return {
+    sessionManager: {
+      getEntries: () => entries,
+    },
+  };
+}
+
+function cleanup(): void {
+  for (const dir of tmpDirs) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+  tmpDirs = [];
+}
+
+process.on("exit", cleanup);
+
+async function main(): Promise<void> {
+  console.log("\n── (a) cache next sequence instead of rescanning every save");
+  {
+    const baseDir = createBaseDir();
+    saveActivityLog(createCtx([{ kind: "first", n: 1 }]) as any, baseDir, "execute-task", "M001/S01/T01");
+
+    writeFileSync(
+      join(activityDir(baseDir), "999-external-manual.jsonl"),
+      '{"external":true}\n',
+      "utf-8",
+    );
+
+    saveActivityLog(createCtx([{ kind: "second", n: 2 }]) as any, baseDir, "execute-task", "M001/S01/T02");
+
+    const files = listActivityFiles(baseDir);
+    assertTrue(files.includes("001-execute-task-M001-S01-T01.jsonl"), "(a) first save uses sequence 001");
+    assertTrue(files.includes("002-execute-task-M001-S01-T02.jsonl"), "(a) second save uses cached next sequence 002");
+    assertTrue(files.includes("999-external-manual.jsonl"), "(a) externally added file remains present");
+    assertTrue(!files.some(file => file.startsWith("1000-")), "(a) second save did not rescan and jump to sequence 1000");
+  }
+
+  console.log("\n── (b) skip rewriting identical snapshots for the same unit");
+  {
+    const baseDir = createBaseDir();
+    const ctx = createCtx([{ role: "assistant", content: "same snapshot" }]);
+
+    saveActivityLog(ctx as any, baseDir, "plan-slice", "M002/S01");
+    saveActivityLog(ctx as any, baseDir, "plan-slice", "M002/S01");
+
+    let files = listActivityFiles(baseDir);
+    assertEq(files.length, 1, "(b) identical repeated save writes only one activity file");
+    assertTrue(files[0] === "001-plan-slice-M002-S01.jsonl", "(b) the original sequence is preserved");
+
+    saveActivityLog(createCtx([{ role: "assistant", content: "changed snapshot" }]) as any, baseDir, "plan-slice", "M002/S01");
+    files = listActivityFiles(baseDir);
+    assertEq(files.length, 2, "(b) changed snapshot writes a new activity file");
+    assertTrue(files.includes("002-plan-slice-M002-S01.jsonl"), "(b) deduped save did not consume the next sequence");
+  }
+
+  console.log("\n── (c) recover if another writer creates the exact cached target file");
+  {
+    const baseDir = createBaseDir();
+    saveActivityLog(createCtx([{ turn: 1 }]) as any, baseDir, "execute-task", "M003/S02/T01");
+
+    writeFileSync(
+      join(activityDir(baseDir), "002-execute-task-M003-S02-T02.jsonl"),
+      '{"collision":true}\n',
+      "utf-8",
+    );
+
+    saveActivityLog(createCtx([{ turn: 2 }]) as any, baseDir, "execute-task", "M003/S02/T02");
+
+    const files = listActivityFiles(baseDir);
+    assertTrue(files.includes("002-execute-task-M003-S02-T02.jsonl"), "(c) exact collision file is preserved");
+    assertTrue(files.includes("003-execute-task-M003-S02-T02.jsonl"), "(c) logger rescans only on collision and advances to 003");
+  }
+
+  console.log("\n── (d) dedupe is tracked per unit, not just the last write in the directory");
+  {
+    const baseDir = createBaseDir();
+    const repeatedCtx = createCtx([{ role: "assistant", content: "same-for-unit-a" }]);
+
+    saveActivityLog(repeatedCtx as any, baseDir, "execute-task", "M004/S01/T01");
+    saveActivityLog(createCtx([{ role: "assistant", content: "other-unit" }]) as any, baseDir, "execute-task", "M004/S01/T02");
+    saveActivityLog(repeatedCtx as any, baseDir, "execute-task", "M004/S01/T01");
+
+    const files = listActivityFiles(baseDir);
+    assertEq(files.length, 2, "(d) interleaving another unit does not force a duplicate rewrite for unit A");
+    assertTrue(files.includes("001-execute-task-M004-S01-T01.jsonl"), "(d) original unit A snapshot is retained");
+    assertTrue(files.includes("002-execute-task-M004-S01-T02.jsonl"), "(d) unit B snapshot is retained");
+  }
+
+  report();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

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

@@ -3,6 +3,8 @@ import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { createTestContext } from './test-helpers.ts';
+import { clearPathCache } from '../paths.ts';
+import { invalidateStateCache } from '../state.ts';
 
 // loadPrompt reads from ~/.gsd/agent/extensions/gsd/prompts/ (main checkout).
 // In a worktree the file may not exist there yet, so we resolve prompts
@@ -146,7 +148,7 @@ async function main(): Promise<void> {
   // ─── deriveState integration: completing-milestone dispatches correctly ─
   console.log("\n=== deriveState completing-milestone integration ===");
   {
-    const { deriveState, isMilestoneComplete } = await import("../state.ts");
+    const { deriveState, isMilestoneComplete, invalidateStateCache } = await import("../state.ts");
     const { parseRoadmap } = await import("../files.ts");
 
     const base = createFixtureBase();
@@ -179,6 +181,8 @@ async function main(): Promise<void> {
 
       // Now add the summary and verify it transitions to complete
       writeMilestoneSummary(base, "M001", "# M001 Summary\n\nDone.");
+      clearPathCache();
+      invalidateStateCache();
       const stateAfter = await deriveState(base);
       assertEq(stateAfter.phase, "complete", "deriveState returns complete after summary exists");
       assertEq(stateAfter.registry[0]?.status, "complete", "registry shows complete status");

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

@@ -2,7 +2,7 @@ import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync, existsSync
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { formatDoctorReport, runGSDDoctor, summarizeDoctorIssues, filterDoctorIssues, selectDoctorScope } from "../doctor.js";
+import { formatDoctorReport, runGSDDoctor, summarizeDoctorIssues, filterDoctorIssues, selectDoctorScope, validateTitle } from "../doctor.js";
 import { createTestContext } from './test-helpers.ts';
 
 const { assertEq, assertTrue, report } = createTestContext();
@@ -471,6 +471,120 @@ Discovered an issue.
     rmSync(mhBase, { recursive: true, force: true });
   }
 
+  // ─── validateTitle: em dash and slash detection ────────────────────────
+  console.log("\n=== validateTitle: returns null for clean titles ===");
+  {
+    assertEq(validateTitle("Foundation"), null, "clean title passes");
+    assertEq(validateTitle("Build Core Systems"), null, "clean title with spaces passes");
+    assertEq(validateTitle("API v2 Integration"), null, "clean title with version passes");
+    assertEq(validateTitle(""), null, "empty title passes");
+  }
+
+  console.log("\n=== validateTitle: detects em dash ===");
+  {
+    const result = validateTitle("Foundation — Build Core");
+    assertTrue(result !== null, "detects em dash in title");
+    assertTrue(result!.includes("em/en dash"), "message mentions em/en dash");
+  }
+
+  console.log("\n=== validateTitle: detects en dash ===");
+  {
+    const result = validateTitle("Phase 1 – Phase 2");
+    assertTrue(result !== null, "detects en dash in title");
+    assertTrue(result!.includes("em/en dash"), "message mentions em/en dash for en dash");
+  }
+
+  console.log("\n=== validateTitle: detects forward slash ===");
+  {
+    const result = validateTitle("Client/Server");
+    assertTrue(result !== null, "detects forward slash in title");
+    assertTrue(result!.includes("forward slash"), "message mentions forward slash");
+  }
+
+  console.log("\n=== validateTitle: detects both em dash and slash ===");
+  {
+    const result = validateTitle("Client — Server/API");
+    assertTrue(result !== null, "detects both delimiters");
+    assertTrue(result!.includes("em/en dash"), "message mentions em/en dash");
+    assertTrue(result!.includes("forward slash"), "message mentions forward slash");
+  }
+
+  // ─── doctor detects delimiter_in_title for milestone ───────────────────
+  console.log("\n=== doctor detects em dash in milestone title ===");
+  {
+    const dtBase = mkdtempSync(join(tmpdir(), "gsd-doctor-dt-test-"));
+    const dtGsd = join(dtBase, ".gsd");
+    const dtMDir = join(dtGsd, "milestones", "M001");
+    const dtSDir = join(dtMDir, "slices", "S01");
+    const dtTDir = join(dtSDir, "tasks");
+    mkdirSync(dtTDir, { recursive: true });
+
+    // Roadmap with em dash in milestone title
+    writeFileSync(join(dtMDir, "M001-ROADMAP.md"), `# M001: Foundation — Build Core\n\n## Slices\n- [ ] **S01: Demo Slice** \`risk:low\` \`depends:[]\`\n  > After this: demo works\n`);
+    writeFileSync(join(dtSDir, "S01-PLAN.md"), `# S01: Demo Slice\n\n**Goal:** Demo\n**Demo:** Demo\n\n## Tasks\n- [ ] **T01: Implement** \`est:10m\`\n  Task.\n`);
+    writeFileSync(join(dtTDir, "T01-PLAN.md"), `# T01: Implement\n\n## Steps\n\n1. Do the thing.\n`);
+
+    const report = await runGSDDoctor(dtBase, { fix: false });
+    const dtIssues = report.issues.filter(i => i.code === "delimiter_in_title");
+    assertTrue(dtIssues.length >= 1, "detects delimiter_in_title for milestone with em dash");
+    const milestoneIssue = dtIssues.find(i => i.scope === "milestone");
+    assertTrue(milestoneIssue !== undefined, "delimiter issue has milestone scope");
+    assertEq(milestoneIssue?.severity, "warning", "delimiter issue has warning severity");
+    assertEq(milestoneIssue?.unitId, "M001", "delimiter issue unitId is M001");
+    assertTrue(milestoneIssue?.message?.includes("em/en dash") ?? false, "issue message mentions em/en dash");
+    assertEq(milestoneIssue?.fixable, false, "delimiter issue is not auto-fixable");
+
+    rmSync(dtBase, { recursive: true, force: true });
+  }
+
+  // ─── doctor detects delimiter_in_title for slice ────────────────────────
+  console.log("\n=== doctor detects em dash in slice title ===");
+  {
+    const dtBase = mkdtempSync(join(tmpdir(), "gsd-doctor-dt-slice-"));
+    const dtGsd = join(dtBase, ".gsd");
+    const dtMDir = join(dtGsd, "milestones", "M001");
+    const dtSDir = join(dtMDir, "slices", "S01");
+    const dtTDir = join(dtSDir, "tasks");
+    mkdirSync(dtTDir, { recursive: true });
+
+    // Roadmap with em dash in slice title (milestone title is clean)
+    writeFileSync(join(dtMDir, "M001-ROADMAP.md"), `# M001: Clean Milestone\n\n## Slices\n- [ ] **S01: Core — Foundation** \`risk:low\` \`depends:[]\`\n  > After this: demo works\n`);
+    writeFileSync(join(dtSDir, "S01-PLAN.md"), `# S01: Core — Foundation\n\n**Goal:** Demo\n**Demo:** Demo\n\n## Tasks\n- [ ] **T01: Implement** \`est:10m\`\n  Task.\n`);
+    writeFileSync(join(dtTDir, "T01-PLAN.md"), `# T01: Implement\n\n## Steps\n\n1. Do the thing.\n`);
+
+    const report = await runGSDDoctor(dtBase, { fix: false });
+    const dtIssues = report.issues.filter(i => i.code === "delimiter_in_title");
+    assertTrue(dtIssues.length >= 1, "detects delimiter_in_title for slice with em dash");
+    const sliceIssue = dtIssues.find(i => i.scope === "slice");
+    assertTrue(sliceIssue !== undefined, "delimiter issue has slice scope");
+    assertEq(sliceIssue?.severity, "warning", "slice delimiter issue has warning severity");
+    assertEq(sliceIssue?.unitId, "M001/S01", "slice delimiter issue unitId is M001/S01");
+
+    rmSync(dtBase, { recursive: true, force: true });
+  }
+
+  // ─── doctor does NOT flag clean titles ──────────────────────────────────
+  console.log("\n=== doctor does NOT flag milestone with clean title ===");
+  {
+    const dtBase = mkdtempSync(join(tmpdir(), "gsd-doctor-dt-clean-"));
+    const dtGsd = join(dtBase, ".gsd");
+    const dtMDir = join(dtGsd, "milestones", "M001");
+    const dtSDir = join(dtMDir, "slices", "S01");
+    const dtTDir = join(dtSDir, "tasks");
+    mkdirSync(dtTDir, { recursive: true });
+
+    // Roadmap with clean titles (no delimiters)
+    writeFileSync(join(dtMDir, "M001-ROADMAP.md"), `# M001: Foundation Build Core\n\n## Slices\n- [ ] **S01: Demo Slice** \`risk:low\` \`depends:[]\`\n  > After this: demo works\n`);
+    writeFileSync(join(dtSDir, "S01-PLAN.md"), `# S01: Demo Slice\n\n**Goal:** Demo\n**Demo:** Demo\n\n## Tasks\n- [ ] **T01: Implement** \`est:10m\`\n  Task.\n`);
+    writeFileSync(join(dtTDir, "T01-PLAN.md"), `# T01: Implement\n\n## Steps\n\n1. Do the thing.\n`);
+
+    const report = await runGSDDoctor(dtBase, { fix: false });
+    const dtIssues = report.issues.filter(i => i.code === "delimiter_in_title");
+    assertEq(dtIssues.length, 0, "no delimiter_in_title issues for clean titles");
+
+    rmSync(dtBase, { recursive: true, force: true });
+  }
+
   report();
 }
 

package/src/resources/extensions/gsd/tests/draft-promotion.test.ts

@@ -2,8 +2,8 @@ import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync } from "node:
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { deriveState } from "../state.js";
-import { resolveMilestoneFile } from "../paths.js";
+import { deriveState, invalidateStateCache } from "../state.js";
+import { resolveMilestoneFile, clearPathCache } from "../paths.js";
 
 let passed = 0;
 let failed = 0;
@@ -40,6 +40,8 @@ assert(
 const contextPath = join(gsd, "milestones", "M001", "M001-CONTEXT.md");
 writeFileSync(contextPath, "# M001: Full Context\n\nDeep discussion output.\n");
 
+clearPathCache();
+invalidateStateCache();
 const state2 = await deriveState(tmpBase);
 assert(
   state2.phase === "pre-planning",
@@ -65,6 +67,8 @@ assert(
 );
 
 // Step 4: After cleanup, state is still pre-planning (CONTEXT.md exists)
+clearPathCache();
+invalidateStateCache();
 const state3 = await deriveState(tmpBase);
 assert(
   state3.phase === "pre-planning",