@codeyam/codeyam-cli 0.1.11 → 0.1.12

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

@@ -1,6 +1,6 @@
 import Database from 'better-sqlite3';
 import { Kysely, SqliteDialect } from 'kysely';
-import { isComponent, classifyGlossaryEntries, computeAudit, filterGlossaryByChangeStatus, resolveAuditSessionScope, queryScenarioCounts, } from "../editorAudit.js";
+import { isComponent, classifyGlossaryEntries, computeAudit, filterGlossaryByChangeStatus, resolveAuditSessionScope, queryScenarioCounts, queryIncompleteEntities, queryMiscategorizedScenarios, isOnlyIncompleteEntities, isAutoRemediable, } from "../editorAudit.js";
 describe('editorAudit', () => {
     describe('isComponent', () => {
         it('should return true for JSX.Element return type', () => {
@@ -983,5 +983,897 @@ describe('editorAudit', () => {
             expect(counts).toEqual({ ArticleCard: 1, ArticleRow: 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 },
+            ]);
+        });
+        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 },
+            ]);
+        });
+        it('should scope to session when featureStartedAt is provided', 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');
+            // Only NewComponent should be flagged (created in session)
+            expect(result).toEqual([
+                { entitySha: 'sha-new', name: 'NewComponent', scenarioCount: 1 },
+            ]);
+        });
+        it('should include scenarios 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,
+                },
+            ]);
+        });
+        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 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 },
+            ]);
+        });
+    });
 });
 //# sourceMappingURL=editorAudit.test.js.map