gsd-pi 2.77.0-dev.58d3d4d6c → 2.77.0-dev.cfd69e714

package/src/resources/extensions/gsd/tests/reassess-default-optin.test.ts

@@ -0,0 +1,132 @@
+// GSD-2 — ADR-003 §4 behavior contract: reassess-roadmap is opt-in.
+// Companion to (eventually replacing) the source-grep assertions in
+// token-profile.test.ts. This file verifies the dispatch rule's guard
+// behavior directly rather than inspecting source text.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+
+import {
+  DISPATCH_RULES,
+  setReassessmentCheckerForTest,
+  type DispatchAction,
+  type DispatchContext,
+} from "../auto-dispatch.ts";
+import { resolveProfileDefaults } from "../preferences-models.ts";
+import type { GSDState } from "../types.ts";
+import type { GSDPreferences } from "../preferences.ts";
+
+const REASSESS_RULE_NAME = "reassess-roadmap (post-completion)";
+
+function makeIsolatedBase(): string {
+  const base = join(tmpdir(), `gsd-reassess-default-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  return base;
+}
+
+function makeCtx(prefs: GSDPreferences | undefined, basePath: string): DispatchContext {
+  const state: GSDState = {
+    phase: "executing",
+    activeMilestone: { id: "M001", title: "Test" },
+    activeSlice: { id: "S01", title: "First" },
+    activeTask: null,
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry: [{ id: "M001", title: "Test", status: "active" }],
+  };
+  return { basePath, mid: "M001", midTitle: "Test", state, prefs };
+}
+
+function reassessRule() {
+  const rule = DISPATCH_RULES.find(r => r.name === REASSESS_RULE_NAME);
+  assert.ok(rule, `dispatch rule "${REASSESS_RULE_NAME}" must exist`);
+  return rule!;
+}
+
+const guardCases: Array<{ name: string; prefs: GSDPreferences | undefined; message?: string }> = [
+  {
+    name: "prefs is undefined (new default)",
+    prefs: undefined,
+    message: "default behavior must be opt-in — no prefs means no reassess dispatch",
+  },
+  {
+    name: "prefs.phases is undefined",
+    prefs: {} as GSDPreferences,
+  },
+  {
+    name: "phases.reassess_after_slice is explicitly false",
+    prefs: { phases: { reassess_after_slice: false } } as unknown as GSDPreferences,
+  },
+  {
+    name: "phases.skip_reassess is true (short-circuit guard preserved)",
+    prefs: { phases: { skip_reassess: true, reassess_after_slice: true } } as unknown as GSDPreferences,
+    message: "skip_reassess must win over reassess_after_slice",
+  },
+];
+
+for (const { name, prefs, message } of guardCases) {
+  test(`ADR-003 §4: reassess-roadmap does NOT dispatch when ${name}`, async (t) => {
+    const base = makeIsolatedBase();
+    t.after(() => { try { rmSync(base, { recursive: true, force: true }); } catch {} });
+
+    let checkerCalls = 0;
+    const restoreChecker = setReassessmentCheckerForTest(async () => {
+      checkerCalls++;
+      return { sliceId: "S01" };
+    });
+    t.after(restoreChecker);
+
+    const result = await reassessRule().match(makeCtx(prefs, base));
+    assert.strictEqual(result, null, message);
+    assert.strictEqual(checkerCalls, 0, "preference guards must short-circuit before reassessment detection");
+  });
+}
+
+test("ADR-003 §4: reassess-roadmap opt-in path dispatches after reassessment detection", async (t) => {
+  const base = makeIsolatedBase();
+  t.after(() => { try { rmSync(base, { recursive: true, force: true }); } catch {} });
+
+  const checkerCalls: Array<{ basePath: string; mid: string; activeSliceId: string | undefined }> = [];
+  const restoreChecker = setReassessmentCheckerForTest(async (checkerBase, checkerMid, state) => {
+    checkerCalls.push({ basePath: checkerBase, mid: checkerMid, activeSliceId: state.activeSlice?.id });
+    return { sliceId: "S01" };
+  });
+  t.after(restoreChecker);
+
+  const prefs = { phases: { reassess_after_slice: true } } as unknown as GSDPreferences;
+  const result: DispatchAction | null = await reassessRule().match(makeCtx(prefs, base));
+
+  assert.deepStrictEqual(checkerCalls, [{ basePath: base, mid: "M001", activeSliceId: "S01" }]);
+  assert.ok(result, "opt-in path should return a dispatch action when reassessment is needed");
+  assert.strictEqual(result.action, "dispatch");
+  if (result.action !== "dispatch") assert.fail("expected dispatch action");
+  assert.strictEqual(result.unitType, "reassess-roadmap");
+  assert.strictEqual(result.unitId, "M001/S01");
+  assert.match(result.prompt, /reassess/i);
+});
+
+test("ADR-003 §4: burn-max profile opts into dedicated reassess-roadmap dispatch", () => {
+  const defaults = resolveProfileDefaults("burn-max");
+  assert.strictEqual(defaults.phases?.reassess_after_slice, true);
+  assert.strictEqual(defaults.phases?.skip_reassess, false);
+});
+
+test("ADR-003 §4: plan-slice prompt and MCP tool agree on reassess sliceChanges shape", () => {
+  const planSlicePrompt = readFileSync(new URL("../prompts/plan-slice.md", import.meta.url), "utf8");
+  assert.match(planSlicePrompt, /gsd_reassess_roadmap/);
+  assert.match(planSlicePrompt, /sliceChanges\.modified/);
+  assert.match(planSlicePrompt, /sliceChanges\.added/);
+  assert.match(planSlicePrompt, /sliceChanges\.removed/);
+
+  const dbToolsSource = readFileSync(new URL("../bootstrap/db-tools.ts", import.meta.url), "utf8");
+  assert.match(dbToolsSource, /name:\s*"gsd_reassess_roadmap"/);
+  assert.match(dbToolsSource, /sliceChanges:\s*Type\.Object/);
+  assert.match(dbToolsSource, /modified:\s*Type\.Array/);
+  assert.match(dbToolsSource, /added:\s*Type\.Array/);
+  assert.match(dbToolsSource, /removed:\s*Type\.Array/);
+});

package/src/resources/extensions/gsd/tests/recovery-attempts-reset.test.ts

@@ -81,46 +81,14 @@ try {
     );
   }
 
-  // ═══ Verify the BUG scenario: omitting recoveryAttempts carries it over ═══
-
-  {
-    console.log("\n=== #2322: demonstrates bug — omitting recoveryAttempts carries it over ===");
-
-    const unitType = "execute-task";
-    const unitId = "M001/S01/T02";
-    const startedAt1 = Date.now() - 10000;
-
-    // First dispatch
-    writeUnitRuntimeRecord(base, unitType, unitId, startedAt1, {
-      phase: "dispatched",
-    });
-
-    // Timeout bumps recoveryAttempts to 1
-    writeUnitRuntimeRecord(base, unitType, unitId, startedAt1, {
-      recoveryAttempts: 1,
-      lastRecoveryReason: "hard",
-    });
-
-    // Re-dispatch WITHOUT resetting recoveryAttempts (the bug)
-    const startedAt2 = Date.now();
-    writeUnitRuntimeRecord(base, unitType, unitId, startedAt2, {
-      phase: "dispatched",
-      wrapupWarningSent: false,
-      timeoutAt: null,
-      lastProgressAt: startedAt2,
-      progressCount: 0,
-      lastProgressKind: "dispatch",
-      // recoveryAttempts: NOT included — this is the bug
-    });
-
-    const afterBuggyRedispatch = readUnitRuntimeRecord(base, unitType, unitId);
-    // This DEMONSTRATES the bug: recoveryAttempts is still 1
-    assertEq(
-      afterBuggyRedispatch?.recoveryAttempts,
-      1,
-      "BUG DEMO: recoveryAttempts carries over when not explicitly reset",
-    );
-  }
+  // Note (#4837): the previous "BUG DEMO" block was tautological — it only
+  // asserted that writeUnitRuntimeRecord merges partial updates into the
+  // stored record (which is the function's documented behaviour and is
+  // already covered by unit-runtime.test.ts). Proving merge semantics here
+  // added zero coverage of the #2322 fix. The first block above verifies the
+  // fix itself (explicit recoveryAttempts: 0 on re-dispatch resets the
+  // counter); the block below verifies the end-to-end budget-reset
+  // invariant.
 
   // ═══ Hard timeout maxRecoveryAttempts=1 — second dispatch must get full budget ═══
 

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

@@ -1,281 +1,161 @@
-// Regex-hardening tests for S02/T02 — proves all 12 regex/parser sites
-// accept both M001 (classic) and M001-abc123 (unique) milestone ID formats.
-//
-// Sections:
-//   (a) Directory scanning regex — findMilestoneIds pattern
-//   (b) Title-strip regex — milestone title cleanup
-//   (c) SLICE_BRANCH_RE — branch name parsing (with/without worktree prefix)
-//   (d) Milestone detection regex — hasExistingMilestones pattern
-//   (e) MILESTONE_CONTEXT_RE — context write-gate filename match
-//   (f) Prompt dispatch regexes — executeMatch and resumeMatch capture
-//   (g) milestoneIdSort — mixed-format ordering
-//   (h) extractMilestoneSeq — numeric extraction from both formats
-
-import { test } from 'node:test';
+/**
+ * regex-hardening.test.ts — verifies production regexes accept both the
+ * legacy (M001) and unique (M001-abc123) milestone ID formats.
+ *
+ * The previous version of this file advertised 12 parser sites but
+ * only 3 tested imports (SLICE_BRANCH_RE, MILESTONE_ID_RE helpers).
+ * The remaining 9 sections (a, b, d, e, f) declared local `const
+ * *_RE = ...` copies of production regexes and asserted against the
+ * copies — a bug in the real regex would not fail those tests. See
+ * #4835.
+ *
+ * This rewrite imports every production pattern it exercises. Four
+ * call sites whose regexes are inline at the use site (state.ts:313
+ * title-strip, workspace-index.ts:80 title extraction, worktree-
+ * command.ts hasExistingMilestones, and the prompt dispatch regexes
+ * in index.ts) are intentionally NOT reimplemented here — they should
+ * be covered by behaviour tests of their parent functions, not by
+ * regex-copy assertions. A follow-up issue tracks extracting those
+ * regexes to a shared patterns module so they can be tested directly.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
 
 import {
   MILESTONE_ID_RE,
   extractMilestoneSeq,
   milestoneIdSort,
-} from '../guided-flow.ts';
-
-import { SLICE_BRANCH_RE } from '../worktree.ts';
-import { createTestContext } from './test-helpers.ts';
-
-
-const { assertEq, assertTrue, report } = createTestContext();
-// ─── Tests ─────────────────────────────────────────────────────────────────
-
-async function main(): Promise<void> {
-  console.log('regex-hardening tests');
-
-  // (a) Directory scanning regex — used in state.ts, workspace-index.ts, files.ts
-  //     Pattern: /^(M\d+(?:-[a-z0-9]{6})?)/
-  {
-    console.log('  (a) Directory scanning regex');
-    const DIR_SCAN_RE = /^(M\d+(?:-[a-z0-9]{6})?)/;
-
-    // Classic format matches
-    assertTrue(DIR_SCAN_RE.test('M001'), 'dir scan matches M001');
-    assertTrue(DIR_SCAN_RE.test('M042'), 'dir scan matches M042');
-    assertTrue(DIR_SCAN_RE.test('M999'), 'dir scan matches M999');
-    assertEq(('M001' as string).match(DIR_SCAN_RE)?.[1], 'M001', 'captures M001');
-
-    // Unique format matches
-    assertTrue(DIR_SCAN_RE.test('M001-abc123'), 'dir scan matches M001-abc123');
-    assertTrue(DIR_SCAN_RE.test('M042-z9a8b7'), 'dir scan matches M042-z9a8b7');
-    assertEq(('M001-abc123' as string).match(DIR_SCAN_RE)?.[1], 'M001-abc123', 'captures M001-abc123 from dir name');
-
-    // Rejects
-    assertTrue(!DIR_SCAN_RE.test('S01'), 'dir scan rejects S01');
-    assertTrue(!DIR_SCAN_RE.test('X001'), 'dir scan rejects X001');
-    assertTrue(!DIR_SCAN_RE.test('.DS_Store'), 'dir scan rejects .DS_Store');
-    assertTrue(!DIR_SCAN_RE.test('notes'), 'dir scan rejects notes');
-  }
-
-  // (b) Title-strip regex — used in state.ts, workspace-index.ts
-  //     Pattern: /^M\d+(?:-[a-z0-9]{6})?[^:]*:\s*/
-  {
-    console.log('  (b) Title-strip regex');
-    const TITLE_STRIP_RE = /^M\d+(?:-[a-z0-9]{6})?[^:]*:\s*/;
-
-    // Classic format strip
-    assertEq('M001: Title'.replace(TITLE_STRIP_RE, ''), 'Title', 'strips M001: Title → Title');
-    assertEq('M042: Payment Integration'.replace(TITLE_STRIP_RE, ''), 'Payment Integration', 'strips M042: Payment Integration');
+} from "../guided-flow.ts";
+import { SLICE_BRANCH_RE } from "../worktree.ts";
+import { MILESTONE_CONTEXT_RE } from "../bootstrap/write-gate.ts";
 
-    // Unique format strip
-    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');
+// ─── MILESTONE_ID_RE ──────────────────────────────────────────────────────
 
-    // 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, ''),
-      'Foo',
-      'strips M001 — Unique Milestone IDs: Foo → Foo (first colon consumed)',
-    );
-
-    // Edge case: colon inside title body preserved
-    assertEq(
-      'M001: Note: important'.replace(TITLE_STRIP_RE, ''),
-      'Note: important',
-      'preserves colons in title body',
-    );
-
-    // No match — leaves non-milestone strings alone
-    assertEq('S01: Slice Title'.replace(TITLE_STRIP_RE, ''), 'S01: Slice Title', 'does not strip S01 prefix');
-  }
-
-  // (c) SLICE_BRANCH_RE — from worktree.ts
-  //     Pattern: /^gsd\/(?:([a-zA-Z0-9_-]+)\/)?(M\d+(?:-[a-z0-9]{6})?)\/(S\d+)$/
-  {
-    console.log('  (c) SLICE_BRANCH_RE');
-
-    // Classic format — no worktree prefix
-    {
-      const m = 'gsd/M001/S01'.match(SLICE_BRANCH_RE);
-      assertTrue(m !== null, 'matches gsd/M001/S01');
-      assertEq(m?.[1], undefined, 'no worktree prefix for gsd/M001/S01');
-      assertEq(m?.[2], 'M001', 'captures M001');
-      assertEq(m?.[3], 'S01', 'captures S01');
-    }
-
-    // Unique format — no worktree prefix
-    {
-      const m = 'gsd/M001-abc123/S01'.match(SLICE_BRANCH_RE);
-      assertTrue(m !== null, 'matches gsd/M001-abc123/S01');
-      assertEq(m?.[1], undefined, 'no worktree prefix for unique format');
-      assertEq(m?.[2], 'M001-abc123', 'captures M001-abc123');
-      assertEq(m?.[3], 'S01', 'captures S01');
-    }
-
-    // Classic format — with worktree prefix
-    {
-      const m = 'gsd/worktree/M001/S01'.match(SLICE_BRANCH_RE);
-      assertTrue(m !== null, 'matches gsd/worktree/M001/S01');
-      assertEq(m?.[1], 'worktree', 'captures worktree prefix');
-      assertEq(m?.[2], 'M001', 'captures M001 with worktree');
-      assertEq(m?.[3], 'S01', 'captures S01 with worktree');
-    }
-
-    // Unique format — with worktree prefix
-    {
-      const m = 'gsd/worktree/M001-abc123/S01'.match(SLICE_BRANCH_RE);
-      assertTrue(m !== null, 'matches gsd/worktree/M001-abc123/S01');
-      assertEq(m?.[1], 'worktree', 'captures worktree prefix with unique format');
-      assertEq(m?.[2], 'M001-abc123', 'captures M001-abc123 with worktree');
-      assertEq(m?.[3], 'S01', 'captures S01 with worktree and unique format');
-    }
-
-    // Rejects
-    assertTrue(!SLICE_BRANCH_RE.test('gsd/S01'), 'rejects gsd/S01 (no milestone)');
-    assertTrue(!SLICE_BRANCH_RE.test('main'), 'rejects main');
-    assertTrue(!SLICE_BRANCH_RE.test('gsd/M001'), 'rejects gsd/M001 (no slice)');
-    assertTrue(!SLICE_BRANCH_RE.test('feature/M001/S01'), 'rejects feature/ prefix');
-  }
-
-  // (d) Milestone detection regex — used in worktree-command.ts (hasExistingMilestones)
-  //     Pattern: /^M\d+(?:-[a-z0-9]{6})?/
-  {
-    console.log('  (d) Milestone detection regex');
-    const MILESTONE_DETECT_RE = /^M\d+(?:-[a-z0-9]{6})?/;
+test("MILESTONE_ID_RE accepts classic M001 format", () => {
+  assert.ok(MILESTONE_ID_RE.test("M001"));
+  assert.ok(MILESTONE_ID_RE.test("M042"));
+  assert.ok(MILESTONE_ID_RE.test("M999"));
+});
 
-    // Classic format matches
-    assertTrue(MILESTONE_DETECT_RE.test('M001'), 'detect matches M001');
-    assertTrue(MILESTONE_DETECT_RE.test('M042'), 'detect matches M042');
+test("MILESTONE_ID_RE accepts unique M001-abc123 format", () => {
+  assert.ok(MILESTONE_ID_RE.test("M001-abc123"));
+  assert.ok(MILESTONE_ID_RE.test("M042-z9a8b7"));
+});
 
-    // Unique format matches
-    assertTrue(MILESTONE_DETECT_RE.test('M001-abc123'), 'detect matches M001-abc123');
-    assertTrue(MILESTONE_DETECT_RE.test('M042-z9a8b7'), 'detect matches M042-z9a8b7');
+test("MILESTONE_ID_RE rejects non-milestone strings", () => {
+  assert.ok(!MILESTONE_ID_RE.test("S01"));
+  assert.ok(!MILESTONE_ID_RE.test("X001"));
+  assert.ok(!MILESTONE_ID_RE.test("notes"));
+  assert.ok(!MILESTONE_ID_RE.test(".DS_Store"));
+  assert.ok(!MILESTONE_ID_RE.test(""));
+  // Must be a bare id — not a prefix match.
+  assert.ok(!MILESTONE_ID_RE.test("M001-ABCDEF"), "uppercase suffix rejected");
+  assert.ok(!MILESTONE_ID_RE.test("M001 "), "trailing space rejected");
+});
 
-    // Rejects
-    assertTrue(!MILESTONE_DETECT_RE.test('S01'), 'detect rejects S01');
-    assertTrue(!MILESTONE_DETECT_RE.test('notes'), 'detect rejects notes');
-    assertTrue(!MILESTONE_DETECT_RE.test('.DS_Store'), 'detect rejects .DS_Store');
+// ─── SLICE_BRANCH_RE ──────────────────────────────────────────────────────
+
+test("SLICE_BRANCH_RE captures milestone + slice without worktree prefix", () => {
+  for (const { input, expectMid } of [
+    { input: "gsd/M001/S01", expectMid: "M001" },
+    { input: "gsd/M001-abc123/S01", expectMid: "M001-abc123" },
+  ]) {
+    const m = input.match(SLICE_BRANCH_RE);
+    assert.ok(m, `should match ${input}`);
+    assert.equal(m?.[1], undefined, "no worktree prefix");
+    assert.equal(m?.[2], expectMid);
+    assert.equal(m?.[3], "S01");
   }
+});
 
-  // (e) MILESTONE_CONTEXT_RE — used in index.ts (write-gate)
-  //     Pattern: /M\d+(?:-[a-z0-9]{6})?-CONTEXT\.md$/
-  {
-    console.log('  (e) MILESTONE_CONTEXT_RE');
-    const CONTEXT_RE = /M\d+(?:-[a-z0-9]{6})?-CONTEXT\.md$/;
-
-    // Classic format matches
-    assertTrue(CONTEXT_RE.test('M001-CONTEXT.md'), 'context matches M001-CONTEXT.md');
-    assertTrue(CONTEXT_RE.test('.gsd/milestones/M001/M001-CONTEXT.md'), 'context matches full path classic format');
-
-    // Unique format matches
-    assertTrue(CONTEXT_RE.test('M001-abc123-CONTEXT.md'), 'context matches M001-abc123-CONTEXT.md');
-    assertTrue(CONTEXT_RE.test('.gsd/milestones/M001-abc123/M001-abc123-CONTEXT.md'), 'context matches full path unique format');
-
-    // Rejects
-    assertTrue(!CONTEXT_RE.test('M001-ROADMAP.md'), 'context rejects M001-ROADMAP.md');
-    assertTrue(!CONTEXT_RE.test('M001-SUMMARY.md'), 'context rejects M001-SUMMARY.md');
-    assertTrue(!CONTEXT_RE.test('CONTEXT.md'), 'context rejects bare CONTEXT.md');
+test("SLICE_BRANCH_RE captures worktree prefix when present", () => {
+  for (const { input, expectMid } of [
+    { input: "gsd/worktree/M001/S01", expectMid: "M001" },
+    { input: "gsd/worktree/M001-abc123/S01", expectMid: "M001-abc123" },
+  ]) {
+    const m = input.match(SLICE_BRANCH_RE);
+    assert.ok(m, `should match ${input}`);
+    assert.equal(m?.[1], "worktree");
+    assert.equal(m?.[2], expectMid);
+    assert.equal(m?.[3], "S01");
   }
+});
 
-  // (f) Prompt dispatch regexes — used in index.ts (executeMatch, resumeMatch)
-  {
-    console.log('  (f) Prompt dispatch regexes');
-    const EXECUTE_RE = /Execute the next task:\s+(T\d+)\s+\("([^"]+)"\)\s+in slice\s+(S\d+)\s+of milestone\s+(M\d+(?:-[a-z0-9]{6})?)/i;
-    const RESUME_RE = /Resume interrupted work\.[\s\S]*?slice\s+(S\d+)\s+of milestone\s+(M\d+(?:-[a-z0-9]{6})?)/i;
-
-    // Execute — classic format
-    {
-      const prompt = 'Execute the next task: T01 ("Write tests") in slice S01 of milestone M001';
-      const m = prompt.match(EXECUTE_RE);
-      assertTrue(m !== null, 'execute matches classic format');
-      assertEq(m?.[1], 'T01', 'execute captures T01');
-      assertEq(m?.[3], 'S01', 'execute captures S01');
-      assertEq(m?.[4], 'M001', 'execute captures M001');
-    }
-
-    // Execute — unique format
-    {
-      const prompt = 'Execute the next task: T02 ("Build feature") in slice S03 of milestone M001-abc123';
-      const m = prompt.match(EXECUTE_RE);
-      assertTrue(m !== null, 'execute matches unique format');
-      assertEq(m?.[1], 'T02', 'execute captures T02 (unique format)');
-      assertEq(m?.[3], 'S03', 'execute captures S03 (unique format)');
-      assertEq(m?.[4], 'M001-abc123', 'execute captures M001-abc123');
-    }
-
-    // Resume — classic format
-    {
-      const prompt = 'Resume interrupted work.\nContinuing slice S02 of milestone M001';
-      const m = prompt.match(RESUME_RE);
-      assertTrue(m !== null, 'resume matches classic format');
-      assertEq(m?.[1], 'S02', 'resume captures S02');
-      assertEq(m?.[2], 'M001', 'resume captures M001');
-    }
-
-    // Resume — unique format
-    {
-      const prompt = 'Resume interrupted work.\nContinuing slice S01 of milestone M042-z9a8b7';
-      const m = prompt.match(RESUME_RE);
-      assertTrue(m !== null, 'resume matches unique format');
-      assertEq(m?.[1], 'S01', 'resume captures S01 (unique format)');
-      assertEq(m?.[2], 'M042-z9a8b7', 'resume captures M042-z9a8b7');
-    }
-  }
+test("SLICE_BRANCH_RE rejects malformed inputs", () => {
+  assert.ok(!SLICE_BRANCH_RE.test("gsd/S01"), "no milestone");
+  assert.ok(!SLICE_BRANCH_RE.test("main"), "non-gsd branch");
+  assert.ok(!SLICE_BRANCH_RE.test("gsd/M001"), "no slice");
+  assert.ok(!SLICE_BRANCH_RE.test("feature/M001/S01"), "wrong prefix");
+});
 
-  // (g) milestoneIdSort — mixed-format ordering
-  {
-    console.log('  (g) milestoneIdSort');
-    const mixed = ['M002-abc123', 'M001', 'M001-xyz789'];
-    const sorted = [...mixed].sort(milestoneIdSort);
-    assertEq(sorted, ['M001', 'M001-xyz789', 'M002-abc123'], 'sorts mixed IDs by sequence number');
+// ─── MILESTONE_CONTEXT_RE ────────────────────────────────────────────────
+
+test("MILESTONE_CONTEXT_RE matches legacy and unique CONTEXT.md names", () => {
+  assert.ok(MILESTONE_CONTEXT_RE.test("M001-CONTEXT.md"));
+  assert.ok(MILESTONE_CONTEXT_RE.test("M001-abc123-CONTEXT.md"));
+  assert.ok(
+    MILESTONE_CONTEXT_RE.test(".gsd/milestones/M001/M001-CONTEXT.md"),
+    "full path legacy format",
+  );
+  assert.ok(
+    MILESTONE_CONTEXT_RE.test(".gsd/milestones/M001-abc123/M001-abc123-CONTEXT.md"),
+    "full path unique format",
+  );
+});
 
-    // Stable within same seq — preserves insertion order
-    const sameSorted = ['M001-abc123', 'M001'].sort(milestoneIdSort);
-    assertEq(sameSorted[0], 'M001-abc123', 'same seq preserves order (first)');
-    assertEq(sameSorted[1], 'M001', 'same seq preserves order (second)');
+test("MILESTONE_CONTEXT_RE rejects non-CONTEXT artifact names", () => {
+  assert.ok(!MILESTONE_CONTEXT_RE.test("M001-ROADMAP.md"));
+  assert.ok(!MILESTONE_CONTEXT_RE.test("M001-SUMMARY.md"));
+  assert.ok(!MILESTONE_CONTEXT_RE.test("CONTEXT.md"), "bare name without milestone prefix");
+});
 
-    // Classic format only
-    const oldOnly = ['M003', 'M001', 'M002'];
-    assertEq([...oldOnly].sort(milestoneIdSort), ['M001', 'M002', 'M003'], 'sorts classic-format IDs');
+// ─── extractMilestoneSeq ──────────────────────────────────────────────────
 
-    // Unique format only
-    const newOnly = ['M003-abc123', 'M001-def456', 'M002-ghi789'];
-    assertEq([...newOnly].sort(milestoneIdSort), ['M001-def456', 'M002-ghi789', 'M003-abc123'], 'sorts unique-format IDs');
-  }
+test("extractMilestoneSeq returns numeric sequence for both formats", () => {
+  assert.equal(extractMilestoneSeq("M001"), 1);
+  assert.equal(extractMilestoneSeq("M042"), 42);
+  assert.equal(extractMilestoneSeq("M999"), 999);
+  assert.equal(extractMilestoneSeq("M001-abc123"), 1);
+  assert.equal(extractMilestoneSeq("M042-z9a8b7"), 42);
+  assert.equal(extractMilestoneSeq("M100-xyz789"), 100);
+});
 
-  // (h) extractMilestoneSeq — numeric extraction from both formats
-  {
-    console.log('  (h) extractMilestoneSeq');
+test("extractMilestoneSeq returns 0 (not NaN) for invalid inputs", () => {
+  assert.equal(extractMilestoneSeq(""), 0);
+  assert.equal(extractMilestoneSeq("notes"), 0);
+  assert.equal(extractMilestoneSeq("S01"), 0);
+  // Specific regression: the parseInt(slice(1)) implementation returned
+  // NaN on inputs like "M001-abc123" because parseInt stopped at the
+  // dash but then the rest of the logic treated the result as a number.
+  // Current impl returns a real number.
+  assert.ok(!Number.isNaN(extractMilestoneSeq("M001-abc123")));
+});
 
-    // Classic format
-    assertEq(extractMilestoneSeq('M001'), 1, 'M001 → 1');
-    assertEq(extractMilestoneSeq('M042'), 42, 'M042 → 42');
-    assertEq(extractMilestoneSeq('M999'), 999, 'M999 → 999');
+// ─── milestoneIdSort ──────────────────────────────────────────────────────
 
-    // Unique format — confirms dispatch-guard refactor correctness
-    assertEq(extractMilestoneSeq('M001-abc123'), 1, 'M001-abc123 → 1');
-    assertEq(extractMilestoneSeq('M042-z9a8b7'), 42, 'M042-z9a8b7 → 42');
-    assertEq(extractMilestoneSeq('M100-xyz789'), 100, 'M100-xyz789 → 100');
+test("milestoneIdSort orders by numeric sequence across both formats", () => {
+  const mixed = ["M002-abc123", "M001", "M001-xyz789"];
+  assert.deepEqual(
+    [...mixed].sort(milestoneIdSort),
+    ["M001", "M001-xyz789", "M002-abc123"],
+    "mixed formats sort by seq number",
+  );
 
-    // Invalid → 0 (not NaN — the old parseInt(slice(1)) bug)
-    assertEq(extractMilestoneSeq(''), 0, 'empty → 0');
-    assertEq(extractMilestoneSeq('notes'), 0, 'notes → 0');
-    assertEq(extractMilestoneSeq('S01'), 0, 'S01 → 0');
-    assertTrue(!Number.isNaN(extractMilestoneSeq('M001-abc123')), 'unique format does not return NaN');
-    assertTrue(!Number.isNaN(extractMilestoneSeq('M001-ABCDEF')), 'invalid format does not return NaN');
-  }
+  const legacy = ["M003", "M001", "M002"];
+  assert.deepEqual([...legacy].sort(milestoneIdSort), ["M001", "M002", "M003"]);
 
-  report();
-}
+  const unique = ["M003-abc123", "M001-def456", "M002-ghi789"];
+  assert.deepEqual(
+    [...unique].sort(milestoneIdSort),
+    ["M001-def456", "M002-ghi789", "M003-abc123"],
+  );
+});
 
-test('regex-hardening: all 12 sites accept both formats', async () => {
-  await main();
+test("milestoneIdSort preserves input order for same-sequence ids", () => {
+  // sort is stable per ECMAScript 2019+ when the comparator returns 0.
+  const sameSeq = ["M001-abc123", "M001"];
+  const sorted = [...sameSeq].sort(milestoneIdSort);
+  assert.equal(sorted[0], "M001-abc123");
+  assert.equal(sorted[1], "M001");
 });