code-auditor-mcp 4.0.0 → 4.0.2

package/dist/pipelineAdapters.d.ts

@@ -15,8 +15,14 @@
  *     analyzer.analyze([]) with rawDb injected through config
  *   - Invariants: Stage 3 reducer — receives full file list, runs rule engine
  */
-import type { Stage2Visitor, Stage3Reducer, Stage4Reducer, Violation } from './types.js';
-export declare function createSolidVisitor(): Stage2Visitor;
+import type { Stage2Visitor, Stage3Reducer, Stage4Reducer, Violation, TestCoverageReport, DeadCluster } from './types.js';
+import type { SizeSample } from './analyzers/universal/UniversalSOLIDAnalyzer.js';
+export interface SolidVisitorBundle {
+    visitor: Stage2Visitor;
+    /** Spec 60 R2 — extract the raw size readings accumulated by the SOLID analyzer. */
+    getSizeSamples: () => Promise<SizeSample[]>;
+}
+export declare function createSolidVisitor(): SolidVisitorBundle;
 export interface DryVisitorBundle {
     visitor: Stage2Visitor;
     /** Extract accumulated dryPairs after the pipeline finishes stage 2. */
@@ -105,7 +111,37 @@ export declare function createConventionsReducer(): Stage3Reducer;
  * Uses analyzer.analyze([]) with rawDb injected.
  */
 export declare function createCrossDomainReducer(): Stage4Reducer;
+interface ClFileInfo {
+    imports: string[];
+    hasExports: boolean;
+    /** Dynamic `import()`/`require()` calls whose specifier is computed (not a
+     *  static string) and therefore cannot be resolved into an import edge. */
+    unresolvedDynamicImports: Array<{
+        line: number;
+        expression: string;
+    }>;
+}
 export declare function createCrossLanguageEntityVisitor(): Stage2Visitor;
+/**
+ * Spec 60 R1 — classify every non-test source module as `tested`,
+ * `untested-live`, or `untested-dead` off the file-level import edges
+ * (`importersOf`), not `function_dependencies`.
+ *
+ * A module is `tested` when a test file imports it *directly* (the edge set is
+ * alias-aware — built by `clResolveImport` through `classifyImportSpecifier`).
+ * `untested-dead` is the *post*-exception dead bucket: a file imported by
+ * nothing *and* not a framework entry point. `deadPreException` is the
+ * empty-importers count before the entry-point exception, so the drop
+ * (`deadPreException - untestedDead`) attributes the entry points exempted.
+ */
+export declare function classifyTestCoverage(fileFacts: Map<string, ClFileInfo>, importersOf: Map<string, Set<string>>, packageEntrySet: ReadonlySet<string>): TestCoverageReport;
+/**
+ * Spec 60 R3 — group unreferenced modules by basename, surfacing the pattern of
+ * the same file name appearing in several sibling directories (e.g. two
+ * `ErrorState.tsx`, three `services.ts` under separate `reports` folders). Only
+ * basenames with ≥2 files become clusters; a singleton dead file is not a duplicate.
+ */
+export declare function clusterDeadModules(deadFiles: string[]): DeadCluster[];
 export declare function createSchemaValidatorReducer(): Stage4Reducer;
 export declare function createAPIContractReducer(): Stage4Reducer;
 export declare function createDependencyGraphReducer(): Stage4Reducer;
@@ -141,4 +177,5 @@ export declare function createSchemaJsonVisitor(): Stage2Visitor;
  * Builds the complete known-tables catalog and checks all table references against it.
  */
 export declare function createSchemaReducer(): Stage3Reducer;
+export {};
 //# sourceMappingURL=pipelineAdapters.d.ts.map

package/dist/pipelineAdapters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pipelineAdapters.d.ts","sourceRoot":"","sources":["../src/pipelineAdapters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAKH,OAAO,KAAK,EAGV,aAAa,EACb,aAAa,EACb,aAAa,EACb,SAAS,EAIV,MAAM,YAAY,CAAC;AAoEpB,wBAAgB,kBAAkB,IAAI,aAAa,CAyBlD;AAID,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,aAAa,CAAC;IACvB,wEAAwE;IACxE,WAAW,EAAE,MAAM,OAAO,CAAC,KAAK,CAAC;QAC/B,eAAe,EAAE,MAAM,CAAC;QACxB,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QACpE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QACpE,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC,CAAC,CAAC;CACL;AAED,wBAAgB,gBAAgB,CAAC,iBAAiB,CAAC,EAAE,GAAG,EAAE,GAAG,gBAAgB,CAqC5E;AAID,wBAAgB,uBAAuB,IAAI,aAAa,CAsBvD;AAID,wBAAgB,0BAA0B,IAAI,aAAa,CAsB1D;AAID,wBAAgB,oBAAoB,IAAI,aAAa,CAsBpD;AAcD;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,wBAAgB,0BAA0B,IAAI,aAAa,CAiW1D;AAID,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,aAAa,CAAC;IACvB;;;OAGG;IACH,sBAAsB,EAAE,CAAC,MAAM,EAAE,GAAG,KAAK,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;CAC/D;AAED,wBAAgB,kBAAkB,IAAI,kBAAkB,CAuFvD;AAMD;;;;GAIG;AACH,wBAAgB,sBAAsB,IAAI,aAAa,CA6BtD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,IAAI,aAAa,CAkCzD;AAwHD;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,IAAI,aAAa,CAmLnD;AAID;;;;GAIG;AACH,wBAAgB,wBAAwB,IAAI,aAAa,CAgDxD;AAID;;;;GAIG;AACH,wBAAgB,wBAAwB,IAAI,aAAa,CAqCxD;AA0fD,wBAAgB,gCAAgC,IAAI,aAAa,CAoChE;AAmKD,wBAAgB,4BAA4B,IAAI,aAAa,CAsD5D;AAID,wBAAgB,wBAAwB,IAAI,aAAa,CAkCxD;AAID,wBAAgB,4BAA4B,IAAI,aAAa,CAoK5D;AAID;;;;GAIG;AACH,wBAAgB,uBAAuB,IAAI,aAAa,CAkFvD;AAaD;;;;GAIG;AACH,wBAAgB,sBAAsB,IAAI,aAAa,CA4BtD;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,aAAa,CAgLvD;AAED;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,aAAa,CAoCzD;AAED;;GAEG;AACH,wBAAgB,uBAAuB,IAAI,aAAa,CAmBvD;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,IAAI,aAAa,CAiSnD"}
+{"version":3,"file":"pipelineAdapters.d.ts","sourceRoot":"","sources":["../src/pipelineAdapters.ts"],"names":[],"mappings":"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"}

package/dist/pipelineAdapters.js

@@ -21,7 +21,6 @@ import { RULE_REGISTRY } from './analyzers/ruleRegistry.js';
 import { TYPESCRIPT_EXTENSIONS, JAVASCRIPT_EXTENSIONS, getLanguageFromPath } from './utils/fileDiscovery.js';
 import { walkAST, isExported, getNodeText, getFieldNode, getLineAndColumn, calculateComplexity, getFunctionBody, } from './languages/adapterBridge.js';
 import { buildImportMap, extractFunctionCalls, } from './utils/dependencyExtractor.js';
-import { resolveDependency, basenameNoExt } from './graph/importGraph.js';
 import { classifyImportSpecifier, DEFAULT_VIRTUAL_MODULES } from './graph/importClassification.js';
 import { isReactComponent, detectComponentType, getComponentName, } from './utils/reactDetection.js';
 import { findTableReferences, checkNamingConventions, checkQueryPatterns, checkSQLInjection, checkUnresolvedQueries, getNearestTableSuggestions, } from './analyzers/universal/schema/codeAnalysis.js';
@@ -50,10 +49,9 @@ function lazySingleton(loader) {
         return promise;
     };
 }
-// ── SOLID visitor ────────────────────────────────────────────────────────────
 export function createSolidVisitor() {
     const getAnalyzer = lazySingleton(() => import('./analyzers/universal/UniversalSOLIDAnalyzer.js').then((m) => new m.UniversalSOLIDAnalyzer()));
-    return {
+    const visitor = {
         name: 'solid',
         stage: 'visitor',
         getRuleIds: () => getRuleIdsFor('solid'),
@@ -69,6 +67,18 @@ export function createSolidVisitor() {
         description: 'Detects violations of SOLID principles',
         category: 'architecture',
     };
+    return {
+        visitor,
+        getSizeSamples: async () => {
+            try {
+                const a = await getAnalyzer();
+                return a.sizeSamples ?? [];
+            }
+            catch {
+                return [];
+            }
+        },
+    };
 }
 export function createDryVisitor(fullFunctionIndex) {
     const getAnalyzer = lazySingleton(() => import('./analyzers/universal/UniversalDRYAnalyzer.js').then((m) => new m.UniversalDRYAnalyzer()));
@@ -408,6 +418,9 @@ export function createFunctionIndexVisitor() {
                     const { classification, resolvedPath } = classifyImportSpecifier(imp.source, filePath, corpusFiles, {
                         virtualModules,
                         aliasPatterns: tsconfigAliases?.pathPatterns ?? [],
+                        pathMappings: tsconfigAliases?.paths ?? {},
+                        baseUrl: tsconfigAliases?.baseUrl,
+                        projectRoot: context.projectRoot,
                     });
                     indexFacts.push({
                         table: 'import_specifiers',
@@ -542,7 +555,7 @@ export function createReactVisitor() {
                 }
             }
             catch {
-                // Cross-component checks are advisory
+                // Cross-component checks are high
             }
             return violations;
         },
@@ -856,7 +869,12 @@ export function createStylesReducer() {
                 const factsConsumed = context.indexHandle.count('style_declarations')
                     + context.indexHandle.count('style_tokens')
                     + context.indexHandle.count('style_class_usage');
-                return { violations: result.violations ?? [], facts: {}, factsConsumed };
+                return {
+                    violations: result.violations ?? [],
+                    facts: {},
+                    factsConsumed,
+                    ...((result.diagnostics?.length ?? 0) > 0 && { diagnostics: result.diagnostics }),
+                };
             }
             catch {
                 return { violations: [], facts: {} };
@@ -1507,27 +1525,35 @@ function clIsEntryPointFile(fp) {
         return true;
     return false;
 }
+/** Resolve one import specifier to zero or one internal file via the classifier. */
+function clResolveImport(dep, sourceFile, options) {
+    const { classification, resolvedPath } = classifyImportSpecifier(dep, sourceFile, options.corpusFiles, {
+        virtualModules: options.virtualModules,
+        aliasPatterns: options.tsconfigAliases?.pathPatterns ?? [],
+        pathMappings: options.tsconfigAliases?.paths ?? {},
+        baseUrl: options.tsconfigAliases?.baseUrl,
+        projectRoot: options.projectRoot,
+    });
+    if (classification === 'internal-resolved' && resolvedPath)
+        return [resolvedPath];
+    return [];
+}
 /**
  * Compute file-level reachability from per-file imports.
  *
  * A file is a framework entry point (live → 1.0), imported by another file
- * (live → 0.5), or referenced by nothing (dead → 0.0). The resolver mirrors
- * importGraph.ts and handles relative paths, npm/alias basenames, and fuzzy
- * path-segment matches.
+ * (live → 0.5), or referenced by nothing (dead → 0.0). Resolution goes through
+ * `classifyImportSpecifier` (relative paths and tsconfig `paths` aliases like
+ * `@/`) instead of the legacy basename/fuzzy matcher, so an alias import creates
+ * a real edge and a bare package import never fabricates a local one.
  */
-function clComputeReachability(fileFacts) {
+function clComputeReachability(fileFacts, options) {
     const filePaths = new Set(fileFacts.keys());
-    const moduleToFile = new Map();
-    for (const fp of filePaths) {
-        const bn = basenameNoExt(fp);
-        if (!moduleToFile.has(bn))
-            moduleToFile.set(bn, new Set());
-        moduleToFile.get(bn).add(fp);
-    }
+    const packageEntries = options.packageEntryPoints ?? new Set();
     const importersOf = new Map();
     for (const [fp, info] of fileFacts) {
         for (const dep of info.imports) {
-            const targets = resolveDependency(dep, filePaths, moduleToFile, fp);
+            const targets = clResolveImport(dep, fp, options);
             for (const t of targets) {
                 if (t === fp)
                     continue;
@@ -1539,12 +1565,106 @@ function clComputeReachability(fileFacts) {
     }
     const reachability = new Map();
     for (const fp of filePaths) {
-        const entry = clIsEntryPointFile(fp);
+        const entry = clIsEntryPointFile(fp) || packageEntries.has(fp);
         const imported = (importersOf.get(fp)?.size ?? 0) > 0;
         reachability.set(fp, entry ? 1 : imported ? 0.5 : 0);
     }
     return { reachability, importersOf };
 }
+/**
+ * Spec 60 R1 — classify every non-test source module as `tested`,
+ * `untested-live`, or `untested-dead` off the file-level import edges
+ * (`importersOf`), not `function_dependencies`.
+ *
+ * A module is `tested` when a test file imports it *directly* (the edge set is
+ * alias-aware — built by `clResolveImport` through `classifyImportSpecifier`).
+ * `untested-dead` is the *post*-exception dead bucket: a file imported by
+ * nothing *and* not a framework entry point. `deadPreException` is the
+ * empty-importers count before the entry-point exception, so the drop
+ * (`deadPreException - untestedDead`) attributes the entry points exempted.
+ */
+export function classifyTestCoverage(fileFacts, importersOf, packageEntrySet) {
+    const result = {
+        tested: 0,
+        untestedLive: 0,
+        untestedDead: 0,
+        total: 0,
+        deadPreException: 0,
+        deadPostException: 0,
+        deadDrop: 0,
+        entryPointExemptions: [],
+        testedFiles: [],
+        untestedLiveFiles: [],
+        untestedDeadFiles: [],
+    };
+    for (const fp of fileFacts.keys()) {
+        if (clIsTestFile(fp))
+            continue;
+        result.total++;
+        const importers = importersOf.get(fp);
+        if (!importers || importers.size === 0) {
+            // Imported by nothing — dead *unless* it is a framework entry point.
+            result.deadPreException++;
+            const isPackageEntry = packageEntrySet.has(fp);
+            const isEntry = isPackageEntry || clIsEntryPointFile(fp);
+            if (isEntry) {
+                result.untestedLive++;
+                result.untestedLiveFiles.push(fp);
+                result.entryPointExemptions.push({
+                    file: fp,
+                    kind: isPackageEntry ? 'package-entry' : 'entry-point',
+                });
+            }
+            else {
+                result.untestedDead++;
+                result.untestedDeadFiles.push(fp);
+            }
+            continue;
+        }
+        let hasTestImporter = false;
+        for (const importer of importers) {
+            if (clIsTestFile(importer)) {
+                hasTestImporter = true;
+                break;
+            }
+        }
+        if (hasTestImporter) {
+            result.tested++;
+            result.testedFiles.push(fp);
+        }
+        else {
+            result.untestedLive++;
+            result.untestedLiveFiles.push(fp);
+        }
+    }
+    result.deadPostException = result.untestedDead;
+    result.deadDrop = result.deadPreException - result.untestedDead;
+    return result;
+}
+/**
+ * Spec 60 R3 — group unreferenced modules by basename, surfacing the pattern of
+ * the same file name appearing in several sibling directories (e.g. two
+ * `ErrorState.tsx`, three `services.ts` under separate `reports` folders). Only
+ * basenames with ≥2 files become clusters; a singleton dead file is not a duplicate.
+ */
+export function clusterDeadModules(deadFiles) {
+    const byBasename = new Map();
+    for (const fp of deadFiles) {
+        const segments = fp.replace(/\\/g, '/').split('/').filter(Boolean);
+        const basename = segments[segments.length - 1] ?? fp;
+        const list = byBasename.get(basename) ?? [];
+        list.push(fp);
+        byBasename.set(basename, list);
+    }
+    const clusters = [];
+    for (const [basename, files] of byBasename) {
+        if (files.length >= 2) {
+            clusters.push({ basename, count: files.length, files });
+        }
+    }
+    clusters.sort((a, b) => b.count - a.count || a.basename.localeCompare(b.basename));
+    return clusters;
+}
 /**
  * Build `calls` cross-references by resolving each entity's extracted callee
  * names against the corpus entity name index. Library calls (fetch, map, …)
@@ -1759,8 +1879,21 @@ export function createDependencyGraphReducer() {
                 }
                 // ── File-level reachability: unreferenced modules + ranking axis ──
                 const fileFacts = clFileFacts(allFacts);
+                let testCoverage;
+                let deadClusters = [];
                 if (fileFacts.size > 0) {
-                    const { reachability, importersOf } = clComputeReachability(fileFacts);
+                    // `context.config` is the reducer's merged config (namespace + `_infra`);
+                    // a bare reducer context in a unit test omits it, so fall back to the
+                    // file facts themselves as the corpus and a no-alias classification.
+                    const infraConfig = (context.config ?? {});
+                    const packageEntrySet = new Set(infraConfig.packageEntryPoints ?? []);
+                    const { reachability, importersOf } = clComputeReachability(fileFacts, {
+                        corpusFiles: new Set(infraConfig.corpusFiles ?? [...fileFacts.keys()]),
+                        virtualModules: infraConfig.importVirtualModules ?? DEFAULT_VIRTUAL_MODULES,
+                        tsconfigAliases: infraConfig.tsconfigAliases,
+                        packageEntryPoints: packageEntrySet,
+                        projectRoot: context.projectRoot ?? '',
+                    });
                     // Persist reachability to graph_cache so the post-pipeline reorder
                     // (auditRunner hotspot block) can rank every finding by live/dead.
                     if (context.indexHandle?.rawDb) {
@@ -1781,19 +1914,44 @@ export function createDependencyGraphReducer() {
                             // neutral default without it.
                         }
                     }
+                    // Spec 60 R1 — persist the file-level import edges (reverse adjacency:
+                    // module → its direct importers) so "what tests exercise this module"
+                    // is answerable downstream from `importersOf`, not the symbol-level
+                    // `function_dependencies` table.
+                    if (context.indexHandle?.rawDb) {
+                        try {
+                            const db = context.indexHandle.rawDb;
+                            const del = db.prepare("DELETE FROM graph_cache WHERE graph_type = 'importers'");
+                            const ins = db.prepare("INSERT OR REPLACE INTO graph_cache (graph_type, node_key, neighbor_key, weight) VALUES ('importers', ?, ?, 1)");
+                            const tx = db.transaction(() => {
+                                del.run();
+                                for (const [fp, importers] of importersOf) {
+                                    for (const importer of importers) {
+                                        ins.run(fp, importer);
+                                    }
+                                }
+                            });
+                            tx();
+                        }
+                        catch {
+                            // Importer-edge persistence is advisory, like reachability.
+                        }
+                    }
                     // Flag files that export symbols yet are imported by nothing and are
                     // not framework entry points — a dead module. This is the signal the
                     // orphaned-nodes check missed: a whole unreferenced file whose every
                     // internal symbol still forms a connected component.
+                    const deadModuleFiles = [];
                     for (const [fp, info] of fileFacts) {
                         if (!info.hasExports)
                             continue;
                         if (clIsTestFile(fp))
                             continue;
-                        if (clIsEntryPointFile(fp))
+                        if (clIsEntryPointFile(fp) || packageEntrySet.has(fp))
                             continue;
                         if ((importersOf.get(fp)?.size ?? 0) > 0)
                             continue;
+                        deadModuleFiles.push(fp);
                         violations.push({
                             file: fp,
                             line: 1,
@@ -1808,6 +1966,12 @@ export function createDependencyGraphReducer() {
                             details: { imports: info.imports },
                         });
                     }
+                    // Spec 60 R1 — classify each non-test module off the import edge set.
+                    testCoverage = classifyTestCoverage(fileFacts, importersOf, packageEntrySet);
+                    // Spec 60 R3 — cluster the unreferenced modules by basename so the
+                    // "dead-and-duplicated" pattern (same file name in sibling dirs) is
+                    // visible as a cluster rather than scattered one-per-file findings.
+                    deadClusters = clusterDeadModules(deadModuleFiles);
                     // Spec 58 R2 — computed-specifier dynamic imports. `import(someVar)`
                     // cannot be resolved into an edge, so any module in this corpus could
                     // be its target and `unreferenced-module` is therefore not exhaustive.
@@ -1828,15 +1992,15 @@ export function createDependencyGraphReducer() {
                 }
                 const HEALTH_SEVERITY = {
                     'break-cycles': 'severe',
-                    'reduce-coupling': 'advisory',
-                    'split-responsibilities': 'advisory',
+                    'reduce-coupling': 'high',
+                    'split-responsibilities': 'high',
                     'review-orphans': 'severe',
                 };
                 for (const s of health.suggestions) {
                     violations.push({
                         file: '(multiple)',
                         line: 0,
-                        severity: HEALTH_SEVERITY[s.type] ?? 'advisory',
+                        severity: HEALTH_SEVERITY[s.type] ?? 'high',
                         message: s.description,
                         rule: s.type,
                         type: s.type,
@@ -1845,7 +2009,12 @@ export function createDependencyGraphReducer() {
                         details: s.affectedNodes ? { affectedNodes: s.affectedNodes } : undefined,
                     });
                 }
-                return { violations, facts: {}, factsConsumed: entities.length, ...(diagnostics.length > 0 && { diagnostics }) };
+                const facts = {};
+                if (testCoverage)
+                    facts.testCoverage = testCoverage;
+                if (deadClusters.length > 0)
+                    facts.deadClusters = deadClusters;
+                return { violations, facts, factsConsumed: entities.length, ...(diagnostics.length > 0 && { diagnostics }) };
             }
             catch (e) {
                 console.error('[dependency-graph reducer] error:', e.message);
@@ -2093,6 +2262,7 @@ export function createSchemaCodeVisitor() {
                         line: usage.line,
                         column: usage.column,
                         raw_query: usage.rawQuery,
+                        origin: usage.origin ?? null,
                     },
                 });
             }
@@ -2111,9 +2281,14 @@ export function createSchemaCodeVisitor() {
             }
             // Check SQL injection
             violations.push(...checkSQLInjection(ast, adapter, sourceCode));
-            // Emit facts for the Stage 3 reducer
+            // Emit facts for the Stage 3 reducer. Fluent-builder references
+            // (`origin: 'query-builder'`) are excluded from the unknown-table check:
+            // a scratch/test table name carried by `db('t').select(...)` is not a
+            // schema catalog miss, and feeding it in flips the 10:1 fail-open ratio.
             const fileFacts = {
-                tableRefs: tableRefs.map((r) => ({
+                tableRefs: tableRefs
+                    .filter((r) => r.origin !== 'query-builder')
+                    .map((r) => ({
                     table: r.table,
                     type: r.type,
                     line: r.location.line,
@@ -2283,12 +2458,18 @@ export function createSchemaReducer() {
                 // Genuinely-new tables introduced by this migration (excludes rename/rebuild
                 // churn like `ALTER … RENAME TO x_old` + re-CREATE of the same name).
                 const createdHere = [];
+                const createdTables = new Set();
+                const droppedTables = new Set();
                 for (const op of sqlFile.ops) {
+                    const t = stripIdentifier(op.table);
                     if (op.op === 'CREATE') {
-                        const t = stripIdentifier(op.table);
+                        createdTables.add(t);
                         if (!before.has(t))
                             createdHere.push(t);
                     }
+                    else if (op.op === 'DROP') {
+                        droppedTables.add(t);
+                    }
                 }
                 for (const op of sqlFile.ops) {
                     const t = stripIdentifier(op.table);
@@ -2299,6 +2480,21 @@ export function createSchemaReducer() {
                         dropProvenance.delete(t);
                     }
                 }
+                // A table created and dropped within this same file is a self-contained
+                // fixture — a scratch table a test or script creates, uses, then tears
+                // down. Its DROP is teardown, not a migration, so it must neither surface
+                // as a stale-table-reference nor leave the name unknown: keep it known and
+                // clear the drop provenance this file recorded for it. (A genuine dropped
+                // table stays stale because its DROP lives in a migration that never also
+                // CREATEs it — e.g. recall's `generation_queue`, dropped in 0198.)
+                for (const t of createdTables) {
+                    if (droppedTables.has(t)) {
+                        knownTables.add(t);
+                        if (dropProvenance.get(t)?.migrationFile === sqlFile.filePath) {
+                            dropProvenance.delete(t);
+                        }
+                    }
+                }
             }
             // 1b. ORM tables from code files — with provenance from the table-source registry
             for (const [filePath, fact] of perFile()) {
@@ -2403,9 +2599,14 @@ export function createSchemaReducer() {
                                 symbol: ref.table,
                                 resolution: {
                                     action: 'update-stale-reference',
+                                    // The tables `created` are evidence the migration replaced the
+                                    // dropped table, not proof of a drop-in successor — schemas can
+                                    // be split or changed incompatibly, in which case the file must
+                                    // be removed rather than updated. The summary names them as
+                                    // context and leaves update-vs-remove to the reviewer.
                                     summary: created.length > 0
-                                        ? `The table '${ref.table}' was dropped in ${migrationName}. That migration creates ${joinEnglish(created)} — update this reference to a table that still exists.`
-                                        : `The table '${ref.table}' was dropped in ${migrationName} and not recreated — update or remove this reference.`,
+                                        ? `The table '${ref.table}' was dropped in ${migrationName}. That migration introduces ${joinEnglish(created)} — review this reference and update or remove it.`
+                                        : `The table '${ref.table}' was dropped in ${migrationName} and was not recreated — update or remove this reference.`,
                                     symbols: created.length > 0 ? created : [ref.table],
                                     files: [ref.file],
                                     lines: [ref.line],