@duckcodeailabs/dql-agent 1.6.5 → 1.6.6

package/dist/metadata/catalog.js

@@ -0,0 +1,1991 @@
+/**
+ * Project-local metadata catalog for OSS agentic analytics.
+ *
+ * Git/DQL/dbt files remain the source of truth. This SQLite database is a
+ * rebuildable local catalog at `.dql/cache/metadata.sqlite` used by agents,
+ * MCP tools, app builder, and notebook/block AI to retrieve one consistent
+ * context pack before answering.
+ */
+import { createHash } from 'node:crypto';
+import { mkdirSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { buildManifest, loadProjectConfig, resolveDbtManifestPath, resolveSemanticLayerWithDiagnostics, } from '@duckcodeailabs/dql-core';
+import { buildKGFromManifest, buildKGFromSemanticLayer } from '../kg/build.js';
+const require = createRequire(import.meta.url);
+let databaseCtor = null;
+function loadDatabase() {
+    databaseCtor ??= require('better-sqlite3');
+    return databaseCtor;
+}
+const OBJECT_PRIORITY = {
+    dql_block: 1,
+    semantic_metric: 2,
+    dql_term: 3,
+    business_view: 4,
+    semantic_dimension: 5,
+    semantic_measure: 6,
+    semantic_entity: 7,
+    semantic_model: 8,
+    dbt_model: 9,
+    dbt_source: 10,
+    dbt_column: 11,
+    warehouse_table: 12,
+    notebook: 13,
+    dashboard: 14,
+    app: 15,
+    domain: 16,
+};
+export function defaultMetadataPath(projectRoot) {
+    return join(projectRoot, '.dql', 'cache', 'metadata.sqlite');
+}
+export function openMetadataCatalog(projectRoot, dbPath = defaultMetadataPath(projectRoot)) {
+    return new MetadataCatalog(dbPath);
+}
+export async function ensureMetadataCatalogFresh(projectRoot, options = {}) {
+    const semanticLayer = options.semanticLayer !== undefined
+        ? options.semanticLayer ?? undefined
+        : loadAgentSemanticLayer(projectRoot);
+    const manifest = options.manifest ?? loadAgentManifest(projectRoot);
+    const snapshot = buildMetadataSnapshot(projectRoot, manifest, semanticLayer);
+    const catalog = openMetadataCatalog(projectRoot);
+    try {
+        const existing = catalog.state('fingerprint');
+        if (!options.force && existing === snapshot.fingerprint) {
+            return {
+                path: defaultMetadataPath(projectRoot),
+                refreshed: false,
+                objectCount: catalog.objectCount(),
+                edgeCount: catalog.edgeCount(),
+                diagnostics: catalog.diagnostics(),
+                fingerprint: snapshot.fingerprint,
+            };
+        }
+        catalog.rebuild(snapshot);
+        return {
+            path: defaultMetadataPath(projectRoot),
+            refreshed: true,
+            objectCount: snapshot.objects.length,
+            edgeCount: snapshot.edges.length,
+            diagnostics: snapshot.diagnostics,
+            fingerprint: snapshot.fingerprint,
+        };
+    }
+    finally {
+        catalog.close();
+    }
+}
+export function upsertMetadataSnapshot(projectRoot, snapshot) {
+    const catalog = openMetadataCatalog(projectRoot);
+    try {
+        catalog.rebuild(snapshot);
+        return {
+            path: defaultMetadataPath(projectRoot),
+            refreshed: true,
+            objectCount: snapshot.objects.length,
+            edgeCount: snapshot.edges.length,
+            diagnostics: snapshot.diagnostics,
+            fingerprint: snapshot.fingerprint,
+        };
+    }
+    finally {
+        catalog.close();
+    }
+}
+export async function buildLocalContextPack(projectRoot, request) {
+    await ensureMetadataCatalogFresh(projectRoot);
+    const catalog = openMetadataCatalog(projectRoot);
+    try {
+        const mode = request.mode ?? 'question';
+        const runtimeSnapshot = request.runtimeSchemaSnapshot ?? catalog.latestRuntimeSchemaSnapshot();
+        const runtimeObjects = runtimeSnapshot ? runtimeSchemaObjects(runtimeSnapshot) : [];
+        const selectedObjects = selectedContextObjects(request.selectedContext);
+        const selectedReferencedObjects = catalog
+            .getObjectsByKeys(selectedContextReferenceKeys(request.selectedContext, selectedObjects))
+            .map((object) => ({ ...object, score: Math.max(object.score ?? 0, 20) }));
+        const searchRows = catalog.searchObjects({
+            query: request.question,
+            objectTypes: request.objectTypes,
+            limit: Math.max(request.limit ?? 80, 20),
+        });
+        const exact = request.focusObjectKey ? catalog.getObject(request.focusObjectKey) : null;
+        const ranked = rankMetadataObjects({
+            rows: mergeObjects(exact
+                ? [exact, ...selectedReferencedObjects, ...searchRows, ...runtimeObjects, ...selectedObjects]
+                : [...selectedReferencedObjects, ...searchRows, ...runtimeObjects, ...selectedObjects]),
+            question: request.question,
+            limit: request.limit ?? 80,
+        });
+        const selected = ranked.selected;
+        const focusObjectKey = request.focusObjectKey ?? selectedReferencedObjects[0]?.objectKey ?? 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 objects = rankMetadataObjects({
+            rows: mergeObjects([...selectedReferencedObjects, ...selected, ...graphObjects, ...runtimeObjects, ...selectedObjects]),
+            question: request.question,
+            limit: request.limit ?? 120,
+        }).selected;
+        const objectKeys = objects.map((row) => row.objectKey);
+        const queryRuns = catalog.queryRunsForObjectKeys(objectKeys, 20);
+        const diagnostics = catalog.diagnostics();
+        const warnings = buildWarnings(diagnostics, objects);
+        const trustLabel = deriveTrust(objects);
+        const citations = buildCitations(objects, edgeWalk);
+        const evidenceSummaries = buildEvidenceSummaries(objects, edgeWalk, queryRuns, diagnostics);
+        const allowedSqlContext = buildAllowedSqlContext(objects, edgeWalk);
+        const evidenceRoles = buildEvidenceRoles(objects, queryRuns);
+        const reranked = rankMetadataObjects({
+            rows: mergeObjects([...searchRows, ...objects]),
+            question: request.question,
+            limit: request.limit ?? 120,
+        });
+        const conflicts = buildCandidateConflicts(reranked.ranked);
+        const routeDecision = planContextPackRoute({
+            request,
+            objects,
+            allowedSqlContext,
+            evidenceRoles,
+            diagnostics,
+            trustLabel,
+        });
+        const payload = {
+            id: '',
+            question: request.question,
+            focusObjectKey,
+            mode,
+            trustLabel,
+            objects,
+            edges: edgeWalk,
+            queryRuns,
+            citations,
+            evidenceSummaries,
+            warnings,
+            routeDecision,
+            evidenceRoles,
+            allowedSqlContext,
+            missingContext: routeDecision.missingContext,
+            conflicts,
+            retrievalDiagnostics: {
+                strategy: 'sqlite_fts',
+                selectedObjects: objects.length,
+                selectedEvidence: reranked.ranked.slice(0, 20).map((item) => ({
+                    objectKey: item.row.objectKey,
+                    objectType: item.row.objectType,
+                    name: item.row.name,
+                    reason: item.reason,
+                    rank: item.rank,
+                    score: item.score,
+                    priorityTier: item.priorityTier,
+                })),
+                topRejected: reranked.rejected,
+                candidateConflicts: conflicts,
+            },
+            freshness: {
+                catalogPath: defaultMetadataPath(projectRoot),
+                builtAt: catalog.state('built_at'),
+                fingerprint: catalog.state('fingerprint'),
+            },
+        };
+        const packPayload = { ...payload };
+        delete packPayload.id;
+        const id = catalog.insertContextPack(packPayload);
+        return { ...payload, id };
+    }
+    finally {
+        catalog.close();
+    }
+}
+export async function planAgentAnswer(projectRoot, request) {
+    const contextPack = await buildLocalContextPack(projectRoot, request);
+    return {
+        contextPackId: contextPack.id,
+        contextPack,
+        routeDecision: contextPack.routeDecision,
+        evidenceRoles: contextPack.evidenceRoles,
+        allowedSqlContext: contextPack.allowedSqlContext,
+        missingContext: contextPack.missingContext,
+        warnings: contextPack.warnings,
+        freshness: contextPack.freshness,
+    };
+}
+export function recordQueryRun(projectRoot, run) {
+    const catalog = openMetadataCatalog(projectRoot);
+    try {
+        return catalog.recordQueryRun(run);
+    }
+    finally {
+        catalog.close();
+    }
+}
+export function recordRuntimeSchemaSnapshot(projectRoot, snapshot) {
+    const catalog = openMetadataCatalog(projectRoot);
+    try {
+        return catalog.recordRuntimeSchemaSnapshot(snapshot);
+    }
+    finally {
+        catalog.close();
+    }
+}
+export function buildMetadataSnapshot(projectRoot, manifest, semanticLayer) {
+    const manifestGraph = buildKGFromManifest(manifest);
+    const semanticGraph = buildKGFromSemanticLayer(semanticLayer);
+    const objects = new Map();
+    const edges = new Map();
+    const diagnostics = [
+        ...(manifest.diagnostics ?? []).map(manifestDiagnosticToMetadataDiagnostic),
+    ];
+    for (const node of [...manifestGraph.nodes, ...semanticGraph.nodes]) {
+        const object = objectFromKGNode(node);
+        const existing = objects.get(object.objectKey);
+        if (existing) {
+            diagnostics.push({
+                kind: 'metadata',
+                severity: 'warning',
+                objectKey: object.objectKey,
+                message: `duplicate metadata object key "${object.objectKey}" from ${existing.sourcePath ?? existing.sourceSystem ?? 'unknown'} and ${object.sourcePath ?? object.sourceSystem ?? 'unknown'}`,
+            });
+            objects.set(object.objectKey, mergeObject(existing, object));
+        }
+        else {
+            objects.set(object.objectKey, object);
+        }
+    }
+    addManifestBlockDetails(manifest, objects);
+    addDbtDagObjects(manifest, objects, edges, diagnostics);
+    addBlockDependencyEdges(manifest, edges);
+    const nodeKeyMap = new Map();
+    for (const node of [...manifestGraph.nodes, ...semanticGraph.nodes]) {
+        nodeKeyMap.set(node.nodeId, objectKeyFromKGNode(node));
+    }
+    for (const edge of [...manifestGraph.edges, ...semanticGraph.edges]) {
+        const fromKey = nodeKeyMap.get(edge.src) ?? edge.src;
+        const toKey = nodeKeyMap.get(edge.dst) ?? edge.dst;
+        const normalized = normalizeEdge(edge, fromKey, toKey);
+        const key = `${normalized.edgeType}\u0000${normalized.fromKey}\u0000${normalized.toKey}`;
+        if (!edges.has(key))
+            edges.set(key, normalized);
+    }
+    addProjectDiagnostics(manifest, semanticLayer, diagnostics);
+    const snapshot = {
+        projectRoot,
+        manifest,
+        objects: Array.from(objects.values()).sort((a, b) => a.objectKey.localeCompare(b.objectKey)),
+        edges: Array.from(edges.values()).sort((a, b) => `${a.edgeType}|${a.fromKey}|${a.toKey}`.localeCompare(`${b.edgeType}|${b.fromKey}|${b.toKey}`)),
+        diagnostics,
+        generatedAt: new Date().toISOString(),
+        fingerprint: '',
+    };
+    snapshot.fingerprint = fingerprintSnapshot(snapshot);
+    return snapshot;
+}
+export class MetadataCatalog {
+    dbPath;
+    db;
+    constructor(dbPath) {
+        this.dbPath = dbPath;
+        mkdirSync(dirname(dbPath), { recursive: true });
+        const Database = loadDatabase();
+        this.db = new Database(dbPath);
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('foreign_keys = ON');
+        this.initSchema();
+    }
+    initSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS metadata_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_metadata_objects_type ON metadata_objects(object_type);
+      CREATE INDEX IF NOT EXISTS idx_metadata_objects_domain ON metadata_objects(domain);
+      CREATE INDEX IF NOT EXISTS idx_metadata_objects_status ON metadata_objects(status);
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS metadata_fts USING fts5(
+        object_key UNINDEXED,
+        name,
+        full_name,
+        description,
+        domain,
+        owner,
+        payload,
+        tokenize = 'porter unicode61'
+      );
+
+      CREATE TABLE IF NOT EXISTS metadata_edges (
+        edge_type    TEXT NOT NULL,
+        from_key     TEXT NOT NULL,
+        to_key       TEXT NOT NULL,
+        confidence   REAL NOT NULL DEFAULT 1.0,
+        payload_json TEXT NOT NULL DEFAULT '{}',
+        created_at   TEXT NOT NULL,
+        PRIMARY KEY (edge_type, from_key, to_key)
+      );
+      CREATE INDEX IF NOT EXISTS idx_metadata_edges_from ON metadata_edges(from_key, edge_type);
+      CREATE INDEX IF NOT EXISTS idx_metadata_edges_to ON metadata_edges(to_key, edge_type);
+
+      CREATE TABLE IF NOT EXISTS context_packs (
+        id               TEXT PRIMARY KEY,
+        question         TEXT NOT NULL,
+        focus_object_key TEXT,
+        mode             TEXT NOT NULL,
+        trust_label      TEXT NOT NULL,
+        payload_json     TEXT NOT NULL DEFAULT '{}',
+        created_at       TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_context_packs_created ON context_packs(created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_context_packs_focus ON context_packs(focus_object_key);
+
+      CREATE TABLE IF NOT EXISTS query_runs (
+        id           TEXT PRIMARY KEY,
+        object_key   TEXT,
+        source       TEXT NOT NULL,
+        status       TEXT NOT NULL,
+        row_count    INTEGER,
+        duration_ms  INTEGER,
+        error_code   TEXT,
+        payload_json TEXT NOT NULL DEFAULT '{}',
+        created_at   TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_query_runs_object ON query_runs(object_key, created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_query_runs_created ON query_runs(created_at DESC);
+
+      CREATE TABLE IF NOT EXISTS runtime_schema_snapshots (
+        id           TEXT PRIMARY KEY,
+        source       TEXT,
+        payload_json TEXT NOT NULL DEFAULT '{}',
+        captured_at  TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_runtime_schema_snapshots_captured ON runtime_schema_snapshots(captured_at DESC);
+
+      CREATE TABLE IF NOT EXISTS metadata_state (
+        key   TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS metadata_diagnostics (
+        id         TEXT PRIMARY KEY,
+        kind       TEXT NOT NULL,
+        severity   TEXT NOT NULL CHECK (severity IN ('error', 'warning')),
+        message    TEXT NOT NULL,
+        object_key TEXT,
+        file_path  TEXT,
+        created_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_metadata_diagnostics_severity ON metadata_diagnostics(severity);
+    `);
+    }
+    rebuild(snapshot) {
+        const now = new Date().toISOString();
+        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 setState = this.db.prepare(`
+      INSERT OR REPLACE INTO metadata_state (key, value) VALUES (?, ?)
+    `);
+        const txn = this.db.transaction(() => {
+            this.db.prepare('DELETE FROM metadata_edges').run();
+            this.db.prepare('DELETE FROM metadata_fts').run();
+            this.db.prepare('DELETE FROM metadata_objects').run();
+            this.db.prepare('DELETE FROM metadata_diagnostics').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));
+            }
+            for (const edge of snapshot.edges) {
+                insertEdge.run(edge.edgeType, edge.fromKey, edge.toKey, edge.confidence ?? 1, JSON.stringify(edge.payload ?? {}), now);
+            }
+            for (const diagnostic of snapshot.diagnostics) {
+                insertDiagnostic.run(diagnosticId(diagnostic), diagnostic.kind, diagnostic.severity, diagnostic.message, diagnostic.objectKey ?? null, diagnostic.filePath ?? null, now);
+            }
+            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('diagnostics_json', JSON.stringify(snapshot.diagnostics));
+            setState.run('manifest_generated_at', snapshot.manifest.generatedAt);
+        });
+        txn();
+    }
+    searchObjects(options) {
+        const { query, objectTypes, domain, limit = 40 } = options;
+        const sanitized = sanitizeFtsQuery(query);
+        if (!sanitized)
+            return this.listObjects({ objectTypes, domain, limit });
+        const filters = [];
+        const params = [sanitized];
+        if (objectTypes && objectTypes.length > 0) {
+            filters.push(`o.object_type IN (${objectTypes.map(() => '?').join(', ')})`);
+            params.push(...objectTypes);
+        }
+        if (domain) {
+            filters.push('o.domain = ?');
+            params.push(domain);
+        }
+        const whereExtra = filters.length > 0 ? ` AND ${filters.join(' AND ')}` : '';
+        const rows = this.db.prepare(`
+      SELECT o.*,
+             bm25(metadata_fts) AS rank,
+             snippet(metadata_fts, -1, '<mark>', '</mark>', '...', 12) AS snip
+      FROM metadata_fts
+      JOIN metadata_objects AS o ON o.object_key = metadata_fts.object_key
+      WHERE metadata_fts MATCH ?${whereExtra}
+      ORDER BY rank
+      LIMIT ?
+    `).all(...params, limit);
+        return rows.map((row) => ({
+            ...rowToObject(row),
+            score: row.rank ? 1 / (1 + Math.max(0, row.rank)) : 1,
+            snippet: row.snip ?? undefined,
+        }));
+    }
+    listObjects(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 updated_at DESC, name
+      LIMIT ?
+    `).all(...params, options.limit ?? 100);
+        return rows.map(rowToObject);
+    }
+    getObject(objectKey) {
+        const row = this.db.prepare('SELECT * FROM metadata_objects WHERE object_key = ?').get(objectKey);
+        return row ? rowToObject(row) : null;
+    }
+    getObjectsByKeys(keys) {
+        const unique = Array.from(new Set(keys.filter(Boolean)));
+        if (unique.length === 0)
+            return [];
+        const rows = [];
+        for (let i = 0; i < unique.length; i += 100) {
+            const chunk = unique.slice(i, i + 100);
+            const fetched = this.db.prepare(`
+        SELECT * FROM metadata_objects
+        WHERE object_key IN (${chunk.map(() => '?').join(', ')})
+        ORDER BY name
+      `).all(...chunk);
+            rows.push(...fetched.map(rowToObject));
+        }
+        return rows;
+    }
+    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);
+            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);
+            for (const row of rows) {
+                const edge = rowToEdge(row);
+                const edgeKey = `${edge.edgeType}\u0000${edge.fromKey}\u0000${edge.toKey}`;
+                if (!edges.has(edgeKey))
+                    edges.set(edgeKey, edge);
+                for (const key of [edge.fromKey, edge.toKey]) {
+                    if (!seenKeys.has(key)) {
+                        seenKeys.add(key);
+                        frontier.add(key);
+                    }
+                }
+            }
+        }
+        return Array.from(edges.values());
+    }
+    insertContextPack(pack) {
+        const id = `ctx_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+        const now = new Date().toISOString();
+        this.db.prepare(`
+      INSERT INTO context_packs (
+        id, question, focus_object_key, mode, trust_label, payload_json, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(id, pack.question, pack.focusObjectKey, pack.mode, pack.trustLabel, JSON.stringify(pack), now);
+        return id;
+    }
+    recordQueryRun(run) {
+        const id = run.id ?? `run_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+        const createdAt = run.createdAt ?? new Date().toISOString();
+        this.db.prepare(`
+      INSERT OR REPLACE INTO query_runs (
+        id, object_key, source, status, row_count, duration_ms, error_code, payload_json, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, run.objectKey ?? null, run.source, run.status, run.rowCount ?? null, run.durationMs ?? null, run.errorCode ?? null, JSON.stringify(run.payload ?? {}), createdAt);
+        return { ...run, id, createdAt };
+    }
+    queryRunsForObjectKeys(keys, limit = 20) {
+        const unique = Array.from(new Set(keys.filter(Boolean)));
+        if (unique.length === 0)
+            return [];
+        const rows = this.db.prepare(`
+      SELECT * FROM query_runs
+      WHERE object_key IN (${unique.slice(0, 80).map(() => '?').join(', ')})
+      ORDER BY created_at DESC
+      LIMIT ?
+    `).all(...unique.slice(0, 80), limit);
+        return rows.map(rowToQueryRun);
+    }
+    recordRuntimeSchemaSnapshot(snapshot) {
+        const capturedAt = snapshot.capturedAt ?? new Date().toISOString();
+        const cleanSnapshot = {
+            source: snapshot.source,
+            capturedAt,
+            tables: normalizeRuntimeSchemaTables(snapshot.tables).slice(0, 500),
+        };
+        const id = `schema_${Date.parse(capturedAt) || Date.now()}`;
+        this.db.prepare(`
+      INSERT OR REPLACE INTO runtime_schema_snapshots (
+        id, source, payload_json, captured_at
+      ) VALUES (?, ?, ?, ?)
+    `).run(id, cleanSnapshot.source ?? null, JSON.stringify(cleanSnapshot), capturedAt);
+        return cleanSnapshot;
+    }
+    latestRuntimeSchemaSnapshot() {
+        const row = this.db.prepare(`
+      SELECT payload_json
+      FROM runtime_schema_snapshots
+      ORDER BY captured_at DESC
+      LIMIT 1
+    `).get();
+        return row ? safeRuntimeSchemaSnapshot(safeJson(row.payload_json, null)) : null;
+    }
+    getContextPack(id) {
+        const row = this.db.prepare('SELECT payload_json FROM context_packs WHERE id = ?').get(id);
+        if (!row)
+            return null;
+        const payload = safeJson(row.payload_json, null);
+        return payload ? { ...payload, id } : null;
+    }
+    objectCount() {
+        const row = this.db.prepare('SELECT COUNT(*) AS n FROM metadata_objects').get();
+        return row.n;
+    }
+    edgeCount() {
+        const row = this.db.prepare('SELECT COUNT(*) AS n FROM metadata_edges').get();
+        return row.n;
+    }
+    diagnostics() {
+        const rows = this.db.prepare(`
+      SELECT kind, severity, message, object_key, file_path
+      FROM metadata_diagnostics
+      ORDER BY severity, kind, message
+    `).all();
+        return rows.map((row) => ({
+            kind: row.kind,
+            severity: row.severity,
+            message: row.message,
+            objectKey: row.object_key ?? undefined,
+            filePath: row.file_path ?? undefined,
+        }));
+    }
+    state(key) {
+        const row = this.db.prepare('SELECT value FROM metadata_state WHERE key = ?').get(key);
+        return row?.value ?? null;
+    }
+    close() {
+        this.db.close();
+    }
+}
+function loadAgentManifest(projectRoot) {
+    return buildManifest({
+        projectRoot,
+        dbtManifestPath: resolveDbtManifestPath(projectRoot) ?? undefined,
+    });
+}
+function loadAgentSemanticLayer(projectRoot) {
+    try {
+        const config = loadProjectConfig(projectRoot);
+        const semanticConfig = config.semanticLayer?.provider
+            ? config.semanticLayer
+            : config.semanticLayer?.path
+                ? { provider: 'dql', path: config.semanticLayer.path }
+                : undefined;
+        const configured = resolveSemanticLayerWithDiagnostics(semanticConfig, projectRoot).layer;
+        if (configured)
+            return configured;
+        if (config.dbt?.projectDir) {
+            return resolveSemanticLayerWithDiagnostics({
+                provider: 'dbt',
+                projectPath: config.dbt.projectDir,
+            }, projectRoot).layer ?? undefined;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+function manifestDiagnosticToMetadataDiagnostic(diagnostic) {
+    return {
+        kind: diagnostic.kind,
+        severity: diagnostic.severity,
+        message: diagnostic.message,
+        filePath: diagnostic.filePath,
+    };
+}
+function objectFromKGNode(node) {
+    const payload = {
+        kgNodeId: node.nodeId,
+        tags: node.tags ?? [],
+        examples: node.examples ?? [],
+        sourceTier: node.sourceTier,
+        certification: node.certification,
+        provenance: node.provenance,
+        freshness: node.freshness,
+        businessOutcome: node.businessOutcome,
+        businessOwner: node.businessOwner,
+        decisionUse: node.decisionUse,
+        reviewCadence: node.reviewCadence,
+        businessRules: node.businessRules ?? [],
+        caveats: node.caveats ?? [],
+        llmContext: node.llmContext,
+    };
+    return {
+        objectKey: objectKeyFromKGNode(node),
+        objectType: objectTypeFromKGNode(node),
+        name: node.name,
+        fullName: node.name,
+        domain: node.domain,
+        owner: node.owner,
+        status: node.status ?? node.certification,
+        description: node.description ?? node.llmContext,
+        sourcePath: node.sourcePath,
+        sourceSystem: node.provenance ?? node.sourceTier,
+        payload: compactObject(payload),
+    };
+}
+function objectKeyFromKGNode(node) {
+    switch (node.kind) {
+        case 'block': return `dql:block:${node.name}`;
+        case 'term': return `dql:term:${node.name}`;
+        case 'business_view': return `dql:business_view:${node.name}`;
+        case 'metric': return `semantic:metric:${node.name}`;
+        case 'dimension': return `semantic:dimension:${node.name}`;
+        case 'measure': return `semantic:measure:${node.name}`;
+        case 'entity': return `semantic:entity:${node.name}`;
+        case 'semantic_model': return `semantic:model:${node.name}`;
+        case 'saved_query': return `semantic:saved_query:${node.name}`;
+        case 'dbt_model': return `dbt:model:${node.name}`;
+        case 'dbt_source':
+            return node.sourceTier === 'dbt_manifest'
+                ? `dbt:source:${node.name}`
+                : `warehouse:table:${node.name}`;
+        case 'notebook': return `notebook:${node.name}`;
+        case 'dashboard': return `dashboard:${node.name}`;
+        case 'app': return `app:${node.name}`;
+        case 'domain': return `domain:${node.name}`;
+        default: return `${node.kind}:${node.name}`;
+    }
+}
+function objectTypeFromKGNode(node) {
+    switch (node.kind) {
+        case 'block': return 'dql_block';
+        case 'term': return 'dql_term';
+        case 'business_view': return 'business_view';
+        case 'metric': return 'semantic_metric';
+        case 'dimension': return 'semantic_dimension';
+        case 'measure': return 'semantic_measure';
+        case 'entity': return 'semantic_entity';
+        case 'semantic_model': return 'semantic_model';
+        case 'saved_query': return 'semantic_saved_query';
+        case 'dbt_model': return 'dbt_model';
+        case 'dbt_source': return node.sourceTier === 'dbt_manifest' ? 'dbt_source' : 'warehouse_table';
+        case 'notebook': return 'notebook';
+        case 'dashboard': return 'dashboard';
+        case 'app': return 'app';
+        case 'domain': return 'domain';
+        default: return node.kind;
+    }
+}
+function normalizeEdge(edge, fromKey, toKey) {
+    return {
+        edgeType: edge.kind,
+        fromKey,
+        toKey,
+        confidence: edge.weight ?? 1,
+        payload: { kgSource: edge.src, kgTarget: edge.dst },
+    };
+}
+function addDbtDagObjects(manifest, objects, edges, diagnostics) {
+    const models = manifest.dbtImport?.dbtDag?.models ?? [];
+    for (const model of models) {
+        const objectType = model.type === 'source' ? 'dbt_source' : 'dbt_model';
+        const objectKey = `dbt:${model.type}:${model.name}`;
+        const relation = [model.database, model.schema, model.name].filter(Boolean).join('.');
+        const object = {
+            objectKey,
+            objectType,
+            name: model.name,
+            fullName: relation || model.name,
+            description: model.description,
+            status: 'dbt_imported',
+            sourceSystem: 'dbt manifest.json',
+            payload: compactObject({
+                uniqueId: model.uniqueId,
+                relation,
+                database: model.database,
+                schema: model.schema,
+                materialized: model.materialized,
+                dependsOn: model.dependsOn,
+                columns: model.columns ?? [],
+            }),
+        };
+        objects.set(objectKey, mergeObject(objects.get(objectKey), object));
+        for (const column of model.columns ?? []) {
+            const columnKey = `dbt:column:${model.name}.${column.name}`;
+            objects.set(columnKey, mergeObject(objects.get(columnKey), {
+                objectKey: columnKey,
+                objectType: 'dbt_column',
+                name: column.name,
+                fullName: `${model.name}.${column.name}`,
+                description: column.description,
+                status: 'dbt_imported',
+                sourceSystem: 'dbt manifest.json',
+                payload: compactObject({
+                    model: model.name,
+                    uniqueId: model.uniqueId,
+                    type: column.type,
+                    relation,
+                }),
+            }));
+            const edge = {
+                edgeType: 'contains',
+                fromKey: objectKey,
+                toKey: columnKey,
+                confidence: 1,
+                payload: { source: 'dbt manifest column' },
+            };
+            edges.set(`${edge.edgeType}\u0000${edge.fromKey}\u0000${edge.toKey}`, edge);
+        }
+        for (const dep of model.dependsOn ?? []) {
+            const edge = {
+                edgeType: 'depends_on',
+                fromKey: objectKey,
+                toKey: dbtDependencyKey(dep),
+                confidence: 1,
+                payload: { source: 'dbt manifest depends_on', uniqueId: dep },
+            };
+            edges.set(`${edge.edgeType}\u0000${edge.fromKey}\u0000${edge.toKey}`, edge);
+        }
+    }
+    if (manifest.dbtImport && (manifest.dbtImport.totalDbtModels ?? 0) > 0 && manifest.dbtImport.modelsImported === 0) {
+        diagnostics.push({
+            kind: 'dbt',
+            severity: 'warning',
+            message: `dbt manifest loaded from ${manifest.dbtImport.manifestPath}, but 0 of ${manifest.dbtImport.totalDbtModels} models matched DQL table references. Check database/schema aliases or dbtImport anchors.`,
+        });
+    }
+}
+function addManifestBlockDetails(manifest, objects) {
+    for (const block of Object.values(manifest.blocks ?? {})) {
+        const objectKey = `dql:block:${block.name}`;
+        const existing = objects.get(objectKey);
+        if (!existing)
+            continue;
+        objects.set(objectKey, mergeObject(existing, {
+            ...existing,
+            payload: compactObject({
+                ...(existing.payload ?? {}),
+                sql: block.sql,
+                tableDependencies: block.tableDependencies,
+                rawTableRefs: block.rawTableRefs,
+                refDependencies: block.refDependencies,
+                metricRefs: block.metricRefs,
+                dimensionRefs: block.dimensionRefs,
+                chartType: block.chartType,
+                blockType: block.blockType,
+                tests: block.tests,
+            }),
+        }));
+    }
+}
+function addBlockDependencyEdges(manifest, edges) {
+    const dbtLookup = buildDbtModelLookup(manifest);
+    for (const block of Object.values(manifest.blocks ?? {})) {
+        const blockKey = `dql:block:${block.name}`;
+        for (const table of block.tableDependencies ?? []) {
+            const tableKey = `warehouse:table:${table}`;
+            putEdge(edges, {
+                edgeType: 'uses_table',
+                fromKey: blockKey,
+                toKey: tableKey,
+                confidence: 1,
+                payload: { source: 'dql block table dependency', tableReference: table },
+            });
+            const dbtKey = resolveDbtModelKeyForTable(table, dbtLookup);
+            if (!dbtKey)
+                continue;
+            putEdge(edges, {
+                edgeType: 'uses_dbt_model',
+                fromKey: blockKey,
+                toKey: dbtKey,
+                confidence: 0.86,
+                payload: { source: 'dql table dependency matched to dbt model', tableReference: table },
+            });
+            putEdge(edges, {
+                edgeType: 'maps_to_dbt_model',
+                fromKey: tableKey,
+                toKey: dbtKey,
+                confidence: 0.86,
+                payload: { source: 'warehouse table name matched to dbt model', tableReference: table },
+            });
+        }
+    }
+}
+function putEdge(edges, edge) {
+    edges.set(`${edge.edgeType}\u0000${edge.fromKey}\u0000${edge.toKey}`, edge);
+}
+function buildDbtModelLookup(manifest) {
+    const lookup = new Map();
+    const add = (key, objectKey) => {
+        const normalized = key.toLowerCase();
+        const existing = lookup.get(normalized);
+        if (existing)
+            existing.add(objectKey);
+        else
+            lookup.set(normalized, new Set([objectKey]));
+    };
+    for (const model of manifest.dbtImport?.dbtDag?.models ?? []) {
+        if (model.type !== 'model')
+            continue;
+        const objectKey = `dbt:model:${model.name}`;
+        for (const key of dbtModelLookupKeys(model.name, model.schema, model.database)) {
+            add(key, objectKey);
+        }
+    }
+    return lookup;
+}
+function resolveDbtModelKeyForTable(tableRef, lookup) {
+    for (const key of tableReferenceLookupKeys(tableRef)) {
+        const matches = lookup.get(key);
+        if (matches?.size === 1)
+            return [...matches][0];
+    }
+    return undefined;
+}
+function dbtModelLookupKeys(name, schema, database) {
+    const aliases = new Set([name.toLowerCase()]);
+    const stripped = stripCommonDbtPrefix(name);
+    if (stripped)
+        aliases.add(stripped);
+    const keys = new Set();
+    for (const alias of aliases) {
+        keys.add(alias);
+        if (schema)
+            keys.add(`${schema}.${alias}`.toLowerCase());
+        if (schema && database)
+            keys.add(`${database}.${schema}.${alias}`.toLowerCase());
+    }
+    return [...keys];
+}
+function tableReferenceLookupKeys(tableRef) {
+    const normalized = tableRef.replace(/["`]/g, '').toLowerCase();
+    const parts = normalized.split('.').filter(Boolean);
+    const keys = new Set([normalized]);
+    if (parts.length >= 2)
+        keys.add(parts.slice(-2).join('.'));
+    const last = parts.at(-1);
+    if (last)
+        keys.add(last);
+    return [...keys];
+}
+function stripCommonDbtPrefix(name) {
+    const match = /^(?:src|stg|int|dim|fct)_(.+)$/i.exec(name);
+    return match?.[1]?.toLowerCase();
+}
+function dbtDependencyKey(uniqueId) {
+    const parts = uniqueId.split('.');
+    const kind = parts[0] === 'source' ? 'source' : 'model';
+    const name = parts.at(-1) ?? uniqueId;
+    return `dbt:${kind}:${name}`;
+}
+function addProjectDiagnostics(manifest, semanticLayer, diagnostics) {
+    const semanticCount = Object.keys(manifest.metrics ?? {}).length +
+        Object.keys(manifest.dimensions ?? {}).length +
+        (semanticLayer?.listMetrics().length ?? 0) +
+        (semanticLayer?.listDimensions().length ?? 0) +
+        (semanticLayer?.listSemanticModels().length ?? 0);
+    if (semanticCount === 0) {
+        diagnostics.push({
+            kind: 'semantic',
+            severity: 'warning',
+            message: 'No semantic metrics or dimensions were found. Agents can use DQL/dbt/warehouse metadata, but semantic metric answers require metric definitions.',
+        });
+    }
+}
+function planContextPackRoute(input) {
+    const intent = input.request.intent ?? classifyMetadataIntent(input.request.question, input.request.followUp);
+    const exact = findExactCertifiedObject(input.request.question, intent, input.objects);
+    const missingContext = buildMissingContext(input.request, intent, input.objects, input.allowedSqlContext);
+    const selectedEvidence = input.evidenceRoles.slice(0, 16);
+    if (exact && (intent === 'exact_certified_lookup'
+        || intent === 'definition_lookup'
+        || (intent === 'ad_hoc_ranking' && objectNameInQuestion(input.request.question, exact)))) {
+        return {
+            route: 'certified',
+            intent,
+            reason: `Certified ${exact.objectType.replace(/_/g, ' ')} "${exact.name}" exactly matches the requested artifact, definition, or direct KPI grain.`,
+            trustLabel: 'certified',
+            reviewStatus: 'certified',
+            exactObjectKey: exact.objectKey,
+            selectedEvidence,
+            missingContext: [],
+            followUps: buildMetadataFollowUps(intent, input.allowedSqlContext),
+        };
+    }
+    if (intent === 'trust_gap_review') {
+        if (input.objects.length === 0) {
+            return clarifyDecision(intent, input.trustLabel, selectedEvidence, [{
+                    kind: 'metadata',
+                    severity: 'blocking',
+                    message: 'No local metadata matched this trust question. Re-run dql compile or connect the relevant DQL/dbt project before reviewing trust.',
+                }]);
+        }
+        return {
+            route: 'research',
+            intent,
+            reason: 'Trust questions need a certification, lineage, owner, caveat, and diagnostic review rather than a metric SQL preview.',
+            trustLabel: input.trustLabel,
+            reviewStatus: 'needs_review',
+            selectedEvidence,
+            missingContext,
+            followUps: buildMetadataFollowUps(intent, input.allowedSqlContext),
+        };
+    }
+    if (intent === 'clarify' || missingContext.some((item) => item.severity === 'blocking')) {
+        return clarifyDecision(intent, input.trustLabel, selectedEvidence, missingContext);
+    }
+    const canGenerate = input.allowedSqlContext.relations.length > 0 ||
+        input.allowedSqlContext.sourceBlockSql.length > 0 ||
+        input.objects.some((object) => object.objectType.startsWith('semantic_'));
+    if (canGenerate && isGeneratedMetadataIntent(intent)) {
+        return {
+            route: 'generated_sql',
+            intent,
+            reason: 'The question asks for a different grain, ranking, breakdown, comparison, entity drilldown, or diagnostic analysis, so certified artifacts are context only.',
+            trustLabel: input.trustLabel === 'certified' ? 'mixed' : input.trustLabel,
+            reviewStatus: 'draft_ready',
+            selectedEvidence,
+            missingContext,
+            followUps: buildMetadataFollowUps(intent, input.allowedSqlContext),
+        };
+    }
+    if (exact) {
+        return {
+            route: 'certified',
+            intent: 'exact_certified_lookup',
+            reason: `Certified artifact "${exact.name}" is the closest safe direct answer.`,
+            trustLabel: 'certified',
+            reviewStatus: 'certified',
+            exactObjectKey: exact.objectKey,
+            selectedEvidence,
+            missingContext: [],
+            followUps: buildMetadataFollowUps('exact_certified_lookup', input.allowedSqlContext),
+        };
+    }
+    return clarifyDecision(intent, input.trustLabel, selectedEvidence, missingContext.length > 0 ? missingContext : [{
+            kind: 'metadata',
+            severity: 'blocking',
+            message: 'The local metadata matched some context, but not enough to choose a safe metric, table, or grain.',
+        }]);
+}
+function clarifyDecision(intent, trustLabel, selectedEvidence, missingContext) {
+    return {
+        route: 'clarify',
+        intent,
+        reason: 'DQL needs one more business or metadata detail before it can safely generate SQL.',
+        trustLabel,
+        reviewStatus: 'none',
+        selectedEvidence,
+        missingContext: missingContext.length > 0 ? missingContext : [{
+                kind: 'metadata',
+                severity: 'blocking',
+                message: 'No certified block, semantic metric, dbt model, or runtime schema matched strongly enough to answer safely.',
+            }],
+        followUps: [
+            'Which metric should define the answer?',
+            'Which table or certified block should be used as the source?',
+            'What filter or time period should apply?',
+        ],
+    };
+}
+function classifyMetadataIntent(question, followUp) {
+    const follow = followUp && typeof followUp === 'object' ? followUp : null;
+    if (follow?.kind === 'drilldown')
+        return 'entity_drilldown';
+    const lower = question.toLowerCase();
+    if (/\b(trust|rely|certif|lineage|owner|caveat|gap|governance)\b/.test(lower))
+        return 'trust_gap_review';
+    if (/\b(define|definition|meaning of|what is|what are|what does .+ mean)\b/.test(lower))
+        return 'definition_lookup';
+    if (/\b(anomal|exception|outlier|spike|dip)\b/.test(lower))
+        return 'anomaly_investigation';
+    if (/\b(compare|versus|vs\.?|segment|cohort)\b/.test(lower))
+        return 'segment_compare';
+    if (/\b(why|changed?|change|drop|dropped|decline|declined|increase|increased|decrease|decreased|delta|variance|what happened)\b/.test(lower))
+        return 'diagnose_change';
+    if (/\b(driver|drivers|drove|break\s*down|breakdown|contribute|contribution|top movers?)\b/.test(lower))
+        return 'driver_breakdown';
+    if (isEntityQuestion(question))
+        return 'entity_drilldown';
+    if (/\b(top|bottom|best|worst|highest|lowest|least|fewest|minimum|min|maximum|max|rank|ranking|most)\b/.test(lower))
+        return 'ad_hoc_ranking';
+    if (/\b(block|certified|saved|existing|approved|governed)\b/.test(lower))
+        return 'exact_certified_lookup';
+    if (/\b(show|list|find|which|who|how many|how much|metric|kpi|dashboard|performance|revenue|sales|points|goals|orders|customers|users)\b/.test(lower))
+        return 'ad_hoc_ranking';
+    return 'clarify';
+}
+function isGeneratedMetadataIntent(intent) {
+    return intent === 'ad_hoc_ranking'
+        || intent === 'driver_breakdown'
+        || intent === 'diagnose_change'
+        || intent === 'segment_compare'
+        || intent === 'entity_drilldown'
+        || intent === 'anomaly_investigation';
+}
+function findExactCertifiedObject(question, intent, objects) {
+    const candidates = objects.filter((object) => isCertifiedMetadataObject(object));
+    if (intent === 'definition_lookup') {
+        return candidates.find((object) => object.objectType === 'dql_term' || object.objectType === 'business_view')
+            ?? candidates.find((object) => object.objectType === 'dql_block' && objectNameInQuestion(question, object));
+    }
+    const namedExact = candidates.find((object) => object.objectType === 'dql_block' &&
+        objectNameInQuestion(question, object) &&
+        hasCompatibleMetadataRankingDirection(question, object));
+    if (namedExact)
+        return namedExact;
+    if (isGeneratedMetadataIntent(intent))
+        return undefined;
+    return candidates.find((object) => object.objectType === 'dql_block' &&
+        objectNameInQuestion(question, object) &&
+        hasCompatibleMetadataRankingDirection(question, object)) ?? candidates.find((object) => object.objectType === 'dql_block' &&
+        hasMeaningfulObjectOverlap(question, object) &&
+        hasCompatibleMetadataRankingDirection(question, object) &&
+        !looksLikeDifferentGrainQuestion(question));
+}
+function isCertifiedMetadataObject(object) {
+    return object.status === 'certified' || object.status === 'approved' || object.payload?.certification === 'certified';
+}
+function objectNameInQuestion(question, object) {
+    const q = normalizeSearchText(question);
+    const name = normalizeSearchText(object.name);
+    const fullName = normalizeSearchText(object.fullName ?? '');
+    return Boolean(name && q.includes(name)) || Boolean(fullName && q.includes(fullName));
+}
+function hasMeaningfulObjectOverlap(question, object) {
+    const terms = new Set(tokenize(question));
+    if (terms.size === 0)
+        return false;
+    const haystack = tokenize([
+        object.name,
+        object.fullName ?? '',
+        object.domain ?? '',
+        object.description ?? '',
+        JSON.stringify(object.payload ?? {}),
+    ].join(' '));
+    return haystack.some((term) => terms.has(term));
+}
+function looksLikeDifferentGrainQuestion(question) {
+    return /\b(for|where|only|specific|single|individual|named|called|by|break\s*down|breakdown|drill|compare|versus|vs\.?|segment|least|lowest|fewest|bottom|why|changed?|driver|anomal|exception)\b/i.test(question);
+}
+function hasCompatibleMetadataRankingDirection(question, object) {
+    const questionDirection = rankingDirection(question);
+    if (!questionDirection)
+        return true;
+    const objectDirection = rankingDirection([
+        object.name,
+        object.description ?? '',
+        JSON.stringify(object.payload ?? {}),
+    ].join(' '));
+    if (!objectDirection)
+        return true;
+    return questionDirection === objectDirection;
+}
+function rankingDirection(text) {
+    const lower = text.toLowerCase();
+    const bottom = /\b(bottom|least|fewest|lowest|minimum|min|smallest|worst|underperform(?:ing|ed|er|ers)?)\b/.test(lower);
+    const top = /\b(top|most|highest|maximum|max|greatest|best|leader|leaders|leading)\b/.test(lower);
+    if (bottom && !top)
+        return 'bottom';
+    if (top && !bottom)
+        return 'top';
+    return undefined;
+}
+function buildMissingContext(request, intent, objects, allowedSqlContext) {
+    const missing = [];
+    const hasSqlContext = allowedSqlContext.relations.length > 0 || allowedSqlContext.sourceBlockSql.length > 0;
+    if (isGeneratedMetadataIntent(intent) && !hasSqlContext && !objects.some((object) => object.objectType.startsWith('semantic_'))) {
+        missing.push({
+            kind: 'table',
+            severity: 'blocking',
+            message: 'No dbt model, warehouse/runtime table, semantic metric, or certified block SQL was available for this generated answer.',
+        });
+    }
+    if (intent === 'diagnose_change' && !hasComparableBaselineContext(request, objects, allowedSqlContext)) {
+        missing.push({
+            kind: 'baseline',
+            severity: 'blocking',
+            message: 'No comparable time/baseline field or selected tile history was found, so DQL needs the baseline period before explaining what changed.',
+        });
+    }
+    if ((intent === 'definition_lookup' || intent === 'trust_gap_review') && objects.length === 0) {
+        missing.push({
+            kind: 'metadata',
+            severity: 'blocking',
+            message: 'No certified term, business view, block, dashboard, app, or lineage metadata matched this question.',
+        });
+    }
+    return missing;
+}
+function hasComparableBaselineContext(request, objects, allowedSqlContext) {
+    if (request.focusObjectKey) {
+        const focus = objects.find((object) => object.objectKey === request.focusObjectKey);
+        if (focus) {
+            const dependencyKeys = new Set([
+                ...metadataStringArray(focus.payload?.tableDependencies),
+                ...metadataStringArray(focus.payload?.rawTableRefs),
+            ].flatMap((relation) => relationLookupKeysForCatalog(relation)));
+            const focusedRelations = dependencyKeys.size > 0
+                ? allowedSqlContext.relations.filter((relation) => relationLookupKeysForCatalog(relation.relation).some((key) => dependencyKeys.has(key)))
+                : [];
+            const focusTextHasBaseline = /\b(date|time|day|week|month|quarter|year|season|period|baseline|history|snapshot)\b/i.test([
+                focus.name,
+                focus.description ?? '',
+                String(focus.payload?.sql ?? ''),
+            ].join(' '));
+            return focusTextHasBaseline || focusedRelations.some((relation) => relation.columns.some((column) => isTimeLikeColumn(column.name)));
+        }
+    }
+    if (allowedSqlContext.relations.some((relation) => relation.columns.some((column) => isTimeLikeColumn(column.name))))
+        return true;
+    const rows = selectedRows(request.selectedContext);
+    if (rows.length < 2)
+        return false;
+    const columns = new Set(rows.flatMap((row) => Object.keys(row)));
+    for (const column of columns) {
+        if (!isTimeLikeColumn(column))
+            continue;
+        const values = new Set(rows.map((row) => row[column]).filter((value) => value !== null && value !== undefined).map(String));
+        if (values.size >= 2)
+            return true;
+    }
+    return false;
+}
+function relationLookupKeysForCatalog(relation) {
+    const normalized = normalizeRelationKey(relation);
+    const parts = normalized.split('.').filter(Boolean);
+    const keys = new Set();
+    if (normalized)
+        keys.add(normalized);
+    if (parts.length >= 2)
+        keys.add(parts.slice(-2).join('.'));
+    if (parts.length >= 1)
+        keys.add(parts[parts.length - 1]);
+    return Array.from(keys);
+}
+function isTimeLikeColumn(name) {
+    return /\b(date|time|day|week|month|quarter|year|season|period|created_at|updated_at)\b/i.test(name);
+}
+function selectedRows(value) {
+    const root = normalizeSelectedContextRoot(value);
+    const selected = root?.selectedBlock && typeof root.selectedBlock === 'object' ? root.selectedBlock : root;
+    const candidates = [
+        selected?.resultSample,
+        selected?.rows,
+        selected?.sampleRows,
+        root?.resultSample,
+        root?.rows,
+    ];
+    for (const candidate of candidates) {
+        if (!Array.isArray(candidate))
+            continue;
+        return candidate.filter((row) => Boolean(row) && typeof row === 'object' && !Array.isArray(row));
+    }
+    return [];
+}
+function buildMetadataFollowUps(intent, allowedSqlContext) {
+    if (intent === 'clarify')
+        return ['Pick the metric', 'Pick the source table', 'Pick the time window'];
+    if (intent === 'trust_gap_review')
+        return ['Show lineage', 'List caveats', 'Create a certified replacement block'];
+    const relation = allowedSqlContext.relations[0];
+    const dimension = relation?.columns.find((column) => /(segment|type|name|team|player|customer|product|region)/i.test(column.name))?.name ?? 'segment';
+    return [
+        `Break down by ${dimension}`,
+        'Show the trend over time',
+        'Save as a draft block for review',
+    ];
+}
+function buildEvidenceRoles(objects, queryRuns) {
+    const roles = objects.slice(0, 40).map((object) => ({
+        objectKey: object.objectKey,
+        objectType: object.objectType,
+        name: object.name,
+        role: evidenceRoleForObject(object),
+        reason: evidenceReasonForObject(object),
+    }));
+    for (const run of queryRuns.slice(0, 8)) {
+        if (!run.objectKey)
+            continue;
+        roles.push({
+            objectKey: run.objectKey,
+            objectType: 'query_run',
+            name: run.payload?.question && typeof run.payload.question === 'string' ? run.payload.question : run.id,
+            role: 'prior_query_run',
+            reason: `Prior query run status: ${run.status}`,
+        });
+    }
+    return roles;
+}
+function evidenceRoleForObject(object) {
+    if (object.objectType === 'dql_block' && isCertifiedMetadataObject(object))
+        return 'certified_context';
+    if (object.objectType === 'semantic_metric')
+        return 'semantic_metric';
+    if (object.objectType === 'dql_term' || object.objectType === 'business_view')
+        return 'business_context';
+    if (object.objectType === 'dbt_model' || object.objectType === 'dbt_source' || object.objectType === 'dbt_column')
+        return 'dbt_model';
+    if (object.objectType === 'warehouse_table')
+        return 'warehouse_schema';
+    if (object.objectType === 'runtime_table' || object.objectType === 'runtime_column')
+        return 'runtime_schema';
+    if (object.objectType === 'selected_context')
+        return 'selected_context';
+    if (object.objectType === 'skill')
+        return 'skill_guidance';
+    return 'other';
+}
+function evidenceReasonForObject(object) {
+    if (object.objectType === 'dql_block' && isCertifiedMetadataObject(object))
+        return 'Certified block can be exact answer only when grain matches; otherwise it is context.';
+    if (object.objectType.startsWith('semantic_'))
+        return 'Semantic definition can ground metric and dimension meaning.';
+    if (object.objectType.startsWith('dbt_'))
+        return 'dbt metadata supplies physical model and column context.';
+    if (object.objectType === 'runtime_table' || object.objectType === 'runtime_column')
+        return 'Runtime schema supplies executable table and column context.';
+    return reasonForObject(object);
+}
+function buildAllowedSqlContext(objects, edges) {
+    const byRelation = new Map();
+    const addRelation = (relation) => {
+        const key = normalizeRelationKey(relation.relation);
+        if (!key)
+            return;
+        const existing = byRelation.get(key);
+        if (!existing) {
+            byRelation.set(key, { ...relation, columns: dedupeRuntimeColumns(relation.columns).slice(0, 120) });
+            return;
+        }
+        byRelation.set(key, {
+            ...existing,
+            objectKey: existing.objectKey ?? relation.objectKey,
+            source: existing.source === relation.source ? existing.source : 'local metadata catalog',
+            columns: dedupeRuntimeColumns([...existing.columns, ...relation.columns]).slice(0, 120),
+        });
+    };
+    for (const object of objects) {
+        const relation = metadataRelationFromObject(object);
+        if (relation)
+            addRelation(relation);
+        for (const table of metadataStringArray(object.payload?.tableDependencies)) {
+            addRelation({
+                relation: table,
+                name: table.split('.').at(-1) ?? table,
+                objectKey: object.objectKey,
+                source: 'certified block dependency',
+                columns: [],
+            });
+        }
+        for (const table of metadataStringArray(object.payload?.rawTableRefs)) {
+            addRelation({
+                relation: table,
+                name: table.split('.').at(-1) ?? table,
+                objectKey: object.objectKey,
+                source: 'certified block SQL reference',
+                columns: [],
+            });
+        }
+    }
+    const objectsByKey = new Map(objects.map((object) => [object.objectKey, object]));
+    for (const edge of edges) {
+        if (edge.edgeType !== 'maps_to_dbt_model' && edge.edgeType !== 'uses_dbt_model')
+            continue;
+        const from = objectsByKey.get(edge.fromKey);
+        const to = objectsByKey.get(edge.toKey);
+        const fromRelation = from ? metadataRelationFromObject(from) : null;
+        const toRelation = to ? metadataRelationFromObject(to) : null;
+        if (fromRelation && toRelation)
+            addRelation({ ...fromRelation, columns: toRelation.columns, source: 'dbt mapped warehouse table' });
+    }
+    return {
+        relations: Array.from(byRelation.values()).sort((a, b) => a.relation.localeCompare(b.relation)),
+        sourceBlockSql: objects
+            .filter((object) => object.objectType === 'dql_block' && typeof object.payload?.sql === 'string' && object.payload.sql.trim())
+            .slice(0, 8)
+            .map((object) => ({
+            objectKey: object.objectKey,
+            name: object.name,
+            status: object.status,
+            sql: String(object.payload?.sql ?? ''),
+        })),
+    };
+}
+function metadataRelationFromObject(object) {
+    if (object.objectType === 'dbt_column' || object.objectType === 'runtime_column') {
+        const relation = metadataPayloadString(object, 'relation');
+        if (!relation)
+            return null;
+        return {
+            relation,
+            name: relation.split('.').at(-1) ?? relation,
+            objectKey: object.objectKey,
+            source: object.objectType === 'runtime_column' ? 'runtime schema snapshot' : 'dbt manifest',
+            columns: [{
+                    name: object.name,
+                    type: metadataPayloadString(object, 'type') ?? metadataPayloadString(object, 'data_type'),
+                    description: object.description,
+                    sampleValues: metadataStringArray(object.payload?.sampleValues),
+                }],
+        };
+    }
+    if (!['dbt_model', 'dbt_source', 'warehouse_table', 'runtime_table'].includes(object.objectType))
+        return null;
+    const relation = metadataPayloadString(object, 'relation') ?? object.fullName ?? object.name;
+    return {
+        relation,
+        name: relation.split('.').at(-1) ?? object.name,
+        objectKey: object.objectKey,
+        source: object.objectType === 'runtime_table' ? 'runtime schema snapshot' : object.sourceSystem ?? 'local metadata catalog',
+        columns: metadataRuntimeColumns(object.payload?.columns),
+    };
+}
+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,
+                columns: table.columns,
+            }),
+            updatedAt: capturedAt,
+        };
+        const columns = table.columns.map((column) => ({
+            objectKey: `runtime:column:${relation}.${column.name}`,
+            objectType: 'runtime_column',
+            name: column.name,
+            fullName: `${relation}.${column.name}`,
+            description: column.description,
+            status: 'runtime_observed',
+            sourceSystem: snapshot.source ?? table.source ?? 'runtime schema snapshot',
+            payload: compactObject({
+                relation,
+                type: column.type,
+                sampleValues: column.sampleValues,
+            }),
+            updatedAt: capturedAt,
+        }));
+        return [tableObject, ...columns];
+    });
+}
+function selectedContextObjects(value) {
+    const root = normalizeSelectedContextRoot(value);
+    if (!root)
+        return [];
+    const selected = root.selectedBlock && typeof root.selectedBlock === 'object' ? root.selectedBlock : root;
+    const title = stringValue(selected.title) ?? stringValue(root.dashboardTitle) ?? stringValue(root.title) ?? 'Selected app context';
+    const objectKey = `selected:context:${sha256(stableStringify(selected)).slice(0, 16)}`;
+    return [{
+            objectKey,
+            objectType: 'selected_context',
+            name: title,
+            description: stringValue(selected.description) ?? stringValue(root.question),
+            status: stringValue(selected.certificationStatus) ?? stringValue(selected.reviewStatus),
+            sourceSystem: 'selected app/notebook context',
+            payload: compactObject({
+                tileId: selected.tileId,
+                blockId: selected.blockId,
+                blockPath: selected.blockPath,
+                dashboardTitle: root.dashboardTitle,
+                rowCount: selected.rowCount,
+                columns: selected.columns,
+                rows: selectedRows(root).slice(0, 20),
+            }),
+        }];
+}
+function selectedContextReferenceKeys(value, selectedObjects) {
+    const root = normalizeSelectedContextRoot(value);
+    const keys = new Set();
+    const addBlock = (blockId) => {
+        if (typeof blockId !== 'string')
+            return;
+        const name = blockId.replace(/^block:/i, '').trim();
+        if (name)
+            keys.add(`dql:block:${name}`);
+    };
+    if (root) {
+        const selected = root.selectedBlock && typeof root.selectedBlock === 'object' ? root.selectedBlock : root;
+        addBlock(selected.blockId);
+        addBlock(root.sourceBlockId);
+        addBlock(root.blockId);
+    }
+    for (const object of selectedObjects) {
+        addBlock(object.payload?.blockId);
+    }
+    return Array.from(keys);
+}
+function normalizeSelectedContextRoot(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const original = value;
+    const fromSql = typeof original.sql === 'string' ? parseJsonObject(original.sql) : null;
+    const root = fromSql ?? original;
+    const nested = root.context && typeof root.context === 'object' && !Array.isArray(root.context)
+        ? root.context
+        : null;
+    if (!nested)
+        return root;
+    return {
+        ...root,
+        ...nested,
+        requestTitle: root.title,
+        requestIntent: root.intent,
+        requestMode: root.mode,
+        context: nested,
+    };
+}
+function parseJsonObject(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed || (!trimmed.startsWith('{') && !trimmed.startsWith('[')))
+        return null;
+    try {
+        const parsed = JSON.parse(trimmed);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeRuntimeSchemaTables(tables) {
+    const byRelation = new Map();
+    for (const table of tables ?? []) {
+        if (!table?.relation)
+            continue;
+        const relation = table.relation.trim();
+        if (!relation)
+            continue;
+        const key = normalizeRelationKey(relation);
+        const current = byRelation.get(key);
+        const normalized = {
+            relation,
+            schema: table.schema,
+            name: table.name ?? relation.split('.').at(-1) ?? relation,
+            description: table.description,
+            source: table.source,
+            columns: dedupeRuntimeColumns(table.columns ?? []).slice(0, 160),
+        };
+        if (!current)
+            byRelation.set(key, normalized);
+        else
+            byRelation.set(key, {
+                ...current,
+                description: current.description ?? normalized.description,
+                columns: dedupeRuntimeColumns([...current.columns, ...normalized.columns]).slice(0, 160),
+            });
+    }
+    return Array.from(byRelation.values());
+}
+function safeRuntimeSchemaSnapshot(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const record = value;
+    if (!Array.isArray(record.tables))
+        return null;
+    return {
+        source: stringValue(record.source),
+        capturedAt: stringValue(record.capturedAt),
+        tables: normalizeRuntimeSchemaTables(record.tables),
+    };
+}
+function metadataRuntimeColumns(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((entry) => {
+        if (!entry || typeof entry !== 'object')
+            return [];
+        const record = entry;
+        const name = stringValue(record.name) ?? stringValue(record.column_name);
+        if (!name)
+            return [];
+        return [{
+                name,
+                type: stringValue(record.type) ?? stringValue(record.data_type),
+                description: stringValue(record.description),
+                sampleValues: metadataStringArray(record.sampleValues),
+            }];
+    });
+}
+function dedupeRuntimeColumns(columns) {
+    const byName = new Map();
+    for (const column of columns) {
+        if (!column?.name)
+            continue;
+        const key = column.name.toLowerCase();
+        const existing = byName.get(key);
+        byName.set(key, existing ? {
+            ...existing,
+            type: existing.type ?? column.type,
+            description: existing.description ?? column.description,
+            sampleValues: Array.from(new Set([...(existing.sampleValues ?? []), ...(column.sampleValues ?? [])])).slice(0, 8),
+        } : {
+            ...column,
+            sampleValues: column.sampleValues?.slice(0, 8),
+        });
+    }
+    return Array.from(byName.values());
+}
+function metadataStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === 'string' && item.trim().length > 0).map((item) => item.trim());
+}
+function metadataPayloadString(object, key) {
+    return stringValue(object.payload?.[key]);
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function normalizeRelationKey(relation) {
+    return relation.replace(/["`]/g, '').trim().toLowerCase();
+}
+function normalizeSearchText(value) {
+    return value.toLowerCase().replace(/[_-]+/g, ' ').replace(/[^a-z0-9 ]+/g, ' ').replace(/\s+/g, ' ').trim();
+}
+function isEntityQuestion(question) {
+    const lower = question.toLowerCase();
+    if (/\b(for|where|only|specific|single|individual|named|called)\b.+\b(account|accounts|customer|customers|player|players|product|products|sku|user|users|team|teams)\b/i.test(lower))
+        return true;
+    if (/\b(account|customer|player|product|sku|user|team)\s+(?:id|name|email)\b/i.test(lower))
+        return true;
+    return /[A-Z][a-z]+(?:\s+[A-Z][a-z]+){1,3}/.test(question)
+        && /\b(revenue|sales|order|orders|spend|value|churn|usage|activity|performance|performed|metric|kpi|points|goals|assists|scoring)\b/i.test(lower);
+}
+function mergeObject(a, b) {
+    if (!a)
+        return b;
+    return {
+        ...a,
+        ...b,
+        score: Math.max(a.score ?? 0, b.score ?? 0) || undefined,
+        description: b.description || a.description,
+        payload: compactObject({ ...(a.payload ?? {}), ...(b.payload ?? {}) }),
+    };
+}
+function fingerprintSnapshot(snapshot) {
+    return sha256(stableStringify({
+        projectRoot: snapshot.projectRoot,
+        manifest: sanitizeManifestForFingerprint(snapshot.manifest),
+        objects: snapshot.objects.map((object) => ({
+            ...object,
+            score: undefined,
+            snippet: undefined,
+        })),
+        edges: snapshot.edges,
+        diagnostics: snapshot.diagnostics,
+    }));
+}
+function sanitizeManifestForFingerprint(manifest) {
+    return {
+        ...manifest,
+        generatedAt: undefined,
+        dbtImport: manifest.dbtImport
+            ? { ...manifest.dbtImport, importedAt: undefined }
+            : undefined,
+    };
+}
+function sha256(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function diagnosticId(diagnostic) {
+    return sha256(stableStringify(diagnostic)).slice(0, 24);
+}
+function stableStringify(value, seen = new WeakSet()) {
+    if (value === undefined)
+        return 'null';
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (seen.has(value))
+        return '"[Circular]"';
+    seen.add(value);
+    if (Array.isArray(value)) {
+        const out = `[${value.map((item) => stableStringify(item, seen)).join(',')}]`;
+        seen.delete(value);
+        return out;
+    }
+    const record = value;
+    const out = `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(record[key], seen)}`).join(',')}}`;
+    seen.delete(value);
+    return out;
+}
+function compactObject(value) {
+    const out = {};
+    for (const [key, raw] of Object.entries(value)) {
+        if (raw === undefined || raw === null)
+            continue;
+        if (Array.isArray(raw) && raw.length === 0)
+            continue;
+        if (typeof raw === 'object' && !Array.isArray(raw) && Object.keys(raw).length === 0)
+            continue;
+        out[key] = raw;
+    }
+    return out;
+}
+function rowToObject(row) {
+    return {
+        objectKey: row.object_key,
+        objectType: row.object_type,
+        name: row.name,
+        fullName: row.full_name ?? undefined,
+        domain: row.domain ?? undefined,
+        owner: row.owner ?? undefined,
+        status: row.status ?? undefined,
+        description: row.description ?? undefined,
+        sourcePath: row.source_path ?? undefined,
+        sourceSystem: row.source_system ?? undefined,
+        payload: safeJson(row.payload_json, {}),
+        updatedAt: row.updated_at,
+    };
+}
+function rowToEdge(row) {
+    return {
+        edgeType: row.edge_type,
+        fromKey: row.from_key,
+        toKey: row.to_key,
+        confidence: row.confidence,
+        payload: safeJson(row.payload_json, {}),
+    };
+}
+function rowToQueryRun(row) {
+    return {
+        id: row.id,
+        objectKey: row.object_key ?? undefined,
+        source: row.source,
+        status: row.status,
+        rowCount: row.row_count ?? undefined,
+        durationMs: row.duration_ms ?? undefined,
+        errorCode: row.error_code ?? undefined,
+        payload: safeJson(row.payload_json, {}),
+        createdAt: row.created_at,
+    };
+}
+function safeJson(raw, fallback) {
+    if (!raw)
+        return fallback;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return fallback;
+    }
+}
+function rankMetadataObjects(args) {
+    const terms = tokenize(args.question).slice(0, 12);
+    const ranked = mergeObjects(args.rows)
+        .map((row) => {
+        const score = scoreMetadataObject(row, terms);
+        return {
+            row,
+            rank: 0,
+            score,
+            reason: selectionReason(row, score),
+            priorityTier: priorityTier(row),
+        };
+    })
+        .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 cutoff = ranked[Math.max(0, args.limit - 1)];
+    return {
+        selected: ranked.slice(0, args.limit).map((item) => item.row),
+        ranked,
+        rejected: ranked.slice(args.limit).slice(0, 24).map((item) => ({
+            objectKey: item.row.objectKey,
+            objectType: item.row.objectType,
+            name: item.row.name,
+            reason: cutoff
+                ? `Lower retrieval score than selected context window (cutoff ${cutoff.score.toFixed(1)}); ${item.reason}`
+                : item.reason,
+            score: item.score,
+            rejectedRank: item.rank,
+        })),
+    };
+}
+function scoreMetadataObject(row, terms) {
+    let score = row.score ? row.score * 10 : 0;
+    score += Math.max(0, 44 - objectPriority(row) * 2);
+    if (row.status === 'certified')
+        score += 36;
+    if (row.status === 'approved')
+        score += 24;
+    if (row.status === 'draft')
+        score -= 8;
+    if (row.objectType === 'dql_block' && row.status !== 'certified')
+        score -= 16;
+    if (row.objectType === 'semantic_metric')
+        score += 10;
+    if (row.objectType === 'dbt_model' || row.objectType === 'dbt_column')
+        score += 4;
+    score += scoreText([
+        row.objectType,
+        row.objectKey,
+        row.name,
+        row.fullName ?? '',
+        row.domain ?? '',
+        row.owner ?? '',
+        row.description ?? '',
+        JSON.stringify(row.payload ?? {}),
+    ].join(' '), terms) * 8;
+    return Number(score.toFixed(3));
+}
+function objectPriority(row) {
+    return OBJECT_PRIORITY[row.objectType] ?? 99;
+}
+function priorityTier(row) {
+    if (row.objectType === 'dql_block' && row.status === 'certified')
+        return 'certified_block';
+    if (row.objectType === 'semantic_metric')
+        return 'semantic_metric';
+    if (row.objectType === 'dql_term' || row.objectType === 'business_view')
+        return 'business_context';
+    if (row.objectType.startsWith('dbt_') || row.objectType === 'warehouse_table')
+        return 'dbt_warehouse_context';
+    if (row.objectType === 'notebook')
+        return 'notebook_evidence';
+    if (row.objectType === 'app' || row.objectType === 'dashboard')
+        return 'consumption_evidence';
+    return 'metadata';
+}
+function selectionReason(row, score) {
+    const reasons = [reasonForObject(row), `priority tier: ${priorityTier(row)}`];
+    if (row.status === 'certified')
+        reasons.push('certified status');
+    reasons.push(`score ${score.toFixed(1)}`);
+    return reasons.join('; ');
+}
+function reasonForObject(row) {
+    if (row.objectType === 'dql_block' && row.status === 'certified')
+        return 'Certified reusable answer candidate';
+    if (row.objectType === 'semantic_metric')
+        return 'Semantic metric matched the question';
+    if (row.objectType === 'dql_term' || row.objectType === 'business_view')
+        return 'DQL business context';
+    if (row.objectType.startsWith('dbt_') || row.objectType === 'warehouse_table')
+        return 'dbt or warehouse metadata supplies physical context';
+    if (row.objectType === 'app' || row.objectType === 'dashboard')
+        return 'Published consumption context';
+    return 'Relevant project metadata';
+}
+function mergeObjects(rows) {
+    const byKey = new Map();
+    for (const row of rows) {
+        const existing = byKey.get(row.objectKey);
+        byKey.set(row.objectKey, existing ? mergeObject(existing, row) : row);
+    }
+    return Array.from(byKey.values());
+}
+function deriveTrust(objects) {
+    if (objects.length === 0)
+        return 'unknown';
+    const statuses = objects.map((row) => row.status ?? '');
+    if (statuses.length > 0 && statuses.every((status) => status === 'certified'))
+        return 'certified';
+    if (statuses.some((status) => status === 'certified') && statuses.some((status) => status && status !== 'certified'))
+        return 'mixed';
+    if (statuses.some((status) => status === 'draft' || status === 'ai_generated' || status === 'analyst_review_required'))
+        return 'draft';
+    return statuses.some((status) => status === 'certified') ? 'mixed' : 'unknown';
+}
+function buildCitations(objects, edges) {
+    const citations = objects.slice(0, 24).map((row) => ({
+        objectKey: row.objectKey,
+        objectType: row.objectType,
+        name: row.name,
+        reason: row.objectType === 'dql_block' && row.status === 'certified'
+            ? 'Certified block candidate'
+            : reasonForObject(row),
+    }));
+    for (const edge of edges.slice(0, 8)) {
+        citations.push({
+            objectKey: edge.fromKey,
+            objectType: 'metadata_edge',
+            name: `${edge.fromKey} -> ${edge.toKey}`,
+            reason: `${edge.edgeType} relationship evidence`,
+        });
+    }
+    const seen = new Set();
+    return citations.filter((citation) => {
+        const key = `${citation.objectType}|${citation.objectKey}|${citation.name}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    }).slice(0, 32);
+}
+function buildEvidenceSummaries(objects, edges, queryRuns, diagnostics) {
+    const summaries = objects.slice(0, 10).map((row) => ({
+        title: row.name || row.objectKey,
+        detail: row.objectType.replace(/_/g, ' '),
+        objectKey: row.objectKey,
+        objectType: row.objectType,
+        reason: reasonForObject(row),
+    }));
+    if (edges.length > 0) {
+        summaries.push({
+            title: `${edges.length} metadata relationship${edges.length === 1 ? '' : 's'}`,
+            detail: 'Object relationships were used to connect business, semantic, and physical context.',
+            reason: 'Graph evidence',
+        });
+    }
+    if (queryRuns.length > 0) {
+        summaries.push({
+            title: 'Recent execution history',
+            detail: `Latest run status: ${queryRuns[0]?.status ?? 'unknown'}.`,
+            reason: 'Runtime evidence',
+        });
+    }
+    const warnings = diagnostics.filter((diagnostic) => diagnostic.severity === 'warning').length;
+    const errors = diagnostics.filter((diagnostic) => diagnostic.severity === 'error').length;
+    if (warnings || errors) {
+        summaries.push({
+            title: 'Metadata diagnostics',
+            detail: `${errors} error(s), ${warnings} warning(s).`,
+            reason: 'Freshness and completeness checks',
+        });
+    }
+    return summaries.slice(0, 16);
+}
+function buildWarnings(diagnostics, objects) {
+    const warnings = diagnostics
+        .filter((diagnostic) => diagnostic.severity === 'warning')
+        .map((diagnostic) => diagnostic.message)
+        .slice(0, 12);
+    if (!objects.some((object) => object.objectType === 'semantic_metric')) {
+        warnings.push('No semantic metric was selected for this context pack.');
+    }
+    return Array.from(new Set(warnings));
+}
+function buildCandidateConflicts(ranked) {
+    const conflicts = [];
+    for (const type of ['dql_block', 'semantic_metric', 'dql_term', 'business_view']) {
+        const candidates = ranked
+            .filter((item) => item.row.objectType === type && isGovernedCandidate(item.row))
+            .slice(0, 4);
+        if (candidates.length < 2)
+            continue;
+        const delta = candidates[0].score - candidates[1].score;
+        if (delta <= 12) {
+            const details = candidates.map((item) => ({
+                objectKey: item.row.objectKey,
+                objectType: item.row.objectType,
+                name: item.row.name,
+                domain: item.row.domain ?? null,
+                status: item.row.status ?? null,
+                rank: item.rank,
+                score: item.score,
+                reason: item.reason,
+            }));
+            conflicts.push({
+                objectType: type,
+                objectKeys: candidates.map((item) => item.row.objectKey),
+                reason: `Multiple high-scoring governed ${type.replace(/_/g, ' ')} candidates may need disambiguation.`,
+                prompt: `Which ${type.replace(/_/g, ' ')} should I use: ${details.map((item) => item.name).join(', ')}?`,
+                candidates: details,
+            });
+        }
+    }
+    return conflicts;
+}
+function isGovernedCandidate(row) {
+    return row.status === 'certified' || row.status === 'approved';
+}
+function tokenize(text) {
+    return Array.from(new Set(text.toLowerCase().replace(/[^a-z0-9_ ]+/g, ' ').split(/\s+/).filter((term) => term.length >= 3))).slice(0, 24);
+}
+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