@1aboveio/skills 1.0.8 → 1.0.9

package/skills/engineering/e2e-test/scripts/presentation-checks.test.mjs

@@ -1,106 +0,0 @@
-// Unit tests for the pure overflow predicate (issue #195). Run: `node --test`.
-// The Playwright wrapper (assertNoHorizontalOverflow) needs a real browser and is
-// exercised downstream; this proves the detection logic without one.
-
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import {
-  findHorizontalOverflow, PRESENTATION_VIEWPORT_FLOOR,
-  rectsIntersect, findOverlaps, applyOverlapAllowlist,
-} from './presentation-checks.mjs'
-
-// helper: build an element with a rect + interactive flag
-const el = (selector, [left, top, right, bottom], interactive = false) =>
-  ({ selector, rect: { left, top, right, bottom, width: right - left, height: bottom - top }, interactive })
-
-const VW = 375
-
-test('no overflow when everything fits', () => {
-  const els = [
-    { selector: 'header', left: 0, right: 375, width: 375, height: 60 },
-    { selector: '.card', left: 16, right: 359, width: 343, height: 120 },
-  ]
-  assert.deepEqual(findHorizontalOverflow(els, VW), [])
-})
-
-test('flags an element wider than the viewport (right overflow)', () => {
-  const els = [{ selector: '.wide-table', left: 0, right: 520, width: 520, height: 200 }]
-  const out = findHorizontalOverflow(els, VW)
-  assert.equal(out.length, 1)
-  assert.equal(out[0].selector, '.wide-table')
-  assert.equal(out[0].overflowPx, 145) // 520 - 375
-})
-
-test('flags a negatively-positioned element (left overflow)', () => {
-  const els = [{ selector: '#drawer', left: -120, right: 200, width: 320, height: 400 }]
-  const out = findHorizontalOverflow(els, VW)
-  assert.equal(out.length, 1)
-  assert.equal(out[0].overflowPx, 120)
-})
-
-test('respects the tolerance band (sub-pixel rounding does not flag)', () => {
-  const els = [{ selector: '.x', left: 0, right: 375.5, width: 375.5, height: 10 }]
-  assert.deepEqual(findHorizontalOverflow(els, VW, { tolerancePx: 1 }), [])
-})
-
-test('ignore list suppresses intentional overflow by selector substring', () => {
-  const els = [{ selector: '.carousel-track', left: 0, right: 900, width: 900, height: 150 }]
-  assert.deepEqual(findHorizontalOverflow(els, VW, { ignore: ['carousel'] }), [])
-})
-
-test('zero-size (unrendered) elements are skipped', () => {
-  const els = [{ selector: '.hidden', left: 0, right: 999, width: 0, height: 0 }]
-  assert.deepEqual(findHorizontalOverflow(els, VW), [])
-})
-
-test('viewport floor is the documented 375 + 1280 pair', () => {
-  assert.deepEqual(PRESENTATION_VIEWPORT_FLOOR.map((v) => v.width), [375, 1280])
-})
-
-// ---------- overlap detection (presentation:spatial) ----------
-
-test('rectsIntersect: overlapping yes, separated no, touching (within tol) no', () => {
-  const a = { left: 0, top: 0, right: 100, bottom: 50 }
-  assert.equal(rectsIntersect(a, { left: 50, top: 25, right: 150, bottom: 75 }), true)
-  assert.equal(rectsIntersect(a, { left: 200, top: 0, right: 300, bottom: 50 }), false)
-  assert.equal(rectsIntersect(a, { left: 100, top: 0, right: 200, bottom: 50 }), false) // edge-touch
-})
-
-test('findOverlaps: flags a collision but skips pure nesting', () => {
-  const parent = el('.card', [0, 0, 200, 200])
-  const child = el('.card .title', [10, 10, 190, 40]) // nested inside parent
-  const stray = el('.badge', [180, 180, 260, 260]) // overlaps parent corner
-  const pairs = findOverlaps([parent, child, stray])
-  // parent⨯child is nesting (skipped); parent⨯stray is a real overlap
-  assert.equal(pairs.length, 1)
-  assert.equal(pairs[0].b, '.badge')
-})
-
-test('applyOverlapAllowlist: gated suppression yields a census entry', () => {
-  const pairs = [{ a: '.carousel-track', b: '.carousel-slide', aInteractive: false, bInteractive: false }]
-  const r = applyOverlapAllowlist(pairs, [{ match: 'carousel', category: 'decorative', reason: 'z-stacked slides' }])
-  assert.equal(r.reported.length, 0)
-  assert.equal(r.suppressed.length, 1)
-  assert.equal(r.suppressed[0].reason, 'z-stacked slides')
-})
-
-test('applyOverlapAllowlist: entry without category/reason is rejected (still fails)', () => {
-  const pairs = [{ a: '.x', b: '.y', aInteractive: false, bInteractive: false }]
-  const r = applyOverlapAllowlist(pairs, [{ match: '.x' }])
-  assert.equal(r.suppressed.length, 0)
-  assert.equal(r.rejected.length, 1)
-})
-
-test('applyOverlapAllowlist: cannot allowlist an overlap that occludes an interactive element', () => {
-  const pairs = [{ a: '.overlay', b: 'button#save', aInteractive: false, bInteractive: true }]
-  const r = applyOverlapAllowlist(pairs, [{ match: '.overlay', category: 'decorative', reason: 'hero flourish' }])
-  assert.equal(r.suppressed.length, 0)
-  assert.equal(r.rejected.length, 1)
-  assert.match(r.rejected[0].why, /interactive/)
-})
-
-test('applyOverlapAllowlist: unmatched overlap is reported', () => {
-  const pairs = [{ a: '.a', b: '.b', aInteractive: false, bInteractive: false }]
-  const r = applyOverlapAllowlist(pairs, [{ match: '.zzz', category: 'decorative', reason: 'n/a' }])
-  assert.equal(r.reported.length, 1)
-})

package/skills/engineering/e2e-test/scripts/presentation-perceivability.test.mjs

@@ -1,117 +0,0 @@
-// Unit tests for the pure Perceivability cores (issue #196). Run: `node --test`.
-// The Playwright wrappers (assertContrast / assertHiddenFromWrongRole /
-// assertRemovedAfterMutation) need a real browser + @axe-core/playwright and are
-// exercised downstream; the contrast math, axe classifier, and predicates are
-// proven here without one.
-
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import {
-  relativeLuminance, contrastRatio, meetsContrast, classifyAxeContrast,
-  isEffectivelyHidden, isExemptFromContrast, assessElementContrast, AbstainError,
-} from './presentation-perceivability.mjs'
-
-const WHITE = [255, 255, 255]
-const BLACK = [0, 0, 0]
-
-// ---------- WCAG math ----------
-
-test('relative luminance: white ~1, black 0', () => {
-  assert.ok(Math.abs(relativeLuminance(WHITE) - 1) < 1e-9)
-  assert.equal(relativeLuminance(BLACK), 0)
-})
-
-test('contrast ratio: black on white is 21:1, white on white is 1:1', () => {
-  assert.ok(Math.abs(contrastRatio(BLACK, WHITE) - 21) < 1e-6)
-  assert.ok(Math.abs(contrastRatio(WHITE, WHITE) - 1) < 1e-9)
-  assert.equal(contrastRatio(BLACK, WHITE), contrastRatio(WHITE, BLACK)) // symmetric
-})
-
-test('meetsContrast: black text on white passes AA', () => {
-  const r = meetsContrast(BLACK, WHITE)
-  assert.equal(r.threshold, 4.5)
-  assert.equal(r.pass, true)
-})
-
-test('meetsContrast: a faint gray fails both text and non-text', () => {
-  const faint = [170, 170, 170] // ~2.3:1 on white
-  assert.equal(meetsContrast(faint, WHITE).pass, false)
-  assert.equal(meetsContrast(faint, WHITE, { nonText: true }).pass, false)
-})
-
-test('meetsContrast: threshold flips between text (4.5) and non-text (3.0)', () => {
-  const mid = [130, 130, 130] // ~3.8:1 on white — between 3 and 4.5
-  const asText = meetsContrast(mid, WHITE)
-  const asUi = meetsContrast(mid, WHITE, { nonText: true })
-  assert.equal(asText.threshold, 4.5)
-  assert.equal(asText.pass, false, 'fails as normal text')
-  assert.equal(asUi.threshold, 3)
-  assert.equal(asUi.pass, true, 'passes as a UI component / large text')
-})
-
-// ---------- axe classifier ----------
-
-test('classifyAxeContrast: no findings → pass', () => {
-  assert.equal(classifyAxeContrast({ violations: [], incomplete: [] }).status, 'pass')
-  assert.equal(classifyAxeContrast({}).status, 'pass')
-})
-
-test('classifyAxeContrast: a color-contrast violation → fail', () => {
-  const res = { violations: [{ id: 'color-contrast', nodes: [{ target: ['.btn'] }] }], incomplete: [] }
-  const c = classifyAxeContrast(res)
-  assert.equal(c.status, 'fail')
-  assert.equal(c.count, 1)
-})
-
-test('classifyAxeContrast: incomplete (gradient/image) → abstain, not pass', () => {
-  const res = { violations: [], incomplete: [{ id: 'color-contrast', nodes: [{ target: ['.hero'] }] }] }
-  assert.equal(classifyAxeContrast(res).status, 'abstain')
-})
-
-test('classifyAxeContrast: violation outranks incomplete; other rule ids ignored', () => {
-  const res = {
-    violations: [{ id: 'color-contrast', nodes: [{}] }, { id: 'label', nodes: [{}] }],
-    incomplete: [{ id: 'color-contrast', nodes: [{}] }],
-  }
-  const c = classifyAxeContrast(res)
-  assert.equal(c.status, 'fail')
-  assert.equal(c.count, 1, 'only color-contrast nodes counted')
-})
-
-// ---------- visibility / exemption predicates ----------
-
-test('isEffectivelyHidden: catches display/visibility/opacity/aria/zero-size', () => {
-  assert.equal(isEffectivelyHidden({ style: { display: 'none' } }), true)
-  assert.equal(isEffectivelyHidden({ style: { visibility: 'hidden' } }), true)
-  assert.equal(isEffectivelyHidden({ style: { opacity: '0' } }), true)
-  assert.equal(isEffectivelyHidden({ ariaHidden: true }), true)
-  assert.equal(isEffectivelyHidden({ rect: { width: 0, height: 10 } }), true)
-})
-
-test('isEffectivelyHidden: a normal visible element is not hidden', () => {
-  assert.equal(isEffectivelyHidden({ style: { display: 'block', visibility: 'visible', opacity: '1' }, rect: { width: 100, height: 40 } }), false)
-})
-
-test('isExemptFromContrast: disabled controls are exempt (WCAG), normal are not', () => {
-  assert.equal(isExemptFromContrast({ disabled: true }), true)
-  assert.equal(isExemptFromContrast({ ariaDisabled: true }), true)
-  assert.equal(isExemptFromContrast({}), false)
-})
-
-test('assessElementContrast (manual/escalation path) composes exemption + threshold', () => {
-  // disabled → exempt, regardless of (bad) colors
-  assert.equal(assessElementContrast(WHITE, WHITE, { disabled: true }).status, 'exempt')
-  // enabled, good contrast → pass
-  assert.equal(assessElementContrast(BLACK, WHITE).status, 'pass')
-  // enabled, faint gray → fail, with ratio reported
-  const fail = assessElementContrast([170, 170, 170], WHITE)
-  assert.equal(fail.status, 'fail')
-  assert.ok(fail.ratio < fail.threshold)
-})
-
-test('AbstainError is distinguishable from a hard failure', () => {
-  const e = new AbstainError('x', { count: 2 })
-  assert.equal(e.abstain, true)
-  assert.equal(e.name, 'AbstainError')
-  assert.ok(e instanceof Error)
-})

package/skills/engineering/e2e-test/scripts/presentation-reachability.test.mjs

@@ -1,69 +0,0 @@
-// Unit tests for the pure Reachability & Affordance cores (issue #197).
-// Run: `node --test`. The Playwright wrappers (crawlReachableRoutes,
-// assertNoNavOrphans, assertTargetSizes, assertFocusVisible, assertModalTrapsFocus,
-// assertRouteNotReachable) need a real browser and are exercised downstream.
-
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { findNavOrphans, meetsTargetSize, hasVisibleFocusIndicator } from './presentation-reachability.mjs'
-
-// ---------- nav-orphan set diff ----------
-
-test('findNavOrphans: routes in manifest but not reachable are orphans', () => {
-  const manifest = ['/', '/dashboard', '/settings', '/secret-report']
-  const reachable = ['/', '/dashboard', '/settings']
-  assert.deepEqual(findNavOrphans(manifest, reachable), ['/secret-report'])
-})
-
-test('findNavOrphans: none when everything is reachable', () => {
-  assert.deepEqual(findNavOrphans(['/', '/a'], ['/', '/a', '/extra']), [])
-})
-
-test('findNavOrphans: ignore by exact id and by prefix glob', () => {
-  const manifest = ['/', '/auth/callback', '/admin/secret', '/deep/x', '/deep/y']
-  const reachable = ['/']
-  // exact ignore for the callback, prefix ignore for everything under /deep
-  const orphans = findNavOrphans(manifest, reachable, { ignore: ['/auth/callback', '/deep/*'] })
-  assert.deepEqual(orphans, ['/admin/secret'])
-})
-
-// ---------- target size ----------
-
-test('meetsTargetSize: 44x44 passes, smaller fails with the short dimension', () => {
-  assert.equal(meetsTargetSize({ width: 44, height: 44 }).pass, true)
-  const r = meetsTargetSize({ width: 30, height: 44 })
-  assert.equal(r.pass, false)
-  assert.deepEqual(r.short, ['width'])
-  assert.deepEqual(meetsTargetSize({ width: 10, height: 10 }).short, ['width', 'height'])
-})
-
-test('meetsTargetSize: custom minimum', () => {
-  assert.equal(meetsTargetSize({ width: 24, height: 24 }, 24).pass, true)
-  assert.equal(meetsTargetSize({ width: 24, height: 24 }, 44).pass, false)
-})
-
-// ---------- focus indicator ----------
-
-const NO_OUTLINE = { outlineStyle: 'none', outlineWidth: '0px', outlineColor: 'rgb(0,0,0)', boxShadow: 'none' }
-
-test('hasVisibleFocusIndicator: outline appearing on focus → visible', () => {
-  const focused = { outlineStyle: 'solid', outlineWidth: '2px', outlineColor: 'rgb(0,90,255)', boxShadow: 'none' }
-  assert.equal(hasVisibleFocusIndicator(NO_OUTLINE, focused), true)
-})
-
-test('hasVisibleFocusIndicator: box-shadow ring appearing on focus → visible', () => {
-  const focused = { ...NO_OUTLINE, boxShadow: '0 0 0 3px rgba(0,90,255,.5)' }
-  assert.equal(hasVisibleFocusIndicator(NO_OUTLINE, focused), true)
-})
-
-test('hasVisibleFocusIndicator: no change between states → NOT visible (the bug)', () => {
-  // outline:none in both states and identical shadow — the missing-focus-ring case
-  assert.equal(hasVisibleFocusIndicator(NO_OUTLINE, { ...NO_OUTLINE }), false)
-})
-
-test('hasVisibleFocusIndicator: zero-width color-only outline change → NOT visible', () => {
-  // `0px solid red` → `0px solid blue` paints nothing; must not false-pass
-  const blurred = { outlineStyle: 'solid', outlineWidth: '0px', outlineColor: 'rgb(255,0,0)', boxShadow: 'none' }
-  const focused = { outlineStyle: 'solid', outlineWidth: '0px', outlineColor: 'rgb(0,0,255)', boxShadow: 'none' }
-  assert.equal(hasVisibleFocusIndicator(blurred, focused), false)
-})

package/skills/engineering/e2e-test/scripts/presentation-render-health.test.mjs

@@ -1,98 +0,0 @@
-// Unit tests for the render-health spine — the pure core, no browser.
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import {
-  isFatalConsole,
-  isFatalResponse,
-  hasFatalMarker,
-  evaluateRenderHealth,
-  assertHealthyThrough,
-} from './presentation-render-health.mjs'
-
-// Minimal fake Playwright page: records listeners, lets a test emit events, and
-// returns body text from evaluate(). Enough to exercise the watcher/compose path
-// without a browser.
-function fakePage(bodyText = '') {
-  const handlers = {}
-  return {
-    on(ev, fn) { (handlers[ev] ||= []).push(fn) },
-    emit(ev, arg) { (handlers[ev] || []).forEach((f) => f(arg)) },
-    async evaluate() { return bodyText },
-  }
-}
-
-test('console.error is fatal; warning is not', () => {
-  assert.equal(isFatalConsole('error', 'boom'), true)
-  assert.equal(isFatalConsole('warning', 'meh'), false)
-  assert.equal(isFatalConsole('log', 'hi'), false)
-})
-
-test('ignored console substrings are not fatal', () => {
-  assert.equal(isFatalConsole('error', 'Download the React DevTools', { ignore: ['React DevTools'] }), false)
-})
-
-test('http >= 500 is fatal; < 500 is not', () => {
-  assert.equal(isFatalResponse(500, '/api/x'), true)
-  assert.equal(isFatalResponse(503, '/api/x'), true)
-  assert.equal(isFatalResponse(404, '/api/x'), false)
-  assert.equal(isFatalResponse(200, '/api/x'), false)
-})
-
-test('cross-origin 5xx is ignored (externals are faked, not graded)', () => {
-  assert.equal(isFatalResponse(500, 'https://stripe.com/v1/x', { origin: 'http://localhost:3000' }), false)
-  assert.equal(isFatalResponse(500, 'http://localhost:3000/api/x', { origin: 'http://localhost:3000' }), true)
-  assert.equal(isFatalResponse(500, '/api/x', { origin: 'http://localhost:3000' }), true) // relative = first-party
-})
-
-test('error-boundary markers are detected in body text', () => {
-  assert.equal(hasFatalMarker('Application error: a client-side exception has occurred'), true)
-  assert.equal(hasFatalMarker("Cannot read properties of undefined (reading 'id')"), true)
-  assert.equal(hasFatalMarker('All good here'), false)
-})
-
-test('the /tasks bug shape fails render-health (pageerror on mount)', () => {
-  const v = evaluateRenderHealth({
-    pageerrors: [{ message: "Cannot read properties of undefined (reading 'id')" }],
-  })
-  assert.equal(v.healthy, false)
-  assert.equal(v.offenders[0].kind, 'pageerror')
-  assert.match(v.offenders[0].detail, /reading 'id'/)
-})
-
-test('a clean render is healthy', () => {
-  const v = evaluateRenderHealth({
-    consoles: [{ type: 'log', text: 'mounted' }, { type: 'warning', text: 'deprecated' }],
-    responses: [{ status: 200, url: '/api/tasks/list' }],
-    bodyText: 'Tasks\nNo tasks match these filters.',
-  })
-  assert.equal(v.healthy, true)
-  assert.deepEqual(v.offenders, [])
-})
-
-test('assertHealthyThrough fails when an error fires DURING the interaction (mutate-health)', async () => {
-  const page = fakePage()
-  await assert.rejects(
-    assertHealthyThrough(page, async () => {
-      // simulate an uncaught error thrown while a delete/submit runs
-      page.emit('pageerror', { message: "Cannot read properties of undefined (reading 'id')" })
-    }),
-    /render-health.*reading 'id'/s,
-  )
-})
-
-test('assertHealthyThrough passes a clean interaction', async () => {
-  const page = fakePage('Tasks\nDeleted.')
-  await assertHealthyThrough(page, async () => { /* clean mutation */ })
-})
-
-test('aggregates multiple offenders (pageerror + console + 5xx + boundary)', () => {
-  const v = evaluateRenderHealth({
-    pageerrors: [{ message: 'x is not a function' }],
-    consoles: [{ type: 'error', text: 'render failed' }],
-    responses: [{ status: 500, url: '/api/tasks/list' }],
-    bodyText: 'Unhandled Runtime Error',
-  }, { origin: 'http://localhost:3000' })
-  assert.equal(v.healthy, false)
-  assert.deepEqual(v.offenders.map((o) => o.kind).sort(), ['console.error', 'error-boundary', 'http>=500', 'pageerror'])
-})

package/skills/engineering/e2e-test/scripts/presentation-sweep.test.mjs

@@ -1,71 +0,0 @@
-// Unit tests for the sweep's pure core (planning + summarize) — no browser.
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { planRoutes, summarize } from './presentation-sweep.mjs'
-
-test('static routes plan to themselves; route-kind filter applies', () => {
-  const plan = planRoutes({ surfaces: [
-    { route: '/tasks', kind: 'route' },
-    { route: '/api/tasks/list', kind: 'api' }, // not a browser route → excluded
-    { route: '/dashboard', kind: 'route' },
-  ] })
-  assert.deepEqual(plan, [
-    { route: '/tasks', url: '/tasks' },
-    { route: '/dashboard', url: '/dashboard' },
-  ])
-})
-
-test('dynamic route with a resolver becomes a concrete url', () => {
-  const plan = planRoutes(
-    { routes: [{ route: '/tasks/[taskRunId]', kind: 'route' }] },
-    { paramResolver: (r) => (r.includes('taskRunId') ? '/tasks/tr_seeded_1' : null) },
-  )
-  assert.deepEqual(plan, [{ route: '/tasks/[taskRunId]', url: '/tasks/tr_seeded_1' }])
-})
-
-test('dynamic route with NO resolver answer is blocked, not skipped or passed', () => {
-  const plan = planRoutes({ routes: [{ route: '/tasks/[id]', kind: 'route' }] })
-  assert.equal(plan.length, 1)
-  assert.equal(plan[0].url, null)
-  assert.match(plan[0].blocked, /param resolver/)
-})
-
-test('ignore list drops routes', () => {
-  const plan = planRoutes(
-    { routes: [{ route: '/tasks', kind: 'route' }, { route: '/_debug/x', kind: 'route' }] },
-    { ignore: ['/_debug'] },
-  )
-  assert.deepEqual(plan.map((p) => p.route), ['/tasks'])
-})
-
-test('accepts a bare string manifest entry', () => {
-  const plan = planRoutes({ routes: ['/a', '/b'] })
-  assert.deepEqual(plan.map((p) => p.url), ['/a', '/b'])
-})
-
-test('summarize: a render-health fail flips the gate to non-ok', () => {
-  const s = summarize([
-    { route: '/dashboard', levels: [{ level: 'presentation:render-health', status: 'pass' }] },
-    { route: '/tasks', levels: [
-      { level: 'presentation:render-health', status: 'fail', evidence: "pageerror: reading 'id'" },
-      { level: 'presentation:spatial', status: 'blocked', evidence: 'not assessable' },
-    ] },
-  ])
-  assert.equal(s.ok, false)
-  assert.equal(s.failedCount, 2) // the fail + the blocked
-  assert.deepEqual(s.viewportFloor, [375, 1280])
-  const tasksHealth = s.results.find((r) => r.route === '/tasks' && r.level === 'presentation:render-health')
-  assert.equal(tasksHealth.status, 'fail')
-})
-
-test('summarize: all-pass is ok', () => {
-  const s = summarize([
-    { route: '/dashboard', levels: [
-      { level: 'presentation:render-health', status: 'pass' },
-      { level: 'presentation:spatial', status: 'pass' },
-    ] },
-  ])
-  assert.equal(s.ok, true)
-  assert.equal(s.failedCount, 0)
-})

package/skills/engineering/e2e-test/scripts/presentation-temporal.test.mjs

@@ -1,59 +0,0 @@
-// Unit tests for the pure Temporal-stability cores (issue #199). Run: `node --test`.
-// The Playwright wrappers (assertNoFirstPartyShift / assertNoThirdPartyShift /
-// assertNoDynamicViewportShift) need a real browser and are exercised downstream.
-
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { findLayoutShift, cumulativeShiftScore } from './presentation-temporal.mjs'
-
-const r = (left, top, right, bottom) => ({ rect: { left, top, right, bottom } })
-const at = (selector, left, top, right, bottom) => ({ selector, ...r(left, top, right, bottom) })
-
-// ---------- findLayoutShift ----------
-
-test('no shift when geometry is unchanged', () => {
-  const snap = [at('.header', 0, 0, 375, 60), at('.cta', 0, 100, 375, 140)]
-  assert.deepEqual(findLayoutShift(snap, snap), [])
-})
-
-test('flags an element pushed down by injected content', () => {
-  const before = [at('.cta', 0, 100, 375, 140)]
-  const after = [at('.cta', 0, 260, 375, 300)] // shoved down 160px (a banner injected above)
-  const shifted = findLayoutShift(before, after)
-  assert.equal(shifted.length, 1)
-  assert.equal(shifted[0].selector, '.cta')
-  assert.equal(shifted[0].dy, 160)
-})
-
-test('sub-tolerance movement is not a shift', () => {
-  const before = [at('.x', 0, 100, 375, 140)]
-  const after = [at('.x', 0, 101, 375, 141)] // 1px < default 2px tolerance
-  assert.deepEqual(findLayoutShift(before, after), [])
-})
-
-test('a newly-injected element is not itself counted as a shift', () => {
-  const before = [at('.cta', 0, 100, 375, 140)]
-  const after = [at('.cta', 0, 100, 375, 140), at('.banner', 0, 0, 375, 80)] // banner is new, cta did not move
-  assert.deepEqual(findLayoutShift(before, after), [])
-})
-
-test('an element that disappears is not a shift of a stable element', () => {
-  const before = [at('.spinner', 0, 0, 50, 50), at('.cta', 0, 100, 375, 140)]
-  const after = [at('.cta', 0, 100, 375, 140)] // spinner gone, cta stable
-  assert.deepEqual(findLayoutShift(before, after), [])
-})
-
-// ---------- cumulativeShiftScore ----------
-
-test('cumulativeShiftScore sums values without recent input', () => {
-  const entries = [
-    { value: 0.05, hadRecentInput: false },
-    { value: 0.10, hadRecentInput: false },
-    { value: 0.30, hadRecentInput: true }, // user-initiated — excluded
-  ]
-  assert.ok(Math.abs(cumulativeShiftScore(entries) - 0.15) < 1e-9)
-})
-
-test('cumulativeShiftScore is 0 for no entries', () => {
-  assert.equal(cumulativeShiftScore([]), 0)
-})

package/skills/engineering/e2e-test/scripts/project-route-manifest.test.mjs

@@ -1,76 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { projectManifest, staleOverlayEntries } from './project-route-manifest.mjs'
-
-const INVENTORY = {
-  surfaces: [
-    { id: '/tasks', kind: 'route', class: 'read', reachability: 'reachable' },
-    { id: '/tasks/[id]', kind: 'route', class: 'detail', reachability: 'reachable' },
-    { id: '/settings/models', kind: 'route', class: 'mutation', reachability: 'reachable' },
-    { id: '/legacy', kind: 'route', class: 'read', reachability: 'reachable' },
-    { id: '/api/tasks/list', kind: 'api', class: 'read' }, // not a browser route
-    { id: 'tasks_table', kind: 'table' },
-  ],
-}
-
-test('projects only browser routes, default tier from class, sorted', () => {
-  const m = projectManifest(INVENTORY)
-  assert.equal(m.generated, true)
-  assert.deepEqual(m.routes, [
-    { path: '/legacy', tier: 1 },
-    { path: '/settings/models', tier: 2 },
-    { path: '/tasks', tier: 1 },
-    { path: '/tasks/[id]', tier: 2 },
-  ])
-})
-
-test('overlay raises tier and drops ignored routes', () => {
-  const overlay = { routes: { '/tasks': { tier: 3 }, '/legacy': { ignore: true } }, spatialIgnore: ['.sticky-header'] }
-  const m = projectManifest(INVENTORY, overlay)
-  assert.equal(m.routes.find((r) => r.path === '/tasks').tier, 3)
-  assert.ok(!m.routes.some((r) => r.path === '/legacy'), 'ignored route dropped from sweep')
-  assert.deepEqual(m.spatialIgnore, ['.sticky-header'])
-})
-
-test('overlay specs are passed through but optional (informational only)', () => {
-  const m = projectManifest(INVENTORY, { routes: { '/tasks': { specs: ['render/tasks.spec.ts'] } } })
-  assert.deepEqual(m.routes.find((r) => r.path === '/tasks').specs, ['render/tasks.spec.ts'])
-  // a route with no overlay has no specs key
-  assert.equal('specs' in m.routes.find((r) => r.path === '/settings/models'), false)
-})
-
-test('same inventory + overlay → identical manifest (no drift, stable diff)', () => {
-  const a = projectManifest(INVENTORY, { routes: { '/tasks': { tier: 3 } } })
-  const b = projectManifest(INVENTORY, { routes: { '/tasks': { tier: 3 } } })
-  assert.deepEqual(a, b)
-})
-
-test('staleOverlayEntries flags curation for a route no longer in inventory', () => {
-  const stale = staleOverlayEntries(INVENTORY, { routes: { '/tasks': { tier: 3 }, '/removed': { ignore: true } } })
-  assert.deepEqual(stale, ['/removed'])
-})
-
-import { spawnSync } from 'node:child_process'
-import { fileURLToPath } from 'node:url'
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-
-const CLI = fileURLToPath(new URL('./project-route-manifest.mjs', import.meta.url))
-
-test('CLI: --help prints usage; a missing inventory is a one-line error, not a stack trace', () => {
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'prm-cli-'))
-  try {
-    const help = spawnSync('node', [CLI, '--help'], { cwd, encoding: 'utf8' })
-    assert.equal(help.status, 0)
-    assert.match(help.stdout, /usage: project-route-manifest\.mjs/)
-    const missing = spawnSync('node', [CLI, '--inventory', path.join(cwd, 'nope.json')], { cwd, encoding: 'utf8' })
-    assert.equal(missing.status, 1)
-    assert.match(missing.stderr, /inventory not found/)
-    assert.doesNotMatch(missing.stderr, /at Object\.|node:internal/, 'no stack trace')
-    assert.deepEqual(fs.readdirSync(cwd), [], 'nothing written')
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true })
-  }
-})

package/skills/engineering/engineering-runtime/engineering-runtime.test.mjs

@@ -1,68 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
-import { dirname, join, relative, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const RUNTIME_DIR = dirname(fileURLToPath(import.meta.url));
-const REPO_ROOT = join(RUNTIME_DIR, '..', '..', '..');
-const MANIFEST = JSON.parse(readFileSync(join(REPO_ROOT, 'skills', 'distribution', 'manifest.json'), 'utf8'));
-
-// @covers package:engineering-runtime
-// @level integration
-test('runtime parser dependency metadata lives in the installed scripts directory', () => {
-  const scripts = join(RUNTIME_DIR, 'scripts');
-  const packageJson = JSON.parse(readFileSync(join(scripts, 'package.json'), 'utf8'));
-  const packageLock = JSON.parse(readFileSync(join(scripts, 'package-lock.json'), 'utf8'));
-
-  assert.equal(existsSync(join(RUNTIME_DIR, 'package.json')), false);
-  assert.equal(existsSync(join(RUNTIME_DIR, 'package-lock.json')), false);
-  // The lockfile must install exactly the version package.json declares.
-  assert.ok(packageJson.dependencies['js-yaml'], 'the runtime parser depends on js-yaml');
-  assert.equal(packageLock.packages['node_modules/js-yaml'].version, packageJson.dependencies['js-yaml']);
-});
-
-function modules(dir) {
-  const found = [];
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    if (entry.name === 'node_modules' || entry.name.endsWith('-workspace')) continue;
-    const path = join(dir, entry.name);
-    if (entry.isDirectory()) found.push(...modules(path));
-    else if (entry.name.endsWith('.mjs') && !entry.name.endsWith('.test.mjs')) found.push(path);
-  }
-  return found;
-}
-
-// @covers package:engineering-runtime
-// @level integration
-test('every first-party Workflow consumer resolves one implementation in source and flat layouts', () => {
-  const workflow = MANIFEST.groups.find((group) => group.id === 'engineering-workflow');
-  const canonical = join(RUNTIME_DIR, 'scripts', 'main-module.mjs');
-  const flatCanonical = join('/flat-skills', 'engineering-runtime', 'scripts', 'main-module.mjs');
-  const consumers = [];
-
-  for (const member of workflow.members.filter((candidate) => candidate.role === 'skill')) {
-    const skillDir = join(REPO_ROOT, member.path);
-    for (const file of modules(skillDir)) {
-      const text = readFileSync(file, 'utf8');
-      if (!/\bisMainModule\s*\(/.test(text)) continue;
-      const staticImport = /import\s+\{\s*isMainModule\s*\}\s+from\s+['"]([^'"]+)['"]/.exec(text);
-      const dynamicImport = /await import\(['"]([^'"]+)['"]\)/.exec(text);
-      const imported = staticImport ?? dynamicImport;
-      assert.ok(imported, `${relative(REPO_ROOT, file)} calls isMainModule without resolving it from the runtime package`);
-      assert.equal(resolve(dirname(file), imported[1]), canonical, `${relative(REPO_ROOT, file)} misses the source runtime`);
-
-      const installedFile = join('/flat-skills', member.installName, relative(skillDir, file));
-      assert.equal(
-        resolve(dirname(installedFile), imported[1]),
-        flatCanonical,
-        `${relative(REPO_ROOT, file)} misses the flat-installed runtime`,
-      );
-      consumers.push(relative(REPO_ROOT, file));
-    }
-  }
-
-  // Shipped members only: the archived resolve-issues/resolve-release scripts left this census when
-  // those names became aliases (they were never packaged).
-  assert.ok(consumers.length >= 17, `the Workflow consumer census found only ${consumers.length} guarded scripts`);
-});