@1aboveio/skills 1.0.8 → 1.0.9

package/skills/engineering/ensure-coverage/scripts/ci-audit.test.mjs

@@ -1,86 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { auditCorpus, buildAdoptionPlan, classifySmoke, renderAdoptionIssue } from './ci-audit.mjs'
-
-const file = (name, text) => ({ name, text })
-
-test('blocking golden-path smoke passes', () => {
-  const report = auditCorpus([file('.github/workflows/ci.yml', `
-jobs:
-  smoke:
-    steps:
-      - run: node smoke.mjs verdict --manifest smoke.manifest.json --target local --results smoke-results.json
-`)])
-  assert.equal(report.ok, true)
-  assert.equal(report.smoke.status, 'present')
-})
-
-test('the generated golden-path workflow counts as the smoke gate', () => {
-  const report = auditCorpus([file('.github/workflows/golden-paths.yml', `
-jobs:
-  golden-paths:
-    steps:
-      - run: node scripts/golden-paths/golden-path.mjs verdict --profile "$GOLDEN_PATH_PROFILE" --target "$BASE_URL"
-`)])
-  assert.equal(report.ok, true)
-  assert.equal(report.smoke.status, 'present')
-})
-
-test('the former coverage gates are ignored', () => {
-  const report = auditCorpus([file('.github/workflows/ci.yml', `
-  - run: node coverage-ledger.mjs validate
-  - run: node presentation-sweep.mjs
-  - run: pnpm playwright test
-  - run: node lint-tests.mjs --rules mock-internal-seam
-  - run: node check-quarantine-expiry.mjs
-`)])
-  assert.equal(report.ok, false)
-  assert.equal(report.smoke.status, 'absent')
-  assert.deepEqual(Object.keys(report), ['smoke', 'ok', 'scanned'])
-})
-
-test('a weakened smoke job is warn-only and fails by default', () => {
-  const report = auditCorpus([file('cloudbuild.yaml', `
-  - id: smoke
-    allowFailure: true
-    args: ['-c', 'node smoke.mjs verdict --manifest smoke.manifest.json --results smoke-results.json']
-`)])
-  assert.equal(report.ok, false)
-  assert.equal(report.smoke.status, 'warn-only')
-})
-
-test('--allow-warn accepts warn-only smoke when explicitly requested', () => {
-  const report = auditCorpus([file('ci.yml', 'run: node smoke.mjs verdict --results out.json || true')], { allowWarn: true })
-  assert.equal(report.ok, true)
-})
-
-test('comments do not count as smoke wiring or weakening', () => {
-  const absent = auditCorpus([file('ci.yml', '# node smoke.mjs verdict --results out.json')])
-  assert.equal(absent.smoke.status, 'absent')
-
-  const corpus = [{ name: 'ci.yml', lines: [
-    '# never add continue-on-error: true',
-    'run: node smoke.mjs verdict --results out.json',
-  ] }]
-  assert.equal(classifySmoke(corpus).status, 'present')
-})
-
-test('weakening far from smoke does not bleed into its status', () => {
-  const lines = ['continue-on-error: true', ...Array.from({ length: 20 }, (_, index) => `# filler ${index}`), 'run: smoke-gate']
-  assert.equal(classifySmoke([{ name: 'ci.yml', lines }]).status, 'present')
-})
-
-test('adoption output requests only golden-path smoke', () => {
-  const report = auditCorpus([file('.github/workflows/ci.yml', 'run: node coverage-ledger.mjs validate')])
-  const plan = buildAdoptionPlan(report)
-  const body = renderAdoptionIssue(plan)
-  assert.equal(plan.needed, true)
-  assert.match(body, /Wire golden-path smoke into CI/)
-  assert.doesNotMatch(body, /coverage-ledger|presentation sweep|quarantine expiry|all-gates|static-gates/)
-})
-
-test('adoption is unnecessary when smoke is blocking', () => {
-  const report = auditCorpus([file('ci.yml', 'run: smoke-gate')])
-  assert.equal(buildAdoptionPlan(report).needed, false)
-})

package/skills/engineering/ensure-coverage/scripts/coverage-ledger.test.mjs

@@ -1,447 +0,0 @@
-// Tests for the Coverage Ledger reference tool, focused on the Presentation axis
-// spine (issue #195). Run: `node --test` from scripts/, or `npm test`.
-
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-
-import {
-  depthStatus, baselineFor, build, PRESENTATION_VIEWPORT_FLOOR,
-  isPresentationLevel, presentationEscalation, applyCellExclusions, computeMetrics,
-  satisfies, PRESENTATION_LEVELS, PRESENTATION_ROUTE_FLOOR,
-} from './coverage-ledger.mjs'
-
-// `presentation:fidelity` is doctrine in references/presentation/axis.md. Doctrine
-// that names a graded token the grader has never heard of is the exact failure this
-// skill family keeps re-learning: the prose reads enforced, the machinery ignores it.
-test('presentation:fidelity is a registered, opt-in, exact-match level', () => {
-  assert.ok(PRESENTATION_LEVELS.has('presentation:fidelity'), 'the grader knows the token')
-  assert.ok(isPresentationLevel('presentation:fidelity'), 'and grades it real-render like its siblings')
-  assert.ok(!PRESENTATION_ROUTE_FLOOR.includes('presentation:fidelity'), 'opt-in: a surface earns it by citing a design source, not by being a route')
-
-  // Exact-match in both directions. The tempting substitution is `presentation:visual`
-  // ("we have a baseline, isn't that the same check?") — it is not: a baseline
-  // captured from the built page ratifies whatever shipped, which is the failure
-  // fidelity exists to catch.
-  assert.ok(satisfies(['presentation:fidelity'], 'presentation:fidelity'))
-  assert.ok(!satisfies(['presentation:visual'], 'presentation:fidelity'))
-  assert.ok(!satisfies(['presentation:fidelity'], 'presentation:visual'))
-  assert.ok(!satisfies(['browser-journey', 'e2e'], 'presentation:fidelity'), 'a functional journey does not prove it')
-})
-
-test('presentation:fidelity grades like its siblings: DOM-only is Over-mocked, real-render needs attestation', () => {
-  // A JSDOM test cannot read computed style off a laid-out page, so it can only ever
-  // restate the manifest back to itself — the axis's over-mock.
-  const domOnly = depthStatus(['presentation:fidelity'], [{ levels: ['presentation:fidelity'], realBrowser: false, intercepts: false }])
-  assert.equal(domOnly.status, 'Over-mocked')
-  assert.match(domOnly.note, /real rendered-page evidence/)
-
-  // Real browser, self-declared → Unverified until the test is marked read, the
-  // same promotion path every presentation level takes.
-  const t = [{ levels: ['presentation:fidelity'], realBrowser: true, intercepts: false }]
-  assert.equal(depthStatus(['presentation:fidelity'], t).status, 'Unverified')
-  assert.equal(depthStatus(['presentation:fidelity'], t, { attested: true }).status, 'Covered')
-})
-
-// A synthetic scanned-test entry, matching what scanTests() produces.
-function t(levels, { intercepts = false, realBrowser = false, domOnly = false } = {}) {
-  return { file: 'x.spec.ts', levels: new Set(levels), intercepts, realBrowser, domOnly }
-}
-
-// ---------- baseline: every browser route auto-owes presentation:spatial ----------
-
-test('browser routes carry the presentation floor for every class', () => {
-  for (const cls of ['read', 'detail', 'mutation']) {
-    const floor = baselineFor('route', cls)
-    assert.ok(floor.includes('browser-journey'), `${cls} keeps functional floor`)
-    assert.ok(floor.includes('presentation:render-health'), `${cls} gains render-health spine`)
-    assert.ok(floor.includes('presentation:spatial'), `${cls} gains spatial floor`)
-    assert.ok(floor.includes('presentation:perceivability'), `${cls} gains perceivability floor`)
-    assert.ok(floor.includes('presentation:reachability'), `${cls} gains reachability floor`)
-    assert.ok(floor.includes('presentation:temporal'), `${cls} gains temporal floor`)
-  }
-})
-
-test('render-health is the spine (first presentation level on the floor)', () => {
-  const floor = baselineFor('route', 'read')
-  const firstPresentation = floor.find((l) => l.startsWith('presentation:'))
-  assert.equal(firstPresentation, 'presentation:render-health')
-})
-
-test('render-health grades like a presentation level (real render required)', () => {
-  const RH = ['presentation:render-health']
-  // a real-browser, non-intercepting test, marked read (verified) → Covered
-  assert.equal(depthStatus(RH, [t(['presentation:render-health'], { realBrowser: true })], { attested: true }).status, 'Covered')
-  // DOM-only cannot observe a pageerror on real mount → Over-mocked
-  assert.equal(depthStatus(RH, [t(['presentation:render-health'], { realBrowser: false, domOnly: true })], { attested: true }).status, 'Over-mocked')
-  // a spec that intercepts first-party traffic does not prove the real page renders
-  assert.equal(depthStatus(RH, [t(['presentation:render-health'], { realBrowser: true, intercepts: true })], { attested: true }).status, 'Over-mocked')
-})
-
-test('render-health breadth floor unifies the old `smoke` token (back-compat alias)', () => {
-  // the renamed token satisfies the floor
-  assert.notEqual(depthStatus(['render-health'], [t(['render-health'], { realBrowser: true })], { attested: true }).status, 'Missing')
-  // a legacy `@level smoke` tag still satisfies a render-health floor (alias)
-  assert.notEqual(depthStatus(['render-health'], [t(['smoke'], { realBrowser: true })], { attested: true }).status, 'Missing')
-  // and a render-health tag satisfies a legacy `smoke` floor (reverse alias)
-  assert.notEqual(depthStatus(['smoke'], [t(['render-health'], { realBrowser: true })], { attested: true }).status, 'Missing')
-  // a fuller browser journey also satisfies render-health
-  assert.notEqual(depthStatus(['render-health'], [t(['browser-journey'], { realBrowser: true })], { attested: true }).status, 'Missing')
-  // no test → Missing (the floor still bites)
-  assert.equal(depthStatus(['render-health'], [], { attested: true }).status, 'Missing')
-})
-
-// ---------- over-mock rate metric (depth-axis honesty) ----------
-
-// A synthetic index row, matching what build() stores per surface.
-function row(depthStatus, depthNote = '') {
-  return { surface: 's', depthStatus, depthNote }
-}
-const idx = (rows) => new Map(rows.map((r, i) => [`s${i}`, r]))
-
-test('over-mock rate = over-mocked / tested surfaces, behaviour vs presentation split', () => {
-  const m = computeMetrics(idx([
-    row('Covered'),
-    row('Over-mocked', 'behavior level met only by internal interception: api'),
-    row('Over-mocked', 'presentation level proven without real rendered-page evidence: presentation:spatial'),
-    row('Wrong Level'),
-  ]))
-  assert.equal(m.tested, 4)            // all four have tests (none Missing)
-  assert.equal(m.overMocked, 2)
-  assert.equal(m.overMockedBehavior, 1)
-  assert.equal(m.overMockedPresentation, 1)
-  assert.equal(m.overMockRate, 0.5)
-  assert.equal(m.overMockRatePct, 50)
-})
-
-test('Missing surfaces are absent, not over-mocked — excluded from the denominator', () => {
-  // 1 over-mocked, 1 covered (tested=2); two Missing surfaces don't dilute the rate.
-  const m = computeMetrics(idx([row('Over-mocked', 'behavior level: x'), row('Covered'), row('Missing'), row('Missing')]))
-  assert.equal(m.tested, 2)
-  assert.equal(m.overMockRate, 0.5)
-})
-
-test('reachability/excluded/null states are not depth-graded — never counted', () => {
-  const m = computeMetrics(idx([row('Reached'), row('Dead'), row('Excluded'), row(null), row('Covered')]))
-  assert.equal(m.depthGraded, 1)       // only the Covered row owes a depth check
-  assert.equal(m.tested, 1)
-  assert.equal(m.overMocked, 0)
-})
-
-test('rate is 0 (never NaN) when nothing is tested', () => {
-  const m = computeMetrics(idx([row('Missing'), row('Excluded')]))
-  assert.equal(m.tested, 0)
-  assert.equal(m.overMockRate, 0)
-  assert.equal(m.overMockRatePct, 0)
-})
-
-test('non-browser surfaces do NOT carry a presentation floor', () => {
-  assert.ok(!baselineFor('api', 'read').includes('presentation:spatial'))
-  assert.ok(!baselineFor('api', 'mutation').includes('presentation:spatial'))
-  assert.deepEqual(baselineFor('table'), [])
-})
-
-test('viewport floor is the documented 375 + 1280 pair', () => {
-  assert.deepEqual(PRESENTATION_VIEWPORT_FLOOR, [375, 1280])
-})
-
-// ---------- depth grading of presentation:spatial ----------
-
-const SPATIAL = ['presentation:spatial']
-
-test('real-rendered + marked read (verified) → Covered', () => {
-  const ds = depthStatus(SPATIAL, [t(['presentation:spatial'], { realBrowser: true })], { attested: true })
-  assert.equal(ds.status, 'Covered')
-})
-
-test('real-rendered but not marked read → Unverified', () => {
-  const ds = depthStatus(SPATIAL, [t(['presentation:spatial'], { realBrowser: true })], { attested: false })
-  assert.equal(ds.status, 'Unverified')
-})
-
-test('DOM-only / JSDOM presentation test → Over-mocked (not Covered)', () => {
-  const ds = depthStatus(SPATIAL, [t(['presentation:spatial'], { realBrowser: false, domOnly: true })], { attested: true })
-  assert.equal(ds.status, 'Over-mocked')
-  assert.match(ds.note, /real rendered-page evidence/)
-})
-
-test('presentation test that intercepts first-party traffic → Over-mocked', () => {
-  const ds = depthStatus(SPATIAL, [t(['presentation:spatial'], { realBrowser: true, intercepts: true })], { attested: true })
-  assert.equal(ds.status, 'Over-mocked')
-})
-
-test('a functional browser-journey does NOT satisfy presentation:spatial', () => {
-  // journey drives the DOM; it never asserts the page is laid out without overflow.
-  const ds = depthStatus(SPATIAL, [t(['browser-journey'], { realBrowser: true })], { attested: true })
-  assert.equal(ds.status, 'Wrong Level')
-  assert.match(ds.note, /presentation:spatial/)
-})
-
-test('no test at all → Missing', () => {
-  const ds = depthStatus(SPATIAL, [], { attested: true })
-  assert.equal(ds.status, 'Missing')
-})
-
-// ---------- perceivability behaves like a presentation level ----------
-
-const PERCEIVE = ['presentation:perceivability']
-
-test('perceivability: real-rendered + attested → Covered', () => {
-  const ds = depthStatus(PERCEIVE, [t(['presentation:perceivability'], { realBrowser: true })], { attested: true })
-  assert.equal(ds.status, 'Covered')
-})
-
-test('perceivability: DOM-only contrast check → Over-mocked', () => {
-  const ds = depthStatus(PERCEIVE, [t(['presentation:perceivability'], { domOnly: true })], { attested: true })
-  assert.equal(ds.status, 'Over-mocked')
-})
-
-test('perceivability: a spatial test does not satisfy perceivability', () => {
-  const ds = depthStatus(PERCEIVE, [t(['presentation:spatial'], { realBrowser: true })], { attested: true })
-  assert.equal(ds.status, 'Wrong Level')
-})
-
-// ---------- reachability behaves like a presentation level ----------
-
-const REACH = ['presentation:reachability']
-
-test('reachability: real-rendered + attested → Covered', () => {
-  const ds = depthStatus(REACH, [t(['presentation:reachability'], { realBrowser: true })], { attested: true })
-  assert.equal(ds.status, 'Covered')
-})
-
-test('reachability: DOM-only (no real crawl/render) → Over-mocked', () => {
-  const ds = depthStatus(REACH, [t(['presentation:reachability'], { domOnly: true })], { attested: true })
-  assert.equal(ds.status, 'Over-mocked')
-})
-
-// ---------- temporal behaves like a presentation level ----------
-
-const TEMPORAL = ['presentation:temporal']
-
-test('temporal: real-rendered + attested → Covered', () => {
-  const ds = depthStatus(TEMPORAL, [t(['presentation:temporal'], { realBrowser: true })], { attested: true })
-  assert.equal(ds.status, 'Covered')
-})
-
-test('temporal: real-rendered but NOT marked read → Unverified (the third-party-lane state)', () => {
-  const ds = depthStatus(TEMPORAL, [t(['presentation:temporal'], { realBrowser: true })], { attested: false })
-  assert.equal(ds.status, 'Unverified')
-})
-
-test('temporal: DOM-only → Over-mocked', () => {
-  const ds = depthStatus(TEMPORAL, [t(['presentation:temporal'], { domOnly: true })], { attested: true })
-  assert.equal(ds.status, 'Over-mocked')
-})
-
-// ---------- feature-derived escalation engine (#200) ----------
-
-test('isPresentationLevel: prefix-based, covers cell-qualified levels', () => {
-  assert.equal(isPresentationLevel('presentation:spatial'), true)
-  assert.equal(isPresentationLevel('presentation:perceivability@dark'), true)
-  assert.equal(isPresentationLevel('browser-journey'), false)
-  assert.equal(isPresentationLevel(undefined), false)
-})
-
-test('presentationEscalation: theme toggle → dark perceivability cell', () => {
-  assert.deepEqual(presentationEscalation({ themeToggle: true }), ['presentation:perceivability@dark'])
-})
-
-test('presentationEscalation: i18n → long-locale + RTL spatial cells', () => {
-  assert.deepEqual(presentationEscalation({ i18n: true }), ['presentation:spatial@long-locale', 'presentation:spatial@rtl'])
-})
-
-test('presentationEscalation: deterministic (sorted, deduped) and empty for no signals', () => {
-  assert.deepEqual(presentationEscalation({}), [])
-  // same signals → identical output regardless of key order
-  const a = presentationEscalation({ themeToggle: true, i18n: true })
-  const b = presentationEscalation({ i18n: true, themeToggle: true })
-  assert.deepEqual(a, b)
-  assert.deepEqual(a, ['presentation:perceivability@dark', 'presentation:spatial@long-locale', 'presentation:spatial@rtl'])
-})
-
-test('applyCellExclusions: gated removal of an escalated cell yields a census', () => {
-  const levels = ['presentation:spatial', 'presentation:perceivability@dark']
-  const r = applyCellExclusions(levels, { 'presentation:perceivability@dark': { category: 'deprecated', reason: 'dark mode being removed' } })
-  assert.deepEqual(r.kept, ['presentation:spatial'])
-  assert.equal(r.census.length, 1)
-})
-
-test('applyCellExclusions: cannot exclude a base (unqualified) floor level', () => {
-  const r = applyCellExclusions(['presentation:spatial'], { 'presentation:spatial': { category: 'x', reason: 'y' } })
-  assert.deepEqual(r.kept, ['presentation:spatial']) // kept despite the entry
-  assert.equal(r.rejected.length, 1)
-})
-
-test('applyCellExclusions: escalated cell without category/reason is rejected (kept)', () => {
-  const levels = ['presentation:perceivability@dark']
-  const r = applyCellExclusions(levels, { 'presentation:perceivability@dark': { category: 'deprecated' } })
-  assert.deepEqual(r.kept, ['presentation:perceivability@dark'])
-  assert.equal(r.rejected.length, 1)
-})
-
-test('build(): a route with a themeToggle signal gains the dark-mode obligation', async () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'covesc-'))
-  try {
-    const gen = path.join(dir, 'docs/tests/_generated')
-    fs.mkdirSync(gen, { recursive: true })
-    fs.writeFileSync(path.join(gen, 'surface-inventory.json'), JSON.stringify({
-      surfaces: [{ id: '/app', kind: 'route', class: 'read', reachability: 'reachable', signals: { themeToggle: true } }],
-    }))
-    const cfg = {
-      inventory: path.join(gen, 'surface-inventory.json'),
-      coverageDir: path.join(dir, 'docs/tests'),
-      testRoots: [dir], requirementGlobs: {}, acceptedMarker: /x/, unverifiedBlocks: true,
-    }
-    const { index } = await build(cfg)
-    const row = index.get('/app')
-    assert.ok(row.requiredLevels.includes('presentation:perceivability@dark'), 'dark cell auto-added from signal')
-    assert.ok(row.requiredLevels.includes('presentation:perceivability'), 'base floor still present')
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true })
-  }
-})
-
-// ---------- end-to-end build() against a temp fixture ----------
-
-test('build() grades a real browser route end-to-end', async () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'covledger-'))
-  try {
-    const gen = path.join(dir, 'docs/tests/_generated')
-    fs.mkdirSync(gen, { recursive: true })
-    fs.writeFileSync(path.join(gen, 'surface-inventory.json'), JSON.stringify({
-      surfaces: [{ id: '/dashboard', kind: 'route', class: 'read', reachability: 'reachable' }],
-    }))
-    // A real-browser presentation test for the route.
-    const e2e = path.join(dir, 'e2e')
-    fs.mkdirSync(e2e, { recursive: true })
-    // Satisfies ALL route floors: the functional browser-journey plus the full
-    // presentation floor (render-health spine + spatial, perceivability,
-    // reachability, temporal), in one real-browser spec.
-    fs.writeFileSync(path.join(e2e, 'dashboard.spec.ts'), [
-      '// @covers /dashboard',
-      '// @level browser-journey',
-      '// @level presentation:render-health',
-      '// @level presentation:spatial',
-      '// @level presentation:perceivability',
-      '// @level presentation:reachability',
-      '// @level presentation:temporal',
-      "import { test, expect } from '@playwright/test'",
-      "test('renders, stable, perceivable, reachable', async ({ page }) => { await page.goto('/dashboard') })",
-    ].join('\n'))
-
-    const cfg = {
-      inventory: path.join(gen, 'surface-inventory.json'),
-      coverageDir: path.join(dir, 'docs/tests'),
-      testRoots: [dir],
-      requirementGlobs: {},
-      acceptedMarker: /status:\s*accepted/i,
-      unverifiedBlocks: true,
-    }
-    const { index } = await build(cfg)
-    const row = index.get('/dashboard')
-    assert.ok(row, 'route is in the index')
-    assert.ok(row.requiredLevels.includes('presentation:spatial'), 'presentation floor applied')
-    // real-rendered but not yet marked read → Unverified
-    assert.equal(row.depthStatus, 'Unverified')
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true })
-  }
-})
-
-test('build(): Unverified is a warning unless the user opts into unverifiedBlocks', async () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'covunv-'))
-  try {
-    const gen = path.join(dir, 'docs/tests/_generated')
-    fs.mkdirSync(gen, { recursive: true })
-    fs.writeFileSync(path.join(gen, 'surface-inventory.json'), JSON.stringify({
-      surfaces: [{ id: '/dashboard', kind: 'route', class: 'read', reachability: 'reachable' }],
-    }))
-    fs.mkdirSync(path.join(dir, 'e2e'), { recursive: true })
-    fs.writeFileSync(path.join(dir, 'e2e', 'dashboard.spec.ts'), [
-      '// @covers /dashboard',
-      '// @level browser-journey',
-      '// @level presentation:render-health',
-      '// @level presentation:spatial',
-      '// @level presentation:perceivability',
-      '// @level presentation:reachability',
-      '// @level presentation:temporal',
-      "import { test } from '@playwright/test'",
-      "test('dashboard', async ({ page }) => { await page.goto('/dashboard') })",
-    ].join('\n'))
-    const base = {
-      inventory: path.join(gen, 'surface-inventory.json'),
-      coverageDir: path.join(dir, 'docs/tests'),
-      testRoots: [dir], requirementGlobs: {}, acceptedMarker: /x/,
-    }
-    const severityOf = async (cfg) => (await build(cfg)).findings
-      .filter((f) => f.kind === 'Unverified' && f.surface === '/dashboard').map((f) => f.severity)
-    assert.deepEqual(await severityOf(base), ['warn'])
-    assert.deepEqual(await severityOf({ ...base, unverifiedBlocks: true }), ['error'])
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true })
-  }
-})
-
-// ---------- acceptance gate (requirementGlobs) ----------
-
-test('build(): the acceptance gate holds every accepted ADR to a criteria doc or a tracked gap', async () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'covadr-'))
-  try {
-    const gen = path.join(dir, 'docs/tests/_generated')
-    const adr = path.join(dir, 'docs/adr')
-    const cov = path.join(dir, 'docs/tests/adr')
-    fs.mkdirSync(gen, { recursive: true }); fs.mkdirSync(adr, { recursive: true }); fs.mkdirSync(cov, { recursive: true })
-    fs.writeFileSync(path.join(gen, 'surface-inventory.json'), JSON.stringify({ surfaces: [] }))
-    fs.writeFileSync(path.join(dir, 'docs/tests/0008-criteria.md'), '# criteria')
-    // 0008: accepted, coverage file links criteria → clean
-    fs.writeFileSync(path.join(adr, '0008-allowlist.md'), '# ADR 8\nstatus: accepted\n')
-    fs.writeFileSync(path.join(cov, '0008-allowlist.coverage.json'), JSON.stringify({ criteria: path.join(dir, 'docs/tests/0008-criteria.md'), surfaces: {} }))
-    // 0009: accepted (bold markdown status form), coverage file with neither criteria nor gap → error
-    fs.writeFileSync(path.join(adr, '0009-dispatch.md'), '# ADR 9\n**Status:** accepted\n')
-    fs.writeFileSync(path.join(cov, '0009-dispatch.coverage.json'), JSON.stringify({ surfaces: {} }))
-    // 0010: accepted, no coverage file at all → error
-    fs.writeFileSync(path.join(adr, '0010-billing.md'), '# ADR 10\nStatus: Accepted\n')
-    // 0011: accepted but declares no runtime behavior → exempt
-    fs.writeFileSync(path.join(adr, '0011-terminology.md'), '# ADR 11\nstatus: accepted\n\nThis ADR has no runtime behavior.\n')
-    // 0012: accepted, coverage file names a tracked gap instead of criteria → clean
-    fs.writeFileSync(path.join(adr, '0012-export.md'), '# ADR 12\nstatus: accepted\n')
-    fs.writeFileSync(path.join(cov, '0012-export.coverage.json'), JSON.stringify({ gapIssue: '#412', surfaces: {} }))
-    // 0013: draft → ignored
-    fs.writeFileSync(path.join(adr, '0013-draft.md'), '# ADR 13\nstatus: proposed\n')
-
-    const cfg = {
-      inventory: path.join(gen, 'surface-inventory.json'),
-      coverageDir: path.join(dir, 'docs/tests'),
-      testRoots: [dir],
-      requirementGlobs: { adr },
-      acceptedMarker: /\bstatus\b[\s*:_-]{0,6}accepted/i,
-      unverifiedBlocks: true,
-    }
-    const { findings } = await build(cfg)
-    const gate = findings.filter((f) => f.kind === 'Gate').map((f) => f.surface).sort()
-    assert.deepEqual(gate, ['adr:0009', 'adr:0010'], `only the placeholder and the missing file fail the gate, got ${JSON.stringify(findings.filter((f) => f.kind === 'Gate'))}`)
-    assert.ok(!findings.some((f) => f.kind === 'Gate skipped'), 'the gate ran')
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true })
-  }
-})
-
-test('build(): a requirementGlobs directory that does not exist is a gate error, not a silent skip', async () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'covadr-'))
-  try {
-    const gen = path.join(dir, 'docs/tests/_generated')
-    fs.mkdirSync(gen, { recursive: true })
-    fs.writeFileSync(path.join(gen, 'surface-inventory.json'), JSON.stringify({ surfaces: [] }))
-    const cfg = {
-      inventory: path.join(gen, 'surface-inventory.json'), coverageDir: path.join(dir, 'docs/tests'), testRoots: [dir],
-      requirementGlobs: { adr: path.join(dir, 'docs/adr') }, acceptedMarker: /status:\s*accepted/i, unverifiedBlocks: true,
-    }
-    const { findings } = await build(cfg)
-    assert.ok(findings.some((f) => f.kind === 'Gate' && f.surface === 'adr:*'), 'names the missing directory')
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true })
-  }
-})