@1aboveio/skills 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,447 @@
+// 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 })
+  }
+})