@duckcodeailabs/dql-agent 1.6.32 → 1.6.34

package/dist/metadata/catalog.js

@@ -19,6 +19,9 @@ import { buildRuntimeValueIndex, normalizeValueIndexText, } from '../grounding/v
 import { grainMatches, requestedGrainFromPlan, } from './grain-gate.js';
 import { certifiedFitAllowsTier1, evaluateCertifiedBlockFit, } from './block-fit.js';
 import { retrieveScopedHints } from '../hints/retrieval.js';
+import { buildFtsMatch, sanitizeFtsQuery } from '../memory/fts-query.js';
+import { envEmbeddingProvider } from '../embeddings/provider.js';
+import { matchExampleParaphrase } from './example-match.js';
 const require = createRequire(import.meta.url);
 let databaseCtor = null;
 function loadDatabase() {
@@ -27,6 +30,39 @@ function loadDatabase() {
 }
 const SCHEMA_SHAPE_CACHE_LIMIT = 64;
 const schemaShapeCandidateCache = new Map();
+/**
+ * Extract single-column `unique` dbt tests, keyed by model name (W5.3). A column
+ * a `unique` test guards is a grain key, which feeds the grain ledger's fan-out
+ * detection — the common way real dbt repos declare keys. Handles both the
+ * `attached_node` (newer dbt) and `depends_on` shapes, and top-level or kwargs
+ * column names.
+ */
+export function extractDbtUniqueColumns(nodes) {
+    const byModel = new Map();
+    for (const node of Object.values(nodes)) {
+        if (node.resource_type !== 'test')
+            continue;
+        const testMetadata = node.test_metadata;
+        if (stringValue(testMetadata?.name) !== 'unique')
+            continue;
+        const column = stringValue(node.column_name) ?? stringValue(testMetadata?.kwargs?.column_name);
+        if (!column)
+            continue;
+        const dependsOn = node.depends_on?.nodes;
+        const attached = stringValue(node.attached_node)
+            ?? (Array.isArray(dependsOn) ? dependsOn.map(String).find((ref) => ref.startsWith('model.')) : undefined);
+        if (!attached)
+            continue;
+        const modelName = attached.split('.').at(-1);
+        if (!modelName)
+            continue;
+        const existing = byModel.get(modelName) ?? [];
+        if (!existing.includes(column))
+            existing.push(column);
+        byModel.set(modelName, existing);
+    }
+    return byModel;
+}
 const OBJECT_PRIORITY = {
     dql_block: 1,
     dql_block_output: 1.5,
@@ -74,7 +110,15 @@ export async function ensureMetadataCatalogFresh(projectRoot, options = {}) {
                 fingerprint: snapshot.fingerprint,
             };
         }
-        catalog.rebuild(snapshot);
+        // W3.4 — incremental reindex when prior state exists (only re-tokenizes changed
+        // sources' FTS); `force` does a clean full rebuild. Proven equal to a full
+        // rebuild by incremental-reindex.test.ts.
+        if (options.force) {
+            catalog.rebuild(snapshot);
+        }
+        else {
+            catalog.rebuildIncremental(snapshot);
+        }
         return {
             path: defaultMetadataPath(projectRoot),
             refreshed: true,
@@ -221,7 +265,7 @@ export async function buildLocalContextPack(projectRoot, request) {
         const trustLabel = deriveTrust(objects);
         const citations = buildCitations(objects, contextEdges);
         const evidenceSummaries = buildEvidenceSummaries(objects, contextEdges, queryRuns, diagnostics);
-        const allowedSqlContext = sortAllowedSqlContextForAnalysisPlan(buildAllowedSqlContext(objects, contextEdges), questionPlan);
+        const allowedSqlContext = sortAllowedSqlContextForAnalysisPlan(buildAllowedSqlContext(objects, contextEdges, tokenizeQuestionForColumns(request.question)), questionPlan);
         const selectedRelations = allowedSqlContext.relations.slice(0, 24).map((relation, index) => {
             const scored = scoreAllowedSqlRelationWithAnalysisPlan(relation, questionPlan);
             return {
@@ -362,6 +406,16 @@ export function recordRuntimeSchemaSnapshot(projectRoot, snapshot) {
         catalog.close();
     }
 }
+/** The most-recent stored live-warehouse schema snapshot for a project, or null. */
+export function latestRuntimeSchemaSnapshotForProject(projectRoot) {
+    const catalog = openMetadataCatalog(projectRoot);
+    try {
+        return catalog.latestRuntimeSchemaSnapshot();
+    }
+    finally {
+        catalog.close();
+    }
+}
 export function buildMetadataSnapshot(projectRoot, manifest, semanticLayer) {
     const manifestGraph = buildKGFromManifest(manifest);
     const semanticGraph = buildKGFromSemanticLayer(semanticLayer);
@@ -643,23 +697,130 @@ export class MetadataCatalog {
         });
         txn();
     }
+    /**
+     * Incremental reindex (W3.4). Only re-inserts objects + FTS rows for sources
+     * whose per-source fingerprint changed (or vanished); unchanged sources' rows are
+     * left in place (skipping the expensive FTS re-tokenization at scale). Edges,
+     * diagnostics, domain shards, and sourceless objects are always rebuilt because
+     * they cross source boundaries. Provably equal to a full rebuild for the semantic
+     * content (object keys/types/names/domains/payloads + FTS + edges); only the
+     * `updated_at`/`built_at` timestamps of untouched rows differ. Falls back to a
+     * full rebuild when there is no prior fingerprint state.
+     */
+    rebuildIncremental(snapshot) {
+        const stored = new Map();
+        for (const row of this.db.prepare('SELECT source_path, fingerprint FROM metadata_source_fingerprints').all()) {
+            stored.set(row.source_path, row.fingerprint);
+        }
+        if (stored.size === 0) {
+            this.rebuild(snapshot);
+            return { mode: 'full', changedSources: 0 };
+        }
+        const now = new Date().toISOString();
+        const incoming = buildSourceFingerprints(snapshot.objects, now);
+        const incomingSources = new Set(incoming.map((f) => f.sourcePath));
+        const changedSources = new Set();
+        for (const fingerprint of incoming) {
+            if (stored.get(fingerprint.sourcePath) !== fingerprint.fingerprint)
+                changedSources.add(fingerprint.sourcePath);
+        }
+        const removedSources = [...stored.keys()].filter((source) => !incomingSources.has(source));
+        const sourceOf = (object) => object.sourcePath ?? object.sourceSystem ?? null;
+        const domainShards = buildDomainShards(snapshot.objects, now);
+        const insertObject = this.db.prepare(`
+      INSERT INTO metadata_objects (
+        object_key, object_type, name, full_name, domain, owner, status,
+        description, source_path, source_system, payload_json, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        const insertFts = this.db.prepare(`
+      INSERT INTO metadata_fts (object_key, name, full_name, description, domain, owner, payload)
+      VALUES (?, ?, ?, ?, ?, ?, ?)`);
+        const insertEdge = this.db.prepare(`
+      INSERT OR IGNORE INTO metadata_edges (edge_type, from_key, to_key, confidence, payload_json, created_at)
+      VALUES (?, ?, ?, ?, ?, ?)`);
+        const insertDiagnostic = this.db.prepare(`
+      INSERT INTO metadata_diagnostics (id, kind, severity, message, object_key, file_path, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)`);
+        const insertSourceFingerprint = this.db.prepare(`
+      INSERT OR REPLACE INTO metadata_source_fingerprints (source_path, fingerprint, object_count, updated_at)
+      VALUES (?, ?, ?, ?)`);
+        const insertDomainShard = this.db.prepare(`
+      INSERT OR REPLACE INTO metadata_domain_shards (
+        domain, object_count, block_count, certified_block_count,
+        semantic_metric_count, dbt_object_count, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)`);
+        const setState = this.db.prepare('INSERT OR REPLACE INTO metadata_state (key, value) VALUES (?, ?)');
+        const deleteFtsForSource = this.db.prepare('DELETE FROM metadata_fts WHERE object_key IN (SELECT object_key FROM metadata_objects WHERE COALESCE(source_path, source_system) = ?)');
+        const deleteObjectsForSource = this.db.prepare('DELETE FROM metadata_objects WHERE COALESCE(source_path, source_system) = ?');
+        const txn = this.db.transaction(() => {
+            // Drop changed + removed sources' rows, and ALL sourceless rows (never
+            // fingerprinted, so always refreshed).
+            for (const source of [...changedSources, ...removedSources]) {
+                deleteFtsForSource.run(source);
+                deleteObjectsForSource.run(source);
+            }
+            this.db.prepare('DELETE FROM metadata_fts WHERE object_key IN (SELECT object_key FROM metadata_objects WHERE source_path IS NULL AND source_system IS NULL)').run();
+            this.db.prepare('DELETE FROM metadata_objects WHERE source_path IS NULL AND source_system IS NULL').run();
+            // Re-insert only objects from changed sources or sourceless; unchanged
+            // sources' rows are left untouched.
+            for (const object of snapshot.objects) {
+                const source = sourceOf(object);
+                if (source !== null && !changedSources.has(source))
+                    continue;
+                const payload = object.payload ?? {};
+                insertObject.run(object.objectKey, object.objectType, object.name, object.fullName ?? null, object.domain ?? null, object.owner ?? null, object.status ?? null, object.description ?? null, object.sourcePath ?? null, object.sourceSystem ?? null, JSON.stringify(payload), object.updatedAt ?? now);
+                insertFts.run(object.objectKey, object.name, object.fullName ?? '', object.description ?? '', object.domain ?? '', object.owner ?? '', JSON.stringify(payload));
+            }
+            // Cross-source tables: rebuild fully.
+            this.db.prepare('DELETE FROM metadata_edges').run();
+            for (const edge of snapshot.edges) {
+                insertEdge.run(edge.edgeType, edge.fromKey, edge.toKey, edge.confidence ?? 1, JSON.stringify(edge.payload ?? {}), now);
+            }
+            this.db.prepare('DELETE FROM metadata_diagnostics').run();
+            for (const diagnostic of snapshot.diagnostics) {
+                insertDiagnostic.run(diagnosticId(diagnostic), diagnostic.kind, diagnostic.severity, diagnostic.message, diagnostic.objectKey ?? null, diagnostic.filePath ?? null, now);
+            }
+            this.db.prepare('DELETE FROM metadata_domain_shards').run();
+            for (const shard of domainShards) {
+                insertDomainShard.run(shard.domain, shard.objectCount, shard.blockCount, shard.certifiedBlockCount, shard.semanticMetricCount, shard.dbtObjectCount, shard.updatedAt);
+            }
+            for (const source of removedSources) {
+                this.db.prepare('DELETE FROM metadata_source_fingerprints WHERE source_path = ?').run(source);
+            }
+            for (const fingerprint of incoming) {
+                insertSourceFingerprint.run(fingerprint.sourcePath, fingerprint.fingerprint, fingerprint.objectCount, fingerprint.updatedAt);
+            }
+            setState.run('built_at', now);
+            setState.run('fingerprint', snapshot.fingerprint);
+            setState.run('project_root', snapshot.projectRoot);
+            setState.run('object_count', String(snapshot.objects.length));
+            setState.run('edge_count', String(snapshot.edges.length));
+            setState.run('source_fingerprint_count', String(incoming.length));
+            setState.run('domain_shard_count', String(domainShards.length));
+            setState.run('diagnostics_json', JSON.stringify(snapshot.diagnostics));
+            setState.run('compile_conflicts_json', JSON.stringify(snapshot.compileConflicts ?? []));
+            setState.run('manifest_generated_at', snapshot.manifest.generatedAt);
+        });
+        txn();
+        return { mode: 'incremental', changedSources: changedSources.size };
+    }
     searchObjects(options) {
         const { query, objectTypes, domain, limit = 40 } = options;
-        const sanitized = sanitizeFtsQuery(query);
-        if (!sanitized)
+        const match = buildFtsMatch(query, { prefix: true });
+        if (!match.or)
             return this.listObjects({ objectTypes, domain, limit });
         const filters = [];
-        const params = [sanitized];
+        const extraParams = [];
         if (objectTypes && objectTypes.length > 0) {
             filters.push(`o.object_type IN (${objectTypes.map(() => '?').join(', ')})`);
-            params.push(...objectTypes);
+            extraParams.push(...objectTypes);
         }
         if (domain) {
             filters.push('o.domain = ?');
-            params.push(domain);
+            extraParams.push(domain);
         }
         const whereExtra = filters.length > 0 ? ` AND ${filters.join(' AND ')}` : '';
-        const rows = this.db.prepare(`
+        const runMatch = (matchExpr) => this.db.prepare(`
       SELECT o.*,
              bm25(metadata_fts) AS rank,
              snippet(metadata_fts, -1, '<mark>', '</mark>', '...', 12) AS snip
@@ -668,7 +829,15 @@ export class MetadataCatalog {
       WHERE metadata_fts MATCH ?${whereExtra}
       ORDER BY rank
       LIMIT ?
-    `).all(...params, limit);
+    `).all(matchExpr, ...extraParams, limit);
+        // Precision-first, recall-preserving UNION: all-terms-co-occur (AND) matches
+        // lead, then OR-of-terms matches fill the remaining budget. A doc mentioning
+        // only one term (a relevant context column) still surfaces, while a doc
+        // containing every term ranks ahead of it. Dedup by object_key.
+        const andRows = match.and ? runMatch(match.and) : [];
+        const seen = new Set(andRows.map((row) => row.object_key));
+        const orRows = runMatch(match.or).filter((row) => !seen.has(row.object_key));
+        const rows = [...andRows, ...orRows].slice(0, limit);
         return rows.map((row) => ({
             ...rowToObject(row),
             score: row.rank ? 1 / (1 + Math.max(0, row.rank)) : 1,
@@ -839,6 +1008,14 @@ export class MetadataCatalog {
     `);
         const txn = this.db.transaction(() => {
             insertSnapshot.run(id, cleanSnapshot.source ?? null, JSON.stringify(cleanSnapshot), capturedAt);
+            // Only the most-recent snapshot is ever read; rows otherwise accumulate one per
+            // question forever. Keep a small margin and prune the rest (P7).
+            this.db.prepare(`
+        DELETE FROM runtime_schema_snapshots
+        WHERE id NOT IN (
+          SELECT id FROM runtime_schema_snapshots ORDER BY captured_at DESC LIMIT 5
+        )
+      `).run();
             this.db.prepare('DELETE FROM runtime_value_fts').run();
             this.db.prepare('DELETE FROM runtime_value_index').run();
             for (const entry of valueEntries) {
@@ -853,7 +1030,9 @@ export class MetadataCatalog {
     }
     searchRuntimeValues(terms, limit = 40) {
         const cleanTerms = uniqueStrings(terms.map(normalizeValueIndexText).filter(Boolean)).slice(0, 8);
-        const query = sanitizeFtsQuery(cleanTerms.join(' '));
+        // Filter VALUES may legitimately be stop words (a category named "current");
+        // fall back to raw tokens so value binding still fires rather than dropping to empty.
+        const query = sanitizeFtsQuery(cleanTerms.join(' '), { prefix: true, fallbackToRawTokens: true });
         if (!query)
             return [];
         const rows = this.db.prepare(`
@@ -1197,6 +1376,7 @@ function addRawDbtManifestCatalogObjects(projectRoot, manifest, objects, edges,
         return;
     }
     const catalogColumns = loadRawDbtCatalogColumns(join(dirname(manifestPath), 'catalog.json'));
+    const uniqueColumnsByModel = extractDbtUniqueColumns(raw.nodes ?? {});
     const entries = [];
     for (const [uniqueId, node] of Object.entries(raw.nodes ?? {})) {
         if (node.resource_type !== 'model')
@@ -1216,6 +1396,7 @@ function addRawDbtManifestCatalogObjects(projectRoot, manifest, objects, edges,
             database,
             schema,
             catalogColumns: catalogColumns.get(uniqueId),
+            uniqueColumns: uniqueColumnsByModel.get(name),
         };
         entries.push(entry);
         addRawDbtCatalogObject({
@@ -1285,6 +1466,8 @@ function addRawDbtCatalogObject(input) {
             catalogOnly: existing ? undefined : true,
             columnCompleteness,
             columns,
+            // W5.3 — single-column `unique` dbt tests become grain-ledger keys.
+            uniqueColumns: input.uniqueColumns && input.uniqueColumns.length > 0 ? input.uniqueColumns : undefined,
         }),
     }));
     for (const column of columns) {
@@ -1659,6 +1842,10 @@ function addDataLexManifestObjects(projectRoot, manifest, objects, edges, diagno
                 payload: compactObject({
                     tags: entity.tags ?? [],
                     binding: entity.binding,
+                    // Entity-level grain + keys (W5.2) feed the grain ledger for fan-out safety.
+                    grain: entity.grain,
+                    candidateKeys: entity.candidate_keys,
+                    businessKeys: entity.business_keys,
                     fields: (entity.fields ?? []).slice(0, 100).map((field) => compactObject({
                         name: field.name,
                         type: field.type,
@@ -1744,6 +1931,58 @@ function addDataLexManifestObjects(projectRoot, manifest, objects, edges, diagno
             }),
         });
     }
+    // Concept-to-physical conformance (W5.1) → searchable `datalex_concept` nodes
+    // carrying the canonical key + the physical relations that realize the concept,
+    // plus `datalex_conforms` edges so retrieval can collapse several physical tables
+    // into one business concept ("Customer" → dim_customer, stg_customers) and reason
+    // at the concept grain. Modeling metadata only — no certification coupling.
+    for (const conformance of raw.conformance ?? []) {
+        if (!conformance?.concept)
+            continue;
+        const conceptDomain = conformance.domain ?? '';
+        const conceptKey = `datalex:concept:${conceptDomain}.${conformance.concept}`;
+        const physicalRefs = (conformance.physical ?? [])
+            .map((physical) => (physical.binding ? objectKeyForDataLexBinding(physical.binding) : undefined))
+            .filter((key) => Boolean(key));
+        const canonicalKey = conformance.canonical_key ?? [];
+        objects.set(conceptKey, mergeObject(objects.get(conceptKey), {
+            objectKey: conceptKey,
+            objectType: 'datalex_concept',
+            name: conformance.concept,
+            fullName: `${conceptDomain}.${conformance.concept}`,
+            domain: conceptDomain || undefined,
+            status: 'contract_evidence',
+            description: `Business concept ${conformance.concept}`
+                + (canonicalKey.length ? ` (canonical key: ${canonicalKey.join(', ')})` : '')
+                + (physicalRefs.length ? `, realized by ${physicalRefs.length} physical relation(s).` : '.'),
+            sourcePath: manifestPath,
+            sourceSystem: 'DataLex manifest',
+            payload: compactObject({
+                canonicalKey,
+                businessKey: conformance.business_key ?? [],
+                implements: conformance.implements ?? [],
+                physicalRefs,
+            }),
+        }));
+        if (conceptDomain) {
+            putEdge(edges, {
+                edgeType: 'contains',
+                fromKey: `datalex:domain:${conceptDomain}`,
+                toKey: conceptKey,
+                confidence: 1,
+                payload: { source: 'datalex conformance' },
+            });
+        }
+        for (const ref of physicalRefs) {
+            putEdge(edges, {
+                edgeType: 'datalex_conforms',
+                fromKey: conceptKey,
+                toKey: ref,
+                confidence: 0.95,
+                payload: compactObject({ source: 'datalex conformance', concept: conformance.concept, canonicalKey }),
+            });
+        }
+    }
     for (const block of Object.values(manifest.blocks ?? {})) {
         if (!block.datalexContract)
             continue;
@@ -2056,15 +2295,30 @@ async function planContextPackRoute(input) {
     const exactByApplicability = [...applicabilityByKey.values()]
         .filter((item) => item.kind === 'exact_answer' || item.kind === 'safe_parameterized')
         .sort((a, b) => b.score - a.score)[0];
-    const exact = exactByApplicability
+    let exact = exactByApplicability
         ? input.objects.find((object) => object.objectKey === exactByApplicability.objectKey)
         : findExactCertifiedObject(input.request.question, intent, input.objects);
-    const certifiedApplicability = exact
-        ? applicabilityByKey.get(exact.objectKey) ?? certifiedApplicabilityForObject(exact, input.questionPlan)
-        : undefined;
     const contextApplicability = [...applicabilityByKey.values()]
         .filter((item) => item.kind === 'context_only')
         .sort((a, b) => b.score - a.score)[0];
+    // W2.1 — paraphrase promotion. When no block string/lexically matched, promote a
+    // top context-only certified candidate whose example QUESTION the user paraphrased
+    // (semantic cosine + direction) to the certified candidate. It still runs the full
+    // shape/grain fit below (paraphraseExampleMatch is kept OUT of directCertifiedBypass,
+    // the fit's exactExampleMatch, and the grain-gate skip) — so paraphrase never bypasses
+    // grain the way a user naming the block directly does.
+    let paraphraseExampleMatch = false;
+    if (!exact && contextApplicability) {
+        const candidate = input.objects.find((object) => object.objectKey === contextApplicability.objectKey);
+        if (candidate && isCertifiedMetadataObject(candidate)
+            && await matchExampleParaphrase(input.request.question, candidate, envEmbeddingProvider())) {
+            exact = candidate;
+            paraphraseExampleMatch = true;
+        }
+    }
+    const certifiedApplicability = exact
+        ? applicabilityByKey.get(exact.objectKey) ?? certifiedApplicabilityForObject(exact, input.questionPlan)
+        : undefined;
     const exactExampleMatch = exact ? hasExactExampleQuestion(input.request.question, exact) : false;
     const directCertifiedBypass = Boolean(exact && (exactExampleMatch
         || intent === 'definition_lookup'
@@ -2127,6 +2381,7 @@ async function planContextPackRoute(input) {
         || intent === 'exact_certified_lookup'
         || intent === 'definition_lookup'
         || exactExampleMatch
+        || paraphraseExampleMatch
         || (intent === 'ad_hoc_ranking' && objectNameInQuestion(input.request.question, exact)))) {
         return {
             route: 'certified',
@@ -3006,6 +3261,55 @@ function isSqlParentObject(object) {
         object.objectType === 'warehouse_table' ||
         object.objectType === 'runtime_table';
 }
+/** Column budget for a single relation in the prompt's allowed-SQL context. */
+const MAX_ALLOWED_SQL_COLUMNS = 120;
+/**
+ * Relevance score for keeping a column when a wide relation must be truncated (W3.3).
+ * Structural columns (join keys, time/grain) always score so joins and grain survive;
+ * a column whose name overlaps the question scores highest so the needed column on a
+ * 300-column table is not dropped just because it sits past the budget cut.
+ */
+function columnBudgetScore(name, questionTokens) {
+    const lower = name.toLowerCase();
+    let score = 0;
+    if (/(^|_)(id|key)$/.test(lower) || lower === 'id')
+        score += 3;
+    if (/(date|time|_at$|_ts$|day|month|year|week|quarter)/.test(lower))
+        score += 2;
+    if (questionTokens) {
+        for (const token of questionTokens) {
+            if (token.length > 2 && lower.includes(token)) {
+                score += 5;
+                break;
+            }
+        }
+    }
+    return score;
+}
+/**
+ * Cap a relation's column list to the prompt budget and downgrade completeness to
+ * 'partial' when columns are dropped. Keeping a truncated relation 'complete' would
+ * let column validation false-positive a valid column past the cut as unknown_column
+ * (the >120-column latent bug, W1.4). When truncating, keep the columns most relevant
+ * to the question + structural keys (W3.3) rather than the arbitrary first-N, then
+ * restore original order among the survivors so prompt ordering is unchanged.
+ */
+function capAllowedSqlColumns(columns, completeness, questionTokens) {
+    if (columns.length <= MAX_ALLOWED_SQL_COLUMNS) {
+        return { columns, columnCompleteness: completeness };
+    }
+    const kept = columns
+        .map((column, index) => ({ column, index, score: columnBudgetScore(column.name, questionTokens) }))
+        .sort((a, b) => (b.score - a.score) || (a.index - b.index))
+        .slice(0, MAX_ALLOWED_SQL_COLUMNS)
+        .sort((a, b) => a.index - b.index)
+        .map((entry) => entry.column);
+    return { columns: kept, columnCompleteness: 'partial' };
+}
+/** Lowercased word tokens from the question, for column-relevance ranking. */
+function tokenizeQuestionForColumns(question) {
+    return (question.toLowerCase().match(/[a-z0-9_]+/g) ?? []).filter((token) => token.length > 2);
+}
 const FULL_CATALOG_RELATION_TYPES = ['dbt_model', 'dbt_source', 'warehouse_table', 'runtime_table'];
 const FULL_CATALOG_COLUMN_TYPES = ['dbt_column', 'warehouse_column', 'runtime_column'];
 /** Deep mode over a catalog this small hands the model everything instead of top-k. */
@@ -3032,7 +3336,7 @@ function collectFullCatalogObjects(catalog) {
         return undefined;
     return mergeObjects([...relations, ...columns]);
 }
-function buildAllowedSqlContext(objects, edges) {
+export function buildAllowedSqlContext(objects, edges, questionTokens) {
     const byRelation = new Map();
     const objectsByKey = new Map(objects.map((object) => [object.objectKey, object]));
     const addRelation = (relation) => {
@@ -3041,16 +3345,17 @@ function buildAllowedSqlContext(objects, edges) {
             return;
         const existing = byRelation.get(key);
         if (!existing) {
-            byRelation.set(key, { ...relation, columns: dedupeRuntimeColumns(relation.columns).slice(0, 120) });
+            const capped = capAllowedSqlColumns(dedupeRuntimeColumns(relation.columns), relation.columnCompleteness, questionTokens);
+            byRelation.set(key, { ...relation, columns: capped.columns, columnCompleteness: capped.columnCompleteness });
             return;
         }
-        const columnCompleteness = mergeRelationCompletenessForCatalog(existing, relation);
+        const capped = capAllowedSqlColumns(mergeRelationColumns(existing, relation), mergeRelationCompletenessForCatalog(existing, relation), questionTokens);
         byRelation.set(key, {
             ...existing,
             objectKey: existing.objectKey ?? relation.objectKey,
             source: mergeRelationSources(existing.source, relation.source),
-            columnCompleteness,
-            columns: mergeRelationColumns(existing, relation).slice(0, 120),
+            columnCompleteness: capped.columnCompleteness,
+            columns: capped.columns,
         });
     };
     for (const object of objects) {
@@ -3500,12 +3805,13 @@ function coalesceRelationAliases(relations) {
             continue;
         const target = targets[0];
         const targetKey = normalizeRelationKey(target.relation);
+        const capped = capAllowedSqlColumns(mergeRelationColumns(target, relation), mergeRelationCompletenessForCatalog(target, relation));
         mergedByRelation.set(targetKey, {
             ...target,
             objectKey: target.objectKey ?? relation.objectKey,
             source: mergeRelationSources(target.source, relation.source),
-            columnCompleteness: mergeRelationCompletenessForCatalog(target, relation),
-            columns: mergeRelationColumns(target, relation).slice(0, 120),
+            columnCompleteness: capped.columnCompleteness,
+            columns: capped.columns,
         });
         skipped.add(relationKey);
     }
@@ -4273,10 +4579,39 @@ function safeJson(raw, fallback) {
         return fallback;
     }
 }
+/**
+ * W3.2 — domain-affinity ranking boost for MULTI-DOMAIN catalogs. At scale
+ * (thousands of models across domains), a question about one domain can be crowded
+ * out of the top-k by lexically-similar objects from other domains. This infers the
+ * dominant domain from the highest-scoring candidates and gives same-domain objects
+ * a small additive bonus. It is RECALL-PRESERVING — it only reorders; every
+ * candidate stays in the ranking, and the bonus (10% of the top score) is small
+ * enough that a much stronger cross-domain signal still wins. No-op for single-domain
+ * catalogs (fewer than 2 domains carry positive score).
+ */
+export function applyDomainAffinityBoost(scored) {
+    const domainScore = new Map();
+    for (const item of scored) {
+        const domain = item.row.domain;
+        if (domain && item.score > 0)
+            domainScore.set(domain, (domainScore.get(domain) ?? 0) + item.score);
+    }
+    if (domainScore.size < 2)
+        return undefined;
+    const [dominant] = [...domainScore.entries()].sort((a, b) => b[1] - a[1])[0];
+    const maxScore = Math.max(0, ...scored.map((item) => item.score));
+    const bonus = Number((0.1 * maxScore).toFixed(3));
+    if (bonus <= 0)
+        return undefined;
+    for (const item of scored) {
+        if (item.row.domain === dominant)
+            item.score = Number((item.score + bonus).toFixed(3));
+    }
+    return dominant;
+}
 function rankMetadataObjects(args) {
     const terms = tokenize(args.question).slice(0, 12);
-    const ranked = mergeObjects(args.rows)
-        .map((row) => {
+    const scored = mergeObjects(args.rows).map((row) => {
         const baseScore = scoreMetadataObject(row, terms);
         const planScore = args.questionPlan ? scoreMetadataObjectWithAnalysisPlan(row, args.questionPlan) : { score: 0, reasons: [] };
         const score = Number((baseScore + planScore.score).toFixed(3));
@@ -4287,7 +4622,9 @@ function rankMetadataObjects(args) {
             reason: selectionReason(row, score, planScore.reasons),
             priorityTier: priorityTier(row),
         };
-    })
+    });
+    applyDomainAffinityBoost(scored);
+    const ranked = scored
         .sort((a, b) => b.score - a.score || objectPriority(a.row) - objectPriority(b.row) || a.row.name.localeCompare(b.row.name))
         .map((item, index) => ({ ...item, rank: index + 1 }));
     const selectedRanked = selectRankedMetadataObjects(ranked, args.limit);
@@ -4633,21 +4970,4 @@ function scoreText(value, terms) {
     const lower = value.toLowerCase();
     return terms.reduce((score, term) => score + (lower.includes(term) ? 1 : 0), 0);
 }
-const STOP_WORDS = new Set([
-    'a', 'about', 'after', 'all', 'an', 'and', 'any', 'are', 'as', 'at', 'be', 'by',
-    'can', 'could', 'did', 'do', 'does', 'down', 'for', 'from', 'give', 'had', 'has',
-    'have', 'how', 'i', 'if', 'in', 'into', 'is', 'it', 'me', 'most', 'my', 'of',
-    'on', 'or', 'please', 'query', 'show', 'sql', 'than', 'that', 'the', 'their',
-    'them', 'this', 'to', 'up', 'using', 'was', 'we', 'were', 'what', 'when',
-    'where', 'which', 'who', 'why', 'with', 'would', 'you', 'your',
-]);
-function sanitizeFtsQuery(raw) {
-    return raw
-        .split(/\s+/)
-        .map((term) => term.replace(/[^\p{L}\p{N}_]/gu, ''))
-        .filter((term) => term.length > 1 && !STOP_WORDS.has(term.toLowerCase()))
-        .slice(0, 48)
-        .map((term) => `"${term}"*`)
-        .join(' OR ');
-}
 //# sourceMappingURL=catalog.js.map