@1aboveio/skills 1.0.8 → 1.0.9

package/skills/engineering/ensure-coverage/scripts/design-parity.test.mjs

@@ -1,552 +0,0 @@
-// Tests for the design-parity fidelity gate.
-//
-// The cases are derived from the incident, not invented: every divergence
-// fmm-express #521 shipped (page measure, card plane, the Amount input's
-// responsive type step, Description's scale) appears below as a test that the
-// gate blocks it. A gate whose tests are hand-picked from what it happens to
-// catch is the thing this skill calls a vacuous assertion.
-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 { execFileSync, spawnSync } from 'node:child_process'
-
-import {
-  PARITY_CATALOG, ROLES, FLOOR_VIEWPORTS,
-  expectedRows, rowKey, isRealReason,
-  validateManifest, compareObserved, valuesAgree, normalize,
-  probeScript, scaffoldManifest, detectExpectationRewrites,
-} from './design-parity.mjs'
-
-const HERE = path.dirname(new URL(import.meta.url).pathname)
-const SCRIPT = path.join(HERE, 'design-parity.mjs')
-
-// The #521 element map, as it would be declared for the merchant charge form.
-const ELEMENTS = {
-  container: '[data-testid="charge-form-plane"]',
-  primary: '[data-testid="charge-amount-input"]',
-  secondary: '[data-testid="description-input"]',
-  coupled: '[data-testid="charge-tip-section"]',
-}
-
-// A complete, decided manifest — built from the catalog so the fixture cannot
-// drift out of sync with doctrine the way a hand-written one would.
-function completeManifest(overrides = {}) {
-  const rows = expectedRows(ELEMENTS).map((r) => ({
-    ...r,
-    ...(r.relation ? {} : { expected: '0px' }),
-    from: 'Dashboard.tipprototype.tsx:781',
-  }))
-  return {
-    source: { ref: 'proto/tip-charge-ia', sha: 'deadbee', path: 'frontend/src/pages/Dashboard.tipprototype.tsx', kind: 'react' },
-    surface: 'merchant-dashboard-charge-form',
-    url: '/dashboard',
-    viewports: FLOOR_VIEWPORTS,
-    elements: ELEMENTS,
-    rows,
-    ...overrides,
-  }
-}
-
-const problems = (v) => v.map((x) => `${x.row}: ${x.problem}`).join('\n')
-
-// ── the catalog ────────────────────────────────────────────────────────────
-
-test('every catalog entry carries the reason it exists (the thing that stops it being deleted)', () => {
-  assert.ok(PARITY_CATALOG.length > 0)
-  for (const e of PARITY_CATALOG) {
-    assert.ok(e.id && e.group, `${e.id}: id + group`)
-    assert.ok(e.why && e.why.length > 20, `${e.id}: a real why, not a label`)
-    assert.ok(e.relation || (ROLES.includes(e.role) && Array.isArray(e.css) && e.css.length), `${e.id}: a known role + css, or a relation`)
-  }
-})
-
-test('the catalog pins each thing #521 lost: measure, plane, per-viewport primary scale, secondary scale, coupled rhythm', () => {
-  const ids = PARITY_CATALOG.map((e) => e.id)
-  for (const id of ['container.measure', 'container.plane', 'primary.scale', 'secondary.scale', 'rhythm.coupled', 'hierarchy.order']) {
-    assert.ok(ids.includes(id), `catalog carries ${id}`)
-  }
-  // The plane is three properties on purpose: pinning only the border lets a card
-  // return through background + shadow.
-  const plane = PARITY_CATALOG.find((e) => e.id === 'container.plane')
-  assert.deepEqual(plane.css.sort(), ['background-color', 'border-top-width', 'box-shadow'])
-  // The responsive step-up is the silent loss, so scale rows are per-viewport.
-  assert.ok(PARITY_CATALOG.find((e) => e.id === 'primary.scale').perViewport)
-  assert.ok(PARITY_CATALOG.find((e) => e.id === 'secondary.scale').perViewport)
-})
-
-// ── expansion ──────────────────────────────────────────────────────────────
-
-test('expectedRows expands per-viewport rows across the floor and skips undeclared roles', () => {
-  const rows = expectedRows({ primary: '#a' })
-  const scale = rows.filter((r) => r.id === 'primary.scale')
-  assert.deepEqual(scale.map((r) => r.viewport).sort(), [...FLOOR_VIEWPORTS].sort())
-  assert.equal(rows.filter((r) => r.role === 'container').length, 0, 'container undeclared → no container rows owed')
-})
-
-test('a relation is owed only when both operands are declared (no row nothing can measure)', () => {
-  assert.equal(expectedRows({ primary: '#a' }).filter((r) => r.relation).length, 0)
-  assert.equal(expectedRows({ primary: '#a', secondary: '#b' }).filter((r) => r.relation).length, 1)
-})
-
-// ── manifest validation ────────────────────────────────────────────────────
-
-test('a complete, decided manifest validates', () => {
-  const v = validateManifest(completeManifest())
-  assert.equal(v.length, 0, problems(v))
-})
-
-test('THE #521 CASE: a manifest that omits the container-plane rows is blocked, not passed', () => {
-  // The defect in miniature — the card plane was never on anyone's list, so nobody
-  // ever decided against it, and four rounds of user correction stood in for the gate.
-  const m = completeManifest()
-  m.rows = m.rows.filter((r) => r.id !== 'container.plane')
-  const v = validateManifest(m)
-  assert.ok(v.length >= 3, 'all three plane properties are owed')
-  assert.match(problems(v), /missing row container\.plane/)
-  assert.match(problems(v), /omission is not a decision/)
-})
-
-test('a dropped responsive viewport is blocked (the flattened Amount type scale)', () => {
-  const m = completeManifest()
-  m.rows = m.rows.filter((r) => !(r.id === 'primary.scale' && r.viewport === 1280))
-  assert.match(problems(validateManifest(m)), /missing row primary\.scale\|primary\|font-size\|1280/)
-})
-
-test('an undecided row (expected: TODO) is blocked', () => {
-  const m = completeManifest()
-  m.rows[0].expected = 'TODO'
-  assert.match(problems(validateManifest(m)), /expected is TODO/)
-})
-
-test('a row may be rejected — but only with a reason a reader can disagree with', () => {
-  const weak = completeManifest()
-  weak.rows[0] = { ...weak.rows[0], expected: undefined, reject: 'n/a' }
-  assert.match(problems(validateManifest(weak)), /no real reason/)
-
-  const real = completeManifest()
-  real.rows[0] = { ...real.rows[0], expected: undefined, from: undefined, reject: 'source is a Figma frame with no measurable page container; measure pinned on the primary instead' }
-  assert.equal(validateManifest(real).length, 0, problems(validateManifest(real)))
-})
-
-test('isRealReason refuses the ritual forms and accepts an argument', () => {
-  for (const s of ['', ' ', 'n/a', 'N/A', 'none', '--', 'TODO', 'tbd', 'no']) assert.equal(isRealReason(s), false, `refuses ${JSON.stringify(s)}`)
-  assert.equal(isRealReason('prototype has no fixed measure; the app shell owns width here'), true)
-})
-
-test('every expected value names the source line it was read off', () => {
-  const m = completeManifest()
-  delete m.rows[0].from
-  assert.match(problems(validateManifest(m)), /no `from:` citation/)
-
-  const bad = completeManifest()
-  bad.rows[0].from = 'somewhere in the prototype'
-  assert.match(problems(validateManifest(bad)), /is not a `<path>:<line>` citation/)
-})
-
-test('a manifest with no pinned source is blocked — an unpinned baseline is not fidelity', () => {
-  const noSha = completeManifest({ source: { path: 'p.tsx' } })
-  assert.match(problems(validateManifest(noSha)), /pin the design source at a commit/)
-  const noPath = completeManifest({ source: { sha: 'abc' } })
-  assert.match(problems(validateManifest(noPath)), /must name the design source/)
-})
-
-test('citations are shape-checked but warned, not blocked, when git cannot answer', () => {
-  const v = validateManifest(completeManifest()) // no resolveSource passed
-  assert.equal(v.length, 0)
-  assert.ok(v.warnings.some((w) => /citation not resolved/.test(w.problem)))
-})
-
-test('a citation that does not resolve in the source blob is blocked', () => {
-  const v = validateManifest(completeManifest(), {
-    resolveSource: () => ({ ok: false, why: 'no `Dashboard.tipprototype.tsx` in deadbee' }),
-  })
-  assert.ok(v.length > 0)
-  assert.match(problems(v), /does not resolve/)
-})
-
-test('an unknown role warns rather than blocking (its rows are simply not derived)', () => {
-  const m = completeManifest({ elements: { ...ELEMENTS, footer: '#f' } })
-  const v = validateManifest(m)
-  assert.equal(v.length, 0, problems(v))
-  assert.ok(v.warnings.some((w) => /unknown role/.test(w.problem)))
-})
-
-// ── comparison against the rendered page ───────────────────────────────────
-
-function observed(pairs, viewport = 375) {
-  return { runs: [{ viewport, measurements: pairs.map(([role, css, value]) => ({ role, css, value })) }] }
-}
-
-function oneRow(row) {
-  return { source: { sha: 'x', path: 'p.tsx' }, elements: ELEMENTS, viewports: [375], rows: [row] }
-}
-
-test('THE #521 CASE: a page laid out to the wrong measure diverges', () => {
-  const m = oneRow({ id: 'container.measure', role: 'container', css: 'max-width', expected: '672px', from: 'p.tsx:781' })
-  const bad = compareObserved(m, observed([['container', 'max-width', '448px']]))  // max-w-md against a max-w-2xl source
-  assert.equal(bad.length, 1)
-  assert.match(bad[0].problem, /expected 672px, page has 448px/)
-  assert.match(bad[0].problem, /source: p\.tsx:781/, 'the failure names the source line to go read')
-
-  assert.equal(compareObserved(m, observed([['container', 'max-width', '672px']])).length, 0)
-})
-
-test('THE #521 CASE: the card plane coming back through any one of its three properties diverges', () => {
-  const rows = [
-    { id: 'container.plane', role: 'container', css: 'background-color', expected: 'rgba(0, 0, 0, 0)', from: 'p.tsx:781' },
-    { id: 'container.plane', role: 'container', css: 'box-shadow', expected: 'none', from: 'p.tsx:781' },
-    { id: 'container.plane', role: 'container', css: 'border-top-width', expected: '0px', from: 'p.tsx:781' },
-  ]
-  const m = { source: { sha: 'x', path: 'p.tsx' }, elements: ELEMENTS, viewports: [375], rows }
-  const flat = observed([['container', 'background-color', 'rgba(0, 0, 0, 0)'], ['container', 'box-shadow', 'none'], ['container', 'border-top-width', '0px']])
-  assert.equal(compareObserved(m, flat).length, 0)
-
-  const shadowOnly = observed([['container', 'background-color', 'rgba(0, 0, 0, 0)'], ['container', 'box-shadow', 'rgba(0,0,0,0.05) 0px 1px 2px 0px'], ['container', 'border-top-width', '0px']])
-  assert.equal(compareObserved(m, shadowOnly).length, 1, 'a shadow alone still reads as a plane')
-})
-
-test('THE #521 CASE: a lost responsive step-up diverges at the viewport that lost it', () => {
-  const m = {
-    source: { sha: 'x', path: 'p.tsx' }, elements: ELEMENTS, viewports: [375, 1280],
-    rows: [
-      { id: 'primary.scale', role: 'primary', css: 'font-size', viewport: 375, expected: '24px', from: 'p.tsx:825' },
-      { id: 'primary.scale', role: 'primary', css: 'font-size', viewport: 1280, expected: '30px', from: 'p.tsx:825' },
-    ],
-  }
-  const flattened = { runs: [
-    { viewport: 375, measurements: [{ role: 'primary', css: 'font-size', value: '24px' }] },
-    { viewport: 1280, measurements: [{ role: 'primary', css: 'font-size', value: '24px' }] },  // never stepped up
-  ] }
-  const bad = compareObserved(m, flattened)
-  assert.equal(bad.length, 1)
-  assert.match(bad[0].row, /\|1280$/, 'only the viewport that lost it fails')
-  assert.match(bad[0].problem, /expected 30px, page has 24px/)
-})
-
-test('THE #521 CASE: Description at Amount weight fails the relational row', () => {
-  const m = oneRow({ id: 'hierarchy.order', relation: 'primary.font-size > secondary.font-size', from: 'p.tsx:825' })
-  const equal = observed([['primary', 'font-size', '24px'], ['secondary', 'font-size', '24px']])
-  const bad = compareObserved(m, equal)
-  assert.equal(bad.length, 1)
-  assert.match(bad[0].problem, /primary\.font-size=24px is not > secondary\.font-size=24px/)
-
-  assert.equal(compareObserved(m, observed([['primary', 'font-size', '24px'], ['secondary', 'font-size', '14px']])).length, 0)
-})
-
-test('a missing element fails loudly — it must never read as agreement', () => {
-  const m = oneRow({ id: 'primary.box', role: 'primary', css: 'padding-top', expected: '12px', from: 'p.tsx:825' })
-  const gone = compareObserved(m, observed([['primary', 'padding-top', null]]))
-  assert.equal(gone.length, 1)
-  assert.match(gone[0].problem, /element not found/)
-  assert.match(gone[0].problem, /charge-amount-input/, 'names the selector that missed')
-})
-
-test('a row the probe never measured fails — silence is not a pass', () => {
-  const m = oneRow({ id: 'primary.box', role: 'primary', css: 'padding-top', expected: '12px', from: 'p.tsx:825' })
-  const bad = compareObserved(m, { runs: [] })
-  assert.equal(bad.length, 1)
-  assert.match(bad[0].problem, /not measured/)
-})
-
-test('a rejected row is not compared (the reject is the decision)', () => {
-  const m = oneRow({ id: 'container.measure', role: 'container', css: 'max-width', reject: 'app shell owns the measure on this route; nothing to pin here' })
-  assert.equal(compareObserved(m, { runs: [] }).length, 0)
-})
-
-test('a viewport-independent row that measures differently per viewport is caught, not silently passed on the first hit', () => {
-  const m = {
-    source: { sha: 'x', path: 'p.tsx' }, elements: ELEMENTS, viewports: [375, 1280],
-    rows: [{ id: 'container.padding', role: 'container', css: 'padding-left', expected: '0px', from: 'p.tsx:781' }],
-  }
-  const responsive = { runs: [
-    { viewport: 375, measurements: [{ role: 'container', css: 'padding-left', value: '0px' }] },
-    { viewport: 1280, measurements: [{ role: 'container', css: 'padding-left', value: '24px' }] },
-  ] }
-  const bad = compareObserved(m, responsive)
-  assert.equal(bad.length, 1)
-  assert.match(bad[0].problem, /split it per viewport/)
-})
-
-test('sub-pixel layout noise is not a design decision; a real step is', () => {
-  assert.equal(valuesAgree('24px', '24.4px'), true)
-  assert.equal(valuesAgree('24px', '24.6px'), false)
-  assert.equal(valuesAgree('24', '24px'), true, 'a bare number in expected means px')
-  assert.equal(valuesAgree('none', 'none'), true)
-  assert.equal(valuesAgree('rgba(0, 0, 0, 0)', 'rgba(0,0,0,0)'), false, 'colour strings are compared as written — normalize in the probe, not here')
-  assert.deepEqual(normalize('  24PX '), { num: 24 })
-})
-
-// ── expectation rewrites (the re-baseline-to-green analogue) ───────────────
-
-const twoVersions = (before, after, srcAfter) => [
-  { source: { sha: 'aaa', path: 'p.tsx' }, elements: ELEMENTS, rows: [{ id: 'container.measure', role: 'container', css: 'max-width', ...before }] },
-  { source: { sha: srcAfter || 'aaa', path: 'p.tsx' }, elements: ELEMENTS, rows: [{ id: 'container.measure', role: 'container', css: 'max-width', ...after }] },
-]
-
-test('rewriting an expectation to match the page, under an unmoved source, BLOCKS', () => {
-  // The cheapest way to green this gate: stop fixing the page, edit the target.
-  // One character in YAML, no PNG in the diff for a reviewer to notice.
-  const [prev, next] = twoVersions(
-    { expected: '672px', from: 'p.tsx:781' },
-    { expected: '448px', from: 'p.tsx:781' },
-  )
-  const out = detectExpectationRewrites(prev, next)
-  assert.equal(out.length, 1)
-  assert.equal(out[0].level, 'block')
-  assert.match(out[0].problem, /672px → 448px/)
-  assert.match(out[0].problem, /moves the target to the page/)
-})
-
-test('the same rewrite clears when the mis-read is declared', () => {
-  const [prev, next] = twoVersions(
-    { expected: '672px', from: 'p.tsx:781' },
-    { expected: '448px', from: 'p.tsx:781', rebase: 'misread the prototype: 672 was the sm: breakpoint, the base measure is 448' },
-  )
-  assert.equal(detectExpectationRewrites(prev, next).length, 0)
-})
-
-test('a `rebase:` that says nothing does not clear it', () => {
-  const [prev, next] = twoVersions(
-    { expected: '672px', from: 'p.tsx:781' },
-    { expected: '448px', from: 'p.tsx:781', rebase: 'n/a' },
-  )
-  assert.equal(detectExpectationRewrites(prev, next)[0].level, 'block')
-})
-
-test('when the design source itself moved, a changed expectation warns rather than blocks', () => {
-  // The source is no longer the same document; expectations are SUPPOSED to change.
-  // Blocking here would make re-pinning a prototype cost a fight with the gate.
-  const [prev, next] = twoVersions(
-    { expected: '672px', from: 'p.tsx:781' },
-    { expected: '448px', from: 'p.tsx:781' },
-    'bbb',
-  )
-  const out = detectExpectationRewrites(prev, next)
-  assert.equal(out[0].level, 'warn')
-  assert.match(out[0].problem, /design source moved/)
-})
-
-test('a changed expectation with a new citation warns — that is a re-read, not a capitulation', () => {
-  const [prev, next] = twoVersions(
-    { expected: '672px', from: 'p.tsx:781' },
-    { expected: '448px', from: 'p.tsx:602' },
-  )
-  assert.equal(detectExpectationRewrites(prev, next)[0].level, 'warn')
-})
-
-test('unchanged rows, new rows and removed rows are not rewrites', () => {
-  const [prev] = twoVersions({ expected: '672px', from: 'p.tsx:781' }, {})
-  assert.equal(detectExpectationRewrites(prev, prev).length, 0, 'identical manifests')
-  const added = { ...prev, rows: [...prev.rows, { id: 'primary.box', role: 'primary', css: 'padding-top', expected: '12px', from: 'p.tsx:825' }] }
-  assert.equal(detectExpectationRewrites(prev, added).length, 0, 'a new row rewrote nothing')
-  assert.equal(detectExpectationRewrites(prev, { ...prev, rows: [] }).length, 0, 'a removed row is caught by the completeness check, not here')
-})
-
-test('CLI: --diff blocks a manifest whose expectation was rewritten to match the page', () => {
-  // Real git history, because the check reads the previous version with `git show`.
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'design-parity-git-'))
-  const git = (...a) => execFileSync('git', a, { cwd: dir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] })
-  git('init', '-q')
-  git('config', 'user.email', 't@t'); git('config', 'user.name', 't')
-  // A COMPLETE manifest, so the only thing left to fail on is the rewrite itself.
-  const m = {
-    source: { sha: 'aaa', path: 'p.tsx' }, elements: { container: '#c' }, viewports: [375],
-    rows: expectedRows({ container: '#c' }, [375]).map((r) => ({ ...r, expected: r.css === 'max-width' ? '672px' : '0px', from: 'p.tsx:781' })),
-  }
-  fs.writeFileSync(path.join(dir, 'm.json'), JSON.stringify(m))
-  git('add', '-A'); git('commit', '-qm', 'pin the measure')
-
-  m.rows.find((r) => r.css === 'max-width').expected = '448px'   // the page won the argument
-  fs.writeFileSync(path.join(dir, 'm.json'), JSON.stringify(m))
-  const r = run(['validate', 'm.json', '--diff', 'HEAD', '--root', dir], dir)
-  assert.equal(r.status, 1)
-  assert.match(r.stdout, /expectation\(s\) rewritten to match the page/)
-  assert.match(r.stdout, /672px → 448px/)
-})
-
-test('CLI: --diff is silent when the manifest is new at that base', () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'design-parity-git-'))
-  const git = (...a) => execFileSync('git', a, { cwd: dir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] })
-  git('init', '-q'); git('config', 'user.email', 't@t'); git('config', 'user.name', 't')
-  fs.writeFileSync(path.join(dir, 'seed.txt'), 'x'); git('add', '-A'); git('commit', '-qm', 'seed')
-  fs.writeFileSync(path.join(dir, 'm.json'), JSON.stringify({ source: { sha: 'a', path: 'p.tsx' }, elements: { container: '#c' }, viewports: [375], rows: [] }))
-  const r = run(['validate', 'm.json', '--diff', 'HEAD', '--root', dir], dir)
-  assert.ok(!/rewritten/.test(r.stdout), 'a manifest with no previous version reports nothing about rewrites')
-})
-
-// ── probe ──────────────────────────────────────────────────────────────────
-
-// Run the emitted snippet against a stub page. Asserting on its SOURCE would pass
-// on a snippet that throws; the only honest question about a probe is what it
-// returns when something evaluates it.
-function runProbe(js, { missing = [] } = {}) {
-  const queried = []
-  const document = {
-    querySelector(sel) { queried.push(sel); return missing.includes(sel) ? null : { sel } },
-  }
-  const getComputedStyle = (el) => new Proxy({}, { get: (_, css) => `<${el.sel}|${String(css)}>` })
-  const result = new Function('document', 'getComputedStyle', `return ${js}`)(document, getComputedStyle)
-  return { result, queried }
-}
-
-test('the probe measures every catalog property plus the operands the relations need', () => {
-  const { result, queried } = runProbe(probeScript({ surface: 's', elements: ELEMENTS, viewports: [375] }, 375))
-  assert.equal(result.surface, 's')
-  assert.equal(result.runs[0].viewport, 375)
-
-  const measured = new Set(result.runs[0].measurements.map((m) => `${m.role}|${m.css}`))
-  for (const owed of expectedRows(ELEMENTS)) {
-    if (owed.relation) continue
-    assert.ok(measured.has(`${owed.role}|${owed.css}`), `probe reads ${owed.role}.${owed.css}`)
-  }
-  // The relational row's operands must be measured even though no plain row asks
-  // for secondary.font-size at an unqualified viewport.
-  assert.ok(measured.has('primary|font-size') && measured.has('secondary|font-size'))
-  for (const sel of Object.values(ELEMENTS)) assert.ok(queried.includes(sel), `probe queries ${sel}`)
-  assert.ok(result.runs[0].measurements.every((m) => typeof m.value === 'string'))
-})
-
-test('the probe reports a missing element as null rather than throwing', () => {
-  // compareObserved turns null into "element not found"; a probe that threw here
-  // would produce no results file at all, and an absent file is easy to read as
-  // "nothing to report".
-  const { result } = runProbe(probeScript({ elements: ELEMENTS, viewports: [375] }, 375), { missing: [ELEMENTS.container] })
-  const container = result.runs[0].measurements.filter((m) => m.role === 'container')
-  assert.ok(container.length > 0)
-  assert.ok(container.every((m) => m.value === null))
-})
-
-test('the probe emits one entry per role+property, not one per manifest row', () => {
-  const js = probeScript({ elements: ELEMENTS, viewports: [375, 1280] }, 375)
-  const fontSizeEntries = js.match(/"css": "font-size"/g) || []
-  assert.equal(fontSizeEntries.length, 2, 'primary + secondary, not primary×2 viewports + secondary×2')
-})
-
-// ── scaffold ───────────────────────────────────────────────────────────────
-
-test('scaffold emits the whole catalog as TODO rows, carrying each reason into the file', () => {
-  const md = scaffoldManifest({ source: { ref: 'proto/x', sha: 'abc123', path: 'proto.tsx' }, surface: 's', url: '/u', elements: ELEMENTS })
-  assert.match(md, /source:\n {2}ref: proto\/x\n {2}sha: abc123/)
-  for (const e of PARITY_CATALOG) {
-    assert.ok(md.includes(`id: ${e.id}`), `scaffold carries ${e.id}`)
-    assert.ok(md.includes(e.why), `scaffold carries the reason for ${e.id}`)
-  }
-  assert.match(md, /expected: TODO/)
-  assert.match(md, /read off the DESIGN SOURCE/, 'the file states the fidelity-not-drift rule where it will be read')
-})
-
-test('scaffold leaves no TODO value on a relational row (the relation IS the expectation)', () => {
-  const md = scaffoldManifest({ source: { path: 'p.tsx' }, elements: ELEMENTS })
-  const block = md.slice(md.indexOf('id: hierarchy.order'))
-  const nextRow = block.indexOf('\n  - id:')
-  assert.ok(!(nextRow === -1 ? block : block.slice(0, nextRow)).includes('expected: TODO'))
-})
-
-test('scaffold comments out undeclared roles instead of emitting rows nothing can measure', () => {
-  const md = scaffoldManifest({ source: { path: 'p.tsx' }, elements: { primary: '#a' } })
-  assert.match(md, /# container: '<selector>'/)
-  assert.ok(!md.includes('id: container.measure'))
-})
-
-test('scaffold output is a manifest validate accepts once filled in', () => {
-  // The two ends have to agree, or the skeleton teaches a shape the gate rejects.
-  const owed = expectedRows(ELEMENTS)
-  const md = scaffoldManifest({ source: { path: 'p.tsx' }, elements: ELEMENTS })
-  for (const r of owed) assert.ok(md.includes(`id: ${r.id}`), `${rowKey(r)} is in the skeleton`)
-})
-
-// ── CLI ────────────────────────────────────────────────────────────────────
-
-const run = (args, cwd) => spawnSync(process.execPath, [SCRIPT, ...args], { cwd, encoding: 'utf8' })
-
-test('CLI: validate exits 1 and names the missing rows on an incomplete manifest', () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'design-parity-'))
-  const m = completeManifest()
-  m.rows = m.rows.filter((r) => r.id !== 'container.plane')
-  fs.writeFileSync(path.join(dir, 'm.json'), JSON.stringify(m))
-  const r = run(['validate', 'm.json', '--root', dir], dir)
-  assert.equal(r.status, 1)
-  assert.match(r.stdout, /missing row container\.plane/)
-})
-
-test('CLI: a run without --observed announces on stderr that it did not check the page', () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'design-parity-'))
-  fs.writeFileSync(path.join(dir, 'm.json'), JSON.stringify(completeManifest()))
-  const r = run(['validate', 'm.json', '--root', dir], dir)
-  // The manifest cites a source that does not exist in `dir`, so this run blocks —
-  // what is asserted here is the NOTE, which must appear on the misleading path too.
-  assert.match(r.stderr, /reduced form/)
-  assert.match(r.stderr, /does NOT check the page/)
-  assert.match(r.stdout, /does not resolve/, 'and an unresolvable source citation blocks')
-})
-
-test('CLI: a manifest citing a real blob at a real commit resolves and passes', () => {
-  const repo = execFileSync('git', ['rev-parse', '--show-toplevel'], { cwd: HERE, encoding: 'utf8' }).trim()
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'design-parity-'))
-  const tracked = 'skills/engineering/ensure-coverage/scripts/coverage-ledger.mjs'
-  const m = completeManifest({ source: { ref: 'HEAD', sha: 'HEAD', path: tracked, kind: 'react' } })
-  m.rows = m.rows.map((r) => ({ ...r, from: r.from ? `${tracked}:10` : r.from }))
-  fs.writeFileSync(path.join(dir, 'm.json'), JSON.stringify(m))
-  const r = run(['validate', path.join(dir, 'm.json'), '--root', repo], repo)
-  assert.equal(r.status, 0, `${r.stdout}\n${r.stderr}`)
-  assert.match(r.stdout, /page unchecked/, 'the pass says what it did not check')
-})
-
-test('CLI: --observed turns the reduced form into the real verdict, and divergence exits 1', () => {
-  const repo = execFileSync('git', ['rev-parse', '--show-toplevel'], { cwd: HERE, encoding: 'utf8' }).trim()
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'design-parity-'))
-  const tracked = 'skills/engineering/ensure-coverage/scripts/coverage-ledger.mjs'
-  const m = completeManifest({ source: { ref: 'HEAD', sha: 'HEAD', path: tracked, kind: 'react' } })
-  m.rows = m.rows.map((r) => ({ ...r, from: r.from ? `${tracked}:10` : r.from }))
-  fs.writeFileSync(path.join(dir, 'm.json'), JSON.stringify(m))
-
-  // Every row expects '0px'; measure one of them wrong.
-  const runs = FLOOR_VIEWPORTS.map((viewport) => ({
-    viewport,
-    measurements: [...new Set(expectedRows(ELEMENTS).filter((r) => !r.relation).map((r) => `${r.role}|${r.css}`))]
-      .map((k) => { const [role, css] = k.split('|'); return { role, css, value: role === 'container' && css === 'max-width' ? '448px' : '0px' } }),
-  }))
-  fs.writeFileSync(path.join(dir, 'o.json'), JSON.stringify({ runs }))
-
-  const r = run(['validate', path.join(dir, 'm.json'), '--observed', path.join(dir, 'o.json'), '--root', repo], repo)
-  assert.equal(r.status, 1)
-  assert.match(r.stdout, /divergence\(s\) from the design source/)
-  assert.match(r.stdout, /expected 0px, page has 448px/)
-  assert.ok(!/reduced form/.test(r.stderr), 'with --observed there is no reduced-form caveat')
-})
-
-test('CLI: scaffold prints a manifest skeleton; probe prints evaluatable JS', () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'design-parity-'))
-  const s = run(['scaffold', '--source', 'proto/x:proto.tsx', '--surface', 'charge-form', '--url', '/dashboard', '--role', `primary=${ELEMENTS.primary}`], dir)
-  assert.equal(s.status, 0, s.stderr)
-  assert.match(s.stdout, /surface: charge-form/)
-  assert.match(s.stdout, /id: primary\.scale/)
-
-  fs.writeFileSync(path.join(dir, 'm.json'), JSON.stringify({ surface: 's', elements: ELEMENTS, viewports: [375] }))
-  const p = run(['probe', 'm.json', '--viewport', '375'], dir)
-  assert.equal(p.status, 0, p.stderr)
-  assert.match(p.stdout, /getComputedStyle/)
-  assert.doesNotThrow(() => new Function(`return typeof (${p.stdout.trim()})`.replace('getComputedStyle', 'globalThis.__x')))
-})
-
-test('CLI: an unresolvable ref leaves `sha:` unfilled rather than copying the moving ref in', () => {
-  // A branch that lives in another repo (the prototype case) must not come back as
-  // a manifest that LOOKS pinned. The placeholder is what makes `validate` and the
-  // next reader both notice.
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'design-parity-'))
-  const r = run(['scaffold', '--source', 'proto/not-here:proto.tsx', '--surface', 's', '--url', '/u', '--role', 'primary=#a'], dir)
-  assert.equal(r.status, 0)
-  assert.match(r.stdout, /sha: <commit-sha>/)
-  assert.ok(!r.stdout.includes('sha: proto/not-here'))
-  assert.match(r.stderr, /could not resolve/)
-})
-
-test('CLI: usage errors exit 2, never 0', () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'design-parity-'))
-  assert.equal(run([], dir).status, 2)
-  assert.equal(run(['validate', 'nope.json'], dir).status, 2)
-  assert.equal(run(['scaffold'], dir).status, 2)
-})