lsd-pi 1.0.0 → 1.1.0

package/src/resources/extensions/gsd/tests/quality-gates.test.ts

@@ -1,347 +0,0 @@
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { extractSection } from "../files.ts";
-import { createTestContext } from "./test-helpers.ts";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const templatesDir = join(__dirname, "..", "templates");
-const promptsDir = join(__dirname, "..", "prompts");
-
-const { assertTrue, report } = createTestContext();
-
-function loadTemplate(name: string): string {
-  return readFileSync(join(templatesDir, `${name}.md`), "utf-8");
-}
-
-function loadPrompt(name: string): string {
-  return readFileSync(join(promptsDir, `${name}.md`), "utf-8");
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Level 1: Templates contain quality gate headings
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log("\n=== Level 1: Templates contain quality gate headings ===");
-{
-  const plan = loadTemplate("plan");
-  assertTrue(plan.includes("## Threat Surface"), "plan.md contains ## Threat Surface");
-  assertTrue(plan.includes("## Requirement Impact"), "plan.md contains ## Requirement Impact");
-
-  const taskPlan = loadTemplate("task-plan");
-  assertTrue(taskPlan.includes("## Failure Modes"), "task-plan.md contains ## Failure Modes");
-  assertTrue(taskPlan.includes("## Load Profile"), "task-plan.md contains ## Load Profile");
-  assertTrue(taskPlan.includes("## Negative Tests"), "task-plan.md contains ## Negative Tests");
-
-  const sliceSummary = loadTemplate("slice-summary");
-  assertTrue(sliceSummary.includes("## Operational Readiness"), "slice-summary.md contains ## Operational Readiness");
-
-  const roadmap = loadTemplate("roadmap");
-  assertTrue(roadmap.includes("## Horizontal Checklist"), "roadmap.md contains ## Horizontal Checklist");
-
-  const milestoneSummary = loadTemplate("milestone-summary");
-  assertTrue(milestoneSummary.includes("## Decision Re-evaluation"), "milestone-summary.md contains ## Decision Re-evaluation");
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Level 2: Prompts reference quality gates
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log("\n=== Level 2: Prompts reference quality gates ===");
-{
-  const planSlice = loadPrompt("plan-slice");
-  assertTrue(planSlice.includes("Threat Surface"), "plan-slice.md mentions Threat Surface");
-  assertTrue(planSlice.includes("Requirement Impact"), "plan-slice.md mentions Requirement Impact");
-  assertTrue(planSlice.toLowerCase().includes("quality gate"), "plan-slice.md mentions quality gate");
-
-  const guidedPlanSlice = loadPrompt("guided-plan-slice");
-  assertTrue(
-    guidedPlanSlice.includes("Threat Surface") || guidedPlanSlice.includes("Q3"),
-    "guided-plan-slice.md mentions Threat Surface or Q3"
-  );
-
-  const executeTask = loadPrompt("execute-task");
-  assertTrue(executeTask.includes("Failure Modes"), "execute-task.md mentions Failure Modes");
-  assertTrue(executeTask.includes("Load Profile"), "execute-task.md mentions Load Profile");
-  assertTrue(executeTask.includes("Negative Tests"), "execute-task.md mentions Negative Tests");
-
-  const guidedExecuteTask = loadPrompt("guided-execute-task");
-  assertTrue(
-    guidedExecuteTask.includes("Failure Modes") || guidedExecuteTask.includes("Q5"),
-    "guided-execute-task.md mentions Failure Modes or Q5"
-  );
-
-  const completeSlice = loadPrompt("complete-slice");
-  assertTrue(completeSlice.includes("Operational Readiness"), "complete-slice.md mentions Operational Readiness");
-
-  const guidedCompleteSlice = loadPrompt("guided-complete-slice");
-  assertTrue(
-    guidedCompleteSlice.includes("Operational Readiness") || guidedCompleteSlice.includes("Q8"),
-    "guided-complete-slice.md mentions Operational Readiness or Q8"
-  );
-
-  const completeMilestone = loadPrompt("complete-milestone");
-  assertTrue(completeMilestone.includes("Horizontal Checklist"), "complete-milestone.md mentions Horizontal Checklist");
-  assertTrue(completeMilestone.includes("Decision Re-evaluation"), "complete-milestone.md mentions Decision Re-evaluation");
-
-  const planMilestone = loadPrompt("plan-milestone");
-  assertTrue(planMilestone.toLowerCase().includes("horizontal checklist"), "plan-milestone.md mentions horizontal checklist");
-
-  const guidedPlanMilestone = loadPrompt("guided-plan-milestone");
-  assertTrue(guidedPlanMilestone.includes("Horizontal Checklist"), "guided-plan-milestone.md mentions Horizontal Checklist");
-
-  const reassess = loadPrompt("reassess-roadmap");
-  assertTrue(reassess.includes("Threat Surface"), "reassess-roadmap.md mentions Threat Surface");
-  assertTrue(reassess.includes("Operational Readiness"), "reassess-roadmap.md mentions Operational Readiness");
-  assertTrue(reassess.includes("Horizontal Checklist"), "reassess-roadmap.md mentions Horizontal Checklist");
-
-  const replan = loadPrompt("replan-slice");
-  assertTrue(replan.includes("Threat Surface"), "replan-slice.md mentions Threat Surface");
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Level 3: Parser backward compatibility — extractSection handles new headings
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log("\n=== Level 3: extractSection backward compatibility ===");
-{
-  // Old-style slice plan (no quality gate sections)
-  const oldPlan = `# S01: Auth Flow
-
-**Goal:** Build login
-**Demo:** User can log in
-
-## Must-Haves
-
-- Login form works
-- Session persists
-
-## Proof Level
-
-- This slice proves: integration
-
-## Tasks
-
-- [ ] **T01: Build login** \`est:1h\`
-`;
-
-  // New-style slice plan (with quality gate sections)
-  const newPlan = `# S01: Auth Flow
-
-**Goal:** Build login
-**Demo:** User can log in
-
-## Must-Haves
-
-- Login form works
-- Session persists
-
-## Threat Surface
-
-- **Abuse**: Credential stuffing, brute force login attempts
-- **Data exposure**: Session tokens in cookies, password in request body
-- **Input trust**: Username/password from form input reaching DB query
-
-## Requirement Impact
-
-- **Requirements touched**: R001, R003
-- **Re-verify**: Login flow, session management
-- **Decisions revisited**: D002
-
-## Proof Level
-
-- This slice proves: integration
-
-## Tasks
-
-- [ ] **T01: Build login** \`est:1h\`
-`;
-
-  // Old plan: quality gate sections return null (not found)
-  assertTrue(
-    extractSection(oldPlan, "Threat Surface") === null,
-    "extractSection returns null for Threat Surface on old plan"
-  );
-  assertTrue(
-    extractSection(oldPlan, "Requirement Impact") === null,
-    "extractSection returns null for Requirement Impact on old plan"
-  );
-
-  // Old plan: core sections still parse correctly
-  const oldMustHaves = extractSection(oldPlan, "Must-Haves");
-  assertTrue(
-    oldMustHaves !== null && oldMustHaves.includes("Login form works"),
-    "extractSection still parses Must-Haves on old plan"
-  );
-
-  // New plan: quality gate sections are extracted
-  const threatSurface = extractSection(newPlan, "Threat Surface");
-  assertTrue(
-    threatSurface !== null && threatSurface.includes("Credential stuffing"),
-    "extractSection extracts Threat Surface content from new plan"
-  );
-
-  const reqImpact = extractSection(newPlan, "Requirement Impact");
-  assertTrue(
-    reqImpact !== null && reqImpact.includes("R001"),
-    "extractSection extracts Requirement Impact content from new plan"
-  );
-
-  // New plan: core sections still parse correctly
-  const newMustHaves = extractSection(newPlan, "Must-Haves");
-  assertTrue(
-    newMustHaves !== null && newMustHaves.includes("Login form works"),
-    "extractSection still parses Must-Haves on new plan"
-  );
-
-  // Task plan: Failure Modes
-  const oldTaskPlan = `# T01: Build Login
-
-## Description
-
-Build the login endpoint.
-
-## Steps
-
-1. Create route
-`;
-
-  const newTaskPlan = `# T01: Build Login
-
-## Description
-
-Build the login endpoint.
-
-## Failure Modes
-
-| Dependency | On error | On timeout | On malformed response |
-|------------|----------|-----------|----------------------|
-| Auth DB | Return 500 | 3s timeout, retry once | Reject, log warning |
-
-## Steps
-
-1. Create route
-`;
-
-  assertTrue(
-    extractSection(oldTaskPlan, "Failure Modes") === null,
-    "extractSection returns null for Failure Modes on old task plan"
-  );
-
-  const failureModes = extractSection(newTaskPlan, "Failure Modes");
-  assertTrue(
-    failureModes !== null && failureModes.includes("Auth DB"),
-    "extractSection extracts Failure Modes content from new task plan"
-  );
-
-  // Slice summary: Operational Readiness
-  const oldSummary = `# S01: Auth Flow
-
-**Built login with session management**
-
-## Verification
-
-All tests pass.
-
-## Deviations
-
-None.
-`;
-
-  const newSummary = `# S01: Auth Flow
-
-**Built login with session management**
-
-## Verification
-
-All tests pass.
-
-## Operational Readiness
-
-- **Health signal**: /health endpoint returns 200 with session count
-- **Failure signal**: Auth error rate > 5% triggers alert
-- **Recovery**: Stateless — restart clears nothing
-- **Monitoring gaps**: None
-
-## Deviations
-
-None.
-`;
-
-  assertTrue(
-    extractSection(oldSummary, "Operational Readiness") === null,
-    "extractSection returns null for Operational Readiness on old summary"
-  );
-
-  const opReadiness = extractSection(newSummary, "Operational Readiness");
-  assertTrue(
-    opReadiness !== null && opReadiness.includes("/health endpoint"),
-    "extractSection extracts Operational Readiness content from new summary"
-  );
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Level 4: Template section ordering is correct
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log("\n=== Level 4: Template section ordering ===");
-{
-  const plan = loadTemplate("plan");
-  const mustHavesIdx = plan.indexOf("## Must-Haves");
-  const threatIdx = plan.indexOf("## Threat Surface");
-  const proofIdx = plan.indexOf("## Proof Level");
-  assertTrue(
-    mustHavesIdx < threatIdx && threatIdx < proofIdx,
-    "plan.md: Threat Surface is between Must-Haves and Proof Level"
-  );
-
-  const reqImpactIdx = plan.indexOf("## Requirement Impact");
-  assertTrue(
-    threatIdx < reqImpactIdx && reqImpactIdx < proofIdx,
-    "plan.md: Requirement Impact is between Threat Surface and Proof Level"
-  );
-
-  const taskPlan = loadTemplate("task-plan");
-  const descIdx = taskPlan.indexOf("## Description");
-  const failIdx = taskPlan.indexOf("## Failure Modes");
-  const stepsIdx = taskPlan.indexOf("## Steps");
-  assertTrue(
-    descIdx < failIdx && failIdx < stepsIdx,
-    "task-plan.md: Failure Modes is between Description and Steps"
-  );
-
-  const loadIdx = taskPlan.indexOf("## Load Profile");
-  const negIdx = taskPlan.indexOf("## Negative Tests");
-  assertTrue(
-    failIdx < loadIdx && loadIdx < negIdx && negIdx < stepsIdx,
-    "task-plan.md: Failure Modes < Load Profile < Negative Tests < Steps"
-  );
-
-  const sliceSummary = loadTemplate("slice-summary");
-  const reqInvalidIdx = sliceSummary.indexOf("## Requirements Invalidated");
-  const opIdx = sliceSummary.indexOf("## Operational Readiness");
-  const devIdx = sliceSummary.indexOf("## Deviations");
-  assertTrue(
-    reqInvalidIdx < opIdx && opIdx < devIdx,
-    "slice-summary.md: Operational Readiness is between Requirements Invalidated and Deviations"
-  );
-
-  const roadmap = loadTemplate("roadmap");
-  const horizIdx = roadmap.indexOf("## Horizontal Checklist");
-  const boundaryIdx = roadmap.indexOf("## Boundary Map");
-  assertTrue(
-    horizIdx > 0 && horizIdx < boundaryIdx,
-    "roadmap.md: Horizontal Checklist is before Boundary Map"
-  );
-
-  const milestoneSummary = loadTemplate("milestone-summary");
-  const reqChangesIdx = milestoneSummary.indexOf("## Requirement Changes");
-  const decRevalIdx = milestoneSummary.indexOf("## Decision Re-evaluation");
-  const fwdIntelIdx = milestoneSummary.indexOf("## Forward Intelligence");
-  assertTrue(
-    reqChangesIdx < decRevalIdx && decRevalIdx < fwdIntelIdx,
-    "milestone-summary.md: Decision Re-evaluation is between Requirement Changes and Forward Intelligence"
-  );
-}
-
-report();

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

@@ -1,100 +0,0 @@
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import { deriveState } from "../state.js";
-import { buildExistingMilestonesContext } from "../guided-flow.js";
-
-describe('queue-draft-detection', () => {
-  test('draft and context milestone detection', async () => {
-    const tmpBase = mkdtempSync(join(tmpdir(), "gsd-queue-draft-test-"));
-    const gsd = join(tmpBase, ".gsd");
-
-    try {
-      // M001: has only CONTEXT-DRAFT.md (draft milestone)
-      mkdirSync(join(gsd, "milestones", "M001"), { recursive: true });
-      writeFileSync(
-        join(gsd, "milestones", "M001", "M001-CONTEXT-DRAFT.md"),
-        "# M001: Draft Milestone\n\nSeed material from prior discussion.\n",
-      );
-
-      // M002: has full CONTEXT.md (ready milestone)
-      mkdirSync(join(gsd, "milestones", "M002"), { recursive: true });
-      writeFileSync(
-        join(gsd, "milestones", "M002", "M002-CONTEXT.md"),
-        "# M002: Ready Milestone\n\nFull context from deep discussion.\n",
-      );
-
-      // M003: has both CONTEXT.md and CONTEXT-DRAFT.md (CONTEXT wins)
-      mkdirSync(join(gsd, "milestones", "M003"), { recursive: true });
-      writeFileSync(
-        join(gsd, "milestones", "M003", "M003-CONTEXT.md"),
-        "# M003: Full Context\n\nThis is the real context.\n",
-      );
-      writeFileSync(
-        join(gsd, "milestones", "M003", "M003-CONTEXT-DRAFT.md"),
-        "# M003: Draft\n\nThis should be ignored.\n",
-      );
-
-      // M004: has neither (empty milestone dir)
-      mkdirSync(join(gsd, "milestones", "M004"), { recursive: true });
-
-      // Build context
-      const state = await deriveState(tmpBase);
-      const milestoneIds = ["M001", "M002", "M003", "M004"];
-      const context = await buildExistingMilestonesContext(tmpBase, milestoneIds, state);
-
-      // draft-only milestone includes "Draft context available"
-      assert.ok(
-        context.includes("Draft context available"),
-        "M001 (draft-only) should include 'Draft context available' label",
-      );
-      assert.ok(
-        context.includes("Seed material from prior discussion"),
-        "M001 draft content should be included in context output",
-      );
-
-      // full-context milestone uses "Context:" label
-      assert.ok(
-        context.includes("**Context:**"),
-        "M002 (full context) should use 'Context:' label",
-      );
-      assert.ok(
-        context.includes("Full context from deep discussion"),
-        "M002 context content should be included",
-      );
-
-      // both files: CONTEXT.md wins, no draft label
-      const m003Idx = context.indexOf("M003:");
-      const m003Section = context.slice(m003Idx, m003Idx + 500);
-      assert.ok(
-        m003Section.includes("**Context:**"),
-        "M003 (both files) should use 'Context:' label (CONTEXT.md wins)",
-      );
-      assert.ok(
-        !m003Section.includes("Draft context available"),
-        "M003 (both files) should NOT show draft label — CONTEXT.md takes precedence",
-      );
-      assert.ok(
-        m003Section.includes("This is the real context"),
-        "M003 should show CONTEXT.md content, not draft content",
-      );
-
-      // neither file: no context section
-      const m004Idx = context.indexOf("M004:");
-      const m004Section = context.slice(m004Idx, m004Idx + 500);
-      assert.ok(
-        !m004Section.includes("**Context:**"),
-        "M004 (neither file) should not have Context: label",
-      );
-      assert.ok(
-        !m004Section.includes("Draft context available"),
-        "M004 (neither file) should not have Draft label",
-      );
-    } finally {
-      rmSync(tmpBase, { recursive: true, force: true });
-    }
-  });
-});

package/src/resources/extensions/gsd/tests/queue-execution-guard.test.ts

@@ -1,157 +0,0 @@
-/**
- * Unit tests for the queue-mode execution guard (#2545).
- *
- * When queue phase is active, the agent should only create milestones —
- * not execute work. This guard blocks write/edit/bash tool calls that
- * target source code (non-.gsd/ paths) during queue mode.
- *
- * Exercises shouldBlockQueueExecution() — a pure function that checks:
- *   (a) queuePhaseActive false → pass (not in queue mode)
- *   (b) toolName is read-only (read, grep, find, ls) → pass
- *   (c) toolName is ask_user_questions → pass (discussion tool)
- *   (d) write/edit to .gsd/ path → pass (planning artifacts)
- *   (e) write/edit to source path → block
- *   (f) bash command → block (could execute work)
- *   (g) registered GSD tools (gsd_milestone_generate_id, gsd_summary_save) → pass
- */
-
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { shouldBlockQueueExecution } from '../bootstrap/write-gate.ts';
-
-// ─── Scenario 1: Not in queue mode — all tools pass ──
-
-test('queue-guard: allows all tools when queue phase is not active', () => {
-  const r1 = shouldBlockQueueExecution('write', '/src/index.ts', false);
-  assert.strictEqual(r1.block, false, 'write should pass outside queue mode');
-
-  const r2 = shouldBlockQueueExecution('bash', 'npm test', false);
-  assert.strictEqual(r2.block, false, 'bash should pass outside queue mode');
-
-  const r3 = shouldBlockQueueExecution('edit', '/src/index.ts', false);
-  assert.strictEqual(r3.block, false, 'edit should pass outside queue mode');
-});
-
-// ─── Scenario 2: Read-only tools always pass in queue mode ──
-
-test('queue-guard: allows read-only tools during queue mode', () => {
-  for (const tool of ['read', 'grep', 'find', 'ls', 'glob']) {
-    const result = shouldBlockQueueExecution(tool, '/src/index.ts', true);
-    assert.strictEqual(result.block, false, `${tool} should pass in queue mode`);
-  }
-});
-
-// ─── Scenario 3: Discussion/planning tools pass in queue mode ──
-
-test('queue-guard: allows discussion and planning tools during queue mode', () => {
-  const r1 = shouldBlockQueueExecution('ask_user_questions', '', true);
-  assert.strictEqual(r1.block, false, 'ask_user_questions should pass');
-
-  const r2 = shouldBlockQueueExecution('gsd_milestone_generate_id', '', true);
-  assert.strictEqual(r2.block, false, 'gsd_milestone_generate_id should pass');
-
-  const r3 = shouldBlockQueueExecution('gsd_summary_save', '', true);
-  assert.strictEqual(r3.block, false, 'gsd_summary_save should pass');
-});
-
-// ─── Scenario 4: Write to .gsd/ paths passes (planning artifacts) ──
-
-test('queue-guard: allows writes to .gsd/ paths during queue mode', () => {
-  const r1 = shouldBlockQueueExecution('write', '.gsd/milestones/M001/M001-CONTEXT.md', true);
-  assert.strictEqual(r1.block, false, 'write to .gsd/ should pass');
-
-  const r2 = shouldBlockQueueExecution('write', '/project/.gsd/PROJECT.md', true);
-  assert.strictEqual(r2.block, false, 'write to .gsd/PROJECT.md should pass');
-
-  const r3 = shouldBlockQueueExecution('edit', '.gsd/QUEUE.md', true);
-  assert.strictEqual(r3.block, false, 'edit to .gsd/QUEUE.md should pass');
-
-  const r4 = shouldBlockQueueExecution('write', '.gsd/REQUIREMENTS.md', true);
-  assert.strictEqual(r4.block, false, 'write to .gsd/REQUIREMENTS.md should pass');
-
-  const r5 = shouldBlockQueueExecution('write', '.gsd/DECISIONS.md', true);
-  assert.strictEqual(r5.block, false, 'write to .gsd/DECISIONS.md should pass');
-});
-
-// ─── Scenario 5: Write/edit to source code paths blocked ──
-
-test('queue-guard: blocks writes to source code during queue mode', () => {
-  const r1 = shouldBlockQueueExecution('write', 'src/index.ts', true);
-  assert.strictEqual(r1.block, true, 'write to src/ should be blocked');
-  assert.ok(r1.reason, 'should provide a reason');
-  assert.ok(r1.reason!.includes('queue'), 'reason should mention queue');
-
-  const r2 = shouldBlockQueueExecution('write', '/project/src/components/App.tsx', true);
-  assert.strictEqual(r2.block, true, 'write to component file should be blocked');
-
-  const r3 = shouldBlockQueueExecution('edit', 'package.json', true);
-  assert.strictEqual(r3.block, true, 'edit to package.json should be blocked');
-
-  const r4 = shouldBlockQueueExecution('edit', '/project/lib/utils.ts', true);
-  assert.strictEqual(r4.block, true, 'edit to lib/ should be blocked');
-});
-
-// ─── Scenario 6: Bash commands blocked during queue mode ──
-
-test('queue-guard: blocks bash commands during queue mode', () => {
-  const r1 = shouldBlockQueueExecution('bash', 'npm install some-package', true);
-  assert.strictEqual(r1.block, true, 'npm install should be blocked');
-  assert.ok(r1.reason, 'should provide a reason');
-
-  const r2 = shouldBlockQueueExecution('bash', 'node src/index.ts', true);
-  assert.strictEqual(r2.block, true, 'running node should be blocked');
-});
-
-// ─── Scenario 7: Bash read-only commands pass during queue mode ──
-
-test('queue-guard: allows read-only bash commands during queue mode', () => {
-  const r1 = shouldBlockQueueExecution('bash', 'cat src/index.ts', true);
-  assert.strictEqual(r1.block, false, 'cat should pass');
-
-  const r2 = shouldBlockQueueExecution('bash', 'ls -la src/', true);
-  assert.strictEqual(r2.block, false, 'ls should pass');
-
-  const r3 = shouldBlockQueueExecution('bash', 'git log --oneline -10', true);
-  assert.strictEqual(r3.block, false, 'git log should pass');
-
-  const r4 = shouldBlockQueueExecution('bash', 'find . -name "*.ts"', true);
-  assert.strictEqual(r4.block, false, 'find should pass');
-
-  const r5 = shouldBlockQueueExecution('bash', 'grep -rn "TODO" src/', true);
-  assert.strictEqual(r5.block, false, 'grep should pass');
-
-  const r6 = shouldBlockQueueExecution('bash', 'head -20 src/index.ts', true);
-  assert.strictEqual(r6.block, false, 'head should pass');
-
-  const r7 = shouldBlockQueueExecution('bash', 'wc -l src/index.ts', true);
-  assert.strictEqual(r7.block, false, 'wc should pass');
-
-  const r8 = shouldBlockQueueExecution('bash', 'git diff HEAD~1', true);
-  assert.strictEqual(r8.block, false, 'git diff should pass');
-
-  const r9 = shouldBlockQueueExecution('bash', 'gh issue view 42', true);
-  assert.strictEqual(r9.block, false, 'gh issue view should pass');
-});
-
-// ─── Scenario 8: mkdir for .gsd/ milestone directories passes ──
-
-test('queue-guard: allows mkdir for .gsd/ milestone directories', () => {
-  const r1 = shouldBlockQueueExecution('bash', 'mkdir -p .gsd/milestones/M010/slices', true);
-  assert.strictEqual(r1.block, false, 'mkdir -p .gsd/ should pass');
-});
-
-// ─── Scenario 9: Web search and library tools pass ──
-
-test('queue-guard: allows web search and library tools during queue mode', () => {
-  const r1 = shouldBlockQueueExecution('search-the-web', '', true);
-  assert.strictEqual(r1.block, false, 'search-the-web should pass');
-
-  const r2 = shouldBlockQueueExecution('resolve_library', '', true);
-  assert.strictEqual(r2.block, false, 'resolve_library should pass');
-
-  const r3 = shouldBlockQueueExecution('get_library_docs', '', true);
-  assert.strictEqual(r3.block, false, 'get_library_docs should pass');
-
-  const r4 = shouldBlockQueueExecution('fetch_page', '', true);
-  assert.strictEqual(r4.block, false, 'fetch_page should pass');
-});