gsd-pi 2.33.1 → 2.34.0-dev.0150ae9

package/src/resources/extensions/gsd/tests/worktree-sync-milestones.test.ts

@@ -1,26 +1,27 @@
 /**
  * worktree-sync-milestones.test.ts — Regression test for #1311.
  *
- * Verifies that syncGsdStateToWorktree copies missing milestones,
- * milestone files, and slice directories from the main repo's .gsd/
- * into the worktree's .gsd/.
+ * Verifies that syncProjectRootToWorktree copies milestone artifacts
+ * from the main repo's .gsd/ into the worktree's .gsd/ for the
+ * specified milestone, and deletes gsd.db so it rebuilds from fresh state.
  *
  * Covers:
- *   - Entirely missing milestone directory
- *   - Milestone exists but missing CONTEXT/ROADMAP files
- *   - Missing slices within an existing milestone
- *   - No-op when directories are identical (symlinked)
- *   - Root-level files (DECISIONS, REQUIREMENTS, etc.)
+ *   - Milestone directory synced from main to worktree
+ *   - Missing slices within a milestone are synced
+ *   - gsd.db deleted in worktree after sync
+ *   - No-op when paths are equal
+ *   - No-op when milestoneId is null
+ *   - Non-existent directories handled gracefully
  */
 
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync, symlinkSync, realpathSync } from 'node:fs';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
-import { syncGsdStateToWorktree } from '../auto-worktree.ts';
+import { syncProjectRootToWorktree } from '../auto-worktree-sync.ts';
 import { createTestContext } from './test-helpers.ts';
 
-const { assertEq, assertTrue, report } = createTestContext();
+const { assertTrue, report } = createTestContext();
 
 function createBase(name: string): string {
   const base = mkdtempSync(join(tmpdir(), `gsd-wt-sync-${name}-`));
@@ -34,156 +35,106 @@ function cleanup(base: string): void {
 
 async function main(): Promise<void> {
 
-  // ─── 1. Missing milestone directory is synced ─────────────────────────
-  console.log('\n=== 1. missing milestone directory is copied from main ===');
+  // ─── 1. Milestone directory synced from main to worktree ──────────────
+  console.log('\n=== 1. milestone directory synced from main to worktree ===');
   {
     const mainBase = createBase('main');
     const wtBase = createBase('wt');
 
     try {
-      // Main repo has M001 and M002
       const m001Dir = join(mainBase, '.gsd', 'milestones', 'M001');
       mkdirSync(m001Dir, { recursive: true });
-      writeFileSync(join(m001Dir, 'M001-CONTEXT.md'), '# M001\nDone.');
+      writeFileSync(join(m001Dir, 'M001-CONTEXT.md'), '# M001\nContext.');
       writeFileSync(join(m001Dir, 'M001-ROADMAP.md'), '# Roadmap');
 
-      const m002Dir = join(mainBase, '.gsd', 'milestones', 'M002');
-      mkdirSync(m002Dir, { recursive: true });
-      writeFileSync(join(m002Dir, 'M002-CONTEXT.md'), '# M002\nNew milestone.');
-      writeFileSync(join(m002Dir, 'M002-ROADMAP.md'), '# Roadmap');
+      // Worktree has no M001
+      assertTrue(!existsSync(join(wtBase, '.gsd', 'milestones', 'M001')), 'M001 missing before sync');
 
-      // Worktree only has M001
-      const wtM001Dir = join(wtBase, '.gsd', 'milestones', 'M001');
-      mkdirSync(wtM001Dir, { recursive: true });
-      writeFileSync(join(wtM001Dir, 'M001-CONTEXT.md'), '# M001\nDone.');
-
-      // M002 is missing from worktree
-      assertTrue(!existsSync(join(wtBase, '.gsd', 'milestones', 'M002')), 'M002 missing before sync');
+      syncProjectRootToWorktree(mainBase, wtBase, 'M001');
 
-      const result = syncGsdStateToWorktree(mainBase, wtBase);
-
-      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M002')), '#1311: M002 synced to worktree');
-      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M002', 'M002-CONTEXT.md')), 'M002 CONTEXT synced');
-      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M002', 'M002-ROADMAP.md')), 'M002 ROADMAP synced');
-      assertTrue(result.synced.length > 0, 'sync reported files');
+      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M001')), '#1311: M001 synced to worktree');
+      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'M001-CONTEXT.md')), 'M001 CONTEXT synced');
+      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md')), 'M001 ROADMAP synced');
     } finally {
       cleanup(mainBase);
       cleanup(wtBase);
     }
   }
 
-  // ─── 2. Missing files within existing milestone ───────────────────────
-  console.log('\n=== 2. missing files within existing milestone are synced ===');
+  // ─── 2. Missing slices synced ──────────────────────────────────────────
+  console.log('\n=== 2. missing slices within milestone are synced ===');
   {
     const mainBase = createBase('main');
     const wtBase = createBase('wt');
 
     try {
-      // Main repo M001 has CONTEXT, ROADMAP, RESEARCH
       const m001Dir = join(mainBase, '.gsd', 'milestones', 'M001');
-      mkdirSync(m001Dir, { recursive: true });
-      writeFileSync(join(m001Dir, 'M001-CONTEXT.md'), '# M001 Context');
-      writeFileSync(join(m001Dir, 'M001-ROADMAP.md'), '# M001 Roadmap');
-      writeFileSync(join(m001Dir, 'M001-RESEARCH.md'), '# M001 Research');
+      mkdirSync(join(m001Dir, 'slices', 'S01'), { recursive: true });
+      mkdirSync(join(m001Dir, 'slices', 'S02'), { recursive: true });
+      writeFileSync(join(m001Dir, 'M001-ROADMAP.md'), '# Roadmap');
+      writeFileSync(join(m001Dir, 'slices', 'S01', 'S01-PLAN.md'), '# S01 Plan');
+      writeFileSync(join(m001Dir, 'slices', 'S02', 'S02-PLAN.md'), '# S02 Plan');
 
-      // Worktree M001 only has CONTEXT (stale snapshot)
+      // Worktree only has S01
       const wtM001Dir = join(wtBase, '.gsd', 'milestones', 'M001');
-      mkdirSync(wtM001Dir, { recursive: true });
-      writeFileSync(join(wtM001Dir, 'M001-CONTEXT.md'), '# M001 Context');
-
-      const result = syncGsdStateToWorktree(mainBase, wtBase);
-
-      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md')), 'ROADMAP synced');
-      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'M001-RESEARCH.md')), 'RESEARCH synced');
-      // Existing file should NOT be overwritten
-      assertEq(
-        readFileSync(join(wtBase, '.gsd', 'milestones', 'M001', 'M001-CONTEXT.md'), 'utf-8'),
-        '# M001 Context',
-        'existing CONTEXT not overwritten',
-      );
+      mkdirSync(join(wtM001Dir, 'slices', 'S01'), { recursive: true });
+      writeFileSync(join(wtM001Dir, 'slices', 'S01', 'S01-PLAN.md'), '# S01 Plan');
+
+      syncProjectRootToWorktree(mainBase, wtBase, 'M001');
+
+      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'slices', 'S02')), '#1311: S02 synced');
+      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'S02-PLAN.md')), 'S02 PLAN synced');
     } finally {
       cleanup(mainBase);
       cleanup(wtBase);
     }
   }
 
-  // ─── 3. Missing slices directory synced ───────────────────────────────
-  console.log('\n=== 3. missing slices directory synced ===');
+  // ─── 3. gsd.db deleted in worktree after sync ─────────────────────────
+  console.log('\n=== 3. gsd.db deleted in worktree after sync ===');
   {
     const mainBase = createBase('main');
     const wtBase = createBase('wt');
 
     try {
-      // Main repo has M001 with slices S01–S03
       const m001Dir = join(mainBase, '.gsd', 'milestones', 'M001');
-      mkdirSync(join(m001Dir, 'slices', 'S01'), { recursive: true });
-      mkdirSync(join(m001Dir, 'slices', 'S02'), { recursive: true });
-      mkdirSync(join(m001Dir, 'slices', 'S03'), { recursive: true });
+      mkdirSync(m001Dir, { recursive: true });
       writeFileSync(join(m001Dir, 'M001-ROADMAP.md'), '# Roadmap');
-      writeFileSync(join(m001Dir, 'slices', 'S01', 'S01-PLAN.md'), '# S01 Plan');
-      writeFileSync(join(m001Dir, 'slices', 'S02', 'S02-PLAN.md'), '# S02 Plan');
-      writeFileSync(join(m001Dir, 'slices', 'S03', 'S03-PLAN.md'), '# S03 Plan');
 
-      // Worktree M001 has slices S01–S02 only (S03 missing)
-      const wtM001Dir = join(wtBase, '.gsd', 'milestones', 'M001');
-      mkdirSync(join(wtM001Dir, 'slices', 'S01'), { recursive: true });
-      mkdirSync(join(wtM001Dir, 'slices', 'S02'), { recursive: true });
-      writeFileSync(join(wtM001Dir, 'M001-ROADMAP.md'), '# Roadmap');
-      writeFileSync(join(wtM001Dir, 'slices', 'S01', 'S01-PLAN.md'), '# S01 Plan');
-      writeFileSync(join(wtM001Dir, 'slices', 'S02', 'S02-PLAN.md'), '# S02 Plan');
+      // Worktree has a stale gsd.db
+      writeFileSync(join(wtBase, '.gsd', 'gsd.db'), 'stale data');
+      assertTrue(existsSync(join(wtBase, '.gsd', 'gsd.db')), 'gsd.db exists before sync');
 
-      assertTrue(!existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'slices', 'S03')), 'S03 missing before sync');
+      syncProjectRootToWorktree(mainBase, wtBase, 'M001');
 
-      syncGsdStateToWorktree(mainBase, wtBase);
-
-      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'slices', 'S03')), '#1311: S03 synced');
-      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'slices', 'S03', 'S03-PLAN.md')), 'S03 PLAN synced');
+      assertTrue(!existsSync(join(wtBase, '.gsd', 'gsd.db')), '#853: gsd.db deleted after sync');
     } finally {
       cleanup(mainBase);
       cleanup(wtBase);
     }
   }
 
-  // ─── 4. No-op when both resolve to same directory (symlink) ───────────
-  console.log('\n=== 4. no-op when .gsd/ resolves to same path (symlinked) ===');
+  // ─── 4. No-op when paths are equal ────────────────────────────────────
+  console.log('\n=== 4. no-op when paths are equal ===');
   {
-    const sharedDir = createBase('shared');
-    const mainBase = mkdtempSync(join(tmpdir(), 'gsd-wt-sync-main-'));
-    const wtBase = mkdtempSync(join(tmpdir(), 'gsd-wt-sync-wt-'));
-
+    const base = createBase('same');
     try {
-      // Both main and worktree symlink to the same shared directory
-      writeFileSync(join(sharedDir, '.gsd', 'milestones', 'keep'), '');
-      symlinkSync(join(sharedDir, '.gsd'), join(mainBase, '.gsd'));
-      symlinkSync(join(sharedDir, '.gsd'), join(wtBase, '.gsd'));
-
-      const result = syncGsdStateToWorktree(mainBase, wtBase);
-      assertEq(result.synced.length, 0, 'no files synced when both point to same dir');
+      // Should not throw
+      syncProjectRootToWorktree(base, base, 'M001');
+      assertTrue(true, 'no crash when paths are equal');
     } finally {
-      cleanup(sharedDir);
-      rmSync(mainBase, { recursive: true, force: true });
-      rmSync(wtBase, { recursive: true, force: true });
+      cleanup(base);
     }
   }
 
-  // ─── 5. Root-level .gsd/ files synced ─────────────────────────────────
-  console.log('\n=== 5. root-level .gsd/ files synced ===');
+  // ─── 5. No-op when milestoneId is null ────────────────────────────────
+  console.log('\n=== 5. no-op when milestoneId is null ===');
   {
     const mainBase = createBase('main');
     const wtBase = createBase('wt');
-
     try {
-      writeFileSync(join(mainBase, '.gsd', 'DECISIONS.md'), '# Decisions');
-      writeFileSync(join(mainBase, '.gsd', 'REQUIREMENTS.md'), '# Requirements');
-      writeFileSync(join(mainBase, '.gsd', 'PROJECT.md'), '# Project');
-
-      // Worktree has none of these
-      const result = syncGsdStateToWorktree(mainBase, wtBase);
-
-      assertTrue(existsSync(join(wtBase, '.gsd', 'DECISIONS.md')), 'DECISIONS.md synced');
-      assertTrue(existsSync(join(wtBase, '.gsd', 'REQUIREMENTS.md')), 'REQUIREMENTS.md synced');
-      assertTrue(existsSync(join(wtBase, '.gsd', 'PROJECT.md')), 'PROJECT.md synced');
-      assertTrue(result.synced.length >= 3, 'at least 3 files synced');
+      syncProjectRootToWorktree(mainBase, wtBase, null);
+      assertTrue(true, 'no crash when milestoneId is null');
     } finally {
       cleanup(mainBase);
       cleanup(wtBase);
@@ -193,8 +144,8 @@ async function main(): Promise<void> {
   // ─── 6. Non-existent directories handled gracefully ───────────────────
   console.log('\n=== 6. non-existent directories → no-op ===');
   {
-    const result = syncGsdStateToWorktree('/tmp/does-not-exist-main', '/tmp/does-not-exist-wt');
-    assertEq(result.synced.length, 0, 'no crash on missing directories');
+    syncProjectRootToWorktree('/tmp/does-not-exist-main', '/tmp/does-not-exist-wt', 'M001');
+    assertTrue(true, 'no crash on missing directories');
   }
 
   report();

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

@@ -104,11 +104,15 @@ async function main(): Promise<void> {
     run("git checkout -b f-123-thing", repo);
     assertEq(getCurrentBranch(repo), "f-123-thing", "on feature branch");
 
+    const commitsBefore = run("git rev-list --count HEAD", repo);
     captureIntegrationBranch(repo, "M001");
     assertEq(readIntegrationBranch(repo, "M001"), "f-123-thing",
       "captureIntegrationBranch records the current branch");
 
-    // .gsd/ metadata is written to disk only (not committed) since commit_docs removal
+    // Metadata is stored in external state, not committed to git.
+    const commitsAfter = run("git rev-list --count HEAD", repo);
+    assertEq(commitsAfter, commitsBefore, "captureIntegrationBranch does not create a git commit");
+
     rmSync(repo, { recursive: true, force: true });
   }
 

package/src/resources/extensions/gsd/tests/write-gate.test.ts

@@ -1,31 +1,19 @@
 /**
- * Unit tests for the CONTEXT.md write-gate.
+ * Unit tests for the CONTEXT.md write-gate (D031 guard chain).
  *
  * Exercises shouldBlockContextWrite() — a pure function that implements:
  *   (a) toolName !== "write" → pass
- *   (b) milestoneId null AND no queue phase → pass (not in any flow)
+ *   (b) milestoneId null → pass (not in discussion)
  *   (c) path doesn't match /M\d+-CONTEXT\.md$/ → pass
- *   (d) depthVerified → pass (backward compat for discussion flows)
- *   (e) queuePhaseActive + per-milestone verified → pass
- *   (f) queuePhaseActive + not verified → block
- *   (g) else → block with actionable reason
- *
- * Also exercises per-milestone verification helpers:
- *   markDepthVerified(), isDepthVerifiedFor()
+ *   (d) depthVerified → pass
+ *   (e) else → block with actionable reason
  */
 
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import {
-  shouldBlockContextWrite,
-  markDepthVerified,
-  isDepthVerifiedFor,
-  isDepthVerified,
-} from '../index.ts';
+import { shouldBlockContextWrite } from '../index.ts';
 
-// ═══════════════════════════════════════════════════════════════════════════
-// Discussion flow tests (backward compatibility)
-// ═══════════════════════════════════════════════════════════════════════════
+// ─── Scenario 1: Blocks CONTEXT.md write during discussion without depth verification (absolute path) ──
 
 test('write-gate: blocks CONTEXT.md write during discussion without depth verification (absolute path)', () => {
   const result = shouldBlockContextWrite(
@@ -38,6 +26,8 @@ test('write-gate: blocks CONTEXT.md write during discussion without depth verifi
   assert.ok(result.reason, 'should provide a reason');
 });
 
+// ─── Scenario 2: Blocks CONTEXT.md write during discussion without depth verification (relative path) ──
+
 test('write-gate: blocks CONTEXT.md write during discussion without depth verification (relative path)', () => {
   const result = shouldBlockContextWrite(
     'write',
@@ -49,7 +39,9 @@ test('write-gate: blocks CONTEXT.md write during discussion without depth verifi
   assert.ok(result.reason, 'should provide a reason');
 });
 
-test('write-gate: allows CONTEXT.md write after depth verification (discussion flow)', () => {
+// ─── Scenario 3: Allows CONTEXT.md write after depth verification ──
+
+test('write-gate: allows CONTEXT.md write after depth verification', () => {
   const result = shouldBlockContextWrite(
     'write',
     '/Users/dev/project/.gsd/milestones/M001/M001-CONTEXT.md',
@@ -60,152 +52,71 @@ test('write-gate: allows CONTEXT.md write after depth verification (discussion f
   assert.strictEqual(result.reason, undefined, 'should have no reason');
 });
 
-test('write-gate: allows CONTEXT.md write outside any flow (milestoneId null, no queue)', () => {
+// ─── Scenario 4: Allows CONTEXT.md write outside discussion phase (milestoneId null) ──
+
+test('write-gate: allows CONTEXT.md write outside discussion phase', () => {
   const result = shouldBlockContextWrite(
     'write',
     '.gsd/milestones/M001/M001-CONTEXT.md',
     null,
     false,
-    false,
   );
-  assert.strictEqual(result.block, false, 'should not block outside any flow');
+  assert.strictEqual(result.block, false, 'should not block outside discussion phase');
 });
 
-test('write-gate: allows non-CONTEXT.md writes during discussion', () => {
-  const r1 = shouldBlockContextWrite('write', '.gsd/milestones/M001/M001-DISCUSSION.md', 'M001', false);
-  assert.strictEqual(r1.block, false, 'DISCUSSION.md should pass');
-
-  const r2 = shouldBlockContextWrite('write', '.gsd/milestones/M001/slices/S01/S01-PLAN.md', 'M001', false);
-  assert.strictEqual(r2.block, false, 'slice plan should pass');
-
-  const r3 = shouldBlockContextWrite('write', 'src/index.ts', 'M001', false);
-  assert.strictEqual(r3.block, false, 'regular code file should pass');
-});
+// ─── Scenario 5: Allows non-CONTEXT.md writes during discussion ──
 
-test('write-gate: regex does not match slice context files (S01-CONTEXT.md)', () => {
-  const result = shouldBlockContextWrite(
+test('write-gate: allows non-CONTEXT.md writes during discussion', () => {
+  // DISCUSSION.md
+  const r1 = shouldBlockContextWrite(
     'write',
-    '.gsd/milestones/M001/slices/S01/S01-CONTEXT.md',
+    '.gsd/milestones/M001/M001-DISCUSSION.md',
     'M001',
     false,
   );
-  assert.strictEqual(result.block, false, 'S01-CONTEXT.md should not be blocked');
-});
-
-test('write-gate: blocked reason contains actionable instructions', () => {
-  const result = shouldBlockContextWrite(
-    'write',
-    '.gsd/milestones/M999/M999-CONTEXT.md',
-    'M999',
-    false,
-  );
-  assert.strictEqual(result.block, true);
-  assert.ok(result.reason!.includes('depth_verification'), 'reason should mention depth_verification');
-  assert.ok(result.reason!.includes('ask_user_questions'), 'reason should mention ask_user_questions');
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Queue flow tests (NEW — enforces write-gate during /gsd queue)
-// ═══════════════════════════════════════════════════════════════════════════
-
-test('write-gate: blocks CONTEXT.md write during queue flow without verification', () => {
-  const result = shouldBlockContextWrite(
-    'write',
-    '.gsd/milestones/M010-3ym37m/M010-3ym37m-CONTEXT.md',
-    null,  // queue flows have no pendingAutoStart → milestoneId is null
-    false,
-    true,  // but queuePhaseActive is true
-  );
-  assert.strictEqual(result.block, true, 'should block during queue flow without verification');
-  assert.ok(result.reason!.includes('multi-milestone'), 'reason should mention multi-milestone');
-});
-
-test('write-gate: allows CONTEXT.md write during queue flow AFTER per-milestone verification', () => {
-  // Simulate: depth_verification_M010-3ym37m was answered
-  markDepthVerified('M010-3ym37m');
+  assert.strictEqual(r1.block, false, 'DISCUSSION.md should pass');
 
-  const result = shouldBlockContextWrite(
+  // Slice file
+  const r2 = shouldBlockContextWrite(
     'write',
-    '.gsd/milestones/M010-3ym37m/M010-3ym37m-CONTEXT.md',
-    null,
+    '.gsd/milestones/M001/slices/S01/S01-PLAN.md',
+    'M001',
     false,
-    true,
   );
-  assert.strictEqual(result.block, false, 'should allow after per-milestone verification');
-});
+  assert.strictEqual(r2.block, false, 'slice plan should pass');
 
-test('write-gate: blocks DIFFERENT milestone in queue flow when only one is verified', () => {
-  // M010-3ym37m was verified above, but M011-rfmd3q was NOT
-  const result = shouldBlockContextWrite(
+  // Regular code file
+  const r3 = shouldBlockContextWrite(
     'write',
-    '.gsd/milestones/M011-rfmd3q/M011-rfmd3q-CONTEXT.md',
-    null,
+    'src/index.ts',
+    'M001',
     false,
-    true,
   );
-  assert.strictEqual(result.block, true, 'should block unverified milestone even when another is verified');
+  assert.strictEqual(r3.block, false, 'regular code file should pass');
 });
 
-test('write-gate: wildcard verification unlocks all milestones in queue flow', () => {
-  markDepthVerified('*');
-
-  const r1 = shouldBlockContextWrite(
-    'write',
-    '.gsd/milestones/M099/M099-CONTEXT.md',
-    null,
-    false,
-    true,
-  );
-  assert.strictEqual(r1.block, false, 'wildcard should pass any milestone');
-});
+// ─── Scenario 6: Regex specificity — doesn't match S01-CONTEXT.md ──
 
-test('write-gate: allows non-CONTEXT.md writes during queue flow regardless', () => {
+test('write-gate: regex does not match slice context files (S01-CONTEXT.md)', () => {
   const result = shouldBlockContextWrite(
     'write',
-    '.gsd/QUEUE.md',
-    null,
+    '.gsd/milestones/M001/slices/S01/S01-CONTEXT.md',
+    'M001',
     false,
-    true,
   );
-  assert.strictEqual(result.block, false, 'QUEUE.md should pass during queue flow');
+  assert.strictEqual(result.block, false, 'S01-CONTEXT.md should not be blocked');
 });
 
-// ═══════════════════════════════════════════════════════════════════════════
-// Unique milestone ID format tests
-// ═══════════════════════════════════════════════════════════════════════════
-
-test('write-gate: matches unique milestone ID format (M010-3ym37m)', () => {
-  const result = shouldBlockContextWrite(
-    'write',
-    '.gsd/milestones/M010-3ym37m/M010-3ym37m-CONTEXT.md',
-    'M010-3ym37m',
-    false,
-  );
-  assert.strictEqual(result.block, true, 'should match unique milestone ID format');
-});
+// ─── Scenario 7: Error message contains actionable instruction ──
 
-test('write-gate: matches classic milestone ID format (M001)', () => {
+test('write-gate: blocked reason contains depth_verification keyword', () => {
   const result = shouldBlockContextWrite(
     'write',
-    '.gsd/milestones/M001/M001-CONTEXT.md',
-    'M001',
+    '.gsd/milestones/M999/M999-CONTEXT.md',
+    'M999',
     false,
   );
-  assert.strictEqual(result.block, true, 'should match classic milestone ID format');
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Per-milestone depth verification helpers
-// ═══════════════════════════════════════════════════════════════════════════
-
-test('isDepthVerifiedFor: returns false for unknown milestone', () => {
-  assert.strictEqual(isDepthVerifiedFor('M999-xxxxxx'), true,
-    'returns true because wildcard * was set in earlier test');
-  // Note: test isolation would require clearing state, but these tests
-  // exercise the module as a singleton (matching production behavior)
-});
-
-test('isDepthVerified: returns true when any milestone verified', () => {
-  // At this point M010-3ym37m and * are verified from earlier tests
-  assert.strictEqual(isDepthVerified(), true);
+  assert.strictEqual(result.block, true);
+  assert.ok(result.reason!.includes('depth_verification'), 'reason should mention depth_verification question id');
+  assert.ok(result.reason!.includes('ask_user_questions'), 'reason should mention ask_user_questions tool');
 });