@event4u/agent-config 14.11.0 → 14.13.0

package/src/scripts/_lib/auto_dispatch.corpus.test.ts

@@ -1,150 +0,0 @@
-/**
- * Deterministic `parallelizable:` classifier recall + false-positive measurement
- * against the orchestration corpus (road-to-orchestration-scope-decision Phase 2
- * / road-to-subagent-value-realization-followup Phase 1 Step 3).
- *
- * The corpus tasks (`internal/bench/orchestration/corpus/*.md`) each document a
- * "Classification signal" and an expected dispatch mode. This encodes those
- * documented signals as `TaskSignals` and asserts `classifyTask` (the pure v1
- * classifier) fires the expected mode — recall on the modes v1 covers
- * (`do-in-parallel`, `do-in-steps`), FP=0 on the negative control, and the
- * documented scope gap (v1 has no `do-competitively` / verdict mode).
- *
- * This is the durable, reproducible "record actual hit/miss counts" deliverable
- * + a regression guard for the classifier. Deterministic — no spend, no agents.
- */
-import { describe, expect, it } from 'vitest';
-
-import {
-    classifyLookup,
-    classifyTask,
-    type ActivationInputs,
-    type LookupClass,
-    type TaskSignals,
-} from './auto_dispatch.js';
-
-const ON: ActivationInputs = { halted: false, subagent_spawn: true };
-
-/** Corpus signals transcribed from each task's documented "Classification signal". */
-const CORPUS: Array<{
-    id: string;
-    signals: TaskSignals;
-    expectMode: 'do-in-parallel' | 'do-in-steps' | null;
-    note: string;
-}> = [
-    {
-        id: 'orch-01',
-        signals: { parallelizable: 'files', independent_slices: 4, size_estimate: 4, ordered_plan: false },
-        expectMode: 'do-in-parallel',
-        note: 'N independent files, same analysis shape',
-    },
-    {
-        id: 'orch-02',
-        signals: { ordered_plan: true, size_estimate: 5, independent_slices: 0 },
-        expectMode: 'do-in-steps',
-        note: 'explicit ordered numbered plan',
-    },
-    {
-        id: 'orch-03',
-        signals: { size_estimate: 3, independent_slices: 0, ordered_plan: false },
-        expectMode: null,
-        note: 'do-competitively — NOT a v1 DispatchMode (documented scope gap)',
-    },
-    {
-        id: 'pv-01',
-        signals: { size_estimate: 2, independent_slices: 0, ordered_plan: false },
-        expectMode: null,
-        note: 'verdict dispatch — out of the v1 parallel/steps scope',
-    },
-    {
-        id: 'pv-02',
-        signals: { size_estimate: 1, independent_slices: 0, ordered_plan: false },
-        expectMode: null,
-        note: 'negative control — a clean one-file task MUST NOT dispatch',
-    },
-];
-
-describe('parallelizable classifier — corpus recall', () => {
-    for (const c of CORPUS) {
-        it(`${c.id}: ${c.note}`, () => {
-            const r = classifyTask(c.signals, ON);
-            expect(r.mode).toBe(c.expectMode);
-        });
-    }
-
-    it('recall on v1-covered modes is 2/2 (orch-01 parallel, orch-02 steps)', () => {
-        const covered = CORPUS.filter((c) => c.expectMode !== null);
-        const hits = covered.filter((c) => classifyTask(c.signals, ON).mode === c.expectMode);
-        expect(covered).toHaveLength(2);
-        expect(hits).toHaveLength(2);
-    });
-
-    it('false-positive rate is 0 — the negative control (pv-02) never dispatches', () => {
-        const pv02 = CORPUS.find((c) => c.id === 'pv-02')!;
-        expect(classifyTask(pv02.signals, ON).action).not.toBe('dispatch');
-    });
-
-    it('documents the v1 scope gap: do-competitively (orch-03) + verdict (pv-01) are not classified', () => {
-        for (const id of ['orch-03', 'pv-01']) {
-            const c = CORPUS.find((x) => x.id === id)!;
-            expect(classifyTask(c.signals, ON).mode).toBeNull();
-        }
-    });
-});
-
-/**
- * Lookup-class corpus (L0 — road-to-lean-agent-init Phase 1). The first four
- * entries are the live-observed 2026-07-28 task shapes that burned ~1.21M
- * subagent tokens; each must route to a primitive, never a spawn. The
- * negative controls are non-lookup tasks that must escalate unchanged.
- */
-const LOOKUP_CORPUS: Array<{ id: string; text: string; expect: LookupClass | null }> = [
-    // ── the four observed shapes (live evidence, 2026-07-28 session) ──
-    { id: 'lk-01', text: 'Confirming ExternalApiProviderEnum definition location', expect: 'definition' },
-    { id: 'lk-02', text: 'Confirming GWInput import call sites', expect: 'references' },
-    { id: 'lk-03', text: 'Running check_enforcement_coverage report', expect: 'report-run' },
-    { id: 'lk-04', text: 'Probing candidate strings with tsx', expect: 'string-existence' },
-    // ── generalizations of the same shapes ──
-    { id: 'lk-05', text: 'Where is classifyTask defined?', expect: 'definition' },
-    { id: 'lk-06', text: 'Who calls readOrchestrationMetrics across the repo?', expect: 'references' },
-    { id: 'lk-07', text: 'Does the string "lean-init-2026" exist anywhere in src/?', expect: 'string-existence' },
-    { id: 'lk-08', text: 'Run the roadmap:progress-check report and summarize', expect: 'report-run' },
-    { id: 'lk-09', text: 'Find all usages of InferredTier in tests', expect: 'references' },
-    { id: 'lk-10', text: 'Locate the enum that lists the dispatch actions', expect: 'definition' },
-    // ── negative controls — must escalate, never route to a primitive ──
-    { id: 'lk-n1', text: 'Refactor the auth middleware to use the new session store', expect: null },
-    { id: 'lk-n2', text: 'Fix the failing corpus test and explain the root cause', expect: null },
-    { id: 'lk-n3', text: 'Design a migration plan for the audit schema', expect: null },
-    { id: 'lk-n4', text: 'Review this diff for security issues', expect: null },
-];
-
-describe('lookup-class routing — corpus recall + FP=0 (lean-init L0)', () => {
-    for (const c of LOOKUP_CORPUS) {
-        it(`${c.id}: ${c.text}`, () => {
-            const r = classifyLookup(c.text);
-            expect(r.lookup_class).toBe(c.expect);
-            expect(r.route).toBe(c.expect === null ? 'escalate' : 'primitive');
-        });
-    }
-
-    it('recall on the four live-observed shapes is 4/4', () => {
-        const observed = LOOKUP_CORPUS.filter((c) => c.id.startsWith('lk-0') && Number(c.id.slice(3)) <= 4);
-        expect(observed).toHaveLength(4);
-        for (const c of observed) {
-            expect(classifyLookup(c.text).route).toBe('primitive');
-        }
-    });
-
-    it('false-positive rate is 0 — no negative control routes to a primitive', () => {
-        for (const c of LOOKUP_CORPUS.filter((x) => x.expect === null)) {
-            expect(classifyLookup(c.text).route).toBe('escalate');
-        }
-    });
-
-    it('unknown resolves to escalate with a non-degradation reason', () => {
-        const r = classifyLookup('Do something clever with the codebase');
-        expect(r.route).toBe('escalate');
-        expect(r.primitive).toBeNull();
-        expect(r.reason).toContain('never down-guessed');
-    });
-});

package/src/scripts/_lib/secret_detector.test.ts

@@ -1,108 +0,0 @@
-/**
- * secret_detector — coverage (secret-hygiene-guardrail Phase 0).
- *
- * Positive fixtures: each labelled line carries one fake secret; expectations
- * come from an in-test label→kind map, NOT from detector output.
- * Negative fixtures: every line must be free of high/medium findings (low is
- * only for placeholder-shaped lines; the `secret-allow` line yields nothing).
- */
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import { describe, expect, it } from 'vitest';
-
-import { scanText, type SecretFinding } from './secret_detector.js';
-
-const HERE = path.dirname(fileURLToPath(import.meta.url));
-const FIXTURES = path.join(HERE, 'fixtures', 'secret-detector');
-
-function readFixture(name: string): string {
-    return fs.readFileSync(path.join(FIXTURES, name), 'utf-8');
-}
-
-// Label → expected kind. Keyed by the leading `<label>|` token, so a reordered
-// fixture cannot silently pass.
-const EXPECTED_KIND: Readonly<Record<string, string>> = {
-    aws: 'aws-access-key',
-    github: 'github-pat',
-    stripe: 'stripe-secret-key',
-    google: 'google-api-key',
-    slack: 'slack-token',
-    pem: 'pem-private-key',
-    jwt: 'jwt',
-    dburl: 'db-connection-uri',
-    assignment: 'generic-assignment',
-    // adversarial-corpus additions (road-to-feedback-9.8.0-followups Phase 3)
-    'github-fine-grained': 'github-pat',
-    'env-db-password': 'generic-assignment',
-    'env-api-key': 'generic-assignment',
-    'dburl-mysql': 'db-connection-uri',
-};
-
-function isReal(f: SecretFinding): boolean {
-    return f.confidence === 'high' || f.confidence === 'medium';
-}
-
-describe('scanText — positives', () => {
-    const text = readFixture('positives.txt');
-    const lines = text.split(/\r\n|\r|\n/);
-    const findings = scanText(text);
-
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i] as string;
-        if (!line.includes('|') || line.startsWith('#')) {
-            continue;
-        }
-        const label = line.slice(0, line.indexOf('|'));
-        const expectedKind = EXPECTED_KIND[label];
-        const lineNo = i + 1;
-
-        it(`flags ${label} as ${expectedKind}`, () => {
-            expect(expectedKind, `no expected kind mapped for label "${label}"`).toBeDefined();
-            const onLine = findings.filter((f) => f.line === lineNo && isReal(f));
-            const kinds = onLine.map((f) => f.kind);
-            expect(
-                kinds,
-                `line ${lineNo} (${label}) expected kind ${expectedKind}, got ${JSON.stringify(onLine)}`,
-            ).toContain(expectedKind);
-        });
-    }
-});
-
-describe('scanText — negatives', () => {
-    const text = readFixture('negatives.txt');
-    const lines = text.split(/\r\n|\r|\n/);
-    const findings = scanText(text);
-
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i] as string;
-        if (line.trim() === '' || line.startsWith('#')) {
-            continue;
-        }
-        const lineNo = i + 1;
-        it(`no high/medium finding on line ${lineNo}`, () => {
-            const real = findings.filter((f) => f.line === lineNo && isReal(f));
-            expect(real, `unexpected real findings: ${JSON.stringify(real)}`).toHaveLength(0);
-        });
-    }
-
-    it('the secret-allow line yields zero findings of any confidence', () => {
-        const allowLineNo = lines.findIndex((l) => l.includes('secret-allow')) + 1;
-        expect(allowLineNo, 'no secret-allow line in fixture').toBeGreaterThan(0);
-        const onLine = findings.filter((f) => f.line === allowLineNo);
-        expect(onLine).toHaveLength(0);
-    });
-});
-
-describe('scanText — masking', () => {
-    it('never reproduces the raw secret in `masked`', () => {
-        const raw = 'AKIA1234567890ABCDEF';
-        const findings = scanText(`aws_key = "${raw}"`);
-        const hit = findings.find((f) => f.kind === 'aws-access-key');
-        expect(hit, 'expected an aws-access-key finding').toBeDefined();
-        const masked = (hit as SecretFinding).masked;
-        expect(masked).not.toBe(raw);
-        expect(masked.includes(raw)).toBe(false);
-    });
-});

package/src/scripts/_lib/secret_detector_adversarial.test.ts

@@ -1,116 +0,0 @@
-// Adversarial precision/recall measurement for the secret detector
-// (road-to-feedback-9.8.0-followups Phase 3). Runs the REAL scanText over
-// the committed fixture corpus plus runtime-constructed multiline cases
-// (assembled from parts so nothing key-shaped beyond the existing corpus
-// convention lands in the tree), computes precision / recall / FP-rate, and
-// publishes the rates to internal/reports/secret-scanner-adversarial.json.
-//
-// Hard floor: recall = 100% on positives, FP-rate = 0% on negative controls.
-// A genuine detector miss must NOT be papered over by weakening a fixture —
-// it gets a known_gap entry excluded from the hard assertion and REPORTED.
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { describe, expect, it } from 'vitest';
-
-import { scanText, type SecretFinding } from './secret_detector.js';
-
-const HERE = path.dirname(fileURLToPath(import.meta.url));
-const FIXTURES = path.join(HERE, 'fixtures', 'secret-detector');
-const REPO = path.resolve(HERE, '..', '..', '..');
-const REPORT = path.join(REPO, 'internal', 'reports', 'secret-scanner-adversarial.json');
-
-/** Measured, documented gaps — excluded from the hard floor, published. */
-const KNOWN_GAPS: string[] = [];
-
-const isReal = (f: SecretFinding): boolean => f.confidence === 'high' || f.confidence === 'medium';
-
-interface Case { id: string; text: string; expect_hit: boolean }
-
-function corpusCases(): Case[] {
-    const cases: Case[] = [];
-    for (const [file, expectHit] of [['positives.txt', true], ['negatives.txt', false]] as const) {
-        const lines = fs.readFileSync(path.join(FIXTURES, file), 'utf-8').split('\n');
-        lines.forEach((line, i) => {
-            if (line.trim().length === 0 || line.startsWith('#')) return;
-            const value = expectHit ? (line.split('|')[1] ?? line) : line;
-            cases.push({ id: `${file}:${i + 1}`, text: value, expect_hit: expectHit });
-        });
-    }
-    return cases;
-}
-
-/** Multiline / wrapped positives assembled at runtime. */
-function constructedCases(): Case[] {
-    // A fake PEM body: base64-ish filler between real BEGIN/END framing.
-    const pem = [
-        ['-----BEGIN', 'RSA PRIVATE KEY-----'].join(' '),
-        'MIIEpAIBAAKCAQEA7fakebodyfakebodyfakebodyfakebodyfakebody12345678',
-        'q7fakebodyfakebodyfakebodyfakebodyfakebodyfakebodyfakebody901234',
-        ['-----END', 'RSA PRIVATE KEY-----'].join(' '),
-    ].join('\n');
-    // A base64-WRAPPED credential next to a keyword: the wrapped payload is a
-    // fake AWS key; the wrapper alone must still trip entropy+keyword.
-    const wrapped = `api_key = "${Buffer.from('AKIA' + '1234567890ABCDEF').toString('base64')}"`;
-    // .env multiline block (several assignments in one scan call).
-    const envBlock = ['APP_ENV=production', 'DB_PASSWORD=q7Xp2Vr9kLm4Nt8wYz3BdF6h', 'MAIL_FROM=noreply@example.com'].join('\n');
-    return [
-        { id: 'constructed:pem-multiline', text: pem, expect_hit: true },
-        { id: 'constructed:base64-wrapped-key', text: wrapped, expect_hit: true },
-        { id: 'constructed:env-block', text: envBlock, expect_hit: true },
-        // Negative: random base64 with NO credential keyword nearby.
-        { id: 'constructed:naked-base64-no-keyword-short', text: 'blob dGhpcyBpcyBmaWxsZXI=', expect_hit: false },
-    ];
-}
-
-describe('secret detector — adversarial corpus measurement', () => {
-    const cases = [...corpusCases(), ...constructedCases()];
-    const rows = cases.map((c) => {
-        const real = scanText(c.text).filter(isReal);
-        return { ...c, hit: real.length > 0, kinds: [...new Set(real.map((f) => f.kind))] };
-    });
-
-    const positives = rows.filter((r) => r.expect_hit);
-    const negatives = rows.filter((r) => !r.expect_hit);
-    const detected = positives.filter((r) => r.hit);
-    const missed = positives.filter((r) => !r.hit).map((r) => r.id);
-    const falsePositives = negatives.filter((r) => r.hit).map((r) => r.id);
-    const recall = positives.length > 0 ? detected.length / positives.length : 1;
-    const fpRate = negatives.length > 0 ? falsePositives.length / negatives.length : 0;
-    const precision =
-        detected.length + falsePositives.length > 0
-            ? detected.length / (detected.length + falsePositives.length)
-            : 1;
-
-    it('publishes the measured rates', () => {
-        const report = {
-            _doc:
-                'Adversarial fixture measurement of the secret detector (scanText). ' +
-                'Regenerated by src/scripts/_lib/secret_detector_adversarial.test.ts on every run; ' +
-                'hard floor asserted there (recall 100% / FP 0% outside known_gaps).',
-            generated: new Date().toISOString().slice(0, 10),
-            corpus_size: rows.length,
-            positives: positives.length,
-            negatives: negatives.length,
-            detected: detected.length,
-            missed,
-            false_positives: falsePositives,
-            known_gaps: KNOWN_GAPS,
-            precision: +precision.toFixed(3),
-            recall: +recall.toFixed(3),
-            fp_rate: +fpRate.toFixed(3),
-        };
-        fs.mkdirSync(path.dirname(REPORT), { recursive: true });
-        fs.writeFileSync(REPORT, `${JSON.stringify(report, null, 2)}\n`);
-        expect(fs.existsSync(REPORT)).toBe(true);
-    });
-
-    it('recall floor: every positive outside known_gaps is detected', () => {
-        const hardMisses = missed.filter((id) => !KNOWN_GAPS.includes(id));
-        expect(hardMisses, `detector missed: ${hardMisses.join(', ')}`).toHaveLength(0);
-    });
-
-    it('FP floor: no negative control fires high/medium', () => {
-        expect(falsePositives, `false positives: ${falsePositives.join(', ')}`).toHaveLength(0);
-    });
-});

package/src/scripts/_lib/ui_authority.test.ts

@@ -1,251 +0,0 @@
-/**
- * A1.1-A1.5 behaviour, pinned against the frontend corpus fixtures.
- *
- * Every case name here is a real directory under `tests/eval/frontend-corpus/`,
- * authored and hashed BEFORE this resolver existed (`34f7dc400`). That ordering
- * is the point: the fixtures state what the right answer is, and the resolver is
- * scored against them rather than the reverse.
- */
-import { describe, expect, it } from 'vitest';
-
-import {
-    DEFAULTS,
-    OPERATIONS,
-    PRESERVE_DELTA_DIMENSIONS,
-    degrade,
-    operationConflicts,
-    preserveViolations,
-    resolveUiAuthority,
-    type Signals,
-} from './ui_authority.js';
-
-describe('A1.1 — one object, fully populated', () => {
-    it('always emits every required field', () => {
-        const a = resolveUiAuthority();
-        for (const k of [
-            'surface_mode',
-            'register',
-            'change_intent',
-            'reference_maturity',
-            'primary_source',
-            'constraints',
-            'conflicts',
-            'provenance',
-            'verification',
-        ]) {
-            expect(a).toHaveProperty(k);
-        }
-        expect(a.verification).toBe('verified');
-    });
-
-    it('records provenance for every resolved field, so a wrong answer is traceable', () => {
-        const a = resolveUiAuthority({ brief: { register: 'brand', path: 'brief.md' } });
-        expect(a.provenance.map((p) => p.field)).toEqual(
-            expect.arrayContaining(['surface_mode', 'register', 'change_intent', 'reference_maturity']),
-        );
-        expect(a.provenance.find((p) => p.field === 'register')).toMatchObject({
-            source: 'surface-brief',
-            detail: 'brief.md',
-        });
-    });
-
-    it('carries fidelity_mandate rather than deriving one', () => {
-        expect(resolveUiAuthority({ fidelity_mandate: 'phase-0-output' }).fidelity_mandate).toBe('phase-0-output');
-        expect(resolveUiAuthority().fidelity_mandate).toBeNull();
-    });
-});
-
-describe('A1.2 — explicit user authority wins; quoted text does not', () => {
-    it('cases/explicit-redesign: the user’s change_intent beats every inference', () => {
-        const a = resolveUiAuthority({
-            user: { change_intent: 'redesign', register: 'brand', surface_mode: 'persuade' },
-            incumbent: { coherent: true },
-        });
-        expect(a.change_intent).toBe('redesign');
-        expect(a.provenance.find((p) => p.field === 'change_intent')?.source).toBe('user-instruction');
-    });
-
-    it('quoted text inside a supplied document is data, not authorisation', () => {
-        const quoted: Signals = {
-            user: { change_intent: 'redesign', register: 'brand', quoted: true },
-            incumbent: { coherent: true },
-        };
-        const a = resolveUiAuthority(quoted);
-        // The incumbent wins, exactly as if the quoted directive were absent.
-        expect(a.change_intent).toBe('extend');
-        expect(a.provenance.find((p) => p.field === 'change_intent')?.source).toBe('incumbent-scan');
-    });
-
-    it('a registered hard constraint outranks a user release', () => {
-        const a = resolveUiAuthority({
-            user: { change_intent: 'redesign' },
-            hard_constraints: ['preserve_palette'],
-        });
-        expect(a.constraints.preserve_palette).toBe(true);
-    });
-});
-
-describe('A1.3 — a missing DESIGN.md is not new-world', () => {
-    it('cases/no-design-md-coherent-incumbent resolves extend with incumbent authority', () => {
-        const a = resolveUiAuthority({
-            incumbent: { coherent: true, type_families: ['ibm plex sans'] },
-            design_md: { present: false },
-        });
-        expect(a.change_intent).toBe('extend');
-        expect(a.primary_source.kind).toBe('incumbent');
-        // The provenance assertion is load-bearing, not decoration. `extend` is
-        // ALSO the declared default, so a value-only assertion cannot tell
-        // "resolved from the coherent incumbent" from "fell through to the
-        // default". A sabotage probe that disabled the A1.3 branch left this
-        // test green until the source was asserted.
-        expect(a.provenance.find((p) => p.field === 'change_intent')).toMatchObject({
-            source: 'incumbent-scan',
-            detail: expect.stringContaining('A1.3'),
-        });
-    });
-
-    it('cases/greenfield — genuinely empty resolves new-world', () => {
-        expect(resolveUiAuthority({ design_md: { present: false } }).change_intent).toBe('new-world');
-    });
-
-    it('an incoherent incumbent falls to the declared default, not to new-world', () => {
-        const a = resolveUiAuthority({ incumbent: { coherent: false } });
-        expect(a.change_intent).toBe(DEFAULTS.change_intent);
-        expect(a.change_intent).not.toBe('new-world');
-        // Same discriminator in the other direction: this one MUST read
-        // `default`, so the pair separates the two paths that both yield
-        // `extend`.
-        expect(a.provenance.find((p) => p.field === 'change_intent')?.source).toBe('default');
-    });
-});
-
-describe('A1.4 / A2.1 — surface-local stays local', () => {
-    it('near-miss/surface-mode-not-product-mode: the brief outranks PRODUCT.md', () => {
-        const a = resolveUiAuthority({
-            brief: { surface_mode: 'persuade', register: 'brand', path: 'brief.md' },
-            product_md: { present: true, register: 'product' },
-            incumbent: { coherent: true },
-        });
-        expect(a.surface_mode).toBe('persuade');
-        expect(a.register).toBe('brand');
-        expect(a.provenance.find((p) => p.field === 'register')?.source).toBe('surface-brief');
-    });
-
-    it('PRODUCT.md never supplies surface_mode — only the brief or the user does', () => {
-        const a = resolveUiAuthority({ product_md: { present: true, register: 'product' } });
-        expect(a.provenance.find((p) => p.field === 'surface_mode')?.source).toBe('default');
-    });
-});
-
-describe('A1.5 — the intent-aware gate, against the pre-registered threshold', () => {
-    const incumbent = {
-        palette: ['#16181d', '#ffffff', '#5b616b', '#e3e5e9'],
-        type_families: ['newsreader', 'inter'],
-    };
-
-    it('near-miss/refine-preserves-world: a palette delta under preserve blocks', () => {
-        const a = resolveUiAuthority({ user: { change_intent: 'preserve' }, incumbent: { coherent: true } });
-        const v = preserveViolations(a, incumbent, { palette: ['#16181d', '#ff6a3d'], type_families: ['newsreader'] });
-        expect(v).toHaveLength(1);
-        expect(v[0]).toContain('palette');
-        expect(v[0]).toContain('#ff6a3d');
-    });
-
-    it('a type-family delta under preserve blocks', () => {
-        const a = resolveUiAuthority({ user: { change_intent: 'preserve' } });
-        const v = preserveViolations(a, incumbent, { palette: [], type_families: ['fraunces'] });
-        expect(v).toHaveLength(1);
-        expect(v[0]).toContain('type_family');
-    });
-
-    it('near-miss/refine-preserves-world: spacing-only refinement does NOT block', () => {
-        // The whole point of the verb. Spacing, rhythm, weight and size are
-        // outside the threshold, so a refine that touches only those passes.
-        const a = resolveUiAuthority({ user: { change_intent: 'preserve' }, incumbent: { coherent: true } });
-        expect(preserveViolations(a, incumbent, incumbent)).toEqual([]);
-    });
-
-    it('cases/explicit-redesign: the same delta under redesign does NOT block', () => {
-        const a = resolveUiAuthority({ user: { change_intent: 'redesign' } });
-        expect(preserveViolations(a, incumbent, { palette: ['#ff6a3d'], type_families: ['fraunces'] })).toEqual([]);
-    });
-
-    it('transparent / currentColor / inherit are never a palette delta', () => {
-        const a = resolveUiAuthority({ user: { change_intent: 'preserve' } });
-        expect(
-            preserveViolations(a, incumbent, {
-                palette: ['transparent', 'currentColor', 'inherit'],
-                type_families: [],
-            }),
-        ).toEqual([]);
-    });
-
-    it('the threshold covers exactly the two pre-registered dimensions', () => {
-        expect([...PRESERVE_DELTA_DIMENSIONS]).toEqual(['palette', 'type_family']);
-    });
-});
-
-describe('A4.1 — six operations as one field, with a conflict path', () => {
-    it('exposes exactly the six the step names', () => {
-        expect(Object.keys(OPERATIONS).sort()).toEqual([
-            'bolder',
-            'clarify',
-            'distill',
-            'harden',
-            'polish',
-            'quieter',
-        ]);
-    });
-
-    it('bolder under preserve surfaces a conflict instead of mutating', () => {
-        const a = resolveUiAuthority({ user: { change_intent: 'preserve' } });
-        const c = operationConflicts(a, 'bolder');
-        expect(c.length).toBeGreaterThan(0);
-        expect(c.map((x) => x.dimension).sort()).toEqual(['palette', 'type_family']);
-        expect(c[0]!.blocked_by).toMatch(/^preserve_/);
-    });
-
-    it('polish under preserve is clean — it touches no locked dimension', () => {
-        const a = resolveUiAuthority({ user: { change_intent: 'preserve' } });
-        expect(operationConflicts(a, 'polish')).toEqual([]);
-    });
-
-    it('bolder under redesign is clean', () => {
-        expect(operationConflicts(resolveUiAuthority({ user: { change_intent: 'redesign' } }), 'bolder')).toEqual([]);
-    });
-});
-
-describe('graft 2 — a pass that could not run says so', () => {
-    it('degrade carries a reason', () => {
-        const d = degrade(resolveUiAuthority(), 'render artefact absent');
-        expect(d.verification).toBe('degraded');
-        expect(d.degradation_reason).toBe('render artefact absent');
-    });
-
-    it('refuses a reason-free degrade by construction', () => {
-        expect(() => degrade(resolveUiAuthority(), '   ')).toThrow(/non-empty degradation_reason/);
-    });
-
-    it('supports unverified as a distinct state', () => {
-        expect(degrade(resolveUiAuthority(), 'no host capability', 'unverified').verification).toBe('unverified');
-    });
-});
-
-describe('reference maturity — the wireframe trap', () => {
-    it('cases/wireframe: a wireframe is recorded as structure, never as a pixel mandate', () => {
-        const a = resolveUiAuthority({ reference: { maturity: 'wireframe', path: 'wireframe.md' } });
-        expect(a.reference_maturity).toBe('wireframe');
-        // `brief`, not `comp`: a wireframe does not become the visual source.
-        expect(a.primary_source.kind).toBe('brief');
-    });
-
-    it('cases/supplied-runnable-html: a runnable artifact IS the source', () => {
-        const a = resolveUiAuthority({ reference: { maturity: 'runnable-artifact', path: 'design.html' } });
-        expect(a.primary_source).toStrictEqual({ kind: 'artifact', path: 'design.html' });
-    });
-
-    it('cases/supplied-finished-comp: a comp is translated, not adopted as code', () => {
-        const a = resolveUiAuthority({ reference: { maturity: 'finished-comp', path: 'HANDOVER.md' } });
-        expect(a.primary_source.kind).toBe('comp');
-    });
-});