@codeyam/codeyam-cli 0.1.0-staging.8778565 → 0.1.0-staging.87dd4be

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

@@ -1,4 +1,6 @@
-import { isComponent, classifyGlossaryEntries, computeAudit, filterGlossaryByChangeStatus, } from "../editorAudit.js";
+import Database from 'better-sqlite3';
+import { Kysely, SqliteDialect } from 'kysely';
+import { isComponent, classifyGlossaryEntries, computeAudit, filterGlossaryByChangeStatus, resolveAuditSessionScope, queryScenarioCounts, queryPageScenarioCounts, queryIncompleteEntities, queryMiscategorizedScenarios, isOnlyIncompleteEntities, isAutoRemediable, identifyScenariosNeedingRecapture, detectDuplicateNames, } from "../editorAudit.js";
 describe('editorAudit', () => {
     describe('isComponent', () => {
         it('should return true for JSX.Element return type', () => {
@@ -288,6 +290,29 @@ describe('editorAudit', () => {
             expect(result.functions[0].testsPassing).toBe(false);
             expect(result.functions[0].testsVisibleInUi).toBe(true);
         });
+        it('should distinguish runner errors from test failures and include error message', () => {
+            const result = computeAudit({
+                components: [],
+                functions: [
+                    {
+                        name: 'getTimeAgo',
+                        filePath: 'src/lib/format.ts',
+                        testFile: 'src/lib/format.test.ts',
+                    },
+                ],
+                scenarioCounts: {},
+                testFileExistence: { 'src/lib/format.test.ts': true },
+                testResults: {
+                    'src/lib/format.test.ts': {
+                        passing: false,
+                        hasEntityNameDescribe: false,
+                        errorMessage: 'Error: Cannot find module "@/lib/format" from "src/lib/format.test.ts"',
+                    },
+                },
+            });
+            expect(result.functions[0].status).toBe('runner_error');
+            expect(result.functions[0].errorMessage).toBe('Error: Cannot find module "@/lib/format" from "src/lib/format.test.ts"');
+        });
         it('should mark function as name_mismatch when tests pass but no describe matches', () => {
             const result = computeAudit({
                 components: [],
@@ -631,5 +656,2025 @@ describe('editorAudit', () => {
             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);
+            });
+        });
+    });
+    // ── queryScenarioCounts ─────────────────────────────────────────────
+    describe('queryScenarioCounts', () => {
+        let db;
+        let rawDb;
+        const projectId = 'test-project-id';
+        beforeEach(async () => {
+            rawDb = new Database(':memory:');
+            db = new Kysely({ dialect: new SqliteDialect({ database: rawDb }) });
+            await db.schema
+                .createTable('editor_scenarios')
+                .addColumn('id', 'varchar', (col) => col.primaryKey())
+                .addColumn('project_id', 'varchar', (col) => col.notNull())
+                .addColumn('name', 'varchar', (col) => col.notNull())
+                .addColumn('description', 'text')
+                .addColumn('component_name', 'varchar')
+                .addColumn('component_path', 'varchar')
+                .addColumn('url', 'varchar')
+                .addColumn('type', 'varchar')
+                .addColumn('screenshot_path', 'varchar')
+                .addColumn('viewport_width', 'integer')
+                .addColumn('viewport_height', 'integer')
+                .addColumn('dimension', 'varchar')
+                .addColumn('created_at', 'datetime')
+                .addColumn('updated_at', 'datetime')
+                .execute();
+        });
+        afterEach(async () => {
+            await db.destroy();
+        });
+        it('should count all scenarios when featureStartedAt is null', async () => {
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-1',
+                project_id: projectId,
+                name: 'ArticleRow - Default',
+                component_name: 'ArticleRow',
+                viewport_width: 1280,
+                viewport_height: 720,
+                created_at: '2026-03-12 13:00:00',
+            })
+                .execute();
+            const counts = await queryScenarioCounts(db, projectId, null);
+            expect(counts).toEqual({ ArticleRow: 1 });
+        });
+        it('should count scenarios created after featureStartedAt', async () => {
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-1',
+                project_id: projectId,
+                name: 'ArticleRow - Default',
+                component_name: 'ArticleRow',
+                viewport_width: 1280,
+                viewport_height: 720,
+                created_at: '2026-03-12 14:30:00',
+            })
+                .execute();
+            const counts = await queryScenarioCounts(db, projectId, '2026-03-12T14:01:31.291Z');
+            expect(counts).toEqual({ ArticleRow: 1 });
+        });
+        it('should exclude scenarios created before featureStartedAt', async () => {
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-1',
+                project_id: projectId,
+                name: 'ArticleRow - Default',
+                component_name: 'ArticleRow',
+                viewport_width: 1280,
+                viewport_height: 720,
+                created_at: '2026-03-12 13:00:00',
+            })
+                .execute();
+            const counts = await queryScenarioCounts(db, projectId, '2026-03-12T14:01:31.291Z');
+            expect(counts).toEqual({});
+        });
+        it('should count re-registered scenarios whose updated_at is after featureStartedAt', async () => {
+            // This is the bug: a scenario from Feature 1 (created_at before featureStartedAt)
+            // is re-registered in Feature 2 (updated_at after featureStartedAt).
+            // The audit should count it because it was actively re-registered in this session.
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-1',
+                project_id: projectId,
+                name: 'ArticleRow - Default',
+                component_name: 'ArticleRow',
+                viewport_width: 400,
+                viewport_height: 600,
+                created_at: '2026-03-12 13:28:00', // Feature 1
+                updated_at: '2026-03-12 14:32:00', // Re-registered in Feature 2
+            })
+                .execute();
+            const counts = await queryScenarioCounts(db, projectId, '2026-03-12T14:01:31.291Z');
+            // Should count because updated_at is after featureStartedAt
+            expect(counts).toEqual({ ArticleRow: 1 });
+        });
+        it('should handle mixed scenarios: some new, some re-registered', async () => {
+            // ArticleCard: new in Feature 2 (created_at after featureStartedAt)
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-1',
+                project_id: projectId,
+                name: 'ArticleCard - Default',
+                component_name: 'ArticleCard',
+                viewport_width: 1280,
+                viewport_height: 720,
+                created_at: '2026-03-12 14:14:00',
+            })
+                .execute();
+            // ArticleRow: from Feature 1, re-registered in Feature 2
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-2',
+                project_id: projectId,
+                name: 'ArticleRow - Default',
+                component_name: 'ArticleRow',
+                viewport_width: 400,
+                viewport_height: 600,
+                created_at: '2026-03-12 13:28:00', // Feature 1
+                updated_at: '2026-03-12 14:32:00', // Re-registered in Feature 2
+            })
+                .execute();
+            const counts = await queryScenarioCounts(db, projectId, '2026-03-12T14:01:31.291Z');
+            expect(counts).toEqual({ ArticleCard: 1, ArticleRow: 1 });
+        });
+    });
+    // ── queryPageScenarioCounts ──────────────────────────────────────────
+    describe('queryPageScenarioCounts', () => {
+        let db;
+        let rawDb;
+        const projectId = 'test-project-id';
+        beforeEach(async () => {
+            rawDb = new Database(':memory:');
+            db = new Kysely({ dialect: new SqliteDialect({ database: rawDb }) });
+            await db.schema
+                .createTable('editor_scenarios')
+                .addColumn('id', 'varchar', (col) => col.primaryKey())
+                .addColumn('project_id', 'varchar', (col) => col.notNull())
+                .addColumn('name', 'varchar', (col) => col.notNull())
+                .addColumn('description', 'text')
+                .addColumn('component_name', 'varchar')
+                .addColumn('component_path', 'varchar')
+                .addColumn('page_file_path', 'varchar')
+                .addColumn('url', 'varchar')
+                .addColumn('type', 'varchar')
+                .addColumn('screenshot_path', 'varchar')
+                .addColumn('viewport_width', 'integer')
+                .addColumn('viewport_height', 'integer')
+                .addColumn('dimension', 'varchar')
+                .addColumn('created_at', 'datetime')
+                .addColumn('updated_at', 'datetime')
+                .execute();
+        });
+        afterEach(async () => {
+            await db.destroy();
+        });
+        it('should count app-level scenarios by page_file_path', async () => {
+            // App-level scenario: has page_file_path but no component_name
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-1',
+                project_id: projectId,
+                name: 'Library - Default',
+                component_name: null,
+                page_file_path: 'app/library/page.tsx',
+                created_at: '2026-03-12 13:00:00',
+            })
+                .execute();
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-2',
+                project_id: projectId,
+                name: 'Library - Empty',
+                component_name: null,
+                page_file_path: 'app/library/page.tsx',
+                created_at: '2026-03-12 13:05:00',
+            })
+                .execute();
+            const counts = await queryPageScenarioCounts(db, projectId, null);
+            expect(counts).toEqual({ 'app/library/page.tsx': 2 });
+        });
+        it('should not count component scenarios (those have component_name)', async () => {
+            // Component scenario — should NOT appear in page counts
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-1',
+                project_id: projectId,
+                name: 'ArticleRow - Default',
+                component_name: 'ArticleRow',
+                page_file_path: null,
+                created_at: '2026-03-12 13:00:00',
+            })
+                .execute();
+            const counts = await queryPageScenarioCounts(db, projectId, null);
+            expect(counts).toEqual({});
+        });
+        it('should respect featureStartedAt filter', async () => {
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-1',
+                project_id: projectId,
+                name: 'Library - Old',
+                component_name: null,
+                page_file_path: 'app/library/page.tsx',
+                created_at: '2026-03-12 13:00:00',
+            })
+                .execute();
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-2',
+                project_id: projectId,
+                name: 'Library - New',
+                component_name: null,
+                page_file_path: 'app/library/page.tsx',
+                created_at: '2026-03-12 15:00:00',
+            })
+                .execute();
+            const counts = await queryPageScenarioCounts(db, projectId, '2026-03-12T14:01:31.291Z');
+            expect(counts).toEqual({ 'app/library/page.tsx': 1 });
+        });
+        it('should count re-registered page scenarios via updated_at', async () => {
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-1',
+                project_id: projectId,
+                name: 'Library - Default',
+                component_name: null,
+                page_file_path: 'app/library/page.tsx',
+                created_at: '2026-03-12 13:00:00',
+                updated_at: '2026-03-12 15:00:00',
+            })
+                .execute();
+            const counts = await queryPageScenarioCounts(db, projectId, '2026-03-12T14:01:31.291Z');
+            expect(counts).toEqual({ 'app/library/page.tsx': 1 });
+        });
+        it('should group counts by page_file_path across multiple pages', async () => {
+            await db
+                .insertInto('editor_scenarios')
+                .values([
+                {
+                    id: 'sc-1',
+                    project_id: projectId,
+                    name: 'Library - Default',
+                    component_name: null,
+                    page_file_path: 'app/library/page.tsx',
+                    created_at: '2026-03-12 13:00:00',
+                },
+                {
+                    id: 'sc-2',
+                    project_id: projectId,
+                    name: 'Library - Rich',
+                    component_name: null,
+                    page_file_path: 'app/library/page.tsx',
+                    created_at: '2026-03-12 13:00:00',
+                },
+                {
+                    id: 'sc-3',
+                    project_id: projectId,
+                    name: 'Collections - Default',
+                    component_name: null,
+                    page_file_path: 'app/library/collections/page.tsx',
+                    created_at: '2026-03-12 13:00:00',
+                },
+            ])
+                .execute();
+            const counts = await queryPageScenarioCounts(db, projectId, null);
+            expect(counts).toEqual({
+                'app/library/page.tsx': 2,
+                'app/library/collections/page.tsx': 1,
+            });
+        });
+    });
+    // ── Audit + entity completeness integration ─────────────────────────
+    describe('audit should catch incomplete entities (bug reproduction)', () => {
+        let db;
+        let rawDb;
+        const projectId = 'test-project-id';
+        beforeEach(async () => {
+            rawDb = new Database(':memory:');
+            db = new Kysely({ dialect: new SqliteDialect({ database: rawDb }) });
+            await db.schema
+                .createTable('editor_scenarios')
+                .addColumn('id', 'varchar', (col) => col.primaryKey())
+                .addColumn('project_id', 'varchar', (col) => col.notNull())
+                .addColumn('name', 'varchar', (col) => col.notNull())
+                .addColumn('component_name', 'varchar')
+                .addColumn('component_path', 'varchar')
+                .addColumn('entity_sha', 'varchar')
+                .addColumn('display_name', 'varchar')
+                .addColumn('page_file_path', 'varchar')
+                .addColumn('url', 'varchar')
+                .addColumn('created_at', 'datetime')
+                .addColumn('updated_at', 'datetime')
+                .execute();
+            await db.schema
+                .createTable('analyses')
+                .addColumn('id', 'varchar', (col) => col.primaryKey())
+                .addColumn('entity_sha', 'varchar')
+                .addColumn('entity_name', 'varchar')
+                .addColumn('project_id', 'varchar')
+                .execute();
+            await db.schema
+                .createTable('entities')
+                .addColumn('sha', 'varchar', (col) => col.primaryKey())
+                .addColumn('name', 'varchar')
+                .addColumn('entity_type', 'varchar')
+                .addColumn('file_path', 'varchar')
+                .execute();
+        });
+        afterEach(async () => {
+            await db.destroy();
+        });
+        it('demonstrates the bug: computeAudit passes but entities are incomplete', async () => {
+            // Setup: Two components in glossary, both have scenarios registered.
+            // CollectionChips has scenarios but NO analysis records — it's "incomplete."
+            // The glossary-based audit (computeAudit) doesn't know about entity analyses
+            // so it says allPassing: true. This is the bug.
+            // Entities in DB
+            await db
+                .insertInto('entities')
+                .values({
+                sha: 'sha-header',
+                name: 'Header',
+                entity_type: 'visual',
+                file_path: 'src/components/Header.tsx',
+            })
+                .execute();
+            await db
+                .insertInto('entities')
+                .values({
+                sha: 'sha-chips',
+                name: 'CollectionChips',
+                entity_type: 'visual',
+                file_path: 'src/components/CollectionChips.tsx',
+            })
+                .execute();
+            // Header has an analysis — it's complete
+            await db
+                .insertInto('analyses')
+                .values({
+                id: 'a-1',
+                entity_sha: 'sha-header',
+                entity_name: 'Header',
+                project_id: projectId,
+            })
+                .execute();
+            // CollectionChips has NO analysis — it's incomplete
+            // Both have scenarios
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-1',
+                project_id: projectId,
+                name: 'Header - Default',
+                component_name: 'Header',
+                entity_sha: 'sha-header',
+                created_at: '2026-03-16 23:00:00',
+            })
+                .execute();
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-2',
+                project_id: projectId,
+                name: 'CollectionChips - Default',
+                component_name: 'CollectionChips',
+                entity_sha: 'sha-chips',
+                created_at: '2026-03-16 23:19:00',
+            })
+                .execute();
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-3',
+                project_id: projectId,
+                name: 'CollectionChips - Many',
+                component_name: 'CollectionChips',
+                entity_sha: 'sha-chips',
+                created_at: '2026-03-16 23:19:05',
+            })
+                .execute();
+            // The glossary says both are components with scenarios
+            const scenarioCounts = await queryScenarioCounts(db, projectId, null);
+            expect(scenarioCounts).toEqual({ Header: 1, CollectionChips: 2 });
+            // computeAudit only checks glossary coverage — it passes!
+            const auditResult = computeAudit({
+                components: [
+                    {
+                        name: 'Header',
+                        filePath: 'src/components/Header.tsx',
+                        returnType: 'JSX.Element',
+                    },
+                    {
+                        name: 'CollectionChips',
+                        filePath: 'src/components/CollectionChips.tsx',
+                        returnType: 'JSX.Element',
+                    },
+                ],
+                functions: [],
+                scenarioCounts,
+                testFileExistence: {},
+            });
+            // BUG: computeAudit alone says everything is fine
+            expect(auditResult.summary.allPassing).toBe(true);
+            expect(auditResult.summary.componentsOk).toBe(2);
+            // But queryIncompleteEntities catches the real issue
+            const incomplete = await queryIncompleteEntities(db, projectId, null);
+            expect(incomplete).toHaveLength(1);
+            expect(incomplete[0].name).toBe('CollectionChips');
+            expect(incomplete[0].scenarioCount).toBe(2);
+        });
+        it('audit should fail when combining computeAudit with incomplete entity check', async () => {
+            // Same setup as above — this test shows the FIX working:
+            // after computeAudit, we also check queryIncompleteEntities,
+            // and if any are found, allPassing becomes false.
+            await db
+                .insertInto('entities')
+                .values({
+                sha: 'sha-header',
+                name: 'Header',
+                entity_type: 'visual',
+                file_path: 'src/components/Header.tsx',
+            })
+                .execute();
+            await db
+                .insertInto('entities')
+                .values({
+                sha: 'sha-chips',
+                name: 'CollectionChips',
+                entity_type: 'visual',
+                file_path: 'src/components/CollectionChips.tsx',
+            })
+                .execute();
+            await db
+                .insertInto('analyses')
+                .values({
+                id: 'a-1',
+                entity_sha: 'sha-header',
+                entity_name: 'Header',
+                project_id: projectId,
+            })
+                .execute();
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-1',
+                project_id: projectId,
+                name: 'Header - Default',
+                component_name: 'Header',
+                entity_sha: 'sha-header',
+                created_at: '2026-03-16 23:00:00',
+            })
+                .execute();
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-2',
+                project_id: projectId,
+                name: 'CollectionChips - Default',
+                component_name: 'CollectionChips',
+                entity_sha: 'sha-chips',
+                created_at: '2026-03-16 23:19:00',
+            })
+                .execute();
+            const scenarioCounts = await queryScenarioCounts(db, projectId, null);
+            const auditResult = computeAudit({
+                components: [
+                    {
+                        name: 'Header',
+                        filePath: 'src/components/Header.tsx',
+                        returnType: 'JSX.Element',
+                    },
+                    {
+                        name: 'CollectionChips',
+                        filePath: 'src/components/CollectionChips.tsx',
+                        returnType: 'JSX.Element',
+                    },
+                ],
+                functions: [],
+                scenarioCounts,
+                testFileExistence: {},
+            });
+            // Apply the same post-processing the audit endpoint does
+            const incomplete = await queryIncompleteEntities(db, projectId, null);
+            if (incomplete.length > 0) {
+                auditResult.summary.allPassing = false;
+                auditResult.summary.incompleteEntities = incomplete.length;
+            }
+            // NOW the audit correctly fails
+            expect(auditResult.summary.allPassing).toBe(false);
+            expect(auditResult.summary.incompleteEntities).toBe(1);
+        });
+        it('audit should pass when all entities have analyses', async () => {
+            // Both entities have analyses — everything is complete
+            await db
+                .insertInto('entities')
+                .values({
+                sha: 'sha-header',
+                name: 'Header',
+                entity_type: 'visual',
+                file_path: 'src/components/Header.tsx',
+            })
+                .execute();
+            await db
+                .insertInto('entities')
+                .values({
+                sha: 'sha-chips',
+                name: 'CollectionChips',
+                entity_type: 'visual',
+                file_path: 'src/components/CollectionChips.tsx',
+            })
+                .execute();
+            await db
+                .insertInto('analyses')
+                .values({
+                id: 'a-1',
+                entity_sha: 'sha-header',
+                entity_name: 'Header',
+                project_id: projectId,
+            })
+                .execute();
+            await db
+                .insertInto('analyses')
+                .values({
+                id: 'a-2',
+                entity_sha: 'sha-chips',
+                entity_name: 'CollectionChips',
+                project_id: projectId,
+            })
+                .execute();
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-1',
+                project_id: projectId,
+                name: 'Header - Default',
+                component_name: 'Header',
+                entity_sha: 'sha-header',
+                created_at: '2026-03-16 23:00:00',
+            })
+                .execute();
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-2',
+                project_id: projectId,
+                name: 'CollectionChips - Default',
+                component_name: 'CollectionChips',
+                entity_sha: 'sha-chips',
+                created_at: '2026-03-16 23:19:00',
+            })
+                .execute();
+            const scenarioCounts = await queryScenarioCounts(db, projectId, null);
+            const auditResult = computeAudit({
+                components: [
+                    {
+                        name: 'Header',
+                        filePath: 'src/components/Header.tsx',
+                        returnType: 'JSX.Element',
+                    },
+                    {
+                        name: 'CollectionChips',
+                        filePath: 'src/components/CollectionChips.tsx',
+                        returnType: 'JSX.Element',
+                    },
+                ],
+                functions: [],
+                scenarioCounts,
+                testFileExistence: {},
+            });
+            const incomplete = await queryIncompleteEntities(db, projectId, null);
+            if (incomplete.length > 0) {
+                auditResult.summary.allPassing = false;
+                auditResult.summary.incompleteEntities = incomplete.length;
+            }
+            // Everything complete — audit passes
+            expect(auditResult.summary.allPassing).toBe(true);
+            expect(auditResult.summary.incompleteEntities).toBeUndefined();
+        });
+    });
+    // ── queryMiscategorizedScenarios ─────────────────────────────────────
+    describe('queryMiscategorizedScenarios', () => {
+        let db;
+        let rawDb;
+        const projectId = 'test-project-id';
+        beforeEach(async () => {
+            rawDb = new Database(':memory:');
+            db = new Kysely({ dialect: new SqliteDialect({ database: rawDb }) });
+            await db.schema
+                .createTable('editor_scenarios')
+                .addColumn('id', 'varchar', (col) => col.primaryKey())
+                .addColumn('project_id', 'varchar', (col) => col.notNull())
+                .addColumn('name', 'varchar', (col) => col.notNull())
+                .addColumn('component_name', 'varchar')
+                .addColumn('component_path', 'varchar')
+                .addColumn('entity_sha', 'varchar')
+                .addColumn('display_name', 'varchar')
+                .addColumn('page_file_path', 'varchar')
+                .addColumn('url', 'varchar')
+                .addColumn('created_at', 'datetime')
+                .addColumn('updated_at', 'datetime')
+                .execute();
+        });
+        afterEach(async () => {
+            await db.destroy();
+        });
+        it('should return empty when all component scenarios use isolation routes', async () => {
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-1',
+                project_id: projectId,
+                name: 'LibraryCard - Default',
+                component_name: 'LibraryCard',
+                url: '/isolated-components/LibraryCard?s=Default',
+                created_at: '2026-03-17 12:00:00',
+            })
+                .execute();
+            const result = await queryMiscategorizedScenarios(db, projectId, null);
+            expect(result).toEqual([]);
+        });
+        it('should flag component scenarios that use non-isolation URLs', async () => {
+            // This is the bug: "Full Library Page" registered as component_name=LibraryPage
+            // but url=/library — it's pointing at the real page, not an isolation route
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-1',
+                project_id: projectId,
+                name: 'Full Library Page',
+                component_name: 'LibraryPage',
+                url: '/library',
+                created_at: '2026-03-17 12:41:40',
+            })
+                .execute();
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-2',
+                project_id: projectId,
+                name: 'Empty Library Page',
+                component_name: 'LibraryPage',
+                url: '/library',
+                created_at: '2026-03-17 12:41:51',
+            })
+                .execute();
+            const result = await queryMiscategorizedScenarios(db, projectId, null);
+            expect(result).toEqual([
+                {
+                    componentName: 'LibraryPage',
+                    scenarioNames: ['Full Library Page', 'Empty Library Page'],
+                    url: '/library',
+                },
+            ]);
+        });
+        it('should not flag page-level scenarios (no component_name)', async () => {
+            // App-level scenarios have no component_name — they're fine with real URLs
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-1',
+                project_id: projectId,
+                name: 'Library with Articles',
+                url: '/',
+                created_at: '2026-03-17 12:25:14',
+            })
+                .execute();
+            const result = await queryMiscategorizedScenarios(db, projectId, null);
+            expect(result).toEqual([]);
+        });
+        it('should group miscategorized scenarios by component and URL', async () => {
+            // Two different components both misusing real URLs
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-1',
+                project_id: projectId,
+                name: 'Full Library Page',
+                component_name: 'LibraryPage',
+                url: '/library',
+                created_at: '2026-03-17 12:41:40',
+            })
+                .execute();
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-2',
+                project_id: projectId,
+                name: 'Dashboard - Full',
+                component_name: 'Dashboard',
+                url: '/dashboard',
+                created_at: '2026-03-17 12:50:00',
+            })
+                .execute();
+            const result = await queryMiscategorizedScenarios(db, projectId, null);
+            expect(result).toHaveLength(2);
+            expect(result.map((r) => r.componentName).sort()).toEqual([
+                'Dashboard',
+                'LibraryPage',
+            ]);
+        });
+        it('should scope to session when featureStartedAt is provided', async () => {
+            // Old miscategorized scenario — before session
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-old',
+                project_id: projectId,
+                name: 'Old Page',
+                component_name: 'OldComponent',
+                url: '/old',
+                created_at: '2026-03-16 10:00:00',
+            })
+                .execute();
+            // New miscategorized scenario — in session
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-new',
+                project_id: projectId,
+                name: 'Full Library Page',
+                component_name: 'LibraryPage',
+                url: '/library',
+                created_at: '2026-03-17 12:41:40',
+            })
+                .execute();
+            const result = await queryMiscategorizedScenarios(db, projectId, '2026-03-17T11:58:55.562Z');
+            expect(result).toHaveLength(1);
+            expect(result[0].componentName).toBe('LibraryPage');
+        });
+        it('should not flag component scenarios with null URL', async () => {
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-1',
+                project_id: projectId,
+                name: 'NoUrl - Default',
+                component_name: 'NoUrl',
+                created_at: '2026-03-17 12:00:00',
+            })
+                .execute();
+            const result = await queryMiscategorizedScenarios(db, projectId, null);
+            expect(result).toEqual([]);
+        });
+    });
+    // ── isOnlyIncompleteEntities ─────────────────────────────────────────
+    describe('isOnlyIncompleteEntities', () => {
+        it('should return true when incompleteEntities is the only failure', () => {
+            expect(isOnlyIncompleteEntities({
+                componentsMissing: 0,
+                componentsWithErrors: 0,
+                functionsFailing: 0,
+                functionsNameMismatch: 0,
+                functionsMissing: 0,
+                missingFromGlossary: 0,
+                incompleteEntities: 3,
+                allPassing: false,
+            })).toBe(true);
+        });
+        it('should return false when there are also missing components', () => {
+            expect(isOnlyIncompleteEntities({
+                componentsMissing: 1,
+                componentsWithErrors: 0,
+                functionsFailing: 0,
+                functionsNameMismatch: 0,
+                functionsMissing: 0,
+                missingFromGlossary: 0,
+                incompleteEntities: 2,
+                allPassing: false,
+            })).toBe(false);
+        });
+        it('should return false when there are also failing tests', () => {
+            expect(isOnlyIncompleteEntities({
+                componentsMissing: 0,
+                componentsWithErrors: 0,
+                functionsFailing: 1,
+                functionsNameMismatch: 0,
+                functionsMissing: 0,
+                missingFromGlossary: 0,
+                incompleteEntities: 2,
+                allPassing: false,
+            })).toBe(false);
+        });
+        it('should return false when there are also missing glossary entries', () => {
+            expect(isOnlyIncompleteEntities({
+                componentsMissing: 0,
+                componentsWithErrors: 0,
+                functionsFailing: 0,
+                functionsNameMismatch: 0,
+                functionsMissing: 0,
+                missingFromGlossary: 1,
+                incompleteEntities: 2,
+                allPassing: false,
+            })).toBe(false);
+        });
+        it('should return true even when incompleteEntities is 0 (no failures at all)', () => {
+            // Edge case: all zeros means nothing is failing
+            expect(isOnlyIncompleteEntities({
+                componentsMissing: 0,
+                componentsWithErrors: 0,
+                functionsFailing: 0,
+                functionsNameMismatch: 0,
+                functionsMissing: 0,
+                missingFromGlossary: 0,
+                incompleteEntities: 0,
+                allPassing: true,
+            })).toBe(true);
+        });
+        it('should return false when there are also miscategorized scenarios', () => {
+            expect(isOnlyIncompleteEntities({
+                componentsMissing: 0,
+                componentsWithErrors: 0,
+                functionsFailing: 0,
+                functionsNameMismatch: 0,
+                functionsMissing: 0,
+                missingFromGlossary: 0,
+                miscategorizedScenarios: 1,
+                incompleteEntities: 2,
+                allPassing: false,
+            })).toBe(false);
+        });
+        it('should handle missing fields gracefully', () => {
+            // Summary from older API version might not have all fields
+            expect(isOnlyIncompleteEntities({
+                incompleteEntities: 2,
+                allPassing: false,
+            })).toBe(true);
+        });
+    });
+    // ── isAutoRemediable ─────────────────────────────────────────────────
+    describe('isAutoRemediable', () => {
+        it('should return true on first attempt when only incomplete entities', () => {
+            const result = isAutoRemediable({
+                componentsMissing: 0,
+                componentsWithErrors: 0,
+                functionsFailing: 0,
+                functionsNameMismatch: 0,
+                functionsMissing: 0,
+                missingFromGlossary: 0,
+                miscategorizedScenarios: 0,
+                incompleteEntities: 3,
+                allPassing: false,
+            }, false);
+            expect(result).toBe(true);
+        });
+        it('should return false on second attempt (already tried once)', () => {
+            // This is the key fix: if we already tried analyze-imports and
+            // entities are STILL incomplete, don't try again — report the failure
+            const result = isAutoRemediable({
+                componentsMissing: 0,
+                componentsWithErrors: 0,
+                functionsFailing: 0,
+                functionsNameMismatch: 0,
+                functionsMissing: 0,
+                missingFromGlossary: 0,
+                miscategorizedScenarios: 0,
+                incompleteEntities: 3,
+                allPassing: false,
+            }, true);
+            expect(result).toBe(false);
+        });
+        it('should return false when there are other failures besides incomplete entities', () => {
+            const result = isAutoRemediable({
+                componentsMissing: 1,
+                incompleteEntities: 3,
+                allPassing: false,
+            }, false);
+            expect(result).toBe(false);
+        });
+        it('should return false when there are no incomplete entities', () => {
+            const result = isAutoRemediable({
+                componentsMissing: 1,
+                allPassing: false,
+            }, false);
+            expect(result).toBe(false);
+        });
+    });
+    // ── queryIncompleteEntities ─────────────────────────────────────────
+    describe('queryIncompleteEntities', () => {
+        let db;
+        let rawDb;
+        const projectId = 'test-project-id';
+        beforeEach(async () => {
+            rawDb = new Database(':memory:');
+            db = new Kysely({ dialect: new SqliteDialect({ database: rawDb }) });
+            await db.schema
+                .createTable('editor_scenarios')
+                .addColumn('id', 'varchar', (col) => col.primaryKey())
+                .addColumn('project_id', 'varchar', (col) => col.notNull())
+                .addColumn('name', 'varchar', (col) => col.notNull())
+                .addColumn('component_name', 'varchar')
+                .addColumn('component_path', 'varchar')
+                .addColumn('entity_sha', 'varchar')
+                .addColumn('display_name', 'varchar')
+                .addColumn('page_file_path', 'varchar')
+                .addColumn('url', 'varchar')
+                .addColumn('created_at', 'datetime')
+                .addColumn('updated_at', 'datetime')
+                .execute();
+            await db.schema
+                .createTable('analyses')
+                .addColumn('id', 'varchar', (col) => col.primaryKey())
+                .addColumn('entity_sha', 'varchar')
+                .addColumn('entity_name', 'varchar')
+                .addColumn('project_id', 'varchar')
+                .execute();
+            await db.schema
+                .createTable('entities')
+                .addColumn('sha', 'varchar', (col) => col.primaryKey())
+                .addColumn('name', 'varchar')
+                .addColumn('entity_type', 'varchar')
+                .addColumn('file_path', 'varchar')
+                .execute();
+        });
+        afterEach(async () => {
+            await db.destroy();
+        });
+        it('should return empty when all scenario entity SHAs have analyses', async () => {
+            // Entity with analysis
+            await db
+                .insertInto('entities')
+                .values({
+                sha: 'sha-header',
+                name: 'Header',
+                entity_type: 'visual',
+                file_path: 'src/Header.tsx',
+            })
+                .execute();
+            await db
+                .insertInto('analyses')
+                .values({
+                id: 'a-1',
+                entity_sha: 'sha-header',
+                entity_name: 'Header',
+                project_id: projectId,
+            })
+                .execute();
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-1',
+                project_id: projectId,
+                name: 'Header - Default',
+                component_name: 'Header',
+                entity_sha: 'sha-header',
+                created_at: '2026-03-16 23:00:00',
+            })
+                .execute();
+            const result = await queryIncompleteEntities(db, projectId, null);
+            expect(result).toEqual([]);
+        });
+        it('should return entities with scenarios but no analyses', async () => {
+            // Entity WITHOUT analysis
+            await db
+                .insertInto('entities')
+                .values({
+                sha: 'sha-chips',
+                name: 'CollectionChips',
+                entity_type: 'visual',
+                file_path: 'src/components/CollectionChips.tsx',
+            })
+                .execute();
+            // Scenario referencing that entity
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-1',
+                project_id: projectId,
+                name: 'CollectionChips - Default',
+                component_name: 'CollectionChips',
+                entity_sha: 'sha-chips',
+                created_at: '2026-03-16 23:00:00',
+            })
+                .execute();
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-2',
+                project_id: projectId,
+                name: 'CollectionChips - Many',
+                component_name: 'CollectionChips',
+                entity_sha: 'sha-chips',
+                created_at: '2026-03-16 23:01:00',
+            })
+                .execute();
+            const result = await queryIncompleteEntities(db, projectId, null);
+            expect(result).toEqual([
+                {
+                    entitySha: 'sha-chips',
+                    name: 'CollectionChips',
+                    scenarioCount: 2,
+                    preExisting: false,
+                },
+            ]);
+        });
+        it('should only return entities without analyses, not those with analyses', async () => {
+            // Entity WITH analysis (Header)
+            await db
+                .insertInto('entities')
+                .values({
+                sha: 'sha-header',
+                name: 'Header',
+                entity_type: 'visual',
+                file_path: 'src/Header.tsx',
+            })
+                .execute();
+            await db
+                .insertInto('analyses')
+                .values({
+                id: 'a-1',
+                entity_sha: 'sha-header',
+                entity_name: 'Header',
+                project_id: projectId,
+            })
+                .execute();
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-1',
+                project_id: projectId,
+                name: 'Header - Default',
+                component_name: 'Header',
+                entity_sha: 'sha-header',
+                created_at: '2026-03-16 23:00:00',
+            })
+                .execute();
+            // Entity WITHOUT analysis (CollectionPicker)
+            await db
+                .insertInto('entities')
+                .values({
+                sha: 'sha-picker',
+                name: 'CollectionPicker',
+                entity_type: 'visual',
+                file_path: 'src/components/CollectionPicker.tsx',
+            })
+                .execute();
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-2',
+                project_id: projectId,
+                name: 'CollectionPicker - Default',
+                component_name: 'CollectionPicker',
+                entity_sha: 'sha-picker',
+                created_at: '2026-03-16 23:00:00',
+            })
+                .execute();
+            const result = await queryIncompleteEntities(db, projectId, null);
+            expect(result).toEqual([
+                {
+                    entitySha: 'sha-picker',
+                    name: 'CollectionPicker',
+                    scenarioCount: 1,
+                    preExisting: false,
+                },
+            ]);
+        });
+        it('should return both pre-session and in-session entities with preExisting flags', async () => {
+            // Entity without analysis, scenario created BEFORE session
+            await db
+                .insertInto('entities')
+                .values({
+                sha: 'sha-old',
+                name: 'OldComponent',
+                entity_type: 'visual',
+                file_path: 'src/OldComponent.tsx',
+            })
+                .execute();
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-old',
+                project_id: projectId,
+                name: 'OldComponent - Default',
+                component_name: 'OldComponent',
+                entity_sha: 'sha-old',
+                created_at: '2026-03-16 20:00:00',
+            })
+                .execute();
+            // Entity without analysis, scenario created DURING session
+            await db
+                .insertInto('entities')
+                .values({
+                sha: 'sha-new',
+                name: 'NewComponent',
+                entity_type: 'visual',
+                file_path: 'src/NewComponent.tsx',
+            })
+                .execute();
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-new',
+                project_id: projectId,
+                name: 'NewComponent - Default',
+                component_name: 'NewComponent',
+                entity_sha: 'sha-new',
+                created_at: '2026-03-16 23:10:00',
+            })
+                .execute();
+            const result = await queryIncompleteEntities(db, projectId, '2026-03-16T23:07:12.698Z');
+            // Both should be returned — OldComponent is preExisting, NewComponent is not
+            expect(result).toEqual(expect.arrayContaining([
+                {
+                    entitySha: 'sha-old',
+                    name: 'OldComponent',
+                    scenarioCount: 1,
+                    preExisting: true,
+                },
+                {
+                    entitySha: 'sha-new',
+                    name: 'NewComponent',
+                    scenarioCount: 1,
+                    preExisting: false,
+                },
+            ]));
+            expect(result).toHaveLength(2);
+        });
+        it('should flag preExisting: false when scenario was updated in session even if created before', async () => {
+            await db
+                .insertInto('entities')
+                .values({
+                sha: 'sha-updated',
+                name: 'UpdatedComponent',
+                entity_type: 'visual',
+                file_path: 'src/Updated.tsx',
+            })
+                .execute();
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-updated',
+                project_id: projectId,
+                name: 'UpdatedComponent - Default',
+                component_name: 'UpdatedComponent',
+                entity_sha: 'sha-updated',
+                created_at: '2026-03-16 20:00:00',
+                updated_at: '2026-03-16 23:20:00', // Updated in session
+            })
+                .execute();
+            const result = await queryIncompleteEntities(db, projectId, '2026-03-16T23:07:12.698Z');
+            expect(result).toEqual([
+                {
+                    entitySha: 'sha-updated',
+                    name: 'UpdatedComponent',
+                    scenarioCount: 1,
+                    preExisting: false,
+                },
+            ]);
+        });
+        it('should skip scenarios with null entity_sha', async () => {
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-null',
+                project_id: projectId,
+                name: 'Orphan Scenario',
+                component_name: 'Orphan',
+                created_at: '2026-03-16 23:00:00',
+            })
+                .execute();
+            const result = await queryIncompleteEntities(db, projectId, null);
+            expect(result).toEqual([]);
+        });
+        it('should return empty when there are no scenarios', async () => {
+            const result = await queryIncompleteEntities(db, projectId, null);
+            expect(result).toEqual([]);
+        });
+        it('should not flag entities when a sibling version (same name+filePath) has analyses', async () => {
+            // Old entity version WITH analysis
+            await db
+                .insertInto('entities')
+                .values({
+                sha: 'sha-btn-v1',
+                name: 'OpenLibraryButton',
+                entity_type: 'visual',
+                file_path: 'src/components/OpenLibraryButton.tsx',
+            })
+                .execute();
+            await db
+                .insertInto('analyses')
+                .values({
+                id: 'a-btn-v1',
+                entity_sha: 'sha-btn-v1',
+                entity_name: 'OpenLibraryButton',
+                project_id: projectId,
+            })
+                .execute();
+            // New entity version WITHOUT analysis (created by file watcher)
+            await db
+                .insertInto('entities')
+                .values({
+                sha: 'sha-btn-v2',
+                name: 'OpenLibraryButton',
+                entity_type: 'visual',
+                file_path: 'src/components/OpenLibraryButton.tsx',
+            })
+                .execute();
+            // Scenario points to the NEW version (backfilled after file watcher)
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-btn',
+                project_id: projectId,
+                name: 'OpenLibraryButton - Default',
+                component_name: 'OpenLibraryButton',
+                entity_sha: 'sha-btn-v2',
+                created_at: '2026-03-16 23:00:00',
+            })
+                .execute();
+            // Should NOT flag as incomplete — sibling version has analyses
+            const result = await queryIncompleteEntities(db, projectId, null);
+            expect(result).toEqual([]);
+        });
+        it('should flag entity when sibling has analyses but different filePath (extracted component)', async () => {
+            // Old entity version WITH analysis at ORIGINAL file path
+            await db
+                .insertInto('entities')
+                .values({
+                sha: 'sha-card-v1',
+                name: 'TaskCard',
+                entity_type: 'visual',
+                file_path: 'app/page.tsx',
+            })
+                .execute();
+            await db
+                .insertInto('analyses')
+                .values({
+                id: 'a-card-v1',
+                entity_sha: 'sha-card-v1',
+                entity_name: 'TaskCard',
+                project_id: projectId,
+            })
+                .execute();
+            // New entity version WITHOUT analysis at EXTRACTED file path
+            await db
+                .insertInto('entities')
+                .values({
+                sha: 'sha-card-v2',
+                name: 'TaskCard',
+                entity_type: 'visual',
+                file_path: 'app/components/TaskCard.tsx',
+            })
+                .execute();
+            // Scenario points to the new version (synced by syncScenarioEntityShas)
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-card',
+                project_id: projectId,
+                name: 'TaskCard - Default',
+                component_name: 'TaskCard',
+                entity_sha: 'sha-card-v2',
+                created_at: '2026-03-16 23:00:00',
+            })
+                .execute();
+            // SHOULD flag as incomplete — sibling has analyses but at a different filePath,
+            // so getAllEntities() won't inherit (it matches by name+filePath)
+            const result = await queryIncompleteEntities(db, projectId, null);
+            expect(result).toEqual([
+                {
+                    entitySha: 'sha-card-v2',
+                    name: 'TaskCard',
+                    scenarioCount: 1,
+                    preExisting: false,
+                },
+            ]);
+        });
+        it('should still flag entities when no sibling version has analyses', async () => {
+            // Only one version, no analyses
+            await db
+                .insertInto('entities')
+                .values({
+                sha: 'sha-icon',
+                name: 'ExternalLinkIcon',
+                entity_type: 'visual',
+                file_path: 'src/components/ExternalLinkIcon.tsx',
+            })
+                .execute();
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-icon',
+                project_id: projectId,
+                name: 'ExternalLinkIcon - Default',
+                component_name: 'ExternalLinkIcon',
+                entity_sha: 'sha-icon',
+                created_at: '2026-03-16 23:00:00',
+            })
+                .execute();
+            // Should flag as incomplete — no version has analyses
+            const result = await queryIncompleteEntities(db, projectId, null);
+            expect(result).toEqual([
+                {
+                    entitySha: 'sha-icon',
+                    name: 'ExternalLinkIcon',
+                    scenarioCount: 1,
+                    preExisting: false,
+                },
+            ]);
+        });
+        it('should use entity name from entities table, falling back to component_name', async () => {
+            // Scenario has entity_sha but entity record doesn't exist
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-1',
+                project_id: projectId,
+                name: 'Ghost - Default',
+                component_name: 'GhostComponent',
+                entity_sha: 'sha-ghost',
+                created_at: '2026-03-16 23:00:00',
+            })
+                .execute();
+            const result = await queryIncompleteEntities(db, projectId, null);
+            expect(result).toEqual([
+                {
+                    entitySha: 'sha-ghost',
+                    name: 'GhostComponent',
+                    scenarioCount: 1,
+                    preExisting: false,
+                },
+            ]);
+        });
+        it('should detect incomplete entity whose scenario predates the session', async () => {
+            // Entity with no analyses, scenario created BEFORE session
+            await db
+                .insertInto('entities')
+                .values({
+                sha: 'sha-preexisting',
+                name: 'PreExistingComponent',
+                entity_type: 'visual',
+                file_path: 'src/PreExistingComponent.tsx',
+            })
+                .execute();
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-preexisting',
+                project_id: projectId,
+                name: 'PreExistingComponent - Default',
+                component_name: 'PreExistingComponent',
+                entity_sha: 'sha-preexisting',
+                created_at: '2026-03-16 20:00:00',
+                updated_at: '2026-03-16 20:00:00',
+            })
+                .execute();
+            // Session started well after scenario was created/updated
+            const result = await queryIncompleteEntities(db, projectId, '2026-03-16T23:07:12.698Z');
+            // Should still be detected — the old time filter would have excluded it
+            expect(result).toEqual([
+                {
+                    entitySha: 'sha-preexisting',
+                    name: 'PreExistingComponent',
+                    scenarioCount: 1,
+                    preExisting: true,
+                },
+            ]);
+        });
+        it('should flag preExisting: true when all scenarios predate the session', async () => {
+            await db
+                .insertInto('entities')
+                .values({
+                sha: 'sha-old-entity',
+                name: 'OldEntity',
+                entity_type: 'visual',
+                file_path: 'src/OldEntity.tsx',
+            })
+                .execute();
+            // Two scenarios, both before session
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-old-1',
+                project_id: projectId,
+                name: 'OldEntity - Default',
+                component_name: 'OldEntity',
+                entity_sha: 'sha-old-entity',
+                created_at: '2026-03-16 19:00:00',
+                updated_at: '2026-03-16 19:00:00',
+            })
+                .execute();
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-old-2',
+                project_id: projectId,
+                name: 'OldEntity - Hover',
+                component_name: 'OldEntity',
+                entity_sha: 'sha-old-entity',
+                created_at: '2026-03-16 19:30:00',
+                updated_at: '2026-03-16 19:30:00',
+            })
+                .execute();
+            const result = await queryIncompleteEntities(db, projectId, '2026-03-16T23:07:12.698Z');
+            expect(result).toEqual([
+                {
+                    entitySha: 'sha-old-entity',
+                    name: 'OldEntity',
+                    scenarioCount: 2,
+                    preExisting: true,
+                },
+            ]);
+        });
+        it('should flag preExisting: false when scenario is from the current session', async () => {
+            await db
+                .insertInto('entities')
+                .values({
+                sha: 'sha-session-entity',
+                name: 'SessionEntity',
+                entity_type: 'visual',
+                file_path: 'src/SessionEntity.tsx',
+            })
+                .execute();
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-session',
+                project_id: projectId,
+                name: 'SessionEntity - Default',
+                component_name: 'SessionEntity',
+                entity_sha: 'sha-session-entity',
+                created_at: '2026-03-16 23:30:00',
+                updated_at: '2026-03-16 23:30:00',
+            })
+                .execute();
+            const result = await queryIncompleteEntities(db, projectId, '2026-03-16T23:07:12.698Z');
+            expect(result).toEqual([
+                {
+                    entitySha: 'sha-session-entity',
+                    name: 'SessionEntity',
+                    scenarioCount: 1,
+                    preExisting: false,
+                },
+            ]);
+        });
+    });
+    // ── identifyScenariosNeedingRecapture ──────────────────────────────
+    describe('identifyScenariosNeedingRecapture', () => {
+        // Reproduces the Margo bug: Feature 1 built app-level popup scenarios,
+        // Feature 2 edited LibraryView (used by App), but app-level scenarios
+        // were never flagged for recapture because the audit only checked
+        // component scenario existence — not whether app-level scenarios are stale.
+        //
+        // Each scenario's entityName is resolved by the caller via
+        // entity_sha → entities.name (the default export for app-level scenarios).
+        it('should flag app-level scenario when its entity is impacted by transitive dependency change', () => {
+            // LibraryView was edited → App is impacted (imports LibraryView)
+            // App-level scenario "Library - Rich Library" has entity_sha pointing to App
+            // It was NOT recaptured during Feature 2 → should be flagged
+            const entityChangeStatus = {
+                LibraryView: { status: 'edited' },
+                App: {
+                    status: 'impacted',
+                    impactedBy: [
+                        {
+                            name: 'LibraryView',
+                            filePath: 'src/components/LibraryView.tsx',
+                            changeType: 'edited',
+                        },
+                    ],
+                },
+            };
+            const result = identifyScenariosNeedingRecapture({
+                scenarios: [
+                    {
+                        name: 'Library - Rich Library',
+                        entityName: 'App', // resolved from entity_sha → entities.name
+                        updatedInSession: false,
+                    },
+                ],
+                entityChangeStatus,
+            });
+            expect(result).toHaveLength(1);
+            expect(result[0].scenarioName).toBe('Library - Rich Library');
+            expect(result[0].entityName).toBe('App');
+            expect(result[0].status.status).toBe('impacted');
+        });
+        it('should flag component scenario when its entity is directly edited and not recaptured', () => {
+            const entityChangeStatus = {
+                LibraryView: { status: 'edited' },
+            };
+            const result = identifyScenariosNeedingRecapture({
+                scenarios: [
+                    {
+                        name: 'LibraryView - Empty',
+                        entityName: 'LibraryView',
+                        updatedInSession: false,
+                    },
+                ],
+                entityChangeStatus,
+            });
+            expect(result).toHaveLength(1);
+            expect(result[0].scenarioName).toBe('LibraryView - Empty');
+            expect(result[0].entityName).toBe('LibraryView');
+            expect(result[0].status.status).toBe('edited');
+        });
+        it('should NOT flag scenario that was already recaptured in the current session', () => {
+            const entityChangeStatus = {
+                App: {
+                    status: 'impacted',
+                    impactedBy: [
+                        {
+                            name: 'LibraryView',
+                            filePath: 'src/components/LibraryView.tsx',
+                            changeType: 'edited',
+                        },
+                    ],
+                },
+            };
+            const result = identifyScenariosNeedingRecapture({
+                scenarios: [
+                    {
+                        name: 'App - Default',
+                        entityName: 'App',
+                        updatedInSession: true, // re-registered during Feature 2
+                    },
+                ],
+                entityChangeStatus,
+            });
+            expect(result).toHaveLength(0);
+        });
+        it('should NOT flag scenario whose entity has no change status', () => {
+            const entityChangeStatus = {
+                LibraryView: { status: 'edited' },
+            };
+            const result = identifyScenariosNeedingRecapture({
+                scenarios: [
+                    {
+                        name: 'WelcomeScreen - Default',
+                        entityName: 'WelcomeScreen',
+                        updatedInSession: false,
+                    },
+                ],
+                entityChangeStatus,
+            });
+            expect(result).toHaveLength(0);
+        });
+        it('should return empty array when entityChangeStatus is undefined', () => {
+            const result = identifyScenariosNeedingRecapture({
+                scenarios: [
+                    {
+                        name: 'Library - Rich Library',
+                        entityName: 'App',
+                        updatedInSession: false,
+                    },
+                ],
+                entityChangeStatus: undefined,
+            });
+            expect(result).toHaveLength(0);
+        });
+        it('should return empty array when entityChangeStatus is empty', () => {
+            const result = identifyScenariosNeedingRecapture({
+                scenarios: [
+                    {
+                        name: 'Library - Rich Library',
+                        entityName: 'App',
+                        updatedInSession: false,
+                    },
+                ],
+                entityChangeStatus: {},
+            });
+            expect(result).toHaveLength(0);
+        });
+        it('should flag multiple app-level scenarios sharing the same impacted entity', () => {
+            const entityChangeStatus = {
+                LibraryView: { status: 'edited' },
+                App: {
+                    status: 'impacted',
+                    impactedBy: [
+                        {
+                            name: 'LibraryView',
+                            filePath: 'src/components/LibraryView.tsx',
+                            changeType: 'edited',
+                        },
+                    ],
+                },
+            };
+            const result = identifyScenariosNeedingRecapture({
+                scenarios: [
+                    {
+                        name: 'Library - Empty',
+                        entityName: 'App',
+                        updatedInSession: false,
+                    },
+                    {
+                        name: 'Library - Rich Library',
+                        entityName: 'App',
+                        updatedInSession: false,
+                    },
+                    {
+                        name: 'First Article Saved',
+                        entityName: 'App',
+                        updatedInSession: false,
+                    },
+                ],
+                entityChangeStatus,
+            });
+            expect(result).toHaveLength(3);
+            expect(result.map((r) => r.scenarioName).sort()).toEqual([
+                'First Article Saved',
+                'Library - Empty',
+                'Library - Rich Library',
+            ]);
+            expect(result.every((r) => r.entityName === 'App')).toBe(true);
+        });
+        it('should skip scenarios with null entityName (no entity_sha set)', () => {
+            const entityChangeStatus = {
+                App: { status: 'edited' },
+            };
+            const result = identifyScenariosNeedingRecapture({
+                scenarios: [
+                    {
+                        name: 'Mystery Scenario',
+                        entityName: null, // no entity_sha → no entity name
+                        updatedInSession: false,
+                    },
+                ],
+                entityChangeStatus,
+            });
+            expect(result).toHaveLength(0);
+        });
+    });
+    // ── detectDuplicateNames ──────────────────────────────────────────
+    describe('detectDuplicateNames', () => {
+        it('should return empty map when no duplicates exist', () => {
+            const entries = [
+                { name: 'Header', filePath: 'app/components/Header.tsx' },
+                { name: 'Footer', filePath: 'app/components/Footer.tsx' },
+                { name: 'Sidebar', filePath: 'app/components/Sidebar.tsx' },
+            ];
+            const result = detectDuplicateNames(entries);
+            expect(result.size).toBe(0);
+        });
+        it('should group entries that share a name', () => {
+            const entries = [
+                { name: 'Page', filePath: 'app/isolated-components/Foo/page.tsx' },
+                { name: 'Page', filePath: 'app/isolated-components/Bar/page.tsx' },
+                { name: 'Page', filePath: 'app/isolated-components/Baz/page.tsx' },
+                { name: 'Header', filePath: 'app/components/Header.tsx' },
+            ];
+            const result = detectDuplicateNames(entries);
+            expect(result.size).toBe(1);
+            expect(result.has('Page')).toBe(true);
+            const pageGroup = result.get('Page');
+            expect(pageGroup).toHaveLength(3);
+            expect(pageGroup.map((e) => e.filePath)).toEqual([
+                'app/isolated-components/Foo/page.tsx',
+                'app/isolated-components/Bar/page.tsx',
+                'app/isolated-components/Baz/page.tsx',
+            ]);
+        });
+        it('should exclude single-occurrence names', () => {
+            const entries = [
+                { name: 'Page', filePath: 'app/isolated-components/Foo/page.tsx' },
+                { name: 'Page', filePath: 'app/isolated-components/Bar/page.tsx' },
+                { name: 'Header', filePath: 'app/components/Header.tsx' },
+                { name: 'Footer', filePath: 'app/components/Footer.tsx' },
+            ];
+            const result = detectDuplicateNames(entries);
+            expect(result.size).toBe(1);
+            expect(result.has('Header')).toBe(false);
+            expect(result.has('Footer')).toBe(false);
+        });
+        it('should handle multiple duplicate groups', () => {
+            const entries = [
+                { name: 'Page', filePath: 'app/isolated-components/A/page.tsx' },
+                { name: 'Page', filePath: 'app/isolated-components/B/page.tsx' },
+                { name: 'Layout', filePath: 'app/isolated-components/A/layout.tsx' },
+                { name: 'Layout', filePath: 'app/isolated-components/B/layout.tsx' },
+                { name: 'Unique', filePath: 'app/components/Unique.tsx' },
+            ];
+            const result = detectDuplicateNames(entries);
+            expect(result.size).toBe(2);
+            expect(result.has('Page')).toBe(true);
+            expect(result.has('Layout')).toBe(true);
+            expect(result.get('Page')).toHaveLength(2);
+            expect(result.get('Layout')).toHaveLength(2);
+        });
+        it('should return empty map for empty input', () => {
+            const result = detectDuplicateNames([]);
+            expect(result.size).toBe(0);
+        });
+    });
+    // ── computeAudit: impacted components with stale scenarios ──────────
+    describe('computeAudit — impacted components with stale scenarios', () => {
+        it('should mark impacted component as needs_recapture when it has total scenarios but none in session', () => {
+            // Library page has 3 scenarios from Feature 1 (totalScenarioCounts),
+            // 0 in the current session (scenarioCounts), and is "impacted" in entityChangeStatus.
+            // It should NOT be marked "missing" — it needs recapture, not new scenarios.
+            const result = computeAudit({
+                components: [
+                    {
+                        name: 'Library',
+                        filePath: 'app/library/page.tsx',
+                        returnType: 'JSX.Element',
+                    },
+                    {
+                        name: 'ArticleTable',
+                        filePath: 'app/components/ArticleTable.tsx',
+                        returnType: 'JSX.Element',
+                    },
+                ],
+                functions: [],
+                scenarioCounts: { ArticleTable: 2 },
+                testFileExistence: {},
+                totalScenarioCounts: { Library: 3 },
+                entityChangeStatus: {
+                    Library: { status: 'impacted' },
+                    ArticleTable: { status: 'edited' },
+                },
+            });
+            // Library: impacted + has total scenarios but 0 in session → needs_recapture
+            expect(result.components[0].status).toBe('needs_recapture');
+            expect(result.components[0].scenarioCount).toBe(3);
+            // ArticleTable: edited + has session scenarios → ok
+            expect(result.components[1].status).toBe('ok');
+            // needs_recapture should NOT count as missing
+            expect(result.summary.componentsMissing).toBe(0);
+            expect(result.summary.componentsNeedingRecapture).toBe(1);
+            // should NOT fail the audit (scenariosNeedingRecapture handles it)
+            expect(result.summary.allPassing).toBe(true);
+        });
+        it('should still mark component as missing when impacted but has zero total scenarios', () => {
+            // New page added to glossary but never had scenarios — truly missing
+            const result = computeAudit({
+                components: [
+                    {
+                        name: 'NewPage',
+                        filePath: 'app/new/page.tsx',
+                        returnType: 'JSX.Element',
+                    },
+                ],
+                functions: [],
+                scenarioCounts: {},
+                testFileExistence: {},
+                totalScenarioCounts: {},
+                entityChangeStatus: {
+                    NewPage: { status: 'impacted' },
+                },
+            });
+            expect(result.components[0].status).toBe('missing');
+            expect(result.summary.componentsMissing).toBe(1);
+        });
+        it('should use needs_recapture for edited entities with existing scenarios from prior sessions', () => {
+            // Edited entities that already have scenarios from prior sessions
+            // need recapture, not re-registration. The code changed, but the
+            // scenarios exist — they just need fresh screenshots.
+            const result = computeAudit({
+                components: [
+                    {
+                        name: 'EditedComp',
+                        filePath: 'app/components/Edited.tsx',
+                        returnType: 'JSX.Element',
+                    },
+                ],
+                functions: [],
+                scenarioCounts: {},
+                testFileExistence: {},
+                totalScenarioCounts: { EditedComp: 2 },
+                entityChangeStatus: {
+                    EditedComp: { status: 'edited' },
+                },
+            });
+            expect(result.components[0].status).toBe('needs_recapture');
+            expect(result.summary.componentsMissing).toBe(0);
+            expect(result.summary.componentsNeedingRecapture).toBe(1);
+        });
+        it('should still mark as missing when new entity has zero total scenarios', () => {
+            // Truly new component with no scenarios ever — needs scenarios created
+            const result = computeAudit({
+                components: [
+                    {
+                        name: 'BrandNew',
+                        filePath: 'app/components/BrandNew.tsx',
+                        returnType: 'JSX.Element',
+                    },
+                ],
+                functions: [],
+                scenarioCounts: {},
+                testFileExistence: {},
+                totalScenarioCounts: {},
+                entityChangeStatus: {
+                    BrandNew: { status: 'new' },
+                },
+            });
+            expect(result.components[0].status).toBe('missing');
+            expect(result.summary.componentsMissing).toBe(1);
+        });
+    });
 });
 //# sourceMappingURL=editorAudit.test.js.map