@duckcodeailabs/dql-agent 1.6.33 → 1.7.0

package/dist/metadata/catalog.js

@@ -19,6 +19,10 @@ 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';
+import { loadSkills, selectRelevantSkills } from '../skills/loader.js';
 const require = createRequire(import.meta.url);
 let databaseCtor = null;
 function loadDatabase() {
@@ -27,6 +31,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,
@@ -60,7 +97,8 @@ export async function ensureMetadataCatalogFresh(projectRoot, options = {}) {
         ? options.semanticLayer ?? undefined
         : loadAgentSemanticLayer(projectRoot);
     const manifest = options.manifest ?? loadAgentManifest(projectRoot);
-    const snapshot = buildMetadataSnapshot(projectRoot, manifest, semanticLayer);
+    const skills = options.skills ?? loadSkills(projectRoot).skills;
+    const snapshot = buildMetadataSnapshot(projectRoot, manifest, semanticLayer, skills);
     const catalog = openMetadataCatalog(projectRoot);
     try {
         const existing = catalog.state('fingerprint');
@@ -74,7 +112,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,
@@ -106,7 +152,18 @@ export function upsertMetadataSnapshot(projectRoot, snapshot) {
     }
 }
 export async function buildLocalContextPack(projectRoot, request) {
-    await ensureMetadataCatalogFresh(projectRoot);
+    let prepared = false;
+    if (request.preparedMetadataFingerprint) {
+        const catalog = openMetadataCatalog(projectRoot);
+        try {
+            prepared = catalog.state('fingerprint') === request.preparedMetadataFingerprint;
+        }
+        finally {
+            catalog.close();
+        }
+    }
+    if (!prepared)
+        await ensureMetadataCatalogFresh(projectRoot);
     const catalog = openMetadataCatalog(projectRoot);
     try {
         const mode = request.mode ?? 'question';
@@ -119,7 +176,7 @@ export async function buildLocalContextPack(projectRoot, request) {
         // candidates only; a SHIFT ignores it. A metadata fingerprint mismatch
         // always disqualifies reuse.
         const reusePolicy = request.reusePolicy ?? 'seed';
-        const priorPack = reusePolicy !== 'off'
+        const priorPack = !request.domainContext && reusePolicy !== 'off'
             && request.priorContextPackId
             && request.conversationTopicRelation
             && request.conversationTopicRelation !== 'shift'
@@ -167,18 +224,24 @@ export async function buildLocalContextPack(projectRoot, request) {
             buildFollowUpSearchQuery(request.question, followUp),
             ...questionPlan.searchQueries,
         ]);
-        const searchRows = mergeObjects(searchQueries.flatMap((query) => catalog.searchObjects({
+        const scopeObjects = (rows) => filterMetadataObjectsByDomainContext(rows, request.domainContext);
+        // Skill guidance is injected only through selectContextPackSkills below.
+        // Leaving it in generic FTS results would bypass status/domain/area/exclusion
+        // eligibility simply because a word in its body matched the question.
+        const retrievalObjects = (rows) => scopeObjects(rows).filter((row) => row.objectType !== 'skill');
+        const searchRows = retrievalObjects(mergeObjects(searchQueries.flatMap((query) => catalog.searchObjects({
             query,
             objectTypes: request.objectTypes,
             limit: Math.max(request.limit ?? 80, 20),
-        })));
+        }))));
         const schemaShapeCandidates = schemaShapeCandidateObjects(catalog, questionPlan, request, mergeObjects([...runtimeObjects, ...runtimeValueObjects]));
         const schemaShapeObjects = schemaShapeCandidates.map((candidate) => candidate.object);
-        const exact = request.focusObjectKey ? catalog.getObject(request.focusObjectKey) : null;
+        const exactCandidate = request.focusObjectKey ? catalog.getObject(request.focusObjectKey) : null;
+        const exact = exactCandidate && retrievalObjects([exactCandidate]).length > 0 ? exactCandidate : null;
         const ranked = rankMetadataObjects({
-            rows: mergeObjects(exact
+            rows: retrievalObjects(mergeObjects(exact
                 ? [exact, ...followUpSourceObjects, ...followUpObjects, ...searchRows, ...schemaShapeObjects, ...runtimeObjects, ...runtimeValueObjects, ...selectedObjects, ...priorSeedObjects]
-                : [...followUpSourceObjects, ...followUpObjects, ...searchRows, ...schemaShapeObjects, ...runtimeObjects, ...runtimeValueObjects, ...selectedObjects, ...priorSeedObjects]),
+                : [...followUpSourceObjects, ...followUpObjects, ...searchRows, ...schemaShapeObjects, ...runtimeObjects, ...runtimeValueObjects, ...selectedObjects, ...priorSeedObjects])),
             question: searchQueries.join(' '),
             questionPlan,
             limit: request.limit ?? 80,
@@ -192,9 +255,9 @@ export async function buildLocalContextPack(projectRoot, request) {
         const focusObjectKey = request.focusObjectKey ?? selected[0]?.objectKey ?? null;
         const edgeWalk = catalog.edgesForKeys(selected.map((row) => row.objectKey), 3);
         const edgeObjectKeys = Array.from(new Set(edgeWalk.flatMap((edge) => [edge.fromKey, edge.toKey])));
-        const graphObjects = catalog.getObjectsByKeys(edgeObjectKeys);
+        const graphObjects = retrievalObjects(catalog.getObjectsByKeys(edgeObjectKeys));
         const rankedObjects = rankMetadataObjects({
-            rows: mergeObjects([...followUpSourceObjects, ...followUpObjects, ...selected, ...graphObjects, ...schemaShapeObjects, ...runtimeObjects, ...runtimeValueObjects, ...selectedObjects]),
+            rows: retrievalObjects(mergeObjects([...followUpSourceObjects, ...followUpObjects, ...selected, ...graphObjects, ...schemaShapeObjects, ...runtimeObjects, ...runtimeValueObjects, ...selectedObjects])),
             question: searchQueries.join(' '),
             questionPlan,
             limit: request.limit ?? 120,
@@ -204,24 +267,30 @@ export async function buildLocalContextPack(projectRoot, request) {
         // entire relation set ("send everything, let the agent decide"). Only when the
         // whole catalog fits comfortably in context — otherwise we keep ranked selection.
         const fullCatalogObjects = request.strictness === 'exploratory'
-            ? collectFullCatalogObjects(catalog)
+            ? retrievalObjects(collectFullCatalogObjects(catalog) ?? [])
             : undefined;
         const usedFullCatalog = Boolean(fullCatalogObjects);
+        // Skills are selected from the catalog snapshot with the same hard domain,
+        // area, status, and exclusion gates as the loader. They are not left to FTS
+        // chance or re-read from disk after the snapshot has been fingerprinted.
+        const selectedSkills = selectContextPackSkills(catalog.listObjects({ objectTypes: ['skill'], limit: 500 }), request.question, request.domainContext);
+        const selectedSkillObjects = selectedSkills.map((item) => item.object);
         const objects = fullCatalogObjects
-            ? mergeObjects([...rankedObjects, ...sqlParentObjects, ...fullCatalogObjects])
-            : mergeObjects([...rankedObjects, ...sqlParentObjects]);
+            ? mergeObjects([...rankedObjects, ...sqlParentObjects, ...fullCatalogObjects, ...selectedSkillObjects])
+            : mergeObjects([...rankedObjects, ...sqlParentObjects, ...selectedSkillObjects]);
         const objectKeys = objects.map((row) => row.objectKey);
+        const allowedObjectKeys = new Set(objectKeys);
         const contextEdges = mergeMetadataEdges([
             ...edgeWalk,
             ...catalog.edgesForKeys(objectKeys, 2),
-        ]);
+        ]).filter((edge) => allowedObjectKeys.has(edge.fromKey) && allowedObjectKeys.has(edge.toKey));
         const queryRuns = catalog.queryRunsForObjectKeys(objectKeys, 20);
         const diagnostics = catalog.diagnostics();
         const warnings = buildWarnings(diagnostics, objects);
         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 {
@@ -237,7 +306,7 @@ export async function buildLocalContextPack(projectRoot, request) {
         const selectedJoinPaths = buildSelectedJoinPaths(allowedSqlContext, contextEdges);
         const evidenceRoles = buildEvidenceRoles(objects, queryRuns);
         const reranked = rankMetadataObjects({
-            rows: mergeObjects([...searchRows, ...schemaShapeObjects, ...objects]),
+            rows: retrievalObjects(mergeObjects([...searchRows, ...schemaShapeObjects, ...objects])),
             question: searchQueries.join(' '),
             questionPlan,
             limit: request.limit ?? 120,
@@ -279,6 +348,7 @@ export async function buildLocalContextPack(projectRoot, request) {
             trustLabel,
             trustLabelInfo: metadataTrustLabelInfo(trustLabel),
             objects,
+            skills: selectedSkills.map((item) => item.skill),
             edges: contextEdges,
             queryRuns,
             citations,
@@ -362,7 +432,17 @@ export function recordRuntimeSchemaSnapshot(projectRoot, snapshot) {
         catalog.close();
     }
 }
-export function buildMetadataSnapshot(projectRoot, manifest, semanticLayer) {
+/** 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, skills = loadSkills(projectRoot).skills) {
     const manifestGraph = buildKGFromManifest(manifest);
     const semanticGraph = buildKGFromSemanticLayer(semanticLayer);
     const objects = new Map();
@@ -387,11 +467,16 @@ export function buildMetadataSnapshot(projectRoot, manifest, semanticLayer) {
         }
     }
     addManifestBlockDetails(manifest, objects);
+    addSkillObjects(skills, objects, edges);
     addDbtDagObjects(manifest, objects, edges, diagnostics);
     addRawDbtManifestCatalogObjects(projectRoot, manifest, objects, edges, diagnostics);
     addBlockDependencyEdges(manifest, edges);
     addBlockOutputLineageObjects(manifest, objects, edges);
-    addDataLexManifestObjects(projectRoot, manifest, objects, edges, diagnostics);
+    // Manifest v3 is the unified DQL runtime. DataLex is migration input only;
+    // retaining it here would reintroduce a second analytical source of truth.
+    if (manifest.manifestVersion !== 3) {
+        addDataLexManifestObjects(projectRoot, manifest, objects, edges, diagnostics);
+    }
     const nodeKeyMap = new Map();
     for (const node of [...manifestGraph.nodes, ...semanticGraph.nodes]) {
         nodeKeyMap.set(node.nodeId, objectKeyFromKGNode(node));
@@ -643,23 +728,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 +860,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 +1039,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 +1061,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(`
@@ -1028,6 +1238,7 @@ function objectFromKGNode(node) {
         dimensions: node.dimensions ?? [],
         allowedFilters: node.allowedFilters ?? [],
         parameterPolicy: node.parameterPolicy ?? [],
+        parameters: node.parameters ?? [],
         filterBindings: node.filterBindings ?? [],
         sourceSystems: node.sourceSystems ?? [],
         replacementFor: node.replacementFor ?? [],
@@ -1107,6 +1318,71 @@ function normalizeEdge(edge, fromKey, toKey) {
         payload: { kgSource: edge.src, kgTarget: edge.dst },
     };
 }
+/**
+ * Skills are source-owned context, not a prompt-only side channel. Persist their
+ * parsed fields in the catalog snapshot so selection, provenance, and
+ * fingerprinting all observe the same immutable project state.
+ */
+function addSkillObjects(skills, objects, edges) {
+    for (const skill of skills) {
+        const identity = skill.qualifiedId ?? skill.id;
+        const objectKey = `skill:${identity}`;
+        const domains = uniqueNonBlank([skill.domain, ...(skill.domains ?? [])]);
+        const object = {
+            objectKey,
+            objectType: 'skill',
+            name: skill.id,
+            fullName: skill.qualifiedId ?? skill.id,
+            domain: skill.domain,
+            owner: skill.owner,
+            status: skill.status ?? 'active',
+            description: skill.description ?? compactSkillDescription(skill.body),
+            sourcePath: skill.sourcePath,
+            sourceSystem: 'DQL domain skill',
+            payload: compactObject({
+                skillId: skill.id,
+                localId: skill.localId ?? skill.id,
+                qualifiedId: skill.qualifiedId,
+                scope: skill.scope,
+                user: skill.user,
+                domains,
+                modelAreaRefs: skill.modelAreaRefs ?? [],
+                kind: skill.kind,
+                triggers: skill.triggers ?? [],
+                exclusions: skill.exclusions ?? [],
+                preferredMetrics: skill.preferredMetrics,
+                preferredBlocks: skill.preferredBlocks,
+                preferredDimensions: skill.preferredDimensions ?? [],
+                requiredFilters: skill.requiredFilters ?? [],
+                clarifyWhen: skill.clarifyWhen ?? [],
+                examples: skill.examples ?? [],
+                sourceRefs: skill.sourceRefs ?? [],
+                vocabulary: skill.vocabulary,
+                body: skill.body,
+                isStarter: skill.isStarter,
+                provenance: 'DQL domain skill',
+            }),
+        };
+        objects.set(objectKey, object);
+        for (const domain of domains) {
+            const edge = {
+                edgeType: 'contains',
+                fromKey: `domain:${domain}`,
+                toKey: objectKey,
+                confidence: 1,
+                payload: { provenance: 'DQL domain skill' },
+            };
+            edges.set(`${edge.edgeType}\u0000${edge.fromKey}\u0000${edge.toKey}`, edge);
+        }
+    }
+}
+function compactSkillDescription(body) {
+    const normalized = body.replace(/\s+/g, ' ').trim();
+    return normalized ? normalized.slice(0, 480) : undefined;
+}
+function uniqueNonBlank(values) {
+    return Array.from(new Set(values.map((value) => value?.trim()).filter((value) => Boolean(value))));
+}
 function addDbtDagObjects(manifest, objects, edges, diagnostics) {
     const models = manifest.dbtImport?.dbtDag?.models ?? [];
     for (const model of models) {
@@ -1197,7 +1473,20 @@ function addRawDbtManifestCatalogObjects(projectRoot, manifest, objects, edges,
         return;
     }
     const catalogColumns = loadRawDbtCatalogColumns(join(dirname(manifestPath), 'catalog.json'));
+    const uniqueColumnsByModel = extractDbtUniqueColumns(raw.nodes ?? {});
     const entries = [];
+    // PERF-001: at enterprise scale, keep columns in their model payload and
+    // load full node detail lazily from the immutable dbt artifact cache. A
+    // separate FTS row + graph edge for every column makes a 300k-column project
+    // consume gigabytes without improving the bounded model-first route.
+    const rawEntries = [...Object.values(raw.nodes ?? {}), ...Object.values(raw.sources ?? {})];
+    const totalColumnCount = rawEntries.reduce((sum, node) => {
+        const columns = node.columns;
+        return sum + (columns && typeof columns === 'object' && !Array.isArray(columns)
+            ? Object.keys(columns).length
+            : 0);
+    }, 0);
+    const includeColumnObjects = totalColumnCount <= 50_000;
     for (const [uniqueId, node] of Object.entries(raw.nodes ?? {})) {
         if (node.resource_type !== 'model')
             continue;
@@ -1216,12 +1505,14 @@ function addRawDbtManifestCatalogObjects(projectRoot, manifest, objects, edges,
             database,
             schema,
             catalogColumns: catalogColumns.get(uniqueId),
+            uniqueColumns: uniqueColumnsByModel.get(name),
         };
         entries.push(entry);
         addRawDbtCatalogObject({
             ...entry,
             objects,
             edges,
+            includeColumnObjects,
         });
     }
     for (const [uniqueId, source] of Object.entries(raw.sources ?? {})) {
@@ -1246,6 +1537,7 @@ function addRawDbtManifestCatalogObjects(projectRoot, manifest, objects, edges,
             ...entry,
             objects,
             edges,
+            includeColumnObjects,
         });
     }
     const relationLookup = buildRawDbtRelationLookup(entries);
@@ -1285,38 +1577,41 @@ 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) {
-        const columnKey = `dbt:column:${input.name}.${column.name}`;
-        const existingColumn = input.objects.get(columnKey);
-        input.objects.set(columnKey, mergeObject(existingColumn, {
-            objectKey: columnKey,
-            objectType: 'dbt_column',
-            name: column.name,
-            fullName: `${input.name}.${column.name}`,
-            description: column.description,
-            status: existingColumn?.status ?? 'dbt_catalog',
-            sourcePath: stringValue(input.node.original_file_path) ?? stringValue(input.node.path),
-            sourceSystem: existingColumn?.sourceSystem ?? 'dbt manifest.json catalog',
-            payload: compactObject({
-                ...(existingColumn?.payload ?? {}),
-                model: input.name,
-                uniqueId: input.uniqueId,
-                type: column.type,
-                relation,
-                columnCompleteness: 'partial',
-                catalogOnly: existingColumn ? undefined : true,
-            }),
-        }));
-        putEdge(input.edges, {
-            edgeType: 'contains',
-            fromKey: input.objectKey,
-            toKey: columnKey,
-            confidence: 1,
-            payload: { source: 'raw dbt manifest column catalog' },
-        });
-    }
+    if (input.includeColumnObjects)
+        for (const column of columns) {
+            const columnKey = `dbt:column:${input.name}.${column.name}`;
+            const existingColumn = input.objects.get(columnKey);
+            input.objects.set(columnKey, mergeObject(existingColumn, {
+                objectKey: columnKey,
+                objectType: 'dbt_column',
+                name: column.name,
+                fullName: `${input.name}.${column.name}`,
+                description: column.description,
+                status: existingColumn?.status ?? 'dbt_catalog',
+                sourcePath: stringValue(input.node.original_file_path) ?? stringValue(input.node.path),
+                sourceSystem: existingColumn?.sourceSystem ?? 'dbt manifest.json catalog',
+                payload: compactObject({
+                    ...(existingColumn?.payload ?? {}),
+                    model: input.name,
+                    uniqueId: input.uniqueId,
+                    type: column.type,
+                    relation,
+                    columnCompleteness: 'partial',
+                    catalogOnly: existingColumn ? undefined : true,
+                }),
+            }));
+            putEdge(input.edges, {
+                edgeType: 'contains',
+                fromKey: input.objectKey,
+                toKey: columnKey,
+                confidence: 1,
+                payload: { source: 'raw dbt manifest column catalog' },
+            });
+        }
     for (const dep of rawDbtDependsOn(input.node)) {
         putEdge(input.edges, {
             edgeType: 'depends_on',
@@ -1537,6 +1832,7 @@ function addManifestBlockDetails(manifest, objects) {
                 blockType: block.blockType,
                 tests: block.tests,
                 parameterPolicy: block.parameterPolicy,
+                parameters: block.parameters,
                 filterBindings: block.filterBindings,
                 sqlFingerprints: buildBlockSqlFingerprints(block.sql),
                 businessFingerprint: buildBlockBusinessFingerprint({
@@ -1659,6 +1955,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 +2044,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 +2408,62 @@ 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
+    // Analytical questions intentionally keep certified applicability conservative:
+    // a lexical/content match alone must not terminate the cascade. A certified
+    // block whose declared/inferred output contract fully covers the requested
+    // answer shape is different, however — that is a proven Tier 1 answer even
+    // when the planner also knows how to generate SQL. Promote only exact/trim-safe
+    // contract fits here; near matches remain context for Tier 2.
+    const exactByContract = input.objects
+        .filter((object) => object.objectType === 'dql_block'
+        && isCertifiedMetadataObject(object)
+        && hasCompatibleMetadataRankingDirection(input.request.question, object))
+        .map((object) => ({
+        object,
+        fit: evaluateCertifiedBlockFit({
+            question: input.request.question,
+            plan: input.questionPlan,
+            block: object,
+            exactExampleMatch: hasExactExampleQuestion(input.request.question, object),
+            definitionLookup: intent === 'definition_lookup',
+        }),
+        applicabilityScore: applicabilityByKey.get(object.objectKey)?.score ?? 0,
+    }))
+        .filter(({ fit }) => (fit.kind === 'exact' || fit.kind === 'trim_safe')
+        && (fit.confidence === 'high' || fit.confidence === 'medium'))
+        .sort((a, b) => (b.fit.confidence === 'high' ? 1 : 0) - (a.fit.confidence === 'high' ? 1 : 0)
+        || b.applicabilityScore - a.applicabilityScore)[0]?.object;
+    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;
+        : findExactCertifiedObject(input.request.question, intent, input.objects) ?? exactByContract;
     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;
+        }
+    }
+    // Keep the strongest context-only certified candidate attached to the route
+    // so the contract and grain gates can explain exactly why it is demoted.
+    // This does not promote a loose match: both gates still have to pass before
+    // Tier 1 is possible.
+    if (!exact && contextApplicability) {
+        exact = input.objects.find((object) => object.objectKey === contextApplicability.objectKey);
+    }
+    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 +2526,8 @@ async function planContextPackRoute(input) {
         || intent === 'exact_certified_lookup'
         || intent === 'definition_lookup'
         || exactExampleMatch
+        || paraphraseExampleMatch
+        || (blockFit && certifiedFitAllowsTier1(blockFit) && hasCompatibleMetadataRankingDirection(input.request.question, exact))
         || (intent === 'ad_hoc_ranking' && objectNameInQuestion(input.request.question, exact)))) {
         return {
             route: 'certified',
@@ -2152,7 +2553,7 @@ async function planContextPackRoute(input) {
             route: 'generated_sql',
             intent: isGeneratedMetadataIntent(intent) ? intent : 'ad_hoc_ranking',
             reason: `Certified block "${exact.name}" is close but answers a different grain than the question, so it is context only and SQL is generated for the requested grain.`,
-            routeReason: grainGate.reason,
+            routeReason: `${grainGate.reason}; routed to Tier 2 generated SQL`,
             grainGate: grainGateInfo,
             blockFit,
             trustLabel: input.trustLabel === 'certified' ? 'mixed' : input.trustLabel,
@@ -2170,7 +2571,7 @@ async function planContextPackRoute(input) {
             route: 'generated_sql',
             intent: isGeneratedMetadataIntent(intent) ? intent : 'ad_hoc_ranking',
             reason: `Certified block "${exact.name}" is relevant but does not satisfy the requested answer shape, so it is context only and SQL is generated for the requested result.`,
-            routeReason: blockFit.reasons.join('; '),
+            routeReason: `${blockFit.reasons.join('; ')}; routed to Tier 2 generated SQL`,
             grainGate: grainGateInfo,
             blockFit,
             trustLabel: input.trustLabel === 'certified' ? 'mixed' : input.trustLabel,
@@ -2523,7 +2924,8 @@ function hasCompatibleMetadataRankingDirection(question, object) {
     const objectDirection = rankingDirection([
         object.name,
         object.description ?? '',
-        JSON.stringify(object.payload ?? {}),
+        Array.isArray(object.payload?.tags) ? object.payload.tags.join(' ') : '',
+        typeof object.payload?.sql === 'string' ? object.payload.sql : '',
     ].join(' '));
     if (!objectDirection)
         return true;
@@ -3006,6 +3408,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 +3483,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 +3492,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 +3952,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 +4726,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 +4769,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);
@@ -4419,6 +4903,121 @@ function reasonForObject(row) {
         return 'Published consumption context';
     return 'Relevant project metadata';
 }
+function filterMetadataObjectsByDomainContext(rows, context) {
+    if (!context?.activeDomain)
+        return rows;
+    const domains = new Set([
+        context.activeDomain,
+        ...context.ancestors,
+        ...context.allowedImports.map((item) => item.providerDomain),
+    ]);
+    return rows.filter((row) => !row.domain || domains.has(row.domain));
+}
+function selectContextPackSkills(objects, question, context) {
+    const byIdentity = new Map();
+    const parsed = objects.flatMap((object) => {
+        const skill = skillFromMetadataObject(object);
+        if (!skill)
+            return [];
+        const identity = skill.qualifiedId ?? skill.id;
+        byIdentity.set(identity, object);
+        return [skill];
+    });
+    const domains = context?.activeDomain
+        ? [context.activeDomain, ...context.ancestors, ...context.allowedImports.map((item) => item.providerDomain)]
+        : [];
+    const selected = selectRelevantSkills(parsed, question, {
+        domains,
+        modelAreaIds: context?.modelAreaId ? [context.modelAreaId] : [],
+    });
+    return selected.flatMap((skill) => {
+        const object = byIdentity.get(skill.qualifiedId ?? skill.id);
+        return object ? [{ object, skill: localContextSkillFromParsed(skill, object) }] : [];
+    });
+}
+function skillFromMetadataObject(object) {
+    if (object.objectType !== 'skill')
+        return null;
+    const payload = object.payload ?? {};
+    const scope = payload.scope === 'personal' ? 'personal' : 'project';
+    const status = payload.status === 'draft' || payload.status === 'deprecated' || payload.status === 'active'
+        ? payload.status
+        : object.status === 'draft' || object.status === 'deprecated' || object.status === 'active'
+            ? object.status
+            : 'active';
+    return {
+        id: stringPayload(payload.skillId) ?? object.name,
+        localId: stringPayload(payload.localId) ?? object.name,
+        qualifiedId: stringPayload(payload.qualifiedId) ?? object.fullName,
+        scope,
+        user: stringPayload(payload.user),
+        domain: object.domain,
+        domains: stringArrayPayload(payload.domains),
+        modelAreaRefs: stringArrayPayload(payload.modelAreaRefs),
+        kind: skillKindPayload(payload.kind),
+        status,
+        owner: object.owner,
+        triggers: stringArrayPayload(payload.triggers),
+        exclusions: stringArrayPayload(payload.exclusions),
+        description: object.description,
+        preferredMetrics: stringArrayPayload(payload.preferredMetrics),
+        preferredBlocks: stringArrayPayload(payload.preferredBlocks),
+        preferredDimensions: stringArrayPayload(payload.preferredDimensions),
+        requiredFilters: stringArrayPayload(payload.requiredFilters),
+        clarifyWhen: stringArrayPayload(payload.clarifyWhen),
+        examples: stringArrayPayload(payload.examples),
+        sourceRefs: stringArrayPayload(payload.sourceRefs),
+        vocabulary: stringRecordPayload(payload.vocabulary),
+        body: stringPayload(payload.body) ?? '',
+        sourcePath: object.sourcePath ?? '',
+        isStarter: payload.isStarter === true,
+    };
+}
+function localContextSkillFromParsed(skill, object) {
+    const guidance = skill.body.slice(0, 4_000);
+    return {
+        objectKey: object.objectKey,
+        id: skill.id,
+        qualifiedId: skill.qualifiedId,
+        domain: skill.domain,
+        domains: [...(skill.domains ?? [])],
+        modelAreaRefs: [...(skill.modelAreaRefs ?? [])],
+        kind: skill.kind,
+        status: skill.status,
+        owner: skill.owner,
+        description: skill.description,
+        triggers: [...(skill.triggers ?? [])],
+        exclusions: [...(skill.exclusions ?? [])],
+        preferredMetrics: [...skill.preferredMetrics],
+        preferredBlocks: [...skill.preferredBlocks],
+        preferredDimensions: [...(skill.preferredDimensions ?? [])],
+        requiredFilters: [...(skill.requiredFilters ?? [])],
+        clarifyWhen: [...(skill.clarifyWhen ?? [])],
+        vocabulary: { ...skill.vocabulary },
+        guidance,
+        guidanceTruncated: guidance.length < skill.body.length,
+        sourceRefs: [...(skill.sourceRefs ?? [])],
+        provenance: stringPayload(object.payload?.provenance) ?? object.sourceSystem ?? 'DQL domain skill',
+        sourcePath: object.sourcePath,
+    };
+}
+function stringPayload(value) {
+    return typeof value === 'string' && value.trim() ? value : undefined;
+}
+function stringArrayPayload(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string' && Boolean(item.trim())) : [];
+}
+function stringRecordPayload(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === 'string'));
+}
+function skillKindPayload(value) {
+    return value === 'domain_reference' || value === 'metric_policy' || value === 'glossary'
+        || value === 'analysis_pattern' || value === 'sql_policy' || value === 'custom'
+        ? value
+        : undefined;
+}
 function mergeObjects(rows) {
     const byKey = new Map();
     for (const row of rows) {
@@ -4633,21 +5232,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