gsd-pi 2.11.0 → 2.12.0

package/dist/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/dist/resources/extensions/gsd/tests/post-unit-hooks.test.ts

@@ -0,0 +1,297 @@
+// GSD Extension — Hook Engine Tests (Post-Unit, Pre-Dispatch, State Persistence)
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { createTestContext } from "./test-helpers.ts";
+import {
+  checkPostUnitHooks,
+  getActiveHook,
+  resetHookState,
+  isRetryPending,
+  consumeRetryTrigger,
+  resolveHookArtifactPath,
+  runPreDispatchHooks,
+  persistHookState,
+  restoreHookState,
+  clearPersistedHookState,
+  getHookStatus,
+  formatHookStatus,
+} from "../post-unit-hooks.ts";
+
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
+// ─── Fixture Helpers ───────────────────────────────────────────────────────
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-hook-test-"));
+  mkdirSync(join(base, ".gsd", "M001", "slices", "S01", "tasks"), { recursive: true });
+  return base;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Phase 1: Post-Unit Hook Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+// ─── resolveHookArtifactPath ───────────────────────────────────────────────
+
+console.log("\n=== resolveHookArtifactPath ===");
+
+{
+  const base = "/project";
+
+  // Task-level
+  const taskPath = resolveHookArtifactPath(base, "M001/S01/T01", "REVIEW-PASS.md");
+  assertEq(
+    taskPath,
+    join(base, ".gsd", "M001", "slices", "S01", "tasks", "T01-REVIEW-PASS.md"),
+    "task-level artifact path",
+  );
+
+  // Slice-level
+  const slicePath = resolveHookArtifactPath(base, "M001/S01", "REVIEW-PASS.md");
+  assertEq(
+    slicePath,
+    join(base, ".gsd", "M001", "slices", "S01", "REVIEW-PASS.md"),
+    "slice-level artifact path",
+  );
+
+  // Milestone-level
+  const milestonePath = resolveHookArtifactPath(base, "M001", "REVIEW-PASS.md");
+  assertEq(
+    milestonePath,
+    join(base, ".gsd", "M001", "REVIEW-PASS.md"),
+    "milestone-level artifact path",
+  );
+}
+
+// ─── resetHookState ────────────────────────────────────────────────────────
+
+console.log("\n=== resetHookState ===");
+
+{
+  resetHookState();
+  assertEq(getActiveHook(), null, "no active hook after reset");
+  assertTrue(!isRetryPending(), "no retry pending after reset");
+  assertEq(consumeRetryTrigger(), null, "no retry trigger after reset");
+}
+
+// ─── checkPostUnitHooks with no hooks configured ───────────────────────────
+
+console.log("\n=== No hooks configured ===");
+
+{
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    const result = checkPostUnitHooks("execute-task", "M001/S01/T01", base);
+    assertEq(result, null, "returns null when no hooks configured");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+// ─── Hook units don't trigger hooks (no hook-on-hook) ──────────────────────
+
+console.log("\n=== Hook-on-hook prevention ===");
+
+{
+  resetHookState();
+  const base = createFixtureBase();
+  try {
+    const result = checkPostUnitHooks("hook/code-review", "M001/S01/T01", base);
+    assertEq(result, null, "hook units don't trigger other hooks");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+// ─── consumeRetryTrigger clears state ──────────────────────────────────────
+
+console.log("\n=== consumeRetryTrigger clears state ===");
+
+{
+  resetHookState();
+  assertEq(consumeRetryTrigger(), null, "no trigger initially");
+  assertTrue(!isRetryPending(), "no retry initially");
+}
+
+// ─── Variable substitution in prompts ──────────────────────────────────────
+
+console.log("\n=== Variable substitution ===");
+
+{
+  const base = "/project";
+
+  // 3-part ID
+  const path3 = resolveHookArtifactPath(base, "M002/S03/T05", "result.md");
+  assertTrue(path3.includes("M002"), "3-part ID extracts milestoneId");
+  assertTrue(path3.includes("S03"), "3-part ID extracts sliceId");
+  assertTrue(path3.includes("T05"), "3-part ID extracts taskId");
+
+  // 2-part ID
+  const path2 = resolveHookArtifactPath(base, "M002/S03", "result.md");
+  assertTrue(path2.includes("M002"), "2-part ID extracts milestoneId");
+  assertTrue(path2.includes("S03"), "2-part ID extracts sliceId");
+
+  // 1-part ID
+  const path1 = resolveHookArtifactPath(base, "M002", "result.md");
+  assertTrue(path1.includes("M002"), "1-part ID extracts milestoneId");
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Phase 2: Pre-Dispatch Hook Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== Pre-dispatch: no hooks configured ===");
+
+{
+  const base = createFixtureBase();
+  try {
+    const result = runPreDispatchHooks("execute-task", "M001/S01/T01", "original prompt", base);
+    assertEq(result.action, "proceed", "proceeds when no hooks");
+    assertEq(result.prompt, "original prompt", "prompt unchanged");
+    assertEq(result.firedHooks.length, 0, "no hooks fired");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+console.log("\n=== Pre-dispatch: hook units bypass ===");
+
+{
+  const base = createFixtureBase();
+  try {
+    const result = runPreDispatchHooks("hook/review", "M001/S01/T01", "hook prompt", base);
+    assertEq(result.action, "proceed", "hook units always proceed");
+    assertEq(result.prompt, "hook prompt", "hook prompt unchanged");
+    assertEq(result.firedHooks.length, 0, "no hooks fired for hook units");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Phase 3: State Persistence Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== State persistence: persist and restore ===");
+
+{
+  const base = createFixtureBase();
+  try {
+    resetHookState();
+
+    // Persist empty state
+    persistHookState(base);
+    const filePath = join(base, ".gsd", "hook-state.json");
+    assertTrue(existsSync(filePath), "hook-state.json created");
+
+    const content = JSON.parse(readFileSync(filePath, "utf-8"));
+    assertEq(typeof content.savedAt, "string", "savedAt is a string");
+    assertEq(Object.keys(content.cycleCounts).length, 0, "empty cycle counts");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+console.log("\n=== State persistence: restore from disk ===");
+
+{
+  const base = createFixtureBase();
+  try {
+    resetHookState();
+
+    // Write a state file with some cycle counts
+    const stateFile = join(base, ".gsd", "hook-state.json");
+    writeFileSync(stateFile, JSON.stringify({
+      cycleCounts: {
+        "review/execute-task/M001/S01/T01": 2,
+        "simplify/execute-task/M001/S01/T02": 1,
+      },
+      savedAt: new Date().toISOString(),
+    }), "utf-8");
+
+    // Restore
+    restoreHookState(base);
+
+    // Verify by persisting and reading back
+    persistHookState(base);
+    const restored = JSON.parse(readFileSync(stateFile, "utf-8"));
+    assertEq(restored.cycleCounts["review/execute-task/M001/S01/T01"], 2, "cycle count restored for review");
+    assertEq(restored.cycleCounts["simplify/execute-task/M001/S01/T02"], 1, "cycle count restored for simplify");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+console.log("\n=== State persistence: clear ===");
+
+{
+  const base = createFixtureBase();
+  try {
+    resetHookState();
+
+    // Write then clear
+    const stateFile = join(base, ".gsd", "hook-state.json");
+    writeFileSync(stateFile, JSON.stringify({
+      cycleCounts: { "review/execute-task/M001/S01/T01": 3 },
+      savedAt: new Date().toISOString(),
+    }), "utf-8");
+
+    clearPersistedHookState(base);
+
+    const cleared = JSON.parse(readFileSync(stateFile, "utf-8"));
+    assertEq(Object.keys(cleared.cycleCounts).length, 0, "cycle counts cleared");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+console.log("\n=== State persistence: restore handles missing file ===");
+
+{
+  const base = createFixtureBase();
+  try {
+    resetHookState();
+    // Should not throw
+    restoreHookState(base);
+    assertEq(getActiveHook(), null, "no active hook after restore from missing file");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+console.log("\n=== State persistence: restore handles corrupt file ===");
+
+{
+  const base = createFixtureBase();
+  try {
+    resetHookState();
+    writeFileSync(join(base, ".gsd", "hook-state.json"), "not json", "utf-8");
+    // Should not throw
+    restoreHookState(base);
+    assertEq(getActiveHook(), null, "no active hook after corrupt restore");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Phase 3: Hook Status Reporting Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== Hook status: no hooks ===");
+
+{
+  resetHookState();
+  const entries = getHookStatus();
+  // No preferences file = no hooks
+  assertEq(entries.length, 0, "no entries when no hooks configured");
+
+  const formatted = formatHookStatus();
+  assertMatch(formatted, /No hooks configured/, "status message says no hooks");
+}
+
+report();

package/dist/resources/extensions/gsd/tests/preferences-hooks.test.ts

@@ -0,0 +1,226 @@
+// GSD Extension — Hook Preferences Parsing Tests (Post-Unit + Pre-Dispatch)
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Phase 1: Post-Unit Hook Config Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== Post-unit hook config validation ===");
+
+{
+  const validHook = {
+    name: "test-hook",
+    after: ["execute-task"],
+    prompt: "Test prompt",
+    max_cycles: 2,
+    model: "claude-sonnet-4-6",
+    artifact: "TEST-RESULT.md",
+    retry_on: "TEST-ISSUES.md",
+    enabled: true,
+  };
+
+  assertEq(validHook.name, "test-hook", "valid hook has name");
+  assertEq(validHook.after.length, 1, "valid hook has one after entry");
+  assertEq(validHook.after[0], "execute-task", "valid hook triggers after execute-task");
+  assertTrue(validHook.max_cycles! <= 10, "max_cycles within limit");
+  assertTrue(validHook.max_cycles! >= 1, "max_cycles above minimum");
+}
+
+console.log("\n=== max_cycles clamping ===");
+
+{
+  const clampedHigh = Math.max(1, Math.min(10, Math.round(15)));
+  assertEq(clampedHigh, 10, "max_cycles above 10 clamped to 10");
+
+  const clampedLow = Math.max(1, Math.min(10, Math.round(0)));
+  assertEq(clampedLow, 1, "max_cycles below 1 clamped to 1");
+
+  const clampedNeg = Math.max(1, Math.min(10, Math.round(-5)));
+  assertEq(clampedNeg, 1, "negative max_cycles clamped to 1");
+
+  const normal = Math.max(1, Math.min(10, Math.round(3)));
+  assertEq(normal, 3, "normal max_cycles passes through");
+}
+
+console.log("\n=== Post-unit hook merging ===");
+
+{
+  const baseHooks = [
+    { name: "review", after: ["execute-task"], prompt: "base prompt" },
+    { name: "lint", after: ["plan-slice"], prompt: "lint code" },
+  ];
+
+  const overrideHooks = [
+    { name: "review", after: ["execute-task", "complete-slice"], prompt: "override prompt" },
+    { name: "security", after: ["execute-task"], prompt: "security check" },
+  ];
+
+  const merged = [...baseHooks];
+  for (const hook of overrideHooks) {
+    const idx = merged.findIndex(h => h.name === hook.name);
+    if (idx >= 0) {
+      merged[idx] = hook;
+    } else {
+      merged.push(hook);
+    }
+  }
+
+  assertEq(merged.length, 3, "merged has 3 hooks");
+  assertEq(merged[0].prompt, "override prompt", "review hook was overridden");
+  assertEq(merged[0].after.length, 2, "overridden review has 2 after entries");
+  assertEq(merged[1].name, "lint", "lint kept from base");
+  assertEq(merged[2].name, "security", "security added from override");
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Phase 2: Pre-Dispatch Hook Config Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== Pre-dispatch hook config shape ===");
+
+{
+  const modifyHook = {
+    name: "inject-context",
+    before: ["execute-task"],
+    action: "modify" as const,
+    prepend: "Remember to follow coding conventions.",
+    append: "Run tests after making changes.",
+    enabled: true,
+  };
+
+  assertEq(modifyHook.name, "inject-context", "modify hook has name");
+  assertEq(modifyHook.action, "modify", "action is modify");
+  assertTrue(!!modifyHook.prepend, "has prepend text");
+  assertTrue(!!modifyHook.append, "has append text");
+}
+
+{
+  const skipHook = {
+    name: "skip-research",
+    before: ["research-slice"],
+    action: "skip" as const,
+    skip_if: "RESEARCH-DONE.md",
+    enabled: true,
+  };
+
+  assertEq(skipHook.action, "skip", "action is skip");
+  assertEq(skipHook.skip_if, "RESEARCH-DONE.md", "has skip condition");
+}
+
+{
+  const replaceHook = {
+    name: "custom-planning",
+    before: ["plan-slice"],
+    action: "replace" as const,
+    prompt: "Use custom planning approach for {sliceId}",
+    unit_type: "custom-plan",
+    model: "claude-opus-4-6",
+    enabled: true,
+  };
+
+  assertEq(replaceHook.action, "replace", "action is replace");
+  assertTrue(!!replaceHook.prompt, "replace hook has prompt");
+  assertEq(replaceHook.unit_type, "custom-plan", "has unit_type override");
+}
+
+console.log("\n=== Pre-dispatch action validation ===");
+
+{
+  const validActions = new Set(["modify", "skip", "replace"]);
+  assertTrue(validActions.has("modify"), "modify is valid");
+  assertTrue(validActions.has("skip"), "skip is valid");
+  assertTrue(validActions.has("replace"), "replace is valid");
+  assertTrue(!validActions.has("delete"), "delete is not valid");
+  assertTrue(!validActions.has(""), "empty string is not valid");
+}
+
+console.log("\n=== Pre-dispatch hook merging ===");
+
+{
+  const baseHooks = [
+    { name: "inject", before: ["execute-task"], action: "modify" as const, prepend: "base" },
+  ];
+
+  const overrideHooks = [
+    { name: "inject", before: ["execute-task"], action: "modify" as const, prepend: "override" },
+    { name: "gate", before: ["plan-slice"], action: "skip" as const },
+  ];
+
+  const merged = [...baseHooks];
+  for (const hook of overrideHooks) {
+    const idx = merged.findIndex(h => h.name === hook.name);
+    if (idx >= 0) {
+      merged[idx] = hook;
+    } else {
+      merged.push(hook);
+    }
+  }
+
+  assertEq(merged.length, 2, "merged has 2 pre-dispatch hooks");
+  assertEq(merged[0].prepend, "override", "inject hook overridden");
+  assertEq(merged[1].name, "gate", "gate hook added");
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Known unit types validation
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== Known unit types ===");
+
+{
+  const knownUnitTypes = new Set([
+    "research-milestone", "plan-milestone", "research-slice", "plan-slice",
+    "execute-task", "complete-slice", "replan-slice", "reassess-roadmap",
+    "run-uat", "fix-merge", "complete-milestone",
+  ]);
+
+  assertTrue(knownUnitTypes.has("execute-task"), "execute-task is known");
+  assertTrue(knownUnitTypes.has("complete-slice"), "complete-slice is known");
+  assertTrue(knownUnitTypes.has("plan-slice"), "plan-slice is known");
+  assertTrue(!knownUnitTypes.has("hook/review"), "hook types are not in known set");
+  assertTrue(!knownUnitTypes.has("invalid-type"), "invalid types are not in known set");
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Preferences YAML format verification
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== Preferences YAML format ===");
+
+{
+  const prefsContent = [
+    "---",
+    "version: 1",
+    "post_unit_hooks:",
+    "  - name: code-review",
+    "    after:",
+    "      - execute-task",
+    "    prompt: Review the changes",
+    "    max_cycles: 3",
+    "    artifact: REVIEW-PASS.md",
+    "    retry_on: REVIEW-ISSUES.md",
+    "pre_dispatch_hooks:",
+    "  - name: inject-conventions",
+    "    before:",
+    "      - execute-task",
+    "    action: modify",
+    "    append: Follow project coding conventions",
+    "  - name: custom-research",
+    "    before:",
+    "      - research-slice",
+    "    action: replace",
+    "    prompt: Custom research prompt",
+    "---",
+  ].join("\n");
+
+  assertTrue(prefsContent.includes("post_unit_hooks:"), "has post_unit_hooks key");
+  assertTrue(prefsContent.includes("pre_dispatch_hooks:"), "has pre_dispatch_hooks key");
+  assertTrue(prefsContent.includes("action: modify"), "has modify action");
+  assertTrue(prefsContent.includes("action: replace"), "has replace action");
+}
+
+report();

package/dist/resources/extensions/gsd/tests/regex-hardening.test.ts

@@ -67,6 +67,18 @@ async function main(): Promise<void> {
     assertEq('M001-abc123: Title'.replace(TITLE_STRIP_RE, ''), 'Title', 'strips M001-abc123: Title → Title');
     assertEq('M042-z9a8b7: Dashboard'.replace(TITLE_STRIP_RE, ''), 'Dashboard', 'strips M042-z9a8b7: Dashboard');
 
+    // Em dash in title — current format (M001: Title) correctly preserves em dash in title body
+    assertEq(
+      'M001: Foundation — Build Core'.replace(TITLE_STRIP_RE, ''),
+      'Foundation — Build Core',
+      'strips M001: prefix and preserves em dash in title body',
+    );
+    assertEq(
+      'M001-abc123: Foundation — Build Core'.replace(TITLE_STRIP_RE, ''),
+      'Foundation — Build Core',
+      'strips M001-abc123: prefix and preserves em dash in title body (unique format)',
+    );
+
     // Edge case: dash-style separator (M001 — Title: Subtitle preserves colon in body)
     assertEq(
       'M001 — Unique Milestone IDs: Foo'.replace(TITLE_STRIP_RE, ''),