@codeyam/codeyam-cli 0.1.7 → 0.1.9

package/codeyam-cli/src/utils/__tests__/editorAudit.test.js

@@ -0,0 +1,855 @@
+import { isComponent, classifyGlossaryEntries, computeAudit, filterGlossaryByChangeStatus, resolveAuditSessionScope, } from "../editorAudit.js";
+describe('editorAudit', () => {
+    describe('isComponent', () => {
+        it('should return true for JSX.Element return type', () => {
+            expect(isComponent({ returnType: 'JSX.Element' })).toBe(true);
+        });
+        it('should return true for React.ReactElement return type', () => {
+            expect(isComponent({ returnType: 'React.ReactElement' })).toBe(true);
+        });
+        it('should return true for ReactNode return type', () => {
+            expect(isComponent({ returnType: 'ReactNode' })).toBe(true);
+        });
+        it('should return true for Element return type', () => {
+            expect(isComponent({ returnType: 'Element' })).toBe(true);
+        });
+        it('should return true when JSX appears anywhere in the return type', () => {
+            expect(isComponent({ returnType: 'Promise<JSX.Element>' })).toBe(true);
+        });
+        it('should return false for non-component return types', () => {
+            expect(isComponent({ returnType: 'number' })).toBe(false);
+            expect(isComponent({ returnType: 'string' })).toBe(false);
+            expect(isComponent({ returnType: 'void' })).toBe(false);
+        });
+        it('should return false when returnType is undefined', () => {
+            expect(isComponent({})).toBe(false);
+        });
+        it('should return false when returnType is empty string', () => {
+            expect(isComponent({ returnType: '' })).toBe(false);
+        });
+    });
+    describe('classifyGlossaryEntries', () => {
+        it('should classify entries with JSX return types as components', () => {
+            const entries = [
+                {
+                    name: 'DrinkCard',
+                    filePath: 'app/components/DrinkCard.tsx',
+                    returnType: 'JSX.Element',
+                },
+                {
+                    name: 'calculatePrice',
+                    filePath: 'app/lib/pricing.ts',
+                    returnType: 'number',
+                },
+            ];
+            const result = classifyGlossaryEntries(entries);
+            expect(result.components).toHaveLength(1);
+            expect(result.components[0].name).toBe('DrinkCard');
+            expect(result.functions).toHaveLength(1);
+            expect(result.functions[0].name).toBe('calculatePrice');
+        });
+        it('should return empty arrays for empty input', () => {
+            const result = classifyGlossaryEntries([]);
+            expect(result.components).toEqual([]);
+            expect(result.functions).toEqual([]);
+        });
+        it('should treat entries without returnType as functions', () => {
+            const entries = [{ name: 'helper', filePath: 'app/lib/helper.ts' }];
+            const result = classifyGlossaryEntries(entries);
+            expect(result.components).toHaveLength(0);
+            expect(result.functions).toHaveLength(1);
+        });
+        it('should handle all components', () => {
+            const entries = [
+                {
+                    name: 'Header',
+                    filePath: 'app/components/Header.tsx',
+                    returnType: 'ReactNode',
+                },
+                {
+                    name: 'Footer',
+                    filePath: 'app/components/Footer.tsx',
+                    returnType: 'JSX.Element',
+                },
+            ];
+            const result = classifyGlossaryEntries(entries);
+            expect(result.components).toHaveLength(2);
+            expect(result.functions).toHaveLength(0);
+        });
+        it('should handle all functions', () => {
+            const entries = [
+                { name: 'add', filePath: 'app/lib/math.ts', returnType: 'number' },
+                { name: 'format', filePath: 'app/lib/format.ts', returnType: 'string' },
+            ];
+            const result = classifyGlossaryEntries(entries);
+            expect(result.components).toHaveLength(0);
+            expect(result.functions).toHaveLength(2);
+        });
+    });
+    describe('computeAudit', () => {
+        it('should mark components with scenarios as ok', () => {
+            const result = computeAudit({
+                components: [
+                    { name: 'DrinkCard', filePath: 'app/components/DrinkCard.tsx' },
+                ],
+                functions: [],
+                scenarioCounts: { DrinkCard: 2 },
+                testFileExistence: {},
+            });
+            expect(result.components[0].status).toBe('ok');
+            expect(result.components[0].scenarioCount).toBe(2);
+            expect(result.summary.componentsOk).toBe(1);
+            expect(result.summary.componentsMissing).toBe(0);
+        });
+        it('should mark components without scenarios as missing', () => {
+            const result = computeAudit({
+                components: [
+                    { name: 'DrinkCard', filePath: 'app/components/DrinkCard.tsx' },
+                ],
+                functions: [],
+                scenarioCounts: {},
+                testFileExistence: {},
+            });
+            expect(result.components[0].status).toBe('missing');
+            expect(result.components[0].scenarioCount).toBe(0);
+            expect(result.summary.componentsMissing).toBe(1);
+        });
+        it('should mark functions with existing test files as ok', () => {
+            const result = computeAudit({
+                components: [],
+                functions: [
+                    {
+                        name: 'calculatePrice',
+                        filePath: 'app/lib/pricing.ts',
+                        testFile: 'app/lib/pricing.test.ts',
+                    },
+                ],
+                scenarioCounts: {},
+                testFileExistence: { 'app/lib/pricing.test.ts': true },
+            });
+            expect(result.functions[0].status).toBe('ok');
+            expect(result.functions[0].testFileExists).toBe(true);
+            expect(result.summary.functionsOk).toBe(1);
+            expect(result.summary.functionsMissing).toBe(0);
+        });
+        it('should mark functions with missing test files as missing', () => {
+            const result = computeAudit({
+                components: [],
+                functions: [
+                    {
+                        name: 'calculatePrice',
+                        filePath: 'app/lib/pricing.ts',
+                        testFile: 'app/lib/pricing.test.ts',
+                    },
+                ],
+                scenarioCounts: {},
+                testFileExistence: { 'app/lib/pricing.test.ts': false },
+            });
+            expect(result.functions[0].status).toBe('missing');
+            expect(result.functions[0].testFileExists).toBe(false);
+            expect(result.summary.functionsMissing).toBe(1);
+        });
+        it('should mark functions without testFile field as missing', () => {
+            const result = computeAudit({
+                components: [],
+                functions: [{ name: 'calculatePrice', filePath: 'app/lib/pricing.ts' }],
+                scenarioCounts: {},
+                testFileExistence: {},
+            });
+            expect(result.functions[0].status).toBe('missing');
+            expect(result.functions[0].testFile).toBeUndefined();
+            expect(result.functions[0].testFileExists).toBe(false);
+        });
+        it('should set allPassing to true when everything is ok', () => {
+            const result = computeAudit({
+                components: [
+                    { name: 'DrinkCard', filePath: 'app/components/DrinkCard.tsx' },
+                ],
+                functions: [
+                    {
+                        name: 'calculatePrice',
+                        filePath: 'app/lib/pricing.ts',
+                        testFile: 'app/lib/pricing.test.ts',
+                    },
+                ],
+                scenarioCounts: { DrinkCard: 1 },
+                testFileExistence: { 'app/lib/pricing.test.ts': true },
+            });
+            expect(result.summary.allPassing).toBe(true);
+        });
+        it('should set allPassing to false when any component is missing', () => {
+            const result = computeAudit({
+                components: [
+                    { name: 'DrinkCard', filePath: 'app/components/DrinkCard.tsx' },
+                ],
+                functions: [],
+                scenarioCounts: {},
+                testFileExistence: {},
+            });
+            expect(result.summary.allPassing).toBe(false);
+        });
+        it('should set allPassing to false when any function is missing', () => {
+            const result = computeAudit({
+                components: [],
+                functions: [{ name: 'calculatePrice', filePath: 'app/lib/pricing.ts' }],
+                scenarioCounts: {},
+                testFileExistence: {},
+            });
+            expect(result.summary.allPassing).toBe(false);
+        });
+        it('should set allPassing to true for empty inputs', () => {
+            const result = computeAudit({
+                components: [],
+                functions: [],
+                scenarioCounts: {},
+                testFileExistence: {},
+            });
+            expect(result.summary.allPassing).toBe(true);
+            expect(result.summary.totalComponents).toBe(0);
+            expect(result.summary.totalFunctions).toBe(0);
+        });
+        it('should compute correct summary totals', () => {
+            const result = computeAudit({
+                components: [
+                    { name: 'DrinkCard', filePath: 'app/components/DrinkCard.tsx' },
+                    { name: 'Header', filePath: 'app/components/Header.tsx' },
+                    { name: 'Footer', filePath: 'app/components/Footer.tsx' },
+                ],
+                functions: [
+                    {
+                        name: 'calculatePrice',
+                        filePath: 'app/lib/pricing.ts',
+                        testFile: 'app/lib/pricing.test.ts',
+                    },
+                    {
+                        name: 'formatDate',
+                        filePath: 'app/lib/format.ts',
+                        testFile: 'app/lib/format.test.ts',
+                    },
+                ],
+                scenarioCounts: { DrinkCard: 3, Header: 1 },
+                testFileExistence: {
+                    'app/lib/pricing.test.ts': true,
+                    'app/lib/format.test.ts': false,
+                },
+            });
+            expect(result.summary.totalComponents).toBe(3);
+            expect(result.summary.componentsOk).toBe(2);
+            expect(result.summary.componentsMissing).toBe(1);
+            expect(result.summary.totalFunctions).toBe(2);
+            expect(result.summary.functionsOk).toBe(1);
+            expect(result.summary.functionsMissing).toBe(1);
+            expect(result.summary.allPassing).toBe(false);
+        });
+        // ── Test results integration ────────────────────────────────────
+        it('should mark function as ok when tests pass and describe matches entity name', () => {
+            const result = computeAudit({
+                components: [],
+                functions: [
+                    {
+                        name: 'calculatePrice',
+                        filePath: 'app/lib/pricing.ts',
+                        testFile: 'app/lib/pricing.test.ts',
+                    },
+                ],
+                scenarioCounts: {},
+                testFileExistence: { 'app/lib/pricing.test.ts': true },
+                testResults: {
+                    'app/lib/pricing.test.ts': {
+                        passing: true,
+                        hasEntityNameDescribe: true,
+                    },
+                },
+            });
+            expect(result.functions[0].status).toBe('ok');
+            expect(result.functions[0].testsPassing).toBe(true);
+            expect(result.functions[0].testsVisibleInUi).toBe(true);
+        });
+        it('should mark function as failing when tests fail', () => {
+            const result = computeAudit({
+                components: [],
+                functions: [
+                    {
+                        name: 'calculatePrice',
+                        filePath: 'app/lib/pricing.ts',
+                        testFile: 'app/lib/pricing.test.ts',
+                    },
+                ],
+                scenarioCounts: {},
+                testFileExistence: { 'app/lib/pricing.test.ts': true },
+                testResults: {
+                    'app/lib/pricing.test.ts': {
+                        passing: false,
+                        hasEntityNameDescribe: true,
+                    },
+                },
+            });
+            expect(result.functions[0].status).toBe('failing');
+            expect(result.functions[0].testsPassing).toBe(false);
+            expect(result.functions[0].testsVisibleInUi).toBe(true);
+        });
+        it('should mark function as name_mismatch when tests pass but no describe matches', () => {
+            const result = computeAudit({
+                components: [],
+                functions: [
+                    {
+                        name: 'useDrinks',
+                        filePath: 'app/hooks/useDrinks.ts',
+                        testFile: 'app/hooks/useDrinks.test.ts',
+                    },
+                ],
+                scenarioCounts: {},
+                testFileExistence: { 'app/hooks/useDrinks.test.ts': true },
+                testResults: {
+                    'app/hooks/useDrinks.test.ts': {
+                        passing: true,
+                        hasEntityNameDescribe: false,
+                    },
+                },
+            });
+            expect(result.functions[0].status).toBe('name_mismatch');
+            expect(result.functions[0].testsPassing).toBe(true);
+            expect(result.functions[0].testsVisibleInUi).toBe(false);
+        });
+        it('should still mark function as missing when test file does not exist even with testResults', () => {
+            const result = computeAudit({
+                components: [],
+                functions: [
+                    {
+                        name: 'calculatePrice',
+                        filePath: 'app/lib/pricing.ts',
+                        testFile: 'app/lib/pricing.test.ts',
+                    },
+                ],
+                scenarioCounts: {},
+                testFileExistence: { 'app/lib/pricing.test.ts': false },
+                testResults: {},
+            });
+            expect(result.functions[0].status).toBe('missing');
+            expect(result.functions[0].testsPassing).toBeUndefined();
+            expect(result.functions[0].testsVisibleInUi).toBeUndefined();
+        });
+        it('should include functionsFailing and functionsNameMismatch in summary', () => {
+            const result = computeAudit({
+                components: [],
+                functions: [
+                    {
+                        name: 'fnOk',
+                        filePath: 'a.ts',
+                        testFile: 'a.test.ts',
+                    },
+                    {
+                        name: 'fnFailing',
+                        filePath: 'b.ts',
+                        testFile: 'b.test.ts',
+                    },
+                    {
+                        name: 'fnMismatch',
+                        filePath: 'c.ts',
+                        testFile: 'c.test.ts',
+                    },
+                    {
+                        name: 'fnMissing',
+                        filePath: 'd.ts',
+                        testFile: 'd.test.ts',
+                    },
+                ],
+                scenarioCounts: {},
+                testFileExistence: {
+                    'a.test.ts': true,
+                    'b.test.ts': true,
+                    'c.test.ts': true,
+                    'd.test.ts': false,
+                },
+                testResults: {
+                    'a.test.ts': { passing: true, hasEntityNameDescribe: true },
+                    'b.test.ts': { passing: false, hasEntityNameDescribe: true },
+                    'c.test.ts': { passing: true, hasEntityNameDescribe: false },
+                },
+            });
+            expect(result.summary.functionsOk).toBe(1);
+            expect(result.summary.functionsFailing).toBe(1);
+            expect(result.summary.functionsNameMismatch).toBe(1);
+            expect(result.summary.functionsMissing).toBe(1);
+            expect(result.summary.allPassing).toBe(false);
+        });
+        it('should set allPassing to true only when all functions are ok', () => {
+            const result = computeAudit({
+                components: [
+                    { name: 'DrinkCard', filePath: 'app/components/DrinkCard.tsx' },
+                ],
+                functions: [
+                    {
+                        name: 'calculatePrice',
+                        filePath: 'app/lib/pricing.ts',
+                        testFile: 'app/lib/pricing.test.ts',
+                    },
+                ],
+                scenarioCounts: { DrinkCard: 1 },
+                testFileExistence: { 'app/lib/pricing.test.ts': true },
+                testResults: {
+                    'app/lib/pricing.test.ts': {
+                        passing: true,
+                        hasEntityNameDescribe: true,
+                    },
+                },
+            });
+            expect(result.summary.allPassing).toBe(true);
+        });
+        it('should set allPassing to false when any function is failing', () => {
+            const result = computeAudit({
+                components: [],
+                functions: [
+                    {
+                        name: 'calculatePrice',
+                        filePath: 'app/lib/pricing.ts',
+                        testFile: 'app/lib/pricing.test.ts',
+                    },
+                ],
+                scenarioCounts: {},
+                testFileExistence: { 'app/lib/pricing.test.ts': true },
+                testResults: {
+                    'app/lib/pricing.test.ts': {
+                        passing: false,
+                        hasEntityNameDescribe: true,
+                    },
+                },
+            });
+            expect(result.summary.allPassing).toBe(false);
+        });
+        it('should set allPassing to false when any function has name_mismatch', () => {
+            const result = computeAudit({
+                components: [],
+                functions: [
+                    {
+                        name: 'useDrinks',
+                        filePath: 'app/hooks/useDrinks.ts',
+                        testFile: 'app/hooks/useDrinks.test.ts',
+                    },
+                ],
+                scenarioCounts: {},
+                testFileExistence: { 'app/hooks/useDrinks.test.ts': true },
+                testResults: {
+                    'app/hooks/useDrinks.test.ts': {
+                        passing: true,
+                        hasEntityNameDescribe: false,
+                    },
+                },
+            });
+            expect(result.summary.allPassing).toBe(false);
+        });
+        it('should fall back to file-existence-only behavior when testResults is not provided', () => {
+            // Backward compat: no testResults → existing behavior
+            const result = computeAudit({
+                components: [],
+                functions: [
+                    {
+                        name: 'calculatePrice',
+                        filePath: 'app/lib/pricing.ts',
+                        testFile: 'app/lib/pricing.test.ts',
+                    },
+                ],
+                scenarioCounts: {},
+                testFileExistence: { 'app/lib/pricing.test.ts': true },
+            });
+            expect(result.functions[0].status).toBe('ok');
+            expect(result.functions[0].testsPassing).toBeUndefined();
+            expect(result.functions[0].testsVisibleInUi).toBeUndefined();
+        });
+        it('should fall back to file-existence-only when testResults is empty for a given file', () => {
+            const result = computeAudit({
+                components: [],
+                functions: [
+                    {
+                        name: 'calculatePrice',
+                        filePath: 'app/lib/pricing.ts',
+                        testFile: 'app/lib/pricing.test.ts',
+                    },
+                ],
+                scenarioCounts: {},
+                testFileExistence: { 'app/lib/pricing.test.ts': true },
+                testResults: {},
+            });
+            // No test result for this file → fall back to existence check
+            expect(result.functions[0].status).toBe('ok');
+            expect(result.functions[0].testsPassing).toBeUndefined();
+            expect(result.functions[0].testsVisibleInUi).toBeUndefined();
+        });
+        // ── Client errors integration ─────────────────────────────────────
+        it('should mark component as has_errors when clientErrors reports errors', () => {
+            const result = computeAudit({
+                components: [
+                    { name: 'DrinkInfo', filePath: 'app/components/DrinkInfo.tsx' },
+                ],
+                functions: [],
+                scenarioCounts: { DrinkInfo: 3 },
+                testFileExistence: {},
+                clientErrors: {
+                    DrinkInfo: ['Cannot read properties of undefined'],
+                },
+            });
+            expect(result.components[0].status).toBe('has_errors');
+            expect(result.components[0].clientErrors).toEqual([
+                'Cannot read properties of undefined',
+            ]);
+            expect(result.summary.componentsWithErrors).toBe(1);
+            expect(result.summary.allPassing).toBe(false);
+        });
+        it('should not count client errors for components with no scenarios', () => {
+            // If a component has no scenarios AND errors, it's still "missing"
+            // (errors come from scenarios, so if there are none, errors are stale)
+            const result = computeAudit({
+                components: [
+                    { name: 'DrinkInfo', filePath: 'app/components/DrinkInfo.tsx' },
+                ],
+                functions: [],
+                scenarioCounts: {},
+                testFileExistence: {},
+                clientErrors: {
+                    DrinkInfo: ['Cannot read properties of undefined'],
+                },
+            });
+            expect(result.components[0].status).toBe('missing');
+        });
+        it('should set allPassing false when any component has errors', () => {
+            const result = computeAudit({
+                components: [
+                    { name: 'DrinkCard', filePath: 'app/components/DrinkCard.tsx' },
+                    { name: 'DrinkInfo', filePath: 'app/components/DrinkInfo.tsx' },
+                ],
+                functions: [],
+                scenarioCounts: { DrinkCard: 2, DrinkInfo: 3 },
+                testFileExistence: {},
+                clientErrors: {
+                    DrinkInfo: ['TypeError: something broke'],
+                },
+            });
+            expect(result.summary.allPassing).toBe(false);
+            expect(result.summary.componentsOk).toBe(1);
+            expect(result.summary.componentsWithErrors).toBe(1);
+        });
+    });
+    // ── filterGlossaryByChangeStatus ──────────────────────────────────
+    describe('filterGlossaryByChangeStatus', () => {
+        const allEntries = [
+            // Feature 1 components (unchanged)
+            {
+                name: 'StarRating',
+                filePath: 'app/components/StarRating.tsx',
+                returnType: 'JSX.Element',
+            },
+            {
+                name: 'CategoryBadge',
+                filePath: 'app/components/CategoryBadge.tsx',
+                returnType: 'JSX.Element',
+            },
+            {
+                name: 'DrinkCard',
+                filePath: 'app/components/DrinkCard.tsx',
+                returnType: 'JSX.Element',
+            },
+            // Feature 2 components (new)
+            {
+                name: 'HeroImage',
+                filePath: 'app/components/HeroImage.tsx',
+                returnType: 'JSX.Element',
+            },
+            {
+                name: 'ReviewCard',
+                filePath: 'app/components/ReviewCard.tsx',
+                returnType: 'JSX.Element',
+            },
+            // Feature 1 function (unchanged)
+            {
+                name: 'computeAvgRating',
+                filePath: 'app/lib/ratings.ts',
+                returnType: 'number',
+                testFile: 'app/lib/ratings.test.ts',
+            },
+            // Feature 2 function (new)
+            {
+                name: 'formatReviewCount',
+                filePath: 'app/lib/formatting.ts',
+                returnType: 'string',
+                testFile: 'app/lib/formatting.test.ts',
+            },
+        ];
+        it('should only include entries whose files are new, edited, or impacted', () => {
+            const entityChangeStatus = {
+                HeroImage: { status: 'new' },
+                ReviewCard: { status: 'new' },
+                formatReviewCount: { status: 'new' },
+                // DrinkCard edited because it now links to detail page
+                DrinkCard: { status: 'edited' },
+                // StarRating impacted because DrinkInfo uses it
+                StarRating: {
+                    status: 'impacted',
+                    impactedBy: [
+                        {
+                            name: 'DrinkInfo',
+                            filePath: 'app/components/DrinkInfo.tsx',
+                            changeType: 'new',
+                        },
+                    ],
+                },
+            };
+            const filtered = filterGlossaryByChangeStatus(allEntries, entityChangeStatus);
+            const names = filtered.map((e) => e.name).sort();
+            expect(names).toEqual([
+                'DrinkCard',
+                'HeroImage',
+                'ReviewCard',
+                'StarRating',
+                'formatReviewCount',
+            ]);
+        });
+        it('should return all entries when entityChangeStatus is empty', () => {
+            // When there's no change status data (e.g., no git changes), fall back to auditing everything
+            const filtered = filterGlossaryByChangeStatus(allEntries, {});
+            expect(filtered).toEqual(allEntries);
+        });
+        it('should return all entries when entityChangeStatus is undefined', () => {
+            const filtered = filterGlossaryByChangeStatus(allEntries, undefined);
+            expect(filtered).toEqual(allEntries);
+        });
+        it('should exclude unchanged entries that have no status', () => {
+            const entityChangeStatus = {
+                HeroImage: { status: 'new' },
+            };
+            const filtered = filterGlossaryByChangeStatus(allEntries, entityChangeStatus);
+            expect(filtered).toHaveLength(1);
+            expect(filtered[0].name).toBe('HeroImage');
+        });
+        it('should match entries by filePath when name does not match any status key', () => {
+            // Sometimes entity names in entityChangeStatus are derived from file paths
+            // and may not exactly match glossary names. Fall back to filePath matching.
+            const entityChangeStatus = {
+                // Entity name derived differently, but filePath matches
+                'app/components/DrinkCard.tsx': { status: 'edited' },
+            };
+            const filtered = filterGlossaryByChangeStatus(allEntries, entityChangeStatus);
+            expect(filtered.map((e) => e.name)).toContain('DrinkCard');
+        });
+    });
+    // ── resolveAuditSessionScope ──────────────────────────────────────
+    describe('resolveAuditSessionScope', () => {
+        it('should scope to session when entityChangeStatus has entries and featureStartedAt exists', () => {
+            const result = resolveAuditSessionScope({
+                featureStartedAt: '2026-03-12T14:01:31.291Z',
+                entityChangeStatus: {
+                    ArticleCard: { status: 'new' },
+                    LibraryHeader: { status: 'new' },
+                },
+            });
+            expect(result.featureStartedAt).toBe('2026-03-12T14:01:31.291Z');
+            expect(result.entityChangeStatus).toEqual({
+                ArticleCard: { status: 'new' },
+                LibraryHeader: { status: 'new' },
+            });
+        });
+        it('should NOT scope scenario counts to session when entityChangeStatus is empty', () => {
+            // This is the testapp bug: entityChangeStatus computation returned empty,
+            // so the glossary filter falls back to "audit all components", but the
+            // scenario count query still filters by featureStartedAt — causing
+            // Feature 1 components to appear as "no scenarios" even though they have them.
+            const result = resolveAuditSessionScope({
+                featureStartedAt: '2026-03-12T14:01:31.291Z',
+                entityChangeStatus: undefined,
+            });
+            // When we can't scope the glossary, we shouldn't scope scenario counts either
+            expect(result.featureStartedAt).toBeNull();
+        });
+        it('should NOT scope scenario counts to session when entityChangeStatus is an empty object', () => {
+            const result = resolveAuditSessionScope({
+                featureStartedAt: '2026-03-12T14:01:31.291Z',
+                entityChangeStatus: {},
+            });
+            expect(result.featureStartedAt).toBeNull();
+        });
+        it('should return null featureStartedAt when none was provided', () => {
+            const result = resolveAuditSessionScope({
+                featureStartedAt: null,
+                entityChangeStatus: { Header: { status: 'new' } },
+            });
+            expect(result.featureStartedAt).toBeNull();
+        });
+        it('should pass through entityChangeStatus unchanged when it has entries', () => {
+            const ecs = {
+                ArticleCard: { status: 'new' },
+                Header: { status: 'edited' },
+            };
+            const result = resolveAuditSessionScope({
+                featureStartedAt: '2026-03-12T14:01:31.291Z',
+                entityChangeStatus: ecs,
+            });
+            expect(result.entityChangeStatus).toBe(ecs);
+        });
+        describe('multi-feature audit scenario (testapp reproduction)', () => {
+            // Reproduces the exact testapp bug:
+            // - Feature 1 built 8 components with scenarios at 13:28-13:30
+            // - Feature 2 starts at 14:01, builds 4 new components with scenarios at 14:14-14:16
+            // - entityChangeStatus computation returns empty (fails/returns {})
+            // - Glossary includes ALL 12 components
+            // - Scenario counts only include Feature 2 scenarios (after 14:01)
+            // - Result: Feature 1's 8 components reported as "no scenarios"
+            const allComponents = [
+                // Feature 1 components
+                {
+                    name: 'Header',
+                    filePath: 'src/components/Header.tsx',
+                    returnType: 'JSX.Element',
+                },
+                {
+                    name: 'Logo',
+                    filePath: 'src/components/Logo.tsx',
+                    returnType: 'JSX.Element',
+                },
+                {
+                    name: 'TabBar',
+                    filePath: 'src/components/TabBar.tsx',
+                    returnType: 'JSX.Element',
+                },
+                {
+                    name: 'ArticlePreview',
+                    filePath: 'src/components/ArticlePreview.tsx',
+                    returnType: 'JSX.Element',
+                },
+                {
+                    name: 'SaveButton',
+                    filePath: 'src/components/SaveButton.tsx',
+                    returnType: 'JSX.Element',
+                },
+                {
+                    name: 'StatusBanner',
+                    filePath: 'src/components/StatusBanner.tsx',
+                    returnType: 'JSX.Element',
+                },
+                {
+                    name: 'EmptyState',
+                    filePath: 'src/components/EmptyState.tsx',
+                    returnType: 'JSX.Element',
+                },
+                {
+                    name: 'ArticleRow',
+                    filePath: 'src/components/ArticleRow.tsx',
+                    returnType: 'JSX.Element',
+                },
+                // Feature 2 components
+                {
+                    name: 'ArticleCard',
+                    filePath: 'src/components/ArticleCard.tsx',
+                    returnType: 'JSX.Element',
+                },
+                {
+                    name: 'LibraryHeader',
+                    filePath: 'src/components/LibraryHeader.tsx',
+                    returnType: 'JSX.Element',
+                },
+                {
+                    name: 'ArticleCardGrid',
+                    filePath: 'src/components/ArticleCardGrid.tsx',
+                    returnType: 'JSX.Element',
+                },
+                {
+                    name: 'OpenLibraryButton',
+                    filePath: 'src/components/OpenLibraryButton.tsx',
+                    returnType: 'JSX.Element',
+                },
+            ];
+            // All scenarios that exist in the DB (both features)
+            const allScenarioCounts = {
+                Header: 2,
+                Logo: 1,
+                TabBar: 3,
+                ArticlePreview: 4,
+                SaveButton: 2,
+                StatusBanner: 2,
+                EmptyState: 2,
+                ArticleRow: 3,
+                ArticleCard: 4,
+                LibraryHeader: 3,
+                ArticleCardGrid: 2,
+                OpenLibraryButton: 1,
+            };
+            // Only Feature 2 scenarios (created after featureStartedAt)
+            const sessionScopedCounts = {
+                ArticleCard: 4,
+                LibraryHeader: 3,
+                ArticleCardGrid: 2,
+                OpenLibraryButton: 1,
+            };
+            it('should pass audit when entityChangeStatus is empty and all scenarios are counted', () => {
+                // With the fix: resolveAuditSessionScope nullifies featureStartedAt
+                // when entityChangeStatus is empty, so ALL scenarios are counted
+                const scope = resolveAuditSessionScope({
+                    featureStartedAt: '2026-03-12T14:01:31.291Z',
+                    entityChangeStatus: undefined,
+                });
+                // Glossary filter: returns all (no change status to filter by)
+                const filtered = filterGlossaryByChangeStatus(allComponents, scope.entityChangeStatus);
+                expect(filtered).toHaveLength(12);
+                // Since featureStartedAt is now null, the route would query ALL scenarios
+                // (not session-scoped), giving us allScenarioCounts
+                const countsToUse = scope.featureStartedAt
+                    ? sessionScopedCounts
+                    : allScenarioCounts;
+                const { components } = classifyGlossaryEntries(filtered);
+                const result = computeAudit({
+                    components,
+                    functions: [],
+                    scenarioCounts: countsToUse,
+                    testFileExistence: {},
+                });
+                // Every component should have scenarios
+                expect(result.summary.componentsMissing).toBe(0);
+                expect(result.summary.componentsOk).toBe(12);
+                expect(result.summary.allPassing).toBe(true);
+            });
+            it('demonstrates the bug: session-scoped counts with unscoped glossary fails Feature 1', () => {
+                // WITHOUT the fix: entityChangeStatus is empty so all 12 components are audited,
+                // but scenario counts are session-scoped so Feature 1 components get 0
+                const filtered = filterGlossaryByChangeStatus(allComponents, undefined);
+                expect(filtered).toHaveLength(12);
+                const { components } = classifyGlossaryEntries(filtered);
+                const result = computeAudit({
+                    components,
+                    functions: [],
+                    scenarioCounts: sessionScopedCounts, // BUG: only Feature 2 scenarios
+                    testFileExistence: {},
+                });
+                // This is the broken behavior — 8 components incorrectly flagged
+                expect(result.summary.componentsMissing).toBe(8);
+                expect(result.summary.allPassing).toBe(false);
+            });
+            it('should correctly scope audit when entityChangeStatus is available', () => {
+                // When entityChangeStatus works, only Feature 2 components are audited
+                // and only Feature 2 scenarios are counted — both filters agree
+                const ecs = {
+                    ArticleCard: { status: 'new' },
+                    LibraryHeader: { status: 'new' },
+                    ArticleCardGrid: { status: 'new' },
+                    OpenLibraryButton: { status: 'new' },
+                };
+                const scope = resolveAuditSessionScope({
+                    featureStartedAt: '2026-03-12T14:01:31.291Z',
+                    entityChangeStatus: ecs,
+                });
+                // featureStartedAt preserved — session scoping is valid
+                expect(scope.featureStartedAt).toBe('2026-03-12T14:01:31.291Z');
+                const filtered = filterGlossaryByChangeStatus(allComponents, scope.entityChangeStatus);
+                expect(filtered).toHaveLength(4); // Only Feature 2 components
+                const { components } = classifyGlossaryEntries(filtered);
+                const result = computeAudit({
+                    components,
+                    functions: [],
+                    scenarioCounts: sessionScopedCounts,
+                    testFileExistence: {},
+                });
+                expect(result.summary.componentsMissing).toBe(0);
+                expect(result.summary.componentsOk).toBe(4);
+                expect(result.summary.allPassing).toBe(true);
+            });
+        });
+    });
+});
+//# sourceMappingURL=editorAudit.test.js.map