@duckcodeailabs/dql-agent 1.7.1 → 1.8.0

package/dist/metadata/catalog.js

@@ -7,22 +7,24 @@
  * context pack before answering.
  */
 import { createHash } from 'node:crypto';
-import { mkdirSync, readFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { dirname, join } from 'node:path';
-import { buildManifest, loadProjectConfig, parseContractRef, resolveDataLexManifestPath, resolveDbtManifestPath, resolveSemanticLayerWithDiagnostics, extractColumnLineage, normalizeDqlArtifactReference, composeEffectiveTrust, } from '@duckcodeailabs/dql-core';
+import { brotliCompressSync, brotliDecompressSync, constants as zlibConstants } from 'node:zlib';
+import { buildManifest, buildManifestKnowledgeGraph, loadDomainPackageRegistry, loadManifestKnowledgeSkills, loadProjectConfig, parseContractRef, resolveDataLexManifestPath, resolveDbtManifestPath, resolveSemanticLayerWithDiagnostics, extractColumnLineage, normalizeDqlArtifactReference, composeEffectiveTrust, } from '@duckcodeailabs/dql-core';
 import { buildKGFromManifest, buildKGFromSemanticLayer } from '../kg/build.js';
 import { buildBlockBusinessFingerprint, buildBlockSqlFingerprints } from './block-fingerprints.js';
 import { buildAnalysisQuestionPlan, certifiedApplicabilityForObject, scoreAllowedSqlRelationWithAnalysisPlan, scoreMetadataObjectWithAnalysisPlan, sortAllowedSqlContextForAnalysisPlan, } from './analysis-planner.js';
 import { extractSimpleSelectShape, sourceSqlShapeColumns } from './sql-shape.js';
-import { buildRuntimeValueIndex, normalizeValueIndexText, } from '../grounding/value-index.js';
 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 { buildFtsMatch } from '../memory/fts-query.js';
 import { envEmbeddingProvider } from '../embeddings/provider.js';
 import { matchExampleParaphrase } from './example-match.js';
 import { loadSkills, selectRelevantSkills } from '../skills/loader.js';
+import { buildMeaningEvidencePackage, } from './meaning-evidence.js';
+export { toAgentRetrievalEvidence } from './meaning-evidence.js';
 const require = createRequire(import.meta.url);
 let databaseCtor = null;
 function loadDatabase() {
@@ -73,6 +75,10 @@ const OBJECT_PRIORITY = {
     semantic_dimension: 5,
     semantic_measure: 6,
     semantic_entity: 7,
+    dql_entity: 7,
+    relationship: 7.2,
+    contract: 7.4,
+    model_area: 7.6,
     semantic_model: 8,
     dbt_model: 9,
     dbt_source: 10,
@@ -86,12 +92,143 @@ const OBJECT_PRIORITY = {
     domain: 16,
 };
 const COLUMN_OBJECT_TYPES = new Set(['dbt_column', 'warehouse_column', 'runtime_column', 'runtime_value']);
+// v3 removes the legacy persisted plaintext runtime-value cache (SEC-003).
+const METADATA_INDEX_VERSION = 'metadata-index-v4-content-addressed-skills';
 export function defaultMetadataPath(projectRoot) {
     return join(projectRoot, '.dql', 'cache', 'metadata.sqlite');
 }
+export function metadataSnapshotPath(projectRoot, fingerprint) {
+    return join(projectRoot, '.dql', 'cache', 'snapshots', `${fingerprint}.sqlite`);
+}
+export function activeMetadataSnapshotPath(projectRoot) {
+    const pointerPath = join(projectRoot, '.dql', 'cache', 'active-snapshot.json');
+    if (!existsSync(pointerPath))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(pointerPath, 'utf8'));
+        const path = typeof parsed.snapshotPath === 'string' ? parsed.snapshotPath : '';
+        return path && existsSync(path) ? path : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Read the prepared catalog identity without rebuilding the metadata snapshot. */
+export function currentMetadataFingerprint(projectRoot) {
+    if (!existsSync(defaultMetadataPath(projectRoot)))
+        return undefined;
+    const catalog = openMetadataCatalog(projectRoot);
+    try {
+        return catalog.state('fingerprint') ?? undefined;
+    }
+    finally {
+        catalog.close();
+    }
+}
+function activateMetadataSnapshot(projectRoot, fingerprint, catalog) {
+    const snapshotPath = metadataSnapshotPath(projectRoot, fingerprint);
+    catalog.exportSnapshot(snapshotPath);
+    const cacheDir = join(projectRoot, '.dql', 'cache');
+    const pointerPath = join(cacheDir, 'active-snapshot.json');
+    const candidate = `${pointerPath}.candidate`;
+    mkdirSync(cacheDir, { recursive: true });
+    writeFileSync(candidate, JSON.stringify({
+        snapshotId: fingerprint,
+        indexSchemaVersion: METADATA_INDEX_VERSION,
+        snapshotPath,
+    }, null, 2), 'utf8');
+    renameSync(candidate, pointerPath);
+    // Do not delete older immutable files here: a request that acquired the old
+    // pointer may still hold it open. Cache cleanup is an explicit maintenance
+    // concern until the snapshot service owns reference-counted leases.
+    return snapshotPath;
+}
 export function openMetadataCatalog(projectRoot, dbPath = defaultMetadataPath(projectRoot)) {
     return new MetadataCatalog(dbPath);
 }
+export function openActiveKnowledgeSnapshot(projectRoot) {
+    const path = activeMetadataSnapshotPath(projectRoot) ?? defaultMetadataPath(projectRoot);
+    return new MetadataCatalog(path, { readOnly: path !== defaultMetadataPath(projectRoot) });
+}
+export function readIndexedDomainKnowledge(projectRoot, domainId) {
+    const catalog = openActiveKnowledgeSnapshot(projectRoot);
+    try {
+        const snapshotId = catalog.state('fingerprint') ?? 'metadata-unavailable';
+        const capsuleObject = catalog.listAllObjects({ objectTypes: ['domain_capsule'], domain: domainId })
+            .find((item) => !stringValue(item.payload?.modelAreaId));
+        const capsule = capsuleObject?.payload;
+        if (!capsule)
+            return null;
+        const rows = catalog.listAllObjects({ domain: domainId })
+            .filter((item) => item.objectType !== 'domain_capsule' && item.objectType !== 'cross_domain_route');
+        const selectedRows = rows.slice(0, 750);
+        const byKey = new Map(selectedRows.map((row) => [row.objectKey, metadataObjectToKnowledge(row)]));
+        const edgeRows = catalog.edgesForKeys(selectedRows.map((row) => row.objectKey), 1).slice(0, 1_500);
+        for (const edge of edgeRows) {
+            if (!byKey.has(edge.fromKey)) {
+                const item = catalog.getObject(edge.fromKey);
+                if (item)
+                    byKey.set(edge.fromKey, metadataObjectToKnowledge(item));
+            }
+            if (!byKey.has(edge.toKey)) {
+                const item = catalog.getObject(edge.toKey);
+                if (item)
+                    byKey.set(edge.toKey, metadataObjectToKnowledge(item));
+            }
+        }
+        const routes = catalog.listAllObjects({ objectTypes: ['cross_domain_route'] })
+            .flatMap((item) => metadataRoute(item) ? [metadataRoute(item)] : [])
+            .filter((route) => route.providerDomainId === domainId || route.consumerDomainId === domainId);
+        const routeStates = routes.reduce((counts, route) => {
+            counts[route.state] = (counts[route.state] ?? 0) + 1;
+            return counts;
+        }, {});
+        return {
+            schemaVersion: 2,
+            snapshotId,
+            sourceFingerprint: stringValue(capsuleObject?.payload?.sourceFingerprint) ?? snapshotId,
+            domainId,
+            capsule,
+            counts: { objects: rows.length, edges: edgeRows.length, routes: routes.length, routeStates },
+            objects: selectedRows.map(metadataObjectToKnowledge),
+            edges: edgeRows.map((edge) => metadataEdgeToKnowledge(edge, byKey)),
+            routes,
+            truncated: rows.length > selectedRows.length || edgeRows.length >= 1_500,
+        };
+    }
+    finally {
+        catalog.close();
+    }
+}
+export function readIndexedKnowledge360(projectRoot, identity) {
+    const catalog = openActiveKnowledgeSnapshot(projectRoot);
+    try {
+        const focusRow = catalog.findObjectByIdentity(identity);
+        if (!focusRow)
+            return null;
+        const edgeRows = catalog.edgesForKeys([focusRow.objectKey], 2).slice(0, 500);
+        const keys = [...new Set([focusRow.objectKey, ...edgeRows.flatMap((edge) => [edge.fromKey, edge.toKey])])].slice(0, 160);
+        const rows = catalog.getObjectsByKeys(keys);
+        const byKey = new Map(rows.map((row) => [row.objectKey, metadataObjectToKnowledge(row)]));
+        const objects = rows.map(metadataObjectToKnowledge);
+        const domains = new Set(objects.flatMap((item) => item.domainId ? [item.domainId] : []));
+        const routes = catalog.listAllObjects({ objectTypes: ['cross_domain_route'] })
+            .flatMap((item) => metadataRoute(item) ? [metadataRoute(item)] : [])
+            .filter((route) => domains.has(route.providerDomainId) && domains.has(route.consumerDomainId));
+        return {
+            snapshotId: catalog.state('fingerprint') ?? 'metadata-unavailable',
+            sourceFingerprint: catalog.state('fingerprint') ?? 'metadata-unavailable',
+            focus: metadataObjectToKnowledge(focusRow),
+            objects,
+            edges: edgeRows.filter((edge) => byKey.has(edge.fromKey) && byKey.has(edge.toKey)).map((edge) => metadataEdgeToKnowledge(edge, byKey)),
+            routes,
+            truncated: keys.length >= 160 || edgeRows.length >= 500,
+        };
+    }
+    finally {
+        catalog.close();
+    }
+}
 export async function ensureMetadataCatalogFresh(projectRoot, options = {}) {
     const semanticLayer = options.semanticLayer !== undefined
         ? options.semanticLayer ?? undefined
@@ -102,9 +239,12 @@ export async function ensureMetadataCatalogFresh(projectRoot, options = {}) {
     const catalog = openMetadataCatalog(projectRoot);
     try {
         const existing = catalog.state('fingerprint');
-        if (!options.force && existing === snapshot.fingerprint) {
+        const compatibleIndex = catalog.state('index_version') === METADATA_INDEX_VERSION;
+        if (!options.force && compatibleIndex && existing === snapshot.fingerprint) {
+            const snapshotPath = activateMetadataSnapshot(projectRoot, snapshot.fingerprint, catalog);
             return {
                 path: defaultMetadataPath(projectRoot),
+                snapshotPath,
                 refreshed: false,
                 objectCount: catalog.objectCount(),
                 edgeCount: catalog.edgeCount(),
@@ -115,14 +255,16 @@ export async function ensureMetadataCatalogFresh(projectRoot, options = {}) {
         // 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) {
+        if (options.force || !compatibleIndex) {
             catalog.rebuild(snapshot);
         }
         else {
             catalog.rebuildIncremental(snapshot);
         }
+        const snapshotPath = activateMetadataSnapshot(projectRoot, snapshot.fingerprint, catalog);
         return {
             path: defaultMetadataPath(projectRoot),
+            snapshotPath,
             refreshed: true,
             objectCount: snapshot.objects.length,
             edgeCount: snapshot.edges.length,
@@ -138,8 +280,10 @@ export function upsertMetadataSnapshot(projectRoot, snapshot) {
     const catalog = openMetadataCatalog(projectRoot);
     try {
         catalog.rebuild(snapshot);
+        const snapshotPath = activateMetadataSnapshot(projectRoot, snapshot.fingerprint, catalog);
         return {
             path: defaultMetadataPath(projectRoot),
+            snapshotPath,
             refreshed: true,
             objectCount: snapshot.objects.length,
             edgeCount: snapshot.edges.length,
@@ -164,7 +308,12 @@ export async function buildLocalContextPack(projectRoot, request) {
     }
     if (!prepared)
         await ensureMetadataCatalogFresh(projectRoot);
-    const catalog = openMetadataCatalog(projectRoot);
+    // Static governed knowledge is read from the immutable content-addressed
+    // snapshot selected at request start. Mutable run history, runtime schema,
+    // and context packs stay in the working catalog and never alter that view.
+    const snapshotPath = activeMetadataSnapshotPath(projectRoot) ?? defaultMetadataPath(projectRoot);
+    const catalog = openActiveKnowledgeSnapshot(projectRoot);
+    const runtimeCatalog = openMetadataCatalog(projectRoot);
     try {
         const mode = request.mode ?? 'question';
         const followUp = normalizeFollowUpContext(request.followUp);
@@ -180,7 +329,7 @@ export async function buildLocalContextPack(projectRoot, request) {
             && request.priorContextPackId
             && request.conversationTopicRelation
             && request.conversationTopicRelation !== 'shift'
-            ? catalog.getContextPack(request.priorContextPackId)
+            ? runtimeCatalog.getContextPack(request.priorContextPackId)
             : null;
         const priorPackFresh = Boolean(priorPack && priorPack.freshness.fingerprint === catalog.state('fingerprint'));
         if (priorPack
@@ -199,13 +348,13 @@ export async function buildLocalContextPack(projectRoot, request) {
                     strategy: 'reused_pack_refinement',
                 },
                 freshness: {
-                    catalogPath: defaultMetadataPath(projectRoot),
+                    catalogPath: snapshotPath,
                     builtAt: catalog.state('built_at'),
                     fingerprint: catalog.state('fingerprint'),
                 },
             };
             delete reusedPayload.id;
-            const reusedId = catalog.insertContextPack(reusedPayload);
+            const reusedId = runtimeCatalog.insertContextPack(reusedPayload);
             return { ...reusedPayload, id: reusedId };
         }
         const priorSeedObjects = priorPack && priorPackFresh
@@ -214,17 +363,23 @@ export async function buildLocalContextPack(projectRoot, request) {
                 || request.conversationTopicRelation === 'return')
             ? priorPack.objects.slice(0, 24)
             : [];
-        const runtimeSnapshot = request.runtimeSchemaSnapshot ?? catalog.latestRuntimeSchemaSnapshot();
-        const runtimeObjects = runtimeSnapshot ? runtimeSchemaObjects(runtimeSnapshot) : [];
-        const runtimeValueObjects = runtimeValueMatchObjects(catalog.searchRuntimeValues(metadataValueSearchTerms(request.question, questionPlan, followUp), 32));
-        const selectedObjects = selectedContextObjects(request.selectedContext);
-        const followUpObjects = followUpContextObjects(followUp);
-        const followUpSourceObjects = catalog.getObjectsByKeys(followUpSourceObjectKeys(followUp));
         const searchQueries = uniqueMetadataSearchQueries([
             buildFollowUpSearchQuery(request.question, followUp),
             ...questionPlan.searchQueries,
         ]);
-        const areaObjects = filterMetadataObjectsByDomainContext(catalog.listObjects({ objectTypes: ['model_area'], limit: 500 }), request.domainContext);
+        // Runtime database schemas live in a separate persisted FTS lane. Normal Ask
+        // requests hydrate only relevant tables, so thousands of tables and hundreds
+        // of thousands of columns never become a request-path full-catalog scan.
+        // Explicit snapshots remain supported for callers that already hold a small,
+        // question-scoped schema payload.
+        const runtimeObjects = request.runtimeSchemaSnapshot
+            ? runtimeSchemaObjects(request.runtimeSchemaSnapshot)
+            : runtimeCatalog.searchRuntimeSchemaObjects(searchQueries.join(' '), Math.max(request.limit ?? 80, 20));
+        const runtimeValueObjects = runtimeValueMatchObjects(runtimeCatalog.searchRuntimeValues(metadataValueSearchTerms(request.question, questionPlan, followUp), 32));
+        const selectedObjects = selectedContextObjects(request.selectedContext);
+        const followUpObjects = followUpContextObjects(followUp);
+        const followUpSourceObjects = catalog.getObjectsByKeys(followUpSourceObjectKeys(followUp));
+        const areaObjects = filterMetadataObjectsByDomainContext(catalog.listAllObjects({ objectTypes: ['model_area'] }), request.domainContext);
         const focusedArea = resolveFocusedModelArea(request.domainContext, request.question, areaObjects);
         const effectiveDomainContext = focusedArea && request.domainContext
             ? { ...request.domainContext, modelAreaId: focusedArea.id }
@@ -280,18 +435,28 @@ export async function buildLocalContextPack(projectRoot, request) {
         // 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, effectiveDomainContext);
+        const selectedSkills = selectContextPackSkills(catalog, catalog.listAllObjects({ objectTypes: ['skill'] }), request.question, effectiveDomainContext);
         const selectedSkillObjects = selectedSkills.map((item) => item.object);
+        const routeCandidates = effectiveDomainContext?.activeDomain
+            ? catalog.crossDomainRouteObjects(effectiveDomainContext.activeDomain, 100)
+            : [];
+        const routeObjects = rankMetadataObjects({
+            rows: retrievalObjects(routeCandidates),
+            question: `${request.question} ${effectiveDomainContext?.purpose ?? ''}`,
+            questionPlan,
+            modelAreaId: focusedArea?.id,
+            limit: 8,
+        }).selected;
         const objects = fullCatalogObjects
-            ? mergeObjects([...rankedObjects, ...sqlParentObjects, ...fullCatalogObjects, ...selectedSkillObjects])
-            : mergeObjects([...rankedObjects, ...sqlParentObjects, ...selectedSkillObjects]);
+            ? mergeObjects([...rankedObjects, ...sqlParentObjects, ...fullCatalogObjects, ...selectedSkillObjects, ...routeObjects])
+            : mergeObjects([...rankedObjects, ...sqlParentObjects, ...selectedSkillObjects, ...routeObjects]);
         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 queryRuns = runtimeCatalog.queryRunsForObjectKeys(objectKeys, 20);
         const diagnostics = catalog.diagnostics();
         const warnings = buildWarnings(diagnostics, objects);
         const trustLabel = deriveTrust(objects);
@@ -320,6 +485,7 @@ export async function buildLocalContextPack(projectRoot, request) {
             limit: request.limit ?? 120,
         });
         const conflicts = buildCandidateConflicts(reranked.ranked);
+        const meaningEvidence = buildMeaningEvidencePackage(request.question, questionPlan, reranked.ranked);
         const compileConflicts = catalog.compileConflicts();
         const routeDecision = withMetadataTrustLabelInfo(await planContextPackRoute({
             request,
@@ -346,6 +512,7 @@ export async function buildLocalContextPack(projectRoot, request) {
             questionScope,
             limit: 6,
         }).catch(() => ({ applied: [], conflicts: [] }));
+        const knowledgeLens = buildKnowledgeLens(catalog, effectiveDomainContext, selectedSkills);
         const payload = {
             id: '',
             question: request.question,
@@ -357,6 +524,7 @@ export async function buildLocalContextPack(projectRoot, request) {
             trustLabelInfo: metadataTrustLabelInfo(trustLabel),
             objects,
             skills: selectedSkills.map((item) => item.skill),
+            knowledgeLens,
             edges: contextEdges,
             queryRuns,
             citations,
@@ -395,22 +563,49 @@ export async function buildLocalContextPack(projectRoot, request) {
                 topRejected: reranked.rejected,
                 certifiedCandidateFits,
                 candidateConflicts: conflicts,
+                meaningEvidence,
             },
             freshness: {
-                catalogPath: defaultMetadataPath(projectRoot),
+                catalogPath: snapshotPath,
                 builtAt: catalog.state('built_at'),
                 fingerprint: catalog.state('fingerprint'),
             },
         };
         const packPayload = { ...payload };
         delete packPayload.id;
-        const id = catalog.insertContextPack(packPayload);
+        const id = runtimeCatalog.insertContextPack(packPayload);
         return { ...payload, id };
     }
     finally {
         catalog.close();
+        runtimeCatalog.close();
     }
 }
+function buildKnowledgeLens(catalog, context, selectedSkills) {
+    const activeDomainId = context?.activeDomain ?? undefined;
+    const capsule = activeDomainId
+        ? catalog.listAllObjects({ objectTypes: ['domain_capsule'] })
+            .find((object) => object.domain === activeDomainId && !stringValue(object.payload?.modelAreaId))
+        : undefined;
+    const skillRefs = selectedSkills
+        .map(({ skill }) => skill.qualifiedId ?? skill.id)
+        .sort();
+    const skillFingerprints = Object.fromEntries(selectedSkills.flatMap(({ object, skill }) => {
+        const fingerprint = stringValue(object.payload?.sourceFingerprint);
+        return fingerprint ? [[skill.qualifiedId ?? skill.id, fingerprint]] : [];
+    }));
+    return {
+        mode: context?.source === 'explicit_api' || context?.source === 'explicit_ui' ? 'pinned' : 'auto',
+        activeDomainId,
+        modelAreaId: context?.modelAreaId,
+        purpose: context?.purpose,
+        skillRefs,
+        snapshotId: context?.snapshotId ?? catalog.state('fingerprint') ?? 'metadata-unavailable',
+        capsuleFingerprint: stringValue(capsule?.payload?.fingerprint)
+            ?? stringValue(capsule?.payload?.sourceFingerprint),
+        skillFingerprints: Object.keys(skillFingerprints).length > 0 ? skillFingerprints : undefined,
+    };
+}
 export async function planAgentAnswer(projectRoot, request) {
     const contextPack = await buildLocalContextPack(projectRoot, request);
     return {
@@ -477,6 +672,7 @@ export function buildMetadataSnapshot(projectRoot, manifest, semanticLayer, skil
         }
     }
     addManifestBlockDetails(manifest, objects);
+    addManifestKnowledgeGraph(materializeIndexedKnowledgeGraph(projectRoot, manifest), objects, edges);
     addSkillObjects(skills, objects, edges);
     addDbtDagObjects(manifest, objects, edges, diagnostics);
     addRawDbtManifestCatalogObjects(projectRoot, manifest, objects, edges, diagnostics);
@@ -510,20 +706,285 @@ export function buildMetadataSnapshot(projectRoot, manifest, semanticLayer, skil
         edges: Array.from(edges.values()).sort((a, b) => `${a.edgeType}|${a.fromKey}|${a.toKey}`.localeCompare(`${b.edgeType}|${b.fromKey}|${b.toKey}`)),
         diagnostics,
         compileConflicts,
+        skillBodies: [...new Map(skills.map((skill) => {
+                const bodyHash = sha256(skill.body);
+                return [bodyHash, { bodyHash, body: skill.body }];
+            })).values()].sort((a, b) => a.bodyHash.localeCompare(b.bodyHash)),
         generatedAt: new Date().toISOString(),
         fingerprint: '',
     };
     snapshot.fingerprint = fingerprintSnapshot(snapshot);
     return snapshot;
 }
+/**
+ * Manifest graph v2 intentionally omits verbose objects and edges. Snapshot
+ * construction rematerializes that compiler graph once, then persists the
+ * detail in immutable SQLite. Normal Ask/API reads never repeat this work.
+ */
+function materializeIndexedKnowledgeGraph(projectRoot, manifest) {
+    const compact = manifest.knowledgeGraph;
+    if (!compact || compact.storageMode !== 'indexed')
+        return manifest;
+    const { knowledgeGraph: _compactGraph, ...baseManifest } = manifest;
+    const registry = loadDomainPackageRegistry(projectRoot);
+    const skillCatalog = loadManifestKnowledgeSkills(projectRoot, registry);
+    const inline = buildManifestKnowledgeGraph({ manifest: baseManifest, skills: skillCatalog.skills });
+    const objects = { ...(inline.objects ?? {}) };
+    for (const ref of compact.objectRefs ?? []) {
+        objects[ref.id] ??= { ...ref };
+    }
+    return {
+        ...manifest,
+        knowledgeGraph: {
+            ...inline,
+            sourceFingerprint: compact.sourceFingerprint,
+            objects,
+            domainCapsules: compact.domainCapsules,
+            crossDomainRoutes: compact.crossDomainRoutes,
+            diagnostics: compact.diagnostics,
+        },
+    };
+}
+/**
+ * CTX-006: project search is a projection of the compiler-owned qualified
+ * policy graph. Legacy KG records are enriched in place so existing route keys
+ * remain compatible while identity, capsules, and governed route state come
+ * from one source.
+ */
+function addManifestKnowledgeGraph(manifest, objects, edges) {
+    const graph = manifest.knowledgeGraph;
+    if (!graph)
+        return;
+    const keyByGraphId = new Map();
+    const graphObjects = Object.values(graph.objects ?? {});
+    const indexedObjects = graphObjects.length > 0 ? graphObjects : (graph.objectRefs ?? []);
+    for (const item of indexedObjects) {
+        const itemPayload = ('payload' in item ? item.payload : undefined);
+        const itemAliases = ('aliases' in item ? item.aliases : undefined);
+        const displayName = knowledgeDisplayName(item.kind, item.localId, itemPayload);
+        const objectKey = knowledgeMetadataKey(item.kind, displayName, item.id, item.source.system);
+        keyByGraphId.set(item.id, objectKey);
+        const description = stringValue(itemPayload?.description)
+            ?? stringValue(itemPayload?.businessContext)
+            ?? itemAliases?.find((alias) => alias !== item.localId);
+        const compiled = {
+            objectKey,
+            objectType: knowledgeMetadataType(item.kind),
+            name: displayName,
+            fullName: item.id,
+            domain: item.domainId,
+            owner: item.owner,
+            status: item.status,
+            description,
+            sourcePath: item.source.path,
+            sourceSystem: `DQL canonical knowledge graph (${item.source.system})`,
+            payload: compactObject({
+                ...(itemPayload ?? {}),
+                qualifiedId: item.id,
+                aliases: itemAliases ?? [],
+                modelAreaIds: item.modelAreaIds ?? [],
+                sourceFingerprint: item.source.fingerprint,
+                sourceNativeId: item.source.nativeId,
+                knowledgeGraphSchemaVersion: graph.schemaVersion,
+            }),
+        };
+        const existing = objects.get(objectKey);
+        objects.set(objectKey, existing ? mergeObject(existing, compiled) : compiled);
+    }
+    for (const capsule of Object.values(graph.domainCapsules)) {
+        const objectKey = `dql:domain_capsule:${capsule.id}`;
+        objects.set(objectKey, {
+            objectKey,
+            objectType: 'domain_capsule',
+            name: capsule.name,
+            fullName: capsule.id,
+            domain: capsule.domainId,
+            description: capsule.description,
+            sourceSystem: 'DQL compiled Domain Knowledge Capsule',
+            payload: compactObject({ ...capsule, sourceFingerprint: graph.sourceFingerprint }),
+        });
+        addMetadataEdge(edges, 'contains', keyByGraphId.get(`domain::${capsule.domainId}`) ?? `domain:${capsule.domainId}`, objectKey, { source: 'knowledge_graph' });
+        for (const skill of capsule.skillRefs)
+            addMetadataEdge(edges, 'guided_by', objectKey, `skill:${skill}`, { source: 'knowledge_graph' });
+    }
+    for (const route of graph.crossDomainRoutes) {
+        const objectKey = `dql:cross_domain_route:${route.id}`;
+        objects.set(objectKey, {
+            objectKey,
+            objectType: 'cross_domain_route',
+            name: `${route.providerDomainId} → ${route.consumerDomainId}`,
+            fullName: route.id,
+            domain: route.consumerDomainId,
+            status: route.state,
+            description: route.purpose ? `Approved purpose: ${route.purpose}` : 'Observed cross-domain dependency',
+            sourceSystem: 'DQL compiled cross-domain policy',
+            payload: compactObject(route),
+        });
+        addMetadataEdge(edges, 'cross_domain_route', keyByGraphId.get(`domain::${route.providerDomainId}`) ?? `domain:${route.providerDomainId}`, objectKey, { state: route.state, reasonCodes: route.reasonCodes });
+        addMetadataEdge(edges, 'cross_domain_route', objectKey, keyByGraphId.get(`domain::${route.consumerDomainId}`) ?? `domain:${route.consumerDomainId}`, { state: route.state, reasonCodes: route.reasonCodes });
+    }
+    for (const edge of graph.edges ?? []) {
+        const fromKey = keyByGraphId.get(edge.from) ?? edge.from;
+        const toKey = keyByGraphId.get(edge.to) ?? edge.to;
+        addMetadataEdge(edges, edge.kind, fromKey, toKey, {
+            state: edge.state,
+            domainPair: edge.domainPair,
+            evidenceRefs: edge.evidenceRefs ?? [],
+            reasonCodes: edge.reasonCodes ?? [],
+            fingerprint: edge.fingerprint,
+            source: 'knowledge_graph',
+        });
+    }
+}
+function addMetadataEdge(edges, edgeType, fromKey, toKey, payload) {
+    const key = `${edgeType}\u0000${fromKey}\u0000${toKey}`;
+    if (!edges.has(key))
+        edges.set(key, { edgeType, fromKey, toKey, confidence: 1, payload: compactObject(payload) });
+}
+function knowledgeMetadataKey(kind, localId, qualifiedId, sourceSystem) {
+    switch (kind) {
+        case 'block': return `dql:block:${localId}`;
+        case 'term': return `dql:term:${localId}`;
+        case 'business_view': return `dql:business_view:${localId}`;
+        case 'metric': return `semantic:metric:${localId}`;
+        case 'dimension': return `semantic:dimension:${localId}`;
+        case 'entity': return `dql:entity:${qualifiedId}`;
+        case 'model_area': return `dql:model_area:${qualifiedId}`;
+        case 'relationship': return `dql:relationship:${qualifiedId}`;
+        case 'contract': return `dql:contract:${qualifiedId}`;
+        case 'domain_export': return `dql:domain_export:${qualifiedId}`;
+        case 'domain_import': return `dql:domain_import:${qualifiedId}`;
+        case 'conformance': return `dql:conformance:${qualifiedId}`;
+        case 'policy': return `dql:policy:${qualifiedId}`;
+        case 'evaluation': return `dql:evaluation:${qualifiedId}`;
+        case 'skill': return `skill:${qualifiedId}`;
+        case 'domain': return `domain:${localId}`;
+        case 'dbt_model': return `dbt:model:${localId}`;
+        case 'dbt_source': return `dbt:source:${localId}`;
+        case 'source_table': return `warehouse:table:${localId}`;
+        case 'notebook': return `notebook:${localId}`;
+        case 'dashboard': return `dashboard:${localId}`;
+        case 'app': return `app:${localId}`;
+        default: return `${sourceSystem}:${kind}:${qualifiedId}`;
+    }
+}
+function knowledgeDisplayName(kind, localId, payload) {
+    if (kind === 'domain' || kind === 'app')
+        return stringValue(payload?.name) ?? localId;
+    if (kind === 'dashboard' || kind === 'notebook')
+        return stringValue(payload?.title) ?? localId;
+    return localId;
+}
+function knowledgeMetadataType(kind) {
+    switch (kind) {
+        case 'block': return 'dql_block';
+        case 'term': return 'dql_term';
+        case 'metric': return 'semantic_metric';
+        case 'dimension': return 'semantic_dimension';
+        case 'entity': return 'dql_entity';
+        case 'model_area': return 'model_area';
+        case 'dbt_model': return 'dbt_model';
+        case 'dbt_source': return 'dbt_source';
+        case 'source_table': return 'warehouse_table';
+        default: return kind;
+    }
+}
+function metadataKnowledgeKind(objectType) {
+    switch (objectType) {
+        case 'dql_block': return 'block';
+        case 'dql_term': return 'term';
+        case 'business_view': return 'business_view';
+        case 'semantic_metric': return 'metric';
+        case 'semantic_dimension': return 'dimension';
+        case 'semantic_model': return 'semantic_model';
+        case 'dql_entity': return 'entity';
+        case 'model_area': return 'model_area';
+        case 'dbt_model': return 'dbt_model';
+        case 'dbt_source': return 'dbt_source';
+        case 'warehouse_table': return 'source_table';
+        case 'domain_capsule': return 'domain';
+        default: return objectType;
+    }
+}
+function metadataObjectToKnowledge(item) {
+    const payload = item.payload ?? {};
+    const id = stringValue(payload.qualifiedId) ?? item.fullName ?? item.objectKey;
+    const system = item.sourceSystem?.toLowerCase().includes('dbt')
+        ? 'dbt'
+        : item.sourceSystem?.toLowerCase().includes('semantic')
+            ? 'semantic'
+            : 'dql';
+    return {
+        id,
+        kind: metadataKnowledgeKind(item.objectType),
+        localId: item.name,
+        domainId: item.domain,
+        modelAreaIds: metadataStringArray(payload.modelAreaIds),
+        aliases: metadataStringArray(payload.aliases),
+        status: item.status,
+        owner: item.owner,
+        source: {
+            system,
+            path: item.sourcePath,
+            nativeId: stringValue(payload.sourceNativeId),
+            fingerprint: stringValue(payload.sourceFingerprint) ?? sha256(stableStringify({ id, sourcePath: item.sourcePath, payload })),
+        },
+        payload,
+    };
+}
+function metadataEdgeToKnowledge(edge, byKey) {
+    const payload = edge.payload ?? {};
+    const from = byKey.get(edge.fromKey)?.id ?? edge.fromKey;
+    const to = byKey.get(edge.toKey)?.id ?? edge.toKey;
+    const fingerprint = stringValue(payload.fingerprint) ?? sha256(stableStringify({ kind: edge.edgeType, from, to, payload }));
+    return {
+        id: `edge::${fingerprint.slice(0, 20)}`,
+        kind: edge.edgeType,
+        from,
+        to,
+        state: payload.state,
+        domainPair: payload.domainPair,
+        evidenceRefs: metadataStringArray(payload.evidenceRefs),
+        reasonCodes: metadataStringArray(payload.reasonCodes),
+        fingerprint,
+    };
+}
+function metadataRoute(item) {
+    const payload = item.payload ?? {};
+    const providerDomainId = stringValue(payload.providerDomainId);
+    const consumerDomainId = stringValue(payload.consumerDomainId);
+    const relationshipId = stringValue(payload.relationshipId);
+    const state = stringValue(payload.state);
+    if (!providerDomainId || !consumerDomainId || !relationshipId || !state || !['observed', 'authorized', 'blocked', 'stale'].includes(state))
+        return null;
+    return {
+        id: stringValue(payload.id) ?? item.fullName ?? item.objectKey,
+        providerDomainId,
+        consumerDomainId,
+        purpose: stringValue(payload.purpose) ?? '',
+        relationshipId,
+        exportId: stringValue(payload.exportId),
+        importId: stringValue(payload.importId),
+        contractId: stringValue(payload.contractId),
+        state: state,
+        reasonCodes: metadataStringArray(payload.reasonCodes),
+        path: metadataStringArray(payload.path),
+        fingerprint: stringValue(payload.fingerprint) ?? sha256(stableStringify(payload)),
+    };
+}
 export class MetadataCatalog {
     dbPath;
     db;
-    constructor(dbPath) {
+    constructor(dbPath, options = {}) {
         this.dbPath = dbPath;
-        mkdirSync(dirname(dbPath), { recursive: true });
+        if (!options.readOnly)
+            mkdirSync(dirname(dbPath), { recursive: true });
         const Database = loadDatabase();
-        this.db = new Database(dbPath);
+        this.db = new Database(dbPath, options.readOnly ? { readonly: true, fileMustExist: true } : undefined);
+        if (options.readOnly) {
+            this.db.pragma('query_only = ON');
+            return;
+        }
         this.db.pragma('journal_mode = WAL');
         this.db.pragma('foreign_keys = ON');
         this.initSchema();
@@ -605,6 +1066,31 @@ export class MetadataCatalog {
       );
       CREATE INDEX IF NOT EXISTS idx_runtime_schema_snapshots_captured ON runtime_schema_snapshots(captured_at DESC);
 
+      CREATE TABLE IF NOT EXISTS runtime_schema_objects (
+        object_key    TEXT PRIMARY KEY,
+        object_type   TEXT NOT NULL,
+        name          TEXT NOT NULL,
+        full_name     TEXT,
+        domain        TEXT,
+        owner         TEXT,
+        status        TEXT,
+        description   TEXT,
+        source_path   TEXT,
+        source_system TEXT,
+        payload_json  TEXT NOT NULL DEFAULT '{}',
+        updated_at    TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_runtime_schema_objects_type ON runtime_schema_objects(object_type);
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS runtime_schema_fts USING fts5(
+        object_key UNINDEXED,
+        name,
+        full_name,
+        description,
+        payload,
+        tokenize = 'porter unicode61'
+      );
+
       CREATE TABLE IF NOT EXISTS runtime_value_index (
         value_key        TEXT PRIMARY KEY,
         relation         TEXT NOT NULL,
@@ -661,7 +1147,23 @@ export class MetadataCatalog {
         dbt_object_count      INTEGER NOT NULL,
         updated_at            TEXT NOT NULL
       );
+
+      CREATE TABLE IF NOT EXISTS skill_bodies (
+        body_hash       TEXT PRIMARY KEY,
+        encoding        TEXT NOT NULL,
+        compressed_body TEXT NOT NULL,
+        original_length INTEGER NOT NULL
+      );
     `);
+        // Runtime values may be used transiently inside one governed Ask, but they
+        // must never survive in the rebuildable metadata database. Clear legacy v2
+        // rows on open so an upgrade removes old plaintext without a migration.
+        this.db.prepare('DELETE FROM runtime_value_fts').run();
+        this.db.prepare('DELETE FROM runtime_value_index').run();
+        this.db.prepare(`
+      INSERT OR REPLACE INTO metadata_state (key, value)
+      VALUES ('runtime_value_index_count', '0')
+    `).run();
     }
     rebuild(snapshot) {
         const now = new Date().toISOString();
@@ -698,6 +1200,10 @@ export class MetadataCatalog {
         domain, object_count, block_count, certified_block_count,
         semantic_metric_count, dbt_object_count, updated_at
       ) VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+        const insertSkillBody = this.db.prepare(`
+      INSERT OR REPLACE INTO skill_bodies (body_hash, encoding, compressed_body, original_length)
+      VALUES (?, 'br', ?, ?)
     `);
         const sourceFingerprints = buildSourceFingerprints(snapshot.objects, now);
         const domainShards = buildDomainShards(snapshot.objects, now);
@@ -708,10 +1214,11 @@ export class MetadataCatalog {
             this.db.prepare('DELETE FROM metadata_diagnostics').run();
             this.db.prepare('DELETE FROM metadata_source_fingerprints').run();
             this.db.prepare('DELETE FROM metadata_domain_shards').run();
+            this.db.prepare('DELETE FROM skill_bodies').run();
             for (const object of snapshot.objects) {
                 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));
+                insertFts.run(object.objectKey, object.name, object.fullName ?? '', object.description ?? '', object.domain ?? '', object.owner ?? '', searchableMetadataPayload(payload));
             }
             for (const edge of snapshot.edges) {
                 insertEdge.run(edge.edgeType, edge.fromKey, edge.toKey, edge.confidence ?? 1, JSON.stringify(edge.payload ?? {}), now);
@@ -725,6 +1232,9 @@ export class MetadataCatalog {
             for (const item of domainShards) {
                 insertDomainShard.run(item.domain, item.objectCount, item.blockCount, item.certifiedBlockCount, item.semanticMetricCount, item.dbtObjectCount, item.updatedAt);
             }
+            for (const item of snapshot.skillBodies ?? []) {
+                insertSkillBody.run(item.bodyHash, brotliCompressSync(item.body, { params: { [zlibConstants.BROTLI_PARAM_QUALITY]: 4 } }).toString('base64'), Buffer.byteLength(item.body, 'utf8'));
+            }
             setState.run('built_at', now);
             setState.run('fingerprint', snapshot.fingerprint);
             setState.run('project_root', snapshot.projectRoot);
@@ -735,6 +1245,7 @@ export class MetadataCatalog {
             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);
+            setState.run('index_version', METADATA_INDEX_VERSION);
         });
         txn();
     }
@@ -791,6 +1302,9 @@ export class MetadataCatalog {
         semantic_metric_count, dbt_object_count, updated_at
       ) VALUES (?, ?, ?, ?, ?, ?, ?)`);
         const setState = this.db.prepare('INSERT OR REPLACE INTO metadata_state (key, value) VALUES (?, ?)');
+        const insertSkillBody = this.db.prepare(`
+      INSERT OR REPLACE INTO skill_bodies (body_hash, encoding, compressed_body, original_length)
+      VALUES (?, 'br', ?, ?)`);
         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(() => {
@@ -810,7 +1324,7 @@ export class MetadataCatalog {
                     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));
+                insertFts.run(object.objectKey, object.name, object.fullName ?? '', object.description ?? '', object.domain ?? '', object.owner ?? '', searchableMetadataPayload(payload));
             }
             // Cross-source tables: rebuild fully.
             this.db.prepare('DELETE FROM metadata_edges').run();
@@ -825,6 +1339,10 @@ export class MetadataCatalog {
             for (const shard of domainShards) {
                 insertDomainShard.run(shard.domain, shard.objectCount, shard.blockCount, shard.certifiedBlockCount, shard.semanticMetricCount, shard.dbtObjectCount, shard.updatedAt);
             }
+            this.db.prepare('DELETE FROM skill_bodies').run();
+            for (const item of snapshot.skillBodies ?? []) {
+                insertSkillBody.run(item.bodyHash, brotliCompressSync(item.body, { params: { [zlibConstants.BROTLI_PARAM_QUALITY]: 4 } }).toString('base64'), Buffer.byteLength(item.body, 'utf8'));
+            }
             for (const source of removedSources) {
                 this.db.prepare('DELETE FROM metadata_source_fingerprints WHERE source_path = ?').run(source);
             }
@@ -841,6 +1359,7 @@ export class MetadataCatalog {
             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);
+            setState.run('index_version', METADATA_INDEX_VERSION);
         });
         txn();
         return { mode: 'incremental', changedSources: changedSources.size };
@@ -879,9 +1398,16 @@ export class MetadataCatalog {
         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);
+        const andKeys = new Set(andRows.map((row) => row.object_key));
+        const maxAndMagnitude = strongestBm25Magnitude(andRows);
+        const maxOrMagnitude = strongestBm25Magnitude(orRows);
         return rows.map((row) => ({
             ...rowToObject(row),
-            score: row.rank ? 1 / (1 + Math.max(0, row.rank)) : 1,
+            // FTS5 bm25() is negative and more-negative means stronger. The old
+            // max(0, rank) conversion flattened virtually every hit to 1. Preserve
+            // within-tier separation and keep all-terms (AND) evidence ahead of a
+            // partial OR-only match without pretending BM25 is an absolute confidence.
+            score: normalizedBm25Score(row.rank, andKeys.has(row.object_key) ? 'and' : 'or', andKeys.has(row.object_key) ? maxAndMagnitude : maxOrMagnitude),
             snippet: row.snip ?? undefined,
         }));
     }
@@ -905,6 +1431,36 @@ export class MetadataCatalog {
     `).all(...params, options.limit ?? 100);
         return rows.map(rowToObject);
     }
+    /** Complete typed inventory; callers must apply their own bounded ranking. */
+    listAllObjects(options = {}) {
+        const filters = [];
+        const params = [];
+        if (options.objectTypes && options.objectTypes.length > 0) {
+            filters.push(`object_type IN (${options.objectTypes.map(() => '?').join(', ')})`);
+            params.push(...options.objectTypes);
+        }
+        if (options.domain) {
+            filters.push('domain = ?');
+            params.push(options.domain);
+        }
+        const where = filters.length > 0 ? `WHERE ${filters.join(' AND ')}` : '';
+        const rows = this.db.prepare(`
+      SELECT * FROM metadata_objects
+      ${where}
+      ORDER BY object_key
+    `).all(...params);
+        return rows.map(rowToObject);
+    }
+    crossDomainRouteObjects(domainId, limit = 100) {
+        const rows = this.db.prepare(`
+      SELECT * FROM metadata_objects
+      WHERE object_type = 'cross_domain_route'
+        AND (domain = ? OR json_extract(payload_json, '$.providerDomainId') = ?)
+      ORDER BY status, name, object_key
+      LIMIT ?
+    `).all(domainId, domainId, Math.max(1, Math.min(limit, 500)));
+        return rows.map(rowToObject);
+    }
     scanObjects(options, visit) {
         const filters = [];
         const params = [];
@@ -942,7 +1498,20 @@ export class MetadataCatalog {
     }
     getObject(objectKey) {
         const row = this.db.prepare('SELECT * FROM metadata_objects WHERE object_key = ?').get(objectKey);
-        return row ? rowToObject(row) : null;
+        if (row)
+            return rowToObject(row);
+        const legacy = legacyQualifiedAlias(objectKey);
+        if (!legacy)
+            return null;
+        const matches = this.db.prepare(`
+      SELECT * FROM metadata_objects
+      WHERE object_type = ? AND name = ?
+      ORDER BY object_key
+      LIMIT 2
+    `).all(legacy.objectType, legacy.name);
+        // A legacy local-name lookup is safe only while it resolves uniquely. When
+        // two domains define the same local ID, callers must use the qualified key.
+        return matches.length === 1 ? rowToObject(matches[0]) : null;
     }
     getObjectsByKeys(keys) {
         const unique = Array.from(new Set(keys.filter(Boolean)));
@@ -958,21 +1527,45 @@ export class MetadataCatalog {
       `).all(...chunk);
             rows.push(...fetched.map(rowToObject));
         }
+        const found = new Set(rows.map((row) => row.objectKey));
+        for (const key of unique) {
+            if (found.has(key))
+                continue;
+            const resolved = this.getObject(key);
+            if (resolved && !rows.some((row) => row.objectKey === resolved.objectKey))
+                rows.push(resolved);
+        }
         return rows;
     }
+    findObjectByIdentity(identity) {
+        const rows = this.db.prepare(`
+      SELECT * FROM metadata_objects
+      WHERE object_key = ? OR full_name = ?
+      ORDER BY CASE WHEN object_key = ? THEN 0 ELSE 1 END, object_key
+      LIMIT 2
+    `).all(identity, identity, identity);
+        return rows.length === 1 ? rowToObject(rows[0]) : rows[0] ? rowToObject(rows[0]) : null;
+    }
     edgesForKeys(keys, hops = 1) {
         let frontier = new Set(keys.filter(Boolean));
         const seenKeys = new Set(frontier);
         const edges = new Map();
         for (let hop = 0; hop < hops && frontier.size > 0; hop += 1) {
-            const current = Array.from(frontier).slice(0, 100);
+            const current = Array.from(frontier).sort();
             frontier = new Set();
-            const rows = this.db.prepare(`
-        SELECT * FROM metadata_edges
-        WHERE from_key IN (${current.map(() => '?').join(', ')})
-           OR to_key IN (${current.map(() => '?').join(', ')})
-        LIMIT 500
-      `).all(...current, ...current);
+            const rows = [];
+            for (let offset = 0; offset < current.length; offset += 100) {
+                const chunk = current.slice(offset, offset + 100);
+                rows.push(...this.db.prepare(`
+          SELECT * FROM metadata_edges
+          WHERE from_key IN (${chunk.map(() => '?').join(', ')})
+             OR to_key IN (${chunk.map(() => '?').join(', ')})
+          ORDER BY confidence DESC, edge_type, from_key, to_key
+          LIMIT 500
+        `).all(...chunk, ...chunk));
+            }
+            rows.sort((left, right) => right.confidence - left.confidence
+                || `${left.edge_type}|${left.from_key}|${left.to_key}`.localeCompare(`${right.edge_type}|${right.from_key}|${right.to_key}`));
             for (const row of rows) {
                 const edge = rowToEdge(row);
                 const edgeKey = `${edge.edgeType}\u0000${edge.fromKey}\u0000${edge.toKey}`;
@@ -1022,26 +1615,26 @@ export class MetadataCatalog {
     }
     recordRuntimeSchemaSnapshot(snapshot) {
         const capturedAt = snapshot.capturedAt ?? new Date().toISOString();
+        const normalizedTables = normalizeRuntimeSchemaTables(snapshot.tables).slice(0, 10_000);
         const cleanSnapshot = {
             source: snapshot.source,
             capturedAt,
-            tables: normalizeRuntimeSchemaTables(snapshot.tables).slice(0, 500),
+            tables: normalizedTables,
         };
         const id = `schema_${Date.parse(capturedAt) || Date.now()}`;
-        const valueEntries = buildRuntimeValueIndex(cleanSnapshot);
         const insertSnapshot = this.db.prepare(`
       INSERT OR REPLACE INTO runtime_schema_snapshots (
         id, source, payload_json, captured_at
       ) VALUES (?, ?, ?, ?)
     `);
-        const insertValue = this.db.prepare(`
-      INSERT OR REPLACE INTO runtime_value_index (
-        value_key, relation, schema_name, table_name, column_name, column_type,
-        value, normalized_value, source, captured_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        const insertSchemaObject = this.db.prepare(`
+      INSERT INTO runtime_schema_objects (
+        object_key, object_type, name, full_name, domain, owner, status,
+        description, source_path, source_system, payload_json, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
-        const insertValueFts = this.db.prepare(`
-      INSERT INTO runtime_value_fts (value_key, relation, column_name, value, normalized_value)
+        const insertSchemaFts = this.db.prepare(`
+      INSERT INTO runtime_schema_fts (object_key, name, full_name, description, payload)
       VALUES (?, ?, ?, ?, ?)
     `);
         const setState = this.db.prepare(`
@@ -1059,34 +1652,47 @@ export class MetadataCatalog {
       `).run();
             this.db.prepare('DELETE FROM runtime_value_fts').run();
             this.db.prepare('DELETE FROM runtime_value_index').run();
-            for (const entry of valueEntries) {
-                insertValue.run(entry.valueKey, entry.relation, entry.schema ?? null, entry.tableName ?? null, entry.columnName, entry.columnType ?? null, entry.value, entry.normalizedValue, entry.source ?? null, entry.capturedAt);
-                insertValueFts.run(entry.valueKey, entry.relation, entry.columnName, entry.value, entry.normalizedValue);
+            this.db.prepare('DELETE FROM runtime_schema_fts').run();
+            this.db.prepare('DELETE FROM runtime_schema_objects').run();
+            for (const table of normalizedTables) {
+                const object = runtimeSchemaTableObject(table, cleanSnapshot.source, capturedAt);
+                const payload = object.payload ?? {};
+                insertSchemaObject.run(object.objectKey, object.objectType, object.name, object.fullName ?? null, null, null, object.status ?? null, object.description ?? null, null, object.sourceSystem ?? null, JSON.stringify(payload), capturedAt);
+                insertSchemaFts.run(object.objectKey, object.name, object.fullName ?? '', object.description ?? '', searchableMetadataPayload(payload));
             }
-            setState.run('runtime_value_index_count', String(valueEntries.length));
+            setState.run('runtime_value_index_count', '0');
             setState.run('runtime_value_index_captured_at', capturedAt);
+            setState.run('runtime_schema_table_count', String(normalizedTables.length));
+            setState.run('runtime_schema_index_captured_at', capturedAt);
         });
         txn();
         return cleanSnapshot;
     }
     searchRuntimeValues(terms, limit = 40) {
-        const cleanTerms = uniqueStrings(terms.map(normalizeValueIndexText).filter(Boolean)).slice(0, 8);
-        // 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)
+        // Deliberately non-persistent. Approved live probes are attached to the
+        // current in-memory schema context by the CLI and discarded after the Ask.
+        void terms;
+        void limit;
+        return [];
+    }
+    searchRuntimeSchemaObjects(query, limit = 40) {
+        const match = buildFtsMatch(query, { prefix: true });
+        if (!match.or)
             return [];
-        const rows = this.db.prepare(`
-      SELECT v.*,
-             bm25(runtime_value_fts) AS rank
-      FROM runtime_value_fts
-      JOIN runtime_value_index AS v ON v.value_key = runtime_value_fts.value_key
-      WHERE runtime_value_fts MATCH ?
+        const runMatch = (matchExpr) => this.db.prepare(`
+      SELECT o.*,
+             bm25(runtime_schema_fts) AS rank,
+             snippet(runtime_schema_fts, -1, '<mark>', '</mark>', '...', 12) AS snip
+      FROM runtime_schema_fts
+      JOIN runtime_schema_objects AS o ON o.object_key = runtime_schema_fts.object_key
+      WHERE runtime_schema_fts MATCH ?
       ORDER BY rank
       LIMIT ?
-    `).all(query, Math.max(1, limit));
-        return rows.map((row) => rowToRuntimeValueMatch(row, cleanTerms))
-            .sort((a, b) => b.score - a.score || a.relation.localeCompare(b.relation) || a.columnName.localeCompare(b.columnName));
+    `).all(matchExpr, Math.max(1, limit));
+        const andRows = match.and ? runMatch(match.and) : [];
+        const seen = new Set(andRows.map((row) => row.object_key));
+        const rows = [...andRows, ...runMatch(match.or).filter((row) => !seen.has(row.object_key))].slice(0, limit);
+        return rows.map(rowToObject);
     }
     latestRuntimeSchemaSnapshot() {
         const row = this.db.prepare(`
@@ -1166,14 +1772,91 @@ export class MetadataCatalog {
             updatedAt: row.updated_at,
         }));
     }
+    skillBody(bodyHash) {
+        const row = this.db.prepare(`
+      SELECT encoding, compressed_body
+      FROM skill_bodies
+      WHERE body_hash = ?
+    `).get(bodyHash);
+        if (!row)
+            return null;
+        if (row.encoding !== 'br')
+            return row.compressed_body;
+        const compressed = Uint8Array.from(Buffer.from(row.compressed_body, 'base64'));
+        return brotliDecompressSync(compressed).toString('utf8');
+    }
+    exportSnapshot(destination) {
+        mkdirSync(dirname(destination), { recursive: true });
+        if (existsSync(destination))
+            return;
+        const candidate = `${destination}.candidate`;
+        rmSync(candidate, { force: true });
+        this.db.pragma('wal_checkpoint(TRUNCATE)');
+        this.db.prepare('VACUUM INTO ?').run(candidate);
+        const Database = loadDatabase();
+        const sealed = new Database(candidate);
+        try {
+            sealed.exec(`
+        DELETE FROM context_packs;
+        DELETE FROM query_runs;
+        DELETE FROM runtime_schema_snapshots;
+        DELETE FROM runtime_schema_fts;
+        DELETE FROM runtime_schema_objects;
+        DELETE FROM runtime_value_fts;
+        DELETE FROM runtime_value_index;
+        VACUUM;
+      `);
+            sealed.pragma('journal_mode = DELETE');
+        }
+        finally {
+            sealed.close();
+        }
+        renameSync(candidate, destination);
+    }
     state(key) {
         const row = this.db.prepare('SELECT value FROM metadata_state WHERE key = ?').get(key);
         return row?.value ?? null;
     }
+    setState(key, value) {
+        this.db.prepare('INSERT OR REPLACE INTO metadata_state (key, value) VALUES (?, ?)').run(key, value);
+    }
     close() {
         this.db.close();
     }
 }
+function strongestBm25Magnitude(rows) {
+    return rows.reduce((strongest, row) => Math.max(strongest, bm25Magnitude(row.rank)), 0);
+}
+function bm25Magnitude(rank) {
+    return typeof rank === 'number' && Number.isFinite(rank) ? Math.max(0, -rank) : 0;
+}
+function normalizedBm25Score(rank, tier, strongest) {
+    const relative = strongest > 0 ? bm25Magnitude(rank) / strongest : 0;
+    const score = tier === 'and'
+        ? 0.55 + relative * 0.45
+        : 0.05 + relative * 0.45;
+    return Number(score.toFixed(6));
+}
+function legacyQualifiedAlias(objectKey) {
+    const mappings = [
+        ['semantic:entity:', 'dql_entity'],
+        ['model_area:', 'model_area'],
+        ['relationship:', 'relationship'],
+        ['contract:', 'contract'],
+        ['domain_export:', 'domain_export'],
+        ['domain_import:', 'domain_import'],
+        ['conformance:', 'conformance'],
+        ['policy:', 'policy'],
+        ['evaluation:', 'evaluation'],
+    ];
+    for (const [prefix, objectType] of mappings) {
+        if (!objectKey.startsWith(prefix))
+            continue;
+        const name = objectKey.slice(prefix.length);
+        return name ? { objectType, name } : undefined;
+    }
+    return undefined;
+}
 function loadAgentManifest(projectRoot) {
     return buildManifest({
         projectRoot,
@@ -1227,6 +1910,7 @@ function manifestDiagnosticToMetadataDiagnostic(diagnostic) {
     };
 }
 function objectFromKGNode(node) {
+    const qualifiedIdentity = qualifiedIdentityFromKGNode(node);
     const payload = {
         ...(node.payload ?? {}),
         kgNodeId: node.nodeId,
@@ -1261,13 +1945,21 @@ function objectFromKGNode(node) {
         businessRules: node.businessRules ?? [],
         caveats: node.caveats ?? [],
         llmContext: node.llmContext,
+        label: kgContextField(node.llmContext, 'label'),
+        metricType: kgContextField(node.llmContext, 'metric type'),
+        aggregation: kgContextField(node.llmContext, 'aggregation'),
+        table: kgContextField(node.llmContext, 'table'),
+        formula: node.kind === 'metric' ? kgContextField(node.llmContext, 'sql') : undefined,
+        semanticModel: ['metric', 'dimension', 'measure', 'entity'].includes(node.kind) && node.name.includes('.')
+            ? node.name.split('.')[0]
+            : undefined,
         referencedBy: node.referencedBy ?? [],
     };
     return {
         objectKey: objectKeyFromKGNode(node),
         objectType: objectTypeFromKGNode(node),
         name: node.name,
-        fullName: node.name,
+        fullName: qualifiedIdentity ?? node.name,
         domain: node.domain,
         owner: node.owner,
         status: node.status ?? node.certification,
@@ -1277,7 +1969,18 @@ function objectFromKGNode(node) {
         payload: compactObject(payload),
     };
 }
+function kgContextField(context, field) {
+    if (!context)
+        return undefined;
+    const prefix = `${field.toLowerCase()}:`;
+    const line = context.split(/\r?\n/).find((candidate) => candidate.trim().toLowerCase().startsWith(prefix));
+    return line?.trim().slice(prefix.length).trim() || undefined;
+}
 function objectKeyFromKGNode(node) {
+    const qualifiedIdentity = qualifiedIdentityFromKGNode(node);
+    if (qualifiedIdentity && isQualifiedDqlModelingNode(node)) {
+        return `dql:${node.kind}:${qualifiedIdentity}`;
+    }
     switch (node.kind) {
         case 'block': return `dql:block:${node.name}`;
         case 'term': return `dql:term:${node.name}`;
@@ -1300,6 +2003,29 @@ function objectKeyFromKGNode(node) {
         default: return `${node.kind}:${node.name}`;
     }
 }
+function isQualifiedDqlModelingNode(node) {
+    return node.sourceTier === 'business_context' && [
+        'model_area',
+        'entity',
+        'relationship',
+        'contract',
+        'domain_export',
+        'domain_import',
+        'conformance',
+        'policy',
+        'evaluation',
+    ].includes(node.kind);
+}
+function qualifiedIdentityFromKGNode(node) {
+    const payload = node.payload ?? {};
+    const explicit = stringValue(payload.qualifiedId);
+    if (explicit)
+        return explicit;
+    if (!isQualifiedDqlModelingNode(node))
+        return undefined;
+    const prefix = `${node.kind}:`;
+    return node.nodeId.startsWith(prefix) ? node.nodeId.slice(prefix.length) : undefined;
+}
 function objectTypeFromKGNode(node) {
     switch (node.kind) {
         case 'block': return 'dql_block';
@@ -1308,7 +2034,7 @@ function objectTypeFromKGNode(node) {
         case 'metric': return 'semantic_metric';
         case 'dimension': return 'semantic_dimension';
         case 'measure': return 'semantic_measure';
-        case 'entity': return 'semantic_entity';
+        case 'entity': return isQualifiedDqlModelingNode(node) ? 'dql_entity' : 'semantic_entity';
         case 'semantic_model': return 'semantic_model';
         case 'saved_query': return 'semantic_saved_query';
         case 'dbt_model': return 'dbt_model';
@@ -1337,6 +2063,15 @@ function normalizeEdge(edge, fromKey, toKey) {
 function addSkillObjects(skills, objects, edges) {
     for (const skill of skills) {
         const identity = skill.qualifiedId ?? skill.id;
+        const bodyHash = sha256(skill.body);
+        const sourceFingerprint = sha256(stableStringify({
+            identity,
+            domain: skill.domain,
+            domains: skill.domains ?? [],
+            modelAreaRefs: skill.modelAreaRefs ?? [],
+            status: skill.status ?? 'active',
+            bodyHash,
+        }));
         const objectKey = `skill:${identity}`;
         const domains = uniqueNonBlank([skill.domain, ...(skill.domains ?? [])]);
         const object = {
@@ -1369,12 +2104,13 @@ function addSkillObjects(skills, objects, edges) {
                 examples: skill.examples ?? [],
                 sourceRefs: skill.sourceRefs ?? [],
                 vocabulary: skill.vocabulary,
-                body: skill.body,
+                bodyHash,
+                sourceFingerprint,
                 isStarter: skill.isStarter,
                 provenance: 'DQL domain skill',
             }),
         };
-        objects.set(objectKey, object);
+        objects.set(objectKey, mergeObject(objects.get(objectKey), object));
         for (const domain of domains) {
             const edge = {
                 edgeType: 'contains',
@@ -2444,9 +3180,16 @@ async function planContextPackRoute(input) {
         && (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
+    const directlyNamedCertified = findExactCertifiedObject(input.request.question, intent, input.objects);
+    const applicabilityCertified = exactByApplicability
         ? input.objects.find((object) => object.objectKey === exactByApplicability.objectKey)
-        : findExactCertifiedObject(input.request.question, intent, input.objects) ?? exactByContract;
+        : undefined;
+    // Selection order is governance-significant (AGT-009/AGT-010): an explicit
+    // block/example reference wins, then a complete answer-shape fit, and only then
+    // the older lexical applicability heuristic. This prevents a broad customer
+    // block containing the word "spend" from displacing an exact beverage-scoped
+    // customer ranking whose measure is named "beverage_revenue".
+    let exact = directlyNamedCertified ?? exactByContract ?? applicabilityCertified;
     const contextApplicability = [...applicabilityByKey.values()]
         .filter((item) => item.kind === 'context_only')
         .sort((a, b) => b.score - a.score)[0];
@@ -2478,7 +3221,6 @@ async function planContextPackRoute(input) {
     const exactExampleMatch = exact ? hasExactExampleQuestion(input.request.question, exact) : false;
     const directCertifiedBypass = Boolean(exact && (exactExampleMatch
         || intent === 'definition_lookup'
-        || intent === 'exact_certified_lookup'
         || objectNameInQuestion(input.request.question, exact)));
     const blockFitObject = exact
         ?? (contextApplicability ? input.objects.find((object) => object.objectKey === contextApplicability.objectKey) : undefined);
@@ -2542,7 +3284,9 @@ async function planContextPackRoute(input) {
         || (intent === 'ad_hoc_ranking' && objectNameInQuestion(input.request.question, exact)))) {
         return {
             route: 'certified',
-            intent,
+            intent: input.questionPlan.outputShape === 'value' && input.questionPlan.requestedShape.dimensions.length === 0
+                ? 'exact_certified_lookup'
+                : intent,
             reason: `Certified ${exact.objectType.replace(/_/g, ' ')} "${exact.name}" exactly matches the requested artifact, definition, or direct KPI grain.`,
             routeReason: grainGateInfo?.reason,
             grainGate: grainGateInfo,
@@ -4094,23 +4838,7 @@ function runtimeSchemaObjects(snapshot) {
     const capturedAt = snapshot.capturedAt ?? new Date().toISOString();
     return normalizeRuntimeSchemaTables(snapshot.tables).flatMap((table) => {
         const relation = table.relation;
-        const tableKey = `runtime:table:${relation}`;
-        const tableObject = {
-            objectKey: tableKey,
-            objectType: 'runtime_table',
-            name: table.name ?? relation.split('.').at(-1) ?? relation,
-            fullName: relation,
-            description: table.description,
-            status: 'runtime_observed',
-            sourceSystem: snapshot.source ?? table.source ?? 'runtime schema snapshot',
-            payload: compactObject({
-                relation,
-                schema: table.schema,
-                columnCompleteness: 'complete',
-                columns: table.columns,
-            }),
-            updatedAt: capturedAt,
-        };
+        const tableObject = runtimeSchemaTableObject(table, snapshot.source, capturedAt);
         const columns = table.columns.map((column) => ({
             objectKey: `runtime:column:${relation}.${column.name}`,
             objectType: 'runtime_column',
@@ -4130,6 +4858,25 @@ function runtimeSchemaObjects(snapshot) {
         return [tableObject, ...columns];
     });
 }
+function runtimeSchemaTableObject(table, snapshotSource, capturedAt) {
+    const relation = table.relation;
+    return {
+        objectKey: `runtime:table:${relation}`,
+        objectType: 'runtime_table',
+        name: table.name ?? relation.split('.').at(-1) ?? relation,
+        fullName: relation,
+        description: table.description,
+        status: 'runtime_observed',
+        sourceSystem: snapshotSource ?? table.source ?? 'runtime schema snapshot',
+        payload: compactObject({
+            relation,
+            schema: table.schema,
+            columnCompleteness: 'complete',
+            columns: table.columns,
+        }),
+        updatedAt: capturedAt,
+    };
+}
 function runtimeValueMatchObjects(matches) {
     return matches.map((match) => ({
         objectKey: match.valueKey,
@@ -4370,7 +5117,7 @@ const METADATA_VALUE_STOP_TERMS = new Set([
     'this year',
     'user',
 ]);
-function buildFollowUpSearchQuery(question, followUp) {
+export function buildFollowUpSearchQuery(question, followUp) {
     if (!followUp)
         return question;
     // Contextual carry is advisory: enrich retrieval softly (prior question, columns,
@@ -4392,14 +5139,19 @@ function buildFollowUpSearchQuery(question, followUp) {
         question,
         followUp.sourceBlockName ?? '',
         followUp.sourceQuestion ?? '',
-        ...(followUp.filters ?? []),
         ...(followUp.dimensions ?? []),
         ...(followUp.priorResultColumns ?? []),
         followUp.priorResultRef?.question ?? '',
         ...(followUp.priorResultRef?.columns ?? []),
-        followUp.priorResultRef?.sourceSql ? followUp.priorResultRef.sourceSql.slice(0, 600) : '',
-        ...dqlArtifactSearchTerms(followUp.priorDqlArtifact, { includeSource: true }),
-        ...Object.entries(followUp.priorResultValues ?? {}).flatMap(([key, values]) => [key, ...values]),
+        ...(followUp.priorMeasures ?? []),
+        // Retrieval searches object meaning, not executable payloads or warehouse
+        // members. The source block is loaded directly by key and the typed follow-up
+        // object retains SQL + values for execution. Injecting 600-1500 characters of
+        // SQL and every prior row value into FTS made an eight-customer drilldown spend
+        // ~11 seconds tokenizing metadata before the provider even started.
+        ...(followUp.priorDqlArtifact?.metrics ?? []),
+        ...(followUp.priorDqlArtifact?.dimensions ?? []),
+        ...(followUp.priorDqlArtifact?.filters ?? []).map((filter) => filter.dimension),
     ].filter(Boolean).join(' ');
 }
 function dqlArtifactSearchTerms(artifact, options) {
@@ -4448,7 +5200,15 @@ function normalizeRuntimeSchemaTables(tables) {
             name: table.name ?? relation.split('.').at(-1) ?? relation,
             description: table.description,
             source: table.source,
-            columns: dedupeRuntimeColumns(table.columns ?? []).slice(0, 160),
+            // Persist structural schema only. Live sample values can contain PII and
+            // are scoped to a single request by the CLI (SEC-003).
+            columns: dedupeRuntimeColumns(table.columns ?? [])
+                .slice(0, 160)
+                .map((column) => ({
+                name: column.name,
+                type: column.type,
+                description: column.description,
+            })),
         };
         if (!current)
             byRelation.set(key, normalized);
@@ -4670,6 +5430,54 @@ function compactObject(value) {
     }
     return out;
 }
+const SEARCHABLE_METADATA_KEYS = new Set([
+    'aliases', 'synonyms', 'tags', 'label', 'metricType', 'aggregation', 'semanticModel',
+    'localId', 'qualifiedId', 'uniqueId',
+    'description', 'businessOutcome', 'decisionUse', 'grain', 'entities',
+    'dimensions', 'allowedFilters', 'declaredOutputs', 'outputContract', 'outputs',
+    'parameters', 'parameterPolicy', 'tableDependencies', 'sourceSystems', 'relation',
+    'table', 'database', 'schema', 'materialized', 'columns', 'intentExamples',
+    'examples', 'primaryTerms', 'businessRules', 'caveats', 'triggers', 'vocabulary',
+]);
+const SEARCHABLE_NESTED_METADATA_KEYS = new Set([
+    'name', 'id', 'label', 'description', 'type', 'role', 'filter', 'binding',
+    'question', 'entity', 'column', 'relation', 'table', 'domain', 'term', 'alias',
+    'synonym', 'localId', 'qualifiedId', 'grain',
+]);
+/**
+ * FTS indexes business/schema evidence, not the complete payload. In particular,
+ * raw SQL and provider/runtime fields add large amounts of noise and can contain
+ * literals that should never become general retrieval context.
+ */
+function searchableMetadataPayload(payload) {
+    const tokens = [];
+    const visit = (value, depth) => {
+        if (tokens.length >= 2_000 || depth > 3 || value === null || value === undefined)
+            return;
+        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+            const text = String(value).replace(/\s+/g, ' ').trim();
+            if (text)
+                tokens.push(text.slice(0, 500));
+            return;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value.slice(0, 500))
+                visit(item, depth + 1);
+            return;
+        }
+        if (typeof value !== 'object')
+            return;
+        for (const [key, item] of Object.entries(value)) {
+            if (depth === 0 ? !SEARCHABLE_METADATA_KEYS.has(key) : !SEARCHABLE_NESTED_METADATA_KEYS.has(key))
+                continue;
+            if (/sql|secret|password|token|credential|api.?key/i.test(key))
+                continue;
+            visit(item, depth + 1);
+        }
+    };
+    visit(payload, 0);
+    return tokens.join(' ');
+}
 function rowToObject(row) {
     return {
         objectKey: row.object_key,
@@ -4962,7 +5770,7 @@ function filterMetadataObjectsByDomainContext(rows, context) {
     ]);
     return rows.filter((row) => !row.domain || domains.has(row.domain));
 }
-function selectContextPackSkills(objects, question, context) {
+function selectContextPackSkills(catalog, objects, question, context) {
     const byIdentity = new Map();
     const parsed = objects.flatMap((object) => {
         const skill = skillFromMetadataObject(object);
@@ -4978,10 +5786,15 @@ function selectContextPackSkills(objects, question, context) {
     const selected = selectRelevantSkills(parsed, question, {
         domains,
         modelAreaIds: context?.modelAreaId ? [context.modelAreaId] : [],
+        pinnedIds: context?.skillRefs ? ['sql-conventions', ...context.skillRefs] : undefined,
     });
     return selected.flatMap((skill) => {
         const object = byIdentity.get(skill.qualifiedId ?? skill.id);
-        return object ? [{ object, skill: localContextSkillFromParsed(skill, object) }] : [];
+        if (!object)
+            return [];
+        const bodyHash = stringPayload(object.payload?.bodyHash);
+        const hydrated = bodyHash ? { ...skill, body: catalog.skillBody(bodyHash) ?? '' } : skill;
+        return [{ object, skill: localContextSkillFromParsed(hydrated, object) }];
     });
 }
 function skillFromMetadataObject(object) {
@@ -5017,7 +5830,7 @@ function skillFromMetadataObject(object) {
         examples: stringArrayPayload(payload.examples),
         sourceRefs: stringArrayPayload(payload.sourceRefs),
         vocabulary: stringRecordPayload(payload.vocabulary),
-        body: stringPayload(payload.body) ?? '',
+        body: '',
         sourcePath: object.sourcePath ?? '',
         isStarter: payload.isStarter === true,
     };