@kaelio/ktx 0.0.0 → 0.1.0-rc.1

package/node_modules/@ktx/context/dist/scan/relationship-benchmarks.test.js

@@ -0,0 +1,1072 @@
+import { mkdir, mkdtemp, readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { currentKtxRelationshipBenchmarkDetector, loadKtxRelationshipBenchmarkFixture, loadKtxRelationshipBenchmarkFixtures, maskKtxRelationshipBenchmarkSnapshot, runKtxRelationshipBenchmarkCase, runKtxRelationshipBenchmarkSuite, } from './relationship-benchmarks.js';
+const EXPECTED_LINKS = {
+    expectedPks: [
+        { table: 'accounts', columns: ['id'] },
+        { table: 'users', columns: ['id'] },
+    ],
+    expectedLinks: [
+        {
+            fromTable: 'users',
+            fromColumns: ['account_id'],
+            toTable: 'accounts',
+            toColumns: ['id'],
+            relationship: 'many_to_one',
+        },
+    ],
+};
+const CHECKED_IN_FIXTURE_ORIGINS = {
+    abbreviated_old_no_declared_constraints: 'synthetic',
+    adventureworks_oltp_with_declared_metadata: 'public',
+    adventureworkslt_with_declared_metadata: 'public',
+    analytical_warehouse_no_naming_convention: 'synthetic',
+    chinook_with_declared_metadata: 'public',
+    composite_keys_no_declared_constraints: 'synthetic',
+    demo_b2b_declared_metadata: 'synthetic',
+    demo_b2b_no_declared_constraints: 'synthetic',
+    mixed_case_within_schema_no_declared_constraints: 'synthetic',
+    natural_keys_no_declared_constraints: 'synthetic',
+    non_english_naming_no_declared_constraints: 'synthetic',
+    northwind_with_declared_metadata: 'public',
+    orbit_style_product_no_declared_constraints: 'synthetic',
+    plan_code_no_declared_constraints: 'synthetic',
+    polymorphic_partial_overlap_no_declared_constraints: 'synthetic',
+    sakila_with_declared_metadata: 'public',
+    scale_stress_no_declared_constraints: 'synthetic',
+    semantic_embedding_aliases_no_declared_constraints: 'synthetic',
+};
+function runAdHocRelationshipBenchmarks() {
+    return process.env.KTX_RUN_RELATIONSHIP_BENCHMARKS === '1';
+}
+const adHocRelationshipBenchmarkIt = runAdHocRelationshipBenchmarks() ? it : it.skip;
+function snapshot() {
+    return {
+        connectionId: 'warehouse',
+        driver: 'sqlite',
+        extractedAt: '2026-05-07T00:00:00.000Z',
+        scope: {},
+        metadata: {},
+        tables: [
+            {
+                catalog: null,
+                db: 'main',
+                name: 'accounts',
+                kind: 'table',
+                comment: null,
+                estimatedRows: 2,
+                columns: [
+                    {
+                        name: 'id',
+                        nativeType: 'INTEGER',
+                        normalizedType: 'integer',
+                        dimensionType: 'number',
+                        nullable: false,
+                        primaryKey: true,
+                        comment: null,
+                    },
+                    {
+                        name: 'name',
+                        nativeType: 'TEXT',
+                        normalizedType: 'text',
+                        dimensionType: 'string',
+                        nullable: false,
+                        primaryKey: false,
+                        comment: null,
+                    },
+                ],
+                foreignKeys: [],
+            },
+            {
+                catalog: null,
+                db: 'main',
+                name: 'users',
+                kind: 'table',
+                comment: null,
+                estimatedRows: 3,
+                columns: [
+                    {
+                        name: 'id',
+                        nativeType: 'INTEGER',
+                        normalizedType: 'integer',
+                        dimensionType: 'number',
+                        nullable: false,
+                        primaryKey: true,
+                        comment: null,
+                    },
+                    {
+                        name: 'account_id',
+                        nativeType: 'INTEGER',
+                        normalizedType: 'integer',
+                        dimensionType: 'number',
+                        nullable: false,
+                        primaryKey: false,
+                        comment: null,
+                    },
+                ],
+                foreignKeys: [
+                    {
+                        fromColumn: 'account_id',
+                        toCatalog: null,
+                        toDb: 'main',
+                        toTable: 'accounts',
+                        toColumn: 'id',
+                        constraintName: 'users_account_id_fkey',
+                    },
+                ],
+            },
+        ],
+    };
+}
+describe('relationship benchmarks', () => {
+    it('keeps the current benchmark detector on the relationship-discovery path only', async () => {
+        const source = await readFile(new URL('relationship-benchmarks.ts', import.meta.url), 'utf-8');
+        expect(source).not.toMatch(/KtxRelationshipDetector/);
+        expect(source).not.toMatch(/relationship-detection\.js/);
+        expect(source).not.toMatch(/\bacceptedLinks\b/);
+        expect(source).toMatch(/generateKtxRelationshipDiscoveryCandidates/);
+        expect(source).toMatch(/validateKtxRelationshipDiscoveryCandidates/);
+        expect(source).toMatch(/resolveKtxRelationshipGraph/);
+    });
+    it('scores the current detector with declared metadata present', async () => {
+        const result = await runKtxRelationshipBenchmarkCase({
+            fixture: {
+                id: 'mini_declared',
+                name: 'Mini declared fixture',
+                tier: 'unit',
+                origin: 'synthetic',
+                snapshot: snapshot(),
+                expected: EXPECTED_LINKS,
+                defaultModes: ['metadata_present'],
+                dataPath: null,
+                columnEmbeddings: {},
+            },
+            mode: 'metadata_present',
+            detector: currentKtxRelationshipBenchmarkDetector(),
+        });
+        expect(result.metrics.pkRecall).toBe(1);
+        expect(result.metrics.pkPrecision).toBe(1);
+        expect(result.metrics.fkRecall).toBe(1);
+        expect(result.metrics.fkPrecision).toBe(1);
+        expect(result.falseNegatives.fk).toEqual([]);
+        expect(result.predicted.fk).toEqual(['users.(account_id)->accounts.(id)']);
+    });
+    it('keeps no-declared-constraint misses in benchmark metrics', async () => {
+        const result = await runKtxRelationshipBenchmarkCase({
+            fixture: {
+                id: 'mini_no_declared',
+                name: 'Mini no declared fixture',
+                tier: 'unit',
+                origin: 'synthetic',
+                snapshot: snapshot(),
+                expected: EXPECTED_LINKS,
+                defaultModes: ['declared_pks_and_declared_fks_removed'],
+                dataPath: null,
+                columnEmbeddings: {},
+            },
+            mode: 'declared_pks_and_declared_fks_removed',
+            detector: currentKtxRelationshipBenchmarkDetector(),
+        });
+        expect(result.metrics.pkRecall).toBe(0.5);
+        expect(result.metrics.fkRecall).toBe(0);
+        expect(result.metrics.reviewRecall).toBe(1);
+        expect(result.metrics.acceptedOrReviewRecall).toBe(1);
+        expect(result.falseNegatives.pk).toEqual(['users.(id)']);
+        expect(result.falseNegatives.fk).toEqual([]);
+        expect(result.predicted.acceptedFk).toEqual([]);
+        expect(result.predicted.reviewFk).toEqual(['users.(account_id)->accounts.(id)']);
+    });
+    it('keeps composite ground truth in recall denominators and skipped-composite buckets', async () => {
+        const compositeExpected = {
+            expectedPks: [{ table: 'order_lines', columns: ['order_id', 'line_number'] }],
+            expectedLinks: [
+                {
+                    fromTable: 'order_line_allocations',
+                    fromColumns: ['order_id', 'line_number'],
+                    toTable: 'order_lines',
+                    toColumns: ['order_id', 'line_number'],
+                    relationship: 'many_to_one',
+                },
+            ],
+        };
+        const emptyDetector = {
+            async detect() {
+                return {
+                    pks: [],
+                    links: [],
+                    validationBlocked: false,
+                    sqlQueries: 0,
+                    llmCalls: 0,
+                    runtimeSeconds: 0.001,
+                };
+            },
+        };
+        const result = await runKtxRelationshipBenchmarkCase({
+            fixture: {
+                id: 'composite_no_declared',
+                name: 'Composite relationship fixture without declared constraints',
+                tier: 'row_bearing',
+                origin: 'synthetic',
+                snapshot: snapshot(),
+                expected: compositeExpected,
+                defaultModes: ['declared_pks_and_declared_fks_removed'],
+                dataPath: null,
+                columnEmbeddings: {},
+            },
+            mode: 'declared_pks_and_declared_fks_removed',
+            detector: emptyDetector,
+        });
+        expect(result.expected.pk).toEqual(['order_lines.(order_id,line_number)']);
+        expect(result.expected.fk).toEqual([
+            'order_line_allocations.(order_id,line_number)->order_lines.(order_id,line_number)',
+        ]);
+        expect(result.metrics.pkRecall).toBe(0);
+        expect(result.metrics.fkRecall).toBe(0);
+        expect(result.falseNegatives.pk).toEqual(['order_lines.(order_id,line_number)']);
+        expect(result.falseNegatives.fk).toEqual([
+            'order_line_allocations.(order_id,line_number)->order_lines.(order_id,line_number)',
+        ]);
+        expect(result.skippedComposite).toEqual({
+            pk: ['order_lines.(order_id,line_number)'],
+            fk: ['order_line_allocations.(order_id,line_number)->order_lines.(order_id,line_number)'],
+        });
+    });
+    it('loads the composite-key fixture and accepts composite ground truth as headline evidence', async () => {
+        const fixtureRoot = new URL('../../test/fixtures/relationship-benchmarks/', import.meta.url);
+        const fixture = await loadKtxRelationshipBenchmarkFixture(join(fixtureRoot.pathname, 'composite_keys_no_declared_constraints'));
+        expect(fixture.tier).toBe('row_bearing');
+        expect(fixture.defaultModes).toEqual([
+            'declared_pks_and_declared_fks_removed',
+            'llm_disabled',
+            'profiling_disabled',
+            'validation_disabled',
+            'embeddings_disabled',
+        ]);
+        expect(fixture.dataPath).toMatch(/composite_keys_no_declared_constraints\/data\.sqlite$/);
+        const suite = await runKtxRelationshipBenchmarkSuite({
+            fixtures: [fixture],
+            detector: currentKtxRelationshipBenchmarkDetector(),
+        });
+        const headline = suite.cases.find((item) => item.fixtureId === 'composite_keys_no_declared_constraints' &&
+            item.mode === 'declared_pks_and_declared_fks_removed');
+        const profilingDisabled = suite.cases.find((item) => item.fixtureId === 'composite_keys_no_declared_constraints' && item.mode === 'profiling_disabled');
+        const validationDisabled = suite.cases.find((item) => item.fixtureId === 'composite_keys_no_declared_constraints' && item.mode === 'validation_disabled');
+        const compositePks = [
+            'order_line_allocations.(order_id,line_number,warehouse_code)',
+            'order_lines.(order_id,line_number)',
+        ];
+        const compositeFk = ['order_line_allocations.(order_id,line_number)->order_lines.(order_id,line_number)'];
+        expect(headline?.expected.pk).toEqual(compositePks);
+        expect(headline?.expected.fk).toEqual(compositeFk);
+        expect(headline?.predicted.pk).toEqual(compositePks);
+        expect(headline?.predicted.acceptedFk).toEqual(compositeFk);
+        expect(headline?.predicted.reviewFk).toEqual([]);
+        expect(headline?.metrics.pkRecall).toBe(1);
+        expect(headline?.metrics.fkRecall).toBe(1);
+        expect(headline?.metrics.acceptedOrReviewRecall).toBe(1);
+        expect(headline?.metrics.acceptedFalsePositiveCount).toBe(0);
+        expect(headline?.falseNegatives.pk).toEqual([]);
+        expect(headline?.falseNegatives.fk).toEqual([]);
+        expect(headline?.skippedComposite).toEqual({
+            pk: [],
+            fk: [],
+        });
+        expect(profilingDisabled?.validationBlocked).toBe(true);
+        expect(validationDisabled?.validationBlocked).toBe(true);
+        expect(suite.validationBlockedCases).toEqual([
+            'composite_keys_no_declared_constraints:profiling_disabled',
+            'composite_keys_no_declared_constraints:validation_disabled',
+        ]);
+        expect(suite.aggregate.headlineCaseCount).toBe(1);
+        expect(suite.aggregate.headlinePkRecall).toBe(1);
+        expect(suite.aggregate.headlineFkRecall).toBe(1);
+    });
+    it('counts formal metadata links in metadata-present mode without SQL validation', async () => {
+        const source = snapshot();
+        const fixture = {
+            id: 'declared_without_sql',
+            name: 'Declared relationships without SQL validation',
+            tier: 'unit',
+            origin: 'synthetic',
+            snapshot: {
+                ...source,
+                tables: source.tables.map((table) => table.name === 'accounts'
+                    ? {
+                        ...table,
+                        columns: table.columns.map((column) => column.name === 'id' ? { ...column, primaryKey: true } : column),
+                    }
+                    : table.name === 'users'
+                        ? {
+                            ...table,
+                            foreignKeys: [
+                                {
+                                    fromColumn: 'account_id',
+                                    toCatalog: null,
+                                    toDb: null,
+                                    toTable: 'accounts',
+                                    toColumn: 'id',
+                                    constraintName: 'users_account_id_fkey',
+                                },
+                            ],
+                        }
+                        : table),
+            },
+            expected: EXPECTED_LINKS,
+            defaultModes: ['metadata_present'],
+            dataPath: null,
+            columnEmbeddings: {},
+        };
+        const result = await runKtxRelationshipBenchmarkCase({
+            fixture,
+            mode: 'metadata_present',
+        });
+        expect(result.validationBlocked).toBe(false);
+        expect(result.predicted.acceptedFk).toEqual(['users.(account_id)->accounts.(id)']);
+        expect(result.metrics.fkRecall).toBe(1);
+        expect(result.metrics.fkPrecision).toBe(1);
+    });
+    it('masks primary keys and foreign keys independently', () => {
+        const pksRemoved = maskKtxRelationshipBenchmarkSnapshot(snapshot(), 'declared_pks_removed');
+        const fksRemoved = maskKtxRelationshipBenchmarkSnapshot(snapshot(), 'declared_fks_removed');
+        expect(pksRemoved.tables.flatMap((table) => table.columns.filter((column) => column.primaryKey))).toEqual([]);
+        expect(pksRemoved.tables.find((table) => table.name === 'users')?.foreignKeys).toHaveLength(1);
+        expect(fksRemoved.tables.find((table) => table.name === 'accounts')?.columns[0]?.primaryKey).toBe(true);
+        expect(fksRemoved.tables.find((table) => table.name === 'users')?.foreignKeys).toEqual([]);
+    });
+    it('loads fixture.yaml, snapshot.json, and expected-links.yaml from a fixture directory', async () => {
+        const fixtureDir = await mkdtemp(join(tmpdir(), 'ktx-relationship-fixture-'));
+        try {
+            await writeFile(join(fixtureDir, 'fixture.yaml'), [
+                'id: mini_loaded',
+                'name: Mini loaded fixture',
+                'tier: unit',
+                'origin: synthetic',
+                'validationBudget: 3',
+                'defaultModes:',
+                '  - metadata_present',
+                '  - declared_pks_and_declared_fks_removed',
+                '',
+            ].join('\n'));
+            await writeFile(join(fixtureDir, 'snapshot.json'), `${JSON.stringify(snapshot(), null, 2)}\n`);
+            await writeFile(join(fixtureDir, 'column-embeddings.json'), `${JSON.stringify({
+                'accounts.id': [1, 0, 0],
+                'users.account_id': [0.99, 0.01, 0],
+            }, null, 2)}\n`);
+            await writeFile(join(fixtureDir, 'expected-links.yaml'), [
+                'expectedPks:',
+                '  - table: accounts',
+                '    columns: [id]',
+                '  - table: users',
+                '    columns: [id]',
+                'expectedLinks:',
+                '  - fromTable: users',
+                '    fromColumns: [account_id]',
+                '    toTable: accounts',
+                '    toColumns: [id]',
+                '    relationship: many_to_one',
+                '',
+            ].join('\n'));
+            await expect(loadKtxRelationshipBenchmarkFixture(fixtureDir)).resolves.toMatchObject({
+                id: 'mini_loaded',
+                origin: 'synthetic',
+                validationBudget: 3,
+                defaultModes: ['metadata_present', 'declared_pks_and_declared_fks_removed'],
+                columnEmbeddings: {
+                    'accounts.id': [1, 0, 0],
+                    'users.account_id': [0.99, 0.01, 0],
+                },
+                expected: {
+                    expectedLinks: [
+                        {
+                            fromTable: 'users',
+                            fromColumns: ['account_id'],
+                            toTable: 'accounts',
+                            toColumns: ['id'],
+                            relationship: 'many_to_one',
+                        },
+                    ],
+                },
+            });
+            await expect(readFile(join(fixtureDir, 'snapshot.json'), 'utf-8')).resolves.toContain('"connectionId": "warehouse"');
+        }
+        finally {
+            await rm(fixtureDir, { recursive: true, force: true });
+        }
+    });
+    it('passes fixture validation budgets into benchmark detectors', async () => {
+        const seenBudgets = [];
+        const detector = {
+            async detect(input) {
+                seenBudgets.push(input.validationBudget);
+                return {
+                    pks: [],
+                    links: [],
+                    validationBlocked: false,
+                    sqlQueries: 0,
+                    llmCalls: 0,
+                    runtimeSeconds: 0.001,
+                };
+            },
+        };
+        await runKtxRelationshipBenchmarkSuite({
+            fixtures: [
+                {
+                    id: 'budgeted_fixture',
+                    name: 'Budgeted fixture',
+                    tier: 'row_bearing',
+                    origin: 'synthetic',
+                    validationBudget: 0,
+                    snapshot: snapshot(),
+                    expected: EXPECTED_LINKS,
+                    defaultModes: ['declared_pks_and_declared_fks_removed'],
+                    dataPath: null,
+                    columnEmbeddings: {},
+                },
+                {
+                    id: 'unbudgeted_fixture',
+                    name: 'Unbudgeted fixture',
+                    tier: 'row_bearing',
+                    origin: 'synthetic',
+                    snapshot: snapshot(),
+                    expected: EXPECTED_LINKS,
+                    defaultModes: ['metadata_present'],
+                    dataPath: null,
+                    columnEmbeddings: {},
+                },
+            ],
+            detector,
+        });
+        expect(seenBudgets).toEqual([0, undefined]);
+    });
+    it('requires relationship benchmark fixture origin provenance', async () => {
+        const fixtureDir = await mkdtemp(join(tmpdir(), 'ktx-relationship-missing-origin-'));
+        try {
+            await writeFile(join(fixtureDir, 'fixture.yaml'), [
+                'id: missing_origin',
+                'name: Missing origin fixture',
+                'tier: unit',
+                'defaultModes:',
+                '  - metadata_present',
+                '',
+            ].join('\n'));
+            await writeFile(join(fixtureDir, 'snapshot.json'), `${JSON.stringify(snapshot(), null, 2)}\n`);
+            await writeFile(join(fixtureDir, 'expected-links.yaml'), ['expectedPks:', '  - table: accounts', '    columns: [id]', 'expectedLinks: []', ''].join('\n'));
+            await expect(loadKtxRelationshipBenchmarkFixture(fixtureDir)).rejects.toThrow(/origin/);
+        }
+        finally {
+            await rm(fixtureDir, { recursive: true, force: true });
+        }
+    });
+    it('loads all benchmark fixture directories in stable order', async () => {
+        const fixtureRoot = await mkdtemp(join(tmpdir(), 'ktx-relationship-fixture-root-'));
+        async function writeFixtureDir(dirName, fixtureId) {
+            const fixtureDir = join(fixtureRoot, dirName);
+            await mkdir(fixtureDir);
+            await writeFile(join(fixtureDir, 'fixture.yaml'), [
+                `id: ${fixtureId}`,
+                `name: ${fixtureId}`,
+                'tier: unit',
+                'origin: synthetic',
+                'defaultModes:',
+                '  - metadata_present',
+                '',
+            ].join('\n'));
+            await writeFile(join(fixtureDir, 'snapshot.json'), `${JSON.stringify(snapshot(), null, 2)}\n`);
+            await writeFile(join(fixtureDir, 'expected-links.yaml'), [
+                'expectedPks:',
+                '  - table: accounts',
+                '    columns: [id]',
+                '  - table: users',
+                '    columns: [id]',
+                'expectedLinks:',
+                '  - fromTable: users',
+                '    fromColumns: [account_id]',
+                '    toTable: accounts',
+                '    toColumns: [id]',
+                '    relationship: many_to_one',
+                '',
+            ].join('\n'));
+        }
+        try {
+            await writeFixtureDir('z_fixture', 'z_fixture');
+            await writeFixtureDir('a_fixture', 'a_fixture');
+            await expect(loadKtxRelationshipBenchmarkFixtures(fixtureRoot)).resolves.toMatchObject([
+                { id: 'a_fixture', origin: 'synthetic' },
+                { id: 'z_fixture', origin: 'synthetic' },
+            ]);
+        }
+        finally {
+            await rm(fixtureRoot, { recursive: true, force: true });
+        }
+    });
+    it('loads every checked-in relationship benchmark fixture with explicit provenance', async () => {
+        const fixtureRoot = new URL('../../test/fixtures/relationship-benchmarks/', import.meta.url);
+        const fixtureDirs = (await readdir(fixtureRoot, { withFileTypes: true }))
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort((left, right) => left.localeCompare(right));
+        expect(fixtureDirs).toEqual(Object.keys(CHECKED_IN_FIXTURE_ORIGINS).sort());
+        const fixtures = await loadKtxRelationshipBenchmarkFixtures(fixtureRoot.pathname);
+        expect(Object.fromEntries(fixtures.map((fixture) => [fixture.id, fixture.origin]))).toEqual(CHECKED_IN_FIXTURE_ORIGINS);
+    });
+    it('loads May 8 evidence-fusion adversarial fixtures as reported synthetic evidence', async () => {
+        const fixtureRoot = new URL('../../test/fixtures/relationship-benchmarks/', import.meta.url);
+        const fixtures = await loadKtxRelationshipBenchmarkFixtures(fixtureRoot.pathname);
+        const byId = new Map(fixtures.map((fixture) => [fixture.id, fixture]));
+        const adversarialIds = [
+            'non_english_naming_no_declared_constraints',
+            'abbreviated_old_no_declared_constraints',
+            'analytical_warehouse_no_naming_convention',
+            'mixed_case_within_schema_no_declared_constraints',
+            'polymorphic_partial_overlap_no_declared_constraints',
+        ];
+        for (const fixtureId of adversarialIds) {
+            const fixture = byId.get(fixtureId);
+            expect(fixture, fixtureId).toBeDefined();
+            expect(fixture?.origin).toBe('synthetic');
+            expect(fixture?.tier).toBe('row_bearing');
+            expect(fixture?.thresholdEligible).toBe(false);
+            expect(fixture?.defaultModes).toEqual(['declared_pks_and_declared_fks_removed']);
+            expect(fixture?.dataPath).toMatch(/data\.sqlite$/);
+            expect(fixture?.expected.expectedPks.length).toBeGreaterThan(0);
+            expect(fixture?.expected.expectedLinks.length).toBeGreaterThan(0);
+        }
+        expect(byId
+            .get('polymorphic_partial_overlap_no_declared_constraints')
+            ?.expected.expectedLinks.filter((link) => link.fromTable === 'activity_events' && link.fromColumns.join(',') === 'entity_id')).toHaveLength(2);
+    });
+    it('loads the May 8 scale stress fixture with bounded benchmark validation', async () => {
+        const fixtureRoot = new URL('../../test/fixtures/relationship-benchmarks/', import.meta.url);
+        const fixture = await loadKtxRelationshipBenchmarkFixture(join(fixtureRoot.pathname, 'scale_stress_no_declared_constraints'));
+        expect(fixture.origin).toBe('synthetic');
+        expect(fixture.tier).toBe('row_bearing');
+        expect(fixture.thresholdEligible).toBe(false);
+        expect(fixture.defaultModes).toEqual(['declared_pks_and_declared_fks_removed']);
+        expect(fixture.validationBudget).toBe(800);
+        expect(fixture.snapshot.tables).toHaveLength(400);
+        expect(fixture.snapshot.tables.every((table) => table.columns.length === 50)).toBe(true);
+        expect(fixture.expected.expectedPks).toHaveLength(20);
+        expect(fixture.expected.expectedLinks).toHaveLength(1900);
+    });
+    adHocRelationshipBenchmarkIt('runs the scale stress fixture inside the benchmark validation budget', async () => {
+        const fixtureRoot = new URL('../../test/fixtures/relationship-benchmarks/', import.meta.url);
+        const fixture = await loadKtxRelationshipBenchmarkFixture(join(fixtureRoot.pathname, 'scale_stress_no_declared_constraints'));
+        const result = await runKtxRelationshipBenchmarkCase({
+            fixture,
+            mode: 'declared_pks_and_declared_fks_removed',
+            detector: currentKtxRelationshipBenchmarkDetector(),
+        });
+        expect(result.metrics.runtimeSeconds).toBeLessThan(60);
+        expect(result.metrics.sqlQueries).toBeLessThanOrEqual(800);
+        expect(result.validationBlocked).toBe(false);
+    }, 60_000);
+    it('aggregates suite metrics without hiding validation-blocked cases', async () => {
+        const suite = await runKtxRelationshipBenchmarkSuite({
+            fixtures: [
+                {
+                    id: 'mini_declared',
+                    name: 'Mini declared fixture',
+                    tier: 'unit',
+                    origin: 'synthetic',
+                    snapshot: snapshot(),
+                    expected: EXPECTED_LINKS,
+                    defaultModes: ['metadata_present'],
+                    dataPath: null,
+                    columnEmbeddings: {},
+                },
+                {
+                    id: 'mini_no_declared',
+                    name: 'Mini no declared fixture',
+                    tier: 'row_bearing',
+                    origin: 'synthetic',
+                    snapshot: snapshot(),
+                    expected: EXPECTED_LINKS,
+                    defaultModes: ['declared_pks_and_declared_fks_removed', 'validation_disabled'],
+                    dataPath: null,
+                    columnEmbeddings: {},
+                },
+            ],
+            detector: currentKtxRelationshipBenchmarkDetector(),
+        });
+        expect(suite.cases.map((item) => `${item.fixtureId}:${item.mode}`)).toEqual([
+            'mini_declared:metadata_present',
+            'mini_no_declared:declared_pks_and_declared_fks_removed',
+            'mini_no_declared:validation_disabled',
+        ]);
+        expect(suite.validationBlockedCases).toEqual(['mini_no_declared:validation_disabled']);
+        expect(suite.aggregate.caseCount).toBe(3);
+        expect(suite.aggregate.headlineCaseCount).toBe(1);
+        expect(suite.aggregate.headlineFkRecall).toBe(0);
+        expect(suite.aggregate.headlineAcceptedOrReviewRecall).toBe(1);
+    });
+    it('keeps smoke fixtures out of headline threshold metrics', async () => {
+        const detector = {
+            async detect() {
+                return {
+                    pks: [
+                        { table: 'accounts', columns: ['id'], score: 1, status: 'accepted' },
+                        { table: 'users', columns: ['id'], score: 1, status: 'accepted' },
+                    ],
+                    links: [
+                        {
+                            fromTable: 'users',
+                            fromColumns: ['account_id'],
+                            toTable: 'accounts',
+                            toColumns: ['id'],
+                            relationship: 'many_to_one',
+                            score: 1,
+                            status: 'accepted',
+                            source: 'test',
+                        },
+                    ],
+                    validationBlocked: false,
+                    sqlQueries: 1,
+                    llmCalls: 0,
+                    runtimeSeconds: 0.001,
+                };
+            },
+        };
+        const suite = await runKtxRelationshipBenchmarkSuite({
+            fixtures: [
+                {
+                    id: 'smoke_no_declared',
+                    name: 'Smoke no declared fixture',
+                    tier: 'smoke',
+                    origin: 'synthetic',
+                    snapshot: snapshot(),
+                    expected: EXPECTED_LINKS,
+                    defaultModes: ['declared_pks_and_declared_fks_removed'],
+                    dataPath: null,
+                    columnEmbeddings: {},
+                },
+                {
+                    id: 'row_bearing_no_declared',
+                    name: 'Row-bearing no declared fixture',
+                    tier: 'row_bearing',
+                    origin: 'synthetic',
+                    snapshot: snapshot(),
+                    expected: EXPECTED_LINKS,
+                    defaultModes: ['declared_pks_and_declared_fks_removed'],
+                    dataPath: null,
+                    columnEmbeddings: {},
+                },
+            ],
+            detector,
+        });
+        expect(suite.aggregate.caseCount).toBe(2);
+        expect(suite.aggregate.headlineCaseCount).toBe(1);
+        expect(suite.aggregate.headlineFkRecall).toBe(1);
+        expect(suite.aggregate.headlinePkRecall).toBe(1);
+    });
+    it('counts product fixtures as headline evidence only when threshold eligible', async () => {
+        const detector = {
+            async detect() {
+                return {
+                    pks: [
+                        { table: 'accounts', columns: ['id'], score: 1, status: 'accepted' },
+                        { table: 'users', columns: ['id'], score: 1, status: 'accepted' },
+                    ],
+                    links: [
+                        {
+                            fromTable: 'users',
+                            fromColumns: ['account_id'],
+                            toTable: 'accounts',
+                            toColumns: ['id'],
+                            relationship: 'many_to_one',
+                            score: 1,
+                            status: 'accepted',
+                            source: 'test',
+                        },
+                    ],
+                    validationBlocked: false,
+                    sqlQueries: 1,
+                    llmCalls: 0,
+                    runtimeSeconds: 0.001,
+                };
+            },
+        };
+        const suite = await runKtxRelationshipBenchmarkSuite({
+            fixtures: [
+                {
+                    id: 'product_not_curated',
+                    name: 'Product fixture without curated threshold evidence',
+                    tier: 'product',
+                    origin: 'synthetic',
+                    snapshot: snapshot(),
+                    expected: EXPECTED_LINKS,
+                    defaultModes: ['declared_pks_and_declared_fks_removed'],
+                    dataPath: null,
+                    columnEmbeddings: {},
+                },
+                {
+                    id: 'product_curated',
+                    name: 'Product fixture with curated threshold evidence',
+                    tier: 'product',
+                    origin: 'synthetic',
+                    thresholdEligible: true,
+                    snapshot: snapshot(),
+                    expected: EXPECTED_LINKS,
+                    defaultModes: ['declared_pks_and_declared_fks_removed'],
+                    dataPath: null,
+                    columnEmbeddings: {},
+                },
+                {
+                    id: 'smoke_even_if_marked',
+                    name: 'Smoke fixture remains excluded',
+                    tier: 'smoke',
+                    origin: 'synthetic',
+                    thresholdEligible: true,
+                    snapshot: snapshot(),
+                    expected: EXPECTED_LINKS,
+                    defaultModes: ['declared_pks_and_declared_fks_removed'],
+                    dataPath: null,
+                    columnEmbeddings: {},
+                },
+            ],
+            detector,
+        });
+        expect(suite.aggregate.caseCount).toBe(3);
+        expect(suite.aggregate.headlineCaseCount).toBe(1);
+        expect(suite.aggregate.headlinePkRecall).toBe(1);
+        expect(suite.aggregate.headlineFkRecall).toBe(1);
+    });
+    it('loads the packaged B2B demo fixtures and records the current relationship-discovery baseline', async () => {
+        const fixtureRoot = new URL('../../test/fixtures/relationship-benchmarks/', import.meta.url);
+        const declared = await loadKtxRelationshipBenchmarkFixture(join(fixtureRoot.pathname, 'demo_b2b_declared_metadata'));
+        const noDeclared = await loadKtxRelationshipBenchmarkFixture(join(fixtureRoot.pathname, 'demo_b2b_no_declared_constraints'));
+        expect(declared.tier).toBe('smoke');
+        expect(noDeclared.tier).toBe('smoke');
+        expect(declared.defaultModes).toEqual([
+            'metadata_present',
+            'declared_fks_removed',
+            'declared_pks_removed',
+            'declared_pks_and_declared_fks_removed',
+            'llm_disabled',
+            'profiling_disabled',
+            'validation_disabled',
+            'embeddings_disabled',
+        ]);
+        expect(noDeclared.defaultModes).toEqual([
+            'declared_pks_and_declared_fks_removed',
+            'profiling_disabled',
+            'validation_disabled',
+            'llm_disabled',
+            'embeddings_disabled',
+        ]);
+        const suite = await runKtxRelationshipBenchmarkSuite({
+            fixtures: [declared, noDeclared],
+            detector: currentKtxRelationshipBenchmarkDetector(),
+        });
+        const declaredCase = suite.cases.find((item) => item.fixtureId === 'demo_b2b_declared_metadata' && item.mode === 'metadata_present');
+        const noDeclaredCase = suite.cases.find((item) => item.fixtureId === 'demo_b2b_no_declared_constraints' && item.mode === 'declared_pks_and_declared_fks_removed');
+        const profilingDisabledCase = suite.cases.find((item) => item.fixtureId === 'demo_b2b_no_declared_constraints' && item.mode === 'profiling_disabled');
+        expect(declaredCase?.expected.fk).toHaveLength(7);
+        expect(declaredCase?.metrics.fkRecall).toBe(1);
+        expect(declaredCase?.metrics.pkRecall).toBe(1);
+        expect(noDeclaredCase?.expected.fk).toHaveLength(7);
+        expect(noDeclaredCase?.metrics.fkRecall).toBe(1);
+        expect(noDeclaredCase?.metrics.fkPrecision).toBe(1);
+        expect(noDeclaredCase?.metrics.pkRecall).toBe(1);
+        expect(noDeclaredCase?.falseNegatives.pk).toEqual([]);
+        expect(noDeclaredCase?.metrics.reviewRecall).toBe(0);
+        expect(noDeclaredCase?.metrics.acceptedOrReviewRecall).toBe(1);
+        expect(noDeclaredCase?.metrics.acceptedFalsePositiveCount).toBe(0);
+        expect(noDeclaredCase?.predicted.acceptedFk).toEqual([
+            'invoices.(account_id)->accounts.(id)',
+            'opportunities.(account_id)->accounts.(id)',
+            'product_events.(account_id)->accounts.(id)',
+            'product_events.(user_id)->users.(id)',
+            'subscriptions.(account_id)->accounts.(id)',
+            'support_tickets.(account_id)->accounts.(id)',
+            'users.(account_id)->accounts.(id)',
+        ]);
+        expect(noDeclaredCase?.predicted.reviewFk).toEqual([]);
+        expect(noDeclaredCase?.falseNegatives.fk).toEqual([]);
+        expect(profilingDisabledCase?.validationBlocked).toBe(true);
+        expect(profilingDisabledCase?.metrics.fkRecall).toBe(0);
+        expect(profilingDisabledCase?.metrics.acceptedOrReviewRecall).toBe(1);
+        expect(suite.aggregate.headlineCaseCount).toBe(0);
+        expect(suite.aggregate.headlineFkRecall).toBe(0);
+        expect(suite.aggregate.headlineAcceptedOrReviewRecall).toBe(0);
+        expect(suite.validationBlockedCases).toEqual([
+            'demo_b2b_declared_metadata:profiling_disabled',
+            'demo_b2b_declared_metadata:validation_disabled',
+            'demo_b2b_no_declared_constraints:profiling_disabled',
+            'demo_b2b_no_declared_constraints:validation_disabled',
+        ]);
+    });
+    it('loads the public Chinook benchmark fixture with declared metadata', async () => {
+        const fixtureRoot = new URL('../../test/fixtures/relationship-benchmarks/', import.meta.url);
+        const fixture = await loadKtxRelationshipBenchmarkFixture(join(fixtureRoot.pathname, 'chinook_with_declared_metadata'));
+        expect(fixture.tier).toBe('row_bearing');
+        expect(fixture.thresholdEligible).toBe(true);
+        expect(fixture.defaultModes).toContain('metadata_present');
+        expect(fixture.defaultModes).toContain('declared_pks_and_declared_fks_removed');
+        expect(fixture.snapshot.tables.length).toBeGreaterThanOrEqual(11);
+        expect(fixture.expected.expectedLinks.length).toBeGreaterThanOrEqual(8);
+        const albumArtist = fixture.expected.expectedLinks.find((link) => link.fromTable === 'Album' && link.toTable === 'Artist');
+        expect(albumArtist).toBeDefined();
+    });
+    it('loads the public Northwind benchmark fixture with declared metadata', async () => {
+        const fixtureRoot = new URL('../../test/fixtures/relationship-benchmarks/', import.meta.url);
+        const fixture = await loadKtxRelationshipBenchmarkFixture(join(fixtureRoot.pathname, 'northwind_with_declared_metadata'));
+        expect(fixture.tier).toBe('row_bearing');
+        expect(fixture.thresholdEligible).toBe(true);
+        expect(fixture.snapshot.tables.length).toBeGreaterThanOrEqual(13);
+        expect(fixture.expected.expectedLinks.length).toBeGreaterThanOrEqual(11);
+        const orderCustomer = fixture.expected.expectedLinks.find((link) => ['Orders', 'orders'].includes(link.fromTable) && ['Customers', 'customers'].includes(link.toTable));
+        expect(orderCustomer).toBeDefined();
+    });
+    it('loads the public Sakila benchmark fixture with declared metadata', async () => {
+        const fixtureRoot = new URL('../../test/fixtures/relationship-benchmarks/', import.meta.url);
+        const fixture = await loadKtxRelationshipBenchmarkFixture(join(fixtureRoot.pathname, 'sakila_with_declared_metadata'));
+        expect(fixture.tier).toBe('row_bearing');
+        expect(fixture.thresholdEligible).toBe(true);
+        expect(fixture.snapshot.tables.length).toBeGreaterThanOrEqual(16);
+        expect(fixture.expected.expectedLinks.length).toBeGreaterThanOrEqual(14);
+        const filmLanguage = fixture.expected.expectedLinks.find((link) => link.fromTable === 'film' && link.toTable === 'language');
+        expect(filmLanguage).toBeDefined();
+    });
+    it('loads the public AdventureWorksLT benchmark fixture with declared metadata', async () => {
+        const fixtureRoot = new URL('../../test/fixtures/relationship-benchmarks/', import.meta.url);
+        const fixture = await loadKtxRelationshipBenchmarkFixture(join(fixtureRoot.pathname, 'adventureworkslt_with_declared_metadata'));
+        expect(fixture.id).toBe('adventureworkslt_with_declared_metadata');
+        expect(fixture.name).toBe('AdventureWorksLT (SQLite, declared metadata)');
+        expect(fixture.tier).toBe('row_bearing');
+        expect(fixture.thresholdEligible).toBe(true);
+        expect(fixture.defaultModes).toEqual([
+            'metadata_present',
+            'declared_pks_and_declared_fks_removed',
+            'declared_pks_removed',
+            'declared_fks_removed',
+            'profiling_disabled',
+            'validation_disabled',
+            'llm_disabled',
+            'embeddings_disabled',
+        ]);
+        expect(fixture.snapshot.tables).toHaveLength(12);
+        expect(fixture.expected.expectedPks).toHaveLength(12);
+        expect(fixture.expected.expectedLinks).toHaveLength(12);
+        const customerAddressPk = fixture.expected.expectedPks.find((pk) => pk.table === 'CustomerAddress');
+        expect(customerAddressPk?.columns).toEqual(['CustomerID', 'AddressID']);
+        const modelDescriptionPk = fixture.expected.expectedPks.find((pk) => pk.table === 'ProductModelProductDescription');
+        expect(modelDescriptionPk?.columns).toEqual(['ProductModelID', 'ProductDescriptionID', 'Culture']);
+        expect(fixture.expected.expectedLinks).toContainEqual({
+            fromTable: 'CustomerAddress',
+            fromColumns: ['CustomerID'],
+            toTable: 'Customer',
+            toColumns: ['CustomerID'],
+            relationship: 'many_to_one',
+        });
+        expect(fixture.expected.expectedLinks).toContainEqual({
+            fromTable: 'ProductCategory',
+            fromColumns: ['ParentProductCategoryID'],
+            toTable: 'ProductCategory',
+            toColumns: ['ProductCategoryID'],
+            relationship: 'many_to_one',
+        });
+        expect(fixture.expected.expectedLinks).toContainEqual({
+            fromTable: 'SalesOrderDetail',
+            fromColumns: ['SalesOrderID'],
+            toTable: 'SalesOrderHeader',
+            toColumns: ['SalesOrderID'],
+            relationship: 'many_to_one',
+        });
+        expect(fixture.expected.expectedLinks).toContainEqual({
+            fromTable: 'SalesOrderHeader',
+            fromColumns: ['CustomerID'],
+            toTable: 'Customer',
+            toColumns: ['CustomerID'],
+            relationship: 'many_to_one',
+        });
+    });
+    it('loads the full AdventureWorks OLTP benchmark fixture with declared metadata', async () => {
+        const fixtureRoot = new URL('../../test/fixtures/relationship-benchmarks/', import.meta.url);
+        const fixture = await loadKtxRelationshipBenchmarkFixture(join(fixtureRoot.pathname, 'adventureworks_oltp_with_declared_metadata'));
+        expect(fixture.id).toBe('adventureworks_oltp_with_declared_metadata');
+        expect(fixture.name).toBe('AdventureWorks OLTP (SQL Server 2022, declared metadata)');
+        expect(fixture.tier).toBe('row_bearing');
+        expect(fixture.thresholdEligible).toBe(true);
+        expect(fixture.defaultModes).toEqual([
+            'metadata_present',
+            'declared_pks_and_declared_fks_removed',
+            'declared_pks_removed',
+            'declared_fks_removed',
+            'profiling_disabled',
+            'validation_disabled',
+            'llm_disabled',
+            'embeddings_disabled',
+        ]);
+        expect(fixture.dataPath === null || fixture.dataPath.endsWith('/adventureworks_oltp_with_declared_metadata/data.sqlite')).toBe(true);
+        expect(fixture.snapshot.driver).toBe('sqlite');
+        expect(fixture.snapshot.metadata.source_driver).toBe('sqlserver');
+        expect(fixture.snapshot.tables).toHaveLength(71);
+        expect(fixture.expected.expectedPks).toHaveLength(71);
+        expect(fixture.expected.expectedLinks).toHaveLength(90);
+        expect(fixture.expected.expectedPks).toContainEqual({
+            table: 'Sales.SalesOrderDetail',
+            columns: ['SalesOrderID', 'SalesOrderDetailID'],
+        });
+        expect(fixture.expected.expectedPks).toContainEqual({
+            table: 'Sales.SalesOrderHeaderSalesReason',
+            columns: ['SalesOrderID', 'SalesReasonID'],
+        });
+        expect(fixture.expected.expectedLinks).toContainEqual({
+            fromTable: 'Sales.SalesOrderHeader',
+            fromColumns: ['CustomerID'],
+            toTable: 'Sales.Customer',
+            toColumns: ['CustomerID'],
+            relationship: 'many_to_one',
+        });
+        expect(fixture.expected.expectedLinks).toContainEqual({
+            fromTable: 'Sales.SalesOrderDetail',
+            fromColumns: ['SalesOrderID'],
+            toTable: 'Sales.SalesOrderHeader',
+            toColumns: ['SalesOrderID'],
+            relationship: 'many_to_one',
+        });
+        expect(fixture.expected.expectedLinks).toContainEqual({
+            fromTable: 'Production.Product',
+            fromColumns: ['ProductSubcategoryID'],
+            toTable: 'Production.ProductSubcategory',
+            toColumns: ['ProductSubcategoryID'],
+            relationship: 'many_to_one',
+        });
+    });
+    it('loads the row-bearing natural-key fixture and counts it as headline evidence', async () => {
+        const fixtureRoot = new URL('../../test/fixtures/relationship-benchmarks/', import.meta.url);
+        const naturalKeys = await loadKtxRelationshipBenchmarkFixture(join(fixtureRoot.pathname, 'natural_keys_no_declared_constraints'));
+        expect(naturalKeys.tier).toBe('row_bearing');
+        expect(naturalKeys.defaultModes).toEqual([
+            'declared_pks_and_declared_fks_removed',
+            'llm_disabled',
+            'profiling_disabled',
+            'validation_disabled',
+            'embeddings_disabled',
+        ]);
+        const suite = await runKtxRelationshipBenchmarkSuite({
+            fixtures: [naturalKeys],
+            detector: currentKtxRelationshipBenchmarkDetector(),
+        });
+        const headline = suite.cases.find((item) => item.fixtureId === 'natural_keys_no_declared_constraints' &&
+            item.mode === 'declared_pks_and_declared_fks_removed');
+        expect(headline?.metrics.pkRecall).toBe(1);
+        expect(headline?.metrics.fkRecall).toBe(1);
+        expect(headline?.metrics.acceptedFalsePositiveCount).toBe(0);
+        expect(headline?.predicted.acceptedFk).toEqual(['fct_accounts.(country_code)->dim_countries.(iso_code)']);
+        expect(headline?.falseNegatives.fk).toEqual([]);
+        expect(suite.aggregate.headlineCaseCount).toBe(1);
+        expect(suite.aggregate.headlineFkRecall).toBe(1);
+    });
+    it('accepts plan-code suffix relationships only when validation is available', async () => {
+        const fixtureRoot = new URL('../../test/fixtures/relationship-benchmarks/', import.meta.url);
+        const fixture = await loadKtxRelationshipBenchmarkFixture(join(fixtureRoot.pathname, 'plan_code_no_declared_constraints'));
+        expect(fixture.tier).toBe('row_bearing');
+        expect(fixture.defaultModes).toEqual([
+            'declared_pks_and_declared_fks_removed',
+            'llm_disabled',
+            'profiling_disabled',
+            'validation_disabled',
+            'embeddings_disabled',
+        ]);
+        const suite = await runKtxRelationshipBenchmarkSuite({
+            fixtures: [fixture],
+            detector: currentKtxRelationshipBenchmarkDetector(),
+        });
+        const expectedAccepted = [
+            'mart_account_segments.(current_plan_code)->stg_plans.(plan_code)',
+            'mart_account_segments.(normalized_plan_code)->stg_plans.(plan_code)',
+            'stg_plan_segment_mapping.(canonical_plan_code)->stg_plans.(plan_code)',
+            'stg_plans.(canonical_plan_code)->stg_plans.(plan_code)',
+        ];
+        const headline = suite.cases.find((item) => item.fixtureId === 'plan_code_no_declared_constraints' && item.mode === 'declared_pks_and_declared_fks_removed');
+        const llmDisabled = suite.cases.find((item) => item.fixtureId === 'plan_code_no_declared_constraints' && item.mode === 'llm_disabled');
+        const embeddingsDisabled = suite.cases.find((item) => item.fixtureId === 'plan_code_no_declared_constraints' && item.mode === 'embeddings_disabled');
+        const validationDisabled = suite.cases.find((item) => item.fixtureId === 'plan_code_no_declared_constraints' && item.mode === 'validation_disabled');
+        const profilingDisabled = suite.cases.find((item) => item.fixtureId === 'plan_code_no_declared_constraints' && item.mode === 'profiling_disabled');
+        expect(headline?.predicted.acceptedFk).toEqual(expectedAccepted);
+        expect(headline?.predicted.reviewFk).toEqual([]);
+        expect(headline?.metrics.fkRecall).toBe(1);
+        expect(headline?.metrics.fkPrecision).toBe(1);
+        expect(headline?.metrics.acceptedFalsePositiveCount).toBe(0);
+        expect(llmDisabled?.predicted.acceptedFk).toEqual(expectedAccepted);
+        expect(embeddingsDisabled?.predicted.acceptedFk).toEqual(expectedAccepted);
+        expect(validationDisabled?.predicted.acceptedFk).toEqual([]);
+        expect(validationDisabled?.predicted.reviewFk).toEqual(expectedAccepted);
+        expect(validationDisabled?.validationBlocked).toBe(true);
+        expect(validationDisabled?.metrics.reviewRecall).toBe(1);
+        expect(validationDisabled?.metrics.acceptedOrReviewRecall).toBe(1);
+        expect(profilingDisabled?.predicted.acceptedFk).toEqual([]);
+        expect(profilingDisabled?.validationBlocked).toBe(true);
+        expect(suite.aggregate.headlineCaseCount).toBe(1);
+        expect(suite.aggregate.headlineFkRecall).toBe(1);
+        expect(suite.aggregate.headlineAcceptedOrReviewRecall).toBe(1);
+    });
+    it('uses embedding fixtures for semantic alias relationship benchmark cases', async () => {
+        const fixtureRoot = new URL('../../test/fixtures/relationship-benchmarks/', import.meta.url);
+        const fixture = await loadKtxRelationshipBenchmarkFixture(join(fixtureRoot.pathname, 'semantic_embedding_aliases_no_declared_constraints'));
+        expect(fixture.columnEmbeddings).toMatchObject({
+            'customers.id': [1, 0, 0],
+            'orders.buyer_ref': [0.995, 0.005, 0],
+        });
+        const withEmbeddings = await runKtxRelationshipBenchmarkCase({
+            fixture,
+            mode: 'declared_pks_and_declared_fks_removed',
+            detector: currentKtxRelationshipBenchmarkDetector(),
+        });
+        const withoutEmbeddings = await runKtxRelationshipBenchmarkCase({
+            fixture,
+            mode: 'embeddings_disabled',
+            detector: currentKtxRelationshipBenchmarkDetector(),
+        });
+        expect(withEmbeddings.predicted.acceptedFk).toEqual(['orders.(buyer_ref)->customers.(id)']);
+        expect(withEmbeddings.metrics.fkRecall).toBe(1);
+        expect(withEmbeddings.metrics.acceptedFalsePositiveCount).toBe(0);
+        expect(withEmbeddings.falseNegatives.fk).toEqual([]);
+        expect(withoutEmbeddings.predicted.acceptedFk).toEqual([]);
+        expect(withoutEmbeddings.metrics.fkRecall).toBe(0);
+        expect(withoutEmbeddings.falseNegatives.fk).toEqual(['orders.(buyer_ref)->customers.(id)']);
+    });
+    it('loads the Orbit-style product fixture as curated relationship-discovery benchmark evidence', async () => {
+        const fixtureRoot = new URL('../../test/fixtures/relationship-benchmarks/', import.meta.url);
+        const fixture = await loadKtxRelationshipBenchmarkFixture(join(fixtureRoot.pathname, 'orbit_style_product_no_declared_constraints'));
+        expect(fixture.tier).toBe('product');
+        expect(fixture.thresholdEligible).toBe(true);
+        expect(fixture.defaultModes).toEqual([
+            'declared_pks_and_declared_fks_removed',
+            'llm_disabled',
+            'profiling_disabled',
+            'validation_disabled',
+            'embeddings_disabled',
+        ]);
+        const suite = await runKtxRelationshipBenchmarkSuite({
+            fixtures: [fixture],
+            detector: currentKtxRelationshipBenchmarkDetector(),
+        });
+        const headline = suite.cases.find((item) => item.fixtureId === 'orbit_style_product_no_declared_constraints' &&
+            item.mode === 'declared_pks_and_declared_fks_removed');
+        const validationDisabled = suite.cases.find((item) => item.fixtureId === 'orbit_style_product_no_declared_constraints' && item.mode === 'validation_disabled');
+        expect(headline?.expected.fk).toHaveLength(9);
+        expect(headline?.metrics.pkRecall).toBe(1);
+        expect(headline?.metrics.fkRecall).toBe(1);
+        expect(headline?.metrics.acceptedFalsePositiveCount).toBe(0);
+        expect(headline?.predicted.acceptedFk).toEqual([
+            'dim_users.(account_id)->dim_accounts.(id)',
+            'dim_workspaces.(account_id)->dim_accounts.(id)',
+            'dim_workspaces.(user_id)->dim_users.(id)',
+            'fct_invoices.(account_id)->dim_accounts.(id)',
+            'fct_product_events.(account_id)->dim_accounts.(id)',
+            'fct_product_events.(user_id)->dim_users.(id)',
+            'fct_product_events.(workspace_id)->dim_workspaces.(id)',
+            'support_tickets.(account_id)->dim_accounts.(id)',
+            'support_tickets.(user_id)->dim_users.(id)',
+        ]);
+        expect(headline?.falseNegatives.fk).toEqual([]);
+        expect(validationDisabled?.validationBlocked).toBe(true);
+        expect(suite.aggregate.headlineCaseCount).toBe(1);
+        expect(suite.aggregate.headlineFkRecall).toBe(1);
+        expect(suite.aggregate.headlinePkRecall).toBe(1);
+    });
+});